/****************************************************************************
**
** 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 "qplatformdefs.h"
#include <qdebug.h>
#include "qpdf_p.h"
#include <qfile.h>
#include <qtemporaryfile.h>
#include <private/qmath_p.h>
#include "private/qcups_p.h"
#include "qprinterinfo.h"
#include <qnumeric.h>
#ifdef Q_OS_UNIX
#include "private/qcore_unix_p.h" // overrides QT_OPEN
#endif
QT_BEGIN_NAMESPACE
Q_GUI_EXPORT extern int qt_defaultDpi();
#ifndef QT_NO_PRINTER
extern QSizeF qt_paperSizeToQSizeF(QPrinter::PaperSize size);
/* also adds a space at the end of the number */
const char *qt_real_to_string(qreal val, char *buf) {
const char *ret = buf;
if (qIsNaN(val)) {
*(buf++) = '0';
*(buf++) = ' ';
*buf = 0;
return ret;
}
if (val < 0) {
*(buf++) = '-';
val = -val;
}
unsigned int ival = (unsigned int) val;
qreal frac = val - (qreal)ival;
int ifrac = (int)(frac * 1000000000);
if (ifrac == 1000000000) {
++ival;
ifrac = 0;
}
char output[256];
int i = 0;
while (ival) {
output[i] = '0' + (ival % 10);
++i;
ival /= 10;
}
int fact = 100000000;
if (i == 0) {
*(buf++) = '0';
} else {
while (i) {
*(buf++) = output[--i];
fact /= 10;
ifrac /= 10;
}
}
if (ifrac) {
*(buf++) = '.';
while (fact) {
*(buf++) = '0' + ((ifrac/fact) % 10);
fact /= 10;
}
}
*(buf++) = ' ';
*buf = 0;
return ret;
}
const char *qt_int_to_string(int val, char *buf) {
const char *ret = buf;
if (val < 0) {
*(buf++) = '-';
val = -val;
}
char output[256];
int i = 0;
while (val) {
output[i] = '0' + (val % 10);
++i;
val /= 10;
}
if (i == 0) {
*(buf++) = '0';
} else {
while (i)
*(buf++) = output[--i];
}
*(buf++) = ' ';
*buf = 0;
return ret;
}
namespace QPdf {
ByteStream::ByteStream(QByteArray *byteArray, bool fileBacking)
: dev(new QBuffer(byteArray)),
fileBackingEnabled(fileBacking),
fileBackingActive(false),
handleDirty(false)
{
dev->open(QIODevice::ReadWrite | QIODevice::Append);
}
ByteStream::ByteStream(bool fileBacking)
: dev(new QBuffer(&ba)),
fileBackingEnabled(fileBacking),
fileBackingActive(false),
handleDirty(false)
{
dev->open(QIODevice::ReadWrite);
}
ByteStream::~ByteStream()
{
delete dev;
}
ByteStream &ByteStream::operator <<(char chr)
{
if (handleDirty) prepareBuffer();
dev->write(&chr, 1);
return *this;
}
ByteStream &ByteStream::operator <<(const char *str)
{
if (handleDirty) prepareBuffer();
dev->write(str, strlen(str));
return *this;
}
ByteStream &ByteStream::operator <<(const QByteArray &str)
{
if (handleDirty) prepareBuffer();
dev->write(str);
return *this;
}
ByteStream &ByteStream::operator <<(const ByteStream &src)
{
Q_ASSERT(!src.dev->isSequential());
if (handleDirty) prepareBuffer();
// We do play nice here, even though it looks ugly.
// We save the position and restore it afterwards.
ByteStream &s = const_cast<ByteStream&>(src);
qint64 pos = s.dev->pos();
s.dev->reset();
while (!s.dev->atEnd()) {
QByteArray buf = s.dev->read(chunkSize());
dev->write(buf);
}
s.dev->seek(pos);
return *this;
}
ByteStream &ByteStream::operator <<(qreal val) {
char buf[256];
qt_real_to_string(val, buf);
*this << buf;
return *this;
}
ByteStream &ByteStream::operator <<(int val) {
char buf[256];
qt_int_to_string(val, buf);
*this << buf;
return *this;
}
ByteStream &ByteStream::operator <<(const QPointF &p) {
char buf[256];
qt_real_to_string(p.x(), buf);
*this << buf;
qt_real_to_string(p.y(), buf);
*this << buf;
return *this;
}
QIODevice *ByteStream::stream()
{
dev->reset();
handleDirty = true;
return dev;
}
void ByteStream::clear()
{
dev->open(QIODevice::ReadWrite | QIODevice::Truncate);
}
void ByteStream::constructor_helper(QByteArray *ba)
{
delete dev;
dev = new QBuffer(ba);
dev->open(QIODevice::ReadWrite);
}
void ByteStream::prepareBuffer()
{
Q_ASSERT(!dev->isSequential());
qint64 size = dev->size();
if (fileBackingEnabled && !fileBackingActive
&& size > maxMemorySize()) {
// Switch to file backing.
QTemporaryFile *newFile = new QTemporaryFile;
newFile->open();
dev->reset();
while (!dev->atEnd()) {
QByteArray buf = dev->read(chunkSize());
newFile->write(buf);
}
delete dev;
dev = newFile;
ba.clear();
fileBackingActive = true;
}
if (dev->pos() != size) {
dev->seek(size);
handleDirty = false;
}
}
}
#define QT_PATH_ELEMENT(elm)
QByteArray QPdf::generatePath(const QPainterPath &path, const QTransform &matrix, PathFlags flags)
{
QByteArray result;
if (!path.elementCount())
return result;
ByteStream s(&result);
int start = -1;
for (int i = 0; i < path.elementCount(); ++i) {
const QPainterPath::Element &elm = path.elementAt(i);
switch (elm.type) {
case QPainterPath::MoveToElement:
if (start >= 0
&& path.elementAt(start).x == path.elementAt(i-1).x
&& path.elementAt(start).y == path.elementAt(i-1).y)
s << "h\n";
s << matrix.map(QPointF(elm.x, elm.y)) << "m\n";
start = i;
break;
case QPainterPath::LineToElement:
s << matrix.map(QPointF(elm.x, elm.y)) << "l\n";
break;
case QPainterPath::CurveToElement:
Q_ASSERT(path.elementAt(i+1).type == QPainterPath::CurveToDataElement);
Q_ASSERT(path.elementAt(i+2).type == QPainterPath::CurveToDataElement);
s << matrix.map(QPointF(elm.x, elm.y))
<< matrix.map(QPointF(path.elementAt(i+1).x, path.elementAt(i+1).y))
<< matrix.map(QPointF(path.elementAt(i+2).x, path.elementAt(i+2).y))
<< "c\n";
i += 2;
break;
default:
qFatal("QPdf::generatePath(), unhandled type: %d", elm.type);
}
}
if (start >= 0
&& path.elementAt(start).x == path.elementAt(path.elementCount()-1).x
&& path.elementAt(start).y == path.elementAt(path.elementCount()-1).y)
s << "h\n";
Qt::FillRule fillRule = path.fillRule();
const char *op = "";
switch (flags) {
case ClipPath:
op = (fillRule == Qt::WindingFill) ? "W n\n" : "W* n\n";
break;
case FillPath:
op = (fillRule == Qt::WindingFill) ? "f\n" : "f*\n";
break;
case StrokePath:
op = "S\n";
break;
case FillAndStrokePath:
op = (fillRule == Qt::WindingFill) ? "B\n" : "B*\n";
break;
}
s << op;
return result;
}
QByteArray QPdf::generateMatrix(const QTransform &matrix)
{
QByteArray result;
ByteStream s(&result);
s << matrix.m11()
<< matrix.m12()
<< matrix.m21()
<< matrix.m22()
<< matrix.dx()
<< matrix.dy()
<< "cm\n";
return result;
}
QByteArray QPdf::generateDashes(const QPen &pen)
{
QByteArray result;
ByteStream s(&result);
s << '[';
QVector<qreal> dasharray = pen.dashPattern();
qreal w = pen.widthF();
if (w < 0.001)
w = 1;
for (int i = 0; i < dasharray.size(); ++i) {
qreal dw = dasharray.at(i)*w;
if (dw < 0.0001) dw = 0.0001;
s << dw;
}
s << ']';
//qDebug() << "dasharray: pen has" << dasharray;
//qDebug() << " => " << result;
return result;
}
static const char* pattern_for_brush[] = {
0, // NoBrush
0, // SolidPattern
"0 J\n"
"6 w\n"
"[] 0 d\n"
"4 0 m\n"
"4 8 l\n"
"0 4 m\n"
"8 4 l\n"
"S\n", // Dense1Pattern
"0 J\n"
"2 w\n"
"[6 2] 1 d\n"
"0 0 m\n"
"0 8 l\n"
"8 0 m\n"
"8 8 l\n"
"S\n"
"[] 0 d\n"
"2 0 m\n"
"2 8 l\n"
"6 0 m\n"
"6 8 l\n"
"S\n"
"[6 2] -3 d\n"
"4 0 m\n"
"4 8 l\n"
"S\n", // Dense2Pattern
"0 J\n"
"2 w\n"
"[6 2] 1 d\n"
"0 0 m\n"
"0 8 l\n"
"8 0 m\n"
"8 8 l\n"
"S\n"
"[2 2] -1 d\n"
"2 0 m\n"
"2 8 l\n"
"6 0 m\n"
"6 8 l\n"
"S\n"
"[6 2] -3 d\n"
"4 0 m\n"
"4 8 l\n"
"S\n", // Dense3Pattern
"0 J\n"
"2 w\n"
"[2 2] 1 d\n"
"0 0 m\n"
"0 8 l\n"
"8 0 m\n"
"8 8 l\n"
"S\n"
"[2 2] -1 d\n"
"2 0 m\n"
"2 8 l\n"
"6 0 m\n"
"6 8 l\n"
"S\n"
"[2 2] 1 d\n"
"4 0 m\n"
"4 8 l\n"
"S\n", // Dense4Pattern
"0 J\n"
"2 w\n"
"[2 6] -1 d\n"
"0 0 m\n"
"0 8 l\n"
"8 0 m\n"
"8 8 l\n"
"S\n"
"[2 2] 1 d\n"
"2 0 m\n"
"2 8 l\n"
"6 0 m\n"
"6 8 l\n"
"S\n"
"[2 6] 3 d\n"
"4 0 m\n"
"4 8 l\n"
"S\n", // Dense5Pattern
"0 J\n"
"2 w\n"
"[2 6] -1 d\n"
"0 0 m\n"
"0 8 l\n"
"8 0 m\n"
"8 8 l\n"
"S\n"
"[2 6] 3 d\n"
"4 0 m\n"
"4 8 l\n"
"S\n", // Dense6Pattern
"0 J\n"
"2 w\n"
"[2 6] -1 d\n"
"0 0 m\n"
"0 8 l\n"
"8 0 m\n"
"8 8 l\n"
"S\n", // Dense7Pattern
"1 w\n"
"0 4 m\n"
"8 4 l\n"
"S\n", // HorPattern
"1 w\n"
"4 0 m\n"
"4 8 l\n"
"S\n", // VerPattern
"1 w\n"
"4 0 m\n"
"4 8 l\n"
"0 4 m\n"
"8 4 l\n"
"S\n", // CrossPattern
"1 w\n"
"-1 5 m\n"
"5 -1 l\n"
"3 9 m\n"
"9 3 l\n"
"S\n", // BDiagPattern
"1 w\n"
"-1 3 m\n"
"5 9 l\n"
"3 -1 m\n"
"9 5 l\n"
"S\n", // FDiagPattern
"1 w\n"
"-1 3 m\n"
"5 9 l\n"
"3 -1 m\n"
"9 5 l\n"
"-1 5 m\n"
"5 -1 l\n"
"3 9 m\n"
"9 3 l\n"
"S\n", // DiagCrossPattern
};
QByteArray QPdf::patternForBrush(const QBrush &b)
{
int style = b.style();
if (style > Qt::DiagCrossPattern)
return QByteArray();
return pattern_for_brush[style];
}
#ifdef USE_NATIVE_GRADIENTS
static void writeTriangleLine(uchar *&data, int xpos, int ypos, int xoff, int yoff, uint rgb, uchar flag, bool alpha)
{
data[0] = flag;
data[1] = (uchar)(xpos >> 16);
data[2] = (uchar)(xpos >> 8);
data[3] = (uchar)(xpos >> 0);
data[4] = (uchar)(ypos >> 16);
data[5] = (uchar)(ypos >> 8);
data[6] = (uchar)(ypos >> 0);
data += 7;
if (alpha) {
*data++ = (uchar)qAlpha(rgb);
} else {
*data++ = (uchar)qRed(rgb);
*data++ = (uchar)qGreen(rgb);
*data++ = (uchar)qBlue(rgb);
}
xpos += xoff;
ypos += yoff;
data[0] = flag;
data[1] = (uchar)(xpos >> 16);
data[2] = (uchar)(xpos >> 8);
data[3] = (uchar)(xpos >> 0);
data[4] = (uchar)(ypos >> 16);
data[5] = (uchar)(ypos >> 8);
data[6] = (uchar)(ypos >> 0);
data += 7;
if (alpha) {
*data++ = (uchar)qAlpha(rgb);
} else {
*data++ = (uchar)qRed(rgb);
*data++ = (uchar)qGreen(rgb);
*data++ = (uchar)qBlue(rgb);
}
}
QByteArray QPdf::generateLinearGradientShader(const QLinearGradient *gradient, const QPointF *page_rect, bool alpha)
{
// generate list of triangles with colors
QPointF start = gradient->start();
QPointF stop = gradient->finalStop();
QGradientStops stops = gradient->stops();
QPointF offset = stop - start;
QGradient::Spread spread = gradient->spread();
if (gradient->spread() == QGradient::ReflectSpread) {
offset *= 2;
for (int i = stops.size() - 2; i >= 0; --i) {
QGradientStop stop = stops.at(i);
stop.first = 2. - stop.first;
stops.append(stop);
}
for (int i = 0 ; i < stops.size(); ++i)
stops[i].first /= 2.;
}
QPointF orthogonal(offset.y(), -offset.x());
qreal length = offset.x()*offset.x() + offset.y()*offset.y();
// find the max and min values in offset and orth direction that are needed to cover
// the whole page
int off_min = INT_MAX;
int off_max = INT_MIN;
qreal ort_min = INT_MAX;
qreal ort_max = INT_MIN;
for (int i = 0; i < 4; ++i) {
qreal off = ((page_rect[i].x() - start.x()) * offset.x() + (page_rect[i].y() - start.y()) * offset.y())/length;
qreal ort = ((page_rect[i].x() - start.x()) * orthogonal.x() + (page_rect[i].y() - start.y()) * orthogonal.y())/length;
off_min = qMin(off_min, qFloor(off));
off_max = qMax(off_max, qCeil(off));
ort_min = qMin(ort_min, ort);
ort_max = qMax(ort_max, ort);
}
ort_min -= 1;
ort_max += 1;
start += off_min * offset + ort_min * orthogonal;
orthogonal *= (ort_max - ort_min);
int num = off_max - off_min;
QPointF gradient_rect[4] = { start,
start + orthogonal,
start + num*offset,
start + num*offset + orthogonal };
qreal xmin = gradient_rect[0].x();
qreal xmax = gradient_rect[0].x();
qreal ymin = gradient_rect[0].y();
qreal ymax = gradient_rect[0].y();
for (int i = 1; i < 4; ++i) {
xmin = qMin(xmin, gradient_rect[i].x());
xmax = qMax(xmax, gradient_rect[i].x());
ymin = qMin(ymin, gradient_rect[i].y());
ymax = qMax(ymax, gradient_rect[i].y());
}
xmin -= 1000;
xmax += 1000;
ymin -= 1000;
ymax += 1000;
start -= QPointF(xmin, ymin);
qreal factor_x = qreal(1<<24)/(xmax - xmin);
qreal factor_y = qreal(1<<24)/(ymax - ymin);
int xoff = (int)(orthogonal.x()*factor_x);
int yoff = (int)(orthogonal.y()*factor_y);
QByteArray triangles;
triangles.resize(spread == QGradient::PadSpread ? 20*(stops.size()+2) : 20*num*stops.size());
uchar *data = (uchar *) triangles.data();
if (spread == QGradient::PadSpread) {
if (off_min > 0 || off_max < 1) {
// linear gradient outside of page
const QGradientStop ¤t_stop = off_min > 0 ? stops.at(stops.size()-1) : stops.at(0);
uint rgb = current_stop.second.rgba();
int xpos = (int)(start.x()*factor_x);
int ypos = (int)(start.y()*factor_y);
writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, 0, alpha);
start += num*offset;
xpos = (int)(start.x()*factor_x);
ypos = (int)(start.y()*factor_y);
writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, 1, alpha);
} else {
int flag = 0;
if (off_min < 0) {
uint rgb = stops.at(0).second.rgba();
int xpos = (int)(start.x()*factor_x);
int ypos = (int)(start.y()*factor_y);
writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);
start -= off_min*offset;
flag = 1;
}
for (int s = 0; s < stops.size(); ++s) {
const QGradientStop ¤t_stop = stops.at(s);
uint rgb = current_stop.second.rgba();
int xpos = (int)(start.x()*factor_x);
int ypos = (int)(start.y()*factor_y);
writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);
if (s < stops.size()-1)
start += offset*(stops.at(s+1).first - stops.at(s).first);
flag = 1;
}
if (off_max > 1) {
start += (off_max - 1)*offset;
uint rgb = stops.at(stops.size()-1).second.rgba();
int xpos = (int)(start.x()*factor_x);
int ypos = (int)(start.y()*factor_y);
writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);
}
}
} else {
for (int i = 0; i < num; ++i) {
uchar flag = 0;
for (int s = 0; s < stops.size(); ++s) {
uint rgb = stops.at(s).second.rgba();
int xpos = (int)(start.x()*factor_x);
int ypos = (int)(start.y()*factor_y);
writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);
if (s < stops.size()-1)
start += offset*(stops.at(s+1).first - stops.at(s).first);
flag = 1;
}
}
}
triangles.resize((char *)data - triangles.constData());
QByteArray shader;
QPdf::ByteStream s(&shader);
s << "<<\n"
"/ShadingType 4\n"
"/ColorSpace " << (alpha ? "/DeviceGray\n" : "/DeviceRGB\n") <<
"/AntiAlias true\n"
"/BitsPerCoordinate 24\n"
"/BitsPerComponent 8\n"
"/BitsPerFlag 8\n"
"/Decode [" << xmin << xmax << ymin << ymax << (alpha ? "0 1]\n" : "0 1 0 1 0 1]\n") <<
"/AntiAlias true\n"
"/Length " << triangles.length() << "\n"
">>\n"
"stream\n" << triangles << "endstream\n"
"endobj\n";
return shader;
}
#endif
static void moveToHook(qfixed x, qfixed y, void *data)
{
QPdf::Stroker *t = (QPdf::Stroker *)data;
if (!t->first)
*t->stream << "h\n";
if (!t->cosmeticPen)
t->matrix.map(x, y, &x, &y);
*t->stream << x << y << "m\n";
t->first = false;
}
static void lineToHook(qfixed x, qfixed y, void *data)
{
QPdf::Stroker *t = (QPdf::Stroker *)data;
if (!t->cosmeticPen)
t->matrix.map(x, y, &x, &y);
*t->stream << x << y << "l\n";
}
static void cubicToHook(qfixed c1x, qfixed c1y,
qfixed c2x, qfixed c2y,
qfixed ex, qfixed ey,
void *data)
{
QPdf::Stroker *t = (QPdf::Stroker *)data;
if (!t->cosmeticPen) {
t->matrix.map(c1x, c1y, &c1x, &c1y);
t->matrix.map(c2x, c2y, &c2x, &c2y);
t->matrix.map(ex, ey, &ex, &ey);
}
*t->stream << c1x << c1y
<< c2x << c2y
<< ex << ey
<< "c\n";
}
QPdf::Stroker::Stroker()
: stream(0),
first(true),
dashStroker(&basicStroker)
{
stroker = &basicStroker;
basicStroker.setMoveToHook(moveToHook);
basicStroker.setLineToHook(lineToHook);
basicStroker.setCubicToHook(cubicToHook);
cosmeticPen = true;
basicStroker.setStrokeWidth(.1);
}
void QPdf::Stroker::setPen(const QPen &pen)
{
if (pen.style() == Qt::NoPen) {
stroker = 0;
return;
}
qreal w = pen.widthF();
bool zeroWidth = w < 0.0001;
cosmeticPen = pen.isCosmetic();
if (zeroWidth)
w = .1;
basicStroker.setStrokeWidth(w);
basicStroker.setCapStyle(pen.capStyle());
basicStroker.setJoinStyle(pen.joinStyle());
basicStroker.setMiterLimit(pen.miterLimit());
QVector<qreal> dashpattern = pen.dashPattern();
if (zeroWidth) {
for (int i = 0; i < dashpattern.size(); ++i)
dashpattern[i] *= 10.;
}
if (!dashpattern.isEmpty()) {
dashStroker.setDashPattern(dashpattern);
dashStroker.setDashOffset(pen.dashOffset());
stroker = &dashStroker;
} else {
stroker = &basicStroker;
}
}
void QPdf::Stroker::strokePath(const QPainterPath &path)
{
if (!stroker)
return;
first = true;
stroker->strokePath(path, this, cosmeticPen ? matrix : QTransform());
*stream << "h f\n";
}
QByteArray QPdf::ascii85Encode(const QByteArray &input)
{
int isize = input.size()/4*4;
QByteArray output;
output.resize(input.size()*5/4+7);
char *out = output.data();
const uchar *in = (const uchar *)input.constData();
for (int i = 0; i < isize; i += 4) {
uint val = (((uint)in[i])<<24) + (((uint)in[i+1])<<16) + (((uint)in[i+2])<<8) + (uint)in[i+3];
if (val == 0) {
*out = 'z';
++out;
} else {
char base[5];
base[4] = val % 85;
val /= 85;
base[3] = val % 85;
val /= 85;
base[2] = val % 85;
val /= 85;
base[1] = val % 85;
val /= 85;
base[0] = val % 85;
*(out++) = base[0] + '!';
*(out++) = base[1] + '!';
*(out++) = base[2] + '!';
*(out++) = base[3] + '!';
*(out++) = base[4] + '!';
}
}
//write the last few bytes
int remaining = input.size() - isize;
if (remaining) {
uint val = 0;
for (int i = isize; i < input.size(); ++i)
val = (val << 8) + in[i];
val <<= 8*(4-remaining);
char base[5];
base[4] = val % 85;
val /= 85;
base[3] = val % 85;
val /= 85;
base[2] = val % 85;
val /= 85;
base[1] = val % 85;
val /= 85;
base[0] = val % 85;
for (int i = 0; i < remaining+1; ++i)
*(out++) = base[i] + '!';
}
*(out++) = '~';
*(out++) = '>';
output.resize(out-output.data());
return output;
}
const char *QPdf::toHex(ushort u, char *buffer)
{
int i = 3;
while (i >= 0) {
ushort hex = (u & 0x000f);
if (hex < 0x0a)
buffer[i] = '0'+hex;
else
buffer[i] = 'A'+(hex-0x0a);
u = u >> 4;
i--;
}
buffer[4] = '\0';
return buffer;
}
const char *QPdf::toHex(uchar u, char *buffer)
{
int i = 1;
while (i >= 0) {
ushort hex = (u & 0x000f);
if (hex < 0x0a)
buffer[i] = '0'+hex;
else
buffer[i] = 'A'+(hex-0x0a);
u = u >> 4;
i--;
}
buffer[2] = '\0';
return buffer;
}
#define Q_MM(n) int((n * 720 + 127) / 254)
#define Q_IN(n) int(n * 72)
static const char * const psToStr[QPrinter::NPaperSize+1] =
{
"A4", "B5", "Letter", "Legal", "Executive",
"A0", "A1", "A2", "A3", "A5", "A6", "A7", "A8", "A9", "B0", "B1",
"B10", "B2", "B3", "B4", "B6", "B7", "B8", "B9", "C5E", "Comm10E",
"DLE", "Folio", "Ledger", "Tabloid", 0
};
QPdf::PaperSize QPdf::paperSize(QPrinter::PaperSize paperSize)
{
QSizeF s = qt_paperSizeToQSizeF(paperSize);
PaperSize p = { Q_MM(s.width()), Q_MM(s.height()) };
return p;
}
const char *QPdf::paperSizeToString(QPrinter::PaperSize paperSize)
{
return psToStr[paperSize];
}
QByteArray QPdf::stripSpecialCharacters(const QByteArray &string)
{
QByteArray s = string;
s.replace(' ', "");
s.replace('(', "");
s.replace(')', "");
s.replace('<', "");
s.replace('>', "");
s.replace('[', "");
s.replace(']', "");
s.replace('{', "");
s.replace('}', "");
s.replace('/', "");
s.replace('%', "");
return s;
}
// -------------------------- base engine, shared code between PS and PDF -----------------------
QPdfBaseEngine::QPdfBaseEngine(QPdfBaseEnginePrivate &dd, PaintEngineFeatures f)
: QAlphaPaintEngine(dd, f)
{
Q_D(QPdfBaseEngine);
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
if (QCUPSSupport::isAvailable()) {
QCUPSSupport cups;
const cups_dest_t* printers = cups.availablePrinters();
int prnCount = cups.availablePrintersCount();
for (int i = 0; i < prnCount; ++i) {
if (printers[i].is_default) {
d->printerName = QString::fromLocal8Bit(printers[i].name);
break;
}
}
} else
#endif
{
d->printerName = QString::fromLocal8Bit(qgetenv("PRINTER"));
if (d->printerName.isEmpty())
d->printerName = QString::fromLocal8Bit(qgetenv("LPDEST"));
if (d->printerName.isEmpty())
d->printerName = QString::fromLocal8Bit(qgetenv("NPRINTER"));
if (d->printerName.isEmpty())
d->printerName = QString::fromLocal8Bit(qgetenv("NGPRINTER"));
}
}
void QPdfBaseEngine::drawPoints (const QPointF *points, int pointCount)
{
if (!points)
return;
QPainterPath p;
for (int i=0; i!=pointCount;++i) {
p.moveTo(points[i]);
p.lineTo(points[i] + QPointF(0, 0.001));
}
drawPath(p);
}
void QPdfBaseEngine::drawLines (const QLineF *lines, int lineCount)
{
if (!lines)
return;
QPainterPath p;
for (int i=0; i!=lineCount;++i) {
p.moveTo(lines[i].p1());
p.lineTo(lines[i].p2());
}
drawPath(p);
}
void QPdfBaseEngine::drawRects (const QRectF *rects, int rectCount)
{
if (!rects)
return;
Q_D(QPdfBaseEngine);
if (d->useAlphaEngine) {
QAlphaPaintEngine::drawRects(rects, rectCount);
if (!continueCall())
return;
}
if (d->clipEnabled && d->allClipped)
return;
if (!d->hasPen && !d->hasBrush)
return;
QBrush penBrush = d->pen.brush();
if (d->simplePen || !d->hasPen) {
// draw strokes natively in this case for better output
if(!d->simplePen && !d->stroker.matrix.isIdentity())
*d->currentPage << "q\n" << QPdf::generateMatrix(d->stroker.matrix);
for (int i = 0; i < rectCount; ++i)
*d->currentPage << rects[i].x() << rects[i].y() << rects[i].width() << rects[i].height() << "re\n";
*d->currentPage << (d->hasPen ? (d->hasBrush ? "B\n" : "S\n") : "f\n");
if(!d->simplePen && !d->stroker.matrix.isIdentity())
*d->currentPage << "Q\n";
} else {
QPainterPath p;
for (int i=0; i!=rectCount; ++i)
p.addRect(rects[i]);
drawPath(p);
}
}
void QPdfBaseEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
{
Q_D(QPdfBaseEngine);
if (d->useAlphaEngine) {
QAlphaPaintEngine::drawPolygon(points, pointCount, mode);
if (!continueCall())
return;
}
if (!points || !pointCount)
return;
bool hb = d->hasBrush;
QPainterPath p;
switch(mode) {
case OddEvenMode:
p.setFillRule(Qt::OddEvenFill);
break;
case ConvexMode:
case WindingMode:
p.setFillRule(Qt::WindingFill);
break;
case PolylineMode:
d->hasBrush = false;
break;
default:
break;
}
p.moveTo(points[0]);
for (int i = 1; i < pointCount; ++i)
p.lineTo(points[i]);
if (mode != PolylineMode)
p.closeSubpath();
drawPath(p);
d->hasBrush = hb;
}
void QPdfBaseEngine::drawPath (const QPainterPath &p)
{
Q_D(QPdfBaseEngine);
if (d->useAlphaEngine) {
QAlphaPaintEngine::drawPath(p);
if (!continueCall())
return;
}
if (d->clipEnabled && d->allClipped)
return;
if (!d->hasPen && !d->hasBrush)
return;
if (d->simplePen) {
// draw strokes natively in this case for better output
*d->currentPage << QPdf::generatePath(p, QTransform(), d->hasBrush ? QPdf::FillAndStrokePath : QPdf::StrokePath);
} else {
if (d->hasBrush)
*d->currentPage << QPdf::generatePath(p, d->stroker.matrix, QPdf::FillPath);
if (d->hasPen) {
*d->currentPage << "q\n";
QBrush b = d->brush;
d->brush = d->pen.brush();
setBrush();
d->stroker.strokePath(p);
*d->currentPage << "Q\n";
d->brush = b;
}
}
}
void QPdfBaseEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
{
Q_D(QPdfBaseEngine);
if (d->useAlphaEngine) {
QAlphaPaintEngine::drawTextItem(p, textItem);
if (!continueCall())
return;
}
if (!d->hasPen || (d->clipEnabled && d->allClipped))
return;
if (d->stroker.matrix.type() >= QTransform::TxProject) {
QPaintEngine::drawTextItem(p, textItem);
return;
}
*d->currentPage << "q\n";
if(!d->simplePen)
*d->currentPage << QPdf::generateMatrix(d->stroker.matrix);
bool hp = d->hasPen;
d->hasPen = false;
QBrush b = d->brush;
d->brush = d->pen.brush();
setBrush();
const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
Q_ASSERT(ti.fontEngine->type() != QFontEngine::Multi);
d->drawTextItem(p, ti);
d->hasPen = hp;
d->brush = b;
*d->currentPage << "Q\n";
}
void QPdfBaseEngine::updateState(const QPaintEngineState &state)
{
Q_D(QPdfBaseEngine);
if (d->useAlphaEngine) {
QAlphaPaintEngine::updateState(state);
if (!continueCall())
return;
}
QPaintEngine::DirtyFlags flags = state.state();
if (flags & DirtyTransform)
d->stroker.matrix = state.transform();
if (flags & DirtyPen) {
d->pen = state.pen();
d->hasPen = d->pen.style() != Qt::NoPen;
d->stroker.setPen(d->pen);
QBrush penBrush = d->pen.brush();
bool oldSimple = d->simplePen;
d->simplePen = (d->hasPen && (penBrush.style() == Qt::SolidPattern) && penBrush.isOpaque());
if (oldSimple != d->simplePen)
flags |= DirtyTransform;
}
if (flags & DirtyBrush) {
d->brush = state.brush();
d->hasBrush = d->brush.style() != Qt::NoBrush;
}
if (flags & DirtyBrushOrigin) {
d->brushOrigin = state.brushOrigin();
flags |= DirtyBrush;
}
if (flags & DirtyOpacity)
d->opacity = state.opacity();
bool ce = d->clipEnabled;
if (flags & DirtyClipPath) {
d->clipEnabled = true;
updateClipPath(state.clipPath(), state.clipOperation());
} else if (flags & DirtyClipRegion) {
d->clipEnabled = true;
QPainterPath path;
QVector<QRect> rects = state.clipRegion().rects();
for (int i = 0; i < rects.size(); ++i)
path.addRect(rects.at(i));
updateClipPath(path, state.clipOperation());
flags |= DirtyClipPath;
} else if (flags & DirtyClipEnabled) {
d->clipEnabled = state.isClipEnabled();
}
if (ce != d->clipEnabled)
flags |= DirtyClipPath;
else if (!d->clipEnabled)
flags &= ~DirtyClipPath;
setupGraphicsState(flags);
}
void QPdfBaseEngine::setupGraphicsState(QPaintEngine::DirtyFlags flags)
{
Q_D(QPdfBaseEngine);
if (flags & DirtyClipPath)
flags |= DirtyTransform|DirtyPen|DirtyBrush;
if (flags & DirtyTransform) {
*d->currentPage << "Q\n";
flags |= DirtyPen|DirtyBrush;
}
if (flags & DirtyClipPath) {
*d->currentPage << "Q q\n";
d->allClipped = false;
if (d->clipEnabled && !d->clips.isEmpty()) {
for (int i = 0; i < d->clips.size(); ++i) {
if (d->clips.at(i).isEmpty()) {
d->allClipped = true;
break;
}
}
if (!d->allClipped) {
for (int i = 0; i < d->clips.size(); ++i) {
*d->currentPage << QPdf::generatePath(d->clips.at(i), QTransform(), QPdf::ClipPath);
}
}
}
}
if (flags & DirtyTransform) {
*d->currentPage << "q\n";
if (d->simplePen && !d->stroker.matrix.isIdentity())
*d->currentPage << QPdf::generateMatrix(d->stroker.matrix);
}
if (flags & DirtyBrush)
setBrush();
if (d->simplePen && (flags & DirtyPen))
setPen();
}
extern QPainterPath qt_regionToPath(const QRegion ®ion);
void QPdfBaseEngine::updateClipPath(const QPainterPath &p, Qt::ClipOperation op)
{
Q_D(QPdfBaseEngine);
QPainterPath path = d->stroker.matrix.map(p);
//qDebug() << "updateClipPath: " << d->stroker.matrix << p.boundingRect() << path.boundingRect() << op;
if (op == Qt::NoClip) {
d->clipEnabled = false;
d->clips.clear();
} else if (op == Qt::ReplaceClip) {
d->clips.clear();
d->clips.append(path);
} else if (op == Qt::IntersectClip) {
d->clips.append(path);
} else { // UniteClip
// ask the painter for the current clipping path. that's the easiest solution
path = painter()->clipPath();
path = d->stroker.matrix.map(path);
d->clips.clear();
d->clips.append(path);
}
if (d->useAlphaEngine) {
// if we have an alpha region, we have to subtract that from the
// any existing clip region since that region will be filled in
// later with images
QPainterPath alphaClip = qt_regionToPath(alphaClipping());
if (!alphaClip.isEmpty()) {
if (!d->clipEnabled) {
QRect r = d->fullPage ? d->paperRect() : d->pageRect();
QPainterPath dev;
dev.addRect(QRect(0, 0, r.width(), r.height()));
if (path.isEmpty())
path = dev;
else
path = path.intersected(dev);
d->clipEnabled = true;
} else {
path = painter()->clipPath();
path = d->stroker.matrix.map(path);
}
path = path.subtracted(alphaClip);
d->clips.clear();
d->clips.append(path);
}
}
}
void QPdfBaseEngine::setPen()
{
Q_D(QPdfBaseEngine);
if (d->pen.style() == Qt::NoPen)
return;
QBrush b = d->pen.brush();
Q_ASSERT(b.style() == Qt::SolidPattern && b.isOpaque());
QColor rgba = b.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();
}
*d->currentPage << "SCN\n";
*d->currentPage << d->pen.widthF() << "w ";
int pdfCapStyle = 0;
switch(d->pen.capStyle()) {
case Qt::FlatCap:
pdfCapStyle = 0;
break;
case Qt::SquareCap:
pdfCapStyle = 2;
break;
case Qt::RoundCap:
pdfCapStyle = 1;
break;
default:
break;
}
*d->currentPage << pdfCapStyle << "J ";
int pdfJoinStyle = 0;
switch(d->pen.joinStyle()) {
case Qt::MiterJoin:
pdfJoinStyle = 0;
break;
case Qt::BevelJoin:
pdfJoinStyle = 2;
break;
case Qt::RoundJoin:
pdfJoinStyle = 1;
break;
default:
break;
}
*d->currentPage << pdfJoinStyle << "j ";
*d->currentPage << QPdf::generateDashes(d->pen) << " 0 d\n";
}
bool QPdfBaseEngine::newPage()
{
Q_D(QPdfBaseEngine);
setupGraphicsState(DirtyBrush|DirtyPen|DirtyClipPath);
QFile *outfile = qobject_cast<QFile*> (d->outDevice);
if (outfile && outfile->error() != QFile::NoError)
return false;
return true;
}
int QPdfBaseEngine::metric(QPaintDevice::PaintDeviceMetric metricType) const
{
Q_D(const QPdfBaseEngine);
int val;
QRect r = d->fullPage ? d->paperRect() : d->pageRect();
switch (metricType) {
case QPaintDevice::PdmWidth:
val = r.width();
break;
case QPaintDevice::PdmHeight:
val = r.height();
break;
case QPaintDevice::PdmDpiX:
case QPaintDevice::PdmDpiY:
val = d->resolution;
break;
case QPaintDevice::PdmPhysicalDpiX:
case QPaintDevice::PdmPhysicalDpiY:
val = 1200;
break;
case QPaintDevice::PdmWidthMM:
val = qRound(r.width()*25.4/d->resolution);
break;
case QPaintDevice::PdmHeightMM:
val = qRound(r.height()*25.4/d->resolution);
break;
case QPaintDevice::PdmNumColors:
val = INT_MAX;
break;
case QPaintDevice::PdmDepth:
val = 32;
break;
default:
qWarning("QPrinter::metric: Invalid metric command");
return 0;
}
return val;
}
void QPdfBaseEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value)
{
Q_D(QPdfBaseEngine);
switch (key) {
case PPK_CollateCopies:
d->collate = value.toBool();
break;
case PPK_ColorMode:
d->colorMode = QPrinter::ColorMode(value.toInt());
break;
case PPK_Creator:
d->creator = value.toString();
break;
case PPK_DocumentName:
d->title = value.toString();
break;
case PPK_FullPage:
d->fullPage = value.toBool();
break;
case PPK_NumberOfCopies:
d->copies = value.toInt();
break;
case PPK_Orientation:
d->orientation = QPrinter::Orientation(value.toInt());
break;
case PPK_OutputFileName:
d->outputFileName = value.toString();
break;
case PPK_PageOrder:
d->pageOrder = QPrinter::PageOrder(value.toInt());
break;
case PPK_PaperSize:
d->paperSize = QPrinter::PaperSize(value.toInt());
break;
case PPK_PaperSource:
d->paperSource = QPrinter::PaperSource(value.toInt());
break;
case PPK_PrinterName:
d->printerName = value.toString();
break;
case PPK_PrinterProgram:
d->printProgram = value.toString();
break;
case PPK_Resolution:
d->resolution = value.toInt();
break;
case PPK_SelectionOption:
d->selectionOption = value.toString();
break;
case PPK_FontEmbedding:
d->embedFonts = value.toBool();
break;
case PPK_Duplex:
d->duplex = static_cast<QPrinter::DuplexMode> (value.toInt());
break;
case PPK_CupsPageRect:
d->cupsPageRect = value.toRect();
break;
case PPK_CupsPaperRect:
d->cupsPaperRect = value.toRect();
break;
case PPK_CupsOptions:
d->cupsOptions = value.toStringList();
break;
case PPK_CupsStringPageSize:
d->cupsStringPageSize = value.toString();
break;
case PPK_CustomPaperSize:
d->paperSize = QPrinter::Custom;
d->customPaperSize = value.toSizeF();
break;
case PPK_PageMargins:
{
QList<QVariant> margins(value.toList());
Q_ASSERT(margins.size() == 4);
d->leftMargin = margins.at(0).toReal();
d->topMargin = margins.at(1).toReal();
d->rightMargin = margins.at(2).toReal();
d->bottomMargin = margins.at(3).toReal();
d->hasCustomPageMargins = true;
break;
}
default:
break;
}
}
QVariant QPdfBaseEngine::property(PrintEnginePropertyKey key) const
{
Q_D(const QPdfBaseEngine);
QVariant ret;
switch (key) {
case PPK_CollateCopies:
ret = d->collate;
break;
case PPK_ColorMode:
ret = d->colorMode;
break;
case PPK_Creator:
ret = d->creator;
break;
case PPK_DocumentName:
ret = d->title;
break;
case PPK_FullPage:
ret = d->fullPage;
break;
case PPK_NumberOfCopies:
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
if (QCUPSSupport::isAvailable())
ret = 1;
else
#endif
ret = d->copies;
break;
case PPK_Orientation:
ret = d->orientation;
break;
case PPK_OutputFileName:
ret = d->outputFileName;
break;
case PPK_PageOrder:
ret = d->pageOrder;
break;
case PPK_PaperSize:
ret = d->paperSize;
break;
case PPK_PaperSource:
ret = d->paperSource;
break;
case PPK_PrinterName:
ret = d->printerName;
break;
case PPK_PrinterProgram:
ret = d->printProgram;
break;
case PPK_Resolution:
ret = d->resolution;
break;
case PPK_SupportedResolutions:
ret = QList<QVariant>() << 72;
break;
case PPK_PaperRect:
ret = d->paperRect();
break;
case PPK_PageRect:
ret = d->pageRect();
break;
case PPK_SelectionOption:
ret = d->selectionOption;
break;
case PPK_FontEmbedding:
ret = d->embedFonts;
break;
case PPK_Duplex:
ret = d->duplex;
break;
case PPK_CupsPageRect:
ret = d->cupsPageRect;
break;
case PPK_CupsPaperRect:
ret = d->cupsPaperRect;
break;
case PPK_CupsOptions:
ret = d->cupsOptions;
break;
case PPK_CupsStringPageSize:
ret = d->cupsStringPageSize;
break;
case PPK_CustomPaperSize:
ret = d->customPaperSize;
break;
case PPK_PageMargins:
{
QList<QVariant> margins;
if (d->hasCustomPageMargins) {
margins << d->leftMargin << d->topMargin
<< d->rightMargin << d->bottomMargin;
} else {
const qreal defaultMargin = 10; // ~3.5 mm
margins << defaultMargin << defaultMargin
<< defaultMargin << defaultMargin;
}
ret = margins;
break;
}
default:
break;
}
return ret;
}
QPdfBaseEnginePrivate::QPdfBaseEnginePrivate(QPrinter::PrinterMode m)
: clipEnabled(false), allClipped(false), hasPen(true), hasBrush(false), simplePen(false),
useAlphaEngine(false),
outDevice(0), fd(-1),
duplex(QPrinter::DuplexNone), collate(false), fullPage(false), embedFonts(true), copies(1),
pageOrder(QPrinter::FirstPageFirst), orientation(QPrinter::Portrait),
paperSize(QPrinter::A4), colorMode(QPrinter::Color), paperSource(QPrinter::Auto),
hasCustomPageMargins(false),
leftMargin(0), topMargin(0), rightMargin(0), bottomMargin(0)
{
resolution = 72;
if (m == QPrinter::HighResolution)
resolution = 1200;
else if (m == QPrinter::ScreenResolution)
resolution = qt_defaultDpi();
postscript = false;
currentObject = 1;
currentPage = 0;
stroker.stream = 0;
}
bool QPdfBaseEngine::begin(QPaintDevice *pdev)
{
Q_D(QPdfBaseEngine);
d->pdev = pdev;
d->postscript = false;
d->currentObject = 1;
d->currentPage = new QPdfPage;
d->stroker.stream = d->currentPage;
d->opacity = 1.0;
return d->openPrintDevice();
}
bool QPdfBaseEngine::end()
{
Q_D(QPdfBaseEngine);
qDeleteAll(d->fonts);
d->fonts.clear();
delete d->currentPage;
d->currentPage = 0;
d->closePrintDevice();
return true;
}
#ifndef QT_NO_LPR
static void closeAllOpenFds()
{
// hack time... getting the maximum number of open
// files, if possible. if not we assume it's the
// larger of 256 and the fd we got
int i;
#if defined(_SC_OPEN_MAX)
i = (int)sysconf(_SC_OPEN_MAX);
#elif defined(_POSIX_OPEN_MAX)
i = (int)_POSIX_OPEN_MAX;
#elif defined(OPEN_MAX)
i = (int)OPEN_MAX;
#else
i = 256;
#endif
// leave stdin/out/err untouched
while(--i > 2)
QT_CLOSE(i);
}
#endif
bool QPdfBaseEnginePrivate::openPrintDevice()
{
if(outDevice)
return false;
if (!outputFileName.isEmpty()) {
QFile *file = new QFile(outputFileName);
if (! file->open(QFile::WriteOnly|QFile::Truncate)) {
delete file;
return false;
}
outDevice = file;
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
} else if (QCUPSSupport::isAvailable()) {
QCUPSSupport cups;
QPair<int, QString> ret = cups.tempFd();
if (ret.first < 0) {
qWarning("QPdfPrinter: Could not open temporary file to print");
return false;
}
cupsTempFile = ret.second;
outDevice = new QFile();
static_cast<QFile *>(outDevice)->open(ret.first, QIODevice::WriteOnly);
#endif
#ifndef QT_NO_LPR
} else {
QString pr;
if (!printerName.isEmpty())
pr = printerName;
int fds[2];
if (qt_safe_pipe(fds) != 0) {
qWarning("QPdfPrinter: Could not open pipe to print");
return false;
}
pid_t pid = fork();
if (pid == 0) { // child process
// if possible, exit quickly, so the actual lp/lpr
// becomes a child of init, and ::waitpid() is
// guaranteed not to wait.
if (fork() > 0) {
closeAllOpenFds();
// try to replace this process with "true" - this prevents
// global destructors from being called (that could possibly
// do wrong things to the parent process)
(void)execlp("true", "true", (char *)0);
(void)execl("/bin/true", "true", (char *)0);
(void)execl("/usr/bin/true", "true", (char *)0);
::_exit(0);
}
qt_safe_dup2(fds[0], 0, 0);
closeAllOpenFds();
if (!printProgram.isEmpty()) {
if (!selectionOption.isEmpty())
pr.prepend(selectionOption);
else
pr.prepend(QLatin1String("-P"));
(void)execlp(printProgram.toLocal8Bit().data(), printProgram.toLocal8Bit().data(),
pr.toLocal8Bit().data(), (char *)0);
} else {
// if no print program has been specified, be smart
// about the option string too.
QList<QByteArray> lprhack;
QList<QByteArray> lphack;
QByteArray media;
if (!pr.isEmpty() || !selectionOption.isEmpty()) {
if (!selectionOption.isEmpty()) {
QStringList list = selectionOption.split(QLatin1Char(' '));
for (int i = 0; i < list.size(); ++i)
lprhack.append(list.at(i).toLocal8Bit());
lphack = lprhack;
} else {
lprhack.append("-P");
lphack.append("-d");
}
lprhack.append(pr.toLocal8Bit());
lphack.append(pr.toLocal8Bit());
}
lphack.append("-s");
char ** lpargs = new char *[lphack.size()+6];
char lp[] = "lp";
lpargs[0] = lp;
int i;
for (i = 0; i < lphack.size(); ++i)
lpargs[i+1] = (char *)lphack.at(i).constData();
#ifndef Q_OS_OSF
if (QPdf::paperSizeToString(paperSize)) {
char dash_o[] = "-o";
lpargs[++i] = dash_o;
lpargs[++i] = const_cast<char *>(QPdf::paperSizeToString(paperSize));
lpargs[++i] = dash_o;
media = "media=";
media += QPdf::paperSizeToString(paperSize);
lpargs[++i] = media.data();
}
#endif
lpargs[++i] = 0;
char **lprargs = new char *[lprhack.size()+2];
char lpr[] = "lpr";
lprargs[0] = lpr;
for (int i = 0; i < lprhack.size(); ++i)
lprargs[i+1] = (char *)lprhack[i].constData();
lprargs[lprhack.size() + 1] = 0;
(void)execvp("lp", lpargs);
(void)execvp("lpr", lprargs);
(void)execv("/bin/lp", lpargs);
(void)execv("/bin/lpr", lprargs);
(void)execv("/usr/bin/lp", lpargs);
(void)execv("/usr/bin/lpr", lprargs);
delete []lpargs;
delete []lprargs;
}
// if we couldn't exec anything, close the fd,
// wait for a second so the parent process (the
// child of the GUI process) has exited. then
// exit.
QT_CLOSE(0);
(void)::sleep(1);
::_exit(0);
}
// parent process
QT_CLOSE(fds[0]);
fd = fds[1];
(void)qt_safe_waitpid(pid, 0, 0);
if (fd < 0)
return false;
outDevice = new QFile();
static_cast<QFile *>(outDevice)->open(fd, QIODevice::WriteOnly);
#endif
}
return true;
}
void QPdfBaseEnginePrivate::closePrintDevice()
{
if (!outDevice)
return;
outDevice->close();
if (fd >= 0)
#if defined(Q_OS_WIN) && defined(_MSC_VER) && _MSC_VER >= 1400
::_close(fd);
#else
::close(fd);
#endif
fd = -1;
delete outDevice;
outDevice = 0;
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
if (!cupsTempFile.isEmpty()) {
QString tempFile = cupsTempFile;
cupsTempFile.clear();
QCUPSSupport cups;
// Set up print options.
QByteArray prnName;
QList<QPair<QByteArray, QByteArray> > options;
QVector<cups_option_t> cupsOptStruct;
if (!printerName.isEmpty()) {
prnName = printerName.toLocal8Bit();
} else {
QPrinterInfo def = QPrinterInfo::defaultPrinter();
if (def.isNull()) {
qWarning("Could not determine printer to print to");
QFile::remove(tempFile);
return;
}
prnName = def.printerName().toLocal8Bit();
}
if (!cupsStringPageSize.isEmpty()) {
options.append(QPair<QByteArray, QByteArray>("media", cupsStringPageSize.toLocal8Bit()));
}
if (copies > 1) {
options.append(QPair<QByteArray, QByteArray>("copies", QString::number(copies).toLocal8Bit()));
}
if (collate) {
options.append(QPair<QByteArray, QByteArray>("Collate", "True"));
}
if (duplex != QPrinter::DuplexNone) {
switch(duplex) {
case QPrinter::DuplexNone: break;
case QPrinter::DuplexAuto:
if (orientation == QPrinter::Portrait)
options.append(QPair<QByteArray, QByteArray>("sides", "two-sided-long-edge"));
else
options.append(QPair<QByteArray, QByteArray>("sides", "two-sided-short-edge"));
break;
case QPrinter::DuplexLongSide:
options.append(QPair<QByteArray, QByteArray>("sides", "two-sided-long-edge"));
break;
case QPrinter::DuplexShortSide:
options.append(QPair<QByteArray, QByteArray>("sides", "two-sided-short-edge"));
break;
}
}
if (QCUPSSupport::cupsVersion() >= 10300 && orientation == QPrinter::Landscape) {
options.append(QPair<QByteArray, QByteArray>("landscape", ""));
}
QStringList::const_iterator it = cupsOptions.constBegin();
while (it != cupsOptions.constEnd()) {
options.append(QPair<QByteArray, QByteArray>((*it).toLocal8Bit(), (*(it+1)).toLocal8Bit()));
it += 2;
}
for (int c = 0; c < options.size(); ++c) {
cups_option_t opt;
opt.name = options[c].first.data();
opt.value = options[c].second.data();
cupsOptStruct.append(opt);
}
// Print the file.
cups_option_t* optPtr = cupsOptStruct.size() ? &cupsOptStruct.first() : 0;
cups.printFile(prnName.constData(), tempFile.toLocal8Bit().constData(),
title.toLocal8Bit().constData(), cupsOptStruct.size(), optPtr);
QFile::remove(tempFile);
}
#endif
}
QPdfBaseEnginePrivate::~QPdfBaseEnginePrivate()
{
qDeleteAll(fonts);
delete currentPage;
}
void QPdfBaseEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti)
{
Q_Q(QPdfBaseEngine);
QFontEngine *fe = ti.fontEngine;
QFontEngine::FaceId face_id = fe->faceId();
bool noEmbed = false;
if (face_id.filename.isEmpty()
|| (!postscript && ((fe->fsType & 0x200) /* bitmap embedding only */
|| (fe->fsType == 2) /* no embedding allowed */))) {
*currentPage << "Q\n";
q->QPaintEngine::drawTextItem(p, ti);
*currentPage << "q\n";
if (face_id.filename.isEmpty())
return;
noEmbed = true;
}
QFontSubset *font = fonts.value(face_id, 0);
if (!font) {
font = new QFontSubset(fe, requestObject());
font->noEmbed = noEmbed;
}
fonts.insert(face_id, font);
if (!currentPage->fonts.contains(font->object_id))
currentPage->fonts.append(font->object_id);
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
QVarLengthArray<glyph_t> glyphs;
QVarLengthArray<QFixedPoint> positions;
QTransform m = QTransform::fromTranslate(p.x(), p.y());
ti.fontEngine->getGlyphPositions(ti.glyphs, m, ti.flags,
glyphs, positions);
if (glyphs.size() == 0)
return;
int synthesized = ti.fontEngine->synthesized();
qreal stretch = synthesized & QFontEngine::SynthesizedStretch ? ti.fontEngine->fontDef.stretch/100. : 1.;
*currentPage << "BT\n"
<< "/F" << font->object_id << size << "Tf "
<< stretch << (synthesized & QFontEngine::SynthesizedItalic
? "0 .3 -1 0 0 Tm\n"
: "0 0 -1 0 0 Tm\n");
#if 0
// #### implement actual text for complex languages
const unsigned short *logClusters = ti.logClusters;
int pos = 0;
do {
int end = pos + 1;
while (end < ti.num_chars && logClusters[end] == logClusters[pos])
++end;
*currentPage << "/Span << /ActualText <FEFF";
for (int i = pos; i < end; ++i) {
s << toHex((ushort)ti.chars[i].unicode(), buf);
}
*currentPage << "> >>\n"
"BDC\n"
"<";
int ge = end == ti.num_chars ? ti.num_glyphs : logClusters[end];
for (int gs = logClusters[pos]; gs < ge; ++gs)
*currentPage << toHex((ushort)ti.glyphs[gs].glyph, buf);
*currentPage << "> Tj\n"
"EMC\n";
pos = end;
} while (pos < ti.num_chars);
#else
qreal last_x = 0.;
qreal last_y = 0.;
for (int i = 0; i < glyphs.size(); ++i) {
qreal x = positions[i].x.toReal();
qreal y = positions[i].y.toReal();
if (synthesized & QFontEngine::SynthesizedItalic)
x += .3*y;
x /= stretch;
char buf[5];
int g = font->addGlyph(glyphs[i]);
*currentPage << x - last_x << last_y - y << "Td <"
<< QPdf::toHex((ushort)g, buf) << "> Tj\n";
last_x = x;
last_y = y;
}
if (synthesized & QFontEngine::SynthesizedBold) {
*currentPage << stretch << (synthesized & QFontEngine::SynthesizedItalic
? "0 .3 -1 0 0 Tm\n"
: "0 0 -1 0 0 Tm\n");
*currentPage << "/Span << /ActualText <> >> BDC\n";
last_x = 0.5*fe->lineThickness().toReal();
last_y = 0.;
for (int i = 0; i < glyphs.size(); ++i) {
qreal x = positions[i].x.toReal();
qreal y = positions[i].y.toReal();
if (synthesized & QFontEngine::SynthesizedItalic)
x += .3*y;
x /= stretch;
char buf[5];
int g = font->addGlyph(glyphs[i]);
*currentPage << x - last_x << last_y - y << "Td <"
<< QPdf::toHex((ushort)g, buf) << "> Tj\n";
last_x = x;
last_y = y;
}
*currentPage << "EMC\n";
}
#endif
*currentPage << "ET\n";
}
QRect QPdfBaseEnginePrivate::paperRect() const
{
int w;
int h;
if (paperSize == QPrinter::Custom) {
w = qRound(customPaperSize.width()*resolution/72.);
h = qRound(customPaperSize.height()*resolution/72.);
} else {
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
if (QCUPSSupport::isAvailable() && !cupsPaperRect.isNull()) {
QRect r = cupsPaperRect;
w = r.width();
h = r.height();
} else
#endif
{
QPdf::PaperSize s = QPdf::paperSize(paperSize);
w = s.width;
h = s.height;
}
w = qRound(w*resolution/72.);
h = qRound(h*resolution/72.);
}
if (orientation == QPrinter::Portrait)
return QRect(0, 0, w, h);
else
return QRect(0, 0, h, w);
}
QRect QPdfBaseEnginePrivate::pageRect() const
{
if(fullPage)
return paperRect();
QRect r;
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
if (!hasCustomPageMargins && QCUPSSupport::isAvailable() && !cupsPageRect.isNull()) {
r = cupsPageRect;
if (r == cupsPaperRect) {
// if cups doesn't define any margins, give it at least approx 3.5 mm
r = QRect(10, 10, r.width() - 20, r.height() - 20);
}
} else
#endif
{
QPdf::PaperSize s;
if (paperSize == QPrinter::Custom) {
s.width = qRound(customPaperSize.width());
s.height = qRound(customPaperSize.height());
} else {
s = QPdf::paperSize(paperSize);
}
if (hasCustomPageMargins)
r = QRect(0, 0, s.width, s.height);
else
r = QRect(72/3, 72/3, s.width - 2*72/3, s.height - 2*72/3);
}
int x = qRound(r.left()*resolution/72.);
int y = qRound(r.top()*resolution/72.);
int w = qRound(r.width()*resolution/72.);
int h = qRound(r.height()*resolution/72.);
if (orientation == QPrinter::Portrait)
r = QRect(x, y, w, h);
else
r = QRect(y, x, h, w);
if (hasCustomPageMargins) {
r.adjust(qRound(leftMargin*(resolution/72.)),
qRound(topMargin*(resolution/72.)),
-qRound(rightMargin*(resolution/72.)),
-qRound(bottomMargin*(resolution/72.)));
}
return r;
}
#endif
QT_END_NAMESPACE