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