Revision control
++ // Copyright (C) 2019 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++ // Qt-Security score:critical reason:data-parser
++
++ #include "qquickkeyframe_p.h"
++
++ #include "qquicktimeline_p.h"
++
++ #include <QtCore/qdebug.h>
++ #include <QtCore/QVariantAnimation>
++ #include <QtCore/qmath.h>
++ #include <QtGui/qpainter.h>
++ #include <QtQml/QQmlProperty>
++ #include <QtQml/QQmlFile>
++ #include <QtQml/QQmlContext>
++ #include <QtQml/QQmlEngine>
++ #include <QtCore/QFile>
++ #include <QtCore/QCborStreamReader>
++ #include <QCborArray>
++ #include <QRect>
++ #include <QVector2D>
++ #include <QVector3D>
++ #include <QVector4D>
++ #include <QQuaternion>
++ #include <QColor>
++
++ #include <private/qvariantanimation_p.h>
++ #include <private/qqmlproperty_p.h>
++
++ #include <algorithm>
++
++ QT_BEGIN_NAMESPACE
++
++ class QQuickKeyframeGroupPrivate : public QObjectPrivate
++ {
++ Q_DECLARE_PUBLIC(QQuickKeyframeGroup)
++ public:
++ QQuickKeyframeGroupPrivate() = default;
++
++ QObject *target = nullptr;
++ QString propertyName;
++ QUrl keyframeSource;
++ QByteArray keyframeData;
++ bool componentComplete = false;
++ int userType = -1;
++
++ protected:
++ void setupKeyframes();
++ bool loadKeyframes(bool fromBinary = false);
++ void resetKeyframes();
++
++ static void append_keyframe(QQmlListProperty<QQuickKeyframe> *list, QQuickKeyframe *a);
++ static qsizetype keyframe_count(QQmlListProperty<QQuickKeyframe> *list);
++ static QQuickKeyframe* keyframe_at(QQmlListProperty<QQuickKeyframe> *list, qsizetype pos);
++ static void clear_keyframes(QQmlListProperty<QQuickKeyframe> *list);
++
++ QList<QQuickKeyframe *> keyframes;
++ QList<QQuickKeyframe *> sortedKeyframes;
++
++ QVariant originalValue;
++ QVariant lastValue;
++ QQmlAnyBinding originalBinding;
++ };
++
++ void QQuickKeyframeGroupPrivate::setupKeyframes()
++ {
++ sortedKeyframes = keyframes;
++ std::sort(sortedKeyframes.begin(), sortedKeyframes.end(), [](const QQuickKeyframe *first, const QQuickKeyframe *second) {
++ return first->frame() < second->frame();
++ });
++ }
++
++ // a valid frame : time, easingType, data
++ // returns total size(data + 2) if valid, -1 otherwise
++ static int validFrameSize(QMetaType::Type type)
++ {
++ switch (type) {
++ case QMetaType::Bool:
++ case QMetaType::Int:
++ case QMetaType::Float:
++ case QMetaType::Double:
++ return 3;
++ case QMetaType::QVector2D:
++ case QMetaType::QPoint:
++ case QMetaType::QPointF:
++ case QMetaType::QSize:
++ case QMetaType::QSizeF:
++ return 4;
++ case QMetaType::QVector3D:
++ return 5;
++ case QMetaType::QVector4D:
++ case QMetaType::QQuaternion:
++ case QMetaType::QColor:
++ case QMetaType::QRect:
++ case QMetaType::QRectF:
++ return 6;
++ default:
++ qWarning() << "Keyframe property type not handled:" << type;
++ return -1;
++ }
++ }
++
++ // Read property 'type' value from CborArray from index 'id' and return it as QVariant.
++ static QVariant qQuickKeyframeReadProperty(const QCborArray &array, qsizetype id, QMetaType::Type type)
++ {
++ switch (type) {
++ case QMetaType::QVector2D:
++ {
++ QVector2D v;
++ v.setX(array.at(id).toDouble());
++ v.setY(array.at(id + 1).toDouble());
++ return QVariant(v);
++ }
++ break;
++ case QMetaType::QVector3D:
++ {
++ QVector3D v;
++ v.setX(array.at(id).toDouble());
++ v.setY(array.at(id + 1).toDouble());
++ v.setZ(array.at(id + 2).toDouble());
++ return QVariant(v);
++ }
++ break;
++ case QMetaType::QVector4D:
++ {
++ QVector4D v;
++ v.setX(array.at(id).toDouble());
++ v.setY(array.at(id + 1).toDouble());
++ v.setZ(array.at(id + 2).toDouble());
++ v.setW(array.at(id + 3).toDouble());
++ return QVariant(v);
++ }
++ break;
++ case QMetaType::QQuaternion:
++ {
++ QQuaternion q;
++ q.setScalar(array.at(id).toDouble());
++ q.setX(array.at(id + 1).toDouble());
++ q.setY(array.at(id + 2).toDouble());
++ q.setZ(array.at(id + 3).toDouble());
++ return QVariant(q);
++ }
++ break;
++ case QMetaType::QColor:
++ {
++ QColor c;
++ c.setRed(array.at(id).toInteger());
++ c.setGreen(array.at(id + 1).toInteger());
++ c.setBlue(array.at(id + 2).toInteger());
++ c.setAlpha(array.at(id + 3).toInteger());
++ return QVariant(c);
++ }
++ break;
++ case QMetaType::QRectF:
++ {
++ QRectF r;
++ r.setX(array.at(id).toDouble());
++ r.setY(array.at(id + 1).toDouble());
++ r.setWidth(array.at(id + 2).toDouble());
++ r.setHeight(array.at(id + 3).toDouble());
++ return QVariant(r);
++ }
++ break;
++ case QMetaType::QRect:
++ {
++ QRect r;
++ r.setX(array.at(id).toInteger());
++ r.setY(array.at(id + 1).toInteger());
++ r.setWidth(array.at(id + 2).toInteger());
++ r.setHeight(array.at(id + 3).toInteger());
++ return QVariant(r);
++ }
++ break;
++ case QMetaType::QPointF:
++ {
++ QPointF p;
++ p.setX(array.at(id).toDouble());
++ p.setY(array.at(id + 1).toDouble());
++ return QVariant(p);
++ }
++ break;
++ case QMetaType::QPoint:
++ {
++ QPoint p;
++ p.setX(array.at(id).toInteger());
++ p.setY(array.at(id + 1).toInteger());
++ return QVariant(p);
++ }
++ break;
++ case QMetaType::QSizeF:
++ {
++ QSizeF s;
++ s.setWidth(array.at(id).toDouble());
++ s.setHeight(array.at(id + 1).toDouble());
++ return QVariant(s);
++ }
++ break;
++ case QMetaType::QSize:
++ {
++ QSize s;
++ s.setWidth(array.at(id).toInteger());
++ s.setHeight(array.at(id + 1).toInteger());
++ return QVariant(s);
++ }
++ break;
++ case QMetaType::Bool:
++ case QMetaType::Int:
++ case QMetaType::Float:
++ case QMetaType::Double:
++ {
++ return array.at(id).toVariant();
++ }
++
++ default:
++ qWarning() << "Keyframe property type not handled:" << type;
++ }
++
++ return QVariant();
++ }
++
++ bool QQuickKeyframeGroupPrivate::loadKeyframes(bool fromBinary)
++ {
++ Q_Q(QQuickKeyframeGroup);
++
++ QCborStreamReader reader;
++ QFile dataFile;
++ if (!fromBinary) {
++ // Resolve URL similar to QQuickImage source
++ QUrl loadUrl = keyframeSource;
++ QQmlContext *context = qmlContext(q);
++ if (context)
++ loadUrl = context->resolvedUrl(keyframeSource);
++ QString dataFilePath = QQmlFile::urlToLocalFileOrQrc(loadUrl);
++
++ dataFile.setFileName(dataFilePath);
++ if (!dataFile.open(QIODevice::ReadOnly)) {
++ // Invalid file
++ qWarning() << "Unable to open keyframeSource:" << dataFilePath;
++ return false;
++ }
++ reader.setDevice(&dataFile);
++ } else {
++ reader.addData(keyframeData);
++ }
++
++ auto error = [&reader](const QString &msg = QString()) {
++ if (!msg.isEmpty())
++ qWarning() << "Corrupt keyframeSource" << msg;
++ else
++ qWarning() << "Corrupt keyframeSource" << reader.lastError().toString();
++ return false;
++ };
++
++ QCborValue kfSrcCborValue = QCborValue::fromCbor(reader);
++ if (reader.lastError() != QCborError::NoError || !kfSrcCborValue.isArray())
++ return error(QStringLiteral("invalid format.(array expected)"));
++
++ QCborArray kfSrcCborArray = kfSrcCborValue.toArray();
++ // [ "QTimelineKeyframes", version(int), property type(int), [...]]
++ if (kfSrcCborArray.size() != 4)
++ return error(QStringLiteral("invalid data size"));
++
++ if (kfSrcCborArray.at(0).toString() != QStringLiteral("QTimelineKeyframes"))
++ return error(QStringLiteral("invalid keyframeSource header string"));
++
++ if (kfSrcCborArray.at(1).toInteger() != 1)
++ return error(QStringLiteral("invalid keyframeSource version %1").arg(kfSrcCborArray.at(1).toInteger()));
++
++ // QMetaType::UnknownType = 0;
++ QMetaType::Type propertyType = static_cast<QMetaType::Type>(kfSrcCborArray.at(2).toInteger(0));
++ const int frameSize = validFrameSize(propertyType);
++ if (frameSize < 0)
++ return error(QStringLiteral("unsupported property type"));
++
++ // Start keyframes array
++ QCborArray kfArray = kfSrcCborArray.at(3).toArray();
++ const auto arraySize = kfArray.size();
++ if (arraySize % frameSize != 0)
++ return error(QStringLiteral("invalid keyframe array"));
++
++ bool validKeyframeData = true;
++ for (qsizetype i = 0; i < arraySize; i += frameSize) {
++ // An array element should be ( time, easingType, keyframeData )
++ auto keyframe = std::make_unique<QQuickKeyframe>(q);
++
++ keyframe->setFrame(kfArray.at(i).toDouble());
++
++ QCborValue easingTypeValue = kfArray.at(i + 1);
++ if (!easingTypeValue.isInteger()) {
++ validKeyframeData = false;
++ break;
++ }
++ keyframe->setEasing(static_cast<QEasingCurve::Type>(easingTypeValue.toInteger()));
++
++ QVariant value = qQuickKeyframeReadProperty(kfArray, i + 2, propertyType);
++ if (value.isValid()) {
++ keyframe->setValue(value);
++ keyframes.append(keyframe.release());
++ } else {
++ validKeyframeData = false;
++ break;
++ }
++ }
++
++ if (!validKeyframeData) {
++ qWarning() << "Invalid keyframe data";
++ resetKeyframes();
++ return false;
++ }
++
++ return true;
++ }
++
++ void QQuickKeyframeGroupPrivate::resetKeyframes()
++ {
++ qDeleteAll(keyframes);
++ keyframes.clear();
++ }
++
++ void QQuickKeyframeGroupPrivate::append_keyframe(QQmlListProperty<QQuickKeyframe> *list, QQuickKeyframe *a)
++ {
++ auto q = static_cast<QQuickKeyframeGroup *>(list->object);
++ q->d_func()->keyframes.append(a);
++ q->d_func()->setupKeyframes();
++ q->reset();
++ }
++
++ qsizetype QQuickKeyframeGroupPrivate::keyframe_count(QQmlListProperty<QQuickKeyframe> *list)
++ {
++ auto q = static_cast<QQuickKeyframeGroup *>(list->object);
++ return q->d_func()->keyframes.size();
++ }
++
++ QQuickKeyframe* QQuickKeyframeGroupPrivate::keyframe_at(QQmlListProperty<QQuickKeyframe> *list, qsizetype pos)
++ {
++ auto q = static_cast<QQuickKeyframeGroup *>(list->object);
++ return q->d_func()->keyframes.at(pos);
++ }
++
++ void QQuickKeyframeGroupPrivate::clear_keyframes(QQmlListProperty<QQuickKeyframe> *list)
++ {
++ auto q = static_cast<QQuickKeyframeGroup *>(list->object);
++ q->d_func()->keyframes.clear();
++ q->d_func()->setupKeyframes();
++ }
++
++ class QQuickKeyframePrivate : public QObjectPrivate
++ {
++ Q_DECLARE_PUBLIC(QQuickKeyframe)
++ public:
++ QQuickKeyframePrivate() = default;
++
++ qreal frame = 0;
++ QEasingCurve easingCurve;
++ QVariant value;
++ };
++
++ /*!
++ \qmltype Keyframe
++ \inherits QtObject
++ \nativetype QQuickKeyframe
++ \inqmlmodule QtQuick.Timeline
++ \ingroup qtqmltypes
++
++ \brief A keyframe.
++
++ The value of a keyframe on a timeline.
++
++ An easing curve can be attached to the keyframe.
++ */
++
++ /*!
++ \qmlproperty double Keyframe::frame
++
++ The position of the keyframe on the timeline.
++ */
++
++ /*!
++ \qmlproperty var Keyframe::easing
++
++ The easing curve attached to the keyframe.
++ */
++
++ /*!
++ \qmlproperty var Keyframe::value
++
++ The value of the keyframe.
++ */
++
++ /*!
++ \qmlsignal Keyframe::easingCurveChanged
++
++ This signal is emitted when the easing curve attached to the keyframe
++ changes.
++ */
++
++ QQuickKeyframe::QQuickKeyframe(QObject *parent)
++ : QObject(*(new QQuickKeyframePrivate), parent)
++ {
++ }
++
++ qreal QQuickKeyframe::frame() const
++ {
++ Q_D(const QQuickKeyframe);
++ return d->frame;
++ }
++
++ void QQuickKeyframe::setFrame(qreal f)
++ {
++ Q_D(QQuickKeyframe);
++ if (d->frame == f)
++ return;
++ d->frame = f;
++
++ reset();
++
++ emit frameChanged();
++ }
++
++ void QQuickKeyframe::reset()
++ {
++ auto keyframes = qobject_cast<QQuickKeyframeGroup*>(parent());
++ if (keyframes)
++ keyframes->reset();
++ }
++
++ QQuickKeyframe::QQuickKeyframe(QQuickKeyframePrivate &dd, QObject *parent)
++ : QObject(dd, parent)
++ {
++ }
++
++ /*!
++ \qmltype KeyframeGroup
++ \inherits QtObject
++ \nativetype QQuickKeyframeGroup
++ \inqmlmodule QtQuick.Timeline
++ \ingroup qtqmltypes
++
++ \brief A keyframe group.
++
++ A keyframe group contains all keyframes for a specific property of an item
++ and always belongs to a timeline.
++ */
++
++ /*!
++ \qmlproperty var KeyframeGroup::target
++
++ The item that is targeted by the keyframe group.
++ */
++
++ /*!
++ \qmlproperty string KeyframeGroup::property
++
++ The property that is targeted by the keyframe group.
++ */
++
++ /*!
++ \qmlproperty list KeyframeGroup::keyframes
++ \readonly
++
++ A list of keyframes that belong to the keyframe group.
++ */
++
++ /*!
++ \qmlproperty url KeyframeGroup::keyframeSource
++
++ The URL to a file containing binary keyframe data.
++
++ \note KeyframeGroup should either set this property or contain
++ Keyframe child elements. Using both can lead to an undefined behavior.
++
++ \since 1.1
++ */
++
++ QQuickKeyframeGroup::QQuickKeyframeGroup(QObject *parent)
++ : QObject(*(new QQuickKeyframeGroupPrivate), parent)
++ {
++
++ }
++
++ QQmlListProperty<QQuickKeyframe> QQuickKeyframeGroup::keyframes()
++ {
++ Q_D(QQuickKeyframeGroup);
++
++ return { this, &d->keyframes, QQuickKeyframeGroupPrivate::append_keyframe,
++ QQuickKeyframeGroupPrivate::keyframe_count,
++ QQuickKeyframeGroupPrivate::keyframe_at,
++ QQuickKeyframeGroupPrivate::clear_keyframes };
++ }
++
++ QObject *QQuickKeyframeGroup::target() const
++ {
++ Q_D(const QQuickKeyframeGroup);
++ return d->target;
++ }
++
++ void QQuickKeyframeGroup::setTargetObject(QObject *o)
++ {
++ Q_D(QQuickKeyframeGroup);
++ if (d->target == o)
++ return;
++ d->target = o;
++
++ if (!property().isEmpty())
++ init();
++
++ emit targetChanged();
++ }
++
++ QString QQuickKeyframeGroup::property() const
++ {
++ Q_D(const QQuickKeyframeGroup);
++ return d->propertyName;
++ }
++
++ void QQuickKeyframeGroup::setProperty(const QString &n)
++ {
++ Q_D(QQuickKeyframeGroup);
++ if (d->propertyName == n)
++ return;
++ d->propertyName = n;
++
++ if (target())
++ init();
++
++ emit propertyChanged();
++ }
++
++ QUrl QQuickKeyframeGroup::keyframeSource() const
++ {
++ Q_D(const QQuickKeyframeGroup);
++ return d->keyframeSource;
++ }
++
++ void QQuickKeyframeGroup::setKeyframeSource(const QUrl &source)
++ {
++ Q_D(QQuickKeyframeGroup);
++ if (d->keyframeSource == source)
++ return;
++
++ if (d->keyframes.size() > 0) {
++ // Remove possible previously loaded keyframes
++ d->resetKeyframes();
++ d->keyframeData.clear();
++ }
++
++ d->keyframeSource = source;
++ if (d->loadKeyframes())
++ d->setupKeyframes();
++ reset();
++
++ emit keyframeSourceChanged();
++ }
++
++ const QByteArray QQuickKeyframeGroup::keyframeData() const
++ {
++ Q_D(const QQuickKeyframeGroup);
++ return d->keyframeData;
++ }
++
++ void QQuickKeyframeGroup::setKeyframeData(const QByteArray &data)
++ {
++ Q_D(QQuickKeyframeGroup);
++ if (d->keyframeData == data)
++ return;
++
++ if (d->keyframes.size() > 0) {
++ // Remove possible previously loaded keyframes
++ d->resetKeyframes();
++ d->keyframeSource.clear();
++ }
++
++ d->keyframeData = data;
++ if (d->loadKeyframes(true))
++ d->setupKeyframes();
++ reset();
++
++ emit keyframeSourceChanged();
++ }
++
++ QVariant QQuickKeyframeGroup::evaluate(qreal frame) const
++ {
++ Q_D(const QQuickKeyframeGroup);
++
++ if (d->sortedKeyframes.isEmpty())
++ return QVariant();
++
++ static QQuickKeyframe dummy;
++ auto timeline = qobject_cast<QQuickTimeline*>(parent());
++ if (timeline)
++ dummy.setFrame(timeline->startFrame() - 0.0001);
++ dummy.setValue(d->originalValue);
++
++ QQuickKeyframe *lastFrame = &dummy;
++
++ for (auto keyFrame : std::as_const(d->sortedKeyframes)) {
++ if (qFuzzyCompare(frame, keyFrame->frame()) || frame < keyFrame->frame())
++ return keyFrame->evaluate(lastFrame, frame, d->userType);
++ lastFrame = keyFrame;
++ }
++
++ return lastFrame->value();
++ }
++
++ void QQuickKeyframeGroup::setProperty(qreal frame)
++ {
++ Q_D(QQuickKeyframeGroup);
++
++ if (target()) {
++ QQmlProperty qmlProperty(target(), property());
++
++ d->lastValue = evaluate(frame);
++
++ if (!qmlProperty.write(d->lastValue))
++ qWarning() << "Cannot set property" << property();
++ }
++ }
++
++ void QQuickKeyframeGroup::init()
++ {
++ Q_D(QQuickKeyframeGroup);
++ if (target()) {
++ QQmlProperty qmlProperty(target(), property());
++ d->originalValue = QQmlProperty::read(target(), property());
++ d->userType = qmlProperty.property().userType();
++ if (d->originalBinding)
++ d->originalBinding = nullptr;
++ d->originalBinding = QQmlAnyBinding::ofProperty(qmlProperty);
++ if (property().contains(QLatin1Char('.'))) {
++ if (d->userType == QMetaType::QVector2D
++ || d->userType == QMetaType::QVector3D
++ || d->userType == QMetaType::QVector4D
++ || d->userType == QMetaType::QQuaternion)
++ d->userType = QMetaType::Double;
++ }
++ }
++ }
++
++ void QQuickKeyframeGroup::resetDefaultValue()
++ {
++ Q_D(QQuickKeyframeGroup);
++
++ if (QQmlProperty::read(target(), property()) == d->lastValue) {
++ if (d->originalBinding) {
++ QQmlProperty qmlProperty(target(), property());
++ d->originalBinding.installOn(qmlProperty);
++ d->originalBinding = nullptr;
++ } else {
++ QQmlProperty::write(target(), property(), d->originalValue);
++ }
++ }
++ }
++
++ void QQuickKeyframeGroup::reset()
++ {
++ Q_D(QQuickKeyframeGroup);
++ if (!d->componentComplete)
++ return;
++
++ auto *timeline = qobject_cast<QQuickTimeline*>(parent());
++ if (timeline)
++ timeline->reevaluate();
++ }
++
++ void QQuickKeyframeGroup::setupKeyframes()
++ {
++ Q_D(QQuickKeyframeGroup);
++
++ if (d->componentComplete)
++ d->setupKeyframes();
++ }
++
++ void QQuickKeyframeGroup::classBegin()
++ {
++ Q_D(QQuickKeyframeGroup);
++ d->componentComplete = false;
++ }
++
++ void QQuickKeyframeGroup::componentComplete()
++ {
++ Q_D(QQuickKeyframeGroup);
++ d->componentComplete = true;
++ setupKeyframes();
++ }
++
++ QEasingCurve QQuickKeyframe::easing() const
++ {
++ Q_D(const QQuickKeyframe);
++ return d->easingCurve;
++ }
++
++ void QQuickKeyframe::setEasing(const QEasingCurve &e)
++ {
++ Q_D(QQuickKeyframe);
++ if (d->easingCurve == e)
++ return;
++
++ d->easingCurve = e;
++
++ reset();
++
++ emit easingCurveChanged();
++ }
++
++ QVariant QQuickKeyframe::value() const
++ {
++ Q_D(const QQuickKeyframe);
++ return d->value;
++ }
++
++ void QQuickKeyframe::setValue(const QVariant &v)
++ {
++ Q_D(QQuickKeyframe);
++ if (d->value == v)
++ return;
++ d->value = v;
++
++ reset();
++
++ emit valueChanged();
++ }
++
++ QVariant QQuickKeyframe::evaluate(QQuickKeyframe *pre, qreal frametime, int userType) const
++ {
++ QVariantAnimation::Interpolator interpolator = QVariantAnimationPrivate::getInterpolator(userType);
++ if (!pre)
++ return value();
++
++ QVariant preValue = pre->value();
++ qreal preFrame = pre->frame();
++
++ qreal duration = frame() - preFrame;
++ qreal offset = frametime - preFrame;
++
++ qreal progress = easing().valueForProgress(offset / duration);
++
++ const QMetaType targetType(userType);
++ preValue.convert(targetType);
++ QVariant convertedValue = value();
++ convertedValue.convert(targetType);
++
++ if (!interpolator) {
++ if (progress < 1.0)
++ return preValue;
++
++ return convertedValue;
++ }
++
++ if (preValue.isValid() && convertedValue.isValid())
++ return interpolator(preValue.constData(), convertedValue.constData(), progress);
++
++ qWarning() << "invalid keyframe target" << preValue << convertedValue << userType;
++
++ return QVariant();
++ }
++
++ QT_END_NAMESPACE
++
++