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

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "qplatformdefs.h"

#include <qdebug.h>

#include "qpdf_p.h"

#include <qfile.h>

#include <qtemporaryfile.h>

#include <private/qmath_p.h>

#include "private/qcups_p.h"

#include "qprinterinfo.h"

#include <qnumeric.h>

#ifdef Q_OS_UNIX

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

#endif

QT_BEGIN_NAMESPACE

extern int qt_defaultDpi();

#ifndef QT_NO_PRINTER

extern QSizeF qt_paperSizeToQSizeF(QPrinter::PaperSize size);

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

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

    const char *ret = buf;

    if (qIsNaN(val)) {

        *(buf++) = '0';

        *(buf++) = ' ';

        *buf = 0;

        return ret;

    }

    if (val < 0) {

        *(buf++) = '-';

        val = -val;

    }

    unsigned int ival = (unsigned int) val;

    qreal frac = val - (qreal)ival;

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

    if (ifrac == 1000000) {

        ++ival;

        ifrac = 0;

    }

    char output[256];

    int i = 0;

    while (ival) {

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

        ++i;

        ival /= 10;

    }

    int fact = 100000;

    if (i == 0) {

        *(buf++) = '0';

    } else {

        while (i) {

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

            fact /= 10;

            ifrac /= 10;

        }

    }

    if (ifrac) {

        *(buf++) =  '.';

        while (fact) {

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

            fact /= 10;

        }

    }

    *(buf++) = ' ';

    *buf = 0;

    return ret;

}

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

    const char *ret = buf;

    if (val < 0) {

        *(buf++) = '-';

        val = -val;

    }

    char output[256];

    int i = 0;

    while (val) {

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

        ++i;

        val /= 10;

    }

    if (i == 0) {

        *(buf++) = '0';

    } else {

        while (i)

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

    }

    *(buf++) = ' ';

    *buf = 0;

    return ret;

}

namespace QPdf {

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

            : dev(new QBuffer(byteArray)),

            fileBackingEnabled(fileBacking),

            fileBackingActive(false),

            handleDirty(false)

    {

        dev->open(QIODevice::ReadWrite);

    }

    ByteStream::ByteStream(bool fileBacking)

            : dev(new QBuffer(&ba)),

            fileBackingEnabled(fileBacking),

            fileBackingActive(false),

            handleDirty(false)

    {

        dev->open(QIODevice::ReadWrite);

    }

    ByteStream::~ByteStream()

    {

        delete dev;

    }

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

    {

        if (handleDirty) prepareBuffer();

        dev->write(&chr, 1);

        return *this;

    }

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

    {

        if (handleDirty) prepareBuffer();

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

        return *this;

    }

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

    {

        if (handleDirty) prepareBuffer();

        dev->write(str);

        return *this;

    }

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

    {

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

        if (handleDirty) prepareBuffer();

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

        // We save the position and restore it afterwards.

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

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

        s.dev->reset();

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

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

            dev->write(buf);

        }

        s.dev->seek(pos);

        return *this;

    }

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

        char buf[256];

        qt_real_to_string(val, buf);

        *this << buf;

        return *this;

    }

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

        char buf[256];

        qt_int_to_string(val, buf);

        *this << buf;

        return *this;

    }

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

        char buf[256];

        qt_real_to_string(p.x(), buf);

        *this << buf;

        qt_real_to_string(p.y(), buf);

        *this << buf;

        return *this;

    }

    QIODevice *ByteStream::stream()

    {

        dev->reset();

        handleDirty = true;

        return dev;

    }

    void ByteStream::clear()

    {

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

    }

    void ByteStream::constructor_helper(QByteArray *ba)

    {

        delete dev;

        dev = new QBuffer(ba);

        dev->open(QIODevice::ReadWrite);

    }

    void ByteStream::prepareBuffer()

    {

        Q_ASSERT(!dev->isSequential());

        qint64 size = dev->size();

        if (fileBackingEnabled && !fileBackingActive

                && size > maxMemorySize()) {

            // Switch to file backing.

            QTemporaryFile *newFile = new QTemporaryFile;

            newFile->open();

            dev->reset();

            while (!dev->atEnd()) {

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

                newFile->write(buf);

            }

            delete dev;

            dev = newFile;

            ba.clear();

            fileBackingActive = true;

        }

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

            dev->seek(size);

            handleDirty = false;

        }

    }

}

#define QT_PATH_ELEMENT(elm)

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

{

    QByteArray result;

    if (!path.elementCount())

        return result;

    ByteStream s(&result);

    int start = -1;

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

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

        switch (elm.type) {

        case QPainterPath::MoveToElement:

            if (start >= 0

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

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

                s << "h\n";

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

            start = i;

                break;

        case QPainterPath::LineToElement:

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

            break;

        case QPainterPath::CurveToElement:

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

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

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

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

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

              << "c\n";

            i += 2;

            break;

        default:

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

        }

    }

    if (start >= 0

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

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

        s << "h\n";

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

    const char *op = "";

    switch (flags) {

    case ClipPath:

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

        break;

    case FillPath:

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

        break;

    case StrokePath:

        op = "S\n";

        break;

    case FillAndStrokePath:

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

        break;

    }

    s << op;

    return result;

}

QByteArray QPdf::generateMatrix(const QTransform &matrix)

{

    QByteArray result;

    ByteStream s(&result);

    s << matrix.m11()

      << matrix.m12()

      << matrix.m21()

      << matrix.m22()

      << matrix.dx()

      << matrix.dy()

      << "cm\n";

    return result;

}

QByteArray QPdf::generateDashes(const QPen &pen)

{

    QByteArray result;

    ByteStream s(&result);

    s << '[';

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

    qreal w = pen.widthF();

    if (w < 0.001)

        w = 1;

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

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

        if (dw < 0.0001) dw = 0.0001;

        s << dw;

    }

    s << ']';

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

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

    return result;

}

static const char* pattern_for_brush[] = {

    0, // NoBrush

    0, // SolidPattern

    "0 J\n"

    "6 w\n"

    "[] 0 d\n"

    "4 0 m\n"

    "4 8 l\n"

    "0 4 m\n"

    "8 4 l\n"

    "S\n", // Dense1Pattern

    "0 J\n"

    "2 w\n"

    "[6 2] 1 d\n"

    "0 0 m\n"

    "0 8 l\n"

    "8 0 m\n"

    "8 8 l\n"

    "S\n"

    "[] 0 d\n"

    "2 0 m\n"

    "2 8 l\n"

    "6 0 m\n"

    "6 8 l\n"

    "S\n"

    "[6 2] -3 d\n"

    "4 0 m\n"

    "4 8 l\n"

    "S\n", // Dense2Pattern

    "0 J\n"

    "2 w\n"

    "[6 2] 1 d\n"

    "0 0 m\n"

    "0 8 l\n"

    "8 0 m\n"

    "8 8 l\n"

    "S\n"

    "[2 2] -1 d\n"

    "2 0 m\n"

    "2 8 l\n"

    "6 0 m\n"

    "6 8 l\n"

    "S\n"

    "[6 2] -3 d\n"

    "4 0 m\n"

    "4 8 l\n"

    "S\n", // Dense3Pattern

    "0 J\n"

    "2 w\n"

    "[2 2] 1 d\n"

    "0 0 m\n"

    "0 8 l\n"

    "8 0 m\n"

    "8 8 l\n"

    "S\n"

    "[2 2] -1 d\n"

    "2 0 m\n"

    "2 8 l\n"

    "6 0 m\n"

    "6 8 l\n"

    "S\n"

    "[2 2] 1 d\n"

    "4 0 m\n"

    "4 8 l\n"

    "S\n", // Dense4Pattern

    "0 J\n"

    "2 w\n"

    "[2 6] -1 d\n"

    "0 0 m\n"

    "0 8 l\n"

    "8 0 m\n"

    "8 8 l\n"

    "S\n"

    "[2 2] 1 d\n"

    "2 0 m\n"

    "2 8 l\n"

    "6 0 m\n"

    "6 8 l\n"

    "S\n"

    "[2 6] 3 d\n"

    "4 0 m\n"

    "4 8 l\n"

    "S\n", // Dense5Pattern

    "0 J\n"

    "2 w\n"

    "[2 6] -1 d\n"

    "0 0 m\n"

    "0 8 l\n"

    "8 0 m\n"

    "8 8 l\n"

    "S\n"

    "[2 6] 3 d\n"

    "4 0 m\n"

    "4 8 l\n"

    "S\n", // Dense6Pattern

    "0 J\n"

    "2 w\n"

    "[2 6] -1 d\n"

    "0 0 m\n"

    "0 8 l\n"

    "8 0 m\n"

    "8 8 l\n"

    "S\n", // Dense7Pattern

    "1 w\n"

    "0 4 m\n"

    "8 4 l\n"

    "S\n", // HorPattern

    "1 w\n"

    "4 0 m\n"

    "4 8 l\n"

    "S\n", // VerPattern

    "1 w\n"

    "4 0 m\n"

    "4 8 l\n"

    "0 4 m\n"

    "8 4 l\n"

    "S\n", // CrossPattern

    "1 w\n"

    "-1 5 m\n"

    "5 -1 l\n"

    "3 9 m\n"

    "9 3 l\n"

    "S\n", // BDiagPattern

    "1 w\n"

    "-1 3 m\n"

    "5 9 l\n"

    "3 -1 m\n"

    "9 5 l\n"

    "S\n", // FDiagPattern

    "1 w\n"

    "-1 3 m\n"

    "5 9 l\n"

    "3 -1 m\n"

    "9 5 l\n"

    "-1 5 m\n"

    "5 -1 l\n"

    "3 9 m\n"

    "9 3 l\n"

    "S\n", // DiagCrossPattern

};

QByteArray QPdf::patternForBrush(const QBrush &b)

{

    int style = b.style();

    if (style > Qt::DiagCrossPattern)