git.oblomov.eu Git - wine/blob - 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 extern ATOM atDialogThemeEnabled;
  45
  46 /***********************************************************************/
  47
  48 /***********************************************************************
  49  *      EnableThemeDialogTexture                            (UXTHEME.@)
  50  */
  51 HRESULT WINAPI EnableThemeDialogTexture(HWND hwnd, DWORD dwFlags)
  52 {
  53     static const WCHAR szTab[] = { 'T','a','b',0 };
  54     HRESULT hr;
  55
  56     TRACE("(%p,0x%08lx\n", hwnd, dwFlags);
  57     hr = SetPropW (hwnd, MAKEINTATOMW (atDialogThemeEnabled),
  58         (HANDLE)(dwFlags|0x80000000));
  59         /* 0x80000000 serves as a "flags set" flag */
  60     if (FAILED(hr))
  61           return hr;
  62     if (dwFlags & ETDT_USETABTEXTURE)
  63         return SetWindowTheme (hwnd, NULL, szTab);
  64     else
  65         return SetWindowTheme (hwnd, NULL, NULL);
  66     return S_OK;
  67  }
  68
  69 /***********************************************************************
  70  *      IsThemeDialogTextureEnabled                         (UXTHEME.@)
  71  */
  72 BOOL WINAPI IsThemeDialogTextureEnabled(HWND hwnd)
  73 {
  74     DWORD dwDialogTextureFlags;
  75     TRACE("(%p)\n", hwnd);
  76
  77     dwDialogTextureFlags = (DWORD)GetPropW (hwnd,
  78         MAKEINTATOMW (atDialogThemeEnabled));
  79     if (dwDialogTextureFlags == 0)
  80         /* Means EnableThemeDialogTexture wasn't called for this dialog */
  81         return TRUE;
  82
  83     return (dwDialogTextureFlags & ETDT_ENABLE) && !(dwDialogTextureFlags & ETDT_DISABLE);
  84 }
  85
  86 /***********************************************************************
  87  *      DrawThemeParentBackground                           (UXTHEME.@)
  88  */
  89 HRESULT WINAPI DrawThemeParentBackground(HWND hwnd, HDC hdc, RECT *prc)
  90 {
  91     RECT rt;
  92     POINT org;
  93     HWND hParent;
  94     HRGN clip = NULL;
  95     int hasClip = -1;
  96
  97     TRACE("(%p,%p,%p)\n", hwnd, hdc, prc);
  98     hParent = GetParent(hwnd);
  99     if(!hParent)
 100         hParent = hwnd;
 101     if(prc) {
 102         CopyRect(&rt, prc);
 103         MapWindowPoints(hwnd, NULL, (LPPOINT)&rt, 2);
 104
 105         clip = CreateRectRgn(0,0,1,1);
 106         hasClip = GetClipRgn(hdc, clip);
 107         if(hasClip == -1)
 108             TRACE("Failed to get original clipping region\n");
 109         else
 110             IntersectClipRect(hdc, prc->left, prc->top, prc->right, prc->bottom);
 111     }
 112     else {
 113         GetClientRect(hParent, &rt);
 114         MapWindowPoints(hParent, NULL, (LPPOINT)&rt, 2);
 115     }
 116
 117     OffsetViewportOrgEx(hdc, -rt.left, -rt.top, &org);
 118
 119     SendMessageW(hParent, WM_ERASEBKGND, (WPARAM)hdc, 0);
 120     SendMessageW(hParent, WM_PRINTCLIENT, (WPARAM)hdc, PRF_CLIENT);
 121
 122     SetViewportOrgEx(hdc, org.x, org.y, NULL);
 123     if(prc) {
 124         if(hasClip == 0)
 125             SelectClipRgn(hdc, NULL);
 126         else if(hasClip == 1)
 127             SelectClipRgn(hdc, clip);
 128         DeleteObject(clip);
 129     }
 130     return S_OK;
 131 }
 132
 133
 134 /***********************************************************************
 135  *      DrawThemeBackground                                 (UXTHEME.@)
 136  */
 137 HRESULT WINAPI DrawThemeBackground(HTHEME hTheme, HDC hdc, int iPartId,
 138                                    int iStateId, const RECT *pRect,
 139                                    const RECT *pClipRect)
 140 {
 141     DTBGOPTS opts;
 142     opts.dwSize = sizeof(DTBGOPTS);
 143     opts.dwFlags = 0;
 144     if(pClipRect) {
 145         opts.dwFlags |= DTBG_CLIPRECT;
 146         CopyRect(&opts.rcClip, pClipRect);
 147     }
 148     return DrawThemeBackgroundEx(hTheme, hdc, iPartId, iStateId, pRect, &opts);
 149 }
 150
 151 /***********************************************************************
 152  *      UXTHEME_SelectImage
 153  *
 154  * Select the image to use
 155  */
 156 static PTHEME_PROPERTY UXTHEME_SelectImage(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, BOOL glyph)
 157 {
 158     PTHEME_PROPERTY tp;
 159     int imageselecttype = IST_NONE;
 160     int i;
 161     int image;
 162     if(glyph)
 163         image = TMT_GLYPHIMAGEFILE;
 164     else
 165         image = TMT_IMAGEFILE;
 166
 167     if((tp=MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, image)))
 168         return tp;
 169     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_IMAGESELECTTYPE, &imageselecttype);
 170
 171     if(imageselecttype == IST_DPI) {
 172         int reqdpi = 0;
 173         int screendpi = GetDeviceCaps(hdc, LOGPIXELSX);
 174         for(i=4; i>=0; i--) {
 175             reqdpi = 0;
 176             if(SUCCEEDED(GetThemeInt(hTheme, iPartId, iStateId, i + TMT_MINDPI1, &reqdpi))) {
 177                 if(reqdpi != 0 && screendpi >= reqdpi) {
 178                     TRACE("Using %d DPI, image %d\n", reqdpi, i + TMT_IMAGEFILE1);
 179                     return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, i + TMT_IMAGEFILE1);
 180                 }
 181             }
 182         }
 183         /* If an image couldn't be selected, choose the first one */
 184         return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, TMT_IMAGEFILE1);
 185     }
 186     else if(imageselecttype == IST_SIZE) {
 187         POINT size = {pRect->right-pRect->left, pRect->bottom-pRect->top};
 188         POINT reqsize;
 189         for(i=4; i>=0; i--) {
 190             PTHEME_PROPERTY fileProp =
 191                 MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, i + TMT_IMAGEFILE1);
 192             if (!fileProp) continue;
 193             if(FAILED(GetThemePosition(hTheme, iPartId, iStateId, i + TMT_MINSIZE1, &reqsize))) {
 194                 /* fall back to size of Nth image */
 195                 WCHAR szPath[MAX_PATH];
 196                 int imagelayout = IL_HORIZONTAL;
 197                 int imagecount = 1;
 198                 int imagenum;
 199                 BITMAP bmp;
 200                 HBITMAP hBmp;
 201                 BOOL hasAlpha;
 202
 203                 lstrcpynW(szPath, fileProp->lpValue,
 204                     min(fileProp->dwValueLen+1, sizeof(szPath)/sizeof(szPath[0])));
 205                 hBmp = MSSTYLES_LoadBitmap(hTheme, szPath, &hasAlpha);
 206                 if(!hBmp) continue;
 207
 208                 GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_IMAGELAYOUT, &imagelayout);
 209                 GetThemeInt(hTheme, iPartId, iStateId, TMT_IMAGECOUNT, &imagecount);
 210
 211                 imagenum = max (min (imagecount, iStateId), 1) - 1;
 212                 GetObjectW(hBmp, sizeof(bmp), &bmp);
 213                 if(imagelayout == IL_VERTICAL) {
 214                     reqsize.x = bmp.bmWidth;
 215                     reqsize.y = bmp.bmHeight/imagecount;
 216                 }
 217                 else {
 218                     reqsize.x = bmp.bmWidth/imagecount;
 219                     reqsize.y = bmp.bmHeight;
 220                 }
 221             }
 222             if(reqsize.x <= size.x && reqsize.y <= size.y) {
 223                 TRACE("Using image size %ldx%ld, image %d\n", reqsize.x, reqsize.y, i + TMT_IMAGEFILE1);
 224                 return fileProp;
 225             }
 226         }
 227         /* If an image couldn't be selected, choose the smallest one */
 228         return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, TMT_IMAGEFILE1);
 229     }
 230     return NULL;
 231 }
 232
 233 /***********************************************************************
 234  *      UXTHEME_LoadImage
 235  *
 236  * Load image for part/state
 237  */
 238 static HRESULT UXTHEME_LoadImage(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, BOOL glyph,
 239                           HBITMAP *hBmp, RECT *bmpRect, BOOL* hasImageAlpha)
 240 {
 241     int imagelayout = IL_HORIZONTAL;
 242     int imagecount = 1;
 243     int imagenum;
 244     BITMAP bmp;
 245     WCHAR szPath[MAX_PATH];
 246     PTHEME_PROPERTY tp = UXTHEME_SelectImage(hTheme, hdc, iPartId, iStateId, pRect, glyph);
 247     if(!tp) {
 248         FIXME("Couldn't determine image for part/state %d/%d, invalid theme?\n", iPartId, iStateId);
 249         return E_PROP_ID_UNSUPPORTED;
 250     }
 251     lstrcpynW(szPath, tp->lpValue, min(tp->dwValueLen+1, sizeof(szPath)/sizeof(szPath[0])));
 252     *hBmp = MSSTYLES_LoadBitmap(hTheme, szPath, hasImageAlpha);
 253     if(!*hBmp) {
 254         TRACE("Failed to load bitmap %s\n", debugstr_w(szPath));
 255         return HRESULT_FROM_WIN32(GetLastError());
 256     }
 257
 258     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_IMAGELAYOUT, &imagelayout);
 259     GetThemeInt(hTheme, iPartId, iStateId, TMT_IMAGECOUNT, &imagecount);
 260
 261     imagenum = max (min (imagecount, iStateId), 1) - 1;
 262     GetObjectW(*hBmp, sizeof(bmp), &bmp);
 263     if(imagelayout == IL_VERTICAL) {
 264         int height = bmp.bmHeight/imagecount;
 265         bmpRect->left = 0;
 266         bmpRect->right = bmp.bmWidth;
 267         bmpRect->top = imagenum * height;
 268         bmpRect->bottom = bmpRect->top + height;
 269     }
 270     else {
 271         int width = bmp.bmWidth/imagecount;
 272         bmpRect->left = imagenum * width;
 273         bmpRect->right = bmpRect->left + width;
 274         bmpRect->top = 0;
 275         bmpRect->bottom = bmp.bmHeight;
 276     }
 277     return S_OK;
 278 }
 279
 280 /***********************************************************************
 281  *      UXTHEME_StretchBlt
 282  *
 283  * Pseudo TransparentBlt/StretchBlt
 284  */
 285 static inline BOOL UXTHEME_StretchBlt(HDC hdcDst, int nXOriginDst, int nYOriginDst, int nWidthDst, int nHeightDst,
 286                                       HDC hdcSrc, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc,
 287                                       INT transparent, COLORREF transcolor)
 288 {
 289     static const BLENDFUNCTION blendFunc =
 290     {
 291       AC_SRC_OVER, /* BlendOp */
 292       0,           /* BlendFlag */
 293       255,         /* SourceConstantAlpha */
 294       AC_SRC_ALPHA /* AlphaFormat */
 295     };
 296     if (transparent == ALPHABLEND_BINARY) {
 297         /* Ensure we don't pass any negative values to TransparentBlt */
 298         return TransparentBlt(hdcDst, nXOriginDst, nYOriginDst, abs(nWidthDst), abs(nHeightDst),
 299                               hdcSrc, nXOriginSrc, nYOriginSrc, abs(nWidthSrc), abs(nHeightSrc),
 300                               transcolor);
 301     }
 302     if ((transparent == ALPHABLEND_NONE) ||
 303         !AlphaBlend(hdcDst, nXOriginDst, nYOriginDst, nWidthDst, nHeightDst,
 304                     hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,
 305                     blendFunc))
 306     {
 307         return StretchBlt(hdcDst, nXOriginDst, nYOriginDst, nWidthDst, nHeightDst,
 308                           hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,
 309                           SRCCOPY);
 310     }
 311     return TRUE;
 312 }
 313
 314 /***********************************************************************
 315  *      UXTHEME_Blt
 316  *
 317  * Simplify sending same width/height for both source and dest
 318  */
 319 static inline BOOL UXTHEME_Blt(HDC hdcDest, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest,
 320                                HDC hdcSrc, int nXOriginSrc, int nYOriginSrc,
 321                                INT transparent, COLORREF transcolor)
 322 {
 323     return UXTHEME_StretchBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
 324                               hdcSrc, nXOriginSrc, nYOriginSrc, nWidthDest, nHeightDest,
 325                               transparent, transcolor);
 326 }
 327
 328 /***********************************************************************
 329  *      UXTHEME_SizedBlt
 330  *
 331  * Stretches or tiles, depending on sizingtype.
 332  */
 333 static inline BOOL UXTHEME_SizedBlt (HDC hdcDst, int nXOriginDst, int nYOriginDst,
 334                                      int nWidthDst, int nHeightDst,
 335                                      HDC hdcSrc, int nXOriginSrc, int nYOriginSrc,
 336                                      int nWidthSrc, int nHeightSrc,
 337                                      int sizingtype,
 338                                      INT transparent, COLORREF transcolor)
 339 {
 340     if (sizingtype == ST_TILE)
 341     {
 342         int yOfs = nYOriginDst;
 343         int yRemaining = nHeightDst;
 344         while (yRemaining > 0)
 345         {
 346             int bltHeight = min (yRemaining, nHeightSrc);
 347             int xOfs = nXOriginDst;
 348             int xRemaining = nWidthDst;
 349             while (xRemaining > 0)
 350             {
 351                 int bltWidth = min (xRemaining, nWidthSrc);
 352                 if (!UXTHEME_Blt (hdcDst, xOfs, yOfs, bltWidth, bltHeight,
 353                                   hdcSrc, nXOriginSrc, nYOriginSrc,
 354                                   transparent, transcolor))
 355                     return FALSE;
 356                 xOfs += nWidthSrc;
 357                 xRemaining -= nWidthSrc;
 358             }
 359             yOfs += nHeightSrc;
 360             yRemaining -= nHeightSrc;
 361         }
 362         return TRUE;
 363     }
 364     else
 365     {
 366         return UXTHEME_StretchBlt (hdcDst, nXOriginDst, nYOriginDst, nWidthDst, nHeightDst,
 367                                    hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,
 368                                    transparent, transcolor);
 369     }
 370 }
 371
 372 /* Get transparency parameters passed to UXTHEME_StretchBlt() - the parameters
 373  * depend on whether the image has full alpha  or whether it is
 374  * color-transparent or just opaque. */
 375 static inline void get_transparency (HTHEME hTheme, int iPartId, int iStateId,
 376                                      BOOL hasImageAlpha, INT* transparent,
 377                                      COLORREF* transparentcolor, BOOL glyph)
 378 {
 379     if (hasImageAlpha)
 380     {
 381         *transparent = ALPHABLEND_FULL;
 382         *transparentcolor = RGB (255, 0, 255);
 383     }
 384     else
 385     {
 386         BOOL trans = FALSE;
 387         GetThemeBool(hTheme, iPartId, iStateId,
 388             glyph ? TMT_GLYPHTRANSPARENT : TMT_TRANSPARENT, &trans);
 389         if(trans) {
 390             *transparent = ALPHABLEND_BINARY;
 391             if(FAILED(GetThemeColor(hTheme, iPartId, iStateId,
 392                 glyph ? TMT_GLYPHTRANSPARENTCOLOR : TMT_TRANSPARENTCOLOR,
 393                 transparentcolor))) {
 394                 /* If image is transparent, but no color was specified, use magenta */
 395                 *transparentcolor = RGB(255, 0, 255);
 396             }
 397         }
 398         else
 399             *transparent = ALPHABLEND_NONE;
 400     }
 401 }
 402
 403 /***********************************************************************
 404  *      UXTHEME_DrawImageGlyph
 405  *
 406  * Draw an imagefile glyph
 407  */
 408 static HRESULT UXTHEME_DrawImageGlyph(HTHEME hTheme, HDC hdc, int iPartId,
 409                                int iStateId, RECT *pRect,
 410                                const DTBGOPTS *pOptions)
 411 {
 412     HRESULT hr;
 413     HBITMAP bmpSrc = NULL;
 414     HDC hdcSrc = NULL;
 415     HGDIOBJ oldSrc = NULL;
 416     RECT rcSrc;
 417     INT transparent = FALSE;
 418     COLORREF transparentcolor;
 419     int valign = VA_CENTER;
 420     int halign = HA_CENTER;
 421     POINT dstSize;
 422     POINT srcSize;
 423     POINT topleft;
 424     BOOL hasAlpha;
 425
 426     hr = UXTHEME_LoadImage(hTheme, hdc, iPartId, iStateId, pRect, TRUE,
 427         &bmpSrc, &rcSrc, &hasAlpha);
 428     if(FAILED(hr)) return hr;
 429     hdcSrc = CreateCompatibleDC(hdc);
 430     if(!hdcSrc) {
 431         hr = HRESULT_FROM_WIN32(GetLastError());
 432         return hr;
 433     }
 434     oldSrc = SelectObject(hdcSrc, bmpSrc);
 435
 436     dstSize.x = pRect->right-pRect->left;
 437     dstSize.y = pRect->bottom-pRect->top;
 438     srcSize.x = rcSrc.right-rcSrc.left;
 439     srcSize.y = rcSrc.bottom-rcSrc.top;
 440
 441     get_transparency (hTheme, iPartId, iStateId, hasAlpha, &transparent,
 442         &transparentcolor, TRUE);
 443     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_VALIGN, &valign);
 444     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_HALIGN, &halign);
 445
 446     topleft.x = pRect->left;
 447     topleft.y = pRect->top;
 448     if(halign == HA_CENTER)      topleft.x += (dstSize.x/2)-(srcSize.x/2);
 449     else if(halign == HA_RIGHT)  topleft.x += dstSize.x-srcSize.x;
 450     if(valign == VA_CENTER)      topleft.y += (dstSize.y/2)-(srcSize.y/2);
 451     else if(valign == VA_BOTTOM) topleft.y += dstSize.y-srcSize.y;
 452
 453     if(!UXTHEME_Blt(hdc, topleft.x, topleft.y, srcSize.x, srcSize.y,
 454                     hdcSrc, rcSrc.left, rcSrc.top,
 455                     transparent, transparentcolor)) {
 456         hr = HRESULT_FROM_WIN32(GetLastError());
 457     }
 458
 459     SelectObject(hdcSrc, oldSrc);
 460     DeleteDC(hdcSrc);
 461     return hr;
 462 }
 463
 464 /***********************************************************************
 465  *      UXTHEME_DrawImageGlyph
 466  *
 467  * Draw glyph on top of background, if appropriate
 468  */
 469 static HRESULT UXTHEME_DrawGlyph(HTHEME hTheme, HDC hdc, int iPartId,
 470                                     int iStateId, RECT *pRect,
 471                                     const DTBGOPTS *pOptions)
 472 {
 473     int glyphtype = GT_NONE;
 474
 475     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_GLYPHTYPE, &glyphtype);
 476
 477     if(glyphtype == GT_IMAGEGLYPH) {
 478         return UXTHEME_DrawImageGlyph(hTheme, hdc, iPartId, iStateId, pRect, pOptions);
 479     }
 480     else if(glyphtype == GT_FONTGLYPH) {
 481         /* I don't know what a font glyph is, I've never seen it used in any themes */
 482         FIXME("Font glyph\n");
 483     }
 484     return S_OK;
 485 }
 486
 487 /***********************************************************************
 488  * get_image_part_size
 489  *
 490  * Used by GetThemePartSize and UXTHEME_DrawImageBackground
 491  */
 492 static HRESULT get_image_part_size (HTHEME hTheme, HDC hdc, int iPartId,
 493                                     int iStateId, RECT *prc, THEMESIZE eSize,
 494                                     POINT *psz)
 495 {
 496     HRESULT hr = S_OK;
 497     HBITMAP bmpSrc;
 498     RECT rcSrc;
 499     BOOL hasAlpha;
 500
 501     hr = UXTHEME_LoadImage(hTheme, hdc, iPartId, iStateId, prc, FALSE,
 502         &bmpSrc, &rcSrc, &hasAlpha);
 503     if (FAILED(hr)) return hr;
 504
 505     switch (eSize)
 506     {
 507         case TS_DRAW:
 508             if (prc != NULL)
 509             {
 510                 RECT rcDst;
 511                 POINT dstSize;
 512                 POINT srcSize;
 513                 int sizingtype = ST_STRETCH;
 514                 BOOL uniformsizing = FALSE;
 515
 516                 CopyRect(&rcDst, prc);
 517
 518                 dstSize.x = rcDst.right-rcDst.left;
 519                 dstSize.y = rcDst.bottom-rcDst.top;
 520                 srcSize.x = rcSrc.right-rcSrc.left;
 521                 srcSize.y = rcSrc.bottom-rcSrc.top;
 522
 523                 GetThemeBool(hTheme, iPartId, iStateId, TMT_UNIFORMSIZING, &uniformsizing);
 524                 if(uniformsizing) {
 525                     /* Scale height and width equally */
 526                     if (dstSize.x*srcSize.y < dstSize.y*srcSize.x)
 527                     {
 528                         dstSize.y = MulDiv (srcSize.y, dstSize.x, srcSize.x);
 529                         rcDst.bottom = rcDst.top + dstSize.y;
 530                     }
 531                     else
 532                     {
 533                         dstSize.x = MulDiv (srcSize.x, dstSize.y, srcSize.y);
 534                         rcDst.right = rcDst.left + dstSize.x;
 535                     }
 536                 }
 537
 538                 GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_SIZINGTYPE, &sizingtype);
 539                 if(sizingtype == ST_TRUESIZE) {
 540                     int truesizestretchmark = 100;
 541
 542                     if(dstSize.x < 0 || dstSize.y < 0) {
 543                         BOOL mirrorimage = TRUE;
 544                         GetThemeBool(hTheme, iPartId, iStateId, TMT_MIRRORIMAGE, &mirrorimage);
 545                         if(mirrorimage) {
 546                             if(dstSize.x < 0) {
 547                                 rcDst.left += dstSize.x;
 548                                 rcDst.right += dstSize.x;
 549                             }
 550                             if(dstSize.y < 0) {
 551                                 rcDst.top += dstSize.y;
 552                                 rcDst.bottom += dstSize.y;
 553                             }
 554                         }
 555                     }
 556                     /* Whatever TrueSizeStretchMark does - it does not seem to
 557                      * be what's outlined below. It appears as if native
 558                      * uxtheme always stretches if dest is smaller than source
 559                      * (ie as if TrueSizeStretchMark==100 with the code below) */
 560 #if 0
 561                     /* Only stretch when target exceeds source by truesizestretchmark percent */
 562                     GetThemeInt(hTheme, iPartId, iStateId, TMT_TRUESIZESTRETCHMARK, &truesizestretchmark);
 563 #endif
 564                     if(dstSize.x < 0 || dstSize.y < 0 ||
 565                       (MulDiv(srcSize.x, 100, dstSize.x) > truesizestretchmark &&
 566                       MulDiv(srcSize.y, 100, dstSize.y) > truesizestretchmark)) {
 567                         memcpy (psz, &dstSize, sizeof (SIZE));
 568                     }
 569                     else {
 570                         memcpy (psz, &srcSize, sizeof (SIZE));
 571                     }
 572                 }
 573                 else
 574                 {
 575                     psz->x = abs(dstSize.x);
 576                     psz->y = abs(dstSize.y);
 577                 }
 578                 break;
 579             }
 580             /* else fall through */
 581         case TS_MIN:
 582             /* FIXME: couldn't figure how native uxtheme computes min size */
 583         case TS_TRUE:
 584             psz->x = rcSrc.right - rcSrc.left;
 585             psz->y = rcSrc.bottom - rcSrc.top;
 586             break;
 587     }
 588     return hr;
 589 }
 590
 591 /***********************************************************************
 592  *      UXTHEME_DrawImageBackground
 593  *
 594  * Draw an imagefile background
 595  */
 596 static HRESULT UXTHEME_DrawImageBackground(HTHEME hTheme, HDC hdc, int iPartId,
 597                                     int iStateId, RECT *pRect,
 598                                     const DTBGOPTS *pOptions)
 599 {
 600     HRESULT hr = S_OK;
 601     HBITMAP bmpSrc;
 602     HGDIOBJ oldSrc;
 603     HDC hdcSrc;
 604     RECT rcSrc;
 605     RECT rcDst;
 606     POINT dstSize;
 607     POINT srcSize;
 608     POINT drawSize;
 609     int sizingtype = ST_STRETCH;
 610     INT transparent;
 611     COLORREF transparentcolor = 0;
 612     BOOL hasAlpha;
 613
 614     hr = UXTHEME_LoadImage(hTheme, hdc, iPartId, iStateId, pRect, FALSE,
 615         &bmpSrc, &rcSrc, &hasAlpha);
 616     if(FAILED(hr)) return hr;
 617     hdcSrc = CreateCompatibleDC(hdc);
 618     if(!hdcSrc) {
 619         hr = HRESULT_FROM_WIN32(GetLastError());
 620         return hr;
 621     }
 622     oldSrc = SelectObject(hdcSrc, bmpSrc);
 623
 624     CopyRect(&rcDst, pRect);
 625
 626     get_transparency (hTheme, iPartId, iStateId, hasAlpha, &transparent,
 627         &transparentcolor, FALSE);
 628
 629     dstSize.x = rcDst.right-rcDst.left;
 630     dstSize.y = rcDst.bottom-rcDst.top;
 631     srcSize.x = rcSrc.right-rcSrc.left;
 632     srcSize.y = rcSrc.bottom-rcSrc.top;
 633
 634     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_SIZINGTYPE, &sizingtype);
 635     if(sizingtype == ST_TRUESIZE) {
 636         int valign = VA_CENTER, halign = HA_CENTER;
 637
 638         get_image_part_size (hTheme, hdc, iPartId, iStateId, pRect, TS_DRAW, &drawSize);
 639         GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_VALIGN, &valign);
 640         GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_HALIGN, &halign);
 641
 642         if (halign == HA_CENTER)
 643             rcDst.left += (dstSize.x/2)-(drawSize.x/2);
 644         else if (halign == HA_RIGHT)
 645             rcDst.left = rcDst.right - drawSize.x;
 646         if (valign == VA_CENTER)
 647             rcDst.top  += (dstSize.y/2)-(drawSize.y/2);
 648         else if (valign == VA_BOTTOM)
 649             rcDst.top = rcDst.bottom - drawSize.y;
 650         rcDst.right = rcDst.left + drawSize.x;
 651         rcDst.bottom = rcDst.top + drawSize.y;
 652         if(!UXTHEME_StretchBlt(hdc, rcDst.left, rcDst.top, drawSize.x, drawSize.y,
 653                                 hdcSrc, rcSrc.left, rcSrc.top, srcSize.x, srcSize.y,
 654                                 transparent, transparentcolor))
 655             hr = HRESULT_FROM_WIN32(GetLastError());
 656     }
 657     else {
 658         HDC hdcDst = NULL;
 659         MARGINS sm;
 660         POINT org;
 661
 662         dstSize.x = abs(dstSize.x);
 663         dstSize.y = abs(dstSize.y);
 664
 665         GetThemeMargins(hTheme, hdc, iPartId, iStateId, TMT_SIZINGMARGINS, NULL, &sm);
 666
 667         hdcDst = hdc;
 668         OffsetViewportOrgEx(hdcDst, rcDst.left, rcDst.top, &org);
 669
 670         /* Upper left corner */
 671         if(!UXTHEME_Blt(hdcDst, 0, 0, sm.cxLeftWidth, sm.cyTopHeight,
 672                         hdcSrc, rcSrc.left, rcSrc.top,
 673                         transparent, transparentcolor)) {
 674             hr = HRESULT_FROM_WIN32(GetLastError());
 675             goto draw_error;
 676         }
 677         /* Upper right corner */
 678         if(!UXTHEME_Blt (hdcDst, dstSize.x-sm.cxRightWidth, 0,
 679                          sm.cxRightWidth, sm.cyTopHeight,
 680                          hdcSrc, rcSrc.right-sm.cxRightWidth, rcSrc.top,
 681                          transparent, transparentcolor)) {
 682             hr = HRESULT_FROM_WIN32(GetLastError());
 683             goto draw_error;
 684         }
 685         /* Lower left corner */
 686         if(!UXTHEME_Blt (hdcDst, 0, dstSize.y-sm.cyBottomHeight,
 687                          sm.cxLeftWidth, sm.cyBottomHeight,
 688                          hdcSrc, rcSrc.left, rcSrc.bottom-sm.cyBottomHeight,
 689                          transparent, transparentcolor)) {
 690             hr = HRESULT_FROM_WIN32(GetLastError());
 691             goto draw_error;
 692         }
 693         /* Lower right corner */
 694         if(!UXTHEME_Blt (hdcDst, dstSize.x-sm.cxRightWidth, dstSize.y-sm.cyBottomHeight,
 695                          sm.cxRightWidth, sm.cyBottomHeight,
 696                          hdcSrc, rcSrc.right-sm.cxRightWidth, rcSrc.bottom-sm.cyBottomHeight,
 697                          transparent, transparentcolor)) {
 698             hr = HRESULT_FROM_WIN32(GetLastError());
 699             goto draw_error;
 700         }
 701
 702         if ((sizingtype == ST_STRETCH) || (sizingtype == ST_TILE)) {
 703             int destCenterWidth  = dstSize.x - (sm.cxLeftWidth + sm.cxRightWidth);
 704             int srcCenterWidth   = srcSize.x - (sm.cxLeftWidth + sm.cxRightWidth);
 705             int destCenterHeight = dstSize.y - (sm.cyTopHeight + sm.cyBottomHeight);
 706             int srcCenterHeight  = srcSize.y - (sm.cyTopHeight + sm.cyBottomHeight);
 707
 708             if(destCenterWidth > 0) {
 709                 /* Center top */
 710                 if(!UXTHEME_SizedBlt (hdcDst, sm.cxLeftWidth, 0,
 711                                       destCenterWidth, sm.cyTopHeight,
 712                                       hdcSrc, rcSrc.left+sm.cxLeftWidth, rcSrc.top,
 713                                       srcCenterWidth, sm.cyTopHeight,
 714                                       sizingtype, transparent, transparentcolor)) {
 715                     hr = HRESULT_FROM_WIN32(GetLastError());
 716                     goto draw_error;
 717                 }
 718                 /* Center bottom */
 719                 if(!UXTHEME_SizedBlt (hdcDst, sm.cxLeftWidth, dstSize.y-sm.cyBottomHeight,
 720                                       destCenterWidth, sm.cyBottomHeight,
 721                                       hdcSrc, rcSrc.left+sm.cxLeftWidth, rcSrc.bottom-sm.cyBottomHeight,
 722                                       srcCenterWidth, sm.cyBottomHeight,
 723                                       sizingtype, transparent, transparentcolor)) {
 724                     hr = HRESULT_FROM_WIN32(GetLastError());
 725                     goto draw_error;
 726                 }
 727             }
 728             if(destCenterHeight > 0) {
 729                 /* Left center */
 730                 if(!UXTHEME_SizedBlt (hdcDst, 0, sm.cyTopHeight,
 731                                       sm.cxLeftWidth, destCenterHeight,
 732                                       hdcSrc, rcSrc.left, rcSrc.top+sm.cyTopHeight,
 733                                       sm.cxLeftWidth, srcCenterHeight,
 734                                       sizingtype,
 735                                       transparent, transparentcolor)) {
 736                     hr = HRESULT_FROM_WIN32(GetLastError());
 737                     goto draw_error;
 738                 }
 739                 /* Right center */
 740                 if(!UXTHEME_SizedBlt (hdcDst, dstSize.x-sm.cxRightWidth, sm.cyTopHeight,
 741                                       sm.cxRightWidth, destCenterHeight,
 742                                       hdcSrc, rcSrc.right-sm.cxRightWidth, rcSrc.top+sm.cyTopHeight,
 743                                       sm.cxRightWidth, srcCenterHeight,
 744                                       sizingtype, transparent, transparentcolor)) {
 745                     hr = HRESULT_FROM_WIN32(GetLastError());
 746                     goto draw_error;
 747                 }
 748             }
 749             if(destCenterHeight > 0 && destCenterWidth > 0) {
 750                 BOOL borderonly = FALSE;
 751                 GetThemeBool(hTheme, iPartId, iStateId, TMT_BORDERONLY, &borderonly);
 752                 if(!borderonly) {
 753                     /* Center */
 754                     if(!UXTHEME_SizedBlt (hdcDst, sm.cxLeftWidth, sm.cyTopHeight,
 755                                           destCenterWidth, destCenterHeight,
 756                                           hdcSrc, rcSrc.left+sm.cxLeftWidth, rcSrc.top+sm.cyTopHeight,
 757                                           srcCenterWidth, srcCenterHeight,
 758                                           sizingtype, transparent, transparentcolor)) {
 759                         hr = HRESULT_FROM_WIN32(GetLastError());
 760                         goto draw_error;
 761                     }
 762                 }
 763             }
 764         }
 765
 766 draw_error:
 767         SetViewportOrgEx (hdcDst, org.x, org.y, NULL);
 768     }
 769     SelectObject(hdcSrc, oldSrc);
 770     DeleteDC(hdcSrc);
 771     CopyRect(pRect, &rcDst);
 772     return hr;
 773 }
 774
 775 /***********************************************************************
 776  *      UXTHEME_DrawBorderRectangle
 777  *
 778  * Draw the bounding rectangle for a borderfill background
 779  */
 780 static HRESULT UXTHEME_DrawBorderRectangle(HTHEME hTheme, HDC hdc, int iPartId,
 781                                     int iStateId, RECT *pRect,
 782                                     const DTBGOPTS *pOptions)
 783 {
 784     HRESULT hr = S_OK;
 785     HPEN hPen;
 786     HGDIOBJ oldPen;
 787     COLORREF bordercolor = RGB(0,0,0);
 788     int bordersize = 1;
 789
 790     GetThemeInt(hTheme, iPartId, iStateId, TMT_BORDERSIZE, &bordersize);
 791     if(bordersize > 0) {
 792         POINT ptCorners[5];
 793         ptCorners[0].x = pRect->left;
 794         ptCorners[0].y = pRect->top;
 795         ptCorners[1].x = pRect->right-1;
 796         ptCorners[1].y = pRect->top;
 797         ptCorners[2].x = pRect->right-1;
 798         ptCorners[2].y = pRect->bottom-1;
 799         ptCorners[3].x = pRect->left;
 800         ptCorners[3].y = pRect->bottom-1;
 801         ptCorners[4].x = pRect->left;
 802         ptCorners[4].y = pRect->top;
 803
 804         InflateRect(pRect, -bordersize, -bordersize);
 805         if(pOptions->dwFlags & DTBG_OMITBORDER)
 806             return S_OK;
 807         GetThemeColor(hTheme, iPartId, iStateId, TMT_BORDERCOLOR, &bordercolor);
 808         hPen = CreatePen(PS_SOLID, bordersize, bordercolor);
 809         if(!hPen)
 810             return HRESULT_FROM_WIN32(GetLastError());
 811         oldPen = SelectObject(hdc, hPen);
 812
 813         if(!Polyline(hdc, ptCorners, 5))
 814             hr = HRESULT_FROM_WIN32(GetLastError());
 815
 816         SelectObject(hdc, oldPen);
 817         DeleteObject(hPen);
 818     }
 819     return hr;
 820 }
 821
 822 /***********************************************************************
 823  *      UXTHEME_DrawBackgroundFill
 824  *
 825  * Fill a borderfill background rectangle
 826  */
 827 static HRESULT UXTHEME_DrawBackgroundFill(HTHEME hTheme, HDC hdc, int iPartId,
 828                                    int iStateId, RECT *pRect,
 829                                    const DTBGOPTS *pOptions)
 830 {
 831     HRESULT hr = S_OK;
 832     int filltype = FT_SOLID;
 833
 834     TRACE("(%d,%d,%ld)\n", iPartId, iStateId, pOptions->dwFlags);
 835
 836     if(pOptions->dwFlags & DTBG_OMITCONTENT)
 837         return S_OK;
 838
 839     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_FILLTYPE, &filltype);
 840
 841     if(filltype == FT_SOLID) {
 842         HBRUSH hBrush;
 843         COLORREF fillcolor = RGB(255,255,255);
 844
 845         GetThemeColor(hTheme, iPartId, iStateId, TMT_FILLCOLOR, &fillcolor);
 846         hBrush = CreateSolidBrush(fillcolor);
 847         if(!FillRect(hdc, pRect, hBrush))
 848             hr = HRESULT_FROM_WIN32(GetLastError());
 849         DeleteObject(hBrush);
 850     }
 851     else if(filltype == FT_VERTGRADIENT || filltype == FT_HORZGRADIENT) {
 852         /* FIXME: This only accounts for 2 gradient colors (out of 5) and ignores
 853             the gradient ratios (no idea how those work)
 854             Few themes use this, and the ones I've seen only use 2 colors with
 855             a gradient ratio of 0 and 255 respectivly
 856         */
 857
 858         COLORREF gradient1 = RGB(0,0,0);
 859         COLORREF gradient2 = RGB(255,255,255);
 860         TRIVERTEX vert[2];
 861         GRADIENT_RECT gRect;
 862
 863         FIXME("Gradient implementation not complete\n");
 864
 865         GetThemeColor(hTheme, iPartId, iStateId, TMT_GRADIENTCOLOR1, &gradient1);
 866         GetThemeColor(hTheme, iPartId, iStateId, TMT_GRADIENTCOLOR2, &gradient2);
 867
 868         vert[0].x     = pRect->left;
 869         vert[0].y     = pRect->top;
 870         vert[0].Red   = GetRValue(gradient1) << 8;
 871         vert[0].Green = GetGValue(gradient1) << 8;
 872         vert[0].Blue  = GetBValue(gradient1) << 8;
 873         vert[0].Alpha = 0x0000;
 874
 875         vert[1].x     = pRect->right;
 876         vert[1].y     = pRect->bottom;
 877         vert[1].Red   = GetRValue(gradient2) << 8;
 878         vert[1].Green = GetGValue(gradient2) << 8;
 879         vert[1].Blue  = GetBValue(gradient2) << 8;
 880         vert[1].Alpha = 0x0000;
 881
 882         gRect.UpperLeft  = 0;
 883         gRect.LowerRight = 1;
 884         GradientFill(hdc,vert,2,&gRect,1,filltype==FT_HORZGRADIENT?GRADIENT_FILL_RECT_H:GRADIENT_FILL_RECT_V);
 885     }
 886     else if(filltype == FT_RADIALGRADIENT) {
 887         /* I've never seen this used in a theme */
 888         FIXME("Radial gradient\n");
 889     }
 890     else if(filltype == FT_TILEIMAGE) {
 891         /* I've never seen this used in a theme */
 892         FIXME("Tile image\n");
 893     }
 894     return hr;
 895 }
 896
 897 /***********************************************************************
 898  *      UXTHEME_DrawBorderBackground
 899  *
 900  * Draw an imagefile background
 901  */
 902 static HRESULT UXTHEME_DrawBorderBackground(HTHEME hTheme, HDC hdc, int iPartId,
 903                                      int iStateId, const RECT *pRect,
 904                                      const DTBGOPTS *pOptions)
 905 {
 906     HRESULT hr;
 907     RECT rt;
 908
 909     CopyRect(&rt, pRect);
 910
 911     hr = UXTHEME_DrawBorderRectangle(hTheme, hdc, iPartId, iStateId, &rt, pOptions);
 912     if(FAILED(hr))
 913         return hr;
 914     return UXTHEME_DrawBackgroundFill(hTheme, hdc, iPartId, iStateId, &rt, pOptions);
 915 }
 916
 917 /***********************************************************************
 918  *      DrawThemeBackgroundEx                               (UXTHEME.@)
 919  */
 920 HRESULT WINAPI DrawThemeBackgroundEx(HTHEME hTheme, HDC hdc, int iPartId,
 921                                      int iStateId, const RECT *pRect,
 922                                      const DTBGOPTS *pOptions)
 923 {
 924     HRESULT hr;
 925     const DTBGOPTS defaultOpts = {sizeof(DTBGOPTS), 0, {0,0,0,0}};
 926     const DTBGOPTS *opts;
 927     HRGN clip = NULL;
 928     int hasClip = -1;
 929     int bgtype = BT_BORDERFILL;
 930     RECT rt;
 931
 932     TRACE("(%p,%p,%d,%d,%ld,%ld)\n", hTheme, hdc, iPartId, iStateId,pRect->left,pRect->top);
 933     if(!hTheme)
 934         return E_HANDLE;
 935
 936     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype);
 937     if (bgtype == BT_NONE) return S_OK;
 938
 939     /* Ensure we have a DTBGOPTS structure available, simplifies some of the code */
 940     opts = pOptions;
 941     if(!opts) opts = &defaultOpts;
 942
 943     if(opts->dwFlags & DTBG_CLIPRECT) {
 944         clip = CreateRectRgn(0,0,1,1);
 945         hasClip = GetClipRgn(hdc, clip);
 946         if(hasClip == -1)
 947             TRACE("Failed to get original clipping region\n");
 948         else
 949             IntersectClipRect(hdc, opts->rcClip.left, opts->rcClip.top, opts->rcClip.right, opts->rcClip.bottom);
 950     }
 951     CopyRect(&rt, pRect);
 952
 953     if(bgtype == BT_IMAGEFILE)
 954         hr = UXTHEME_DrawImageBackground(hTheme, hdc, iPartId, iStateId, &rt, opts);
 955     else if(bgtype == BT_BORDERFILL)
 956         hr = UXTHEME_DrawBorderBackground(hTheme, hdc, iPartId, iStateId, pRect, opts);
 957     else {
 958         FIXME("Unknown background type\n");
 959         /* This should never happen, and hence I don't know what to return */
 960         hr = E_FAIL;
 961     }
 962     if(SUCCEEDED(hr))
 963         hr = UXTHEME_DrawGlyph(hTheme, hdc, iPartId, iStateId, &rt, opts);
 964     if(opts->dwFlags & DTBG_CLIPRECT) {
 965         if(hasClip == 0)
 966             SelectClipRgn(hdc, NULL);
 967         else if(hasClip == 1)
 968             SelectClipRgn(hdc, clip);
 969         DeleteObject(clip);
 970     }
 971     return hr;
 972 }
 973
 974 /*
 975  * DrawThemeEdge() implementation
 976  *
 977  * Since it basically is DrawEdge() with different colors, I copied its code
 978  * from user32's uitools.c.
 979  */
 980
 981 enum
 982 {
 983     EDGE_LIGHT,
 984     EDGE_HIGHLIGHT,
 985     EDGE_SHADOW,
 986     EDGE_DARKSHADOW,
 987     EDGE_FILL,
 988
 989     EDGE_WINDOW,
 990     EDGE_WINDOWFRAME,
 991
 992     EDGE_NUMCOLORS
 993 };
 994
 995 static const struct
 996 {
 997     int themeProp;
 998     int sysColor;
 999 } EdgeColorMap[EDGE_NUMCOLORS] = {
1000     {TMT_EDGELIGHTCOLOR,                  COLOR_3DLIGHT},
1001     {TMT_EDGEHIGHLIGHTCOLOR,              COLOR_BTNHIGHLIGHT},
1002     {TMT_EDGESHADOWCOLOR,                 COLOR_BTNSHADOW},
1003     {TMT_EDGEDKSHADOWCOLOR,               COLOR_3DDKSHADOW},
1004     {TMT_EDGEFILLCOLOR,                   COLOR_BTNFACE},
1005     {-1,                                  COLOR_WINDOW},
1006     {-1,                                  COLOR_WINDOWFRAME}
1007 };
1008
1009 static const signed char LTInnerNormal[] = {
1010     -1,           -1,                 -1,                 -1,
1011     -1,           EDGE_HIGHLIGHT,     EDGE_HIGHLIGHT,     -1,
1012     -1,           EDGE_DARKSHADOW,    EDGE_DARKSHADOW,    -1,
1013     -1,           -1,                 -1,                 -1
1014 };
1015
1016 static const signed char LTOuterNormal[] = {
1017     -1,                 EDGE_LIGHT,     EDGE_SHADOW, -1,
1018     EDGE_HIGHLIGHT,     EDGE_LIGHT,     EDGE_SHADOW, -1,
1019     EDGE_DARKSHADOW,    EDGE_LIGHT,     EDGE_SHADOW, -1,
1020     -1,                 EDGE_LIGHT,     EDGE_SHADOW, -1
1021 };
1022
1023 static const signed char RBInnerNormal[] = {
1024     -1,           -1,                 -1,               -1,
1025     -1,           EDGE_SHADOW,        EDGE_SHADOW,      -1,
1026     -1,           EDGE_LIGHT,         EDGE_LIGHT,       -1,
1027     -1,           -1,                 -1,               -1
1028 };
1029
1030 static const signed char RBOuterNormal[] = {
1031     -1,               EDGE_DARKSHADOW,  EDGE_HIGHLIGHT, -1,
1032     EDGE_SHADOW,      EDGE_DARKSHADOW,  EDGE_HIGHLIGHT, -1,
1033     EDGE_LIGHT,       EDGE_DARKSHADOW,  EDGE_HIGHLIGHT, -1,
1034     -1,               EDGE_DARKSHADOW,  EDGE_HIGHLIGHT, -1
1035 };
1036
1037 static const signed char LTInnerSoft[] = {
1038     -1,                  -1,                -1,               -1,
1039     -1,                  EDGE_LIGHT,        EDGE_LIGHT,       -1,
1040     -1,                  EDGE_SHADOW,       EDGE_SHADOW,      -1,
1041     -1,                  -1,                -1,               -1
1042 };
1043
1044 static const signed char LTOuterSoft[] = {
1045     -1,               EDGE_HIGHLIGHT, EDGE_DARKSHADOW, -1,
1046     EDGE_LIGHT,       EDGE_HIGHLIGHT, EDGE_DARKSHADOW, -1,
1047     EDGE_SHADOW,      EDGE_HIGHLIGHT, EDGE_DARKSHADOW, -1,
1048     -1,               EDGE_HIGHLIGHT, EDGE_DARKSHADOW, -1
1049 };
1050
1051 #define RBInnerSoft RBInnerNormal   /* These are the same */
1052 #define RBOuterSoft RBOuterNormal
1053
1054 static const signed char LTRBOuterMono[] = {
1055     -1,           EDGE_WINDOWFRAME, EDGE_WINDOWFRAME, EDGE_WINDOWFRAME,
1056     EDGE_WINDOW,  EDGE_WINDOWFRAME, EDGE_WINDOWFRAME, EDGE_WINDOWFRAME,
1057     EDGE_WINDOW,  EDGE_WINDOWFRAME, EDGE_WINDOWFRAME, EDGE_WINDOWFRAME,
1058     EDGE_WINDOW,  EDGE_WINDOWFRAME, EDGE_WINDOWFRAME, EDGE_WINDOWFRAME,
1059 };
1060
1061 static const signed char LTRBInnerMono[] = {
1062     -1, -1,           -1,           -1,
1063     -1, EDGE_WINDOW,  EDGE_WINDOW,  EDGE_WINDOW,
1064     -1, EDGE_WINDOW,  EDGE_WINDOW,  EDGE_WINDOW,
1065     -1, EDGE_WINDOW,  EDGE_WINDOW,  EDGE_WINDOW,
1066 };
1067
1068 static const signed char LTRBOuterFlat[] = {
1069     -1,                 EDGE_SHADOW, EDGE_SHADOW, EDGE_SHADOW,
1070     EDGE_FILL,          EDGE_SHADOW, EDGE_SHADOW, EDGE_SHADOW,
1071     EDGE_FILL,          EDGE_SHADOW, EDGE_SHADOW, EDGE_SHADOW,
1072     EDGE_FILL,          EDGE_SHADOW, EDGE_SHADOW, EDGE_SHADOW,
1073 };
1074
1075 static const signed char LTRBInnerFlat[] = {
1076     -1, -1,               -1,               -1,
1077     -1, EDGE_FILL,        EDGE_FILL,        EDGE_FILL,
1078     -1, EDGE_FILL,        EDGE_FILL,        EDGE_FILL,
1079     -1, EDGE_FILL,        EDGE_FILL,        EDGE_FILL,
1080 };
1081
1082 static COLORREF get_edge_color (int edgeType, HTHEME theme, int part, int state)
1083 {
1084     COLORREF col;
1085     if ((EdgeColorMap[edgeType].themeProp == -1)
1086         || FAILED (GetThemeColor (theme, part, state,
1087             EdgeColorMap[edgeType].themeProp, &col)))
1088         col = GetSysColor (EdgeColorMap[edgeType].sysColor);
1089     return col;
1090 }
1091
1092 static inline HPEN get_edge_pen (int edgeType, HTHEME theme, int part, int state)
1093 {
1094     return CreatePen (PS_SOLID, 1, get_edge_color (edgeType, theme, part, state));
1095 }
1096
1097 static inline HBRUSH get_edge_brush (int edgeType, HTHEME theme, int part, int state)
1098 {
1099     return CreateSolidBrush (get_edge_color (edgeType, theme, part, state));
1100 }
1101
1102 /***********************************************************************
1103  *           draw_diag_edge
1104  *
1105  * Same as DrawEdge invoked with BF_DIAGONAL
1106  */
1107 static HRESULT draw_diag_edge (HDC hdc, HTHEME theme, int part, int state,
1108                                const RECT* rc, UINT uType,
1109                                UINT uFlags, LPRECT contentsRect)
1110 {
1111     POINT Points[4];
1112     signed char InnerI, OuterI;
1113     HPEN InnerPen, OuterPen;
1114     POINT SavePoint;
1115     HPEN SavePen;
1116     int spx, spy;
1117     int epx, epy;
1118     int Width = rc->right - rc->left;
1119     int Height= rc->bottom - rc->top;
1120     int SmallDiam = Width > Height ? Height : Width;
1121     HRESULT retval = (((uType & BDR_INNER) == BDR_INNER
1122                        || (uType & BDR_OUTER) == BDR_OUTER)
1123                       && !(uFlags & (BF_FLAT|BF_MONO)) ) ? E_FAIL : S_OK;
1124     int add = (LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0)
1125             + (LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0);
1126
1127     /* Init some vars */
1128     OuterPen = InnerPen = (HPEN)GetStockObject(NULL_PEN);
1129     SavePen = (HPEN)SelectObject(hdc, InnerPen);
1130     spx = spy = epx = epy = 0; /* Satisfy the compiler... */
1131
1132     /* Determine the colors of the edges */
1133     if(uFlags & BF_MONO)
1134     {
1135         InnerI = LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)];
1136         OuterI = LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)];
1137     }
1138     else if(uFlags & BF_FLAT)
1139     {
1140         InnerI = LTRBInnerFlat[uType & (BDR_INNER|BDR_OUTER)];
1141         OuterI = LTRBOuterFlat[uType & (BDR_INNER|BDR_OUTER)];
1142     }
1143     else if(uFlags & BF_SOFT)
1144     {
1145         if(uFlags & BF_BOTTOM)
1146         {
1147             InnerI = RBInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
1148             OuterI = RBOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
1149         }
1150         else
1151         {
1152             InnerI = LTInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
1153             OuterI = LTOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
1154         }
1155     }
1156     else
1157     {
1158         if(uFlags & BF_BOTTOM)
1159         {
1160             InnerI = RBInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
1161             OuterI = RBOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
1162         }
1163         else
1164         {
1165             InnerI = LTInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
1166             OuterI = LTOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
1167         }
1168     }
1169
1170     if(InnerI != -1) InnerPen = get_edge_pen (InnerI, theme, part, state);
1171     if(OuterI != -1) OuterPen = get_edge_pen (OuterI, theme, part, state);
1172
1173     MoveToEx(hdc, 0, 0, &SavePoint);
1174
1175     /* Don't ask me why, but this is what is visible... */
1176     /* This must be possible to do much simpler, but I fail to */
1177     /* see the logic in the MS implementation (sigh...). */
1178     /* So, this might look a bit brute force here (and it is), but */
1179     /* it gets the job done;) */
1180
1181     switch(uFlags & BF_RECT)
1182     {
1183     case 0:
1184     case BF_LEFT:
1185     case BF_BOTTOM:
1186     case BF_BOTTOMLEFT:
1187         /* Left bottom endpoint */
1188         epx = rc->left-1;
1189         spx = epx + SmallDiam;
1190         epy = rc->bottom;
1191         spy = epy - SmallDiam;
1192         break;
1193
1194     case BF_TOPLEFT:
1195     case BF_BOTTOMRIGHT:
1196         /* Left top endpoint */
1197         epx = rc->left-1;
1198         spx = epx + SmallDiam;
1199         epy = rc->top-1;
1200         spy = epy + SmallDiam;
1201         break;
1202
1203     case BF_TOP:
1204     case BF_RIGHT:
1205     case BF_TOPRIGHT:
1206     case BF_RIGHT|BF_LEFT:
1207     case BF_RIGHT|BF_LEFT|BF_TOP:
1208     case BF_BOTTOM|BF_TOP:
1209     case BF_BOTTOM|BF_TOP|BF_LEFT:
1210     case BF_BOTTOMRIGHT|BF_LEFT:
1211     case BF_BOTTOMRIGHT|BF_TOP:
1212     case BF_RECT:
1213         /* Right top endpoint */
1214         spx = rc->left;
1215         epx = spx + SmallDiam;
1216         spy = rc->bottom-1;
1217         epy = spy - SmallDiam;
1218         break;
1219     }
1220
1221     MoveToEx(hdc, spx, spy, NULL);
1222     SelectObject(hdc, OuterPen);
1223     LineTo(hdc, epx, epy);
1224
1225     SelectObject(hdc, InnerPen);
1226
1227     switch(uFlags & (BF_RECT|BF_DIAGONAL))
1228     {
1229     case BF_DIAGONAL_ENDBOTTOMLEFT:
1230     case (BF_DIAGONAL|BF_BOTTOM):
1231     case BF_DIAGONAL:
1232     case (BF_DIAGONAL|BF_LEFT):
1233         MoveToEx(hdc, spx-1, spy, NULL);
1234         LineTo(hdc, epx, epy-1);
1235         Points[0].x = spx-add;
1236         Points[0].y = spy;
1237         Points[1].x = rc->left;
1238         Points[1].y = rc->top;
1239         Points[2].x = epx+1;
1240         Points[2].y = epy-1-add;
1241         Points[3] = Points[2];
1242         break;
1243
1244     case BF_DIAGONAL_ENDBOTTOMRIGHT:
1245         MoveToEx(hdc, spx-1, spy, NULL);
1246         LineTo(hdc, epx, epy+1);
1247         Points[0].x = spx-add;
1248         Points[0].y = spy;
1249         Points[1].x = rc->left;
1250         Points[1].y = rc->bottom-1;
1251         Points[2].x = epx+1;
1252         Points[2].y = epy+1+add;
1253         Points[3] = Points[2];
1254         break;
1255
1256     case (BF_DIAGONAL|BF_BOTTOM|BF_RIGHT|BF_TOP):
1257     case (BF_DIAGONAL|BF_BOTTOM|BF_RIGHT|BF_TOP|BF_LEFT):
1258     case BF_DIAGONAL_ENDTOPRIGHT:
1259     case (BF_DIAGONAL|BF_RIGHT|BF_TOP|BF_LEFT):
1260         MoveToEx(hdc, spx+1, spy, NULL);
1261         LineTo(hdc, epx, epy+1);
1262         Points[0].x = epx-1;
1263         Points[0].y = epy+1+add;
1264         Points[1].x = rc->right-1;
1265         Points[1].y = rc->top+add;
1266         Points[2].x = rc->right-1;
1267         Points[2].y = rc->bottom-1;
1268         Points[3].x = spx+add;
1269         Points[3].y = spy;
1270         break;
1271
1272     case BF_DIAGONAL_ENDTOPLEFT:
1273         MoveToEx(hdc, spx, spy-1, NULL);
1274         LineTo(hdc, epx+1, epy);
1275         Points[0].x = epx+1+add;
1276         Points[0].y = epy+1;
1277         Points[1].x = rc->right-1;
1278         Points[1].y = rc->top;
1279         Points[2].x = rc->right-1;
1280         Points[2].y = rc->bottom-1-add;
1281         Points[3].x = spx;
1282         Points[3].y = spy-add;
1283         break;
1284
1285     case (BF_DIAGONAL|BF_TOP):
1286     case (BF_DIAGONAL|BF_BOTTOM|BF_TOP):
1287     case (BF_DIAGONAL|BF_BOTTOM|BF_TOP|BF_LEFT):
1288         MoveToEx(hdc, spx+1, spy-1, NULL);
1289         LineTo(hdc, epx, epy);
1290         Points[0].x = epx-1;
1291         Points[0].y = epy+1;
1292         Points[1].x = rc->right-1;
1293         Points[1].y = rc->top;
1294         Points[2].x = rc->right-1;
1295         Points[2].y = rc->bottom-1-add;
1296         Points[3].x = spx+add;
1297         Points[3].y = spy-add;
1298         break;
1299
1300     case (BF_DIAGONAL|BF_RIGHT):
1301     case (BF_DIAGONAL|BF_RIGHT|BF_LEFT):
1302     case (BF_DIAGONAL|BF_RIGHT|BF_LEFT|BF_BOTTOM):
1303         MoveToEx(hdc, spx, spy, NULL);
1304         LineTo(hdc, epx-1, epy+1);
1305         Points[0].x = spx;
1306         Points[0].y = spy;
1307         Points[1].x = rc->left;
1308         Points[1].y = rc->top+add;
1309         Points[2].x = epx-1-add;
1310         Points[2].y = epy+1+add;
1311         Points[3] = Points[2];
1312         break;
1313     }
1314
1315     /* Fill the interior if asked */
1316     if((uFlags & BF_MIDDLE) && retval)
1317     {
1318         HBRUSH hbsave;
1319         HBRUSH hb = get_edge_brush ((uFlags & BF_MONO) ? EDGE_WINDOW : EDGE_FILL,
1320             theme, part, state);
1321         HPEN hpsave;
1322         HPEN hp = get_edge_pen ((uFlags & BF_MONO) ? EDGE_WINDOW : EDGE_FILL,
1323             theme, part, state);
1324         hbsave = (HBRUSH)SelectObject(hdc, hb);
1325         hpsave = (HPEN)SelectObject(hdc, hp);
1326         Polygon(hdc, Points, 4);
1327         SelectObject(hdc, hbsave);
1328         SelectObject(hdc, hpsave);
1329         DeleteObject (hp);
1330         DeleteObject (hb);
1331     }
1332
1333     /* Adjust rectangle if asked */
1334     if(uFlags & BF_ADJUST)
1335     {
1336         *contentsRect = *rc;
1337         if(uFlags & BF_LEFT)   contentsRect->left   += add;
1338         if(uFlags & BF_RIGHT)  contentsRect->right  -= add;
1339         if(uFlags & BF_TOP)    contentsRect->top    += add;
1340         if(uFlags & BF_BOTTOM) contentsRect->bottom -= add;
1341     }
1342
1343     /* Cleanup */
1344     SelectObject(hdc, SavePen);
1345     MoveToEx(hdc, SavePoint.x, SavePoint.y, NULL);
1346     if(InnerI != -1) DeleteObject (InnerPen);
1347     if(OuterI != -1) DeleteObject (OuterPen);
1348
1349     return retval;
1350 }
1351
1352 /***********************************************************************
1353  *           draw_rect_edge
1354  *
1355  * Same as DrawEdge invoked without BF_DIAGONAL
1356  */
1357 static HRESULT draw_rect_edge (HDC hdc, HTHEME theme, int part, int state,
1358                                const RECT* rc, UINT uType,
1359                                UINT uFlags, LPRECT contentsRect)
1360 {
1361     signed char LTInnerI, LTOuterI;
1362     signed char RBInnerI, RBOuterI;
1363     HPEN LTInnerPen, LTOuterPen;
1364     HPEN RBInnerPen, RBOuterPen;
1365     RECT InnerRect = *rc;
1366     POINT SavePoint;
1367     HPEN SavePen;
1368     int LBpenplus = 0;
1369     int LTpenplus = 0;
1370     int RTpenplus = 0;
1371     int RBpenplus = 0;
1372     HRESULT retval = (((uType & BDR_INNER) == BDR_INNER
1373                        || (uType & BDR_OUTER) == BDR_OUTER)
1374                       && !(uFlags & (BF_FLAT|BF_MONO)) ) ? E_FAIL : S_OK;
1375
1376     /* Init some vars */
1377     LTInnerPen = LTOuterPen = RBInnerPen = RBOuterPen = (HPEN)GetStockObject(NULL_PEN);
1378     SavePen = (HPEN)SelectObject(hdc, LTInnerPen);
1379
1380     /* Determine the colors of the edges */
1381     if(uFlags & BF_MONO)
1382     {
1383         LTInnerI = RBInnerI = LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)];
1384         LTOuterI = RBOuterI = LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)];
1385     }
1386     else if(uFlags & BF_FLAT)
1387     {
1388         LTInnerI = RBInnerI = LTRBInnerFlat[uType & (BDR_INNER|BDR_OUTER)];
1389         LTOuterI = RBOuterI = LTRBOuterFlat[uType & (BDR_INNER|BDR_OUTER)];
1390
1391         if( LTInnerI != -1 ) LTInnerI = RBInnerI = COLOR_BTNFACE;
1392     }
1393     else if(uFlags & BF_SOFT)
1394     {
1395         LTInnerI = LTInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
1396         LTOuterI = LTOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
1397         RBInnerI = RBInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
1398         RBOuterI = RBOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
1399     }
1400     else
1401     {
1402         LTInnerI = LTInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
1403         LTOuterI = LTOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
1404         RBInnerI = RBInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
1405         RBOuterI = RBOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
1406     }
1407
1408     if((uFlags & BF_BOTTOMLEFT) == BF_BOTTOMLEFT)   LBpenplus = 1;
1409     if((uFlags & BF_TOPRIGHT) == BF_TOPRIGHT)       RTpenplus = 1;
1410     if((uFlags & BF_BOTTOMRIGHT) == BF_BOTTOMRIGHT) RBpenplus = 1;
1411     if((uFlags & BF_TOPLEFT) == BF_TOPLEFT)         LTpenplus = 1;
1412
1413     if(LTInnerI != -1) LTInnerPen = get_edge_pen (LTInnerI, theme, part, state);
1414     if(LTOuterI != -1) LTOuterPen = get_edge_pen (LTOuterI, theme, part, state);
1415     if(RBInnerI != -1) RBInnerPen = get_edge_pen (RBInnerI, theme, part, state);
1416     if(RBOuterI != -1) RBOuterPen = get_edge_pen (RBOuterI, theme, part, state);
1417
1418     MoveToEx(hdc, 0, 0, &SavePoint);
1419
1420     /* Draw the outer edge */
1421     SelectObject(hdc, LTOuterPen);
1422     if(uFlags & BF_TOP)
1423     {
1424         MoveToEx(hdc, InnerRect.left, InnerRect.top, NULL);
1425         LineTo(hdc, InnerRect.right, InnerRect.top);
1426     }
1427     if(uFlags & BF_LEFT)
1428     {
1429         MoveToEx(hdc, InnerRect.left, InnerRect.top, NULL);
1430         LineTo(hdc, InnerRect.left, InnerRect.bottom);
1431     }
1432     SelectObject(hdc, RBOuterPen);
1433     if(uFlags & BF_BOTTOM)
1434     {
1435         MoveToEx(hdc, InnerRect.right-1, InnerRect.bottom-1, NULL);
1436         LineTo(hdc, InnerRect.left-1, InnerRect.bottom-1);
1437     }
1438     if(uFlags & BF_RIGHT)
1439     {
1440         MoveToEx(hdc, InnerRect.right-1, InnerRect.bottom-1, NULL);
1441         LineTo(hdc, InnerRect.right-1, InnerRect.top-1);
1442     }
1443
1444     /* Draw the inner edge */
1445     SelectObject(hdc, LTInnerPen);
1446     if(uFlags & BF_TOP)
1447     {
1448         MoveToEx(hdc, InnerRect.left+LTpenplus, InnerRect.top+1, NULL);
1449         LineTo(hdc, InnerRect.right-RTpenplus, InnerRect.top+1);
1450     }
1451     if(uFlags & BF_LEFT)
1452     {
1453         MoveToEx(hdc, InnerRect.left+1, InnerRect.top+LTpenplus, NULL);
1454         LineTo(hdc, InnerRect.left+1, InnerRect.bottom-LBpenplus);
1455     }
1456     SelectObject(hdc, RBInnerPen);
1457     if(uFlags & BF_BOTTOM)
1458     {
1459         MoveToEx(hdc, InnerRect.right-1-RBpenplus, InnerRect.bottom-2, NULL);
1460         LineTo(hdc, InnerRect.left-1+LBpenplus, InnerRect.bottom-2);
1461     }
1462     if(uFlags & BF_RIGHT)
1463     {
1464         MoveToEx(hdc, InnerRect.right-2, InnerRect.bottom-1-RBpenplus, NULL);
1465         LineTo(hdc, InnerRect.right-2, InnerRect.top-1+RTpenplus);
1466     }
1467
1468     if( ((uFlags & BF_MIDDLE) && retval) || (uFlags & BF_ADJUST) )
1469     {
1470         int add = (LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0)
1471                 + (LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0);
1472
1473         if(uFlags & BF_LEFT)   InnerRect.left   += add;
1474         if(uFlags & BF_RIGHT)  InnerRect.right  -= add;
1475         if(uFlags & BF_TOP)    InnerRect.top    += add;
1476         if(uFlags & BF_BOTTOM) InnerRect.bottom -= add;
1477
1478         if((uFlags & BF_MIDDLE) && retval)
1479         {
1480             HBRUSH br = get_edge_brush ((uFlags & BF_MONO) ? EDGE_WINDOW : EDGE_FILL,
1481                 theme, part, state);
1482             FillRect(hdc, &InnerRect, br);
1483             DeleteObject (br);
1484         }
1485
1486         if(uFlags & BF_ADJUST)
1487             *contentsRect = InnerRect;
1488     }
1489
1490     /* Cleanup */
1491     SelectObject(hdc, SavePen);
1492     MoveToEx(hdc, SavePoint.x, SavePoint.y, NULL);
1493     if(LTInnerI != -1) DeleteObject (LTInnerPen);
1494     if(LTOuterI != -1) DeleteObject (LTOuterPen);
1495     if(RBInnerI != -1) DeleteObject (RBInnerPen);
1496     if(RBOuterI != -1) DeleteObject (RBOuterPen);
1497     return retval;
1498 }
1499
1500
1501 /***********************************************************************
1502  *      DrawThemeEdge                                       (UXTHEME.@)
1503  *
1504  * DrawThemeEdge() is pretty similar to the vanilla DrawEdge() - the
1505  * difference is that it does not rely on the system colors alone, but
1506  * also allows color specification in the theme.
1507  */
1508 HRESULT WINAPI DrawThemeEdge(HTHEME hTheme, HDC hdc, int iPartId,
1509                              int iStateId, const RECT *pDestRect, UINT uEdge,
1510                              UINT uFlags, RECT *pContentRect)
1511 {
1512     TRACE("%d %d 0x%08x 0x%08x\n", iPartId, iStateId, uEdge, uFlags);
1513     if(!hTheme)
1514         return E_HANDLE;
1515
1516     if(uFlags & BF_DIAGONAL)
1517         return draw_diag_edge (hdc, hTheme, iPartId, iStateId, pDestRect,
1518             uEdge, uFlags, pContentRect);
1519     else
1520         return draw_rect_edge (hdc, hTheme, iPartId, iStateId, pDestRect,
1521             uEdge, uFlags, pContentRect);
1522 }
1523
1524
1525 /***********************************************************************
1526  *      DrawThemeIcon                                       (UXTHEME.@)
1527  */
1528 HRESULT WINAPI DrawThemeIcon(HTHEME hTheme, HDC hdc, int iPartId, int iStateId,
1529                              const RECT *pRect, HIMAGELIST himl, int iImageIndex)
1530 {
1531     FIXME("%d %d: stub\n", iPartId, iStateId);
1532     if(!hTheme)
1533         return E_HANDLE;
1534     return ERROR_CALL_NOT_IMPLEMENTED;
1535 }
1536
1537 /***********************************************************************
1538  *      DrawThemeText                                       (UXTHEME.@)
1539  */
1540 HRESULT WINAPI DrawThemeText(HTHEME hTheme, HDC hdc, int iPartId, int iStateId,
1541                              LPCWSTR pszText, int iCharCount, DWORD dwTextFlags,
1542                              DWORD dwTextFlags2, const RECT *pRect)
1543 {
1544     HRESULT hr;
1545     HFONT hFont = NULL;
1546     HGDIOBJ oldFont = NULL;
1547     LOGFONTW logfont;
1548     COLORREF textColor;
1549     COLORREF oldTextColor;
1550     int oldBkMode;
1551     RECT rt;
1552
1553     TRACE("%d %d: stub\n", iPartId, iStateId);
1554     if(!hTheme)
1555         return E_HANDLE;
1556
1557     hr = GetThemeFont(hTheme, hdc, iPartId, iStateId, TMT_FONT, &logfont);
1558     if(SUCCEEDED(hr)) {
1559         hFont = CreateFontIndirectW(&logfont);
1560         if(!hFont)
1561             TRACE("Failed to create font\n");
1562     }
1563     CopyRect(&rt, pRect);
1564     if(hFont)
1565         oldFont = SelectObject(hdc, hFont);
1566
1567     if(dwTextFlags2 & DTT_GRAYED)
1568         textColor = GetSysColor(COLOR_GRAYTEXT);
1569     else {
1570         if(FAILED(GetThemeColor(hTheme, iPartId, iStateId, TMT_TEXTCOLOR, &textColor)))
1571             textColor = GetTextColor(hdc);
1572     }
1573     oldTextColor = SetTextColor(hdc, textColor);
1574     oldBkMode = SetBkMode(hdc, TRANSPARENT);
1575     DrawTextW(hdc, pszText, iCharCount, &rt, dwTextFlags);
1576     SetBkMode(hdc, oldBkMode);
1577     SetTextColor(hdc, oldTextColor);
1578
1579     if(hFont) {
1580         SelectObject(hdc, oldFont);
1581         DeleteObject(hFont);
1582     }
1583     return S_OK;
1584 }
1585
1586 /***********************************************************************
1587  *      GetThemeBackgroundContentRect                       (UXTHEME.@)
1588  */
1589 HRESULT WINAPI GetThemeBackgroundContentRect(HTHEME hTheme, HDC hdc, int iPartId,
1590                                              int iStateId,
1591                                              const RECT *pBoundingRect,
1592                                              RECT *pContentRect)
1593 {
1594     MARGINS margin;
1595     HRESULT hr;
1596
1597     TRACE("(%d,%d)\n", iPartId, iStateId);
1598     if(!hTheme)
1599         return E_HANDLE;
1600
1601     /* try content margins property... */
1602     hr = GetThemeMargins(hTheme, hdc, iPartId, iStateId, TMT_CONTENTMARGINS, NULL, &margin);
1603     if(SUCCEEDED(hr)) {
1604         pContentRect->left = pBoundingRect->left + margin.cxLeftWidth;
1605         pContentRect->top  = pBoundingRect->top + margin.cyTopHeight;
1606         pContentRect->right = pBoundingRect->right - margin.cxRightWidth;
1607         pContentRect->bottom = pBoundingRect->bottom - margin.cyBottomHeight;
1608     } else {
1609         /* otherwise, try to determine content rect from the background type and props */
1610         int bgtype = BT_BORDERFILL;
1611         memcpy(pContentRect, pBoundingRect, sizeof(RECT));
1612
1613         GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype);
1614         if(bgtype == BT_BORDERFILL) {
1615             int bordersize = 1;
1616
1617             GetThemeInt(hTheme, iPartId, iStateId, TMT_BORDERSIZE, &bordersize);
1618             InflateRect(pContentRect, -bordersize, -bordersize);
1619         } else if ((bgtype == BT_IMAGEFILE)
1620                 && (SUCCEEDED(hr = GetThemeMargins(hTheme, hdc, iPartId, iStateId,
1621                 TMT_SIZINGMARGINS, NULL, &margin)))) {
1622             pContentRect->left = pBoundingRect->left + margin.cxLeftWidth;
1623             pContentRect->top  = pBoundingRect->top + margin.cyTopHeight;
1624             pContentRect->right = pBoundingRect->right - margin.cxRightWidth;
1625             pContentRect->bottom = pBoundingRect->bottom - margin.cyBottomHeight;
1626         }
1627         /* If nothing was found, leave unchanged */
1628     }
1629
1630     TRACE("left:%ld,top:%ld,right:%ld,bottom:%ld\n", pContentRect->left, pContentRect->top, pContentRect->right, pContentRect->bottom);
1631
1632     return S_OK;
1633 }
1634
1635 /***********************************************************************
1636  *      GetThemeBackgroundExtent                            (UXTHEME.@)
1637  */
1638 HRESULT WINAPI GetThemeBackgroundExtent(HTHEME hTheme, HDC hdc, int iPartId,
1639                                         int iStateId, const RECT *pContentRect,
1640                                         RECT *pExtentRect)
1641 {
1642     MARGINS margin;
1643     HRESULT hr;
1644
1645     TRACE("(%d,%d)\n", iPartId, iStateId);
1646     if(!hTheme)
1647         return E_HANDLE;
1648
1649     /* try content margins property... */
1650     hr = GetThemeMargins(hTheme, hdc, iPartId, iStateId, TMT_CONTENTMARGINS, NULL, &margin);
1651     if(SUCCEEDED(hr)) {
1652         pExtentRect->left = pContentRect->left - margin.cxLeftWidth;
1653         pExtentRect->top  = pContentRect->top - margin.cyTopHeight;
1654         pExtentRect->right = pContentRect->right + margin.cxRightWidth;
1655         pExtentRect->bottom = pContentRect->bottom + margin.cyBottomHeight;
1656     } else {
1657         /* otherwise, try to determine content rect from the background type and props */
1658         int bgtype = BT_BORDERFILL;
1659         memcpy(pExtentRect, pContentRect, sizeof(RECT));
1660
1661         GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype);
1662         if(bgtype == BT_BORDERFILL) {
1663             int bordersize = 1;
1664
1665             GetThemeInt(hTheme, iPartId, iStateId, TMT_BORDERSIZE, &bordersize);
1666             InflateRect(pExtentRect, bordersize, bordersize);
1667         } else if ((bgtype == BT_IMAGEFILE)
1668                 && (SUCCEEDED(hr = GetThemeMargins(hTheme, hdc, iPartId, iStateId,
1669                 TMT_SIZINGMARGINS, NULL, &margin)))) {
1670             pExtentRect->left = pContentRect->left - margin.cxLeftWidth;
1671             pExtentRect->top  = pContentRect->top - margin.cyTopHeight;
1672             pExtentRect->right = pContentRect->right + margin.cxRightWidth;
1673             pExtentRect->bottom = pContentRect->bottom + margin.cyBottomHeight;
1674         }
1675         /* If nothing was found, leave unchanged */
1676     }
1677
1678     TRACE("left:%ld,top:%ld,right:%ld,bottom:%ld\n", pExtentRect->left, pExtentRect->top, pExtentRect->right, pExtentRect->bottom);
1679
1680     return S_OK;
1681 }
1682
1683 /***********************************************************************
1684  *      GetThemeBackgroundRegion                            (UXTHEME.@)
1685  *
1686  * Calculate the background region, taking into consideration transparent areas
1687  * of the background image.
1688  */
1689 HRESULT WINAPI GetThemeBackgroundRegion(HTHEME hTheme, HDC hdc, int iPartId,
1690                                         int iStateId, const RECT *pRect,
1691                                         HRGN *pRegion)
1692 {
1693     HRESULT hr = S_OK;
1694     int bgtype = BT_BORDERFILL;
1695
1696     TRACE("(%p,%p,%d,%d)\n", hTheme, hdc, iPartId, iStateId);
1697     if(!hTheme)
1698         return E_HANDLE;
1699     if(!pRect || !pRegion)
1700         return E_POINTER;
1701
1702     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype);
1703     if(bgtype == BT_IMAGEFILE) {
1704         FIXME("Images not handled yet\n");
1705         hr = ERROR_CALL_NOT_IMPLEMENTED;
1706     }
1707     else if(bgtype == BT_BORDERFILL) {
1708         *pRegion = CreateRectRgn(pRect->left, pRect->top, pRect->right, pRect->bottom);
1709         if(!*pRegion)
1710             hr = HRESULT_FROM_WIN32(GetLastError());
1711     }
1712     else {
1713         FIXME("Unknown background type\n");
1714         /* This should never happen, and hence I don't know what to return */
1715         hr = E_FAIL;
1716     }
1717     return hr;
1718 }
1719
1720 /* compute part size for "borderfill" backgrounds */
1721 HRESULT get_border_background_size (HTHEME hTheme, int iPartId,
1722                                     int iStateId, THEMESIZE eSize, POINT* psz)
1723 {
1724     HRESULT hr = S_OK;
1725     int bordersize = 1;
1726
1727     if (SUCCEEDED (hr = GetThemeInt(hTheme, iPartId, iStateId, TMT_BORDERSIZE,
1728         &bordersize)))
1729     {
1730         psz->x = psz->y = 2*bordersize;
1731         if (eSize != TS_MIN)
1732         {
1733             psz->x++;
1734             psz->y++;
1735         }
1736     }
1737     return hr;
1738 }
1739
1740 /***********************************************************************
1741  *      GetThemePartSize                                    (UXTHEME.@)
1742  */
1743 HRESULT WINAPI GetThemePartSize(HTHEME hTheme, HDC hdc, int iPartId,
1744                                 int iStateId, RECT *prc, THEMESIZE eSize,
1745                                 SIZE *psz)
1746 {
1747     int bgtype = BT_BORDERFILL;
1748     HRESULT hr = S_OK;
1749     POINT size = {1, 1};
1750
1751     if(!hTheme)
1752         return E_HANDLE;
1753
1754     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype);
1755     if (bgtype == BT_NONE)
1756         /* do nothing */;
1757     else if(bgtype == BT_IMAGEFILE)
1758         hr = get_image_part_size (hTheme, hdc, iPartId, iStateId, prc, eSize, &size);
1759     else if(bgtype == BT_BORDERFILL)
1760         hr = get_border_background_size (hTheme, iPartId, iStateId, eSize, &size);
1761     else {
1762         FIXME("Unknown background type\n");
1763         /* This should never happen, and hence I don't know what to return */
1764         hr = E_FAIL;
1765     }
1766     psz->cx = size.x;
1767     psz->cy = size.y;
1768     return hr;
1769 }
1770
1771
1772 /***********************************************************************
1773  *      GetThemeTextExtent                                  (UXTHEME.@)
1774  */
1775 HRESULT WINAPI GetThemeTextExtent(HTHEME hTheme, HDC hdc, int iPartId,
1776                                   int iStateId, LPCWSTR pszText, int iCharCount,
1777                                   DWORD dwTextFlags, const RECT *pBoundingRect,
1778                                   RECT *pExtentRect)
1779 {
1780     HRESULT hr;
1781     HFONT hFont = NULL;
1782     HGDIOBJ oldFont = NULL;
1783     LOGFONTW logfont;
1784     RECT rt = {0,0,0xFFFF,0xFFFF};
1785
1786     TRACE("%d %d: stub\n", iPartId, iStateId);
1787     if(!hTheme)
1788         return E_HANDLE;
1789
1790     if(pBoundingRect)
1791         CopyRect(&rt, pBoundingRect);
1792
1793     hr = GetThemeFont(hTheme, hdc, iPartId, iStateId, TMT_FONT, &logfont);
1794     if(SUCCEEDED(hr)) {
1795         hFont = CreateFontIndirectW(&logfont);
1796         if(!hFont)
1797             TRACE("Failed to create font\n");
1798     }
1799     if(hFont)
1800         oldFont = SelectObject(hdc, hFont);
1801
1802     DrawTextW(hdc, pszText, iCharCount, &rt, dwTextFlags|DT_CALCRECT);
1803     CopyRect(pExtentRect, &rt);
1804
1805     if(hFont) {
1806         SelectObject(hdc, oldFont);
1807         DeleteObject(hFont);
1808     }
1809     return S_OK;
1810 }
1811
1812 /***********************************************************************
1813  *      GetThemeTextMetrics                                 (UXTHEME.@)
1814  */
1815 HRESULT WINAPI GetThemeTextMetrics(HTHEME hTheme, HDC hdc, int iPartId,
1816                                    int iStateId, TEXTMETRICW *ptm)
1817 {
1818     HRESULT hr;
1819     HFONT hFont = NULL;
1820     HGDIOBJ oldFont = NULL;
1821     LOGFONTW logfont;
1822
1823     TRACE("(%p, %p, %d, %d)\n", hTheme, hdc, iPartId, iStateId);
1824     if(!hTheme)
1825         return E_HANDLE;
1826
1827     hr = GetThemeFont(hTheme, hdc, iPartId, iStateId, TMT_FONT, &logfont);
1828     if(SUCCEEDED(hr)) {
1829         hFont = CreateFontIndirectW(&logfont);
1830         if(!hFont)
1831             TRACE("Failed to create font\n");
1832     }
1833     if(hFont)
1834         oldFont = SelectObject(hdc, hFont);
1835
1836     if(!GetTextMetricsW(hdc, ptm))
1837         hr = HRESULT_FROM_WIN32(GetLastError());
1838
1839     if(hFont) {
1840         SelectObject(hdc, oldFont);
1841         DeleteObject(hFont);
1842     }
1843     return hr;
1844 }
1845
1846 /***********************************************************************
1847  *      IsThemeBackgroundPartiallyTransparent               (UXTHEME.@)
1848  */
1849 BOOL WINAPI IsThemeBackgroundPartiallyTransparent(HTHEME hTheme, int iPartId,
1850                                                   int iStateId)
1851 {
1852     int bgtype = BT_BORDERFILL;
1853     RECT rect = {0, 0, 0, 0};
1854     HBITMAP bmpSrc;
1855     RECT rcSrc;
1856     BOOL hasAlpha;
1857     INT transparent;
1858     COLORREF transparentcolor;
1859
1860     TRACE("(%d,%d)\n", iPartId, iStateId);
1861
1862     if(!hTheme)
1863         return FALSE;
1864
1865     GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype);
1866
1867     if (bgtype != BT_IMAGEFILE) return FALSE;
1868
1869     if(FAILED (UXTHEME_LoadImage (hTheme, 0, iPartId, iStateId, &rect, FALSE,
1870                                   &bmpSrc, &rcSrc, &hasAlpha)))
1871         return FALSE;
1872
1873     get_transparency (hTheme, iPartId, iStateId, hasAlpha, &transparent,
1874         &transparentcolor, FALSE);
1875     return (transparent != ALPHABLEND_NONE);
1876 }