Changeset 84 for trunk/src

Timestamp:

Jul 26, 2009, 1:19:03 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

corelib: Implemented timers (#24).

Location:

trunk/src/corelib/kernel

Files:

• qeventdispatcher_pm.cpp (modified) (34 diffs)
• qeventdispatcher_pm_p.h (modified) (1 diff)

trunk/src/corelib/kernel/qeventdispatcher_pm.cpp

@@ -49 +49 @@
 #include "qmutex.h"
 #include "qwaitcondition.h"
+#include "qlist.h"
+#include "qmap.h"
+#include "qhash.h"
+#include "qset.h"
 
 #include "qabstracteventdispatcher_p.h"
@@ -59 +63 @@
 
 #include <sys/socket.h>
+#include <sys/times.h> // for times()
+#include <unistd.h> // for sysconf()
 
 QT_BEGIN_NAMESPACE
 
 extern uint qGlobalPostedEventsCount();
-
-class QEventDispatcherPMPrivate;
-
-// @todo later: timers
-#if 0
-
-struct WinTimerInfo {                           // internal timer info
-    QObject *dispatcher;
-    int timerId;
-    int interval;
-    QObject *obj;                               // - object to receive events
-    bool inTimerEvent;
-    int fastTimerId;
-};
-
-class QZeroTimerEvent : public QTimerEvent
-{
-public:
-    inline QZeroTimerEvent(int timerId)
-        : QTimerEvent(timerId)
-    { t = QEvent::ZeroTimerEvent; }
-};
-
-typedef QList<WinTimerInfo*>  WinTimerVec;      // vector of TimerInfo structs
-typedef QHash<int, WinTimerInfo*> WinTimerDict; // fast dict of timers
-
-#if !defined(DWORD_PTR) && !defined(Q_WS_WIN64)
-#define DWORD_PTR DWORD
-#endif
-
-typedef MMRESULT(WINAPI *ptimeSetEvent)(UINT, UINT, LPTIMECALLBACK, DWORD_PTR, UINT);
-typedef MMRESULT(WINAPI *ptimeKillEvent)(UINT);
-
-static ptimeSetEvent qtimeSetEvent = 0;
-static ptimeKillEvent qtimeKillEvent = 0;
-
-LRESULT CALLBACK qt_internal_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp);
-
-static void resolveTimerAPI()
-{
-    static bool triedResolve = false;
-    if (!triedResolve) {
-#ifndef QT_NO_THREAD
-        QMutexLocker locker(QMutexPool::globalInstanceGet(&triedResolve));
-        if (triedResolve)
-            return;
-#endif
-        triedResolve = true;
-#if !defined(Q_OS_WINCE)
-        qtimeSetEvent = (ptimeSetEvent)QLibrary::resolve(QLatin1String("winmm"), "timeSetEvent");
-        qtimeKillEvent = (ptimeKillEvent)QLibrary::resolve(QLatin1String("winmm"), "timeKillEvent");
-#else
-        qtimeSetEvent = (ptimeSetEvent)QLibrary::resolve(QLatin1String("Mmtimer"), "timeSetEvent");
-        qtimeKillEvent = (ptimeKillEvent)QLibrary::resolve(QLatin1String("Mmtimer"), "timeKillEvent");
-#endif
-    }
-}
-
-#endif
 
 /*****************************************************************************
@@ -272 +219 @@
 
 
-// socket select notification (highest priority)
+// socket select notification (higher priority)
 #define WM_U_SEM_SELECT     WM_SEM1
-// zero timer notification (lowest priority)
-#define WM_U_SEM_ZEROTIMER  WM_SEM4
+// timer notification (lower priority)
+#define WM_U_SEM_TIMER      WM_SEM3 // scheduled right before WM_TIMER
+
+// Internal operator functions for timevals
+
+inline bool operator<(const timeval &t1, const timeval &t2)
+{
+    return t1.tv_sec < t2.tv_sec || (t1.tv_sec == t2.tv_sec && t1.tv_usec < t2.tv_usec);
+}
+
+inline bool operator==(const timeval &t1, const timeval &t2)
+{
+    return t1.tv_sec == t2.tv_sec && t1.tv_usec == t2.tv_usec;
+}
+
+inline timeval &operator+=(timeval &t1, const timeval &t2)
+{
+    t1.tv_sec += t2.tv_sec;
+    if ((t1.tv_usec += t2.tv_usec) >= 1000000l) {
+        ++t1.tv_sec;
+        t1.tv_usec -= 1000000l;
+    }
+    return t1;
+}
+inline timeval operator+(const timeval &t1, const timeval &t2)
+{
+    timeval tmp;
+    tmp.tv_sec = t1.tv_sec + t2.tv_sec;
+    if ((tmp.tv_usec = t1.tv_usec + t2.tv_usec) >= 1000000l) {
+        ++tmp.tv_sec;
+        tmp.tv_usec -= 1000000l;
+    }
+    return tmp;
+}
+inline timeval operator-(const timeval &t1, const timeval &t2)
+{
+    timeval tmp;
+    tmp.tv_sec = t1.tv_sec - t2.tv_sec;
+    if ((tmp.tv_usec = t1.tv_usec - t2.tv_usec) < 0l) {
+        --tmp.tv_sec;
+        tmp.tv_usec += 1000000l;
+    }
+    return tmp;
+}
 
 /*****************************************************************************
- socket select() thread
+ socket select() and timer service thread
  *****************************************************************************/
 
 #if !defined(QT_NO_THREAD)
 
-class QSockSelectThread : public QThread
+class QSelectThread : public QThread
 {
 public:
+
     typedef QSocketNotifier::Type Type;
 
@@ -292 +282 @@
     static QSocketNotifier *getSocketNotifier(int key);
 
+    // timer support is based on QTimerInfoList from the Unix implementation
+    static void addTimer(int timerId, int interval, QObject *object, HWND hwnd);
+    static bool removeTimer(int timerId);
+    static bool removeTimers(QObject *object);
+    static QList<QPair<int, int> > knownTimers(QObject *object);
+    static QObject *getTimerObject(int timerId);
+
     static void attachThread();
     static void detachThread();
 
 private:
-    QSockSelectThread() : finish(false), refcnt(0), maxSockfd(-1) {};
+    QSelectThread();
+    ~QSelectThread();
 
     void run();
     void cancelSelectOrIdle();
+
+    struct TimerInfo;
+
+    bool timeChanged(timeval *delta);
+    void getTime(timeval &t);
+    void updateCurrentTime();
+    void removeFromTimeoutMap(TimerInfo *ti);
+
+    bool timerWait(timeval &);
+    void timerRepair(const timeval &);
+
+    void activateTimers();
 
     bool finish;
@@ -305 +315 @@
     QWaitCondition cond;
 
+    // socket stuff
+
     typedef QHash<int, QSocketNotifier*> Sockets;
     Sockets sockets;
@@ -310 +322 @@
 
     enum Op { Add, Remove };
-    struct PendingOp {
+    struct PendingSockOp {
         Op op;
         int sockfd;
@@ -316 +328 @@
         HWND hwnd;
     };
-    typedef QList<PendingOp> Pending;
-    Pending pending;
-
-    static int toKey(int sockfd, Type type) {
+
+    typedef QList<PendingSockOp> PendingSockets;
+    PendingSockets pendingSockets;
+
+    // timer stuff
+
+    struct TimerInfo {
+        int id;           // - timer identifier
+        timeval interval; // - timer interval
+        timeval timeout;  // - when to sent event
+        QObject *obj;     // - object to receive event
+        HWND hwnd;        // - where to post the timer message
+    };
+
+    typedef QHash<int, TimerInfo*> TimerInfoMap;
+    TimerInfoMap timers;
+
+    typedef QMap<timeval, TimerInfo*> TimevalMap;
+    TimevalMap timersByTimeout;
+
+    timeval currentTime;
+    timeval previousTime;
+    clock_t previousTicks;
+    int ticksPerSecond;
+    int msPerTick;
+
+    static int toSockKey(int sockfd, Type type) {
         // as a hash key, we use first two bits of int for the type and the rest
         // for the sockfd which should be enough in the real world
@@ -325 +360 @@
         return (sockfd << 2) + type;
     }
-    // opposite to toKey()
+    // opposite to toSockKey()
     static int toSocket(int key) { return key >> 2; }
-    static Type toType(int key) { return Type(key & 0x3); }
-
-    static QSockSelectThread *instance;
+    static Type toSockType(int key) { return Type(key & 0x3); }
+
+    static QSelectThread *instance;
     static QMutex mutex;
 };
 
 // static
-QSockSelectThread *QSockSelectThread::instance = 0;
-QMutex QSockSelectThread::mutex;
+QSelectThread *QSelectThread::instance = 0;
+QMutex QSelectThread::mutex;
 
 // static
-void QSockSelectThread::addSelect(QSocketNotifier *notifier, HWND hwnd)
+void QSelectThread::addSelect(QSocketNotifier *notifier, HWND hwnd)
 {
     Q_ASSERT(hwnd != NULLHANDLE);
@@ -346 +381 @@
     int sockfd = notifier->socket();
     Type type = notifier->type();
-    int key = toKey(sockfd, type);
+    int key = toSockKey(sockfd, type);
 
     QMutexLocker locker(&mutex);
     Q_ASSERT(instance);
 
+    // lazy start
     instance->start();
 
@@ -360 +396 @@
     }
     instance->sockets.insert(key, notifier);
-    PendingOp op = {Add, sockfd, type, hwnd};
-    instance->pending.append(op);
+    PendingSockOp op = {Add, sockfd, type, hwnd};
+    instance->pendingSockets.append(op);
     instance->cancelSelectOrIdle();
 }
 
 // static
-void QSockSelectThread::removeSelect(QSocketNotifier *notifier)
+void QSelectThread::removeSelect(QSocketNotifier *notifier)
 {
     QMutexLocker locker(&mutex);
@@ -373 +409 @@
     int sockfd = notifier->socket();
     Type type = notifier->type();
-    int key = toKey(sockfd, notifier->type());
+    int key = toSockKey(sockfd, notifier->type());
 
     if (instance->sockets.contains(key)) {
         instance->sockets.remove(key);
-        PendingOp op = {Remove, sockfd, type};
-        instance->pending.append(op);
+        PendingSockOp op = {Remove, sockfd, type};
+        instance->pendingSockets.append(op);
         instance->cancelSelectOrIdle();
     }
@@ -389 +425 @@
 
     May return 0 if the socket notifier object is disabled/deleted after
-    WM_U_SEM_SELECT is issued for it but before this message gets processed by
+    WM_U_SEM_SELECT was issued for it but before this message gets processed by
     the owning thread.
 */
 // static
-QSocketNotifier *QSockSelectThread::getSocketNotifier(int key)
+QSocketNotifier *QSelectThread::getSocketNotifier(int key)
 {
     QMutexLocker locker(&mutex);
@@ -405 +441 @@
 }
 
+// static
+void QSelectThread::addTimer(int timerId, int interval, QObject *object, HWND hwnd)
+{
+    Q_ASSERT(hwnd != NULLHANDLE);
+    if (hwnd == NULLHANDLE)
+        return;
+
+    QMutexLocker locker(&mutex);
+    Q_ASSERT(instance);
+
+    // lazy start
+    instance->start();
+
+    instance->updateCurrentTime();
+
+    TimerInfo *t = new TimerInfo;
+    t->id = timerId;
+    t->interval.tv_sec  = interval / 1000;
+    t->interval.tv_usec = (interval % 1000) * 1000;
+    t->timeout = instance->currentTime + t->interval;
+    t->obj = object;
+    t->hwnd = hwnd;
+
+    instance->timers.insert(t->id, t);
+    // QMap is sorted by key (timeval), which is exactly what we need
+    instance->timersByTimeout.insert(t->timeout, t);
+
+    instance->cancelSelectOrIdle();
+}
+
+// static
+bool QSelectThread::removeTimer(int timerId)
+{
+    QMutexLocker locker(&mutex);
+    Q_ASSERT(instance);
+
+    // set timer inactive
+    TimerInfo *t = instance->timers.take(timerId);
+    if (t) {
+        // release the timer id
+        if (!QObjectPrivate::get(t->obj)->inThreadChangeEvent)
+            QAbstractEventDispatcherPrivate::releaseTimerId(timerId);
+        instance->removeFromTimeoutMap(t);
+
+        delete t;
+        return true;
+    }
+
+    // id not found
+    return false;
+}
+
+// static
+bool QSelectThread::removeTimers(QObject *object)
+{
+    QMutexLocker locker(&mutex);
+    Q_ASSERT(instance);
+
+    if (instance->timers.isEmpty())
+        return false;
+    for (TimerInfoMap::iterator it = instance->timers.begin();
+          it != instance->timers.end();) {
+        register TimerInfo *t = it.value();
+        if (t->obj == object) {
+            // object found
+            it = instance->timers.erase(it);
+
+            // release the timer id
+            if (!QObjectPrivate::get(t->obj)->inThreadChangeEvent)
+                QAbstractEventDispatcherPrivate::releaseTimerId(t->id);
+            instance->removeFromTimeoutMap(t);
+
+            delete t;
+        } else {
+            ++it;
+        }
+    }
+    return true;
+}
+
+// static
+QList<QPair<int, int> > QSelectThread::knownTimers(QObject *object)
+{
+    QMutexLocker locker(&mutex);
+    Q_ASSERT(instance);
+
+    QList<QPair<int, int> > list;
+    for (TimerInfoMap::const_iterator it = instance->timers.constBegin();
+          it != instance->timers.constEnd(); ++it) {
+        register const TimerInfo * const t = it.value();
+        if (t->obj == object)
+            list << QPair<int, int>(t->id, t->interval.tv_sec * 1000 + t->interval.tv_usec / 1000);
+    }
+    return list;
+}
+
 /*!
-    Incrreases the usage count of the QSockSelectThread instance by one. If no
-    QSockSelectThread instance exists yet, creates it. Note that the thread is
+    Returns the timer object corresponding to the given timer ID from the
+    WM_U_SEM_TIMER message. The return value is only correct for the thread
+    that owns the timer (creates/registers/unregisters it).
+
+    May return 0 if the timer is stopped/deleted after WM_U_SEM_TIMER was issued
+    for it but before this message gets processed by the owning thread.
+*/
+// static
+QObject *QSelectThread::getTimerObject(int timerId)
+{
+    QMutexLocker locker(&mutex);
+    Q_ASSERT(instance);
+
+    TimerInfo *t = instance->timers.value(timerId);
+    if (t)
+        return t->obj;
+
+    return 0;
+}
+
+/*!
+    Incrreases the usage count of the QSelectThread instance by one. If no
+    QSelectThread instance exists yet, creates it. Note that the thread is
     started on demand by addSelect(), not by this method.
 
@@ -415 +568 @@
 */
 // static
-void QSockSelectThread::attachThread()
+void QSelectThread::attachThread()
 {
     QMutexLocker locker(&mutex);
 
     if (instance == 0) {
-        instance = new QSockSelectThread();
+        instance = new QSelectThread();
         instance->start();
     }
@@ -429 +582 @@
 /*!
     Removes all socket notifiers owned by the current thread and decreases the
-    usage count of the QSockSelectThread instance by one. When the usage count
+    usage count of the QSelectThread instance by one. When the usage count
     goes to zero, the socket select thread is stopped and the instance is
     deleted.
@@ -437 +590 @@
 */
 // static
-void QSockSelectThread::detachThread()
+void QSelectThread::detachThread()
 {
     QMutexLocker locker(&mutex);
     Q_ASSERT(instance);
 
+    // remove socket notifiers owned by this thread
     for (Sockets::iterator it = instance->sockets.begin();
           it != instance->sockets.end();) {
         QSocketNotifier *notifier = it.value();
         if (notifier->thread() == QThread::currentThread()) {
-            PendingOp op = {Remove, notifier->socket(), notifier->type()};
-            instance->pending.append(op);
+            PendingSockOp op = {Remove, notifier->socket(), notifier->type()};
+            instance->pendingSockets.append(op);
             it = instance->sockets.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
+    // remove timers owned by this thread
+    for (TimerInfoMap::iterator it = instance->timers.begin();
+          it != instance->timers.end();) {
+        register TimerInfo *t = it.value();
+        if (t->obj->thread() == QThread::currentThread()) {
+            // object found
+            it = instance->timers.erase(it);
+
+            // release the timer id
+            if (!QObjectPrivate::get(t->obj)->inThreadChangeEvent)
+                QAbstractEventDispatcherPrivate::releaseTimerId(t->id);
+            instance->removeFromTimeoutMap(t);
+
+            delete t;
         } else {
             ++it;
@@ -464 +637 @@
     }
 }
-void QSockSelectThread::run()
+
+QSelectThread::QSelectThread() : finish(false), refcnt(0)
+{
+    // initialize socket stuff
+    maxSockfd = -1;
+
+    // initialize timer stuff
+    getTime(currentTime);
+
+    // initialize the timeChanged() machinery
+    previousTime = currentTime;
+
+    tms unused;
+    previousTicks = times(&unused);
+
+    ticksPerSecond = sysconf(_SC_CLK_TCK);
+    msPerTick = 1000 / ticksPerSecond;
+}
+
+QSelectThread::~QSelectThread()
+{
+    // detachThread() calls must clean up sockets/timers they own
+    Q_ASSERT(sockets.isEmpty());
+    Q_ASSERT(timers.isEmpty());
+    Q_ASSERT(timersByTimeout.isEmpty());
+
+    // but, still, be nice and cleanup timers (we allocate them with new)
+    qDeleteAll(timers);
+}
+
+void QSelectThread::run()
 {
     // maintain a separate hash for HWNDs to avoid mutex locking every time
@@ -476 +679 @@
     FD_ZERO(&exS);
 
+    mutex.lock();
+
     do {
-        mutex.lock();
-
         while (!finish && sockets.isEmpty()) {
             cond.wait(&mutex);
         }
 
-        if (finish) {
-            mutex.unlock();
+        if (finish)
             break;
-        }
-
-        while (!pending.isEmpty()) {
-            PendingOp p = pending.takeFirst();
+
+        // process pending socket operations
+        while (!pendingSockets.isEmpty()) {
+            PendingSockOp p = pendingSockets.takeFirst();
             switch (p.op) {
                 case Add:
@@ -500 +702 @@
                             FD_SET(p.sockfd, &exS); break;
                     }
-                    hwnds.insert(toKey(p.sockfd, p.type), p.hwnd);
+                    hwnds.insert(toSockKey(p.sockfd, p.type), p.hwnd);
                     maxSockfd = qMax(maxSockfd, p.sockfd);
                     break;
@@ -512 +714 @@
                             FD_CLR(p.sockfd, &exS); break;
                     }
-                    hwnds.remove(toKey(p.sockfd, p.type));
+                    hwnds.remove(toSockKey(p.sockfd, p.type));
                     if (maxSockfd == p.sockfd) {
                         // find the new hignest socket
@@ -528 +730 @@
         }
 
+        // get the maximum time we can wait (for the closest timer)
+        timeval *timeout = 0;
+        timeval wait_tm = { 0l, 0l };
+        if (timerWait(wait_tm))
+            timeout = &wait_tm;
+
+        mutex.unlock();
+
         // do select
-        mutex.unlock();
-        int nsel = ::select(maxSockfd + 1, &readS, &writeS, &exS, NULL);
+        int nsel = ::select(maxSockfd + 1, &readS, &writeS, &exS, timeout);
         if (nsel > 0) {
             for (Hwnds::const_iterator it = hwnds.constBegin();
@@ -536 +745 @@
                 int sockfd = toSocket(it.key());
                 bool isSet = false;
-                switch (toType(it.key())) {
+                switch (toSockType(it.key())) {
                     case QSocketNotifier::Read:
                         isSet = FD_ISSET(sockfd, &readS); break;
@@ -548 +757 @@
             }
         }
+
+        mutex.lock();
+
+        if (nsel == 0 || (nsel == -1 && errno == EINTR)) {
+            // timeout, check if there are expired timers
+            activateTimers();
+        }
     } while(true);
-}
-
-// Must be called from under QSockSelectThread::mutex
-void QSockSelectThread::cancelSelectOrIdle()
+
+    mutex.unlock();
+}
+
+// Must be called from under QSelectThread::mutex
+void QSelectThread::cancelSelectOrIdle()
 {
     if (maxSockfd >= 0) {
@@ -563 +781 @@
 }
 
+/*
+  Returns true if the real time clock has changed by more than 10%
+  relative to the processor time since the last time this function was
+  called. This presumably means that the system time has been changed.
+
+  If /a delta is nonzero, delta is set to our best guess at how much the system
+  clock was changed.
+*/
+bool QSelectThread::timeChanged(timeval *delta)
+{
+    tms unused;
+    clock_t currentTicks = times(&unused);
+
+    int elapsedTicks = currentTicks - previousTicks;
+    timeval elapsedTime = currentTime - previousTime;
+    int elapsedMsecTicks = (elapsedTicks * 1000) / ticksPerSecond;
+    int deltaMsecs = (elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000)
+                     - elapsedMsecTicks;
+
+    if (delta) {
+        delta->tv_sec = deltaMsecs / 1000;
+        delta->tv_usec = (deltaMsecs % 1000) * 1000;
+    }
+    previousTicks = currentTicks;
+    previousTime = currentTime;
+
+    // If tick drift is more than 10% off compared to realtime, we assume that the clock has
+    // been set. Of course, we have to allow for the tick granularity as well.
+
+     return (qAbs(deltaMsecs) - msPerTick) * 10 > elapsedMsecTicks;
+}
+
+void QSelectThread::getTime(timeval &t)
+{
+    gettimeofday(&t, 0);
+    // NTP-related fix
+    while (t.tv_usec >= 1000000l) {
+        t.tv_usec -= 1000000l;
+        ++t.tv_sec;
+    }
+    while (t.tv_usec < 0l) {
+        if (t.tv_sec > 0l) {
+            t.tv_usec += 1000000l;
+            --t.tv_sec;
+        } else {
+            t.tv_usec = 0l;
+            break;
+        }
+    }
+}
+
+void QSelectThread::updateCurrentTime()
+{
+    getTime(currentTime);
+
+    // repair timers if needed
+    timeval delta;
+    if (timeChanged(&delta))
+        timerRepair(delta);
+}
+
+void QSelectThread::removeFromTimeoutMap(TimerInfo *ti)
+{
+    TimevalMap::iterator it = timersByTimeout.find(ti->timeout);
+    while (it != timersByTimeout.end() && it.value() != ti)
+        ++it;
+    Q_ASSERT(it != timersByTimeout.end());
+    timersByTimeout.erase(it);
+}
+
+/*
+  repair broken timer
+*/
+void QSelectThread::timerRepair(const timeval &diff)
+{
+    // repair all timers
+    for (TimerInfoMap::iterator it = instance->timers.begin();
+          it != instance->timers.end(); ++it) {
+        register TimerInfo *t = it.value();
+        t->timeout = t->timeout - diff;
+    }
+}
+
+/*
+  Returns the time to wait for the next timer, or null if no timers
+  are waiting.
+*/
+bool QSelectThread::timerWait(timeval &tm)
+{
+    updateCurrentTime();
+
+    if (timers.isEmpty())
+        return false;
+
+    TimerInfo *t = timersByTimeout.begin().value();    // first waiting timer
+    if (currentTime < t->timeout) {
+        // time to wait
+        tm = t->timeout - currentTime;
+    } else {
+        // no time to wait
+        tm.tv_sec  = 0;
+        tm.tv_usec = 0;
+    }
+
+    return true;
+}
+
+/*
+    Activates pending timers.
+*/
+void QSelectThread::activateTimers()
+{
+    if (timers.isEmpty())
+        return; // nothing to do
+
+    updateCurrentTime();
+
+    while(true) {
+        TimerInfo *t = timersByTimeout.begin().value();
+
+        if (currentTime < t->timeout)
+            break; // no timer has expired
+
+        // remove from map
+        timersByTimeout.erase(timersByTimeout.begin());
+
+        // determine next timeout time
+        if (t->interval.tv_sec == 0 && t->interval.tv_usec == 0) {
+            // zero timer; make sure it won't fire again in this loop
+            t->timeout.tv_sec = 0;
+            t->timeout.tv_usec = 1;
+            t->timeout += currentTime;
+        } else {
+            // normal timer; also make sure it won't fire again in this loop
+            t->timeout += t->interval;
+            if (t->timeout < currentTime)
+                t->timeout = currentTime + t->interval;
+        }
+
+        // reinsert timer (in proper sort order)
+        timersByTimeout.insert(t->timeout, t);
+
+        // post the timer message
+        WinPostMsg(t->hwnd, WM_U_SEM_TIMER, MPFROMLONG(t->id), 0);
+    }
+
+    return;
+}
+
 #else
 
-class QSockSelectThread
-{
+class QSelectThread
+{
+    // dummy implementation
+
 public:
     static void addSelect(QSocketNotifier *notifier, HWND hwnd) {
@@ -577 +946 @@
     static QSocketNotifier *getSocketNotifier(int key); { return 0; }
 
+    static void addTimer(int timerId, int interval, QObject *object, HWND hwnd) {
+#ifndef QT_NO_DEBUG
+        qWarning("QObject::startTimer: timers require thread support but"
+                 "QT_NO_THREAD was defined");
+#endif
+    }
+    static bool removeTimer(int timerId) { return false; }
+    static bool removeTimers(QObject *object) { return false; }
+    static QList<QPair<int, int> > knownTimers(QObject *object) const {
+        return QList<QPair<int, int> >();
+    }
+    static QObject *getTimerObject(int timerId);
+
     static void attachThread() {}
     static void detachThread() {}
@@ -593 +975 @@
     void createAuxWnd();
 
-    // Auxiliary object window to process WM_U_SEM_SELECT and WM_TIMER messages.
+    // Auxiliary object window to process WM_U_SEM_SELECT and WM_U_SEM_TIMER messages.
     // We need a dedicated window along with processing these messages directly in
     // QEventLoop::processEvents() to make sure they are processed even if the
@@ -607 +989 @@
         MRESULT message(ULONG msg, MPARAM mp1, MPARAM mp2);
         QEventDispatcherPMPrivate *dispatcher;
+    private:
+        QSet<int> timersInSend;
     } auxWnd;
 
@@ -615 +999 @@
 
 // @todo later
-//
-//  // timers
-//  WinTimerVec timerVec;
-//  WinTimerDict timerDict;
-//  void registerTimer(WinTimerInfo *t);
-//  void unregisterTimer(WinTimerInfo *t);
-//  void sendTimerEvent(int timerId);
 //
 //  QList<QMSG> queuedUserInputEvents;
@@ -685 +1062 @@
         case WM_U_SEM_SELECT: {
             QSocketNotifier *notifier =
-                QSockSelectThread::getSocketNotifier(LONGFROMMP(mp1));
-                if (notifier) {
-                    QEvent event(QEvent::SockAct);
-                    QCoreApplication::sendEvent(notifier, &event);
-                }
+                QSelectThread::getSocketNotifier(LONGFROMMP(mp1));
+            if (notifier) {
+                QEvent event(QEvent::SockAct);
+                QCoreApplication::sendEvent(notifier, &event);
+            }
             break;
         }
-        case WM_U_SEM_ZEROTIMER: {
-// @todo later
-//          if (numZeroTimers) {
-//              activateZeroTimers();
-//              // repost the message if there are still zero timers left
-//              if (numZeroTimers)
-//                  WinPostMsg(hwnd(), WM_U_SEM_ZEROTIMER, 0, 0);
-//          }
+        case WM_U_SEM_TIMER: {
+            int timerId = LONGFROMMP(mp1);
+            QObject *obj = QSelectThread::getTimerObject(timerId);
+
+            if (obj && !timersInSend.contains(timerId)) {
+                // send event, but don't allow it to recurse
+                timersInSend += timerId;
+
+                QTimerEvent e(timerId);
+                QCoreApplication::sendEvent(obj, &e);
+
+                timersInSend -= timerId;
+            }
             break;
         }
-        case WM_TIMER: {
-// @todo later
-//          USHORT id = SHORT1FROMMP(mp1);
-//          dispatchTimer((uint) id, &qmsg);
+        default:
             break;
-        }
     }
 
     return FALSE;
 }
-
-// @todo remove
-#if 0
-
-LRESULT CALLBACK qt_internal_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
-{
-    if (message == WM_NCCREATE) {
-            return true;
-    } else if (message == WM_USER) {
-
-        // socket notifier message
-        MSG msg;
-        msg.hwnd = hwnd;
-        msg.message = message;
-        msg.wParam = wp;
-        msg.lParam = lp;
-
-        QCoreApplication *app = QCoreApplication::instance();
-        long result;
-        if (app && app->filterEvent(&msg, &result))
-            return result;
-
-        int type = -1;
-        switch (WSAGETSELECTEVENT(lp)) {
-        case FD_READ:
-        case FD_CLOSE:
-        case FD_ACCEPT:
-            type = 0;
-            break;
-        case FD_WRITE:
-        case FD_CONNECT:
-            type = 1;
-            break;
-        case FD_OOB:
-            type = 2;
-            break;
-        }
-        if (type >= 0) {
-
-    #ifdef GWLP_USERDATA
-            QEventDispatcherPM *eventDispatcher =
-                (QEventDispatcherPM *) GetWindowLongPtrA(hwnd, GWLP_USERDATA);
-    #else
-            QEventDispatcherPM *eventDispatcher =
-                (QEventDispatcherPM *) GetWindowLongA(hwnd, GWL_USERDATA);
-    #endif
-            if (eventDispatcher) {
-                QEventDispatcherPMPrivate *d = eventDispatcher->d_func();
-                QSNDict *sn_vec[3] = { &d->sn_read, &d->sn_write, &d->sn_except };
-                QSNDict *dict = sn_vec[type];
-
-                QSockNot *sn = dict ? dict->value(wp) : 0;
-                if (sn) {
-                    QEvent event(QEvent::SockAct);
-                    QCoreApplication::sendEvent(sn->obj, &event);
-                }
-            }
-        }
-        return 0;
-
-    } else if (message == WM_TIMER) {
-
-        MSG msg;
-        msg.hwnd = hwnd;
-        msg.message = message;
-        msg.wParam = wp;
-        msg.lParam = lp;
-
-        QCoreApplication *app = QCoreApplication::instance();
-        Q_ASSERT_X(app, "qt_interal_proc", "Timer fired, but no QCoreApplication");
-        if (!app) {
-            KillTimer(hwnd, wp);
-            return 0;
-        }
-
-        long result;
-        if (app->filterEvent(&msg, &result))
-            return result;
-
-        QEventDispatcherPM *eventDispatcher =
-            qobject_cast<QEventDispatcherPM *>(QAbstractEventDispatcher::instance());
-        Q_ASSERT(eventDispatcher != 0);
-        QEventDispatcherPMPrivate *d = eventDispatcher->d_func();
-        d->sendTimerEvent(wp);
-        return 0;
-    }
-
-    return  DefWindowProc(hwnd, message, wp, lp);
-}
-
-void QEventDispatcherPMPrivate::registerTimer(WinTimerInfo *t)
-{
-    Q_ASSERT(internalHwnd);
-
-    Q_Q(QEventDispatcherPM);
-
-    int ok = 0;
-
-    if (t->interval > 10 || !t->interval || !qtimeSetEvent) {
-        ok = 1;
-        if (!t->interval)  // optimization for single-shot-zero-timer
-            QCoreApplication::postEvent(q, new QZeroTimerEvent(t->timerId));
-        else
-            ok = SetTimer(internalHwnd, t->timerId, (uint) t->interval, 0);
-    } else {
-        ok = t->fastTimerId = qtimeSetEvent(t->interval, 1, qt_fast_timer_proc, (DWORD_PTR)t,
-                                            TIME_CALLBACK_FUNCTION | TIME_PERIODIC | TIME_KILL_SYNCHRONOUS);
-        if (ok == 0) { // fall back to normal timer if no more multimedia timers avaiable
-            ok = SetTimer(internalHwnd, t->timerId, (uint) t->interval, 0);
-        }
-    }
-
-    if (ok == 0)
-        qErrnoWarning("QEventDispatcherPM::registerTimer: Failed to create a timer");
-}
-
-void QEventDispatcherPMPrivate::unregisterTimer(WinTimerInfo *t)
-{
-    // mark timer as unused
-    if (!QObjectPrivate::get(t->obj)->inThreadChangeEvent)
-        QAbstractEventDispatcherPrivate::releaseTimerId(t->timerId);
-
-    if (t->interval == 0) {
-        QCoreApplicationPrivate::removePostedTimerEvent(t->dispatcher, t->timerId);
-    } else if (t->fastTimerId != 0) {
-        qtimeKillEvent(t->fastTimerId);
-        QCoreApplicationPrivate::removePostedTimerEvent(t->dispatcher, t->timerId);
-    } else if (internalHwnd) {
-        KillTimer(internalHwnd, t->timerId);
-    }
-    delete t;
-}
-
-void QEventDispatcherPMPrivate::sendTimerEvent(int timerId)
-{
-    WinTimerInfo *t = timerDict.value(timerId);
-    if (t && !t->inTimerEvent) {
-        // send event, but don't allow it to recurse
-        t->inTimerEvent = true;
-
-        QTimerEvent e(t->timerId);
-        QCoreApplication::sendEvent(t->obj, &e);
-
-        // timer could have been removed
-        t = timerDict.value(timerId);
-        if (t) {
-            t->inTimerEvent = false;
-        }
-    }
-}
-
-void QEventDispatcherPM::createInternalHwnd()
-{
-    Q_D(QEventDispatcherPM);
-
-    Q_ASSERT(!d->internalHwnd);
-    if (d->internalHwnd)
-        return;
-    d->internalHwnd = qt_create_internal_window(this);
-
-    // register all socket notifiers
-    QList<int> sockets = (d->sn_read.keys().toSet()
-                          + d->sn_write.keys().toSet()
-                          + d->sn_except.keys().toSet()).toList();
-    for (int i = 0; i < sockets.count(); ++i)
-        d->doWsaAsyncSelect(sockets.at(i));
-
-    // start all normal timers
-    for (int i = 0; i < d->timerVec.count(); ++i)
-        d->registerTimer(d->timerVec.at(i));
-}
-
-#endif
 
 QEventDispatcherPM::QEventDispatcherPM(QObject *parent)
@@ -1022 +1227 @@
     d->createAuxWnd();
 
-    QSockSelectThread::addSelect(notifier, d->auxWnd.hwnd());
+    QSelectThread::addSelect(notifier, d->auxWnd.hwnd());
 }
 
@@ -1041 +1246 @@
 #endif
 
-    QSockSelectThread::removeSelect(notifier);
+    QSelectThread::removeSelect(notifier);
 }
 
 void QEventDispatcherPM::registerTimer(int timerId, int interval, QObject *object)
 {
-// @todo later
-#if 0
+#ifndef QT_NO_DEBUG
     if (timerId < 1 || interval < 0 || !object) {
         qWarning("QEventDispatcherPM::registerTimer: invalid arguments");
@@ -1055 +1259 @@
         return;
     }
+#endif
 
     Q_D(QEventDispatcherPM);
-
-    register WinTimerInfo *t = new WinTimerInfo;
-    t->dispatcher = this;
-    t->timerId  = timerId;
-    t->interval = interval;
-    t->obj  = object;
-    t->inTimerEvent = false;
-    t->fastTimerId = 0;
-
-    if (d->internalHwnd)
-        d->registerTimer(t);
-
-    d->timerVec.append(t);                      // store in timer vector
-    d->timerDict.insert(t->timerId, t);          // store timers in dict
-#endif
+    d->createAuxWnd();
+
+    QSelectThread::addTimer(timerId, interval, object, d->auxWnd.hwnd());
 }
 
 bool QEventDispatcherPM::unregisterTimer(int timerId)
 {
-// @todo later
-#if 0
+#ifndef QT_NO_DEBUG
     if (timerId < 1) {
         qWarning("QEventDispatcherPM::unregisterTimer: invalid argument");
         return false;
-    }
-    QThread *currentThread = QThread::currentThread();
-    if (thread() != currentThread) {
+    } else if (thread() != QThread::currentThread()) {
         qWarning("QObject::killTimer: timers cannot be stopped from another thread");
         return false;
     }
-
-    Q_D(QEventDispatcherPM);
-    if (d->timerVec.isEmpty() || timerId <= 0)
-        return false;
-
-    WinTimerInfo *t = d->timerDict.value(timerId);
-    if (!t)
-        return false;
-
-    d->timerDict.remove(t->timerId);
-    d->timerVec.removeAll(t);
-    d->unregisterTimer(t);
-    return true;
-#else
-    return false;
 #endif
+
+    return QSelectThread::removeTimer(timerId);
 }
 
 bool QEventDispatcherPM::unregisterTimers(QObject *object)
 {
-// @todo later
-#if 0
+#ifndef QT_NO_DEBUG
     if (!object) {
         qWarning("QEventDispatcherPM::unregisterTimers: invalid argument");
         return false;
-    }
-    QThread *currentThread = QThread::currentThread();
-    if (object->thread() != thread() || thread() != currentThread) {
+    } else if (object->thread() != thread() || thread() != QThread::currentThread()) {
         qWarning("QObject::killTimers: timers cannot be stopped from another thread");
         return false;
     }
-
-    Q_D(QEventDispatcherPM);
-    if (d->timerVec.isEmpty())
-        return false;
-    register WinTimerInfo *t;
-    for (int i=0; i<d->timerVec.size(); i++) {
-        t = d->timerVec.at(i);
-        if (t && t->obj == object) {                // object found
-            d->timerDict.remove(t->timerId);
-            d->timerVec.removeAt(i);
-            d->unregisterTimer(t);
-            --i;
-        }
-    }
-    return true;
-#else
-    return false;
 #endif
+
+    return QSelectThread::removeTimers(object);
 }
 
@@ -1141 +1300 @@
 QEventDispatcherPM::registeredTimers(QObject *object) const
 {
-// @todo later
-#if 0
+#ifndef QT_NO_DEBUG
     if (!object) {
         qWarning("QEventDispatcherPM:registeredTimers: invalid argument");
         return QList<TimerInfo>();
     }
-
-    Q_D(const QEventDispatcherPM);
-    QList<TimerInfo> list;
-    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);
-    }
-    return list;
-#else
-    return QList<TimerInfo>();
 #endif
+
+    return QSelectThread::knownTimers(object);
 }
 
@@ -1185 +1334 @@
 void QEventDispatcherPM::startingUp()
 {
-    QSockSelectThread::attachThread();
+    QSelectThread::attachThread();
 }
 
 void QEventDispatcherPM::closingDown()
 {
-    QSockSelectThread::detachThread();
-
-// @todo remove later
-#if 0
-    Q_D(QEventDispatcherPM);
-
-    // clean up any timers
-    while (!d->timerDict.isEmpty())
-        unregisterTimer((*(d->timerDict.begin()))->timerId);
-#endif
-}
-
-// @todo remove later
-#if 0
-bool QEventDispatcherPM::event(QEvent *e)
-{
-    Q_D(QEventDispatcherPM);
-    if (e->type() == QEvent::ZeroTimerEvent) {
-        QZeroTimerEvent *zte = static_cast<QZeroTimerEvent*>(e);
-        WinTimerInfo *t = d->timerDict.value(zte->timerId());
-        if (t) {
-            t->inTimerEvent = true;
-
-            QTimerEvent te(zte->timerId());
-            QCoreApplication::sendEvent(t->obj, &te);
-
-            t = d->timerDict.value(zte->timerId());
-            if (t) {
-                if (t->interval == 0 && t->inTimerEvent) {
-                    // post the next zero timer event as long as the timer was not restarted
-                    QCoreApplication::postEvent(this, new QZeroTimerEvent(zte->timerId()));
-                }
-
-                t->inTimerEvent = false;
-            }
-        }
-        return true;
-    } else if (e->type() == QEvent::Timer) {
-        QTimerEvent *te = static_cast<QTimerEvent*>(e);
-        d->sendTimerEvent(te->timerId());
-    }
-    return QAbstractEventDispatcher::event(e);
-}
-#endif
+    QSelectThread::detachThread();
+}
 
 QT_END_NAMESPACE

trunk/src/corelib/kernel/qeventdispatcher_pm_p.h

@@ -91 +91 @@
     void startingUp();
     void closingDown();
-
-// @todo remove later
-//  bool event(QEvent *e);
 };