qtimeline.cpp

Go to the documentation of this file.

// Copyright (C) 2020 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 "qtimeline.h"
 
#include <private/qproperty_p.h>
#include <private/qobject_p.h>
#include <QtCore/qcoreevent.h>
#include <QtCore/qmath.h>
#include <QtCore/qelapsedtimer.h>
 
QT_BEGIN_NAMESPACE
 
class QTimeLinePrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QTimeLine)
public:
    QElapsedTimer timer;
    Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(QTimeLinePrivate, QEasingCurve, easingCurve,
                                         QEasingCurve::InOutSine)
 
    int startTime = 0;
    void setDuration(int duration) { q_func()->setDuration(duration); }
    Q_OBJECT_COMPAT_PROPERTY_WITH_ARGS(QTimeLinePrivate, int, duration,
                                       &QTimeLinePrivate::setDuration, 1000)
    int startFrame = 0;
    int endFrame = 0;
    Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(QTimeLinePrivate, int, updateInterval, 1000 / 25)
    Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(QTimeLinePrivate, int, loopCount, 1)
    int currentLoopCount = 0;
 
    void setCurrentTimeForwardToQ(int time) { q_func()->setCurrentTime(time); }
    Q_OBJECT_COMPAT_PROPERTY_WITH_ARGS(QTimeLinePrivate, int, currentTime,
                                       &QTimeLinePrivate::setCurrentTimeForwardToQ, 0)
    int timerId = 0;
 
    void setDirection(QTimeLine::Direction direction) { q_func()->setDirection(direction); }
    Q_OBJECT_COMPAT_PROPERTY_WITH_ARGS(QTimeLinePrivate, QTimeLine::Direction, direction,
                                       &QTimeLinePrivate::setDirection, QTimeLine::Forward)
    QTimeLine::State state = QTimeLine::NotRunning;
    inline void setState(QTimeLine::State newState)
    {
        Q_Q(QTimeLine);
        if (newState != state)
            emit q->stateChanged(state = newState, QTimeLine::QPrivateSignal());
    }
 
    void setCurrentTime(int msecs);
};
 
void QTimeLinePrivate::setCurrentTime(int msecs)
{
    Q_Q(QTimeLine);
    currentTime.removeBindingUnlessInWrapper();
    const auto previousCurrentTime = currentTime.valueBypassingBindings();
 
    const qreal lastValue = q->valueForTime(previousCurrentTime);
    const int lastFrame = q->frameForTime(previousCurrentTime);
 
    // Determine if we are looping.
    const int elapsed = (direction == QTimeLine::Backward) ? (-msecs + duration) : msecs;
    const int loopCountNow = elapsed / duration;
 
    const bool looping = (loopCountNow != currentLoopCount);
#ifdef QTIMELINE_DEBUG
    qDebug() << "QTimeLinePrivate::setCurrentTime:" << msecs << duration << "with loopCountNow"
             << loopCountNow << "currentLoopCount" << currentLoopCount << "looping" << looping;
#endif
    if (looping)
        currentLoopCount = loopCountNow;
 
    // Normalize msecs to be between 0 and duration, inclusive.
    currentTime.setValueBypassingBindings(elapsed % duration);
    if (direction.value() == QTimeLine::Backward)
        currentTime.setValueBypassingBindings(duration - currentTime.valueBypassingBindings());
 
    // Check if we have reached the end of loopcount.
    bool finished = false;
    if (loopCount && currentLoopCount >= loopCount) {
        finished = true;
        currentTime.setValueBypassingBindings((direction == QTimeLine::Backward) ? 0 : duration);
        currentLoopCount = loopCount - 1;
    }
 
    const int currentFrame = q->frameForTime(currentTime.valueBypassingBindings());
#ifdef QTIMELINE_DEBUG
    qDebug() << "QTimeLinePrivate::setCurrentTime: frameForTime"
             << currentTime.valueBypassingBindings() << currentFrame;
#endif
    const qreal currentValue = q->valueForTime(currentTime.valueBypassingBindings());
    if (!qFuzzyCompare(lastValue, currentValue))
        emit q->valueChanged(currentValue, QTimeLine::QPrivateSignal());
    if (lastFrame != currentFrame) {
        const int transitionframe = (direction == QTimeLine::Forward ? endFrame : startFrame);
        if (looping && !finished && transitionframe != currentFrame) {
#ifdef QTIMELINE_DEBUG
            qDebug("QTimeLinePrivate::setCurrentTime: transitionframe");
#endif
            emit q->frameChanged(transitionframe, QTimeLine::QPrivateSignal());
        }
#ifdef QTIMELINE_DEBUG
        else {
            QByteArray reason;
            if (!looping)
                reason += " not looping";
            if (finished) {
                if (!reason.isEmpty())
                    reason += " and";
                reason += " finished";
            }
            if (transitionframe == currentFrame) {
                if (!reason.isEmpty())
                    reason += " and";
                reason += " transitionframe is equal to currentFrame: " + QByteArray::number(currentFrame);
            }
            qDebug("QTimeLinePrivate::setCurrentTime: not transitionframe because %s",  reason.constData());
        }
#endif
        emit q->frameChanged(currentFrame, QTimeLine::QPrivateSignal());
    }
    if (finished && state == QTimeLine::Running) {
        q->stop();
        emit q->finished(QTimeLine::QPrivateSignal());
    }
    if (currentTime.valueBypassingBindings() != previousCurrentTime)
        currentTime.notify();
}
QBindable<int> QTimeLine::bindableCurrentTime()
{
    Q_D(QTimeLine);
    return &d->currentTime;
}
 
QTimeLine::QTimeLine(int duration, QObject *parent)
    : QObject(*new QTimeLinePrivate, parent)
{
    setDuration(duration);
}
 
QTimeLine::~QTimeLine()
{
    Q_D(QTimeLine);
 
    if (d->state == Running)
        stop();
}
 
QTimeLine::State QTimeLine::state() const
{
    Q_D(const QTimeLine);
    return d->state;
}
 
int QTimeLine::loopCount() const
{
    Q_D(const QTimeLine);
    return d->loopCount;
}
 
void QTimeLine::setLoopCount(int count)
{
    Q_D(QTimeLine);
    d->loopCount = count;
}
 
QBindable<int> QTimeLine::bindableLoopCount()
{
    Q_D(QTimeLine);
    return &d->loopCount;
}
 
QTimeLine::Direction QTimeLine::direction() const
{
    Q_D(const QTimeLine);
    return d->direction;
}
void QTimeLine::setDirection(Direction direction)
{
    Q_D(QTimeLine);
    d->direction.removeBindingUnlessInWrapper();
    const auto previousDirection = d->direction.valueBypassingBindings();
    d->direction.setValueBypassingBindings(direction);
    d->startTime = d->currentTime;
    d->timer.start();
    if (previousDirection != d->direction.valueBypassingBindings())
        d->direction.notify();
}
 
QBindable<QTimeLine::Direction> QTimeLine::bindableDirection()
{
    Q_D(QTimeLine);
    return &d->direction;
}
 
int QTimeLine::duration() const
{
    Q_D(const QTimeLine);
    return d->duration;
}
void QTimeLine::setDuration(int duration)
{
    Q_D(QTimeLine);
    if (duration <= 0) {
        qWarning("QTimeLine::setDuration: cannot set duration <= 0");
        return;
    }
    d->duration.removeBindingUnlessInWrapper();
    if (duration != d->duration.valueBypassingBindings()) {
        d->duration.setValueBypassingBindings(duration);
        d->duration.notify();
    }
}
 
QBindable<int> QTimeLine::bindableDuration()
{
    Q_D(QTimeLine);
    return &d->duration;
}
 
int QTimeLine::startFrame() const
{
    Q_D(const QTimeLine);
    return d->startFrame;
}
 
void QTimeLine::setStartFrame(int frame)
{
    Q_D(QTimeLine);
    d->startFrame = frame;
}
 
int QTimeLine::endFrame() const
{
    Q_D(const QTimeLine);
    return d->endFrame;
}
 
void QTimeLine::setEndFrame(int frame)
{
    Q_D(QTimeLine);
    d->endFrame = frame;
}
 
void QTimeLine::setFrameRange(int startFrame, int endFrame)
{
    Q_D(QTimeLine);
    d->startFrame = startFrame;
    d->endFrame = endFrame;
}
 
int QTimeLine::updateInterval() const
{
    Q_D(const QTimeLine);
    return d->updateInterval;
}
void QTimeLine::setUpdateInterval(int interval)
{
    Q_D(QTimeLine);
    d->updateInterval = interval;
}
QBindable<int> QTimeLine::bindableUpdateInterval()
{
    Q_D(QTimeLine);
    return &d->updateInterval;
}
 
QEasingCurve QTimeLine::easingCurve() const
{
    Q_D(const QTimeLine);
    return d->easingCurve;
}
 
void QTimeLine::setEasingCurve(const QEasingCurve &curve)
{
    Q_D(QTimeLine);
    d->easingCurve = curve;
}
 
QBindable<QEasingCurve> QTimeLine::bindableEasingCurve()
{
    Q_D(QTimeLine);
    return &d->easingCurve;
}
 
int QTimeLine::currentTime() const
{
    Q_D(const QTimeLine);
    return d->currentTime;
}
void QTimeLine::setCurrentTime(int msec)
{
    Q_D(QTimeLine);
    d->startTime = 0;
    d->currentLoopCount = 0;
    d->timer.restart();
    d->setCurrentTime(msec);
}
 
int QTimeLine::currentFrame() const
{
    Q_D(const QTimeLine);
    return frameForTime(d->currentTime);
}
 
qreal QTimeLine::currentValue() const
{
    Q_D(const QTimeLine);
    return valueForTime(d->currentTime);
}
 
int QTimeLine::frameForTime(int msec) const
{
    Q_D(const QTimeLine);
    if (d->direction == Forward)
        return d->startFrame + int((d->endFrame - d->startFrame) * valueForTime(msec));
    return d->startFrame + qCeil((d->endFrame - d->startFrame) * valueForTime(msec));
}
 
qreal QTimeLine::valueForTime(int msec) const
{
    Q_D(const QTimeLine);
    msec = qBound(0, msec, d->duration.value());
 
    qreal value = msec / qreal(d->duration.value());
    return d->easingCurve.value().valueForProgress(value);
}
 
void QTimeLine::start()
{
    Q_D(QTimeLine);
    if (d->timerId) {
        qWarning("QTimeLine::start: already running");
        return;
    }
    int curTime = 0;
    if (d->direction == Backward)
        curTime = d->duration;
    d->timerId = startTimer(d->updateInterval);
    d->startTime = curTime;
    d->currentLoopCount = 0;
    d->timer.start();
    d->setState(Running);
    d->setCurrentTime(curTime);
}
 
void QTimeLine::resume()
{
    Q_D(QTimeLine);
    if (d->timerId) {
        qWarning("QTimeLine::resume: already running");
        return;
    }
    d->timerId = startTimer(d->updateInterval);
    d->startTime = d->currentTime;
    d->timer.start();
    d->setState(Running);
}
 
void QTimeLine::stop()
{
    Q_D(QTimeLine);
    if (d->timerId)
        killTimer(d->timerId);
    d->setState(NotRunning);
    d->timerId = 0;
}
 
void QTimeLine::setPaused(bool paused)
{
    Q_D(QTimeLine);
    if (d->state == NotRunning) {
        qWarning("QTimeLine::setPaused: Not running");
        return;
    }
    if (paused && d->state != Paused) {
        d->startTime = d->currentTime;
        killTimer(d->timerId);
        d->timerId = 0;
        d->setState(Paused);
    } else if (!paused && d->state == Paused) {
        // Same as resume()
        d->timerId = startTimer(d->updateInterval);
        d->startTime = d->currentTime;
        d->timer.start();
        d->setState(Running);
    }
}
 
void QTimeLine::toggleDirection()
{
    Q_D(QTimeLine);
    setDirection(d->direction == Forward ? Backward : Forward);
}
 
void QTimeLine::timerEvent(QTimerEvent *event)
{
    Q_D(QTimeLine);
    if (event->timerId() != d->timerId) {
        event->ignore();
        return;
    }
    event->accept();
 
    if (d->direction == Forward) {
        d->setCurrentTime(d->startTime + d->timer.elapsed());
    } else {
        d->setCurrentTime(d->startTime - d->timer.elapsed());
    }
}
 
QT_END_NAMESPACE
 
#include "moc_qtimeline.cpp"