qsvganimatedproperty.cpp

Go to the documentation of this file.

// 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