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