dlls/uxtheme/msstyles.c

   1 /*
   2  * Win32 5.1 msstyles theme format
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #define NO_SHLWAPI_REG
  29 #include "shlwapi.h"
  30 #include "winnls.h"
  31 #include "wingdi.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 BOOL MSSTYLES_GetNextInteger(LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR *lpValEnd, int *value);
  47 BOOL MSSTYLES_GetNextToken(LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR *lpValEnd, LPWSTR lpBuff, DWORD buffSize);
  48
  49 extern HINSTANCE hDllInst;
  50
  51 #define MSSTYLES_VERSION 0x0003
  52
  53 static const WCHAR szThemesIniResource[] = {
  54     't','h','e','m','e','s','_','i','n','i','\0'
  55 };
  56
  57 PTHEME_FILE tfActiveTheme = NULL;
  58
  59 /***********************************************************************/
  60
  61 /**********************************************************************
  62  *      MSSTYLES_OpenThemeFile
  63  *
  64  * Load and validate a theme
  65  *
  66  * PARAMS
  67  *     lpThemeFile         Path to theme file to load
  68  *     pszColorName        Color name wanted, can be NULL
  69  *     pszSizeName         Size name wanted, can be NULL
  70  *
  71  * NOTES
  72  * If pszColorName or pszSizeName are NULL, the default color/size will be used.
  73  * If one/both are provided, they are validated against valid color/sizes and if
  74  * a match is not found, the function fails.
  75  */
  76 HRESULT MSSTYLES_OpenThemeFile(LPCWSTR lpThemeFile, LPCWSTR pszColorName, LPCWSTR pszSizeName, PTHEME_FILE *tf)
  77 {
  78     HMODULE hTheme;
  79     HRSRC hrsc;
  80     HRESULT hr = S_OK;
  81     static const WCHAR szPackThemVersionResource[] = {
  82         'P','A','C','K','T','H','E','M','_','V','E','R','S','I','O','N', '\0'
  83     };
  84     static const WCHAR szColorNamesResource[] = {
  85         'C','O','L','O','R','N','A','M','E','S','\0'
  86     };
  87     static const WCHAR szSizeNamesResource[] = {
  88         'S','I','Z','E','N','A','M','E','S','\0'
  89     };
  90
  91     WORD version;
  92     DWORD versize;
  93     LPWSTR pszColors;
  94     LPWSTR pszSelectedColor = NULL;
  95     LPWSTR pszSizes;
  96     LPWSTR pszSelectedSize = NULL;
  97     LPWSTR tmp;
  98
  99     TRACE("Opening %s\n", debugstr_w(lpThemeFile));
 100
 101     hTheme = LoadLibraryExW(lpThemeFile, NULL, LOAD_LIBRARY_AS_DATAFILE);
 102
 103     /* Validate that this is really a theme */
 104     if(!hTheme) {
 105         hr = HRESULT_FROM_WIN32(GetLastError());
 106         goto invalid_theme;
 107     }
 108     if(!(hrsc = FindResourceW(hTheme, MAKEINTRESOURCEW(1), szPackThemVersionResource))) {
 109         TRACE("No version resource found\n");
 110         hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
 111         goto invalid_theme;
 112     }
 113     if((versize = SizeofResource(hTheme, hrsc)) != 2)
 114     {
 115         TRACE("Version resource found, but wrong size: %ld\n", versize);
 116         hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
 117         goto invalid_theme;
 118     }
 119     version = *(WORD*)LoadResource(hTheme, hrsc);
 120     if(version != MSSTYLES_VERSION)
 121     {
 122         TRACE("Version of theme file is unsupported: 0x%04x\n", version);
 123         hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
 124         goto invalid_theme;
 125     }
 126
 127     if(!(hrsc = FindResourceW(hTheme, MAKEINTRESOURCEW(1), szColorNamesResource))) {
 128         TRACE("Color names resource not found\n");
 129         hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
 130         goto invalid_theme;
 131     }
 132     pszColors = (LPWSTR)LoadResource(hTheme, hrsc);
 133
 134     if(!(hrsc = FindResourceW(hTheme, MAKEINTRESOURCEW(1), szSizeNamesResource))) {
 135         TRACE("Size names resource not found\n");
 136         hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
 137         goto invalid_theme;
 138     }
 139     pszSizes = (LPWSTR)LoadResource(hTheme, hrsc);
 140
 141     /* Validate requested color against whats available from the theme */
 142     if(pszColorName) {
 143         tmp = pszColors;
 144         while(*tmp) {
 145             if(!lstrcmpiW(pszColorName, tmp)) {
 146                 pszSelectedColor = tmp;
 147                 break;
 148             }
 149             tmp += lstrlenW(tmp)+1;
 150         }
 151     }
 152     else
 153         pszSelectedColor = pszColors; /* Use the default color */
 154
 155     /* Validate requested size against whats available from the theme */
 156     if(pszSizeName) {
 157         tmp = pszSizes;
 158         while(*tmp) {
 159             if(!lstrcmpiW(pszSizeName, tmp)) {
 160                 pszSelectedSize = tmp;
 161                 break;
 162             }
 163             tmp += lstrlenW(tmp)+1;
 164         }
 165     }
 166     else
 167         pszSelectedSize = pszSizes; /* Use the default size */
 168
 169     if(!pszSelectedColor || !pszSelectedSize) {
 170         TRACE("Requested color/size (%s/%s) not found in theme\n",
 171               debugstr_w(pszColorName), debugstr_w(pszSizeName));
 172         hr = E_PROP_ID_UNSUPPORTED;
 173         goto invalid_theme;
 174     }
 175
 176     *tf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(THEME_FILE));
 177     (*tf)->hTheme = hTheme;
 178
 179     GetFullPathNameW(lpThemeFile, MAX_PATH, (*tf)->szThemeFile, NULL);
 180
 181     (*tf)->pszAvailColors = pszColors;
 182     (*tf)->pszAvailSizes = pszSizes;
 183     (*tf)->pszSelectedColor = pszSelectedColor;
 184     (*tf)->pszSelectedSize = pszSelectedSize;
 185     (*tf)->dwRefCount = 1;
 186     return S_OK;
 187
 188 invalid_theme:
 189     if(hTheme) FreeLibrary(hTheme);
 190     return hr;
 191 }
 192
 193 /***********************************************************************
 194  *      MSSTYLES_CloseThemeFile
 195  *
 196  * Close theme file and free resources
 197  */
 198 void MSSTYLES_CloseThemeFile(PTHEME_FILE tf)
 199 {
 200     if(tf) {
 201         tf->dwRefCount--;
 202         if(!tf->dwRefCount) {
 203             if(tf->hTheme) FreeLibrary(tf->hTheme);
 204             if(tf->classes) {
 205                 while(tf->classes) {
 206                     PTHEME_CLASS pcls = tf->classes;
 207                     tf->classes = pcls->next;
 208                     while(pcls->partstate) {
 209                         PTHEME_PARTSTATE ps = pcls->partstate;
 210                         pcls->partstate = ps->next;
 211                         HeapFree(GetProcessHeap(), 0, ps);
 212                     }
 213                     HeapFree(GetProcessHeap(), 0, pcls);
 214                 }
 215             }
 216             HeapFree(GetProcessHeap(), 0, tf);
 217         }
 218     }
 219 }
 220
 221 /***********************************************************************
 222  *      MSSTYLES_SetActiveTheme
 223  *
 224  * Set the current active theme
 225  */
 226 HRESULT MSSTYLES_SetActiveTheme(PTHEME_FILE tf)
 227 {
 228     if(tfActiveTheme)
 229         MSSTYLES_CloseThemeFile(tfActiveTheme);
 230     tfActiveTheme = tf;
 231     if (tfActiveTheme)
 232         tfActiveTheme->dwRefCount++;
 233     return S_OK;
 234 }
 235
 236 /***********************************************************************
 237  *      MSSTYLES_GetThemeIni
 238  *
 239  * Retrieves themes.ini from a theme
 240  */
 241 PUXINI_FILE MSSTYLES_GetThemeIni(PTHEME_FILE tf)
 242 {
 243     return UXINI_LoadINI(tf->hTheme, szThemesIniResource);
 244 }
 245
 246 /***********************************************************************
 247  *      MSSTYLES_GetActiveThemeIni
 248  *
 249  * Retrieve the ini file for the selected color/style
 250  */
 251 PUXINI_FILE MSSTYLES_GetActiveThemeIni(PTHEME_FILE tf)
 252 {
 253     static const WCHAR szFileResNamesResource[] = {
 254         'F','I','L','E','R','E','S','N','A','M','E','S','\0'
 255     };
 256     DWORD dwColorCount = 0;
 257     DWORD dwSizeCount = 0;
 258     DWORD dwColorNum = 0;
 259     DWORD dwSizeNum = 0;
 260     DWORD i;
 261     DWORD dwResourceIndex;
 262     LPWSTR tmp;
 263     HRSRC hrsc;
 264
 265     /* Count the number of available colors & styles, and determine the index number
 266        of the color/style we are interested in
 267     */
 268     tmp = tf->pszAvailColors;
 269     while(*tmp) {
 270         if(!lstrcmpiW(tf->pszSelectedColor, tmp))
 271             dwColorNum = dwColorCount;
 272         tmp += lstrlenW(tmp)+1;
 273         dwColorCount++;
 274     }
 275     tmp = tf->pszAvailSizes;
 276     while(*tmp) {
 277         if(!lstrcmpiW(tf->pszSelectedSize, tmp))
 278             dwSizeNum = dwSizeCount;
 279         tmp += lstrlenW(tmp)+1;
 280         dwSizeCount++;
 281     }
 282
 283     if(!(hrsc = FindResourceW(tf->hTheme, MAKEINTRESOURCEW(1), szFileResNamesResource))) {
 284         TRACE("FILERESNAMES map not found\n");
 285         return NULL;
 286     }
 287     tmp = (LPWSTR)LoadResource(tf->hTheme, hrsc);
 288     dwResourceIndex = (dwSizeCount * dwColorNum) + dwSizeNum;
 289     for(i=0; i < dwResourceIndex; i++) {
 290         tmp += lstrlenW(tmp)+1;
 291     }
 292     return UXINI_LoadINI(tf->hTheme, tmp);
 293 }
 294
 295
 296 /***********************************************************************
 297  *      MSSTYLES_ParseIniSectionName
 298  *
 299  * Parse an ini section name into its component parts
 300  * Valid formats are:
 301  * [classname]
 302  * [classname(state)]
 303  * [classname.part]
 304  * [classname.part(state)]
 305  * [application::classname]
 306  * [application::classname(state)]
 307  * [application::classname.part]
 308  * [application::classname.part(state)]
 309  *
 310  * PARAMS
 311  *     lpSection           Section name
 312  *     dwLen               Length of section name
 313  *     szAppName           Location to store application name
 314  *     szClassName         Location to store class name
 315  *     iPartId             Location to store part id
 316  *     iStateId            Location to store state id
 317  */
 318 BOOL MSSTYLES_ParseIniSectionName(LPCWSTR lpSection, DWORD dwLen, LPWSTR szAppName, LPWSTR szClassName, int *iPartId, int *iStateId)
 319 {
 320     WCHAR sec[255];
 321     WCHAR part[60] = {'\0'};
 322     WCHAR state[60] = {'\0'};
 323     LPWSTR tmp;
 324     LPWSTR comp;
 325     lstrcpynW(sec, lpSection, min(dwLen+1, sizeof(sec)/sizeof(sec[0])));
 326
 327     *szAppName = 0;
 328     *szClassName = 0;
 329     *iPartId = 0;
 330     *iStateId = 0;
 331     comp = sec;
 332     /* Get the application name */
 333     tmp = StrChrW(comp, ':');
 334     if(tmp) {
 335         *tmp++ = 0;
 336         tmp++;
 337         lstrcpynW(szAppName, comp, MAX_THEME_APP_NAME);
 338         comp = tmp;
 339     }
 340
 341     tmp = StrChrW(comp, '.');
 342     if(tmp) {
 343         *tmp++ = 0;
 344         lstrcpynW(szClassName, comp, MAX_THEME_CLASS_NAME);
 345         comp = tmp;
 346         /* now get the part & state */
 347         tmp = StrChrW(comp, '(');
 348         if(tmp) {
 349             *tmp++ = 0;
 350             lstrcpynW(part, comp, sizeof(part)/sizeof(part[0]));
 351             comp = tmp;
 352             /* now get the state */
 353             *StrChrW(comp, ')') = 0;
 354             lstrcpynW(state, comp, sizeof(state)/sizeof(state[0]));
 355         }
 356         else {
 357             lstrcpynW(part, comp, sizeof(part)/sizeof(part[0]));
 358         }
 359     }
 360     else {
 361         tmp = StrChrW(comp, '(');
 362         if(tmp) {
 363             *tmp++ = 0;
 364             lstrcpynW(szClassName, comp, MAX_THEME_CLASS_NAME);
 365             comp = tmp;
 366             /* now get the state */
 367             *StrChrW(comp, ')') = 0;
 368             lstrcpynW(state, comp, sizeof(state)/sizeof(state[0]));
 369         }
 370         else {
 371             lstrcpynW(szClassName, comp, MAX_THEME_CLASS_NAME);
 372         }
 373     }
 374     if(!*szClassName) return FALSE;
 375     return MSSTYLES_LookupPartState(szClassName, part[0]?part:NULL, state[0]?state:NULL, iPartId, iStateId);
 376 }
 377
 378 /***********************************************************************
 379  *      MSSTYLES_FindClass
 380  *
 381  * Find a class
 382  *
 383  * PARAMS
 384  *     tf                  Theme file
 385  *     pszAppName          App name to find
 386  *     pszClassName        Class name to find
 387  *
 388  * RETURNS
 389  *  The class found, or NULL
 390  */
 391 PTHEME_CLASS MSSTYLES_FindClass(PTHEME_FILE tf, LPCWSTR pszAppName, LPCWSTR pszClassName)
 392 {
 393     PTHEME_CLASS cur = tf->classes;
 394     while(cur) {
 395         if(!pszAppName) {
 396             if(!*cur->szAppName && !lstrcmpiW(pszClassName, cur->szClassName))
 397                 return cur;
 398         }
 399         else {
 400             if(!lstrcmpiW(pszAppName, cur->szAppName) && !lstrcmpiW(pszClassName, cur->szClassName))
 401                 return cur;
 402         }
 403         cur = cur->next;
 404     }
 405     return NULL;
 406 }
 407
 408 /***********************************************************************
 409  *      MSSTYLES_AddClass
 410  *
 411  * Add a class to a theme file
 412  *
 413  * PARAMS
 414  *     tf                  Theme file
 415  *     pszAppName          App name to add
 416  *     pszClassName        Class name to add
 417  *
 418  * RETURNS
 419  *  The class added, or a class previously added with the same name
 420  */
 421 PTHEME_CLASS MSSTYLES_AddClass(PTHEME_FILE tf, LPCWSTR pszAppName, LPCWSTR pszClassName)
 422 {
 423     PTHEME_CLASS cur = MSSTYLES_FindClass(tf, pszAppName, pszClassName);
 424     if(cur) return cur;
 425
 426     cur = HeapAlloc(GetProcessHeap(), 0, sizeof(THEME_CLASS));
 427     cur->hTheme = tf->hTheme;
 428     lstrcpyW(cur->szAppName, pszAppName);
 429     lstrcpyW(cur->szClassName, pszClassName);
 430     cur->next = tf->classes;
 431     cur->partstate = NULL;
 432     cur->overrides = NULL;
 433     tf->classes = cur;
 434     return cur;
 435 }
 436
 437 /***********************************************************************
 438  *      MSSTYLES_FindPartState
 439  *
 440  * Find a part/state
 441  *
 442  * PARAMS
 443  *     tc                  Class to search
 444  *     iPartId             Part ID to find
 445  *     iStateId            State ID to find
 446  *     tcNext              Receives the next class in the override chain
 447  *
 448  * RETURNS
 449  *  The part/state found, or NULL
 450  */
 451 PTHEME_PARTSTATE MSSTYLES_FindPartState(PTHEME_CLASS tc, int iPartId, int iStateId, PTHEME_CLASS *tcNext)
 452 {
 453     PTHEME_PARTSTATE cur = tc->partstate;
 454     while(cur) {
 455         if(cur->iPartId == iPartId && cur->iStateId == iStateId) {
 456             if(tcNext) *tcNext = tc->overrides;
 457             return cur;
 458         }
 459         cur = cur->next;
 460     }
 461     if(tc->overrides) return MSSTYLES_FindPartState(tc->overrides, iPartId, iStateId, tcNext);
 462     return NULL;
 463 }
 464
 465 /***********************************************************************
 466  *      MSSTYLES_AddPartState
 467  *
 468  * Add a part/state to a class
 469  *
 470  * PARAMS
 471  *     tc                  Theme class
 472  *     iPartId             Part ID to add
 473  *     iStateId            State ID to add
 474  *
 475  * RETURNS
 476  *  The part/state added, or a part/state previously added with the same IDs
 477  */
 478 PTHEME_PARTSTATE MSSTYLES_AddPartState(PTHEME_CLASS tc, int iPartId, int iStateId)
 479 {
 480     PTHEME_PARTSTATE cur = MSSTYLES_FindPartState(tc, iPartId, iStateId, NULL);
 481     if(cur) return cur;
 482
 483     cur = HeapAlloc(GetProcessHeap(), 0, sizeof(THEME_PARTSTATE));
 484     cur->iPartId = iPartId;
 485     cur->iStateId = iStateId;
 486     cur->properties = NULL;
 487     cur->next = tc->partstate;
 488     tc->partstate = cur;
 489     return cur;
 490 }
 491
 492 /***********************************************************************
 493  *      MSSTYLES_LFindProperty
 494  *
 495  * Find a property within a property list
 496  *
 497  * PARAMS
 498  *     tp                  property list to scan
 499  *     iPropertyPrimitive  Type of value expected
 500  *     iPropertyId         ID of the required value
 501  *
 502  * RETURNS
 503  *  The property found, or NULL
 504  */
 505 PTHEME_PROPERTY MSSTYLES_LFindProperty(PTHEME_PROPERTY tp, int iPropertyPrimitive, int iPropertyId)
 506 {
 507     PTHEME_PROPERTY cur = tp;
 508     while(cur) {
 509         if(cur->iPropertyId == iPropertyId) {
 510             if(cur->iPrimitiveType == iPropertyPrimitive) {
 511                 return cur;
 512             }
 513             else {
 514                 if(!iPropertyPrimitive)
 515                     return cur;
 516                 return NULL;
 517             }
 518         }
 519         cur = cur->next;
 520     }
 521     return NULL;
 522 }
 523
 524 /***********************************************************************
 525  *      MSSTYLES_PSFindProperty
 526  *
 527  * Find a value within a part/state
 528  *
 529  * PARAMS
 530  *     ps                  Part/state to search
 531  *     iPropertyPrimitive  Type of value expected
 532  *     iPropertyId         ID of the required value
 533  *
 534  * RETURNS
 535  *  The property found, or NULL
 536  */
 537 static inline PTHEME_PROPERTY MSSTYLES_PSFindProperty(PTHEME_PARTSTATE ps, int iPropertyPrimitive, int iPropertyId)
 538 {
 539     return MSSTYLES_LFindProperty(ps->properties, iPropertyPrimitive, iPropertyId);
 540 }
 541
 542 /***********************************************************************
 543  *      MSSTYLES_FFindMetric
 544  *
 545  * Find a metric property for a theme file
 546  *
 547  * PARAMS
 548  *     tf                  Theme file
 549  *     iPropertyPrimitive  Type of value expected
 550  *     iPropertyId         ID of the required value
 551  *
 552  * RETURNS
 553  *  The property found, or NULL
 554  */
 555 static inline PTHEME_PROPERTY MSSTYLES_FFindMetric(PTHEME_FILE tf, int iPropertyPrimitive, int iPropertyId)
 556 {
 557     return MSSTYLES_LFindProperty(tf->metrics, iPropertyPrimitive, iPropertyId);
 558 }
 559
 560 /***********************************************************************
 561  *      MSSTYLES_FindMetric
 562  *
 563  * Find a metric property for the current installed theme
 564  *
 565  * PARAMS
 566  *     tf                  Theme file
 567  *     iPropertyPrimitive  Type of value expected
 568  *     iPropertyId         ID of the required value
 569  *
 570  * RETURNS
 571  *  The property found, or NULL
 572  */
 573 PTHEME_PROPERTY MSSTYLES_FindMetric(int iPropertyPrimitive, int iPropertyId)
 574 {
 575     if(!tfActiveTheme) return NULL;
 576     return MSSTYLES_FFindMetric(tfActiveTheme, iPropertyPrimitive, iPropertyId);
 577 }
 578
 579 /***********************************************************************
 580  *      MSSTYLES_AddProperty
 581  *
 582  * Add a property to a part/state
 583  *
 584  * PARAMS
 585  *     ps                  Part/state
 586  *     iPropertyPrimitive  Primitive type of the property
 587  *     iPropertyId         ID of the property
 588  *     lpValue             Raw value (non-NULL terminated)
 589  *     dwValueLen          Length of the value
 590  *
 591  * RETURNS
 592  *  The property added, or a property previously added with the same IDs
 593  */
 594 PTHEME_PROPERTY MSSTYLES_AddProperty(PTHEME_PARTSTATE ps, int iPropertyPrimitive, int iPropertyId, LPCWSTR lpValue, DWORD dwValueLen, BOOL isGlobal)
 595 {
 596     PTHEME_PROPERTY cur = MSSTYLES_PSFindProperty(ps, iPropertyPrimitive, iPropertyId);
 597     /* Should duplicate properties overwrite the original, or be ignored? */
 598     if(cur) return cur;
 599
 600     cur = HeapAlloc(GetProcessHeap(), 0, sizeof(THEME_PROPERTY));
 601     cur->iPrimitiveType = iPropertyPrimitive;
 602     cur->iPropertyId = iPropertyId;
 603     cur->lpValue = lpValue;
 604     cur->dwValueLen = dwValueLen;
 605
 606     if(ps->iStateId)
 607         cur->origin = PO_STATE;
 608     else if(ps->iPartId)
 609         cur->origin = PO_PART;
 610     else if(isGlobal)
 611         cur->origin = PO_GLOBAL;
 612     else
 613         cur->origin = PO_CLASS;
 614
 615     cur->next = ps->properties;
 616     ps->properties = cur;
 617     return cur;
 618 }
 619
 620 /***********************************************************************
 621  *      MSSTYLES_AddMetric
 622  *
 623  * Add a property to a part/state
 624  *
 625  * PARAMS
 626  *     tf                  Theme file
 627  *     iPropertyPrimitive  Primitive type of the property
 628  *     iPropertyId         ID of the property
 629  *     lpValue             Raw value (non-NULL terminated)
 630  *     dwValueLen          Length of the value
 631  *
 632  * RETURNS
 633  *  The property added, or a property previously added with the same IDs
 634  */
 635 PTHEME_PROPERTY MSSTYLES_AddMetric(PTHEME_FILE tf, int iPropertyPrimitive, int iPropertyId, LPCWSTR lpValue, DWORD dwValueLen)
 636 {
 637     PTHEME_PROPERTY cur = MSSTYLES_FFindMetric(tf, iPropertyPrimitive, iPropertyId);
 638     /* Should duplicate properties overwrite the original, or be ignored? */
 639     if(cur) return cur;
 640
 641     cur = HeapAlloc(GetProcessHeap(), 0, sizeof(THEME_PROPERTY));
 642     cur->iPrimitiveType = iPropertyPrimitive;
 643     cur->iPropertyId = iPropertyId;
 644     cur->lpValue = lpValue;
 645     cur->dwValueLen = dwValueLen;
 646
 647     cur->origin = PO_GLOBAL;
 648
 649     cur->next = tf->metrics;
 650     tf->metrics = cur;
 651     return cur;
 652 }
 653
 654 /***********************************************************************
 655  *      MSSTYLES_ParseThemeIni
 656  *
 657  * Parse the theme ini for the selected color/style
 658  *
 659  * PARAMS
 660  *     tf                  Theme to parse
 661  */
 662 void MSSTYLES_ParseThemeIni(PTHEME_FILE tf)
 663 {
 664     static const WCHAR szSysMetrics[] = {'S','y','s','M','e','t','r','i','c','s','\0'};
 665     static const WCHAR szGlobals[] = {'g','l','o','b','a','l','s','\0'};
 666     PTHEME_CLASS cls;
 667     PTHEME_CLASS globals;
 668     PTHEME_PARTSTATE ps;
 669     PUXINI_FILE ini;
 670     WCHAR szAppName[MAX_THEME_APP_NAME];
 671     WCHAR szClassName[MAX_THEME_CLASS_NAME];
 672     WCHAR szPropertyName[MAX_THEME_VALUE_NAME];
 673     int iPartId;
 674     int iStateId;
 675     int iPropertyPrimitive;
 676     int iPropertyId;
 677     DWORD dwLen;
 678     LPCWSTR lpName;
 679     DWORD dwValueLen;
 680     LPCWSTR lpValue;
 681
 682     ini = MSSTYLES_GetActiveThemeIni(tf);
 683
 684     while((lpName=UXINI_GetNextSection(ini, &dwLen))) {
 685         if(CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lpName, dwLen, szSysMetrics, -1) == CSTR_EQUAL) {
 686             int colorCount = 0;
 687             int colorElements[TMT_LASTCOLOR-TMT_FIRSTCOLOR];
 688             COLORREF colorRgb[TMT_LASTCOLOR-TMT_FIRSTCOLOR];
 689             LPCWSTR lpValueEnd;
 690
 691             while((lpName=UXINI_GetNextValue(ini, &dwLen, &lpValue, &dwValueLen))) {
 692                 lstrcpynW(szPropertyName, lpName, min(dwLen+1, sizeof(szPropertyName)/sizeof(szPropertyName[0])));
 693                 if(MSSTYLES_LookupProperty(szPropertyName, &iPropertyPrimitive, &iPropertyId)) {
 694                     if(iPropertyId >= TMT_FIRSTCOLOR && iPropertyId <= TMT_LASTCOLOR) {
 695                         int r,g,b;
 696                         lpValueEnd = lpValue + dwValueLen;
 697                         MSSTYLES_GetNextInteger(lpValue, lpValueEnd, &lpValue, &r);
 698                         MSSTYLES_GetNextInteger(lpValue, lpValueEnd, &lpValue, &g);
 699                         if(MSSTYLES_GetNextInteger(lpValue, lpValueEnd, &lpValue, &b)) {
 700                             colorElements[colorCount] = iPropertyId - TMT_FIRSTCOLOR;
 701                             colorRgb[colorCount++] = RGB(r,g,b);
 702                         }
 703                         else {
 704                             FIXME("Invalid color value for %s\n", debugstr_w(szPropertyName));
 705                         }
 706                     }
 707                     /* Catch all metrics, including colors */
 708                     MSSTYLES_AddMetric(tf, iPropertyPrimitive, iPropertyId, lpValue, dwValueLen);
 709                 }
 710                 else {
 711                     TRACE("Unknown system metric %s\n", debugstr_w(szPropertyName));
 712                 }
 713             }
 714             if(colorCount > 0)
 715                 SetSysColors(colorCount, colorElements, colorRgb);
 716             continue;
 717         }
 718         if(MSSTYLES_ParseIniSectionName(lpName, dwLen, szAppName, szClassName, &iPartId, &iStateId)) {
 719             BOOL isGlobal = FALSE;
 720             if(!lstrcmpiW(szClassName, szGlobals)) {
 721                 isGlobal = TRUE;
 722             }
 723             cls = MSSTYLES_AddClass(tf, szAppName, szClassName);
 724             ps = MSSTYLES_AddPartState(cls, iPartId, iStateId);
 725
 726             while((lpName=UXINI_GetNextValue(ini, &dwLen, &lpValue, &dwValueLen))) {
 727                 lstrcpynW(szPropertyName, lpName, min(dwLen+1, sizeof(szPropertyName)/sizeof(szPropertyName[0])));
 728                 if(MSSTYLES_LookupProperty(szPropertyName, &iPropertyPrimitive, &iPropertyId)) {
 729                     MSSTYLES_AddProperty(ps, iPropertyPrimitive, iPropertyId, lpValue, dwValueLen, isGlobal);
 730                 }
 731                 else {
 732                     TRACE("Unknown property %s\n", debugstr_w(szPropertyName));
 733                 }
 734             }
 735         }
 736     }
 737
 738     /* App/Class combos override values defined by the base class, map these overrides */
 739     globals = MSSTYLES_FindClass(tf, NULL, szGlobals);
 740     cls = tf->classes;
 741     while(cls) {
 742         if(*cls->szAppName) {
 743             cls->overrides = MSSTYLES_FindClass(tf, NULL, cls->szClassName);
 744             if(!cls->overrides) {
 745                 TRACE("No overrides found for app %s class %s\n", debugstr_w(cls->szAppName), debugstr_w(cls->szClassName));
 746             }
 747             else {
 748                 cls->overrides = globals;
 749             }
 750         }
 751         else {
 752             /* Everything overrides globals..except globals */
 753             if(cls != globals) cls->overrides = globals;
 754         }
 755         cls = cls->next;
 756     }
 757     UXINI_CloseINI(ini);
 758
 759     if(!tf->classes) {
 760         ERR("Failed to parse theme ini\n");
 761     }
 762 }
 763
 764 /***********************************************************************
 765  *      MSSTYLES_OpenThemeClass
 766  *
 767  * Open a theme class, uses the current active theme
 768  *
 769  * PARAMS
 770  *     pszAppName          Application name, for theme styles specific
 771  *                         to a particular application
 772  *     pszClassList        List of requested classes, semicolon delimited
 773  */
 774 PTHEME_CLASS MSSTYLES_OpenThemeClass(LPCWSTR pszAppName, LPCWSTR pszClassList)
 775 {
 776     PTHEME_CLASS cls = NULL;
 777     WCHAR szClassName[MAX_THEME_CLASS_NAME];
 778     LPCWSTR start;
 779     LPCWSTR end;
 780     DWORD len;
 781
 782     if(!tfActiveTheme) {
 783         TRACE("there is no active theme\n");
 784         return NULL;
 785     }
 786     if(!tfActiveTheme->classes) {
 787         MSSTYLES_ParseThemeIni(tfActiveTheme);
 788         if(!tfActiveTheme->classes)
 789             return NULL;
 790     }
 791
 792     start = pszClassList;
 793     while((end = StrChrW(start, ';'))) {
 794         len = end-start;
 795         lstrcpynW(szClassName, start, min(len+1, sizeof(szClassName)/sizeof(szClassName[0])));
 796         start = end+1;
 797         cls = MSSTYLES_FindClass(tfActiveTheme, pszAppName, szClassName);
 798         if(cls) break;
 799     }
 800     if(!cls && *start) {
 801         lstrcpynW(szClassName, start, sizeof(szClassName)/sizeof(szClassName[0]));
 802         cls = MSSTYLES_FindClass(tfActiveTheme, pszAppName, szClassName);
 803     }
 804     if(cls) {
 805         TRACE("Opened app %s, class %s from list %s\n", debugstr_w(cls->szAppName), debugstr_w(cls->szClassName), debugstr_w(pszClassList));
 806     }
 807     return cls;
 808 }
 809
 810 /***********************************************************************
 811  *      MSSTYLES_CloseThemeClass
 812  *
 813  * Close a theme class
 814  *
 815  * PARAMS
 816  *     tc                  Theme class to close
 817  *
 818  * NOTES
 819  *  There is currently no need clean anything up for theme classes,
 820  *  so do nothing for now
 821  */
 822 HRESULT MSSTYLES_CloseThemeClass(PTHEME_CLASS tc)
 823 {
 824     return S_OK;
 825 }
 826
 827 /***********************************************************************
 828  *      MSSTYLES_FindProperty
 829  *
 830  * Locate a property in a class. Part and state IDs will be used as a
 831  * preference, but may be ignored in the attempt to locate the property.
 832  * Will scan the entire chain of overrides for this class.
 833  */
 834 PTHEME_PROPERTY MSSTYLES_FindProperty(PTHEME_CLASS tc, int iPartId, int iStateId, int iPropertyPrimitive, int iPropertyId)
 835 {
 836     PTHEME_CLASS next = tc;
 837     PTHEME_PARTSTATE ps;
 838     PTHEME_PROPERTY tp;
 839
 840     TRACE("(%p, %d, %d, %d)\n", tc, iPartId, iStateId, iPropertyId);
 841      /* Try and find an exact match on part & state */
 842     while(next && (ps = MSSTYLES_FindPartState(next, iPartId, iStateId, &next))) {
 843         if((tp = MSSTYLES_PSFindProperty(ps, iPropertyPrimitive, iPropertyId))) {
 844             return tp;
 845         }
 846     }
 847     /* If that fails, and we didn't already try it, search for just part */
 848     if(iStateId != 0)
 849         iStateId = 0;
 850     /* As a last ditch attempt..go for just class */
 851     else if(iPartId != 0)
 852         iPartId = 0;
 853     else
 854         return NULL;
 855
 856     if((tp = MSSTYLES_FindProperty(tc, iPartId, iStateId, iPropertyPrimitive, iPropertyId)))
 857         return tp;
 858     return NULL;
 859 }
 860
 861 HBITMAP MSSTYLES_LoadBitmap(HDC hdc, PTHEME_CLASS tc, LPCWSTR lpFilename)
 862 {
 863     WCHAR szFile[MAX_PATH];
 864     LPWSTR tmp;
 865     lstrcpynW(szFile, lpFilename, sizeof(szFile)/sizeof(szFile[0]));
 866     tmp = szFile;
 867     do {
 868         if(*tmp == '\\') *tmp = '_';
 869         if(*tmp == '/') *tmp = '_';
 870         if(*tmp == '.') *tmp = '_';
 871     } while(*tmp++);
 872     return LoadImageW(tc->hTheme, szFile, IMAGE_BITMAP, 0, 0, LR_SHARED|LR_CREATEDIBSECTION);
 873 }
 874
 875 BOOL MSSTYLES_GetNextInteger(LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR *lpValEnd, int *value)
 876 {
 877     LPCWSTR cur = lpStringStart;
 878     int total = 0;
 879     BOOL gotNeg = FALSE;
 880
 881     while(cur < lpStringEnd && (*cur < '0' || *cur > '9' || *cur == '-')) cur++;
 882     if(cur >= lpStringEnd) {
 883         return FALSE;
 884     }
 885     if(*cur == '-') {
 886         cur++;
 887         gotNeg = TRUE;
 888     }
 889     while(cur < lpStringEnd && (*cur >= '0' && *cur <= '9')) {
 890         total = total * 10 + (*cur - '0');
 891         cur++;
 892     }
 893     if(gotNeg) total = -total;
 894     *value = total;
 895     if(lpValEnd) *lpValEnd = cur;
 896     return TRUE;
 897 }
 898
 899 BOOL MSSTYLES_GetNextToken(LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR *lpValEnd, LPWSTR lpBuff, DWORD buffSize) {
 900     LPCWSTR cur = lpStringStart;
 901     LPCWSTR start;
 902     LPCWSTR end;
 903
 904     while(cur < lpStringEnd && (isspace(*cur) || *cur == ',')) cur++;
 905     if(cur >= lpStringEnd) {
 906         return FALSE;
 907     }
 908     start = cur;
 909     while(cur < lpStringEnd && *cur != ',') cur++;
 910     end = cur;
 911     while(isspace(*end)) end--;
 912
 913     lstrcpynW(lpBuff, start, min(buffSize, end-start+1));
 914
 915     if(lpValEnd) *lpValEnd = cur;
 916     return TRUE;
 917 }
 918
 919 /***********************************************************************
 920  *      MSSTYLES_GetPropertyBool
 921  *
 922  * Retrieve a color value for a property
 923  */
 924 HRESULT MSSTYLES_GetPropertyBool(PTHEME_PROPERTY tp, BOOL *pfVal)
 925 {
 926     *pfVal = FALSE;
 927     if(*tp->lpValue == 't' || *tp->lpValue == 'T')
 928         *pfVal = TRUE;
 929     return S_OK;
 930 }
 931
 932 /***********************************************************************
 933  *      MSSTYLES_GetPropertyColor
 934  *
 935  * Retrieve a color value for a property
 936  */
 937 HRESULT MSSTYLES_GetPropertyColor(PTHEME_PROPERTY tp, COLORREF *pColor)
 938 {
 939     LPCWSTR lpEnd;
 940     LPCWSTR lpCur;
 941     int red, green, blue;
 942
 943     lpCur = tp->lpValue;
 944     lpEnd = tp->lpValue + tp->dwValueLen;
 945
 946     MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &red);
 947     MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &green);
 948     if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &blue)) {
 949         TRACE("Could not parse color property\n");
 950         return E_PROP_ID_UNSUPPORTED;
 951     }
 952     *pColor = RGB(red,green,blue);
 953     return S_OK;
 954 }
 955
 956 /***********************************************************************
 957  *      MSSTYLES_GetPropertyColor
 958  *
 959  * Retrieve a color value for a property
 960  */
 961 HRESULT MSSTYLES_GetPropertyFont(PTHEME_PROPERTY tp, HDC hdc, LOGFONTW *pFont)
 962 {
 963     static const WCHAR szBold[] = {'b','o','l','d','\0'};
 964     static const WCHAR szItalic[] = {'i','t','a','l','i','c','\0'};
 965     static const WCHAR szUnderline[] = {'u','n','d','e','r','l','i','n','e','\0'};
 966     static const WCHAR szStrikeOut[] = {'s','t','r','i','k','e','o','u','t','\0'};
 967     int pointSize;
 968     WCHAR attr[32];
 969     LPCWSTR lpCur = tp->lpValue;
 970     LPCWSTR lpEnd = tp->lpValue + tp->dwValueLen;
 971
 972     ZeroMemory(pFont, sizeof(LOGFONTW));
 973
 974     if(!MSSTYLES_GetNextToken(lpCur, lpEnd, &lpCur, pFont->lfFaceName, LF_FACESIZE)) {
 975         TRACE("Property is there, but failed to get face name\n");
 976         return E_PROP_ID_UNSUPPORTED;
 977     }
 978     if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pointSize)) {
 979         TRACE("Property is there, but failed to get point size\n");
 980         return E_PROP_ID_UNSUPPORTED;
 981     }
 982     pFont->lfHeight = -MulDiv(pointSize, GetDeviceCaps(hdc, LOGPIXELSY), 72);
 983     pFont->lfWeight = FW_REGULAR;
 984     pFont->lfCharSet = DEFAULT_CHARSET;
 985     while(MSSTYLES_GetNextToken(lpCur, lpEnd, &lpCur, attr, sizeof(attr)/sizeof(attr[0]))) {
 986         if(!lstrcmpiW(szBold, attr)) pFont->lfWeight = FW_BOLD;
 987         else if(!!lstrcmpiW(szItalic, attr)) pFont->lfItalic = TRUE;
 988         else if(!!lstrcmpiW(szUnderline, attr)) pFont->lfUnderline = TRUE;
 989         else if(!!lstrcmpiW(szStrikeOut, attr)) pFont->lfStrikeOut = TRUE;
 990     }
 991     return S_OK;
 992 }
 993
 994 /***********************************************************************
 995  *      MSSTYLES_GetPropertyInt
 996  *
 997  * Retrieve an int value for a property
 998  */
 999 HRESULT MSSTYLES_GetPropertyInt(PTHEME_PROPERTY tp, int *piVal)
1000 {
1001     if(!MSSTYLES_GetNextInteger(tp->lpValue, (tp->lpValue + tp->dwValueLen), NULL, piVal)) {
1002         TRACE("Could not parse int property\n");
1003         return E_PROP_ID_UNSUPPORTED;
1004     }
1005     return S_OK;
1006 }
1007
1008 /***********************************************************************
1009  *      MSSTYLES_GetPropertyIntList
1010  *
1011  * Retrieve an int list value for a property
1012  */
1013 HRESULT MSSTYLES_GetPropertyIntList(PTHEME_PROPERTY tp, INTLIST *pIntList)
1014 {
1015     int i;
1016     LPCWSTR lpCur = tp->lpValue;
1017     LPCWSTR lpEnd = tp->lpValue + tp->dwValueLen;
1018
1019     for(i=0; i < MAX_INTLIST_COUNT; i++) {
1020         if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pIntList->iValues[i]))
1021             break;
1022     }
1023     pIntList->iValueCount = i;
1024     return S_OK;
1025 }
1026
1027 /***********************************************************************
1028  *      MSSTYLES_GetPropertyPosition
1029  *
1030  * Retrieve a position value for a property
1031  */
1032 HRESULT MSSTYLES_GetPropertyPosition(PTHEME_PROPERTY tp, POINT *pPoint)
1033 {
1034     int x,y;
1035     LPCWSTR lpCur = tp->lpValue;
1036     LPCWSTR lpEnd = tp->lpValue + tp->dwValueLen;
1037
1038     MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &x);
1039     if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &y)) {
1040         TRACE("Could not parse position property\n");
1041         return E_PROP_ID_UNSUPPORTED;
1042     }
1043     pPoint->x = x;
1044     pPoint->y = y;
1045     return S_OK;
1046 }
1047
1048 /***********************************************************************
1049  *      MSSTYLES_GetPropertyString
1050  *
1051  * Retrieve a string value for a property
1052  */
1053 HRESULT MSSTYLES_GetPropertyString(PTHEME_PROPERTY tp, LPWSTR pszBuff, int cchMaxBuffChars)
1054 {
1055     lstrcpynW(pszBuff, tp->lpValue, min(tp->dwValueLen+1, cchMaxBuffChars));
1056     return S_OK;
1057 }
1058
1059 /***********************************************************************
1060  *      MSSTYLES_GetPropertyRect
1061  *
1062  * Retrieve a rect value for a property
1063  */
1064 HRESULT MSSTYLES_GetPropertyRect(PTHEME_PROPERTY tp, RECT *pRect)
1065 {
1066     LPCWSTR lpCur = tp->lpValue;
1067     LPCWSTR lpEnd = tp->lpValue + tp->dwValueLen;
1068
1069     MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, (int*)&pRect->left);
1070     MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, (int*)&pRect->top);
1071     MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, (int*)&pRect->right);
1072     if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, (int*)&pRect->bottom)) {
1073         TRACE("Could not parse rect property\n");
1074         return E_PROP_ID_UNSUPPORTED;
1075     }
1076     return S_OK;
1077 }
1078
1079 /***********************************************************************
1080  *      MSSTYLES_GetPropertyMargins
1081  *
1082  * Retrieve a margins value for a property
1083  */
1084 HRESULT MSSTYLES_GetPropertyMargins(PTHEME_PROPERTY tp, RECT *prc, MARGINS *pMargins)
1085 {
1086     LPCWSTR lpCur = tp->lpValue;
1087     LPCWSTR lpEnd = tp->lpValue + tp->dwValueLen;
1088
1089     MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pMargins->cxLeftWidth);
1090     MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pMargins->cxRightWidth);
1091     MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pMargins->cyTopHeight);
1092     if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pMargins->cyBottomHeight)) {
1093         TRACE("Could not parse margins property\n");
1094         return E_PROP_ID_UNSUPPORTED;
1095     }
1096     return S_OK;
1097 }