qsvganimatedproperty.cpp

++ // Copyright (C) 2024 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:significant reason:default

++

++

++ #include "qsvganimatedproperty_p.h"

++ #include <QtCore/qpoint.h>

++ #include <QtGui/qcolor.h>

++ #include <QtGui/qtransform.h>

++

++ #include <QtCore/qlatin1stringview.h>

++ #include <QtCore/qloggingcategory.h>

++ #include <QtCore/qstring.h>

++

++ #include <optional>

++

++ QT_BEGIN_NAMESPACE

++

++ using namespace Qt::StringLiterals;

++

++ Q_STATIC_LOGGING_CATEGORY(lcSvgAnimatedProperty, "qt.svg.animation.properties")

++

++ static std::optional<QSvgAbstractAnimatedProperty::Type> name2type(const QString &name)

++ {

++     // Perfect hashing:

++     //

++     //   the length of the string uniquely identifies the property name

++     //   (compiler guarantees, otherwise it would complain about duplicate case

++     //   labels):

++     constexpr auto hash = [](QStringView s) {

++         return s.size();

++     };

++

++     switch (hash(name)) {

++ #define CASE(str, type) \

++     case hash(u"" #str): \

++         if (name == #str ## _L1) \

++             return QSvgAbstractAnimatedProperty:: type ; \

++         break; \

++     /* end */

++

++     CASE(fill, Color)

++     CASE(fill-opacity, Float)

++     CASE(stroke-opacity, Float)

++     CASE(stroke, Color)

++     CASE(opacity, Float)

++     CASE(transform, Transform)

++     CASE(offset-distance, Float)

++ #undef CASE

++     };

++     return std::nullopt;

++ }

++

++ static qreal q_lerp(qreal a, qreal b, qreal t)

++ {

++     return a + (b - a) * t;

++ }

++

++ static QPointF pointInterpolator(QPointF v1, QPointF v2, qreal t)

++ {

++     qreal x = q_lerp(v1.x(), v2.x(), t);

++     qreal y = q_lerp(v1.y(), v2.y(), t);

++

++     return QPointF(x, y);

++ }

++

++

++ QSvgAbstractAnimatedProperty::QSvgAbstractAnimatedProperty(const QString &name, Type type)

++     : m_propertyName(name)

++     , m_type(type)

++ {

++ }

++

++ QSvgAbstractAnimatedProperty::~QSvgAbstractAnimatedProperty()

++ {

++ }

++

++ void QSvgAbstractAnimatedProperty::setKeyFrames(const QList<qreal> &keyFrames)

++ {

++     m_keyFrames = keyFrames;

++ }

++

++ void QSvgAbstractAnimatedProperty::appendKeyFrame(qreal keyFrame)

++ {

++     m_keyFrames.append(keyFrame);

++ }

++

++ QList<qreal> QSvgAbstractAnimatedProperty::keyFrames() const

++ {

++     return m_keyFrames;

++ }

++

++ void QSvgAbstractAnimatedProperty::appendEasing(QSvgEasingInterfacePtr easing)

++ {

++     m_easings.push_back(std::move(easing));

++ }

++

++ const QSvgEasingInterface *QSvgAbstractAnimatedProperty::easingAt(unsigned int i) const

++ {

++     return i < m_easings.size() ? m_easings[i].get() : nullptr;

++ }

++

++ void QSvgAbstractAnimatedProperty::setPropertyName(const QString &name)

++ {

++     m_propertyName = name;

++ }

++

++ QStringView QSvgAbstractAnimatedProperty::propertyName() const

++ {

++     return m_propertyName;

++ }

++

++ QSvgAbstractAnimatedProperty::Type QSvgAbstractAnimatedProperty::type() const

++ {

++     return m_type;

++ }

++

++ QVariant QSvgAbstractAnimatedProperty::interpolatedValue() const

++ {

++     return m_interpolatedValue;

++ }

++

++ QSvgAbstractAnimatedProperty *QSvgAbstractAnimatedProperty::createAnimatedProperty(const QString &name)

++ {

++     const std::optional<Type> type = name2type(name);

++

++     if (!type) {

++         qCDebug(lcSvgAnimatedProperty) << "Property : " << name << " is not animatable";

++         return nullptr;

++     }

++

++     QSvgAbstractAnimatedProperty *prop = nullptr;

++

++     switch (*type) {

++     case QSvgAbstractAnimatedProperty::Color:

++         prop = new QSvgAnimatedPropertyColor(name);

++         break;

++     case QSvgAbstractAnimatedProperty::Transform:

++         prop = new QSvgAnimatedPropertyTransform(name);

++         break;

++     case QSvgAbstractAnimatedProperty::Float:

++         prop = new QSvgAnimatedPropertyFloat(name);

++     default:

++         break;

++     }

++

++     return prop;

++ }

++

++ QSvgAnimatedPropertyColor::QSvgAnimatedPropertyColor(const QString &name)

++     : QSvgAbstractAnimatedProperty(name, QSvgAbstractAnimatedProperty::Color)

++ {

++ }

++

++ QSvgAnimatedPropertyColor::~QSvgAnimatedPropertyColor()

++     = default;

++

++ void QSvgAnimatedPropertyColor::setColors(const QList<QColor> &colors)

++ {

++     m_colors = colors;

++ }

++

++ void QSvgAnimatedPropertyColor::appendColor(const QColor &color)

++ {

++     m_colors.append(color);

++ }

++

++ QList<QColor> QSvgAnimatedPropertyColor::colors() const

++ {

++     return m_colors;

++ }

++

++ void QSvgAnimatedPropertyColor::interpolate(uint index, qreal t) const

++ {

++     QColor c1 = m_colors.at(index - 1);

++     QColor c2 = m_colors.at(index);

++

++     int alpha  = q_lerp(c1.alpha(), c2.alpha(), t);

++     int red    = q_lerp(c1.red(), c2.red(), t);

++     int green  = q_lerp(c1.green(), c2.green(), t);

++     int blue   = q_lerp(c1.blue(), c2.blue(), t);

++

++     m_interpolatedValue = QColor(red, green, blue, alpha);

++ }

++

++ QSvgAnimatedPropertyFloat::QSvgAnimatedPropertyFloat(const QString &name)

++     : QSvgAbstractAnimatedProperty(name, QSvgAbstractAnimatedProperty::Float)

++ {

++ }

++

++ QSvgAnimatedPropertyFloat::~QSvgAnimatedPropertyFloat()

++     = default;

++

++ void QSvgAnimatedPropertyFloat::setValues(const QList<qreal> &values)

++ {

++     m_values = values;

++ }

++

++ void QSvgAnimatedPropertyFloat::appendValue(const qreal value)

++ {

++     m_values.append(value);

++ }

++

++ QList<qreal> QSvgAnimatedPropertyFloat::values() const

++ {

++     return m_values;

++ }

++

++ void QSvgAnimatedPropertyFloat::interpolate(uint index, qreal t) const

++ {

++     if (index >= (uint)m_keyFrames.size()) {

++         qCWarning(lcSvgAnimatedProperty) << "Invalid index for key frames";

++         return;

++     }

++

++     qreal float1 = m_values.at(index - 1);

++     qreal float2 = m_values.at(index);

++

++     m_interpolatedValue = q_lerp(float1, float2, t);

++ }

++

++ QSvgAnimatedPropertyTransform::QSvgAnimatedPropertyTransform(const QString &name)

++     : QSvgAbstractAnimatedProperty(name, QSvgAbstractAnimatedProperty::Transform)

++ {

++

++ }

++

++ QSvgAnimatedPropertyTransform::~QSvgAnimatedPropertyTransform()

++     = default;

++

++ void QSvgAnimatedPropertyTransform::setTransformCount(quint32 count)

++ {

++     m_transformCount = count;

++ }

++

++ quint32 QSvgAnimatedPropertyTransform::transformCount() const

++ {

++     return m_transformCount;

++ }

++

++ void QSvgAnimatedPropertyTransform::appendComponents(const QList<TransformComponent> &components)

++ {

++     m_components.append(components);

++ }

++

++ QList<QSvgAnimatedPropertyTransform::TransformComponent> QSvgAnimatedPropertyTransform::components() const

++ {

++     return m_components;

++ }

++

++ // this function iterates over all TransformComponents in two consecutive

++ // key frames and interpolate between all TransformComponents. Moreover,

++ // it requires all key frames to have the same number of TransformComponents.

++ // This must be ensured by the parser itself, and it is handled in validateTransform

++ // function in qsvgcsshandler.cpp and in createAnimateTransformNode function

++ // in qsvghandler.cpp.

++ void QSvgAnimatedPropertyTransform::interpolate(uint index, qreal t) const

++ {

++     if (index >= (uint)m_keyFrames.size()) {

++         qCWarning(lcSvgAnimatedProperty) << "Invalid index for key frames";

++         return;

++     }

++

++     if (!m_transformCount ||

++         ((m_components.size() / qsizetype(m_transformCount)) != m_keyFrames.size())) {

++         return;

++     }

++

++     QTransform transform = QTransform();

++

++     qsizetype startIndex = (index - 1) * qsizetype(m_transformCount);

++     qsizetype endIndex = index * qsizetype(m_transformCount);

++

++     for (quint32 i = 0; i < m_transformCount; i++) {

++         TransformComponent tc1 = m_components.at(startIndex + i);

++         TransformComponent tc2 = m_components.at(endIndex + i);

++         if (tc1.type == tc2.type) {

++             if (tc1.type == TransformComponent::Translate) {

++                 QPointF t1 = QPointF(tc1.values.at(0), tc1.values.at(1));

++                 QPointF t2 = QPointF(tc2.values.at(0), tc2.values.at(1));

++                 QPointF tr = pointInterpolator(t1, t2, t);

++                 transform.translate(tr.x(), tr.y());

++             } else if (tc1.type == TransformComponent::Scale) {

++                 QPointF s1 = QPointF(tc1.values.at(0), tc1.values.at(1));

++                 QPointF s2 = QPointF(tc2.values.at(0), tc2.values.at(1));

++                 QPointF sr = pointInterpolator(s1, s2, t);

++                 transform.scale(sr.x(), sr.y());

++             } else if (tc1.type == TransformComponent::Rotate) {

++                 QPointF cor1 = QPointF(tc1.values.at(1), tc1.values.at(2));

++                 QPointF cor2 = QPointF(tc2.values.at(1), tc2.values.at(2));

++                 QPointF corResult = pointInterpolator(cor1, cor2, t);

++                 qreal angle1 = tc1.values.at(0);

++                 qreal angle2 = tc2.values.at(0);

++                 qreal angleResult = q_lerp(angle1, angle2, t);

++                 transform.translate(corResult.x(), corResult.y());

++                 transform.rotate(angleResult);

++                 transform.translate(-corResult.x(), -corResult.y());

++             } else if (tc1.type == TransformComponent::Skew) {

++                 QPointF skew1 = QPointF(tc1.values.at(0), tc1.values.at(1));

++                 QPointF skew2 = QPointF(tc2.values.at(0), tc2.values.at(1));

++                 QPointF skewResult = pointInterpolator(skew1, skew2, t);

++                 transform.shear(qTan(qDegreesToRadians(skewResult.x())),

++                                 qTan(qDegreesToRadians(skewResult.y())));

++             }

++         }

++     }

++

++     m_interpolatedValue = transform;

++ }

++

++ QT_END_NAMESPACE

Revision control