1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
// Copyright (C) 2020 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 "qbasictimer.h"
#include "qabstracteventdispatcher.h"
#include "qabstracteventdispatcher_p.h"
QT_BEGIN_NAMESPACE
/*!
\class QBasicTimer
\inmodule QtCore
\brief The QBasicTimer class provides timer events for objects.
\ingroup events
This is a fast, lightweight, and low-level class used by Qt
internally. We recommend using the higher-level QTimer class
rather than this class if you want to use timers in your
applications. Note that this timer is a repeating timer that
will send subsequent timer events unless the stop() function is called.
To use this class, create a QBasicTimer, and call its start()
function with a timeout interval and with a pointer to a QObject
subclass. When the timer times out it will send a timer event to
the QObject subclass. The timer can be stopped at any time using
stop(). isActive() returns \c true for a timer that is running;
i.e. it has been started, has not reached the timeout time, and
has not been stopped. The timer's ID can be retrieved using
timerId().
Objects of this class cannot be copied, but can be moved, so you
can maintain a list of basic timers by holding them in container
that supports move-only types, e.g. std::vector.
The \l{widgets/wiggly}{Wiggly} example uses QBasicTimer to repaint
a widget at regular intervals.
\sa QTimer, QTimerEvent, QObject::timerEvent(), Timers, {Wiggly Example}
*/
/*!
\fn QBasicTimer::QBasicTimer()
Constructs a basic timer.
\sa start()
*/
/*!
\fn QBasicTimer::QBasicTimer(QBasicTimer &&other)
\since 5.14
Move-constructs a basic timer from \a other, which is left
\l{isActive()}{inactive}.
\sa isActive(), swap()
*/
/*!
\fn QBasicTimer &QBasicTimer::operator=(QBasicTimer &&other)
\since 5.14
Move-assigns \a other to this basic timer. The timer
previously represented by this basic timer is stopped.
\a other is left as \l{isActive()}{inactive}.
\sa stop(), isActive(), swap()
*/
/*!
\fn QBasicTimer::~QBasicTimer()
Destroys the basic timer.
*/
/*!
\fn bool QBasicTimer::isActive() const
Returns \c true if the timer is running and has not been stopped; otherwise
returns \c false.
\sa start(), stop()
*/
/*!
\fn QBasicTimer::swap(QBasicTimer &other)
\fn swap(QBasicTimer &lhs, QBasicTimer &rhs)
\since 5.14
Swaps string \a other with this string, or \a lhs with \a rhs.
This operation is very fast and never fails.
*/
/*!
\fn int QBasicTimer::timerId() const
Returns the timer's ID.
\sa QTimerEvent::timerId()
*/
/*!
\fn void QBasicTimer::start(int msec, QObject *object)
Starts (or restarts) the timer with a \a msec milliseconds timeout. The
timer will be a Qt::CoarseTimer. See Qt::TimerType for information on the
different timer types.
The given \a object will receive timer events.
\sa stop(), isActive(), QObject::timerEvent(), Qt::CoarseTimer
*/
void QBasicTimer::start(int msec, QObject *obj)
{
start(msec, Qt::CoarseTimer, obj);
}
/*!
\overload
Starts (or restarts) the timer with a \a msec milliseconds timeout and the
given \a timerType. See Qt::TimerType for information on the different
timer types.
\a obj will receive timer events.
\sa stop(), isActive(), QObject::timerEvent(), Qt::TimerType
*/
void QBasicTimer::start(int msec, Qt::TimerType timerType, QObject *obj)
{
QAbstractEventDispatcher *eventDispatcher = QAbstractEventDispatcher::instance();
if (Q_UNLIKELY(msec < 0)) {
qWarning("QBasicTimer::start: Timers cannot have negative timeouts");
return;
}
if (Q_UNLIKELY(!eventDispatcher)) {
qWarning("QBasicTimer::start: QBasicTimer can only be used with threads started with QThread");
return;
}
if (Q_UNLIKELY(obj && obj->thread() != eventDispatcher->thread())) {
qWarning("QBasicTimer::start: Timers cannot be started from another thread");
return;
}
stop();
if (obj)
id = eventDispatcher->registerTimer(msec, timerType, obj);
}
/*!
Stops the timer.
\sa start(), isActive()
*/
void QBasicTimer::stop()
{
if (id) {
QAbstractEventDispatcher *eventDispatcher = QAbstractEventDispatcher::instance();
if (eventDispatcher && !eventDispatcher->unregisterTimer(id)) {
qWarning("QBasicTimer::stop: Failed. Possibly trying to stop from a different thread");
return;
}
QAbstractEventDispatcherPrivate::releaseTimerId(id);
}
id = 0;
}
QT_END_NAMESPACE
|
