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