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

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

对话框与窗口

开发平台：

Visual C++

XTPReportControl.cpp：源码内容
  1. // XTPReportControl.cpp : implementation of the CXTPReportControl 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/XTPDrawHelpers.h"
  25. #include "Common/XTPSystemHelpers.h"
  26. #include "Common/XTPImageManager.h"
  27. #include "Common/XTPVC80Helpers.h"
  28. #include "Common/XTPVC50Helpers.h"
  29. #include "Common/XTPPropExchange.h"
  30. #include "Common/XTPToolTipContext.h"
  31. #include "Common/XTPResourceManager.h"
  33. #include "XTPReportRecordItem.h"
  34. #include "XTPReportRecordItemText.h"
  35. #include "XTPReportRecord.h"
  36. #include "XTPReportRecords.h"
  37. #include "XTPReportHeader.h"
  38. #include "XTPReportColumn.h"
  39. #include "XTPReportColumns.h"
  40. #include "XTPReportRow.h"
  41. #include "XTPReportRows.h"
  42. #include "XTPReportControl.h"
  43. #include "XTPReportPaintManager.h"
  44. #include "XTPReportNavigator.h"
  45. #include "XTPReportFilterEditControl.h"
  46. #include "XTPReportSubListControl.h"
  47. #include "XTPReportGroupRow.h"
  48. #include "XTPReportInplaceControls.h"
  50. #include <locale.h>
  52. #ifdef _DEBUG
  53. #define new DEBUG_NEW
  54. #undef THIS_FILE
  55. static char THIS_FILE[] = __FILE__;
  56. #endif
  58. #define XTP_REPORT_HSCROLL_STEP 7
  60. #define XTP_REPORT_AUTO_SCROLL_TIMER_ID 7
  61. #define XTP_REPORT_AUTO_SCROLL_TIMER_RESOLUTION_MS  200
  63. #define XTP_REPORT_CB_RECORDS_DATA_VER 1
  65. #define ASSERT_DBG_REMOVE_RECORD_EX
  66. //#define XTP_DBG_REMOVE_RECORD_EX_ASSERT ASSERT
  69. //////////////////////////////////////////////////////////////////////////
  70. XTP_IMPLEMENT_HEAP_ALLOCATOR(CXTPReportDataAllocator, FALSE)
  71. XTP_IMPLEMENT_HEAP_ALLOCATOR(CXTPReportRowAllocator, FALSE)
  73. // to allocate in app default heap
  74. XTP_IMPLEMENT_HEAP_ALLOCATOR(CXTPReportAllocatorDefault, FALSE)
  77. class CXTPReportRow_Batch : public CXTPBatchAllocObjT<CXTPReportRow, CXTPReportRow_BatchData> {};
  78. class CXTPReportGroupRow_Batch : public CXTPBatchAllocObjT<CXTPReportGroupRow, CXTPReportGroupRow_BatchData> {};
  80. XTP_IMPLEMENT_BATCH_ALLOC_OBJ_DATA(CXTPReportRow_BatchData, CXTPReportRow_Batch, FALSE)
  81. XTP_IMPLEMENT_BATCH_ALLOC_OBJ_DATA(CXTPReportGroupRow_BatchData, CXTPReportGroupRow_Batch, FALSE)
  83. //===========================================================================
  84. BOOL CXTPReportControl::UseReportCustomHeap()
  85. {
  86. ASSERT(CXTPReportDataAllocator::ms_dwRefs == 0 || CXTPReportDataAllocator::ms_bUseCustomHeap);
  87. ASSERT(CXTPReportRowAllocator::ms_dwRefs == 0 || CXTPReportRowAllocator::ms_bUseCustomHeap);
  89. if (CXTPReportDataAllocator::ms_dwRefs == 0)
  90. CXTPReportDataAllocator::ms_bUseCustomHeap = TRUE;
  92. if (CXTPReportRowAllocator::ms_dwRefs == 0)
  93. CXTPReportRowAllocator::ms_bUseCustomHeap = TRUE;
  95. return CXTPReportDataAllocator::ms_bUseCustomHeap &&
  96. CXTPReportRowAllocator::ms_bUseCustomHeap;
  97. }
  99. BOOL CXTPReportControl::UseRowBatchAllocation()
  100. {
  101. ASSERT(CXTPReportRow_BatchData::IsDataEmpty() || CXTPReportRow_BatchData::m_bBatchAllocationEnabled);
  102. ASSERT(CXTPReportGroupRow_BatchData::IsDataEmpty() || CXTPReportGroupRow_BatchData::m_bBatchAllocationEnabled);
  104. if (CXTPReportRow_BatchData::IsDataEmpty())
  105. CXTPReportRow_BatchData::m_bBatchAllocationEnabled = TRUE;
  107. if (CXTPReportGroupRow_BatchData::IsDataEmpty())
  108. CXTPReportGroupRow_BatchData::m_bBatchAllocationEnabled = TRUE;
  110. return CXTPReportRow_BatchData::m_bBatchAllocationEnabled &&
  111. CXTPReportGroupRow_BatchData::m_bBatchAllocationEnabled;
  112. }
  114. void CXTPReportControl::FreeRowBatchExtraData()
  115. {
  116. CXTPReportRow_Batch::FreeExtraData();
  117. CXTPReportGroupRow_Batch::FreeExtraData();
  118. }
  120. //////////////////////////////////////////////////////////////////////////
  121. BOOL CXTPReportControlLocale::s_bUseResourceFileLocale = FALSE;
  123. CArray<CXTPReportControlLocale::XTP_TIMESPEC, CXTPReportControlLocale::XTP_TIMESPEC&>
  124. CXTPReportControlLocale::s_arMappedSpecs;
  126. //===========================================================================
  127. BOOL CXTPReportControlLocale::IsUseResourceFileLocale()
  128. {
  129. return s_bUseResourceFileLocale;
  130. }
  132. void CXTPReportControlLocale::SetUseResourceFileLocale(BOOL bUseResourceFileLocale)
  133. {
  134. s_bUseResourceFileLocale = bUseResourceFileLocale;
  135. }
  137. LCID CXTPReportControlLocale::GetActiveLCID()
  138. {
  139. LCID lcidCurr = LOCALE_USER_DEFAULT;
  141. if (s_bUseResourceFileLocale)
  142. lcidCurr = MAKELCID(XTPResourceManager()->GetResourcesLangID(), SORT_DEFAULT);
  144. return lcidCurr;
  145. }
  147. BOOL AFX_CDECL CXTPReportControlLocale::VariantChangeTypeEx(VARIANT& rVarValue, VARTYPE vartype, BOOL bThrowError)
  148. {
  149. if (vartype != rVarValue.vt)
  150. {
  151. LCID lcID = GetActiveLCID();
  153. HRESULT hr = ::VariantChangeTypeEx(&rVarValue, &rVarValue, lcID, 0, vartype);
  155. if (bThrowError && FAILED(hr))
  156. {
  157. if (hr == E_OUTOFMEMORY)
  158. AfxThrowMemoryException();
  159. else
  160. AfxThrowOleException(hr);
  161. }
  164. return SUCCEEDED(hr);
  165. }
  166. return TRUE;
  167. }
  169. CString AFX_CDECL CXTPReportControlLocale::FormatDateTime(const COleDateTime& dt, LPCTSTR lpcszFormatString)
  170. {
  171. return _FormatDateTime(dt, lpcszFormatString, GetActiveLCID());
  172. }
  174. CString CXTPReportControlLocale::_FormatDateTime(const COleDateTime& dt, LPCTSTR lpcszFormatString, LCID lcLocaleID)
  175. {
  176. if (dt.GetStatus() != COleDateTime::valid)
  177. {
  178. ASSERT(dt.GetStatus() == COleDateTime::null);
  179. return _T("");
  180. }
  182. CString strDT = lpcszFormatString;
  184. SYSTEMTIME sysTime;
  185. if (!GETASSYSTEMTIME_DT(dt, sysTime))
  186. {
  187. ASSERT(FALSE);
  188. return _T("");
  189. }
  191. //  %% Percent sign
  192. REPLACE_S(strDT, _T("%%"), _T("x1"));
  194. _ProcessMappedSpecs(strDT, &sysTime, lcLocaleID);
  195. _ProcessDateTimeSpecs(strDT, &sysTime, lcLocaleID);
  197. // All locale dependent specifiers already processed
  198. _ProcessOtherSpecs(strDT, dt);
  200. REPLACE_S(strDT, _T("x1"), _T("%"));
  202. return strDT;
  203. }
  205. void CXTPReportControlLocale::_ProcessMappedSpecs(CString& rstrFormat, const SYSTEMTIME* pST, LCID lcLocaleID)
  206. {
  207. _InitMappedSpecs();
  209. const int cnBufferSize = 96;
  210. TCHAR szBuffer[cnBufferSize];
  212. int nCount = (int)s_arMappedSpecs.GetSize();
  213. for (int i = 0; i < nCount; i++)
  214. {
  215. const XTP_TIMESPEC& specI = s_arMappedSpecs.ElementAt(i);
  216. if (FIND_S(rstrFormat, specI.pcszSpec, 0) < 0)
  217. continue;
  219. ::ZeroMemory(szBuffer, sizeof(szBuffer));
  221. int nResult;
  222. if (specI.bTime)
  223. {
  224. nResult = ::GetTimeFormat(lcLocaleID, 0, pST, specI.pcszFormat, szBuffer, cnBufferSize);
  225. }
  226. else
  227. {
  228. nResult = ::GetDateFormat(lcLocaleID, 0, pST, specI.pcszFormat, szBuffer, cnBufferSize);
  229. }
  230. ASSERT(nResult);
  231. if (nResult)
  232. {
  233. REPLACE_S(rstrFormat, specI.pcszSpec, szBuffer);
  234. }
  235. }
  236. }
  238. void CXTPReportControlLocale::_ProcessDateTimeSpecs(CString& rstrFormat, const SYSTEMTIME* pST, LCID lcLocaleID)
  239. {
  240. //  %c  Date and time representation appropriate for locale
  241. //  %#c Long date and time representation
  243. //  %x Date representation for current locale
  244. //  %#x Long date representation for current locale
  246. //  %X Time representation for current locale
  248. REPLACE_S(rstrFormat, _T("%c"), _T("%x %X"));
  249. REPLACE_S(rstrFormat, _T("%#c"), _T("%#x %X"));
  251. __ProcessDate_x(rstrFormat, pST, lcLocaleID);
  252. __ProcessTime_X(rstrFormat, pST, lcLocaleID);
  253. }
  255. void CXTPReportControlLocale::__ProcessDate_x(CString& rstrFormat, const SYSTEMTIME* pST, LCID lcLocaleID)
  256. {
  257. const int cnBufferSize = 96;
  258. TCHAR szBuffer[cnBufferSize];
  260. //  %x Date representation for current locale
  261. //  %#x Long date representation for current locale
  263. TCHAR* arSpec2[2] = {_T("%x"), _T("%#x")};
  265. for (int i = 0; i < 2; i++)
  266. {
  267. if (FIND_S(rstrFormat, arSpec2[i], 0) >= 0)
  268. {
  269. ::ZeroMemory(szBuffer, sizeof(szBuffer));
  271. DWORD dwFlags = (i == 0) ? DATE_SHORTDATE : DATE_LONGDATE;
  273. int nRes = ::GetDateFormat(lcLocaleID, dwFlags, pST, NULL, szBuffer, cnBufferSize);
  275. ASSERT(nRes);
  276. REPLACE_S(rstrFormat, arSpec2[i], szBuffer);
  277. }
  278. }
  279. }
  281. void CXTPReportControlLocale::__ProcessTime_X(CString& rstrFormat, const SYSTEMTIME* pST, LCID lcLocaleID)
  282. {
  283. if (FIND_S(rstrFormat, _T("%X"), 0) >= 0)
  284. {
  285. const int cnBufferSize = 96;
  286. TCHAR szBuffer[cnBufferSize];
  288. ::ZeroMemory(szBuffer, sizeof(szBuffer));
  289. int nRes = ::GetTimeFormat(lcLocaleID, 0, pST, NULL, szBuffer, cnBufferSize);
  291. ASSERT(nRes);
  292. REPLACE_S(rstrFormat, _T("%X"), szBuffer);
  293. }
  294. }
  296. void CXTPReportControlLocale::_ProcessOtherSpecs(CString& rstrFormat, const COleDateTime& dt)
  297. {
  298. //  %j Day of year as decimal number (001 - 366)
  299. //  %w Weekday as decimal number (0 - 6; Sunday is 0)
  300. //  %U Week of year as decimal number, with Sunday as first day of week (00 - 53)
  301. //  %W Week of year as decimal number, with Monday as first day of week (00 - 53)
  302. //  %z, %Z  Either the time-zone name or time zone abbreviation, depending on registry settings; no characters if time zone is unknown
  304. static LPCTSTR arszSpecs[] = {  _T("%j"), _T("%#j"),
  305. _T("%w"), _T("%#w"),
  306. _T("%U"), _T("%#U"),
  307. _T("%W"), _T("%#W"),
  308. _T("%z"), _T("%Z") };
  310. int nCount = _countof(arszSpecs);
  311. for (int i = 0; i < nCount; i++)
  312. {
  313. if (FIND_S(rstrFormat, arszSpecs[i], 0) < 0)
  314. continue;
  316. CString str = dt.Format(arszSpecs[i]);
  318. REPLACE_S(rstrFormat, arszSpecs[i], str);
  319. }
  320. }
  322. void CXTPReportControlLocale::_InitMappedSpecs()
  323. {
  324. if (s_arMappedSpecs.GetSize())
  325. return;
  327. // date
  328. _AddsMappedSpec(_T("%a"), _T("ddd"),    FALSE);
  329. _AddsMappedSpec(_T("%A"), _T("dddd"),   FALSE);
  331. _AddsMappedSpec(_T("%b"), _T("MMM"),    FALSE);
  332. _AddsMappedSpec(_T("%B"), _T("MMMM"),   FALSE);
  334. _AddsMappedSpec(_T("%d"),  _T("dd"),    FALSE);
  335. _AddsMappedSpec(_T("%#d"), _T("d"),     FALSE);
  337. _AddsMappedSpec(_T("%m"),  _T("MM"),    FALSE);
  338. _AddsMappedSpec(_T("%#m"), _T("M"),     FALSE);
  340. _AddsMappedSpec(_T("%y"),  _T("yy"),    FALSE);
  341. _AddsMappedSpec(_T("%#y"), _T("y"),     FALSE);
  342. _AddsMappedSpec(_T("%Y"), _T("yyyy"),   FALSE);
  344. // time
  345. _AddsMappedSpec(_T("%H"),  _T("HH"),    TRUE);
  346. _AddsMappedSpec(_T("%#H"), _T("H"),     TRUE);
  348. _AddsMappedSpec(_T("%I"),  _T("hh"),    TRUE);
  349. _AddsMappedSpec(_T("%#I"), _T("h"),     TRUE);
  351. _AddsMappedSpec(_T("%M"),  _T("mm"),    TRUE);
  352. _AddsMappedSpec(_T("%#M"), _T("m"),     TRUE);
  354. _AddsMappedSpec(_T("%S"),  _T("ss"),    TRUE);
  355. _AddsMappedSpec(_T("%#S"), _T("s"),     TRUE);
  357. _AddsMappedSpec(_T("%p"), _T("tt"),     TRUE);
  358. }
  360. void CXTPReportControlLocale::_AddsMappedSpec(LPCTSTR pcszSpec, LPCTSTR pcszFormat, BOOL bTime)
  361. {
  362. XTP_TIMESPEC tmpSpec = {pcszSpec, pcszFormat, bTime};
  363. s_arMappedSpecs.Add(tmpSpec);
  364. }
  366. //////////////////////////////////////////////////////////////////////////
  367. // CReportDropTarget
  368. class CXTPReportControl::CReportDropTarget : public COleDropTarget
  369. {
  370. public:
  371. virtual DROPEFFECT OnDragEnter(CWnd* pWnd, COleDataObject* pDataObject, DWORD dwKeyState, CPoint point)
  372. {
  373. CXTPReportControl* pReport = DYNAMIC_DOWNCAST(CXTPReportControl, pWnd);
  374. if (!pReport)
  375. return DROPEFFECT_NONE;
  377. return pReport->OnDragOver(pDataObject, dwKeyState, point, 0);
  378. }
  380. virtual DROPEFFECT OnDragOver(CWnd* pWnd, COleDataObject* pDataObject, DWORD dwKeyState, CPoint point)
  381. {
  382. CXTPReportControl* pReport = DYNAMIC_DOWNCAST(CXTPReportControl, pWnd);
  383. if (!pReport)
  384. return DROPEFFECT_NONE;
  386. return pReport->OnDragOver(pDataObject, dwKeyState, point, 2);
  387. }
  389. virtual void OnDragLeave(CWnd* pWnd)
  390. {
  391. CXTPReportControl* pReport = DYNAMIC_DOWNCAST(CXTPReportControl, pWnd);
  393. if (pReport)
  394. {
  395. pReport->OnDragOver(NULL, 0, CPoint(-1, -1), 1);
  396. }
  397. }
  398. virtual BOOL OnDrop(CWnd* pWnd, COleDataObject* pDataObject,
  399. DROPEFFECT dropEffect, CPoint point)
  400. {
  401. CXTPReportControl* pReport = DYNAMIC_DOWNCAST(CXTPReportControl, pWnd);
  403. if (pReport)
  404. {
  405. return pReport->OnDrop(pDataObject, dropEffect, point);
  406. }
  407. return FALSE;
  408. }
  409. };
  411. /////////////////////////////////////////////////////////////////////////////
  412. void XTPStrSplit(LPCTSTR pcszString, LPCTSTR pcszSeparator, CStringArray& rarStrings)
  413. {
  414. rarStrings.RemoveAll();
  416. int nSeparatorLen = (int)_tcslen(pcszSeparator);
  417. CString strString(pcszString);
  418. CString strItem;
  419. int nIndex_start = 0;
  421. // parse data
  422. BOOL bBreak = FALSE;
  423. do
  424. {
  425. int nIndex = FIND_S(strString, pcszSeparator, nIndex_start);
  426. if (nIndex >= 0)
  427. {
  428. strItem = strString.Mid(nIndex_start, nIndex - nIndex_start);
  429. }
  430. else
  431. {
  432. strItem = strString.Mid(nIndex_start);
  433. bBreak = TRUE;
  434. }
  436. //---------------------------------------
  437. rarStrings.Add(strItem);
  439. nIndex_start = nIndex + nSeparatorLen;
  440. }
  441. while (!bBreak);
  442. }
  444. CString XTPStrMake(const CStringArray& arStrings, LPCTSTR pcszSeparator)
  445. {
  446. CString strString;
  448. int nCount = (int)arStrings.GetSize();
  449. for (int i = 0; i < nCount; i++)
  450. {
  451. if (i > 0)
  452. {
  453. strString += pcszSeparator;
  454. }
  455. strString += arStrings[i];
  456. }
  458. return strString;
  459. }
  461. // CXTPReportControl
  462. IMPLEMENT_DYNCREATE(CXTPReportControl, CWnd)
  464. BEGIN_MESSAGE_MAP(CXTPReportControl, CWnd)
  465. //{{AFX_MSG_MAP(CXTPReportControl)
  466. ON_WM_PAINT()
  467. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  468. ON_WM_ERASEBKGND()
  469. ON_WM_SIZE()
  470. ON_WM_LBUTTONDOWN()
  471. ON_WM_LBUTTONUP()
  472. ON_WM_RBUTTONDOWN()
  473. ON_WM_RBUTTONUP()
  474. ON_WM_CONTEXTMENU()
  475. ON_WM_MOUSEMOVE()
  476. ON_WM_SETCURSOR()
  477. ON_WM_KEYDOWN()
  478. ON_WM_VSCROLL()
  479. ON_WM_HSCROLL()
  480. ON_WM_MOUSEWHEEL()
  481. ON_WM_SYSKEYDOWN()
  482. ON_WM_CAPTURECHANGED()
  483. ON_WM_SYSCOLORCHANGE()
  484. ON_WM_SETFOCUS()
  485. ON_WM_KILLFOCUS()
  486. ON_WM_KEYUP()
  487. ON_WM_SYSKEYUP()
  488. ON_WM_LBUTTONDBLCLK()
  489. ON_WM_GETDLGCODE()
  490. ON_WM_CHAR()
  491. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  492. ON_WM_STYLECHANGED()
  493. ON_WM_ENABLE()
  494. ON_WM_TIMER()
  495. //}}AFX_MSG_MAP
  496. END_MESSAGE_MAP()
  498. CXTPReportControl::CXTPReportControl()
  499. {
  500. RegisterWindowClass();
  502. m_nLockUpdateCount = 0;
  503. m_nRowsPerWheel = GetMouseScrollLines();
  505. m_pRows = new CXTPHeapObjectT<CXTPReportRows, CXTPReportAllocatorDefault>;
  506. m_pPlainTree = new CXTPHeapObjectT<CXTPReportRows, CXTPReportAllocatorDefault>;
  507. m_pRecords = new CXTPHeapObjectT<CXTPReportRecords, CXTPReportAllocatorDefault>;
  509. m_pColumns = new CXTPReportColumns(this);
  510. m_pReportHeader = new CXTPReportHeader(this, m_pColumns);
  512. m_pPaintManager = new CXTPReportPaintManager();
  513. m_pNavigator = new CXTPReportNavigator(this);
  514. m_nTopRow = 0;
  516. m_nFocusedRow = -1;
  517. m_nFocusedHeaderRow = -1;
  518. m_nFocusedFooterRow = -1;
  520. m_mouseMode = xtpReportMouseNothing;
  522. m_pSelectedRows = new CXTPReportSelectedRows(this);
  524. m_bChanged = TRUE;
  525. m_bRefreshIndexes = FALSE;
  527. m_bGroupByEnabled = FALSE;
  528. m_bHeaderVisible = TRUE;
  529. m_bFooterVisible = FALSE;
  530. m_bHeaderRecordsVisible = FALSE;
  531. m_bFooterRecordsVisible = FALSE;
  533. m_bMultipleSelection = TRUE;
  534. m_bMultiSelectionMode = FALSE;
  536. m_bShowTooltips = TRUE;
  538. m_bSkipGroupsFocus = TRUE;
  540. m_pImageManager = new CXTPImageManager();
  542. m_pFocusedColumn = NULL;
  543. m_pActiveItem = NULL;
  545. m_bFocusSubItems = FALSE;
  546. m_bEditOnClick = TRUE;
  547. m_bAllowEdit = FALSE;
  548. m_bHeaderAllowEdit = FALSE;
  549. m_bFooterAllowEdit = FALSE;
  550. m_bSelectionEnable = TRUE;
  551. m_bRowFocusVisible = TRUE;
  553. m_bAutoCheckItems = TRUE;
  555. m_pInplaceEdit = new CXTPReportInplaceEdit();
  556. m_pInplaceButtons = new CXTPReportInplaceButtons();
  557. m_pInplaceList = new CXTPReportInplaceList();
  559. m_rcGroupByArea.SetRectEmpty();
  560. m_rcHeaderArea.SetRectEmpty();
  561. m_rcReportArea.SetRectEmpty();
  562. m_rcFooterArea.SetRectEmpty();
  564. m_nFreezeColumnsCount = 0;
  565. m_nDisableReorderColumnsCount = 0;
  566. m_nLeftOffset = 0;
  567. m_pHotRow = 0;
  568. m_nOLEDropMode = 0;
  569. m_bFullColumnScrolling = FALSE;
  570. m_nHScrollStep = XTP_REPORT_HSCROLL_STEP;
  572. m_bVScrollBarVisible = FALSE;
  573. m_bHScrollBarVisible = FALSE;
  575. m_bPrepareDrag = FALSE;
  576. m_pointDrag = CPoint(0, 0);
  578. m_pToolTipContext = new CXTPToolTipContext;
  579. m_pCachedToolTipInfo = new XTP_NM_REPORTTOOLTIPINFO;
  581. m_nPopulatedRecordsCount = 0;
  583. m_cfReport = NULL;
  584. m_pDropTarget = new CReportDropTarget;
  585. m_bDragMode = FALSE;
  586. m_dwDragDropFlags = 0;
  587. m_nDropPos = -1;
  588. m_pDropRecords = NULL;
  589. m_pSelectOnUpRow = NULL;
  591. m_bOnSizeRunning = FALSE;
  592. m_uAutoScrollTimerID = 0;
  594. m_bSortRecordChilds = FALSE;
  596. m_pRowsCompareFunc = NULL;
  598. m_ptrVirtualEditingRow = NULL;
  600. m_bFilterHiddenColumns = FALSE;
  602. m_pHeaderRecords = new CXTPHeapObjectT<CXTPReportRecords, CXTPReportAllocatorDefault>;
  603. m_pFooterRecords = new CXTPHeapObjectT<CXTPReportRecords, CXTPReportAllocatorDefault>;
  604. m_pHeaderRows = new CXTPHeapObjectT<CXTPReportRows, CXTPReportAllocatorDefault>;
  605. m_pFooterRows = new CXTPHeapObjectT<CXTPReportRows, CXTPReportAllocatorDefault>;
  607. m_hbmpWatermark = NULL;
  608. m_WatermarkTransparency = 100;
  609. m_WatermarkAlignment = xtpReportWatermarkStretch;
  611. m_bHeaderRowsAllowAccess = TRUE;
  612. m_bFooterRowsAllowAccess = TRUE;
  614. m_bHeaderRowsSelectionEnable = TRUE;
  615. m_bFooterRowsSelectionEnable = TRUE;
  617. m_nEnsureVisibleRowIdx = m_nEnsureVisibleColumnIdx = -1;
  618. }
  620. BOOL CXTPReportControl::RegisterWindowClass(HINSTANCE hInstance /*= NULL*/)
  621. {
  622. return XTPDrawHelpers()->RegisterWndClass(hInstance, XTPREPORTCTRL_CLASSNAME, CS_DBLCLKS);
  623. }
  625. CXTPReportControl::~CXTPReportControl()
  626. {
  627. if (::IsWindow(m_wndTip.GetSafeHwnd()))
  628. m_wndTip.DestroyWindow();
  630. EditItem(0);
  632. //m_arrScreenRows.Clear();
  633. ResetContent(FALSE);
  635. CMDTARGET_RELEASE(m_pRows);
  636. CMDTARGET_RELEASE(m_pPlainTree);
  637. CMDTARGET_RELEASE(m_pSelectedRows);
  638. CMDTARGET_RELEASE(m_pRecords);
  639. CMDTARGET_RELEASE(m_pColumns);
  640. CMDTARGET_RELEASE(m_pPaintManager);
  641. CMDTARGET_RELEASE(m_pNavigator);
  643. CMDTARGET_RELEASE(m_pImageManager);
  644. CMDTARGET_RELEASE(m_pReportHeader);
  646. CMDTARGET_RELEASE(m_pToolTipContext);
  647. SAFE_DELETE(m_pCachedToolTipInfo);
  649. SAFE_DELETE(m_pInplaceEdit);
  650. SAFE_DELETE(m_pInplaceButtons);
  651. SAFE_DELETE(m_pInplaceList);
  653. CMDTARGET_RELEASE(m_pDropTarget);
  654. CMDTARGET_RELEASE(m_ptrVirtualEditingRow);
  656. CMDTARGET_RELEASE(m_pHeaderRecords);
  657. CMDTARGET_RELEASE(m_pFooterRecords);
  658. CMDTARGET_RELEASE(m_pHeaderRows);
  659. CMDTARGET_RELEASE(m_pFooterRows);
  661. CMDTARGET_RELEASE(m_pDropRecords);
  663. if(m_hbmpWatermark)
  664. ::DeleteObject(m_hbmpWatermark);
  666. }
  668. void CXTPReportControl::ResetContent(BOOL bUpdateControl)
  669. {
  670. EditItem(NULL);
  672. m_arrScreenRows.Clear();
  674. if (m_pRows) m_pRows->Clear();
  675. if (m_pPlainTree) m_pPlainTree->Clear();
  676. if (m_pSelectedRows) m_pSelectedRows->Clear();
  678. //  m_pHeaderRows->Clear();
  679. //  m_pFooterRows->Clear();
  681. //  m_pHeaderRecords->RemoveAll();
  682. //  m_pFooterRecords->RemoveAll();
  684. if (m_pRecords) m_pRecords->RemoveAll();
  686. if (bUpdateControl)
  687. {
  688. AdjustIndentation();
  689. AdjustScrollBars();
  690. RedrawControl();
  691. }
  692. }
  695. void CXTPReportControl::SetReportHeader(CXTPReportHeader* pReportHeader)
  696. {
  697. if (pReportHeader)
  698. {
  699. m_pReportHeader->InternalRelease();
  700. m_pReportHeader = pReportHeader;
  701. AdjustLayout();
  702. }
  703. }
  705. void CXTPReportControl::SetImageManager(CXTPImageManager* pImageManager)
  706. {
  707. if (pImageManager)
  708. {
  709. m_pImageManager->InternalRelease();
  710. m_pImageManager = pImageManager;
  711. }
  713. }
  715. void CXTPReportControl::SetImageList(CImageList* pImageList)
  716. {
  717. for (int i = 0; i < pImageList->GetImageCount(); i++)
  718. {
  719. HICON hIcon = pImageList->ExtractIcon(i);
  720. m_pImageManager->SetIcon(hIcon, i);
  722. DestroyIcon(hIcon);
  723. }
  724. }
  726. void CXTPReportControl::SetPaintManager(CXTPReportPaintManager* pPaintManager)
  727. {
  728. if (pPaintManager)
  729. {
  730. m_pPaintManager->InternalRelease();
  731. m_pPaintManager = pPaintManager;
  733. AdjustLayout();
  734. AdjustScrollBars();
  735. }
  736. }
  739. BOOL CXTPReportControl::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext)
  740. {
  741. if (!CWnd::Create(XTPREPORTCTRL_CLASSNAME, NULL, dwStyle, rect, pParentWnd, nID, pContext))
  742. return FALSE;
  744. return TRUE;
  745. }
  747. int CXTPReportControl::GetIndent(int nLevel) const
  748. {
  749. return max(0, (nLevel - 1) * m_pPaintManager->m_nTreeIndent);
  750. }
  752. void CXTPReportControl::SetTreeIndent(int nIndent)
  753. {
  754. m_pPaintManager->m_nTreeIndent = nIndent;
  755. }
  758. void CXTPReportControl::BeginUpdate()
  759. {
  760. m_nLockUpdateCount++;
  761. m_bRefreshIndexes = FALSE;
  763. }
  765. void CXTPReportControl::EndUpdate()
  766. {
  767. SetChanged();
  768. m_nLockUpdateCount--;
  770. if (m_nLockUpdateCount == 0)
  771. {
  772. if (m_bRefreshIndexes)
  773. {
  774. m_bRefreshIndexes = FALSE;
  775. _RefreshIndexes();
  776. }
  778. RedrawControl();
  779. }
  780. }
  782. void CXTPReportControl::RedrawControl()
  783. {
  784. SetChanged();
  785. if (m_nLockUpdateCount == 0 && GetSafeHwnd())
  786. {
  787. Invalidate(FALSE);
  788. }
  789. }
  791. void CXTPReportControl::UpdateSubList()
  792. {
  793. CXTPReportHeader* pHeader = GetReportHeader();
  794. if (pHeader && pHeader->m_pSubList &&
  795. (pHeader->m_pSubList->GetReportCtrl() == this))
  796. {
  797. pHeader->m_pSubList->UpdateList();
  798. }
  799. }
  801. void CXTPReportControl::_DoCollapse(CXTPReportRow* pRow)
  802. {
  803. int nIndex = pRow->GetIndex() + 1;
  804. int nCount = 0;
  806. while (nIndex < m_pRows->GetCount())
  807. {
  808. CXTPReportRow* pRowChild = m_pRows->GetAt(nIndex);
  809. if (!pRowChild->HasParent(pRow))
  810. break;
  812. pRowChild->m_bVisible = FALSE;
  813. pRowChild->m_nIndex = -1;
  814. m_pRows->RemoveAt(nIndex);
  815. nCount++;
  816. }
  818. if (nCount > 0)
  819. {
  820. m_pSelectedRows->_OnCollapsed(nIndex - 1, nCount);
  822. if (m_nFocusedRow >= nIndex)
  823. m_nFocusedRow = max(nIndex - 1, m_nFocusedRow - nCount);
  825. }
  826. }
  828. void CXTPReportControl::_DoExpand(CXTPReportRow* pRow)
  829. {
  830. int nIndex = pRow->m_nIndex;
  831. int nCount = _DoExpand(nIndex, pRow);
  833. if (nCount > 0)
  834. {
  835. m_pSelectedRows->_OnExpanded(nIndex, nCount);
  837. if (m_nFocusedRow > nIndex)
  838. m_nFocusedRow += nCount;
  840. }
  841. }
  843. int CXTPReportControl::_DoExpand(int nIndex, CXTPReportRow* pRow)
  844. {
  845. if (!pRow->HasChildren())
  846. return 0;
  848. int nStartIndex = nIndex;
  849. for (int i = 0; i < pRow->GetChilds()->GetCount(); i++)
  850. {
  851. CXTPReportRow* pRowChild = pRow->GetChilds()->GetAt(i);
  853. pRowChild->m_nRowLevel = pRow->m_nRowLevel + 1;
  854. pRowChild->m_nGroupLevel = pRow->m_nGroupLevel + (pRow->IsGroupRow() ? 1 : 0);
  856. nIndex += InsertRow(nIndex + 1, pRowChild);
  857. }
  858. return nIndex - nStartIndex;
  859. }
  861. void CXTPReportControl::RefreshIndexes(BOOL bAdjustLayout, BOOL bReverseOrder)
  862. {
  863. int nRowCount = m_pRows->GetCount();
  864. int nStartIdx = 0, nEndIdx = nRowCount, nStep = 1;
  865. if(bReverseOrder)
  866. {
  867. nStartIdx = nRowCount - 1;
  868. nEndIdx = nStep = -1;
  869. }
  870. for (int nIndex = nStartIdx; nIndex != nEndIdx; nIndex += nStep)
  871. {
  872. CXTPReportRow* pRow = m_pRows->GetAt(nIndex);
  874. BOOL bSelected = m_pSelectedRows->Contains(pRow);
  875. if(bSelected)
  876. m_pSelectedRows->Remove(pRow);
  878. pRow->m_nIndex = nIndex;
  879. ASSERT(pRow->m_bVisible);
  881. if(bSelected)
  882. m_pSelectedRows->Add(pRow);
  883. }
  885. if (bAdjustLayout)
  886. AdjustScrollBars();
  887. }
  889. void CXTPReportControl::_RefreshIndexes(BOOL bAdjustLayout, BOOL bReverseOrder)
  890. {
  891. if (m_nLockUpdateCount != 0)
  892. {
  893. m_bRefreshIndexes = TRUE;
  894. return;
  896. }
  898. RefreshIndexes(bAdjustLayout, bReverseOrder);
  899. }
  901. int CXTPReportControl::InsertRow(int nIndex, CXTPReportRow* pRow)
  902. {
  903. m_pRows->InsertAt(nIndex, pRow);
  904. pRow->InternalAddRef();
  905. pRow->m_bVisible = TRUE;
  908. int nRowsInserted = 1;
  910. if (pRow->IsExpanded() && pRow->HasChildren())
  911. {
  912. nRowsInserted += _DoExpand(nIndex, pRow);
  913. }
  914. return nRowsInserted;
  915. }
  917. void CXTPReportControl::BuildTree(CXTPReportRows* pTree, CXTPReportRow* pParentRow, CXTPReportRecords* pRecords)
  918. {
  919. ASSERT(pTree->GetCount() == 0);
  921. pTree->ReserveSize(pRecords->GetCount());
  923. for (int i = 0; i < pRecords->GetCount(); i++)
  924. {
  925. CXTPReportRecord* pRecord = pRecords->GetAt(i);
  927. // add record if all conditions are met
  928. if (pRecord->IsLocked() ||
  929. (pRecord->IsVisible() && !ApplyFilter(pRecord, GetFilterText(), IsPreviewMode())))
  930. {
  931. CXTPReportRow* pRow = CreateRow();
  932. pRow->InitRow(this, pRecord);
  934. pRow->m_pParentRow = pParentRow;
  935. pTree->Add(pRow);
  937. if (pRecord->HasChildren())
  938. {
  939. BuildTree(pRow->GetChilds(), pRow, pRecord->GetChilds());
  940. if (pRow->GetChilds() && IsSortRecordChilds())
  941. {
  942. SortRows(pRow->GetChilds());
  943. }
  944. }
  945. }
  946. }
  947. }
  949. void CXTPReportControl::SortTree(CXTPReportRows* pTree)
  950. {
  951. ASSERT(pTree);
  952. if (!pTree)
  953. return;
  955. SortRows(pTree);
  957. for (int i = 0; i < pTree->GetCount(); i++)
  958. {
  959. CXTPReportRow* pRow = pTree->GetAt(i);
  960. ASSERT(pRow);
  961. if (!pRow)
  962. continue;
  965. BOOL bRecordHasChildren = pRow->GetRecord() && pRow->GetRecord()->HasChildren();
  967. if (pRow->HasChildren() && pRow->GetChilds() &&
  968. (bRecordHasChildren && m_bSortRecordChilds || !bRecordHasChildren))
  969. {
  970. SortTree(pRow->GetChilds());
  971. }
  972. }
  974. pTree->RefreshChildIndices(FALSE);
  975. }
  977. void CXTPReportControl::ReSortRows()
  978. {
  979. if (IsVirtualMode())
  980. {
  981. Populate();
  982. return;
  983. }
  985. SortTree(m_pPlainTree);
  987. CXTPReportRecord* pFocusedRecord = GetFocusedRow() ? GetFocusedRow()->GetRecord() : NULL;
  989. m_pRows->Clear();
  990. m_arrScreenRows.Clear(FALSE);
  992. for (int nGroupRow = 0; nGroupRow < m_pPlainTree->GetCount(); nGroupRow++)
  993. {
  994. CXTPReportRow* pRow = m_pPlainTree->GetAt(nGroupRow);
  995. InsertRow(m_pRows->GetCount(), pRow);
  996. pRow->m_nChildIndex = nGroupRow;
  997. ASSERT(pRow->m_pParentRows == m_pPlainTree);
  998. }
  1000. //-----------------------------------------------------------------------
  1001. m_nFocusedRow = -1;
  1002. // Update indexes on virtual rows
  1003. int nRowCount = m_pRows->GetCount();
  1004. for (int nRowIndex = 0; nRowIndex < nRowCount; nRowIndex++)
  1005. {
  1006. CXTPReportRow* pRow = m_pRows->GetAt(nRowIndex);
  1007. if (pRow)
  1008. {
  1009. pRow->SetIndex(nRowIndex);
  1010. pRow->m_bVisible = TRUE;
  1012. if (pFocusedRecord && pRow->GetRecord() == pFocusedRecord)
  1013. {
  1014. m_nFocusedRow = pRow->GetIndex();
  1015. if(IsSelectionEnabled())
  1016. m_pSelectedRows->Select(pRow);
  1017. }
  1018. }
  1019. }
  1021. AdjustIndentation();
  1022. AdjustLayout();
  1024. RedrawControl();
  1025. }
  1027. CLIPFORMAT CXTPReportControl::EnableDragDrop(LPCTSTR lpszClipboardFormat, DWORD dwFlags)
  1028. {
  1029. if (m_dwDragDropFlags != 0)
  1030. {
  1031. if (m_pDropTarget)
  1032. m_pDropTarget->Revoke();
  1033. }
  1035. m_dwDragDropFlags = dwFlags;
  1036. m_cfReport = NULL;
  1038. if (m_dwDragDropFlags != 0)
  1039. {
  1040. if (m_pDropTarget)
  1041. {
  1042. m_cfReport = (CLIPFORMAT)::RegisterClipboardFormat(lpszClipboardFormat);
  1044. m_pDropTarget->Revoke(); // to ensure kill previous registration.
  1046. m_pDropTarget->Register(this);
  1047. }
  1048. }
  1050. return m_cfReport;
  1051. }
  1053. BOOL CXTPReportControl::ApplyFilter(CXTPReportRecord* pRecord, CString strFilterText, BOOL bIncludePreview)
  1054. {
  1055. // not filtered if filter text is empty
  1056. if (!pRecord)
  1057. return FALSE;
  1059. if (pRecord->IsFiltered())
  1060. return TRUE;
  1062. if (strFilterText.IsEmpty())
  1063. return FALSE;
  1065. BOOL bFilterHidden = IsFilterHiddenColumns();
  1067. // process each token in the filter string
  1068. TCHAR szSeps[] = _T(" t");
  1069. TCHAR *szToken, *lpszContext = 0;
  1070. //int nCurPos = 0;
  1072. szToken = STRTOK_S(strFilterText.GetBuffer(strFilterText.GetLength()), szSeps, &lpszContext);
  1073. while (szToken != NULL)
  1074. {
  1075. CString strToken(szToken);
  1076. strToken.MakeLower();
  1077. BOOL bTokenFound = FALSE;
  1078. // enumerate all visible columns
  1079. int nColumnsCount = m_pColumns->GetCount();
  1080. for (int nCol = 0; nCol < nColumnsCount; nCol++)
  1081. {
  1082. CXTPReportColumn* pCol = m_pColumns->GetAt(nCol);
  1083. if (pCol && (pCol->IsVisible() || bFilterHidden) && pCol->IsFiltrable())
  1084. {
  1085. CXTPReportRecordItem* pItem = pRecord->GetItem(pCol);
  1086. if (pItem)
  1087. {
  1088. CString sItemText = pItem->GetCaption(pCol);
  1089. // case-insensitive search
  1090. sItemText.MakeLower();
  1091. bTokenFound = sItemText.Find(strToken) != -1;
  1093. if (bTokenFound)
  1094. {
  1095. // stop search current token - passed
  1096. break;
  1097. }
  1098. }
  1099. }
  1100. }
  1101. // also check preview text
  1102. if (bIncludePreview && !bTokenFound && pRecord->GetItemPreview())
  1103. {
  1104. CString sItemText = pRecord->GetItemPreview()->GetCaption(NULL);
  1105. // case-insensitive search
  1106. sItemText.MakeLower();
  1107. bTokenFound = sItemText.Find(strToken) != -1;
  1108. }
  1110. // Token not found - filter this record
  1111. if (!bTokenFound)
  1112. {
  1113. return TRUE;
  1114. }
  1116. // get next token
  1117. szToken = STRTOK_S(NULL, szSeps, &lpszContext);
  1118. }
  1120. return FALSE;
  1121. }
  1123. void CXTPReportControl::Populate()
  1124. {
  1125. EditItem(NULL);
  1127. BeginUpdate();
  1129. m_nPopulatedRecordsCount = 0;
  1131. // save focused items
  1132. CXTPReportRecord* pFocusedRecord = GetFocusedRow() ? GetFocusedRow()->GetRecord() : NULL;
  1133. m_pSelectedRows->Clear();
  1134. m_nFocusedRow = -1;
  1135. m_nFocusedHeaderRow = -1;
  1136. m_nFocusedFooterRow = -1;
  1138. m_pRows->Clear();
  1139. m_pPlainTree->Clear();
  1140. m_arrScreenRows.Clear(FALSE);
  1141. m_pHeaderRows->Clear();
  1142. m_pFooterRows->Clear();
  1144. if (IsVirtualMode())
  1145. {
  1146. CXTPReportRow* pRow = CreateRow();
  1147. pRow->InitRow(this, GetRecords()->m_pVirtualRecord);
  1148. pRow->m_bVisible = TRUE;
  1150. m_pRows->SetVirtualMode(pRow, GetRecords()->GetCount());
  1151. m_nPopulatedRecordsCount = GetRecords()->GetCount();
  1152. }
  1153. else
  1154. {
  1155. BuildTree(m_pPlainTree, NULL, m_pRecords);
  1156. m_nPopulatedRecordsCount = m_pPlainTree->GetCount();
  1158. SortRows(m_pPlainTree);
  1160. int nGroupRowsCount = 0;
  1162. if (m_pColumns->GetGroupsOrder()->GetCount() > 0)
  1163. {
  1164. CXTPReportRows* pGroupTree = new CXTPHeapObjectT<CXTPReportRows, CXTPReportAllocatorDefault>;
  1166. int nReserve = m_pRecords->GetCount() / (m_pColumns->GetGroupsOrder()->GetCount() + 1);
  1167. nReserve = max(nReserve, 300);
  1168. pGroupTree->ReserveSize(nReserve);
  1170. CXTPReportGroupRow* pLastGroup = NULL;
  1172. for (int nPlainRow = 0; nPlainRow < m_pPlainTree->GetCount(); nPlainRow++)
  1173. {
  1174. CXTPReportRow* pRow = m_pPlainTree->GetAt(nPlainRow);
  1175. CXTPReportGroupRow* pGroupToAdd = NULL;
  1177. for (int nColumn = 0; nColumn < m_pColumns->GetGroupsOrder()->GetCount(); nColumn++)
  1178. {
  1179. CXTPReportColumn* pColumn = m_pColumns->GetGroupsOrder()->GetAt(nColumn);
  1180. CXTPReportRecordItem* pItem = pRow->GetRecord()->GetItem(pColumn);
  1181. CString strGroup = pItem ? pItem->GetGroupCaption(pColumn) : _T("");
  1183. if (pLastGroup && GetRecords()->Compare(pLastGroup->GetCaption(), strGroup) == 0)
  1184. {
  1185. pGroupToAdd = pLastGroup;
  1187. if (pGroupToAdd->HasChildren())
  1188. pLastGroup = (CXTPReportGroupRow*)pGroupToAdd->GetChilds()->GetAt(pGroupToAdd->GetChilds()->GetCount() - 1);
  1190. }
  1191. else
  1192. {
  1193. CXTPReportGroupRow* pGroup = CreateGroupRow();
  1194. nGroupRowsCount++;
  1196. pGroup->InitRow(this, NULL);
  1197. pGroup->SetCaption(strGroup);
  1199. if (pGroupToAdd)
  1200. {
  1201. pGroupToAdd->AddChild(pGroup);
  1202. }
  1203. else
  1204. {
  1205. pGroupTree->Add(pGroup);
  1206. }
  1208. pGroupToAdd = pGroup;
  1209. pLastGroup = NULL;
  1210. }
  1212. }
  1213. if (pGroupToAdd) pGroupToAdd->AddChild(pRow);
  1214. pRow->InternalAddRef();
  1215. pLastGroup = (CXTPReportGroupRow*)pGroupTree->GetAt(pGroupTree->GetCount() - 1);
  1216. }
  1218. m_pPlainTree->InternalRelease();
  1219. m_pPlainTree = pGroupTree;
  1220. }
  1222. m_pRows->ReserveSize(m_pRecords->GetCount() + nGroupRowsCount + 10);
  1224. for (int nGroupRow = 0; nGroupRow < m_pPlainTree->GetCount(); nGroupRow++)
  1225. {
  1226. CXTPReportRow* pRow = m_pPlainTree->GetAt(nGroupRow);
  1227. InsertRow(m_pRows->GetCount(), pRow);
  1228. pRow->m_nChildIndex = nGroupRow;
  1229. ASSERT(pRow->m_pParentRows == m_pPlainTree);
  1230. }
  1233. m_nFocusedRow = -1;
  1234. m_nFocusedHeaderRow = -1;
  1235. m_nFocusedFooterRow = -1;
  1237. // Update indexes on virtual rows
  1238. int nRowCount = m_pRows->GetCount();
  1239. for (int nRowIndex = 0; nRowIndex < nRowCount; nRowIndex++)
  1240. {
  1241. CXTPReportRow* pRow = m_pRows->GetAt(nRowIndex);
  1242. if (pRow)
  1243. {
  1244. pRow->SetIndex(nRowIndex);
  1245. pRow->m_bVisible = TRUE;
  1247. if (pFocusedRecord && pRow->GetRecord() == pFocusedRecord)
  1248. {
  1249. m_nFocusedRow = pRow->GetIndex();
  1250. if(IsSelectionEnabled())
  1251. m_pSelectedRows->Select(pRow);
  1252. }
  1253. }
  1254. }
  1256. int i;
  1257. // header record rows
  1258. for (i = 0; i < m_pHeaderRecords->GetCount(); i++)
  1259. {
  1260. CXTPReportRecord* pRecord = m_pHeaderRecords->GetAt(i);
  1261. CXTPReportRow* pRow = CreateHeaderFooterRow();
  1263. pRow->InitRow(this, pRecord);
  1264. pRow->SetIndex(i);
  1265. pRow->m_nRowType = xtpRowTypeHeader;
  1266. pRow->m_pParentRow = NULL;
  1267. m_pHeaderRows->Add(pRow);
  1268. }
  1270. // footer record rows
  1271. for (i = 0; i < m_pFooterRecords->GetCount(); i++)
  1272. {
  1273. CXTPReportRecord* pRecord = m_pFooterRecords->GetAt(i);
  1274. CXTPReportRow* pRow = CreateHeaderFooterRow();
  1276. pRow->InitRow(this, pRecord);
  1277. pRow->SetIndex(i);
  1278. pRow->m_nRowType = xtpRowTypeFooter;
  1279. pRow->m_pParentRow = NULL;
  1280. m_pFooterRows->Add(pRow);
  1281. }
  1282. }
  1284. AdjustIndentation();
  1285. AdjustLayout();
  1286. AdjustScrollBars();
  1288. UpdateSubList();
  1290. if (m_nFocusedRow == -1)
  1291. {
  1292. SetTopRow(0);
  1294. if (GetRows()->GetCount() > 0)
  1295. {
  1296. m_nFocusedRow = 0;
  1297. if(IsSelectionEnabled())
  1298. m_pSelectedRows->Select(m_pRows->GetAt(0));
  1299. }
  1301. }
  1302. else
  1303. {
  1304. EnsureVisible(GetFocusedRow());
  1305. }
  1307. if (m_pFocusedColumn == NULL && m_bFocusSubItems)
  1308. {
  1309. m_pFocusedColumn = m_pColumns->GetFirstVisibleColumn();
  1310. }
  1312. EndUpdate();
  1313. }
  1315. void CXTPReportControl::PopulateHeaderRows()
  1316. {
  1317. if(IsVirtualMode())
  1318. return;
  1320. EditItem(NULL);
  1321. BeginUpdate();
  1323. m_pHeaderRows->Clear();
  1324. for (int i = 0; i < m_pHeaderRecords->GetCount(); i++)
  1325. {
  1326. CXTPReportRecord* pRecord = m_pHeaderRecords->GetAt(i);
  1327. CXTPReportRow* pRow = CreateHeaderFooterRow();
  1329. pRow->InitRow(this, pRecord);
  1330. pRow->SetIndex(i);
  1331. pRow->m_nRowType = xtpRowTypeHeader;
  1332. pRow->m_pParentRow = NULL;
  1333. m_pHeaderRows->Add(pRow);
  1334. }
  1335. AdjustIndentation();
  1336. AdjustLayout();
  1337. AdjustScrollBars();
  1339. UpdateSubList();
  1341. EndUpdate();
  1342. }
  1344. void CXTPReportControl::PopulateFooterRows()
  1345. {
  1346. if(IsVirtualMode())
  1347. return;
  1349. EditItem(NULL);
  1350. BeginUpdate();
  1352. m_pFooterRows->Clear();
  1353. for (int i = 0; i < m_pFooterRecords->GetCount(); i++)
  1354. {
  1355. CXTPReportRecord* pRecord = m_pFooterRecords->GetAt(i);
  1356. CXTPReportRow* pRow = CreateHeaderFooterRow();
  1358. pRow->InitRow(this, pRecord);
  1359. pRow->SetIndex(i);
  1360. pRow->m_nRowType = xtpRowTypeFooter;
  1361. pRow->m_pParentRow = NULL;
  1362. m_pFooterRows->Add(pRow);
  1363. }
  1364. AdjustIndentation();
  1365. AdjustLayout();
  1366. AdjustScrollBars();
  1368. UpdateSubList();
  1370. EndUpdate();
  1371. }
  1373. void CXTPReportControl::SortRows(CXTPReportRows* pRows)
  1374. {
  1375. if (pRows->GetCount() == 0)
  1376. return;
  1378. if (m_pRowsCompareFunc && m_pRowsCompareFunc != CXTPReportRows::CompareRows)
  1379. {
  1380. pRows->SortEx(m_pRowsCompareFunc);
  1381. return;
  1382. }
  1384. if (m_pColumns->GetSortOrder()->GetCount() == 0 &&
  1385. m_pColumns->GetGroupsOrder()->GetCount() == 0)
  1386. return;
  1388. pRows->Sort();
  1389. }
  1391. void CXTPReportControl::AdjustIndentation()
  1392. {
  1393. XTP_TRACE(_T("AdjustIndentation()n"));
  1395. GetReportHeader()->m_nIndentLevel =
  1396. m_pColumns->GetGroupsOrder()->GetCount();
  1397. }
  1399. CXTPReportColumn* CXTPReportControl::AddColumn(CXTPReportColumn* pColumn)
  1400. {
  1401. ASSERT(pColumn);
  1402. m_pColumns->Add(pColumn);
  1404. return pColumn;
  1405. }
  1407. CXTPReportRecord* CXTPReportControl::AddRecord(CXTPReportRecord* pRecord)
  1408. {
  1409. ASSERT(pRecord);
  1410. if (!pRecord)
  1411. return NULL;
  1413. m_pRecords->Add(pRecord);
  1415. return pRecord;
  1416. }
  1418. void CXTPReportControl::AddRecordEx(CXTPReportRecord* pRecord, CXTPReportRecord* pParentRecord, int nChildIndex)
  1419. {
  1420. ASSERT(pRecord);
  1421. if (!pRecord)
  1422. return;
  1424. // add record
  1425. BOOL bAddRecord = TRUE;
  1426. CXTPReportRecords* pParentRecords = pParentRecord ? pParentRecord->HasChildren() ? pParentRecord->GetChilds() : NULL : m_pRecords;
  1427. if(pParentRecords)
  1428. {
  1429. for(int nChild = 0; nChild < pParentRecords->GetCount(); nChild++)
  1430. {
  1431. if(pRecord == pParentRecords->GetAt(nChild))
  1432. {
  1433. bAddRecord = FALSE;
  1434. break;
  1435. }
  1436. }
  1437. }
  1438. if(bAddRecord)
  1439. {
  1440. if(pParentRecord)
  1441. pParentRecord->GetChilds()->Add(pRecord);
  1442. else
  1443. m_pRecords->Add(pRecord);
  1444. }
  1446. if(!pRecord->IsVisible())
  1447. return;
  1449. // find parent record rows
  1450. CXTPReportRows* pParentRows = m_pPlainTree;
  1451. CXTPReportRow* pParentRow = NULL;
  1452. if(pParentRecord)
  1453. {
  1454. pParentRow = m_pPlainTree->FindInTree(pParentRecord);
  1455. if(pParentRow)
  1456. pParentRows = pParentRow->GetChilds();
  1457. }
  1458. BOOL bRoot = pParentRows == m_pPlainTree;
  1460. // create new row
  1461. CXTPReportRow* pNewRow = CreateRow();
  1462. pNewRow->InitRow(this, pRecord);
  1463. pNewRow->m_pParentRow = NULL;
  1465. // add row to pParentRows
  1466. BOOL bInsertAfter = FALSE;
  1467. CXTPReportRow* pPlainTreeRow = NULL;
  1468. CXTPReportRow* pInsertRowPos = NULL;
  1469. int nNextSiblingIndex = m_pRows->GetCount();
  1470. if(bRoot)
  1471. {
  1472. pInsertRowPos = pParentRows->FindInsertionPos(pNewRow, bInsertAfter);
  1473. CXTPReportRow* pRow = pInsertRowPos;
  1474. while(pRow)
  1475. {
  1476. if(pRow->GetNextSiblingRow())
  1477. {
  1478. nNextSiblingIndex = pRow->GetNextSiblingRow()->GetIndex();
  1479. break;
  1480. }
  1481. else
  1482. pRow = pRow->GetParentRow();
  1483. }
  1484. if(m_pColumns->GetGroupsOrder()->GetCount() > 0)
  1485. {
  1486. CXTPReportGroupRow* pGroupToAdd = pInsertRowPos ? (CXTPReportGroupRow*)pInsertRowPos->GetParentRow() : NULL;
  1487. if(!pInsertRowPos || (pInsertRowPos && pInsertRowPos->IsGroupRow()))
  1488. {
  1489. for(int nColumn = pInsertRowPos ? pInsertRowPos->GetGroupLevel() : 0; nColumn < m_pColumns->GetGroupsOrder()->GetCount(); nColumn++)
  1490. {
  1491. CXTPReportColumn* pColumn = m_pColumns->GetGroupsOrder()->GetAt(nColumn);
  1492. CXTPReportRecordItem* pItem = pRecord->GetItem(pColumn);
  1493. CString strGroup = pItem ? pItem->GetGroupCaption(pColumn) : _T("");
  1495. CXTPReportGroupRow* pGroup = CreateGroupRow();
  1496. pGroup->InitRow(this, NULL);
  1497. pGroup->SetCaption(strGroup);
  1498. pGroup->m_nGroupLevel = pGroupToAdd ? pGroupToAdd->m_nRowLevel + 1 : 0;
  1499. pGroup->m_nRowLevel = nColumn;
  1500. if(pGroupToAdd)
  1501. {
  1502. if(!pPlainTreeRow)
  1503. {
  1504. pPlainTreeRow = pGroup;
  1505. pGroupToAdd->GetChilds()->InsertAt(bInsertAfter ? pInsertRowPos ? pInsertRowPos->m_nChildIndex + 1 : 0 : pInsertRowPos ? pInsertRowPos->m_nChildIndex : 0, pGroup);
  1506. }
  1507. else
  1508. pGroupToAdd->AddChild(pGroup);
  1509. pGroup->m_pParentRows = pGroupToAdd->GetChilds();
  1510. pGroup->m_pParentRow = pGroupToAdd;
  1511. pGroup->m_bVisible = pGroupToAdd->IsExpanded();
  1512. }
  1513. else
  1514. {
  1515. pPlainTreeRow = pGroup;
  1516. pParentRows->InsertAt(pInsertRowPos ? pInsertRowPos->m_nChildIndex : pParentRows->GetCount(), pGroup);
  1517. pGroup->m_pParentRows = pParentRows;
  1518. pGroup->m_pParentRow = NULL;
  1519. pGroup->m_bVisible = TRUE;
  1520. }
  1521. pGroupToAdd = pGroup;
  1522. }
  1523. // insert row
  1524. if(pGroupToAdd)
  1525. {
  1526. pGroupToAdd->AddChild(pNewRow);
  1527. pNewRow->m_pParentRows = pGroupToAdd->GetChilds();
  1528. //              pNewRow->m_pParentRow = pGroupToAdd;
  1529. pNewRow->m_bVisible = pGroupToAdd->IsExpanded();
  1530. }
  1531. }
  1532. else
  1533. {
  1534. // insert row
  1535. if(pGroupToAdd)
  1536. {
  1537. pGroupToAdd->GetChilds()->InsertAt(bInsertAfter ? pInsertRowPos ? pInsertRowPos->m_nChildIndex + 1 : 0 : pInsertRowPos ? pInsertRowPos->m_nChildIndex : 0, pNewRow);
  1538. pNewRow->m_pParentRows = pGroupToAdd->GetChilds();
  1539. pNewRow->m_pParentRow = pGroupToAdd;
  1540. pNewRow->m_bVisible = pGroupToAdd->IsExpanded();
  1541. }
  1542. }
  1543. }
  1544. else
  1545. {
  1546. pParentRows->InsertAt(pInsertRowPos ? pInsertRowPos->m_nChildIndex : pParentRows->GetCount(), pNewRow);
  1547. pNewRow->m_pParentRows = pParentRows;
  1548. pNewRow->m_pParentRow = NULL;
  1549. pNewRow->m_bVisible = TRUE;
  1550. }
  1551. }
  1552. else
  1553. {
  1554. if(nChildIndex >= 0 && nChildIndex < pParentRows->GetCount())
  1555. pParentRows->InsertAt(nChildIndex, pNewRow);
  1556. else
  1557. pParentRows->Add(pNewRow);
  1558. pNewRow->m_pParentRows = pParentRows;
  1559. pNewRow->m_pParentRow = pParentRow;
  1560. pNewRow->m_bVisible = TRUE;
  1561. pNewRow->m_nRowLevel = pParentRow->m_nRowLevel + 1;
  1562. pNewRow->m_nGroupLevel = pParentRow->m_nGroupLevel;
  1563. pNewRow->m_nChildIndex = nChildIndex >= 0 ? nChildIndex : pParentRows->GetCount() - 1;
  1565. CXTPReportRow* pRow = pNewRow;
  1566. while(pRow)
  1567. {
  1568. if(pRow->GetNextSiblingRow())
  1569. {
  1570. nNextSiblingIndex = pRow->GetNextSiblingRow()->GetIndex();
  1571. break;
  1572. }
  1573. else
  1574. pRow = pRow->GetParentRow();
  1575. }
  1576. }
  1577. // refresh child indices
  1578. if(pInsertRowPos && pInsertRowPos->GetParentRows())
  1579. pInsertRowPos->GetParentRows()->RefreshChildIndices();
  1580. else
  1581. pParentRows->RefreshChildIndices();
  1583. // add row to m_pRows
  1584. if(bRoot)
  1585. {
  1586. if(pInsertRowPos)
  1587. {
  1588. CXTPReportRow* pRow = pInsertRowPos->GetParentRow();
  1589. BOOL bIsExpanded = TRUE;
  1590. while(pRow && bIsExpanded)
  1591. {
  1592. bIsExpanded = bIsExpanded && pRow->IsExpanded();
  1593. pRow = pRow->GetParentRow();
  1594. }
  1596. if(bIsExpanded)
  1597. {
  1598. if(bInsertAfter)
  1599. InsertRow(nNextSiblingIndex, pPlainTreeRow ? pPlainTreeRow : pNewRow);
  1600. else
  1601. InsertRow(pInsertRowPos->GetIndex(), pPlainTreeRow ? pPlainTreeRow : pNewRow);
  1602. }
  1603. }
  1604. else
  1605. {
  1606. InsertRow(m_pRows->GetCount(), pPlainTreeRow ? pPlainTreeRow : pNewRow);
  1607. }
  1608. }
  1609. else
  1610. {
  1611. CXTPReportRow* pRow = pNewRow->GetParentRow();
  1612. BOOL bIsExpanded = TRUE;
  1613. while(pRow && bIsExpanded)
  1614. {
  1615. bIsExpanded = bIsExpanded && pRow->IsExpanded();
  1616. pRow = pRow->GetParentRow();
  1617. }
  1619. if(bIsExpanded)
  1620. InsertRow(nNextSiblingIndex, pNewRow);
  1621. }
  1623. RefreshIndexes(FALSE, TRUE);
  1625. // add children
  1626. if(pRecord && pRecord->HasChildren())
  1627. {
  1628. for(int nChild = 0; nChild < pRecord->GetChilds()->GetCount(); nChild++)
  1629. {
  1630. AddRecordEx(pRecord->GetChilds()->GetAt(nChild), pRecord);
  1631. }
  1632. }
  1633. }
  1635. BOOL CXTPReportControl::RemoveRowEx(CXTPReportRow* pRow, BOOL bAdjustLayout)
  1636. {
  1637. ASSERT(pRow);
  1638. if (!pRow)
  1639. return FALSE;
  1641. //------------------------------------------------
  1642. if (!pRow->IsGroupRow())
  1643. {
  1644. ASSERT(pRow->GetRecord());
  1645. return RemoveRecordEx(pRow->GetRecord(), bAdjustLayout);
  1646. }
  1648. //------------------------------------------------
  1649. CWaitCursor _WC;
  1651. int nCount = pRow->GetChilds()->GetCount();
  1652. ASSERT(nCount);
  1654. for (int i = nCount - 1; i >= 0 ; i--)
  1655. {
  1656. CXTPReportRow* pRowI = pRow->GetChilds()->GetAt(i);
  1657. RemoveRowEx(pRowI, bAdjustLayout);
  1658. }
  1660. return TRUE;
  1661. }
  1663. BOOL CXTPReportControl::RemoveRecordEx(CXTPReportRecord* pRecord, BOOL bAdjustLayout, BOOL bRemoveFromParent)
  1664. {
  1665. ASSERT(pRecord && m_pRecords);
  1667. if (!pRecord || !m_pRecords)
  1668. return FALSE;
  1670. if (pRecord->HasChildren())
  1671. {
  1672. for (int i = pRecord->GetChilds()->GetCount() - 1; i >= 0 ; i--)
  1673. {
  1674. RemoveRecordEx(pRecord->GetChilds()->GetAt(i), bAdjustLayout, FALSE);
  1675. }
  1677. //      return RemoveRecordEx(pRecord, bAdjustLayout);
  1678. }
  1680. BOOL bResult = FALSE;
  1682. //--------------------------------------------------------
  1683. CXTPReportRow* pRow0 = m_pPlainTree->FindInTree(pRecord);
  1685. ASSERT_DBG_REMOVE_RECORD_EX(pRow0);
  1687. if (pRow0)
  1688. {
  1689. CXTPReportRow* pRow = pRow0;
  1690. pRow0 = NULL;
  1692. do
  1693. {
  1694. CXTPReportRow* pRow_parent = pRow->GetParentRow();
  1696. ASSERT(pRow->GetParentRows());
  1698. // 1. Remove from selected rows
  1699. if(m_pSelectedRows->Contains(pRow))
  1700. m_pSelectedRows->Remove(pRow);
  1702. // 2. remove from Rows Tree
  1703. if (pRow->GetParentRows())
  1704. VERIFY(pRow->GetParentRows()->RemoveRow(pRow) >= 0);
  1706. // 3. remove from Display Rows array
  1707. m_pRows->RemoveRow(pRow);
  1709. pRow = pRow_parent;
  1711. } while (pRow && pRow->IsGroupRow() && pRow->GetChilds()->GetCount() == 0);
  1713. // refresh child indices
  1714. if(pRow && pRow->HasChildren())
  1715. pRow->GetChilds()->RefreshChildIndices();
  1716. else
  1717. m_pPlainTree->RefreshChildIndices();
  1719. bResult = TRUE;
  1720. }
  1722. //-------------------------------------------------------
  1723. //pRecord->Delete(); // the code below is more safe when record already removed!
  1725. ASSERT(pRecord->GetRecords());
  1727. if (bRemoveFromParent && pRecord->GetRecords())
  1728. {
  1729. BOOL bRecordRem = pRecord->GetRecords()->RemoveRecord(pRecord) >= 0;
  1730. pRecord = NULL;
  1731. ASSERT_DBG_REMOVE_RECORD_EX(bRecordRem);
  1733. bResult |= bRecordRem;
  1734. }
  1736. if (m_nFocusedRow >= 0 && m_nFocusedRow >= m_pRows->GetCount())
  1737. m_nFocusedRow = m_pRows->GetCount() - 1;
  1739. //-------------------------------------------------------
  1740. if (bResult)
  1741. RefreshIndexes(bAdjustLayout);
  1743. return bResult;
  1744. }
  1746. void CXTPReportControl::UpdateRecord(CXTPReportRecord* pRecord, BOOL bUpdateChildren)
  1747. {
  1748. // get parent record
  1749. CXTPReportRecord* pParentRecord = NULL;
  1750. if(pRecord->GetRecords())
  1751. pParentRecord = pRecord->GetRecords()->GetOwnerRecord();
  1752. // update record
  1753. if(!pParentRecord || bUpdateChildren)
  1754. {
  1755. // internal addref
  1756. pRecord->TreeAddRef();
  1757. // get record row child index
  1758. CXTPReportRow* pRow = m_pPlainTree->FindInTree(pRecord);
  1759. int nChildIndex = pRow->m_nChildIndex;
  1760. // remove record
  1761. RemoveRecordEx(pRecord, FALSE);
  1762. // add record
  1763. AddRecordEx(pRecord, pParentRecord, nChildIndex);
  1764. // internal release
  1765. pRecord->TreeRelease();
  1766. }
  1767. else
  1768. RedrawControl();
  1769. }
  1771. void CXTPReportControl::DrawNoItems(CDC* pDC, const CRect& rcClient)
  1772. {
  1773. pDC->SetTextColor(GetPaintManager()->m_clrWindowText);
  1774. CString strNoItems = GetPaintManager()->m_strNoItems;
  1776. if (!strNoItems.IsEmpty())
  1777. {
  1778. CRect rcText(rcClient);
  1779. rcText.DeflateRect(5, 5, 5, 5);
  1780. CXTPFontDC font(pDC, &GetPaintManager()->m_fontText);
  1781. UINT uFlags = DT_CENTER | DT_TOP | DT_NOPREFIX | DT_WORDBREAK |
  1782.   DT_WORD_ELLIPSIS | DT_END_ELLIPSIS | DT_EDITCONTROL;
  1784. pDC->DrawText(strNoItems, rcText, uFlags);
  1785. }
  1787. }
  1789. void CXTPReportControl::DrawRows(CDC* pDC, CRect& rcClient)
  1790. {
  1791. m_arrScreenRows.Clear(FALSE);
  1793. pDC->SetBkMode(TRANSPARENT);
  1795. int y = rcClient.top;
  1797. int nRowCount = m_pRows->GetCount();
  1799. if (0 == nRowCount)
  1800. {
  1801. DrawNoItems(pDC, rcClient);
  1802. }
  1804. if (GetReportHeader()->GetNextVisibleColumn(-1, 1) == NULL)
  1805. return;
  1807. int nRowHeight = 0;
  1808. int nHeaderWidth = GetReportHeader()->GetWidth();
  1811. //m_arrScreenRows.ReserveSize(200);
  1812. m_arrScreenRows.SetSize(0, 200);
  1814. for (int i = m_nTopRow; i < nRowCount; i++)
  1815. {
  1816. CXTPReportRow* pRow = m_pRows->GetAt(i);
  1817. ASSERT(pRow);
  1818. if (!pRow)
  1819. continue;
  1821. if (y > rcClient.bottom)
  1822. break;
  1824. nRowHeight = pRow->GetHeight(pDC, nHeaderWidth);
  1826. CRect rcRow(rcClient.left, y, rcClient.left + nHeaderWidth,
  1827. y + pRow->GetHeight(pDC, nHeaderWidth));
  1829. pRow->Draw(pDC, rcRow, m_nLeftOffset);
  1831. y += rcRow.Height();
  1834. CXTPReportRow* pScreenRow = NULL;
  1835. if (IsVirtualMode())
  1836. {
  1837. pScreenRow = CreateRow();
  1838. pScreenRow->InitRow(pRow);
  1839. pScreenRow->m_bExpanded = pRow->m_bExpanded;
  1840. if(pScreenRow->m_nRowLevel == 0)
  1841. pScreenRow->m_rcCollapse = pRow->m_rcCollapse;
  1842. }
  1843. else
  1844. {
  1845. pScreenRow = pRow;
  1846. pScreenRow->InternalAddRef();
  1848. }
  1849. m_arrScreenRows.InsertAt(m_arrScreenRows.GetCount(), pScreenRow);
  1850. }
  1852. // fill the rest of space with the "fake" rows
  1853. if (GetPaintManager()->IsDrawGridForEmptySpace() && y < rcClient.bottom)
  1854. {
  1855. CRect rcEmpty(rcClient);
  1856. rcEmpty.top = y;
  1857. DrawDefaultGrid(pDC, rcEmpty, nRowHeight, m_nLeftOffset);
  1858. }
  1859. }
  1861. void CXTPReportControl::DrawFixedRows(CDC* pDC, CRect& rcClient, CXTPReportRows* pRows)
  1862. {
  1863. pDC->SetBkMode(TRANSPARENT);
  1865. int y = rcClient.top;
  1867. int nRowCount = pRows->GetCount();
  1869. if ( nRowCount > 0 )
  1870. {
  1871. if (GetReportHeader()->GetNextVisibleColumn(-1, 1) == NULL)
  1872. return;
  1874. int nHeaderWidth = GetReportHeader()->GetWidth();
  1876. for (int i = 0; i < nRowCount; i++)
  1877. {
  1878. CXTPReportRow* pRow = pRows->GetAt(i);
  1880. if (y > rcClient.bottom)
  1881. break;
  1883. CRect rcRow(rcClient.left, y, rcClient.left + nHeaderWidth,
  1884. y + pRow->GetHeight(pDC, nHeaderWidth));
  1886. pRow->DrawFixed(pDC, rcRow, m_nLeftOffset, rcClient);
  1888. y += rcRow.Height();
  1889. }
  1890. }
  1891. }
  1893. void CXTPReportControl::DrawFixedRecordsDivider(CDC* pDC, CRect& rcClient, BOOL bHeaderRows)
  1894. {
  1895. GetPaintManager()->DrawFixedRowsDivider(pDC, rcClient, this, bHeaderRows, m_bVScrollBarVisible);
  1896. }
  1898. void CXTPReportControl::OnSelectionChanged()
  1899. {
  1900. SendNotifyMessage(XTP_NM_REPORT_SELCHANGED);
  1901. if (m_pSelectedRows)
  1902. m_pSelectedRows->SetChanged(FALSE);
  1903. }
  1905. BOOL CXTPReportControl::OnFocusChanging(CXTPReportRow* pNewRow, CXTPReportColumn* pNewCol)
  1906. {
  1907. XTP_NM_REPORTREQUESTEDIT nm;
  1908. ::ZeroMemory(&nm, sizeof(nm));
  1910. nm.bCancel = FALSE;
  1911. nm.pRow = pNewRow ? pNewRow : GetFocusedRow();
  1912. nm.pColumn = pNewCol ? pNewCol : GetFocusedColumn();
  1913. nm.pItem = nm.pRow && nm.pColumn ? (nm.pRow->GetRecord() ? nm.pRow->GetRecord()->GetItem(nm.pColumn) : NULL) : NULL;
  1915. SendNotifyMessage(XTP_NM_REPORT_FOCUS_CHANGING, (NMHDR*)&nm);
  1917. return !nm.bCancel;
  1918. }
  1920. void CXTPReportControl::GetItemMetrics(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs,
  1921. XTP_REPORTRECORDITEM_METRICS* pMetrics)
  1922. {
  1923. XTP_NM_REPORTITEMMETRICS nmData;
  1924. nmData.pDrawArgs = pDrawArgs;
  1925. nmData.pItemMetrics = pMetrics;
  1927. SendNotifyMessage(XTP_NM_REPORT_GETITEMMETRICS, (NMHDR*)&nmData);
  1928. }
  1932. BOOL CXTPReportControl::SetFocusedColumn(CXTPReportColumn* pColumn)
  1933. {
  1934. if (m_pFocusedColumn != pColumn)
  1935. {
  1936. if (m_bFocusSubItems && pColumn)
  1937. {
  1938. if(!OnFocusChanging(NULL, pColumn))
  1939. return FALSE;
  1940. }
  1942. m_pFocusedColumn = pColumn;
  1944. if (m_pFocusedColumn && m_bFocusSubItems)
  1945. {
  1946. CRect rc(m_pFocusedColumn->GetRect());
  1948. if (rc.right >= m_rcReportArea.Width())
  1949. {
  1950. SetLeftOffset(m_nLeftOffset + min(rc.left, rc.right - m_rcReportArea.Width()));
  1951. }
  1952. else
  1953. {
  1954. int nFreezeColumnWidth = 0;
  1955. if (m_nFreezeColumnsCount > 0)
  1956. {
  1957. int nFreezeColumnsCount = m_nFreezeColumnsCount;
  1958. for (int i = 0; (i < m_pColumns->GetCount()) && (nFreezeColumnsCount > 0); i++)
  1959. {
  1960. CXTPReportColumn* pColumnCheck = m_pColumns->GetAt(i);
  1962. if (pColumnCheck == m_pFocusedColumn)
  1963. {
  1964. nFreezeColumnWidth = 0;
  1965. break;
  1966. }
  1968. if (pColumnCheck && pColumnCheck->IsVisible())
  1969. {
  1970. nFreezeColumnsCount--;
  1971. nFreezeColumnWidth = pColumnCheck->GetRect().right;
  1972. }
  1973. }
  1974. }
  1976. if (rc.left - nFreezeColumnWidth <= 0 && m_nLeftOffset != 0)
  1977. {
  1978. SetLeftOffset(m_nLeftOffset + rc.left - nFreezeColumnWidth);
  1979. }
  1980. }
  1981. }
  1983. if (m_bFocusSubItems)
  1984. {
  1985. OnSelectionChanged();
  1986. }
  1987. }
  1989. return TRUE;
  1990. }
  1992. BOOL CXTPReportControl::SetFocusedRow(CXTPReportRow* pRow, BOOL bIgnoreSelection)
  1993. {
  1994. if(pRow)
  1995. {
  1996. int nFocusedRow = m_nFocusedRow != -1 ? m_nFocusedRow : m_nFocusedHeaderRow != -1 ? m_nFocusedHeaderRow : m_nFocusedFooterRow;
  1997. int nFocusedRowType = m_nFocusedRow != -1 ? xtpRowTypeBody : m_nFocusedHeaderRow != -1 ? xtpRowTypeHeader : xtpRowTypeFooter;
  1999. if (nFocusedRow != pRow->GetIndex() || pRow->GetType() != nFocusedRowType)
  2000. {
  2001. if (!OnFocusChanging(pRow, NULL))
  2002. return FALSE;
  2003. }
  2004. }
  2006. EditItem(NULL);
  2007. BeginUpdate();
  2009. BOOL bEnableSelection = (!bIgnoreSelection || !m_bMultipleSelection) && IsSelectionEnabled();
  2010. if (pRow && pRow->GetType() == xtpRowTypeHeader)
  2011. bEnableSelection &= IsHeaderRowsSelectionEnabled();
  2012. if (pRow && pRow->GetType() == xtpRowTypeFooter)
  2013. bEnableSelection &= IsFooterRowsSelectionEnabled();
  2015. if (bEnableSelection)
  2016. {
  2017. m_pSelectedRows->Select(pRow);
  2018. }
  2020. if (pRow)
  2021. {
  2022. m_nFocusedRow = m_nFocusedHeaderRow = m_nFocusedFooterRow = -1;
  2024. switch (pRow->GetType())
  2025. {
  2026. case xtpRowTypeBody:    m_nFocusedRow = pRow->GetIndex(); break;
  2027. case xtpRowTypeHeader:  m_nFocusedHeaderRow = pRow->GetIndex();  break;
  2028. case xtpRowTypeFooter:  m_nFocusedFooterRow = pRow->GetIndex(); break;
  2029. }
  2031. GetNavigator()->SetMovePosition(pRow->GetType());
  2033. EnsureVisible(pRow);
  2034. }
  2036. EndUpdate();
  2038. if (m_pSelectedRows->IsChanged())
  2039. OnSelectionChanged();
  2041. return TRUE;
  2042. }
  2044. BOOL CXTPReportControl::SetFocusedRow(CXTPReportRow* pRow, BOOL bSelectBlock, BOOL bIgnoreSelection)
  2045. {
  2046. if (!pRow)
  2047. return FALSE;
  2049. int nFocusedRow = m_nFocusedRow != -1 ? m_nFocusedRow : m_nFocusedHeaderRow != -1 ? m_nFocusedHeaderRow : m_nFocusedFooterRow;
  2050. int nFocusedRowType = m_nFocusedRow != -1 ? xtpRowTypeBody : m_nFocusedHeaderRow != -1 ? xtpRowTypeHeader : xtpRowTypeFooter;
  2052. if (nFocusedRow != pRow->GetIndex() || pRow->GetType() != nFocusedRowType)
  2053. {
  2054. if (!OnFocusChanging(pRow, NULL))
  2055. return FALSE;
  2056. }
  2058. EditItem(NULL);
  2059. BeginUpdate();
  2061. BOOL bEnableSelection = IsSelectionEnabled();
  2062. if(pRow && pRow->GetType() == xtpRowTypeHeader)
  2063. bEnableSelection &= IsHeaderRowsSelectionEnabled();
  2064. if(pRow && pRow->GetType() == xtpRowTypeFooter)
  2065. bEnableSelection &= IsFooterRowsSelectionEnabled();
  2067. if(bEnableSelection)
  2068. {
  2069. if (m_bMultipleSelection)
  2070. {
  2071. int nFocusedRow = m_nFocusedRow != -1 ? m_nFocusedRow : m_nFocusedHeaderRow != -1 ? m_nFocusedHeaderRow : m_nFocusedFooterRow;
  2072. if (bSelectBlock && nFocusedRow != -1)
  2073. {
  2074. m_pSelectedRows->SelectBlock(nFocusedRow, pRow->GetIndex());
  2076. }
  2077. else if (!bIgnoreSelection)
  2078. {
  2079. m_pSelectedRows->Select(pRow);
  2080. }
  2081. }
  2082. else
  2083. {
  2084. m_pSelectedRows->Select(pRow);
  2085. }
  2086. }
  2088. m_nFocusedRow = m_nFocusedHeaderRow = m_nFocusedFooterRow = -1;
  2090. switch(pRow->GetType())
  2091. {
  2092. case xtpRowTypeBody:    m_nFocusedRow       = pRow->GetIndex(); break;
  2093. case xtpRowTypeHeader:  m_nFocusedHeaderRow = pRow->GetIndex(); break;
  2094. case xtpRowTypeFooter:  m_nFocusedFooterRow = pRow->GetIndex(); break;
  2095. }
  2097. GetNavigator()->SetMovePosition(pRow->GetType());
  2099. EnsureVisible(pRow);
  2100. EndUpdate();
  2102. if (m_pSelectedRows->IsChanged())
  2103. OnSelectionChanged();
  2105. return TRUE;
  2106. }
  2109. void CXTPReportControl::SetLeftOffset(int nOffset)
  2110. {
  2111. if (nOffset < 0)
  2112. nOffset = 0;
  2114. if (nOffset == m_nLeftOffset)
  2115. return;
  2117. m_nLeftOffset = nOffset;
  2119. if (!m_bFullColumnScrolling)
  2120. SetScrollPos(SB_HORZ, nOffset);
  2122. AdjustScrollBars();
  2123. }
  2125. void CXTPReportControl::SetTopRow(int nIndex)
  2126. {
  2127. if (nIndex == m_nTopRow)
  2128. return;
  2130. ASSERT(nIndex >= 0);
  2132. if (nIndex < 0)
  2133. nIndex = 0;
  2135. m_nTopRow = nIndex;
  2136. SetScrollPos(SB_VERT, nIndex);
  2137. AdjustScrollBars();
  2138. }
  2140. void CXTPReportControl::EnsureVisible(CXTPReportRow* pCheckRow)
  2141. {
  2142. int nCheckIndex = pCheckRow ? pCheckRow->GetIndex() : -1;
  2144. if (nCheckIndex == -1 || !pCheckRow->m_bVisible || nCheckIndex >= m_pRows->GetCount())
  2145. return;
  2147. if(m_rcReportArea.Height() <= 0)
  2148. {
  2149. m_nEnsureVisibleRowIdx = nCheckIndex;
  2150. return;
  2151. }
  2153. if (nCheckIndex < m_nTopRow)
  2154. {
  2155. SetTopRow(nCheckIndex);
  2156. return;
  2157. }
  2159. CClientDC dc (this);
  2161. int top = m_rcReportArea.top;
  2162. int nHeaderWidth = GetReportHeader()->GetWidth();
  2164. for (int i = m_nTopRow; i < m_pRows->GetCount(); i++)
  2165. {
  2166. CXTPReportRow* pRow = m_pRows->GetAt(i);
  2167. ASSERT(pRow);
  2168. if (!pRow)
  2169. continue;
  2171. int nRowHeight = pRow->GetHeight(&dc, nHeaderWidth);
  2173. if (top + nRowHeight > m_rcReportArea.bottom)
  2174. break;
  2176. if (i == nCheckIndex)
  2177. return;
  2179. top += nRowHeight;
  2180. }
  2182. int nHeight = m_rcReportArea.Height();
  2183. for (top = nCheckIndex; top >= 0; top--)
  2184. {
  2185. CXTPReportRow* pRow = m_pRows->GetAt(top);
  2186. int nRowHeight = pRow->GetHeight(&dc, nHeaderWidth);
  2188. if (nHeight - nRowHeight < 0)
  2189. {
  2190. if (top != nCheckIndex)
  2191. top++;
  2192. break;
  2193. }
  2195. nHeight -= nRowHeight;
  2196. }
  2197. SetTopRow(top);
  2198. RedrawControl();
  2199. }
  2201. void CXTPReportControl::EnsureVisible(CXTPReportColumn* pCheckColumn)
  2202. {
  2203. int nCheckIndex = pCheckColumn ? pCheckColumn->GetIndex() : -1;
  2205. if (nCheckIndex == -1 || !pCheckColumn->m_bVisible || nCheckIndex >= m_pColumns->GetCount())
  2206. return;
  2208. if(m_rcReportArea.Height() <= 0)
  2209. {
  2210. m_nEnsureVisibleRowIdx = nCheckIndex;
  2211. return;
  2212. }
  2214. CRect rc(pCheckColumn->GetRect());
  2216. if (rc.right >= m_rcReportArea.Width())
  2217. {
  2218. SetLeftOffset(m_nLeftOffset + min(rc.left, rc.right - m_rcReportArea.Width()));
  2219. }
  2220. else
  2221. {
  2222. int nFreezeColumnWidth = 0;
  2223. if (m_nFreezeColumnsCount > 0)
  2224. {
  2225. int nFreezeColumnsCount = m_nFreezeColumnsCount;
  2226. for (int i = 0; (i < m_pColumns->GetCount()) && (nFreezeColumnsCount > 0); i++)
  2227. {
  2228. CXTPReportColumn* pColumn = m_pColumns->GetAt(i);
  2230. if (pColumn == pCheckColumn)
  2231. {
  2232. nFreezeColumnWidth = 0;
  2233. break;
  2234. }
  2236. if (pColumn && pColumn->IsVisible())
  2237. {
  2238. nFreezeColumnsCount--;
  2239. nFreezeColumnWidth = pColumn->GetRect().right;
  2240. }
  2241. }
  2242. }
  2244. if (rc.left - nFreezeColumnWidth <= 0 && m_nLeftOffset != 0)
  2245. {
  2246. SetLeftOffset(m_nLeftOffset + rc.left - nFreezeColumnWidth);
  2247. }
  2248. }
  2249. }
  2251. CXTPReportRow* CXTPReportControl::HitTest(CPoint pt) const
  2252. {
  2253. if (m_rcReportArea.PtInRect(pt))
  2254. {
  2255. for (int i = 0; i < m_arrScreenRows.GetCount(); i++)
  2256. {
  2257. CXTPReportRow* pRow = m_arrScreenRows.GetAt(i);
  2259. CRect rc = pRow->GetRect();
  2261. if (rc.PtInRect(pt))
  2262. return pRow;
  2263. }
  2264. }
  2266. // header records
  2267. if (m_rcHeaderRecordsArea.PtInRect(pt))
  2268. {
  2269. for (int i = 0; i < m_pHeaderRows->GetCount(); i++)
  2270. {
  2271. CXTPReportRow* pRow = m_pHeaderRows->GetAt(i);
  2273. CRect rc = pRow->GetRect();
  2275. if (rc.PtInRect(pt))
  2276. return pRow;
  2277. }
  2278. }
  2280. // footer records
  2281. if (m_rcFooterRecordsArea.PtInRect(pt))
  2282. {
  2283. for (int i = 0; i < m_pFooterRows->GetCount(); i++)
  2284. {
  2285. CXTPReportRow* pRow = m_pFooterRows->GetAt(i);
  2287. CRect rc = pRow->GetRect();
  2289. if (rc.PtInRect(pt))
  2290. return pRow;
  2291. }
  2292. }
  2294. return NULL;
  2295. }
  2297. int CXTPReportControl::GetReportAreaRows(int nStartRow, BOOL bMoveDown)
  2298. {
  2299. int nDirection = bMoveDown ? +1 : -1;
  2301. int top = m_rcReportArea.top;
  2303. CClientDC dc(this);
  2304. int nHeaderWidth = GetReportHeader()->GetWidth();
  2306. for (int i = nStartRow; (i < m_pRows->GetCount() && i >= 0); i += nDirection)
  2307. {
  2308. CXTPReportRow* pRow = m_pRows->GetAt(i);
  2309. ASSERT(pRow);
  2310. if (!pRow)
  2311. continue;
  2313. int rowHeight = pRow->GetHeight(&dc, nHeaderWidth);
  2315. if (top + rowHeight > m_rcReportArea.bottom)
  2316. return bMoveDown ? i - nStartRow - 1 : nStartRow - i - 1;
  2318. top += rowHeight;
  2319. }
  2321. return bMoveDown ? m_pRows->GetCount() - nStartRow : nStartRow;
  2322. }
  2324. void CXTPReportControl::AdjustLayout()
  2325. {
  2326. if (GetSafeHwnd() == 0)
  2327. return;
  2329. CXTPClientRect rc(this);
  2331. int nHeaderWidth = m_rcHeaderArea.Width();
  2333. CXTPReportHeader* pHeader = GetReportHeader();
  2334. int nGroupByHeight = (m_bGroupByEnabled && pHeader) ? pHeader->GetGroupByHeight() : 0;
  2335. m_rcGroupByArea.SetRect(0, 0, rc.Width(), nGroupByHeight);
  2337. int nHeaderHeight = 0;
  2338. int nFooterHeight = 0;
  2339. int nHeaderRecordsHeight = 0;
  2340. int nFooterRecordsHeight = 0;
  2342. if (m_bHeaderVisible)
  2343. {
  2344. CWindowDC dc (this);
  2345. nHeaderHeight = GetPaintManager()->GetHeaderHeight(this, &dc);
  2346. }
  2348. if (m_bFooterVisible)
  2349. {
  2350. CWindowDC dc (this);
  2351. nFooterHeight = GetPaintManager()->GetFooterHeight(this, &dc);
  2352. }
  2354. // header records divider
  2355. int nHeaderDividerHeight = GetHeaderRowsDividerHeight();
  2356. int nFooterDividerHeight = GetFooterRowsDividerHeight();
  2358. // header records height
  2359. if (m_bHeaderRecordsVisible)
  2360. {
  2361. nHeaderRecordsHeight = GetRowsHeight(m_pHeaderRows, rc.Width());
  2362. }
  2363. else
  2364. nHeaderDividerHeight = 0;
  2366. // footer records height
  2367. if (m_bFooterRecordsVisible)
  2368. {
  2369. nFooterRecordsHeight = GetRowsHeight(m_pFooterRows, rc.Width());
  2370. }
  2372. m_rcHeaderArea.SetRect(0, m_rcGroupByArea.bottom, rc.Width(), m_rcGroupByArea.bottom + nHeaderHeight);
  2373. m_rcHeaderRecordsArea.SetRect(0, m_rcHeaderArea.bottom, rc.Width(), m_rcHeaderArea.bottom + nHeaderRecordsHeight);
  2376. m_rcHeaderRecordsDividerArea.SetRect(0, m_rcHeaderRecordsArea.bottom, rc.Width(), m_rcHeaderRecordsArea.bottom + nHeaderDividerHeight);
  2378. int nFreeHeight = rc.Height() - nGroupByHeight- nHeaderHeight - nFooterHeight - nHeaderRecordsHeight - nFooterRecordsHeight - nHeaderDividerHeight - nFooterDividerHeight;
  2379. BOOL bPinned = FALSE;
  2381. if (m_bFooterRecordsVisible && m_bPinFooterRecords)
  2382. {
  2383. int nBodyRowsHeight = GetRowsHeight(m_pRows, rc.Width(), nFreeHeight);
  2385. if (nBodyRowsHeight < nFreeHeight)
  2386. {
  2387. // footer records immediately after body records
  2388. m_rcFooterRecordsArea.SetRect(0, m_rcHeaderRecordsArea.bottom + nHeaderDividerHeight + nFooterDividerHeight + nBodyRowsHeight, rc.Width(),
  2389. m_rcHeaderRecordsArea.bottom + nHeaderDividerHeight + nFooterDividerHeight + nBodyRowsHeight + nFooterRecordsHeight);
  2391. m_rcFooterRecordsDividerArea.SetRect(0,m_rcFooterRecordsArea.top - nFooterDividerHeight,rc.Width(), m_rcFooterRecordsArea.top);
  2392. bPinned = TRUE;
  2393. }
  2394. }
  2396. if (!bPinned)
  2397. {
  2398. if (rc.Height() - nFooterHeight - nFooterRecordsHeight > m_rcHeaderRecordsArea.bottom + nHeaderDividerHeight)
  2399. {
  2400. // there can be empty space between body rows and footer records rows
  2401. m_rcFooterRecordsArea.SetRect(0, rc.Height() - nFooterHeight - nFooterRecordsHeight, rc.Width(), rc.Height() - nFooterHeight);
  2402. }
  2403. else
  2404. {
  2405. // no place for body records (between header and footer records)
  2406. m_rcFooterRecordsArea.SetRect(0, m_rcHeaderRecordsArea.bottom + nHeaderDividerHeight, rc.Width(), m_rcHeaderRecordsArea.bottom + nFooterRecordsHeight + nHeaderDividerHeight);
  2407. }
  2409. m_rcFooterRecordsDividerArea.SetRect(0,m_rcFooterRecordsArea.top - nFooterDividerHeight -1,rc.Width(), m_rcFooterRecordsArea.top);
  2410. }
  2412. m_rcFooterArea.SetRect(0, rc.Height() - nFooterHeight, rc.Width(), rc.Height());
  2413. m_rcReportArea.SetRect(0, m_rcHeaderRecordsArea.bottom + nHeaderDividerHeight, rc.Width(), m_rcFooterRecordsArea.top - nFooterDividerHeight);
  2415. if (nHeaderWidth != m_rcHeaderArea.Width() && pHeader)
  2416. {
  2417. pHeader->AdjustColumnsWidth(m_rcHeaderArea.Width());
  2418. }
  2419. }
  2421. CScrollBar* CXTPReportControl::GetScrollBarCtrl(int nBar) const
  2422. {
  2423. if (DYNAMIC_DOWNCAST(CView, GetParent()))
  2424. return GetParent()->GetScrollBarCtrl(nBar);
  2426. return 0;
  2427. }
  2429. void CXTPReportControl::AdjustScrollBars()
  2430. {
  2431. if (GetSafeHwnd() == 0)
  2432. return;
  2434. EditItem(NULL);
  2436. int nHeight = m_rcReportArea.Height();
  2438. if (nHeight <= 0)
  2439. return;
  2441. BeginUpdate();
  2443. int nCount = m_pRows->GetCount() - 1;
  2444. int nLinesCount = nCount;
  2445. int nHeaderWidth = GetReportHeader()->GetWidth();
  2447. {
  2448. CClientDC dc(this);
  2450. for (; nLinesCount >= 0; nLinesCount--)
  2451. {
  2453. nHeight -= m_pRows->GetAt(nLinesCount)->GetHeight(&dc, nHeaderWidth);
  2455. if (nHeight < 0)
  2456. {
  2457. if (nLinesCount != nCount)
  2458. nLinesCount++;
  2460. break;
  2461. }
  2462. }
  2463. }
  2465. nLinesCount = max(nLinesCount, 0);
  2467. if (m_nTopRow > nLinesCount)
  2468. {
  2469. m_nTopRow = nLinesCount;
  2470. SetScrollPos(SB_VERT, m_nTopRow);
  2471. }
  2473. BOOL bEnabled = nLinesCount > 0;
  2475. if (bEnabled)
  2476. {
  2477. SCROLLINFO  si ;
  2478. si.cbSize = sizeof(SCROLLINFO);
  2479. si.nPage = nCount - nLinesCount + 1;
  2480. si.nMax = nCount;
  2481. si.nMin = 0 ;
  2482. si.fMask = SIF_PAGE | SIF_RANGE ;
  2483. SetScrollInfo(SB_VERT, &si) ;
  2484. }
  2486. EnableScrollBarCtrl(SB_VERT, bEnabled);
  2488. ::EnableScrollBar(m_hWnd, SB_VERT, (bEnabled && IsWindowEnabled()) ? ESB_ENABLE_BOTH : ESB_DISABLE_BOTH);
  2490. m_bVScrollBarVisible = bEnabled;
  2493. if (!GetReportHeader()->m_bAutoColumnSizing)
  2494. {
  2495. if (m_bFullColumnScrolling)
  2496. {
  2497. CXTPReportColumn *pPrev = NULL, *pCurr = NULL, *pNext = NULL;
  2498. int nScrollPos, nScrollMax;
  2499. GetReportHeader()->GetFulColScrollInfo(pPrev, pCurr, pNext, nScrollPos, nScrollMax);
  2501. bEnabled = nScrollMax > 1;
  2503. if (bEnabled)
  2504. {
  2505. SCROLLINFO  si ;
  2506. si.cbSize = sizeof(SCROLLINFO);
  2507. si.nPage = 1;
  2508. si.nMax = nScrollMax - 1;
  2509. si.nMin = 0;
  2510. si.nPos = nScrollPos;
  2511. si.fMask = SIF_PAGE | SIF_RANGE | SIF_POS;
  2512. SetScrollInfo(SB_HORZ, &si) ;
  2513. }
  2514. else
  2515. {
  2516. m_nLeftOffset = 0;
  2517. SetScrollPos(SB_HORZ, m_nLeftOffset);
  2518. }
  2519. }
  2520. else
  2521. {
  2522. nHeaderWidth = max(GetReportHeader()->GetWidth() - m_rcReportArea.Width(), 0);
  2524. if (m_nLeftOffset > nHeaderWidth)
  2525. {
  2526. m_nLeftOffset = nHeaderWidth;
  2527. SetScrollPos(SB_HORZ, m_nLeftOffset);
  2528. }
  2530. bEnabled = nHeaderWidth > 0;
  2532. if (bEnabled)
  2533. {
  2534. SCROLLINFO  si ;
  2535. si.cbSize = sizeof(SCROLLINFO);
  2536. si.nPage = m_rcReportArea.Width();
  2537. si.nMax = si.nPage + nHeaderWidth;
  2538. si.nMin = 0 ;
  2539. si.fMask = SIF_PAGE | SIF_RANGE ;
  2540. SetScrollInfo(SB_HORZ, &si) ;
  2541. }
  2542. }
  2544. EnableScrollBarCtrl(SB_HORZ, bEnabled);
  2545. m_bHScrollBarVisible = bEnabled;
  2546. ::EnableScrollBar(m_hWnd, SB_HORZ, (bEnabled && IsWindowEnabled()) ? ESB_ENABLE_BOTH : ESB_DISABLE_BOTH);
  2547. }
  2550. AdjustLayout();
  2552. EndUpdate();
  2554. }
  2556. void CXTPReportControl::SetFullColumnScrolling(BOOL bSet)
  2557. {
  2558. m_bFullColumnScrolling = bSet;
  2560. if (m_hWnd)
  2561. {
  2562. CXTPReportControl::OnHScroll(SB_TOP, 0, NULL);
  2564. RedrawControl();
  2565. UpdateWindow();
  2567. AdjustScrollBars();
  2568. }
  2569. }
  2571. BOOL CXTPReportControl::SetWatermarkBitmap(HBITMAP hBitmap, BYTE Transparency)
  2572. {
  2573. m_WatermarkTransparency = Transparency;
  2575. // if bitmap handle is NULL, remove watermark bitmap
  2576. if(!hBitmap)
  2577. {
  2578. ::DeleteObject(m_hbmpWatermark);
  2579. m_hbmpWatermark = NULL;
  2580. }
  2581. else
  2582. {
  2583. // remove old watermark bitmap if one is
  2584. if(m_hbmpWatermark)
  2585. {
  2586. ::DeleteObject(m_hbmpWatermark);
  2587. m_hbmpWatermark = NULL;
  2588. }
  2589. // add new watermark bitmap
  2590. m_hbmpWatermark = CXTPImageManagerIcon::CopyAlphaBitmap(hBitmap);
  2591. if(!m_hbmpWatermark)
  2592. return FALSE;
  2593. if(!CBitmap::FromHandle(m_hbmpWatermark)->GetBitmap(&m_bmWatermark))
  2594. {
  2595. ::DeleteObject(m_hbmpWatermark);
  2596. m_hbmpWatermark = NULL;
  2597. return FALSE;
  2598. }
  2599. BOOL bAlphaBitmap = m_bmWatermark.bmBitsPixel == 32;
  2600. // create an alpha bitmap if the bitmap supplied isn't an alpha one
  2601. if(!bAlphaBitmap)
  2602. {
  2603. CXTPCompatibleDC memWatermarkDC(NULL, m_hbmpWatermark);
  2604. CXTPImageManagerIcon::DrawAlphaBitmap(&memWatermarkDC, m_hbmpWatermark, CPoint(0, 0), CSize(m_bmWatermark.bmWidth, m_bmWatermark.bmHeight));
  2605. }
  2606. }
  2608. return TRUE;
  2609. }
  2611. BOOL CXTPReportControl::SetWatermarkBitmap(LPCTSTR szPath, BYTE Transparency)
  2612. {
  2613. m_WatermarkTransparency = Transparency;
  2615. // if path is empty, remove watermark bitmap
  2616. if(_tcslen(szPath) == 0)
  2617. {
  2618. ::DeleteObject(m_hbmpWatermark);
  2619. m_hbmpWatermark = NULL;
  2620. }
  2621. else
  2622. {
  2623. // remove old watermark bitmap if one is
  2624. if(m_hbmpWatermark)
  2625. {
  2626. ::DeleteObject(m_hbmpWatermark);
  2627. m_hbmpWatermark = NULL;
  2628. }
  2629. // add new watermark bitmap
  2630. BOOL bAlphaBitmap = FALSE;
  2631. m_hbmpWatermark = CXTPImageManagerIcon::LoadBitmapFromFile(szPath, &bAlphaBitmap);
  2632. if(!m_hbmpWatermark)
  2633. return FALSE;
  2634. if(!CBitmap::FromHandle(m_hbmpWatermark)->GetBitmap(&m_bmWatermark))
  2635. {
  2636. ::DeleteObject(m_hbmpWatermark);
  2637. m_hbmpWatermark = NULL;
  2638. return FALSE;
  2639. }
  2640. // create an alpha bitmap if the bitmap supplied isn't an alpha one
  2641. if(!bAlphaBitmap)
  2642. {
  2643. CXTPCompatibleDC memWatermarkDC(NULL, m_hbmpWatermark);
  2644. CXTPImageManagerIcon::DrawAlphaBitmap(&memWatermarkDC, m_hbmpWatermark, CPoint(0, 0), CSize(m_bmWatermark.bmWidth, m_bmWatermark.bmHeight));
  2645. }
  2646. }
  2648. return TRUE;
  2649. }
  2651. //////////////////////////////////////////////////////////////////////////
  2652. // CXTPReportControl message handlers
  2654. void CXTPReportControl::OnPaint()
  2655. {
  2656. CPaintDC dc(this);      // device context for painting
  2657. CXTPClientRect rc(this);
  2659. // ensure visible row and column if first started
  2660. if(m_nEnsureVisibleRowIdx >= 0)
  2661. {
  2662. EnsureVisible(GetRows()->GetAt(m_nEnsureVisibleRowIdx));
  2663. m_nEnsureVisibleRowIdx = -1;
  2664. }
  2665. if(m_nEnsureVisibleColumnIdx >= 0)
  2666. {
  2667. EnsureVisible(GetColumns()->GetAt(m_nEnsureVisibleColumnIdx));
  2668. m_nEnsureVisibleColumnIdx = -1;
  2669. }
  2671. // start counting drawing time
  2672. #ifdef XTP_DEBUG
  2673. LARGE_INTEGER iStartCount;
  2674. QueryPerformanceCounter(&iStartCount);
  2675. #endif
  2677. if (m_nLockUpdateCount == 0 && (IsChanged() || m_bmpCache.GetSafeHandle() == 0))
  2678. {
  2679. CDC memDC;
  2680. memDC.CreateCompatibleDC(&dc);
  2682. m_bmpCache.DeleteObject();
  2683. m_bmpCache.CreateCompatibleBitmap(&dc, rc.Width(), rc.Height());
  2686. CBitmap* pOldBitmap = memDC.SelectObject(&m_bmpCache);
  2688. OnDraw(&memDC);
  2690. // update flag
  2691. SetChanged(FALSE);
  2693. if (!IsWindowEnabled())
  2694. {
  2695. XTPImageManager()->DisableBitmap(memDC, rc, RGB(250, 250, 250), RGB(128, 128, 128));
  2696. }
  2698. if(m_hbmpWatermark)
  2699. {
  2700. CRect rcDst(GetReportRectangle());
  2701. if(IsHeaderRowsVisible())
  2702. rcDst.top = m_rcHeaderArea.top;
  2703. if(IsFooterRowsVisible())
  2704. rcDst.bottom = m_rcFooterArea.bottom;
  2705. CRect rcAll(rcDst);
  2706. CRect rcSrc(0, 0, m_bmWatermark.bmWidth, m_bmWatermark.bmHeight);
  2707. // no stretch
  2708. if(!(GetWatermarkAlignment() & xtpReportWatermarkStretch))
  2709. {
  2710. if(rcSrc.Width() > rcDst.Width())
  2711. rcSrc.right = rcSrc.left + rcDst.Width();
  2712. else
  2713. rcDst.right = rcDst.left + rcSrc.Width();
  2714. if(rcSrc.Height() > rcDst.Height())
  2715. rcSrc.bottom = rcSrc.top + rcDst.Height();
  2716. else
  2717. rcDst.bottom = rcDst.top + rcSrc.Height();
  2718. }
  2719. // enlarge only
  2720. if((GetWatermarkAlignment() & xtpReportWatermarkStretch) && (GetWatermarkAlignment() & xtpReportWatermarkEnlargeOnly))
  2721. {
  2722. if(rcSrc.Width() > rcDst.Width())
  2723. rcSrc.right = rcSrc.left + rcDst.Width();
  2724. if(rcSrc.Height() > rcDst.Height())
  2725. rcSrc.bottom = rcSrc.top + rcDst.Height();
  2726. }
  2727. // shrink only
  2728. if((GetWatermarkAlignment() & xtpReportWatermarkStretch) && (GetWatermarkAlignment() & xtpReportWatermarkShrinkOnly))
  2729. {
  2730. if(rcSrc.Width() < rcDst.Width())
  2731. rcDst.right = rcDst.left + rcSrc.Width();
  2732. if(rcSrc.Height() < rcDst.Height())
  2733. rcDst.bottom = rcDst.top + rcSrc.Height();
  2734. }
  2735. // preserve aspect ratio
  2736. if((GetWatermarkAlignment() & xtpReportWatermarkStretch) && (GetWatermarkAlignment() & xtpReportWatermarkPreserveRatio))
  2737. {
  2738. if(rcDst.Width() > (rcDst.Height() * rcSrc.Width() / rcSrc.Height()))
  2739. rcDst.right = rcDst.left + rcDst.Height() * rcSrc.Width() / rcSrc.Height();
  2740. if(rcDst.Height() > (rcDst.Width() * rcSrc.Height() / rcSrc.Width()))
  2741. rcDst.bottom = rcDst.top + rcDst.Width() * rcSrc.Height() / rcSrc.Width();
  2742. }
  2743. // alignment
  2744. //          if(!(GetWatermarkAlignment() & xtpReportWatermarkStretch))
  2745. {
  2746. // horizontal
  2747. switch(GetWatermarkAlignment() & xtpReportWatermarkHmask)
  2748. {
  2749. // center
  2750. case xtpReportWatermarkCenter :
  2751. rcDst.OffsetRect((rcAll.Width() - rcDst.Width()) / 2, 0);
  2752. break;
  2753. // right
  2754. case xtpReportWatermarkRight :
  2755. rcDst.OffsetRect(rcAll.Width() - rcDst.Width(), 0);
  2756. break;
  2757. // left
  2758. default :
  2759. break;
  2760. }
  2761. // vertical
  2762. switch(GetWatermarkAlignment() & xtpReportWatermarkVmask)
  2763. {
  2764. // center
  2765. case xtpReportWatermarkVCenter :
  2766. rcDst.OffsetRect(0, (rcAll.Height() - rcDst.Height()) / 2);
  2767. break;
  2768. // bottom
  2769. case xtpReportWatermarkBottom:
  2770. rcDst.OffsetRect(0, rcAll.Height() - rcDst.Height());
  2771. break;