Initial import of statemachine branch from the old kinetic repository

1 files changed, 4205 insertions, 0 deletions

diff --git a/src/gui/styles/qwindowsxpstyle.cpp b/src/gui/styles/qwindowsxpstyle.cpp
new file mode 100644
index 0000000..9d735a7
--- /dev/null
+++ b/src/gui/styles/qwindowsxpstyle.cpp
@@ -0,0 +1,4205 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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 <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 windowsSepHeight        =  9; // separator item height
+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 windowsCheckMarkHMargin =  0; // horiz. margins of check mark
+static const int windowsRightBorder      = 12; // right border on windows
+
+// External function calls
+extern Q_GUI_EXPORT HDC qt_win_display_dc();
+
+
+
+// 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),
+                                (TCHAR*)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 (qApp->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->setObjectName(QLatin1String("xp_limbo_widget"));
+    }
+
+    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();
+
+    QRegion rgn = QRegion(0,0,1,1);
+    const bool success = CombineRgn(rgn.handle(), hRgn, 0, RGN_COPY) != ERROR;
+    DeleteObject(hRgn);
+    if (success)
+        return rgn;
+    return QRegion();
+}
+
+/*! \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;
+            if (firstAlpha == -1)
+                firstAlpha = alpha;
+            else if (alpha != firstAlpha)
+                return true;
+        }
+    }
+    return false;
+}
+
+/*! \internal
+    When the theme engine paints both a true alpha pixmap and a glyph
+    into our buffer, the glyph might not contain a proper alpha value.
+    The rule of thumb for premultiplied pixmaps is that the color
+    values of a pixel can never be higher than the alpha values, so
+    we use this to our advantage here, and fix all instances where
+    this occures.
+*/
+bool QWindowsXPStylePrivate::fixAlphaChannel(const QRect &rect)
+{
+    const int startX = rect.left();
+    const int startY = rect.top();
+    const int w = rect.width();
+    const int h = rect.height();
+    bool hasFixedAlphaValue = false;
+
+    for (int y = startY; y < h; ++y) {
+        register DWORD *buffer = (DWORD*)bufferPixels + (y * bufferW);
+        for (register int x = startX; x < w; ++x, ++buffer) {
+            uint pixel = *buffer;
+            int alpha = qAlpha(pixel);
+            if (qRed(pixel) > alpha || qGreen(pixel) > alpha || qBlue(pixel) > alpha) {
+                *buffer |= 0xff000000;
+                hasFixedAlphaValue = true;
+            }
+        }
+    }
+    return hasFixedAlphaValue;
+}
+
+/*! \internal
+    Swaps the alpha values on certain pixels:
+        0xFF?????? -> 0x00??????
+        0x00?????? -> 0xFF??????
+    Used to determin the mask of a non-alpha transparent pixmap in
+    the native doublebuffer, and swap the alphas so we may paint
+    the image as a Premultiplied QImage with drawImage(), and obtain
+    the mask transparency.
+*/
+bool QWindowsXPStylePrivate::swapAlphaChannel(const QRect &rect, bool allPixels)
+{
+    const int startX = rect.left();
+    const int startY = rect.top();
+    const int w = rect.width();
+    const int h = rect.height();
+    bool valueChange = false;
+
+    // Flip the alphas, so that 255-alpha pixels are 0, and 0-alpha are 255.
+    for (int y = startY; y < h; ++y) {
+        register DWORD *buffer = (DWORD*)bufferPixels + (y * bufferW);
+        for (register int x = startX; x < w; ++x, ++buffer) {
+            if (allPixels) {
+                *buffer |= 0xFF000000;
+                continue;
+            }
+            register unsigned int alphaValue = (*buffer) & 0xFF000000;
+            if (alphaValue == 0xFF000000) {
+                *buffer &= 0x00FFFFFF;
+                valueChange = true;
+            } else if (alphaValue == 0) {
+                *buffer |= 0xFF000000;
+                valueChange = true;
+            }
+        }
+    }
+    return valueChange;
+}
+
+/*! \internal
+    Main theme drawing function.
+    Determines the correct lowlevel drawing method depending on several
+    factors.
+        Use drawBackgroundThruNativeBuffer() if:
+            - Painter does not have an HDC
+            - Theme part is flipped (mirrored horizontally)
+        else use drawBackgroundDirectly().
+*/
+void QWindowsXPStylePrivate::drawBackground(XPThemeData &themeData)
+{
+    if (themeData.rect.isEmpty())
+        return;
+
+    QPainter *painter = themeData.painter;
+    Q_ASSERT_X(painter != 0, "QWindowsXPStylePrivate::drawBackground()", "Trying to draw a theme part without a painter");
+    if (!painter)
+        return;
+
+    painter->save();
+
+    QMatrix m = painter->matrix();
+    bool complexXForm = m.m11() != 1.0 || m.m22() != 1.0 || m.m12() != 0.0 || m.m21() != 0.0;
+
+    bool useFallback = painter->paintEngine()->getDC() == 0
+                       || painter->opacity() != 1.0
+                       || themeData.rotate
+                       || complexXForm
+                       || themeData.mirrorVertically
+                       || (themeData.mirrorHorizontally && pDrawThemeBackgroundEx == 0);
+    if (!useFallback)
+        drawBackgroundDirectly(themeData);
+    else
+        drawBackgroundThruNativeBuffer(themeData);
+
+    painter->restore();
+}
+
+/*! \internal
+    This function draws the theme parts directly to the paintengines HDC.
+    Do not use this if you need to perform other transformations on the
+    resulting data.
+*/
+void QWindowsXPStylePrivate::drawBackgroundDirectly(XPThemeData &themeData)
+{
+    QPainter *painter = themeData.painter;
+    HDC dc = painter->paintEngine()->getDC();
+
+    QPoint redirectionDelta(int(painter->deviceMatrix().dx()),
+                            int(painter->deviceMatrix().dy()));
+    QRect area = themeData.rect.translated(redirectionDelta);
+
+    QRegion sysRgn = painter->paintEngine()->systemClip();
+    if (sysRgn.isEmpty())
+        sysRgn = area;
+    else
+        sysRgn &= area;
+    if (painter->hasClipping())
+        sysRgn &= painter->clipRegion().translated(redirectionDelta);
+    SelectClipRgn(dc, sysRgn.handle());
+
+#ifdef DEBUG_XP_STYLE
+        printf("---[ DIRECT PAINTING ]------------------> Name(%-10s) Part(%d) State(%d)\n",
+               qPrintable(themeData.name), themeData.partId, themeData.stateId);
+        showProperties(themeData);
+#endif
+
+    RECT drawRECT = themeData.toRECT(area);
+    DTBGOPTS drawOptions;
+    drawOptions.dwSize = sizeof(drawOptions);
+    drawOptions.rcClip = themeData.toRECT(sysRgn.boundingRect());
+    drawOptions.dwFlags = DTBG_CLIPRECT
+                          | (themeData.noBorder ? DTBG_OMITBORDER : 0)
+                          | (themeData.noContent ? DTBG_OMITCONTENT : 0)
+                          | (themeData.mirrorHorizontally ? DTBG_MIRRORDC : 0);
+
+    if (pDrawThemeBackgroundEx != 0) {
+        pDrawThemeBackgroundEx(themeData.handle(), dc, themeData.partId, themeData.stateId, &(drawRECT), &drawOptions);
+    } else {
+        // We are running on a system where the uxtheme.dll does not have
+        // the DrawThemeBackgroundEx function, so we need to clip away
+        // borders or contents manually. All flips and mirrors uses the
+        // fallback implementation
+
+        int borderSize = 0;
+        PROPERTYORIGIN origin = PO_NOTFOUND;
+        pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &origin);
+        pGetThemeInt(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &borderSize);
+
+        // Clip away border region
+        QRegion extraClip = sysRgn;
+        if ((origin == PO_CLASS || origin == PO_PART || origin == PO_STATE) && borderSize > 0) {
+            if (themeData.noBorder) {
+                // extraClip &= area is already done
+                drawRECT = themeData.toRECT(area.adjusted(-borderSize, -borderSize, borderSize, borderSize));
+            }
+
+            // Clip away content region
+            if (themeData.noContent) {
+                QRegion content = area.adjusted(borderSize, borderSize, -borderSize, -borderSize);
+                extraClip ^= content;
+            }
+
+            // Set the clip region, if used..
+            if (themeData.noBorder || themeData.noContent)
+                SelectClipRgn(dc, extraClip.handle());
+        }
+
+        pDrawThemeBackground(themeData.handle(), dc, themeData.partId, themeData.stateId, &(drawRECT), &(drawOptions.rcClip));
+    }
+    SelectClipRgn(dc, 0);
+}
+
+/*! \internal
+    This function uses a secondary Native doublebuffer for painting parts.
+    It should only be used when the painteengine doesn't provide a proper
+    HDC for direct painting (e.g. when doing a grabWidget(), painting to
+    other pixmaps etc), or when special transformations are needed (e.g.
+    flips (horizonal mirroring only, vertical are handled by the theme
+    engine).
+*/
+void QWindowsXPStylePrivate::drawBackgroundThruNativeBuffer(XPThemeData &themeData)
+{
+    QPainter *painter = themeData.painter;
+    QRect rect = themeData.rect;
+
+    if ((themeData.rotate + 90) % 180 == 0) { // Catch 90,270,etc.. degree flips.
+        rect = QRect(0, 0, rect.height(), rect.width());
+    }
+    rect.moveTo(0,0);
+    int partId = themeData.partId;
+    int stateId = themeData.stateId;
+    int w = rect.width();
+    int h = rect.height();
+
+    // Values initialized later, either from cached values, or from function calls
+    AlphaChannelType alphaType = UnknownAlpha;
+    bool stateHasData = true; // We assume so;
+    bool hasAlpha = false;
+    bool partIsTransparent;
+    bool inspectData;
+    bool potentialInvalidAlpha;
+
+    QString pixmapCacheKey = QString::fromLatin1("$qt_xp_%1p%2s%3s%4b%5c%6w%7h").arg(themeData.name)
+                             .arg(partId).arg(stateId).arg(!themeData.noBorder).arg(!themeData.noContent)
+                             .arg(w).arg(h);
+    QPixmap cachedPixmap;
+    ThemeMapKey key(themeData);
+    ThemeMapData data = alphaCache.value(key);
+
+    bool haveCachedPixmap = false;
+    bool isCached = data.dataValid;
+    if (isCached) {
+        if (!(stateHasData = data.hasAnyData))
+            return; // Cached NOOP
+        inspectData = data.wasAlphaSwapped;
+        partIsTransparent = data.partIsTransparent;
+        hasAlpha = data.hasAlphaChannel;
+        alphaType = data.alphaType;
+        potentialInvalidAlpha = data.hadInvalidAlpha;
+
+        haveCachedPixmap = QPixmapCache::find(pixmapCacheKey, cachedPixmap);
+
+#ifdef DEBUG_XP_STYLE
+        char buf[25];
+        ::sprintf(buf, "+ Pixmap(%3d, %3d) ]", w, h);
+        printf("---[ CACHED %s--------> Name(%-10s) Part(%d) State(%d)\n",
+               haveCachedPixmap ? buf : "]-------------------",
+               qPrintable(themeData.name), themeData.partId, themeData.stateId);
+#endif
+    } else {
+        // Not cached, so get values from Theme Engine
+        BOOL tmt_borderonly = false;
+        COLORREF tmt_transparentcolor = 0x0;
+        PROPERTYORIGIN proporigin = PO_NOTFOUND;
+        pGetThemeBool(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERONLY, &tmt_borderonly);
+        pGetThemeColor(themeData.handle(), themeData.partId, themeData.stateId, TMT_TRANSPARENTCOLOR, &tmt_transparentcolor);
+        pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_CAPTIONMARGINS, &proporigin);
+        inspectData = (tmt_transparentcolor != 0 || tmt_borderonly || proporigin == PO_PART || proporigin == PO_STATE);
+
+        // ### This is a vista-specific workaround for broken alpha in titlebar pixmaps
+        if ((QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)) {
+            if (themeData.partId == WP_CAPTION || themeData.partId == WP_SMALLCAPTION)
+                inspectData = false;
+        }
+
+        partIsTransparent = isTransparent(themeData);
+
+        potentialInvalidAlpha = false;
+        pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_GLYPHTYPE, &proporigin);
+        if (proporigin == PO_PART || proporigin == PO_STATE) {
+            int tmt_glyphtype = GT_NONE;
+            pGetThemeEnumValue(themeData.handle(), themeData.partId, themeData.stateId, TMT_GLYPHTYPE, &tmt_glyphtype);
+            potentialInvalidAlpha = partIsTransparent && !inspectData && tmt_glyphtype == GT_IMAGEGLYPH;
+        }
+
+#ifdef DEBUG_XP_STYLE
+        printf("---[ NOT CACHED ]-----------------------> Name(%-10s) Part(%d) State(%d)\n",
+               qPrintable(themeData.name), themeData.partId, themeData.stateId);
+        printf("-->partIsTransparen      = %d\n", partIsTransparent);
+        printf("-->inspectData           = %d\n", inspectData);
+        printf("-->potentialInvalidAlpha = %d\n", potentialInvalidAlpha);
+        showProperties(themeData);
+#endif
+    }
+    bool wasAlphaSwapped = false;
+    bool wasAlphaFixed = false;
+
+    // OLD PSDK Workaround ------------------------------------------------------------------------
+    // See if we need extra clipping for the older PSDK, which does
+    // not have a DrawThemeBackgroundEx function for DTGB_OMITBORDER
+    // and DTGB_OMITCONTENT
+    bool addBorderContentClipping = false;
+    QRegion extraClip;
+    QRect area = rect;
+    if (themeData.noBorder || themeData.noContent) {
+        extraClip = area;
+        // We are running on a system where the uxtheme.dll does not have
+        // the DrawThemeBackgroundEx function, so we need to clip away
+        // borders or contents manually.
+
+        int borderSize = 0;
+        PROPERTYORIGIN origin = PO_NOTFOUND;
+        pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &origin);
+        pGetThemeInt(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &borderSize);
+
+        // Clip away border region
+        if ((origin == PO_CLASS || origin == PO_PART || origin == PO_STATE) && borderSize > 0) {
+            if (themeData.noBorder) {
+                extraClip &= area;
+                area = area.adjusted(-borderSize, -borderSize, borderSize, borderSize);
+            }
+
+            // Clip away content region
+            if (themeData.noContent) {
+                QRegion content = area.adjusted(borderSize, borderSize, -borderSize, -borderSize);
+                extraClip ^= content;
+            }
+        }
+        addBorderContentClipping = (themeData.noBorder | themeData.noContent);
+    }
+
+    QImage img;
+    if (!haveCachedPixmap) { // If the pixmap is not cached, generate it! -------------------------
+        buffer(w, h); // Ensure a buffer of at least (w, h) in size
+        HDC dc = bufferHDC();
+
+        // Clear the buffer
+        if (alphaType != NoAlpha) {
+            // Consider have separate "memset" function for small chunks for more speedup
+            memset(bufferPixels, inspectData ? 0xFF : 0x00, bufferW * h * 4);
+        }
+
+        // Difference between area and rect
+        int dx = area.x() - rect.x();
+        int dy = area.y() - rect.y();
+        int dr = area.right() - rect.right();
+        int db = area.bottom() - rect.bottom();
+
+        // Adjust so painting rect starts from Origo
+        rect.moveTo(0,0);
+        area.moveTo(dx,dy);
+        DTBGOPTS drawOptions;
+        drawOptions.dwSize = sizeof(drawOptions);
+        drawOptions.rcClip = themeData.toRECT(rect);
+        drawOptions.dwFlags = DTBG_CLIPRECT
+                            | (themeData.noBorder ? DTBG_OMITBORDER : 0)
+                            | (themeData.noContent ? DTBG_OMITCONTENT : 0);
+
+        // Drawing the part into the backing store
+        if (pDrawThemeBackgroundEx != 0) {
+            RECT rect(themeData.toRECT(area));
+            pDrawThemeBackgroundEx(themeData.handle(), dc, themeData.partId, themeData.stateId, &rect, &drawOptions);
+        } else {
+            // Set the clip region, if used..
+            if (addBorderContentClipping) {
+                SelectClipRgn(dc, extraClip.handle());
+                // Compensate for the noBorder area difference (noContent has the same area)
+                drawOptions.rcClip = themeData.toRECT(rect.adjusted(dx, dy, dr, db));
+            }
+
+            pDrawThemeBackground(themeData.handle(), dc, themeData.partId, themeData.stateId, &(drawOptions.rcClip), 0);
+
+            if (addBorderContentClipping)
+                SelectClipRgn(dc, 0);
+        }
+
+        // If not cached, analyze the buffer data to figure
+        // out alpha type, and if it contains data
+        if (!isCached) {
+            if (inspectData)
+                stateHasData = hasAnyData(rect);
+            // SHORTCUT: If the part's state has no data, cache it for NOOP later
+            if (!stateHasData) {
+                memset(&data, 0, sizeof(data));
+                data.dataValid = true;
+                alphaCache.insert(key, data);
+                return;
+            }
+            hasAlpha = hasAlphaChannel(rect);
+            if (!hasAlpha && partIsTransparent)
+                potentialInvalidAlpha = true;
+#if defined(DEBUG_XP_STYLE) && 1
+            dumpNativeDIB(w, h);
+#endif
+        }
+
+        // Swap alpha values, if needed
+        if (inspectData)
+            wasAlphaSwapped = swapAlphaChannel(rect);
+
+        // Fix alpha values, if needed
+        if (potentialInvalidAlpha)
+            wasAlphaFixed = fixAlphaChannel(rect);
+
+        QImage::Format format;
+        if ((partIsTransparent && !wasAlphaSwapped) || (!partIsTransparent && hasAlpha)) {
+            format = QImage::Format_ARGB32_Premultiplied;
+            alphaType = RealAlpha;
+        } else if (wasAlphaSwapped) {
+            format = QImage::Format_ARGB32_Premultiplied;
+            alphaType = MaskAlpha;
+        } else {
+            format = QImage::Format_RGB32;
+            // The image data we got from the theme engine does not have any transparency,
+            // thus the alpha channel is set to 0.
+            // However, Format_RGB32 requires the alpha part to be set to 0xff, thus
+            // we must flip it from 0x00 to 0xff
+            swapAlphaChannel(rect, true);
+            alphaType = NoAlpha;
+        }
+#if defined(DEBUG_XP_STYLE) && 1
+        printf("Image format is: %s\n", alphaType == RealAlpha ? "Real Alpha" : alphaType == MaskAlpha ? "Masked Alpha" : "No Alpha");
+#endif
+        img = QImage(bufferPixels, bufferW, bufferH, format);
+    }
+
+    // Blitting backing store
+    bool useRegion = partIsTransparent && !hasAlpha && !wasAlphaSwapped;
+
+    QRegion newRegion;
+    QRegion oldRegion;
+    if (useRegion) {
+        newRegion = region(themeData);
+        oldRegion = painter->clipRegion();
+        painter->setClipRegion(newRegion);
+#if defined(DEBUG_XP_STYLE) && 0
+        printf("Using region:\n");
+        QVector<QRect> rects = newRegion.rects();
+        for (int i = 0; i < rects.count(); ++i) {
+            const QRect &r = rects.at(i);
+            printf("    (%d, %d, %d, %d)\n", r.x(), r.y(), r.right(), r.bottom());
+        }
+#endif
+    }
+
+    if (addBorderContentClipping)
+        painter->setClipRegion(extraClip, Qt::IntersectClip);
+
+    if (!themeData.mirrorHorizontally && !themeData.mirrorVertically && !themeData.rotate) {
+        if (!haveCachedPixmap)
+            painter->drawImage(themeData.rect, img, rect);
+        else
+            painter->drawPixmap(themeData.rect, cachedPixmap);
+    } else {
+        // This is _slow_!
+        // Make a copy containing only the necessary data, and mirror
+        // on all wanted axes. Then draw the copy.
+        // If cached, the normal pixmap is cached, instead of caching
+        // all possible orientations for each part and state.
+        QImage imgCopy;
+        if (!haveCachedPixmap)
+            imgCopy = img.copy(rect);
+        else
+            imgCopy = cachedPixmap.toImage();
+
+        if (themeData.rotate) {
+            QMatrix rotMatrix;
+            rotMatrix.rotate(themeData.rotate);
+            imgCopy = imgCopy.transformed(rotMatrix);
+        }
+        if (themeData.mirrorHorizontally || themeData.mirrorVertically) {
+            imgCopy = imgCopy.mirrored(themeData.mirrorHorizontally, themeData.mirrorVertically);
+        }
+        painter->drawImage(themeData.rect,
+                           imgCopy);
+    }
+
+    if (useRegion || addBorderContentClipping) {
+        if (oldRegion.isEmpty())
+            painter->setClipping(false);
+        else
+            painter->setClipRegion(oldRegion);
+    }
+
+    // Cache the pixmap to avoid expensive swapAlphaChannel() calls
+    if (!haveCachedPixmap && w && h) {
+        QPixmap pix = QPixmap::fromImage(img).copy(rect);
+        QPixmapCache::insert(pixmapCacheKey, pix);
+#ifdef DEBUG_XP_STYLE
+        printf("+++Adding pixmap to cache, size(%d, %d), wasAlphaSwapped(%d), wasAlphaFixed(%d), name(%s)\n",
+               w, h, wasAlphaSwapped, wasAlphaFixed, qPrintable(pixmapCacheKey));
+#endif
+    }
+
+    // Add to theme part cache
+    if (!isCached) {
+        memset(&data, 0, sizeof(data));
+        data.dataValid = true;
+        data.partIsTransparent = partIsTransparent;
+        data.alphaType = alphaType;
+        data.hasAlphaChannel = hasAlpha;
+        data.hasAnyData = stateHasData;
+        data.wasAlphaSwapped = wasAlphaSwapped;
+        data.hadInvalidAlpha = wasAlphaFixed;
+        alphaCache.insert(key, data);
+    }
+}
+
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \class QWindowsXPStyle
+    \brief The QWindowsXPStyle class provides a Microsoft Windows XP-like look and feel.
+
+    \ingroup appearance
+
+    \warning This style is only available on the Windows XP platform
+    because it makes use of Windows XP's style engine.
+
+    Most of the functions are documented in the base classes
+    QWindowsStyle, QCommonStyle, and QStyle, but the
+    QWindowsXPStyle overloads of drawComplexControl(), drawControl(),
+    drawControlMask(), drawPrimitive(), subControlRect(), and
+    sizeFromContents(), are documented here.
+
+    \img qwindowsxpstyle.png
+    \sa QMacStyle, QWindowsStyle, QPlastiqueStyle, QCDEStyle, QMotifStyle
+*/
+
+/*!
+    Constructs a QWindowsStyle
+*/
+QWindowsXPStyle::QWindowsXPStyle()
+    : QWindowsStyle(*new QWindowsXPStylePrivate)
+{
+}
+
+/*!
+    Destroys the style.
+*/
+QWindowsXPStyle::~QWindowsXPStyle()
+{
+}
+
+/*! \reimp */
+void QWindowsXPStyle::unpolish(QApplication *app)
+{
+    QWindowsStyle::unpolish(app);
+}
+
+/*! \reimp */
+void QWindowsXPStyle::polish(QApplication *app)
+{
+    QWindowsStyle::polish(app);
+    if (!QWindowsXPStylePrivate::useXP())
+        return;
+}
+
+/*! \reimp */
+void QWindowsXPStyle::polish(QWidget *widget)
+{
+    QWindowsStyle::polish(widget);
+    if (!QWindowsXPStylePrivate::useXP())
+        return;
+
+    if (qobject_cast<QAbstractButton*>(widget)
+        || qobject_cast<QToolButton*>(widget)
+        || qobject_cast<QTabBar*>(widget)
+#ifndef QT_NO_COMBOBOX
+        || qobject_cast<QComboBox*>(widget)
+#endif // QT_NO_COMBOBOX
+        || qobject_cast<QScrollBar*>(widget)
+        || qobject_cast<QSlider*>(widget)
+        || qobject_cast<QHeaderView*>(widget)
+#ifndef QT_NO_SPINBOX
+        || qobject_cast<QAbstractSpinBox*>(widget)
+        || qobject_cast<QSpinBox*>(widget)
+#endif // QT_NO_SPINBOX
+        || widget->inherits("QWorkspaceChild")
+        || widget->inherits("Q3TitleBar"))
+        widget->setAttribute(Qt::WA_Hover);
+
+#ifndef QT_NO_RUBBERBAND
+    if (qobject_cast<QRubberBand*>(widget)) {
+        widget->setWindowOpacity(0.6);
+    }
+#endif
+    if (qobject_cast<QStackedWidget*>(widget) &&
+               qobject_cast<QTabWidget*>(widget->parent()))
+        widget->parentWidget()->setAttribute(Qt::WA_ContentsPropagated);
+
+    Q_D(QWindowsXPStyle);
+    if (!d->hasInitColors) {
+        // Get text color for group box labels
+        COLORREF cref;
+        XPThemeData theme(0, 0, QLatin1String("BUTTON"), 0, 0);
+        pGetThemeColor(theme.handle(), BP_GROUPBOX, GBS_NORMAL, TMT_TEXTCOLOR, &cref);
+        d->groupBoxTextColor = qRgb(GetRValue(cref), GetGValue(cref), GetBValue(cref));
+        pGetThemeColor(theme.handle(), BP_GROUPBOX, GBS_DISABLED, TMT_TEXTCOLOR, &cref);
+        d->groupBoxTextColorDisabled = qRgb(GetRValue(cref), GetGValue(cref), GetBValue(cref));
+        // Where does this color come from?
+        //pGetThemeColor(theme.handle(), TKP_TICS, TSS_NORMAL, TMT_COLOR, &cref);
+        d->sliderTickColor = qRgb(165, 162, 148);
+        d->hasInitColors = true;
+    }
+}
+
+/*! \reimp */
+void QWindowsXPStyle::polish(QPalette &pal)
+{
+    QWindowsStyle::polish(pal);
+    pal.setBrush(QPalette::AlternateBase, pal.base().color().darker(110));
+}
+
+/*! \reimp */
+void QWindowsXPStyle::unpolish(QWidget *widget)
+{
+#ifndef QT_NO_RUBBERBAND
+    if (qobject_cast<QRubberBand*>(widget)) {
+        widget->setWindowOpacity(1.0);
+    }
+#endif
+    Q_D(QWindowsXPStyle);
+    // Unpolish of widgets is the first thing that
+    // happens when a theme changes, or the theme
+    // engine is turned off. So we detect it here.
+    bool oldState = QWindowsXPStylePrivate::useXP();
+    bool newState = QWindowsXPStylePrivate::useXP(true);
+    if ((oldState != newState) && newState) {
+        d->cleanup(true);
+        d->init(true);
+    } else {
+        // Cleanup handle map, if just changing style,
+        // or turning it on. In both cases the values
+        // already in the map might be old (other style).
+        d->cleanupHandleMap();
+    }
+    if (qobject_cast<QAbstractButton*>(widget)
+        || qobject_cast<QToolButton*>(widget)
+        || qobject_cast<QTabBar*>(widget)
+#ifndef QT_NO_COMBOBOX
+        || qobject_cast<QComboBox*>(widget)
+#endif // QT_NO_COMBOBOX
+        || qobject_cast<QScrollBar*>(widget)
+        || qobject_cast<QSlider*>(widget)
+        || qobject_cast<QHeaderView*>(widget)
+#ifndef QT_NO_SPINBOX
+        || qobject_cast<QAbstractSpinBox*>(widget)
+        || qobject_cast<QSpinBox*>(widget)
+#endif // QT_NO_SPINBOX
+        || widget->inherits("QWorkspaceChild")
+        || widget->inherits("Q3TitleBar"))
+        widget->setAttribute(Qt::WA_Hover, false);
+    QWindowsStyle::unpolish(widget);
+}
+
+/*! \reimp */
+QRect QWindowsXPStyle::subElementRect(SubElement sr, const QStyleOption *option, const QWidget *widget) const
+{
+    if (!QWindowsXPStylePrivate::useXP()) {
+        return QWindowsStyle::subElementRect(sr, option, widget);
+    }
+
+    QRect rect(option->rect);
+    switch(sr) {
+    case SE_DockWidgetCloseButton:
+    case SE_DockWidgetFloatButton:
+        rect = QWindowsStyle::subElementRect(sr, option, widget);
+        return rect.translated(0, 1);
+    break;
+    case SE_TabWidgetTabContents:
+        if (qstyleoption_cast<const QStyleOptionTabWidgetFrame *>(option))
+        {
+            rect = QWindowsStyle::subElementRect(sr, option, widget);
+            if (sr == SE_TabWidgetTabContents)
+                   rect.adjust(0, 0, -2, -2);
+        }
+        break;
+    case SE_TabWidgetTabBar: {
+        rect = QWindowsStyle::subElementRect(sr, option, widget);
+        const QStyleOptionTabWidgetFrame *twfOption =
+            qstyleoption_cast<const QStyleOptionTabWidgetFrame *>(option);
+        if (twfOption && twfOption->direction == Qt::RightToLeft
+            && (twfOption->shape == QTabBar::RoundedNorth
+                || twfOption->shape == QTabBar::RoundedSouth))
+        {
+            QStyleOptionTab otherOption;
+            otherOption.shape = (twfOption->shape == QTabBar::RoundedNorth
+                                ? QTabBar::RoundedEast : QTabBar::RoundedSouth);
+            int overlap = pixelMetric(PM_TabBarBaseOverlap, &otherOption, widget);
+            int borderThickness = pixelMetric(PM_DefaultFrameWidth, option, widget);
+            rect.adjust(-overlap + borderThickness, 0, -overlap + borderThickness, 0);
+        }
+        break;}
+
+    case SE_PushButtonContents:
+        if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {
+            MARGINS borderSize;
+            if (widget) {
+                HTHEME theme = pOpenThemeData(QWindowsXPStylePrivate::winId(widget), L"Button");
+                if (theme) {
+                    int stateId;
+                    if (!(option->state & State_Enabled))
+                        stateId = PBS_DISABLED;
+                    else if (option->state & State_Sunken)
+                        stateId = PBS_PRESSED;
+                    else if (option->state & State_MouseOver)
+                        stateId = PBS_HOT;
+                    else if (btn->features & QStyleOptionButton::DefaultButton)
+                        stateId = PBS_DEFAULTED;
+                    else
+                        stateId = PBS_NORMAL;
+
+                    int border = pixelMetric(PM_DefaultFrameWidth, btn, widget);
+                    rect = option->rect.adjusted(border, border, -border, -border);
+
+                    int result = pGetThemeMargins(theme,
+                                                  NULL,
+                                                  BP_PUSHBUTTON,
+                                                  stateId,
+                                                  TMT_CONTENTMARGINS,
+                                                  NULL,
+                                                  &borderSize);
+
+                    if (result == S_OK) {
+                        rect.adjust(borderSize.cxLeftWidth, borderSize.cyTopHeight,
+                                    -borderSize.cxRightWidth, -borderSize.cyBottomHeight);
+                        rect = visualRect(option->direction, option->rect, rect);
+                    }
+                }
+            }
+        }
+        break;
+    case SE_ProgressBarContents:
+        rect = QCommonStyle::subElementRect(SE_ProgressBarGroove, option, widget);
+        if (option->state & QStyle::State_Horizontal)
+            rect.adjust(4, 3, -4, -3);
+        else
+            rect.adjust(3, 2, -3, -2);
+        break;
+    default:
+        rect = QWindowsStyle::subElementRect(sr, option, widget);
+    }
+    return rect;
+}
+
+/*!
+    \reimp
+*/
+void QWindowsXPStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *option, QPainter *p,
+                                    const QWidget *widget) const
+{
+    QWindowsXPStylePrivate *d = const_cast<QWindowsXPStylePrivate*>(d_func());
+
+    if (!QWindowsXPStylePrivate::useXP()) {
+        QWindowsStyle::drawPrimitive(pe, option, p, widget);
+        return;
+    }
+
+    QString name;
+    int partId = 0;
+    int stateId = 0;
+    QRect rect = option->rect;
+    State flags = option->state;
+    bool hMirrored = false;
+    bool vMirrored = false;
+    bool noBorder = false;
+    bool noContent = false;
+    int  rotate = 0;
+
+    switch (pe) {
+    case PE_FrameTabBarBase:
+        if (const QStyleOptionTabBarBase *tbb
+                = qstyleoption_cast<const QStyleOptionTabBarBase *>(option)) {
+            p->save();
+            switch (tbb->shape) {
+            case QTabBar::RoundedNorth:
+                p->setPen(QPen(tbb->palette.dark(), 0));
+                p->drawLine(tbb->rect.topLeft(), tbb->rect.topRight());
+                break;
+            case QTabBar::RoundedWest:
+                p->setPen(QPen(tbb->palette.dark(), 0));
+                p->drawLine(tbb->rect.left(), tbb->rect.top(), tbb->rect.left(), tbb->rect.bottom());
+                break;
+            case QTabBar::RoundedSouth:
+                p->setPen(QPen(tbb->palette.dark(), 0));
+                p->drawLine(tbb->rect.left(), tbb->rect.top(),
+                            tbb->rect.right(), tbb->rect.top());
+                break;
+            case QTabBar::RoundedEast:
+                p->setPen(QPen(tbb->palette.dark(), 0));
+                p->drawLine(tbb->rect.topLeft(), tbb->rect.bottomLeft());
+                break;
+            case QTabBar::TriangularNorth:
+            case QTabBar::TriangularEast:
+            case QTabBar::TriangularWest:
+            case QTabBar::TriangularSouth:
+                p->restore();
+                QWindowsStyle::drawPrimitive(pe, option, p, widget);
+                return;
+            }
+            p->restore();
+        }
+        return;
+    case PE_PanelButtonBevel:
+        name = QLatin1String("BUTTON");
+        partId = BP_PUSHBUTTON;
+        if (!(flags & State_Enabled))
+            stateId = PBS_DISABLED;
+        else if ((flags & State_Sunken) || (flags & State_On))
+            stateId = PBS_PRESSED;
+        else if (flags & State_MouseOver)
+            stateId = PBS_HOT;
+        //else if (flags & State_ButtonDefault)
+        //    stateId = PBS_DEFAULTED;
+        else
+            stateId = PBS_NORMAL;
+        break;
+
+    case PE_PanelButtonTool:
+        if (widget && widget->inherits("QDockWidgetTitleButton")) {
+            if (const QWidget *dw = widget->parentWidget())
+                if (dw->isWindow())
+                    return;
+        }
+        name = QLatin1String("TOOLBAR");
+        partId = TP_BUTTON;
+        if (!(flags & State_Enabled))
+            stateId = TS_DISABLED;
+        else if (flags & State_Sunken)
+            stateId = TS_PRESSED;
+        else if (flags & State_MouseOver)
+            stateId = flags & State_On ? TS_HOTCHECKED : TS_HOT;
+        else if (flags & State_On)
+            stateId = TS_CHECKED;
+        else if (!(flags & State_AutoRaise))
+            stateId = TS_HOT;
+        else
+            stateId = TS_NORMAL;
+        break;
+
+    case PE_IndicatorButtonDropDown:
+        name = QLatin1String("TOOLBAR");
+        partId = TP_SPLITBUTTONDROPDOWN;
+        if (!(flags & State_Enabled))
+            stateId = TS_DISABLED;
+        else if (flags & State_Sunken)
+            stateId = TS_PRESSED;
+        else if (flags & State_MouseOver)
+            stateId = flags & State_On ? TS_HOTCHECKED : TS_HOT;
+        else if (flags & State_On)
+            stateId = TS_CHECKED;
+        else if (!(flags & State_AutoRaise))
+            stateId = TS_HOT;
+        else
+            stateId = TS_NORMAL;
+        if (option->direction == Qt::RightToLeft)
+            hMirrored = true;
+        break;
+
+    case PE_IndicatorCheckBox:
+        name = QLatin1String("BUTTON");
+        partId = BP_CHECKBOX;
+        if (!(flags & State_Enabled))
+            stateId = CBS_UNCHECKEDDISABLED;
+        else if (flags & State_Sunken)
+            stateId = CBS_UNCHECKEDPRESSED;
+        else if (flags & State_MouseOver)
+            stateId = CBS_UNCHECKEDHOT;
+        else
+            stateId = CBS_UNCHECKEDNORMAL;
+
+        if (flags & State_On)
+            stateId += CBS_CHECKEDNORMAL-1;
+        else if (flags & State_NoChange)
+            stateId += CBS_MIXEDNORMAL-1;
+
+        break;
+
+    case PE_IndicatorRadioButton:
+        name = QLatin1String("BUTTON");
+        partId = BP_RADIOBUTTON;
+        if (!(flags & State_Enabled))
+            stateId = RBS_UNCHECKEDDISABLED;
+        else if (flags & State_Sunken)
+            stateId = RBS_UNCHECKEDPRESSED;
+        else if (flags & State_MouseOver)
+            stateId = RBS_UNCHECKEDHOT;
+        else
+            stateId = RBS_UNCHECKEDNORMAL;
+
+        if (flags & State_On)
+            stateId += RBS_CHECKEDNORMAL-1;
+        break;
+
+    case PE_IndicatorDockWidgetResizeHandle:
+        return;
+
+case PE_Frame:
+    {
+        if (flags & State_Raised)
+            return;
+        name = QLatin1String("LISTVIEW");
+        partId = LVP_LISTGROUP;
+        XPThemeData theme(0, 0, name, partId, 0);
+
+        if (!(flags & State_Enabled))
+            stateId = ETS_DISABLED;
+        else
+            stateId = ETS_NORMAL;
+        int fillType;
+        if (pGetThemeEnumValue(theme.handle(), partId, stateId, TMT_BGTYPE, &fillType) == S_OK) {
+            if (fillType == BT_BORDERFILL) {
+                COLORREF bcRef;
+                pGetThemeColor(theme.handle(), partId, stateId, TMT_BORDERCOLOR, &bcRef);
+                QColor bordercolor(qRgb(GetRValue(bcRef), GetGValue(bcRef), GetBValue(bcRef)));
+                QPen oldPen = p->pen();
+                // int borderSize = 1;
+                // pGetThemeInt(theme.handle(), partId, stateId, TMT_BORDERCOLOR, &borderSize);
+
+                // Inner white border
+                p->setPen(QPen(option->palette.base().color(), 1));
+                p->drawRect(option->rect.adjusted(1, 1, -2, -2));
+                // Outer dark border
+                p->setPen(QPen(bordercolor, 1));
+                p->drawRect(option->rect.adjusted(0, 0, -1, -1));
+                p->setPen(oldPen);
+                return;
+            } else if (fillType == BT_NONE) {
+                return;
+            } else {
+                break;
+            }
+        }
+    }
+    case PE_FrameLineEdit: {
+        // we try to check if this lineedit is a delegate on a QAbstractItemView-derived class.
+        QWidget *parentWidget = 0;
+        if (widget)
+            parentWidget = widget->parentWidget();
+        if (parentWidget)
+            parentWidget = parentWidget->parentWidget();
+        if (widget && widget->inherits("QLineEdit")
+            && parentWidget && parentWidget->inherits("QAbstractItemView")) {
+            QPen oldPen = p->pen();
+            // Inner white border
+            p->setPen(QPen(option->palette.base().color(), 1));
+            p->drawRect(option->rect.adjusted(1, 1, -2, -2));
+            // Outer dark border
+            p->setPen(QPen(option->palette.shadow().color(), 1));
+            p->drawRect(option->rect.adjusted(0, 0, -1, -1));
+            p->setPen(oldPen);
+            return;
+        } else if (qstyleoption_cast<const QStyleOptionFrame *>(option)) {
+            name = QLatin1String("EDIT");
+            partId = EP_EDITTEXT;
+            noContent = true;
+            if (!(flags & State_Enabled))
+                stateId = ETS_DISABLED;
+            else
+                stateId = ETS_NORMAL;
+        }
+        break;
+    }
+
+    case PE_PanelLineEdit:
+        if (const QStyleOptionFrame *panel = qstyleoption_cast<const QStyleOptionFrame *>(option)) {
+            name = QLatin1String("EDIT");
+            partId = EP_EDITTEXT;
+            noBorder = true;
+            QBrush bg;
+            bool usePalette = false;
+            bool isEnabled = flags & State_Enabled;
+            uint resolve_mask = panel->palette.resolve();
+
+#ifndef QT_NO_SPINBOX
+            //Since spin box includes a line edit we need to resolve the palette on the spin box instead
+            if (widget) {
+                if (QAbstractSpinBox *spinbox = qobject_cast<QAbstractSpinBox*>(widget->parentWidget()))
+                    resolve_mask = spinbox->palette().resolve();
+            }
+#endif // QT_NO_SPINBOX
+            if (resolve_mask & (1 << QPalette::Base)) {
+                // Base color is set for this widget, so use it
+                bg = panel->palette.brush(QPalette::Base);
+                usePalette = true;
+            }
+
+            stateId = isEnabled ? ETS_NORMAL : ETS_DISABLED;
+
+            if (usePalette) {
+                p->fillRect(panel->rect, bg);
+            } else {
+                XPThemeData theme(0, p, name, partId, stateId, rect);
+                if (!theme.isValid()) {
+                    QWindowsStyle::drawPrimitive(pe, option, p, widget);
+                    return;
+                }
+                int bgType;
+                pGetThemeEnumValue( theme.handle(),
+                                    partId,
+                                    stateId,
+                                    TMT_BGTYPE,
+                                    &bgType);
+                if( bgType == BT_IMAGEFILE ) {
+                    theme.mirrorHorizontally = hMirrored;
+                    theme.mirrorVertically = vMirrored;
+                    theme.noBorder = noBorder;
+                    theme.noContent = noContent;
+                    theme.rotate = rotate;
+                    d->drawBackground(theme);
+                } else {
+                    QBrush fillColor = option->palette.brush(QPalette::Base);
+
+                    if (!isEnabled) {
+                        PROPERTYORIGIN origin = PO_NOTFOUND;
+                        pGetThemePropertyOrigin(theme.handle(), theme.partId, theme.stateId, TMT_FILLCOLOR, &origin);
+                        // Use only if the fill property comes from our part
+                        if ((origin == PO_PART || origin == PO_STATE)) {
+                            COLORREF bgRef;
+                            pGetThemeColor(theme.handle(), partId, stateId, TMT_FILLCOLOR, &bgRef);
+                            fillColor = QBrush(qRgb(GetRValue(bgRef), GetGValue(bgRef), GetBValue(bgRef)));
+                        }
+                    }
+                    p->fillRect(option->rect, fillColor);
+                }
+            }
+
+            if (panel->lineWidth > 0)
+                drawPrimitive(PE_FrameLineEdit, panel, p, widget);
+            return;
+        }
+        break;
+
+    case PE_FrameTabWidget:
+        if (const QStyleOptionTabWidgetFrame *tab = qstyleoption_cast<const QStyleOptionTabWidgetFrame *>(option))
+        {
+            name = QLatin1String("TAB");
+            partId = TABP_PANE;
+
+            if (widget) {
+                bool useGradient = true;
+                const int maxlength = 256;
+                WCHAR themeFileName[maxlength];
+                WCHAR themeColor[maxlength];
+                // Due to a a scaling issue with the XP Silver theme, tab gradients are not used with it
+                if (pGetCurrentThemeName(themeFileName, maxlength, themeColor, maxlength, NULL, 0) == S_OK) {
+                    WCHAR* offset;
+                    if ((offset = wcsrchr(themeFileName, QChar(QLatin1Char('\\')).unicode())) != NULL) {
+                        offset++;
+                        if (!lstrcmp(offset, L"Luna.msstyles") && !lstrcmp(offset, L"Metallic")) {
+                            useGradient = false;
+                        }
+                    }
+                }
+                // This should work, but currently there's an error in the ::drawBackgroundDirectly()
+                // code, when using the HDC directly..
+                if (useGradient) {
+                    QStyleOptionTabWidgetFrame frameOpt = *tab;
+                    frameOpt.rect = widget->rect();
+                    QRect contentsRect = subElementRect(SE_TabWidgetTabContents, &frameOpt, widget);
+                    QRegion reg = option->rect;
+                    reg -= contentsRect;
+                    p->setClipRegion(reg);
+                    XPThemeData theme(widget, p, name, partId, stateId, rect);
+                    theme.mirrorHorizontally = hMirrored;
+                    theme.mirrorVertically = vMirrored;
+                    d->drawBackground(theme);
+                    p->setClipRect(contentsRect);
+                    partId = TABP_BODY;
+                }
+            }
+            switch (tab->shape) {
+            case QTabBar::RoundedNorth:
+            case QTabBar::TriangularNorth:
+                break;
+            case QTabBar::RoundedSouth:
+            case QTabBar::TriangularSouth:
+                vMirrored = true;
+                break;
+            case QTabBar::RoundedEast:
+            case QTabBar::TriangularEast:
+                rotate = 90;
+                break;
+            case QTabBar::RoundedWest:
+            case QTabBar::TriangularWest:
+                rotate = 90;
+                hMirrored = true;
+                break;
+            default:
+                break;
+            }
+        }
+        break;
+
+    case PE_FrameMenu:
+        p->save();
+        p->setPen(option->palette.dark().color());
+        p->drawRect(rect.adjusted(0, 0, -1, -1));
+        p->restore();
+        return;
+
+    case PE_PanelMenuBar:
+        break;
+
+ case PE_FrameDockWidget:
+     if (const QStyleOptionFrame *frm = qstyleoption_cast<const QStyleOptionFrame *>(option))
+        {
+            name = QLatin1String("WINDOW");
+            if (flags & State_Active)
+                stateId = FS_ACTIVE;
+            else
+                stateId = FS_INACTIVE;
+
+            int fwidth = pixelMetric(PM_DockWidgetFrameWidth, frm, widget);
+
+            XPThemeData theme(widget, p, name, 0, stateId);
+            if (!theme.isValid())
+                break;
+            theme.rect = QRect(frm->rect.x(), frm->rect.y(), frm->rect.x()+fwidth, frm->rect.height()-fwidth);           theme.partId = WP_SMALLFRAMELEFT;
+            d->drawBackground(theme);
+            theme.rect = QRect(frm->rect.width()-fwidth, frm->rect.y(), fwidth, frm->rect.height()-fwidth);
+            theme.partId = WP_SMALLFRAMERIGHT;
+            d->drawBackground(theme);
+            theme.rect = QRect(frm->rect.x(), frm->rect.bottom()-fwidth+1, frm->rect.width(), fwidth);
+            theme.partId = WP_SMALLFRAMEBOTTOM;
+            d->drawBackground(theme);
+            return;
+        }
+        break;
+
+    case PE_IndicatorHeaderArrow:
+        {
+#if 0 // XP theme engine doesn't know about this :(
+            name = QLatin1String("HEADER");
+            partId = HP_HEADERSORTARROW;
+            if (flags & State_Down)
+                stateId = HSAS_SORTEDDOWN;
+            else
+                stateId = HSAS_SORTEDUP;
+#else
+            if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
+                p->save();
+                p->setPen(option->palette.dark().color());
+                p->translate(0, option->rect.height()/2 - 4);
+                if (header->sortIndicator & QStyleOptionHeader::SortUp) { // invert logic to follow Windows style guide
+                    p->drawLine(option->rect.x(), option->rect.y(), option->rect.x()+8, option->rect.y());
+                    p->drawLine(option->rect.x()+1, option->rect.y()+1, option->rect.x()+7, option->rect.y()+1);
+                    p->drawLine(option->rect.x()+2, option->rect.y()+2, option->rect.x()+6, option->rect.y()+2);
+                    p->drawLine(option->rect.x()+3, option->rect.y()+3, option->rect.x()+5, option->rect.y()+3);
+                    p->drawPoint(option->rect.x()+4, option->rect.y()+4);
+                } else if(header->sortIndicator & QStyleOptionHeader::SortDown) {
+                    p->drawLine(option->rect.x(), option->rect.y()+4, option->rect.x()+8, option->rect.y()+4);
+                    p->drawLine(option->rect.x()+1, option->rect.y()+3, option->rect.x()+7, option->rect.y()+3);
+                    p->drawLine(option->rect.x()+2, option->rect.y()+2, option->rect.x()+6, option->rect.y()+2);
+                    p->drawLine(option->rect.x()+3, option->rect.y()+1, option->rect.x()+5, option->rect.y()+1);
+                    p->drawPoint(option->rect.x()+4, option->rect.y());
+                }
+                p->restore();
+                return;
+            }
+#endif
+        }
+        break;
+
+    case PE_FrameStatusBarItem:
+        name = QLatin1String("STATUS");
+        partId = SP_PANE;
+        break;
+
+    case PE_FrameGroupBox:
+        name = QLatin1String("BUTTON");
+        partId = BP_GROUPBOX;
+        if (!(flags & State_Enabled))
+            stateId = GBS_DISABLED;
+        else
+            stateId = GBS_NORMAL;
+        if (const QStyleOptionFrame *frame = qstyleoption_cast<const QStyleOptionFrame *>(option)) {
+            const QStyleOptionFrameV2 *frame2 = qstyleoption_cast<const QStyleOptionFrameV2 *>(option);
+            if (frame2->features & QStyleOptionFrameV2::Flat) {
+                // Windows XP does not have a theme part for a flat GroupBox, paint it with the windows style
+                QRect fr = frame->rect;
+                QPoint p1(fr.x(), fr.y() + 1);
+                QPoint p2(fr.x() + fr.width(), p1.y() + 1);
+                rect = QRect(p1, p2);
+                name = QLatin1String("");
+            }
+        }
+        break;
+
+    case PE_IndicatorProgressChunk:
+        {
+        Qt::Orientation orient = Qt::Horizontal;
+        bool inverted = false;
+        if (const QStyleOptionProgressBarV2 *pb2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {
+            orient = pb2->orientation;
+            if (pb2->invertedAppearance)
+                inverted = true;
+        }
+        if (orient == Qt::Horizontal) {
+            partId = PP_CHUNK;
+            rect = QRect(option->rect.x(), option->rect.y(), option->rect.width(), option->rect.height() );
+            if (inverted && option->direction == Qt::LeftToRight)
+                hMirrored = true;
+        } else {
+            partId = PP_CHUNKVERT;
+            rect = QRect(option->rect.x(), option->rect.y(), option->rect.width(), option->rect.height());
+        }
+        name = QLatin1String("PROGRESS");
+        stateId = 1;
+        }
+        break;
+
+    case PE_Q3DockWindowSeparator:
+        name = QLatin1String("TOOLBAR");
+        if (flags & State_Horizontal)
+            partId = TP_SEPARATOR;
+        else
+            partId = TP_SEPARATORVERT;
+        break;
+
+    case PE_FrameWindow:
+        if (const QStyleOptionFrame *frm = qstyleoption_cast<const QStyleOptionFrame *>(option))
+        {
+            name = QLatin1String("WINDOW");
+            if (flags & State_Active)
+                stateId = FS_ACTIVE;
+            else
+                stateId = FS_INACTIVE;
+
+            int fwidth = frm->lineWidth + frm->midLineWidth;
+
+            XPThemeData theme(0, p, name, 0, stateId);
+            if (!theme.isValid())
+                break;
+
+            theme.rect = QRect(option->rect.x(), option->rect.y()+fwidth, option->rect.x()+fwidth, option->rect.height()-fwidth);
+            theme.partId = WP_FRAMELEFT;
+            d->drawBackground(theme);
+            theme.rect = QRect(option->rect.width()-fwidth, option->rect.y()+fwidth, fwidth, option->rect.height()-fwidth);
+            theme.partId = WP_FRAMERIGHT;
+            d->drawBackground(theme);
+            theme.rect = QRect(option->rect.x(), option->rect.height()-fwidth, option->rect.width(), fwidth);
+            theme.partId = WP_FRAMEBOTTOM;
+            d->drawBackground(theme);
+            theme.rect = QRect(option->rect.x(), option->rect.y(), option->rect.width(), option->rect.y()+fwidth);
+            theme.partId = WP_CAPTION;
+            d->drawBackground(theme);
+            return;
+        }
+        break;
+
+    case PE_IndicatorBranch:
+        {
+            static const int decoration_size = 9;
+            int mid_h = option->rect.x() + option->rect.width() / 2;
+            int mid_v = option->rect.y() + option->rect.height() / 2;
+            int bef_h = mid_h;
+            int bef_v = mid_v;
+            int aft_h = mid_h;
+            int aft_v = mid_v;
+            QBrush brush(option->palette.dark().color(), Qt::Dense4Pattern);
+            if (option->state & State_Item) {
+                if (option->direction == Qt::RightToLeft)
+                    p->fillRect(option->rect.left(), mid_v, bef_h - option->rect.left(), 1, brush);
+                else
+                    p->fillRect(aft_h, mid_v, option->rect.right() - aft_h + 1, 1, brush);
+            }
+            if (option->state & State_Sibling)
+                p->fillRect(mid_h, aft_v, 1, option->rect.bottom() - aft_v + 1, brush);
+            if (option->state & (State_Open | State_Children | State_Item | State_Sibling))
+                p->fillRect(mid_h, option->rect.y(), 1, bef_v - option->rect.y(), brush);
+            if (option->state & State_Children) {
+                int delta = decoration_size / 2;
+                bef_h -= delta;
+                bef_v -= delta;
+                aft_h += delta;
+                aft_v += delta;
+                XPThemeData theme(0, p, QLatin1String("TREEVIEW"));
+                theme.rect = QRect(bef_h, bef_v, decoration_size, decoration_size);
+                theme.partId = TVP_GLYPH;
+                theme.stateId = flags & QStyle::State_Open ? GLPS_OPENED : GLPS_CLOSED;
+                d->drawBackground(theme);
+            }
+        }
+        return;
+
+    case PE_IndicatorToolBarSeparator:
+
+        name = QLatin1String("TOOLBAR");
+        partId = TP_SEPARATOR;
+
+        if (option->state & State_Horizontal)
+            partId = TP_SEPARATOR;
+        else
+            partId = TP_SEPARATORVERT;
+
+        break;
+
+    case PE_IndicatorToolBarHandle:
+
+        name = QLatin1String("REBAR");
+        partId = RP_GRIPPER;
+        if (option->state & State_Horizontal) {
+            partId = RP_GRIPPER;
+            rect.adjust(0, 0, -2, 0);
+        }
+        else {
+            partId = RP_GRIPPERVERT;
+            rect.adjust(0, 0, 0, -2);
+        }
+        break;
+
+    case PE_IndicatorItemViewItemCheck: {
+        QStyleOptionButton button;
+        button.QStyleOption::operator=(*option);
+        button.state &= ~State_MouseOver;
+        drawPrimitive(PE_IndicatorCheckBox, &button, p, widget);
+        return;
+    }
+
+    default:
+        break;
+    }
+
+    XPThemeData theme(0, p, name, partId, stateId, rect);
+    if (!theme.isValid()) {
+        QWindowsStyle::drawPrimitive(pe, option, p, widget);
+        return;
+    }
+    theme.mirrorHorizontally = hMirrored;
+    theme.mirrorVertically = vMirrored;
+    theme.noBorder = noBorder;
+    theme.noContent = noContent;
+    theme.rotate = rotate;
+    d->drawBackground(theme);
+}
+
+/*!
+    \reimp
+*/
+void QWindowsXPStyle::drawControl(ControlElement element, const QStyleOption *option, QPainter *p,
+                                  const QWidget *widget) const
+{
+  QWindowsXPStylePrivate *d = const_cast<QWindowsXPStylePrivate*>(d_func());
+    if (!QWindowsXPStylePrivate::useXP()) {
+        QWindowsStyle::drawControl(element, option, p, widget);
+        return;
+    }
+
+    QRect rect(option->rect);
+    State flags = option->state;
+
+    int rotate = 0;
+    bool hMirrored = false;
+    bool vMirrored = false;
+
+    QString name;
+    int partId = 0;
+    int stateId = 0;
+    switch (element) {
+    case CE_SizeGrip:
+        {
+            name = QLatin1String("STATUS");
+            partId = SP_GRIPPER;
+            SIZE sz;
+            XPThemeData theme(0, p, name, partId, 0);
+            pGetThemePartSize(theme.handle(), 0, partId, 0, 0, TS_TRUE, &sz);
+            --sz.cy;
+            if (const QStyleOptionSizeGrip *sg = qstyleoption_cast<const QStyleOptionSizeGrip *>(option)) {
+                switch (sg->corner) {
+                    case Qt::BottomRightCorner:
+                        rect = QRect(rect.right() - sz.cx, rect.bottom() - sz.cy, sz.cx, sz.cy);
+                        break;
+                    case Qt::BottomLeftCorner:
+                        rect = QRect(rect.left() + 1, rect.bottom() - sz.cy, sz.cx, sz.cy);
+                        hMirrored = true;
+                        break;
+                    case Qt::TopRightCorner:
+                        rect = QRect(rect.right() - sz.cx, rect.top() + 1, sz.cx, sz.cy);
+                        vMirrored = true;
+                        break;
+                    case Qt::TopLeftCorner:
+                        rect = QRect(rect.left() + 1, rect.top() + 1, sz.cx, sz.cy);
+                        hMirrored = vMirrored = true;
+                }
+            }
+        }
+        break;
+
+    case CE_HeaderSection:
+        name = QLatin1String("HEADER");
+        partId = HP_HEADERITEM;
+        if (flags & State_Sunken)
+            stateId = HIS_PRESSED;
+        else if (flags & State_MouseOver)
+            stateId = HIS_HOT;
+        else
+            stateId = HIS_NORMAL;
+        break;
+
+    case CE_Splitter:
+        p->eraseRect(option->rect);
+        return;
+
+    case CE_PushButtonBevel:
+        if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option))
+        {
+            name = QLatin1String("BUTTON");
+            partId = BP_PUSHBUTTON;
+            bool justFlat = (btn->features & QStyleOptionButton::Flat) && !(flags & (State_On|State_Sunken))
+                || (btn->features & QStyleOptionButton::CommandLinkButton
+                    && !(flags & State_MouseOver)
+                    && !(btn->features & QStyleOptionButton::DefaultButton));
+            if (!(flags & State_Enabled) && !(btn->features & QStyleOptionButton::Flat))
+                stateId = PBS_DISABLED;
+            else if (justFlat)
+                ;
+            else if (flags & (State_Sunken | State_On))
+                stateId = PBS_PRESSED;
+            else if (flags & State_MouseOver)
+                stateId = PBS_HOT;
+            else if (btn->features & QStyleOptionButton::DefaultButton)
+                stateId = PBS_DEFAULTED;
+            else
+                stateId = PBS_NORMAL;
+
+            if (!justFlat) {
+                XPThemeData theme(widget, p, name, partId, stateId, rect);
+                d->drawBackground(theme);
+            }
+
+            if (btn->features & QStyleOptionButton::HasMenu) {
+                int mbiw = 0, mbih = 0;
+                XPThemeData theme(widget, 0, QLatin1String("TOOLBAR"), TP_SPLITBUTTONDROPDOWN);
+                if (theme.isValid()) {
+                    SIZE size;
+                    pGetThemePartSize(theme.handle(), 0, theme.partId, theme.stateId, 0, TS_TRUE, &size);
+                    mbiw = size.cx;
+                    mbih = size.cy;
+                }
+
+                QRect ir = btn->rect;
+                QStyleOptionButton newBtn = *btn;
+                newBtn.rect = QRect(ir.right() - mbiw - 1, 1 + (ir.height()/2) - (mbih/2), mbiw, mbih);
+                drawPrimitive(PE_IndicatorArrowDown, &newBtn, p, widget);
+            }
+            return;
+        }
+        break;
+    case CE_TabBarTab:
+        if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option))
+        {
+            stateId = tab->state & State_Enabled ? TIS_NORMAL : TIS_DISABLED;
+        }
+    break;
+
+    case CE_TabBarTabShape:
+        if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option))
+        {
+            name = QLatin1String("TAB");
+            bool isDisabled = !(tab->state & State_Enabled);
+            bool hasFocus = tab->state & State_HasFocus;
+            bool isHot = tab->state & State_MouseOver;
+            bool selected = tab->state & State_Selected;
+            bool lastTab = tab->position == QStyleOptionTab::End;
+            bool firstTab = tab->position == QStyleOptionTab::Beginning;
+            bool onlyOne = tab->position == QStyleOptionTab::OnlyOneTab;
+            bool leftAligned = styleHint(SH_TabBar_Alignment, tab, widget) == Qt::AlignLeft;
+            bool centerAligned = styleHint(SH_TabBar_Alignment, tab, widget) == Qt::AlignCenter;
+            int borderThickness = pixelMetric(PM_DefaultFrameWidth, option, widget);
+            int tabOverlap = pixelMetric(PM_TabBarTabOverlap, option, widget);
+
+            if (isDisabled)
+                stateId = TIS_DISABLED;
+            else if (selected)
+                stateId = TIS_SELECTED;
+            else if (hasFocus)
+                stateId = TIS_FOCUSED;
+            else if (isHot)
+                stateId = TIS_HOT;
+            else
+                stateId = TIS_NORMAL;
+
+            // Selecting proper part depending on position
+            if (firstTab || onlyOne) {
+                if (leftAligned) {
+                    partId = TABP_TABITEMLEFTEDGE;
+                } else if (centerAligned) {
+                    partId = TABP_TABITEM;
+                } else { // rightAligned
+                    partId = TABP_TABITEMRIGHTEDGE;
+                }
+            } else {
+                partId = TABP_TABITEM;
+            }
+
+            if (tab->direction == Qt::RightToLeft
+                && (tab->shape == QTabBar::RoundedNorth
+                    || tab->shape == QTabBar::RoundedSouth)) {
+                bool temp = firstTab;
+                firstTab = lastTab;
+                lastTab = temp;
+            }
+            bool begin = firstTab || onlyOne;
+            bool end = lastTab || onlyOne;
+            switch (tab->shape) {
+            case QTabBar::RoundedNorth:
+                if (selected)
+                    rect.adjust(begin ? 0 : -tabOverlap, 0, end ? 0 : tabOverlap, borderThickness);
+                else
+                    rect.adjust(begin? tabOverlap : 0, tabOverlap, end ? -tabOverlap : 0, 0);
+                break;
+            case QTabBar::RoundedSouth:
+                //vMirrored = true;
+                rotate = 180; // Not 100% correct, but works
+                if (selected)
+                    rect.adjust(begin ? 0 : -tabOverlap , -borderThickness, end ? 0 : tabOverlap, 0);
+                else
+                    rect.adjust(begin ? tabOverlap : 0, 0, end ? -tabOverlap : 0 , -tabOverlap);
+                break;
+            case QTabBar::RoundedEast:
+                rotate = 90;
+                if (selected) {
+                    rect.adjust(-borderThickness, begin ? 0 : -tabOverlap, 0, end ? 0 : tabOverlap);
+                }else{
+                    rect.adjust(0, begin ? tabOverlap : 0, -tabOverlap, end ? -tabOverlap : 0);
+                }
+                break;
+            case QTabBar::RoundedWest:
+                hMirrored = true;
+                rotate = 90;
+                if (selected) {
+                    rect.adjust(0, begin ? 0 : -tabOverlap, borderThickness, end ? 0 : tabOverlap);
+                }else{
+                    rect.adjust(tabOverlap, begin ? tabOverlap : 0, 0, end ? -tabOverlap : 0);
+                }
+                break;
+            default:
+                name = QLatin1String("");  // Do our own painting for triangular
+                break;
+            }
+
+            if (!selected) {
+                switch (tab->shape) {
+                case QTabBar::RoundedNorth:
+                    rect.adjust(0,0, 0,-1);
+                    break;
+                case QTabBar::RoundedSouth:
+                    rect.adjust(0,1, 0,0);
+                    break;
+                case QTabBar::RoundedEast:
+                    rect.adjust( 1,0, 0,0);
+                    break;
+                case QTabBar::RoundedWest:
+                    rect.adjust(0,0, -1,0);
+                    break;
+                default:
+                    break;
+                }
+            }
+        }
+        break;
+
+    case CE_ProgressBarGroove:
+        {
+        Qt::Orientation orient = Qt::Horizontal;
+        if (const QStyleOptionProgressBarV2 *pb2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option))
+            orient = pb2->orientation;
+        partId = (orient == Qt::Horizontal) ? PP_BAR : PP_BARVERT;
+        name = QLatin1String("PROGRESS");
+        stateId = 1;
+        }
+        break;
+
+    case CE_MenuEmptyArea:
+    case CE_MenuItem:
+        if (const QStyleOptionMenuItem *menuitem = qstyleoption_cast<const QStyleOptionMenuItem *>(option))
+        {
+            int tab = menuitem->tabWidth;
+            bool dis = !(menuitem->state & State_Enabled);
+            bool act = menuitem->state & State_Selected;
+            bool checkable = menuitem->menuHasCheckableItems;
+            bool checked = checkable ? menuitem->checked : false;
+
+            // windows always has a check column, regardless whether we have an icon or not
+            int checkcol = qMax(menuitem->maxIconWidth, 12);
+
+            int x, y, w, h;
+            rect.getRect(&x, &y, &w, &h);
+
+            QBrush fill = menuitem->palette.brush(act ? QPalette::Highlight : QPalette::Button);
+            p->fillRect(rect, fill);
+
+            if (element == CE_MenuEmptyArea)
+                break;
+
+            // draw separator -------------------------------------------------
+            if (menuitem->menuItemType == QStyleOptionMenuItem::Separator) {
+                int yoff = y-1 + h / 2;
+                p->setPen(menuitem->palette.dark().color());
+                p->drawLine(x, yoff, x+w, yoff);
+                ++yoff;
+                p->setPen(menuitem->palette.light().color());
+                p->drawLine(x, yoff, x+w, yoff);
+                return;
+            }
+
+            int xpos = x;
+
+            // draw icon ------------------------------------------------------
+            if (!menuitem->icon.isNull()) {
+                QIcon::Mode mode = dis ? QIcon::Disabled : QIcon::Normal;
+                if (act && !dis)
+                    mode = QIcon::Active;
+                QPixmap pixmap = checked ?
+                                 menuitem->icon.pixmap(pixelMetric(PM_SmallIconSize, option, widget), mode, QIcon::On) :
+                                 menuitem->icon.pixmap(pixelMetric(PM_SmallIconSize, option, widget), mode);
+                int pixw = pixmap.width();
+                int pixh = pixmap.height();
+                QRect iconRect(0, 0, pixw, pixh);
+                iconRect.moveCenter(QRect(xpos, y, checkcol, h).center());
+                QRect vIconRect = visualRect(option->direction, option->rect, iconRect);
+                p->setPen(menuitem->palette.text().color());
+                p->setBrush(Qt::NoBrush);
+                if (checked)
+                    p->drawRect(vIconRect.adjusted(-1, -2, 1, 1));
+                p->drawPixmap(vIconRect.topLeft(), pixmap);
+
+            // draw checkmark -------------------------------------------------
+            } else if (checked) {
+                QStyleOptionMenuItem newMi = *menuitem;
+                newMi.state = State_None;
+                if (!dis)
+                    newMi.state |= State_Enabled;
+                if (act)
+                    newMi.state |= State_On;
+
+                QRect checkMarkRect = QRect(menuitem->rect.x() + windowsItemFrame,
+                                            menuitem->rect.y() + windowsItemFrame,
+                                            checkcol - 2 * windowsItemFrame,
+                                            menuitem->rect.height() - 2*windowsItemFrame);
+                newMi.rect = visualRect(option->direction, option->rect, checkMarkRect);
+                drawPrimitive(PE_IndicatorMenuCheckMark, &newMi, p, widget);
+            }
+
+            QColor textColor = dis ? menuitem->palette.text().color() :
+                               act ? menuitem->palette.highlightedText().color() : menuitem->palette.buttonText().color();
+            p->setPen(textColor);
+
+            // draw text ------------------------------------------------------
+            int xm = windowsItemFrame + checkcol + windowsItemHMargin;
+            xpos = menuitem->rect.x() + xm;
+            QRect textRect(xpos, y + windowsItemVMargin, w - xm - windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin);
+            QRect vTextRect = visualRect(option->direction, option->rect, textRect);
+            QString s = menuitem->text;
+            if (!s.isEmpty()) {
+                p->save();
+                int t = s.indexOf(QLatin1Char('\t'));
+                int text_flags = Qt::AlignVCenter|Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine | Qt::AlignLeft;
+                if (!styleHint(SH_UnderlineShortcut, menuitem, widget))
+                    text_flags |= Qt::TextHideMnemonic;
+                // draw tab text ----------------
+                if (t >= 0) {
+                    QRect vShortcutRect = visualRect(option->direction, option->rect, QRect(textRect.topRight(), menuitem->rect.bottomRight()));
+                    if (dis && !act && styleHint(SH_EtchDisabledText, option, widget)) {
+                        p->setPen(menuitem->palette.light().color());
+                        p->drawText(vShortcutRect.adjusted(1,1,1,1), text_flags, s.mid(t + 1));
+                        p->setPen(textColor);
+                    }
+                    p->drawText(vShortcutRect, text_flags, s.mid(t + 1));
+                    s = s.left(t);
+                }
+                QFont font = menuitem->font;
+                if (menuitem->menuItemType == QStyleOptionMenuItem::DefaultItem)
+                    font.setBold(true);
+                p->setFont(font);
+                if (dis && !act && styleHint(SH_EtchDisabledText, option, widget)) {
+                    p->setPen(menuitem->palette.light().color());
+                    p->drawText(vTextRect.adjusted(1,1,1,1), text_flags, s.left(t));
+                    p->setPen(textColor);
+                }
+                p->drawText(vTextRect, text_flags, s);
+                p->restore();
+            }
+
+            // draw sub menu arrow --------------------------------------------
+            if (menuitem->menuItemType == QStyleOptionMenuItem::SubMenu) {
+                int dim = (h - 2) / 2;
+                PrimitiveElement arrow;
+                arrow = (option->direction == Qt::RightToLeft) ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight;
+                xpos = x + w - windowsArrowHMargin - windowsItemFrame - dim;
+                QRect vSubMenuRect = visualRect(option->direction, option->rect, QRect(xpos, y + h / 2 - dim / 2, dim, dim));
+                QStyleOptionMenuItem newMI = *menuitem;
+                newMI.rect = vSubMenuRect;
+                newMI.state = dis ? State_None : State_Enabled;
+                if (act)
+                    newMI.palette.setColor(QPalette::ButtonText, newMI.palette.highlightedText().color());
+                drawPrimitive(arrow, &newMI, p, widget);
+            }
+        }
+        return;
+
+    case CE_MenuBarItem:
+        if (const QStyleOptionMenuItem *mbi = qstyleoption_cast<const QStyleOptionMenuItem *>(option))
+        {
+            if (mbi->menuItemType == QStyleOptionMenuItem::DefaultItem)
+                break;
+
+            bool act = mbi->state & State_Selected;
+            bool dis = !(mbi->state & State_Enabled);
+
+            QBrush fill = mbi->palette.brush(act ? QPalette::Highlight : QPalette::Button);
+            QPalette::ColorRole textRole = dis ? QPalette::Text:
+                                           act ? QPalette::HighlightedText : QPalette::ButtonText;
+            QPixmap pix = mbi->icon.pixmap(pixelMetric(PM_SmallIconSize, option, widget), QIcon::Normal);
+
+            uint alignment = Qt::AlignCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;
+            if (!styleHint(SH_UnderlineShortcut, mbi, widget))
+                alignment |= Qt::TextHideMnemonic;
+
+            p->fillRect(rect, fill);
+            if (!pix.isNull())
+                drawItemPixmap(p, mbi->rect, alignment, pix);
+            else
+                drawItemText(p, mbi->rect, alignment, mbi->palette, mbi->state & State_Enabled, mbi->text, textRole);
+        }
+        return;
+#ifndef QT_NO_DOCKWIDGET
+    case CE_DockWidgetTitle:
+        if (const QStyleOptionDockWidget *dwOpt = qstyleoption_cast<const QStyleOptionDockWidget *>(option))
+        {
+            int buttonMargin = 4;
+            int mw = pixelMetric(QStyle::PM_DockWidgetTitleMargin, dwOpt, widget);
+            int fw = pixelMetric(PM_DockWidgetFrameWidth, dwOpt, widget);
+            bool isFloating = widget && widget->isWindow();
+            bool isActive = dwOpt->state & State_Active;
+
+            const QStyleOptionDockWidgetV2 *v2
+                = qstyleoption_cast<const QStyleOptionDockWidgetV2*>(dwOpt);
+            bool verticalTitleBar = v2 == 0 ? false : v2->verticalTitleBar;
+
+            if (verticalTitleBar) {
+                QSize s = rect.size();
+                s.transpose();
+                rect.setSize(s);
+
+                p->translate(rect.left() - 1, rect.top() + rect.width());
+                p->rotate(-90);
+                p->translate(-rect.left() + 1, -rect.top());
+            }
+            QRect r = rect.adjusted(0, 2, -1, -3);
+            QRect titleRect = r;
+
+            if (dwOpt->closable) {
+                QSize sz = standardIcon(QStyle::SP_TitleBarCloseButton, dwOpt, widget).actualSize(QSize(10, 10));
+                titleRect.adjust(0, 0, -sz.width() - mw - buttonMargin, 0);
+            }
+
+            if (dwOpt->floatable) {
+                QSize sz = standardIcon(QStyle::SP_TitleBarMaxButton, dwOpt, widget).actualSize(QSize(10, 10));
+                titleRect.adjust(0, 0, -sz.width() - mw - buttonMargin, 0);
+            }
+
+            if (isFloating) {
+                titleRect.adjust(0, -fw, 0, 0);
+                if (widget != 0 && widget->windowIcon().cacheKey() != qApp->windowIcon().cacheKey())
+                    titleRect.adjust(titleRect.height() + mw, 0, 0, 0);
+            } else {
+                titleRect.adjust(mw, 0, 0, 0);
+                if (!dwOpt->floatable && !dwOpt->closable)
+                    titleRect.adjust(0, 0, -mw, 0);
+            }
+
+            if (!verticalTitleBar)
+                titleRect = visualRect(dwOpt->direction, r, titleRect);
+
+            if (!isFloating) {
+                QPen oldPen = p->pen();
+                QString titleText = p->fontMetrics().elidedText(dwOpt->title, Qt::ElideRight, titleRect.width());
+                p->setPen(dwOpt->palette.color(QPalette::Dark));
+                p->drawRect(r);
+
+                if (!titleText.isEmpty()) {
+                    drawItemText(p, titleRect,
+                                Qt::AlignLeft | Qt::AlignVCenter | Qt::TextShowMnemonic, dwOpt->palette,
+                                dwOpt->state & State_Enabled, titleText,
+                                QPalette::WindowText);
+                }
+
+                p->setPen(oldPen);
+            } else {
+                name = QLatin1String("WINDOW");
+                if (isActive)
+                    stateId = CS_ACTIVE;
+                else
+                    stateId = CS_INACTIVE;
+
+                int titleHeight = rect.height() - 2;
+                rect = rect.adjusted(-fw, -fw, fw, 0);
+
+                XPThemeData theme(widget, p, name, 0, stateId);
+                if (!theme.isValid())
+                    break;
+
+                // Draw small type title bar
+                theme.rect = rect;
+                theme.partId = WP_SMALLCAPTION;
+                d->drawBackground(theme);
+
+                // Figure out maximal button space on title bar
+
+                QIcon ico = widget->windowIcon();
+                bool hasIcon = (ico.cacheKey() != qApp->windowIcon().cacheKey());
+                if (hasIcon) {
+                    QPixmap pxIco = ico.pixmap(titleHeight);
+                    if (!verticalTitleBar && QApplication::layoutDirection() == Qt::RightToLeft)
+                        p->drawPixmap(rect.width() - titleHeight - pxIco.width(), rect.bottom() - titleHeight - 2, pxIco);
+                    else
+                        p->drawPixmap(fw, rect.bottom() - titleHeight - 2, pxIco);
+                }
+                if (!dwOpt->title.isEmpty()) {
+                    QPen oldPen = p->pen();
+                    QFont oldFont = p->font();
+                    QFont titleFont = oldFont;
+                    titleFont.setBold(true);
+                    p->setFont(titleFont);
+                    QString titleText
+                        = p->fontMetrics().elidedText(dwOpt->title, Qt::ElideRight, titleRect.width());
+
+                    int result = TST_NONE;
+                    pGetThemeEnumValue(theme.handle(), WP_SMALLCAPTION, isActive ? CS_ACTIVE : CS_INACTIVE, TMT_TEXTSHADOWTYPE, &result);
+                    if (result != TST_NONE) {
+                        COLORREF textShadowRef;
+                        pGetThemeColor(theme.handle(), WP_SMALLCAPTION, isActive ? CS_ACTIVE : CS_INACTIVE, TMT_TEXTSHADOWCOLOR, &textShadowRef);
+                        QColor textShadow = qRgb(GetRValue(textShadowRef), GetGValue(textShadowRef), GetBValue(textShadowRef));
+                        p->setPen(textShadow);
+                        drawItemText(p, titleRect.adjusted(1, 1, 1, 1),
+                                    Qt::AlignLeft | Qt::AlignBottom, dwOpt->palette,
+                                    dwOpt->state & State_Enabled, titleText);
+                    }
+
+                    COLORREF captionText = GetSysColor(isActive ? COLOR_CAPTIONTEXT : COLOR_INACTIVECAPTIONTEXT);
+                    QColor textColor = qRgb(GetRValue(captionText), GetGValue(captionText), GetBValue(captionText));
+                    p->setPen(textColor);
+                    drawItemText(p, titleRect,
+                                Qt::AlignLeft | Qt::AlignBottom, dwOpt->palette,
+                                dwOpt->state & State_Enabled, titleText);
+                    p->setFont(oldFont);
+                    p->setPen(oldPen);
+                }
+
+            }
+
+            return;
+        }
+        break;
+#endif // QT_NO_DOCKWIDGET
+#ifndef QT_NO_RUBBERBAND
+    case CE_RubberBand:
+        if (qstyleoption_cast<const QStyleOptionRubberBand *>(option)) {
+            QColor highlight = option->palette.color(QPalette::Active, QPalette::Highlight);
+            p->save();
+            QRect r = option->rect;
+            p->setPen(highlight.darker(120));
+            QColor dimHighlight(qMin(highlight.red()/2 + 110, 255),
+                                qMin(highlight.green()/2 + 110, 255),
+                                qMin(highlight.blue()/2 + 110, 255),
+                                (widget && widget->isTopLevel())? 255 : 127);
+            p->setBrush(dimHighlight);
+            p->drawRect(option->rect.adjusted(0, 0, -1, -1));
+            p->restore();
+            return;
+        }
+#endif // QT_NO_RUBBERBAND
+    case CE_HeaderEmptyArea:
+        if (option->state & State_Horizontal)
+        {
+            name = QLatin1String("HEADER");
+            stateId = HIS_NORMAL;
+        }
+        else {
+            QWindowsStyle::drawControl(CE_HeaderEmptyArea, option, p, widget);
+            return;
+        }
+        break;
+    default:
+        break;
+    }
+
+    XPThemeData theme(widget, p, name, partId, stateId, rect);
+    if (!theme.isValid()) {
+        QWindowsStyle::drawControl(element, option, p, widget);
+        return;
+    }
+
+    theme.rotate = rotate;
+    theme.mirrorHorizontally = hMirrored;
+    theme.mirrorVertically = vMirrored;
+    d->drawBackground(theme);
+}
+
+
+/*!
+    \reimp
+*/
+void QWindowsXPStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex *option,
+                                         QPainter *p, const QWidget *widget) const
+{
+    QWindowsXPStylePrivate *d = const_cast<QWindowsXPStylePrivate*>(d_func());
+
+    if (!QWindowsXPStylePrivate::useXP()) {
+        QWindowsStyle::drawComplexControl(cc, option, p, widget);
+        return;
+    }
+
+    State flags = option->state;
+    SubControls sub = option->subControls;
+    QRect r = option->rect;
+
+    int partId = 0;
+    int stateId = 0;
+    if (widget && widget->testAttribute(Qt::WA_UnderMouse) && widget->isActiveWindow())
+        flags |= State_MouseOver;
+
+    switch (cc) {
+#ifndef QT_NO_SPINBOX
+    case CC_SpinBox:
+        if (const QStyleOptionSpinBox *sb = qstyleoption_cast<const QStyleOptionSpinBox *>(option))
+        {
+            XPThemeData theme(widget, p, QLatin1String("SPIN"));
+
+            if (sb->frame && (sub & SC_SpinBoxFrame)) {
+                partId = EP_EDITTEXT;
+                if (!(flags & State_Enabled))
+                    stateId = ETS_DISABLED;
+                else if (flags & State_HasFocus)
+                    stateId = ETS_FOCUSED;
+                else
+                    stateId = ETS_NORMAL;
+
+                XPThemeData ftheme(widget, p, QLatin1String("EDIT"), partId, stateId, r);
+                ftheme.noContent = true;
+                d->drawBackground(ftheme);
+            }
+            if (sub & SC_SpinBoxUp) {
+                theme.rect = subControlRect(CC_SpinBox, option, SC_SpinBoxUp, widget);
+                partId = SPNP_UP;
+                if (!(sb->stepEnabled & QAbstractSpinBox::StepUpEnabled) || !(flags & State_Enabled))
+                    stateId = UPS_DISABLED;
+                else if (sb->activeSubControls == SC_SpinBoxUp && (sb->state & State_Sunken))
+                    stateId = UPS_PRESSED;
+                else if (sb->activeSubControls == SC_SpinBoxUp && (sb->state & State_MouseOver))
+                    stateId = UPS_HOT;
+                else
+                    stateId = UPS_NORMAL;
+                theme.partId = partId;
+                theme.stateId = stateId;
+                d->drawBackground(theme);
+            }
+            if (sub & SC_SpinBoxDown) {
+                theme.rect = subControlRect(CC_SpinBox, option, SC_SpinBoxDown, widget);
+                partId = SPNP_DOWN;
+                if (!(sb->stepEnabled & QAbstractSpinBox::StepDownEnabled) || !(flags & State_Enabled))
+                    stateId = DNS_DISABLED;
+                else if (sb->activeSubControls == SC_SpinBoxDown && (sb->state & State_Sunken))
+                    stateId = DNS_PRESSED;
+                else if (sb->activeSubControls == SC_SpinBoxDown && (sb->state & State_MouseOver))
+                    stateId = DNS_HOT;
+                else
+                    stateId = DNS_NORMAL;
+                theme.partId = partId;
+                theme.stateId = stateId;
+                d->drawBackground(theme);
+            }
+        }
+        break;
+#endif // QT_NO_SPINBOX
+#ifndef QT_NO_COMBOBOX
+    case CC_ComboBox:
+        if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(option))
+        {
+            if (sub & SC_ComboBoxEditField) {
+                if (cmb->frame) {
+                    partId = EP_EDITTEXT;
+                    if (!(flags & State_Enabled))
+                        stateId = ETS_DISABLED;
+                    else if (flags & State_HasFocus)
+                        stateId = ETS_FOCUSED;
+                    else
+                        stateId = ETS_NORMAL;
+                    XPThemeData theme(widget, p, QLatin1String("EDIT"), partId, stateId, r);
+                    d->drawBackground(theme);
+                } else {
+                    QBrush editBrush = cmb->palette.brush(QPalette::Base);
+                    p->fillRect(option->rect, editBrush);
+                }
+                if (!cmb->editable) {
+                    QRect re = subControlRect(CC_ComboBox, option, SC_ComboBoxEditField, widget);
+                    if (option->state & State_HasFocus) {
+                        p->fillRect(re, option->palette.highlight());
+                        p->setPen(option->palette.highlightedText().color());
+                        p->setBackground(option->palette.highlight());
+                    } else {
+                        p->fillRect(re, option->palette.base());
+                        p->setPen(option->palette.text().color());
+                        p->setBackground(option->palette.base());
+                    }
+                }
+            }
+
+            if (sub & SC_ComboBoxArrow) {
+                XPThemeData theme(widget, p, QLatin1String("COMBOBOX"));
+                theme.rect = subControlRect(CC_ComboBox, option, SC_ComboBoxArrow, widget);
+                partId = CP_DROPDOWNBUTTON;
+                if (!(flags & State_Enabled))
+                    stateId = CBXS_DISABLED;
+                else if (cmb->activeSubControls == SC_ComboBoxArrow && (cmb->state & State_Sunken))
+                    stateId = CBXS_PRESSED;
+                else if (cmb->activeSubControls == SC_ComboBoxArrow && (cmb->state & State_MouseOver))
+                    stateId = CBXS_HOT;
+                else
+                    stateId = CBXS_NORMAL;
+                theme.partId = partId;
+                theme.stateId = stateId;
+                d->drawBackground(theme);
+            }
+        }
+        break;
+#endif // QT_NO_COMBOBOX
+    case CC_ScrollBar:
+        if (const QStyleOptionSlider *scrollbar = qstyleoption_cast<const QStyleOptionSlider *>(option))
+        {
+            XPThemeData theme(widget, p, QLatin1String("SCROLLBAR"));
+            bool maxedOut = (scrollbar->maximum == scrollbar->minimum);
+            if (maxedOut)
+                flags &= ~State_Enabled;
+
+            bool isHorz = flags & State_Horizontal;
+            bool isRTL  = option->direction == Qt::RightToLeft;
+            if (sub & SC_ScrollBarAddLine) {
+                theme.rect = subControlRect(CC_ScrollBar, option, SC_ScrollBarAddLine, widget);
+                partId = SBP_ARROWBTN;
+                if (!(flags & State_Enabled))
+                    stateId = (isHorz ? (isRTL ? ABS_LEFTDISABLED : ABS_RIGHTDISABLED) : ABS_DOWNDISABLED);
+                else if (scrollbar->activeSubControls & SC_ScrollBarAddLine && (scrollbar->state & State_Sunken))
+                    stateId = (isHorz ? (isRTL ? ABS_LEFTPRESSED : ABS_RIGHTPRESSED) : ABS_DOWNPRESSED);
+                else if (scrollbar->activeSubControls & SC_ScrollBarAddLine && (scrollbar->state & State_MouseOver))
+                    stateId = (isHorz ? (isRTL ? ABS_LEFTHOT : ABS_RIGHTHOT) : ABS_DOWNHOT);
+                else
+                    stateId = (isHorz ? (isRTL ? ABS_LEFTNORMAL : ABS_RIGHTNORMAL) : ABS_DOWNNORMAL);
+                theme.partId = partId;
+                theme.stateId = stateId;
+                d->drawBackground(theme);
+            }
+            if (sub & SC_ScrollBarSubLine) {
+                theme.rect = subControlRect(CC_ScrollBar, option, SC_ScrollBarSubLine, widget);
+                partId = SBP_ARROWBTN;
+                if (!(flags & State_Enabled))
+                    stateId = (isHorz ? (isRTL ? ABS_RIGHTDISABLED : ABS_LEFTDISABLED) : ABS_UPDISABLED);
+                else if (scrollbar->activeSubControls & SC_ScrollBarSubLine && (scrollbar->state & State_Sunken))
+                    stateId = (isHorz ? (isRTL ? ABS_RIGHTPRESSED : ABS_LEFTPRESSED) : ABS_UPPRESSED);
+                else if (scrollbar->activeSubControls & SC_ScrollBarSubLine && (scrollbar->state & State_MouseOver))
+                    stateId = (isHorz ? (isRTL ? ABS_RIGHTHOT : ABS_LEFTHOT) : ABS_UPHOT);
+                else
+                    stateId = (isHorz ? (isRTL ? ABS_RIGHTNORMAL : ABS_LEFTNORMAL) : ABS_UPNORMAL);
+                theme.partId = partId;
+                theme.stateId = stateId;
+                d->drawBackground(theme);
+            }
+            if (maxedOut) {
+                theme.rect = subControlRect(CC_ScrollBar, option, SC_ScrollBarSlider, widget);
+                theme.rect = theme.rect.united(subControlRect(CC_ScrollBar, option, SC_ScrollBarSubPage, widget));
+                theme.rect = theme.rect.united(subControlRect(CC_ScrollBar, option, SC_ScrollBarAddPage, widget));
+                partId = scrollbar->orientation == Qt::Horizontal ? SBP_LOWERTRACKHORZ : SBP_LOWERTRACKVERT;
+                stateId = SCRBS_DISABLED;
+                theme.partId = partId;
+                theme.stateId = stateId;
+                d->drawBackground(theme);
+            } else {
+                if (sub & SC_ScrollBarSubPage) {
+                    theme.rect = subControlRect(CC_ScrollBar, option, SC_ScrollBarSubPage, widget);
+                    partId = flags & State_Horizontal ? SBP_UPPERTRACKHORZ : SBP_UPPERTRACKVERT;
+                    if (!(flags & State_Enabled))
+                        stateId = SCRBS_DISABLED;
+                    else if (scrollbar->activeSubControls & SC_ScrollBarSubPage && (scrollbar->state & State_Sunken))
+                        stateId = SCRBS_PRESSED;
+                    else if (scrollbar->activeSubControls & SC_ScrollBarSubPage && (scrollbar->state & State_MouseOver))
+                        stateId = SCRBS_HOT;
+                    else
+                        stateId = SCRBS_NORMAL;
+                    theme.partId = partId;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_ScrollBarAddPage) {
+                    theme.rect = subControlRect(CC_ScrollBar, option, SC_ScrollBarAddPage, widget);
+                    partId = flags & State_Horizontal ? SBP_LOWERTRACKHORZ : SBP_LOWERTRACKVERT;
+                    if (!(flags & State_Enabled))
+                        stateId = SCRBS_DISABLED;
+                    else if (scrollbar->activeSubControls & SC_ScrollBarAddPage && (scrollbar->state & State_Sunken))
+                        stateId = SCRBS_PRESSED;
+                    else if (scrollbar->activeSubControls & SC_ScrollBarAddPage && (scrollbar->state & State_MouseOver))
+                        stateId = SCRBS_HOT;
+                    else
+                        stateId = SCRBS_NORMAL;
+                    theme.partId = partId;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_ScrollBarSlider) {
+                    theme.rect = subControlRect(CC_ScrollBar, option, SC_ScrollBarSlider, widget);
+                    if (!(flags & State_Enabled))
+                        stateId = SCRBS_DISABLED;
+                    else if (scrollbar->activeSubControls & SC_ScrollBarSlider && (scrollbar->state & State_Sunken))
+                        stateId = SCRBS_PRESSED;
+                    else if (scrollbar->activeSubControls & SC_ScrollBarSlider && (scrollbar->state & State_MouseOver))
+                        stateId = SCRBS_HOT;
+                    else
+                        stateId = SCRBS_NORMAL;
+
+                    // Draw handle
+                    theme.rect = subControlRect(CC_ScrollBar, option, SC_ScrollBarSlider, widget);
+                    theme.partId = flags & State_Horizontal ? SBP_THUMBBTNHORZ : SBP_THUMBBTNVERT;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+
+                    // Calculate rect of gripper
+                    const int swidth = theme.rect.width();
+                    const int sheight = theme.rect.height();
+
+                    MARGINS contentsMargin;
+                    RECT rect = theme.toRECT(theme.rect);
+                    pGetThemeMargins(theme.handle(), 0, theme.partId, theme.stateId, TMT_SIZINGMARGINS, &rect, &contentsMargin);
+
+                    SIZE size;
+                    theme.partId = flags & State_Horizontal ? SBP_GRIPPERHORZ : SBP_GRIPPERVERT;
+                    pGetThemePartSize(theme.handle(), 0, theme.partId, theme.stateId, 0, TS_TRUE, &size);
+                    int gw = size.cx, gh = size.cy;
+
+
+                    QRect gripperBounds;
+                    if (flags & State_Horizontal && ((swidth - contentsMargin.cxLeftWidth - contentsMargin.cxRightWidth) > gw)) {
+                        gripperBounds.setLeft(theme.rect.left() + swidth/2 - gw/2);
+                        gripperBounds.setTop(theme.rect.top() + sheight/2 - gh/2);
+                        gripperBounds.setWidth(gw);
+                        gripperBounds.setHeight(gh);
+                    } else if ((sheight - contentsMargin.cyTopHeight - contentsMargin.cyBottomHeight) > gh) {
+                        gripperBounds.setLeft(theme.rect.left() + swidth/2 - gw/2);
+                        gripperBounds.setTop(theme.rect.top() + sheight/2 - gh/2);
+                        gripperBounds.setWidth(gw);
+                        gripperBounds.setHeight(gh);
+                    }
+
+                    // Draw gripper if there is enough space
+                    if (!gripperBounds.isEmpty()) {
+                        p->save();
+                        XPThemeData grippBackground = theme;
+                        grippBackground.partId = flags & State_Horizontal ? SBP_LOWERTRACKHORZ : SBP_LOWERTRACKVERT;
+                        theme.rect = gripperBounds;
+                        p->setClipRegion(d->region(theme));// Only change inside the region of the gripper
+                        d->drawBackground(grippBackground);// The gutter is the grippers background
+                        d->drawBackground(theme);          // Transparent gripper ontop of background
+                        p->restore();
+                    }
+                }
+            }
+        }
+        break;
+
+#ifndef QT_NO_SLIDER
+    case CC_Slider:
+        if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option))
+        {
+            XPThemeData theme(widget, p, QLatin1String("TRACKBAR"));
+            QRect slrect = slider->rect;
+            QRegion tickreg = slrect;
+            if (sub & SC_SliderGroove) {
+                theme.rect = subControlRect(CC_Slider, option, SC_SliderGroove, widget);
+                if (slider->orientation == Qt::Horizontal) {
+                    partId = TKP_TRACK;
+                    stateId = TRS_NORMAL;
+                    theme.rect = QRect(slrect.left(), theme.rect.center().y() - 2, slrect.width(), 4);
+                } else {
+                    partId = TKP_TRACKVERT;
+                    stateId = TRVS_NORMAL;
+                    theme.rect = QRect(theme.rect.center().x() - 2, slrect.top(), 4, slrect.height());
+                }
+                theme.partId = partId;
+                theme.stateId = stateId;
+                d->drawBackground(theme);
+                tickreg -= theme.rect;
+            }
+            if (sub & SC_SliderTickmarks) {
+                int tickOffset = pixelMetric(PM_SliderTickmarkOffset, slider, widget);
+                int ticks = slider->tickPosition;
+                int thickness = pixelMetric(PM_SliderControlThickness, slider, widget);
+                int len = pixelMetric(PM_SliderLength, slider, widget);
+                int available = pixelMetric(PM_SliderSpaceAvailable, slider, widget);
+                int interval = slider->tickInterval;
+                if (interval <= 0) {
+                    interval = slider->singleStep;
+                    if (QStyle::sliderPositionFromValue(slider->minimum, slider->maximum, interval,
+                                                        available)
+                        - QStyle::sliderPositionFromValue(slider->minimum, slider->maximum,
+                                                          0, available) < 3)
+                        interval = slider->pageStep;
+                }
+                if (!interval)
+                    interval = 1;
+                int fudge = len / 2;
+                int pos;
+                int bothOffset = (ticks & QSlider::TicksAbove && ticks & QSlider::TicksBelow) ? 1 : 0;
+                p->setPen(d->sliderTickColor);
+                QVarLengthArray<QLine, 32> lines;
+                int v = slider->minimum;
+                while (v <= slider->maximum + 1) {
+                    if (v == slider->maximum + 1 && interval == 1)
+                        break;
+                    const int v_ = qMin(v, slider->maximum);
+                    int tickLength = (v_ == slider->minimum || v_ >= slider->maximum) ? 4 : 3;
+                    pos = QStyle::sliderPositionFromValue(slider->minimum, slider->maximum,
+                                                          v_, available) + fudge;
+                    if (slider->orientation == Qt::Horizontal) {
+                        if (ticks & QSlider::TicksAbove)
+                            lines.append(QLine(pos, tickOffset - 1 - bothOffset,
+                                               pos, tickOffset - 1 - bothOffset - tickLength));
+
+                        if (ticks & QSlider::TicksBelow)
+                            lines.append(QLine(pos, tickOffset + thickness + bothOffset,
+                                               pos, tickOffset + thickness + bothOffset + tickLength));
+                    } else {
+                        if (ticks & QSlider::TicksAbove)
+                            lines.append(QLine(tickOffset - 1 - bothOffset, pos,
+                                               tickOffset - 1 - bothOffset - tickLength, pos));
+
+                        if (ticks & QSlider::TicksBelow)
+                            lines.append(QLine(tickOffset + thickness + bothOffset, pos,
+                                               tickOffset + thickness + bothOffset + tickLength, pos));
+                    }
+                    // in the case where maximum is max int
+                    int nextInterval = v + interval;
+                    if (nextInterval < v)
+                        break;
+                    v = nextInterval;
+                }
+                if (lines.size() > 0) {
+                    p->save();
+                    p->translate(slrect.topLeft());
+                    p->drawLines(lines.constData(), lines.size());
+                    p->restore();
+                }
+            }
+            if (sub & SC_SliderHandle) {
+                theme.rect = subControlRect(CC_Slider, option, SC_SliderHandle, widget);
+                if (slider->orientation == Qt::Horizontal) {
+                    if (slider->tickPosition == QSlider::TicksAbove)
+                        partId = TKP_THUMBTOP;
+                    else if (slider->tickPosition == QSlider::TicksBelow)
+                        partId = TKP_THUMBBOTTOM;
+                    else
+                        partId = TKP_THUMB;
+
+                    if (!(slider->state & State_Enabled))
+                        stateId = TUS_DISABLED;
+                    else if (slider->activeSubControls & SC_SliderHandle && (slider->state & State_Sunken))
+                        stateId = TUS_PRESSED;
+                    else if (slider->activeSubControls & SC_SliderHandle && (slider->state & State_MouseOver))
+                        stateId = TUS_HOT;
+                    else if (flags & State_HasFocus)
+                        stateId = TUS_FOCUSED;
+                    else
+                        stateId = TUS_NORMAL;
+                } else {
+                    if (slider->tickPosition == QSlider::TicksLeft)
+                        partId = TKP_THUMBLEFT;
+                    else if (slider->tickPosition == QSlider::TicksRight)
+                        partId = TKP_THUMBRIGHT;
+                    else
+                        partId = TKP_THUMBVERT;
+
+                    if (!(slider->state & State_Enabled))
+                        stateId = TUVS_DISABLED;
+                    else if (slider->activeSubControls & SC_SliderHandle && (slider->state & State_Sunken))
+                        stateId = TUVS_PRESSED;
+                    else if (slider->activeSubControls & SC_SliderHandle && (slider->state & State_MouseOver))
+                        stateId = TUVS_HOT;
+                    else if (flags & State_HasFocus)
+                        stateId = TUVS_FOCUSED;
+                    else
+                        stateId = TUVS_NORMAL;
+                }
+                theme.partId = partId;
+                theme.stateId = stateId;
+                d->drawBackground(theme);
+            }
+            if (slider->state & State_HasFocus) {
+                QStyleOptionFocusRect fropt;
+                fropt.QStyleOption::operator=(*slider);
+                fropt.rect = subElementRect(SE_SliderFocusRect, slider, widget);
+                drawPrimitive(PE_FrameFocusRect, &fropt, p, widget);
+            }
+        }
+        break;
+#endif
+#ifndef QT_NO_TOOLBUTTON
+    case CC_ToolButton:
+        if (const QStyleOptionToolButton *toolbutton
+            = qstyleoption_cast<const QStyleOptionToolButton *>(option)) {
+            QRect button, menuarea;
+            button = subControlRect(cc, toolbutton, SC_ToolButton, widget);
+            menuarea = subControlRect(cc, toolbutton, SC_ToolButtonMenu, widget);
+
+            State bflags = toolbutton->state & ~State_Sunken;
+            State mflags = bflags;
+
+            if (bflags & State_AutoRaise) {
+                if (!(bflags & State_MouseOver) || !(bflags & State_Enabled)) {
+                    bflags &= ~State_Raised;
+                }
+            }
+
+            if (toolbutton->state & State_Sunken) {
+                if (toolbutton->activeSubControls & SC_ToolButton) {
+                    bflags |= State_Sunken;
+                    mflags |= State_MouseOver | State_Sunken;
+                } else if (toolbutton->activeSubControls & SC_ToolButtonMenu) {
+                    mflags |= State_Sunken;
+                    bflags |= State_MouseOver;
+                }
+            }
+            
+            QStyleOption tool(0);
+            tool.palette = toolbutton->palette;
+            if (toolbutton->subControls & SC_ToolButton) {
+                if (flags & (State_Sunken | State_On | State_Raised) || !(flags & State_AutoRaise)) {
+                    if (toolbutton->features & QStyleOptionToolButton::MenuButtonPopup) {
+                        XPThemeData theme(widget, p, QLatin1String("TOOLBAR"));
+                        theme.partId = TP_SPLITBUTTON;
+                        theme.rect = button;
+                        if (!(bflags & State_Enabled))
+                            stateId = TS_DISABLED;
+                        else if (bflags & State_Sunken)
+                            stateId = TS_PRESSED;
+                        else if (bflags & State_MouseOver || !(flags & State_AutoRaise))
+                            stateId = flags & State_On ? TS_HOTCHECKED : TS_HOT;
+                        else if (bflags & State_On)
+                            stateId = TS_CHECKED;
+                        else
+                            stateId = TS_NORMAL;
+                        if (option->direction == Qt::RightToLeft)
+                            theme.mirrorHorizontally = true;
+                        theme.stateId = stateId;
+                        d->drawBackground(theme);
+                    } else {
+                        tool.rect = button;
+                        tool.state = bflags;
+                        if (widget && !qobject_cast<QToolBar*>(widget->parentWidget())
+                                   && !(bflags & State_AutoRaise))
+                            drawPrimitive(PE_PanelButtonBevel, &tool, p, widget);
+                        else
+                            drawPrimitive(PE_PanelButtonTool, &tool, p, widget);
+                    }
+                }
+            }
+
+            if (toolbutton->state & State_HasFocus) {
+                QStyleOptionFocusRect fr;
+                fr.QStyleOption::operator=(*toolbutton);
+                fr.rect.adjust(3, 3, -3, -3);
+                if (toolbutton->features & QStyleOptionToolButton::MenuButtonPopup)
+                    fr.rect.adjust(0, 0, -pixelMetric(QStyle::PM_MenuButtonIndicator,
+                                                      toolbutton, widget), 0);
+                drawPrimitive(PE_FrameFocusRect, &fr, p, widget);
+            }
+            QStyleOptionToolButton label = *toolbutton;
+            label.state = bflags;
+            int fw = 2;
+            label.rect = button.adjusted(fw, fw, -fw, -fw);
+            drawControl(CE_ToolButtonLabel, &label, p, widget);
+
+            if (toolbutton->subControls & SC_ToolButtonMenu) {
+                tool.rect = menuarea;
+                tool.state = mflags;
+                drawPrimitive(PE_IndicatorButtonDropDown, &tool, p, widget);
+            } else if (toolbutton->features & QStyleOptionToolButton::HasMenu) {
+                int mbi = pixelMetric(PM_MenuButtonIndicator, toolbutton, widget);
+                QRect ir = toolbutton->rect;
+                QStyleOptionToolButton newBtn = *toolbutton;
+                newBtn.rect = QRect(ir.right() + 4 - mbi, ir.height() - mbi + 4, mbi - 5, mbi - 5);
+                drawPrimitive(PE_IndicatorArrowDown, &newBtn, p, widget);
+            }
+        }
+        break;
+#endif // QT_NO_TOOLBUTTON
+
+    case CC_TitleBar:
+        {
+            if (const QStyleOptionTitleBar *tb = qstyleoption_cast<const QStyleOptionTitleBar *>(option))
+            {
+                bool isActive = tb->titleBarState & QStyle::State_Active;
+                XPThemeData theme(widget, p, QLatin1String("WINDOW"));
+                if (sub & SC_TitleBarLabel) {
+
+#ifdef QT3_SUPPORT
+                    if (widget && widget->inherits("Q3DockWindowTitleBar")) {
+                        partId = WP_SMALLCAPTION;
+                    } else
+#endif
+                        partId = (tb->titleBarState & Qt::WindowMinimized) ? WP_MINCAPTION : WP_CAPTION;
+                    theme.rect = option->rect;
+                    if (widget && !widget->isEnabled())
+                        stateId = CS_DISABLED;
+                    else if (isActive)
+                        stateId = CS_ACTIVE;
+                    else
+                        stateId = CS_INACTIVE;
+
+                    theme.partId = partId;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+
+                    QRect ir = subControlRect(CC_TitleBar, tb, SC_TitleBarLabel, widget);
+
+                    int result = TST_NONE;
+                    pGetThemeEnumValue(theme.handle(), WP_CAPTION, isActive ? CS_ACTIVE : CS_INACTIVE, TMT_TEXTSHADOWTYPE, &result);
+                    if (result != TST_NONE) {
+                        COLORREF textShadowRef;
+                        pGetThemeColor(theme.handle(), WP_CAPTION, isActive ? CS_ACTIVE : CS_INACTIVE, TMT_TEXTSHADOWCOLOR, &textShadowRef);
+                        QColor textShadow = qRgb(GetRValue(textShadowRef), GetGValue(textShadowRef), GetBValue(textShadowRef));
+                        p->setPen(textShadow);
+                        p->drawText(ir.x() + 3, ir.y() + 2, ir.width() - 1, ir.height(),
+                                    Qt::AlignLeft | Qt::AlignVCenter | Qt::TextSingleLine, tb->text);
+                    }
+                    COLORREF captionText = GetSysColor(isActive ? COLOR_CAPTIONTEXT : COLOR_INACTIVECAPTIONTEXT);
+                    QColor textColor = qRgb(GetRValue(captionText), GetGValue(captionText), GetBValue(captionText));
+                    p->setPen(textColor);
+                    p->drawText(ir.x() + 2, ir.y() + 1, ir.width() - 2, ir.height(),
+                                Qt::AlignLeft | Qt::AlignVCenter | Qt::TextSingleLine, tb->text);
+                }
+                if (sub & SC_TitleBarSysMenu && tb->titleBarFlags & Qt::WindowSystemMenuHint) {
+                    theme.rect = subControlRect(CC_TitleBar, option, SC_TitleBarSysMenu, widget);
+                    partId = WP_SYSBUTTON;
+                    if ((widget && !widget->isEnabled()) || !isActive)
+                        stateId = SBS_DISABLED;
+                    else if (option->activeSubControls == SC_TitleBarSysMenu && (option->state & State_Sunken))
+                        stateId = SBS_PUSHED;
+                    else if (option->activeSubControls == SC_TitleBarSysMenu && (option->state & State_MouseOver))
+                        stateId = SBS_HOT;
+                    else
+                        stateId = SBS_NORMAL;
+                    if (!tb->icon.isNull()) {
+                        tb->icon.paint(p, theme.rect);
+                    } else {
+                        theme.partId = partId;
+                        theme.stateId = stateId;
+                        SIZE sz;
+                        pGetThemePartSize(theme.handle(), qt_win_display_dc(), theme.partId, theme.stateId, 0, TS_TRUE, &sz);
+                        if (sz.cx == 0 || sz.cy == 0) {
+                            int iconSize = pixelMetric(PM_SmallIconSize, tb, widget);
+                            QPixmap pm = standardIcon(SP_TitleBarMenuButton, tb, widget).pixmap(iconSize, iconSize);
+                            p->save();
+                            drawItemPixmap(p, theme.rect, Qt::AlignCenter, pm);
+                            p->restore();
+                        } else {
+                            d->drawBackground(theme);
+                        }
+                    }
+                }
+
+                if (sub & SC_TitleBarMinButton && tb->titleBarFlags & Qt::WindowMinimizeButtonHint
+                        && !(tb->titleBarState & Qt::WindowMinimized)) {
+                    theme.rect = subControlRect(CC_TitleBar, option, SC_TitleBarMinButton, widget);
+                    partId = WP_MINBUTTON;
+                    if (widget && !widget->isEnabled())
+                        stateId = MINBS_DISABLED;
+                    else if (option->activeSubControls == SC_TitleBarMinButton && (option->state & State_Sunken))
+                        stateId = MINBS_PUSHED;
+                    else if (option->activeSubControls == SC_TitleBarMinButton && (option->state & State_MouseOver))
+                        stateId = MINBS_HOT;
+                    else if (!isActive)
+                        stateId = MINBS_INACTIVE;
+                    else
+                        stateId = MINBS_NORMAL;
+                    theme.partId = partId;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_TitleBarMaxButton && tb->titleBarFlags & Qt::WindowMaximizeButtonHint
+                        && !(tb->titleBarState & Qt::WindowMaximized)) {
+                    theme.rect = subControlRect(CC_TitleBar, option, SC_TitleBarMaxButton, widget);
+                    partId = WP_MAXBUTTON;
+                    if (widget && !widget->isEnabled())
+                        stateId = MAXBS_DISABLED;
+                    else if (option->activeSubControls == SC_TitleBarMaxButton && (option->state & State_Sunken))
+                        stateId = MAXBS_PUSHED;
+                    else if (option->activeSubControls == SC_TitleBarMaxButton && (option->state & State_MouseOver))
+                        stateId = MAXBS_HOT;
+                    else if (!isActive)
+                        stateId = MAXBS_INACTIVE;
+                    else
+                        stateId = MAXBS_NORMAL;
+                    theme.partId = partId;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_TitleBarContextHelpButton
+                    && tb->titleBarFlags & Qt::WindowContextHelpButtonHint) {
+                    theme.rect = subControlRect(CC_TitleBar, option, SC_TitleBarContextHelpButton, widget);
+                    partId = WP_HELPBUTTON;
+                    if (widget && !widget->isEnabled())
+                        stateId = MINBS_DISABLED;
+                    else if (option->activeSubControls == SC_TitleBarContextHelpButton && (option->state & State_Sunken))
+                        stateId = MINBS_PUSHED;
+                    else if (option->activeSubControls == SC_TitleBarContextHelpButton && (option->state & State_MouseOver))
+                        stateId = MINBS_HOT;
+                    else if (!isActive)
+                        stateId = MINBS_INACTIVE;
+                    else
+                        stateId = MINBS_NORMAL;
+                    theme.partId = partId;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+                }
+                bool drawNormalButton = (sub & SC_TitleBarNormalButton)
+                                        && (((tb->titleBarFlags & Qt::WindowMinimizeButtonHint)
+                                        && (tb->titleBarState & Qt::WindowMinimized))
+                                        || ((tb->titleBarFlags & Qt::WindowMaximizeButtonHint)
+                                        && (tb->titleBarState & Qt::WindowMaximized)));
+                if (drawNormalButton) {
+                    theme.rect = subControlRect(CC_TitleBar, option, SC_TitleBarNormalButton, widget);
+                    partId = WP_RESTOREBUTTON;
+                    if (widget && !widget->isEnabled())
+                        stateId = RBS_DISABLED;
+                    else if (option->activeSubControls == SC_TitleBarNormalButton && (option->state & State_Sunken))
+                        stateId = RBS_PUSHED;
+                    else if (option->activeSubControls == SC_TitleBarNormalButton && (option->state & State_MouseOver))
+                        stateId = RBS_HOT;
+                    else if (!isActive)
+                        stateId = RBS_INACTIVE;
+                    else
+                        stateId = RBS_NORMAL;
+                    theme.partId = partId;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_TitleBarShadeButton && tb->titleBarFlags & Qt::WindowShadeButtonHint
+                        && !(tb->titleBarState & Qt::WindowMinimized)) {
+                    theme.rect = subControlRect(CC_TitleBar, option, SC_TitleBarShadeButton, widget);
+                    partId = WP_MINBUTTON;
+                    if (widget && !widget->isEnabled())
+                        stateId = MINBS_DISABLED;
+                    else if (option->activeSubControls == SC_TitleBarShadeButton && (option->state & State_Sunken))
+                        stateId = MINBS_PUSHED;
+                    else if (option->activeSubControls == SC_TitleBarShadeButton && (option->state & State_MouseOver))
+                        stateId = MINBS_HOT;
+                    else if (!isActive)
+                        stateId = MINBS_INACTIVE;
+                    else
+                        stateId = MINBS_NORMAL;
+                    theme.partId = partId;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_TitleBarUnshadeButton && tb->titleBarFlags & Qt::WindowShadeButtonHint
+                        && tb->titleBarState & Qt::WindowMinimized) {
+                    theme.rect = subControlRect(CC_TitleBar, option, SC_TitleBarUnshadeButton, widget);
+                    partId = WP_RESTOREBUTTON;
+                    if (widget && !widget->isEnabled())
+                        stateId = RBS_DISABLED;
+                    else if (option->activeSubControls == SC_TitleBarUnshadeButton && (option->state & State_Sunken))
+                        stateId = RBS_PUSHED;
+                    else if (option->activeSubControls == SC_TitleBarUnshadeButton && (option->state & State_MouseOver))
+                        stateId = RBS_HOT;
+                    else if (!isActive)
+                        stateId = RBS_INACTIVE;
+                    else
+                        stateId = RBS_NORMAL;
+                    theme.partId = partId;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_TitleBarCloseButton && tb->titleBarFlags & Qt::WindowSystemMenuHint) {
+                    theme.rect = subControlRect(CC_TitleBar, option, SC_TitleBarCloseButton, widget);
+                    //partId = titlebar->testWFlags(Qt::WA_WState_Tool) ? WP_SMALLCLOSEBUTTON : WP_CLOSEBUTTON;
+                    partId = WP_CLOSEBUTTON;
+                    if (widget && !widget->isEnabled())
+                        stateId = CBS_DISABLED;
+                    else if (option->activeSubControls == SC_TitleBarCloseButton && (option->state & State_Sunken))
+                        stateId = CBS_PUSHED;
+                    else if (option->activeSubControls == SC_TitleBarCloseButton && (option->state & State_MouseOver))
+                        stateId = CBS_HOT;
+                    else if (!isActive)
+                        stateId = CBS_INACTIVE;
+                    else
+                        stateId = CBS_NORMAL;
+                    theme.partId = partId;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+                }
+            }
+        }
+        break;
+
+#ifndef QT_NO_WORKSPACE
+    case CC_MdiControls:
+        {
+            QRect buttonRect;
+            XPThemeData theme(widget, p, QLatin1String("WINDOW"), WP_MDICLOSEBUTTON, CBS_NORMAL);
+
+            if (option->subControls & SC_MdiCloseButton) {
+                buttonRect = subControlRect(CC_MdiControls, option, SC_MdiCloseButton, widget);
+                if (theme.isValid()) {
+                    theme.partId = WP_MDICLOSEBUTTON;
+                    theme.rect = buttonRect;
+                    if (!(flags & State_Enabled))
+                        theme.stateId = CBS_INACTIVE;
+                    else if (flags & State_Sunken && (option->activeSubControls & SC_MdiCloseButton))
+                        theme.stateId = CBS_PUSHED;
+                    else if (flags & State_MouseOver && (option->activeSubControls & SC_MdiCloseButton))
+                        theme.stateId = CBS_HOT;
+                    else
+                        theme.stateId = CBS_NORMAL;
+                    d->drawBackground(theme);
+                }
+            }
+            if (option->subControls & SC_MdiNormalButton) {
+                buttonRect = subControlRect(CC_MdiControls, option, SC_MdiNormalButton, widget);
+                if (theme.isValid()) {
+                    theme.partId = WP_MDIRESTOREBUTTON;
+                    theme.rect = buttonRect;
+                    if (!(flags & State_Enabled))
+                        theme.stateId = CBS_INACTIVE;
+                    else if (flags & State_Sunken && (option->activeSubControls & SC_MdiNormalButton))
+                        theme.stateId = CBS_PUSHED;
+                    else if (flags & State_MouseOver && (option->activeSubControls & SC_MdiNormalButton))
+                        theme.stateId = CBS_HOT;
+                    else
+                        theme.stateId = CBS_NORMAL;
+                    d->drawBackground(theme);
+                }
+            }
+            if (option->subControls & QStyle::SC_MdiMinButton) {
+                buttonRect = subControlRect(CC_MdiControls, option, SC_MdiMinButton, widget);
+                if (theme.isValid()) {
+                    theme.partId = WP_MDIMINBUTTON;
+                    theme.rect = buttonRect;
+                    if (!(flags & State_Enabled))
+                        theme.stateId = CBS_INACTIVE;
+                    else if (flags & State_Sunken && (option->activeSubControls & SC_MdiMinButton))
+                        theme.stateId = CBS_PUSHED;
+                    else if (flags & State_MouseOver && (option->activeSubControls & SC_MdiMinButton))
+                        theme.stateId = CBS_HOT;
+                    else
+                        theme.stateId = CBS_NORMAL;
+                    d->drawBackground(theme);
+                }
+            }
+        }
+        break;
+#endif //QT_NO_WORKSPACE
+    default:
+        QWindowsStyle::drawComplexControl(cc, option, p, widget);
+        break;
+    }
+}
+
+/*! \reimp */
+int QWindowsXPStyle::pixelMetric(PixelMetric pm, const QStyleOption *option, const QWidget *widget) const
+{
+    if (!QWindowsXPStylePrivate::useXP())
+        return QWindowsStyle::pixelMetric(pm, option, widget);
+
+    int res = 0;
+    switch (pm) {
+    case PM_MenuBarPanelWidth:
+        res = 0;
+        break;
+
+    case PM_DefaultFrameWidth:
+        if (qobject_cast<const QListView*>(widget))
+            res = 2;
+        else
+            res = 1;
+        break;
+    case PM_MenuPanelWidth:
+    case PM_SpinBoxFrameWidth:
+        res = 1;
+        break;
+
+    case PM_TabBarTabOverlap:
+    case PM_MenuHMargin:
+    case PM_MenuVMargin:
+        res = 2;
+        break;
+
+    case PM_TabBarBaseOverlap:
+        if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {
+            switch (tab->shape) {
+            case QTabBar::RoundedNorth:
+            case QTabBar::TriangularNorth:
+                res = 1;
+                break;
+            case QTabBar::RoundedSouth:
+            case QTabBar::TriangularSouth:
+                res = 2;
+                break;
+            case QTabBar::RoundedEast:
+            case QTabBar::TriangularEast:
+                res = 3;
+                break;
+            case QTabBar::RoundedWest:
+            case QTabBar::TriangularWest:
+                res = 1;
+                break;
+            }
+        }
+        break;
+
+    case PM_SplitterWidth:
+        res = qMax(5, QApplication::globalStrut().width());
+        break;
+
+    case PM_IndicatorWidth:
+    case PM_IndicatorHeight:
+        {
+            XPThemeData theme(widget, 0, QLatin1String("BUTTON"), BP_CHECKBOX, CBS_UNCHECKEDNORMAL);
+            if (theme.isValid()) {
+                SIZE size;
+                pGetThemePartSize(theme.handle(), 0, theme.partId, theme.stateId, 0, TS_TRUE, &size);
+                res = (pm == PM_IndicatorWidth ? size.cx+2 : res = size.cy+2);
+            }
+        }
+        break;
+
+    case PM_ExclusiveIndicatorWidth:
+    case PM_ExclusiveIndicatorHeight:
+        {
+            XPThemeData theme(widget, 0, QLatin1String("BUTTON"), BP_RADIOBUTTON, RBS_UNCHECKEDNORMAL);
+            if (theme.isValid()) {
+                SIZE size;
+                pGetThemePartSize(theme.handle(), 0, theme.partId, theme.stateId, 0, TS_TRUE, &size);
+                res = (pm == PM_ExclusiveIndicatorWidth ? size.cx+2 : res = size.cy+2);
+            }
+        }
+        break;
+
+    case PM_ProgressBarChunkWidth:
+        {
+            Qt::Orientation orient = Qt::Horizontal;
+            if (const QStyleOptionProgressBarV2 *pb2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option))
+                orient = pb2->orientation;
+            XPThemeData theme(widget, 0, QLatin1String("PROGRESS"), (orient == Qt::Horizontal) ? PP_CHUNK : PP_CHUNKVERT);
+            if (theme.isValid()) {
+                SIZE size;
+                pGetThemePartSize(theme.handle(), 0, theme.partId, theme.stateId, 0, TS_TRUE, &size);
+                res = (orient == Qt::Horizontal) ? size.cx : size.cy;
+            }
+        }
+        break;
+
+    case PM_SliderThickness:
+        {
+            XPThemeData theme(widget, 0, QLatin1String("TRACKBAR"), TKP_THUMB);
+            if (theme.isValid()) {
+                SIZE size;
+                pGetThemePartSize(theme.handle(), 0, theme.partId, theme.stateId, 0, TS_TRUE, &size);
+                res = size.cy;
+            }
+        }
+        break;
+
+    case PM_MenuButtonIndicator:
+        {
+            XPThemeData theme(widget, 0, QLatin1String("TOOLBAR"), TP_SPLITBUTTONDROPDOWN);
+            if (theme.isValid()) {
+                SIZE size;
+                pGetThemePartSize(theme.handle(), 0, theme.partId, theme.stateId, 0, TS_TRUE, &size);
+                res = size.cx;
+            }
+        }
+        break;
+
+    case PM_TitleBarHeight:
+        {
+#ifdef QT3_SUPPORT
+            if (widget && widget->inherits("Q3DockWindowTitleBar")) {
+                res = GetSystemMetrics(SM_CYSMCAPTION) + GetSystemMetrics(SM_CXSIZEFRAME);
+            } else
+#endif
+            if (widget && (widget->windowType() == Qt::Tool))
+                res = GetSystemMetrics(SM_CYSMCAPTION) + GetSystemMetrics(SM_CXSIZEFRAME);
+            else
+                res = GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CXSIZEFRAME);
+        }
+        break;
+
+    case PM_MdiSubWindowFrameWidth:
+        {
+            XPThemeData theme(widget, 0, QLatin1String("WINDOW"), WP_FRAMELEFT, FS_ACTIVE);
+            if (theme.isValid()) {
+                SIZE size;
+                pGetThemePartSize(theme.handle(), 0, WP_FRAMELEFT, FS_ACTIVE, 0, TS_TRUE, &size);
+                res = size.cx-1;
+            }
+        }
+        break;
+
+    case PM_MdiSubWindowMinimizedWidth:
+        res = 160;
+        break;
+
+#ifndef QT_NO_TOOLBAR
+    case PM_ToolBarHandleExtent:
+        res = 8;
+        break;
+
+#endif // QT_NO_TOOLBAR
+    case PM_DockWidgetFrameWidth:
+    {
+        XPThemeData theme(widget, 0, QLatin1String("WINDOW"), WP_SMALLFRAMERIGHT, FS_ACTIVE);
+        if (theme.isValid()) {
+            SIZE size;
+            pGetThemePartSize(theme.handle(), 0, theme.partId, theme.stateId, 0, TS_TRUE, &size);
+            res = size.cx;
+        }
+    }
+    break;
+    case PM_DockWidgetSeparatorExtent:
+        res = 4;
+        break;
+    case PM_DockWidgetTitleMargin:
+        res = 4;
+        break;
+
+    case PM_ButtonShiftHorizontal:
+    case PM_ButtonShiftVertical:
+        if (qstyleoption_cast<const QStyleOptionToolButton *>(option))
+            res = 1;
+        else
+            res = 0;
+        break;
+
+    default:
+        res = QWindowsStyle::pixelMetric(pm, option, widget);
+    }
+
+    return res;
+}
+
+/*
+  This function is used by subControlRect to check if a button
+  should be drawn for the given subControl given a set of window flags.
+*/
+static bool buttonVisible(const QStyle::SubControl sc, const QStyleOptionTitleBar *tb){
+
+    bool isMinimized = tb->titleBarState & Qt::WindowMinimized;
+    bool isMaximized = tb->titleBarState & Qt::WindowMaximized;
+    const uint flags = tb->titleBarFlags;
+    bool retVal = false;
+    switch (sc) {
+    case QStyle::SC_TitleBarContextHelpButton:
+        if (flags & Qt::WindowContextHelpButtonHint)
+            retVal = true;
+        break;
+    case QStyle::SC_TitleBarMinButton:
+        if (!isMinimized && (flags & Qt::WindowMinimizeButtonHint))
+            retVal = true;
+        break;
+    case QStyle::SC_TitleBarNormalButton:
+        if (isMinimized && (flags & Qt::WindowMinimizeButtonHint))
+            retVal = true;
+        else if (isMaximized && (flags & Qt::WindowMaximizeButtonHint))
+            retVal = true;
+        break;
+    case QStyle::SC_TitleBarMaxButton:
+        if (!isMaximized && (flags & Qt::WindowMaximizeButtonHint))
+            retVal = true;
+        break;
+    case QStyle::SC_TitleBarShadeButton:
+        if (!isMinimized &&  flags & Qt::WindowShadeButtonHint)
+            retVal = true;
+        break;
+    case QStyle::SC_TitleBarUnshadeButton:
+        if (isMinimized && flags & Qt::WindowShadeButtonHint)
+            retVal = true;
+        break;
+    case QStyle::SC_TitleBarCloseButton:
+        if (flags & Qt::WindowSystemMenuHint)
+            retVal = true;
+        break;
+    case QStyle::SC_TitleBarSysMenu:
+        if (flags & Qt::WindowSystemMenuHint)
+            retVal = true;
+        break;
+    default :
+        retVal = true;
+    }
+    return retVal;
+}
+
+/*!
+    \reimp
+*/
+QRect QWindowsXPStyle::subControlRect(ComplexControl cc, const QStyleOptionComplex *option,
+                                      SubControl subControl, const QWidget *widget) const
+{
+    if (!QWindowsXPStylePrivate::useXP())
+        return QWindowsStyle::subControlRect(cc, option, subControl, widget);
+
+    QRect rect;
+
+    switch (cc) {
+    case CC_TitleBar:
+        if (const QStyleOptionTitleBar *tb = qstyleoption_cast<const QStyleOptionTitleBar *>(option)) {
+            if (!buttonVisible(subControl, tb))
+                return rect;
+            const bool isToolTitle = false;
+            const int height = tb->rect.height();
+            const int width = tb->rect.width();
+            int buttonHeight = GetSystemMetrics(SM_CYSIZE) - 4;
+            int buttonWidth = GetSystemMetrics(SM_CXSIZE) - 4;
+            const int delta = buttonWidth + 2;
+            int controlTop = option->rect.bottom() - buttonHeight - 2;
+            const int frameWidth = pixelMetric(PM_MdiSubWindowFrameWidth, option, widget);
+            const bool sysmenuHint  = (tb->titleBarFlags & Qt::WindowSystemMenuHint) != 0;
+            const bool minimizeHint = (tb->titleBarFlags & Qt::WindowMinimizeButtonHint) != 0;
+            const bool maximizeHint = (tb->titleBarFlags & Qt::WindowMaximizeButtonHint) != 0;
+            const bool contextHint = (tb->titleBarFlags & Qt::WindowContextHelpButtonHint) != 0;
+            const bool shadeHint = (tb->titleBarFlags & Qt::WindowShadeButtonHint) != 0;
+            bool isMinimized = tb->titleBarState & Qt::WindowMinimized;
+            bool isMaximized = tb->titleBarState & Qt::WindowMaximized;
+            int offset = 0;
+
+            switch (subControl) {
+            case SC_TitleBarLabel:
+                rect = QRect(frameWidth, 0, width - (buttonWidth + frameWidth + 10), height);
+                if (isToolTitle) {
+                    if (sysmenuHint) {
+                        rect.adjust(0, 0, -buttonWidth - 3, 0);
+                    }
+                    if (minimizeHint || maximizeHint)
+                        rect.adjust(0, 0, -buttonWidth - 2, 0);
+                } else {
+                    if (sysmenuHint) {
+                        const int leftOffset = height - 8;
+                        rect.adjust(leftOffset, 0, 0, 0);
+                    }
+                    if (minimizeHint)
+                        rect.adjust(0, 0, -buttonWidth - 2, 0);
+                    if (maximizeHint)
+                        rect.adjust(0, 0, -buttonWidth - 2, 0);
+                    if (contextHint)
+                        rect.adjust(0, 0, -buttonWidth - 2, 0);
+                    if (shadeHint)
+                        rect.adjust(0, 0, -buttonWidth - 2, 0);
+                }
+                break;
+
+            case SC_TitleBarContextHelpButton:
+                if (tb->titleBarFlags & Qt::WindowContextHelpButtonHint)
+                    offset += delta;
+                //fall through
+            case SC_TitleBarMinButton:
+                if (!isMinimized && (tb->titleBarFlags & Qt::WindowMinimizeButtonHint))
+                    offset += delta;
+                else if (subControl == SC_TitleBarMinButton)
+                    break;
+                //fall through
+            case SC_TitleBarNormalButton:
+                if (isMinimized && (tb->titleBarFlags & Qt::WindowMinimizeButtonHint))
+                    offset += delta;
+                else if (isMaximized && (tb->titleBarFlags & Qt::WindowMaximizeButtonHint))
+                    offset += delta;
+                else if (subControl == SC_TitleBarNormalButton)
+                    break;
+                //fall through
+            case SC_TitleBarMaxButton:
+                if (!isMaximized && (tb->titleBarFlags & Qt::WindowMaximizeButtonHint))
+                    offset += delta;
+                else if (subControl == SC_TitleBarMaxButton)
+                    break;
+                //fall through
+            case SC_TitleBarShadeButton:
+                if (!isMinimized && (tb->titleBarFlags & Qt::WindowShadeButtonHint))
+                    offset += delta;
+                else if (subControl == SC_TitleBarShadeButton)
+                    break;
+                //fall through
+            case SC_TitleBarUnshadeButton:
+                if (isMinimized && (tb->titleBarFlags & Qt::WindowShadeButtonHint))
+                    offset += delta;
+                else if (subControl == SC_TitleBarUnshadeButton)
+                    break;
+                //fall through
+            case SC_TitleBarCloseButton:
+                if (tb->titleBarFlags & Qt::WindowSystemMenuHint)
+                    offset += delta;
+                else if (subControl == SC_TitleBarCloseButton)
+                    break;
+
+                rect.setRect(width - offset - controlTop + 1, controlTop,
+                             buttonWidth, buttonHeight);
+                break;
+
+            case SC_TitleBarSysMenu:
+                {
+                    const int controlTop = 6;
+                    const int controlHeight = height - controlTop - 3;
+                    const int iconExtent = pixelMetric(PM_SmallIconSize);
+                    QSize iconSize = tb->icon.actualSize(QSize(iconExtent, iconExtent));
+                    if (tb->icon.isNull())
+                        iconSize = QSize(controlHeight, controlHeight);
+                    int hPad = (controlHeight - iconSize.height())/2;
+                    int vPad = (controlHeight - iconSize.width())/2;
+                    rect = QRect(frameWidth + hPad, controlTop + vPad, iconSize.width(), iconSize.height());
+                }
+                break;
+            }
+        }
+        break;
+
+    case CC_ComboBox:
+        if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
+            int x = cmb->rect.x(), y = cmb->rect.y(), wi = cmb->rect.width(), he = cmb->rect.height();
+            int xpos = x;
+            xpos += wi - 1 - 16;
+
+            switch (subControl) {
+            case SC_ComboBoxFrame:
+                rect = cmb->rect;
+                break;
+
+            case SC_ComboBoxArrow:
+                rect = QRect(xpos, y+1, 16, he-2);
+                break;
+
+            case SC_ComboBoxEditField:
+                rect = QRect(x+2, y+2, wi-3-16, he-4);
+                break;
+
+            case SC_ComboBoxListBoxPopup:
+                rect = cmb->rect;
+                break;
+            }
+        }
+        break;
+#ifndef QT_NO_WORKSPACE
+    case CC_MdiControls:
+    {
+        int numSubControls = 0;
+        if (option->subControls & SC_MdiCloseButton)
+            ++numSubControls;
+        if (option->subControls & SC_MdiMinButton)
+            ++numSubControls;
+        if (option->subControls & SC_MdiNormalButton)
+            ++numSubControls;
+        if (numSubControls == 0)
+            break;
+
+        int buttonWidth = option->rect.width()/ numSubControls;
+        int offset = 0;
+        switch (subControl) {
+        case SC_MdiCloseButton:
+            // Only one sub control, no offset needed.
+            if (numSubControls == 1)
+                break;
+            offset += buttonWidth;
+            //FALL THROUGH
+        case SC_MdiNormalButton:
+            // No offset needed if
+            // 1) There's only one sub control
+            // 2) We have a close button and a normal button (offset already added in SC_MdiClose)
+            if (numSubControls == 1 || (numSubControls == 2 && !(option->subControls & SC_MdiMinButton)))
+                break;
+            if (option->subControls & SC_MdiNormalButton)
+                offset += buttonWidth;
+            break;
+        default:
+            break;
+        }
+        rect = QRect(offset, 0, buttonWidth, option->rect.height());
+        break;
+    }
+#endif // QT_NO_WORKSPACE
+
+    default:
+        rect = visualRect(option->direction, option->rect,
+                          QWindowsStyle::subControlRect(cc, option, subControl, widget));
+        break;
+    }
+    return visualRect(option->direction, option->rect, rect);
+}
+
+/*!
+    \reimp
+*/
+QSize QWindowsXPStyle::sizeFromContents(ContentsType ct, const QStyleOption *option,
+                                        const QSize &contentsSize, const QWidget *widget) const
+{
+    if (!QWindowsXPStylePrivate::useXP())
+        return QWindowsStyle::sizeFromContents(ct, option, contentsSize, widget);
+
+    QSize sz(contentsSize);
+    switch (ct) {
+    case CT_LineEdit:
+    case CT_ComboBox:
+        {
+            HTHEME theme = pOpenThemeData(QWindowsXPStylePrivate::winId(widget), L"Button");
+            MARGINS borderSize;
+            if (theme) {
+                int result = pGetThemeMargins(theme,
+                                              NULL,
+                                              BP_PUSHBUTTON,
+                                              PBS_NORMAL,
+                                              TMT_CONTENTMARGINS,
+                                              NULL,
+                                              &borderSize);
+                if (result == S_OK) {
+                    sz += QSize(borderSize.cxLeftWidth + borderSize.cxRightWidth - 2,
+                                borderSize.cyBottomHeight + borderSize.cyTopHeight - 2);
+                }
+                sz += QSize(23, 0); //arrow button
+            }
+        }
+        break;
+    case CT_SpinBox:
+        {
+            //Spinbox adds frame twice
+            sz = QWindowsStyle::sizeFromContents(ct, option, contentsSize, widget);
+            int border = pixelMetric(PM_SpinBoxFrameWidth, option, widget);
+            sz -= QSize(2*border, 2*border);
+        }
+        break;
+    case CT_TabWidget:
+        sz += QSize(6, 6);
+        break;
+    case CT_Menu:
+        sz += QSize(1, 0);
+        break;
+#ifndef QT_NO_MENUBAR
+    case CT_MenuBarItem:
+        if (!sz.isEmpty())
+            sz += QSize(windowsItemHMargin * 5 + 1, 6);
+        break;
+#endif
+    case CT_MenuItem:
+        if (const QStyleOptionMenuItem *menuitem = qstyleoption_cast<const QStyleOptionMenuItem *>(option))
+        {
+            if (menuitem->menuItemType != QStyleOptionMenuItem::Separator) {
+                sz = QWindowsStyle::sizeFromContents(ct, option, sz, widget);
+                sz.setHeight(sz.height() - 2);
+                return sz;
+            }
+        }
+        sz = QWindowsStyle::sizeFromContents(ct, option, sz, widget);
+        break;
+
+    case CT_MdiControls:
+        if (const QStyleOptionComplex *styleOpt = qstyleoption_cast<const QStyleOptionComplex *>(option)) {
+            int width = 0;
+            if (styleOpt->subControls & SC_MdiMinButton)
+                width += 17 + 1;
+            if (styleOpt->subControls & SC_MdiNormalButton)
+                width += 17 + 1;
+            if (styleOpt->subControls & SC_MdiCloseButton)
+                width += 17 + 1;
+            sz = QSize(width, 19);
+        } else {
+            sz = QSize(54, 19);
+        }
+        break;
+
+    default:
+        sz = QWindowsStyle::sizeFromContents(ct, option, sz, widget);
+        break;
+    }
+
+    return sz;
+}
+
+
+/*! \reimp */
+int QWindowsXPStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidget *widget,
+                               QStyleHintReturn *returnData) const
+{
+  QWindowsXPStylePrivate *d = const_cast<QWindowsXPStylePrivate*>(d_func());
+    if (!QWindowsXPStylePrivate::useXP())
+        return QWindowsStyle::styleHint(hint, option, widget, returnData);
+
+    int res = 0;
+    switch (hint) {
+
+    case SH_EtchDisabledText:
+        res = (qobject_cast<const QLabel*>(widget) != 0);
+        break;
+
+    case SH_SpinControls_DisableOnBounds:
+        res = 0;
+        break;
+
+    case SH_TitleBar_AutoRaise:
+    case SH_TitleBar_NoBorder:
+        res = 1;
+        break;
+
+    case SH_GroupBox_TextLabelColor:
+        if (!widget || (widget && widget->isEnabled()))
+            res = d->groupBoxTextColor;
+        else
+            res = d->groupBoxTextColorDisabled;
+        break;
+
+    case SH_Table_GridLineColor:
+        res = 0xC0C0C0;
+        break;
+
+    case SH_WindowFrame_Mask:
+        {
+            res = 1;
+            QStyleHintReturnMask *mask = qstyleoption_cast<QStyleHintReturnMask *>(returnData);
+            const QStyleOptionTitleBar *titlebar = qstyleoption_cast<const QStyleOptionTitleBar *>(option);
+            if (mask && titlebar) {
+                XPThemeData themeData;
+                if (titlebar->titleBarState & Qt::WindowMinimized) {
+                    themeData = XPThemeData(widget, 0, QLatin1String("WINDOW"), WP_MINCAPTION, CS_ACTIVE, option->rect);
+                } else
+                    themeData = XPThemeData(widget, 0, QLatin1String("WINDOW"), WP_CAPTION, CS_ACTIVE, option->rect);
+                mask->region = d->region(themeData);
+            }
+        }
+        break;
+#ifndef QT_NO_RUBBERBAND
+    case SH_RubberBand_Mask:
+        if (qstyleoption_cast<const QStyleOptionRubberBand *>(option)) {
+            res = 0;
+            break;
+        }
+#endif // QT_NO_RUBBERBAND
+
+    case SH_ItemView_DrawDelegateFrame:
+        res = 1;
+        break;
+
+    default:
+        res =QWindowsStyle::styleHint(hint, option, widget, returnData);
+    }
+
+    return res;
+}
+
+/*! \reimp */
+QPalette QWindowsXPStyle::standardPalette() const
+{
+    if (QWindowsXPStylePrivate::useXP() && QApplicationPrivate::sys_pal)
+        return *QApplicationPrivate::sys_pal;
+    else
+        return QWindowsStyle::standardPalette();
+}
+
+/*!
+    \reimp
+*/
+QPixmap QWindowsXPStyle::standardPixmap(StandardPixmap standardPixmap, const QStyleOption *option,
+                                        const QWidget *widget) const
+{
+    if (!QWindowsXPStylePrivate::useXP())
+        return QWindowsStyle::standardPixmap(standardPixmap, option, widget);
+
+    switch(standardPixmap) {
+    case SP_TitleBarMaxButton:
+    case SP_TitleBarCloseButton:
+        if (qstyleoption_cast<const QStyleOptionDockWidget *>(option))
+        {
+            if (widget && widget->isWindow()) {
+                XPThemeData theme(widget, 0, QLatin1String("WINDOW"), WP_SMALLCLOSEBUTTON, CBS_NORMAL);
+                if (theme.isValid()) {
+                    SIZE sz;
+                    pGetThemePartSize(theme.handle(), 0, theme.partId, theme.stateId, 0, TS_TRUE, &sz);
+                    return QIcon(QWindowsStyle::standardPixmap(standardPixmap, option, widget)).pixmap(QSize(sz.cx, sz.cy));
+                }
+            }
+        }
+        break;
+    }
+    return QWindowsStyle::standardPixmap(standardPixmap, option, widget);
+}
+
+/*!
+    \internal
+*/
+QIcon QWindowsXPStyle::standardIconImplementation(StandardPixmap standardIcon,
+                                                  const QStyleOption *option,
+                                                  const QWidget *widget) const
+{
+    if (!QWindowsXPStylePrivate::useXP()) {
+        return QWindowsStyle::standardIconImplementation(standardIcon, option, widget);
+    }
+
+    QWindowsXPStylePrivate *d = const_cast<QWindowsXPStylePrivate*>(d_func());
+    switch(standardIcon) {
+    case SP_TitleBarMaxButton:
+        if (qstyleoption_cast<const QStyleOptionDockWidget *>(option))
+        {
+            if (d->dockFloat.isNull()) {
+                XPThemeData themeSize(0, 0, QLatin1String("WINDOW"), WP_SMALLCLOSEBUTTON, CBS_NORMAL);
+                XPThemeData theme(0, 0, QLatin1String("WINDOW"), WP_MAXBUTTON, MAXBS_NORMAL);
+                if (theme.isValid()) {
+                    SIZE size;
+                    pGetThemePartSize(themeSize.handle(), 0, themeSize.partId, themeSize.stateId, 0, TS_TRUE, &size);
+                    QPixmap pm = QPixmap(size.cx, size.cy);
+                    pm.fill(Qt::transparent);
+                    QPainter p(&pm);
+                    theme.painter = &p;
+                    theme.rect = QRect(0, 0, size.cx, size.cy);
+                    d->drawBackground(theme);
+                    d->dockFloat.addPixmap(pm, QIcon::Normal, QIcon::Off);    // Normal
+                    pm.fill(Qt::transparent);
+                    theme.stateId = MAXBS_PUSHED;
+                    d->drawBackground(theme);
+                    d->dockFloat.addPixmap(pm, QIcon::Normal, QIcon::On);     // Pressed
+                    pm.fill(Qt::transparent);
+                    theme.stateId = MAXBS_HOT;
+                    d->drawBackground(theme);
+                    d->dockFloat.addPixmap(pm, QIcon::Active, QIcon::Off);    // Hover
+                    pm.fill(Qt::transparent);
+                    theme.stateId = MAXBS_INACTIVE;
+                    d->drawBackground(theme);
+                    d->dockFloat.addPixmap(pm, QIcon::Disabled, QIcon::Off);  // Disabled
+                }
+            }
+            if (widget && widget->isWindow())
+                return d->dockFloat;
+
+        }
+        break;
+    case SP_TitleBarCloseButton:
+        if (qstyleoption_cast<const QStyleOptionDockWidget *>(option))
+        {
+            if (d->dockClose.isNull()) {
+                XPThemeData theme(0, 0, QLatin1String("WINDOW"), WP_SMALLCLOSEBUTTON, CBS_NORMAL);
+                if (theme.isValid()) {
+                    SIZE size;
+                    pGetThemePartSize(theme.handle(), 0, theme.partId, theme.stateId, 0, TS_TRUE, &size);
+                    QPixmap pm = QPixmap(size.cx, size.cy);
+                    pm.fill(Qt::transparent);
+                    QPainter p(&pm);
+                    theme.painter = &p;
+                    theme.partId = WP_CLOSEBUTTON; // ####
+                    theme.rect = QRect(0, 0, size.cx, size.cy);
+                    d->drawBackground(theme);
+                    d->dockClose.addPixmap(pm, QIcon::Normal, QIcon::Off);    // Normal
+                    pm.fill(Qt::transparent);
+                    theme.stateId = CBS_PUSHED;
+                    d->drawBackground(theme);
+                    d->dockClose.addPixmap(pm, QIcon::Normal, QIcon::On);     // Pressed
+                    pm.fill(Qt::transparent);
+                    theme.stateId = CBS_HOT;
+                    d->drawBackground(theme);
+                    d->dockClose.addPixmap(pm, QIcon::Active, QIcon::Off);    // Hover
+                    pm.fill(Qt::transparent);
+                    theme.stateId = CBS_INACTIVE;
+                    d->drawBackground(theme);
+                    d->dockClose.addPixmap(pm, QIcon::Disabled, QIcon::Off);  // Disabled
+                }
+            }
+            if (widget && widget->isWindow())
+                return d->dockClose;
+        }
+        break;
+    case SP_TitleBarNormalButton:
+        if (qstyleoption_cast<const QStyleOptionDockWidget *>(option))
+        {
+            if (d->dockFloat.isNull()) {
+                XPThemeData themeSize(0, 0, QLatin1String("WINDOW"), WP_SMALLCLOSEBUTTON, CBS_NORMAL);
+                XPThemeData theme(0, 0, QLatin1String("WINDOW"), WP_RESTOREBUTTON, RBS_NORMAL);
+                if (theme.isValid()) {
+                    SIZE size;
+                    pGetThemePartSize(themeSize.handle(), 0, themeSize.partId, themeSize.stateId, 0, TS_TRUE, &size);
+                    QPixmap pm = QPixmap(size.cx, size.cy);
+                    pm.fill(Qt::transparent);
+                    QPainter p(&pm);
+                    theme.painter = &p;
+                    theme.rect = QRect(0, 0, size.cx, size.cy);
+                    d->drawBackground(theme);
+                    d->dockFloat.addPixmap(pm, QIcon::Normal, QIcon::Off);    // Normal
+                    pm.fill(Qt::transparent);
+                    theme.stateId = RBS_PUSHED;
+                    d->drawBackground(theme);
+                    d->dockFloat.addPixmap(pm, QIcon::Normal, QIcon::On);     // Pressed
+                    pm.fill(Qt::transparent);
+                    theme.stateId = RBS_HOT;
+                    d->drawBackground(theme);
+                    d->dockFloat.addPixmap(pm, QIcon::Active, QIcon::Off);    // Hover
+                    pm.fill(Qt::transparent);
+                    theme.stateId = RBS_INACTIVE;
+                    d->drawBackground(theme);
+                    d->dockFloat.addPixmap(pm, QIcon::Disabled, QIcon::Off);  // Disabled
+                }
+            }
+            if (widget && widget->isWindow())
+                return d->dockFloat;
+
+        }
+        break;
+    }
+
+    return QWindowsStyle::standardIconImplementation(standardIcon, option, widget);
+}
+
+/*!
+    \internal
+
+    Constructs a QWindowsXPStyle object.
+*/
+QWindowsXPStyle::QWindowsXPStyle(QWindowsXPStylePrivate &dd) : QWindowsStyle(dd)
+{
+}
+
+
+// Debugging code ---------------------------------------------------------------------[ START ]---
+// The code for this point on is not compiled by default, but only used as assisting
+// debugging code when you uncomment the DEBUG_XP_STYLE define at the top of the file.
+
+#ifdef DEBUG_XP_STYLE
+// The schema file expects these to be defined by the user.
+#define TMT_ENUMDEF 8
+#define TMT_ENUMVAL TEXT('A')
+#define TMT_ENUM    TEXT('B')
+#define SCHEMA_STRINGS // For 2nd pass on schema file
+QT_BEGIN_INCLUDE_NAMESPACE
+#include <tmschema.h>
+QT_END_INCLUDE_NAMESPACE
+
+// A property's value, type and name combo
+struct PropPair {
+    int propValue;
+    int propType;
+    LPCWSTR propName;
+};
+
+// Operator for sorting of PropPairs
+bool operator<(PropPair a, PropPair b) {
+    return wcscmp(a.propName, b.propName) < 0;
+}
+
+// Our list of all possible properties
+static QList<PropPair> all_props;
+
+
+/*! \internal
+    Dumps a portion of the full native DIB section double buffer.
+    The DIB section double buffer is only used when doing special
+    transformations to the theme part, or when the real double
+    buffer in the paintengine does not have an HDC we may use
+    directly.
+    Since we cannot rely on the pixel data we get from Microsoft
+    when drawing into the DIB section, we use this function to
+    see the actual data we got, and can determin the appropriate
+    action.
+*/
+void QWindowsXPStylePrivate::dumpNativeDIB(int w, int h)
+{
+    if (w && h) {
+        static int pCount = 0;
+        DWORD *bufPix = (DWORD*)bufferPixels;
+
+        char *bufferDump = new char[bufferH * bufferW * 16];
+        char *bufferPos = bufferDump;
+
+        memset(bufferDump, 0, sizeof(bufferDump));
+        bufferPos += sprintf(bufferPos, "const int pixelBufferW%d = %d;\n", pCount, w);
+        bufferPos += sprintf(bufferPos, "const int pixelBufferH%d = %d;\n", pCount, h);
+        bufferPos += sprintf(bufferPos, "const unsigned DWORD pixelBuffer%d[] = {", pCount);
+        for (int iy = 0; iy < h; ++iy) {
+            bufferPos += sprintf(bufferPos, "\n    ");
+            bufPix = (DWORD*)(bufferPixels + (iy * bufferW * 4));
+            for (int ix = 0; ix < w; ++ix) {
+                bufferPos += sprintf(bufferPos, "0x%08x, ", *bufPix);
+                ++bufPix;
+            }
+        }
+        bufferPos += sprintf(bufferPos, "\n};\n\n");
+        printf(bufferDump);
+
+        delete bufferDump;
+        ++pCount;
+    }
+}
+
+/*! \internal
+    Shows the value of a given property for a part.
+*/
+static void showProperty(XPThemeData &themeData, const PropPair &prop)
+{
+    PROPERTYORIGIN origin = PO_NOTFOUND;
+    pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, &origin);
+    const char *originStr;
+    switch(origin) {
+    case PO_STATE:
+        originStr = "State ";
+        break;
+    case PO_PART:
+        originStr = "Part  ";
+        break;
+    case PO_CLASS:
+        originStr = "Class ";
+        break;
+    case PO_GLOBAL:
+        originStr = "Globl ";
+        break;
+    case PO_NOTFOUND:
+    default:
+        originStr = "Unkwn ";
+        break;
+    }
+
+    switch(prop.propType) {
+    case TMT_STRING:
+        {
+            wchar_t buffer[512];
+            pGetThemeString(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, buffer, 512);
+            printf("  (%sString)  %-20S: %S\n", originStr, prop.propName, buffer);
+        }
+        break;
+    case TMT_ENUM:
+        {
+            int result = -1;
+            pGetThemeEnumValue(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, &result);
+            printf("  (%sEnum)    %-20S: %d\n", originStr, prop.propName, result);
+        }
+        break;
+    case TMT_INT:
+        {
+            int result = -1;
+            pGetThemeInt(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, &result);
+            printf("  (%sint)     %-20S: %d\n", originStr, prop.propName, result);
+        }
+        break;
+    case TMT_BOOL:
+        {
+            BOOL result = false;
+            pGetThemeBool(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, &result);
+            printf("  (%sbool)    %-20S: %d\n", originStr, prop.propName, result);
+        }
+        break;
+    case TMT_COLOR:
+        {
+            COLORREF result = 0;
+            pGetThemeColor(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, &result);
+            printf("  (%scolor)   %-20S: 0x%08X\n", originStr, prop.propName, result);
+        }
+        break;
+    case TMT_MARGINS:
+        {
+            MARGINS result;
+            memset(&result, 0, sizeof(result));
+            pGetThemeMargins(themeData.handle(), 0, themeData.partId, themeData.stateId, prop.propValue, 0, &result);
+            printf("  (%smargins) %-20S: (%d, %d, %d, %d)\n", originStr,
+                   prop.propName, result.cxLeftWidth, result.cyTopHeight, result.cxRightWidth, result.cyBottomHeight);
+        }
+        break;
+    case TMT_FILENAME:
+        {
+            wchar_t buffer[512];
+            pGetThemeFilename(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, buffer, 512);
+            printf("  (%sfilename)%-20S: %S\n", originStr, prop.propName, buffer);
+        }
+        break;
+    case TMT_SIZE:
+        {
+            SIZE result1;
+            SIZE result2;
+            SIZE result3;
+            memset(&result1, 0, sizeof(result1));
+            memset(&result2, 0, sizeof(result2));
+            memset(&result3, 0, sizeof(result3));
+            pGetThemePartSize(themeData.handle(), 0, themeData.partId, themeData.stateId, 0, TS_MIN,  &result1);
+            pGetThemePartSize(themeData.handle(), 0, themeData.partId, themeData.stateId, 0, TS_TRUE, &result2);
+            pGetThemePartSize(themeData.handle(), 0, themeData.partId, themeData.stateId, 0, TS_DRAW, &result3);
+            printf("  (%ssize)    %-20S: Min (%d, %d),  True(%d, %d),  Draw(%d, %d)\n", originStr, prop.propName,
+                   result1.cx, result1.cy, result2.cx, result2.cy, result3.cx, result3.cy);
+        }
+        break;
+    case TMT_POSITION:
+        {
+            POINT result;
+            memset(&result, 0, sizeof(result));
+            pGetThemePosition(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, &result);
+            printf("  (%sPosition)%-20S: (%d, %d)\n", originStr, prop.propName, result.x, result.y);
+        }
+        break;
+    case TMT_RECT:
+        {
+            RECT result;
+            memset(&result, 0, sizeof(result));
+            pGetThemeRect(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, &result);
+            printf("  (%sRect)    %-20S: (%d, %d, %d, %d)\n", originStr, prop.propName, result.left, result.top, result.right, result.bottom);
+        }
+        break;
+    case TMT_FONT:
+        {
+            LOGFONT result;
+            memset(&result, 0, sizeof(result));
+            pGetThemeFont(themeData.handle(), 0, themeData.partId, themeData.stateId, prop.propValue, &result);
+            printf("  (%sFont)    %-20S: %S  height(%d)  width(%d)  weight(%d)\n", originStr, prop.propName,
+                   result.lfFaceName, result.lfHeight, result.lfWidth, result.lfWeight);
+        }
+        break;
+    case TMT_INTLIST:
+        {
+            INTLIST result;
+            memset(&result, 0, sizeof(result));
+            pGetThemeIntList(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, &result);
+            printf("  (%sInt list)%-20S: { ", originStr, prop.propName);
+            for (int i = 0; i < result.iValueCount; ++i)
+                printf("%d ", result.iValues[i]);
+            printf("}\n");
+        }
+        break;
+    default:
+        printf("    %s%S : Unknown property type (%d)!\n", originStr, prop.propName, prop.propType);
+    }
+}
+
+/*! \internal
+    Dump all valid properties for a part.
+    If it's the first time this function is called, then the name,
+    enum value and documentation of all properties are shown, as
+    well as all global properties.
+*/
+void QWindowsXPStylePrivate::showProperties(XPThemeData &themeData)
+{
+    if (!all_props.count()) {
+        const TMSCHEMAINFO *infoTable = GetSchemaInfo();
+        for (int i = 0; i < infoTable->iPropCount; ++i) {
+            int propType  = infoTable->pPropTable[i].bPrimVal;
+            int propValue = infoTable->pPropTable[i].sEnumVal;
+            LPCWSTR propName = infoTable->pPropTable[i].pszName;
+
+            switch(propType) {
+            case TMT_ENUMDEF:
+            case TMT_ENUMVAL:
+                continue;
+            default:
+                if (propType != propValue) {
+                    PropPair prop;
+                    prop.propValue = propValue;
+                    prop.propName  = propName;
+                    prop.propType  = propType;
+                    all_props.append(prop);
+                }
+            }
+        }
+        qSort(all_props);
+
+        {// List all properties
+            printf("part properties count = %d:\n", all_props.count());
+            printf("      Enum  Property Name        Description\n");
+            printf("-----------------------------------------------------------\n");
+            wchar_t themeName[256];
+            pGetCurrentThemeName(themeName, 256, 0, 0, 0, 0);
+            for (int j = 0; j < all_props.count(); ++j) {
+                PropPair prop = all_props.at(j);
+                wchar_t buf[500];
+                pGetThemeDocumentationProperty(themeName, prop.propName, buf, 500);
+                printf("%3d: (%4d) %-20S %S\n", j, prop.propValue, prop.propName, buf);
+            }
+        }
+
+        {// Show Global values
+            printf("Global Properties:\n");
+            for (int j = 0; j < all_props.count(); ++j) {
+                PropPair prop = all_props.at(j);
+                PROPERTYORIGIN origin = PO_NOTFOUND;
+                pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, &origin);
+                if (origin == PO_GLOBAL) {
+                    showProperty(themeData, prop);
+                }
+            }
+        }
+    }
+
+    for (int j = 0; j < all_props.count(); ++j) {
+        PropPair prop = all_props.at(j);
+        PROPERTYORIGIN origin = PO_NOTFOUND;
+        pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, &origin);
+        if (origin != PO_NOTFOUND)
+        {
+            showProperty(themeData, prop);
+        }
+    }
+}
+#endif
+// Debugging code -----------------------------------------------------------------------[ END ]---
+
+
+QT_END_NAMESPACE
+
+#endif //QT_NO_WINDOWSXP