Initial "port" of QQC2::QWindowsStyle

It also includes qwindowsxpstyle and qwindowsvistastyle,
but they do not compile at the moment

Change-Id: Ie9ce0bf99d620d65534c2660150117e4747f5c86
Reviewed-by: Richard Moe Gustavsen <richard.gustavsen@qt.io>

14 files changed, 11410 insertions, 6 deletions

diff --git a/src/imports/nativestyle/qstyle/qstyle.pri b/src/imports/nativestyle/qstyle/qstyle.pri
index 9f1e82df..33257845 100644
--- a/src/imports/nativestyle/qstyle/qstyle.pri
+++ b/src/imports/nativestyle/qstyle/qstyle.pri
@@ -20,3 +20,4 @@ SOURCES += \
     $$PWD/qquickstyleoption.cpp
 
 macos: include(mac/mac.pri)
+windows: include(windows/windows.pri)
diff --git a/src/imports/nativestyle/qstyle/windows/qdrawutil.cpp b/src/imports/nativestyle/qstyle/windows/qdrawutil.cpp
new file mode 100644
index 00000000..66729e4d
--- /dev/null
+++ b/src/imports/nativestyle/qstyle/windows/qdrawutil.cpp
@@ -0,0 +1,1143 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWidgets module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qdrawutil.h"
+#include "qbitmap.h"
+#include "qpixmapcache.h"
+#include "qpainter.h"
+#include "qpalette.h"
+#include <private/qpaintengineex_p.h>
+#include <qvarlengtharray.h>
+#include <qmath.h>
+#include <private/qhexstring_p.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace {
+class PainterStateGuard {
+    Q_DISABLE_COPY_MOVE(PainterStateGuard)
+public:
+    explicit PainterStateGuard(QPainter *p) : m_painter(p) {}
+    ~PainterStateGuard()
+    {
+        for ( ; m_level > 0; --m_level)
+            m_painter->restore();
+    }
+
+    void save()
+    {
+        m_painter->save();
+        ++m_level;
+    }
+
+    void restore()
+    {
+        m_painter->restore();
+        --m_level;
+    }
+
+private:
+    QPainter *m_painter;
+    int m_level= 0;
+};
+} // namespace
+
+/*!
+    \headerfile <qdrawutil.h>
+    \title Drawing Utility Functions
+
+    \sa QPainter
+*/
+
+/*!
+    \fn void qDrawShadeLine(QPainter *painter, int x1, int y1, int x2, int y2,
+                     const QPalette &palette, bool sunken,
+                     int lineWidth, int midLineWidth)
+    \relates <qdrawutil.h>
+
+    Draws a horizontal (\a y1 == \a y2) or vertical (\a x1 == \a x2)
+    shaded line using the given \a painter.  Note that nothing is
+    drawn if \a y1 != \a y2 and \a x1 != \a x2 (i.e. the line is
+    neither horizontal nor vertical).
+
+    The provided \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors).  The given \a lineWidth
+    specifies the line width for each of the lines; it is not the
+    total line width. The given \a midLineWidth specifies the width of
+    a middle line drawn in the QPalette::mid() color.
+
+    The line appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style().  Use the drawing functions in QStyle to
+    make widgets that follow the current GUI style.
+
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded line:
+
+    \snippet code/src_gui_painting_qdrawutil.cpp 0
+
+    \sa qDrawShadeRect(), qDrawShadePanel(), QStyle
+*/
+
+void qDrawShadeLine(QPainter *p, int x1, int y1, int x2, int y2,
+                     const QPalette &pal, bool sunken,
+                     int lineWidth, int midLineWidth)
+{
+    if (Q_UNLIKELY(!p || lineWidth < 0 || midLineWidth < 0)) {
+        qWarning("qDrawShadeLine: Invalid parameters");
+        return;
+    }
+    int tlw = lineWidth*2 + midLineWidth;        // total line width
+    QPen oldPen = p->pen();                        // save pen
+    if (sunken)
+        p->setPen(pal.color(QPalette::Dark));
+    else
+        p->setPen(pal.light().color());
+    QPolygon a;
+    int i;
+    if (y1 == y2) {                                // horizontal line
+        int y = y1 - tlw/2;
+        if (x1 > x2) {                        // swap x1 and x2
+            int t = x1;
+            x1 = x2;
+            x2 = t;
+        }
+        x2--;
+        for (i=0; i<lineWidth; i++) {                // draw top shadow
+            a.setPoints(3, x1+i, y+tlw-1-i,
+                         x1+i, y+i,
+                         x2-i, y+i);
+            p->drawPolyline(a);
+        }
+        if (midLineWidth > 0) {
+            p->setPen(pal.mid().color());
+            for (i=0; i<midLineWidth; i++)        // draw lines in the middle
+                p->drawLine(x1+lineWidth, y+lineWidth+i,
+                             x2-lineWidth, y+lineWidth+i);
+        }
+        if (sunken)
+            p->setPen(pal.light().color());
+        else
+            p->setPen(pal.dark().color());
+        for (i=0; i<lineWidth; i++) {                // draw bottom shadow
+            a.setPoints(3, x1+i, y+tlw-i-1,
+                         x2-i, y+tlw-i-1,
+                         x2-i, y+i+1);
+            p->drawPolyline(a);
+        }
+    }
+    else if (x1 == x2) {                        // vertical line
+        int x = x1 - tlw/2;
+        if (y1 > y2) {                        // swap y1 and y2
+            int t = y1;
+            y1 = y2;
+            y2 = t;
+        }
+        y2--;
+        for (i=0; i<lineWidth; i++) {                // draw left shadow
+            a.setPoints(3, x+i, y2,
+                         x+i, y1+i,
+                         x+tlw-1, y1+i);
+            p->drawPolyline(a);
+        }
+        if (midLineWidth > 0) {
+            p->setPen(pal.mid().color());
+            for (i=0; i<midLineWidth; i++)        // draw lines in the middle
+                p->drawLine(x+lineWidth+i, y1+lineWidth, x+lineWidth+i, y2);
+        }
+        if (sunken)
+            p->setPen(pal.light().color());
+        else
+            p->setPen(pal.dark().color());
+        for (i=0; i<lineWidth; i++) {                // draw right shadow
+            a.setPoints(3, x+lineWidth, y2-i,
+                         x+tlw-i-1, y2-i,
+                         x+tlw-i-1, y1+lineWidth);
+            p->drawPolyline(a);
+        }
+    }
+    p->setPen(oldPen);
+}
+
+/*!
+    \fn void qDrawShadeRect(QPainter *painter, int x, int y, int width, int height,
+                     const QPalette &palette, bool sunken,
+                     int lineWidth, int midLineWidth,
+                     const QBrush *fill)
+    \relates <qdrawutil.h>
+
+    Draws the shaded rectangle beginning at (\a x, \a y) with the
+    given \a width and \a height using the provided \a painter.
+
+    The provide \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors.  The given \a lineWidth
+    specifies the line width for each of the lines; it is not the
+    total line width.  The \a midLineWidth specifies the width of a
+    middle line drawn in the QPalette::mid() color.  The rectangle's
+    interior is filled with the \a fill brush unless \a fill is \nullptr.
+
+    The rectangle appears sunken if \a sunken is true, otherwise
+    raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded rectangle:
+
+    \snippet code/src_gui_painting_qdrawutil.cpp 1
+
+    \sa qDrawShadeLine(), qDrawShadePanel(), qDrawPlainRect(), QStyle
+*/
+
+void qDrawShadeRect(QPainter *p, int x, int y, int w, int h,
+                     const QPalette &pal, bool sunken,
+                     int lineWidth, int midLineWidth,
+                     const QBrush *fill)
+{
+    if (w == 0 || h == 0)
+        return;
+    if (Q_UNLIKELY(w < 0 || h < 0 || lineWidth < 0 || midLineWidth < 0)) {
+        qWarning("qDrawShadeRect: Invalid parameters");
+        return;
+    }
+
+    PainterStateGuard painterGuard(p);
+    const qreal devicePixelRatio = p->device()->devicePixelRatioF();
+    if (!qFuzzyCompare(devicePixelRatio, qreal(1))) {
+        painterGuard.save();
+        const qreal inverseScale = qreal(1) / devicePixelRatio;
+        p->scale(inverseScale, inverseScale);
+        x = qRound(devicePixelRatio * x);
+        y = qRound(devicePixelRatio * y);
+        w = qRound(devicePixelRatio * w);
+        h = qRound(devicePixelRatio * h);
+        lineWidth = qRound(devicePixelRatio * lineWidth);
+        midLineWidth = qRound(devicePixelRatio * midLineWidth);
+    }
+
+    QPen oldPen = p->pen();
+    if (sunken)
+        p->setPen(pal.dark().color());
+    else
+        p->setPen(pal.light().color());
+    int x1=x, y1=y, x2=x+w-1, y2=y+h-1;
+
+    if (lineWidth == 1 && midLineWidth == 0) {// standard shade rectangle
+        p->drawRect(x1, y1, w-2, h-2);
+        if (sunken)
+            p->setPen(pal.light().color());
+        else
+            p->setPen(pal.dark().color());
+        QLineF lines[4] = { QLineF(x1+1, y1+1, x2-2, y1+1),
+                            QLineF(x1+1, y1+2, x1+1, y2-2),
+                            QLineF(x1, y2, x2, y2),
+                            QLineF(x2,y1, x2,y2-1) };
+        p->drawLines(lines, 4);              // draw bottom/right lines
+    } else {                                        // more complicated
+        int m = lineWidth+midLineWidth;
+        int i, j=0, k=m;
+        for (i=0; i<lineWidth; i++) {                // draw top shadow
+            QLineF lines[4] = { QLineF(x1+i, y2-i, x1+i, y1+i),
+                                QLineF(x1+i, y1+i, x2-i, y1+i),
+                                QLineF(x1+k, y2-k, x2-k, y2-k),
+                                QLineF(x2-k, y2-k, x2-k, y1+k) };
+            p->drawLines(lines, 4);
+            k++;
+        }
+        p->setPen(pal.mid().color());
+        j = lineWidth*2;
+        for (i=0; i<midLineWidth; i++) {        // draw lines in the middle
+            p->drawRect(x1+lineWidth+i, y1+lineWidth+i, w-j-1, h-j-1);
+            j += 2;
+        }
+        if (sunken)
+            p->setPen(pal.light().color());
+        else
+            p->setPen(pal.dark().color());
+        k = m;
+        for (i=0; i<lineWidth; i++) {                // draw bottom shadow
+            QLineF lines[4] = { QLineF(x1+1+i, y2-i, x2-i, y2-i),
+                                QLineF(x2-i, y2-i, x2-i, y1+i+1),
+                                QLineF(x1+k, y2-k, x1+k, y1+k),
+                                QLineF(x1+k, y1+k, x2-k, y1+k) };
+            p->drawLines(lines, 4);
+            k++;
+        }
+    }
+    if (fill) {
+        QBrush oldBrush = p->brush();
+        int tlw = lineWidth + midLineWidth;
+        p->setPen(Qt::NoPen);
+        p->setBrush(*fill);
+        p->drawRect(x+tlw, y+tlw, w-2*tlw, h-2*tlw);
+        p->setBrush(oldBrush);
+    }
+    p->setPen(oldPen);                        // restore pen
+}
+
+
+/*!
+    \fn void qDrawShadePanel(QPainter *painter, int x, int y, int width, int height,
+                      const QPalette &palette, bool sunken,
+                      int lineWidth, const QBrush *fill)
+    \relates <qdrawutil.h>
+
+    Draws the shaded panel beginning at (\a x, \a y) with the given \a
+    width and \a height using the provided \a painter and the given \a
+    lineWidth.
+
+    The given \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors).  The panel's interior is filled
+    with the \a fill brush unless \a fill is \nullptr.
+
+    The panel appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded panel:
+
+    \snippet code/src_gui_painting_qdrawutil.cpp 2
+
+    \sa qDrawWinPanel(), qDrawShadeLine(), qDrawShadeRect(), QStyle
+*/
+
+void qDrawShadePanel(QPainter *p, int x, int y, int w, int h,
+                      const QPalette &pal, bool sunken,
+                      int lineWidth, const QBrush *fill)
+{
+    if (w == 0 || h == 0)
+        return;
+    if (Q_UNLIKELY(w < 0 || h < 0 || lineWidth < 0)) {
+        qWarning("qDrawShadePanel: Invalid parameters");
+    }
+
+    PainterStateGuard painterGuard(p);
+    const qreal devicePixelRatio = p->device()->devicePixelRatioF();
+    if (!qFuzzyCompare(devicePixelRatio, qreal(1))) {
+        painterGuard.save();
+        const qreal inverseScale = qreal(1) / devicePixelRatio;
+        p->scale(inverseScale, inverseScale);
+        x = qRound(devicePixelRatio * x);
+        y = qRound(devicePixelRatio * y);
+        w = qRound(devicePixelRatio * w);
+        h = qRound(devicePixelRatio * h);
+        lineWidth = qRound(devicePixelRatio * lineWidth);
+    }
+
+    QColor shade = pal.dark().color();
+    QColor light = pal.light().color();
+    if (fill) {
+        if (fill->color() == shade)
+            shade = pal.shadow().color();
+        if (fill->color() == light)
+            light = pal.midlight().color();
+    }
+    QPen oldPen = p->pen();                        // save pen
+    QVector<QLineF> lines;
+    lines.reserve(2*lineWidth);
+
+    if (sunken)
+        p->setPen(shade);
+    else
+        p->setPen(light);
+    int x1, y1, x2, y2;
+    int i;
+    x1 = x;
+    y1 = y2 = y;
+    x2 = x+w-2;
+    for (i=0; i<lineWidth; i++) {                // top shadow
+        lines << QLineF(x1, y1++, x2--, y2++);
+    }
+    x2 = x1;
+    y1 = y+h-2;
+    for (i=0; i<lineWidth; i++) {                // left shado
+        lines << QLineF(x1++, y1, x2++, y2--);
+    }
+    p->drawLines(lines);
+    lines.clear();
+    if (sunken)
+        p->setPen(light);
+    else
+        p->setPen(shade);
+    x1 = x;
+    y1 = y2 = y+h-1;
+    x2 = x+w-1;
+    for (i=0; i<lineWidth; i++) {                // bottom shadow
+        lines << QLineF(x1++, y1--, x2, y2--);
+    }
+    x1 = x2;
+    y1 = y;
+    y2 = y+h-lineWidth-1;
+    for (i=0; i<lineWidth; i++) {                // right shadow
+        lines << QLineF(x1--, y1++, x2--, y2);
+    }
+    p->drawLines(lines);
+    if (fill)                                // fill with fill color
+        p->fillRect(x+lineWidth, y+lineWidth, w-lineWidth*2, h-lineWidth*2, *fill);
+    p->setPen(oldPen);                        // restore pen
+}
+
+
+/*!
+  \internal
+  This function draws a rectangle with two pixel line width.
+  It is called from qDrawWinButton() and qDrawWinPanel().
+
+  c1..c4 and fill are used:
+
+    1 1 1 1 1 2
+    1 3 3 3 4 2
+    1 3 F F 4 2
+    1 3 F F 4 2
+    1 4 4 4 4 2
+    2 2 2 2 2 2
+*/
+
+static void qDrawWinShades(QPainter *p,
+                           int x, int y, int w, int h,
+                           const QColor &c1, const QColor &c2,
+                           const QColor &c3, const QColor &c4,
+                           const QBrush *fill)
+{
+    if (w < 2 || h < 2)                        // can't do anything with that
+        return;
+
+    PainterStateGuard painterGuard(p);
+    const qreal devicePixelRatio = p->device()->devicePixelRatioF();
+    if (!qFuzzyCompare(devicePixelRatio, qreal(1))) {
+        painterGuard.save();
+        const qreal inverseScale = qreal(1) / devicePixelRatio;
+        p->scale(inverseScale, inverseScale);
+        x = qRound(devicePixelRatio * x);
+        y = qRound(devicePixelRatio * y);
+        w = qRound(devicePixelRatio * w);
+        h = qRound(devicePixelRatio * h);
+    }
+
+    QPen oldPen = p->pen();
+    QPoint a[3] = { QPoint(x, y+h-2), QPoint(x, y), QPoint(x+w-2, y) };
+    p->setPen(c1);
+    p->drawPolyline(a, 3);
+    QPoint b[3] = { QPoint(x, y+h-1), QPoint(x+w-1, y+h-1), QPoint(x+w-1, y) };
+    p->setPen(c2);
+    p->drawPolyline(b, 3);
+    if (w > 4 && h > 4) {
+        QPoint c[3] = { QPoint(x+1, y+h-3), QPoint(x+1, y+1), QPoint(x+w-3, y+1) };
+        p->setPen(c3);
+        p->drawPolyline(c, 3);
+        QPoint d[3] = { QPoint(x+1, y+h-2), QPoint(x+w-2, y+h-2), QPoint(x+w-2, y+1) };
+        p->setPen(c4);
+        p->drawPolyline(d, 3);
+        if (fill)
+            p->fillRect(QRect(x+2, y+2, w-4, h-4), *fill);
+    }
+    p->setPen(oldPen);
+}
+
+
+/*!
+    \fn void qDrawWinButton(QPainter *painter, int x, int y, int width, int height,
+                     const QPalette &palette, bool sunken,
+                     const QBrush *fill)
+    \relates <qdrawutil.h>
+
+    Draws the Windows-style button specified by the given point (\a x,
+    \a y}, \a width and \a height using the provided \a painter with a
+    line width of 2 pixels. The button's interior is filled with the
+    \a{fill} brush unless \a fill is \nullptr.
+
+    The given \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors).
+
+    The button appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style()-> Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    \sa qDrawWinPanel(), QStyle
+*/
+
+void qDrawWinButton(QPainter *p, int x, int y, int w, int h,
+                     const QPalette &pal, bool sunken,
+                     const QBrush *fill)
+{
+    if (sunken)
+        qDrawWinShades(p, x, y, w, h,
+                       pal.shadow().color(), pal.light().color(), pal.dark().color(),
+                       pal.button().color(), fill);
+    else
+        qDrawWinShades(p, x, y, w, h,
+                       pal.light().color(), pal.shadow().color(), pal.button().color(),
+                       pal.dark().color(), fill);
+}
+
+/*!
+    \fn void qDrawWinPanel(QPainter *painter, int x, int y, int width, int height,
+                    const QPalette &palette, bool        sunken,
+                    const QBrush *fill)
+    \relates <qdrawutil.h>
+
+    Draws the Windows-style panel specified by the given point(\a x,
+    \a y), \a width and \a height using the provided \a painter with a
+    line width of 2 pixels. The button's interior is filled with the
+    \a fill brush unless \a fill is \nullptr.
+
+    The given \a palette specifies the shading colors.  The panel
+    appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded panel:
+
+    \snippet code/src_gui_painting_qdrawutil.cpp 3
+
+    \sa qDrawShadePanel(), qDrawWinButton(), QStyle
+*/
+
+void qDrawWinPanel(QPainter *p, int x, int y, int w, int h,
+                    const QPalette &pal, bool        sunken,
+                    const QBrush *fill)
+{
+    if (sunken)
+        qDrawWinShades(p, x, y, w, h,
+                        pal.dark().color(), pal.light().color(), pal.shadow().color(),
+                       pal.midlight().color(), fill);
+    else
+        qDrawWinShades(p, x, y, w, h,
+                       pal.light().color(), pal.shadow().color(), pal.midlight().color(),
+                       pal.dark().color(), fill);
+}
+
+/*!
+    \fn void qDrawPlainRect(QPainter *painter, int x, int y, int width, int height, const QColor &lineColor,
+                     int lineWidth, const QBrush *fill)
+    \relates <qdrawutil.h>
+
+    Draws the plain rectangle beginning at (\a x, \a y) with the given
+    \a width and \a height, using the specified \a painter, \a lineColor
+    and \a lineWidth. The rectangle's interior is filled with the \a
+    fill brush unless \a fill is \nullptr.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a plain rectangle:
+
+    \snippet code/src_gui_painting_qdrawutil.cpp 4
+
+    \sa qDrawShadeRect(), QStyle
+*/
+
+void qDrawPlainRect(QPainter *p, int x, int y, int w, int h, const QColor &c,
+                     int lineWidth, const QBrush *fill)
+{
+    if (w == 0 || h == 0)
+        return;
+    if (Q_UNLIKELY(w < 0 || h < 0 || lineWidth < 0)) {
+        qWarning("qDrawPlainRect: Invalid parameters");
+    }
+
+    PainterStateGuard painterGuard(p);
+    const qreal devicePixelRatio = p->device()->devicePixelRatioF();
+    if (!qFuzzyCompare(devicePixelRatio, qreal(1))) {
+        painterGuard.save();
+        const qreal inverseScale = qreal(1) / devicePixelRatio;
+        p->scale(inverseScale, inverseScale);
+        x = qRound(devicePixelRatio * x);
+        y = qRound(devicePixelRatio * y);
+        w = qRound(devicePixelRatio * w);
+        h = qRound(devicePixelRatio * h);
+        lineWidth = qRound(devicePixelRatio * lineWidth);
+    }
+
+    QPen   oldPen   = p->pen();
+    QBrush oldBrush = p->brush();
+    p->setPen(c);
+    p->setBrush(Qt::NoBrush);
+    for (int i=0; i<lineWidth; i++)
+        p->drawRect(x+i, y+i, w-i*2 - 1, h-i*2 - 1);
+    if (fill) {                                // fill with fill color
+        p->setPen(Qt::NoPen);
+        p->setBrush(*fill);
+        p->drawRect(x+lineWidth, y+lineWidth, w-lineWidth*2, h-lineWidth*2);
+    }
+    p->setPen(oldPen);
+    p->setBrush(oldBrush);
+}
+
+/*****************************************************************************
+  Overloaded functions.
+ *****************************************************************************/
+
+/*!
+    \fn void qDrawShadeLine(QPainter *painter, const QPoint &p1, const QPoint &p2,
+             const QPalette &palette, bool sunken, int lineWidth, int midLineWidth)
+    \relates <qdrawutil.h>
+    \overload
+
+    Draws a horizontal or vertical shaded line between \a p1 and \a p2
+    using the given \a painter.  Note that nothing is drawn if the line
+    between the points would be neither horizontal nor vertical.
+
+    The provided \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors).  The given \a lineWidth
+    specifies the line width for each of the lines; it is not the
+    total line width. The given \a midLineWidth specifies the width of
+    a middle line drawn in the QPalette::mid() color.
+
+    The line appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style().  Use the drawing functions in QStyle to
+    make widgets that follow the current GUI style.
+
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded line:
+
+    \snippet code/src_gui_painting_qdrawutil.cpp 5
+
+    \sa qDrawShadeRect(), qDrawShadePanel(), QStyle
+*/
+
+void qDrawShadeLine(QPainter *p, const QPoint &p1, const QPoint &p2,
+                     const QPalette &pal, bool sunken,
+                     int lineWidth, int midLineWidth)
+{
+    qDrawShadeLine(p, p1.x(), p1.y(), p2.x(), p2.y(), pal, sunken,
+                    lineWidth, midLineWidth);
+}
+
+/*!
+    \fn void qDrawShadeRect(QPainter *painter, const QRect &rect, const QPalette &palette,
+             bool sunken, int lineWidth, int midLineWidth, const QBrush *fill)
+    \relates <qdrawutil.h>
+    \overload
+
+    Draws the shaded rectangle specified by \a rect using the given \a painter.
+
+    The provide \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors.  The given \a lineWidth
+    specifies the line width for each of the lines; it is not the
+    total line width.  The \a midLineWidth specifies the width of a
+    middle line drawn in the QPalette::mid() color.  The rectangle's
+    interior is filled with the \a fill brush unless \a fill is \nullptr.
+
+    The rectangle appears sunken if \a sunken is true, otherwise
+    raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded rectangle:
+
+    \snippet code/src_gui_painting_qdrawutil.cpp 6
+
+    \sa qDrawShadeLine(), qDrawShadePanel(), qDrawPlainRect(), QStyle
+*/
+
+void qDrawShadeRect(QPainter *p, const QRect &r,
+                     const QPalette &pal, bool sunken,
+                     int lineWidth, int midLineWidth,
+                     const QBrush *fill)
+{
+    qDrawShadeRect(p, r.x(), r.y(), r.width(), r.height(), pal, sunken,
+                    lineWidth, midLineWidth, fill);
+}
+
+/*!
+    \fn void qDrawShadePanel(QPainter *painter, const QRect &rect, const QPalette &palette,
+             bool sunken, int lineWidth, const QBrush *fill)
+    \relates <qdrawutil.h>
+    \overload
+
+    Draws the shaded panel at the rectangle specified by \a rect using the
+    given \a painter and the given \a lineWidth.
+
+    The given \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors).  The panel's interior is filled
+    with the \a fill brush unless \a fill is \nullptr.
+
+    The panel appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded panel:
+
+    \snippet code/src_gui_painting_qdrawutil.cpp 7
+
+    \sa qDrawWinPanel(), qDrawShadeLine(), qDrawShadeRect(), QStyle
+*/
+
+void qDrawShadePanel(QPainter *p, const QRect &r,
+                      const QPalette &pal, bool sunken,
+                      int lineWidth, const QBrush *fill)
+{
+    qDrawShadePanel(p, r.x(), r.y(), r.width(), r.height(), pal, sunken,
+                     lineWidth, fill);
+}
+
+/*!
+    \fn void qDrawWinButton(QPainter *painter, const QRect &rect, const QPalette &palette,
+             bool sunken, const QBrush *fill)
+    \relates <qdrawutil.h>
+    \overload
+
+    Draws the Windows-style button at the rectangle specified by \a rect using
+    the given \a painter with a line width of 2 pixels. The button's interior
+    is filled with the \a{fill} brush unless \a fill is \nullptr.
+
+    The given \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors).
+
+    The button appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style()-> Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    \sa qDrawWinPanel(), QStyle
+*/
+
+void qDrawWinButton(QPainter *p, const QRect &r,
+                     const QPalette &pal, bool sunken, const QBrush *fill)
+{
+    qDrawWinButton(p, r.x(), r.y(), r.width(), r.height(), pal, sunken, fill);
+}
+
+/*!
+    \fn void qDrawWinPanel(QPainter *painter, const QRect &rect, const QPalette &palette,
+             bool sunken, const QBrush *fill)
+    \overload
+
+    Draws the Windows-style panel at the rectangle specified by \a rect using
+    the given \a painter with a line width of 2 pixels. The button's interior
+    is filled with the \a fill brush unless \a fill is \nullptr.
+
+    The given \a palette specifies the shading colors.  The panel
+    appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded panel:
+
+    \snippet code/src_gui_painting_qdrawutil.cpp 8
+
+    \sa qDrawShadePanel(), qDrawWinButton(), QStyle
+*/
+
+void qDrawWinPanel(QPainter *p, const QRect &r,
+                    const QPalette &pal, bool sunken, const QBrush *fill)
+{
+    qDrawWinPanel(p, r.x(), r.y(), r.width(), r.height(), pal, sunken, fill);
+}
+
+/*!
+    \fn void qDrawPlainRect(QPainter *painter, const QRect &rect, const QColor &lineColor, int lineWidth, const QBrush *fill)
+    \relates <qdrawutil.h>
+    \overload
+
+    Draws the plain rectangle specified by \a rect using the given \a painter,
+    \a lineColor and \a lineWidth. The rectangle's interior is filled with the
+    \a fill brush unless \a fill is \nullptr.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a plain rectangle:
+
+    \snippet code/src_gui_painting_qdrawutil.cpp 9
+
+    \sa qDrawShadeRect(), QStyle
+*/
+
+void qDrawPlainRect(QPainter *p, const QRect &r, const QColor &c,
+                     int lineWidth, const QBrush *fill)
+{
+    qDrawPlainRect(p, r.x(), r.y(), r.width(), r.height(), c,
+                    lineWidth, fill);
+}
+
+
+/*!
+    \class QTileRules
+    \since 4.6
+
+    \inmodule QtWidgets
+
+    \brief The QTileRules class provides the rules used to draw a
+    pixmap or image split into nine segments.
+
+    Spliiting is similar to \l{http://www.w3.org/TR/css3-background/}{CSS3 border-images}.
+
+    \sa Qt::TileRule, QMargins
+*/
+
+/*! \fn QTileRules::QTileRules(Qt::TileRule horizontalRule, Qt::TileRule verticalRule)
+  Constructs a QTileRules with the given \a horizontalRule and
+  \a verticalRule.
+ */
+
+/*! \fn QTileRules::QTileRules(Qt::TileRule rule)
+  Constructs a QTileRules with the given \a rule used for both
+  the horizontal rule and the vertical rule.
+ */
+
+/*!
+    \fn void qDrawBorderPixmap(QPainter *painter, const QRect &target, const QMargins &margins, const QPixmap &pixmap)
+    \relates <qdrawutil.h>
+    \since 4.6
+
+    \brief The qDrawBorderPixmap function is for drawing a pixmap into
+    the margins of a rectangle.
+
+    Draws the given \a pixmap into the given \a target rectangle, using the
+    given \a painter. The pixmap will be split into nine segments and drawn
+    according to the \a margins structure.
+*/
+
+typedef QVarLengthArray<QPainter::PixmapFragment, 16> QPixmapFragmentsArray;
+
+/*!
+    \since 4.6
+
+    Draws the indicated \a sourceRect rectangle from the given \a pixmap into
+    the given \a targetRect rectangle, using the given \a painter. The pixmap
+    will be split into nine segments according to the given \a targetMargins
+    and \a sourceMargins structures. Finally, the pixmap will be drawn
+    according to the given \a rules.
+
+    This function is used to draw a scaled pixmap, similar to
+    \l{http://www.w3.org/TR/css3-background/}{CSS3 border-images}
+
+    \sa Qt::TileRule, QTileRules, QMargins
+*/
+
+void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargins &targetMargins,
+                       const QPixmap &pixmap, const QRect &sourceRect,const QMargins &sourceMargins,
+                       const QTileRules &rules
+#ifndef Q_CLANG_QDOC
+                       , QDrawBorderPixmap::DrawingHints hints
+#endif
+                       )
+{
+    QPainter::PixmapFragment d;
+    d.opacity = 1.0;
+    d.rotation = 0.0;
+
+    QPixmapFragmentsArray opaqueData;
+    QPixmapFragmentsArray translucentData;
+
+    // source center
+    const int sourceCenterTop = sourceRect.top() + sourceMargins.top();
+    const int sourceCenterLeft = sourceRect.left() + sourceMargins.left();
+    const int sourceCenterBottom = sourceRect.bottom() - sourceMargins.bottom() + 1;
+    const int sourceCenterRight = sourceRect.right() - sourceMargins.right() + 1;
+    const int sourceCenterWidth = sourceCenterRight - sourceCenterLeft;
+    const int sourceCenterHeight = sourceCenterBottom - sourceCenterTop;
+    // target center
+    const int targetCenterTop = targetRect.top() + targetMargins.top();
+    const int targetCenterLeft = targetRect.left() + targetMargins.left();
+    const int targetCenterBottom = targetRect.bottom() - targetMargins.bottom() + 1;
+    const int targetCenterRight = targetRect.right() - targetMargins.right() + 1;
+    const int targetCenterWidth = targetCenterRight - targetCenterLeft;
+    const int targetCenterHeight = targetCenterBottom - targetCenterTop;
+
+    QVarLengthArray<qreal, 16> xTarget; // x-coordinates of target rectangles
+    QVarLengthArray<qreal, 16> yTarget; // y-coordinates of target rectangles
+
+    int columns = 3;
+    int rows = 3;
+    if (rules.horizontal != Qt::StretchTile && sourceCenterWidth != 0)
+        columns = qMax(3, 2 + qCeil(targetCenterWidth / qreal(sourceCenterWidth)));
+    if (rules.vertical != Qt::StretchTile && sourceCenterHeight != 0)
+        rows = qMax(3, 2 + qCeil(targetCenterHeight / qreal(sourceCenterHeight)));
+
+    xTarget.resize(columns + 1);
+    yTarget.resize(rows + 1);
+
+    bool oldAA = painter->testRenderHint(QPainter::Antialiasing);
+    if (painter->paintEngine()->type() != QPaintEngine::OpenGL
+        && painter->paintEngine()->type() != QPaintEngine::OpenGL2
+        && oldAA && painter->combinedTransform().type() != QTransform::TxNone) {
+        painter->setRenderHint(QPainter::Antialiasing, false);
+    }
+
+    xTarget[0] = targetRect.left();
+    xTarget[1] = targetCenterLeft;
+    xTarget[columns - 1] = targetCenterRight;
+    xTarget[columns] = targetRect.left() + targetRect.width();
+
+    yTarget[0] = targetRect.top();
+    yTarget[1] = targetCenterTop;
+    yTarget[rows - 1] = targetCenterBottom;
+    yTarget[rows] = targetRect.top() + targetRect.height();
+
+    qreal dx = targetCenterWidth;
+    qreal dy = targetCenterHeight;
+
+    switch (rules.horizontal) {
+    case Qt::StretchTile:
+        dx = targetCenterWidth;
+        break;
+    case Qt::RepeatTile:
+        dx = sourceCenterWidth;
+        break;
+    case Qt::RoundTile:
+        dx = targetCenterWidth / qreal(columns - 2);
+        break;
+    }
+
+    for (int i = 2; i < columns - 1; ++i)
+        xTarget[i] = xTarget[i - 1] + dx;
+
+    switch (rules.vertical) {
+    case Qt::StretchTile:
+        dy = targetCenterHeight;
+        break;
+    case Qt::RepeatTile:
+        dy = sourceCenterHeight;
+        break;
+    case Qt::RoundTile:
+        dy = targetCenterHeight / qreal(rows - 2);
+        break;
+    }
+
+    for (int i = 2; i < rows - 1; ++i)
+        yTarget[i] = yTarget[i - 1] + dy;
+
+    // corners
+    if (targetMargins.top() > 0 && targetMargins.left() > 0 && sourceMargins.top() > 0 && sourceMargins.left() > 0) { // top left
+        d.x = (0.5 * (xTarget[1] + xTarget[0]));
+        d.y = (0.5 * (yTarget[1] + yTarget[0]));
+        d.sourceLeft = sourceRect.left();
+        d.sourceTop = sourceRect.top();
+        d.width = sourceMargins.left();
+        d.height = sourceMargins.top();
+        d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.width;
+        d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.height;
+        if (hints & QDrawBorderPixmap::OpaqueTopLeft)
+            opaqueData.append(d);
+        else
+            translucentData.append(d);
+    }
+    if (targetMargins.top() > 0 && targetMargins.right() > 0 && sourceMargins.top() > 0 && sourceMargins.right() > 0) { // top right
+        d.x = (0.5 * (xTarget[columns] + xTarget[columns - 1]));
+        d.y = (0.5 * (yTarget[1] + yTarget[0]));
+        d.sourceLeft = sourceCenterRight;
+        d.sourceTop = sourceRect.top();
+        d.width = sourceMargins.right();
+        d.height = sourceMargins.top();
+        d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.width;
+        d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.height;
+        if (hints & QDrawBorderPixmap::OpaqueTopRight)
+            opaqueData.append(d);
+        else
+            translucentData.append(d);
+    }
+    if (targetMargins.bottom() > 0 && targetMargins.left() > 0 && sourceMargins.bottom() > 0 && sourceMargins.left() > 0) { // bottom left
+        d.x = (0.5 * (xTarget[1] + xTarget[0]));
+        d.y =(0.5 * (yTarget[rows] + yTarget[rows - 1]));
+        d.sourceLeft = sourceRect.left();
+        d.sourceTop = sourceCenterBottom;
+        d.width = sourceMargins.left();
+        d.height = sourceMargins.bottom();
+        d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.width;
+        d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.height;
+        if (hints & QDrawBorderPixmap::OpaqueBottomLeft)
+            opaqueData.append(d);
+        else
+            translucentData.append(d);
+    }
+    if (targetMargins.bottom() > 0 && targetMargins.right() > 0 && sourceMargins.bottom() > 0 && sourceMargins.right() > 0) { // bottom right
+        d.x = (0.5 * (xTarget[columns] + xTarget[columns - 1]));
+        d.y = (0.5 * (yTarget[rows] + yTarget[rows - 1]));
+        d.sourceLeft = sourceCenterRight;
+        d.sourceTop = sourceCenterBottom;
+        d.width = sourceMargins.right();
+        d.height = sourceMargins.bottom();
+        d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.width;
+        d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.height;
+        if (hints & QDrawBorderPixmap::OpaqueBottomRight)
+            opaqueData.append(d);
+        else
+            translucentData.append(d);
+    }
+
+    // horizontal edges
+    if (targetCenterWidth > 0 && sourceCenterWidth > 0) {
+        if (targetMargins.top() > 0 && sourceMargins.top() > 0) { // top
+            QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueTop ? opaqueData : translucentData;
+            d.sourceLeft = sourceCenterLeft;
+            d.sourceTop = sourceRect.top();
+            d.width = sourceCenterWidth;
+            d.height = sourceMargins.top();
+            d.y = (0.5 * (yTarget[1] + yTarget[0]));
+            d.scaleX = dx / d.width;
+            d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.height;
+            for (int i = 1; i < columns - 1; ++i) {
+                d.x = (0.5 * (xTarget[i + 1] + xTarget[i]));
+                data.append(d);
+            }
+            if (rules.horizontal == Qt::RepeatTile)
+                data[data.size() - 1].width = ((xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX);
+        }
+        if (targetMargins.bottom() > 0 && sourceMargins.bottom() > 0) { // bottom
+            QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueBottom ? opaqueData : translucentData;
+            d.sourceLeft = sourceCenterLeft;
+            d.sourceTop = sourceCenterBottom;
+            d.width = sourceCenterWidth;
+            d.height = sourceMargins.bottom();
+            d.y = (0.5 * (yTarget[rows] + yTarget[rows - 1]));
+            d.scaleX = dx / d.width;
+            d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.height;
+            for (int i = 1; i < columns - 1; ++i) {
+                d.x = (0.5 * (xTarget[i + 1] + xTarget[i]));
+                data.append(d);
+            }
+            if (rules.horizontal == Qt::RepeatTile)
+                data[data.size() - 1].width = ((xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX);
+        }
+    }
+
+    // vertical edges
+    if (targetCenterHeight > 0 && sourceCenterHeight > 0) {
+        if (targetMargins.left() > 0 && sourceMargins.left() > 0) { // left
+            QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueLeft ? opaqueData : translucentData;
+            d.sourceLeft = sourceRect.left();
+            d.sourceTop = sourceCenterTop;
+            d.width = sourceMargins.left();
+            d.height = sourceCenterHeight;
+            d.x = (0.5 * (xTarget[1] + xTarget[0]));
+            d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.width;
+            d.scaleY = dy / d.height;
+            for (int i = 1; i < rows - 1; ++i) {
+                d.y = (0.5 * (yTarget[i + 1] + yTarget[i]));
+                data.append(d);
+            }
+            if (rules.vertical == Qt::RepeatTile)
+                data[data.size() - 1].height = ((yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY);
+        }
+        if (targetMargins.right() > 0 && sourceMargins.right() > 0) { // right
+            QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueRight ? opaqueData : translucentData;
+            d.sourceLeft = sourceCenterRight;
+            d.sourceTop = sourceCenterTop;
+            d.width = sourceMargins.right();
+            d.height = sourceCenterHeight;
+            d.x = (0.5 * (xTarget[columns] + xTarget[columns - 1]));
+            d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.width;
+            d.scaleY = dy / d.height;
+            for (int i = 1; i < rows - 1; ++i) {
+                d.y = (0.5 * (yTarget[i + 1] + yTarget[i]));
+                data.append(d);
+            }
+            if (rules.vertical == Qt::RepeatTile)
+                data[data.size() - 1].height = ((yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY);
+        }
+    }
+
+    // center
+    if (targetCenterWidth > 0 && targetCenterHeight > 0 && sourceCenterWidth > 0 && sourceCenterHeight > 0) {
+        QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueCenter ? opaqueData : translucentData;
+        d.sourceLeft = sourceCenterLeft;
+        d.sourceTop = sourceCenterTop;
+        d.width = sourceCenterWidth;
+        d.height = sourceCenterHeight;
+        d.scaleX = dx / d.width;
+        d.scaleY = dy / d.height;
+
+        qreal repeatWidth = (xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX;
+        qreal repeatHeight = (yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY;
+
+        for (int j = 1; j < rows - 1; ++j) {
+            d.y = (0.5 * (yTarget[j + 1] + yTarget[j]));
+            for (int i = 1; i < columns - 1; ++i) {
+                d.x = (0.5 * (xTarget[i + 1] + xTarget[i]));
+                data.append(d);
+            }
+            if (rules.horizontal == Qt::RepeatTile)
+                data[data.size() - 1].width = repeatWidth;
+        }
+        if (rules.vertical == Qt::RepeatTile) {
+            for (int i = 1; i < columns - 1; ++i)
+                data[data.size() - i].height = repeatHeight;
+        }
+    }
+
+    if (opaqueData.size())
+        painter->drawPixmapFragments(opaqueData.data(), opaqueData.size(), pixmap, QPainter::OpaqueHint);
+    if (translucentData.size())
+        painter->drawPixmapFragments(translucentData.data(), translucentData.size(), pixmap);
+
+    if (oldAA)
+        painter->setRenderHint(QPainter::Antialiasing, true);
+}
+
+QT_END_NAMESPACE
diff --git a/src/imports/nativestyle/qstyle/windows/qdrawutil.h b/src/imports/nativestyle/qstyle/windows/qdrawutil.h
new file mode 100644
index 00000000..1cba7f95
--- /dev/null
+++ b/src/imports/nativestyle/qstyle/windows/qdrawutil.h
@@ -0,0 +1,168 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWidgets module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDRAWUTIL_H
+#define QDRAWUTIL_H
+
+#include <QtCore/qnamespace.h>
+#include <QtCore/qstring.h> // char*->QString conversion
+#include <QtCore/qmargins.h>
+#include <QtGui/qpixmap.h>
+QT_BEGIN_NAMESPACE
+
+
+class QPainter;
+class QPalette;
+class QPoint;
+class QColor;
+class QBrush;
+class QRect;
+
+//
+// Standard shade drawing
+//
+
+void qDrawShadeLine(QPainter *p, int x1, int y1, int x2, int y2,
+                              const QPalette &pal, bool sunken = true,
+                              int lineWidth = 1, int midLineWidth = 0);
+
+void qDrawShadeLine(QPainter *p, const QPoint &p1, const QPoint &p2,
+                              const QPalette &pal, bool sunken = true,
+                              int lineWidth = 1, int midLineWidth = 0);
+
+void qDrawShadeRect(QPainter *p, int x, int y, int w, int h,
+                              const QPalette &pal, bool sunken = false,
+                              int lineWidth = 1, int midLineWidth = 0,
+                              const QBrush *fill = nullptr);
+
+void qDrawShadeRect(QPainter *p, const QRect &r,
+                              const QPalette &pal, bool sunken = false,
+                              int lineWidth = 1, int midLineWidth = 0,
+                              const QBrush *fill = nullptr);
+
+void qDrawShadePanel(QPainter *p, int x, int y, int w, int h,
+                               const QPalette &pal, bool sunken = false,
+                               int lineWidth = 1, const QBrush *fill = nullptr);
+
+void qDrawShadePanel(QPainter *p, const QRect &r,
+                               const QPalette &pal, bool sunken = false,
+                               int lineWidth = 1, const QBrush *fill = nullptr);
+
+void qDrawWinButton(QPainter *p, int x, int y, int w, int h,
+                              const QPalette &pal, bool sunken = false,
+                              const QBrush *fill = nullptr);
+
+void qDrawWinButton(QPainter *p, const QRect &r,
+                              const QPalette &pal, bool sunken = false,
+                              const QBrush *fill = nullptr);
+
+void qDrawWinPanel(QPainter *p, int x, int y, int w, int h,
+                              const QPalette &pal, bool sunken = false,
+                             const QBrush *fill = nullptr);
+
+void qDrawWinPanel(QPainter *p, const QRect &r,
+                              const QPalette &pal, bool sunken = false,
+                             const QBrush *fill = nullptr);
+
+void qDrawPlainRect(QPainter *p, int x, int y, int w, int h, const QColor &,
+                              int lineWidth = 1, const QBrush *fill = nullptr);
+
+void qDrawPlainRect(QPainter *p, const QRect &r, const QColor &,
+                              int lineWidth = 1, const QBrush *fill = nullptr);
+
+
+
+struct QTileRules
+{
+    inline QTileRules(Qt::TileRule horizontalRule, Qt::TileRule verticalRule)
+            : horizontal(horizontalRule), vertical(verticalRule) {}
+    inline QTileRules(Qt::TileRule rule = Qt::StretchTile)
+            : horizontal(rule), vertical(rule) {}
+    Qt::TileRule horizontal;
+    Qt::TileRule vertical;
+};
+
+#ifndef Q_CLANG_QDOC
+// For internal use only.
+namespace QDrawBorderPixmap
+{
+    enum DrawingHint
+    {
+        OpaqueTopLeft = 0x0001,
+        OpaqueTop = 0x0002,
+        OpaqueTopRight = 0x0004,
+        OpaqueLeft = 0x0008,
+        OpaqueCenter = 0x0010,
+        OpaqueRight = 0x0020,
+        OpaqueBottomLeft = 0x0040,
+        OpaqueBottom = 0x0080,
+        OpaqueBottomRight = 0x0100,
+        OpaqueCorners = OpaqueTopLeft | OpaqueTopRight | OpaqueBottomLeft | OpaqueBottomRight,
+        OpaqueEdges = OpaqueTop | OpaqueLeft | OpaqueRight | OpaqueBottom,
+        OpaqueFrame = OpaqueCorners | OpaqueEdges,
+        OpaqueAll = OpaqueCenter | OpaqueFrame
+    };
+
+    Q_DECLARE_FLAGS(DrawingHints, DrawingHint)
+}
+#endif
+
+void qDrawBorderPixmap(QPainter *painter,
+                                    const QRect &targetRect,
+                                    const QMargins &targetMargins,
+                                    const QPixmap &pixmap,
+                                    const QRect &sourceRect,
+                                    const QMargins &sourceMargins,
+                                    const QTileRules &rules = QTileRules()
+#ifndef Q_CLANG_QDOC
+                                    , QDrawBorderPixmap::DrawingHints hints = QDrawBorderPixmap::DrawingHints()
+#endif
+                                    );
+
+inline void qDrawBorderPixmap(QPainter *painter,
+                                           const QRect &target,
+                                           const QMargins &margins,
+                                           const QPixmap &pixmap)
+{
+    qDrawBorderPixmap(painter, target, margins, pixmap, pixmap.rect(), margins);
+}
+
+QT_END_NAMESPACE
+
+#endif // QDRAWUTIL_H
diff --git a/src/imports/nativestyle/qstyle/windows/qquickwindowsstyle.cpp b/src/imports/nativestyle/qstyle/windows/qquickwindowsstyle.cpp
new file mode 100644
index 00000000..22a90139
--- /dev/null
+++ b/src/imports/nativestyle/qstyle/windows/qquickwindowsstyle.cpp
@@ -0,0 +1,2387 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWidgets module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquickwindowsstyle_p.h"
+#include "qquickwindowsstyle_p_p.h"
+#include "qquickstyleoption.h"
+#include "qquickstylehelper_p.h"
+
+#include <QtGui/qbitmap.h>
+#include "qdrawutil.h"
+//#include "qdrawutil.h" // for now
+#include <QtGui/qevent.h>
+#include <QtGui/qpaintengine.h>
+#include <QtGui/qpainter.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qfile.h>
+#include <QtCore/qtextstream.h>
+#include <QtGui/qpixmapcache.h>
+#include <private/qmath_p.h>
+#include <qmath.h>
+#include <QtGui/qpainterpath.h>
+#include <QtGui/qscreen.h>
+#include <QtGui/qwindow.h>
+#include <qpa/qplatformtheme.h>
+#include <qpa/qplatformscreen.h>
+#include <private/qguiapplication_p.h>
+#include <private/qhighdpiscaling_p.h>
+#include <qpa/qplatformnativeinterface.h>
+
+#if 0 && QT_CONFIG(animation)
+//#include <private/qstyleanimation_p.h>
+#endif
+
+#include <algorithm>
+
+QT_BEGIN_NAMESPACE
+
+namespace QQC2 {
+
+#if defined(Q_OS_WIN)
+
+QT_BEGIN_INCLUDE_NAMESPACE
+#include "qt_windows.h"
+QT_END_INCLUDE_NAMESPACE
+#  ifndef COLOR_GRADIENTACTIVECAPTION
+#    define COLOR_GRADIENTACTIVECAPTION     27
+#  endif
+#  ifndef COLOR_GRADIENTINACTIVECAPTION
+#    define COLOR_GRADIENTINACTIVECAPTION   28
+#  endif
+
+Q_GUI_EXPORT HICON qt_pixmapToWinHICON(const QPixmap &);
+#endif //Q_OS_WIN
+
+QT_BEGIN_INCLUDE_NAMESPACE
+#include <limits.h>
+QT_END_INCLUDE_NAMESPACE
+
+enum QSliderDirection { SlUp, SlDown, SlLeft, SlRight };
+
+/*
+    \internal
+*/
+
+QWindowsStylePrivate::QWindowsStylePrivate() = default;
+
+qreal QWindowsStylePrivate::appDevicePixelRatio()
+{
+    return qApp->devicePixelRatio();
+}
+
+bool QWindowsStylePrivate::isDarkMode()
+{
+    bool result = false;
+#ifdef Q_OS_WIN
+    // Windows only: Return whether dark mode style support is desired and
+    // dark mode is in effect.
+    if (auto ni = QGuiApplication::platformNativeInterface()) {
+        const QVariant darkModeStyleP = ni->property("darkModeStyle");
+        result = darkModeStyleP.type() == QVariant::Bool
+                 && darkModeStyleP.value<bool>()
+                 && ni->property("darkMode").value<bool>();
+    }
+#endif
+    return result;
+}
+
+//  ###TODO SH_UnderlineShortcut
+#if 0
+// Returns \c true if the toplevel parent of \a widget has seen the Alt-key
+bool QWindowsStylePrivate::hasSeenAlt(const QWidget *widget) const
+{
+    widget = widget->window();
+    return seenAlt.contains(widget);
+}
+
+/*!
+    \reimp
+*/
+bool QWindowsStyle::eventFilter(QObject *o, QEvent *e)
+{
+    // Records Alt- and Focus events
+//    if (!o->isWidgetType())
+        return QObject::eventFilter(o, e);
+    QWidget *widget = qobject_cast<QWidget*>(o);
+    Q_D(QWindowsStyle);
+    switch (e->type()) {
+    case QEvent::KeyPress:
+        if (static_cast<QKeyEvent *>(e)->key() == Qt::Key_Alt) {
+            widget = widget->window();
+
+            // Alt has been pressed - find all widgets that care
+            QList<QWidget *> l = widget->findChildren<QWidget *>();
+            auto ignorable = [](QWidget *w) {
+                return w->isWindow() || !w->isVisible()
+                        || w->style()->styleHint(SH_UnderlineShortcut, nullptr, w);
+            };
+            l.erase(std::remove_if (l.begin(), l.end(), ignorable), l.end());
+            // Update states before repainting
+            d->seenAlt.append(widget);
+            d->alt_down = true;
+
+            // Repaint all relevant widgets
+            for (int pos = 0; pos < l.size(); ++pos)
+                l.at(pos)->update();
+        }
+        break;
+    case QEvent::KeyRelease:
+        if (static_cast<QKeyEvent*>(e)->key() == Qt::Key_Alt) {
+            widget = widget->window();
+
+            // Update state and repaint the menu bars.
+            d->alt_down = false;
+#if 0 && QT_CONFIG(menubar)
+            QList<QMenuBar *> l = widget->findChildren<QMenuBar *>();
+            for (int i = 0; i < l.size(); ++i)
+                l.at(i)->update();
+#endif
+        }
+        break;
+    case QEvent::Close:
+        // Reset widget when closing
+        d->seenAlt.removeAll(widget);
+        d->seenAlt.removeAll(widget->window());
+        break;
+    default:
+        break;
+    }
+    return QCommonStyle::eventFilter(o, e);
+}
+#endif
+
+/*!
+    \class QWindowsStyle
+    \brief The QWindowsStyle class provides a Microsoft Windows-like look and feel.
+
+    \ingroup appearance
+    \inmodule QtWidgets
+    \internal
+
+    This style is Qt's default GUI style on Windows.
+
+    \image qwindowsstyle.png
+    \sa QWindowsVistaStyle, QMacStyle, QFusionStyle
+*/
+
+/*!
+    Constructs a QWindowsStyle object.
+*/
+QWindowsStyle::QWindowsStyle() : QCommonStyle(*new QWindowsStylePrivate)
+{
+}
+
+/*!
+    \internal
+
+    Constructs a QWindowsStyle object.
+*/
+QWindowsStyle::QWindowsStyle(QWindowsStylePrivate &dd) : QCommonStyle(dd)
+{
+}
+
+
+/*! Destroys the QWindowsStyle object. */
+QWindowsStyle::~QWindowsStyle()
+{
+}
+
+#ifdef Q_OS_WIN
+static inline QRgb colorref2qrgb(COLORREF col)
+{
+    return qRgb(GetRValue(col), GetGValue(col), GetBValue(col));
+}
+#endif
+#if 0
+/*! \reimp */
+void QWindowsStyle::polish(QApplication *app)
+{
+    QCommonStyle::polish(app);
+    QWindowsStylePrivate *d = const_cast<QWindowsStylePrivate*>(d_func());
+    // We only need the overhead when shortcuts are sometimes hidden
+    if (!proxy()->styleHint(SH_UnderlineShortcut, nullptr) && app)
+        app->installEventFilter(this);
+
+    const auto &palette = QGuiApplication::palette();
+    d->activeGradientCaptionColor = palette.highlight().color();
+    d->activeCaptionColor = d->activeGradientCaptionColor;
+    d->inactiveGradientCaptionColor = palette.dark().color();
+    d->inactiveCaptionColor = d->inactiveGradientCaptionColor;
+    d->inactiveCaptionText = palette.window().color();
+
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINRT) //fetch native title bar colors
+    if (app->desktopSettingsAware()){
+        DWORD activeCaption = GetSysColor(COLOR_ACTIVECAPTION);
+        DWORD gradientActiveCaption = GetSysColor(COLOR_GRADIENTACTIVECAPTION);
+        DWORD inactiveCaption = GetSysColor(COLOR_INACTIVECAPTION);
+        DWORD gradientInactiveCaption = GetSysColor(COLOR_GRADIENTINACTIVECAPTION);
+        DWORD inactiveCaptionText = GetSysColor(COLOR_INACTIVECAPTIONTEXT);
+        d->activeCaptionColor = colorref2qrgb(activeCaption);
+        d->activeGradientCaptionColor = colorref2qrgb(gradientActiveCaption);
+        d->inactiveCaptionColor = colorref2qrgb(inactiveCaption);
+        d->inactiveGradientCaptionColor = colorref2qrgb(gradientInactiveCaption);
+        d->inactiveCaptionText = colorref2qrgb(inactiveCaptionText);
+    }
+#endif
+}
+
+/*! \reimp */
+void QWindowsStyle::unpolish(QApplication *app)
+{
+    QCommonStyle::unpolish(app);
+    app->removeEventFilter(this);
+}
+
+/*! \reimp */
+void QWindowsStyle::polish(QWidget *widget)
+{
+    QCommonStyle::polish(widget);
+}
+
+/*! \reimp */
+void QWindowsStyle::unpolish(QWidget *widget)
+{
+    QCommonStyle::unpolish(widget);
+}
+
+/*!
+  \reimp
+*/
+void QWindowsStyle::polish(QPalette &pal)
+{
+    QCommonStyle::polish(pal);
+}
+#endif
+
+int QWindowsStylePrivate::pixelMetricFromSystemDp(QStyle::PixelMetric pm, const QStyleOption *opt)
+{
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINRT)
+    switch (pm) {
+    case QStyle::PM_DockWidgetFrameWidth:
+        return GetSystemMetrics(SM_CXFRAME);
+
+    case QStyle::PM_TitleBarHeight:
+        Q_ASSERT(opt);
+        if (const QStyleOptionTitleBar *tb = qstyleoption_cast<const QStyleOptionTitleBar *>(opt)) {
+            if ((tb->titleBarFlags & Qt::WindowType_Mask) == Qt::Tool) {
+                // MS always use one less than they say
+                return GetSystemMetrics(SM_CYSMCAPTION) - 1;
+            }
+        }
+        return GetSystemMetrics(SM_CYCAPTION) - 1;
+
+    case QStyle::PM_ScrollBarExtent:
+        {
+            NONCLIENTMETRICS ncm;
+            ncm.cbSize = FIELD_OFFSET(NONCLIENTMETRICS, lfMessageFont) + sizeof(LOGFONT);
+            if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0))
+                return qMax(ncm.iScrollHeight, ncm.iScrollWidth);
+        }
+        break;
+
+    case  QStyle::PM_MdiSubWindowFrameWidth:
+        return GetSystemMetrics(SM_CYFRAME);
+
+    default:
+        break;
+    }
+#else // Q_OS_WIN && !Q_OS_WINRT
+    Q_UNUSED(pm);
+    Q_UNUSED(widget);
+#endif
+    return QWindowsStylePrivate::InvalidMetric;
+}
+
+int QWindowsStylePrivate::fixedPixelMetric(QStyle::PixelMetric pm)
+{
+    switch (pm) {
+    case QStyle::PM_ToolBarItemSpacing:
+        return 0;
+    case QStyle::PM_ButtonDefaultIndicator:
+    case QStyle::PM_ButtonShiftHorizontal:
+    case QStyle::PM_ButtonShiftVertical:
+    case QStyle::PM_MenuHMargin:
+    case QStyle::PM_MenuVMargin:
+    case QStyle::PM_ToolBarItemMargin:
+        return 1;
+    case QStyle::PM_DockWidgetSeparatorExtent:
+        return 4;
+#if 0 && QT_CONFIG(tabbar)
+    case QStyle::PM_TabBarTabShiftHorizontal:
+        return 0;
+    case QStyle::PM_TabBarTabShiftVertical:
+        return 2;
+#endif
+
+#if 0 && QT_CONFIG(slider)
+    case QStyle::PM_SliderLength:
+        return 11;
+#endif // QT_CONFIG(slider)
+
+#if 0 && QT_CONFIG(menu)
+    case QStyle::PM_MenuBarHMargin:
+    case QStyle::PM_MenuBarVMargin:
+    case QStyle::PM_MenuBarPanelWidth:
+        return 0;
+    case QStyle::PM_SmallIconSize:
+        return 16;
+    case QStyle::PM_LargeIconSize:
+        return 32;
+    case QStyle::PM_DockWidgetTitleMargin:
+        return 2;
+    case QStyle::PM_DockWidgetTitleBarButtonMargin:
+    case QStyle::PM_DockWidgetFrameWidth:
+        return 4;
+
+#endif // QT_CONFIG(menu)
+    case QStyle::PM_ToolBarHandleExtent:
+        return 10;
+    default:
+        break;
+    }
+    return QWindowsStylePrivate::InvalidMetric;
+}
+
+static QScreen *screenOf(const QWindow *w)
+{
+    if (w) {
+        if (auto screen = w->screen())
+            return screen;
+    }
+    return QGuiApplication::primaryScreen();
+}
+
+// Calculate the overall scale factor to obtain Qt Device Independent
+// Pixels from a native Windows size. Divide by devicePixelRatio
+// and account for secondary screens with differing logical DPI.
+qreal QWindowsStylePrivate::nativeMetricScaleFactor(const QStyleOption *opt)
+{
+    QWindow *win = opt->window;
+    qreal result = qreal(1) / QWindowsStylePrivate::devicePixelRatio(opt);
+    if (QGuiApplicationPrivate::screen_list.size() > 1) {
+        const QScreen *primaryScreen = QGuiApplication::primaryScreen();
+        const QScreen *screen = screenOf(win);
+        if (screen != primaryScreen) {
+            const qreal primaryLogicalDpi = primaryScreen->handle()->logicalDpi().first;
+            const qreal logicalDpi = screen->handle()->logicalDpi().first;
+            if (!qFuzzyCompare(primaryLogicalDpi, logicalDpi))
+                result *= logicalDpi / primaryLogicalDpi;
+        }
+    }
+    return result;
+}
+
+/*!
+  \reimp
+*/
+int QWindowsStyle::pixelMetric(PixelMetric pm, const QStyleOption *opt) const
+{
+    int ret = QWindowsStylePrivate::pixelMetricFromSystemDp(pm, opt);
+    if (ret != QWindowsStylePrivate::InvalidMetric)
+        return qRound(qreal(ret) * QWindowsStylePrivate::nativeMetricScaleFactor(opt));
+
+    ret = QWindowsStylePrivate::fixedPixelMetric(pm);
+    if (ret != QWindowsStylePrivate::InvalidMetric)
+        return int(QStyleHelper::dpiScaled(ret, opt));
+
+    ret = 0;
+
+    switch (pm) {
+    case PM_MaximumDragDistance:
+        ret = QCommonStyle::pixelMetric(PM_MaximumDragDistance);
+        if (ret == -1)
+            ret = 60;
+        break;
+
+#if 0 && QT_CONFIG(slider)
+        // Returns the number of pixels to use for the business part of the
+        // slider (i.e., the non-tickmark portion). The remaining space is shared
+        // equally between the tickmark regions.
+    case PM_SliderControlThickness:
+        if (const QStyleOptionSlider *sl = qstyleoption_cast<const QStyleOptionSlider *>(opt)) {
+            int space = (sl->orientation == Qt::Horizontal) ? sl->rect.height() : sl->rect.width();
+            int ticks = sl->tickPosition;
+            int n = 0;
+            if (ticks & QSlider::TicksAbove)
+                ++n;
+            if (ticks & QSlider::TicksBelow)
+                ++n;
+            if (!n) {
+                ret = space;
+                break;
+            }
+
+            int thick = 6;        // Magic constant to get 5 + 16 + 5
+            if (ticks != QSlider::TicksBothSides && ticks != QSlider::NoTicks)
+                thick += proxy()->pixelMetric(PM_SliderLength, sl, widget) / 4;
+
+            space -= thick;
+            if (space > 0)
+                thick += (space * 2) / (n + 2);
+            ret = thick;
+        }
+        break;
+#endif // QT_CONFIG(slider)
+
+    case PM_IconViewIconSize:
+        ret = proxy()->pixelMetric(PM_LargeIconSize, opt);
+        break;
+
+    case PM_SplitterWidth:
+        ret = int(QStyleHelper::dpiScaled(4, opt));
+        break;
+
+    default:
+        ret = QCommonStyle::pixelMetric(pm, opt);
+        break;
+    }
+
+    return ret;
+}
+
+/*!
+ \reimp
+ */
+QPixmap QWindowsStyle::standardPixmap(StandardPixmap standardPixmap, const QStyleOption *opt) const
+{
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINRT)
+    QPixmap desktopIcon;
+    switch (standardPixmap) {
+    case SP_DriveCDIcon:
+    case SP_DriveDVDIcon:
+    case SP_DriveNetIcon:
+    case SP_DriveHDIcon:
+    case SP_DriveFDIcon:
+    case SP_FileIcon:
+    case SP_FileLinkIcon:
+    case SP_DirLinkIcon:
+    case SP_DirClosedIcon:
+    case SP_DesktopIcon:
+    case SP_ComputerIcon:
+    case SP_DirOpenIcon:
+    case SP_FileDialogNewFolder:
+    case SP_DirHomeIcon:
+    case SP_TrashIcon:
+    case SP_VistaShield:
+        if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) {
+            QPlatformTheme::StandardPixmap sp = static_cast<QPlatformTheme::StandardPixmap>(standardPixmap);
+            desktopIcon = theme->standardPixmap(sp, QSizeF(16, 16));
+        }
+        break;
+    case SP_MessageBoxInformation:
+    case SP_MessageBoxWarning:
+    case SP_MessageBoxCritical:
+    case SP_MessageBoxQuestion:
+        if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) {
+            QPlatformTheme::StandardPixmap sp = static_cast<QPlatformTheme::StandardPixmap>(standardPixmap);
+            desktopIcon = theme->standardPixmap(sp, QSizeF());
+        }
+        break;
+    default:
+        break;
+    }
+    if (!desktopIcon.isNull()) {
+        return desktopIcon;
+    }
+#endif // Q_OS_WIN && !Q_OS_WINRT
+    return QCommonStyle::standardPixmap(standardPixmap, opt);
+}
+
+/*! \reimp */
+int QWindowsStyle::styleHint(StyleHint hint, const QStyleOption *opt,
+                             QStyleHintReturn *returnData) const
+{
+    int ret = 0;
+
+    switch (hint) {
+    case SH_EtchDisabledText:
+        ret = d_func()->isDarkMode() ? 0 : 1;
+        break;
+    case SH_Slider_SnapToValue:
+    case SH_PrintDialog_RightAlignButtons:
+    case SH_FontDialog_SelectAssociatedText:
+    case SH_Menu_AllowActiveAndDisabled:
+    case SH_MenuBar_AltKeyNavigation:
+    case SH_MenuBar_MouseTracking:
+    case SH_Menu_MouseTracking:
+    case SH_ComboBox_ListMouseTracking:
+    case SH_Slider_StopMouseOverSlider:
+    case SH_MainWindow_SpaceBelowMenuBar:
+        ret = 1;
+
+        break;
+    case SH_ItemView_ShowDecorationSelected:
+#if 0 && QT_CONFIG(listview)
+        if (qobject_cast<const QListView*>(widget))
+            ret = 1;
+#endif
+        break;
+    case SH_ItemView_ChangeHighlightOnFocus:
+        ret = 1;
+        break;
+    case SH_ToolBox_SelectedPageTitleBold:
+        ret = 0;
+        break;
+
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINRT) // Option not used on WinRT -> common style
+    case SH_UnderlineShortcut:
+    {
+        ret = 1;
+        BOOL cues = false;
+        SystemParametersInfo(SPI_GETKEYBOARDCUES, 0, &cues, 0);
+        ret = int(cues);
+        // Do nothing if we always paint underlines
+        Q_D(const QWindowsStyle);
+        if (!ret && d) {
+#if 0 && QT_CONFIG(menubar)
+            const QMenuBar *menuBar = qobject_cast<const QMenuBar *>(widget);
+            if (!menuBar && qobject_cast<const QMenu *>(widget)) {
+                QWidget *w = QApplication::activeWindow();
+                if (w && w != widget)
+                    menuBar = w->findChild<QMenuBar *>();
+            }
+            // If we paint a menu bar draw underlines if is in the keyboardState
+            if (menuBar) {
+                if (menuBar->d_func()->keyboardState || d->altDown())
+                    ret = 1;
+                // Otherwise draw underlines if the toplevel widget has seen an alt-press
+            } else
+#endif // QT_CONFIG(menubar)
+//            if (d->hasSeenAlt(widget)) {
+//                ret = 1;
+//            }
+        }
+#ifndef QT_NO_ACCESSIBILITY
+        if (!ret && opt && opt->type == QStyleOption::SO_MenuItem
+            && QStyleHelper::isInstanceOf(opt->styleObject, QAccessible::MenuItem)
+            && opt->styleObject->property("_q_showUnderlined").toBool())
+            ret = 1;
+#endif // QT_NO_ACCESSIBILITY
+        break;
+    }
+#endif // Q_OS_WIN && !Q_OS_WINRT
+    case SH_Menu_SubMenuSloppyCloseTimeout:
+    case SH_Menu_SubMenuPopupDelay: {
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINRT)
+        DWORD delay;
+        if (SystemParametersInfo(SPI_GETMENUSHOWDELAY, 0, &delay, 0))
+            ret = delay;
+        else
+#endif // Q_OS_WIN && !Q_OS_WINRT
+            ret = 400;
+        break;
+    }
+#if 0 && QT_CONFIG(rubberband)
+    case SH_RubberBand_Mask:
+        if (const QStyleOptionRubberBand *rbOpt = qstyleoption_cast<const QStyleOptionRubberBand *>(opt)) {
+            ret = 0;
+            if (rbOpt->shape == QRubberBand::Rectangle) {
+                ret = true;
+                if (QStyleHintReturnMask *mask = qstyleoption_cast<QStyleHintReturnMask*>(returnData)) {
+                    mask->region = opt->rect;
+                    int size = 1;
+                    if (widget && widget->isWindow())
+                        size = 4;
+                    mask->region -= opt->rect.adjusted(size, size, -size, -size);
+                }
+            }
+        }
+        break;
+#endif // QT_CONFIG(rubberband)
+#if 0 && QT_CONFIG(wizard)
+    case SH_WizardStyle:
+        ret = QWizard::ModernStyle;
+        break;
+#endif
+    case SH_ItemView_ArrowKeysNavigateIntoChildren:
+        ret = true;
+        break;
+    case SH_DialogButtonBox_ButtonsHaveIcons:
+        ret = 0;
+        break;
+    default:
+        ret = QCommonStyle::styleHint(hint, opt, returnData);
+        break;
+    }
+    return ret;
+}
+
+/*! \reimp */
+void QWindowsStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *p) const
+{
+    // Used to restore across fallthrough cases. Currently only used in PE_IndicatorCheckBox
+    bool doRestore = false;
+
+    switch (pe) {
+#if 0 && QT_CONFIG(toolbar)
+  case PE_IndicatorToolBarSeparator:
+        {
+            QRect rect = opt->rect;
+            const int margin = 2;
+            QPen oldPen = p->pen();
+            if (opt->state & State_Horizontal){
+                const int offset = rect.width()/2;
+                p->setPen(QPen(opt->palette.dark().color()));
+                p->drawLine(rect.bottomLeft().x() + offset,
+                            rect.bottomLeft().y() - margin,
+                            rect.topLeft().x() + offset,
+                            rect.topLeft().y() + margin);
+                p->setPen(QPen(opt->palette.light().color()));
+                p->drawLine(rect.bottomLeft().x() + offset + 1,
+                            rect.bottomLeft().y() - margin,
+                            rect.topLeft().x() + offset + 1,
+                            rect.topLeft().y() + margin);
+            }
+            else{ //Draw vertical separator
+                const int offset = rect.height()/2;
+                p->setPen(QPen(opt->palette.dark().color()));
+                p->drawLine(rect.topLeft().x() + margin ,
+                            rect.topLeft().y() + offset,
+                            rect.topRight().x() - margin,
+                            rect.topRight().y() + offset);
+                p->setPen(QPen(opt->palette.light().color()));
+                p->drawLine(rect.topLeft().x() + margin ,
+                            rect.topLeft().y() + offset + 1,
+                            rect.topRight().x() - margin,
+                            rect.topRight().y() + offset + 1);
+            }
+            p->setPen(oldPen);
+        }
+        break;
+    case PE_IndicatorToolBarHandle:
+        p->save();
+        p->translate(opt->rect.x(), opt->rect.y());
+        if (opt->state & State_Horizontal) {
+            int x = opt->rect.width() / 2 - 4;
+            if (opt->direction == Qt::RightToLeft)
+                x -= 2;
+            if (opt->rect.height() > 4) {
+                qDrawShadePanel(p, x, 2, 3, opt->rect.height() - 4,
+                                opt->palette, false, 1, nullptr);
+                qDrawShadePanel(p, x + 3, 2, 3, opt->rect.height() - 4,
+                                opt->palette, false, 1, nullptr);
+            }
+        } else {
+            if (opt->rect.width() > 4) {
+                int y = opt->rect.height() / 2 - 4;
+                qDrawShadePanel(p, 2, y, opt->rect.width() - 4, 3,
+                                opt->palette, false, 1, nullptr);
+                qDrawShadePanel(p, 2, y + 3, opt->rect.width() - 4, 3,
+                                opt->palette, false, 1, nullptr);
+            }
+        }
+        p->restore();
+        break;
+
+#endif // QT_CONFIG(toolbar)
+    case PE_FrameButtonTool:
+    case PE_PanelButtonTool: {
+        QPen oldPen = p->pen();
+#if 0 && QT_CONFIG(dockwidget)
+        if (w && w->inherits("QDockWidgetTitleButton")) {
+           if (const QWidget *dw = w->parentWidget())
+                if (dw->isWindow()){
+                    qDrawWinButton(p, opt->rect.adjusted(1, 1, 0, 0), opt->palette, opt->state & (State_Sunken | State_On),
+                           &opt->palette.button());
+
+                    return;
+                }
+        }
+#endif // QT_CONFIG(dockwidget)
+        QBrush fill;
+        bool stippled;
+        bool panel = (pe == PE_PanelButtonTool);
+        if ((!(opt->state & State_Sunken ))
+            && (!(opt->state & State_Enabled)
+                || !(opt->state & State_MouseOver && opt->state & State_AutoRaise))
+            && (opt->state & State_On)) {
+            fill = QBrush(opt->palette.light().color(), Qt::Dense4Pattern);
+            stippled = true;
+        } else {
+            fill = opt->palette.brush(QPalette::Button);
+            stippled = false;
+        }
+
+        if (opt->state & (State_Raised | State_Sunken | State_On)) {
+            if (opt->state & State_AutoRaise) {
+                if (opt->state & (State_Enabled | State_Sunken | State_On)){
+                    if (panel)
+                        qDrawShadePanel(p, opt->rect, opt->palette,
+                                        opt->state & (State_Sunken | State_On), 1, &fill);
+                    else
+                        qDrawShadeRect(p, opt->rect, opt->palette,
+                                       opt->state & (State_Sunken | State_On), 1);
+                }
+                if (stippled) {
+                    p->setPen(opt->palette.button().color());
+                    p->drawRect(opt->rect.adjusted(1,1,-2,-2));
+                }
+            } else {
+                qDrawWinButton(p, opt->rect, opt->palette,
+                               opt->state & (State_Sunken | State_On), panel ? &fill : nullptr);
+            }
+        } else {
+            p->fillRect(opt->rect, fill);
+        }
+        p->setPen(oldPen);
+        break; }
+    case PE_PanelButtonCommand:
+        if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(opt)) {
+            QBrush fill;
+            State flags = opt->state;
+            QPalette pal = opt->palette;
+            QRect r = opt->rect;
+            if (! (flags & State_Sunken) && (flags & State_On))
+                fill = QBrush(pal.light().color(), Qt::Dense4Pattern);
+            else
+                fill = pal.brush(QPalette::Button);
+
+            if (btn->features & QStyleOptionButton::DefaultButton && flags & State_Sunken) {
+                p->setPen(pal.dark().color());
+                p->setBrush(fill);
+                p->drawRect(r.adjusted(0, 0, -1, -1));
+            } else if (flags & (State_Raised | State_On | State_Sunken)) {
+                qDrawWinButton(p, r, pal, flags & (State_Sunken | State_On),
+                               &fill);
+            } else {
+                p->fillRect(r, fill);
+            }
+        }
+        break;
+    case PE_FrameDefaultButton: {
+        QPen oldPen = p->pen();
+        p->setPen(QPen(opt->palette.shadow().color(), 0));
+        QRectF rect = opt->rect;
+        const qreal dpi = QStyleHelper::dpi(opt);
+        const qreal topLevelAdjustment = QStyleHelper::dpiScaled(0.5, dpi);
+        const qreal bottomRightAdjustment = QStyleHelper::dpiScaled(-1.5, dpi);
+        rect.adjust(topLevelAdjustment, topLevelAdjustment,
+                    bottomRightAdjustment, bottomRightAdjustment);
+        p->drawRect(rect);
+        p->setPen(oldPen);
+        break;
+    }
+    case PE_IndicatorCheckBox: {
+        QBrush fill;
+        if (opt->state & State_NoChange)
+            fill = QBrush(opt->palette.base().color(), Qt::Dense4Pattern);
+        else if (opt->state & State_Sunken)
+            fill = opt->palette.button();
+        else if (opt->state & State_Enabled)
+            fill = opt->palette.base();
+        else
+            fill = opt->palette.window();
+        p->save();
+        doRestore = true;
+        qDrawWinPanel(p, opt->rect, opt->palette, true, &fill);
+        if (opt->state & State_NoChange)
+            p->setPen(opt->palette.dark().color());
+        else
+            p->setPen(opt->palette.text().color());
+        }
+        Q_FALLTHROUGH();
+    case PE_IndicatorItemViewItemCheck:
+        if (!doRestore) {
+            p->save();
+            doRestore = true;
+        }
+#if 0 && QT_CONFIG(itemviews)
+        if (pe == PE_IndicatorItemViewItemCheck) {
+            const QStyleOptionViewItem *itemViewOpt = qstyleoption_cast<const QStyleOptionViewItem *>(opt);
+            p->setPen(itemViewOpt
+                      && itemViewOpt->showDecorationSelected
+                      && opt->state & State_Selected
+                        ? opt->palette.highlightedText().color()
+                        : opt->palette.text().color());
+            if (opt->state & State_NoChange)
+                p->setBrush(opt->palette.brush(QPalette::Button));
+            p->drawRect(opt->rect.x() + 1, opt->rect.y() + 1, opt->rect.width() - 2, opt->rect.height() - 2);
+        }
+#endif // QT_CONFIG(itemviews)
+        if (!(opt->state & State_Off)) {
+            QPointF  points[6];
+            qreal scaleh = opt->rect.width() / 12.0;
+            qreal scalev = opt->rect.height() / 12.0;
+            points[0] = { opt->rect.x() + 3.5 * scaleh, opt->rect.y() + 5.5 * scalev };
+            points[1] = { points[0].x(),                points[0].y() + 2 * scalev };
+            points[2] = { points[1].x() + 2 * scaleh,   points[1].y() + 2 * scalev };
+            points[3] = { points[2].x() + 4 * scaleh,   points[2].y() - 4 * scalev };
+            points[4] = { points[3].x(),                points[3].y() - 2 * scalev };
+            points[5] = { points[4].x() - 4 * scaleh,   points[4].y() + 4 * scalev };
+            p->setPen(QPen(opt->palette.text().color(), 0));
+            p->setBrush(opt->palette.text().color());
+            p->drawPolygon(points, 6);
+        }
+        if (doRestore)
+            p->restore();
+        break;
+    case PE_FrameFocusRect:
+        if (const QStyleOptionFocusRect *fropt = qstyleoption_cast<const QStyleOptionFocusRect *>(opt)) {
+            //### check for d->alt_down
+            if (!(fropt->state & State_KeyboardFocusChange) && !proxy()->styleHint(SH_UnderlineShortcut, opt))
+                return;
+            QRect r = opt->rect;
+            p->save();
+            p->setBackgroundMode(Qt::TransparentMode);
+            QColor bg_col = fropt->backgroundColor;
+            if (!bg_col.isValid())
+                bg_col = p->background().color();
+            // Create an "XOR" color.
+            QColor patternCol((bg_col.red() ^ 0xff) & 0xff,
+                              (bg_col.green() ^ 0xff) & 0xff,
+                              (bg_col.blue() ^ 0xff) & 0xff);
+            p->setBrush(QBrush(patternCol, Qt::Dense4Pattern));
+            p->setBrushOrigin(r.topLeft());
+            p->setPen(Qt::NoPen);
+            p->drawRect(r.left(), r.top(), r.width(), 1);    // Top
+            p->drawRect(r.left(), r.bottom(), r.width(), 1); // Bottom
+            p->drawRect(r.left(), r.top(), 1, r.height());   // Left
+            p->drawRect(r.right(), r.top(), 1, r.height());  // Right
+            p->restore();
+        }
+        break;
+    case PE_IndicatorRadioButton:
+        {
+            QRect r = opt->rect;
+            p->save();
+            p->setRenderHint(QPainter::Antialiasing, true);
+
+            QPointF circleCenter = r.center() + QPoint(1, 1);
+            qreal radius = (r.width() + (r.width() + 1) % 2) / 2.0 - 1;
+
+            QPainterPath path1;
+            path1.addEllipse(circleCenter, radius, radius);
+            radius *= 0.85;
+            QPainterPath path2;
+            path2.addEllipse(circleCenter, radius, radius);
+            radius *= 0.85;
+            QPainterPath path3;
+            path3.addEllipse(circleCenter, radius, radius);
+            radius *= 0.5;
+            QPainterPath path4;
+            path4.addEllipse(circleCenter, radius, radius);
+
+            QPolygon topLeftPol, bottomRightPol;
+            topLeftPol.setPoints(3, r.x(), r.y(), r.x(), r.y() + r.height(), r.x() + r.width(), r.y());
+            bottomRightPol.setPoints(3, r.x(), r.y() + r.height(), r.x() + r.width(), r.y() + r.height(), r.x() + r.width(), r.y());
+
+            p->setClipRegion(QRegion(topLeftPol));
+            p->setPen(opt->palette.dark().color());
+            p->setBrush(opt->palette.dark().color());
+            p->drawPath(path1);
+            p->setPen(opt->palette.shadow().color());
+            p->setBrush(opt->palette.shadow().color());
+            p->drawPath(path2);
+
+            p->setClipRegion(QRegion(bottomRightPol));
+            p->setPen(opt->palette.light().color());
+            p->setBrush(opt->palette.light().color());
+            p->drawPath(path1);
+            p->setPen(opt->palette.midlight().color());
+            p->setBrush(opt->palette.midlight().color());
+            p->drawPath(path2);
+
+            QColor fillColor = ((opt->state & State_Sunken) || !(opt->state & State_Enabled)) ?
+                                opt->palette.button().color() : opt->palette.base().color();
+
+            p->setClipping(false);
+            p->setPen(fillColor);
+            p->setBrush(fillColor);
+            p->drawPath(path3);
+
+            if (opt->state & State_On) {
+                p->setPen(opt->palette.text().color());
+                p->setBrush(opt->palette.text());
+                p->drawPath(path4);
+            }
+            p->restore();
+            break;
+        }
+#ifndef QT_NO_FRAME
+    case PE_Frame:
+    case PE_FrameMenu:
+        if (const QStyleOptionFrame *frame = qstyleoption_cast<const QStyleOptionFrame *>(opt)) {
+            if (frame->lineWidth == 2 || pe == PE_Frame) {
+                QPalette popupPal = frame->palette;
+                if (pe == PE_FrameMenu) {
+                    popupPal.setColor(QPalette::Light, frame->palette.window().color());
+                    popupPal.setColor(QPalette::Midlight, frame->palette.light().color());
+                }
+                if (pe == PE_Frame && (frame->state & State_Raised))
+                    qDrawWinButton(p, frame->rect, popupPal, frame->state & State_Sunken);
+                else if (pe == PE_Frame && (frame->state & State_Sunken))
+                {
+                    popupPal.setColor(QPalette::Midlight, frame->palette.window().color());
+                    qDrawWinPanel(p, frame->rect, popupPal, frame->state & State_Sunken);
+                }
+                else
+                    qDrawWinPanel(p, frame->rect, popupPal, frame->state & State_Sunken);
+            } else {
+                QCommonStyle::drawPrimitive(pe, opt, p);
+            }
+        } else {
+            QPalette popupPal = opt->palette;
+            popupPal.setColor(QPalette::Light, opt->palette.window().color());
+            popupPal.setColor(QPalette::Midlight, opt->palette.light().color());
+            qDrawWinPanel(p, opt->rect, popupPal, opt->state & State_Sunken);
+        }
+        break;
+#endif // QT_NO_FRAME
+    case PE_FrameButtonBevel:
+    case PE_PanelButtonBevel: {
+        QBrush fill;
+        bool panel = pe != PE_FrameButtonBevel;
+        p->setBrushOrigin(opt->rect.topLeft());
+        if (!(opt->state & State_Sunken) && (opt->state & State_On))
+            fill = QBrush(opt->palette.light().color(), Qt::Dense4Pattern);
+        else
+            fill = opt->palette.brush(QPalette::Button);
+
+        if (opt->state & (State_Raised | State_On | State_Sunken)) {
+            qDrawWinButton(p, opt->rect, opt->palette, opt->state & (State_Sunken | State_On),
+                           panel ? &fill : nullptr);
+        } else {
+            if (panel)
+                p->fillRect(opt->rect, fill);
+            else
+                p->drawRect(opt->rect);
+        }
+        break; }
+    case PE_FrameWindow: {
+         QPalette popupPal = opt->palette;
+         popupPal.setColor(QPalette::Light, opt->palette.window().color());
+         popupPal.setColor(QPalette::Midlight, opt->palette.light().color());
+         qDrawWinPanel(p, opt->rect, popupPal, opt->state & State_Sunken);
+        break; }
+#if 0 && QT_CONFIG(dockwidget)
+    case PE_IndicatorDockWidgetResizeHandle:
+        break;
+    case PE_FrameDockWidget:
+        if (qstyleoption_cast<const QStyleOptionFrame *>(opt)) {
+            proxy()->drawPrimitive(QStyle::PE_FrameWindow, opt, p, w);
+        }
+    break;
+#endif // QT_CONFIG(dockwidget)
+
+    case PE_FrameStatusBarItem:
+        qDrawShadePanel(p, opt->rect, opt->palette, true, 1, nullptr);
+        break;
+
+    case PE_IndicatorProgressChunk:
+        {
+            bool vertical = false, inverted = false;
+            if (const QStyleOptionProgressBar *pb = qstyleoption_cast<const QStyleOptionProgressBar *>(opt)) {
+                vertical = !(pb->state & QStyle::State_Horizontal);
+                inverted = pb->invertedAppearance;
+            }
+
+            int space = 2;
+            int chunksize = proxy()->pixelMetric(PM_ProgressBarChunkWidth, opt) - space;
+            if (!vertical) {
+                if (opt->rect.width() <= chunksize)
+                    space = 0;
+
+                if (inverted)
+                    p->fillRect(opt->rect.x() + space, opt->rect.y(), opt->rect.width() - space, opt->rect.height(),
+                            opt->palette.brush(QPalette::Highlight));
+                else
+                    p->fillRect(opt->rect.x(), opt->rect.y(), opt->rect.width() - space, opt->rect.height(),
+                                opt->palette.brush(QPalette::Highlight));
+            } else {
+                if (opt->rect.height() <= chunksize)
+                    space = 0;
+
+                if (inverted)
+                    p->fillRect(opt->rect.x(), opt->rect.y(), opt->rect.width(), opt->rect.height() - space,
+                            opt->palette.brush(QPalette::Highlight));
+                else
+                    p->fillRect(opt->rect.x(), opt->rect.y() + space, opt->rect.width(), opt->rect.height() - space,
+                                opt->palette.brush(QPalette::Highlight));
+            }
+        }
+        break;
+
+    case PE_FrameTabWidget: {
+        qDrawWinButton(p, opt->rect, opt->palette, false, nullptr);
+        break;
+    }
+    default:
+        QCommonStyle::drawPrimitive(pe, opt, p);
+    }
+}
+
+/*! \reimp */
+void QWindowsStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPainter *p) const
+{
+    switch (ce) {
+#if 0 && QT_CONFIG(rubberband)
+    case CE_RubberBand:
+        if (qstyleoption_cast<const QStyleOptionRubberBand *>(opt)) {
+            // ### workaround for slow general painter path
+            QPixmap tiledPixmap(16, 16);
+            QPainter pixmapPainter(&tiledPixmap);
+            pixmapPainter.setPen(Qt::NoPen);
+            pixmapPainter.setBrush(Qt::Dense4Pattern);
+            pixmapPainter.setBackground(Qt::white);
+            pixmapPainter.setBackgroundMode(Qt::OpaqueMode);
+            pixmapPainter.drawRect(0, 0, tiledPixmap.width(), tiledPixmap.height());
+            pixmapPainter.end();
+            tiledPixmap = QPixmap::fromImage(tiledPixmap.toImage());
+            p->save();
+            QRect r = opt->rect;
+            QStyleHintReturnMask mask;
+            if (proxy()->styleHint(QStyle::SH_RubberBand_Mask, opt, widget, &mask))
+                p->setClipRegion(mask.region);
+            p->drawTiledPixmap(r.x(), r.y(), r.width(), r.height(), tiledPixmap);
+            p->restore();
+            return;
+        }
+        break;
+#endif // QT_CONFIG(rubberband)
+
+#if 0 && QT_CONFIG(menu) && QT_CONFIG(mainwindow)
+    case CE_MenuBarEmptyArea:
+        if (widget && qobject_cast<const QMainWindow *>(widget->parentWidget())) {
+            p->fillRect(opt->rect, opt->palette.button());
+            QPen oldPen = p->pen();
+            p->setPen(QPen(opt->palette.dark().color()));
+            p->drawLine(opt->rect.bottomLeft(), opt->rect.bottomRight());
+            p->setPen(oldPen);
+        }
+        break;
+#endif
+#if 0 && QT_CONFIG(menu)
+    case CE_MenuItem:
+        if (const QStyleOptionMenuItem *menuitem = qstyleoption_cast<const QStyleOptionMenuItem *>(opt)) {
+            int x, y, w, h;
+            menuitem->rect.getRect(&x, &y, &w, &h);
+            int tab = menuitem->tabWidth;
+            bool dis = !(menuitem->state & State_Enabled);
+            bool checked = menuitem->checkType != QStyleOptionMenuItem::NotCheckable
+                            ? menuitem->checked : false;
+            bool act = menuitem->state & State_Selected;
+
+            // windows always has a check column, regardless whether we have an icon or not
+            int checkcol = qMax<int>(menuitem->maxIconWidth, QWindowsStylePrivate::windowsCheckMarkWidth);
+
+            QBrush fill = menuitem->palette.brush(act ? QPalette::Highlight : QPalette::Button);
+            p->fillRect(menuitem->rect.adjusted(0, 0, -1, 0), fill);
+
+            if (menuitem->menuItemType == QStyleOptionMenuItem::Separator){
+                int yoff = y-1 + h / 2;
+                p->setPen(menuitem->palette.dark().color());
+                p->drawLine(x + 2, yoff, x + w - 4, yoff);
+                p->setPen(menuitem->palette.light().color());
+                p->drawLine(x + 2, yoff + 1, x + w - 4, yoff + 1);
+                return;
+            }
+
+            QRect vCheckRect = visualRect(opt->direction, menuitem->rect, QRect(menuitem->rect.x(), menuitem->rect.y(), checkcol, menuitem->rect.height()));
+            if (!menuitem->icon.isNull() && checked) {
+                if (act) {
+                    qDrawShadePanel(p, vCheckRect,
+                                    menuitem->palette, true, 1,
+                                    &menuitem->palette.brush(QPalette::Button));
+                } else {
+                    QBrush fill(menuitem->palette.light().color(), Qt::Dense4Pattern);
+                    qDrawShadePanel(p, vCheckRect, menuitem->palette, true, 1, &fill);
+                }
+            } else if (!act) {
+                p->fillRect(vCheckRect, menuitem->palette.brush(QPalette::Button));
+            }
+
+            // On Windows Style, if we have a checkable item and an icon we
+            // draw the icon recessed to indicate an item is checked. If we
+            // have no icon, we draw a checkmark instead.
+            if (!menuitem->icon.isNull()) {
+                QIcon::Mode mode = dis ? QIcon::Disabled : QIcon::Normal;
+                if (act && !dis)
+                    mode = QIcon::Active;
+                QPixmap pixmap;
+                if (checked)
+                    pixmap = menuitem->icon.pixmap(proxy()->pixelMetric(PM_SmallIconSize, opt, widget), mode, QIcon::On);
+                else
+                    pixmap = menuitem->icon.pixmap(proxy()->pixelMetric(PM_SmallIconSize, opt, widget), mode);
+                const int pixw = pixmap.width() / pixmap.devicePixelRatio();
+                const int pixh = pixmap.height() / pixmap.devicePixelRatio();
+                QRect pmr(0, 0, pixw, pixh);
+                pmr.moveCenter(vCheckRect.center());
+                p->setPen(menuitem->palette.text().color());
+                p->drawPixmap(pmr.topLeft(), pixmap);
+            } else if (checked) {
+                QStyleOptionMenuItem newMi = *menuitem;
+                newMi.state = State_None;
+                if (!dis)
+                    newMi.state |= State_Enabled;
+                if (act)
+                    newMi.state |= State_On;
+                newMi.rect = visualRect(opt->direction, menuitem->rect, QRect(menuitem->rect.x() + QWindowsStylePrivate::windowsItemFrame,
+                                                                              menuitem->rect.y() + QWindowsStylePrivate::windowsItemFrame,
+                                                                              checkcol - 2 * QWindowsStylePrivate::windowsItemFrame,
+                                                                              menuitem->rect.height() - 2 * QWindowsStylePrivate::windowsItemFrame));
+                proxy()->drawPrimitive(PE_IndicatorMenuCheckMark, &newMi, p, widget);
+            }
+            p->setPen(act ? menuitem->palette.highlightedText().color() : menuitem->palette.buttonText().color());
+
+            QColor discol;
+            if (dis) {
+                discol = menuitem->palette.text().color();
+                p->setPen(discol);
+            }
+
+            int xm = int(QWindowsStylePrivate::windowsItemFrame) + checkcol + int(QWindowsStylePrivate::windowsItemHMargin);
+            int xpos = menuitem->rect.x() + xm;
+            QRect textRect(xpos, y + QWindowsStylePrivate::windowsItemVMargin,
+                           w - xm - QWindowsStylePrivate::windowsRightBorder - tab + 1, h - 2 * QWindowsStylePrivate::windowsItemVMargin);
+            QRect vTextRect = visualRect(opt->direction, menuitem->rect, textRect);
+            QStringRef s(&menuitem->text);
+            if (!s.isEmpty()) {                     // draw text
+                p->save();
+                int t = s.indexOf(QLatin1Char('\t'));
+                int text_flags = Qt::AlignVCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;
+                if (!proxy()->styleHint(SH_UnderlineShortcut, menuitem, widget))
+                    text_flags |= Qt::TextHideMnemonic;
+                text_flags |= Qt::AlignLeft;
+                if (t >= 0) {
+                    QRect vShortcutRect = visualRect(opt->direction, menuitem->rect,
+                        QRect(textRect.topRight(), QPoint(menuitem->rect.right(), textRect.bottom())));
+                    const QString textToDraw = s.mid(t + 1).toString();
+                    if (dis && !act && proxy()->styleHint(SH_EtchDisabledText, opt, widget)) {
+                        p->setPen(menuitem->palette.light().color());
+                        p->drawText(vShortcutRect.adjusted(1, 1, 1, 1), text_flags, textToDraw);
+                        p->setPen(discol);
+                    }
+                    p->drawText(vShortcutRect, text_flags, textToDraw);
+                    s = s.left(t);
+                }
+                QFont font = menuitem->font;
+                if (menuitem->menuItemType == QStyleOptionMenuItem::DefaultItem)
+                    font.setBold(true);
+                p->setFont(font);
+                const QString textToDraw = s.left(t).toString();
+                if (dis && !act && proxy()->styleHint(SH_EtchDisabledText, opt, widget)) {
+                    p->setPen(menuitem->palette.light().color());
+                    p->drawText(vTextRect.adjusted(1, 1, 1, 1), text_flags, textToDraw);
+                    p->setPen(discol);
+                }
+                p->drawText(vTextRect, text_flags, textToDraw);
+                p->restore();
+            }
+            if (menuitem->menuItemType == QStyleOptionMenuItem::SubMenu) {// draw sub menu arrow
+                int dim = (h - 2 * QWindowsStylePrivate::windowsItemFrame) / 2;
+                PrimitiveElement arrow;
+                arrow = (opt->direction == Qt::RightToLeft) ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight;
+                xpos = x + w - QWindowsStylePrivate::windowsArrowHMargin - QWindowsStylePrivate::windowsItemFrame - dim;
+                QRect  vSubMenuRect = visualRect(opt->direction, menuitem->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());
+                proxy()->drawPrimitive(arrow, &newMI, p, widget);
+            }
+
+        }
+        break;
+#endif // QT_CONFIG(menu)
+#if 0 && QT_CONFIG(menubar)
+    case CE_MenuBarItem:
+        if (const QStyleOptionMenuItem *mbi = qstyleoption_cast<const QStyleOptionMenuItem *>(opt)) {
+            bool active = mbi->state & State_Selected;
+            bool hasFocus = mbi->state & State_HasFocus;
+            bool down = mbi->state & State_Sunken;
+            QStyleOptionMenuItem newMbi = *mbi;
+            p->fillRect(mbi->rect, mbi->palette.brush(QPalette::Button));
+            if (active || hasFocus) {
+                QBrush b = mbi->palette.brush(QPalette::Button);
+                if (active && down)
+                    p->setBrushOrigin(p->brushOrigin() + QPoint(1, 1));
+                if (active && hasFocus)
+                    qDrawShadeRect(p, mbi->rect.x(), mbi->rect.y(), mbi->rect.width(),
+                                   mbi->rect.height(), mbi->palette, active && down, 1, 0, &b);
+                if (active && down) {
+                    newMbi.rect.translate(proxy()->pixelMetric(PM_ButtonShiftHorizontal, mbi, widget),
+                                       proxy()->pixelMetric(PM_ButtonShiftVertical, mbi, widget));
+                    p->setBrushOrigin(p->brushOrigin() - QPoint(1, 1));
+                }
+            }
+            QCommonStyle::drawControl(ce, &newMbi, p, widget);
+        }
+        break;
+#endif // QT_CONFIG(menubar)
+#if 0 && QT_CONFIG(tabbar)
+    case CE_TabBarTabShape:
+        if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(opt)) {
+            bool rtlHorTabs = (tab->direction == Qt::RightToLeft
+                               && (tab->shape == QTabBar::RoundedNorth
+                                   || tab->shape == QTabBar::RoundedSouth));
+            bool selected = tab->state & State_Selected;
+            bool lastTab = ((!rtlHorTabs && tab->position == QStyleOptionTab::End)
+                            || (rtlHorTabs
+                                && tab->position == QStyleOptionTab::Beginning));
+            bool firstTab = ((!rtlHorTabs
+                               && tab->position == QStyleOptionTab::Beginning)
+                             || (rtlHorTabs
+                                 && tab->position == QStyleOptionTab::End));
+            bool onlyOne = tab->position == QStyleOptionTab::OnlyOneTab;
+            bool previousSelected =
+                ((!rtlHorTabs
+                  && tab->selectedPosition == QStyleOptionTab::PreviousIsSelected)
+                || (rtlHorTabs
+                    && tab->selectedPosition == QStyleOptionTab::NextIsSelected));
+            bool nextSelected =
+                ((!rtlHorTabs
+                  && tab->selectedPosition == QStyleOptionTab::NextIsSelected)
+                 || (rtlHorTabs
+                     && tab->selectedPosition
+                            == QStyleOptionTab::PreviousIsSelected));
+            int tabBarAlignment = proxy()->styleHint(SH_TabBar_Alignment, tab, widget);
+            bool leftAligned = (!rtlHorTabs && tabBarAlignment == Qt::AlignLeft)
+                                || (rtlHorTabs
+                                    && tabBarAlignment == Qt::AlignRight);
+
+            bool rightAligned = (!rtlHorTabs && tabBarAlignment == Qt::AlignRight)
+                                 || (rtlHorTabs
+                                         && tabBarAlignment == Qt::AlignLeft);
+
+            QColor light = tab->palette.light().color();
+            QColor dark = tab->palette.dark().color();
+            QColor shadow = tab->palette.shadow().color();
+            int borderThinkness = proxy()->pixelMetric(PM_TabBarBaseOverlap, tab, widget);
+            if (selected)
+                borderThinkness /= 2;
+            QRect r2(opt->rect);
+            int x1 = r2.left();
+            int x2 = r2.right();
+            int y1 = r2.top();
+            int y2 = r2.bottom();
+            switch (tab->shape) {
+            default:
+                QCommonStyle::drawControl(ce, tab, p, widget);
+                break;
+            case QTabBar::RoundedNorth: {
+                if (!selected) {
+                    y1 += 2;
+                    x1 += onlyOne || firstTab ? borderThinkness : 0;
+                    x2 -= onlyOne || lastTab ? borderThinkness : 0;
+                }
+
+                p->fillRect(QRect(x1 + 1, y1 + 1, (x2 - x1) - 1, (y2 - y1) - 2), tab->palette.window());
+
+                // Delete border
+                if (selected) {
+                    p->fillRect(QRect(x1,y2-1,x2-x1,1), tab->palette.window());
+                    p->fillRect(QRect(x1,y2,x2-x1,1), tab->palette.window());
+                }
+                // Left
+                if (firstTab || selected || onlyOne || !previousSelected) {
+                    p->setPen(light);
+                    p->drawLine(x1, y1 + 2, x1, y2 - ((onlyOne || firstTab) && selected && leftAligned ? 0 : borderThinkness));
+                    p->drawPoint(x1 + 1, y1 + 1);
+                }
+                // Top
+                {
+                    int beg = x1 + (previousSelected ? 0 : 2);
+                    int end = x2 - (nextSelected ? 0 : 2);
+                    p->setPen(light);
+                    p->drawLine(beg, y1, end, y1);
+                }
+                // Right
+                if (lastTab || selected || onlyOne || !nextSelected) {
+                    p->setPen(shadow);
+                    p->drawLine(x2, y1 + 2, x2, y2 - ((onlyOne || lastTab) && selected && rightAligned ? 0 : borderThinkness));
+                    p->drawPoint(x2 - 1, y1 + 1);
+                    p->setPen(dark);
+                    p->drawLine(x2 - 1, y1 + 2, x2 - 1, y2 - ((onlyOne || lastTab) && selected && rightAligned ? 0 : borderThinkness));
+                }
+                break; }
+            case QTabBar::RoundedSouth: {
+                if (!selected) {
+                    y2 -= 2;
+                    x1 += firstTab ? borderThinkness : 0;
+                    x2 -= lastTab ? borderThinkness : 0;
+                }
+
+                p->fillRect(QRect(x1 + 1, y1 + 2, (x2 - x1) - 1, (y2 - y1) - 1), tab->palette.window());
+
+                // Delete border
+                if (selected) {
+                    p->fillRect(QRect(x1, y1 + 1, (x2 - 1)-x1, 1), tab->palette.window());
+                    p->fillRect(QRect(x1, y1, (x2 - 1)-x1, 1), tab->palette.window());
+                }
+                // Left
+                if (firstTab || selected || onlyOne || !previousSelected) {
+                    p->setPen(light);
+                    p->drawLine(x1, y2 - 2, x1, y1 + ((onlyOne || firstTab) && selected && leftAligned ? 0 : borderThinkness));
+                    p->drawPoint(x1 + 1, y2 - 1);
+                }
+                // Bottom
+                {
+                    int beg = x1 + (previousSelected ? 0 : 2);
+                    int end = x2 - (nextSelected ? 0 : 2);
+                    p->setPen(shadow);
+                    p->drawLine(beg, y2, end, y2);
+                    p->setPen(dark);
+                    p->drawLine(beg, y2 - 1, end, y2 - 1);
+                }
+                // Right
+                if (lastTab || selected || onlyOne || !nextSelected) {
+                    p->setPen(shadow);
+                    p->drawLine(x2, y2 - 2, x2, y1 + ((onlyOne || lastTab) && selected && rightAligned ? 0 : borderThinkness));
+                    p->drawPoint(x2 - 1, y2 - 1);
+                    p->setPen(dark);
+                    p->drawLine(x2 - 1, y2 - 2, x2 - 1, y1 + ((onlyOne || lastTab) && selected && rightAligned ? 0 : borderThinkness));
+                }
+                break; }
+            case QTabBar::RoundedWest: {
+                if (!selected) {
+                    x1 += 2;
+                    y1 += firstTab ? borderThinkness : 0;
+                    y2 -= lastTab ? borderThinkness : 0;
+                }
+
+                p->fillRect(QRect(x1 + 1, y1 + 1, (x2 - x1) - 2, (y2 - y1) - 1), tab->palette.window());
+
+                // Delete border
+                if (selected) {
+                    p->fillRect(QRect(x2 - 1, y1, 1, y2-y1), tab->palette.window());
+                    p->fillRect(QRect(x2, y1, 1, y2-y1), tab->palette.window());
+                }
+                // Top
+                if (firstTab || selected || onlyOne || !previousSelected) {
+                    p->setPen(light);
+                    p->drawLine(x1 + 2, y1, x2 - ((onlyOne || firstTab) && selected && leftAligned ? 0 : borderThinkness), y1);
+                    p->drawPoint(x1 + 1, y1 + 1);
+                }
+                // Left
+                {
+                    int beg = y1 + (previousSelected ? 0 : 2);
+                    int end = y2 - (nextSelected ? 0 : 2);
+                    p->setPen(light);
+                    p->drawLine(x1, beg, x1, end);
+                }
+                // Bottom
+                if (lastTab || selected || onlyOne || !nextSelected) {
+                    p->setPen(shadow);
+                    p->drawLine(x1 + 3, y2, x2 - ((onlyOne || lastTab) && selected && rightAligned ? 0 : borderThinkness), y2);
+                    p->drawPoint(x1 + 2, y2 - 1);
+                    p->setPen(dark);
+                    p->drawLine(x1 + 3, y2 - 1, x2 - ((onlyOne || lastTab) && selected && rightAligned ? 0 : borderThinkness), y2 - 1);
+                    p->drawPoint(x1 + 1, y2 - 1);
+                    p->drawPoint(x1 + 2, y2);
+                }
+                break; }
+            case QTabBar::RoundedEast: {
+                if (!selected) {
+                    x2 -= 2;
+                    y1 += firstTab ? borderThinkness : 0;
+                    y2 -= lastTab ? borderThinkness : 0;
+                }
+
+                p->fillRect(QRect(x1 + 2, y1 + 1, (x2 - x1) - 1, (y2 - y1) - 1), tab->palette.window());
+
+                // Delete border
+                if (selected) {
+                    p->fillRect(QRect(x1 + 1, y1, 1, (y2 - 1)-y1),tab->palette.window());
+                    p->fillRect(QRect(x1, y1, 1, (y2-1)-y1), tab->palette.window());
+                }
+                // Top
+                if (firstTab || selected || onlyOne || !previousSelected) {
+                    p->setPen(light);
+                    p->drawLine(x2 - 2, y1, x1 + ((onlyOne || firstTab) && selected && leftAligned ? 0 : borderThinkness), y1);
+                    p->drawPoint(x2 - 1, y1 + 1);
+                }
+                // Right
+                {
+                    int beg = y1 + (previousSelected ? 0 : 2);
+                    int end = y2 - (nextSelected ? 0 : 2);
+                    p->setPen(shadow);
+                    p->drawLine(x2, beg, x2, end);
+                    p->setPen(dark);
+                    p->drawLine(x2 - 1, beg, x2 - 1, end);
+                }
+                // Bottom
+                if (lastTab || selected || onlyOne || !nextSelected) {
+                    p->setPen(shadow);
+                    p->drawLine(x2 - 2, y2, x1 + ((onlyOne || lastTab) && selected && rightAligned ? 0 : borderThinkness), y2);
+                    p->drawPoint(x2 - 1, y2 - 1);
+                    p->setPen(dark);
+                    p->drawLine(x2 - 2, y2 - 1, x1 + ((onlyOne || lastTab) && selected && rightAligned ? 0 : borderThinkness), y2 - 1);
+                }
+                break; }
+            }
+        }
+        break;
+#endif // QT_CONFIG(tabbar)
+    case CE_ToolBoxTabShape:
+        qDrawShadePanel(p, opt->rect, opt->palette,
+                        opt->state & (State_Sunken | State_On), 1,
+                        &opt->palette.brush(QPalette::Button));
+        break;
+#if 0 && QT_CONFIG(splitter)
+    case CE_Splitter:
+        p->eraseRect(opt->rect);
+        break;
+#endif // QT_CONFIG(splitter)
+#if 0 && QT_CONFIG(scrollbar)
+    case CE_ScrollBarSubLine:
+    case CE_ScrollBarAddLine: {
+        if ((opt->state & State_Sunken)) {
+            p->setPen(opt->palette.dark().color());
+            p->setBrush(opt->palette.brush(QPalette::Button));
+            p->drawRect(opt->rect.adjusted(0, 0, -1, -1));
+        } else {
+            QStyleOption buttonOpt = *opt;
+            if (!(buttonOpt.state & State_Sunken))
+                buttonOpt.state |= State_Raised;
+            QPalette pal(opt->palette);
+            pal.setColor(QPalette::Button, opt->palette.light().color());
+            pal.setColor(QPalette::Light, opt->palette.button().color());
+            qDrawWinButton(p, opt->rect, pal, opt->state & (State_Sunken | State_On),
+                           &opt->palette.brush(QPalette::Button));
+        }
+        PrimitiveElement arrow;
+        if (opt->state & State_Horizontal) {
+            if (ce == CE_ScrollBarAddLine)
+                arrow = opt->direction == Qt::LeftToRight ? PE_IndicatorArrowRight : PE_IndicatorArrowLeft;
+            else
+                arrow = opt->direction == Qt::LeftToRight ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight;
+        } else {
+            if (ce == CE_ScrollBarAddLine)
+                arrow = PE_IndicatorArrowDown;
+            else
+                arrow = PE_IndicatorArrowUp;
+        }
+        QStyleOption arrowOpt = *opt;
+        arrowOpt.rect = opt->rect.adjusted(4, 4, -4, -4);
+        proxy()->drawPrimitive(arrow, &arrowOpt, p, widget);
+        break; }
+    case CE_ScrollBarAddPage:
+    case CE_ScrollBarSubPage: {
+            QBrush br;
+            QBrush bg = p->background();
+            Qt::BGMode bg_mode = p->backgroundMode();
+            p->setPen(Qt::NoPen);
+            p->setBackgroundMode(Qt::OpaqueMode);
+
+            if (opt->state & State_Sunken) {
+                br = QBrush(opt->palette.shadow().color(), Qt::Dense4Pattern);
+                p->setBackground(opt->palette.dark().color());
+                p->setBrush(br);
+            } else {
+                const QBrush paletteBrush = opt->palette.brush(QPalette::Light);
+                if (paletteBrush.style() == Qt::TexturePattern) {
+                    if (qHasPixmapTexture(paletteBrush))
+                        br = QBrush(paletteBrush.texture());
+                    else
+                        br = QBrush(paletteBrush.textureImage());
+                } else
+                    br = QBrush(opt->palette.light().color(), Qt::Dense4Pattern);
+                p->setBackground(opt->palette.window().color());
+                p->setBrush(br);
+            }
+            p->drawRect(opt->rect);
+            p->setBackground(bg);
+            p->setBackgroundMode(bg_mode);
+            break; }
+    case CE_ScrollBarSlider:
+        if (!(opt->state & State_Enabled)) {
+            QBrush br;
+            const QBrush paletteBrush = opt->palette.brush(QPalette::Light);
+            if (paletteBrush.style() == Qt::TexturePattern) {
+                if (qHasPixmapTexture(paletteBrush))
+                    br = QBrush(paletteBrush.texture());
+                else
+                    br = QBrush(paletteBrush.textureImage());
+            } else
+                br = QBrush(opt->palette.light().color(), Qt::Dense4Pattern);
+            p->setPen(Qt::NoPen);
+            p->setBrush(br);
+            p->setBackgroundMode(Qt::OpaqueMode);
+            p->drawRect(opt->rect);
+        } else {
+            QStyleOptionButton buttonOpt;
+            buttonOpt.QStyleOption::operator=(*opt);
+            buttonOpt.state = State_Enabled | State_Raised;
+
+            QPalette pal(opt->palette);
+            pal.setColor(QPalette::Button, opt->palette.light().color());
+            pal.setColor(QPalette::Light, opt->palette.button().color());
+            qDrawWinButton(p, opt->rect, pal, false, &opt->palette.brush(QPalette::Button));
+        }
+        break;
+#endif // QT_CONFIG(scrollbar)
+    case CE_HeaderSection: {
+        QBrush fill;
+        if (opt->state & State_On)
+            fill = QBrush(opt->palette.light().color(), Qt::Dense4Pattern);
+        else
+            fill = opt->palette.brush(QPalette::Button);
+
+        if (opt->state & (State_Raised | State_Sunken)) {
+            qDrawWinButton(p, opt->rect, opt->palette, opt->state & State_Sunken, &fill);
+        } else {
+            p->fillRect(opt->rect, fill);
+        }
+        break; }
+#if 0 && QT_CONFIG(toolbar)
+    case CE_ToolBar:
+        if (const QStyleOptionToolBar *toolbar = qstyleoption_cast<const QStyleOptionToolBar *>(opt)) {
+            // Reserve the beveled appearance only for mainwindow toolbars
+            if (!(widget && qobject_cast<const QMainWindow*> (widget->parentWidget())))
+                break;
+
+            QRect rect = opt->rect;
+            bool paintLeftBorder = true;
+            bool paintRightBorder = true;
+            bool paintBottomBorder = true;
+
+            switch (toolbar->toolBarArea){
+            case Qt::BottomToolBarArea :
+                switch (toolbar->positionOfLine){
+                case QStyleOptionToolBar::Beginning:
+                case QStyleOptionToolBar::OnlyOne:
+                    paintBottomBorder = false;
+                    break;
+                default:
+                    break;
+                }
+                Q_FALLTHROUGH(); // It continues in the end of the next case
+            case Qt::TopToolBarArea :
+                switch (toolbar->positionWithinLine){
+                case QStyleOptionToolBar::Beginning:
+                    paintLeftBorder = false;
+                    break;
+                case QStyleOptionToolBar::End:
+                    paintRightBorder = false;
+                    break;
+                case QStyleOptionToolBar::OnlyOne:
+                    paintRightBorder = false;
+                    paintLeftBorder = false;
+                    break;
+                default:
+                    break;
+                }
+                if (opt->direction == Qt::RightToLeft){ //reverse layout changes the order of Beginning/end
+                    bool tmp = paintLeftBorder;
+                    paintRightBorder=paintLeftBorder;
+                    paintLeftBorder=tmp;
+                }
+                break;
+            case Qt::RightToolBarArea :
+                switch (toolbar->positionOfLine){
+                case QStyleOptionToolBar::Beginning:
+                case QStyleOptionToolBar::OnlyOne:
+                    paintRightBorder = false;
+                    break;
+                default:
+                    break;
+                }
+                break;
+            case Qt::LeftToolBarArea :
+                switch (toolbar->positionOfLine){
+                case QStyleOptionToolBar::Beginning:
+                case QStyleOptionToolBar::OnlyOne:
+                    paintLeftBorder = false;
+                    break;
+                default:
+                    break;
+                }
+                break;
+            default:
+                break;
+            }
+
+
+            //draw top border
+            p->setPen(QPen(opt->palette.light().color()));
+            p->drawLine(rect.topLeft().x(),
+                        rect.topLeft().y(),
+                        rect.topRight().x(),
+                        rect.topRight().y());
+
+            if (paintLeftBorder){
+                p->setPen(QPen(opt->palette.light().color()));
+                p->drawLine(rect.topLeft().x(),
+                            rect.topLeft().y(),
+                            rect.bottomLeft().x(),
+                            rect.bottomLeft().y());
+            }
+
+            if (paintRightBorder){
+                p->setPen(QPen(opt->palette.dark().color()));
+                p->drawLine(rect.topRight().x(),
+                            rect.topRight().y(),
+                            rect.bottomRight().x(),
+                            rect.bottomRight().y());
+            }
+
+            if (paintBottomBorder){
+                p->setPen(QPen(opt->palette.dark().color()));
+                p->drawLine(rect.bottomLeft().x(),
+                            rect.bottomLeft().y(),
+                            rect.bottomRight().x(),
+                            rect.bottomRight().y());
+            }
+        }
+        break;
+
+
+#endif // QT_CONFIG(toolbar)
+
+    case CE_ProgressBarContents:
+        if (const QStyleOptionProgressBar *pb = qstyleoption_cast<const QStyleOptionProgressBar *>(opt)) {
+            QRect rect = pb->rect;
+            if (!rect.isValid())
+                return;
+
+            const bool vertical = !(pb->state & QStyle::State_Horizontal);
+            const bool inverted = pb->invertedAppearance;
+
+            QTransform m;
+            if (vertical) {
+                rect = QRect(rect.y(), rect.x(), rect.height(), rect.width()); // flip width and height
+                m.rotate(90);
+                m.translate(0, -(rect.height() + rect.y()*2));
+            }
+            QPalette pal2 = pb->palette;
+            // Correct the highlight color if it is the same as the background
+            if (pal2.highlight() == pal2.window())
+                pal2.setColor(QPalette::Highlight, pb->palette.color(QPalette::Active,
+                                                                     QPalette::Highlight));
+            bool reverse = ((!vertical && (pb->direction == Qt::RightToLeft)) || vertical);
+            if (inverted)
+                reverse = !reverse;
+            int w = rect.width();
+            Q_D(const QWindowsStyle);
+            if (pb->minimum == 0 && pb->maximum == 0) {
+                const int unit_width = proxy()->pixelMetric(PM_ProgressBarChunkWidth, pb);
+                QStyleOptionProgressBar pbBits = *pb;
+                Q_ASSERT(unit_width >0);
+
+                pbBits.rect = rect;
+                pbBits.palette = pal2;
+
+                int step = 0;
+                int chunkCount = w / unit_width + 1;
+#if 0 && QT_CONFIG(animation)
+                if (QProgressStyleAnimation *animation = qobject_cast<QProgressStyleAnimation*>(d->animation(opt->styleObject)))
+                    step = (animation->animationStep() / 3) % chunkCount;
+                else
+                    d->startAnimation(new QProgressStyleAnimation(d->animationFps, opt->styleObject));
+#else
+                Q_UNUSED(d);
+#endif
+                int chunksInRow = 5;
+                int myY = pbBits.rect.y();
+                int myHeight = pbBits.rect.height();
+                int chunksToDraw = chunksInRow;
+
+                if (step > chunkCount - 5)chunksToDraw = (chunkCount - step);
+                p->save();
+                p->setClipRect(m.mapRect(QRectF(rect)).toRect());
+
+                int x0 = reverse ? rect.left() + rect.width() - unit_width*(step) - unit_width  : rect.left() + unit_width * step;
+                int x = 0;
+
+                for (int i = 0; i < chunksToDraw ; ++i) {
+                    pbBits.rect.setRect(x0 + x, myY, unit_width, myHeight);
+                    pbBits.rect = m.mapRect(QRectF(pbBits.rect)).toRect();
+                    proxy()->drawPrimitive(PE_IndicatorProgressChunk, &pbBits, p);
+                    x += reverse ? -unit_width : unit_width;
+                }
+                //Draw wrap-around chunks
+                if ( step > chunkCount-5){
+                    x0 = reverse ? rect.left() + rect.width() - unit_width : rect.left() ;
+                    x = 0;
+                    int chunksToDraw = step - (chunkCount - chunksInRow);
+                    for (int i = 0; i < chunksToDraw ; ++i) {
+                        pbBits.rect.setRect(x0 + x, myY, unit_width, myHeight);
+                        pbBits.rect = m.mapRect(QRectF(pbBits.rect)).toRect();
+                        proxy()->drawPrimitive(PE_IndicatorProgressChunk, &pbBits, p);
+                        x += reverse ? -unit_width : unit_width;
+                    }
+                }
+                p->restore(); //restore state
+            }
+            else {
+#if 0 && QT_CONFIG(animation)
+                d->stopAnimation(opt->styleObject);
+#endif
+                QCommonStyle::drawControl(ce, opt, p);
+            }
+        }
+        break;
+
+#if 0 && QT_CONFIG(dockwidget)
+    case CE_DockWidgetTitle:
+
+        if (const QStyleOptionDockWidget *dwOpt = qstyleoption_cast<const QStyleOptionDockWidget *>(opt)) {
+            Q_D(const QWindowsStyle);
+
+            const bool verticalTitleBar = dwOpt->verticalTitleBar;
+
+            QRect rect = dwOpt->rect;
+            QRect r = rect;
+
+            if (verticalTitleBar) {
+                r = r.transposed();
+
+                p->save();
+                p->translate(r.left(), r.top() + r.width());
+                p->rotate(-90);
+                p->translate(-r.left(), -r.top());
+            }
+
+            bool floating = false;
+            bool active = dwOpt->state & State_Active;
+            QColor inactiveCaptionTextColor = d->inactiveCaptionText;
+            if (dwOpt->movable) {
+                QColor left, right;
+
+                //Titlebar gradient
+                if (opt->state & QStyle::State_Window) {
+                    floating = true;
+                    if (active) {
+                        left = d->activeCaptionColor;
+                        right = d->activeGradientCaptionColor;
+                    } else {
+                        left = d->inactiveCaptionColor;
+                        right = d->inactiveGradientCaptionColor;
+                    }
+                    QBrush fillBrush(left);
+                    if (left != right) {
+                        QPoint p1(r.x(), r.top() + r.height()/2);
+                        QPoint p2(rect.right(), r.top() + r.height()/2);
+                        QLinearGradient lg(p1, p2);
+                        lg.setColorAt(0, left);
+                        lg.setColorAt(1, right);
+                        fillBrush = lg;
+                    }
+                    p->fillRect(r.adjusted(0, 0, 0, -3), fillBrush);
+                }
+            }
+            if (!dwOpt->title.isEmpty()) {
+                QFont oldFont = p->font();
+                if (floating) {
+                    QFont font = oldFont;
+                    font.setBold(true);
+                    p->setFont(font);
+                }
+                QPalette palette = dwOpt->palette;
+                palette.setColor(QPalette::Window, inactiveCaptionTextColor);
+                QRect titleRect = subElementRect(SE_DockWidgetTitleBarText, opt, widget);
+                if (verticalTitleBar) {
+                    titleRect = QRect(r.left() + rect.bottom()
+                                        - titleRect.bottom(),
+                                    r.top() + titleRect.left() - rect.left(),
+                                    titleRect.height(), titleRect.width());
+                }
+                proxy()->drawItemText(p, titleRect,
+                            Qt::AlignLeft | Qt::AlignVCenter, palette,
+                            dwOpt->state & State_Enabled, dwOpt->title,
+                            floating ? (active ? QPalette::BrightText : QPalette::Window) : QPalette::WindowText);
+                p->setFont(oldFont);
+            }
+            if (verticalTitleBar)
+                p->restore();
+        }
+        return;
+#endif // QT_CONFIG(dockwidget)
+#if 0 && QT_CONFIG(combobox)
+    case CE_ComboBoxLabel:
+        if (const QStyleOptionComboBox *cb = qstyleoption_cast<const QStyleOptionComboBox *>(opt)) {
+            if (cb->state & State_HasFocus) {
+                p->setPen(cb->palette.highlightedText().color());
+                p->setBackground(cb->palette.highlight());
+            } else {
+                p->setPen(cb->palette.text().color());
+                p->setBackground(cb->palette.window());
+            }
+        }
+        QCommonStyle::drawControl(ce, opt, p, widget);
+        break;
+#endif // QT_CONFIG(combobox)
+    default:
+        QCommonStyle::drawControl(ce, opt, p);
+    }
+}
+
+/*! \reimp */
+QRect QWindowsStyle::subElementRect(SubElement sr, const QStyleOption *opt) const
+{
+    QRect r;
+    switch (sr) {
+    case SE_SliderFocusRect:
+    case SE_ToolBoxTabContents:
+        r = visualRect(opt->direction, opt->rect, opt->rect);
+        break;
+    case SE_DockWidgetTitleBarText: {
+        r = QCommonStyle::subElementRect(sr, opt);
+        const QStyleOptionDockWidget *dwOpt
+            = qstyleoption_cast<const QStyleOptionDockWidget*>(opt);
+        const bool verticalTitleBar = dwOpt && dwOpt->verticalTitleBar;
+        int m = proxy()->pixelMetric(PM_DockWidgetTitleMargin, opt);
+        if (verticalTitleBar) {
+            r.adjust(0, 0, 0, -m);
+        } else {
+            if (opt->direction == Qt::LeftToRight)
+                r.adjust(m, 0, 0, 0);
+            else
+                r.adjust(0, 0, -m, 0);
+        }
+        break;
+    }
+    case SE_ProgressBarContents:
+        r = QCommonStyle::subElementRect(SE_ProgressBarGroove, opt);
+        r.adjust(3, 3, -3, -3);
+        break;
+    default:
+        r = QCommonStyle::subElementRect(sr, opt);
+    }
+    return r;
+}
+
+
+/*! \reimp */
+void QWindowsStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex *opt,
+                                       QPainter *p) const
+{
+    switch (cc) {
+#if 0 && QT_CONFIG(slider)
+    case CC_Slider:
+        if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(opt)) {
+            int thickness  = proxy()->pixelMetric(PM_SliderControlThickness, slider, widget);
+            int len        = proxy()->pixelMetric(PM_SliderLength, slider, widget);
+            int ticks = slider->tickPosition;
+            QRect groove = proxy()->subControlRect(CC_Slider, slider, SC_SliderGroove, widget);
+            QRect handle = proxy()->subControlRect(CC_Slider, slider, SC_SliderHandle, widget);
+
+            if ((slider->subControls & SC_SliderGroove) && groove.isValid()) {
+                int mid = thickness / 2;
+
+                if (ticks & QSlider::TicksAbove)
+                    mid += len / 8;
+                if (ticks & QSlider::TicksBelow)
+                    mid -= len / 8;
+
+                p->setPen(slider->palette.shadow().color());
+                if (slider->orientation == Qt::Horizontal) {
+                    qDrawWinPanel(p, groove.x(), groove.y() + mid - 2,
+                                   groove.width(), 4, slider->palette, true);
+                    p->drawLine(groove.x() + 1, groove.y() + mid - 1,
+                                groove.x() + groove.width() - 3, groove.y() + mid - 1);
+                } else {
+                    qDrawWinPanel(p, groove.x() + mid - 2, groove.y(),
+                                  4, groove.height(), slider->palette, true);
+                    p->drawLine(groove.x() + mid - 1, groove.y() + 1,
+                                groove.x() + mid - 1, groove.y() + groove.height() - 3);
+                }
+            }
+
+            if (slider->subControls & SC_SliderTickmarks) {
+                QStyleOptionSlider tmpSlider = *slider;
+                tmpSlider.subControls = SC_SliderTickmarks;
+                QCommonStyle::drawComplexControl(cc, &tmpSlider, p, widget);
+            }
+
+            if (slider->subControls & SC_SliderHandle) {
+                // 4444440
+                // 4333310
+                // 4322210
+                // 4322210
+                // 4322210
+                // 4322210
+                // *43210*
+                // **410**
+                // ***0***
+                const QColor c0 = slider->palette.shadow().color();
+                const QColor c1 = slider->palette.dark().color();
+                // const QColor c2 = g.button();
+                const QColor c3 = slider->palette.midlight().color();
+                const QColor c4 = slider->palette.light().color();
+                QBrush handleBrush;
+
+                if (slider->state & State_Enabled) {
+                    handleBrush = slider->palette.color(QPalette::Button);
+                } else {
+                    handleBrush = QBrush(slider->palette.color(QPalette::Button),
+                                         Qt::Dense4Pattern);
+                }
+
+
+                int x = handle.x(), y = handle.y(),
+                   wi = handle.width(), he = handle.height();
+
+                int x1 = x;
+                int x2 = x+wi-1;
+                int y1 = y;
+                int y2 = y+he-1;
+
+                Qt::Orientation orient = slider->orientation;
+                bool tickAbove = slider->tickPosition == QSlider::TicksAbove;
+                bool tickBelow = slider->tickPosition == QSlider::TicksBelow;
+
+                if (slider->state & State_HasFocus) {
+                    QStyleOptionFocusRect fropt;
+                    fropt.QStyleOption::operator=(*slider);
+                    fropt.rect = subElementRect(SE_SliderFocusRect, slider, widget);
+                    proxy()->drawPrimitive(PE_FrameFocusRect, &fropt, p, widget);
+                }
+
+                if ((tickAbove && tickBelow) || (!tickAbove && !tickBelow)) {
+                    Qt::BGMode oldMode = p->backgroundMode();
+                    p->setBackgroundMode(Qt::OpaqueMode);
+                    qDrawWinButton(p, QRect(x, y, wi, he), slider->palette, false,
+                                   &handleBrush);
+                    p->setBackgroundMode(oldMode);
+                    return;
+                }
+
+                QSliderDirection dir;
+
+                if (orient == Qt::Horizontal)
+                    if (tickAbove)
+                        dir = SlUp;
+                    else
+                        dir = SlDown;
+                else
+                    if (tickAbove)
+                        dir = SlLeft;
+                    else
+                        dir = SlRight;
+
+                QPolygon a;
+
+                int d = 0;
+                switch (dir) {
+                case SlUp:
+                    y1 = y1 + wi/2;
+                    d =  (wi + 1) / 2 - 1;
+                    a.setPoints(5, x1,y1, x1,y2, x2,y2, x2,y1, x1+d,y1-d);
+                    break;
+                case SlDown:
+                    y2 = y2 - wi/2;
+                    d =  (wi + 1) / 2 - 1;
+                    a.setPoints(5, x1,y1, x1,y2, x1+d,y2+d, x2,y2, x2,y1);
+                    break;
+                case SlLeft:
+                    d =  (he + 1) / 2 - 1;
+                    x1 = x1 + he/2;
+                    a.setPoints(5, x1,y1, x1-d,y1+d, x1,y2, x2,y2, x2,y1);
+                    break;
+                case SlRight:
+                    d =  (he + 1) / 2 - 1;
+                    x2 = x2 - he/2;
+                    a.setPoints(5, x1,y1, x1,y2, x2,y2, x2+d,y1+d, x2,y1);
+                    break;
+                }
+
+                QBrush oldBrush = p->brush();
+                bool oldQt4CompatiblePainting = p->testRenderHint(QPainter::Qt4CompatiblePainting);
+                p->setPen(Qt::NoPen);
+                p->setBrush(handleBrush);
+                p->setRenderHint(QPainter::Qt4CompatiblePainting);
+                Qt::BGMode oldMode = p->backgroundMode();
+                p->setBackgroundMode(Qt::OpaqueMode);
+                p->drawRect(x1, y1, x2-x1+1, y2-y1+1);
+                p->drawPolygon(a);
+                p->setBrush(oldBrush);
+                p->setBackgroundMode(oldMode);
+
+                if (dir != SlUp) {
+                    p->setPen(c4);
+                    p->drawLine(x1, y1, x2, y1);
+                    p->setPen(c3);
+                    p->drawLine(x1, y1+1, x2, y1+1);
+                }
+                if (dir != SlLeft) {
+                    p->setPen(c3);
+                    p->drawLine(x1+1, y1+1, x1+1, y2);
+                    p->setPen(c4);
+                    p->drawLine(x1, y1, x1, y2);
+                }
+                if (dir != SlRight) {
+                    p->setPen(c0);
+                    p->drawLine(x2, y1, x2, y2);
+                    p->setPen(c1);
+                    p->drawLine(x2-1, y1+1, x2-1, y2-1);
+                }
+                if (dir != SlDown) {
+                    p->setPen(c0);
+                    p->drawLine(x1, y2, x2, y2);
+                    p->setPen(c1);
+                    p->drawLine(x1+1, y2-1, x2-1, y2-1);
+                }
+
+                switch (dir) {
+                case SlUp:
+                    p->setPen(c4);
+                    p->drawLine(x1, y1, x1+d, y1-d);
+                    p->setPen(c0);
+                    d = wi - d - 1;
+                    p->drawLine(x2, y1, x2-d, y1-d);
+                    d--;
+                    p->setPen(c3);
+                    p->drawLine(x1+1, y1, x1+1+d, y1-d);
+                    p->setPen(c1);
+                    p->drawLine(x2-1, y1, x2-1-d, y1-d);
+                    break;
+                case SlDown:
+                    p->setPen(c4);
+                    p->drawLine(x1, y2, x1+d, y2+d);
+                    p->setPen(c0);
+                    d = wi - d - 1;
+                    p->drawLine(x2, y2, x2-d, y2+d);
+                    d--;
+                    p->setPen(c3);
+                    p->drawLine(x1+1, y2, x1+1+d, y2+d);
+                    p->setPen(c1);
+                    p->drawLine(x2-1, y2, x2-1-d, y2+d);
+                    break;
+                case SlLeft:
+                    p->setPen(c4);
+                    p->drawLine(x1, y1, x1-d, y1+d);
+                    p->setPen(c0);
+                    d = he - d - 1;
+                    p->drawLine(x1, y2, x1-d, y2-d);
+                    d--;
+                    p->setPen(c3);
+                    p->drawLine(x1, y1+1, x1-d, y1+1+d);
+                    p->setPen(c1);
+                    p->drawLine(x1, y2-1, x1-d, y2-1-d);
+                    break;
+                case SlRight:
+                    p->setPen(c4);
+                    p->drawLine(x2, y1, x2+d, y1+d);
+                    p->setPen(c0);
+                    d = he - d - 1;
+                    p->drawLine(x2, y2, x2+d, y2-d);
+                    d--;
+                    p->setPen(c3);
+                    p->drawLine(x2, y1+1, x2+d, y1+1+d);
+                    p->setPen(c1);
+                    p->drawLine(x2, y2-1, x2+d, y2-1-d);
+                    break;
+                }
+                p->setRenderHint(QPainter::Qt4CompatiblePainting, oldQt4CompatiblePainting);
+            }
+        }
+        break;
+#endif // QT_CONFIG(slider)
+#if 0 && QT_CONFIG(scrollbar)
+    case CC_ScrollBar:
+        if (const QStyleOptionSlider *scrollbar = qstyleoption_cast<const QStyleOptionSlider *>(opt)) {
+            QStyleOptionSlider newScrollbar = *scrollbar;
+            if (scrollbar->minimum == scrollbar->maximum)
+                newScrollbar.state &= ~State_Enabled; //do not draw the slider.
+            QCommonStyle::drawComplexControl(cc, &newScrollbar, p, widget);
+        }
+        break;
+#endif // QT_CONFIG(scrollbar)
+#if 0 && QT_CONFIG(combobox)
+    case CC_ComboBox:
+        if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(opt)) {
+            QBrush editBrush = cmb->palette.brush(QPalette::Button);
+            if ((cmb->subControls & SC_ComboBoxFrame)) {
+                if (cmb->frame) {
+                    QPalette shadePal = opt->palette;
+                    shadePal.setColor(QPalette::Midlight, shadePal.button().color());
+                    qDrawWinPanel(p, opt->rect, shadePal, true, &editBrush);
+                }
+                else {
+                    p->fillRect(opt->rect, editBrush);
+                }
+            }
+            if (cmb->subControls & SC_ComboBoxArrow) {
+                State flags = State_None;
+
+                QRect ar = proxy()->subControlRect(CC_ComboBox, cmb, SC_ComboBoxArrow, widget);
+                bool sunkenArrow = cmb->activeSubControls == SC_ComboBoxArrow
+                                   && cmb->state & State_Sunken;
+                if (sunkenArrow) {
+                    p->setPen(cmb->palette.dark().color());
+                    p->setBrush(cmb->palette.brush(QPalette::Button));
+                    p->drawRect(ar.adjusted(0,0,-1,-1));
+                } else {
+                    // Make qDrawWinButton use the right colors for drawing the shade of the button
+                    QPalette pal(cmb->palette);
+                    pal.setColor(QPalette::Button, cmb->palette.light().color());
+                    pal.setColor(QPalette::Light, cmb->palette.button().color());
+                    qDrawWinButton(p, ar, pal, false,
+                                   &cmb->palette.brush(QPalette::Button));
+                }
+
+                ar.adjust(2, 2, -2, -2);
+                if (opt->state & State_Enabled)
+                    flags |= State_Enabled;
+                if (opt->state & State_HasFocus)
+                    flags |= State_HasFocus;
+
+                if (sunkenArrow)
+                    flags |= State_Sunken;
+                QStyleOption arrowOpt = *cmb;
+                arrowOpt.rect = ar.adjusted(1, 1, -1, -1);
+                arrowOpt.state = flags;
+                proxy()->drawPrimitive(PE_IndicatorArrowDown, &arrowOpt, p, widget);
+            }
+
+            if (cmb->subControls & SC_ComboBoxEditField) {
+                QRect re = proxy()->subControlRect(CC_ComboBox, cmb, SC_ComboBoxEditField, widget);
+                if (cmb->state & State_HasFocus && !cmb->editable)
+                    p->fillRect(re.x(), re.y(), re.width(), re.height(),
+                                cmb->palette.brush(QPalette::Highlight));
+
+                if (cmb->state & State_HasFocus) {
+                    p->setPen(cmb->palette.highlightedText().color());
+                    p->setBackground(cmb->palette.highlight());
+
+                } else {
+                    p->setPen(cmb->palette.text().color());
+                    p->setBackground(cmb->palette.window());
+                }
+
+                if (cmb->state & State_HasFocus && !cmb->editable) {
+                    QStyleOptionFocusRect focus;
+                    focus.QStyleOption::operator=(*cmb);
+                    focus.rect = subElementRect(SE_ComboBoxFocusRect, cmb, widget);
+                    focus.state |= State_FocusAtBorder;
+                    focus.backgroundColor = cmb->palette.highlight().color();
+                    proxy()->drawPrimitive(PE_FrameFocusRect, &focus, p, widget);
+                }
+            }
+        }
+        break;
+#endif // QT_CONFIG(combobox)
+#if 0 && QT_CONFIG(spinbox)
+    case CC_SpinBox:
+        if (const QStyleOptionSpinBox *sb = qstyleoption_cast<const QStyleOptionSpinBox *>(opt)) {
+            QStyleOptionSpinBox copy = *sb;
+            PrimitiveElement pe;
+            bool enabled = opt->state & State_Enabled;
+            if (sb->frame && (sb->subControls & SC_SpinBoxFrame)) {
+                QBrush editBrush = sb->palette.brush(QPalette::Base);
+                QRect r = proxy()->subControlRect(CC_SpinBox, sb, SC_SpinBoxFrame, widget);
+                QPalette shadePal = sb->palette;
+                shadePal.setColor(QPalette::Midlight, shadePal.button().color());
+                qDrawWinPanel(p, r, shadePal, true, &editBrush);
+            }
+
+            QPalette shadePal(opt->palette);
+            shadePal.setColor(QPalette::Button, opt->palette.light().color());
+            shadePal.setColor(QPalette::Light, opt->palette.button().color());
+
+            if (sb->subControls & SC_SpinBoxUp) {
+                copy.subControls = SC_SpinBoxUp;
+                QPalette pal2 = sb->palette;
+                if (!(sb->stepEnabled & QAbstractSpinBox::StepUpEnabled)) {
+                    pal2.setCurrentColorGroup(QPalette::Disabled);
+                    copy.state &= ~State_Enabled;
+                }
+
+                copy.palette = pal2;
+
+                if (sb->activeSubControls == SC_SpinBoxUp && (sb->state & State_Sunken)) {
+                    copy.state |= State_On;
+                    copy.state |= State_Sunken;
+                } else {
+                    copy.state |= State_Raised;
+                    copy.state &= ~State_Sunken;
+                }
+                pe = (sb->buttonSymbols == QAbstractSpinBox::PlusMinus ? PE_IndicatorSpinPlus
+                                                                       : PE_IndicatorSpinUp);
+
+                copy.rect = proxy()->subControlRect(CC_SpinBox, sb, SC_SpinBoxUp, widget);
+                qDrawWinButton(p, copy.rect, shadePal, copy.state & (State_Sunken | State_On),
+                                &copy.palette.brush(QPalette::Button));
+                copy.rect.adjust(4, 1, -5, -1);
+                if ((!enabled || !(sb->stepEnabled & QAbstractSpinBox::StepUpEnabled))
+                    && proxy()->styleHint(SH_EtchDisabledText, opt, widget) )
+                {
+                    QStyleOptionSpinBox lightCopy = copy;
+                    lightCopy.rect.adjust(1, 1, 1, 1);
+                    lightCopy.palette.setBrush(QPalette::ButtonText, copy.palette.light());
+                    proxy()->drawPrimitive(pe, &lightCopy, p, widget);
+                }
+                proxy()->drawPrimitive(pe, &copy, p, widget);
+            }
+
+            if (sb->subControls & SC_SpinBoxDown) {
+                copy.subControls = SC_SpinBoxDown;
+                copy.state = sb->state;
+                QPalette pal2 = sb->palette;
+                if (!(sb->stepEnabled & QAbstractSpinBox::StepDownEnabled)) {
+                    pal2.setCurrentColorGroup(QPalette::Disabled);
+                    copy.state &= ~State_Enabled;
+                }
+                copy.palette = pal2;
+
+                if (sb->activeSubControls == SC_SpinBoxDown && (sb->state & State_Sunken)) {
+                    copy.state |= State_On;
+                    copy.state |= State_Sunken;
+                } else {
+                    copy.state |= State_Raised;
+                    copy.state &= ~State_Sunken;
+                }
+                pe = (sb->buttonSymbols == QAbstractSpinBox::PlusMinus ? PE_IndicatorSpinMinus
+                                                                       : PE_IndicatorSpinDown);
+
+                copy.rect = proxy()->subControlRect(CC_SpinBox, sb, SC_SpinBoxDown, widget);
+                qDrawWinButton(p, copy.rect, shadePal, copy.state & (State_Sunken | State_On),
+                                &copy.palette.brush(QPalette::Button));
+                copy.rect.adjust(4, 0, -5, -1);
+                if ((!enabled || !(sb->stepEnabled & QAbstractSpinBox::StepDownEnabled))
+                    && proxy()->styleHint(SH_EtchDisabledText, opt, widget) )
+                {
+                    QStyleOptionSpinBox lightCopy = copy;
+                    lightCopy.rect.adjust(1, 1, 1, 1);
+                    lightCopy.palette.setBrush(QPalette::ButtonText, copy.palette.light());
+                    proxy()->drawPrimitive(pe, &lightCopy, p, widget);
+                }
+                proxy()->drawPrimitive(pe, &copy, p, widget);
+            }
+        }
+        break;
+#endif // QT_CONFIG(spinbox)
+
+    default:
+        QCommonStyle::drawComplexControl(cc, opt, p);
+    }
+}
+
+/*! \reimp */
+QSize QWindowsStyle::sizeFromContents(ContentsType ct, const QStyleOption *opt, const QSize &csz) const
+{
+    QSize sz(csz);
+    switch (ct) {
+    case CT_PushButton:
+        if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(opt)) {
+            sz = QCommonStyle::sizeFromContents(ct, opt, csz);
+            int w = sz.width(),
+                h = sz.height();
+            int defwidth = 0;
+            if (btn->features & QStyleOptionButton::AutoDefaultButton)
+                defwidth = 2 * proxy()->pixelMetric(PM_ButtonDefaultIndicator, btn);
+            const qreal dpi = QStyleHelper::dpi(opt);
+            int minwidth = int(QStyleHelper::dpiScaled(75, dpi));
+            int minheight = int(QStyleHelper::dpiScaled(23, dpi));
+
+#ifndef QT_QWS_SMALL_PUSHBUTTON
+            if (w < minwidth + defwidth && !btn->text.isEmpty())
+                w = minwidth + defwidth;
+            if (h < minheight + defwidth)
+                h = minheight + defwidth;
+#endif
+            sz = QSize(w, h);
+        }
+        break;
+#if 0 && QT_CONFIG(menu)
+    case CT_MenuItem:
+        if (const QStyleOptionMenuItem *mi = qstyleoption_cast<const QStyleOptionMenuItem *>(opt)) {
+            int w = sz.width();
+            sz = QCommonStyle::sizeFromContents(ct, opt, csz, widget);
+
+            if (mi->menuItemType == QStyleOptionMenuItem::Separator) {
+                sz = QSize(10, QWindowsStylePrivate::windowsSepHeight);
+            }
+            else if (mi->icon.isNull()) {
+                sz.setHeight(sz.height() - 2);
+                w -= 6;
+            }
+
+            if (mi->menuItemType != QStyleOptionMenuItem::Separator && !mi->icon.isNull()) {
+                int iconExtent = proxy()->pixelMetric(PM_SmallIconSize, opt, widget);
+                sz.setHeight(qMax(sz.height(),
+                                  mi->icon.actualSize(QSize(iconExtent, iconExtent)).height()
+                                  + 2 * QWindowsStylePrivate::windowsItemFrame));
+            }
+            int maxpmw = mi->maxIconWidth;
+            int tabSpacing = 20;
+            if (mi->text.contains(QLatin1Char('\t')))
+                w += tabSpacing;
+            else if (mi->menuItemType == QStyleOptionMenuItem::SubMenu)
+                w += 2 * QWindowsStylePrivate::windowsArrowHMargin;
+            else if (mi->menuItemType == QStyleOptionMenuItem::DefaultItem) {
+                // adjust the font and add the difference in size.
+                // it would be better if the font could be adjusted in the initStyleOption qmenu func!!
+                QFontMetrics fm(mi->font);
+                QFont fontBold = mi->font;
+                fontBold.setBold(true);
+                QFontMetrics fmBold(fontBold);
+                w += fmBold.horizontalAdvance(mi->text) - fm.horizontalAdvance(mi->text);
+            }
+
+            int checkcol = qMax<int>(maxpmw, QWindowsStylePrivate::windowsCheckMarkWidth); // Windows always shows a check column
+            w += checkcol;
+            w += int(QWindowsStylePrivate::windowsRightBorder) + 10;
+            sz.setWidth(w);
+        }
+        break;
+#endif // QT_CONFIG(menu)
+#if 0 && QT_CONFIG(menubar)
+    case CT_MenuBarItem:
+        if (!sz.isEmpty())
+            sz += QSize(QWindowsStylePrivate::windowsItemHMargin * 4, QWindowsStylePrivate::windowsItemVMargin * 2);
+        break;
+#endif
+    case CT_ToolButton:
+        if (qstyleoption_cast<const QStyleOptionToolButton *>(opt))
+            return sz += QSize(7, 6);
+        Q_FALLTHROUGH();
+
+    default:
+        sz = QCommonStyle::sizeFromContents(ct, opt, csz);
+    }
+    return sz;
+}
+
+/*!
+    \reimp
+*/
+QIcon QWindowsStyle::standardIcon(StandardPixmap standardIcon, const QStyleOption *option) const
+{
+    return QCommonStyle::standardIcon(standardIcon, option);
+}
+
+} //namespace QQC2
+
+QT_END_NAMESPACE
+
+#include "moc_qquickwindowsstyle_p.cpp"
diff --git a/src/imports/nativestyle/qstyle/windows/qquickwindowsstyle_p.h b/src/imports/nativestyle/qstyle/windows/qquickwindowsstyle_p.h
new file mode 100644
index 00000000..92926b71
--- /dev/null
+++ b/src/imports/nativestyle/qstyle/windows/qquickwindowsstyle_p.h
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWidgets module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKWINDOWSSTYLE_P_H
+#define QQUICKWINDOWSSTYLE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickcommonstyle.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPalette;
+
+namespace QQC2 {
+
+class QStyleOptionButton;
+class QWindowsStylePrivate;
+
+class QWindowsStylePrivate;
+
+class QWindowsStyle : public QCommonStyle
+{
+    Q_OBJECT
+public:
+    QWindowsStyle();
+    ~QWindowsStyle() override;
+/*
+    void polish(QApplication*) override;
+    void unpolish(QApplication*) override;
+
+    void polish(QWidget*) override;
+    void unpolish(QWidget*) override;
+
+    void polish(QPalette &) override;
+*/
+    void drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *p) const override;
+    void drawControl(ControlElement element, const QStyleOption *opt, QPainter *p) const override;
+    void drawComplexControl(ComplexControl cc, const QStyleOptionComplex *opt, QPainter *p) const override;
+
+    QRect subElementRect(SubElement r, const QStyleOption *opt) const override;
+    QSize sizeFromContents(ContentsType ct, const QStyleOption *opt, const QSize &contentsSize) const override;
+
+    int pixelMetric(PixelMetric pm, const QStyleOption *option = nullptr) const override;
+
+    int styleHint(StyleHint hint, const QStyleOption *opt = nullptr,
+                  QStyleHintReturn *returnData = nullptr) const override;
+
+    QPixmap standardPixmap(StandardPixmap standardPixmap, const QStyleOption *opt) const override;
+
+    QIcon standardIcon(StandardPixmap standardIcon, const QStyleOption *option = nullptr) const override;
+
+protected:
+//    bool eventFilter(QObject *o, QEvent *e) override;
+    QWindowsStyle(QWindowsStylePrivate &dd);
+
+private:
+    Q_DISABLE_COPY_MOVE(QWindowsStyle)
+    Q_DECLARE_PRIVATE(QWindowsStyle)
+};
+
+} // namespace QQC2
+
+QT_END_NAMESPACE
+
+#endif // QQUICKWINDOWSSTYLE_P_H
diff --git a/src/imports/nativestyle/qstyle/windows/qquickwindowsstyle_p_p.h b/src/imports/nativestyle/qstyle/windows/qquickwindowsstyle_p_p.h
new file mode 100644
index 00000000..1cd06fed
--- /dev/null
+++ b/src/imports/nativestyle/qstyle/windows/qquickwindowsstyle_p_p.h
@@ -0,0 +1,116 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWidgets module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKWINDOWSSTYLE_P_P_H
+#define QQUICKWINDOWSSTYLE_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of XX.  This header
+// file may change from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickwindowsstyle_p.h"
+#include "qquickcommonstyle_p.h"
+#include "qquickstylehelper_p.h"
+
+QT_BEGIN_NAMESPACE
+
+namespace QQC2 {
+
+class QStyleOptionButton;
+class QWindowsStylePrivate;
+
+#include <qlist.h>
+
+class QTime;
+
+class QWindowsStylePrivate : public QCommonStylePrivate
+{
+    Q_DECLARE_PUBLIC(QWindowsStyle)
+public:
+    enum { InvalidMetric = -23576 };
+
+    QWindowsStylePrivate();
+    static int pixelMetricFromSystemDp(QStyle::PixelMetric pm, const QStyleOption *option = nullptr);
+    static int fixedPixelMetric(QStyle::PixelMetric pm);
+    static qreal devicePixelRatio(const QStyleOption *option = nullptr)
+        { return (option && option->window) ? option->window->devicePixelRatio() : QWindowsStylePrivate::appDevicePixelRatio(); }
+    static qreal nativeMetricScaleFactor(const QStyleOption *option = nullptr);
+    static bool isDarkMode();
+
+#if 0
+    bool hasSeenAlt(const QWidget *widget) const;
+    bool altDown() const { return alt_down; }
+    bool alt_down = false;
+#endif
+    QList<const QWidget *> seenAlt;
+    int menuBarTimer = 0;
+
+    QColor inactiveCaptionText;
+    QColor activeCaptionColor;
+    QColor activeGradientCaptionColor;
+    QColor inactiveCaptionColor;
+    QColor inactiveGradientCaptionColor;
+
+    enum {
+        windowsItemFrame        =  2, // menu item frame width
+        windowsSepHeight        =  9, // separator item height
+        windowsItemHMargin      =  3, // menu item hor text margin
+        windowsItemVMargin      =  2, // menu item ver text margin
+        windowsArrowHMargin     =  6, // arrow horizontal margin
+        windowsRightBorder      = 15, // right border on windows
+        windowsCheckMarkWidth   = 12  // checkmarks width on windows
+    };
+
+private:
+    static qreal appDevicePixelRatio();
+};
+
+} // namespace QQC2
+
+QT_END_NAMESPACE
+
+#endif //QQUICKWINDOWSSTYLE_P_P_H
+
diff --git a/src/imports/nativestyle/qstyle/windows/qquickwindowsvistastyle.cpp b/src/imports/nativestyle/qstyle/windows/qquickwindowsvistastyle.cpp
new file mode 100644
index 00000000..c3a567bd
--- /dev/null
+++ b/src/imports/nativestyle/qstyle/windows/qquickwindowsvistastyle.cpp
@@ -0,0 +1,2509 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWidgets module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquickwindowsvistastyle_p.h"
+#include "qquickwindowsvistastyle_p_p.h"
+#include <qoperatingsystemversion.h>
+#include <qscreen.h>
+#include <qwindow.h>
+#include <private/qstyleanimation_p.h>
+#include <private/qstylehelper_p.h>
+#include <qpa/qplatformnativeinterface.h>
+
+QT_BEGIN_NAMESPACE
+
+static const int windowsItemFrame        =  2; // menu item frame width
+static const int windowsItemHMargin      =  3; // menu item hor text margin
+static const int windowsItemVMargin      =  4; // menu item ver text margin
+static const int windowsArrowHMargin     =  6; // arrow horizontal margin
+static const int windowsRightBorder      = 15; // right border on windows
+
+#ifndef TMT_CONTENTMARGINS
+#  define TMT_CONTENTMARGINS 3602
+#endif
+#ifndef TMT_SIZINGMARGINS
+#  define TMT_SIZINGMARGINS 3601
+#endif
+#ifndef LISS_NORMAL
+#  define LISS_NORMAL 1
+#  define LISS_HOT 2
+#  define LISS_SELECTED 3
+#  define LISS_DISABLED 4
+#  define LISS_SELECTEDNOTFOCUS 5
+#  define LISS_HOTSELECTED 6
+#endif
+#ifndef BP_COMMANDLINK
+#  define BP_COMMANDLINK 6
+#  define BP_COMMANDLINKGLYPH 7
+#  define CMDLGS_NORMAL 1
+#  define CMDLGS_HOT 2
+#  define CMDLGS_PRESSED 3
+#  define CMDLGS_DISABLED 4
+#endif
+
+/* \internal
+    Checks if we should use Vista style , or if we should
+    fall back to Windows style.
+*/
+bool QWindowsVistaStylePrivate::useVista()
+{
+    return QWindowsVistaStylePrivate::useXP();
+}
+
+/* \internal
+    Checks and returns the style object
+*/
+inline QObject *styleObject(const QStyleOption *option) {
+    return option ? option->styleObject : nullptr;
+}
+
+/* \internal
+    Checks if we can animate on a style option
+*/
+bool canAnimate(const QStyleOption *option) {
+    return option
+            && option->styleObject
+            && !option->styleObject->property("_q_no_animation").toBool();
+}
+
+static inline QImage createAnimationBuffer(const QStyleOption *option, const QWidget *widget)
+{
+    const int devicePixelRatio = widget ? widget->devicePixelRatio() : 1;
+    QImage result(option->rect.size() * devicePixelRatio, QImage::Format_ARGB32_Premultiplied);
+    result.setDevicePixelRatio(devicePixelRatio);
+    result.fill(0);
+    return result;
+}
+
+/* \internal
+    Used by animations to clone a styleoption and shift its offset
+*/
+QStyleOption *clonedAnimationStyleOption(const QStyleOption*option) {
+    QStyleOption *styleOption = nullptr;
+    if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider*>(option))
+        styleOption = new QStyleOptionSlider(*slider);
+    else if (const QStyleOptionSpinBox *spinbox = qstyleoption_cast<const QStyleOptionSpinBox*>(option))
+        styleOption = new QStyleOptionSpinBox(*spinbox);
+    else if (const QStyleOptionGroupBox *groupBox = qstyleoption_cast<const QStyleOptionGroupBox*>(option))
+        styleOption = new QStyleOptionGroupBox(*groupBox);
+    else if (const QStyleOptionComboBox *combo = qstyleoption_cast<const QStyleOptionComboBox*>(option))
+        styleOption = new QStyleOptionComboBox(*combo);
+    else if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton*>(option))
+        styleOption = new QStyleOptionButton(*button);
+    else
+        styleOption = new QStyleOption(*option);
+    styleOption->rect = QRect(QPoint(0,0), option->rect.size());
+    return styleOption;
+}
+
+/* \internal
+    Used by animations to delete cloned styleoption
+*/
+void deleteClonedAnimationStyleOption(const QStyleOption *option)
+{
+    if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider*>(option))
+        delete slider;
+    else if (const QStyleOptionSpinBox *spinbox = qstyleoption_cast<const QStyleOptionSpinBox*>(option))
+        delete spinbox;
+    else if (const QStyleOptionGroupBox *groupBox = qstyleoption_cast<const QStyleOptionGroupBox*>(option))
+        delete groupBox;
+    else if (const QStyleOptionComboBox *combo = qstyleoption_cast<const QStyleOptionComboBox*>(option))
+        delete combo;
+    else if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton*>(option))
+        delete button;
+    else
+        delete option;
+}
+
+/*!
+  \class QWindowsVistaStyle
+  \brief The QWindowsVistaStyle class provides a look and feel suitable for applications on Microsoft Windows Vista.
+  \since 4.3
+  \ingroup appearance
+  \inmodule QtWidgets
+  \internal
+
+  \warning This style is only available on the Windows Vista platform
+  because it makes use of Windows Vista's style engine.
+
+  \sa QMacStyle, QWindowsXPStyle, QFusionStyle
+*/
+
+/*!
+  Constructs a QWindowsVistaStyle object.
+*/
+QWindowsVistaStyle::QWindowsVistaStyle()
+    : QWindowsXPStyle(*new QWindowsVistaStylePrivate)
+{
+}
+
+/*!
+  Destructor.
+*/
+QWindowsVistaStyle::~QWindowsVistaStyle() = default;
+
+//convert Qt state flags to uxtheme button states
+static int buttonStateId(int flags, int partId)
+{
+    int stateId = 0;
+    if (partId == BP_RADIOBUTTON || partId == BP_CHECKBOX) {
+        if (!(flags & QStyle::State_Enabled))
+            stateId = RBS_UNCHECKEDDISABLED;
+        else if (flags & QStyle::State_Sunken)
+            stateId = RBS_UNCHECKEDPRESSED;
+        else if (flags & QStyle::State_MouseOver)
+            stateId = RBS_UNCHECKEDHOT;
+        else
+            stateId = RBS_UNCHECKEDNORMAL;
+
+        if (flags & QStyle::State_On)
+            stateId += RBS_CHECKEDNORMAL-1;
+
+    } else if (partId == BP_PUSHBUTTON) {
+        if (!(flags & QStyle::State_Enabled))
+            stateId = PBS_DISABLED;
+        else if (flags & (QStyle::State_Sunken | QStyle::State_On))
+            stateId = PBS_PRESSED;
+        else if (flags & QStyle::State_MouseOver)
+            stateId = PBS_HOT;
+        else
+            stateId = PBS_NORMAL;
+    } else {
+        Q_ASSERT(1);
+    }
+    return stateId;
+}
+
+bool QWindowsVistaAnimation::isUpdateNeeded() const
+{
+    return QWindowsVistaStylePrivate::useVista();
+}
+
+void QWindowsVistaAnimation::paint(QPainter *painter, const QStyleOption *option)
+{
+    painter->drawImage(option->rect, currentImage());
+}
+
+static inline bool supportsStateTransition(QStyle::PrimitiveElement element,
+                                           const QStyleOption *option,
+                                           const QWidget *widget)
+{
+    bool result = false;
+    switch (element) {
+    case QStyle::PE_IndicatorRadioButton:
+    case QStyle::PE_IndicatorCheckBox:
+        result = true;
+        break;
+    // QTBUG-40634, do not animate when color is set in palette for PE_PanelLineEdit.
+    case QStyle::PE_FrameLineEdit:
+        result = !QWindowsXPStylePrivate::isLineEditBaseColorSet(option, widget);
+        break;
+    default:
+        break;
+    }
+    return result;
+}
+
+/*!
+ \internal
+
+  Animations are used for some state transitions on specific widgets.
+
+  Only one running animation can exist for a widget at any specific
+  time.  Animations can be added through
+  QWindowsVistaStylePrivate::startAnimation(Animation *) and any
+  existing animation on a widget can be retrieved with
+  QWindowsVistaStylePrivate::widgetAnimation(Widget *).
+
+  Once an animation has been started,
+  QWindowsVistaStylePrivate::timerEvent(QTimerEvent *) will
+  continuously call update() on the widget until it is stopped,
+  meaning that drawPrimitive will be called many times until the
+  transition has completed. During this time, the result will be
+  retrieved by the Animation::paint(...) function and not by the style
+  itself.
+
+  To determine if a transition should occur, the style needs to know
+  the previous state of the widget as well as the current one. This is
+  solved by updating dynamic properties on the widget every time the
+  function is called.
+
+  Transitions interrupting existing transitions should always be
+  smooth, so whenever a hover-transition is started on a pulsating
+  button, it uses the current frame of the pulse-animation as the
+  starting image for the hover transition.
+
+ */
+
+void QWindowsVistaStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option,
+                                       QPainter *painter, const QWidget *widget) const
+{
+    QWindowsVistaStylePrivate *d = const_cast<QWindowsVistaStylePrivate*>(d_func());
+
+    int state = option->state;
+    if (!QWindowsVistaStylePrivate::useVista()) {
+        QWindowsStyle::drawPrimitive(element, option, painter, widget);
+        return;
+    }
+
+    if ((option->state & State_Enabled) && d->transitionsEnabled() && canAnimate(option)) {
+        {
+            QRect oldRect;
+            QRect newRect;
+
+            if (supportsStateTransition(element, option, widget)) {
+                // Retrieve and update the dynamic properties tracking
+                // the previous state of the widget:
+                QObject *styleObject = option->styleObject;
+                styleObject->setProperty("_q_no_animation", true);
+
+                int oldState = styleObject->property("_q_stylestate").toInt();
+                oldRect = styleObject->property("_q_stylerect").toRect();
+                newRect = option->rect;
+                styleObject->setProperty("_q_stylestate", int(option->state));
+                styleObject->setProperty("_q_stylerect", option->rect);
+
+                bool doTransition = oldState &&
+                        ((state & State_Sunken)    != (oldState & State_Sunken) ||
+                        (state & State_On)         != (oldState & State_On)     ||
+                        (state & State_MouseOver)  != (oldState & State_MouseOver));
+
+                if (oldRect != newRect ||
+                        (state & State_Enabled) != (oldState & State_Enabled) ||
+                        (state & State_Active)  != (oldState & State_Active))
+                    d->stopAnimation(styleObject);
+
+                if (option->state & State_ReadOnly && element == PE_FrameLineEdit) // Do not animate read only line edits
+                    doTransition = false;
+
+                if (doTransition) {
+                    QStyleOption *styleOption = clonedAnimationStyleOption(option);
+                    styleOption->state = QStyle::State(oldState);
+
+                    QWindowsVistaAnimation *anim = qobject_cast<QWindowsVistaAnimation *>(d->animation(styleObject));
+                    QWindowsVistaTransition *t = new QWindowsVistaTransition(styleObject);
+
+                    // We create separate images for the initial and final transition states and store them in the
+                    // Transition object.
+                    QImage startImage = createAnimationBuffer(option, widget);
+                    QPainter startPainter(&startImage);
+
+                    QImage endImage = createAnimationBuffer(option, widget);
+                    QPainter endPainter(&endImage);
+
+                    // If we have a running animation on the widget already, we will use that to paint the initial
+                    // state of the new transition, this ensures a smooth transition from a current animation such as a
+                    // pulsating default button into the intended target state.
+                    if (!anim)
+                        proxy()->drawPrimitive(element, styleOption, &startPainter, widget);
+                    else
+                        anim->paint(&startPainter, styleOption);
+
+                    t->setStartImage(startImage);
+
+                    // The end state of the transition is simply the result we would have painted
+                    // if the style was not animated.
+                    styleOption->styleObject = nullptr;
+                    styleOption->state = option->state;
+                    proxy()->drawPrimitive(element, styleOption, &endPainter, widget);
+
+
+                    t->setEndImage(endImage);
+
+                    HTHEME theme;
+                    int partId;
+                    DWORD duration;
+                    int fromState = 0;
+                    int toState = 0;
+
+                    //translate state flags to UXTHEME states :
+                    if (element == PE_FrameLineEdit) {
+                        theme = OpenThemeData(nullptr, L"Edit");
+                        partId = EP_EDITBORDER_NOSCROLL;
+
+                        if (oldState & State_MouseOver)
+                            fromState = ETS_HOT;
+                        else if (oldState & State_HasFocus)
+                            fromState = ETS_FOCUSED;
+                        else
+                            fromState = ETS_NORMAL;
+
+                        if (state & State_MouseOver)
+                            toState = ETS_HOT;
+                        else if (state & State_HasFocus)
+                            toState = ETS_FOCUSED;
+                        else
+                            toState = ETS_NORMAL;
+
+                    } else {
+                        theme = OpenThemeData(nullptr, L"Button");
+                        if (element == PE_IndicatorRadioButton)
+                            partId = BP_RADIOBUTTON;
+                        else if (element == PE_IndicatorCheckBox)
+                            partId = BP_CHECKBOX;
+                        else
+                            partId = BP_PUSHBUTTON;
+
+                        fromState = buttonStateId(oldState, partId);
+                        toState = buttonStateId(option->state, partId);
+                    }
+
+                    // Retrieve the transition time between the states from the system.
+                    if (theme
+                        && SUCCEEDED(GetThemeTransitionDuration(theme, partId, fromState, toState,
+                                                                TMT_TRANSITIONDURATIONS, &duration))) {
+                        t->setDuration(int(duration));
+                    }
+                    t->setStartTime(QTime::currentTime());
+
+                    deleteClonedAnimationStyleOption(styleOption);
+                    d->startAnimation(t);
+                }
+                styleObject->setProperty("_q_no_animation", false);
+            }
+
+        } // End of animation part
+    }
+
+    QRect rect = option->rect;
+
+    switch (element) {
+    case PE_IndicatorHeaderArrow:
+        if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
+            int stateId = HSAS_SORTEDDOWN;
+            if (header->sortIndicator & QStyleOptionHeader::SortDown)
+                stateId = HSAS_SORTEDUP; //note that the uxtheme sort down indicator is the inverse of ours
+            XPThemeData theme(widget, painter,
+                              QWindowsXPStylePrivate::HeaderTheme,
+                              HP_HEADERSORTARROW, stateId, option->rect);
+            d->drawBackground(theme);
+        }
+        break;
+
+    case PE_IndicatorBranch:
+        {
+            XPThemeData theme(widget, painter, QWindowsXPStylePrivate::VistaTreeViewTheme);
+            static int decoration_size = 0;
+            if (!decoration_size && theme.isValid()) {
+                XPThemeData themeSize = theme;
+                themeSize.partId = TVP_HOTGLYPH;
+                themeSize.stateId = GLPS_OPENED;
+                const QSizeF size = themeSize.size() * QWindowsStylePrivate::nativeMetricScaleFactor(widget);
+                decoration_size = qRound(qMax(size.width(), size.height()));
+            }
+            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;
+            if (option->state & State_Children) {
+                int delta = decoration_size / 2;
+                theme.rect = QRect(bef_h - delta, bef_v - delta, decoration_size, decoration_size);
+                theme.partId = option->state & State_MouseOver ? TVP_HOTGLYPH : TVP_GLYPH;
+                theme.stateId = option->state & QStyle::State_Open ? GLPS_OPENED : GLPS_CLOSED;
+                if (option->direction == Qt::RightToLeft)
+                    theme.mirrorHorizontally = true;
+                d->drawBackground(theme);
+                bef_h -= delta + 2;
+                bef_v -= delta + 2;
+                aft_h += delta - 2;
+                aft_v += delta - 2;
+            }
+#if 0
+            QBrush brush(option->palette.dark().color(), Qt::Dense4Pattern);
+            if (option->state & State_Item) {
+                if (option->direction == Qt::RightToLeft)
+                    painter->fillRect(option->rect.left(), mid_v, bef_h - option->rect.left(), 1, brush);
+                else
+                    painter->fillRect(aft_h, mid_v, option->rect.right() - aft_h + 1, 1, brush);
+            }
+            if (option->state & State_Sibling && option->rect.bottom() > aft_v)
+                painter->fillRect(mid_h, aft_v, 1, option->rect.bottom() - aft_v + 1, brush);
+            if (option->state & (State_Open | State_Children | State_Item | State_Sibling) && (bef_v > option->rect.y()))
+                painter->fillRect(mid_h, option->rect.y(), 1, bef_v - option->rect.y(), brush);
+#endif
+        }
+        break;
+
+    case PE_PanelButtonBevel:
+    case PE_IndicatorCheckBox:
+    case PE_IndicatorRadioButton:
+        {
+            if (QWindowsVistaAnimation *a =
+                    qobject_cast<QWindowsVistaAnimation *>(d->animation(styleObject(option)))){
+                a->paint(painter, option);
+            } else {
+                QWindowsXPStyle::drawPrimitive(element, option, painter, widget);
+            }
+        }
+        break;
+
+    case PE_FrameMenu:
+        {
+            int stateId = option->state & State_Active ? MB_ACTIVE : MB_INACTIVE;
+            XPThemeData theme(widget, painter,
+                              QWindowsXPStylePrivate::MenuTheme,
+                              MENU_POPUPBORDERS, stateId, option->rect);
+            d->drawBackground(theme);
+        }
+        break;
+    case PE_Frame: {
+#ifndef QT_NO_ACCESSIBILITY
+        if (QStyleHelper::isInstanceOf(option->styleObject, QAccessible::EditableText)
+                || QStyleHelper::isInstanceOf(option->styleObject, QAccessible::StaticText) ||
+#else
+        if (
+#endif
+            (widget && widget->inherits("QTextEdit"))) {
+            painter->save();
+            int stateId = ETS_NORMAL;
+            if (!(state & State_Enabled))
+                stateId = ETS_DISABLED;
+            else if (state & State_ReadOnly)
+                stateId = ETS_READONLY;
+            else if (state & State_HasFocus)
+                stateId = ETS_SELECTED;
+            XPThemeData theme(widget, painter,
+                              QWindowsXPStylePrivate::EditTheme,
+                              EP_EDITBORDER_HVSCROLL, stateId, option->rect);
+            // Since EP_EDITBORDER_HVSCROLL does not us borderfill, theme.noContent cannot be used for clipping
+            int borderSize = 1;
+            GetThemeInt(theme.handle(), theme.partId, theme.stateId, TMT_BORDERSIZE, &borderSize);
+            QRegion clipRegion = option->rect;
+            QRegion content = option->rect.adjusted(borderSize, borderSize, -borderSize, -borderSize);
+            clipRegion ^= content;
+            painter->setClipRegion(clipRegion);
+            d->drawBackground(theme);
+            painter->restore();
+        } else {
+            QWindowsXPStyle::drawPrimitive(element, option, painter, widget);
+        }
+    }
+    break;
+
+    case PE_PanelLineEdit:
+        if (const QStyleOptionFrame *panel = qstyleoption_cast<const QStyleOptionFrame *>(option)) {
+            bool isEnabled = option->state & State_Enabled;
+            if (QWindowsXPStylePrivate::isLineEditBaseColorSet(option, widget)) {
+                painter->fillRect(panel->rect, panel->palette.brush(QPalette::Base));
+            } else {
+                int partId = EP_BACKGROUND;
+                int stateId = EBS_NORMAL;
+                if (!isEnabled)
+                    stateId = EBS_DISABLED;
+                else if (state & State_ReadOnly)
+                    stateId = EBS_READONLY;
+                else if (state & State_MouseOver)
+                    stateId = EBS_HOT;
+
+                XPThemeData theme(nullptr, painter, QWindowsXPStylePrivate::EditTheme,
+                                  partId, stateId, rect);
+                if (!theme.isValid()) {
+                    QWindowsStyle::drawPrimitive(element, option, painter, widget);
+                    return;
+                }
+                int bgType;
+                GetThemeEnumValue(theme.handle(), partId, stateId, TMT_BGTYPE, &bgType);
+                if ( bgType == BT_IMAGEFILE ) {
+                    d->drawBackground(theme);
+                } else {
+                    QBrush fillColor = option->palette.brush(QPalette::Base);
+                    if (!isEnabled) {
+                        PROPERTYORIGIN origin = PO_NOTFOUND;
+                        GetThemePropertyOrigin(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;
+                            GetThemeColor(theme.handle(), partId, stateId, TMT_FILLCOLOR, &bgRef);
+                            fillColor = QBrush(qRgb(GetRValue(bgRef), GetGValue(bgRef), GetBValue(bgRef)));
+                        }
+                    }
+                    painter->fillRect(option->rect, fillColor);
+                }
+            }
+            if (panel->lineWidth > 0)
+                proxy()->drawPrimitive(PE_FrameLineEdit, panel, painter, widget);
+            return;
+        }
+        break;
+
+    case PE_FrameLineEdit:
+        if (QWindowsVistaAnimation *anim = qobject_cast<QWindowsVistaAnimation *>(d->animation(styleObject(option)))) {
+            anim->paint(painter, option);
+        } else {
+            QPainter *p = painter;
+            if (QWindowsXPStylePrivate::isItemViewDelegateLineEdit(widget)) {
+                // we try to check if this lineedit is a delegate on a QAbstractItemView-derived class.
+                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;
+            }
+            int stateId = ETS_NORMAL;
+            if (!(state & State_Enabled))
+                stateId = ETS_DISABLED;
+            else if (state & State_ReadOnly)
+                stateId = ETS_READONLY;
+            else if (state & State_MouseOver)
+                stateId = ETS_HOT;
+            else if (state & State_HasFocus)
+                stateId = ETS_SELECTED;
+            XPThemeData theme(widget, painter,
+                              QWindowsXPStylePrivate::EditTheme,
+                              EP_EDITBORDER_NOSCROLL, stateId, option->rect);
+            theme.noContent = true;
+            painter->save();
+            QRegion clipRegion = option->rect;
+            clipRegion -= option->rect.adjusted(2, 2, -2, -2);
+            painter->setClipRegion(clipRegion);
+            d->drawBackground(theme);
+            painter->restore();
+        }
+        break;
+
+    case PE_IndicatorToolBarHandle:
+        {
+            XPThemeData theme;
+            QRect rect;
+            if (option->state & State_Horizontal) {
+                theme = XPThemeData(widget, painter,
+                                    QWindowsXPStylePrivate::RebarTheme,
+                                    RP_GRIPPER, ETS_NORMAL, option->rect.adjusted(0, 1, -2, -2));
+                rect = option->rect.adjusted(0, 1, 0, -2);
+                rect.setWidth(4);
+            } else {
+                theme = XPThemeData(widget, painter, QWindowsXPStylePrivate::RebarTheme,
+                                    RP_GRIPPERVERT, ETS_NORMAL, option->rect.adjusted(0, 1, -2, -2));
+                rect = option->rect.adjusted(1, 0, -1, 0);
+                rect.setHeight(4);
+            }
+            theme.rect = rect;
+            d->drawBackground(theme);
+        }
+        break;
+
+    case PE_IndicatorToolBarSeparator:
+        {
+            QPen pen = painter->pen();
+            int margin = 3;
+            painter->setPen(option->palette.window().color().darker(114));
+            if (option->state & State_Horizontal) {
+                int x1 = option->rect.center().x();
+                painter->drawLine(QPoint(x1, option->rect.top() + margin), QPoint(x1, option->rect.bottom() - margin));
+            } else {
+                int y1 = option->rect.center().y();
+                painter->drawLine(QPoint(option->rect.left() + margin, y1), QPoint(option->rect.right() - margin, y1));
+            }
+            painter->setPen(pen);
+        }
+        break;
+
+    case PE_PanelTipLabel: {
+        XPThemeData theme(widget, painter,
+                          QWindowsXPStylePrivate::ToolTipTheme,
+                          TTP_STANDARD, TTSS_NORMAL, option->rect);
+        d->drawBackground(theme);
+        break;
+    }
+
+    case PE_PanelItemViewItem:
+        {
+            const QStyleOptionViewItem *vopt;
+            bool newStyle = true;
+            QAbstractItemView::SelectionBehavior selectionBehavior = QAbstractItemView::SelectRows;
+            QAbstractItemView::SelectionMode selectionMode = QAbstractItemView::NoSelection;
+            if (const QAbstractItemView *view = qobject_cast<const QAbstractItemView *>(widget)) {
+                newStyle = !qobject_cast<const QTableView*>(view);
+                selectionBehavior = view->selectionBehavior();
+                selectionMode = view->selectionMode();
+#ifndef QT_NO_ACCESSIBILITY
+            } else if (!widget) {
+                newStyle = !QStyleHelper::hasAncestor(option->styleObject, QAccessible::MenuItem) ;
+#endif
+            }
+
+            if (newStyle && (vopt = qstyleoption_cast<const QStyleOptionViewItem *>(option))) {
+                bool selected = vopt->state & QStyle::State_Selected;
+                const bool hover = selectionMode != QAbstractItemView::NoSelection && (vopt->state & QStyle::State_MouseOver);
+                bool active = vopt->state & QStyle::State_Active;
+
+                if (vopt->features & QStyleOptionViewItem::Alternate)
+                    painter->fillRect(vopt->rect, vopt->palette.alternateBase());
+
+                QPalette::ColorGroup cg = vopt->state & QStyle::State_Enabled
+                                          ? QPalette::Normal : QPalette::Disabled;
+                if (cg == QPalette::Normal && !(vopt->state & QStyle::State_Active))
+                    cg = QPalette::Inactive;
+
+                QRect itemRect = subElementRect(QStyle::SE_ItemViewItemFocusRect, option, widget).adjusted(-1, 0, 1, 0);
+                itemRect.setTop(vopt->rect.top());
+                itemRect.setBottom(vopt->rect.bottom());
+
+                QSize sectionSize = itemRect.size();
+                if (vopt->showDecorationSelected)
+                    sectionSize = vopt->rect.size();
+
+                if (selectionBehavior == QAbstractItemView::SelectRows)
+                    sectionSize.setWidth(vopt->rect.width());
+                QPixmap pixmap;
+
+                if (vopt->backgroundBrush.style() != Qt::NoBrush) {
+                    const QPointF oldBrushOrigin = painter->brushOrigin();
+                    painter->setBrushOrigin(vopt->rect.topLeft());
+                    painter->fillRect(vopt->rect, vopt->backgroundBrush);
+                    painter->setBrushOrigin(oldBrushOrigin);
+                }
+
+                if (hover || selected) {
+                    if (sectionSize.width() > 0 && sectionSize.height() > 0) {
+                        QString key = QString::fromLatin1("qvdelegate-%1-%2-%3-%4-%5").arg(sectionSize.width())
+                                                            .arg(sectionSize.height()).arg(selected).arg(active).arg(hover);
+                        if (!QPixmapCache::find(key, &pixmap)) {
+                            pixmap = QPixmap(sectionSize);
+                            pixmap.fill(Qt::transparent);
+
+                            int state;
+                            if (selected && hover)
+                                state = LISS_HOTSELECTED;
+                            else if (selected && !active)
+                                state = LISS_SELECTEDNOTFOCUS;
+                            else if (selected)
+                                state = LISS_SELECTED;
+                            else
+                                state = LISS_HOT;
+
+                            QPainter pixmapPainter(&pixmap);
+                            XPThemeData theme(widget, &pixmapPainter,
+                                              QWindowsXPStylePrivate::VistaTreeViewTheme,
+                                LVP_LISTITEM, state, QRect(0, 0, sectionSize.width(), sectionSize.height()));
+                            if (theme.isValid()) {
+                                d->drawBackground(theme);
+                            } else {
+                                QWindowsXPStyle::drawPrimitive(PE_PanelItemViewItem, option, painter, widget);
+                                break;
+                            }
+                            QPixmapCache::insert(key, pixmap);
+                        }
+                    }
+
+                    if (vopt->showDecorationSelected) {
+                        const int frame = 2; //Assumes a 2 pixel pixmap border
+                        QRect srcRect = QRect(0, 0, sectionSize.width(), sectionSize.height());
+                        QRect pixmapRect = vopt->rect;
+                        bool reverse = vopt->direction == Qt::RightToLeft;
+                        bool leftSection = vopt->viewItemPosition == QStyleOptionViewItem::Beginning;
+                        bool rightSection = vopt->viewItemPosition == QStyleOptionViewItem::End;
+                        if (vopt->viewItemPosition == QStyleOptionViewItem::OnlyOne
+                            || vopt->viewItemPosition == QStyleOptionViewItem::Invalid)
+                            painter->drawPixmap(pixmapRect.topLeft(), pixmap);
+                        else if (reverse ? rightSection : leftSection){
+                            painter->drawPixmap(QRect(pixmapRect.topLeft(),
+                                                QSize(frame, pixmapRect.height())), pixmap,
+                                                QRect(QPoint(0, 0), QSize(frame, pixmapRect.height())));
+                            painter->drawPixmap(pixmapRect.adjusted(frame, 0, 0, 0),
+                                                pixmap, srcRect.adjusted(frame, 0, -frame, 0));
+                        } else if (reverse ? leftSection : rightSection) {
+                            painter->drawPixmap(QRect(pixmapRect.topRight() - QPoint(frame - 1, 0),
+                                                QSize(frame, pixmapRect.height())), pixmap,
+                                                QRect(QPoint(pixmapRect.width() - frame, 0),
+                                                QSize(frame, pixmapRect.height())));
+                            painter->drawPixmap(pixmapRect.adjusted(0, 0, -frame, 0),
+                                                pixmap, srcRect.adjusted(frame, 0, -frame, 0));
+                        } else if (vopt->viewItemPosition == QStyleOptionViewItem::Middle)
+                            painter->drawPixmap(pixmapRect, pixmap,
+                                                srcRect.adjusted(frame, 0, -frame, 0));
+                    } else {
+                        if (vopt->text.isEmpty() && vopt->icon.isNull())
+                            break;
+                        painter->drawPixmap(itemRect.topLeft(), pixmap);
+                    }
+                }
+            } else {
+                QWindowsXPStyle::drawPrimitive(element, option, painter, widget);
+            }
+            break;
+        }
+    case PE_Widget:
+        {
+#if QT_CONFIG(dialogbuttonbox)
+            const QDialogButtonBox *buttonBox = nullptr;
+
+            if (qobject_cast<const QMessageBox *> (widget))
+                buttonBox = widget->findChild<const QDialogButtonBox *>(QLatin1String("qt_msgbox_buttonbox"));
+#if QT_CONFIG(inputdialog)
+            else if (qobject_cast<const QInputDialog *> (widget))
+                buttonBox = widget->findChild<const QDialogButtonBox *>(QLatin1String("qt_inputdlg_buttonbox"));
+#endif // QT_CONFIG(inputdialog)
+
+            if (buttonBox) {
+                //draw white panel part
+                XPThemeData theme(widget, painter,
+                                  QWindowsXPStylePrivate::TaskDialogTheme,
+                                  TDLG_PRIMARYPANEL, 0, option->rect);
+                QRect toprect = option->rect;
+                toprect.setBottom(buttonBox->geometry().top());
+                theme.rect = toprect;
+                d->drawBackground(theme);
+
+                //draw bottom panel part
+                QRect buttonRect = option->rect;
+                buttonRect.setTop(buttonBox->geometry().top());
+                theme.rect = buttonRect;
+                theme.partId = TDLG_SECONDARYPANEL;
+                d->drawBackground(theme);
+            }
+#endif
+        }
+        break;
+    default:
+        QWindowsXPStyle::drawPrimitive(element, option, painter, widget);
+        break;
+    }
+}
+
+
+/*!
+ \internal
+
+ see drawPrimitive for comments on the animation support
+ */
+void QWindowsVistaStyle::drawControl(ControlElement element, const QStyleOption *option,
+                                  QPainter *painter, const QWidget *widget) const
+{
+    QWindowsVistaStylePrivate *d = const_cast<QWindowsVistaStylePrivate*>(d_func());
+
+    if (!QWindowsVistaStylePrivate::useVista()) {
+        QWindowsStyle::drawControl(element, option, painter, widget);
+        return;
+    }
+
+    bool selected = option->state & State_Selected;
+    bool pressed = option->state & State_Sunken;
+    bool disabled = !(option->state & State_Enabled);
+
+    int state = option->state;
+    int themeNumber  = -1;
+
+    QRect rect(option->rect);
+    State flags = option->state;
+    int partId = 0;
+    int stateId = 0;
+
+    if (d->transitionsEnabled() && canAnimate(option))
+    {
+        if (element == CE_PushButtonBevel) {
+            QRect oldRect;
+            QRect newRect;
+
+            QObject *styleObject = option->styleObject;
+
+            int oldState = styleObject->property("_q_stylestate").toInt();
+            oldRect = styleObject->property("_q_stylerect").toRect();
+            newRect = option->rect;
+            styleObject->setProperty("_q_stylestate", int(option->state));
+            styleObject->setProperty("_q_stylerect", option->rect);
+
+            bool wasDefault = false;
+            bool isDefault = false;
+            if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton *>(option)) {
+                wasDefault = styleObject->property("_q_isdefault").toBool();
+                isDefault = button->features & QStyleOptionButton::DefaultButton;
+                styleObject->setProperty("_q_isdefault", isDefault);
+            }
+
+            bool doTransition = ((state & State_Sunken)     != (oldState & State_Sunken) ||
+                    (state & State_On)         != (oldState & State_On)     ||
+                    (state & State_MouseOver)  != (oldState & State_MouseOver));
+
+            if (oldRect != newRect || (wasDefault && !isDefault)) {
+                doTransition = false;
+                d->stopAnimation(styleObject);
+            }
+
+            if (doTransition) {
+                styleObject->setProperty("_q_no_animation", true);
+
+                QWindowsVistaTransition *t = new QWindowsVistaTransition(styleObject);
+                QWindowsVistaAnimation *anim = qobject_cast<QWindowsVistaAnimation *>(d->animation(styleObject));
+                QStyleOption *styleOption = clonedAnimationStyleOption(option);
+                styleOption->state = QStyle::State(oldState);
+
+                QImage startImage = createAnimationBuffer(option, widget);
+                QPainter startPainter(&startImage);
+
+                // Use current state of existing animation if already one is running
+                if (!anim) {
+                    proxy()->drawControl(element, styleOption, &startPainter, widget);
+                } else {
+                    anim->paint(&startPainter, styleOption);
+                    d->stopAnimation(styleObject);
+                }
+
+                t->setStartImage(startImage);
+                QImage endImage = createAnimationBuffer(option, widget);
+                QPainter endPainter(&endImage);
+                styleOption->state = option->state;
+                proxy()->drawControl(element, styleOption, &endPainter, widget);
+                t->setEndImage(endImage);
+
+
+                DWORD duration = 0;
+                const HTHEME theme = OpenThemeData(nullptr, L"Button");
+
+                int fromState = buttonStateId(oldState, BP_PUSHBUTTON);
+                int toState = buttonStateId(option->state, BP_PUSHBUTTON);
+                if (GetThemeTransitionDuration(theme, BP_PUSHBUTTON, fromState, toState, TMT_TRANSITIONDURATIONS, &duration) == S_OK)
+                    t->setDuration(int(duration));
+                else
+                    t->setDuration(0);
+                t->setStartTime(QTime::currentTime());
+                styleObject->setProperty("_q_no_animation", false);
+
+                deleteClonedAnimationStyleOption(styleOption);
+                d->startAnimation(t);
+            }
+
+            QWindowsVistaAnimation *anim = qobject_cast<QWindowsVistaAnimation *>(d->animation(styleObject));
+            if (anim) {
+                anim->paint(painter, option);
+                return;
+            }
+
+        }
+    }
+    switch (element) {
+    case CE_PushButtonBevel:
+        if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option))
+        {
+            themeNumber = QWindowsXPStylePrivate::ButtonTheme;
+            partId = BP_PUSHBUTTON;
+            if (btn->features & QStyleOptionButton::CommandLinkButton)
+                partId = BP_COMMANDLINK;
+            bool justFlat = (btn->features & QStyleOptionButton::Flat) && !(flags & (State_On|State_Sunken));
+            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 && (state & State_Active))
+                stateId = PBS_DEFAULTED;
+            else
+                stateId = PBS_NORMAL;
+
+            if (!justFlat) {
+
+                if (d->transitionsEnabled() && (btn->features & QStyleOptionButton::DefaultButton) &&
+                        !(state & (State_Sunken | State_On)) && !(state & State_MouseOver) &&
+                        (state & State_Enabled) && (state & State_Active))
+                {
+                    QWindowsVistaAnimation *anim = qobject_cast<QWindowsVistaAnimation *>(d->animation(styleObject(option)));
+
+                    if (!anim) {
+                        QImage startImage = createAnimationBuffer(option, widget);
+                        QImage alternateImage = createAnimationBuffer(option, widget);
+
+                        QWindowsVistaPulse *pulse = new QWindowsVistaPulse(styleObject(option));
+
+                        QPainter startPainter(&startImage);
+                        stateId = PBS_DEFAULTED;
+                        XPThemeData theme(widget, &startPainter, themeNumber, partId, stateId, rect);
+                        d->drawBackground(theme);
+
+                        QPainter alternatePainter(&alternateImage);
+                        theme.stateId = PBS_DEFAULTED_ANIMATING;
+                        theme.painter = &alternatePainter;
+                        d->drawBackground(theme);
+                        pulse->setStartImage(startImage);
+                        pulse->setEndImage(alternateImage);
+                        pulse->setStartTime(QTime::currentTime());
+                        pulse->setDuration(2000);
+                        d->startAnimation(pulse);
+                        anim = pulse;
+                    }
+
+                    if (anim)
+                        anim->paint(painter, option);
+                    else {
+                        XPThemeData theme(widget, painter, themeNumber, partId, stateId, rect);
+                        d->drawBackground(theme);
+                    }
+                }
+                else {
+                    XPThemeData theme(widget, painter, themeNumber, partId, stateId, rect);
+                    d->drawBackground(theme);
+                }
+            }
+
+            if (btn->features & QStyleOptionButton::HasMenu) {
+                int mbiw = 0, mbih = 0;
+                XPThemeData theme(widget, nullptr, QWindowsXPStylePrivate::ToolBarTheme,
+                                  TP_DROPDOWNBUTTON);
+                if (theme.isValid()) {
+                    const QSizeF size = theme.size() * QStyleHelper::dpiScaled(1, option);
+                    if (!size.isEmpty()) {
+                        mbiw = qRound(size.width());
+                        mbih = qRound(size.height());
+                    }
+                }
+                QRect ir = subElementRect(SE_PushButtonContents, option, nullptr);
+                QStyleOptionButton newBtn = *btn;
+                newBtn.rect = QStyle::visualRect(option->direction, option->rect,
+                                                QRect(ir.right() - mbiw - 2,
+                                                      option->rect.top() + (option->rect.height()/2) - (mbih/2),
+                                                      mbiw + 1, mbih + 1));
+                proxy()->drawPrimitive(PE_IndicatorArrowDown, &newBtn, painter, widget);
+            }
+            return;
+        }
+        break;
+
+    case CE_ProgressBarContents:
+        if (const QStyleOptionProgressBar *bar
+                = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {
+            bool isIndeterminate = (bar->minimum == 0 && bar->maximum == 0);
+            const bool vertical = bar->orientation == Qt::Vertical;
+            const bool inverted = bar->invertedAppearance;
+
+            if (isIndeterminate || (bar->progress > 0 && (bar->progress < bar->maximum) && d->transitionsEnabled())) {
+                if (!d->animation(styleObject(option)))
+                    d->startAnimation(new QProgressStyleAnimation(d->animationFps, styleObject(option)));
+            } else {
+                d->stopAnimation(styleObject(option));
+            }
+
+            XPThemeData theme(widget, painter,
+                              QWindowsXPStylePrivate::ProgressTheme,
+                              vertical ? PP_FILLVERT : PP_FILL);
+            theme.rect = option->rect;
+            bool reverse = (bar->direction == Qt::LeftToRight && inverted) || (bar->direction == Qt::RightToLeft && !inverted);
+            QTime current = QTime::currentTime();
+
+            if (isIndeterminate) {
+                if (QProgressStyleAnimation *a = qobject_cast<QProgressStyleAnimation *>(d->animation(styleObject(option)))) {
+                    int glowSize = 120;
+                    int animationWidth = glowSize * 2 + (vertical ? theme.rect.height() : theme.rect.width());
+                    int animOffset = a->startTime().msecsTo(current) / 4;
+                    if (animOffset > animationWidth)
+                        a->setStartTime(QTime::currentTime());
+                    painter->save();
+                    painter->setClipRect(theme.rect);
+                    QRect animRect;
+                    QSize pixmapSize(14, 14);
+                    if (vertical) {
+                        animRect = QRect(theme.rect.left(),
+                                         inverted ? rect.top() - glowSize + animOffset :
+                                                    rect.bottom() + glowSize - animOffset,
+                                         rect.width(), glowSize);
+                         pixmapSize.setHeight(animRect.height());
+                    } else {
+                        animRect = QRect(rect.left() - glowSize + animOffset,
+                                         rect.top(), glowSize, rect.height());
+                        animRect = QStyle::visualRect(reverse ? Qt::RightToLeft : Qt::LeftToRight,
+                                                                option->rect, animRect);
+                        pixmapSize.setWidth(animRect.width());
+                    }
+                    QString name = QString::fromLatin1("qiprogress-%1-%2").arg(pixmapSize.width()).arg(pixmapSize.height());
+                    QPixmap pixmap;
+                    if (!QPixmapCache::find(name, &pixmap)) {
+                        QImage image(pixmapSize, QImage::Format_ARGB32);
+                        image.fill(Qt::transparent);
+                        QPainter imagePainter(&image);
+                        theme.painter = &imagePainter;
+                        theme.partId = vertical ? PP_FILLVERT : PP_FILL;
+                        theme.rect = QRect(QPoint(0,0), animRect.size());
+                        QLinearGradient alphaGradient(0, 0, vertical ? 0 : image.width(),
+                                                      vertical ? image.height() : 0);
+                        alphaGradient.setColorAt(0, QColor(0, 0, 0, 0));
+                        alphaGradient.setColorAt(0.5, QColor(0, 0, 0, 220));
+                        alphaGradient.setColorAt(1, QColor(0, 0, 0, 0));
+                        imagePainter.fillRect(image.rect(), alphaGradient);
+                        imagePainter.setCompositionMode(QPainter::CompositionMode_SourceIn);
+                        d->drawBackground(theme);
+                        imagePainter.end();
+                        pixmap = QPixmap::fromImage(image);
+                        QPixmapCache::insert(name, pixmap);
+                    }
+                    painter->drawPixmap(animRect, pixmap);
+                    painter->restore();
+                }
+            }
+            else {
+                qint64 progress = qMax<qint64>(bar->progress, bar->minimum); // workaround for bug in QProgressBar
+
+                if (vertical) {
+                    int maxHeight = option->rect.height();
+                    int minHeight = 0;
+                    double vc6_workaround = ((progress - qint64(bar->minimum)) / qMax(double(1.0), double(qint64(bar->maximum) - qint64(bar->minimum))) * maxHeight);
+                    int height = isIndeterminate ? maxHeight: qMax(int(vc6_workaround), minHeight);
+                    theme.rect.setHeight(height);
+                    if (!inverted)
+                        theme.rect.moveTop(rect.height() - theme.rect.height());
+                } else {
+                    int maxWidth = option->rect.width();
+                    int minWidth = 0;
+                    double vc6_workaround = ((progress - qint64(bar->minimum)) / qMax(double(1.0), double(qint64(bar->maximum) - qint64(bar->minimum))) * maxWidth);
+                    int width = isIndeterminate ? maxWidth : qMax(int(vc6_workaround), minWidth);
+                    theme.rect.setWidth(width);
+                    theme.rect = QStyle::visualRect(reverse ? Qt::RightToLeft : Qt::LeftToRight,
+                                                              option->rect, theme.rect);
+                }
+                d->drawBackground(theme);
+
+                if (QProgressStyleAnimation *a = qobject_cast<QProgressStyleAnimation *>(d->animation(styleObject(option)))) {
+                    int glowSize = 140;
+                    int animationWidth = glowSize * 2 + (vertical ? theme.rect.height() : theme.rect.width());
+                    int animOffset = a->startTime().msecsTo(current) / 4;
+                    theme.partId = vertical ? PP_MOVEOVERLAYVERT : PP_MOVEOVERLAY;
+                    if (animOffset > animationWidth) {
+                        if (bar->progress < bar->maximum)
+                            a->setStartTime(QTime::currentTime());
+                        else
+                            d->stopAnimation(styleObject(option)); //we stop the glow motion only after it has
+                                                                   //moved out of view
+                    }
+                    painter->save();
+                    painter->setClipRect(theme.rect);
+                    if (vertical) {
+                        theme.rect = QRect(theme.rect.left(),
+                                           inverted ? rect.top() - glowSize + animOffset :
+                                                      rect.bottom() + glowSize - animOffset,
+                                           rect.width(), glowSize);
+                    } else {
+                        theme.rect = QRect(rect.left() - glowSize + animOffset,rect.top(), glowSize, rect.height());
+                        theme.rect = QStyle::visualRect(reverse ? Qt::RightToLeft : Qt::LeftToRight, option->rect, theme.rect);
+                    }
+                    d->drawBackground(theme);
+                    painter->restore();
+                }
+            }
+        }
+        break;
+
+    case CE_MenuBarItem:
+        {
+
+        if (const QStyleOptionMenuItem *mbi = qstyleoption_cast<const QStyleOptionMenuItem *>(option))
+        {
+            if (mbi->menuItemType == QStyleOptionMenuItem::DefaultItem)
+                break;
+
+            QPalette::ColorRole textRole = disabled ? QPalette::Text : QPalette::ButtonText;
+            QPixmap pix = mbi->icon.pixmap(proxy()->pixelMetric(PM_SmallIconSize, option, widget), QIcon::Normal);
+
+            int alignment = Qt::AlignCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;
+            if (!proxy()->styleHint(SH_UnderlineShortcut, mbi, widget))
+                alignment |= Qt::TextHideMnemonic;
+
+            if (widget && mbi->palette.color(QPalette::Window) != Qt::transparent) { // Not needed for QtQuick Controls
+                //The rect adjustment is a workaround for the menu not really filling its background.
+                XPThemeData theme(widget, painter,
+                                  QWindowsXPStylePrivate::MenuTheme,
+                                  MENU_BARBACKGROUND, 0, option->rect.adjusted(-1, 0, 2, 1));
+                d->drawBackground(theme);
+            }
+
+            int stateId = MBI_NORMAL;
+            if (disabled)
+                stateId = MBI_DISABLED;
+            else if (pressed)
+                stateId = MBI_PUSHED;
+            else if (selected)
+                stateId = MBI_HOT;
+
+            XPThemeData theme2(widget, painter,
+                               QWindowsXPStylePrivate::MenuTheme,
+                               MENU_BARITEM, stateId, option->rect);
+            d->drawBackground(theme2);
+
+            if (!pix.isNull())
+                drawItemPixmap(painter, mbi->rect, alignment, pix);
+            else
+                drawItemText(painter, mbi->rect, alignment, mbi->palette, mbi->state & State_Enabled, mbi->text, textRole);
+        }
+    }
+    break;
+#if QT_CONFIG(menu)
+    case CE_MenuItem:
+        if (const QStyleOptionMenuItem *menuitem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
+            // windows always has a check column, regardless whether we have an icon or not
+            const qreal factor = QWindowsXPStylePrivate::nativeMetricScaleFactor(widget);
+            int checkcol = qRound(qreal(25) * factor);
+            const int gutterWidth = qRound(qreal(3) * factor);
+            {
+                XPThemeData theme(widget, nullptr, QWindowsXPStylePrivate::MenuTheme,
+                                  MENU_POPUPCHECKBACKGROUND, MBI_HOT);
+                XPThemeData themeSize = theme;
+                themeSize.partId = MENU_POPUPCHECK;
+                themeSize.stateId = 0;
+                const QSizeF size = themeSize.size() * QWindowsStylePrivate::nativeMetricScaleFactor(widget);
+                const QMarginsF margins = themeSize.margins() * QWindowsStylePrivate::nativeMetricScaleFactor(widget);
+                checkcol = qMax(menuitem->maxIconWidth, qRound(gutterWidth + size.width() + margins.left() + margins.right()));
+            }
+            QRect rect = option->rect;
+
+            //draw vertical menu line
+            if (option->direction == Qt::LeftToRight)
+                checkcol += rect.x();
+            QPoint p1 = QStyle::visualPos(option->direction, menuitem->rect, QPoint(checkcol, rect.top()));
+            QPoint p2 = QStyle::visualPos(option->direction, menuitem->rect, QPoint(checkcol, rect.bottom()));
+            QRect gutterRect(p1.x(), p1.y(), gutterWidth, p2.y() - p1.y() + 1);
+            XPThemeData theme2(widget, painter, QWindowsXPStylePrivate::MenuTheme,
+                               MENU_POPUPGUTTER, stateId, gutterRect);
+            d->drawBackground(theme2);
+
+            int x, y, w, h;
+            menuitem->rect.getRect(&x, &y, &w, &h);
+            int tab = menuitem->tabWidth;
+            bool dis = !(menuitem->state & State_Enabled);
+            bool checked = menuitem->checkType != QStyleOptionMenuItem::NotCheckable
+                            ? menuitem->checked : false;
+            bool act = menuitem->state & State_Selected;
+
+            if (menuitem->menuItemType == QStyleOptionMenuItem::Separator) {
+                int yoff = y-2 + h / 2;
+                const int separatorSize = qRound(qreal(6) * QWindowsStylePrivate::nativeMetricScaleFactor(widget));
+                QPoint p1 = QPoint(x + checkcol, yoff);
+                QPoint p2 = QPoint(x + w + separatorSize, yoff);
+                stateId = MBI_HOT;
+                QRect subRect(p1.x() + (gutterWidth - menuitem->rect.x()), p1.y(),
+                              p2.x() - p1.x(), separatorSize);
+                subRect  = QStyle::visualRect(option->direction, option->rect, subRect );
+                XPThemeData theme2(widget, painter,
+                                   QWindowsXPStylePrivate::MenuTheme,
+                                   MENU_POPUPSEPARATOR, stateId, subRect);
+                d->drawBackground(theme2);
+                return;
+            }
+
+            QRect vCheckRect = visualRect(option->direction, menuitem->rect, QRect(menuitem->rect.x(),
+                                          menuitem->rect.y(), checkcol - (gutterWidth + menuitem->rect.x()), menuitem->rect.height()));
+
+            if (act) {
+                stateId = dis ? MBI_DISABLED : MBI_HOT;
+                XPThemeData theme2(widget, painter,
+                                   QWindowsXPStylePrivate::MenuTheme,
+                                   MENU_POPUPITEM, stateId, option->rect);
+                d->drawBackground(theme2);
+            }
+
+            if (checked) {
+                XPThemeData theme(widget, painter,
+                                  QWindowsXPStylePrivate::MenuTheme,
+                                  MENU_POPUPCHECKBACKGROUND,
+                                  menuitem->icon.isNull() ? MBI_HOT : MBI_PUSHED, vCheckRect);
+                XPThemeData themeSize = theme;
+                themeSize.partId = MENU_POPUPCHECK;
+                themeSize.stateId = 0;
+                const QSizeF size = themeSize.size() * QWindowsStylePrivate::nativeMetricScaleFactor(widget);
+                const QMarginsF margins = themeSize.margins() * QWindowsStylePrivate::nativeMetricScaleFactor(widget);
+                QRect checkRect(0, 0, qRound(size.width() + margins.left() + margins.right()),
+                                qRound(size.height() + margins.bottom() + margins.top()));
+                checkRect.moveCenter(vCheckRect.center());
+                theme.rect = checkRect;
+
+                d->drawBackground(theme);
+
+                if (menuitem->icon.isNull()) {
+                    checkRect = QRect(QPoint(0, 0), size.toSize());
+                    checkRect.moveCenter(theme.rect.center());
+                    theme.rect = checkRect;
+
+                    theme.partId = MENU_POPUPCHECK;
+                    bool bullet = menuitem->checkType & QStyleOptionMenuItem::Exclusive;
+                    if (dis)
+                        theme.stateId = bullet ? MC_BULLETDISABLED: MC_CHECKMARKDISABLED;
+                    else
+                        theme.stateId = bullet ? MC_BULLETNORMAL: MC_CHECKMARKNORMAL;
+                    d->drawBackground(theme);
+                }
+            }
+
+            if (!menuitem->icon.isNull()) {
+                QIcon::Mode mode = dis ? QIcon::Disabled : QIcon::Normal;
+                if (act && !dis)
+                    mode = QIcon::Active;
+                QPixmap pixmap;
+                if (checked)
+                    pixmap = menuitem->icon.pixmap(proxy()->pixelMetric(PM_SmallIconSize, option, widget), mode, QIcon::On);
+                else
+                    pixmap = menuitem->icon.pixmap(proxy()->pixelMetric(PM_SmallIconSize, option, widget), mode);
+                const int pixw = pixmap.width() / pixmap.devicePixelRatio();
+                const int pixh = pixmap.height() / pixmap.devicePixelRatio();
+                QRect pmr(0, 0, pixw, pixh);
+                pmr.moveCenter(vCheckRect.center());
+                painter->setPen(menuitem->palette.text().color());
+                painter->drawPixmap(pmr.topLeft(), pixmap);
+            }
+
+            painter->setPen(menuitem->palette.buttonText().color());
+
+            const QColor textColor = menuitem->palette.text().color();
+            if (dis)
+                painter->setPen(textColor);
+
+            int xm = windowsItemFrame + checkcol + windowsItemHMargin + (gutterWidth - menuitem->rect.x()) - 1;
+            int xpos = menuitem->rect.x() + xm;
+            QRect textRect(xpos, y + windowsItemVMargin, w - xm - windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin);
+            QRect vTextRect = visualRect(option->direction, menuitem->rect, textRect);
+            QString s = menuitem->text;
+            if (!s.isEmpty()) {    // draw text
+                painter->save();
+                int t = s.indexOf(QLatin1Char('\t'));
+                int text_flags = Qt::AlignVCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;
+                if (!proxy()->styleHint(SH_UnderlineShortcut, menuitem, widget))
+                    text_flags |= Qt::TextHideMnemonic;
+                text_flags |= Qt::AlignLeft;
+                if (t >= 0) {
+                    QRect vShortcutRect = visualRect(option->direction, menuitem->rect,
+                    QRect(textRect.topRight(), QPoint(menuitem->rect.right(), textRect.bottom())));
+                    painter->drawText(vShortcutRect, text_flags, s.mid(t + 1));
+                    s = s.left(t);
+                }
+                QFont font = menuitem->font;
+                if (menuitem->menuItemType == QStyleOptionMenuItem::DefaultItem)
+                    font.setBold(true);
+                painter->setFont(font);
+                painter->setPen(textColor);
+                painter->drawText(vTextRect, text_flags, s.left(t));
+                painter->restore();
+            }
+            if (menuitem->menuItemType == QStyleOptionMenuItem::SubMenu) {// draw sub menu arrow
+                int dim = (h - 2 * windowsItemFrame) / 2;
+                PrimitiveElement arrow;
+                arrow = (option->direction == Qt::RightToLeft) ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight;
+                xpos = x + w - windowsArrowHMargin - windowsItemFrame - dim;
+                QRect  vSubMenuRect = visualRect(option->direction, menuitem->rect, QRect(xpos, y + h / 2 - dim / 2, dim, dim));
+                QStyleOptionMenuItem newMI = *menuitem;
+                newMI.rect = vSubMenuRect;
+                newMI.state = dis ? State_None : State_Enabled;
+                proxy()->drawPrimitive(arrow, &newMI, painter, widget);
+            }
+        }
+        break;
+#endif // QT_CONFIG(menu)
+    case CE_HeaderSection:
+        if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
+            partId = HP_HEADERITEM;
+            if (flags & State_Sunken)
+                stateId = HIS_PRESSED;
+            else if (flags & State_MouseOver)
+                stateId = HIS_HOT;
+            else
+                stateId = HIS_NORMAL;
+
+            if (header->sortIndicator != QStyleOptionHeader::None)
+                stateId += 3;
+
+            XPThemeData theme(widget, painter,
+                              QWindowsXPStylePrivate::HeaderTheme,
+                              partId, stateId, option->rect);
+            d->drawBackground(theme);
+        }
+        break;
+    case CE_MenuBarEmptyArea:
+        {
+            stateId = MBI_NORMAL;
+            if (!(state & State_Enabled))
+                stateId = MBI_DISABLED;
+            XPThemeData theme(widget, painter,
+                              QWindowsXPStylePrivate::MenuTheme,
+                              MENU_BARBACKGROUND, stateId, option->rect);
+            d->drawBackground(theme);
+        }
+        break;
+    case CE_ToolBar:
+        if (const QStyleOptionToolBar *toolbar = qstyleoption_cast<const QStyleOptionToolBar *>(option)) {
+            QPalette pal = option->palette;
+            pal.setColor(QPalette::Dark, option->palette.window().color().darker(130));
+            QStyleOptionToolBar copyOpt = *toolbar;
+            copyOpt.palette = pal;
+            QWindowsStyle::drawControl(element, &copyOpt, painter, widget);
+        }
+        break;
+#if QT_CONFIG(dockwidget)
+    case CE_DockWidgetTitle:
+        if (const QStyleOptionDockWidget *dwOpt = qstyleoption_cast<const QStyleOptionDockWidget *>(option)) {
+            const QDockWidget *dockWidget = qobject_cast<const QDockWidget *>(widget);
+            QRect rect = option->rect;
+            if (dockWidget && dockWidget->isFloating()) {
+                QWindowsXPStyle::drawControl(element, option, painter, widget);
+                break; //otherwise fall through
+            }
+
+            const bool verticalTitleBar = dwOpt->verticalTitleBar;
+
+            if (verticalTitleBar) {
+                rect = rect.transposed();
+
+                painter->translate(rect.left() - 1, rect.top() + rect.width());
+                painter->rotate(-90);
+                painter->translate(-rect.left() + 1, -rect.top());
+            }
+
+            painter->setBrush(option->palette.window().color().darker(110));
+            painter->setPen(option->palette.window().color().darker(130));
+            painter->drawRect(rect.adjusted(0, 1, -1, -3));
+
+            int buttonMargin = 4;
+            int mw = proxy()->pixelMetric(QStyle::PM_DockWidgetTitleMargin, dwOpt, widget);
+            int fw = proxy()->pixelMetric(PM_DockWidgetFrameWidth, dwOpt, widget);
+            const QDockWidget *dw = qobject_cast<const QDockWidget *>(widget);
+            bool isFloating = dw && dw->isFloating();
+
+            QRect r = option->rect.adjusted(0, 2, -1, -3);
+            QRect titleRect = r;
+
+            if (dwOpt->closable) {
+                QSize sz = proxy()->standardIcon(QStyle::SP_TitleBarCloseButton, dwOpt, widget).actualSize(QSize(10, 10));
+                titleRect.adjust(0, 0, -sz.width() - mw - buttonMargin, 0);
+            }
+
+            if (dwOpt->floatable) {
+                QSize sz = proxy()->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 && widget->windowIcon().cacheKey() != QApplication::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 (!dwOpt->title.isEmpty()) {
+                QString titleText = painter->fontMetrics().elidedText(dwOpt->title, Qt::ElideRight,
+                                                                      verticalTitleBar ? titleRect.height() : titleRect.width());
+                const int indent = 4;
+                drawItemText(painter, rect.adjusted(indent + 1, 1, -indent - 1, -1),
+                                Qt::AlignLeft | Qt::AlignVCenter | Qt::TextShowMnemonic,
+                                dwOpt->palette,
+                                dwOpt->state & State_Enabled, titleText,
+                                QPalette::WindowText);
+                }
+            }
+            break;
+#endif // QT_CONFIG(dockwidget)
+#if QT_CONFIG(itemviews)
+    case CE_ItemViewItem:
+        {
+            const QStyleOptionViewItem *vopt;
+
+            const QAbstractItemView *view = qobject_cast<const QAbstractItemView *>(widget);
+            bool newStyle = true;
+
+            if (qobject_cast<const QTableView*>(widget))
+                newStyle = false;
+
+            if (newStyle && view && (vopt = qstyleoption_cast<const QStyleOptionViewItem *>(option))) {
+                /*
+                // We cannot currently get the correct selection color for "explorer style" views
+                COLORREF cref = 0;
+                XPThemeData theme(d->treeViewHelper(), 0, QLatin1String("LISTVIEW"), 0, 0);
+                unsigned int res = GetThemeColor(theme.handle(), LVP_LISTITEM, LISS_SELECTED, TMT_TEXTCOLOR, &cref);
+                QColor textColor(GetRValue(cref), GetGValue(cref), GetBValue(cref));
+                */
+                QPalette palette = vopt->palette;
+                palette.setColor(QPalette::All, QPalette::HighlightedText, palette.color(QPalette::Active, QPalette::Text));
+                // Note that setting a saturated color here results in ugly XOR colors in the focus rect
+                palette.setColor(QPalette::All, QPalette::Highlight, palette.base().color().darker(108));
+                QStyleOptionViewItem adjustedOption = *vopt;
+                adjustedOption.palette = palette;
+                // We hide the  focusrect in singleselection as it is not required
+                if ((view->selectionMode() == QAbstractItemView::SingleSelection)
+                    && !(vopt->state & State_KeyboardFocusChange))
+                adjustedOption.state &= ~State_HasFocus;
+                QWindowsXPStyle::drawControl(element, &adjustedOption, painter, widget);
+            } else {
+                QWindowsXPStyle::drawControl(element, option, painter, widget);
+            }
+            break;
+        }
+#endif // QT_CONFIG(itemviews)
+#if QT_CONFIG(combobox)
+    case CE_ComboBoxLabel:
+        QCommonStyle::drawControl(element, option, painter, widget);
+        break;
+#endif // QT_CONFIG(combobox)
+    default:
+        QWindowsXPStyle::drawControl(element, option, painter, widget);
+        break;
+    }
+}
+
+/*!
+  \internal
+
+  see drawPrimitive for comments on the animation support
+
+ */
+void QWindowsVistaStyle::drawComplexControl(ComplexControl control, const QStyleOptionComplex *option,
+                                         QPainter *painter, const QWidget *widget) const
+{
+    QWindowsVistaStylePrivate *d = const_cast<QWindowsVistaStylePrivate*>(d_func());
+    if (!QWindowsVistaStylePrivate::useVista()) {
+        QWindowsStyle::drawComplexControl(control, option, painter, widget);
+        return;
+    }
+
+    State state = option->state;
+    SubControls sub = option->subControls;
+    QRect r = option->rect;
+
+    int partId = 0;
+    int stateId = 0;
+
+    State flags = option->state;
+    if (widget && widget->testAttribute(Qt::WA_UnderMouse) && widget->isActiveWindow())
+        flags |= State_MouseOver;
+
+    if (d->transitionsEnabled() && canAnimate(option))
+    {
+
+        if (control == CC_ScrollBar || control == CC_SpinBox || control == CC_ComboBox) {
+
+            QObject *styleObject = option->styleObject; // Can be widget or qquickitem
+
+            int oldState = styleObject->property("_q_stylestate").toInt();
+            int oldActiveControls = styleObject->property("_q_stylecontrols").toInt();
+
+            QRect oldRect = styleObject->property("_q_stylerect").toRect();
+            styleObject->setProperty("_q_stylestate", int(option->state));
+            styleObject->setProperty("_q_stylecontrols", int(option->activeSubControls));
+            styleObject->setProperty("_q_stylerect", option->rect);
+
+            bool doTransition = ((state & State_Sunken)     != (oldState & State_Sunken)    ||
+                                 (state & State_On)         != (oldState & State_On)        ||
+                                 (state & State_MouseOver)  != (oldState & State_MouseOver) ||
+                                  oldActiveControls         != int(option->activeSubControls));
+
+            if (qstyleoption_cast<const QStyleOptionSlider *>(option)) {
+                QRect oldSliderPos = styleObject->property("_q_stylesliderpos").toRect();
+                QRect currentPos = proxy()->subControlRect(CC_ScrollBar, option, SC_ScrollBarSlider, widget);
+                styleObject->setProperty("_q_stylesliderpos", currentPos);
+                if (oldSliderPos != currentPos) {
+                    doTransition = false;
+                    d->stopAnimation(styleObject);
+                }
+            } else if (control == CC_SpinBox) {
+                //spinboxes have a transition when focus changes
+                if (!doTransition)
+                    doTransition = (state & State_HasFocus) != (oldState & State_HasFocus);
+            }
+
+            if (oldRect != option->rect) {
+                doTransition = false;
+                d->stopAnimation(styleObject);
+            }
+
+            if (doTransition) {
+                QImage startImage = createAnimationBuffer(option, widget);
+                QPainter startPainter(&startImage);
+
+                QImage endImage = createAnimationBuffer(option, widget);
+                QPainter endPainter(&endImage);
+
+                QWindowsVistaAnimation *anim = qobject_cast<QWindowsVistaAnimation *>(d->animation(styleObject));
+                QWindowsVistaTransition *t = new QWindowsVistaTransition(styleObject);
+
+                // Draw the image that ends the animation by using the current styleoption
+                QStyleOptionComplex *styleOption = qstyleoption_cast<QStyleOptionComplex*>(clonedAnimationStyleOption(option));
+
+                styleObject->setProperty("_q_no_animation", true);
+
+                // Draw transition source
+                if (!anim) {
+                    styleOption->state = QStyle::State(oldState);
+                    styleOption->activeSubControls = QStyle::SubControl(oldActiveControls);
+                    proxy()->drawComplexControl(control, styleOption, &startPainter, widget);
+                } else {
+                    anim->paint(&startPainter, option);
+                }
+                t->setStartImage(startImage);
+
+                // Draw transition target
+                styleOption->state = option->state;
+                styleOption->activeSubControls = option->activeSubControls;
+                proxy()->drawComplexControl(control, styleOption, &endPainter, widget);
+
+                styleObject->setProperty("_q_no_animation", false);
+
+                t->setEndImage(endImage);
+                t->setStartTime(QTime::currentTime());
+
+                if (option->state & State_MouseOver || option->state & State_Sunken)
+                    t->setDuration(150);
+                else
+                    t->setDuration(500);
+
+                deleteClonedAnimationStyleOption(styleOption);
+                d->startAnimation(t);
+            }
+            if (QWindowsVistaAnimation *anim = qobject_cast<QWindowsVistaAnimation *>(d->animation(styleObject))) {
+                anim->paint(painter, option);
+                return;
+            }
+        }
+    }
+
+    switch (control) {
+    case CC_ComboBox:
+        if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(option))
+        {
+            if (cmb->editable) {
+                if (sub & SC_ComboBoxEditField) {
+                    partId = EP_EDITBORDER_NOSCROLL;
+                    if (!(flags & State_Enabled))
+                        stateId = ETS_DISABLED;
+                    else if (flags & State_MouseOver)
+                        stateId = ETS_HOT;
+                    else if (flags & State_HasFocus)
+                        stateId = ETS_FOCUSED;
+                    else
+                        stateId = ETS_NORMAL;
+
+                    XPThemeData theme(widget, painter,
+                                      QWindowsXPStylePrivate::EditTheme,
+                                      partId, stateId, r);
+
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_ComboBoxArrow) {
+                    QRect subRect = proxy()->subControlRect(CC_ComboBox, option, SC_ComboBoxArrow, widget);
+                    XPThemeData theme(widget, painter, QWindowsXPStylePrivate::ComboboxTheme);
+                    theme.rect = subRect;
+                    partId = option->direction == Qt::RightToLeft ? CP_DROPDOWNBUTTONLEFT : CP_DROPDOWNBUTTONRIGHT;
+
+                    if (!(cmb->state & State_Enabled))
+                        stateId = CBXS_DISABLED;
+                    else if (cmb->state & State_Sunken || cmb->state & State_On)
+                        stateId = CBXS_PRESSED;
+                    else if (cmb->state & State_MouseOver && option->activeSubControls & SC_ComboBoxArrow)
+                        stateId = CBXS_HOT;
+                    else
+                        stateId = CBXS_NORMAL;
+
+                    theme.partId = partId;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+                }
+
+            } else {
+                if (sub & SC_ComboBoxFrame) {
+                    XPThemeData theme(widget, painter, QWindowsXPStylePrivate::ComboboxTheme);
+                    theme.rect = option->rect;
+                    theme.partId = CP_READONLY;
+                    if (!(cmb->state & State_Enabled))
+                        theme.stateId = CBXS_DISABLED;
+                    else if (cmb->state & State_Sunken || cmb->state & State_On)
+                        theme.stateId = CBXS_PRESSED;
+                    else if (cmb->state & State_MouseOver)
+                        theme.stateId = CBXS_HOT;
+                    else
+                        theme.stateId = CBXS_NORMAL;
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_ComboBoxArrow) {
+                    XPThemeData theme(widget, painter, QWindowsXPStylePrivate::ComboboxTheme);
+                    theme.rect = proxy()->subControlRect(CC_ComboBox, option, SC_ComboBoxArrow, widget);
+                    theme.partId = option->direction == Qt::RightToLeft ? CP_DROPDOWNBUTTONLEFT : CP_DROPDOWNBUTTONRIGHT;
+                    if (!(cmb->state & State_Enabled))
+                        theme.stateId = CBXS_DISABLED;
+                    else
+                        theme.stateId = CBXS_NORMAL;
+                    d->drawBackground(theme);
+                }
+                if ((sub & SC_ComboBoxEditField) && (flags & State_HasFocus)) {
+                    QStyleOptionFocusRect fropt;
+                    fropt.QStyleOption::operator=(*cmb);
+                    fropt.rect = proxy()->subControlRect(CC_ComboBox, option, SC_ComboBoxEditField, widget);
+                    proxy()->drawPrimitive(PE_FrameFocusRect, &fropt, painter, widget);
+                }
+            }
+        }
+        break;
+    case CC_ScrollBar:
+        if (const QStyleOptionSlider *scrollbar = qstyleoption_cast<const QStyleOptionSlider *>(option))
+        {
+            XPThemeData theme(widget, painter, QWindowsXPStylePrivate::ScrollBarTheme);
+            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 = proxy()->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 if (scrollbar->state & State_MouseOver)
+                    stateId = (isHorz ? (isRTL ? ABS_LEFTHOVER : ABS_RIGHTHOVER) : ABS_DOWNHOVER);
+                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 = proxy()->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 if (scrollbar->state & State_MouseOver)
+                    stateId = (isHorz ? (isRTL ? ABS_RIGHTHOVER : ABS_LEFTHOVER) : ABS_UPHOVER);
+                else
+                    stateId = (isHorz ? (isRTL ? ABS_RIGHTNORMAL : ABS_LEFTNORMAL) : ABS_UPNORMAL);
+                theme.partId = partId;
+                theme.stateId = stateId;
+                d->drawBackground(theme);
+            }
+            if (maxedOut) {
+                theme.rect = proxy()->subControlRect(CC_ScrollBar, option, SC_ScrollBarSlider, widget);
+                theme.rect = theme.rect.united(proxy()->subControlRect(CC_ScrollBar, option, SC_ScrollBarSubPage, widget));
+                theme.rect = theme.rect.united(proxy()->subControlRect(CC_ScrollBar, option, SC_ScrollBarAddPage, widget));
+                partId = flags & State_Horizontal ? SBP_LOWERTRACKHORZ : SBP_LOWERTRACKVERT;
+                stateId = SCRBS_DISABLED;
+                theme.partId = partId;
+                theme.stateId = stateId;
+                d->drawBackground(theme);
+            } else {
+                if (sub & SC_ScrollBarSubPage) {
+                    theme.rect = proxy()->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 = proxy()->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 = proxy()->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 if (option->state & State_MouseOver)
+                        stateId = SCRBS_HOVER;
+                    else
+                        stateId = SCRBS_NORMAL;
+
+                    // Draw handle
+                    theme.partId = flags & State_Horizontal ? SBP_THUMBBTNHORZ : SBP_THUMBBTNVERT;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+
+                    if (QOperatingSystemVersion::current() < QOperatingSystemVersion::Windows8) {
+                        const QRect gripperBounds = QWindowsXPStylePrivate::scrollBarGripperBounds(flags, widget, &theme);
+                        // Draw gripper if there is enough space
+                        if (!gripperBounds.isEmpty() && flags & State_Enabled) {
+                            painter->save();
+                            XPThemeData grippBackground = theme;
+                            grippBackground.partId = flags & State_Horizontal ? SBP_LOWERTRACKHORZ : SBP_LOWERTRACKVERT;
+                            theme.rect = gripperBounds;
+                            painter->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
+                            painter->restore();
+                        }
+                    }
+                }
+            }
+        }
+        break;
+#if QT_CONFIG(spinbox)
+    case CC_SpinBox:
+        if (const QStyleOptionSpinBox *sb = qstyleoption_cast<const QStyleOptionSpinBox *>(option))
+        {
+            XPThemeData theme(widget, painter, QWindowsXPStylePrivate::SpinTheme);
+            if (sb->frame && (sub & SC_SpinBoxFrame)) {
+                partId = EP_EDITBORDER_NOSCROLL;
+                if (!(flags & State_Enabled))
+                    stateId = ETS_DISABLED;
+                else if (flags & State_MouseOver)
+                    stateId = ETS_HOT;
+                else if (flags & State_HasFocus)
+                    stateId = ETS_SELECTED;
+                else
+                    stateId = ETS_NORMAL;
+
+                XPThemeData ftheme(widget, painter,
+                                   QWindowsXPStylePrivate::EditTheme,
+                                   partId, stateId, r);
+                // The spinbox in Windows QStyle is drawn with frameless QLineEdit inside it
+                // That however breaks with QtQuickControls where this results in transparent
+                // spinbox background, so if there's no "widget" passed (QtQuickControls case),
+                // let ftheme.noContent be false, which fixes the spinbox rendering in QQC
+                ftheme.noContent = (widget != nullptr);
+                d->drawBackground(ftheme);
+            }
+            if (sub & SC_SpinBoxUp) {
+                theme.rect = proxy()->subControlRect(CC_SpinBox, option, SC_SpinBoxUp, widget).adjusted(0, 0, 0, 1);
+                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 = proxy()->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_CONFIG(spinbox)
+    default:
+        QWindowsXPStyle::drawComplexControl(control, option, painter, widget);
+        break;
+    }
+}
+
+/*!
+ \internal
+ */
+QSize QWindowsVistaStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
+                                        const QSize &size, const QWidget *widget) const
+{
+    if (!QWindowsVistaStylePrivate::useVista())
+        return QWindowsStyle::sizeFromContents(type, option, size, widget);
+
+    QSize sz(size);
+    switch (type) {
+    case CT_MenuItem:
+        sz = QWindowsXPStyle::sizeFromContents(type, option, size, widget);
+        int minimumHeight;
+        {
+            XPThemeData theme(widget, nullptr,
+                              QWindowsXPStylePrivate::MenuTheme,
+                              MENU_POPUPCHECKBACKGROUND, MBI_HOT);
+            XPThemeData themeSize = theme;
+            themeSize.partId = MENU_POPUPCHECK;
+            themeSize.stateId = 0;
+            const QSizeF size = themeSize.size() * QWindowsStylePrivate::nativeMetricScaleFactor(widget);
+            const QMarginsF margins = themeSize.margins() * QWindowsStylePrivate::nativeMetricScaleFactor(widget);
+            minimumHeight = qMax(qRound(size.height() + margins.bottom() + margins.top()), sz.height());
+            sz.rwidth() += qRound(size.width() + margins.left() + margins.right());
+        }
+
+        if (const QStyleOptionMenuItem *menuitem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
+            if (menuitem->menuItemType != QStyleOptionMenuItem::Separator)
+                sz.setHeight(minimumHeight);
+        }
+        return sz;
+#if QT_CONFIG(menubar)
+    case CT_MenuBarItem:
+        if (!sz.isEmpty())
+            sz += QSize(windowsItemHMargin * 5 + 1, 5);
+        return sz;
+#endif
+    case CT_ItemViewItem:
+        sz = QWindowsXPStyle::sizeFromContents(type, option, size, widget);
+        sz.rheight() += 2;
+        return sz;
+    case CT_SpinBox:
+        {
+            //Spinbox adds frame twice
+            sz = QWindowsStyle::sizeFromContents(type, option, size, widget);
+            int border = proxy()->pixelMetric(PM_SpinBoxFrameWidth, option, widget);
+            sz -= QSize(2*border, 2*border);
+        }
+        return sz;
+    case CT_HeaderSection:
+        {
+            // When there is a sort indicator it adds to the width but it is shown
+            // above the text natively and not on the side
+            if (QStyleOptionHeader *hdr = qstyleoption_cast<QStyleOptionHeader *>(const_cast<QStyleOption *>(option))) {
+                QStyleOptionHeader::SortIndicator sortInd = hdr->sortIndicator;
+                hdr->sortIndicator = QStyleOptionHeader::None;
+                sz = QWindowsXPStyle::sizeFromContents(type, hdr, size, widget);
+                hdr->sortIndicator = sortInd;
+                return sz;
+            }
+            break;
+        }
+    default:
+        break;
+    }
+    return QWindowsXPStyle::sizeFromContents(type, option, size, widget);
+}
+
+/*!
+ \internal
+ */
+QRect QWindowsVistaStyle::subElementRect(SubElement element, const QStyleOption *option, const QWidget *widget) const
+{
+   if (!QWindowsVistaStylePrivate::useVista())
+        return QWindowsStyle::subElementRect(element, option, widget);
+
+   QRect rect = QWindowsXPStyle::subElementRect(element, option, widget);
+    switch (element) {
+
+    case SE_PushButtonContents:
+        if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {
+            MARGINS borderSize;
+            const HTHEME theme = OpenThemeData(widget ? QWindowsVistaStylePrivate::winId(widget) : nullptr, L"Button");
+            if (theme) {
+                int stateId = PBS_NORMAL;
+                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;
+
+                int border = proxy()->pixelMetric(PM_DefaultFrameWidth, btn, widget);
+                rect = option->rect.adjusted(border, border, -border, -border);
+
+                if (SUCCEEDED(GetThemeMargins(theme, nullptr, BP_PUSHBUTTON, stateId, TMT_CONTENTMARGINS, nullptr, &borderSize))) {
+                    rect.adjust(borderSize.cxLeftWidth, borderSize.cyTopHeight,
+                                -borderSize.cxRightWidth, -borderSize.cyBottomHeight);
+                    rect = visualRect(option->direction, option->rect, rect);
+                }
+            }
+        }
+        break;
+
+    case SE_HeaderArrow:
+        {
+            QRect r = rect;
+            int h = option->rect.height();
+            int w = option->rect.width();
+            int x = option->rect.x();
+            int y = option->rect.y();
+            int margin = proxy()->pixelMetric(QStyle::PM_HeaderMargin, option, widget);
+
+            XPThemeData theme(widget, nullptr,
+                              QWindowsXPStylePrivate::HeaderTheme,
+                              HP_HEADERSORTARROW, HSAS_SORTEDDOWN, option->rect);
+
+            int arrowWidth = 13;
+            int arrowHeight = 5;
+            if (theme.isValid()) {
+                const QSizeF size = theme.size() * QWindowsStylePrivate::nativeMetricScaleFactor(widget);
+                if (!size.isEmpty()) {
+                    arrowWidth = qRound(size.width());
+                    arrowHeight = qRound(size.height());
+                }
+            }
+            if (option->state & State_Horizontal) {
+                r.setRect(x + w/2 - arrowWidth/2, y , arrowWidth, arrowHeight);
+            } else {
+                int vert_size = w / 2;
+                r.setRect(x + 5, y + h - margin * 2 - vert_size,
+                          w - margin * 2 - 5, vert_size);
+            }
+            rect = visualRect(option->direction, option->rect, r);
+        }
+        break;
+
+    case SE_HeaderLabel:
+        {
+            int margin = proxy()->pixelMetric(QStyle::PM_HeaderMargin, option, widget);
+            QRect r = option->rect;
+            r.setRect(option->rect.x() + margin, option->rect.y() + margin,
+                      option->rect.width() - margin * 2, option->rect.height() - margin * 2);
+            if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
+                // Subtract width needed for arrow, if there is one
+                if (header->sortIndicator != QStyleOptionHeader::None) {
+                    if (!(option->state & State_Horizontal)) //horizontal arrows are positioned on top
+                        r.setHeight(r.height() - (option->rect.width() / 2) - (margin * 2));
+                }
+            }
+            rect = visualRect(option->direction, option->rect, r);
+        }
+        break;
+    case SE_ProgressBarContents:
+        rect = QCommonStyle::subElementRect(SE_ProgressBarGroove, option, widget);
+        break;
+    case SE_ItemViewItemDecoration:
+        if (qstyleoption_cast<const QStyleOptionViewItem *>(option))
+            rect.adjust(-2, 0, 2, 0);
+        break;
+    case SE_ItemViewItemFocusRect:
+        if (const QStyleOptionViewItem *vopt = qstyleoption_cast<const QStyleOptionViewItem *>(option)) {
+            QRect textRect = subElementRect(QStyle::SE_ItemViewItemText, option, widget);
+            QRect displayRect = subElementRect(QStyle::SE_ItemViewItemDecoration, option, widget);
+            if (!vopt->icon.isNull())
+                rect = textRect.united(displayRect);
+            else
+                rect = textRect;
+            rect = rect.adjusted(1, 0, -1, 0);
+        }
+        break;
+    default:
+        break;
+    }
+    return rect;
+}
+
+
+/*
+  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 auto 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;
+}
+
+
+/*! \internal */
+int QWindowsVistaStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidget *widget,
+                             QStyleHintReturn *returnData) const
+{
+    QWindowsVistaStylePrivate *d = const_cast<QWindowsVistaStylePrivate*>(d_func());
+    int ret = 0;
+    switch (hint) {
+    case SH_MessageBox_CenterButtons:
+        ret = false;
+        break;
+    case SH_ToolTip_Mask:
+        if (option) {
+            if (QStyleHintReturnMask *mask = qstyleoption_cast<QStyleHintReturnMask*>(returnData)) {
+                ret = true;
+                XPThemeData themeData(widget, nullptr,
+                                      QWindowsXPStylePrivate::ToolTipTheme,
+                                      TTP_STANDARD, TTSS_NORMAL, option->rect);
+                mask->region = d->region(themeData);
+            }
+        }
+        break;
+     case SH_Table_GridLineColor:
+        if (option)
+            ret = int(option->palette.color(QPalette::Base).darker(118).rgba());
+        else
+            ret = -1;
+        break;
+    case SH_Header_ArrowAlignment:
+        ret = Qt::AlignTop | Qt::AlignHCenter;
+        break;
+    default:
+        ret = QWindowsXPStyle::styleHint(hint, option, widget, returnData);
+        break;
+    }
+    return ret;
+}
+
+
+/*!
+ \internal
+ */
+QRect QWindowsVistaStyle::subControlRect(ComplexControl control, const QStyleOptionComplex *option,
+                                  SubControl subControl, const QWidget *widget) const
+{
+   if (!QWindowsVistaStylePrivate::useVista())
+        return QWindowsStyle::subControlRect(control, option, subControl, widget);
+
+    QRect rect = QWindowsXPStyle::subControlRect(control, option, subControl, widget);
+    switch (control) {
+#if QT_CONFIG(combobox)
+    case CC_ComboBox:
+        if (const QStyleOptionComboBox *cb = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
+            const int x = cb->rect.x(), y = cb->rect.y(), wi = cb->rect.width(), he = cb->rect.height();
+            const int margin = cb->frame ? 3 : 0;
+            const int bmarg = cb->frame ? 2 : 0;
+            const int arrowWidth = qRound(QStyleHelper::dpiScaled(16, option));
+            const int arrowButtonWidth = bmarg + arrowWidth;
+            const int xpos = x + wi - arrowButtonWidth;
+
+            switch (subControl) {
+            case SC_ComboBoxFrame:
+                rect = cb->rect;
+                break;
+            case SC_ComboBoxArrow:
+                rect.setRect(xpos, y , arrowButtonWidth, he);
+                break;
+            case SC_ComboBoxEditField:
+                rect.setRect(x + margin, y + margin, wi - 2 * margin - arrowWidth, he - 2 * margin);
+                break;
+            case SC_ComboBoxListBoxPopup:
+                rect = cb->rect;
+                break;
+            default:
+                break;
+            }
+            rect = visualRect(cb->direction, cb->rect, rect);
+            return rect;
+        }
+        break;
+#endif // QT_CONFIG(combobox)
+    case CC_TitleBar:
+        if (const QStyleOptionTitleBar *tb = qstyleoption_cast<const QStyleOptionTitleBar *>(option)) {
+            if (!buttonVisible(subControl, tb))
+                return rect;
+            const qreal factor = QWindowsStylePrivate::nativeMetricScaleFactor(widget);
+            const bool isToolTitle = false;
+            const int height = tb->rect.height();
+            const int width = tb->rect.width();
+            const int buttonWidth =
+                qRound(qreal(GetSystemMetrics(SM_CXSIZE)) * factor - QStyleHelper::dpiScaled(4, option));
+
+            const int frameWidth = proxy()->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;
+
+            switch (subControl) {
+            case SC_TitleBarLabel:
+                rect = QRect(frameWidth, 0, width - (buttonWidth + frameWidth + 10), height);
+                if (isToolTitle) {
+                    if (sysmenuHint) {
+                        rect.adjust(0, 0, int(-buttonWidth - 3 * factor), 0);
+                    }
+                    if (minimizeHint || maximizeHint)
+                        rect.adjust(0, 0, int(-buttonWidth - 2 * factor), 0);
+                } else {
+                    if (sysmenuHint) {
+                        const int leftOffset = int(height - 8 * factor);
+                        rect.adjust(leftOffset, 0, 0, int(4 * factor));
+                    }
+                    if (minimizeHint)
+                        rect.adjust(0, 0, int(-buttonWidth - 2 * factor), 0);
+                    if (maximizeHint)
+                        rect.adjust(0, 0, int(-buttonWidth - 2 * factor), 0);
+                    if (contextHint)
+                        rect.adjust(0, 0, int(-buttonWidth - 2 * factor), 0);
+                    if (shadeHint)
+                        rect.adjust(0, 0, int(-buttonWidth - 2 * factor), 0);
+                }
+                rect.translate(0, int(2 * factor));
+                rect = visualRect(option->direction, option->rect, rect);
+                break;
+            case SC_TitleBarSysMenu:
+                {
+                    const int controlTop = int(6 * factor);
+                    const int controlHeight = int(height - controlTop - 3 * factor);
+                    int iconExtent = proxy()->pixelMetric(PM_SmallIconSize, option);
+                    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());
+                    rect.translate(0, int(3 * factor));
+                    rect = visualRect(option->direction, option->rect, rect);
+                }
+                break;
+            default:
+                break;
+            }
+        }
+        break;
+    default:
+        break;
+    }
+    return rect;
+}
+
+/*!
+ \internal
+ */
+QStyle::SubControl QWindowsVistaStyle::hitTestComplexControl(ComplexControl control, const QStyleOptionComplex *option,
+                                                          const QPoint &pos, const QWidget *widget) const
+{
+    if (!QWindowsVistaStylePrivate::useVista()) {
+        return QWindowsStyle::hitTestComplexControl(control, option, pos, widget);
+    }
+    return QWindowsXPStyle::hitTestComplexControl(control, option, pos, widget);
+}
+
+int QWindowsVistaStylePrivate::fixedPixelMetric(QStyle::PixelMetric pm)
+{
+    switch (pm) {
+    case QStyle::PM_DockWidgetTitleBarButtonMargin:
+        return 5;
+    case QStyle::PM_ScrollBarSliderMin:
+        return 18;
+    case QStyle::PM_MenuHMargin:
+    case QStyle::PM_MenuVMargin:
+        return 0;
+    case QStyle::PM_MenuPanelWidth:
+        return 3;
+    default:
+        break;
+    }
+    return QWindowsVistaStylePrivate::InvalidMetric;
+}
+
+/*!
+ \internal
+ */
+int QWindowsVistaStyle::pixelMetric(PixelMetric metric, const QStyleOption *option, const QWidget *widget) const
+{
+    if (!QWindowsVistaStylePrivate::useVista())
+        return QWindowsStyle::pixelMetric(metric, option, widget);
+
+    int ret = QWindowsVistaStylePrivate::fixedPixelMetric(metric);
+    if (ret != QWindowsStylePrivate::InvalidMetric)
+        return int(QStyleHelper::dpiScaled(ret, option));
+
+    return QWindowsXPStyle::pixelMetric(metric, option, widget);
+}
+
+/*!
+ \internal
+ */
+QPalette QWindowsVistaStyle::standardPalette() const
+{
+    return QWindowsXPStyle::standardPalette();
+}
+
+/*!
+ \internal
+ */
+void QWindowsVistaStyle::polish(QApplication *app)
+{
+    QWindowsXPStyle::polish(app);
+}
+
+/*!
+ \internal
+ */
+void QWindowsVistaStyle::polish(QWidget *widget)
+{
+    QWindowsXPStyle::polish(widget);
+#if QT_CONFIG(lineedit)
+    if (qobject_cast<QLineEdit*>(widget))
+        widget->setAttribute(Qt::WA_Hover);
+    else
+#endif // QT_CONFIG(lineedit)
+    if (qobject_cast<QGroupBox*>(widget))
+        widget->setAttribute(Qt::WA_Hover);
+#if QT_CONFIG(commandlinkbutton)
+    else if (qobject_cast<QCommandLinkButton*>(widget)) {
+        QFont buttonFont = widget->font();
+        buttonFont.setFamily(QLatin1String("Segoe UI"));
+        widget->setFont(buttonFont);
+    }
+#endif // QT_CONFIG(commandlinkbutton)
+    else if (widget->inherits("QTipLabel")){
+        //note that since tooltips are not reused
+        //we do not have to care about unpolishing
+        widget->setContentsMargins(3, 0, 4, 0);
+        COLORREF bgRef;
+        HTHEME theme = OpenThemeData(widget ? QWindowsVistaStylePrivate::winId(widget) : nullptr, L"TOOLTIP");
+        if (theme && SUCCEEDED(GetThemeColor(theme, TTP_STANDARD, TTSS_NORMAL, TMT_TEXTCOLOR, &bgRef))) {
+            QColor textColor = QColor::fromRgb(bgRef);
+            QPalette pal;
+            pal.setColor(QPalette::All, QPalette::ToolTipText, textColor);
+            widget->setPalette(pal);
+        }
+    } else if (qobject_cast<QMessageBox *> (widget)) {
+        widget->setAttribute(Qt::WA_StyledBackground);
+#if QT_CONFIG(dialogbuttonbox)
+        QDialogButtonBox *buttonBox = widget->findChild<QDialogButtonBox *>(QLatin1String("qt_msgbox_buttonbox"));
+        if (buttonBox)
+            buttonBox->setContentsMargins(0, 9, 0, 0);
+#endif
+    }
+#if QT_CONFIG(inputdialog)
+    else if (qobject_cast<QInputDialog *> (widget)) {
+        widget->setAttribute(Qt::WA_StyledBackground);
+#if QT_CONFIG(dialogbuttonbox)
+        QDialogButtonBox *buttonBox = widget->findChild<QDialogButtonBox *>(QLatin1String("qt_inputdlg_buttonbox"));
+        if (buttonBox)
+            buttonBox->setContentsMargins(0, 9, 0, 0);
+#endif
+    }
+#endif // QT_CONFIG(inputdialog)
+    else if (QTreeView *tree = qobject_cast<QTreeView *> (widget)) {
+        tree->viewport()->setAttribute(Qt::WA_Hover);
+    }
+    else if (QListView *list = qobject_cast<QListView *> (widget)) {
+        list->viewport()->setAttribute(Qt::WA_Hover);
+    }
+}
+
+/*!
+ \internal
+ */
+void QWindowsVistaStyle::unpolish(QWidget *widget)
+{
+    QWindowsXPStyle::unpolish(widget);
+
+    QWindowsVistaStylePrivate *d = d_func();
+
+    d->stopAnimation(widget);
+
+#if QT_CONFIG(lineedit)
+    if (qobject_cast<QLineEdit*>(widget))
+        widget->setAttribute(Qt::WA_Hover, false);
+    else
+#endif // QT_CONFIG(lineedit)
+    if (qobject_cast<QGroupBox*>(widget))
+        widget->setAttribute(Qt::WA_Hover, false);
+    else if (qobject_cast<QMessageBox *> (widget)) {
+        widget->setAttribute(Qt::WA_StyledBackground, false);
+#if QT_CONFIG(dialogbuttonbox)
+        QDialogButtonBox *buttonBox = widget->findChild<QDialogButtonBox *>(QLatin1String("qt_msgbox_buttonbox"));
+        if (buttonBox)
+            buttonBox->setContentsMargins(0, 0, 0, 0);
+#endif
+    }
+#if QT_CONFIG(inputdialog)
+    else if (qobject_cast<QInputDialog *> (widget)) {
+        widget->setAttribute(Qt::WA_StyledBackground, false);
+#if QT_CONFIG(dialogbuttonbox)
+        QDialogButtonBox *buttonBox = widget->findChild<QDialogButtonBox *>(QLatin1String("qt_inputdlg_buttonbox"));
+        if (buttonBox)
+            buttonBox->setContentsMargins(0, 0, 0, 0);
+#endif
+    }
+#endif // QT_CONFIG(inputdialog)
+    else if (QTreeView *tree = qobject_cast<QTreeView *> (widget)) {
+        tree->viewport()->setAttribute(Qt::WA_Hover, false);
+    }
+#if QT_CONFIG(commandlinkbutton)
+    else if (qobject_cast<QCommandLinkButton*>(widget)) {
+        QFont font = QApplication::font("QCommandLinkButton");
+        QFont widgetFont = widget->font();
+        widgetFont.setFamily(font.family()); //Only family set by polish
+        widget->setFont(widgetFont);
+    }
+#endif // QT_CONFIG(commandlinkbutton)
+}
+
+
+/*!
+ \internal
+ */
+void QWindowsVistaStyle::unpolish(QApplication *app)
+{
+    QWindowsXPStyle::unpolish(app);
+}
+
+/*!
+ \internal
+ */
+void QWindowsVistaStyle::polish(QPalette &pal)
+{
+    QWindowsStyle::polish(pal);
+    pal.setBrush(QPalette::AlternateBase, pal.base().color().darker(104));
+}
+
+/*!
+ \internal
+ */
+QPixmap QWindowsVistaStyle::standardPixmap(StandardPixmap standardPixmap, const QStyleOption *option,
+                                      const QWidget *widget) const
+{
+    if (!QWindowsVistaStylePrivate::useVista()) {
+        return QWindowsStyle::standardPixmap(standardPixmap, option, widget);
+    }
+    return QWindowsXPStyle::standardPixmap(standardPixmap, option, widget);
+}
+
+QWindowsVistaStylePrivate::QWindowsVistaStylePrivate() :
+    QWindowsXPStylePrivate()
+{
+}
+
+bool QWindowsVistaStylePrivate::transitionsEnabled() const
+{
+    BOOL animEnabled = false;
+    if (SystemParametersInfo(SPI_GETCLIENTAREAANIMATION, 0, &animEnabled, 0))
+    {
+        if (animEnabled)
+            return true;
+    }
+    return false;
+}
+
+/*!
+\reimp
+*/
+QIcon QWindowsVistaStyle::standardIcon(StandardPixmap standardIcon,
+                                       const QStyleOption *option,
+                                       const QWidget *widget) const
+{
+    if (!QWindowsVistaStylePrivate::useVista()) {
+        return QWindowsStyle::standardIcon(standardIcon, option, widget);
+    }
+
+    QWindowsVistaStylePrivate *d = const_cast<QWindowsVistaStylePrivate *>(d_func());
+    switch (standardIcon) {
+    case SP_CommandLink:
+        {
+            XPThemeData theme(nullptr, nullptr,
+                              QWindowsXPStylePrivate::ButtonTheme,
+                              BP_COMMANDLINKGLYPH, CMDLGS_NORMAL);
+            if (theme.isValid()) {
+                const QSize size = (theme.size() * QWindowsStylePrivate::nativeMetricScaleFactor(widget)).toSize();
+                QIcon linkGlyph;
+                QPixmap pm(size);
+                pm.fill(Qt::transparent);
+                QPainter p(&pm);
+                theme.painter = &p;
+                theme.rect = QRect(QPoint(0, 0), size);
+                d->drawBackground(theme);
+                linkGlyph.addPixmap(pm, QIcon::Normal, QIcon::Off);    // Normal
+                pm.fill(Qt::transparent);
+
+                theme.stateId = CMDLGS_PRESSED;
+                d->drawBackground(theme);
+                linkGlyph.addPixmap(pm, QIcon::Normal, QIcon::On);     // Pressed
+                pm.fill(Qt::transparent);
+
+                theme.stateId = CMDLGS_HOT;
+                d->drawBackground(theme);
+                linkGlyph.addPixmap(pm, QIcon::Active, QIcon::Off);    // Hover
+                pm.fill(Qt::transparent);
+
+                theme.stateId = CMDLGS_DISABLED;
+                d->drawBackground(theme);
+                linkGlyph.addPixmap(pm, QIcon::Disabled, QIcon::Off);  // Disabled
+                return linkGlyph;
+            }
+        }
+        break;
+    default:
+        break;
+    }
+    return QWindowsXPStyle::standardIcon(standardIcon, option, widget);
+}
+
+QT_END_NAMESPACE
diff --git a/src/imports/nativestyle/qstyle/windows/qquickwindowsvistastyle_p.h b/src/imports/nativestyle/qstyle/windows/qquickwindowsvistastyle_p.h
new file mode 100644
index 00000000..07cd2b8a
--- /dev/null
+++ b/src/imports/nativestyle/qstyle/windows/qquickwindowsvistastyle_p.h
@@ -0,0 +1,109 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWidgets module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWINDOWSVISTASTYLE_P_H
+#define QWINDOWSVISTASTYLE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtWidgets/private/qtwidgetsglobal_p.h>
+#include "qquickwindowsxpstyle_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QWindowsVistaStylePrivate;
+class QWindowsVistaStyle : public QWindowsXPStyle
+{
+    Q_OBJECT
+public:
+    QWindowsVistaStyle();
+    ~QWindowsVistaStyle() override;
+
+    void drawPrimitive(PrimitiveElement element, const QStyleOption *option,
+                       QPainter *painter,
+                       const QWidget *widget = nullptr) const override;
+    void drawControl(ControlElement element, const QStyleOption *option,
+                     QPainter *painter, const QWidget *widget) const override;
+    void drawComplexControl(ComplexControl control, const QStyleOptionComplex *option,
+                            QPainter *painter, const QWidget *widget) const override;
+    QSize sizeFromContents(ContentsType type, const QStyleOption *option,
+                           const QSize &size, const QWidget *widget) const override;
+
+    QRect subElementRect(SubElement element, const QStyleOption *option,
+                         const QWidget *widget) const override;
+    QRect subControlRect(ComplexControl cc, const QStyleOptionComplex *opt,
+                         SubControl sc, const QWidget *widget) const override;
+
+    SubControl hitTestComplexControl(ComplexControl control, const QStyleOptionComplex *option,
+                                     const QPoint &pos, const QWidget *widget = nullptr) const override;
+
+    QIcon standardIcon(StandardPixmap standardIcon, const QStyleOption *option = nullptr,
+                       const QWidget *widget = nullptr) const override;
+    QPixmap standardPixmap(StandardPixmap standardPixmap, const QStyleOption *opt,
+                           const QWidget *widget = nullptr) const override;
+    int pixelMetric(PixelMetric metric, const QStyleOption *option = nullptr,
+                    const QWidget *widget = nullptr) const override;
+    int styleHint(StyleHint hint, const QStyleOption *opt = nullptr,
+                  const QWidget *widget = nullptr, QStyleHintReturn *returnData = nullptr) const override;
+
+    void polish(QWidget *widget) override;
+    void unpolish(QWidget *widget) override;
+    void polish(QPalette &pal) override;
+    void polish(QApplication *app) override;
+    void unpolish(QApplication *app) override;
+    QPalette standardPalette() const override;
+
+private:
+    Q_DISABLE_COPY_MOVE(QWindowsVistaStyle)
+    Q_DECLARE_PRIVATE(QWindowsVistaStyle)
+    friend class QStyleFactory;
+};
+
+QT_END_NAMESPACE
+
+#endif // QWINDOWSVISTASTYLE_P_H
diff --git a/src/imports/nativestyle/qstyle/windows/qquickwindowsvistastyle_p_p.h b/src/imports/nativestyle/qstyle/windows/qquickwindowsvistastyle_p_p.h
new file mode 100644
index 00000000..a5383175
--- /dev/null
+++ b/src/imports/nativestyle/qstyle/windows/qquickwindowsvistastyle_p_p.h
@@ -0,0 +1,204 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWidgets module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWINDOWSVISTASTYLE_P_P_H
+#define QWINDOWSVISTASTYLE_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp.  This header
+// file may change from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtWidgets/private/qtwidgetsglobal_p.h>
+#include "qquickwindowsvistastyle_p.h"
+#include "qquickwindowsxpstyle_p_p.h"
+#include <private/qstyleanimation_p.h>
+#include <private/qpaintengine_raster_p.h>
+#include <qpaintengine.h>
+#include <qwidget.h>
+#include <qapplication.h>
+#include <qpixmapcache.h>
+#include <qstyleoption.h>
+#if QT_CONFIG(pushbutton)
+#include <qpushbutton.h>
+#endif
+#include <qradiobutton.h>
+#if QT_CONFIG(lineedit)
+#include <qlineedit.h>
+#endif
+#include <qgroupbox.h>
+#if QT_CONFIG(toolbutton)
+#include <qtoolbutton.h>
+#endif
+#if QT_CONFIG(spinbox)
+#include <qspinbox.h>
+#endif
+#if QT_CONFIG(toolbar)
+#include <qtoolbar.h>
+#endif
+#if QT_CONFIG(combobox)
+#include <qcombobox.h>
+#endif
+#if QT_CONFIG(scrollbar)
+#include <qscrollbar.h>
+#endif
+#if QT_CONFIG(progressbar)
+#include <qprogressbar.h>
+#endif
+#if QT_CONFIG(dockwidget)
+#include <qdockwidget.h>
+#endif
+#if QT_CONFIG(listview)
+#include <qlistview.h>
+#endif
+#if QT_CONFIG(treeview)
+#include <qtreeview.h>
+#endif
+#include <qtextedit.h>
+#include <qmessagebox.h>
+#if QT_CONFIG(dialogbuttonbox)
+#include <qdialogbuttonbox.h>
+#endif
+#include <qinputdialog.h>
+#if QT_CONFIG(tableview)
+#include <qtableview.h>
+#endif
+#include <qdatetime.h>
+#if QT_CONFIG(commandlinkbutton)
+#include <qcommandlinkbutton.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#if !defined(SCHEMA_VERIFY_VSSYM32)
+#define TMT_ANIMATIONDURATION       5006
+#define TMT_TRANSITIONDURATIONS     6000
+#define EP_EDITBORDER_NOSCROLL      6
+#define EP_EDITBORDER_HVSCROLL      9
+#define EP_BACKGROUND               3
+#define EBS_NORMAL                  1
+#define EBS_HOT                     2
+#define EBS_DISABLED                3
+#define EBS_READONLY                5
+#define PBS_DEFAULTED_ANIMATING     6
+#define MBI_NORMAL                  1
+#define MBI_HOT                     2
+#define MBI_PUSHED                  3
+#define MBI_DISABLED                4
+#define MB_ACTIVE                   1
+#define MB_INACTIVE                 2
+#define PP_FILL                     5
+#define PP_FILLVERT                 6
+#define PP_MOVEOVERLAY              8
+#define PP_MOVEOVERLAYVERT          10
+#define MENU_BARBACKGROUND          7
+#define MENU_BARITEM                8
+#define MENU_POPUPCHECK             11
+#define MENU_POPUPCHECKBACKGROUND   12
+#define MENU_POPUPGUTTER            13
+#define MENU_POPUPITEM              14
+#define MENU_POPUPBORDERS           10
+#define MENU_POPUPSEPARATOR         15
+#define MC_CHECKMARKNORMAL          1
+#define MC_CHECKMARKDISABLED        2
+#define MC_BULLETNORMAL             3
+#define MC_BULLETDISABLED           4
+#define ABS_UPHOVER                 17
+#define ABS_DOWNHOVER               18
+#define ABS_LEFTHOVER               19
+#define ABS_RIGHTHOVER              20
+#define CP_DROPDOWNBUTTONRIGHT      6
+#define CP_DROPDOWNBUTTONLEFT       7
+#define SCRBS_HOVER                 5
+#define TVP_HOTGLYPH                4
+#define SPI_GETCLIENTAREAANIMATION  0x1042
+#define TDLG_PRIMARYPANEL           1
+#define TDLG_SECONDARYPANEL         8
+#endif
+
+class QWindowsVistaAnimation : public QBlendStyleAnimation
+{
+    Q_OBJECT
+public:
+    QWindowsVistaAnimation(Type type, QObject *target) : QBlendStyleAnimation(type, target) { }
+
+    bool isUpdateNeeded() const override;
+    void paint(QPainter *painter, const QStyleOption *option);
+};
+
+
+// Handles state transition animations
+class QWindowsVistaTransition : public QWindowsVistaAnimation
+{
+    Q_OBJECT
+public:
+    QWindowsVistaTransition(QObject *target) : QWindowsVistaAnimation(Transition, target) {}
+};
+
+
+// Handles pulse animations (default buttons)
+class QWindowsVistaPulse: public QWindowsVistaAnimation
+{
+    Q_OBJECT
+public:
+    QWindowsVistaPulse(QObject *target) : QWindowsVistaAnimation(Pulse, target) {}
+};
+
+
+class QWindowsVistaStylePrivate :  public QWindowsXPStylePrivate
+{
+    Q_DECLARE_PUBLIC(QWindowsVistaStyle)
+
+public:
+    QWindowsVistaStylePrivate();
+
+    static int fixedPixelMetric(QStyle::PixelMetric pm);
+    static inline bool useVista();
+    bool transitionsEnabled() const;
+};
+
+QT_END_NAMESPACE
+
+#endif // QWINDOWSVISTASTYLE_P_P_H
diff --git a/src/imports/nativestyle/qstyle/windows/qquickwindowsxpstyle.cpp b/src/imports/nativestyle/qstyle/windows/qquickwindowsxpstyle.cpp
new file mode 100644
index 00000000..6c63e3d6
--- /dev/null
+++ b/src/imports/nativestyle/qstyle/windows/qquickwindowsxpstyle.cpp
@@ -0,0 +1,4163 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWidgets module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qquickstylehelper_p.h"
+#include "qquickwindowsxpstyle_p.h"
+#include "qquickwindowsxpstyle_p_p.h"
+
+#include <private/qobject_p.h>
+#include <private/qpaintengine_raster_p.h>
+#include <qpa/qplatformnativeinterface.h>
+#include <qpainter.h>
+#include <qpaintengine.h>
+#include <qbackingstore.h>
+#include <qpixmapcache.h>
+#include <qpa/qplatformnativeinterface.h>
+
+#include <qvarlengtharray.h>
+#include <qdebug.h>
+
+#include <algorithm>
+
+QT_BEGIN_NAMESPACE
+
+// General const values
+static const int windowsItemFrame        =  2; // menu item frame width
+static const int windowsItemHMargin      =  3; // menu item hor text margin
+static const int windowsItemVMargin      =  0; // menu item ver text margin
+static const int windowsArrowHMargin     =  6; // arrow horizontal margin
+static const int windowsRightBorder      = 12; // right border on windows
+
+// Theme names matching the QWindowsXPStylePrivate::Theme enumeration.
+static const wchar_t *themeNames[QWindowsXPStylePrivate::NThemes] =
+{
+    L"BUTTON",   L"COMBOBOX",   L"EDIT",    L"HEADER",    L"LISTVIEW",
+    L"MENU",     L"PROGRESS",   L"REBAR",   L"SCROLLBAR", L"SPIN",
+    L"TAB",      L"TASKDIALOG", L"TOOLBAR", L"TOOLTIP",   L"TRACKBAR",
+    L"TREEVIEW", L"WINDOW",     L"STATUS",  L"TREEVIEW"
+};
+
+static inline QBackingStore *backingStoreForWidget(const QWidget *widget)
+{
+    if (QBackingStore *backingStore = widget->backingStore())
+        return backingStore;
+    if (const QWidget *topLevel = widget->nativeParentWidget())
+        if (QBackingStore *topLevelBackingStore = topLevel->backingStore())
+            return topLevelBackingStore;
+    return nullptr;
+}
+
+static inline HDC hdcForWidgetBackingStore(const QWidget *widget)
+{
+    if (QBackingStore *backingStore = backingStoreForWidget(widget)) {
+        QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface();
+        if (nativeInterface)
+            return static_cast<HDC>(nativeInterface->nativeResourceForBackingStore(QByteArrayLiteral("getDC"), backingStore));
+    }
+    return nullptr;
+}
+
+// Theme data helper ------------------------------------------------------------------------------
+/* \internal
+    Returns \c true if the themedata is valid for use.
+*/
+bool XPThemeData::isValid()
+{
+    return QWindowsXPStylePrivate::useXP() && theme >= 0 && 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 nullptr;
+
+    if (!htheme)
+        htheme = QWindowsXPStylePrivate::createTheme(theme, QWindowsXPStylePrivate::winId(widget));
+    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(QWidget *widget)
+{
+    if (!IsThemeBackgroundPartiallyTransparent(handle(), partId, stateId))
+        return nullptr;
+
+    HRGN hrgn;
+    HDC dc = nullptr;
+    if (widget)
+        dc = hdcForWidgetBackingStore(widget);
+    RECT nativeRect = toRECT(rect);
+    GetThemeBackgroundRegion(handle(), dc, partId, stateId, &nativeRect, &hrgn);
+    return hrgn;
+}
+
+// QWindowsXPStylePrivate -------------------------------------------------------------------------
+// Static initializations
+HWND QWindowsXPStylePrivate::m_vistaTreeViewHelper = nullptr;
+HTHEME QWindowsXPStylePrivate::m_themes[NThemes];
+bool QWindowsXPStylePrivate::use_xp = false;
+QBasicAtomicInt QWindowsXPStylePrivate::ref = Q_BASIC_ATOMIC_INITIALIZER(-1); // -1 based refcounting
+
+static void qt_add_rect(HRGN &winRegion, QRect r)
+{
+    HRGN rgn = CreateRectRgn(r.left(), r.top(), r.x() + r.width(), r.y() + r.height());
+    if (rgn) {
+        HRGN dest = CreateRectRgn(0,0,0,0);
+        int result = CombineRgn(dest, winRegion, rgn, RGN_OR);
+        if (result) {
+            DeleteObject(winRegion);
+            winRegion = dest;
+        }
+        DeleteObject(rgn);
+    }
+}
+
+static HRGN qt_hrgn_from_qregion(const QRegion &region)
+{
+    HRGN hRegion = CreateRectRgn(0,0,0,0);
+    if (region.rectCount() == 1) {
+        qt_add_rect(hRegion, region.boundingRect());
+        return hRegion;
+    }
+    for (const QRect &rect : region)
+        qt_add_rect(hRegion, rect);
+    return hRegion;
+}
+
+/* \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) {
+        use_xp = IsThemeActive() && (IsAppThemed() || !QCoreApplication::instance())
+                 && !QWindowsStylePrivate::isDarkMode();
+    }
+    return use_xp;
+}
+
+/* \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);
+    std::fill(m_themes, m_themes + NThemes, nullptr);
+}
+
+/* \internal
+    Cleans up all static data.
+*/
+void QWindowsXPStylePrivate::cleanup(bool force)
+{
+    if (bufferBitmap) {
+        if (bufferDC && nullBitmap)
+            SelectObject(bufferDC, nullBitmap);
+        DeleteObject(bufferBitmap);
+        bufferBitmap = nullptr;
+    }
+
+    if (bufferDC)
+        DeleteDC(bufferDC);
+    bufferDC = nullptr;
+
+    if (ref.deref() && !force)
+        return;
+    if (!force)  // -1 based atomic refcounting
+        ref.deref();
+
+    use_xp = false;
+    cleanupHandleMap();
+}
+
+/* In order to obtain the correct VistaTreeViewTheme (arrows for PE_IndicatorBranch),
+ * we need to set the windows "explorer" theme explicitly on a native
+ * window and open the "TREEVIEW" theme handle passing its window handle
+ * in order to get Vista-style item view themes (particulary drawBackground()
+ * for selected items needs this).
+ * We invoke a service of the native Windows interface to create
+ * a non-visible window handle, open the theme on it and insert it into
+ * the cache so that it is found by XPThemeData::handle() first.
+ */
+
+static inline HWND createTreeViewHelperWindow()
+{
+    if (QPlatformNativeInterface *ni = QGuiApplication::platformNativeInterface()) {
+        void *hwnd = nullptr;
+        void *wndProc = reinterpret_cast<void *>(DefWindowProc);
+        if (QMetaObject::invokeMethod(ni, "createMessageWindow", Qt::DirectConnection,
+                                  Q_RETURN_ARG(void*, hwnd),
+                                  Q_ARG(QString, QStringLiteral("QTreeViewThemeHelperWindowClass")),
+                                  Q_ARG(QString, QStringLiteral("QTreeViewThemeHelperWindow")),
+                                  Q_ARG(void*, wndProc)) && hwnd) {
+            return reinterpret_cast<HWND>(hwnd);
+        }
+    }
+    return nullptr;
+}
+
+bool QWindowsXPStylePrivate::initVistaTreeViewTheming()
+{
+    if (m_vistaTreeViewHelper)
+        return true;
+
+    m_vistaTreeViewHelper = createTreeViewHelperWindow();
+    if (!m_vistaTreeViewHelper) {
+        qWarning("Unable to create the treeview helper window.");
+        return false;
+    }
+    if (FAILED(SetWindowTheme(m_vistaTreeViewHelper, L"explorer", nullptr))) {
+        qErrnoWarning("SetWindowTheme() failed.");
+        cleanupVistaTreeViewTheming();
+        return false;
+    }
+    return true;
+}
+
+void QWindowsXPStylePrivate::cleanupVistaTreeViewTheming()
+{
+    if (m_vistaTreeViewHelper) {
+        DestroyWindow(m_vistaTreeViewHelper);
+        m_vistaTreeViewHelper = nullptr;
+    }
+}
+
+/* \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()
+{
+    for (auto &theme : m_themes) {
+        if (theme) {
+            CloseThemeData(theme);
+            theme = nullptr;
+        }
+    }
+    QWindowsXPStylePrivate::cleanupVistaTreeViewTheming();
+}
+
+HTHEME QWindowsXPStylePrivate::createTheme(int theme, HWND hwnd)
+{
+    if (Q_UNLIKELY(theme < 0 || theme >= NThemes || !hwnd)) {
+        qWarning("Invalid parameters #%d, %p", theme, hwnd);
+        return nullptr;
+    }
+    if (!m_themes[theme]) {
+        const wchar_t *name = themeNames[theme];
+        if (theme == VistaTreeViewTheme && QWindowsXPStylePrivate::initVistaTreeViewTheming())
+            hwnd = QWindowsXPStylePrivate::m_vistaTreeViewHelper;
+        m_themes[theme] = OpenThemeData(hwnd, name);
+        if (Q_UNLIKELY(!m_themes[theme]))
+            qErrnoWarning("OpenThemeData() failed for theme %d (%s).",
+                          theme, qPrintable(themeName(theme)));
+    }
+    return m_themes[theme];
+}
+
+QString QWindowsXPStylePrivate::themeName(int theme)
+{
+    return theme >= 0 && theme < NThemes ?
+           QString::fromWCharArray(themeNames[theme]) :
+           QString();
+}
+
+bool QWindowsXPStylePrivate::isItemViewDelegateLineEdit(const QWidget *widget)
+{
+    if (!widget)
+        return false;
+    const QWidget *parent1 = widget->parentWidget();
+    // Exlude dialogs or other toplevels parented on item views.
+    if (!parent1 || parent1->isWindow())
+        return false;
+    const QWidget *parent2 = parent1->parentWidget();
+    return parent2 && widget->inherits("QLineEdit")
+        && parent2->inherits("QAbstractItemView");
+}
+
+// Returns whether base color is set for this widget
+bool QWindowsXPStylePrivate::isLineEditBaseColorSet(const QStyleOption *option, const QWidget *widget)
+{
+    uint resolveMask = option->palette.resolve();
+    if (widget) {
+        // Since spin box includes a line edit we need to resolve the palette mask also from
+        // the parent, as while the color is always correct on the palette supplied by panel,
+        // the mask can still be empty. If either mask specifies custom base color, use that.
+#if QT_CONFIG(spinbox)
+        if (const QAbstractSpinBox *spinbox = qobject_cast<QAbstractSpinBox*>(widget->parentWidget()))
+            resolveMask |= spinbox->palette().resolve();
+#endif // QT_CONFIG(spinbox)
+    }
+    return (resolveMask & (1 << QPalette::Base)) != 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)
+        if (const HWND hwnd = QApplicationPrivate::getHWNDForWidget(const_cast<QWidget *>(widget)))
+            return hwnd;
+
+    // Find top level with native window (there might be dialogs that do not have one).
+    const auto allWindows = QGuiApplication::allWindows();
+    for (const QWindow *window : allWindows) {
+        if (window->isTopLevel() && window->type() != Qt::Desktop && window->handle() != nullptr)
+            return reinterpret_cast<HWND>(window->winId());
+    }
+
+    return GetDesktopWindow();
+}
+
+/*! \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 = nullptr;
+    }
+
+    w = qMax(bufferW, w);
+    h = qMax(bufferH, h);
+
+    if (!bufferDC) {
+        HDC displayDC = GetDC(nullptr);
+        bufferDC = CreateCompatibleDC(displayDC);
+        ReleaseDC(nullptr, displayDC);
+    }
+
+    // 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 = nullptr;
+    bufferBitmap = CreateDIBSection(bufferDC, &bmi, DIB_RGB_COLORS, reinterpret_cast<void **>(&bufferPixels), nullptr, 0);
+    GdiFlush();
+    nullBitmap = static_cast<HBITMAP>(SelectObject(bufferDC, bufferBitmap));
+
+    if (Q_UNLIKELY(!bufferBitmap)) {
+        qErrnoWarning("QWindowsXPStylePrivate::buffer(%dx%d), CreateDIBSection() failed.", w, h);
+        bufferW = 0;
+        bufferH = 0;
+        return nullptr;
+    }
+    if (Q_UNLIKELY(!bufferPixels)) {
+        qErrnoWarning("QWindowsXPStylePrivate::buffer(%dx%d), CreateDIBSection() did not allocate pixel data.", w, h);
+        bufferW = 0;
+        bufferH = 0;
+        return nullptr;
+    }
+    bufferW = w;
+    bufferH = h;
+#ifdef DEBUG_XP_STYLE
+    qDebug("Creating new dib section (%d, %d)", w, h);
+#endif
+    return bufferBitmap;
+}
+
+/*! \internal
+    Returns \c 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 IsThemeBackgroundPartiallyTransparent(themeData.handle(), themeData.partId,
+                                                 themeData.stateId);
+}
+
+
+/*! \internal
+    Returns a QRegion of the region of the part
+*/
+QRegion QWindowsXPStylePrivate::region(XPThemeData &themeData)
+{
+    HRGN hRgn = nullptr;
+    const qreal factor = QWindowsStylePrivate::nativeMetricScaleFactor(themeData.widget);
+    RECT rect = themeData.toRECT(QRect(themeData.rect.topLeft() / factor, themeData.rect.size() / factor));
+    if (!SUCCEEDED(GetThemeBackgroundRegion(themeData.handle(), bufferHDC(), themeData.partId,
+                                            themeData.stateId, &rect, &hRgn))) {
+        return QRegion();
+    }
+
+    HRGN dest = CreateRectRgn(0, 0, 0, 0);
+    const bool success = CombineRgn(dest, hRgn, nullptr, RGN_COPY) != ERROR;
+
+    QRegion region;
+
+    if (success) {
+        const auto numBytes = GetRegionData(dest, 0, nullptr);
+        if (numBytes == 0)
+            return QRegion();
+
+        char *buf = new (std::nothrow) char[numBytes];
+        if (!buf)
+            return QRegion();
+
+        RGNDATA *rd = reinterpret_cast<RGNDATA*>(buf);
+        if (GetRegionData(dest, numBytes, rd) == 0) {
+            delete [] buf;
+            return QRegion();
+        }
+
+        RECT *r = reinterpret_cast<RECT*>(rd->Buffer);
+        for (uint i = 0; i < rd->rdh.nCount; ++i) {
+            QRect rect;
+            rect.setCoords(int(r->left * factor), int(r->top * factor), int((r->right - 1) * factor), int((r->bottom - 1) * factor));
+            ++r;
+            region |= rect;
+        }
+
+        delete [] buf;
+    }
+
+    DeleteObject(hRgn);
+    DeleteObject(dest);
+
+    return region;
+}
+
+/*! \internal
+    Returns \c 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) {
+        auto buffer = reinterpret_cast<const 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) {
+        auto buffer = reinterpret_cast<DWORD *>(bufferPixels) + (y * bufferW);
+        for (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) {
+        auto buffer = reinterpret_cast<DWORD *>(bufferPixels) + (y * bufferW);
+        for (int x = startX; x < w; ++x, ++buffer) {
+            if (allPixels) {
+                *buffer |= 0xFF000000;
+                continue;
+            }
+            unsigned int alphaValue = (*buffer) & 0xFF000000;
+            if (alphaValue == 0xFF000000) {
+                *buffer = 0;
+                valueChange = true;
+            } else if (alphaValue == 0) {
+                *buffer |= 0xFF000000;
+                valueChange = true;
+            }
+        }
+    }
+    return valueChange;
+}
+
+enum TransformType { SimpleTransform, HighDpiScalingTransform, ComplexTransform };
+
+static inline TransformType transformType(const QTransform &transform, qreal devicePixelRatio)
+{
+    if (transform.type() <= QTransform::TxTranslate)
+        return SimpleTransform;
+    if (transform.type() > QTransform::TxScale)
+        return ComplexTransform;
+    return qFuzzyCompare(transform.m11(), devicePixelRatio)
+        && qFuzzyCompare(transform.m22(), devicePixelRatio)
+        ? HighDpiScalingTransform : ComplexTransform;
+}
+
+// QTBUG-60571: Exclude known fully opaque theme parts which produce values
+// invalid in ARGB32_Premultiplied (for example, 0x00ffffff).
+static inline bool isFullyOpaque(const XPThemeData &themeData)
+{
+    return themeData.theme == QWindowsXPStylePrivate::TaskDialogTheme && themeData.partId == TDLG_PRIMARYPANEL;
+}
+
+/*! \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().
+    \note drawBackgroundThruNativeBuffer() can return false for large
+    sizes due to buffer()/CreateDIBSection() failing.
+*/
+bool QWindowsXPStylePrivate::drawBackground(XPThemeData &themeData, qreal correctionFactor)
+{
+    if (themeData.rect.isEmpty())
+        return true;
+
+    QPainter *painter = themeData.painter;
+    Q_ASSERT_X(painter != nullptr, "QWindowsXPStylePrivate::drawBackground()", "Trying to draw a theme part without a painter");
+    if (!painter || !painter->isActive())
+        return false;
+
+    painter->save();
+
+    // Access paintDevice via engine since the painter may
+    // return the clip device which can still be a widget device in case of grabWidget().
+
+    bool translucentToplevel = false;
+    const QPaintDevice *paintDevice = painter->device();
+    const qreal aditionalDevicePixelRatio = themeData.widget ? themeData.widget->devicePixelRatioF() : qreal(1);
+    if (paintDevice->devType() == QInternal::Widget) {
+        const QWidget *window = static_cast<const QWidget *>(paintDevice)->window();
+        translucentToplevel = window->testAttribute(Qt::WA_TranslucentBackground);
+    }
+
+    const TransformType tt = transformType(painter->deviceTransform(), aditionalDevicePixelRatio);
+
+    bool canDrawDirectly = false;
+    if (themeData.widget && painter->opacity() == 1.0 && !themeData.rotate
+        && !isFullyOpaque(themeData)
+        && tt != ComplexTransform && !themeData.mirrorVertically
+        && !translucentToplevel) {
+        // Draw on backing store DC only for real widgets or backing store images.
+        const QPaintDevice *enginePaintDevice = painter->paintEngine()->paintDevice();
+        switch (enginePaintDevice->devType()) {
+        case QInternal::Widget:
+            canDrawDirectly = true;
+            break;
+        case QInternal::Image:
+            // Ensure the backing store has received as resize and is initialized.
+            if (QBackingStore *bs = backingStoreForWidget(themeData.widget))
+                if (bs->size().isValid() && bs->paintDevice() == enginePaintDevice)
+                    canDrawDirectly = true;
+        }
+    }
+
+    const HDC dc = canDrawDirectly ? hdcForWidgetBackingStore(themeData.widget) : nullptr;
+    const bool result = dc && qFuzzyCompare(correctionFactor, qreal(1))
+        ? drawBackgroundDirectly(dc, themeData, aditionalDevicePixelRatio)
+        : drawBackgroundThruNativeBuffer(themeData, aditionalDevicePixelRatio, correctionFactor);
+    painter->restore();
+    return result;
+}
+
+static inline QRectF scaleRect(const QRectF &r, qreal factor)
+{
+    return r.isValid() && factor > 1
+        ? QRectF(r.topLeft() * factor, r.size() * factor)
+        : r;
+}
+
+static QRegion scaleRegion(const QRegion &region, qreal factor)
+{
+    if (region.isEmpty() || qFuzzyCompare(factor, qreal(1)))
+        return region;
+    QRegion result;
+    for (const QRect &rect : region)
+        result += QRectF(QPointF(rect.topLeft()) * factor, QSizeF(rect.size() * factor)).toRect();
+    return result;
+}
+
+/*! \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.
+*/
+bool QWindowsXPStylePrivate::drawBackgroundDirectly(HDC dc, XPThemeData &themeData, qreal additionalDevicePixelRatio)
+{
+    QPainter *painter = themeData.painter;
+
+    const auto &deviceTransform = painter->deviceTransform();
+    const QPointF redirectionDelta(deviceTransform.dx(), deviceTransform.dy());
+    const QRect area = scaleRect(QRectF(themeData.rect), additionalDevicePixelRatio).translated(redirectionDelta).toRect();
+
+    QRegion sysRgn = painter->paintEngine()->systemClip();
+    if (sysRgn.isEmpty())
+        sysRgn = area;
+    else
+        sysRgn &= area;
+    if (painter->hasClipping())
+        sysRgn &= scaleRegion(painter->clipRegion(), additionalDevicePixelRatio).translated(redirectionDelta.toPoint());
+    HRGN hrgn = qt_hrgn_from_qregion(sysRgn);
+    SelectClipRgn(dc, hrgn);
+
+#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;
+    memset(&drawOptions, 0, sizeof(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);
+
+    const HRESULT result = DrawThemeBackgroundEx(themeData.handle(), dc, themeData.partId, themeData.stateId, &(drawRECT), &drawOptions);
+    SelectClipRgn(dc, nullptr);
+    DeleteObject(hrgn);
+    return SUCCEEDED(result);
+}
+
+/*! \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).
+
+    \a correctionFactor is an additional factor used to scale up controls
+    that are too small on High DPI screens, as has been observed for
+    WP_MDICLOSEBUTTON, WP_MDIRESTOREBUTTON, WP_MDIMINBUTTON (QTBUG-75927).
+*/
+bool QWindowsXPStylePrivate::drawBackgroundThruNativeBuffer(XPThemeData &themeData,
+                                                            qreal additionalDevicePixelRatio,
+                                                            qreal correctionFactor)
+{
+    QPainter *painter = themeData.painter;
+    QRectF rectF = scaleRect(QRectF(themeData.rect), additionalDevicePixelRatio);
+
+    if ((themeData.rotate + 90) % 180 == 0) { // Catch 90,270,etc.. degree flips.
+        rectF = QRectF(0, 0, rectF.height(), rectF.width());
+    }
+    rectF.moveTo(0, 0);
+
+    const bool hasCorrectionFactor = !qFuzzyCompare(correctionFactor, qreal(1));
+    QRect rect = rectF.toRect();
+    QRect drawRect = hasCorrectionFactor
+        ? QRectF(rectF.topLeft() / correctionFactor, rectF.size() / correctionFactor).toRect() : rect;
+    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 potentialInvalidAlpha;
+
+    QString pixmapCacheKey = QStringLiteral("$qt_xp_");
+    pixmapCacheKey.append(themeName(themeData.theme));
+    pixmapCacheKey.append(QLatin1Char('p'));
+    pixmapCacheKey.append(QString::number(partId));
+    pixmapCacheKey.append(QLatin1Char('s'));
+    pixmapCacheKey.append(QString::number(stateId));
+    pixmapCacheKey.append(QLatin1Char('s'));
+    pixmapCacheKey.append(themeData.noBorder ? QLatin1Char('0') : QLatin1Char('1'));
+    pixmapCacheKey.append(QLatin1Char('b'));
+    pixmapCacheKey.append(themeData.noContent ? QLatin1Char('0') : QLatin1Char('1'));
+    pixmapCacheKey.append(QString::number(w));
+    pixmapCacheKey.append(QLatin1Char('w'));
+    pixmapCacheKey.append(QString::number(h));
+    pixmapCacheKey.append(QLatin1Char('h'));
+    pixmapCacheKey.append(QString::number(additionalDevicePixelRatio));
+    pixmapCacheKey.append(QLatin1Char('d'));
+    if (hasCorrectionFactor) {
+        pixmapCacheKey.append(QLatin1Char('c'));
+        pixmapCacheKey.append(QString::number(correctionFactor));
+    }
+
+    QPixmap cachedPixmap;
+    ThemeMapKey key(themeData);
+    ThemeMapData data = alphaCache.value(key);
+
+    bool haveCachedPixmap = false;
+    bool isCached = data.dataValid;
+    if (isCached) {
+        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;
+        GetThemeBool(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERONLY, &tmt_borderonly);
+        GetThemeColor(themeData.handle(), themeData.partId, themeData.stateId, TMT_TRANSPARENTCOLOR, &tmt_transparentcolor);
+        GetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_CAPTIONMARGINS, &proporigin);
+
+        partIsTransparent = isTransparent(themeData);
+
+        potentialInvalidAlpha = false;
+        GetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_GLYPHTYPE, &proporigin);
+        if (proporigin == PO_PART || proporigin == PO_STATE) {
+            int tmt_glyphtype = GT_NONE;
+            GetThemeEnumValue(themeData.handle(), themeData.partId, themeData.stateId, TMT_GLYPHTYPE, &tmt_glyphtype);
+            potentialInvalidAlpha = partIsTransparent && 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("-->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 = drawRect;
+    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;
+        GetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &origin);
+        GetThemeInt(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &borderSize);
+        borderSize *= additionalDevicePixelRatio;
+
+        // 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! -------------------------
+        if (!buffer(drawRect.width(), drawRect.height())) // Ensure a buffer of at least (w, h) in size
+            return false;
+        HDC dc = bufferHDC();
+
+        // Clear the buffer
+        if (alphaType != NoAlpha) {
+            // Consider have separate "memset" function for small chunks for more speedup
+            memset(bufferPixels, 0x00, bufferW * drawRect.height() * 4);
+        }
+
+        // Difference between area and rect
+        int dx = area.x() - drawRect.x();
+        int dy = area.y() - drawRect.y();
+
+        // 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
+        RECT wRect(themeData.toRECT(area));
+        DrawThemeBackgroundEx(themeData.handle(), dc, themeData.partId, themeData.stateId, &wRect, &drawOptions);
+
+        // If not cached, analyze the buffer data to figure
+        // out alpha type, and if it contains data
+        if (!isCached) {
+            // SHORTCUT: If the part's state has no data, cache it for NOOP later
+            if (!stateHasData) {
+                memset(static_cast<void *>(&data), 0, sizeof(data));
+                data.dataValid = true;
+                alphaCache.insert(key, data);
+                return true;
+            }
+            hasAlpha = hasAlphaChannel(rect);
+            if (!hasAlpha && partIsTransparent)
+                potentialInvalidAlpha = true;
+#if defined(DEBUG_XP_STYLE) && 1
+            dumpNativeDIB(drawRect.width(), drawRect.height());
+#endif
+        }
+
+        // Fix alpha values, if needed
+        if (potentialInvalidAlpha)
+            wasAlphaFixed = fixAlphaChannel(drawRect);
+
+        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);
+        if (hasCorrectionFactor)
+            img = img.scaled(w, h, Qt::KeepAspectRatio, Qt::SmoothTransformation);
+        img.setDevicePixelRatio(additionalDevicePixelRatio);
+    }
+
+    // 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");
+        for (const QRect &r : newRegion)
+            printf("    (%d, %d, %d, %d)\n", r.x(), r.y(), r.right(), r.bottom());
+#endif
+    }
+
+    if (addBorderContentClipping)
+        painter->setClipRegion(scaleRegion(extraClip, 1.0 / additionalDevicePixelRatio), 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) {
+            QTransform 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(static_cast<void *>(&data), 0, sizeof(data));
+        data.dataValid = true;
+        data.partIsTransparent = partIsTransparent;
+        data.alphaType = alphaType;
+        data.hasAlphaChannel = hasAlpha;
+        data.wasAlphaSwapped = wasAlphaSwapped;
+        data.hadInvalidAlpha = wasAlphaFixed;
+        alphaCache.insert(key, data);
+    }
+    return true;
+}
+
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \class QWindowsXPStyle
+    \brief The QWindowsXPStyle class provides a Microsoft Windows XP-like look and feel.
+
+    \ingroup appearance
+    \inmodule QtWidgets
+    \internal
+
+    \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(), proxy()->subControlRect(), and
+    sizeFromContents(), are documented here.
+
+    \image qwindowsxpstyle.png
+    \sa QMacStyle, QWindowsStyle, QFusionStyle
+*/
+
+/*!
+    Constructs a QWindowsStyle
+*/
+QWindowsXPStyle::QWindowsXPStyle()
+    : QWindowsStyle(*new QWindowsXPStylePrivate)
+{
+}
+
+/*!
+    Destroys the style.
+*/
+QWindowsXPStyle::~QWindowsXPStyle() = default;
+
+/*! \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 (false
+#if QT_CONFIG(abstractbutton)
+        || qobject_cast<QAbstractButton*>(widget)
+#endif
+        || qobject_cast<QToolButton*>(widget)
+        || qobject_cast<QTabBar*>(widget)
+#if QT_CONFIG(combobox)
+        || qobject_cast<QComboBox*>(widget)
+#endif // QT_CONFIG(combobox)
+        || qobject_cast<QScrollBar*>(widget)
+        || qobject_cast<QSlider*>(widget)
+        || qobject_cast<QHeaderView*>(widget)
+#if QT_CONFIG(spinbox)
+        || qobject_cast<QAbstractSpinBox*>(widget)
+        || qobject_cast<QSpinBox*>(widget)
+#endif // QT_CONFIG(spinbox)
+        ) {
+        widget->setAttribute(Qt::WA_Hover);
+    }
+
+#if QT_CONFIG(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(widget, nullptr, QWindowsXPStylePrivate::ButtonTheme, 0, 0);
+        GetThemeColor(theme.handle(), BP_GROUPBOX, GBS_NORMAL, TMT_TEXTCOLOR, &cref);
+        d->groupBoxTextColor = qRgb(GetRValue(cref), GetGValue(cref), GetBValue(cref));
+        GetThemeColor(theme.handle(), BP_GROUPBOX, GBS_DISABLED, TMT_TEXTCOLOR, &cref);
+        d->groupBoxTextColorDisabled = qRgb(GetRValue(cref), GetGValue(cref), GetBValue(cref));
+        // Where does this color come from?
+        //GetThemeColor(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)
+{
+#if QT_CONFIG(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 (false
+#if QT_CONFIG(abstractbutton)
+        || qobject_cast<QAbstractButton*>(widget)
+#endif
+        || qobject_cast<QToolButton*>(widget)
+        || qobject_cast<QTabBar*>(widget)
+#if QT_CONFIG(combobox)
+        || qobject_cast<QComboBox*>(widget)
+#endif // QT_CONFIG(combobox)
+        || qobject_cast<QScrollBar*>(widget)
+        || qobject_cast<QSlider*>(widget)
+        || qobject_cast<QHeaderView*>(widget)
+#if QT_CONFIG(spinbox)
+        || qobject_cast<QAbstractSpinBox*>(widget)
+        || qobject_cast<QSpinBox*>(widget)
+#endif // QT_CONFIG(spinbox)
+        ) {
+        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) {
+                if (const QTabWidget *tabWidget = qobject_cast<const QTabWidget *>(widget)) {
+                    if (tabWidget->documentMode())
+                        break;
+                }
+
+                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 = proxy()->pixelMetric(PM_TabBarBaseOverlap, &otherOption, widget);
+            int borderThickness = proxy()->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) {
+                XPThemeData buttontheme(widget, nullptr, QWindowsXPStylePrivate::ButtonTheme);
+                HTHEME theme = buttontheme.handle();
+                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 = proxy()->pixelMetric(PM_DefaultFrameWidth, btn, widget);
+                    rect = option->rect.adjusted(border, border, -border, -border);
+
+                    if (SUCCEEDED(GetThemeMargins(theme, nullptr, BP_PUSHBUTTON, stateId, TMT_CONTENTMARGINS, nullptr, &borderSize))) {
+                        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;
+    }
+
+    int themeNumber = -1;
+    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:
+        themeNumber = QWindowsXPStylePrivate::ButtonTheme;
+        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;
+        }
+        themeNumber = QWindowsXPStylePrivate::ToolBarTheme;
+        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:
+        themeNumber = QWindowsXPStylePrivate::ToolBarTheme;
+        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:
+        themeNumber = QWindowsXPStylePrivate::ButtonTheme;
+        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:
+        themeNumber = QWindowsXPStylePrivate::ButtonTheme;
+        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;
+        themeNumber = QWindowsXPStylePrivate::ListViewTheme;
+        partId = LVP_LISTGROUP;
+        XPThemeData theme(widget, nullptr, themeNumber, partId);
+
+        if (!(flags & State_Enabled))
+            stateId = ETS_DISABLED;
+        else
+            stateId = ETS_NORMAL;
+        int fillType;
+        if (GetThemeEnumValue(theme.handle(), partId, stateId, TMT_BGTYPE, &fillType) == S_OK) {
+            if (fillType == BT_BORDERFILL) {
+                COLORREF bcRef;
+                GetThemeColor(theme.handle(), partId, stateId, TMT_BORDERCOLOR, &bcRef);
+                QColor bordercolor(qRgb(GetRValue(bcRef), GetGValue(bcRef), GetBValue(bcRef)));
+                QPen oldPen = p->pen();
+                // int borderSize = 1;
+                // GetThemeInt(theme.handle(), partId, stateId, TMT_BORDERCOLOR, &borderSize);
+
+                // Inner white border
+                p->setPen(QPen(option->palette.base().color(), 0));
+                const qreal dpi = QStyleHelper::dpi(option);
+                const auto topLevelAdjustment = QStyleHelper::dpiScaled(0.5, dpi);
+                const auto bottomRightAdjustment = QStyleHelper::dpiScaled(-1, dpi);
+                p->drawRect(QRectF(option->rect).adjusted(topLevelAdjustment, topLevelAdjustment,
+                                                          bottomRightAdjustment, bottomRightAdjustment));
+                // Outer dark border
+                p->setPen(QPen(bordercolor, 0));
+                p->drawRect(QRectF(option->rect).adjusted(0, 0, -topLevelAdjustment, -topLevelAdjustment));
+                p->setPen(oldPen);
+                return;
+            }
+            if (fillType == BT_NONE)
+                return;
+        }
+        break;
+    }
+    case PE_FrameLineEdit: {
+        // we try to check if this lineedit is a delegate on a QAbstractItemView-derived class.
+        if (QWindowsXPStylePrivate::isItemViewDelegateLineEdit(widget)) {
+            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;
+        }
+        if (qstyleoption_cast<const QStyleOptionFrame *>(option)) {
+            themeNumber = QWindowsXPStylePrivate::EditTheme;
+            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)) {
+            themeNumber = QWindowsXPStylePrivate::EditTheme;
+            partId = EP_EDITTEXT;
+            noBorder = true;
+            bool isEnabled = flags & State_Enabled;
+
+            stateId = isEnabled ? ETS_NORMAL : ETS_DISABLED;
+
+            if (QWindowsXPStylePrivate::isLineEditBaseColorSet(option, widget)) {
+                p->fillRect(panel->rect, panel->palette.brush(QPalette::Base));
+            } else {
+                XPThemeData theme(nullptr, p, themeNumber, partId, stateId, rect);
+                if (!theme.isValid()) {
+                    QWindowsStyle::drawPrimitive(pe, option, p, widget);
+                    return;
+                }
+                int bgType;
+                GetThemeEnumValue(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;
+                        GetThemePropertyOrigin(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;
+                            GetThemeColor(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)
+                proxy()->drawPrimitive(PE_FrameLineEdit, panel, p, widget);
+            return;
+        }
+        break;
+
+    case PE_FrameTabWidget:
+        if (const QStyleOptionTabWidgetFrame *tab = qstyleoption_cast<const QStyleOptionTabWidgetFrame *>(option))
+        {
+            themeNumber = QWindowsXPStylePrivate::TabTheme;
+            partId = TABP_PANE;
+
+            if (widget) {
+                bool useGradient = true;
+                const int maxlength = 256;
+                wchar_t themeFileName[maxlength];
+                wchar_t themeColor[maxlength];
+                // Due to a a scaling issue with the XP Silver theme, tab gradients are not used with it
+                if (GetCurrentThemeName(themeFileName, maxlength, themeColor, maxlength, nullptr, 0) == S_OK) {
+                    wchar_t *offset = nullptr;
+                    if ((offset = wcsrchr(themeFileName, QChar(QLatin1Char('\\')).unicode())) != nullptr) {
+                        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, themeNumber, 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))
+        {
+            themeNumber = QWindowsXPStylePrivate::WindowTheme;
+            if (flags & State_Active)
+                stateId = FS_ACTIVE;
+            else
+                stateId = FS_INACTIVE;
+
+            int fwidth = proxy()->pixelMetric(PM_DockWidgetFrameWidth, frm, widget);
+
+            XPThemeData theme(widget, p, themeNumber, 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 = QWindowsXPStylePrivate::HeaderTheme;
+            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:
+        themeNumber = QWindowsXPStylePrivate::StatusTheme;
+        partId = SP_PANE;
+        break;
+
+    case PE_FrameGroupBox:
+        themeNumber = QWindowsXPStylePrivate::ButtonTheme;
+        partId = BP_GROUPBOX;
+        if (!(flags & State_Enabled))
+            stateId = GBS_DISABLED;
+        else
+            stateId = GBS_NORMAL;
+        if (const QStyleOptionFrame *frame = qstyleoption_cast<const QStyleOptionFrame *>(option)) {
+            if (frame->features & QStyleOptionFrame::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);
+                themeNumber = -1;
+            }
+        }
+        break;
+
+    case PE_IndicatorProgressChunk:
+        {
+        Qt::Orientation orient = Qt::Horizontal;
+        bool inverted = false;
+        if (const QStyleOptionProgressBar *pb = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {
+            orient = pb->orientation;
+            inverted = pb->invertedAppearance;
+        }
+        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());
+        }
+        themeNumber = QWindowsXPStylePrivate::ProgressTheme;
+        stateId = 1;
+        }
+        break;
+
+    case PE_FrameWindow:
+        if (const QStyleOptionFrame *frm = qstyleoption_cast<const QStyleOptionFrame *>(option))
+        {
+            themeNumber = QWindowsXPStylePrivate::WindowTheme;
+            if (flags & State_Active)
+                stateId = FS_ACTIVE;
+            else
+                stateId = FS_INACTIVE;
+
+            int fwidth = int((frm->lineWidth + frm->midLineWidth) / QWindowsStylePrivate::nativeMetricScaleFactor(widget));
+
+            XPThemeData theme(widget, p, themeNumber, 0, stateId);
+            if (!theme.isValid())
+                break;
+
+            // May fail due to too-large buffers for large widgets, fall back to Windows style.
+            theme.rect = QRect(option->rect.x(), option->rect.y()+fwidth, option->rect.x()+fwidth, option->rect.height()-fwidth);
+            theme.partId = WP_FRAMELEFT;
+            if (!d->drawBackground(theme)) {
+                QWindowsStyle::drawPrimitive(pe, option, p, widget);
+                return;
+            }
+            theme.rect = QRect(option->rect.width()-fwidth, option->rect.y()+fwidth, fwidth, option->rect.height()-fwidth);
+            theme.partId = WP_FRAMERIGHT;
+            if (!d->drawBackground(theme)) {
+                QWindowsStyle::drawPrimitive(pe, option, p, widget);
+                return;
+            }
+            theme.rect = QRect(option->rect.x(), option->rect.height()-fwidth, option->rect.width(), fwidth);
+            theme.partId = WP_FRAMEBOTTOM;
+            if (!d->drawBackground(theme)) {
+                QWindowsStyle::drawPrimitive(pe, option, p, widget);
+                return;
+            }
+            theme.rect = QRect(option->rect.x(), option->rect.y(), option->rect.width(), option->rect.y()+fwidth);
+            theme.partId = WP_CAPTION;
+            if (!d->drawBackground(theme))
+                QWindowsStyle::drawPrimitive(pe, option, p, widget);
+            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(nullptr, p, QWindowsXPStylePrivate::XpTreeViewTheme);
+                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:
+        if (option->rect.height() < 3) {
+            // XP style requires a few pixels for the separator
+            // to be visible.
+            QWindowsStyle::drawPrimitive(pe, option, p, widget);
+            return;
+        }
+        themeNumber = QWindowsXPStylePrivate::ToolBarTheme;
+        partId = TP_SEPARATOR;
+
+        if (option->state & State_Horizontal)
+            partId = TP_SEPARATOR;
+        else
+            partId = TP_SEPARATORVERT;
+
+        break;
+
+    case PE_IndicatorToolBarHandle:
+
+        themeNumber = QWindowsXPStylePrivate::RebarTheme;
+        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;
+        proxy()->drawPrimitive(PE_IndicatorCheckBox, &button, p, widget);
+        return;
+    }
+
+    default:
+        break;
+    }
+
+    XPThemeData theme(widget, p, themeNumber, 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;
+
+    int themeNumber = -1;
+    int partId = 0;
+    int stateId = 0;
+    switch (element) {
+    case CE_SizeGrip:
+        {
+            themeNumber = QWindowsXPStylePrivate::StatusTheme;
+            partId = SP_GRIPPER;
+            XPThemeData theme(nullptr, p, themeNumber, partId);
+            QSize size = (theme.size() * QWindowsStylePrivate::nativeMetricScaleFactor(widget)).toSize();
+            size.rheight()--;
+            if (const QStyleOptionSizeGrip *sg = qstyleoption_cast<const QStyleOptionSizeGrip *>(option)) {
+                switch (sg->corner) {
+                    case Qt::BottomRightCorner:
+                        rect = QRect(QPoint(rect.right() - size.width(), rect.bottom() - size.height()), size);
+                        break;
+                    case Qt::BottomLeftCorner:
+                        rect = QRect(QPoint(rect.left() + 1, rect.bottom() - size.height()), size);
+                        hMirrored = true;
+                        break;
+                    case Qt::TopRightCorner:
+                        rect = QRect(QPoint(rect.right() - size.width(), rect.top() + 1), size);
+                        vMirrored = true;
+                        break;
+                    case Qt::TopLeftCorner:
+                        rect = QRect(rect.topLeft() + QPoint(1, 1), size);
+                        hMirrored = vMirrored = true;
+                }
+            }
+        }
+        break;
+
+    case CE_HeaderSection:
+        themeNumber = QWindowsXPStylePrivate::HeaderTheme;
+        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))
+        {
+            themeNumber = QWindowsXPStylePrivate::ButtonTheme;
+            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, themeNumber, partId, stateId, rect);
+                d->drawBackground(theme);
+            }
+
+            if (btn->features & QStyleOptionButton::HasMenu) {
+                int mbiw = 0, mbih = 0;
+                XPThemeData theme(widget, nullptr,
+                                  QWindowsXPStylePrivate::ToolBarTheme,
+                                  TP_SPLITBUTTONDROPDOWN);
+                if (theme.isValid()) {
+                    const QSize size = (theme.size() * QWindowsStylePrivate::nativeMetricScaleFactor(widget)).toSize();
+                    mbiw = size.width();
+                    mbih = size.height();
+                }
+
+                QRect ir = btn->rect;
+                QStyleOptionButton newBtn = *btn;
+                newBtn.rect = QRect(ir.right() - mbiw - 1, 1 + (ir.height()/2) - (mbih/2), mbiw, mbih);
+                proxy()->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))
+        {
+            themeNumber = QWindowsXPStylePrivate::TabTheme;
+            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 = proxy()->styleHint(SH_TabBar_Alignment, tab, widget) == Qt::AlignLeft;
+            bool centerAligned = proxy()->styleHint(SH_TabBar_Alignment, tab, widget) == Qt::AlignCenter;
+            int borderThickness = proxy()->pixelMetric(PM_DefaultFrameWidth, option, widget);
+            int tabOverlap = proxy()->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:
+                themeNumber = -1; // 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 QStyleOptionProgressBar *pb = qstyleoption_cast<const QStyleOptionProgressBar *>(option))
+            orient = pb->orientation;
+        partId = (orient == Qt::Horizontal) ? PP_BAR : PP_BARVERT;
+        themeNumber = QWindowsXPStylePrivate::ProgressTheme;
+        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(proxy()->pixelMetric(PM_SmallIconSize, option, widget), mode, QIcon::On) :
+                                 menuitem->icon.pixmap(proxy()->pixelMetric(PM_SmallIconSize, option, widget), mode);
+                const int pixw = pixmap.width() / pixmap.devicePixelRatio();
+                const int pixh = pixmap.height() / pixmap.devicePixelRatio();
+                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, -1, 0, 0));
+                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);
+                proxy()->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 (!proxy()->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 && proxy()->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 && proxy()->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());
+                proxy()->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(proxy()->pixelMetric(PM_SmallIconSize, option, widget), QIcon::Normal);
+
+            uint alignment = Qt::AlignCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;
+            if (!proxy()->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;
+#if QT_CONFIG(dockwidget)
+    case CE_DockWidgetTitle:
+        if (const QStyleOptionDockWidget *dwOpt = qstyleoption_cast<const QStyleOptionDockWidget *>(option))
+        {
+            int buttonMargin = 4;
+            int mw = proxy()->pixelMetric(QStyle::PM_DockWidgetTitleMargin, dwOpt, widget);
+            int fw = proxy()->pixelMetric(PM_DockWidgetFrameWidth, dwOpt, widget);
+            bool isFloating = widget && widget->isWindow();
+            bool isActive = dwOpt->state & State_Active;
+
+            const bool verticalTitleBar = dwOpt->verticalTitleBar;
+
+            if (verticalTitleBar) {
+                rect = rect.transposed();
+
+                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 = proxy()->standardIcon(QStyle::SP_TitleBarCloseButton, dwOpt, widget).actualSize(QSize(10, 10));
+                titleRect.adjust(0, 0, -sz.width() - mw - buttonMargin, 0);
+            }
+
+            if (dwOpt->floatable) {
+                QSize sz = proxy()->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 != nullptr && widget->windowIcon().cacheKey() != QApplication::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 {
+                themeNumber = QWindowsXPStylePrivate::WindowTheme;
+                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, themeNumber, 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() != QApplication::windowIcon().cacheKey());
+                if (hasIcon) {
+                    QPixmap pxIco = ico.pixmap(titleHeight);
+                    if (!verticalTitleBar && dwOpt->direction == 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;
+                    GetThemeEnumValue(theme.handle(), WP_SMALLCAPTION, isActive ? CS_ACTIVE : CS_INACTIVE, TMT_TEXTSHADOWTYPE, &result);
+                    if (result != TST_NONE) {
+                        COLORREF textShadowRef;
+                        GetThemeColor(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_CONFIG(dockwidget)
+#if QT_CONFIG(rubberband)
+    case CE_RubberBand:
+        if (qstyleoption_cast<const QStyleOptionRubberBand *>(option)) {
+            QColor highlight = option->palette.color(QPalette::Active, QPalette::Highlight);
+            p->save();
+            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;
+        }
+        break;
+#endif // QT_CONFIG(rubberband)
+    case CE_HeaderEmptyArea:
+        if (option->state & State_Horizontal)
+        {
+            themeNumber = QWindowsXPStylePrivate::HeaderTheme;
+            stateId = HIS_NORMAL;
+        }
+        else {
+            QWindowsStyle::drawControl(CE_HeaderEmptyArea, option, p, widget);
+            return;
+        }
+        break;
+    default:
+        break;
+    }
+
+    XPThemeData theme(widget, p, themeNumber, 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);
+}
+
+QRect QWindowsXPStylePrivate::scrollBarGripperBounds(QStyle::State flags, const QWidget *widget, XPThemeData *theme)
+{
+    const bool horizontal = flags & QStyle::State_Horizontal;
+    const qreal factor = QWindowsStylePrivate::nativeMetricScaleFactor(widget);
+    const QMargins contentsMargin =
+        (theme->margins(theme->rect, TMT_SIZINGMARGINS) * factor).toMargins();
+    theme->partId = horizontal ? SBP_GRIPPERHORZ : SBP_GRIPPERVERT;
+    const QSize size = (theme->size() * factor).toSize();
+
+    const int hSpace = theme->rect.width() - size.width();
+    const int vSpace = theme->rect.height() - size.height();
+    const bool sufficientSpace = (horizontal && hSpace > (contentsMargin.left() + contentsMargin.right()))
+        || vSpace > contentsMargin.top() + contentsMargin.bottom();
+    return sufficientSpace ? QRect(theme->rect.topLeft() + QPoint(hSpace, vSpace) / 2, size) : QRect();
+}
+
+#if QT_CONFIG(mdiarea)
+// Helper for drawing MDI buttons into the corner widget of QMenuBar in case a
+// QMdiSubWindow is maximized.
+static void populateMdiButtonTheme(const QStyle *proxy, const QWidget *widget,
+                                   const QStyleOptionComplex *option,
+                                   QStyle::SubControl subControl, int part,
+                                   XPThemeData *theme)
+{
+        theme->partId = part;
+        theme->rect = proxy->subControlRect(QStyle::CC_MdiControls, option, subControl, widget);
+        if (!option->state.testFlag(QStyle::State_Enabled))
+            theme->stateId = CBS_INACTIVE;
+        else if (option->state.testFlag(QStyle::State_Sunken) && option->activeSubControls.testFlag(subControl))
+            theme->stateId = CBS_PUSHED;
+        else if (option->state.testFlag(QStyle::State_MouseOver) && option->activeSubControls.testFlag(subControl))
+            theme->stateId = CBS_HOT;
+        else
+            theme->stateId = CBS_NORMAL;
+}
+
+// Calculate an small (max 2), empirical correction factor for scaling up
+// WP_MDICLOSEBUTTON, WP_MDIRESTOREBUTTON, WP_MDIMINBUTTON, which are too
+// small on High DPI screens (QTBUG-75927).
+qreal mdiButtonCorrectionFactor(XPThemeData &theme, const QPaintDevice *pd = nullptr)
+{
+    const auto dpr = pd ? pd->devicePixelRatioF() : qApp->devicePixelRatio();
+    const QSizeF nativeSize = QSizeF(theme.size()) / dpr;
+    const QSizeF requestedSize(theme.rect.size());
+    const auto rawFactor = qMin(requestedSize.width() / nativeSize.width(),
+                                requestedSize.height() / nativeSize.height());
+    const auto factor = rawFactor >= qreal(2) ? qreal(2) : qreal(1);
+    return factor;
+}
+#endif // QT_CONFIG(mdiarea)
+
+static void populateTitleBarButtonTheme(const QStyle *proxy, const QWidget *widget,
+                                        const QStyleOptionComplex *option,
+                                        QStyle::SubControl subControl,
+                                        bool isTitleBarActive, int part,
+                                        XPThemeData *theme)
+{
+    theme->rect = proxy->subControlRect(QStyle::CC_TitleBar, option, subControl, widget);
+    theme->partId = part;
+    if (widget && !widget->isEnabled())
+        theme->stateId = RBS_DISABLED;
+    else if (option->activeSubControls == subControl && option->state.testFlag(QStyle::State_Sunken))
+        theme->stateId = RBS_PUSHED;
+    else if (option->activeSubControls == subControl && option->state.testFlag(QStyle::State_MouseOver))
+        theme->stateId = RBS_HOT;
+    else if (!isTitleBarActive)
+        theme->stateId = RBS_INACTIVE;
+    else
+        theme->stateId = RBS_NORMAL;
+}
+
+/*!
+    \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) {
+#if QT_CONFIG(spinbox)
+    case CC_SpinBox:
+        if (const QStyleOptionSpinBox *sb = qstyleoption_cast<const QStyleOptionSpinBox *>(option))
+        {
+            XPThemeData theme(widget, p, QWindowsXPStylePrivate::SpinTheme);
+
+            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, QWindowsXPStylePrivate::EditTheme,
+                                   partId, stateId, r);
+                ftheme.noContent = true;
+                d->drawBackground(ftheme);
+            }
+            if (sub & SC_SpinBoxUp) {
+                theme.rect = proxy()->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 = proxy()->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_CONFIG(spinbox)
+#if QT_CONFIG(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, QWindowsXPStylePrivate::EditTheme, partId, stateId, r);
+                    d->drawBackground(theme);
+                } else {
+                    QBrush editBrush = cmb->palette.brush(QPalette::Base);
+                    p->fillRect(option->rect, editBrush);
+                }
+                if (!cmb->editable) {
+                    QRect re = proxy()->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, QWindowsXPStylePrivate::ComboboxTheme);
+                theme.rect = proxy()->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_CONFIG(combobox)
+    case CC_ScrollBar:
+        if (const QStyleOptionSlider *scrollbar = qstyleoption_cast<const QStyleOptionSlider *>(option))
+        {
+            XPThemeData theme(widget, p, QWindowsXPStylePrivate::ScrollBarTheme);
+            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 = proxy()->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 = proxy()->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 = proxy()->subControlRect(CC_ScrollBar, option, SC_ScrollBarSlider, widget);
+                theme.rect = theme.rect.united(proxy()->subControlRect(CC_ScrollBar, option, SC_ScrollBarSubPage, widget));
+                theme.rect = theme.rect.united(proxy()->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 = proxy()->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 = proxy()->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 = proxy()->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.partId = flags & State_Horizontal ? SBP_THUMBBTNHORZ : SBP_THUMBBTNVERT;
+                    theme.stateId = stateId;
+                    d->drawBackground(theme);
+
+                    const QRect gripperBounds = QWindowsXPStylePrivate::scrollBarGripperBounds(flags, widget, &theme);
+                    // Draw gripper if there is enough space
+                    if (!gripperBounds.isEmpty()) {
+                        p->save();
+                        theme.rect = gripperBounds;
+                        p->setClipRegion(d->region(theme));// Only change inside the region of the gripper
+                        d->drawBackground(theme);          // Transparent gripper ontop of background
+                        p->restore();
+                    }
+                }
+            }
+        }
+        break;
+
+#if QT_CONFIG(slider)
+    case CC_Slider:
+        if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option))
+        {
+            XPThemeData theme(widget, p, QWindowsXPStylePrivate::TrackBarTheme);
+            QRect slrect = slider->rect;
+            QRegion tickreg = slrect;
+            if (sub & SC_SliderGroove) {
+                theme.rect = proxy()->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 = proxy()->pixelMetric(PM_SliderTickmarkOffset, slider, widget);
+                int ticks = slider->tickPosition;
+                int thickness = proxy()->pixelMetric(PM_SliderControlThickness, slider, widget);
+                int len = proxy()->pixelMetric(PM_SliderLength, slider, widget);
+                int available = proxy()->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.isEmpty()) {
+                    p->save();
+                    p->translate(slrect.topLeft());
+                    p->drawLines(lines.constData(), lines.size());
+                    p->restore();
+                }
+            }
+            if (sub & SC_SliderHandle) {
+                theme.rect = proxy()->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);
+                proxy()->drawPrimitive(PE_FrameFocusRect, &fropt, p, widget);
+            }
+        }
+        break;
+#endif
+#if QT_CONFIG(toolbutton)
+    case CC_ToolButton:
+        if (const QStyleOptionToolButton *toolbutton
+            = qstyleoption_cast<const QStyleOptionToolButton *>(option)) {
+            QRect button, menuarea;
+            button = proxy()->subControlRect(cc, toolbutton, SC_ToolButton, widget);
+            menuarea = proxy()->subControlRect(cc, toolbutton, SC_ToolButtonMenu, widget);
+
+            State bflags = toolbutton->state & ~State_Sunken;
+            State mflags = bflags;
+            bool autoRaise = flags & State_AutoRaise;
+            if (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 = *toolbutton;
+            if (toolbutton->subControls & SC_ToolButton) {
+                if (flags & (State_Sunken | State_On | State_Raised) || !autoRaise) {
+                    if (toolbutton->features & QStyleOptionToolButton::MenuButtonPopup && autoRaise) {
+                        XPThemeData theme(widget, p, QWindowsXPStylePrivate::ToolBarTheme);
+                        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 = option->rect;
+                        tool.state = bflags;
+                        if (autoRaise) // for tool bars
+                            proxy()->drawPrimitive(PE_PanelButtonTool, &tool, p, widget);
+                        else
+                            proxy()->drawPrimitive(PE_PanelButtonBevel, &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, -proxy()->pixelMetric(QStyle::PM_MenuButtonIndicator,
+                                                      toolbutton, widget), 0);
+                proxy()->drawPrimitive(PE_FrameFocusRect, &fr, p, widget);
+            }
+            QStyleOptionToolButton label = *toolbutton;
+            label.state = bflags;
+            int fw = 2;
+            if (!autoRaise)
+                label.state &= ~State_Sunken;
+            label.rect = button.adjusted(fw, fw, -fw, -fw);
+            proxy()->drawControl(CE_ToolButtonLabel, &label, p, widget);
+
+            if (toolbutton->subControls & SC_ToolButtonMenu) {
+                tool.rect = menuarea;
+                tool.state = mflags;
+                if (autoRaise) {
+                    proxy()->drawPrimitive(PE_IndicatorButtonDropDown, &tool, p, widget);
+                } else {
+                    tool.state = mflags;
+                    menuarea.adjust(-2, 0, 0, 0);
+                    // Draw menu button
+                    if ((bflags & State_Sunken) != (mflags & State_Sunken)){
+                        p->save();
+                        p->setClipRect(menuarea);
+                        tool.rect = option->rect;
+                        proxy()->drawPrimitive(PE_PanelButtonBevel, &tool, p, nullptr);
+                        p->restore();
+                    }
+                    // Draw arrow
+                    p->save();
+                    p->setPen(option->palette.dark().color());
+                    p->drawLine(menuarea.left(), menuarea.top() + 3,
+                                menuarea.left(), menuarea.bottom() - 3);
+                    p->setPen(option->palette.light().color());
+                    p->drawLine(menuarea.left() - 1, menuarea.top() + 3,
+                                menuarea.left() - 1, menuarea.bottom() - 3);
+
+                    tool.rect = menuarea.adjusted(2, 3, -2, -1);
+                    proxy()->drawPrimitive(PE_IndicatorArrowDown, &tool, p, widget);
+                    p->restore();
+                }
+            } else if (toolbutton->features & QStyleOptionToolButton::HasMenu) {
+                int mbi = proxy()->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);
+                proxy()->drawPrimitive(PE_IndicatorArrowDown, &newBtn, p, widget);
+            }
+        }
+        break;
+#endif // QT_CONFIG(toolbutton)
+
+    case CC_TitleBar:
+        {
+            if (const QStyleOptionTitleBar *tb = qstyleoption_cast<const QStyleOptionTitleBar *>(option))
+            {
+                const qreal factor = QWindowsStylePrivate::nativeMetricScaleFactor(widget);
+                bool isActive = tb->titleBarState & QStyle::State_Active;
+                XPThemeData theme(widget, p, QWindowsXPStylePrivate::WindowTheme);
+                if (sub & SC_TitleBarLabel) {
+
+                        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 = proxy()->subControlRect(CC_TitleBar, tb, SC_TitleBarLabel, widget);
+
+                    int result = TST_NONE;
+                    GetThemeEnumValue(theme.handle(), WP_CAPTION, isActive ? CS_ACTIVE : CS_INACTIVE, TMT_TEXTSHADOWTYPE, &result);
+                    if (result != TST_NONE) {
+                        COLORREF textShadowRef;
+                        GetThemeColor(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(int(ir.x() + 3 * factor), int(ir.y() + 2 * factor),
+                                    int(ir.width() - 1 * factor), 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(int(ir.x() + 2 * factor), int(ir.y() + 1 * factor),
+                                int(ir.width() - 2 * factor), ir.height(),
+                                Qt::AlignLeft | Qt::AlignVCenter | Qt::TextSingleLine, tb->text);
+                }
+                if (sub & SC_TitleBarSysMenu && tb->titleBarFlags & Qt::WindowSystemMenuHint) {
+                    theme.rect = proxy()->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;
+                        if (theme.size().isEmpty()) {
+                            int iconSize = proxy()->pixelMetric(PM_SmallIconSize, tb, widget);
+                            QPixmap pm = proxy()->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)) {
+                    populateTitleBarButtonTheme(proxy(), widget, option, SC_TitleBarMinButton, isActive, WP_MINBUTTON, &theme);
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_TitleBarMaxButton && tb->titleBarFlags & Qt::WindowMaximizeButtonHint
+                        && !(tb->titleBarState & Qt::WindowMaximized)) {
+                    populateTitleBarButtonTheme(proxy(), widget, option, SC_TitleBarMaxButton, isActive, WP_MAXBUTTON, &theme);
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_TitleBarContextHelpButton
+                    && tb->titleBarFlags & Qt::WindowContextHelpButtonHint) {
+                    populateTitleBarButtonTheme(proxy(), widget, option, SC_TitleBarContextHelpButton, isActive, WP_HELPBUTTON, &theme);
+                    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) {
+                    populateTitleBarButtonTheme(proxy(), widget, option, SC_TitleBarNormalButton, isActive, WP_RESTOREBUTTON, &theme);
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_TitleBarShadeButton && tb->titleBarFlags & Qt::WindowShadeButtonHint
+                        && !(tb->titleBarState & Qt::WindowMinimized)) {
+                    populateTitleBarButtonTheme(proxy(), widget, option, SC_TitleBarShadeButton, isActive, WP_MINBUTTON, &theme);
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_TitleBarUnshadeButton && tb->titleBarFlags & Qt::WindowShadeButtonHint
+                        && tb->titleBarState & Qt::WindowMinimized) {
+                    populateTitleBarButtonTheme(proxy(), widget, option, SC_TitleBarUnshadeButton, isActive, WP_RESTOREBUTTON, &theme);
+                    d->drawBackground(theme);
+                }
+                if (sub & SC_TitleBarCloseButton && tb->titleBarFlags & Qt::WindowSystemMenuHint) {
+                    populateTitleBarButtonTheme(proxy(), widget, option, SC_TitleBarCloseButton, isActive, WP_CLOSEBUTTON, &theme);
+                    d->drawBackground(theme);
+                }
+            }
+        }
+        break;
+
+#if QT_CONFIG(mdiarea)
+    case CC_MdiControls:
+        {
+            XPThemeData theme(widget, p, QWindowsXPStylePrivate::WindowTheme, WP_MDICLOSEBUTTON, CBS_NORMAL);
+            if (Q_UNLIKELY(!theme.isValid()))
+                return;
+
+            if (option->subControls.testFlag(SC_MdiCloseButton)) {
+                populateMdiButtonTheme(proxy(), widget, option, SC_MdiCloseButton, WP_MDICLOSEBUTTON, &theme);
+                d->drawBackground(theme, mdiButtonCorrectionFactor(theme, widget));
+            }
+            if (option->subControls.testFlag(SC_MdiNormalButton)) {
+                populateMdiButtonTheme(proxy(), widget, option, SC_MdiNormalButton, WP_MDIRESTOREBUTTON, &theme);
+                d->drawBackground(theme, mdiButtonCorrectionFactor(theme, widget));
+            }
+            if (option->subControls.testFlag(QStyle::SC_MdiMinButton)) {
+                populateMdiButtonTheme(proxy(), widget, option, SC_MdiMinButton, WP_MDIMINBUTTON, &theme);
+                d->drawBackground(theme, mdiButtonCorrectionFactor(theme, widget));
+            }
+        }
+        break;
+#endif // QT_CONFIG(mdiarea)
+#if QT_CONFIG(dial)
+    case CC_Dial:
+        if (const QStyleOptionSlider *dial = qstyleoption_cast<const QStyleOptionSlider *>(option))
+            QStyleHelper::drawDial(dial, p);
+        break;
+#endif // QT_CONFIG(dial)
+    default:
+        QWindowsStyle::drawComplexControl(cc, option, p, widget);
+        break;
+    }
+}
+
+static inline Qt::Orientation progressBarOrientation(const QStyleOption *option = nullptr)
+{
+    if (const QStyleOptionProgressBar *pb = qstyleoption_cast<const QStyleOptionProgressBar *>(option))
+        return pb->orientation;
+    return Qt::Horizontal;
+}
+
+int QWindowsXPStylePrivate::pixelMetricFromSystemDp(QStyle::PixelMetric pm, const QStyleOption *option, const QWidget *widget)
+{
+    switch (pm) {
+    case QStyle::PM_IndicatorWidth:
+        return XPThemeData::themeSize(widget, nullptr, QWindowsXPStylePrivate::ButtonTheme, BP_CHECKBOX, CBS_UNCHECKEDNORMAL).width();
+    case QStyle::PM_IndicatorHeight:
+        return XPThemeData::themeSize(widget, nullptr, QWindowsXPStylePrivate::ButtonTheme, BP_CHECKBOX, CBS_UNCHECKEDNORMAL).height();
+    case QStyle::PM_ExclusiveIndicatorWidth:
+        return XPThemeData::themeSize(widget, nullptr, QWindowsXPStylePrivate::ButtonTheme, BP_RADIOBUTTON, RBS_UNCHECKEDNORMAL).width();
+    case QStyle::PM_ExclusiveIndicatorHeight:
+        return XPThemeData::themeSize(widget, nullptr, QWindowsXPStylePrivate::ButtonTheme, BP_RADIOBUTTON, RBS_UNCHECKEDNORMAL).height();
+    case QStyle::PM_ProgressBarChunkWidth:
+        return progressBarOrientation(option) == Qt::Horizontal
+            ? XPThemeData::themeSize(widget, nullptr, QWindowsXPStylePrivate::ProgressTheme, PP_CHUNK).width()
+            : XPThemeData::themeSize(widget, nullptr, QWindowsXPStylePrivate::ProgressTheme, PP_CHUNKVERT).height();
+    case QStyle::PM_SliderThickness:
+        return XPThemeData::themeSize(widget, nullptr, QWindowsXPStylePrivate::TrackBarTheme, TKP_THUMB).height();
+    case QStyle::PM_TitleBarHeight:
+        return widget && (widget->windowType() == Qt::Tool)
+            ? GetSystemMetrics(SM_CYSMCAPTION) + GetSystemMetrics(SM_CXSIZEFRAME)
+            : GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CXSIZEFRAME);
+    case QStyle::PM_MdiSubWindowFrameWidth:
+        return XPThemeData::themeSize(widget, nullptr, QWindowsXPStylePrivate::WindowTheme, WP_FRAMELEFT, FS_ACTIVE).width();
+    case QStyle::PM_DockWidgetFrameWidth:
+        return XPThemeData::themeSize(widget, nullptr, QWindowsXPStylePrivate::WindowTheme, WP_SMALLFRAMERIGHT, FS_ACTIVE).width();
+    default:
+        break;
+    }
+    return QWindowsXPStylePrivate::InvalidMetric;
+}
+
+/*! \reimp */
+int QWindowsXPStyle::pixelMetric(PixelMetric pm, const QStyleOption *option, const QWidget *widget) const
+{
+    if (!QWindowsXPStylePrivate::useXP())
+        return QWindowsStyle::pixelMetric(pm, option, widget);
+
+    int res = QWindowsXPStylePrivate::pixelMetricFromSystemDp(pm, option, widget);
+    if (res != QWindowsStylePrivate::InvalidMetric)
+        return qRound(qreal(res) * QWindowsStylePrivate::nativeMetricScaleFactor(widget));
+
+    res = 0;
+    switch (pm) {
+    case PM_MenuBarPanelWidth:
+    case PM_ButtonDefaultIndicator:
+        res = 0;
+        break;
+
+    case PM_DefaultFrameWidth:
+        res = qobject_cast<const QListView*>(widget) ? 2 : 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:
+            case QTabBar::RoundedWest:
+            case QTabBar::TriangularWest:
+                res = 1;
+                break;
+            case QTabBar::RoundedSouth:
+            case QTabBar::TriangularSouth:
+                res = 2;
+                break;
+            case QTabBar::RoundedEast:
+            case QTabBar::TriangularEast:
+                res = 3;
+                break;
+            }
+        }
+        break;
+
+    case PM_SplitterWidth:
+        res = QStyleHelper::dpiScaled(5., option);
+        break;
+
+    case PM_MdiSubWindowMinimizedWidth:
+        res = 160;
+        break;
+
+#if QT_CONFIG(toolbar)
+    case PM_ToolBarHandleExtent:
+        res = int(QStyleHelper::dpiScaled(8., option));
+        break;
+
+#endif // QT_CONFIG(toolbar)
+    case PM_DockWidgetSeparatorExtent:
+    case PM_DockWidgetTitleMargin:
+        res = int(QStyleHelper::dpiScaled(4., option));
+        break;
+
+    case PM_ButtonShiftHorizontal:
+    case PM_ButtonShiftVertical:
+        res = qstyleoption_cast<const QStyleOptionToolButton *>(option) ? 1 : 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();
+            const int buttonMargin = int(QStyleHelper::dpiScaled(4, option));
+            const qreal factor = QWindowsStylePrivate::nativeMetricScaleFactor(widget);
+            int buttonHeight = qRound(qreal(GetSystemMetrics(SM_CYSIZE)) * factor)
+                - buttonMargin;
+            int buttonWidth = qRound(qreal(GetSystemMetrics(SM_CXSIZE)) * factor)
+                - buttonMargin;
+            const int delta = buttonWidth + 2;
+            int controlTop = option->rect.bottom() - buttonHeight - 2;
+            const int frameWidth = proxy()->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;
+                Q_FALLTHROUGH();
+            case SC_TitleBarMinButton:
+                if (!isMinimized && (tb->titleBarFlags & Qt::WindowMinimizeButtonHint))
+                    offset += delta;
+                else if (subControl == SC_TitleBarMinButton)
+                    break;
+                Q_FALLTHROUGH();
+            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;
+                Q_FALLTHROUGH();
+            case SC_TitleBarMaxButton:
+                if (!isMaximized && (tb->titleBarFlags & Qt::WindowMaximizeButtonHint))
+                    offset += delta;
+                else if (subControl == SC_TitleBarMaxButton)
+                    break;
+                Q_FALLTHROUGH();
+            case SC_TitleBarShadeButton:
+                if (!isMinimized && (tb->titleBarFlags & Qt::WindowShadeButtonHint))
+                    offset += delta;
+                else if (subControl == SC_TitleBarShadeButton)
+                    break;
+                Q_FALLTHROUGH();
+            case SC_TitleBarUnshadeButton:
+                if (isMinimized && (tb->titleBarFlags & Qt::WindowShadeButtonHint))
+                    offset += delta;
+                else if (subControl == SC_TitleBarUnshadeButton)
+                    break;
+                Q_FALLTHROUGH();
+            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 = proxy()->pixelMetric(PM_SmallIconSize, option);
+                    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;
+            default:
+                break;
+            }
+        }
+        break;
+
+    case CC_ComboBox:
+        if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
+            const int x = cmb->rect.x(), y = cmb->rect.y(), wi = cmb->rect.width(), he = cmb->rect.height();
+            const int xpos = x + wi - qRound(QStyleHelper::dpiScaled(1 + 16, option));
+
+            switch (subControl) {
+            case SC_ComboBoxFrame:
+                rect = cmb->rect;
+                break;
+
+            case SC_ComboBoxArrow: {
+                const qreal dpi = QStyleHelper::dpi(option);
+                rect = QRect(xpos, y + qRound(QStyleHelper::dpiScaled(1, dpi)),
+                             qRound(QStyleHelper::dpiScaled(16, dpi)),
+                             he - qRound(QStyleHelper::dpiScaled(2, dpi)));
+            }
+                break;
+
+            case SC_ComboBoxEditField: {
+                const qreal dpi = QStyleHelper::dpi(option);
+                const int frame = qRound(QStyleHelper::dpiScaled(2, dpi));
+                rect = QRect(x + frame, y + frame,
+                             wi - qRound(QStyleHelper::dpiScaled(3 + 16, dpi)),
+                             he - qRound(QStyleHelper::dpiScaled(4, dpi)));
+            }
+                break;
+
+            case SC_ComboBoxListBoxPopup:
+                rect = cmb->rect;
+                break;
+
+            default:
+                break;
+            }
+        }
+        break;
+#if QT_CONFIG(mdiarea)
+    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;
+            Q_FALLTHROUGH();
+        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_CONFIG(mdiarea)
+
+    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:
+        {
+            XPThemeData buttontheme(widget, nullptr, QWindowsXPStylePrivate::ButtonTheme, BP_PUSHBUTTON, PBS_NORMAL);
+            if (buttontheme.isValid()) {
+                const qreal factor = QWindowsXPStylePrivate::nativeMetricScaleFactor(widget);
+                const QMarginsF borderSize = buttontheme.margins() * factor;
+                if (!borderSize.isNull()) {
+                    const qreal margin = qreal(2) * factor;
+                    sz.rwidth() += qRound(borderSize.left() + borderSize.right() - margin);
+                    sz.rheight() += int(borderSize.bottom() + borderSize.top() - margin
+                        + qreal(1) / factor - 1);
+                }
+                const int textMargins = 2*(proxy()->pixelMetric(PM_FocusFrameHMargin, option) + 1);
+                sz += QSize(qMax(pixelMetric(QStyle::PM_ScrollBarExtent, option, widget)
+                                 + textMargins, 23), 0); //arrow button
+            }
+        }
+        break;
+    case CT_SpinBox:
+        {
+            //Spinbox adds frame twice
+            sz = QWindowsStyle::sizeFromContents(ct, option, contentsSize, widget);
+            int border = proxy()->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;
+#if QT_CONFIG(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: {
+        sz.setHeight(int(QStyleHelper::dpiScaled(19, option)));
+        int width = 54;
+        if (const QStyleOptionComplex *styleOpt = qstyleoption_cast<const QStyleOptionComplex *>(option)) {
+            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.setWidth(int(QStyleHelper::dpiScaled(width, option)));
+    }
+        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) {
+                // Note certain themes will not return the whole window frame but only the titlebar part when
+                // queried This function needs to return the entire window mask, hence we will only fetch the mask for the
+                // titlebar itself and add the remaining part of the window rect at the bottom.
+                int tbHeight = proxy()->pixelMetric(PM_TitleBarHeight, option, widget);
+                QRect titleBarRect = option->rect;
+                titleBarRect.setHeight(tbHeight);
+                XPThemeData themeData;
+                if (titlebar->titleBarState & Qt::WindowMinimized) {
+                    themeData = XPThemeData(widget, nullptr,
+                                            QWindowsXPStylePrivate::WindowTheme,
+                                            WP_MINCAPTION, CS_ACTIVE, titleBarRect);
+                } else
+                    themeData = XPThemeData(widget, nullptr,
+                                            QWindowsXPStylePrivate::WindowTheme,
+                                            WP_CAPTION, CS_ACTIVE, titleBarRect);
+                mask->region = d->region(themeData) +
+                               QRect(0, tbHeight, option->rect.width(), option->rect.height() - tbHeight);
+            }
+        }
+        break;
+#if QT_CONFIG(rubberband)
+    case SH_RubberBand_Mask:
+        if (qstyleoption_cast<const QStyleOptionRubberBand *>(option))
+            res = 0;
+        break;
+#endif // QT_CONFIG(rubberband)
+
+    case SH_ItemView_DrawDelegateFrame:
+        res = 1;
+        break;
+
+    default:
+        res =QWindowsStyle::styleHint(hint, option, widget, returnData);
+    }
+
+    return res;
+}
+
+/*! \reimp */
+QPalette QWindowsXPStyle::standardPalette() const
+{
+    return QWindowsXPStylePrivate::useXP() ? QPalette() : 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, nullptr, QWindowsXPStylePrivate::WindowTheme, WP_SMALLCLOSEBUTTON, CBS_NORMAL);
+                if (theme.isValid()) {
+                    const QSize size = (theme.size() * QWindowsStylePrivate::nativeMetricScaleFactor(widget)).toSize();
+                    return QIcon(QWindowsStyle::standardPixmap(standardPixmap, option, widget)).pixmap(size);
+                }
+            }
+        }
+        break;
+    default:
+        break;
+    }
+    return QWindowsStyle::standardPixmap(standardPixmap, option, widget);
+}
+
+/*!
+    \reimp
+*/
+QIcon QWindowsXPStyle::standardIcon(StandardPixmap standardIcon,
+                                    const QStyleOption *option,
+                                    const QWidget *widget) const
+{
+    if (!QWindowsXPStylePrivate::useXP()) {
+        return QWindowsStyle::standardIcon(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(nullptr, nullptr, QWindowsXPStylePrivate::WindowTheme,
+                                      WP_SMALLCLOSEBUTTON, CBS_NORMAL);
+                XPThemeData theme(nullptr, nullptr, QWindowsXPStylePrivate::WindowTheme,
+                                  WP_MAXBUTTON, MAXBS_NORMAL);
+                if (theme.isValid()) {
+                    const QSize size = (themeSize.size() * QWindowsStylePrivate::nativeMetricScaleFactor(widget)).toSize();
+                    QPixmap pm(size);
+                    pm.fill(Qt::transparent);
+                    QPainter p(&pm);
+                    theme.painter = &p;
+                    theme.rect = QRect(QPoint(0, 0), size);
+                    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(nullptr, nullptr, QWindowsXPStylePrivate::WindowTheme,
+                                  WP_SMALLCLOSEBUTTON, CBS_NORMAL);
+                if (theme.isValid()) {
+                    const QSize size = (theme.size() * QWindowsStylePrivate::nativeMetricScaleFactor(widget)).toSize();
+                    QPixmap pm(size);
+                    pm.fill(Qt::transparent);
+                    QPainter p(&pm);
+                    theme.painter = &p;
+                    theme.partId = WP_CLOSEBUTTON; // ####
+                    theme.rect = QRect(QPoint(0, 0), size);
+                    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(nullptr, nullptr, QWindowsXPStylePrivate::WindowTheme,
+                                      WP_SMALLCLOSEBUTTON, CBS_NORMAL);
+                XPThemeData theme(nullptr, nullptr, QWindowsXPStylePrivate::WindowTheme,
+                                  WP_RESTOREBUTTON, RBS_NORMAL);
+                if (theme.isValid()) {
+                    const QSize size = (themeSize.size() * QWindowsStylePrivate::nativeMetricScaleFactor(widget)).toSize();
+                    QPixmap pm(size);
+                    pm.fill(Qt::transparent);
+                    QPainter p(&pm);
+                    theme.painter = &p;
+                    theme.rect = QRect(QPoint(0, 0), size);
+                    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;
+    default:
+        break;
+    }
+
+    return QWindowsStyle::standardIcon(standardIcon, option, widget);
+}
+
+/*!
+    \internal
+
+    Constructs a QWindowsXPStyle object.
+*/
+QWindowsXPStyle::QWindowsXPStyle(QWindowsXPStylePrivate &dd) : QWindowsStyle(dd)
+{
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug d, const XPThemeData &t)
+{
+    QDebugStateSaver saver(d);
+    d.nospace();
+    d << "XPThemeData(" << t.widget << ", theme=#" << t.theme << ", " << t.htheme
+        << ", partId=" << t.partId << ", stateId=" << t.stateId << ", rect=" << t.rect
+        << ", mirrorHorizontally=" << t.mirrorHorizontally << ", mirrorVertically="
+        << t.mirrorVertically << ", noBorder=" << t.noBorder << ", noContent=" << t.noContent
+        << ", rotate=" << t.rotate << ')';
+    return d;
+}
+
+QDebug operator<<(QDebug d, const ThemeMapKey &k)
+{
+    QDebugStateSaver saver(d);
+    d.nospace();
+    d << "ThemeMapKey(theme=#" << k.theme
+        << ", partId=" << k.partId << ", stateId=" << k.stateId
+        << ", noBorder=" << k.noBorder << ", noContent=" << k.noContent << ')';
+    return d;
+}
+
+QDebug operator<<(QDebug d, const ThemeMapData &td)
+{
+    QDebugStateSaver saver(d);
+    d.nospace();
+    d << "ThemeMapData(alphaType=" << td.alphaType
+      << ", dataValid=" << td.dataValid << ", partIsTransparent=" << td.partIsTransparent
+      << ", hasAlphaChannel=" << td.hasAlphaChannel << ", wasAlphaSwapped=" << td.wasAlphaSwapped
+      << ", hadInvalidAlpha=" << td.hadInvalidAlpha << ')';
+    return d;
+}
+#endif // QT_NO_DEBUG_STREAM
+
+// 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;
+    GetThemePropertyOrigin(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];
+            GetThemeString(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;
+            GetThemeEnumValue(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;
+            GetThemeInt(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;
+            GetThemeBool(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;
+            GetThemeColor(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));
+            GetThemeMargins(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];
+            GetThemeFilename(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));
+            GetThemePartSize(themeData.handle(), 0, themeData.partId, themeData.stateId, 0, TS_MIN,  &result1);
+            GetThemePartSize(themeData.handle(), 0, themeData.partId, themeData.stateId, 0, TS_TRUE, &result2);
+            GetThemePartSize(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));
+            GetThemePosition(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));
+            GetThemeRect(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));
+            GetThemeFont(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));
+            GetThemeIntList(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);
+                }
+            }
+        }
+        std::sort(all_props.begin(), all_props.end());
+
+        {// 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];
+                GetThemeDocumentationProperty(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;
+                GetThemePropertyOrigin(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;
+        GetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, prop.propValue, &origin);
+        if (origin != PO_NOTFOUND)
+        {
+            showProperty(themeData, prop);
+        }
+    }
+}
+#endif
+// Debugging code -----------------------------------------------------------------------[ END ]---
+
+
+QT_END_NAMESPACE
diff --git a/src/imports/nativestyle/qstyle/windows/qquickwindowsxpstyle_p.h b/src/imports/nativestyle/qstyle/windows/qquickwindowsxpstyle_p.h
new file mode 100644
index 00000000..af08e3e0
--- /dev/null
+++ b/src/imports/nativestyle/qstyle/windows/qquickwindowsxpstyle_p.h
@@ -0,0 +1,108 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWidgets module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWINDOWSXPSTYLE_P_H
+#define QWINDOWSXPSTYLE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtWidgets/private/qtwidgetsglobal_p.h>
+#include <QtWidgets/private/qwindowsstyle_p.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace QQC2 {
+
+class QWindowsXPStylePrivate;
+class QWindowsXPStyle : public QWindowsStyle
+{
+    Q_OBJECT
+public:
+    QWindowsXPStyle();
+    QWindowsXPStyle(QWindowsXPStylePrivate &dd);
+    ~QWindowsXPStyle() override;
+
+    void unpolish(QApplication*) override;
+    void polish(QApplication*) override;
+    void polish(QWidget*) override;
+    void polish(QPalette&) override;
+    void unpolish(QWidget*) override;
+
+    void drawPrimitive(PrimitiveElement pe, const QStyleOption *option, QPainter *p,
+                       const QWidget *widget = nullptr) const override;
+    void drawControl(ControlElement element, const QStyleOption *option, QPainter *p,
+                     const QWidget *wwidget = nullptr) const override;
+    QRect subElementRect(SubElement r, const QStyleOption *option,
+                         const QWidget *widget = nullptr) const override;
+    QRect subControlRect(ComplexControl cc, const QStyleOptionComplex *option, SubControl sc,
+                         const QWidget *widget = nullptr) const override;
+    void drawComplexControl(ComplexControl cc, const QStyleOptionComplex *option, QPainter *p,
+                            const QWidget *widget = nullptr) const override;
+    QSize sizeFromContents(ContentsType ct, const QStyleOption *option, const QSize &contentsSize,
+                           const QWidget *widget = nullptr) const override;
+    int pixelMetric(PixelMetric pm, const QStyleOption *option = nullptr,
+                    const QWidget *widget = nullptr) const override;
+    int styleHint(StyleHint hint, const QStyleOption *option = nullptr,
+                  const QWidget *widget = nullptr,
+                  QStyleHintReturn *returnData = nullptr) const override;
+
+    QPalette standardPalette() const override;
+    QPixmap standardPixmap(StandardPixmap standardIcon, const QStyleOption *option,
+                           const QWidget *widget = nullptr) const override;
+    QIcon standardIcon(StandardPixmap standardIcon, const QStyleOption *option = nullptr,
+                       const QWidget *widget = nullptr) const override;
+
+private:
+    Q_DISABLE_COPY_MOVE(QWindowsXPStyle)
+    Q_DECLARE_PRIVATE(QWindowsXPStyle)
+    friend class QStyleFactory;
+};
+
+QT_END_NAMESPACE
+
+#endif // QWINDOWSXPSTYLE_P_H
diff --git a/src/imports/nativestyle/qstyle/windows/qquickwindowsxpstyle_p_p.h b/src/imports/nativestyle/qstyle/windows/qquickwindowsxpstyle_p_p.h
new file mode 100644
index 00000000..827e7bc2
--- /dev/null
+++ b/src/imports/nativestyle/qstyle/windows/qquickwindowsxpstyle_p_p.h
@@ -0,0 +1,345 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWidgets module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWINDOWSXPSTYLE_P_P_H
+#define QWINDOWSXPSTYLE_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp.  This header
+// file may change from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtWidgets/private/qtwidgetsglobal_p.h>
+#include "qquickwindowsxpstyle_p.h"
+#include <QtWidgets/private/qwindowsstyle_p_p.h>
+#include <qmap.h>
+#include <qt_windows.h>
+
+#include <uxtheme.h>
+#include <vssym32.h>
+
+#include <limits.h>
+
+QT_BEGIN_NAMESPACE
+
+class QDebug;
+
+// TMT_TEXTSHADOWCOLOR is wrongly defined in mingw
+#if TMT_TEXTSHADOWCOLOR != 3818
+#undef TMT_TEXTSHADOWCOLOR
+#define TMT_TEXTSHADOWCOLOR 3818
+#endif
+#ifndef TST_NONE
+#  define TST_NONE 0
+#endif
+
+// These defines are missing from the tmschema, but still exist as
+// states for their parts
+#ifndef MINBS_INACTIVE
+#define MINBS_INACTIVE 5
+#endif
+#ifndef MAXBS_INACTIVE
+#define MAXBS_INACTIVE 5
+#endif
+#ifndef RBS_INACTIVE
+#define RBS_INACTIVE 5
+#endif
+#ifndef HBS_INACTIVE
+#define HBS_INACTIVE 5
+#endif
+#ifndef CBS_INACTIVE
+#define CBS_INACTIVE 5
+#endif
+
+// Uncomment define below to build debug assisting code, and output
+// #define DEBUG_XP_STYLE
+
+// Declarations -----------------------------------------------------------------------------------
+class XPThemeData
+{
+public:
+    explicit XPThemeData(const QWidget *w = nullptr, QPainter *p = nullptr, int themeIn = -1,
+                         int part = 0, int state = 0, const QRect &r = QRect())
+        : widget(w), painter(p), theme(themeIn), partId(part), stateId(state),
+          mirrorHorizontally(false), mirrorVertically(false), noBorder(false),
+          noContent(false), rect(r)
+    {}
+
+    HRGN mask(QWidget *widget);
+    HTHEME handle();
+
+    static RECT toRECT(const QRect &qr);
+    bool isValid();
+
+    QSizeF size();
+    QMarginsF margins(const QRect &rect, int propId = TMT_CONTENTMARGINS);
+    QMarginsF margins(int propId = TMT_CONTENTMARGINS);
+
+    static QSizeF themeSize(const QWidget *w = nullptr, QPainter *p = nullptr, int themeIn = -1, int part = 0, int state = 0);
+    static QMarginsF themeMargins(const QRect &rect, const QWidget *w = nullptr, QPainter *p = nullptr, int themeIn = -1,
+                                  int part = 0, int state = 0, int propId = TMT_CONTENTMARGINS);
+    static QMarginsF themeMargins(const QWidget *w = nullptr, QPainter *p = nullptr, int themeIn = -1,
+                                  int part = 0, int state = 0, int propId = TMT_CONTENTMARGINS);
+
+    const QWidget *widget;
+    QPainter *painter;
+
+    int theme;
+    HTHEME htheme = nullptr;
+    int partId;
+    int stateId;
+
+    uint mirrorHorizontally : 1;
+    uint mirrorVertically : 1;
+    uint noBorder : 1;
+    uint noContent : 1;
+    uint rotate = 0;
+    QRect rect;
+};
+
+struct ThemeMapKey {
+    int theme = 0;
+    int partId = -1;
+    int stateId = -1;
+    bool noBorder = false;
+    bool noContent = false;
+
+    ThemeMapKey() = default;
+    ThemeMapKey(const XPThemeData &data)
+        : theme(data.theme), partId(data.partId), stateId(data.stateId),
+        noBorder(data.noBorder), noContent(data.noContent) {}
+
+};
+
+inline size_t qHash(const ThemeMapKey &key)
+{ return key.theme ^ key.partId ^ key.stateId; }
+
+inline bool operator==(const ThemeMapKey &k1, const ThemeMapKey &k2)
+{
+    return k1.theme == k2.theme
+           && k1.partId == k2.partId
+           && k1.stateId == k2.stateId;
+}
+
+enum AlphaChannelType {
+    UnknownAlpha = -1,          // Alpha of part & state not yet known
+    NoAlpha,                    // Totally opaque, no need to touch alpha (RGB)
+    MaskAlpha,                  // Alpha channel must be fixed            (ARGB)
+    RealAlpha                   // Proper alpha values from Windows       (ARGB_Premultiplied)
+};
+
+struct ThemeMapData {
+    AlphaChannelType alphaType = UnknownAlpha; // Which type of alpha on part & state
+
+    bool dataValid         : 1; // Only used to detect if hash value is ok
+    bool partIsTransparent : 1;
+    bool hasAlphaChannel   : 1; // True =  part & state has real Alpha
+    bool wasAlphaSwapped   : 1; // True =  alpha channel needs to be swapped
+    bool hadInvalidAlpha   : 1; // True =  alpha channel contained invalid alpha values
+
+    ThemeMapData() : dataValid(false), partIsTransparent(false),
+                     hasAlphaChannel(false), wasAlphaSwapped(false), hadInvalidAlpha(false) {}
+};
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug d, const XPThemeData &t);
+QDebug operator<<(QDebug d, const ThemeMapKey &k);
+QDebug operator<<(QDebug d, const ThemeMapData &td);
+#endif
+
+class QWindowsXPStylePrivate : public QWindowsStylePrivate
+{
+    Q_DECLARE_PUBLIC(QWindowsXPStyle)
+public:
+    enum Theme {
+        ButtonTheme,
+        ComboboxTheme,
+        EditTheme,
+        HeaderTheme,
+        ListViewTheme,
+        MenuTheme,
+        ProgressTheme,
+        RebarTheme,
+        ScrollBarTheme,
+        SpinTheme,
+        TabTheme,
+        TaskDialogTheme,
+        ToolBarTheme,
+        ToolTipTheme,
+        TrackBarTheme,
+        XpTreeViewTheme, // '+'/'-' shape treeview indicators (XP)
+        WindowTheme,
+        StatusTheme,
+        VistaTreeViewTheme, // arrow shape treeview indicators (Vista) obtained from "explorer" theme.
+        NThemes
+    };
+
+    QWindowsXPStylePrivate()
+    { init(); }
+
+    ~QWindowsXPStylePrivate()
+    { cleanup(); }
+
+    static int pixelMetricFromSystemDp(QStyle::PixelMetric pm, const QStyleOption *option = nullptr, const QWidget *widget = nullptr);
+    static int fixedPixelMetric(QStyle::PixelMetric pm, const QStyleOption *option = nullptr, const QWidget *widget = nullptr);
+
+    static HWND winId(const QWidget *widget);
+
+    void init(bool force = false);
+    void cleanup(bool force = false);
+    void cleanupHandleMap();
+
+    HBITMAP buffer(int w = 0, int h = 0);
+    HDC bufferHDC()
+    { return bufferDC;}
+
+    static bool useXP(bool update = false);
+    static QRect scrollBarGripperBounds(QStyle::State flags, const QWidget *widget, XPThemeData *theme);
+
+    bool isTransparent(XPThemeData &themeData);
+    QRegion region(XPThemeData &themeData);
+
+    bool drawBackground(XPThemeData &themeData, qreal correctionFactor = 1);
+    bool drawBackgroundThruNativeBuffer(XPThemeData &themeData, qreal aditionalDevicePixelRatio, qreal correctionFactor);
+    bool drawBackgroundDirectly(HDC dc, XPThemeData &themeData, qreal aditionalDevicePixelRatio);
+
+    bool hasAlphaChannel(const QRect &rect);
+    bool fixAlphaChannel(const QRect &rect);
+    bool swapAlphaChannel(const QRect &rect, bool allPixels = false);
+
+    QRgb groupBoxTextColor = 0;
+    QRgb groupBoxTextColorDisabled = 0;
+    QRgb sliderTickColor = 0;
+    bool hasInitColors = false;
+
+    static HTHEME createTheme(int theme, HWND hwnd);
+    static QString themeName(int theme);
+    static inline bool hasTheme(int theme) { return theme >= 0 && theme < NThemes && m_themes[theme]; }
+    static bool isItemViewDelegateLineEdit(const QWidget *widget);
+    static bool isLineEditBaseColorSet(const QStyleOption *option, const QWidget *widget);
+
+    QIcon dockFloat, dockClose;
+
+private:
+#ifdef DEBUG_XP_STYLE
+    void dumpNativeDIB(int w, int h);
+    void showProperties(XPThemeData &themeData);
+#endif
+
+    static bool initVistaTreeViewTheming();
+    static void cleanupVistaTreeViewTheming();
+
+    static QBasicAtomicInt ref;
+    static bool use_xp;
+
+    QHash<ThemeMapKey, ThemeMapData> alphaCache;
+    HDC bufferDC = nullptr;
+    HBITMAP bufferBitmap = nullptr;
+    HBITMAP nullBitmap = nullptr;
+    uchar *bufferPixels = nullptr;
+    int bufferW = 0;
+    int bufferH = 0;
+
+    static HWND m_vistaTreeViewHelper;
+    static HTHEME m_themes[NThemes];
+};
+
+inline QSizeF XPThemeData::size()
+{
+    QSizeF result(0, 0);
+    if (isValid()) {
+        SIZE size;
+        if (SUCCEEDED(GetThemePartSize(handle(), nullptr, partId, stateId, nullptr, TS_TRUE, &size)))
+            result = QSize(size.cx, size.cy);
+    }
+    return result;
+}
+
+inline QMarginsF XPThemeData::margins(const QRect &qRect, int propId)
+{
+    QMarginsF result(0, 0, 0 ,0);
+    if (isValid()) {
+        MARGINS margins;
+        RECT rect = XPThemeData::toRECT(qRect);
+        if (SUCCEEDED(GetThemeMargins(handle(), nullptr, partId, stateId, propId, &rect, &margins)))
+            result = QMargins(margins.cxLeftWidth, margins.cyTopHeight, margins.cxRightWidth, margins.cyBottomHeight);
+    }
+    return result;
+}
+
+inline QMarginsF XPThemeData::margins(int propId)
+{
+    QMarginsF result(0, 0, 0 ,0);
+    if (isValid()) {
+        MARGINS margins;
+        if (SUCCEEDED(GetThemeMargins(handle(), nullptr, partId, stateId, propId, nullptr, &margins)))
+            result = QMargins(margins.cxLeftWidth, margins.cyTopHeight, margins.cxRightWidth, margins.cyBottomHeight);
+    }
+    return result;
+}
+
+inline QSizeF XPThemeData::themeSize(const QWidget *w, QPainter *p, int themeIn, int part, int state)
+{
+    XPThemeData theme(w, p, themeIn, part, state);
+    return theme.size();
+}
+
+inline QMarginsF XPThemeData::themeMargins(const QRect &rect, const QWidget *w, QPainter *p, int themeIn,
+                                           int part, int state, int propId)
+{
+    XPThemeData theme(w, p, themeIn, part, state);
+    return theme.margins(rect, propId);
+}
+
+inline QMarginsF XPThemeData::themeMargins(const QWidget *w, QPainter *p, int themeIn,
+                                           int part, int state, int propId)
+{
+    XPThemeData theme(w, p, themeIn, part, state);
+    return theme.margins(propId);
+}
+
+QT_END_NAMESPACE
+
+#endif //QWINDOWSXPSTYLE_P_P_H
diff --git a/src/imports/nativestyle/qstyle/windows/windows.pri b/src/imports/nativestyle/qstyle/windows/windows.pri
new file mode 100644
index 00000000..ac159975
--- /dev/null
+++ b/src/imports/nativestyle/qstyle/windows/windows.pri
@@ -0,0 +1,20 @@
+
+INCLUDEPATH += $$PWD
+
+HEADERS += \
+    $$PWD/qquickwindowsstyle_p.h \
+    $$PWD/qquickwindowsstyle_p_p.h \
+    $$PWD/qdrawutil.h
+#    $$PWD/qquickwindowsvistastyle_p.h \
+#    $$PWD/qquickwindowsvistastyle_p_p.h \
+#    $$PWD/qquickwindowsxpstyle_p.h \
+#    $$PWD/qquickwindowsxpstyle_p_p.h
+
+SOURCES += \
+    $$PWD/qquickwindowsstyle.cpp \
+    $$PWD/qdrawutil.cpp
+#    $$PWD/qquickwindowsvistastyle.cpp \
+#    $$PWD/qquickwindowsxpstyle.cpp
+
+QMAKE_USE_PRIVATE += user32 gdi32
+LIBS_PRIVATE *= -luxtheme
diff --git a/src/imports/nativestyle/qtquickcontrols2nativestyleplugin.cpp b/src/imports/nativestyle/qtquickcontrols2nativestyleplugin.cpp
index 470c805d..8aedcdb8 100644
--- a/src/imports/nativestyle/qtquickcontrols2nativestyleplugin.cpp
+++ b/src/imports/nativestyle/qtquickcontrols2nativestyleplugin.cpp
@@ -42,6 +42,8 @@
 
 #if defined(Q_OS_MACOS)
 #include "qquickmacstyle_mac_p.h"
+#elif defined(Q_OS_WINDOWS)
+# include "qquickwindowsstyle_p.h"
 #endif
 
 QT_BEGIN_NAMESPACE
@@ -77,16 +79,34 @@ void QtQuickControls2NativeStylePlugin::initializeEngine(QQmlEngine *engine, con
     Q_UNUSED(uri);
     // Enable commonstyle as a reference style while
     // the native styles are under development.
-    if (qEnvironmentVariable("QQC2_COMMONSTYLE") == QStringLiteral("true"))
-        QQuickNativeStyle::setStyle(new QCommonStyle);
-    else
+    QStyle *style = nullptr;
+    if (qEnvironmentVariable("QQC2_COMMONSTYLE") == QStringLiteral("true")) {
+        style = new QCommonStyle;
+    } else {
+        const QString envStyle = qEnvironmentVariable("QQC2_STYLE");
+        if (!envStyle.isNull()) {
+            if (envStyle.compare(QLatin1String("common")))
+                style = new QCommonStyle;
+#if defined(Q_OS_MACOS)
+            else if (envStyle.compare(QLatin1String("mac")))
+                style = new QMacStyle;
+#endif
+#if defined(Q_OS_WINDOWS)
+            else if (envStyle.compare(QLatin1String("windows")))
+                style = new QWindowsStyle;
+#endif
+        }
+        if (!style) {
 #if defined(Q_OS_MACOS)
-        QQuickNativeStyle::setStyle(new QMacStyle);
+            style = new QMacStyle;
 #elif defined(Q_OS_WINDOWS)
-        QQuickNativeStyle::setStyle(new QCommonStyle);
+            style = new QWindowsStyle;
 #else
-        QQuickNativeStyle::setStyle(new QCommonStyle);
+            style = new QCommonStyle;
 #endif
+        }
+    }
+    QQuickNativeStyle::setStyle(style);
 }
 
 void QtQuickControls2NativeStylePlugin::registerTypes(const char *uri)