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

**

** All rights reserved.

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

**

** This file is part of the QtSvg 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 "qsvggenerator.h"

#ifndef QT_NO_SVGGENERATOR

#include "qpainterpath.h"

#include "private/qpaintengine_p.h"

#include "private/qtextengine_p.h"

#include "private/qdrawhelper_p.h"

#include "qfile.h"

#include "qtextcodec.h"

#include "qtextstream.h"

#include "qbuffer.h"

#include "qmath.h"

#include "qdebug.h"

QT_BEGIN_NAMESPACE

static void translate_color(const QColor &color, QString *color_string,

                            QString *opacity_string)

{

    Q_ASSERT(color_string);

    Q_ASSERT(opacity_string);

    *color_string =

        QString::fromLatin1("#%1%2%3")

        .arg(color.red(), 2, 16, QLatin1Char('0'))

        .arg(color.green(), 2, 16, QLatin1Char('0'))

        .arg(color.blue(), 2, 16, QLatin1Char('0'));

    *opacity_string = QString::number(color.alphaF());

}

static void translate_dashPattern(QVector<qreal> pattern, const qreal& width, QString *pattern_string)

{

    Q_ASSERT(pattern_string);

    // Note that SVG operates in absolute lengths, whereas Qt uses a length/width ratio.

    foreach (qreal entry, pattern)

        *pattern_string += QString::fromLatin1("%1,").arg(entry * width);

    pattern_string->chop(1);

}

class QSvgPaintEnginePrivate : public QPaintEnginePrivate

{

public:

    QSvgPaintEnginePrivate()

    {

        size = QSize();

        viewBox = QRectF();

        outputDevice = 0;

        resolution = 72;

        attributes.document_title = QLatin1String("Qt Svg Document");

        attributes.document_description = QLatin1String("Generated with Qt");

        attributes.font_family = QLatin1String("serif");

        attributes.font_size = QLatin1String("10pt");

        attributes.font_style = QLatin1String("normal");

        attributes.font_weight = QLatin1String("normal");

        afterFirstUpdate = false;

        numGradients = 0;

    }

    QSize size;

    QRectF viewBox;

    QIODevice *outputDevice;

    QTextStream *stream;

    int resolution;

    QString header;

    QString defs;

    QString body;

    bool    afterFirstUpdate;

    QBrush brush;

    QPen pen;

    QMatrix matrix;

    QFont font;

    QString generateGradientName() {

        ++numGradients;

        currentGradientName = QString::fromLatin1("gradient%1").arg(numGradients);

        return currentGradientName;

    }

    QString currentGradientName;

    int numGradients;

    struct _attributes {

        QString document_title;

        QString document_description;

        QString font_weight;

        QString font_size;

        QString font_family;

        QString font_style;

        QString stroke, strokeOpacity;

        QString dashPattern, dashOffset;

        QString fill, fillOpacity;

    } attributes;

};

static inline QPaintEngine::PaintEngineFeatures svgEngineFeatures()

{

    return QPaintEngine::PaintEngineFeatures(

        QPaintEngine::AllFeatures

        & ~QPaintEngine::PatternBrush

        & ~QPaintEngine::PerspectiveTransform

        & ~QPaintEngine::ConicalGradientFill

        & ~QPaintEngine::PorterDuff);

}

class QSvgPaintEngine : public QPaintEngine

{

    Q_DECLARE_PRIVATE(QSvgPaintEngine)

public:

    QSvgPaintEngine()

        : QPaintEngine(*new QSvgPaintEnginePrivate,

                       svgEngineFeatures())

    {

    }

    bool begin(QPaintDevice *device);

    bool end();

    void updateState(const QPaintEngineState &state);

    void popGroup();

    void drawPath(const QPainterPath &path);

    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);

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

    void drawTextItem(const QPointF &pt, const QTextItem &item);

    void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,

                   Qt::ImageConversionFlag = Qt::AutoColor);

    QPaintEngine::Type type() const { return QPaintEngine::SVG; }

    QSize size() const { return d_func()->size; }

    void setSize(const QSize &size) {

        Q_ASSERT(!isActive());

        d_func()->size = size;

    }

    QRectF viewBox() const { return d_func()->viewBox; }

    void setViewBox(const QRectF &viewBox) {

        Q_ASSERT(!isActive());

        d_func()->viewBox = viewBox;

    }

    QString documentTitle() const { return d_func()->attributes.document_title; }

    void setDocumentTitle(const QString &title) {

        d_func()->attributes.document_title = title;

    }

    QString documentDescription() const { return d_func()->attributes.document_description; }

    void setDocumentDescription(const QString &description) {

        d_func()->attributes.document_description = description;

    }

    QIODevice *outputDevice() const { return d_func()->outputDevice; }

    void setOutputDevice(QIODevice *device) {

        Q_ASSERT(!isActive());

        d_func()->outputDevice = device;

    }

    int resolution() { return d_func()->resolution; }

    void setResolution(int resolution) {

        Q_ASSERT(!isActive());

        d_func()->resolution = resolution;

    }

    void saveLinearGradientBrush(const QGradient *g)

    {

        QTextStream str(&d_func()->defs, QIODevice::Append);

        const QLinearGradient *grad = static_cast<const QLinearGradient*>(g);

        str << QLatin1String("<linearGradient ");

        saveGradientUnits(str, g);

        if (grad) {

            str << QLatin1String("x1=\"") <<grad->start().x()<< QLatin1String("\" ")

                << QLatin1String("y1=\"") <<grad->start().y()<< QLatin1String("\" ")

                << QLatin1String("x2=\"") <<grad->finalStop().x() << QLatin1String("\" ")

                << QLatin1String("y2=\"") <<grad->finalStop().y() << QLatin1String("\" ");

        }

        str << QLatin1String("id=\"") << d_func()->generateGradientName() << QLatin1String("\">\n");

        saveGradientStops(str, g);

        str << QLatin1String("</linearGradient>") <<endl;

    }

    void saveRadialGradientBrush(const QGradient *g)

    {

        QTextStream str(&d_func()->defs, QIODevice::Append);

        const QRadialGradient *grad = static_cast<const QRadialGradient*>(g);

        str << QLatin1String("<radialGradient ");

        saveGradientUnits(str, g);

        if (grad) {

            str << QLatin1String("cx=\"") <<grad->center().x()<< QLatin1String("\" ")

                << QLatin1String("cy=\"") <<grad->center().y()<< QLatin1String("\" ")

                << QLatin1String("r=\"") <<grad->radius() << QLatin1String("\" ")

                << QLatin1String("fx=\"") <<grad->focalPoint().x() << QLatin1String("\" ")

                << QLatin1String("fy=\"") <<grad->focalPoint().y() << QLatin1String("\" ");

        }

        str << QLatin1String("xml:id=\"") <<d_func()->generateGradientName()<< QLatin1String("\">\n");

        saveGradientStops(str, g);

        str << QLatin1String("</radialGradient>") << endl;

    }

    void saveConicalGradientBrush(const QGradient *)

    {

        qWarning("svg's don't support conical gradients!");

    }

    void saveGradientStops(QTextStream &str, const QGradient *g) {

        QGradientStops stops = g->stops();

        if (g->interpolationMode() == QGradient::ColorInterpolation) {

            bool constantAlpha = true;

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

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

                constantAlpha &= (stops.at(i).second.alpha() == alpha);

            if (!constantAlpha) {

                const qreal spacing = qreal(0.02);

                QGradientStops newStops;

                QRgb fromColor = PREMUL(stops.at(0).second.rgba());

                QRgb toColor;

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

                    int parts = qCeil((stops.at(i + 1).first - stops.at(i).first) / spacing);

                    newStops.append(stops.at(i));

                    toColor = PREMUL(stops.at(i + 1).second.rgba());

                    if (parts > 1) {

                        qreal step = (stops.at(i + 1).first - stops.at(i).first) / parts;

                        for (int j = 1; j < parts; ++j) {

                            QRgb color = INV_PREMUL(INTERPOLATE_PIXEL_256(fromColor, 256 - 256 * j / parts, toColor, 256 * j / parts));

                            newStops.append(QGradientStop(stops.at(i).first + j * step, QColor::fromRgba(color)));

                        }

                    }

                    fromColor = toColor;

                }

                newStops.append(stops.back());

                stops = newStops;

            }

        }

        foreach(QGradientStop stop, stops) {

            QString color =

                QString::fromLatin1("#%1%2%3")

                .arg(stop.second.red(), 2, 16, QLatin1Char('0'))

                .arg(stop.second.green(), 2, 16, QLatin1Char('0'))

                .arg(stop.second.blue(), 2, 16, QLatin1Char('0'));

            str << QLatin1String("    <stop offset=\"")<< stop.first << QLatin1String("\" ")

                << QLatin1String("stop-color=\"") << color << QLatin1String("\" ")

                << QLatin1String("stop-opacity=\"") << stop.second.alphaF() <<QLatin1String("\" />\n");

        }

    }

    void saveGradientUnits(QTextStream &str, const QGradient *gradient)

    {

        str << QLatin1String("gradientUnits=\"");

        if (gradient && gradient->coordinateMode() == QGradient::ObjectBoundingMode)

            str << QLatin1String("objectBoundingBox");

        else

            str << QLatin1String("userSpaceOnUse");

        str << QLatin1String("\" ");

    }

    void generateQtDefaults()

    {

        *d_func()->stream << QLatin1String("fill=\"none\" ");

        *d_func()->stream << QLatin1String("stroke=\"black\" ");

        *d_func()->stream << QLatin1String("vector-effect=\"non-scaling-stroke\" ");

        *d_func()->stream << QLatin1String("stroke-width=\"1\" ");

        *d_func()->stream << QLatin1String("fill-rule=\"evenodd\" ");

        *d_func()->stream << QLatin1String("stroke-linecap=\"square\" ");

        *d_func()->stream << QLatin1String("stroke-linejoin=\"bevel\" ");

        *d_func()->stream << QLatin1String(">\n");

    }

    inline QTextStream &stream()

    {

        return *d_func()->stream;

    }

    void qpenToSvg(const QPen &spen)

    {

        QString width;

        d_func()->pen = spen;

        switch (spen.style()) {

        case Qt::NoPen:

            stream() << QLatin1String("stroke=\"none\" ");

            d_func()->attributes.stroke = QLatin1String("none");

            d_func()->attributes.strokeOpacity = QString();

            return;

            break;

        case Qt::SolidLine: {

            QString color, colorOpacity;

            translate_color(spen.color(), &color,

                            &colorOpacity);

            d_func()->attributes.stroke = color;

            d_func()->attributes.strokeOpacity = colorOpacity;

            stream() << QLatin1String("stroke=\"")<<color<< QLatin1String("\" ");

            stream() << QLatin1String("stroke-opacity=\"")<<colorOpacity<< QLatin1String("\" ");

        }

            break;

        case Qt::DashLine:

        case Qt::DotLine:

        case Qt::DashDotLine:

        case Qt::DashDotDotLine:

        case Qt::CustomDashLine: {

            QString color, colorOpacity, dashPattern, dashOffset;

            qreal penWidth = spen.width() == 0 ? qreal(1) : spen.widthF();

            translate_color(spen.color(), &color, &colorOpacity);

            translate_dashPattern(spen.dashPattern(), penWidth, &dashPattern);

            // SVG uses absolute offset

            dashOffset = QString::number(spen.dashOffset() * penWidth);

            d_func()->attributes.stroke = color;

            d_func()->attributes.strokeOpacity = colorOpacity;

            d_func()->attributes.dashPattern = dashPattern;

            d_func()->attributes.dashOffset = dashOffset;

            stream() << QLatin1String("stroke=\"")<<color<< QLatin1String("\" ");

            stream() << QLatin1String("stroke-opacity=\"")<<colorOpacity<< QLatin1String("\" ");

            stream() << QLatin1String("stroke-dasharray=\"")<<dashPattern<< QLatin1String("\" ");

            stream() << QLatin1String("stroke-dashoffset=\"")<<dashOffset<< QLatin1String("\" ");

            break;

        }

        default:

            qWarning("Unsupported pen style");

            break;

        }

        if (spen.widthF() == 0) {

            width = QLatin1String("1");

            stream() << "vector-effect=\"non-scaling-stroke\" ";

        }

        else

            width = QString::number(spen.widthF());

        stream() <<"stroke-width=\""<<width<<"\" ";

        switch (spen.capStyle()) {

        case Qt::FlatCap:

            stream() << "stroke-linecap=\"butt\" ";

            break;

        case Qt::SquareCap:

            stream() << "stroke-linecap=\"square\" ";

            break;

        case Qt::RoundCap:

            stream() << "stroke-linecap=\"round\" ";

            break;

        default:

            qWarning("Unhandled cap style");

        }

        switch (spen.joinStyle()) {

        case Qt::MiterJoin:

            stream() << "stroke-linejoin=\"miter\" "

                        "stroke-miterlimit=\""<<spen.miterLimit()<<"\" ";

            break;

        case Qt::BevelJoin:

            stream() << "stroke-linejoin=\"bevel\" ";

            break;

        case Qt::RoundJoin:

            stream() << "stroke-linejoin=\"round\" ";

            break;

        case Qt::SvgMiterJoin:

            stream() << "stroke-linejoin=\"miter\" "

                        "stroke-miterlimit=\""<<spen.miterLimit()<<"\" ";

            break;

        default:

            qWarning("Unhandled join style");

        }

    }

    void qbrushToSvg(const QBrush &sbrush)

    {

        d_func()->brush = sbrush;

        switch (sbrush.style()) {

        case Qt::SolidPattern: {

            QString color, colorOpacity;

            translate_color(sbrush.color(), &color, &colorOpacity);

            stream() << "fill=\"" << color << "\" "

                        "fill-opacity=\""

                     << colorOpacity << "\" ";

            d_func()->attributes.fill = color;

            d_func()->attributes.fillOpacity = colorOpacity;

        }

            break;

        case Qt::LinearGradientPattern:

            saveLinearGradientBrush(sbrush.gradient());

            d_func()->attributes.fill = QString::fromLatin1("url(#%1)").arg(d_func()->currentGradientName);

            d_func()->attributes.fillOpacity = QString();

            stream() << QLatin1String("fill=\"url(#") << d_func()->currentGradientName << QLatin1String(")\" ");

            break;

        case Qt::RadialGradientPattern:

            saveRadialGradientBrush(sbrush.gradient());

            d_func()->attributes.fill = QString::fromLatin1("url(#%1)").arg(d_func()->currentGradientName);

            d_func()->attributes.fillOpacity = QString();

            stream() << QLatin1String("fill=\"url(#") << d_func()->currentGradientName << QLatin1String(")\" ");

            break;

        case Qt::ConicalGradientPattern:

            saveConicalGradientBrush(sbrush.gradient());

            d_func()->attributes.fill = QString::fromLatin1("url(#%1)").arg(d_func()->currentGradientName);

            d_func()->attributes.fillOpacity = QString();

            stream() << QLatin1String("fill=\"url(#") << d_func()->currentGradientName << QLatin1String(")\" ");

            break;

        case Qt::NoBrush:

            stream() << QLatin1String("fill=\"none\" ");

            d_func()->attributes.fill = QLatin1String("none");

            d_func()->attributes.fillOpacity = QString();

            return;

            break;

        default:

           break;

        }

    }

    void qfontToSvg(const QFont &sfont)

    {

        Q_D(QSvgPaintEngine);

        d->font = sfont;

        if (d->font.pixelSize() == -1)

            d->attributes.font_size = QString::number(d->font.pointSizeF() * d->resolution / 72);

        else

            d->attributes.font_size = QString::number(d->font.pixelSize());

        int svgWeight = d->font.weight();

        switch (svgWeight) {

        case QFont::Light:

            svgWeight = 100;

            break;

        case QFont::Normal:

            svgWeight = 400;

            break;

        case QFont::Bold:

            svgWeight = 700;

            break;

        default:

            svgWeight *= 10;

        }

        d->attributes.font_weight = QString::number(svgWeight);

        d->attributes.font_family = d->font.family();

        d->attributes.font_style = d->font.italic() ? QLatin1String("italic") : QLatin1String("normal");

        *d->stream << "font-family=\"" << d->attributes.font_family << "\" "

                      "font-size=\"" << d->attributes.font_size << "\" "

                      "font-weight=\"" << d->attributes.font_weight << "\" "

                      "font-style=\"" << d->attributes.font_style << "\" "

                   << endl;

    }

};

class QSvgGeneratorPrivate

{

public:

    QSvgPaintEngine *engine;

    uint owns_iodevice : 1;

    QString fileName;

};

/*!

    \class QSvgGenerator

    \ingroup painting

    \since 4.3

    \brief The QSvgGenerator class provides a paint device that is used to create SVG drawings.

    \reentrant

    This paint device represents a Scalable Vector Graphics (SVG) drawing. Like QPrinter, it is

    designed as a write-only device that generates output in a specific format.

    To write an SVG file, you first need to configure the output by setting the \l fileName

    or \l outputDevice properties. It is usually necessary to specify the size of the drawing

    by setting the \l size property, and in some cases where the drawing will be included in

    another, the \l viewBox property also needs to be set.

    \snippet examples/painting/svggenerator/window.cpp configure SVG generator