1 /**
2 * This file is part of OpenOrienteering.
3 *
4 * This is a modified version of a file from the Qt Toolkit.
5 * You can redistribute it and/or modify it under the terms of
6 * the GNU General Public License, version 3, as published by
7 * the Free Software Foundation.
8 *
9 * OpenOrienteering is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with OpenOrienteering. If not, see <http://www.gnu.org/licenses/>
16 *
17 * Changes:
18 * 2015-10-18 Kai Pastor <dg0yt@darc.de>
19 * - Adjustment of legal information
20 * - Modifications required for separate compilation:
21 * - Renaming of selected files, classes, members and macros
22 * - Adjustment of include statements
23 * - Removal of Q_XXX_EXPORT
24 * - Change of the PDF Producer property
25 * - Use of DeviceCMYK color space in PDF output
26 * - Distinct paint engine type
27 */
28 /****************************************************************************
29 **
30 ** Copyright (C) 2015 The Qt Company Ltd.
31 ** Contact: http://www.qt.io/licensing/
32 **
33 ****************************************************************************/
34
35 #include "advanced_pdf_p.h"
36
37 #ifndef QT_NO_PDF
38
39 #include "qplatformdefs.h"
40 #include <qdebug.h>
41 #include <qfile.h>
42 #include <qtemporaryfile.h>
43 #include <private/qmath_p.h>
44 #include <private/qpainter_p.h>
45 #include <qnumeric.h>
46 #include <private/qfont_p.h>
47 #include <qimagewriter.h>
48 #include "qbuffer.h"
49 #include "QtCore/qdatetime.h"
50
51 #ifndef QT_NO_COMPRESS
52 #include <zlib.h>
53 #endif
54
55 #ifdef QT_NO_COMPRESS
56 static const bool do_compress = false;
57 #else
58 static const bool do_compress = true;
59 #endif
60
61 // might be helpful for smooth transforms of images
62 // Can't use it though, as gs generates completely wrong images if this is true.
63 static const bool interpolateImages = false;
64
65 QT_BEGIN_NAMESPACE
66
qt_pdf_decide_features()67 inline QPaintEngine::PaintEngineFeatures qt_pdf_decide_features()
68 {
69 QPaintEngine::PaintEngineFeatures f = QPaintEngine::AllFeatures;
70 f &= ~(QPaintEngine::PorterDuff
71 | QPaintEngine::PerspectiveTransform
72 | QPaintEngine::ObjectBoundingModeGradients
73 | QPaintEngine::ConicalGradientFill);
74 return f;
75 }
76
77
78
79 /* also adds a space at the end of the number */
qt_real_to_string(qreal val,char * buf)80 const char *qt_real_to_string(qreal val, char *buf) {
81 const char *ret = buf;
82
83 if (qIsNaN(val)) {
84 *(buf++) = '0';
85 *(buf++) = ' ';
86 *buf = 0;
87 return ret;
88 }
89
90 if (val < 0) {
91 *(buf++) = '-';
92 val = -val;
93 }
94 unsigned int ival = (unsigned int) val;
95 qreal frac = val - (qreal)ival;
96
97 int ifrac = (int)(frac * 1000000000);
98 if (ifrac == 1000000000) {
99 ++ival;
100 ifrac = 0;
101 }
102 char output[256];
103 int i = 0;
104 while (ival) {
105 output[i] = '0' + (ival % 10);
106 ++i;
107 ival /= 10;
108 }
109 int fact = 100000000;
110 if (i == 0) {
111 *(buf++) = '0';
112 } else {
113 while (i) {
114 *(buf++) = output[--i];
115 fact /= 10;
116 ifrac /= 10;
117 }
118 }
119
120 if (ifrac) {
121 *(buf++) = '.';
122 while (fact) {
123 *(buf++) = '0' + ((ifrac/fact) % 10);
124 fact /= 10;
125 }
126 }
127 *(buf++) = ' ';
128 *buf = 0;
129 return ret;
130 }
131
qt_int_to_string(int val,char * buf)132 const char *qt_int_to_string(int val, char *buf) {
133 const char *ret = buf;
134 if (val < 0) {
135 *(buf++) = '-';
136 val = -val;
137 }
138 char output[256];
139 int i = 0;
140 while (val) {
141 output[i] = '0' + (val % 10);
142 ++i;
143 val /= 10;
144 }
145 if (i == 0) {
146 *(buf++) = '0';
147 } else {
148 while (i)
149 *(buf++) = output[--i];
150 }
151 *(buf++) = ' ';
152 *buf = 0;
153 return ret;
154 }
155
156
157 namespace AdvancedPdf {
ByteStream(QByteArray * byteArray,bool fileBacking)158 ByteStream::ByteStream(QByteArray *byteArray, bool fileBacking)
159 : dev(new QBuffer(byteArray)),
160 fileBackingEnabled(fileBacking),
161 fileBackingActive(false),
162 handleDirty(false)
163 {
164 dev->open(QIODevice::ReadWrite | QIODevice::Append);
165 }
166
ByteStream(bool fileBacking)167 ByteStream::ByteStream(bool fileBacking)
168 : dev(new QBuffer(&ba)),
169 fileBackingEnabled(fileBacking),
170 fileBackingActive(false),
171 handleDirty(false)
172 {
173 dev->open(QIODevice::ReadWrite);
174 }
175
~ByteStream()176 ByteStream::~ByteStream()
177 {
178 delete dev;
179 }
180
operator <<(char chr)181 ByteStream &ByteStream::operator <<(char chr)
182 {
183 if (handleDirty) prepareBuffer();
184 dev->write(&chr, 1);
185 return *this;
186 }
187
operator <<(const char * str)188 ByteStream &ByteStream::operator <<(const char *str)
189 {
190 if (handleDirty) prepareBuffer();
191 dev->write(str, strlen(str));
192 return *this;
193 }
194
operator <<(const QByteArray & str)195 ByteStream &ByteStream::operator <<(const QByteArray &str)
196 {
197 if (handleDirty) prepareBuffer();
198 dev->write(str);
199 return *this;
200 }
201
operator <<(const ByteStream & src)202 ByteStream &ByteStream::operator <<(const ByteStream &src)
203 {
204 Q_ASSERT(!src.dev->isSequential());
205 if (handleDirty) prepareBuffer();
206 // We do play nice here, even though it looks ugly.
207 // We save the position and restore it afterwards.
208 ByteStream &s = const_cast<ByteStream&>(src);
209 qint64 pos = s.dev->pos();
210 s.dev->reset();
211 while (!s.dev->atEnd()) {
212 QByteArray buf = s.dev->read(chunkSize());
213 dev->write(buf);
214 }
215 s.dev->seek(pos);
216 return *this;
217 }
218
operator <<(qreal val)219 ByteStream &ByteStream::operator <<(qreal val) {
220 char buf[256];
221 qt_real_to_string(val, buf);
222 *this << buf;
223 return *this;
224 }
225
operator <<(int val)226 ByteStream &ByteStream::operator <<(int val) {
227 char buf[256];
228 qt_int_to_string(val, buf);
229 *this << buf;
230 return *this;
231 }
232
operator <<(const QPointF & p)233 ByteStream &ByteStream::operator <<(const QPointF &p) {
234 char buf[256];
235 qt_real_to_string(p.x(), buf);
236 *this << buf;
237 qt_real_to_string(p.y(), buf);
238 *this << buf;
239 return *this;
240 }
241
stream()242 QIODevice *ByteStream::stream()
243 {
244 dev->reset();
245 handleDirty = true;
246 return dev;
247 }
248
clear()249 void ByteStream::clear()
250 {
251 dev->open(QIODevice::ReadWrite | QIODevice::Truncate);
252 }
253
constructor_helper(QByteArray * ba)254 void ByteStream::constructor_helper(QByteArray *ba)
255 {
256 delete dev;
257 dev = new QBuffer(ba);
258 dev->open(QIODevice::ReadWrite);
259 }
260
prepareBuffer()261 void ByteStream::prepareBuffer()
262 {
263 Q_ASSERT(!dev->isSequential());
264 qint64 size = dev->size();
265 if (fileBackingEnabled && !fileBackingActive
266 && size > maxMemorySize()) {
267 // Switch to file backing.
268 QTemporaryFile *newFile = new QTemporaryFile;
269 newFile->open();
270 dev->reset();
271 while (!dev->atEnd()) {
272 QByteArray buf = dev->read(chunkSize());
273 newFile->write(buf);
274 }
275 delete dev;
276 dev = newFile;
277 ba.clear();
278 fileBackingActive = true;
279 }
280 if (dev->pos() != size) {
281 dev->seek(size);
282 handleDirty = false;
283 }
284 }
285 }
286
287 #define QT_PATH_ELEMENT(elm)
288
generatePath(const QPainterPath & path,const QTransform & matrix,PathFlags flags)289 QByteArray AdvancedPdf::generatePath(const QPainterPath &path, const QTransform &matrix, PathFlags flags)
290 {
291 QByteArray result;
292 if (!path.elementCount())
293 return result;
294
295 ByteStream s(&result);
296
297 int start = -1;
298 for (int i = 0; i < path.elementCount(); ++i) {
299 const QPainterPath::Element &elm = path.elementAt(i);
300 switch (elm.type) {
301 case QPainterPath::MoveToElement:
302 if (start >= 0
303 && path.elementAt(start).x == path.elementAt(i-1).x
304 && path.elementAt(start).y == path.elementAt(i-1).y)
305 s << "h\n";
306 s << matrix.map(QPointF(elm.x, elm.y)) << "m\n";
307 start = i;
308 break;
309 case QPainterPath::LineToElement:
310 s << matrix.map(QPointF(elm.x, elm.y)) << "l\n";
311 break;
312 case QPainterPath::CurveToElement:
313 Q_ASSERT(path.elementAt(i+1).type == QPainterPath::CurveToDataElement);
314 Q_ASSERT(path.elementAt(i+2).type == QPainterPath::CurveToDataElement);
315 s << matrix.map(QPointF(elm.x, elm.y))
316 << matrix.map(QPointF(path.elementAt(i+1).x, path.elementAt(i+1).y))
317 << matrix.map(QPointF(path.elementAt(i+2).x, path.elementAt(i+2).y))
318 << "c\n";
319 i += 2;
320 break;
321 default:
322 qFatal("AdvancedPdf::generatePath(), unhandled type: %d", elm.type);
323 }
324 }
325 if (start >= 0
326 && path.elementAt(start).x == path.elementAt(path.elementCount()-1).x
327 && path.elementAt(start).y == path.elementAt(path.elementCount()-1).y)
328 s << "h\n";
329
330 Qt::FillRule fillRule = path.fillRule();
331
332 const char *op = "";
333 switch (flags) {
334 case ClipPath:
335 op = (fillRule == Qt::WindingFill) ? "W n\n" : "W* n\n";
336 break;
337 case FillPath:
338 op = (fillRule == Qt::WindingFill) ? "f\n" : "f*\n";
339 break;
340 case StrokePath:
341 op = "S\n";
342 break;
343 case FillAndStrokePath:
344 op = (fillRule == Qt::WindingFill) ? "B\n" : "B*\n";
345 break;
346 }
347 s << op;
348 return result;
349 }
350
generateMatrix(const QTransform & matrix)351 QByteArray AdvancedPdf::generateMatrix(const QTransform &matrix)
352 {
353 QByteArray result;
354 ByteStream s(&result);
355 s << matrix.m11()
356 << matrix.m12()
357 << matrix.m21()
358 << matrix.m22()
359 << matrix.dx()
360 << matrix.dy()
361 << "cm\n";
362 return result;
363 }
364
generateDashes(const QPen & pen)365 QByteArray AdvancedPdf::generateDashes(const QPen &pen)
366 {
367 QByteArray result;
368 ByteStream s(&result);
369 s << '[';
370
371 QVector<qreal> dasharray = pen.dashPattern();
372 qreal w = pen.widthF();
373 if (w < 0.001)
374 w = 1;
375 for (int i = 0; i < dasharray.size(); ++i) {
376 qreal dw = dasharray.at(i)*w;
377 if (dw < 0.0001) dw = 0.0001;
378 s << dw;
379 }
380 s << ']';
381 //qDebug() << "dasharray: pen has" << dasharray;
382 //qDebug() << " => " << result;
383 return result;
384 }
385
386
387
388 static const char* const pattern_for_brush[] = {
389 0, // NoBrush
390 0, // SolidPattern
391 "0 J\n"
392 "6 w\n"
393 "[] 0 d\n"
394 "4 0 m\n"
395 "4 8 l\n"
396 "0 4 m\n"
397 "8 4 l\n"
398 "S\n", // Dense1Pattern
399
400 "0 J\n"
401 "2 w\n"
402 "[6 2] 1 d\n"
403 "0 0 m\n"
404 "0 8 l\n"
405 "8 0 m\n"
406 "8 8 l\n"
407 "S\n"
408 "[] 0 d\n"
409 "2 0 m\n"
410 "2 8 l\n"
411 "6 0 m\n"
412 "6 8 l\n"
413 "S\n"
414 "[6 2] -3 d\n"
415 "4 0 m\n"
416 "4 8 l\n"
417 "S\n", // Dense2Pattern
418
419 "0 J\n"
420 "2 w\n"
421 "[6 2] 1 d\n"
422 "0 0 m\n"
423 "0 8 l\n"
424 "8 0 m\n"
425 "8 8 l\n"
426 "S\n"
427 "[2 2] -1 d\n"
428 "2 0 m\n"
429 "2 8 l\n"
430 "6 0 m\n"
431 "6 8 l\n"
432 "S\n"
433 "[6 2] -3 d\n"
434 "4 0 m\n"
435 "4 8 l\n"
436 "S\n", // Dense3Pattern
437
438 "0 J\n"
439 "2 w\n"
440 "[2 2] 1 d\n"
441 "0 0 m\n"
442 "0 8 l\n"
443 "8 0 m\n"
444 "8 8 l\n"
445 "S\n"
446 "[2 2] -1 d\n"
447 "2 0 m\n"
448 "2 8 l\n"
449 "6 0 m\n"
450 "6 8 l\n"
451 "S\n"
452 "[2 2] 1 d\n"
453 "4 0 m\n"
454 "4 8 l\n"
455 "S\n", // Dense4Pattern
456
457 "0 J\n"
458 "2 w\n"
459 "[2 6] -1 d\n"
460 "0 0 m\n"
461 "0 8 l\n"
462 "8 0 m\n"
463 "8 8 l\n"
464 "S\n"
465 "[2 2] 1 d\n"
466 "2 0 m\n"
467 "2 8 l\n"
468 "6 0 m\n"
469 "6 8 l\n"
470 "S\n"
471 "[2 6] 3 d\n"
472 "4 0 m\n"
473 "4 8 l\n"
474 "S\n", // Dense5Pattern
475
476 "0 J\n"
477 "2 w\n"
478 "[2 6] -1 d\n"
479 "0 0 m\n"
480 "0 8 l\n"
481 "8 0 m\n"
482 "8 8 l\n"
483 "S\n"
484 "[2 6] 3 d\n"
485 "4 0 m\n"
486 "4 8 l\n"
487 "S\n", // Dense6Pattern
488
489 "0 J\n"
490 "2 w\n"
491 "[2 6] -1 d\n"
492 "0 0 m\n"
493 "0 8 l\n"
494 "8 0 m\n"
495 "8 8 l\n"
496 "S\n", // Dense7Pattern
497
498 "1 w\n"
499 "0 4 m\n"
500 "8 4 l\n"
501 "S\n", // HorPattern
502
503 "1 w\n"
504 "4 0 m\n"
505 "4 8 l\n"
506 "S\n", // VerPattern
507
508 "1 w\n"
509 "4 0 m\n"
510 "4 8 l\n"
511 "0 4 m\n"
512 "8 4 l\n"
513 "S\n", // CrossPattern
514
515 "1 w\n"
516 "-1 5 m\n"
517 "5 -1 l\n"
518 "3 9 m\n"
519 "9 3 l\n"
520 "S\n", // BDiagPattern
521
522 "1 w\n"
523 "-1 3 m\n"
524 "5 9 l\n"
525 "3 -1 m\n"
526 "9 5 l\n"
527 "S\n", // FDiagPattern
528
529 "1 w\n"
530 "-1 3 m\n"
531 "5 9 l\n"
532 "3 -1 m\n"
533 "9 5 l\n"
534 "-1 5 m\n"
535 "5 -1 l\n"
536 "3 9 m\n"
537 "9 3 l\n"
538 "S\n", // DiagCrossPattern
539 };
540
patternForBrush(const QBrush & b)541 QByteArray AdvancedPdf::patternForBrush(const QBrush &b)
542 {
543 int style = b.style();
544 if (style > Qt::DiagCrossPattern)
545 return QByteArray();
546 return pattern_for_brush[style];
547 }
548
549
moveToHook(qfixed x,qfixed y,void * data)550 static void moveToHook(qfixed x, qfixed y, void *data)
551 {
552 AdvancedPdf::Stroker *t = (AdvancedPdf::Stroker *)data;
553 if (!t->first)
554 *t->stream << "h\n";
555 if (!t->cosmeticPen)
556 t->matrix.map(x, y, &x, &y);
557 *t->stream << x << y << "m\n";
558 t->first = false;
559 }
560
lineToHook(qfixed x,qfixed y,void * data)561 static void lineToHook(qfixed x, qfixed y, void *data)
562 {
563 AdvancedPdf::Stroker *t = (AdvancedPdf::Stroker *)data;
564 if (!t->cosmeticPen)
565 t->matrix.map(x, y, &x, &y);
566 *t->stream << x << y << "l\n";
567 }
568
cubicToHook(qfixed c1x,qfixed c1y,qfixed c2x,qfixed c2y,qfixed ex,qfixed ey,void * data)569 static void cubicToHook(qfixed c1x, qfixed c1y,
570 qfixed c2x, qfixed c2y,
571 qfixed ex, qfixed ey,
572 void *data)
573 {
574 AdvancedPdf::Stroker *t = (AdvancedPdf::Stroker *)data;
575 if (!t->cosmeticPen) {
576 t->matrix.map(c1x, c1y, &c1x, &c1y);
577 t->matrix.map(c2x, c2y, &c2x, &c2y);
578 t->matrix.map(ex, ey, &ex, &ey);
579 }
580 *t->stream << c1x << c1y
581 << c2x << c2y
582 << ex << ey
583 << "c\n";
584 }
585
Stroker()586 AdvancedPdf::Stroker::Stroker()
587 : stream(0),
588 first(true),
589 dashStroker(&basicStroker)
590 {
591 stroker = &basicStroker;
592 basicStroker.setMoveToHook(moveToHook);
593 basicStroker.setLineToHook(lineToHook);
594 basicStroker.setCubicToHook(cubicToHook);
595 cosmeticPen = true;
596 basicStroker.setStrokeWidth(.1);
597 }
598
setPen(const QPen & pen,QPainter::RenderHints hints)599 void AdvancedPdf::Stroker::setPen(const QPen &pen, QPainter::RenderHints hints)
600 {
601 if (pen.style() == Qt::NoPen) {
602 stroker = 0;
603 return;
604 }
605 qreal w = pen.widthF();
606 bool zeroWidth = w < 0.0001;
607 cosmeticPen = qt_pen_is_cosmetic(pen, hints);
608 if (zeroWidth)
609 w = .1;
610
611 basicStroker.setStrokeWidth(w);
612 basicStroker.setCapStyle(pen.capStyle());
613 basicStroker.setJoinStyle(pen.joinStyle());
614 basicStroker.setMiterLimit(pen.miterLimit());
615
616 QVector<qreal> dashpattern = pen.dashPattern();
617 if (zeroWidth) {
618 for (int i = 0; i < dashpattern.size(); ++i)
619 dashpattern[i] *= 10.;
620 }
621 if (!dashpattern.isEmpty()) {
622 dashStroker.setDashPattern(dashpattern);
623 dashStroker.setDashOffset(pen.dashOffset());
624 stroker = &dashStroker;
625 } else {
626 stroker = &basicStroker;
627 }
628 }
629
strokePath(const QPainterPath & path)630 void AdvancedPdf::Stroker::strokePath(const QPainterPath &path)
631 {
632 if (!stroker)
633 return;
634 first = true;
635
636 stroker->strokePath(path, this, cosmeticPen ? matrix : QTransform());
637 *stream << "h f\n";
638 }
639
ascii85Encode(const QByteArray & input)640 QByteArray AdvancedPdf::ascii85Encode(const QByteArray &input)
641 {
642 int isize = input.size()/4*4;
643 QByteArray output;
644 output.resize(input.size()*5/4+7);
645 char *out = output.data();
646 const uchar *in = (const uchar *)input.constData();
647 for (int i = 0; i < isize; i += 4) {
648 uint val = (((uint)in[i])<<24) + (((uint)in[i+1])<<16) + (((uint)in[i+2])<<8) + (uint)in[i+3];
649 if (val == 0) {
650 *out = 'z';
651 ++out;
652 } else {
653 char base[5];
654 base[4] = val % 85;
655 val /= 85;
656 base[3] = val % 85;
657 val /= 85;
658 base[2] = val % 85;
659 val /= 85;
660 base[1] = val % 85;
661 val /= 85;
662 base[0] = val % 85;
663 *(out++) = base[0] + '!';
664 *(out++) = base[1] + '!';
665 *(out++) = base[2] + '!';
666 *(out++) = base[3] + '!';
667 *(out++) = base[4] + '!';
668 }
669 }
670 //write the last few bytes
671 int remaining = input.size() - isize;
672 if (remaining) {
673 uint val = 0;
674 for (int i = isize; i < input.size(); ++i)
675 val = (val << 8) + in[i];
676 val <<= 8*(4-remaining);
677 char base[5];
678 base[4] = val % 85;
679 val /= 85;
680 base[3] = val % 85;
681 val /= 85;
682 base[2] = val % 85;
683 val /= 85;
684 base[1] = val % 85;
685 val /= 85;
686 base[0] = val % 85;
687 for (int i = 0; i < remaining+1; ++i)
688 *(out++) = base[i] + '!';
689 }
690 *(out++) = '~';
691 *(out++) = '>';
692 output.resize(out-output.data());
693 return output;
694 }
695
toHex(ushort u,char * buffer)696 const char *AdvancedPdf::toHex(ushort u, char *buffer)
697 {
698 int i = 3;
699 while (i >= 0) {
700 ushort hex = (u & 0x000f);
701 if (hex < 0x0a)
702 buffer[i] = '0'+hex;
703 else
704 buffer[i] = 'A'+(hex-0x0a);
705 u = u >> 4;
706 i--;
707 }
708 buffer[4] = '\0';
709 return buffer;
710 }
711
toHex(uchar u,char * buffer)712 const char *AdvancedPdf::toHex(uchar u, char *buffer)
713 {
714 int i = 1;
715 while (i >= 0) {
716 ushort hex = (u & 0x000f);
717 if (hex < 0x0a)
718 buffer[i] = '0'+hex;
719 else
720 buffer[i] = 'A'+(hex-0x0a);
721 u = u >> 4;
722 i--;
723 }
724 buffer[2] = '\0';
725 return buffer;
726 }
727
728
AdvancedPdfPage()729 AdvancedPdfPage::AdvancedPdfPage()
730 : AdvancedPdf::ByteStream(true) // Enable file backing
731 {
732 }
733
streamImage(int w,int h,int object)734 void AdvancedPdfPage::streamImage(int w, int h, int object)
735 {
736 *this << w << "0 0 " << -h << "0 " << h << "cm /Im" << object << " Do\n";
737 if (!images.contains(object))
738 images.append(object);
739 }
740
741
AdvancedPdfEngine(AdvancedPdfEnginePrivate & dd)742 AdvancedPdfEngine::AdvancedPdfEngine(AdvancedPdfEnginePrivate &dd)
743 : QPaintEngine(dd, qt_pdf_decide_features())
744 {
745 }
746
AdvancedPdfEngine()747 AdvancedPdfEngine::AdvancedPdfEngine()
748 : QPaintEngine(*new AdvancedPdfEnginePrivate(), qt_pdf_decide_features())
749 {
750 }
751
setOutputFilename(const QString & filename)752 void AdvancedPdfEngine::setOutputFilename(const QString &filename)
753 {
754 Q_D(AdvancedPdfEngine);
755 d->outputFileName = filename;
756 }
757
758
drawPoints(const QPointF * points,int pointCount)759 void AdvancedPdfEngine::drawPoints (const QPointF *points, int pointCount)
760 {
761 if (!points)
762 return;
763
764 Q_D(AdvancedPdfEngine);
765 QPainterPath p;
766 for (int i=0; i!=pointCount;++i) {
767 p.moveTo(points[i]);
768 p.lineTo(points[i] + QPointF(0, 0.001));
769 }
770
771 bool hadBrush = d->hasBrush;
772 d->hasBrush = false;
773 drawPath(p);
774 d->hasBrush = hadBrush;
775 }
776
drawLines(const QLineF * lines,int lineCount)777 void AdvancedPdfEngine::drawLines (const QLineF *lines, int lineCount)
778 {
779 if (!lines)
780 return;
781
782 Q_D(AdvancedPdfEngine);
783 QPainterPath p;
784 for (int i=0; i!=lineCount;++i) {
785 p.moveTo(lines[i].p1());
786 p.lineTo(lines[i].p2());
787 }
788 bool hadBrush = d->hasBrush;
789 d->hasBrush = false;
790 drawPath(p);
791 d->hasBrush = hadBrush;
792 }
793
drawRects(const QRectF * rects,int rectCount)794 void AdvancedPdfEngine::drawRects (const QRectF *rects, int rectCount)
795 {
796 if (!rects)
797 return;
798
799 Q_D(AdvancedPdfEngine);
800
801 if (d->clipEnabled && d->allClipped)
802 return;
803 if (!d->hasPen && !d->hasBrush)
804 return;
805
806 QBrush penBrush = d->pen.brush();
807 if (d->simplePen || !d->hasPen) {
808 // draw strokes natively in this case for better output
809 if(!d->simplePen && !d->stroker.matrix.isIdentity())
810 *d->currentPage << "q\n" << AdvancedPdf::generateMatrix(d->stroker.matrix);
811 for (int i = 0; i < rectCount; ++i)
812 *d->currentPage << rects[i].x() << rects[i].y() << rects[i].width() << rects[i].height() << "re\n";
813 *d->currentPage << (d->hasPen ? (d->hasBrush ? "B\n" : "S\n") : "f\n");
814 if(!d->simplePen && !d->stroker.matrix.isIdentity())
815 *d->currentPage << "Q\n";
816 } else {
817 QPainterPath p;
818 for (int i=0; i!=rectCount; ++i)
819 p.addRect(rects[i]);
820 drawPath(p);
821 }
822 }
823
drawPolygon(const QPointF * points,int pointCount,PolygonDrawMode mode)824 void AdvancedPdfEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
825 {
826 Q_D(AdvancedPdfEngine);
827
828 if (!points || !pointCount)
829 return;
830
831 bool hb = d->hasBrush;
832 QPainterPath p;
833
834 switch(mode) {
835 case OddEvenMode:
836 p.setFillRule(Qt::OddEvenFill);
837 break;
838 case ConvexMode:
839 case WindingMode:
840 p.setFillRule(Qt::WindingFill);
841 break;
842 case PolylineMode:
843 d->hasBrush = false;
844 break;
845 default:
846 break;
847 }
848
849 p.moveTo(points[0]);
850 for (int i = 1; i < pointCount; ++i)
851 p.lineTo(points[i]);
852
853 if (mode != PolylineMode)
854 p.closeSubpath();
855 drawPath(p);
856
857 d->hasBrush = hb;
858 }
859
drawPath(const QPainterPath & p)860 void AdvancedPdfEngine::drawPath (const QPainterPath &p)
861 {
862 Q_D(AdvancedPdfEngine);
863
864 if (d->clipEnabled && d->allClipped)
865 return;
866 if (!d->hasPen && !d->hasBrush)
867 return;
868
869 if (d->simplePen) {
870 // draw strokes natively in this case for better output
871 *d->currentPage << AdvancedPdf::generatePath(p, QTransform(), d->hasBrush ? AdvancedPdf::FillAndStrokePath : AdvancedPdf::StrokePath);
872 } else {
873 if (d->hasBrush)
874 *d->currentPage << AdvancedPdf::generatePath(p, d->stroker.matrix, AdvancedPdf::FillPath);
875 if (d->hasPen) {
876 *d->currentPage << "q\n";
877 QBrush b = d->brush;
878 d->brush = d->pen.brush();
879 setBrush();
880 d->stroker.strokePath(p);
881 *d->currentPage << "Q\n";
882 d->brush = b;
883 }
884 }
885 }
886
drawPixmap(const QRectF & rectangle,const QPixmap & pixmap,const QRectF & sr)887 void AdvancedPdfEngine::drawPixmap (const QRectF &rectangle, const QPixmap &pixmap, const QRectF &sr)
888 {
889 if (sr.isEmpty() || rectangle.isEmpty() || pixmap.isNull())
890 return;
891 Q_D(AdvancedPdfEngine);
892
893 QBrush b = d->brush;
894
895 QRect sourceRect = sr.toRect();
896 QPixmap pm = sourceRect != pixmap.rect() ? pixmap.copy(sourceRect) : pixmap;
897 QImage image = pm.toImage();
898 bool bitmap = true;
899 const int object = d->addImage(image, &bitmap, pm.cacheKey());
900 if (object < 0)
901 return;
902
903 *d->currentPage << "q\n/GSa gs\n";
904 *d->currentPage
905 << AdvancedPdf::generateMatrix(QTransform(rectangle.width() / sr.width(), 0, 0, rectangle.height() / sr.height(),
906 rectangle.x(), rectangle.y()) * (d->simplePen ? QTransform() : d->stroker.matrix));
907 if (bitmap) {
908 // set current pen as d->brush
909 d->brush = d->pen.brush();
910 }
911 setBrush();
912 d->currentPage->streamImage(image.width(), image.height(), object);
913 *d->currentPage << "Q\n";
914
915 d->brush = b;
916 }
917
drawImage(const QRectF & rectangle,const QImage & image,const QRectF & sr,Qt::ImageConversionFlags)918 void AdvancedPdfEngine::drawImage(const QRectF &rectangle, const QImage &image, const QRectF &sr, Qt::ImageConversionFlags)
919 {
920 if (sr.isEmpty() || rectangle.isEmpty() || image.isNull())
921 return;
922 Q_D(AdvancedPdfEngine);
923
924 QRect sourceRect = sr.toRect();
925 QImage im = sourceRect != image.rect() ? image.copy(sourceRect) : image;
926 bool bitmap = true;
927 const int object = d->addImage(im, &bitmap, im.cacheKey());
928 if (object < 0)
929 return;
930
931 *d->currentPage << "q\n/GSa gs\n";
932 *d->currentPage
933 << AdvancedPdf::generateMatrix(QTransform(rectangle.width() / sr.width(), 0, 0, rectangle.height() / sr.height(),
934 rectangle.x(), rectangle.y()) * (d->simplePen ? QTransform() : d->stroker.matrix));
935 setBrush();
936 d->currentPage->streamImage(im.width(), im.height(), object);
937 *d->currentPage << "Q\n";
938 }
939
drawTiledPixmap(const QRectF & rectangle,const QPixmap & pixmap,const QPointF & point)940 void AdvancedPdfEngine::drawTiledPixmap (const QRectF &rectangle, const QPixmap &pixmap, const QPointF &point)
941 {
942 Q_D(AdvancedPdfEngine);
943
944 bool bitmap = (pixmap.depth() == 1);
945 QBrush b = d->brush;
946 QPointF bo = d->brushOrigin;
947 bool hp = d->hasPen;
948 d->hasPen = false;
949 bool hb = d->hasBrush;
950 d->hasBrush = true;
951
952 d->brush = QBrush(pixmap);
953 if (bitmap)
954 // #### fix bitmap case where we have a brush pen
955 d->brush.setColor(d->pen.color());
956
957 d->brushOrigin = -point;
958 *d->currentPage << "q\n";
959 setBrush();
960
961 drawRects(&rectangle, 1);
962 *d->currentPage << "Q\n";
963
964 d->hasPen = hp;
965 d->hasBrush = hb;
966 d->brush = b;
967 d->brushOrigin = bo;
968 }
969
drawTextItem(const QPointF & p,const QTextItem & textItem)970 void AdvancedPdfEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
971 {
972 Q_D(AdvancedPdfEngine);
973
974 if (!d->hasPen || (d->clipEnabled && d->allClipped))
975 return;
976
977 if (d->stroker.matrix.type() >= QTransform::TxProject) {
978 QPaintEngine::drawTextItem(p, textItem);
979 return;
980 }
981
982 *d->currentPage << "q\n";
983 if(!d->simplePen)
984 *d->currentPage << AdvancedPdf::generateMatrix(d->stroker.matrix);
985
986 bool hp = d->hasPen;
987 d->hasPen = false;
988 QBrush b = d->brush;
989 d->brush = d->pen.brush();
990 setBrush();
991
992 const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
993 Q_ASSERT(ti.fontEngine->type() != QFontEngine::Multi);
994 d->drawTextItem(p, ti);
995 d->hasPen = hp;
996 d->brush = b;
997 *d->currentPage << "Q\n";
998 }
999
1000
updateState(const QPaintEngineState & state)1001 void AdvancedPdfEngine::updateState(const QPaintEngineState &state)
1002 {
1003 Q_D(AdvancedPdfEngine);
1004
1005 QPaintEngine::DirtyFlags flags = state.state();
1006
1007 if (flags & DirtyTransform)
1008 d->stroker.matrix = state.transform();
1009
1010 if (flags & DirtyPen) {
1011 d->pen = state.pen();
1012 d->hasPen = d->pen.style() != Qt::NoPen;
1013 d->stroker.setPen(d->pen, state.renderHints());
1014 QBrush penBrush = d->pen.brush();
1015 bool oldSimple = d->simplePen;
1016 d->simplePen = (d->hasPen && (penBrush.style() == Qt::SolidPattern) && penBrush.isOpaque() && d->opacity == 1.0);
1017 if (oldSimple != d->simplePen)
1018 flags |= DirtyTransform;
1019 } else if (flags & DirtyHints) {
1020 d->stroker.setPen(d->pen, state.renderHints());
1021 }
1022 if (flags & DirtyBrush) {
1023 d->brush = state.brush();
1024 if (d->brush.color().alpha() == 0 && d->brush.style() == Qt::SolidPattern)
1025 d->brush.setStyle(Qt::NoBrush);
1026 d->hasBrush = d->brush.style() != Qt::NoBrush;
1027 }
1028 if (flags & DirtyBrushOrigin) {
1029 d->brushOrigin = state.brushOrigin();
1030 flags |= DirtyBrush;
1031 }
1032 if (flags & DirtyOpacity) {
1033 d->opacity = state.opacity();
1034 if (d->simplePen && d->opacity != 1.0) {
1035 d->simplePen = false;
1036 flags |= DirtyTransform;
1037 }
1038 }
1039
1040 bool ce = d->clipEnabled;
1041 if (flags & DirtyClipPath) {
1042 d->clipEnabled = true;
1043 updateClipPath(state.clipPath(), state.clipOperation());
1044 } else if (flags & DirtyClipRegion) {
1045 d->clipEnabled = true;
1046 QPainterPath path;
1047 QVector<QRect> rects = state.clipRegion().rects();
1048 for (int i = 0; i < rects.size(); ++i)
1049 path.addRect(rects.at(i));
1050 updateClipPath(path, state.clipOperation());
1051 flags |= DirtyClipPath;
1052 } else if (flags & DirtyClipEnabled) {
1053 d->clipEnabled = state.isClipEnabled();
1054 }
1055
1056 if (ce != d->clipEnabled)
1057 flags |= DirtyClipPath;
1058 else if (!d->clipEnabled)
1059 flags &= ~DirtyClipPath;
1060
1061 setupGraphicsState(flags);
1062 }
1063
setupGraphicsState(QPaintEngine::DirtyFlags flags)1064 void AdvancedPdfEngine::setupGraphicsState(QPaintEngine::DirtyFlags flags)
1065 {
1066 Q_D(AdvancedPdfEngine);
1067 if (flags & DirtyClipPath)
1068 flags |= DirtyTransform|DirtyPen|DirtyBrush;
1069
1070 if (flags & DirtyTransform) {
1071 *d->currentPage << "Q\n";
1072 flags |= DirtyPen|DirtyBrush;
1073 }
1074
1075 if (flags & DirtyClipPath) {
1076 *d->currentPage << "Q q\n";
1077
1078 d->allClipped = false;
1079 if (d->clipEnabled && !d->clips.isEmpty()) {
1080 for (int i = 0; i < d->clips.size(); ++i) {
1081 if (d->clips.at(i).isEmpty()) {
1082 d->allClipped = true;
1083 break;
1084 }
1085 }
1086 if (!d->allClipped) {
1087 for (int i = 0; i < d->clips.size(); ++i) {
1088 *d->currentPage << AdvancedPdf::generatePath(d->clips.at(i), QTransform(), AdvancedPdf::ClipPath);
1089 }
1090 }
1091 }
1092 }
1093
1094 if (flags & DirtyTransform) {
1095 *d->currentPage << "q\n";
1096 if (d->simplePen && !d->stroker.matrix.isIdentity())
1097 *d->currentPage << AdvancedPdf::generateMatrix(d->stroker.matrix);
1098 }
1099 if (flags & DirtyBrush)
1100 setBrush();
1101 if (d->simplePen && (flags & DirtyPen))
1102 setPen();
1103 }
1104
1105 extern QPainterPath qt_regionToPath(const QRegion ®ion);
1106
updateClipPath(const QPainterPath & p,Qt::ClipOperation op)1107 void AdvancedPdfEngine::updateClipPath(const QPainterPath &p, Qt::ClipOperation op)
1108 {
1109 Q_D(AdvancedPdfEngine);
1110 QPainterPath path = d->stroker.matrix.map(p);
1111 //qDebug() << "updateClipPath: " << d->stroker.matrix << p.boundingRect() << path.boundingRect() << op;
1112
1113 if (op == Qt::NoClip) {
1114 d->clipEnabled = false;
1115 d->clips.clear();
1116 } else if (op == Qt::ReplaceClip) {
1117 d->clips.clear();
1118 d->clips.append(path);
1119 } else if (op == Qt::IntersectClip) {
1120 d->clips.append(path);
1121 } else { // UniteClip
1122 // ask the painter for the current clipping path. that's the easiest solution
1123 path = painter()->clipPath();
1124 path = d->stroker.matrix.map(path);
1125 d->clips.clear();
1126 d->clips.append(path);
1127 }
1128 }
1129
setPen()1130 void AdvancedPdfEngine::setPen()
1131 {
1132 Q_D(AdvancedPdfEngine);
1133 if (d->pen.style() == Qt::NoPen)
1134 return;
1135 QBrush b = d->pen.brush();
1136 Q_ASSERT(b.style() == Qt::SolidPattern && b.isOpaque());
1137
1138 QColor rgba = b.color();
1139 if (d->grayscale) {
1140 qreal gray = (255-qGray(rgba.rgba()))/255.0;
1141 *d->currentPage << 0.0 << 0.0 << 0.0 << gray;
1142 } else {
1143 *d->currentPage << rgba.cyanF()
1144 << rgba.magentaF()
1145 << rgba.yellowF()
1146 << rgba.blackF();
1147 }
1148 *d->currentPage << "SCN\n";
1149
1150 *d->currentPage << d->pen.widthF() << "w ";
1151
1152 int pdfCapStyle = 0;
1153 switch(d->pen.capStyle()) {
1154 case Qt::FlatCap:
1155 pdfCapStyle = 0;
1156 break;
1157 case Qt::SquareCap:
1158 pdfCapStyle = 2;
1159 break;
1160 case Qt::RoundCap:
1161 pdfCapStyle = 1;
1162 break;
1163 default:
1164 break;
1165 }
1166 *d->currentPage << pdfCapStyle << "J ";
1167
1168 int pdfJoinStyle = 0;
1169 switch(d->pen.joinStyle()) {
1170 case Qt::MiterJoin:
1171 case Qt::SvgMiterJoin:
1172 *d->currentPage << d->pen.miterLimit() << "M ";
1173 pdfJoinStyle = 0;
1174 break;
1175 case Qt::BevelJoin:
1176 pdfJoinStyle = 2;
1177 break;
1178 case Qt::RoundJoin:
1179 pdfJoinStyle = 1;
1180 break;
1181 default:
1182 break;
1183 }
1184 *d->currentPage << pdfJoinStyle << "j ";
1185
1186 *d->currentPage << AdvancedPdf::generateDashes(d->pen) << " 0 d\n";
1187 }
1188
1189
setBrush()1190 void AdvancedPdfEngine::setBrush()
1191 {
1192 Q_D(AdvancedPdfEngine);
1193 Qt::BrushStyle style = d->brush.style();
1194 if (style == Qt::NoBrush)
1195 return;
1196
1197 bool specifyColor;
1198 int gStateObject = 0;
1199 int patternObject = d->addBrushPattern(d->stroker.matrix, &specifyColor, &gStateObject);
1200 if (!patternObject && !specifyColor)
1201 return;
1202
1203 *d->currentPage << (patternObject ? "/PCSp cs " : "/CSp cs ");
1204 if (specifyColor) {
1205 QColor rgba = d->brush.color();
1206 if (d->grayscale) {
1207 qreal gray = (255-qGray(rgba.rgba()))/255.0;
1208 *d->currentPage << 0.0 << 0.0 << 0.0 << gray;
1209 } else {
1210 *d->currentPage << rgba.cyanF()
1211 << rgba.magentaF()
1212 << rgba.yellowF()
1213 << rgba.blackF();
1214 }
1215 }
1216 if (patternObject)
1217 *d->currentPage << "/Pat" << patternObject;
1218 *d->currentPage << "scn\n";
1219
1220 if (gStateObject)
1221 *d->currentPage << "/GState" << gStateObject << "gs\n";
1222 else
1223 *d->currentPage << "/GSa gs\n";
1224 }
1225
1226
newPage()1227 bool AdvancedPdfEngine::newPage()
1228 {
1229 Q_D(AdvancedPdfEngine);
1230 if (!isActive())
1231 return false;
1232 d->newPage();
1233
1234 setupGraphicsState(DirtyBrush|DirtyPen|DirtyClipPath);
1235 QFile *outfile = qobject_cast<QFile*> (d->outDevice);
1236 if (outfile && outfile->error() != QFile::NoError)
1237 return false;
1238 return true;
1239 }
1240
1241 AdvancedPdfEngine::PaintEngineTypeStruct AdvancedPdfEngine::PaintEngineType = {};
1242
type() const1243 QPaintEngine::Type AdvancedPdfEngine::type() const
1244 {
1245 return PaintEngineType;
1246 }
1247
setResolution(int resolution)1248 void AdvancedPdfEngine::setResolution(int resolution)
1249 {
1250 Q_D(AdvancedPdfEngine);
1251 d->resolution = resolution;
1252 }
1253
resolution() const1254 int AdvancedPdfEngine::resolution() const
1255 {
1256 Q_D(const AdvancedPdfEngine);
1257 return d->resolution;
1258 }
1259
setPageLayout(const QPageLayout & pageLayout)1260 void AdvancedPdfEngine::setPageLayout(const QPageLayout &pageLayout)
1261 {
1262 Q_D(AdvancedPdfEngine);
1263 d->m_pageLayout = pageLayout;
1264 }
1265
setPageSize(const QPageSize & pageSize)1266 void AdvancedPdfEngine::setPageSize(const QPageSize &pageSize)
1267 {
1268 Q_D(AdvancedPdfEngine);
1269 d->m_pageLayout.setPageSize(pageSize);
1270 }
1271
setPageOrientation(QPageLayout::Orientation orientation)1272 void AdvancedPdfEngine::setPageOrientation(QPageLayout::Orientation orientation)
1273 {
1274 Q_D(AdvancedPdfEngine);
1275 d->m_pageLayout.setOrientation(orientation);
1276 }
1277
setPageMargins(const QMarginsF & margins,QPageLayout::Unit units)1278 void AdvancedPdfEngine::setPageMargins(const QMarginsF &margins, QPageLayout::Unit units)
1279 {
1280 Q_D(AdvancedPdfEngine);
1281 d->m_pageLayout.setUnits(units);
1282 d->m_pageLayout.setMargins(margins);
1283 }
1284
pageLayout() const1285 QPageLayout AdvancedPdfEngine::pageLayout() const
1286 {
1287 Q_D(const AdvancedPdfEngine);
1288 return d->m_pageLayout;
1289 }
1290
1291 // Metrics are in Device Pixels
metric(QPaintDevice::PaintDeviceMetric metricType) const1292 int AdvancedPdfEngine::metric(QPaintDevice::PaintDeviceMetric metricType) const
1293 {
1294 Q_D(const AdvancedPdfEngine);
1295 int val;
1296 switch (metricType) {
1297 case QPaintDevice::PdmWidth:
1298 val = d->m_pageLayout.paintRectPixels(d->resolution).width();
1299 break;
1300 case QPaintDevice::PdmHeight:
1301 val = d->m_pageLayout.paintRectPixels(d->resolution).height();
1302 break;
1303 case QPaintDevice::PdmDpiX:
1304 case QPaintDevice::PdmDpiY:
1305 val = d->resolution;
1306 break;
1307 case QPaintDevice::PdmPhysicalDpiX:
1308 case QPaintDevice::PdmPhysicalDpiY:
1309 val = 1200;
1310 break;
1311 case QPaintDevice::PdmWidthMM:
1312 val = qRound(d->m_pageLayout.paintRect(QPageLayout::Millimeter).width());
1313 break;
1314 case QPaintDevice::PdmHeightMM:
1315 val = qRound(d->m_pageLayout.paintRect(QPageLayout::Millimeter).height());
1316 break;
1317 case QPaintDevice::PdmNumColors:
1318 val = INT_MAX;
1319 break;
1320 case QPaintDevice::PdmDepth:
1321 val = 32;
1322 break;
1323 case QPaintDevice::PdmDevicePixelRatio:
1324 val = 1;
1325 break;
1326 default:
1327 qWarning("AdvancedPdfWriter::metric: Invalid metric command");
1328 return 0;
1329 }
1330 return val;
1331 }
1332
AdvancedPdfEnginePrivate()1333 AdvancedPdfEnginePrivate::AdvancedPdfEnginePrivate()
1334 : clipEnabled(false), allClipped(false), hasPen(true), hasBrush(false), simplePen(false),
1335 outDevice(0), ownsDevice(false),
1336 embedFonts(true),
1337 grayscale(false),
1338 m_pageLayout(QPageSize(QPageSize::A4), QPageLayout::Portrait, QMarginsF(10, 10, 10, 10))
1339 {
1340 resolution = 1200;
1341 currentObject = 1;
1342 currentPage = 0;
1343 stroker.stream = 0;
1344
1345 streampos = 0;
1346
1347 stream = new QDataStream;
1348 }
1349
begin(QPaintDevice * pdev)1350 bool AdvancedPdfEngine::begin(QPaintDevice *pdev)
1351 {
1352 Q_D(AdvancedPdfEngine);
1353 d->pdev = pdev;
1354
1355 if (!d->outDevice) {
1356 if (!d->outputFileName.isEmpty()) {
1357 QFile *file = new QFile(d->outputFileName);
1358 if (!file->open(QFile::WriteOnly|QFile::Truncate)) {
1359 delete file;
1360 return false;
1361 }
1362 d->outDevice = file;
1363 } else {
1364 return false;
1365 }
1366 d->ownsDevice = true;
1367 }
1368
1369 d->currentObject = 1;
1370
1371 d->currentPage = new AdvancedPdfPage;
1372 d->stroker.stream = d->currentPage;
1373 d->opacity = 1.0;
1374
1375 d->stream->setDevice(d->outDevice);
1376
1377 d->streampos = 0;
1378 d->hasPen = true;
1379 d->hasBrush = false;
1380 d->clipEnabled = false;
1381 d->allClipped = false;
1382
1383 d->xrefPositions.clear();
1384 d->pageRoot = 0;
1385 d->catalog = 0;
1386 d->info = 0;
1387 d->graphicsState = 0;
1388 d->patternColorSpace = 0;
1389 d->simplePen = false;
1390
1391 d->pages.clear();
1392 d->imageCache.clear();
1393 d->alphaCache.clear();
1394
1395 setActive(true);
1396 d->writeHeader();
1397 newPage();
1398
1399 return true;
1400 }
1401
end()1402 bool AdvancedPdfEngine::end()
1403 {
1404 Q_D(AdvancedPdfEngine);
1405 d->writeTail();
1406
1407 d->stream->unsetDevice();
1408
1409 qDeleteAll(d->fonts);
1410 d->fonts.clear();
1411 delete d->currentPage;
1412 d->currentPage = 0;
1413
1414 if (d->outDevice && d->ownsDevice) {
1415 d->outDevice->close();
1416 delete d->outDevice;
1417 d->outDevice = 0;
1418 }
1419
1420 setActive(false);
1421 return true;
1422 }
1423
~AdvancedPdfEnginePrivate()1424 AdvancedPdfEnginePrivate::~AdvancedPdfEnginePrivate()
1425 {
1426 qDeleteAll(fonts);
1427 delete currentPage;
1428 delete stream;
1429 }
1430
writeHeader()1431 void AdvancedPdfEnginePrivate::writeHeader()
1432 {
1433 addXrefEntry(0,false);
1434
1435 xprintf("%%PDF-1.4\n");
1436
1437 writeInfo();
1438
1439 catalog = addXrefEntry(-1);
1440 pageRoot = requestObject();
1441 xprintf("<<\n"
1442 "/Type /Catalog\n"
1443 "/Pages %d 0 R\n"
1444 ">>\n"
1445 "endobj\n", pageRoot);
1446
1447 // graphics state
1448 graphicsState = addXrefEntry(-1);
1449 xprintf("<<\n"
1450 "/Type /ExtGState\n"
1451 "/SA true\n"
1452 "/SM 0.02\n"
1453 "/ca 1.0\n"
1454 "/CA 1.0\n"
1455 "/AIS false\n"
1456 "/SMask /None"
1457 ">>\n"
1458 "endobj\n");
1459
1460 // color space for pattern
1461 patternColorSpace = addXrefEntry(-1);
1462 xprintf("[/Pattern /DeviceCMYK]\n"
1463 "endobj\n");
1464 }
1465
writeInfo()1466 void AdvancedPdfEnginePrivate::writeInfo()
1467 {
1468 info = addXrefEntry(-1);
1469 xprintf("<<\n/Title ");
1470 printString(title);
1471 xprintf("\n/Creator ");
1472 printString(creator);
1473 xprintf("\n/Producer ");
1474 printString(QString::fromLatin1("OpenOrienteering"));
1475 QDateTime now = QDateTime::currentDateTime().toUTC();
1476 QTime t = now.time();
1477 QDate d = now.date();
1478 xprintf("\n/CreationDate (D:%d%02d%02d%02d%02d%02d)\n",
1479 d.year(),
1480 d.month(),
1481 d.day(),
1482 t.hour(),
1483 t.minute(),
1484 t.second());
1485 xprintf(">>\n"
1486 "endobj\n");
1487 }
1488
writePageRoot()1489 void AdvancedPdfEnginePrivate::writePageRoot()
1490 {
1491 addXrefEntry(pageRoot);
1492
1493 xprintf("<<\n"
1494 "/Type /Pages\n"
1495 "/Kids \n"
1496 "[\n");
1497 int size = pages.size();
1498 for (int i = 0; i < size; ++i)
1499 xprintf("%d 0 R\n", pages[i]);
1500 xprintf("]\n");
1501
1502 //xprintf("/Group <</S /Transparency /I true /K false>>\n");
1503 xprintf("/Count %d\n", pages.size());
1504
1505 xprintf("/ProcSet [/PDF /Text /ImageB /ImageC]\n"
1506 ">>\n"
1507 "endobj\n");
1508 }
1509
1510
embedFont(QFontSubset * font)1511 void AdvancedPdfEnginePrivate::embedFont(QFontSubset *font)
1512 {
1513 //qDebug() << "embedFont" << font->object_id;
1514 int fontObject = font->object_id;
1515 QByteArray fontData = font->toTruetype();
1516 #ifdef FONT_DUMP
1517 static int i = 0;
1518 QString fileName("font%1.ttf");
1519 fileName = fileName.arg(i++);
1520 QFile ff(fileName);
1521 ff.open(QFile::WriteOnly);
1522 ff.write(fontData);
1523 ff.close();
1524 #endif
1525
1526 int fontDescriptor = requestObject();
1527 int fontstream = requestObject();
1528 int cidfont = requestObject();
1529 int toUnicode = requestObject();
1530
1531 QFontEngine::Properties properties = font->fontEngine->properties();
1532
1533 {
1534 qreal scale = 1000/properties.emSquare.toReal();
1535 addXrefEntry(fontDescriptor);
1536 QByteArray descriptor;
1537 AdvancedPdf::ByteStream s(&descriptor);
1538 s << "<< /Type /FontDescriptor\n"
1539 "/FontName /Q";
1540 int tag = fontDescriptor;
1541 for (int i = 0; i < 5; ++i) {
1542 s << (char)('A' + (tag % 26));
1543 tag /= 26;
1544 }
1545 s << '+' << properties.postscriptName << "\n"
1546 "/Flags " << 4 << "\n"
1547 "/FontBBox ["
1548 << properties.boundingBox.x()*scale
1549 << -(properties.boundingBox.y() + properties.boundingBox.height())*scale
1550 << (properties.boundingBox.x() + properties.boundingBox.width())*scale
1551 << -properties.boundingBox.y()*scale << "]\n"
1552 "/ItalicAngle " << properties.italicAngle.toReal() << "\n"
1553 "/Ascent " << properties.ascent.toReal()*scale << "\n"
1554 "/Descent " << -properties.descent.toReal()*scale << "\n"
1555 "/CapHeight " << properties.capHeight.toReal()*scale << "\n"
1556 "/StemV " << properties.lineWidth.toReal()*scale << "\n"
1557 "/FontFile2 " << fontstream << "0 R\n"
1558 ">> endobj\n";
1559 write(descriptor);
1560 }
1561 {
1562 addXrefEntry(fontstream);
1563 QByteArray header;
1564 AdvancedPdf::ByteStream s(&header);
1565
1566 int length_object = requestObject();
1567 s << "<<\n"
1568 "/Length1 " << fontData.size() << "\n"
1569 "/Length " << length_object << "0 R\n";
1570 if (do_compress)
1571 s << "/Filter /FlateDecode\n";
1572 s << ">>\n"
1573 "stream\n";
1574 write(header);
1575 int len = writeCompressed(fontData);
1576 write("endstream\n"
1577 "endobj\n");
1578 addXrefEntry(length_object);
1579 xprintf("%d\n"
1580 "endobj\n", len);
1581 }
1582 {
1583 addXrefEntry(cidfont);
1584 QByteArray cid;
1585 AdvancedPdf::ByteStream s(&cid);
1586 s << "<< /Type /Font\n"
1587 "/Subtype /CIDFontType2\n"
1588 "/BaseFont /" << properties.postscriptName << "\n"
1589 "/CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >>\n"
1590 "/FontDescriptor " << fontDescriptor << "0 R\n"
1591 "/CIDToGIDMap /Identity\n"
1592 << font->widthArray() <<
1593 ">>\n"
1594 "endobj\n";
1595 write(cid);
1596 }
1597 {
1598 addXrefEntry(toUnicode);
1599 QByteArray touc = font->createToUnicodeMap();
1600 xprintf("<< /Length %d >>\n"
1601 "stream\n", touc.length());
1602 write(touc);
1603 write("endstream\n"
1604 "endobj\n");
1605 }
1606 {
1607 addXrefEntry(fontObject);
1608 QByteArray font;
1609 AdvancedPdf::ByteStream s(&font);
1610 s << "<< /Type /Font\n"
1611 "/Subtype /Type0\n"
1612 "/BaseFont /" << properties.postscriptName << "\n"
1613 "/Encoding /Identity-H\n"
1614 "/DescendantFonts [" << cidfont << "0 R]\n"
1615 "/ToUnicode " << toUnicode << "0 R"
1616 ">>\n"
1617 "endobj\n";
1618 write(font);
1619 }
1620 }
1621
1622
writeFonts()1623 void AdvancedPdfEnginePrivate::writeFonts()
1624 {
1625 for (QHash<QFontEngine::FaceId, QFontSubset *>::iterator it = fonts.begin(); it != fonts.end(); ++it) {
1626 embedFont(*it);
1627 delete *it;
1628 }
1629 fonts.clear();
1630 }
1631
writePage()1632 void AdvancedPdfEnginePrivate::writePage()
1633 {
1634 if (pages.empty())
1635 return;
1636
1637 *currentPage << "Q Q\n";
1638
1639 uint pageStream = requestObject();
1640 uint pageStreamLength = requestObject();
1641 uint resources = requestObject();
1642 uint annots = requestObject();
1643
1644 addXrefEntry(pages.last());
1645 xprintf("<<\n"
1646 "/Type /Page\n"
1647 "/Parent %d 0 R\n"
1648 "/Contents %d 0 R\n"
1649 "/Resources %d 0 R\n"
1650 "/Annots %d 0 R\n"
1651 "/MediaBox [0 0 %d %d]\n"
1652 ">>\n"
1653 "endobj\n",
1654 pageRoot, pageStream, resources, annots,
1655 // make sure we use the pagesize from when we started the page, since the user may have changed it
1656 currentPage->pageSize.width(), currentPage->pageSize.height());
1657
1658 addXrefEntry(resources);
1659 xprintf("<<\n"
1660 "/ColorSpace <<\n"
1661 "/PCSp %d 0 R\n"
1662 "/CSp /DeviceCMYK\n"
1663 "/CSpg /DeviceGray\n"
1664 ">>\n"
1665 "/ExtGState <<\n"
1666 "/GSa %d 0 R\n",
1667 patternColorSpace, graphicsState);
1668
1669 for (int i = 0; i < currentPage->graphicStates.size(); ++i)
1670 xprintf("/GState%d %d 0 R\n", currentPage->graphicStates.at(i), currentPage->graphicStates.at(i));
1671 xprintf(">>\n");
1672
1673 xprintf("/Pattern <<\n");
1674 for (int i = 0; i < currentPage->patterns.size(); ++i)
1675 xprintf("/Pat%d %d 0 R\n", currentPage->patterns.at(i), currentPage->patterns.at(i));
1676 xprintf(">>\n");
1677
1678 xprintf("/Font <<\n");
1679 for (int i = 0; i < currentPage->fonts.size();++i)
1680 xprintf("/F%d %d 0 R\n", currentPage->fonts[i], currentPage->fonts[i]);
1681 xprintf(">>\n");
1682
1683 xprintf("/XObject <<\n");
1684 for (int i = 0; i<currentPage->images.size(); ++i) {
1685 xprintf("/Im%d %d 0 R\n", currentPage->images.at(i), currentPage->images.at(i));
1686 }
1687 xprintf(">>\n");
1688
1689 xprintf(">>\n"
1690 "endobj\n");
1691
1692 addXrefEntry(annots);
1693 xprintf("[ ");
1694 for (int i = 0; i<currentPage->annotations.size(); ++i) {
1695 xprintf("%d 0 R ", currentPage->annotations.at(i));
1696 }
1697 xprintf("]\nendobj\n");
1698
1699 addXrefEntry(pageStream);
1700 xprintf("<<\n"
1701 "/Length %d 0 R\n", pageStreamLength); // object number for stream length object
1702 if (do_compress)
1703 xprintf("/Filter /FlateDecode\n");
1704
1705 xprintf(">>\n");
1706 xprintf("stream\n");
1707 QIODevice *content = currentPage->stream();
1708 int len = writeCompressed(content);
1709 xprintf("endstream\n"
1710 "endobj\n");
1711
1712 addXrefEntry(pageStreamLength);
1713 xprintf("%d\nendobj\n",len);
1714 }
1715
writeTail()1716 void AdvancedPdfEnginePrivate::writeTail()
1717 {
1718 writePage();
1719 writeFonts();
1720 writePageRoot();
1721 addXrefEntry(xrefPositions.size(),false);
1722 xprintf("xref\n"
1723 "0 %d\n"
1724 "%010d 65535 f \n", xrefPositions.size()-1, xrefPositions[0]);
1725
1726 for (int i = 1; i < xrefPositions.size()-1; ++i)
1727 xprintf("%010d 00000 n \n", xrefPositions[i]);
1728
1729 xprintf("trailer\n"
1730 "<<\n"
1731 "/Size %d\n"
1732 "/Info %d 0 R\n"
1733 "/Root %d 0 R\n"
1734 ">>\n"
1735 "startxref\n%d\n"
1736 "%%%%EOF\n",
1737 xrefPositions.size()-1, info, catalog, xrefPositions.last());
1738 }
1739
addXrefEntry(int object,bool printostr)1740 int AdvancedPdfEnginePrivate::addXrefEntry(int object, bool printostr)
1741 {
1742 if (object < 0)
1743 object = requestObject();
1744
1745 if (object>=xrefPositions.size())
1746 xrefPositions.resize(object+1);
1747
1748 xrefPositions[object] = streampos;
1749 if (printostr)
1750 xprintf("%d 0 obj\n",object);
1751
1752 return object;
1753 }
1754
printString(const QString & string)1755 void AdvancedPdfEnginePrivate::printString(const QString &string) {
1756 // The 'text string' type in PDF is encoded either as PDFDocEncoding, or
1757 // Unicode UTF-16 with a Unicode byte order mark as the first character
1758 // (0xfeff), with the high-order byte first.
1759 QByteArray array("(\xfe\xff");
1760 const ushort *utf16 = string.utf16();
1761
1762 for (int i=0; i < string.size(); ++i) {
1763 char part[2] = {char((*(utf16 + i)) >> 8), char((*(utf16 + i)) & 0xff)};
1764 for(int j=0; j < 2; ++j) {
1765 if (part[j] == '(' || part[j] == ')' || part[j] == '\\')
1766 array.append('\\');
1767 array.append(part[j]);
1768 }
1769 }
1770 array.append(")");
1771 write(array);
1772 }
1773
1774
1775 // For strings up to 10000 bytes only !
xprintf(const char * fmt,...)1776 void AdvancedPdfEnginePrivate::xprintf(const char* fmt, ...)
1777 {
1778 if (!stream)
1779 return;
1780
1781 const int msize = 10000;
1782 char buf[msize];
1783
1784 va_list args;
1785 va_start(args, fmt);
1786 int bufsize = qvsnprintf(buf, msize, fmt, args);
1787
1788 Q_ASSERT(bufsize<msize);
1789
1790 va_end(args);
1791
1792 stream->writeRawData(buf, bufsize);
1793 streampos += bufsize;
1794 }
1795
writeCompressed(QIODevice * dev)1796 int AdvancedPdfEnginePrivate::writeCompressed(QIODevice *dev)
1797 {
1798 #ifndef QT_NO_COMPRESS
1799 if (do_compress) {
1800 int size = AdvancedPdfPage::chunkSize();
1801 int sum = 0;
1802 ::z_stream zStruct;
1803 zStruct.zalloc = Z_NULL;
1804 zStruct.zfree = Z_NULL;
1805 zStruct.opaque = Z_NULL;
1806 if (::deflateInit(&zStruct, Z_DEFAULT_COMPRESSION) != Z_OK) {
1807 qWarning("AdvancedPdfStream::writeCompressed: Error in deflateInit()");
1808 return sum;
1809 }
1810 zStruct.avail_in = 0;
1811 QByteArray in, out;
1812 out.resize(size);
1813 while (!dev->atEnd() || zStruct.avail_in != 0) {
1814 if (zStruct.avail_in == 0) {
1815 in = dev->read(size);
1816 zStruct.avail_in = in.size();
1817 zStruct.next_in = reinterpret_cast<unsigned char*>(in.data());
1818 if (in.size() <= 0) {
1819 qWarning("AdvancedPdfStream::writeCompressed: Error in read()");
1820 ::deflateEnd(&zStruct);
1821 return sum;
1822 }
1823 }
1824 zStruct.next_out = reinterpret_cast<unsigned char*>(out.data());
1825 zStruct.avail_out = out.size();
1826 if (::deflate(&zStruct, 0) != Z_OK) {
1827 qWarning("AdvancedPdfStream::writeCompressed: Error in deflate()");
1828 ::deflateEnd(&zStruct);
1829 return sum;
1830 }
1831 int written = out.size() - zStruct.avail_out;
1832 stream->writeRawData(out.constData(), written);
1833 streampos += written;
1834 sum += written;
1835 }
1836 int ret;
1837 do {
1838 zStruct.next_out = reinterpret_cast<unsigned char*>(out.data());
1839 zStruct.avail_out = out.size();
1840 ret = ::deflate(&zStruct, Z_FINISH);
1841 if (ret != Z_OK && ret != Z_STREAM_END) {
1842 qWarning("AdvancedPdfStream::writeCompressed: Error in deflate()");
1843 ::deflateEnd(&zStruct);
1844 return sum;
1845 }
1846 int written = out.size() - zStruct.avail_out;
1847 stream->writeRawData(out.constData(), written);
1848 streampos += written;
1849 sum += written;
1850 } while (ret == Z_OK);
1851
1852 ::deflateEnd(&zStruct);
1853
1854 return sum;
1855 } else
1856 #endif
1857 {
1858 QByteArray arr;
1859 int sum = 0;
1860 while (!dev->atEnd()) {
1861 arr = dev->read(AdvancedPdfPage::chunkSize());
1862 stream->writeRawData(arr.constData(), arr.size());
1863 streampos += arr.size();
1864 sum += arr.size();
1865 }
1866 return sum;
1867 }
1868 }
1869
writeCompressed(const char * src,int len)1870 int AdvancedPdfEnginePrivate::writeCompressed(const char *src, int len)
1871 {
1872 #ifndef QT_NO_COMPRESS
1873 if(do_compress) {
1874 uLongf destLen = len + len/100 + 13; // zlib requirement
1875 Bytef* dest = new Bytef[destLen];
1876 if (Z_OK == ::compress(dest, &destLen, (const Bytef*) src, (uLongf)len)) {
1877 stream->writeRawData((const char*)dest, destLen);
1878 } else {
1879 qWarning("AdvancedPdfStream::writeCompressed: Error in compress()");
1880 destLen = 0;
1881 }
1882 delete [] dest;
1883 len = destLen;
1884 } else
1885 #endif
1886 {
1887 stream->writeRawData(src,len);
1888 }
1889 streampos += len;
1890 return len;
1891 }
1892
writeImage(const QByteArray & data,int width,int height,int depth,int maskObject,int softMaskObject,bool dct)1893 int AdvancedPdfEnginePrivate::writeImage(const QByteArray &data, int width, int height, int depth,
1894 int maskObject, int softMaskObject, bool dct)
1895 {
1896 int image = addXrefEntry(-1);
1897 xprintf("<<\n"
1898 "/Type /XObject\n"
1899 "/Subtype /Image\n"
1900 "/Width %d\n"
1901 "/Height %d\n", width, height);
1902
1903 if (depth == 1) {
1904 xprintf("/ImageMask true\n"
1905 "/Decode [1 0]\n");
1906 } else {
1907 xprintf("/BitsPerComponent 8\n"
1908 "/ColorSpace %s\n", (depth == 32) ? "/DeviceRGB" : "/DeviceGray");
1909 }
1910 if (maskObject > 0)
1911 xprintf("/Mask %d 0 R\n", maskObject);
1912 if (softMaskObject > 0)
1913 xprintf("/SMask %d 0 R\n", softMaskObject);
1914
1915 int lenobj = requestObject();
1916 xprintf("/Length %d 0 R\n", lenobj);
1917 if (interpolateImages)
1918 xprintf("/Interpolate true\n");
1919 int len = 0;
1920 if (dct) {
1921 //qDebug() << "DCT";
1922 xprintf("/Filter /DCTDecode\n>>\nstream\n");
1923 write(data);
1924 len = data.length();
1925 } else {
1926 if (do_compress)
1927 xprintf("/Filter /FlateDecode\n>>\nstream\n");
1928 else
1929 xprintf(">>\nstream\n");
1930 len = writeCompressed(data);
1931 }
1932 xprintf("endstream\n"
1933 "endobj\n");
1934 addXrefEntry(lenobj);
1935 xprintf("%d\n"
1936 "endobj\n", len);
1937 return image;
1938 }
1939
1940 struct QGradientBound {
1941 qreal start;
1942 qreal stop;
1943 int function;
1944 bool reverse;
1945 };
1946
createShadingFunction(const QGradient * gradient,int from,int to,bool reflect,bool alpha)1947 int AdvancedPdfEnginePrivate::createShadingFunction(const QGradient *gradient, int from, int to, bool reflect, bool alpha)
1948 {
1949 QGradientStops stops = gradient->stops();
1950 if (stops.isEmpty()) {
1951 stops << QGradientStop(0, Qt::black);
1952 stops << QGradientStop(1, Qt::white);
1953 }
1954 if (stops.at(0).first > 0)
1955 stops.prepend(QGradientStop(0, stops.at(0).second));
1956 if (stops.at(stops.size() - 1).first < 1)
1957 stops.append(QGradientStop(1, stops.at(stops.size() - 1).second));
1958
1959 QVector<int> functions;
1960 for (int i = 0; i < stops.size() - 1; ++i) {
1961 int f = addXrefEntry(-1);
1962 QByteArray data;
1963 AdvancedPdf::ByteStream s(&data);
1964 s << "<<\n"
1965 "/FunctionType 2\n"
1966 "/Domain [0 1]\n"
1967 "/N 1\n";
1968 if (alpha) {
1969 s << "/C0 [" << stops.at(i).second.alphaF() << "]\n"
1970 "/C1 [" << stops.at(i + 1).second.alphaF() << "]\n";
1971 } else {
1972 s << "/C0 [" << stops.at(i).second.redF() << stops.at(i).second.greenF() << stops.at(i).second.blueF() << "]\n"
1973 "/C1 [" << stops.at(i + 1).second.redF() << stops.at(i + 1).second.greenF() << stops.at(i + 1).second.blueF() << "]\n";
1974 }
1975 s << ">>\n"
1976 "endobj\n";
1977 write(data);
1978 functions << f;
1979 }
1980
1981 QVector<QGradientBound> gradientBounds;
1982
1983 for (int step = from; step < to; ++step) {
1984 if (reflect && step % 2) {
1985 for (int i = stops.size() - 1; i > 0; --i) {
1986 QGradientBound b;
1987 b.start = step + 1 - qBound(qreal(0.), stops.at(i).first, qreal(1.));
1988 b.stop = step + 1 - qBound(qreal(0.), stops.at(i - 1).first, qreal(1.));
1989 b.function = functions.at(i - 1);
1990 b.reverse = true;
1991 gradientBounds << b;
1992 }
1993 } else {
1994 for (int i = 0; i < stops.size() - 1; ++i) {
1995 QGradientBound b;
1996 b.start = step + qBound(qreal(0.), stops.at(i).first, qreal(1.));
1997 b.stop = step + qBound(qreal(0.), stops.at(i + 1).first, qreal(1.));
1998 b.function = functions.at(i);
1999 b.reverse = false;
2000 gradientBounds << b;
2001 }
2002 }
2003 }
2004
2005 // normalize bounds to [0..1]
2006 qreal bstart = gradientBounds.at(0).start;
2007 qreal bend = gradientBounds.at(gradientBounds.size() - 1).stop;
2008 qreal norm = 1./(bend - bstart);
2009 for (int i = 0; i < gradientBounds.size(); ++i) {
2010 gradientBounds[i].start = (gradientBounds[i].start - bstart)*norm;
2011 gradientBounds[i].stop = (gradientBounds[i].stop - bstart)*norm;
2012 }
2013
2014 int function;
2015 if (gradientBounds.size() > 1) {
2016 function = addXrefEntry(-1);
2017 QByteArray data;
2018 AdvancedPdf::ByteStream s(&data);
2019 s << "<<\n"
2020 "/FunctionType 3\n"
2021 "/Domain [0 1]\n"
2022 "/Bounds [";
2023 for (int i = 1; i < gradientBounds.size(); ++i)
2024 s << gradientBounds.at(i).start;
2025 s << "]\n"
2026 "/Encode [";
2027 for (int i = 0; i < gradientBounds.size(); ++i)
2028 s << (gradientBounds.at(i).reverse ? "1 0 " : "0 1 ");
2029 s << "]\n"
2030 "/Functions [";
2031 for (int i = 0; i < gradientBounds.size(); ++i)
2032 s << gradientBounds.at(i).function << "0 R ";
2033 s << "]\n"
2034 ">>\n";
2035 write(data);
2036 } else {
2037 function = functions.at(0);
2038 }
2039 return function;
2040 }
2041
generateLinearGradientShader(const QLinearGradient * gradient,const QTransform & matrix,bool alpha)2042 int AdvancedPdfEnginePrivate::generateLinearGradientShader(const QLinearGradient *gradient, const QTransform &matrix, bool alpha)
2043 {
2044 QPointF start = gradient->start();
2045 QPointF stop = gradient->finalStop();
2046 QPointF offset = stop - start;
2047 Q_ASSERT(gradient->coordinateMode() == QGradient::LogicalMode);
2048
2049 int from = 0;
2050 int to = 1;
2051 bool reflect = false;
2052 switch (gradient->spread()) {
2053 case QGradient::PadSpread:
2054 break;
2055 case QGradient::ReflectSpread:
2056 reflect = true;
2057 // fall through
2058 case QGradient::RepeatSpread: {
2059 // calculate required bounds
2060 QRectF pageRect = m_pageLayout.fullRectPixels(resolution);
2061 QTransform inv = matrix.inverted();
2062 QPointF page_rect[4] = { inv.map(pageRect.topLeft()),
2063 inv.map(pageRect.topRight()),
2064 inv.map(pageRect.bottomLeft()),
2065 inv.map(pageRect.bottomRight()) };
2066
2067 qreal length = offset.x()*offset.x() + offset.y()*offset.y();
2068
2069 // find the max and min values in offset and orth direction that are needed to cover
2070 // the whole page
2071 from = INT_MAX;
2072 to = INT_MIN;
2073 for (int i = 0; i < 4; ++i) {
2074 qreal off = ((page_rect[i].x() - start.x()) * offset.x() + (page_rect[i].y() - start.y()) * offset.y())/length;
2075 from = qMin(from, qFloor(off));
2076 to = qMax(to, qCeil(off));
2077 }
2078
2079 stop = start + to * offset;
2080 start = start + from * offset;\
2081 break;
2082 }
2083 }
2084
2085 int function = createShadingFunction(gradient, from, to, reflect, alpha);
2086
2087 QByteArray shader;
2088 AdvancedPdf::ByteStream s(&shader);
2089 s << "<<\n"
2090 "/ShadingType 2\n"
2091 "/ColorSpace " << (alpha ? "/DeviceGray\n" : "/DeviceRGB\n") <<
2092 "/AntiAlias true\n"
2093 "/Coords [" << start.x() << start.y() << stop.x() << stop.y() << "]\n"
2094 "/Extend [true true]\n"
2095 "/Function " << function << "0 R\n"
2096 ">>\n"
2097 "endobj\n";
2098 int shaderObject = addXrefEntry(-1);
2099 write(shader);
2100 return shaderObject;
2101 }
2102
generateRadialGradientShader(const QRadialGradient * gradient,const QTransform & matrix,bool alpha)2103 int AdvancedPdfEnginePrivate::generateRadialGradientShader(const QRadialGradient *gradient, const QTransform &matrix, bool alpha)
2104 {
2105 QPointF p1 = gradient->center();
2106 double r1 = gradient->centerRadius();
2107 QPointF p0 = gradient->focalPoint();
2108 double r0 = gradient->focalRadius();
2109
2110 Q_ASSERT(gradient->coordinateMode() == QGradient::LogicalMode);
2111
2112 int from = 0;
2113 int to = 1;
2114 bool reflect = false;
2115 switch (gradient->spread()) {
2116 case QGradient::PadSpread:
2117 break;
2118 case QGradient::ReflectSpread:
2119 reflect = true;
2120 // fall through
2121 case QGradient::RepeatSpread: {
2122 Q_ASSERT(qFuzzyIsNull(r0)); // QPainter emulates if this is not 0
2123
2124 QRectF pageRect = m_pageLayout.fullRectPixels(resolution);
2125 QTransform inv = matrix.inverted();
2126 QPointF page_rect[4] = { inv.map(pageRect.topLeft()),
2127 inv.map(pageRect.topRight()),
2128 inv.map(pageRect.bottomLeft()),
2129 inv.map(pageRect.bottomRight()) };
2130
2131 // increase to until the whole page fits into it
2132 bool done = false;
2133 while (!done) {
2134 QPointF center = QPointF(p0.x() + to*(p1.x() - p0.x()), p0.y() + to*(p1.y() - p0.y()));
2135 double radius = r0 + to*(r1 - r0);
2136 double r2 = radius*radius;
2137 done = true;
2138 for (int i = 0; i < 4; ++i) {
2139 QPointF off = page_rect[i] - center;
2140 if (off.x()*off.x() + off.y()*off.y() > r2) {
2141 ++to;
2142 done = false;
2143 break;
2144 }
2145 }
2146 }
2147 p1 = QPointF(p0.x() + to*(p1.x() - p0.x()), p0.y() + to*(p1.y() - p0.y()));
2148 r1 = r0 + to*(r1 - r0);
2149 break;
2150 }
2151 }
2152
2153 int function = createShadingFunction(gradient, from, to, reflect, alpha);
2154
2155 QByteArray shader;
2156 AdvancedPdf::ByteStream s(&shader);
2157 s << "<<\n"
2158 "/ShadingType 3\n"
2159 "/ColorSpace " << (alpha ? "/DeviceGray\n" : "/DeviceRGB\n") <<
2160 "/AntiAlias true\n"
2161 "/Domain [0 1]\n"
2162 "/Coords [" << p0.x() << p0.y() << r0 << p1.x() << p1.y() << r1 << "]\n"
2163 "/Extend [true true]\n"
2164 "/Function " << function << "0 R\n"
2165 ">>\n"
2166 "endobj\n";
2167 int shaderObject = addXrefEntry(-1);
2168 write(shader);
2169 return shaderObject;
2170 }
2171
generateGradientShader(const QGradient * gradient,const QTransform & matrix,bool alpha)2172 int AdvancedPdfEnginePrivate::generateGradientShader(const QGradient *gradient, const QTransform &matrix, bool alpha)
2173 {
2174 switch (gradient->type()) {
2175 case QGradient::LinearGradient:
2176 return generateLinearGradientShader(static_cast<const QLinearGradient *>(gradient), matrix, alpha);
2177 case QGradient::RadialGradient:
2178 return generateRadialGradientShader(static_cast<const QRadialGradient *>(gradient), matrix, alpha);
2179 case QGradient::ConicalGradient:
2180 default:
2181 qWarning() << "Implement me!";
2182 }
2183 return 0;
2184 }
2185
gradientBrush(const QBrush & b,const QTransform & matrix,int * gStateObject)2186 int AdvancedPdfEnginePrivate::gradientBrush(const QBrush &b, const QTransform &matrix, int *gStateObject)
2187 {
2188 const QGradient *gradient = b.gradient();
2189
2190 if (!gradient || gradient->coordinateMode() != QGradient::LogicalMode)
2191 return 0;
2192
2193 QRectF pageRect = m_pageLayout.fullRectPixels(resolution);
2194
2195 QTransform m = b.transform() * matrix;
2196 int shaderObject = generateGradientShader(gradient, m);
2197
2198 QByteArray str;
2199 AdvancedPdf::ByteStream s(&str);
2200 s << "<<\n"
2201 "/Type /Pattern\n"
2202 "/PatternType 2\n"
2203 "/Shading " << shaderObject << "0 R\n"
2204 "/Matrix ["
2205 << m.m11()
2206 << m.m12()
2207 << m.m21()
2208 << m.m22()
2209 << m.dx()
2210 << m.dy() << "]\n";
2211 s << ">>\n"
2212 "endobj\n";
2213
2214 int patternObj = addXrefEntry(-1);
2215 write(str);
2216 currentPage->patterns.append(patternObj);
2217
2218 if (!b.isOpaque()) {
2219 bool ca = true;
2220 QGradientStops stops = gradient->stops();
2221 int a = stops.at(0).second.alpha();
2222 for (int i = 1; i < stops.size(); ++i) {
2223 if (stops.at(i).second.alpha() != a) {
2224 ca = false;
2225 break;
2226 }
2227 }
2228 if (ca) {
2229 *gStateObject = addConstantAlphaObject(stops.at(0).second.alpha());
2230 } else {
2231 int alphaShaderObject = generateGradientShader(gradient, m, true);
2232
2233 QByteArray content;
2234 AdvancedPdf::ByteStream c(&content);
2235 c << "/Shader" << alphaShaderObject << "sh\n";
2236
2237 QByteArray form;
2238 AdvancedPdf::ByteStream f(&form);
2239 f << "<<\n"
2240 "/Type /XObject\n"
2241 "/Subtype /Form\n"
2242 "/BBox [0 0 " << pageRect.width() << pageRect.height() << "]\n"
2243 "/Group <</S /Transparency >>\n"
2244 "/Resources <<\n"
2245 "/Shading << /Shader" << alphaShaderObject << alphaShaderObject << "0 R >>\n"
2246 ">>\n";
2247
2248 f << "/Length " << content.length() << "\n"
2249 ">>\n"
2250 "stream\n"
2251 << content
2252 << "endstream\n"
2253 "endobj\n";
2254
2255 int softMaskFormObject = addXrefEntry(-1);
2256 write(form);
2257 *gStateObject = addXrefEntry(-1);
2258 xprintf("<< /SMask << /S /Alpha /G %d 0 R >> >>\n"
2259 "endobj\n", softMaskFormObject);
2260 currentPage->graphicStates.append(*gStateObject);
2261 }
2262 }
2263
2264 return patternObj;
2265 }
2266
addConstantAlphaObject(int brushAlpha,int penAlpha)2267 int AdvancedPdfEnginePrivate::addConstantAlphaObject(int brushAlpha, int penAlpha)
2268 {
2269 if (brushAlpha == 255 && penAlpha == 255)
2270 return 0;
2271 int object = alphaCache.value(QPair<uint, uint>(brushAlpha, penAlpha), 0);
2272 if (!object) {
2273 object = addXrefEntry(-1);
2274 QByteArray alphaDef;
2275 AdvancedPdf::ByteStream s(&alphaDef);
2276 s << "<<\n/ca " << (brushAlpha/qreal(255.)) << '\n';
2277 s << "/CA " << (penAlpha/qreal(255.)) << "\n>>";
2278 xprintf("%s\nendobj\n", alphaDef.constData());
2279 alphaCache.insert(QPair<uint, uint>(brushAlpha, penAlpha), object);
2280 }
2281 if (currentPage->graphicStates.indexOf(object) < 0)
2282 currentPage->graphicStates.append(object);
2283
2284 return object;
2285 }
2286
2287
addBrushPattern(const QTransform & m,bool * specifyColor,int * gStateObject)2288 int AdvancedPdfEnginePrivate::addBrushPattern(const QTransform &m, bool *specifyColor, int *gStateObject)
2289 {
2290 int paintType = 2; // Uncolored tiling
2291 int w = 8;
2292 int h = 8;
2293
2294 *specifyColor = true;
2295 *gStateObject = 0;
2296
2297 QTransform matrix = m;
2298 matrix.translate(brushOrigin.x(), brushOrigin.y());
2299 matrix = matrix * pageMatrix();
2300 //qDebug() << brushOrigin << matrix;
2301
2302 Qt::BrushStyle style = brush.style();
2303 if (style == Qt::LinearGradientPattern || style == Qt::RadialGradientPattern) {// && style <= Qt::ConicalGradientPattern) {
2304 *specifyColor = false;
2305 return gradientBrush(brush, matrix, gStateObject);
2306 }
2307
2308 if ((!brush.isOpaque() && brush.style() < Qt::LinearGradientPattern) || opacity != 1.0)
2309 *gStateObject = addConstantAlphaObject(qRound(brush.color().alpha() * opacity),
2310 qRound(pen.color().alpha() * opacity));
2311
2312 int imageObject = -1;
2313 QByteArray pattern = AdvancedPdf::patternForBrush(brush);
2314 if (pattern.isEmpty()) {
2315 if (brush.style() != Qt::TexturePattern)
2316 return 0;
2317 QImage image = brush.textureImage();
2318 bool bitmap = true;
2319 imageObject = addImage(image, &bitmap, image.cacheKey());
2320 if (imageObject != -1) {
2321 QImage::Format f = image.format();
2322 if (f != QImage::Format_MonoLSB && f != QImage::Format_Mono) {
2323 paintType = 1; // Colored tiling
2324 *specifyColor = false;
2325 }
2326 w = image.width();
2327 h = image.height();
2328 QTransform m(w, 0, 0, -h, 0, h);
2329 AdvancedPdf::ByteStream s(&pattern);
2330 s << AdvancedPdf::generateMatrix(m);
2331 s << "/Im" << imageObject << " Do\n";
2332 }
2333 }
2334
2335 QByteArray str;
2336 AdvancedPdf::ByteStream s(&str);
2337 s << "<<\n"
2338 "/Type /Pattern\n"
2339 "/PatternType 1\n"
2340 "/PaintType " << paintType << "\n"
2341 "/TilingType 1\n"
2342 "/BBox [0 0 " << w << h << "]\n"
2343 "/XStep " << w << "\n"
2344 "/YStep " << h << "\n"
2345 "/Matrix ["
2346 << matrix.m11()
2347 << matrix.m12()
2348 << matrix.m21()
2349 << matrix.m22()
2350 << matrix.dx()
2351 << matrix.dy() << "]\n"
2352 "/Resources \n<< "; // open resource tree
2353 if (imageObject > 0) {
2354 s << "/XObject << /Im" << imageObject << ' ' << imageObject << "0 R >> ";
2355 }
2356 s << ">>\n"
2357 "/Length " << pattern.length() << "\n"
2358 ">>\n"
2359 "stream\n"
2360 << pattern
2361 << "endstream\n"
2362 "endobj\n";
2363
2364 int patternObj = addXrefEntry(-1);
2365 write(str);
2366 currentPage->patterns.append(patternObj);
2367 return patternObj;
2368 }
2369
is_monochrome(const QVector<QRgb> & colorTable)2370 static inline bool is_monochrome(const QVector<QRgb> &colorTable)
2371 {
2372 return colorTable.size() == 2
2373 && colorTable.at(0) == QColor(Qt::black).rgba()
2374 && colorTable.at(1) == QColor(Qt::white).rgba()
2375 ;
2376 }
2377
2378 /*!
2379 * Adds an image to the pdf and return the pdf-object id. Returns -1 if adding the image failed.
2380 */
addImage(const QImage & img,bool * bitmap,qint64 serial_no)2381 int AdvancedPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, qint64 serial_no)
2382 {
2383 if (img.isNull())
2384 return -1;
2385
2386 int object = imageCache.value(serial_no);
2387 if(object)
2388 return object;
2389
2390 QImage image = img;
2391 QImage::Format format = image.format();
2392 if (image.depth() == 1 && *bitmap && is_monochrome(img.colorTable())) {
2393 if (format == QImage::Format_MonoLSB)
2394 image = image.convertToFormat(QImage::Format_Mono);
2395 format = QImage::Format_Mono;
2396 } else {
2397 *bitmap = false;
2398 if (format != QImage::Format_RGB32 && format != QImage::Format_ARGB32) {
2399 image = image.convertToFormat(QImage::Format_ARGB32);
2400 format = QImage::Format_ARGB32;
2401 }
2402 }
2403
2404 int w = image.width();
2405 int h = image.height();
2406 int d = image.depth();
2407
2408 if (format == QImage::Format_Mono) {
2409 int bytesPerLine = (w + 7) >> 3;
2410 QByteArray data;
2411 data.resize(bytesPerLine * h);
2412 char *rawdata = data.data();
2413 for (int y = 0; y < h; ++y) {
2414 memcpy(rawdata, image.constScanLine(y), bytesPerLine);
2415 rawdata += bytesPerLine;
2416 }
2417 object = writeImage(data, w, h, d, 0, 0);
2418 } else {
2419 QByteArray softMaskData;
2420 bool dct = false;
2421 QByteArray imageData;
2422 bool hasAlpha = false;
2423 bool hasMask = false;
2424
2425 if (QImageWriter::supportedImageFormats().contains("jpeg") && !grayscale) {
2426 QBuffer buffer(&imageData);
2427 QImageWriter writer(&buffer, "jpeg");
2428 writer.setQuality(94);
2429 writer.write(image);
2430 dct = true;
2431
2432 if (format != QImage::Format_RGB32) {
2433 softMaskData.resize(w * h);
2434 uchar *sdata = (uchar *)softMaskData.data();
2435 for (int y = 0; y < h; ++y) {
2436 const QRgb *rgb = (const QRgb *)image.constScanLine(y);
2437 for (int x = 0; x < w; ++x) {
2438 uchar alpha = qAlpha(*rgb);
2439 *sdata++ = alpha;
2440 hasMask |= (alpha < 255);
2441 hasAlpha |= (alpha != 0 && alpha != 255);
2442 ++rgb;
2443 }
2444 }
2445 }
2446 } else {
2447 imageData.resize(grayscale ? w * h : 3 * w * h);
2448 uchar *data = (uchar *)imageData.data();
2449 softMaskData.resize(w * h);
2450 uchar *sdata = (uchar *)softMaskData.data();
2451 for (int y = 0; y < h; ++y) {
2452 const QRgb *rgb = (const QRgb *)image.constScanLine(y);
2453 if (grayscale) {
2454 for (int x = 0; x < w; ++x) {
2455 *(data++) = qGray(*rgb);
2456 uchar alpha = qAlpha(*rgb);
2457 *sdata++ = alpha;
2458 hasMask |= (alpha < 255);
2459 hasAlpha |= (alpha != 0 && alpha != 255);
2460 ++rgb;
2461 }
2462 } else {
2463 for (int x = 0; x < w; ++x) {
2464 *(data++) = qRed(*rgb);
2465 *(data++) = qGreen(*rgb);
2466 *(data++) = qBlue(*rgb);
2467 uchar alpha = qAlpha(*rgb);
2468 *sdata++ = alpha;
2469 hasMask |= (alpha < 255);
2470 hasAlpha |= (alpha != 0 && alpha != 255);
2471 ++rgb;
2472 }
2473 }
2474 }
2475 if (format == QImage::Format_RGB32)
2476 hasAlpha = hasMask = false;
2477 }
2478 int maskObject = 0;
2479 int softMaskObject = 0;
2480 if (hasAlpha) {
2481 softMaskObject = writeImage(softMaskData, w, h, 8, 0, 0);
2482 } else if (hasMask) {
2483 // dither the soft mask to 1bit and add it. This also helps PDF viewers
2484 // without transparency support
2485 int bytesPerLine = (w + 7) >> 3;
2486 QByteArray mask(bytesPerLine * h, 0);
2487 uchar *mdata = (uchar *)mask.data();
2488 const uchar *sdata = (const uchar *)softMaskData.constData();
2489 for (int y = 0; y < h; ++y) {
2490 for (int x = 0; x < w; ++x) {
2491 if (*sdata)
2492 mdata[x>>3] |= (0x80 >> (x&7));
2493 ++sdata;
2494 }
2495 mdata += bytesPerLine;
2496 }
2497 maskObject = writeImage(mask, w, h, 1, 0, 0);
2498 }
2499 object = writeImage(imageData, w, h, grayscale ? 8 : 32,
2500 maskObject, softMaskObject, dct);
2501 }
2502 imageCache.insert(serial_no, object);
2503 return object;
2504 }
2505
drawTextItem(const QPointF & p,const QTextItemInt & ti)2506 void AdvancedPdfEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti)
2507 {
2508 Q_Q(AdvancedPdfEngine);
2509
2510 if (ti.charFormat.isAnchor()) {
2511 qreal size = ti.fontEngine->fontDef.pixelSize;
2512 int synthesized = ti.fontEngine->synthesized();
2513 qreal stretch = synthesized & QFontEngine::SynthesizedStretch ? ti.fontEngine->fontDef.stretch/100. : 1.;
2514
2515 QTransform trans;
2516 // Build text rendering matrix (Trm). We need it to map the text area to user
2517 // space units on the PDF page.
2518 trans = QTransform(size*stretch, 0, 0, size, 0, 0);
2519 // Apply text matrix (Tm).
2520 trans *= QTransform(1,0,0,-1,p.x(),p.y());
2521 // Apply page displacement (Identity for first page).
2522 trans *= stroker.matrix;
2523 // Apply Current Transformation Matrix (CTM)
2524 trans *= pageMatrix();
2525 qreal x1, y1, x2, y2;
2526 trans.map(0, 0, &x1, &y1);
2527 trans.map(ti.width.toReal()/size, (ti.ascent.toReal()-ti.descent.toReal())/size, &x2, &y2);
2528
2529 uint annot = addXrefEntry(-1);
2530 QByteArray x1s, y1s, x2s, y2s;
2531 x1s.setNum(static_cast<double>(x1), 'f');
2532 y1s.setNum(static_cast<double>(y1), 'f');
2533 x2s.setNum(static_cast<double>(x2), 'f');
2534 y2s.setNum(static_cast<double>(y2), 'f');
2535 QByteArray rectData = x1s + ' ' + y1s + ' ' + x2s + ' ' + y2s;
2536 xprintf("<<\n/Type /Annot\n/Subtype /Link\n/Rect [");
2537 xprintf(rectData.constData());
2538 #ifdef Q_DEBUG_PDF_LINKS
2539 xprintf("]\n/Border [16 16 1]\n/A <<\n");
2540 #else
2541 xprintf("]\n/Border [0 0 0]\n/A <<\n");
2542 #endif
2543 xprintf("/Type /Action\n/S /URI\n/URI (%s)\n",
2544 ti.charFormat.anchorHref().toLatin1().constData());
2545 xprintf(">>\n>>\n");
2546 xprintf("endobj\n");
2547
2548 if (!currentPage->annotations.contains(annot)) {
2549 currentPage->annotations.append(annot);
2550 }
2551 }
2552
2553 QFontEngine *fe = ti.fontEngine;
2554
2555 QFontEngine::FaceId face_id = fe->faceId();
2556 bool noEmbed = false;
2557 if (!embedFonts
2558 || face_id.filename.isEmpty()
2559 || fe->fsType & 0x200 /* bitmap embedding only */
2560 || fe->fsType == 2 /* no embedding allowed */) {
2561 *currentPage << "Q\n";
2562 q->QPaintEngine::drawTextItem(p, ti);
2563 *currentPage << "q\n";
2564 if (face_id.filename.isEmpty())
2565 return;
2566 noEmbed = true;
2567 }
2568
2569 QFontSubset *font = fonts.value(face_id, 0);
2570 if (!font) {
2571 font = new QFontSubset(fe, requestObject());
2572 font->noEmbed = noEmbed;
2573 }
2574 fonts.insert(face_id, font);
2575
2576 if (!currentPage->fonts.contains(font->object_id))
2577 currentPage->fonts.append(font->object_id);
2578
2579 qreal size = ti.fontEngine->fontDef.pixelSize;
2580
2581 QVarLengthArray<glyph_t> glyphs;
2582 QVarLengthArray<QFixedPoint> positions;
2583 QTransform m = QTransform::fromTranslate(p.x(), p.y());
2584 ti.fontEngine->getGlyphPositions(ti.glyphs, m, ti.flags,
2585 glyphs, positions);
2586 if (glyphs.size() == 0)
2587 return;
2588 int synthesized = ti.fontEngine->synthesized();
2589 qreal stretch = synthesized & QFontEngine::SynthesizedStretch ? ti.fontEngine->fontDef.stretch/100. : 1.;
2590
2591 *currentPage << "BT\n"
2592 << "/F" << font->object_id << size << "Tf "
2593 << stretch << (synthesized & QFontEngine::SynthesizedItalic
2594 ? "0 .3 -1 0 0 Tm\n"
2595 : "0 0 -1 0 0 Tm\n");
2596
2597
2598 #if 0
2599 // #### implement actual text for complex languages
2600 const unsigned short *logClusters = ti.logClusters;
2601 int pos = 0;
2602 do {
2603 int end = pos + 1;
2604 while (end < ti.num_chars && logClusters[end] == logClusters[pos])
2605 ++end;
2606 *currentPage << "/Span << /ActualText <FEFF";
2607 for (int i = pos; i < end; ++i) {
2608 s << toHex((ushort)ti.chars[i].unicode(), buf);
2609 }
2610 *currentPage << "> >>\n"
2611 "BDC\n"
2612 "<";
2613 int ge = end == ti.num_chars ? ti.num_glyphs : logClusters[end];
2614 for (int gs = logClusters[pos]; gs < ge; ++gs)
2615 *currentPage << toHex((ushort)ti.glyphs[gs].glyph, buf);
2616 *currentPage << "> Tj\n"
2617 "EMC\n";
2618 pos = end;
2619 } while (pos < ti.num_chars);
2620 #else
2621 qreal last_x = 0.;
2622 qreal last_y = 0.;
2623 for (int i = 0; i < glyphs.size(); ++i) {
2624 qreal x = positions[i].x.toReal();
2625 qreal y = positions[i].y.toReal();
2626 if (synthesized & QFontEngine::SynthesizedItalic)
2627 x += .3*y;
2628 x /= stretch;
2629 char buf[5];
2630 int g = font->addGlyph(glyphs[i]);
2631 *currentPage << x - last_x << last_y - y << "Td <"
2632 << AdvancedPdf::toHex((ushort)g, buf) << "> Tj\n";
2633 last_x = x;
2634 last_y = y;
2635 }
2636 if (synthesized & QFontEngine::SynthesizedBold) {
2637 *currentPage << stretch << (synthesized & QFontEngine::SynthesizedItalic
2638 ? "0 .3 -1 0 0 Tm\n"
2639 : "0 0 -1 0 0 Tm\n");
2640 *currentPage << "/Span << /ActualText <> >> BDC\n";
2641 last_x = 0.5*fe->lineThickness().toReal();
2642 last_y = 0.;
2643 for (int i = 0; i < glyphs.size(); ++i) {
2644 qreal x = positions[i].x.toReal();
2645 qreal y = positions[i].y.toReal();
2646 if (synthesized & QFontEngine::SynthesizedItalic)
2647 x += .3*y;
2648 x /= stretch;
2649 char buf[5];
2650 int g = font->addGlyph(glyphs[i]);
2651 *currentPage << x - last_x << last_y - y << "Td <"
2652 << AdvancedPdf::toHex((ushort)g, buf) << "> Tj\n";
2653 last_x = x;
2654 last_y = y;
2655 }
2656 *currentPage << "EMC\n";
2657 }
2658 #endif
2659
2660 *currentPage << "ET\n";
2661 }
2662
pageMatrix() const2663 QTransform AdvancedPdfEnginePrivate::pageMatrix() const
2664 {
2665 qreal scale = 72./resolution;
2666 QTransform tmp(scale, 0.0, 0.0, -scale, 0.0, m_pageLayout.fullRectPoints().height());
2667 if (m_pageLayout.mode() != QPageLayout::FullPageMode) {
2668 QRect r = m_pageLayout.paintRectPixels(resolution);
2669 tmp.translate(r.left(), r.top());
2670 }
2671 return tmp;
2672 }
2673
newPage()2674 void AdvancedPdfEnginePrivate::newPage()
2675 {
2676 if (currentPage && currentPage->pageSize.isEmpty())
2677 currentPage->pageSize = m_pageLayout.fullRectPoints().size();
2678 writePage();
2679
2680 delete currentPage;
2681 currentPage = new AdvancedPdfPage;
2682 currentPage->pageSize = m_pageLayout.fullRectPoints().size();
2683 stroker.stream = currentPage;
2684 pages.append(requestObject());
2685
2686 *currentPage << "/GSa gs /CSp cs /CSp CS\n"
2687 << AdvancedPdf::generateMatrix(pageMatrix())
2688 << "q q\n";
2689 }
2690
2691 QT_END_NAMESPACE
2692
2693 #endif // QT_NO_PDF
2694