Implement DrawThemeBackgroundEx, DrawThemeText, GetThemeTextExtent.

dlls/uxtheme/Makefile.in

@@ -4,6 +4,7 @@ SRCDIR    = @srcdir@
 VPATH     = @srcdir@
 MODULE    = uxtheme.dll
 IMPORTS   = shlwapi user32 gdi32 advapi32 kernel32 ntdll
+DELAYIMPORTS = msimg32
 EXTRALIBS = $(LIBUNICODE)
 
 C_SRCS = \

dlls/uxtheme/draw.c

@@ -20,6 +20,7 @@
 
 #include "config.h"
 
+#include <stdlib.h>
 #include <stdarg.h>
 
 #include "windef.h"
@@ -112,16 +113,640 @@ HRESULT WINAPI DrawThemeBackground(HTHEME hTheme, HDC hdc, int iPartId,
 }
 
 /***********************************************************************
+ *      UXTHEME_SelectImage
+ *
+ * Select the image to use
+ */
+PTHEME_PROPERTY UXTHEME_SelectImage(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, BOOL glyph)
+{
+    PTHEME_PROPERTY tp;
+    int imageselecttype = IST_NONE;
+    int i;
+    int image;
+    if(glyph)
+        image = TMT_GLYPHIMAGEFILE;
+    else
+        image = TMT_IMAGEFILE;
+
+    if((tp=MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, image)))
+        return tp;
+    GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_IMAGESELECTTYPE, &imageselecttype);
+
+    if(imageselecttype == IST_DPI) {
+        int reqdpi = 0;
+        int screendpi = GetDeviceCaps(hdc, LOGPIXELSX);
+        for(i=4; i>=0; i--) {
+            reqdpi = 0;
+            if(SUCCEEDED(GetThemeInt(hTheme, iPartId, iStateId, i + TMT_MINDPI1, &reqdpi))) {
+                if(reqdpi != 0 && screendpi >= reqdpi) {
+                    TRACE("Using %d DPI, image %d\n", reqdpi, i + TMT_IMAGEFILE1);
+                    return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, i + TMT_IMAGEFILE1);
+                }
+            }
+        }
+        /* If an image couldnt be selected, choose the first one */
+        return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, TMT_IMAGEFILE1);
+    }
+    else if(imageselecttype == IST_SIZE) {
+        POINT size = {pRect->right-pRect->left, pRect->bottom-pRect->top};
+        POINT reqsize;
+        for(i=4; i>=0; i--) {
+            if(SUCCEEDED(GetThemePosition(hTheme, iPartId, iStateId, i + TMT_MINSIZE1, &reqsize))) {
+                if(reqsize.x >= size.x && reqsize.y >= size.y) {
+                    TRACE("Using image size %ldx%ld, image %d\n", reqsize.x, reqsize.y, i + TMT_IMAGEFILE1);
+                    return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, i + TMT_IMAGEFILE1);
+                }
+            }
+        }
+        /* If an image couldnt be selected, choose the smallest one */
+        return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, TMT_IMAGEFILE1);
+    }
+    return NULL;
+}
+
+/***********************************************************************
+ *      UXTHEME_LoadImage
+ *
+ * Load image for part/state
+ */
+HRESULT UXTHEME_LoadImage(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, BOOL glyph,
+                          HBITMAP *hBmp, RECT *bmpRect)
+{
+    int imagelayout = IL_VERTICAL;
+    int imagecount = 0;
+    BITMAP bmp;
+    WCHAR szPath[MAX_PATH];
+    PTHEME_PROPERTY tp = UXTHEME_SelectImage(hTheme, hdc, iPartId, iStateId, pRect, glyph);
+    if(!tp) {
+        FIXME("Couldn't determine image for part/state %d/%d, invalid theme?\n", iPartId, iStateId);
+        return E_PROP_ID_UNSUPPORTED;
+    }
+    lstrcpynW(szPath, tp->lpValue, min(tp->dwValueLen+1, sizeof(szPath)/sizeof(szPath[0])));
+    *hBmp = MSSTYLES_LoadBitmap(hdc, hTheme, szPath);
+    if(!*hBmp) {
+        TRACE("Failed to load bitmap %s\n", debugstr_w(szPath));
+        return HRESULT_FROM_WIN32(GetLastError());
+    }
+    
+    GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_IMAGELAYOUT, &imagelayout);
+    GetThemeInt(hTheme, iPartId, iStateId, TMT_IMAGECOUNT, &imagecount);
+
+    GetObjectW(*hBmp, sizeof(bmp), &bmp);
+    if(imagelayout == IL_VERTICAL) {
+        int height = bmp.bmHeight/imagecount;
+        bmpRect->left = 0;
+        bmpRect->right = bmp.bmWidth;
+        bmpRect->top = (min(imagecount, iStateId)-1) * height;
+        bmpRect->bottom = bmpRect->top + height;
+    }
+    else {
+        int width = bmp.bmWidth/imagecount;
+        bmpRect->left = (min(imagecount, iStateId)-1) * width;
+        bmpRect->right = bmpRect->left + width;
+        bmpRect->top = 0;
+        bmpRect->bottom = bmp.bmHeight;
+    }
+    return S_OK;
+}
+
+/***********************************************************************
+ *      UXTHEME_StretchBlt
+ *
+ * Psudo TransparentBlt/StretchBlt
+ */
+static inline BOOL UXTHEME_StretchBlt(HDC hdcDst, int nXOriginDst, int nYOriginDst, int nWidthDst, int nHeightDst,
+                                      HDC hdcSrc, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc,
+                                      BOOL transparent, COLORREF transcolor)
+{
+    if(transparent) {
+        /* Ensure we dont pass any negative values to TransparentBlt */
+        return TransparentBlt(hdcDst, nXOriginDst, nYOriginDst, abs(nWidthDst), abs(nHeightDst),
+                              hdcSrc, nXOriginSrc, nYOriginSrc, abs(nWidthSrc), abs(nHeightSrc),
+                              transcolor);
+    }
+    /* This should be using AlphaBlend */
+    return StretchBlt(hdcDst, nXOriginDst, nYOriginDst, nWidthDst, nHeightDst,
+                        hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,
+                        SRCCOPY);
+}
+
+/***********************************************************************
+ *      UXTHEME_Blt
+ *
+ * Simplify sending same width/height for both source and dest
+ */
+static inline BOOL UXTHEME_Blt(HDC hdcDest, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest,
+                               HDC hdcSrc, int nXOriginSrc, int nYOriginSrc,
+                               BOOL transparent, COLORREF transcolor)
+{
+    return UXTHEME_StretchBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
+                              hdcSrc, nXOriginSrc, nYOriginSrc, nWidthDest, nHeightDest,
+                              transparent, transcolor);
+}
+
+
+/***********************************************************************
+ *      UXTHEME_DrawImageGlyph
+ *
+ * Draw an imagefile glyph
+ */
+HRESULT UXTHEME_DrawImageGlyph(HTHEME hTheme, HDC hdc, int iPartId,
+                               int iStateId, RECT *pRect,
+                               const DTBGOPTS *pOptions)
+{
+    HRESULT hr;
+    HBITMAP bmpSrc = NULL;
+    HDC hdcSrc = NULL;
+    HGDIOBJ oldSrc = NULL;
+    RECT rcSrc;
+    BOOL transparent = FALSE;
+    COLORREF transparentcolor = 0;
+    int valign = VA_CENTER;
+    int halign = HA_CENTER;
+    POINT dstSize;
+    POINT srcSize;
+    POINT topleft;
+
+    hr = UXTHEME_LoadImage(hTheme, hdc, iPartId, iStateId, pRect, TRUE, &bmpSrc, &rcSrc);
+    if(FAILED(hr)) return hr;
+    hdcSrc = CreateCompatibleDC(hdc);
+    if(!hdcSrc) {
+        hr = HRESULT_FROM_WIN32(GetLastError());
+        DeleteObject(bmpSrc);
+        return hr;
+    }
+    oldSrc = SelectObject(hdcSrc, bmpSrc);
+
+    dstSize.x = pRect->right-pRect->left;
+    dstSize.y = pRect->bottom-pRect->top;
+    srcSize.x = rcSrc.right-rcSrc.left;
+    srcSize.y = rcSrc.bottom-rcSrc.top;
+
+    GetThemeBool(hTheme, iPartId, iStateId, TMT_GLYPHTRANSPARENT, &transparent);
+    if(transparent) {
+        if(FAILED(GetThemeColor(hTheme, iPartId, iStateId, TMT_GLYPHTRANSPARENTCOLOR, &transparentcolor))) {
+            /* If image is transparent, but no color was specified, get the color of the upper left corner */
+            transparentcolor = GetPixel(hdcSrc, 0, 0);
+        }
+    }
+    GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_VALIGN, &valign);
+    GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_HALIGN, &halign);
+
+    topleft.x = pRect->left;
+    topleft.y = pRect->top;
+    if(halign == HA_CENTER)      topleft.x += (dstSize.x/2)-(srcSize.x/2);
+    else if(halign == HA_RIGHT)  topleft.x += dstSize.x-srcSize.x;
+    if(valign == VA_CENTER)      topleft.y += (dstSize.y/2)-(srcSize.y/2);
+    else if(valign == VA_BOTTOM) topleft.y += dstSize.y-srcSize.y;
+
+    if(!UXTHEME_Blt(hdc, topleft.x, topleft.y, srcSize.x, srcSize.y,
+                    hdcSrc, rcSrc.left, rcSrc.top,
+                    transparent, transparentcolor)) {
+        hr = HRESULT_FROM_WIN32(GetLastError());
+    }
+
+    SelectObject(hdcSrc, oldSrc);
+    DeleteDC(hdcSrc);
+    DeleteObject(bmpSrc);
+    return hr;
+}
+
+/***********************************************************************
+ *      UXTHEME_DrawImageGlyph
+ *
+ * Draw glyph on top of background, if appropriate
+ */
+HRESULT UXTHEME_DrawGlyph(HTHEME hTheme, HDC hdc, int iPartId,
+                                    int iStateId, RECT *pRect,
+                                    const DTBGOPTS *pOptions)
+{
+    int glyphtype = GT_NONE;
+
+    GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_GLYPHTYPE, &glyphtype);
+
+    if(glyphtype == GT_IMAGEGLYPH) {
+        return UXTHEME_DrawImageGlyph(hTheme, hdc, iPartId, iStateId, pRect, pOptions);
+    }
+    else if(glyphtype == GT_FONTGLYPH) {
+        /* I don't know what a font glyph is, I've never seen it used in any themes */
+        FIXME("Font glyph\n");
+    }
+    return S_OK;
+}
+
+/***********************************************************************
+ *      UXTHEME_DrawImageBackground
+ *
+ * Draw an imagefile background
+ */
+HRESULT UXTHEME_DrawImageBackground(HTHEME hTheme, HDC hdc, int iPartId,
+                                    int iStateId, RECT *pRect,
+                                    const DTBGOPTS *pOptions)
+{
+    HRESULT hr = S_OK;
+    HBITMAP bmpSrc;
+    HGDIOBJ oldSrc;
+    HDC hdcSrc;
+    RECT rcSrc;
+    RECT rcDst;
+    POINT dstSize;
+    POINT srcSize;
+    int sizingtype = ST_TRUESIZE;
+    BOOL uniformsizing = FALSE;
+    BOOL transparent = FALSE;
+    COLORREF transparentcolor = 0;
+
+    hr = UXTHEME_LoadImage(hTheme, hdc, iPartId, iStateId, pRect, FALSE, &bmpSrc, &rcSrc);
+    if(FAILED(hr)) return hr;
+    hdcSrc = CreateCompatibleDC(hdc);
+    if(!hdcSrc) {
+        hr = HRESULT_FROM_WIN32(GetLastError());
+        DeleteObject(bmpSrc);
+        return hr;
+    }
+    oldSrc = SelectObject(hdcSrc, bmpSrc);
+
+    CopyRect(&rcDst, pRect);
+    
+    GetThemeBool(hTheme, iPartId, iStateId, TMT_TRANSPARENT, &transparent);
+    if(transparent) {
+        if(FAILED(GetThemeColor(hTheme, iPartId, iStateId, TMT_TRANSPARENTCOLOR, &transparentcolor))) {
+            /* If image is transparent, but no color was specified, get the color of the upper left corner */
+            transparentcolor = GetPixel(hdcSrc, 0, 0);
+        }
+    }
+
+    dstSize.x = rcDst.right-rcDst.left;
+    dstSize.y = rcDst.bottom-rcDst.top;
+    srcSize.x = rcSrc.right-rcSrc.left;
+    srcSize.y = rcSrc.bottom-rcSrc.top;
+
+    if(uniformsizing) {
+        /* Scale height and width equally */
+        int widthDiff = abs(srcSize.x-dstSize.x);
+        int heightDiff = abs(srcSize.y-dstSize.x);
+        if(widthDiff > heightDiff) {
+            dstSize.y -= widthDiff-heightDiff;
+            rcDst.bottom = rcDst.top + dstSize.y;
+        }
+        else if(heightDiff > widthDiff) {
+            dstSize.x -= heightDiff-widthDiff;
+            rcDst.right = rcDst.left + dstSize.x;
+        }
+    }
+
+    GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_SIZINGTYPE, &sizingtype);
+    if(sizingtype == ST_TRUESIZE) {
+        int truesizestretchmark = 0;
+
+        if(dstSize.x < 0 || dstSize.y < 0) {
+            BOOL mirrorimage = TRUE;
+            GetThemeBool(hTheme, iPartId, iStateId, TMT_MIRRORIMAGE, &mirrorimage);
+            if(mirrorimage) {
+                if(dstSize.x < 0) {
+                    rcDst.left += dstSize.x;
+                    rcDst.right += dstSize.x;
+                }
+                if(dstSize.y < 0) {
+                    rcDst.top += dstSize.y;
+                    rcDst.bottom += dstSize.y;
+                }
+            }
+        }
+        /* Only stretch when target exceeds source by truesizestretchmark percent */
+        GetThemeInt(hTheme, iPartId, iStateId, TMT_TRUESIZESTRETCHMARK, &truesizestretchmark);
+        if(dstSize.x < 0 || dstSize.y < 0 ||
+           MulDiv(srcSize.x, 100, dstSize.x) > truesizestretchmark ||
+           MulDiv(srcSize.y, 100, dstSize.y) > truesizestretchmark) {
+            if(!UXTHEME_StretchBlt(hdc, rcDst.left, rcDst.top, dstSize.x, dstSize.y,
+                                   hdcSrc, rcSrc.left, rcSrc.top, srcSize.x, srcSize.y,
+                                   transparent, transparentcolor))
+                hr = HRESULT_FROM_WIN32(GetLastError());
+        }
+        else {
+            rcDst.left += (dstSize.x/2)-(srcSize.x/2);
+            rcDst.top  += (dstSize.y/2)-(srcSize.y/2);
+            rcDst.right = rcDst.left + srcSize.x;
+            rcDst.bottom = rcDst.top + srcSize.y;
+            if(!UXTHEME_Blt(hdc, rcDst.left, rcDst.top, srcSize.x, srcSize.y,
+                            hdcSrc, rcSrc.left, rcSrc.top,
+                            transparent, transparentcolor))
+                hr = HRESULT_FROM_WIN32(GetLastError());
+        }
+    }
+    else {
+        HDC hdcDst = NULL;
+        HBITMAP bmpDst = NULL;
+        HGDIOBJ oldDst = NULL;
+        MARGINS sm;
+
+        dstSize.x = abs(dstSize.x);
+        dstSize.y = abs(dstSize.y);
+
+        GetThemeMargins(hTheme, hdc, iPartId, iStateId, TMT_SIZINGMARGINS, NULL, &sm);
+
+        hdcDst = CreateCompatibleDC(hdc);
+        if(!hdcDst) {
+            hr = HRESULT_FROM_WIN32(GetLastError());
+            goto draw_error; 
+        }
+        bmpDst = CreateCompatibleBitmap(hdc, dstSize.x, dstSize.y);
+        if(!bmpDst) {
+            hr = HRESULT_FROM_WIN32(GetLastError());
+            goto draw_error; 
+        }
+        oldDst = SelectObject(hdcDst, bmpDst);
+
+        /* Upper left corner */
+        if(!BitBlt(hdcDst, 0, 0, sm.cxLeftWidth, sm.cyTopHeight,
+                   hdcSrc, rcSrc.left, rcSrc.top, SRCCOPY)) {
+            hr = HRESULT_FROM_WIN32(GetLastError());
+            goto draw_error; 
+        }
+        /* Upper right corner */
+        if(!BitBlt(hdcDst, dstSize.x-sm.cxRightWidth, 0, sm.cxRightWidth, sm.cyTopHeight,
+                   hdcSrc, rcSrc.right-sm.cxRightWidth, rcSrc.top, SRCCOPY)) {
+            hr = HRESULT_FROM_WIN32(GetLastError());
+            goto draw_error; 
+        }
+        /* Lower left corner */
+        if(!BitBlt(hdcDst, 0, dstSize.y-sm.cyBottomHeight, sm.cxLeftWidth, sm.cyBottomHeight,
+                   hdcSrc, rcSrc.left, rcSrc.bottom-sm.cyBottomHeight, SRCCOPY)) {
+            hr = HRESULT_FROM_WIN32(GetLastError());
+            goto draw_error; 
+        }
+        /* Lower right corner */
+        if(!BitBlt(hdcDst, dstSize.x-sm.cxRightWidth, dstSize.y-sm.cyBottomHeight, sm.cxRightWidth, sm.cyBottomHeight,
+                   hdcSrc, rcSrc.right-sm.cxRightWidth, rcSrc.bottom-sm.cyBottomHeight, SRCCOPY)) {
+            hr = HRESULT_FROM_WIN32(GetLastError());
+            goto draw_error; 
+        }
+
+        if(sizingtype == ST_TILE) {
+            FIXME("Tile\n");
+            sizingtype = ST_STRETCH; /* Just use stretch for now */
+        }
+        if(sizingtype == ST_STRETCH) {
+            int destCenterWidth  = dstSize.x - (sm.cxLeftWidth + sm.cxRightWidth);
+            int srcCenterWidth   = srcSize.x - (sm.cxLeftWidth + sm.cxRightWidth);
+            int destCenterHeight = dstSize.y - (sm.cyTopHeight + sm.cyBottomHeight);
+            int srcCenterHeight  = srcSize.y - (sm.cyTopHeight + sm.cyBottomHeight);
+
+            if(destCenterWidth > 0) {
+                /* Center top */
+                if(!StretchBlt(hdcDst, sm.cxLeftWidth, 0, destCenterWidth, sm.cyTopHeight,
+                               hdcSrc, rcSrc.left+sm.cxLeftWidth, rcSrc.top, srcCenterWidth, sm.cyTopHeight, SRCCOPY)) {
+                    hr = HRESULT_FROM_WIN32(GetLastError());
+                    goto draw_error; 
+                }
+                /* Center bottom */
+                if(!StretchBlt(hdcDst, sm.cxLeftWidth, dstSize.y-sm.cyBottomHeight, destCenterWidth, sm.cyBottomHeight,
+                               hdcSrc, rcSrc.left+sm.cxLeftWidth, rcSrc.bottom-sm.cyBottomHeight, srcCenterWidth, sm.cyTopHeight, SRCCOPY)) {
+                    hr = HRESULT_FROM_WIN32(GetLastError());
+                    goto draw_error; 
+                }
+            }
+            if(destCenterHeight > 0) {
+                /* Left center */
+                if(!StretchBlt(hdcDst, 0, sm.cyTopHeight, sm.cxLeftWidth, destCenterHeight,
+                           hdcSrc, rcSrc.left, rcSrc.top+sm.cyTopHeight, sm.cxLeftWidth, srcCenterHeight, SRCCOPY)) {
+                    hr = HRESULT_FROM_WIN32(GetLastError());
+                    goto draw_error; 
+                }
+                /* Right center */
+                if(!StretchBlt(hdcDst, dstSize.x-sm.cxRightWidth, sm.cyTopHeight, sm.cxRightWidth, destCenterHeight,
+                               hdcSrc, rcSrc.right-sm.cxRightWidth, rcSrc.top+sm.cyTopHeight, sm.cxRightWidth, srcCenterHeight, SRCCOPY)) {
+                    hr = HRESULT_FROM_WIN32(GetLastError());
+                    goto draw_error; 
+                }
+            }
+            if(destCenterHeight > 0 && destCenterWidth > 0) {
+                BOOL borderonly = FALSE;
+                GetThemeBool(hTheme, iPartId, iStateId, TMT_BORDERONLY, &borderonly);
+                if(!borderonly) {
+                    /* Center */
+                    if(!StretchBlt(hdcDst, sm.cxLeftWidth, sm.cyTopHeight, destCenterWidth, destCenterHeight,
+                                   hdcSrc, rcSrc.left+sm.cxLeftWidth, rcSrc.top+sm.cyTopHeight, srcCenterWidth, srcCenterHeight, SRCCOPY)) {
+                        hr = HRESULT_FROM_WIN32(GetLastError());
+                        goto draw_error; 
+                    }
+                }
+            }
+        }
+
+        if(!UXTHEME_Blt(hdc, rcDst.left, rcDst.top, dstSize.x, dstSize.y,
+                        hdcDst, 0, 0,
+                        transparent, transparentcolor))
+            hr = HRESULT_FROM_WIN32(GetLastError());
+
+draw_error:
+        if(hdcDst) {
+            SelectObject(hdcDst, oldDst);
+            DeleteDC(hdcDst);
+        }
+        if(bmpDst) DeleteObject(bmpDst);
+    }
+    SelectObject(hdcSrc, oldSrc);
+    DeleteObject(bmpSrc);
+    DeleteDC(hdcSrc);
+    CopyRect(pRect, &rcDst);
+    return hr;
+}
+
+/***********************************************************************
+ *      UXTHEME_DrawBorderRectangle
+ *
+ * Draw the bounding rectangle for a borderfill background
+ */
+HRESULT UXTHEME_DrawBorderRectangle(HTHEME hTheme, HDC hdc, int iPartId,
+                                    int iStateId, RECT *pRect,
+                                    const DTBGOPTS *pOptions)
+{
+    HRESULT hr = S_OK;
+    HPEN hPen;
+    HGDIOBJ oldPen;
+    COLORREF bordercolor = RGB(0,0,0);
+    int bordersize = 1;
+
+    GetThemeInt(hTheme, iPartId, iStateId, TMT_BORDERSIZE, &bordersize);
+    if(bordersize > 0) {
+        POINT ptCorners[4];
+        ptCorners[0].x = pRect->left;
+        ptCorners[0].y = pRect->top;
+        ptCorners[1].x = pRect->right;
+        ptCorners[1].y = pRect->top;
+        ptCorners[2].x = pRect->right;
+        ptCorners[2].y = pRect->bottom;
+        ptCorners[3].x = pRect->left;
+        ptCorners[3].y = pRect->bottom;
+
+        InflateRect(pRect, -bordersize, -bordersize);
+        if(pOptions->dwFlags & DTBG_OMITBORDER)
+            return S_OK;
+        GetThemeColor(hTheme, iPartId, iStateId, TMT_BORDERCOLOR, &bordercolor);
+        hPen = CreatePen(PS_SOLID, bordersize, bordercolor);
+        if(!hPen)
+            return HRESULT_FROM_WIN32(GetLastError());
+        oldPen = SelectObject(hdc, hPen);
+
+        if(!Polyline(hdc, ptCorners, 4))
+            hr = HRESULT_FROM_WIN32(GetLastError());
+
+        SelectObject(hdc, oldPen);
+        DeleteObject(hPen);
+    }
+    return hr;
+}
+
+/***********************************************************************
+ *      UXTHEME_DrawBorderRectangle
+ *
+ * Fill a borderfill background rectangle
+ */
+HRESULT UXTHEME_DrawBackgroundFill(HTHEME hTheme, HDC hdc, int iPartId,
+                                   int iStateId, RECT *pRect,
+                                   const DTBGOPTS *pOptions)
+{
+    HRESULT hr = S_OK;
+    int filltype = FT_SOLID;
+
+    TRACE("(%d,%d,%ld)\n", iPartId, iStateId, pOptions->dwFlags);
+
+    if(pOptions->dwFlags & DTBG_OMITCONTENT)
+        return S_OK;
+
+    GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_FILLTYPE, &filltype);
+
+    if(filltype == FT_SOLID) {
+        HBRUSH hBrush;
+        COLORREF fillcolor = RGB(255,255,255);
+        FIXME("Solid\n");
+
+        GetThemeColor(hTheme, iPartId, iStateId, TMT_FILLCOLOR, &fillcolor);
+        hBrush = CreateSolidBrush(fillcolor);
+        if(!FillRect(hdc, pRect, hBrush))
+            hr = HRESULT_FROM_WIN32(GetLastError());
+        DeleteObject(hBrush);
+    }
+    else if(filltype == FT_VERTGRADIENT || filltype == FT_HORZGRADIENT) {
+        /* FIXME: This only accounts for 2 gradient colors (out of 5) and ignores
+            the gradient ratios (no idea how those work)
+            Few themes use this, and the ones I've seen only use 2 colors with
+            a gradient ratio of 0 and 255 respectivly
+        */
+
+        COLORREF gradient1 = RGB(0,0,0);
+        COLORREF gradient2 = RGB(255,255,255);
+        TRIVERTEX vert[2];
+        GRADIENT_RECT gRect;
+
+        FIXME("Gradient\n");
+
+        GetThemeColor(hTheme, iPartId, iStateId, TMT_GRADIENTCOLOR1, &gradient1);
+        GetThemeColor(hTheme, iPartId, iStateId, TMT_GRADIENTCOLOR2, &gradient2);
+
+        vert[0].x     = pRect->left;
+        vert[0].y     = pRect->top;
+        vert[0].Red   = GetRValue(gradient1) << 8;
+        vert[0].Green = GetGValue(gradient1) << 8;
+        vert[0].Blue  = GetBValue(gradient1) << 8;
+        vert[0].Alpha = 0x0000;
+
+        vert[1].x     = pRect->right;
+        vert[1].y     = pRect->bottom;
+        vert[1].Red   = GetRValue(gradient2) << 8;
+        vert[1].Green = GetGValue(gradient2) << 8;
+        vert[1].Blue  = GetBValue(gradient2) << 8;
+        vert[1].Alpha = 0x0000;
+
+        gRect.UpperLeft  = 0;
+        gRect.LowerRight = 1;
+        GradientFill(hdc,vert,2,&gRect,1,filltype==FT_HORZGRADIENT?GRADIENT_FILL_RECT_H:GRADIENT_FILL_RECT_V);
+    }
+    else if(filltype == FT_RADIALGRADIENT) {
+        /* I've never seen this used in a theme */
+        FIXME("Radial gradient\n");
+    }
+    else if(filltype == FT_TILEIMAGE) {
+        /* I've never seen this used in a theme */
+        FIXME("Tile image\n");
+    }
+    return hr;
+}
+
+/***********************************************************************
+ *      UXTHEME_DrawImageBackground
+ *
+ * Draw an imagefile background
+ */
+HRESULT UXTHEME_DrawBorderBackground(HTHEME hTheme, HDC hdc, int iPartId,
+                                     int iStateId, const RECT *pRect,
+                                     const DTBGOPTS *pOptions)
+{
+    HRESULT hr;
+    RECT rt;
+
+    CopyRect(&rt, pRect);
+
+    hr = UXTHEME_DrawBorderRectangle(hTheme, hdc, iPartId, iStateId, &rt, pOptions);
+    if(FAILED(hr))
+        return hr;
+    return UXTHEME_DrawBackgroundFill(hTheme, hdc, iPartId, iStateId, &rt, pOptions);
+}
+
+/***********************************************************************
  *      DrawThemeBackgroundEx                               (UXTHEME.@)
  */
 HRESULT WINAPI DrawThemeBackgroundEx(HTHEME hTheme, HDC hdc, int iPartId,
                                      int iStateId, const RECT *pRect,
                                      const DTBGOPTS *pOptions)
 {
-    FIXME("%d %d: stub\n", iPartId, iStateId);
+    HRESULT hr;
+    const DTBGOPTS defaultOpts = {sizeof(DTBGOPTS), 0, {0,0,0,0}};
+    const DTBGOPTS *opts;
+    HRGN clip = NULL;
+    int hasClip = -1;
+    int bgtype = BT_BORDERFILL;
+    RECT rt;
+
+    TRACE("(%p,%p,%d,%d,%ld,%ld)\n", hTheme, hdc, iPartId, iStateId,pRect->left,pRect->top);
     if(!hTheme)
         return E_HANDLE;
-    return ERROR_CALL_NOT_IMPLEMENTED;
+
+    /* Ensure we have a DTBGOPTS structure available, simplifies some of the code */
+    opts = pOptions;
+    if(!opts) opts = &defaultOpts;
+
+    if(opts->dwFlags & DTBG_CLIPRECT) {
+        clip = CreateRectRgn(0,0,1,1);
+        hasClip = GetClipRgn(hdc, clip);
+        if(hasClip == -1)
+            TRACE("Failed to get original clipping region\n");
+        else
+            IntersectClipRect(hdc, opts->rcClip.left, opts->rcClip.top, opts->rcClip.right, opts->rcClip.bottom);
+    }
+    CopyRect(&rt, pRect);
+
+    GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype);
+    if(bgtype == BT_IMAGEFILE)
+        hr = UXTHEME_DrawImageBackground(hTheme, hdc, iPartId, iStateId, &rt, opts);
+    else if(bgtype == BT_BORDERFILL)
+        hr = UXTHEME_DrawBorderBackground(hTheme, hdc, iPartId, iStateId, pRect, opts);
+    else {
+        FIXME("Unknown background type\n");
+        /* This should never happen, and hence I don't know what to return */
+        hr = E_FAIL;
+    }
+    if(SUCCEEDED(hr))
+        hr = UXTHEME_DrawGlyph(hTheme, hdc, iPartId, iStateId, &rt, opts);
+    if(opts->dwFlags & DTBG_CLIPRECT) {
+        if(hasClip == 0)
+            SelectClipRgn(hdc, NULL);
+        else if(hasClip == 1)
+            SelectClipRgn(hdc, clip);
+        DeleteObject(clip);
+    }
+    return hr;
 }
 
 /***********************************************************************
@@ -156,10 +781,46 @@ HRESULT WINAPI DrawThemeText(HTHEME hTheme, HDC hdc, int iPartId, int iStateId,
                              LPCWSTR pszText, int iCharCount, DWORD dwTextFlags,
                              DWORD dwTextFlags2, const RECT *pRect)
 {
-    FIXME("%d %d: stub\n", iPartId, iStateId);
+    HRESULT hr;
+    HFONT hFont = NULL;
+    HGDIOBJ oldFont = NULL;
+    LOGFONTW logfont;
+    COLORREF textColor;
+    COLORREF oldTextColor;
+    int oldBkMode;
+    RECT rt;
+    
+    TRACE("%d %d: stub\n", iPartId, iStateId);
     if(!hTheme)
         return E_HANDLE;
-    return ERROR_CALL_NOT_IMPLEMENTED;
+    
+    hr = GetThemeFont(hTheme, hdc, iPartId, iStateId, TMT_FONT, &logfont);
+    if(SUCCEEDED(hr)) {
+        hFont = CreateFontIndirectW(&logfont);
+        if(!hFont)
+            TRACE("Failed to create font\n");
+    }
+    CopyRect(&rt, pRect);
+    if(hFont)
+        oldFont = SelectObject(hdc, hFont);
+        
+    if(dwTextFlags2 & DTT_GRAYED)
+        textColor = GetSysColor(COLOR_GRAYTEXT);
+    else {
+        if(FAILED(GetThemeColor(hTheme, iPartId, iStateId, TMT_TEXTCOLOR, &textColor)))
+            textColor = GetTextColor(hdc);
+    }
+    oldTextColor = SetTextColor(hdc, textColor);
+    oldBkMode = SetBkMode(hdc, TRANSPARENT);
+    DrawTextW(hdc, pszText, iCharCount, &rt, dwTextFlags);
+    SetBkMode(hdc, oldBkMode);
+    SetTextColor(hdc, oldTextColor);
+
+    if(hFont) {
+        SelectObject(hdc, oldFont);
+        DeleteObject(hFont);
+    }
+    return S_OK;
 }
 
 /***********************************************************************
@@ -240,6 +901,38 @@ HRESULT WINAPI GetThemeTextExtent(HTHEME hTheme, HDC hdc, int iPartId,
                                   DWORD dwTextFlags, const RECT *pBoundingRect,
                                   RECT *pExtentRect)
 {
+    HRESULT hr;
+    HFONT hFont = NULL;
+    HGDIOBJ oldFont = NULL;
+    LOGFONTW logfont;
+    RECT rt = {0,0,0xFFFF,0xFFFF};
+    
+    TRACE("%d %d: stub\n", iPartId, iStateId);
+    if(!hTheme)
+        return E_HANDLE;
+
+    if(pBoundingRect)
+        CopyRect(&rt, pBoundingRect);
+            
+    hr = GetThemeFont(hTheme, hdc, iPartId, iStateId, TMT_FONT, &logfont);
+    if(SUCCEEDED(hr)) {
+        hFont = CreateFontIndirectW(&logfont);
+        if(!hFont)
+            TRACE("Failed to create font\n");
+    }
+    if(hFont)
+        oldFont = SelectObject(hdc, hFont);
+        
+    DrawTextW(hdc, pszText, iCharCount, &rt, dwTextFlags|DT_CALCRECT);
+    CopyRect(pExtentRect, &rt);
+
+    if(hFont) {
+        SelectObject(hdc, oldFont);
+        DeleteObject(hFont);
+    }
+    return S_OK;
+
+    
     FIXME("%d %d: stub\n", iPartId, iStateId);
     if(!hTheme)
         return E_HANDLE;

dlls/uxtheme/msstyles.c

@@ -765,3 +765,17 @@ PTHEME_PROPERTY MSSTYLES_FindProperty(PTHEME_CLASS tc, int iPartId, int iStateId
         return tp;
     return NULL;
 }
+
+HBITMAP MSSTYLES_LoadBitmap(HDC hdc, PTHEME_CLASS tc, LPCWSTR lpFilename)
+{
+    WCHAR szFile[MAX_PATH];
+    LPWSTR tmp;
+    lstrcpynW(szFile, lpFilename, sizeof(szFile)/sizeof(szFile[0]));
+    tmp = szFile;
+    do {
+        if(*tmp == '\\') *tmp = '_';
+        if(*tmp == '/') *tmp = '_';
+        if(*tmp == '.') *tmp = '_';
+    } while(*tmp++);
+    return LoadImageW(tc->hTheme, szFile, IMAGE_BITMAP, 0, 0, LR_SHARED|LR_CREATEDIBSECTION);
+}

dlls/uxtheme/msstyles.h

@@ -82,6 +82,7 @@ PUXINI_FILE MSSTYLES_GetThemeIni(PTHEME_FILE tf);
 PTHEME_PARTSTATE MSSTYLES_FindPartState(PTHEME_CLASS tc, int iPartId, int iStateId, PTHEME_CLASS *tcNext);
 PTHEME_CLASS MSSTYLES_FindClass(PTHEME_FILE tf, LPCWSTR pszAppName, LPCWSTR pszClassName);
 PTHEME_PROPERTY MSSTYLES_FindProperty(PTHEME_CLASS tc, int iPartId, int iStateId, int iPropertyPrimitive, int iPropertyId);
+HBITMAP MSSTYLES_LoadBitmap(HDC hdc, PTHEME_CLASS tc, LPCWSTR lpFilename);
 
 PUXINI_FILE UXINI_LoadINI(HMODULE hTheme, LPCWSTR lpName);
 void UXINI_CloseINI(PUXINI_FILE uf);

dlls/uxtheme/property.c

@@ -60,6 +60,26 @@ BOOL UXTHEME_GetNextInteger(LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR
     return TRUE;
 }
 
+BOOL UXTHEME_GetNextToken(LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR *lpValEnd, LPWSTR lpBuff, DWORD buffSize) {
+    LPCWSTR cur = lpStringStart;
+    LPCWSTR start;
+    LPCWSTR end;
+
+    while(cur < lpStringEnd && (isspace(*cur) || *cur == ',')) cur++;
+    if(cur >= lpStringEnd) {
+        return FALSE;
+    }
+    start = cur;
+    while(cur < lpStringEnd && *cur != ',') cur++;
+    end = cur;
+    while(isspace(*end)) end--;
+
+    lstrcpynW(lpBuff, start, min(buffSize, end-start+1));
+
+    if(lpValEnd) *lpValEnd = cur;
+    return TRUE;
+}
+
 /***********************************************************************
  *      GetThemeBool                                        (UXTHEME.@)
  */
@@ -156,10 +176,46 @@ HRESULT WINAPI GetThemeFilename(HTHEME hTheme, int iPartId, int iStateId,
 HRESULT WINAPI GetThemeFont(HTHEME hTheme, HDC hdc, int iPartId,
                             int iStateId, int iPropId, LOGFONTW *pFont)
 {
-    FIXME("%d %d %d: stub\n", iPartId, iStateId, iPropId);
+    LPCWSTR lpCur;
+    LPCWSTR lpEnd;
+    PTHEME_PROPERTY tp;
+    int pointSize;
+    WCHAR attr[32];
+    const WCHAR szBold[] = {'b','o','l','d','\0'};
+    const WCHAR szItalic[] = {'i','t','a','l','i','c','\0'};
+    const WCHAR szUnderline[] = {'u','n','d','e','r','l','i','n','e','\0'};
+    const WCHAR szStrikeOut[] = {'s','t','r','i','k','e','o','u','t','\0'};
+
+    TRACE("(%d, %d, %d)\n", iPartId, iStateId, iPropId);
     if(!hTheme)
         return E_HANDLE;
-    return ERROR_CALL_NOT_IMPLEMENTED;
+
+    if(!(tp = MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FONT, iPropId)))
+        return E_PROP_ID_UNSUPPORTED;
+
+    lpCur = tp->lpValue;
+    lpEnd = tp->lpValue + tp->dwValueLen;
+
+    ZeroMemory(pFont, sizeof(LOGFONTW));
+
+    if(!UXTHEME_GetNextToken(lpCur, lpEnd, &lpCur, pFont->lfFaceName, LF_FACESIZE)) {
+        TRACE("Property is there, but failed to get face name\n");
+        return E_PROP_ID_UNSUPPORTED;
+    }
+    if(!UXTHEME_GetNextInteger(lpCur, lpEnd, &lpCur, &pointSize)) {
+        TRACE("Property is there, but failed to get point size\n");
+        return E_PROP_ID_UNSUPPORTED;
+    }
+    pFont->lfHeight = -MulDiv(pointSize, GetDeviceCaps(hdc, LOGPIXELSY), 72);
+    pFont->lfWeight = FW_REGULAR;
+    pFont->lfCharSet = DEFAULT_CHARSET;
+    while(UXTHEME_GetNextToken(lpCur, lpEnd, &lpCur, attr, sizeof(attr)/sizeof(attr[0]))) {
+        if(!lstrcmpiW(szBold, attr)) pFont->lfWeight = FW_BOLD;
+        else if(!!lstrcmpiW(szItalic, attr)) pFont->lfItalic = TRUE;
+        else if(!!lstrcmpiW(szUnderline, attr)) pFont->lfUnderline = TRUE;
+        else if(!!lstrcmpiW(szStrikeOut, attr)) pFont->lfStrikeOut = TRUE;
+    }
+    return S_OK;
 }
 
 /***********************************************************************
@@ -189,10 +245,26 @@ HRESULT WINAPI GetThemeInt(HTHEME hTheme, int iPartId, int iStateId,
 HRESULT WINAPI GetThemeIntList(HTHEME hTheme, int iPartId, int iStateId,
                                int iPropId, INTLIST *pIntList)
 {
-    FIXME("%d %d %d: stub\n", iPartId, iStateId, iPropId);
+    LPCWSTR lpCur;
+    LPCWSTR lpEnd;
+    int i;
+    PTHEME_PROPERTY tp;
+
+    TRACE("(%d, %d, %d)\n", iPartId, iStateId, iPropId);
     if(!hTheme)
         return E_HANDLE;
-    return ERROR_CALL_NOT_IMPLEMENTED;
+
+    if(!(tp = MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_INTLIST, iPropId)))
+        return E_PROP_ID_UNSUPPORTED;
+    lpCur = tp->lpValue;
+    lpEnd = tp->lpValue + tp->dwValueLen;
+
+    for(i=0; i < MAX_INTLIST_COUNT; i++) {
+        if(!UXTHEME_GetNextInteger(lpCur, lpEnd, &lpCur, &pIntList->iValues[i]))
+            break;
+    }
+    pIntList->iValueCount = i;
+    return S_OK;
 }
 
 /***********************************************************************