qquicktimeline.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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
 
#include "qquicktimeline_p_p.h"
 
#include <QDebug>
#include <QMutex>
#include <QThread>
#include <QWaitCondition>
#include <QEvent>
#include <QCoreApplication>
#include <QEasingCurve>
#include <QTime>
#include <QtCore/private/qnumeric_p.h>
#include <QHash>
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
Q_LOGGING_CATEGORY(lcTl, "qt.quick.timeline")
 
struct Update {
    Update(QQuickTimeLineValue *_g, qreal _v)
        : g(_g), v(_v) {}
    Update(const QQuickTimeLineCallback &_e)
        : g(nullptr), v(0), e(_e) {}
 
    QQuickTimeLineValue *g;
    qreal v;
    QQuickTimeLineCallback e;
};
 
struct QQuickTimeLinePrivate
{
    QQuickTimeLinePrivate(QQuickTimeLine *);
 
    struct Op {
        enum Type {
            Pause, // Pauses any value updates
            Set, // Instantly changes the value to a target value
            Move, // Moves towards a target value over time
            MoveBy, // Same as Move, but target value is now an offset from the starting value
            Accel, // Moves towards a target value over time with a constant acceleration
            AccelDistance,
            Execute // Calls back a function
        };
        Op() {}
        Op(Type t, int l, qreal v, qreal v2, int o,
           const QQuickTimeLineCallback &ev = QQuickTimeLineCallback(), const QEasingCurve &es = QEasingCurve())
            : type(t), length(l), value(v), value2(v2), order(o), event(ev),
              easing(es) {}
        Op(const Op &o)
            : type(o.type), length(o.length), value(o.value), value2(o.value2),
              order(o.order), event(o.event), easing(o.easing) {}
        Op &operator=(const Op &o) {
            type = o.type; length = o.length; value = o.value;
            value2 = o.value2; order = o.order; event = o.event;
            easing = o.easing;
            return *this;
        }
 
        Type type;
        int length;
        qreal value;
        qreal value2;
 
        int order;
        QQuickTimeLineCallback event;
        QEasingCurve easing;
    };
    struct TimeLine
    {
        TimeLine() {}
        QList<Op> ops;
        int length = 0;
        int consumedOpLength = 0;
        qreal base = 0.;
    };
 
    int length;
    int syncPoint;
    typedef QHash<QQuickTimeLineObject *, TimeLine> Ops;
    Ops ops;
    QQuickTimeLine *q;
 
    void add(QQuickTimeLineObject &, const Op &);
    qreal value(const Op &op, int time, qreal base, bool *) const;
 
    int advance(int);
 
    bool clockRunning;
    int prevTime;
 
    int order;
 
    QQuickTimeLine::SyncMode syncMode;
    int syncAdj;
    QList<QPair<int, Update> > *updateQueue;
};
 
QQuickTimeLinePrivate::QQuickTimeLinePrivate(QQuickTimeLine *parent)
: length(0), syncPoint(0), q(parent), clockRunning(false), prevTime(0), order(0), syncMode(QQuickTimeLine::LocalSync), syncAdj(0), updateQueue(nullptr)
{
}
 
void QQuickTimeLinePrivate::add(QQuickTimeLineObject &g, const Op &o)
{
    if (g._t && g._t != q) {
        qWarning() << "QQuickTimeLine: Cannot modify a QQuickTimeLineValue owned by"
                   << "another timeline.";
        return;
    }
    g._t = q;
 
    Ops::Iterator iter = ops.find(&g);
    if (iter == ops.end()) {
        iter = ops.insert(&g, TimeLine());
        if (syncPoint > 0)
            q->pause(g, syncPoint);
    }
    if (!iter->ops.isEmpty() &&
       o.type == Op::Pause &&
       iter->ops.constLast().type == Op::Pause) {
        // If the last operation was a pause, and we're adding another, simply prolong it.
        iter->ops.last().length += o.length;
        iter->length += o.length;
    } else {
        // Add to the list of operations
        iter->ops.append(o);
        iter->length += o.length;
    }
 
    if (iter->length > length)
        length = iter->length;
 
    if (!clockRunning) {
        q->stop();
        prevTime = 0;
        clockRunning = true;
 
        if (syncMode == QQuickTimeLine::LocalSync)  {
            syncAdj = -1;
        } else {
            syncAdj = 0;
        }
        q->start();
/*        q->tick(0);
        if (syncMode == QQuickTimeLine::LocalSync)  {
            syncAdj = -1;
        } else {
            syncAdj = 0;
        }
        */
    }
}
 
qreal QQuickTimeLinePrivate::value(const Op &op, int time, qreal base, bool *changed) const
{
    Q_ASSERT(time >= 0);
    Q_ASSERT(time <= op.length);
    *changed = true;
 
    switch(op.type) {
        case Op::Pause:
            *changed = false;
            return base;
        case Op::Set:
            return op.value;
        case Op::Move:
            if (time == 0) {
                return base;
            } else if (time == (op.length)) {
                return op.value;
            } else {
                qreal delta = op.value - base;
                qreal pTime = (qreal)(time) / (qreal)op.length;
                if (op.easing.type() == QEasingCurve::Linear)
                    return base + delta * pTime;
                else
                    return base + delta * op.easing.valueForProgress(pTime);
            }
        case Op::MoveBy:
            if (time == 0) {
                return base;
            } else if (time == (op.length)) {
                return base + op.value;
            } else {
                qreal delta = op.value;
                qreal pTime = (qreal)(time) / (qreal)op.length;
                if (op.easing.type() == QEasingCurve::Linear)
                    return base + delta * pTime;
                else
                    return base + delta * op.easing.valueForProgress(pTime);
            }
        case Op::Accel:
            if (time == 0) {
                return base;
            } else {
                qreal t = (qreal)(time) / 1000.0f;
                qreal delta = op.value * t + 0.5f * op.value2 * t * t;
                return base + delta;
            }
        case Op::AccelDistance:
            if (time == 0) {
                return base;
            } else if (time == (op.length)) {
                return base + op.value2;
            } else {
                qreal t = (qreal)(time) / 1000.0f;
                qreal accel = -1.0f * 1000.0f * op.value / (qreal)op.length;
                qreal delta = op.value * t + 0.5f * accel * t * t;
                return base + delta;
 
            }
        case Op::Execute:
            op.event.d0(op.event.d1);
            *changed = false;
            return -1;
    }
 
    return base;
}
 
QQuickTimeLine::QQuickTimeLine(QObject *parent)
    : QObject(parent)
{
    d = new QQuickTimeLinePrivate(this);
}
 
QQuickTimeLine::~QQuickTimeLine()
{
    for (QQuickTimeLinePrivate::Ops::Iterator iter = d->ops.begin();
            iter != d->ops.end();
            ++iter)
        iter.key()->_t = nullptr;
 
    delete d; d = nullptr;
}
 
QQuickTimeLine::SyncMode QQuickTimeLine::syncMode() const
{
    return d->syncMode;
}
 
void QQuickTimeLine::setSyncMode(SyncMode syncMode)
{
    d->syncMode = syncMode;
}
 
void QQuickTimeLine::pause(QQuickTimeLineObject &obj, int time)
{
    if (time <= 0) return;
    QQuickTimeLinePrivate::Op op(QQuickTimeLinePrivate::Op::Pause, time, 0., 0., d->order++);
    d->add(obj, op);
}
 
void QQuickTimeLine::callback(const QQuickTimeLineCallback &callback)
{
    QQuickTimeLinePrivate::Op op(QQuickTimeLinePrivate::Op::Execute, 0, 0, 0., d->order++, callback);
    d->add(*callback.callbackObject(), op);
}
 
void QQuickTimeLine::set(QQuickTimeLineValue &timeLineValue, qreal value)
{
    QQuickTimeLinePrivate::Op op(QQuickTimeLinePrivate::Op::Set, 0, value, 0., d->order++);
    d->add(timeLineValue, op);
}
 
int QQuickTimeLine::accel(QQuickTimeLineValue &timeLineValue, qreal velocity, qreal acceleration)
{
    if (qFuzzyIsNull(acceleration) || qt_is_nan(acceleration))
        return -1;
 
    if ((velocity > 0.0f) == (acceleration > 0.0f))
        acceleration = acceleration * -1.0f;
 
    int time = static_cast<int>(-1000 * velocity / acceleration);
    if (time <= 0) return -1;
 
    QQuickTimeLinePrivate::Op op(QQuickTimeLinePrivate::Op::Accel, time, velocity, acceleration, d->order++);
    d->add(timeLineValue, op);
 
    return time;
}
 
int QQuickTimeLine::accel(QQuickTimeLineValue &timeLineValue, qreal velocity, qreal acceleration, qreal maxDistance)
{
    if (qFuzzyIsNull(maxDistance) || qt_is_nan(maxDistance) || qFuzzyIsNull(acceleration) || qt_is_nan(acceleration))
        return -1;
 
    Q_ASSERT(acceleration > 0.0f && maxDistance > 0.0f);
 
    qreal maxAccel = (velocity * velocity) / (2.0f * maxDistance);
    if (maxAccel > acceleration)
        acceleration = maxAccel;
 
    if ((velocity > 0.0f) == (acceleration > 0.0f))
        acceleration = acceleration * -1.0f;
 
    int time = static_cast<int>(-1000 * velocity / acceleration);
    if (time <= 0) return -1;
 
    QQuickTimeLinePrivate::Op op(QQuickTimeLinePrivate::Op::Accel, time, velocity, acceleration, d->order++);
    d->add(timeLineValue, op);
 
    return time;
}
 
int QQuickTimeLine::accelDistance(QQuickTimeLineValue &timeLineValue, qreal velocity, qreal distance)
{
    if (qFuzzyIsNull(distance) || qt_is_nan(distance) || qFuzzyIsNull(velocity) || qt_is_nan(velocity))
        return -1;
 
    Q_ASSERT((distance >= 0.0f) == (velocity >= 0.0f));
 
    int time = static_cast<int>(1000 * (2.0f * distance) / velocity);
    if (time <= 0) return -1;
 
    QQuickTimeLinePrivate::Op op(QQuickTimeLinePrivate::Op::AccelDistance, time, velocity, distance, d->order++);
    d->add(timeLineValue, op);
 
    return time;
}
 
void QQuickTimeLine::move(QQuickTimeLineValue &timeLineValue, qreal destination, int time)
{
    if (time <= 0) return;
    QQuickTimeLinePrivate::Op op(QQuickTimeLinePrivate::Op::Move, time, destination, 0.0f, d->order++);
    d->add(timeLineValue, op);
}
 
void QQuickTimeLine::move(QQuickTimeLineValue &timeLineValue, qreal destination, const QEasingCurve &easing, int time)
{
    if (time <= 0) return;
    QQuickTimeLinePrivate::Op op(QQuickTimeLinePrivate::Op::Move, time, destination, 0.0f, d->order++, QQuickTimeLineCallback(), easing);
    d->add(timeLineValue, op);
}
 
void QQuickTimeLine::moveBy(QQuickTimeLineValue &timeLineValue, qreal change, int time)
{
    if (time <= 0) return;
    QQuickTimeLinePrivate::Op op(QQuickTimeLinePrivate::Op::MoveBy, time, change, 0.0f, d->order++);
    d->add(timeLineValue, op);
}
 
void QQuickTimeLine::moveBy(QQuickTimeLineValue &timeLineValue, qreal change, const QEasingCurve &easing, int time)
{
    if (time <= 0) return;
    QQuickTimeLinePrivate::Op op(QQuickTimeLinePrivate::Op::MoveBy, time, change, 0.0f, d->order++, QQuickTimeLineCallback(), easing);
    d->add(timeLineValue, op);
}
 
void QQuickTimeLine::reset(QQuickTimeLineValue &timeLineValue)
{
    if (!timeLineValue._t)
        return;
    if (timeLineValue._t != this) {
        qWarning() << "QQuickTimeLine: Cannot reset a QQuickTimeLineValue owned by another timeline.";
        return;
    }
    qCDebug(lcTl) << static_cast<QObject*>(this) << timeLineValue.value();
    remove(&timeLineValue);
    timeLineValue._t = nullptr;
}
 
int QQuickTimeLine::duration() const
{
    return -1;
}
 
void QQuickTimeLine::sync(QQuickTimeLineValue &timeLineValue, QQuickTimeLineValue &syncTo)
{
    QQuickTimeLinePrivate::Ops::Iterator iter = d->ops.find(&syncTo);
    if (iter == d->ops.end())
        return;
    int length = iter->length;
 
    iter = d->ops.find(&timeLineValue);
    if (iter == d->ops.end()) {
        pause(timeLineValue, length);
    } else {
        int glength = iter->length;
        pause(timeLineValue, length - glength);
    }
}
 
void QQuickTimeLine::sync(QQuickTimeLineValue &timeLineValue)
{
    QQuickTimeLinePrivate::Ops::Iterator iter = d->ops.find(&timeLineValue);
    if (iter == d->ops.end()) {
        pause(timeLineValue, d->length);
    } else {
        pause(timeLineValue, d->length - iter->length);
    }
}
 
/*
    Synchronize all currently and future scheduled values in this timeline to
    the longest action currently scheduled.
 
    For example:
    \code
    value1->setValue(0.);
    value2->setValue(0.);
    value3->setValue(0.);
    QQuickTimeLine tl;
    ...
    tl.move(value1, 10, 200);
    tl.move(value2, 10, 100);
    tl.sync();
    tl.move(value2, 20, 100);
    tl.move(value3, 20, 100);
    \endcode
 
    will result in:
 
    \table
    \header \li \li 0ms \li 50ms \li 100ms \li 150ms \li 200ms \li 250ms \li 300ms
    \row \li value1 \li 0 \li 2.5 \li 5.0 \li 7.5 \li 10 \li 10 \li 10
    \row \li value2 \li 0 \li 5.0 \li 10.0 \li 10.0 \li 10.0 \li 15.0 \li 20.0
    \row \li value2 \li 0 \li 0 \li 0 \li 0 \li 0 \li 10.0 \li 20.0
    \endtable
*/
 
/*void QQuickTimeLine::sync()
{
    for (QQuickTimeLinePrivate::Ops::Iterator iter = d->ops.begin();
            iter != d->ops.end();
            ++iter)
        pause(*iter.key(), d->length - iter->length);
    d->syncPoint = d->length;
}*/
 
void QQuickTimeLine::setSyncPoint(int sp)
{
    d->syncPoint = sp;
}
 
int QQuickTimeLine::syncPoint() const
{
    return d->syncPoint;
}
 
bool QQuickTimeLine::isActive() const
{
    return !d->ops.isEmpty();
}
 
void QQuickTimeLine::complete()
{
    d->advance(d->length);
}
 
void QQuickTimeLine::clear()
{
    for (QQuickTimeLinePrivate::Ops::const_iterator iter = d->ops.cbegin(), cend  = d->ops.cend(); iter != cend; ++iter)
        iter.key()->_t = nullptr;
    d->ops.clear();
    d->length = 0;
    d->syncPoint = 0;
    //XXX need stop here?
}
 
int QQuickTimeLine::time() const
{
    return d->prevTime;
}
 
void QQuickTimeLine::updateCurrentTime(int v)
{
    if (d->syncAdj == -1)
        d->syncAdj = v;
    v -= d->syncAdj;
 
    int timeChanged = v - d->prevTime;
#if 0
    if (!timeChanged)
        return;
#endif
    d->prevTime = v;
    d->advance(timeChanged);
    emit updated();
 
    // Do we need to stop the clock?
    if (d->ops.isEmpty()) {
        stop();
        d->prevTime = 0;
        d->clockRunning = false;
        emit completed();
    } /*else if (pauseTime > 0) {
        GfxClock::cancelClock();
        d->prevTime = 0;
        GfxClock::pauseFor(pauseTime);
        d->syncAdj = 0;
        d->clockRunning = false;
    }*/ else if ( state() != Running) {
        stop();
        d->prevTime = 0;
        d->clockRunning = true;
        d->syncAdj = 0;
        start();
    }
}
 
void QQuickTimeLine::debugAnimation(QDebug d) const
{
    d << "QuickTimeLine(" << Qt::hex << (const void *) this << Qt::dec << ")";
}
 
bool operator<(const QPair<int, Update> &lhs,
               const QPair<int, Update> &rhs)
{
    return lhs.first < rhs.first;
}
 
int QQuickTimeLinePrivate::advance(int t)
{
    int pauseTime = -1;
 
    // XXX - surely there is a more efficient way?
    do {
        pauseTime = -1;
        // Minimal advance time
        int advanceTime = t;
        for (Ops::const_iterator iter = ops.constBegin(), cend = ops.constEnd(); iter != cend; ++iter) {
            const TimeLine &tl = *iter;
            const Op &op = tl.ops.first();
            int length = op.length - tl.consumedOpLength;
 
            if (length < advanceTime) {
                advanceTime = length;
                if (advanceTime == 0)
                    break;
            }
        }
        t -= advanceTime;
 
        // Process until then.  A zero length advance time will only process
        // sets.
        QList<QPair<int, Update> > updates;
 
        for (Ops::Iterator iter = ops.begin(); iter != ops.end(); ) {
            QQuickTimeLineValue *v = static_cast<QQuickTimeLineValue *>(iter.key());
            TimeLine &tl = *iter;
            Q_ASSERT(!tl.ops.isEmpty());
 
            do {
                Op &op = tl.ops.first();
                if (advanceTime == 0 && op.length != 0)
                    continue;
 
                if (tl.consumedOpLength == 0 &&
                   op.type != Op::Pause &&
                   op.type != Op::Execute)
                    tl.base = v->value();
 
                if ((tl.consumedOpLength + advanceTime) == op.length) {
                    // Finishing operation, the timeline value will be the operation's target value.
                    if (op.type == Op::Execute) {
                        updates << qMakePair(op.order, Update(op.event));
                    } else {
                        bool changed = false;
                        qreal val = value(op, op.length, tl.base, &changed);
                        if (changed)
                            updates << qMakePair(op.order, Update(v, val));
                    }
                    tl.length -= qMin(advanceTime, tl.length);
                    tl.consumedOpLength = 0;
                    tl.ops.removeFirst();
                } else {
                    // Partially finished operation, the timeline value will be between the base
                    // value and the target value, depending on progress and type of operation.
                    tl.consumedOpLength += advanceTime;
                    bool changed = false;
                    qreal val = value(op, tl.consumedOpLength, tl.base, &changed);
                    if (changed)
                        updates << qMakePair(op.order, Update(v, val));
                    tl.length -= qMin(advanceTime, tl.length);
                    break;
                }
 
            } while(!tl.ops.isEmpty() && advanceTime == 0 && tl.ops.first().length == 0);
 
 
            if (tl.ops.isEmpty()) {
                iter = ops.erase(iter);
                v->_t = nullptr;
            } else {
                if (tl.ops.first().type == Op::Pause && pauseTime != 0) {
                    int opPauseTime = tl.ops.first().length - tl.consumedOpLength;
                    if (pauseTime == -1 || opPauseTime < pauseTime)
                        pauseTime = opPauseTime;
                } else {
                    pauseTime = 0;
                }
                ++iter;
            }
        }
 
        length -= qMin(length, advanceTime);
        syncPoint -= advanceTime;
 
        std::sort(updates.begin(), updates.end());
        updateQueue = &updates;
        for (int ii = 0; ii < updates.size(); ++ii) {
            const Update &v = updates.at(ii).second;
            if (v.g) {
                v.g->setValue(v.v);
            } else {
                v.e.d0(v.e.d1);
            }
        }
        updateQueue = nullptr;
    } while(t);
 
    return pauseTime;
}
 
void QQuickTimeLine::remove(QQuickTimeLineObject *v)
{
    QQuickTimeLinePrivate::Ops::Iterator iter = d->ops.find(v);
    Q_ASSERT(iter != d->ops.end());
 
    int len = iter->length;
    d->ops.erase(iter);
    if (len == d->length) {
        // We need to recalculate the length
        d->length = 0;
        for (QQuickTimeLinePrivate::Ops::Iterator iter = d->ops.begin();
                iter != d->ops.end();
                ++iter) {
 
            if (iter->length > d->length)
                d->length = iter->length;
 
        }
    }
    if (d->ops.isEmpty()) {
        stop();
        d->clockRunning = false;
    } else if (state() != Running) { // was !GfxClock::isActive()
        stop();
        d->prevTime = 0;
        d->clockRunning = true;
 
        if (d->syncMode == QQuickTimeLine::LocalSync) {
            d->syncAdj = -1;
        } else {
            d->syncAdj = 0;
        }
        start();
    }
 
    if (d->updateQueue) {
        for (int ii = 0; ii < d->updateQueue->size(); ++ii) {
            if (d->updateQueue->at(ii).second.g == v ||
               d->updateQueue->at(ii).second.e.callbackObject() == v) {
                d->updateQueue->removeAt(ii);
                --ii;
            }
        }
    }
 
 
}
 
QQuickTimeLineObject::QQuickTimeLineObject()
: _t(nullptr)
{
}
 
QQuickTimeLineObject::~QQuickTimeLineObject()
{
    if (_t) {
        _t->remove(this);
        _t = nullptr;
    }
}
 
QQuickTimeLineCallback::QQuickTimeLineCallback()
: d0(nullptr), d1(nullptr), d2(nullptr)
{
}
 
QQuickTimeLineCallback::QQuickTimeLineCallback(QQuickTimeLineObject *b, Callback f, void *d)
: d0(f), d1(d), d2(b)
{
}
 
QQuickTimeLineCallback::QQuickTimeLineCallback(const QQuickTimeLineCallback &o)
: d0(o.d0), d1(o.d1), d2(o.d2)
{
}
 
QQuickTimeLineCallback &QQuickTimeLineCallback::operator=(const QQuickTimeLineCallback &o)
{
    d0 = o.d0;
    d1 = o.d1;
    d2 = o.d2;
    return *this;
}
 
QQuickTimeLineObject *QQuickTimeLineCallback::callbackObject() const
{
    return d2;
}
 
QT_END_NAMESPACE
 
#include "moc_qquicktimeline_p_p.cpp"