1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add QChronoTimer, a timer with nanoseconds precision

Browse Source 
The interval in QTimer is a QProperty of type int, which means it's
limited to the number of milliseconds that would fit in an int (~24
days), this could cause overflow if a user constructs a QTimer with an
interval > INT_MAX milliseconds. And it can't be easily changed to use
qint64/std::chrono::nanoseconds:
  - changing the getters to return qint64 means user code would have
    narrowing conversions
  - the bindable QProperty interval can't be changed to qint64 during
    Qt6's lifetime without the risk of breaking user code
  - adding a new bindable QProperty that is qint64/nanoseconds is an
    option, but it has the complication of what to do with the int
    interval; set it when setInterval(milliseconds) is used by using
    saturation arithmetic? and what about notifying observers of the
    changed interval?

Thus the idea of creating a new stop-gap class, QChronoTimer, as a
cleaner solution. Both classes use QTimerPrivate.

During the lifetime of Qt6, QTimer's interval range is about 24 days,
whereas QChronoTimer's interval range is about 292 years
(duration_cast<years>nanoseconds::max()).

Currently the plan is to fold QChronotTimer back into QTimer in Qt7.

Mark all QPropertyS in the new class as FINAL since they aren't
intended to be overridden; this offers a performance boost for QML[1].

[1] https://lists.qt-project.org/pipermail/development/2024-February/044977.html

[ChangeLog][QtCore] Added QChronoTimer, which uses a
std::chrono::nanoseconds intervals, as a replacement for QTimer.

Fixes: QTBUG-113544
Change-Id: I71697f4a8b35452c6b5604b1322ee7f0b4453f04
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
This commit is contained in:
Ahmad Samir 2023-07-11 16:32:39 +03:00
parent 4fa9034d0c
commit bd764cc1ca
13 changed files with 819 additions and 1251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/corelib/CMakeLists.txt
View File

@ -153,6 +153,7 @@ qt_internal_add_module(Core
kernel/qassociativeiterable.cpp kernel/qassociativeiterable.h kernel/qassociativeiterable.cpp kernel/qassociativeiterable.h
kernel/qbasictimer.cpp kernel/qbasictimer.h kernel/qbasictimer.cpp kernel/qbasictimer.h
kernel/qbindingstorage.h kernel/qbindingstorage.h
kernel/qchronotimer.cpp kernel/qchronotimer.h
kernel/qcoreapplication.cpp kernel/qcoreapplication.h kernel/qcoreapplication_p.h kernel/qcoreapplication.cpp kernel/qcoreapplication.h kernel/qcoreapplication_p.h
kernel/qcoreapplication_platform.h kernel/qcoreapplication_platform.h
kernel/qcorecmdlineargs_p.h kernel/qcorecmdlineargs_p.h

44
src/corelib/doc/snippets/timers/timers.cpp
View File

@ -1,8 +1,12 @@
// Copyright (C) 2016 The Qt Company Ltd. // Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
#include <QChronoTimer>
#include <QObject>
#include <QTimer> #include <QTimer>
using namespace std::chrono;
class Foo : public QObject class Foo : public QObject
{ {
public: public:
@ -35,7 +39,45 @@ Foo::Foo()
} }
} }
// QChronoTimer
class MyWidget : QObject
{
MyWidget()
{
//! [qchronotimer-singleshot]
MyWidget widget;
QChronoTimer::singleShot(100ms, &widget, &MyWidget::processOneThing);
//! [qchronotimer-singleshot]
//! [zero-timer]
// The default interval is 0ns
QChronoTimer *timer = new QChronoTimer(this);
connect(timer, &QChronoTimer::timeout, this, &MyWidget::processOneThing);
timer->start();
//! [zero-timer]
{
//! [timer-interval-in-ctor]
QChronoTimer *timer = new QChronoTimer(1s, this);
connect(timer, &QChronoTimer::timeout, this, &MyWidget::processOneThing);
timer->start();
//! [timer-interval-in-ctor]
}
{
//! [timer-setinterval]
QChronoTimer *timer = new QChronoTimer(this);
connect(timer, &QChronoTimer::timeout, this, &MyWidget::processOneThing);
timer->setInterval(1s);
timer->start();
//! [timer-setinterval]
}
}
public Q_SLOTS:
void processOneThing();
};
int main() int main()
{ {
} }

735
src/corelib/kernel/qchronotimer.cpp
View File

@ -2,7 +2,7 @@
// Copyright (C) 2016 Intel Corporation. // 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 // 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 "qchronotimer.h"
#include "qtimer_p.h" #include "qtimer_p.h"
#include "qsingleshottimer_p.h" #include "qsingleshottimer_p.h"
@ -20,123 +20,125 @@ using namespace std::chrono_literals;
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
/*! /*!
\class QTimer \class QChronoTimer
\inmodule QtCore \inmodule QtCore
\brief The QTimer class provides repetitive and single-shot timers. \since 6.8
\ingroup events \ingroup events
\brief The QChronoTimer class provides repetitive and single-shot timers.
The QTimer class provides a high-level programming interface for The QChronoTimer class provides a high-level programming interface for
timers. To use it, create a QTimer, connect its timeout() signal timers. To use it, create a QChronoTimer, either passing the interval to the
to the appropriate slots, and call start(). From then on, it will constructor, or setting it after construction using setInterval(), connect
emit the timeout() signal at constant intervals. its timeout() signal to the appropriate slots, and call start(). From then
on, it will emit the timeout() signal at constant intervals. For example:
Example for a one second (1000 millisecond) timer (from the \snippet timers/timers.cpp timer-interval-in-ctor
\l{widgets/analogclock}{Analog Clock} example): \snippet timers/timers.cpp timer-setinterval
\snippet ../widgets/widgets/analogclock/analogclock.cpp 4 You can set a timer to time out only once by calling setSingleShot(true).
\snippet ../widgets/widgets/analogclock/analogclock.cpp 5
\snippet ../widgets/widgets/analogclock/analogclock.cpp 6
From then on, the \c update() slot is called every second. QChronoTimer also has singleShot() static methods:
You can set a timer to time out only once by calling \snippet timers/timers.cpp qchronotimer-singleshot
setSingleShot(true). You can also use the static
QTimer::singleShot() function to call a slot after a specified
interval:
\snippet timers/timers.cpp 3 In multithreaded applications, you can use QChronoTimer in any thread
In multithreaded applications, you can use QTimer in any thread
that has an event loop. To start an event loop from a non-GUI that has an event loop. To start an event loop from a non-GUI
thread, use QThread::exec(). Qt uses the timer's thread, use QThread::exec(). Qt uses the timer's
\l{QObject::thread()}{thread affinity} to determine which thread \l{QObject::thread()}{thread affinity} to determine which thread
will emit the \l{QTimer::}{timeout()} signal. Because of this, you will emit the \l{QChronoTimer::}{timeout()} signal. Because of this, you
must start and stop the timer in its thread; it is not possible to must start and stop the timer in its thread; it is not possible to
start a timer from another thread. start a timer from another thread.
As a special case, a QTimer with a timeout of 0 will time out as soon as As a special case, a QChronoTimer with a timeout of \c 0ns will time out
possible, though the ordering between zero timers and other sources of as soon as possible, though the ordering between zero timers and other
events is unspecified. Zero timers can be used to do some work while still sources of events is unspecified. Zero timers can be used to do some
providing a snappy user interface: work while still providing a responsive user interface:
\snippet timers/timers.cpp 4 \snippet timers/timers.cpp zero-timer
\snippet timers/timers.cpp 5
\snippet timers/timers.cpp 6
From then on, \c processOneThing() will be called repeatedly. It From then on, \c processOneThing() will be called repeatedly. It should
should be written in such a way that it always returns quickly be written in such a way that it always returns quickly (for example,
(typically after processing one data item) so that Qt can deliver after processing one data item) so that Qt can deliver events to the user
events to the user interface and stop the timer as soon as it has done all interface and stop the timer as soon as it has done all its work. This
its work. This is the traditional way of implementing heavy work is the traditional way of implementing heavy work in GUI applications,
in GUI applications, but as multithreading is nowadays becoming available on but as multithreading is becoming available on more platforms, a modern
more and more platforms, we expect that zero-millisecond alternative is doing the heavy work in a thread other than the GUI (main)
QTimer objects will gradually be replaced by \l{QThread}s. thread. Qt has the QThread class, which can be used to achieve that.
\section1 Accuracy and Timer Resolution \section1 Accuracy and Timer Resolution
The accuracy of timers depends on the underlying operating system The accuracy of timers depends on the underlying operating system and
and hardware. Most platforms support a resolution of 1 millisecond, hardware. Most platforms support requesting nano-second precision for
though the accuracy of the timer will not equal this resolution timers (for example, libc's \c nanosleep), though the accuracy of the
in many real-world situations. timer will not equal this resolution in many real-world situations.
The accuracy also depends on the \l{Qt::TimerType}{timer type}. For You can set the \l{Qt::TimerType}{timer type} to tell QChronoTimer which
Qt::PreciseTimer, QTimer will try to keep the accuracy at 1 millisecond. precision to request from the system.
Precise timers will also never time out earlier than expected.
For Qt::CoarseTimer and Qt::VeryCoarseTimer types, QTimer may wake up For Qt::PreciseTimer, QChronoTimer will try to keep the precision at
earlier than expected, within the margins for those types: 5% of the \c 1ns. Precise timers will never time out earlier than expected.
interval for Qt::CoarseTimer and 500 ms for Qt::VeryCoarseTimer.
For Qt::CoarseTimer and Qt::VeryCoarseTimer types, QChronoTimer may wake
up earlier than expected, within the margins for those types:
\list
\li 5% of the interval for Qt::CoarseTimer
\li \c 500ms for Qt::VeryCoarseTimer
\endlist
All timer types may time out later than expected if the system is busy or All timer types may time out later than expected if the system is busy or
unable to provide the requested accuracy. In such a case of timeout unable to provide the requested accuracy. In such a case of timeout
overrun, Qt will emit timeout() only once, even if multiple timeouts have overrun, Qt will emit timeout() only once, even if multiple timeouts have
expired, and then will resume the original interval. expired, and then will resume the original interval.
\section1 Alternatives to QTimer \section1 Alternatives to QChronoTimer
An alternative to using QTimer is to call QObject::startTimer() An alternative to using QChronoTimer is to call QObject::startTimer()
for your object and reimplement the QObject::timerEvent() event for your object and reimplement the QObject::timerEvent() event handler
handler in your class (which must inherit QObject). The in your class (which must be a sub-class of QObject). The disadvantage
disadvantage is that timerEvent() does not support such is that timerEvent() does not support such high-level features as
high-level features as single-shot timers or signals. single-shot timers or signals.
Another alternative is QBasicTimer. It is typically less Another alternative is QBasicTimer. It is typically less cumbersome
cumbersome than using QObject::startTimer() than using QObject::startTimer() directly. See \l{Timers} for an
directly. See \l{Timers} for an overview of all three approaches. overview of all three approaches.
Some operating systems limit the number of timers that may be Some operating systems limit the number of timers that may be used;
used; Qt tries to work around these limitations. Qt does its best to work around these limitations.
\sa QBasicTimer, QTimerEvent, QObject::timerEvent(), Timers, \sa QBasicTimer, QTimerEvent, QObject::timerEvent(), Timers,
{Analog Clock} {Analog Clock}
*/ */
/*! /*!
Constructs a timer with the given \a parent. Constructs a timer with the given \a parent, using the default interval,
\c 0ns.
*/ */
QChronoTimer::QChronoTimer(QObject *parent)
QTimer::QTimer(QObject *parent) : QChronoTimer(0ns, parent)
: QObject(*new QTimerPrivate(this), parent)
{ {
Q_ASSERT(d_func()->isQTimer);
} }
/*!
Constructs a timer with the given \a parent, using an interval of \a nsec.
*/
QChronoTimer::QChronoTimer(std::chrono::nanoseconds nsec, QObject *parent)
: QObject(*new QTimerPrivate(nsec, this), parent)
{
Q_ASSERT(!d_func()->isQTimer);
}
/*! /*!
Destroys the timer. Destroys the timer.
*/ */
QChronoTimer::~QChronoTimer()
QTimer::~QTimer()
{ {
if (d_func()->id != QTimerPrivate::INV_TIMER) // stop running timer if (d_func()->id != QTimerPrivate::INV_TIMER) // stop running timer
stop(); stop();
} }
/*! /*!
\fn void QTimer::timeout() \fn void QChronoTimer::timeout()
This signal is emitted when the timer times out. This signal is emitted when the timer times out.
@ -144,109 +146,64 @@ QTimer::~QTimer()
*/ */
/*! /*!
\property QTimer::active \property QChronoTimer::active
\since 4.3
This boolean property is \c true if the timer is running; otherwise This boolean property is \c true if the timer is running; otherwise
false. \c false.
*/ */
/*! /*!
\fn bool QTimer::isActive() const
Returns \c true if the timer is running (pending); otherwise returns Returns \c true if the timer is running (pending); otherwise returns
false. false.
*/ */
bool QTimer::isActive() const bool QChronoTimer::isActive() const
{ {
return d_func()->isActiveData.value(); return d_func()->isActiveData.value();
} }
QBindable<bool> QTimer::bindableActive() QBindable<bool> QChronoTimer::bindableActive()
{ {
return QBindable<bool>(&d_func()->isActiveData); return QBindable<bool>(&d_func()->isActiveData);
} }
/*! /*!
\fn int QTimer::timerId() const
Returns the ID of the timer if the timer is running; otherwise returns Returns the ID of the timer if the timer is running; otherwise returns
-1. -1.
*/ */
int QTimer::timerId() const int QChronoTimer::id() const
{ {
return d_func()->id; return d_func()->id;
} }
/*! \overload start() /*! \overload start()
Starts or restarts the timer with the timeout specified in \l interval. Starts or restarts the timer with the timeout specified in \l interval.
If the timer is already running, it will be If the timer is already running, it will be
\l{QTimer::stop()}{stopped} and restarted. \l{QChronoTimer::stop()}{stopped} and restarted.
If \l singleShot is true, the timer will be activated only once. If \l singleShot is true, the timer will be activated only once.
*/ */
void QTimer::start() void QChronoTimer::start()
{ {
Q_D(QTimer); auto *d = d_func();
if (d->id != QTimerPrivate::INV_TIMER) // stop running timer if (d->id != QTimerPrivate::INV_TIMER) // stop running timer
stop(); stop();
const int id = QObject::startTimer(std::chrono::milliseconds{d->inter}, d->type); const auto id = QObject::startTimer(d->intervalDuration, d->type);
if (id > 0) { if (id > 0) {
d->id = id; d->id = id;
d->isActiveData.notify(); d->isActiveData.notify();
} }
} }
/*!
Starts or restarts the timer with a timeout interval of \a msec
milliseconds.
If the timer is already running, it will be
\l{QTimer::stop()}{stopped} and restarted.
If \l singleShot is true, the timer will be activated only once. This is
equivalent to:
\code
timer.setInterval(msec);
timer.start();
\endcode
\note Keeping the event loop busy with a zero-timer is bound to
cause trouble and highly erratic behavior of the UI.
*/
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();
}
/*! /*!
Stops the timer. Stops the timer.
\sa start() \sa start()
*/ */
void QChronoTimer::stop()
void QTimer::stop()
{ {
Q_D(QTimer); auto *d = d_func();
if (d->id != QTimerPrivate::INV_TIMER) { if (d->id != QTimerPrivate::INV_TIMER) {
QObject::killTimer(d->id); QObject::killTimer(d->id);
d->id = QTimerPrivate::INV_TIMER; d->id = QTimerPrivate::INV_TIMER;
@ -254,36 +211,208 @@ void QTimer::stop()
} }
} }
/*! /*!
\reimp \reimp
*/ */
void QTimer::timerEvent(QTimerEvent *e) void QChronoTimer::timerEvent(QTimerEvent *e)
{ {
Q_D(QTimer); auto *d = d_func();
if (e->timerId() == d->id) { if (e->timerId() == d->id) {
if (d->single) if (d->single)
stop(); stop();
emit timeout(QPrivateSignal()); Q_EMIT timeout(QPrivateSignal());
}
}
/*!
\fn template <typename Functor> QMetaObject::Connection QChronoTimer::callOnTimeout(const QObject *context, Functor &&slot, Qt::ConnectionType connectionType = Qt::AutoConnection)
\overload callOnTimeout()
Creates a connection from the timeout() signal to \a slot to be placed in a
specific event loop of \a context, with connection type \a connectionType,
and returns a handle to the connection.
This method is provided as a convenience. It's equivalent to calling:
\code
QObject::connect(timer, &QChronoTimer::timeout, context, slot, connectionType);
\endcode
\sa QObject::connect(), timeout()
*/
/*!
\property QChronoTimer::singleShot
\brief Whether the timer is a single-shot timer
A single-shot timer fires only once, non-single-shot timers fire every
\l interval.
The default value for this property is \c false.
\sa interval, singleShot()
*/
void QChronoTimer::setSingleShot(bool singleShot)
{
d_func()->single = singleShot;
}
bool QChronoTimer::isSingleShot() const
{
return d_func()->single;
}
QBindable<bool> QChronoTimer::bindableSingleShot()
{
return QBindable<bool>(&d_func()->single);
}
/*!
\property QChronoTimer::interval
\brief The timeout interval
The default value for this property is \c 0ns.
A QChronoTimer with a timeout of \c 0ns will time out as soon as all
the events in the window system's event queue have been processed.
Setting the interval of an active timer changes the interval and acquires
a new id(). If the timer is not active, only the interval is changed.
\sa singleShot
*/
void QChronoTimer::setInterval(std::chrono::nanoseconds nsec)
{
auto *d = d_func();
d->intervalDuration.removeBindingUnlessInWrapper();
const bool intervalChanged = nsec != d->intervalDuration.valueBypassingBindings();
d->intervalDuration.setValueBypassingBindings(nsec);
if (d->id != QTimerPrivate::INV_TIMER) { // Create new timer
QObject::killTimer(d->id); // Restart timer
const auto id = QObject::startTimer(nsec, d->type);
if (id > 0) {
// Restarted successfully. No need to update the active state.
d->id = id;
} else {
// Failed to start the timer.
// Need to notify about active state change.
d->id = QTimerPrivate::INV_TIMER;
d->isActiveData.notify();
}
}
if (intervalChanged)
d->intervalDuration.notify();
}
std::chrono::nanoseconds QChronoTimer::interval() const
{
return d_func()->intervalDuration.value();
}
QBindable<std::chrono::nanoseconds> QChronoTimer::bindableInterval()
{
return {&d_func()->intervalDuration};
}
/*!
\property QChronoTimer::remainingTime
\brief The remaining time
Returns the remaining duration until the timeout.
If the timer is inactive, the returned duration will be negative.
If the timer is overdue, the returned duration will be \c 0ns.
\sa interval
*/
std::chrono::nanoseconds QChronoTimer::remainingTime() const
{
if (isActive())
return QAbstractEventDispatcher::instance()->remainingTime(d_func()->id) * 1ms;
return std::chrono::nanoseconds::min();
}
/*!
\property QChronoTimer::timerType
\brief Controls the accuracy of the timer
The default value for this property is \c Qt::CoarseTimer.
\sa Qt::TimerType
*/
void QChronoTimer::setTimerType(Qt::TimerType atype)
{
d_func()->type = atype;
}
Qt::TimerType QChronoTimer::timerType() const
{
return d_func()->type;
}
QBindable<Qt::TimerType> QChronoTimer::bindableTimerType()
{
return {&d_func()->type};
}
/*!
\overload
\reentrant
This static function calls the slot \a member, on object \a receiver, after
time interval \a interval. \a timerType affects the precision of the timer
\a member has to be a member function of \a receiver; you need to use the
\c SLOT() macro to get this parameter.
This function is provided as a convenience to save the need to use a
\l{QObject::timerEvent()}{timerEvent} or create a local QTimer object.
\sa start(), Qt::TimerType
*/
void QChronoTimer::singleShot(std::chrono::nanoseconds interval, Qt::TimerType timerType,
const QObject *receiver, const char *member)
{
if (Q_UNLIKELY(interval < 0ns)) {
qWarning("QChronoTimer::singleShot: Timers cannot have negative timeouts");
return;
}
if (receiver && member) {
if (interval == 0ns) {
// special code shortpath for 0-timers
const char* bracketPosition = strchr(member, '(');
if (!bracketPosition || !(member[0] >= '0' && member[0] <= '2')) {
qWarning("QChronoTimer::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(interval, timerType, receiver, member);
} }
} }
/*! /*!
\internal \internal
Implementation of the template version of singleShot \list
\li \a interval the time interval
\a msec is the timer interval \li \a timerType the type of the timer; this affects the precision of
\a timerType is the timer type the timer
\a receiver is the receiver object, can be null. In such a case, it will be the same \li \a receiver the receiver or context object; if this is \c nullptr,
as the final sender class. this method will figure out a context object to use, see code
\a slotObj the slot object comments below
\li \a slotObj a callable, for example a lambda
\endlist
*/ */
void QTimer::singleShotImpl(std::chrono::milliseconds msec, Qt::TimerType timerType, void QChronoTimer::singleShotImpl(std::chrono::nanoseconds interval, Qt::TimerType timerType,
const QObject *receiver, const QObject *receiver, QtPrivate::QSlotObjectBase *slotObj)
QtPrivate::QSlotObjectBase *slotObj)
{ {
if (msec == 0ms) { if (interval == 0ns) {
bool deleteReceiver = false; bool deleteReceiver = false;
// Optimize: set a receiver context when none is given, such that we can use // 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. // QMetaObject::invokeMethod which is more efficient than going through a timer.
@ -312,335 +441,9 @@ void QTimer::singleShotImpl(std::chrono::milliseconds msec, Qt::TimerType timerT
return; return;
} }
new QSingleShotTimer(msec, timerType, receiver, slotObj); new QSingleShotTimer(interval, timerType, receiver, slotObj);
}
/*!
\fn void QTimer::singleShot(int msec, const QObject *receiver, const char *member)
\reentrant
\deprecated [6.8] Use the chrono overloads.
This static function calls a slot after a given time interval.
It is very convenient to use this function because you do not need
to bother with a \l{QObject::timerEvent()}{timerEvent} or
create a local QTimer object.
Example:
\snippet code/src_corelib_kernel_qtimer.cpp 0
This sample program automatically terminates after 10 minutes
(600,000 milliseconds).
The \a receiver is the receiving object and the \a member is the
slot. The time interval is \a msec milliseconds.
\sa start()
*/
/*!
\fn void QTimer::singleShot(int msec, Qt::TimerType timerType, const QObject *receiver, const char *member)
\overload
\reentrant
\deprecated [6.8] Use the chrono overloads.
This static function calls a slot after a given time interval.
It is very convenient to use this function because you do not need
to bother with a \l{QObject::timerEvent()}{timerEvent} or
create a local QTimer object.
The \a receiver is the receiving object and the \a member is the slot. The
time interval is \a msec milliseconds. The \a timerType affects the
accuracy of the timer.
\sa start()
*/
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(msec, timerType, receiver, member);
}
}
/*! \fn template<typename Duration, typename Functor> void QTimer::singleShot(Duration msec, const QObject *context, Functor &&functor)
\fn template<typename Duration, typename Functor> void QTimer::singleShot(Duration msec, Qt::TimerType timerType, const QObject *context, Functor &&functor)
\fn template<typename Duration, typename Functor> void QTimer::singleShot(Duration msec, Functor &&functor)
\fn template<typename Duration, typename Functor> void QTimer::singleShot(Duration msec, Qt::TimerType timerType, Functor &&functor)
\since 5.4
\reentrant
This static function calls \a functor after \a msec milliseconds.
It is very convenient to use this function because you do not need
to bother with a \l{QObject::timerEvent()}{timerEvent} or
create a local QTimer object.
If \a context is specified, then the \a functor will be called only if the
\a context object has not been destroyed before the interval occurs. The functor
will then be run the thread of \a context. The context's thread must have a
running Qt event loop.
If \a functor is a member
function of \a context, then the function will be called on the object.
The \a msec parameter can be an \c int or a \c std::chrono::milliseconds value.
\sa start()
*/
/*!
\fn void QTimer::singleShot(std::chrono::milliseconds msec, const QObject *receiver, const char *member)
\since 5.8
\overload
\reentrant
This static function calls a slot after a given time interval.
It is very convenient to use this function because you do not need
to bother with a \l{QObject::timerEvent()}{timerEvent} or
create a local QTimer object.
The \a receiver is the receiving object and the \a member is the slot. The
time interval is given in the duration object \a msec.
\sa start()
*/
/*!
\fn void QTimer::singleShot(std::chrono::milliseconds msec, Qt::TimerType timerType, const QObject *receiver, const char *member)
\since 5.8
\overload
\reentrant
This static function calls a slot after a given time interval.
It is very convenient to use this function because you do not need
to bother with a \l{QObject::timerEvent()}{timerEvent} or
create a local QTimer object.
The \a receiver is the receiving object and the \a member is the slot. The
time interval is given in the duration object \a msec. The \a timerType affects the
accuracy of the timer.
\sa start()
*/
/*!
\fn template <typename Functor> QMetaObject::Connection QTimer::callOnTimeout(Functor &&slot)
\since 5.12
Creates a connection from the timer's timeout() signal to \a slot.
Returns a handle to the connection.
This method is provided for convenience. It's equivalent to calling:
\code
QObject::connect(timer, &QTimer::timeout, timer, slot, Qt::DirectConnection);
\endcode
\note This overload is not available when \c {QT_NO_CONTEXTLESS_CONNECT} is
defined, instead use the callOnTimeout() overload that takes a context object.
\sa QObject::connect(), timeout()
*/
/*!
\fn template <typename Functor> QMetaObject::Connection QTimer::callOnTimeout(const QObject *context, Functor &&slot, Qt::ConnectionType connectionType = Qt::AutoConnection)
\since 5.12
\overload callOnTimeout()
Creates a connection from the timeout() signal to \a slot to be placed in a specific
event loop of \a context, and returns a handle to the connection.
This method is provided for convenience. It's equivalent to calling:
\code
QObject::connect(timer, &QTimer::timeout, context, slot, connectionType);
\endcode
\sa QObject::connect(), timeout()
*/
/*!
\fn void QTimer::start(std::chrono::milliseconds msec)
\since 5.8
\overload
Starts or restarts the timer with a timeout of duration \a msec milliseconds.
If the timer is already running, it will be
\l{QTimer::stop()}{stopped} and restarted.
If \l singleShot is true, the timer will be activated only once. This is
equivalent to:
\code
timer.setInterval(msec);
timer.start();
\endcode
*/
/*!
\fn std::chrono::milliseconds QTimer::intervalAsDuration() const
\since 5.8
Returns the interval of this timer as a \c std::chrono::milliseconds object.
\sa interval
*/
/*!
\fn std::chrono::milliseconds QTimer::remainingTimeAsDuration() const
\since 5.8
Returns the time remaining in this timer object as a \c
std::chrono::milliseconds object. If this timer is due or overdue, the
returned value is \c std::chrono::milliseconds::zero(). If the remaining
time could not be found or the timer is not active, this function returns a
negative duration.
\sa remainingTime()
*/
/*!
\property QTimer::singleShot
\brief whether the timer is a single-shot timer
A single-shot timer fires only once, non-single-shot timers fire
every \l interval milliseconds.
The default value for this property is \c false.
\sa interval, singleShot()
*/
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);
}
/*!
\property QTimer::interval
\brief the timeout interval in milliseconds
The default value for this property is 0. A QTimer with a timeout
interval of 0 will time out as soon as all the events in the window
system's event queue have been processed.
Setting the interval of an active timer changes its timerId().
\sa singleShot
*/
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->id != QTimerPrivate::INV_TIMER) { // create new timer
QObject::killTimer(d->id); // restart timer
const int id = QObject::startTimer(std::chrono::milliseconds{msec}, d->type);
if (id > 0) {
// Restarted successfully. No need to update the active state.
d->id = id;
} else {
// Failed to start the timer.
// Need to notify about active state change.
d->id = QTimerPrivate::INV_TIMER;
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);
}
/*!
\property QTimer::remainingTime
\since 5.0
\brief the remaining time in milliseconds
Returns the timer's remaining value in milliseconds left until the timeout.
If the timer is inactive, the returned value will be -1. If the timer is
overdue, the returned value will be 0.
\sa interval
*/
int QTimer::remainingTime() const
{
Q_D(const QTimer);
if (d->id != QTimerPrivate::INV_TIMER) {
return QAbstractEventDispatcher::instance()->remainingTime(d->id);
}
return -1;
}
/*!
\property QTimer::timerType
\brief controls the accuracy of the timer
The default value for this property is \c Qt::CoarseTimer.
\sa Qt::TimerType
*/
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 QT_END_NAMESPACE
#include "moc_qtimer.cpp" #include "moc_qchronotimer.cpp"

178
src/corelib/kernel/qchronotimer.h
View File

@ -1,42 +1,50 @@
// Copyright (C) 2016 The Qt Company Ltd. // 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 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#ifndef QTIMER_H #ifndef QCHRONOTIMER_H
#define QTIMER_H #define QCHRONOTIMER_H
#include <QtCore/qglobal.h>
#ifndef QT_NO_QOBJECT #ifndef QT_NO_QOBJECT
#include <QtCore/qbasictimer.h> // conceptual inheritance #include <QtCore/qcoreevent.h>
#include <QtCore/qnamespace.h>
#include <QtCore/qobject.h> #include <QtCore/qobject.h>
#include <QtCore/qproperty.h>
#include <chrono> #include <chrono>
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
class QTimerPrivate; class QTimerPrivate;
class Q_CORE_EXPORT QTimer : public QObject class Q_CORE_EXPORT QChronoTimer : public QObject
{ {
Q_OBJECT Q_OBJECT
Q_PROPERTY(bool singleShot READ isSingleShot WRITE setSingleShot BINDABLE bindableSingleShot) Q_PROPERTY(bool singleShot READ isSingleShot WRITE setSingleShot
Q_PROPERTY(int interval READ interval WRITE setInterval BINDABLE bindableInterval) BINDABLE bindableSingleShot FINAL)
Q_PROPERTY(int remainingTime READ remainingTime) Q_PROPERTY(std::chrono::nanoseconds interval READ interval WRITE setInterval
Q_PROPERTY(Qt::TimerType timerType READ timerType WRITE setTimerType BINDABLE bindableTimerType) BINDABLE bindableInterval FINAL)
Q_PROPERTY(bool active READ isActive STORED false BINDABLE bindableActive) Q_PROPERTY(std::chrono::nanoseconds remainingTime READ remainingTime FINAL)
Q_PROPERTY(Qt::TimerType timerType READ timerType WRITE setTimerType
BINDABLE bindableTimerType FINAL)
Q_PROPERTY(bool active READ isActive STORED false BINDABLE bindableActive FINAL)
template <typename Functor>
using FunctorContext = typename QtPrivate::ContextTypeForFunctor<Functor>::ContextType;
public: public:
explicit QTimer(QObject *parent = nullptr); explicit QChronoTimer(std::chrono::nanoseconds nsec, QObject *parent = nullptr);
~QTimer(); explicit QChronoTimer(QObject *parent = nullptr);
~QChronoTimer() override;
bool isActive() const; bool isActive() const;
QBindable<bool> bindableActive(); QBindable<bool> bindableActive();
int timerId() const; int id() const;
void setInterval(int msec); void setInterval(std::chrono::nanoseconds nsec);
int interval() const; std::chrono::nanoseconds interval() const;
QBindable<int> bindableInterval(); QBindable<std::chrono::nanoseconds> bindableInterval();
int remainingTime() const; std::chrono::nanoseconds remainingTime() const;
void setTimerType(Qt::TimerType atype); void setTimerType(Qt::TimerType atype);
Qt::TimerType timerType() const; Qt::TimerType timerType() const;
@ -46,142 +54,96 @@ public:
bool isSingleShot() const; bool isSingleShot() const;
QBindable<bool> bindableSingleShot(); QBindable<bool> bindableSingleShot();
QT_CORE_INLINE_SINCE(6, 8)
static void singleShot(int msec, const QObject *receiver, const char *member);
QT_CORE_INLINE_SINCE(6, 8)
static void singleShot(int msec, Qt::TimerType timerType, const QObject *receiver, const char *member);
// singleShot with context // singleShot with context
#ifdef Q_QDOC #ifdef Q_QDOC
template <typename Duration, typename Functor> template <typename Functor>
static inline void singleShot(Duration interval, const QObject *receiver, Functor &&slot); static inline void singleShot(std::chrono::nanoseconds interval,
template <typename Duration, typename Functor> const QObject *receiver, Functor &&slot);
static inline void singleShot(Duration interval, Qt::TimerType timerType, template <typename Functor>
static inline void singleShot(std::chrono::nanoseconds interval interval,
Qt::TimerType timerType,
const QObject *receiver, Functor &&slot); const QObject *receiver, Functor &&slot);
#else #else
template <typename Duration, typename Functor> template <typename Functor>
static inline void singleShot(Duration interval, static void singleShot(std::chrono::nanoseconds interval,
const typename QtPrivate::ContextTypeForFunctor<Functor>::ContextType *receiver, const FunctorContext<Functor> *receiver, Functor &&slot)
Functor &&slot)
{ {
singleShot(interval, defaultTypeFor(interval), receiver, std::forward<Functor>(slot)); singleShot(interval, defaultTimerTypeFor(interval), receiver, std::forward<Functor>(slot));
} }
template <typename Duration, typename Functor> template <typename Functor>
static inline void singleShot(Duration interval, Qt::TimerType timerType, static void singleShot(std::chrono::nanoseconds interval, Qt::TimerType timerType,
const typename QtPrivate::ContextTypeForFunctor<Functor>::ContextType *receiver, const FunctorContext<Functor> *receiver, Functor &&slot)
Functor &&slot)
{ {
using Prototype = void(*)(); using Prototype = void(*)();
singleShotImpl(interval, timerType, receiver, auto *slotObj = QtPrivate::makeCallableObject<Prototype>(std::forward<Functor>(slot));
QtPrivate::makeCallableObject<Prototype>(std::forward<Functor>(slot))); singleShotImpl(interval, timerType, receiver, slotObj);
} }
#endif #endif
// singleShot without context template <typename Functor>
template <typename Duration, typename Functor> static void singleShot(std::chrono::nanoseconds interval, Qt::TimerType timerType,
static inline void singleShot(Duration interval, Functor &&slot) Functor &&slot)
{ singleShot(interval, timerType, nullptr, std::forward<Functor>(slot)); }
template <typename Functor>
static void singleShot(std::chrono::nanoseconds interval, Functor &&slot)
{ {
singleShot(interval, defaultTypeFor(interval), nullptr, std::forward<Functor>(slot)); singleShot(interval, defaultTimerTypeFor(interval), nullptr, std::forward<Functor>(slot));
}
template <typename Duration, typename Functor>
static inline void singleShot(Duration interval, Qt::TimerType timerType, Functor &&slot)
{
singleShot(interval, timerType, nullptr, std::forward<Functor>(slot));
} }
static void singleShot(std::chrono::nanoseconds interval, Qt::TimerType timerType,
const QObject *receiver, const char *member);
static void singleShot(std::chrono::nanoseconds interval, const QObject *receiver,
const char *member)
{ singleShot(interval, defaultTimerTypeFor(interval), receiver, member); }
#ifdef Q_QDOC #ifdef Q_QDOC
template <typename Functor> template <typename Functor>
QMetaObject::Connection callOnTimeout(Functor &&slot); QMetaObject::Connection callOnTimeout(const QObject *context, Functor &&slot,
template <typename Functor> Qt::ConnectionType connectionType = Qt::AutoConnection);
QMetaObject::Connection callOnTimeout(const QObject *context, Functor &&slot, Qt::ConnectionType connectionType = Qt::AutoConnection);
#else #else
template <typename ... Args> template <typename ... Args>
QMetaObject::Connection callOnTimeout(Args && ...args) QMetaObject::Connection callOnTimeout(Args && ...args)
{ {
return QObject::connect(this, &QTimer::timeout, std::forward<Args>(args)... ); return QObject::connect(this, &QChronoTimer::timeout, std::forward<Args>(args)... );
} }
#endif #endif
public Q_SLOTS: public Q_SLOTS:
void start(int msec);
void start(); void start();
void stop(); void stop();
Q_SIGNALS: Q_SIGNALS:
void timeout(QPrivateSignal); void timeout(QPrivateSignal);
public:
void setInterval(std::chrono::milliseconds value);
std::chrono::milliseconds intervalAsDuration() const
{
return std::chrono::milliseconds(interval());
}
std::chrono::milliseconds remainingTimeAsDuration() const
{
return std::chrono::milliseconds(remainingTime());
}
static void singleShot(std::chrono::milliseconds value, const QObject *receiver, const char *member)
{
singleShot(value, defaultTypeFor(value), receiver, member);
}
static void singleShot(std::chrono::milliseconds interval, Qt::TimerType timerType,
const QObject *receiver, const char *member);
void start(std::chrono::milliseconds value);
protected: protected:
void timerEvent(QTimerEvent *) override; void timerEvent(QTimerEvent *) override;
private: private:
Q_DISABLE_COPY(QTimer) Q_DISABLE_COPY(QChronoTimer)
Q_DECLARE_PRIVATE(QTimer)
inline int startTimer(int){ return -1;} // QChronoTimer uses QTimerPrivate
inline void killTimer(int){} inline QTimerPrivate *d_func() noexcept
{ Q_CAST_IGNORE_ALIGN(return reinterpret_cast<QTimerPrivate *>(qGetPtrHelper(d_ptr));) }
inline const QTimerPrivate *d_func() const noexcept
{ Q_CAST_IGNORE_ALIGN(return reinterpret_cast<const QTimerPrivate *>(qGetPtrHelper(d_ptr));) }
static constexpr Qt::TimerType defaultTypeFor(int msecs) noexcept // These two functions are inherited from QObject
{ return defaultTypeFor(std::chrono::milliseconds{msecs}); } int startTimer(std::chrono::nanoseconds) = delete;
void killTimer(int) = delete;
static constexpr Qt::TimerType defaultTypeFor(std::chrono::milliseconds interval) noexcept static constexpr Qt::TimerType defaultTimerTypeFor(std::chrono::nanoseconds interval) noexcept
{ {
// coarse timers are worst in their first firing
// so we prefer a high precision timer for something that happens only once
// unless the timeout is too big, in which case we go for coarse anyway
using namespace std::chrono_literals; using namespace std::chrono_literals;
return interval >= 2s ? Qt::CoarseTimer : Qt::PreciseTimer; return interval >= 2s ? Qt::CoarseTimer : Qt::PreciseTimer;
} }
QT_CORE_INLINE_SINCE(6, 8) static void singleShotImpl(std::chrono::nanoseconds interval, Qt::TimerType timerType,
static void singleShotImpl(int msec, Qt::TimerType timerType,
const QObject *receiver, QtPrivate::QSlotObjectBase *slotObj);
static void singleShotImpl(std::chrono::milliseconds interval, Qt::TimerType timerType,
const QObject *receiver, QtPrivate::QSlotObjectBase *slotObj); const QObject *receiver, QtPrivate::QSlotObjectBase *slotObj);
}; };
#if QT_CORE_INLINE_IMPL_SINCE(6, 8)
void QTimer::singleShot(int msec, const QObject *receiver, const char *member)
{ singleShot(std::chrono::milliseconds{msec}, receiver, member); }
void QTimer::singleShot(int msec, Qt::TimerType timerType, const QObject *receiver,
const char *member)
{ singleShot(std::chrono::milliseconds{msec}, timerType, receiver, member); }
void QTimer::singleShotImpl(int msec, Qt::TimerType timerType,
const QObject *receiver, QtPrivate::QSlotObjectBase *slotObj)
{
singleShotImpl(std::chrono::milliseconds{msec}, timerType, receiver, slotObj);
}
#endif
QT_END_NAMESPACE QT_END_NAMESPACE
#endif // QT_NO_QOBJECT #endif // QT_NO_QOBJECT
#endif // QTIMER_H #endif // QCHRONOTIMER_H

1
src/corelib/kernel/qobjectdefs.h
View File

@ -639,6 +639,7 @@ private:
const void **parameters, const char **typeNames, const void **parameters, const char **typeNames,
const QtPrivate::QMetaTypeInterface **metaTypes); const QtPrivate::QMetaTypeInterface **metaTypes);
friend class QTimer; friend class QTimer;
friend class QChronoTimer;
}; };
class Q_CORE_EXPORT QMetaObject::Connection { class Q_CORE_EXPORT QMetaObject::Connection {

3
src/corelib/kernel/qtimer.cpp
View File

@ -118,8 +118,9 @@ QT_BEGIN_NAMESPACE
*/ */
QTimer::QTimer(QObject *parent) QTimer::QTimer(QObject *parent)
: QObject(*new QTimerPrivate, parent) : QObject(*new QTimerPrivate(this), parent)
{ {
Q_ASSERT(d_func()->isQTimer);
} }

38
src/corelib/kernel/qtimer_p.h
View File

@ -15,24 +15,58 @@
#include "qobject_p.h" #include "qobject_p.h"
#include "qproperty_p.h" #include "qproperty_p.h"
#include "qtimer.h" #include "qtimer.h"
#include "qchronotimer.h"
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
class QTimerPrivate : public QObjectPrivate class QTimerPrivate : public QObjectPrivate
{ {
Q_DECLARE_PUBLIC(QTimer)
public: public:
QTimerPrivate(QTimer *qq)
: q(qq),
isQTimer(true)
{}
QTimerPrivate(std::chrono::nanoseconds nsec, QChronoTimer *qq)
: intervalDuration(nsec),
q(qq)
{
intervalDuration.notify();
}
static constexpr int INV_TIMER = -1; // invalid timer id static constexpr int INV_TIMER = -1; // invalid timer id
void setInterval(int msec) { q_func()->setInterval(msec); } void setIntervalDuration(std::chrono::nanoseconds nsec)
{
if (isQTimer) {
const auto msec = std::chrono::duration_cast<std::chrono::milliseconds>(nsec);
static_cast<QTimer *>(q)->setInterval(msec);
} else {
static_cast<QChronoTimer *>(q)->setInterval(nsec);
}
}
void setInterval(int msec)
{
Q_ASSERT(isQTimer);
static_cast<QTimer *>(q)->setInterval(msec);
}
bool isActiveActualCalculation() const { return id > 0; } bool isActiveActualCalculation() const { return id > 0; }
int id = INV_TIMER; int id = INV_TIMER;
Q_OBJECT_COMPAT_PROPERTY_WITH_ARGS(QTimerPrivate, int, inter, &QTimerPrivate::setInterval, 0) Q_OBJECT_COMPAT_PROPERTY_WITH_ARGS(QTimerPrivate, int, inter, &QTimerPrivate::setInterval, 0)
Q_OBJECT_COMPAT_PROPERTY_WITH_ARGS(QTimerPrivate, std::chrono::nanoseconds, intervalDuration,
&QTimerPrivate::setIntervalDuration,
std::chrono::nanoseconds{0})
Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(QTimerPrivate, bool, single, false) Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(QTimerPrivate, bool, single, false)
Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(QTimerPrivate, Qt::TimerType, type, Qt::CoarseTimer) Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(QTimerPrivate, Qt::TimerType, type, Qt::CoarseTimer)
Q_OBJECT_COMPUTED_PROPERTY(QTimerPrivate, bool, isActiveData, Q_OBJECT_COMPUTED_PROPERTY(QTimerPrivate, bool, isActiveData,
&QTimerPrivate::isActiveActualCalculation) &QTimerPrivate::isActiveActualCalculation)
QObject *q;
// true if q is a QTimer*, false otherwise
const bool isQTimer = false;
}; };
QT_END_NAMESPACE QT_END_NAMESPACE

1
tests/auto/corelib/kernel/CMakeLists.txt
View File

@ -2,6 +2,7 @@
# SPDX-License-Identifier: BSD-3-Clause # SPDX-License-Identifier: BSD-3-Clause
add_subdirectory(qapplicationstatic) add_subdirectory(qapplicationstatic)
add_subdirectory(qchronotimer)
add_subdirectory(qcoreapplication) add_subdirectory(qcoreapplication)
add_subdirectory(qdeadlinetimer) add_subdirectory(qdeadlinetimer)
add_subdirectory(qelapsedtimer) add_subdirectory(qelapsedtimer)

2
tests/auto/corelib/kernel/qchronotimer/.gitignore vendored
View File

@ -1 +1 @@
tst_qtimer tst_qchronotimer

15
tests/auto/corelib/kernel/qchronotimer/CMakeLists.txt
View File

@ -3,7 +3,7 @@
if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT)
cmake_minimum_required(VERSION 3.16) cmake_minimum_required(VERSION 3.16)
project(tst_qtimer LANGUAGES CXX) project(tst_qchronotimer LANGUAGES CXX)
find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST)
endif() endif()
@ -11,24 +11,23 @@ if (NOT QT_FEATURE_thread)
return() return()
endif() endif()
function(addTimerTest test) function(addChronoTimerTest test)
qt_internal_add_test(${test} qt_internal_add_test(${test}
SOURCES SOURCES
tst_qtimer.cpp tst_qchronotimer.cpp
LIBRARIES LIBRARIES
Qt::CorePrivate Qt::CorePrivate
Qt::TestPrivate Qt::TestPrivate
) )
endfunction() endfunction()
addTimerTest(tst_qtimer) addChronoTimerTest(tst_qchronotimer)
if(QT_FEATURE_glib AND UNIX) if(QT_FEATURE_glib AND UNIX)
addTimerTest(tst_qtimer_no_glib) addChronoTimerTest(tst_qchronotimer_no_glib)
qt_internal_extend_target(tst_qtimer_no_glib qt_internal_extend_target(tst_qchronotimer_no_glib
DEFINES DEFINES
DISABLE_GLIB DISABLE_GLIB
tst_QTimer=tst_QTimer_no_glib # Class name in the unittest tst_QChronoTimer=tst_QChronoTimer_no_glib # Class name in the unittest
) )
endif() endif()

1031
tests/auto/corelib/kernel/qchronotimer/tst_qchronotimer.cpp
View File

File diff suppressed because it is too large Load Diff

1
tests/auto/gui/kernel/CMakeLists.txt
View File

@ -10,6 +10,7 @@ add_subdirectory(qcursor)
add_subdirectory(qdrag) add_subdirectory(qdrag)
add_subdirectory(qevent) add_subdirectory(qevent)
add_subdirectory(qfileopenevent) add_subdirectory(qfileopenevent)
add_subdirectory(qguichronotimer)
add_subdirectory(qguieventdispatcher) add_subdirectory(qguieventdispatcher)
add_subdirectory(qguitimer) add_subdirectory(qguitimer)
if(NOT ANDROID AND NOT WASM) if(NOT ANDROID AND NOT WASM)

20
tests/auto/gui/kernel/qguichronotimer/CMakeLists.txt
View File

@ -2,19 +2,19 @@
# SPDX-License-Identifier: BSD-3-Clause # SPDX-License-Identifier: BSD-3-Clause
##################################################################### #####################################################################
## tst_qguitimer Test: ## tst_qguichronotimer Test:
##################################################################### #####################################################################
if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT)
cmake_minimum_required(VERSION 3.16) cmake_minimum_required(VERSION 3.16)
project(tst_qguitimer LANGUAGES CXX) project(tst_qguichronotimer LANGUAGES CXX)
find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST)
endif() endif()
function(addGuiTimerTest test) function(addGuiChronoTimerTest test)
qt_internal_add_test(${test} qt_internal_add_test(${test}
SOURCES SOURCES
../../../corelib/kernel/qtimer/tst_qtimer.cpp ../../../corelib/kernel/qchronotimer/tst_qchronotimer.cpp
LIBRARIES LIBRARIES
Qt::CorePrivate Qt::CorePrivate
Qt::Gui Qt::Gui
@ -22,17 +22,17 @@ function(addGuiTimerTest test)
) )
endfunction() endfunction()
addGuiTimerTest(tst_qguitimer) addGuiChronoTimerTest(tst_qguichronotimer)
qt_internal_extend_target(tst_qguitimer qt_internal_extend_target(tst_qguichronotimer
DEFINES DEFINES
tst_Qtimer=tst_QGuiTimer tst_Qtimer=tst_QGuiChronoTimer
) )
if(QT_FEATURE_glib AND UNIX) if(QT_FEATURE_glib AND UNIX)
addGuiTimerTest(tst_qguitimer_no_glib) addGuiChronoTimerTest(tst_qguichronotimer_no_glib)
qt_internal_extend_target(tst_qguitimer_no_glib qt_internal_extend_target(tst_qguichronotimer_no_glib
DEFINES DEFINES
DISABLE_GLIB DISABLE_GLIB
tst_QTimer=tst_QGuiTimer_no_glib # Class name in the unittest tst_QTimer=tst_QGuiChronoTimer_no_glib # Class name in the unittest
) )
endif() endif()