dlls/uxtheme/draw.c

   1 /*
   2  * Win32 5.1 Theme drawing
   3  *
   4  * Copyright (C) 2003 Kevin Koltzau
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "wingdi.h"
  30 #include "uxtheme.h"
  31 #include "tmschema.h"
  32
  33 #include "msstyles.h"
  34 #include "uxthemedll.h"
  35
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(uxtheme);
  39
  40 /***********************************************************************
  41  * Defines and global variables
  42  */
  43
  44 DWORD dwDialogTextureFlags;
  45
  46 /***********************************************************************/
  47
  48 /***********************************************************************
  49  *      EnableThemeDialogTexture                            (UXTHEME.@)
  50  */
  51 HRESULT WINAPI EnableThemeDialogTexture(HWND hwnd, DWORD dwFlags)
  52 {
  53     TRACE("(%p,0x%08lx\n", hwnd, dwFlags);
  54     dwDialogTextureFlags = dwFlags;
  55     return S_OK;
  56  }
  57
  58 /***********************************************************************
  59  *      IsThemeDialogTextureEnabled                         (UXTHEME.@)
  60  */
  61 BOOL WINAPI IsThemeDialogTextureEnabled(void)
  62 {
  63     TRACE("\n");
  64     return (dwDialogTextureFlags & ETDT_ENABLE) && !(dwDialogTextureFlags & ETDT_DISABLE);
  65 }
  66
  67 /***********************************************************************
  68  *      DrawThemeParentBackground                           (UXTHEME.@)
  69  */
  70 HRESULT WINAPI DrawThemeParentBackground(HWND hwnd, HDC hdc, RECT *prc)
  71 {
  72     RECT rt;
  73     POINT org;
  74     HWND hParent;
  75     HRGN clip = NULL;
  76     int hasClip = -1;
  77
  78     TRACE("(%p,%p,%p)\n", hwnd, hdc, prc);
  79     hParent = GetParent(hwnd);
  80     if(!hParent)
  81         hParent = hwnd;
  82     if(prc) {
  83         CopyRect(&rt, prc);
  84         MapWindowPoints(hwnd, NULL, (LPPOINT)&rt, 2);
  85
  86         clip = CreateRectRgn(0,0,1,1);
  87         hasClip = GetClipRgn(hdc, clip);
  88         if(hasClip == -1)
  89             TRACE("Failed to get original clipping region\n");
  90         else
  91             IntersectClipRect(hdc, prc->left, prc->top, prc->right, prc->bottom);
  92     }
  93     else {
  94         GetClientRect(hParent, &rt);
  95         MapWindowPoints(hParent, NULL, (LPPOINT)&rt, 2);
  96     }
  97
  98     SetViewportOrgEx(hdc, rt.left, rt.top, &org);
  99
 100     SendMessageW(hParent, WM_ERASEBKGND, (WPARAM)hdc, 0);
 101     SendMessageW(hParent, WM_PRINTCLIENT, (WPARAM)hdc, PRF_CLIENT);
 102
 103     SetViewportOrgEx(hdc, org.x, org.y, NULL);
 104     if(prc) {
 105         if(hasClip == 0)
 106             SelectClipRgn(hdc, NULL);
 107         else if(hasClip == 1)
 108             SelectClipRgn(hdc, clip);
 109         DeleteObject(clip);
 110     }
 111     return S_OK;
 112 }
 113
 114
 115 /***********************************************************************
 116  *      DrawThemeBackground                                 (UXTHEME.@)
 117  */
 118 HRESULT WINAPI DrawThemeBackground(HTHEME hTheme, HDC hdc, int iPartId,
 119                                    int iStateId, const RECT *pRect,
 120                                    const RECT *pClipRect)
 121 {
 122     DTBGOPTS opts;
 123     opts.dwSize = sizeof(DTBGOPTS);
 124     opts.dwFlags = 0;
 125     if(pClipRect) {
 126         opts.dwFlags |= DTBG_CLIPRECT;
 127         CopyRect(&opts.rcClip, pClipRect);
 128     }
 129     return DrawThemeBackgroundEx(hTheme, hdc, iPartId, iStateId, pRect, &opts);
 130 }
 131
 132 /***********************************************************************
 133  *      UXTHEME_SelectImage
 134  *
 135  * Select the image to use
 136  */
 137 PTHEME_PROPERTY UXTHEME_SelectImage(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, BOOL glyph)
 138 {
 139     PTHEME_PROPERTY tp;
 140     int imageselecttype = IST_NONE;
 141     int i;
 142     int image;
 143     if(glyph)
 144         image = TMT_GLYPHIMAGEFILE;
 145     else
 146         image = TMT_IMAGEFILE;
 147
 148     if((tp=MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, image)))
 149         return tp;
 150     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_IMAGESELECTTYPE, &imageselecttype);
 151
 152     if(imageselecttype == IST_DPI) {
 153         int reqdpi = 0;
 154         int screendpi = GetDeviceCaps(hdc, LOGPIXELSX);
 155         for(i=4; i>=0; i--) {
 156             reqdpi = 0;
 157             if(SUCCEEDED(GetThemeInt(hTheme, iPartId, iStateId, i + TMT_MINDPI1, &reqdpi))) {
 158                 if(reqdpi != 0 && screendpi >= reqdpi) {
 159                     TRACE("Using %d DPI, image %d\n", reqdpi, i + TMT_IMAGEFILE1);
 160                     return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, i + TMT_IMAGEFILE1);
 161                 }
 162             }
 163         }
 164         /* If an image couldnt be selected, choose the first one */
 165         return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, TMT_IMAGEFILE1);
 166     }
 167     else if(imageselecttype == IST_SIZE) {
 168         POINT size = {pRect->right-pRect->left, pRect->bottom-pRect->top};
 169         POINT reqsize;
 170         for(i=4; i>=0; i--) {
 171             if(SUCCEEDED(GetThemePosition(hTheme, iPartId, iStateId, i + TMT_MINSIZE1, &reqsize))) {
 172                 if(reqsize.x >= size.x && reqsize.y >= size.y) {
 173                     TRACE("Using image size %ldx%ld, image %d\n", reqsize.x, reqsize.y, i + TMT_IMAGEFILE1);
 174                     return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, i + TMT_IMAGEFILE1);
 175                 }
 176             }
 177         }
 178         /* If an image couldnt be selected, choose the smallest one */
 179         return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, TMT_IMAGEFILE1);
 180     }
 181     return NULL;
 182 }
 183
 184 /***********************************************************************
 185  *      UXTHEME_LoadImage
 186  *
 187  * Load image for part/state
 188  */
 189 HRESULT UXTHEME_LoadImage(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, BOOL glyph,
 190                           HBITMAP *hBmp, RECT *bmpRect)
 191 {
 192     int imagelayout = IL_VERTICAL;
 193     int imagecount = 0;
 194     BITMAP bmp;
 195     WCHAR szPath[MAX_PATH];
 196     PTHEME_PROPERTY tp = UXTHEME_SelectImage(hTheme, hdc, iPartId, iStateId, pRect, glyph);
 197     if(!tp) {
 198         FIXME("Couldn't determine image for part/state %d/%d, invalid theme?\n", iPartId, iStateId);
 199         return E_PROP_ID_UNSUPPORTED;
 200     }
 201     lstrcpynW(szPath, tp->lpValue, min(tp->dwValueLen+1, sizeof(szPath)/sizeof(szPath[0])));
 202     *hBmp = MSSTYLES_LoadBitmap(hdc, hTheme, szPath);
 203     if(!*hBmp) {
 204         TRACE("Failed to load bitmap %s\n", debugstr_w(szPath));
 205         return HRESULT_FROM_WIN32(GetLastError());
 206     }
 207
 208     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_IMAGELAYOUT, &imagelayout);
 209     GetThemeInt(hTheme, iPartId, iStateId, TMT_IMAGECOUNT, &imagecount);
 210
 211     GetObjectW(*hBmp, sizeof(bmp), &bmp);
 212     if(imagelayout == IL_VERTICAL) {
 213         int height = bmp.bmHeight/imagecount;
 214         bmpRect->left = 0;
 215         bmpRect->right = bmp.bmWidth;
 216         bmpRect->top = (min(imagecount, iStateId)-1) * height;
 217         bmpRect->bottom = bmpRect->top + height;
 218     }
 219     else {
 220         int width = bmp.bmWidth/imagecount;
 221         bmpRect->left = (min(imagecount, iStateId)-1) * width;
 222         bmpRect->right = bmpRect->left + width;
 223         bmpRect->top = 0;
 224         bmpRect->bottom = bmp.bmHeight;
 225     }
 226     return S_OK;
 227 }
 228
 229 /***********************************************************************
 230  *      UXTHEME_StretchBlt
 231  *
 232  * Psudo TransparentBlt/StretchBlt
 233  */
 234 static inline BOOL UXTHEME_StretchBlt(HDC hdcDst, int nXOriginDst, int nYOriginDst, int nWidthDst, int nHeightDst,
 235                                       HDC hdcSrc, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc,
 236                                       BOOL transparent, COLORREF transcolor)
 237 {
 238     if(transparent) {
 239         /* Ensure we don't pass any negative values to TransparentBlt */
 240         return TransparentBlt(hdcDst, nXOriginDst, nYOriginDst, abs(nWidthDst), abs(nHeightDst),
 241                               hdcSrc, nXOriginSrc, nYOriginSrc, abs(nWidthSrc), abs(nHeightSrc),
 242                               transcolor);
 243     }
 244     /* This should be using AlphaBlend */
 245     return StretchBlt(hdcDst, nXOriginDst, nYOriginDst, nWidthDst, nHeightDst,
 246                         hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,
 247                         SRCCOPY);
 248 }
 249
 250 /***********************************************************************
 251  *      UXTHEME_Blt
 252  *
 253  * Simplify sending same width/height for both source and dest
 254  */
 255 static inline BOOL UXTHEME_Blt(HDC hdcDest, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest,
 256                                HDC hdcSrc, int nXOriginSrc, int nYOriginSrc,
 257                                BOOL transparent, COLORREF transcolor)
 258 {
 259     return UXTHEME_StretchBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
 260                               hdcSrc, nXOriginSrc, nYOriginSrc, nWidthDest, nHeightDest,
 261                               transparent, transcolor);
 262 }
 263
 264
 265 /***********************************************************************
 266  *      UXTHEME_DrawImageGlyph
 267  *
 268  * Draw an imagefile glyph
 269  */
 270 HRESULT UXTHEME_DrawImageGlyph(HTHEME hTheme, HDC hdc, int iPartId,
 271                                int iStateId, RECT *pRect,
 272                                const DTBGOPTS *pOptions)
 273 {
 274     HRESULT hr;
 275     HBITMAP bmpSrc = NULL;
 276     HDC hdcSrc = NULL;
 277     HGDIOBJ oldSrc = NULL;
 278     RECT rcSrc;
 279     BOOL transparent = FALSE;
 280     COLORREF transparentcolor = 0;
 281     int valign = VA_CENTER;
 282     int halign = HA_CENTER;
 283     POINT dstSize;
 284     POINT srcSize;
 285     POINT topleft;
 286
 287     hr = UXTHEME_LoadImage(hTheme, hdc, iPartId, iStateId, pRect, TRUE, &bmpSrc, &rcSrc);
 288     if(FAILED(hr)) return hr;
 289     hdcSrc = CreateCompatibleDC(hdc);
 290     if(!hdcSrc) {
 291         hr = HRESULT_FROM_WIN32(GetLastError());
 292         DeleteObject(bmpSrc);
 293         return hr;
 294     }
 295     oldSrc = SelectObject(hdcSrc, bmpSrc);
 296
 297     dstSize.x = pRect->right-pRect->left;
 298     dstSize.y = pRect->bottom-pRect->top;
 299     srcSize.x = rcSrc.right-rcSrc.left;
 300     srcSize.y = rcSrc.bottom-rcSrc.top;
 301
 302     GetThemeBool(hTheme, iPartId, iStateId, TMT_GLYPHTRANSPARENT, &transparent);
 303     if(transparent) {
 304         if(FAILED(GetThemeColor(hTheme, iPartId, iStateId, TMT_GLYPHTRANSPARENTCOLOR, &transparentcolor))) {
 305             /* If image is transparent, but no color was specified, get the color of the upper left corner */
 306             transparentcolor = GetPixel(hdcSrc, 0, 0);
 307         }
 308     }
 309     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_VALIGN, &valign);
 310     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_HALIGN, &halign);
 311
 312     topleft.x = pRect->left;
 313     topleft.y = pRect->top;
 314     if(halign == HA_CENTER)      topleft.x += (dstSize.x/2)-(srcSize.x/2);
 315     else if(halign == HA_RIGHT)  topleft.x += dstSize.x-srcSize.x;
 316     if(valign == VA_CENTER)      topleft.y += (dstSize.y/2)-(srcSize.y/2);
 317     else if(valign == VA_BOTTOM) topleft.y += dstSize.y-srcSize.y;
 318
 319     if(!UXTHEME_Blt(hdc, topleft.x, topleft.y, srcSize.x, srcSize.y,
 320                     hdcSrc, rcSrc.left, rcSrc.top,
 321                     transparent, transparentcolor)) {
 322         hr = HRESULT_FROM_WIN32(GetLastError());
 323     }
 324
 325     SelectObject(hdcSrc, oldSrc);
 326     DeleteDC(hdcSrc);
 327     DeleteObject(bmpSrc);
 328     return hr;
 329 }
 330
 331 /***********************************************************************
 332  *      UXTHEME_DrawImageGlyph
 333  *
 334  * Draw glyph on top of background, if appropriate
 335  */
 336 HRESULT UXTHEME_DrawGlyph(HTHEME hTheme, HDC hdc, int iPartId,
 337                                     int iStateId, RECT *pRect,
 338                                     const DTBGOPTS *pOptions)
 339 {
 340     int glyphtype = GT_NONE;
 341
 342     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_GLYPHTYPE, &glyphtype);
 343
 344     if(glyphtype == GT_IMAGEGLYPH) {
 345         return UXTHEME_DrawImageGlyph(hTheme, hdc, iPartId, iStateId, pRect, pOptions);
 346     }
 347     else if(glyphtype == GT_FONTGLYPH) {
 348         /* I don't know what a font glyph is, I've never seen it used in any themes */
 349         FIXME("Font glyph\n");
 350     }
 351     return S_OK;
 352 }
 353
 354 /***********************************************************************
 355  *      UXTHEME_DrawImageBackground
 356  *
 357  * Draw an imagefile background
 358  */
 359 HRESULT UXTHEME_DrawImageBackground(HTHEME hTheme, HDC hdc, int iPartId,
 360                                     int iStateId, RECT *pRect,
 361                                     const DTBGOPTS *pOptions)
 362 {
 363     HRESULT hr = S_OK;
 364     HBITMAP bmpSrc;
 365     HGDIOBJ oldSrc;
 366     HDC hdcSrc;
 367     RECT rcSrc;
 368     RECT rcDst;
 369     POINT dstSize;
 370     POINT srcSize;
 371     int sizingtype = ST_TRUESIZE;
 372     BOOL uniformsizing = FALSE;
 373     BOOL transparent = FALSE;
 374     COLORREF transparentcolor = 0;
 375
 376     hr = UXTHEME_LoadImage(hTheme, hdc, iPartId, iStateId, pRect, FALSE, &bmpSrc, &rcSrc);
 377     if(FAILED(hr)) return hr;
 378     hdcSrc = CreateCompatibleDC(hdc);
 379     if(!hdcSrc) {
 380         hr = HRESULT_FROM_WIN32(GetLastError());
 381         DeleteObject(bmpSrc);
 382         return hr;
 383     }
 384     oldSrc = SelectObject(hdcSrc, bmpSrc);
 385
 386     CopyRect(&rcDst, pRect);
 387
 388     GetThemeBool(hTheme, iPartId, iStateId, TMT_TRANSPARENT, &transparent);
 389     if(transparent) {
 390         if(FAILED(GetThemeColor(hTheme, iPartId, iStateId, TMT_TRANSPARENTCOLOR, &transparentcolor))) {
 391             /* If image is transparent, but no color was specified, get the color of the upper left corner */
 392             transparentcolor = GetPixel(hdcSrc, 0, 0);
 393         }
 394     }
 395
 396     dstSize.x = rcDst.right-rcDst.left;
 397     dstSize.y = rcDst.bottom-rcDst.top;
 398     srcSize.x = rcSrc.right-rcSrc.left;
 399     srcSize.y = rcSrc.bottom-rcSrc.top;
 400
 401     GetThemeBool(hTheme, iPartId, iStateId, TMT_UNIFORMSIZING, &uniformsizing);
 402     if(uniformsizing) {
 403         /* Scale height and width equally */
 404         int widthDiff = abs(srcSize.x-dstSize.x);
 405         int heightDiff = abs(srcSize.y-dstSize.x);
 406         if(widthDiff > heightDiff) {
 407             dstSize.y -= widthDiff-heightDiff;
 408             rcDst.bottom = rcDst.top + dstSize.y;
 409         }
 410         else if(heightDiff > widthDiff) {
 411             dstSize.x -= heightDiff-widthDiff;
 412             rcDst.right = rcDst.left + dstSize.x;
 413         }
 414     }
 415
 416     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_SIZINGTYPE, &sizingtype);
 417     if(sizingtype == ST_TRUESIZE) {
 418         int truesizestretchmark = 0;
 419
 420         if(dstSize.x < 0 || dstSize.y < 0) {
 421             BOOL mirrorimage = TRUE;
 422             GetThemeBool(hTheme, iPartId, iStateId, TMT_MIRRORIMAGE, &mirrorimage);
 423             if(mirrorimage) {
 424                 if(dstSize.x < 0) {
 425                     rcDst.left += dstSize.x;
 426                     rcDst.right += dstSize.x;
 427                 }
 428                 if(dstSize.y < 0) {
 429                     rcDst.top += dstSize.y;
 430                     rcDst.bottom += dstSize.y;
 431                 }
 432             }
 433         }
 434         /* Only stretch when target exceeds source by truesizestretchmark percent */
 435         GetThemeInt(hTheme, iPartId, iStateId, TMT_TRUESIZESTRETCHMARK, &truesizestretchmark);
 436         if(dstSize.x < 0 || dstSize.y < 0 ||
 437            MulDiv(srcSize.x, 100, dstSize.x) > truesizestretchmark ||
 438            MulDiv(srcSize.y, 100, dstSize.y) > truesizestretchmark) {
 439             if(!UXTHEME_StretchBlt(hdc, rcDst.left, rcDst.top, dstSize.x, dstSize.y,
 440                                    hdcSrc, rcSrc.left, rcSrc.top, srcSize.x, srcSize.y,
 441                                    transparent, transparentcolor))
 442                 hr = HRESULT_FROM_WIN32(GetLastError());
 443         }
 444         else {
 445             rcDst.left += (dstSize.x/2)-(srcSize.x/2);
 446             rcDst.top  += (dstSize.y/2)-(srcSize.y/2);
 447             rcDst.right = rcDst.left + srcSize.x;
 448             rcDst.bottom = rcDst.top + srcSize.y;
 449             if(!UXTHEME_Blt(hdc, rcDst.left, rcDst.top, srcSize.x, srcSize.y,
 450                             hdcSrc, rcSrc.left, rcSrc.top,
 451                             transparent, transparentcolor))
 452                 hr = HRESULT_FROM_WIN32(GetLastError());
 453         }
 454     }
 455     else {
 456         HDC hdcDst = NULL;
 457         HBITMAP bmpDst = NULL;
 458         HGDIOBJ oldDst = NULL;
 459         MARGINS sm;
 460
 461         dstSize.x = abs(dstSize.x);
 462         dstSize.y = abs(dstSize.y);
 463
 464         GetThemeMargins(hTheme, hdc, iPartId, iStateId, TMT_SIZINGMARGINS, NULL, &sm);
 465
 466         hdcDst = CreateCompatibleDC(hdc);
 467         if(!hdcDst) {
 468             hr = HRESULT_FROM_WIN32(GetLastError());
 469             goto draw_error;
 470         }
 471         bmpDst = CreateCompatibleBitmap(hdc, dstSize.x, dstSize.y);
 472         if(!bmpDst) {
 473             hr = HRESULT_FROM_WIN32(GetLastError());
 474             goto draw_error;
 475         }
 476         oldDst = SelectObject(hdcDst, bmpDst);
 477
 478         /* Upper left corner */
 479         if(!BitBlt(hdcDst, 0, 0, sm.cxLeftWidth, sm.cyTopHeight,
 480                    hdcSrc, rcSrc.left, rcSrc.top, SRCCOPY)) {
 481             hr = HRESULT_FROM_WIN32(GetLastError());
 482             goto draw_error;
 483         }
 484         /* Upper right corner */
 485         if(!BitBlt(hdcDst, dstSize.x-sm.cxRightWidth, 0, sm.cxRightWidth, sm.cyTopHeight,
 486                    hdcSrc, rcSrc.right-sm.cxRightWidth, rcSrc.top, SRCCOPY)) {
 487             hr = HRESULT_FROM_WIN32(GetLastError());
 488             goto draw_error;
 489         }
 490         /* Lower left corner */
 491         if(!BitBlt(hdcDst, 0, dstSize.y-sm.cyBottomHeight, sm.cxLeftWidth, sm.cyBottomHeight,
 492                    hdcSrc, rcSrc.left, rcSrc.bottom-sm.cyBottomHeight, SRCCOPY)) {
 493             hr = HRESULT_FROM_WIN32(GetLastError());
 494             goto draw_error;
 495         }
 496         /* Lower right corner */
 497         if(!BitBlt(hdcDst, dstSize.x-sm.cxRightWidth, dstSize.y-sm.cyBottomHeight, sm.cxRightWidth, sm.cyBottomHeight,
 498                    hdcSrc, rcSrc.right-sm.cxRightWidth, rcSrc.bottom-sm.cyBottomHeight, SRCCOPY)) {
 499             hr = HRESULT_FROM_WIN32(GetLastError());
 500             goto draw_error;
 501         }
 502
 503         if(sizingtype == ST_TILE) {
 504             FIXME("Tile\n");
 505             sizingtype = ST_STRETCH; /* Just use stretch for now */
 506         }
 507         if(sizingtype == ST_STRETCH) {
 508             int destCenterWidth  = dstSize.x - (sm.cxLeftWidth + sm.cxRightWidth);
 509             int srcCenterWidth   = srcSize.x - (sm.cxLeftWidth + sm.cxRightWidth);
 510             int destCenterHeight = dstSize.y - (sm.cyTopHeight + sm.cyBottomHeight);
 511             int srcCenterHeight  = srcSize.y - (sm.cyTopHeight + sm.cyBottomHeight);
 512
 513             if(destCenterWidth > 0) {
 514                 /* Center top */
 515                 if(!StretchBlt(hdcDst, sm.cxLeftWidth, 0, destCenterWidth, sm.cyTopHeight,
 516                                hdcSrc, rcSrc.left+sm.cxLeftWidth, rcSrc.top, srcCenterWidth, sm.cyTopHeight, SRCCOPY)) {
 517                     hr = HRESULT_FROM_WIN32(GetLastError());
 518                     goto draw_error;
 519                 }
 520                 /* Center bottom */
 521                 if(!StretchBlt(hdcDst, sm.cxLeftWidth, dstSize.y-sm.cyBottomHeight, destCenterWidth, sm.cyBottomHeight,
 522                                hdcSrc, rcSrc.left+sm.cxLeftWidth, rcSrc.bottom-sm.cyBottomHeight, srcCenterWidth, sm.cyTopHeight, SRCCOPY)) {
 523                     hr = HRESULT_FROM_WIN32(GetLastError());
 524                     goto draw_error;
 525                 }
 526             }
 527             if(destCenterHeight > 0) {
 528                 /* Left center */
 529                 if(!StretchBlt(hdcDst, 0, sm.cyTopHeight, sm.cxLeftWidth, destCenterHeight,
 530                            hdcSrc, rcSrc.left, rcSrc.top+sm.cyTopHeight, sm.cxLeftWidth, srcCenterHeight, SRCCOPY)) {
 531                     hr = HRESULT_FROM_WIN32(GetLastError());
 532                     goto draw_error;
 533                 }
 534                 /* Right center */
 535                 if(!StretchBlt(hdcDst, dstSize.x-sm.cxRightWidth, sm.cyTopHeight, sm.cxRightWidth, destCenterHeight,
 536                                hdcSrc, rcSrc.right-sm.cxRightWidth, rcSrc.top+sm.cyTopHeight, sm.cxRightWidth, srcCenterHeight, SRCCOPY)) {
 537                     hr = HRESULT_FROM_WIN32(GetLastError());
 538                     goto draw_error;
 539                 }
 540             }
 541             if(destCenterHeight > 0 && destCenterWidth > 0) {
 542                 BOOL borderonly = FALSE;
 543                 GetThemeBool(hTheme, iPartId, iStateId, TMT_BORDERONLY, &borderonly);
 544                 if(!borderonly) {
 545                     /* Center */
 546                     if(!StretchBlt(hdcDst, sm.cxLeftWidth, sm.cyTopHeight, destCenterWidth, destCenterHeight,
 547                                    hdcSrc, rcSrc.left+sm.cxLeftWidth, rcSrc.top+sm.cyTopHeight, srcCenterWidth, srcCenterHeight, SRCCOPY)) {
 548                         hr = HRESULT_FROM_WIN32(GetLastError());
 549                         goto draw_error;
 550                     }
 551                 }
 552             }
 553         }
 554
 555         if(!UXTHEME_Blt(hdc, rcDst.left, rcDst.top, dstSize.x, dstSize.y,
 556                         hdcDst, 0, 0,
 557                         transparent, transparentcolor))
 558             hr = HRESULT_FROM_WIN32(GetLastError());
 559
 560 draw_error:
 561         if(hdcDst) {
 562             SelectObject(hdcDst, oldDst);
 563             DeleteDC(hdcDst);
 564         }
 565         if(bmpDst) DeleteObject(bmpDst);
 566     }
 567     SelectObject(hdcSrc, oldSrc);
 568     DeleteObject(bmpSrc);
 569     DeleteDC(hdcSrc);
 570     CopyRect(pRect, &rcDst);
 571     return hr;
 572 }
 573
 574 /***********************************************************************
 575  *      UXTHEME_DrawBorderRectangle
 576  *
 577  * Draw the bounding rectangle for a borderfill background
 578  */
 579 HRESULT UXTHEME_DrawBorderRectangle(HTHEME hTheme, HDC hdc, int iPartId,
 580                                     int iStateId, RECT *pRect,
 581                                     const DTBGOPTS *pOptions)
 582 {
 583     HRESULT hr = S_OK;
 584     HPEN hPen;
 585     HGDIOBJ oldPen;
 586     COLORREF bordercolor = RGB(0,0,0);
 587     int bordersize = 1;
 588
 589     GetThemeInt(hTheme, iPartId, iStateId, TMT_BORDERSIZE, &bordersize);
 590     if(bordersize > 0) {
 591         POINT ptCorners[4];
 592         ptCorners[0].x = pRect->left;
 593         ptCorners[0].y = pRect->top;
 594         ptCorners[1].x = pRect->right;
 595         ptCorners[1].y = pRect->top;
 596         ptCorners[2].x = pRect->right;
 597         ptCorners[2].y = pRect->bottom;
 598         ptCorners[3].x = pRect->left;
 599         ptCorners[3].y = pRect->bottom;
 600
 601         InflateRect(pRect, -bordersize, -bordersize);
 602         if(pOptions->dwFlags & DTBG_OMITBORDER)
 603             return S_OK;
 604         GetThemeColor(hTheme, iPartId, iStateId, TMT_BORDERCOLOR, &bordercolor);
 605         hPen = CreatePen(PS_SOLID, bordersize, bordercolor);
 606         if(!hPen)
 607             return HRESULT_FROM_WIN32(GetLastError());
 608         oldPen = SelectObject(hdc, hPen);
 609
 610         if(!Polyline(hdc, ptCorners, 4))
 611             hr = HRESULT_FROM_WIN32(GetLastError());
 612
 613         SelectObject(hdc, oldPen);
 614         DeleteObject(hPen);
 615     }
 616     return hr;
 617 }
 618
 619 /***********************************************************************
 620  *      UXTHEME_DrawBackgroundFill
 621  *
 622  * Fill a borderfill background rectangle
 623  */
 624 HRESULT UXTHEME_DrawBackgroundFill(HTHEME hTheme, HDC hdc, int iPartId,
 625                                    int iStateId, RECT *pRect,
 626                                    const DTBGOPTS *pOptions)
 627 {
 628     HRESULT hr = S_OK;
 629     int filltype = FT_SOLID;
 630
 631     TRACE("(%d,%d,%ld)\n", iPartId, iStateId, pOptions->dwFlags);
 632
 633     if(pOptions->dwFlags & DTBG_OMITCONTENT)
 634         return S_OK;
 635
 636     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_FILLTYPE, &filltype);
 637
 638     if(filltype == FT_SOLID) {
 639         HBRUSH hBrush;
 640         COLORREF fillcolor = RGB(255,255,255);
 641
 642         GetThemeColor(hTheme, iPartId, iStateId, TMT_FILLCOLOR, &fillcolor);
 643         hBrush = CreateSolidBrush(fillcolor);
 644         if(!FillRect(hdc, pRect, hBrush))
 645             hr = HRESULT_FROM_WIN32(GetLastError());
 646         DeleteObject(hBrush);
 647     }
 648     else if(filltype == FT_VERTGRADIENT || filltype == FT_HORZGRADIENT) {
 649         /* FIXME: This only accounts for 2 gradient colors (out of 5) and ignores
 650             the gradient ratios (no idea how those work)
 651             Few themes use this, and the ones I've seen only use 2 colors with
 652             a gradient ratio of 0 and 255 respectivly
 653         */
 654
 655         COLORREF gradient1 = RGB(0,0,0);
 656         COLORREF gradient2 = RGB(255,255,255);
 657         TRIVERTEX vert[2];
 658         GRADIENT_RECT gRect;
 659
 660         FIXME("Gradient implementation not complete\n");
 661
 662         GetThemeColor(hTheme, iPartId, iStateId, TMT_GRADIENTCOLOR1, &gradient1);
 663         GetThemeColor(hTheme, iPartId, iStateId, TMT_GRADIENTCOLOR2, &gradient2);
 664
 665         vert[0].x     = pRect->left;
 666         vert[0].y     = pRect->top;
 667         vert[0].Red   = GetRValue(gradient1) << 8;
 668         vert[0].Green = GetGValue(gradient1) << 8;
 669         vert[0].Blue  = GetBValue(gradient1) << 8;
 670         vert[0].Alpha = 0x0000;
 671
 672         vert[1].x     = pRect->right;
 673         vert[1].y     = pRect->bottom;
 674         vert[1].Red   = GetRValue(gradient2) << 8;
 675         vert[1].Green = GetGValue(gradient2) << 8;
 676         vert[1].Blue  = GetBValue(gradient2) << 8;
 677         vert[1].Alpha = 0x0000;
 678
 679         gRect.UpperLeft  = 0;
 680         gRect.LowerRight = 1;
 681         GradientFill(hdc,vert,2,&gRect,1,filltype==FT_HORZGRADIENT?GRADIENT_FILL_RECT_H:GRADIENT_FILL_RECT_V);
 682     }
 683     else if(filltype == FT_RADIALGRADIENT) {
 684         /* I've never seen this used in a theme */
 685         FIXME("Radial gradient\n");
 686     }
 687     else if(filltype == FT_TILEIMAGE) {
 688         /* I've never seen this used in a theme */
 689         FIXME("Tile image\n");
 690     }
 691     return hr;
 692 }
 693
 694 /***********************************************************************
 695  *      UXTHEME_DrawBorderBackground
 696  *
 697  * Draw an imagefile background
 698  */
 699 HRESULT UXTHEME_DrawBorderBackground(HTHEME hTheme, HDC hdc, int iPartId,
 700                                      int iStateId, const RECT *pRect,
 701                                      const DTBGOPTS *pOptions)
 702 {
 703     HRESULT hr;
 704     RECT rt;
 705
 706     CopyRect(&rt, pRect);
 707
 708     hr = UXTHEME_DrawBorderRectangle(hTheme, hdc, iPartId, iStateId, &rt, pOptions);
 709     if(FAILED(hr))
 710         return hr;
 711     return UXTHEME_DrawBackgroundFill(hTheme, hdc, iPartId, iStateId, &rt, pOptions);
 712 }
 713
 714 /***********************************************************************
 715  *      DrawThemeBackgroundEx                               (UXTHEME.@)
 716  */
 717 HRESULT WINAPI DrawThemeBackgroundEx(HTHEME hTheme, HDC hdc, int iPartId,
 718                                      int iStateId, const RECT *pRect,
 719                                      const DTBGOPTS *pOptions)
 720 {
 721     HRESULT hr;
 722     const DTBGOPTS defaultOpts = {sizeof(DTBGOPTS), 0, {0,0,0,0}};
 723     const DTBGOPTS *opts;
 724     HRGN clip = NULL;
 725     int hasClip = -1;
 726     int bgtype = BT_BORDERFILL;
 727     RECT rt;
 728
 729     TRACE("(%p,%p,%d,%d,%ld,%ld)\n", hTheme, hdc, iPartId, iStateId,pRect->left,pRect->top);
 730     if(!hTheme)
 731         return E_HANDLE;
 732
 733     /* Ensure we have a DTBGOPTS structure available, simplifies some of the code */
 734     opts = pOptions;
 735     if(!opts) opts = &defaultOpts;
 736
 737     if(opts->dwFlags & DTBG_CLIPRECT) {
 738         clip = CreateRectRgn(0,0,1,1);
 739         hasClip = GetClipRgn(hdc, clip);
 740         if(hasClip == -1)
 741             TRACE("Failed to get original clipping region\n");
 742         else
 743             IntersectClipRect(hdc, opts->rcClip.left, opts->rcClip.top, opts->rcClip.right, opts->rcClip.bottom);
 744     }
 745     CopyRect(&rt, pRect);
 746
 747     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype);
 748     if(bgtype == BT_IMAGEFILE)
 749         hr = UXTHEME_DrawImageBackground(hTheme, hdc, iPartId, iStateId, &rt, opts);
 750     else if(bgtype == BT_BORDERFILL)
 751         hr = UXTHEME_DrawBorderBackground(hTheme, hdc, iPartId, iStateId, pRect, opts);
 752     else {
 753         FIXME("Unknown background type\n");
 754         /* This should never happen, and hence I don't know what to return */
 755         hr = E_FAIL;
 756     }
 757     if(SUCCEEDED(hr))
 758         hr = UXTHEME_DrawGlyph(hTheme, hdc, iPartId, iStateId, &rt, opts);
 759     if(opts->dwFlags & DTBG_CLIPRECT) {
 760         if(hasClip == 0)
 761             SelectClipRgn(hdc, NULL);
 762         else if(hasClip == 1)
 763             SelectClipRgn(hdc, clip);
 764         DeleteObject(clip);
 765     }
 766     return hr;
 767 }
 768
 769 /***********************************************************************
 770  *      DrawThemeEdge                                       (UXTHEME.@)
 771  */
 772 HRESULT WINAPI DrawThemeEdge(HTHEME hTheme, HDC hdc, int iPartId,
 773                              int iStateId, const RECT *pDestRect, UINT uEdge,
 774                              UINT uFlags, RECT *pContentRect)
 775 {
 776     FIXME("%d %d 0x%08x 0x%08x: stub\n", iPartId, iStateId, uEdge, uFlags);
 777     if(!hTheme)
 778         return E_HANDLE;
 779     return ERROR_CALL_NOT_IMPLEMENTED;
 780 }
 781
 782 /***********************************************************************
 783  *      DrawThemeIcon                                       (UXTHEME.@)
 784  */
 785 HRESULT WINAPI DrawThemeIcon(HTHEME hTheme, HDC hdc, int iPartId, int iStateId,
 786                              const RECT *pRect, HIMAGELIST himl, int iImageIndex)
 787 {
 788     FIXME("%d %d: stub\n", iPartId, iStateId);
 789     if(!hTheme)
 790         return E_HANDLE;
 791     return ERROR_CALL_NOT_IMPLEMENTED;
 792 }
 793
 794 /***********************************************************************
 795  *      DrawThemeText                                       (UXTHEME.@)
 796  */
 797 HRESULT WINAPI DrawThemeText(HTHEME hTheme, HDC hdc, int iPartId, int iStateId,
 798                              LPCWSTR pszText, int iCharCount, DWORD dwTextFlags,
 799                              DWORD dwTextFlags2, const RECT *pRect)
 800 {
 801     HRESULT hr;
 802     HFONT hFont = NULL;
 803     HGDIOBJ oldFont = NULL;
 804     LOGFONTW logfont;
 805     COLORREF textColor;
 806     COLORREF oldTextColor;
 807     int oldBkMode;
 808     RECT rt;
 809
 810     TRACE("%d %d: stub\n", iPartId, iStateId);
 811     if(!hTheme)
 812         return E_HANDLE;
 813
 814     hr = GetThemeFont(hTheme, hdc, iPartId, iStateId, TMT_FONT, &logfont);
 815     if(SUCCEEDED(hr)) {
 816         hFont = CreateFontIndirectW(&logfont);
 817         if(!hFont)
 818             TRACE("Failed to create font\n");
 819     }
 820     CopyRect(&rt, pRect);
 821     if(hFont)
 822         oldFont = SelectObject(hdc, hFont);
 823
 824     if(dwTextFlags2 & DTT_GRAYED)
 825         textColor = GetSysColor(COLOR_GRAYTEXT);
 826     else {
 827         if(FAILED(GetThemeColor(hTheme, iPartId, iStateId, TMT_TEXTCOLOR, &textColor)))
 828             textColor = GetTextColor(hdc);
 829     }
 830     oldTextColor = SetTextColor(hdc, textColor);
 831     oldBkMode = SetBkMode(hdc, TRANSPARENT);
 832     DrawTextW(hdc, pszText, iCharCount, &rt, dwTextFlags);
 833     SetBkMode(hdc, oldBkMode);
 834     SetTextColor(hdc, oldTextColor);
 835
 836     if(hFont) {
 837         SelectObject(hdc, oldFont);
 838         DeleteObject(hFont);
 839     }
 840     return S_OK;
 841 }
 842
 843 /***********************************************************************
 844  *      GetThemeBackgroundContentRect                       (UXTHEME.@)
 845  */
 846 HRESULT WINAPI GetThemeBackgroundContentRect(HTHEME hTheme, HDC hdc, int iPartId,
 847                                              int iStateId,
 848                                              const RECT *pBoundingRect,
 849                                              RECT *pContentRect)
 850 {
 851     MARGINS margin;
 852     HRESULT hr;
 853
 854     TRACE("(%d,%d)\n", iPartId, iStateId);
 855     if(!hTheme)
 856         return E_HANDLE;
 857
 858     hr = GetThemeMargins(hTheme, hdc, iPartId, iStateId, TMT_CONTENTMARGINS, NULL, &margin);
 859     if(FAILED(hr)) {
 860         TRACE("Margins not found\n");
 861         return hr;
 862     }
 863     pContentRect->left = pBoundingRect->left + margin.cxLeftWidth;
 864     pContentRect->top  = pBoundingRect->top + margin.cyTopHeight;
 865     pContentRect->right = pBoundingRect->right - margin.cxRightWidth;
 866     pContentRect->bottom = pBoundingRect->bottom - margin.cyBottomHeight;
 867
 868     TRACE("left:%ld,top:%ld,right:%ld,bottom:%ld\n", pContentRect->left, pContentRect->top, pContentRect->right, pContentRect->bottom);
 869
 870     return S_OK;
 871 }
 872
 873 /***********************************************************************
 874  *      GetThemeBackgroundExtent                            (UXTHEME.@)
 875  */
 876 HRESULT WINAPI GetThemeBackgroundExtent(HTHEME hTheme, HDC hdc, int iPartId,
 877                                         int iStateId, const RECT *pContentRect,
 878                                         RECT *pExtentRect)
 879 {
 880     MARGINS margin;
 881     HRESULT hr;
 882
 883     TRACE("(%d,%d)\n", iPartId, iStateId);
 884     if(!hTheme)
 885         return E_HANDLE;
 886
 887     hr = GetThemeMargins(hTheme, hdc, iPartId, iStateId, TMT_CONTENTMARGINS, NULL, &margin);
 888     if(FAILED(hr)) {
 889         TRACE("Margins not found\n");
 890         return hr;
 891     }
 892     pExtentRect->left = pContentRect->left - margin.cxLeftWidth;
 893     pExtentRect->top  = pContentRect->top - margin.cyTopHeight;
 894     pExtentRect->right = pContentRect->right + margin.cxRightWidth;
 895     pExtentRect->bottom = pContentRect->bottom + margin.cyBottomHeight;
 896
 897     TRACE("left:%ld,top:%ld,right:%ld,bottom:%ld\n", pExtentRect->left, pExtentRect->top, pExtentRect->right, pExtentRect->bottom);
 898
 899     return S_OK;
 900 }
 901
 902 /***********************************************************************
 903  *      GetThemeBackgroundRegion                            (UXTHEME.@)
 904  *
 905  * Calculate the background region, taking into consideration transparent areas
 906  * of the background image.
 907  */
 908 HRESULT WINAPI GetThemeBackgroundRegion(HTHEME hTheme, HDC hdc, int iPartId,
 909                                         int iStateId, const RECT *pRect,
 910                                         HRGN *pRegion)
 911 {
 912     HRESULT hr = S_OK;
 913     int bgtype = BT_BORDERFILL;
 914
 915     TRACE("(%p,%p,%d,%d)\n", hTheme, hdc, iPartId, iStateId);
 916     if(!hTheme)
 917         return E_HANDLE;
 918     if(!pRect || !pRegion)
 919         return E_POINTER;
 920
 921     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype);
 922     if(bgtype == BT_IMAGEFILE) {
 923         FIXME("Images not handled yet\n");
 924         hr = ERROR_CALL_NOT_IMPLEMENTED;
 925     }
 926     else if(bgtype == BT_BORDERFILL) {
 927         *pRegion = CreateRectRgn(pRect->left, pRect->top, pRect->right, pRect->bottom);
 928         if(!*pRegion)
 929             hr = HRESULT_FROM_WIN32(GetLastError());
 930     }
 931     else {
 932         FIXME("Unknown background type\n");
 933         /* This should never happen, and hence I don't know what to return */
 934         hr = E_FAIL;
 935     }
 936     return hr;
 937 }
 938
 939 /***********************************************************************
 940  *      GetThemePartSize                                    (UXTHEME.@)
 941  */
 942 HRESULT WINAPI GetThemePartSize(HTHEME hTheme, HDC hdc, int iPartId,
 943                                 int iStateId, RECT *prc, THEMESIZE eSize,
 944                                 SIZE *psz)
 945 {
 946     FIXME("%d %d %d: stub\n", iPartId, iStateId, eSize);
 947     if(!hTheme)
 948         return E_HANDLE;
 949     return ERROR_CALL_NOT_IMPLEMENTED;
 950 }
 951
 952
 953 /***********************************************************************
 954  *      GetThemeTextExtent                                  (UXTHEME.@)
 955  */
 956 HRESULT WINAPI GetThemeTextExtent(HTHEME hTheme, HDC hdc, int iPartId,
 957                                   int iStateId, LPCWSTR pszText, int iCharCount,
 958                                   DWORD dwTextFlags, const RECT *pBoundingRect,
 959                                   RECT *pExtentRect)
 960 {
 961     HRESULT hr;
 962     HFONT hFont = NULL;
 963     HGDIOBJ oldFont = NULL;
 964     LOGFONTW logfont;
 965     RECT rt = {0,0,0xFFFF,0xFFFF};
 966
 967     TRACE("%d %d: stub\n", iPartId, iStateId);
 968     if(!hTheme)
 969         return E_HANDLE;
 970
 971     if(pBoundingRect)
 972         CopyRect(&rt, pBoundingRect);
 973
 974     hr = GetThemeFont(hTheme, hdc, iPartId, iStateId, TMT_FONT, &logfont);
 975     if(SUCCEEDED(hr)) {
 976         hFont = CreateFontIndirectW(&logfont);
 977         if(!hFont)
 978             TRACE("Failed to create font\n");
 979     }
 980     if(hFont)
 981         oldFont = SelectObject(hdc, hFont);
 982
 983     DrawTextW(hdc, pszText, iCharCount, &rt, dwTextFlags|DT_CALCRECT);
 984     CopyRect(pExtentRect, &rt);
 985
 986     if(hFont) {
 987         SelectObject(hdc, oldFont);
 988         DeleteObject(hFont);
 989     }
 990     return S_OK;
 991 }
 992
 993 /***********************************************************************
 994  *      GetThemeTextMetrics                                 (UXTHEME.@)
 995  */
 996 HRESULT WINAPI GetThemeTextMetrics(HTHEME hTheme, HDC hdc, int iPartId,
 997                                    int iStateId, TEXTMETRICW *ptm)
 998 {
 999     HRESULT hr;
1000     HFONT hFont = NULL;
1001     HGDIOBJ oldFont = NULL;
1002     LOGFONTW logfont;
1003
1004     TRACE("(%p, %p, %d, %d)\n", hTheme, hdc, iPartId, iStateId);
1005     if(!hTheme)
1006         return E_HANDLE;
1007
1008     hr = GetThemeFont(hTheme, hdc, iPartId, iStateId, TMT_FONT, &logfont);
1009     if(SUCCEEDED(hr)) {
1010         hFont = CreateFontIndirectW(&logfont);
1011         if(!hFont)
1012             TRACE("Failed to create font\n");
1013     }
1014     if(hFont)
1015         oldFont = SelectObject(hdc, hFont);
1016
1017     if(!GetTextMetricsW(hdc, ptm))
1018         hr = HRESULT_FROM_WIN32(GetLastError());
1019
1020     if(hFont) {
1021         SelectObject(hdc, oldFont);
1022         DeleteObject(hFont);
1023     }
1024     return hr;
1025 }
1026
1027 /***********************************************************************
1028  *      IsThemeBackgroundPartiallyTransparent               (UXTHEME.@)
1029  */
1030 BOOL WINAPI IsThemeBackgroundPartiallyTransparent(HTHEME hTheme, int iPartId,
1031                                                   int iStateId)
1032 {
1033     BOOL transparent = FALSE;
1034     TRACE("(%d,%d)\n", iPartId, iStateId);
1035     GetThemeBool(hTheme, iPartId, iStateId, TMT_TRANSPARENT, &transparent);
1036     return transparent;
1037 }