QWindowsXPStylePrivate Class Reference

#include <qwindowsxpstyle_p.h>

Inheritance diagram for QWindowsXPStylePrivate:

Public Functions
HBITMAP	buffer (int w=0, int h=0)
	Returns a native buffer (DIB section) of at least the size of ( x , y ). More...
HDC	bufferHDC ()
void	cleanup (bool force=false)
void	cleanupHandleMap ()
void	drawBackground (XPThemeData &themeData)
	Main theme drawing function. More...
void	drawBackgroundDirectly (XPThemeData &themeData)
	This function draws the theme parts directly to the paintengines HDC. More...
void	drawBackgroundThruNativeBuffer (XPThemeData &themeData)
	This function uses a secondary Native doublebuffer for painting parts. More...
bool	fixAlphaChannel (const QRect &rect)
	When the theme engine paints both a true alpha pixmap and a glyph into our buffer, the glyph might not contain a proper alpha value. More...
bool	hasAlphaChannel (const QRect &rect)
	Returns true if the native doublebuffer contains pixels with varying alpha value. More...
bool	hasAnyData (const QRect &rect)
	Returns true if the native doublebuffer contains a pixel which has a non-0xFF alpha value. More...
void	init (bool force=false)
bool	isTransparent (XPThemeData &themeData)
	Returns true if the part contains any transparency at all. More...
	QWindowsXPStylePrivate ()
QRegion	region (XPThemeData &themeData)
void	setTransparency (QWidget *widget, XPThemeData &themeData)
	Sets the parts region on a window. More...
bool	swapAlphaChannel (const QRect &rect, bool allPixels=false)
	Swaps the alpha values on certain pixels: 0xFF?????? -> 0x00?????? 0x00?????? -> 0xFF?????? Used to determin the mask of a non-alpha transparent pixmap in the native doublebuffer, and swap the alphas so we may paint the image as a Premultiplied QImage with drawImage(), and obtain the mask transparency. More...
const QPixmap *	tabBody (QWidget *widget)
	Returns the pointer to a tab widgets body pixmap, scaled to the height of the screen. More...
	~QWindowsXPStylePrivate ()
Public Functions inherited from QWindowsStylePrivate
bool	altDown () const
bool	hasSeenAlt (const QWidget *widget) const
	QWindowsStylePrivate ()
void	startAnimation (QObject *o, QProgressBar *bar)
void	stopAnimation (QObject *o, QProgressBar *bar)
Public Functions inherited from QCommonStylePrivate
bool	isViewItemCached (const QStyleOptionViewItemV4 &option) const
	QCommonStylePrivate ()
void	tabLayout (const QStyleOptionTabV3 *opt, const QWidget *widget, QRect *textRect, QRect *pixmapRect) const
void	viewItemDrawText (QPainter *p, const QStyleOptionViewItemV4 *option, const QRect &rect) const
void	viewItemLayout (const QStyleOptionViewItemV4 *opt, QRect *checkRect, QRect *pixmapRect, QRect *textRect, bool sizehint) const
	Set sizehint to false to layout the elements inside opt->rect. More...
QSize	viewItemSize (const QStyleOptionViewItemV4 *option, int role) const
	~QCommonStylePrivate ()
Public Functions inherited from QStylePrivate
	QStylePrivate ()
Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)
void	addConnection (int signal, Connection *c)
void	cleanConnectionLists ()
void	connectNotify (const char *signal)
void	deleteChildren ()
void	disconnectNotify (const char *signal)
bool	isSender (const QObject *receiver, const char *signal) const
bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...
void	moveToThread_helper ()
	QObjectPrivate (int version=QObjectPrivateVersion)
QObjectList	receiverList (const char *signal) const
QObjectList	senderList () const
void	setParent_helper (QObject *)
void	setThreadData_helper (QThreadData *currentData, QThreadData *targetData)
int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...
virtual	~QObjectPrivate ()
Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Static Public Functions
static bool	isItemViewDelegateLineEdit (const QWidget *widget)
static bool	resolveSymbols ()
	Returns true if all the necessary theme engine symbols were resolved. More...
static bool	useXP (bool update=false)
static HWND	winId (const QWidget *widget)
	This function will always return a valid window handle, and might create a limbo widget to do so. More...
Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)
static QObjectPrivate *	get (QObject *o)
static void	resetCurrentSender (QObject *receiver, Sender *currentSender, Sender *previousSender)
static Sender *	setCurrentSender (QObject *receiver, Sender *sender)
static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Public Variables
QIcon	dockClose
QIcon	dockFloat
QRgb	groupBoxTextColor
QRgb	groupBoxTextColorDisabled
bool	hasInitColors
QRgb	sliderTickColor
Public Variables inherited from QWindowsStylePrivate
QColor	activeCaptionColor
QColor	activeGradientCaptionColor
bool	alt_down
QList< QProgressBar * >	animatedProgressBars
int	animateStep
int	animateTimer
int	animationFps
QColor	inactiveCaptionColor
QColor	inactiveCaptionText
QColor	inactiveGradientCaptionColor
int	menuBarTimer
QList< const QWidget * >	seenAlt
QElapsedTimer	startTime
Public Variables inherited from QCommonStylePrivate
QStyleOptionViewItemV4 *	cachedOption
QRect	checkRect
QRect	decorationRect
QRect	displayRect
QIcon	tabBarcloseButtonIcon
Public Variables inherited from QStylePrivate
int	layoutSpacingIndex
QStyle *	proxyStyle
Public Variables inherited from QObjectPrivate
union {
QObject *   currentChildBeingDeleted
QAbstractDeclarativeData *   declarativeData
};
quint32	connectedSignals [2]
QObjectConnectionListVector *	connectionLists
Sender *	currentSender
QList< QPointer< QObject > >	eventFilters
ExtraData *	extraData
QString	objectName
Connection *	senders
QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount
QThreadData *	threadData
void *	unused
Public Variables inherited from QObjectData
uint	blockSig: 1
QObjectList	children
uint	hasGuards: 1
uint	inEventHandler: 1
uint	inThreadChangeEvent: 1
uint	isWidget: 1
QMetaObject *	metaObject
uint	ownObjectName: 1
QObject *	parent
uint	pendTimer: 1
int	postedEvents
QObject *	q_ptr
uint	receiveChildEvents: 1
uint	sendChildEvents: 1
uint	unused: 22
uint	wasDeleted: 1

Static Public Variables
static QMap< QString, HTHEME > *	handleMap = 0

Properties
QHash< ThemeMapKey, ThemeMapData >	alphaCache
HBITMAP	bufferBitmap
HDC	bufferDC
int	bufferH
uchar *	bufferPixels
int	bufferW
HBITMAP	nullBitmap

Static Private Attributes
static QWidget *	limboWidget = 0
static QBasicAtomicInt	ref = Q_BASIC_ATOMIC_INITIALIZER(-1)
static QPixmap *	tabbody = 0
static bool	use_xp = false

Additional Inherited Members
Public Types inherited from QWindowsStylePrivate
enum	{   windowsItemFrame = 2, windowsSepHeight = 9, windowsItemHMargin = 3, windowsItemVMargin = 2,   windowsArrowHMargin = 6, windowsRightBorder = 15, windowsCheckMarkWidth = 12 }
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject *, QMetaObject::Call, int, void **)

Detailed Description

Definition at line 285 of file qwindowsxpstyle_p.h.

Constructors and Destructors

QWindowsXPStylePrivate()

QWindowsXPStylePrivate::QWindowsXPStylePrivate ( )

inline

Definition at line 289 of file qwindowsxpstyle_p.h.

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

~QWindowsXPStylePrivate()

QWindowsXPStylePrivate::~QWindowsXPStylePrivate ( )

inline

Definition at line 294 of file qwindowsxpstyle_p.h.

    { cleanup(); }

Functions

buffer()

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

Returns a native buffer (DIB section) of at least the size of ( x , y ).

Warning

This function is not part of the public interface. The buffer has a 32 bit depth, to not lose the alpha values on proper alpha-pixmaps.

Definition at line 410 of file qwindowsxpstyle.cpp.

{
    // 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;
}

bufferHDC()

HDC QWindowsXPStylePrivate::bufferHDC ( )

inline

Definition at line 305 of file qwindowsxpstyle_p.h.

    { return bufferDC;}

cleanup()

void QWindowsXPStylePrivate::cleanup

(

bool

force = false

)

Definition at line 242 of file qwindowsxpstyle.cpp.

{
    if(bufferBitmap) {
        if (bufferDC && nullBitmap)
            SelectObject(bufferDC, nullBitmap);
        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();
    if (limboWidget) {
        if (QApplication::closingDown())
            delete limboWidget;
        else
            limboWidget->deleteLater();
    }
    delete tabbody;
    limboWidget = 0;
    tabbody = 0;
}

cleanupHandleMap()

void QWindowsXPStylePrivate::cleanupHandleMap

(

)

Definition at line 278 of file qwindowsxpstyle.cpp.

{
    if (!handleMap)
        return;

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

drawBackground()

void QWindowsXPStylePrivate::drawBackground

(

XPThemeData &

themeData

)

Main theme drawing function.

Warning

This function is not part of the public interface.

Determines the correct lowlevel drawing method depending on several factors. Use drawBackgroundThruNativeBuffer() if:

• Painter does not have an HDC
• Theme part is flipped (mirrored horizontally) else use drawBackgroundDirectly().

Definition at line 660 of file qwindowsxpstyle.cpp.

Referenced by QWindowsVistaStyle::drawComplexControl(), QWindowsXPStyle::drawComplexControl(), QWindowsVistaStyle::drawControl(), QWindowsXPStyle::drawControl(), QWindowsVistaStyle::drawPrimitive(), QWindowsXPStyle::drawPrimitive(), QWindowsXPStyle::standardIconImplementation(), and QWindowsVistaStyle::standardIconImplementation().

{
    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 || !painter->isActive())
        return;

    painter->save();

    bool complexXForm = painter->deviceTransform().type() > QTransform::TxTranslate;

    bool translucentToplevel = false;
    QPaintDevice *pdev = painter->device();
    if (pdev->devType() == QInternal::Widget) {
        QWidget *win = ((QWidget *) pdev)->window();
        translucentToplevel = win->testAttribute(Qt::WA_TranslucentBackground);
    }

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

    if (!useFallback)
        drawBackgroundDirectly(themeData);
    else
        drawBackgroundThruNativeBuffer(themeData);

    painter->restore();
}

drawBackgroundDirectly()

void QWindowsXPStylePrivate::drawBackgroundDirectly

(

XPThemeData &

themeData

)

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

Warning

This function is not part of the public interface.

Do not use this if you need to perform other transformations on the resulting data.

Definition at line 705 of file qwindowsxpstyle.cpp.

{
    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);
}

drawBackgroundThruNativeBuffer()

void QWindowsXPStylePrivate::drawBackgroundThruNativeBuffer

(

XPThemeData &

themeData

)

This function uses a secondary Native doublebuffer for painting parts.

Warning

This function is not part of the public interface.

It should only be used when the painteengine doesn't provide a proper HDC for direct painting (e.g. when doing a grabWidget(), painting to other pixmaps etc), or when special transformations are needed (e.g. flips (horizonal mirroring only, vertical are handled by the theme engine).

Definition at line 786 of file qwindowsxpstyle.cpp.

{
    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::fromLatin1("$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);

        // ### This is a vista-specific workaround for broken alpha in titlebar pixmaps
        if ((QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && (QSysInfo::WindowsVersion & QSysInfo::WV_NT_based))) {
            if (themeData.partId == WP_CAPTION || themeData.partId == WP_SMALLCAPTION)
                inspectData = false;
        }

        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) {
            RECT rect(themeData.toRECT(area));
            pDrawThemeBackgroundEx(themeData.handle(), dc, themeData.partId, themeData.stateId, &rect, &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 (!hasAlpha && partIsTransparent)
                potentialInvalidAlpha = true;
#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;
            // The image data we got from the theme engine does not have any transparency,
            // thus the alpha channel is set to 0.
            // However, Format_RGB32 requires the alpha part to be set to 0xff, thus
            // we must flip it from 0x00 to 0xff
            swapAlphaChannel(rect, true);
            alphaType = NoAlpha;
        }
#if defined(DEBUG_XP_STYLE) && 1
        printf("Image format is: %s\n", alphaType == RealAlpha ? "Real Alpha" : alphaType == MaskAlpha ? "Masked Alpha" : "No Alpha");
#endif
        img = QImage(bufferPixels, bufferW, bufferH, format);
    }

    // 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) {
        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);
    }
}

fixAlphaChannel()

bool QWindowsXPStylePrivate::fixAlphaChannel

(

const QRect &

rect

)

When the theme engine paints both a true alpha pixmap and a glyph into our buffer, the glyph might not contain a proper alpha value.

Warning

This function is not part of the public interface.

The rule of thumb for premultiplied pixmaps is that the color values of a pixel can never be higher than the alpha values, so we use this to our advantage here, and fix all instances where this occures.

Definition at line 585 of file qwindowsxpstyle.cpp.

{
    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;
}

hasAlphaChannel()

bool QWindowsXPStylePrivate::hasAlphaChannel

(

const QRect &

rect

)

Returns true if the native doublebuffer contains pixels with varying alpha value.

Warning

This function is not part of the public interface.

Definition at line 553 of file qwindowsxpstyle.cpp.

{
    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;
}

hasAnyData()

bool QWindowsXPStylePrivate::hasAnyData

(

const QRect &

rect

)

Returns true if the native doublebuffer contains a pixel which has a non-0xFF alpha value.

Warning

This function is not part of the public interface. Should only be use when its guaranteed that data painted into the buffer wasn't a proper alpha pixmap.

Definition at line 528 of file qwindowsxpstyle.cpp.

{
    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;
}

init()

void QWindowsXPStylePrivate::init

(

bool

force = false

)

Definition at line 229 of file qwindowsxpstyle.cpp.

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

    useXP(true);
}

isItemViewDelegateLineEdit()

bool QWindowsXPStylePrivate::isItemViewDelegateLineEdit ( const QWidget *  widget )

static

Definition at line 290 of file qwindowsxpstyle.cpp.

Referenced by QWindowsVistaStyle::drawPrimitive(), and QWindowsXPStyle::drawPrimitive().

{
    if (!widget)
        return false;
    const QWidget *parent1 = widget->parentWidget();
    // Exlude dialogs or other toplevels parented on item views.
    if (!parent1 || parent1->isWindow())
        return false;
    const QWidget *parent2 = parent1->parentWidget();
    return parent2 && widget->inherits("QLineEdit")
        && parent2->inherits("QAbstractItemView");
}

isTransparent()

bool QWindowsXPStylePrivate::isTransparent

(

XPThemeData &

themeData

)

Returns true if the part contains any transparency at all.

Warning

This function is not part of the public interface. This does not indicate what kind of transparency we're dealing with. It can be

• Alpha transparency
• Masked transparency

Definition at line 474 of file qwindowsxpstyle.cpp.

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

region()

QRegion QWindowsXPStylePrivate::region

(

XPThemeData &

themeData

)

Warning

This function is not part of the public interface. Returns a QRegion of the region of the part

Definition at line 484 of file qwindowsxpstyle.cpp.

Referenced by QWindowsVistaStyle::drawComplexControl(), QWindowsXPStyle::drawComplexControl(), QWindowsVistaStyle::styleHint(), and QWindowsXPStyle::styleHint().

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

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

    QRegion region;

    if (success)
        region = qt_region_from_HRGN(dest);

    DeleteObject(hRgn);
    DeleteObject(dest);

    return region;
}

resolveSymbols()

bool QWindowsXPStylePrivate::resolveSymbols ( )

static

Returns true if all the necessary theme engine symbols were resolved.

Warning

This function is not part of the public interface.

Definition at line 364 of file qwindowsxpstyle.cpp.

{
    static bool tried = false;
    if (!tried) {
        QSystemLibrary themeLib(QLatin1String("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");
        }
        tried = true;
    }

    return pIsAppThemed != 0;
}

setTransparency()

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

Sets the parts region on a window.

Warning

This function is not part of the public interface.

Definition at line 512 of file qwindowsxpstyle.cpp.

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

swapAlphaChannel()

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

Swaps the alpha values on certain pixels: 0xFF?????? -> 0x00?????? 0x00?????? -> 0xFF?????? Used to determin the mask of a non-alpha transparent pixmap in the native doublebuffer, and swap the alphas so we may paint the image as a Premultiplied QImage with drawImage(), and obtain the mask transparency.

Warning

This function is not part of the public interface.

Definition at line 619 of file qwindowsxpstyle.cpp.

{
    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) {
            if (allPixels) {
                *buffer |= 0xFF000000;
                continue;
            }
            register unsigned int alphaValue = (*buffer) & 0xFF000000;
            if (alphaValue == 0xFF000000) {
                *buffer = 0;
                valueChange = true;
            } else if (alphaValue == 0) {
                *buffer |= 0xFF000000;
                valueChange = true;
            }
        }
    }
    return valueChange;
}

tabBody()

const QPixmap * QWindowsXPStylePrivate::tabBody

(

QWidget *

widget

)

Returns the pointer to a tab widgets body pixmap, scaled to the height of the screen.

Warning

This function is not part of the public interface. This way the theme engine doesn't need to scale the body for every time we ask for it. (Speed optimization)

Definition at line 337 of file qwindowsxpstyle.cpp.

{
    if (!tabbody) {
        SIZE sz;
        XPThemeData theme(0, 0, QLatin1String("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;
}

useXP()

bool QWindowsXPStylePrivate::useXP ( bool  update = false )

static

Definition at line 218 of file qwindowsxpstyle.cpp.

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

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

winId()

HWND QWindowsXPStylePrivate::winId ( const QWidget *  widget )

static

This function will always return a valid window handle, and might create a limbo widget to do so.

Warning

This function is not part of the public interface.

We often need a window handle to for example open theme data, so this function ensures that we get one.

Definition at line 312 of file qwindowsxpstyle.cpp.

Referenced by XPThemeData::handle(), QWindowsVistaStyle::polish(), and QWindowsVistaStyle::subElementRect().

{
    if (widget && widget->internalWinId())
        return widget->internalWinId();

    if (!limboWidget) {
        limboWidget = new QWidget(0);
        limboWidget->createWinId();
        limboWidget->setObjectName(QLatin1String("xp_limbo_widget"));
        // We don't need this internal widget to appear in QApplication::topLevelWidgets()
        if (QWidgetPrivate::allWidgets)
            QWidgetPrivate::allWidgets->remove(limboWidget);
    }

    return limboWidget->winId();
}

Properties

alphaCache

QHash<ThemeMapKey, ThemeMapData> QWindowsXPStylePrivate::alphaCache

private

Definition at line 346 of file qwindowsxpstyle_p.h.

bufferBitmap

HBITMAP QWindowsXPStylePrivate::bufferBitmap

private

Definition at line 348 of file qwindowsxpstyle_p.h.

bufferDC

HDC QWindowsXPStylePrivate::bufferDC

private

Definition at line 347 of file qwindowsxpstyle_p.h.

bufferH

int QWindowsXPStylePrivate::bufferH

private

Definition at line 351 of file qwindowsxpstyle_p.h.

bufferPixels

uchar* QWindowsXPStylePrivate::bufferPixels

private

Definition at line 350 of file qwindowsxpstyle_p.h.

bufferW

int QWindowsXPStylePrivate::bufferW

private

Definition at line 351 of file qwindowsxpstyle_p.h.

dockClose

QIcon QWindowsXPStylePrivate::dockClose

Definition at line 333 of file qwindowsxpstyle_p.h.

Referenced by QWindowsXPStyle::standardIconImplementation().

dockFloat

QIcon QWindowsXPStylePrivate::dockFloat

Definition at line 333 of file qwindowsxpstyle_p.h.

Referenced by QWindowsXPStyle::standardIconImplementation().

groupBoxTextColor

QRgb QWindowsXPStylePrivate::groupBoxTextColor

Definition at line 326 of file qwindowsxpstyle_p.h.

Referenced by QWindowsXPStyle::styleHint().

groupBoxTextColorDisabled

QRgb QWindowsXPStylePrivate::groupBoxTextColorDisabled

Definition at line 327 of file qwindowsxpstyle_p.h.

Referenced by QWindowsXPStyle::styleHint().

handleMap

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

static

Definition at line 331 of file qwindowsxpstyle_p.h.

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

hasInitColors

bool QWindowsXPStylePrivate::hasInitColors

Definition at line 329 of file qwindowsxpstyle_p.h.

limboWidget

QWidget * QWindowsXPStylePrivate::limboWidget = 0

staticprivate

Definition at line 343 of file qwindowsxpstyle_p.h.

Referenced by XPThemeData::mask().

nullBitmap

HBITMAP QWindowsXPStylePrivate::nullBitmap

private

Definition at line 349 of file qwindowsxpstyle_p.h.

ref

QBasicAtomicInt QWindowsXPStylePrivate::ref = Q_BASIC_ATOMIC_INITIALIZER(-1)

staticprivate

Definition at line 341 of file qwindowsxpstyle_p.h.

Referenced by XPThemeData::mask().

sliderTickColor

QRgb QWindowsXPStylePrivate::sliderTickColor

Definition at line 328 of file qwindowsxpstyle_p.h.

Referenced by QWindowsXPStyle::drawComplexControl().

tabbody

QPixmap * QWindowsXPStylePrivate::tabbody = 0

staticprivate

Definition at line 344 of file qwindowsxpstyle_p.h.

Referenced by XPThemeData::mask().

use_xp

bool QWindowsXPStylePrivate::use_xp = false

staticprivate

Definition at line 342 of file qwindowsxpstyle_p.h.

Referenced by XPThemeData::mask().

---

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

• /src/gui/styles/qwindowsxpstyle_p.h
• /src/gui/styles/qwindowsxpstyle.cpp