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 *       IsCompositionActive   (UXTHEME.@)
 567 */
 568 BOOL WINAPI IsCompositionActive(void)
 569 {
 570     FIXME(": stub\n");
 571
 572     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 573
 574     return FALSE;
 575 }
 576
 577 /***********************************************************************
 578  *      EnableTheming                                       (UXTHEME.@)
 579  *
 580  * NOTES
 581  * This is a global and persistent change
 582  */
 583 HRESULT WINAPI EnableTheming(BOOL fEnable)
 584 {
 585     HKEY hKey;
 586     WCHAR szEnabled[] = {'0','\0'};
 587
 588     TRACE("(%d)\n", fEnable);
 589
 590     if(fEnable != bThemeActive) {
 591         if(fEnable)
 592             UXTHEME_BackupSystemMetrics();
 593         else
 594             UXTHEME_RestoreSystemMetrics();
 595         UXTHEME_SaveSystemMetrics ();
 596         bThemeActive = fEnable;
 597         if(bThemeActive) szEnabled[0] = '1';
 598         if(!RegOpenKeyW(HKEY_CURRENT_USER, szThemeManager, &hKey)) {
 599             RegSetValueExW(hKey, szThemeActive, 0, REG_SZ, (LPBYTE)szEnabled, sizeof(WCHAR));
 600             RegCloseKey(hKey);
 601         }
 602         UXTHEME_broadcast_msg (NULL, WM_THEMECHANGED);
 603     }
 604     return S_OK;
 605 }
 606
 607 /***********************************************************************
 608  *      UXTHEME_SetWindowProperty
 609  *
 610  * I'm using atoms as there may be large numbers of duplicated strings
 611  * and they do the work of keeping memory down as a cause of that quite nicely
 612  */
 613 static HRESULT UXTHEME_SetWindowProperty(HWND hwnd, ATOM aProp, LPCWSTR pszValue)
 614 {
 615     ATOM oldValue = (ATOM)(size_t)RemovePropW(hwnd, (LPCWSTR)MAKEINTATOM(aProp));
 616     if(oldValue)
 617         DeleteAtom(oldValue);
 618     if(pszValue) {
 619         ATOM atValue = AddAtomW(pszValue);
 620         if(!atValue
 621            || !SetPropW(hwnd, (LPCWSTR)MAKEINTATOM(aProp), (LPWSTR)MAKEINTATOM(atValue))) {
 622             HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
 623             if(atValue) DeleteAtom(atValue);
 624             return hr;
 625         }
 626     }
 627     return S_OK;
 628 }
 629
 630 static LPWSTR UXTHEME_GetWindowProperty(HWND hwnd, ATOM aProp, LPWSTR pszBuffer, int dwLen)
 631 {
 632     ATOM atValue = (ATOM)(size_t)GetPropW(hwnd, (LPCWSTR)MAKEINTATOM(aProp));
 633     if(atValue) {
 634         if(GetAtomNameW(atValue, pszBuffer, dwLen))
 635             return pszBuffer;
 636         TRACE("property defined, but unable to get value\n");
 637     }
 638     return NULL;
 639 }
 640
 641 /***********************************************************************
 642  *      OpenThemeDataEx                                     (UXTHEME.61)
 643  */
 644 HTHEME WINAPI OpenThemeDataEx(HWND hwnd, LPCWSTR pszClassList, DWORD flags)
 645 {
 646     WCHAR szAppBuff[256];
 647     WCHAR szClassBuff[256];
 648     LPCWSTR pszAppName;
 649     LPCWSTR pszUseClassList;
 650     HTHEME hTheme = NULL;
 651     TRACE("(%p,%s, %x)\n", hwnd, debugstr_w(pszClassList), flags);
 652
 653     if(!pszClassList)
 654     {
 655         SetLastError(E_POINTER);
 656         return NULL;
 657     }
 658
 659     if(flags)
 660         FIXME("unhandled flags: %x\n", flags);
 661
 662     if(bThemeActive)
 663     {
 664         pszAppName = UXTHEME_GetWindowProperty(hwnd, atSubAppName, szAppBuff, sizeof(szAppBuff)/sizeof(szAppBuff[0]));
 665         /* If SetWindowTheme was used on the window, that overrides the class list passed to this function */
 666         pszUseClassList = UXTHEME_GetWindowProperty(hwnd, atSubIdList, szClassBuff, sizeof(szClassBuff)/sizeof(szClassBuff[0]));
 667         if(!pszUseClassList)
 668             pszUseClassList = pszClassList;
 669
 670         if (pszUseClassList)
 671             hTheme = MSSTYLES_OpenThemeClass(pszAppName, pszUseClassList);
 672     }
 673     if(IsWindow(hwnd))
 674         SetPropW(hwnd, (LPCWSTR)MAKEINTATOM(atWindowTheme), hTheme);
 675     TRACE(" = %p\n", hTheme);
 676     return hTheme;
 677 }
 678
 679 /***********************************************************************
 680  *      OpenThemeData                                       (UXTHEME.@)
 681  */
 682 HTHEME WINAPI OpenThemeData(HWND hwnd, LPCWSTR classlist)
 683 {
 684     return OpenThemeDataEx(hwnd, classlist, 0);
 685 }
 686
 687 /***********************************************************************
 688  *      GetWindowTheme                                      (UXTHEME.@)
 689  *
 690  * Retrieve the last theme opened for a window.
 691  *
 692  * PARAMS
 693  *  hwnd  [I] window to retrieve the theme for
 694  *
 695  * RETURNS
 696  *  The most recent theme.
 697  */
 698 HTHEME WINAPI GetWindowTheme(HWND hwnd)
 699 {
 700     TRACE("(%p)\n", hwnd);
 701     return GetPropW(hwnd, (LPCWSTR)MAKEINTATOM(atWindowTheme));
 702 }
 703
 704 /***********************************************************************
 705  *      SetWindowTheme                                      (UXTHEME.@)
 706  *
 707  * Persistent through the life of the window, even after themes change
 708  */
 709 HRESULT WINAPI SetWindowTheme(HWND hwnd, LPCWSTR pszSubAppName,
 710                               LPCWSTR pszSubIdList)
 711 {
 712     HRESULT hr;
 713     TRACE("(%p,%s,%s)\n", hwnd, debugstr_w(pszSubAppName),
 714           debugstr_w(pszSubIdList));
 715     hr = UXTHEME_SetWindowProperty(hwnd, atSubAppName, pszSubAppName);
 716     if(SUCCEEDED(hr))
 717         hr = UXTHEME_SetWindowProperty(hwnd, atSubIdList, pszSubIdList);
 718     if(SUCCEEDED(hr))
 719         UXTHEME_broadcast_msg (hwnd, WM_THEMECHANGED);
 720     return hr;
 721 }
 722
 723 /***********************************************************************
 724  *      GetCurrentThemeName                                 (UXTHEME.@)
 725  */
 726 HRESULT WINAPI GetCurrentThemeName(LPWSTR pszThemeFileName, int dwMaxNameChars,
 727                                    LPWSTR pszColorBuff, int cchMaxColorChars,
 728                                    LPWSTR pszSizeBuff, int cchMaxSizeChars)
 729 {
 730     if(!bThemeActive)
 731         return E_PROP_ID_UNSUPPORTED;
 732     if(pszThemeFileName) lstrcpynW(pszThemeFileName, szCurrentTheme, dwMaxNameChars);
 733     if(pszColorBuff) lstrcpynW(pszColorBuff, szCurrentColor, cchMaxColorChars);
 734     if(pszSizeBuff) lstrcpynW(pszSizeBuff, szCurrentSize, cchMaxSizeChars);
 735     return S_OK;
 736 }
 737
 738 /***********************************************************************
 739  *      GetThemeAppProperties                               (UXTHEME.@)
 740  */
 741 DWORD WINAPI GetThemeAppProperties(void)
 742 {
 743     return dwThemeAppProperties;
 744 }
 745
 746 /***********************************************************************
 747  *      SetThemeAppProperties                               (UXTHEME.@)
 748  */
 749 void WINAPI SetThemeAppProperties(DWORD dwFlags)
 750 {
 751     TRACE("(0x%08x)\n", dwFlags);
 752     dwThemeAppProperties = dwFlags;
 753 }
 754
 755 /***********************************************************************
 756  *      CloseThemeData                                      (UXTHEME.@)
 757  */
 758 HRESULT WINAPI CloseThemeData(HTHEME hTheme)
 759 {
 760     TRACE("(%p)\n", hTheme);
 761     if(!hTheme || hTheme == INVALID_HANDLE_VALUE)
 762         return E_HANDLE;
 763     return MSSTYLES_CloseThemeClass(hTheme);
 764 }
 765
 766 /***********************************************************************
 767  *      HitTestThemeBackground                              (UXTHEME.@)
 768  */
 769 HRESULT WINAPI HitTestThemeBackground(HTHEME hTheme, HDC hdc, int iPartId,
 770                                      int iStateId, DWORD dwOptions,
 771                                      const RECT *pRect, HRGN hrgn,
 772                                      POINT ptTest, WORD *pwHitTestCode)
 773 {
 774     FIXME("%d %d 0x%08x: stub\n", iPartId, iStateId, dwOptions);
 775     if(!hTheme)
 776         return E_HANDLE;
 777     return E_NOTIMPL;
 778 }
 779
 780 /***********************************************************************
 781  *      IsThemePartDefined                                  (UXTHEME.@)
 782  */
 783 BOOL WINAPI IsThemePartDefined(HTHEME hTheme, int iPartId, int iStateId)
 784 {
 785     TRACE("(%p,%d,%d)\n", hTheme, iPartId, iStateId);
 786     if(!hTheme) {
 787         SetLastError(E_HANDLE);
 788         return FALSE;
 789     }
 790     if(MSSTYLES_FindPartState(hTheme, iPartId, iStateId, NULL))
 791         return TRUE;
 792     return FALSE;
 793 }
 794
 795 /***********************************************************************
 796  *      GetThemeDocumentationProperty                       (UXTHEME.@)
 797  *
 798  * Try and retrieve the documentation property from string resources
 799  * if that fails, get it from the [documentation] section of themes.ini
 800  */
 801 HRESULT WINAPI GetThemeDocumentationProperty(LPCWSTR pszThemeName,
 802                                              LPCWSTR pszPropertyName,
 803                                              LPWSTR pszValueBuff,
 804                                              int cchMaxValChars)
 805 {
 806     const WORD wDocToRes[] = {
 807         TMT_DISPLAYNAME,5000,
 808         TMT_TOOLTIP,5001,
 809         TMT_COMPANY,5002,
 810         TMT_AUTHOR,5003,
 811         TMT_COPYRIGHT,5004,
 812         TMT_URL,5005,
 813         TMT_VERSION,5006,
 814         TMT_DESCRIPTION,5007
 815     };
 816
 817     PTHEME_FILE pt;
 818     HRESULT hr;
 819     unsigned int i;
 820     int iDocId;
 821     TRACE("(%s,%s,%p,%d)\n", debugstr_w(pszThemeName), debugstr_w(pszPropertyName),
 822           pszValueBuff, cchMaxValChars);
 823
 824     hr = MSSTYLES_OpenThemeFile(pszThemeName, NULL, NULL, &pt);
 825     if(FAILED(hr)) return hr;
 826
 827     /* Try to load from string resources */
 828     hr = E_PROP_ID_UNSUPPORTED;
 829     if(MSSTYLES_LookupProperty(pszPropertyName, NULL, &iDocId)) {
 830         for(i=0; i<sizeof(wDocToRes)/sizeof(wDocToRes[0]); i+=2) {
 831             if(wDocToRes[i] == iDocId) {
 832                 if(LoadStringW(pt->hTheme, wDocToRes[i+1], pszValueBuff, cchMaxValChars)) {
 833                     hr = S_OK;
 834                     break;
 835                 }
 836             }
 837         }
 838     }
 839     /* If loading from string resource failed, try getting it from the theme.ini */
 840     if(FAILED(hr)) {
 841         PUXINI_FILE uf = MSSTYLES_GetThemeIni(pt);
 842         if(UXINI_FindSection(uf, szIniDocumentation)) {
 843             LPCWSTR lpValue;
 844             DWORD dwLen;
 845             if(UXINI_FindValue(uf, pszPropertyName, &lpValue, &dwLen)) {
 846                 lstrcpynW(pszValueBuff, lpValue, min(dwLen+1,cchMaxValChars));
 847                 hr = S_OK;
 848             }
 849         }
 850         UXINI_CloseINI(uf);
 851     }
 852
 853     MSSTYLES_CloseThemeFile(pt);
 854     return hr;
 855 }
 856
 857 /**********************************************************************
 858  *      Undocumented functions
 859  */
 860
 861 /**********************************************************************
 862  *      QueryThemeServices                                 (UXTHEME.1)
 863  *
 864  * RETURNS
 865  *     some kind of status flag
 866  */
 867 DWORD WINAPI QueryThemeServices(void)
 868 {
 869     FIXME("stub\n");
 870     return 3; /* This is what is returned under XP in most cases */
 871 }
 872
 873
 874 /**********************************************************************
 875  *      OpenThemeFile                                      (UXTHEME.2)
 876  *
 877  * Opens a theme file, which can be used to change the current theme, etc
 878  *
 879  * PARAMS
 880  *     pszThemeFileName    Path to a msstyles theme file
 881  *     pszColorName        Color defined in the theme, eg. NormalColor
 882  *     pszSizeName         Size defined in the theme, eg. NormalSize
 883  *     hThemeFile          Handle to theme file
 884  *
 885  * RETURNS
 886  *     Success: S_OK
 887  *     Failure: HRESULT error-code
 888  */
 889 HRESULT WINAPI OpenThemeFile(LPCWSTR pszThemeFileName, LPCWSTR pszColorName,
 890                              LPCWSTR pszSizeName, HTHEMEFILE *hThemeFile,
 891                              DWORD unknown)
 892 {
 893     TRACE("(%s,%s,%s,%p,%d)\n", debugstr_w(pszThemeFileName),
 894           debugstr_w(pszColorName), debugstr_w(pszSizeName),
 895           hThemeFile, unknown);
 896     return MSSTYLES_OpenThemeFile(pszThemeFileName, pszColorName, pszSizeName, (PTHEME_FILE*)hThemeFile);
 897 }
 898
 899 /**********************************************************************
 900  *      CloseThemeFile                                     (UXTHEME.3)
 901  *
 902  * Releases theme file handle returned by OpenThemeFile
 903  *
 904  * PARAMS
 905  *     hThemeFile           Handle to theme file
 906  *
 907  * RETURNS
 908  *     Success: S_OK
 909  *     Failure: HRESULT error-code
 910  */
 911 HRESULT WINAPI CloseThemeFile(HTHEMEFILE hThemeFile)
 912 {
 913     TRACE("(%p)\n", hThemeFile);
 914     MSSTYLES_CloseThemeFile(hThemeFile);
 915     return S_OK;
 916 }
 917
 918 /**********************************************************************
 919  *      ApplyTheme                                         (UXTHEME.4)
 920  *
 921  * Set a theme file to be the currently active theme
 922  *
 923  * PARAMS
 924  *     hThemeFile           Handle to theme file
 925  *     unknown              See notes
 926  *     hWnd                 Window requesting the theme change
 927  *
 928  * RETURNS
 929  *     Success: S_OK
 930  *     Failure: HRESULT error-code
 931  *
 932  * NOTES
 933  * I'm not sure what the second parameter is (the datatype is likely wrong), other then this:
 934  * Under XP if I pass
 935  * char b[] = "";
 936  *   the theme is applied with the screen redrawing really badly (flickers)
 937  * char b[] = "\0"; where \0 can be one or more of any character, makes no difference
 938  *   the theme is applied smoothly (screen does not flicker)
 939  * char *b = "\0" or NULL; where \0 can be zero or more of any character, makes no difference
 940  *   the function fails returning invalid parameter... very strange
 941  */
 942 HRESULT WINAPI ApplyTheme(HTHEMEFILE hThemeFile, char *unknown, HWND hWnd)
 943 {
 944     HRESULT hr;
 945     TRACE("(%p,%s,%p)\n", hThemeFile, unknown, hWnd);
 946     hr = UXTHEME_SetActiveTheme(hThemeFile);
 947     UXTHEME_broadcast_msg (NULL, WM_THEMECHANGED);
 948     return hr;
 949 }
 950
 951 /**********************************************************************
 952  *      GetThemeDefaults                                   (UXTHEME.7)
 953  *
 954  * Get the default color & size for a theme
 955  *
 956  * PARAMS
 957  *     pszThemeFileName    Path to a msstyles theme file
 958  *     pszColorName        Buffer to receive the default color name
 959  *     dwColorNameLen      Length, in characters, of color name buffer
 960  *     pszSizeName         Buffer to receive the default size name
 961  *     dwSizeNameLen       Length, in characters, of size name buffer
 962  *
 963  * RETURNS
 964  *     Success: S_OK
 965  *     Failure: HRESULT error-code
 966  */
 967 HRESULT WINAPI GetThemeDefaults(LPCWSTR pszThemeFileName, LPWSTR pszColorName,
 968                                 DWORD dwColorNameLen, LPWSTR pszSizeName,
 969                                 DWORD dwSizeNameLen)
 970 {
 971     PTHEME_FILE pt;
 972     HRESULT hr;
 973     TRACE("(%s,%p,%d,%p,%d)\n", debugstr_w(pszThemeFileName),
 974           pszColorName, dwColorNameLen,
 975           pszSizeName, dwSizeNameLen);
 976
 977     hr = MSSTYLES_OpenThemeFile(pszThemeFileName, NULL, NULL, &pt);
 978     if(FAILED(hr)) return hr;
 979
 980     lstrcpynW(pszColorName, pt->pszSelectedColor, dwColorNameLen);
 981     lstrcpynW(pszSizeName, pt->pszSelectedSize, dwSizeNameLen);
 982
 983     MSSTYLES_CloseThemeFile(pt);
 984     return S_OK;
 985 }
 986
 987 /**********************************************************************
 988  *      EnumThemes                                         (UXTHEME.8)
 989  *
 990  * Enumerate available themes, calls specified EnumThemeProc for each
 991  * theme found. Passes lpData through to callback function.
 992  *
 993  * PARAMS
 994  *     pszThemePath        Path containing themes
 995  *     callback            Called for each theme found in path
 996  *     lpData              Passed through to callback
 997  *
 998  * RETURNS
 999  *     Success: S_OK
1000  *     Failure: HRESULT error-code
1001  */
1002 HRESULT WINAPI EnumThemes(LPCWSTR pszThemePath, EnumThemeProc callback,
1003                           LPVOID lpData)
1004 {
1005     WCHAR szDir[MAX_PATH];
1006     WCHAR szPath[MAX_PATH];
1007     static const WCHAR szStar[] = {'*','.','*','\0'};
1008     static const WCHAR szFormat[] = {'%','s','%','s','\\','%','s','.','m','s','s','t','y','l','e','s','\0'};
1009     static const WCHAR szDisplayName[] = {'d','i','s','p','l','a','y','n','a','m','e','\0'};
1010     static const WCHAR szTooltip[] = {'t','o','o','l','t','i','p','\0'};
1011     WCHAR szName[60];
1012     WCHAR szTip[60];
1013     HANDLE hFind;
1014     WIN32_FIND_DATAW wfd;
1015     HRESULT hr;
1016     size_t pathLen;
1017
1018     TRACE("(%s,%p,%p)\n", debugstr_w(pszThemePath), callback, lpData);
1019
1020     if(!pszThemePath || !callback)
1021         return E_POINTER;
1022
1023     lstrcpyW(szDir, pszThemePath);
1024     pathLen = lstrlenW (szDir);
1025     if ((pathLen > 0) && (pathLen < MAX_PATH-1) && (szDir[pathLen - 1] != '\\'))
1026     {
1027         szDir[pathLen] = '\\';
1028         szDir[pathLen+1] = 0;
1029     }
1030
1031     lstrcpyW(szPath, szDir);
1032     lstrcatW(szPath, szStar);
1033     TRACE("searching %s\n", debugstr_w(szPath));
1034
1035     hFind = FindFirstFileW(szPath, &wfd);
1036     if(hFind != INVALID_HANDLE_VALUE) {
1037         do {
1038             if(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
1039                && !(wfd.cFileName[0] == '.' && ((wfd.cFileName[1] == '.' && wfd.cFileName[2] == 0) || wfd.cFileName[1] == 0))) {
1040                 wsprintfW(szPath, szFormat, szDir, wfd.cFileName, wfd.cFileName);
1041
1042                 hr = GetThemeDocumentationProperty(szPath, szDisplayName, szName, sizeof(szName)/sizeof(szName[0]));
1043                 if(SUCCEEDED(hr))
1044                     hr = GetThemeDocumentationProperty(szPath, szTooltip, szTip, sizeof(szTip)/sizeof(szTip[0]));
1045                 if(SUCCEEDED(hr)) {
1046                     TRACE("callback(%s,%s,%s,%p)\n", debugstr_w(szPath), debugstr_w(szName), debugstr_w(szTip), lpData);
1047                     if(!callback(NULL, szPath, szName, szTip, NULL, lpData)) {
1048                         TRACE("callback ended enum\n");
1049                         break;
1050                     }
1051                 }
1052             }
1053         } while(FindNextFileW(hFind, &wfd));
1054         FindClose(hFind);
1055     }
1056     return S_OK;
1057 }
1058
1059
1060 /**********************************************************************
1061  *      EnumThemeColors                                    (UXTHEME.9)
1062  *
1063  * Enumerate theme colors available with a particular size
1064  *
1065  * PARAMS
1066  *     pszThemeFileName    Path to a msstyles theme file
1067  *     pszSizeName         Theme size to enumerate available colors
1068  *                         If NULL the default theme size is used
1069  *     dwColorNum          Color index to retrieve, increment from 0
1070  *     pszColorNames       Output color names
1071  *
1072  * RETURNS
1073  *     S_OK on success
1074  *     E_PROP_ID_UNSUPPORTED when dwColorName does not refer to a color
1075  *          or when pszSizeName does not refer to a valid size
1076  *
1077  * NOTES
1078  * XP fails with E_POINTER when pszColorNames points to a buffer smaller than
1079  * sizeof(THEMENAMES).
1080  *
1081  * Not very efficient that I'm opening & validating the theme every call, but
1082  * this is undocumented and almost never called..
1083  * (and this is how windows works too)
1084  */
1085 HRESULT WINAPI EnumThemeColors(LPWSTR pszThemeFileName, LPWSTR pszSizeName,
1086                                DWORD dwColorNum, PTHEMENAMES pszColorNames)
1087 {
1088     PTHEME_FILE pt;
1089     HRESULT hr;
1090     LPWSTR tmp;
1091     UINT resourceId = dwColorNum + 1000;
1092     TRACE("(%s,%s,%d)\n", debugstr_w(pszThemeFileName),
1093           debugstr_w(pszSizeName), dwColorNum);
1094
1095     hr = MSSTYLES_OpenThemeFile(pszThemeFileName, NULL, pszSizeName, &pt);
1096     if(FAILED(hr)) return hr;
1097
1098     tmp = pt->pszAvailColors;
1099     while(dwColorNum && *tmp) {
1100         dwColorNum--;
1101         tmp += lstrlenW(tmp)+1;
1102     }
1103     if(!dwColorNum && *tmp) {
1104         TRACE("%s\n", debugstr_w(tmp));
1105         lstrcpyW(pszColorNames->szName, tmp);
1106         LoadStringW (pt->hTheme, resourceId,
1107             pszColorNames->szDisplayName,
1108             sizeof (pszColorNames->szDisplayName) / sizeof (WCHAR));
1109         LoadStringW (pt->hTheme, resourceId+1000,
1110             pszColorNames->szTooltip,
1111             sizeof (pszColorNames->szTooltip) / sizeof (WCHAR));
1112     }
1113     else
1114         hr = E_PROP_ID_UNSUPPORTED;
1115
1116     MSSTYLES_CloseThemeFile(pt);
1117     return hr;
1118 }
1119
1120 /**********************************************************************
1121  *      EnumThemeSizes                                     (UXTHEME.10)
1122  *
1123  * Enumerate theme colors available with a particular size
1124  *
1125  * PARAMS
1126  *     pszThemeFileName    Path to a msstyles theme file
1127  *     pszColorName        Theme color to enumerate available sizes
1128  *                         If NULL the default theme color is used
1129  *     dwSizeNum           Size index to retrieve, increment from 0
1130  *     pszSizeNames        Output size names
1131  *
1132  * RETURNS
1133  *     S_OK on success
1134  *     E_PROP_ID_UNSUPPORTED when dwSizeName does not refer to a size
1135  *          or when pszColorName does not refer to a valid color
1136  *
1137  * NOTES
1138  * XP fails with E_POINTER when pszSizeNames points to a buffer smaller than
1139  * sizeof(THEMENAMES).
1140  *
1141  * Not very efficient that I'm opening & validating the theme every call, but
1142  * this is undocumented and almost never called..
1143  * (and this is how windows works too)
1144  */
1145 HRESULT WINAPI EnumThemeSizes(LPWSTR pszThemeFileName, LPWSTR pszColorName,
1146                               DWORD dwSizeNum, PTHEMENAMES pszSizeNames)
1147 {
1148     PTHEME_FILE pt;
1149     HRESULT hr;
1150     LPWSTR tmp;
1151     UINT resourceId = dwSizeNum + 3000;
1152     TRACE("(%s,%s,%d)\n", debugstr_w(pszThemeFileName),
1153           debugstr_w(pszColorName), dwSizeNum);
1154
1155     hr = MSSTYLES_OpenThemeFile(pszThemeFileName, pszColorName, NULL, &pt);
1156     if(FAILED(hr)) return hr;
1157
1158     tmp = pt->pszAvailSizes;
1159     while(dwSizeNum && *tmp) {
1160         dwSizeNum--;
1161         tmp += lstrlenW(tmp)+1;
1162     }
1163     if(!dwSizeNum && *tmp) {
1164         TRACE("%s\n", debugstr_w(tmp));
1165         lstrcpyW(pszSizeNames->szName, tmp);
1166         LoadStringW (pt->hTheme, resourceId,
1167             pszSizeNames->szDisplayName,
1168             sizeof (pszSizeNames->szDisplayName) / sizeof (WCHAR));
1169         LoadStringW (pt->hTheme, resourceId+1000,
1170             pszSizeNames->szTooltip,
1171             sizeof (pszSizeNames->szTooltip) / sizeof (WCHAR));
1172     }
1173     else
1174         hr = E_PROP_ID_UNSUPPORTED;
1175
1176     MSSTYLES_CloseThemeFile(pt);
1177     return hr;
1178 }
1179
1180 /**********************************************************************
1181  *      ParseThemeIniFile                                  (UXTHEME.11)
1182  *
1183  * Enumerate data in a theme INI file.
1184  *
1185  * PARAMS
1186  *     pszIniFileName      Path to a theme ini file
1187  *     pszUnknown          Cannot be NULL, L"" is valid
1188  *     callback            Called for each found entry
1189  *     lpData              Passed through to callback
1190  *
1191  * RETURNS
1192  *     S_OK on success
1193  *     0x800706488 (Unknown property) when enumeration is canceled from callback
1194  *
1195  * NOTES
1196  * When pszUnknown is NULL the callback is never called, the value does not seem to serve
1197  * any other purpose
1198  */
1199 HRESULT WINAPI ParseThemeIniFile(LPCWSTR pszIniFileName, LPWSTR pszUnknown,
1200                                  ParseThemeIniFileProc callback, LPVOID lpData)
1201 {
1202     FIXME("%s %s: stub\n", debugstr_w(pszIniFileName), debugstr_w(pszUnknown));
1203     return E_NOTIMPL;
1204 }
1205
1206 /**********************************************************************
1207  *      CheckThemeSignature                                (UXTHEME.29)
1208  *
1209  * Validates the signature of a theme file
1210  *
1211  * PARAMS
1212  *     pszIniFileName      Path to a theme file
1213  *
1214  * RETURNS
1215  *     Success: S_OK
1216  *     Failure: HRESULT error-code
1217  */
1218 HRESULT WINAPI CheckThemeSignature(LPCWSTR pszThemeFileName)
1219 {
1220     PTHEME_FILE pt;
1221     HRESULT hr;
1222     TRACE("(%s)\n", debugstr_w(pszThemeFileName));
1223     hr = MSSTYLES_OpenThemeFile(pszThemeFileName, NULL, NULL, &pt);
1224     if(FAILED(hr))
1225         return hr;
1226     MSSTYLES_CloseThemeFile(pt);
1227     return S_OK;
1228 }