QWindowsXPStylePrivate Class Reference

Inheritance diagram for QWindowsXPStylePrivate:

[legend]Collaboration diagram for QWindowsXPStylePrivate:

[legend]List of all members.

---

Detailed Description

Definition at line 317 of file qwindowsxpstyle.cpp.

Public Member Functions
	QWindowsXPStylePrivate ()
	~QWindowsXPStylePrivate ()
void	init (bool force=false)
void	cleanup (bool force=false)
void	cleanupHandleMap ()
const QPixmap *	tabBody (QWidget *widget)
HBITMAP	buffer (int w=0, int h=0)
HDC	bufferHDC ()
bool	isTransparent (XPThemeData &themeData)
QRegion	region (XPThemeData &themeData)
void	setTransparency (QWidget *widget, XPThemeData &themeData)
void	drawBackground (XPThemeData &themeData)
void	drawBackgroundThruNativeBuffer (XPThemeData &themeData)
void	drawBackgroundDirectly (XPThemeData &themeData)
bool	hasAnyData (const QRect &rect)
bool	hasAlphaChannel (const QRect &rect)
bool	fixAlphaChannel (const QRect &rect)
bool	swapAlphaChannel (const QRect &rect)
Static Public Member Functions
static HWND	winId (const QWidget *widget)
static bool	resolveSymbols ()
static bool	useXP (bool update=false)
Public Attributes
QRgb	groupBoxTextColor
QRgb	groupBoxTextColorDisabled
QRgb	sliderTickColor
bool	hasInitColors
QIcon	dockFloat
QIcon	dockClose
Static Public Attributes
static QMap< QString, HTHEME > *	handleMap
Private Attributes
QHash< ThemeMapKey, ThemeMapData >	alphaCache
HDC	bufferDC
HBITMAP	bufferBitmap
HBITMAP	nullBitmap
uchar *	bufferPixels
int	bufferW
int	bufferH
Static Private Attributes
static QAtomic	ref
static bool	use_xp
static QWidget *	limboWidget
static QPixmap *	tabbody

---

Constructor & Destructor Documentation

QWindowsXPStylePrivate::QWindowsXPStylePrivate

(

)

[inline]

Definition at line 321 of file qwindowsxpstyle.cpp.

References init().

        : QWindowsStylePrivate(), hasInitColors(false), bufferDC(0), bufferBitmap(0), nullBitmap(0),
          bufferPixels(0), bufferW(0), bufferH(0)
    { init(); }

Here is the call graph for this function:

QWindowsXPStylePrivate::~QWindowsXPStylePrivate

(

)

[inline]

Definition at line 326 of file qwindowsxpstyle.cpp.

References cleanup().

    { cleanup(); }

Here is the call graph for this function:

---

Member Function Documentation

HWND QWindowsXPStylePrivate::winId

(

const QWidget *

widget

)

[static]

Definition at line 534 of file qwindowsxpstyle.cpp.

References limboWidget, QObject::setObjectName(), QWidget::testAttribute(), Qt::WA_WState_Created, and QWidget::winId().

Referenced by XPThemeData::handle(), setTransparency(), and QWindowsXPStyle::subElementRect().

{
    if (widget && widget->testAttribute(Qt::WA_WState_Created)) {
        return widget->winId();
    }
    if (!limboWidget) {
        limboWidget = new QWidget(0);
        limboWidget->setObjectName(QLatin1String("xp_limbo_widget"));
    }

    return limboWidget->winId();
}

Here is the call graph for this function:

void QWindowsXPStylePrivate::init

(

bool

force = false

)

Definition at line 475 of file qwindowsxpstyle.cpp.

References ref, QBasicAtomic::ref(), and useXP().

Referenced by QWindowsXPStylePrivate().

{
    if (ref.ref() && !force)
        return;
    if (!force) // -1 based atomic refcounting
        ref.ref();

    useXP(true);
}

Here is the call graph for this function:

void QWindowsXPStylePrivate::cleanup

(

bool

force = false

)

Definition at line 488 of file qwindowsxpstyle.cpp.

References bufferBitmap, bufferDC, cleanupHandleMap(), QBasicAtomic::deref(), limboWidget, ref, tabbody, and use_xp.

Referenced by ~QWindowsXPStylePrivate().

{
    if(bufferBitmap)
        DeleteObject(bufferBitmap);
    bufferBitmap = 0;

    if(bufferDC)
        DeleteDC(bufferDC);
    bufferDC = 0;

    if (ref.deref() && !force)
        return;
    if (!force)  // -1 based atomic refcounting
        ref.deref();

    use_xp = false;
    cleanupHandleMap();
    delete limboWidget;
    delete tabbody;
    limboWidget = 0;
    tabbody = 0;
}

Here is the call graph for this function:

void QWindowsXPStylePrivate::cleanupHandleMap

(

)

Definition at line 516 of file qwindowsxpstyle.cpp.

References QMap< Key, T >::begin(), QMap< Key, T >::end(), handleMap, pCloseThemeData, and QMap< Key, T >::value().

Referenced by cleanup().

{
    if (!handleMap)
        return;

    QMap<QString, HTHEME>::Iterator it;
    for (it = handleMap->begin(); it != handleMap->end(); ++it)
        pCloseThemeData(it.value());
    delete handleMap;
    handleMap = 0;
}

Here is the call graph for this function:

const QPixmap * QWindowsXPStylePrivate::tabBody

(

QWidget *

widget

)

Definition at line 552 of file qwindowsxpstyle.cpp.

References QApplication::desktop(), drawBackground(), XPThemeData::handle(), QRect::height(), pGetThemePartSize, qt_win_display_dc(), XPThemeData::rect, QDesktopWidget::screenGeometry(), and tabbody.

{
    if (!tabbody) {
        SIZE sz;
        XPThemeData theme(0, 0, "TAB", TABP_BODY);
        pGetThemePartSize(theme.handle(), qt_win_display_dc(), TABP_BODY, 0, 0, TS_TRUE, &sz);

        tabbody = new QPixmap(sz.cx, QApplication::desktop()->screenGeometry().height());
        QPainter painter(tabbody);
        theme.rect = QRect(0, 0, sz.cx, sz.cy);
        drawBackground(theme);
        // We fill with the last line of the themedata, that
        // way we don't get a tiled pixmap inside big tabs
        QPixmap temp(sz.cx, 1);
        painter.drawPixmap(0, 0, temp, 0, sz.cy-1, -1, -1);
        painter.drawTiledPixmap(0, sz.cy, sz.cx, tabbody->height()-sz.cy, temp);
    }
    return tabbody;
}

Here is the call graph for this function:

HBITMAP QWindowsXPStylePrivate::buffer	(	int	w = 0,
		int	h = 0
	)

Definition at line 619 of file qwindowsxpstyle.cpp.

References bufferBitmap, bufferDC, bufferH, bufferPixels, bufferW, nullBitmap, qDebug(), qErrnoWarning(), qMax(), and qt_win_display_dc().

Referenced by drawBackgroundThruNativeBuffer(), fixAlphaChannel(), hasAlphaChannel(), hasAnyData(), and swapAlphaChannel().

{
    // If we already have a HBITMAP which is of adequate size, just return that
    if (bufferBitmap) {
        if (bufferW >= w && bufferH >= h)
            return bufferBitmap;
        // Not big enough, discard the old one
        if (bufferDC && nullBitmap)
            SelectObject(bufferDC, nullBitmap);
        DeleteObject(bufferBitmap);
        bufferBitmap = 0;
    }

    w = qMax(bufferW, w);
    h = qMax(bufferH, h);

    if (!bufferDC)
        bufferDC = CreateCompatibleDC(qt_win_display_dc());

    // Define the header
    BITMAPINFO bmi;
    memset(&bmi, 0, sizeof(bmi));
    bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth       = w;
    bmi.bmiHeader.biHeight      = -h;
    bmi.bmiHeader.biPlanes      = 1;
    bmi.bmiHeader.biBitCount    = 32;
    bmi.bmiHeader.biCompression = BI_RGB;

    // Create the pixmap
    bufferPixels = 0;
    bufferBitmap = CreateDIBSection(bufferDC, &bmi, DIB_RGB_COLORS, (void **) &bufferPixels, 0, 0);
    GdiFlush();
    nullBitmap = (HBITMAP)SelectObject(bufferDC, bufferBitmap);

    if (!bufferBitmap) {
        qErrnoWarning("QWindowsXPStylePrivate::buffer(w,h), failed to create dibsection");
        bufferW = 0;
        bufferH = 0;
        return 0;
    }
    if (!bufferPixels) {
        qErrnoWarning("QWindowsXPStylePrivate::buffer(w,h), did not allocate pixel data");
        bufferW = 0;
        bufferH = 0;
        return 0;
    }
    bufferW = w;
    bufferH = h;
#ifdef DEBUG_XP_STYLE
    qDebug("Creating new dib section (%d, %d)", w, h);
#endif
    return bufferBitmap;
}

Here is the call graph for this function:

HDC QWindowsXPStylePrivate::bufferHDC

(

)

[inline]

Definition at line 337 of file qwindowsxpstyle.cpp.

References bufferDC.

Referenced by drawBackgroundThruNativeBuffer(), and region().

    { return bufferDC;}

bool QWindowsXPStylePrivate::resolveSymbols

(

)

[static]

Definition at line 576 of file qwindowsxpstyle.cpp.

References pCloseThemeData, pDrawThemeBackground, pDrawThemeBackgroundEx, pGetCurrentThemeName, pGetThemeBackgroundRegion, pGetThemeBool, pGetThemeColor, pGetThemeDocumentationProperty, pGetThemeEnumValue, pGetThemeFilename, pGetThemeFont, pGetThemeInt, pGetThemeIntList, pGetThemeMargins, pGetThemeMetric, pGetThemePartSize, pGetThemePosition, pGetThemePropertyOrigin, pGetThemeRect, pGetThemeString, pIsAppThemed, pIsThemeActive, pIsThemeBackgroundPartiallyTransparent, pOpenThemeData, and QLibrary::resolve().

Referenced by useXP().

{
    static bool tried = false;
    if (!tried) {
        tried = true;
        QLibrary themeLib("uxtheme");
        pIsAppThemed = (PtrIsAppThemed)themeLib.resolve("IsAppThemed");
        if (pIsAppThemed) {
            pIsThemeActive          = (PtrIsThemeActive         )themeLib.resolve("IsThemeActive");
            pGetThemePartSize       = (PtrGetThemePartSize      )themeLib.resolve("GetThemePartSize");
            pOpenThemeData          = (PtrOpenThemeData         )themeLib.resolve("OpenThemeData");
            pCloseThemeData         = (PtrCloseThemeData        )themeLib.resolve("CloseThemeData");
            pDrawThemeBackground    = (PtrDrawThemeBackground   )themeLib.resolve("DrawThemeBackground");
            pDrawThemeBackgroundEx  = (PtrDrawThemeBackgroundEx )themeLib.resolve("DrawThemeBackgroundEx");
            pGetCurrentThemeName    = (PtrGetCurrentThemeName   )themeLib.resolve("GetCurrentThemeName");
            pGetThemeBool           = (PtrGetThemeBool          )themeLib.resolve("GetThemeBool");
            pGetThemeColor          = (PtrGetThemeColor         )themeLib.resolve("GetThemeColor");
            pGetThemeEnumValue      = (PtrGetThemeEnumValue     )themeLib.resolve("GetThemeEnumValue");
            pGetThemeFilename       = (PtrGetThemeFilename      )themeLib.resolve("GetThemeFilename");
            pGetThemeFont           = (PtrGetThemeFont          )themeLib.resolve("GetThemeFont");
            pGetThemeInt            = (PtrGetThemeInt           )themeLib.resolve("GetThemeInt");
            pGetThemeIntList        = (PtrGetThemeIntList       )themeLib.resolve("GetThemeIntList");
            pGetThemeMargins        = (PtrGetThemeMargins       )themeLib.resolve("GetThemeMargins");
            pGetThemeMetric         = (PtrGetThemeMetric        )themeLib.resolve("GetThemeMetric");
            pGetThemePartSize       = (PtrGetThemePartSize      )themeLib.resolve("GetThemePartSize");
            pGetThemePosition       = (PtrGetThemePosition      )themeLib.resolve("GetThemePosition");
            pGetThemePropertyOrigin = (PtrGetThemePropertyOrigin)themeLib.resolve("GetThemePropertyOrigin");
            pGetThemeRect           = (PtrGetThemeRect          )themeLib.resolve("GetThemeRect");
            pGetThemeString         = (PtrGetThemeString        )themeLib.resolve("GetThemeString");
            pGetThemeBackgroundRegion              = (PtrGetThemeBackgroundRegion             )themeLib.resolve("GetThemeBackgroundRegion");
            pGetThemeDocumentationProperty         = (PtrGetThemeDocumentationProperty        )themeLib.resolve("GetThemeDocumentationProperty");
            pIsThemeBackgroundPartiallyTransparent = (PtrIsThemeBackgroundPartiallyTransparent)themeLib.resolve("IsThemeBackgroundPartiallyTransparent");
        }
    }

    return pIsAppThemed != 0;
}

Here is the call graph for this function:

bool QWindowsXPStylePrivate::useXP

(

bool

update = false

)

[inline, static]

Definition at line 464 of file qwindowsxpstyle.cpp.

References QCoreApplication::instance(), pIsAppThemed, pIsThemeActive, resolveSymbols(), and use_xp.

Referenced by QWindowsXPStyle::drawComplexControl(), QWindowsXPStyle::drawControl(), QWindowsXPStyle::drawPrimitive(), XPThemeData::handle(), init(), XPThemeData::isValid(), QWindowsXPStyle::pixelMetric(), QWindowsXPStyle::polish(), QWindowsXPStyle::sizeFromContents(), QWindowsXPStyle::standardIconImplementation(), QWindowsXPStyle::standardPixmap(), QWindowsXPStyle::styleHint(), QWindowsXPStyle::subControlRect(), QWindowsXPStyle::subElementRect(), and QWindowsXPStyle::unpolish().

{
    if (!update)
        return use_xp;
    return (use_xp = resolveSymbols() && pIsThemeActive()
            && (pIsAppThemed() || !QApplication::instance()));
}

Here is the call graph for this function:

bool QWindowsXPStylePrivate::isTransparent

(

XPThemeData &

themeData

)

Definition at line 680 of file qwindowsxpstyle.cpp.

References XPThemeData::handle(), XPThemeData::partId, pIsThemeBackgroundPartiallyTransparent, and XPThemeData::stateId.

Referenced by drawBackgroundThruNativeBuffer().

{
    return pIsThemeBackgroundPartiallyTransparent(themeData.handle(), themeData.partId,
                                                  themeData.stateId);
}

Here is the call graph for this function:

QRegion QWindowsXPStylePrivate::region

(

XPThemeData &

themeData

)

Definition at line 689 of file qwindowsxpstyle.cpp.

References bufferHDC(), XPThemeData::handle(), XPThemeData::partId, pGetThemeBackgroundRegion, XPThemeData::rect, XPThemeData::stateId, and XPThemeData::toRECT().

Referenced by drawBackgroundThruNativeBuffer().

{
    HRGN hRgn = 0;
    RECT rect = themeData.toRECT(themeData.rect);
    if (!SUCCEEDED(pGetThemeBackgroundRegion(themeData.handle(), bufferHDC(), themeData.partId,
                                             themeData.stateId, &rect, &hRgn)))
        return QRegion();

    QRegion rgn = QRegion(0,0,1,1);
    CombineRgn(rgn.handle(), hRgn, 0, RGN_COPY);
    DeleteObject(hRgn);
    return rgn;
}

Here is the call graph for this function:

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

Definition at line 706 of file qwindowsxpstyle.cpp.

References XPThemeData::mask(), and winId().

{
    HRGN hrgn = themeData.mask();
    if (hrgn)
        SetWindowRgn(winId(widget), hrgn, true);
}

Here is the call graph for this function:

void QWindowsXPStylePrivate::drawBackground

(

XPThemeData &

themeData

)

Definition at line 835 of file qwindowsxpstyle.cpp.

References drawBackgroundDirectly(), drawBackgroundThruNativeBuffer(), QRect::isEmpty(), m, QPainter::matrix(), XPThemeData::mirrorHorizontally, XPThemeData::mirrorVertically, QPainter::opacity(), QPainter::paintEngine(), XPThemeData::painter, pDrawThemeBackgroundEx, XPThemeData::rect, QPainter::restore(), XPThemeData::rotate, and QPainter::save().

Referenced by tabBody().

{
    if (themeData.rect.isEmpty())
        return;

    QPainter *painter = themeData.painter;
    Q_ASSERT_X(painter != 0, "QWindowsXPStylePrivate::drawBackground()", "Trying to draw a theme part without a painter");
    if (!painter)
        return;

    painter->save();

    QMatrix m = painter->matrix();
    bool complexXForm = m.m11() != 1.0 || m.m22() != 1.0 || m.m12() != 0.0 || m.m21() != 0.0;

    bool useFallback = painter->paintEngine()->getDC() == 0
                       || painter->opacity() != 1.0
                       || themeData.rotate
                       || complexXForm
                 || themeData.mirrorVertically
                 || (themeData.mirrorHorizontally && pDrawThemeBackgroundEx == 0);
    if (!useFallback)
        drawBackgroundDirectly(themeData);
    else
        drawBackgroundThruNativeBuffer(themeData);

    painter->restore();
}

Here is the call graph for this function:

void QWindowsXPStylePrivate::drawBackgroundThruNativeBuffer

(

XPThemeData &

themeData

)

Definition at line 947 of file qwindowsxpstyle.cpp.

References QRect::adjusted(), alphaCache, area(), QVector< T >::at(), BOOL, QRect::bottom(), buf, buffer(), bufferH, bufferHDC(), bufferPixels, bufferW, QPainter::clipRegion(), QPixmap::copy(), QImage::copy(), QVector< T >::count(), data, QPainter::drawImage(), QPainter::drawPixmap(), DTBG_CLIPRECT, DTBG_OMITBORDER, DTBG_OMITCONTENT, _DTBGOPTS::dwFlags, _DTBGOPTS::dwSize, QPixmapCache::find(), fixAlphaChannel(), QImage::Format_ARGB32_Premultiplied, QImage::Format_RGB32, QPixmap::fromImage(), GT_IMAGEGLYPH, GT_NONE, h, XPThemeData::handle(), hasAlphaChannel(), hasAnyData(), QRect::height(), i, QPixmapCache::insert(), QHash< Key, T >::insert(), Qt::IntersectClip, QRegion::isEmpty(), isTransparent(), key, MaskAlpha, QImage::mirrored(), XPThemeData::mirrorHorizontally, XPThemeData::mirrorVertically, QRect::moveTo(), XPThemeData::name, NoAlpha, XPThemeData::noBorder, XPThemeData::noContent, XPThemeData::painter, XPThemeData::partId, pDrawThemeBackground, pDrawThemeBackgroundEx, pGetThemeBool, pGetThemeColor, pGetThemeEnumValue, pGetThemeInt, pGetThemePropertyOrigin, printf, _DTBGOPTS::rcClip, XPThemeData::rect, QRegion::rects(), region(), QRect::right(), QMatrix::rotate(), XPThemeData::rotate, QPainter::setClipping(), QPainter::setClipRegion(), XPThemeData::stateId, swapAlphaChannel(), TMT_BORDERONLY, TMT_BORDERSIZE, TMT_CAPTIONMARGINS, TMT_GLYPHTYPE, TMT_TRANSPARENTCOLOR, QPixmap::toImage(), XPThemeData::toRECT(), QImage::transformed(), UnknownAlpha, QHash< Key, T >::value(), w, QRect::width(), QRect::x(), and QRect::y().

Referenced by drawBackground().

{
    QPainter *painter = themeData.painter;
    QRect rect = themeData.rect;

    if ((themeData.rotate + 90) % 180 == 0) { // Catch 90,270,etc.. degree flips.
        rect = QRect(0, 0, rect.height(), rect.width());
    }
    rect.moveTo(0,0);
    int partId = themeData.partId;
    int stateId = themeData.stateId;
    int w = rect.width();
    int h = rect.height();

    // Values initialized later, either from cached values, or from function calls
    AlphaChannelType alphaType = UnknownAlpha;
    bool stateHasData = true; // We assume so;
    bool hasAlpha = false;
    bool partIsTransparent;
    bool inspectData;
    bool potentialInvalidAlpha;

    QString pixmapCacheKey = QString("$qt_xp_%1p%2s%3s%4b%5c%6w%7h").arg(themeData.name)
                             .arg(partId).arg(stateId).arg(!themeData.noBorder).arg(!themeData.noContent)
                             .arg(w).arg(h);
    QPixmap cachedPixmap;
    ThemeMapKey key(themeData);
    ThemeMapData data = alphaCache.value(key);

    bool haveCachedPixmap = false;
    bool isCached = data.dataValid;
    if (isCached) {
        if (!(stateHasData = data.hasAnyData))
            return; // Cached NOOP
        inspectData = data.wasAlphaSwapped;
        partIsTransparent = data.partIsTransparent;
        hasAlpha = data.hasAlphaChannel;
        alphaType = data.alphaType;
        potentialInvalidAlpha = data.hadInvalidAlpha;

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

#ifdef DEBUG_XP_STYLE
        char buf[25];
        ::sprintf(buf, "+ Pixmap(%3d, %3d) ]", w, h);
        printf("---[ CACHED %s--------> Name(%-10s) Part(%d) State(%d)\n",
               haveCachedPixmap ? buf : "]-------------------",
               qPrintable(themeData.name), themeData.partId, themeData.stateId);
#endif
    } else {
        // Not cached, so get values from Theme Engine
        BOOL tmt_borderonly = false;
        COLORREF tmt_transparentcolor = 0x0;
        PROPERTYORIGIN proporigin = PO_NOTFOUND;
        pGetThemeBool(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERONLY, &tmt_borderonly);
        pGetThemeColor(themeData.handle(), themeData.partId, themeData.stateId, TMT_TRANSPARENTCOLOR, &tmt_transparentcolor);
        pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_CAPTIONMARGINS, &proporigin);
        inspectData = (tmt_transparentcolor != 0 || tmt_borderonly || proporigin == PO_PART || proporigin == PO_STATE);
        partIsTransparent = isTransparent(themeData);

        potentialInvalidAlpha = false;
        pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_GLYPHTYPE, &proporigin);
        if (proporigin == PO_PART || proporigin == PO_STATE) {
            int tmt_glyphtype = GT_NONE;
            pGetThemeEnumValue(themeData.handle(), themeData.partId, themeData.stateId, TMT_GLYPHTYPE, &tmt_glyphtype);
            potentialInvalidAlpha = partIsTransparent && !inspectData && tmt_glyphtype == GT_IMAGEGLYPH;
        }

#ifdef DEBUG_XP_STYLE
        printf("---[ NOT CACHED ]-----------------------> Name(%-10s) Part(%d) State(%d)\n",
               qPrintable(themeData.name), themeData.partId, themeData.stateId);
        printf("-->partIsTransparen      = %d\n", partIsTransparent);
        printf("-->inspectData           = %d\n", inspectData);
        printf("-->potentialInvalidAlpha = %d\n", potentialInvalidAlpha);
        showProperties(themeData);
#endif
    }
    bool wasAlphaSwapped = false;
    bool wasAlphaFixed = false;

    // OLD PSDK Workaround ------------------------------------------------------------------------
    // See if we need extra clipping for the older PSDK, which does
    // not have a DrawThemeBackgroundEx function for DTGB_OMITBORDER
    // and DTGB_OMITCONTENT
    bool addBorderContentClipping = false;
    QRegion extraClip;
    QRect area = rect;
    if (themeData.noBorder || themeData.noContent) {
  extraClip = area;
  // We are running on a system where the uxtheme.dll does not have
  // the DrawThemeBackgroundEx function, so we need to clip away
  // borders or contents manually.

  int borderSize = 0;
  PROPERTYORIGIN origin = PO_NOTFOUND;
  pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &origin);
  pGetThemeInt(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &borderSize);

  // Clip away border region
  if ((origin == PO_CLASS || origin == PO_PART || origin == PO_STATE) && borderSize > 0) {
      if (themeData.noBorder) {
    extraClip &= area;
    area = area.adjusted(-borderSize, -borderSize, borderSize, borderSize);
      }

      // Clip away content region
      if (themeData.noContent) {
    QRegion content = area.adjusted(borderSize, borderSize, -borderSize, -borderSize);
    extraClip ^= content;
      }
  }
  addBorderContentClipping = (themeData.noBorder | themeData.noContent);
    }

    QImage img;
    if (!haveCachedPixmap) { // If the pixmap is not cached, generate it! -------------------------
        buffer(w, h); // Ensure a buffer of at least (w, h) in size
        HDC dc = bufferHDC();

        // Clear the buffer
        if (alphaType != NoAlpha) {
            // Consider have separate "memset" function for small chunks for more speedup
            memset(bufferPixels, inspectData ? 0xFF : 0x00, bufferW * h * 4);
        }

  // Difference between area and rect
  int dx = area.x() - rect.x();
  int dy = area.y() - rect.y();
  int dr = area.right() - rect.right();
  int db = area.bottom() - rect.bottom();

  // Adjust so painting rect starts from Origo
  rect.moveTo(0,0);
        area.moveTo(dx,dy);
  DTBGOPTS drawOptions;
        drawOptions.dwSize = sizeof(drawOptions);
        drawOptions.rcClip = themeData.toRECT(rect);
        drawOptions.dwFlags = DTBG_CLIPRECT
                            | (themeData.noBorder ? DTBG_OMITBORDER : 0)
                            | (themeData.noContent ? DTBG_OMITCONTENT : 0);

        // Drawing the part into the backing store
  if (pDrawThemeBackgroundEx != 0) {
            pDrawThemeBackgroundEx(themeData.handle(), dc, themeData.partId, themeData.stateId, &(themeData.toRECT(area)), &drawOptions);
  } else {
      // Set the clip region, if used..
      if (addBorderContentClipping) {
    SelectClipRgn(dc, extraClip.handle());
    // Compensate for the noBorder area difference (noContent has the same area)
    drawOptions.rcClip = themeData.toRECT(rect.adjusted(dx, dy, dr, db));
      }

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

      if (addBorderContentClipping)
    SelectClipRgn(dc, 0);
  }

        // If not cached, analyze the buffer data to figure
        // out alpha type, and if it contains data
        if (!isCached) {
            if (inspectData)
                stateHasData = hasAnyData(rect);
            // SHORTCUT: If the part's state has no data, cache it for NOOP later
            if (!stateHasData) {
                memset(&data, 0, sizeof(data));
                data.dataValid = true;
                alphaCache.insert(key, data);
                return;
            }
            hasAlpha = hasAlphaChannel(rect);
#if defined(DEBUG_XP_STYLE) && 1
            dumpNativeDIB(w, h);
#endif
        }

        // Swap alpha values, if needed
        if (inspectData)
            wasAlphaSwapped = swapAlphaChannel(rect);

        // Fix alpha values, if needed
        if (potentialInvalidAlpha)
            wasAlphaFixed = fixAlphaChannel(rect);

        QImage::Format format;
        if ((partIsTransparent && !wasAlphaSwapped) || (!partIsTransparent && hasAlpha)) {
            format = QImage::Format_ARGB32_Premultiplied;
            alphaType = RealAlpha;
        } else if (wasAlphaSwapped) {
            format = QImage::Format_ARGB32_Premultiplied;
            alphaType = MaskAlpha;
        } else {
            format = QImage::Format_RGB32;
            alphaType = NoAlpha;
        }
#if defined(DEBUG_XP_STYLE) && 1
        printf("Image format is: %s\n", alphaType == RealAlpha ? "Real Alpha" : alphaType == MaskAlpha ? "Masked Alpha" : "No Alpha");
#endif
        img = QImage(bufferPixels, bufferW, bufferH, format);
    }

    // Blitting backing store
    bool useRegion = partIsTransparent && !hasAlpha && !wasAlphaSwapped;

    QRegion newRegion;
    QRegion oldRegion;
    if (useRegion) {
        newRegion = region(themeData);
        oldRegion = painter->clipRegion();
        painter->setClipRegion(newRegion);
#if defined(DEBUG_XP_STYLE) && 0
        printf("Using region:\n");
        QVector<QRect> rects = newRegion.rects();
        for (int i = 0; i < rects.count(); ++i) {
            const QRect &r = rects.at(i);
            printf("    (%d, %d, %d, %d)\n", r.x(), r.y(), r.right(), r.bottom());
        }
#endif
    }

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

    if (!themeData.mirrorHorizontally && !themeData.mirrorVertically && !themeData.rotate) {
        if (!haveCachedPixmap)
            painter->drawImage(themeData.rect, img, rect);
        else
            painter->drawPixmap(themeData.rect, cachedPixmap);
    } else {
        // This is _slow_!
        // Make a copy containing only the necessary data, and mirror
        // on all wanted axes. Then draw the copy.
        // If cached, the normal pixmap is cached, instead of caching
        // all possible orientations for each part and state.
        QImage imgCopy;
        if (!haveCachedPixmap)
            imgCopy = img.copy(rect);
        else
            imgCopy = cachedPixmap.toImage();

        if (themeData.rotate) {
            QMatrix rotMatrix;
            rotMatrix.rotate(themeData.rotate);
            imgCopy = imgCopy.transformed(rotMatrix);
        }
        if (themeData.mirrorHorizontally || themeData.mirrorVertically) {
            imgCopy = imgCopy.mirrored(themeData.mirrorHorizontally, themeData.mirrorVertically);
        }
        painter->drawImage(themeData.rect,
                           imgCopy);
    }

    if (useRegion || addBorderContentClipping) {
        if (oldRegion.isEmpty())
            painter->setClipping(false);
        else
            painter->setClipRegion(oldRegion);
    }

    // Cache the pixmap to avoid expensive swapAlphaChannel() calls
    if (!haveCachedPixmap && ((w * h) < 2000) && w && h) {
        QPixmap pix = QPixmap::fromImage(img).copy(rect);
        QPixmapCache::insert(pixmapCacheKey, pix);
#ifdef DEBUG_XP_STYLE
        printf("+++Adding pixmap to cache, size(%d, %d), wasAlphaSwapped(%d), wasAlphaFixed(%d), name(%s)\n",
               w, h, wasAlphaSwapped, wasAlphaFixed, qPrintable(pixmapCacheKey));
#endif
    }

    // Add to theme part cache
    if (!isCached) {
        memset(&data, 0, sizeof(data));
        data.dataValid = true;
        data.partIsTransparent = partIsTransparent;
        data.alphaType = alphaType;
        data.hasAlphaChannel = hasAlpha;
        data.hasAnyData = stateHasData;
        data.wasAlphaSwapped = wasAlphaSwapped;
        data.hadInvalidAlpha = wasAlphaFixed;
        alphaCache.insert(key, data);
    }
}

Here is the call graph for this function:

void QWindowsXPStylePrivate::drawBackgroundDirectly

(

XPThemeData &

themeData

)

Definition at line 869 of file qwindowsxpstyle.cpp.

References area(), QRegion::boundingRect(), QPainter::clipRegion(), QPainter::deviceMatrix(), DTBG_CLIPRECT, DTBG_MIRRORDC, DTBG_OMITBORDER, DTBG_OMITCONTENT, _DTBGOPTS::dwFlags, _DTBGOPTS::dwSize, QMatrix::dx(), QMatrix::dy(), XPThemeData::handle(), QPainter::hasClipping(), QRegion::isEmpty(), XPThemeData::mirrorHorizontally, XPThemeData::name, XPThemeData::noBorder, XPThemeData::noContent, QPainter::paintEngine(), XPThemeData::painter, XPThemeData::partId, pDrawThemeBackground, pDrawThemeBackgroundEx, pGetThemeInt, pGetThemePropertyOrigin, printf, _DTBGOPTS::rcClip, XPThemeData::rect, XPThemeData::stateId, QPaintEngine::systemClip(), TMT_BORDERSIZE, XPThemeData::toRECT(), QRegion::translated(), and QRect::translated().

Referenced by drawBackground().

{
    QPainter *painter = themeData.painter;
    HDC dc = painter->paintEngine()->getDC();

    QPoint redirectionDelta(int(painter->deviceMatrix().dx()),
                            int(painter->deviceMatrix().dy()));
    QRect area = themeData.rect.translated(redirectionDelta);

    QRegion sysRgn = painter->paintEngine()->systemClip();
    if (sysRgn.isEmpty())
        sysRgn = area;
    else
        sysRgn &= area;
    if (painter->hasClipping())
        sysRgn &= painter->clipRegion().translated(redirectionDelta);
    SelectClipRgn(dc, sysRgn.handle());

#ifdef DEBUG_XP_STYLE
        printf("---[ DIRECT PAINTING ]------------------> Name(%-10s) Part(%d) State(%d)\n",
               qPrintable(themeData.name), themeData.partId, themeData.stateId);
        showProperties(themeData);
#endif

    RECT drawRECT = themeData.toRECT(area);
    DTBGOPTS drawOptions;
    drawOptions.dwSize = sizeof(drawOptions);
    drawOptions.rcClip = themeData.toRECT(sysRgn.boundingRect());
    drawOptions.dwFlags = DTBG_CLIPRECT
                          | (themeData.noBorder ? DTBG_OMITBORDER : 0)
                          | (themeData.noContent ? DTBG_OMITCONTENT : 0)
                          | (themeData.mirrorHorizontally ? DTBG_MIRRORDC : 0);

    if (pDrawThemeBackgroundEx != 0) {
        pDrawThemeBackgroundEx(themeData.handle(), dc, themeData.partId, themeData.stateId, &(drawRECT), &drawOptions);
    } else {
  // We are running on a system where the uxtheme.dll does not have
  // the DrawThemeBackgroundEx function, so we need to clip away
  // borders or contents manually. All flips and mirrors uses the
  // fallback implementation

  int borderSize = 0;
  PROPERTYORIGIN origin = PO_NOTFOUND;
  pGetThemePropertyOrigin(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &origin);
        pGetThemeInt(themeData.handle(), themeData.partId, themeData.stateId, TMT_BORDERSIZE, &borderSize);

  // Clip away border region
        QRegion extraClip = sysRgn;
  if ((origin == PO_CLASS || origin == PO_PART || origin == PO_STATE) && borderSize > 0) {
      if (themeData.noBorder) {
    // extraClip &= area is already done
    drawRECT = themeData.toRECT(area.adjusted(-borderSize, -borderSize, borderSize, borderSize));
      }

      // Clip away content region
      if (themeData.noContent) {
    QRegion content = area.adjusted(borderSize, borderSize, -borderSize, -borderSize);
    extraClip ^= content;
      }

      // Set the clip region, if used..
      if (themeData.noBorder || themeData.noContent)
    SelectClipRgn(dc, extraClip.handle());
        }

  pDrawThemeBackground(themeData.handle(), dc, themeData.partId, themeData.stateId, &(drawRECT), &(drawOptions.rcClip));
    }
    SelectClipRgn(dc, 0);
}

Here is the call graph for this function:

bool QWindowsXPStylePrivate::hasAnyData

(

const QRect &

rect

)

Definition at line 719 of file qwindowsxpstyle.cpp.

References alpha, buffer(), bufferPixels, bufferW, h, QRect::height(), QRect::left(), QRect::top(), w, QRect::width(), x, and y.

Referenced by drawBackgroundThruNativeBuffer().

{
    const int startX = rect.left();
    const int startY = rect.top();
    const int w = rect.width();
    const int h = rect.height();

    for (int y = startY; y < h; ++y) {
        register DWORD *buffer = (DWORD*)bufferPixels + (y * bufferW);
        for (int x = startX; x < w; ++x, ++buffer) {
            int alpha = (*buffer) >> 24;
            if (alpha != 0xFF) // buffer has been touched
                return true;
        }
    }
    return false;
}

Here is the call graph for this function:

bool QWindowsXPStylePrivate::hasAlphaChannel

(

const QRect &

rect

)

Definition at line 741 of file qwindowsxpstyle.cpp.

References alpha, buffer(), bufferPixels, bufferW, h, QRect::height(), QRect::left(), QRect::top(), w, QRect::width(), x, and y.

Referenced by drawBackgroundThruNativeBuffer().

{
    const int startX = rect.left();
    const int startY = rect.top();
    const int w = rect.width();
    const int h = rect.height();

    int firstAlpha = -1;
    for (int y = startY; y < h/2; ++y) {
        register DWORD *buffer = (DWORD*)bufferPixels + (y * bufferW);
        for (int x = startX; x < w; ++x, ++buffer) {
            int alpha = (*buffer) >> 24;
            if (firstAlpha == -1)
                firstAlpha = alpha;
            else if (alpha != firstAlpha)
                return true;
        }
    }
    return false;
}

Here is the call graph for this function:

bool QWindowsXPStylePrivate::fixAlphaChannel

(

const QRect &

rect

)

Definition at line 770 of file qwindowsxpstyle.cpp.

References alpha, buffer(), bufferPixels, bufferW, h, QRect::height(), QRect::left(), qAlpha(), qBlue(), qGreen(), qRed(), QRect::top(), w, QRect::width(), x, and y.

Referenced by drawBackgroundThruNativeBuffer().

{
    const int startX = rect.left();
    const int startY = rect.top();
    const int w = rect.width();
    const int h = rect.height();
    bool hasFixedAlphaValue = false;

    for (int y = startY; y < h; ++y) {
        register DWORD *buffer = (DWORD*)bufferPixels + (y * bufferW);
        for (register int x = startX; x < w; ++x, ++buffer) {
            uint pixel = *buffer;
            int alpha = qAlpha(pixel);
            if (qRed(pixel) > alpha || qGreen(pixel) > alpha || qBlue(pixel) > alpha) {
                *buffer |= 0xff000000;
                hasFixedAlphaValue = true;
            }
        }
    }
    return hasFixedAlphaValue;
}

Here is the call graph for this function:

bool QWindowsXPStylePrivate::swapAlphaChannel

(

const QRect &

rect

)

Definition at line 801 of file qwindowsxpstyle.cpp.

References buffer(), bufferPixels, bufferW, h, QRect::height(), QRect::left(), QRect::top(), w, QRect::width(), x, and y.

Referenced by drawBackgroundThruNativeBuffer().

{
    const int startX = rect.left();
    const int startY = rect.top();
    const int w = rect.width();
    const int h = rect.height();
    bool valueChange = false;

    // Flip the alphas, so that 255-alpha pixels are 0, and 0-alpha are 255.
    for (int y = startY; y < h; ++y) {
        register DWORD *buffer = (DWORD*)bufferPixels + (y * bufferW);
        for (register int x = startX; x < w; ++x, ++buffer) {
            register unsigned int alphaValue = (*buffer) & 0xFF000000;
            if (alphaValue == 0xFF000000) {
                *buffer &= 0x00FFFFFF;
                valueChange = true;
            } else if (alphaValue == 0) {
                *buffer |= 0xFF000000;
                valueChange = true;
            }
        }
    }
    return valueChange;
}

Here is the call graph for this function:

---

Member Data Documentation

QRgb QWindowsXPStylePrivate::groupBoxTextColor

Definition at line 356 of file qwindowsxpstyle.cpp.

QRgb QWindowsXPStylePrivate::groupBoxTextColorDisabled

Definition at line 357 of file qwindowsxpstyle.cpp.

QRgb QWindowsXPStylePrivate::sliderTickColor

Definition at line 358 of file qwindowsxpstyle.cpp.

bool QWindowsXPStylePrivate::hasInitColors

Definition at line 359 of file qwindowsxpstyle.cpp.

QMap< QString, HTHEME > * QWindowsXPStylePrivate::handleMap [static]

Definition at line 361 of file qwindowsxpstyle.cpp.

Referenced by cleanupHandleMap(), and XPThemeData::handle().

QIcon QWindowsXPStylePrivate::dockFloat

Definition at line 363 of file qwindowsxpstyle.cpp.

QIcon QWindowsXPStylePrivate::dockClose

Definition at line 363 of file qwindowsxpstyle.cpp.

QAtomic QWindowsXPStylePrivate::ref [static, private]

Definition at line 371 of file qwindowsxpstyle.cpp.

Referenced by cleanup(), and init().

bool QWindowsXPStylePrivate::use_xp [static, private]

Definition at line 372 of file qwindowsxpstyle.cpp.

Referenced by cleanup(), and useXP().

QWidget * QWindowsXPStylePrivate::limboWidget [static, private]

Definition at line 373 of file qwindowsxpstyle.cpp.

Referenced by cleanup(), and winId().

QPixmap * QWindowsXPStylePrivate::tabbody [static, private]

Definition at line 374 of file qwindowsxpstyle.cpp.

Referenced by cleanup(), and tabBody().

QHash<ThemeMapKey, ThemeMapData> QWindowsXPStylePrivate::alphaCache [private]

Definition at line 376 of file qwindowsxpstyle.cpp.

Referenced by drawBackgroundThruNativeBuffer().

HDC QWindowsXPStylePrivate::bufferDC [private]

Definition at line 377 of file qwindowsxpstyle.cpp.

Referenced by buffer(), bufferHDC(), and cleanup().

HBITMAP QWindowsXPStylePrivate::bufferBitmap [private]

Definition at line 378 of file qwindowsxpstyle.cpp.

Referenced by buffer(), and cleanup().

HBITMAP QWindowsXPStylePrivate::nullBitmap [private]

Definition at line 379 of file qwindowsxpstyle.cpp.

Referenced by buffer().

uchar* QWindowsXPStylePrivate::bufferPixels [private]

Definition at line 380 of file qwindowsxpstyle.cpp.

Referenced by buffer(), drawBackgroundThruNativeBuffer(), fixAlphaChannel(), hasAlphaChannel(), hasAnyData(), and swapAlphaChannel().

int QWindowsXPStylePrivate::bufferW [private]

Definition at line 381 of file qwindowsxpstyle.cpp.

Referenced by buffer(), drawBackgroundThruNativeBuffer(), fixAlphaChannel(), hasAlphaChannel(), hasAnyData(), and swapAlphaChannel().

int QWindowsXPStylePrivate::bufferH [private]

Definition at line 381 of file qwindowsxpstyle.cpp.

Referenced by buffer(), and drawBackgroundThruNativeBuffer().

---

The documentation for this class was generated from the following file:

• src/gui/styles/qwindowsxpstyle.cpp

---