winhttp: Use schannel for HTTPS connection by defaul and get rid of OpenSSL dependency.
[wine] / dlls / uxtheme / system.c
1 /*
2  * Win32 5.1 Theme system
3  *
4  * Copyright (C) 2003 Kevin Koltzau
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22
23 #include <stdarg.h>
24 #include <stdio.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "wingdi.h"
29 #include "winuser.h"
30 #include "winreg.h"
31 #include "vfwmsgs.h"
32 #include "uxtheme.h"
33 #include "tmschema.h"
34
35 #include "uxthemedll.h"
36 #include "msstyles.h"
37
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(uxtheme);
41
42 /***********************************************************************
43  * Defines and global variables
44  */
45
46 static const WCHAR szThemeManager[] = {
47     'S','o','f','t','w','a','r','e','\\',
48     'M','i','c','r','o','s','o','f','t','\\',
49     'W','i','n','d','o','w','s','\\',
50     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
51     'T','h','e','m','e','M','a','n','a','g','e','r','\0'
52 };
53 static const WCHAR szThemeActive[] = {'T','h','e','m','e','A','c','t','i','v','e','\0'};
54 static const WCHAR szSizeName[] = {'S','i','z','e','N','a','m','e','\0'};
55 static const WCHAR szColorName[] = {'C','o','l','o','r','N','a','m','e','\0'};
56 static const WCHAR szDllName[] = {'D','l','l','N','a','m','e','\0'};
57
58 static const WCHAR szIniDocumentation[] = {'d','o','c','u','m','e','n','t','a','t','i','o','n','\0'};
59
60 DECLSPEC_HIDDEN ATOM atDialogThemeEnabled;
61
62 static DWORD dwThemeAppProperties = STAP_ALLOW_NONCLIENT | STAP_ALLOW_CONTROLS;
63 static ATOM atWindowTheme;
64 static ATOM atSubAppName;
65 static ATOM atSubIdList;
66
67 static BOOL bThemeActive = FALSE;
68 static WCHAR szCurrentTheme[MAX_PATH];
69 static WCHAR szCurrentColor[64];
70 static WCHAR szCurrentSize[64];
71
72 /***********************************************************************/
73
74 static BOOL CALLBACK UXTHEME_broadcast_msg_enumchild (HWND hWnd, LPARAM msg)
75 {
76     PostMessageW(hWnd, msg, 0, 0);
77     return TRUE;
78 }
79
80 /* Broadcast a message to *all* windows, including children */
81 static BOOL CALLBACK UXTHEME_broadcast_msg (HWND hWnd, LPARAM msg)
82 {
83     if (hWnd == NULL)
84     {
85         EnumWindows (UXTHEME_broadcast_msg, msg);
86     }
87     else
88     {
89         PostMessageW(hWnd, msg, 0, 0);
90         EnumChildWindows (hWnd, UXTHEME_broadcast_msg_enumchild, msg);
91     }
92     return TRUE;
93 }
94
95 /* At the end of the day this is a subset of what SHRegGetPath() does - copied
96  * here to avoid linking against shlwapi. */
97 static DWORD query_reg_path (HKEY hKey, LPCWSTR lpszValue,
98                              LPVOID pvData)
99 {
100   DWORD dwRet, dwType, dwUnExpDataLen = MAX_PATH, dwExpDataLen;
101
102   TRACE("(hkey=%p,%s,%p)\n", hKey, debugstr_w(lpszValue),
103         pvData);
104
105   dwRet = RegQueryValueExW(hKey, lpszValue, 0, &dwType, pvData, &dwUnExpDataLen);
106   if (dwRet!=ERROR_SUCCESS && dwRet!=ERROR_MORE_DATA)
107       return dwRet;
108
109   if (dwType == REG_EXPAND_SZ)
110   {
111     DWORD nBytesToAlloc;
112
113     /* Expand type REG_EXPAND_SZ into REG_SZ */
114     LPWSTR szData;
115
116     /* If the caller didn't supply a buffer or the buffer is too small we have
117      * to allocate our own
118      */
119     if (dwRet == ERROR_MORE_DATA)
120     {
121       WCHAR cNull = '\0';
122       nBytesToAlloc = dwUnExpDataLen;
123
124       szData = LocalAlloc(LMEM_ZEROINIT, nBytesToAlloc);
125       RegQueryValueExW (hKey, lpszValue, 0, NULL, (LPBYTE)szData, &nBytesToAlloc);
126       dwExpDataLen = ExpandEnvironmentStringsW(szData, &cNull, 1);
127       dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
128       LocalFree(szData);
129     }
130     else
131     {
132       nBytesToAlloc = (lstrlenW(pvData) + 1) * sizeof(WCHAR);
133       szData = LocalAlloc(LMEM_ZEROINIT, nBytesToAlloc );
134       lstrcpyW(szData, pvData);
135       dwExpDataLen = ExpandEnvironmentStringsW(szData, pvData, MAX_PATH );
136       if (dwExpDataLen > MAX_PATH) dwRet = ERROR_MORE_DATA;
137       dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
138       LocalFree(szData);
139     }
140   }
141
142   RegCloseKey(hKey);
143   return dwRet;
144 }
145
146 /***********************************************************************
147  *      UXTHEME_LoadTheme
148  *
149  * Set the current active theme from the registry
150  */
151 static void UXTHEME_LoadTheme(void)
152 {
153     HKEY hKey;
154     DWORD buffsize;
155     HRESULT hr;
156     WCHAR tmp[10];
157     PTHEME_FILE pt;
158
159     /* Get current theme configuration */
160     if(!RegOpenKeyW(HKEY_CURRENT_USER, szThemeManager, &hKey)) {
161         TRACE("Loading theme config\n");
162         buffsize = sizeof(tmp)/sizeof(tmp[0]);
163         if(!RegQueryValueExW(hKey, szThemeActive, NULL, NULL, (LPBYTE)tmp, &buffsize)) {
164             bThemeActive = (tmp[0] != '0');
165         }
166         else {
167             bThemeActive = FALSE;
168             TRACE("Failed to get ThemeActive: %d\n", GetLastError());
169         }
170         buffsize = sizeof(szCurrentColor)/sizeof(szCurrentColor[0]);
171         if(RegQueryValueExW(hKey, szColorName, NULL, NULL, (LPBYTE)szCurrentColor, &buffsize))
172             szCurrentColor[0] = '\0';
173         buffsize = sizeof(szCurrentSize)/sizeof(szCurrentSize[0]);
174         if(RegQueryValueExW(hKey, szSizeName, NULL, NULL, (LPBYTE)szCurrentSize, &buffsize))
175             szCurrentSize[0] = '\0';
176         if (query_reg_path (hKey, szDllName, szCurrentTheme))
177             szCurrentTheme[0] = '\0';
178         RegCloseKey(hKey);
179     }
180     else
181         TRACE("Failed to open theme registry key\n");
182
183     if(bThemeActive) {
184         /* Make sure the theme requested is actually valid */
185         hr = MSSTYLES_OpenThemeFile(szCurrentTheme,
186                                     szCurrentColor[0]?szCurrentColor:NULL,
187                                     szCurrentSize[0]?szCurrentSize:NULL,
188                                     &pt);
189         if(FAILED(hr)) {
190             bThemeActive = FALSE;
191             szCurrentTheme[0] = '\0';
192             szCurrentColor[0] = '\0';
193             szCurrentSize[0] = '\0';
194         }
195         else {
196             /* Make sure the global color & size match the theme */
197             lstrcpynW(szCurrentColor, pt->pszSelectedColor, sizeof(szCurrentColor)/sizeof(szCurrentColor[0]));
198             lstrcpynW(szCurrentSize, pt->pszSelectedSize, sizeof(szCurrentSize)/sizeof(szCurrentSize[0]));
199
200             MSSTYLES_SetActiveTheme(pt, FALSE);
201             TRACE("Theme active: %s %s %s\n", debugstr_w(szCurrentTheme),
202                 debugstr_w(szCurrentColor), debugstr_w(szCurrentSize));
203             MSSTYLES_CloseThemeFile(pt);
204         }
205     }
206     if(!bThemeActive) {
207         MSSTYLES_SetActiveTheme(NULL, FALSE);
208         TRACE("Theming not active\n");
209     }
210 }
211
212 /***********************************************************************/
213
214 static const char * const SysColorsNames[] =
215 {
216     "Scrollbar",                /* COLOR_SCROLLBAR */
217     "Background",               /* COLOR_BACKGROUND */
218     "ActiveTitle",              /* COLOR_ACTIVECAPTION */
219     "InactiveTitle",            /* COLOR_INACTIVECAPTION */
220     "Menu",                     /* COLOR_MENU */
221     "Window",                   /* COLOR_WINDOW */
222     "WindowFrame",              /* COLOR_WINDOWFRAME */
223     "MenuText",                 /* COLOR_MENUTEXT */
224     "WindowText",               /* COLOR_WINDOWTEXT */
225     "TitleText",                /* COLOR_CAPTIONTEXT */
226     "ActiveBorder",             /* COLOR_ACTIVEBORDER */
227     "InactiveBorder",           /* COLOR_INACTIVEBORDER */
228     "AppWorkSpace",             /* COLOR_APPWORKSPACE */
229     "Hilight",                  /* COLOR_HIGHLIGHT */
230     "HilightText",              /* COLOR_HIGHLIGHTTEXT */
231     "ButtonFace",               /* COLOR_BTNFACE */
232     "ButtonShadow",             /* COLOR_BTNSHADOW */
233     "GrayText",                 /* COLOR_GRAYTEXT */
234     "ButtonText",               /* COLOR_BTNTEXT */
235     "InactiveTitleText",        /* COLOR_INACTIVECAPTIONTEXT */
236     "ButtonHilight",            /* COLOR_BTNHIGHLIGHT */
237     "ButtonDkShadow",           /* COLOR_3DDKSHADOW */
238     "ButtonLight",              /* COLOR_3DLIGHT */
239     "InfoText",                 /* COLOR_INFOTEXT */
240     "InfoWindow",               /* COLOR_INFOBK */
241     "ButtonAlternateFace",      /* COLOR_ALTERNATEBTNFACE */
242     "HotTrackingColor",         /* COLOR_HOTLIGHT */
243     "GradientActiveTitle",      /* COLOR_GRADIENTACTIVECAPTION */
244     "GradientInactiveTitle",    /* COLOR_GRADIENTINACTIVECAPTION */
245     "MenuHilight",              /* COLOR_MENUHILIGHT */
246     "MenuBar",                  /* COLOR_MENUBAR */
247 };
248 static const WCHAR strColorKey[] = 
249     { 'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
250       'C','o','l','o','r','s',0 };
251 static const WCHAR keyFlatMenus[] = { 'F','l','a','t','M','e','n','u', 0};
252 static const WCHAR keyGradientCaption[] = { 'G','r','a','d','i','e','n','t',
253                                             'C','a','p','t','i','o','n', 0 };
254 static const WCHAR keyNonClientMetrics[] = { 'N','o','n','C','l','i','e','n','t',
255                                              'M','e','t','r','i','c','s',0 };
256 static const WCHAR keyIconTitleFont[] = { 'I','c','o','n','T','i','t','l','e',
257                                           'F','o','n','t',0 };
258
259 static const struct BackupSysParam
260 {
261     int spiGet, spiSet;
262     const WCHAR* keyName;
263 } backupSysParams[] = 
264 {
265     {SPI_GETFLATMENU, SPI_SETFLATMENU, keyFlatMenus},
266     {SPI_GETGRADIENTCAPTIONS, SPI_SETGRADIENTCAPTIONS, keyGradientCaption},
267     {-1, -1, 0}
268 };
269
270 #define NUM_SYS_COLORS     (COLOR_MENUBAR+1)
271
272 static void save_sys_colors (HKEY baseKey)
273 {
274     char colorStr[13];
275     HKEY hKey;
276     int i;
277
278     if (RegCreateKeyExW( baseKey, strColorKey,
279                          0, 0, 0, KEY_ALL_ACCESS,
280                          0, &hKey, 0 ) == ERROR_SUCCESS)
281     {
282         for (i = 0; i < NUM_SYS_COLORS; i++)
283         {
284             COLORREF col = GetSysColor (i);
285         
286             sprintf (colorStr, "%d %d %d", 
287                 GetRValue (col), GetGValue (col), GetBValue (col));
288
289             RegSetValueExA (hKey, SysColorsNames[i], 0, REG_SZ, 
290                 (BYTE*)colorStr, strlen (colorStr)+1);
291         }
292         RegCloseKey (hKey);
293     }
294 }
295
296 /* Before activating a theme, query current system colors, certain settings 
297  * and backup them in the registry, so they can be restored when the theme 
298  * is deactivated */
299 static void UXTHEME_BackupSystemMetrics(void)
300 {
301     HKEY hKey;
302     const struct BackupSysParam* bsp = backupSysParams;
303
304     if (RegCreateKeyExW( HKEY_CURRENT_USER, szThemeManager,
305                          0, 0, 0, KEY_ALL_ACCESS,
306                          0, &hKey, 0) == ERROR_SUCCESS)
307     {
308         NONCLIENTMETRICSW ncm;
309         LOGFONTW iconTitleFont;
310         
311         /* back up colors */
312         save_sys_colors (hKey);
313     
314         /* back up "other" settings */
315         while (bsp->spiGet >= 0)
316         {
317             DWORD value;
318             
319             SystemParametersInfoW (bsp->spiGet, 0, &value, 0);
320             RegSetValueExW (hKey, bsp->keyName, 0, REG_DWORD, 
321                 (LPBYTE)&value, sizeof (value));
322         
323             bsp++;
324         }
325         
326         /* back up non-client metrics */
327         memset (&ncm, 0, sizeof (ncm));
328         ncm.cbSize = sizeof (ncm);
329         SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, sizeof (ncm), &ncm, 0);
330         RegSetValueExW (hKey, keyNonClientMetrics, 0, REG_BINARY, (LPBYTE)&ncm,
331             sizeof (ncm));
332         memset (&iconTitleFont, 0, sizeof (iconTitleFont));
333         SystemParametersInfoW (SPI_GETICONTITLELOGFONT, sizeof (iconTitleFont),
334             &iconTitleFont, 0);
335         RegSetValueExW (hKey, keyIconTitleFont, 0, REG_BINARY, 
336             (LPBYTE)&iconTitleFont, sizeof (iconTitleFont));
337     
338         RegCloseKey (hKey);
339     }
340 }
341
342 /* Read back old settings after a theme was deactivated */
343 static void UXTHEME_RestoreSystemMetrics(void)
344 {
345     HKEY hKey;
346     const struct BackupSysParam* bsp = backupSysParams;
347
348     if (RegOpenKeyExW (HKEY_CURRENT_USER, szThemeManager,
349                        0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS) 
350     {
351         HKEY colorKey;
352     
353         /* read backed-up colors */
354         if (RegOpenKeyExW (hKey, strColorKey,
355                            0, KEY_QUERY_VALUE, &colorKey) == ERROR_SUCCESS) 
356         {
357             int i;
358             COLORREF sysCols[NUM_SYS_COLORS];
359             int sysColsIndices[NUM_SYS_COLORS];
360             int sysColCount = 0;
361         
362             for (i = 0; i < NUM_SYS_COLORS; i++)
363             {
364                 DWORD type;
365                 char colorStr[13];
366                 DWORD count = sizeof(colorStr);
367             
368                 if (RegQueryValueExA (colorKey, SysColorsNames[i], 0,
369                     &type, (LPBYTE) colorStr, &count) == ERROR_SUCCESS)
370                 {
371                     int r, g, b;
372                     if (sscanf (colorStr, "%d %d %d", &r, &g, &b) == 3)
373                     {
374                         sysColsIndices[sysColCount] = i;
375                         sysCols[sysColCount] = RGB(r, g, b);
376                         sysColCount++;
377                     }
378                 }
379             }
380             RegCloseKey (colorKey);
381           
382             SetSysColors (sysColCount, sysColsIndices, sysCols);
383         }
384     
385         /* read backed-up other settings */
386         while (bsp->spiGet >= 0)
387         {
388             DWORD value;
389             DWORD count = sizeof(value);
390             DWORD type;
391             
392             if (RegQueryValueExW (hKey, bsp->keyName, 0,
393                 &type, (LPBYTE)&value, &count) == ERROR_SUCCESS)
394             {
395                 SystemParametersInfoW (bsp->spiSet, 0, UlongToPtr(value), SPIF_UPDATEINIFILE);
396             }
397         
398             bsp++;
399         }
400     
401         /* read backed-up non-client metrics */
402         {
403             NONCLIENTMETRICSW ncm;
404             LOGFONTW iconTitleFont;
405             DWORD count = sizeof(ncm);
406             DWORD type;
407             
408             if (RegQueryValueExW (hKey, keyNonClientMetrics, 0,
409                 &type, (LPBYTE)&ncm, &count) == ERROR_SUCCESS)
410             {
411                 SystemParametersInfoW (SPI_SETNONCLIENTMETRICS, 
412                     count, &ncm, SPIF_UPDATEINIFILE);
413             }
414             
415             count = sizeof(iconTitleFont);
416             
417             if (RegQueryValueExW (hKey, keyIconTitleFont, 0,
418                 &type, (LPBYTE)&iconTitleFont, &count) == ERROR_SUCCESS)
419             {
420                 SystemParametersInfoW (SPI_SETICONTITLELOGFONT, 
421                     count, &iconTitleFont, SPIF_UPDATEINIFILE);
422             }
423         }
424       
425         RegCloseKey (hKey);
426     }
427 }
428
429 /* Make system settings persistent, so they're in effect even w/o uxtheme 
430  * loaded.
431  * For efficiency reasons, only the last SystemParametersInfoW sets
432  * SPIF_SENDWININICHANGE */
433 static void UXTHEME_SaveSystemMetrics(void)
434 {
435     const struct BackupSysParam* bsp = backupSysParams;
436     NONCLIENTMETRICSW ncm;
437     LOGFONTW iconTitleFont;
438
439     save_sys_colors (HKEY_CURRENT_USER);
440
441     while (bsp->spiGet >= 0)
442     {
443         DWORD value;
444         
445         SystemParametersInfoW (bsp->spiGet, 0, &value, 0);
446         SystemParametersInfoW (bsp->spiSet, 0, UlongToPtr(value), SPIF_UPDATEINIFILE);
447         bsp++;
448     }
449     
450     memset (&ncm, 0, sizeof (ncm));
451     ncm.cbSize = sizeof (ncm);
452     SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, sizeof (ncm), &ncm, 0);
453     SystemParametersInfoW (SPI_SETNONCLIENTMETRICS, sizeof (ncm), &ncm,
454         SPIF_UPDATEINIFILE);
455
456     memset (&iconTitleFont, 0, sizeof (iconTitleFont));
457     SystemParametersInfoW (SPI_GETICONTITLELOGFONT, sizeof (iconTitleFont),
458         &iconTitleFont, 0);
459     SystemParametersInfoW (SPI_SETICONTITLELOGFONT, sizeof (iconTitleFont),
460         &iconTitleFont, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
461 }
462
463 /***********************************************************************
464  *      UXTHEME_SetActiveTheme
465  *
466  * Change the current active theme
467  */
468 static HRESULT UXTHEME_SetActiveTheme(PTHEME_FILE tf)
469 {
470     HKEY hKey;
471     WCHAR tmp[2];
472     HRESULT hr;
473
474     if(tf && !bThemeActive) UXTHEME_BackupSystemMetrics();
475     hr = MSSTYLES_SetActiveTheme(tf, TRUE);
476     if(FAILED(hr))
477         return hr;
478     if(tf) {
479         bThemeActive = TRUE;
480         lstrcpynW(szCurrentTheme, tf->szThemeFile, sizeof(szCurrentTheme)/sizeof(szCurrentTheme[0]));
481         lstrcpynW(szCurrentColor, tf->pszSelectedColor, sizeof(szCurrentColor)/sizeof(szCurrentColor[0]));
482         lstrcpynW(szCurrentSize, tf->pszSelectedSize, sizeof(szCurrentSize)/sizeof(szCurrentSize[0]));
483     }
484     else {
485         UXTHEME_RestoreSystemMetrics();
486         bThemeActive = FALSE;
487         szCurrentTheme[0] = '\0';
488         szCurrentColor[0] = '\0';
489         szCurrentSize[0] = '\0';
490     }
491
492     TRACE("Writing theme config to registry\n");
493     if(!RegCreateKeyW(HKEY_CURRENT_USER, szThemeManager, &hKey)) {
494         tmp[0] = bThemeActive?'1':'0';
495         tmp[1] = '\0';
496         RegSetValueExW(hKey, szThemeActive, 0, REG_SZ, (const BYTE*)tmp, sizeof(WCHAR)*2);
497         if(bThemeActive) {
498             RegSetValueExW(hKey, szColorName, 0, REG_SZ, (const BYTE*)szCurrentColor, 
499                 (lstrlenW(szCurrentColor)+1)*sizeof(WCHAR));
500             RegSetValueExW(hKey, szSizeName, 0, REG_SZ, (const BYTE*)szCurrentSize, 
501                 (lstrlenW(szCurrentSize)+1)*sizeof(WCHAR));
502             RegSetValueExW(hKey, szDllName, 0, REG_SZ, (const BYTE*)szCurrentTheme, 
503                 (lstrlenW(szCurrentTheme)+1)*sizeof(WCHAR));
504         }
505         else {
506             RegDeleteValueW(hKey, szColorName);
507             RegDeleteValueW(hKey, szSizeName);
508             RegDeleteValueW(hKey, szDllName);
509
510         }
511         RegCloseKey(hKey);
512     }
513     else
514         TRACE("Failed to open theme registry key\n");
515     
516     UXTHEME_SaveSystemMetrics ();
517     
518     return hr;
519 }
520
521 /***********************************************************************
522  *      UXTHEME_InitSystem
523  */
524 void UXTHEME_InitSystem(HINSTANCE hInst)
525 {
526     static const WCHAR szWindowTheme[] = {
527         'u','x','_','t','h','e','m','e','\0'
528     };
529     static const WCHAR szSubAppName[] = {
530         'u','x','_','s','u','b','a','p','p','\0'
531     };
532     static const WCHAR szSubIdList[] = {
533         'u','x','_','s','u','b','i','d','l','s','t','\0'
534     };
535     static const WCHAR szDialogThemeEnabled[] = {
536         'u','x','_','d','i','a','l','o','g','t','h','e','m','e','\0'
537     };
538
539     atWindowTheme        = GlobalAddAtomW(szWindowTheme);
540     atSubAppName         = GlobalAddAtomW(szSubAppName);
541     atSubIdList          = GlobalAddAtomW(szSubIdList);
542     atDialogThemeEnabled = GlobalAddAtomW(szDialogThemeEnabled);
543
544     UXTHEME_LoadTheme();
545 }
546
547 /***********************************************************************
548  *      IsAppThemed                                         (UXTHEME.@)
549  */
550 BOOL WINAPI IsAppThemed(void)
551 {
552     return IsThemeActive();
553 }
554
555 /***********************************************************************
556  *      IsThemeActive                                       (UXTHEME.@)
557  */
558 BOOL WINAPI IsThemeActive(void)
559 {
560     TRACE("\n");
561     SetLastError(ERROR_SUCCESS);
562     return bThemeActive;
563 }
564
565 /***********************************************************************
566  *      EnableTheming                                       (UXTHEME.@)
567  *
568  * NOTES
569  * This is a global and persistent change
570  */
571 HRESULT WINAPI EnableTheming(BOOL fEnable)
572 {
573     HKEY hKey;
574     WCHAR szEnabled[] = {'0','\0'};
575
576     TRACE("(%d)\n", fEnable);
577
578     if(fEnable != bThemeActive) {
579         if(fEnable) 
580             UXTHEME_BackupSystemMetrics();
581         else
582             UXTHEME_RestoreSystemMetrics();
583         UXTHEME_SaveSystemMetrics ();
584         bThemeActive = fEnable;
585         if(bThemeActive) szEnabled[0] = '1';
586         if(!RegOpenKeyW(HKEY_CURRENT_USER, szThemeManager, &hKey)) {
587             RegSetValueExW(hKey, szThemeActive, 0, REG_SZ, (LPBYTE)szEnabled, sizeof(WCHAR));
588             RegCloseKey(hKey);
589         }
590         UXTHEME_broadcast_msg (NULL, WM_THEMECHANGED);
591     }
592     return S_OK;
593 }
594
595 /***********************************************************************
596  *      UXTHEME_SetWindowProperty
597  *
598  * I'm using atoms as there may be large numbers of duplicated strings
599  * and they do the work of keeping memory down as a cause of that quite nicely
600  */
601 static HRESULT UXTHEME_SetWindowProperty(HWND hwnd, ATOM aProp, LPCWSTR pszValue)
602 {
603     ATOM oldValue = (ATOM)(size_t)RemovePropW(hwnd, (LPCWSTR)MAKEINTATOM(aProp));
604     if(oldValue)
605         DeleteAtom(oldValue);
606     if(pszValue) {
607         ATOM atValue = AddAtomW(pszValue);
608         if(!atValue
609            || !SetPropW(hwnd, (LPCWSTR)MAKEINTATOM(aProp), (LPWSTR)MAKEINTATOM(atValue))) {
610             HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
611             if(atValue) DeleteAtom(atValue);
612             return hr;
613         }
614     }
615     return S_OK;
616 }
617
618 static LPWSTR UXTHEME_GetWindowProperty(HWND hwnd, ATOM aProp, LPWSTR pszBuffer, int dwLen)
619 {
620     ATOM atValue = (ATOM)(size_t)GetPropW(hwnd, (LPCWSTR)MAKEINTATOM(aProp));
621     if(atValue) {
622         if(GetAtomNameW(atValue, pszBuffer, dwLen))
623             return pszBuffer;
624         TRACE("property defined, but unable to get value\n");
625     }
626     return NULL;
627 }
628
629 /***********************************************************************
630  *      OpenThemeDataEx                                     (UXTHEME.61)
631  */
632 HTHEME WINAPI OpenThemeDataEx(HWND hwnd, LPCWSTR pszClassList, DWORD flags)
633 {
634     WCHAR szAppBuff[256];
635     WCHAR szClassBuff[256];
636     LPCWSTR pszAppName;
637     LPCWSTR pszUseClassList;
638     HTHEME hTheme = NULL;
639     TRACE("(%p,%s, %x)\n", hwnd, debugstr_w(pszClassList), flags);
640
641     if(!pszClassList)
642     {
643         SetLastError(E_POINTER);
644         return NULL;
645     }
646
647     if(flags)
648         FIXME("unhandled flags: %x\n", flags);
649
650     if(bThemeActive)
651     {
652         pszAppName = UXTHEME_GetWindowProperty(hwnd, atSubAppName, szAppBuff, sizeof(szAppBuff)/sizeof(szAppBuff[0]));
653         /* If SetWindowTheme was used on the window, that overrides the class list passed to this function */
654         pszUseClassList = UXTHEME_GetWindowProperty(hwnd, atSubIdList, szClassBuff, sizeof(szClassBuff)/sizeof(szClassBuff[0]));
655         if(!pszUseClassList)
656             pszUseClassList = pszClassList;
657
658         if (pszUseClassList)
659             hTheme = MSSTYLES_OpenThemeClass(pszAppName, pszUseClassList);
660     }
661     if(IsWindow(hwnd))
662         SetPropW(hwnd, (LPCWSTR)MAKEINTATOM(atWindowTheme), hTheme);
663     TRACE(" = %p\n", hTheme);
664     return hTheme;
665 }
666
667 /***********************************************************************
668  *      OpenThemeData                                       (UXTHEME.@)
669  */
670 HTHEME WINAPI OpenThemeData(HWND hwnd, LPCWSTR classlist)
671 {
672     return OpenThemeDataEx(hwnd, classlist, 0);
673 }
674
675 /***********************************************************************
676  *      GetWindowTheme                                      (UXTHEME.@)
677  *
678  * Retrieve the last theme opened for a window.
679  *
680  * PARAMS
681  *  hwnd  [I] window to retrieve the theme for
682  *
683  * RETURNS
684  *  The most recent theme.
685  */
686 HTHEME WINAPI GetWindowTheme(HWND hwnd)
687 {
688     TRACE("(%p)\n", hwnd);
689     return GetPropW(hwnd, (LPCWSTR)MAKEINTATOM(atWindowTheme));
690 }
691
692 /***********************************************************************
693  *      SetWindowTheme                                      (UXTHEME.@)
694  *
695  * Persistent through the life of the window, even after themes change
696  */
697 HRESULT WINAPI SetWindowTheme(HWND hwnd, LPCWSTR pszSubAppName,
698                               LPCWSTR pszSubIdList)
699 {
700     HRESULT hr;
701     TRACE("(%p,%s,%s)\n", hwnd, debugstr_w(pszSubAppName),
702           debugstr_w(pszSubIdList));
703     hr = UXTHEME_SetWindowProperty(hwnd, atSubAppName, pszSubAppName);
704     if(SUCCEEDED(hr))
705         hr = UXTHEME_SetWindowProperty(hwnd, atSubIdList, pszSubIdList);
706     if(SUCCEEDED(hr))
707         UXTHEME_broadcast_msg (hwnd, WM_THEMECHANGED);
708     return hr;
709 }
710
711 /***********************************************************************
712  *      GetCurrentThemeName                                 (UXTHEME.@)
713  */
714 HRESULT WINAPI GetCurrentThemeName(LPWSTR pszThemeFileName, int dwMaxNameChars,
715                                    LPWSTR pszColorBuff, int cchMaxColorChars,
716                                    LPWSTR pszSizeBuff, int cchMaxSizeChars)
717 {
718     if(!bThemeActive)
719         return E_PROP_ID_UNSUPPORTED;
720     if(pszThemeFileName) lstrcpynW(pszThemeFileName, szCurrentTheme, dwMaxNameChars);
721     if(pszColorBuff) lstrcpynW(pszColorBuff, szCurrentColor, cchMaxColorChars);
722     if(pszSizeBuff) lstrcpynW(pszSizeBuff, szCurrentSize, cchMaxSizeChars);
723     return S_OK;
724 }
725
726 /***********************************************************************
727  *      GetThemeAppProperties                               (UXTHEME.@)
728  */
729 DWORD WINAPI GetThemeAppProperties(void)
730 {
731     return dwThemeAppProperties;
732 }
733
734 /***********************************************************************
735  *      SetThemeAppProperties                               (UXTHEME.@)
736  */
737 void WINAPI SetThemeAppProperties(DWORD dwFlags)
738 {
739     TRACE("(0x%08x)\n", dwFlags);
740     dwThemeAppProperties = dwFlags;
741 }
742
743 /***********************************************************************
744  *      CloseThemeData                                      (UXTHEME.@)
745  */
746 HRESULT WINAPI CloseThemeData(HTHEME hTheme)
747 {
748     TRACE("(%p)\n", hTheme);
749     if(!hTheme)
750         return E_HANDLE;
751     return MSSTYLES_CloseThemeClass(hTheme);
752 }
753
754 /***********************************************************************
755  *      HitTestThemeBackground                              (UXTHEME.@)
756  */
757 HRESULT WINAPI HitTestThemeBackground(HTHEME hTheme, HDC hdc, int iPartId,
758                                      int iStateId, DWORD dwOptions,
759                                      const RECT *pRect, HRGN hrgn,
760                                      POINT ptTest, WORD *pwHitTestCode)
761 {
762     FIXME("%d %d 0x%08x: stub\n", iPartId, iStateId, dwOptions);
763     if(!hTheme)
764         return E_HANDLE;
765     return ERROR_CALL_NOT_IMPLEMENTED;
766 }
767
768 /***********************************************************************
769  *      IsThemePartDefined                                  (UXTHEME.@)
770  */
771 BOOL WINAPI IsThemePartDefined(HTHEME hTheme, int iPartId, int iStateId)
772 {
773     TRACE("(%p,%d,%d)\n", hTheme, iPartId, iStateId);
774     if(!hTheme) {
775         SetLastError(E_HANDLE);
776         return FALSE;
777     }
778     if(MSSTYLES_FindPartState(hTheme, iPartId, iStateId, NULL))
779         return TRUE;
780     return FALSE;
781 }
782
783 /***********************************************************************
784  *      GetThemeDocumentationProperty                       (UXTHEME.@)
785  *
786  * Try and retrieve the documentation property from string resources
787  * if that fails, get it from the [documentation] section of themes.ini
788  */
789 HRESULT WINAPI GetThemeDocumentationProperty(LPCWSTR pszThemeName,
790                                              LPCWSTR pszPropertyName,
791                                              LPWSTR pszValueBuff,
792                                              int cchMaxValChars)
793 {
794     const WORD wDocToRes[] = {
795         TMT_DISPLAYNAME,5000,
796         TMT_TOOLTIP,5001,
797         TMT_COMPANY,5002,
798         TMT_AUTHOR,5003,
799         TMT_COPYRIGHT,5004,
800         TMT_URL,5005,
801         TMT_VERSION,5006,
802         TMT_DESCRIPTION,5007
803     };
804
805     PTHEME_FILE pt;
806     HRESULT hr;
807     unsigned int i;
808     int iDocId;
809     TRACE("(%s,%s,%p,%d)\n", debugstr_w(pszThemeName), debugstr_w(pszPropertyName),
810           pszValueBuff, cchMaxValChars);
811
812     hr = MSSTYLES_OpenThemeFile(pszThemeName, NULL, NULL, &pt);
813     if(FAILED(hr)) return hr;
814
815     /* Try to load from string resources */
816     hr = E_PROP_ID_UNSUPPORTED;
817     if(MSSTYLES_LookupProperty(pszPropertyName, NULL, &iDocId)) {
818         for(i=0; i<sizeof(wDocToRes)/sizeof(wDocToRes[0]); i+=2) {
819             if(wDocToRes[i] == iDocId) {
820                 if(LoadStringW(pt->hTheme, wDocToRes[i+1], pszValueBuff, cchMaxValChars)) {
821                     hr = S_OK;
822                     break;
823                 }
824             }
825         }
826     }
827     /* If loading from string resource failed, try getting it from the theme.ini */
828     if(FAILED(hr)) {
829         PUXINI_FILE uf = MSSTYLES_GetThemeIni(pt);
830         if(UXINI_FindSection(uf, szIniDocumentation)) {
831             LPCWSTR lpValue;
832             DWORD dwLen;
833             if(UXINI_FindValue(uf, pszPropertyName, &lpValue, &dwLen)) {
834                 lstrcpynW(pszValueBuff, lpValue, min(dwLen+1,cchMaxValChars));
835                 hr = S_OK;
836             }
837         }
838         UXINI_CloseINI(uf);
839     }
840
841     MSSTYLES_CloseThemeFile(pt);
842     return hr;
843 }
844
845 /**********************************************************************
846  *      Undocumented functions
847  */
848
849 /**********************************************************************
850  *      QueryThemeServices                                 (UXTHEME.1)
851  *
852  * RETURNS
853  *     some kind of status flag
854  */
855 DWORD WINAPI QueryThemeServices(void)
856 {
857     FIXME("stub\n");
858     return 3; /* This is what is returned under XP in most cases */
859 }
860
861
862 /**********************************************************************
863  *      OpenThemeFile                                      (UXTHEME.2)
864  *
865  * Opens a theme file, which can be used to change the current theme, etc
866  *
867  * PARAMS
868  *     pszThemeFileName    Path to a msstyles theme file
869  *     pszColorName        Color defined in the theme, eg. NormalColor
870  *     pszSizeName         Size defined in the theme, eg. NormalSize
871  *     hThemeFile          Handle to theme file
872  *
873  * RETURNS
874  *     Success: S_OK
875  *     Failure: HRESULT error-code
876  */
877 HRESULT WINAPI OpenThemeFile(LPCWSTR pszThemeFileName, LPCWSTR pszColorName,
878                              LPCWSTR pszSizeName, HTHEMEFILE *hThemeFile,
879                              DWORD unknown)
880 {
881     TRACE("(%s,%s,%s,%p,%d)\n", debugstr_w(pszThemeFileName),
882           debugstr_w(pszColorName), debugstr_w(pszSizeName),
883           hThemeFile, unknown);
884     return MSSTYLES_OpenThemeFile(pszThemeFileName, pszColorName, pszSizeName, (PTHEME_FILE*)hThemeFile);
885 }
886
887 /**********************************************************************
888  *      CloseThemeFile                                     (UXTHEME.3)
889  *
890  * Releases theme file handle returned by OpenThemeFile
891  *
892  * PARAMS
893  *     hThemeFile           Handle to theme file
894  *
895  * RETURNS
896  *     Success: S_OK
897  *     Failure: HRESULT error-code
898  */
899 HRESULT WINAPI CloseThemeFile(HTHEMEFILE hThemeFile)
900 {
901     TRACE("(%p)\n", hThemeFile);
902     MSSTYLES_CloseThemeFile(hThemeFile);
903     return S_OK;
904 }
905
906 /**********************************************************************
907  *      ApplyTheme                                         (UXTHEME.4)
908  *
909  * Set a theme file to be the currently active theme
910  *
911  * PARAMS
912  *     hThemeFile           Handle to theme file
913  *     unknown              See notes
914  *     hWnd                 Window requesting the theme change
915  *
916  * RETURNS
917  *     Success: S_OK
918  *     Failure: HRESULT error-code
919  *
920  * NOTES
921  * I'm not sure what the second parameter is (the datatype is likely wrong), other then this:
922  * Under XP if I pass
923  * char b[] = "";
924  *   the theme is applied with the screen redrawing really badly (flickers)
925  * char b[] = "\0"; where \0 can be one or more of any character, makes no difference
926  *   the theme is applied smoothly (screen does not flicker)
927  * char *b = "\0" or NULL; where \0 can be zero or more of any character, makes no difference
928  *   the function fails returning invalid parameter... very strange
929  */
930 HRESULT WINAPI ApplyTheme(HTHEMEFILE hThemeFile, char *unknown, HWND hWnd)
931 {
932     HRESULT hr;
933     TRACE("(%p,%s,%p)\n", hThemeFile, unknown, hWnd);
934     hr = UXTHEME_SetActiveTheme(hThemeFile);
935     UXTHEME_broadcast_msg (NULL, WM_THEMECHANGED);
936     return hr;
937 }
938
939 /**********************************************************************
940  *      GetThemeDefaults                                   (UXTHEME.7)
941  *
942  * Get the default color & size for a theme
943  *
944  * PARAMS
945  *     pszThemeFileName    Path to a msstyles theme file
946  *     pszColorName        Buffer to receive the default color name
947  *     dwColorNameLen      Length, in characters, of color name buffer
948  *     pszSizeName         Buffer to receive the default size name
949  *     dwSizeNameLen       Length, in characters, of size name buffer
950  *
951  * RETURNS
952  *     Success: S_OK
953  *     Failure: HRESULT error-code
954  */
955 HRESULT WINAPI GetThemeDefaults(LPCWSTR pszThemeFileName, LPWSTR pszColorName,
956                                 DWORD dwColorNameLen, LPWSTR pszSizeName,
957                                 DWORD dwSizeNameLen)
958 {
959     PTHEME_FILE pt;
960     HRESULT hr;
961     TRACE("(%s,%p,%d,%p,%d)\n", debugstr_w(pszThemeFileName),
962           pszColorName, dwColorNameLen,
963           pszSizeName, dwSizeNameLen);
964
965     hr = MSSTYLES_OpenThemeFile(pszThemeFileName, NULL, NULL, &pt);
966     if(FAILED(hr)) return hr;
967
968     lstrcpynW(pszColorName, pt->pszSelectedColor, dwColorNameLen);
969     lstrcpynW(pszSizeName, pt->pszSelectedSize, dwSizeNameLen);
970
971     MSSTYLES_CloseThemeFile(pt);
972     return S_OK;
973 }
974
975 /**********************************************************************
976  *      EnumThemes                                         (UXTHEME.8)
977  *
978  * Enumerate available themes, calls specified EnumThemeProc for each
979  * theme found. Passes lpData through to callback function.
980  *
981  * PARAMS
982  *     pszThemePath        Path containing themes
983  *     callback            Called for each theme found in path
984  *     lpData              Passed through to callback
985  *
986  * RETURNS
987  *     Success: S_OK
988  *     Failure: HRESULT error-code
989  */
990 HRESULT WINAPI EnumThemes(LPCWSTR pszThemePath, EnumThemeProc callback,
991                           LPVOID lpData)
992 {
993     WCHAR szDir[MAX_PATH];
994     WCHAR szPath[MAX_PATH];
995     static const WCHAR szStar[] = {'*','.','*','\0'};
996     static const WCHAR szFormat[] = {'%','s','%','s','\\','%','s','.','m','s','s','t','y','l','e','s','\0'};
997     static const WCHAR szDisplayName[] = {'d','i','s','p','l','a','y','n','a','m','e','\0'};
998     static const WCHAR szTooltip[] = {'t','o','o','l','t','i','p','\0'};
999     WCHAR szName[60];
1000     WCHAR szTip[60];
1001     HANDLE hFind;
1002     WIN32_FIND_DATAW wfd;
1003     HRESULT hr;
1004     size_t pathLen;
1005
1006     TRACE("(%s,%p,%p)\n", debugstr_w(pszThemePath), callback, lpData);
1007
1008     if(!pszThemePath || !callback)
1009         return E_POINTER;
1010
1011     lstrcpyW(szDir, pszThemePath);
1012     pathLen = lstrlenW (szDir);
1013     if ((pathLen > 0) && (pathLen < MAX_PATH-1) && (szDir[pathLen - 1] != '\\'))
1014     {
1015         szDir[pathLen] = '\\';
1016         szDir[pathLen+1] = 0;
1017     }
1018
1019     lstrcpyW(szPath, szDir);
1020     lstrcatW(szPath, szStar);
1021     TRACE("searching %s\n", debugstr_w(szPath));
1022
1023     hFind = FindFirstFileW(szPath, &wfd);
1024     if(hFind != INVALID_HANDLE_VALUE) {
1025         do {
1026             if(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
1027                && !(wfd.cFileName[0] == '.' && ((wfd.cFileName[1] == '.' && wfd.cFileName[2] == 0) || wfd.cFileName[1] == 0))) {
1028                 wsprintfW(szPath, szFormat, szDir, wfd.cFileName, wfd.cFileName);
1029
1030                 hr = GetThemeDocumentationProperty(szPath, szDisplayName, szName, sizeof(szName)/sizeof(szName[0]));
1031                 if(SUCCEEDED(hr))
1032                     hr = GetThemeDocumentationProperty(szPath, szTooltip, szTip, sizeof(szTip)/sizeof(szTip[0]));
1033                 if(SUCCEEDED(hr)) {
1034                     TRACE("callback(%s,%s,%s,%p)\n", debugstr_w(szPath), debugstr_w(szName), debugstr_w(szTip), lpData);
1035                     if(!callback(NULL, szPath, szName, szTip, NULL, lpData)) {
1036                         TRACE("callback ended enum\n");
1037                         break;
1038                     }
1039                 }
1040             }
1041         } while(FindNextFileW(hFind, &wfd));
1042         FindClose(hFind);
1043     }
1044     return S_OK;
1045 }
1046
1047
1048 /**********************************************************************
1049  *      EnumThemeColors                                    (UXTHEME.9)
1050  *
1051  * Enumerate theme colors available with a particular size
1052  *
1053  * PARAMS
1054  *     pszThemeFileName    Path to a msstyles theme file
1055  *     pszSizeName         Theme size to enumerate available colors
1056  *                         If NULL the default theme size is used
1057  *     dwColorNum          Color index to retrieve, increment from 0
1058  *     pszColorNames       Output color names
1059  *
1060  * RETURNS
1061  *     S_OK on success
1062  *     E_PROP_ID_UNSUPPORTED when dwColorName does not refer to a color
1063  *          or when pszSizeName does not refer to a valid size
1064  *
1065  * NOTES
1066  * XP fails with E_POINTER when pszColorNames points to a buffer smaller than 
1067  * sizeof(THEMENAMES).
1068  *
1069  * Not very efficient that I'm opening & validating the theme every call, but
1070  * this is undocumented and almost never called..
1071  * (and this is how windows works too)
1072  */
1073 HRESULT WINAPI EnumThemeColors(LPWSTR pszThemeFileName, LPWSTR pszSizeName,
1074                                DWORD dwColorNum, PTHEMENAMES pszColorNames)
1075 {
1076     PTHEME_FILE pt;
1077     HRESULT hr;
1078     LPWSTR tmp;
1079     UINT resourceId = dwColorNum + 1000;
1080     TRACE("(%s,%s,%d)\n", debugstr_w(pszThemeFileName),
1081           debugstr_w(pszSizeName), dwColorNum);
1082
1083     hr = MSSTYLES_OpenThemeFile(pszThemeFileName, NULL, pszSizeName, &pt);
1084     if(FAILED(hr)) return hr;
1085
1086     tmp = pt->pszAvailColors;
1087     while(dwColorNum && *tmp) {
1088         dwColorNum--;
1089         tmp += lstrlenW(tmp)+1;
1090     }
1091     if(!dwColorNum && *tmp) {
1092         TRACE("%s\n", debugstr_w(tmp));
1093         lstrcpyW(pszColorNames->szName, tmp);
1094         LoadStringW (pt->hTheme, resourceId,
1095             pszColorNames->szDisplayName,
1096             sizeof (pszColorNames->szDisplayName) / sizeof (WCHAR));
1097         LoadStringW (pt->hTheme, resourceId+1000,
1098             pszColorNames->szTooltip,
1099             sizeof (pszColorNames->szTooltip) / sizeof (WCHAR));
1100     }
1101     else
1102         hr = E_PROP_ID_UNSUPPORTED;
1103
1104     MSSTYLES_CloseThemeFile(pt);
1105     return hr;
1106 }
1107
1108 /**********************************************************************
1109  *      EnumThemeSizes                                     (UXTHEME.10)
1110  *
1111  * Enumerate theme colors available with a particular size
1112  *
1113  * PARAMS
1114  *     pszThemeFileName    Path to a msstyles theme file
1115  *     pszColorName        Theme color to enumerate available sizes
1116  *                         If NULL the default theme color is used
1117  *     dwSizeNum           Size index to retrieve, increment from 0
1118  *     pszSizeNames        Output size names
1119  *
1120  * RETURNS
1121  *     S_OK on success
1122  *     E_PROP_ID_UNSUPPORTED when dwSizeName does not refer to a size
1123  *          or when pszColorName does not refer to a valid color
1124  *
1125  * NOTES
1126  * XP fails with E_POINTER when pszSizeNames points to a buffer smaller than 
1127  * sizeof(THEMENAMES).
1128  *
1129  * Not very efficient that I'm opening & validating the theme every call, but
1130  * this is undocumented and almost never called..
1131  * (and this is how windows works too)
1132  */
1133 HRESULT WINAPI EnumThemeSizes(LPWSTR pszThemeFileName, LPWSTR pszColorName,
1134                               DWORD dwSizeNum, PTHEMENAMES pszSizeNames)
1135 {
1136     PTHEME_FILE pt;
1137     HRESULT hr;
1138     LPWSTR tmp;
1139     UINT resourceId = dwSizeNum + 3000;
1140     TRACE("(%s,%s,%d)\n", debugstr_w(pszThemeFileName),
1141           debugstr_w(pszColorName), dwSizeNum);
1142
1143     hr = MSSTYLES_OpenThemeFile(pszThemeFileName, pszColorName, NULL, &pt);
1144     if(FAILED(hr)) return hr;
1145
1146     tmp = pt->pszAvailSizes;
1147     while(dwSizeNum && *tmp) {
1148         dwSizeNum--;
1149         tmp += lstrlenW(tmp)+1;
1150     }
1151     if(!dwSizeNum && *tmp) {
1152         TRACE("%s\n", debugstr_w(tmp));
1153         lstrcpyW(pszSizeNames->szName, tmp);
1154         LoadStringW (pt->hTheme, resourceId,
1155             pszSizeNames->szDisplayName,
1156             sizeof (pszSizeNames->szDisplayName) / sizeof (WCHAR));
1157         LoadStringW (pt->hTheme, resourceId+1000,
1158             pszSizeNames->szTooltip,
1159             sizeof (pszSizeNames->szTooltip) / sizeof (WCHAR));
1160     }
1161     else
1162         hr = E_PROP_ID_UNSUPPORTED;
1163
1164     MSSTYLES_CloseThemeFile(pt);
1165     return hr;
1166 }
1167
1168 /**********************************************************************
1169  *      ParseThemeIniFile                                  (UXTHEME.11)
1170  *
1171  * Enumerate data in a theme INI file.
1172  *
1173  * PARAMS
1174  *     pszIniFileName      Path to a theme ini file
1175  *     pszUnknown          Cannot be NULL, L"" is valid
1176  *     callback            Called for each found entry
1177  *     lpData              Passed through to callback
1178  *
1179  * RETURNS
1180  *     S_OK on success
1181  *     0x800706488 (Unknown property) when enumeration is canceled from callback
1182  *
1183  * NOTES
1184  * When pszUnknown is NULL the callback is never called, the value does not seem to serve
1185  * any other purpose
1186  */
1187 HRESULT WINAPI ParseThemeIniFile(LPCWSTR pszIniFileName, LPWSTR pszUnknown,
1188                                  ParseThemeIniFileProc callback, LPVOID lpData)
1189 {
1190     FIXME("%s %s: stub\n", debugstr_w(pszIniFileName), debugstr_w(pszUnknown));
1191     return ERROR_CALL_NOT_IMPLEMENTED;
1192 }
1193
1194 /**********************************************************************
1195  *      CheckThemeSignature                                (UXTHEME.29)
1196  *
1197  * Validates the signature of a theme file
1198  *
1199  * PARAMS
1200  *     pszIniFileName      Path to a theme file
1201  *
1202  * RETURNS
1203  *     Success: S_OK
1204  *     Failure: HRESULT error-code
1205  */
1206 HRESULT WINAPI CheckThemeSignature(LPCWSTR pszThemeFileName)
1207 {
1208     PTHEME_FILE pt;
1209     HRESULT hr;
1210     TRACE("(%s)\n", debugstr_w(pszThemeFileName));
1211     hr = MSSTYLES_OpenThemeFile(pszThemeFileName, NULL, NULL, &pt);
1212     if(FAILED(hr))
1213         return hr;
1214     MSSTYLES_CloseThemeFile(pt);
1215     return S_OK;
1216 }