qqmltimer.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 "qqmltimer_p.h"
 
#include <QtCore/qcoreapplication.h>
#include "private/qpauseanimationjob_p.h"
#include <qdebug.h>
 
#include <private/qobject_p.h>
 
QT_BEGIN_NAMESPACE
 
namespace {
    const QEvent::Type QEvent_MaybeTick = QEvent::Type(QEvent::User + 1);
    const QEvent::Type QEvent_Triggered = QEvent::Type(QEvent::User + 2);
}
 
class QQmlTimerPrivate : public QObjectPrivate, public QAnimationJobChangeListener
{
    Q_DECLARE_PUBLIC(QQmlTimer)
public:
    QQmlTimerPrivate()
        : running(false), repeating(false), triggeredOnStart(false)
        , classBegun(false), componentComplete(false), firstTick(true), awaitingTick(false) {}
 
    void animationFinished(QAbstractAnimationJob *) override;
    void animationCurrentLoopChanged(QAbstractAnimationJob *) override { maybeTick(); }
 
    void maybeTick() {
        Q_Q(QQmlTimer);
        if (!awaitingTick) {
            awaitingTick = true;
            QCoreApplication::postEvent(q, new QEvent(QEvent_MaybeTick));
        }
    }
 
    int interval = 1000;
    QPauseAnimationJob pause;
    bool running : 1;
    bool repeating : 1;
    bool triggeredOnStart : 1;
    bool classBegun : 1;
    bool componentComplete : 1;
    bool firstTick : 1;
    bool awaitingTick : 1;
};
 
QQmlTimer::QQmlTimer(QObject *parent)
    : QObject(*(new QQmlTimerPrivate), parent)
{
    Q_D(QQmlTimer);
    d->pause.addAnimationChangeListener(d, QAbstractAnimationJob::Completion | QAbstractAnimationJob::CurrentLoop);
    d->pause.setLoopCount(1);
    d->pause.setDuration(d->interval);
}
 
void QQmlTimer::setInterval(int interval)
{
    Q_D(QQmlTimer);
    if (interval != d->interval) {
        d->interval = interval;
        update();
        emit intervalChanged();
    }
}
 
int QQmlTimer::interval() const
{
    Q_D(const QQmlTimer);
    return d->interval;
}
 
bool QQmlTimer::isRunning() const
{
    Q_D(const QQmlTimer);
    return d->running;
}
 
void QQmlTimer::setRunning(bool running)
{
    Q_D(QQmlTimer);
    if (d->running != running) {
        d->running = running;
        d->firstTick = true;
        emit runningChanged();
        update();
    }
}
 
bool QQmlTimer::isRepeating() const
{
    Q_D(const QQmlTimer);
    return d->repeating;
}
 
void QQmlTimer::setRepeating(bool repeating)
{
    Q_D(QQmlTimer);
    if (repeating != d->repeating) {
        d->repeating = repeating;
        update();
        emit repeatChanged();
    }
}
 
bool QQmlTimer::triggeredOnStart() const
{
    Q_D(const QQmlTimer);
    return d->triggeredOnStart;
}
 
void QQmlTimer::setTriggeredOnStart(bool triggeredOnStart)
{
    Q_D(QQmlTimer);
    if (d->triggeredOnStart != triggeredOnStart) {
        d->triggeredOnStart = triggeredOnStart;
        update();
        emit triggeredOnStartChanged();
    }
}
 
void QQmlTimer::start()
{
    setRunning(true);
}
 
void QQmlTimer::stop()
{
    setRunning(false);
}
 
void QQmlTimer::restart()
{
    setRunning(false);
    setRunning(true);
}
 
void QQmlTimer::update()
{
    Q_D(QQmlTimer);
    if (d->classBegun && !d->componentComplete)
        return;
    d->pause.stop();
    if (d->running) {
        d->pause.setCurrentTime(0);
        d->pause.setLoopCount(d->repeating ? -1 : 1);
        d->pause.setDuration(d->interval);
        d->pause.start();
        if (d->triggeredOnStart && d->firstTick)
            d->maybeTick();
    }
}
 
void QQmlTimer::classBegin()
{
    Q_D(QQmlTimer);
    d->classBegun = true;
}
 
void QQmlTimer::componentComplete()
{
    Q_D(QQmlTimer);
    d->componentComplete = true;
    update();
}
 
void QQmlTimer::ticked()
{
    Q_D(QQmlTimer);
    if (d->running && (d->pause.currentTime() > 0 || (d->triggeredOnStart && d->firstTick)))
        emit triggered();
    d->firstTick = false;
}
 
bool QQmlTimer::event(QEvent *e)
{
    Q_D(QQmlTimer);
    if (e->type() == QEvent_MaybeTick) {
        d->awaitingTick = false;
        ticked();
        return true;
    } else if (e->type() == QEvent_Triggered) {
        if (d->running && d->pause.isStopped()) {
            d->running = false;
            emit triggered();
            emit runningChanged();
        }
        return true;
    }
    return QObject::event(e);
}
 
void QQmlTimerPrivate::animationFinished(QAbstractAnimationJob *)
{
    Q_Q(QQmlTimer);
    if (repeating || !running)
        return;
    firstTick = false;
    QCoreApplication::postEvent(q, new QEvent(QEvent_Triggered));
}
 
QT_END_NAMESPACE
 
#include "moc_qqmltimer_p.cpp"