/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtGui/qprintengine.h>
#include <qiodevice.h>
#include <qpainter.h>
#include <qbitmap.h>
#include <qpainterpath.h>
#include <qpaintdevice.h>
#include <qfile.h>
#include <qdebug.h>
#include <qimagewriter.h>
#include <qbuffer.h>
#include <qdatetime.h>
#ifndef QT_NO_PRINTER
#include <limits.h>
#include <math.h>
#ifndef QT_NO_COMPRESS
#include <zlib.h>
#endif
#if defined(Q_OS_WINCE)
#include "qwinfunctions_wince.h"
#endif
#include "qprintengine_pdf_p.h"
#include "private/qdrawhelper_p.h"
QT_BEGIN_NAMESPACE
extern qint64 qt_pixmap_id(const QPixmap &pixmap);
extern qint64 qt_image_id(const QImage &image);
//#define FONT_DUMP
// might be helpful for smooth transforms of images
// Can't use it though, as gs generates completely wrong images if this is true.
static const bool interpolateImages = false;
#ifdef QT_NO_COMPRESS
static const bool do_compress = false;
#else
static const bool do_compress = true;
#endif
QPdfPage::QPdfPage()
: QPdf::ByteStream(true) // Enable file backing
{
}
void QPdfPage::streamImage(int w, int h, int object)
{
*this << w << "0 0 " << -h << "0 " << h << "cm /Im" << object << " Do\n";
if (!images.contains(object))
images.append(object);
}
inline QPaintEngine::PaintEngineFeatures qt_pdf_decide_features()
{
QPaintEngine::PaintEngineFeatures f = QPaintEngine::AllFeatures;
f &= ~(QPaintEngine::PorterDuff | QPaintEngine::PerspectiveTransform
| QPaintEngine::ObjectBoundingModeGradients
#ifndef USE_NATIVE_GRADIENTS
| QPaintEngine::LinearGradientFill
#endif
| QPaintEngine::RadialGradientFill
| QPaintEngine::ConicalGradientFill);
return f;
}
QPdfEngine::QPdfEngine(QPrinter::PrinterMode m)
: QPdfBaseEngine(*new QPdfEnginePrivate(m), qt_pdf_decide_features())
{
state = QPrinter::Idle;
}
QPdfEngine::~QPdfEngine()
{
}
bool QPdfEngine::begin(QPaintDevice *pdev)
{
Q_D(QPdfEngine);
if(!QPdfBaseEngine::begin(pdev)) {
state = QPrinter::Error;
return false;
}
d->stream->setDevice(d->outDevice);
d->streampos = 0;
d->hasPen = true;
d->hasBrush = false;
d->clipEnabled = false;
d->allClipped = false;
d->xrefPositions.clear();
d->pageRoot = 0;
d->catalog = 0;
d->info = 0;
d->graphicsState = 0;
d->patternColorSpace = 0;
d->pages.clear();
d->imageCache.clear();
setActive(true);
state = QPrinter::Active;
d->writeHeader();
newPage();
return true;
}
bool QPdfEngine::end()
{
Q_D(QPdfEngine);
d->writeTail();
d->stream->unsetDevice();
QPdfBaseEngine::end();
setActive(false);
state = QPrinter::Idle;
return true;
}
void QPdfEngine::drawPixmap (const QRectF &rectangle, const QPixmap &pixmap, const QRectF &sr)
{
if (sr.isEmpty() || rectangle.isEmpty() || pixmap.isNull())
return;
Q_D(QPdfEngine);
QBrush b = d->brush;
QRect sourceRect = sr.toRect();
QPixmap pm = sourceRect != pixmap.rect() ? pixmap.copy(sourceRect) : pixmap;
QImage image = pm.toImage();
bool bitmap = true;
const int object = d->addImage(image, &bitmap, pm.cacheKey());
if (object < 0)
return;
*d->currentPage << "q\n/GSa gs\n";
*d->currentPage
<< QPdf::generateMatrix(QTransform(rectangle.width() / sr.width(), 0, 0, rectangle.height() / sr.height(),
rectangle.x(), rectangle.y()) * (d->simplePen ? QTransform() : d->stroker.matrix));
if (bitmap) {
// set current pen as d->brush
d->brush = d->pen.brush();
}
setBrush();
d->currentPage->streamImage(image.width(), image.height(), object);
*d->currentPage << "Q\n";
d->brush = b;
}
void QPdfEngine::drawImage(const QRectF &rectangle, const QImage &image, const QRectF &sr, Qt::ImageConversionFlags)
{
if (sr.isEmpty() || rectangle.isEmpty() || image.isNull())
return;
Q_D(QPdfEngine);
QRect sourceRect = sr.toRect();
QImage im = sourceRect != image.rect() ? image.copy(sourceRect) : image;
bool bitmap = true;
const int object = d->addImage(im, &bitmap, im.cacheKey());
if (object < 0)
return;
*d->currentPage << "q\n/GSa gs\n";
*d->currentPage
<< QPdf::generateMatrix(QTransform(rectangle.width() / sr.width(), 0, 0, rectangle.height() / sr.height(),
rectangle.x(), rectangle.y()) * (d->simplePen ? QTransform() : d->stroker.matrix));
setBrush();
d->currentPage->streamImage(im.width(), im.height(), object);
*d->currentPage << "Q\n";
}
void QPdfEngine::drawTiledPixmap (const QRectF &rectangle, const QPixmap &pixmap, const QPointF &point)
{
Q_D(QPdfEngine);
bool bitmap = (pixmap.depth() == 1);
QBrush b = d->brush;
QPointF bo = d->brushOrigin;
bool hp = d->hasPen;
d->hasPen = false;
bool hb = d->hasBrush;
d->hasBrush = true;
d->brush = QBrush(pixmap);
if (bitmap)
// #### fix bitmap case where we have a brush pen
d->brush.setColor(d->pen.color());
d->brushOrigin = -point;
*d->currentPage << "q\n";
setBrush();
drawRects(&rectangle, 1);
*d->currentPage << "Q\n";
d->hasPen = hp;
d->hasBrush = hb;
d->brush = b;
d->brushOrigin = bo;
}
void QPdfEngine::setBrush()
{
Q_D(QPdfEngine);
Qt::BrushStyle style = d->brush.style();
if (style == Qt::NoBrush)
return;
bool specifyColor;
int gStateObject = 0;
int patternObject = d->addBrushPattern(d->stroker.matrix, &specifyColor, &gStateObject);
*d->currentPage << (patternObject ? "/PCSp cs " : "/CSp cs ");
if (specifyColor) {
QColor rgba = d->brush.color();
if (d->colorMode == QPrinter::GrayScale) {
qreal gray = qGray(rgba.rgba())/255.;
*d->currentPage << gray << gray << gray;
} else {
*d->currentPage << rgba.redF()
<< rgba.greenF()
<< rgba.blueF();
}
}
if (patternObject)
*d->currentPage << "/Pat" << patternObject;
*d->currentPage << "scn\n";
if (gStateObject)
*d->currentPage << "/GState" << gStateObject << "gs\n";
else
*d->currentPage << "/GSa gs\n";
}
QPaintEngine::Type QPdfEngine::type() const
{
return QPaintEngine::Pdf;
}
bool QPdfEngine::newPage()
{
Q_D(QPdfEngine);
if (!isActive())
return false;
d->newPage();
return QPdfBaseEngine::newPage();
}
QPdfEnginePrivate::QPdfEnginePrivate(QPrinter::PrinterMode m)
: QPdfBaseEnginePrivate(m)
{
streampos = 0;
stream = new QDataStream;
pageOrder = QPrinter::FirstPageFirst;
orientation = QPrinter::Portrait;
fullPage = false;
}
QPdfEnginePrivate::~QPdfEnginePrivate()
{
delete stream;
}
#ifdef USE_NATIVE_GRADIENTS
int QPdfEnginePrivate::gradientBrush(const QBrush &b, const QMatrix &matrix, int *gStateObject)
{
const QGradient *gradient = b.gradient();
if (!gradient)
return 0;
QTransform inv = matrix.inverted();
QPointF page_rect[4] = { inv.map(QPointF(0, 0)),
inv.map(QPointF(width_, 0)),
inv.map(QPointF(0, height_)),
inv.map(QPointF(width_, height_)) };
bool opaque = b.isOpaque();
QByteArray shader;
QByteArray alphaShader;
if (gradient->type() == QGradient::LinearGradient) {
const QLinearGradient *lg = static_cast<const QLinearGradient *>(gradient);
shader = QPdf::generateLinearGradientShader(lg, page_rect);
if (!opaque)
alphaShader = QPdf::generateLinearGradientShader(lg, page_rect, true);
} else {
// #############
return 0;
}
int shaderObject = addXrefEntry(-1);
write(shader);
QByteArray str;
QPdf::ByteStream s(&str);
s << "<<\n"
"/Type /Pattern\n"
"/PatternType 2\n"
"/Shading " << shaderObject << "0 R\n"
"/Matrix ["
<< matrix.m11()
<< matrix.m12()
<< matrix.m21()
<< matrix.m22()
<< matrix.dx()
<< matrix.dy() << "]\n";
s << ">>\n"
"endobj\n";
int patternObj = addXrefEntry(-1);
write(str);
currentPage->patterns.append(patternObj);
if (!opaque) {
bool ca = true;
QGradientStops stops = gradient->stops();
int a = stops.at(0).second.alpha();
for (int i = 1; i < stops.size(); ++i) {
if (stops.at(i).second.alpha() != a) {
ca = false;
break;
}
}
if (ca) {
*gStateObject = addConstantAlphaObject(stops.at(0).second.alpha());
} else {
int alphaShaderObject = addXrefEntry(-1);
write(alphaShader);
QByteArray content;
QPdf::ByteStream c(&content);
c << "/Shader" << alphaShaderObject << "sh\n";
QByteArray form;
QPdf::ByteStream f(&form);
f << "<<\n"
"/Type /XObject\n"
"/Subtype /Form\n"
"/BBox [0 0 " << width_ << height_ << "]\n"
"/Group <</S /Transparency >>\n"
"/Resources <<\n"
"/Shading << /Shader" << alphaShaderObject << alphaShaderObject << "0 R >>\n"
">>\n";
f << "/Length " << content.length() << "\n"
">>\n"
"stream\n"
<< content
<< "endstream\n"
"endobj\n";
int softMaskFormObject = addXrefEntry(-1);
write(form);
*gStateObject = addXrefEntry(-1);
xprintf("<< /SMask << /S /Alpha /G %d 0 R >> >>\n"
"endobj\n", softMaskFormObject);
currentPage->graphicStates.append(*gStateObject);
}
}
return patternObj;
}
#endif
int QPdfEnginePrivate::addConstantAlphaObject(int brushAlpha, int penAlpha)
{
if (brushAlpha == 255 && penAlpha == 255)
return 0;
int object = alphaCache.value(QPair<uint, uint>(brushAlpha, penAlpha), 0);
if (!object) {
object = addXrefEntry(-1);
QByteArray alphaDef;
QPdf::ByteStream s(&alphaDef);
s << "<<\n/ca " << (brushAlpha/qreal(255.)) << '\n';
s << "/CA " << (penAlpha/qreal(255.)) << "\n>>";
xprintf("%s\nendobj\n", alphaDef.constData());
alphaCache.insert(QPair<uint, uint>(brushAlpha, penAlpha), object);
}
if (currentPage->graphicStates.indexOf(object) < 0)
currentPage->graphicStates.append(object);
return object;
}
int QPdfEnginePrivate::addBrushPattern(const QTransform &m, bool *specifyColor, int *gStateObject)
{
int paintType = 2; // Uncolored tiling
int w = 8;
int h = 8;
*specifyColor = true;
*gStateObject = 0;
QTransform matrix = m;
matrix.translate(brushOrigin.x(), brushOrigin.y());
matrix = matrix * pageMatrix();
//qDebug() << brushOrigin << matrix;
Qt::BrushStyle style = brush.style();
if (style == Qt::LinearGradientPattern) {// && style <= Qt::ConicalGradientPattern) {
#ifdef USE_NATIVE_GRADIENTS
*specifyColor = false;
return gradientBrush(b, matrix, gStateObject);
#else
return 0;
#endif
}
if ((!brush.isOpaque() && brush.style() < Qt::LinearGradientPattern) || opacity != 1.0)
*gStateObject = addConstantAlphaObject(qRound(brush.color().alpha() * opacity),
qRound(pen.color().alpha() * opacity));
int imageObject = -1;
QByteArray pattern = QPdf::patternForBrush(brush);
if (pattern.isEmpty()) {
if (brush.style() != Qt::TexturePattern)
return 0;
QImage image = brush.texture().toImage();
bool bitmap = true;
imageObject = addImage(image, &bitmap, qt_pixmap_id(brush.texture()));
if (imageObject != -1) {
QImage::Format f = image.format();
if (f != QImage::Format_MonoLSB && f != QImage::Format_Mono) {
paintType = 1; // Colored tiling
*specifyColor = false;
}
w = image.width();
h = image.height();
QTransform m(w, 0, 0, -h, 0, h);
QPdf::ByteStream s(&pattern);
s << QPdf::generateMatrix(m);
s << "/Im" << imageObject << " Do\n";
}
}
QByteArray str;
QPdf::ByteStream s(&str);
s << "<<\n"
"/Type /Pattern\n"
"/PatternType 1\n"
"/PaintType " << paintType << "\n"
"/TilingType 1\n"
"/BBox [0 0 " << w << h << "]\n"
"/XStep " << w << "\n"
"/YStep " << h << "\n"
"/Matrix ["
<< matrix.m11()
<< matrix.m12()
<< matrix.m21()
<< matrix.m22()
<< matrix.dx()
<< matrix.dy() << "]\n"
"/Resources \n<< "; // open resource tree
if (imageObject > 0) {
s << "/XObject << /Im" << imageObject << ' ' << imageObject << "0 R >> ";
}
s << ">>\n"
"/Length " << pattern.length() << "\n"
">>\n"
"stream\n"
<< pattern
<< "endstream\n"
"endobj\n";
int patternObj = addXrefEntry(-1);
write(str);
currentPage->patterns.append(patternObj);
return patternObj;
}
/*!
* Adds an image to the pdf and return the pdf-object id. Returns -1 if adding the image failed.
*/
int QPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, qint64 serial_no)
{
if (img.isNull())
return -1;
int object = imageCache.value(serial_no);
if(object)
return object;
QImage image = img;
QImage::Format format = image.format();
if (image.depth() == 1 && *bitmap && img.colorTable().size() == 0) {
if (format == QImage::Format_MonoLSB)
image = image.convertToFormat(QImage::Format_Mono);
format = QImage::Format_Mono;
} else {
*bitmap = false;
if (format != QImage::Format_RGB32 && format != QImage::Format_ARGB32) {
image = image.convertToFormat(QImage::Format_ARGB32);
format = QImage::Format_ARGB32;
}
}
int w = image.width();
int h = image.height();
int d = image.depth();
if (format == QImage::Format_Mono) {
int bytesPerLine = (w + 7) >> 3;
QByteArray data;
data.resize(bytesPerLine * h);
char *rawdata = data.data();
for (int y = 0; y < h; ++y) {
memcpy(rawdata, image.scanLine(y), bytesPerLine);
rawdata += bytesPerLine;
}
object = writeImage(data, w, h, d, 0, 0);
} else {
QByteArray softMaskData;
bool dct = false;
QByteArray imageData;
bool hasAlpha = false;
bool hasMask = false;
if (QImageWriter::supportedImageFormats().contains("jpeg") && colorMode != QPrinter::GrayScale) {
QBuffer buffer(&imageData);
QImageWriter writer(&buffer, "jpeg");
writer.setQuality(94);
writer.write(image);
dct = true;
if (format != QImage::Format_RGB32) {
softMaskData.resize(w * h);
uchar *sdata = (uchar *)softMaskData.data();
for (int y = 0; y < h; ++y) {
const QRgb *rgb = (const QRgb *)image.scanLine(y);
for (int x = 0; x < w; ++x) {
uchar alpha = qAlpha(*rgb);
*sdata++ = alpha;
hasMask |= (alpha < 255);
hasAlpha |= (alpha != 0 && alpha != 255);
++rgb;
}
}
}
} else {
imageData.resize(colorMode == QPrinter::GrayScale ? w * h : 3 * w * h);
uchar *data = (uchar *)imageData.data();
softMaskData.resize(w * h);
uchar *sdata = (uchar *)softMaskData.data();
for (int y = 0; y < h; ++y) {
const QRgb *rgb = (const QRgb *)image.scanLine(y);
if (colorMode == QPrinter::GrayScale) {
for (int x = 0; x < w; ++x) {
*(data++) = qGray(*rgb);
uchar alpha = qAlpha(*rgb);
*sdata++ = alpha;
hasMask |= (alpha < 255);
hasAlpha |= (alpha != 0 && alpha != 255);
++rgb;
}
} else {
for (int x = 0; x < w; ++x) {
*(data++) = qRed(*rgb);
*(data++) = qGreen(*rgb);
*(data++) = qBlue(*rgb);
uchar alpha = qAlpha(*rgb);
*sdata++ = alpha;
hasMask |= (alpha < 255);
hasAlpha |= (alpha != 0 && alpha != 255);
++rgb;
}
}
}
if (format == QImage::Format_RGB32)
hasAlpha = hasMask = false;
}
int maskObject = 0;
int softMaskObject = 0;
if (hasAlpha) {
softMaskObject = writeImage(softMaskData, w, h, 8, 0, 0);
} else if (hasMask) {
// dither the soft mask to 1bit and add it. This also helps PDF viewers
// without transparency support
int bytesPerLine = (w + 7) >> 3;
QByteArray mask(bytesPerLine * h, 0);
uchar *mdata = (uchar *)mask.data();
const uchar *sdata = (const uchar *)softMaskData.constData();
for (int y = 0; y < h; ++y) {
for (int x = 0; x < w; ++x) {
if (*sdata)
mdata[x>>3] |= (0x80 >> (x&7));
++sdata;
}
mdata += bytesPerLine;
}
maskObject = writeImage(mask, w, h, 1, 0, 0);
}
object = writeImage(imageData, w, h, colorMode == QPrinter::GrayScale ? 8 : 32,
maskObject, softMaskObject, dct);
}
imageCache.insert(serial_no, object);
return object;
}
void QPdfEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti)
{
if (ti.charFormat.isAnchor()) {
qreal size = ti.fontEngine->fontDef.pixelSize;
#ifdef Q_WS_WIN
if (ti.fontEngine->type() == QFontEngine::Win) {
QFontEngineWin *fe = static_cast<QFontEngineWin *>(ti.fontEngine);
size = fe->tm.tmHeight;
}
#endif
int synthesized = ti.fontEngine->synthesized();
qreal stretch = synthesized & QFontEngine::SynthesizedStretch ? ti.fontEngine->fontDef.stretch/100. : 1.;
QTransform trans;
// Build text rendering matrix (Trm). We need it to map the text area to user
// space units on the PDF page.
trans = QTransform(size*stretch, 0, 0, size, 0, 0);
// Apply text matrix (Tm).
trans *= QTransform(1,0,0,-1,p.x(),p.y());
// Apply page displacement (Identity for first page).
trans *= stroker.matrix;
// Apply Current Transformation Matrix (CTM)
trans *= pageMatrix();
qreal x1, y1, x2, y2;
trans.map(0, 0, &x1, &y1);
trans.map(ti.width.toReal()/size, (ti.ascent.toReal()-ti.descent.toReal())/size, &x2, &y2);
uint annot = addXrefEntry(-1);
#ifdef Q_DEBUG_PDF_LINKS
xprintf("<<\n/Type /Annot\n/Subtype /Link\n/Rect [%f %f %f %f]\n/Border [16 16 1]\n/A <<\n",
#else
xprintf("<<\n/Type /Annot\n/Subtype /Link\n/Rect [%f %f %f %f]\n/Border [0 0 0]\n/A <<\n",
#endif
static_cast<double>(x1),
static_cast<double>(y1),
static_cast<double>(x2),
static_cast<double>(y2));
xprintf("/Type /Action\n/S /URI\n/URI (%s)\n",
ti.charFormat.anchorHref().toLatin1().constData());
xprintf(">>\n>>\n");
xprintf("endobj\n");
if (!currentPage->annotations.contains(annot)) {
currentPage->annotations.append(annot);
}
}
QPdfBaseEnginePrivate::drawTextItem(p, ti);
}
QTransform QPdfEnginePrivate::pageMatrix() const
{
qreal scale = 72./resolution;
QTransform tmp(scale, 0.0, 0.0, -scale, 0.0, height());
if (!fullPage) {
QRect r = pageRect();
tmp.translate(r.left(), r.top());
}
return tmp;
}
void QPdfEnginePrivate::newPage()
{
if (currentPage && currentPage->pageSize.isEmpty())
currentPage->pageSize = QSize(width(), height());
writePage();
delete currentPage;
currentPage = new QPdfPage;
currentPage->pageSize = QSize(width(), height());
stroker.stream = currentPage;
pages.append(requestObject());
*currentPage << "/GSa gs /CSp cs /CSp CS\n"
<< QPdf::generateMatrix(pageMatrix())
<< "q q\n";
}
// For strings up to 10000 bytes only !
void QPdfEnginePrivate::xprintf(const char* fmt, ...)
{
if (!stream)
return;
const int msize = 10000;
char buf[msize];
va_list args;
va_start(args, fmt);
int bufsize = qvsnprintf(buf, msize, fmt, args);
Q_ASSERT(bufsize<msize);
va_end(args);
stream->writeRawData(buf, bufsize);
streampos += bufsize;
}
int QPdfEnginePrivate::writeCompressed(QIODevice *dev)
{
#ifndef QT_NO_COMPRESS
if (do_compress) {
int size = QPdfPage::chunkSize();
int sum = 0;
::z_stream zStruct;
zStruct.zalloc = Z_NULL;
zStruct.zfree = Z_NULL;
zStruct.opaque = Z_NULL;
if (::deflateInit(&zStruct, Z_DEFAULT_COMPRESSION) != Z_OK) {
qWarning("QPdfStream::writeCompressed: Error in deflateInit()");
return sum;
}
zStruct.avail_in = 0;
QByteArray in, out;
out.resize(size);
while (!dev->atEnd() || zStruct.avail_in != 0) {
if (zStruct.avail_in == 0) {
in = dev->read(size);
zStruct.avail_in = in.size();
zStruct.next_in = reinterpret_cast<unsigned char*>(in.data());
if (in.size() <= 0) {
qWarning("QPdfStream::writeCompressed: Error in read()");
::deflateEnd(&zStruct);
return sum;
}
}
zStruct.next_out = reinterpret_cast<unsigned char*>(out.data());
zStruct.avail_out = out.size();
if (::deflate(&zStruct, 0) != Z_OK) {
qWarning("QPdfStream::writeCompressed: Error in deflate()");
::deflateEnd(&zStruct);
return sum;
}
int written = out.size() - zStruct.avail_out;
stream->writeRawData(out.constData(), written);
streampos += written;
sum += written;
}
int ret;
do {
zStruct.next_out = reinterpret_cast<unsigned char*>(out.data());
zStruct.avail_out = out.size();
ret = ::deflate(&zStruct, Z_FINISH);
if (ret != Z_OK && ret != Z_STREAM_END) {
qWarning("QPdfStream::writeCompressed: Error in deflate()");
::deflateEnd(&zStruct);
return sum;
}
int written = out.size() - zStruct.avail_out;
stream->writeRawData(out.constData(), written);
streampos += written;
sum += written;
} while (ret == Z_OK);
::deflateEnd(&zStruct);
return sum;
} else
#endif
{
QByteArray arr;
int sum = 0;
while (!dev->atEnd()) {
arr = dev->read(QPdfPage::chunkSize());
stream->writeRawData(arr.constData(), arr.size());
streampos += arr.size();
sum += arr.size();
}
return sum;
}
}
int QPdfEnginePrivate::writeCompressed(const char *src, int len)
{
#ifndef QT_NO_COMPRESS
if(do_compress) {
uLongf destLen = len + len/100 + 13; // zlib requirement
Bytef* dest = new Bytef[destLen];
if (Z_OK == ::compress(dest, &destLen, (const Bytef*) src, (uLongf)len)) {
stream->writeRawData((const char*)dest, destLen);
} else {
qWarning("QPdfStream::writeCompressed: Error in compress()");
destLen = 0;
}
delete [] dest;
len = destLen;
} else
#endif
{
stream->writeRawData(src,len);
}
streampos += len;
return len;
}
int QPdfEnginePrivate::writeImage(const QByteArray &data, int width, int height, int depth,
int maskObject, int softMaskObject, bool dct)
{
int image = addXrefEntry(-1);
xprintf("<<\n"
"/Type /XObject\n"
"/Subtype /Image\n"
"/Width %d\n"
"/Height %d\n", width, height);
if (depth == 1) {
xprintf("/ImageMask true\n"
"/Decode [1 0]\n");
} else {
xprintf("/BitsPerComponent 8\n"
"/ColorSpace %s\n", (depth == 32) ? "/DeviceRGB" : "/DeviceGray");
}
if (maskObject > 0)
xprintf("/Mask %d 0 R\n", maskObject);
if (softMaskObject > 0)
xprintf("/SMask %d 0 R\n", softMaskObject);
int lenobj = requestObject();
xprintf("/Length %d 0 R\n", lenobj);
if (interpolateImages)
xprintf("/Interpolate true\n");
int len = 0;
if (dct) {
//qDebug() << "DCT";
xprintf("/Filter /DCTDecode\n>>\nstream\n");
write(data);
len = data.length();
} else {
if (do_compress)
xprintf("/Filter /FlateDecode\n>>\nstream\n");
else
xprintf(">>\nstream\n");
len = writeCompressed(data);
}
xprintf("endstream\n"
"endobj\n");
addXrefEntry(lenobj);
xprintf("%d\n"
"endobj\n", len);
return image;
}
void QPdfEnginePrivate::writeHeader()
{
addXrefEntry(0,false);
xprintf("%%PDF-1.4\n");
writeInfo();
catalog = addXrefEntry(-1);
pageRoot = requestObject();
xprintf("<<\n"
"/Type /Catalog\n"
"/Pages %d 0 R\n"
">>\n"
"endobj\n", pageRoot);
// graphics state
graphicsState = addXrefEntry(-1);
xprintf("<<\n"
"/Type /ExtGState\n"
"/SA true\n"
"/SM 0.02\n"
"/ca 1.0\n"
"/CA 1.0\n"
"/AIS false\n"
"/SMask /None"
">>\n"
"endobj\n");
// color space for pattern
patternColorSpace = addXrefEntry(-1);
xprintf("[/Pattern /DeviceRGB]\n"
"endobj\n");
}
void QPdfEnginePrivate::writeInfo()
{
info = addXrefEntry(-1);
xprintf("<<\n/Title ");
printString(title);
xprintf("\n/Creator ");
printString(creator);
xprintf("\n/Producer ");
printString(QString::fromLatin1("Qt " QT_VERSION_STR " (C) 2010 Nokia Corporation and/or its subsidiary(-ies)"));
QDateTime now = QDateTime::currentDateTime().toUTC();
QTime t = now.time();
QDate d = now.date();
xprintf("\n/CreationDate (D:%d%02d%02d%02d%02d%02d)\n",
d.year(),
d.month(),
d.day(),
t.hour(),
t.minute(),
t.second());
xprintf(">>\n"
"endobj\n");
}
void QPdfEnginePrivate::writePageRoot()
{
addXrefEntry(pageRoot);
xprintf("<<\n"
"/Type /Pages\n"
"/Kids \n"
"[\n");
int size = pages.size();
for (int i = 0; i < size; ++i)
xprintf("%d 0 R\n", pages[i]);
xprintf("]\n");
//xprintf("/Group <</S /Transparency /I true /K false>>\n");
xprintf("/Count %d\n", pages.size());
xprintf("/ProcSet [/PDF /Text /ImageB /ImageC]\n"
">>\n"
"endobj\n");
}
void QPdfEnginePrivate::embedFont(QFontSubset *font)
{
//qDebug() << "embedFont" << font->object_id;
int fontObject = font->object_id;
QByteArray fontData = font->toTruetype();
#ifdef FONT_DUMP
static int i = 0;
QString fileName("font%1.ttf");
fileName = fileName.arg(i++);
QFile ff(fileName);
ff.open(QFile::WriteOnly);
ff.write(fontData);
ff.close();
#endif
int fontDescriptor = requestObject();
int fontstream = requestObject();
int cidfont = requestObject();
int toUnicode = requestObject();
QFontEngine::Properties properties = font->fontEngine->properties();
{
qreal scale = 1000/properties.emSquare.toReal();
addXrefEntry(fontDescriptor);
QByteArray descriptor;
QPdf::ByteStream s(&descriptor);
s << "<< /Type /FontDescriptor\n"
"/FontName /Q";
int tag = fontDescriptor;
for (int i = 0; i < 5; ++i) {
s << (char)('A' + (tag % 26));
tag /= 26;
}
s << '+' << properties.postscriptName << "\n"
"/Flags " << 4 << "\n"
"/FontBBox ["
<< properties.boundingBox.x()*scale
<< -(properties.boundingBox.y() + properties.boundingBox.height())*scale
<< (properties.boundingBox.x() + properties.boundingBox.width())*scale
<< -properties.boundingBox.y()*scale << "]\n"
"/ItalicAngle " << properties.italicAngle.toReal() << "\n"
"/Ascent " << properties.ascent.toReal()*scale << "\n"
"/Descent " << -properties.descent.toReal()*scale << "\n"
"/CapHeight " << properties.capHeight.toReal()*scale << "\n"
"/StemV " << properties.lineWidth.toReal()*scale << "\n"
"/FontFile2 " << fontstream << "0 R\n"
">> endobj\n";
write(descriptor);
}
{
addXrefEntry(fontstream);
QByteArray header;
QPdf::ByteStream s(&header);
int length_object = requestObject();
s << "<<\n"
"/Length1 " << fontData.size() << "\n"
"/Length " << length_object << "0 R\n";
if (do_compress)
s << "/Filter /FlateDecode\n";
s << ">>\n"
"stream\n";
write(header);
int len = writeCompressed(fontData);
write("endstream\n"
"endobj\n");
addXrefEntry(length_object);
xprintf("%d\n"
"endobj\n", len);
}
{
addXrefEntry(cidfont);
QByteArray cid;
QPdf::ByteStream s(&cid);
s << "<< /Type /Font\n"
"/Subtype /CIDFontType2\n"
"/BaseFont /" << properties.postscriptName << "\n"
"/CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >>\n"
"/FontDescriptor " << fontDescriptor << "0 R\n"
"/CIDToGIDMap /Identity\n"
<< font->widthArray() <<
">>\n"
"endobj\n";
write(cid);
}
{
addXrefEntry(toUnicode);
QByteArray touc = font->createToUnicodeMap();
xprintf("<< /Length %d >>\n"
"stream\n", touc.length());
write(touc);
write("endstream\n"
"endobj\n");
}
{
addXrefEntry(fontObject);
QByteArray font;
QPdf::ByteStream s(&font);
s << "<< /Type /Font\n"
"/Subtype /Type0\n"
"/BaseFont /" << properties.postscriptName << "\n"
"/Encoding /Identity-H\n"
"/DescendantFonts [" << cidfont << "0 R]\n"
"/ToUnicode " << toUnicode << "0 R"
">>\n"
"endobj\n";
write(font);
}
}
void QPdfEnginePrivate::writeFonts()
{
for (QHash<QFontEngine::FaceId, QFontSubset *>::iterator it = fonts.begin(); it != fonts.end(); ++it) {
embedFont(*it);
delete *it;
}
fonts.clear();
}
void QPdfEnginePrivate::writePage()
{
if (pages.empty())
return;
*currentPage << "Q Q\n";
uint pageStream = requestObject();
uint pageStreamLength = requestObject();
uint resources = requestObject();
uint annots = requestObject();
addXrefEntry(pages.last());
xprintf("<<\n"
"/Type /Page\n"
"/Parent %d 0 R\n"
"/Contents %d 0 R\n"
"/Resources %d 0 R\n"
"/Annots %d 0 R\n"
"/MediaBox [0 0 %d %d]\n"
">>\n"
"endobj\n",
pageRoot, pageStream, resources, annots,
// make sure we use the pagesize from when we started the page, since the user may have changed it
currentPage->pageSize.width(), currentPage->pageSize.height());
addXrefEntry(resources);
xprintf("<<\n"
"/ColorSpace <<\n"
"/PCSp %d 0 R\n"
"/CSp /DeviceRGB\n"
"/CSpg /DeviceGray\n"
">>\n"
"/ExtGState <<\n"
"/GSa %d 0 R\n",
patternColorSpace, graphicsState);
for (int i = 0; i < currentPage->graphicStates.size(); ++i)
xprintf("/GState%d %d 0 R\n", currentPage->graphicStates.at(i), currentPage->graphicStates.at(i));
xprintf(">>\n");
xprintf("/Pattern <<\n");
for (int i = 0; i < currentPage->patterns.size(); ++i)
xprintf("/Pat%d %d 0 R\n", currentPage->patterns.at(i), currentPage->patterns.at(i));
xprintf(">>\n");
xprintf("/Font <<\n");
for (int i = 0; i < currentPage->fonts.size();++i)
xprintf("/F%d %d 0 R\n", currentPage->fonts[i], currentPage->fonts[i]);
xprintf(">>\n");
xprintf("/XObject <<\n");
for (int i = 0; i<currentPage->images.size(); ++i) {
xprintf("/Im%d %d 0 R\n", currentPage->images.at(i), currentPage->images.at(i));
}
xprintf(">>\n");
xprintf(">>\n"
"endobj\n");
addXrefEntry(annots);
xprintf("[ ");
for (int i = 0; i<currentPage->annotations.size(); ++i) {
xprintf("%d 0 R ", currentPage->annotations.at(i));
}
xprintf("]\nendobj\n");
addXrefEntry(pageStream);
xprintf("<<\n"
"/Length %d 0 R\n", pageStreamLength); // object number for stream length object
if (do_compress)
xprintf("/Filter /FlateDecode\n");
xprintf(">>\n");
xprintf("stream\n");
QIODevice *content = currentPage->stream();
int len = writeCompressed(content);
xprintf("endstream\n"
"endobj\n");
addXrefEntry(pageStreamLength);
xprintf("%d\nendobj\n",len);
}
void QPdfEnginePrivate::writeTail()
{
writePage();
writeFonts();
writePageRoot();
addXrefEntry(xrefPositions.size(),false);
xprintf("xref\n"
"0 %d\n"
"%010d 65535 f \n", xrefPositions.size()-1, xrefPositions[0]);
for (int i = 1; i < xrefPositions.size()-1; ++i)
xprintf("%010d 00000 n \n", xrefPositions[i]);
xprintf("trailer\n"
"<<\n"
"/Size %d\n"
"/Info %d 0 R\n"
"/Root %d 0 R\n"
">>\n"
"startxref\n%d\n"
"%%%%EOF\n",
xrefPositions.size()-1, info, catalog, xrefPositions.last());
}
int QPdfEnginePrivate::addXrefEntry(int object, bool printostr)
{
if (object < 0)
object = requestObject();
if (object>=xrefPositions.size())
xrefPositions.resize(object+1);
xrefPositions[object] = streampos;
if (printostr)
xprintf("%d 0 obj\n",object);
return object;
}
void QPdfEnginePrivate::printString(const QString &string) {
// The 'text string' type in PDF is encoded either as PDFDocEncoding, or
// Unicode UTF-16 with a Unicode byte order mark as the first character
// (0xfeff), with the high-order byte first.
QByteArray array("(\xfe\xff");
const ushort *utf16 = string.utf16();
for (int i=0; i < string.size(); ++i) {
char part[2] = {char((*(utf16 + i)) >> 8), char((*(utf16 + i)) & 0xff)};
for(int j=0; j < 2; ++j) {
if (part[j] == '(' || part[j] == ')' || part[j] == '\\')
array.append('\\');
array.append(part[j]);
}
}
array.append(")");
write(array);
}
QT_END_NAMESPACE
#endif // QT_NO_PRINTER