1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 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 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    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 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include "qplatformdefs.h"

    42 #include <qdebug.h>

    43 #include "qpdf_p.h"

    44 #include <qfile.h>

    45 #include <qtemporaryfile.h>

    46 #include <private/qmath_p.h>

    47 #include "private/qcups_p.h"

    48 #include "qprinterinfo.h"

    49 #include <qnumeric.h>

    50 

    51 #ifdef Q_OS_UNIX

    52 #include "private/qcore_unix_p.h" // overrides QT_OPEN

    53 #endif

    54 

    55 QT_BEGIN_NAMESPACE

    56 

    57 extern int qt_defaultDpi();

    58 

    59 #ifndef QT_NO_PRINTER

    60 

    61 extern QSizeF qt_paperSizeToQSizeF(QPrinter::PaperSize size);

    62 

    63 /* also adds a space at the end of the number */

    64 const char *qt_real_to_string(qreal val, char *buf) {

    65     const char *ret = buf;

    66 

    67     if (qIsNaN(val)) {

    68         *(buf++) = '0';

    69         *(buf++) = ' ';

    70         *buf = 0;

    71         return ret;

    72     }

    73 

    74     if (val < 0) {

    75         *(buf++) = '-';

    76         val = -val;

    77     }

    78     unsigned int ival = (unsigned int) val;

    79     qreal frac = val - (qreal)ival;

    80 

    81     int ifrac = (int)(frac * 1000000);

    82     if (ifrac == 1000000) {

    83         ++ival;

    84         ifrac = 0;

    85     }

    86     char output[256];

    87     int i = 0;

    88     while (ival) {

    89         output[i] = '0' + (ival % 10);

    90         ++i;

    91         ival /= 10;

    92     }

    93     int fact = 100000;

    94     if (i == 0) {

    95         *(buf++) = '0';

    96     } else {

    97         while (i) {

    98             *(buf++) = output[--i];

    99             fact /= 10;

   100             ifrac /= 10;

   101         }

   102     }

   103 

   104     if (ifrac) {

   105         *(buf++) =  '.';

   106         while (fact) {

   107             *(buf++) = '0' + ((ifrac/fact) % 10);

   108             fact /= 10;

   109         }

   110     }

   111     *(buf++) = ' ';

   112     *buf = 0;

   113     return ret;

   114 }

   115 

   116 const char *qt_int_to_string(int val, char *buf) {

   117     const char *ret = buf;

   118     if (val < 0) {

   119         *(buf++) = '-';

   120         val = -val;

   121     }

   122     char output[256];

   123     int i = 0;

   124     while (val) {

   125         output[i] = '0' + (val % 10);

   126         ++i;

   127         val /= 10;

   128     }

   129     if (i == 0) {

   130         *(buf++) = '0';

   131     } else {

   132         while (i)

   133             *(buf++) = output[--i];

   134     }

   135     *(buf++) = ' ';

   136     *buf = 0;

   137     return ret;

   138 }

   139 

   140 

   141 namespace QPdf {

   142     ByteStream::ByteStream(QByteArray *byteArray, bool fileBacking)

   143             : dev(new QBuffer(byteArray)),

   144             fileBackingEnabled(fileBacking),

   145             fileBackingActive(false),

   146             handleDirty(false)

   147     {

   148         dev->open(QIODevice::ReadWrite);

   149     }

   150 

   151     ByteStream::ByteStream(bool fileBacking)

   152             : dev(new QBuffer(&ba)),

   153             fileBackingEnabled(fileBacking),

   154             fileBackingActive(false),

   155             handleDirty(false)

   156     {

   157         dev->open(QIODevice::ReadWrite);

   158     }

   159 

   160     ByteStream::~ByteStream()

   161     {

   162         delete dev;

   163     }

   164 

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

   166     {

   167         if (handleDirty) prepareBuffer();

   168         dev->write(&chr, 1);

   169         return *this;

   170     }

   171 

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

   173     {

   174         if (handleDirty) prepareBuffer();

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

   176         return *this;

   177     }

   178 

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

   180     {

   181         if (handleDirty) prepareBuffer();

   182         dev->write(str);

   183         return *this;

   184     }

   185 

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

   187     {

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

   189         if (handleDirty) prepareBuffer();

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

   191         // We save the position and restore it afterwards.

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

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

   194         s.dev->reset();

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

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

   197             dev->write(buf);

   198         }

   199         s.dev->seek(pos);

   200         return *this;

   201     }

   202 

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

   204         char buf[256];

   205         qt_real_to_string(val, buf);

   206         *this << buf;

   207         return *this;

   208     }

   209 

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

   211         char buf[256];

   212         qt_int_to_string(val, buf);

   213         *this << buf;

   214         return *this;

   215     }

   216 

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

   218         char buf[256];

   219         qt_real_to_string(p.x(), buf);

   220         *this << buf;

   221         qt_real_to_string(p.y(), buf);

   222         *this << buf;

   223         return *this;

   224     }

   225 

   226     QIODevice *ByteStream::stream()

   227     {

   228         dev->reset();

   229         handleDirty = true;

   230         return dev;

   231     }

   232 

   233     void ByteStream::clear()

   234     {

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

   236     }

   237 

   238     void ByteStream::constructor_helper(QByteArray *ba)

   239     {

   240         delete dev;

   241         dev = new QBuffer(ba);

   242         dev->open(QIODevice::ReadWrite);

   243     }

   244 

   245     void ByteStream::prepareBuffer()

   246     {

   247         Q_ASSERT(!dev->isSequential());

   248         qint64 size = dev->size();

   249         if (fileBackingEnabled && !fileBackingActive

   250                 && size > maxMemorySize()) {

   251             // Switch to file backing.

   252             QTemporaryFile *newFile = new QTemporaryFile;

   253             newFile->open();

   254             dev->reset();

   255             while (!dev->atEnd()) {

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

   257                 newFile->write(buf);

   258             }

   259             delete dev;

   260             dev = newFile;

   261             ba.clear();

   262             fileBackingActive = true;

   263         }

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

   265             dev->seek(size);

   266             handleDirty = false;

   267         }

   268     }

   269 }

   270 

   271 #define QT_PATH_ELEMENT(elm)

   272 

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

   274 {

   275     QByteArray result;

   276     if (!path.elementCount())

   277         return result;

   278 

   279     ByteStream s(&result);

   280 

   281     int start = -1;

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

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

   284         switch (elm.type) {

   285         case QPainterPath::MoveToElement:

   286             if (start >= 0

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

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

   289                 s << "h\n";

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

   291             start = i;

   292                 break;

   293         case QPainterPath::LineToElement:

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

   295             break;

   296         case QPainterPath::CurveToElement:

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

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

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

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

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

   302               << "c\n";

   303             i += 2;

   304             break;

   305         default:

   306             qFatal("QPdf::generatePath(), unhandled type: %d", elm.type);

   307         }

   308     }

   309     if (start >= 0

   310         && path.elementAt(start).x == path.elementAt(path.elementCount()-1).x

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

   312         s << "h\n";

   313 

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

   315 

   316     const char *op = "";

   317     switch (flags) {

   318     case ClipPath:

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

   320         break;

   321     case FillPath:

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

   323         break;

   324     case StrokePath:

   325         op = "S\n";

   326         break;

   327     case FillAndStrokePath:

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

   329         break;

   330     }

   331     s << op;

   332     return result;

   333 }

   334 

   335 QByteArray QPdf::generateMatrix(const QTransform &matrix)

   336 {

   337     QByteArray result;

   338     ByteStream s(&result);

   339     s << matrix.m11()

   340       << matrix.m12()

   341       << matrix.m21()

   342       << matrix.m22()

   343       << matrix.dx()

   344       << matrix.dy()

   345       << "cm\n";

   346     return result;

   347 }

   348 

   349 QByteArray QPdf::generateDashes(const QPen &pen)

   350 {

   351     QByteArray result;

   352     ByteStream s(&result);

   353     s << '[';

   354 

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

   356     qreal w = pen.widthF();

   357     if (w < 0.001)

   358         w = 1;

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

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

   361         if (dw < 0.0001) dw = 0.0001;

   362         s << dw;

   363     }

   364     s << ']';

   365     //qDebug() << "dasharray: pen has" << dasharray;

   366     //qDebug() << "  => " << result;

   367     return result;

   368 }

   369 

   370 

   371 

   372 static const char* pattern_for_brush[] = {

   373     0, // NoBrush

   374     0, // SolidPattern

   375     "0 J\n"

   376     "6 w\n"

   377     "[] 0 d\n"

   378     "4 0 m\n"

   379     "4 8 l\n"

   380     "0 4 m\n"

   381     "8 4 l\n"

   382     "S\n", // Dense1Pattern

   383 

   384     "0 J\n"

   385     "2 w\n"

   386     "[6 2] 1 d\n"

   387     "0 0 m\n"

   388     "0 8 l\n"

   389     "8 0 m\n"

   390     "8 8 l\n"

   391     "S\n"

   392     "[] 0 d\n"

   393     "2 0 m\n"

   394     "2 8 l\n"

   395     "6 0 m\n"

   396     "6 8 l\n"

   397     "S\n"

   398     "[6 2] -3 d\n"

   399     "4 0 m\n"

   400     "4 8 l\n"

   401     "S\n", // Dense2Pattern

   402 

   403     "0 J\n"

   404     "2 w\n"

   405     "[6 2] 1 d\n"

   406     "0 0 m\n"

   407     "0 8 l\n"

   408     "8 0 m\n"

   409     "8 8 l\n"

   410     "S\n"

   411     "[2 2] -1 d\n"

   412     "2 0 m\n"

   413     "2 8 l\n"

   414     "6 0 m\n"

   415     "6 8 l\n"

   416     "S\n"

   417     "[6 2] -3 d\n"

   418     "4 0 m\n"

   419     "4 8 l\n"

   420     "S\n", // Dense3Pattern

   421 

   422     "0 J\n"

   423     "2 w\n"

   424     "[2 2] 1 d\n"

   425     "0 0 m\n"

   426     "0 8 l\n"

   427     "8 0 m\n"

   428     "8 8 l\n"

   429     "S\n"

   430     "[2 2] -1 d\n"

   431     "2 0 m\n"

   432     "2 8 l\n"

   433     "6 0 m\n"

   434     "6 8 l\n"

   435     "S\n"

   436     "[2 2] 1 d\n"

   437     "4 0 m\n"

   438     "4 8 l\n"

   439     "S\n", // Dense4Pattern

   440 

   441     "0 J\n"

   442     "2 w\n"

   443     "[2 6] -1 d\n"

   444     "0 0 m\n"

   445     "0 8 l\n"

   446     "8 0 m\n"

   447     "8 8 l\n"

   448     "S\n"

   449     "[2 2] 1 d\n"

   450     "2 0 m\n"

   451     "2 8 l\n"

   452     "6 0 m\n"

   453     "6 8 l\n"

   454     "S\n"

   455     "[2 6] 3 d\n"

   456     "4 0 m\n"

   457     "4 8 l\n"

   458     "S\n", // Dense5Pattern

   459 

   460     "0 J\n"

   461     "2 w\n"

   462     "[2 6] -1 d\n"

   463     "0 0 m\n"

   464     "0 8 l\n"

   465     "8 0 m\n"

   466     "8 8 l\n"

   467     "S\n"

   468     "[2 6] 3 d\n"

   469     "4 0 m\n"

   470     "4 8 l\n"

   471     "S\n", // Dense6Pattern

   472 

   473     "0 J\n"

   474     "2 w\n"

   475     "[2 6] -1 d\n"

   476     "0 0 m\n"

   477     "0 8 l\n"

   478     "8 0 m\n"

   479     "8 8 l\n"

   480     "S\n", // Dense7Pattern

   481 

   482     "1 w\n"

   483     "0 4 m\n"

   484     "8 4 l\n"

   485     "S\n", // HorPattern

   486 

   487     "1 w\n"

   488     "4 0 m\n"

   489     "4 8 l\n"

   490     "S\n", // VerPattern

   491 

   492     "1 w\n"

   493     "4 0 m\n"

   494     "4 8 l\n"

   495     "0 4 m\n"

   496     "8 4 l\n"

   497     "S\n", // CrossPattern

   498 

   499     "1 w\n"

   500     "-1 5 m\n"

   501     "5 -1 l\n"

   502     "3 9 m\n"

   503     "9 3 l\n"

   504     "S\n", // BDiagPattern

   505 

   506     "1 w\n"

   507     "-1 3 m\n"

   508     "5 9 l\n"

   509     "3 -1 m\n"

   510     "9 5 l\n"

   511     "S\n", // FDiagPattern

   512 

   513     "1 w\n"

   514     "-1 3 m\n"

   515     "5 9 l\n"

   516     "3 -1 m\n"

   517     "9 5 l\n"

   518     "-1 5 m\n"

   519     "5 -1 l\n"

   520     "3 9 m\n"

   521     "9 3 l\n"

   522     "S\n", // DiagCrossPattern

   523 };

   524 

   525 QByteArray QPdf::patternForBrush(const QBrush &b)

   526 {

   527     int style = b.style();

   528     if (style > Qt::DiagCrossPattern)

   529         return QByteArray();

   530     return pattern_for_brush[style];

   531 }

   532 

   533 #ifdef USE_NATIVE_GRADIENTS

   534 static void writeTriangleLine(uchar *&data, int xpos, int ypos, int xoff, int yoff, uint rgb, uchar flag, bool alpha)

   535 {

   536     data[0] =  flag;

   537     data[1] = (uchar)(xpos >> 16);

   538     data[2] = (uchar)(xpos >> 8);

   539     data[3] = (uchar)(xpos >> 0);

   540     data[4] = (uchar)(ypos >> 16);

   541     data[5] = (uchar)(ypos >> 8);

   542     data[6] = (uchar)(ypos >> 0);

   543     data += 7;

   544     if (alpha) {

   545         *data++ = (uchar)qAlpha(rgb);

   546     } else {

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

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

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

   550     }

   551     xpos += xoff;

   552     ypos += yoff;

   553     data[0] =  flag;

   554     data[1] = (uchar)(xpos >> 16);

   555     data[2] = (uchar)(xpos >> 8);

   556     data[3] = (uchar)(xpos >> 0);

   557     data[4] = (uchar)(ypos >> 16);

   558     data[5] = (uchar)(ypos >> 8);

   559     data[6] = (uchar)(ypos >> 0);

   560     data += 7;

   561     if (alpha) {

   562         *data++ = (uchar)qAlpha(rgb);

   563     } else {

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

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

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

   567     }

   568 }

   569 

   570 

   571 QByteArray QPdf::generateLinearGradientShader(const QLinearGradient *gradient, const QPointF *page_rect, bool alpha)

   572 {

   573     // generate list of triangles with colors

   574     QPointF start = gradient->start();

   575     QPointF stop = gradient->finalStop();

   576     QGradientStops stops = gradient->stops();

   577     QPointF offset = stop - start;

   578     QGradient::Spread spread = gradient->spread();

   579 

   580     if (gradient->spread() == QGradient::ReflectSpread) {

   581         offset *= 2;

   582         for (int i = stops.size() - 2; i >= 0; --i) {

   583             QGradientStop stop = stops.at(i);

   584             stop.first = 2. - stop.first;

   585             stops.append(stop);

   586         }

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

   588             stops[i].first /= 2.;

   589     }

   590 

   591     QPointF orthogonal(offset.y(), -offset.x());

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

   593 

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

   595     // the whole page

   596     int off_min = INT_MAX;

   597     int off_max = INT_MIN;

   598     qreal ort_min = INT_MAX;

   599     qreal ort_max = INT_MIN;

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

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

   602         qreal ort = ((page_rect[i].x() - start.x()) * orthogonal.x() + (page_rect[i].y() - start.y()) * orthogonal.y())/length;

   603         off_min = qMin(off_min, qFloor(off));

   604         off_max = qMax(off_max, qCeil(off));

   605         ort_min = qMin(ort_min, ort);

   606         ort_max = qMax(ort_max, ort);

   607     }

   608     ort_min -= 1;

   609     ort_max += 1;

   610 

   611     start += off_min * offset + ort_min * orthogonal;

   612     orthogonal *= (ort_max - ort_min);

   613     int num = off_max - off_min;

   614 

   615     QPointF gradient_rect[4] = { start,

   616                                  start + orthogonal,

   617                                  start + num*offset,

   618                                  start + num*offset + orthogonal };

   619     qreal xmin = gradient_rect[0].x();

   620     qreal xmax = gradient_rect[0].x();

   621     qreal ymin = gradient_rect[0].y();

   622     qreal ymax = gradient_rect[0].y();

   623     for (int i = 1; i < 4; ++i) {

   624         xmin = qMin(xmin, gradient_rect[i].x());

   625         xmax = qMax(xmax, gradient_rect[i].x());

   626         ymin = qMin(ymin, gradient_rect[i].y());

   627         ymax = qMax(ymax, gradient_rect[i].y());

   628     }

   629     xmin -= 1000;

   630     xmax += 1000;

   631     ymin -= 1000;

   632     ymax += 1000;

   633     start -= QPointF(xmin, ymin);

   634     qreal factor_x = qreal(1<<24)/(xmax - xmin);

   635     qreal factor_y = qreal(1<<24)/(ymax - ymin);

   636     int xoff = (int)(orthogonal.x()*factor_x);

   637     int yoff = (int)(orthogonal.y()*factor_y);

   638 

   639     QByteArray triangles;

   640     triangles.resize(spread == QGradient::PadSpread ? 20*(stops.size()+2) : 20*num*stops.size());

   641     uchar *data = (uchar *) triangles.data();

   642     if (spread == QGradient::PadSpread) {

   643         if (off_min > 0 || off_max < 1) {

   644             // linear gradient outside of page

   645             const QGradientStop &current_stop = off_min > 0 ? stops.at(stops.size()-1) : stops.at(0);

   646             uint rgb = current_stop.second.rgba();

   647             int xpos = (int)(start.x()*factor_x);

   648             int ypos = (int)(start.y()*factor_y);

   649             writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, 0, alpha);

   650             start += num*offset;

   651             xpos = (int)(start.x()*factor_x);

   652             ypos = (int)(start.y()*factor_y);

   653             writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, 1, alpha);

   654         } else {

   655             int flag = 0;

   656             if (off_min < 0) {

   657                 uint rgb = stops.at(0).second.rgba();

   658                 int xpos = (int)(start.x()*factor_x);

   659                 int ypos = (int)(start.y()*factor_y);

   660                 writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);

   661                 start -= off_min*offset;

   662                 flag = 1;

   663             }

   664             for (int s = 0; s < stops.size(); ++s) {

   665                 const QGradientStop &current_stop = stops.at(s);

   666                 uint rgb = current_stop.second.rgba();

   667                 int xpos = (int)(start.x()*factor_x);

   668                 int ypos = (int)(start.y()*factor_y);

   669                 writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);

   670                 if (s < stops.size()-1)

   671                     start += offset*(stops.at(s+1).first - stops.at(s).first);

   672                 flag = 1;

   673             }

   674             if (off_max > 1) {

   675                 start += (off_max - 1)*offset;

   676                 uint rgb = stops.at(stops.size()-1).second.rgba();

   677                 int xpos = (int)(start.x()*factor_x);

   678                 int ypos = (int)(start.y()*factor_y);

   679                 writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);

   680             }

   681         }

   682     } else {

   683         for (int i = 0; i < num; ++i) {

   684             uchar flag = 0;

   685             for (int s = 0; s < stops.size(); ++s) {

   686                 uint rgb = stops.at(s).second.rgba();

   687                 int xpos = (int)(start.x()*factor_x);

   688                 int ypos = (int)(start.y()*factor_y);

   689                 writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);

   690                 if (s < stops.size()-1)

   691                     start += offset*(stops.at(s+1).first - stops.at(s).first);

   692                 flag = 1;

   693             }

   694         }

   695     }

   696     triangles.resize((char *)data - triangles.constData());

   697 

   698     QByteArray shader;

   699     QPdf::ByteStream s(&shader);

   700     s << "<<\n"

   701         "/ShadingType 4\n"

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

   703         "/AntiAlias true\n"

   704         "/BitsPerCoordinate 24\n"

   705         "/BitsPerComponent 8\n"

   706         "/BitsPerFlag 8\n"

   707         "/Decode [" << xmin << xmax << ymin << ymax << (alpha ? "0 1]\n" : "0 1 0 1 0 1]\n") <<

   708         "/AntiAlias true\n"

   709         "/Length " << triangles.length() << "\n"

   710         ">>\n"

   711         "stream\n" << triangles << "endstream\n"

   712         "endobj\n";

   713     return shader;

   714 }

   715 #endif

   716 

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

   718 {

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

   720     if (!t->first)

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

   722     if (!t->cosmeticPen)

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

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

   725     t->first = false;

   726 }

   727 

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

   729 {

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

   731     if (!t->cosmeticPen)

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

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

   734 }

   735 

   736 static void cubicToHook(qfixed c1x, qfixed c1y,

   737                         qfixed c2x, qfixed c2y,

   738                         qfixed ex, qfixed ey,

   739                         void *data)

   740 {

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

   742     if (!t->cosmeticPen) {

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

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

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

   746     }

   747     *t->stream << c1x << c1y

   748                << c2x << c2y

   749                << ex << ey

   750                << "c\n";

   751 }

   752 

   753 QPdf::Stroker::Stroker()

   754     : stream(0),

   755     first(true),

   756     dashStroker(&basicStroker)

   757 {

   758     stroker = &basicStroker;

   759     basicStroker.setMoveToHook(moveToHook);

   760     basicStroker.setLineToHook(lineToHook);

   761     basicStroker.setCubicToHook(cubicToHook);

   762     cosmeticPen = true;

   763     basicStroker.setStrokeWidth(.1);

   764 }

   765 

   766 void QPdf::Stroker::setPen(const QPen &pen)

   767 {

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

   769         stroker = 0;

   770         return;

   771     }

   772     qreal w = pen.widthF();

   773     bool zeroWidth = w < 0.0001;

   774     cosmeticPen = pen.isCosmetic();

   775     if (zeroWidth)

   776         w = .1;

   777 

   778     basicStroker.setStrokeWidth(w);

   779     basicStroker.setCapStyle(pen.capStyle());

   780     basicStroker.setJoinStyle(pen.joinStyle());

   781     basicStroker.setMiterLimit(pen.miterLimit());

   782 

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

   784     if (zeroWidth) {

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

   786             dashpattern[i] *= 10.;

   787     }

   788     if (!dashpattern.isEmpty()) {

   789         dashStroker.setDashPattern(dashpattern);

   790         dashStroker.setDashOffset(pen.dashOffset());

   791         stroker = &dashStroker;

   792     } else {

   793         stroker = &basicStroker;

   794     }

   795 }

   796 

   797 void QPdf::Stroker::strokePath(const QPainterPath &path)

   798 {

   799     if (!stroker)

   800         return;

   801     first = true;

   802 

   803     stroker->strokePath(path, this, cosmeticPen ? matrix : QTransform());

   804     *stream << "h f\n";

   805 }

   806 

   807 QByteArray QPdf::ascii85Encode(const QByteArray &input)

   808 {

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

   810     QByteArray output;

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

   812     char *out = output.data();

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

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

   815         uint val = (((uint)in[i])<<24) + (((uint)in[i+1])<<16) + (((uint)in[i+2])<<8) + (uint)in[i+3];

   816         if (val == 0) {

   817             *out = 'z';

   818             ++out;

   819         } else {

   820             char base[5];

   821             base[4] = val % 85;

   822             val /= 85;

   823             base[3] = val % 85;

   824             val /= 85;

   825             base[2] = val % 85;

   826             val /= 85;

   827             base[1] = val % 85;

   828             val /= 85;

   829             base[0] = val % 85;

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

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

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

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

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

   835         }

   836     }

   837     //write the last few bytes

   838     int remaining = input.size() - isize;

   839     if (remaining) {

   840         uint val = 0;

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

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

   843         val <<= 8*(4-remaining);

   844         char base[5];

   845         base[4] = val % 85;

   846         val /= 85;

   847         base[3] = val % 85;

   848         val /= 85;

   849         base[2] = val % 85;

   850         val /= 85;

   851         base[1] = val % 85;

   852         val /= 85;

   853         base[0] = val % 85;

   854         for (int i = 0; i < remaining+1; ++i)

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

   856     }

   857     *(out++) = '~';

   858     *(out++) = '>';

   859     output.resize(out-output.data());

   860     return output;

   861 }

   862 

   863 const char *QPdf::toHex(ushort u, char *buffer)

   864 {

   865     int i = 3;

   866     while (i >= 0) {

   867         ushort hex = (u & 0x000f);

   868         if (hex < 0x0a)

   869             buffer[i] = '0'+hex;

   870         else

   871             buffer[i] = 'A'+(hex-0x0a);

   872         u = u >> 4;

   873         i--;

   874     }

   875     buffer[4] = '\0';

   876     return buffer;

   877 }

   878 

   879 const char *QPdf::toHex(uchar u, char *buffer)

   880 {

   881     int i = 1;

   882     while (i >= 0) {

   883         ushort hex = (u & 0x000f);

   884         if (hex < 0x0a)

   885             buffer[i] = '0'+hex;

   886         else

   887             buffer[i] = 'A'+(hex-0x0a);

   888         u = u >> 4;

   889         i--;

   890     }

   891     buffer[2] = '\0';

   892     return buffer;

   893 }

   894 

   895 #define Q_MM(n) int((n * 720 + 127) / 254)

   896 #define Q_IN(n) int(n * 72)

   897 

   898 static const char * const psToStr[QPrinter::NPaperSize+1] =

   899 {

   900     "A4", "B5", "Letter", "Legal", "Executive",

   901     "A0", "A1", "A2", "A3", "A5", "A6", "A7", "A8", "A9", "B0", "B1",

   902     "B10", "B2", "B3", "B4", "B6", "B7", "B8", "B9", "C5E", "Comm10E",

   903     "DLE", "Folio", "Ledger", "Tabloid", 0

   904 };

   905 

   906 QPdf::PaperSize QPdf::paperSize(QPrinter::PaperSize paperSize)

   907 {

   908     QSizeF s = qt_paperSizeToQSizeF(paperSize);

   909     PaperSize p = { Q_MM(s.width()), Q_MM(s.height()) };

   910     return p;

   911 }

   912 

   913 const char *QPdf::paperSizeToString(QPrinter::PaperSize paperSize)

   914 {

   915     return psToStr[paperSize];

   916 }

   917 

   918 

   919 QByteArray QPdf::stripSpecialCharacters(const QByteArray &string)

   920 {

   921     QByteArray s = string;

   922     s.replace(' ', "");

   923     s.replace('(', "");

   924     s.replace(')', "");

   925     s.replace('<', "");

   926     s.replace('>', "");

   927     s.replace('[', "");

   928     s.replace(']', "");

   929     s.replace('{', "");

   930     s.replace('}', "");

   931     s.replace('/', "");

   932     s.replace('%', "");

   933     return s;

   934 }

   935 

   936 

   937 // -------------------------- base engine, shared code between PS and PDF -----------------------

   938 

   939 QPdfBaseEngine::QPdfBaseEngine(QPdfBaseEnginePrivate &dd, PaintEngineFeatures f)

   940     : QAlphaPaintEngine(dd, f)

   941 {

   942     Q_D(QPdfBaseEngine);

   943 #if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

   944     if (QCUPSSupport::isAvailable()) {

   945         QCUPSSupport cups;

   946         const cups_dest_t* printers = cups.availablePrinters();

   947         int prnCount = cups.availablePrintersCount();

   948 

   949         for (int i = 0; i <  prnCount; ++i) {

   950             if (printers[i].is_default) {

   951                 d->printerName = QString::fromLocal8Bit(printers[i].name);

   952                 break;

   953             }

   954         }

   955 

   956     } else

   957 #endif

   958     {

   959         d->printerName = QString::fromLocal8Bit(qgetenv("PRINTER"));

   960         if (d->printerName.isEmpty())

   961             d->printerName = QString::fromLocal8Bit(qgetenv("LPDEST"));

   962         if (d->printerName.isEmpty())

   963             d->printerName = QString::fromLocal8Bit(qgetenv("NPRINTER"));

   964         if (d->printerName.isEmpty())

   965             d->printerName = QString::fromLocal8Bit(qgetenv("NGPRINTER"));

   966     }

   967 }

   968 

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

   970 {

   971     if (!points)

   972         return;

   973 

   974     QPainterPath p;

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

   976         p.moveTo(points[i]);

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

   978     }

   979     drawPath(p);

   980 }

   981 

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

   983 {

   984     if (!lines)

   985         return;

   986 

   987     QPainterPath p;

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

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

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

   991     }

   992     drawPath(p);

   993 }

   994 

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

   996 {

   997     if (!rects)

   998         return;

   999 

  1000     Q_D(QPdfBaseEngine);

  1001     if (d->useAlphaEngine) {

  1002         QAlphaPaintEngine::drawRects(rects, rectCount);

  1003         if (!continueCall())

  1004             return;

  1005     }

  1006 

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

  1008         return;

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

  1010         return;

  1011 

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

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

  1014         // draw strokes natively in this case for better output

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

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

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

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

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

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

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

  1022     } else {

  1023         QPainterPath p;

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

  1025             p.addRect(rects[i]);

  1026         drawPath(p);

  1027     }

  1028 }

  1029 

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

  1031 {

  1032     Q_D(QPdfBaseEngine);

  1033 

  1034     if (d->useAlphaEngine) {

  1035         QAlphaPaintEngine::drawPolygon(points, pointCount, mode);

  1036         if (!continueCall())

  1037             return;

  1038     }

  1039 

  1040     if (!points || !pointCount)

  1041         return;

  1042 

  1043     bool hb = d->hasBrush;

  1044     QPainterPath p;

  1045 

  1046     switch(mode) {

  1047         case OddEvenMode:

  1048             p.setFillRule(Qt::OddEvenFill);

  1049             break;

  1050         case ConvexMode:

  1051         case WindingMode:

  1052             p.setFillRule(Qt::WindingFill);

  1053             break;

  1054         case PolylineMode:

  1055             d->hasBrush = false;

  1056             break;

  1057         default:

  1058             break;

  1059     }

  1060 

  1061     p.moveTo(points[0]);

  1062     for (int i = 1; i < pointCount; ++i)

  1063         p.lineTo(points[i]);

  1064 

  1065     if (mode != PolylineMode)

  1066         p.closeSubpath();

  1067     drawPath(p);

  1068 

  1069     d->hasBrush = hb;

  1070 }

  1071 

  1072 void QPdfBaseEngine::drawPath (const QPainterPath &p)

  1073 {

  1074     Q_D(QPdfBaseEngine);

  1075 

  1076     if (d->useAlphaEngine) {

  1077         QAlphaPaintEngine::drawPath(p);

  1078         if (!continueCall())

  1079             return;

  1080     }

  1081 

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

  1083         return;

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

  1085         return;

  1086 

  1087     if (d->simplePen) {

  1088         // draw strokes natively in this case for better output

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

  1090     } else {

  1091         if (d->hasBrush)

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

  1093         if (d->hasPen) {

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

  1095             QBrush b = d->brush;

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

  1097             setBrush();

  1098             d->stroker.strokePath(p);

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

  1100             d->brush = b;

  1101         }

  1102     }

  1103 }

  1104 

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

  1106 {

  1107     Q_D(QPdfBaseEngine);

  1108 

  1109     if (d->useAlphaEngine) {

  1110         QAlphaPaintEngine::drawTextItem(p, textItem);

  1111         if (!continueCall())

  1112             return;

  1113     }

  1114 

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

  1116         return;

  1117 

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

  1119         QPaintEngine::drawTextItem(p, textItem);

  1120         return;

  1121     }

  1122 

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

  1124     if(!d->simplePen)

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

  1126 

  1127     bool hp = d->hasPen;

  1128     d->hasPen = false;

  1129     QBrush b = d->brush;

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

  1131     setBrush();

  1132 

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

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