source: trunk/src/svg/qsvggenerator.cpp@ 561

Last change on this file since 561 was 561, checked in by Dmitry A. Kuminov, 15 years ago

trunk: Merged in qt 4.6.1 sources.
File size: 33.6 KB
Line 
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 QtSvg module of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
15**
16** GNU Lesser General Public License Usage
17** Alternatively, this file may be used under the terms of the GNU Lesser
18** General Public License version 2.1 as published by the Free Software
19** Foundation and appearing in the file LICENSE.LGPL included in the
20** packaging of this file. Please review the following information to
21** ensure the GNU Lesser General Public License version 2.1 requirements
22** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23**
24** In addition, as a special exception, Nokia gives you certain additional
25** rights. These rights are described in the Nokia Qt LGPL Exception
26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at qt-info@nokia.com.
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "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
60QT_BEGIN_NAMESPACE
61
62static 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
76static 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
87class QSvgPaintEnginePrivate : public QPaintEnginePrivate
88{
89public:
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
146static 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
156class QSvgPaintEngine : public QPaintEngine
157{
158 Q_DECLARE_PRIVATE(QSvgPaintEngine)
159public:
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
503class QSvgGeneratorPrivate
504{
505public:
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*/
552QSvgGenerator::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*/
564QSvgGenerator::~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*/
578QString QSvgGenerator::title() const
579{
580 Q_D(const QSvgGenerator);
581
582 return d->engine->documentTitle();
583}
584
585void 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*/
598QString QSvgGenerator::description() const
599{
600 Q_D(const QSvgGenerator);
601
602 return d->engine->documentDescription();
603}
604
605void 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*/
626QSize QSvgGenerator::size() const
627{
628 Q_D(const QSvgGenerator);
629 return d->engine->size();
630}
631
632void 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*/
656QRectF 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*/
669QRect QSvgGenerator::viewBox() const
670{
671 Q_D(const QSvgGenerator);
672 return d->engine->viewBox().toRect();
673}
674
675void 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
685void 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*/
697QString QSvgGenerator::fileName() const
698{
699 Q_D(const QSvgGenerator);
700 return d->fileName;
701}
702
703void 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*/
731QIODevice *QSvgGenerator::outputDevice() const
732{
733 Q_D(const QSvgGenerator);
734 return d->engine->outputDevice();
735}
736
737void 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*/
759int QSvgGenerator::resolution() const
760{
761 Q_D(const QSvgGenerator);
762 return d->engine->resolution();
763}
764
765void 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*/
775QPaintEngine *QSvgGenerator::paintEngine() const
776{
777 Q_D(const QSvgGenerator);
778 return d->engine;
779}
780
781/*!
782 \reimp
783*/
784int 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
819bool 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
879bool 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
905void QSvgPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm,
906 const QRectF &sr)
907{
908 drawImage(r, pm.toImage(), sr);
909}
910
911void 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
936void 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
982void 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
1029void 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
1053void 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
1075QT_END_NAMESPACE
1076
1077#endif // QT_NO_SVGGENERATOR
Note: See TracBrowser for help on using the repository browser.