src/svg/qsvggenerator.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 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 QtSvg 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
  42 #include "qsvggenerator.h"
  43
  44 #ifndef QT_NO_SVGGENERATOR
  45
  46 #include "qpainterpath.h"
  47
  48 #include "private/qpaintengine_p.h"
  49 #include "private/qtextengine_p.h"
  50 #include "private/qdrawhelper_p.h"
  51
  52 #include "qfile.h"
  53 #include "qtextcodec.h"
  54 #include "qtextstream.h"
  55 #include "qbuffer.h"
  56 #include "qmath.h"
  57
  58 #include "qdebug.h"
  59
  60 QT_BEGIN_NAMESPACE
  61
  62 static void translate_color(const QColor &color, QString *color_string,
  63                             QString *opacity_string)
  64 {
  65     Q_ASSERT(color_string);
  66     Q_ASSERT(opacity_string);
  67
  68     *color_string =
  69         QString::fromLatin1("#%1%2%3")
  70         .arg(color.red(), 2, 16, QLatin1Char('0'))
  71         .arg(color.green(), 2, 16, QLatin1Char('0'))
  72         .arg(color.blue(), 2, 16, QLatin1Char('0'));
  73     *opacity_string = QString::number(color.alphaF());
  74 }
  75
  76 static void translate_dashPattern(QVector<qreal> pattern, const qreal& width, QString *pattern_string)
  77 {
  78     Q_ASSERT(pattern_string);
  79
  80     // Note that SVG operates in absolute lengths, whereas Qt uses a length/width ratio.
  81     foreach (qreal entry, pattern)
  82         *pattern_string += QString::fromLatin1("%1,").arg(entry * width);
  83
  84     pattern_string->chop(1);
  85 }
  86
  87 class QSvgPaintEnginePrivate : public QPaintEnginePrivate
  88 {
  89 public:
  90     QSvgPaintEnginePrivate()
  91     {
  92         size = QSize();
  93         viewBox = QRectF();
  94         outputDevice = 0;
  95         resolution = 72;
  96
  97         attributes.document_title = QLatin1String("Qt Svg Document");
  98         attributes.document_description = QLatin1String("Generated with Qt");
  99         attributes.font_family = QLatin1String("serif");
 100         attributes.font_size = QLatin1String("10pt");
 101         attributes.font_style = QLatin1String("normal");
 102         attributes.font_weight = QLatin1String("normal");
 103
 104         afterFirstUpdate = false;
 105         numGradients = 0;
 106     }
 107
 108     QSize size;
 109     QRectF viewBox;
 110     QIODevice *outputDevice;
 111     QTextStream *stream;
 112     int resolution;
 113
 114     QString header;
 115     QString defs;
 116     QString body;
 117     bool    afterFirstUpdate;
 118
 119     QBrush brush;
 120     QPen pen;
 121     QMatrix matrix;
 122     QFont font;
 123
 124     QString generateGradientName() {
 125         ++numGradients;
 126         currentGradientName = QString::fromLatin1("gradient%1").arg(numGradients);
 127         return currentGradientName;
 128     }
 129
 130     QString currentGradientName;
 131     int numGradients;
 132
 133     struct _attributes {
 134         QString document_title;
 135         QString document_description;
 136         QString font_weight;
 137         QString font_size;
 138         QString font_family;
 139         QString font_style;
 140         QString stroke, strokeOpacity;
 141         QString dashPattern, dashOffset;
 142         QString fill, fillOpacity;
 143     } attributes;
 144 };
 145
 146 static inline QPaintEngine::PaintEngineFeatures svgEngineFeatures()
 147 {
 148     return QPaintEngine::PaintEngineFeatures(
 149         QPaintEngine::AllFeatures
 150         & ~QPaintEngine::PatternBrush
 151         & ~QPaintEngine::PerspectiveTransform
 152         & ~QPaintEngine::ConicalGradientFill
 153         & ~QPaintEngine::PorterDuff);
 154 }
 155
 156 class QSvgPaintEngine : public QPaintEngine
 157 {
 158     Q_DECLARE_PRIVATE(QSvgPaintEngine)
 159 public:
 160
 161     QSvgPaintEngine()
 162         : QPaintEngine(*new QSvgPaintEnginePrivate,
 163                        svgEngineFeatures())
 164     {
 165     }
 166
 167     bool begin(QPaintDevice *device);
 168     bool end();
 169
 170     void updateState(const QPaintEngineState &state);
 171     void popGroup();
 172
 173     void drawPath(const QPainterPath &path);
 174     void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
 175     void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
 176     void drawTextItem(const QPointF &pt, const QTextItem &item);
 177     void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
 178                    Qt::ImageConversionFlag = Qt::AutoColor);
 179
 180     QPaintEngine::Type type() const { return QPaintEngine::SVG; }
 181
 182     QSize size() const { return d_func()->size; }
 183     void setSize(const QSize &size) {
 184         Q_ASSERT(!isActive());
 185         d_func()->size = size;
 186     }
 187
 188     QRectF viewBox() const { return d_func()->viewBox; }
 189     void setViewBox(const QRectF &viewBox) {
 190         Q_ASSERT(!isActive());
 191         d_func()->viewBox = viewBox;
 192     }
 193
 194     QString documentTitle() const { return d_func()->attributes.document_title; }
 195     void setDocumentTitle(const QString &title) {
 196         d_func()->attributes.document_title = title;
 197     }
 198
 199     QString documentDescription() const { return d_func()->attributes.document_description; }
 200     void setDocumentDescription(const QString &description) {
 201         d_func()->attributes.document_description = description;
 202     }
 203
 204     QIODevice *outputDevice() const { return d_func()->outputDevice; }
 205     void setOutputDevice(QIODevice *device) {
 206         Q_ASSERT(!isActive());
 207         d_func()->outputDevice = device;
 208     }
 209
 210     int resolution() { return d_func()->resolution; }
 211     void setResolution(int resolution) {
 212         Q_ASSERT(!isActive());
 213         d_func()->resolution = resolution;
 214     }
 215     void saveLinearGradientBrush(const QGradient *g)
 216     {
 217         QTextStream str(&d_func()->defs, QIODevice::Append);
 218         const QLinearGradient *grad = static_cast<const QLinearGradient*>(g);
 219         str << QLatin1String("<linearGradient ");
 220         saveGradientUnits(str, g);
 221         if (grad) {
 222             str << QLatin1String("x1=\"") <<grad->start().x()<< QLatin1String("\" ")
 223                 << QLatin1String("y1=\"") <<grad->start().y()<< QLatin1String("\" ")
 224                 << QLatin1String("x2=\"") <<grad->finalStop().x() << QLatin1String("\" ")
 225                 << QLatin1String("y2=\"") <<grad->finalStop().y() << QLatin1String("\" ");
 226         }
 227
 228         str << QLatin1String("id=\"") << d_func()->generateGradientName() << QLatin1String("\">\n");
 229         saveGradientStops(str, g);
 230         str << QLatin1String("</linearGradient>") <<endl;
 231     }
 232     void saveRadialGradientBrush(const QGradient *g)
 233     {
 234         QTextStream str(&d_func()->defs, QIODevice::Append);
 235         const QRadialGradient *grad = static_cast<const QRadialGradient*>(g);
 236         str << QLatin1String("<radialGradient ");
 237         saveGradientUnits(str, g);
 238         if (grad) {
 239             str << QLatin1String("cx=\"") <<grad->center().x()<< QLatin1String("\" ")
 240                 << QLatin1String("cy=\"") <<grad->center().y()<< QLatin1String("\" ")
 241                 << QLatin1String("r=\"") <<grad->radius() << QLatin1String("\" ")
 242                 << QLatin1String("fx=\"") <<grad->focalPoint().x() << QLatin1String("\" ")
 243                 << QLatin1String("fy=\"") <<grad->focalPoint().y() << QLatin1String("\" ");
 244         }
 245         str << QLatin1String("xml:id=\"") <<d_func()->generateGradientName()<< QLatin1String("\">\n");
 246         saveGradientStops(str, g);
 247         str << QLatin1String("</radialGradient>") << endl;
 248     }
 249     void saveConicalGradientBrush(const QGradient *)
 250     {
 251         qWarning("svg's don't support conical gradients!");
 252     }
 253
 254     void saveGradientStops(QTextStream &str, const QGradient *g) {
 255         QGradientStops stops = g->stops();
 256
 257         if (g->interpolationMode() == QGradient::ColorInterpolation) {
 258             bool constantAlpha = true;
 259             int alpha = stops.at(0).second.alpha();
 260             for (int i = 1; i < stops.size(); ++i)
 261                 constantAlpha &= (stops.at(i).second.alpha() == alpha);
 262
 263             if (!constantAlpha) {
 264                 const qreal spacing = qreal(0.02);
 265                 QGradientStops newStops;
 266                 QRgb fromColor = PREMUL(stops.at(0).second.rgba());
 267                 QRgb toColor;
 268                 for (int i = 0; i + 1 < stops.size(); ++i) {
 269                     int parts = qCeil((stops.at(i + 1).first - stops.at(i).first) / spacing);
 270                     newStops.append(stops.at(i));
 271                     toColor = PREMUL(stops.at(i + 1).second.rgba());
 272
 273                     if (parts > 1) {
 274                         qreal step = (stops.at(i + 1).first - stops.at(i).first) / parts;
 275                         for (int j = 1; j < parts; ++j) {
 276                             QRgb color = INV_PREMUL(INTERPOLATE_PIXEL_256(fromColor, 256 - 256 * j / parts, toColor, 256 * j / parts));
 277                             newStops.append(QGradientStop(stops.at(i).first + j * step, QColor::fromRgba(color)));
 278                         }
 279                     }
 280                     fromColor = toColor;
 281                 }
 282                 newStops.append(stops.back());
 283                 stops = newStops;
 284             }
 285         }
 286
 287         foreach(QGradientStop stop, stops) {
 288             QString color =
 289                 QString::fromLatin1("#%1%2%3")
 290                 .arg(stop.second.red(), 2, 16, QLatin1Char('0'))
 291                 .arg(stop.second.green(), 2, 16, QLatin1Char('0'))
 292                 .arg(stop.second.blue(), 2, 16, QLatin1Char('0'));
 293             str << QLatin1String("    <stop offset=\"")<< stop.first << QLatin1String("\" ")
 294                 << QLatin1String("stop-color=\"") << color << QLatin1String("\" ")
 295                 << QLatin1String("stop-opacity=\"") << stop.second.alphaF() <<QLatin1String("\" />\n");
 296         }
 297     }
 298
 299     void saveGradientUnits(QTextStream &str, const QGradient *gradient)
 300     {
 301         str << QLatin1String("gradientUnits=\"");
 302         if (gradient && gradient->coordinateMode() == QGradient::ObjectBoundingMode)
 303             str << QLatin1String("objectBoundingBox");
 304         else
 305             str << QLatin1String("userSpaceOnUse");
 306         str << QLatin1String("\" ");
 307     }
 308
 309     void generateQtDefaults()
 310     {
 311         *d_func()->stream << QLatin1String("fill=\"none\" ");
 312         *d_func()->stream << QLatin1String("stroke=\"black\" ");
 313         *d_func()->stream << QLatin1String("vector-effect=\"non-scaling-stroke\" ");
 314         *d_func()->stream << QLatin1String("stroke-width=\"1\" ");
 315         *d_func()->stream << QLatin1String("fill-rule=\"evenodd\" ");
 316         *d_func()->stream << QLatin1String("stroke-linecap=\"square\" ");
 317         *d_func()->stream << QLatin1String("stroke-linejoin=\"bevel\" ");
 318         *d_func()->stream << QLatin1String(">\n");
 319     }
 320     inline QTextStream &stream()
 321     {
 322         return *d_func()->stream;
 323     }
 324
 325
 326     void qpenToSvg(const QPen &spen)
 327     {
 328         QString width;
 329
 330         d_func()->pen = spen;
 331
 332         switch (spen.style()) {
 333         case Qt::NoPen:
 334             stream() << QLatin1String("stroke=\"none\" ");
 335
 336             d_func()->attributes.stroke = QLatin1String("none");
 337             d_func()->attributes.strokeOpacity = QString();
 338             return;
 339             break;
 340         case Qt::SolidLine: {
 341             QString color, colorOpacity;
 342
 343             translate_color(spen.color(), &color,
 344                             &colorOpacity);
 345             d_func()->attributes.stroke = color;
 346             d_func()->attributes.strokeOpacity = colorOpacity;
 347
 348             stream() << QLatin1String("stroke=\"")<<color<< QLatin1String("\" ");
 349             stream() << QLatin1String("stroke-opacity=\"")<<colorOpacity<< QLatin1String("\" ");
 350         }
 351             break;
 352         case Qt::DashLine:
 353         case Qt::DotLine:
 354         case Qt::DashDotLine:
 355         case Qt::DashDotDotLine:
 356         case Qt::CustomDashLine: {
 357             QString color, colorOpacity, dashPattern, dashOffset;
 358
 359             qreal penWidth = spen.width() == 0 ? qreal(1) : spen.widthF();
 360
 361             translate_color(spen.color(), &color, &colorOpacity);
 362             translate_dashPattern(spen.dashPattern(), penWidth, &dashPattern);
 363
 364             // SVG uses absolute offset
 365             dashOffset = QString::number(spen.dashOffset() * penWidth);
 366
 367             d_func()->attributes.stroke = color;
 368             d_func()->attributes.strokeOpacity = colorOpacity;
 369             d_func()->attributes.dashPattern = dashPattern;
 370             d_func()->attributes.dashOffset = dashOffset;
 371
 372             stream() << QLatin1String("stroke=\"")<<color<< QLatin1String("\" ");
 373             stream() << QLatin1String("stroke-opacity=\"")<<colorOpacity<< QLatin1String("\" ");
 374             stream() << QLatin1String("stroke-dasharray=\"")<<dashPattern<< QLatin1String("\" ");
 375             stream() << QLatin1String("stroke-dashoffset=\"")<<dashOffset<< QLatin1String("\" ");
 376             break;
 377         }
 378         default:
 379             qWarning("Unsupported pen style");
 380             break;
 381         }
 382
 383         if (spen.widthF() == 0) {
 384             width = QLatin1String("1");
 385             stream() << "vector-effect=\"non-scaling-stroke\" ";
 386         }
 387         else
 388             width = QString::number(spen.widthF());
 389         stream() <<"stroke-width=\""<<width<<"\" ";
 390
 391         switch (spen.capStyle()) {
 392         case Qt::FlatCap:
 393             stream() << "stroke-linecap=\"butt\" ";
 394             break;
 395         case Qt::SquareCap:
 396             stream() << "stroke-linecap=\"square\" ";
 397             break;
 398         case Qt::RoundCap:
 399             stream() << "stroke-linecap=\"round\" ";
 400             break;
 401         default:
 402             qWarning("Unhandled cap style");
 403         }
 404         switch (spen.joinStyle()) {
 405         case Qt::MiterJoin:
 406             stream() << "stroke-linejoin=\"miter\" "
 407                         "stroke-miterlimit=\""<<spen.miterLimit()<<"\" ";
 408             break;
 409         case Qt::BevelJoin:
 410             stream() << "stroke-linejoin=\"bevel\" ";
 411             break;
 412         case Qt::RoundJoin:
 413             stream() << "stroke-linejoin=\"round\" ";
 414             break;
 415         case Qt::SvgMiterJoin:
 416             stream() << "stroke-linejoin=\"miter\" "
 417                         "stroke-miterlimit=\""<<spen.miterLimit()<<"\" ";
 418             break;
 419         default:
 420             qWarning("Unhandled join style");
 421         }
 422     }
 423     void qbrushToSvg(const QBrush &sbrush)
 424     {
 425         d_func()->brush = sbrush;
 426         switch (sbrush.style()) {
 427         case Qt::SolidPattern: {
 428             QString color, colorOpacity;
 429             translate_color(sbrush.color(), &color, &colorOpacity);
 430             stream() << "fill=\"" << color << "\" "
 431                         "fill-opacity=\""
 432                      << colorOpacity << "\" ";
 433             d_func()->attributes.fill = color;
 434             d_func()->attributes.fillOpacity = colorOpacity;
 435         }
 436             break;
 437         case Qt::LinearGradientPattern:
 438             saveLinearGradientBrush(sbrush.gradient());
 439             d_func()->attributes.fill = QString::fromLatin1("url(#%1)").arg(d_func()->currentGradientName);
 440             d_func()->attributes.fillOpacity = QString();
 441             stream() << QLatin1String("fill=\"url(#") << d_func()->currentGradientName << QLatin1String(")\" ");
 442             break;
 443         case Qt::RadialGradientPattern:
 444             saveRadialGradientBrush(sbrush.gradient());
 445             d_func()->attributes.fill = QString::fromLatin1("url(#%1)").arg(d_func()->currentGradientName);
 446             d_func()->attributes.fillOpacity = QString();
 447             stream() << QLatin1String("fill=\"url(#") << d_func()->currentGradientName << QLatin1String(")\" ");
 448             break;
 449         case Qt::ConicalGradientPattern:
 450             saveConicalGradientBrush(sbrush.gradient());
 451             d_func()->attributes.fill = QString::fromLatin1("url(#%1)").arg(d_func()->currentGradientName);
 452             d_func()->attributes.fillOpacity = QString();
 453             stream() << QLatin1String("fill=\"url(#") << d_func()->currentGradientName << QLatin1String(")\" ");
 454             break;
 455         case Qt::NoBrush:
 456             stream() << QLatin1String("fill=\"none\" ");
 457             d_func()->attributes.fill = QLatin1String("none");
 458             d_func()->attributes.fillOpacity = QString();
 459             return;
 460             break;
 461         default:
 462            break;
 463         }
 464     }
 465     void qfontToSvg(const QFont &sfont)
 466     {
 467         Q_D(QSvgPaintEngine);
 468
 469         d->font = sfont;
 470
 471         if (d->font.pixelSize() == -1)
 472             d->attributes.font_size = QString::number(d->font.pointSizeF() * d->resolution / 72);
 473         else
 474             d->attributes.font_size = QString::number(d->font.pixelSize());
 475
 476         int svgWeight = d->font.weight();
 477         switch (svgWeight) {
 478         case QFont::Light:
 479             svgWeight = 100;
 480             break;
 481         case QFont::Normal:
 482             svgWeight = 400;
 483             break;
 484         case QFont::Bold:
 485             svgWeight = 700;
 486             break;
 487         default:
 488             svgWeight *= 10;
 489         }
 490
 491         d->attributes.font_weight = QString::number(svgWeight);
 492         d->attributes.font_family = d->font.family();
 493         d->attributes.font_style = d->font.italic() ? QLatin1String("italic") : QLatin1String("normal");
 494
 495         *d->stream << "font-family=\"" << d->attributes.font_family << "\" "
 496                       "font-size=\"" << d->attributes.font_size << "\" "
 497                       "font-weight=\"" << d->attributes.font_weight << "\" "
 498                       "font-style=\"" << d->attributes.font_style << "\" "
 499                    << endl;
 500     }
 501 };
 502
 503 class QSvgGeneratorPrivate
 504 {
 505 public:
 506     QSvgPaintEngine *engine;
 507
 508     uint owns_iodevice : 1;
 509     QString fileName;
 510 };
 511
 512 /*!
 513     \class QSvgGenerator
 514     \ingroup painting
 515     \since 4.3
 516     \brief The QSvgGenerator class provides a paint device that is used to create SVG drawings.
 517     \reentrant
 518
 519     This paint device represents a Scalable Vector Graphics (SVG) drawing. Like QPrinter, it is
 520     designed as a write-only device that generates output in a specific format.
 521
 522     To write an SVG file, you first need to configure the output by setting the \l fileName
 523     or \l outputDevice properties. It is usually necessary to specify the size of the drawing
 524     by setting the \l size property, and in some cases where the drawing will be included in
 525     another, the \l viewBox property also needs to be set.
 526
 527     \snippet examples/painting/svggenerator/window.cpp configure SVG generator
 528
 529     Other meta-data can be specified by setting the \a title, \a description and \a resolution
 530     properties.
 531
 532     As with other QPaintDevice subclasses, a QPainter object is used to paint onto an instance
 533     of this class:
 534
 535     \snippet examples/painting/svggenerator/window.cpp begin painting
 536     \dots
 537     \snippet examples/painting/svggenerator/window.cpp end painting
 538
 539     Painting is performed in the same way as for any other paint device. However,
 540     it is necessary to use the QPainter::begin() and \l{QPainter::}{end()} to
 541     explicitly begin and end painting on the device.
 542
 543     The \l{SVG Generator Example} shows how the same painting commands can be used
 544     for painting a widget and writing an SVG file.
 545
 546     \sa QSvgRenderer, QSvgWidget, {About SVG}
 547 */
 548
 549 /*!
 550     Constructs a new generator.
 551 */
 552 QSvgGenerator::QSvgGenerator()
 553     : d_ptr(new QSvgGeneratorPrivate)
 554 {
 555     Q_D(QSvgGenerator);
 556
 557     d->engine = new QSvgPaintEngine;
 558     d->owns_iodevice = false;
 559 }
 560
 561 /*!
 562     Destroys the generator.
 563 */
 564 QSvgGenerator::~QSvgGenerator()
 565 {
 566     Q_D(QSvgGenerator);
 567     if (d->owns_iodevice)
 568         delete d->engine->outputDevice();
 569     delete d->engine;
 570 }
 571
 572 /*!
 573     \property QSvgGenerator::title
 574     \brief the title of the generated SVG drawing
 575     \since 4.5
 576     \sa description
 577 */
 578 QString QSvgGenerator::title() const
 579 {
 580     Q_D(const QSvgGenerator);
 581
 582     return d->engine->documentTitle();
 583 }
 584
 585 void QSvgGenerator::setTitle(const QString &title)
 586 {
 587     Q_D(QSvgGenerator);
 588
 589     d->engine->setDocumentTitle(title);
 590 }
 591
 592 /*!
 593     \property QSvgGenerator::description
 594     \brief the description of the generated SVG drawing
 595     \since 4.5
 596     \sa title
 597 */
 598 QString QSvgGenerator::description() const
 599 {
 600     Q_D(const QSvgGenerator);
 601
 602     return d->engine->documentDescription();
 603 }
 604
 605 void QSvgGenerator::setDescription(const QString &description)
 606 {
 607     Q_D(QSvgGenerator);
 608
 609     d->engine->setDocumentDescription(description);
 610 }
 611
 612 /*!
 613     \property QSvgGenerator::size
 614     \brief the size of the generated SVG drawing
 615     \since 4.5
 616
 617     By default this property is set to \c{QSize(-1, -1)}, which
 618     indicates that the generator should not output the width and
 619     height attributes of the \c<svg> element.
 620
 621     \note It is not possible to change this property while a
 622     QPainter is active on the generator.
 623
 624     \sa viewBox, resolution
 625 */
 626 QSize QSvgGenerator::size() const
 627 {
 628     Q_D(const QSvgGenerator);
 629     return d->engine->size();
 630 }
 631
 632 void QSvgGenerator::setSize(const QSize &size)
 633 {
 634     Q_D(QSvgGenerator);
 635     if (d->engine->isActive()) {
 636         qWarning("QSvgGenerator::setSize(), cannot set size while SVG is being generated");
 637         return;
 638     }
 639     d->engine->setSize(size);
 640 }
 641
 642 /*!
 643     \property QSvgGenerator::viewBox
 644     \brief the viewBox of the generated SVG drawing
 645     \since 4.5
 646
 647     By default this property is set to \c{QRect(0, 0, -1, -1)}, which
 648     indicates that the generator should not output the viewBox attribute
 649     of the \c<svg> element.
 650
 651     \note It is not possible to change this property while a
 652     QPainter is active on the generator.
 653
 654     \sa viewBox(), size, resolution
 655 */
 656 QRectF QSvgGenerator::viewBoxF() const
 657 {
 658     Q_D(const QSvgGenerator);
 659     return d->engine->viewBox();
 660 }
 661
 662 /*!
 663     \since 4.5
 664
 665     Returns viewBoxF().toRect().
 666
 667     \sa viewBoxF()
 668 */
 669 QRect QSvgGenerator::viewBox() const
 670 {
 671     Q_D(const QSvgGenerator);
 672     return d->engine->viewBox().toRect();
 673 }
 674
 675 void QSvgGenerator::setViewBox(const QRectF &viewBox)
 676 {
 677     Q_D(QSvgGenerator);
 678     if (d->engine->isActive()) {
 679         qWarning("QSvgGenerator::setViewBox(), cannot set viewBox while SVG is being generated");
 680         return;
 681     }
 682     d->engine->setViewBox(viewBox);
 683 }
 684
 685 void QSvgGenerator::setViewBox(const QRect &viewBox)
 686 {
 687     setViewBox(QRectF(viewBox));
 688 }
 689
 690 /*!
 691     \property QSvgGenerator::fileName
 692     \brief the target filename for the generated SVG drawing
 693     \since 4.5
 694
 695     \sa outputDevice
 696 */
 697 QString QSvgGenerator::fileName() const
 698 {
 699     Q_D(const QSvgGenerator);
 700     return d->fileName;
 701 }
 702
 703 void QSvgGenerator::setFileName(const QString &fileName)
 704 {
 705     Q_D(QSvgGenerator);
 706     if (d->engine->isActive()) {
 707         qWarning("QSvgGenerator::setFileName(), cannot set file name while SVG is being generated");
 708         return;
 709     }
 710
 711     if (d->owns_iodevice)
 712         delete d->engine->outputDevice();
 713
 714     d->owns_iodevice = true;
 715
 716     d->fileName = fileName;
 717     QFile *file = new QFile(fileName);
 718     d->engine->setOutputDevice(file);
 719 }
 720
 721 /*!
 722     \property QSvgGenerator::outputDevice
 723     \brief the output device for the generated SVG drawing
 724     \since 4.5
 725
 726     If both output device and file name are specified, the output device
 727     will have precedence.
 728
 729     \sa fileName
 730 */
 731 QIODevice *QSvgGenerator::outputDevice() const
 732 {
 733     Q_D(const QSvgGenerator);
 734     return d->engine->outputDevice();
 735 }
 736
 737 void QSvgGenerator::setOutputDevice(QIODevice *outputDevice)
 738 {
 739     Q_D(QSvgGenerator);
 740     if (d->engine->isActive()) {
 741         qWarning("QSvgGenerator::setOutputDevice(), cannot set output device while SVG is being generated");
 742         return;
 743     }
 744     d->owns_iodevice = false;
 745     d->engine->setOutputDevice(outputDevice);
 746     d->fileName = QString();
 747 }
 748
 749 /*!
 750     \property QSvgGenerator::resolution
 751     \brief the resolution of the generated output
 752     \since 4.5
 753
 754     The resolution is specified in dots per inch, and is used to
 755     calculate the physical size of an SVG drawing.
 756
 757     \sa size, viewBox
 758 */
 759 int QSvgGenerator::resolution() const
 760 {
 761     Q_D(const QSvgGenerator);
 762     return d->engine->resolution();
 763 }
 764
 765 void QSvgGenerator::setResolution(int dpi)
 766 {
 767     Q_D(QSvgGenerator);
 768     d->engine->setResolution(dpi);
 769 }
 770
 771 /*!
 772     Returns the paint engine used to render graphics to be converted to SVG
 773     format information.
 774 */
 775 QPaintEngine *QSvgGenerator::paintEngine() const
 776 {
 777     Q_D(const QSvgGenerator);
 778     return d->engine;
 779 }
 780
 781 /*!
 782     \reimp
 783 */
 784 int QSvgGenerator::metric(QPaintDevice::PaintDeviceMetric metric) const
 785 {
 786     Q_D(const QSvgGenerator);
 787     switch (metric) {
 788     case QPaintDevice::PdmDepth:
 789         return 32;
 790     case QPaintDevice::PdmWidth:
 791         return d->engine->size().width();
 792     case QPaintDevice::PdmHeight:
 793         return d->engine->size().height();
 794     case QPaintDevice::PdmDpiX:
 795         return d->engine->resolution();
 796     case QPaintDevice::PdmDpiY:
 797         return d->engine->resolution();
 798     case QPaintDevice::PdmHeightMM:
 799         return qRound(d->engine->size().height() * 25.4 / d->engine->resolution());
 800     case QPaintDevice::PdmWidthMM:
 801         return qRound(d->engine->size().width() * 25.4 / d->engine->resolution());
 802     case QPaintDevice::PdmNumColors:
 803         return 0xffffffff;
 804     case QPaintDevice::PdmPhysicalDpiX:
 805         return d->engine->resolution();
 806     case QPaintDevice::PdmPhysicalDpiY:
 807         return d->engine->resolution();
 808     default:
 809         qWarning("QSvgGenerator::metric(), unhandled metric %d\n", metric);
 810         break;
 811     }
 812     return 0;
 813 }
 814
 815 /*****************************************************************************
 816  * class QSvgPaintEngine
 817  */
 818
 819 bool QSvgPaintEngine::begin(QPaintDevice *)
 820 {
 821     Q_D(QSvgPaintEngine);
 822     if (!d->outputDevice) {
 823         qWarning("QSvgPaintEngine::begin(), no output device");
 824         return false;
 825     }
 826
 827     if (!d->outputDevice->isOpen()) {
 828         if (!d->outputDevice->open(QIODevice::WriteOnly | QIODevice::Text)) {
 829             qWarning("QSvgPaintEngine::begin(), could not open output device: '%s'",
 830                      qPrintable(d->outputDevice->errorString()));
 831             return false;
 832         }
 833     } else if (!d->outputDevice->isWritable()) {
 834         qWarning("QSvgPaintEngine::begin(), could not write to read-only output device: '%s'",
 835                  qPrintable(d->outputDevice->errorString()));
 836         return false;
 837     }
 838
 839     d->stream = new QTextStream(&d->header);
 840
 841     // stream out the header...
 842     *d->stream << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>" << endl << "<svg";
 843
 844     if (d->size.isValid()) {
 845         qreal wmm = d->size.width() * 25.4 / d->resolution;
 846         qreal hmm = d->size.height() * 25.4 / d->resolution;
 847         *d->stream << " width=\"" << wmm << "mm\" height=\"" << hmm << "mm\"" << endl;
 848     }
 849
 850     if (d->viewBox.isValid()) {
 851         *d->stream << " viewBox=\"" << d->viewBox.left() << ' ' << d->viewBox.top();
 852         *d->stream << ' ' << d->viewBox.width() << ' ' << d->viewBox.height() << '\"' << endl;
 853     }
 854
 855     *d->stream << " xmlns=\"http://www.w3.org/2000/svg\""
 856                   " xmlns:xlink=\"http://www.w3.org/1999/xlink\" "
 857                   " version=\"1.2\" baseProfile=\"tiny\">" << endl;
 858
 859     if (!d->attributes.document_title.isEmpty()) {
 860         *d->stream << "<title>" << d->attributes.document_title << "</title>" << endl;
 861     }
 862
 863     if (!d->attributes.document_description.isEmpty()) {
 864         *d->stream << "<desc>" << d->attributes.document_description << "</desc>" << endl;
 865     }
 866
 867     d->stream->setString(&d->defs);
 868     *d->stream << "<defs>\n";
 869
 870     d->stream->setString(&d->body);
 871     // Start the initial graphics state...
 872     *d->stream << "<g ";
 873     generateQtDefaults();
 874     *d->stream << endl;
 875
 876     return true;
 877 }
 878
 879 bool QSvgPaintEngine::end()
 880 {
 881     Q_D(QSvgPaintEngine);
 882
 883     d->stream->setString(&d->defs);
 884     *d->stream << "</defs>\n";
 885
 886     d->stream->setDevice(d->outputDevice);
 887 #ifndef QT_NO_TEXTCODEC
 888     d->stream->setCodec(QTextCodec::codecForName("UTF-8"));
 889 #endif
 890
 891     *d->stream << d->header;
 892     *d->stream << d->defs;
 893     *d->stream << d->body;
 894     if (d->afterFirstUpdate)
 895         *d->stream << "</g>" << endl; // close the updateState
 896
 897     *d->stream << "</g>" << endl // close the Qt defaults
 898                << "</svg>" << endl;
 899
 900     delete d->stream;
 901
 902     return true;
 903 }
 904
 905 void QSvgPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm,
 906                                  const QRectF &sr)
 907 {
 908     drawImage(r, pm.toImage(), sr);
 909 }
 910
 911 void QSvgPaintEngine::drawImage(const QRectF &r, const QImage &image,
 912                                 const QRectF &sr,
 913                                 Qt::ImageConversionFlag flags)
 914 {
 915     //Q_D(QSvgPaintEngine);
 916
 917     Q_UNUSED(sr);
 918     Q_UNUSED(flags);
 919     stream() << "<image ";
 920     stream() << "x=\""<<r.x()<<"\" "
 921                 "y=\""<<r.y()<<"\" "
 922                 "width=\""<<r.width()<<"\" "
 923                 "height=\""<<r.height()<<"\" "
 924                 "preserveAspectRatio=\"none\" ";
 925
 926     QByteArray data;
 927     QBuffer buffer(&data);
 928     buffer.open(QBuffer::ReadWrite);
 929     image.save(&buffer, "PNG");
 930     buffer.close();
 931     stream() << "xlink:href=\"data:image/png;base64,"
 932              << data.toBase64()
 933              <<"\" />\n";
 934 }
 935
 936 void QSvgPaintEngine::updateState(const QPaintEngineState &state)
 937 {
 938     Q_D(QSvgPaintEngine);
 939     QPaintEngine::DirtyFlags flags = state.state();
 940
 941     // always stream full gstate, which is not required, but...
 942     flags |= QPaintEngine::AllDirty;
 943
 944     // close old state and start a new one...
 945     if (d->afterFirstUpdate)
 946         *d->stream << "</g>\n\n";
 947
 948     *d->stream << "<g ";
 949
 950     if (flags & QPaintEngine::DirtyBrush) {
 951         qbrushToSvg(state.brush());
 952     }
 953
 954     if (flags & QPaintEngine::DirtyPen) {
 955         qpenToSvg(state.pen());
 956     }
 957
 958     if (flags & QPaintEngine::DirtyTransform) {
 959         d->matrix = state.matrix();
 960         *d->stream << "transform=\"matrix(" << d->matrix.m11() << ','
 961                    << d->matrix.m12() << ','
 962                    << d->matrix.m21() << ',' << d->matrix.m22() << ','
 963                    << d->matrix.dx() << ',' << d->matrix.dy()
 964                    << ")\""
 965                    << endl;
 966     }
 967
 968     if (flags & QPaintEngine::DirtyFont) {
 969         qfontToSvg(state.font());
 970     }
 971
 972     if (flags & QPaintEngine::DirtyOpacity) {
 973         if (!qFuzzyIsNull(state.opacity() - 1))
 974             stream() << "opacity=\""<<state.opacity()<<"\" ";
 975     }
 976
 977     *d->stream << '>' << endl;
 978
 979     d->afterFirstUpdate = true;
 980 }
 981
 982 void QSvgPaintEngine::drawPath(const QPainterPath &p)
 983 {
 984     Q_D(QSvgPaintEngine);
 985
 986     *d->stream << "<path "
 987                   "fill-rule=";
 988     if (p.fillRule() == Qt::OddEvenFill)
 989         *d->stream << "\"evenodd\" ";
 990     else
 991         *d->stream << "\"nonzero\" ";
 992
 993     *d->stream << "d=\"";
 994
 995     for (int i=0; i<p.elementCount(); ++i) {
 996         const QPainterPath::Element &e = p.elementAt(i);
 997         switch (e.type) {
 998         case QPainterPath::MoveToElement:
 999             *d->stream << 'M' << e.x << ',' << e.y;
1000             break;
1001         case QPainterPath::LineToElement:
1002             *d->stream << 'L' << e.x << ',' << e.y;
1003             break;
1004         case QPainterPath::CurveToElement:
1005             *d->stream << 'C' << e.x << ',' << e.y;
1006             ++i;
1007             while (i < p.elementCount()) {
1008                 const QPainterPath::Element &e = p.elementAt(i);
1009                 if (e.type != QPainterPath::CurveToDataElement) {
1010                     --i;
1011                     break;
1012                 } else
1013                     *d->stream << ' ';
1014                 *d->stream << e.x << ',' << e.y;
1015                 ++i;
1016             }
1017             break;
1018         default:
1019             break;
1020         }
1021         if (i != p.elementCount() - 1) {
1022             *d->stream << ' ';
1023         }
1024     }
1025
1026     *d->stream << "\"/>" << endl;
1027 }
1028
1029 void QSvgPaintEngine::drawPolygon(const QPointF *points, int pointCount,
1030                                   PolygonDrawMode mode)
1031 {
1032     Q_ASSERT(pointCount >= 2);
1033
1034     //Q_D(QSvgPaintEngine);
1035
1036     QPainterPath path(points[0]);
1037     for (int i=1; i<pointCount; ++i)
1038         path.lineTo(points[i]);
1039
1040     if (mode == PolylineMode) {
1041         stream() << "<polyline fill=\"none\" points=\"";
1042         for (int i = 0; i < pointCount; ++i) {
1043             const QPointF &pt = points[i];
1044             stream() << pt.x() << ',' << pt.y() << ' ';
1045         }
1046         stream() << "\" />" <<endl;
1047     } else {
1048         path.closeSubpath();
1049         drawPath(path);
1050     }
1051 }
1052
1053 void QSvgPaintEngine::drawTextItem(const QPointF &pt, const QTextItem &textItem)
1054 {
1055     Q_D(QSvgPaintEngine);
1056     if (d->pen.style() == Qt::NoPen)
1057         return;
1058
1059     const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
1060     QString s = QString::fromRawData(ti.chars, ti.num_chars);
1061
1062     *d->stream << "<text "
1063                   "fill=\"" << d->attributes.stroke << "\" "
1064                   "fill-opacity=\"" << d->attributes.strokeOpacity << "\" "
1065                   "stroke=\"none\" "
1066                   "xml:space=\"preserve\" "
1067                   "x=\"" << pt.x() << "\" y=\"" << pt.y() << "\" ";
1068     qfontToSvg(textItem.font());
1069     *d->stream << " >"
1070                << Qt::escape(s)
1071                << "</text>"
1072                << endl;
1073 }
1074
1075 QT_END_NAMESPACE
1076
1077 #endif // QT_NO_SVGGENERATOR