怎么打印ListCtrl(Report view风格)。(包括表格和item)

[wangbab]

RT

[wangbab]

那样太麻烦了，有什么简便的方法吗？

[wangbab]

有谁知道吗？

[DalyQiao]

不要偷懒了，应该是没办法的，你得自己写

[stonexl]

好象得自己使用MoveTo,LineTo,DrawText等函数一个个的写吧。

[wuxfBrave]

// PrintObj.h: interface for the CPrintObj class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_PRINTOBJ_H__1CC0C53B_59B6_4CEA_B7BB_99F2F1D41A2E__INCLUDED_)
#define AFX_PRINTOBJ_H__1CC0C53B_59B6_4CEA_B7BB_99F2F1D41A2E__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CPrintObj
{
public:
CPrintObj();
virtual ~CPrintObj();

public:
void OnPrepareDC(CDC *pDC, CPrintInfo *pInfo);
CWnd *m_pParent;
CString m_strTitle;
bool m_bAlreadyAskedPageOpt;

bool DoPreparePrinting(CPrintInfo *pInfo);
virtual void OnFilePrint();
virtual void OnPrint(CDC *pDC, CPrintInfo *pInfo);
virtual void OnEndPrinting(CDC *pDC, CPrintInfo *pInfo);
virtual void OnBeginPrinting(CDC *pDC, CPrintInfo *pInfo);
virtual bool OnPreparePrinting(CPrintInfo *pInfo, bool bPrintPreview = false);
};

#endif // !defined(AFX_PRINTOBJ_H__1CC0C53B_59B6_4CEA_B7BB_99F2F1D41A2E__INCLUDED_)

[wuxfBrave]

还是给个信箱我给你发完整的代码吧

[zhuobattle]

如果可以也给我发一个吧,谢谢!
[e-mail]

[geolin]

谢谢，借楼主宝地了 [e-mail]

[wuxfBrave]

#include "stdafx.h"
#include "mdclient.h"
#include "PrintObj.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

bool bGfxUserAbort = false;

BOOL CALLBACK EXPORT _GfxAbortProc(HDC, int)
{
MSG msg;
while (!bGfxUserAbort && ::PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE))
{
if (!AfxGetThread()->PumpMessage())
return FALSE;
}

return !bGfxUserAbort;
}

CPrintObj::CPrintObj()
{
m_pParent = NULL;
m_strTitle.Empty();
m_bAlreadyAskedPageOpt = false;
}

CPrintObj::~CPrintObj()
{

}

bool CPrintObj::OnPreparePrinting(CPrintInfo *pInfo, bool bPrintPreview)
{
if (bPrintPreview)
return true;

return DoPreparePrinting(pInfo);
}

void CPrintObj::OnBeginPrinting(CDC *pDC, CPrintInfo *pInfo)
{

}

void CPrintObj::OnEndPrinting(CDC *pDC, CPrintInfo *pInfo)
{

}

void CPrintObj::OnPrint(CDC *pDC, CPrintInfo *pInfo)
{

}

bool CPrintObj::DoPreparePrinting(CPrintInfo *pInfo)
{
ASSERT(pInfo != NULL);
ASSERT(pInfo->m_pPD != NULL);

if (pInfo->m_pPD->m_pd.nMinPage > pInfo->m_pPD->m_pd.nMaxPage)
pInfo->m_pPD->m_pd.nMaxPage = pInfo->m_pPD->m_pd.nMinPage;

pInfo->m_pPD->m_pd.nFromPage = (WORD)pInfo->GetMinPage();

pInfo->m_pPD->m_pd.nToPage = (WORD)pInfo->GetMaxPage();

if (AfxGetApp()->DoPrintDialog(pInfo->m_pPD) != IDOK)
return FALSE;

ASSERT(pInfo->m_pPD != NULL);
ASSERT(pInfo->m_pPD->m_pd.hDC != NULL);

if (pInfo->m_pPD->m_pd.hDC == NULL)
return FALSE;

pInfo->m_nNumPreviewPages = AfxGetApp()->m_nNumPreviewPages;

VERIFY(pInfo->m_strPageDesc.LoadString(AFX_IDS_PREVIEWPAGEDESC));

return TRUE;
}
void CPrintObj::OnPrepareDC(CDC * pDC, CPrintInfo * pInfo)
{
ASSERT_VALID(pDC);
UNUSED(pDC); // unused in release builds

// Default to one page printing if doc length not known
if (pInfo != NULL)
pInfo->m_bContinuePrinting =
(pInfo->GetMaxPage() != 0xffff || (pInfo->m_nCurPage == 1));
}

[wuxfBrave]

void CPrintObj::OnFilePrint()
{
CPrintInfo printInfo;
ASSERT(printInfo.m_pPD != NULL); // must be set

if (OnPreparePrinting(&printInfo))
{
// hDC must be set (did you remember to call DoPreparePrinting?)
ASSERT(printInfo.m_pPD->m_pd.hDC != NULL);

// gather file to print to if print-to-file selected
CString strOutput;
if (printInfo.m_pPD->m_pd.Flags & PD_PRINTTOFILE)
{
// construct CFileDialog for browsing
CString strDef(MAKEINTRESOURCE(AFX_IDS_PRINTDEFAULTEXT));
CString strPrintDef(MAKEINTRESOURCE(AFX_IDS_PRINTDEFAULT));
CString strFilter(MAKEINTRESOURCE(AFX_IDS_PRINTFILTER));
CString strCaption(MAKEINTRESOURCE(AFX_IDS_PRINTCAPTION));
CFileDialog dlg(FALSE, strDef, strPrintDef, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, strFilter);
dlg.m_ofn.lpstrTitle = strCaption;
if (dlg.DoModal() != IDOK)
return;
// set output device to resulting path name
strOutput = dlg.GetPathName();
}

DOCINFO docInfo;
memset(&docInfo, 0, sizeof(DOCINFO));
docInfo.cbSize = sizeof(DOCINFO);
docInfo.lpszDocName = m_strTitle;
CString strPortName;
int nFormatID;
if (strOutput.IsEmpty())
{
docInfo.lpszOutput = NULL;
strPortName = printInfo.m_pPD->GetPortName();
nFormatID = AFX_IDS_PRINTONPORT;
}
else
{
docInfo.lpszOutput = strOutput;
nFormatID = AFX_IDS_PRINTTOFILE;
}

// setup the printing DC
CDC dcPrint;
dcPrint.Attach(printInfo.m_pPD->m_pd.hDC); // attach printer dc
dcPrint.m_bPrinting = TRUE;
printInfo.m_rectDraw.SetRect(0, 0, dcPrint.GetDeviceCaps(HORZRES), dcPrint.GetDeviceCaps(VERTRES));
dcPrint.DPtoLP(&printInfo.m_rectDraw);

OnBeginPrinting(&dcPrint, &printInfo);
dcPrint.SetAbortProc(_GfxAbortProc);

// disable main window while printing & init printing status dialog
CString csFormat, cs, strTemp;
AfxGetMainWnd()->EnableWindow(FALSE);
// CPrintStatus dlgPrintStatus(pParent);
// cs.Format("Stampa di %s in corso ..", strTitle);
// dlgPrintStatus.SetWindowText(cs);

// dlgPrintStatus.GetDlgItemText(IDC_TEXT1, csFormat);
// AfxFormatString1(strTemp, nFormatID, strPortName);
// cs.Format(csFormat, strTitle, printInfo.m_pPD->GetDeviceName(), strTemp);
// dlgPrintStatus.SetDlgItemText(IDC_TEXT1, cs);

// dlgPrintStatus.ShowWindow(SW_SHOW);
// dlgPrintStatus.UpdateWindow();

// start document printing process
if (dcPrint.StartDoc(&docInfo) == SP_ERROR)
{
// enable main window before proceeding
AfxGetMainWnd()->EnableWindow(TRUE);

// cleanup and show error message
OnEndPrinting(&dcPrint, &printInfo);
// dlgPrintStatus.DestroyWindow();
dcPrint.Detach(); // will be cleaned up by CPrintInfo destructor
AfxMessageBox(AFX_IDP_FAILED_TO_START_PRINT);
return;
}

// Guarantee values are in the valid range
UINT nEndPage = printInfo.GetToPage();
UINT nStartPage = printInfo.GetFromPage();

if (nEndPage < printInfo.GetMinPage()) nEndPage = printInfo.GetMinPage();
if (nEndPage > printInfo.GetMaxPage()) nEndPage = printInfo.GetMaxPage();
if (nStartPage < printInfo.GetMinPage()) nStartPage = printInfo.GetMinPage();
if (nStartPage > printInfo.GetMaxPage()) nStartPage = printInfo.GetMaxPage();
int nStep = (nEndPage >= nStartPage) ? 1 : -1;
nEndPage = (nEndPage == 0xffff) ? 0xffff : nEndPage + nStep;
int iPageTot = abs(abs(nEndPage) - abs(nStartPage)), iPrintedPages = 0;
// CString csPageFormat;
// dlgPrintStatus.GetDlgItemText(IDC_PAGES, csPageFormat);

// begin page printing loop
DWORD dwStart = GetTickCount(), dTickPerPage = 0;

// dlgPrintStatus.wndProg.SetRange(0, iPageTot);
// dlgPrintStatus.wndProg.SetPos(0);

bool bRectSet = false;
BOOL bError = FALSE;
for (printInfo.m_nCurPage = nStartPage; printInfo.m_nCurPage != nEndPage; printInfo.m_nCurPage += nStep)
{
// TCHAR szBuf[80];

iPrintedPages ++;
// dlgPrintStatus.wndProg.SetPos(iPrintedPages);
// dlgPrintStatus.wndProg.UpdateWindow();

// wsprintf(szBuf, "%d %%", iPrintedPages*100/iPageTot);
// dlgPrintStatus.SetDlgItemText(IDC_PC, szBuf);

OnPrepareDC(&dcPrint, &printInfo);

// check for end of print
if (!printInfo.m_bContinuePrinting) break;
// write current page

DWORD tck = dTickPerPage * (iPageTot - iPrintedPages + 1) / 1000;
if (tck > 60)
{
tck = 60;
DWORD tckS = tck%60;
tck /= 60;
strTemp.Format("%d minuti, %d secondi", tck, tckS);
}
else
{
if (iPageTot > 1)
{
if (tck > 0) strTemp.Format("%d secondi", tck);
else strTemp = "??";
}
}

// wsprintf(szBuf, csPageFormat, iPrintedPages, iPageTot, strTemp);
// dlgPrintStatus.SetDlgItemText(IDC_PAGES, szBuf);

printInfo.m_rectDraw.SetRect(0, 0, dcPrint.GetDeviceCaps(HORZRES), dcPrint.GetDeviceCaps(VERTRES));
dcPrint.DPtoLP(&printInfo.m_rectDraw);

// attempt to start the current page
if (dcPrint.StartPage() < 0)
{
bError = TRUE;
break;
}

OnPrepareDC(&dcPrint, &printInfo);
ASSERT(printInfo.m_bContinuePrinting);
// page successfully started, so now render the page
int is = dcPrint.SaveDC();
OnPrint(&dcPrint, &printInfo);
if (dcPrint.EndPage() < 0 || !_GfxAbortProc(dcPrint.m_hDC, 0))
{
bError = TRUE;
break;
}
dcPrint.RestoreDC(is);

dTickPerPage = (GetTickCount() - dwStart) / iPrintedPages;
}

// cleanup document printing process
if (!bError)
dcPrint.EndDoc();
else
dcPrint.AbortDoc();

AfxGetMainWnd()->EnableWindow(); // enable main window
OnEndPrinting(&dcPrint, &printInfo); // clean up after printing
// dlgPrintStatus.DestroyWindow();
dcPrint.Detach(); // will be cleaned up by CPrintInfo destructor
}
}

[wuxfBrave]

// ListCtrlPrint.h: interface for the CListCtrlPrint class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_LISTCTRLPRINT_H__2377F1E5_7770_450D_BCA2_BCDDA1B88093__INCLUDED_)
#define AFX_LISTCTRLPRINT_H__2377F1E5_7770_450D_BCA2_BCDDA1B88093__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "PrintObj.h"

class CListCtrlPrint : public CPrintObj
{
public:
CListCtrlPrint();
virtual ~CListCtrlPrint();

CRect m_rcMarginMM; // contain the margins in millimeters
CFont m_ftPrint, m_ftHead, m_ftFoot; // fonts used for printing
CSize m_szFtPrint, m_szFtHead, m_szFtFoot; // sizes of fonts (in device unit)
int *m_pDx, *m_pFormat; // datas about column size and format (center, right ..)
char **m_pColTitle; // columns titles
int m_iItemXPage, m_iNumCol, m_iTotItem; // number of item in page, of columns and of tot number of items in list control
CListCtrl *m_pList; // pointer of the list ctrl
CString m_csPageHead; // text of header
CString m_csPageFooter; // text of footer
CString m_csPage; // format of page number / tot pages (ex. page %d of %d)

CString m_csFtHead, m_csFtFoot, m_csFtPrint; // fonts type names
int m_iFtHead, m_iFtFoot, m_iFtPrint; // fonts sizes

CSize m_szFoot; // internal use

// this subtracts the margins from the page size
void SubtractMargin(CDC *pDC, CRect &rc);

// virtual overridden from base class; same meaning of CView's one
void OnBeginPrinting(CDC *pDC, CPrintInfo *pInfo);
void OnEndPrinting(CDC *pDC, CPrintInfo *pInfo);
bool OnPreparePrinting(CPrintInfo *pInfo, bool bPrintPreview = false);
void OnPrint(CDC* pDC, CPrintInfo *pInfo);

// function self explicative; the items will be printed in the OnPrint function
// if bCalc is true, the function is called to compute the space for items and so
// no printing is needed, but only to return the size used and to subtract from the
// rcpage the space used
CSize PrintListFoot(CDC *pDC, CRect &rcPage, bool bCalc);
CSize PrintListHead(CDC *pDC, CRect &rcPage, bool bCalc);
CSize PrintPageFoot(CDC *pDC, CRect &rcPage, bool bCalc);
CSize PrintPageHead(CDC *pDC, CRect &rcPage, const int nPage, const int iMaxPage, bool bCalc);
};

#endif // !defined(AFX_LISTCTRLPRINT_H__2377F1E5_7770_450D_BCA2_BCDDA1B88093__INCLUDED_)

[wuxfBrave]

// ListCtrlPrint.cpp: implementation of the CListCtrlPrint class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "mdclient.h"
#include "ListCtrlPrint.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CListCtrlPrint::CListCtrlPrint()
{
m_rcMarginMM = CRect(10,10,10,10);
m_szFtPrint = m_szFtHead = m_szFtFoot = CSize(0,0);
m_pDx = NULL;
m_iItemXPage = 1;
m_iNumCol = 0;
m_pList = NULL;
m_szFoot = CSize(0,0);
m_pFormat = NULL;
m_pColTitle = NULL;
m_iTotItem = 0;

m_csFtHead = "Arial";
m_csFtFoot = "Times New Roman";
m_csFtPrint = "Arial";
m_iFtHead = 12;
m_iFtFoot = 6;
m_iFtPrint = 8;
}

CListCtrlPrint::~CListCtrlPrint()
{
if (m_iNumCol)
{
if (m_pDx)
delete[] m_pDx;
if (m_pFormat)
delete[] m_pFormat;

if (m_pColTitle)
{
for (int t = 0; t < m_iNumCol; t++)
if (m_pColTitle[t])
delete[] m_pColTitle[t];

delete[] m_pColTitle;
}
}
}

bool CListCtrlPrint::OnPreparePrinting(CPrintInfo *pInfo, bool bPrintPreview)
{
pInfo->SetMinPage(1);
if (!m_pList)
return false;
m_iTotItem = m_pList->GetItemCount();

if (m_iTotItem <= 0)
return false;

ASSERT(m_pDx == NULL);

CHeaderCtrl *pHeader = (CHeaderCtrl *)(m_pList->GetDlgItem(0));
ASSERT(pHeader);
m_iNumCol = pHeader->GetItemCount();
if (m_iNumCol <= 0)
return false;
m_pDx = new int[m_iNumCol+1];
m_pFormat = new int[m_iNumCol];
m_pColTitle = new char *[m_iNumCol];
ZeroMemory(m_pColTitle, sizeof(char *) * m_iNumCol);
ZeroMemory(m_pDx, sizeof(int) * (m_iNumCol + 1));
ZeroMemory(m_pFormat, sizeof(int) * m_iNumCol);
char txt[128];
for (int t = 0; t < m_iNumCol; t++)
{
HDITEM hi;
hi.cchTextMax = 128;
hi.pszText = txt;

hi.mask = HDI_TEXT|HDI_WIDTH|HDI_FORMAT;
if (pHeader->GetItem(t, &hi))
{
m_pDx[t+1] = hi.cxy;
m_pFormat[t] = hi.fmt;
if (hi.cchTextMax > 0 && hi.pszText)
{
m_pColTitle[t] = new char[hi.cchTextMax];
ASSERT(m_pColTitle[t]);
lstrcpy(m_pColTitle[t], hi.pszText);
}
}
}

// CListPrintSetup dlg;

/* dlg.dlgSheet2.iSx = m_rcMarginMM.left;
dlg.dlgSheet2.iUp = m_rcMarginMM.top;
dlg.dlgSheet2.iDx = m_rcMarginMM.right;
dlg.dlgSheet2.iDown = m_rcMarginMM.bottom;
dlg.dlgSheet1.csFtHead = m_csFtHead;
dlg.dlgSheet1.csFtFoot = m_csFtFoot;
dlg.dlgSheet1.csFtPrint = m_csFtPrint;
dlg.dlgSheet1.iFtHead = m_iFtHead;
dlg.dlgSheet1.iFtFoot = m_iFtFoot;
dlg.dlgSheet1.iFtPrint = m_iFtPrint;
dlg.dlgSheet1.csHead = m_csPageHead;
dlg.dlgSheet1.csFooter = m_csPageFooter;
dlg.dlgSheet1.csPage = m_csPage;

if (dlg.DoModal() == IDCANCEL)
return false;

m_rcMarginMM = CRect(dlg.dlgSheet2.iSx, dlg.dlgSheet2.iUp, dlg.dlgSheet2.iDx, dlg.dlgSheet2.iDown);

m_csFtHead = dlg.dlgSheet1.csFtHead;
m_csFtFoot = dlg.dlgSheet1.csFtFoot;
m_csFtPrint = dlg.dlgSheet1.csFtPrint;
m_iFtHead = dlg.dlgSheet1.iFtHead;
m_iFtFoot = dlg.dlgSheet1.iFtFoot;
m_iFtPrint = dlg.dlgSheet1.iFtPrint;

m_csPageHead = dlg.dlgSheet1.csHead;
m_csPageFooter = dlg.dlgSheet1.csFooter;
m_csPage = dlg.dlgSheet1.csPage;*/

return CPrintObj::OnPreparePrinting(pInfo, bPrintPreview);
}

void CListCtrlPrint::OnBeginPrinting(CDC *pDC, CPrintInfo *pInfo)
{
m_ftPrint.CreatePointFont(m_iFtPrint*10, m_csFtPrint, pDC);
m_ftHead.CreatePointFont(m_iFtHead*10, m_csFtHead, pDC);
m_ftFoot.CreatePointFont(m_iFtFoot*10, m_csFtFoot, pDC);;
CString cs = "X";
CFont * of = pDC->SelectObject(&m_ftPrint);
m_szFtPrint = pDC->GetTextExtent(cs);
pDC->SelectObject(&m_ftHead);
m_szFtHead = pDC->GetTextExtent(cs);
pDC->SelectObject(&m_ftFoot);
m_szFtFoot = pDC->GetTextExtent(cs);
pDC->SelectObject(of);

m_szFtPrint.cy += 4;
m_szFtHead.cy += 4;

for (int t = 1; t <= m_iNumCol; t++)
m_pDx[t] += m_pDx[t-1];

CRect rcPrint(pInfo->m_rectDraw);
SubtractMargin(pDC, rcPrint);
double db = rcPrint.Width();
db /= (double) m_pDx[m_iNumCol];
for (t = 0; t <= m_iNumCol; t++)
m_pDx[t] = (int)double(m_pDx[t] * db);
ASSERT(m_pList);

PrintListHead(pDC, rcPrint, true);
PrintPageHead(pDC, rcPrint, 0, 0, true);

CSize sz1 = PrintListFoot(pDC, rcPrint, true);
CSize sz2 = PrintPageFoot(pDC, rcPrint, true);
m_szFoot.cy = sz1.cy+sz2.cy + 2;

m_iItemXPage = rcPrint.Height() / (m_szFtPrint.cy + 1) -1;
int nPages = m_iTotItem / m_iItemXPage + 1;
pInfo->SetMaxPage(nPages);
}

void CListCtrlPrint::OnEndPrinting(CDC *pDC, CPrintInfo *pInfo)
{

}

void CListCtrlPrint::SubtractMargin(CDC *pDC, CRect &rc)
{
CSize upsz(m_rcMarginMM.left*100, m_rcMarginMM.top*100);
CSize dwsz(m_rcMarginMM.right*100, m_rcMarginMM.bottom*100);
pDC->HIMETRICtoDP(&upsz);
pDC->HIMETRICtoDP(&dwsz);
rc.top += upsz.cy;
rc.left += upsz.cx;
rc.right -= dwsz.cx;
rc.bottom -= dwsz.cy;
}

[wuxfBrave]

void CListCtrlPrint::OnPrint(CDC *pDC, CPrintInfo *pInfo)
{
CRect rcPrint(pInfo->m_rectDraw);

SubtractMargin(pDC, rcPrint);
int obkm = pDC->SetBkMode(TRANSPARENT);

PrintPageHead(pDC, rcPrint, pInfo->m_nCurPage, (int)pInfo->GetMaxPage(), false);
PrintListHead(pDC, rcPrint, false);

int iFirst = (pInfo->m_nCurPage - 1) * m_iItemXPage;
int iLast = (pInfo->m_nCurPage) * m_iItemXPage;

int y = rcPrint.top;
int x = rcPrint.left;

CFont * oft = pDC->SelectObject(&m_ftPrint);
CRect rc1;
CString cs;
int iMax = m_iTotItem;

for (int i = iFirst; i < iLast; i++)
{
bool bIs = i < iMax;

int box = 0;
for (int t = 0; t < m_iNumCol; t++)
{
rc1.SetRect(rcPrint.left+m_pDx[t], y, rcPrint.left+m_pDx[t+1], y+m_szFtPrint.cy);
if (bIs)
{
cs = m_pList->GetItemText(i, t);
UINT ftm = DT_LEFT;
if (m_pFormat[t]&HDF_CENTER)
ftm = DT_CENTER;
else if (m_pFormat[t]&HDF_RIGHT)
ftm = DT_RIGHT;

pDC->DrawText(cs, rc1, ftm|DT_VCENTER);
}
pDC->MoveTo(rc1.left,rc1.bottom);
pDC->LineTo(rc1.left,rc1.top);
pDC->LineTo(rc1.right,rc1.top);
}
pDC->LineTo(rc1.right,rc1.bottom);
y += m_szFtPrint.cy + 1;
}

pDC->MoveTo(rcPrint.left,y);
pDC->LineTo(rcPrint.right,y);
pDC->SelectObject(oft);

rcPrint = pInfo->m_rectDraw;
SubtractMargin(pDC, rcPrint);
rcPrint.top = rcPrint.bottom - m_szFoot.cy;

PrintListFoot(pDC, rcPrint, false);
PrintPageFoot(pDC, rcPrint, false);

pDC->SetBkMode(obkm);
}

CSize CListCtrlPrint::PrintPageHead(CDC *pDC, CRect &rcPage, const int nPage, const int iMaxPage, bool bCalc)
{
CFont *oft = pDC->SelectObject(&m_ftHead);
int y = rcPage.top;
int x = rcPage.left;
CSize szPg(0,0);
if (m_csPage != "")
{
CString cs;
cs.Format(m_csPage, nPage, iMaxPage);
CRect rc1(x,y,rcPage.right,y);
pDC->DrawText(cs, rc1, DT_WORDBREAK|DT_CALCRECT|DT_RIGHT);
rc1.left = rcPage.right - rc1.Width();
rc1.right = rcPage.right;
if (!bCalc)
pDC->DrawText(cs, rc1, DT_WORDBREAK|DT_RIGHT);
szPg = rc1.Size();
}

if (m_csPageHead != "")
{
CRect rc1(x,y,rcPage.right - szPg.cy,y);
pDC->DrawText(m_csPageHead, rc1, DT_WORDBREAK|DT_CALCRECT|DT_LEFT);
if (!bCalc)
pDC->DrawText(m_csPageHead, rc1, DT_WORDBREAK|DT_LEFT);
if (rc1.Height() > szPg.cy)
szPg.cy = rc1.Height();
}

rcPage.top += szPg.cy;
pDC->SelectObject(oft);
return szPg;
}

CSize CListCtrlPrint::PrintPageFoot(CDC *pDC, CRect &rcPage, bool bCalc)
{
CFont *oft = pDC->SelectObject(&m_ftFoot);
int y = rcPage.top;
int x = rcPage.left;
CSize szPg(0, 0);

if (m_csPageFooter != "")
{
CRect rc1(x, y, rcPage.right - szPg.cy, y);
pDC->DrawText(m_csPageFooter, rc1, DT_WORDBREAK|DT_CALCRECT|DT_LEFT);
if (!bCalc)
pDC->DrawText(m_csPageFooter, rc1, DT_WORDBREAK|DT_LEFT);
szPg.cy = rc1.Height();
}

rcPage.bottom -= szPg.cy;
pDC->SelectObject(oft);

return szPg;
}

CSize CListCtrlPrint::PrintListHead(CDC *pDC, CRect &rcPage, bool bCalc)
{
if (!bCalc)
{
CFont *oft = pDC->SelectObject(&m_ftPrint);
CRect rcc(rcPage.left, rcPage.top, rcPage.right, rcPage.top + m_szFtPrint.cy);
pDC->MoveTo(rcc.left, rcc.top);
pDC->LineTo(rcc.right, rcc.top);
pDC->LineTo(rcc.right, rcc.bottom);
pDC->LineTo(rcc.left, rcc.bottom);
pDC->LineTo(rcc.left, rcc.top);

int box = 0;
CRect rc1;
int y = rcPage.top;
for (int t = 0; t < m_iNumCol; t++)
{
rc1.SetRect(rcPage.left+m_pDx[t], y, rcPage.left+m_pDx[t+1], y+m_szFtPrint.cy);
CString cs = m_pColTitle[t] ? m_pColTitle[t] : "";
pDC->Rectangle(rc1);

UINT ftm = DT_LEFT;
if (m_pFormat[t]&HDF_CENTER)
ftm = DT_CENTER;
else if (m_pFormat[t]&HDF_RIGHT)
ftm = DT_RIGHT;

pDC->DrawText(cs, rc1, ftm|DT_VCENTER);

pDC->MoveTo(rc1.left, rc1.bottom);
pDC->LineTo(rc1.left, rc1.top);
pDC->LineTo(rc1.right, rc1.top);
}

pDC->SelectObject(oft);
}

rcPage.top += m_szFtPrint.cy;

return CSize(0, m_szFtPrint.cy);
}

CSize CListCtrlPrint::PrintListFoot(CDC *pDC, CRect &rcPage, bool bCalc)
{
return CSize(0, 0);
}

[wuxfBrave]

CListCtrlPrint cJob;
cJob.m_csPageHead = strHead;
cJob.m_pList = &m_listLog;//日志listctrlm_listLog
cJob.OnFilePrint();
//使用方法

[wuxfBrave]

以上是一个可以打印的listctrl
是从网上下的

[wangbab]

几天没来，有这么多回复。谢谢大家关注。

Email：[e-mail]
发给我OK?