1 | /****************************************************************************
|
---|
2 | **
|
---|
3 | ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
---|
4 | ** All rights reserved.
|
---|
5 | ** Contact: Nokia Corporation (qt-info@nokia.com)
|
---|
6 | **
|
---|
7 | ** This file is part of the QtGui module of the Qt Toolkit.
|
---|
8 | **
|
---|
9 | ** $QT_BEGIN_LICENSE:LGPL$
|
---|
10 | ** Commercial Usage
|
---|
11 | ** Licensees holding valid Qt Commercial licenses may use this file in
|
---|
12 | ** accordance with the Qt Commercial License Agreement provided with the
|
---|
13 | ** Software or, alternatively, in accordance with the terms contained in
|
---|
14 | ** a written agreement between you and Nokia.
|
---|
15 | **
|
---|
16 | ** GNU Lesser General Public License Usage
|
---|
17 | ** Alternatively, this file may be used under the terms of the GNU Lesser
|
---|
18 | ** General Public License version 2.1 as published by the Free Software
|
---|
19 | ** Foundation and appearing in the file LICENSE.LGPL included in the
|
---|
20 | ** packaging of this file. Please review the following information to
|
---|
21 | ** ensure the GNU Lesser General Public License version 2.1 requirements
|
---|
22 | ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
---|
23 | **
|
---|
24 | ** In addition, as a special exception, Nokia gives you certain additional
|
---|
25 | ** rights. These rights are described in the Nokia Qt LGPL Exception
|
---|
26 | ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
---|
27 | **
|
---|
28 | ** GNU General Public License Usage
|
---|
29 | ** Alternatively, this file may be used under the terms of the GNU
|
---|
30 | ** General Public License version 3.0 as published by the Free Software
|
---|
31 | ** Foundation and appearing in the file LICENSE.GPL included in the
|
---|
32 | ** packaging of this file. Please review the following information to
|
---|
33 | ** ensure the GNU General Public License version 3.0 requirements will be
|
---|
34 | ** met: http://www.gnu.org/copyleft/gpl.html.
|
---|
35 | **
|
---|
36 | ** If you have questions regarding the use of this file, please contact
|
---|
37 | ** Nokia at qt-info@nokia.com.
|
---|
38 | ** $QT_END_LICENSE$
|
---|
39 | **
|
---|
40 | ****************************************************************************/
|
---|
41 |
|
---|
42 | #include "qplatformdefs.h"
|
---|
43 |
|
---|
44 | #include <private/qprintengine_ps_p.h>
|
---|
45 | #include <private/qpainter_p.h>
|
---|
46 | #include <private/qfontengine_p.h>
|
---|
47 | #include <private/qpaintengine_p.h>
|
---|
48 | #include <private/qpdf_p.h>
|
---|
49 |
|
---|
50 | #ifndef QT_NO_PRINTER
|
---|
51 |
|
---|
52 | #include "qprinter.h"
|
---|
53 | #include "qpainter.h"
|
---|
54 | #include "qapplication.h"
|
---|
55 | #include "qpixmap.h"
|
---|
56 | #include "qimage.h"
|
---|
57 | #include "qdatetime.h"
|
---|
58 | #include "qstring.h"
|
---|
59 | #include "qbytearray.h"
|
---|
60 | #include "qhash.h"
|
---|
61 | #include "qbuffer.h"
|
---|
62 | #include "qsettings.h"
|
---|
63 | #include "qmap.h"
|
---|
64 | #include "qbitmap.h"
|
---|
65 | #include "qregion.h"
|
---|
66 | #include "qimagewriter.h"
|
---|
67 | #include <private/qpainterpath_p.h>
|
---|
68 | #include <qdebug.h>
|
---|
69 | #include <private/qdrawhelper_p.h>
|
---|
70 | #include <private/qmutexpool_p.h>
|
---|
71 |
|
---|
72 | #ifndef Q_OS_WIN
|
---|
73 | #include <unistd.h>
|
---|
74 | #endif
|
---|
75 | #include <stdlib.h>
|
---|
76 | #include <limits.h>
|
---|
77 |
|
---|
78 | QT_BEGIN_NAMESPACE
|
---|
79 |
|
---|
80 | static bool qt_gen_epsf = false;
|
---|
81 |
|
---|
82 | void qt_generate_epsf(bool b)
|
---|
83 | {
|
---|
84 | qt_gen_epsf = b;
|
---|
85 | }
|
---|
86 |
|
---|
87 | static const char *const ps_header =
|
---|
88 | "/BD{bind def}bind def/d2{dup dup}BD/ED{exch def}BD/D0{0 ED}BD/F{setfont}BD\n"
|
---|
89 | "/RL{rlineto}BD/CM{currentmatrix}BD/SM{setmatrix}BD/TR{translate}BD/SD\n"
|
---|
90 | "{setdash}BD/SC{aload pop setrgbcolor}BD/CR{currentfile read pop}BD/i{index}\n"
|
---|
91 | "BD/scs{setcolorspace}BD/DB{dict dup begin}BD/DE{end def}BD/ie{ifelse}BD/gs\n"
|
---|
92 | "{gsave}BD/gr{grestore}BD/w{setlinewidth}BD/d{setdash}BD/J{setlinecap}BD/j\n"
|
---|
93 | "{setlinejoin}BD/scn{3 array astore/BCol exch def}BD/SCN{3 array astore/PCol\n"
|
---|
94 | "exch def}BD/cm{6 array astore concat}BD/m{moveto}BD/l{lineto}BD/c{curveto}BD\n"
|
---|
95 | "/h{closepath}BD/W{clip}BD/W*{eoclip}BD/n{newpath}BD/q{gsave 10 dict begin}BD\n"
|
---|
96 | "/Q{end grestore}BD/re{4 2 roll m dup 0 exch RL exch 0 RL 0 exch neg RL h}BD\n"
|
---|
97 | "/S{gs PCol SC stroke gr n}BD/BT{gsave 10 dict begin/_m matrix CM def BCol\n"
|
---|
98 | "SC}BD/ET{end grestore}BD/Tf{/_fs ED findfont[_fs 0 0 _fs 0 0]makefont F}BD\n"
|
---|
99 | "/Tm{6 array astore concat}BD/Td{translate}BD/Tj{0 0 m show}BD/BDC{pop pop}BD\n"
|
---|
100 | "/EMC{}BD/BSt 0 def/WFi false def/BCol[1 1 1]def/PCol[0 0 0]def/BDArr[0.94\n"
|
---|
101 | "0.88 0.63 0.50 0.37 0.12 0.06]def/level3{/languagelevel where{pop\n"
|
---|
102 | "languagelevel 3 ge}{false}ie}BD/QCIgray D0/QCIcolor D0/QCIindex D0/QCI{\n"
|
---|
103 | "/colorimage where{pop false 3 colorimage}{exec/QCIcolor ED/QCIgray QCIcolor\n"
|
---|
104 | "length 3 idiv string def 0 1 QCIcolor length 3 idiv 1 sub{/QCIindex ED/_x\n"
|
---|
105 | "QCIindex 3 mul def QCIgray QCIindex QCIcolor _x get 0.30 mul QCIcolor _x 1\n"
|
---|
106 | "add get 0.59 mul QCIcolor _x 2 add get 0.11 mul add add cvi put}for QCIgray\n"
|
---|
107 | "image}ie}BD/di{gs TR 1 i 1 eq{pop pop false 3 1 roll BCol SC imagemask}{dup\n"
|
---|
108 | "false ne{level3}{false}ie{/_ma ED 8 eq{/_dc[0 1]def/DeviceGray}{/_dc[0 1 0 1\n"
|
---|
109 | "0 1]def/DeviceRGB}ie scs/_im ED/_mt ED/_h ED/_w ED <</ImageType 3/DataDict\n"
|
---|
110 | "<</ImageType 1/Width _w/Height _h/ImageMatrix _mt/DataSource _im\n"
|
---|
111 | "/BitsPerComponent 8/Decode _dc >>/MaskDict <</ImageType 1/Width _w/Height _h\n"
|
---|
112 | "/ImageMatrix _mt/DataSource _ma/BitsPerComponent 1/Decode[0 1]>>\n"
|
---|
113 | "/InterleaveType 3 >> image}{pop 8 4 1 roll 8 eq{image}{QCI}ie}ie}ie gr}BD/BF\n"
|
---|
114 | "{gs BSt 1 eq{BCol SC WFi{fill}{eofill}ie}if BSt 2 ge BSt 8 le and{BDArr BSt\n"
|
---|
115 | "2 sub get/_sc ED BCol{1. exch sub _sc mul 1. exch sub}forall 3 array astore\n"
|
---|
116 | "SC WFi{fill}{eofill}ie}if BSt 9 ge BSt 14 le and{WFi{W}{W*}ie pathbbox 3 i 3\n"
|
---|
117 | "i TR 4 2 roll 3 2 roll exch sub/_h ED sub/_w ED BCol SC 0.3 w n BSt 9 eq BSt\n"
|
---|
118 | "11 eq or{0 4 _h{dup 0 exch m _w exch l}for}if BSt 10 eq BSt 11 eq or{0 4 _w{\n"
|
---|
119 | "dup 0 m _h l}for}if BSt 12 eq BSt 14 eq or{_w _h gt{0 6 _w _h add{dup 0 m _h\n"
|
---|
120 | "sub _h l}for}{0 6 _w _h add{dup 0 exch m _w sub _w exch l}for}ie}if BSt 13\n"
|
---|
121 | "eq BSt 14 eq or{_w _h gt{0 6 _w _h add{dup _h m _h sub 0 l}for}{0 6 _w _h\n"
|
---|
122 | "add{dup _w exch m _w sub 0 exch l}for}ie}if stroke}if BSt 15 eq{}if BSt 24\n"
|
---|
123 | "eq{}if gr}BD/f{/WFi true def BF n}BD/f*{/WFi false def BF n}BD/B{/WFi true\n"
|
---|
124 | "def BF S n}BD/B*{/WFi false def BF S n}BD/QI{/C save def pageinit q n}BD/QP{\n"
|
---|
125 | "Q C restore showpage}BD/SPD{/setpagedevice where{<< 3 1 roll >>\n"
|
---|
126 | "setpagedevice}{pop pop}ie}BD/T1AddMapping{10 dict begin/glyphs ED/fnt ED\n"
|
---|
127 | "/current fnt/NumGlyphs get def/CMap fnt/CMap get def 0 1 glyphs length 1 sub\n"
|
---|
128 | "{glyphs exch get/gn ED current dup 256 mod/min ED 256 idiv/maj ED CMap dup\n"
|
---|
129 | "maj get dup null eq{pop 256 array 0 1 255{1 i exch/.notdef put}for}if dup\n"
|
---|
130 | "min gn put maj exch put/current current 1 add def}for fnt/CMap CMap put fnt\n"
|
---|
131 | "/NumGlyphs current put end}def/T1AddGlyphs{10 dict begin/glyphs ED/fnt ED\n"
|
---|
132 | "/current fnt/NumGlyphs get def/CMap fnt/CMap get def/CharStrings fnt\n"
|
---|
133 | "/CharStrings get def 0 1 glyphs length 2 idiv 1 sub{2 mul dup glyphs exch\n"
|
---|
134 | "get/gn ED 1 add glyphs exch get/cs ED current dup 256 mod/min ED 256 idiv\n"
|
---|
135 | "/maj ED CMap dup maj get dup null eq{pop 256 array 0 1 255{1 i exch/.notdef\n"
|
---|
136 | "put}for}if dup min gn put maj exch put CharStrings gn cs put/current current\n"
|
---|
137 | "1 add def}for fnt/CharStrings CharStrings put fnt/CMap CMap put fnt\n"
|
---|
138 | "/NumGlyphs current put end}def/StringAdd{1 i length 1 i length add string 3\n"
|
---|
139 | "1 roll 2 i 0 3 i putinterval 2 i 2 i length 2 i putinterval pop pop}def\n"
|
---|
140 | "/T1Setup{10 dict begin dup/FontName ED (-Base) StringAdd cvx cvn/Font ED\n"
|
---|
141 | "/MaxPage Font/NumGlyphs get 1 sub 256 idiv def/FDepVector MaxPage 1 add\n"
|
---|
142 | "array def/Encoding MaxPage 1 add array def 0 1 MaxPage{dup Encoding exch dup\n"
|
---|
143 | "put dup/Page ED FontName (-) StringAdd exch 20 string cvs StringAdd cvn Font\n"
|
---|
144 | "0 dict copy d2/CMap get Page get/Encoding exch put definefont FDepVector\n"
|
---|
145 | "exch Page exch put}for FontName cvn <</FontType 0/FMapType 2/FontMatrix[1 0\n"
|
---|
146 | "0 1 0 0]/Encoding Encoding/FDepVector FDepVector >> definefont pop end}def\n";
|
---|
147 |
|
---|
148 |
|
---|
149 |
|
---|
150 | // ------------------------------End of static data ----------------------------------
|
---|
151 |
|
---|
152 | // make sure DSC comments are not longer than 255 chars per line.
|
---|
153 | static QByteArray wrapDSC(const QByteArray &str)
|
---|
154 | {
|
---|
155 | QByteArray dsc = str.simplified();
|
---|
156 | const int wrapAt = 254;
|
---|
157 | QByteArray wrapped;
|
---|
158 | if (dsc.length() < wrapAt)
|
---|
159 | wrapped = dsc;
|
---|
160 | else {
|
---|
161 | wrapped = dsc.left(wrapAt);
|
---|
162 | QByteArray tmp = dsc.mid(wrapAt);
|
---|
163 | while (tmp.length() > wrapAt-3) {
|
---|
164 | wrapped += "\n%%+" + tmp.left(wrapAt-3);
|
---|
165 | tmp = tmp.mid(wrapAt-3);
|
---|
166 | }
|
---|
167 | wrapped += "\n%%+" + tmp;
|
---|
168 | }
|
---|
169 | return wrapped + '\n';
|
---|
170 | }
|
---|
171 |
|
---|
172 | // ----------------------------- Internal class declarations -----------------------------
|
---|
173 |
|
---|
174 | QPSPrintEnginePrivate::QPSPrintEnginePrivate(QPrinter::PrinterMode m)
|
---|
175 | : QPdfBaseEnginePrivate(m),
|
---|
176 | printerState(QPrinter::Idle), hugeDocument(false), headerDone(false)
|
---|
177 | {
|
---|
178 | useAlphaEngine = true;
|
---|
179 | postscript = true;
|
---|
180 |
|
---|
181 | firstPage = true;
|
---|
182 |
|
---|
183 | #ifndef QT_NO_SETTINGS
|
---|
184 | QSettings settings(QSettings::UserScope, QLatin1String("Trolltech"));
|
---|
185 | settings.beginGroup(QLatin1String("Qt"));
|
---|
186 | embedFonts = settings.value(QLatin1String("embedFonts"), true).toBool();
|
---|
187 | #else
|
---|
188 | embedFonts = true;
|
---|
189 | #endif
|
---|
190 | }
|
---|
191 |
|
---|
192 | QPSPrintEnginePrivate::~QPSPrintEnginePrivate()
|
---|
193 | {
|
---|
194 | }
|
---|
195 |
|
---|
196 | QT_BEGIN_INCLUDE_NAMESPACE
|
---|
197 | #include <qdebug.h>
|
---|
198 | QT_END_INCLUDE_NAMESPACE
|
---|
199 |
|
---|
200 | static void ps_r7(QPdf::ByteStream& stream, const char * s, int l)
|
---|
201 | {
|
---|
202 | int i = 0;
|
---|
203 | uchar line[84];
|
---|
204 | int col = 0;
|
---|
205 |
|
---|
206 | while(i < l) {
|
---|
207 | line[col++] = s[i++];
|
---|
208 | if (i < l - 1 && col >= 76) {
|
---|
209 | line[col++] = '\n';
|
---|
210 | line[col++] = '\0';
|
---|
211 | stream << (const char *)line;
|
---|
212 | col = 0;
|
---|
213 | }
|
---|
214 | }
|
---|
215 | if (col > 0) {
|
---|
216 | while((col&3) != 0)
|
---|
217 | line[col++] = '%'; // use a comment as padding
|
---|
218 | line[col++] = '\n';
|
---|
219 | line[col++] = '\0';
|
---|
220 | stream << (const char *)line;
|
---|
221 | }
|
---|
222 | }
|
---|
223 |
|
---|
224 | static QByteArray runlengthEncode(const QByteArray &input)
|
---|
225 | {
|
---|
226 | if (!input.length())
|
---|
227 | return input;
|
---|
228 |
|
---|
229 | const char *data = input.constData();
|
---|
230 |
|
---|
231 | QByteArray out;
|
---|
232 | int start = 0;
|
---|
233 | char last = *data;
|
---|
234 |
|
---|
235 | enum State {
|
---|
236 | Undef,
|
---|
237 | Equal,
|
---|
238 | Diff
|
---|
239 | };
|
---|
240 | State state = Undef;
|
---|
241 |
|
---|
242 | int i = 1;
|
---|
243 | int written = 0;
|
---|
244 | while (1) {
|
---|
245 | bool flush = (i == input.size());
|
---|
246 | if (!flush) {
|
---|
247 | switch(state) {
|
---|
248 | case Undef:
|
---|
249 | state = (last == data[i]) ? Equal : Diff;
|
---|
250 | break;
|
---|
251 | case Equal:
|
---|
252 | if (data[i] != last)
|
---|
253 | flush = true;
|
---|
254 | break;
|
---|
255 | case Diff:
|
---|
256 | if (data[i] == last) {
|
---|
257 | --i;
|
---|
258 | flush = true;
|
---|
259 | }
|
---|
260 | }
|
---|
261 | }
|
---|
262 | if (flush || i - start == 128) {
|
---|
263 | int size = i - start;
|
---|
264 | if (state == Equal) {
|
---|
265 | out.append((char)(uchar)(257-size));
|
---|
266 | out.append(last);
|
---|
267 | written += size;
|
---|
268 | } else {
|
---|
269 | out.append((char)(uchar)size-1);
|
---|
270 | while (start < i)
|
---|
271 | out.append(data[start++]);
|
---|
272 | written += size;
|
---|
273 | }
|
---|
274 | state = Undef;
|
---|
275 | start = i;
|
---|
276 | if (i == input.size())
|
---|
277 | break;
|
---|
278 | }
|
---|
279 | last = data[i];
|
---|
280 | ++i;
|
---|
281 | };
|
---|
282 | out.append((char)(uchar)128);
|
---|
283 | return out;
|
---|
284 | }
|
---|
285 |
|
---|
286 | enum format {
|
---|
287 | Raw,
|
---|
288 | Runlength,
|
---|
289 | DCT
|
---|
290 | };
|
---|
291 | static const char *const filters[3] = {
|
---|
292 | " ",
|
---|
293 | "/RunLengthDecode filter ",
|
---|
294 | "/DCTDecode filter "
|
---|
295 | };
|
---|
296 |
|
---|
297 | static QByteArray compressHelper(const QImage &image, bool gray, int *format)
|
---|
298 | {
|
---|
299 | // we can't use premultiplied here
|
---|
300 | QByteArray pixelData;
|
---|
301 | int depth = image.depth();
|
---|
302 |
|
---|
303 | Q_ASSERT(image.format() != QImage::Format_ARGB32_Premultiplied);
|
---|
304 |
|
---|
305 | if (depth != 1 && !gray && QImageWriter::supportedImageFormats().contains("jpeg")) {
|
---|
306 | QBuffer buffer(&pixelData);
|
---|
307 | QImageWriter writer(&buffer, "jpeg");
|
---|
308 | writer.setQuality(94);
|
---|
309 | writer.write(image);
|
---|
310 | *format = DCT;
|
---|
311 | } else {
|
---|
312 | int width = image.width();
|
---|
313 | int height = image.height();
|
---|
314 | int size = width*height;
|
---|
315 |
|
---|
316 | if (depth == 1)
|
---|
317 | size = (width+7)/8*height;
|
---|
318 | else if (!gray)
|
---|
319 | size = size*3;
|
---|
320 |
|
---|
321 | pixelData.resize(size);
|
---|
322 | uchar *pixel = (uchar *)pixelData.data();
|
---|
323 | int i = 0;
|
---|
324 | if (depth == 1) {
|
---|
325 | QImage::Format format = image.format();
|
---|
326 | memset(pixel, 0xff, size);
|
---|
327 | for(int y=0; y < height; y++) {
|
---|
328 | const uchar * s = image.scanLine(y);
|
---|
329 | for(int x=0; x < width; x++) {
|
---|
330 | // need to copy bit for bit...
|
---|
331 | bool b = (format == QImage::Format_MonoLSB) ?
|
---|
332 | (*(s + (x >> 3)) >> (x & 7)) & 1 :
|
---|
333 | (*(s + (x >> 3)) << (x & 7)) & 0x80 ;
|
---|
334 | if (b)
|
---|
335 | pixel[i >> 3] ^= (0x80 >> (i & 7));
|
---|
336 | i++;
|
---|
337 | }
|
---|
338 | // we need to align to 8 bit here
|
---|
339 | i = (i+7) & 0xffffff8;
|
---|
340 | }
|
---|
341 | } else if (depth == 8) {
|
---|
342 | for(int y=0; y < height; y++) {
|
---|
343 | const uchar * s = image.scanLine(y);
|
---|
344 | for(int x=0; x < width; x++) {
|
---|
345 | QRgb rgb = image.color(s[x]);
|
---|
346 | if (gray) {
|
---|
347 | pixel[i] = (unsigned char) qGray(rgb);
|
---|
348 | i++;
|
---|
349 | } else {
|
---|
350 | pixel[i] = (unsigned char) qRed(rgb);
|
---|
351 | pixel[i+1] = (unsigned char) qGreen(rgb);
|
---|
352 | pixel[i+2] = (unsigned char) qBlue(rgb);
|
---|
353 | i += 3;
|
---|
354 | }
|
---|
355 | }
|
---|
356 | }
|
---|
357 | } else {
|
---|
358 | for(int y=0; y < height; y++) {
|
---|
359 | QRgb * s = (QRgb*)(image.scanLine(y));
|
---|
360 | for(int x=0; x < width; x++) {
|
---|
361 | QRgb rgb = (*s++);
|
---|
362 | if (gray) {
|
---|
363 | pixel[i] = (unsigned char) qGray(rgb);
|
---|
364 | i++;
|
---|
365 | } else {
|
---|
366 | pixel[i] = (unsigned char) qRed(rgb);
|
---|
367 | pixel[i+1] = (unsigned char) qGreen(rgb);
|
---|
368 | pixel[i+2] = (unsigned char) qBlue(rgb);
|
---|
369 | i += 3;
|
---|
370 | }
|
---|
371 | }
|
---|
372 | }
|
---|
373 | }
|
---|
374 | *format = Raw;
|
---|
375 | if (depth == 1) {
|
---|
376 | pixelData = runlengthEncode(pixelData);
|
---|
377 | *format = Runlength;
|
---|
378 | }
|
---|
379 | }
|
---|
380 | QByteArray outarr = QPdf::ascii85Encode(pixelData);
|
---|
381 | return outarr;
|
---|
382 | }
|
---|
383 |
|
---|
384 | void QPSPrintEnginePrivate::drawImageHelper(qreal x, qreal y, qreal w, qreal h, const QImage &img,
|
---|
385 | const QImage &mask, bool gray, qreal scaleX, qreal scaleY)
|
---|
386 | {
|
---|
387 | Q_UNUSED(h);
|
---|
388 | Q_UNUSED(w);
|
---|
389 | int width = img.width();
|
---|
390 | int height = img.height();
|
---|
391 |
|
---|
392 | QByteArray out;
|
---|
393 | int size = 0;
|
---|
394 | const char *bits;
|
---|
395 |
|
---|
396 | if (!mask.isNull()) {
|
---|
397 | int format;
|
---|
398 | out = compressHelper(mask, true, &format);
|
---|
399 | size = (width+7)/8*height;
|
---|
400 | *currentPage << "/mask currentfile/ASCII85Decode filter"
|
---|
401 | << filters[format]
|
---|
402 | << size << " string readstring\n";
|
---|
403 | ps_r7(*currentPage, out, out.size());
|
---|
404 | *currentPage << " pop def\n";
|
---|
405 | }
|
---|
406 | if (img.depth() == 1) {
|
---|
407 | size = (width+7)/8*height;
|
---|
408 | bits = "1 ";
|
---|
409 | } else if (gray) {
|
---|
410 | size = width*height;
|
---|
411 | bits = "8 ";
|
---|
412 | } else {
|
---|
413 | size = width*height*3;
|
---|
414 | bits = "24 ";
|
---|
415 | }
|
---|
416 |
|
---|
417 | int format;
|
---|
418 | out = compressHelper(img, gray, &format);
|
---|
419 | *currentPage << "/sl currentfile/ASCII85Decode filter"
|
---|
420 | << filters[format]
|
---|
421 | << size << " string readstring\n";
|
---|
422 | ps_r7(*currentPage, out, out.size());
|
---|
423 | *currentPage << " pop def\n";
|
---|
424 | *currentPage << width << ' ' << height << '[' << scaleX << " 0 0 " << scaleY << " 0 0]sl "
|
---|
425 | << bits << (!mask.isNull() ? "mask " : "false ")
|
---|
426 | << x << ' ' << y << " di\n";
|
---|
427 | }
|
---|
428 |
|
---|
429 |
|
---|
430 | void QPSPrintEnginePrivate::drawImage(qreal x, qreal y, qreal w, qreal h,
|
---|
431 | const QImage &image, const QImage &msk)
|
---|
432 | {
|
---|
433 | if (!w || !h || image.isNull()) return;
|
---|
434 |
|
---|
435 | QImage img(image);
|
---|
436 | QImage mask(msk);
|
---|
437 |
|
---|
438 | if (image.format() == QImage::Format_ARGB32_Premultiplied)
|
---|
439 | img = image.convertToFormat(QImage::Format_ARGB32);
|
---|
440 |
|
---|
441 | if (!msk.isNull() && msk.format() == QImage::Format_ARGB32_Premultiplied)
|
---|
442 | mask = msk.convertToFormat(QImage::Format_ARGB32);
|
---|
443 |
|
---|
444 | int width = img.width();
|
---|
445 | int height = img.height();
|
---|
446 | qreal scaleX = width/w;
|
---|
447 | qreal scaleY = height/h;
|
---|
448 |
|
---|
449 | bool gray = (colorMode == QPrinter::GrayScale) || img.allGray();
|
---|
450 | int splitSize = 21830 * (gray ? 3 : 1);
|
---|
451 | if (width * height > splitSize) { // 65535/3, tolerance for broken printers
|
---|
452 | int images, subheight;
|
---|
453 | images = (width * height + splitSize - 1) / splitSize;
|
---|
454 | subheight = (height + images-1) / images;
|
---|
455 | while (subheight * width > splitSize) {
|
---|
456 | images++;
|
---|
457 | subheight = (height + images-1) / images;
|
---|
458 | }
|
---|
459 | int suby = 0;
|
---|
460 | const QImage constImg(img);
|
---|
461 | const QImage constMask(mask);
|
---|
462 | while(suby < height) {
|
---|
463 | qreal subImageHeight = qMin(subheight, height-suby);
|
---|
464 | const QImage subImage(constImg.scanLine(suby), width, subImageHeight,
|
---|
465 | constImg.bytesPerLine(), constImg.format());
|
---|
466 | const QImage subMask = mask.isNull() ? mask : QImage(constMask.scanLine(suby), width, subImageHeight,
|
---|
467 | constMask.bytesPerLine(), constMask.format());
|
---|
468 | drawImageHelper(x, y + suby/scaleY, w, subImageHeight/scaleY,
|
---|
469 | subImage, subMask, gray, scaleX, scaleY);
|
---|
470 | suby += subheight;
|
---|
471 | }
|
---|
472 | } else {
|
---|
473 | drawImageHelper(x, y, width, height, img, mask, gray, scaleX, scaleY);
|
---|
474 | }
|
---|
475 | }
|
---|
476 |
|
---|
477 | void QPSPrintEnginePrivate::emitHeader(bool finished)
|
---|
478 | {
|
---|
479 | QPSPrintEngine *q = static_cast<QPSPrintEngine *>(q_ptr);
|
---|
480 | QPrinter *printer = static_cast<QPrinter*>(pdev);
|
---|
481 |
|
---|
482 | if (creator.isEmpty())
|
---|
483 | creator = QLatin1String("Qt " QT_VERSION_STR);
|
---|
484 |
|
---|
485 | QByteArray header;
|
---|
486 | QPdf::ByteStream s(&header);
|
---|
487 |
|
---|
488 | qreal scale = 72. / ((qreal) q->metric(QPaintDevice::PdmDpiY));
|
---|
489 | QRect pageRect = this->pageRect();
|
---|
490 | QRect paperRect = this->paperRect();
|
---|
491 | int mtop = pageRect.top() - paperRect.top();
|
---|
492 | int mleft = pageRect.left() - paperRect.left();
|
---|
493 | int mbottom = paperRect.bottom() - pageRect.bottom();
|
---|
494 | int mright = paperRect.right() - pageRect.right();
|
---|
495 | int width = pageRect.width();
|
---|
496 | int height = pageRect.height();
|
---|
497 | if (finished && pageCount == 1 && copies == 1 &&
|
---|
498 | ((fullPage && qt_gen_epsf) || (outputFileName.endsWith(QLatin1String(".eps")))))
|
---|
499 | {
|
---|
500 | // According to the EPSF 3.0 spec it is required that the PS
|
---|
501 | // version is PS-Adobe-3.0
|
---|
502 | s << "%!PS-Adobe-3.0";
|
---|
503 | if (!boundingBox.isValid())
|
---|
504 | boundingBox.setRect(0, 0, width, height);
|
---|
505 | if (orientation == QPrinter::Landscape) {
|
---|
506 | if (!fullPage)
|
---|
507 | boundingBox.translate(-mleft, -mtop);
|
---|
508 | s << " EPSF-3.0\n%%BoundingBox: "
|
---|
509 | << int((printer->height() - boundingBox.bottom())*scale) // llx
|
---|
510 | << int((printer->width() - boundingBox.right())*scale - 1) // lly
|
---|
511 | << int((printer->height() - boundingBox.top())*scale + 1) // urx
|
---|
512 | << int((printer->width() - boundingBox.left())*scale); // ury
|
---|
513 | } else {
|
---|
514 | if (!fullPage)
|
---|
515 | boundingBox.translate(mleft, -mtop);
|
---|
516 | s << " EPSF-3.0\n%%BoundingBox: "
|
---|
517 | << int((boundingBox.left())*scale)
|
---|
518 | << int((printer->height() - boundingBox.bottom())*scale - 1)
|
---|
519 | << int((boundingBox.right())*scale + 1)
|
---|
520 | << int((printer->height() - boundingBox.top())*scale);
|
---|
521 | }
|
---|
522 | } else {
|
---|
523 | s << "%!PS-Adobe-1.0";
|
---|
524 | int w = width + (fullPage ? 0 : mleft + mright);
|
---|
525 | int h = height + (fullPage ? 0 : mtop + mbottom);
|
---|
526 | w = (int)(w*scale);
|
---|
527 | h = (int)(h*scale);
|
---|
528 | // set a bounding box according to the DSC
|
---|
529 | if (orientation == QPrinter::Landscape)
|
---|
530 | s << "\n%%BoundingBox: 0 0 " << h << w;
|
---|
531 | else
|
---|
532 | s << "\n%%BoundingBox: 0 0 " << w << h;
|
---|
533 | }
|
---|
534 | s << '\n' << wrapDSC("%%Creator: " + creator.toUtf8());
|
---|
535 | if (!title.isEmpty())
|
---|
536 | s << wrapDSC("%%Title: " + title.toUtf8());
|
---|
537 | #ifndef QT_NO_DATESTRING
|
---|
538 | s << "%%CreationDate: " << QDateTime::currentDateTime().toString().toUtf8();
|
---|
539 | #endif
|
---|
540 | s << "\n%%Orientation: ";
|
---|
541 | if (orientation == QPrinter::Landscape)
|
---|
542 | s << "Landscape";
|
---|
543 | else
|
---|
544 | s << "Portrait";
|
---|
545 |
|
---|
546 | s << "\n%%Pages: (atend)"
|
---|
547 | "\n%%DocumentFonts: (atend)"
|
---|
548 | "\n%%EndComments\n"
|
---|
549 |
|
---|
550 | "%%BeginProlog\n"
|
---|
551 | "% Prolog copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).\n"
|
---|
552 | "% You may copy this prolog in any way that is directly related to this document.\n"
|
---|
553 | "% For other use of this prolog, see your licensing agreement for Qt.\n"
|
---|
554 | << ps_header << '\n';
|
---|
555 |
|
---|
556 |
|
---|
557 | s << "/pageinit {\n";
|
---|
558 | if (!fullPage) {
|
---|
559 | if (orientation == QPrinter::Portrait)
|
---|
560 | s << mleft*scale << mbottom*scale << "translate\n";
|
---|
561 | else
|
---|
562 | s << mtop*scale << mleft*scale << "translate\n";
|
---|
563 | }
|
---|
564 | if (orientation == QPrinter::Portrait) {
|
---|
565 | s << "% " << printer->widthMM() << '*' << printer->heightMM()
|
---|
566 | << "mm (portrait)\n0 " << height*scale
|
---|
567 | << "translate " << scale << '-' << scale << "scale } def\n";
|
---|
568 | } else {
|
---|
569 | s << "% " << printer->heightMM() << '*' << printer->widthMM()
|
---|
570 | << " mm (landscape)\n 90 rotate " << scale << '-' << scale << "scale } def\n";
|
---|
571 | }
|
---|
572 | s << "%%EndProlog\n";
|
---|
573 |
|
---|
574 | outDevice->write(header);
|
---|
575 | headerDone = true;
|
---|
576 | }
|
---|
577 |
|
---|
578 |
|
---|
579 | void QPSPrintEnginePrivate::emitPages()
|
---|
580 | {
|
---|
581 | if (!hugeDocument) {
|
---|
582 | for (QHash<QFontEngine::FaceId, QFontSubset *>::const_iterator it = fonts.constBegin();
|
---|
583 | it != fonts.constEnd(); ++it)
|
---|
584 | outDevice->write((*it)->toType1());
|
---|
585 | }
|
---|
586 |
|
---|
587 | QIODevice *content = buffer.stream();
|
---|
588 | // Write the page contents in chunks.
|
---|
589 | while (!content->atEnd()) {
|
---|
590 | QByteArray buf = content->read(currentPage->chunkSize());
|
---|
591 | if (!buf.isEmpty())
|
---|
592 | outDevice->write(buf);
|
---|
593 | }
|
---|
594 | content = currentPage->stream();
|
---|
595 | // Write the page contents in chunks.
|
---|
596 | while (!content->atEnd()) {
|
---|
597 | QByteArray buf = content->read(currentPage->chunkSize());
|
---|
598 | if (!buf.isEmpty())
|
---|
599 | outDevice->write(buf);
|
---|
600 | }
|
---|
601 | outDevice->write(trailer);
|
---|
602 |
|
---|
603 | buffer.clear();
|
---|
604 | currentPage->clear();
|
---|
605 | trailer = QByteArray();
|
---|
606 | hugeDocument = true;
|
---|
607 | }
|
---|
608 |
|
---|
609 |
|
---|
610 | #ifdef Q_WS_QWS
|
---|
611 | static const int max_in_memory_size = 2000000;
|
---|
612 | #else
|
---|
613 | static const int max_in_memory_size = 32000000;
|
---|
614 | #endif
|
---|
615 |
|
---|
616 | void QPSPrintEnginePrivate::flushPage(bool last)
|
---|
617 | {
|
---|
618 | if (!last && currentPage->stream()->size() == 0)
|
---|
619 | return;
|
---|
620 |
|
---|
621 | QPdf::ByteStream e(&trailer);
|
---|
622 | buffer << "%%Page: "
|
---|
623 | << pageCount << pageCount << "\n"
|
---|
624 | "%%BeginPageSetup\n"
|
---|
625 | "QI\n";
|
---|
626 | if (hugeDocument) {
|
---|
627 | for (QHash<QFontEngine::FaceId, QFontSubset *>::const_iterator it = fonts.constBegin();
|
---|
628 | it != fonts.constEnd(); ++it) {
|
---|
629 | if (currentPage->fonts.contains((*it)->object_id)) {
|
---|
630 | if ((*it)->downloaded_glyphs == 0) {
|
---|
631 | buffer << (*it)->toType1();
|
---|
632 | (*it)->downloaded_glyphs = 0;
|
---|
633 | } else {
|
---|
634 | buffer << (*it)->type1AddedGlyphs();
|
---|
635 | }
|
---|
636 | }
|
---|
637 | }
|
---|
638 | }
|
---|
639 | for (int i = 0; i < currentPage->fonts.size(); ++i)
|
---|
640 | buffer << "(F" << QByteArray::number(currentPage->fonts.at(i)) << ") T1Setup\n";
|
---|
641 |
|
---|
642 | buffer << "%%EndPageSetup\nq\n";
|
---|
643 | e << "\nQ QP\n";
|
---|
644 | if (last || hugeDocument
|
---|
645 | || buffer.stream()->size() + currentPage->stream()->size() > max_in_memory_size) {
|
---|
646 | // qDebug("emiting header at page %d", pageCount);
|
---|
647 | if (!headerDone)
|
---|
648 | emitHeader(last);
|
---|
649 | emitPages();
|
---|
650 | } else {
|
---|
651 | buffer << *currentPage << e;
|
---|
652 | currentPage->clear();
|
---|
653 | trailer.clear();
|
---|
654 | }
|
---|
655 | pageCount++;
|
---|
656 | }
|
---|
657 |
|
---|
658 | // ================ PSPrinter class ========================
|
---|
659 |
|
---|
660 | QPSPrintEngine::QPSPrintEngine(QPrinter::PrinterMode m)
|
---|
661 | : QPdfBaseEngine(*(new QPSPrintEnginePrivate(m)),
|
---|
662 | PrimitiveTransform
|
---|
663 | | PatternTransform
|
---|
664 | | PixmapTransform
|
---|
665 | | PainterPaths
|
---|
666 | | PatternBrush
|
---|
667 | )
|
---|
668 | {
|
---|
669 | }
|
---|
670 |
|
---|
671 | static void ignoreSigPipe(bool b)
|
---|
672 | {
|
---|
673 | #ifndef QT_NO_LPR
|
---|
674 | static struct sigaction *users_sigpipe_handler = 0;
|
---|
675 | static int lockCount = 0;
|
---|
676 |
|
---|
677 | #ifndef QT_NO_THREAD
|
---|
678 | QMutexLocker locker(QMutexPool::globalInstanceGet(&users_sigpipe_handler));
|
---|
679 | #endif
|
---|
680 |
|
---|
681 | if (b) {
|
---|
682 | if (lockCount++ > 0)
|
---|
683 | return;
|
---|
684 |
|
---|
685 | if (users_sigpipe_handler != 0)
|
---|
686 | return; // already ignoring sigpipe
|
---|
687 |
|
---|
688 | users_sigpipe_handler = new struct sigaction;
|
---|
689 | struct sigaction tmp_sigpipe_handler;
|
---|
690 | tmp_sigpipe_handler.sa_handler = SIG_IGN;
|
---|
691 | sigemptyset(&tmp_sigpipe_handler.sa_mask);
|
---|
692 | tmp_sigpipe_handler.sa_flags = 0;
|
---|
693 |
|
---|
694 | if (sigaction(SIGPIPE, &tmp_sigpipe_handler, users_sigpipe_handler) == -1) {
|
---|
695 | delete users_sigpipe_handler;
|
---|
696 | users_sigpipe_handler = 0;
|
---|
697 | }
|
---|
698 | }
|
---|
699 | else {
|
---|
700 | if (--lockCount > 0)
|
---|
701 | return;
|
---|
702 |
|
---|
703 | if (users_sigpipe_handler == 0)
|
---|
704 | return; // not ignoring sigpipe
|
---|
705 |
|
---|
706 | if (sigaction(SIGPIPE, users_sigpipe_handler, 0) == -1)
|
---|
707 | qWarning("QPSPrintEngine: Could not restore SIGPIPE handler");
|
---|
708 |
|
---|
709 | delete users_sigpipe_handler;
|
---|
710 | users_sigpipe_handler = 0;
|
---|
711 | }
|
---|
712 | #else
|
---|
713 | Q_UNUSED(b);
|
---|
714 | #endif
|
---|
715 | }
|
---|
716 | QPSPrintEngine::~QPSPrintEngine()
|
---|
717 | {
|
---|
718 | Q_D(QPSPrintEngine);
|
---|
719 | if (d->fd >= 0)
|
---|
720 | #if defined(Q_OS_WIN) && defined(_MSC_VER) && _MSC_VER >= 1400
|
---|
721 | ::_close(d->fd);
|
---|
722 | #else
|
---|
723 | ::close(d->fd);
|
---|
724 | #endif
|
---|
725 | }
|
---|
726 |
|
---|
727 | bool QPSPrintEngine::begin(QPaintDevice *pdev)
|
---|
728 | {
|
---|
729 | Q_D(QPSPrintEngine);
|
---|
730 |
|
---|
731 | if (d->fd >= 0)
|
---|
732 | return true;
|
---|
733 |
|
---|
734 | if (d->useAlphaEngine) {
|
---|
735 | QAlphaPaintEngine::begin(pdev);
|
---|
736 | if (!continueCall())
|
---|
737 | return true;
|
---|
738 | }
|
---|
739 |
|
---|
740 | if(!QPdfBaseEngine::begin(pdev)) {
|
---|
741 | d->printerState = QPrinter::Error;
|
---|
742 | return false;
|
---|
743 | }
|
---|
744 |
|
---|
745 | d->pageCount = 1; // initialize state
|
---|
746 |
|
---|
747 | d->pen = QPen(Qt::black);
|
---|
748 | d->brush = Qt::NoBrush;
|
---|
749 | d->hasPen = true;
|
---|
750 | d->hasBrush = false;
|
---|
751 | d->clipEnabled = false;
|
---|
752 | d->allClipped = false;
|
---|
753 | d->boundingBox = QRect();
|
---|
754 | d->fontsUsed = "";
|
---|
755 | d->hugeDocument = false;
|
---|
756 | d->simplePen = false;
|
---|
757 |
|
---|
758 | setActive(true);
|
---|
759 | d->printerState = QPrinter::Active;
|
---|
760 |
|
---|
761 | newPage();
|
---|
762 |
|
---|
763 | return true;
|
---|
764 | }
|
---|
765 |
|
---|
766 | bool QPSPrintEngine::end()
|
---|
767 | {
|
---|
768 | Q_D(QPSPrintEngine);
|
---|
769 |
|
---|
770 | if (d->useAlphaEngine) {
|
---|
771 | QAlphaPaintEngine::end();
|
---|
772 | if (!continueCall())
|
---|
773 | return true;
|
---|
774 | }
|
---|
775 |
|
---|
776 | // we're writing to lp/lpr through a pipe, we don't want to crash with SIGPIPE
|
---|
777 | // if lp/lpr dies
|
---|
778 | ignoreSigPipe(true);
|
---|
779 | d->flushPage(true);
|
---|
780 | QByteArray trailer;
|
---|
781 | QPdf::ByteStream s(&trailer);
|
---|
782 | s << "%%Trailer\n"
|
---|
783 | "%%Pages: " << d->pageCount - 1 << '\n' <<
|
---|
784 | wrapDSC("%%DocumentFonts: " + d->fontsUsed);
|
---|
785 | s << "%%EOF\n";
|
---|
786 | d->outDevice->write(trailer);
|
---|
787 |
|
---|
788 | QPdfBaseEngine::end();
|
---|
789 | ignoreSigPipe(false);
|
---|
790 |
|
---|
791 | d->firstPage = true;
|
---|
792 | d->headerDone = false;
|
---|
793 |
|
---|
794 | setActive(false);
|
---|
795 | d->printerState = QPrinter::Idle;
|
---|
796 | d->pdev = 0;
|
---|
797 |
|
---|
798 | return true;
|
---|
799 | }
|
---|
800 |
|
---|
801 | void QPSPrintEngine::setBrush()
|
---|
802 | {
|
---|
803 | Q_D(QPSPrintEngine);
|
---|
804 | #if 0
|
---|
805 | bool specifyColor;
|
---|
806 | int gStateObject = 0;
|
---|
807 | int patternObject = d->addBrushPattern(brush, d->stroker.matrix, brushOrigin, &specifyColor, &gStateObject);
|
---|
808 |
|
---|
809 | *d->currentPage << (patternObject ? "/PCSp cs " : "/CSp cs ");
|
---|
810 | if (specifyColor) {
|
---|
811 | QColor rgba = brush.color();
|
---|
812 | *d->currentPage << rgba.redF()
|
---|
813 | << rgba.greenF()
|
---|
814 | << rgba.blueF();
|
---|
815 | }
|
---|
816 | if (patternObject)
|
---|
817 | *d->currentPage << "/Pat" << patternObject;
|
---|
818 | *d->currentPage << "scn\n";
|
---|
819 | #endif
|
---|
820 | QColor rgba = d->brush.color();
|
---|
821 | if (d->colorMode == QPrinter::GrayScale) {
|
---|
822 | qreal gray = qGray(rgba.rgba())/255.;
|
---|
823 | *d->currentPage << gray << gray << gray;
|
---|
824 | } else {
|
---|
825 | *d->currentPage << rgba.redF()
|
---|
826 | << rgba.greenF()
|
---|
827 | << rgba.blueF();
|
---|
828 | }
|
---|
829 | *d->currentPage << "scn\n"
|
---|
830 | << "/BSt " << d->brush.style() << "def\n";
|
---|
831 | }
|
---|
832 |
|
---|
833 | void QPSPrintEngine::drawImageInternal(const QRectF &r, QImage image, bool bitmap)
|
---|
834 | {
|
---|
835 | Q_D(QPSPrintEngine);
|
---|
836 | if (d->clipEnabled && d->allClipped)
|
---|
837 | return;
|
---|
838 | if (bitmap && image.depth() != 1)
|
---|
839 | bitmap = false;
|
---|
840 | QImage mask;
|
---|
841 | // the below is not necessary since it's handled by the alpha
|
---|
842 | // engine
|
---|
843 | if (!d->useAlphaEngine && !bitmap) {
|
---|
844 | if (image.format() == QImage::Format_Mono || image.format() == QImage::Format_MonoLSB)
|
---|
845 | image = image.convertToFormat(QImage::Format_Indexed8);
|
---|
846 | if (image.hasAlphaChannel()) {
|
---|
847 | // get better alpha dithering
|
---|
848 | int xscale = image.width();
|
---|
849 | xscale *= xscale <= 800 ? 4 : (xscale <= 1600 ? 2 : 1);
|
---|
850 | int yscale = image.height();
|
---|
851 | yscale *= yscale <= 800 ? 4 : (yscale <= 1600 ? 2 : 1);
|
---|
852 | image = image.scaled(xscale, yscale);
|
---|
853 | mask = image.createAlphaMask(Qt::OrderedAlphaDither);
|
---|
854 | }
|
---|
855 | }
|
---|
856 | *d->currentPage << "q\n";
|
---|
857 | if(!d->simplePen)
|
---|
858 | *d->currentPage << QPdf::generateMatrix(d->stroker.matrix);
|
---|
859 | QBrush b = d->brush;
|
---|
860 | if (image.depth() == 1) {
|
---|
861 | // set current pen as brush
|
---|
862 | d->brush = d->pen.brush();
|
---|
863 | setBrush();
|
---|
864 | }
|
---|
865 | d->drawImage(r.x(), r.y(), r.width(), r.height(), image, mask);
|
---|
866 | *d->currentPage << "Q\n";
|
---|
867 | d->brush = b;
|
---|
868 | }
|
---|
869 |
|
---|
870 |
|
---|
871 | void QPSPrintEngine::drawImage(const QRectF &r, const QImage &img, const QRectF &sr,
|
---|
872 | Qt::ImageConversionFlags)
|
---|
873 | {
|
---|
874 | Q_D(QPSPrintEngine);
|
---|
875 |
|
---|
876 | if (d->useAlphaEngine) {
|
---|
877 | QAlphaPaintEngine::drawImage(r, img, sr);
|
---|
878 | if (!continueCall())
|
---|
879 | return;
|
---|
880 | }
|
---|
881 | QImage image = img.copy(sr.toRect());
|
---|
882 | drawImageInternal(r, image, false);
|
---|
883 | }
|
---|
884 |
|
---|
885 | void QPSPrintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
|
---|
886 | {
|
---|
887 | Q_D(QPSPrintEngine);
|
---|
888 |
|
---|
889 | if (d->useAlphaEngine) {
|
---|
890 | QAlphaPaintEngine::drawPixmap(r, pm, sr);
|
---|
891 | if (!continueCall())
|
---|
892 | return;
|
---|
893 | }
|
---|
894 |
|
---|
895 | QImage img = pm.copy(sr.toRect()).toImage();
|
---|
896 | drawImageInternal(r, img, true);
|
---|
897 | }
|
---|
898 |
|
---|
899 | void QPSPrintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &p)
|
---|
900 | {
|
---|
901 | Q_D(QPSPrintEngine);
|
---|
902 |
|
---|
903 | if (d->useAlphaEngine) {
|
---|
904 | QAlphaPaintEngine::drawTiledPixmap(r, pixmap, p);
|
---|
905 | if (!continueCall())
|
---|
906 | return;
|
---|
907 | }
|
---|
908 |
|
---|
909 | if (d->clipEnabled && d->allClipped)
|
---|
910 | return;
|
---|
911 | // ### Optimize implementation!
|
---|
912 | qreal yPos = r.y();
|
---|
913 | qreal yOff = p.y();
|
---|
914 | while(yPos < r.y() + r.height()) {
|
---|
915 | qreal drawH = pixmap.height() - yOff; // Cropping first row
|
---|
916 | if (yPos + drawH > r.y() + r.height()) // Cropping last row
|
---|
917 | drawH = r.y() + r.height() - yPos;
|
---|
918 | qreal xPos = r.x();
|
---|
919 | qreal xOff = p.x();
|
---|
920 | while(xPos < r.x() + r.width()) {
|
---|
921 | qreal drawW = pixmap.width() - xOff; // Cropping first column
|
---|
922 | if (xPos + drawW > r.x() + r.width()) // Cropping last column
|
---|
923 | drawW = r.x() + r.width() - xPos;
|
---|
924 | // ########
|
---|
925 | painter()->drawPixmap(QPointF(xPos, yPos).toPoint(), pixmap,
|
---|
926 | QRectF(xOff, yOff, drawW, drawH).toRect());
|
---|
927 | xPos += drawW;
|
---|
928 | xOff = 0;
|
---|
929 | }
|
---|
930 | yPos += drawH;
|
---|
931 | yOff = 0;
|
---|
932 | }
|
---|
933 |
|
---|
934 | }
|
---|
935 |
|
---|
936 | bool QPSPrintEngine::newPage()
|
---|
937 | {
|
---|
938 | Q_D(QPSPrintEngine);
|
---|
939 |
|
---|
940 | if (!d->firstPage && d->useAlphaEngine)
|
---|
941 | flushAndInit();
|
---|
942 |
|
---|
943 | // we're writing to lp/lpr through a pipe, we don't want to crash with SIGPIPE
|
---|
944 | // if lp/lpr dies
|
---|
945 | ignoreSigPipe(true);
|
---|
946 | if (!d->firstPage)
|
---|
947 | d->flushPage();
|
---|
948 | d->firstPage = false;
|
---|
949 | ignoreSigPipe(false);
|
---|
950 |
|
---|
951 | delete d->currentPage;
|
---|
952 | d->currentPage = new QPdfPage;
|
---|
953 | d->stroker.stream = d->currentPage;
|
---|
954 |
|
---|
955 | return QPdfBaseEngine::newPage();
|
---|
956 | }
|
---|
957 |
|
---|
958 | bool QPSPrintEngine::abort()
|
---|
959 | {
|
---|
960 | // ### abort!?!
|
---|
961 | return false;
|
---|
962 | }
|
---|
963 |
|
---|
964 | QPrinter::PrinterState QPSPrintEngine::printerState() const
|
---|
965 | {
|
---|
966 | Q_D(const QPSPrintEngine);
|
---|
967 | return d->printerState;
|
---|
968 | }
|
---|
969 |
|
---|
970 | QT_END_NAMESPACE
|
---|
971 |
|
---|
972 | #endif // QT_NO_PRINTER
|
---|