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

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "qwindowsvistastyle.h"

#include "qwindowsvistastyle_p.h"

#include <private/qstylehelper_p.h>

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

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

// Runtime resolved theme engine function calls

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

typedef HRESULT (WINAPI *PtrGetThemeTransitionDuration)(HTHEME hTheme, int iPartId, int iStateFromId, int iStateToId, int iPropId, int *pDuration);

typedef HRESULT (WINAPI *PtrIsThemePartDefined)(HTHEME hTheme, int iPartId, int iStateId);

typedef HRESULT (WINAPI *PtrSetWindowTheme)(HWND hwnd, LPCWSTR pszSubAppName, LPCWSTR pszSubIdList);

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

static PtrIsThemePartDefined pIsThemePartDefined = 0;

static PtrOpenThemeData pOpenThemeData = 0;

static PtrCloseThemeData pCloseThemeData = 0;

static PtrDrawThemeBackground pDrawThemeBackground = 0;

static PtrDrawThemeBackgroundEx pDrawThemeBackgroundEx = 0;

static PtrGetCurrentThemeName pGetCurrentThemeName = 0;

static PtrGetThemeBool pGetThemeBool = 0;

static PtrGetThemeColor pGetThemeColor = 0;

static PtrGetThemeEnumValue pGetThemeEnumValue = 0;

static PtrGetThemeFilename pGetThemeFilename = 0;

static PtrGetThemeFont pGetThemeFont = 0;

static PtrGetThemeInt pGetThemeInt = 0;

static PtrGetThemeIntList pGetThemeIntList = 0;

static PtrGetThemeMargins pGetThemeMargins = 0;

static PtrGetThemeMetric pGetThemeMetric = 0;

static PtrGetThemePartSize pGetThemePartSize = 0;

static PtrGetThemePosition pGetThemePosition = 0;

static PtrGetThemeRect pGetThemeRect = 0;

static PtrGetThemeString pGetThemeString = 0;

static PtrGetThemeTransitionDuration pGetThemeTransitionDuration= 0;

static PtrSetWindowTheme pSetWindowTheme = 0;

static PtrGetThemePropertyOrigin pGetThemePropertyOrigin = 0;

/* \internal

    Checks if we should use Vista style , or if we should

    fall back to Windows style.

*/

bool QWindowsVistaStylePrivate::useVista()

{

    return (QWindowsVistaStylePrivate::useXP() &&

            (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA &&

             QSysInfo::WindowsVersion < QSysInfo::WV_NT_based));

}

/*!

  \class QWindowsVistaStyle

  \brief The QWindowsVistaStyle class provides a look and feel suitable for applications on Microsoft Windows Vista.

  \since 4.3

  \ingroup appearance

  \warning This style is only available on the Windows Vista platform

  because it makes use of Windows Vista's style engine.

  \sa QMacStyle, QWindowsXPStyle, QPlastiqueStyle, QCleanlooksStyle, QMotifStyle

*/

/*!

  Constructs a QWindowsVistaStyle object.

*/

QWindowsVistaStyle::QWindowsVistaStyle()

    : QWindowsXPStyle(*new QWindowsVistaStylePrivate)

{

}

//convert Qt state flags to uxtheme button states

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;

}

void Animation::paint(QPainter *painter, const QStyleOption *option)

{

    Q_UNUSED(option);

    Q_UNUSED(painter);

}

/*! \internal

  Helperfunction to paint the current transition state between two

  animation frames.

  The result is a blended image consisting of ((alpha)*_primaryImage)

  + ((1-alpha)*_secondaryImage)

*/

void Animation::drawBlendedImage(QPainter *painter, QRect rect, float alpha) {

    if (_secondaryImage.isNull() || _primaryImage.isNull())

        return;

    if (_tempImage.isNull())

        _tempImage = _secondaryImage;

    const int a = qRound(alpha*256);

    const int ia = 256 - a;

    const int sw = _primaryImage.width();

    const int sh = _primaryImage.height();

    const int bpl = _primaryImage.bytesPerLine();

    switch(_primaryImage.depth()) {

    case 32:

        {

            uchar *mixed_data = _tempImage.bits();

            const uchar *back_data = _primaryImage.bits();

            const uchar *front_data = _secondaryImage.bits();

            for (int sy = 0; sy < sh; sy++) {

                quint32* mixed = (quint32*)mixed_data;

                const quint32* back = (const quint32*)back_data;

                const quint32* front = (const quint32*)front_data;

                for (int sx = 0; sx < sw; sx++) {

                    quint32 bp = back[sx];

                    quint32 fp = front[sx];

                    mixed[sx] =  qRgba ((qRed(bp)*ia + qRed(fp)*a)>>8,

                                        (qGreen(bp)*ia + qGreen(fp)*a)>>8,

                                        (qBlue(bp)*ia + qBlue(fp)*a)>>8,

                                        (qAlpha(bp)*ia + qAlpha(fp)*a)>>8);

                }

                mixed_data += bpl;

                back_data += bpl;

                front_data += bpl;

            }

        }

    default:

        break;

    }

    painter->drawImage(rect, _tempImage);

}

/*! \internal

  Paints a transition state. The result will be a mix between the

  initial and final state of the transition, depending on the time

  difference between _startTime and current time.

*/

void Transition::paint(QPainter *painter, const QStyleOption *option)

{

    float alpha = 1.0;

    if (_duration > 0) {

        QTime current = QTime::currentTime();

        if (_startTime > current)

            _startTime = current;

        int timeDiff = _startTime.msecsTo(current);

        alpha = timeDiff/(float)_duration;

        if (timeDiff > _duration) {

            _running = false;

            alpha = 1.0;

        }

    }

    else {

        _running = false;

    }

    drawBlendedImage(painter, option->rect, alpha);

}

/*! \internal

  Paints a pulse. The result will be a mix between the primary and

  secondary pulse images depending on the time difference between

  _startTime and current time.

*/

void Pulse::paint(QPainter *painter, const QStyleOption *option)

{

    float alpha = 1.0;

    if (_duration > 0) {

        QTime current = QTime::currentTime();

        if (_startTime > current)

            _startTime = current;

        int timeDiff = _startTime.msecsTo(current) % _duration*2;

        if (timeDiff > _duration)

            timeDiff = _duration*2 - timeDiff;

        alpha = timeDiff/(float)_duration;

    } else {

        _running = false;

    }

    drawBlendedImage(painter, option->rect, alpha);

}

/*!

 \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;

    }

    QRect oldRect;

    QRect newRect;

    if (widget && d->transitionsEnabled())

    {

        /* all widgets that supports state transitions : */

        if (

#ifndef QT_NO_LINEEDIT

            (qobject_cast<const QLineEdit*>(widget) && element == PE_FrameLineEdit) ||

#endif // QT_NO_LINEEDIT

            (qobject_cast<const QRadioButton*>(widget)&& element == PE_IndicatorRadioButton) ||

            (qobject_cast<const QCheckBox*>(widget) && element == PE_IndicatorCheckBox) ||

            (qobject_cast<const QGroupBox *>(widget)&& element == PE_IndicatorCheckBox) ||

            (qobject_cast<const QToolButton*>(widget) && element == PE_PanelButtonBevel)

        )

        {

            // Retrieve and update the dynamic properties tracking

            // the previous state of the widget:

            QWidget *w = const_cast<QWidget *> (widget);

            int oldState = w->property("_q_stylestate").toInt();

            oldRect = w->property("_q_stylerect").toRect();

            newRect = w->rect();

            w->setProperty("_q_stylestate", (int)option->state);

            w->setProperty("_q_stylerect", w->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(widget);

#ifndef QT_NO_LINEEDIT

            if (const QLineEdit *edit = qobject_cast<const QLineEdit *>(widget))

                if (edit->isReadOnly() && element == PE_FrameLineEdit) // Do not animate read only line edits

                    doTransition = false;

#endif // QT_NO_LINEEDIT

            if (doTransition) {

                // We create separate images for the initial and final transition states and store them in the

                // Transition object.

                QImage startImage(option->rect.size(), QImage::Format_ARGB32_Premultiplied);

                QImage endImage(option->rect.size(), QImage::Format_ARGB32_Premultiplied);

                QStyleOption opt = *option;

                opt.rect.setRect(0, 0, option->rect.width(), option->rect.height());

                opt.state = (QStyle::State)oldState;

                startImage.fill(0);

                QPainter startPainter(&startImage);

                Animation *anim = d->widgetAnimation(widget);

                Transition *t = new Transition;

                t->setWidget(w);

                // 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, &opt, &startPainter, 0); // Note that the widget pointer is intentionally 0

                else                                               // this ensures that we do not recurse in the animation logic above

                    anim->paint(&startPainter, &opt);

                d->startAnimation(t);

                t->setStartImage(startImage);

                // The end state of the transition is simply the result we would have painted

                // if the style was not animated.

                QPainter endPainter(&endImage);

                endImage.fill(0);

                QStyleOption opt2 = opt;

                opt2.state = option->state;

                proxy()->drawPrimitive(element, &opt2, &endPainter, 0); // Note that the widget pointer is intentionally 0

                                                              // this ensures that we do not recurse in the animation logic above

                t->setEndImage(endImage);

                HTHEME theme;

                int partId;

                int duration;

                int fromState = 0;

                int toState = 0;

                //translate state flags to UXTHEME states :

                if (element == PE_FrameLineEdit) {

                    theme = pOpenThemeData(0, 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 = pOpenThemeData(0, 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 && pGetThemeTransitionDuration(theme, partId, fromState, toState,

                    TMT_TRANSITIONDURATIONS, &duration) == S_OK)

                {

                    t->setDuration(duration);

                }

                t->setStartTime(QTime::currentTime());

            }

        }

    } // 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, QLatin1String("HEADER"), HP_HEADERSORTARROW, stateId, option->rect);

            d->drawBackground(theme);

        }

        break;

    case PE_IndicatorBranch:

        {

            XPThemeData theme(d->treeViewHelper(), painter, QLatin1String("TREEVIEW"));

            static int decoration_size = 0;

            if (theme.isValid() && !decoration_size) {

                SIZE size;

                pGetThemePartSize(theme.handle(), 0, TVP_HOTGLYPH, GLPS_OPENED, 0, TS_TRUE, &size);

                decoration_size = qMax(size.cx, size.cy);

            }

            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;