Mention QChronoTimer in API docs

Change-Id: Iaf9fb31994f1580b2051dbd0b1b8eef2a218aa39
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

9 files changed, 46 insertions, 33 deletions

diff --git a/src/corelib/kernel/qbasictimer.cpp b/src/corelib/kernel/qbasictimer.cpp
index 2aea3269a0..e7626f7426 100644
--- a/src/corelib/kernel/qbasictimer.cpp
+++ b/src/corelib/kernel/qbasictimer.cpp
@@ -33,7 +33,8 @@ QT_BEGIN_NAMESPACE
     can maintain a list of basic timers by holding them in container
     that supports move-only types, e.g. std::vector.
 
-    \sa QTimer, QTimerEvent, QObject::timerEvent(), Timers, {Affine Transformations}
+    \sa QTimer, QChronoTimer, QTimerEvent, QObject::timerEvent(),
+    Timers, {Affine Transformations}
 */
 
 
diff --git a/src/corelib/kernel/qchronotimer.cpp b/src/corelib/kernel/qchronotimer.cpp
index ac799203d3..4da7538278 100644
--- a/src/corelib/kernel/qchronotimer.cpp
+++ b/src/corelib/kernel/qchronotimer.cpp
@@ -368,7 +368,8 @@ QBindable<Qt::TimerType> QChronoTimer::bindableTimerType()
     \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.
+    \l{QObject::timerEvent()}{timerEvent} or create a local QChronoTimer
+    object.
 
     \sa start(), Qt::TimerType
 */
diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index 5be217b5fd..6fe4d75acd 100644
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@@ -1364,7 +1364,8 @@ bool QCoreApplication::closingDown()
 
     \threadsafe
 
-    \sa exec(), QTimer, QEventLoop::processEvents(), sendPostedEvents()
+    \sa exec(), QTimer, QChronoTimer, QEventLoop::processEvents(),
+    sendPostedEvents()
 */
 void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags)
 {
@@ -1413,7 +1414,7 @@ void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, int m
 
     \threadsafe
 
-    \sa exec(), QTimer, QEventLoop::processEvents()
+    \sa exec(), QTimer, QChronoTimer, QEventLoop::processEvents()
 */
 void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, QDeadlineTimer deadline)
 {
@@ -1443,10 +1444,10 @@ void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, QDead
     main event loop receives events from the window system and
     dispatches these to the application widgets.
 
-    To make your application perform idle processing (by executing a
-    special function whenever there are no pending events), use a
-    QTimer with 0 timeout. More advanced idle processing schemes can
-    be achieved using processEvents().
+    To make your application perform idle processing (by executing a special
+    function whenever there are no pending events), use a QChronoTimer
+    with 0ns timeout. More advanced idle processing schemes can be achieved
+    using processEvents().
 
     We recommend that you connect clean-up code to the
     \l{QCoreApplication::}{aboutToQuit()} signal, instead of putting it in
diff --git a/src/corelib/kernel/qcoreevent.cpp b/src/corelib/kernel/qcoreevent.cpp
index b4b6ca3c37..9c99530268 100644
--- a/src/corelib/kernel/qcoreevent.cpp
+++ b/src/corelib/kernel/qcoreevent.cpp
@@ -519,12 +519,12 @@ int QEvent::registerEventType(int hint) noexcept
     started one or more timers. Each timer has a unique identifier. A
     timer is started with QObject::startTimer().
 
-    The QTimer class provides a high-level programming interface that
+    The QChronoTimer class provides a high-level programming interface that
     uses signals instead of events. It also provides single-shot timers.
 
     The event handler QObject::timerEvent() receives timer events.
 
-    \sa QTimer, QObject::timerEvent(), QObject::startTimer(),
+    \sa QChronoTimer, QObject::timerEvent(), QObject::startTimer(),
     QObject::killTimer()
 */
 
diff --git a/src/corelib/kernel/qdeadlinetimer.cpp b/src/corelib/kernel/qdeadlinetimer.cpp
index f2f182274a..5d07aede61 100644
--- a/src/corelib/kernel/qdeadlinetimer.cpp
+++ b/src/corelib/kernel/qdeadlinetimer.cpp
@@ -84,11 +84,12 @@ static qint64 add_saturate(qint64 t1, Duration1 dur, Durations... extra)
 
     \section1 Timer types
 
-    Like QTimer, QDeadlineTimer can select among different levels of coarseness
-    on the timers. You can select precise timing by passing Qt::PreciseTimer to
-    the functions that set of change the timer, or you can select coarse timing
-    by passing Qt::CoarseTimer. Qt::VeryCoarseTimer is currently interpreted
-    the same way as Qt::CoarseTimer.
+    Like QTimer and QChronoTimer, QDeadlineTimer can select among
+    different levels of coarseness on the timers. You can select
+    precise timing by passing Qt::PreciseTimer to the functions that
+    set of change the timer, or you can select coarse timing by passing
+    Qt::CoarseTimer. Qt::VeryCoarseTimer is currently interpreted the same
+    way as Qt::CoarseTimer.
 
     This feature is dependent on support from the operating system: if the OS
     does not support a coarse timer functionality, then QDeadlineTimer will
@@ -120,7 +121,7 @@ static qint64 add_saturate(qint64 t1, Duration1 dur, Durations... extra)
 
     \snippet code/src_corelib_kernel_qdeadlinetimer.cpp 2
 
-    \sa QTime, QTimer, QDeadlineTimer, Qt::TimerType
+    \sa QTime, QChronoTimer, QDeadlineTimer, Qt::TimerType
 */
 
 /*!
diff --git a/src/corelib/kernel/qelapsedtimer.cpp b/src/corelib/kernel/qelapsedtimer.cpp
index fd5e090541..511b81a04e 100644
--- a/src/corelib/kernel/qelapsedtimer.cpp
+++ b/src/corelib/kernel/qelapsedtimer.cpp
@@ -75,7 +75,7 @@ QT_BEGIN_NAMESPACE
     that the clock used is the same as QElapsedTimer (see
     QElapsedTimer::clockType()).
 
-    \sa QTime, QTimer, QDeadlineTimer
+    \sa QTime, QChronoTimer, QDeadlineTimer
 */
 
 /*!
diff --git a/src/corelib/kernel/qeventloop.cpp b/src/corelib/kernel/qeventloop.cpp
index a921f54fac..d318069ca0 100644
--- a/src/corelib/kernel/qeventloop.cpp
+++ b/src/corelib/kernel/qeventloop.cpp
@@ -116,10 +116,10 @@ bool QEventLoop::processEvents(ProcessEventsFlags flags)
     can be used before calling exec(), because modal widgets
     use their own local event loop.
 
-    To make your application perform idle processing (i.e. executing a
-    special function whenever there are no pending events), use a
-    QTimer with 0 timeout. More sophisticated idle processing schemes
-    can be achieved using processEvents().
+    To make your application perform idle processing (i.e. executing a special
+    function whenever there are no pending events), use a QChronoTimer with
+    0ns timeout. More sophisticated idle processing schemes can be achieved
+    using processEvents().
 
     \sa QCoreApplication::quit(), exit(), processEvents()
 */
diff --git a/src/corelib/kernel/qobject.cpp b/src/corelib/kernel/qobject.cpp
index 4fea4d0d3a..b00827dfa2 100644
--- a/src/corelib/kernel/qobject.cpp
+++ b/src/corelib/kernel/qobject.cpp
@@ -810,7 +810,7 @@ QMetaCallEvent* QMetaCallEvent::create_impl(QtPrivate::SlotObjUniquePtr slotObj,
     to catch child events.
 
     Last but not least, QObject provides the basic timer support in
-    Qt; see QTimer for high-level support for timers.
+    Qt; see QChronoTimer for high-level support for timers.
 
     Notice that the Q_OBJECT macro is mandatory for any object that
     implements signals, slots or properties. You also need to run the
@@ -1488,9 +1488,9 @@ bool QObject::event(QEvent *e)
     This event handler can be reimplemented in a subclass to receive
     timer events for the object.
 
-    QTimer provides a higher-level interface to the timer
-    functionality, and also more general information about timers. The
-    timer event is passed in the \a event parameter.
+    QChronoTimer provides higher-level interfaces to the timer functionality,
+    and also more general information about timers. The timer event is passed
+    in the \a event parameter.
 
     \sa startTimer(), killTimer(), event()
 */
@@ -1839,7 +1839,7 @@ void QObjectPrivate::setThreadData_helper(QThreadData *currentData, QThreadData
     startTimer(std::chrono::milliseconds{interval}, timerType);
     \endcode
 
-    \sa timerEvent(), killTimer(), QTimer::singleShot()
+    \sa timerEvent(), killTimer(), QChronoTimer::singleShot()
 */
 
 int QObject::startTimer(int interval, Qt::TimerType timerType)
@@ -1870,19 +1870,21 @@ int QObject::startTimer(int interval, Qt::TimerType timerType)
 
     \snippet code/src_corelib_kernel_qobject.cpp 8
 
-    Note that QTimer's accuracy depends on the underlying operating system and
-    hardware. The \a timerType argument allows you to customize the accuracy of
+    Note that the accuracy of QChronoTimer depends on the underlying operating
+    system and hardware.
+
+    The \a timerType argument allows you to customize the accuracy of
     the timer. See Qt::TimerType for information on the different timer types.
     Most platforms support an accuracy of 20 milliseconds; some provide more.
     If Qt is unable to deliver the requested number of timer events, it will
     silently discard some.
 
-    The QTimer class provides a high-level programming interface with
-    single-shot timers and timer signals instead of events. There is
-    also a QBasicTimer class that is more lightweight than QTimer and
-    less clumsy than using timer IDs directly.
+    The QTimer and QChronoTimer classes provide a high-level programming
+    interface with single-shot timers and timer signals instead of
+    events. There is also a QBasicTimer class that is more lightweight than
+    QChronoTimer but less clumsy than using timer IDs directly.
 
-    \sa timerEvent(), killTimer(), QTimer::singleShot()
+    \sa timerEvent(), killTimer(), QChronoTimer::singleShot()
 
     \note Starting from Qt 6.8 the type of \a interval
     is \c std::chrono::nanoseconds, prior to that it was \c
diff --git a/src/corelib/kernel/qtimer.cpp b/src/corelib/kernel/qtimer.cpp
index 5784d023ff..3291c7d24b 100644
--- a/src/corelib/kernel/qtimer.cpp
+++ b/src/corelib/kernel/qtimer.cpp
@@ -74,6 +74,13 @@ QT_BEGIN_NAMESPACE
     more and more platforms, we expect that zero-millisecond
     QTimer objects will gradually be replaced by \l{QThread}s.
 
+    \note Since Qt 6.7 this class is superseded by \l{QChronoTimer}.
+    The maximum interval QTimer supports is limited by the number of
+    milliseconds that would fit in an \c int (which is around 24 days);
+    whereas QChronoTimer stores its interval as \c std::chrono::nanoseconds
+    (which raises that limit to around 292 million years), that is, there is
+    less chance of integer overflow with QChronoTimer.
+
     \section1 Accuracy and Timer Resolution
 
     The accuracy of timers depends on the underlying operating system