qsvgcsshandler.cpp

++ // Copyright (C) 2025 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:critical reason:data-parser

++

++ #include "qsvgcsshandler_p.h"

++ #include <QtSvg/private/qsvgstyleselector_p.h>

++ #include <QtSvg/private/qsvganimatedproperty_p.h>

++ #include <QtGui/private/qmath_p.h>

++ #include <QtGui/private/qguisvg_p.h>

++ #include <QtCore/qlist.h>

++

++ QT_BEGIN_NAMESPACE

++

++ namespace {

++

++ struct CssKeyFrameValue{

++     qreal keyFrame{0.0};

++     QList<QCss::Value> values;

++     QCss::Declaration timingFunction;

++ };

++

++ bool fillPropertyEasing(const QList<CssKeyFrameValue> &keyFrames, QSvgAbstractAnimatedProperty *prop)

++ {

++     for (const CssKeyFrameValue &keyFrameValue : keyFrames) {

++         QStringView timingFunctionStr = QSvgCssHandler::parseDecltoString(keyFrameValue.timingFunction);

++         QSvgEasingInterfacePtr easing;

++         if (timingFunctionStr == QStringLiteral("linear")) {

++             easing = QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction::Linear);

++         } else if (timingFunctionStr == QStringLiteral("ease-in")) {

++             easing = QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction::EaseIn);

++         } else if (timingFunctionStr == QStringLiteral("ease-out")) {

++             easing = QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction::EaseOut);

++         } else if (timingFunctionStr == QStringLiteral("ease-in-out")) {

++             easing = QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction::EaseInOut);

++         } else if (timingFunctionStr == QStringLiteral("step-end")) {

++             easing = QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction::Steps,

++                                                   QSvgCssValues::StepValues{quint32(1),

++                                                   QSvgCssValues::StepPosition::End});

++         } else if (timingFunctionStr == QStringLiteral("step-start")) {

++             easing = QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction::Steps,

++                                                   QSvgCssValues::StepValues{quint32(1),

++                                                   QSvgCssValues::StepPosition::Start});

++         }

++

++         prop->appendEasing(std::move(easing));

++     }

++

++

++

++     return true;

++ }

++

++ bool fillColorProperty(const QList<CssKeyFrameValue> &keyFrames, QSvgAnimatedPropertyColor *prop)

++ {

++     for (const CssKeyFrameValue &keyFrame : keyFrames) {

++         if (keyFrame.values.size() != 1)

++             return false;

++

++         QString colorStr = keyFrame.values.first().toString();

++         QColor color = QColor::fromString(colorStr);

++         prop->appendColor(color);

++         prop->appendKeyFrame(keyFrame.keyFrame);

++     }

++

++     return true;

++ }

++

++ bool fillOpacityProperty(const QList<CssKeyFrameValue> &keyFrames, QSvgAnimatedPropertyFloat *prop)

++ {

++     for (const CssKeyFrameValue &keyFrame : keyFrames) {

++         if (keyFrame.values.size() != 1)

++             return false;

++

++         QString opacity = keyFrame.values.first().toString();

++         prop->appendValue(opacity.toDouble());

++         prop->appendKeyFrame(keyFrame.keyFrame);

++     }

++

++     return true;

++ }

++

++ bool validateTransform(QList<QList<QSvgAnimatedPropertyTransform::TransformComponent>> &keyFrameComponents) {

++

++     if (keyFrameComponents.size() < 2)

++         return false;

++

++     qsizetype maxIndex = 0;

++     qsizetype maxSize = 0;

++     for (int i = 1; i < keyFrameComponents.size(); i++) {

++         auto &listA = keyFrameComponents[i - 1];

++         auto &listB = keyFrameComponents[i];

++         for (int j = 0; j < qMin(listA.size(), listB.size()); j++) {

++             auto typeA = listA.at(j).type;

++             auto typeB = listB.at(j).type;

++             // TODO: Handle type mismatch as mentioned in CSS Transform Module specs.

++             if (typeA != typeB)

++                 return false;

++         }

++

++         if (listA.size() > maxSize) {

++             maxIndex = i - 1;

++             maxSize = listA.size();

++         }

++

++         if (listB.size() > maxSize) {

++             maxIndex = i;

++             maxSize = listB.size();

++         }

++     }

++

++     const auto &longList = keyFrameComponents.at(maxIndex);

++     // pad the shorter list with identical transforms set to default values.

++     for (auto &list : keyFrameComponents) {

++         qsizetype size = list.size();

++

++         for (int j = size; j < maxSize; j++) {

++             QSvgAnimatedPropertyTransform::TransformComponent comp = longList.value(j);

++             switch (comp.type) {

++             case QSvgAnimatedPropertyTransform::TransformComponent::Translate:

++             case QSvgAnimatedPropertyTransform::TransformComponent::Skew:

++                 comp.values[0] = 0;

++                 comp.values[1] = 0;

++                 break;

++             case QSvgAnimatedPropertyTransform::TransformComponent::Rotate:

++                 comp.values[0] = 0;

++                 comp.values[1] = 0;

++                 comp.values[2] = 0;

++                 break;

++             case QSvgAnimatedPropertyTransform::TransformComponent::Scale:

++                 comp.values[0] = 1;

++                 comp.values[1] = 1;

++                 break;

++             default:

++                 break;

++             }

++             list.append(comp);

++         }

++     }

++

++     return true;

++ }

++

++ bool fillTransformProperty(const QList<CssKeyFrameValue> &keyFrames, QSvgAnimatedPropertyTransform *prop)

++ {

++     // Stores each key frame's list of components

++     QList<QList<QSvgAnimatedPropertyTransform::TransformComponent>> keyFramesComponents;

++

++     for (const CssKeyFrameValue &keyFrame : keyFrames) {

++         QList<QSvgAnimatedPropertyTransform::TransformComponent> components;

++         for (const QCss::Value &val : keyFrame.values) {

++             if (val.type == QCss::Value::Function) {

++                 const QStringList lst = val.variant.toStringList();

++                 const QStringView transformType = lst.value(0);

++                 const QList<QStringView> args =

++                         QStringView{ lst.value(1) }.split(QStringLiteral(","), Qt::SkipEmptyParts);

++                 if (transformType == QStringLiteral("scale")) {

++                     QSvgAnimatedPropertyTransform::TransformComponent component;

++                     qreal scale0 = QGuiSvg::toDouble(args.value(0).trimmed());

++                     qreal scale1 = QGuiSvg::toDouble(args.value(1).trimmed());

++                     component.type = QSvgAnimatedPropertyTransform::TransformComponent::Scale;

++                     component.values.append(scale0);

++                     component.values.append(scale1);

++                     components.append(component);

++                 } else if (transformType == QStringLiteral("translate")) {

++                     QSvgAnimatedPropertyTransform::TransformComponent component;

++                     QGuiSvg::LengthType type;

++                     qreal translate0 = QGuiSvg::parseLength(args.value(0), &type);

++                     translate0 = QGuiSvg::convertToPixels(translate0, false, type);

++                     qreal translate1 = QGuiSvg::parseLength(args.value(1), &type);

++                     translate1 = QGuiSvg::convertToPixels(translate1, false, type);

++                     component.type = QSvgAnimatedPropertyTransform::TransformComponent::Translate;

++                     component.values.append(translate0);

++                     component.values.append(translate1);

++                     components.append(component);

++                 } else if (transformType == QStringLiteral("rotate")) {

++                     QSvgAnimatedPropertyTransform::TransformComponent component;

++                     qreal rotationAngle = QGuiSvg::parseAngle(args.value(0)).value_or(0);

++                     component.type = QSvgAnimatedPropertyTransform::TransformComponent::Rotate;

++                     component.values.append(rotationAngle);

++                     component.values.append(0);

++                     component.values.append(0);

++                     components.append(component);

++                 } else if (transformType == QStringLiteral("skew")) {

++                     QSvgAnimatedPropertyTransform::TransformComponent component;

++                     qreal skew0 = QGuiSvg::parseAngle(args.value(0)).value_or(0);

++                     qreal skew1 = QGuiSvg::parseAngle(args.value(1)).value_or(0);

++                     component.type = QSvgAnimatedPropertyTransform::TransformComponent::Skew;

++                     component.values.append(skew0);

++                     component.values.append(skew1);

++                     components.append(component);

++                 } else if (transformType == QStringLiteral("matrix")) {

++                     QSvgAnimatedPropertyTransform::TransformComponent component1, component2, component3;

++                     QGuiSvg::LengthType type;

++                     qreal translate0 = QGuiSvg::parseLength(args.value(4), &type);

++                     translate0 = QGuiSvg::convertToPixels(translate0, false, type);

++                     qreal translate1 = QGuiSvg::parseLength(args.value(5), &type);

++                     translate1 = QGuiSvg::convertToPixels(translate1, false, type);

++                     qreal scale0 = QGuiSvg::toDouble(args.value(0).trimmed());

++                     qreal scale1 = QGuiSvg::toDouble(args.value(3).trimmed());

++                     qreal skew0 = QGuiSvg::toDouble((args.value(1).trimmed()));

++                     qreal skew1 = QGuiSvg::toDouble((args.value(2).trimmed()));

++                     component1.type = QSvgAnimatedPropertyTransform::TransformComponent::Translate;

++                     component1.values.append(translate0);

++                     component1.values.append(translate1);

++                     component2.type = QSvgAnimatedPropertyTransform::TransformComponent::Scale;

++                     component2.values.append(scale0);

++                     component2.values.append(scale1);

++                     component3.type = QSvgAnimatedPropertyTransform::TransformComponent::Skew;

++                     component3.values.append(skew0);

++                     component3.values.append(skew1);

++                     components.append(component1);

++                     components.append(component2);

++                     components.append(component3);

++                 }

++             }

++         }

++         keyFramesComponents.append(components);

++         prop->appendKeyFrame(keyFrame.keyFrame);

++     }

++

++     if (!validateTransform(keyFramesComponents))

++         return false;

++

++     for (const auto &comp : std::as_const(keyFramesComponents)) {

++         prop->appendComponents(comp);

++     }

++     prop->setTransformCount(keyFramesComponents.first().size());

++

++     return true;

++ }

++

++ bool fillOffsetDistanceProperty(const QList<CssKeyFrameValue> &keyFrames, QSvgAnimatedPropertyFloat *prop)

++ {

++     for (const CssKeyFrameValue &keyFrame : keyFrames) {

++         if (keyFrame.values.size() != 1)

++             return false;

++

++         QString offsetDistance = keyFrame.values.first().toString();

++

++         bool ok = false;

++         qreal distance = offsetDistance.toDouble(&ok);

++         if (!ok)

++             return false;

++

++         QCss::Value::Type type = keyFrame.values.first().type;

++         if (type != QCss::Value::Percentage && !qFuzzyCompare(distance, 0.))

++             return false;

++         distance /= 100;

++         prop->appendValue(distance);

++         prop->appendKeyFrame(keyFrame.keyFrame);

++     }

++

++     return true;

++ }

++

++ }

++

++ QSvgCssHandler::QSvgCssHandler()

++     : m_selector(new QSvgStyleSelector)

++ {

++

++ }

++

++ QSvgCssHandler::~QSvgCssHandler()

++ {

++     delete m_selector;

++     m_selector = nullptr;

++ }

++

++ QSvgCssAnimation *QSvgCssHandler::createAnimation(QStringView name)

++ {

++     if (!m_animations.contains(name))

++         return nullptr;

++

++     QCss::AnimationRule animationRule = m_animations[name];

++     QHash<QString, QSvgAbstractAnimatedProperty*> animatedProperies;

++     QSvgCssAnimation *animation = new QSvgCssAnimation;

++

++

++     // Css Parser returns a list of all properties for each key frame. Here,

++     // we store the key frames and values for each property for easier parsing.

++     QHash<QString, QList<CssKeyFrameValue>> keyFrameValues;

++     for (const auto &ruleSet : std::as_const(animationRule.ruleSets)) {

++         for (const QCss::Declaration &decl : ruleSet.declarations) {

++             QCss::Value timingFunction;

++             CssKeyFrameValue keyFrameValue = {ruleSet.keyFrame, decl.d->values, ruleSet.timingFunction};

++             QList<CssKeyFrameValue> &value = keyFrameValues[decl.d->property];

++             value.append(keyFrameValue);

++         }

++     }

++

++     for (auto it = keyFrameValues.begin(); it != keyFrameValues.end(); it++) {

++         QStringView property = it.key();

++         const QList<CssKeyFrameValue> &keyFrames = it.value();

++         auto *prop = QSvgAbstractAnimatedProperty::createAnimatedProperty(property.toString());

++         if (!prop)

++             continue;

++

++         bool result = false;

++         if (property == QLatin1StringView("fill") || property == QLatin1StringView("stroke"))

++             result = fillColorProperty(keyFrames, static_cast<QSvgAnimatedPropertyColor*>(prop));

++         else if (property == QLatin1StringView("transform"))

++             result = fillTransformProperty(keyFrames, static_cast<QSvgAnimatedPropertyTransform*>(prop));

++         else if (property == QLatin1StringView("fill-opacity") || property == QLatin1StringView("stroke-opacity")

++                  || property == QLatin1StringView("opacity"))

++             result = fillOpacityProperty(keyFrames, static_cast<QSvgAnimatedPropertyFloat*>(prop));

++         else if (property == QLatin1StringView("offset-distance"))

++             result = fillOffsetDistanceProperty(keyFrames, static_cast<QSvgAnimatedPropertyFloat*>(prop));

++

++         result &= fillPropertyEasing(keyFrames, prop);

++         if (!result) {

++             delete prop;

++             continue;

++         }

++

++         animatedProperies[property] = prop;

++     }

++

++     for (auto it = animatedProperies.begin(); it != animatedProperies.end(); it++)

++         animation->appendProperty(it.value());

++

++     return animation;

++ }

++

++ QSvgCssEasingPtr QSvgCssHandler::createEasing(QSvgCssValues::EasingFunction easingFunction,

++                                               const QSvgCssValues::EasingValues &values)

++ {

++     QSvgCssEasingPtr easing;

++

++     switch (easingFunction) {

++     case QSvgCssValues::EasingFunction::Ease:

++     case QSvgCssValues::EasingFunction::EaseIn:

++     case QSvgCssValues::EasingFunction::EaseOut:

++     case QSvgCssValues::EasingFunction::EaseInOut:

++     case QSvgCssValues::EasingFunction::Linear:

++         easing = createEasingFromKeyword(easingFunction);

++         break;

++     case QSvgCssValues::EasingFunction::Steps:

++         easing = createStepsEasing(std::get<QSvgCssValues::StepValues>(values));

++         break;

++     default:

++         easing = createEasingFromKeyword(QSvgCssValues::EasingFunction::Ease);

++         break;

++     }

++

++     return easing;

++ }

++

++ void QSvgCssHandler::collectAnimations(const QCss::StyleSheet &sheet)

++ {

++     auto sortFunction = [](QCss::AnimationRule::AnimationRuleSet r1, QCss::AnimationRule::AnimationRuleSet r2) {

++         return r1.keyFrame < r2.keyFrame;

++     };

++

++     QList<QCss::AnimationRule> animationRules = sheet.animationRules;

++     for (QCss::AnimationRule &rule : animationRules) {

++         std::sort(rule.ruleSets.begin(), rule.ruleSets.end(), sortFunction);

++         m_animations[rule.animName] = rule;

++     }

++ }

++

++ void QSvgCssHandler::parseStyleSheet(const QStringView str)

++ {

++     QString css = str.toString();

++     QCss::StyleSheet sheet;

++     QCss::Parser(css).parse(&sheet);

++     m_selector->styleSheets.append(sheet);

++

++     collectAnimations(sheet);

++ }

++

++ QString QSvgCssHandler::parseDecltoString(const QCss::Declaration &decl)

++ {

++     if (decl.d->property.isEmpty())

++         return QString();

++

++     QString valueStr;

++     const int valCount = decl.d->values.size();

++     for (int i = 0; i < valCount; ++i) {

++         QCss::Value val = decl.d->values.at(i);

++         switch (val.type) {

++         case QCss::Value::TermOperatorComma:

++             valueStr += QLatin1Char(';');

++             break;

++         case QCss::Value::Uri:

++         {

++             QString temp = val.toString();

++             temp.prepend(QLatin1String("url("));

++             temp.append(QLatin1Char(')'));

++             valueStr += temp;

++             break;

++         }

++         case QCss::Value::Function:

++         {

++             QStringList lst = val.variant.toStringList();

++             valueStr.append(lst.at(0));

++             valueStr.append(QLatin1Char('('));

++             for (int i = 1; i < lst.size(); ++i) {

++                 valueStr.append(lst.at(i));

++                 if ((i +1) < lst.size())

++                     valueStr.append(QLatin1Char(','));

++             }

++             valueStr.append(QLatin1Char(')'));

++             break;

++         }

++         case QCss::Value::KnownIdentifier:

++             switch (val.variant.toInt()) {

++             case QCss::Value_None:

++                 valueStr += QLatin1String("none");

++                 break;

++             case QCss::Value_Auto:

++                 valueStr += QLatin1String("auto");

++                 break;

++             default:

++                 valueStr += val.toString();

++                 break;

++             }

++             break;

++         case QCss::Value::Percentage:

++             valueStr += val.toString() + QLatin1Char('%');

++             break;

++         default:

++             valueStr += val.toString();

++             break;

++         }

++

++         if (i + 1 < valCount)

++             valueStr += QLatin1Char(' ');

++     }

++

++     return valueStr;

++ }

++

++ void QSvgCssHandler::parseCSStoXMLAttrs(const QList<QCss::Declaration> &declarations, QXmlStreamAttributes &attributes) const

++ {

++     for (int i = 0; i < declarations.size(); ++i) {

++         const QCss::Declaration &decl = declarations.at(i);

++         QString valueStr = parseDecltoString(decl);

++         if (!valueStr.isEmpty())

++             attributes.append(QString(), decl.d->property, valueStr);

++     }

++ }

++

++ void QSvgCssHandler::parseCSStoXMLAttrs(const QString &css, QXmlStreamAttributes &attributes) const

++ {

++     // preprocess (for unicode escapes), tokenize and remove comments

++     QCss::Parser parser(css);

++     QString key;

++

++     while (parser.hasNext()) {

++         parser.skipSpace();

++

++         if (!parser.hasNext())

++             break;

++         parser.next();

++

++         QString name;

++         QString value;

++

++         if (parser.hasEscapeSequences) {

++             key = parser.lexem();

++             name = key;

++         } else {

++             const QCss::Symbol &sym = parser.symbol();

++             name = sym.text.mid(sym.start, sym.len);

++         }

++

++         parser.skipSpace();

++         if (!parser.test(QCss::COLON))

++             break;

++

++         parser.skipSpace();

++         if (!parser.hasNext())

++             break;

++

++         const int firstSymbol = parser.index;

++         int symbolCount = 0;

++         do {

++             parser.next();

++             ++symbolCount;

++         } while (parser.hasNext() && !parser.test(QCss::SEMICOLON));

++

++         bool canExtractValueByRef = !parser.hasEscapeSequences;

++         if (canExtractValueByRef) {

++             int len = parser.symbols.at(firstSymbol).len;

++             for (int i = firstSymbol + 1; i < firstSymbol + symbolCount; ++i) {

++                 len += parser.symbols.at(i).len;

++

++                 if (parser.symbols.at(i - 1).start + parser.symbols.at(i - 1).len

++                     != parser.symbols.at(i).start) {

++                     canExtractValueByRef = false;

++                     break;

++                 }

++             }

++             if (canExtractValueByRef) {

++                 const QCss::Symbol &sym = parser.symbols.at(firstSymbol);

++                 value = sym.text.mid(sym.start, len);

++             }

++         }

++         if (!canExtractValueByRef) {

++

++             for (int i = firstSymbol; i < parser.index - 1; ++i)

++                 value += parser.symbols.at(i).lexem();

++         }

++

++         attributes.append(QString(), name, value);

++

++         parser.skipSpace();

++     }

++ }

++

++ void QSvgCssHandler::styleLookup(QSvgNode *node, QXmlStreamAttributes &attributes) const

++ {

++     QCss::StyleSelector::NodePtr cssNode;

++     cssNode.ptr = node;

++     QList<QCss::Declaration> decls = m_selector->declarationsForNode(cssNode);

++

++     parseCSStoXMLAttrs(decls, attributes);

++ }

++

++ QSvgCssEasingPtr QSvgCssHandler::createEasingFromKeyword(QSvgCssValues::EasingFunction easingFunction)

++ {

++     constexpr QPointF easeC1(0.25, 0.1);

++     constexpr QPointF easeC2(0.25, 1);

++     constexpr QPointF easeInC1(0.42, 0);

++     constexpr QPointF easeInC2(1, 1);

++     constexpr QPointF easeOutC1(0, 0);

++     constexpr QPointF easeOutC2(0.58, 1);

++     constexpr QPointF linearC1(0, 0);

++     constexpr QPointF linearC2(1, 1);

++

++     QSvgCssEasingPtr easing;

++

++     switch (easingFunction) {

++     case QSvgCssValues::EasingFunction::Ease:

++         easing = std::make_unique<QSvgCssCubicBezierEasing>(easingFunction, easeC1, easeC2);

++         break;

++     case QSvgCssValues::EasingFunction::EaseIn:

++         easing = std::make_unique<QSvgCssCubicBezierEasing>(easingFunction, easeInC1, easeInC2);

++         break;

++     case QSvgCssValues::EasingFunction::EaseOut:

++         easing = std::make_unique<QSvgCssCubicBezierEasing>(easingFunction, easeOutC1, easeOutC2);

++         break;

++     case QSvgCssValues::EasingFunction::EaseInOut:

++         easing = std::make_unique<QSvgCssCubicBezierEasing>(easingFunction, easeInC1, easeOutC2);

++         break;

++     case QSvgCssValues::EasingFunction::Linear:

++         easing = std::make_unique<QSvgCssCubicBezierEasing>(easingFunction, linearC1, linearC2);

++         break;

++     default:

++         Q_UNREACHABLE();

++         break;

++     }

++

++     return easing;

++ }

++

++ QSvgCssEasingPtr QSvgCssHandler::createStepsEasing(const QSvgCssValues::StepValues &values)

++ {

++     quint32 steps = values.steps;

++     QSvgCssValues::StepPosition position = values.stepPosition;

++

++     return std::make_unique<QSvgCssStepsEasing>(steps, position);

++ }

++

++ QT_END_NAMESPACE

Revision control