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

**

** Copyright (C) 2009 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

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

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

    // event notifier

    QWinEventNotifier wakeUpNotifier;

    QList<QWinEventNotifier *> winEventNotifierList;

    void activateEventNotifier(QWinEventNotifier * wen);

    QList<MSG> queuedUserInputEvents;

    QList<MSG> queuedSocketEvents;

};

QEventDispatcherWin32Private::QEventDispatcherWin32Private()

    : threadId(GetCurrentThreadId()), interrupt(false), internalHwnd(0)

{

    resolveTimerAPI();

    wakeUpNotifier.setHandle(CreateEvent(0, FALSE, FALSE, 0));

    if (!wakeUpNotifier.handle())

        qWarning("QEventDispatcher: Creating QEventDispatcherWin32Private wakeup event failed");

}

QEventDispatcherWin32Private::~QEventDispatcherWin32Private()

{

    wakeUpNotifier.setEnabled(false);

    CloseHandle(wakeUpNotifier.handle());

    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;

    } 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

            QEventDispatcherWin32 *eventDispatcher =

                (QEventDispatcherWin32 *) GetWindowLongPtr(hwnd, GWLP_USERDATA);

    #else

            QEventDispatcherWin32 *eventDispatcher =

                (QEventDispatcherWin32 *) GetWindowLong(hwnd, GWL_USERDATA);

    #endif

            if (eventDispatcher) {

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

        QEventDispatcherWin32 *eventDispatcher =

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

        Q_ASSERT(eventDispatcher != 0);

        QEventDispatcherWin32Private *d = eventDispatcher->d_func();

        d->sendTimerEvent(wp);

        return 0;

    }

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

}

static HWND qt_create_internal_window(const QEventDispatcherWin32 *eventDispatcher)

{

    // make sure that multiple Qt's can coexist in the same process

    QString className = QLatin1String("QEventDispatcherWin32_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);

    HWND wnd = CreateWindow(wc.lpszClassName,  // classname

                            wc.lpszClassName,  // window name

                            0,                 // style

                            0, 0, 0, 0,        // geometry

                            0,                 // parent

                            0,                 // menu handle

                            qWinAppInst(),     // application

                            0);                // windows creation data.

#ifdef GWLP_USERDATA

    SetWindowLongPtr(wnd, GWLP_USERDATA, (LONG_PTR)eventDispatcher);

#else

    SetWindowLong(wnd, GWL_USERDATA, (LONG)eventDispatcher);

#endif

    if (!wnd) {