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

**

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

#include "qwindowsxpstyle_p.h"

#if !defined(QT_NO_STYLE_WINDOWSXP) || defined(QT_PLUGIN)

#include <private/qobject_p.h>

#include <private/qpaintengine_raster_p.h>

#include <private/qapplication_p.h>

#include <private/qstylehelper_p.h>

#include <private/qwidget_p.h>

#include <qlibrary.h>

#include <qpainter.h>

#include <qpaintengine.h>

#include <qwidget.h>

#include <qapplication.h>

#include <qpixmapcache.h>

#include <qdesktopwidget.h>

#include <qtoolbutton.h>

#include <qtabbar.h>

#include <qcombobox.h>

#include <qscrollbar.h>

#include <qheaderview.h>

#include <qspinbox.h>

#include <qlistview.h>

#include <qstackedwidget.h>

#include <qpushbutton.h>

#include <qtoolbar.h>

#include <qlabel.h>

#include <qvarlengtharray.h>

#include <qdebug.h>

QT_BEGIN_NAMESPACE

// Runtime resolved theme engine function calls

typedef bool (WINAPI *PtrIsAppThemed)();

typedef bool (WINAPI *PtrIsThemeActive)();

typedef HRESULT (WINAPI *PtrGetThemePartSize)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, OPTIONAL RECT *prc, enum THEMESIZE eSize, OUT SIZE *psz);

typedef HTHEME (WINAPI *PtrOpenThemeData)(HWND hwnd, LPCWSTR pszClassList);

typedef HRESULT (WINAPI *PtrCloseThemeData)(HTHEME hTheme);

typedef HRESULT (WINAPI *PtrDrawThemeBackground)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, OPTIONAL const RECT *pClipRect);

typedef HRESULT (WINAPI *PtrDrawThemeBackgroundEx)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, OPTIONAL const DTBGOPTS *pOptions);

typedef HRESULT (WINAPI *PtrGetCurrentThemeName)(OUT LPWSTR pszThemeFileName, int cchMaxNameChars, OUT OPTIONAL LPWSTR pszColorBuff, int cchMaxColorChars, OUT OPTIONAL LPWSTR pszSizeBuff, int cchMaxSizeChars);

typedef HRESULT (WINAPI *PtrGetThemeDocumentationProperty)(LPCWSTR pszThemeName, LPCWSTR pszPropertyName, OUT LPWSTR pszValueBuff, int cchMaxValChars);

typedef HRESULT (WINAPI *PtrGetThemeBool)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, OUT BOOL *pfVal);

typedef HRESULT (WINAPI *PtrGetThemeColor)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, OUT COLORREF *pColor);

typedef HRESULT (WINAPI *PtrGetThemeEnumValue)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, OUT int *piVal);

typedef HRESULT (WINAPI *PtrGetThemeFilename)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, OUT LPWSTR pszThemeFileName, int cchMaxBuffChars);

typedef HRESULT (WINAPI *PtrGetThemeFont)(HTHEME hTheme, OPTIONAL HDC hdc, int iPartId, int iStateId, int iPropId, OUT LOGFONT *pFont);

typedef HRESULT (WINAPI *PtrGetThemeInt)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, OUT int *piVal);

typedef HRESULT (WINAPI *PtrGetThemeIntList)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, OUT INTLIST *pIntList);

typedef HRESULT (WINAPI *PtrGetThemeMargins)(HTHEME hTheme, OPTIONAL HDC hdc, int iPartId, int iStateId, int iPropId, OPTIONAL RECT *prc, OUT MARGINS *pMargins);

typedef HRESULT (WINAPI *PtrGetThemeMetric)(HTHEME hTheme, OPTIONAL HDC hdc, int iPartId, int iStateId, int iPropId, OUT int *piVal);

typedef HRESULT (WINAPI *PtrGetThemePartSize)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, OPTIONAL RECT *prc, enum THEMESIZE eSize, OUT SIZE *psz);

typedef HRESULT (WINAPI *PtrGetThemePosition)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, OUT POINT *pPoint);

typedef HRESULT (WINAPI *PtrGetThemePropertyOrigin)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, OUT enum PROPERTYORIGIN *pOrigin);

typedef HRESULT (WINAPI *PtrGetThemeRect)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, OUT RECT *pRect);

typedef HRESULT (WINAPI *PtrGetThemeString)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, OUT LPWSTR pszBuff, int cchMaxBuffChars);

typedef HRESULT (WINAPI *PtrGetThemeBackgroundRegion)(HTHEME hTheme, OPTIONAL HDC hdc, int iPartId, int iStateId, const RECT *pRect, OUT HRGN *pRegion);

typedef BOOL (WINAPI *PtrIsThemeBackgroundPartiallyTransparent)(HTHEME hTheme, int iPartId, int iStateId);

static PtrIsAppThemed pIsAppThemed = 0;

static PtrIsThemeActive pIsThemeActive = 0;

static PtrOpenThemeData pOpenThemeData = 0;

static PtrCloseThemeData pCloseThemeData = 0;

static PtrDrawThemeBackground pDrawThemeBackground = 0;

static PtrDrawThemeBackgroundEx pDrawThemeBackgroundEx = 0;

static PtrGetCurrentThemeName pGetCurrentThemeName = 0;

static PtrGetThemeBool pGetThemeBool = 0;

static PtrGetThemeColor pGetThemeColor = 0;

static PtrGetThemeEnumValue pGetThemeEnumValue = 0;

static PtrGetThemeFilename pGetThemeFilename = 0;

static PtrGetThemeFont pGetThemeFont = 0;

static PtrGetThemeInt pGetThemeInt = 0;

static PtrGetThemeIntList pGetThemeIntList = 0;

static PtrGetThemeMargins pGetThemeMargins = 0;

static PtrGetThemeMetric pGetThemeMetric = 0;

static PtrGetThemePartSize pGetThemePartSize = 0;

static PtrGetThemePosition pGetThemePosition = 0;

static PtrGetThemePropertyOrigin pGetThemePropertyOrigin = 0;

static PtrGetThemeRect pGetThemeRect = 0;

static PtrGetThemeString pGetThemeString = 0;

static PtrGetThemeBackgroundRegion pGetThemeBackgroundRegion = 0;

static PtrGetThemeDocumentationProperty pGetThemeDocumentationProperty = 0;

static PtrIsThemeBackgroundPartiallyTransparent pIsThemeBackgroundPartiallyTransparent = 0;

// General const values

static const int windowsItemFrame        =  2; // menu item frame width

static const int windowsItemHMargin      =  3; // menu item hor text margin

static const int windowsItemVMargin      =  0; // menu item ver text margin

static const int windowsArrowHMargin     =  6; // arrow horizontal margin

static const int windowsRightBorder      = 12; // right border on windows

// External function calls

extern Q_GUI_EXPORT HDC qt_win_display_dc();

extern QRegion qt_region_from_HRGN(HRGN rgn);

// Theme data helper ------------------------------------------------------------------------------

/* \internal

    Returns true if the themedata is valid for use.

*/

bool XPThemeData::isValid()

{

    return QWindowsXPStylePrivate::useXP() && name.size() && handle();

}

/* \internal

    Returns the theme engine handle to the specific class.

    If the handle hasn't been opened before, it opens the data, and

    adds it to a static map, for caching.

*/

HTHEME XPThemeData::handle()

{

    if (!QWindowsXPStylePrivate::useXP())

        return 0;

    if (!htheme && QWindowsXPStylePrivate::handleMap)

        htheme = QWindowsXPStylePrivate::handleMap->operator[](name);

    if (!htheme) {

        htheme = pOpenThemeData(QWindowsXPStylePrivate::winId(widget), (wchar_t*)name.utf16());

        if (htheme) {

            if (!QWindowsXPStylePrivate::handleMap)

                QWindowsXPStylePrivate::handleMap = new QMap<QString, HTHEME>;

            QWindowsXPStylePrivate::handleMap->operator[](name) = htheme;

        }

    }

    return htheme;

}

/* \internal

    Converts a QRect to the native RECT structure.

*/

RECT XPThemeData::toRECT(const QRect &qr)

{

    RECT r;

    r.left = qr.x();

    r.right = qr.x() + qr.width();

    r.top = qr.y();

    r.bottom = qr.y() + qr.height();

    return r;

}

/* \internal

    Returns the native region of a part, if the part is considered

    transparent. The region is scaled to the parts size (rect).

*/

HRGN XPThemeData::mask()

{

    if (!pIsThemeBackgroundPartiallyTransparent(handle(), partId, stateId))

        return 0;

    HRGN hrgn;

    HDC dc = painter == 0 ? 0 : painter->paintEngine()->getDC();

    RECT nativeRect = toRECT(rect);

    pGetThemeBackgroundRegion(handle(), dc, partId, stateId, &nativeRect, &hrgn);

    if (dc)

        painter->paintEngine()->releaseDC(dc);

    return hrgn;

}

// QWindowsXPStylePrivate -------------------------------------------------------------------------

// Static initializations

QWidget *QWindowsXPStylePrivate::limboWidget = 0;

QPixmap *QWindowsXPStylePrivate::tabbody = 0;

QMap<QString,HTHEME> *QWindowsXPStylePrivate::handleMap = 0;

bool QWindowsXPStylePrivate::use_xp = false;

QBasicAtomicInt QWindowsXPStylePrivate::ref = Q_BASIC_ATOMIC_INITIALIZER(-1); // -1 based refcounting

/* \internal

    Checks if the theme engine can/should be used, or if we should

    fall back to Windows style.

*/

bool QWindowsXPStylePrivate::useXP(bool update)

{

    if (!update)

        return use_xp;

    return (use_xp = resolveSymbols() && pIsThemeActive()

            && (pIsAppThemed() || !QApplication::instance()));

}

/* \internal

    Handles refcounting, and queries the theme engine for usage.

*/

void QWindowsXPStylePrivate::init(bool force)

{

    if (ref.ref() && !force)

        return;

    if (!force) // -1 based atomic refcounting

        ref.ref();

    useXP(true);

}

/* \internal

    Cleans up all static data.

*/

void QWindowsXPStylePrivate::cleanup(bool force)

{

    if(bufferBitmap) {

        if (bufferDC && nullBitmap)

            SelectObject(bufferDC, nullBitmap);

        DeleteObject(bufferBitmap);

        bufferBitmap = 0;

    }

    if(bufferDC)

        DeleteDC(bufferDC);

    bufferDC = 0;

    if (ref.deref() && !force)

        return;

    if (!force)  // -1 based atomic refcounting

        ref.deref();

    use_xp = false;

    cleanupHandleMap();

    if (limboWidget) {

        if (QApplication::closingDown())

            delete limboWidget;

        else

            limboWidget->deleteLater();

    }

    delete tabbody;

    limboWidget = 0;

    tabbody = 0;

}

/* \internal

    Closes all open theme data handles to ensure that we don't leak

    resources, and that we don't refere to old handles when for

    example the user changes the theme style.

*/

void QWindowsXPStylePrivate::cleanupHandleMap()

{

    if (!handleMap)

        return;

    QMap<QString, HTHEME>::Iterator it;

    for (it = handleMap->begin(); it != handleMap->end(); ++it)

        pCloseThemeData(it.value());

    delete handleMap;

    handleMap = 0;

}

/*! \internal

    This function will always return a valid window handle, and might

    create a limbo widget to do so.

    We often need a window handle to for example open theme data, so

    this function ensures that we get one.

*/

HWND QWindowsXPStylePrivate::winId(const QWidget *widget)

{

    if (widget && widget->internalWinId())

        return widget->internalWinId();

    if (!limboWidget) {

        limboWidget = new QWidget(0);

        limboWidget->createWinId();

        limboWidget->setObjectName(QLatin1String("xp_limbo_widget"));

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

        if (QWidgetPrivate::allWidgets)

            QWidgetPrivate::allWidgets->remove(limboWidget);

    }

    return limboWidget->winId();

}

/*! \internal

    Returns the pointer to a tab widgets body pixmap, scaled to the

    height of the screen. This way the theme engine doesn't need to

    scale the body for every time we ask for it. (Speed optimization)

*/

const QPixmap *QWindowsXPStylePrivate::tabBody(QWidget *)

{

    if (!tabbody) {

        SIZE sz;

        XPThemeData theme(0, 0, QLatin1String("TAB"), TABP_BODY);

        pGetThemePartSize(theme.handle(), qt_win_display_dc(), TABP_BODY, 0, 0, TS_TRUE, &sz);

        tabbody = new QPixmap(sz.cx, QApplication::desktop()->screenGeometry().height());

        QPainter painter(tabbody);

        theme.rect = QRect(0, 0, sz.cx, sz.cy);

        drawBackground(theme);

        // We fill with the last line of the themedata, that

        // way we don't get a tiled pixmap inside big tabs

        QPixmap temp(sz.cx, 1);

        painter.drawPixmap(0, 0, temp, 0, sz.cy-1, -1, -1);

        painter.drawTiledPixmap(0, sz.cy, sz.cx, tabbody->height()-sz.cy, temp);

    }

    return tabbody;

}

/*! \internal

    Returns true if all the necessary theme engine symbols were

    resolved.

*/

bool QWindowsXPStylePrivate::resolveSymbols()

{

    static bool tried = false;

    if (!tried) {

        tried = true;

        QLibrary themeLib(QLatin1String("uxtheme"));

        pIsAppThemed = (PtrIsAppThemed)themeLib.resolve("IsAppThemed");

        if (pIsAppThemed) {

            pIsThemeActive          = (PtrIsThemeActive         )themeLib.resolve("IsThemeActive");

            pGetThemePartSize       = (PtrGetThemePartSize      )themeLib.resolve("GetThemePartSize");

            pOpenThemeData          = (PtrOpenThemeData         )themeLib.resolve("OpenThemeData");

            pCloseThemeData         = (PtrCloseThemeData        )themeLib.resolve("CloseThemeData");

            pDrawThemeBackground    = (PtrDrawThemeBackground   )themeLib.resolve("DrawThemeBackground");

            pDrawThemeBackgroundEx  = (PtrDrawThemeBackgroundEx )themeLib.resolve("DrawThemeBackgroundEx");

            pGetCurrentThemeName    = (PtrGetCurrentThemeName   )themeLib.resolve("GetCurrentThemeName");

            pGetThemeBool           = (PtrGetThemeBool          )themeLib.resolve("GetThemeBool");

            pGetThemeColor          = (PtrGetThemeColor         )themeLib.resolve("GetThemeColor");

            pGetThemeEnumValue      = (PtrGetThemeEnumValue     )themeLib.resolve("GetThemeEnumValue");

            pGetThemeFilename       = (PtrGetThemeFilename      )themeLib.resolve("GetThemeFilename");

            pGetThemeFont           = (PtrGetThemeFont          )themeLib.resolve("GetThemeFont");

            pGetThemeInt            = (PtrGetThemeInt           )themeLib.resolve("GetThemeInt");

            pGetThemeIntList        = (PtrGetThemeIntList       )themeLib.resolve("GetThemeIntList");

            pGetThemeMargins        = (PtrGetThemeMargins       )themeLib.resolve("GetThemeMargins");

            pGetThemeMetric         = (PtrGetThemeMetric        )themeLib.resolve("GetThemeMetric");

            pGetThemePartSize       = (PtrGetThemePartSize      )themeLib.resolve("GetThemePartSize");

            pGetThemePosition       = (PtrGetThemePosition      )themeLib.resolve("GetThemePosition");

            pGetThemePropertyOrigin = (PtrGetThemePropertyOrigin)themeLib.resolve("GetThemePropertyOrigin");

            pGetThemeRect           = (PtrGetThemeRect          )themeLib.resolve("GetThemeRect");

            pGetThemeString         = (PtrGetThemeString        )themeLib.resolve("GetThemeString");

            pGetThemeBackgroundRegion              = (PtrGetThemeBackgroundRegion             )themeLib.resolve("GetThemeBackgroundRegion");

            pGetThemeDocumentationProperty         = (PtrGetThemeDocumentationProperty        )themeLib.resolve("GetThemeDocumentationProperty");

            pIsThemeBackgroundPartiallyTransparent = (PtrIsThemeBackgroundPartiallyTransparent)themeLib.resolve("IsThemeBackgroundPartiallyTransparent");

        }

    }

    return pIsAppThemed != 0;

}

/*! \internal

    Returns a native buffer (DIB section) of at least the size of

    ( \a x , \a y ). The buffer has a 32 bit depth, to not lose

    the alpha values on proper alpha-pixmaps.

*/

HBITMAP QWindowsXPStylePrivate::buffer(int w, int h)

{

    // If we already have a HBITMAP which is of adequate size, just return that

    if (bufferBitmap) {

        if (bufferW >= w && bufferH >= h)

            return bufferBitmap;

        // Not big enough, discard the old one

        if (bufferDC && nullBitmap)

            SelectObject(bufferDC, nullBitmap);

        DeleteObject(bufferBitmap);

        bufferBitmap = 0;

    }

    w = qMax(bufferW, w);

    h = qMax(bufferH, h);

    if (!bufferDC)

        bufferDC = CreateCompatibleDC(qt_win_display_dc());

    // Define the header

    BITMAPINFO bmi;

    memset(&bmi, 0, sizeof(bmi));

    bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);

    bmi.bmiHeader.biWidth       = w;

    bmi.bmiHeader.biHeight      = -h;

    bmi.bmiHeader.biPlanes      = 1;

    bmi.bmiHeader.biBitCount    = 32;

    bmi.bmiHeader.biCompression = BI_RGB;

    // Create the pixmap

    bufferPixels = 0;

    bufferBitmap = CreateDIBSection(bufferDC, &bmi, DIB_RGB_COLORS, (void **) &bufferPixels, 0, 0);

    GdiFlush();

    nullBitmap = (HBITMAP)SelectObject(bufferDC, bufferBitmap);

    if (!bufferBitmap) {

        qErrnoWarning("QWindowsXPStylePrivate::buffer(w,h), failed to create dibsection");

        bufferW = 0;

        bufferH = 0;

        return 0;

    }

    if (!bufferPixels) {

        qErrnoWarning("QWindowsXPStylePrivate::buffer(w,h), did not allocate pixel data");

        bufferW = 0;

        bufferH = 0;

        return 0;

    }

    bufferW = w;

    bufferH = h;

#ifdef DEBUG_XP_STYLE

    qDebug("Creating new dib section (%d, %d)", w, h);

#endif

    return bufferBitmap;

}

/*! \internal

    Returns true if the part contains any transparency at all. This does

    not indicate what kind of transparency we're dealing with. It can be

        - Alpha transparency

        - Masked transparency

*/

bool QWindowsXPStylePrivate::isTransparent(XPThemeData &themeData)

{

    return pIsThemeBackgroundPartiallyTransparent(themeData.handle(), themeData.partId,

                                                  themeData.stateId);

}

/*! \internal

    Returns a QRegion of the region of the part

*/

QRegion QWindowsXPStylePrivate::region(XPThemeData &themeData)

{

    HRGN hRgn = 0;

    RECT rect = themeData.toRECT(themeData.rect);

    if (!SUCCEEDED(pGetThemeBackgroundRegion(themeData.handle(), bufferHDC(), themeData.partId,

                                             themeData.stateId, &rect, &hRgn)))

        return QRegion();

    HRGN dest = CreateRectRgn(0, 0, 0, 0);

    const bool success = CombineRgn(dest, hRgn, 0, RGN_COPY) != ERROR;

    QRegion region;

    if (success)

        region = qt_region_from_HRGN(dest);

    DeleteObject(hRgn);

    DeleteObject(dest);

    return region;

}

/*! \internal

    Sets the parts region on a window.

*/

void QWindowsXPStylePrivate::setTransparency(QWidget *widget, XPThemeData &themeData)

{

    HRGN hrgn = themeData.mask();

    if (hrgn && widget)

        SetWindowRgn(winId(widget), hrgn, true);

}

/*! \internal

    Returns true if the native doublebuffer contains a pixel which

    has a non-0xFF alpha value. Should only be use when its

    guaranteed that data painted into the buffer wasn't a proper

    alpha pixmap.

*/

bool QWindowsXPStylePrivate::hasAnyData(const QRect &rect)

{

    const int startX = rect.left();

    const int startY = rect.top();

    const int w = rect.width();

    const int h = rect.height();

    for (int y = startY; y < h; ++y) {

        register DWORD *buffer = (DWORD*)bufferPixels + (y * bufferW);

        for (int x = startX; x < w; ++x, ++buffer) {

            int alpha = (*buffer) >> 24;

            if (alpha != 0xFF) // buffer has been touched

                return true;

        }

    }

    return false;

}

/*! \internal

    Returns true if the native doublebuffer contains pixels with

    varying alpha value.

*/

bool QWindowsXPStylePrivate::hasAlphaChannel(const QRect &rect)

{

    const int startX = rect.left();

    const int startY = rect.top();

    const int w = rect.width();

    const int h = rect.height();

    int firstAlpha = -1;

    for (int y = startY; y < h/2; ++y) {

        register DWORD *buffer = (DWORD*)bufferPixels + (y * bufferW);

        for (int x = startX; x < w; ++x, ++buffer) {

            int alpha = (*buffer) >> 24;