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

    42 #include "qwindowsxpstyle_p.h"

    43 

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

    45 

    46 #include <private/qobject_p.h>

    47 #include <private/qpaintengine_raster_p.h>

    48 #include <private/qapplication_p.h>

    49 #include <private/qstylehelper_p.h>

    50 #include <qlibrary.h>

    51 #include <qpainter.h>

    52 #include <qpaintengine.h>

    53 #include <qwidget.h>

    54 #include <qapplication.h>

    55 #include <qpixmapcache.h>

    56 

    57 #include <qdesktopwidget.h>

    58 #include <qtoolbutton.h>

    59 #include <qtabbar.h>

    60 #include <qcombobox.h>

    61 #include <qscrollbar.h>

    62 #include <qheaderview.h>

    63 #include <qspinbox.h>

    64 #include <qlistview.h>

    65 #include <qstackedwidget.h>

    66 #include <qpushbutton.h>

    67 #include <qtoolbar.h>

    68 #include <qlabel.h>

    69 #include <qvarlengtharray.h>

    70 #include <qdebug.h>

    71 

    72 QT_BEGIN_NAMESPACE

    73 

    74 // Runtime resolved theme engine function calls

    75 typedef bool (WINAPI *PtrIsAppThemed)();

    76 typedef bool (WINAPI *PtrIsThemeActive)();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   100 

   101 static PtrIsAppThemed pIsAppThemed = 0;

   102 static PtrIsThemeActive pIsThemeActive = 0;

   103 static PtrOpenThemeData pOpenThemeData = 0;

   104 static PtrCloseThemeData pCloseThemeData = 0;

   105 static PtrDrawThemeBackground pDrawThemeBackground = 0;

   106 static PtrDrawThemeBackgroundEx pDrawThemeBackgroundEx = 0;

   107 static PtrGetCurrentThemeName pGetCurrentThemeName = 0;

   108 static PtrGetThemeBool pGetThemeBool = 0;

   109 static PtrGetThemeColor pGetThemeColor = 0;

   110 static PtrGetThemeEnumValue pGetThemeEnumValue = 0;

   111 static PtrGetThemeFilename pGetThemeFilename = 0;

   112 static PtrGetThemeFont pGetThemeFont = 0;

   113 static PtrGetThemeInt pGetThemeInt = 0;

   114 static PtrGetThemeIntList pGetThemeIntList = 0;

   115 static PtrGetThemeMargins pGetThemeMargins = 0;

   116 static PtrGetThemeMetric pGetThemeMetric = 0;

   117 static PtrGetThemePartSize pGetThemePartSize = 0;

   118 static PtrGetThemePosition pGetThemePosition = 0;

   119 static PtrGetThemePropertyOrigin pGetThemePropertyOrigin = 0;

   120 static PtrGetThemeRect pGetThemeRect = 0;

   121 static PtrGetThemeString pGetThemeString = 0;

   122 static PtrGetThemeBackgroundRegion pGetThemeBackgroundRegion = 0;

   123 static PtrGetThemeDocumentationProperty pGetThemeDocumentationProperty = 0;

   124 static PtrIsThemeBackgroundPartiallyTransparent pIsThemeBackgroundPartiallyTransparent = 0;

   125 

   126 // General const values

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

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

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

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

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

   132 

   133 // External function calls

   134 extern Q_GUI_EXPORT HDC qt_win_display_dc();

   135 extern QRegion qt_region_from_HRGN(HRGN rgn);

   136 

   137 

   138 

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

   140 /* \internal

   141     Returns true if the themedata is valid for use.

   142 */

   143 bool XPThemeData::isValid()

   144 {

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

   146 }

   147 

   148 

   149 /* \internal

   150     Returns the theme engine handle to the specific class.

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

   152     adds it to a static map, for caching.

   153 */

   154 HTHEME XPThemeData::handle()

   155 {

   156     if (!QWindowsXPStylePrivate::useXP())

   157         return 0;

   158 

   159     if (!htheme && QWindowsXPStylePrivate::handleMap)

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

   161 

   162     if (!htheme) {

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

   164         if (htheme) {

   165             if (!QWindowsXPStylePrivate::handleMap)

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

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

   168         }

   169     }

   170 

   171     return htheme;

   172 }

   173 

   174 /* \internal

   175     Converts a QRect to the native RECT structure.

   176 */

   177 RECT XPThemeData::toRECT(const QRect &qr)

   178 {

   179     RECT r;

   180     r.left = qr.x();

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

   182     r.top = qr.y();

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

   184     return r;

   185 }

   186 

   187 /* \internal

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

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

   190 */

   191 HRGN XPThemeData::mask()

   192 {

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

   194         return 0;

   195 

   196     HRGN hrgn;

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

   198     RECT nativeRect = toRECT(rect);

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

   200     if (dc)

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

   202     return hrgn;

   203 }

   204 

   205 // QWindowsXPStylePrivate -------------------------------------------------------------------------

   206 // Static initializations

   207 QWidget *QWindowsXPStylePrivate::limboWidget = 0;

   208 QPixmap *QWindowsXPStylePrivate::tabbody = 0;

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

   210 bool QWindowsXPStylePrivate::use_xp = false;

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

   212 

   213 /* \internal

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

   215     fall back to Windows style.

   216 */

   217 bool QWindowsXPStylePrivate::useXP(bool update)

   218 {

   219     if (!update)

   220         return use_xp;

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

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

   223 }

   224 

   225 /* \internal

   226     Handles refcounting, and queries the theme engine for usage.

   227 */

   228 void QWindowsXPStylePrivate::init(bool force)

   229 {

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

   231         return;

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

   233         ref.ref();

   234 

   235     useXP(true);

   236 }

   237 

   238 /* \internal

   239     Cleans up all static data.

   240 */

   241 void QWindowsXPStylePrivate::cleanup(bool force)

   242 {

   243     if(bufferBitmap) {

   244         if (bufferDC && nullBitmap)

   245             SelectObject(bufferDC, nullBitmap);

   246         DeleteObject(bufferBitmap);

   247         bufferBitmap = 0;

   248     }

   249 

   250     if(bufferDC)

   251         DeleteDC(bufferDC);

   252     bufferDC = 0;

   253 

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

   255         return;

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

   257         ref.deref();

   258 

   259     use_xp = false;

   260     cleanupHandleMap();

   261     if (limboWidget) {

   262         if (QApplication::closingDown())

   263             delete limboWidget;

   264         else

   265             limboWidget->deleteLater();

   266     }

   267     delete tabbody;

   268     limboWidget = 0;

   269     tabbody = 0;

   270 }

   271 

   272 /* \internal

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

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

   275     example the user changes the theme style.

   276 */

   277 void QWindowsXPStylePrivate::cleanupHandleMap()

   278 {

   279     if (!handleMap)

   280         return;

   281 

   282     QMap<QString, HTHEME>::Iterator it;

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

   284         pCloseThemeData(it.value());

   285     delete handleMap;

   286     handleMap = 0;

   287 }

   288 

   289 /*! \internal

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

   291     create a limbo widget to do so.

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

   293     this function ensures that we get one.

   294 */

   295 HWND QWindowsXPStylePrivate::winId(const QWidget *widget)

   296 {

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

   298         return widget->internalWinId();

   299 

   300     if (!limboWidget) {

   301         limboWidget = new QWidget(0);

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

   303     }

   304 

   305     return limboWidget->winId();

   306 }

   307 

   308 /*! \internal

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

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

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

   312 */

   313 const QPixmap *QWindowsXPStylePrivate::tabBody(QWidget *)

   314 {

   315     if (!tabbody) {

   316         SIZE sz;

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

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

   319 

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

   321         QPainter painter(tabbody);

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

   323         drawBackground(theme);

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

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

   326         QPixmap temp(sz.cx, 1);

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

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

   329     }

   330     return tabbody;

   331 }

   332 

   333 /*! \internal

   334     Returns true if all the necessary theme engine symbols were

   335     resolved.

   336 */

   337 bool QWindowsXPStylePrivate::resolveSymbols()

   338 {

   339     static bool tried = false;

   340     if (!tried) {

   341         tried = true;

   342         QLibrary themeLib(QLatin1String("uxtheme"));

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

   344         if (pIsAppThemed) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   369         }

   370     }

   371 

   372     return pIsAppThemed != 0;

   373 }

   374 

   375 /*! \internal

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

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

   378     the alpha values on proper alpha-pixmaps.

   379 */

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

   381 {

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

   383     if (bufferBitmap) {

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

   385             return bufferBitmap;

   386         // Not big enough, discard the old one

   387         if (bufferDC && nullBitmap)

   388             SelectObject(bufferDC, nullBitmap);

   389         DeleteObject(bufferBitmap);

   390         bufferBitmap = 0;

   391     }

   392 

   393     w = qMax(bufferW, w);

   394     h = qMax(bufferH, h);

   395 

   396     if (!bufferDC)

   397         bufferDC = CreateCompatibleDC(qt_win_display_dc());

   398 

   399     // Define the header

   400     BITMAPINFO bmi;

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

   402     bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);

   403     bmi.bmiHeader.biWidth       = w;

   404     bmi.bmiHeader.biHeight      = -h;

   405     bmi.bmiHeader.biPlanes      = 1;

   406     bmi.bmiHeader.biBitCount    = 32;

   407     bmi.bmiHeader.biCompression = BI_RGB;

   408 

   409     // Create the pixmap

   410     bufferPixels = 0;

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

   412     GdiFlush();

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

   414 

   415     if (!bufferBitmap) {

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

   417         bufferW = 0;

   418         bufferH = 0;

   419         return 0;

   420     }

   421     if (!bufferPixels) {

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

   423         bufferW = 0;

   424         bufferH = 0;

   425         return 0;

   426     }

   427     bufferW = w;

   428     bufferH = h;

   429 #ifdef DEBUG_XP_STYLE

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

   431 #endif

   432     return bufferBitmap;

   433 }

   434 

   435 /*! \internal

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

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

   438         - Alpha transparency

   439         - Masked transparency

   440 */

   441 bool QWindowsXPStylePrivate::isTransparent(XPThemeData &themeData)

   442 {

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

   444                                                   themeData.stateId);

   445 }

   446 

   447 

   448 /*! \internal

   449     Returns a QRegion of the region of the part

   450 */

   451 QRegion QWindowsXPStylePrivate::region(XPThemeData &themeData)

   452 {

   453     HRGN hRgn = 0;

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

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

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

   457         return QRegion();

   458 

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

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

   461 

   462     QRegion region;

   463 

   464     if (success)

   465         region = qt_region_from_HRGN(dest);

   466 

   467     DeleteObject(hRgn);

   468     DeleteObject(dest);

   469 

   470     return region;

   471 }

   472 

   473 /*! \internal

   474     Sets the parts region on a window.

   475 */

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

   477 {

   478     HRGN hrgn = themeData.mask();

   479     if (hrgn && widget)

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

   481 }

   482 

   483 /*! \internal

   484     Returns true if the native doublebuffer contains a pixel which

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

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

   487     alpha pixmap.

   488 */

   489 bool QWindowsXPStylePrivate::hasAnyData(const QRect &rect)

   490 {

   491     const int startX = rect.left();

   492     const int startY = rect.top();

   493     const int w = rect.width();

   494     const int h = rect.height();

   495 

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

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

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

   499             int alpha = (*buffer) >> 24;

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

   501                 return true;

   502         }

   503     }

   504     return false;

   505 }

   506 

   507 /*! \internal

   508     Returns true if the native doublebuffer contains pixels with

   509     varying alpha value.

   510 */

   511 bool QWindowsXPStylePrivate::hasAlphaChannel(const QRect &rect)

   512 {

   513     const int startX = rect.left();

   514     const int startY = rect.top();

   515     const int w = rect.width();

   516     const int h = rect.height();

   517 

   518     int firstAlpha = -1;

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

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

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

   522             int alpha = (*buffer) >> 24;

   523             if (firstAlpha == -1)

   524                 firstAlpha = alpha;

   525             else if (alpha != firstAlpha)

   526                 return true;

   527         }

   528     }

   529     return false;

   530 }

   531 

   532 /*! \internal

   533     When the theme engine paints both a true alpha pixmap and a glyph

   534     into our buffer, the glyph might not contain a proper alpha value.

   535     The rule of thumb for premultiplied pixmaps is that the color

   536     values of a pixel can never be higher than the alpha values, so

   537     we use this to our advantage here, and fix all instances where

   538     this occures.

   539 */

   540 bool QWindowsXPStylePrivate::fixAlphaChannel(const QRect &rect)

   541 {

   542     const int startX = rect.left();

   543     const int startY = rect.top();

   544     const int w = rect.width();

   545     const int h = rect.height();

   546     bool hasFixedAlphaValue = false;

   547 

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

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

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

   551             uint pixel = *buffer;

   552             int alpha = qAlpha(pixel);

   553             if (qRed(pixel) > alpha || qGreen(pixel) > alpha || qBlue(pixel) > alpha) {

   554                 *buffer |= 0xff000000;

   555                 hasFixedAlphaValue = true;

   556             }

   557         }

   558     }

   559     return hasFixedAlphaValue;

   560 }

   561 

   562 /*! \internal

   563     Swaps the alpha values on certain pixels:

   564         0xFF?????? -> 0x00??????

   565         0x00?????? -> 0xFF??????

   566     Used to determin the mask of a non-alpha transparent pixmap in

   567     the native doublebuffer, and swap the alphas so we may paint

   568     the image as a Premultiplied QImage with drawImage(), and obtain

   569     the mask transparency.

   570 */

   571 bool QWindowsXPStylePrivate::swapAlphaChannel(const QRect &rect, bool allPixels)

   572 {

   573     const int startX = rect.left();

   574     const int startY = rect.top();

   575     const int w = rect.width();

   576     const int h = rect.height();

   577     bool valueChange = false;

   578 

   579     // Flip the alphas, so that 255-alpha pixels are 0, and 0-alpha are 255.

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

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

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

   583             if (allPixels) {

   584                 *buffer |= 0xFF000000;

   585                 continue;

   586             }

   587             register unsigned int alphaValue = (*buffer) & 0xFF000000;

   588             if (alphaValue == 0xFF000000) {

   589                 *buffer = 0;

   590                 valueChange = true;

   591             } else if (alphaValue == 0) {

   592                 *buffer |= 0xFF000000;

   593                 valueChange = true;

   594             }

   595         }

   596     }

   597     return valueChange;

   598 }

   599 

   600 /*! \internal

   601     Main theme drawing function.

   602     Determines the correct lowlevel drawing method depending on several

   603     factors.

   604         Use drawBackgroundThruNativeBuffer() if:

   605             - Painter does not have an HDC

   606             - Theme part is flipped (mirrored horizontally)

   607         else use drawBackgroundDirectly().

   608 */

   609 void QWindowsXPStylePrivate::drawBackground(XPThemeData &themeData)

   610 {

   611     if (themeData.rect.isEmpty())

   612         return;

   613 

   614     QPainter *painter = themeData.painter;

   615     Q_ASSERT_X(painter != 0, "QWindowsXPStylePrivate::drawBackground()", "Trying to draw a theme part without a painter");

   616     if (!painter || !painter->isActive())

   617         return;

   618 

   619     painter->save();

   620 

   621     QMatrix m = painter->matrix();

   622     bool complexXForm = m.m11() != 1.0 || m.m22() != 1.0 || m.m12() != 0.0 || m.m21() != 0.0;

   623 

   624     bool translucentToplevel = false;

   625     QPaintDevice *pdev = painter->device();

   626     if (pdev->devType() == QInternal::Widget) {

   627         QWidget *win = ((QWidget *) pdev)->window();

   628         translucentToplevel = win->testAttribute(Qt::WA_TranslucentBackground);

   629     }

   630 

   631     bool useFallback = painter->paintEngine()->getDC() == 0

   632                        || painter->opacity() != 1.0

   633                        || themeData.rotate

   634                        || complexXForm

   635                        || themeData.mirrorVertically

   636                        || (themeData.mirrorHorizontally && pDrawThemeBackgroundEx == 0)

   637                        || translucentToplevel;

   638 

   639     if (!useFallback)

   640         drawBackgroundDirectly(themeData);

   641     else

   642         drawBackgroundThruNativeBuffer(themeData);

   643 

   644     painter->restore();

   645 }

   646 

   647 /*! \internal

   648     This function draws the theme parts directly to the paintengines HDC.

   649     Do not use this if you need to perform other transformations on the

   650     resulting data.

   651 */

   652 void QWindowsXPStylePrivate::drawBackgroundDirectly(XPThemeData &themeData)

   653 {

   654     QPainter *painter = themeData.painter;

   655     HDC dc = painter->paintEngine()->getDC();

   656 

   657     QPoint redirectionDelta(int(painter->deviceMatrix().dx()),

   658                             int(painter->deviceMatrix().dy()));

   659     QRect area = themeData.rect.translated(redirectionDelta);

   660 

   661     QRegion sysRgn = painter->paintEngine()->systemClip();

   662     if (sysRgn.isEmpty())

   663         sysRgn = area;

   664     else

   665         sysRgn &= area;

   666     if (painter->hasClipping())

   667         sysRgn &= painter->clipRegion().translated(redirectionDelta);

   668     SelectClipRgn(dc, sysRgn.handle());

   669 

   670 #ifdef DEBUG_XP_STYLE

   671         printf("---[ DIRECT PAINTING ]------------------> Name(%-10s) Part(%d) State(%d)\n",

   672                qPrintable(themeData.name), themeData.partId, themeData.stateId);

   673         showProperties(themeData);

   674 #endif

   675 

   676     RECT drawRECT = themeData.toRECT(area);

   677     DTBGOPTS drawOptions;

   678     drawOptions.dwSize = sizeof(drawOptions);

   679     drawOptions.rcClip = themeData.toRECT(sysRgn.boundingRect());

   680     drawOptions.dwFlags = DTBG_CLIPRECT

   681                           | (themeData.noBorder ? DTBG_OMITBORDER : 0)

   682                           | (themeData.noContent ? DTBG_OMITCONTENT : 0)

   683                           | (themeData.mirrorHorizontally ? DTBG_MIRRORDC : 0);

   684 

   685     if (pDrawThemeBackgroundEx != 0) {

   686         pDrawThemeBackgroundEx(themeData.handle(), dc, themeData.partId, themeData.stateId, &(drawRECT), &drawOptions);

   687     } else {

   688         // We are running on a system where the uxtheme.dll does not have

   689         // the DrawThemeBackgroundEx function, so we need to clip away

   690         // borders or contents manually. All flips and mirrors uses the

   691         // fallback implementation

   692 

   693         int borderSize = 0;

   694         PROPERTYORIGIN origin = PO_NOTFOUND;

   695         pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &origin);

   696         pGetThemeInt(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &borderSize);

   697 

   698         // Clip away border region

   699         QRegion extraClip = sysRgn;

   700         if ((origin == PO_CLASS || origin == PO_PART || origin == PO_STATE) && borderSize > 0) {

   701             if (themeData.noBorder) {

   702                 // extraClip &= area is already done

   703                 drawRECT = themeData.toRECT(area.adjusted(-borderSize, -borderSize, borderSize, borderSize));

   704             }

   705 

   706             // Clip away content region

   707             if (themeData.noContent) {

   708                 QRegion content = area.adjusted(borderSize, borderSize, -borderSize, -borderSize);

   709                 extraClip ^= content;

   710             }

   711 

   712             // Set the clip region, if used..

   713             if (themeData.noBorder || themeData.noContent)

   714                 SelectClipRgn(dc, extraClip.handle());

   715         }

   716 

   717         pDrawThemeBackground(themeData.handle(), dc, themeData.partId, themeData.stateId, &(drawRECT), &(drawOptions.rcClip));

   718     }

   719     SelectClipRgn(dc, 0);

   720 }

   721 

   722 /*! \internal

   723     This function uses a secondary Native doublebuffer for painting parts.

   724     It should only be used when the painteengine doesn't provide a proper

   725     HDC for direct painting (e.g. when doing a grabWidget(), painting to

   726     other pixmaps etc), or when special transformations are needed (e.g.

   727     flips (horizonal mirroring only, vertical are handled by the theme

   728     engine).

   729 */

   730 void QWindowsXPStylePrivate::drawBackgroundThruNativeBuffer(XPThemeData &themeData)

   731 {

   732     QPainter *painter = themeData.painter;

   733     QRect rect = themeData.rect;

   734 

   735     if ((themeData.rotate + 90) % 180 == 0) { // Catch 90,270,etc.. degree flips.

   736         rect = QRect(0, 0, rect.height(), rect.width());

   737     }

   738     rect.moveTo(0,0);

   739     int partId = themeData.partId;

   740     int stateId = themeData.stateId;

   741     int w = rect.width();

   742     int h = rect.height();

   743 

   744     // Values initialized later, either from cached values, or from function calls

   745     AlphaChannelType alphaType = UnknownAlpha;

   746     bool stateHasData = true; // We assume so;

   747     bool hasAlpha = false;

   748     bool partIsTransparent;

   749     bool inspectData;

   750     bool potentialInvalidAlpha;

   751 

   752     QString pixmapCacheKey = QString::fromLatin1("$qt_xp_%1p%2s%3s%4b%5c%6w%7h").arg(themeData.name)

   753                              .arg(partId).arg(stateId).arg(!themeData.noBorder).arg(!themeData.noContent)

   754                              .arg(w).arg(h);

   755     QPixmap cachedPixmap;

   756     ThemeMapKey key(themeData);

   757     ThemeMapData data = alphaCache.value(key);

   758 

   759     bool haveCachedPixmap = false;

   760     bool isCached = data.dataValid;

   761     if (isCached) {

   762         if (!(stateHasData = data.hasAnyData))

   763             return; // Cached NOOP

   764         inspectData = data.wasAlphaSwapped;

   765         partIsTransparent = data.partIsTransparent;

   766         hasAlpha = data.hasAlphaChannel;

   767         alphaType = data.alphaType;

   768         potentialInvalidAlpha = data.hadInvalidAlpha;

   769 

   770         haveCachedPixmap = QPixmapCache::find(pixmapCacheKey, cachedPixmap);

   771 

   772 #ifdef DEBUG_XP_STYLE

   773         char buf[25];

   774         ::sprintf(buf, "+ Pixmap(%3d, %3d) ]", w, h);

   775         printf("---[ CACHED %s--------> Name(%-10s) Part(%d) State(%d)\n",

   776                haveCachedPixmap ? buf : "]-------------------",

   777                qPrintable(themeData.name), themeData.partId, themeData.stateId);

   778 #endif

   779     } else {

   780         // Not cached, so get values from Theme Engine

   781         BOOL tmt_borderonly = false;

   782         COLORREF tmt_transparentcolor = 0x0;

   783         PROPERTYORIGIN proporigin = PO_NOTFOUND;

   784         pGetThemeBool(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERONLY, &tmt_borderonly);

   785         pGetThemeColor(themeData.handle(), themeData.partId, themeData.stateId, TMT_TRANSPARENTCOLOR, &tmt_transparentcolor);

   786         pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_CAPTIONMARGINS, &proporigin);

   787         inspectData = (tmt_transparentcolor != 0 || tmt_borderonly || proporigin == PO_PART || proporigin == PO_STATE);

   788 

   789         // ### This is a vista-specific workaround for broken alpha in titlebar pixmaps

   790         if ((QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)) {

   791             if (themeData.partId == WP_CAPTION || themeData.partId == WP_SMALLCAPTION)

   792                 inspectData = false;

   793         }

   794 

   795         partIsTransparent = isTransparent(themeData);

   796 

   797         potentialInvalidAlpha = false;

   798         pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_GLYPHTYPE, &proporigin);

   799         if (proporigin == PO_PART || proporigin == PO_STATE) {

   800             int tmt_glyphtype = GT_NONE;

   801             pGetThemeEnumValue(themeData.handle(), themeData.partId, themeData.stateId, TMT_GLYPHTYPE, &tmt_glyphtype);

   802             potentialInvalidAlpha = partIsTransparent && !inspectData && tmt_glyphtype == GT_IMAGEGLYPH;

   803         }

   804 

   805 #ifdef DEBUG_XP_STYLE

   806         printf("---[ NOT CACHED ]-----------------------> Name(%-10s) Part(%d) State(%d)\n",

   807                qPrintable(themeData.name), themeData.partId, themeData.stateId);

   808         printf("-->partIsTransparen      = %d\n", partIsTransparent);

   809         printf("-->inspectData           = %d\n", inspectData);

   810         printf("-->potentialInvalidAlpha = %d\n", potentialInvalidAlpha);

   811         showProperties(themeData);

   812 #endif

   813     }

   814     bool wasAlphaSwapped = false;

   815     bool wasAlphaFixed = false;

   816 

   817     // OLD PSDK Workaround ------------------------------------------------------------------------

   818     // See if we need extra clipping for the older PSDK, which does

   819     // not have a DrawThemeBackgroundEx function for DTGB_OMITBORDER

   820     // and DTGB_OMITCONTENT

   821     bool addBorderContentClipping = false;

   822     QRegion extraClip;

   823     QRect area = rect;

   824     if (themeData.noBorder || themeData.noContent) {

   825         extraClip = area;

   826         // We are running on a system where the uxtheme.dll does not have

   827         // the DrawThemeBackgroundEx function, so we need to clip away

   828         // borders or contents manually.

   829 

   830         int borderSize = 0;

   831         PROPERTYORIGIN origin = PO_NOTFOUND;

   832         pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &origin);

   833         pGetThemeInt(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &borderSize);

   834 

   835         // Clip away border region

   836         if ((origin == PO_CLASS || origin == PO_PART || origin == PO_STATE) && borderSize > 0) {

   837             if (themeData.noBorder) {

   838                 extraClip &= area;

   839                 area = area.adjusted(-borderSize, -borderSize, borderSize, borderSize);

   840             }

   841 

   842             // Clip away content region

   843             if (themeData.noContent) {

   844                 QRegion content = area.adjusted(borderSize, borderSize, -borderSize, -borderSize);

   845                 extraClip ^= content;

   846             }

   847         }

   848         addBorderContentClipping = (themeData.noBorder | themeData.noContent);

   849     }

   850 

   851     QImage img;

   852     if (!haveCachedPixmap) { // If the pixmap is not cached, generate it! -------------------------

   853         buffer(w, h); // Ensure a buffer of at least (w, h) in size

   854         HDC dc = bufferHDC();

   855 

   856         // Clear the buffer

   857         if (alphaType != NoAlpha) {

   858             // Consider have separate "memset" function for small chunks for more speedup

   859             memset(bufferPixels, inspectData ? 0xFF : 0x00, bufferW * h * 4);

   860         }

   861 

   862         // Difference between area and rect

   863         int dx = area.x() - rect.x();

   864         int dy = area.y() - rect.y();

   865         int dr = area.right() - rect.right();

   866         int db = area.bottom() - rect.bottom();

   867 

   868         // Adjust so painting rect starts from Origo

   869         rect.moveTo(0,0);

   870         area.moveTo(dx,dy);

   871         DTBGOPTS drawOptions;

   872         drawOptions.dwSize = sizeof(drawOptions);

   873         drawOptions.rcClip = themeData.toRECT(rect);

   874         drawOptions.dwFlags = DTBG_CLIPRECT

   875                             | (themeData.noBorder ? DTBG_OMITBORDER : 0)

   876                             | (themeData.noContent ? DTBG_OMITCONTENT : 0);

   877 

   878         // Drawing the part into the backing store

   879         if (pDrawThemeBackgroundEx != 0) {

   880             RECT rect(themeData.toRECT(area));

   881             pDrawThemeBackgroundEx(themeData.handle(), dc, themeData.partId, themeData.stateId, &rect, &drawOptions);

   882         } else {

   883             // Set the clip region, if used..

   884             if (addBorderContentClipping) {

   885                 SelectClipRgn(dc, extraClip.handle());

   886                 // Compensate for the noBorder area difference (noContent has the same area)

   887                 drawOptions.rcClip = themeData.toRECT(rect.adjusted(dx, dy, dr, db));

   888             }

   889 

   890             pDrawThemeBackground(themeData.handle(), dc, themeData.partId, themeData.stateId, &(drawOptions.rcClip), 0);

   891 

   892             if (addBorderContentClipping)

   893                 SelectClipRgn(dc, 0);

   894         }

   895 

   896         // If not cached, analyze the buffer data to figure

   897         // out alpha type, and if it contains data

   898         if (!isCached) {

   899             if (inspectData)

   900                 stateHasData = hasAnyData(rect);

   901             // SHORTCUT: If the part's state has no data, cache it for NOOP later

   902             if (!stateHasData) {

   903                 memset(&data, 0, sizeof(data));

   904                 data.dataValid = true;

   905                 alphaCache.insert(key, data);

   906                 return;

   907             }

   908             hasAlpha = hasAlphaChannel(rect);

   909             if (!hasAlpha && partIsTransparent)

   910                 potentialInvalidAlpha = true;

   911 #if defined(DEBUG_XP_STYLE) && 1

   912             dumpNativeDIB(w, h);

   913 #endif

   914         }

   915 

   916         // Swap alpha values, if needed

   917         if (inspectData)

   918             wasAlphaSwapped = swapAlphaChannel(rect);

   919 

   920         // Fix alpha values, if needed

   921         if (potentialInvalidAlpha)

   922             wasAlphaFixed = fixAlphaChannel(rect);

   923 

   924         QImage::Format format;

   925         if ((partIsTransparent && !wasAlphaSwapped) || (!partIsTransparent && hasAlpha)) {

   926             format = QImage::Format_ARGB32_Premultiplied;

   927             alphaType = RealAlpha;

   928         } else if (wasAlphaSwapped) {

   929             format = QImage::Format_ARGB32_Premultiplied;

   930             alphaType = MaskAlpha;

   931         } else {

   932             format = QImage::Format_RGB32;

   933             // The image data we got from the theme engine does not have any transparency,

   934             // thus the alpha channel is set to 0.

   935             // However, Format_RGB32 requires the alpha part to be set to 0xff, thus

   936             // we must flip it from 0x00 to 0xff

   937             swapAlphaChannel(rect, true);

   938             alphaType = NoAlpha;

   939         }

   940 #if defined(DEBUG_XP_STYLE) && 1

   941         printf("Image format is: %s\n", alphaType == RealAlpha ? "Real Alpha" : alphaType == MaskAlpha ? "Masked Alpha" : "No Alpha");

   942 #endif

   943         img = QImage(bufferPixels, bufferW, bufferH, format);

   944     }

   945 

   946     // Blitting backing store

   947     bool useRegion = partIsTransparent && !hasAlpha && !wasAlphaSwapped;

   948 

   949     QRegion newRegion;

   950     QRegion oldRegion;

   951     if (useRegion) {

   952         newRegion = region(themeData);

   953         oldRegion = painter->clipRegion();

   954         painter->setClipRegion(newRegion);

   955 #if defined(DEBUG_XP_STYLE) && 0

   956         printf("Using region:\n");

   957         QVector<QRect> rects = newRegion.rects();

   958         for (int i = 0; i < rects.count(); ++i) {

   959             const QRect &r = rects.at(i);

   960             printf("    (%d, %d, %d, %d)\n", r.x(), r.y(), r.right(), r.bottom());

   961         }

   962 #endif

   963     }

   964 

   965     if (addBorderContentClipping)

   966         painter->setClipRegion(extraClip, Qt::IntersectClip);

   967 

   968     if (!themeData.mirrorHorizontally && !themeData.mirrorVertically && !themeData.rotate) {

   969         if (!haveCachedPixmap)

   970             painter->drawImage(themeData.rect, img, rect);

   971         else

   972             painter->drawPixmap(themeData.rect, cachedPixmap);

   973     } else {

   974         // This is _slow_!

   975         // Make a copy containing only the necessary data, and mirror

   976         // on all wanted axes. Then draw the copy.

   977         // If cached, the normal pixmap is cached, instead of caching

   978         // all possible orientations for each part and state.

   979         QImage imgCopy;

   980         if (!haveCachedPixmap)

   981             imgCopy = img.copy(rect);

   982         else

   983             imgCopy = cachedPixmap.toImage();

   984 

   985         if (themeData.rotate) {

   986             QMatrix rotMatrix;

   987             rotMatrix.rotate(themeData.rotate);

   988             imgCopy = imgCopy.transformed(rotMatrix);

   989         }

   990         if (themeData.mirrorHorizontally || themeData.mirrorVertically) {

   991             imgCopy = imgCopy.mirrored(themeData.mirrorHorizontally, themeData.mirrorVertically);

   992         }

   993         painter->drawImage(themeData.rect,

   994                            imgCopy);

   995     }

   996 

   997     if (useRegion || addBorderContentClipping) {

   998         if (oldRegion.isEmpty())

   999             painter->setClipping(false);

  1000         else

  1001             painter->setClipRegion(oldRegion);

  1002     }

  1003 

  1004     // Cache the pixmap to avoid expensive swapAlphaChannel() calls

  1005     if (!haveCachedPixmap && w && h) {

  1006         QPixmap pix = QPixmap::fromImage(img).copy(rect);

  1007         QPixmapCache::insert(pixmapCacheKey, pix);

  1008 #ifdef DEBUG_XP_STYLE

  1009         printf("+++Adding pixmap to cache, size(%d, %d), wasAlphaSwapped(%d), wasAlphaFixed(%d), name(%s)\n",

  1010                w, h, wasAlphaSwapped, wasAlphaFixed, qPrintable(pixmapCacheKey));

  1011 #endif

  1012     }

  1013 

  1014     // Add to theme part cache

  1015     if (!isCached) {

  1016         memset(&data, 0, sizeof(data));

  1017         data.dataValid = true;

  1018         data.partIsTransparent = partIsTransparent;

  1019         data.alphaType = alphaType;

  1020         data.hasAlphaChannel = hasAlpha;

  1021         data.hasAnyData = stateHasData;

  1022         data.wasAlphaSwapped = wasAlphaSwapped;

  1023         data.hadInvalidAlpha = wasAlphaFixed;

  1024         alphaCache.insert(key, data);

  1025     }

  1026 }

  1027 

  1028 

  1029 // ------------------------------------------------------------------------------------------------

  1030 

  1031 /*!

  1032     \class QWindowsXPStyle

  1033     \brief The QWindowsXPStyle class provides a Microsoft Windows XP-like look and feel.

  1034 

  1035     \ingroup appearance

  1036 

  1037     \warning This style is only available on the Windows XP platform

  1038     because it makes use of Windows XP's style engine.

  1039 

  1040     Most of the functions are documented in the base classes

  1041     QWindowsStyle, QCommonStyle, and QStyle, but the

  1042     QWindowsXPStyle overloads of drawComplexControl(), drawControl(),

  1043     drawControlMask(), drawPrimitive(), proxy()->subControlRect(), and

  1044     sizeFromContents(), are documented here.

  1045 

  1046     \img qwindowsxpstyle.png

  1047     \sa QMacStyle, QWindowsStyle, QPlastiqueStyle, QCDEStyle, QMotifStyle

  1048 */

  1049 

  1050 /*!

  1051     Constructs a QWindowsStyle

  1052 */

  1053 QWindowsXPStyle::QWindowsXPStyle()

  1054     : QWindowsStyle(*new QWindowsXPStylePrivate)

  1055 {

  1056 }

  1057 

  1058 /*!

  1059     Destroys the style.

  1060 */

  1061 QWindowsXPStyle::~QWindowsXPStyle()

  1062 {

  1063 }

  1064 

  1065 /*! \reimp */

  1066 void QWindowsXPStyle::unpolish(QApplication *app)

  1067 {

  1068     QWindowsStyle::unpolish(app);

  1069 }

  1070 

  1071 /*! \reimp */

  1072 void QWindowsXPStyle::polish(QApplication *app)

  1073 {

  1074     QWindowsStyle::polish(app);

  1075     if (!QWindowsXPStylePrivate::useXP())

  1076         return;

  1077 }

  1078 

  1079 /*! \reimp */

  1080 void QWindowsXPStyle::polish(QWidget *widget)

  1081 {

  1082     QWindowsStyle::polish(widget);

  1083     if (!QWindowsXPStylePrivate::useXP())

  1084         return;

  1085 

  1086     if (qobject_cast<QAbstractButton*>(widget)

  1087         || qobject_cast<QToolButton*>(widget)

  1088         || qobject_cast<QTabBar*>(widget)

  1089 #ifndef QT_NO_COMBOBOX

  1090         || qobject_cast<QComboBox*>(widget)

  1091 #endif // QT_NO_COMBOBOX

  1092         || qobject_cast<QScrollBar*>(widget)

  1093         || qobject_cast<QSlider*>(widget)

  1094         || qobject_cast<QHeaderView*>(widget)

  1095 #ifndef QT_NO_SPINBOX

  1096         || qobject_cast<QAbstractSpinBox*>(widget)

  1097         || qobject_cast<QSpinBox*>(widget)

  1098 #endif // QT_NO_SPINBOX

  1099         || widget->inherits("QWorkspaceChild")

  1100         || widget->inherits("Q3TitleBar"))

  1101         widget->setAttribute(Qt::WA_Hover);

  1102 

  1103 #ifndef QT_NO_RUBBERBAND

  1104     if (qobject_cast<QRubberBand*>(widget)) {

  1105         widget->setWindowOpacity(0.6);

  1106     }

  1107 #endif

  1108     if (qobject_cast<QStackedWidget*>(widget) &&

  1109                qobject_cast<QTabWidget*>(widget->parent()))

  1110         widget->parentWidget()->setAttribute(Qt::WA_ContentsPropagated);

  1111 

  1112     Q_D(QWindowsXPStyle);

  1113     if (!d->hasInitColors) {

  1114         // Get text color for group box labels

  1115         COLORREF cref;

  1116         XPThemeData theme(0, 0, QLatin1String("BUTTON"), 0, 0);

  1117         pGetThemeColor(theme.handle(), BP_GROUPBOX, GBS_NORMAL, TMT_TEXTCOLOR, &cref);

  1118         d->groupBoxTextColor = qRgb(GetRValue(cref), GetGValue(cref), GetBValue(cref));

  1119         pGetThemeColor(theme.handle(), BP_GROUPBOX, GBS_DISABLED, TMT_TEXTCOLOR, &cref);

  1120         d->groupBoxTextColorDisabled = qRgb(GetRValue(cref), GetGValue(cref), GetBValue(cref));

  1121         // Where does this color come from?

  1122         //pGetThemeColor(theme.handle(), TKP_TICS, TSS_NORMAL, TMT_COLOR, &cref);

  1123         d->sliderTickColor = qRgb(165, 162, 148);

  1124         d->hasInitColors = true;

  1125     }

  1126 }

  1127 

  1128 /*! \reimp */

  1129 void QWindowsXPStyle::polish(QPalette &pal)

  1130 {

  1131     QWindowsStyle::polish(pal);

  1132     pal.setBrush(QPalette::AlternateBase, pal.base().color().darker(110));

  1133 }

  1134