qquickframeanimation.cpp

Go to the documentation of this file.

// Copyright (C) 2022 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 "qquickframeanimation_p.h"
 
#include <QtCore/qcoreapplication.h>
#include <QtCore/qelapsedtimer.h>
#include "private/qabstractanimationjob_p.h"
#include <private/qobject_p.h>
#include <qdebug.h>
 
QT_BEGIN_NAMESPACE
 
class QFrameAnimationJob : public QAbstractAnimationJob
{
    int duration() const override {
        return 1;
    }
};
 
class QQuickFrameAnimationPrivate : public QObjectPrivate, public QAnimationJobChangeListener
{
    Q_DECLARE_PUBLIC(QQuickFrameAnimation)
public:
    QQuickFrameAnimationPrivate() {}
 
    void animationCurrentLoopChanged(QAbstractAnimationJob *) override {
        maybeTick();
    }
 
    void maybeTick()
    {
        Q_Q(QQuickFrameAnimation);
        if (!running || paused)
            return;
 
        qint64 elapsedTimeNs = elapsedTimer.nsecsElapsed();
        qint64 frameTimeNs = elapsedTimeNs - prevElapsedTimeNs;
        if (prevFrameTimeNs != frameTimeNs) {
            frameTime = qreal(frameTimeNs) / 1000000000.0;
            Q_EMIT q->frameTimeChanged();
        }
 
        const qreal f = 0.1;
        qreal newSmoothFrameTime = f * frameTime + (1.0 - f) * smoothFrameTime;
        if (!qFuzzyCompare(newSmoothFrameTime, smoothFrameTime)) {
            smoothFrameTime = newSmoothFrameTime;
            Q_EMIT q->smoothFrameTimeChanged();
        }
 
        q->setElapsedTime(elapsedTime + frameTime);
 
        const int frame = (firstTick && currentFrame > 0) ? 0 : currentFrame + 1;
        q->setCurrentFrame(frame);
 
        prevElapsedTimeNs = elapsedTimeNs;
        prevFrameTimeNs = frameTimeNs;
        firstTick = false;
 
        Q_EMIT q->triggered();
    }
 
    // Handle the running/pausing state updates.
    void updateState()
    {
        if (!componentComplete)
            return;
 
        if (running && !paused) {
            if (firstTick) {
                elapsedTime = 0;
                elapsedTimer.start();
            }
            prevElapsedTimeNs = elapsedTimer.nsecsElapsed();
            frameJob.start();
        } else {
            frameJob.stop();
        }
    }
 
private:
    QFrameAnimationJob frameJob;
    QElapsedTimer elapsedTimer;
    int currentFrame = 0;
    qreal frameTime = 0.0;
    qreal smoothFrameTime = 0.0;
    qreal elapsedTime = 0.0;
    qint64 prevFrameTimeNs = 0;
    qint64 prevElapsedTimeNs = 0;
    bool running = false;
    bool paused = false;
    bool componentComplete = false;
    bool firstTick = true;
};
 
QQuickFrameAnimation::QQuickFrameAnimation(QObject *parent)
    : QObject(*(new QQuickFrameAnimationPrivate), parent)
{
    Q_D(QQuickFrameAnimation);
    d->frameJob.addAnimationChangeListener(d, QAbstractAnimationJob::CurrentLoop);
    d->frameJob.setLoopCount(-1);
}
 
bool QQuickFrameAnimation::isRunning() const
{
    Q_D(const QQuickFrameAnimation);
    return d->running;
}
 
void QQuickFrameAnimation::setRunning(bool running)
{
    Q_D(QQuickFrameAnimation);
    if (d->running != running) {
        d->running = running;
        d->firstTick = true;
        Q_EMIT runningChanged();
        d->updateState();
    }
}
 
bool QQuickFrameAnimation::isPaused() const
{
    Q_D(const QQuickFrameAnimation);
    return d->paused;
}
 
void QQuickFrameAnimation::setPaused(bool paused)
{
    Q_D(QQuickFrameAnimation);
    if (d->paused != paused) {
        d->paused = paused;
        Q_EMIT pausedChanged();
        d->updateState();
    }
}
 
int QQuickFrameAnimation::currentFrame() const
{
    Q_D(const QQuickFrameAnimation);
    return d->currentFrame;
}
 
qreal QQuickFrameAnimation::frameTime() const
{
    Q_D(const QQuickFrameAnimation);
    return d->frameTime;
}
 
qreal QQuickFrameAnimation::smoothFrameTime() const
{
    Q_D(const QQuickFrameAnimation);
    return d->smoothFrameTime;
}
 
qreal QQuickFrameAnimation::elapsedTime() const
{
    Q_D(const QQuickFrameAnimation);
    return d->elapsedTime;
}
 
void QQuickFrameAnimation::start()
{
    setRunning(true);
}
 
void QQuickFrameAnimation::stop()
{
    setRunning(false);
    setPaused(false);
}
 
void QQuickFrameAnimation::restart()
{
    stop();
    start();
}
 
void QQuickFrameAnimation::pause()
{
    setPaused(true);
}
 
void QQuickFrameAnimation::resume()
{
    setPaused(false);
}
 
void QQuickFrameAnimation::reset()
{
    Q_D(QQuickFrameAnimation);
    setElapsedTime(0);
    setCurrentFrame(0);
    d->prevElapsedTimeNs = 0;
    d->elapsedTimer.start();
}
 
void QQuickFrameAnimation::classBegin()
{
    Q_D(QQuickFrameAnimation);
    d->componentComplete = false;
}
 
void QQuickFrameAnimation::componentComplete()
{
    Q_D(QQuickFrameAnimation);
    d->componentComplete = true;
    d->updateState();
}
 
void QQuickFrameAnimation::setCurrentFrame(int frame)
{
    Q_D(QQuickFrameAnimation);
    if (d->currentFrame != frame) {
        d->currentFrame = frame;
        Q_EMIT currentFrameChanged();
    }
}
 
void QQuickFrameAnimation::setElapsedTime(qreal elapsedTime)
{
    Q_D(QQuickFrameAnimation);
    if (!qFuzzyCompare(d->elapsedTime, elapsedTime)) {
        d->elapsedTime = elapsedTime;
        Q_EMIT elapsedTimeChanged();
    }
}
 
QT_END_NAMESPACE
 
#include "moc_qquickframeanimation_p.cpp"