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