reactos/dll/win32/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 "uxthemep.h"
  22 #include <wine/debug.h>
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(uxtheme);
  25
  26 /***********************************************************************
  27  * Defines and global variables
  28  */
  29
  30 static const WCHAR szThemeManager[] = {
  31     'S','o','f','t','w','a','r','e','\\',
  32     'M','i','c','r','o','s','o','f','t','\\',
  33     'W','i','n','d','o','w','s','\\',
  34     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  35     'T','h','e','m','e','M','a','n','a','g','e','r','\0'
  36 };
  37 static const WCHAR szThemeActive[] = {'T','h','e','m','e','A','c','t','i','v','e','\0'};
  38 static const WCHAR szSizeName[] = {'S','i','z','e','N','a','m','e','\0'};
  39 static const WCHAR szColorName[] = {'C','o','l','o','r','N','a','m','e','\0'};
  40 static const WCHAR szDllName[] = {'D','l','l','N','a','m','e','\0'};
  41
  42 static const WCHAR szIniDocumentation[] = {'d','o','c','u','m','e','n','t','a','t','i','o','n','\0'};
  43
  44 HINSTANCE hDllInst;
  45 ATOM atDialogThemeEnabled;
  46
  47 static DWORD dwThemeAppProperties = STAP_ALLOW_NONCLIENT | STAP_ALLOW_CONTROLS;
  48 ATOM atWindowTheme;
  49 static ATOM atSubAppName;
  50 static ATOM atSubIdList;
  51 ATOM atWndContrext;
  52
  53 static BOOL bThemeActive = FALSE;
  54 static WCHAR szCurrentTheme[MAX_PATH];
  55 static WCHAR szCurrentColor[64];
  56 static WCHAR szCurrentSize[64];
  57
  58 /***********************************************************************/
  59
  60 static BOOL CALLBACK UXTHEME_broadcast_msg_enumchild (HWND hWnd, LPARAM msg)
  61 {
  62     PostMessageW(hWnd, msg, 0, 0);
  63     return TRUE;
  64 }
  65
  66 /* Broadcast a message to *all* windows, including children */
  67 BOOL CALLBACK UXTHEME_broadcast_msg (HWND hWnd, LPARAM msg)
  68 {
  69     if (hWnd == NULL)
  70     {
  71         EnumWindows (UXTHEME_broadcast_msg, msg);
  72     }
  73     else
  74     {
  75         PostMessageW(hWnd, msg, 0, 0);
  76         EnumChildWindows (hWnd, UXTHEME_broadcast_msg_enumchild, msg);
  77     }
  78     return TRUE;
  79 }
  80
  81 /* At the end of the day this is a subset of what SHRegGetPath() does - copied
  82  * here to avoid linking against shlwapi. */
  83 static DWORD query_reg_path (HKEY hKey, LPCWSTR lpszValue,
  84                              LPVOID pvData)
  85 {
  86   DWORD dwRet, dwType, dwUnExpDataLen = MAX_PATH, dwExpDataLen;
  87
  88   TRACE("(hkey=%p,%s,%p)\n", hKey, debugstr_w(lpszValue),
  89         pvData);
  90
  91   dwRet = RegQueryValueExW(hKey, lpszValue, 0, &dwType, pvData, &dwUnExpDataLen);
  92   if (dwRet!=ERROR_SUCCESS && dwRet!=ERROR_MORE_DATA)
  93       return dwRet;
  94
  95   if (dwType == REG_EXPAND_SZ)
  96   {
  97     DWORD nBytesToAlloc;
  98
  99     /* Expand type REG_EXPAND_SZ into REG_SZ */
 100     LPWSTR szData;
 101
 102     /* If the caller didn't supply a buffer or the buffer is too small we have
 103      * to allocate our own
 104      */
 105     if (dwRet == ERROR_MORE_DATA)
 106     {
 107       WCHAR cNull = '\0';
 108       nBytesToAlloc = dwUnExpDataLen;
 109
 110       szData = LocalAlloc(LMEM_ZEROINIT, nBytesToAlloc);
 111       RegQueryValueExW (hKey, lpszValue, 0, NULL, (LPBYTE)szData, &nBytesToAlloc);
 112       dwExpDataLen = ExpandEnvironmentStringsW(szData, &cNull, 1);
 113       dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
 114       LocalFree(szData);
 115     }
 116     else
 117     {
 118       nBytesToAlloc = (lstrlenW(pvData) + 1) * sizeof(WCHAR);
 119       szData = LocalAlloc(LMEM_ZEROINIT, nBytesToAlloc );
 120       lstrcpyW(szData, pvData);
 121       dwExpDataLen = ExpandEnvironmentStringsW(szData, pvData, MAX_PATH );
 122       if (dwExpDataLen > MAX_PATH) dwRet = ERROR_MORE_DATA;
 123       dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
 124       LocalFree(szData);
 125     }
 126   }
 127
 128   return dwRet;
 129 }
 130
 131 /***********************************************************************
 132  *      UXTHEME_LoadTheme
 133  *
 134  * Set the current active theme from the registry
 135  */
 136 void UXTHEME_LoadTheme(BOOL bLoad)
 137 {
 138     HKEY hKey;
 139     DWORD buffsize;
 140     HRESULT hr;
 141     WCHAR tmp[10];
 142     PTHEME_FILE pt;
 143
 144     if(bLoad == TRUE)
 145     {
 146         /* Get current theme configuration */
 147         if(!RegOpenKeyW(HKEY_CURRENT_USER, szThemeManager, &hKey)) {
 148             TRACE("Loading theme config\n");
 149             buffsize = sizeof(tmp)/sizeof(tmp[0]);
 150             if(!RegQueryValueExW(hKey, szThemeActive, NULL, NULL, (LPBYTE)tmp, &buffsize)) {
 151                 bThemeActive = (tmp[0] != '0');
 152             }
 153             else {
 154                 bThemeActive = FALSE;
 155                 TRACE("Failed to get ThemeActive: %d\n", GetLastError());
 156             }
 157             buffsize = sizeof(szCurrentColor)/sizeof(szCurrentColor[0]);
 158             if(RegQueryValueExW(hKey, szColorName, NULL, NULL, (LPBYTE)szCurrentColor, &buffsize))
 159                 szCurrentColor[0] = '\0';
 160             buffsize = sizeof(szCurrentSize)/sizeof(szCurrentSize[0]);
 161             if(RegQueryValueExW(hKey, szSizeName, NULL, NULL, (LPBYTE)szCurrentSize, &buffsize))
 162                 szCurrentSize[0] = '\0';
 163             if (query_reg_path (hKey, szDllName, szCurrentTheme))
 164                 szCurrentTheme[0] = '\0';
 165             RegCloseKey(hKey);
 166         }
 167         else
 168             TRACE("Failed to open theme registry key\n");
 169     }
 170     else
 171     {
 172         bThemeActive = FALSE;
 173     }
 174
 175     if(bThemeActive) {
 176         /* Make sure the theme requested is actually valid */
 177         hr = MSSTYLES_OpenThemeFile(szCurrentTheme,
 178                                     szCurrentColor[0]?szCurrentColor:NULL,
 179                                     szCurrentSize[0]?szCurrentSize:NULL,
 180                                     &pt);
 181         if(FAILED(hr)) {
 182             bThemeActive = FALSE;
 183             szCurrentTheme[0] = '\0';
 184             szCurrentColor[0] = '\0';
 185             szCurrentSize[0] = '\0';
 186         }
 187         else {
 188             /* Make sure the global color & size match the theme */
 189             lstrcpynW(szCurrentColor, pt->pszSelectedColor, sizeof(szCurrentColor)/sizeof(szCurrentColor[0]));
 190             lstrcpynW(szCurrentSize, pt->pszSelectedSize, sizeof(szCurrentSize)/sizeof(szCurrentSize[0]));
 191
 192             MSSTYLES_SetActiveTheme(pt, FALSE);
 193             TRACE("Theme active: %s %s %s\n", debugstr_w(szCurrentTheme),
 194                 debugstr_w(szCurrentColor), debugstr_w(szCurrentSize));
 195             MSSTYLES_CloseThemeFile(pt);
 196         }
 197     }
 198     if(!bThemeActive) {
 199         MSSTYLES_SetActiveTheme(NULL, FALSE);
 200         TRACE("Theming not active\n");
 201     }
 202 }
 203
 204 /***********************************************************************/
 205
 206 static const char * const SysColorsNames[] =
 207 {
 208     "Scrollbar",                /* COLOR_SCROLLBAR */
 209     "Background",               /* COLOR_BACKGROUND */
 210     "ActiveTitle",              /* COLOR_ACTIVECAPTION */
 211     "InactiveTitle",            /* COLOR_INACTIVECAPTION */
 212     "Menu",                     /* COLOR_MENU */
 213     "Window",                   /* COLOR_WINDOW */
 214     "WindowFrame",              /* COLOR_WINDOWFRAME */
 215     "MenuText",                 /* COLOR_MENUTEXT */
 216     "WindowText",               /* COLOR_WINDOWTEXT */
 217     "TitleText",                /* COLOR_CAPTIONTEXT */
 218     "ActiveBorder",             /* COLOR_ACTIVEBORDER */
 219     "InactiveBorder",           /* COLOR_INACTIVEBORDER */
 220     "AppWorkSpace",             /* COLOR_APPWORKSPACE */
 221     "Hilight",                  /* COLOR_HIGHLIGHT */
 222     "HilightText",              /* COLOR_HIGHLIGHTTEXT */
 223     "ButtonFace",               /* COLOR_BTNFACE */
 224     "ButtonShadow",             /* COLOR_BTNSHADOW */
 225     "GrayText",                 /* COLOR_GRAYTEXT */
 226     "ButtonText",               /* COLOR_BTNTEXT */
 227     "InactiveTitleText",        /* COLOR_INACTIVECAPTIONTEXT */
 228     "ButtonHilight",            /* COLOR_BTNHIGHLIGHT */
 229     "ButtonDkShadow",           /* COLOR_3DDKSHADOW */
 230     "ButtonLight",              /* COLOR_3DLIGHT */
 231     "InfoText",                 /* COLOR_INFOTEXT */
 232     "InfoWindow",               /* COLOR_INFOBK */
 233     "ButtonAlternateFace",      /* COLOR_ALTERNATEBTNFACE */
 234     "HotTrackingColor",         /* COLOR_HOTLIGHT */
 235     "GradientActiveTitle",      /* COLOR_GRADIENTACTIVECAPTION */
 236     "GradientInactiveTitle",    /* COLOR_GRADIENTINACTIVECAPTION */
 237     "MenuHilight",              /* COLOR_MENUHILIGHT */
 238     "MenuBar",                  /* COLOR_MENUBAR */
 239 };
 240 static const WCHAR strColorKey[] =
 241     { 'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
 242       'C','o','l','o','r','s',0 };
 243 static const WCHAR keyFlatMenus[] = { 'F','l','a','t','M','e','n','u', 0};
 244 static const WCHAR keyGradientCaption[] = { 'G','r','a','d','i','e','n','t',
 245                                             'C','a','p','t','i','o','n', 0 };
 246 static const WCHAR keyNonClientMetrics[] = { 'N','o','n','C','l','i','e','n','t',
 247                                              'M','e','t','r','i','c','s',0 };
 248 static const WCHAR keyIconTitleFont[] = { 'I','c','o','n','T','i','t','l','e',
 249                                           'F','o','n','t',0 };
 250
 251 static const struct BackupSysParam
 252 {
 253     int spiGet, spiSet;
 254     const WCHAR* keyName;
 255 } backupSysParams[] =
 256 {
 257     {SPI_GETFLATMENU, SPI_SETFLATMENU, keyFlatMenus},
 258     {SPI_GETGRADIENTCAPTIONS, SPI_SETGRADIENTCAPTIONS, keyGradientCaption},
 259     {-1, -1, 0}
 260 };
 261
 262 #define NUM_SYS_COLORS     (COLOR_MENUBAR+1)
 263
 264 static void save_sys_colors (HKEY baseKey)
 265 {
 266     char colorStr[13];
 267     HKEY hKey;
 268     int i;
 269
 270     if (RegCreateKeyExW( baseKey, strColorKey,
 271                          0, 0, 0, KEY_ALL_ACCESS,
 272                          0, &hKey, 0 ) == ERROR_SUCCESS)
 273     {
 274         for (i = 0; i < NUM_SYS_COLORS; i++)
 275         {
 276             COLORREF col = GetSysColor (i);
 277
 278             sprintf (colorStr, "%d %d %d",
 279                 GetRValue (col), GetGValue (col), GetBValue (col));
 280
 281             RegSetValueExA (hKey, SysColorsNames[i], 0, REG_SZ,
 282                 (BYTE*)colorStr, strlen (colorStr)+1);
 283         }
 284         RegCloseKey (hKey);
 285     }
 286 }
 287
 288 /* Before activating a theme, query current system colors, certain settings
 289  * and backup them in the registry, so they can be restored when the theme
 290  * is deactivated */
 291 static void UXTHEME_BackupSystemMetrics(void)
 292 {
 293     HKEY hKey;
 294     const struct BackupSysParam* bsp = backupSysParams;
 295
 296     if (RegCreateKeyExW( HKEY_CURRENT_USER, szThemeManager,
 297                          0, 0, 0, KEY_ALL_ACCESS,
 298                          0, &hKey, 0) == ERROR_SUCCESS)
 299     {
 300         NONCLIENTMETRICSW ncm;
 301         LOGFONTW iconTitleFont;
 302
 303         /* back up colors */
 304         save_sys_colors (hKey);
 305
 306         /* back up "other" settings */
 307         while (bsp->spiGet >= 0)
 308         {
 309             DWORD value;
 310
 311             SystemParametersInfoW (bsp->spiGet, 0, &value, 0);
 312             RegSetValueExW (hKey, bsp->keyName, 0, REG_DWORD,
 313                 (LPBYTE)&value, sizeof (value));
 314
 315             bsp++;
 316         }
 317
 318         /* back up non-client metrics */
 319         memset (&ncm, 0, sizeof (ncm));
 320         ncm.cbSize = sizeof (ncm);
 321         SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, sizeof (ncm), &ncm, 0);
 322         RegSetValueExW (hKey, keyNonClientMetrics, 0, REG_BINARY, (LPBYTE)&ncm,
 323             sizeof (ncm));
 324         memset (&iconTitleFont, 0, sizeof (iconTitleFont));
 325         SystemParametersInfoW (SPI_GETICONTITLELOGFONT, sizeof (iconTitleFont),
 326             &iconTitleFont, 0);
 327         RegSetValueExW (hKey, keyIconTitleFont, 0, REG_BINARY,
 328             (LPBYTE)&iconTitleFont, sizeof (iconTitleFont));
 329
 330         RegCloseKey (hKey);
 331     }
 332 }
 333
 334 /* Read back old settings after a theme was deactivated */
 335 static void UXTHEME_RestoreSystemMetrics(void)
 336 {
 337     HKEY hKey;
 338     const struct BackupSysParam* bsp = backupSysParams;
 339
 340     if (RegOpenKeyExW (HKEY_CURRENT_USER, szThemeManager,
 341                        0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS)
 342     {
 343         HKEY colorKey;
 344
 345         /* read backed-up colors */
 346         if (RegOpenKeyExW (hKey, strColorKey,
 347                            0, KEY_QUERY_VALUE, &colorKey) == ERROR_SUCCESS)
 348         {
 349             int i;
 350             COLORREF sysCols[NUM_SYS_COLORS];
 351             int sysColsIndices[NUM_SYS_COLORS];
 352             int sysColCount = 0;
 353
 354             for (i = 0; i < NUM_SYS_COLORS; i++)
 355             {
 356                 DWORD type;
 357                 char colorStr[13];
 358                 DWORD count = sizeof(colorStr);
 359
 360                 if (RegQueryValueExA (colorKey, SysColorsNames[i], 0,
 361                     &type, (LPBYTE) colorStr, &count) == ERROR_SUCCESS)
 362                 {
 363                     int r, g, b;
 364                     if (sscanf (colorStr, "%d %d %d", &r, &g, &b) == 3)
 365                     {
 366                         sysColsIndices[sysColCount] = i;
 367                         sysCols[sysColCount] = RGB(r, g, b);
 368                         sysColCount++;
 369                     }
 370                 }
 371             }
 372             RegCloseKey (colorKey);
 373
 374             SetSysColors (sysColCount, sysColsIndices, sysCols);
 375         }
 376
 377         /* read backed-up other settings */
 378         while (bsp->spiGet >= 0)
 379         {
 380             DWORD value;
 381             DWORD count = sizeof(value);
 382             DWORD type;
 383
 384             if (RegQueryValueExW (hKey, bsp->keyName, 0,
 385                 &type, (LPBYTE)&value, &count) == ERROR_SUCCESS)
 386             {
 387                 SystemParametersInfoW (bsp->spiSet, 0, UlongToPtr(value), SPIF_UPDATEINIFILE);
 388             }
 389
 390             bsp++;
 391         }
 392
 393         /* read backed-up non-client metrics */
 394         {
 395             NONCLIENTMETRICSW ncm;
 396             LOGFONTW iconTitleFont;
 397             DWORD count = sizeof(ncm);
 398             DWORD type;
 399
 400             if (RegQueryValueExW (hKey, keyNonClientMetrics, 0,
 401                 &type, (LPBYTE)&ncm, &count) == ERROR_SUCCESS)
 402             {
 403                 SystemParametersInfoW (SPI_SETNONCLIENTMETRICS,
 404                     count, &ncm, SPIF_UPDATEINIFILE);
 405             }
 406
 407             count = sizeof(iconTitleFont);
 408
 409             if (RegQueryValueExW (hKey, keyIconTitleFont, 0,
 410                 &type, (LPBYTE)&iconTitleFont, &count) == ERROR_SUCCESS)
 411             {
 412                 SystemParametersInfoW (SPI_SETICONTITLELOGFONT,
 413                     count, &iconTitleFont, SPIF_UPDATEINIFILE);
 414             }
 415         }
 416
 417         RegCloseKey (hKey);
 418     }
 419 }
 420
 421 /* Make system settings persistent, so they're in effect even w/o uxtheme
 422  * loaded.
 423  * For efficiency reasons, only the last SystemParametersInfoW sets
 424  * SPIF_SENDWININICHANGE */
 425 static void UXTHEME_SaveSystemMetrics(void)
 426 {
 427     const struct BackupSysParam* bsp = backupSysParams;
 428     NONCLIENTMETRICSW ncm;
 429     LOGFONTW iconTitleFont;
 430
 431     save_sys_colors (HKEY_CURRENT_USER);
 432
 433     while (bsp->spiGet >= 0)
 434     {
 435         DWORD value;
 436
 437         SystemParametersInfoW (bsp->spiGet, 0, &value, 0);
 438         SystemParametersInfoW (bsp->spiSet, 0, UlongToPtr(value), SPIF_UPDATEINIFILE);
 439         bsp++;
 440     }
 441
 442     memset (&ncm, 0, sizeof (ncm));
 443     ncm.cbSize = sizeof (ncm);
 444     SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, sizeof (ncm), &ncm, 0);
 445     SystemParametersInfoW (SPI_SETNONCLIENTMETRICS, sizeof (ncm), &ncm,
 446         SPIF_UPDATEINIFILE);
 447
 448     memset (&iconTitleFont, 0, sizeof (iconTitleFont));
 449     SystemParametersInfoW (SPI_GETICONTITLELOGFONT, sizeof (iconTitleFont),
 450         &iconTitleFont, 0);
 451     SystemParametersInfoW (SPI_SETICONTITLELOGFONT, sizeof (iconTitleFont),
 452         &iconTitleFont, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
 453 }
 454
 455 /***********************************************************************
 456  *      UXTHEME_SetActiveTheme
 457  *
 458  * Change the current active theme
 459  */
 460 static HRESULT UXTHEME_SetActiveTheme(PTHEME_FILE tf)
 461 {
 462     HKEY hKey;
 463     WCHAR tmp[2];
 464     HRESULT hr;
 465
 466     if(tf && !bThemeActive) UXTHEME_BackupSystemMetrics();
 467     hr = MSSTYLES_SetActiveTheme(tf, TRUE);
 468     if(FAILED(hr))
 469         return hr;
 470     if(tf) {
 471         bThemeActive = TRUE;
 472         lstrcpynW(szCurrentTheme, tf->szThemeFile, sizeof(szCurrentTheme)/sizeof(szCurrentTheme[0]));
 473         lstrcpynW(szCurrentColor, tf->pszSelectedColor, sizeof(szCurrentColor)/sizeof(szCurrentColor[0]));
 474         lstrcpynW(szCurrentSize, tf->pszSelectedSize, sizeof(szCurrentSize)/sizeof(szCurrentSize[0]));
 475     }
 476     else {
 477         UXTHEME_RestoreSystemMetrics();
 478         bThemeActive = FALSE;
 479         szCurrentTheme[0] = '\0';
 480         szCurrentColor[0] = '\0';
 481         szCurrentSize[0] = '\0';
 482     }
 483
 484     TRACE("Writing theme config to registry\n");
 485     if(!RegCreateKeyW(HKEY_CURRENT_USER, szThemeManager, &hKey)) {
 486         tmp[0] = bThemeActive?'1':'0';
 487         tmp[1] = '\0';
 488         RegSetValueExW(hKey, szThemeActive, 0, REG_SZ, (const BYTE*)tmp, sizeof(WCHAR)*2);
 489         if(bThemeActive) {
 490             RegSetValueExW(hKey, szColorName, 0, REG_SZ, (const BYTE*)szCurrentColor,
 491                 (lstrlenW(szCurrentColor)+1)*sizeof(WCHAR));
 492             RegSetValueExW(hKey, szSizeName, 0, REG_SZ, (const BYTE*)szCurrentSize,
 493                 (lstrlenW(szCurrentSize)+1)*sizeof(WCHAR));
 494             RegSetValueExW(hKey, szDllName, 0, REG_SZ, (const BYTE*)szCurrentTheme,
 495                 (lstrlenW(szCurrentTheme)+1)*sizeof(WCHAR));
 496         }
 497         else {
 498             RegDeleteValueW(hKey, szColorName);
 499             RegDeleteValueW(hKey, szSizeName);
 500             RegDeleteValueW(hKey, szDllName);
 501
 502         }
 503         RegCloseKey(hKey);
 504     }
 505     else
 506         TRACE("Failed to open theme registry key\n");
 507
 508     UXTHEME_SaveSystemMetrics ();
 509
 510     return hr;
 511 }
 512
 513 /***********************************************************************
 514  *      UXTHEME_InitSystem
 515  */
 516 void UXTHEME_InitSystem(HINSTANCE hInst)
 517 {
 518     static const WCHAR szWindowTheme[] = {
 519         'u','x','_','t','h','e','m','e','\0'
 520     };
 521     static const WCHAR szSubAppName[] = {
 522         'u','x','_','s','u','b','a','p','p','\0'
 523     };
 524     static const WCHAR szSubIdList[] = {
 525         'u','x','_','s','u','b','i','d','l','s','t','\0'
 526     };
 527     static const WCHAR szDialogThemeEnabled[] = {
 528         'u','x','_','d','i','a','l','o','g','t','h','e','m','e','\0'
 529     };
 530
 531     hDllInst = hInst;
 532
 533     atWindowTheme        = GlobalAddAtomW(szWindowTheme);
 534     atSubAppName         = GlobalAddAtomW(szSubAppName);
 535     atSubIdList          = GlobalAddAtomW(szSubIdList);
 536     atDialogThemeEnabled = GlobalAddAtomW(szDialogThemeEnabled);
 537     atWndContrext        = GlobalAddAtomW(L"ux_WndContext");
 538 }
 539
 540 /***********************************************************************
 541  *      IsAppThemed                                         (UXTHEME.@)
 542  */
 543 BOOL WINAPI IsAppThemed(void)
 544 {
 545     return IsThemeActive();
 546 }
 547
 548 /***********************************************************************
 549  *      IsThemeActive                                       (UXTHEME.@)
 550  */
 551 BOOL WINAPI IsThemeActive(void)
 552 {
 553     TRACE("\n");
 554     SetLastError(ERROR_SUCCESS);
 555     return bThemeActive;
 556 }
 557
 558 /***********************************************************************
 559  *      EnableTheming                                       (UXTHEME.@)
 560  *
 561  * NOTES
 562  * This is a global and persistent change
 563  */
 564 HRESULT WINAPI EnableTheming(BOOL fEnable)
 565 {
 566     HKEY hKey;
 567     WCHAR szEnabled[] = {'0','\0'};
 568
 569     TRACE("(%d)\n", fEnable);
 570
 571     if(fEnable != bThemeActive) {
 572         if(fEnable)
 573             UXTHEME_BackupSystemMetrics();
 574         else
 575             UXTHEME_RestoreSystemMetrics();
 576         UXTHEME_SaveSystemMetrics ();
 577         bThemeActive = fEnable;
 578         if(bThemeActive) szEnabled[0] = '1';
 579         if(!RegOpenKeyW(HKEY_CURRENT_USER, szThemeManager, &hKey)) {
 580             RegSetValueExW(hKey, szThemeActive, 0, REG_SZ, (LPBYTE)szEnabled, sizeof(WCHAR));
 581             RegCloseKey(hKey);
 582         }
 583         UXTHEME_broadcast_msg (NULL, WM_THEMECHANGED);
 584     }
 585     return S_OK;
 586 }
 587
 588 /***********************************************************************
 589  *      UXTHEME_SetWindowProperty
 590  *
 591  * I'm using atoms as there may be large numbers of duplicated strings
 592  * and they do the work of keeping memory down as a cause of that quite nicely
 593  */
 594 static HRESULT UXTHEME_SetWindowProperty(HWND hwnd, ATOM aProp, LPCWSTR pszValue)
 595 {
 596     ATOM oldValue = (ATOM)(size_t)RemovePropW(hwnd, (LPCWSTR)MAKEINTATOM(aProp));
 597     if(oldValue)
 598         DeleteAtom(oldValue);
 599     if(pszValue) {
 600         ATOM atValue = AddAtomW(pszValue);
 601         if(!atValue
 602            || !SetPropW(hwnd, (LPCWSTR)MAKEINTATOM(aProp), (LPWSTR)MAKEINTATOM(atValue))) {
 603             HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
 604             if(atValue) DeleteAtom(atValue);
 605             return hr;
 606         }
 607     }
 608     return S_OK;
 609 }
 610
 611 static LPWSTR UXTHEME_GetWindowProperty(HWND hwnd, ATOM aProp, LPWSTR pszBuffer, int dwLen)
 612 {
 613     ATOM atValue = (ATOM)(size_t)GetPropW(hwnd, (LPCWSTR)MAKEINTATOM(aProp));
 614     if(atValue) {
 615         if(GetAtomNameW(atValue, pszBuffer, dwLen))
 616             return pszBuffer;
 617         TRACE("property defined, but unable to get value\n");
 618     }
 619     return NULL;
 620 }
 621
 622 /***********************************************************************
 623  *      OpenThemeDataEx                                     (UXTHEME.61)
 624  */
 625 HTHEME WINAPI OpenThemeDataEx(HWND hwnd, LPCWSTR pszClassList, DWORD flags)
 626 {
 627     WCHAR szAppBuff[256];
 628     WCHAR szClassBuff[256];
 629     LPCWSTR pszAppName;
 630     LPCWSTR pszUseClassList;
 631     HTHEME hTheme = NULL;
 632     TRACE("(%p,%s)\n", hwnd, debugstr_w(pszClassList));
 633
 634     if(!pszClassList)
 635     {
 636         SetLastError(E_POINTER);
 637         return NULL;
 638     }
 639
 640     if(flags)
 641         FIXME("unhandled flags: %x\n", flags);
 642
 643     if(bThemeActive)
 644     {
 645         pszAppName = UXTHEME_GetWindowProperty(hwnd, atSubAppName, szAppBuff, sizeof(szAppBuff)/sizeof(szAppBuff[0]));
 646         /* If SetWindowTheme was used on the window, that overrides the class list passed to this function */
 647         pszUseClassList = UXTHEME_GetWindowProperty(hwnd, atSubIdList, szClassBuff, sizeof(szClassBuff)/sizeof(szClassBuff[0]));
 648         if(!pszUseClassList)
 649             pszUseClassList = pszClassList;
 650
 651         if (pszUseClassList)
 652             hTheme = MSSTYLES_OpenThemeClass(pszAppName, pszUseClassList);
 653     }
 654     if(IsWindow(hwnd))
 655         SetPropW(hwnd, (LPCWSTR)MAKEINTATOM(atWindowTheme), hTheme);
 656     TRACE(" = %p\n", hTheme);
 657     return hTheme;
 658 }
 659
 660 /***********************************************************************
 661  *      OpenThemeData                                       (UXTHEME.@)
 662  */
 663 HTHEME WINAPI OpenThemeData(HWND hwnd, LPCWSTR classlist)
 664 {
 665     return OpenThemeDataEx(hwnd, classlist, 0);
 666 }
 667
 668 /***********************************************************************
 669  *      GetWindowTheme                                      (UXTHEME.@)
 670  *
 671  * Retrieve the last theme opened for a window.
 672  *
 673  * PARAMS
 674  *  hwnd  [I] window to retrieve the theme for
 675  *
 676  * RETURNS
 677  *  The most recent theme.
 678  */
 679 HTHEME WINAPI GetWindowTheme(HWND hwnd)
 680 {
 681     TRACE("(%p)\n", hwnd);
 682         if(!IsWindow(hwnd))
 683                 SetLastError(E_HANDLE);
 684
 685     return GetPropW(hwnd, (LPCWSTR)MAKEINTATOM(atWindowTheme));
 686 }
 687
 688 /***********************************************************************
 689  *      SetWindowTheme                                      (UXTHEME.@)
 690  *
 691  * Persistent through the life of the window, even after themes change
 692  */
 693 HRESULT WINAPI SetWindowTheme(HWND hwnd, LPCWSTR pszSubAppName,
 694                               LPCWSTR pszSubIdList)
 695 {
 696         HRESULT hr;
 697     TRACE("(%p,%s,%s)\n", hwnd, debugstr_w(pszSubAppName),
 698         debugstr_w(pszSubIdList));
 699
 700     if(!IsWindow(hwnd))
 701                 return E_HANDLE;
 702
 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 }