Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
qsvgcsshandler.cpp
Go to the documentation of this file.
1// Copyright (C) 2025 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// Qt-Security score:critical reason:data-parser
4
5#include "qsvgcsshandler_p.h"
6#include <QtSvg/private/qsvgstyleselector_p.h>
7#include <QtSvg/private/qsvganimatedproperty_p.h>
8#include <QtSvg/private/qsvgutils_p.h>
9#include <QtGui/private/qmath_p.h>
10#include <QtCore/qlist.h>
11
12QT_BEGIN_NAMESPACE
13
14namespace {
15
21
22bool fillPropertyEasing(const QList<CssKeyFrameValue> &keyFrames, QSvgAbstractAnimatedProperty *prop)
23{
24 for (const CssKeyFrameValue &keyFrameValue : keyFrames) {
25 QStringView timingFunctionStr = QSvgCssHandler::parseDecltoString(keyFrameValue.timingFunction);
26 QSvgEasingInterfacePtr easing;
27 if (timingFunctionStr == QStringLiteral("linear")) {
28 easing = QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction::Linear);
29 } else if (timingFunctionStr == QStringLiteral("ease-in")) {
30 easing = QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction::EaseIn);
31 } else if (timingFunctionStr == QStringLiteral("ease-out")) {
32 easing = QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction::EaseOut);
33 } else if (timingFunctionStr == QStringLiteral("ease-in-out")) {
34 easing = QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction::EaseInOut);
35 } else if (timingFunctionStr == QStringLiteral("step-end")) {
36 easing = QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction::Steps,
37 QSvgCssValues::StepValues{quint32(1),
38 QSvgCssValues::StepPosition::End});
39 } else if (timingFunctionStr == QStringLiteral("step-start")) {
40 easing = QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction::Steps,
41 QSvgCssValues::StepValues{quint32(1),
42 QSvgCssValues::StepPosition::Start});
43 }
44
45 prop->appendEasing(std::move(easing));
46 }
47
48
49
50 return true;
51}
52
53bool fillColorProperty(const QList<CssKeyFrameValue> &keyFrames, QSvgAnimatedPropertyColor *prop)
54{
55 for (CssKeyFrameValue keyFrame : keyFrames) {
56 if (keyFrame.values.size() != 1)
57 return false;
58
59 QString colorStr = keyFrame.values.first().toString();
60 QColor color = QColor::fromString(colorStr);
61 prop->appendColor(color);
62 prop->appendKeyFrame(keyFrame.keyFrame);
63 }
64
65 return true;
66}
67
68bool fillOpacityProperty(const QList<CssKeyFrameValue> &keyFrames, QSvgAnimatedPropertyFloat *prop)
69{
70 for (CssKeyFrameValue keyFrame : keyFrames) {
71 if (keyFrame.values.size() != 1)
72 return false;
73
74 QString opacity = keyFrame.values.first().toString();
75 prop->appendValue(opacity.toDouble());
76 prop->appendKeyFrame(keyFrame.keyFrame);
77 }
78
79 return true;
80}
81
82bool validateTransform(QList<QList<QSvgAnimatedPropertyTransform::TransformComponent>> &keyFrameComponents) {
83
84 if (keyFrameComponents.size() < 2)
85 return false;
86
87 qsizetype maxIndex = 0;
88 qsizetype maxSize = 0;
89 for (int i = 1; i < keyFrameComponents.size(); i++) {
90 auto &listA = keyFrameComponents[i - 1];
91 auto &listB = keyFrameComponents[i];
92 for (int j = 0; j < qMin(listA.size(), listB.size()); j++) {
93 auto typeA = listA.at(j).type;
94 auto typeB = listB.at(j).type;
95 // TODO: Handle type mismatch as mentioned in CSS Transform Module specs.
96 if (typeA != typeB)
97 return false;
98 }
99
100 if (listA.size() > maxSize) {
101 maxIndex = i - 1;
102 maxSize = listA.size();
103 }
104
105 if (listB.size() > maxSize) {
106 maxIndex = i;
107 maxSize = listB.size();
108 }
109 }
110
111 const auto &longList = keyFrameComponents.at(maxIndex);
112 // pad the shorter list with identical transforms set to default values.
113 for (auto &list : keyFrameComponents) {
114 qsizetype size = list.size();
115
116 for (int j = size; j < maxSize; j++) {
117 QSvgAnimatedPropertyTransform::TransformComponent comp = longList.value(j);
118 switch (comp.type) {
119 case QSvgAnimatedPropertyTransform::TransformComponent::Translate:
120 case QSvgAnimatedPropertyTransform::TransformComponent::Skew:
121 comp.values[0] = 0;
122 comp.values[1] = 0;
123 break;
124 case QSvgAnimatedPropertyTransform::TransformComponent::Rotate:
125 comp.values[0] = 0;
126 comp.values[1] = 0;
127 comp.values[2] = 0;
128 break;
129 case QSvgAnimatedPropertyTransform::TransformComponent::Scale:
130 comp.values[0] = 1;
131 comp.values[1] = 1;
132 break;
133 default:
134 break;
135 }
136 list.append(comp);
137 }
138 }
139
140 return true;
141}
142
143bool fillTransformProperty(const QList<CssKeyFrameValue> &keyFrames, QSvgAnimatedPropertyTransform *prop)
144{
145 // Stores each key frame's list of components
146 QList<QList<QSvgAnimatedPropertyTransform::TransformComponent>> keyFramesComponents;
147
148 for (const CssKeyFrameValue &keyFrame : keyFrames) {
149 QList<QSvgAnimatedPropertyTransform::TransformComponent> components;
150 for (const QCss::Value &val : keyFrame.values) {
151 if (val.type == QCss::Value::Function) {
152 QStringList lst = val.variant.toStringList();
153 QStringView transformType = lst.value(0);
154 QStringList args = lst.value(1).split(QStringLiteral(","), Qt::SkipEmptyParts);
155 if (transformType == QStringLiteral("scale")) {
156 QSvgAnimatedPropertyTransform::TransformComponent component;
157 qreal scale0 = QSvgUtils::toDouble(args.value(0).trimmed());
158 qreal scale1 = QSvgUtils::toDouble(args.value(1).trimmed());
159 component.type = QSvgAnimatedPropertyTransform::TransformComponent::Scale;
160 component.values.append(scale0);
161 component.values.append(scale1);
162 components.append(component);
163 } else if (transformType == QStringLiteral("translate")) {
164 QSvgAnimatedPropertyTransform::TransformComponent component;
165 QSvgUtils::LengthType type;
166 qreal translate0 = QSvgUtils::parseLength(args.value(0), &type);
167 translate0 = QSvgUtils::convertToPixels(translate0, false, type);
168 qreal translate1 = QSvgUtils::parseLength(args.value(1), &type);
169 translate1 = QSvgUtils::convertToPixels(translate1, false, type);
170 component.type = QSvgAnimatedPropertyTransform::TransformComponent::Translate;
171 component.values.append(translate0);
172 component.values.append(translate1);
173 components.append(component);
174 } else if (transformType == QStringLiteral("rotate")) {
175 QSvgAnimatedPropertyTransform::TransformComponent component;
176 qreal rotationAngle = QSvgUtils::parseAngle(args.value(0)).value_or(0);
177 component.type = QSvgAnimatedPropertyTransform::TransformComponent::Rotate;
178 component.values.append(rotationAngle);
179 component.values.append(0);
180 component.values.append(0);
181 components.append(component);
182 } else if (transformType == QStringLiteral("skew")) {
183 QSvgAnimatedPropertyTransform::TransformComponent component;
184 qreal skew0 = QSvgUtils::parseAngle(args.value(0)).value_or(0);
185 qreal skew1 = QSvgUtils::parseAngle(args.value(1)).value_or(0);
186 component.type = QSvgAnimatedPropertyTransform::TransformComponent::Skew;
187 component.values.append(skew0);
188 component.values.append(skew1);
189 components.append(component);
190 } else if (transformType == QStringLiteral("matrix")) {
191 QSvgAnimatedPropertyTransform::TransformComponent component1, component2, component3;
192 QSvgUtils::LengthType type;
193 qreal translate0 = QSvgUtils::parseLength(args.value(4), &type);
194 translate0 = QSvgUtils::convertToPixels(translate0, false, type);
195 qreal translate1 = QSvgUtils::parseLength(args.value(5), &type);
196 translate1 = QSvgUtils::convertToPixels(translate1, false, type);
197 qreal scale0 = QSvgUtils::toDouble(args.value(0).trimmed());
198 qreal scale1 = QSvgUtils::toDouble(args.value(3).trimmed());
199 qreal skew0 = QSvgUtils::toDouble((args.value(1).trimmed()));
200 qreal skew1 = QSvgUtils::toDouble((args.value(2).trimmed()));
201 component1.type = QSvgAnimatedPropertyTransform::TransformComponent::Translate;
202 component1.values.append(translate0);
203 component1.values.append(translate1);
204 component2.type = QSvgAnimatedPropertyTransform::TransformComponent::Scale;
205 component2.values.append(scale0);
206 component2.values.append(scale1);
207 component3.type = QSvgAnimatedPropertyTransform::TransformComponent::Skew;
208 component3.values.append(skew0);
209 component3.values.append(skew1);
210 components.append(component1);
211 components.append(component2);
212 components.append(component3);
213 }
214 }
215 }
216 keyFramesComponents.append(components);
217 prop->appendKeyFrame(keyFrame.keyFrame);
218 }
219
220 if (!validateTransform(keyFramesComponents))
221 return false;
222
223 for (const auto &comp : std::as_const(keyFramesComponents)) {
224 prop->appendComponents(comp);
225 }
226 prop->setTransformCount(keyFramesComponents.first().size());
227
228 return true;
229}
230
231bool fillOffsetDistanceProperty(const QList<CssKeyFrameValue> &keyFrames, QSvgAnimatedPropertyFloat *prop)
232{
233 for (const CssKeyFrameValue &keyFrame : keyFrames) {
234 if (keyFrame.values.size() != 1)
235 return false;
236
237 QString offsetDistance = keyFrame.values.first().toString();
238
239 bool ok = false;
240 qreal distance = offsetDistance.toDouble(&ok);
241 if (!ok)
242 return false;
243
244 QCss::Value::Type type = keyFrame.values.first().type;
245 if (type != QCss::Value::Percentage && !qFuzzyCompare(distance, 0.))
246 return false;
247 distance /= 100;
248 prop->appendValue(distance);
249 prop->appendKeyFrame(keyFrame.keyFrame);
250 }
251
252 return true;
253}
254
255}
256
257QSvgCssHandler::QSvgCssHandler()
258 : m_selector(new QSvgStyleSelector)
259{
260
261}
262
263QSvgCssHandler::~QSvgCssHandler()
264{
265 delete m_selector;
266 m_selector = nullptr;
267}
268
269QSvgCssAnimation *QSvgCssHandler::createAnimation(QStringView name)
270{
271 if (!m_animations.contains(name))
272 return nullptr;
273
274 QCss::AnimationRule animationRule = m_animations[name];
275 QHash<QString, QSvgAbstractAnimatedProperty*> animatedProperies;
276 QSvgCssAnimation *animation = new QSvgCssAnimation;
277
278
279 // Css Parser returns a list of all properties for each key frame. Here,
280 // we store the key frames and values for each property for easier parsing.
281 QHash<QString, QList<CssKeyFrameValue>> keyFrameValues;
282 for (const auto &ruleSet : std::as_const(animationRule.ruleSets)) {
283 for (QCss::Declaration decl : ruleSet.declarations) {
284 QCss::Value timingFunction;
285 CssKeyFrameValue keyFrameValue = {ruleSet.keyFrame, decl.d->values, ruleSet.timingFunction};
286 QList<CssKeyFrameValue> &value = keyFrameValues[decl.d->property];
287 value.append(keyFrameValue);
288 }
289 }
290
291 for (auto it = keyFrameValues.begin(); it != keyFrameValues.end(); it++) {
292 QStringView property = it.key();
293 const QList<CssKeyFrameValue> &keyFrames = it.value();
294 auto *prop = QSvgAbstractAnimatedProperty::createAnimatedProperty(property.toString());
295 if (!prop)
296 continue;
297
298 bool result = false;
299 if (property == QLatin1StringView("fill") || property == QLatin1StringView("stroke"))
300 result = fillColorProperty(keyFrames, static_cast<QSvgAnimatedPropertyColor*>(prop));
301 else if (property == QLatin1StringView("transform"))
302 result = fillTransformProperty(keyFrames, static_cast<QSvgAnimatedPropertyTransform*>(prop));
303 else if (property == QLatin1StringView("fill-opacity") || property == QLatin1StringView("stroke-opacity")
304 || property == QLatin1StringView("opacity"))
305 result = fillOpacityProperty(keyFrames, static_cast<QSvgAnimatedPropertyFloat*>(prop));
306 else if (property == QLatin1StringView("offset-distance"))
307 result = fillOffsetDistanceProperty(keyFrames, static_cast<QSvgAnimatedPropertyFloat*>(prop));
308
309 result &= fillPropertyEasing(keyFrames, prop);
310 if (!result) {
311 delete prop;
312 continue;
313 }
314
315 animatedProperies[property] = prop;
316 }
317
318 for (auto it = animatedProperies.begin(); it != animatedProperies.end(); it++)
319 animation->appendProperty(it.value());
320
321 return animation;
322}
323
324QSvgCssEasingPtr QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction easingFunction,
325 const QSvgCssValues::EasingValues &values)
326{
327 QSvgCssEasingPtr easing;
328
329 switch (easingFunction) {
330 case QSvgCssValues::EasingFunction::Ease:
331 case QSvgCssValues::EasingFunction::EaseIn:
332 case QSvgCssValues::EasingFunction::EaseOut:
333 case QSvgCssValues::EasingFunction::EaseInOut:
334 case QSvgCssValues::EasingFunction::Linear:
335 easing = createEasingFromKeyword(easingFunction);
336 break;
337 case QSvgCssValues::EasingFunction::Steps:
338 easing = createStepsEasing(std::get<QSvgCssValues::StepValues>(values));
339 break;
340 default:
341 easing = createEasingFromKeyword(QSvgCssValues::EasingFunction::Ease);
342 break;
343 }
344
345 return easing;
346}
347
348void QSvgCssHandler::collectAnimations(const QCss::StyleSheet &sheet)
349{
350 auto sortFunction = [](QCss::AnimationRule::AnimationRuleSet r1, QCss::AnimationRule::AnimationRuleSet r2) {
351 return r1.keyFrame < r2.keyFrame;
352 };
353
354 QList<QCss::AnimationRule> animationRules = sheet.animationRules;
355 for (QCss::AnimationRule &rule : animationRules) {
356 std::sort(rule.ruleSets.begin(), rule.ruleSets.end(), sortFunction);
357 m_animations[rule.animName] = rule;
358 }
359}
360
361void QSvgCssHandler::parseStyleSheet(const QStringView str)
362{
363 QString css = str.toString();
364 QCss::StyleSheet sheet;
365 QCss::Parser(css).parse(&sheet);
366 m_selector->styleSheets.append(sheet);
367
368 collectAnimations(sheet);
369}
370
371QString QSvgCssHandler::parseDecltoString(const QCss::Declaration &decl)
372{
373 if (decl.d->property.isEmpty())
374 return QString();
375
376 QString valueStr;
377 const int valCount = decl.d->values.size();
378 for (int i = 0; i < valCount; ++i) {
379 QCss::Value val = decl.d->values.at(i);
380 switch (val.type) {
381 case QCss::Value::TermOperatorComma:
382 valueStr += QLatin1Char(';');
383 break;
384 case QCss::Value::Uri:
385 {
386 QString temp = val.toString();
387 temp.prepend(QLatin1String("url("));
388 temp.append(QLatin1Char(')'));
389 valueStr += temp;
390 break;
391 }
392 case QCss::Value::Function:
393 {
394 QStringList lst = val.variant.toStringList();
395 valueStr.append(lst.at(0));
396 valueStr.append(QLatin1Char('('));
397 for (int i = 1; i < lst.size(); ++i) {
398 valueStr.append(lst.at(i));
399 if ((i +1) < lst.size())
400 valueStr.append(QLatin1Char(','));
401 }
402 valueStr.append(QLatin1Char(')'));
403 break;
404 }
405 case QCss::Value::KnownIdentifier:
406 switch (val.variant.toInt()) {
407 case QCss::Value_None:
408 valueStr += QLatin1String("none");
409 break;
410 case QCss::Value_Auto:
411 valueStr += QLatin1String("auto");
412 break;
413 default:
414 valueStr += val.toString();
415 break;
416 }
417 break;
418 case QCss::Value::Percentage:
419 valueStr += val.toString() + QLatin1Char('%');
420 break;
421 default:
422 valueStr += val.toString();
423 break;
424 }
425
426 if (i + 1 < valCount)
427 valueStr += QLatin1Char(' ');
428 }
429
430 return valueStr;
431}
432
433void QSvgCssHandler::parseCSStoXMLAttrs(const QList<QCss::Declaration> &declarations, QXmlStreamAttributes &attributes) const
434{
435 for (int i = 0; i < declarations.size(); ++i) {
436 const QCss::Declaration &decl = declarations.at(i);
437 QString valueStr = parseDecltoString(decl);
438 if (!valueStr.isEmpty())
439 attributes.append(QString(), decl.d->property, valueStr);
440 }
441}
442
443void QSvgCssHandler::parseCSStoXMLAttrs(const QString &css, QXmlStreamAttributes &attributes) const
444{
445 // preprocess (for unicode escapes), tokenize and remove comments
446 QCss::Parser parser(css);
447 QString key;
448
449 while (parser.hasNext()) {
450 parser.skipSpace();
451
452 if (!parser.hasNext())
453 break;
454 parser.next();
455
456 QString name;
457 QString value;
458
459 if (parser.hasEscapeSequences) {
460 key = parser.lexem();
461 name = key;
462 } else {
463 const QCss::Symbol &sym = parser.symbol();
464 name = sym.text.mid(sym.start, sym.len);
465 }
466
467 parser.skipSpace();
468 if (!parser.test(QCss::COLON))
469 break;
470
471 parser.skipSpace();
472 if (!parser.hasNext())
473 break;
474
475 const int firstSymbol = parser.index;
476 int symbolCount = 0;
477 do {
478 parser.next();
479 ++symbolCount;
480 } while (parser.hasNext() && !parser.test(QCss::SEMICOLON));
481
482 bool canExtractValueByRef = !parser.hasEscapeSequences;
483 if (canExtractValueByRef) {
484 int len = parser.symbols.at(firstSymbol).len;
485 for (int i = firstSymbol + 1; i < firstSymbol + symbolCount; ++i) {
486 len += parser.symbols.at(i).len;
487
488 if (parser.symbols.at(i - 1).start + parser.symbols.at(i - 1).len
489 != parser.symbols.at(i).start) {
490 canExtractValueByRef = false;
491 break;
492 }
493 }
494 if (canExtractValueByRef) {
495 const QCss::Symbol &sym = parser.symbols.at(firstSymbol);
496 value = sym.text.mid(sym.start, len);
497 }
498 }
499 if (!canExtractValueByRef) {
500
501 for (int i = firstSymbol; i < parser.index - 1; ++i)
502 value += parser.symbols.at(i).lexem();
503 }
504
505 attributes.append(QString(), name, value);
506
507 parser.skipSpace();
508 }
509}
510
511void QSvgCssHandler::styleLookup(QSvgNode *node, QXmlStreamAttributes &attributes) const
512{
513 QCss::StyleSelector::NodePtr cssNode;
514 cssNode.ptr = node;
515 QList<QCss::Declaration> decls = m_selector->declarationsForNode(cssNode);
516
517 parseCSStoXMLAttrs(decls, attributes);
518}
519
520QSvgCssEasingPtr QSvgCssHandler::createEasingFromKeyword(QSvgCssValues::EasingFunction easingFunction)
521{
522 constexpr QPointF easeC1(0.25, 0.1);
523 constexpr QPointF easeC2(0.25, 1);
524 constexpr QPointF easeInC1(0.42, 0);
525 constexpr QPointF easeInC2(1, 1);
526 constexpr QPointF easeOutC1(0, 0);
527 constexpr QPointF easeOutC2(0.58, 1);
528 constexpr QPointF linearC1(0, 0);
529 constexpr QPointF linearC2(1, 1);
530
531 QSvgCssEasingPtr easing;
532
533 switch (easingFunction) {
534 case QSvgCssValues::EasingFunction::Ease:
535 easing = std::make_unique<QSvgCssCubicBezierEasing>(easingFunction, easeC1, easeC2);
536 break;
537 case QSvgCssValues::EasingFunction::EaseIn:
538 easing = std::make_unique<QSvgCssCubicBezierEasing>(easingFunction, easeInC1, easeInC2);
539 break;
540 case QSvgCssValues::EasingFunction::EaseOut:
541 easing = std::make_unique<QSvgCssCubicBezierEasing>(easingFunction, easeOutC1, easeOutC2);
542 break;
543 case QSvgCssValues::EasingFunction::EaseInOut:
544 easing = std::make_unique<QSvgCssCubicBezierEasing>(easingFunction, easeInC1, easeOutC2);
545 break;
546 case QSvgCssValues::EasingFunction::Linear:
547 easing = std::make_unique<QSvgCssCubicBezierEasing>(easingFunction, linearC1, linearC2);
548 break;
549 default:
550 Q_UNREACHABLE();
551 break;
552 }
553
554 return easing;
555}
556
557QSvgCssEasingPtr QSvgCssHandler::createStepsEasing(const QSvgCssValues::StepValues &values)
558{
559 quint32 steps = values.steps;
560 QSvgCssValues::StepPosition position = values.stepPosition;
561
562 return std::make_unique<QSvgCssStepsEasing>(steps, position);
563}
564
565QT_END_NAMESPACE
QT_BEGIN_NAMESPACE
Combined button and popup list for selecting options.
Definition qrandomaccessasyncfile_darwin.mm:17
QT_BEGIN_NAMESPACE::fillTransformProperty
bool fillTransformProperty(const QList< CssKeyFrameValue > &keyFrames, QSvgAnimatedPropertyTransform *prop)
Definition qsvgcsshandler.cpp:143
QT_BEGIN_NAMESPACE::fillOffsetDistanceProperty
bool fillOffsetDistanceProperty(const QList< CssKeyFrameValue > &keyFrames, QSvgAnimatedPropertyFloat *prop)
Definition qsvgcsshandler.cpp:231
QT_BEGIN_NAMESPACE::fillOpacityProperty
bool fillOpacityProperty(const QList< CssKeyFrameValue > &keyFrames, QSvgAnimatedPropertyFloat *prop)
Definition qsvgcsshandler.cpp:68
QT_BEGIN_NAMESPACE::fillPropertyEasing
bool fillPropertyEasing(const QList< CssKeyFrameValue > &keyFrames, QSvgAbstractAnimatedProperty *prop)
Definition qsvgcsshandler.cpp:22
QT_BEGIN_NAMESPACE::fillColorProperty
bool fillColorProperty(const QList< CssKeyFrameValue > &keyFrames, QSvgAnimatedPropertyColor *prop)
Definition qsvgcsshandler.cpp:53
QT_BEGIN_NAMESPACE::validateTransform
bool validateTransform(QList< QList< QSvgAnimatedPropertyTransform::TransformComponent > > &keyFrameComponents)
Definition qsvgcsshandler.cpp:82
QT_BEGIN_NAMESPACE::CssKeyFrameValue
Definition qsvgcsshandler.cpp:16
QT_BEGIN_NAMESPACE::CssKeyFrameValue::values
QList< QCss::Value > values
Definition qsvgcsshandler.cpp:18
QT_BEGIN_NAMESPACE::CssKeyFrameValue::timingFunction
QCss::Declaration timingFunction
Definition qsvgcsshandler.cpp:19
QT_BEGIN_NAMESPACE::CssKeyFrameValue::keyFrame
qreal keyFrame
Definition qsvgcsshandler.cpp:17