pidgin/quail/quail-redux

First the easy part of getting the windows functions, next I need to merge the Glib loop with these calls
advanced-eventloop
2013-09-13, Phil Hannent
1b96f1615999
Parents cf73733ee683
Children 581cc29f93e5
First the easy part of getting the windows functions, next I need to merge the Glib loop with these calls
2 files changed, 1083 insertions(+), 6 deletions(-)
  • +1078 -1
    src/QuailWinGlibEventLoop.cpp
  • +5 -5
    src/QuailWinGlibEventLoop.h
    • --- a/src/QuailWinGlibEventLoop.cpp Fri Sep 13 13:58:43 2013 +0100
    +++ b/src/QuailWinGlibEventLoop.cpp Fri Sep 13 14:11:27 2013 +0100
    @@ -1,5 +1,1082 @@
    #include "QuailWinGlibEventLoop.h"
    -QuailWinGlibEventLoop::QuailWinGlibEventLoop()
    +#include <QCoreApplication>
    +
    +HINSTANCE qWinAppInst();
    +extern uint qGlobalPostedEventsCount();
    +
    +#ifndef TIME_KILL_SYNCHRONOUS
    +# define TIME_KILL_SYNCHRONOUS 0x0100
    +#endif
    +
    +#ifndef QS_RAWINPUT
    +# ifdef Q_OS_WINCE
    +# define QS_RAWINPUT 0x0000
    +# else
    +# define QS_RAWINPUT 0x0400
    +# endif
    +#endif
    +
    +#ifndef WM_TOUCH
    +# define WM_TOUCH 0x0240
    +#endif
    +#ifndef QT_NO_GESTURES
    +#ifndef WM_GESTURE
    +# define WM_GESTURE 0x0119
    +#endif
    +#ifndef WM_GESTURENOTIFY
    +# define WM_GESTURENOTIFY 0x011A
    +#endif
    +#endif // QT_NO_GESTURES
    +
    +enum {
    + WM_QT_SOCKETNOTIFIER = WM_USER,
    + WM_QT_SENDPOSTEDEVENTS = WM_USER + 1,
    + SendPostedEventsWindowsTimerId = ~1u
    +};
    +
    +#if defined(Q_OS_WINCE)
    +QT_BEGIN_INCLUDE_NAMESPACE
    +#include <winsock.h>
    +QT_END_INCLUDE_NAMESPACE
    +// Asynchronous Winsocks ------------------------------------------
    +#ifndef QT_NO_THREAD
    +QT_BEGIN_INCLUDE_NAMESPACE
    +#include <qthread.h>
    +#include <qmap.h>
    +#include <qmutex.h>
    +QT_END_INCLUDE_NAMESPACE
    +
    +//#define QCE_ASYNC_DEBUG
    +
    +namespace {
    + class SocketAsyncHandler;
    +
    + class SocketAsyncHandler : public QThread
    + {
    + public:
    + SocketAsyncHandler();
    + ~SocketAsyncHandler();
    + void run();
    + void select(SOCKET sock, HWND handle, unsigned int msg, long ev);
    + void removeSelect(SOCKET sock);
    + void safeRemove(SOCKET sock);
    + private:
    + struct SockInfo {
    + HWND handle;
    + unsigned int msg;
    + long ev;
    + };
    + QMap<SOCKET, SockInfo> sockets;
    + QMutex mutex;
    + QWaitCondition cond;
    + bool supposedToDie;
    + };
    +
    + SocketAsyncHandler::SocketAsyncHandler()
    + : supposedToDie(false)
    + {
    + }
    +
    + SocketAsyncHandler::~SocketAsyncHandler()
    + {
    + mutex.lock();
    + supposedToDie = true;
    + mutex.unlock();
    + cond.wakeOne();
    + wait();
    + while (sockets.size() > 0)
    + removeSelect(sockets.begin().key());
    + }
    +
    + void SocketAsyncHandler::removeSelect(SOCKET sock)
    + {
    + if (!sockets.contains(sock))
    + return;
    + sockets.remove(sock);
    + return;
    + }
    +
    + void SocketAsyncHandler::safeRemove(SOCKET sock)
    + {
    + QMutexLocker locker(&mutex);
    + removeSelect(sock);
    + }
    +
    + void SocketAsyncHandler::select(SOCKET sock, HWND handle, unsigned int msg, long ev)
    + {
    + QMutexLocker locker(&mutex);
    +
    + if (sockets.contains(sock))
    + sockets.remove(sock);
    +
    + SockInfo info;
    + info.handle = handle;
    + info.msg = msg;
    + info.ev = ev;
    + sockets.insert(sock, info);
    + cond.wakeOne();
    + }
    +
    + void SocketAsyncHandler::run()
    + {
    + do {
    + mutex.lock();
    +
    + while (!supposedToDie && sockets.isEmpty()) {
    + cond.wait(&mutex);
    + }
    +
    + if (supposedToDie) {
    + mutex.unlock();
    + break;
    + }
    +
    + // Copy current items to reduce lock time
    + // and to be able to use SendMessage
    + QMap<SOCKET, SockInfo> currentSockets = sockets;
    + mutex.unlock();
    +
    + fd_set readS, writeS, exS;
    + FD_ZERO(&readS);
    + FD_ZERO(&writeS);
    + FD_ZERO(&exS);
    +
    + int maxFd = 0;
    +
    + for (QMap<SOCKET, SockInfo>::iterator it = currentSockets.begin(); it != currentSockets.end(); ++it) {
    + const SockInfo &info = it.value();
    + int socket = it.key();
    + maxFd = qMax(maxFd, socket);
    +
    + if ((info.ev & FD_READ) || (info.ev & FD_CLOSE) || (info.ev & FD_ACCEPT))
    + FD_SET(socket, &readS);
    + if ((info.ev & FD_WRITE)|| (info.ev & FD_CONNECT))
    + FD_SET(socket, &writeS);
    + if (info.ev & FD_OOB)
    + FD_SET(socket, &exS);
    + }
    +
    + timeval timeout;
    + timeout.tv_sec = 0;
    + timeout.tv_usec = 50000;
    + int result = ::select(maxFd + 1, &readS, &writeS, &exS, &timeout);
    + if (result > 0) {
    + HWND handle;
    + unsigned int tmpMsg;
    + SOCKET sock;
    + HRESULT ret;
    + for (QMap<SOCKET, SockInfo>::const_iterator it = currentSockets.constBegin();
    + it != currentSockets.constEnd(); ++it) {
    + handle = (*it).handle;
    + tmpMsg = (*it).msg;
    + sock = it.key();
    + if (FD_ISSET(sock, &readS))
    + ret = SendMessage(handle, tmpMsg, sock, FD_READ);
    +
    + if (FD_ISSET(sock, &writeS))
    + ret = SendMessage(handle, tmpMsg, sock, FD_WRITE);
    +
    + if (FD_ISSET(sock, &exS))
    + ret = SendMessage(handle, tmpMsg, sock, FD_OOB);
    + }
    + }
    +
    +#ifdef QCE_ASYNC_DEBUG
    + else if (result == 0) { //timeout
    + qDebug(" WSAAsync select timeout");
    + } else if (result < 0) { // SocketError
    + // This might happen because of two reasons
    + // 1. We already closed a socket in between the copy and the select
    + // and thus select() returns an error
    + // 2. Something is really wrong, then
    + // ### Loop on all descriptors, try to select and remove the
    + // ### broken one.
    + qWarning("WSAAsync select error %d", WSAGetLastError());
    + }
    +#endif
    + } while(true);
    + }
    +} // namespace
    +
    +Q_GLOBAL_STATIC(SocketAsyncHandler, qt_async_handler)
    +
    +int WSAAsyncSelect(SOCKET sock, HWND handle, unsigned int msg, long ev)
    +{
    + if (sock == 0 || handle == 0 || handle == INVALID_HANDLE_VALUE) {
    + WSASetLastError(WSAEINVAL);
    + return SOCKET_ERROR;
    + }
    +
    + if (msg == 0 && ev == 0)
    + qt_async_handler()->safeRemove(sock);
    + else
    + qt_async_handler()->select(sock, handle, msg, ev);
    +
    + qt_async_handler()->start(QThread::LowPriority);
    + WSASetLastError(0);
    + return 0;
    +}
    +#else // QT_NO_THREAD
    +int WSAAsyncSelect(SOCKET, HWND, unsigned int, long)
    +{
    + return SOCKET_ERROR;
    +}
    +#endif
    +#endif // Q_OS_WINCE
    +
    +class QuailEventDispatcherWinGlibPrivate;
    +
    +#if !defined(DWORD_PTR) && !defined(Q_OS_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 QT_WIN_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)
    +# if defined(_MSC_VER) && _MSC_VER >= 1700
    + if (QSysInfo::WindowsVersion >= QSysInfo::WV_WINDOWS8) {
    +# else
    + {
    +# endif
    + qtimeSetEvent = (ptimeSetEvent)QSystemLibrary::resolve(QLatin1String("winmm"), "timeSetEvent");
    + qtimeKillEvent = (ptimeKillEvent)QSystemLibrary::resolve(QLatin1String("winmm"), "timeKillEvent");
    + }
    +#else
    + qtimeSetEvent = (ptimeSetEvent)QSystemLibrary::resolve(QLatin1String("Mmtimer"), "timeSetEvent");
    + qtimeKillEvent = (ptimeKillEvent)QSystemLibrary::resolve(QLatin1String("Mmtimer"), "timeKillEvent");
    +#endif
    + }
    +}
    +
    +QuailEventDispatcherWinGliPrivateb::QuailEventDispatcherWinGlibPrivate()
    + : threadId(GetCurrentThreadId()), interrupt(false), internalHwnd(0), getMessageHook(0),
    + serialNumber(0), lastSerialNumber(0), sendPostedEventsWindowsTimerId(0), wakeUps(0)
    +{
    + resolveTimerAPI();
    +}
    +
    +QuailEventDispatcherWinGlibPrivate::~QuailEventDispatcherWinGlibPrivate()
    +{
    + if (internalHwnd)
    + DestroyWindow(internalHwnd);
    + QString className = QLatin1String("QuailEventDispatcherWinGlib_Internal_Widget") + QString::number(quintptr(qt_internal_proc));
    + UnregisterClass((wchar_t*)className.utf16(), qWinAppInst());
    +}
    +
    +void QuailEventDispatcherWinGlibPrivate::activateEventNotifier(QWinEventNotifier * wen)
    +{
    + QEvent event(QEvent::WinEventAct);
    + QCoreApplication::sendEvent(wen, &event);
    +}
    +
    +// This function is called by a workerthread
    +void WINAPI QT_WIN_CALLBACK qt_fast_timer_proc(uint timerId, uint /*reserved*/, DWORD_PTR user, DWORD_PTR /*reserved*/, DWORD_PTR /*reserved*/)
    +{
    + if (!timerId) // sanity check
    + return;
    + WinTimerInfo *t = (WinTimerInfo*)user;
    + Q_ASSERT(t);
    + QCoreApplication::postEvent(t->dispatcher, new QTimerEvent(t->timerId));
    +}
    +
    +LRESULT QT_WIN_CALLBACK qt_internal_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
    +{
    + if (message == WM_NCCREATE)
    + return true;
    +
    + MSG msg;
    + msg.hwnd = hwnd;
    + msg.message = message;
    + msg.wParam = wp;
    + msg.lParam = lp;
    + QAbstractEventDispatcher* dispatcher = QAbstractEventDispatcher::instance();
    + long result;
    + if (!dispatcher) {
    + if (message == WM_TIMER)
    + KillTimer(hwnd, wp);
    + return 0;
    + } else if (dispatcher->filterNativeEvent(QByteArrayLiteral("windows_dispatcher_MSG"), &msg, &result)) {
    + return result;
    + }
    +
    +#ifdef GWLP_USERDATA
    + QuailEventDispatcherWinGlib *q = (QuailEventDispatcherWinGlib *) GetWindowLongPtr(hwnd, GWLP_USERDATA);
    +#else
    + QuailEventDispatcherWinGlib *q = (QuailEventDispatcherWinGlib *) GetWindowLong(hwnd, GWL_USERDATA);
    +#endif
    + QuailEventDispatcherWinGlibPrivate *d = 0;
    + if (q != 0)
    + d = q->d_func();
    +
    + if (message == WM_QT_SOCKETNOTIFIER) {
    + // socket notifier message
    + int type = -1;
    + switch (WSAGETSELECTEVENT(lp)) {
    + case FD_READ:
    + case FD_ACCEPT:
    + type = 0;
    + break;
    + case FD_WRITE:
    + case FD_CONNECT:
    + type = 1;
    + break;
    + case FD_OOB:
    + type = 2;
    + break;
    + case FD_CLOSE:
    + type = 3;
    + break;
    + }
    + if (type >= 0) {
    + Q_ASSERT(d != 0);
    + QSNDict *sn_vec[4] = { &d->sn_read, &d->sn_write, &d->sn_except, &d->sn_read };
    + QSNDict *dict = sn_vec[type];
    +
    + QSockNot *sn = dict ? dict->value(wp) : 0;
    + if (sn) {
    + if (type < 3) {
    + QEvent event(QEvent::SockAct);
    + QCoreApplication::sendEvent(sn->obj, &event);
    + } else {
    + QEvent event(QEvent::SockClose);
    + QCoreApplication::sendEvent(sn->obj, &event);
    + }
    + }
    + }
    + return 0;
    + } else if (message == WM_QT_SENDPOSTEDEVENTS
    + // we also use a Windows timer to send posted events when the message queue is full
    + || (message == WM_TIMER
    + && d->sendPostedEventsWindowsTimerId != 0
    + && wp == (uint)d->sendPostedEventsWindowsTimerId)) {
    + const int localSerialNumber = d->serialNumber.load();
    + if (localSerialNumber != d->lastSerialNumber) {
    + d->lastSerialNumber = localSerialNumber;
    + q->sendPostedEvents();
    + }
    + return 0;
    + } else if (message == WM_TIMER) {
    + Q_ASSERT(d != 0);
    + d->sendTimerEvent(wp);
    + return 0;
    + }
    +
    + return DefWindowProc(hwnd, message, wp, lp);
    +}
    +
    +LRESULT QT_WIN_CALLBACK qt_GetMessageHook(int code, WPARAM wp, LPARAM lp)
    +{
    + if (wp == PM_REMOVE) {
    + QuailEventDispatcherWinGlib *q = qobject_cast<QuailEventDispatcherWinGlib *>(QAbstractEventDispatcher::instance());
    + Q_ASSERT(q != 0);
    + if (q) {
    + MSG *msg = (MSG *) lp;
    + QuailEventDispatcherWinGlibPrivate *d = q->d_func();
    + const int localSerialNumber = d->serialNumber.load();
    + if (HIWORD(GetQueueStatus(QS_TIMER | QS_INPUT | QS_RAWINPUT)) == 0) {
    + // no more input or timer events in the message queue, we can allow posted events to be sent normally now
    + if (d->sendPostedEventsWindowsTimerId != 0) {
    + // stop the timer to send posted events, since we now allow the WM_QT_SENDPOSTEDEVENTS message
    + KillTimer(d->internalHwnd, d->sendPostedEventsWindowsTimerId);
    + d->sendPostedEventsWindowsTimerId = 0;
    + }
    + (void) d->wakeUps.fetchAndStoreRelease(0);
    + if (localSerialNumber != d->lastSerialNumber
    + // if this message IS the one that triggers sendPostedEvents(), no need to post it again
    + && (msg->hwnd != d->internalHwnd
    + || msg->message != WM_QT_SENDPOSTEDEVENTS)) {
    + PostMessage(d->internalHwnd, WM_QT_SENDPOSTEDEVENTS, 0, 0);
    + }
    + } else if (d->sendPostedEventsWindowsTimerId == 0
    + && localSerialNumber != d->lastSerialNumber) {
    + // start a special timer to continue delivering posted events while
    + // there are still input and timer messages in the message queue
    + d->sendPostedEventsWindowsTimerId = SetTimer(d->internalHwnd,
    + SendPostedEventsWindowsTimerId,
    + 0, // we specify zero, but Windows uses USER_TIMER_MINIMUM
    + NULL);
    + // we don't check the return value of SetTimer()... if creating the timer failed, there's little
    + // we can do. we just have to accept that posted events will be starved
    + }
    + }
    + }
    +#ifdef Q_OS_WINCE
    + return 0;
    +#else
    + return CallNextHookEx(0, code, wp, lp);
    +#endif
    +}
    +
    +static HWND qt_create_internal_window(const QuailEventDispatcherWinGlib *eventDispatcher)
    +{
    + // make sure that multiple Qt's can coexist in the same process
    + QString className = QLatin1String("QuailEventDispatcherWinGlib_Internal_Widget") + QString::number(quintptr(qt_internal_proc));
    +
    + WNDCLASS wc;
    + wc.style = 0;
    + wc.lpfnWndProc = qt_internal_proc;
    + wc.cbClsExtra = 0;
    + wc.cbWndExtra = 0;
    + wc.hInstance = qWinAppInst();
    + wc.hIcon = 0;
    + wc.hCursor = 0;
    + wc.hbrBackground = 0;
    + wc.lpszMenuName = NULL;
    + wc.lpszClassName = reinterpret_cast<const wchar_t *> (className.utf16());
    +
    + RegisterClass(&wc);
    +#ifdef Q_OS_WINCE
    + HWND parent = 0;
    +#else
    + HWND parent = HWND_MESSAGE;
    +#endif
    + HWND wnd = CreateWindow(wc.lpszClassName, // classname
    + wc.lpszClassName, // window name
    + 0, // style
    + 0, 0, 0, 0, // geometry
    + parent, // parent
    + 0, // menu handle
    + qWinAppInst(), // application
    + 0); // windows creation data.
    +
    + if (!wnd) {
    + qWarning("QEventDispatcher: Failed to create QuailEventDispatcherWinGlib internal window: %d\n", (int)GetLastError());
    + }
    +
    +#ifdef GWLP_USERDATA
    + SetWindowLongPtr(wnd, GWLP_USERDATA, (LONG_PTR)eventDispatcher);
    +#else
    + SetWindowLong(wnd, GWL_USERDATA, (LONG)eventDispatcher);
    +#endif
    +
    + return wnd;
    +}
    +
    +void QuailEventDispatcherWinGlibPrivate::registerTimer(WinTimerInfo *t)
    +{
    + Q_ASSERT(internalHwnd);
    +
    + Q_Q(QuailEventDispatcherWinGlib);
    +
    + int ok = 0;
    + uint interval = t->interval;
    + if (interval == 0u) {
    + // optimization for single-shot-zero-timer
    + QCoreApplication::postEvent(q, new QZeroTimerEvent(t->timerId));
    + ok = 1;
    + } else if ((interval < 20u || t->timerType == Qt::PreciseTimer) && qtimeSetEvent) {
    + ok = t->fastTimerId = qtimeSetEvent(interval, 1, qt_fast_timer_proc, (DWORD_PTR)t,
    + TIME_CALLBACK_FUNCTION | TIME_PERIODIC | TIME_KILL_SYNCHRONOUS);
    + } else if (interval >= 20000u || t->timerType == Qt::VeryCoarseTimer) {
    + // round the interval, VeryCoarseTimers only have full second accuracy
    + interval = ((interval + 500)) / 1000 * 1000;
    + }
    + if (ok == 0) {
    + // user normal timers for (Very)CoarseTimers, or if no more multimedia timers available
    + ok = SetTimer(internalHwnd, t->timerId, interval, 0);
    + }
    +
    + t->timeout = qt_msectime() + interval;
    +
    + if (ok == 0)
    + qErrnoWarning("QuailEventDispatcherWinGlib::registerTimer: Failed to create a timer");
    +}
    +
    +void QuailEventDispatcherWinGlibPrivate::unregisterTimer(WinTimerInfo *t)
    +{
    + 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 QuailEventDispatcherWinGlibPrivate::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 QuailEventDispatcherWinGlibPrivate::doWsaAsyncSelect(int socket)
    +{
    + Q_ASSERT(internalHwnd);
    + int sn_event = 0;
    + if (sn_read.contains(socket))
    + sn_event |= FD_READ | FD_CLOSE | FD_ACCEPT;
    + if (sn_write.contains(socket))
    + sn_event |= FD_WRITE | FD_CONNECT;
    + if (sn_except.contains(socket))
    + sn_event |= FD_OOB;
    + // BoundsChecker may emit a warning for WSAAsyncSelect when sn_event == 0
    + // This is a BoundsChecker bug and not a Qt bug
    + WSAAsyncSelect(socket, internalHwnd, sn_event ? int(WM_QT_SOCKETNOTIFIER) : 0, sn_event);
    +}
    +
    +void QuailEventDispatcherWinGlib::createInternalHwnd()
    +{
    + Q_D(QuailEventDispatcherWinGlib);
    +
    + Q_ASSERT(!d->internalHwnd);
    + if (d->internalHwnd)
    + return;
    + d->internalHwnd = qt_create_internal_window(this);
    +
    +#ifndef Q_OS_WINCE
    + // setup GetMessage hook needed to drive our posted events
    + d->getMessageHook = SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC) qt_GetMessageHook, NULL, GetCurrentThreadId());
    + if (!d->getMessageHook) {
    + qFatal("Qt: INTERNALL ERROR: failed to install GetMessage hook");
    + }
    +#endif
    +
    + // 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));
    +
    + // trigger a call to sendPostedEvents()
    + wakeUp();
    +}
    +
    +QuailEventDispatcherWinGlib::QuailEventDispatcherWinGlib(QObject *parent)
    + : QAbstractEventDispatcher(*new QuailEventDispatcherWinGlibPrivate, parent)
    {
    }
    +
    +QuailEventDispatcherWinGlib::QuailEventDispatcherWinGlib(QuailEventDispatcherWinGlibPrivate &dd, QObject *parent)
    + : QAbstractEventDispatcher(dd, parent)
    +{ }
    +
    +QuailEventDispatcherWinGlib::~QuailEventDispatcherWinGlib()
    +{
    +}
    +
    +bool QuailEventDispatcherWinGlib::processEvents(QEventLoop::ProcessEventsFlags flags)
    +{
    + Q_D(QuailEventDispatcherWinGlib);
    +
    + if (!d->internalHwnd)
    + createInternalHwnd();
    +
    + d->interrupt = false;
    + emit awake();
    +
    + bool canWait;
    + bool retVal = false;
    + bool seenWM_QT_SENDPOSTEDEVENTS = false;
    + bool needWM_QT_SENDPOSTEDEVENTS = false;
    + do {
    + DWORD waitRet = 0;
    + HANDLE pHandles[MAXIMUM_WAIT_OBJECTS - 1];
    + QVarLengthArray<MSG> processedTimers;
    + while (!d->interrupt) {
    + DWORD nCount = d->winEventNotifierList.count();
    + Q_ASSERT(nCount < MAXIMUM_WAIT_OBJECTS - 1);
    +
    + MSG msg;
    + bool haveMessage;
    +
    + if (!(flags & QEventLoop::ExcludeUserInputEvents) && !d->queuedUserInputEvents.isEmpty()) {
    + // process queued user input events
    + haveMessage = true;
    + msg = d->queuedUserInputEvents.takeFirst();
    + } else if(!(flags & QEventLoop::ExcludeSocketNotifiers) && !d->queuedSocketEvents.isEmpty()) {
    + // process queued socket events
    + haveMessage = true;
    + msg = d->queuedSocketEvents.takeFirst();
    + } else {
    + haveMessage = PeekMessage(&msg, 0, 0, 0, PM_REMOVE);
    + if (haveMessage && (flags & QEventLoop::ExcludeUserInputEvents)
    + && ((msg.message >= WM_KEYFIRST
    + && msg.message <= WM_KEYLAST)
    + || (msg.message >= WM_MOUSEFIRST
    + && msg.message <= WM_MOUSELAST)
    + || msg.message == WM_MOUSEWHEEL
    + || msg.message == WM_MOUSEHWHEEL
    + || msg.message == WM_TOUCH
    +#ifndef QT_NO_GESTURES
    + || msg.message == WM_GESTURE
    + || msg.message == WM_GESTURENOTIFY
    +#endif
    + || msg.message == WM_CLOSE)) {
    + // queue user input events for later processing
    + haveMessage = false;
    + d->queuedUserInputEvents.append(msg);
    + }
    + if (haveMessage && (flags & QEventLoop::ExcludeSocketNotifiers)
    + && (msg.message == WM_QT_SOCKETNOTIFIER && msg.hwnd == d->internalHwnd)) {
    + // queue socket events for later processing
    + haveMessage = false;
    + d->queuedSocketEvents.append(msg);
    + }
    + }
    + if (!haveMessage) {
    + // no message - check for signalled objects
    + for (int i=0; i<(int)nCount; i++)
    + pHandles[i] = d->winEventNotifierList.at(i)->handle();
    + waitRet = MsgWaitForMultipleObjectsEx(nCount, pHandles, 0, QS_ALLINPUT, MWMO_ALERTABLE);
    + if ((haveMessage = (waitRet == WAIT_OBJECT_0 + nCount))) {
    + // a new message has arrived, process it
    + continue;
    + }
    + }
    + if (haveMessage) {
    +#ifdef Q_OS_WINCE
    + // WinCE doesn't support hooks at all, so we have to call this by hand :(
    + (void) qt_GetMessageHook(0, PM_REMOVE, (LPARAM) &msg);
    +#endif
    +
    + if (d->internalHwnd == msg.hwnd && msg.message == WM_QT_SENDPOSTEDEVENTS) {
    + if (seenWM_QT_SENDPOSTEDEVENTS) {
    + // when calling processEvents() "manually", we only want to send posted
    + // events once
    + needWM_QT_SENDPOSTEDEVENTS = true;
    + continue;
    + }
    + seenWM_QT_SENDPOSTEDEVENTS = true;
    + } else if (msg.message == WM_TIMER) {
    + // avoid live-lock by keeping track of the timers we've already sent
    + bool found = false;
    + for (int i = 0; !found && i < processedTimers.count(); ++i) {
    + const MSG processed = processedTimers.constData()[i];
    + found = (processed.wParam == msg.wParam && processed.hwnd == msg.hwnd && processed.lParam == msg.lParam);
    + }
    + if (found)
    + continue;
    + processedTimers.append(msg);
    + } else if (msg.message == WM_QUIT) {
    + if (QCoreApplication::instance())
    + QCoreApplication::instance()->quit();
    + return false;
    + }
    +
    + if (!filterNativeEvent(QByteArrayLiteral("windows_generic_MSG"), &msg, 0)) {
    + TranslateMessage(&msg);
    + DispatchMessage(&msg);
    + }
    + } else if (waitRet - WAIT_OBJECT_0 < nCount) {
    + d->activateEventNotifier(d->winEventNotifierList.at(waitRet - WAIT_OBJECT_0));
    + } else {
    + // nothing todo so break
    + break;
    + }
    + retVal = true;
    + }
    +
    + // still nothing - wait for message or signalled objects
    + canWait = (!retVal
    + && !d->interrupt
    + && (flags & QEventLoop::WaitForMoreEvents));
    + if (canWait) {
    + DWORD nCount = d->winEventNotifierList.count();
    + Q_ASSERT(nCount < MAXIMUM_WAIT_OBJECTS - 1);
    + for (int i=0; i<(int)nCount; i++)
    + pHandles[i] = d->winEventNotifierList.at(i)->handle();
    +
    + emit aboutToBlock();
    + waitRet = MsgWaitForMultipleObjectsEx(nCount, pHandles, INFINITE, QS_ALLINPUT, MWMO_ALERTABLE | MWMO_INPUTAVAILABLE);
    + emit awake();
    + if (waitRet - WAIT_OBJECT_0 < nCount) {
    + d->activateEventNotifier(d->winEventNotifierList.at(waitRet - WAIT_OBJECT_0));
    + retVal = true;
    + }
    + }
    + } while (canWait);
    +
    + if (!seenWM_QT_SENDPOSTEDEVENTS && (flags & QEventLoop::EventLoopExec) == 0) {
    + // when called "manually", always send posted events
    + sendPostedEvents();
    + }
    +
    + if (needWM_QT_SENDPOSTEDEVENTS)
    + PostMessage(d->internalHwnd, WM_QT_SENDPOSTEDEVENTS, 0, 0);
    +
    + return retVal;
    +}
    +
    +bool QuailEventDispatcherWinGlib::hasPendingEvents()
    +{
    + MSG msg;
    + return qGlobalPostedEventsCount() || PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
    +}
    +
    +void QuailEventDispatcherWinGlib::registerSocketNotifier(QSocketNotifier *notifier)
    +{
    + Q_ASSERT(notifier);
    + int sockfd = notifier->socket();
    + int type = notifier->type();
    +#ifndef QT_NO_DEBUG
    + if (sockfd < 0) {
    + qWarning("QSocketNotifier: Internal error");
    + return;
    + } else if (notifier->thread() != thread() || thread() != QThread::currentThread()) {
    + qWarning("QSocketNotifier: socket notifiers cannot be enabled from another thread");
    + return;
    + }
    +#endif
    +
    + Q_D(QuailEventDispatcherWinGlib);
    + QSNDict *sn_vec[3] = { &d->sn_read, &d->sn_write, &d->sn_except };
    + QSNDict *dict = sn_vec[type];
    +
    + if (QCoreApplication::closingDown()) // ### d->exitloop?
    + return; // after sn_cleanup, don't reinitialize.
    +
    + if (dict->contains(sockfd)) {
    + const char *t[] = { "Read", "Write", "Exception" };
    + /* Variable "socket" below is a function pointer. */
    + qWarning("QSocketNotifier: Multiple socket notifiers for "
    + "same socket %d and type %s", sockfd, t[type]);
    + }
    +
    + QSockNot *sn = new QSockNot;
    + sn->obj = notifier;
    + sn->fd = sockfd;
    + dict->insert(sn->fd, sn);
    +
    + if (d->internalHwnd)
    + d->doWsaAsyncSelect(sockfd);
    +}
    +
    +void QuailEventDispatcherWinGlib::unregisterSocketNotifier(QSocketNotifier *notifier)
    +{
    + Q_ASSERT(notifier);
    + int sockfd = notifier->socket();
    + int type = notifier->type();
    +#ifndef QT_NO_DEBUG
    + if (sockfd < 0) {
    + qWarning("QSocketNotifier: Internal error");
    + return;
    + } else if (notifier->thread() != thread() || thread() != QThread::currentThread()) {
    + qWarning("QSocketNotifier: socket notifiers cannot be disabled from another thread");
    + return;
    + }
    +#endif
    +
    + Q_D(QuailEventDispatcherWinGlib);
    + QSNDict *sn_vec[3] = { &d->sn_read, &d->sn_write, &d->sn_except };
    + QSNDict *dict = sn_vec[type];
    + QSockNot *sn = dict->value(sockfd);
    + if (!sn)
    + return;
    +
    + dict->remove(sockfd);
    + delete sn;
    +
    + if (d->internalHwnd)
    + d->doWsaAsyncSelect(sockfd);
    +}
    +
    +void QuailEventDispatcherWinGlib::registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject *object)
    +{
    + if (timerId < 1 || interval < 0 || !object) {
    + qWarning("QuailEventDispatcherWinGlib::registerTimer: invalid arguments");
    + return;
    + } else if (object->thread() != thread() || thread() != QThread::currentThread()) {
    + qWarning("QObject::startTimer: timers cannot be started from another thread");
    + return;
    + }
    +
    + Q_D(QuailEventDispatcherWinGlib);
    +
    + WinTimerInfo *t = new WinTimerInfo;
    + t->dispatcher = this;
    + t->timerId = timerId;
    + t->interval = interval;
    + t->timerType = timerType;
    + 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
    +}
    +
    +bool QuailEventDispatcherWinGlib::unregisterTimer(int timerId)
    +{
    + if (timerId < 1) {
    + qWarning("QuailEventDispatcherWinGlib::unregisterTimer: invalid argument");
    + return false;
    + }
    + QThread *currentThread = QThread::currentThread();
    + if (thread() != currentThread) {
    + qWarning("QObject::killTimer: timers cannot be stopped from another thread");
    + return false;
    + }
    +
    + Q_D(QuailEventDispatcherWinGlib);
    + 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;
    +}
    +
    +bool QuailEventDispatcherWinGlib::unregisterTimers(QObject *object)
    +{
    + if (!object) {
    + qWarning("QuailEventDispatcherWinGlib::unregisterTimers: invalid argument");
    + return false;
    + }
    + QThread *currentThread = QThread::currentThread();
    + if (object->thread() != thread() || thread() != currentThread) {
    + qWarning("QObject::killTimers: timers cannot be stopped from another thread");
    + return false;
    + }
    +
    + Q_D(QuailEventDispatcherWinGlib);
    + 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;
    +}
    +
    +QList<QuailEventDispatcherWinGlib::TimerInfo>
    +QuailEventDispatcherWinGlib::registeredTimers(QObject *object) const
    +{
    + if (!object) {
    + qWarning("QuailEventDispatcherWinGlib:registeredTimers: invalid argument");
    + return QList<TimerInfo>();
    + }
    +
    + Q_D(const QuailEventDispatcherWinGlib);
    + 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, t->timerType);
    + }
    + return list;
    +}
    +
    +bool QuailEventDispatcherWinGlib::registerEventNotifier(QWinEventNotifier *notifier)
    +{
    + if (!notifier) {
    + qWarning("QWinEventNotifier: Internal error");
    + return false;
    + } else if (notifier->thread() != thread() || thread() != QThread::currentThread()) {
    + qWarning("QWinEventNotifier: event notifiers cannot be enabled from another thread");
    + return false;
    + }
    +
    + Q_D(QuailEventDispatcherWinGlib);
    +
    + if (d->winEventNotifierList.contains(notifier))
    + return true;
    +
    + if (d->winEventNotifierList.count() >= MAXIMUM_WAIT_OBJECTS - 2) {
    + qWarning("QWinEventNotifier: Cannot have more than %d enabled at one time", MAXIMUM_WAIT_OBJECTS - 2);
    + return false;
    + }
    + d->winEventNotifierList.append(notifier);
    + return true;
    +}
    +
    +void QuailEventDispatcherWinGlib::unregisterEventNotifier(QWinEventNotifier *notifier)
    +{
    + if (!notifier) {
    + qWarning("QWinEventNotifier: Internal error");
    + return;
    + } else if (notifier->thread() != thread() || thread() != QThread::currentThread()) {
    + qWarning("QWinEventNotifier: event notifiers cannot be disabled from another thread");
    + return;
    + }
    +
    + Q_D(QuailEventDispatcherWinGlib);
    +
    + int i = d->winEventNotifierList.indexOf(notifier);
    + if (i != -1)
    + d->winEventNotifierList.takeAt(i);
    +}
    +
    +void QuailEventDispatcherWinGlib::activateEventNotifiers()
    +{
    + Q_D(QuailEventDispatcherWinGlib);
    + //### this could break if events are removed/added in the activation
    + for (int i=0; i<d->winEventNotifierList.count(); i++) {
    +#if !defined(Q_OS_WINCE)
    + if (WaitForSingleObjectEx(d->winEventNotifierList.at(i)->handle(), 0, TRUE) == WAIT_OBJECT_0)
    + d->activateEventNotifier(d->winEventNotifierList.at(i));
    +#else
    + if (WaitForSingleObject(d->winEventNotifierList.at(i)->handle(), 0) == WAIT_OBJECT_0)
    + d->activateEventNotifier(d->winEventNotifierList.at(i));
    +#endif
    + }
    +}
    +
    +int QuailEventDispatcherWinGlib::remainingTime(int timerId)
    +{
    +#ifndef QT_NO_DEBUG
    + if (timerId < 1) {
    + qWarning("QuailEventDispatcherWinGlib::remainingTime: invalid argument");
    + return -1;
    + }
    +#endif
    +
    + Q_D(QuailEventDispatcherWinGlib);
    +
    + if (d->timerVec.isEmpty())
    + return -1;
    +
    + quint64 currentTime = qt_msectime();
    +
    + register WinTimerInfo *t;
    + for (int i=0; i<d->timerVec.size(); i++) {
    + t = d->timerVec.at(i);
    + if (t && t->timerId == timerId) { // timer found
    + if (currentTime < t->timeout) {
    + // time to wait
    + return t->timeout - currentTime;
    + } else {
    + return 0;
    + }
    + }
    + }
    +
    +#ifndef QT_NO_DEBUG
    + qWarning("QuailEventDispatcherWinGlib::remainingTime: timer id %d not found", timerId);
    +#endif
    +
    + return -1;
    +}
    +
    +void QuailEventDispatcherWinGlib::wakeUp()
    +{
    + Q_D(QuailEventDispatcherWinGlib);
    + d->serialNumber.ref();
    + if (d->internalHwnd && d->wakeUps.testAndSetAcquire(0, 1)) {
    + // post a WM_QT_SENDPOSTEDEVENTS to this thread if there isn't one already pending
    + PostMessage(d->internalHwnd, WM_QT_SENDPOSTEDEVENTS, 0, 0);
    + }
    +}
    +
    +void QuailEventDispatcherWinGlib::interrupt()
    +{
    + Q_D(QuailEventDispatcherWinGlib);
    + d->interrupt = true;
    + wakeUp();
    +}
    +
    +void QuailEventDispatcherWinGlib::flush()
    +{ }
    +
    +void QuailEventDispatcherWinGlib::startingUp()
    +{ }
    +
    +void QuailEventDispatcherWinGlib::closingDown()
    +{
    + Q_D(QuailEventDispatcherWinGlib);
    +
    + // clean up any socketnotifiers
    + while (!d->sn_read.isEmpty())
    + unregisterSocketNotifier((*(d->sn_read.begin()))->obj);
    + while (!d->sn_write.isEmpty())
    + unregisterSocketNotifier((*(d->sn_write.begin()))->obj);
    + while (!d->sn_except.isEmpty())
    + unregisterSocketNotifier((*(d->sn_except.begin()))->obj);
    +
    + // clean up any timers
    + for (int i = 0; i < d->timerVec.count(); ++i)
    + d->unregisterTimer(d->timerVec.at(i));
    + d->timerVec.clear();
    + d->timerDict.clear();
    +
    +#ifndef Q_OS_WINCE
    + if (d->getMessageHook)
    + UnhookWindowsHookEx(d->getMessageHook);
    + d->getMessageHook = 0;
    +#endif
    +}
    +
    +bool QuailEventDispatcherWinGlib::event(QEvent *e)
    +{
    + Q_D(QuailEventDispatcherWinGlib);
    + 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);
    +}
    +
    +void QuailEventDispatcherWinGlib::sendPostedEvents()
    +{
    + Q_D(QuailEventDispatcherWinGlib);
    + QCoreApplicationPrivate::sendPostedEvents(0, 0, d->threadData);
    +}
    --- a/src/QuailWinGlibEventLoop.h Fri Sep 13 13:58:43 2013 +0100
    +++ b/src/QuailWinGlibEventLoop.h Fri Sep 13 14:11:27 2013 +0100
    @@ -56,7 +56,7 @@
    static bool versionSupported();
    protected:
    - QEventDispatcherWinGlib(QuailEventDispatcherWinGlibPrivate &dd, QObject *parent = 0);
    + QuailEventDispatcherWinGlib(QuailEventDispatcherWinGlibPrivate &dd, QObject *parent = 0);
    virtual void sendPostedEvents();
    private:
    @@ -99,11 +99,11 @@
    class Q_CORE_EXPORT QuailEventDispatcherWinGlibPrivate : public QAbstractEventDispatcherPrivate
    {
    - Q_DECLARE_PUBLIC(QEventDispatcherWinGlib)
    + Q_DECLARE_PUBLIC(QuailEventDispatcherWinGlib)
    public:
    - QEventDispatcherWinGlibPrivate();
    - QEventDispatcherWinGlibPrivate(GMainContext *context = 0);
    - ~QEventDispatcherWinGlibPrivate();
    + QuailEventDispatcherWinGlibPrivate();
    + QuailEventDispatcherWinGlibPrivate(GMainContext *context = 0);
    + ~QuailEventDispatcherWinGlibPrivate();
    GMainContext *mainContext;
    GPostEventSource *postEventSource;