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

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

对话框与窗口

开发平台：

Visual C++

XTPReportRow.cpp：源码内容
  1. // XTPReportRow.cpp : implementation of the CXTPReportRow 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/XTPToolTipContext.h"
  27. #include "XTPReportRecord.h"
  28. #include "XTPReportControl.h"
  29. #include "XTPReportPaintManager.h"
  30. #include "XTPReportRow.h"
  31. #include "XTPReportColumns.h"
  32. #include "XTPReportColumn.h"
  33. #include "XTPReportRecordItem.h"
  34. #include "XTPReportRecordItemText.h"
  35. #include "XTPReportTip.h"
  36. #include "XTPReportInplaceControls.h"
  37. #include "XTPReportHeader.h"
  39. #ifdef _DEBUG
  40. #define new DEBUG_NEW
  41. #undef THIS_FILE
  42. static char THIS_FILE[] = __FILE__;
  43. #endif
  45. IMPLEMENT_DYNAMIC(CXTPReportRow, CCmdTarget)
  46. /////////////////////////////////////////////////////////////////////////////
  47. // CXTPReportRow
  50. CXTPReportRow::CXTPReportRow()
  51. : m_pParentRow(NULL), m_pRecord(NULL), m_pControl(NULL), m_pParentRows(NULL)
  52. {
  53. m_nGroupLevel = m_nRowLevel = 0;
  56. m_bVisible = FALSE;
  57. m_pChilds = NULL;
  58. m_bExpanded = TRUE;
  60. m_rcRow.SetRectEmpty();
  61. m_rcCollapse.SetRectEmpty();
  62. m_nChildIndex = m_nIndex = -1;
  64. m_nPreviewHeight = 0;
  65. m_nRowType = xtpRowTypeBody;
  67. }
  69. void CXTPReportRow::InitRow(CXTPReportControl* pControl, CXTPReportRecord* pRecord)
  70. {
  71. ASSERT(pRecord || IsGroupRow());
  73. m_pControl = pControl;
  75. if (pRecord)
  76. {
  77. m_pRecord = pRecord;
  78. m_bExpanded = pRecord->m_bExpanded;
  79. m_pRecord->InternalAddRef();
  80. }
  81. }
  83. void CXTPReportRow::InitRow(CXTPReportRow* pRow)
  84. {
  85. ASSERT(pRow->m_pRecord);
  86. ASSERT(pRow->m_pParentRow == NULL);
  88. m_pControl = pRow->m_pControl;
  89. m_pRecord = pRow->m_pRecord;
  90. if (m_pRecord) m_pRecord->InternalAddRef();
  91. m_rcRow = pRow->m_rcRow;
  92. m_nIndex = pRow->m_nIndex;
  93. m_nPreviewHeight = pRow->m_nPreviewHeight;
  94. m_nRowLevel = pRow->m_nRowLevel;
  95. m_nGroupLevel = pRow->m_nGroupLevel;
  96. }
  99. CXTPReportRows* CXTPReportRow::GetChilds()
  100. {
  101. if (!m_pChilds)
  102. {
  103. m_pChilds = new CXTPReportRows();
  104. }
  105. return m_pChilds;
  106. }
  110. CXTPReportRow::~CXTPReportRow()
  111. {
  112. if (m_pChilds)
  113. {
  114. m_pChilds->InternalRelease();
  115. }
  117. if (m_pRecord)
  118. {
  119. m_pRecord->InternalRelease();
  120. }
  121. }
  123. int CXTPReportRow::GetHeight(CDC* pDC, int nWidth)
  124. {
  125. ASSERT(m_pControl);
  126. if (!m_pControl)
  127. return 0;
  128. int nHeight = m_pControl->GetPaintManager()->GetRowHeight(pDC, this, nWidth);
  130. if (!IsGroupRow() && !IsItemsVisible())
  131. nHeight = 0;
  133. if (pDC->IsPrinting())
  134. return nHeight;
  136. m_nPreviewHeight = 0;
  138. if (IsPreviewVisible())
  139. {
  140. CXTPReportRecordItemPreview* pItem = GetRecord()->GetItemPreview();
  142. m_nPreviewHeight = pItem->GetPreviewHeight(pDC, this, m_pControl->GetReportHeader()->GetWidth());
  143. m_nPreviewHeight = m_pControl->GetPaintManager()->GetPreviewItemHeight(pDC, this, m_pControl->GetReportHeader()->GetWidth(), m_nPreviewHeight);
  145. return nHeight + m_nPreviewHeight;
  146. }
  148. return nHeight;
  149. }
  152. BOOL CXTPReportRow::IsFocused() const
  153. {
  154. switch(m_nRowType)
  155. {
  156. case xtpRowTypeBody:
  157. return m_pControl->m_nFocusedRow == m_nIndex;
  158. case xtpRowTypeHeader:
  159. return m_pControl->m_nFocusedHeaderRow == m_nIndex;
  160. case xtpRowTypeFooter:
  161. return m_pControl->m_nFocusedFooterRow == m_nIndex;
  162. }
  164. return FALSE;
  165. }
  167. BOOL CXTPReportRow::IsSelected() const
  168. {
  169. return m_pControl->GetSelectedRows()->Contains(this);
  170. }
  172. void CXTPReportRow::SetSelected(BOOL bSelected)
  173. {
  174. if (bSelected)
  175. {
  176. if (!m_pControl->IsMultipleSelection())
  177. m_pControl->GetSelectedRows()->Clear();
  179. m_pControl->GetSelectedRows()->Add(this);
  180. }
  181. else
  182. {
  183. m_pControl->GetSelectedRows()->Remove(this);
  184. }
  186. m_pControl->RedrawControl();
  187. }
  189. int CXTPReportRow::GetLastChildRow(CXTPReportRows* pChilds) const
  190. {
  191. CXTPReportRow* pRow = pChilds->GetAt(pChilds->GetCount() - 1);
  192. return pRow->HasChildren() && pRow->IsExpanded() ? GetLastChildRow(pRow->GetChilds()) : pRow->GetIndex();
  193. }
  195. void CXTPReportRow::SelectChilds()
  196. {
  197. if (!(m_pControl->IsMultipleSelection() && HasChildren() && IsExpanded() && m_nIndex != -1))
  198. return;
  200. m_pControl->BeginUpdate();
  202. int nIndexBegin = m_nIndex + 1;
  203. int nIndexEnd = GetLastChildRow(GetChilds());
  205. m_pControl->GetSelectedRows()->AddBlock(nIndexBegin, nIndexEnd);
  207. m_pControl->EndUpdate();
  208. }
  210. BOOL CXTPReportRow::IsItemsVisible() const
  211. {
  212. return TRUE;
  213. }
  216. BOOL CXTPReportRow::IsPreviewVisible() const
  217. {
  218. return !IsGroupRow() && m_pRecord && m_pControl->IsPreviewMode() && m_pRecord->GetItemPreview() != NULL;
  219. }
  221. void CXTPReportRow::Draw(CDC* pDC, CRect rcRow, int nLeftOffset)
  222. {
  223. ASSERT(m_pControl);
  224. if (!m_pControl)
  225. return;
  227. BOOL bControlFocused = m_pControl->HasFocus();
  228. int nFreezeCols = m_pControl->m_nFreezeColumnsCount;
  229. CRect rcClipBox = m_pControl->GetReportRectangle();
  231. m_rcRow = rcRow;
  232. m_rcRow.left -= nLeftOffset;
  233. m_rcRow.right -= nLeftOffset;
  235. if (nFreezeCols == 0)
  236. {
  237. rcRow = m_rcRow;
  238. }
  240. XTP_REPORTRECORDITEM_DRAWARGS drawArgs;
  241. drawArgs.pDC = pDC;
  242. drawArgs.pControl = m_pControl;
  243. drawArgs.pRow = this;
  244. int nIndentWidth = m_pControl->GetHeaderIndent();
  245. CXTPReportPaintManager* pPaintManager = m_pControl->GetPaintManager();
  247. CXTPReportColumns arrVisibleColumns(m_pControl);
  248. m_pControl->GetColumns()->GetVisibleColumns(arrVisibleColumns);
  249. int nVisColCount = arrVisibleColumns.GetCount();
  250. nFreezeCols = min(nFreezeCols, nVisColCount);
  252. // paint row background
  253. pPaintManager->FillRow(pDC, this, m_rcRow);
  255. CRect rcItem(m_rcRow.left, m_rcRow.top, m_rcRow.right, m_rcRow.bottom - m_nPreviewHeight);
  257. CRect rcIndent(nFreezeCols ? rcRow : m_rcRow);
  258. rcIndent.right = rcIndent.left + nIndentWidth;
  260. if (m_pRecord) // if drawing record, not group
  261. {
  262. int xMinCol_0 = rcRow.left + nIndentWidth;
  263. // paint record items
  264. for (int nColumn = nVisColCount-1; nColumn >= 0; nColumn--)
  265. {
  266. BOOL bFreezeCol = nColumn < nFreezeCols;
  267. int nColIdx = bFreezeCol ? nFreezeCols - 1 - nColumn : nColumn;
  269. CXTPReportColumn* pColumn = arrVisibleColumns.GetAt(nColIdx);
  270. ASSERT(pColumn && pColumn->IsVisible());
  272. if (pColumn && IsItemsVisible())
  273. {
  274. rcItem.left = pColumn->GetRect().left;
  275. if (nColIdx == 0)
  276. {
  277. rcItem.left = max(xMinCol_0, rcItem.left);
  278. }
  279. rcItem.right = pColumn->GetRect().right;
  281. if (!CRect().IntersectRect(rcClipBox, rcItem))
  282. continue;
  284. if (bFreezeCol)
  285. {
  286. pDC->FillSolidRect(rcItem, pPaintManager->GetControlBackColor(GetControl()));
  287. pPaintManager->FillRow(pDC, this, rcItem);
  288. }
  290. CRect rcGridItem(rcItem);
  291. rcGridItem.left--;
  293. // draw shade background if sorted by this row
  294. if (pColumn->IsSorted())
  295. {
  296. pPaintManager->FillItemShade(pDC, rcItem);
  297. }
  299. CXTPReportRecordItem* pItem = m_pRecord->GetItem(pColumn);
  301. if (pItem)
  302. {
  303. // draw item
  304. drawArgs.pColumn = pColumn;
  305. drawArgs.rcItem = rcItem;
  306. drawArgs.nTextAlign = pColumn->GetAlignment();
  307. drawArgs.pItem = pItem;
  308. // draw item
  309. int nItemTextWidth = pItem->Draw(&drawArgs);
  311. pColumn->m_nMaxItemWidth = max(pColumn->m_nMaxItemWidth, nItemTextWidth);
  312. }
  314. pPaintManager->DrawGrid(pDC, TRUE, rcGridItem);
  316. if (nColIdx == nFreezeCols - 1)
  317. pPaintManager->DrawFreezeColsDivider(pDC, rcGridItem, GetControl(), this);
  318. }
  319. }
  321. if (IsPreviewVisible())
  322. {
  323. CRect rcPreviewItem(m_rcRow);
  324. rcPreviewItem.DeflateRect(nIndentWidth, rcPreviewItem.Height() - m_nPreviewHeight, 0, 0);
  326. drawArgs.rcItem = rcPreviewItem;
  327. drawArgs.nTextAlign = DT_LEFT;
  328. drawArgs.pItem = m_pRecord->GetItemPreview();
  329. drawArgs.pColumn = NULL;
  331. drawArgs.pItem->Draw(&drawArgs);
  332. }
  334. if (nIndentWidth > 0)
  335. {
  336. // draw indent column
  337. pPaintManager->FillIndent(pDC, rcIndent);
  338. }
  339. }
  341. BOOL bGridVisible = pPaintManager->IsGridVisible(FALSE);
  343. //CRect rcFocus(m_rcRow.left + nIndentWidth, m_rcRow.top, m_rcRow.right, m_rcRow.bottom - (bGridVisible ? 1 : 0));
  344. CRect rcFocus(rcIndent.right, m_rcRow.top, m_rcRow.right, m_rcRow.bottom - (bGridVisible ? 1 : 0));
  346. if (IsFocused() && bControlFocused && m_pControl->IsRowFocusVisible())
  347. pPaintManager->DrawFocusedRow(pDC, rcFocus);
  350. if (m_nIndex < m_pControl->GetRows()->GetCount() - 1 && nIndentWidth > 0)
  351. {
  352. CXTPReportRow* pNextRow = m_pControl->GetRows()->GetAt(m_nIndex + 1);
  353. ASSERT(pNextRow);
  354. if (pNextRow) rcFocus.left = rcIndent.left + min(nIndentWidth, pPaintManager->m_nTreeIndent * pNextRow->GetTreeDepth());
  355. }
  356. else
  357. {
  358. rcFocus.left = m_rcRow.left;
  359. }
  361. pPaintManager->DrawGrid(pDC, FALSE, rcFocus);
  363. }
  365. int CXTPReportRow::GetTreeDepth() const
  366. {
  367. return m_nRowLevel;
  368. }
  370. INT_PTR CXTPReportRow::OnToolHitTest(CPoint point, TOOLINFO* pTI)
  371. {
  372. CRect rcItem;
  373. CXTPReportRecordItem* pItem = HitTest(point, &rcItem);
  375. if (!pItem)
  376. return -1;
  378. INT_PTR nHit = (INT_PTR)pItem;
  379. CString strTip = pItem->GetTooltip();
  381. m_pControl->OnGetToolTipInfo(this, pItem, strTip);
  383. if (strTip.IsEmpty() || strTip == _T(" "))
  384. return -1;
  386. CXTPToolTipContext::FillInToolInfo(pTI, m_pControl->m_hWnd, rcItem,
  387. nHit, strTip);
  389. return nHit;
  390. }
  392. BOOL CXTPReportRow::OnLButtonDown(XTP_REPORTRECORDITEM_CLICKARGS* pClickArgs)
  393. {
  394. if(pClickArgs->pItem && pClickArgs->pItem->OnLButtonDown(pClickArgs))
  395. return TRUE;
  396. return (BOOL)m_pControl->SendMessageToParent(this, pClickArgs->pItem, pClickArgs->pColumn, XTP_NM_REPORT_LBUTTONDOWN, &pClickArgs->ptClient);
  397. }
  399. BOOL CXTPReportRow::OnLButtonUp(XTP_REPORTRECORDITEM_CLICKARGS* pClickArgs)
  400. {
  401. if(pClickArgs->pItem)
  402. pClickArgs->pItem->OnLButtonUp(pClickArgs);
  403. return TRUE;
  404. }
  406. void CXTPReportRow::OnClick(CPoint ptClicked)
  407. {
  408. XTP_REPORTRECORDITEM_CLICKARGS clickArgs;
  409. clickArgs.pControl = m_pControl;
  410. clickArgs.pRow = this;
  411. clickArgs.ptClient = ptClicked;
  412. clickArgs.pColumn = NULL;
  414. // find clicked item
  415. clickArgs.pItem = HitTest(ptClicked, &clickArgs.rcItem, &clickArgs.pColumn);
  417. if(m_pControl->IsVirtualMode())
  418. {
  419. if (m_nRowLevel == 0 && m_rcCollapse.PtInRect(ptClicked)
  420. && clickArgs.pColumn && clickArgs.pColumn->IsTreeColumn())
  421. {
  422. m_pControl->SendMessageToParent(this, NULL, NULL, XTP_NM_REPORT_ROWEXPANDED, NULL);
  423. return;
  424. }
  425. }
  426. if (HasChildren() && m_rcCollapse.PtInRect(ptClicked)
  427. && clickArgs.pColumn && clickArgs.pColumn->IsTreeColumn())
  428. {
  429. SetExpanded(!IsExpanded());
  430. return;
  431. }
  433. // notify item if found
  434. if (!clickArgs.pItem)
  435. return;
  437. clickArgs.pItem->OnClick(&clickArgs);
  438. }
  440. void CXTPReportRow::OnDblClick(CPoint ptClicked)
  441. {
  442. XTP_REPORTRECORDITEM_CLICKARGS clickArgs;
  443. clickArgs.pControl = m_pControl;
  444. clickArgs.pRow = this;
  445. clickArgs.ptClient = ptClicked;
  446. clickArgs.pColumn = NULL;
  448. // find clicked item
  449. clickArgs.pItem = HitTest(ptClicked, &clickArgs.rcItem, &clickArgs.pColumn);
  451. // notify item if found
  452. if (clickArgs.pItem != NULL)
  453. {
  454. clickArgs.pItem->OnDblClick(&clickArgs);
  455. }
  456. else
  457. {
  458. // just notify parent
  459. m_pControl->SendMessageToParent(this, NULL, clickArgs.pColumn, NM_DBLCLK, &ptClicked, -1);
  460. }
  461. }
  463. CRect CXTPReportRow::GetItemRect(CXTPReportRecordItem* pItem)
  464. {
  465. if (!IsItemsVisible() || !pItem || !m_pRecord)
  466. return CRect(0, 0, 0, 0);
  468. if (IsPreviewVisible() && pItem == GetRecord()->GetItemPreview())
  469. {
  470. return CRect(m_rcRow.left + m_pControl->GetHeaderIndent(),
  471. m_rcRow.bottom - m_nPreviewHeight, m_rcRow.right, m_rcRow.bottom);
  472. }
  474. CXTPReportColumns* pColumns = m_pControl->GetColumns();
  475. int nColumnCount = pColumns->GetCount();
  477. CRect rcItem(0, m_rcRow.top, 0, m_rcRow.bottom - m_nPreviewHeight);
  479. int nFreezeColCount = m_pControl->GetFreezeColumnsCount();
  480. int nLeft = nFreezeColCount ? pColumns->GetAt(nFreezeColCount - 1)->GetRect().right : 0;
  482. for (int nColumn = 0; nColumn < nColumnCount; nColumn++)
  483. {
  484. CXTPReportColumn* pColumn = pColumns->GetAt(nColumn);
  485. if (pColumn && pColumn->IsVisible())
  486. {
  487. if (m_pRecord->GetItem(pColumn) != pItem)
  488. continue;
  490. rcItem.left = pColumn->GetRect().left;
  491. rcItem.right = pColumn->GetRect().right;
  492. if(pColumn->GetIndex() >= nFreezeColCount)
  493. {
  494. rcItem.left = max(rcItem.left, nLeft);
  495. rcItem.right = max(rcItem.right, nLeft);
  496. }
  497. if(rcItem.Width() <= 0)
  498. return CRect(0, 0, 0, 0);
  499. ShiftTreeIndent(rcItem, pColumn);
  500. return rcItem;
  501. }
  502. }
  503. return CRect(0, 0, 0, 0);
  504. }
  506. void CXTPReportRow::ShiftTreeIndent(CRect& rcItem, CXTPReportColumn* pColumn) const
  507. {
  508. if (pColumn->IsTreeColumn())
  509. {
  510. int nTreeDepth = GetTreeDepth() - m_nGroupLevel;
  511. if (nTreeDepth > 0)
  512. nTreeDepth++;
  513. rcItem.left += m_pControl->GetIndent(nTreeDepth);
  515. CRect rcBitmap(rcItem);
  516. int nIndent = m_pControl->GetPaintManager()->DrawCollapsedBitmap(NULL, this, rcBitmap).cx;
  518. rcItem.left += nIndent + 1;
  519. }
  520. }
  522. CXTPReportRecordItem* CXTPReportRow::HitTest(CPoint ptPoint, CRect* pRectItem, CXTPReportColumn** ppColumn) const
  523. {
  524. if (!m_pRecord)
  525. return NULL;
  527. // find record item
  528. int x = m_rcRow.left + m_pControl->GetHeaderIndent();
  530. CXTPReportColumns* pColumns = m_pControl->GetColumns();
  531. int nColumnCount = pColumns->GetCount();
  534. // if hittes for Preview item
  535. if (IsPreviewVisible())
  536. {
  537. CXTPReportRecordItemPreview* pPreviewItem = GetRecord()->GetItemPreview();
  538. if (pPreviewItem)
  539. {
  540. CRect rcItem(x, m_rcRow.bottom - m_nPreviewHeight, m_rcRow.right, m_rcRow.bottom);
  541. if (rcItem.PtInRect(ptPoint))
  542. {
  543. if (pRectItem)
  544. {
  545. *pRectItem = rcItem;
  546. }
  547. return pPreviewItem;
  548. }
  549. }
  550. }
  552. CRect rcItem(0, m_rcRow.top, 0, m_rcRow.bottom - m_nPreviewHeight);
  554. if (!IsItemsVisible())
  555. return NULL;
  557. int nFreezeColCount = m_pControl->GetFreezeColumnsCount();
  558. int nLeft = nFreezeColCount ? pColumns->GetAt(nFreezeColCount - 1)->GetRect().right : 0;
  560. for (int nColumn = 0; nColumn < nColumnCount; nColumn++)
  561. {
  562. CXTPReportColumn* pColumn = pColumns->GetAt(nColumn);
  563. if (pColumn && pColumn->IsVisible())
  564. {
  565. rcItem.left = pColumn->GetRect().left;
  566. rcItem.right = pColumn->GetRect().right;
  567. if(pColumn->GetIndex() >= nFreezeColCount)
  568. {
  569. rcItem.left = max(rcItem.left, nLeft);
  570. rcItem.right = max(rcItem.right, nLeft);
  571. }
  572. if(!rcItem.Width())
  573. continue;
  575. if (rcItem.PtInRect(ptPoint) && ppColumn)
  576. {
  577. *ppColumn = pColumn;
  578. }
  579. // make tooltip shift if tree view (see also Draw function)
  580. ShiftTreeIndent(rcItem, pColumn);
  582. // check point
  583. if (rcItem.PtInRect(ptPoint))
  584. {
  585. if (pRectItem)
  586. {
  587. *pRectItem = rcItem;
  588. }
  590. return m_pRecord->GetItem(pColumn);
  591. }
  592. }
  593. }
  595. return NULL;
  596. }
  598. void CXTPReportRow::OnMouseMove(UINT nFlags, CPoint point)
  599. {
  601. // find clicked item
  602. CRect rcItem;
  603. CXTPReportRecordItem* pItem = HitTest(point, &rcItem);
  605. // notify item if found
  606. if (pItem != NULL)
  607. {
  608. pItem->OnMouseMove(nFlags, point, m_pControl);
  609. }
  611. }
  614. void CXTPReportRow::FillMetrics(CXTPReportColumn* pColumn, CXTPReportRecordItem* pItem, XTP_REPORTRECORDITEM_METRICS* pMetrics)
  615. {
  616. m_pControl->m_nLockUpdateCount++;
  617. XTP_REPORTRECORDITEM_DRAWARGS drawArgs;
  618. drawArgs.pDC = NULL;
  619. drawArgs.pColumn = pColumn;
  620. drawArgs.pControl = m_pControl;
  621. drawArgs.pRow = this;
  622. drawArgs.rcItem.SetRectEmpty();
  623. drawArgs.pItem = pItem;
  624. drawArgs.nTextAlign = pColumn ? pColumn->GetAlignment() : DT_LEFT;
  625. GetItemMetrics(&drawArgs, pMetrics);
  626. m_pControl->m_nLockUpdateCount--;
  627. }
  629. void CXTPReportRow::ShowToolTip(CPoint ptTip, CXTPReportTip* pTipWnd)
  630. {
  631. CRect rcItem(0, 0, 0, 0);
  632. CXTPReportColumn* pColumn = NULL;
  633. CXTPReportRecordItem* pItem = HitTest(ptTip, &rcItem, &pColumn);
  634. // show tooltip
  635. if (!(pItem && (pItem->IsPreviewItem() || !pItem->IsPreviewItem() && pColumn)))
  636. {
  637. pTipWnd->m_pItem = NULL;
  638. pTipWnd->m_nRowIndex = -1;
  639. return;
  640. }
  642. if (!CXTPDrawHelpers::IsTopParentActive(m_pControl->GetSafeHwnd()) || m_pControl->GetActiveItem())
  643. {
  644. return;
  645. }
  647. if ((pItem != pTipWnd->m_pItem) || (m_nIndex != pTipWnd->m_nRowIndex))
  648. {
  649. pTipWnd->m_pItem = pItem;
  650. pTipWnd->m_nRowIndex = m_nIndex;
  652. CString strTip = pItem->GetTooltip();
  653. m_pControl->OnGetToolTipInfo(this, pItem, strTip);
  655. if (!strTip.IsEmpty() || strTip == _T(" ") || pColumn && (pColumn->GetAlignment() & DT_WORDBREAK))
  656. return;
  658. if (pItem->GetMarkupUIElement() != 0)
  659. return;
  661. XTP_REPORTRECORDITEM_METRICS* pMetrics = new XTP_REPORTRECORDITEM_METRICS();
  662. pMetrics->strText = pItem->GetCaption(pColumn);
  663. FillMetrics(pColumn, pItem, pMetrics);
  665. CString strText(pMetrics->strText);
  667. strText.TrimRight();
  669. if (strText.IsEmpty())
  670. {
  671. pMetrics->InternalRelease();
  672. return;
  673. }
  675. XTP_REPORTRECORDITEM_ARGS itemArgs;
  676. itemArgs.pControl = m_pControl;
  677. itemArgs.pRow = this;
  679. pItem->GetCaptionRect(&itemArgs, rcItem);
  681. m_pControl->ClientToScreen(&rcItem);
  683. if (!pTipWnd->GetSafeHwnd())
  684. {
  685. pTipWnd->Create(m_pControl);
  686. }
  688. CWindowDC dc(m_pControl);
  689. CXTPFontDC font(&dc, pMetrics->pFont);
  690. CRect rcTooltip(rcItem);
  691. BOOL bActivate = FALSE;
  692. if (pItem->IsPreviewItem())
  693. {
  694. CRect rcCalc(rcTooltip.left, 0, rcTooltip.right, 0);
  695. dc.DrawText(strText, rcCalc, DT_WORDBREAK | DT_CALCRECT | DT_NOPREFIX);
  696. bActivate = (rcCalc.Height() / dc.GetTextExtent(_T(" "), 1).cy) > m_pControl->GetPaintManager()->GetMaxPreviewLines();
  697. rcTooltip.bottom = rcTooltip.top + rcCalc.Height();
  698. rcTooltip.right++;
  699. }
  700. else
  701. {
  702. CSize sz = dc.GetTextExtent(strText);
  703. bActivate = sz.cx > (rcTooltip.Width() - 4);
  704. }
  706. if (bActivate)
  707. {
  708. rcTooltip.InflateRect(1, 1, 0, 0);
  710. pTipWnd->SetFont(pMetrics->pFont);
  711. pTipWnd->SetTooltipText(strText);
  712. pTipWnd->SetHoverRect(rcTooltip);
  713. pTipWnd->Activate(TRUE, pItem->IsPreviewItem());
  715. TRACKMOUSEEVENT tme =
  716. {
  717. sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_pControl->GetSafeHwnd(), 0
  718. };
  719. _TrackMouseEvent (&tme);
  720. }
  722. pMetrics->InternalRelease();
  723. }
  724. }
  726. BOOL CXTPReportRow::HasParent(CXTPReportRow* pRow)
  727. {
  728. if (m_pParentRow == NULL)
  729. return FALSE;
  730. if (pRow == m_pParentRow)
  731. return TRUE;
  732. return m_pParentRow->HasParent(pRow);
  733. }
  735. void CXTPReportRow::SetExpanded(BOOL bExpanded)
  736. {
  737. if (bExpanded != m_bExpanded && HasChildren())
  738. {
  739. if (bExpanded)
  740. {
  741. m_pControl->_DoExpand(this);
  742. }
  743. else
  744. {
  745. m_pControl->_DoCollapse(this);
  746. }
  748. if (m_pRecord)
  749. {
  750. m_pRecord->m_bExpanded = bExpanded;
  751. }
  753. m_bExpanded = bExpanded;
  755. m_pControl->_RefreshIndexes();
  756. m_pControl->SendMessageToParent(this, NULL, NULL, XTP_NM_REPORT_ROWEXPANDED, NULL);
  757. }
  758. else
  759. {
  760. m_bExpanded = bExpanded;
  761. }
  763. }
  765. CXTPReportRow* CXTPReportRow::AddChild(CXTPReportRow* pRow)
  766. {
  767. GetChilds()->Add(pRow);
  768. pRow->m_pParentRow = this;
  770. return pRow;
  771. }
  773. void CXTPReportRow::OnContextMenu(CPoint ptClick)
  774. {
  775. CXTPReportColumn* pColumn = NULL;
  776. CXTPReportRecordItem* pItem = HitTest(ptClick, NULL, &pColumn);
  778. m_pControl->ClientToScreen(&ptClick);
  780. // send process notification to the user and wait for the reaction
  781. m_pControl->SendMessageToParent(this, pItem, pColumn, NM_RCLICK, &ptClick);
  782. }
  784. void CXTPReportRow::GetItemMetrics(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, XTP_REPORTRECORDITEM_METRICS* pItemMetrics)
  785. {
  786. ASSERT(m_pRecord);
  787. ASSERT(pDrawArgs->pRow == this);
  788. ASSERT(pDrawArgs->pItem != NULL);
  789. if (!m_pRecord || !pDrawArgs->pItem)
  790. return;
  792. CXTPReportPaintManager* pPaintManager = pDrawArgs->pControl->GetPaintManager();
  794. pItemMetrics->pFont = &pPaintManager->m_fontText;
  795. pItemMetrics->clrForeground = pPaintManager->m_clrWindowText;
  796. pItemMetrics->clrBackground = XTP_REPORT_COLOR_DEFAULT;
  797. pItemMetrics->nColumnAlignment = pDrawArgs->nTextAlign;
  798. pItemMetrics->nItemIcon = XTP_REPORT_NOICON;
  800. m_pRecord->GetItemMetrics(pDrawArgs, pItemMetrics);
  801. pDrawArgs->pItem->GetItemMetrics(pDrawArgs, pItemMetrics);
  803. m_pControl->GetItemMetrics(pDrawArgs, pItemMetrics);
  804. pDrawArgs->nTextAlign = pItemMetrics->nColumnAlignment;
  806. if (IsSelected() && (pDrawArgs->pDC && !pDrawArgs->pDC->IsPrinting()))
  807. {
  808. if (pDrawArgs->pColumn && IsFocused() && m_pControl->m_pFocusedColumn == pDrawArgs->pColumn)
  809. return;
  811. if (GetControl()->HasFocus())
  812. {
  813. pItemMetrics->clrForeground = pPaintManager->m_clrHighlightText;
  814. pItemMetrics->clrBackground = pPaintManager->m_clrHighlight;
  815. }
  816. else if (!pPaintManager->m_bHideSelection)
  817. {
  818. pItemMetrics->clrForeground = pPaintManager->m_clrSelectedRowText;
  819. pItemMetrics->clrBackground = pPaintManager->m_clrSelectedRow;
  820. }
  821. }
  822. }
  824. BOOL CXTPReportRow::HasChildren() const
  825. {
  826. return m_pChilds && m_pChilds->GetCount() > 0;
  827. }
  829. int CXTPReportRow::GetIndex() const
  830. {
  831. return m_nIndex;
  832. }
  834. BOOL CXTPReportRow::IsGroupRow() const
  835. {
  836. return FALSE;
  837. }
  839. BOOL CXTPReportRow::IsExpanded() const
  840. {
  841. return m_bExpanded;
  842. }
  844. BOOL CXTPReportRow::IsLastTreeRow() const
  845. {
  846. if (!m_pParentRow)
  847. return FALSE;
  849. CXTPReportRows* pRows = m_pParentRow->GetChilds();
  851. return pRows->GetCount() > 0 && pRows->GetAt(pRows->GetCount() - 1) == this;
  852. }
  854. void CXTPReportRow::EnsureVisible()
  855. {
  856. m_pControl->EnsureVisible(this);
  858. }
  860. CXTPReportRow* CXTPReportRow::GetNextSiblingRow() const
  861. {
  862. if (!m_pParentRows)
  863. return 0;
  865. if (m_nChildIndex == -1)
  866. return 0;
  868. ASSERT(m_pParentRows->GetAt(m_nChildIndex) == this);
  870. if (m_nChildIndex < m_pParentRows->GetCount() - 1)
  871. return m_pParentRows->GetAt(m_nChildIndex + 1);
  873. return 0;
  874. }
  877. void CXTPReportRow::DrawFixed(CDC* pDC, CRect rcRow, int nLeftOffset, CRect rcArea)
  878. {
  879. ASSERT(m_pControl);
  880. if (!m_pControl)
  881. return;
  883. //  BOOL bControlFocused = m_pControl->HasFocus();
  884. int nFreezeCols = m_pControl->m_nFreezeColumnsCount;
  886. CRect rcClipBox = rcArea ;
  888. m_rcRow = rcRow;
  889. m_rcRow.left -= nLeftOffset;
  890. m_rcRow.right -= nLeftOffset;
  892. if (nFreezeCols == 0)
  893. {
  894. rcRow = m_rcRow;
  895. }
  897. XTP_REPORTRECORDITEM_DRAWARGS drawArgs;
  898. drawArgs.pDC = pDC;
  899. drawArgs.pControl = m_pControl;
  900. drawArgs.pRow = this;
  901. int nIndentWidth = m_pControl->GetHeaderIndent();
  903. CXTPReportPaintManager* pPaintManager = m_pControl->GetPaintManager();
  905. // whether to draw header's last horizontal grid depends on header divider style.
  906. BOOL bDrawLastHeaderGrid = TRUE;
  907. if (GetType() == xtpRowTypeHeader)
  908. {
  909. bDrawLastHeaderGrid = xtpReportFixedRowsDividerNone == (pPaintManager->GetHeaderRowsDividerStyle() & ~xtpReportFixedRowsDividerShade);
  910. }
  912. // whether to draw footer's first horizontal grid depends on footer divider style.
  913. BOOL bDrawFirstFooterGrid = TRUE;
  914. if (GetType() == xtpRowTypeFooter)
  915. {
  916. bDrawFirstFooterGrid = xtpReportFixedRowsDividerNone == (pPaintManager->GetFooterRowsDividerStyle() & ~xtpReportFixedRowsDividerShade);
  917. }
  919. CXTPReportColumns arrVisibleColumns(m_pControl);
  920. m_pControl->GetColumns()->GetVisibleColumns(arrVisibleColumns);
  921. int nVisColCount = arrVisibleColumns.GetCount();
  922. nFreezeCols = min(nFreezeCols, nVisColCount);
  924. // paint row background
  925. pDC->FillSolidRect(m_rcRow, pPaintManager->GetControlBackColor(GetControl()));
  927. CRect rcItem(m_rcRow.left, m_rcRow.top, m_rcRow.right, m_rcRow.bottom - m_nPreviewHeight);
  929. CRect rcIndent(nFreezeCols ? rcRow : m_rcRow);
  930. rcIndent.right = rcIndent.left + nIndentWidth;
  932. if (m_pRecord) // if drawing record, not group
  933. {
  934. int xMinCol_0 = rcRow.left + nIndentWidth;
  935. // paint record items
  936. for (int nColumn = nVisColCount-1; nColumn >= 0; nColumn--)
  937. {
  938. BOOL bFreezeCol = nColumn < nFreezeCols;
  939. int nColIdx = bFreezeCol ? nFreezeCols - 1 - nColumn : nColumn;
  941. CXTPReportColumn* pColumn = arrVisibleColumns.GetAt(nColIdx);
  942. ASSERT(pColumn && pColumn->IsVisible());
  944. if (pColumn && IsItemsVisible())
  945. {
  946. rcItem.left = pColumn->GetRect().left;
  947. if (nColIdx == 0)
  948. {
  949. rcItem.left = max(xMinCol_0, rcItem.left);
  950. }
  951. rcItem.right = pColumn->GetRect().right;
  953. if (!CRect().IntersectRect(rcClipBox, rcItem))
  954. continue;
  956. if (bFreezeCol)
  957. {
  958. pDC->FillSolidRect(rcItem, pPaintManager->GetControlBackColor(GetControl()));
  959. pPaintManager->FillRow(pDC, this, rcItem);
  960. }
  962. CRect rcGridItem(rcItem);
  963. rcGridItem.left--;
  965. // draw shade background if sorted by this row
  966. if (pColumn->IsSorted())
  967. {
  968. pPaintManager->FillItemShade(pDC, rcItem);
  969. }
  971. CXTPReportRecordItem* pItem = m_pRecord->GetItem(pColumn);
  973. if (pItem)
  974. {
  975. // draw item
  976. drawArgs.pColumn = pColumn;
  977. drawArgs.rcItem = rcItem;
  978. drawArgs.nTextAlign = pColumn->GetAlignment();
  979. drawArgs.pItem = pItem;
  980. // draw item
  981. int nItemTextWidth = pItem->Draw(&drawArgs);
  983. pColumn->m_nMaxItemWidth = max(pColumn->m_nMaxItemWidth, nItemTextWidth);
  984. }
  986. // is vertical grid required
  987. if (GetType() == xtpRowTypeHeader)
  988. {
  989. if (pColumn->GetDrawHeaderRowsVGrid())
  990. pPaintManager->DrawGrid(pDC, TRUE, rcGridItem);
  991. }
  992. else
  993. if (GetType() == xtpRowTypeFooter)
  994. {
  995. if (pColumn->GetDrawFooterRowsVGrid())
  996. pPaintManager->DrawGrid(pDC, TRUE, rcGridItem);
  997. }
  999. if (bDrawFirstFooterGrid)
  1000. {
  1001. // horizontal grid above
  1002. CRect rcTop(rcGridItem);
  1003. rcTop.bottom = --rcGridItem.top;
  1004. pPaintManager->DrawGrid(pDC, FALSE, rcTop);
  1005. }
  1006. bDrawFirstFooterGrid = TRUE;
  1008. if (nColIdx == nFreezeCols - 1)
  1009. pPaintManager->DrawFreezeColsDivider(pDC, rcGridItem, GetControl(), this);
  1010. }
  1011. }
  1013. if (nIndentWidth > 0)
  1014. {
  1015. // draw indent column
  1016. pPaintManager->FillIndent(pDC, rcIndent);
  1017. }
  1018. }
  1020. // draw focus
  1021. BOOL bControlFocused = m_pControl->HasFocus();
  1022. BOOL bGridVisible = pPaintManager->IsGridVisible(FALSE);
  1023. CRect rcFocus(rcIndent.right, m_rcRow.top, m_rcRow.right, m_rcRow.bottom - (bGridVisible ? 1 : 0));
  1025. if (IsFocused() && bControlFocused && m_pControl->IsRowFocusVisible())
  1026. pPaintManager->DrawFocusedRow(pDC, rcFocus);
  1028. // last header grid line
  1029. if (bDrawLastHeaderGrid)
  1030. {
  1031. pPaintManager->DrawGrid(pDC, FALSE, rcFocus);
  1032. }
  1033. }