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

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

对话框与窗口

开发平台：

Visual C++

XTPReportControl.cpp：源码内容
  1. // top
  2. default :
  3. break;
  4. }
  5. }
  7. CXTPCompatibleDC memWatermarkDC(&dc, m_hbmpWatermark);
  9. COLORREF clrBk = GetPaintManager()->m_clrControlBack;
  10. CRect rcReport00(0, 0, rc.Width(), rc.Height());
  12. CBitmap bmpTmp;
  13. bmpTmp.CreateCompatibleBitmap(&dc, rc.Width(), rc.Height());
  15. CXTPCompatibleDC memDCtmp(&dc, &bmpTmp);
  17. memDCtmp.FillSolidRect(&rcReport00, clrBk);
  19. if(GetWatermarkAlignment() & xtpReportWatermarkStretch)
  20. {
  21. CBitmap bmpWatermarkTmp;
  22. bmpWatermarkTmp.CreateCompatibleBitmap(&dc, rc.Width(), rc.Height());
  23. CXTPCompatibleDC memWatermarkDCtmp(&dc, &bmpWatermarkTmp);
  24. memWatermarkDCtmp.FillSolidRect(&rc, RGB(255, 255, 255));
  25. memWatermarkDCtmp.SetStretchBltMode(HALFTONE);
  26. memWatermarkDCtmp.StretchBlt(rcDst.left, rcDst.top, rcDst.Width(), rcDst.Height(), &memWatermarkDC, 0, 0, rcSrc.Width(), rcSrc.Height(), SRCCOPY);
  28. XTPImageManager()->AlphaBlend2(memDCtmp, rc, memWatermarkDCtmp, rc, m_WatermarkTransparency);
  29. }
  30. else
  31. {
  32. XTPImageManager()->AlphaBlend2(memDCtmp, rcDst, memWatermarkDC, rcSrc, m_WatermarkTransparency);
  33. }
  35. XTPImageManager()->TransparentBlt(memDCtmp, rcReport00, memDC, rcReport00, clrBk);
  37. memDC.BitBlt(0, 0, rc.right, rc.bottom, &memDCtmp, 0, 0, SRCCOPY);
  38. }
  40. dc.BitBlt(0, 0, rc.right, rc.bottom, &memDC, 0, 0, SRCCOPY);
  42. memDC.SelectObject(pOldBitmap);
  43. }
  44. else
  45. {
  46. CXTPCompatibleDC memDC(&dc, &m_bmpCache);
  47. dc.BitBlt(0, 0, rc.right, rc.bottom, &memDC, 0, 0, SRCCOPY);
  48. }
  50. // count drawing time
  51. #ifdef XTP_DEBUG
  52. LARGE_INTEGER iEndCount;
  53. QueryPerformanceCounter(&iEndCount);
  54. XTP_TRACE(_T("Draw counter ticks: %dn"), iEndCount.LowPart-iStartCount.LowPart);
  55. #endif
  57. }
  59. LRESULT CXTPReportControl::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  60. {
  61. CDC* pDC = CDC::FromHandle((HDC)wParam);
  62. if (pDC)
  63. {
  64. if (m_bmpCache.GetSafeHandle() == 0)
  65. OnDraw(pDC);
  66. else
  67. {
  68. CXTPCompatibleDC memDC(pDC, &m_bmpCache);
  69. CXTPClientRect rc(this);
  70. pDC->BitBlt(0, 0, rc.right, rc.bottom, &memDC, 0, 0, SRCCOPY);
  71. }
  72. }
  74. return TRUE;
  75. }
  77. BOOL CXTPReportControl::OnEraseBkgnd(CDC* /*pDC*/)
  78. {
  79. return TRUE;    // Don't erase the background.
  80. }
  82. void CXTPReportControl::OnDraw(CDC* pDC)
  83. {
  84. if (GetExStyle() & WS_EX_RTLREADING)
  85. {
  86. pDC->SetTextAlign(TA_RTLREADING);
  87. }
  89. // draw new image
  90. pDC->FillSolidRect(CXTPClientRect(this), GetPaintManager()->GetControlBackColor(this));
  92. CXTPReportHeader* pHeader = GetReportHeader();
  94. CRect rcHeader = m_rcHeaderArea;
  95. rcHeader.right = rcHeader.left + pHeader->GetWidth();
  97. // draw header
  98. if (pHeader)
  99. pHeader->Draw(pDC, rcHeader, m_nLeftOffset);
  101. // draw group by box
  102. if (pHeader)
  103. pHeader->DrawGroupByControl(pDC, m_rcGroupByArea);
  105. DrawRows(pDC, m_rcReportArea);
  107. if (m_bHeaderRecordsVisible && m_pHeaderRows->GetCount() > 0)
  108. {
  109. DrawFixedRows(pDC, m_rcHeaderRecordsArea, m_pHeaderRows);
  110. DrawFixedRecordsDivider(pDC, m_rcHeaderRecordsDividerArea, TRUE);
  111. }
  113. if (m_bFooterRecordsVisible && m_pFooterRows->GetCount() > 0)
  114. {
  115. DrawFixedRows(pDC, m_rcFooterRecordsArea, m_pFooterRows);
  116. DrawFixedRecordsDivider(pDC, m_rcFooterRecordsDividerArea, FALSE);
  117. }
  119. CRect rcFooter = m_rcFooterArea;
  120. if (rcFooter.Height() > 0)
  121. pHeader->DrawFooter(pDC, rcFooter, m_nLeftOffset);
  123. if (m_nDropPos != -1)
  124. {
  125. DrawDropMarker(pDC);
  126. }
  129. // update flag
  130. SetChanged(FALSE);
  131. }
  133. void CXTPReportControl::DrawDropMarker(CDC* pDC)
  134. {
  135. CRect rc(m_rcReportArea.left, m_nDropPos, m_rcReportArea.right, m_nDropPos + 1);
  137. pDC->FillSolidRect(rc, GetPaintManager()->m_clrHotDivider);
  139. CXTPPenDC pen (*pDC, GetPaintManager()->m_clrHotDivider);
  140. CXTPBrushDC brush (*pDC, GetPaintManager()->m_clrHotDivider);
  142. int x = rc.left;
  143. int y = m_nDropPos;
  145. POINT ptsLeftArrow[] =
  146. {
  147. {x, y - 2}, {x + 2, y - 2}, {x + 2, y - 5}, {x + 7, y},
  148. {x + 2, y + 5}, {x + 2, y + 2}, {x, y + 2}
  149. };
  150. pDC->Polygon(ptsLeftArrow, 7);
  152. x = rc.right - 1;
  154. POINT ptsRightArrow[] =
  155. {
  156. {x, y - 2}, {x - 2, y - 2}, {x - 2, y - 5}, {x - 7, y},
  157. {x - 2, y + 5}, {x - 2, y + 2}, {x, y + 2}
  158. };
  159. pDC->Polygon(ptsRightArrow, 7);
  162. }
  164. void CXTPReportControl::OnSize(UINT nType, int cx, int cy)
  165. {
  166. if (m_bOnSizeRunning)
  167. return;
  169. m_bOnSizeRunning = TRUE;
  171. CWnd::OnSize(nType, cx, cy);
  173. AdjustLayout();
  174. AdjustScrollBars();
  176. m_bOnSizeRunning = FALSE;
  177. }
  179. void CXTPReportControl::OnRButtonDown(UINT nFlags, CPoint point)
  180. {
  181. CWnd::OnRButtonDown(nFlags, point);
  183. }
  185. void CXTPReportControl::OnRButtonUp(UINT nFlags, CPoint point)
  186. {
  187. HWND hWnd = m_hWnd;
  188. CWnd::OnRButtonUp(nFlags, point);
  190. if (!IsWindow(hWnd)) // Can be destroyed in WM_CONTEXTMENU
  191. return;
  193. }
  196. void CXTPReportControl::OnLButtonDown(UINT nFlags, CPoint point)
  197. {
  198. CWnd::OnLButtonDown(nFlags, point);
  199. SetFocus();
  200. EditItem(NULL);
  202. // columns processing
  203. CXTPReportHeader* pHeader = GetReportHeader();
  204. if (pHeader)
  205. {
  206. pHeader->OnLButtonDown(point);
  207. }
  209. // rows selection
  210. CXTPReportRow* pRow = HitTest(point);
  211. if (pRow)
  212. {
  213. XTP_REPORTRECORDITEM_CLICKARGS clickArgs;
  214. clickArgs.pControl = this;
  215. clickArgs.pRow = pRow;
  216. clickArgs.ptClient = point;
  217. clickArgs.pColumn = NULL;
  219. // find clicked item
  220. clickArgs.pItem = pRow->HitTest(point, &clickArgs.rcItem, &clickArgs.pColumn);
  222. if (pRow->OnLButtonDown(&clickArgs))
  223. return;
  225. // some rows may be unaccessible for end user
  226. if (pRow->GetType() == xtpRowTypeHeader && !m_bHeaderRowsAllowAccess)
  227. return;
  229. if (pRow->GetType() == xtpRowTypeFooter && !m_bFooterRowsAllowAccess)
  230. return;
  232. bool bIgnoreSelection = GetKeyState(VK_CONTROL) < 0 || IsMultiSelectionMode();
  233. bool bSelectBlock = GetKeyState(VK_SHIFT) < 0;
  234. BOOL bFocusChanged = TRUE;
  237. CXTPReportColumn* pFocusedColumn = clickArgs.pColumn;
  240. CUpdateContext updateContext(this);
  242. if (m_bFocusSubItems && pFocusedColumn && pRow->GetRecord() && pRow->GetRecord()->GetItem(pFocusedColumn)->IsFocusable())
  243. {
  244. SetFocusedColumn(pFocusedColumn);
  245. }
  247. if (pRow->IsSelected() && !bIgnoreSelection && !bSelectBlock)
  248. {
  249. m_pSelectOnUpRow = pRow;
  250. }
  251. else
  252. {
  253. bFocusChanged = SetFocusedRow(pRow, bSelectBlock, bIgnoreSelection);
  254. }
  256. BOOL bSelectionChanged = m_pSelectedRows->IsChanged();
  257. if (bFocusChanged && bIgnoreSelection && IsSelectionEnabled())
  258. {
  259. m_pSelectedRows->Invert(pRow);
  260. if(!bSelectionChanged && m_pSelectedRows->IsChanged())
  261. OnSelectionChanged();
  262. }
  264. m_pointDrag = point;
  265. m_bPrepareDrag = TRUE;
  267. }
  269. }
  271. void CXTPReportControl::OnLButtonUp(UINT nFlags, CPoint point)
  272. {
  273. CWnd::OnLButtonUp(nFlags, point);
  275. m_bPrepareDrag = FALSE;
  277. EnsureStopAutoVertScroll();
  279. // columns processing
  280. CXTPReportHeader* pHeader = GetReportHeader();
  281. if (pHeader)
  282. {
  283. pHeader->OnLButtonUp(nFlags, point);
  284. }
  286. CXTPReportRow* pRow = HitTest(point);
  288. if (pRow)
  289. {
  290. if (pRow == m_pSelectOnUpRow)
  291. {
  292. SetFocusedRow(pRow, FALSE, FALSE);
  293. }
  295. XTP_REPORTRECORDITEM_CLICKARGS clickArgs;
  296. clickArgs.pControl = this;
  297. clickArgs.pRow = pRow;
  298. clickArgs.ptClient = point;
  299. clickArgs.pColumn = NULL;
  301. // find clicked item
  302. clickArgs.pItem = pRow->HitTest(point, &clickArgs.rcItem, &clickArgs.pColumn);
  304. pRow->OnLButtonUp(&clickArgs);
  305. }
  307. m_pSelectOnUpRow = NULL;
  309. if (!m_bMultipleSelection || (GetKeyState(VK_SHIFT) >= 0 && (GetKeyState(VK_CONTROL) >= 0 && !IsMultiSelectionMode())))
  310. {
  311. // rows processing
  312. if (pRow && pRow->IsFocused())
  313. {
  314. pRow->OnClick(point);
  315. }
  316. }
  319. }
  321. void CXTPReportControl::OnLButtonDblClk(UINT nFlags, CPoint ptDblClick)
  322. {
  323. CWnd::OnLButtonDblClk(nFlags, ptDblClick);
  325. // columns processing
  326. CXTPReportHeader* pHeader = GetReportHeader();
  327. if (pHeader)
  328. {
  329. pHeader->OnLButtonDblClk(ptDblClick);
  330. }
  332. // rows processing
  333. CXTPReportRow* pRow = HitTest(ptDblClick);
  334. if (pRow)
  335. {
  336. pRow->OnDblClick(ptDblClick);
  337. }
  338. else
  339. {
  340. // just notify parent
  341. SendMessageToParent(NULL, NULL, NULL, NM_DBLCLK, &ptDblClick);
  342. }
  344. }
  345. void CXTPReportControl::OnContextMenu(CWnd* /*pWnd*/, CPoint pos)
  346. {
  347. if (GetMouseMode() != xtpReportMouseNothing)
  348. return;
  350. CPoint ptClient = pos;
  351. ScreenToClient(&ptClient);
  353. // call context menu handler for report header if clicked inside
  354. if (m_rcHeaderArea.PtInRect(ptClient) ||
  355. m_rcGroupByArea.PtInRect(ptClient))
  356. {
  357. CXTPReportHeader* pHeader = GetReportHeader();
  358. if (pHeader)
  359. pHeader->OnContextMenu(ptClient);
  360. return;
  361. }
  363. // call context menu handler for report area if clicked inside
  364. if (m_rcReportArea.PtInRect(ptClient)           ||
  365. m_rcHeaderRecordsArea.PtInRect(ptClient)    ||
  366. m_rcFooterRecordsArea.PtInRect(ptClient))
  367. {
  368. // rows processing
  369. CXTPReportRow* pRow = HitTest(ptClient);
  370. if (pRow)
  371. {
  372. SetFocusedRow(pRow, pRow->IsSelected());
  373. pRow->OnContextMenu(ptClient);
  374. }
  375. else
  376. {
  377. SendMessageToParent(NULL, NULL, NULL, NM_RCLICK, &pos);
  378. }
  380. return;
  381. }
  383. if (pos == CPoint(-1, -1))
  384. {
  385. CXTPReportRow* pFocusedRow = GetFocusedRow();
  386. if (pFocusedRow)
  387. {
  388. ptClient = CPoint(pFocusedRow->GetRect().left, pFocusedRow->GetRect().bottom);
  389. pFocusedRow->OnContextMenu(ptClient);
  390. }
  391. else
  392. {
  393. pos = m_rcReportArea.TopLeft();
  394. ClientToScreen(&pos);
  395. SendMessageToParent(NULL, NULL, NULL, NM_RCLICK, &pos);
  396. }
  397. }
  398. }
  400. CXTPReportColumn* CXTPReportControl::GetNextFocusableColumn(CXTPReportRow* pRow, int nColumnIndex, int nDirection)
  401. {
  402. if (!pRow->GetRecord())
  403. return NULL;
  405. for (;;)
  406. {
  407. CXTPReportColumn* pColumn = GetReportHeader()->GetNextVisibleColumn(nColumnIndex, nDirection);
  408. if (!pColumn)
  409. return NULL;
  411. CXTPReportRecordItem* pItem = pRow->GetRecord()->GetItem(pColumn);
  413. if (pItem && pItem->IsFocusable())
  414. return pColumn;
  416. nColumnIndex = pColumn->GetIndex();
  417. }
  418. }
  420. BOOL CXTPReportControl::OnPreviewKeyDown(UINT& rnChar, UINT nRepCnt, UINT nFlags)
  421. {
  422. XTP_NM_REPORTPREVIEWKEYDOWN nmParams;
  423. ::ZeroMemory(&nmParams, sizeof(nmParams));
  425. nmParams.nChar = rnChar;
  426. nmParams.nRepCnt = nRepCnt;
  427. nmParams.nFlags = nFlags;
  428. nmParams.bCancel = FALSE;
  430. SendNotifyMessage(XTP_NM_REPORT_PREVIEWKEYDOWN, (NMHDR*)&nmParams);
  431. rnChar = nmParams.nChar;
  433. return !nmParams.bCancel;
  434. }
  436. void CXTPReportControl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  437. {
  438. //  TRACE(_T("ReportControl, OnKeyDown('%d') n"), nChar);
  440. // Moved to PreTranslateMessage
  441. //  if (!OnPreviewKeyDown(nChar, nRepCnt, nFlags))
  442. //  {
  443. //      return;
  444. //  }
  446. CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
  448. BOOL  bSelectBlock = GetKeyState(VK_SHIFT) < 0;
  449. BOOL  bSignoreSelection = GetKeyState(VK_CONTROL) < 0 || IsMultiSelectionMode();
  451. CXTPReportRow* pFocusedRow = GetFocusedRow();
  453. CXTPDrawHelpers::KeyToLayout(this, nChar);
  455. if (m_pRows->GetCount() != 0)
  456. switch (nChar)
  457. {
  458. case VK_ADD:
  459. if (bSignoreSelection)
  460. ExpandAll();
  461. else if (pFocusedRow && pFocusedRow->HasChildren() && !pFocusedRow->IsExpanded())
  462. {
  463. pFocusedRow->SetExpanded(TRUE);
  464. }
  465. break;
  467. case VK_SUBTRACT:
  468. if (bSignoreSelection)
  469. CollapseAll();
  470. else if (pFocusedRow && pFocusedRow->HasChildren() && pFocusedRow->IsExpanded())
  471. {
  472. pFocusedRow->SetExpanded(FALSE);
  473. }
  474. break;
  476. case VK_RIGHT:
  477. if (pFocusedRow && pFocusedRow->HasChildren() && !pFocusedRow->IsExpanded())
  478. {
  479. pFocusedRow->SetExpanded(TRUE);
  480. break;
  481. }
  482. if (pFocusedRow && m_bFocusSubItems && m_pFocusedColumn)
  483. {
  484. CXTPReportColumn* pColumn = GetNextFocusableColumn(pFocusedRow, m_pFocusedColumn->GetIndex(), +1);
  485. if (pColumn)
  486. {
  487. SetFocusedColumn(pColumn);
  488. SetFocusedRow(GetFocusedRow());
  489. }
  490. break;
  491. }
  493. case VK_DOWN:
  494. GetNavigator()->MoveDown(bSelectBlock, bSignoreSelection);
  495. break;
  497. case  VK_LEFT:
  498. if (pFocusedRow && pFocusedRow->HasChildren() && pFocusedRow->IsExpanded())
  499. {
  500. pFocusedRow->SetExpanded(FALSE);
  501. break;
  502. }
  503. if (pFocusedRow && m_bFocusSubItems && m_pFocusedColumn)
  504. {
  505. CXTPReportColumn* pColumn = GetNextFocusableColumn(pFocusedRow, m_pFocusedColumn->GetIndex(), -1);
  506. if (pColumn)
  507. {
  508. SetFocusedColumn(pColumn);
  509. SetFocusedRow(GetFocusedRow());
  510. }
  511. break;
  512. }
  513. if (pFocusedRow && !pFocusedRow->HasChildren() && pFocusedRow->GetParentRow() && !bSelectBlock)
  514. {
  515. SetFocusedRow(pFocusedRow->GetParentRow());
  516. pFocusedRow->SetExpanded(FALSE);
  517. break;
  518. }
  520. case VK_UP:
  521. GetNavigator()->MoveUp(bSelectBlock, bSignoreSelection);
  522. break;
  524. case VK_HOME:
  525. GetNavigator()->MoveFirstRow(bSelectBlock, FALSE);
  526. break;
  528. case VK_END:
  529. GetNavigator()->MoveLastRow(bSelectBlock, FALSE);
  530. break;
  532. case VK_NEXT:
  533. GetNavigator()->MovePageDown(bSelectBlock, FALSE);
  534. break;
  536. case VK_PRIOR:
  537. GetNavigator()->MovePageUp(bSelectBlock, FALSE);
  538. break;
  540. case VK_RETURN:
  541. if (pFocusedRow && pFocusedRow->HasChildren())
  542. {
  543. pFocusedRow->SetExpanded(!pFocusedRow->IsExpanded());
  544. }
  545. break;
  547. case VK_ESCAPE:
  548. if (m_mouseMode != xtpReportMouseNothing)
  549. {
  550. GetReportHeader()->CancelMouseMode();
  551. }
  552. break;
  554. case VK_F2:
  555. GetNavigator()->BeginEdit();
  556. break;
  557. case VK_SPACE:
  558. if(IsSelectionEnabled() && bSignoreSelection && pFocusedRow)
  559. {
  560. //              m_pSelectedRows->Invert(pFocusedRow);
  561. if(pFocusedRow->IsSelected())
  562. m_pSelectedRows->Remove(pFocusedRow);
  563. else
  564. m_pSelectedRows->Add(pFocusedRow);
  565. OnSelectionChanged();
  566. }
  567. break;
  568. }
  570. NMKEY nmgv;
  571. nmgv.nVKey = nChar;
  572. nmgv.uFlags = nFlags;
  573. SendNotifyMessage(NM_KEYDOWN, (NMHDR*)&nmgv);
  575. }
  577. void CXTPReportControl::OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  578. {
  579. CWnd::OnSysKeyDown(nChar, nRepCnt, nFlags);
  580. }
  582. void CXTPReportControl::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
  583. {
  584. CWnd::OnKeyUp(nChar, nRepCnt, nFlags);
  585. }
  587. void CXTPReportControl::OnSysKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
  588. {
  589. CWnd::OnSysKeyUp(nChar, nRepCnt, nFlags);
  590. }
  592. void CXTPReportControl::OnChar(UINT nChar, UINT nRepCntr, UINT nFlags)
  593. {
  594. //  TRACE(_T("ReportControl, OnChar('%d') n"), nChar);
  596. // Moved to PreTranslateMessage
  597. //  if (!OnPreviewKeyDown(nChar, nRepCntr, nFlags))
  598. //  {
  599. //      return;
  600. //  }
  602. NMCHAR nmgv;
  603. ZeroMemory(&nmgv, sizeof(NMCHAR));
  604. nmgv.ch = nChar;
  605. SendNotifyMessage(NM_CHAR, (NMHDR*)&nmgv);
  608. CXTPReportRow* pFocusedRow = GetFocusedRow();
  610. if (m_bFocusSubItems && pFocusedRow && (nChar == VK_TAB))
  611. {
  612. EditItem(NULL);
  614. BOOL bBack = GetKeyState(VK_SHIFT) < 0;
  616. GetNavigator()->MoveLeftRight(bBack);
  618. return;
  619. }
  621. if (m_pFocusedColumn && pFocusedRow && pFocusedRow->GetRecord() && (nChar != VK_RETURN) && (nChar != VK_ESCAPE))
  622. {
  623. XTP_REPORTRECORDITEM_ARGS itemArgs(this, pFocusedRow, m_pFocusedColumn) ;
  625. if (itemArgs.pItem && itemArgs.pItem->OnChar(&itemArgs, nChar))
  626. return;
  627. }
  629. CWnd::OnChar(nChar, nRepCntr, nFlags);
  630. }
  632. void CXTPReportControl::OnCaptureChanged(CWnd* pWnd)
  633. {
  634. if (m_mouseMode != xtpReportMouseNothing)
  635. {
  636. GetReportHeader()->CancelMouseMode();
  637. }
  638. CWnd::OnCaptureChanged(pWnd);
  639. }
  641. void CXTPReportControl::OnEnable(BOOL bEnable)
  642. {
  643. UNREFERENCED_PARAMETER(bEnable);
  645. AdjustScrollBars();
  646. }
  648. void CXTPReportControl::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  649. {
  650. if (pScrollBar != NULL)
  651. {
  652. CWnd::OnVScroll(nSBCode, nPos, pScrollBar);
  653. return;
  654. }
  655. int nCurPos = m_nTopRow;
  657. // decide what to do for each diffrent scroll event
  658. switch (nSBCode)
  659. {
  660. case SB_TOP: nCurPos = 0; break;
  661. case SB_BOTTOM: nCurPos = GetScrollLimit(SB_VERT); break;
  662. case SB_LINEUP: nCurPos = max(nCurPos - 1, 0); break;
  663. case SB_LINEDOWN: nCurPos = min(nCurPos + 1, GetScrollLimit(SB_VERT)); break;
  665. case SB_PAGEUP: nCurPos = max(nCurPos - GetReportAreaRows(nCurPos, false), 0); break;
  666. case SB_PAGEDOWN: nCurPos = min(nCurPos + GetReportAreaRows(nCurPos, true), GetScrollLimit(SB_VERT)); break;
  668. case SB_THUMBTRACK:
  669. case SB_THUMBPOSITION:
  670. {
  671. SCROLLINFO si;
  672. ZeroMemory(&si, sizeof(SCROLLINFO));
  673. si.cbSize = sizeof(SCROLLINFO);
  674. si.fMask = SIF_TRACKPOS;
  676. if (!GetScrollInfo(SB_VERT, &si))
  677. return;
  678. nCurPos = si.nTrackPos;
  679. }
  680. break;
  681. }
  683. SetTopRow(nCurPos);
  684. }
  686. void CXTPReportControl::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  687. {
  688. if (pScrollBar != NULL)
  689. {
  690. CWnd::OnHScroll(nSBCode, nPos, pScrollBar);
  691. return;
  692. }
  693. int nCurPos = m_nLeftOffset;
  695. // FCS - full column scrolling
  696. int nLeftOffset_new = m_nLeftOffset;
  698. CXTPReportColumn *pPrev = NULL, *pCurr = NULL, *pNext = NULL;
  699. int nScrollPos = 0, nScrollMax = 0;
  700. int nFreezOffset = 0;
  701. if (m_bFullColumnScrolling)
  702. nFreezOffset = GetReportHeader()->GetFulColScrollInfo(pPrev, pCurr, pNext, nScrollPos, nScrollMax);
  704. // decide what to do for each different scroll event
  705. switch (nSBCode)
  706. {
  707. case SB_TOP:
  708. nCurPos = 0;
  709. nLeftOffset_new = 0;
  710. nScrollPos = 0;
  711. break;
  713. case SB_BOTTOM:
  714. nCurPos = GetScrollLimit(SB_HORZ);
  715. if (m_bFullColumnScrolling)
  716. {
  717. int nVisColCount = GetColumns()->GetVisibleColumnsCount();
  718. CXTPReportColumn *pLast = GetColumns()->GetVisibleAt(max(nVisColCount-1, 0));
  719. ASSERT(pLast);
  720. if (!pLast)
  721. return;
  723. nLeftOffset_new = labs(GetReportHeader()->m_rcHeader.left - pLast->GetRect().left) - nFreezOffset;
  724. nScrollPos = max(nScrollMax - 1, 0);
  725. }
  726. break;
  728. case SB_LINEUP:
  729. nCurPos = max(nCurPos - m_nHScrollStep, 0);
  730. if (m_bFullColumnScrolling && pPrev)
  731. {
  732. nLeftOffset_new = labs(GetReportHeader()->m_rcHeader.left - pPrev->GetRect().left) - nFreezOffset;
  733. nScrollPos = max(nScrollPos - 1, 0);
  734. }
  735. break;
  737. case SB_LINEDOWN:
  738. nCurPos = min(nCurPos + m_nHScrollStep, GetScrollLimit(SB_HORZ));
  739. if (m_bFullColumnScrolling && pNext)
  740. {
  741. nLeftOffset_new = labs(GetReportHeader()->m_rcHeader.left - pNext->GetRect().left) - nFreezOffset;
  742. nScrollPos = nScrollPos + 1;
  743. }
  744. break;
  746. case SB_PAGEUP:
  747. nCurPos = max(nCurPos - m_rcReportArea.Width(), 0);
  748. if (m_bFullColumnScrolling && pPrev)
  749. {
  750. nLeftOffset_new = labs(GetReportHeader()->m_rcHeader.left - pPrev->GetRect().left) - nFreezOffset;
  751. nScrollPos = max(nScrollPos - 1, 0);
  752. }
  753. break;
  755. case SB_PAGEDOWN:
  756. nCurPos = min(nCurPos + m_rcReportArea.Width(), GetScrollLimit(SB_HORZ));
  757. if (m_bFullColumnScrolling && pNext)
  758. {
  759. nLeftOffset_new = labs(GetReportHeader()->m_rcHeader.left - pNext->GetRect().left) - nFreezOffset;
  760. nScrollPos = nScrollPos + 1;
  761. }
  762. break;
  764. case SB_THUMBTRACK:
  765. case SB_THUMBPOSITION:
  766. nCurPos = nPos;
  767. if (m_bFullColumnScrolling)
  768. {
  769. int nVisColCount = GetColumns()->GetVisibleColumnsCount();
  771. int nCurrCol = nVisColCount - nScrollMax + nPos;
  772. CXTPReportColumn *pCurrScroll = GetColumns()->GetVisibleAt(nCurrCol);
  774. ASSERT(pCurrScroll);
  775. if (!pCurrScroll)
  776. return;
  778. nLeftOffset_new = labs(GetReportHeader()->m_rcHeader.left - pCurrScroll->GetRect().left) - nFreezOffset;
  779. nScrollPos = nPos;
  780. }
  781. break;
  782. }
  784. if (m_bFullColumnScrolling)
  785. {
  786. SetLeftOffset(nLeftOffset_new);
  787. SetScrollPos(SB_HORZ, nScrollPos);
  788. }
  789. else
  790. {
  791. SetLeftOffset(nCurPos);
  792. }
  793. }
  795. UINT CXTPReportControl::GetMouseScrollLines()
  796. {
  797. int nScrollLines = 3; // default value
  799. if (XTPSystemVersion()->IsWin95())
  800. {
  802. HKEY hKey;
  803. if (ERROR_SUCCESS == RegOpenKeyEx(
  804. HKEY_CURRENT_USER, _T("Control Panel\Desktop"), 0, KEY_QUERY_VALUE, &hKey))
  805. {
  806. TCHAR szData[128];
  807. DWORD dwKeyDataType;
  808. DWORD dwDataBufSize = sizeof(szData);
  810. if (ERROR_SUCCESS == RegQueryValueEx(
  811. hKey, _T("WheelScrollLines"), NULL, &dwKeyDataType, (LPBYTE) &szData, &dwDataBufSize))
  812. {
  813. nScrollLines = _tcstoul(szData, NULL, 10);
  814. }
  815. RegCloseKey(hKey);
  816. }
  817. }
  818. // win98 or greater
  819. else
  820. SystemParametersInfo (SPI_GETWHEELSCROLLLINES, 0, &nScrollLines, 0);
  822. return nScrollLines;
  823. }
  825. BOOL CXTPReportControl::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
  826. {
  827. if (!m_bVScrollBarVisible)
  828. return CWnd::OnMouseWheel(nFlags, zDelta, pt);
  830. UINT uiMsg;
  831. int nScrollsCount = 0;
  832. // calculate what should be sent
  833. if (m_nRowsPerWheel == -1)
  834. {
  835. // A m_nRowsPerWheel value less than 0 indicates that the mouse wheel scrolls whole pages, not just lines.
  836. int nPagesScrolled = zDelta / 120;
  837. uiMsg = nPagesScrolled > 0 ? SB_PAGEUP : SB_PAGEDOWN;
  838. nScrollsCount = nPagesScrolled > 0 ? nPagesScrolled : -nPagesScrolled;
  839. }
  840. else
  841. {
  842. int nRowsScrolled = m_nRowsPerWheel * zDelta / 120;
  843. uiMsg = nRowsScrolled > 0 ? SB_LINEUP : SB_LINEDOWN;
  844. nScrollsCount = nRowsScrolled > 0 ? nRowsScrolled : -nRowsScrolled;
  845. }
  847. BeginUpdate();
  849. // send scroll messages
  850. for (int i = 0; i < nScrollsCount; i++)
  851. {
  852. OnVScroll(uiMsg, 0, NULL);
  853. }
  855. EndUpdate();
  856. UpdateWindow();
  858. return CWnd::OnMouseWheel(nFlags, zDelta, pt);
  859. }
  861. void CXTPReportControl::OnMouseLeave()
  862. {
  863. OnMouseMove(0, CPoint(-1, -1));
  864. }
  866. void CXTPReportControl::OnMouseMove(UINT nFlags, CPoint point)
  867. {
  868. CWnd::OnMouseMove(nFlags, point);
  870. CXTPReportHeader* pHeader = GetReportHeader();
  871. if (pHeader)
  872. {
  873. pHeader->OnMouseMove(nFlags, point);
  874. }
  876. if (GetMouseMode() == xtpReportMouseNothing)
  877. {
  878. CXTPReportRow* pRow = HitTest(point);
  879. if (pRow)
  880. {
  881. pRow->OnMouseMove(nFlags, point);
  883. if (m_bShowTooltips && nFlags == 0)
  884. {
  885. pRow->ShowToolTip(point, &m_wndTip);
  886. }
  887. }
  889. if (m_pHotRow != pRow)
  890. {
  891. TRACKMOUSEEVENT tme =
  892. {
  893. sizeof(TRACKMOUSEEVENT), TME_LEAVE, GetSafeHwnd(), 0
  894. };
  895. _TrackMouseEvent (&tme);
  897. m_pHotRow = pRow;
  898. }
  900. // If mouse moved some since down...
  901. if (m_bPrepareDrag && (labs (point.x - m_pointDrag.x) > 3 ||
  902. labs (point.y - m_pointDrag.y) > 3))
  903. {
  904. // Prevent duplicate
  905. m_bPrepareDrag = FALSE;
  907. m_pSelectOnUpRow = NULL;
  909. // Begin a drag operation
  910. OnBeginDrag(m_pointDrag);
  911. }
  912. }
  916. }
  918. void CXTPReportControl::OnBeginDrag(CPoint point)
  919. {
  920. if (SendMessageToParent(NULL, NULL, NULL, LVN_BEGINDRAG, &point))
  921. return;
  923. if (m_cfReport ==  NULL)
  924. return;
  926. CXTPReportSelectedRows* pSelectedRows = GetSelectedRows();
  927. if (!pSelectedRows)
  928. return;
  930. if ((m_dwDragDropFlags & xtpReportAllowDrag) == 0)
  931. return;
  933. int nCount = pSelectedRows->GetCount();
  934. for (int i = nCount - 1; i >= 0; i--)
  935. {
  936. CXTPReportRow* pRow = pSelectedRows->GetAt(i);
  937. if (pRow->IsGroupRow())
  938. {
  939. pRow->SetExpanded(TRUE);
  940. pRow->SelectChilds();
  941. }
  942. }
  944. COleDataSource ds;
  946. int nRowsCount = pSelectedRows->GetCount();
  947. if (nRowsCount < 1)
  948. return;
  950. // minimize memory reallocs to improve performance
  951. UINT nAveRecordsSize = 1500; // bytes
  952. UINT nGrowBytes = ((nRowsCount * nAveRecordsSize) / 4096 + 1) * 4096;
  954. UINT nAllocFlags = GMEM_MOVEABLE | GMEM_DDESHARE | GMEM_ZEROINIT;
  956. CSharedFile fileRecords(nAllocFlags, nGrowBytes);
  958. BOOL bSucceed = FALSE;
  960. //------------------------------------------------------------------------
  961. const int cErrTextSize = 1024;
  962. TCHAR szErrText[cErrTextSize + 1];
  964. CXTPReportRecords* pDragRecords = new CXTPReportRecords(TRUE);
  966. if (!_GetSelectedRows(pDragRecords))
  967. {
  968. CMDTARGET_RELEASE(pDragRecords);
  969. return;
  970. }
  972. try
  973. {
  974. CArchive ar(&fileRecords, CArchive::store);
  975. CXTPPropExchangeArchive px(ar);
  977. bSucceed = _WriteRecordsData(&px, pDragRecords);
  979. ar.Close(); // perform Flush() and detach from file
  980. }
  981. catch(CArchiveException* pE)
  982. {
  983. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  984. {
  985. TRACE(_T("EXCEPTION: CXTPReportControl::Copy() - %sn"), szErrText);
  986. }
  987. pE->Delete();
  988. }
  989. catch(CFileException* pE)
  990. {
  991. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  992. {
  993. TRACE(_T("EXCEPTION: CXTPReportControl::Copy() - %sn"), szErrText);
  994. }
  995. pE->Delete();
  996. }
  997. catch(...)
  998. {
  999. TRACE(_T("EXCEPTION: CXTPReportControl::Copy() - Unhandled Exception!n"));
  1000. }
  1002. if (!bSucceed)
  1003. {
  1004. CMDTARGET_RELEASE(pDragRecords);
  1005. return;
  1006. }
  1008. HGLOBAL hGlobal = fileRecords.Detach();
  1010. m_bDragMode = TRUE;
  1012. DROPEFFECT dropEffectMask =
  1013. ((m_dwDragDropFlags & xtpReportAllowDragCopy) ? DROPEFFECT_COPY : 0) +
  1014. ((m_dwDragDropFlags & xtpReportAllowDragMove) ? DROPEFFECT_MOVE : 0);
  1016. XTP_NM_REPORTDRAGDROP nmData;
  1017. ZeroMemory(&nmData, sizeof(nmData));
  1018. nmData.pRecords = pDragRecords;
  1020. if (SendNotifyMessage(XTP_NM_REPORT_BEGINDRAG, (NMHDR*)&nmData) == -1)
  1021. return;
  1023. ds.CacheGlobalData (m_cfReport, hGlobal);
  1024. DROPEFFECT dropEffect = ds.DoDragDrop(dropEffectMask);
  1026. m_bDragMode = FALSE;
  1028. nmData.dropEffect = dropEffect;
  1029. SendNotifyMessage(XTP_NM_REPORT_DRAGDROP_COMPLETED, (NMHDR*)&nmData);
  1031. if ((dropEffect == DROPEFFECT_MOVE) && (dropEffectMask & DROPEFFECT_MOVE))
  1032. {
  1033. Cut();
  1034. }
  1036. CMDTARGET_RELEASE(pDragRecords);
  1038. EnsureStopAutoVertScroll();
  1039. }
  1041. DROPEFFECT CXTPReportControl::OnDragOver(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point, int nState)
  1042. {
  1043. DROPEFFECT dropEffect = DROPEFFECT_MOVE;
  1044. BOOL bAbove = TRUE;
  1045. CXTPReportRecord* pTargetRecord = NULL;
  1047. if ((dwKeyState & MK_CONTROL) == MK_CONTROL)
  1048. dropEffect = DROPEFFECT_COPY;
  1050. if (!m_nOLEDropMode)
  1051. {
  1052. if (m_cfReport == NULL)
  1053. dropEffect = DROPEFFECT_NONE;
  1055. if ((m_dwDragDropFlags & xtpReportAllowDrop) == 0)
  1056. dropEffect = DROPEFFECT_NONE;
  1058. if ((dropEffect != DROPEFFECT_NONE) && (!pDataObject || !pDataObject->IsDataAvailable(m_cfReport)))
  1059. dropEffect = DROPEFFECT_NONE;
  1060. }
  1062. int nDropPos = m_nDropPos;
  1063. m_nDropPos = -1;
  1065. if (dropEffect != DROPEFFECT_NONE)
  1066. {
  1067. DoAutoVertScrollIfNeed(m_pointDrag, point);
  1069. if (GetColumns()->GetSortOrder()->GetCount() == 0 && GetColumns()->GetGroupsOrder()->GetCount() == 0)
  1070. {
  1071. CXTPReportRow* pRow = HitTest(point);
  1072. if (pRow && pRow->GetRecord())
  1073. {
  1074. bAbove = pRow->GetRect().CenterPoint().y < point.y ? FALSE : TRUE;
  1075. pTargetRecord = pRow->GetRecord();
  1076. m_nDropPos = (pRow->GetRect().CenterPoint().y < point.y ? pRow->GetRect().bottom - 1: pRow->GetRect().top - 1);
  1077. }
  1078. }
  1079. }
  1082. if(nState == 0)
  1083. {
  1084. // entering, get report records
  1086. CMDTARGET_RELEASE(m_pDropRecords);
  1088. CFile* pFile = m_cfReport ? pDataObject->GetFileData(m_cfReport) : NULL;
  1089. if (pFile)
  1090. {
  1091. m_pDropRecords = new CXTPReportRecords();
  1093. const int cErrTextSize = 1024;
  1094. TCHAR szErrText[cErrTextSize + 1];
  1096. try
  1097. {
  1098. CArchive ar(pFile, CArchive::load);
  1099. CXTPPropExchangeArchive px(ar);
  1101. if (!_ReadRecodsFromData(&px, *m_pDropRecords))
  1102. {
  1103. m_pDropRecords->RemoveAll();
  1104. }
  1105. ar.Close(); // detach from file
  1106. }
  1107. catch(CArchiveException* pE)
  1108. {
  1109. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  1110. {
  1111. TRACE(_T("EXCEPTION: CXTPReportControl::Paste() - %sn"), szErrText);
  1112. }
  1113. pE->Delete();
  1114. }
  1115. catch(CFileException* pE)
  1116. {
  1117. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  1118. {
  1119. TRACE(_T("EXCEPTION: CXTPReportControl::Paste() - %sn"), szErrText);
  1120. }
  1121. pE->Delete();
  1122. }
  1123. catch(...)
  1124. {
  1125. TRACE(_T("EXCEPTION: CXTPReportControl::Paste() - Unhandled Exception!n"));
  1126. }
  1128. delete pFile;
  1129. }
  1130. }
  1131. else if(nState == 1)
  1132. {
  1133. // leaving, release drop records
  1134. CMDTARGET_RELEASE(m_pDropRecords);
  1135. }
  1137. XTP_NM_REPORTDRAGDROP nmData;
  1138. nmData.pRecords = m_pDropRecords;
  1139. nmData.pTargetRecord = pTargetRecord;
  1140. nmData.bAbove = bAbove;
  1141. nmData.dropEffect = dropEffect;
  1142. nmData.pt = point;
  1143. nmData.nState = nState;
  1144. SendNotifyMessage(XTP_NM_REPORT_DRAGOVER, (NMHDR*)&nmData);
  1146. if (m_nDropPos != nDropPos)
  1147. {
  1148. RedrawControl();
  1149. }
  1151. return dropEffect;
  1152. }
  1154. void CXTPReportControl::OnTimer(UINT_PTR uTimerID)
  1155. {
  1156. if (m_uAutoScrollTimerID == uTimerID)
  1157. {
  1158. CPoint ptMouse;
  1159. if (::GetCursorPos(&ptMouse))
  1160. {
  1161. ScreenToClient(&ptMouse);
  1162. DoAutoVertScrollIfNeed(m_pointDrag, ptMouse);
  1163. }
  1164. //TRACE(_T("AutoScrollTimer n"));
  1165. }
  1167. CWnd::OnTimer(uTimerID);
  1168. }
  1170. void CXTPReportControl::EnsureStopAutoVertScroll()
  1171. {
  1172. if (m_uAutoScrollTimerID)
  1173. {
  1174. KillTimer(m_uAutoScrollTimerID);
  1175. m_uAutoScrollTimerID = 0;
  1177. //TRACE(_T("AutoScroll STOP n"));
  1178. }
  1179. }
  1181. void CXTPReportControl::EnsureStartAutoVertScroll()
  1182. {
  1183. if (!m_uAutoScrollTimerID)
  1184. {
  1185. m_uAutoScrollTimerID = SetTimer(XTP_REPORT_AUTO_SCROLL_TIMER_ID, XTP_REPORT_AUTO_SCROLL_TIMER_RESOLUTION_MS, NULL);
  1186. }
  1187. }
  1189. void CXTPReportControl::DoAutoVertScrollIfNeed(CPoint ptClick, CPoint pt)
  1190. {
  1191. if (!m_arrScreenRows.GetCount())
  1192. {
  1193. EnsureStopAutoVertScroll();
  1194. return;
  1195. }
  1197. CXTPReportRow* pRow0 = m_arrScreenRows.GetAt(0);
  1198. CXTPReportRow* pRow1 = m_arrScreenRows.GetAt(m_arrScreenRows.GetCount() - 1);
  1200. if (!pRow0 || !pRow1)
  1201. {
  1202. EnsureStopAutoVertScroll();
  1203. return;
  1204. }
  1206. int nDirection = 0;
  1208. CRect rc0 = m_rcReportArea;   //pRow0->GetRect();
  1209. CRect rc1 = m_rcReportArea;   //pRow1->GetRect();
  1210. rc0.bottom = m_rcReportArea.top + 20;
  1211. rc1.top = m_rcReportArea.bottom - 20;
  1213. if (rc0.PtInRect(pt))
  1214. nDirection = -1;
  1215. else if (rc1.PtInRect(pt))
  1216. nDirection = 1;
  1218. if (!nDirection ||
  1219. m_bDragMode &&
  1220. (nDirection == 1 && pt.y - ptClick.y < 3 ||
  1221.  nDirection == -1 && ptClick.y - pt.y < 3)
  1222.    )
  1223. {
  1224. EnsureStopAutoVertScroll();
  1225. return;
  1226. }
  1228. //-----------------------------------------------------
  1229. int nTopRow = GetTopRowIndex();
  1230. int nRowsCount = m_pRows->GetCount();
  1232. if (nDirection == -1 && nTopRow > 0 ||
  1233. nDirection == 1 &&
  1234. (pRow1->GetIndex() < nRowsCount ||
  1235.  pRow1->GetRect().bottom > m_rcReportArea.bottom)
  1236. )
  1237. {
  1238. //TRACE(_T("AutoScroll direction=%d, nextRow=%dn"), nDirection, nTopRow+nDirection);
  1239. SetTopRow(nTopRow + nDirection);
  1241. EnsureStartAutoVertScroll();
  1242. return;
  1243. }
  1245. EnsureStopAutoVertScroll();
  1246. }
  1248. BOOL CXTPReportControl::OnDrop(COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point)
  1249. {
  1250. CMDTARGET_RELEASE(m_pDropRecords);
  1252. EnsureStopAutoVertScroll();
  1254. CUpdateContext updateContext(this);
  1255. int nDropPos = m_nDropPos;
  1256. m_nDropPos = -1;
  1258. if (dropEffect != DROPEFFECT_COPY && dropEffect != DROPEFFECT_MOVE)
  1259. return FALSE;
  1262. if (IsVirtualMode())
  1263. return FALSE;
  1265. if (!pDataObject || !pDataObject->IsDataAvailable(m_cfReport))
  1266. return FALSE;
  1268. if ((m_dwDragDropFlags & xtpReportAllowDrop) == 0)
  1269. return FALSE;
  1273. int nInsert = GetRecords()->GetCount();
  1275. BOOL bAbove = TRUE;
  1276. CXTPReportRecord* pTargetRecord = NULL;
  1278. CXTPReportRow* pRow = HitTest(point);
  1279. if (pRow)
  1280. {
  1281. bAbove = pRow->GetRect().CenterPoint().y < point.y ? FALSE : TRUE;
  1283. pTargetRecord = pRow->GetRecord();
  1284. if(pTargetRecord)
  1285. nInsert = pTargetRecord->GetIndex() + (bAbove ? 0 : 1);
  1286. }
  1288. if (m_bDragMode && dropEffect == DROPEFFECT_MOVE)
  1289. {
  1290. if (nDropPos == -1)
  1291. return FALSE;
  1293. CXTPReportRecords* pDropRecords = new CXTPReportRecords(TRUE);
  1295. if (!_GetSelectedRows(pDropRecords))
  1296. {
  1297. CMDTARGET_RELEASE(pDropRecords);
  1298. return FALSE;
  1299. }
  1301. XTP_NM_REPORTDRAGDROP nmData;
  1302. nmData.pRecords = pDropRecords;
  1303. nmData.pTargetRecord = pTargetRecord;
  1304. nmData.bAbove = bAbove;
  1305. nmData.dropEffect = dropEffect;
  1307. CMDTARGET_ADDREF(pTargetRecord);
  1309. if (SendNotifyMessage(XTP_NM_REPORT_DROP, (NMHDR*)&nmData) == -1)
  1310. {
  1311. CMDTARGET_RELEASE(pDropRecords);
  1312. return FALSE;
  1313. }
  1315. GetRecords()->Move(nInsert, pDropRecords);
  1317. Populate();
  1319. _SelectRows(pDropRecords);
  1321. RedrawControl();
  1323. SendNotifyMessage(XTP_NM_REPORT_RECORDS_DROPPED, (NMHDR*)&nmData);
  1326. CMDTARGET_RELEASE(pDropRecords);
  1327. CMDTARGET_RELEASE(pTargetRecord);
  1329. return FALSE;
  1330. }
  1332. CFile* pFile = pDataObject->GetFileData(m_cfReport);
  1333. if (!pFile)
  1334. return FALSE;
  1336. CXTPReportRecords* pDropRecords = new CXTPReportRecords();
  1338. const int cErrTextSize = 1024;
  1339. TCHAR szErrText[cErrTextSize + 1];
  1341. try
  1342. {
  1343. CArchive ar(pFile, CArchive::load);
  1344. CXTPPropExchangeArchive px(ar);
  1346. if (!_ReadRecodsFromData(&px, *pDropRecords))
  1347. {
  1348. pDropRecords->RemoveAll();
  1349. }
  1350. ar.Close(); // detach from file
  1351. }
  1352. catch(CArchiveException* pE)
  1353. {
  1354. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  1355. {
  1356. TRACE(_T("EXCEPTION: CXTPReportControl::Paste() - %sn"), szErrText);
  1357. }
  1358. pE->Delete();
  1359. }
  1360. catch(CFileException* pE)
  1361. {
  1362. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  1363. {
  1364. TRACE(_T("EXCEPTION: CXTPReportControl::Paste() - %sn"), szErrText);
  1365. }
  1366. pE->Delete();
  1367. }
  1368. catch(...)
  1369. {
  1370. TRACE(_T("EXCEPTION: CXTPReportControl::Paste() - Unhandled Exception!n"));
  1371. }
  1373. delete pFile;
  1375. XTP_NM_REPORTDRAGDROP nmData;
  1376. nmData.pRecords = pDropRecords;
  1377. nmData.pTargetRecord = pTargetRecord;
  1378. nmData.bAbove = bAbove;
  1379. nmData.dropEffect = dropEffect;
  1381. if (SendNotifyMessage(XTP_NM_REPORT_DROP, (NMHDR*)&nmData) == -1)
  1382. {
  1383. CMDTARGET_RELEASE(pDropRecords);
  1384. return FALSE;
  1385. }
  1387. // Add and Populate records
  1388. int nRecordsCount = pDropRecords->GetCount();
  1389. if (nRecordsCount > 0)
  1390. {
  1391. // Add
  1392. for (int i = 0; i < nRecordsCount; i++)
  1393. {
  1394. CXTPReportRecord* pRecord = pDropRecords->GetAt(i);
  1395. if (pRecord)
  1396. {
  1397. CMDTARGET_ADDREF(pRecord);
  1399. m_pRecords->InsertAt(nInsert, pRecord);
  1400. nInsert++;
  1401. }
  1402. }
  1404. Populate();
  1406. _SelectRows(pDropRecords);
  1408. RedrawControl();
  1410. SendNotifyMessage(XTP_NM_REPORT_RECORDS_DROPPED, (NMHDR*)&nmData);
  1411. }
  1413. CMDTARGET_RELEASE(pDropRecords);
  1415. return TRUE;
  1417. }
  1420. BOOL CXTPReportControl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  1421. {
  1422. if (nHitTest == HTCLIENT)
  1423. {
  1424. switch (m_mouseMode)
  1425. {
  1426. case xtpReportMouseOverColumnDivide:
  1427. SetCursor(GetReportHeader()->m_hResizeCursor);
  1428. return TRUE;
  1429. }
  1431. }
  1433. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  1434. }
  1437. LRESULT CXTPReportControl::SendNotifyMessage(UINT nMessage, NMHDR* pNMHDR) const
  1438. {
  1439. if (!IsWindow(m_hWnd))
  1440. return 0;
  1442. NMHDR nmhdr;
  1443. if (pNMHDR == NULL)
  1444. pNMHDR = &nmhdr;
  1446. pNMHDR->hwndFrom = GetSafeHwnd();
  1447. pNMHDR->idFrom = GetDlgCtrlID();
  1448. pNMHDR->code = nMessage;
  1450. CWnd *pOwner = GetOwner();
  1451. if (pOwner && IsWindow(pOwner->m_hWnd))
  1452. return pOwner->SendMessage(WM_NOTIFY, pNMHDR->idFrom, (LPARAM)pNMHDR);
  1453. else
  1454. return 0;
  1455. }
  1458. LRESULT CXTPReportControl::SendMessageToParent(CXTPReportRow* pRow, CXTPReportRecordItem* pItem, CXTPReportColumn* pColumn, UINT nMessage, CPoint* pPoint, int nHyperlink) const
  1459. {
  1460. if (!IsWindow(m_hWnd))
  1461. return 0;
  1463. XTP_NM_REPORTRECORDITEM nmgv;
  1464. nmgv.pItem = pItem;
  1465. nmgv.pColumn = pColumn;
  1466. nmgv.pRow = pRow;
  1467. nmgv.nHyperlink = nHyperlink;
  1468. nmgv.pt.x = 0;
  1469. nmgv.pt.y = 0;
  1470. if (pPoint)
  1471. {
  1472. nmgv.pt = *pPoint;
  1473. }
  1475. return SendNotifyMessage(nMessage, (NMHDR*)&nmgv);
  1476. }
  1478. void CXTPReportControl::DoPropExchange(CXTPPropExchange* pPX)
  1479. {
  1480. TRY
  1481. {
  1482. pPX->ExchangeSchemaSafe();
  1484. CXTPPropExchangeSection secColumns(pPX->GetSection(_T("Columns")));
  1485. m_pColumns->DoPropExchange(&secColumns);
  1487. PX_Bool(pPX, _T("ShowGroupBox"), m_bGroupByEnabled, FALSE);
  1488. PX_Int(pPX, _T("FreezeColumnsCount"), m_nFreezeColumnsCount, 0);
  1490. if (pPX->GetSchema() >= _XTP_SCHEMA_110)
  1491. {
  1492. PX_Bool(pPX, _T("FullColumnScrolling"), m_bFullColumnScrolling, FALSE);
  1493. PX_Int(pPX, _T("HScrollStep"), m_nHScrollStep, XTP_REPORT_HSCROLL_STEP);
  1494. }
  1496. CXTPPropExchangeSection secHeader(pPX->GetSection(_T("Header")));
  1497. GetReportHeader()->DoPropExchange(&secHeader);
  1499. if (pPX->IsLoading())
  1500. {
  1501. GetReportHeader()->OnColumnsChanged();
  1502. Populate();
  1503. }
  1504. }
  1505. CATCH(CArchiveException, e)
  1506. {
  1507. }
  1508. END_CATCH
  1509. }
  1511. void CXTPReportControl::SerializeState(CArchive& ar)
  1512. {
  1513. CXTPPropExchangeArchive px(ar);
  1514. DoPropExchange(&px);
  1515. }
  1517. void CXTPReportControl::CollapseAll()
  1518. {
  1519. BeginUpdate();
  1520. for (int i = m_pRows->GetCount() - 1; i >= 0; i--)
  1521. m_pRows->GetAt(i)->SetExpanded(FALSE);
  1523. EndUpdate();
  1524. EnsureVisible(GetFocusedRow());
  1525. }
  1527. void CXTPReportControl::ExpandAll()
  1528. {
  1529. BeginUpdate();
  1530. for (int i = m_pRows->GetCount() - 1; i >= 0; i--)
  1531. m_pRows->GetAt(i)->SetExpanded(TRUE);
  1533. EndUpdate();
  1534. EnsureVisible(GetFocusedRow());
  1535. }
  1537. void CXTPReportControl::SetMouseMode(XTPReportMouseMode nMode)
  1538. {
  1539. XTP_TRACE(_T("SetMouseMode: Switching from %d to %dn"), m_mouseMode, nMode);
  1540. m_mouseMode = nMode;
  1541. }
  1543. void CXTPReportControl::RelayToolTipEvent(UINT message)
  1544. {
  1545. if (m_wndTip.GetSafeHwnd() && m_wndTip.IsWindowVisible())
  1546. {
  1547. CPoint pt;
  1548. GetCursorPos(&pt);
  1550. if (!m_wndTip.GetHoverRect().PtInRect(pt))
  1551. {
  1552. m_wndTip.SetTooltipText(NULL);
  1553. m_wndTip.Activate(FALSE, FALSE);
  1554. }
  1556. switch (message)
  1557. {
  1558. case WM_MOUSEWHEEL:
  1559. case WM_KEYDOWN:
  1560. case WM_SYSKEYDOWN:
  1561. case WM_LBUTTONDOWN:
  1562. case WM_RBUTTONDOWN:
  1563. case WM_MBUTTONDOWN:
  1564. case WM_LBUTTONUP:
  1565. case WM_RBUTTONUP:
  1566. case WM_MBUTTONUP:
  1567. case WM_MOUSELEAVE:
  1568. m_wndTip.Activate(FALSE, FALSE);
  1569. }
  1570. }
  1572. }
  1574. BOOL CXTPReportControl::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  1575. {
  1576. static BOOL bRelay = FALSE;
  1577. if (m_wndTip.GetSafeHwnd() && m_wndTip.IsWindowVisible() && !bRelay)
  1578. {
  1579. bRelay = TRUE;
  1580. RelayToolTipEvent(message);
  1581. bRelay = FALSE;
  1582. }
  1584. if (m_pToolTipContext && m_bShowTooltips)
  1585. {
  1586. m_pToolTipContext->FilterToolTipMessage(this, message, wParam, lParam);
  1587. }
  1589. return CWnd::OnWndMsg(message, wParam, lParam, pResult);
  1590. }
  1592. void CXTPReportControl::OnSysColorChange()
  1593. {
  1594. CWnd::OnSysColorChange();
  1595. m_pPaintManager->RefreshMetrics();
  1597. RedrawControl();
  1598. }
  1600. UINT CXTPReportControl::OnGetDlgCode()
  1601. {
  1602. return (m_bFocusSubItems ? DLGC_WANTTAB :0) | DLGC_WANTARROWS | DLGC_WANTCHARS;
  1603. }
  1605. void CXTPReportControl::OnSetFocus(CWnd* pOldWnd)
  1606. {
  1607. CWnd::OnSetFocus(pOldWnd);
  1608. RedrawControl();
  1610. }
  1612. void CXTPReportControl::OnKillFocus (CWnd* pNewWnd)
  1613. {
  1614. CWnd::OnKillFocus(pNewWnd);
  1616. EnsureStopAutoVertScroll();
  1617. RedrawControl();
  1619. }
  1621. int CXTPReportControl::GetHeaderIndent() const
  1622. {
  1623. return GetIndent(GetReportHeader()->m_nIndentLevel);
  1624. }
  1626. CXTPReportRow* CXTPReportControl::CreateRow()
  1627. {
  1628. return new CXTPReportRow_Batch();
  1629. }
  1631. CXTPReportGroupRow* CXTPReportControl::CreateGroupRow()
  1632. {
  1633. return new CXTPReportGroupRow_Batch();
  1635. }
  1637. CXTPReportRow* CXTPReportControl::CreateHeaderFooterRow()
  1638. {
  1639. return new CXTPHeapObjectT<CXTPReportRow, CXTPReportAllocatorDefault>;
  1640. }
  1642. void CXTPReportControl::EditItem(XTP_REPORTRECORDITEM_ARGS* pItemArgs)
  1643. {
  1644. CXTPReportRecordItem* pItem = pItemArgs ? pItemArgs->pItem : NULL;
  1646. if (m_pActiveItem != NULL)
  1647. {
  1648. m_pActiveItem->OnCancelEdit(this, TRUE);
  1649. m_pActiveItem = NULL;
  1651. if (!m_bFocusSubItems)
  1652. {
  1653. SetFocusedColumn(NULL);
  1654. }
  1655. }
  1656. CMDTARGET_RELEASE(m_ptrVirtualEditingRow);
  1658. if (pItem && pItemArgs && pItemArgs->pRow)
  1659. {
  1660. if (!HasFocus())
  1661. SetFocus();
  1663. if (!IsVirtualMode())
  1664. {
  1665. AdjustScrollBars();
  1666. RedrawControl();
  1667. UpdateWindow();
  1668. }
  1670. if (IsVirtualMode())
  1671. {
  1672. int nRowIndex = pItemArgs->pRow->GetIndex();
  1674. EnsureVisible(pItemArgs->pRow);
  1676. RedrawControl();
  1677. UpdateWindow();
  1678. pItemArgs->pRow = NULL; // RedrawControl delete and re-create new screen rows
  1680. BOOL bMapped = FALSE;
  1681. int nScrCount = m_arrScreenRows.GetCount();
  1682. for (int i = 0; i < nScrCount; i++)
  1683. {
  1684. CXTPReportRow* pRow = m_arrScreenRows.GetAt(i);
  1685. if (pRow->GetIndex() == nRowIndex)
  1686. {
  1687. pItemArgs->pRow = pRow;
  1688. bMapped = TRUE;
  1690. ASSERT(m_ptrVirtualEditingRow == NULL);
  1692. m_ptrVirtualEditingRow = pRow;
  1693. CMDTARGET_ADDREF(m_ptrVirtualEditingRow);
  1694. break;
  1695. }
  1696. }
  1697. ASSERT(bMapped);
  1698. if (!bMapped)
  1699. return;
  1700. }
  1701. else if (GetFocusedRow() != pItemArgs->pRow)
  1702. {
  1703. SetFocusedRow(pItemArgs->pRow);
  1704. UpdateWindow();
  1705. }
  1707. pItemArgs->rcItem = pItemArgs->pRow->GetItemRect(pItem);
  1709. if(SetFocusedColumn(pItemArgs->pColumn))
  1710. {
  1711. m_pActiveItem = pItem;
  1712. pItem->OnBeginEdit(pItemArgs);
  1713. }
  1714. }
  1716. RedrawControl();
  1717. }
  1719. BOOL CXTPReportControl::HasFocus() const
  1720. {
  1721. const CWnd* pFocusWnd = GetFocus();
  1722. if (!pFocusWnd)
  1723. return FALSE;
  1725. return (pFocusWnd->GetSafeHwnd() == m_hWnd) || (pFocusWnd->GetParent()->GetSafeHwnd() == m_hWnd) || (pFocusWnd->GetOwner()->GetSafeHwnd() == m_hWnd);
  1726. }
  1729. void CXTPReportControl::ReleaseItem(int nIndex)
  1730. {
  1731. int i;
  1733. for (i = 0; i < m_pRecords->GetCount(); i++)
  1734. {
  1735. CXTPReportRecord* pRecord = m_pRecords->GetAt(i);
  1737. pRecord->m_arrItems[nIndex]->InternalRelease();
  1738. pRecord->m_arrItems.RemoveAt(nIndex);
  1739. }
  1741. CXTPReportColumns* pColumns = GetColumns();
  1743. CXTPReportColumn* pColumnToRemove = NULL;
  1745. int nColumnsCount = pColumns->GetCount();
  1746. for (i = 0; i < nColumnsCount; i++)
  1747. {
  1748. CXTPReportColumn* pColumn = pColumns->GetAt(i);
  1750. if (pColumn->m_nItemIndex > nIndex)
  1751. {
  1752. pColumn->m_nItemIndex--;
  1753. }
  1754. else if (pColumn->m_nItemIndex == nIndex)
  1755. {
  1756. pColumnToRemove = pColumn;
  1757. }
  1758. }
  1760. if (pColumnToRemove)
  1761. pColumns->Remove(pColumnToRemove);
  1762. }
  1764. void CXTPReportControl::SetVirtualMode(CXTPReportRecord* pVirtualRecord, int nCount)
  1765. {
  1766. if (m_pRecords)
  1767. m_pRecords->SetVirtualMode(pVirtualRecord, nCount);
  1768. }
  1770. BOOL CXTPReportControl::IsVirtualMode() const
  1771. {
  1772. return m_pRecords ? m_pRecords->IsVirtualMode() : FALSE;
  1773. }
  1775. CXTPReportRow* CXTPReportControl::GetFocusedRow() const
  1776. {
  1777. if (m_nFocusedRow != -1)
  1778. return m_pRows ? m_pRows->GetAt(m_nFocusedRow) : NULL;
  1780. if (m_nFocusedHeaderRow != -1)
  1781. return m_pHeaderRows ? m_pHeaderRows->GetAt(m_nFocusedHeaderRow) : NULL;
  1783. if (m_nFocusedFooterRow != -1)
  1784. return m_pFooterRows ? m_pFooterRows->GetAt(m_nFocusedFooterRow) : NULL;
  1786. return NULL;
  1787. }
  1789. void CXTPReportControl::OnStyleChanged(int nStyleType, LPSTYLESTRUCT lpStyleStruct)
  1790. {
  1791. CWnd::OnStyleChanged(nStyleType, lpStyleStruct);
  1793. RedrawControl();
  1794. }
  1796. CXTPToolTipContext* CXTPReportControl::GetToolTipContext() const
  1797. {
  1798. return m_pToolTipContext;
  1799. }
  1801. INT_PTR CXTPReportControl::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  1802. {
  1803. ASSERT_VALID(this);
  1804. ASSERT(::IsWindow(m_hWnd));
  1806. // check child windows first by calling CControlBar
  1807. INT_PTR nHit = CWnd::OnToolHitTest(point, pTI);
  1808. if (nHit != -1)
  1809. return nHit;
  1811. nHit = GetReportHeader()->OnToolHitTest(point, pTI);
  1812. if (nHit != -1)
  1813. return nHit;
  1815. CXTPReportRow* pRow = HitTest(point);
  1816. if (pRow)
  1817. {
  1818. nHit = pRow->OnToolHitTest(point, pTI);
  1819. }
  1821. return nHit;
  1822. }
  1824. void CXTPReportControl::SetLayoutRTL(BOOL bRightToLeft)
  1825. {
  1826. if (!XTPSystemVersion()->IsLayoutRTLSupported())
  1827. return;
  1829. if (!m_hWnd)
  1830. return;
  1832. ModifyStyleEx(bRightToLeft ? 0 : WS_EX_LAYOUTRTL, !bRightToLeft ? 0 : WS_EX_LAYOUTRTL);
  1833. GetImageManager()->DrawReverted(bRightToLeft);
  1835. GetInplaceEdit()->DestroyWindow();
  1837. AdjustLayout();
  1838. }
  1840. BOOL CXTPReportControl::IsLayoutRTL()
  1841. {
  1842. if (!XTPSystemVersion()->IsLayoutRTLSupported())
  1843. return FALSE;
  1845. if (!m_hWnd)
  1846. return FALSE;
  1848. return !!(GetWindowLong(m_hWnd, GWL_EXSTYLE) & WS_EX_LAYOUTRTL);
  1849. }
  1851. //////////////////////////////////////////////////////////////////////////
  1852. // Clipboard operations
  1854. BOOL CXTPReportControl::CanCopy()
  1855. {
  1856. // Check whether are there any selected rows to be copied
  1857. CXTPReportSelectedRows* pSelRows = GetSelectedRows();
  1859. if ((pSelRows != NULL) && (pSelRows->GetCount() > 0))
  1860. {
  1861. return TRUE;
  1862. }
  1863. return FALSE;
  1864. }
  1866. BOOL CXTPReportControl::CanCut()
  1867. {
  1868. if (IsVirtualMode())
  1869. return FALSE;
  1871. return CanCopy();
  1872. }
  1874. BOOL CXTPReportControl::CanPaste()
  1875. {
  1876. if (IsVirtualMode())
  1877. return FALSE;
  1879. CLIPFORMAT uCF_Records = (CLIPFORMAT)::RegisterClipboardFormat(XTPREPORTCTRL_CF_RECORDS);
  1881. BOOL bCan = FALSE;
  1882. COleDataObject odj;
  1883. if (odj.AttachClipboard())
  1884. {
  1885. bCan = odj.IsDataAvailable(CF_TEXT)
  1886. || odj.IsDataAvailable(CF_UNICODETEXT)
  1887. || odj.IsDataAvailable(uCF_Records) ;
  1888. }
  1889. return bCan;
  1890. }
  1892. void CXTPReportControl::Cut()
  1893. {
  1894. CWaitCursor _WC;
  1896. // Copy selected data into the clipboard
  1897. Copy();
  1899. if (IsVirtualMode())
  1900. return;
  1902. // Delete selected rows
  1903. CXTPInternalCollectionT<CXTPReportRow> arSelectedRows;
  1904. _GetSelectedRows(NULL, &arSelectedRows);
  1905. int nSelRowsCount = (int)arSelectedRows.GetSize();
  1906. int nFirstSelRow = INT_MAX;
  1907. for (int i = nSelRowsCount - 1; i >= 0 ; i--)
  1908. {
  1909. CXTPReportRow* pRow = arSelectedRows.GetAt(i, FALSE);
  1910. if (pRow)
  1911. {
  1912. nFirstSelRow = min(nFirstSelRow, pRow->GetIndex());
  1913. VERIFY(RemoveRowEx(pRow, FALSE));
  1914. }
  1916. arSelectedRows.RemoveAt(i);
  1917. }
  1919. if (GetSelectedRows())
  1920. {
  1921. GetSelectedRows()->Clear();
  1923. if (nFirstSelRow != INT_MAX)
  1924. {
  1925. m_nFocusedRow = min(nFirstSelRow, GetRows()->GetCount() - 1);
  1927. if (GetFocusedRow())
  1928. {
  1929. SetFocusedRow(GetFocusedRow());
  1930. GetSelectedRows()->Add(GetFocusedRow());
  1931. }
  1932. }
  1933. }
  1935. AdjustScrollBars();
  1936. RedrawControl();
  1938. }
  1940. // We support text format with t dividers for record items and
  1941. // rn dividers for records (simple tab-separated text).
  1942. // Such format is also supported by Excel and some other applications.
  1943. void CXTPReportControl::Copy()
  1944. {
  1945. CWaitCursor _WC;
  1947. int nRowsCount = GetSelectedRows() ? GetSelectedRows()->GetCount() : 1;
  1949. // minimize memory reallocs to improve performance
  1950. UINT nAveRecordsSize = 1500; // bytes
  1951. UINT nGrowBytes = ((nRowsCount * nAveRecordsSize) / 4096 + 1) * 4096;
  1953. UINT nAllocFlags = GMEM_MOVEABLE | GMEM_DDESHARE | GMEM_ZEROINIT;
  1955. CSharedFile fileRecords(nAllocFlags, nGrowBytes);
  1957. BOOL bIsRecordsData = FALSE;
  1959. //------------------------------------------------------------------------
  1960. const int cErrTextSize = 1024;
  1961. TCHAR szErrText[cErrTextSize + 1];
  1963. try
  1964. {
  1965. CArchive ar(&fileRecords, CArchive::store);
  1966. CXTPPropExchangeArchive px(ar);
  1968. bIsRecordsData = _WriteSelectedRowsData(&px);
  1970. ar.Close(); // perform Flush() and detach from file
  1971. }
  1972. catch(CArchiveException* pE)
  1973. {
  1974. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  1975. {
  1976. TRACE(_T("EXCEPTION: CXTPReportControl::Copy() - %sn"), szErrText);
  1977. }
  1978. pE->Delete();
  1979. }
  1980. catch(CFileException* pE)
  1981. {
  1982. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  1983. {
  1984. TRACE(_T("EXCEPTION: CXTPReportControl::Copy() - %sn"), szErrText);
  1985. }
  1986. pE->Delete();
  1987. }
  1988. catch(...)
  1989. {
  1990. TRACE(_T("EXCEPTION: CXTPReportControl::Copy() - Unhandled Exception!n"));
  1991. }
  1993. //*****
  1994. CString strClipText = _GetSelectedRowsVisibleColsText();
  1996. CLIPFORMAT uCF_Records = (CLIPFORMAT)::RegisterClipboardFormat(XTPREPORTCTRL_CF_RECORDS);
  1998. // Put prepared text into the clipboard
  1999. if (OpenClipboard())
  2000. {
  2001. ::EmptyClipboard();
  2003. // 1 - Text
  2004. int nLen = (strClipText.GetLength() + 1) * sizeof(TCHAR);
  2005. HGLOBAL hText = ::GlobalAlloc(nAllocFlags, nLen);
  2007. if (hText != NULL)
  2008. {
  2009. LPTSTR lptstrCopy = (TCHAR*)GlobalLock(hText);
  2010. STRCPY_S(lptstrCopy, strClipText.GetLength() + 1, (LPCTSTR)strClipText);
  2011. GlobalUnlock(hText);
  2013. #ifndef _UNICODE
  2014. ::SetClipboardData(CF_TEXT, hText);
  2015. #else
  2016. ::SetClipboardData(CF_UNICODETEXT, hText);
  2017. #endif
  2018. }
  2020. // 2 - Blob data
  2021. if (bIsRecordsData)
  2022. {
  2023. HGLOBAL hData = fileRecords.Detach();
  2024. ::GlobalUnlock(hData); // unlock data
  2025. ::SetClipboardData(uCF_Records, hData);
  2026. }
  2028. //-----------------
  2029. ::CloseClipboard();
  2030. }
  2031. }
  2033. void CXTPReportControl::Paste()
  2034. {
  2035. if (IsVirtualMode())
  2036. return;
  2038. CWaitCursor _WC;
  2040. CLIPFORMAT uCF_Records = (CLIPFORMAT)::RegisterClipboardFormat(XTPREPORTCTRL_CF_RECORDS);
  2042. CXTPReportRecords arRecords;
  2043. BOOL bTryPasteFromText = TRUE;
  2045. // Retrieve text from the clipboard
  2046. if (!OpenClipboard())
  2047. return;
  2049. if (::IsClipboardFormatAvailable(uCF_Records))
  2050. {
  2051. HGLOBAL hPasteData = ::GetClipboardData(uCF_Records);
  2053. if (hPasteData)
  2054. {
  2055. bTryPasteFromText = FALSE;
  2057. const int cErrTextSize = 1024;
  2058. TCHAR szErrText[cErrTextSize + 1];
  2060. CSharedFile fileSahred;
  2061. fileSahred.SetHandle(hPasteData, FALSE);
  2062. CArchive ar(&fileSahred, CArchive::load);
  2064. try
  2065. {
  2066. CXTPPropExchangeArchive px(ar);
  2068. if (!_ReadRecodsFromData(&px, arRecords))
  2069. {
  2070. arRecords.RemoveAll();
  2071. }
  2072. }
  2073. catch(CArchiveException* pE)
  2074. {
  2075. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  2076. {
  2077. TRACE(_T("EXCEPTION: CXTPReportControl::Paste() - %sn"), szErrText);
  2078. }
  2079. pE->Delete();
  2080. }
  2081. catch(CFileException* pE)
  2082. {
  2083. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  2084. {
  2085. TRACE(_T("EXCEPTION: CXTPReportControl::Paste() - %sn"), szErrText);
  2086. }
  2087. pE->Delete();
  2088. }
  2089. catch(...)
  2090. {
  2091. TRACE(_T("EXCEPTION: CXTPReportControl::Paste() - Unhandled Exception!n"));
  2092. }
  2094. //*********
  2095. ar.Close(); // detach from file
  2096. fileSahred.Detach(); //detach from data
  2097. ::GlobalUnlock(hPasteData); // unlock data
  2098. }
  2099. }
  2101. UINT uCF_TText = sizeof(TCHAR) == 2 ? CF_UNICODETEXT : CF_TEXT;
  2103. if (bTryPasteFromText && ::IsClipboardFormatAvailable(uCF_TText))
  2104. {
  2105. // Try to get text data from the clipboard
  2106. HGLOBAL hglbPaste = ::GetClipboardData(uCF_TText);
  2108. // Import Text data into the control
  2109. if (hglbPaste != NULL)
  2110. {
  2111. TCHAR* lpszClipboard = (TCHAR*)GlobalLock(hglbPaste);
  2113. if (!_ReadRecodsFromText(lpszClipboard, arRecords))
  2114. {
  2115. arRecords.RemoveAll();
  2116. }
  2117. ::GlobalUnlock(hglbPaste);
  2118. }
  2119. }
  2121. ::CloseClipboard();
  2122. //////////////////////////////////////////////////////////////////////////
  2124. CUpdateContext updateContext(this);
  2126. // Add and Populate records
  2127. int nRecordsCount = arRecords.GetCount();
  2128. if (nRecordsCount > 0)
  2129. {
  2130. // Add
  2131. for (int i = 0; i < nRecordsCount; i++)
  2132. {
  2133. CXTPReportRecord* pRecord = arRecords.GetAt(i);
  2134. if (pRecord)
  2135. {
  2136. CMDTARGET_ADDREF(pRecord);
  2137. AddRecord(pRecord);
  2138. }
  2139. }
  2141. Populate();
  2143. // Select added records
  2144. _SelectRows(&arRecords);
  2145. }
  2146. }
  2148. // We support text format with t dividers for record items and
  2149. // rn dividers for records (simple tab-separated text).
  2150. // Such format is also supported by Excel and some other applications.
  2151. CString CXTPReportControl::_GetSelectedRowsVisibleColsText()
  2152. {
  2153. CString strSelText;
  2155. CXTPReportColumns* pColumns = GetColumns();
  2156. if (NULL == pColumns)
  2157. return _T("");
  2159. const int nColumnCount = pColumns->GetVisibleColumnsCount();
  2161. // Iterate over the selected rows and prepare corresponding records text
  2162. CXTPReportSelectedRows* pSelectedRows = GetSelectedRows();
  2163. if ((pSelectedRows != NULL) && (pSelectedRows->GetCount() > 0))
  2164. {
  2165. POSITION pos = pSelectedRows->GetFirstSelectedRowPosition();
  2166. while (pos)
  2167. {
  2168. CXTPReportRow* pRow = pSelectedRows->GetNextSelectedRow(pos);
  2169. if (NULL == pRow)
  2170. break;
  2172. CXTPReportRecord* pRecord = pRow->GetRecord();
  2173. if (NULL == pRecord)
  2174. continue;
  2176. CStringArray arStrings;
  2177. for (int nCol = 0; nCol < nColumnCount; nCol++)
  2178. {
  2179. CXTPReportColumn* pColumn = pColumns->GetVisibleAt(nCol);
  2180. CXTPReportRecordItem* pItem = pRecord->GetItem(pColumn);
  2181. if (NULL == pItem)
  2182. continue;
  2184. arStrings.Add(pItem->GetCaption(pColumn));
  2185. }
  2187. //===============================================================
  2188. BOOL bCanceled = OnBeforeCopyToText(pRecord, arStrings);
  2189. if (bCanceled)
  2190. {
  2191. continue;
  2192. }
  2194. strSelText += XTPStrMake(arStrings, _T("t"));
  2195. strSelText += _T("rn");
  2196. }
  2197. }
  2199. return strSelText;
  2200. }
  2202. BOOL CXTPReportControl::_ReadRecodsFromText(LPCTSTR pcszText,
  2203. CXTPReportRecords& rarRecords)
  2204. {
  2205. //////////////////////////////////////////////////////////////////////////
  2206. // Insert retrieved text into the control
  2208. CStringArray arRecordsStrings;
  2209. XTPStrSplit(pcszText, _T("rn"), arRecordsStrings);
  2211. int nCount = (int)arRecordsStrings.GetSize();
  2212. for (int i = 0; i < nCount; i++)
  2213. {
  2214. CString strRecord = arRecordsStrings[i];
  2215. if (strRecord.IsEmpty())
  2216. {
  2217. continue;
  2218. }
  2220. CXTPReportRecord* pNewRec = _CreateRecodFromText(strRecord);
  2221. // pNewRec = NULL - paste was handled by the user
  2223. if (pNewRec)
  2224. {
  2225. rarRecords.Add(pNewRec);
  2226. }
  2227. }
  2229. return TRUE;
  2230. }
  2232. CXTPReportRecord* CXTPReportControl::_CreateRecodFromText(LPCTSTR pcszRecord)
  2233. {
  2234. if (!GetColumns())
  2235. {
  2236. ASSERT(FALSE);
  2237. return NULL;
  2238. }
  2240. CStringArray arStrings;
  2242. // Read each field from the initial string and set visible field one by one
  2243. XTPStrSplit(pcszRecord, _T("t"), arStrings);
  2245. //=======================================================================
  2246. CXTPReportRecord* pRecord = NULL;
  2247. BOOL bHandled = OnBeforePasteFromText(arStrings, &pRecord);
  2248. if (bHandled)
  2249. {
  2250. return pRecord;
  2251. }
  2253. #if _MFC_VER >= 0x0600 // Not supported by Visual Studio 5.0
  2255. if (!pRecord)
  2256. {
  2257. pRecord = new CXTPReportRecord();
  2258. if (!pRecord)
  2259. {
  2260. return NULL;
  2261. }
  2263. int nDataCount = (int)arStrings.GetSize();
  2265. // Fill record with all items
  2266. int nCount = GetColumns()->GetCount();
  2267. for (int i = 0; i < nCount; i++)
  2268. {
  2269. COleVariant varItem(_T(""));
  2271. CXTPReportRecordItem* pItem = new CXTPReportRecordItemVariant(varItem);
  2272. if (!pItem)
  2273. {
  2274. CMDTARGET_RELEASE(pRecord);
  2275. return NULL;
  2276. }
  2277. pRecord->AddItem(pItem);
  2278. }
  2280. // Iterate all visible columns and set text for each next
  2281. const int nColumnCount = GetColumns()->GetVisibleColumnsCount();
  2282. for (int nCol = 0; nCol < nColumnCount; nCol++)
  2283. {
  2284. COleVariant varItem(nCol < nDataCount ? (LPCTSTR)arStrings[nCol] : _T(""));
  2286. CXTPReportColumn* pColumn = GetColumns()->GetVisibleAt(nCol);
  2287. CXTPReportRecordItem* pItem = pRecord->GetItem(pColumn);
  2288. ASSERT(pItem);
  2289. if (NULL == pItem)
  2290. continue;
  2292. CXTPReportRecordItemVariant* pItemVar = DYNAMIC_DOWNCAST(CXTPReportRecordItemVariant, pItem);
  2293. ASSERT(pItemVar);
  2295. if (pItemVar)
  2296. {
  2297. pItemVar->m_oleValue = varItem;
  2298. }
  2299. }
  2300. }
  2301. #endif
  2303. return pRecord;
  2304. }
  2306. BOOL CXTPReportControl::_WriteRecordsData(CXTPPropExchange* pPX, CXTPReportRecords* pRecords)
  2307. {
  2308. if (!pRecords)
  2309. return FALSE;
  2312. long nSchema = XTP_REPORT_CB_RECORDS_DATA_VER;
  2314. PX_Long(pPX, _T("Version"), (long&)nSchema);
  2315. pPX->ExchangeLocale();
  2318. CXTPPropExchangeSection secRecords(pPX->GetSection(_T("ReportRecords")));
  2320. int nRecordsCount = (int)pRecords->GetCount();
  2321. CXTPPropExchangeEnumeratorPtr pEnumRecords(secRecords->GetEnumerator(_T("Record")));
  2322. POSITION posRecord = pEnumRecords->GetPosition((DWORD)nRecordsCount);
  2324. for (int i = 0; i < nRecordsCount; i++)
  2325. {
  2326. CXTPPropExchangeSection secRecord(pEnumRecords->GetNext(posRecord));
  2328. CXTPReportRecord* pRecord = pRecords->GetAt(i);
  2329. PX_Object(&secRecord, pRecord, RUNTIME_CLASS(CXTPReportRecord));
  2330. }
  2332. return TRUE;
  2333. }
  2335. void CXTPReportControl::_SelectRows(CXTPReportRecords* pRecords)
  2336. {
  2337. CXTPReportRows* pRows = GetRows();
  2338. CXTPReportSelectedRows* pSelRows = GetSelectedRows();
  2339. if (!pRows || !pSelRows)
  2340. return;
  2342. pSelRows->Clear();
  2343. int nRecordsCount = pRecords->GetCount();
  2345. for (int nNewRecNr = 0; nNewRecNr < nRecordsCount; nNewRecNr++)
  2346. {
  2347. CXTPReportRecord* pRec = pRecords->GetAt(nNewRecNr);
  2348. CXTPReportRow* pRow = pRows->Find(pRec);
  2349. if (pRow)
  2350. {
  2351. pSelRows->Add(pRow);
  2353. if (nNewRecNr == nRecordsCount - 1)
  2354. SetFocusedRow(pRow, TRUE);
  2355. }
  2356. }
  2357. }
  2359. BOOL CXTPReportControl::_GetSelectedRows(CXTPReportRecords* pRecords,
  2360.  CXTPInternalCollectionT<CXTPReportRow> *pRows)
  2361. {
  2362. ASSERT(!pRecords || pRecords->m_bArray == TRUE);
  2364. CXTPReportSelectedRows* pSelectedRows = GetSelectedRows();
  2365. if (!pSelectedRows || !pSelectedRows->GetCount() || (!pRecords && !pRows))
  2366. {
  2367. return FALSE;
  2368. }
  2370. POSITION pos = pSelectedRows->GetFirstSelectedRowPosition();
  2371. while (pos)
  2372. {
  2373. CXTPReportRow* pRow = pSelectedRows->GetNextSelectedRow(pos);
  2374. CXTPReportRecord* pRecord = pRow ? pRow->GetRecord() : NULL;
  2375. if (NULL == pRow)
  2376. {
  2377. break;
  2378. }
  2379. if (pRecord && pRecords)
  2380. {
  2381. pRecords->Add(pRecord);
  2382. }
  2384. if (pRow && pRows)
  2385. {
  2386. pRows->AddPtr(pRow, TRUE);
  2387. }
  2388. }
  2390. return TRUE;
  2391. }
  2393. BOOL CXTPReportControl::_WriteSelectedRowsData(CXTPPropExchange* pPX)
  2394. {
  2395. if (!pPX || !pPX->IsStoring())
  2396. {
  2397. ASSERT(FALSE);
  2398. return FALSE;
  2399. }
  2401. CXTPReportRecords* pSelectedRecords= new CXTPReportRecords(TRUE);
  2403. if (!_GetSelectedRows(pSelectedRecords) || !_WriteRecordsData(pPX, pSelectedRecords))
  2404. {
  2405. CMDTARGET_RELEASE(pSelectedRecords);
  2406. return FALSE;
  2407. }
  2409. CMDTARGET_RELEASE(pSelectedRecords);
  2410. return TRUE;
  2411. }
  2413. BOOL CXTPReportControl::_ReadRecodsFromData(CXTPPropExchange* pPX,
  2414. CXTPReportRecords& rarRecords)
  2415. {
  2416. rarRecords.RemoveAll();
  2418. if (!pPX || !pPX->IsLoading())
  2419. {
  2420. ASSERT(FALSE);
  2421. return FALSE;
  2422. }
  2424. CXTPPropExchangeSection secRecords(pPX->GetSection(_T("ReportRecords")));
  2426. long nSchema = 0;
  2428. PX_Long(pPX, _T("Version"), (long&)nSchema);
  2429. pPX->ExchangeLocale();
  2431. if (nSchema != XTP_REPORT_CB_RECORDS_DATA_VER)
  2432. {
  2433. ASSERT(FALSE);
  2434. return FALSE;
  2435. }
  2437. CXTPPropExchangeEnumeratorPtr pEnumRecords(secRecords->GetEnumerator(_T("Record")));
  2438. POSITION posRecord = pEnumRecords->GetPosition();
  2440. while (posRecord)
  2441. {
  2442. CXTPPropExchangeSection secRecord(pEnumRecords->GetNext(posRecord));
  2444. CXTPReportRecord* pRecord = NULL;
  2445. PX_Object(&secRecord, pRecord, RUNTIME_CLASS(CXTPReportRecord));
  2447. if (!pRecord)
  2448. {
  2449. AfxThrowArchiveException(CArchiveException::badClass);
  2450. }
  2451. CXTPReportRecord* pRecord2 = pRecord;
  2452. BOOL bCanceled = OnBeforePaste(&pRecord2);
  2454. if (bCanceled || pRecord2 != pRecord)
  2455. {
  2456. CMDTARGET_RELEASE(pRecord);
  2457. }
  2458. if (bCanceled)
  2459. {
  2460. continue;
  2461. }
  2463. rarRecords.Add(pRecord2);
  2464. }
  2466. return TRUE;
  2467. }
  2469. BOOL CXTPReportControl::OnBeforeCopyToText(CXTPReportRecord* pRecord, CStringArray& rarStrings)
  2470. {
  2471. XTP_NM_REPORT_BEFORE_COPYPASTE nmParams;
  2472. ::ZeroMemory(&nmParams, sizeof(nmParams));
  2474. CXTPReportRecord* pRecordTmp = pRecord;
  2475. nmParams.ppRecord = &pRecordTmp;
  2476. nmParams.parStrings = &rarStrings;
  2478. LRESULT lResult = SendNotifyMessage(XTP_NM_REPORT_BEFORE_COPY_TOTEXT, (NMHDR*)&nmParams);
  2480. return lResult != 0;
  2481. }
  2483. BOOL CXTPReportControl::OnBeforePasteFromText(CStringArray& arStrings,
  2484. CXTPReportRecord** ppRecord)
  2485. {
  2486. XTP_NM_REPORT_BEFORE_COPYPASTE nmParams;
  2487. ::ZeroMemory(&nmParams, sizeof(nmParams));
  2489. nmParams.parStrings = &arStrings;
  2490. nmParams.ppRecord = ppRecord;
  2492. LRESULT lResult = SendNotifyMessage(XTP_NM_REPORT_BEFORE_PASTE_FROMTEXT, (NMHDR*)&nmParams);
  2494. return lResult != 0;
  2495. }
  2497. BOOL CXTPReportControl::OnBeforePaste(CXTPReportRecord** ppRecord)
  2498. {
  2499. XTP_NM_REPORT_BEFORE_COPYPASTE nmParams;
  2500. ::ZeroMemory(&nmParams, sizeof(nmParams));
  2502. nmParams.ppRecord = ppRecord;
  2504. LRESULT lResult = SendNotifyMessage(XTP_NM_REPORT_BEFORE_PASTE, (NMHDR*)&nmParams);
  2506. return lResult != 0;
  2507. }
  2509. int CXTPReportControl::OnGetColumnDataBestFitWidth(CXTPReportColumn* pColumn)
  2510. {
  2511. CXTPReportPaintManager* pPaintManager = GetPaintManager();
  2512. if (!pColumn || !pPaintManager)
  2513. {
  2514. ASSERT(FALSE);
  2515. return 0;
  2516. }
  2518. if(pColumn->GetBestFitMode() != xtpColumnBestFitModeAllData)
  2519. return 0;
  2521. CClientDC dc(this);
  2522. CXTPFontDC autoFont(&dc, pPaintManager->GetTextFont()); // to reset selected font on exit
  2524. int nDataWidth = OnGetItemsCaptionMaxWidth(&dc, GetRows(), pColumn);
  2526. return nDataWidth;
  2527. }
  2529. int CXTPReportControl::OnGetItemsCaptionMaxWidth(CDC* pDC, CXTPReportRows* pRows,
  2530. CXTPReportColumn* pColumn)
  2531. {
  2532. CXTPReportPaintManager* pPaintManager = GetPaintManager();
  2533. if(!pDC || !pRows || !pColumn || !pPaintManager)
  2534. {
  2535. ASSERT(FALSE);
  2536. return 0;
  2537. }
  2539. XTP_REPORTRECORDITEM_DRAWARGS drawArgs;
  2540. drawArgs.pDC = pDC;
  2541. drawArgs.pControl = this;
  2542. drawArgs.pColumn = pColumn;
  2543. drawArgs.rcItem = pColumn->GetRect();
  2545. XTP_REPORTRECORDITEM_METRICS* pMetrics = new XTP_REPORTRECORDITEM_METRICS();
  2547. int nMaxWidth = 0;
  2548. int nItemIndex = pColumn->GetItemIndex();
  2550. int nCount = pRows->GetCount();
  2551. for (int i = 0; i < nCount; i++)
  2552. {
  2553. CXTPReportRow* pRow = pRows->GetAt(i);
  2554. ASSERT(pRow);
  2555. if (pRow && pRow->IsGroupRow())
  2556. continue;
  2558. CXTPReportRecord* pRec = pRow ? pRow->GetRecord() : NULL;
  2559. CXTPReportRecordItem* pItem = pRec ? pRec->GetItem(nItemIndex) : NULL;
  2560. ASSERT(pItem);
  2562. if (!pItem)
  2563. continue;
  2565. drawArgs.pRow = pRow;
  2566. drawArgs.pItem = pItem;
  2568. pMetrics->strText = pItem->GetCaption(pColumn);
  2570. pRow->GetItemMetrics(&drawArgs, pMetrics);
  2572. pDC->SelectObject(pMetrics->pFont);
  2574. int nWidth = pDC->GetTextExtent(pMetrics->strText).cx + 7;
  2575. nMaxWidth = max(nMaxWidth, nWidth);
  2576. }
  2578. CMDTARGET_RELEASE(pMetrics);
  2580. return nMaxWidth;
  2581. }
  2583. BOOL CXTPReportControl::IsEditMode()
  2584. {
  2585. CXTPReportInplaceEdit* pEdit = GetInplaceEdit();
  2587. BOOL bEditMode = pEdit && pEdit->GetSafeHwnd() && pEdit->IsWindowVisible();
  2588. bEditMode |= GetInplaceList() && GetInplaceList()->GetSafeHwnd() && GetInplaceList()->IsWindowVisible();
  2590. return bEditMode;
  2591. }
  2594. int CXTPReportControl::GetRowsHeight(CXTPReportRows* pRows, int nTotalWidth, int nMaxHeight)
  2595. {
  2596. int nRowsHeight = 0;
  2598. CWindowDC dc (this);
  2600. for(int i = 0; i < pRows->GetCount(); ++i)
  2601. {
  2602. nRowsHeight += GetPaintManager()->GetRowHeight(&dc, pRows->GetAt(i), nTotalWidth);
  2604. if (nMaxHeight >= 0 && nRowsHeight > nMaxHeight)
  2605. return nRowsHeight;
  2606. }
  2608. return nRowsHeight;
  2609. }
  2611. int CXTPReportControl::GetHeaderRowsDividerHeight()
  2612. {
  2613. return GetPaintManager()->GetHeaderRowsDividerHeight();
  2614. }
  2616. int CXTPReportControl::GetFooterRowsDividerHeight()
  2617. {
  2618. return GetPaintManager()->GetFooterRowsDividerHeight();
  2619. }
  2621. void CXTPReportControl::DrawDefaultGrid(CDC* pDC, CRect rcClient, int nRowHeight, int nLeftOffset)
  2622. {
  2623. if (nRowHeight <= 0)
  2624. return;
  2626. //  int y = rcClient.top;
  2627. int nFreezeCols = m_nFreezeColumnsCount;
  2628. CRect rcClipBox = GetReportRectangle();
  2630. CRect rcRow;
  2631. rcRow = rcClient;
  2632. rcRow.left -= nLeftOffset;
  2633. rcRow.right -= nLeftOffset;
  2634. rcRow.bottom = rcClient.top + nRowHeight;
  2636. int nIndentWidth = GetHeaderIndent();
  2637. CXTPReportPaintManager* pPaintManager = GetPaintManager();
  2639. CXTPReportColumns arrVisibleColumns(this);
  2640. GetColumns()->GetVisibleColumns(arrVisibleColumns);
  2641. int nVisColCount = arrVisibleColumns.GetCount();
  2642. nFreezeCols = min(nFreezeCols, nVisColCount);
  2644. // fill the empty space
  2645. while(rcRow.top < rcClient.bottom)
  2646. {
  2647. CRect rcItem(rcRow.left, rcRow.top, rcRow.right, rcRow.bottom);
  2649. CRect rcIndent(nFreezeCols ? rcRow : rcRow); /////////////////////
  2650. rcIndent.right = rcIndent.left + nIndentWidth;
  2652. int xMinCol_0 = rcRow.left + nIndentWidth;
  2654. for (int nColumn = nVisColCount-1; nColumn >= 0; nColumn--)
  2655. {
  2656. BOOL bFreezeCol = nColumn < nFreezeCols;
  2657. int nColIdx = bFreezeCol ? nFreezeCols - 1 - nColumn : nColumn;
  2659. CXTPReportColumn* pColumn = arrVisibleColumns.GetAt(nColIdx);
  2660. ASSERT(pColumn && pColumn->IsVisible());
  2662. if (pColumn)
  2663. {
  2664. rcItem.left = pColumn->GetRect().left;
  2665. if (nColIdx == 0)
  2666. {
  2667. rcItem.left = max(xMinCol_0, rcItem.left);
  2668. }
  2669. rcItem.right = pColumn->GetRect().right;
  2671. if (!CRect().IntersectRect(rcClipBox, rcItem))
  2672. continue;
  2674. if (bFreezeCol)
  2675. {
  2676. CRect rcFreeze(rcItem);
  2677. rcFreeze.top +=1;
  2678. pDC->FillSolidRect(rcFreeze, pPaintManager->GetControlBackColor(this));
  2679. }
  2681. CRect rcGridItem(rcItem);
  2682. rcGridItem.left--;
  2684. pPaintManager->DrawGrid(pDC, FALSE, rcGridItem);
  2685. pPaintManager->DrawGrid(pDC, TRUE, rcGridItem);
  2687. if (nColIdx == nFreezeCols - 1)
  2688. pPaintManager->DrawFreezeColsDivider(pDC, rcGridItem, this);
  2689. }
  2690. }
  2692. if (nIndentWidth > 0)
  2693. {
  2694. // draw indent column
  2695. pPaintManager->FillIndent(pDC, rcIndent);
  2696. }
  2698. rcRow.top += nRowHeight;
  2699. rcRow.bottom += nRowHeight;
  2700. }
  2701. }
  2704. BOOL CXTPReportControl::PreTranslateMessage(MSG* pMsg)
  2705. {
  2706. if (pMsg->message == WM_KEYDOWN)
  2707. {
  2708. if (!OnPreviewKeyDown((UINT&)pMsg->wParam, LOWORD(pMsg->lParam), HIWORD(pMsg->lParam)) )
  2709. {
  2710. TRACE(_T("ReportControl, PreTranslateMessagem-OnPreviewKeyDown('%d') = CANCEL  n"), pMsg->wParam);
  2711. return TRUE;
  2712. }
  2713. }
  2715. return CWnd::PreTranslateMessage(pMsg);
  2716. }
  2718. BOOL CXTPReportControl::OnConstraintSelecting(CXTPReportRow* pRow, CXTPReportRecordItem* pItem, CXTPReportColumn* pColumn,
  2719. CXTPReportRecordItemConstraint* pConstraint)
  2720. {
  2721. XTP_NM_REPORTCONSTRAINTSELECTING    nmConstraint;
  2722. ::ZeroMemory(&nmConstraint, sizeof(nmConstraint));
  2724. nmConstraint.pRow = pRow;
  2725. nmConstraint.pColumn = pColumn;
  2726. nmConstraint.pItem = pItem;
  2727. nmConstraint.pConstraint = pConstraint;
  2729. LRESULT lResult = SendNotifyMessage(XTP_NM_REPORT_CONSTRAINT_SELECTING, (NMHDR*)&nmConstraint);
  2731. return lResult != 0;
  2732. }
  2734. const XTP_NM_REPORTTOOLTIPINFO& CXTPReportControl::OnGetToolTipInfo(CXTPReportRow* pRow, CXTPReportRecordItem* pItem, CString& rstrToolTipText)
  2735. {
  2736. ::ZeroMemory(m_pCachedToolTipInfo, sizeof(XTP_NM_REPORTTOOLTIPINFO));
  2738. m_pCachedToolTipInfo->pRow = pRow;
  2739. m_pCachedToolTipInfo->pItem = pItem;
  2740. m_pCachedToolTipInfo->pstrText = &rstrToolTipText;
  2742. SendNotifyMessage(XTP_NM_REPORT_GETTOOLTIPINFO, (NMHDR*)m_pCachedToolTipInfo);
  2744. return *m_pCachedToolTipInfo;
  2745. }
  2747. CRect CXTPReportControl::GetElementRect(int nElement) const
  2748. {
  2749. switch(nElement)
  2750. {
  2751. case xtpReportElementRectGroupByArea : return m_rcGroupByArea; break;
  2752. case xtpReportElementRectHeaderArea : return m_rcHeaderArea; break;
  2753. case xtpReportElementRectFooterArea : return m_rcFooterArea; break;
  2754. case xtpReportElementRectHeaderRecordsArea : return m_rcHeaderRecordsArea; break;
  2755. case xtpReportElementRectFooterRecordsArea : return m_rcFooterRecordsArea; break;
  2756. case xtpReportElementRectHeaderRecordsDividerArea : return m_rcHeaderRecordsDividerArea; break;
  2757. case xtpReportElementRectFooterRecordsDividerArea : return m_rcFooterRecordsDividerArea; break;
  2758. default : return m_rcReportArea; break;
  2759. }
  2760. }
  2762. void CXTPReportControl::EnableMarkup(BOOL bEnable)
  2763. {
  2764. m_pRecords->EnableMarkup(bEnable);
  2765. }
  2767. CXTPMarkupContext* CXTPReportControl::GetMarkupContext() const
  2768. {
  2769. return m_pRecords->GetMarkupContext();
  2770. }