qpdf.cpp

Jenkins

qpdf.cpp

Absolute File Name:

/home/qt/qt5_coco/qt5/qtbase/src/gui/painting/qpdf.cpp

Line

Source

Count

/****************************************************************************

** Contact: https://www.qt.io/licensing/

** This file is part of the QtGui module of the Qt Toolkit.

** $QT_BEGIN_LICENSE:LGPL$

** Commercial License Usage

** Licensees holding valid commercial Qt licenses may use this file in

** accordance with the commercial license agreement provided with the

** Software or, alternatively, in accordance with the terms contained in

** a written agreement between you and The Qt Company. For licensing terms

** and conditions see https://www.qt.io/terms-conditions. For further

** information use the contact form at https://www.qt.io/contact-us.

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 3 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL3 included in the

** packaging of this file. Please review the following information to

** ensure the GNU Lesser General Public License version 3 requirements

** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU

** General Public License version 2.0 or (at your option) the GNU General

** Public license version 3 or any later version approved by the KDE Free

** Qt Foundation. The licenses are as published by the Free Software

** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3

** included in the packaging of this file. Please review the following

** information to ensure the GNU General Public License requirements will

** be met: https://www.gnu.org/licenses/gpl-2.0.html and

** https://www.gnu.org/licenses/gpl-3.0.html.

** $QT_END_LICENSE$

****************************************************************************/

#include "qpdf_p.h"

#ifndef QT_NO_PDF

#include "qplatformdefs.h"

#include <qdebug.h>

#include <qfile.h>

#include <qtemporaryfile.h>

#include <private/qmath_p.h>

#include <private/qpainter_p.h>

#include <qnumeric.h>

#include "private/qfont_p.h"

#include <qimagewriter.h>

#include "qbuffer.h"

#include "QtCore/qdatetime.h"

#ifndef QT_NO_COMPRESS

#include <zlib.h>

#endif

#ifdef QT_NO_COMPRESS

static const bool do_compress = false;

#else

static const bool do_compress = true;

#endif

// 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;

QT_BEGIN_NAMESPACE

inline QPaintEngine::PaintEngineFeatures qt_pdf_decide_features()

{

QPaintEngine::PaintEngineFeatures f = QPaintEngine::AllFeatures;

f &= ~(QPaintEngine::PorterDuff

| QPaintEngine::PerspectiveTransform

| QPaintEngine::ObjectBoundingModeGradients

| QPaintEngine::ConicalGradientFill);

return f;

}

/* 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;

100

qreal frac = val - (qreal)ival;

101

102

int ifrac = (int)(frac * 1000000000);

103

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) {

138

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)

164

: dev(new QBuffer(byteArray)),

165

fileBackingEnabled(fileBacking),

166

fileBackingActive(false),

167

handleDirty(false)

168

{

169

dev->open(QIODevice::ReadWrite | QIODevice::Append);

170

}

171

172

ByteStream::ByteStream(bool fileBacking)

173

: dev(new QBuffer(&ba)),

174

fileBackingEnabled(fileBacking),

175

fileBackingActive(false),

176

handleDirty(false)

177

{

178

dev->open(QIODevice::ReadWrite);

179

}

180

181

ByteStream::~ByteStream()

{

delete dev;

}

ByteStream &ByteStream::operator <<(char chr)

187

{

188

if (handleDirty) prepareBuffer();

dev->write(&chr, 1);

return *this;

}

ByteStream &ByteStream::operator <<(const char *str)

194

{

195

if (handleDirty) prepareBuffer();

196

dev->write(str, strlen(str));

return *this;

}

ByteStream &ByteStream::operator <<(const QByteArray &str)

201

{

202

if (handleDirty) prepareBuffer();

dev->write(str);

return *this;

}

ByteStream &ByteStream::operator <<(const ByteStream &src)

208

{

209

Q_ASSERT(!src.dev->isSequential());

210

if (handleDirty) prepareBuffer();

211

// We do play nice here, even though it looks ugly.

212

// We save the position and restore it afterwards.

213

ByteStream &s = const_cast<ByteStream&>(src);

214

qint64 pos = s.dev->pos();

215

s.dev->reset();

216

while (!s.dev->atEnd()) {

217

QByteArray buf = s.dev->read(chunkSize());

dev->write(buf);

}

s.dev->seek(pos);

return *this;

}

ByteStream &ByteStream::operator <<(qreal val) {

225

char buf[256];

226

qt_real_to_string(val, buf);

*this << buf;

return *this;

}

ByteStream &ByteStream::operator <<(int val) {

232

char buf[256];

233

qt_int_to_string(val, buf);

*this << buf;

return *this;

}

ByteStream &ByteStream::operator <<(const QPointF &p) {

239

char buf[256];

240

qt_real_to_string(p.x(), buf);

241

*this << buf;

242

qt_real_to_string(p.y(), buf);

*this << buf;

return *this;

}

QIODevice *ByteStream::stream()

{

dev->reset();

handleDirty = true;

return dev;

}

void ByteStream::clear()

255

{

256

dev->open(QIODevice::ReadWrite | QIODevice::Truncate);

257

}

258

259

void ByteStream::constructor_helper(QByteArray *ba)

260

{

261

delete dev;

262

dev = new QBuffer(ba);

263

dev->open(QIODevice::ReadWrite);

264

}

265

266

void ByteStream::prepareBuffer()

267

{

268

Q_ASSERT(!dev->isSequential());

269

qint64 size = dev->size();

270

if (fileBackingEnabled && !fileBackingActive

271

&& size > maxMemorySize()) {

272

// Switch to file backing.

273

QTemporaryFile *newFile = new QTemporaryFile;

274

newFile->open();

275

dev->reset();

276

while (!dev->atEnd()) {

277

QByteArray buf = dev->read(chunkSize());

newFile->write(buf);

}

delete dev;

dev = newFile;

ba.clear();

fileBackingActive = true;

284

}

285

if (dev->pos() != size) {

dev->seek(size);

handleDirty = false;

}

}

}

#define QT_PATH_ELEMENT(elm)

293

294

QByteArray QPdf::generatePath(const QPainterPath &path, const QTransform &matrix, PathFlags flags)

295

{

296

QByteArray result;

297

if (!path.elementCount())

298

return result;

299

300

ByteStream s(&result);

301

302

int start = -1;

303

for (int i = 0; i < path.elementCount(); ++i) {

304

const QPainterPath::Element &elm = path.elementAt(i);

305

switch (elm.type) {

306

case QPainterPath::MoveToElement:

307

if (start >= 0

308

&& path.elementAt(start).x == path.elementAt(i-1).x

309

&& path.elementAt(start).y == path.elementAt(i-1).y)

310

s << "h\n";

311

s << matrix.map(QPointF(elm.x, elm.y)) << "m\n";

312

start = i;

313

break;

314

case QPainterPath::LineToElement:

315

s << matrix.map(QPointF(elm.x, elm.y)) << "l\n";

316

break;

317

case QPainterPath::CurveToElement:

318

Q_ASSERT(path.elementAt(i+1).type == QPainterPath::CurveToDataElement);

319

Q_ASSERT(path.elementAt(i+2).type == QPainterPath::CurveToDataElement);

320

s << matrix.map(QPointF(elm.x, elm.y))

321

<< matrix.map(QPointF(path.elementAt(i+1).x, path.elementAt(i+1).y))

322

<< 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

332

&& path.elementAt(start).y == path.elementAt(path.elementCount()-1).y)

333

s << "h\n";

334

335

Qt::FillRule fillRule = path.fillRule();

const char *op = "";

switch (flags) {

case ClipPath:

op = (fillRule == Qt::WindingFill) ? "W n\n" : "W* n\n";

341

break;

342

case FillPath:

343

op = (fillRule == Qt::WindingFill) ? "f\n" : "f*\n";

break;

case StrokePath:

op = "S\n";

break;

case FillAndStrokePath:

349

op = (fillRule == Qt::WindingFill) ? "B\n" : "B*\n";

break;

}

s << op;

return result;

}

QByteArray QPdf::generateMatrix(const QTransform &matrix)

357

{

358

QByteArray result;

359

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)

371

{

372

QByteArray result;

373

ByteStream s(&result);

374

s << '[';

375

376

QVector<qreal> dasharray = pen.dashPattern();

377

qreal w = pen.widthF();

378

if (w < 0.001)

379

w = 1;

380

for (int i = 0; i < dasharray.size(); ++i) {

381

qreal dw = dasharray.at(i)*w;

382

if (dw < 0.0001) dw = 0.0001;

s << dw;

}

s << ']';

s << pen.dashOffset() * w;

s << " d\n";

return result;

}

static const char* const 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

544

};

545

546

QByteArray QPdf::patternForBrush(const QBrush &b)

547

{

548

int style = b.style();

549

if (style > Qt::DiagCrossPattern)

550

return QByteArray();

551

return pattern_for_brush[style];

}

static void moveToHook(qfixed x, qfixed y, void *data)

556

{

557

QPdf::Stroker *t = (QPdf::Stroker *)data;

if (!t->first)

*t->stream << "h\n";

if (!t->cosmeticPen)

t->matrix.map(x, y, &x, &y);

562

*t->stream << x << y << "m\n";

t->first = false;

}

static void lineToHook(qfixed x, qfixed y, void *data)

567

{

568

QPdf::Stroker *t = (QPdf::Stroker *)data;

569

if (!t->cosmeticPen)

570

t->matrix.map(x, y, &x, &y);

571

*t->stream << x << y << "l\n";

572

}

573

574

static void cubicToHook(qfixed c1x, qfixed c1y,

575

qfixed c2x, qfixed c2y,

576

qfixed ex, qfixed ey,

577

void *data)

578

{

579

QPdf::Stroker *t = (QPdf::Stroker *)data;

580

if (!t->cosmeticPen) {

581

t->matrix.map(c1x, c1y, &c1x, &c1y);

582

t->matrix.map(c2x, c2y, &c2x, &c2y);

583

t->matrix.map(ex, ey, &ex, &ey);

584

}

585

*t->stream << c1x << c1y

<< c2x << c2y

<< ex << ey

<< "c\n";

}

QPdf::Stroker::Stroker()

592

: stream(0),

593

first(true),

594

dashStroker(&basicStroker)

595

{

596

stroker = &basicStroker;

597

basicStroker.setMoveToHook(moveToHook);

598

basicStroker.setLineToHook(lineToHook);

599

basicStroker.setCubicToHook(cubicToHook);

600

cosmeticPen = true;

601

basicStroker.setStrokeWidth(.1);

602

}

603

604

void QPdf::Stroker::setPen(const QPen &pen, QPainter::RenderHints hints)

605

{

606

if (pen.style() == Qt::NoPen) {

stroker = 0;

return;

}

qreal w = pen.widthF();

611

bool zeroWidth = w < 0.0001;

612

cosmeticPen = qt_pen_is_cosmetic(pen, hints);

if (zeroWidth)

w = .1;

basicStroker.setStrokeWidth(w);

617

basicStroker.setCapStyle(pen.capStyle());

618

basicStroker.setJoinStyle(pen.joinStyle());

619

basicStroker.setMiterLimit(pen.miterLimit());

620

621

QVector<qreal> dashpattern = pen.dashPattern();

622

if (zeroWidth) {

623

for (int i = 0; i < dashpattern.size(); ++i)

624

dashpattern[i] *= 10.;

625

}

626

if (!dashpattern.isEmpty()) {

627

dashStroker.setDashPattern(dashpattern);

628

dashStroker.setDashOffset(pen.dashOffset());

629

stroker = &dashStroker;

630

} else {

631

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)

646

{

647

int isize = input.size()/4*4;

648

QByteArray output;

649

output.resize(input.size()*5/4+7);

650

char *out = output.data();

651

const uchar *in = (const uchar *)input.constData();

652

for (int i = 0; i < isize; i += 4) {

653

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] + '!';

669

*(out++) = base[1] + '!';

670

*(out++) = base[2] + '!';

671

*(out++) = base[3] + '!';

672

*(out++) = base[4] + '!';

673

}

674

}

675

//write the last few bytes

676

int remaining = input.size() - isize;

677

if (remaining) {

678

uint val = 0;

679

for (int i = isize; i < input.size(); ++i)

680

val = (val << 8) + in[i];

681

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)

693

*(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;

}

QPdfPage::QPdfPage()

: QPdf::ByteStream(true) // Enable file backing

{

}

void QPdfPage::streamImage(int w, int h, int object)

740

{

741

*this << w << "0 0 " << -h << "0 " << h << "cm /Im" << object << " Do\n";

742

if (!images.contains(object))

743

images.append(object);

}

QPdfEngine::QPdfEngine(QPdfEnginePrivate &dd)

748

: QPaintEngine(dd, qt_pdf_decide_features())

{

}

QPdfEngine::QPdfEngine()

753

: QPaintEngine(*new QPdfEnginePrivate(), qt_pdf_decide_features())

{

}

void QPdfEngine::setOutputFilename(const QString &filename)

758

{

759

Q_D(QPdfEngine);

760

d->outputFileName = filename;

}

void QPdfEngine::drawPoints (const QPointF *points, int pointCount)

{

if (!points)

return;

Q_D(QPdfEngine);

QPainterPath p;

for (int i=0; i!=pointCount;++i) {

772

p.moveTo(points[i]);

773

p.lineTo(points[i] + QPointF(0, 0.001));

774

}

775

776

bool hadBrush = d->hasBrush;

777

d->hasBrush = false;

778

drawPath(p);

779

d->hasBrush = hadBrush;

780

}

781

782

void QPdfEngine::drawLines (const QLineF *lines, int lineCount)

{

if (!lines)

return;

Q_D(QPdfEngine);

QPainterPath p;

for (int i=0; i!=lineCount;++i) {

790

p.moveTo(lines[i].p1());

791

p.lineTo(lines[i].p2());

792

}

793

bool hadBrush = d->hasBrush;

794

d->hasBrush = false;

795

drawPath(p);

796

d->hasBrush = hadBrush;

797

}

798

799

void QPdfEngine::drawRects (const QRectF *rects, int rectCount)

{

if (!rects)

return;

Q_D(QPdfEngine);

if (d->clipEnabled && d->allClipped)

807

return;

808

if (!d->hasPen && !d->hasBrush)

809

return;

810

811

QBrush penBrush = d->pen.brush();

812

if (d->simplePen || !d->hasPen) {

813

// draw strokes natively in this case for better output

814

if(!d->simplePen && !d->stroker.matrix.isIdentity())

815

*d->currentPage << "q\n" << QPdf::generateMatrix(d->stroker.matrix);

816

for (int i = 0; i < rectCount; ++i)

817

*d->currentPage << rects[i].x() << rects[i].y() << rects[i].width() << rects[i].height() << "re\n";

818

*d->currentPage << (d->hasPen ? (d->hasBrush ? "B\n" : "S\n") : "f\n");

819

if(!d->simplePen && !d->stroker.matrix.isIdentity())

820

*d->currentPage << "Q\n";

821

} else {

822

QPainterPath p;

823

for (int i=0; i!=rectCount; ++i)

p.addRect(rects[i]);

drawPath(p);

}

}

void QPdfEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)

{

Q_D(QPdfEngine);

if (!points || !pointCount)

834

return;

835

836

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)

856

p.lineTo(points[i]);

857

858

if (mode != PolylineMode)

p.closeSubpath();

drawPath(p);

d->hasBrush = hb;

}

void QPdfEngine::drawPath (const QPainterPath &p)

{

Q_D(QPdfEngine);

if (d->clipEnabled && d->allClipped)

870

return;

871

if (!d->hasPen && !d->hasBrush)

return;

if (d->simplePen) {

// draw strokes natively in this case for better output

876

*d->currentPage << QPdf::generatePath(p, QTransform(), d->hasBrush ? QPdf::FillAndStrokePath : QPdf::StrokePath);

877

} else {

878

if (d->hasBrush)

879

*d->currentPage << QPdf::generatePath(p, d->stroker.matrix, QPdf::FillPath);

880

if (d->hasPen) {

881

*d->currentPage << "q\n";

882

QBrush b = d->brush;

883

d->brush = d->pen.brush();

884

setBrush();

885

d->stroker.strokePath(p);

886

*d->currentPage << "Q\n";

d->brush = b;

}

}

}

void QPdfEngine::drawPixmap (const QRectF &rectangle, const QPixmap &pixmap, const QRectF &sr)

893

{

894

if (sr.isEmpty() || rectangle.isEmpty() || pixmap.isNull())

return;

Q_D(QPdfEngine);

QBrush b = d->brush;

QRect sourceRect = sr.toRect();

901

QPixmap pm = sourceRect != pixmap.rect() ? pixmap.copy(sourceRect) : pixmap;

902

QImage image = pm.toImage();

903

bool bitmap = true;

904

const int object = d->addImage(image, &bitmap, pm.cacheKey());

if (object < 0)

return;

*d->currentPage << "q\n/GSa gs\n";

909

*d->currentPage

910

<< QPdf::generateMatrix(QTransform(rectangle.width() / sr.width(), 0, 0, rectangle.height() / sr.height(),

911

rectangle.x(), rectangle.y()) * (d->simplePen ? QTransform() : d->stroker.matrix));

912

if (bitmap) {

913

// set current pen as d->brush

914

d->brush = d->pen.brush();

915

}

916

setBrush();

917

d->currentPage->streamImage(image.width(), image.height(), object);

918

*d->currentPage << "Q\n";

d->brush = b;

}

void QPdfEngine::drawImage(const QRectF &rectangle, const QImage &image, const QRectF &sr, Qt::ImageConversionFlags)

924

{

925

if (sr.isEmpty() || rectangle.isEmpty() || image.isNull())

return;

Q_D(QPdfEngine);

QRect sourceRect = sr.toRect();

930

QImage im = sourceRect != image.rect() ? image.copy(sourceRect) : image;

931

bool bitmap = true;

932

const int object = d->addImage(im, &bitmap, im.cacheKey());

if (object < 0)

return;

*d->currentPage << "q\n/GSa gs\n";

937

*d->currentPage

938

<< QPdf::generateMatrix(QTransform(rectangle.width() / sr.width(), 0, 0, rectangle.height() / sr.height(),

939

rectangle.x(), rectangle.y()) * (d->simplePen ? QTransform() : d->stroker.matrix));

940

setBrush();

941

d->currentPage->streamImage(im.width(), im.height(), object);

942

*d->currentPage << "Q\n";

943

}

944

945

void QPdfEngine::drawTiledPixmap (const QRectF &rectangle, const QPixmap &pixmap, const QPointF &point)

{

Q_D(QPdfEngine);

bool bitmap = (pixmap.depth() == 1);

950

QBrush b = d->brush;

951

QPointF bo = d->brushOrigin;

952

bool hp = d->hasPen;

953

d->hasPen = false;

954

bool hb = d->hasBrush;

955

d->hasBrush = true;

956

957

d->brush = QBrush(pixmap);

958

if (bitmap)

959

// #### fix bitmap case where we have a brush pen

960

d->brush.setColor(d->pen.color());

961

962

d->brushOrigin = -point;

963

*d->currentPage << "q\n";

964

setBrush();

965

966

drawRects(&rectangle, 1);

967

*d->currentPage << "Q\n";

d->hasPen = hp;

d->hasBrush = hb;

d->brush = b;

d->brushOrigin = bo;

}

void QPdfEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)

{

Q_D(QPdfEngine);

if (!d->hasPen || (d->clipEnabled && d->allClipped))

980

return;

981

982

if (d->stroker.matrix.type() >= QTransform::TxProject) {

983

QPaintEngine::drawTextItem(p, textItem);

return;

}

*d->currentPage << "q\n";

988

if(!d->simplePen)

989

*d->currentPage << QPdf::generateMatrix(d->stroker.matrix);

bool hp = d->hasPen;

d->hasPen = false;

QBrush b = d->brush;

d->brush = d->pen.brush();

995

setBrush();

996

997

const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);

998

Q_ASSERT(ti.fontEngine->type() != QFontEngine::Multi);

999

d->drawTextItem(p, ti);

1000

d->hasPen = hp;

1001

d->brush = b;

1002

*d->currentPage << "Q\n";

1003

}

1004

1005

void QPdfEngine::drawHyperlink(const QRectF &r, const QUrl &url)

{

Q_D(QPdfEngine);

const uint annot = d->addXrefEntry(-1);

1010

const QByteArray urlascii = url.toEncoded();

1011

int len = urlascii.size();

1012

QVarLengthArray<char> url_esc;

1013

url_esc.reserve(len + 1);

1014

for (int j = 0; j < len; j++) {

1015

if (urlascii[j] == '(' || urlascii[j] == ')' || urlascii[j] == '\\')

1016

url_esc.append('\\');

1017

url_esc.append(urlascii[j]);

1018

}

1019

url_esc.append('\0');

1020

1021

char buf[256];

1022

const QRectF rr = d->pageMatrix().mapRect(r);

1023

d->xprintf("<<\n/Type /Annot\n/Subtype /Link\n/Rect [");

1024

d->xprintf("%s ", qt_real_to_string(rr.left(), buf));

1025

d->xprintf("%s ", qt_real_to_string(rr.top(), buf));

1026

d->xprintf("%s ", qt_real_to_string(rr.right(), buf));

1027

d->xprintf("%s", qt_real_to_string(rr.bottom(), buf));

1028

d->xprintf("]\n/Border [0 0 0]\n/A <<\n");

1029

d->xprintf("/Type /Action\n/S /URI\n/URI (%s)\n", url_esc.constData());

1030

d->xprintf(">>\n>>\n");

1031

d->xprintf("endobj\n");

1032

d->currentPage->annotations.append(annot);

1033

}

1034

1035

void QPdfEngine::updateState(const QPaintEngineState &state)

{

Q_D(QPdfEngine);

QPaintEngine::DirtyFlags flags = state.state();

1040

1041

if (flags & DirtyTransform)

1042

d->stroker.matrix = state.transform();

1043

1044

if (flags & DirtyPen) {

1045

d->pen = state.pen();

1046

d->hasPen = d->pen.style() != Qt::NoPen;

1047

d->stroker.setPen(d->pen, state.renderHints());

1048

QBrush penBrush = d->pen.brush();

1049

bool oldSimple = d->simplePen;

1050

d->simplePen = (d->hasPen && (penBrush.style() == Qt::SolidPattern) && penBrush.isOpaque() && d->opacity == 1.0);

1051

if (oldSimple != d->simplePen)

1052

flags |= DirtyTransform;

1053

} else if (flags & DirtyHints) {

1054

d->stroker.setPen(d->pen, state.renderHints());

1055

}

1056

if (flags & DirtyBrush) {

1057

d->brush = state.brush();

1058

if (d->brush.color().alpha() == 0 && d->brush.style() == Qt::SolidPattern)

1059

d->brush.setStyle(Qt::NoBrush);

1060

d->hasBrush = d->brush.style() != Qt::NoBrush;

1061

}

1062

if (flags & DirtyBrushOrigin) {

1063

d->brushOrigin = state.brushOrigin();

1064

flags |= DirtyBrush;

1065

}

1066

if (flags & DirtyOpacity) {

1067

d->opacity = state.opacity();

1068

if (d->simplePen && d->opacity != 1.0) {

1069

d->simplePen = false;

1070

flags |= DirtyTransform;

}

}

bool ce = d->clipEnabled;

1075

if (flags & DirtyClipPath) {

1076

d->clipEnabled = true;

1077

updateClipPath(state.clipPath(), state.clipOperation());

1078

} else if (flags & DirtyClipRegion) {

1079

d->clipEnabled = true;

1080

QPainterPath path;

1081

QVector<QRect> rects = state.clipRegion().rects();

1082

for (int i = 0; i < rects.size(); ++i)

1083

path.addRect(rects.at(i));

1084

updateClipPath(path, state.clipOperation());

1085

flags |= DirtyClipPath;

1086

} else if (flags & DirtyClipEnabled) {

1087

d->clipEnabled = state.isClipEnabled();

1088

}

1089

1090

if (ce != d->clipEnabled)

1091

flags |= DirtyClipPath;

1092

else if (!d->clipEnabled)

1093

flags &= ~DirtyClipPath;

1094

1095

setupGraphicsState(flags);

1096

}

1097

1098

void QPdfEngine::setupGraphicsState(QPaintEngine::DirtyFlags flags)

1099

{

1100

Q_D(QPdfEngine);

1101

if (flags & DirtyClipPath)

1102

flags |= DirtyTransform|DirtyPen|DirtyBrush;

1103

1104

if (flags & DirtyTransform) {

1105

*d->currentPage << "Q\n";

1106

flags |= DirtyPen|DirtyBrush;

1107

}

1108

1109

if (flags & DirtyClipPath) {

1110

*d->currentPage << "Q q\n";

1111

1112

d->allClipped = false;

1113

if (d->clipEnabled && !d->clips.isEmpty()) {

1114

for (int i = 0; i < d->clips.size(); ++i) {

1115

if (d->clips.at(i).isEmpty()) {

1116

d->allClipped = true;

break;

}

}

if (!d->allClipped) {

1121

for (int i = 0; i < d->clips.size(); ++i) {

1122

*d->currentPage << QPdf::generatePath(d->clips.at(i), QTransform(), QPdf::ClipPath);

}

}

}

}

if (flags & DirtyTransform) {

1129

*d->currentPage << "q\n";

1130

if (d->simplePen && !d->stroker.matrix.isIdentity())

1131

*d->currentPage << QPdf::generateMatrix(d->stroker.matrix);

1132

}

1133

if (flags & DirtyBrush)

1134

setBrush();

1135

if (d->simplePen && (flags & DirtyPen))

setPen();

}

extern QPainterPath qt_regionToPath(const QRegion &region);

1140

1141

void QPdfEngine::updateClipPath(const QPainterPath &p, Qt::ClipOperation op)

1142

{

1143

Q_D(QPdfEngine);

1144

QPainterPath path = d->stroker.matrix.map(p);

1145

//qDebug() << "updateClipPath: " << d->stroker.matrix << p.boundingRect() << path.boundingRect() << op;

1146

1147

if (op == Qt::NoClip) {

1148

d->clipEnabled = false;

1149

d->clips.clear();

1150

} else if (op == Qt::ReplaceClip) {

1151

d->clips.clear();

1152

d->clips.append(path);

1153

} else if (op == Qt::IntersectClip) {

1154

d->clips.append(path);

1155

} else { // UniteClip

1156

// ask the painter for the current clipping path. that's the easiest solution

1157

path = painter()->clipPath();

1158

path = d->stroker.matrix.map(path);

1159

d->clips.clear();

1160

d->clips.append(path);

}

}

void QPdfEngine::setPen()

1165

{

1166

Q_D(QPdfEngine);

1167

if (d->pen.style() == Qt::NoPen)

1168

return;

1169

QBrush b = d->pen.brush();

1170

Q_ASSERT(b.style() == Qt::SolidPattern && b.isOpaque());

1171

1172

QColor rgba = b.color();

1173

if (d->grayscale) {

1174

qreal gray = qGray(rgba.rgba())/255.;

1175

*d->currentPage << gray << gray << gray;

1176

} else {

1177

*d->currentPage << rgba.redF()

<< rgba.greenF()

<< rgba.blueF();

}

*d->currentPage << "SCN\n";

1182

1183

*d->currentPage << d->pen.widthF() << "w ";

1184

1185

int pdfCapStyle = 0;

1186

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 ";

1200

1201

int pdfJoinStyle = 0;

1202

switch(d->pen.joinStyle()) {

1203

case Qt::MiterJoin:

1204

case Qt::SvgMiterJoin:

1205

*d->currentPage << qMax(qreal(1.0), d->pen.miterLimit()) << "M ";

pdfJoinStyle = 0;

break;

case Qt::BevelJoin:

pdfJoinStyle = 2;

break;

case Qt::RoundJoin:

pdfJoinStyle = 1;

break;

default:

break;

}

*d->currentPage << pdfJoinStyle << "j ";

1218

1219

*d->currentPage << QPdf::generateDashes(d->pen);

}

void QPdfEngine::setBrush()

1224

{

1225

Q_D(QPdfEngine);

1226

Qt::BrushStyle style = d->brush.style();

1227

if (style == Qt::NoBrush)

return;

bool specifyColor;

int gStateObject = 0;

1232

int patternObject = d->addBrushPattern(d->stroker.matrix, &specifyColor, &gStateObject);

1233

if (!patternObject && !specifyColor)

1234

return;

1235

1236

*d->currentPage << (patternObject ? "/PCSp cs " : "/CSp cs ");

1237

if (specifyColor) {

1238

QColor rgba = d->brush.color();

1239

if (d->grayscale) {

1240

qreal gray = qGray(rgba.rgba())/255.;

1241

*d->currentPage << gray << gray << gray;

1242

} else {

1243

*d->currentPage << rgba.redF()

<< rgba.greenF()

<< rgba.blueF();

}

}

if (patternObject)

*d->currentPage << "/Pat" << patternObject;

1250

*d->currentPage << "scn\n";

1251

1252

if (gStateObject)

1253

*d->currentPage << "/GState" << gStateObject << "gs\n";

1254

else

1255

*d->currentPage << "/GSa gs\n";

}

bool QPdfEngine::newPage()

{

Q_D(QPdfEngine);

if (!isActive())

return false;

d->newPage();

setupGraphicsState(DirtyBrush|DirtyPen|DirtyClipPath);

1267

QFile *outfile = qobject_cast<QFile*> (d->outDevice);

1268

if (outfile && outfile->error() != QFile::NoError)

return false;

return true;

}

QPaintEngine::Type QPdfEngine::type() const

1274

{

1275

return QPaintEngine::Pdf;

1276

}

1277

1278

void QPdfEngine::setResolution(int resolution)

1279

{

1280

Q_D(QPdfEngine);

1281

d->resolution = resolution;

1282

}

1283

1284

int QPdfEngine::resolution() const

1285

{

1286

Q_D(const QPdfEngine);

1287

return d->resolution;

1288

}

1289

1290

void QPdfEngine::setPageLayout(const QPageLayout &pageLayout)

1291

{

1292

Q_D(QPdfEngine);

1293

d->m_pageLayout = pageLayout;

1294

}

1295

1296

void QPdfEngine::setPageSize(const QPageSize &pageSize)

1297

{

1298

Q_D(QPdfEngine);

1299

d->m_pageLayout.setPageSize(pageSize);

1300

}

1301

1302

void QPdfEngine::setPageOrientation(QPageLayout::Orientation orientation)

1303

{

1304

Q_D(QPdfEngine);

1305

d->m_pageLayout.setOrientation(orientation);

1306

}

1307

1308

void QPdfEngine::setPageMargins(const QMarginsF &margins, QPageLayout::Unit units)

1309

{

1310

Q_D(QPdfEngine);

1311

d->m_pageLayout.setUnits(units);

1312

d->m_pageLayout.setMargins(margins);

1313

}

1314

1315

QPageLayout QPdfEngine::pageLayout() const

1316

{

1317

Q_D(const QPdfEngine);

1318

return d->m_pageLayout;

1319

}

1320

1321

// Metrics are in Device Pixels

1322

int QPdfEngine::metric(QPaintDevice::PaintDeviceMetric metricType) const

1323

{

1324

Q_D(const QPdfEngine);

1325

int val;

1326

switch (metricType) {

1327

case QPaintDevice::PdmWidth:

1328

val = d->m_pageLayout.paintRectPixels(d->resolution).width();

1329

break;

1330

case QPaintDevice::PdmHeight:

1331

val = d->m_pageLayout.paintRectPixels(d->resolution).height();

1332

break;

1333

case QPaintDevice::PdmDpiX:

1334

case QPaintDevice::PdmDpiY:

1335

val = d->resolution;

1336

break;

1337

case QPaintDevice::PdmPhysicalDpiX:

1338

case QPaintDevice::PdmPhysicalDpiY:

1339

val = 1200;

1340

break;

1341

case QPaintDevice::PdmWidthMM:

1342

val = qRound(d->m_pageLayout.paintRect(QPageLayout::Millimeter).width());

1343

break;

1344

case QPaintDevice::PdmHeightMM:

1345

val = qRound(d->m_pageLayout.paintRect(QPageLayout::Millimeter).height());

1346

break;

1347

case QPaintDevice::PdmNumColors:

1348

val = INT_MAX;

1349

break;

1350

case QPaintDevice::PdmDepth:

1351

val = 32;

1352

break;

1353

case QPaintDevice::PdmDevicePixelRatio:

1354

val = 1;

1355

break;

1356

case QPaintDevice::PdmDevicePixelRatioScaled:

1357

val = 1 * QPaintDevice::devicePixelRatioFScale();

1358

break;

1359

default:

1360

qWarning("QPdfWriter::metric: Invalid metric command");

return 0;

}

return val;

}

QPdfEnginePrivate::QPdfEnginePrivate()

1367

: clipEnabled(false), allClipped(false), hasPen(true), hasBrush(false), simplePen(false),

1368

outDevice(0), ownsDevice(false),

1369

embedFonts(true),

1370

grayscale(false),

1371

m_pageLayout(QPageSize(QPageSize::A4), QPageLayout::Portrait, QMarginsF(10, 10, 10, 10))

{

resolution = 1200;

currentObject = 1;

currentPage = 0;

stroker.stream = 0;

streampos = 0;

stream = new QDataStream;

1381

}

1382

1383

bool QPdfEngine::begin(QPaintDevice *pdev)

{

Q_D(QPdfEngine);

d->pdev = pdev;

if (!d->outDevice) {

if (!d->outputFileName.isEmpty()) {

1390

QFile *file = new QFile(d->outputFileName);

1391

if (!file->open(QFile::WriteOnly|QFile::Truncate)) {

delete file;

return false;

}

d->outDevice = file;

} else {

return false;

}

d->ownsDevice = true;

1400

}

1401

1402

d->currentObject = 1;

1403

1404

d->currentPage = new QPdfPage;

1405

d->stroker.stream = d->currentPage;

1406

d->opacity = 1.0;

1407

1408

d->stream->setDevice(d->outDevice);

d->streampos = 0;

d->hasPen = true;

d->hasBrush = false;

d->clipEnabled = false;

1414

d->allClipped = false;

1415

1416

d->xrefPositions.clear();

d->pageRoot = 0;

d->catalog = 0;

d->info = 0;

d->graphicsState = 0;

1421

d->patternColorSpace = 0;

1422

d->simplePen = false;

1423

1424

d->pages.clear();

1425

d->imageCache.clear();

1426

d->alphaCache.clear();

setActive(true);

d->writeHeader();

newPage();

return true;

}

bool QPdfEngine::end()

{

Q_D(QPdfEngine);

d->writeTail();

d->stream->unsetDevice();

1441

1442

qDeleteAll(d->fonts);

1443

d->fonts.clear();

1444

delete d->currentPage;

1445

d->currentPage = 0;

1446

1447

if (d->outDevice && d->ownsDevice) {

1448

d->outDevice->close();

delete d->outDevice;

d->outDevice = 0;

}

setActive(false);

return true;

}

QPdfEnginePrivate::~QPdfEnginePrivate()

{

qDeleteAll(fonts);

delete currentPage;

delete stream;

}

void QPdfEnginePrivate::writeHeader()

1465

{

1466

addXrefEntry(0,false);

1467

1468

xprintf("%%PDF-1.4\n");

writeInfo();

catalog = addXrefEntry(-1);

1473

pageRoot = requestObject();

xprintf("<<\n"

"/Type /Catalog\n"

"/Pages %d 0 R\n"

">>\n"

"endobj\n", pageRoot);

1479

1480

// graphics state

1481

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

1494

patternColorSpace = addXrefEntry(-1);

1495

xprintf("[/Pattern /DeviceRGB]\n"

"endobj\n");

}

void QPdfEnginePrivate::writeInfo()

1500

{

1501

info = addXrefEntry(-1);

1502

xprintf("<<\n/Title ");

1503

printString(title);

1504

xprintf("\n/Creator ");

1505

printString(creator);

1506

xprintf("\n/Producer ");

1507

printString(QString::fromLatin1("Qt " QT_VERSION_STR));

1508

QDateTime now = QDateTime::currentDateTimeUtc();

1509

QTime t = now.time();

1510

QDate d = now.date();

1511

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()

1523

{

1524

addXrefEntry(pageRoot);

xprintf("<<\n"

"/Type /Pages\n"

"/Kids \n"

"[\n");

int size = pages.size();

1531

for (int i = 0; i < size; ++i)

1532

xprintf("%d 0 R\n", pages[i]);

1533

xprintf("]\n");

1534

1535

//xprintf("/Group <</S /Transparency /I true /K false>>\n");

1536

xprintf("/Count %d\n", pages.size());

1537

1538

xprintf("/ProcSet [/PDF /Text /ImageB /ImageC]\n"

">>\n"

"endobj\n");

}

void QPdfEnginePrivate::embedFont(QFontSubset *font)

1545

{

1546

//qDebug() << "embedFont" << font->object_id;

1547

int fontObject = font->object_id;

1548

QByteArray fontData = font->toTruetype();

1549

#ifdef FONT_DUMP

1550

static int i = 0;

1551

QString fileName("font%1.ttf");

1552

fileName = fileName.arg(i++);

1553

QFile ff(fileName);

1554

ff.open(QFile::WriteOnly);

ff.write(fontData);

ff.close();

#endif

int fontDescriptor = requestObject();

1560

int fontstream = requestObject();

1561

int cidfont = requestObject();

1562

int toUnicode = requestObject();

1563

1564

QFontEngine::Properties properties = font->fontEngine->properties();

1565

QByteArray postscriptName = properties.postscriptName.replace(' ', '_');

1566

1567

{

1568

qreal scale = 1000/properties.emSquare.toReal();

1569

addXrefEntry(fontDescriptor);

1570

QByteArray descriptor;

1571

QPdf::ByteStream s(&descriptor);

1572

s << "<< /Type /FontDescriptor\n"

1573

"/FontName /Q";

1574

int tag = fontDescriptor;

1575

for (int i = 0; i < 5; ++i) {

1576

s << (char)('A' + (tag % 26));

1577

tag /= 26;

1578

}

1579

s << '+' << postscriptName << "\n"

1580

"/Flags " << 4 << "\n"

1581

"/FontBBox ["

1582

<< properties.boundingBox.x()*scale

1583

<< -(properties.boundingBox.y() + properties.boundingBox.height())*scale

1584

<< (properties.boundingBox.x() + properties.boundingBox.width())*scale

1585

<< -properties.boundingBox.y()*scale << "]\n"

1586

"/ItalicAngle " << properties.italicAngle.toReal() << "\n"

1587

"/Ascent " << properties.ascent.toReal()*scale << "\n"

1588

"/Descent " << -properties.descent.toReal()*scale << "\n"

1589

"/CapHeight " << properties.capHeight.toReal()*scale << "\n"

1590

"/StemV " << properties.lineWidth.toReal()*scale << "\n"

1591

"/FontFile2 " << fontstream << "0 R\n"

">> endobj\n";

write(descriptor);

}

{

addXrefEntry(fontstream);

1597

QByteArray header;

1598

QPdf::ByteStream s(&header);

1599

1600

int length_object = requestObject();

1601

s << "<<\n"

1602

"/Length1 " << fontData.size() << "\n"

1603

"/Length " << length_object << "0 R\n";

1604

if (do_compress)

1605

s << "/Filter /FlateDecode\n";

s << ">>\n"

"stream\n";

write(header);

int len = writeCompressed(fontData);

1610

write("endstream\n"

1611

"endobj\n");

1612

addXrefEntry(length_object);

xprintf("%d\n"

"endobj\n", len);

}

{

addXrefEntry(cidfont);

1618

QByteArray cid;

1619

QPdf::ByteStream s(&cid);

1620

s << "<< /Type /Font\n"

1621

"/Subtype /CIDFontType2\n"

1622

"/BaseFont /" << postscriptName << "\n"

1623

"/CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >>\n"

1624

"/FontDescriptor " << fontDescriptor << "0 R\n"

1625

"/CIDToGIDMap /Identity\n"

1626

<< font->widthArray() <<

">>\n"

"endobj\n";

write(cid);

}

{

addXrefEntry(toUnicode);

1633

QByteArray touc = font->createToUnicodeMap();

1634

xprintf("<< /Length %d >>\n"

1635

"stream\n", touc.length());

write(touc);

write("endstream\n"

"endobj\n");

}

{

addXrefEntry(fontObject);

1642

QByteArray font;

1643

QPdf::ByteStream s(&font);

1644

s << "<< /Type /Font\n"

1645

"/Subtype /Type0\n"

1646

"/BaseFont /" << postscriptName << "\n"

1647

"/Encoding /Identity-H\n"

1648

"/DescendantFonts [" << cidfont << "0 R]\n"

1649

"/ToUnicode " << toUnicode << "0 R"

">>\n"

"endobj\n";

write(font);

}

}

void QPdfEnginePrivate::writeFonts()

1658

{

1659

for (QHash<QFontEngine::FaceId, QFontSubset *>::iterator it = fonts.begin(); it != fonts.end(); ++it) {

embedFont(*it);

delete *it;

}

fonts.clear();

}

void QPdfEnginePrivate::writePage()

1667

{

1668

if (pages.empty())

pages.empty()	Description
TRUE	never evaluated
FALSE	never evaluated

1669

return;

never executed: return;

1670

1671

*currentPage << "Q Q\n";

1672

1673

uint pageStream = requestObject();

1674

uint pageStreamLength = requestObject();

1675

uint resources = requestObject();

1676

uint annots = requestObject();

1677

1678

addXrefEntry(pages.lastconstLast());

xprintf("<<\n"

"/Type /Page\n"

"/Parent %d 0 R\n"

"/Contents %d 0 R\n"

"/Resources %d 0 R\n"

1684

"/Annots %d 0 R\n"

1685

"/MediaBox [0 0 %d %d]\n"

1686

">>\n"

1687

"endobj\n",

1688

pageRoot, pageStream, resources, annots,

1689

// make sure we use the pagesize from when we started the page, since the user may have changed it

1690

currentPage->pageSize.width(), currentPage->pageSize.height());

1691

1692

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);

1702

1703

for (int i = 0; i < currentPage->graphicStates.size(); ++i)

i < currentPag...cStates.size()	Description
TRUE	never evaluated
FALSE	never evaluated

1704

xprintf("/GState%d %d 0 R\n", currentPage->graphicStates.at(i), currentPage->graphicStates.at(i));

never executed: xprintf("/GState%d %d 0 R\n", currentPage->graphicStates.at(i), currentPage->graphicStates.at(i));

1705

xprintf(">>\n");

1706

1707

xprintf("/Pattern <<\n");

1708

for (int i = 0; i < currentPage->patterns.size(); ++i)

i < currentPag...atterns.size()	Description
TRUE	never evaluated
FALSE	never evaluated

1709

xprintf("/Pat%d %d 0 R\n", currentPage->patterns.at(i), currentPage->patterns.at(i));

never executed: xprintf("/Pat%d %d 0 R\n", currentPage->patterns.at(i), currentPage->patterns.at(i));

1710

xprintf(">>\n");

1711

1712

xprintf("/Font <<\n");

1713

for (int i = 0; i < currentPage->fonts.size();++i)

i < currentPage->fonts.size()	Description
TRUE	never evaluated
FALSE	never evaluated

1714

xprintf("/F%d %d 0 R\n", currentPage->fonts[i], currentPage->fonts[i]);

never executed: xprintf("/F%d %d 0 R\n", currentPage->fonts[i], currentPage->fonts[i]);

1715

xprintf(">>\n");

1716

1717

xprintf("/XObject <<\n");

1718

for (int i = 0; i<currentPage->images.size(); ++i) {

i<currentPage->images.size()	Description
TRUE	never evaluated
FALSE	never evaluated

1719

xprintf("/Im%d %d 0 R\n", currentPage->images.at(i), currentPage->images.at(i));

1720

}

never executed: end of block

xprintf(">>\n");

xprintf(">>\n"

"endobj\n");

addXrefEntry(annots);

1727

xprintf("[ ");

1728

for (int i = 0; i<currentPage->annotations.size(); ++i) {

i<currentPage-...tations.size()	Description
TRUE	never evaluated
FALSE	never evaluated

1729

xprintf("%d 0 R ", currentPage->annotations.at(i));

1730

}

never executed: end of block

1731

xprintf("]\nendobj\n");

1732

1733

addXrefEntry(pageStream);

1734

xprintf("<<\n"

1735

"/Length %d 0 R\n", pageStreamLength); // object number for stream length object

1736

if (do_compress)

do_compress	Description
TRUE	never evaluated
FALSE	never evaluated

1737

xprintf("/Filter /FlateDecode\n");

never executed: xprintf("/Filter /FlateDecode\n");

xprintf(">>\n");

xprintf("stream\n");

QIODevice *content = currentPage->stream();

1742

int len = writeCompressed(content);

1743

xprintf("endstream\n"

1744

"endobj\n");

1745

1746

addXrefEntry(pageStreamLength);

1747

xprintf("%d\nendobj\n",len);

1748

}

never executed: end of block

1749

1750

void QPdfEnginePrivate::writeTail()

{

writePage();

writeFonts();

writePageRoot();

addXrefEntry(xrefPositions.size(),false);

1756

xprintf("xref\n"

1757

"0 %d\n"

1758

"%010d 65535 f \n", xrefPositions.size()-1, xrefPositions[0]);

1759

1760

for (int i = 1; i < xrefPositions.size()-1; ++i)

i < xrefPositions.size()-1	Description
TRUE	never evaluated
FALSE	never evaluated

1761

xprintf("%010d 00000 n \n", xrefPositions[i]);

never executed: 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.lastconstLast());

1772

}

never executed: end of block

1773

1774

int QPdfEnginePrivate::addXrefEntry(int object, bool printostr)

1775

{

1776

if (object < 0)

1777

object = requestObject();

1778

1779

if (object>=xrefPositions.size())

1780

xrefPositions.resize(object+1);

1781

1782

xrefPositions[object] = streampos;

1783

if (printostr)

1784

xprintf("%d 0 obj\n",object);

return object;

}

void QPdfEnginePrivate::printString(const QString &string) {

1790

// The 'text string' type in PDF is encoded either as PDFDocEncoding, or

1791

// Unicode UTF-16 with a Unicode byte order mark as the first character

1792

// (0xfeff), with the high-order byte first.

1793

QByteArray array("(\xfe\xff");

1794

const ushort *utf16 = string.utf16();

1795

1796

for (int i=0; i < string.size(); ++i) {

1797

char part[2] = {char((*(utf16 + i)) >> 8), char((*(utf16 + i)) & 0xff)};

1798

for(int j=0; j < 2; ++j) {

1799

if (part[j] == '(' || part[j] == ')' || part[j] == '\\')

1800

array.append('\\');

1801

array.append(part[j]);

}

}

array.append(')');

write(array);

}

// For strings up to 10000 bytes only !

1810

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);

1821

1822

Q_ASSERT(bufsize<msize);

va_end(args);

stream->writeRawData(buf, bufsize);

1827

streampos += bufsize;

1828

}

1829

1830

int QPdfEnginePrivate::writeCompressed(QIODevice *dev)

1831

{

1832

#ifndef QT_NO_COMPRESS

1833

if (do_compress) {

1834

int size = QPdfPage::chunkSize();

1835

int sum = 0;

1836

::z_stream zStruct;

1837

zStruct.zalloc = Z_NULL;

1838

zStruct.zfree = Z_NULL;

1839

zStruct.opaque = Z_NULL;

1840

if (::deflateInit(&zStruct, Z_DEFAULT_COMPRESSION) != Z_OK) {

1841

qWarning("QPdfStream::writeCompressed: Error in deflateInit()");

1842

return sum;

1843

}

1844

zStruct.avail_in = 0;

1845

QByteArray in, out;

1846

out.resize(size);

1847

while (!dev->atEnd() || zStruct.avail_in != 0) {

1848

if (zStruct.avail_in == 0) {

1849

in = dev->read(size);

1850

zStruct.avail_in = in.size();

1851

zStruct.next_in = reinterpret_cast<unsigned char*>(in.data());

1852

if (in.size() <= 0) {

1853

qWarning("QPdfStream::writeCompressed: Error in read()");

1854

::deflateEnd(&zStruct);

return sum;

}

}

zStruct.next_out = reinterpret_cast<unsigned char*>(out.data());

1859

zStruct.avail_out = out.size();

1860

if (::deflate(&zStruct, 0) != Z_OK) {

1861

qWarning("QPdfStream::writeCompressed: Error in deflate()");

1862

::deflateEnd(&zStruct);

1863

return sum;

1864

}

1865

int written = out.size() - zStruct.avail_out;

1866

stream->writeRawData(out.constData(), written);

1867

streampos += written;

sum += written;

}

int ret;

do {

zStruct.next_out = reinterpret_cast<unsigned char*>(out.data());

1873

zStruct.avail_out = out.size();

1874

ret = ::deflate(&zStruct, Z_FINISH);

1875

if (ret != Z_OK && ret != Z_STREAM_END) {

1876

qWarning("QPdfStream::writeCompressed: Error in deflate()");

1877

::deflateEnd(&zStruct);

1878

return sum;

1879

}

1880

int written = out.size() - zStruct.avail_out;

1881

stream->writeRawData(out.constData(), written);

1882

streampos += written;

1883

sum += written;

1884

} while (ret == Z_OK);

1885

1886

::deflateEnd(&zStruct);

return sum;

} else

#endif

{

QByteArray arr;

int sum = 0;

while (!dev->atEnd()) {

1895

arr = dev->read(QPdfPage::chunkSize());

1896

stream->writeRawData(arr.constData(), arr.size());

1897

streampos += arr.size();

sum += arr.size();

}

return sum;

}

}

int QPdfEnginePrivate::writeCompressed(const char *src, int len)

1905

{

1906

#ifndef QT_NO_COMPRESS

1907

if(do_compress) {

1908

uLongf destLen = len + len/100 + 13; // zlib requirement

1909

Bytef* dest = new Bytef[destLen];

1910

if (Z_OK == ::compress(dest, &destLen, (const Bytef*) src, (uLongf)len)) {

1911

stream->writeRawData((const char*)dest, destLen);

1912

} else {

1913

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,

1928

int maskObject, int softMaskObject, bool dct, bool isMono)

1929

{

1930

int image = addXrefEntry(-1);

xprintf("<<\n"

"/Type /XObject\n"

"/Subtype /Image\n"

"/Width %d\n"

"/Height %d\n", width, height);

if (depth == 1) {

if (!isMono) {

xprintf("/ImageMask true\n"

1940

"/Decode [1 0]\n");

1941

} else {

1942

xprintf("/BitsPerComponent 1\n"

1943

"/ColorSpace /DeviceGray\n");

1944

}

1945

} else {

1946

xprintf("/BitsPerComponent 8\n"

1947

"/ColorSpace %s\n", (depth == 32) ? "/DeviceRGB" : "/DeviceGray");

1948

}

1949

if (maskObject > 0)

1950

xprintf("/Mask %d 0 R\n", maskObject);

1951

if (softMaskObject > 0)

1952

xprintf("/SMask %d 0 R\n", softMaskObject);

1953

1954

int lenobj = requestObject();

1955

xprintf("/Length %d 0 R\n", lenobj);

1956

if (interpolateImages)

1957

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");

1967

else

1968

xprintf(">>\nstream\n");

1969

len = writeCompressed(data);

1970

}

1971

xprintf("endstream\n"

1972

"endobj\n");

1973

addXrefEntry(lenobj);

xprintf("%d\n"

"endobj\n", len);

return image;

}

struct QGradientBound {

qreal start;

qreal stop;

int function;

bool reverse;

};

Q_DECLARE_TYPEINFO(QGradientBound, Q_PRIMITIVE_TYPE);

1986

1987

int QPdfEnginePrivate::createShadingFunction(const QGradient *gradient, int from, int to, bool reflect, bool alpha)

1988

{

1989

QGradientStops stops = gradient->stops();

1990

if (stops.isEmpty()) {

1991

stops << QGradientStop(0, Qt::black);

1992

stops << QGradientStop(1, Qt::white);

1993

}

1994

if (stops.at(0).first > 0)

1995

stops.prepend(QGradientStop(0, stops.at(0).second));

1996

if (stops.at(stops.size() - 1).first < 1)

1997

stops.append(QGradientStop(1, stops.at(stops.size() - 1).second));

1998

1999

QVector<int> functions;

2000

const int numStops = stops.size();

2001

functions.reserve(numStops - 1);

2002

for (int i = 0; i < numStops - 1; ++i) {

2003

int f = addXrefEntry(-1);

2004

QByteArray data;

2005

QPdf::ByteStream s(&data);

s << "<<\n"

"/FunctionType 2\n"

"/Domain [0 1]\n"

"/N 1\n";

if (alpha) {

s << "/C0 [" << stops.at(i).second.alphaF() << "]\n"

2012

"/C1 [" << stops.at(i + 1).second.alphaF() << "]\n";

2013

} else {

2014

s << "/C0 [" << stops.at(i).second.redF() << stops.at(i).second.greenF() << stops.at(i).second.blueF() << "]\n"

2015

"/C1 [" << stops.at(i + 1).second.redF() << stops.at(i + 1).second.greenF() << stops.at(i + 1).second.blueF() << "]\n";

}

s << ">>\n"

"endobj\n";

write(data);

functions << f;

}

QVector<QGradientBound> gradientBounds;

2024

gradientBounds.reserve((to - from) * (numStops - 1));

2025

2026

for (int step = from; step < to; ++step) {

2027

if (reflect && step % 2) {

2028

for (int i = numStops - 1; i > 0; --i) {

2029

QGradientBound b;

2030

b.start = step + 1 - qBound(qreal(0.), stops.at(i).first, qreal(1.));

2031

b.stop = step + 1 - qBound(qreal(0.), stops.at(i - 1).first, qreal(1.));

2032

b.function = functions.at(i - 1);

b.reverse = true;

gradientBounds << b;

}

} else {

for (int i = 0; i < numStops - 1; ++i) {

2038

QGradientBound b;

2039

b.start = step + qBound(qreal(0.), stops.at(i).first, qreal(1.));

2040

b.stop = step + qBound(qreal(0.), stops.at(i + 1).first, qreal(1.));

2041

b.function = functions.at(i);

b.reverse = false;

gradientBounds << b;

}

}

}

// normalize bounds to [0..1]

2049

qreal bstart = gradientBounds.at(0).start;

2050

qreal bend = gradientBounds.at(gradientBounds.size() - 1).stop;

2051

qreal norm = 1./(bend - bstart);

2052

for (int i = 0; i < gradientBounds.size(); ++i) {

2053

gradientBounds[i].start = (gradientBounds[i].start - bstart)*norm;

2054

gradientBounds[i].stop = (gradientBounds[i].stop - bstart)*norm;

}

int function;

if (gradientBounds.size() > 1) {

2059

function = addXrefEntry(-1);

2060

QByteArray data;

2061

QPdf::ByteStream s(&data);

s << "<<\n"

"/FunctionType 3\n"

"/Domain [0 1]\n"

"/Bounds [";

for (int i = 1; i < gradientBounds.size(); ++i)

2067

s << gradientBounds.at(i).start;

2068

s << "]\n"

2069

"/Encode [";

2070

for (int i = 0; i < gradientBounds.size(); ++i)

2071

s << (gradientBounds.at(i).reverse ? "1 0 " : "0 1 ");

2072

s << "]\n"

2073

"/Functions [";

2074

for (int i = 0; i < gradientBounds.size(); ++i)

2075

s << gradientBounds.at(i).function << "0 R ";

s << "]\n"

">>\n";

write(data);

} else {

function = functions.at(0);

}

return function;

}

int QPdfEnginePrivate::generateLinearGradientShader(const QLinearGradient *gradient, const QTransform &matrix, bool alpha)

2086

{

2087

QPointF start = gradient->start();

2088

QPointF stop = gradient->finalStop();

2089

QPointF offset = stop - start;

2090

Q_ASSERT(gradient->coordinateMode() == QGradient::LogicalMode);

int from = 0;

int to = 1;

bool reflect = false;

2095

switch (gradient->spread()) {

2096

case QGradient::PadSpread:

2097

break;

2098

case QGradient::ReflectSpread:

2099

reflect = true;

2100

// fall through

2101

case QGradient::RepeatSpread: {

2102

// calculate required bounds

2103

QRectF pageRect = m_pageLayout.fullRectPixels(resolution);

2104

QTransform inv = matrix.inverted();

2105

QPointF page_rect[4] = { inv.map(pageRect.topLeft()),

2106

inv.map(pageRect.topRight()),

2107

inv.map(pageRect.bottomLeft()),

2108

inv.map(pageRect.bottomRight()) };

2109

2110

qreal length = offset.x()*offset.x() + offset.y()*offset.y();

2111

2112

// find the max and min values in offset and orth direction that are needed to cover

// the whole page

from = INT_MAX;

to = INT_MIN;

for (int i = 0; i < 4; ++i) {

2117

qreal off = ((page_rect[i].x() - start.x()) * offset.x() + (page_rect[i].y() - start.y()) * offset.y())/length;

2118

from = qMin(from, qFloor(off));

2119

to = qMax(to, qCeil(off));

2120

}

2121

2122

stop = start + to * offset;

2123

start = start + from * offset;\

break;

}

}

int function = createShadingFunction(gradient, from, to, reflect, alpha);

2129

2130

QByteArray shader;

2131

QPdf::ByteStream s(&shader);

2132

s << "<<\n"

2133

"/ShadingType 2\n"

2134

"/ColorSpace " << (alpha ? "/DeviceGray\n" : "/DeviceRGB\n") <<

2135

"/AntiAlias true\n"

2136

"/Coords [" << start.x() << start.y() << stop.x() << stop.y() << "]\n"

2137

"/Extend [true true]\n"

2138

"/Function " << function << "0 R\n"

2139

">>\n"

2140

"endobj\n";

2141

int shaderObject = addXrefEntry(-1);

write(shader);

return shaderObject;

}

int QPdfEnginePrivate::generateRadialGradientShader(const QRadialGradient *gradient, const QTransform &matrix, bool alpha)

2147

{

2148

QPointF p1 = gradient->center();

2149

qreal r1 = gradient->centerRadius();

2150

QPointF p0 = gradient->focalPoint();

2151

qreal r0 = gradient->focalRadius();

2152

2153

Q_ASSERT(gradient->coordinateMode() == QGradient::LogicalMode);

int from = 0;

int to = 1;

bool reflect = false;

2158

switch (gradient->spread()) {

2159

case QGradient::PadSpread:

2160

break;

2161

case QGradient::ReflectSpread:

2162

reflect = true;

2163

// fall through

2164

case QGradient::RepeatSpread: {

2165

Q_ASSERT(qFuzzyIsNull(r0)); // QPainter emulates if this is not 0

2166

2167

QRectF pageRect = m_pageLayout.fullRectPixels(resolution);

2168

QTransform inv = matrix.inverted();

2169

QPointF page_rect[4] = { inv.map(pageRect.topLeft()),

2170

inv.map(pageRect.topRight()),

2171

inv.map(pageRect.bottomLeft()),

2172

inv.map(pageRect.bottomRight()) };

2173

2174

// increase to until the whole page fits into it

2175

bool done = false;

2176

while (!done) {

2177

QPointF center = QPointF(p0.x() + to*(p1.x() - p0.x()), p0.y() + to*(p1.y() - p0.y()));

2178

double radius = r0 + to*(r1 - r0);

2179

double r2 = radius*radius;

2180

done = true;

2181

for (int i = 0; i < 4; ++i) {

2182

QPointF off = page_rect[i] - center;

2183

if (off.x()*off.x() + off.y()*off.y() > r2) {

++to;

done = false;

break;

}

}

}

p1 = QPointF(p0.x() + to*(p1.x() - p0.x()), p0.y() + to*(p1.y() - p0.y()));

2191

r1 = r0 + to*(r1 - r0);

break;

}

}

int function = createShadingFunction(gradient, from, to, reflect, alpha);

2197

2198

QByteArray shader;

2199

QPdf::ByteStream s(&shader);

2200

s << "<<\n"

2201

"/ShadingType 3\n"

2202

"/ColorSpace " << (alpha ? "/DeviceGray\n" : "/DeviceRGB\n") <<

2203

"/AntiAlias true\n"

2204

"/Domain [0 1]\n"

2205

"/Coords [" << p0.x() << p0.y() << r0 << p1.x() << p1.y() << r1 << "]\n"

2206

"/Extend [true true]\n"

2207

"/Function " << function << "0 R\n"

2208

">>\n"

2209

"endobj\n";

2210

int shaderObject = addXrefEntry(-1);

write(shader);

return shaderObject;

}

int QPdfEnginePrivate::generateGradientShader(const QGradient *gradient, const QTransform &matrix, bool alpha)

2216

{

2217

switch (gradient->type()) {

2218

case QGradient::LinearGradient:

never executed: case QGradient::LinearGradient:

2219

return generateLinearGradientShader(static_cast<const QLinearGradient *>(gradient), matrix, alpha);

never executed: return generateLinearGradientShader(static_cast<const QLinearGradient *>(gradient), matrix, alpha);

2220

case QGradient::RadialGradient:

never executed: case QGradient::RadialGradient:

2221

return generateRadialGradientShader(static_cast<const QRadialGradient *>(gradient), matrix, alpha);

never executed: return generateRadialGradientShader(static_cast<const QRadialGradient *>(gradient), matrix, alpha);

2222

case QGradient::ConicalGradient:

never executed: case QGradient::ConicalGradient:

2223

defaultQ_UNIMPLEMENTED(); // ### Implement me!

2224

never executed: break;

break;

never executed: break;

2225

case QGradient::NoGradient

never executed: case QGradient::NoGradient:

2226

qWarning() << "Implement me!"break;

never executed: break;

2227

}

2228

return 0;

never executed: return 0;

2229

}

2230

2231

int QPdfEnginePrivate::gradientBrush(const QBrush &b, const QTransform &matrix, int *gStateObject)

2232

{

2233

const QGradient *gradient = b.gradient();

2234

2235

if (!gradient || gradient->coordinateMode() != QGradient::LogicalMode)

2236

return 0;

2237

2238

QRectF pageRect = m_pageLayout.fullRectPixels(resolution);

2239

2240

QTransform m = b.transform() * matrix;

2241

int shaderObject = generateGradientShader(gradient, m);

2242

2243

QByteArray str;

2244

QPdf::ByteStream s(&str);

s << "<<\n"

"/Type /Pattern\n"

"/PatternType 2\n"

"/Shading " << shaderObject << "0 R\n"

"/Matrix ["

<< m.m11()

<< m.m12()

<< m.m21()

<< m.m22()

<< m.dx()

<< m.dy() << "]\n";

s << ">>\n"

"endobj\n";

int patternObj = addXrefEntry(-1);

2260

write(str);

2261

currentPage->patterns.append(patternObj);

if (!b.isOpaque()) {

bool ca = true;

QGradientStops stops = gradient->stops();

2266

int a = stops.at(0).second.alpha();

2267

for (int i = 1; i < stops.size(); ++i) {

2268

if (stops.at(i).second.alpha() != a) {

ca = false;

break;

}

}

if (ca) {

*gStateObject = addConstantAlphaObject(stops.at(0).second.alpha());

2275

} else {

2276

int alphaShaderObject = generateGradientShader(gradient, m, true);

2277

2278

QByteArray content;

2279

QPdf::ByteStream c(&content);

2280

c << "/Shader" << alphaShaderObject << "sh\n";

2281

2282

QByteArray form;

2283

QPdf::ByteStream f(&form);

f << "<<\n"

"/Type /XObject\n"

"/Subtype /Form\n"

"/BBox [0 0 " << pageRect.width() << pageRect.height() << "]\n"

2288

"/Group <</S /Transparency >>\n"

2289

"/Resources <<\n"

2290

"/Shading << /Shader" << alphaShaderObject << alphaShaderObject << "0 R >>\n"

2291

">>\n";

2292

2293

f << "/Length " << content.length() << "\n"

">>\n"

"stream\n"

<< content

<< "endstream\n"

"endobj\n";

int softMaskFormObject = addXrefEntry(-1);

2301

write(form);

2302

*gStateObject = addXrefEntry(-1);

2303

xprintf("<< /SMask << /S /Alpha /G %d 0 R >> >>\n"

2304

"endobj\n", softMaskFormObject);

2305

currentPage->graphicStates.append(*gStateObject);

}

}

return patternObj;

}

int QPdfEnginePrivate::addConstantAlphaObject(int brushAlpha, int penAlpha)

2313

{

2314

if (brushAlpha == 255 && penAlpha == 255)

2315

return 0;

2316

int object = alphaCache.value(QPair<uint, uint>(brushAlpha, penAlpha), 0);

2317

if (!object) {

2318

object = addXrefEntry(-1);

2319

QByteArray alphaDef;

2320

QPdf::ByteStream s(&alphaDef);

2321

s << "<<\n/ca " << (brushAlpha/qreal(255.)) << '\n';

2322

s << "/CA " << (penAlpha/qreal(255.)) << "\n>>";

2323

xprintf("%s\nendobj\n", alphaDef.constData());

2324

alphaCache.insert(QPair<uint, uint>(brushAlpha, penAlpha), object);

2325

}

2326

if (currentPage->graphicStates.indexOf(object) < 0)

2327

currentPage->graphicStates.append(object);

return object;

}

int QPdfEnginePrivate::addBrushPattern(const QTransform &m, bool *specifyColor, int *gStateObject)

2334

{

2335

int paintType = 2; // Uncolored tiling

int w = 8;

int h = 8;

*specifyColor = true;

2340

*gStateObject = 0;

2341

2342

QTransform matrix = m;

2343

matrix.translate(brushOrigin.x(), brushOrigin.y());

2344

matrix = matrix * pageMatrix();

2345

//qDebug() << brushOrigin << matrix;

2346

2347

Qt::BrushStyle style = brush.style();

2348

if (style == Qt::LinearGradientPattern || style == Qt::RadialGradientPattern) {// && style <= Qt::ConicalGradientPattern) {

2349

*specifyColor = false;

2350

return gradientBrush(brush, matrix, gStateObject);

2351

}

2352

2353

if ((!brush.isOpaque() && brush.style() < Qt::LinearGradientPattern) || opacity != 1.0)

2354

*gStateObject = addConstantAlphaObject(qRound(brush.color().alpha() * opacity),

2355

qRound(pen.color().alpha() * opacity));

2356

2357

int imageObject = -1;

2358

QByteArray pattern = QPdf::patternForBrush(brush);

2359

if (pattern.isEmpty()) {

2360

if (brush.style() != Qt::TexturePattern)

2361

return 0;

2362

QImage image = brush.textureImage();

2363

bool bitmap = true;

2364

imageObject = addImage(image, &bitmap, image.cacheKey());

2365

if (imageObject != -1) {

2366

QImage::Format f = image.format();

2367

if (f != QImage::Format_MonoLSB && f != QImage::Format_Mono) {

2368

paintType = 1; // Colored tiling

2369

*specifyColor = false;

}

w = image.width();

h = image.height();

QTransform m(w, 0, 0, -h, 0, h);

2374

QPdf::ByteStream s(&pattern);

2375

s << QPdf::generateMatrix(m);

2376

s << "/Im" << imageObject << " Do\n";

}

}

QByteArray str;

QPdf::ByteStream s(&str);

s << "<<\n"

"/Type /Pattern\n"

"/PatternType 1\n"

"/PaintType " << paintType << "\n"

2386

"/TilingType 1\n"

2387

"/BBox [0 0 " << w << h << "]\n"

2388

"/XStep " << w << "\n"

2389

"/YStep " << h << "\n"

"/Matrix ["

<< matrix.m11()

<< matrix.m12()

<< matrix.m21()

<< matrix.m22()

<< matrix.dx()

<< matrix.dy() << "]\n"

2397

"/Resources \n<< "; // open resource tree

2398

if (imageObject > 0) {

2399

s << "/XObject << /Im" << imageObject << ' ' << imageObject << "0 R >> ";

2400

}

2401

s << ">>\n"

2402

"/Length " << pattern.length() << "\n"

">>\n"

"stream\n"

<< pattern

<< "endstream\n"

"endobj\n";

int patternObj = addXrefEntry(-1);

2410

write(str);

2411

currentPage->patterns.append(patternObj);

return patternObj;

}

static inline bool is_monochrome(const QVector<QRgb> &colorTable)

2416

{

2417

return colorTable.size() == 2

2418

&& colorTable.at(0) == QColor(Qt::black).rgba()

2419

&& colorTable.at(1) == QColor(Qt::white).rgba()

;

}

/*!

* Adds an image to the pdf and return the pdf-object id. Returns -1 if adding the image failed.

2425

2426

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();

2437

if (image.depth() == 1 && *bitmap && is_monochrome(img.colorTable())) {

2438

if (format == QImage::Format_MonoLSB)

2439

image = image.convertToFormat(QImage::Format_Mono);

2440

format = QImage::Format_Mono;

2441

} else {

2442

*bitmap = false;

2443

if (format != QImage::Format_RGB32 && format != QImage::Format_ARGB32) {

2444

image = image.convertToFormat(QImage::Format_ARGB32);

2445

format = QImage::Format_ARGB32;

}

}

int w = image.width();

2450

int h = image.height();

2451

int d = image.depth();

2452

2453

if (format == QImage::Format_Mono) {

2454

int bytesPerLine = (w + 7) >> 3;

2455

QByteArray data;

2456

data.resize(bytesPerLine * h);

2457

char *rawdata = data.data();

2458

for (int y = 0; y < h; ++y) {

2459

memcpy(rawdata, image.constScanLine(y), bytesPerLine);

2460

rawdata += bytesPerLine;

2461

}

2462

object = writeImage(data, w, h, d, 0, 0, false, is_monochrome(img.colorTable()));

2463

} else {

2464

QByteArray softMaskData;

2465

bool dct = false;

2466

QByteArray imageData;

2467

bool hasAlpha = false;

2468

bool hasMask = false;

2469

2470

if (QImageWriter::supportedImageFormats().contains("jpeg") && !grayscale) {

2471

QBuffer buffer(&imageData);

2472

QImageWriter writer(&buffer, "jpeg");

2473

writer.setQuality(94);

writer.write(image);

dct = true;

if (format != QImage::Format_RGB32) {

2478

softMaskData.resize(w * h);

2479

uchar *sdata = (uchar *)softMaskData.data();

2480

for (int y = 0; y < h; ++y) {

2481

const QRgb *rgb = (const QRgb *)image.constScanLine(y);

2482

for (int x = 0; x < w; ++x) {

2483

uchar alpha = qAlpha(*rgb);

2484

*sdata++ = alpha;

2485

hasMask |= (alpha < 255);

2486

hasAlpha |= (alpha != 0 && alpha != 255);

++rgb;

}

}

}

} else {

imageData.resize(grayscale ? w * h : 3 * w * h);

2493

uchar *data = (uchar *)imageData.data();

2494

softMaskData.resize(w * h);

2495

uchar *sdata = (uchar *)softMaskData.data();

2496

for (int y = 0; y < h; ++y) {

2497

const QRgb *rgb = (const QRgb *)image.constScanLine(y);

2498

if (grayscale) {

2499

for (int x = 0; x < w; ++x) {

2500

*(data++) = qGray(*rgb);

2501

uchar alpha = qAlpha(*rgb);

2502

*sdata++ = alpha;

2503

hasMask |= (alpha < 255);

2504

hasAlpha |= (alpha != 0 && alpha != 255);

++rgb;

}

} else {

for (int x = 0; x < w; ++x) {

2509

*(data++) = qRed(*rgb);

2510

*(data++) = qGreen(*rgb);

2511

*(data++) = qBlue(*rgb);

2512

uchar alpha = qAlpha(*rgb);

2513

*sdata++ = alpha;

2514

hasMask |= (alpha < 255);

2515

hasAlpha |= (alpha != 0 && alpha != 255);

++rgb;

}

}

}

if (format == QImage::Format_RGB32)

2521

hasAlpha = hasMask = false;

2522

}

2523

int maskObject = 0;

2524

int softMaskObject = 0;

2525

if (hasAlpha) {

2526

softMaskObject = writeImage(softMaskData, w, h, 8, 0, 0);

2527

} else if (hasMask) {

2528

// dither the soft mask to 1bit and add it. This also helps PDF viewers

2529

// without transparency support

2530

int bytesPerLine = (w + 7) >> 3;

2531

QByteArray mask(bytesPerLine * h, 0);

2532

uchar *mdata = (uchar *)mask.data();

2533

const uchar *sdata = (const uchar *)softMaskData.constData();

2534

for (int y = 0; y < h; ++y) {

2535

for (int x = 0; x < w; ++x) {

2536

if (*sdata)

2537

mdata[x>>3] |= (0x80 >> (x&7));

2538

++sdata;

2539

}

2540

mdata += bytesPerLine;

2541

}

2542

maskObject = writeImage(mask, w, h, 1, 0, 0);

2543

}

2544

object = writeImage(imageData, w, h, grayscale ? 8 : 32,

2545

maskObject, softMaskObject, dct);

2546

}

2547

imageCache.insert(serial_no, object);

return object;

}

void QPdfEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti)

{

Q_Q(QPdfEngine);

if (ti.charFormat.isAnchor()) {

2556

qreal size = ti.fontEngine->fontDef.pixelSize;

2557

int synthesized = ti.fontEngine->synthesized();

2558

qreal stretch = synthesized & QFontEngine::SynthesizedStretch ? ti.fontEngine->fontDef.stretch/100. : 1.;

2559

2560

QTransform trans;

2561

// Build text rendering matrix (Trm). We need it to map the text area to user

2562

// space units on the PDF page.

2563

trans = QTransform(size*stretch, 0, 0, size, 0, 0);

2564

// Apply text matrix (Tm).

2565

trans *= QTransform(1,0,0,-1,p.x(),p.y());

2566

// Apply page displacement (Identity for first page).

2567

trans *= stroker.matrix;

2568

// Apply Current Transformation Matrix (CTM)

2569

trans *= pageMatrix();

2570

qreal x1, y1, x2, y2;

2571

trans.map(0, 0, &x1, &y1);

2572

trans.map(ti.width.toReal()/size, (ti.ascent.toReal()-ti.descent.toReal())/size, &x2, &y2);

2573

2574

uint annot = addXrefEntry(-1);

2575

QByteArray x1s, y1s, x2s, y2s;

2576

x1s.setNum(static_cast<double>(x1), 'f');

2577

y1s.setNum(static_cast<double>(y1), 'f');

2578

x2s.setNum(static_cast<double>(x2), 'f');

2579

y2s.setNum(static_cast<double>(y2), 'f');

2580

QByteArray rectData = x1s + ' ' + y1s + ' ' + x2s + ' ' + y2s;

2581

xprintf("<<\n/Type /Annot\n/Subtype /Link\n/Rect [");

2582

xprintf(rectData.constData());

2583

#ifdef Q_DEBUG_PDF_LINKS

2584

xprintf("]\n/Border [16 16 1]\n/A <<\n");

2585

#else

2586

xprintf("]\n/Border [0 0 0]\n/A <<\n");

2587

#endif

2588

xprintf("/Type /Action\n/S /URI\n/URI (%s)\n",

2589

ti.charFormat.anchorHref().toLatin1().constData());

xprintf(">>\n>>\n");

xprintf("endobj\n");

if (!currentPage->annotations.contains(annot)) {

2594

currentPage->annotations.append(annot);

}

}

QFontEngine *fe = ti.fontEngine;

2599

2600

QFontEngine::FaceId face_id = fe->faceId();

2601

bool noEmbed = false;

2602

if (!embedFonts

2603

|| face_id.filename.isEmpty()

2604

|| fe->fsType & 0x200 /* bitmap embedding only */

2605

|| fe->fsType == 2 /* no embedding allowed */) {

2606

*currentPage << "Q\n";

2607

q->QPaintEngine::drawTextItem(p, ti);

2608

*currentPage << "q\n";

2609

if (face_id.filename.isEmpty())

return;

noEmbed = true;

}

QFontSubset *font = fonts.value(face_id, 0);

2615

if (!font) {

2616

font = new QFontSubset(fe, requestObject());

2617

font->noEmbed = noEmbed;

2618

}

2619

fonts.insert(face_id, font);

2620

2621

if (!currentPage->fonts.contains(font->object_id))

2622

currentPage->fonts.append(font->object_id);

2623

2624

qreal size = ti.fontEngine->fontDef.pixelSize;

2625

2626

QVarLengthArray<glyph_t> glyphs;

2627

QVarLengthArray<QFixedPoint> positions;

2628

QTransform m = QTransform::fromTranslate(p.x(), p.y());

2629

ti.fontEngine->getGlyphPositions(ti.glyphs, m, ti.flags,

2630

glyphs, positions);

2631

if (glyphs.size() == 0)

2632

return;

2633

int synthesized = ti.fontEngine->synthesized();

2634

qreal stretch = synthesized & QFontEngine::SynthesizedStretch ? ti.fontEngine->fontDef.stretch/100. : 1.;

2635

2636

*currentPage << "BT\n"

2637

<< "/F" << font->object_id << size << "Tf "

2638

<< stretch << (synthesized & QFontEngine::SynthesizedItalic

2639

? "0 .3 -1 0 0 Tm\n"

2640

: "0 0 -1 0 0 Tm\n");

#if 0

// #### implement actual text for complex languages

2645

const unsigned short *logClusters = ti.logClusters;

int pos = 0;

do {

int end = pos + 1;

while (end < ti.num_chars && logClusters[end] == logClusters[pos])

2650

++end;

2651

*currentPage << "/Span << /ActualText <FEFF";

2652

for (int i = pos; i < end; ++i) {

2653

s << toHex((ushort)ti.chars[i].unicode(), buf);

2654

}

2655

*currentPage << "> >>\n"

2656

"BDC\n"

2657

"<";

2658

int ge = end == ti.num_chars ? ti.num_glyphs : logClusters[end];

2659

for (int gs = logClusters[pos]; gs < ge; ++gs)

2660

*currentPage << toHex((ushort)ti.glyphs[gs].glyph, buf);

2661

*currentPage << "> Tj\n"

2662

"EMC\n";

2663

pos = end;

2664

} while (pos < ti.num_chars);

#else

qreal last_x = 0.;

qreal last_y = 0.;

for (int i = 0; i < glyphs.size(); ++i) {

2669

qreal x = positions[i].x.toReal();

2670

qreal y = positions[i].y.toReal();

2671

if (synthesized & QFontEngine::SynthesizedItalic)

x += .3*y;

x /= stretch;

char buf[5];

int g = font->addGlyph(glyphs[i]);

2676

*currentPage << x - last_x << last_y - y << "Td <"

2677

<< QPdf::toHex((ushort)g, buf) << "> Tj\n";

last_x = x;

last_y = y;

}

if (synthesized & QFontEngine::SynthesizedBold) {

2682

*currentPage << stretch << (synthesized & QFontEngine::SynthesizedItalic

2683

? "0 .3 -1 0 0 Tm\n"

2684

: "0 0 -1 0 0 Tm\n");

2685

*currentPage << "/Span << /ActualText <> >> BDC\n";

2686

last_x = 0.5*fe->lineThickness().toReal();

2687

last_y = 0.;

2688

for (int i = 0; i < glyphs.size(); ++i) {

2689

qreal x = positions[i].x.toReal();

2690

qreal y = positions[i].y.toReal();

2691

if (synthesized & QFontEngine::SynthesizedItalic)

x += .3*y;

x /= stretch;

char buf[5];

int g = font->addGlyph(glyphs[i]);

2696

*currentPage << x - last_x << last_y - y << "Td <"

2697

<< QPdf::toHex((ushort)g, buf) << "> Tj\n";

last_x = x;

last_y = y;

}

*currentPage << "EMC\n";

}

#endif

*currentPage << "ET\n";

2706

}

2707

2708

QTransform QPdfEnginePrivate::pageMatrix() const

2709

{

2710

qreal scale = 72./resolution;

2711

QTransform tmp(scale, 0.0, 0.0, -scale, 0.0, m_pageLayout.fullRectPoints().height());

2712

if (m_pageLayout.mode() != QPageLayout::FullPageMode) {

2713

QRect r = m_pageLayout.paintRectPixels(resolution);

2714

tmp.translate(r.left(), r.top());

}

return tmp;

}

void QPdfEnginePrivate::newPage()

2720

{

2721

if (currentPage && currentPage->pageSize.isEmpty())

2722

currentPage->pageSize = m_pageLayout.fullRectPoints().size();

writePage();

delete currentPage;

currentPage = new QPdfPage;

2727

currentPage->pageSize = m_pageLayout.fullRectPoints().size();

2728

stroker.stream = currentPage;

2729

pages.append(requestObject());

2730

2731

*currentPage << "/GSa gs /CSp cs /CSp CS\n"

2732

<< QPdf::generateMatrix(pageMatrix())

<< "q q\n";

}

QT_END_NAMESPACE

#endif // QT_NO_PDF

Generated by Squish Coco Non-Commercial 4.3.0-BETA-master-30-08-2018-4cb69e9