1// Copyright (C) 2021 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "qsvgstyle_p.h"
5
6#include "qsvgfont_p.h"
7#include "qsvggraphics_p.h"
8#include "qsvgnode_p.h"
9#include "qsvgtinydocument_p.h"
10
11#include "qpainter.h"
12#include "qpair.h"
13#include "qcolor.h"
14#include "qdebug.h"
15#include "qmath.h"
16#include "qnumeric.h"
17
18QT_BEGIN_NAMESPACE
19
20QSvgExtraStates::QSvgExtraStates()
21 : fillOpacity(1.0),
22 strokeOpacity(1.0),
23 svgFont(0),
24 textAnchor(Qt::AlignLeft),
25 fontWeight(QFont::Normal),
26 fillRule(Qt::WindingFill),
27 strokeDashOffset(0),
28 vectorEffect(false),
29 imageRendering(QSvgQualityStyle::ImageRenderingAuto)
30{
31}
32
33QSvgStyleProperty::~QSvgStyleProperty()
34{
35}
36
37void QSvgPaintStyleProperty::apply(QPainter *, const QSvgNode *, QSvgExtraStates &)
38{
39 Q_ASSERT(!"This should not be called!");
40}
41
42void QSvgPaintStyleProperty::revert(QPainter *, QSvgExtraStates &)
43{
44 Q_ASSERT(!"This should not be called!");
45}
46
47
48QSvgQualityStyle::QSvgQualityStyle(int color)
49 : m_imageRendering(QSvgQualityStyle::ImageRenderingAuto)
50 , m_oldImageRendering(QSvgQualityStyle::ImageRenderingAuto)
51 , m_imageRenderingSet(0)
52{
53 Q_UNUSED(color);
54}
55
56void QSvgQualityStyle::setImageRendering(ImageRendering hint) {
57 m_imageRendering = hint;
58 m_imageRenderingSet = 1;
59}
60
61void QSvgQualityStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &states)
62{
63 m_oldImageRendering = states.imageRendering;
64 if (m_imageRenderingSet) {
65 states.imageRendering = m_imageRendering;
66 }
67 if (m_imageRenderingSet) {
68 bool smooth = false;
69 if (m_imageRendering == ImageRenderingAuto)
70 // auto (the spec says to prefer quality)
71 smooth = true;
72 else
73 smooth = (m_imageRendering == ImageRenderingOptimizeQuality);
74 p->setRenderHint(hint: QPainter::SmoothPixmapTransform, on: smooth);
75 }
76}
77
78void QSvgQualityStyle::revert(QPainter *p, QSvgExtraStates &states)
79{
80 if (m_imageRenderingSet) {
81 states.imageRendering = m_oldImageRendering;
82 bool smooth = false;
83 if (m_oldImageRendering == ImageRenderingAuto)
84 smooth = true;
85 else
86 smooth = (m_oldImageRendering == ImageRenderingOptimizeQuality);
87 p->setRenderHint(hint: QPainter::SmoothPixmapTransform, on: smooth);
88 }
89}
90
91QSvgFillStyle::QSvgFillStyle()
92 : m_style(0)
93 , m_fillRule(Qt::WindingFill)
94 , m_oldFillRule(Qt::WindingFill)
95 , m_fillOpacity(1.0)
96 , m_oldFillOpacity(0)
97 , m_paintStyleResolved(1)
98 , m_fillRuleSet(0)
99 , m_fillOpacitySet(0)
100 , m_fillSet(0)
101{
102}
103
104void QSvgFillStyle::setFillRule(Qt::FillRule f)
105{
106 m_fillRuleSet = 1;
107 m_fillRule = f;
108}
109
110void QSvgFillStyle::setFillOpacity(qreal opacity)
111{
112 m_fillOpacitySet = 1;
113 m_fillOpacity = opacity;
114}
115
116void QSvgFillStyle::setFillStyle(QSvgPaintStyleProperty* style)
117{
118 m_style = style;
119 m_fillSet = 1;
120}
121
122void QSvgFillStyle::setBrush(QBrush brush)
123{
124 m_fill = std::move(brush);
125 m_style = nullptr;
126 m_fillSet = 1;
127}
128
129void QSvgFillStyle::apply(QPainter *p, const QSvgNode *n, QSvgExtraStates &states)
130{
131 m_oldFill = p->brush();
132 m_oldFillRule = states.fillRule;
133 m_oldFillOpacity = states.fillOpacity;
134
135 if (m_fillRuleSet)
136 states.fillRule = m_fillRule;
137 if (m_fillSet) {
138 if (m_style)
139 p->setBrush(m_style->brush(p, node: n, states));
140 else
141 p->setBrush(m_fill);
142 }
143 if (m_fillOpacitySet)
144 states.fillOpacity = m_fillOpacity;
145}
146
147void QSvgFillStyle::revert(QPainter *p, QSvgExtraStates &states)
148{
149 if (m_fillOpacitySet)
150 states.fillOpacity = m_oldFillOpacity;
151 if (m_fillSet)
152 p->setBrush(m_oldFill);
153 if (m_fillRuleSet)
154 states.fillRule = m_oldFillRule;
155}
156
157QSvgViewportFillStyle::QSvgViewportFillStyle(const QBrush &brush)
158 : m_viewportFill(brush)
159{
160}
161
162void QSvgViewportFillStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &)
163{
164 m_oldFill = p->brush();
165 p->setBrush(m_viewportFill);
166}
167
168void QSvgViewportFillStyle::revert(QPainter *p, QSvgExtraStates &)
169{
170 p->setBrush(m_oldFill);
171}
172
173QSvgFontStyle::QSvgFontStyle(QSvgFont *font, QSvgTinyDocument *doc)
174 : m_svgFont(font)
175 , m_doc(doc)
176 , m_familySet(0)
177 , m_sizeSet(0)
178 , m_styleSet(0)
179 , m_variantSet(0)
180 , m_weightSet(0)
181 , m_textAnchorSet(0)
182{
183}
184
185QSvgFontStyle::QSvgFontStyle()
186 : m_svgFont(0)
187 , m_doc(0)
188 , m_familySet(0)
189 , m_sizeSet(0)
190 , m_styleSet(0)
191 , m_variantSet(0)
192 , m_weightSet(0)
193 , m_textAnchorSet(0)
194{
195}
196
197void QSvgFontStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &states)
198{
199 m_oldQFont = p->font();
200 m_oldSvgFont = states.svgFont;
201 m_oldTextAnchor = states.textAnchor;
202 m_oldWeight = states.fontWeight;
203
204 if (m_textAnchorSet)
205 states.textAnchor = m_textAnchor;
206
207 QFont font = m_oldQFont;
208 if (m_familySet) {
209 states.svgFont = m_svgFont;
210 font.setFamilies(m_qfont.families());
211 }
212
213 if (m_sizeSet)
214 font.setPointSizeF(m_qfont.pointSizeF());
215
216 if (m_styleSet)
217 font.setStyle(m_qfont.style());
218
219 if (m_variantSet)
220 font.setCapitalization(m_qfont.capitalization());
221
222 if (m_weightSet) {
223 if (m_weight == BOLDER) {
224 states.fontWeight = qMin(a: states.fontWeight + 100, b: static_cast<int>(QFont::Black));
225 } else if (m_weight == LIGHTER) {
226 states.fontWeight = qMax(a: states.fontWeight - 100, b: static_cast<int>(QFont::Thin));
227 } else {
228 states.fontWeight = m_weight;
229 }
230 font.setWeight(QFont::Weight(qBound(min: static_cast<int>(QFont::Weight::Thin),
231 val: states.fontWeight,
232 max: static_cast<int>(QFont::Weight::Black))));
233 }
234
235 p->setFont(font);
236}
237
238void QSvgFontStyle::revert(QPainter *p, QSvgExtraStates &states)
239{
240 p->setFont(m_oldQFont);
241 states.svgFont = m_oldSvgFont;
242 states.textAnchor = m_oldTextAnchor;
243 states.fontWeight = m_oldWeight;
244}
245
246QSvgStrokeStyle::QSvgStrokeStyle()
247 : m_strokeOpacity(1.0)
248 , m_oldStrokeOpacity(0.0)
249 , m_strokeDashOffset(0)
250 , m_oldStrokeDashOffset(0)
251 , m_style(0)
252 , m_paintStyleResolved(1)
253 , m_vectorEffect(0)
254 , m_oldVectorEffect(0)
255 , m_strokeSet(0)
256 , m_strokeDashArraySet(0)
257 , m_strokeDashOffsetSet(0)
258 , m_strokeLineCapSet(0)
259 , m_strokeLineJoinSet(0)
260 , m_strokeMiterLimitSet(0)
261 , m_strokeOpacitySet(0)
262 , m_strokeWidthSet(0)
263 , m_vectorEffectSet(0)
264{
265}
266
267void QSvgStrokeStyle::apply(QPainter *p, const QSvgNode *n, QSvgExtraStates &states)
268{
269 m_oldStroke = p->pen();
270 m_oldStrokeOpacity = states.strokeOpacity;
271 m_oldStrokeDashOffset = states.strokeDashOffset;
272 m_oldVectorEffect = states.vectorEffect;
273
274 QPen pen = p->pen();
275
276 qreal oldWidth = pen.widthF();
277 qreal width = m_stroke.widthF();
278 if (oldWidth == 0)
279 oldWidth = 1;
280 if (width == 0)
281 width = 1;
282 qreal scale = oldWidth / width;
283
284 if (m_strokeOpacitySet)
285 states.strokeOpacity = m_strokeOpacity;
286
287 if (m_vectorEffectSet)
288 states.vectorEffect = m_vectorEffect;
289
290 if (m_strokeSet) {
291 if (m_style)
292 pen.setBrush(m_style->brush(p, node: n, states));
293 else
294 pen.setBrush(m_stroke.brush());
295 }
296
297 if (m_strokeWidthSet)
298 pen.setWidthF(m_stroke.widthF());
299
300 bool setDashOffsetNeeded = false;
301
302 if (m_strokeDashOffsetSet) {
303 states.strokeDashOffset = m_strokeDashOffset;
304 setDashOffsetNeeded = true;
305 }
306
307 if (m_strokeDashArraySet) {
308 if (m_stroke.style() == Qt::SolidLine) {
309 pen.setStyle(Qt::SolidLine);
310 } else if (m_strokeWidthSet || oldWidth == 1) {
311 // If both width and dash array was set, the dash array is already scaled correctly.
312 pen.setDashPattern(m_stroke.dashPattern());
313 setDashOffsetNeeded = true;
314 } else {
315 // If dash array was set, but not the width, the dash array has to be scaled with respect to the old width.
316 QList<qreal> dashes = m_stroke.dashPattern();
317 for (int i = 0; i < dashes.size(); ++i)
318 dashes[i] /= oldWidth;
319 pen.setDashPattern(dashes);
320 setDashOffsetNeeded = true;
321 }
322 } else if (m_strokeWidthSet && pen.style() != Qt::SolidLine && scale != 1) {
323 // If the width was set, but not the dash array, the old dash array must be scaled with respect to the new width.
324 QList<qreal> dashes = pen.dashPattern();
325 for (int i = 0; i < dashes.size(); ++i)
326 dashes[i] *= scale;
327 pen.setDashPattern(dashes);
328 setDashOffsetNeeded = true;
329 }
330
331 if (m_strokeLineCapSet)
332 pen.setCapStyle(m_stroke.capStyle());
333 if (m_strokeLineJoinSet)
334 pen.setJoinStyle(m_stroke.joinStyle());
335 if (m_strokeMiterLimitSet)
336 pen.setMiterLimit(m_stroke.miterLimit());
337
338 // You can have dash offset on solid strokes in SVG files, but not in Qt.
339 // QPen::setDashOffset() will set the pen style to Qt::CustomDashLine,
340 // so don't call the method if the pen is solid.
341 if (setDashOffsetNeeded && pen.style() != Qt::SolidLine) {
342 qreal currentWidth = pen.widthF();
343 if (currentWidth == 0)
344 currentWidth = 1;
345 pen.setDashOffset(states.strokeDashOffset / currentWidth);
346 }
347
348 pen.setCosmetic(states.vectorEffect);
349
350 p->setPen(pen);
351}
352
353void QSvgStrokeStyle::revert(QPainter *p, QSvgExtraStates &states)
354{
355 p->setPen(m_oldStroke);
356 states.strokeOpacity = m_oldStrokeOpacity;
357 states.strokeDashOffset = m_oldStrokeDashOffset;
358 states.vectorEffect = m_oldVectorEffect;
359}
360
361void QSvgStrokeStyle::setDashArray(const QList<qreal> &dashes)
362{
363 if (m_strokeWidthSet) {
364 QList<qreal> d = dashes;
365 qreal w = m_stroke.widthF();
366 if (w != 0 && w != 1) {
367 for (int i = 0; i < d.size(); ++i)
368 d[i] /= w;
369 }
370 m_stroke.setDashPattern(d);
371 } else {
372 m_stroke.setDashPattern(dashes);
373 }
374 m_strokeDashArraySet = 1;
375}
376
377QSvgSolidColorStyle::QSvgSolidColorStyle(const QColor &color)
378 : m_solidColor(color)
379{
380}
381
382QSvgGradientStyle::QSvgGradientStyle(QGradient *grad)
383 : m_gradient(grad), m_gradientStopsSet(false)
384{
385}
386
387QBrush QSvgGradientStyle::brush(QPainter *, const QSvgNode *, QSvgExtraStates &)
388{
389 if (!m_link.isEmpty()) {
390 resolveStops();
391 }
392
393 // If the gradient is marked as empty, insert transparent black
394 if (!m_gradientStopsSet) {
395 m_gradient->setStops(QGradientStops() << QGradientStop(0.0, QColor(0, 0, 0, 0)));
396 m_gradientStopsSet = true;
397 }
398
399 QBrush b(*m_gradient);
400
401 if (!m_transform.isIdentity())
402 b.setTransform(m_transform);
403
404 return b;
405}
406
407
408void QSvgGradientStyle::setTransform(const QTransform &transform)
409{
410 m_transform = transform;
411}
412
413QSvgPatternStyle::QSvgPatternStyle(QSvgPattern *pattern)
414 : m_pattern(pattern)
415{
416
417}
418
419QBrush QSvgPatternStyle::brush(QPainter *p, const QSvgNode *node, QSvgExtraStates &states)
420{
421 m_patternImage = m_pattern->patternImage(p, states, patternElement: node);
422 QBrush b(m_patternImage);
423 b.setTransform(m_pattern->appliedTransform());
424 return b;
425}
426
427QSvgTransformStyle::QSvgTransformStyle(const QTransform &trans)
428 : m_transform(trans)
429{
430}
431
432void QSvgTransformStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &)
433{
434 m_oldWorldTransform.push(t: p->worldTransform());
435 p->setWorldTransform(matrix: m_transform, combine: true);
436}
437
438void QSvgTransformStyle::revert(QPainter *p, QSvgExtraStates &)
439{
440 QTransform oldTransform = m_oldWorldTransform.size() == 1 ? m_oldWorldTransform.top()
441 : m_oldWorldTransform.pop();
442 p->setWorldTransform(matrix: oldTransform, combine: false /* don't combine */);
443}
444
445QSvgStyleProperty::Type QSvgQualityStyle::type() const
446{
447 return QUALITY;
448}
449
450QSvgStyleProperty::Type QSvgFillStyle::type() const
451{
452 return FILL;
453}
454
455QSvgStyleProperty::Type QSvgViewportFillStyle::type() const
456{
457 return VIEWPORT_FILL;
458}
459
460QSvgStyleProperty::Type QSvgFontStyle::type() const
461{
462 return FONT;
463}
464
465QSvgStyleProperty::Type QSvgStrokeStyle::type() const
466{
467 return STROKE;
468}
469
470QSvgStyleProperty::Type QSvgSolidColorStyle::type() const
471{
472 return SOLID_COLOR;
473}
474
475QSvgStyleProperty::Type QSvgGradientStyle::type() const
476{
477 return GRADIENT;
478}
479
480QSvgStyleProperty::Type QSvgPatternStyle::type() const
481{
482 return PATTERN;
483}
484
485QSvgStyleProperty::Type QSvgTransformStyle::type() const
486{
487 return TRANSFORM;
488}
489
490
491QSvgCompOpStyle::QSvgCompOpStyle(QPainter::CompositionMode mode)
492 : m_mode(mode)
493{
494
495}
496
497void QSvgCompOpStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &)
498{
499 m_oldMode = p->compositionMode();
500 p->setCompositionMode(m_mode);
501}
502
503void QSvgCompOpStyle::revert(QPainter *p, QSvgExtraStates &)
504{
505 p->setCompositionMode(m_oldMode);
506}
507
508QSvgStyleProperty::Type QSvgCompOpStyle::type() const
509{
510 return COMP_OP;
511}
512
513QSvgStyle::~QSvgStyle()
514{
515}
516
517void QSvgStyle::apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states)
518{
519 if (quality) {
520 quality->apply(p, node, states);
521 }
522
523 if (fill) {
524 fill->apply(p, n: node, states);
525 }
526
527 if (viewportFill) {
528 viewportFill->apply(p, node, states);
529 }
530
531 if (font) {
532 font->apply(p, node, states);
533 }
534
535 if (stroke) {
536 stroke->apply(p, n: node, states);
537 }
538
539 if (transform) {
540 transform->apply(p, node, states);
541 }
542
543 for (auto it = animateColors.constBegin(); it != animateColors.constEnd(); ++it)
544 (*it)->apply(p, node, states);
545
546 //animated transforms have to be applied
547 //_after_ the original object transformations
548 if (!animateTransforms.isEmpty()) {
549 qreal totalTimeElapsed = node->document()->currentElapsed();
550 // Find the last animateTransform with additive="replace", since this will override all
551 // previous animateTransforms.
552 QList<QSvgRefCounter<QSvgAnimateTransform> >::const_iterator itr = animateTransforms.constEnd();
553 do {
554 --itr;
555 if ((*itr)->animActive(totalTimeElapsed)
556 && (*itr)->additiveType() == QSvgAnimateTransform::Replace) {
557 // An animateTransform with additive="replace" will replace the transform attribute.
558 if (transform)
559 transform->revert(p, states);
560 break;
561 }
562 } while (itr != animateTransforms.constBegin());
563
564 // Apply the animateTransforms after and including the last one with additive="replace".
565 for (; itr != animateTransforms.constEnd(); ++itr) {
566 if ((*itr)->animActive(totalTimeElapsed))
567 (*itr)->apply(p, node, states);
568 }
569 }
570
571 if (opacity) {
572 opacity->apply(p, node, states);
573 }
574
575 if (compop) {
576 compop->apply(p, node, states);
577 }
578}
579
580void QSvgStyle::revert(QPainter *p, QSvgExtraStates &states)
581{
582 if (quality) {
583 quality->revert(p, states);
584 }
585
586 if (fill) {
587 fill->revert(p, states);
588 }
589
590 if (viewportFill) {
591 viewportFill->revert(p, states);
592 }
593
594 if (font) {
595 font->revert(p, states);
596 }
597
598 if (stroke) {
599 stroke->revert(p, states);
600 }
601
602 //animated transforms need to be reverted _before_
603 //the native transforms
604 if (!animateTransforms.isEmpty()) {
605 QList<QSvgRefCounter<QSvgAnimateTransform> >::const_iterator itr = animateTransforms.constBegin();
606 for (; itr != animateTransforms.constEnd(); ++itr) {
607 if ((*itr)->transformApplied()) {
608 (*itr)->revert(p, states);
609 break;
610 }
611 }
612 for (; itr != animateTransforms.constEnd(); ++itr)
613 (*itr)->clearTransformApplied();
614 }
615
616 if (transform) {
617 transform->revert(p, states);
618 }
619
620 for (auto it = animateColors.constBegin(); it != animateColors.constEnd(); ++it)
621 (*it)->revert(p, states);
622
623 if (opacity) {
624 opacity->revert(p, states);
625 }
626
627 if (compop) {
628 compop->revert(p, states);
629 }
630}
631
632QSvgAnimate::QSvgAnimate()
633 : QSvgStyleProperty(),
634 m_from(-1),
635 m_totalRunningTime(0),
636 m_end(0),
637 m_repeatCount(-1.0),
638 m_finished(false)
639
640{}
641
642void QSvgAnimate::setRepeatCount(qreal repeatCount)
643{
644 m_repeatCount = repeatCount;
645}
646
647void QSvgAnimate::setRunningTime(int startMs, int durMs, int endMs, int by)
648{
649 Q_UNUSED(by)
650 m_from = startMs;
651 m_end = endMs;
652 m_totalRunningTime = startMs + durMs;
653}
654
655qreal QSvgAnimate::lerp(qreal a, qreal b, qreal t) const
656{
657 return a + (b - a) * t;
658}
659
660qreal QSvgAnimate::currentIterTimeFraction(qreal elpasedTime)
661{
662 qreal fractionOfTotalTime = 0;
663 if (m_totalRunningTime != 0) {
664 fractionOfTotalTime = (elpasedTime - m_from) / m_totalRunningTime;
665 if (m_repeatCount >= 0 && m_repeatCount < fractionOfTotalTime) {
666 m_finished = true;
667 fractionOfTotalTime = m_repeatCount;
668 }
669 }
670
671 return fractionOfTotalTime - std::trunc(x: fractionOfTotalTime);
672}
673
674QSvgAnimateTransform::QSvgAnimateTransform()
675 : m_type(Empty),
676 m_additive(Replace),
677 m_count(0),
678 m_freeze(false),
679 m_transformApplied(false)
680{
681}
682
683void QSvgAnimateTransform::setArgs(TransformType type, Additive additive, const QList<qreal> &args)
684{
685 m_type = type;
686 m_args = args;
687 m_additive = additive;
688 Q_ASSERT(!(args.size()%3));
689 m_count = args.size() / 3;
690}
691
692void QSvgAnimateTransform::apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &)
693{
694 m_oldWorldTransform = p->worldTransform();
695 resolveMatrix(node);
696 p->setWorldTransform(matrix: m_transform, combine: true);
697 m_transformApplied = true;
698}
699
700void QSvgAnimateTransform::revert(QPainter *p, QSvgExtraStates &)
701{
702 p->setWorldTransform(matrix: m_oldWorldTransform, combine: false /* don't combine */);
703 m_transformApplied = false;
704}
705
706void QSvgAnimateTransform::resolveMatrix(const QSvgNode *node)
707{
708 qreal elapsedTime = node->document()->currentElapsed();
709 if (elapsedTime < m_from || m_finished)
710 return;
711
712 qreal fractionOfCurrentIterationTime = currentIterTimeFraction(elpasedTime: elapsedTime);
713 qreal currentIndexPosition = fractionOfCurrentIterationTime * (m_count - 1);
714 int endElem = qCeil(v: currentIndexPosition);
715 int startElem = qMax(a: endElem - 1, b: 0);
716
717 qreal fractionOfCurrentElement = currentIndexPosition - std::trunc(x: currentIndexPosition);
718
719 switch(m_type)
720 {
721 case Translate: {
722 startElem *= 3;
723 endElem *= 3;
724 qreal from1, from2;
725 qreal to1, to2;
726 from1 = m_args[startElem++];
727 from2 = m_args[startElem++];
728 to1 = m_args[endElem++];
729 to2 = m_args[endElem++];
730
731 qreal transX = lerp(a: from1, b: to1, t: fractionOfCurrentElement);
732 qreal transY = lerp(a: from2, b: to2, t: fractionOfCurrentElement);
733 m_transform = QTransform();
734 m_transform.translate(dx: transX, dy: transY);
735 break;
736 }
737 case Scale: {
738 startElem *= 3;
739 endElem *= 3;
740 qreal from1, from2;
741 qreal to1, to2;
742 from1 = m_args[startElem++];
743 from2 = m_args[startElem++];
744 to1 = m_args[endElem++];
745 to2 = m_args[endElem++];
746
747 qreal scaleX = lerp(a: from1, b: to1, t: fractionOfCurrentElement);
748 qreal scaleY = lerp(a: from2, b: to2, t: fractionOfCurrentElement);
749 if (scaleY == 0)
750 scaleY = scaleX;
751 m_transform = QTransform();
752 m_transform.scale(sx: scaleX, sy: scaleY);
753 break;
754 }
755 case Rotate: {
756 startElem *= 3;
757 endElem *= 3;
758 qreal from1, from2, from3;
759 qreal to1, to2, to3;
760 from1 = m_args[startElem++];
761 from2 = m_args[startElem++];
762 from3 = m_args[startElem++];
763 to1 = m_args[endElem++];
764 to2 = m_args[endElem++];
765 to3 = m_args[endElem++];
766
767 qreal rotationDiff = (to1 - from1) * fractionOfCurrentElement;
768
769 qreal transX = lerp(a: from2, b: to2, t: fractionOfCurrentElement);
770 qreal transY = lerp(a: from3, b: to3, t: fractionOfCurrentElement);
771 m_transform = QTransform();
772 m_transform.translate(dx: transX, dy: transY);
773 m_transform.rotate(a: rotationDiff);
774 m_transform.translate(dx: -transX, dy: -transY);
775 break;
776 }
777 case SkewX: {
778 startElem *= 3;
779 endElem *= 3;
780 qreal from1;
781 qreal to1;
782 from1 = m_args[startElem++];
783 to1 = m_args[endElem++];
784
785 qreal skewX = lerp(a: from1, b: to1, t: fractionOfCurrentElement);
786 m_transform = QTransform();
787 m_transform.shear(sh: qTan(v: qDegreesToRadians(degrees: skewX)), sv: 0);
788 break;
789 }
790 case SkewY: {
791 startElem *= 3;
792 endElem *= 3;
793 qreal from1;
794 qreal to1;
795 from1 = m_args[startElem++];
796 to1 = m_args[endElem++];
797
798 qreal skewY = lerp(a: from1, b: to1, t: fractionOfCurrentElement);
799 m_transform = QTransform();
800 m_transform.shear(sh: 0, sv: qTan(v: qDegreesToRadians(degrees: skewY)));
801 break;
802 }
803 default:
804 break;
805 }
806}
807
808QSvgStyleProperty::Type QSvgAnimateTransform::type() const
809{
810 return ANIMATE_TRANSFORM;
811}
812
813void QSvgAnimateTransform::setFreeze(bool freeze)
814{
815 m_freeze = freeze;
816}
817
818QSvgAnimateColor::QSvgAnimateColor()
819 : m_fill(false),
820 m_freeze(false)
821{
822}
823
824void QSvgAnimateColor::setArgs(bool fill,
825 const QList<QColor> &colors)
826{
827 m_fill = fill;
828 m_colors = colors;
829}
830
831void QSvgAnimateColor::setFreeze(bool freeze)
832{
833 m_freeze = freeze;
834}
835
836void QSvgAnimateColor::apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &)
837{
838 qreal elapsedTime = node->document()->currentElapsed();
839 if (elapsedTime < m_from || m_finished)
840 return;
841
842 qreal fractionOfCurrentIterationTime = currentIterTimeFraction(elpasedTime: elapsedTime);
843
844 qreal currentPosition = fractionOfCurrentIterationTime * (m_colors.size() - 1);
845
846 int startElem = qFloor(v: currentPosition);
847 int endElem = qCeil(v: currentPosition);
848 QColor start = m_colors[startElem];
849 QColor end = m_colors[endElem];
850
851 qreal percentOfColorMorph = currentPosition;
852 if (percentOfColorMorph > 1) {
853 percentOfColorMorph -= ((int)percentOfColorMorph);
854 }
855
856 int alpha = lerp(a: start.alpha(), b: end.alpha(), t: percentOfColorMorph);
857 int red = lerp(a: start.red(), b: end.red(), t: percentOfColorMorph);
858 int green = lerp(a: start.green(), b: end.green(), t: percentOfColorMorph);
859 int blue = lerp(a: start.blue(), b: end.blue(), t: percentOfColorMorph);;
860
861 QColor color(red, green, blue, alpha);
862
863 if (m_fill) {
864 QBrush b = p->brush();
865 m_oldBrush = b;
866 b.setColor(color);
867 p->setBrush(b);
868 } else {
869 QPen pen = p->pen();
870 m_oldPen = pen;
871 pen.setColor(color);
872 p->setPen(pen);
873 }
874}
875
876void QSvgAnimateColor::revert(QPainter *p, QSvgExtraStates &)
877{
878 if (m_fill) {
879 p->setBrush(m_oldBrush);
880 } else {
881 p->setPen(m_oldPen);
882 }
883}
884
885QSvgStyleProperty::Type QSvgAnimateColor::type() const
886{
887 return ANIMATE_COLOR;
888}
889
890QSvgOpacityStyle::QSvgOpacityStyle(qreal opacity)
891 : m_opacity(opacity), m_oldOpacity(0)
892{
893
894}
895
896void QSvgOpacityStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &)
897{
898 m_oldOpacity = p->opacity();
899 p->setOpacity(m_opacity * m_oldOpacity);
900}
901
902void QSvgOpacityStyle::revert(QPainter *p, QSvgExtraStates &)
903{
904 p->setOpacity(m_oldOpacity);
905}
906
907QSvgStyleProperty::Type QSvgOpacityStyle::type() const
908{
909 return OPACITY;
910}
911
912void QSvgGradientStyle::setStopLink(const QString &link, QSvgTinyDocument *doc)
913{
914 m_link = link;
915 m_doc = doc;
916}
917
918void QSvgGradientStyle::resolveStops()
919{
920 QStringList visited;
921 resolveStops_helper(visited: &visited);
922}
923
924void QSvgGradientStyle::resolveStops_helper(QStringList *visited)
925{
926 if (!m_link.isEmpty() && m_doc) {
927 QSvgStyleProperty *prop = m_doc->styleProperty(id: m_link);
928 if (prop && !visited->contains(str: m_link)) {
929 visited->append(t: m_link);
930 if (prop->type() == QSvgStyleProperty::GRADIENT) {
931 QSvgGradientStyle *st =
932 static_cast<QSvgGradientStyle*>(prop);
933 st->resolveStops_helper(visited);
934 m_gradient->setStops(st->qgradient()->stops());
935 m_gradientStopsSet = st->gradientStopsSet();
936 }
937 } else {
938 qWarning(msg: "Could not resolve property : %s", qPrintable(m_link));
939 }
940 m_link = QString();
941 }
942}
943
944QT_END_NAMESPACE
945

source code of qtsvg/src/svg/qsvgstyle.cpp