/* * Win32 5.1 Theme drawing * * Copyright (C) 2003 Kevin Koltzau * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include #include #include "windef.h" #include "winbase.h" #include "winuser.h" #include "wingdi.h" #include "vfwmsgs.h" #include "uxtheme.h" #include "tmschema.h" #include "msstyles.h" #include "uxthemedll.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(uxtheme); /*********************************************************************** * Defines and global variables */ extern ATOM atDialogThemeEnabled; /***********************************************************************/ /*********************************************************************** * EnableThemeDialogTexture (UXTHEME.@) */ HRESULT WINAPI EnableThemeDialogTexture(HWND hwnd, DWORD dwFlags) { static const WCHAR szTab[] = { 'T','a','b',0 }; BOOL res; TRACE("(%p,0x%08x\n", hwnd, dwFlags); res = SetPropW (hwnd, (LPCWSTR)MAKEINTATOM(atDialogThemeEnabled), UlongToHandle(dwFlags|0x80000000)); /* 0x80000000 serves as a "flags set" flag */ if (!res) return HRESULT_FROM_WIN32(GetLastError()); if (dwFlags & ETDT_USETABTEXTURE) return SetWindowTheme (hwnd, NULL, szTab); else return SetWindowTheme (hwnd, NULL, NULL); } /*********************************************************************** * IsThemeDialogTextureEnabled (UXTHEME.@) */ BOOL WINAPI IsThemeDialogTextureEnabled(HWND hwnd) { DWORD dwDialogTextureFlags; TRACE("(%p)\n", hwnd); dwDialogTextureFlags = HandleToUlong( GetPropW( hwnd, (LPCWSTR)MAKEINTATOM(atDialogThemeEnabled) )); if (dwDialogTextureFlags == 0) /* Means EnableThemeDialogTexture wasn't called for this dialog */ return TRUE; return (dwDialogTextureFlags & ETDT_ENABLE) && !(dwDialogTextureFlags & ETDT_DISABLE); } /*********************************************************************** * DrawThemeParentBackground (UXTHEME.@) */ HRESULT WINAPI DrawThemeParentBackground(HWND hwnd, HDC hdc, RECT *prc) { RECT rt; POINT org; HWND hParent; HRGN clip = NULL; int hasClip = -1; TRACE("(%p,%p,%p)\n", hwnd, hdc, prc); hParent = GetParent(hwnd); if(!hParent) hParent = hwnd; if(prc) { rt = *prc; MapWindowPoints(hwnd, hParent, (LPPOINT)&rt, 2); clip = CreateRectRgn(0,0,1,1); hasClip = GetClipRgn(hdc, clip); if(hasClip == -1) TRACE("Failed to get original clipping region\n"); else IntersectClipRect(hdc, prc->left, prc->top, prc->right, prc->bottom); } else { GetClientRect(hwnd, &rt); MapWindowPoints(hwnd, hParent, (LPPOINT)&rt, 2); } OffsetViewportOrgEx(hdc, -rt.left, -rt.top, &org); SendMessageW(hParent, WM_ERASEBKGND, (WPARAM)hdc, 0); SendMessageW(hParent, WM_PRINTCLIENT, (WPARAM)hdc, PRF_CLIENT); SetViewportOrgEx(hdc, org.x, org.y, NULL); if(prc) { if(hasClip == 0) SelectClipRgn(hdc, NULL); else if(hasClip == 1) SelectClipRgn(hdc, clip); DeleteObject(clip); } return S_OK; } /*********************************************************************** * DrawThemeBackground (UXTHEME.@) */ HRESULT WINAPI DrawThemeBackground(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, const RECT *pClipRect) { DTBGOPTS opts; opts.dwSize = sizeof(DTBGOPTS); opts.dwFlags = 0; if(pClipRect) { opts.dwFlags |= DTBG_CLIPRECT; opts.rcClip = *pClipRect; } return DrawThemeBackgroundEx(hTheme, hdc, iPartId, iStateId, pRect, &opts); } /*********************************************************************** * UXTHEME_SelectImage * * Select the image to use */ static PTHEME_PROPERTY UXTHEME_SelectImage(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, BOOL glyph) { PTHEME_PROPERTY tp; int imageselecttype = IST_NONE; int i; int image; if(glyph) image = TMT_GLYPHIMAGEFILE; else image = TMT_IMAGEFILE; if((tp=MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, image))) return tp; GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_IMAGESELECTTYPE, &imageselecttype); if(imageselecttype == IST_DPI) { int reqdpi = 0; int screendpi = GetDeviceCaps(hdc, LOGPIXELSX); for(i=4; i>=0; i--) { reqdpi = 0; if(SUCCEEDED(GetThemeInt(hTheme, iPartId, iStateId, i + TMT_MINDPI1, &reqdpi))) { if(reqdpi != 0 && screendpi >= reqdpi) { TRACE("Using %d DPI, image %d\n", reqdpi, i + TMT_IMAGEFILE1); return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, i + TMT_IMAGEFILE1); } } } /* If an image couldn't be selected, choose the first one */ return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, TMT_IMAGEFILE1); } else if(imageselecttype == IST_SIZE) { POINT size = {pRect->right-pRect->left, pRect->bottom-pRect->top}; POINT reqsize; for(i=4; i>=0; i--) { PTHEME_PROPERTY fileProp = MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, i + TMT_IMAGEFILE1); if (!fileProp) continue; if(FAILED(GetThemePosition(hTheme, iPartId, iStateId, i + TMT_MINSIZE1, &reqsize))) { /* fall back to size of Nth image */ WCHAR szPath[MAX_PATH]; int imagelayout = IL_HORIZONTAL; int imagecount = 1; BITMAP bmp; HBITMAP hBmp; BOOL hasAlpha; lstrcpynW(szPath, fileProp->lpValue, min(fileProp->dwValueLen+1, ARRAY_SIZE(szPath))); hBmp = MSSTYLES_LoadBitmap(hTheme, szPath, &hasAlpha); if(!hBmp) continue; GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_IMAGELAYOUT, &imagelayout); GetThemeInt(hTheme, iPartId, iStateId, TMT_IMAGECOUNT, &imagecount); GetObjectW(hBmp, sizeof(bmp), &bmp); if(imagelayout == IL_VERTICAL) { reqsize.x = bmp.bmWidth; reqsize.y = bmp.bmHeight/imagecount; } else { reqsize.x = bmp.bmWidth/imagecount; reqsize.y = bmp.bmHeight; } } if(reqsize.x <= size.x && reqsize.y <= size.y) { TRACE("Using image size %dx%d, image %d\n", reqsize.x, reqsize.y, i + TMT_IMAGEFILE1); return fileProp; } } /* If an image couldn't be selected, choose the smallest one */ return MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_FILENAME, TMT_IMAGEFILE1); } return NULL; } /*********************************************************************** * UXTHEME_LoadImage * * Load image for part/state */ static HRESULT UXTHEME_LoadImage(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, BOOL glyph, HBITMAP *hBmp, RECT *bmpRect, BOOL* hasImageAlpha) { int imagelayout = IL_HORIZONTAL; int imagecount = 1; int imagenum; BITMAP bmp; WCHAR szPath[MAX_PATH]; PTHEME_PROPERTY tp = UXTHEME_SelectImage(hTheme, hdc, iPartId, iStateId, pRect, glyph); if(!tp) { FIXME("Couldn't determine image for part/state %d/%d, invalid theme?\n", iPartId, iStateId); return E_PROP_ID_UNSUPPORTED; } lstrcpynW(szPath, tp->lpValue, min(tp->dwValueLen+1, ARRAY_SIZE(szPath))); *hBmp = MSSTYLES_LoadBitmap(hTheme, szPath, hasImageAlpha); if(!*hBmp) { TRACE("Failed to load bitmap %s\n", debugstr_w(szPath)); return HRESULT_FROM_WIN32(GetLastError()); } GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_IMAGELAYOUT, &imagelayout); GetThemeInt(hTheme, iPartId, iStateId, TMT_IMAGECOUNT, &imagecount); imagenum = max (min (imagecount, iStateId), 1) - 1; GetObjectW(*hBmp, sizeof(bmp), &bmp); if(imagecount < 1) imagecount = 1; if(imagelayout == IL_VERTICAL) { int height = bmp.bmHeight/imagecount; bmpRect->left = 0; bmpRect->right = bmp.bmWidth; bmpRect->top = imagenum * height; bmpRect->bottom = bmpRect->top + height; } else { int width = bmp.bmWidth/imagecount; bmpRect->left = imagenum * width; bmpRect->right = bmpRect->left + width; bmpRect->top = 0; bmpRect->bottom = bmp.bmHeight; } return S_OK; } /*********************************************************************** * UXTHEME_StretchBlt * * Pseudo TransparentBlt/StretchBlt */ static inline BOOL UXTHEME_StretchBlt(HDC hdcDst, int nXOriginDst, int nYOriginDst, int nWidthDst, int nHeightDst, HDC hdcSrc, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, INT transparent, COLORREF transcolor) { static const BLENDFUNCTION blendFunc = { AC_SRC_OVER, /* BlendOp */ 0, /* BlendFlag */ 255, /* SourceConstantAlpha */ AC_SRC_ALPHA /* AlphaFormat */ }; BOOL ret = TRUE; int old_stretch_mode; POINT old_brush_org; old_stretch_mode = SetStretchBltMode(hdcDst, HALFTONE); SetBrushOrgEx(hdcDst, nXOriginDst, nYOriginDst, &old_brush_org); if (transparent == ALPHABLEND_BINARY) { /* Ensure we don't pass any negative values to TransparentBlt */ ret = TransparentBlt(hdcDst, nXOriginDst, nYOriginDst, abs(nWidthDst), abs(nHeightDst), hdcSrc, nXOriginSrc, nYOriginSrc, abs(nWidthSrc), abs(nHeightSrc), transcolor); } else if ((transparent == ALPHABLEND_NONE) || !AlphaBlend(hdcDst, nXOriginDst, nYOriginDst, nWidthDst, nHeightDst, hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, blendFunc)) { ret = StretchBlt(hdcDst, nXOriginDst, nYOriginDst, nWidthDst, nHeightDst, hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, SRCCOPY); } SetBrushOrgEx(hdcDst, old_brush_org.x, old_brush_org.y, NULL); SetStretchBltMode(hdcDst, old_stretch_mode); return ret; } /*********************************************************************** * UXTHEME_Blt * * Simplify sending same width/height for both source and dest */ static inline BOOL UXTHEME_Blt(HDC hdcDest, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest, HDC hdcSrc, int nXOriginSrc, int nYOriginSrc, INT transparent, COLORREF transcolor) { return UXTHEME_StretchBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, nWidthDest, nHeightDest, transparent, transcolor); } /*********************************************************************** * UXTHEME_SizedBlt * * Stretches or tiles, depending on sizingtype. */ static inline BOOL UXTHEME_SizedBlt (HDC hdcDst, int nXOriginDst, int nYOriginDst, int nWidthDst, int nHeightDst, HDC hdcSrc, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, int sizingtype, INT transparent, COLORREF transcolor) { if (sizingtype == ST_TILE) { HDC hdcTemp; BOOL result = FALSE; if (!nWidthSrc || !nHeightSrc) return TRUE; /* For destination width/height less than or equal to source width/height, do not bother with memory bitmap optimization */ if (nWidthSrc >= nWidthDst && nHeightSrc >= nHeightDst) { int bltWidth = min (nWidthDst, nWidthSrc); int bltHeight = min (nHeightDst, nHeightSrc); return UXTHEME_Blt (hdcDst, nXOriginDst, nYOriginDst, bltWidth, bltHeight, hdcSrc, nXOriginSrc, nYOriginSrc, transparent, transcolor); } /* Create a DC with a bitmap consisting of a tiling of the source bitmap, with standard GDI functions. This is faster than an iteration with UXTHEME_Blt(). */ hdcTemp = CreateCompatibleDC(hdcSrc); if (hdcTemp != 0) { HBITMAP bitmapTemp; HBITMAP bitmapOrig; int nWidthTemp, nHeightTemp; int xOfs, xRemaining; int yOfs, yRemaining; int growSize; /* Calculate temp dimensions of integer multiples of source dimensions */ nWidthTemp = ((nWidthDst + nWidthSrc - 1) / nWidthSrc) * nWidthSrc; nHeightTemp = ((nHeightDst + nHeightSrc - 1) / nHeightSrc) * nHeightSrc; bitmapTemp = CreateCompatibleBitmap(hdcSrc, nWidthTemp, nHeightTemp); bitmapOrig = SelectObject(hdcTemp, bitmapTemp); /* Initial copy of bitmap */ BitBlt(hdcTemp, 0, 0, nWidthSrc, nHeightSrc, hdcSrc, nXOriginSrc, nYOriginSrc, SRCCOPY); /* Extend bitmap in the X direction. Growth of width is exponential */ xOfs = nWidthSrc; xRemaining = nWidthTemp - nWidthSrc; growSize = nWidthSrc; while (xRemaining > 0) { growSize = min(growSize, xRemaining); BitBlt(hdcTemp, xOfs, 0, growSize, nHeightSrc, hdcTemp, 0, 0, SRCCOPY); xOfs += growSize; xRemaining -= growSize; growSize *= 2; } /* Extend bitmap in the Y direction. Growth of height is exponential */ yOfs = nHeightSrc; yRemaining = nHeightTemp - nHeightSrc; growSize = nHeightSrc; while (yRemaining > 0) { growSize = min(growSize, yRemaining); BitBlt(hdcTemp, 0, yOfs, nWidthTemp, growSize, hdcTemp, 0, 0, SRCCOPY); yOfs += growSize; yRemaining -= growSize; growSize *= 2; } /* Use temporary hdc for source */ result = UXTHEME_Blt (hdcDst, nXOriginDst, nYOriginDst, nWidthDst, nHeightDst, hdcTemp, 0, 0, transparent, transcolor); SelectObject(hdcTemp, bitmapOrig); DeleteObject(bitmapTemp); } DeleteDC(hdcTemp); return result; } else { return UXTHEME_StretchBlt (hdcDst, nXOriginDst, nYOriginDst, nWidthDst, nHeightDst, hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, transparent, transcolor); } } /* Get transparency parameters passed to UXTHEME_StretchBlt() - the parameters * depend on whether the image has full alpha or whether it is * color-transparent or just opaque. */ static inline void get_transparency (HTHEME hTheme, int iPartId, int iStateId, BOOL hasImageAlpha, INT* transparent, COLORREF* transparentcolor, BOOL glyph) { if (hasImageAlpha) { *transparent = ALPHABLEND_FULL; *transparentcolor = RGB (255, 0, 255); } else { BOOL trans = FALSE; GetThemeBool(hTheme, iPartId, iStateId, glyph ? TMT_GLYPHTRANSPARENT : TMT_TRANSPARENT, &trans); if(trans) { *transparent = ALPHABLEND_BINARY; if(FAILED(GetThemeColor(hTheme, iPartId, iStateId, glyph ? TMT_GLYPHTRANSPARENTCOLOR : TMT_TRANSPARENTCOLOR, transparentcolor))) { /* If image is transparent, but no color was specified, use magenta */ *transparentcolor = RGB(255, 0, 255); } } else *transparent = ALPHABLEND_NONE; } } /*********************************************************************** * UXTHEME_DrawImageGlyph * * Draw an imagefile glyph */ static HRESULT UXTHEME_DrawImageGlyph(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, RECT *pRect, const DTBGOPTS *pOptions) { HRESULT hr; HBITMAP bmpSrc = NULL; HDC hdcSrc = NULL; HGDIOBJ oldSrc = NULL; RECT rcSrc; INT transparent = 0; COLORREF transparentcolor; int valign = VA_CENTER; int halign = HA_CENTER; POINT dstSize; POINT srcSize; POINT topleft; BOOL hasAlpha; hr = UXTHEME_LoadImage(hTheme, hdc, iPartId, iStateId, pRect, TRUE, &bmpSrc, &rcSrc, &hasAlpha); if(FAILED(hr)) return hr; hdcSrc = CreateCompatibleDC(hdc); if(!hdcSrc) { hr = HRESULT_FROM_WIN32(GetLastError()); return hr; } oldSrc = SelectObject(hdcSrc, bmpSrc); dstSize.x = pRect->right-pRect->left; dstSize.y = pRect->bottom-pRect->top; srcSize.x = rcSrc.right-rcSrc.left; srcSize.y = rcSrc.bottom-rcSrc.top; get_transparency (hTheme, iPartId, iStateId, hasAlpha, &transparent, &transparentcolor, TRUE); GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_VALIGN, &valign); GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_HALIGN, &halign); topleft.x = pRect->left; topleft.y = pRect->top; if(halign == HA_CENTER) topleft.x += (dstSize.x/2)-(srcSize.x/2); else if(halign == HA_RIGHT) topleft.x += dstSize.x-srcSize.x; if(valign == VA_CENTER) topleft.y += (dstSize.y/2)-(srcSize.y/2); else if(valign == VA_BOTTOM) topleft.y += dstSize.y-srcSize.y; if(!UXTHEME_Blt(hdc, topleft.x, topleft.y, srcSize.x, srcSize.y, hdcSrc, rcSrc.left, rcSrc.top, transparent, transparentcolor)) { hr = HRESULT_FROM_WIN32(GetLastError()); } SelectObject(hdcSrc, oldSrc); DeleteDC(hdcSrc); return hr; } /*********************************************************************** * UXTHEME_DrawImageGlyph * * Draw glyph on top of background, if appropriate */ static HRESULT UXTHEME_DrawGlyph(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, RECT *pRect, const DTBGOPTS *pOptions) { int glyphtype = GT_NONE; GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_GLYPHTYPE, &glyphtype); if(glyphtype == GT_IMAGEGLYPH) { return UXTHEME_DrawImageGlyph(hTheme, hdc, iPartId, iStateId, pRect, pOptions); } else if(glyphtype == GT_FONTGLYPH) { /* I don't know what a font glyph is, I've never seen it used in any themes */ FIXME("Font glyph\n"); } return S_OK; } /*********************************************************************** * get_image_part_size * * Used by GetThemePartSize and UXTHEME_DrawImageBackground */ static HRESULT get_image_part_size (HTHEME hTheme, HDC hdc, int iPartId, int iStateId, RECT *prc, THEMESIZE eSize, POINT *psz) { HRESULT hr = S_OK; HBITMAP bmpSrc; RECT rcSrc; BOOL hasAlpha; hr = UXTHEME_LoadImage(hTheme, hdc, iPartId, iStateId, prc, FALSE, &bmpSrc, &rcSrc, &hasAlpha); if (FAILED(hr)) return hr; switch (eSize) { case TS_DRAW: if (prc != NULL) { RECT rcDst; POINT dstSize; POINT srcSize; int sizingtype = ST_STRETCH; BOOL uniformsizing = FALSE; rcDst = *prc; dstSize.x = rcDst.right-rcDst.left; dstSize.y = rcDst.bottom-rcDst.top; srcSize.x = rcSrc.right-rcSrc.left; srcSize.y = rcSrc.bottom-rcSrc.top; GetThemeBool(hTheme, iPartId, iStateId, TMT_UNIFORMSIZING, &uniformsizing); if(uniformsizing) { /* Scale height and width equally */ if (dstSize.x*srcSize.y < dstSize.y*srcSize.x) { dstSize.y = MulDiv (srcSize.y, dstSize.x, srcSize.x); rcDst.bottom = rcDst.top + dstSize.y; } else { dstSize.x = MulDiv (srcSize.x, dstSize.y, srcSize.y); rcDst.right = rcDst.left + dstSize.x; } } GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_SIZINGTYPE, &sizingtype); if(sizingtype == ST_TRUESIZE) { int truesizestretchmark = 100; if(dstSize.x < 0 || dstSize.y < 0) { BOOL mirrorimage = TRUE; GetThemeBool(hTheme, iPartId, iStateId, TMT_MIRRORIMAGE, &mirrorimage); if(mirrorimage) { if(dstSize.x < 0) { rcDst.left += dstSize.x; rcDst.right += dstSize.x; } if(dstSize.y < 0) { rcDst.top += dstSize.y; rcDst.bottom += dstSize.y; } } } /* Whatever TrueSizeStretchMark does - it does not seem to * be what's outlined below. It appears as if native * uxtheme always stretches if dest is smaller than source * (ie as if TrueSizeStretchMark==100 with the code below) */ #if 0 /* Only stretch when target exceeds source by truesizestretchmark percent */ GetThemeInt(hTheme, iPartId, iStateId, TMT_TRUESIZESTRETCHMARK, &truesizestretchmark); #endif if(dstSize.x < 0 || dstSize.y < 0 || (MulDiv(srcSize.x, 100, dstSize.x) > truesizestretchmark && MulDiv(srcSize.y, 100, dstSize.y) > truesizestretchmark)) { memcpy (psz, &dstSize, sizeof (SIZE)); } else { memcpy (psz, &srcSize, sizeof (SIZE)); } } else { psz->x = abs(dstSize.x); psz->y = abs(dstSize.y); } break; } /* else fall through */ case TS_MIN: /* FIXME: couldn't figure how native uxtheme computes min size */ case TS_TRUE: psz->x = rcSrc.right - rcSrc.left; psz->y = rcSrc.bottom - rcSrc.top; break; } return hr; } /*********************************************************************** * UXTHEME_DrawImageBackground * * Draw an imagefile background */ static HRESULT UXTHEME_DrawImageBackground(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, RECT *pRect, const DTBGOPTS *pOptions) { HRESULT hr = S_OK; HBITMAP bmpSrc, bmpSrcResized = NULL; HGDIOBJ oldSrc; HDC hdcSrc, hdcOrigSrc = NULL; RECT rcSrc; RECT rcDst; POINT dstSize; POINT srcSize; POINT drawSize; int sizingtype = ST_STRETCH; INT transparent; COLORREF transparentcolor = 0; BOOL hasAlpha; hr = UXTHEME_LoadImage(hTheme, hdc, iPartId, iStateId, pRect, FALSE, &bmpSrc, &rcSrc, &hasAlpha); if(FAILED(hr)) return hr; hdcSrc = CreateCompatibleDC(hdc); if(!hdcSrc) { hr = HRESULT_FROM_WIN32(GetLastError()); return hr; } oldSrc = SelectObject(hdcSrc, bmpSrc); rcDst = *pRect; get_transparency (hTheme, iPartId, iStateId, hasAlpha, &transparent, &transparentcolor, FALSE); dstSize.x = rcDst.right-rcDst.left; dstSize.y = rcDst.bottom-rcDst.top; srcSize.x = rcSrc.right-rcSrc.left; srcSize.y = rcSrc.bottom-rcSrc.top; GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_SIZINGTYPE, &sizingtype); if(sizingtype == ST_TRUESIZE) { int valign = VA_CENTER, halign = HA_CENTER; get_image_part_size (hTheme, hdc, iPartId, iStateId, pRect, TS_DRAW, &drawSize); GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_VALIGN, &valign); GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_HALIGN, &halign); if (halign == HA_CENTER) rcDst.left += (dstSize.x/2)-(drawSize.x/2); else if (halign == HA_RIGHT) rcDst.left = rcDst.right - drawSize.x; if (valign == VA_CENTER) rcDst.top += (dstSize.y/2)-(drawSize.y/2); else if (valign == VA_BOTTOM) rcDst.top = rcDst.bottom - drawSize.y; rcDst.right = rcDst.left + drawSize.x; rcDst.bottom = rcDst.top + drawSize.y; if(!UXTHEME_StretchBlt(hdc, rcDst.left, rcDst.top, drawSize.x, drawSize.y, hdcSrc, rcSrc.left, rcSrc.top, srcSize.x, srcSize.y, transparent, transparentcolor)) hr = HRESULT_FROM_WIN32(GetLastError()); } else { HDC hdcDst = NULL; MARGINS sm; POINT org; dstSize.x = abs(dstSize.x); dstSize.y = abs(dstSize.y); GetThemeMargins(hTheme, hdc, iPartId, iStateId, TMT_SIZINGMARGINS, NULL, &sm); /* Resize source image if destination smaller than margins */ if (sm.cyTopHeight + sm.cyBottomHeight > dstSize.y || sm.cxLeftWidth + sm.cxRightWidth > dstSize.x) { if (sm.cyTopHeight + sm.cyBottomHeight > dstSize.y) { sm.cyTopHeight = MulDiv(sm.cyTopHeight, dstSize.y, srcSize.y); sm.cyBottomHeight = dstSize.y - sm.cyTopHeight; srcSize.y = dstSize.y; } if (sm.cxLeftWidth + sm.cxRightWidth > dstSize.x) { sm.cxLeftWidth = MulDiv(sm.cxLeftWidth, dstSize.x, srcSize.x); sm.cxRightWidth = dstSize.x - sm.cxLeftWidth; srcSize.x = dstSize.x; } hdcOrigSrc = hdcSrc; hdcSrc = CreateCompatibleDC(NULL); bmpSrcResized = CreateBitmap(srcSize.x, srcSize.y, 1, 32, NULL); SelectObject(hdcSrc, bmpSrcResized); UXTHEME_StretchBlt(hdcSrc, 0, 0, srcSize.x, srcSize.y, hdcOrigSrc, rcSrc.left, rcSrc.top, rcSrc.right - rcSrc.left, rcSrc.bottom - rcSrc.top, transparent, transparentcolor); rcSrc.left = 0; rcSrc.top = 0; rcSrc.right = srcSize.x; rcSrc.bottom = srcSize.y; } hdcDst = hdc; OffsetViewportOrgEx(hdcDst, rcDst.left, rcDst.top, &org); /* Upper left corner */ if(!UXTHEME_Blt(hdcDst, 0, 0, sm.cxLeftWidth, sm.cyTopHeight, hdcSrc, rcSrc.left, rcSrc.top, transparent, transparentcolor)) { hr = HRESULT_FROM_WIN32(GetLastError()); goto draw_error; } /* Upper right corner */ if(!UXTHEME_Blt (hdcDst, dstSize.x-sm.cxRightWidth, 0, sm.cxRightWidth, sm.cyTopHeight, hdcSrc, rcSrc.right-sm.cxRightWidth, rcSrc.top, transparent, transparentcolor)) { hr = HRESULT_FROM_WIN32(GetLastError()); goto draw_error; } /* Lower left corner */ if(!UXTHEME_Blt (hdcDst, 0, dstSize.y-sm.cyBottomHeight, sm.cxLeftWidth, sm.cyBottomHeight, hdcSrc, rcSrc.left, rcSrc.bottom-sm.cyBottomHeight, transparent, transparentcolor)) { hr = HRESULT_FROM_WIN32(GetLastError()); goto draw_error; } /* Lower right corner */ if(!UXTHEME_Blt (hdcDst, dstSize.x-sm.cxRightWidth, dstSize.y-sm.cyBottomHeight, sm.cxRightWidth, sm.cyBottomHeight, hdcSrc, rcSrc.right-sm.cxRightWidth, rcSrc.bottom-sm.cyBottomHeight, transparent, transparentcolor)) { hr = HRESULT_FROM_WIN32(GetLastError()); goto draw_error; } if ((sizingtype == ST_STRETCH) || (sizingtype == ST_TILE)) { int destCenterWidth = dstSize.x - (sm.cxLeftWidth + sm.cxRightWidth); int srcCenterWidth = srcSize.x - (sm.cxLeftWidth + sm.cxRightWidth); int destCenterHeight = dstSize.y - (sm.cyTopHeight + sm.cyBottomHeight); int srcCenterHeight = srcSize.y - (sm.cyTopHeight + sm.cyBottomHeight); if(destCenterWidth > 0) { /* Center top */ if(!UXTHEME_SizedBlt (hdcDst, sm.cxLeftWidth, 0, destCenterWidth, sm.cyTopHeight, hdcSrc, rcSrc.left+sm.cxLeftWidth, rcSrc.top, srcCenterWidth, sm.cyTopHeight, sizingtype, transparent, transparentcolor)) { hr = HRESULT_FROM_WIN32(GetLastError()); goto draw_error; } /* Center bottom */ if(!UXTHEME_SizedBlt (hdcDst, sm.cxLeftWidth, dstSize.y-sm.cyBottomHeight, destCenterWidth, sm.cyBottomHeight, hdcSrc, rcSrc.left+sm.cxLeftWidth, rcSrc.bottom-sm.cyBottomHeight, srcCenterWidth, sm.cyBottomHeight, sizingtype, transparent, transparentcolor)) { hr = HRESULT_FROM_WIN32(GetLastError()); goto draw_error; } } if(destCenterHeight > 0) { /* Left center */ if(!UXTHEME_SizedBlt (hdcDst, 0, sm.cyTopHeight, sm.cxLeftWidth, destCenterHeight, hdcSrc, rcSrc.left, rcSrc.top+sm.cyTopHeight, sm.cxLeftWidth, srcCenterHeight, sizingtype, transparent, transparentcolor)) { hr = HRESULT_FROM_WIN32(GetLastError()); goto draw_error; } /* Right center */ if(!UXTHEME_SizedBlt (hdcDst, dstSize.x-sm.cxRightWidth, sm.cyTopHeight, sm.cxRightWidth, destCenterHeight, hdcSrc, rcSrc.right-sm.cxRightWidth, rcSrc.top+sm.cyTopHeight, sm.cxRightWidth, srcCenterHeight, sizingtype, transparent, transparentcolor)) { hr = HRESULT_FROM_WIN32(GetLastError()); goto draw_error; } } if(destCenterHeight > 0 && destCenterWidth > 0) { BOOL borderonly = FALSE; GetThemeBool(hTheme, iPartId, iStateId, TMT_BORDERONLY, &borderonly); if(!borderonly) { /* Center */ if(!UXTHEME_SizedBlt (hdcDst, sm.cxLeftWidth, sm.cyTopHeight, destCenterWidth, destCenterHeight, hdcSrc, rcSrc.left+sm.cxLeftWidth, rcSrc.top+sm.cyTopHeight, srcCenterWidth, srcCenterHeight, sizingtype, transparent, transparentcolor)) { hr = HRESULT_FROM_WIN32(GetLastError()); goto draw_error; } } } } draw_error: SetViewportOrgEx (hdcDst, org.x, org.y, NULL); } SelectObject(hdcSrc, oldSrc); DeleteDC(hdcSrc); if (bmpSrcResized) DeleteObject(bmpSrcResized); if (hdcOrigSrc) DeleteDC(hdcOrigSrc); *pRect = rcDst; return hr; } /*********************************************************************** * UXTHEME_DrawBorderRectangle * * Draw the bounding rectangle for a borderfill background */ static HRESULT UXTHEME_DrawBorderRectangle(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, RECT *pRect, const DTBGOPTS *pOptions) { HRESULT hr = S_OK; HPEN hPen; HGDIOBJ oldPen; COLORREF bordercolor = RGB(0,0,0); int bordersize = 1; GetThemeInt(hTheme, iPartId, iStateId, TMT_BORDERSIZE, &bordersize); if(bordersize > 0) { POINT ptCorners[5]; ptCorners[0].x = pRect->left; ptCorners[0].y = pRect->top; ptCorners[1].x = pRect->right-1; ptCorners[1].y = pRect->top; ptCorners[2].x = pRect->right-1; ptCorners[2].y = pRect->bottom-1; ptCorners[3].x = pRect->left; ptCorners[3].y = pRect->bottom-1; ptCorners[4].x = pRect->left; ptCorners[4].y = pRect->top; InflateRect(pRect, -bordersize, -bordersize); if(pOptions->dwFlags & DTBG_OMITBORDER) return S_OK; GetThemeColor(hTheme, iPartId, iStateId, TMT_BORDERCOLOR, &bordercolor); hPen = CreatePen(PS_SOLID, bordersize, bordercolor); if(!hPen) return HRESULT_FROM_WIN32(GetLastError()); oldPen = SelectObject(hdc, hPen); if(!Polyline(hdc, ptCorners, 5)) hr = HRESULT_FROM_WIN32(GetLastError()); SelectObject(hdc, oldPen); DeleteObject(hPen); } return hr; } /*********************************************************************** * UXTHEME_DrawBackgroundFill * * Fill a borderfill background rectangle */ static HRESULT UXTHEME_DrawBackgroundFill(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, RECT *pRect, const DTBGOPTS *pOptions) { HRESULT hr = S_OK; int filltype = FT_SOLID; TRACE("(%d,%d,%d)\n", iPartId, iStateId, pOptions->dwFlags); if(pOptions->dwFlags & DTBG_OMITCONTENT) return S_OK; GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_FILLTYPE, &filltype); if(filltype == FT_SOLID) { HBRUSH hBrush; COLORREF fillcolor = RGB(255,255,255); GetThemeColor(hTheme, iPartId, iStateId, TMT_FILLCOLOR, &fillcolor); hBrush = CreateSolidBrush(fillcolor); if(!FillRect(hdc, pRect, hBrush)) hr = HRESULT_FROM_WIN32(GetLastError()); DeleteObject(hBrush); } else if(filltype == FT_VERTGRADIENT || filltype == FT_HORZGRADIENT) { /* FIXME: This only accounts for 2 gradient colors (out of 5) and ignores the gradient ratios (no idea how those work) Few themes use this, and the ones I've seen only use 2 colors with a gradient ratio of 0 and 255 respectively */ COLORREF gradient1 = RGB(0,0,0); COLORREF gradient2 = RGB(255,255,255); TRIVERTEX vert[2]; GRADIENT_RECT gRect; FIXME("Gradient implementation not complete\n"); GetThemeColor(hTheme, iPartId, iStateId, TMT_GRADIENTCOLOR1, &gradient1); GetThemeColor(hTheme, iPartId, iStateId, TMT_GRADIENTCOLOR2, &gradient2); vert[0].x = pRect->left; vert[0].y = pRect->top; vert[0].Red = GetRValue(gradient1) << 8; vert[0].Green = GetGValue(gradient1) << 8; vert[0].Blue = GetBValue(gradient1) << 8; vert[0].Alpha = 0xff00; vert[1].x = pRect->right; vert[1].y = pRect->bottom; vert[1].Red = GetRValue(gradient2) << 8; vert[1].Green = GetGValue(gradient2) << 8; vert[1].Blue = GetBValue(gradient2) << 8; vert[1].Alpha = 0xff00; gRect.UpperLeft = 0; gRect.LowerRight = 1; GradientFill(hdc,vert,2,&gRect,1,filltype==FT_HORZGRADIENT?GRADIENT_FILL_RECT_H:GRADIENT_FILL_RECT_V); } else if(filltype == FT_RADIALGRADIENT) { /* I've never seen this used in a theme */ FIXME("Radial gradient\n"); } else if(filltype == FT_TILEIMAGE) { /* I've never seen this used in a theme */ FIXME("Tile image\n"); } return hr; } /*********************************************************************** * UXTHEME_DrawBorderBackground * * Draw an imagefile background */ static HRESULT UXTHEME_DrawBorderBackground(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, const DTBGOPTS *pOptions) { HRESULT hr; RECT rt; rt = *pRect; hr = UXTHEME_DrawBorderRectangle(hTheme, hdc, iPartId, iStateId, &rt, pOptions); if(FAILED(hr)) return hr; return UXTHEME_DrawBackgroundFill(hTheme, hdc, iPartId, iStateId, &rt, pOptions); } /*********************************************************************** * DrawThemeBackgroundEx (UXTHEME.@) */ HRESULT WINAPI DrawThemeBackgroundEx(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, const DTBGOPTS *pOptions) { HRESULT hr; const DTBGOPTS defaultOpts = {sizeof(DTBGOPTS), 0, {0,0,0,0}}; const DTBGOPTS *opts; HRGN clip = NULL; int hasClip = -1; int bgtype = BT_BORDERFILL; RECT rt; TRACE("(%p,%p,%d,%d,%d,%d)\n", hTheme, hdc, iPartId, iStateId,pRect->left,pRect->top); if(!hTheme) return E_HANDLE; GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype); if (bgtype == BT_NONE) return S_OK; /* Ensure we have a DTBGOPTS structure available, simplifies some of the code */ opts = pOptions; if(!opts) opts = &defaultOpts; if(opts->dwFlags & DTBG_CLIPRECT) { clip = CreateRectRgn(0,0,1,1); hasClip = GetClipRgn(hdc, clip); if(hasClip == -1) TRACE("Failed to get original clipping region\n"); else IntersectClipRect(hdc, opts->rcClip.left, opts->rcClip.top, opts->rcClip.right, opts->rcClip.bottom); } rt = *pRect; if(bgtype == BT_IMAGEFILE) hr = UXTHEME_DrawImageBackground(hTheme, hdc, iPartId, iStateId, &rt, opts); else if(bgtype == BT_BORDERFILL) hr = UXTHEME_DrawBorderBackground(hTheme, hdc, iPartId, iStateId, pRect, opts); else { FIXME("Unknown background type\n"); /* This should never happen, and hence I don't know what to return */ hr = E_FAIL; } if(SUCCEEDED(hr)) hr = UXTHEME_DrawGlyph(hTheme, hdc, iPartId, iStateId, &rt, opts); if(opts->dwFlags & DTBG_CLIPRECT) { if(hasClip == 0) SelectClipRgn(hdc, NULL); else if(hasClip == 1) SelectClipRgn(hdc, clip); DeleteObject(clip); } return hr; } /* * DrawThemeEdge() implementation * * Since it basically is DrawEdge() with different colors, I copied its code * from user32's uitools.c. */ enum { EDGE_LIGHT, EDGE_HIGHLIGHT, EDGE_SHADOW, EDGE_DARKSHADOW, EDGE_FILL, EDGE_WINDOW, EDGE_WINDOWFRAME, EDGE_NUMCOLORS }; static const struct { int themeProp; int sysColor; } EdgeColorMap[EDGE_NUMCOLORS] = { {TMT_EDGELIGHTCOLOR, COLOR_3DLIGHT}, {TMT_EDGEHIGHLIGHTCOLOR, COLOR_BTNHIGHLIGHT}, {TMT_EDGESHADOWCOLOR, COLOR_BTNSHADOW}, {TMT_EDGEDKSHADOWCOLOR, COLOR_3DDKSHADOW}, {TMT_EDGEFILLCOLOR, COLOR_BTNFACE}, {-1, COLOR_WINDOW}, {-1, COLOR_WINDOWFRAME} }; static const signed char LTInnerNormal[] = { -1, -1, -1, -1, -1, EDGE_HIGHLIGHT, EDGE_HIGHLIGHT, -1, -1, EDGE_DARKSHADOW, EDGE_DARKSHADOW, -1, -1, -1, -1, -1 }; static const signed char LTOuterNormal[] = { -1, EDGE_LIGHT, EDGE_SHADOW, -1, EDGE_HIGHLIGHT, EDGE_LIGHT, EDGE_SHADOW, -1, EDGE_DARKSHADOW, EDGE_LIGHT, EDGE_SHADOW, -1, -1, EDGE_LIGHT, EDGE_SHADOW, -1 }; static const signed char RBInnerNormal[] = { -1, -1, -1, -1, -1, EDGE_SHADOW, EDGE_SHADOW, -1, -1, EDGE_LIGHT, EDGE_LIGHT, -1, -1, -1, -1, -1 }; static const signed char RBOuterNormal[] = { -1, EDGE_DARKSHADOW, EDGE_HIGHLIGHT, -1, EDGE_SHADOW, EDGE_DARKSHADOW, EDGE_HIGHLIGHT, -1, EDGE_LIGHT, EDGE_DARKSHADOW, EDGE_HIGHLIGHT, -1, -1, EDGE_DARKSHADOW, EDGE_HIGHLIGHT, -1 }; static const signed char LTInnerSoft[] = { -1, -1, -1, -1, -1, EDGE_LIGHT, EDGE_LIGHT, -1, -1, EDGE_SHADOW, EDGE_SHADOW, -1, -1, -1, -1, -1 }; static const signed char LTOuterSoft[] = { -1, EDGE_HIGHLIGHT, EDGE_DARKSHADOW, -1, EDGE_LIGHT, EDGE_HIGHLIGHT, EDGE_DARKSHADOW, -1, EDGE_SHADOW, EDGE_HIGHLIGHT, EDGE_DARKSHADOW, -1, -1, EDGE_HIGHLIGHT, EDGE_DARKSHADOW, -1 }; #define RBInnerSoft RBInnerNormal /* These are the same */ #define RBOuterSoft RBOuterNormal static const signed char LTRBOuterMono[] = { -1, EDGE_WINDOWFRAME, EDGE_WINDOWFRAME, EDGE_WINDOWFRAME, EDGE_WINDOW, EDGE_WINDOWFRAME, EDGE_WINDOWFRAME, EDGE_WINDOWFRAME, EDGE_WINDOW, EDGE_WINDOWFRAME, EDGE_WINDOWFRAME, EDGE_WINDOWFRAME, EDGE_WINDOW, EDGE_WINDOWFRAME, EDGE_WINDOWFRAME, EDGE_WINDOWFRAME, }; static const signed char LTRBInnerMono[] = { -1, -1, -1, -1, -1, EDGE_WINDOW, EDGE_WINDOW, EDGE_WINDOW, -1, EDGE_WINDOW, EDGE_WINDOW, EDGE_WINDOW, -1, EDGE_WINDOW, EDGE_WINDOW, EDGE_WINDOW, }; static const signed char LTRBOuterFlat[] = { -1, EDGE_SHADOW, EDGE_SHADOW, EDGE_SHADOW, EDGE_FILL, EDGE_SHADOW, EDGE_SHADOW, EDGE_SHADOW, EDGE_FILL, EDGE_SHADOW, EDGE_SHADOW, EDGE_SHADOW, EDGE_FILL, EDGE_SHADOW, EDGE_SHADOW, EDGE_SHADOW, }; static const signed char LTRBInnerFlat[] = { -1, -1, -1, -1, -1, EDGE_FILL, EDGE_FILL, EDGE_FILL, -1, EDGE_FILL, EDGE_FILL, EDGE_FILL, -1, EDGE_FILL, EDGE_FILL, EDGE_FILL, }; static COLORREF get_edge_color (int edgeType, HTHEME theme, int part, int state) { COLORREF col; if ((EdgeColorMap[edgeType].themeProp == -1) || FAILED (GetThemeColor (theme, part, state, EdgeColorMap[edgeType].themeProp, &col))) col = GetSysColor (EdgeColorMap[edgeType].sysColor); return col; } static inline HPEN get_edge_pen (int edgeType, HTHEME theme, int part, int state) { return CreatePen (PS_SOLID, 1, get_edge_color (edgeType, theme, part, state)); } static inline HBRUSH get_edge_brush (int edgeType, HTHEME theme, int part, int state) { return CreateSolidBrush (get_edge_color (edgeType, theme, part, state)); } /*********************************************************************** * draw_diag_edge * * Same as DrawEdge invoked with BF_DIAGONAL */ static HRESULT draw_diag_edge (HDC hdc, HTHEME theme, int part, int state, const RECT* rc, UINT uType, UINT uFlags, LPRECT contentsRect) { POINT Points[4]; signed char InnerI, OuterI; HPEN InnerPen, OuterPen; POINT SavePoint; HPEN SavePen; int spx, spy; int epx, epy; int Width = rc->right - rc->left; int Height= rc->bottom - rc->top; int SmallDiam = Width > Height ? Height : Width; HRESULT retval = (((uType & BDR_INNER) == BDR_INNER || (uType & BDR_OUTER) == BDR_OUTER) && !(uFlags & (BF_FLAT|BF_MONO)) ) ? E_FAIL : S_OK; int add = (LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0) + (LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0); /* Init some vars */ OuterPen = InnerPen = GetStockObject(NULL_PEN); SavePen = SelectObject(hdc, InnerPen); spx = spy = epx = epy = 0; /* Satisfy the compiler... */ /* Determine the colors of the edges */ if(uFlags & BF_MONO) { InnerI = LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)]; OuterI = LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)]; } else if(uFlags & BF_FLAT) { InnerI = LTRBInnerFlat[uType & (BDR_INNER|BDR_OUTER)]; OuterI = LTRBOuterFlat[uType & (BDR_INNER|BDR_OUTER)]; } else if(uFlags & BF_SOFT) { if(uFlags & BF_BOTTOM) { InnerI = RBInnerSoft[uType & (BDR_INNER|BDR_OUTER)]; OuterI = RBOuterSoft[uType & (BDR_INNER|BDR_OUTER)]; } else { InnerI = LTInnerSoft[uType & (BDR_INNER|BDR_OUTER)]; OuterI = LTOuterSoft[uType & (BDR_INNER|BDR_OUTER)]; } } else { if(uFlags & BF_BOTTOM) { InnerI = RBInnerNormal[uType & (BDR_INNER|BDR_OUTER)]; OuterI = RBOuterNormal[uType & (BDR_INNER|BDR_OUTER)]; } else { InnerI = LTInnerNormal[uType & (BDR_INNER|BDR_OUTER)]; OuterI = LTOuterNormal[uType & (BDR_INNER|BDR_OUTER)]; } } if(InnerI != -1) InnerPen = get_edge_pen (InnerI, theme, part, state); if(OuterI != -1) OuterPen = get_edge_pen (OuterI, theme, part, state); MoveToEx(hdc, 0, 0, &SavePoint); /* Don't ask me why, but this is what is visible... */ /* This must be possible to do much simpler, but I fail to */ /* see the logic in the MS implementation (sigh...). */ /* So, this might look a bit brute force here (and it is), but */ /* it gets the job done;) */ switch(uFlags & BF_RECT) { case 0: case BF_LEFT: case BF_BOTTOM: case BF_BOTTOMLEFT: /* Left bottom endpoint */ epx = rc->left-1; spx = epx + SmallDiam; epy = rc->bottom; spy = epy - SmallDiam; break; case BF_TOPLEFT: case BF_BOTTOMRIGHT: /* Left top endpoint */ epx = rc->left-1; spx = epx + SmallDiam; epy = rc->top-1; spy = epy + SmallDiam; break; case BF_TOP: case BF_RIGHT: case BF_TOPRIGHT: case BF_RIGHT|BF_LEFT: case BF_RIGHT|BF_LEFT|BF_TOP: case BF_BOTTOM|BF_TOP: case BF_BOTTOM|BF_TOP|BF_LEFT: case BF_BOTTOMRIGHT|BF_LEFT: case BF_BOTTOMRIGHT|BF_TOP: case BF_RECT: /* Right top endpoint */ spx = rc->left; epx = spx + SmallDiam; spy = rc->bottom-1; epy = spy - SmallDiam; break; } MoveToEx(hdc, spx, spy, NULL); SelectObject(hdc, OuterPen); LineTo(hdc, epx, epy); SelectObject(hdc, InnerPen); switch(uFlags & (BF_RECT|BF_DIAGONAL)) { case BF_DIAGONAL_ENDBOTTOMLEFT: case (BF_DIAGONAL|BF_BOTTOM): case BF_DIAGONAL: case (BF_DIAGONAL|BF_LEFT): MoveToEx(hdc, spx-1, spy, NULL); LineTo(hdc, epx, epy-1); Points[0].x = spx-add; Points[0].y = spy; Points[1].x = rc->left; Points[1].y = rc->top; Points[2].x = epx+1; Points[2].y = epy-1-add; Points[3] = Points[2]; break; case BF_DIAGONAL_ENDBOTTOMRIGHT: MoveToEx(hdc, spx-1, spy, NULL); LineTo(hdc, epx, epy+1); Points[0].x = spx-add; Points[0].y = spy; Points[1].x = rc->left; Points[1].y = rc->bottom-1; Points[2].x = epx+1; Points[2].y = epy+1+add; Points[3] = Points[2]; break; case (BF_DIAGONAL|BF_BOTTOM|BF_RIGHT|BF_TOP): case (BF_DIAGONAL|BF_BOTTOM|BF_RIGHT|BF_TOP|BF_LEFT): case BF_DIAGONAL_ENDTOPRIGHT: case (BF_DIAGONAL|BF_RIGHT|BF_TOP|BF_LEFT): MoveToEx(hdc, spx+1, spy, NULL); LineTo(hdc, epx, epy+1); Points[0].x = epx-1; Points[0].y = epy+1+add; Points[1].x = rc->right-1; Points[1].y = rc->top+add; Points[2].x = rc->right-1; Points[2].y = rc->bottom-1; Points[3].x = spx+add; Points[3].y = spy; break; case BF_DIAGONAL_ENDTOPLEFT: MoveToEx(hdc, spx, spy-1, NULL); LineTo(hdc, epx+1, epy); Points[0].x = epx+1+add; Points[0].y = epy+1; Points[1].x = rc->right-1; Points[1].y = rc->top; Points[2].x = rc->right-1; Points[2].y = rc->bottom-1-add; Points[3].x = spx; Points[3].y = spy-add; break; case (BF_DIAGONAL|BF_TOP): case (BF_DIAGONAL|BF_BOTTOM|BF_TOP): case (BF_DIAGONAL|BF_BOTTOM|BF_TOP|BF_LEFT): MoveToEx(hdc, spx+1, spy-1, NULL); LineTo(hdc, epx, epy); Points[0].x = epx-1; Points[0].y = epy+1; Points[1].x = rc->right-1; Points[1].y = rc->top; Points[2].x = rc->right-1; Points[2].y = rc->bottom-1-add; Points[3].x = spx+add; Points[3].y = spy-add; break; case (BF_DIAGONAL|BF_RIGHT): case (BF_DIAGONAL|BF_RIGHT|BF_LEFT): case (BF_DIAGONAL|BF_RIGHT|BF_LEFT|BF_BOTTOM): MoveToEx(hdc, spx, spy, NULL); LineTo(hdc, epx-1, epy+1); Points[0].x = spx; Points[0].y = spy; Points[1].x = rc->left; Points[1].y = rc->top+add; Points[2].x = epx-1-add; Points[2].y = epy+1+add; Points[3] = Points[2]; break; } /* Fill the interior if asked */ if((uFlags & BF_MIDDLE) && retval) { HBRUSH hbsave; HBRUSH hb = get_edge_brush ((uFlags & BF_MONO) ? EDGE_WINDOW : EDGE_FILL, theme, part, state); HPEN hpsave; HPEN hp = get_edge_pen ((uFlags & BF_MONO) ? EDGE_WINDOW : EDGE_FILL, theme, part, state); hbsave = SelectObject(hdc, hb); hpsave = SelectObject(hdc, hp); Polygon(hdc, Points, 4); SelectObject(hdc, hbsave); SelectObject(hdc, hpsave); DeleteObject (hp); DeleteObject (hb); } /* Adjust rectangle if asked */ if(uFlags & BF_ADJUST) { *contentsRect = *rc; if(uFlags & BF_LEFT) contentsRect->left += add; if(uFlags & BF_RIGHT) contentsRect->right -= add; if(uFlags & BF_TOP) contentsRect->top += add; if(uFlags & BF_BOTTOM) contentsRect->bottom -= add; } /* Cleanup */ SelectObject(hdc, SavePen); MoveToEx(hdc, SavePoint.x, SavePoint.y, NULL); if(InnerI != -1) DeleteObject (InnerPen); if(OuterI != -1) DeleteObject (OuterPen); return retval; } /*********************************************************************** * draw_rect_edge * * Same as DrawEdge invoked without BF_DIAGONAL */ static HRESULT draw_rect_edge (HDC hdc, HTHEME theme, int part, int state, const RECT* rc, UINT uType, UINT uFlags, LPRECT contentsRect) { signed char LTInnerI, LTOuterI; signed char RBInnerI, RBOuterI; HPEN LTInnerPen, LTOuterPen; HPEN RBInnerPen, RBOuterPen; RECT InnerRect = *rc; POINT SavePoint; HPEN SavePen; int LBpenplus = 0; int LTpenplus = 0; int RTpenplus = 0; int RBpenplus = 0; HRESULT retval = (((uType & BDR_INNER) == BDR_INNER || (uType & BDR_OUTER) == BDR_OUTER) && !(uFlags & (BF_FLAT|BF_MONO)) ) ? E_FAIL : S_OK; /* Init some vars */ LTInnerPen = LTOuterPen = RBInnerPen = RBOuterPen = GetStockObject(NULL_PEN); SavePen = SelectObject(hdc, LTInnerPen); /* Determine the colors of the edges */ if(uFlags & BF_MONO) { LTInnerI = RBInnerI = LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)]; LTOuterI = RBOuterI = LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)]; } else if(uFlags & BF_FLAT) { LTInnerI = RBInnerI = LTRBInnerFlat[uType & (BDR_INNER|BDR_OUTER)]; LTOuterI = RBOuterI = LTRBOuterFlat[uType & (BDR_INNER|BDR_OUTER)]; if( LTInnerI != -1 ) LTInnerI = RBInnerI = EDGE_FILL; } else if(uFlags & BF_SOFT) { LTInnerI = LTInnerSoft[uType & (BDR_INNER|BDR_OUTER)]; LTOuterI = LTOuterSoft[uType & (BDR_INNER|BDR_OUTER)]; RBInnerI = RBInnerSoft[uType & (BDR_INNER|BDR_OUTER)]; RBOuterI = RBOuterSoft[uType & (BDR_INNER|BDR_OUTER)]; } else { LTInnerI = LTInnerNormal[uType & (BDR_INNER|BDR_OUTER)]; LTOuterI = LTOuterNormal[uType & (BDR_INNER|BDR_OUTER)]; RBInnerI = RBInnerNormal[uType & (BDR_INNER|BDR_OUTER)]; RBOuterI = RBOuterNormal[uType & (BDR_INNER|BDR_OUTER)]; } if((uFlags & BF_BOTTOMLEFT) == BF_BOTTOMLEFT) LBpenplus = 1; if((uFlags & BF_TOPRIGHT) == BF_TOPRIGHT) RTpenplus = 1; if((uFlags & BF_BOTTOMRIGHT) == BF_BOTTOMRIGHT) RBpenplus = 1; if((uFlags & BF_TOPLEFT) == BF_TOPLEFT) LTpenplus = 1; if(LTInnerI != -1) LTInnerPen = get_edge_pen (LTInnerI, theme, part, state); if(LTOuterI != -1) LTOuterPen = get_edge_pen (LTOuterI, theme, part, state); if(RBInnerI != -1) RBInnerPen = get_edge_pen (RBInnerI, theme, part, state); if(RBOuterI != -1) RBOuterPen = get_edge_pen (RBOuterI, theme, part, state); MoveToEx(hdc, 0, 0, &SavePoint); /* Draw the outer edge */ SelectObject(hdc, LTOuterPen); if(uFlags & BF_TOP) { MoveToEx(hdc, InnerRect.left, InnerRect.top, NULL); LineTo(hdc, InnerRect.right, InnerRect.top); } if(uFlags & BF_LEFT) { MoveToEx(hdc, InnerRect.left, InnerRect.top, NULL); LineTo(hdc, InnerRect.left, InnerRect.bottom); } SelectObject(hdc, RBOuterPen); if(uFlags & BF_BOTTOM) { MoveToEx(hdc, InnerRect.right-1, InnerRect.bottom-1, NULL); LineTo(hdc, InnerRect.left-1, InnerRect.bottom-1); } if(uFlags & BF_RIGHT) { MoveToEx(hdc, InnerRect.right-1, InnerRect.bottom-1, NULL); LineTo(hdc, InnerRect.right-1, InnerRect.top-1); } /* Draw the inner edge */ SelectObject(hdc, LTInnerPen); if(uFlags & BF_TOP) { MoveToEx(hdc, InnerRect.left+LTpenplus, InnerRect.top+1, NULL); LineTo(hdc, InnerRect.right-RTpenplus, InnerRect.top+1); } if(uFlags & BF_LEFT) { MoveToEx(hdc, InnerRect.left+1, InnerRect.top+LTpenplus, NULL); LineTo(hdc, InnerRect.left+1, InnerRect.bottom-LBpenplus); } SelectObject(hdc, RBInnerPen); if(uFlags & BF_BOTTOM) { MoveToEx(hdc, InnerRect.right-1-RBpenplus, InnerRect.bottom-2, NULL); LineTo(hdc, InnerRect.left-1+LBpenplus, InnerRect.bottom-2); } if(uFlags & BF_RIGHT) { MoveToEx(hdc, InnerRect.right-2, InnerRect.bottom-1-RBpenplus, NULL); LineTo(hdc, InnerRect.right-2, InnerRect.top-1+RTpenplus); } if( ((uFlags & BF_MIDDLE) && retval) || (uFlags & BF_ADJUST) ) { int add = (LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0) + (LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0); if(uFlags & BF_LEFT) InnerRect.left += add; if(uFlags & BF_RIGHT) InnerRect.right -= add; if(uFlags & BF_TOP) InnerRect.top += add; if(uFlags & BF_BOTTOM) InnerRect.bottom -= add; if((uFlags & BF_MIDDLE) && retval) { HBRUSH br = get_edge_brush ((uFlags & BF_MONO) ? EDGE_WINDOW : EDGE_FILL, theme, part, state); FillRect(hdc, &InnerRect, br); DeleteObject (br); } if(uFlags & BF_ADJUST) *contentsRect = InnerRect; } /* Cleanup */ SelectObject(hdc, SavePen); MoveToEx(hdc, SavePoint.x, SavePoint.y, NULL); if(LTInnerI != -1) DeleteObject (LTInnerPen); if(LTOuterI != -1) DeleteObject (LTOuterPen); if(RBInnerI != -1) DeleteObject (RBInnerPen); if(RBOuterI != -1) DeleteObject (RBOuterPen); return retval; } /*********************************************************************** * DrawThemeEdge (UXTHEME.@) * * DrawThemeEdge() is pretty similar to the vanilla DrawEdge() - the * difference is that it does not rely on the system colors alone, but * also allows color specification in the theme. */ HRESULT WINAPI DrawThemeEdge(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pDestRect, UINT uEdge, UINT uFlags, RECT *pContentRect) { TRACE("%d %d 0x%08x 0x%08x\n", iPartId, iStateId, uEdge, uFlags); if(!hTheme) return E_HANDLE; if(uFlags & BF_DIAGONAL) return draw_diag_edge (hdc, hTheme, iPartId, iStateId, pDestRect, uEdge, uFlags, pContentRect); else return draw_rect_edge (hdc, hTheme, iPartId, iStateId, pDestRect, uEdge, uFlags, pContentRect); } /*********************************************************************** * DrawThemeIcon (UXTHEME.@) */ HRESULT WINAPI DrawThemeIcon(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, HIMAGELIST himl, int iImageIndex) { FIXME("%d %d: stub\n", iPartId, iStateId); if(!hTheme) return E_HANDLE; return E_NOTIMPL; } /*********************************************************************** * DrawThemeText (UXTHEME.@) */ HRESULT WINAPI DrawThemeText(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCWSTR pszText, int iCharCount, DWORD flags, DWORD flags2, const RECT *pRect) { DTTOPTS opts = { 0 }; RECT rt; TRACE("%d %d\n", iPartId, iStateId); rt = *pRect; opts.dwSize = sizeof(opts); if (flags2 & DTT_GRAYED) { opts.dwFlags = DTT_TEXTCOLOR; opts.crText = GetSysColor(COLOR_GRAYTEXT); } return DrawThemeTextEx(hTheme, hdc, iPartId, iStateId, pszText, iCharCount, flags, &rt, &opts); } /*********************************************************************** * DrawThemeTextEx (UXTHEME.@) */ HRESULT WINAPI DrawThemeTextEx(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCWSTR pszText, int iCharCount, DWORD flags, RECT *rect, const DTTOPTS *options) { HRESULT hr; HFONT hFont = NULL; HGDIOBJ oldFont = NULL; LOGFONTW logfont; COLORREF textColor; COLORREF oldTextColor; int oldBkMode; TRACE("%p %p %d %d %s:%d 0x%08x %p %p\n", hTheme, hdc, iPartId, iStateId, debugstr_wn(pszText, iCharCount), iCharCount, flags, rect, options); if(!hTheme) return E_HANDLE; if (options->dwFlags & ~DTT_TEXTCOLOR) FIXME("unsupported flags 0x%08x\n", options->dwFlags); hr = GetThemeFont(hTheme, hdc, iPartId, iStateId, TMT_FONT, &logfont); if(SUCCEEDED(hr)) { hFont = CreateFontIndirectW(&logfont); if(!hFont) TRACE("Failed to create font\n"); } if(hFont) oldFont = SelectObject(hdc, hFont); if (options->dwFlags & DTT_TEXTCOLOR) textColor = options->crText; else { if(FAILED(GetThemeColor(hTheme, iPartId, iStateId, TMT_TEXTCOLOR, &textColor))) textColor = GetTextColor(hdc); } oldTextColor = SetTextColor(hdc, textColor); oldBkMode = SetBkMode(hdc, TRANSPARENT); DrawTextW(hdc, pszText, iCharCount, rect, flags); SetBkMode(hdc, oldBkMode); SetTextColor(hdc, oldTextColor); if(hFont) { SelectObject(hdc, oldFont); DeleteObject(hFont); } return S_OK; } /*********************************************************************** * GetThemeBackgroundContentRect (UXTHEME.@) */ HRESULT WINAPI GetThemeBackgroundContentRect(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pBoundingRect, RECT *pContentRect) { MARGINS margin; HRESULT hr; TRACE("(%d,%d)\n", iPartId, iStateId); if(!hTheme) return E_HANDLE; /* try content margins property... */ hr = GetThemeMargins(hTheme, hdc, iPartId, iStateId, TMT_CONTENTMARGINS, NULL, &margin); if(SUCCEEDED(hr)) { pContentRect->left = pBoundingRect->left + margin.cxLeftWidth; pContentRect->top = pBoundingRect->top + margin.cyTopHeight; pContentRect->right = pBoundingRect->right - margin.cxRightWidth; pContentRect->bottom = pBoundingRect->bottom - margin.cyBottomHeight; } else { /* otherwise, try to determine content rect from the background type and props */ int bgtype = BT_BORDERFILL; *pContentRect = *pBoundingRect; GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype); if(bgtype == BT_BORDERFILL) { int bordersize = 1; GetThemeInt(hTheme, iPartId, iStateId, TMT_BORDERSIZE, &bordersize); InflateRect(pContentRect, -bordersize, -bordersize); } else if ((bgtype == BT_IMAGEFILE) && (SUCCEEDED(hr = GetThemeMargins(hTheme, hdc, iPartId, iStateId, TMT_SIZINGMARGINS, NULL, &margin)))) { pContentRect->left = pBoundingRect->left + margin.cxLeftWidth; pContentRect->top = pBoundingRect->top + margin.cyTopHeight; pContentRect->right = pBoundingRect->right - margin.cxRightWidth; pContentRect->bottom = pBoundingRect->bottom - margin.cyBottomHeight; } /* If nothing was found, leave unchanged */ } TRACE("%s\n", wine_dbgstr_rect(pContentRect)); return S_OK; } /*********************************************************************** * GetThemeBackgroundExtent (UXTHEME.@) */ HRESULT WINAPI GetThemeBackgroundExtent(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pContentRect, RECT *pExtentRect) { MARGINS margin; HRESULT hr; TRACE("(%d,%d)\n", iPartId, iStateId); if(!hTheme) return E_HANDLE; /* try content margins property... */ hr = GetThemeMargins(hTheme, hdc, iPartId, iStateId, TMT_CONTENTMARGINS, NULL, &margin); if(SUCCEEDED(hr)) { pExtentRect->left = pContentRect->left - margin.cxLeftWidth; pExtentRect->top = pContentRect->top - margin.cyTopHeight; pExtentRect->right = pContentRect->right + margin.cxRightWidth; pExtentRect->bottom = pContentRect->bottom + margin.cyBottomHeight; } else { /* otherwise, try to determine content rect from the background type and props */ int bgtype = BT_BORDERFILL; *pExtentRect = *pContentRect; GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype); if(bgtype == BT_BORDERFILL) { int bordersize = 1; GetThemeInt(hTheme, iPartId, iStateId, TMT_BORDERSIZE, &bordersize); InflateRect(pExtentRect, bordersize, bordersize); } else if ((bgtype == BT_IMAGEFILE) && (SUCCEEDED(hr = GetThemeMargins(hTheme, hdc, iPartId, iStateId, TMT_SIZINGMARGINS, NULL, &margin)))) { pExtentRect->left = pContentRect->left - margin.cxLeftWidth; pExtentRect->top = pContentRect->top - margin.cyTopHeight; pExtentRect->right = pContentRect->right + margin.cxRightWidth; pExtentRect->bottom = pContentRect->bottom + margin.cyBottomHeight; } /* If nothing was found, leave unchanged */ } TRACE("%s\n", wine_dbgstr_rect(pExtentRect)); return S_OK; } static inline void flush_rgn_data( HRGN rgn, RGNDATA *data ) { HRGN tmp = ExtCreateRegion( NULL, data->rdh.dwSize + data->rdh.nRgnSize, data ); CombineRgn( rgn, rgn, tmp, RGN_OR ); DeleteObject( tmp ); data->rdh.nCount = 0; } static inline void add_row( HRGN rgn, RGNDATA *data, int x, int y, int len ) { RECT *rect = (RECT *)data->Buffer + data->rdh.nCount; if (len <= 0) return; rect->left = x; rect->top = y; rect->right = x + len; rect->bottom = y + 1; data->rdh.nCount++; if (data->rdh.nCount * sizeof(RECT) > data->rdh.nRgnSize - sizeof(RECT)) flush_rgn_data( rgn, data ); } static HRESULT create_image_bg_region(HTHEME theme, int part, int state, const RECT *rect, HRGN *rgn) { RECT r; HDC dc; HBITMAP bmp; HRGN hrgn; BOOL istrans; COLORREF transcolour; HBRUSH transbrush; unsigned int x, y, start; BITMAPINFO bitmapinfo; DWORD *bits; char buffer[4096]; RGNDATA *data = (RGNDATA *)buffer; if (FAILED(GetThemeBool(theme, part, state, TMT_TRANSPARENT, &istrans)) || !istrans) { *rgn = CreateRectRgn(rect->left, rect->top, rect->right, rect->bottom); return S_OK; } r = *rect; OffsetRect(&r, -r.left, -r.top); if (FAILED(GetThemeColor(theme, part, state, TMT_TRANSPARENTCOLOR, &transcolour))) transcolour = RGB(255, 0, 255); /* defaults to magenta */ dc = CreateCompatibleDC(NULL); if (!dc) { WARN("CreateCompatibleDC failed\n"); return E_FAIL; } bitmapinfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); bitmapinfo.bmiHeader.biWidth = rect->right - rect->left; bitmapinfo.bmiHeader.biHeight = -(rect->bottom - rect->top); bitmapinfo.bmiHeader.biPlanes = 1; bitmapinfo.bmiHeader.biBitCount = 32; bitmapinfo.bmiHeader.biCompression = BI_RGB; bitmapinfo.bmiHeader.biSizeImage = bitmapinfo.bmiHeader.biWidth * bitmapinfo.bmiHeader.biHeight * 4; bitmapinfo.bmiHeader.biXPelsPerMeter = 0; bitmapinfo.bmiHeader.biYPelsPerMeter = 0; bitmapinfo.bmiHeader.biClrUsed = 0; bitmapinfo.bmiHeader.biClrImportant = 0; bmp = CreateDIBSection(dc, &bitmapinfo, DIB_RGB_COLORS, (void**)&bits, NULL, 0); if (!bmp) { WARN("CreateDIBSection failed\n"); DeleteDC(dc); return E_FAIL; } SelectObject(dc, bmp); transbrush = CreateSolidBrush(transcolour); FillRect(dc, &r, transbrush); DeleteObject(transbrush); if (FAILED(DrawThemeBackground(theme, dc, part, state, &r, NULL))) { WARN("DrawThemeBackground failed\n"); DeleteObject(bmp); DeleteDC(dc); return E_FAIL; } data->rdh.dwSize = sizeof(data->rdh); data->rdh.iType = RDH_RECTANGLES; data->rdh.nCount = 0; data->rdh.nRgnSize = sizeof(buffer) - sizeof(data->rdh); hrgn = CreateRectRgn(0, 0, 0, 0); for (y = 0; y < r.bottom; y++, bits += r.right) { x = 0; while (x < r.right) { while (x < r.right && (bits[x] & 0xffffff) == transcolour) x++; start = x; while (x < r.right && !((bits[x] & 0xffffff) == transcolour)) x++; add_row( hrgn, data, rect->left + start, rect->top + y, x - start ); } } if (data->rdh.nCount > 0) flush_rgn_data(hrgn, data); *rgn = hrgn; DeleteObject(bmp); DeleteDC(dc); return S_OK; } /*********************************************************************** * GetThemeBackgroundRegion (UXTHEME.@) * * Calculate the background region, taking into consideration transparent areas * of the background image. */ HRESULT WINAPI GetThemeBackgroundRegion(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, HRGN *pRegion) { HRESULT hr = S_OK; int bgtype = BT_BORDERFILL; TRACE("(%p,%p,%d,%d)\n", hTheme, hdc, iPartId, iStateId); if(!hTheme) return E_HANDLE; if(!pRect || !pRegion) return E_POINTER; GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype); if(bgtype == BT_IMAGEFILE) { hr = create_image_bg_region(hTheme, iPartId, iStateId, pRect, pRegion); } else if(bgtype == BT_BORDERFILL) { *pRegion = CreateRectRgn(pRect->left, pRect->top, pRect->right, pRect->bottom); if(!*pRegion) hr = HRESULT_FROM_WIN32(GetLastError()); } else { FIXME("Unknown background type\n"); /* This should never happen, and hence I don't know what to return */ hr = E_FAIL; } return hr; } /* compute part size for "borderfill" backgrounds */ static HRESULT get_border_background_size (HTHEME hTheme, int iPartId, int iStateId, THEMESIZE eSize, POINT* psz) { HRESULT hr = S_OK; int bordersize = 1; if (SUCCEEDED (hr = GetThemeInt(hTheme, iPartId, iStateId, TMT_BORDERSIZE, &bordersize))) { psz->x = psz->y = 2*bordersize; if (eSize != TS_MIN) { psz->x++; psz->y++; } } return hr; } /*********************************************************************** * GetThemePartSize (UXTHEME.@) */ HRESULT WINAPI GetThemePartSize(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, RECT *prc, THEMESIZE eSize, SIZE *psz) { int bgtype = BT_BORDERFILL; HRESULT hr = S_OK; POINT size = {1, 1}; if(!hTheme) return E_HANDLE; GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype); if (bgtype == BT_NONE) /* do nothing */; else if(bgtype == BT_IMAGEFILE) hr = get_image_part_size (hTheme, hdc, iPartId, iStateId, prc, eSize, &size); else if(bgtype == BT_BORDERFILL) hr = get_border_background_size (hTheme, iPartId, iStateId, eSize, &size); else { FIXME("Unknown background type\n"); /* This should never happen, and hence I don't know what to return */ hr = E_FAIL; } psz->cx = size.x; psz->cy = size.y; return hr; } /*********************************************************************** * GetThemeTextExtent (UXTHEME.@) */ HRESULT WINAPI GetThemeTextExtent(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCWSTR pszText, int iCharCount, DWORD dwTextFlags, const RECT *pBoundingRect, RECT *pExtentRect) { HRESULT hr; HFONT hFont = NULL; HGDIOBJ oldFont = NULL; LOGFONTW logfont; RECT rt = {0,0,0xFFFF,0xFFFF}; TRACE("%d %d\n", iPartId, iStateId); if(!hTheme) return E_HANDLE; if(pBoundingRect) rt = *pBoundingRect; hr = GetThemeFont(hTheme, hdc, iPartId, iStateId, TMT_FONT, &logfont); if(SUCCEEDED(hr)) { hFont = CreateFontIndirectW(&logfont); if(!hFont) TRACE("Failed to create font\n"); } if(hFont) oldFont = SelectObject(hdc, hFont); DrawTextW(hdc, pszText, iCharCount, &rt, dwTextFlags|DT_CALCRECT); *pExtentRect = rt; if(hFont) { SelectObject(hdc, oldFont); DeleteObject(hFont); } return S_OK; } /*********************************************************************** * GetThemeTextMetrics (UXTHEME.@) */ HRESULT WINAPI GetThemeTextMetrics(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, TEXTMETRICW *ptm) { HRESULT hr; HFONT hFont = NULL; HGDIOBJ oldFont = NULL; LOGFONTW logfont; TRACE("(%p, %p, %d, %d)\n", hTheme, hdc, iPartId, iStateId); if(!hTheme) return E_HANDLE; hr = GetThemeFont(hTheme, hdc, iPartId, iStateId, TMT_FONT, &logfont); if(SUCCEEDED(hr)) { hFont = CreateFontIndirectW(&logfont); if(!hFont) TRACE("Failed to create font\n"); } if(hFont) oldFont = SelectObject(hdc, hFont); if(!GetTextMetricsW(hdc, ptm)) hr = HRESULT_FROM_WIN32(GetLastError()); if(hFont) { SelectObject(hdc, oldFont); DeleteObject(hFont); } return hr; } /*********************************************************************** * IsThemeBackgroundPartiallyTransparent (UXTHEME.@) */ BOOL WINAPI IsThemeBackgroundPartiallyTransparent(HTHEME hTheme, int iPartId, int iStateId) { int bgtype = BT_BORDERFILL; RECT rect = {0, 0, 0, 0}; HBITMAP bmpSrc; RECT rcSrc; BOOL hasAlpha; INT transparent; COLORREF transparentcolor; TRACE("(%d,%d)\n", iPartId, iStateId); if(!hTheme) return FALSE; GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_BGTYPE, &bgtype); if (bgtype != BT_IMAGEFILE) return FALSE; if(FAILED (UXTHEME_LoadImage (hTheme, 0, iPartId, iStateId, &rect, FALSE, &bmpSrc, &rcSrc, &hasAlpha))) return FALSE; get_transparency (hTheme, iPartId, iStateId, hasAlpha, &transparent, &transparentcolor, FALSE); return (transparent != ALPHABLEND_NONE); }