projects / reactos.git / blob
? search:


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