1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qwindowsvistastyle.h"

    43 #include "qwindowsvistastyle_p.h"

    44 #include <private/qstylehelper_p.h>

    45 

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

    47 

    48 QT_BEGIN_NAMESPACE

    49 

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

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

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

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

    54 static const int windowsRightBorder      = 15; // right border on windows

    55 

    56 #ifndef TMT_CONTENTMARGINS

    57 #  define TMT_CONTENTMARGINS 3602

    58 #endif

    59 #ifndef TMT_SIZINGMARGINS

    60 #  define TMT_SIZINGMARGINS 3601

    61 #endif

    62 #ifndef LISS_NORMAL

    63 #  define LISS_NORMAL 1

    64 #  define LISS_HOT 2

    65 #  define LISS_SELECTED 3

    66 #  define LISS_DISABLED 4

    67 #  define LISS_SELECTEDNOTFOCUS 5

    68 #  define LISS_HOTSELECTED 6

    69 #endif

    70 #ifndef BP_COMMANDLINK

    71 #  define BP_COMMANDLINK 6

    72 #  define BP_COMMANDLINKGLYPH 7

    73 #  define CMDLGS_NORMAL 1

    74 #  define CMDLGS_HOT 2

    75 #  define CMDLGS_PRESSED 3

    76 #  define CMDLGS_DISABLED 4

    77 #endif

    78 

    79 // Runtime resolved theme engine function calls

    80 

    81 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   106 

   107 static PtrIsThemePartDefined pIsThemePartDefined = 0;

   108 static PtrOpenThemeData pOpenThemeData = 0;

   109 static PtrCloseThemeData pCloseThemeData = 0;

   110 static PtrDrawThemeBackground pDrawThemeBackground = 0;

   111 static PtrDrawThemeBackgroundEx pDrawThemeBackgroundEx = 0;

   112 static PtrGetCurrentThemeName pGetCurrentThemeName = 0;

   113 static PtrGetThemeBool pGetThemeBool = 0;

   114 static PtrGetThemeColor pGetThemeColor = 0;

   115 static PtrGetThemeEnumValue pGetThemeEnumValue = 0;

   116 static PtrGetThemeFilename pGetThemeFilename = 0;

   117 static PtrGetThemeFont pGetThemeFont = 0;

   118 static PtrGetThemeInt pGetThemeInt = 0;

   119 static PtrGetThemeIntList pGetThemeIntList = 0;

   120 static PtrGetThemeMargins pGetThemeMargins = 0;

   121 static PtrGetThemeMetric pGetThemeMetric = 0;

   122 static PtrGetThemePartSize pGetThemePartSize = 0;

   123 static PtrGetThemePosition pGetThemePosition = 0;

   124 static PtrGetThemeRect pGetThemeRect = 0;

   125 static PtrGetThemeString pGetThemeString = 0;

   126 static PtrGetThemeTransitionDuration pGetThemeTransitionDuration= 0;

   127 static PtrSetWindowTheme pSetWindowTheme = 0;

   128 static PtrGetThemePropertyOrigin pGetThemePropertyOrigin = 0;

   129 

   130 /* \internal

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

   132     fall back to Windows style.

   133 */

   134 bool QWindowsVistaStylePrivate::useVista()

   135 {

   136     return (QWindowsVistaStylePrivate::useXP() &&

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

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

   139 }

   140 

   141 /*!

   142   \class QWindowsVistaStyle

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

   144   \since 4.3

   145   \ingroup appearance

   146 

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

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

   149 

   150   \sa QMacStyle, QWindowsXPStyle, QPlastiqueStyle, QCleanlooksStyle, QMotifStyle

   151 */

   152 

   153 /*!

   154   Constructs a QWindowsVistaStyle object.

   155 */

   156 QWindowsVistaStyle::QWindowsVistaStyle()

   157     : QWindowsXPStyle(*new QWindowsVistaStylePrivate)

   158 {

   159 }

   160 

   161 //convert Qt state flags to uxtheme button states

   162 int buttonStateId(int flags, int partId)

   163 {

   164     int stateId = 0;

   165     if (partId == BP_RADIOBUTTON || partId == BP_CHECKBOX) {

   166         if (!(flags & QStyle::State_Enabled))

   167             stateId = RBS_UNCHECKEDDISABLED;

   168         else if (flags & QStyle::State_Sunken)

   169             stateId = RBS_UNCHECKEDPRESSED;

   170         else if (flags & QStyle::State_MouseOver)

   171             stateId = RBS_UNCHECKEDHOT;

   172         else

   173             stateId = RBS_UNCHECKEDNORMAL;

   174 

   175         if (flags & QStyle::State_On)

   176             stateId += RBS_CHECKEDNORMAL-1;

   177 

   178     } else if (partId == BP_PUSHBUTTON) {

   179         if (!(flags & QStyle::State_Enabled))

   180             stateId = PBS_DISABLED;

   181         else if (flags & (QStyle::State_Sunken | QStyle::State_On))

   182             stateId = PBS_PRESSED;

   183         else if (flags & QStyle::State_MouseOver)

   184             stateId = PBS_HOT;

   185         else

   186             stateId = PBS_NORMAL;

   187     } else {

   188         Q_ASSERT(1);

   189     }

   190     return stateId;

   191 }

   192 

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

   194 {

   195     Q_UNUSED(option);

   196     Q_UNUSED(painter);

   197 }

   198 

   199 /*! \internal

   200 

   201   Helperfunction to paint the current transition state between two

   202   animation frames.

   203 

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

   205   + ((1-alpha)*_secondaryImage)

   206 

   207 */

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

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

   210         return;

   211 

   212     if (_tempImage.isNull())

   213         _tempImage = _secondaryImage;

   214 

   215     const int a = qRound(alpha*256);

   216     const int ia = 256 - a;

   217     const int sw = _primaryImage.width();

   218     const int sh = _primaryImage.height();

   219     const int bpl = _primaryImage.bytesPerLine();

   220     switch(_primaryImage.depth()) {

   221     case 32:

   222         {

   223             uchar *mixed_data = _tempImage.bits();

   224             const uchar *back_data = _primaryImage.bits();

   225             const uchar *front_data = _secondaryImage.bits();

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

   227                 quint32* mixed = (quint32*)mixed_data;

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

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

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

   231                     quint32 bp = back[sx];

   232                     quint32 fp = front[sx];

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

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

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

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

   237                 }

   238                 mixed_data += bpl;

   239                 back_data += bpl;

   240                 front_data += bpl;

   241             }

   242         }

   243     default:

   244         break;

   245     }

   246     painter->drawImage(rect, _tempImage);

   247 }

   248 

   249 /*! \internal

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

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

   252   difference between _startTime and current time.

   253 */

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

   255 {

   256     float alpha = 1.0;

   257     if (_duration > 0) {

   258         QTime current = QTime::currentTime();

   259 

   260         if (_startTime > current)

   261             _startTime = current;

   262 

   263         int timeDiff = _startTime.msecsTo(current);

   264         alpha = timeDiff/(float)_duration;

   265         if (timeDiff > _duration) {

   266             _running = false;

   267             alpha = 1.0;

   268         }

   269     }

   270     else {

   271         _running = false;

   272     }

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

   274 }

   275 

   276 /*! \internal

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

   278   secondary pulse images depending on the time difference between

   279   _startTime and current time.

   280 */

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

   282 {

   283     float alpha = 1.0;

   284     if (_duration > 0) {

   285         QTime current = QTime::currentTime();

   286 

   287         if (_startTime > current)

   288             _startTime = current;

   289 

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

   291         if (timeDiff > _duration)

   292             timeDiff = _duration*2 - timeDiff;

   293         alpha = timeDiff/(float)_duration;

   294     } else {

   295         _running = false;

   296     }

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

   298 }

   299 

   300 

   301 /*!

   302  \internal

   303  

   304   Animations are used for some state transitions on specific widgets.

   305  

   306   Only one running animation can exist for a widget at any specific

   307   time.  Animations can be added through

   308   QWindowsVistaStylePrivate::startAnimation(Animation *) and any

   309   existing animation on a widget can be retrieved with

   310   QWindowsVistaStylePrivate::widgetAnimation(Widget *).

   311  

   312   Once an animation has been started,

   313   QWindowsVistaStylePrivate::timerEvent(QTimerEvent *) will

   314   continuously call update() on the widget until it is stopped,

   315   meaning that drawPrimitive will be called many times until the

   316   transition has completed. During this time, the result will be

   317   retrieved by the Animation::paint(...) function and not by the style

   318   itself.

   319  

   320   To determine if a transition should occur, the style needs to know

   321   the previous state of the widget as well as the current one. This is

   322   solved by updating dynamic properties on the widget every time the

   323   function is called.

   324  

   325   Transitions interrupting existing transitions should always be

   326   smooth, so whenever a hover-transition is started on a pulsating

   327   button, it uses the current frame of the pulse-animation as the

   328   starting image for the hover transition.

   329  

   330  */

   331 void QWindowsVistaStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option,

   332                                        QPainter *painter, const QWidget *widget) const

   333 {

   334     QWindowsVistaStylePrivate *d = const_cast<QWindowsVistaStylePrivate*>(d_func());

   335 

   336     int state = option->state;

   337     if (!QWindowsVistaStylePrivate::useVista()) {

   338         QWindowsStyle::drawPrimitive(element, option, painter, widget);

   339         return;

   340     }

   341 

   342     QRect oldRect;

   343     QRect newRect;

   344 

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

   346     {

   347         /* all widgets that supports state transitions : */

   348         if (

   349 #ifndef QT_NO_LINEEDIT

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

   351 #endif // QT_NO_LINEEDIT

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

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

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

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

   356         )

   357         {

   358             // Retrieve and update the dynamic properties tracking

   359             // the previous state of the widget:

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

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

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

   363             newRect = w->rect();

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

   365             w->setProperty("_q_stylerect", w->rect());

   366 

   367             bool doTransition = oldState && 

   368                                 ((state & State_Sunken)     != (oldState & State_Sunken) ||

   369                                  (state & State_On)         != (oldState & State_On)     ||

   370                                  (state & State_MouseOver)  != (oldState & State_MouseOver));

   371 

   372             if (oldRect != newRect ||

   373                 (state & State_Enabled) != (oldState & State_Enabled) ||

   374                 (state & State_Active)  != (oldState & State_Active))

   375                     d->stopAnimation(widget);

   376 

   377 #ifndef QT_NO_LINEEDIT

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

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

   380                     doTransition = false;

   381 #endif // QT_NO_LINEEDIT

   382 

   383             if (doTransition) {

   384 

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

   386                 // Transition object.

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

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

   389                 QStyleOption opt = *option;

   390 

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

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

   393                 startImage.fill(0);

   394                 QPainter startPainter(&startImage);

   395 

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

   397                 Transition *t = new Transition;

   398                 t->setWidget(w);

   399 

   400                 // If we have a running animation on the widget already, we will use that to paint the initial

   401                 // state of the new transition, this ensures a smooth transition from a current animation such as a

   402                 // pulsating default button into the intended target state.

   403 

   404                 if (!anim)

   405                     proxy()->drawPrimitive(element, &opt, &startPainter, 0); // Note that the widget pointer is intentionally 0

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

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

   408 

   409                 d->startAnimation(t);

   410                 t->setStartImage(startImage);

   411 

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

   413                 // if the style was not animated.

   414 

   415                 QPainter endPainter(&endImage);

   416                 endImage.fill(0);

   417                 QStyleOption opt2 = opt;

   418                 opt2.state = option->state;

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

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

   421                 t->setEndImage(endImage);

   422 

   423                 HTHEME theme;

   424                 int partId;

   425                 int duration;

   426                 int fromState = 0;

   427                 int toState = 0;

   428 

   429                 //translate state flags to UXTHEME states :

   430                 if (element == PE_FrameLineEdit) {

   431                     theme = pOpenThemeData(0, L"Edit");

   432                     partId = EP_EDITBORDER_NOSCROLL;

   433 

   434                     if (oldState & State_MouseOver)

   435                         fromState = ETS_HOT;

   436                     else if (oldState & State_HasFocus)

   437                         fromState = ETS_FOCUSED;

   438                     else

   439                         fromState = ETS_NORMAL;

   440 

   441                     if (state & State_MouseOver)

   442                         toState = ETS_HOT;

   443                     else if (state & State_HasFocus)

   444                         toState = ETS_FOCUSED;

   445                     else

   446                         toState = ETS_NORMAL;

   447 

   448                 } else {

   449                     theme = pOpenThemeData(0, L"Button");

   450                     if (element == PE_IndicatorRadioButton)

   451                         partId = BP_RADIOBUTTON;

   452                     else if (element == PE_IndicatorCheckBox)

   453                         partId = BP_CHECKBOX;

   454                     else

   455                         partId = BP_PUSHBUTTON;

   456 

   457                     fromState = buttonStateId(oldState, partId);

   458                     toState = buttonStateId(option->state, partId);

   459                 }

   460 

   461                 // Retrieve the transition time between the states from the system.

   462                 if (theme && pGetThemeTransitionDuration(theme, partId, fromState, toState,

   463                     TMT_TRANSITIONDURATIONS, &duration) == S_OK)

   464                 {

   465                     t->setDuration(duration);

   466                 }

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

   468             }

   469         }

   470     } // End of animation part

   471 

   472 

   473     QRect rect = option->rect;

   474 

   475     switch (element) {

   476     case PE_IndicatorHeaderArrow:

   477         if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {

   478             int stateId = HSAS_SORTEDDOWN;

   479             if (header->sortIndicator & QStyleOptionHeader::SortDown)

   480                 stateId = HSAS_SORTEDUP; //note that the uxtheme sort down indicator is the inverse of ours

   481             XPThemeData theme(widget, painter, QLatin1String("HEADER"), HP_HEADERSORTARROW, stateId, option->rect);

   482             d->drawBackground(theme);

   483         }

   484         break;

   485 

   486     case PE_IndicatorBranch:

   487         {

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

   489             static int decoration_size = 0;

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

   491                 SIZE size;

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

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

   494             }

   495             int mid_h = option->rect.x() + option->rect.width() / 2;

   496             int mid_v = option->rect.y() + option->rect.height() / 2;

   497             int bef_h = mid_h;

   498             int bef_v = mid_v;

   499             int aft_h = mid_h;

   500             int aft_v = mid_v;

   501             if (option->state & State_Children) {

   502                 int delta = decoration_size / 2;

   503                 theme.rect = QRect(bef_h - delta, bef_v - delta, decoration_size, decoration_size);

   504                 theme.partId = option->state & State_MouseOver ? TVP_HOTGLYPH : TVP_GLYPH;

   505                 theme.stateId = option->state & QStyle::State_Open ? GLPS_OPENED : GLPS_CLOSED;

   506                 if (option->direction == Qt::RightToLeft)

   507                     theme.mirrorHorizontally = true;

   508                 d->drawBackground(theme);

   509                 bef_h -= delta + 2;

   510                 bef_v -= delta + 2;

   511                 aft_h += delta - 2;

   512                 aft_v += delta - 2;

   513             }

   514 #if 0

   515             QBrush brush(option->palette.dark().color(), Qt::Dense4Pattern);

   516             if (option->state & State_Item) {

   517                 if (option->direction == Qt::RightToLeft)

   518                     painter->fillRect(option->rect.left(), mid_v, bef_h - option->rect.left(), 1, brush);

   519                 else

   520                     painter->fillRect(aft_h, mid_v, option->rect.right() - aft_h + 1, 1, brush);

   521             }

   522             if (option->state & State_Sibling && option->rect.bottom() > aft_v)

   523                 painter->fillRect(mid_h, aft_v, 1, option->rect.bottom() - aft_v + 1, brush);

   524             if (option->state & (State_Open | State_Children | State_Item | State_Sibling) && (bef_v > option->rect.y()))

   525                 painter->fillRect(mid_h, option->rect.y(), 1, bef_v - option->rect.y(), brush);

   526 #endif

   527         }

   528         break;

   529 

   530     case PE_PanelButtonBevel:

   531     case PE_IndicatorCheckBox:

   532     case PE_IndicatorRadioButton:

   533         {

   534             if (Animation *a = d->widgetAnimation(widget)) {

   535                 a->paint(painter, option);

   536             } else {

   537                 QWindowsXPStyle::drawPrimitive(element, option, painter, widget);

   538             }

   539         }

   540         break;

   541 

   542     case PE_FrameMenu:

   543         {

   544             int stateId = option->state & State_Active ? MB_ACTIVE : MB_INACTIVE;

   545             XPThemeData theme(widget, painter, QLatin1String("MENU"), MENU_POPUPBORDERS, stateId, option->rect);

   546             d->drawBackground(theme);

   547         }

   548         break;

   549     case PE_Frame:

   550 #ifndef QT_NO_TEXTEDIT

   551         if (const QTextEdit *edit = qobject_cast<const QTextEdit*>(widget)) {

   552             painter->save();

   553             int stateId = ETS_NORMAL;

   554             if (!(state & State_Enabled))

   555                 stateId = ETS_DISABLED;

   556             else if (edit->isReadOnly())

   557                 stateId = ETS_READONLY;

   558             else if (state & State_HasFocus)

   559                 stateId = ETS_SELECTED;

   560             XPThemeData theme(widget, painter, QLatin1String("EDIT"), EP_EDITBORDER_HVSCROLL, stateId, option->rect);

   561             uint resolve_mask = option->palette.resolve();

   562             if (resolve_mask & (1 << QPalette::Base)) {

   563                 // Since EP_EDITBORDER_HVSCROLL does not us borderfill, theme.noContent cannot be used for clipping

   564                 int borderSize = 1;

   565                 pGetThemeInt(theme.handle(), theme.partId, theme.stateId, TMT_BORDERSIZE, &borderSize);

   566                 QRegion clipRegion = option->rect;

   567                 QRegion content = option->rect.adjusted(borderSize, borderSize, -borderSize, -borderSize);

   568                 clipRegion ^= content;

   569                 painter->setClipRegion(clipRegion);

   570             }

   571             d->drawBackground(theme);

   572             painter->restore();

   573         } else

   574 #endif // QT_NO_TEXTEDIT

   575             QWindowsXPStyle::drawPrimitive(element, option, painter, widget);

   576         break;

   577 

   578     case PE_PanelLineEdit:

   579         if (const QStyleOptionFrame *panel = qstyleoption_cast<const QStyleOptionFrame *>(option)) {

   580             QBrush bg;

   581             bool usePalette = false;

   582             bool isEnabled = option->state & State_Enabled;

   583             uint resolve_mask = panel->palette.resolve();

   584             if (widget) {

   585             //Since spin box and combo box includes a line edit we need to resolve the palette on the parent instead

   586 #ifndef QT_NO_SPINBOX

   587                 if (QAbstractSpinBox *spinbox = qobject_cast<QAbstractSpinBox*>(widget->parentWidget()))

   588                     resolve_mask = spinbox->palette().resolve();

   589 #endif // QT_NO_SPINBOX

   590 #ifndef QT_NO_COMBOBOX

   591                 if (QComboBox *combobox = qobject_cast<QComboBox*>(widget->parentWidget()))

   592                     resolve_mask = combobox->palette().resolve();

   593 #endif // QT_NO_COMBOBOX

   594             }

   595             if (resolve_mask & (1 << QPalette::Base)) {

   596                 // Base color is set for this widget, so use it

   597                 bg = panel->palette.brush(QPalette::Base);

   598                 usePalette = true;

   599             }

   600             if (usePalette) {

   601                 painter->fillRect(panel->rect, bg);

   602             } else {

   603                 int partId = EP_BACKGROUND;

   604                 int stateId = EBS_NORMAL;

   605                 if (!isEnabled)

   606                     stateId = EBS_DISABLED;

   607                 else if (state & State_ReadOnly)

   608                     stateId = EBS_READONLY;

   609                 else if (state & State_MouseOver)

   610                     stateId = EBS_HOT;

   611 

   612                 XPThemeData theme(0, painter, QLatin1String("EDIT"), partId, stateId, rect);

   613                 if (!theme.isValid()) {

   614                     QWindowsStyle::drawPrimitive(element, option, painter, widget);

   615                     return;

   616                 }

   617                 int bgType;

   618                 pGetThemeEnumValue( theme.handle(),

   619                                     partId,

   620                                     stateId,

   621                                     TMT_BGTYPE,

   622                                     &bgType);

   623                 if( bgType == BT_IMAGEFILE ) {

   624                     d->drawBackground(theme);

   625                 } else {

   626                     QBrush fillColor = option->palette.brush(QPalette::Base);

   627                     if (!isEnabled) {

   628                         PROPERTYORIGIN origin = PO_NOTFOUND;

   629                         pGetThemePropertyOrigin(theme.handle(), theme.partId, theme.stateId, TMT_FILLCOLOR, &origin);

   630                         // Use only if the fill property comes from our part

   631                         if ((origin == PO_PART || origin == PO_STATE)) {

   632                             COLORREF bgRef;

   633                             pGetThemeColor(theme.handle(), partId, stateId, TMT_FILLCOLOR, &bgRef);

   634                             fillColor = QBrush(qRgb(GetRValue(bgRef), GetGValue(bgRef), GetBValue(bgRef)));

   635                         }

   636                     }

   637                     painter->fillRect(option->rect, fillColor);

   638                 }

   639             }

   640             if (panel->lineWidth > 0)

   641                 proxy()->drawPrimitive(PE_FrameLineEdit, panel, painter, widget);

   642             return;

   643         }

   644         break;

   645 

   646     case PE_FrameLineEdit:

   647         if (Animation *anim = d->widgetAnimation(widget)) {

   648             anim->paint(painter, option);

   649         } else {

   650             QPainter *p = painter;

   651             QWidget *parentWidget = 0;

   652             if (widget) {

   653                 parentWidget = widget->parentWidget();

   654                 if (parentWidget)

   655                     parentWidget = parentWidget->parentWidget();

   656             }

   657             if (widget && widget->inherits("QLineEdit")

   658                 && parentWidget && parentWidget->inherits("QAbstractItemView")) {

   659                 // we try to check if this lineedit is a delegate on a QAbstractItemView-derived class.

   660                 QPen oldPen = p->pen();

   661                 // Inner white border

   662                 p->setPen(QPen(option->palette.base().color(), 1));

   663                 p->drawRect(option->rect.adjusted(1, 1, -2, -2));

   664                 // Outer dark border

   665                 p->setPen(QPen(option->palette.shadow().color(), 1));

   666                 p->drawRect(option->rect.adjusted(0, 0, -1, -1));

   667                 p->setPen(oldPen);

   668                 return;

   669             } else {

   670                 int stateId = ETS_NORMAL;

   671                 if (!(state & State_Enabled))

   672                     stateId = ETS_DISABLED;

   673                 else if (state & State_ReadOnly)

   674                     stateId = ETS_READONLY;

   675                 else if (state & State_MouseOver)

   676                     stateId = ETS_HOT;

   677                 else if (state & State_HasFocus)

   678                     stateId = ETS_SELECTED;

   679                 XPThemeData theme(widget, painter, QLatin1String("EDIT"), EP_EDITBORDER_NOSCROLL, stateId, option->rect);

   680                 painter->save();

   681                 QRegion clipRegion = option->rect;

   682                 clipRegion -= option->rect.adjusted(2, 2, -2, -2);

   683                 painter->setClipRegion(clipRegion);

   684                 d->drawBackground(theme);

   685                 painter->restore();

   686             }

   687         }

   688         break;

   689 

   690     case PE_IndicatorToolBarHandle:

   691         {

   692             XPThemeData theme;

   693             QRect rect;

   694             if (option->state & State_Horizontal) {

   695                 theme = XPThemeData(widget, painter, QLatin1String("REBAR"), RP_GRIPPER, ETS_NORMAL, option->rect.adjusted(0, 1, -2, -2));

   696                 rect = option->rect.adjusted(0, 1, 0, -2);

   697                 rect.setWidth(4);

   698             } else {

   699                 theme = XPThemeData(widget, painter, QLatin1String("REBAR"), RP_GRIPPERVERT, ETS_NORMAL, option->rect.adjusted(0, 1, -2, -2));

   700                 rect = option->rect.adjusted(1, 0, -1, 0);

   701                 rect.setHeight(4);

   702             }

   703             theme.rect = rect;

   704             d->drawBackground(theme);

   705         }

   706         break;

   707 

   708     case PE_IndicatorToolBarSeparator:

   709         {

   710             QPen pen = painter->pen();

   711             int margin = 3;

   712             painter->setPen(option->palette.background().color().darker(114));

   713             if (option->state & State_Horizontal) {

   714                 int x1 = option->rect.center().x();

   715                 painter->drawLine(QPoint(x1, option->rect.top() + margin), QPoint(x1, option->rect.bottom() - margin));

   716             } else {

   717                 int y1 = option->rect.center().y();

   718                 painter->drawLine(QPoint(option->rect.left() + margin, y1), QPoint(option->rect.right() - margin, y1));

   719             }

   720             painter->setPen(pen);

   721         }

   722         break;

   723 

   724     case PE_PanelTipLabel: {

   725         XPThemeData theme(widget, painter, QLatin1String("TOOLTIP"), TTP_STANDARD, TTSS_NORMAL, option->rect);

   726         d->drawBackground(theme);

   727         break;

   728     }

   729 

   730     case PE_PanelItemViewItem:

   731         {

   732             const QStyleOptionViewItemV4 *vopt;

   733             const QAbstractItemView *view = qobject_cast<const QAbstractItemView *>(widget);

   734             bool newStyle = true;

   735 

   736             if (qobject_cast<const QTableView*>(widget))

   737                 newStyle = false;

   738 

   739             if (newStyle && view && (vopt = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option))) {

   740                 bool selected = vopt->state & QStyle::State_Selected;

   741                 bool hover = vopt->state & QStyle::State_MouseOver;

   742                 bool active = vopt->state & QStyle::State_Active;

   743 

   744                 if (vopt->features & QStyleOptionViewItemV2::Alternate)

   745                     painter->fillRect(vopt->rect, vopt->palette.alternateBase());

   746 

   747                 QPalette::ColorGroup cg = vopt->state & QStyle::State_Enabled

   748                                           ? QPalette::Normal : QPalette::Disabled;

   749                 if (cg == QPalette::Normal && !(vopt->state & QStyle::State_Active))

   750                     cg = QPalette::Inactive;

   751 

   752                 QRect textRect = subElementRect(QStyle::SE_ItemViewItemText, option, widget);

   753                 QRect itemRect = subElementRect(QStyle::SE_ItemViewItemFocusRect, option, widget).adjusted(-1, 0, 1, 0);

   754                 itemRect.setTop(vopt->rect.top());

   755                 itemRect.setBottom(vopt->rect.bottom());

   756 

   757                 QSize sectionSize = itemRect.size();

   758                 if (vopt->showDecorationSelected)

   759                     sectionSize = vopt->rect.size();

   760 

   761                 if (view->selectionBehavior() == QAbstractItemView::SelectRows)

   762                     sectionSize.setWidth(vopt->rect.width());

   763                 if (view->selectionMode() == QAbstractItemView::NoSelection)

   764                     hover = false;

   765                 QPixmap pixmap;

   766 

   767                 if (vopt->backgroundBrush.style() != Qt::NoBrush) {

   768                     QPointF oldBO = painter->brushOrigin();

   769                     painter->setBrushOrigin(vopt->rect.topLeft());

   770                     painter->fillRect(vopt->rect, vopt->backgroundBrush);

   771                 }

   772 

   773                 if (hover || selected) {

   774                     QString key = QString::fromLatin1("qvdelegate-%1-%2-%3-%4-%5").arg(sectionSize.width())

   775                                                         .arg(sectionSize.height()).arg(selected).arg(active).arg(hover);

   776                     if (!QPixmapCache::find(key, pixmap)) {

   777                         pixmap = QPixmap(sectionSize);

   778                         pixmap.fill(Qt::transparent);

   779 

   780                         int state;

   781                         if (selected && hover)

   782                             state = LISS_HOTSELECTED;

   783                         else if (selected && !active)

   784                             state = LISS_SELECTEDNOTFOCUS;

   785                         else if (selected)

   786                             state = LISS_SELECTED;

   787                         else

   788                             state = LISS_HOT;

   789 

   790                         QPainter pixmapPainter(&pixmap);

   791                         XPThemeData theme(d->treeViewHelper(), &pixmapPainter, QLatin1String("TREEVIEW"),

   792                             LVP_LISTITEM, state, QRect(0, 0, sectionSize.width(), sectionSize.height()));

   793                         if (theme.isValid()) {

   794                             d->drawBackground(theme);

   795                         } else {

   796                             QWindowsXPStyle::drawPrimitive(PE_PanelItemViewItem, option, painter, widget);

   797                             break;;

   798                         }

   799                         QPixmapCache::insert(key, pixmap);

   800                     }

   801 

   802                     if (vopt->showDecorationSelected) {

   803                         const int frame = 2; //Assumes a 2 pixel pixmap border

   804                         QRect srcRect = QRect(0, 0, sectionSize.width(), sectionSize.height());

   805                         QRect pixmapRect = vopt->rect;

   806                         bool reverse = vopt->direction == Qt::RightToLeft;

   807                         bool leftSection = vopt->viewItemPosition == QStyleOptionViewItemV4::Beginning;

   808                         bool rightSection = vopt->viewItemPosition == QStyleOptionViewItemV4::End;

   809                         if (vopt->viewItemPosition == QStyleOptionViewItemV4::OnlyOne

   810                             || vopt->viewItemPosition == QStyleOptionViewItemV4::Invalid)

   811                             painter->drawPixmap(pixmapRect.topLeft(), pixmap);

   812                         else if (reverse ? rightSection : leftSection){

   813                             painter->drawPixmap(QRect(pixmapRect.topLeft(), 

   814                                                 QSize(frame, pixmapRect.height())), pixmap, 

   815                                                 QRect(QPoint(0, 0), QSize(frame, pixmapRect.height())));

   816                             painter->drawPixmap(pixmapRect.adjusted(frame, 0, 0, 0), 

   817                                                 pixmap, srcRect.adjusted(frame, 0, -frame, 0));

   818                         } else if (reverse ? leftSection : rightSection) {

   819                             painter->drawPixmap(QRect(pixmapRect.topRight() - QPoint(frame - 1, 0), 

   820                                                 QSize(frame, pixmapRect.height())), pixmap, 

   821                                                 QRect(QPoint(pixmapRect.width() - frame, 0), 

   822                                                 QSize(frame, pixmapRect.height())));

   823                             painter->drawPixmap(pixmapRect.adjusted(0, 0, -frame, 0), 

   824                                                 pixmap, srcRect.adjusted(frame, 0, -frame, 0));

   825                         } else if (vopt->viewItemPosition == QStyleOptionViewItemV4::Middle)

   826                             painter->drawPixmap(pixmapRect, pixmap,

   827                                                 srcRect.adjusted(frame, 0, -frame, 0));

   828                     } else {

   829                         if (vopt->text.isEmpty() && vopt->icon.isNull())

   830                             break;

   831                         painter->drawPixmap(itemRect.topLeft(), pixmap);

   832                     }

   833                 }

   834             } else {

   835                 QWindowsXPStyle::drawPrimitive(element, option, painter, widget);

   836             }

   837             break;

   838         }

   839     case PE_Widget:

   840         {

   841             const QDialogButtonBox *buttonBox = 0;

   842 

   843             if (qobject_cast<const QMessageBox *> (widget))

   844                 buttonBox = qFindChild<const QDialogButtonBox *>(widget,QLatin1String("qt_msgbox_buttonbox"));

   845 #ifndef QT_NO_INPUTDIALOG

   846             else if (qobject_cast<const QInputDialog *> (widget))

   847                 buttonBox = qFindChild<const QDialogButtonBox *>(widget,QLatin1String("qt_inputdlg_buttonbox"));

   848 #endif // QT_NO_INPUTDIALOG

   849 

   850             if (buttonBox) {

   851                 //draw white panel part

   852                 XPThemeData theme(widget, painter, QLatin1String("TASKDIALOG"), TDLG_PRIMARYPANEL, 0, option->rect);

   853                 QRect toprect = option->rect;

   854                 toprect.setBottom(buttonBox->geometry().top());

   855                 theme.rect = toprect;

   856                 d->drawBackground(theme);

   857 

   858                 //draw bottom panel part

   859                 QRect buttonRect = option->rect;

   860                 buttonRect.setTop(buttonBox->geometry().top());

   861                 theme.rect = buttonRect;

   862                 theme.partId = TDLG_SECONDARYPANEL;

   863                 d->drawBackground(theme);

   864             }

   865         }

   866         break;

   867     default:

   868         QWindowsXPStyle::drawPrimitive(element, option, painter, widget);

   869         break;

   870     }

   871 }

   872 

   873 

   874 /*!

   875  \internal

   876 

   877  see drawPrimitive for comments on the animation support

   878  */

   879 void QWindowsVistaStyle::drawControl(ControlElement element, const QStyleOption *option,

   880                                   QPainter *painter, const QWidget *widget) const

   881 {

   882     QWindowsVistaStylePrivate *d = const_cast<QWindowsVistaStylePrivate*>(d_func());

   883 

   884     if (!QWindowsVistaStylePrivate::useVista()) {

   885         QWindowsStyle::drawControl(element, option, painter, widget);

   886         return;

   887     }

   888 

   889     bool selected = option->state & State_Selected;

   890     bool pressed = option->state & State_Sunken;

   891     bool disabled = !(option->state & State_Enabled);

   892 

   893     int state = option->state;

   894     QString name;

   895 

   896     QRect rect(option->rect);

   897     State flags = option->state;

   898     int partId = 0;

   899     int stateId = 0;

   900 

   901     QRect oldRect;

   902     QRect newRect;

   903 

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

   905         if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton *>(option)) {

   906             if ((qobject_cast<const QPushButton*>(widget) && element == CE_PushButtonBevel))

   907             {

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

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

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

   911                 newRect = w->rect();

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

   913                 w->setProperty("_q_stylerect", w->rect());

   914 

   915                 bool wasDefault = w->property("_q_isdefault").toBool();

   916                 bool isDefault = button->features & QStyleOptionButton::DefaultButton;

   917                 w->setProperty("_q_isdefault", isDefault);

   918 

   919                 bool doTransition = ((state & State_Sunken)     != (oldState & State_Sunken) ||

   920                                      (state & State_On)         != (oldState & State_On)     ||

   921                                      (state & State_MouseOver)  != (oldState & State_MouseOver));

   922 

   923                 if (oldRect != newRect || (wasDefault && !isDefault))

   924                 {

   925                     doTransition = false;

   926                     d->stopAnimation(widget);

   927                 }

   928 

   929                 if (doTransition) {

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

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

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

   933 

   934                     QStyleOptionButton opt = *button;

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

   936 

   937                     startImage.fill(0);

   938                     Transition *t = new Transition;

   939                     t->setWidget(w);

   940                     QPainter startPainter(&startImage);

   941 

   942                     if (!anim) {

   943                         proxy()->drawControl(element, &opt, &startPainter, 0 /* Intentional */);

   944                     } else {

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

   946                         d->stopAnimation(widget);

   947                     }

   948 

   949                     t->setStartImage(startImage);

   950                     d->startAnimation(t);

   951 

   952                     endImage.fill(0);

   953                     QPainter endPainter(&endImage);

   954                     proxy()->drawControl(element, option, &endPainter, 0 /* Intentional */);

   955                     t->setEndImage(endImage);

   956                     int duration = 0;

   957                     HTHEME theme = pOpenThemeData(0, L"Button");

   958 

   959                     int fromState = buttonStateId(oldState, BP_PUSHBUTTON);

   960                     int toState = buttonStateId(option->state, BP_PUSHBUTTON);

   961                     if (pGetThemeTransitionDuration(theme, BP_PUSHBUTTON, fromState, toState, TMT_TRANSITIONDURATIONS, &duration) == S_OK)

   962                         t->setDuration(duration);

   963                     else

   964                         t->setDuration(0);

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

   966                 }

   967             }

   968         }

   969     }

   970     switch (element) {

   971     case CE_PushButtonBevel:

   972         if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option))

   973         {

   974 

   975             if (Animation *anim = d->widgetAnimation(widget)) {

   976                 anim->paint(painter, option);

   977             } else {

   978                 name = QLatin1String("BUTTON");

   979                 partId = BP_PUSHBUTTON;

   980                 if (btn->features & QStyleOptionButton::CommandLinkButton)

   981                     partId = BP_COMMANDLINK;

   982                 bool justFlat = (btn->features & QStyleOptionButton::Flat) && !(flags & (State_On|State_Sunken));

   983                 if (!(flags & State_Enabled) && !(btn->features & QStyleOptionButton::Flat))

   984                     stateId = PBS_DISABLED;

   985                 else if (justFlat)

   986                     ;

   987                 else if (flags & (State_Sunken | State_On))

   988                     stateId = PBS_PRESSED;

   989                 else if (flags & State_MouseOver)

   990                     stateId = PBS_HOT;

   991                 else if (btn->features & QStyleOptionButton::DefaultButton && (state & State_Active))

   992                     stateId = PBS_DEFAULTED;

   993                 else

   994                     stateId = PBS_NORMAL;

   995 

   996                 if (!justFlat) {

   997 

   998                     if (widget && d->transitionsEnabled() && (btn->features & QStyleOptionButton::DefaultButton) &&

   999                         !(state & (State_Sunken | State_On)) && !(state & State_MouseOver) &&

  1000                          (state & State_Enabled) && (state & State_Active))

  1001                         {

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

  1003                         if (!anim && widget) {

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

  1005                             startImage.fill(0);

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

  1007                             alternateImage.fill(0);

  1008 

  1009                             Pulse *pulse = new Pulse;

  1010                             pulse->setWidget(const_cast<QWidget*>(widget));

  1011 

  1012                             QPainter startPainter(&startImage);

  1013                             stateId = PBS_DEFAULTED;

  1014                             XPThemeData theme(widget, &startPainter, name, partId, stateId, rect);

  1015                             d->drawBackground(theme);

  1016 

  1017                             QPainter alternatePainter(&alternateImage);

  1018                             theme.stateId = PBS_DEFAULTED_ANIMATING;

  1019                             theme.painter = &alternatePainter;

  1020                             d->drawBackground(theme);

  1021                             pulse->setPrimaryImage(startImage);

  1022                             pulse->setAlternateImage(alternateImage);

  1023                             pulse->setStartTime(QTime::currentTime());

  1024                             pulse->setDuration(2000);

  1025                             d->startAnimation(pulse);

  1026                             anim = pulse;

  1027                         }

  1028 

  1029                         if (anim)

  1030                             anim->paint(painter, option);

  1031                         else {

  1032                             XPThemeData theme(widget, painter, name, partId, stateId, rect);

  1033                             d->drawBackground(theme);

  1034                         }

  1035                     }

  1036                     else {

  1037                         d->stopAnimation(widget);

  1038                         XPThemeData theme(widget, painter, name, partId, stateId, rect);

  1039                         d->drawBackground(theme);

  1040                     }

  1041                 }

  1042             }

  1043             if (btn->features & QStyleOptionButton::HasMenu) {

  1044                 int mbiw = 0, mbih = 0;

  1045                 XPThemeData theme(widget, 0, QLatin1String("TOOLBAR"), TP_DROPDOWNBUTTON);

  1046                 if (theme.isValid()) {

  1047                     SIZE size;

  1048                     if (pGetThemePartSize(theme.handle(), 0, theme.partId, theme.stateId, 0, TS_TRUE, &size) == S_OK) {

  1049                         mbiw = size.cx;

  1050                         mbih = size.cy;

  1051                     }

  1052                 }

  1053                 QRect ir = subElementRect(SE_PushButtonContents, option, 0);

  1054                 QStyleOptionButton newBtn = *btn;

  1055                 newBtn.rect = QStyle::visualRect(option->direction, option->rect,

  1056                                                 QRect(ir.right() - mbiw - 2,

  1057                                                       option->rect.top() + (option->rect.height()/2) - (mbih/2),

  1058                                                       mbiw + 1, mbih + 1));

  1059                 proxy()->drawPrimitive(PE_IndicatorArrowDown, &newBtn, painter, widget);

  1060             }

  1061             return;

  1062         }

  1063         break;

  1064 #ifndef QT_NO_PROGRESSBAR

  1065     case CE_ProgressBarContents:

  1066         if (const QStyleOptionProgressBar *bar

  1067                 = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {

  1068             int stateId = MBI_NORMAL;

  1069             if (disabled)

  1070                 stateId = MBI_DISABLED;

  1071             bool isIndeterminate = (bar->minimum == 0 && bar->maximum == 0);

  1072             bool vertical = false;

  1073             bool inverted = false;

  1074             if (const QStyleOptionProgressBarV2 *pb2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {

  1075                 vertical = (pb2->orientation == Qt::Vertical);

  1076                 inverted = pb2->invertedAppearance;

  1077             }

  1078 

  1079             if (const QProgressBar *progressbar = qobject_cast<const QProgressBar *>(widget)) {

  1080                 if (((progressbar->value() > 0  && d->transitionsEnabled()) || isIndeterminate)) {

  1081                     if (!d->widgetAnimation(progressbar) && progressbar->value() < progressbar->maximum()) {

  1082                         Animation *a = new Animation;

  1083                         a->setWidget(const_cast<QWidget*>(widget));

  1084                         a->setStartTime(QTime::currentTime());

  1085                         d->startAnimation(a);

  1086                     }

  1087                 } else {

  1088                     d->stopAnimation(progressbar);

  1089                 }

  1090             }

  1091 

  1092             XPThemeData theme(widget, painter, QLatin1String("PROGRESS"), vertical ? PP_FILLVERT : PP_FILL);

  1093             theme.rect = option->rect;

  1094             bool reverse = (bar->direction == Qt::LeftToRight && inverted) || (bar->direction == Qt::RightToLeft && !inverted);

  1095             QTime current = QTime::currentTime();

  1096 

  1097             if (isIndeterminate) {

  1098                 if (Animation *a = d->widgetAnimation(widget)) {

  1099                     int glowSize = 120;

  1100                     int animationWidth = glowSize * 2 + (vertical ? theme.rect.height() : theme.rect.width());

  1101                     int animOffset = a->startTime().msecsTo(current) / 4;

  1102                     if (animOffset > animationWidth)

  1103                         a->setStartTime(QTime::currentTime());

  1104                     painter->save();

  1105                     painter->setClipRect(theme.rect);

  1106                     QRect animRect;

  1107                     QSize pixmapSize(14, 14);

  1108                     if (vertical) {

  1109                         animRect = QRect(theme.rect.left(),

  1110                                          inverted ? rect.top() - glowSize + animOffset :

  1111                                                     rect.bottom() + glowSize - animOffset,

  1112                                          rect.width(), glowSize);

  1113                          pixmapSize.setHeight(animRect.height());

  1114                     } else {

  1115                         animRect = QRect(rect.left() - glowSize + animOffset,

  1116                                          rect.top(), glowSize, rect.height());

  1117                         animRect = QStyle::visualRect(reverse ? Qt::RightToLeft : Qt::LeftToRight, 

  1118                                                                 option->rect, animRect);

  1119                         pixmapSize.setWidth(animRect.width());

  1120                     }

  1121                     QString name = QString::fromLatin1("qiprogress-%1-%2").arg(pixmapSize.width()).arg(pixmapSize.height());

  1122                     QPixmap pixmap;

  1123                     if (!QPixmapCache::find(name, pixmap)) {

  1124                         QImage image(pixmapSize, QImage::Format_ARGB32);

  1125                         image.fill(Qt::transparent);

  1126                         QPainter imagePainter(&image);

  1127                         theme.painter = &imagePainter;

  1128                         theme.partId = vertical ? PP_FILLVERT : PP_FILL;

  1129                         theme.rect = QRect(QPoint(0,0), theme.rect.size());

  1130                         QLinearGradient alphaGradient(0, 0, vertical ? 0 : image.width(),

  1131                                                       vertical ? image.height() : 0);

  1132                         alphaGradient.setColorAt(0, QColor(0, 0, 0, 0));

  1133                         alphaGradient.setColorAt(0.5, QColor(0, 0, 0, 220));

  1134                         alphaGradient.setColorAt(1, QColor(0, 0, 0, 0));