qtimer.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qtimer.h"
#include "qtimer_p.h"
#include "qsingleshottimer_p.h"
 
#include "qabstracteventdispatcher.h"
#include "qcoreapplication.h"
#include "qcoreapplication_p.h"
#include "qdeadlinetimer.h"
#include "qmetaobject_p.h"
#include "qobject_p.h"
#include "qproperty_p.h"
#include "qthread.h"
 
using namespace std::chrono_literals;
 
QT_BEGIN_NAMESPACE
 
QTimer::QTimer(QObject *parent)
    : QObject(*new QTimerPrivate(this), parent)
{
    Q_ASSERT(d_func()->isQTimer);
}
 
 
QTimer::~QTimer()
{
    if (d_func()->isActive()) // stop running timer
        stop();
}
 
 
bool QTimer::isActive() const
{
    return d_func()->isActiveData.value();
}
 
QBindable<bool> QTimer::bindableActive()
{
    return QBindable<bool>(&d_func()->isActiveData);
}
 
int QTimer::timerId() const
{
    auto v = qToUnderlying(id());
    return v == 0 ? -1 : v;
}
 
Qt::TimerId QTimer::id() const
{
    return d_func()->id;
}
 
void QTimer::start()
{
    Q_D(QTimer);
    if (d->isActive()) // stop running timer
        stop();
 
    Qt::TimerId newId{ QObject::startTimer(d->inter * 1ms, d->type) }; // overflow impossible
    if (newId > Qt::TimerId::Invalid) {
        d->id = newId;
        d->isActiveData.notify();
    }
}
 
void QTimer::start(int msec)
{
    start(msec * 1ms);
}
 
void QTimer::start(std::chrono::milliseconds interval)
{
    Q_D(QTimer);
    // This could be narrowing as the interval is stored in an `int` QProperty,
    // and the type can't be changed in Qt6.
    const int msec = interval.count();
    const bool intervalChanged = msec != d->inter;
    d->inter.setValue(msec);
    start();
    if (intervalChanged)
        d->inter.notify();
}
 
 
 
void QTimer::stop()
{
    Q_D(QTimer);
    if (d->isActive()) {
        QObject::killTimer(d->id);
        d->id = Qt::TimerId::Invalid;
        d->isActiveData.notify();
    }
}
 
 
void QTimer::timerEvent(QTimerEvent *e)
{
    Q_D(QTimer);
    if (Qt::TimerId{e->timerId()} == d->id) {
        if (d->single)
            stop();
        emit timeout(QPrivateSignal());
    }
}
 
void QTimer::singleShotImpl(std::chrono::milliseconds msec, Qt::TimerType timerType,
                            const QObject *receiver,
                            QtPrivate::QSlotObjectBase *slotObj)
{
    if (msec == 0ms) {
        bool deleteReceiver = false;
        // Optimize: set a receiver context when none is given, such that we can use
        // QMetaObject::invokeMethod which is more efficient than going through a timer.
        // We need a QObject living in the current thread. But the QThread itself lives
        // in a different thread - with the exception of the main QThread which lives in
        // itself. And QThread::currentThread() is among the few QObjects we know that will
        // most certainly be there. Note that one can actually call singleShot before the
        // QApplication is created!
        if (!receiver && QThread::currentThread() == QCoreApplicationPrivate::mainThread()) {
            // reuse main thread as context object
            receiver = QThread::currentThread();
        } else if (!receiver) {
            // Create a receiver context object on-demand. According to the benchmarks,
            // this is still more efficient than going through a timer.
            receiver = new QObject;
            deleteReceiver = true;
        }
 
        auto h = QtPrivate::invokeMethodHelper({});
        QMetaObject::invokeMethodImpl(const_cast<QObject *>(receiver), slotObj,
                Qt::QueuedConnection, h.parameterCount(), h.parameters.data(), h.typeNames.data(),
                h.metaTypes.data());
 
        if (deleteReceiver)
            const_cast<QObject *>(receiver)->deleteLater();
        return;
    }
 
    new QSingleShotTimer(QSingleShotTimer::fromMsecs(msec), timerType, receiver, slotObj);
}
 
void QTimer::singleShot(std::chrono::milliseconds msec, Qt::TimerType timerType,
                        const QObject *receiver, const char *member)
{
    if (Q_UNLIKELY(msec < 0ms)) {
        qWarning("QTimer::singleShot: Timers cannot have negative timeouts");
        return;
    }
    if (receiver && member) {
        if (msec == 0ms) {
            // special code shortpath for 0-timers
            const char* bracketPosition = strchr(member, '(');
            if (!bracketPosition || !(member[0] >= '0' && member[0] <= '2')) {
                qWarning("QTimer::singleShot: Invalid slot specification");
                return;
            }
            const auto methodName = QByteArrayView(member + 1, // extract method name
                                                   bracketPosition - 1 - member).trimmed();
            QMetaObject::invokeMethod(const_cast<QObject *>(receiver), methodName.toByteArray().constData(),
                                      Qt::QueuedConnection);
            return;
        }
        (void) new QSingleShotTimer(QSingleShotTimer::fromMsecs(msec), timerType, receiver, member);
    }
}
 
void QTimer::setSingleShot(bool singleShot)
{
    d_func()->single = singleShot;
}
 
bool QTimer::isSingleShot() const
{
    return d_func()->single;
}
 
QBindable<bool> QTimer::bindableSingleShot()
{
    return QBindable<bool>(&d_func()->single);
}
 
void QTimer::setInterval(int msec)
{
    setInterval(std::chrono::milliseconds{msec});
}
 
void QTimer::setInterval(std::chrono::milliseconds interval)
{
    Q_D(QTimer);
    // This could be narrowing as the interval is stored in an `int` QProperty,
    // and the type can't be changed in Qt6.
    const int msec = interval.count();
    d->inter.removeBindingUnlessInWrapper();
    const bool intervalChanged = msec != d->inter.valueBypassingBindings();
    d->inter.setValueBypassingBindings(msec);
    if (d->isActive()) { // create new timer
        QObject::killTimer(d->id);                        // restart timer
        Qt::TimerId newId{ QObject::startTimer(msec * 1ms, d->type) };  // overflow impossible
        if (newId > Qt::TimerId::Invalid) {
            // Restarted successfully. No need to update the active state.
            d->id = newId;
        } else {
            // Failed to start the timer.
            // Need to notify about active state change.
            d->id = Qt::TimerId::Invalid;
            d->isActiveData.notify();
        }
    }
    if (intervalChanged)
        d->inter.notify();
}
 
int QTimer::interval() const
{
    return d_func()->inter;
}
 
QBindable<int> QTimer::bindableInterval()
{
    return QBindable<int>(&d_func()->inter);
}
 
int QTimer::remainingTime() const
{
    Q_D(const QTimer);
    if (d->isActive()) {
        using namespace std::chrono;
        auto remaining = QAbstractEventDispatcher::instance()->remainingTime(d->id);
        return ceil<milliseconds>(remaining).count();
    }
 
    return -1;
}
 
void QTimer::setTimerType(Qt::TimerType atype)
{
    d_func()->type = atype;
}
 
Qt::TimerType QTimer::timerType() const
{
    return d_func()->type;
}
 
QBindable<Qt::TimerType> QTimer::bindableTimerType()
{
    return QBindable<Qt::TimerType>(&d_func()->type);
}
 
QT_END_NAMESPACE
 
#include "moc_qtimer.cpp"