Revision control

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include "qquickkeyframe_p.h"
#include "qquicktimeline_p.h"
- #include "qquickkeyframedatautils_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();
- void loadKeyframes(bool fromBinary = false);
+ 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();
});
}
- void QQuickKeyframeGroupPrivate::loadKeyframes(bool fromBinary)
+ // time, easingType, data
+ 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;
- qDeleteAll(keyframes);
- keyframes.clear();
- return;
+ return false;
}
reader.setDevice(&dataFile);
} else {
reader.addData(keyframeData);
}
- auto cleanup = qScopeGuard([&dataFile] { dataFile.close(); });
+ auto error = [&reader](const QString &msg = QString()) {
+ if (!msg.isEmpty())
+ qWarning() << "Corrupt keyframeSource" << msg;
+ else
+ qWarning() << "Corrupt keyframeSource" << reader.lastError().toString();
+ return false;
+ };
- // Check that file is standard keyframes CBOR and get the version
- int version = readKeyframesHeader(reader);
+ QCborValue kfSrcCborValue = QCborValue::fromCbor(reader);
+ if (reader.lastError() != QCborError::NoError || !kfSrcCborValue.isArray())
+ return error(QStringLiteral("invalid format.(array expected)"));
- if (version == -1) {
- // Invalid file
- qWarning() << "Invalid keyframeSource version:" << version;
- return;
- }
+ QCborArray kfSrcCborArray = kfSrcCborValue.toArray();
+ // [ "QTimelineKeyframes", version(int), property type(int), [...]]
+ if (kfSrcCborArray.size() != 4)
+ return error(QStringLiteral("invalid data size"));
- QMetaType::Type propertyType = QMetaType::UnknownType;
- if (reader.isInteger()) {
- propertyType = static_cast<QMetaType::Type>(reader.toInteger());
- reader.next();
- }
+ 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
- reader.enterContainer();
-
- while (reader.lastError() == QCborError::NoError && reader.hasNext()) {
- auto keyframe = new QQuickKeyframe(q);
- keyframe->setFrame(readReal(reader));
- keyframe->setEasing(QEasingCurve(static_cast<QEasingCurve::Type>(reader.toInteger())));
- reader.next();
- keyframe->setValue(readValue(reader, propertyType));
- keyframes.append(keyframe);
+ QCborArray kfArray = kfSrcCborArray.at(3).toArray();
+ const auto arraySize = kfArray.size();
+ bool validKeyframeData = true;
+ for (qsizetype i = 0; i < arraySize - frameSize; i += frameSize) {
+ 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;
+ }
}
- // Leave keyframes array
- reader.leaveContainer();
- // Leave root array
- reader.leaveContainer();
+ 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
- qDeleteAll(d->keyframes);
- d->keyframes.clear();
+ d->resetKeyframes();
d->keyframeData.clear();
}
d->keyframeSource = source;
- d->loadKeyframes();
- d->setupKeyframes();
+ 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
- qDeleteAll(d->keyframes);
- d->keyframes.clear();
+ d->resetKeyframes();
d->keyframeSource.clear();
}
d->keyframeData = data;
- d->loadKeyframes(true);
- d->setupKeyframes();
+ 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