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

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

对话框与窗口

开发平台：

Visual C++

XTPReportView.cpp：源码内容
  1. // XTPReportView.cpp : implementation of the CXTPReportView 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"
  23. #include "XTPReportView.h"
  24. #include "XTPReportColumn.h"
  25. #include "XTPReportColumns.h"
  26. #include "XTPReportRecordItem.h"
  27. #include "XTPReportRecordItemText.h"
  28. #include "XTPReportInplaceControls.h"
  29. #include "XTPReportRecord.h"
  30. #include "XTPReportRecords.h"
  32. #include "Common/XTPVC80Helpers.h"
  33. #include "Common/XTPResourceManager.h"
  34. #include "Common/XTPImageManager.h"
  36. #include "Common/Resource.h"
  38. #ifdef _DEBUG
  39. #define new DEBUG_NEW
  40. #undef THIS_FILE
  41. static char THIS_FILE[] = __FILE__;
  42. #endif
  44. /////////////////////////////////////////////////////////////////////////////
  46. BEGIN_MESSAGE_MAP(CXTPReportPageSetupDialog, CPageSetupDialog)
  47. ON_BN_CLICKED(XTP_IDC_HEADER_FORMAT_BTN, OnBnClickedHeaderFormat)
  48. ON_BN_CLICKED(XTP_IDC_FOOTER_FORMAT_BTN, OnBnClickedFooterFormat)
  49. END_MESSAGE_MAP()
  51. CXTPReportPageSetupDialog::CXTPReportPageSetupDialog(
  52. CXTPReportViewPrintOptions* pOptions,
  53. DWORD dwFlags, CWnd* pParentWnd)
  54. : CPageSetupDialog(dwFlags, pParentWnd)
  55. {
  56. ASSERT(pOptions);
  57. m_pOptions = pOptions;
  59. if (m_pOptions)
  60. {
  61. BOOL bIsInches = m_pOptions->IsMarginsMeasureInches();
  62. DWORD dwMeasure = bIsInches ? PSD_INTHOUSANDTHSOFINCHES : PSD_INHUNDREDTHSOFMILLIMETERS;
  64. m_psd.Flags &= ~PSD_INWININIINTLMEASURE;
  65. m_psd.Flags |= dwMeasure;
  66. }
  68. m_psd.Flags |= PSD_ENABLEPAGESETUPTEMPLATEHANDLE;
  69. m_psd.hPageSetupTemplate = XTPResourceManager()->LoadDialogTemplate2(MAKEINTRESOURCE(IDD));
  70. ASSERT(m_psd.hPageSetupTemplate);
  72. if (m_pOptions)
  73. {
  74. m_psd.rtMargin = m_pOptions->m_rcMargins;
  75. }
  77. m_nIDHelp = CXTPReportPageSetupDialog::IDD;
  78. }
  80. CXTPReportPageSetupDialog::~CXTPReportPageSetupDialog()
  81. {
  82. }
  84. #ifndef rad1
  85. #define rad1        0x0420
  86. #define rad2        0x0421
  88. #define grp4        0x0433
  89. #endif
  91. BOOL CXTPReportPageSetupDialog::OnInitDialog ()
  92. {
  93. CPageSetupDialog::OnInitDialog();
  95. ASSERT(m_pOptions);
  97. VERIFY( m_ctrlHeaderFormat.SubclassDlgItem(XTP_IDC_HEADER_FORMAT, this) );
  98. VERIFY( m_ctrlFooterFormat.SubclassDlgItem(XTP_IDC_FOOTER_FORMAT, this) );
  100. VERIFY( m_ctrlHeaderFormatBtn.SubclassDlgItem(XTP_IDC_HEADER_FORMAT_BTN, this) );
  101. VERIFY( m_ctrlFooterFormatBtn.SubclassDlgItem(XTP_IDC_FOOTER_FORMAT_BTN, this) );
  103. if(m_pOptions && m_pOptions->GetPageHeader())
  104. {
  105. m_ctrlHeaderFormat.SetWindowText(m_pOptions->GetPageHeader()->m_strFormatString);
  106. }
  108. if(m_pOptions && m_pOptions->GetPageFooter())
  109. {
  110. m_ctrlFooterFormat.SetWindowText(m_pOptions->GetPageFooter()->m_strFormatString);
  111. }
  113. if (GetDlgItem(rad1))
  114. GetDlgItem(rad1)->EnableWindow(TRUE); //1056 Portrait
  115. if (GetDlgItem(rad2))
  116. GetDlgItem(rad2)->EnableWindow(TRUE); //1057 Landscape
  118. BOOL bIsInches = m_pOptions ? m_pOptions->IsMarginsMeasureInches() : FALSE;
  120. UINT uStrID = bIsInches ? XTP_IDS_REPORT_MARGINS_INCH : XTP_IDS_REPORT_MARGINS_MM;
  121. CString strCaption;
  122. VERIFY(XTPResourceManager()->LoadString(&strCaption, uStrID));
  124. if (!strCaption.IsEmpty() && GetDlgItem(grp4))
  125. {
  126. GetDlgItem(grp4)->SetWindowText(strCaption);
  127. }
  129. HICON hBtnIcon = XTPResourceManager()->LoadIcon(XTP_IDI_BTN_ARROW_R, CSize(0,0));
  130. ASSERT(hBtnIcon);
  131. if (hBtnIcon)
  132. {
  133. m_ctrlHeaderFormatBtn.SetIcon(hBtnIcon);
  134. m_ctrlFooterFormatBtn.SetIcon(hBtnIcon);
  135. }
  137. return FALSE;
  138. }
  140. void CXTPReportPageSetupDialog::OnOK()
  141. {
  142. if(m_pOptions && m_pOptions->GetPageHeader())
  143. {
  144. m_ctrlHeaderFormat.GetWindowText(m_pOptions->GetPageHeader()->m_strFormatString);
  145. }
  147. if(m_pOptions && m_pOptions->GetPageFooter())
  148. {
  149. m_ctrlFooterFormat.GetWindowText(m_pOptions->GetPageFooter()->m_strFormatString);
  150. }
  152. if (m_pOptions) m_pOptions->m_rcMargins = m_psd.rtMargin;
  154. CPageSetupDialog::OnOK();
  155. }
  157. void CXTPReportPageSetupDialog::OnBnClickedHeaderFormat()
  158. {
  159. CXTPPrintPageHeaderFooter::DoInsertHFFormatSpecifierViaMenu(
  160. this, &m_ctrlHeaderFormat, &m_ctrlHeaderFormatBtn);
  161. }
  163. void CXTPReportPageSetupDialog::OnBnClickedFooterFormat()
  164. {
  165. CXTPPrintPageHeaderFooter::DoInsertHFFormatSpecifierViaMenu(
  166. this, &m_ctrlFooterFormat, &m_ctrlFooterFormatBtn);
  167. }
  169. /////////////////////////////////////////////////////////////////////////////
  170. // CXTPReportView
  172. IMPLEMENT_DYNCREATE(CXTPReportView, CView)
  174. CXTPReportView::CXTPReportView()
  175. {
  176. m_pReport = NULL;
  177. m_pPrintOptions = new CXTPReportViewPrintOptions();
  179. m_bPrintSelection = FALSE;
  181. m_bPrintDirect = FALSE;
  182. m_bResizeControlWithView = TRUE;
  184. m_bAllowCut = TRUE;
  185. m_bAllowPaste = TRUE;
  187. m_pScrollBar = NULL;
  189. }
  191. CXTPReportView::~CXTPReportView()
  192. {
  193. CMDTARGET_RELEASE(m_pPrintOptions);
  194. SAFE_DELETE(m_pReport);
  195. }
  198. CXTPReportControl& CXTPReportView::GetReportCtrl() const
  199. {
  200. return m_pReport == NULL ? (CXTPReportControl&)m_wndReport : *m_pReport;
  201. }
  203. void CXTPReportView::SetReportCtrl(CXTPReportControl* pReport)
  204. {
  205. if (::IsWindow(m_wndReport.GetSafeHwnd()))
  206. m_wndReport.DestroyWindow();
  208. m_pReport = pReport;
  209. }
  211. void CXTPReportView::SetScrollBarCtrl(CScrollBar* pScrollBar)
  212. {
  213. m_pScrollBar = pScrollBar;
  214. }
  216. BEGIN_MESSAGE_MAP(CXTPReportView, CView)
  217. //{{AFX_MSG_MAP(CXTPReportView)
  218. ON_WM_ERASEBKGND()
  219. ON_WM_SIZE()
  220. ON_WM_CREATE()
  221. ON_WM_SETFOCUS()
  222. ON_WM_PAINT()
  223. ON_COMMAND(ID_FILE_PRINT, OnFilePrint)
  224. ON_COMMAND(ID_EDIT_CUT, OnEditCut)
  225. ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
  226. ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
  227. ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
  228. ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditCopy)
  229. ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateEditCut)
  230. ON_WM_VSCROLL()
  231. //}}AFX_MSG_MAP
  232. END_MESSAGE_MAP()
  234. /////////////////////////////////////////////////////////////////////////////
  235. // CXTPReportView drawing
  237. void CXTPReportView::OnDraw(CDC* /*pDC*/)
  238. {
  239. }
  241. void CXTPReportView::OnPaint()
  242. {
  243. Default();
  244. }
  247. /////////////////////////////////////////////////////////////////////////////
  248. // CXTPReportView diagnostics
  250. #ifdef _DEBUG
  251. void CXTPReportView::AssertValid() const
  252. {
  253. CView::AssertValid();
  254. }
  256. void CXTPReportView::Dump(CDumpContext& dc) const
  257. {
  258. CView::Dump(dc);
  259. }
  260. #endif //_DEBUG
  262. /////////////////////////////////////////////////////////////////////////////
  263. // CXTPReportView message handlers
  265. BOOL CXTPReportView::OnEraseBkgnd(CDC*)
  266. {
  267. return TRUE;
  268. }
  270. CScrollBar* CXTPReportView::GetScrollBarCtrl(int nBar) const
  271. {
  272. if (nBar == SB_VERT && m_pScrollBar)
  273. return m_pScrollBar;
  275. return CView::GetScrollBarCtrl(nBar);
  276. }
  278. void CXTPReportView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  279. {
  280. if (m_pScrollBar && pScrollBar == m_pScrollBar)
  281. GetReportCtrl().OnVScroll(nSBCode, nPos, 0);
  283. CView::OnVScroll(nSBCode, nPos, pScrollBar);
  284. }
  286. void CXTPReportView::OnSize(UINT nType, int cx, int cy)
  287. {
  288. CView::OnSize(nType, cx, cy);
  290. if (m_pScrollBar && m_pScrollBar->GetSafeHwnd())
  291. {
  292. int nScroll = GetSystemMetrics(SM_CXVSCROLL);
  293. m_pScrollBar->MoveWindow(cx - nScroll, 0, nScroll, cy);
  294. cx -= nScroll;
  295. }
  297. if (m_bResizeControlWithView && GetReportCtrl().GetSafeHwnd())
  298. {
  299. GetReportCtrl().MoveWindow(0, 0, cx, cy);
  300. }
  301. }
  303. int CXTPReportView::OnCreate(LPCREATESTRUCT lpCreateStruct)
  304. {
  305. if (CView::OnCreate(lpCreateStruct) == -1)
  306. return -1;
  308. if (!GetReportCtrl().Create(WS_CHILD | WS_TABSTOP | WS_VISIBLE ,
  309. CRect(0, 0, 0, 0), this, XTP_ID_REPORT_CONTROL))
  310. {
  311. TRACE(_T("Failed to create report control windown"));
  312. return -1;
  313. }
  314. return 0;
  315. }
  317. void CXTPReportView::OnSetFocus(CWnd* pOldWnd)
  318. {
  319. CView::OnSetFocus(pOldWnd);
  321. if(IsWindow(GetReportCtrl().GetSafeHwnd()))
  322. GetReportCtrl().SetFocus();
  323. }
  326. /////////////////////////////////////////////////////////////////////////////
  327. // CReportSampleView printing
  329. BOOL CXTPReportView::OnPreparePrinting(CPrintInfo* pInfo)
  330. {
  331. if (GetReportCtrl().GetSelectedRows()->GetCount() > 0)
  332. {
  333. pInfo->m_pPD->m_pd.Flags &= ~PD_NOSELECTION;
  334. }
  336. pInfo->m_bDirect = m_bPrintDirect;
  338. // default preparation
  339. if (!DoPreparePrinting(pInfo))
  340. return FALSE;
  342. m_bPrintSelection = pInfo->m_pPD->PrintSelection();
  344. return TRUE;
  345. }
  347. void CXTPReportView::OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo)
  348. {
  349. ASSERT(m_aPageStart.GetSize() == 0);
  350. m_aPageStart.RemoveAll();
  351. m_aPageStart.Add(0);
  353. CString str1, str2;
  354. if (m_pPrintOptions && m_pPrintOptions->GetPageHeader())
  355. str1 = m_pPrintOptions->GetPageHeader()->m_strFormatString;
  356. if (m_pPrintOptions && m_pPrintOptions->GetPageFooter())
  357. str2 = m_pPrintOptions->GetPageFooter()->m_strFormatString;
  359. if (str1.Find(_T("&P")) >= 0 || str2.Find(_T("&P")) >= 0)
  360. {
  361. int nCurPage = pInfo->m_nCurPage;
  363. pInfo->m_nCurPage = 65535;
  365. if (PaginateTo(pDC, pInfo))
  366. {
  367. pInfo->SetMaxPage((int)m_aPageStart.GetSize() - 1);
  368. }
  370. pInfo->m_nCurPage = nCurPage;
  371. }
  372. }
  374. void CXTPReportView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  375. {
  376. m_aPageStart.RemoveAll();
  377. m_bmpGrayDC.DeleteObject();
  378. }
  380. CXTPReportPaintManager* CXTPReportView::GetPaintManager() const
  381. {
  382. return GetReportCtrl().GetPaintManager();
  383. }
  385. int CXTPReportView::GetColumnWidth(CXTPReportColumn* pColumnTest, int nTotalWidth)
  386. {
  387. return pColumnTest->GetPrintWidth(nTotalWidth);
  388. }
  390. void CXTPReportView::PrintHeader(CDC* pDC, CRect rcHeader)
  391. {
  392. GetPaintManager()->FillHeaderControl(pDC, rcHeader);
  394. int x = rcHeader.left;
  396. CXTPReportColumns* pColumns = GetReportCtrl().GetColumns();
  398. for (int i = 0; i < pColumns->GetCount(); i++)
  399. {
  400. CXTPReportColumn* pColumn = pColumns->GetAt(i);
  401. if (!pColumn->IsVisible())
  402. continue;
  404. int nWidth = GetColumnWidth(pColumn, rcHeader.Width());
  405. CRect rcItem(x, rcHeader.top, x + nWidth, rcHeader.bottom);
  407. GetPaintManager()->DrawColumn(pDC, pColumn, GetReportCtrl().GetReportHeader(), rcItem);
  409. x += nWidth;
  410. }
  411. }
  413. void CXTPReportView::PrintFooter(CDC* pDC, CRect rcFooter)
  414. {
  415. GetPaintManager()->FillFooter(pDC, rcFooter);
  417. int x = rcFooter.left;
  419. CXTPReportColumns* pColumns = GetReportCtrl().GetColumns();
  421. for (int i = 0; i < pColumns->GetCount(); i++)
  422. {
  423. CXTPReportColumn* pColumn = pColumns->GetAt(i);
  424. if (!pColumn->IsVisible())
  425. continue;
  427. int nWidth = GetColumnWidth(pColumn, rcFooter.Width());
  428. CRect rcItem(x, rcFooter.top, x + nWidth, rcFooter.bottom);
  430. GetPaintManager()->DrawColumnFooter(pDC, pColumn, GetReportCtrl().GetReportHeader(), rcItem);
  432. x += nWidth;
  433. }
  434. }
  436. void CXTPReportView::PrintRow(CDC* pDC, CXTPReportRow* pRow, CRect rcRow, int nPreviewHeight)
  437. {
  438. if (pRow->IsGroupRow())
  439. {
  440. pRow->Draw(pDC, rcRow, 0);
  441. return;
  442. }
  444. CXTPReportControl& wndReport = GetReportCtrl();
  446. XTP_REPORTRECORDITEM_DRAWARGS drawArgs;
  447. drawArgs.pDC = pDC;
  448. drawArgs.pControl = &wndReport;
  449. drawArgs.pRow = pRow;
  450. int nIndentWidth = wndReport.GetHeaderIndent();
  451. CXTPReportPaintManager* pPaintManager = GetPaintManager();
  453. CXTPReportColumns* pColumns = wndReport.GetColumns();
  454. int nColumnCount = pColumns->GetCount();
  456. // paint row background
  457. pPaintManager->FillRow(pDC, pRow, rcRow);
  459. CRect rcItem(rcRow);
  460. rcItem.bottom = rcItem.bottom - nPreviewHeight;
  462. CXTPReportRecord* pRecord = pRow->GetRecord();
  463. if (pRecord) // if drawing record, not group
  464. {
  465. BOOL bFirstVisibleColumn = TRUE;
  466. int x = rcRow.left;
  467. // paint record items
  468. for (int nColumn = 0; nColumn < nColumnCount; nColumn++)
  469. {
  470. CXTPReportColumn* pColumn = pColumns->GetAt(nColumn);
  471. if (pColumn && pColumn->IsVisible() && pRow->IsItemsVisible())
  472. {
  473. rcItem.left = x;
  474. x = rcItem.right = rcItem.left + GetColumnWidth(pColumn, rcRow.Width());
  476. if (bFirstVisibleColumn)
  477. {
  478. rcItem.left += nIndentWidth;
  479. bFirstVisibleColumn = FALSE;
  480. }
  482. CRect rcGridItem(rcItem);
  483. rcGridItem.left--;
  485. CXTPReportRecordItem* pItem = pRecord->GetItem(pColumn);
  487. if (pItem)
  488. {
  490. // draw item
  491. drawArgs.pColumn = pColumn;
  492. drawArgs.rcItem = rcItem;
  493. drawArgs.nTextAlign = pColumn->GetAlignment();
  494. drawArgs.pItem = pItem;
  495. // draw item
  496. pItem->Draw(&drawArgs);
  497. }
  499. // customize grid (is vertical grid required)
  500. if (pRow->GetType() == xtpRowTypeHeader)
  501. {
  502. if (pColumn->GetDrawHeaderRowsVGrid())
  503. pPaintManager->DrawGrid(pDC, TRUE, rcGridItem);
  504. }
  505. else if (pRow->GetType() == xtpRowTypeFooter)
  507. {
  508. if (pColumn->GetDrawFooterRowsVGrid())
  509. pPaintManager->DrawGrid(pDC, TRUE, rcGridItem);
  510. }
  511. else
  512. {
  513. pPaintManager->DrawGrid(pDC, TRUE, rcGridItem);
  514. }
  515. }
  516. }
  518. if (nIndentWidth > 0)
  519. {
  520. // draw indent column
  521. CRect rcIndent(rcRow);
  522. rcIndent.right = rcRow.left + nIndentWidth;
  523. pPaintManager->FillIndent(pDC, rcIndent);
  524. }
  526. if (pRow->IsPreviewVisible())
  527. {
  528. CXTPReportRecordItemPreview* pItem = pRecord->GetItemPreview();
  530. CRect rcPreviewItem(rcRow);
  531. rcPreviewItem.DeflateRect(nIndentWidth, rcPreviewItem.Height() - nPreviewHeight, 0, 0);
  533. drawArgs.rcItem = rcPreviewItem;
  534. drawArgs.nTextAlign = DT_LEFT;
  535. drawArgs.pItem = pItem;
  536. drawArgs.pColumn = NULL;
  538. drawArgs.pItem->Draw(&drawArgs);
  539. }
  540. }
  542. BOOL bGridVisible = pPaintManager->IsGridVisible(FALSE);
  544. CRect rcFocus(rcRow.left, rcRow.top, rcRow.right, rcRow.bottom - (bGridVisible ? 1 : 0));
  546. if (pRow->GetIndex() < wndReport.GetRows()->GetCount() - 1 && nIndentWidth > 0)
  547. {
  548. CXTPReportRow* pNextRow = wndReport.GetRows()->GetAt(pRow->GetIndex() + 1);
  549. ASSERT(pNextRow);
  550. if (pNextRow) rcFocus.left = rcRow.left +  min(nIndentWidth, pPaintManager->m_nTreeIndent * pNextRow->GetTreeDepth());
  551. }
  553. pPaintManager->DrawGrid(pDC, FALSE, rcFocus);
  554. }
  557. int CXTPReportView::PrintRows(CDC* pDC, CRect rcClient, long nIndexStart, int* pnPrintedRowsHeight)
  558. {
  559. int y = rcClient.top;
  560. CXTPReportRows* pRows = GetReportCtrl().GetRows();
  562. for (; nIndexStart < pRows->GetCount(); nIndexStart++)
  563. {
  564. CXTPReportRow* pRow = pRows->GetAt(nIndexStart);
  566. if (m_bPrintSelection && !pRow->IsSelected())
  567. {
  568. continue;
  569. }
  571. int nHeight = pRow->GetHeight(pDC, rcClient.Width());
  572. int nPreviewHeight = 0;
  574. if (pRow->IsPreviewVisible())
  575. {
  576. CXTPReportRecordItemPreview* pItem = pRow->GetRecord()->GetItemPreview();
  577. nPreviewHeight = pItem->GetPreviewHeight(pDC, pRow, rcClient.Width());
  578. nPreviewHeight = GetReportCtrl().GetPaintManager()->GetPreviewItemHeight(pDC, pRow, rcClient.Width(), nPreviewHeight);
  579. nHeight += nPreviewHeight;
  580. }
  582. CRect rcRow(rcClient.left, y, rcClient.right, y + nHeight);
  584. if (rcRow.bottom > rcClient.bottom)
  585. break;
  587. PrintRow(pDC, pRow, rcRow, nPreviewHeight);
  589. y += rcRow.Height();
  590. }
  592. if(pnPrintedRowsHeight != NULL)
  593. *pnPrintedRowsHeight = y - rcClient.top; // height of the printed rows
  595. return nIndexStart;
  596. }
  599. long CXTPReportView::PrintReport(CDC* pDC, CPrintInfo* /*pInfo*/, CRect rcPage, long nIndexStart)
  600. {
  601. int nHeaderHeight = 0;
  602. int nFooterHeight = 0;
  604. if (GetReportCtrl().IsHeaderVisible())
  605. nHeaderHeight = GetPaintManager()->GetHeaderHeight(&GetReportCtrl(), pDC, rcPage.Width()-2);
  607. if (GetReportCtrl().IsFooterVisible())
  608. nFooterHeight = GetPaintManager()->GetFooterHeight(&GetReportCtrl(), pDC, rcPage.Width()-2);
  610. CRect rcHeader(rcPage.left + 1, rcPage.top + 1, rcPage.right - 1, rcPage.top + 1 + nHeaderHeight);
  611. CRect rcFooter(rcPage.left + 1, rcPage.bottom - nFooterHeight - 1, rcPage.right - 1, rcPage.bottom - 1);
  613. if (nHeaderHeight)
  614. PrintHeader(pDC, rcHeader);
  616. CRect rcRows(rcHeader.left, rcHeader.bottom, rcHeader.right, rcFooter.top);
  618. // print header rows (if exist and visible)
  619. if (GetReportCtrl().GetHeaderRows()->GetCount() > 0 && GetReportCtrl().IsHeaderRowsVisible())
  620. {
  621. // print on the first page, at least
  622. if (0 == nIndexStart || m_pPrintOptions->m_bRepeatHeaderRows)
  623. {
  624.  rcRows.top += PrintFixedRows(pDC, rcRows, TRUE);
  626. // print divider
  627. rcRows.top += PrintFixedRowsDivider(pDC, rcRows, TRUE);
  628. }
  629. }
  631. // calculate space for footer rows
  632. int nNeedForFooterRows = 0;
  634. if (GetReportCtrl().GetFooterRows()->GetCount() > 0 && GetReportCtrl().IsFooterRowsVisible())
  635. {
  636. nNeedForFooterRows = GetReportCtrl().GetRowsHeight(GetReportCtrl().GetFooterRows(), rcRows.Width());
  637. nNeedForFooterRows += GetPaintManager()->GetFooterRowsDividerHeight();
  639. if (m_pPrintOptions->m_bRepeatFooterRows)
  640. {
  641. // decrease space for body rows, if footer rows to be repeated on every page.
  642. rcRows.bottom = rcFooter.top - nNeedForFooterRows;
  643. }
  644. }
  646. // print body rows
  647. int nPrintedBodyRowsHeight = 0;
  648. nIndexStart = PrintRows(pDC, rcRows, nIndexStart, &nPrintedBodyRowsHeight);
  650. // print footer rows (if exist and visible)
  651. if (nNeedForFooterRows > 0)
  652. {
  653. CRect rcFooterRows(rcRows);
  654. rcFooterRows.top = rcRows.top + nPrintedBodyRowsHeight; //immediately after body rows
  655. rcFooterRows.bottom = rcFooter.top;
  657. // one more check, if there is enough space for footer divider + footer rows
  658. if (rcFooterRows.Height() > nNeedForFooterRows)
  659. {
  660. // print divider
  661. rcFooterRows.top += PrintFixedRowsDivider(pDC, rcFooterRows, FALSE);
  663. // print footer rows
  664. PrintFixedRows(pDC, rcFooterRows, FALSE);
  665. }
  666. }
  668. if (nFooterHeight)
  669. PrintFooter(pDC, rcFooter);
  671. pDC->Draw3dRect(rcPage, 0, 0);
  673. return nIndexStart;
  674. }
  676. int CXTPReportView::PrintFixedRowsDivider(CDC* pDC, const CRect& rc, BOOL bHeaderRows)
  677. {
  678. CRect rcDiv(rc);
  680. // get divider's height
  681. int nHeight = bHeaderRows ? GetPaintManager()->GetHeaderRowsDividerHeight() : GetPaintManager()->GetFooterRowsDividerHeight();
  683. rcDiv.bottom = rcDiv.top + nHeight;
  685. GetPaintManager()->DrawFixedRowsDivider(pDC, rcDiv, &GetReportCtrl(), bHeaderRows, FALSE);
  687. return nHeight;
  688. }
  690. long CXTPReportView::PrintPage(CDC* pDC, CPrintInfo* pInfo, CRect rcPage, long nIndexStart)
  691. {
  692. if (!m_pPrintOptions || !pDC || !pInfo)
  693. {
  694. ASSERT(FALSE);
  695. return INT_MAX;
  696. }
  698. CRect rcPageHeader = rcPage;
  699. CRect rcPageFooter = rcPage;
  701. CString strTitle = CXTPPrintPageHeaderFooter::GetParentFrameTitle(this);
  703. m_pPrintOptions->GetPageHeader()->FormatTexts(pInfo, strTitle);
  704. m_pPrintOptions->GetPageFooter()->FormatTexts(pInfo, strTitle);
  706. pDC->SetBkColor(RGB(255, 255, 255));
  707. m_pPrintOptions->GetPageFooter()->Draw(pDC, rcPageFooter, TRUE);
  708. m_pPrintOptions->GetPageHeader()->Draw(pDC, rcPageHeader);
  710. CRect rcReport = rcPage;
  712. rcReport.top += rcPageHeader.Height() + 2;
  713. rcReport.bottom -= rcPageFooter.Height() + 2;
  715. long nNextRow = PrintReport(pDC, pInfo, rcReport, nIndexStart);
  717. pDC->SetBkColor(RGB(255, 255, 255));
  718. m_pPrintOptions->GetPageFooter()->Draw(pDC, rcPageFooter);
  720. return nNextRow;
  721. }
  723. void CXTPReportView::OnPrint(CDC* pDC, CPrintInfo* pInfo)
  724. {
  725. if (!m_pPrintOptions || !pDC || !pInfo)
  726. {
  727. ASSERT(FALSE);
  728. return;
  729. }
  731. CRect rcMargins = m_pPrintOptions->GetMarginsLP(pDC);
  732. CRect rcPrint = pInfo->m_rectDraw;
  733. rcPrint.NormalizeRect();
  734. rcPrint.DeflateRect(rcMargins);
  736. //----------------------------------------------------------
  737. if (!m_pPrintOptions->m_bBlackWhitePrinting)
  738. {
  739. _OnPrint2(pDC, pInfo, rcPrint);
  740. }
  741. else
  742. {
  743. CRect rcPrint00(0, 0, rcPrint.Width(), rcPrint.Height());
  745. CDC memDC;
  746. VERIFY(memDC.CreateCompatibleDC(pDC));
  747. memDC.m_bPrinting = TRUE;
  749. if (!m_bmpGrayDC.m_hObject || m_bmpGrayDC.GetBitmapDimension() != rcPrint00.Size())
  750. {
  751. m_bmpGrayDC.DeleteObject();
  752. m_bmpGrayDC.CreateCompatibleBitmap(pDC, rcPrint00.Width(), rcPrint00.Height());
  753. }
  755. CXTPBitmapDC autpBmp(&memDC, &m_bmpGrayDC);
  757. //----------------------------------------------------
  758. memDC.FillSolidRect(rcPrint00, RGB(255, 255, 255));
  760. _OnPrint2(&memDC, pInfo, rcPrint00);
  762. int nCC = max(0, min(m_pPrintOptions->m_nBlackWhiteContrast, 255));
  763. XTPImageManager()->BlackWhiteBitmap(memDC, rcPrint00, nCC);
  765. pDC->BitBlt(rcPrint.left, rcPrint.top, rcPrint.Width(), rcPrint.Height(),
  766. &memDC, 0, 0, SRCCOPY);
  767. }
  768. }
  770. void CXTPReportView::_OnPrint2(CDC* pDC, CPrintInfo* pInfo, CRect rcPrint)
  771. {
  772. if (!m_pPrintOptions || !pDC || !pInfo)
  773. {
  774. ASSERT(FALSE);
  775. return;
  776. }
  778. UINT nPage = pInfo->m_nCurPage;
  779. ASSERT(nPage <= (UINT)m_aPageStart.GetSize());
  780. UINT nIndex = m_aPageStart[nPage-1];
  782. // print as much as possible in the current page.
  783. nIndex = PrintPage(pDC, pInfo, rcPrint, nIndex);
  785. // update pagination information for page just printed
  786. if (nPage == (UINT)m_aPageStart.GetSize())
  787. {
  788. m_aPageStart.Add(nIndex);
  789. }
  790. else
  791. {
  792. ASSERT(nPage < (UINT)m_aPageStart.GetSize());
  793. m_aPageStart[nPage] = nIndex;
  794. }
  795. }
  797. extern BOOL CALLBACK _XTPAbortProc(HDC, int);
  799. BOOL CXTPReportView::PaginateTo(CDC* pDC, CPrintInfo* pInfo)
  800. // attempts pagination to pInfo->m_nCurPage, TRUE == success
  801. {
  802. ASSERT_VALID(this);
  803. ASSERT_VALID(pDC);
  805. BOOL bAborted = FALSE;
  806. CXTPPrintingDialog dlgPrintStatus(this);
  807. CString strTemp;
  808. if (GetParentFrame())
  809. GetParentFrame()->GetWindowText(strTemp);
  811. dlgPrintStatus.SetWindowText(_T("Calculating pages..."));
  813. dlgPrintStatus.SetDlgItemText(AFX_IDC_PRINT_DOCNAME, strTemp);
  814. dlgPrintStatus.SetDlgItemText(AFX_IDC_PRINT_PRINTERNAME, pInfo->m_pPD->GetDeviceName());
  815. dlgPrintStatus.SetDlgItemText(AFX_IDC_PRINT_PORTNAME, pInfo->m_pPD->GetPortName());
  816. dlgPrintStatus.ShowWindow(SW_SHOW);
  817. dlgPrintStatus.UpdateWindow();
  819. CRect rectSave = pInfo->m_rectDraw;
  820. UINT nPageSave = pInfo->m_nCurPage;
  821. BOOL bBlackWhiteSaved = m_pPrintOptions->m_bBlackWhitePrinting;
  822. m_pPrintOptions->m_bBlackWhitePrinting = FALSE;
  824. ASSERT(nPageSave > 1);
  825. ASSERT(nPageSave >= (UINT)m_aPageStart.GetSize());
  826. VERIFY(pDC->SaveDC() != 0);
  828. pDC->IntersectClipRect(0, 0, 0, 0);
  829. pInfo->m_nCurPage = (UINT)m_aPageStart.GetSize();
  830. while (pInfo->m_nCurPage < nPageSave)
  831. {
  832. ASSERT(pInfo->m_nCurPage == (UINT)m_aPageStart.GetSize());
  833. OnPrepareDC(pDC, pInfo);
  834. if (!pInfo->m_bContinuePrinting)
  835. break;
  837. strTemp.Format(_T("%d"), pInfo->m_nCurPage);
  838. dlgPrintStatus.SetDlgItemText(AFX_IDC_PRINT_PAGENUM, strTemp);
  840. pInfo->m_rectDraw.SetRect(0, 0, pDC->GetDeviceCaps(HORZRES), pDC->GetDeviceCaps(VERTRES));
  841. pDC->DPtoLP(&pInfo->m_rectDraw);
  842. OnPrint(pDC, pInfo);
  843. //if (pInfo->m_nCurPage == (UINT)m_aPageStart.GetSize())
  844. //  break;
  845. ++pInfo->m_nCurPage;
  847. if(!_XTPAbortProc(0, 0))
  848. {
  849. bAborted = TRUE;
  850. break;
  851. }
  852. }
  853. dlgPrintStatus.DestroyWindow();
  855. BOOL bResult = !bAborted && (pInfo->m_nCurPage == nPageSave || nPageSave == 65535);
  857. pInfo->m_bContinuePrinting = bResult;
  859. pDC->RestoreDC(-1);
  860. m_pPrintOptions->m_bBlackWhitePrinting = bBlackWhiteSaved;
  861. pInfo->m_nCurPage = nPageSave;
  862. pInfo->m_rectDraw = rectSave;
  863. ASSERT_VALID(this);
  865. return bResult;
  866. }
  868. void CXTPReportView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
  869. {
  870. ASSERT_VALID(this);
  871. ASSERT_VALID(pDC);
  872. ASSERT(pInfo != NULL);  // overriding OnPaint -- never get this.
  873. if (!pInfo)
  874. return;
  876. if (pInfo->m_nCurPage == 1 && GetReportCtrl().GetRows()->GetCount() == 0)
  877. {
  878. pInfo->m_bContinuePrinting = TRUE;
  879. }
  880. else if (pInfo->m_nCurPage == (UINT)m_aPageStart.GetSize() &&
  881. m_aPageStart[pInfo->m_nCurPage - 1] >= (UINT)GetReportCtrl().GetRows()->GetCount())
  882. {
  883. // can't paginate to that page, thus cannot print it.
  884. pInfo->m_bContinuePrinting = FALSE;
  885. }
  886. else if (pInfo->m_nCurPage > (UINT)m_aPageStart.GetSize() &&
  887. !PaginateTo(pDC, pInfo))
  888. {
  889. // can't paginate to that page, thus cannot print it.
  890. pInfo->m_bContinuePrinting = FALSE;
  891. }
  892. pDC->SetMapMode(MM_ANISOTROPIC);
  894. pDC->SetViewportExt(pDC->GetDeviceCaps(LOGPIXELSX),
  895. pDC->GetDeviceCaps(LOGPIXELSY));
  897. pDC->SetWindowExt(100, 100);
  899. // ptOrg is in logical coordinates
  900. pDC->OffsetWindowOrg(0, 0);
  902. if (GetReportCtrl().GetExStyle() & WS_EX_RTLREADING)
  903. {
  904. pDC->SetTextAlign(TA_RTLREADING);
  905. }
  907. if(GetReportCtrl().IsLayoutRTL())
  908. XTPDrawHelpers()->SetContextRTL(pDC, LAYOUT_RTL);
  909. }
  911. //////////////////////////////////////////////////////////////////////////
  912. // Clipboard operations
  914. void CXTPReportView::OnUpdateEditCopy(CCmdUI* pCmdUI)
  915. {
  916. pCmdUI->Enable(GetReportCtrl().CanCopy());
  917. }
  919. void CXTPReportView::OnUpdateEditCut(CCmdUI* pCmdUI)
  920. {
  921. pCmdUI->Enable(m_bAllowCut && GetReportCtrl().CanCut());
  922. }
  924. void CXTPReportView::OnUpdateEditPaste(CCmdUI* pCmdUI)
  925. {
  926. pCmdUI->Enable(m_bAllowPaste && GetReportCtrl().CanPaste());
  927. }
  929. void CXTPReportView::OnEditCut()
  930. {
  931. if (m_bAllowCut) GetReportCtrl().Cut();
  932. }
  934. void CXTPReportView::OnEditCopy()
  935. {
  936. GetReportCtrl().Copy();
  937. }
  939. void CXTPReportView::OnEditPaste()
  940. {
  941. if (m_bAllowPaste) GetReportCtrl().Paste();
  942. }
  944. void CXTPReportView::OnFilePageSetup()
  945. {
  946. DWORD dwFlags = PSD_MARGINS | PSD_INWININIINTLMEASURE;
  947. CXTPReportPageSetupDialog dlgPageSetup(GetPrintOptions(), dwFlags, this);
  949. XTPGetPrinterDeviceDefaults(dlgPageSetup.m_psd.hDevMode, dlgPageSetup.m_psd.hDevNames);
  951. int nDlgRes = (int)dlgPageSetup.DoModal();
  953. if (nDlgRes == IDOK)
  954. {
  955. AfxGetApp()->SelectPrinter(dlgPageSetup.m_psd.hDevNames, dlgPageSetup.m_psd.hDevMode, FALSE);
  956. }
  957. }
  959. int CXTPReportView::PrintFixedRows(CDC* pDC, CRect rcClient, BOOL bHeaderRows)
  960. {
  961. int y = rcClient.top;
  963. CXTPReportRows* pRows = bHeaderRows ? GetReportCtrl().GetHeaderRows() : GetReportCtrl().GetFooterRows();
  965. for (int i = 0; i < pRows->GetCount(); ++i)
  966. {
  967. CXTPReportRow* pRow = pRows->GetAt(i);
  969. int nHeight = pRow->GetHeight(pDC, rcClient.Width());
  971. CRect rcRow(rcClient.left, y, rcClient.right, y + nHeight);
  973. if (rcRow.bottom > rcClient.bottom)
  974. break;
  976. PrintRow(pDC, pRow, rcRow, 0);
  978. y += rcRow.Height();
  979. }
  981. return y - rcClient.top; // height of all printed rows
  982. }
  984. /////////////////////////////////////////////////////////////////////////////
  985. //class CXTPReportViewPrintOptions
  987. IMPLEMENT_DYNAMIC(CXTPReportViewPrintOptions, CXTPPrintOptions)
  988. CXTPReportViewPrintOptions::CXTPReportViewPrintOptions()
  989. {
  990. m_bRepeatHeaderRows = FALSE;
  991. m_bRepeatFooterRows = FALSE;
  993. }
  995. LCID CXTPReportViewPrintOptions::GetActiveLCID()
  996. {
  997. return CXTPReportControlLocale::GetActiveLCID();
  998. }
  1000. void CXTPReportViewPrintOptions::Set(const CXTPReportViewPrintOptions* pSrc)
  1001. {
  1002. if (pSrc)
  1003. {
  1004. CXTPPrintOptions::Set(pSrc);
  1006. m_bRepeatHeaderRows = pSrc->m_bRepeatHeaderRows;
  1007. m_bRepeatFooterRows = pSrc->m_bRepeatFooterRows;
  1008. }
  1009. }