1 | /****************************************************************************
|
---|
2 | **
|
---|
3 | ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
|
---|
4 | ** Contact: Qt Software Information (qt-info@nokia.com)
|
---|
5 | **
|
---|
6 | ** This file is part of the QtSvg module of the Qt Toolkit.
|
---|
7 | **
|
---|
8 | ** $QT_BEGIN_LICENSE:LGPL$
|
---|
9 | ** Commercial Usage
|
---|
10 | ** Licensees holding valid Qt Commercial licenses may use this file in
|
---|
11 | ** accordance with the Qt Commercial License Agreement provided with the
|
---|
12 | ** Software or, alternatively, in accordance with the terms contained in
|
---|
13 | ** a written agreement between you and Nokia.
|
---|
14 | **
|
---|
15 | ** GNU Lesser General Public License Usage
|
---|
16 | ** Alternatively, this file may be used under the terms of the GNU Lesser
|
---|
17 | ** General Public License version 2.1 as published by the Free Software
|
---|
18 | ** Foundation and appearing in the file LICENSE.LGPL included in the
|
---|
19 | ** packaging of this file. Please review the following information to
|
---|
20 | ** ensure the GNU Lesser General Public License version 2.1 requirements
|
---|
21 | ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
---|
22 | **
|
---|
23 | ** In addition, as a special exception, Nokia gives you certain
|
---|
24 | ** additional rights. These rights are described in the Nokia Qt LGPL
|
---|
25 | ** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
|
---|
26 | ** 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 are unsure which license is appropriate for your use, please
|
---|
37 | ** contact the sales department at qt-sales@nokia.com.
|
---|
38 | ** $QT_END_LICENSE$
|
---|
39 | **
|
---|
40 | ****************************************************************************/
|
---|
41 |
|
---|
42 | #include "qsvggraphics_p.h"
|
---|
43 |
|
---|
44 | #ifndef QT_NO_SVG
|
---|
45 |
|
---|
46 | #include "qsvgfont_p.h"
|
---|
47 |
|
---|
48 | #include "qpainter.h"
|
---|
49 | #include "qtextdocument.h"
|
---|
50 | #include "qabstracttextdocumentlayout.h"
|
---|
51 | #include "qtextcursor.h"
|
---|
52 | #include "qdebug.h"
|
---|
53 |
|
---|
54 | #include <math.h>
|
---|
55 | #include <limits.h>
|
---|
56 |
|
---|
57 | QT_BEGIN_NAMESPACE
|
---|
58 |
|
---|
59 | #define QT_SVG_DRAW_SHAPE(command) \
|
---|
60 | applyStyle(p, states); \
|
---|
61 | qreal oldOpacity = p->opacity(); \
|
---|
62 | QBrush oldBrush = p->brush(); \
|
---|
63 | QPen oldPen = p->pen(); \
|
---|
64 | p->setPen(Qt::NoPen); \
|
---|
65 | p->setOpacity(oldOpacity * states.fillOpacity); \
|
---|
66 | command; \
|
---|
67 | p->setOpacity(oldOpacity); \
|
---|
68 | p->setPen(oldPen); \
|
---|
69 | p->setBrush(Qt::NoBrush); \
|
---|
70 | command; \
|
---|
71 | p->setBrush(oldBrush); \
|
---|
72 | revertStyle(p, states);
|
---|
73 |
|
---|
74 |
|
---|
75 | void QSvgAnimation::draw(QPainter *, QSvgExtraStates &)
|
---|
76 | {
|
---|
77 | qWarning("<animation> no implemented");
|
---|
78 | }
|
---|
79 |
|
---|
80 | static inline QRectF boundsOnStroke(const QPainterPath &path, qreal width)
|
---|
81 | {
|
---|
82 | QPainterPathStroker stroker;
|
---|
83 | stroker.setWidth(width);
|
---|
84 | QPainterPath stroke = stroker.createStroke(path);
|
---|
85 | return stroke.boundingRect();
|
---|
86 | }
|
---|
87 |
|
---|
88 | QSvgCircle::QSvgCircle(QSvgNode *parent, const QRectF &rect)
|
---|
89 | : QSvgNode(parent), m_bounds(rect)
|
---|
90 | {
|
---|
91 | }
|
---|
92 |
|
---|
93 |
|
---|
94 | QRectF QSvgCircle::bounds() const
|
---|
95 | {
|
---|
96 | qreal sw = strokeWidth();
|
---|
97 | if (qFuzzyCompare(sw + 1, 1))
|
---|
98 | return m_bounds;
|
---|
99 | else {
|
---|
100 | QPainterPath path;
|
---|
101 | path.addRect(m_bounds);
|
---|
102 | return boundsOnStroke(path, sw);
|
---|
103 | }
|
---|
104 | }
|
---|
105 |
|
---|
106 | void QSvgCircle::draw(QPainter *p, QSvgExtraStates &states)
|
---|
107 | {
|
---|
108 | QT_SVG_DRAW_SHAPE(p->drawEllipse(m_bounds));
|
---|
109 | }
|
---|
110 |
|
---|
111 | QSvgArc::QSvgArc(QSvgNode *parent, const QPainterPath &path)
|
---|
112 | : QSvgNode(parent), cubic(path)
|
---|
113 | {
|
---|
114 | m_cachedBounds = path.boundingRect();
|
---|
115 | }
|
---|
116 |
|
---|
117 | void QSvgArc::draw(QPainter *p, QSvgExtraStates &states)
|
---|
118 | {
|
---|
119 | applyStyle(p, states);
|
---|
120 | p->drawPath(cubic);
|
---|
121 | revertStyle(p, states);
|
---|
122 | }
|
---|
123 |
|
---|
124 | QSvgEllipse::QSvgEllipse(QSvgNode *parent, const QRectF &rect)
|
---|
125 | : QSvgNode(parent), m_bounds(rect)
|
---|
126 | {
|
---|
127 | }
|
---|
128 |
|
---|
129 | QRectF QSvgEllipse::bounds() const
|
---|
130 | {
|
---|
131 | qreal sw = strokeWidth();
|
---|
132 | if (qFuzzyCompare(sw + 1, 1))
|
---|
133 | return m_bounds;
|
---|
134 | else {
|
---|
135 | QPainterPath path;
|
---|
136 | path.addEllipse(m_bounds);
|
---|
137 | return boundsOnStroke(path, sw);
|
---|
138 | }
|
---|
139 | }
|
---|
140 |
|
---|
141 | void QSvgEllipse::draw(QPainter *p, QSvgExtraStates &states)
|
---|
142 | {
|
---|
143 | QT_SVG_DRAW_SHAPE(p->drawEllipse(m_bounds));
|
---|
144 | }
|
---|
145 |
|
---|
146 | QSvgImage::QSvgImage(QSvgNode *parent, const QImage &image,
|
---|
147 | const QRect &bounds)
|
---|
148 | : QSvgNode(parent), m_image(image),
|
---|
149 | m_bounds(bounds)
|
---|
150 | {
|
---|
151 | if (m_bounds.width() == 0)
|
---|
152 | m_bounds.setWidth(m_image.width());
|
---|
153 | if (m_bounds.height() == 0)
|
---|
154 | m_bounds.setHeight(m_image.height());
|
---|
155 | }
|
---|
156 |
|
---|
157 | void QSvgImage::draw(QPainter *p, QSvgExtraStates &states)
|
---|
158 | {
|
---|
159 | applyStyle(p, states);
|
---|
160 | p->drawImage(m_bounds, m_image);
|
---|
161 | revertStyle(p, states);
|
---|
162 | }
|
---|
163 |
|
---|
164 |
|
---|
165 | QSvgLine::QSvgLine(QSvgNode *parent, const QLineF &line)
|
---|
166 | : QSvgNode(parent), m_bounds(line)
|
---|
167 | {
|
---|
168 | }
|
---|
169 |
|
---|
170 |
|
---|
171 | void QSvgLine::draw(QPainter *p, QSvgExtraStates &states)
|
---|
172 | {
|
---|
173 | applyStyle(p, states);
|
---|
174 | p->drawLine(m_bounds);
|
---|
175 | revertStyle(p, states);
|
---|
176 | }
|
---|
177 |
|
---|
178 | QSvgPath::QSvgPath(QSvgNode *parent, const QPainterPath &qpath)
|
---|
179 | : QSvgNode(parent), m_path(qpath)
|
---|
180 | {
|
---|
181 | //m_cachedBounds = m_path.controlPointRect();
|
---|
182 | m_cachedBounds = m_path.boundingRect();
|
---|
183 | }
|
---|
184 |
|
---|
185 | void QSvgPath::draw(QPainter *p, QSvgExtraStates &states)
|
---|
186 | {
|
---|
187 | QT_SVG_DRAW_SHAPE(p->drawPath(m_path));
|
---|
188 | }
|
---|
189 |
|
---|
190 | QRectF QSvgPath::bounds() const
|
---|
191 | {
|
---|
192 | qreal sw = strokeWidth();
|
---|
193 | if (qFuzzyCompare(sw + 1, 1))
|
---|
194 | return m_cachedBounds;
|
---|
195 | else {
|
---|
196 | return boundsOnStroke(m_path, sw);
|
---|
197 | }
|
---|
198 | }
|
---|
199 |
|
---|
200 | QSvgPolygon::QSvgPolygon(QSvgNode *parent, const QPolygonF &poly)
|
---|
201 | : QSvgNode(parent), m_poly(poly)
|
---|
202 | {
|
---|
203 |
|
---|
204 | }
|
---|
205 |
|
---|
206 | QRectF QSvgPolygon::bounds() const
|
---|
207 | {
|
---|
208 | qreal sw = strokeWidth();
|
---|
209 | if (qFuzzyCompare(sw + 1, 1))
|
---|
210 | return m_poly.boundingRect();
|
---|
211 | else {
|
---|
212 | QPainterPath path;
|
---|
213 | path.addPolygon(m_poly);
|
---|
214 | return boundsOnStroke(path, sw);
|
---|
215 | }
|
---|
216 | }
|
---|
217 |
|
---|
218 | void QSvgPolygon::draw(QPainter *p, QSvgExtraStates &states)
|
---|
219 | {
|
---|
220 | QT_SVG_DRAW_SHAPE(p->drawPolygon(m_poly));
|
---|
221 | }
|
---|
222 |
|
---|
223 |
|
---|
224 | QSvgPolyline::QSvgPolyline(QSvgNode *parent, const QPolygonF &poly)
|
---|
225 | : QSvgNode(parent), m_poly(poly)
|
---|
226 | {
|
---|
227 |
|
---|
228 | }
|
---|
229 |
|
---|
230 | void QSvgPolyline::draw(QPainter *p, QSvgExtraStates &states)
|
---|
231 | {
|
---|
232 | applyStyle(p, states);
|
---|
233 | if (p->brush().style() != Qt::NoBrush) {
|
---|
234 | QPen save = p->pen();
|
---|
235 | p->setPen(QPen(Qt::NoPen));
|
---|
236 | p->drawPolygon(m_poly);
|
---|
237 | p->setPen(save);
|
---|
238 | }
|
---|
239 | p->drawPolyline(m_poly);
|
---|
240 | revertStyle(p, states);
|
---|
241 | }
|
---|
242 |
|
---|
243 | QSvgRect::QSvgRect(QSvgNode *node, const QRectF &rect, int rx, int ry)
|
---|
244 | : QSvgNode(node),
|
---|
245 | m_rect(rect), m_rx(rx), m_ry(ry)
|
---|
246 | {
|
---|
247 | }
|
---|
248 |
|
---|
249 | QRectF QSvgRect::bounds() const
|
---|
250 | {
|
---|
251 | qreal sw = strokeWidth();
|
---|
252 | if (qFuzzyCompare(sw + 1, 1))
|
---|
253 | return m_rect;
|
---|
254 | else {
|
---|
255 | QPainterPath path;
|
---|
256 | path.addRect(m_rect);
|
---|
257 | return boundsOnStroke(path, sw);
|
---|
258 | }
|
---|
259 | }
|
---|
260 |
|
---|
261 | void QSvgRect::draw(QPainter *p, QSvgExtraStates &states)
|
---|
262 | {
|
---|
263 | if (m_rx || m_ry) {
|
---|
264 | QT_SVG_DRAW_SHAPE(p->drawRoundedRect(m_rect, m_rx, m_ry, Qt::RelativeSize));
|
---|
265 | } else {
|
---|
266 | QT_SVG_DRAW_SHAPE(p->drawRect(m_rect));
|
---|
267 | }
|
---|
268 | }
|
---|
269 |
|
---|
270 | QSvgText::QSvgText(QSvgNode *parent, const QPointF &coord)
|
---|
271 | : QSvgNode(parent)
|
---|
272 | , m_coord(coord)
|
---|
273 | , m_textAlignment(Qt::AlignLeft)
|
---|
274 | , m_scale(1)
|
---|
275 | , m_appendSpace(false)
|
---|
276 | , m_type(TEXT)
|
---|
277 | , m_size(0, 0)
|
---|
278 | {
|
---|
279 | m_paragraphs.push_back(QString());
|
---|
280 | m_formatRanges.push_back(QList<QTextLayout::FormatRange>());
|
---|
281 | }
|
---|
282 |
|
---|
283 | QSvgText::~QSvgText()
|
---|
284 | {
|
---|
285 | }
|
---|
286 |
|
---|
287 | void QSvgText::setTextArea(const QSizeF &size)
|
---|
288 | {
|
---|
289 | m_size = size;
|
---|
290 | m_type = TEXTAREA;
|
---|
291 | }
|
---|
292 |
|
---|
293 | //QRectF QSvgText::bounds() const {}
|
---|
294 |
|
---|
295 | void QSvgText::draw(QPainter *p, QSvgExtraStates &states)
|
---|
296 | {
|
---|
297 | applyStyle(p, states);
|
---|
298 |
|
---|
299 | QSvgFontStyle *fontStyle = static_cast<QSvgFontStyle*>(
|
---|
300 | styleProperty(QSvgStyleProperty::FONT));
|
---|
301 | if (fontStyle && fontStyle->svgFont()) {
|
---|
302 | // SVG fonts not fully supported...
|
---|
303 | QString text = m_paragraphs.front();
|
---|
304 | for (int i = 1; i < m_paragraphs.size(); ++i) {
|
---|
305 | text.append(QLatin1Char('\n'));
|
---|
306 | text.append(m_paragraphs[i]);
|
---|
307 | }
|
---|
308 | fontStyle->svgFont()->draw(p, m_coord, text, fontStyle->pointSize(), m_textAlignment);
|
---|
309 | revertStyle(p, states);
|
---|
310 | return;
|
---|
311 | }
|
---|
312 |
|
---|
313 | // Scale the font to its correct size.
|
---|
314 | QTransform oldTransform = p->worldTransform();
|
---|
315 | p->scale(1 / m_scale, 1 / m_scale);
|
---|
316 |
|
---|
317 | qreal y = 0;
|
---|
318 | bool initial = true;
|
---|
319 | qreal px = m_coord.x() * m_scale;
|
---|
320 | qreal py = m_coord.y() * m_scale;
|
---|
321 | QSizeF scaledSize = m_size * m_scale;
|
---|
322 |
|
---|
323 | if (m_type == TEXTAREA) {
|
---|
324 | if (m_textAlignment == Qt::AlignHCenter)
|
---|
325 | px += scaledSize.width() / 2;
|
---|
326 | else if (m_textAlignment == Qt::AlignRight)
|
---|
327 | px += scaledSize.width();
|
---|
328 | }
|
---|
329 |
|
---|
330 | QRectF bounds;
|
---|
331 | if (m_size.height() != 0)
|
---|
332 | bounds = QRectF(0, 0, 1, scaledSize.height());
|
---|
333 |
|
---|
334 | for (int i = 0; i < m_paragraphs.size(); ++i) {
|
---|
335 | QTextLayout tl(m_paragraphs[i]);
|
---|
336 | QTextOption op = tl.textOption();
|
---|
337 | op.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
|
---|
338 | tl.setTextOption(op);
|
---|
339 | tl.setAdditionalFormats(m_formatRanges[i]);
|
---|
340 | tl.beginLayout();
|
---|
341 | forever {
|
---|
342 | QTextLine line = tl.createLine();
|
---|
343 | if (!line.isValid())
|
---|
344 | break;
|
---|
345 |
|
---|
346 | if (m_size.width() != 0)
|
---|
347 | line.setLineWidth(scaledSize.width());
|
---|
348 | }
|
---|
349 | tl.endLayout();
|
---|
350 |
|
---|
351 | bool endOfBoundsReached = false;
|
---|
352 | for (int i = 0; i < tl.lineCount(); ++i) {
|
---|
353 | QTextLine line = tl.lineAt(i);
|
---|
354 |
|
---|
355 | qreal x = 0;
|
---|
356 | if (m_textAlignment == Qt::AlignHCenter)
|
---|
357 | x -= line.naturalTextWidth() / 2;
|
---|
358 | else if (m_textAlignment == Qt::AlignRight)
|
---|
359 | x -= line.naturalTextWidth();
|
---|
360 |
|
---|
361 | if (initial && m_type == TEXT)
|
---|
362 | y -= line.ascent();
|
---|
363 | initial = false;
|
---|
364 |
|
---|
365 | line.setPosition(QPointF(x, y));
|
---|
366 | if ((m_size.width() != 0 && line.naturalTextWidth() > scaledSize.width())
|
---|
367 | || (m_size.height() != 0 && y + line.height() > scaledSize.height())) {
|
---|
368 | bounds.setHeight(y);
|
---|
369 | endOfBoundsReached = true;
|
---|
370 | break;
|
---|
371 | }
|
---|
372 |
|
---|
373 | y += 1.1 * line.height();
|
---|
374 | }
|
---|
375 | tl.draw(p, QPointF(px, py), QVector<QTextLayout::FormatRange>(), bounds);
|
---|
376 |
|
---|
377 | if (endOfBoundsReached)
|
---|
378 | break;
|
---|
379 | }
|
---|
380 |
|
---|
381 | p->setWorldTransform(oldTransform, false);
|
---|
382 | revertStyle(p, states);
|
---|
383 | }
|
---|
384 |
|
---|
385 | void QSvgText::insertText(const QString &text, WhitespaceMode mode)
|
---|
386 | {
|
---|
387 | bool isTSpan = (m_formats.count() == 2);
|
---|
388 | QString newText(text);
|
---|
389 | newText.replace(QLatin1Char('\t'), QLatin1Char(' '));
|
---|
390 | newText.replace(QLatin1Char('\n'), QLatin1Char(' '));
|
---|
391 |
|
---|
392 | bool prependSpace = !m_appendSpace && !isTSpan && (mode == Default) && !m_paragraphs.back().isEmpty() && newText.startsWith(QLatin1Char(' '));
|
---|
393 | if (m_appendSpace || prependSpace)
|
---|
394 | m_paragraphs.back().append(QLatin1Char(' '));
|
---|
395 |
|
---|
396 | bool appendSpaceNext = (!isTSpan && (mode == Default) && newText.endsWith(QLatin1Char(' ')));
|
---|
397 |
|
---|
398 | if (mode == Default) {
|
---|
399 | newText = newText.simplified();
|
---|
400 | if (newText.isEmpty())
|
---|
401 | appendSpaceNext = false;
|
---|
402 | }
|
---|
403 |
|
---|
404 | if (!m_formats.isEmpty()) {
|
---|
405 | QTextLayout::FormatRange range;
|
---|
406 | range.start = m_paragraphs.back().length();
|
---|
407 | range.length = newText.length();
|
---|
408 | range.format = m_formats.top();
|
---|
409 | if (m_appendSpace) {
|
---|
410 | Q_ASSERT(!m_formatRanges.back().isEmpty());
|
---|
411 | ++m_formatRanges.back().back().length;
|
---|
412 | } else if (prependSpace) {
|
---|
413 | --range.start;
|
---|
414 | ++range.length;
|
---|
415 | }
|
---|
416 | m_formatRanges.back().append(range);
|
---|
417 | }
|
---|
418 |
|
---|
419 | m_appendSpace = appendSpaceNext;
|
---|
420 | m_paragraphs.back() += newText;
|
---|
421 | }
|
---|
422 |
|
---|
423 | void QSvgText::insertFormat(const QTextCharFormat &format)
|
---|
424 | {
|
---|
425 | QTextCharFormat mergedFormat = format;
|
---|
426 | if (!m_formats.isEmpty()) {
|
---|
427 | mergedFormat = m_formats.top();
|
---|
428 | mergedFormat.merge(format);
|
---|
429 | }
|
---|
430 | m_formats.push(mergedFormat);
|
---|
431 | }
|
---|
432 |
|
---|
433 | void QSvgText::insertLineBreak()
|
---|
434 | {
|
---|
435 | if (m_type == TEXTAREA) {
|
---|
436 | if (m_paragraphs.back().isEmpty())
|
---|
437 | insertText(QLatin1String(" "), Preserve);
|
---|
438 | m_appendSpace = false;
|
---|
439 | m_paragraphs.push_back(QString());
|
---|
440 | m_formatRanges.push_back(QList<QTextLayout::FormatRange>());
|
---|
441 | }
|
---|
442 | }
|
---|
443 |
|
---|
444 | void QSvgText::popFormat()
|
---|
445 | {
|
---|
446 | if (m_formats.count() > 1)
|
---|
447 | m_formats.pop();
|
---|
448 | }
|
---|
449 |
|
---|
450 | qreal QSvgText::scale() const
|
---|
451 | {
|
---|
452 | return m_scale;
|
---|
453 | }
|
---|
454 |
|
---|
455 | void QSvgText::setScale(qreal scale)
|
---|
456 | {
|
---|
457 | m_scale = scale;
|
---|
458 | }
|
---|
459 |
|
---|
460 | const QTextCharFormat &QSvgText::topFormat() const
|
---|
461 | {
|
---|
462 | return m_formats.top();
|
---|
463 | }
|
---|
464 |
|
---|
465 | void QSvgText::setTextAlignment(const Qt::Alignment &alignment)
|
---|
466 | {
|
---|
467 | m_textAlignment = alignment;
|
---|
468 | }
|
---|
469 |
|
---|
470 | QSvgUse::QSvgUse(const QPointF &start, QSvgNode *parent, QSvgNode *node)
|
---|
471 | : QSvgNode(parent), m_link(node), m_start(start)
|
---|
472 | {
|
---|
473 |
|
---|
474 | }
|
---|
475 |
|
---|
476 | void QSvgUse::draw(QPainter *p, QSvgExtraStates &states)
|
---|
477 | {
|
---|
478 | applyStyle(p, states);
|
---|
479 |
|
---|
480 | if (!m_start.isNull()) {
|
---|
481 | p->translate(m_start);
|
---|
482 | }
|
---|
483 | m_link->draw(p, states);
|
---|
484 | if (!m_start.isNull()) {
|
---|
485 | p->translate(-m_start);
|
---|
486 | }
|
---|
487 |
|
---|
488 | revertStyle(p, states);
|
---|
489 | }
|
---|
490 |
|
---|
491 | void QSvgVideo::draw(QPainter *p, QSvgExtraStates &states)
|
---|
492 | {
|
---|
493 | applyStyle(p, states);
|
---|
494 |
|
---|
495 | revertStyle(p, states);
|
---|
496 | }
|
---|
497 |
|
---|
498 | QSvgNode::Type QSvgAnimation::type() const
|
---|
499 | {
|
---|
500 | return ANIMATION;
|
---|
501 | }
|
---|
502 |
|
---|
503 | QSvgNode::Type QSvgArc::type() const
|
---|
504 | {
|
---|
505 | return ARC;
|
---|
506 | }
|
---|
507 |
|
---|
508 | QSvgNode::Type QSvgCircle::type() const
|
---|
509 | {
|
---|
510 | return CIRCLE;
|
---|
511 | }
|
---|
512 |
|
---|
513 | QSvgNode::Type QSvgEllipse::type() const
|
---|
514 | {
|
---|
515 | return ELLIPSE;
|
---|
516 | }
|
---|
517 |
|
---|
518 | QSvgNode::Type QSvgImage::type() const
|
---|
519 | {
|
---|
520 | return IMAGE;
|
---|
521 | }
|
---|
522 |
|
---|
523 | QSvgNode::Type QSvgLine::type() const
|
---|
524 | {
|
---|
525 | return LINE;
|
---|
526 | }
|
---|
527 |
|
---|
528 | QSvgNode::Type QSvgPath::type() const
|
---|
529 | {
|
---|
530 | return PATH;
|
---|
531 | }
|
---|
532 |
|
---|
533 | QSvgNode::Type QSvgPolygon::type() const
|
---|
534 | {
|
---|
535 | return POLYGON;
|
---|
536 | }
|
---|
537 |
|
---|
538 | QSvgNode::Type QSvgPolyline::type() const
|
---|
539 | {
|
---|
540 | return POLYLINE;
|
---|
541 | }
|
---|
542 |
|
---|
543 | QSvgNode::Type QSvgRect::type() const
|
---|
544 | {
|
---|
545 | return RECT;
|
---|
546 | }
|
---|
547 |
|
---|
548 | QSvgNode::Type QSvgText::type() const
|
---|
549 | {
|
---|
550 | return m_type;
|
---|
551 | }
|
---|
552 |
|
---|
553 | QSvgNode::Type QSvgUse::type() const
|
---|
554 | {
|
---|
555 | return USE;
|
---|
556 | }
|
---|
557 |
|
---|
558 | QSvgNode::Type QSvgVideo::type() const
|
---|
559 | {
|
---|
560 | return VIDEO;
|
---|
561 | }
|
---|
562 |
|
---|
563 | QRectF QSvgUse::bounds() const
|
---|
564 | {
|
---|
565 | if (m_link && m_bounds.isEmpty()) {
|
---|
566 | m_bounds = m_link->bounds();
|
---|
567 | m_bounds = QRectF(m_bounds.x()+m_start.x(),
|
---|
568 | m_bounds.y()+m_start.y(),
|
---|
569 | m_bounds.width(),
|
---|
570 | m_bounds.height());
|
---|
571 |
|
---|
572 | return m_bounds;
|
---|
573 | }
|
---|
574 | return m_bounds;
|
---|
575 | }
|
---|
576 |
|
---|
577 | QRectF QSvgUse::transformedBounds(const QTransform &transform) const
|
---|
578 | {
|
---|
579 | QRectF bounds;
|
---|
580 | QTransform t = transform;
|
---|
581 |
|
---|
582 | if (m_link) {
|
---|
583 | QSvgTransformStyle *transStyle = m_style.transform;
|
---|
584 | if (transStyle) {
|
---|
585 | t = transStyle->qtransform() * t;
|
---|
586 | }
|
---|
587 | t.translate(m_start.x(), m_start.y());
|
---|
588 |
|
---|
589 | bounds = m_link->transformedBounds(t);
|
---|
590 |
|
---|
591 | return bounds;
|
---|
592 | }
|
---|
593 | return bounds;
|
---|
594 | }
|
---|
595 |
|
---|
596 | QRectF QSvgPolyline::bounds() const
|
---|
597 | {
|
---|
598 | qreal sw = strokeWidth();
|
---|
599 | if (qFuzzyCompare(sw + 1, 1))
|
---|
600 | return m_poly.boundingRect();
|
---|
601 | else {
|
---|
602 | QPainterPath path;
|
---|
603 | path.addPolygon(m_poly);
|
---|
604 | return boundsOnStroke(path, sw);
|
---|
605 | }
|
---|
606 | }
|
---|
607 |
|
---|
608 | QRectF QSvgArc::bounds() const
|
---|
609 | {
|
---|
610 | qreal sw = strokeWidth();
|
---|
611 | if (qFuzzyCompare(sw + 1, 1))
|
---|
612 | return m_cachedBounds;
|
---|
613 | else {
|
---|
614 | return boundsOnStroke(cubic, sw);
|
---|
615 | }
|
---|
616 | }
|
---|
617 |
|
---|
618 | QRectF QSvgImage::bounds() const
|
---|
619 | {
|
---|
620 | return m_bounds;
|
---|
621 | }
|
---|
622 |
|
---|
623 | QRectF QSvgLine::bounds() const
|
---|
624 | {
|
---|
625 | qreal sw = strokeWidth();
|
---|
626 | if (qFuzzyCompare(sw + 1, 1)) {
|
---|
627 | qreal minX = qMin(m_bounds.x1(), m_bounds.x2());
|
---|
628 | qreal minY = qMin(m_bounds.y1(), m_bounds.y2());
|
---|
629 | qreal maxX = qMax(m_bounds.x1(), m_bounds.x2());
|
---|
630 | qreal maxY = qMax(m_bounds.y1(), m_bounds.y2());
|
---|
631 | return QRectF(minX, minY, maxX-minX, maxY-minY);
|
---|
632 | } else {
|
---|
633 | QPainterPath path;
|
---|
634 | path.moveTo(m_bounds.x1(), m_bounds.y1());
|
---|
635 | path.lineTo(m_bounds.x2(), m_bounds.y2());
|
---|
636 | return boundsOnStroke(path, sw);
|
---|
637 | }
|
---|
638 | }
|
---|
639 |
|
---|
640 | QT_END_NAMESPACE
|
---|
641 |
|
---|
642 | #endif // QT_NO_SVG
|
---|