- The previously exported function qt_translateRawTouchEvent() has been removed.
Use QWindowSystemInterface::handleTouchEvent() instead.
+- QAbstractEventDispatcher
+
+ * The signature for the pure-virtual registerTimer() has changed. Subclasses
+ of QAbstractEventDispatcher will need to be updated to reimplement the new
+ pure-virtual 'virtual void registerTimer(int timerId, int interval,
+ Qt::TimerType timerType, QObject *object) = 0;'
+
+ * QAbstractEventDispatcher::TimerInfo is no longer a QPair<int, int>. It is
+ now a struct with 3 members: struct TimerInfo { int timerId; int interval;
+ Qt::TimerType timerType; }; Reimplementations of
+ QAbstractEventDispatcher::registeredTimers() will need to be updated to pass
+ 3 arguments to the TimerInfo constructor (instead of 2).
****************************************************************************
* General *
*/
/*!
+ \obsolete
+
\fn int QAbstractEventDispatcher::registerTimer(int interval, QObject *object)
- Registers a timer with the specified \a interval for the given \a object.
+ Registers a timer with the specified \a interval for the given \a object
+ and returns the timer id.
+*/
+
+/*!
+ \obsolete
+
+ \fn void QAbstractEventDispatcher::registerTimer(int timerId, int interval, QObject *object)
+
+ Register a timer with the specified \a timerId and \a interval for the
+ given \a object.
+*/
+
+/*!
+ Registers a timer with the specified \a interval and \a timerType for the
+ given \a object and returns the timer id.
*/
-int QAbstractEventDispatcher::registerTimer(int interval, QObject *object)
+int QAbstractEventDispatcher::registerTimer(int interval, Qt::TimerType timerType, QObject *object)
{
int id = QAbstractEventDispatcherPrivate::allocateTimerId();
- registerTimer(id, interval, object);
+ registerTimer(id, interval, timerType, object);
return id;
}
/*!
- \fn void QAbstractEventDispatcher::registerTimer(int timerId, int interval, QObject *object)
+ \fn void QAbstractEventDispatcher::registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *object)
- Register a timer with the specified \a timerId and \a interval for
- the given \a object.
+ Register a timer with the specified \a timerId, \a interval, and \a
+ timerType for the given \a object.
*/
/*!
/*!
\fn QList<TimerInfo> QAbstractEventDispatcher::registeredTimers(QObject *object) const
- Returns a list of registered timers for \a object. The timer ID
- is the first member in each pair; the interval is the second.
+ Returns a list of registered timers for \a object. The TimerInfo struct has
+ \c timerId, \c interval, and \c timerType members.
+
+ \sa Qt::TimerType
*/
/*! \fn void QAbstractEventDispatcher::wakeUp()
class QAbstractEventDispatcherPrivate;
class QSocketNotifier;
-template <typename T1, typename T2> struct QPair;
class Q_CORE_EXPORT QAbstractEventDispatcher : public QObject
{
Q_DECLARE_PRIVATE(QAbstractEventDispatcher)
public:
- typedef QPair<int, int> TimerInfo;
+ struct TimerInfo
+ {
+ int timerId;
+ int interval;
+ Qt::TimerType timerType;
+
+ inline TimerInfo(int id, int i, Qt::TimerType t)
+ : timerId(id), interval(i), timerType(t)
+ { }
+ };
explicit QAbstractEventDispatcher(QObject *parent = 0);
~QAbstractEventDispatcher();
virtual void registerSocketNotifier(QSocketNotifier *notifier) = 0;
virtual void unregisterSocketNotifier(QSocketNotifier *notifier) = 0;
- int registerTimer(int interval, QObject *object);
- virtual void registerTimer(int timerId, int interval, QObject *object) = 0;
+#if QT_DEPRECATED_SINCE(5,0)
+ QT_DEPRECATED inline int registerTimer(int interval, QObject *object)
+ { return registerTimer(interval, Qt::CoarseTimer, object); }
+ QT_DEPRECATED inline void registerTimer(int timerId, int interval, QObject *object)
+ { registerTimer(timerId, interval, Qt::CoarseTimer, object); }
+#endif
+ int registerTimer(int interval, Qt::TimerType timerType, QObject *object);
+ virtual void registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *object) = 0;
virtual bool unregisterTimer(int timerId) = 0;
virtual bool unregisterTimers(QObject *object) = 0;
virtual QList<TimerInfo> registeredTimers(QObject *object) const = 0;
}
}
-void QEventDispatcherGlib::registerTimer(int timerId, int interval, QObject *object)
+void QEventDispatcherGlib::registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *object)
{
#ifndef QT_NO_DEBUG
if (timerId < 1 || interval < 0 || !object) {
#endif
Q_D(QEventDispatcherGlib);
- d->timerSource->timerList.registerTimer(timerId, interval, object);
+ d->timerSource->timerList.registerTimer(timerId, interval, timerType, object);
}
bool QEventDispatcherGlib::unregisterTimer(int timerId)
void registerSocketNotifier(QSocketNotifier *socketNotifier);
void unregisterSocketNotifier(QSocketNotifier *socketNotifier);
- void registerTimer(int timerId, int interval, QObject *object);
+ void registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *object);
bool unregisterTimer(int timerId);
bool unregisterTimers(QObject *object);
QList<TimerInfo> registeredTimers(QObject *object) const;
/*!
\internal
*/
-void QEventDispatcherUNIX::registerTimer(int timerId, int interval, QObject *obj)
+void QEventDispatcherUNIX::registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *obj)
{
#ifndef QT_NO_DEBUG
if (timerId < 1 || interval < 0 || !obj) {
#endif
Q_D(QEventDispatcherUNIX);
- d->timerList.registerTimer(timerId, interval, obj);
+ d->timerList.registerTimer(timerId, interval, timerType, obj);
}
/*!
void registerSocketNotifier(QSocketNotifier *notifier);
void unregisterSocketNotifier(QSocketNotifier *notifier);
- void registerTimer(int timerId, int interval, QObject *object);
+ void registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *object);
bool unregisterTimer(int timerId);
bool unregisterTimers(QObject *object);
QList<TimerInfo> registeredTimers(QObject *object) const;
d->doWsaAsyncSelect(sockfd);
}
-void QEventDispatcherWin32::registerTimer(int timerId, int interval, QObject *object)
+void QEventDispatcherWin32::registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *object)
{
if (timerId < 1 || interval < 0 || !object) {
qWarning("QEventDispatcherWin32::registerTimer: invalid arguments");
t->dispatcher = this;
t->timerId = timerId;
t->interval = interval;
+ t->timerType = timerType;
t->obj = object;
t->inTimerEvent = false;
t->fastTimerId = 0;
for (int i = 0; i < d->timerVec.size(); ++i) {
const WinTimerInfo *t = d->timerVec.at(i);
if (t && t->obj == object)
- list << TimerInfo(t->timerId, t->interval);
+ list << TimerInfo(t->timerId, t->interval, t->timerType);
}
return list;
}
void registerSocketNotifier(QSocketNotifier *notifier);
void unregisterSocketNotifier(QSocketNotifier *notifier);
- void registerTimer(int timerId, int interval, QObject *object);
+ void registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *object);
bool unregisterTimer(int timerId);
bool unregisterTimers(QObject *object);
QList<TimerInfo> registeredTimers(QObject *object) const;
QObject *dispatcher;
int timerId;
int interval;
+ Qt::TimerType timerType;
QObject *obj; // - object to receive events
bool inTimerEvent;
int fastTimerId;
QThreadData *threadData = d->threadData;
QAbstractEventDispatcher *eventDispatcher = threadData->eventDispatcher;
if (eventDispatcher) {
- QList<QPair<int, int> > timers = eventDispatcher->registeredTimers(this);
+ QList<QAbstractEventDispatcher::TimerInfo> timers = eventDispatcher->registeredTimers(this);
if (!timers.isEmpty()) {
// set inThreadChangeEvent to true to tell the dispatcher not to release out timer ids
// back to the pool (since the timer ids are moving to a new thread).
eventDispatcher->unregisterTimers(this);
d->inThreadChangeEvent = false;
QMetaObject::invokeMethod(this, "_q_reregisterTimers", Qt::QueuedConnection,
- Q_ARG(void*, (new QList<QPair<int, int> >(timers))));
+ Q_ARG(void*, (new QList<QAbstractEventDispatcher::TimerInfo>(timers))));
}
}
break;
void QObjectPrivate::_q_reregisterTimers(void *pointer)
{
Q_Q(QObject);
- QList<QPair<int, int> > *timerList = reinterpret_cast<QList<QPair<int, int> > *>(pointer);
+ QList<QAbstractEventDispatcher::TimerInfo> *timerList = reinterpret_cast<QList<QAbstractEventDispatcher::TimerInfo> *>(pointer);
QAbstractEventDispatcher *eventDispatcher = threadData->eventDispatcher;
for (int i = 0; i < timerList->size(); ++i) {
- const QPair<int, int> &pair = timerList->at(i);
- eventDispatcher->registerTimer(pair.first, pair.second, q);
+ const QAbstractEventDispatcher::TimerInfo &ti = timerList->at(i);
+ eventDispatcher->registerTimer(ti.timerId, ti.interval, ti.timerType, q);
}
delete timerList;
}
qWarning("QObject::startTimer: QTimer can only be used with threads started with QThread");
return 0;
}
- return d->threadData->eventDispatcher->registerTimer(interval, this);
+ return d->threadData->eventDispatcher->registerTimer(interval, timerType, this);
}
/*!
return true;
}
-void QTimerInfoList::registerTimer(int timerId, int interval, QObject *object)
+void QTimerInfoList::registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *object)
{
QTimerInfo *t = new QTimerInfo;
t->id = timerId;
+ t->timerType = timerType;
t->interval.tv_sec = interval / 1000;
t->interval.tv_usec = (interval % 1000) * 1000;
t->timeout = updateCurrentTime() + t->interval;
return true;
}
-QList<QPair<int, int> > QTimerInfoList::registeredTimers(QObject *object) const
+QList<QAbstractEventDispatcher::TimerInfo> QTimerInfoList::registeredTimers(QObject *object) const
{
- QList<QPair<int, int> > list;
+ QList<QAbstractEventDispatcher::TimerInfo> list;
for (int i = 0; i < count(); ++i) {
register const QTimerInfo * const t = at(i);
if (t->obj == object)
- list << QPair<int, int>(t->id, t->interval.tv_sec * 1000 + t->interval.tv_usec / 1000);
+ list << QAbstractEventDispatcher::TimerInfo(t->id, t->interval.tv_sec * 1000 + t->interval.tv_usec / 1000, t->timerType);
}
return list;
}
// We mean it.
//
-#include <qobject.h>
-#include <qlist.h>
-#include <qpair.h>
+#include "qabstracteventdispatcher.h"
#include <sys/time.h> // struct timeval
// internal timer info
struct QTimerInfo {
int id; // - timer identifier
+ Qt::TimerType timerType; // - timer type
timeval interval; // - timer interval
timeval timeout; // - when to sent event
QObject *obj; // - object to receive event
void timerInsert(QTimerInfo *);
void timerRepair(const timeval &);
- void registerTimer(int timerId, int interval, QObject *object);
+ void registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *object);
bool unregisterTimer(int timerId);
bool unregisterTimers(QObject *object);
- QList<QPair<int, int> > registeredTimers(QObject *object) const;
+ QList<QAbstractEventDispatcher::TimerInfo> registeredTimers(QObject *object) const;
int activateTimers();
};
void registerSocketNotifier(QSocketNotifier *notifier);
void unregisterSocketNotifier(QSocketNotifier *notifier);
- void registerTimer(int timerId, int interval, QObject *object);
+ void registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *object);
bool unregisterTimer(int timerId);
bool unregisterTimers(QObject *object);
QList<TimerInfo> registeredTimers(QObject *object) const;
struct MacTimerInfo {
int id;
int interval;
+ Qt::TimerType timerType;
QObject *obj;
bool pending;
CFRunLoopTimerRef runLoopTimer;
}
-void QCocoaEventDispatcher::registerTimer(int timerId, int interval, QObject *obj)
+void QCocoaEventDispatcher::registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *obj)
{
#ifndef QT_NO_DEBUG
if (timerId < 1 || interval < 0 || !obj) {
MacTimerInfo *t = new MacTimerInfo();
t->id = timerId;
t->interval = interval;
+ t->timerType = timerType;
t->obj = obj;
t->runLoopTimer = 0;
t->pending = false;
while (it != QCocoaEventDispatcherPrivate::macTimerHash.constEnd()) {
MacTimerInfo *t = it.value();
if (t->obj == object)
- list << TimerInfo(t->id, t->interval);
+ list << TimerInfo(t->id, t->interval, t->timerType);
++it;
}
return list;
}
void registerSocketNotifier(QSocketNotifier *) {}
void unregisterSocketNotifier(QSocketNotifier *) {}
- void registerTimer(int , int , QObject *) {}
+ void registerTimer(int , int , Qt::TimerType, QObject *) {}
bool unregisterTimer(int ) { return false; }
bool unregisterTimers(QObject *) { return false; }
QList<TimerInfo> registeredTimers(QObject *) const { return QList<TimerInfo>(); }
}
void registerSocketNotifier(QSocketNotifier *) {}
void unregisterSocketNotifier(QSocketNotifier *) {}
- void registerTimer(int , int , QObject *) {}
+ void registerTimer(int, int, Qt::TimerType, QObject *) {}
bool unregisterTimer(int ) { return false; }
bool unregisterTimers(QObject *) { return false; }
QList<TimerInfo> registeredTimers(QObject *) const { return QList<TimerInfo>(); }
void interrupt() {}
bool processEvents(QEventLoop::ProcessEventsFlags) { return false; }
void registerSocketNotifier(QSocketNotifier*) {}
- int registerTimer(int,QObject*) { return -1; }
- void registerTimer(int,int,QObject*) {}
+ void registerTimer(int,int,Qt::TimerType,QObject*) {}
QList<TimerInfo> registeredTimers(QObject*) const { return QList<TimerInfo>(); }
void unregisterSocketNotifier(QSocketNotifier*) {}
bool unregisterTimer(int) { return false; }
void interrupt() {}
bool processEvents(QEventLoop::ProcessEventsFlags) { return false; }
void registerSocketNotifier(QSocketNotifier*) {}
- int registerTimer(int,QObject*) { return -1; }
- void registerTimer(int,int,QObject*) {}
+ void registerTimer(int,int,Qt::TimerType,QObject*) {}
QList<TimerInfo> registeredTimers(QObject*) const { return QList<TimerInfo>(); }
void unregisterSocketNotifier(QSocketNotifier*) {}
bool unregisterTimer(int) { return false; }