Qt利用QGraphicsScene编写Word排版工具导出PDF

自定义Graphics图形系统
QTEGraphicsItem

QTEGraphicsScene

Word排版工具
QTEWordExpress

QTEReport

本篇的目的是编写一个工具，能够方便的对富文本、表格、图片生成Report和导出PDF，并且必须要在ARM、MIPS平台的linux嵌入式系统中方便使用。

自定义Graphics图形系统

Graphic系统，可以良好的完成图形的编辑工作和显示工作，但是在嵌入式板子上并不能良好的工作，因为内部绘图机制在嵌入式屏幕上存在很大的失真问题。

QTEGraphicsItem

QTEGraphicsItem.h

#ifndef QTEGRAPHICSITEM_H
#define QTEGRAPHICSITEM_H

#include <QGraphicsItem>
#include <QGraphicsProxyWidget>

class QTEGraphicsItem : public QGraphicsItem
{
public:
explicit QTEGraphicsItem(QTEGraphicsItem *parent = 0);

};

class QTEGraphicsTextItem : public QGraphicsTextItem
{
public:
explicit QTEGraphicsTextItem(QTEGraphicsItem *parent = 0);

// QGraphicsItem interface
public:
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
};

class QTEGraphicsSimpleTextItem : public QGraphicsSimpleTextItem
{
public:
explicit QTEGraphicsSimpleTextItem(QTEGraphicsItem *parent = 0);

};

class QTEGraphicsPixmapItem : public QGraphicsPixmapItem
{
public:
explicit QTEGraphicsPixmapItem(QTEGraphicsItem *parent = 0);

};

class QTEGraphicsRectItem : public QGraphicsRectItem
{
public:
explicit QTEGraphicsRectItem(QTEGraphicsItem *parent = 0);

// QGraphicsItem interface
public:
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
};

class QTEGraphicsLineItem : public QGraphicsLineItem
{
public:
explicit QTEGraphicsLineItem(QTEGraphicsItem *parent = 0);

// QGraphicsItem interface
public:
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
};

class QTEGraphicsPathItem : public QGraphicsPathItem
{
public:
explicit QTEGraphicsPathItem(QTEGraphicsItem *parent = 0);

};

class QTEGraphicsEllipseItem : public QGraphicsEllipseItem
{
public:
explicit QTEGraphicsEllipseItem(QTEGraphicsItem *parent = 0);

};

class QTEGraphicsPolygonItem : public QGraphicsPolygonItem
{
public:
explicit QTEGraphicsPolygonItem(QTEGraphicsItem *parent = 0);

};

class QTEGraphicsItemGroup : public QGraphicsItemGroup
{
public:
explicit QTEGraphicsItemGroup(QTEGraphicsItem *parent = 0);

};

class QTEGraphicsProxyWidget : public QGraphicsProxyWidget
{
public:
explicit QTEGraphicsProxyWidget(QTEGraphicsItem *parent = 0);

};

#endif // QTEGRAPHICSITEM_H

QTEGraphicsItem.cpp

#include "hngraphicsitem.h"
#include <QPainter>
#include <QStyleOptionGraphicsItem>
#include "QTEDefine.h"

QTEGraphicsItem::QTEGraphicsItem(QTEGraphicsItem *parent) : QGraphicsItem(parent) {}

QTEGraphicsTextItem::QTEGraphicsTextItem(QTEGraphicsItem *parent) : QGraphicsTextItem(parent) {}

QTEGraphicsRectItem::QTEGraphicsRectItem(QTEGraphicsItem *parent) : QGraphicsRectItem(parent) {}

QTEGraphicsSimpleTextItem::QTEGraphicsSimpleTextItem(QTEGraphicsItem *parent) : QGraphicsSimpleTextItem(parent) {}

QTEGraphicsLineItem::QTEGraphicsLineItem(QTEGraphicsItem *parent) : QGraphicsLineItem(parent) {}

QTEGraphicsPixmapItem::QTEGraphicsPixmapItem(QTEGraphicsItem *parent) : QGraphicsPixmapItem(parent) {}

QTEGraphicsPathItem::QTEGraphicsPathItem(QTEGraphicsItem *parent) : QGraphicsPathItem(parent) {}

QTEGraphicsEllipseItem::QTEGraphicsEllipseItem(QTEGraphicsItem *parent) : QGraphicsEllipseItem(parent) {}

QTEGraphicsPolygonItem::QTEGraphicsPolygonItem(QTEGraphicsItem *parent) : QGraphicsPolygonItem(parent) {}

QTEGraphicsItemGroup::QTEGraphicsItemGroup(QTEGraphicsItem *parent) : QGraphicsItemGroup(parent) {}

QTEGraphicsProxyWidget::QTEGraphicsProxyWidget(QTEGraphicsItem *parent) : QGraphicsProxyWidget(parent) {}

void QTEGraphicsTextItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
QFont oldFont(painter->font());

painter->setFont(font());
//painter->fillRect(option->rect, Qt::SolidPattern);
painter->drawText(option->rect, Qt::AlignCenter, toPlainText());

if (option->state & (QStyle::State_Selected | QStyle::State_HasFocus))
;

if(toPlainText().contains("K1160"))
{
pline() << font().pointSize() << font().pixelSize();
pline() << pos() << option->rect << option->exposedRect << toPlainText();
pline() << option->matrix << option->matrix.mapRect(option->rect);
}
painter->setFont(oldFont);
}

void QTEGraphicsLineItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
QPen oldPen(painter->pen());

qreal xratio = option->rect.width() / option->exposedRect.width();
qreal yratio = option->rect.height() / option->exposedRect.height();

QPen pn = pen();
pn.setWidth(pn.width()*xratio);
painter->setPen(pn);

QLineF l = QLineF(option->rect.left(), option->rect.top(),
option->rect.right(), option->rect.top());

painter->drawLine(l);
if(0)
{
pline() << line() << l << option->rect << option->exposedRect;
pline() << option->matrix << option->matrix.mapRect(option->rect);
}

painter->setPen(oldPen);
}

void QTEGraphicsRectItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
QPen oldPen(painter->pen());
QBrush oldBrush(painter->brush());

qreal xratio = option->rect.width() / option->exposedRect.width();
qreal yratio = option->rect.height() / option->exposedRect.height();

QPen pn = pen();
pn.setWidth(pn.width()*xratio);
painter->setPen(pn);

QRectF r = QRectF(option->rect.left(), option->rect.top(),
option->r
17bc0
ect.width(), option->rect.height());

painter->setBrush(brush());
painter->drawRect(r);

if(0)
{
pline() << option->matrix << option->matrix.mapRect(option->rect) << r;
}

painter->setPen(oldPen);
painter->setBrush(oldBrush);
}

QTEGraphicsScene

QTEGraphicsScene.h

#ifndef QTEGRAPHICSSCENE_H
#define QTEGRAPHICSSCENE_H

#include <QGraphicsScene>
#include "hngraphicsitem.h"

class QTEGraphicsScene : public QGraphicsScene
{
Q_OBJECT
public:
QTEGraphicsScene(QObject *parent = 0);
QTEGraphicsScene(const QRectF &sceneRect, QObject *parent = 0);
QTEGraphicsScene(qreal x, qreal y, qreal width, qreal height, QObject *parent = 0);
virtual ~QTEGraphicsScene() {}

void render(QPainter *painter,
const QRectF &target = QRectF(), const QRectF &source = QRectF(),
Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio);
QTEGraphicsEllipseItem *addEllipse(const QRectF &rect, const QPen &pen = QPen(), const QBrush &brush = QBrush());
inline QGraphicsEllipseItem *addEllipse(qreal x, qreal y, qreal w, qreal h, const QPen &pen = QPen(), const QBrush &brush = QBrush())
{ return addEllipse(QRectF(x, y, w, h), pen, brush); }

QTEGraphicsPathItem *addPath(const QPainterPath &path, const QPen &pen = QPen(), const QBrush &brush = QBrush());
QTEGraphicsPixmapItem *addPixmap(const QPixmap &pixmap);
QTEGraphicsPolygonItem *addPolygon(const QPolygonF &polygon, const QPen &pen = QPen(), const QBrush &brush = QBrush());
QTEGraphicsTextItem *addText(const QString &text, const QFont &font = QFont());
QTEGraphicsSimpleTextItem *addSimpleText(const QString &text, const QFont &font = QFont());
QTEGraphicsProxyWidget *addWidget(QWidget *widget, Qt::WindowFlags wFlags = 0);
QTEGraphicsLineItem *addLine(const QLineF &line, const QPen &pen = QPen());
inline QTEGraphicsLineItem *addLine(qreal x1, qreal y1, qreal x2, qreal y2, const QPen &pen = QPen())
{ return addLine(QLineF(x1, y1, x2, y2), pen); }
QTEGraphicsRectItem *addRect(const QRectF &rect, const QPen &pen = QPen(), const QBrush &brush = QBrush());
inline QTEGraphicsRectItem *addRect(qreal x, qreal y, qreal w, qreal h, const QPen &pen = QPen(), const QBrush &brush = QBrush())
{ return addRect(QRectF(x, y, w, h), pen, brush); }

signals:

public slots:

// QGraphicsScene interface
protected:
void drawItems(QPainter *painter, int numItems, QGraphicsItem *items[], const QStyleOptionGraphicsItem options[], QWidget *widget = 0);

private:
};

#endif // QTEGRAPHICSSCENE_H

QTEGraphicsScene.cpp

#include "hngraphicsscene.h"
#include <QGraphicsItem>
#include <QPainter>
#include "QTEDefine.h"

QTEGraphicsScene::QTEGraphicsScene(QObject *parent) :
QGraphicsScene(parent)
{
}

QTEGraphicsScene::QTEGraphicsScene(const QRectF &sceneRect, QObject *parent) :
QGraphicsScene(sceneRect, parent)
{

}

QTEGraphicsScene::QTEGraphicsScene(qreal x, qreal y, qreal width, qreal height, QObject *parent) :
QGraphicsScene(x, y, width, height, parent)
{

}

/**
* @brief QTEGraphicsScene::render
* 经过测试，失真是由于render放缩QPainter和drawItems里面的itemPaint共同导致失真
* 现在规整理如下，原则：Qpainter不允许改变
* 重写itemPaint函数
* @param painter
* @param target
* @param source
* @param aspectRatioMode
*/
void QTEGraphicsScene::render(QPainter *painter, const QRectF &target, const QRectF &source, Qt::AspectRatioMode aspectRatioMode)
{
// Find the ideal x / y scaling ratio to fit a source into a target.
QRectF sourceRect = sceneRect();
QRectF targetRect = sourceRect;
if(!source.isEmpty())
sourceRect = source;
if(!target.isEmpty())
targetRect = target;

qreal xratio = targetRect.width() / sourceRect.width();
qreal yratio = targetRect.height() / sourceRect.height();

QList<QGraphicsItem *> itemList = items();
QGraphicsItem **itemArray = new QGraphicsItem *[itemList.size()];
int numItems = itemList.size();
for (int i = 0; i < numItems; ++i)
itemArray[numItems - i - 1] = itemList.at(i);
itemList.clear();

painter->save();

// Generate the style options
QStyleOptionGraphicsItem *styleOptionArray = new QStyleOptionGraphicsItem[numItems];
for (int i = 0; i < numItems; ++i) {
QGraphicsItem *item = itemArray[i];
QStyleOptionGraphicsItem option;
option.state = QStyle::State_None;
if (item->isSelected())
option.state |= QStyle::State_Selected;
if (item->isEnabled())
option.state |= QStyle::State_Enabled;
if (item->hasFocus())
option.state |= QStyle::State_HasFocus;
if (item == mouseGrabberItem())
option.state |= QStyle::State_Sunken;

option.exposedRect = item->boundingRect();

option.rect.setLeft(item->pos().x()*xratio);
option.rect.setWidth(option.exposedRect.width()*xratio);
option.rect.setTop(item->pos().y()*yratio);
option.rect.setHeight(option.exposedRect.height()*yratio);

//pline() << xratio << yratio << item->pos() << option.rect << option.exposedRect;

styleOptionArray[i] = option;
}
// Render the scene.
drawBackground(painter, targetRect);
drawItems(painter, numItems, itemArray, styleOptionArray);
drawForeground(painter, targetRect);
delete [] itemArray;
delete [] styleOptionArray;

painter->restore();
}

QTEGraphicsTextItem *QTEGraphicsScene::addText(const QString &text, const QFont &font)
{
QTEGraphicsTextItem* item = new QTEGraphicsTextItem;
item->setFont(font);
item->setPlainText(text);
addItem(item);
return item;
}

QTEGraphicsRectItem *QTEGraphicsScene::addRect(const QRectF &rect, const QPen &pen, const QBrush &brush)
{
QTEGraphicsRectItem* item = new QTEGraphicsRectItem;
item->setRect(rect);
item->setPen(pen);
item->setBrush(brush);
item->moveBy(rect.x(), rect.y());
addItem(item);
return item;
}

QTEGraphicsLineItem *QTEGraphicsScene::addLine(const QLineF &line, const QPen &pen)
{
QTEGraphicsLineItem* item = new QTEGraphicsLineItem;
item->setLine(line);
item->setPen(pen);
item->moveBy(line.x1(), line.y1());

addItem(item);
return item;
}

void QTEGraphicsScene::drawItems(QPainter *painter, int numItems, QGraphicsItem *items[], const QStyleOptionGraphicsItem options[], QWidget *widget)
{
for (int i = 0; i < numItems; ++i) {

QTEGraphicsItem *item = (QTEGraphicsItem*)items[i];
if (item->flags() & QGraphicsItem::ItemClipsToShape) {
//painter->setClipPath(item->shape(), Qt::IntersectClip);
}
item->paint(painter, &options[i], widget);
}

}

Word排版工具

支持添加Table、图片、文本，支持导出pdf、jpg、png、svg，支持预览。

QTEWordExpress

QTEWordExpress.h

#ifndef QTEWORDEXPRESS_H
#define QTEWORDEXPRESS_H

#include <QObject>
#include "hngui-qt.h"
#include "hnprinter.h"
#include "hngraphicsscene.h"

class QTEWordExpress : public QObject
{
Q_OBJECT
public:
explicit QTEWordExpress(QObject *parent = 0);

void addText(const QString& text, QFont m_font = QFont(),
Qt::Alignment align = Qt::AlignHCenter, QPointF point= QPointF(0, 0));
void addSignoffText(const QString& text, QFont m_font = QFont());
void addTable(const QTableView* table, QPointF pos = QPointF(0, 0));

int pageNum() { return pageSceneVector.size(); }
QTEGraphicsScene* getPage(int num);
void exportPdf(const QString &pdf);
void print();

QRectF margin();
void setMargin(qreal left = 0, qreal right = 0,
qreal top = 0, qreal botoom = 0);
void setLineSpacing(qreal mainSpacing = 0);
void setHeaderSize(qreal size = 0);
void setFooterSize(qreal size = 0);

QFont font() { return m_font; }
void setFont(QFont m_font = QFont());
void setHeaderFont(QFont m_font = QFont());
QFont mainFont() { return m_mainFont; }
QFont titleFont() { return m_titleFont; }
QFont title2Font() { return m_title2Font; }
QFont headerFont() { return m_headerFont; }
void setHeaderLine(bool show = false);
void setFooterLine(bool show = false);
void setHeaderText(const QString &text, QFont m_font = QFont(),
Qt::Alignment align = Qt::AlignHCenter);
void setFooterText(const QString& text, QFont m_font = QFont(),
Qt::Alignment align = Qt::AlignHCenter);
/**
* @brief initWordExpress 初始化纸张，第一张空白纸
*/
void initWordExpress();

protected:
virtual void adjustdy(qreal dy0);
virtual void createFrame();
virtual void paintPageHeader();
virtual void paintPageFooter();
signals:

public slots:

private:
//输出
QTEPrinter* pr;
//对页面元素高度不能迅速统计的场景
QVector<QTEGraphicsScene*> pageSceneVector;
QTEGraphicsScene* pageScene;

//页面元素
int logicalDpiX;
int logicalDpiY;
QRectF sceneRect;

qreal xpos, xpos2, ypos, ypos2;
qreal dx, dy;

qreal leftMargin;
qreal rightMargin;
qreal topMargin;
qreal bottomMargin;

qreal mainHeight;
qreal titleHeight;
qreal title2Height;
qreal headerHeight;
qreal mainSpacing;
qreal titleSpacing;
qreal title2Spacing;
qreal headerSpacing;

//页眉
qreal headerSize;
QFont m_headerFont;
QFontMetrics *headerFmt;
QString headerText;
//页脚
qreal footerSize;
QString footerStdText;
QString footerText;
//标题
QFont m_titleFont;
QFontMetrics *titleFmt;
//二号标题
QFont m_title2Font;
QFontMetrics *title2Fmt;
//正文
QFont m_mainFont;
QFontMetrics *mainFmt;
//使用中
QFont m_font;
QFontMetrics *fmt;
};

#endif // QTEWORDEXPRESS_H

QTEWordExpress.cpp

#include "hnwordexpress.h"
#include "QTEDefine.h"

QTEWordExpress::QTEWordExpress(QObject *parent) :
QObject(parent),
fmt(0), mainFmt(0),headerFmt(0),titleFmt(0), title2Fmt(0)
{
//setup printer
pr= new QTEPrinter(QPrinter::HighResolution);
pr->setFullPage(true);
pr->setColorMode(QPrinter::Color);
pr->setPaperSize(QPrinter::A4);
pr->setOrientation(QPrinter::Portrait);
pr->setOutputFormat(QPrinter::PdfFormat);

//Font目标是打印纸上，所见即所得。
//Pos目标不是纸上的，是屏幕上的，所以更换屏幕，必须更换DPI；
//这个数值是迪文屏上的标准分辨率，打印机使用会失真；
//迪文View 142,138 //PCView 96 //打印机View 1200
//打印机分辨率1200不会失真，绘图必须进行坐标变换。
//数值增大，DrawText可用空间减小甚至切掉一部分
#ifdef __MIPS_LINUX__
//这是实验结果，和理论结果不符合。
logicalDpiX = 136;
logicalDpiY = 156;
#else
logicalDpiX = 96;
logicalDpiY = 96;
#endif

QRect rect = pr->paperRect();
sceneRect = QRectF(0.0, 0.0, logicalDpiX *rect.width()/pr->logicalDpiX(), logicalDpiY*rect.height()/pr->logicalDpiY());

#if 0
//1200 9917,14033 printerRect 固定
//116  958,1356 sceneRect
//142  1113,1660 sceneRect
pline() << pr->logicalDpiX() << pr->logicalDpiY();
pline()  << logicalDpiX << logicalDpiY << pr->pageRect() << sceneRect;
pline() << pr->paperRect(QPrinter::DevicePixel);
pline() << pr->paperRect(QPrinter::Millimeter);
pline() << pr->paperRect(QPrinter::Point);
pline() << pr->paperRect(QPrinter::Inch);
pline() << pr->paperRect(QPrinter::Pica);
pline() << pr->paperRect(QPrinter::Didot);
pline() << pr->paperRect(QPrinter::Cicero);
#endif

m_mainFont = QApplication::font();
if(mainFmt)
delete mainFmt;
mainFmt = new QFontMetrics(m_mainFont);
m_titleFont= QApplication::font();
m_titleFont.setPointSize(22);
if(titleFmt)
delete titleFmt;
titleFmt = new QFontMetrics(m_titleFont);
m_title2Font = QApplication::font();;
m_title2Font.setPointSize(16);
if(title2Fmt)
delete title2Fmt;
title2Fmt =new QFontMetrics(m_title2Font);

setMargin();
setHeaderSize();
setFooterSize();

setFont();
setHeaderFont();
setLineSpacing();

setHeaderLine();
setFooterLine();

initWordExpress();
}

void QTEWordExpress::setMargin(qreal left, qreal right, qreal top, qreal botoom)
{
leftMargin=134.6;
rightMargin=134.6;
topMargin=177.7;
bottomMargin=177.7;
}

QRectF QTEWordExpress::margin()
{
return QRectF(leftMargin, topMargin,
sceneRect.width()-leftMargin-rightMargin,
sceneRect.height()-topMargin-bottomMargin);
}

void QTEWordExpress::setFont(QFont font)
{
//normal font 11
m_font = QApplication::font();
if(fmt)
delete fmt;
fmt = new QFontMetrics(m_font);
}

void QTEWordExpress::setLineSpacing(qreal spacing)
{
//单倍行距
mainHeight = mainFmt->height();
titleHeight = titleFmt->height();
title2Height = title2Fmt->height();
headerHeight = headerFmt->height();

mainSpacing = mainFmt->height() * 2;
titleSpacing = titleFmt->height() * 2;
title2Spacing = title2Fmt->height() * 2;
headerSpacing = headerFmt->height() * 1;
}

void QTEWordExpress::addText(const QString &text, QFont font, Qt::Alignment align, QPointF point)
{
QFontMetrics fmt = QFontMetrics(font);
int spacing = fmt.height() * 2;
int height = fmt.height();
int width=fmt.width(text);

pline() << font.pointSize() << fmt.height();

adjustdy(height + spacing);

QTEGraphicsTextItem* item = pageScene->addText(text, font);

if(align & Qt::AlignLeft)
item->moveBy(dx, dy+height);
else if(align & Qt::AlignRight)
item->moveBy(xpos2 - width, dy+height);
else if(align & Qt::AlignHCenter)
item->moveBy((pageScene->width()/2)-(width/2), dy+height);
dy += height + spacing;
}

void QTEWordExpress::addSignoffText(const QString &text, QFont font)
{
adjustdy(mainHeight + mainSpacing);

int ddy = dy;

dy = ypos2 - ( (mainHeight + mainSpacing) * 2 );

addText(text, m_mainFont, Qt::AlignRight);

dy = ddy;
}

void QTEWordExpress::addTable(const QTableView *table, QPointF pos)
{
const QTableView *tableView = table;
QAbstractItemModel* model = tableView->model();
QFont tableFont = tableView->font();
QFontMetrics tableFmt = QFontMetrics(tableFont);

int tableRowHeight = tableView->horizontalHeader()->height();
adjustdy(tableRowHeight);
for (int i=0; i<model->columnCount(); i++) {
int logicalIndex=tableView->horizontalHeader()->logicalIndex(i);
int actColSize= tableView->columnWidth(logicalIndex);

QPen pen(Qt::gray, 0.1);
QBrush brush(QColor(255, 250, 250));
//QBrush brush(tableView->horizontalHeader()->palette().background());
pageScene->addRect(dx,dy, actColSize,tableRowHeight, pen, brush);

QString txt = model->headerData(logicalIndex,Qt::Horizontal,Qt::DisplayRole).toString();
txt = tableFmt.elidedText(txt, Qt::ElideRight, actColSize-2);
QTEGraphicsTextItem *item = pageScene->addText(txt, tableFont);
item->moveBy(dx, dy);
dx += actColSize;
}
dy += tableRowHeight;

//Table rows
QPen pen(Qt::gray, 0.1);
QBrush brush(Qt::gray, Qt::SolidPattern);
int row = 0;
for (;;) {
if (row >= model->rowCount()) {
break;
}

tableRowHeight = tableView->rowHeight(row);
adjustdy(tableRowHeight);
for (int j=0; j<model->columnCount(); j++) {
int logicalIndex=tableView->horizontalHeader()->logicalIndex(j);
int actColSize=tableView->columnWidth(logicalIndex);

QPen pen(Qt::gray, 0.1);
QBrush brush(tableView->palette().window());
bool balt = tableView->alternatingRowColors();
if(balt)
{
int modulo= row % 2;
if (modulo != 0) {
//rectangle grey
pageScene->addRect(dx,dy,actColSize,tableRowHeight, pen, brush);
}
else
{
pageScene->addRect(dx,dy,actColSize,tableRowHeight, pen);
}
}
else
{
pageScene->addRect(dx,dy,actColSize,tableRowHeight, pen);
}

QString txt = model->data(model->index(row,logicalIndex)).toString();
txt=tableFmt.elidedText(txt,Qt::ElideRight,actColSize-2);
QTEGraphicsTextItem *item = pageScene->addText(txt, tableFont);
item->moveBy(dx,dy);

dx+=actColSize;
}
row++;
dy += tableRowHeight;
dx = xpos;
}
}

void QTEWordExpress::exportPdf(const QString &pdf)
{
// setup printer
pr->setOutputFileName(pdf);

// print pdf
QPainter p(pr);

QTEGraphicsScene* pageScene = 0;
foreach (pageScene, pageSceneVector) {

pageScene->render(&p, pr->paperRect(), sceneRect);

if(pageScene != pageSceneVector.last())
pr->newPage();
}
}

QTEGraphicsScene *QTEWordExpress::getPage(int num)
{
if(num < 1 || num > pageSceneVector.size())
return NULL;
return pageSceneVector.at(num-1);
}

void QTEWordExpress::print()
{
pr->print();
}

void QTEWordExpress::setHeaderFont(QFont font)
{
//header font
m_headerFont = QApplication::font();;
m_headerFont.setPointSize(9);
if(headerFmt)
delete headerFmt;
headerFmt =new QFontMetrics(m_headerFont);
}

void QTEWordExpress::setHeaderSize(qreal size)
{
headerSize=70;
}

void QTEWordExpress::setHeaderLine(bool show)
{

}

void QTEWordExpress::setHeaderText(const QString &text, QFont font, Qt::Alignment align)
{
headerText = text;
paintPageHeader();
}

void QTEWordExpress::setFooterSize(qreal size)
{
footerSize=70;
}

void QTEWordExpress::setFooterLine(bool show)
{

}

void QTEWordExpress::setFooterText(const QString &text, QFont font, Qt::Alignment align)
{
footerText = text;
paintPageFooter();
}

void QTEWordExpress::initWordExpress()
{
while ( ! pageSceneVector.isEmpty() ) {
QTEGraphicsScene* pageScene = pageSceneVector.first();
pageScene->clear();
delete pageScene;
pageSceneVector.remove(0);
}
headerText = "";
footerText = "";
createFrame();
}

void QTEWordExpress::adjustdy(qreal dy0)
{
dx = xpos;
if(dy + dy0 < ypos2)
return;
createFrame();
}

void QTEWordExpress::createFrame()
{
xpos = leftMargin;
xpos2 = sceneRect.width() - rightMargin;
ypos = topMargin;
ypos2 = sceneRect.height() - bottomMargin;
dx = xpos;
dy = ypos;

pageScene = new QTEGraphicsScene(sceneRect);
pageSceneVector.append(pageScene);
paintPageHeader();
paintPageFooter();
}

void QTEWordExpress::paintPageHeader()
{
// Page header
if (headerText.isEmpty())
return;

int sx = xpos;
int sy = ypos-headerSize;
//页眉
QTEGraphicsTextItem *headerItem = pageScene->addText(headerText, m_headerFont);
headerItem->moveBy(sx, sy);

//std text
QString date=QDate::currentDate().toString(QLocale().dateFormat());
QString time=QTime::currentTime().toString(QLocale().timeFormat(QLocale::ShortFormat));
QString headerStdText;
headerStdText = date+"  "+time;
QTEGraphicsTextItem *item = pageScene->addText(headerStdText, m_headerFont);
item->moveBy(xpos2 - headerFmt->width(headerStdText), sy);

sy += headerItem->boundingRect().height();

//line
pageScene->addLine(xpos, sy, xpos2, sy, QPen(Qt::black, 1.0));
}

void QTEWordExpress::paintPageFooter()
{
if (footerText.isEmpty())
return;

// footer
int sx = xpos;

QString footerStdText = tr("第 ") + QString::number(pageSceneVector.size()) + tr(" 页");
QTEGraphicsTextItem *item=pageScene->addText(footerStdText, m_headerFont);
int height = item->boundingRect().height();
int sy = ypos2 + footerSize - height;
item->moveBy(xpos2 - headerFmt->width(footerStdText), sy);

pageScene->addLine(xpos, sy, xpos2, sy, QPen(Qt::black, 1.0));

QTEGraphicsTextItem *footerItem=pageScene->addText(footerText, m_headerFont);
footerItem->moveBy(xpos, sy);
}

QTEReport

QTEReport.h

#ifndef QTEREPORT_H
#define QTEREPORT_H

#include "hnwordexpress.h"

class QTEReport : public QTEWordExpress
{
Q_OBJECT
public:
explicit QTEReport(QObject *parent = 0);

void createSampleReport(const QString& head, const QString& foot, const QString& title,
const QTableView* table);
void GenerateComplexReport();
signals:

public slots:

// QTEWordExpress interface
protected:

private:
};

QTEReport* QTEReportInstance(QObject* parent);

#endif // QTEREPORT_H

QTEReport.cpp

#include "hnreport.h"

QTEReport::QTEReport(QObject *parent) :
QTEWordExpress(parent)
{
}

void QTEReport::createSampleReport(const QString &head, const QString &foot, const QString &title, const QTableView *table)
{
initWordExpress();
setHeaderText(head);
setFooterText(foot);
addText(title, titleFont());
addText("试验结果", title2Font(), Qt::AlignLeft);
addTable(table);
addSignoffText("打印人:___________");
}

void QTEReport::GenerateComplexReport()
{
}

QTEReport *QTEReportInstance(QObject *parent)
{
static QTEReport* r = new QTEReport(parent);
return r;
}