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

**

** 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 "qcoreapplication.h"

#include "qcoreapplication_p.h"

#include "qstringlist.h"

#include "qt_windows.h"

#include "qvector.h"

#include "qmutex.h"

#include "qfileinfo.h"

#include "qcorecmdlineargs_p.h"

#include <private/qthread_p.h>

#include <ctype.h>

QT_BEGIN_NAMESPACE

char         appFileName[MAX_PATH];                // application file name

char         theAppName[MAX_PATH];                        // application name

HINSTANCE appInst        = 0;                // handle to app instance

HINSTANCE appPrevInst        = 0;                // handle to prev app instance

int appCmdShow = 0;

bool usingWinMain = false;  // whether the qWinMain() is used or not

Q_CORE_EXPORT HINSTANCE qWinAppInst()                // get Windows app handle

{

    return appInst;

}

Q_CORE_EXPORT HINSTANCE qWinAppPrevInst()                // get Windows prev app handle

{

    return appPrevInst;

}

Q_CORE_EXPORT int qWinAppCmdShow()                        // get main window show command

{

    return appCmdShow;

}

Q_CORE_EXPORT QString qAppFileName()                // get application file name

{

    // We do MAX_PATH + 2 here, and request with MAX_PATH + 1, so we can handle all paths

    // up to, and including MAX_PATH size perfectly fine with string termination, as well

    // as easily detect if the file path is indeed larger than MAX_PATH, in which case we

    // need to use the heap instead. This is a work-around, since contrary to what the

    // MSDN documentation states, GetModuleFileName sometimes doesn't set the

    // ERROR_INSUFFICIENT_BUFFER error number, and we thus cannot rely on this value if

    // GetModuleFileName(0, buffer, MAX_PATH) == MAX_PATH.

    // GetModuleFileName(0, buffer, MAX_PATH + 1) == MAX_PATH just means we hit the normal

    // file path limit, and we handle it normally, if the result is MAX_PATH + 1, we use

    // heap (even if the result _might_ be exactly MAX_PATH + 1, but that's ok).

    wchar_t buffer[MAX_PATH + 2];

    DWORD v = GetModuleFileName(0, buffer, MAX_PATH + 1);

    buffer[MAX_PATH + 1] = 0;

    if (v == 0)

        return QString();

    else if (v <= MAX_PATH)

        return QString::fromWCharArray(buffer);

    // MAX_PATH sized buffer wasn't large enough to contain the full path, use heap

    wchar_t *b = 0;

    int i = 1;

    size_t size;

    do {

        ++i;

        size = MAX_PATH * i;

        b = reinterpret_cast<wchar_t *>(realloc(b, (size + 1) * sizeof(wchar_t)));

        if (b)

            v = GetModuleFileName(NULL, b, size);

    } while (b && v == size);

    if (b)

        *(b + size) = 0;

    QString res = QString::fromWCharArray(b);

    free(b);

    return res;

}

void set_winapp_name()

{

    static bool already_set = false;

    if (!already_set) {

        already_set = true;

        QString moduleName = qAppFileName();

        QByteArray filePath = moduleName.toLocal8Bit();

        QByteArray fileName = QFileInfo(moduleName).baseName().toLocal8Bit();

        memcpy(appFileName, filePath.constData(), filePath.length());

        memcpy(theAppName, fileName.constData(), fileName.length());

        if (appInst == 0)

            appInst = GetModuleHandle(0);

    }

}

QString QCoreApplicationPrivate::appName() const

{

    return QFileInfo(qAppFileName()).baseName();

}

class QWinMsgHandlerCriticalSection

{

    CRITICAL_SECTION cs;

public:

    QWinMsgHandlerCriticalSection()

    { InitializeCriticalSection(&cs); }

    ~QWinMsgHandlerCriticalSection()

    { DeleteCriticalSection(&cs); }

    void lock()

    { EnterCriticalSection(&cs); }

    void unlock()

    { LeaveCriticalSection(&cs); }

};

Q_CORE_EXPORT void qWinMsgHandler(QtMsgType t, const char* str)

{

    Q_UNUSED(t);

    // OutputDebugString is not threadsafe.

    // cannot use QMutex here, because qWarning()s in the QMutex

    // implementation may cause this function to recurse

    static QWinMsgHandlerCriticalSection staticCriticalSection;

    if (!str)

        str = "(null)";

    staticCriticalSection.lock();

    QString s(QString::fromLocal8Bit(str));

    s += QLatin1Char('\n');

    OutputDebugString((wchar_t*)s.utf16());

    staticCriticalSection.unlock();

}

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

  qWinMain() - Initializes Windows. Called from WinMain() in qtmain_win.cpp

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

#if defined(Q_OS_WINCE)

Q_CORE_EXPORT void __cdecl qWinMain(HINSTANCE instance, HINSTANCE prevInstance, LPSTR cmdParam,

               int cmdShow, int &argc, QVector<char *> &argv)

#else

Q_CORE_EXPORT

void qWinMain(HINSTANCE instance, HINSTANCE prevInstance, LPSTR cmdParam,

               int cmdShow, int &argc, QVector<char *> &argv)

#endif

{

    static bool already_called = false;

    if (already_called) {

        qWarning("Qt: Internal error: qWinMain should be called only once");

        return;

    }

    already_called = true;

    usingWinMain = true;

  // Install default debug handler

    qInstallMsgHandler(qWinMsgHandler);

  // Create command line

    argv = qWinCmdLine<char>(cmdParam, int(strlen(cmdParam)), argc);

    // Get Windows parameters

    appInst = instance;

    appPrevInst = prevInstance;

    appCmdShow = cmdShow;

    set_winapp_name();

}

/*!

    The message procedure calls this function for every message

    received. Reimplement this function if you want to process window

    messages \a msg that are not processed by Qt. If you don't want

    the event to be processed by Qt, then return true and set \a result

    to the value that the window procedure should return. Otherwise

    return false.

    It is only directly addressed messages that are filtered. To

    handle system wide messages, such as messages from a registered

    hot key, you need to install an event filter on the event

    dispatcher, which is returned from

    QAbstractEventDispatcher::instance().

*/

bool QCoreApplication::winEventFilter(MSG *msg, long *result)        // Windows event filter

{

    Q_UNUSED(msg);

    Q_UNUSED(result);

    return false;

}

void QCoreApplicationPrivate::removePostedTimerEvent(QObject *object, int timerId)

{

    QThreadData *data = object->d_func()->threadData;

    QMutexLocker locker(&data->postEventList.mutex);

    if (data->postEventList.size() == 0)

        return;

    for (int i = 0; i < data->postEventList.size(); ++i) {

        const QPostEvent & pe = data->postEventList.at(i);

        if (pe.receiver == object

            && pe.event

            && (pe.event->type() == QEvent::Timer || pe.event->type() == QEvent::ZeroTimerEvent)

            && static_cast<QTimerEvent *>(pe.event)->timerId() == timerId) {

                --pe.receiver->d_func()->postedEvents;

                pe.event->posted = false;

                delete pe.event;

                const_cast<QPostEvent &>(pe).event = 0;

                return;

            }

    }

}

#if defined(Q_WS_WIN) && !defined(QT_NO_DEBUG_STREAM)

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

  Convenience functions for convert WM_* messages into human readable strings,

  including a nifty QDebug operator<< for simpel QDebug() << msg output.

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

QT_BEGIN_INCLUDE_NAMESPACE

#include <windowsx.h>

#include "qdebug.h"

QT_END_INCLUDE_NAMESPACE

#if !defined(GET_X_LPARAM)

#  define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))

#  define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))

#endif

#ifdef _WIN32_WCE

#  ifndef WM_NCACTIVATE

#    define WM_NCACTIVATE 0x86

#  endif

#endif

// The values below should never change. Note that none of the usual

// WM_...FIRST & WM_...LAST values are in the list, as they normally have other

// WM_... representations

struct KnownWM {

    uint WM;

    const char* str;

} knownWM[] =

{{ 0x0000, "WM_NULL" },

 { 0x0001, "WM_CREATE" },

 { 0x0002, "WM_DESTROY" },

 { 0x0003, "WM_MOVE" },

 { 0x0005, "WM_SIZE" },

 { 0x0006, "WM_ACTIVATE" },

 { 0x0007, "WM_SETFOCUS" },

 { 0x0008, "WM_KILLFOCUS" },

 { 0x000A, "WM_ENABLE" },

 { 0x000B, "WM_SETREDRAW" },

 { 0x000C, "WM_SETTEXT" },

 { 0x000D, "WM_GETTEXT" },

 { 0x000E, "WM_GETTEXTLENGTH" },

 { 0x000F, "WM_PAINT" },

 { 0x0010, "WM_CLOSE" },

 { 0x0011, "WM_QUERYENDSESSION" },

 { 0x0013, "WM_QUERYOPEN" },

 { 0x0016, "WM_ENDSESSION" },

 { 0x0012, "WM_QUIT" },

 { 0x0014, "WM_ERASEBKGND" },

 { 0x0015, "WM_SYSCOLORCHANGE" },

 { 0x0018, "WM_SHOWWINDOW" },

 { 0x001A, "WM_WININICHANGE" },

 { 0x001B, "WM_DEVMODECHANGE" },

 { 0x001C, "WM_ACTIVATEAPP" },

 { 0x001D, "WM_FONTCHANGE" },

 { 0x001E, "WM_TIMECHANGE" },

 { 0x001F, "WM_CANCELMODE" },

 { 0x0020, "WM_SETCURSOR" },

 { 0x0021, "WM_MOUSEACTIVATE" },

 { 0x0022, "WM_CHILDACTIVATE" },

 { 0x0023, "WM_QUEUESYNC" },

 { 0x0024, "WM_GETMINMAXINFO" },

 { 0x0026, "WM_PAINTICON" },

 { 0x0027, "WM_ICONERASEBKGND" },

 { 0x0028, "WM_NEXTDLGCTL" },

 { 0x002A, "WM_SPOOLERSTATUS" },

 { 0x002B, "WM_DRAWITEM" },

 { 0x002C, "WM_MEASUREITEM" },

 { 0x002D, "WM_DELETEITEM" },

 { 0x002E, "WM_VKEYTOITEM" },

 { 0x002F, "WM_CHARTOITEM" },

 { 0x0030, "WM_SETFONT" },

 { 0x0031, "WM_GETFONT" },

 { 0x0032, "WM_SETHOTKEY" },

 { 0x0033, "WM_GETHOTKEY" },

 { 0x0037, "WM_QUERYDRAGICON" },

 { 0x0039, "WM_COMPAREITEM" },

 { 0x003D, "WM_GETOBJECT" },

 { 0x0041, "WM_COMPACTING" },

 { 0x0044, "WM_COMMNOTIFY" },

 { 0x0046, "WM_WINDOWPOSCHANGING" },

 { 0x0047, "WM_WINDOWPOSCHANGED" },

 { 0x0048, "WM_POWER" },

 { 0x004A, "WM_COPYDATA" },

 { 0x004B, "WM_CANCELJOURNAL" },

 { 0x004E, "WM_NOTIFY" },

 { 0x0050, "WM_INPUTLANGCHANGEREQUEST" },

 { 0x0051, "WM_INPUTLANGCHANGE" },

 { 0x0052, "WM_TCARD" },

 { 0x0053, "WM_HELP" },

 { 0x0054, "WM_USERCHANGED" },

 { 0x0055, "WM_NOTIFYFORMAT" },

 { 0x007B, "WM_CONTEXTMENU" },

 { 0x007C, "WM_STYLECHANGING" },

 { 0x007D, "WM_STYLECHANGED" },

 { 0x007E, "WM_DISPLAYCHANGE" },

 { 0x007F, "WM_GETICON" },

 { 0x0080, "WM_SETICON" },

 { 0x0081, "WM_NCCREATE" },

 { 0x0082, "WM_NCDESTROY" },

 { 0x0083, "WM_NCCALCSIZE" },

 { 0x0084, "WM_NCHITTEST" },

 { 0x0085, "WM_NCPAINT" },

 { 0x0086, "WM_NCACTIVATE" },

 { 0x0087, "WM_GETDLGCODE" },

 { 0x0088, "WM_SYNCPAINT" },

 { 0x00A0, "WM_NCMOUSEMOVE" },

 { 0x00A1, "WM_NCLBUTTONDOWN" },

 { 0x00A2, "WM_NCLBUTTONUP" },

 { 0x00A3, "WM_NCLBUTTONDBLCLK" },

 { 0x00A4, "WM_NCRBUTTONDOWN" },

 { 0x00A5, "WM_NCRBUTTONUP" },

 { 0x00A6, "WM_NCRBUTTONDBLCLK" },

 { 0x00A7, "WM_NCMBUTTONDOWN" },

 { 0x00A8, "WM_NCMBUTTONUP" },

 { 0x00A9, "WM_NCMBUTTONDBLCLK" },

 { 0x00AB, "WM_NCXBUTTONDOWN" },

 { 0x00AC, "WM_NCXBUTTONUP" },

 { 0x00AD, "WM_NCXBUTTONDBLCLK" },

 { 0x00FF, "WM_INPUT" },

 { 0x0100, "WM_KEYDOWN" },

 { 0x0101, "WM_KEYUP" },

 { 0x0102, "WM_CHAR" },

 { 0x0103, "WM_DEADCHAR" },

 { 0x0104, "WM_SYSKEYDOWN" },

 { 0x0105, "WM_SYSKEYUP" },

 { 0x0106, "WM_SYSCHAR" },

 { 0x0107, "WM_SYSDEADCHAR" },

 { 0x0109, "WM_UNICHAR" },

 { 0x010D, "WM_IME_STARTCOMPOSITION" },

 { 0x010E, "WM_IME_ENDCOMPOSITION" },

 { 0x010F, "WM_IME_COMPOSITION" },

 { 0x0110, "WM_INITDIALOG" },

 { 0x0111, "WM_COMMAND" },

 { 0x0112, "WM_SYSCOMMAND" },

 { 0x0113, "WM_TIMER" },

 { 0x0114, "WM_HSCROLL" },

 { 0x0115, "WM_VSCROLL" },

 { 0x0116, "WM_INITMENU" },

 { 0x0117, "WM_INITMENUPOPUP" },

 { 0x011F, "WM_MENUSELECT" },

 { 0x0120, "WM_MENUCHAR" },

 { 0x0121, "WM_ENTERIDLE" },

 { 0x0122, "WM_MENURBUTTONUP" },

 { 0x0123, "WM_MENUDRAG" },

 { 0x0124, "WM_MENUGETOBJECT" },

 { 0x0125, "WM_UNINITMENUPOPUP" },

 { 0x0126, "WM_MENUCOMMAND" },

 { 0x0127, "WM_CHANGEUISTATE" },

 { 0x0128, "WM_UPDATEUISTATE" },

 { 0x0129, "WM_QUERYUISTATE" },

 { 0x0132, "WM_CTLCOLORMSGBOX" },

 { 0x0133, "WM_CTLCOLOREDIT" },

 { 0x0134, "WM_CTLCOLORLISTBOX" },

 { 0x0135, "WM_CTLCOLORBTN" },

 { 0x0136, "WM_CTLCOLORDLG" },

 { 0x0137, "WM_CTLCOLORSCROLLBAR" },

 { 0x0138, "WM_CTLCOLORSTATIC" },

 { 0x0200, "WM_MOUSEMOVE" },

 { 0x0201, "WM_LBUTTONDOWN" },

 { 0x0202, "WM_LBUTTONUP" },

 { 0x0203, "WM_LBUTTONDBLCLK" },

 { 0x0204, "WM_RBUTTONDOWN" },

 { 0x0205, "WM_RBUTTONUP" },

 { 0x0206, "WM_RBUTTONDBLCLK" },

 { 0x0207, "WM_MBUTTONDOWN" },

 { 0x0208, "WM_MBUTTONUP" },

 { 0x0209, "WM_MBUTTONDBLCLK" },

 { 0x020A, "WM_MOUSEWHEEL" },

 { 0x020B, "WM_XBUTTONDOWN" },

 { 0x020C, "WM_XBUTTONUP" },

 { 0x020D, "WM_XBUTTONDBLCLK" },

 { 0x020E, "WM_MOUSEHWHEEL" },

 { 0x0210, "WM_PARENTNOTIFY" },

 { 0x0211, "WM_ENTERMENULOOP" },

 { 0x0212, "WM_EXITMENULOOP" },

 { 0x0213, "WM_NEXTMENU" },

 { 0x0214, "WM_SIZING" },

 { 0x0215, "WM_CAPTURECHANGED" },

 { 0x0216, "WM_MOVING" },

 { 0x0218, "WM_POWERBROADCAST" },

 { 0x0219, "WM_DEVICECHANGE" },

 { 0x0220, "WM_MDICREATE" },

 { 0x0221, "WM_MDIDESTROY" },

 { 0x0222, "WM_MDIACTIVATE" },

 { 0x0223, "WM_MDIRESTORE" },

 { 0x0224, "WM_MDINEXT" },

 { 0x0225, "WM_MDIMAXIMIZE" },

 { 0x0226, "WM_MDITILE" },

 { 0x0227, "WM_MDICASCADE" },

 { 0x0228, "WM_MDIICONARRANGE" },

 { 0x0229, "WM_MDIGETACTIVE" },

 { 0x0230, "WM_MDISETMENU" },

 { 0x0231, "WM_ENTERSIZEMOVE" },

 { 0x0232, "WM_EXITSIZEMOVE" },

 { 0x0233, "WM_DROPFILES" },

 { 0x0234, "WM_MDIREFRESHMENU" },

 { 0x0281, "WM_IME_SETCONTEXT" },

 { 0x0282, "WM_IME_NOTIFY" },

 { 0x0283, "WM_IME_CONTROL" },

 { 0x0284, "WM_IME_COMPOSITIONFULL" },

 { 0x0285, "WM_IME_SELECT" },

 { 0x0286, "WM_IME_CHAR" },

 { 0x0288, "WM_IME_REQUEST" },

 { 0x0290, "WM_IME_KEYDOWN" },

 { 0x0291, "WM_IME_KEYUP" },

 { 0x02A0, "WM_NCMOUSEHOVER" },

 { 0x02A1, "WM_MOUSEHOVER" },

 { 0x02A2, "WM_NCMOUSELEAVE" },

 { 0x02A3, "WM_MOUSELEAVE" },

 { 0x02B1, "WM_WTSSESSION_CHANGE" },

 { 0x02C0, "WM_TABLET_FIRST" },

 { 0x02C1, "WM_TABLET_FIRST + 1" },

 { 0x02C2, "WM_TABLET_FIRST + 2" },

 { 0x02C3, "WM_TABLET_FIRST + 3" },

 { 0x02C4, "WM_TABLET_FIRST + 4" },

 { 0x02C5, "WM_TABLET_FIRST + 5" },

 { 0x02C6, "WM_TABLET_FIRST + 6" },

 { 0x02C7, "WM_TABLET_FIRST + 7" },

 { 0x02C8, "WM_TABLET_FIRST + 8" },

 { 0x02C9, "WM_TABLET_FIRST + 9" },

 { 0x02CA, "WM_TABLET_FIRST + 10" },

 { 0x02CB, "WM_TABLET_FIRST + 11" },

 { 0x02CC, "WM_TABLET_FIRST + 12" },

 { 0x02CD, "WM_TABLET_FIRST + 13" },

 { 0x02CE, "WM_TABLET_FIRST + 14" },

 { 0x02CF, "WM_TABLET_FIRST + 15" },

 { 0x02D0, "WM_TABLET_FIRST + 16" },

 { 0x02D1, "WM_TABLET_FIRST + 17" },

 { 0x02D2, "WM_TABLET_FIRST + 18" },

 { 0x02D3, "WM_TABLET_FIRST + 19" },

 { 0x02D4, "WM_TABLET_FIRST + 20" },

 { 0x02D5, "WM_TABLET_FIRST + 21" },

 { 0x02D6, "WM_TABLET_FIRST + 22" },

 { 0x02D7, "WM_TABLET_FIRST + 23" },

 { 0x02D8, "WM_TABLET_FIRST + 24" },

 { 0x02D9, "WM_TABLET_FIRST + 25" },

 { 0x02DA, "WM_TABLET_FIRST + 26" },

 { 0x02DB, "WM_TABLET_FIRST + 27" },

 { 0x02DC, "WM_TABLET_FIRST + 28" },

 { 0x02DD, "WM_TABLET_FIRST + 29" },

 { 0x02DE, "WM_TABLET_FIRST + 30" },

 { 0x02DF, "WM_TABLET_LAST" },

 { 0x0300, "WM_CUT" },

 { 0x0301, "WM_COPY" },

 { 0x0302, "WM_PASTE" },

 { 0x0303, "WM_CLEAR" },

 { 0x0304, "WM_UNDO" },

 { 0x0305, "WM_RENDERFORMAT" },

 { 0x0306, "WM_RENDERALLFORMATS" },

 { 0x0307, "WM_DESTROYCLIPBOARD" },

 { 0x0308, "WM_DRAWCLIPBOARD" },

 { 0x0309, "WM_PAINTCLIPBOARD" },

 { 0x030A, "WM_VSCROLLCLIPBOARD" },

 { 0x030B, "WM_SIZECLIPBOARD" },

 { 0x030C, "WM_ASKCBFORMATNAME" },

 { 0x030D, "WM_CHANGECBCHAIN" },

 { 0x030E, "WM_HSCROLLCLIPBOARD" },

 { 0x030F, "WM_QUERYNEWPALETTE" },

 { 0x0310, "WM_PALETTEISCHANGING" },

 { 0x0311, "WM_PALETTECHANGED" },

 { 0x0312, "WM_HOTKEY" },

 { 0x0317, "WM_PRINT" },

 { 0x0318, "WM_PRINTCLIENT" },

 { 0x0319, "WM_APPCOMMAND" },

 { 0x031A, "WM_THEMECHANGED" },

 { 0x0358, "WM_HANDHELDFIRST" },

 { 0x0359, "WM_HANDHELDFIRST + 1" },

 { 0x035A, "WM_HANDHELDFIRST + 2" },

 { 0x035B, "WM_HANDHELDFIRST + 3" },

 { 0x035C, "WM_HANDHELDFIRST + 4" },