/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qeventdispatcher_win_p.h"

#include "qcoreapplication.h"

#include "qhash.h"

#include "qlibrary.h"

#include "qpair.h"

#include "qset.h"

#include "qsocketnotifier.h"

#include "qvarlengtharray.h"

#include "qwineventnotifier_p.h"

#include "qabstracteventdispatcher_p.h"

#include "qcoreapplication_p.h"

#include <private/qthread_p.h>

#include <private/qmutexpool_p.h>

QT_BEGIN_NAMESPACE

HINSTANCE qWinAppInst();

extern uint qGlobalPostedEventsCount();

#ifndef TIME_KILL_SYNCHRONOUS

#  define TIME_KILL_SYNCHRONOUS 0x0100

#endif

#ifndef QS_RAWINPUT

#  define QS_RAWINPUT 0x0400

#endif

#ifndef WM_TOUCH

#  define WM_TOUCH 0x0240

#endif

#ifndef WM_GESTURE

#  define WM_GESTURE 0x0119

#  define WM_GESTURENOTIFY 0x011A

#endif

enum {

    WM_QT_SOCKETNOTIFIER = WM_USER,

    WM_QT_SENDPOSTEDEVENTS = WM_USER + 1,

    SendPostedEventsTimerId = ~1u

};

#if defined(Q_OS_WINCE)

QT_BEGIN_INCLUDE_NAMESPACE

#include <winsock.h>

// Asynchronous Winsocks ------------------------------------------

#ifndef QT_NO_THREAD

#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 QEventDispatcherWin32Private;

struct QSockNot {

    QSocketNotifier *obj;

    int fd;

};

typedef QHash<int, QSockNot *> QSNDict;

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

    }

}

class QEventDispatcherWin32Private : public QAbstractEventDispatcherPrivate

{

    Q_DECLARE_PUBLIC(QEventDispatcherWin32)

public:

    QEventDispatcherWin32Private();

    ~QEventDispatcherWin32Private();

    DWORD threadId;

    bool interrupt;

    // internal window handle used for socketnotifiers/timers/etc

    HWND internalHwnd;

    HHOOK getMessageHook;

    // for controlling when to send posted events

    QAtomicInt serialNumber;

    int lastSerialNumber;

    QAtomicInt wakeUps;

    // timers

    WinTimerVec timerVec;

    WinTimerDict timerDict;

    void registerTimer(WinTimerInfo *t);

    void unregisterTimer(WinTimerInfo *t, bool closingDown = false);

    void sendTimerEvent(int timerId);

    // socket notifiers

    QSNDict sn_read;

    QSNDict sn_write;

    QSNDict sn_except;

    void doWsaAsyncSelect(int socket);

    QList<QWinEventNotifier *> winEventNotifierList;

    void activateEventNotifier(QWinEventNotifier * wen);

    QList<MSG> queuedUserInputEvents;

    QList<MSG> queuedSocketEvents;

};

QEventDispatcherWin32Private::QEventDispatcherWin32Private()

    : threadId(GetCurrentThreadId()), interrupt(false), internalHwnd(0), getMessageHook(0), serialNumber(0), lastSerialNumber(0), wakeUps(0)

{

    resolveTimerAPI();

}

QEventDispatcherWin32Private::~QEventDispatcherWin32Private()

{

    if (internalHwnd)

        DestroyWindow(internalHwnd);

    QString className = QLatin1String("QEventDispatcherWin32_Internal_Widget") + QString::number(quintptr(qt_internal_proc));

    UnregisterClass((wchar_t*)className.utf16(), qWinAppInst());

}

void QEventDispatcherWin32Private::activateEventNotifier(QWinEventNotifier * wen)

{

    QEvent event(QEvent::WinEventAct);

    QCoreApplication::sendEvent(wen, &event);

}

// ### Qt 5: remove

Q_CORE_EXPORT bool winPeekMessage(MSG* msg, HWND hWnd, UINT wMsgFilterMin,

                     UINT wMsgFilterMax, UINT wRemoveMsg)

{

    return PeekMessage(msg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);

}

// ### Qt 5: remove

Q_CORE_EXPORT bool winPostMessage(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)

{

    return PostMessage(hWnd, msg, wParam, lParam);

}

// ### Qt 5: remove

Q_CORE_EXPORT bool winGetMessage(MSG* msg, HWND hWnd, UINT wMsgFilterMin,

                     UINT wMsgFilterMax)

{

    return GetMessage(msg, hWnd, wMsgFilterMin, wMsgFilterMax);

}

// This function is called by a workerthread

void WINAPI 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 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;

    QCoreApplication *app = QCoreApplication::instance();

    long result;

    if (!app) {

        if (message == WM_TIMER)

            KillTimer(hwnd, wp);

        return 0;

    } else if (app->filterEvent(&msg, &result)) {

        return result;

    }

#ifdef GWLP_USERDATA

    QEventDispatcherWin32 *q = (QEventDispatcherWin32 *) GetWindowLongPtr(hwnd, GWLP_USERDATA);

#else

    QEventDispatcherWin32 *q = (QEventDispatcherWin32 *) GetWindowLong(hwnd, GWL_USERDATA);

#endif

    QEventDispatcherWin32Private *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_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) {

            Q_ASSERT(d != 0);

            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) {    

        Q_ASSERT(d != 0);

        d->sendTimerEvent(wp);

        return 0;

    } else if (message == WM_QT_SENDPOSTEDEVENTS) {

        int localSerialNumber = d->serialNumber;

        if (localSerialNumber != d->lastSerialNumber) {

            d->lastSerialNumber = localSerialNumber;

            QCoreApplicationPrivate::sendPostedEvents(0, 0, d->threadData);

        }

        return 0;

    }

    return DefWindowProc(hwnd, message, wp, lp);

}

LRESULT CALLBACK qt_GetMessageHook(int code, WPARAM wp, LPARAM lp)

{

    if (wp == PM_REMOVE) {

        QEventDispatcherWin32 *q = qobject_cast<QEventDispatcherWin32 *>(QAbstractEventDispatcher::instance());

        Q_ASSERT(q != 0);

        if (q) {

            QEventDispatcherWin32Private *d = q->d_func();

            int localSerialNumber = d->serialNumber;

            if (HIWORD(GetQueueStatus(QS_INPUT | QS_RAWINPUT | QS_TIMER)) == 0) {

                // no more input or timer events in the message queue, we can allow posted events to be

                // sent now

                (void) d->wakeUps.fetchAndStoreRelease(0);

                MSG *msg = (MSG *) lp;

                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);

                }

            }

        }

    }

#ifdef Q_OS_WINCE