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

**

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

#include "qapplication_p.h"

#include "qbitmap.h"

#include "qcursor.h"

#include "qdesktopwidget.h"

#include "qevent.h"

#include "qimage.h"

#include "qlayout.h"

#include "qlibrary.h"

#include "qpainter.h"

#include "qstack.h"

#include "qt_windows.h"

#include "qwidget.h"

#include "qwidget_p.h"

#include "private/qbackingstore_p.h"

#include "private/qwindowsurface_raster_p.h"

#include "qscrollbar.h"

#include "qabstractscrollarea.h"

#include <private/qabstractscrollarea_p.h>

#include <qdebug.h>

#include <private/qapplication_p.h>

#include <private/qwininputcontext_p.h>

#include <private/qpaintengine_raster_p.h>

#if defined(Q_WS_WINCE)

#include "qguifunctions_wince.h"

QT_USE_NAMESPACE

extern void qt_wince_maximize(QWidget *widget);                          //defined in qguifunctions_wince.cpp

extern void qt_wince_minimize(HWND hwnd);                                //defined in qguifunctions_wince.cpp

extern void qt_wince_full_screen(HWND hwnd, bool fullScreen, UINT swpf); //defined in qguifunctions_wince.cpp

extern bool qt_wince_is_mobile();                                        //defined in qguifunctions_wince.cpp

#endif

typedef BOOL    (WINAPI *PtrSetLayeredWindowAttributes)(HWND hwnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags);

static PtrSetLayeredWindowAttributes ptrSetLayeredWindowAttributes = 0;

#ifndef QT_NO_DIRECTDRAW

#include <ddraw.h>

#include <private/qimage_p.h>

static IDirectDraw *qt_ddraw_object;

static IDirectDrawSurface *qt_ddraw_primary;

#endif

#if defined(QT_NON_COMMERCIAL)

#include "qnc_win.h"

#endif

#if !defined(WS_EX_TOOLWINDOW)

#define WS_EX_TOOLWINDOW 0x00000080

#endif

#if !defined(GWLP_WNDPROC)

#define GWLP_WNDPROC GWL_WNDPROC

#endif

//#define TABLET_DEBUG

#define PACKETDATA  (PK_X | PK_Y | PK_BUTTONS | PK_NORMAL_PRESSURE | PK_TANGENT_PRESSURE \

                     | PK_ORIENTATION | PK_CURSOR | PK_Z)

#define PACKETMODE  0

#include <wintab.h>

#include <pktdef.h>

QT_BEGIN_NAMESPACE

typedef HCTX        (API *PtrWTOpen)(HWND, LPLOGCONTEXT, BOOL);

typedef BOOL        (API *PtrWTClose)(HCTX);

typedef UINT        (API *PtrWTInfo)(UINT, UINT, LPVOID);

typedef BOOL        (API *PtrWTEnable)(HCTX, BOOL);

typedef BOOL        (API *PtrWTOverlap)(HCTX, BOOL);

typedef int        (API *PtrWTPacketsGet)(HCTX, int, LPVOID);

typedef BOOL        (API *PtrWTGet)(HCTX, LPLOGCONTEXT);

typedef int     (API *PtrWTQueueSizeGet)(HCTX);

typedef BOOL    (API *PtrWTQueueSizeSet)(HCTX, int);

static PtrWTOpen ptrWTOpen = 0;

static PtrWTClose ptrWTClose = 0;

static PtrWTInfo ptrWTInfo = 0;

static PtrWTQueueSizeGet ptrWTQueueSizeGet = 0;

static PtrWTQueueSizeSet ptrWTQueueSizeSet = 0;

static void init_wintab_functions();

static void qt_tablet_init();

static void qt_tablet_cleanup();

extern HCTX qt_tablet_context;

extern bool qt_tablet_tilt_support;

static QWidget *qt_tablet_widget = 0;

QWidget* qt_get_tablet_widget()

{

    return qt_tablet_widget;

}

extern bool qt_is_gui_used;

static void init_wintab_functions()

{

#if defined(Q_OS_WINCE)

    return;

#else

    if (!qt_is_gui_used)

        return;

    QLibrary library(QLatin1String("wintab32"));

    ptrWTOpen = (PtrWTOpen)library.resolve("WTOpenW");

    ptrWTInfo = (PtrWTInfo)library.resolve("WTInfoW");

    ptrWTClose = (PtrWTClose)library.resolve("WTClose");

    ptrWTQueueSizeGet = (PtrWTQueueSizeGet)library.resolve("WTQueueSizeGet");

    ptrWTQueueSizeSet = (PtrWTQueueSizeSet)library.resolve("WTQueueSizeSet");

#endif // Q_OS_WINCE

}

static void qt_tablet_init()

{

    static bool firstTime = true;

    if (!firstTime)

        return;

    firstTime = false;

    qt_tablet_widget = new QWidget(0);

    qt_tablet_widget->createWinId();

    qt_tablet_widget->setObjectName(QLatin1String("Qt internal tablet widget"));

    // We dont need this internal widget to appear in QApplication::topLevelWidgets()

    if (QWidgetPrivate::allWidgets)

        QWidgetPrivate::allWidgets->remove(qt_tablet_widget);

    LOGCONTEXT lcMine;

    qAddPostRoutine(qt_tablet_cleanup);

    struct tagAXIS tpOri[3];

    init_wintab_functions();

    if (ptrWTInfo && ptrWTOpen && ptrWTQueueSizeGet && ptrWTQueueSizeSet) {

        // make sure we have WinTab

        if (!ptrWTInfo(0, 0, NULL)) {

#ifdef TABLET_DEBUG

            qWarning("QWidget: Wintab services not available");

#endif

            return;

        }

        // some tablets don't support tilt, check if it is possible,

        qt_tablet_tilt_support = ptrWTInfo(WTI_DEVICES, DVC_ORIENTATION, &tpOri);

        if (qt_tablet_tilt_support) {

            // check for azimuth and altitude

            qt_tablet_tilt_support = tpOri[0].axResolution && tpOri[1].axResolution;

        }

        // build our context from the default context

        ptrWTInfo(WTI_DEFSYSCTX, 0, &lcMine);

        // Go for the raw coordinates, the tablet event will return good stuff

        lcMine.lcOptions |= CXO_MESSAGES | CXO_CSRMESSAGES;

        lcMine.lcPktData = PACKETDATA;

        lcMine.lcPktMode = PACKETMODE;

        lcMine.lcMoveMask = PACKETDATA;

        lcMine.lcOutOrgX = 0;

        lcMine.lcOutExtX = lcMine.lcInExtX;

        lcMine.lcOutOrgY = 0;

        lcMine.lcOutExtY = -lcMine.lcInExtY;

        qt_tablet_context = ptrWTOpen(qt_tablet_widget->winId(), &lcMine, true);

#ifdef TABLET_DEBUG

        qDebug("Tablet is %p", qt_tablet_context);

#endif

        if (!qt_tablet_context) {

#ifdef TABLET_DEBUG

            qWarning("QWidget: Failed to open the tablet");

#endif

            return;

        }

        // Set the size of the Packet Queue to the correct size...

        int currSize = ptrWTQueueSizeGet(qt_tablet_context);

        if (!ptrWTQueueSizeSet(qt_tablet_context, QT_TABLET_NPACKETQSIZE)) {

            // Ideally one might want to use a smaller

            // multiple, but for now, since we managed to destroy

            // the existing Q with the previous call, set it back

            // to the other size, which should work.  If not,

            // there will be trouble.

            if (!ptrWTQueueSizeSet(qt_tablet_context, currSize)) {

                Q_ASSERT_X(0, "Qt::Internal", "There is no packet queue for"

                         " the tablet. The tablet will not work");

            }

        }

    }

}

static void qt_tablet_cleanup()

{

    if (ptrWTClose)

        ptrWTClose(qt_tablet_context);

    delete qt_tablet_widget;

    qt_tablet_widget = 0;

}

const QString qt_reg_winclass(QWidget *w);                // defined in qapplication_win.cpp

#ifndef QT_NO_DRAGANDDROP

void            qt_olednd_unregister(QWidget* widget, QOleDropTarget *dst); // dnd_win

QOleDropTarget* qt_olednd_register(QWidget* widget);

#endif

extern bool qt_nograb();

extern HRGN qt_win_bitmapToRegion(const QBitmap& bitmap);

static QWidget *mouseGrb    = 0;

static QCursor *mouseGrbCur = 0;

static QWidget *keyboardGrb = 0;

static HHOOK   journalRec  = 0;

extern "C" LRESULT CALLBACK QtWndProc(HWND, UINT, WPARAM, LPARAM);

#define XCOORD_MAX 16383

#define WRECT_MAX 16383

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

  QWidget member functions

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

#ifndef Q_WS_WINCE

void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyOldWindow)

{

    Q_Q(QWidget);

    static int sw = -1, sh = -1;

    Qt::WindowType type = q->windowType();

    Qt::WindowFlags flags = data.window_flags;

    bool topLevel = (flags & Qt::Window);

    bool popup = (type == Qt::Popup);

    bool dialog = (type == Qt::Dialog

                   || type == Qt::Sheet

                   || (flags & Qt::MSWindowsFixedSizeDialogHint));

    bool desktop = (type == Qt::Desktop);

    bool tool = (type == Qt::Tool || type == Qt::Drawer);

    HINSTANCE appinst  = qWinAppInst();

    HWND parentw, destroyw = 0;

    WId id = 0;

    QString windowClassName = qt_reg_winclass(q);

    if (!window)                                // always initialize

        initializeWindow = true;

    if (popup)

        flags |= Qt::WindowStaysOnTopHint; // a popup stays on top

    if (sw < 0) {                                // get the (primary) screen size

        sw = GetSystemMetrics(SM_CXSCREEN);

        sh = GetSystemMetrics(SM_CYSCREEN);

    }

    if (desktop && !q->testAttribute(Qt::WA_DontShowOnScreen)) {                                // desktop widget

        popup = false;                                // force this flags off

        data.crect.setRect(GetSystemMetrics(76 /* SM_XVIRTUALSCREEN  */), GetSystemMetrics(77 /* SM_YVIRTUALSCREEN  */),

                           GetSystemMetrics(78 /* SM_CXVIRTUALSCREEN */), GetSystemMetrics(79 /* SM_CYVIRTUALSCREEN */));

    }

    parentw = q->parentWidget() ? q->parentWidget()->effectiveWinId() : 0;

    QString title;

    int style = WS_CHILD;

    int exsty = 0;

    if (window) {

        style = GetWindowLong(window, GWL_STYLE);

        if (!style)

            qErrnoWarning("QWidget::create: GetWindowLong failed");

        topLevel = false; // #### needed for some IE plugins??

    } else if (popup || (type == Qt::ToolTip) || (type == Qt::SplashScreen)) {

        style = WS_POPUP;

    } else if (topLevel && !desktop) {

        if (flags & Qt::FramelessWindowHint)

            style = WS_POPUP;                // no border

        else if (flags & Qt::WindowTitleHint)

            style = WS_OVERLAPPED;

        else

            style = 0;

    }

    if (!desktop) {

        // if (!testAttribute(Qt::WA_PaintUnclipped))

        // ### Commented out for now as it causes some problems, but

        // this should be correct anyway, so dig some more into this

#ifndef Q_FLATTEN_EXPOSE

        style |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN ;

#endif

        if (topLevel) {

            if ((type == Qt::Window || dialog || tool)) {

                if (!(flags & Qt::FramelessWindowHint)) {

                    if (!(flags & Qt::MSWindowsFixedSizeDialogHint)) {

                        style |= WS_THICKFRAME;

                        if(!(flags &

                            ( Qt::WindowSystemMenuHint

                            | Qt::WindowTitleHint

                            | Qt::WindowMinMaxButtonsHint

                            | Qt::WindowCloseButtonHint

                            | Qt::WindowContextHelpButtonHint)))

                            style |= WS_POPUP;

                    } else {

                        style |= WS_POPUP | WS_DLGFRAME;

                    }

                }

                if (flags & Qt::WindowTitleHint)

                    style |= WS_CAPTION;

                if (flags & Qt::WindowSystemMenuHint)

                    style |= WS_SYSMENU;

                if (flags & Qt::WindowMinimizeButtonHint)

                    style |= WS_MINIMIZEBOX;

                if (shouldShowMaximizeButton())

                    style |= WS_MAXIMIZEBOX;

                if (tool)

                    exsty |= WS_EX_TOOLWINDOW;

                if (flags & Qt::WindowContextHelpButtonHint)

                    exsty |= WS_EX_CONTEXTHELP;

            } else {

                 exsty |= WS_EX_TOOLWINDOW;

            }

        }

    }

    if (flags & Qt::WindowTitleHint) {

        title = q->isWindow() ? qAppName() : q->objectName();

    }

    // The Qt::WA_WState_Created flag is checked by translateConfigEvent() in

    // qapplication_win.cpp. We switch it off temporarily to avoid move

    // and resize events during creationt

    q->setAttribute(Qt::WA_WState_Created, false);

    if (window) {                                // override the old window

        if (destroyOldWindow)

            destroyw = data.winid;

        id = window;

        setWinId(window);

        LONG res = SetWindowLong(window, GWL_STYLE, style);

        if (!res)

            qErrnoWarning("QWidget::create: Failed to set window style");

#ifdef _WIN64

        res = SetWindowLongPtr( window, GWLP_WNDPROC, (LONG_PTR)QtWndProc );

#else

        res = SetWindowLong( window, GWL_WNDPROC, (LONG)QtWndProc );

#endif

        if (!res)

            qErrnoWarning("QWidget::create: Failed to set window procedure");

    } else if (desktop) {                        // desktop widget

        id = GetDesktopWindow();

//         QWidget *otherDesktop = QWidget::find(id);        // is there another desktop?

//         if (otherDesktop && otherDesktop->testWFlags(Qt::WPaintDesktop)) {

//             otherDesktop->d_func()->setWinId(0);        // remove id from widget mapper

//             d->setWinId(id);                     // make sure otherDesktop is

//             otherDesktop->d_func()->setWinId(id);       //   found first

//         } else {

            setWinId(id);

//         }

    } else if (topLevel) {                       // create top-level widget

        if (popup)

            parentw = 0;

        const bool wasMoved = q->testAttribute(Qt::WA_Moved);

        int x = wasMoved ? data.crect.left() : CW_USEDEFAULT;

        int y = wasMoved ? data.crect.top() : CW_USEDEFAULT;

        int w = CW_USEDEFAULT;

        int h = CW_USEDEFAULT;

        // Adjust for framestrut when needed

        RECT rect = {0,0,0,0};

        bool isVisibleOnScreen = !q->testAttribute(Qt::WA_DontShowOnScreen);

        if (isVisibleOnScreen && AdjustWindowRectEx(&rect, style & ~WS_OVERLAPPED, FALSE, exsty)) {

            QTLWExtra *td = maybeTopData();

            if (wasMoved && (td && !td->posFromMove)) {

                x = data.crect.x() + rect.left;

                y = data.crect.y() + rect.top;

            }

            if (q->testAttribute(Qt::WA_Resized)) {

                w = data.crect.width() + (rect.right - rect.left);

                h = data.crect.height() + (rect.bottom - rect.top);

            }

        }

        //update position & initial size of POPUP window

        if (isVisibleOnScreen && topLevel && initializeWindow && (style & WS_POPUP)) {

            if (!q->testAttribute(Qt::WA_Resized)) {

                w = sw/2;

                h = 4*sh/10;

            }

            if (!wasMoved) {

                x = sw/2 - w/2;

                y = sh/2 - h/2;

            }

        }

        id = CreateWindowEx(exsty, reinterpret_cast<const wchar_t *>(windowClassName.utf16()),

                            reinterpret_cast<const wchar_t *>(title.utf16()), style,

                            x, y, w, h,

                            parentw, NULL, appinst, NULL);

        if (!id)

            qErrnoWarning("QWidget::create: Failed to create window");

        setWinId(id);

        if ((flags & Qt::WindowStaysOnTopHint) || (type == Qt::ToolTip)) {

            SetWindowPos(id, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);

            if (flags & Qt::WindowStaysOnBottomHint)

                qWarning() << "QWidget: Incompatible window flags: the window can't be on top and on bottom at the same time";

        } else if (flags & Qt::WindowStaysOnBottomHint)

            SetWindowPos(id, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);

        winUpdateIsOpaque();

    } else if (q->testAttribute(Qt::WA_NativeWindow) || paintOnScreen()) { // create child widget

        id = CreateWindowEx(exsty, reinterpret_cast<const wchar_t *>(windowClassName.utf16()),

                            reinterpret_cast<const wchar_t *>(title.utf16()), style,

                            data.crect.left(), data.crect.top(), data.crect.width(), data.crect.height(),

                            parentw, NULL, appinst, NULL);

        if (!id)

            qErrnoWarning("QWidget::create: Failed to create window");

        SetWindowPos(id, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);

        setWinId(id);

    }

    if (desktop) {

        q->setAttribute(Qt::WA_WState_Visible);

    } else if (topLevel && !q->testAttribute(Qt::WA_DontShowOnScreen)) {

        RECT  cr;

        GetClientRect(id, &cr);

        // one cannot trust cr.left and cr.top, use a correction POINT instead

        POINT pt;

        pt.x = 0;

        pt.y = 0;

        ClientToScreen(id, &pt);

        if (data.crect.width() == 0 || data.crect.height() == 0) {

            data.crect = QRect(pt.x, pt.y, data.crect.width(), data.crect.height());

        } else {

            data.crect = QRect(QPoint(pt.x, pt.y),

                               QPoint(pt.x + cr.right - 1, pt.y + cr.bottom - 1));

        }

        if (data.fstrut_dirty) {

            // be nice to activeqt

            updateFrameStrut();

        }

    }

    if (topLevel) {

        if (data.window_flags & Qt::CustomizeWindowHint

            && data.window_flags & Qt::WindowTitleHint) {

            HMENU systemMenu = GetSystemMenu((HWND)q->internalWinId(), FALSE);

            if (data.window_flags & Qt::WindowCloseButtonHint)

                EnableMenuItem(systemMenu, SC_CLOSE, MF_BYCOMMAND|MF_ENABLED);

            else

                EnableMenuItem(systemMenu, SC_CLOSE, MF_BYCOMMAND|MF_GRAYED);

        }

    }

    q->setAttribute(Qt::WA_WState_Created);                // accept move/resize events

    hd = 0;                                        // no display context

    if (q->testAttribute(Qt::WA_AcceptTouchEvents))

        registerTouchWindow();

    if (window) {                                // got window from outside

        if (IsWindowVisible(window))

            q->setAttribute(Qt::WA_WState_Visible);

        else

            q->setAttribute(Qt::WA_WState_Visible, false);

    }

    if (extra && !extra->mask.isEmpty())

        setMask_sys(extra->mask);

#if defined(QT_NON_COMMERCIAL)

    QT_NC_WIDGET_CREATE

#endif

    if (q->hasFocus() && q->testAttribute(Qt::WA_InputMethodEnabled))

        q->inputContext()->setFocusWidget(q);

    if (destroyw) {

        DestroyWindow(destroyw);

    }

    if (q != qt_tablet_widget && QWidgetPrivate::mapper)

        qt_tablet_init();

    if (q->testAttribute(Qt::WA_DropSiteRegistered))

        registerDropSite(true);

    if (maybeTopData() && maybeTopData()->opacity != 255)

        q->setWindowOpacity(maybeTopData()->opacity/255.);

    if (topLevel && (data.crect.width() == 0 || data.crect.height() == 0)) {

        q->setAttribute(Qt::WA_OutsideWSRange, true);

    }

    if (!topLevel && q->testAttribute(Qt::WA_NativeWindow) && q->testAttribute(Qt::WA_Mapped)) {