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

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

对话框与窗口

开发平台：

Visual C++

XTPReportPaintManager.cpp：源码内容
  1. // XTPReportPaintManager.cpp : implementation of the CXTPReportPaintManager class.
  2. //
  3. // This file is a part of the XTREME REPORTCONTROL 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/XTPDrawHelpers.h"
  26. #include "Common/XTPImageManager.h"
  27. #include "Common/XTPVC80Helpers.h"
  28. #include "Common/XTPVC50Helpers.h"
  29. #include "Common/XTPOffice2007Image.h"
  30. #include "Common/XTPMarkupRender.h"
  32. #include "XTPReportPaintManager.h"
  33. #include "XTPReportRow.h"
  34. #include "XTPReportGroupRow.h"
  35. #include "XTPReportColumn.h"
  36. #include "XTPReportHeader.h"
  37. #include "XTPReportControl.h"
  38. #include "XTPReportInplaceControls.h"
  39. #include "XTPReportRecordItemControls.h"
  40. #include "XTPReportColumns.h"
  41. #include "XTPReportRecord.h"
  42. #include "XTPReportHyperlink.h"
  44. #ifdef _DEBUG
  45. #undef THIS_FILE
  46. static char THIS_FILE[] = __FILE__;
  47. #define new DEBUG_NEW
  48. #endif
  50. #define XTP_HLINK_SPACE_X   ((TCHAR)1)
  52. AFX_INLINE int GetTextExtentX(CDC* pDC, const CString& strString)
  53. {
  54. CString str(strString);
  55. REPLACE_S(str, XTP_HLINK_SPACE_X, _T(' '));
  57. int nExt1 = pDC->GetTextExtent(str).cx;
  58. if (pDC->IsPrinting())
  59. {
  60. int nExt2 = pDC->GetOutputTextExtent(str).cx;
  61. return max(nExt1, nExt2);
  62. }
  63. return nExt1;
  64. }
  66. AFX_INLINE int GetTextExtentX(CDC* pDC, LPTSTR pszString, int nCount)
  67. {
  68. CString str(pszString, nCount);
  69. REPLACE_S(str, XTP_HLINK_SPACE_X, _T(' '));
  71. int nExt1 = pDC->GetTextExtent(str).cx;
  72. if (pDC->IsPrinting())
  73. {
  74. int nExt2 = pDC->GetOutputTextExtent(str).cx;
  75. return max(nExt1, nExt2);
  76. }
  77. return nExt1;
  78. }
  79. /////////////////////////////////////////////////////////////////////////////
  80. // class CXTPFormulaMulDivC
  82. CXTPFormulaMulDivC::CXTPFormulaMulDivC()
  83. {
  84. m_nMultiplier = 1;
  85. m_nDivisor = 1;
  86. m_nConstant = 0;
  88. }
  90. CXTPFormulaMulDivC::~CXTPFormulaMulDivC()
  91. {
  92. }
  94. int CXTPFormulaMulDivC::Calculate(int nY) const
  95. {
  96. ASSERT((int)m_nDivisor);
  98. int nDiv = (int)m_nDivisor ? (int)m_nDivisor : (int)1;
  100. int nResult = nY * m_nMultiplier / nDiv + m_nConstant;
  102. return nResult;
  103. }
  105. void CXTPFormulaMulDivC::SetStandardValue(int nMul, int nDiv, int nC)
  106. {
  107. m_nMultiplier = nMul;
  108. m_nDivisor = nDiv;
  109. m_nConstant = nC;
  110. }
  112. void CXTPFormulaMulDivC::GetStandardValue(int& rnMul, int& rnDiv, int& rnC)
  113. {
  114. rnMul = m_nMultiplier;
  115. rnDiv = m_nDivisor;
  116. rnC = m_nConstant;
  117. }
  120. //////////////////////////////////////////////////////////////////////
  121. // CXTPReportPaintManager
  123. CXTPReportPaintManager::CXTPReportPaintManager()
  124. {
  125. m_pHeaderHeightFormula = new CXTPFormulaMulDivC;
  126. m_pHeaderHeightFormula->SetStandardValue(11, 10, 8);
  128. m_clrPreviewText.SetStandardValue(RGB(0, 0, 255));
  129. //m_clrColumnOffice2007CustomTheme.SetStandardValue(RGB(196, 221, 255));
  130. m_clrColumnOffice2007CustomTheme = COLORREF_NULL;
  131. m_nMaxPreviewLines = 3;
  132. m_szGlyph = CSize(12, 12);
  134. m_bThemedInplaceButtons = TRUE;
  136. // defaults
  137. m_nGroupGridLineHeight = 2;
  138. m_nResizingWidth = 1;
  139. m_bIsPreviewMode = FALSE;
  140. m_bShadeGroupHeadings = FALSE;
  141. m_bGroupRowTextBold = FALSE;
  142. m_bShadeSortColumn = TRUE;
  143. m_columnStyle = xtpReportColumnShaded;
  145. m_treeStructureStyle = xtpReportTreeStructureSolid;
  146. m_HeaderRowsDividerStyle = xtpReportFixedRowsDividerThin;
  147. m_FooterRowsDividerStyle = xtpReportFixedRowsDividerThin;
  149. m_verticalGridStyle = xtpReportGridNoLines;
  150. m_horizontalGridStyle = xtpReportGridSolid;
  152. m_bRevertAlignment = FALSE;
  153. m_bUseEditTextAlignment = TRUE;
  154. m_bUseColumnTextAlignment = FALSE;
  155. m_bHotTracking = TRUE;
  156. m_bInvertColumnOnClick = TRUE;
  158. XTPResourceManager()->LoadString(&m_strNoItems, XTP_IDS_REPORT_NOITEMS);
  159. XTPResourceManager()->LoadString(&m_strNoGroupBy, XTP_IDS_REPORT_NOGROUPBY);
  160. XTPResourceManager()->LoadString(&m_strNoFieldsAvailable, XTP_IDS_REPORT_NOFIELDSAVAILABLE);
  161. if (XTPResourceManager()->LoadString(&m_strSortBy, XTP_IDS_REPORT_SORTBY))
  162. {
  163. m_strSortBy += _T(" ");
  164. }
  166. m_bHideSelection = FALSE;
  168. m_rcPreviewIndent.SetRect(10, 0, 10, 2);
  170. m_nTreeIndent = 20;
  171. m_bDrawSortTriangleAlways = TRUE;
  174. // get system parameters
  175. LOGFONT lfIcon;
  176. VERIFY(::SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lfIcon), &lfIcon, 0));
  178. VERIFY(m_fontPreview.CreateFontIndirect(&lfIcon));
  180. SetCaptionFont(lfIcon);
  181. SetTextFont(lfIcon);
  183. VERIFY(m_ilGlyphs.Create(12, 12, ILC_COLOR24 | ILC_MASK, 0, 1));
  184. CBitmap bmp;
  185. VERIFY(XTPResourceManager()->LoadBitmap(&bmp, XTP_IDB_REPORT_GLYPHS));
  186. m_ilGlyphs.Add(&bmp, RGB(255, 0, 255));
  188. m_bFixedRowHeight = TRUE;
  189. m_bDrawGridForEmptySpace = FALSE;
  191. m_bFixedInplaceButtonHeight = FALSE;
  192. m_nFreezeColsDividerStyle = xtpReportFreezeColsDividerThin | xtpReportFreezeColsDividerShade | xtpReportFreezeColsDividerHeader;
  193. m_HeaderRowsDividerStyle = xtpReportFixedRowsDividerThin;
  194. m_FooterRowsDividerStyle = xtpReportFixedRowsDividerThin;
  196. m_nTreeStructureStyle = 0;
  198. RefreshMetrics();
  200. }
  202. CXTPReportPaintManager::~CXTPReportPaintManager()
  203. {
  204. CMDTARGET_RELEASE(m_pHeaderHeightFormula);
  205. }
  207. COLORREF CXTPReportPaintManager::GetControlBackColor(CXTPReportControl* /*pControl*/)
  208. {
  209. return m_clrControlBack;
  210. }
  213. void CXTPReportPaintManager::RefreshMetrics()
  214. {
  215. RefreshXtremeColors();
  217. m_clrBtnFace.SetStandardValue(GetXtremeColor(COLOR_BTNFACE));
  218. m_clrBtnText.SetStandardValue(GetXtremeColor(COLOR_BTNTEXT));
  219. m_clrControlDark.SetStandardValue(GetXtremeColor(COLOR_3DSHADOW));
  220. m_clrHighlight.SetStandardValue(GetXtremeColor(COLOR_HIGHLIGHT));
  221. m_clrHighlightText.SetStandardValue(GetXtremeColor(COLOR_HIGHLIGHTTEXT));
  222. m_clrWindowText.SetStandardValue(GetXtremeColor(COLOR_WINDOWTEXT));
  223. m_clrControlLightLight.SetStandardValue(GetXtremeColor(COLOR_3DHIGHLIGHT));
  224. m_clrControlBack.SetStandardValue(GetXtremeColor(COLOR_WINDOW));
  226. m_clrIndentControl.SetStandardValue(m_clrBtnFace);
  227. m_clrCaptionText.SetStandardValue(m_clrBtnText);
  228. m_clrGridLine.SetStandardValue(m_clrControlDark);
  229. m_clrHeaderControl.SetStandardValue(m_clrBtnFace);
  230. m_clrGroupShadeBorder.SetStandardValue(m_clrControlDark);
  231. m_clrGroupShadeBack.SetStandardValue(m_clrBtnFace);
  232. m_clrGroupShadeText.SetStandardValue(m_clrBtnText);
  233. m_clrGroupRowText.SetStandardValue(m_clrControlDark);
  234. m_clrGroupBoxBack.SetStandardValue(m_clrControlDark);
  236. m_clrSelectedRow.SetStandardValue(m_clrBtnFace);
  237. m_clrSelectedRowText.SetStandardValue(m_clrBtnText);
  239. m_clrHyper.SetStandardValue(RGB(0, 0, 0xFF));
  240. m_clrItemShade.SetStandardValue(RGB(245, 245, 245));
  241. m_clrHotDivider.SetStandardValue(RGB(0xFF, 0, 0));
  243. m_crlNoGroupByText.SetStandardValue(m_clrControlDark);
  245. m_clrGradientColumnSeparator.SetStandardValue(m_clrControlDark);
  247. m_themeWrapper.OpenThemeData(0, L"HEADER");
  248. m_themeButton.OpenThemeData(0, L"BUTTON");
  249. m_themeCombo.OpenThemeData(0, L"COMBOBOX");
  250. m_themeSpin.OpenThemeData(0, L"SPIN");
  253. if (!XTPColorManager()->IsLunaColorsDisabled())
  254. {
  256. XTPCurrentSystemTheme systemTheme = XTPColorManager()->GetCurrentSystemTheme();
  258. switch (systemTheme)
  259. {
  260. case xtpSystemThemeBlue:
  261. case xtpSystemThemeRoyale:
  262. case xtpSystemThemeAero:
  263. m_clrGroupShadeBorder.SetStandardValue(RGB(123, 164, 224));
  264. m_clrIndentControl.SetStandardValue(RGB(253, 238, 201));
  265. m_clrGroupShadeBack.SetStandardValue(RGB(190, 218, 251));
  266. m_clrGroupRowText.SetStandardValue(RGB(55, 104, 185));
  267. m_clrGridLine.SetStandardValue(RGB(234, 233, 225));
  268. break;
  270. case xtpSystemThemeOlive:
  271. m_clrGroupShadeBorder.SetStandardValue(RGB(181, 196, 143));
  272. m_clrIndentControl.SetStandardValue(RGB(253, 238, 201));
  273. m_clrGroupShadeBack.SetStandardValue(RGB(175, 186, 145));
  274. m_clrGroupRowText.SetStandardValue(RGB(115, 137, 84));
  275. m_clrGridLine.SetStandardValue(RGB(234, 233, 225));
  276. break;
  278. case xtpSystemThemeSilver:
  279. m_clrGroupShadeBorder.SetStandardValue(RGB(165, 164, 189));
  280. m_clrIndentControl.SetStandardValue(RGB(253, 238, 201));
  281. m_clrGroupShadeBack.SetStandardValue(RGB(229, 229, 235));
  282. m_clrGroupRowText.SetStandardValue(RGB(112, 111, 145));
  283. m_clrGridLine.SetStandardValue(RGB(229, 229, 235));
  284. break;
  285. }
  286. }
  288. if (m_columnStyle == xtpReportColumnOffice2007)
  289. {
  290. if (m_clrColumnOffice2007CustomTheme != COLORREF_NULL)
  291. {
  292. COLORREF clrHsl = XTPDrawHelpers()->RGBtoHSL(m_clrColumnOffice2007CustomTheme);
  293. BYTE Hue = GetRValue(clrHsl);
  294. BYTE Sat = GetGValue(clrHsl);
  296. m_grcGradientColumnPushed.SetStandardValue(XTPDrawHelpers()->HSLtoRGB(RGB(Hue, Sat, 212)), XTPDrawHelpers()->HSLtoRGB(RGB(Hue, Sat, 239)));
  297. m_grcGradientColumn.SetStandardValue(XTPDrawHelpers()->HSLtoRGB(RGB(Hue, Sat, 239)), XTPDrawHelpers()->HSLtoRGB(RGB(Hue, Sat, 212)));
  298. m_clrGradientColumnShadow.SetStandardValue(XTPDrawHelpers()->HSLtoRGB(RGB(Hue, (BYTE)(Sat * 0.525f), 145)));
  299. m_clrGradientColumnSeparator.SetStandardValue(XTPDrawHelpers()->HSLtoRGB(RGB(Hue, Sat, 192)));
  300. m_clrGroupBoxBack.SetStandardValue(XTPDrawHelpers()->HSLtoRGB(RGB(Hue, Sat, 227)));
  301. m_crlNoGroupByText.SetStandardValue(XTPDrawHelpers()->HSLtoRGB(RGB(Hue, (BYTE)(Sat * 0.75f), 79)));
  302. m_clrGroupShadeBack.SetStandardValue(XTPDrawHelpers()->HSLtoRGB(RGB(Hue, (BYTE)(Sat * 0.88f), 208)));
  303. }
  304. else
  305. {
  306. if (XTPOffice2007Images()->IsValid())
  307. {
  308. m_grcGradientColumn.SetStandardValue(XTPOffice2007Images()->GetImageColor(_T("ReportControl"), _T("NormalColumnLight")),
  309. XTPOffice2007Images()->GetImageColor(_T("ReportControl"), _T("NormalColumnDark")));
  310. m_grcGradientColumnPushed.SetStandardValue(XTPOffice2007Images()->GetImageColor(_T("ReportControl"), _T("PressedColumnLight")),
  311. XTPOffice2007Images()->GetImageColor(_T("ReportControl"), _T("PressedColumnDark")));
  313. m_clrGradientColumnShadow.SetStandardValue(XTPOffice2007Images()->GetImageColor(_T("ReportControl"), _T("ColumnShadow")));
  314. m_clrGradientColumnSeparator.SetStandardValue(XTPOffice2007Images()->GetImageColor(_T("ReportControl"), _T("ColumnSeparator")));
  315. m_clrGroupBoxBack.SetStandardValue(XTPOffice2007Images()->GetImageColor(_T("ReportControl"), _T("GroupBoxBackground")));
  316. m_crlNoGroupByText.SetStandardValue(XTPOffice2007Images()->GetImageColor(_T("ReportControl"), _T("GroupBoxTextColor")));
  317. m_clrGroupShadeBack.SetStandardValue(XTPOffice2007Images()->GetImageColor(_T("ReportControl"), _T("GroupShadeBackground")));
  318. m_clrGroupShadeBorder.SetStandardValue(XTPOffice2007Images()->GetImageColor(_T("ReportControl"), _T("GroupShadeBorder")));
  319. m_clrIndentControl.SetStandardValue(XTPOffice2007Images()->GetImageColor(_T("ReportControl"), _T("GroupShadeIndent")));
  320. m_clrHighlight.SetStandardValue(XTPOffice2007Images()->GetImageColor(_T("ReportControl"), _T("SelectionBackground")));
  321. m_clrHighlightText.SetStandardValue(0);
  322. }
  323. else
  324. {
  325. m_grcGradientColumnPushed.SetStandardValue(RGB(196, 221, 255), RGB(252, 253, 255));
  326. m_grcGradientColumn.SetStandardValue(RGB(252, 253,255), RGB(196, 221, 255));
  327. m_clrGradientColumnShadow.SetStandardValue(RGB(101, 147, 207));
  328. m_clrGradientColumnSeparator.SetStandardValue(RGB(154, 198, 255));
  329. m_clrGroupBoxBack.SetStandardValue(RGB(227, 239, 255));
  330. m_crlNoGroupByText.SetStandardValue(RGB(50, 75, 44));
  331. m_clrGroupShadeBack.SetStandardValue(RGB(190, 218, 251));
  332. m_clrGroupShadeBorder.SetStandardValue(RGB(111, 157, 217));
  333. m_clrIndentControl.SetStandardValue(RGB(253, 238, 201));
  334. }
  336. }
  337. m_grcGradientColumnHot.SetStandardValue(m_grcGradientColumn);
  338. m_clrGroupRowText.SetStandardValue(m_crlNoGroupByText);
  339. m_clrGroupShadeBorder.SetStandardValue(m_clrGradientColumnSeparator);
  340. }
  341. else if (m_columnStyle == xtpReportColumnOffice2003)
  342. {
  343. m_grcGradientColumn.SetStandardValue(XTPColorManager()->LightColor(GetXtremeColor(COLOR_3DFACE), GetXtremeColor(COLOR_WINDOW), 0xcd), GetXtremeColor(COLOR_3DFACE));
  344. m_grcGradientColumnHot.SetStandardValue(GetXtremeColor(XPCOLOR_HIGHLIGHT));
  345. m_grcGradientColumnPushed.SetStandardValue(GetXtremeColor(XPCOLOR_HIGHLIGHT_PUSHED));
  346. m_clrGradientColumnShadow.SetStandardValue(GetXtremeColor(XPCOLOR_TOOLBAR_FACE));
  347. m_clrGradientColumnSeparator.SetStandardValue(GetXtremeColor(XPCOLOR_SEPARATOR));
  349. switch (XTPColorManager()->GetCurrentSystemTheme())
  350. {
  351. case xtpSystemThemeBlue:
  352. case xtpSystemThemeRoyale:
  353. case xtpSystemThemeAero:
  354. m_grcGradientColumn.SetStandardValue(RGB(221, 236, 254), RGB(129, 169, 226));
  355. m_clrGradientColumnShadow.SetStandardValue(RGB(59, 97, 156));
  356. m_clrGradientColumnSeparator.SetStandardValue(RGB(106, 140, 203));
  357. m_grcGradientColumnPushed.SetStandardValue(RGB(254, 142, 75), RGB(255, 207, 139));
  358. m_grcGradientColumnHot.SetStandardValue(RGB(255, 242, 200), RGB(255, 212, 151));
  359. break;
  361. case xtpSystemThemeOlive:
  362. m_grcGradientColumn.SetStandardValue(RGB(244, 247, 222), RGB(183, 198, 145));
  363. m_clrGradientColumnShadow.SetStandardValue(RGB(96, 128, 88));
  364. m_clrGradientColumnSeparator.SetStandardValue(RGB(96, 128, 88));
  365. m_grcGradientColumnPushed.SetStandardValue(RGB(254, 142, 75), RGB(255, 207, 139));
  366. m_grcGradientColumnHot.SetStandardValue(RGB(255, 242, 200), RGB(255, 212, 151));
  367. break;
  369. case xtpSystemThemeSilver:
  370. m_grcGradientColumn.SetStandardValue(RGB(243, 244, 250), RGB(153, 151, 181));
  371. m_clrGradientColumnShadow.SetStandardValue(RGB(124, 124, 148));
  372. m_clrGradientColumnSeparator.SetStandardValue(RGB(110, 109, 143));
  373. m_grcGradientColumnPushed.SetStandardValue(RGB(254, 142, 75), RGB(255, 207, 139));
  374. m_grcGradientColumnHot.SetStandardValue(RGB(255, 242, 200), RGB(255, 212, 151));
  375. break;
  376. }
  377. }
  379. m_brushVeriticalGrid.DeleteObject();
  380. m_brushHorizontalGrid.DeleteObject();
  381. m_brushTreeStructure.DeleteObject();
  383. m_clrFreezeColsDivider.SetStandardValue(RGB(0, 0, 222));
  384. m_clrHeaderRowsDivider.SetStandardValue(COLOR_BTNFACE);
  385. m_clrFooterRowsDivider.SetStandardValue(COLOR_BTNFACE);
  387. LOGFONT lf;
  388. m_fontCaption.GetLogFont(&lf);
  389. SetCaptionFont(lf);
  390. }
  393. void CXTPReportPaintManager::FillRow(CDC* /*pDC*/, CXTPReportRow* /*pRow*/, CRect /*rcRow*/)
  394. {
  395. }
  397. void CXTPReportPaintManager::DrawGridPat(CDC* pDC, CBrush* pBrush, CRect rc, CONST VOID*pPattern, COLORREF clr)
  398. {
  399. if (pBrush->GetSafeHandle() == 0)
  400. {
  401. CBitmap bmp;
  402. bmp.CreateBitmap(8, 8, 1, 1, pPattern);
  403. pBrush->CreatePatternBrush(&bmp);
  404. }
  405. CBrush* pOldBrush = (CBrush*)pDC->SelectObject(pBrush);
  407. pDC->SetTextColor(m_clrControlBack);
  408. pDC->SetBkColor(clr);
  409. PatBlt(pDC->GetSafeHdc(), rc.left, rc.top, rc.Width(), rc.Height(), PATCOPY);
  411. pDC->SelectObject(pOldBrush);
  412. }
  414. void CXTPReportPaintManager::SetGridStyle(BOOL bVertical, XTPReportGridStyle gridStyle)
  415. {
  416. if (bVertical)
  417. {
  418. m_verticalGridStyle = gridStyle;
  419. m_brushVeriticalGrid.DeleteObject();
  420. }
  421. else
  422. {
  423. m_horizontalGridStyle = gridStyle;
  424. m_brushHorizontalGrid.DeleteObject();
  425. }
  426. }
  428. void CXTPReportPaintManager::DrawGrid(CDC* pDC, BOOL bVertical, CRect rc)
  429. {
  430. if (!bVertical)
  431. {
  432. switch (m_horizontalGridStyle)
  433. {
  434. case xtpReportGridSolid:
  435. DrawHorizontalLine(pDC, rc.left, rc.bottom, rc.Width(), m_clrGridLine);
  436. break;
  437. case xtpReportGridSmallDots:
  438. {
  439. const unsigned short _cb[] = {0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55};
  440. DrawGridPat(pDC, &m_brushHorizontalGrid, CRect(rc.left, rc.bottom, rc.right, rc.bottom + 1), _cb, m_clrGridLine);
  441. break;
  442. }
  443. case xtpReportGridLargeDots:
  444. {
  445. const unsigned short _cb[] = {0xcc, 0x33, 0xcc, 0x33, 0xcc, 0x33, 0xcc, 0x33};
  446. DrawGridPat(pDC, &m_brushHorizontalGrid, CRect(rc.left, rc.bottom, rc.right, rc.bottom + 1), _cb, m_clrGridLine);
  447. break;
  448. }
  449. case xtpReportGridDashes:
  450. {
  451. const unsigned short _cb[] = {0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0};
  452. DrawGridPat(pDC, &m_brushHorizontalGrid, CRect(rc.left, rc.bottom, rc.right, rc.bottom + 1), _cb, m_clrGridLine);
  453. break;
  455. }
  457. }
  458. }
  459. else
  460. {
  461. int nPos = rc.right - 1;
  462. switch (m_verticalGridStyle)
  463. {
  464. case xtpReportGridSolid:
  465. DrawVerticalLine(pDC, nPos, rc.top, rc.Height(), m_clrGridLine);
  466. break;
  467. case xtpReportGridSmallDots:
  468. {
  469. const unsigned short _cb[] = {0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55};
  470. DrawGridPat(pDC, &m_brushVeriticalGrid, CRect(nPos, rc.top, nPos + 1, rc.bottom), _cb, m_clrGridLine);
  471. break;
  472. }
  473. case xtpReportGridLargeDots:
  474. {
  475. const unsigned short _cb[] = {0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0x33, 0x33};
  476. DrawGridPat(pDC, &m_brushVeriticalGrid, CRect(nPos, rc.top, nPos + 1, rc.bottom), _cb, m_clrGridLine);
  477. break;
  478. }
  479. case xtpReportGridDashes:
  480. {
  481. const unsigned short _cb[] = {0xf0, 0xf0, 0xf0, 0xf0, 0xf, 0xf, 0xf, 0xf};
  482. DrawGridPat(pDC, &m_brushVeriticalGrid, CRect(nPos, rc.top, nPos + 1, rc.bottom), _cb, m_clrGridLine);
  483. break;
  485. }
  487. }
  489. }
  490. }
  492. void CXTPReportPaintManager::DrawFreezeColsDivider(CDC* pDC, const CRect& rc, CXTPReportControl* pControl, CXTPReportRow* pRow)
  493. {
  494. if (pControl->GetReportHeader()->IsAutoColumnSizing() ||
  495. (m_nFreezeColsDividerStyle == 0))
  496. return;
  498. CRect rcDvX = rc;
  500. if ((m_nFreezeColsDividerStyle & xtpReportFreezeColsDividerShade) &&
  501. pControl->GetScrollPos(SB_HORZ) && !pControl->IsFullColumnScrolling())
  502. {
  503. rcDvX.left = rcDvX.right-1;
  504. rcDvX.right = rcDvX.left + 4;
  505. XTPDrawHelpers()->GradientFill(pDC, rcDvX, m_clrFreezeColsDivider,
  506.    RGB(255, 255, 255), TRUE);
  507. }
  508. else if (m_nFreezeColsDividerStyle & (xtpReportFreezeColsDividerThin | xtpReportFreezeColsDividerBold))
  509. {
  510. int nWidth = (m_nFreezeColsDividerStyle & xtpReportFreezeColsDividerBold) ? 2 : 1;
  511. rcDvX.left = rcDvX.right-nWidth;
  512. pDC->FillSolidRect(&rcDvX, m_clrFreezeColsDivider);
  513. }
  515. int nMask = (xtpReportFreezeColsDividerThin | xtpReportFreezeColsDividerBold | xtpReportFreezeColsDividerShade);
  516. if (pRow && pRow->IsSelected() && (m_nFreezeColsDividerStyle & nMask))
  517. {
  518. pDC->InvertRect(&rcDvX);
  519. }
  520. }
  522. void CXTPReportPaintManager::FillGroupRowMetrics(CXTPReportGroupRow* pRow,
  523. XTP_REPORTRECORDITEM_METRICS* pMetrics, BOOL bPrinting)
  524. {
  525. ASSERT(pRow && pMetrics);
  526. if (!pRow || !pRow->GetControl() || !pMetrics)
  527. {
  528. return;
  529. }
  531. BOOL bControlFocused = pRow->GetControl()->HasFocus();
  533. pMetrics->clrForeground = m_clrGroupRowText;
  534. pMetrics->clrBackground = XTP_REPORT_COLOR_DEFAULT;
  536. if (pRow->IsSelected() && bControlFocused && !bPrinting)
  537. {
  538. pMetrics->clrForeground = m_clrHighlightText;
  539. pMetrics->clrBackground = m_clrHighlight;
  540. }
  541. else if (m_bShadeGroupHeadings)
  542. {
  543. pMetrics->clrForeground = m_clrGroupShadeText;
  544. pMetrics->clrBackground = m_clrGroupShadeBack;
  545. }
  547. //--------------------------------
  548. pMetrics->pFont = m_bGroupRowTextBold ? &m_fontBoldText : &m_fontText;
  549. }
  551. void CXTPReportPaintManager::DrawGroupRow(CDC* pDC, CXTPReportGroupRow* pRow, CRect rcRow,
  552. XTP_REPORTRECORDITEM_METRICS* pMetrics)
  553. {
  554. BOOL bControlFocused = pRow->GetControl()->HasFocus();
  556. if (pMetrics->clrBackground != XTP_REPORT_COLOR_DEFAULT)
  557. {
  558. pDC->FillSolidRect(rcRow, pMetrics->clrBackground);
  559. }
  560. pDC->SetTextColor(pMetrics->clrForeground);
  562. //--------------------------------
  563. ASSERT(pMetrics->pFont);
  564. CXTPFontDC font(pDC, pMetrics->pFont);
  566. int nRowLevel = pRow->GetTreeDepth();
  567. int nIndent = pRow->GetControl()->GetIndent(nRowLevel + 1);
  569. pDC->FillSolidRect(rcRow.left, rcRow.bottom - m_nGroupGridLineHeight, rcRow.Width(), m_nGroupGridLineHeight, m_clrGroupShadeBorder);
  571. if (pRow->IsFocused() && bControlFocused && !pDC->IsPrinting() && pRow->GetControl()->IsRowFocusVisible())
  572. {
  573. DrawFocusedRow(pDC, CRect(rcRow.left + nIndent, rcRow.top, rcRow.right, rcRow.bottom - 1));
  574. }
  576. if (nIndent > 0)
  577. {
  578. FillIndent(pDC, CRect(rcRow.left, rcRow.top, rcRow.left + nIndent, rcRow.bottom));
  579. }
  580. rcRow.left += nIndent;
  582. //-----------------------------------------------------------------------
  583. int nBitmapOffset = 0;
  584. int nTextOffset = 0;
  585. CSize szIcon(0, 0);
  587. int nGroupRowIconAlignment = pMetrics->nGroupRowIconAlignment;
  589. // check and set defaults if need
  590. if ((nGroupRowIconAlignment & xtpGroupRowIconHmask) == 0)
  591. {
  592. nGroupRowIconAlignment |= xtpGroupRowIconLeft;
  593. }
  594. if ((nGroupRowIconAlignment & xtpGroupRowIconVmask) == 0)
  595. {
  596. nGroupRowIconAlignment |= xtpGroupRowIconVCenter;
  597. }
  599. if (pMetrics->nGroupRowIcon != XTP_REPORT_NOICON)
  600. {
  601. CXTPImageManagerIcon* pIcon = pRow->GetControl()->GetImageManager()->
  602. GetImage(pMetrics->nGroupRowIcon, 0);
  603. if (pIcon)
  604. {
  605. szIcon = CSize(pIcon->GetWidth(), pIcon->GetHeight());
  606. }
  608. if (nGroupRowIconAlignment & xtpGroupRowIconLeft)
  609. {
  610. nBitmapOffset = szIcon.cx + 5;
  611. }
  612. if (nGroupRowIconAlignment & xtpGroupRowIconBeforeText)
  613. {
  614. nTextOffset = szIcon.cx + 5 + 5;
  615. }
  616. }
  618. //-----------------------------------------------------------------------
  619. CRect rcBitmap(rcRow);
  620. rcBitmap.top = rcBitmap.bottom - m_nRowHeight - 12;
  621. rcBitmap.top = rcBitmap.CenterPoint().y - m_szGlyph.cy / 2;
  622. rcBitmap.left += nBitmapOffset;
  624. int nBitmapWidth = DrawCollapsedBitmap(pDC, pRow, rcBitmap).cx;
  626. if (!pDC->IsPrinting())
  627. pRow->SetCollapseRect(rcBitmap);
  629. //-----------------------------------------------------------------------
  630. CRect rcText(rcBitmap.left + nBitmapWidth + 5, rcRow.top, rcRow.right, rcRow.bottom);
  631. rcText.top = rcText.bottom - m_nRowHeight - 6;
  632. rcText.left += nTextOffset;
  634. int nRightMask = (xtpGroupRowIconAfterText | xtpGroupRowIconRight);
  635. if (pMetrics->nGroupRowIcon != XTP_REPORT_NOICON &&
  636. (nGroupRowIconAlignment & nRightMask))
  637. {
  638. rcText.right -= szIcon.cx;
  639. }
  641. UINT nFlags = DT_SINGLELINE | DT_END_ELLIPSIS | DT_VCENTER | DT_NOPREFIX;
  642. pDC->DrawText(pMetrics->strText, rcText, nFlags);
  643. int nTextWidth = pDC->GetTextExtent(pMetrics->strText).cx;
  645. //-----------------------------------------------------------------------
  646. if (pMetrics->nGroupRowIcon != XTP_REPORT_NOICON)
  647. {
  648. CRect rcIcon(rcRow);
  650. if (nGroupRowIconAlignment & xtpGroupRowIconBeforeText)
  651. {
  652. rcIcon.left = rcBitmap.left + nBitmapWidth + 5;
  653. }
  654. else if (nGroupRowIconAlignment & xtpGroupRowIconAfterText)
  655. {
  656. rcIcon.left = rcText.left + nTextWidth + 5;
  657. rcIcon.left = min(rcIcon.left, rcRow.right - szIcon.cx - 1);
  658. }
  659. else if (nGroupRowIconAlignment & xtpGroupRowIconRight)
  660. {
  661. rcIcon.left = rcRow.right - szIcon.cx - 1;
  662. }
  663. else
  664. {
  665. // xtpGroupRowIconLeft
  666. }
  668. // ***
  669. if (nGroupRowIconAlignment & xtpGroupRowIconVTop)
  670. {
  671. rcIcon.bottom = rcIcon.top + szIcon.cy + 1;
  672. }
  673. else if (nGroupRowIconAlignment & xtpGroupRowIconVCenterToText)
  674. {
  675. rcIcon.top = rcText.CenterPoint().y - szIcon.cy / 2;
  676. rcIcon.bottom = rcIcon.top + szIcon.cy + 1;
  677. }
  678. else if (nGroupRowIconAlignment & xtpGroupRowIconVBottom)
  679. {
  680. rcIcon.top = rcIcon.bottom - szIcon.cy - 1;
  681. }
  682. else
  683. {
  684. // xtpGroupRowIconVCenter
  685. }
  687. //-------------------------------------------------------------------
  688. COLORREF clrBk = pMetrics->clrBackground != XTP_REPORT_COLOR_DEFAULT ?
  689. pMetrics->clrBackground : RGB(255, 255, 255);
  691. COLORREF clrBkPrev = pDC->SetBkColor(clrBk);
  693. DrawBitmap(pDC, pRow->GetControl(), rcIcon, pMetrics->nGroupRowIcon);
  695. pDC->SetBkColor(clrBkPrev);
  696. }
  697. }
  699. CSize CXTPReportPaintManager::DrawCollapsedBitmap(CDC* pDC, const CXTPReportRow* pRow, CRect& rcBitmap)
  700. {
  701. rcBitmap.left += 2;
  703. CSize sizeGlyph = DrawGlyph(pDC, rcBitmap, pRow->IsExpanded() ? 0 : 1);
  705. if (sizeGlyph.cx != 0 && pDC)
  706. {
  707. rcBitmap.right = rcBitmap.left + sizeGlyph.cx;
  708. }
  709. return CSize(2 + sizeGlyph.cx, 2 + sizeGlyph.cy);
  710. }
  712. void CXTPReportPaintManager::FillIndent(CDC* pDC, CRect rcRow)
  713. {
  714. pDC->FillSolidRect(&rcRow, m_clrIndentControl);
  715. }
  717. void CXTPReportPaintManager::FillItemShade(CDC* pDC, CRect rcItem)
  718. {
  719. // fill item background shade (for example when sorted by this column)
  720. if (!m_bShadeSortColumn)
  721. return;
  723. if (pDC)
  724. {
  725. pDC->FillSolidRect(rcItem, m_clrItemShade);
  726. }
  727. }
  729. void CXTPReportPaintManager::FillHeaderControl(CDC* pDC, CRect rcHeader)
  730. {
  731. pDC->FillSolidRect(rcHeader, m_clrHeaderControl);
  732. }
  734. void CXTPReportPaintManager::DrawNoGroupByText(CDC* pDC, CRect rcItem)
  735. {
  736. int nWidth = max(55, pDC->GetTextExtent(m_strNoGroupBy).cx + 8);
  737. rcItem.right = rcItem.left + nWidth;
  739. pDC->SetTextColor(m_crlNoGroupByText);
  741. if (m_columnStyle != xtpReportColumnOffice2007)
  742. FillHeaderControl(pDC, rcItem);
  744. pDC->DrawText(m_strNoGroupBy, rcItem, DT_END_ELLIPSIS | DT_CENTER | DT_NOPREFIX);
  746. }
  748. void CXTPReportPaintManager::FillFooter(CDC* pDC, CRect rcFooter)
  749. {
  750. if (m_columnStyle == xtpReportColumnOffice2007)
  751. {
  752. XTPDrawHelpers()->GradientFill(pDC, rcFooter,
  753. m_grcGradientColumn.clrDark, m_grcGradientColumn.clrLight, FALSE);
  755. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.top, rcFooter.Width(), m_clrGroupBoxBack);
  756. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.top + 1, rcFooter.Width(), m_clrGradientColumnShadow);
  757. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.top + 2, rcFooter.Width(), MixColor(m_grcGradientColumn.clrDark, m_clrGradientColumnShadow, 0.25));
  758. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.top + 3, rcFooter.Width(), MixColor(m_grcGradientColumn.clrDark, m_clrGradientColumnShadow, 0.1));
  760. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.bottom - 1, rcFooter.Width(), m_clrGradientColumnShadow);
  761. }
  762. else if (m_columnStyle == xtpReportColumnOffice2003)
  763. {
  764. XTPDrawHelpers()->GradientFill(pDC, rcFooter,
  765. m_grcGradientColumn.clrDark, m_grcGradientColumn.clrLight, FALSE);
  767. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.top, rcFooter.Width(), m_clrControlBack);
  768. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.top + 1, rcFooter.Width(), m_clrGradientColumnShadow);
  769. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.top + 2, rcFooter.Width(), MixColor(m_grcGradientColumn.clrDark, m_clrGradientColumnShadow, 0.25));
  770. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.top + 3, rcFooter.Width(), MixColor(m_grcGradientColumn.clrDark, m_clrGradientColumnShadow, 0.1));
  772. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.bottom - 1, rcFooter.Width(), m_clrGradientColumnShadow);
  773. }
  774. else
  775. {
  776. pDC->FillSolidRect(rcFooter, m_clrHeaderControl);
  778. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.top, rcFooter.Width(), m_clrControlBack);
  779. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.top + 1, rcFooter.Width(), m_clrControlDark);
  780. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.top + 2, rcFooter.Width(), MixColor(m_clrHeaderControl, m_clrControlDark, 0.6));
  781. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.top + 3, rcFooter.Width(), MixColor(m_clrHeaderControl, m_clrControlDark, 0.25));
  783. DrawHorizontalLine(pDC, rcFooter.left, rcFooter.bottom - 1, rcFooter.Width(), m_clrControlDark);
  784. }
  785. }
  787. void CXTPReportPaintManager::DrawHorizontalLine(CDC* pDC, int x, int y, int cx, COLORREF clr)
  788. {
  789. pDC->FillSolidRect(x, y, cx, 1, clr);
  790. }
  792. void CXTPReportPaintManager::DrawVerticalLine(CDC* pDC, int x, int y, int cy, COLORREF clr)
  793. {
  794. pDC->FillSolidRect(x, y, 1, cy, clr);
  795. }
  797. void CXTPReportPaintManager::DrawTriangle(CDC* pDC, CRect rcTriangle, BOOL bToDown)
  798. {
  799. CRect rcTRect;
  801. if (rcTriangle.Width() > 15)
  802. {
  803. CPoint pt(rcTriangle.left + 10, rcTriangle.CenterPoint().y);
  805. if (m_columnStyle == xtpReportColumnOffice2007 || m_columnStyle == xtpReportColumnExplorer)
  806. {
  807. if (bToDown)
  808. {
  809. CXTPDrawHelpers::Triangle(pDC, CPoint(pt.x - 4, pt.y - 2),
  810. CPoint(pt.x, pt.y + 2), CPoint(pt.x + 4, pt.y  - 2), m_clrGradientColumnSeparator);
  811. }
  812. else
  813. {
  814. CXTPDrawHelpers::Triangle(pDC, CPoint(pt.x - 4, pt.y + 2),
  815. CPoint(pt.x, pt.y - 2), CPoint(pt.x + 4, pt.y  + 2), m_clrGradientColumnSeparator);
  816. }
  817. return;
  818. }
  820. // Set up pens to use for drawing the triangle
  821. CPen penLight(PS_SOLID, 1, m_clrControlLightLight);
  822. CPen penShadow(PS_SOLID, 1, m_clrControlDark);
  824. if (bToDown)
  825. {
  826. Line(pDC, pt.x, pt.y - 3 + 6, 3, -6, &penLight);
  827. Line(pDC, pt.x, pt.y - 2 + 6, 3, -6, &penLight);
  828. Line(pDC, pt.x - 4, pt.y - 2, 3, +6, &penShadow);
  829. Line(pDC, pt.x - 1, pt.y - 2 + 6, -4, -7, &penShadow);
  830. Line(pDC, pt.x - 4, pt.y - 2, 8, 0, &penShadow);
  831. }
  832. else
  833. {
  834. Line(pDC, pt.x, pt.y - 3, 3, 6, &penLight);
  835. Line(pDC, pt.x, pt.y - 2, 3, 6, &penLight);
  836. Line(pDC, pt.x - 3, pt.y + 3, 6, 0, &penLight);
  837. Line(pDC, pt.x - 1, pt.y - 3, -3, 6, &penShadow);
  838. Line(pDC, pt.x - 2, pt.y - 2, -3, 6, &penShadow);
  839. }
  840. }
  841. }
  843. void CXTPReportPaintManager::DrawItemBitmap(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, CRect& rcItem, int nImage)
  844. {
  845. ASSERT(pDrawArgs->pControl);
  846. if (!pDrawArgs->pControl)
  847. return;
  849. POINT ptIcon;
  851. CXTPImageManagerIcon* pIcon = pDrawArgs->pControl->GetImageManager()->GetImage(nImage, 0);
  853. if (!pIcon)
  854. return;
  856. CSize szImage(pIcon->GetWidth(), pIcon->GetHeight());
  857. CSize szColumn(rcItem.Size());
  859. int nIconAlign = pDrawArgs->nTextAlign & xtpColumnIconMask;
  861. if (szImage.cx < szColumn.cx && szImage.cy < szColumn.cy && pDrawArgs->pDC)
  862. {
  863. // calculate image position
  864. if (nIconAlign & xtpColumnIconRight)
  865. {
  866. ptIcon.x = rcItem.right - szImage.cx - 1;
  867. rcItem.right -= (1 + szImage.cx); // shift text box to the left
  868. }
  869. else if (nIconAlign & xtpColumnIconCenter)
  870. {
  871. ptIcon.x = rcItem.left + szColumn.cx / 2 - szImage.cx / 2 - 1;
  872. }
  873. else //xtpColumnIconLeft : by default
  874. {
  875. ptIcon.x = rcItem.left + 1;
  876. rcItem.left += 1 + szImage.cx; // shift text box to the right
  877. }
  879. // vertically align
  880. if (nIconAlign & xtpColumnIconTop)
  881. {
  882. ptIcon.y = rcItem.top;
  883. }
  884. else if (nIconAlign & xtpColumnIconBottom)
  885. {
  887. ptIcon.y = rcItem.bottom - szImage.cy - 1;
  888. }
  889. else // xtpColumnIconVCenter - by default
  890. {
  891. ptIcon.y = rcItem.top + (szColumn.cy - szImage.cy) /2;
  892. }
  894. // draw image
  895. if (pDrawArgs->pDC->IsPrinting())
  896. {
  897. CBitmap bmp;
  898. bmp.CreateCompatibleBitmap(pDrawArgs->pDC, szImage.cx, szImage.cy);
  899. CXTPCompatibleDC dcMem(NULL, &bmp);
  900. dcMem.FillSolidRect(0, 0, szImage.cx, szImage.cy, pDrawArgs->pDC->GetBkColor());
  902. pIcon->Draw(&dcMem, CPoint(0, 0), pIcon->GetIcon());
  903. pDrawArgs->pDC->BitBlt(ptIcon.x, ptIcon.y, szImage.cx, szImage.cy, &dcMem, 0, 0, SRCCOPY);
  904. }
  905. else
  906. {
  907. pIcon->Draw(pDrawArgs->pDC, ptIcon, pIcon->GetIcon());
  908. }
  909. }
  910. }
  912. int CXTPReportPaintManager::DrawColumnIcon(CDC* pDC, CXTPReportColumn* pColumn,
  913.    CRect rcColumn, CRect rcIcon, int iIcon)
  914. {
  915. if (!pColumn || !pColumn->GetControl())
  916. {
  917. ASSERT(FALSE);
  918. return 0;
  919. }
  921. POINT ptIcon;
  923. CXTPImageManagerIcon* pIcon = pColumn->GetControl()->GetImageManager()->GetImage(iIcon, 0);
  925. if (!pIcon)
  926. return 0;
  928. CSize szImage(pIcon->GetWidth(), pIcon->GetHeight());
  929. CSize szColumn(rcIcon.Size());
  931. if (szImage.cx < szColumn.cx && szImage.cy < szColumn.cy && pDC)
  932. {
  933. ptIcon.x = rcIcon.left + 1;
  934. ptIcon.y = rcIcon.top + (szColumn.cy - szImage.cy) /2;
  936. if (pDC->IsPrinting())
  937. {
  938. CPoint ptIconOffset(ptIcon.x - rcColumn.left, ptIcon.y - rcColumn.top);
  939. CRect rcColumn2(0, 0, rcColumn.Width(), rcColumn.Height());
  941. CBitmap bmp;
  942. bmp.CreateCompatibleBitmap(pDC, rcColumn2.Width(), rcColumn2.Height());
  944. CXTPCompatibleDC dcMem(NULL, &bmp);
  946. // Fill background
  947. dcMem.FillSolidRect(&rcColumn2, pDC->GetBkColor());
  948. BOOL bColumnPressed = FALSE;
  949. DrawColumnBackground(&dcMem, pColumn, rcColumn2, bColumnPressed);
  952. pIcon->Draw(&dcMem, ptIconOffset, pIcon->GetIcon());
  954. pDC->BitBlt(ptIcon.x, ptIcon.y, szImage.cx, szImage.cy, &dcMem,
  955. ptIconOffset.x, ptIconOffset.y, SRCCOPY);
  956. }
  957. else
  958. {
  959. pIcon->Draw(pDC, ptIcon, pIcon->GetIcon());
  960. }
  961. }
  963. return 1 + szImage.cx;
  964. }
  966. int CXTPReportPaintManager::DrawBitmap(CDC* pDC, CXTPReportControl* pControl, CRect rcColumn, int iIcon)
  967. {
  968. ASSERT(pControl);
  969. if (!pControl)
  970. return 0;
  972. POINT ptIcon;
  974. CXTPImageManagerIcon* pIcon = pControl->GetImageManager()->GetImage(iIcon, 0);
  976. if (!pIcon)
  977. return 0;
  979. CSize szImage(pIcon->GetWidth(), pIcon->GetHeight());
  980. CSize szColumn(rcColumn.Size());
  982. if (szImage.cx < szColumn.cx && szImage.cy < szColumn.cy && pDC)
  983. {
  984. ptIcon.x = rcColumn.left + 1;
  985. ptIcon.y = rcColumn.top + (szColumn.cy - szImage.cy) /2;
  987. if (pDC->IsPrinting())
  988. {
  989. CBitmap bmp;
  990. bmp.CreateCompatibleBitmap(pDC, szImage.cx, szImage.cy);
  991. CXTPCompatibleDC dcMem(NULL, &bmp);
  992. dcMem.FillSolidRect(0, 0, szImage.cx, szImage.cy, pDC->GetBkColor());
  994. pIcon->Draw(&dcMem, CPoint(0, 0), pIcon->GetIcon());
  995. pDC->BitBlt(ptIcon.x, ptIcon.y, szImage.cx, szImage.cy, &dcMem, 0, 0, SRCCOPY);
  997. }
  998. else
  999. {
  1000. pIcon->Draw(pDC, ptIcon, pIcon->GetIcon());
  1001. }
  1002. }
  1004. return 1 + szImage.cx;
  1005. }
  1007. CSize CXTPReportPaintManager::DrawGlyph(CDC* pDC, CRect rcColumn, int iIcon)
  1008. {
  1009. CImageList* pImageList = &m_ilGlyphs;
  1011. IMAGEINFO imgInf;
  1013. if (!pImageList->GetImageInfo(iIcon, &imgInf))
  1014. return CSize(0, 0);
  1016. CSize szImage(imgInf.rcImage.right - imgInf.rcImage.left, imgInf.rcImage.bottom - imgInf.rcImage.top);
  1017. CSize szColumn(rcColumn.Size());
  1019. if (szImage.cy < szColumn.cy && pDC)
  1020. {
  1021. POINT ptIcon;
  1023. ptIcon.x = rcColumn.left + 1;
  1024. ptIcon.y = rcColumn.top + (szColumn.cy - szImage.cy) /2;
  1026. if (pDC->IsPrinting())
  1027. {
  1028. CBitmap bmp;
  1029. bmp.CreateCompatibleBitmap(pDC, szImage.cx, szImage.cy);
  1030. CXTPCompatibleDC dcMem(NULL, &bmp);
  1031. dcMem.FillSolidRect(0, 0, szImage.cx, szImage.cy, pDC->GetBkColor());
  1033. pImageList->Draw(&dcMem, iIcon, CPoint(0, 0), ILD_TRANSPARENT);
  1034. pDC->BitBlt(ptIcon.x, ptIcon.y, szImage.cx, szImage.cy, &dcMem, 0, 0, SRCCOPY);
  1036. }
  1037. else if (CXTPDrawHelpers::IsContextRTL(pDC))  // Revert Icon
  1038. {
  1039. HICON hIcon = pImageList->ExtractIcon(iIcon);
  1040. DrawIconEx(pDC->GetSafeHdc(), ptIcon.x + szImage.cx, ptIcon.y, hIcon, -szImage.cx, szImage.cy, 0, 0, DI_NORMAL);
  1041. DestroyIcon(hIcon);
  1042. }
  1043. else
  1044. {
  1045. pImageList->Draw(pDC, iIcon, ptIcon, ILD_TRANSPARENT);
  1046. }
  1047. }
  1049. return CSize(1 + szImage.cx, 1 + szImage.cy);
  1050. }
  1052. int CXTPReportPaintManager::GetRowHeight(CDC* pDC, CXTPReportRow* pRow, int nTotalWidth)
  1053. {
  1054. if (m_bFixedRowHeight || pRow->IsGroupRow() || !pRow->IsItemsVisible())
  1055. return GetRowHeight(pDC, pRow);
  1057. CXTPReportColumns* pColumns = pRow->GetControl()->GetColumns();
  1058. int nColumnCount = pColumns->GetCount();
  1060. XTP_REPORTRECORDITEM_DRAWARGS drawArgs;
  1061. drawArgs.pControl = pRow->GetControl();
  1062. drawArgs.pDC = pDC;
  1063. drawArgs.pRow = pRow;
  1065. XTP_REPORTRECORDITEM_METRICS* pItemMetrics = new XTP_REPORTRECORDITEM_METRICS;
  1066. int nHeight = 0;
  1068. for (int nColumn = 0; nColumn < nColumnCount; nColumn++)
  1069. {
  1070. CXTPReportColumn* pColumn = pColumns->GetAt(nColumn);
  1071. if (pColumn && pColumn->IsVisible())
  1072. {
  1073. CXTPReportRecordItem* pItem = pRow->GetRecord()->GetItem(pColumn);
  1074. if (!pItem)
  1075. continue;
  1077. drawArgs.pItem = pItem;
  1078. drawArgs.nTextAlign = pColumn->GetAlignment();
  1080. pItemMetrics->Reset();
  1082. pRow->GetItemMetrics(&drawArgs, pItemMetrics);
  1084. CXTPFontDC fnt(pDC, pItemMetrics->pFont);
  1086. int nWidth = pDC->IsPrinting() ? pColumn->GetPrintWidth(nTotalWidth) : pColumn->GetWidth();
  1088. CRect rcItem(0, 0, nWidth - 4, 0);
  1089. pRow->ShiftTreeIndent(rcItem, pColumn);
  1091. pItem->GetCaptionRect(&drawArgs, rcItem);
  1093. if (pItem->GetMarkupUIElement())
  1094. {
  1095. int nCalculatedHeight = XTPMarkupMeasureElement(pItem->GetMarkupUIElement(), rcItem.Width(), INT_MAX).cy;
  1096. nHeight = max(nHeight, nCalculatedHeight);
  1097. }
  1098. else
  1099. {
  1100. BOOL bWordBreak = !!(pItemMetrics->nColumnAlignment & DT_WORDBREAK);
  1101. CString strText = pItem->GetCaption(pColumn);
  1102. ReplaceInHyperLinks(pItem, strText, XTP_HLINK_SPACE_X);
  1103. int nCalculatedHeight = CalculateRowHeight(pDC, strText, rcItem.Width(), bWordBreak);
  1105. nHeight = max(nHeight, nCalculatedHeight);
  1106. }
  1108. if (pItem->GetIconIndex() != XTP_REPORT_NOICON)
  1109. {
  1110. CXTPImageManagerIcon* pIcon = pRow->GetControl()->
  1111. GetImageManager()->GetImage(pItem->GetIconIndex(), 0);
  1113. if (pIcon)
  1114. {
  1115. nHeight = max(nHeight, pIcon->GetHeight());
  1116. }
  1117. }
  1118. }
  1119. }
  1121. CMDTARGET_RELEASE(pItemMetrics);
  1123. return max(nHeight + 5, m_nRowHeight) + (IsGridVisible(FALSE) ? 1 : 0);
  1124. }
  1126. int CXTPReportPaintManager::GetRowHeight(CDC* /*pDC*/, CXTPReportRow* pRow)
  1127. {
  1128. if (!pRow->IsGroupRow())
  1129. {
  1130. return m_nRowHeight + (IsGridVisible(FALSE) ? 1 : 0);
  1131. }
  1133. if (m_bShadeGroupHeadings)
  1134. return m_nRowHeight + 6;
  1136. return m_nRowHeight + 16;
  1137. }
  1139. BOOL CXTPReportPaintManager::IsColumHotTrackingEnabled() const
  1140. {
  1141. return m_bHotTracking && ((m_columnStyle == xtpReportColumnOffice2003) || ((m_columnStyle == xtpReportColumnExplorer) && m_themeWrapper.IsAppThemed()));
  1142. }
  1144. void CXTPReportPaintManager::DrawColumnBackground(CDC* pDC, CXTPReportColumn* pColumn, CRect rcColumn, BOOL& bColumnPressed, CXTPReportHeader* pHeader)
  1145. {
  1146. CXTPReportColumn* pPrevColumn = pHeader ? pHeader->GetNextVisibleColumn(pColumn->GetIndex(), -1) : NULL;
  1148. if (m_columnStyle == xtpReportColumnShaded)
  1149. {
  1150. int nShadowWidth = 4;
  1152. if (pColumn->GetDrawHeaderDivider())
  1153. DrawVerticalLine(pDC, rcColumn.right - 1, rcColumn.top + 2, rcColumn.Height() - 2 - nShadowWidth, m_clrControlDark);
  1155. DrawHorizontalLine(pDC, rcColumn.left, rcColumn.bottom - 3, rcColumn.Width(), MixColor(m_clrHeaderControl, m_clrControlDark, 0.25));
  1156. DrawHorizontalLine(pDC, rcColumn.left, rcColumn.bottom - 2, rcColumn.Width(), MixColor(m_clrHeaderControl, m_clrControlDark, 0.4));
  1157. DrawHorizontalLine(pDC, rcColumn.left, rcColumn.bottom - 1, rcColumn.Width(), MixColor(m_clrHeaderControl, m_clrControlDark, 0.6));
  1159. if (!pPrevColumn || pPrevColumn->GetDrawHeaderDivider())
  1160. DrawVerticalLine(pDC, rcColumn.left, rcColumn.top + 2, rcColumn.Height() - 2 - nShadowWidth, m_clrControlLightLight);
  1161. }
  1162. else if (m_columnStyle == xtpReportColumnOffice2003 || m_columnStyle == xtpReportColumnOffice2007)
  1163. {
  1165. XTPDrawHelpers()->GradientFill(pDC, rcColumn,
  1166. bColumnPressed ? m_grcGradientColumnPushed: pColumn->IsHotTracking() ? m_grcGradientColumnHot : m_grcGradientColumn, FALSE);
  1168. DrawHorizontalLine(pDC, rcColumn.left, rcColumn.bottom - 1, rcColumn.Width(), m_clrGradientColumnShadow);
  1170. if (pColumn->GetDrawHeaderDivider())
  1171. DrawVerticalLine(pDC, rcColumn.right - 1, rcColumn.top + 2, rcColumn.Height() - 2 - 4, m_clrGradientColumnSeparator);
  1173. if (m_columnStyle == xtpReportColumnOffice2003 && (!pPrevColumn || pPrevColumn->GetDrawHeaderDivider()))
  1174. DrawVerticalLine(pDC, rcColumn.left, rcColumn.top + 3, rcColumn.Height() - 2 - 4, m_clrControlLightLight);
  1176. if (pColumn->GetControl()->IsGroupByVisible())
  1177. DrawHorizontalLine(pDC, rcColumn.left, rcColumn.top, rcColumn.Width(), m_clrGradientColumnShadow);
  1179. bColumnPressed = FALSE;
  1180. }
  1181. else if (m_columnStyle == xtpReportColumnExplorer)
  1182. {
  1183. if (m_themeWrapper.IsAppThemed())
  1184. {
  1185. int iState = bColumnPressed ? HIS_PRESSED: pColumn->IsHotTracking() ? HIS_HOT : HIS_NORMAL;
  1187. m_themeWrapper.DrawThemeBackground(pDC->GetSafeHdc(), HP_HEADERITEM, iState, &rcColumn, NULL);
  1188. }
  1189. else
  1190. {
  1191. if (bColumnPressed)
  1192. {
  1193. pDC->Draw3dRect(rcColumn, m_clrControlDark, m_clrControlDark);
  1194. }
  1195. else
  1196. {
  1197. pDC->Draw3dRect(rcColumn, m_clrControlLightLight, m_clrBtnText);
  1198. rcColumn.DeflateRect(1, 1);
  1199. pDC->Draw3dRect(rcColumn, m_clrHeaderControl, m_clrControlDark);
  1200. if(!pColumn->GetDrawHeaderDivider())
  1201. {
  1202. DrawVerticalLine(pDC, rcColumn.right - 1, rcColumn.top, rcColumn.Height() - 1, m_clrHeaderControl);
  1203. DrawVerticalLine(pDC, rcColumn.right, rcColumn.top, rcColumn.Height() - 1, m_clrHeaderControl);
  1204. pDC->SetPixel(rcColumn.right, rcColumn.top - 1, m_clrControlLightLight);
  1205. pDC->SetPixel(rcColumn.right, rcColumn.bottom - 1, m_clrControlDark);
  1206. }
  1207. if(pPrevColumn && !pPrevColumn->GetDrawHeaderDivider())
  1208. {
  1209. DrawVerticalLine(pDC, rcColumn.left - 1, rcColumn.top, rcColumn.Height() - 1, m_clrHeaderControl);
  1210. pDC->SetPixel(rcColumn.left - 1, rcColumn.bottom - 1, m_clrControlDark);
  1211. }
  1212. }
  1213. }
  1214. bColumnPressed = FALSE;
  1216. }
  1217. else
  1218. { // xtpReportColumnFlat
  1219. pDC->Draw3dRect(rcColumn, m_clrControlLightLight, m_clrControlDark);
  1220. if(!pColumn->GetDrawHeaderDivider())
  1221. {
  1222. DrawVerticalLine(pDC, rcColumn.right - 1, rcColumn.top + 1, rcColumn.Height() - 2, m_clrHeaderControl);
  1223. pDC->SetPixel(rcColumn.right - 1, rcColumn.top, m_clrControlLightLight);
  1224. }
  1225. if(pPrevColumn && !pPrevColumn->GetDrawHeaderDivider())
  1226. DrawVerticalLine(pDC, rcColumn.left, rcColumn.top + 1, rcColumn.Height() - 2, m_clrHeaderControl);
  1227. }
  1228. }
  1230. void CXTPReportPaintManager::DrawColumnFooter(CDC* pDC, CXTPReportColumn* pColumn, CXTPReportHeader* /*pHeader*/, CRect rcColumn)
  1231. {
  1232. if (pColumn->GetDrawFooterDivider())
  1233. {
  1234. DrawVerticalLine(pDC, rcColumn.right, rcColumn.top + 6, rcColumn.Height() - 9, m_clrControlLightLight);
  1235. DrawVerticalLine(pDC, rcColumn.right - 1, rcColumn.top + 5, rcColumn.Height() - 9,
  1236. m_columnStyle == xtpReportColumnOffice2003 || m_columnStyle == xtpReportColumnOffice2007 ? m_clrGradientColumnSeparator : m_clrControlDark);
  1237. }
  1239. pDC->SetBkMode(TRANSPARENT);
  1240. CXTPFontDC font(pDC, pColumn->GetFooterFont(), m_clrCaptionText);
  1242. CString strCaption = pColumn->GetFooterText();
  1243. CSize sizeText = pDC->GetTextExtent(strCaption);
  1244. CRect rcText(rcColumn);
  1246. rcText.DeflateRect(3, 2, 3, 2);
  1248. if (pColumn->GetFooterAlignment() != DT_LEFT)
  1249. {
  1250. int nLength = 6 + sizeText.cx;
  1252. if (rcText.Width() > nLength)
  1253. {
  1254. if (pColumn->GetFooterAlignment() & DT_RIGHT)
  1255. rcText.left = rcText.right - nLength;
  1256. if (pColumn->GetFooterAlignment() & DT_CENTER)
  1257. rcText.left = (rcText.left + rcText.right - nLength) / 2;
  1258. }
  1259. }
  1261. UINT uFlags = DT_END_ELLIPSIS | DT_NOPREFIX;
  1263. if (!m_bFixedRowHeight && (pColumn->GetFooterAlignment() & DT_WORDBREAK))
  1264. {
  1265. uFlags |= DT_WORDBREAK;
  1267. // try to center vertically because DT_VCENTER works only for DT_SINGLELINE;
  1268. CRect rcTextReal = rcText;
  1269. pDC->DrawText(strCaption, rcTextReal, uFlags | DT_CALCRECT);
  1271. int nHeightDiff = rcText.Height() - rcTextReal.Height();
  1272. if (nHeightDiff > 1)
  1273. {
  1274. rcText.top += nHeightDiff/2;
  1275. }
  1276. }
  1277. else
  1278. {
  1279. uFlags |= DT_SINGLELINE | DT_VCENTER;
  1280. }
  1282. if (strCaption.GetLength() > 0 && rcText.right > rcText.left)
  1283. {
  1284. pDC->DrawText(strCaption, rcText, uFlags);
  1285. }
  1286. }
  1289. void CXTPReportPaintManager::DrawColumn(CDC* pDC, CXTPReportColumn* pColumn, CXTPReportHeader* pHeader, CRect rcColumn, BOOL bDrawExternal)
  1290. {
  1291. // save column parameter for future use in drawing
  1293. BOOL bDraggingFromHeader = bDrawExternal && pColumn->IsDragging() &&
  1294. rcColumn.left == 0 && rcColumn.top == 0 && pHeader->IsDragHeader();
  1296. BOOL bPlainColumn = bDrawExternal && !bDraggingFromHeader;
  1297. BOOL bColumnPressed = pColumn->IsDragging() && !bDrawExternal && pHeader->IsDragHeader();
  1300. CRect rcColumn0 = rcColumn;
  1301. // draw
  1302. int nIconID = pColumn->GetIconID();
  1303. CString strCaption = pColumn->GetCaption();
  1304. int nShadowWidth = !bPlainColumn && m_columnStyle == xtpReportColumnShaded ? 4 : 0;
  1306. if (bPlainColumn)
  1307. {
  1308. if (m_columnStyle == xtpReportColumnOffice2007)
  1309. {
  1310. XTPDrawHelpers()->GradientFill(pDC, rcColumn, m_grcGradientColumn, FALSE);
  1311. pDC->Draw3dRect(rcColumn, m_clrGradientColumnShadow, m_clrGradientColumnShadow);
  1312. }
  1313. else
  1314. {
  1315. pDC->Draw3dRect(rcColumn, m_clrControlLightLight, m_clrControlDark);
  1316. pDC->MoveTo(rcColumn.left, rcColumn.bottom);
  1317. pDC->LineTo(rcColumn.right, rcColumn.bottom);
  1318. pDC->LineTo(rcColumn.right, rcColumn.top-1);
  1319. }
  1320. }
  1321. else
  1322. {
  1323. DrawColumnBackground(pDC, pColumn, rcColumn, bColumnPressed, pHeader);
  1324. }
  1326. pDC->SetBkColor(m_clrHeaderControl);
  1329. rcColumn.bottom = rcColumn.bottom - 1 - nShadowWidth;
  1331. CRect rcText(rcColumn);
  1333. if (!pColumn->IsAutoSize() && !bPlainColumn)
  1334. {
  1335. rcText.left += pColumn->GetIndent();
  1336. }
  1338. BOOL bHasSortTriangle = pColumn->HasSortTriangle() && !pDC->IsPrinting();
  1340. CXTPFontDC font(pDC, &m_fontCaption);
  1341. CSize sizeText = pDC->GetTextExtent(strCaption);
  1343. if (pColumn->GetHeaderAlignment() != DT_LEFT && !bPlainColumn)
  1344. {
  1345. int nLength = 6 + sizeText.cx;
  1347. if (nIconID != XTP_REPORT_NOICON)
  1348. {
  1349. nLength += DrawBitmap(NULL, pColumn->GetControl(), rcText, nIconID) + 2;
  1350. }
  1351. if (bHasSortTriangle)
  1352. nLength += 27;
  1354. if (rcText.Width() > nLength)
  1355. {
  1356. if (pColumn->GetHeaderAlignment() & DT_RIGHT)
  1357. rcText.left = rcText.right - nLength;
  1358. if (pColumn->GetHeaderAlignment() & DT_CENTER)
  1359. rcText.left = (rcText.left + rcText.right - nLength) / 2;
  1361. }
  1363. }
  1365. if (nIconID != XTP_REPORT_NOICON && !bPlainColumn)
  1366. {
  1367. CRect rcIcon(rcText);
  1368. rcIcon.bottom += nShadowWidth;
  1369. // shift column left by bitmap drawing place
  1371. //rcText.left += DrawBitmap(pDC, pColumn->GetControl(), rcIcon, nIconID);
  1372. rcText.left += DrawColumnIcon(pDC, pColumn, rcColumn0, rcIcon, nIconID);
  1374. // shift column left to the column right to disallow drawing text on Bitmap column headers
  1375. rcText.left += 2;
  1376. }
  1378. pDC->SetBkMode(TRANSPARENT);
  1380. rcText.DeflateRect(3, 0, 3, 0);
  1381. CRect rcTriangle(rcText);
  1383. if (strCaption.GetLength() > 0 && rcText.right > rcText.left)
  1384. {
  1385. // TODO: Markup support for columns
  1386. //      if (pColumn->m_pMarkupUIElement)
  1387. //      {
  1388. //          rcText.DeflateRect(2, 1, 2, 0);
  1389. //
  1390. //          XTPMarkupMeasureElement(pColumn->m_pMarkupUIElement, rcText.Width(), INT_MAX);
  1391. //
  1392. //          XTPMarkupSetDefaultFont(m_pRecord->GetRecords()->GetMarkupContext(), (HFONT)m_fontCaption->GetSafeHandle(), m_clrControlLightLight);
  1393. //          XTPMarkupRenderElement(m_pMarkupUIElement, pDC->GetSafeHdc(), &rcText);
  1394. //      }
  1395. //      else
  1396. {
  1397. pDC->SetTextColor(m_clrCaptionText);
  1399. if (m_bDrawSortTriangleAlways && bHasSortTriangle)
  1400. {
  1401. sizeText.cx = max(-5, min(sizeText.cx, rcText.Width() - 27));
  1402. rcText.right = min(rcText.right, rcText.left + sizeText.cx + 8);
  1403. }
  1405. UINT uFlags = DT_END_ELLIPSIS | DT_NOPREFIX;
  1407. if (pColumn->GetHeaderAlignment() & DT_WORDBREAK)
  1408. {
  1409. uFlags |= DT_WORDBREAK;
  1410. if (pColumn->GetHeaderAlignment() & DT_RIGHT)
  1411. uFlags |= DT_RIGHT;
  1413. // try to center vertically because DT_VCENTER works only for DT_SINGLELINE;
  1414. CRect rcTextReal = rcText;
  1415. pDC->DrawText(strCaption, rcTextReal, uFlags | DT_CALCRECT);
  1417. int nHeightDiff = rcText.Height() - rcTextReal.Height();
  1418. if (nHeightDiff > 1)
  1419. {
  1420. rcText.top += nHeightDiff/2;
  1421. }
  1422. }
  1423. else
  1424. {
  1425. uFlags |= DT_SINGLELINE | DT_VCENTER;
  1426. }
  1428. pDC->DrawText(strCaption, rcText, uFlags);
  1430. rcTriangle.left += sizeText.cx;
  1431. }
  1432. }
  1434. if (bHasSortTriangle)
  1435. {
  1436. rcTriangle.left += (bPlainColumn ? 17 : 10);
  1437. DrawTriangle(pDC, rcTriangle, pColumn->IsSortedDecreasing());
  1438. }
  1440. if (bColumnPressed && m_bInvertColumnOnClick)
  1441. {
  1442. rcColumn.bottom += nShadowWidth;
  1443. pDC->InvertRect(&rcColumn);
  1444. }
  1445. }
  1447. int CXTPReportPaintManager::CalcColumnHeight(CDC* pDC, CXTPReportColumn* pColumn,
  1448. int nTotalWidth)
  1449. {
  1450. int nIconID = pColumn->GetIconID();
  1451. CString strCaption = pColumn->GetCaption();
  1453. int nWidth = pDC->IsPrinting() ? pColumn->GetPrintWidth(nTotalWidth) : pColumn->GetWidth();
  1454. CRect rcColumn = pColumn->GetRect();
  1455. rcColumn.right = rcColumn.left + nWidth;
  1457. CRect rcText(rcColumn);
  1459. if (!pColumn->IsAutoSize())
  1460. {
  1461. rcText.left += pColumn->GetIndent();
  1462. }
  1464. BOOL bHasSortTriangle = pColumn->HasSortTriangle() && !pDC->IsPrinting();
  1466. CXTPFontDC font(pDC, &m_fontCaption);
  1467. CSize sizeText = pDC->GetTextExtent(strCaption);
  1469. if (nIconID != XTP_REPORT_NOICON)
  1470. {
  1471. // shift column left by bitmap drawing place
  1472. rcText.left += DrawBitmap(NULL, pColumn->GetControl(), rcText, nIconID);
  1473. // shift column left to the column right to disallow drawing text on Bitmap column headers
  1474. rcText.left += 2;
  1475. }
  1477. rcText.DeflateRect(3, 0, 3, 0);
  1479. if (strCaption.GetLength() > 0 && rcText.right > rcText.left)
  1480. {
  1481. if (m_bDrawSortTriangleAlways && bHasSortTriangle)
  1482. {
  1483. sizeText.cx = max(-5, min(sizeText.cx, rcText.Width() - 27));
  1484. rcText.right = min(rcText.right, rcText.left + sizeText.cx + 8);
  1485. }
  1487. UINT uFlags = DT_END_ELLIPSIS | DT_VCENTER | DT_NOPREFIX;
  1488. uFlags |= (pColumn->GetHeaderAlignment() & DT_WORDBREAK) ? DT_WORDBREAK : DT_SINGLELINE;
  1489. uFlags |= DT_CALCRECT;
  1491. pDC->DrawText(strCaption, rcText, uFlags);
  1493. return m_pHeaderHeightFormula->Calculate(rcText.Height());
  1494. }
  1496. return 8;
  1497. }
  1499. void CXTPReportPaintManager::FillGroupByControl(CDC* pDC, CRect& rcGroupBy)
  1500. {
  1501. pDC->FillSolidRect(rcGroupBy, m_clrGroupBoxBack);
  1502. }
  1504. void CXTPReportPaintManager::DrawConnector(CDC* pDC, CPoint ptFrom, CPoint ptTo)
  1505. {
  1506. COLORREF crConnector = RGB(0, 0, 0);
  1507. DrawVerticalLine(pDC, ptFrom.x, ptFrom.y, ptTo.y - ptFrom.y, crConnector);
  1508. DrawHorizontalLine(pDC, ptFrom.x, ptTo.y, ptTo.x - ptFrom.x, crConnector);
  1509. }
  1511. void CXTPReportPaintManager::DrawFocusedRow(CDC* pDC, CRect rcRow)
  1512. {
  1513. COLORREF clrTextColor = pDC->SetTextColor(m_clrControlBack);
  1514. COLORREF clrBkColor = pDC->SetBkColor(m_clrWindowText);
  1515. pDC->DrawFocusRect(rcRow);
  1516. pDC->SetTextColor(clrTextColor);
  1517. pDC->SetBkColor(clrBkColor);
  1518. }
  1521. int CXTPReportPaintManager::GetPreviewLinesCount(CDC* pDC, CRect& rcText, const CString& strText)
  1522. {
  1523. if (rcText.Width() < 1)
  1524. return 0;
  1526. if (pDC->GetTextExtent(strText).cx / rcText.Width() > m_nMaxPreviewLines)
  1527. return m_nMaxPreviewLines;
  1529. CRect rcCalc(rcText.left, 0, rcText.right, 0);
  1530. pDC->DrawText(strText, rcCalc, DT_WORDBREAK | DT_CALCRECT | DT_NOPREFIX);
  1532. return min(rcCalc.Height() / pDC->GetTextExtent(_T(" "), 1).cy, m_nMaxPreviewLines);
  1534. }
  1537. void CXTPReportPaintManager::SetTextFont(LOGFONT& lf)
  1538. {
  1539. m_fontText.DeleteObject();
  1540. m_fontBoldText.DeleteObject();
  1542. m_fontText.CreateFontIndirect(&lf);
  1544. lf.lfWeight = FW_BOLD;
  1545. m_fontBoldText.CreateFontIndirect(&lf);
  1547. CWindowDC dc (NULL);
  1548. CXTPFontDC font(&dc, &m_fontText);
  1550. int nFontHeight = dc.GetTextExtent(_T(" "), 1).cy;
  1551. m_nRowHeight = max(18, nFontHeight + 4);
  1553. }
  1555. void CXTPReportPaintManager::SetCaptionFont(LOGFONT& lf)
  1556. {
  1557. m_fontCaption.DeleteObject();
  1558. VERIFY(m_fontCaption.CreateFontIndirect(&lf));
  1560. CWindowDC dc (NULL);
  1561. CXTPFontDC font(&dc, &m_fontCaption);
  1563. font.SetFont(&m_fontCaption);
  1564. int nFontHeight = dc.GetTextExtent(_T(" "), 1).cy;
  1565. m_nHeaderHeight = m_pHeaderHeightFormula->Calculate(nFontHeight);
  1566. m_nFooterHeight = m_nHeaderHeight;
  1567. }
  1569. int CXTPReportPaintManager::GetFooterHeight(CXTPReportControl* pControl, CDC* pDC, int nTotalWidth)
  1570. {
  1571. ASSERT(pControl && pDC);
  1573. if (!pControl || !pDC)
  1574. {
  1575. return m_nFooterHeight;
  1576. }
  1578. CXTPReportColumns* pColumns = pControl->GetColumns();
  1579. int nColumnCount = pColumns->GetCount();
  1580. int nHeight = 22;
  1582. CXTPFontDC font(pDC);
  1584. for (int nColumn = 0; nColumn < nColumnCount; nColumn++)
  1585. {
  1586. CXTPReportColumn* pColumn = pColumns->GetAt(nColumn);
  1587. if (pColumn && pColumn->IsVisible())
  1588. {
  1589. CString strCaption = pColumn->GetFooterText();
  1591. int nWidth = pDC->IsPrinting() ? pColumn->GetPrintWidth(nTotalWidth) : pColumn->GetWidth();
  1592. CRect rcText(0, 0, nWidth, 22);
  1593. rcText.DeflateRect(3, 0, 3, 0);
  1595. UINT uFlags = DT_CALCRECT | DT_END_ELLIPSIS | DT_VCENTER | DT_NOPREFIX;
  1596. if (!m_bFixedRowHeight && (pColumn->GetFooterAlignment() & DT_WORDBREAK))
  1597. uFlags |= DT_WORDBREAK;
  1598. else
  1599. uFlags |= DT_SINGLELINE;
  1601. font.SetFont(pColumn->GetFooterFont());
  1602. pDC->DrawText(strCaption, rcText, uFlags);
  1604. nHeight = max(nHeight, rcText.Height() + 8);
  1605. }
  1606. }
  1607. return  nHeight;
  1608. }
  1610. int CXTPReportPaintManager::GetHeaderHeight(CXTPReportControl* pControl,
  1611. CDC* pDC, int nTotalWidth)
  1612. {
  1613. ASSERT(pControl && pDC);
  1615. if (m_bFixedRowHeight || !pControl || !pDC)
  1616. {
  1617. return GetHeaderHeight();
  1618. }
  1620. CXTPReportColumns* pColumns = pControl->GetColumns();
  1621. int nColumnCount = pColumns->GetCount();
  1622. int nHeight = m_nHeaderHeight;
  1624. for (int nColumn = 0; nColumn < nColumnCount; nColumn++)
  1625. {
  1626. CXTPReportColumn* pColumn = pColumns->GetAt(nColumn);
  1627. if (pColumn && pColumn->IsVisible())
  1628. {
  1629. if (pColumn->GetHeaderAlignment() & DT_WORDBREAK)
  1630. {
  1631. int nColHeight = CalcColumnHeight(pDC, pColumn, nTotalWidth);
  1633. nHeight = max(nHeight, nColHeight);
  1634. }
  1636. // calculate icon height.
  1637. int nIconID = pColumn->GetIconID();
  1638. if (nIconID != XTP_REPORT_NOICON)
  1639. {
  1640. CXTPImageManagerIcon* pIcon = pColumn->GetControl()->
  1641. GetImageManager()->GetImage(nIconID, 0);
  1643. if (pIcon)
  1644. {
  1645. nHeight = max(nHeight, pIcon->GetHeight() + 2);
  1646. }
  1647. }
  1648. }
  1649. }
  1651. return nHeight;
  1652. }
  1654. void CXTPReportPaintManager::SetPreviewIndent(int nLeft, int nTop, int nRight, int nBottom)
  1655. {
  1656. m_rcPreviewIndent.SetRect(nLeft, nTop, nRight, nBottom);
  1657. }
  1659. void CXTPReportPaintManager::DrawInplaceButton(CDC* pDC, CXTPReportInplaceButton* pButton)
  1660. {
  1661. CXTPClientRect rect((CWnd*)pButton);
  1662. BOOL bButtonIconDrawn = FALSE;
  1664. if (m_bThemedInplaceButtons)
  1665. {
  1666. if (pButton->GetID() == XTP_ID_REPORT_COMBOBUTTON && m_themeCombo.IsAppThemed())
  1667. {
  1668. m_themeCombo.DrawThemeBackground(*pDC, CP_DROPDOWNBUTTON,
  1669. pButton->IsPressed() ? CBXS_PRESSED:  CBXS_NORMAL, rect, 0);
  1671. return;
  1672. }
  1674. if (pButton->GetID() == XTP_ID_REPORT_EXPANDBUTTON  && m_themeButton.IsAppThemed())
  1675. {
  1676. pDC->FillSolidRect(rect, GetXtremeColor(COLOR_3DFACE));
  1678. m_themeButton.DrawThemeBackground(*pDC, BP_PUSHBUTTON, pButton->IsPressed() ? PBS_PRESSED :
  1679. CWnd::GetFocus() == pButton ? PBS_DEFAULTED : PBS_NORMAL, rect, 0);
  1681. if(!DrawInplaceButtonIcon(pDC, pButton))
  1682. {
  1683. // draw dots
  1684. pDC->Rectangle(rect.left + 3, rect.bottom -5, rect.left + 5, rect.bottom -3);
  1685. pDC->Rectangle(rect.left + 7, rect.bottom -5, rect.left + 9, rect.bottom -3);
  1686. pDC->Rectangle(rect.left + 11, rect.bottom -5, rect.left + 13, rect.bottom -3);
  1687. }
  1689. return;
  1690. }
  1692. if (pButton->GetID() == XTP_ID_REPORT_SPINBUTTON && m_themeSpin.IsAppThemed())
  1693. {
  1694. int nHeight = rect.Height() / 2;
  1695. rect.bottom -= nHeight;
  1696. m_themeSpin.DrawThemeBackground(*pDC, SPNP_UP, pButton->GetState() == SPNP_UP ? UPS_PRESSED : UPS_NORMAL, rect, 0);
  1697. rect.OffsetRect(0, nHeight);
  1698. m_themeSpin.DrawThemeBackground(*pDC, SPNP_DOWN, pButton->GetState() == SPNP_DOWN ? UPS_PRESSED : UPS_NORMAL, rect, 0);
  1700. return;
  1701. }
  1702. }
  1703. if (pButton->GetID() == XTP_ID_REPORT_COMBOBUTTON)
  1704. {
  1705. DrawInplaceButtonFrame(pDC, pButton);
  1706. }
  1707. else if (pButton->GetID() == XTP_ID_REPORT_EXPANDBUTTON)
  1708. {
  1709. DrawInplaceButtonFrame(pDC, pButton);
  1710. bButtonIconDrawn = DrawInplaceButtonIcon(pDC, pButton);
  1711. }
  1712. else if(pButton->GetID() == XTP_ID_REPORT_SPINBUTTON)
  1713. {
  1714. CXTPClientRect rect((CWnd*)pButton);
  1715. int nHeight = rect.Height() / 2;
  1716. rect.bottom -= nHeight;
  1717. for(int i = 0; i < 2; i++)
  1718. {
  1719. pDC->FillSolidRect(rect, GetXtremeColor(COLOR_3DFACE));
  1721. if (i == 0 && pButton->GetState() == SPNP_UP || i == 1 && pButton->GetState() == SPNP_DOWN)
  1722. {
  1723. pDC->Draw3dRect(rect, GetXtremeColor(COLOR_3DDKSHADOW), GetXtremeColor(COLOR_WINDOW));
  1724. }
  1725. else
  1726. {
  1727. pDC->Draw3dRect(rect, GetXtremeColor(COLOR_3DFACE), GetXtremeColor(COLOR_3DDKSHADOW));
  1728. rect.DeflateRect(1, 1);
  1729. pDC->Draw3dRect(rect, GetXtremeColor(COLOR_WINDOW), GetXtremeColor(COLOR_3DSHADOW));
  1730. rect.InflateRect(1, 1);
  1731. }
  1732. rect.OffsetRect(0, nHeight);
  1733. }
  1734. }
  1736. CXTPPenDC pen (*pDC, GetXtremeColor(COLOR_BTNTEXT));
  1737. CXTPBrushDC brush (*pDC, GetXtremeColor(COLOR_BTNTEXT));
  1739. if (pButton->GetID() == XTP_ID_REPORT_COMBOBUTTON)
  1740. {
  1741. CPoint pt = rect.CenterPoint();
  1743. CPoint pts[3];
  1744. pts[0] = CPoint(pt.x -3, pt.y -1);
  1745. pts[1] = CPoint(pt.x + 3, pt.y -1);
  1746. pts[2] = CPoint(pt.x, pt.y +2);
  1747. pDC->Polygon(pts, 3);
  1748. }
  1750. if (pButton->GetID() == XTP_ID_REPORT_EXPANDBUTTON && !bButtonIconDrawn)
  1751. {
  1752. pDC->Rectangle(rect.left + 3, rect.bottom -5, rect.left + 5, rect.bottom -3);
  1753. pDC->Rectangle(rect.left + 7, rect.bottom -5, rect.left + 9, rect.bottom -3);
  1754. pDC->Rectangle(rect.left + 11, rect.bottom -5, rect.left + 13, rect.bottom -3);
  1755. }
  1757. if (pButton->GetID() == XTP_ID_REPORT_SPINBUTTON)
  1758. {
  1759. CPoint pt = rect.CenterPoint();
  1760. pt.y -= rect.Height() / 4;
  1762. CPoint pts[3];
  1763. pts[0] = CPoint(pt.x - 2, pt.y + 1);
  1764. pts[1] = CPoint(pt.x + 2, pt.y + 1);
  1765. pts[2] = CPoint(pt.x, pt.y - 1);
  1766. pDC->Polygon(pts, 3);
  1768. pt.y += rect.Height() / 2;
  1769. pts[0] = CPoint(pt.x - 2, pt.y - 1);
  1770. pts[1] = CPoint(pt.x + 2, pt.y - 1);
  1771. pts[2] = CPoint(pt.x, pt.y + 1);
  1772. pDC->Polygon(pts, 3);
  1773. }
  1774. }
  1776. void CXTPReportPaintManager::DrawInplaceButtonFrame(CDC* pDC, CXTPReportInplaceButton* pButton)
  1777. {
  1778. CXTPClientRect rect((CWnd*)pButton);
  1780. pDC->FillSolidRect(rect, GetXtremeColor(COLOR_3DFACE));
  1782. if (pButton->IsPressed())
  1783. {
  1784. pDC->Draw3dRect(rect, GetXtremeColor(COLOR_3DDKSHADOW), GetXtremeColor(COLOR_WINDOW));
  1785. }
  1786. else
  1787. {
  1788. pDC->Draw3dRect(rect, GetXtremeColor(COLOR_3DFACE), GetXtremeColor(COLOR_3DDKSHADOW));
  1789. rect.DeflateRect(1, 1);
  1790. pDC->Draw3dRect(rect, GetXtremeColor(COLOR_WINDOW), GetXtremeColor(COLOR_3DSHADOW));
  1791. }
  1792. }
  1794. BOOL CXTPReportPaintManager::DrawInplaceButtonIcon(CDC* pDC, CXTPReportInplaceButton* pButton)
  1795. {
  1796. CXTPClientRect rect((CWnd*)pButton);
  1798. int nIconIndex = pButton->GetIconIndex();
  1799. if(nIconIndex == XTP_REPORT_NOICON)
  1800. return FALSE;
  1801. CXTPImageManagerIcon* pIcon = pButton->pControl->GetImageManager()->GetImage(nIconIndex, 0);
  1802. if(!pIcon)
  1803. return FALSE;
  1804. CSize szImage(pIcon->GetWidth(), pIcon->GetHeight());
  1805. CPoint ptIcon(max(rect.left, rect.left + (rect.Width() - szImage.cx) / 2),
  1806. max(rect.top, rect.top + (rect.Height() - szImage.cy) / 2));
  1807. szImage.cx = min(szImage.cx, rect.Width());
  1808. szImage.cy = min(szImage.cy, rect.Height());
  1809. pIcon->Draw(pDC, ptIcon, pIcon->GetIcon(), szImage);
  1811. return TRUE;
  1812. }
  1814. void CXTPReportPaintManager::DrawTreeStructureLine(CDC* pDC, int x, int y, int cx, int cy, COLORREF clr)
  1815. {
  1816. if (m_treeStructureStyle == xtpReportTreeStructureDots)
  1817. {
  1818. const unsigned short _cb[] = {0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55};
  1819. DrawGridPat(pDC, &m_brushTreeStructure, CRect(x, y, x + cx, y + cy), _cb, m_clrControlDark);
  1820. }
  1821. else
  1822. {
  1823. pDC->FillSolidRect(x, y, cx, cy, clr);
  1824. }
  1825. }
  1827. void CXTPReportPaintManager::DrawTreeStructure(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, XTP_REPORTRECORDITEM_METRICS* pMetrics, CRect rcItem, CSize sizeGlyph)
  1828. {
  1829. if (m_treeStructureStyle == xtpReportTreeStructureNone)
  1830. return;
  1832. CDC* pDC = pDrawArgs->pDC;
  1833. CXTPReportRow* pRow = pDrawArgs->pRow;
  1834. COLORREF clrTreeStructure = pMetrics->clrForeground;
  1836. if(pDrawArgs->pControl->IsVirtualMode())
  1837. {
  1838. if(pMetrics->nVirtRowLevel == 0)
  1839. return;
  1840. }
  1841. else
  1842. {
  1843. if (pRow->IsGroupRow() || (m_nTreeStructureStyle == 0 && (!pRow->GetParentRow() || pRow->GetParentRow()->IsGroupRow())))
  1844. return;
  1845. }
  1847. int nTreeIndent = pDrawArgs->pControl->GetPaintManager()->m_nTreeIndent;
  1848. int nHeight = rcItem.Height();
  1850. LONG lHorLineOffset = nHeight / 2;
  1851. int nIconAlign = pDrawArgs->nTextAlign & xtpColumnIconMask;
  1852. switch(nIconAlign)
  1853. {
  1854. case xtpColumnIconTop:
  1855. lHorLineOffset = sizeGlyph.cy / 2;
  1856. break;
  1857. case xtpColumnIconBottom:
  1858. lHorLineOffset = rcItem.bottom - rcItem.top - 2 - sizeGlyph.cy / 2;
  1859. break;
  1860. }
  1862. if(m_nTreeStructureStyle > 0)
  1863. rcItem.OffsetRect((sizeGlyph.cy + 1) / 2 + 2, 0);
  1864. BOOL bSiblingRow = pDrawArgs->pControl->IsVirtualMode() ? !(pMetrics->nVirtRowFlags & xtpVirtRowLastChild) : !!pRow->GetNextSiblingRow();
  1865. if (!bSiblingRow)
  1866. {
  1867. DrawTreeStructureLine(pDC, rcItem.left, rcItem.top - 1, 1, lHorLineOffset + 1, clrTreeStructure);
  1868. }
  1869. else
  1870. {
  1871. DrawTreeStructureLine(pDC, rcItem.left, rcItem.top - 1, 1, nHeight + 1, clrTreeStructure);
  1872. }
  1874. DrawTreeStructureLine(pDC, rcItem.left, rcItem.top + lHorLineOffset, sizeGlyph.cx / 2 + 1, 1, clrTreeStructure);
  1876. for (;;)
  1877. {
  1878. pRow = pRow->GetParentRow();
  1880. if (pRow == NULL || pRow->IsGroupRow() || (m_nTreeStructureStyle == 0 && (pRow->GetParentRow() == 0 || pRow->GetParentRow()->IsGroupRow())))
  1881. break;
  1883. rcItem.OffsetRect(-nTreeIndent, 0);
  1885. if (pRow->GetNextSiblingRow())
  1886. {
  1887. DrawTreeStructureLine(pDC, rcItem.left, rcItem.top - 1, 1, rcItem.Height() + 1, clrTreeStructure);
  1888. }
  1889. }
  1891. }
  1893. int CXTPReportPaintManager::DrawString(int* pnCurrDrawPos, CDC* pDC, const CString& strDraw, CRect rcDraw, UINT nFormat)
  1894. {
  1895. int nCharCount = 0;
  1898. switch (nFormat)
  1899. {
  1900. case DT_END_ELLIPSIS:
  1901. {
  1902. // in this case char count only for identify if string printed partially
  1903. *pnCurrDrawPos += GetTextExtentX(pDC,strDraw);
  1904. if (*pnCurrDrawPos >= rcDraw.right)
  1905. nCharCount = - 1;
  1906. else
  1907. nCharCount = strDraw.GetLength();
  1909. pDC->DrawText(strDraw, rcDraw, DT_LEFT | DT_END_ELLIPSIS | DT_NOPREFIX);
  1910. break;
  1911. }
  1912. case DT_WORDBREAK:
  1913. {
  1914. const TCHAR seps[] = _T(" tn");
  1915. TCHAR* lpszContext = 0;
  1916. CString strOut = _T("");
  1917. CString strSrc = strDraw;
  1918. TCHAR* szWord = STRTOK_S(strSrc.GetBuffer(strSrc.GetLength()), seps, &lpszContext);
  1919. int nRightStrMargin = GetTextExtentX(pDC, CString(szWord));
  1921. if (nRightStrMargin > rcDraw.Width())
  1922. {
  1923. strOut = szWord;
  1925. }
  1926. else
  1927. {
  1928. while (szWord != NULL && nRightStrMargin < rcDraw.Width())
  1929. {
  1930. strOut = strOut + szWord + _T(" ");
  1931. szWord = STRTOK_S(NULL, seps, &lpszContext);
  1932. nRightStrMargin = GetTextExtentX(pDC,strOut + szWord);
  1933. }
  1934. }
  1936. nCharCount = strOut.GetLength();
  1937. *pnCurrDrawPos += GetTextExtentX(pDC,strOut);
  1938. pDC->DrawText(strOut, rcDraw, DT_LEFT | DT_NOPREFIX);
  1939. break;
  1940. }
  1941. case DT_LEFT:
  1942. case DT_RIGHT:
  1943. case DT_CENTER:
  1944. {
  1945. *pnCurrDrawPos += GetTextExtentX(pDC,strDraw);
  1946. if (*pnCurrDrawPos >= rcDraw.right)
  1947. nCharCount = - 1;
  1948. else
  1949. nCharCount = strDraw.GetLength();
  1951. pDC->DrawText(strDraw, rcDraw, nFormat  | DT_NOPREFIX);
  1952. break;
  1953. }
  1955. } // switch
  1957. return nCharCount;
  1958. }
  1960. int CXTPReportPaintManager::DrawLink(int* pnCurrDrawPos, XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, CXTPReportHyperlink* pHyperlink,
  1961. CString strText, CRect rcLink, int nFlag)
  1962. {
  1963. return DrawLink2(pnCurrDrawPos, pDrawArgs, pHyperlink, strText, rcLink, nFlag);
  1964. }
  1966. void CXTPReportPaintManager::DrawTextLine(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, const CString& strText,
  1967. CRect rcItem, int nFlag, int& nCharCounter, int& nHyperlikCounter)
  1968. {
  1969. CDC* pDC = pDrawArgs->pDC;
  1970. CXTPReportRecordItem* pItem = pDrawArgs->pItem;
  1971. UINT nAlingFlag = 0;
  1972. int nHyperlink = nHyperlikCounter; // Hyperlink index
  1973. int nCharCount = nCharCounter; // Number of actually printed chars
  1974. CXTPReportHyperlink* pHl = NULL;
  1975. int nHyperlinks = pItem->GetHyperlinksCount();
  1977. int nCurrStrPos = nCharCount;
  1978. CRect rcText;
  1979. rcText.CopyRect(&rcItem);
  1981. if (nHyperlinks == 0)
  1982. {
  1983. pDC->DrawText(strText, rcText, pDrawArgs->nTextAlign | nFlag | DT_NOPREFIX | DT_SINGLELINE);
  1984. return;
  1985. }
  1987. // calculate rect for drawing text for text alignment feature
  1988. pDC->DrawText(strText, rcText, DT_CALCRECT | DT_NOPREFIX | DT_SINGLELINE);
  1990. if (rcText.Width() < rcItem.Width())
  1991. {
  1992. switch (pDrawArgs->nTextAlign & (DT_RIGHT|DT_CENTER))
  1993. {
  1994. case DT_RIGHT :
  1995. rcText.left = rcItem.right - rcText.Width();
  1996. break;
  1997. case DT_CENTER :
  1998. rcText.left = rcItem.left + (rcItem.Width() - rcText.Width())/2;
  1999. break;
  2000. }
  2001. }
  2002. rcText.right = rcItem.right;
  2004. int nCurrDrawPos = rcText.left;
  2006. while (strText.GetLength() > nCurrStrPos && nCurrDrawPos < rcText.right)
  2007. {
  2008. CString strOut;
  2009. if (nHyperlinks > nHyperlink)
  2010. {
  2011. pHl = pItem->GetHyperlinkAt(nHyperlink);
  2012. strOut = strText.Mid(nCurrStrPos, pHl->m_nHyperTextBegin - nCurrStrPos);
  2013. if (strOut.GetLength() > 0) // print str
  2014. {
  2015. // replace LF, CR characters (if any)
  2016. REMOVE_S(strOut, _T('n'));
  2017. REMOVE_S(strOut, _T('r'));
  2019. nCharCount = DrawString(&nCurrDrawPos, pDC, strOut, rcText, nFlag);
  2020. rcText.left = nCurrDrawPos > rcText.right ? rcText.right : nCurrDrawPos;
  2022. // if previous string was cut - stop draw
  2023. if (nCharCount < strOut.GetLength())
  2024. {
  2025. nCharCount += nCurrStrPos;
  2026. break;
  2027. }
  2028. }
  2030. // print link
  2031. nCharCount = DrawLink(&nCurrDrawPos, pDrawArgs, pHl, strText, rcText, nFlag);
  2032. rcText.left = nCurrDrawPos > rcText.right ? rcText.right : nCurrDrawPos;
  2034. // update current position in string
  2035. nCurrStrPos = pHl->m_nHyperTextBegin + pHl->m_nHyperTextLen;
  2036. nHyperlink++;
  2038. // if previous string was cut - stop draw
  2039. if (nCharCount < (pHl->m_nHyperTextLen))
  2040. {
  2041. nCharCount += nCurrStrPos;
  2042. break;
  2043. }
  2044. }
  2045. else
  2046. {
  2048. // print whole string without links or tail of string
  2049. strOut = strText.Mid(nCurrStrPos, strText.GetLength() - nCurrStrPos);
  2050. nCharCount = DrawString(&nCurrDrawPos, pDC, strOut, rcText, nFlag);
  2051. nCharCount += nCurrStrPos;
  2052. break; // all was drawn!
  2053. }
  2054. }
  2056. pDC->SetTextAlign(nAlingFlag);
  2057. nCharCounter = nCharCount;
  2058. }
  2060. void CXTPReportPaintManager::DrawItemCaption(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, XTP_REPORTRECORDITEM_METRICS* pMetrics)
  2061. {
  2062. CString strText = pMetrics->strText;
  2064. CRect& rcItem = pDrawArgs->rcItem;
  2066. rcItem.DeflateRect(2, 1, 2, 0);
  2068. // draw item text
  2069. if (!strText.IsEmpty())
  2070. {
  2071. if (!m_bFixedRowHeight)// && (pDrawArgs->nTextAlign & DT_WORDBREAK))
  2072. {
  2073. BOOL bWordBreak = !!(pDrawArgs->nTextAlign & DT_WORDBREAK);
  2075. if (pDrawArgs->nTextAlign & DT_VCENTER)
  2076. {
  2077. // try to center vertically because DT_VCENTER works only for DT_SINGLELINE;
  2079. ReplaceInHyperLinks(pDrawArgs->pItem, strText, XTP_HLINK_SPACE_X);
  2080. int nHeightRequired = CalculateRowHeight(pDrawArgs->pDC, strText, rcItem.Width(), bWordBreak);
  2081. int nHeightDiff = rcItem.Height() - nHeightRequired;
  2083. if (nHeightDiff >= 4)
  2084. {
  2085. rcItem.top += nHeightDiff/2 - 2;
  2086. }
  2088. strText = pMetrics->strText;
  2089. }
  2091. DrawMultiLineText(pDrawArgs, strText, rcItem, bWordBreak);
  2092. }
  2093. else
  2094. {
  2095. int nCharCount = 0;
  2096. int nHyperlink = 0;
  2097. DrawTextLine(pDrawArgs, strText, rcItem, DT_END_ELLIPSIS, nCharCount, nHyperlink);
  2098. }
  2099. }
  2100. }
  2102. void CXTPReportPaintManager::DrawItemControl(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, CXTPReportRecordItemControl* pControl, CRect& rcItem)
  2103. {
  2104. if(!pControl)
  2105. return;
  2106. CXTPFontDC dc(pDrawArgs->pDC, pControl->GetFont(), pControl->GetCaptionColor());
  2107. CRect rcControl = rcItem;
  2108. // calculate control's rectangle
  2109. // horizontal
  2110. int nControlWidth = pControl->GetSize().cx;
  2111. if(nControlWidth > 0)
  2112. {
  2113. if(pControl->GetAlignment() == xtpItemControlRight)
  2114. {
  2115. rcControl.left = rcControl.right - nControlWidth;
  2116. rcItem.right -= nControlWidth;
  2117. }
  2118. else
  2119. {
  2120. rcControl.right = rcControl.left + nControlWidth;
  2121. rcItem.left += nControlWidth;
  2122. }
  2123. }
  2124. else
  2125. {
  2126. rcItem.right = rcItem.left;
  2127. }
  2128. // vertical
  2129. int nControlHeight = pControl->GetSize().cy;
  2130. if(nControlHeight > 0 && nControlHeight < rcItem.Height())
  2131. {
  2132. rcControl.top = rcItem.top + (rcItem.Height() - nControlHeight) / 2;
  2133. rcControl.bottom = rcControl.top + nControlHeight;
  2134. }
  2135. //  else
  2136. //      rcControl.DeflateRect(0, 1);
  2137. // handle alignment
  2138. // set control's rectangle
  2139. pControl->SetRect(rcControl);
  2140. switch (pControl->GetType())
  2141. {
  2142. case xtpItemControlTypeButton :
  2143. {
  2144. // draw button
  2145. CXTPReportRecordItemButton* pButton = DYNAMIC_DOWNCAST(CXTPReportRecordItemButton, pControl);
  2146. ASSERT(pButton);
  2147. pDrawArgs->pDC->FillSolidRect(rcControl, GetXtremeColor(COLOR_3DFACE));
  2148. int nState = pButton->GetEnable() ? pButton->GetState() : PBS_DISABLED;
  2149. if(pButton->GetThemed())
  2150. {
  2151. m_themeButton.DrawThemeBackground(*pDrawArgs->pDC, BP_PUSHBUTTON, nState, rcControl, 0);
  2152. }
  2153. else
  2154. {
  2155. //              pDrawArgs->pDC->DrawFrameControl(&rcControl, DFC_BUTTON, DFCS_BUTTONPUSH | (nState == PBS_PRESSED ? DFCS_PUSHED : 0));
  2156. if (nState == PBS_PRESSED)
  2157. {
  2158. pDrawArgs->pDC->Draw3dRect(rcControl, GetXtremeColor(COLOR_3DDKSHADOW), GetXtremeColor(COLOR_WINDOW));
  2159. }
  2160. else
  2161. {
  2162. pDrawArgs->pDC->Draw3dRect(rcControl, GetXtremeColor(COLOR_3DFACE), GetXtremeColor(COLOR_3DDKSHADOW));
  2163. rcControl.DeflateRect(1, 1);
  2164. pDrawArgs->pDC->Draw3dRect(rcControl, GetXtremeColor(COLOR_WINDOW), GetXtremeColor(COLOR_3DSHADOW));
  2165. }
  2166. }
  2167. // calculate rectangle for drawing icon or caption
  2168. if(nState == PBS_PRESSED)
  2169. rcControl.DeflateRect(3, 3, 1, 1);
  2170. else
  2171. rcControl.DeflateRect(1, 1);
  2172. // draw button icon
  2173. int nIconIndex = pButton->GetIconIndex(nState);
  2174. if(nIconIndex != XTP_REPORT_NOICON)
  2175. {
  2176. //              DrawBitmap(pDrawArgs->pDC, pDrawArgs->pControl, rcControl, nIconIndex);
  2177. CXTPImageManagerIcon* pIcon = pDrawArgs->pControl->GetImageManager()->GetImage(nIconIndex, 0);
  2178. if(pIcon)
  2179. {
  2180. CSize szImage(pIcon->GetWidth(), pIcon->GetHeight());
  2181. CPoint ptIcon(max(rcControl.left, rcControl.left + (rcControl.Width() - szImage.cx) / 2),
  2182. max(rcControl.top, rcControl.top + (rcControl.Height() - szImage.cy) / 2));
  2183. szImage.cx = min(szImage.cx, rcControl.Width());
  2184. szImage.cy = min(szImage.cy, rcControl.Height());
  2185. if(pDrawArgs->pDC->IsPrinting())
  2186. {
  2187. CBitmap bmp;
  2188. bmp.CreateCompatibleBitmap(pDrawArgs->pDC, szImage.cx, szImage.cy);
  2189. CXTPCompatibleDC dcMem(NULL, &bmp);
  2190. dcMem.FillSolidRect(0, 0, szImage.cx, szImage.cy, GetXtremeColor(COLOR_3DFACE));
  2191. pIcon->Draw(&dcMem, CPoint(0, 0), pIcon->GetIcon());
  2192. pDrawArgs->pDC->BitBlt(ptIcon.x, ptIcon.y, szImage.cx, szImage.cy, &dcMem, 0, 0, SRCCOPY);
  2193. }
  2194. else
  2195. pIcon->Draw(pDrawArgs->pDC, ptIcon, pIcon->GetIcon(), szImage);
  2196. }
  2197. }
  2198. // draw button caption
  2199. if(!pButton->GetCaption().IsEmpty())
  2200. {
  2201. COLORREF clrPrev = pDrawArgs->pDC->SetTextColor(pButton->GetEnable() ? pButton->GetCaptionColor() : GetXtremeColor(XPCOLOR_GRAYTEXT));
  2202. pDrawArgs->pDC->DrawText(pButton->GetCaption(), rcControl, DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE);
  2203. pDrawArgs->pDC->SetTextColor(clrPrev);
  2204. }
  2205. break;
  2206. }
  2207. }
  2208. }
  2210. void CXTPReportPaintManager::ReplaceInHyperLinks(CXTPReportRecordItem* pItem, CString& rstrText, TCHAR chReplace )
  2211. {
  2212. ASSERT(pItem);
  2213. if (!pItem)
  2214. return;
  2216. int nHyperlinks = pItem->GetHyperlinksCount();
  2217. for (int nHLink = 0; nHLink < nHyperlinks; nHLink++)
  2218. {
  2219. CXTPReportHyperlink* pHLink = pItem->GetHyperlinkAt(nHLink);
  2220. ASSERT(pHLink);
  2221. if (!pHLink)
  2222. continue;
  2224. int nI0 = max(0, min(pHLink->m_nHyperTextBegin, rstrText.GetLength()-1));
  2225. int nI1 = max(0, min(pHLink->m_nHyperTextBegin + pHLink->m_nHyperTextLen, rstrText.GetLength()));
  2226. for (int i = nI0; i < nI1; i++)
  2227. {
  2228. if(rstrText.GetAt(i) == _T(' '))
  2229. {
  2230. rstrText.SetAt(i, chReplace);
  2231. }
  2232. }
  2233. }
  2234. }
  2236. void CXTPReportPaintManager::DrawMultiLineText(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, const CString& strText,
  2237. CRect rcItem, BOOL bWordBreak)
  2238. {
  2239. CDC* pDC = pDrawArgs->pDC;
  2240. CXTPReportRecordItem* pItem = pDrawArgs->pItem;
  2242. int nCurrStrPos = 0, nStringWidth = 0, nWordWidth = 0;
  2243. int nStartString = -1, nEndString = -1;
  2245. CRect rcText;
  2246. rcText.CopyRect(&rcItem);
  2248. if (0 == pItem->GetHyperlinksCount())
  2249. {
  2250. // no hyperlinks
  2251. pDC->DrawText(strText, rcText, DT_NOPREFIX | pDrawArgs->nTextAlign | DT_WORD_ELLIPSIS | (bWordBreak ?  DT_WORDBREAK : 0));
  2252. return;
  2253. }
  2255. int nLineHeight = pDC->GetTextExtent(_T(" "), 1).cy;
  2256. CString strSrc = strText + _T(" ");
  2257. REPLACE_S(strSrc, _T('r'), _T(' '));
  2259. ReplaceInHyperLinks(pItem, strSrc, XTP_HLINK_SPACE_X);
  2261. CString strWord, strString;
  2262. int nTextLength = strSrc.GetLength();
  2264. TCHAR* lpszBuff = strSrc.GetBuffer(nTextLength + 1);
  2265. TCHAR  cChar = lpszBuff[nCurrStrPos];
  2267. int     nWordLength = 0;
  2268. TCHAR*  lpszWord = strWord.GetBuffer(nTextLength + 1);
  2270. // parsing for the words (tokens)
  2271. while (_T('') != (cChar = lpszBuff[nCurrStrPos++]))
  2272. {
  2273. if (cChar == _T(' ') || cChar == _T('t') || cChar == _T('n'))
  2274. {
  2275. if (lpszWord[0] == _T('') && cChar != _T('n'))
  2276. continue;
  2278. if (strString.IsEmpty())
  2279. {
  2280. nStartString = nCurrStrPos - nWordLength;
  2281. nEndString = nCurrStrPos;
  2282. }
  2283. nWordWidth = GetTextExtentX(pDC, lpszWord, nWordLength);
  2285. if (nWordWidth > rcItem.Width() && bWordBreak || cChar == _T('n'))
  2286. {
  2287. if (!strString.IsEmpty())
  2288. {
  2289. DrawSingleLineText(pDrawArgs,  strSrc , rcText, nStartString-1, nEndString-1,
  2290. GetTextExtentX(pDC,strString));
  2292. rcText.top += nLineHeight;
  2293. rcText.left = rcItem.left;
  2294. }
  2296. // the word exceeds the cell's width
  2297. DrawSingleLineText(pDrawArgs, strSrc , rcText, nCurrStrPos - nWordLength -1, nCurrStrPos -1, nWordWidth);
  2299. if((nCurrStrPos - nWordLength) != nCurrStrPos)
  2300. {
  2301. rcText.top += nLineHeight;
  2302. rcText.left = rcItem.left;
  2303. }
  2305. strString.Empty();
  2307. lpszWord[0] = _T('');
  2308. nWordLength = 0;
  2309. continue;
  2310. }
  2312. int nPrevStringWidth = GetTextExtentX(pDC,strString);
  2314. if (!strString.IsEmpty())
  2315. strString += _T(" ");
  2317. strString += lpszWord;
  2318. nStringWidth = GetTextExtentX(pDC,strString);
  2320. if (nStringWidth > rcItem.Width() && bWordBreak)
  2321. {
  2322. DrawSingleLineText(pDrawArgs,  strSrc , rcText, nStartString-1, nEndString-1,
  2323. nPrevStringWidth);
  2325. rcText.top += nLineHeight;
  2326. rcText.left = rcItem.left;
  2329. nStartString = nCurrStrPos - nWordLength;
  2330. strString = lpszWord;
  2331. }
  2333. nEndString = nCurrStrPos;
  2334. lpszWord[0] = _T('');
  2335. nWordLength = 0;
  2336. continue;
  2337. }
  2339. ASSERT(nWordLength <= nTextLength);
  2340. lpszWord[nWordLength] = cChar;
  2341. lpszWord[nWordLength + 1] = _T('');
  2343. ++nWordLength;
  2344. }
  2346. // the rest of the string
  2347. if (strString.GetLength())
  2348. {
  2349. DrawSingleLineText(pDrawArgs,  strSrc , rcText, nStartString-1, strText.GetLength(),
  2350. GetTextExtentX(pDC,strString));
  2351. }
  2353. }
  2355. void CXTPReportPaintManager::DrawSingleLineText(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs,const CString& strText,
  2356. CRect rcItem, int nStartPos, int nEndPos,int nActualWidth )
  2357. {
  2359. CDC* pDC = pDrawArgs->pDC;
  2360. CXTPReportRecordItem* pItem = pDrawArgs->pItem;
  2361. CXTPReportHyperlink* pHl = NULL;
  2363. // alignment
  2364. CRect   rcText(rcItem);
  2365. int nFlag = pDrawArgs->nTextAlign & (DT_LEFT | DT_RIGHT | DT_CENTER);
  2367. if (nFlag & DT_RIGHT)
  2368. rcText.left = rcText.right - nActualWidth;
  2369. else
  2370. if (nFlag & DT_CENTER)
  2371. rcText.left += (rcText.Width() - nActualWidth) / 2;
  2373. // Left align the string, that exceeds the cell's width.
  2374. rcText.left = max(rcText.left, rcItem.left);
  2376. int nCurrDrawPos = rcText.left;
  2377. int nHyperlink = 0; // Hyperlink index
  2378. int nCurrStrPos = nStartPos;
  2379. int nBeginHyperlink = 0xFFFF;
  2380. int nHyperlinks = pItem->GetHyperlinksCount();
  2382. CString strWord, strPre, strPost, strSrc = strText + _T(" ");
  2383. TCHAR* lpszBuff = strSrc.GetBuffer(strSrc.GetLength());
  2384. TCHAR  cChar = lpszBuff[nCurrStrPos];
  2385. BOOL  bNeedsBlank = FALSE;
  2387. int   nBlankWidth = GetTextExtentX(pDC, _T(" "), 1);
  2389. while (nCurrStrPos <= nEndPos && _T('') != (cChar = lpszBuff[nCurrStrPos++]))
  2390. {
  2391. if (cChar == _T(' ') || cChar == _T('t') || cChar == _T('n'))
  2392. {
  2393. if (strWord.IsEmpty())
  2394. continue;
  2396. if (bNeedsBlank)
  2397. {
  2398. // between words
  2399. pDC->DrawText(_T(" "), rcText, DT_LEFT);
  2400. rcText.left += nBlankWidth;
  2401. }
  2403. // as hyperlinks are not sorted in the array, check all
  2404. for (nHyperlink = 0; nHyperlink < nHyperlinks; ++nHyperlink)
  2405. {
  2406. pHl = pItem->GetHyperlinkAt(nHyperlink);
  2407. nBeginHyperlink = pHl->m_nHyperTextBegin;
  2409. // validate the hyperlink
  2410. if (nBeginHyperlink >= 0 &&
  2411. nBeginHyperlink <= strText.GetLength() - 1                  &&
  2412. pHl->m_nHyperTextLen > 1                                    &&
  2413. nBeginHyperlink + pHl->m_nHyperTextLen <= strText.GetLength())
  2414. {
  2415. // particular case: hyperlink begins with blank(s)
  2416. BOOL bInclude = FALSE;
  2417. if (nStartPos > nBeginHyperlink )
  2418. {
  2419. CString strExtracted = strText.Mid(nBeginHyperlink, nStartPos - nBeginHyperlink);
  2420. if (_tcsspnp(strExtracted.GetBuffer(strExtracted.GetLength()),_T(" ")) == NULL)
  2421. bInclude = TRUE;
  2422. }
  2424. // does the hyperlink belong to the string
  2425. if (nBeginHyperlink >= nStartPos &&
  2426. nBeginHyperlink + pHl->m_nHyperTextLen <= nEndPos ||
  2427. bInclude)
  2428. {
  2430. // does the word contain the hyperlink
  2431. CString strExtracted = strText.Mid(nBeginHyperlink,pHl->m_nHyperTextLen);
  2432. strExtracted.TrimLeft();
  2433. if (strWord.Find(strExtracted) != -1)
  2434. {
  2435. if (nBeginHyperlink < nCurrStrPos)
  2436. {
  2437. // before hyperlink
  2438. strPre = strWord.Mid(0,strWord.GetLength() - (nCurrStrPos - nBeginHyperlink - 1));
  2439. if (!strPre.IsEmpty())
  2440. {
  2441. pDC->DrawText(strPre, rcText, DT_LEFT | DT_END_ELLIPSIS | DT_NOPREFIX);
  2442. rcText.left += GetTextExtentX(pDC,strPre);
  2443. }
  2445. // the hyperlink
  2446. nCurrDrawPos = rcText.left;
  2447. DrawLink2(&nCurrDrawPos,pDrawArgs,pHl,strText,rcText, DT_LEFT | DT_END_ELLIPSIS, TRUE);
  2448. rcText.left = nCurrDrawPos;
  2450. // after hyperlink
  2451. int n = strWord.GetLength() - (nCurrStrPos - (nBeginHyperlink+pHl->m_nHyperTextLen +1));
  2452. if (n >=0 && (strWord.GetLength() - n) > 0)
  2453. {
  2454. strPost = strWord.Mid(n,strWord.GetLength() - n);
  2455. if (!strPost.IsEmpty())
  2456. {
  2457. pDC->DrawText(strPost, rcText, DT_LEFT | DT_END_ELLIPSIS | DT_NOPREFIX);
  2458. rcText.left += GetTextExtentX(pDC,strPost);
  2459. }
  2460. }
  2462. strWord.Empty();
  2463. bNeedsBlank = TRUE;
  2464. continue;
  2465. }
  2466. }
  2467. }
  2468. }
  2469. } // the hyperlink validation
  2471. // non-hyperlink words
  2472. pDC->DrawText(strWord, rcText, DT_LEFT | DT_END_ELLIPSIS | DT_NOPREFIX);
  2473. rcText.left += GetTextExtentX(pDC,strWord);
  2475. strWord.Empty();
  2476. bNeedsBlank = TRUE;
  2477. continue;
  2478. }
  2480. strWord += cChar;
  2481. }
  2482. }
  2484. int CXTPReportPaintManager::CalculateRowHeight(CDC* pDC, const CString& strText, int nMaxWidth, BOOL bWordBreak)
  2485. {
  2486. CString strWord, strBuff(strText);
  2487. strBuff += _T(" ");
  2489. int     nLineHeight = pDC->GetTextExtent(_T(" "),1).cy;
  2490. int     nRowHeight = 0;
  2491. int     nCurrXPos = 0;
  2492. int     nCurrStrPos = 0;
  2493. int     nBlanksWidth = 0;
  2496. // just calculate new line characters
  2497. if (!bWordBreak)
  2498. {
  2499. int nCount = 0, nPos = -1;
  2501. do
  2502. {
  2503. nCount++;
  2504. nPos = FIND_S(strBuff, _T('n'), nPos + 1);
  2505. }
  2506. while(nPos != -1);
  2508. return nLineHeight * nCount;
  2509. }
  2511. int     nWordLength = 0;
  2512. BOOL    bNeedsLine = TRUE;
  2513. int     nBlankWidth = GetTextExtentX(pDC, _T(" "), 1);
  2514. int     nTextLength = strBuff.GetLength();
  2516. TCHAR*  lpszBuff = strBuff.GetBuffer(nTextLength + 1);
  2517. TCHAR   cChar = lpszBuff[nCurrStrPos];
  2519. TCHAR*  lpszWord = strWord.GetBuffer(nTextLength + 1);
  2521. // breaking the text by words
  2522. while (_T('') != (cChar = lpszBuff[nCurrStrPos++]))
  2523. {
  2524. if (cChar == _T(' ') || cChar == _T('t') || cChar == _T('n'))
  2525. {
  2526. nBlanksWidth += nBlankWidth;
  2528. if (lpszWord[0] == _T('') && cChar != _T('n'))
  2529. continue;
  2531. int nWordWidth = GetTextExtentX(pDC, lpszWord, nWordLength);
  2533. if (nWordWidth >= nMaxWidth)
  2534. {
  2535. // the word exceeds the cell's width
  2536. nRowHeight += nLineHeight;
  2538. if (nCurrXPos > 0)
  2539. nRowHeight += nLineHeight; // for the preceding line (regardless of its size)
  2541. bNeedsLine = FALSE;
  2542. nCurrXPos = 0;
  2543. nBlanksWidth = 0;
  2545. lpszWord[0] = _T('');
  2546. nWordLength = 0;
  2547. continue;
  2548. }
  2550. if (nCurrXPos + nWordWidth >= nMaxWidth)
  2551. {
  2552. nCurrXPos = nWordWidth + nBlanksWidth;
  2553. nRowHeight += nLineHeight;
  2554. }
  2555. else
  2556. {
  2557. nCurrXPos += nWordWidth + nBlanksWidth;
  2558. bNeedsLine = TRUE;
  2559. }
  2561. if (cChar == _T('n')) // a new line is forced
  2562. {
  2563. nRowHeight += nLineHeight;
  2564. nCurrXPos = 0;
  2565. }
  2567. nBlanksWidth = 0;
  2568. lpszWord[0] = _T('');
  2569. nWordLength = 0;
  2570. continue;
  2571. }
  2573. ASSERT(nWordLength <= nTextLength);
  2574. lpszWord[nWordLength] = cChar;
  2575. lpszWord[nWordLength+1] = _T('');
  2577. ++nWordLength;
  2578. }
  2580. if (bNeedsLine)
  2581. nRowHeight += nLineHeight;
  2583. return nRowHeight;
  2584. }
  2586. int CXTPReportPaintManager::DrawLink2(int* pnCurrDrawPos, XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, CXTPReportHyperlink* pHyperlink,
  2587. CString strText, CRect rcLink, int nFlag, BOOL bTrim )
  2588. {
  2589. int nCount = pHyperlink->m_nHyperTextLen;
  2591. int nDiff = pHyperlink->m_nHyperTextBegin + pHyperlink->m_nHyperTextLen - strText.GetLength();
  2592. if (nDiff > 0)
  2593. nCount = max(0, pHyperlink->m_nHyperTextLen - nDiff);
  2595. if (pHyperlink->m_nHyperTextBegin < 0 || pHyperlink->m_nHyperTextBegin >= strText.GetLength() ||
  2596. nCount <= 0)
  2597. return 0;
  2599. CDC* pDC = pDrawArgs->pDC;
  2600. CString strOut = strText.Mid(pHyperlink->m_nHyperTextBegin, nCount);
  2602. if (bTrim)
  2603. {
  2604. strOut.TrimLeft();
  2605. strOut.TrimRight();
  2606. }
  2607. REPLACE_S(strOut, XTP_HLINK_SPACE_X, _T(' '));
  2609. BOOL bSelected = pDrawArgs->pRow->IsSelected() && pDrawArgs->pRow->GetControl()->HasFocus() &&
  2610. (!pDrawArgs->pColumn || !pDrawArgs->pRow->GetControl()->GetFocusedColumn() ||
  2611.   pDrawArgs->pColumn != pDrawArgs->pRow->GetControl()->GetFocusedColumn());
  2613. COLORREF clrPrev = pDC->SetTextColor(bSelected ? m_clrHighlightText : m_clrHyper);
  2615. TEXTMETRIC textMetrics;
  2616. pDC->GetTextMetrics(&textMetrics);
  2617. int nCharCount = 0;
  2618. //!pHyperlink->m_rcHyperSpot.left = pDC->GetCurrentPosition().x; // update hyperlink left bound before drawing
  2619. pHyperlink->m_rcHyperSpot.left = *pnCurrDrawPos;
  2620. nCharCount = DrawString(pnCurrDrawPos, pDC, strOut, rcLink, nFlag);
  2622. // update hyperlink spot
  2623. pHyperlink->m_rcHyperSpot.top = rcLink.top;
  2624. //!pHyperlink->m_rcHyperSpot.right = pDC->GetCurrentPosition().x;
  2625. pHyperlink->m_rcHyperSpot.right = *pnCurrDrawPos;
  2626. pHyperlink->m_rcHyperSpot.bottom = rcLink.top + textMetrics.tmHeight;
  2628. pDC->SetTextColor(clrPrev);
  2630. return nCharCount;
  2631. }
  2633. void CXTPReportPaintManager::DrawFixedRowsDivider(CDC* pDC, const CRect& rc, CXTPReportControl* pControl, BOOL bHeaderRows, BOOL bVScrollBarVisible)
  2634. {
  2635. int nDividerStyle = bHeaderRows ? m_HeaderRowsDividerStyle : m_FooterRowsDividerStyle;
  2636. COLORREF clr =  bHeaderRows ? m_clrHeaderRowsDivider : m_clrFooterRowsDivider;
  2638. if (nDividerStyle == xtpReportFixedRowsDividerNone)
  2639. return;
  2641. if (nDividerStyle & xtpReportFixedRowsDividerOutlook)
  2642. {
  2643. if (m_columnStyle == xtpReportColumnShaded)
  2644. {
  2645. pDC->FillSolidRect(rc, m_clrHeaderControl);
  2646. DrawHorizontalLine(pDC, rc.left, rc.bottom - 2, rc.Width(), MixColor(m_clrHeaderControl, m_clrControlDark, 0.4));
  2647. DrawHorizontalLine(pDC, rc.left, rc.bottom - 1, rc.Width(), MixColor(m_clrHeaderControl, m_clrControlDark, 0.6));
  2648. }
  2649. else if (m_columnStyle == xtpReportColumnOffice2003)
  2650. {
  2651. XTPDrawHelpers()->GradientFill(pDC, rc,m_grcGradientColumn.clrLight, m_grcGradientColumn.clrDark,FALSE);
  2652. DrawHorizontalLine(pDC, rc.left, rc.bottom - 1, rc.Width(), m_clrGradientColumnShadow);
  2653. }
  2654. else if (m_columnStyle == xtpReportColumnOffice2007)
  2655. {
  2656. pDC->FillSolidRect(rc,  MixColor(m_grcGradientColumn.clrLight, m_grcGradientColumn.clrDark, 0.4));
  2657. DrawHorizontalLine(pDC, rc.left, rc.top, rc.Width(), RGB(255, 255, 255));
  2658. DrawHorizontalLine(pDC, rc.left, rc.bottom - 1, rc.Width(), m_clrGradientColumnSeparator);
  2659. }
  2660. else if (m_columnStyle == xtpReportColumnExplorer)
  2661. {
  2662. pDC->FillSolidRect(rc, m_clrHeaderControl);
  2663. pDC->Draw3dRect(rc, m_clrControlLightLight, m_clrBtnText);
  2665. CRect rcTmp(rc);
  2666. rcTmp.DeflateRect(1, 1);
  2667. pDC->Draw3dRect(rcTmp, m_clrHeaderControl, m_clrControlDark);
  2668. }
  2669. else
  2670. {
  2671. pDC->FillSolidRect(rc, m_clrHeaderControl);
  2672. pDC->Draw3dRect(rc, m_clrControlLightLight, m_clrControlDark);
  2673. }
  2674. }
  2675. else
  2676. {
  2677. if (nDividerStyle & xtpReportFixedRowsDividerThin || nDividerStyle & xtpReportFixedRowsDividerBold)
  2678. {
  2679. pDC->FillSolidRect(rc, clr);
  2680. }
  2681. }
  2683. // draw shade (if necessary)
  2684. int nScrollPos = pControl->GetScrollPos(SB_VERT);
  2685. int nScrollLimit = pControl->GetScrollLimit(SB_VERT);
  2687. SCROLLINFO si;
  2688. pControl->GetScrollInfo(SB_VERT,&si);
  2690. if (nDividerStyle & xtpReportFixedRowsDividerShade)
  2691. {
  2692. if (bHeaderRows)
  2693. {
  2694. // header rows
  2695. if (nScrollPos)
  2696. {
  2697. CRect rcShade(rc);
  2698. rcShade.top = rcShade.bottom;
  2699. rcShade.bottom += 4;
  2701. XTPDrawHelpers()->GradientFill(pDC, rcShade, clr, RGB(255, 255, 255), FALSE);
  2702. }
  2703. }
  2704. else
  2705. // footer rows
  2706. if (bVScrollBarVisible && nScrollPos != nScrollLimit) // && (UINT)si.nMax != si.nPage)
  2707. {
  2708. CRect rcShade(rc);
  2709. rcShade.bottom = rcShade.top;
  2710. rcShade.top -= 4;
  2712. XTPDrawHelpers()->GradientFill(pDC, rcShade, RGB(255, 255, 255), clr, FALSE);
  2713. }
  2714. }
  2715. }
  2717. int CXTPReportPaintManager::GetHeaderRowsDividerHeight()
  2718. {
  2719. int nHeight = 0;
  2721. switch(m_HeaderRowsDividerStyle & ~xtpReportFixedRowsDividerShade)
  2722. {
  2723. case xtpReportFixedRowsDividerNone:     nHeight = 0; break;
  2724. case xtpReportFixedRowsDividerThin:     nHeight = 1; break;
  2725. case xtpReportFixedRowsDividerBold:     nHeight = 2; break;
  2726. case xtpReportFixedRowsDividerOutlook:  nHeight = 8; break;
  2727. }
  2729. return nHeight;
  2730. }
  2732. int CXTPReportPaintManager::GetFooterRowsDividerHeight()
  2733. {
  2734. int nHeight = 0;
  2736. switch(m_FooterRowsDividerStyle & ~xtpReportFixedRowsDividerShade)
  2737. {
  2738. case xtpReportFixedRowsDividerNone:     nHeight = 0; break;
  2739. case xtpReportFixedRowsDividerThin:     nHeight = 1; break;
  2740. case xtpReportFixedRowsDividerBold:     nHeight = 2; break;
  2741. case xtpReportFixedRowsDividerOutlook:  nHeight = 8; break;
  2742. }
  2744. return nHeight;
  2745. }