mirror of
git://source.winehq.org/git/wine.git
synced 2024-10-31 10:41:12 +00:00
1399 lines
43 KiB
C
1399 lines
43 KiB
C
/*
|
|
* Win32 5.1 msstyles theme format
|
|
*
|
|
* Copyright (C) 2003 Kevin Koltzau
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "wingdi.h"
|
|
#include "winuser.h"
|
|
#include "winnls.h"
|
|
#include "vfwmsgs.h"
|
|
#include "uxtheme.h"
|
|
#include "tmschema.h"
|
|
|
|
#include "msstyles.h"
|
|
|
|
#include "wine/unicode.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(uxtheme);
|
|
|
|
/***********************************************************************
|
|
* Defines and global variables
|
|
*/
|
|
|
|
static BOOL MSSTYLES_GetNextInteger(LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR *lpValEnd, int *value);
|
|
static BOOL MSSTYLES_GetNextToken(LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR *lpValEnd, LPWSTR lpBuff, DWORD buffSize);
|
|
static void MSSTYLES_ParseThemeIni(PTHEME_FILE tf, BOOL setMetrics);
|
|
static HRESULT MSSTYLES_GetFont (LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR *lpValEnd, LOGFONTW* logfont);
|
|
|
|
extern int alphaBlendMode;
|
|
|
|
#define MSSTYLES_VERSION 0x0003
|
|
|
|
static const WCHAR szThemesIniResource[] = {
|
|
't','h','e','m','e','s','_','i','n','i','\0'
|
|
};
|
|
|
|
static PTHEME_FILE tfActiveTheme;
|
|
|
|
/***********************************************************************/
|
|
|
|
/**********************************************************************
|
|
* MSSTYLES_OpenThemeFile
|
|
*
|
|
* Load and validate a theme
|
|
*
|
|
* PARAMS
|
|
* lpThemeFile Path to theme file to load
|
|
* pszColorName Color name wanted, can be NULL
|
|
* pszSizeName Size name wanted, can be NULL
|
|
*
|
|
* NOTES
|
|
* If pszColorName or pszSizeName are NULL, the default color/size will be used.
|
|
* If one/both are provided, they are validated against valid color/sizes and if
|
|
* a match is not found, the function fails.
|
|
*/
|
|
HRESULT MSSTYLES_OpenThemeFile(LPCWSTR lpThemeFile, LPCWSTR pszColorName, LPCWSTR pszSizeName, PTHEME_FILE *tf)
|
|
{
|
|
HMODULE hTheme;
|
|
HRSRC hrsc;
|
|
HRESULT hr = S_OK;
|
|
static const WCHAR szPackThemVersionResource[] = {
|
|
'P','A','C','K','T','H','E','M','_','V','E','R','S','I','O','N', '\0'
|
|
};
|
|
static const WCHAR szColorNamesResource[] = {
|
|
'C','O','L','O','R','N','A','M','E','S','\0'
|
|
};
|
|
static const WCHAR szSizeNamesResource[] = {
|
|
'S','I','Z','E','N','A','M','E','S','\0'
|
|
};
|
|
|
|
WORD version;
|
|
DWORD versize;
|
|
LPWSTR pszColors;
|
|
LPWSTR pszSelectedColor = NULL;
|
|
LPWSTR pszSizes;
|
|
LPWSTR pszSelectedSize = NULL;
|
|
LPWSTR tmp;
|
|
|
|
TRACE("Opening %s\n", debugstr_w(lpThemeFile));
|
|
|
|
hTheme = LoadLibraryExW(lpThemeFile, NULL, LOAD_LIBRARY_AS_DATAFILE);
|
|
|
|
/* Validate that this is really a theme */
|
|
if(!hTheme) {
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
goto invalid_theme;
|
|
}
|
|
if(!(hrsc = FindResourceW(hTheme, MAKEINTRESOURCEW(1), szPackThemVersionResource))) {
|
|
TRACE("No version resource found\n");
|
|
hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
|
|
goto invalid_theme;
|
|
}
|
|
if((versize = SizeofResource(hTheme, hrsc)) != 2)
|
|
{
|
|
TRACE("Version resource found, but wrong size: %d\n", versize);
|
|
hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
|
|
goto invalid_theme;
|
|
}
|
|
version = *(WORD*)LoadResource(hTheme, hrsc);
|
|
if(version != MSSTYLES_VERSION)
|
|
{
|
|
TRACE("Version of theme file is unsupported: 0x%04x\n", version);
|
|
hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
|
|
goto invalid_theme;
|
|
}
|
|
|
|
if(!(hrsc = FindResourceW(hTheme, MAKEINTRESOURCEW(1), szColorNamesResource))) {
|
|
TRACE("Color names resource not found\n");
|
|
hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
|
|
goto invalid_theme;
|
|
}
|
|
pszColors = LoadResource(hTheme, hrsc);
|
|
|
|
if(!(hrsc = FindResourceW(hTheme, MAKEINTRESOURCEW(1), szSizeNamesResource))) {
|
|
TRACE("Size names resource not found\n");
|
|
hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
|
|
goto invalid_theme;
|
|
}
|
|
pszSizes = LoadResource(hTheme, hrsc);
|
|
|
|
/* Validate requested color against what's available from the theme */
|
|
if(pszColorName) {
|
|
tmp = pszColors;
|
|
while(*tmp) {
|
|
if(!lstrcmpiW(pszColorName, tmp)) {
|
|
pszSelectedColor = tmp;
|
|
break;
|
|
}
|
|
tmp += lstrlenW(tmp)+1;
|
|
}
|
|
}
|
|
else
|
|
pszSelectedColor = pszColors; /* Use the default color */
|
|
|
|
/* Validate requested size against what's available from the theme */
|
|
if(pszSizeName) {
|
|
tmp = pszSizes;
|
|
while(*tmp) {
|
|
if(!lstrcmpiW(pszSizeName, tmp)) {
|
|
pszSelectedSize = tmp;
|
|
break;
|
|
}
|
|
tmp += lstrlenW(tmp)+1;
|
|
}
|
|
}
|
|
else
|
|
pszSelectedSize = pszSizes; /* Use the default size */
|
|
|
|
if(!pszSelectedColor || !pszSelectedSize) {
|
|
TRACE("Requested color/size (%s/%s) not found in theme\n",
|
|
debugstr_w(pszColorName), debugstr_w(pszSizeName));
|
|
hr = E_PROP_ID_UNSUPPORTED;
|
|
goto invalid_theme;
|
|
}
|
|
|
|
*tf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(THEME_FILE));
|
|
(*tf)->hTheme = hTheme;
|
|
|
|
GetFullPathNameW(lpThemeFile, MAX_PATH, (*tf)->szThemeFile, NULL);
|
|
|
|
(*tf)->pszAvailColors = pszColors;
|
|
(*tf)->pszAvailSizes = pszSizes;
|
|
(*tf)->pszSelectedColor = pszSelectedColor;
|
|
(*tf)->pszSelectedSize = pszSelectedSize;
|
|
(*tf)->dwRefCount = 1;
|
|
return S_OK;
|
|
|
|
invalid_theme:
|
|
if(hTheme) FreeLibrary(hTheme);
|
|
return hr;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_CloseThemeFile
|
|
*
|
|
* Close theme file and free resources
|
|
*/
|
|
void MSSTYLES_CloseThemeFile(PTHEME_FILE tf)
|
|
{
|
|
if(tf) {
|
|
tf->dwRefCount--;
|
|
if(!tf->dwRefCount) {
|
|
if(tf->hTheme) FreeLibrary(tf->hTheme);
|
|
if(tf->classes) {
|
|
while(tf->classes) {
|
|
PTHEME_CLASS pcls = tf->classes;
|
|
tf->classes = pcls->next;
|
|
while(pcls->partstate) {
|
|
PTHEME_PARTSTATE ps = pcls->partstate;
|
|
|
|
while(ps->properties) {
|
|
PTHEME_PROPERTY prop = ps->properties;
|
|
ps->properties = prop->next;
|
|
HeapFree(GetProcessHeap(), 0, prop);
|
|
}
|
|
|
|
pcls->partstate = ps->next;
|
|
HeapFree(GetProcessHeap(), 0, ps);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, pcls);
|
|
}
|
|
}
|
|
while (tf->images)
|
|
{
|
|
PTHEME_IMAGE img = tf->images;
|
|
tf->images = img->next;
|
|
DeleteObject (img->image);
|
|
HeapFree (GetProcessHeap(), 0, img);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, tf);
|
|
}
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_SetActiveTheme
|
|
*
|
|
* Set the current active theme
|
|
*/
|
|
HRESULT MSSTYLES_SetActiveTheme(PTHEME_FILE tf, BOOL setMetrics)
|
|
{
|
|
if(tfActiveTheme)
|
|
MSSTYLES_CloseThemeFile(tfActiveTheme);
|
|
tfActiveTheme = tf;
|
|
if (tfActiveTheme)
|
|
{
|
|
tfActiveTheme->dwRefCount++;
|
|
if(!tfActiveTheme->classes)
|
|
MSSTYLES_ParseThemeIni(tfActiveTheme, setMetrics);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_GetThemeIni
|
|
*
|
|
* Retrieves themes.ini from a theme
|
|
*/
|
|
PUXINI_FILE MSSTYLES_GetThemeIni(PTHEME_FILE tf)
|
|
{
|
|
return UXINI_LoadINI(tf->hTheme, szThemesIniResource);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_GetActiveThemeIni
|
|
*
|
|
* Retrieve the ini file for the selected color/style
|
|
*/
|
|
static PUXINI_FILE MSSTYLES_GetActiveThemeIni(PTHEME_FILE tf)
|
|
{
|
|
static const WCHAR szFileResNamesResource[] = {
|
|
'F','I','L','E','R','E','S','N','A','M','E','S','\0'
|
|
};
|
|
DWORD dwColorCount = 0;
|
|
DWORD dwSizeCount = 0;
|
|
DWORD dwColorNum = 0;
|
|
DWORD dwSizeNum = 0;
|
|
DWORD i;
|
|
DWORD dwResourceIndex;
|
|
LPWSTR tmp;
|
|
HRSRC hrsc;
|
|
|
|
/* Count the number of available colors & styles, and determine the index number
|
|
of the color/style we are interested in
|
|
*/
|
|
tmp = tf->pszAvailColors;
|
|
while(*tmp) {
|
|
if(!lstrcmpiW(tf->pszSelectedColor, tmp))
|
|
dwColorNum = dwColorCount;
|
|
tmp += lstrlenW(tmp)+1;
|
|
dwColorCount++;
|
|
}
|
|
tmp = tf->pszAvailSizes;
|
|
while(*tmp) {
|
|
if(!lstrcmpiW(tf->pszSelectedSize, tmp))
|
|
dwSizeNum = dwSizeCount;
|
|
tmp += lstrlenW(tmp)+1;
|
|
dwSizeCount++;
|
|
}
|
|
|
|
if(!(hrsc = FindResourceW(tf->hTheme, MAKEINTRESOURCEW(1), szFileResNamesResource))) {
|
|
TRACE("FILERESNAMES map not found\n");
|
|
return NULL;
|
|
}
|
|
tmp = LoadResource(tf->hTheme, hrsc);
|
|
dwResourceIndex = (dwSizeCount * dwColorNum) + dwSizeNum;
|
|
for(i=0; i < dwResourceIndex; i++) {
|
|
tmp += lstrlenW(tmp)+1;
|
|
}
|
|
return UXINI_LoadINI(tf->hTheme, tmp);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_ParseIniSectionName
|
|
*
|
|
* Parse an ini section name into its component parts
|
|
* Valid formats are:
|
|
* [classname]
|
|
* [classname(state)]
|
|
* [classname.part]
|
|
* [classname.part(state)]
|
|
* [application::classname]
|
|
* [application::classname(state)]
|
|
* [application::classname.part]
|
|
* [application::classname.part(state)]
|
|
*
|
|
* PARAMS
|
|
* lpSection Section name
|
|
* dwLen Length of section name
|
|
* szAppName Location to store application name
|
|
* szClassName Location to store class name
|
|
* iPartId Location to store part id
|
|
* iStateId Location to store state id
|
|
*/
|
|
static BOOL MSSTYLES_ParseIniSectionName(LPCWSTR lpSection, DWORD dwLen, LPWSTR szAppName, LPWSTR szClassName, int *iPartId, int *iStateId)
|
|
{
|
|
WCHAR sec[255];
|
|
WCHAR part[60] = {'\0'};
|
|
WCHAR state[60] = {'\0'};
|
|
LPWSTR tmp;
|
|
LPWSTR comp;
|
|
lstrcpynW(sec, lpSection, min(dwLen+1, sizeof(sec)/sizeof(sec[0])));
|
|
|
|
*szAppName = 0;
|
|
*szClassName = 0;
|
|
*iPartId = 0;
|
|
*iStateId = 0;
|
|
comp = sec;
|
|
/* Get the application name */
|
|
tmp = strchrW(comp, ':');
|
|
if(tmp) {
|
|
*tmp++ = 0;
|
|
tmp++;
|
|
lstrcpynW(szAppName, comp, MAX_THEME_APP_NAME);
|
|
comp = tmp;
|
|
}
|
|
|
|
tmp = strchrW(comp, '.');
|
|
if(tmp) {
|
|
*tmp++ = 0;
|
|
lstrcpynW(szClassName, comp, MAX_THEME_CLASS_NAME);
|
|
comp = tmp;
|
|
/* now get the part & state */
|
|
tmp = strchrW(comp, '(');
|
|
if(tmp) {
|
|
*tmp++ = 0;
|
|
lstrcpynW(part, comp, sizeof(part)/sizeof(part[0]));
|
|
comp = tmp;
|
|
/* now get the state */
|
|
tmp = strchrW(comp, ')');
|
|
if (!tmp)
|
|
return FALSE;
|
|
*tmp = 0;
|
|
lstrcpynW(state, comp, sizeof(state)/sizeof(state[0]));
|
|
}
|
|
else {
|
|
lstrcpynW(part, comp, sizeof(part)/sizeof(part[0]));
|
|
}
|
|
}
|
|
else {
|
|
tmp = strchrW(comp, '(');
|
|
if(tmp) {
|
|
*tmp++ = 0;
|
|
lstrcpynW(szClassName, comp, MAX_THEME_CLASS_NAME);
|
|
comp = tmp;
|
|
/* now get the state */
|
|
tmp = strchrW(comp, ')');
|
|
if (!tmp)
|
|
return FALSE;
|
|
*tmp = 0;
|
|
lstrcpynW(state, comp, sizeof(state)/sizeof(state[0]));
|
|
}
|
|
else {
|
|
lstrcpynW(szClassName, comp, MAX_THEME_CLASS_NAME);
|
|
}
|
|
}
|
|
if(!*szClassName) return FALSE;
|
|
return MSSTYLES_LookupPartState(szClassName, part[0]?part:NULL, state[0]?state:NULL, iPartId, iStateId);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_FindClass
|
|
*
|
|
* Find a class
|
|
*
|
|
* PARAMS
|
|
* tf Theme file
|
|
* pszAppName App name to find
|
|
* pszClassName Class name to find
|
|
*
|
|
* RETURNS
|
|
* The class found, or NULL
|
|
*/
|
|
static PTHEME_CLASS MSSTYLES_FindClass(PTHEME_FILE tf, LPCWSTR pszAppName, LPCWSTR pszClassName)
|
|
{
|
|
PTHEME_CLASS cur = tf->classes;
|
|
while(cur) {
|
|
if(!pszAppName) {
|
|
if(!*cur->szAppName && !lstrcmpiW(pszClassName, cur->szClassName))
|
|
return cur;
|
|
}
|
|
else {
|
|
if(!lstrcmpiW(pszAppName, cur->szAppName) && !lstrcmpiW(pszClassName, cur->szClassName))
|
|
return cur;
|
|
}
|
|
cur = cur->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_AddClass
|
|
*
|
|
* Add a class to a theme file
|
|
*
|
|
* PARAMS
|
|
* tf Theme file
|
|
* pszAppName App name to add
|
|
* pszClassName Class name to add
|
|
*
|
|
* RETURNS
|
|
* The class added, or a class previously added with the same name
|
|
*/
|
|
static PTHEME_CLASS MSSTYLES_AddClass(PTHEME_FILE tf, LPCWSTR pszAppName, LPCWSTR pszClassName)
|
|
{
|
|
PTHEME_CLASS cur = MSSTYLES_FindClass(tf, pszAppName, pszClassName);
|
|
if(cur) return cur;
|
|
|
|
cur = HeapAlloc(GetProcessHeap(), 0, sizeof(THEME_CLASS));
|
|
cur->hTheme = tf->hTheme;
|
|
lstrcpyW(cur->szAppName, pszAppName);
|
|
lstrcpyW(cur->szClassName, pszClassName);
|
|
cur->next = tf->classes;
|
|
cur->partstate = NULL;
|
|
cur->overrides = NULL;
|
|
tf->classes = cur;
|
|
return cur;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_FindPartState
|
|
*
|
|
* Find a part/state
|
|
*
|
|
* PARAMS
|
|
* tc Class to search
|
|
* iPartId Part ID to find
|
|
* iStateId State ID to find
|
|
* tcNext Receives the next class in the override chain
|
|
*
|
|
* RETURNS
|
|
* The part/state found, or NULL
|
|
*/
|
|
PTHEME_PARTSTATE MSSTYLES_FindPartState(PTHEME_CLASS tc, int iPartId, int iStateId, PTHEME_CLASS *tcNext)
|
|
{
|
|
PTHEME_PARTSTATE cur = tc->partstate;
|
|
while(cur) {
|
|
if(cur->iPartId == iPartId && cur->iStateId == iStateId) {
|
|
if(tcNext) *tcNext = tc->overrides;
|
|
return cur;
|
|
}
|
|
cur = cur->next;
|
|
}
|
|
if(tc->overrides) return MSSTYLES_FindPartState(tc->overrides, iPartId, iStateId, tcNext);
|
|
return NULL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_AddPartState
|
|
*
|
|
* Add a part/state to a class
|
|
*
|
|
* PARAMS
|
|
* tc Theme class
|
|
* iPartId Part ID to add
|
|
* iStateId State ID to add
|
|
*
|
|
* RETURNS
|
|
* The part/state added, or a part/state previously added with the same IDs
|
|
*/
|
|
static PTHEME_PARTSTATE MSSTYLES_AddPartState(PTHEME_CLASS tc, int iPartId, int iStateId)
|
|
{
|
|
PTHEME_PARTSTATE cur = MSSTYLES_FindPartState(tc, iPartId, iStateId, NULL);
|
|
if(cur) return cur;
|
|
|
|
cur = HeapAlloc(GetProcessHeap(), 0, sizeof(THEME_PARTSTATE));
|
|
cur->iPartId = iPartId;
|
|
cur->iStateId = iStateId;
|
|
cur->properties = NULL;
|
|
cur->next = tc->partstate;
|
|
tc->partstate = cur;
|
|
return cur;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_LFindProperty
|
|
*
|
|
* Find a property within a property list
|
|
*
|
|
* PARAMS
|
|
* tp property list to scan
|
|
* iPropertyPrimitive Type of value expected
|
|
* iPropertyId ID of the required value
|
|
*
|
|
* RETURNS
|
|
* The property found, or NULL
|
|
*/
|
|
static PTHEME_PROPERTY MSSTYLES_LFindProperty(PTHEME_PROPERTY tp, int iPropertyPrimitive, int iPropertyId)
|
|
{
|
|
PTHEME_PROPERTY cur = tp;
|
|
while(cur) {
|
|
if(cur->iPropertyId == iPropertyId) {
|
|
if(cur->iPrimitiveType == iPropertyPrimitive) {
|
|
return cur;
|
|
}
|
|
else {
|
|
if(!iPropertyPrimitive)
|
|
return cur;
|
|
return NULL;
|
|
}
|
|
}
|
|
cur = cur->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_PSFindProperty
|
|
*
|
|
* Find a value within a part/state
|
|
*
|
|
* PARAMS
|
|
* ps Part/state to search
|
|
* iPropertyPrimitive Type of value expected
|
|
* iPropertyId ID of the required value
|
|
*
|
|
* RETURNS
|
|
* The property found, or NULL
|
|
*/
|
|
static inline PTHEME_PROPERTY MSSTYLES_PSFindProperty(PTHEME_PARTSTATE ps, int iPropertyPrimitive, int iPropertyId)
|
|
{
|
|
return MSSTYLES_LFindProperty(ps->properties, iPropertyPrimitive, iPropertyId);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_FFindMetric
|
|
*
|
|
* Find a metric property for a theme file
|
|
*
|
|
* PARAMS
|
|
* tf Theme file
|
|
* iPropertyPrimitive Type of value expected
|
|
* iPropertyId ID of the required value
|
|
*
|
|
* RETURNS
|
|
* The property found, or NULL
|
|
*/
|
|
static inline PTHEME_PROPERTY MSSTYLES_FFindMetric(PTHEME_FILE tf, int iPropertyPrimitive, int iPropertyId)
|
|
{
|
|
return MSSTYLES_LFindProperty(tf->metrics, iPropertyPrimitive, iPropertyId);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_FindMetric
|
|
*
|
|
* Find a metric property for the current installed theme
|
|
*
|
|
* PARAMS
|
|
* tf Theme file
|
|
* iPropertyPrimitive Type of value expected
|
|
* iPropertyId ID of the required value
|
|
*
|
|
* RETURNS
|
|
* The property found, or NULL
|
|
*/
|
|
PTHEME_PROPERTY MSSTYLES_FindMetric(int iPropertyPrimitive, int iPropertyId)
|
|
{
|
|
if(!tfActiveTheme) return NULL;
|
|
return MSSTYLES_FFindMetric(tfActiveTheme, iPropertyPrimitive, iPropertyId);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_AddProperty
|
|
*
|
|
* Add a property to a part/state
|
|
*
|
|
* PARAMS
|
|
* ps Part/state
|
|
* iPropertyPrimitive Primitive type of the property
|
|
* iPropertyId ID of the property
|
|
* lpValue Raw value (non-NULL terminated)
|
|
* dwValueLen Length of the value
|
|
*
|
|
* RETURNS
|
|
* The property added, or a property previously added with the same IDs
|
|
*/
|
|
static PTHEME_PROPERTY MSSTYLES_AddProperty(PTHEME_PARTSTATE ps, int iPropertyPrimitive, int iPropertyId, LPCWSTR lpValue, DWORD dwValueLen, BOOL isGlobal)
|
|
{
|
|
PTHEME_PROPERTY cur = MSSTYLES_PSFindProperty(ps, iPropertyPrimitive, iPropertyId);
|
|
/* Should duplicate properties overwrite the original, or be ignored? */
|
|
if(cur) return cur;
|
|
|
|
cur = HeapAlloc(GetProcessHeap(), 0, sizeof(THEME_PROPERTY));
|
|
cur->iPrimitiveType = iPropertyPrimitive;
|
|
cur->iPropertyId = iPropertyId;
|
|
cur->lpValue = lpValue;
|
|
cur->dwValueLen = dwValueLen;
|
|
|
|
if(ps->iStateId)
|
|
cur->origin = PO_STATE;
|
|
else if(ps->iPartId)
|
|
cur->origin = PO_PART;
|
|
else if(isGlobal)
|
|
cur->origin = PO_GLOBAL;
|
|
else
|
|
cur->origin = PO_CLASS;
|
|
|
|
cur->next = ps->properties;
|
|
ps->properties = cur;
|
|
return cur;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_AddMetric
|
|
*
|
|
* Add a property to a part/state
|
|
*
|
|
* PARAMS
|
|
* tf Theme file
|
|
* iPropertyPrimitive Primitive type of the property
|
|
* iPropertyId ID of the property
|
|
* lpValue Raw value (non-NULL terminated)
|
|
* dwValueLen Length of the value
|
|
*
|
|
* RETURNS
|
|
* The property added, or a property previously added with the same IDs
|
|
*/
|
|
static PTHEME_PROPERTY MSSTYLES_AddMetric(PTHEME_FILE tf, int iPropertyPrimitive, int iPropertyId, LPCWSTR lpValue, DWORD dwValueLen)
|
|
{
|
|
PTHEME_PROPERTY cur = MSSTYLES_FFindMetric(tf, iPropertyPrimitive, iPropertyId);
|
|
/* Should duplicate properties overwrite the original, or be ignored? */
|
|
if(cur) return cur;
|
|
|
|
cur = HeapAlloc(GetProcessHeap(), 0, sizeof(THEME_PROPERTY));
|
|
cur->iPrimitiveType = iPropertyPrimitive;
|
|
cur->iPropertyId = iPropertyId;
|
|
cur->lpValue = lpValue;
|
|
cur->dwValueLen = dwValueLen;
|
|
|
|
cur->origin = PO_GLOBAL;
|
|
|
|
cur->next = tf->metrics;
|
|
tf->metrics = cur;
|
|
return cur;
|
|
}
|
|
|
|
/* Color-related state for theme ini parsing */
|
|
struct PARSECOLORSTATE
|
|
{
|
|
int colorCount;
|
|
int colorElements[TMT_LASTCOLOR-TMT_FIRSTCOLOR+1];
|
|
COLORREF colorRgb[TMT_LASTCOLOR-TMT_FIRSTCOLOR+1];
|
|
int captionColors;
|
|
};
|
|
|
|
static inline void parse_init_color (struct PARSECOLORSTATE* state)
|
|
{
|
|
memset (state, 0, sizeof (*state));
|
|
}
|
|
|
|
static BOOL parse_handle_color_property (struct PARSECOLORSTATE* state,
|
|
int iPropertyId, LPCWSTR lpValue,
|
|
DWORD dwValueLen)
|
|
{
|
|
int r,g,b;
|
|
LPCWSTR lpValueEnd = lpValue + dwValueLen;
|
|
if(MSSTYLES_GetNextInteger(lpValue, lpValueEnd, &lpValue, &r) &&
|
|
MSSTYLES_GetNextInteger(lpValue, lpValueEnd, &lpValue, &g) &&
|
|
MSSTYLES_GetNextInteger(lpValue, lpValueEnd, &lpValue, &b)) {
|
|
state->colorElements[state->colorCount] = iPropertyId - TMT_FIRSTCOLOR;
|
|
state->colorRgb[state->colorCount++] = RGB(r,g,b);
|
|
switch (iPropertyId)
|
|
{
|
|
case TMT_ACTIVECAPTION:
|
|
state->captionColors |= 0x1;
|
|
break;
|
|
case TMT_INACTIVECAPTION:
|
|
state->captionColors |= 0x2;
|
|
break;
|
|
case TMT_GRADIENTACTIVECAPTION:
|
|
state->captionColors |= 0x4;
|
|
break;
|
|
case TMT_GRADIENTINACTIVECAPTION:
|
|
state->captionColors |= 0x8;
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static void parse_apply_color (struct PARSECOLORSTATE* state)
|
|
{
|
|
if (state->colorCount > 0)
|
|
SetSysColors(state->colorCount, state->colorElements, state->colorRgb);
|
|
if (state->captionColors == 0xf)
|
|
SystemParametersInfoW (SPI_SETGRADIENTCAPTIONS, 0, (PVOID)TRUE, 0);
|
|
}
|
|
|
|
/* Non-client-metrics-related state for theme ini parsing */
|
|
struct PARSENONCLIENTSTATE
|
|
{
|
|
NONCLIENTMETRICSW metrics;
|
|
BOOL metricsDirty;
|
|
LOGFONTW iconTitleFont;
|
|
};
|
|
|
|
static inline void parse_init_nonclient (struct PARSENONCLIENTSTATE* state)
|
|
{
|
|
memset (state, 0, sizeof (*state));
|
|
state->metrics.cbSize = sizeof (NONCLIENTMETRICSW);
|
|
SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, sizeof (NONCLIENTMETRICSW),
|
|
&state->metrics, 0);
|
|
SystemParametersInfoW (SPI_GETICONTITLELOGFONT, sizeof (LOGFONTW),
|
|
&state->iconTitleFont, 0);
|
|
}
|
|
|
|
static BOOL parse_handle_nonclient_font (struct PARSENONCLIENTSTATE* state,
|
|
int iPropertyId, LPCWSTR lpValue,
|
|
DWORD dwValueLen)
|
|
{
|
|
LOGFONTW font;
|
|
|
|
memset (&font, 0, sizeof (font));
|
|
if (SUCCEEDED (MSSTYLES_GetFont (lpValue, lpValue + dwValueLen, &lpValue,
|
|
&font)))
|
|
{
|
|
switch (iPropertyId)
|
|
{
|
|
case TMT_CAPTIONFONT:
|
|
state->metrics.lfCaptionFont = font;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_SMALLCAPTIONFONT:
|
|
state->metrics.lfSmCaptionFont = font;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_MENUFONT:
|
|
state->metrics.lfMenuFont = font;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_STATUSFONT:
|
|
state->metrics.lfStatusFont = font;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_MSGBOXFONT:
|
|
state->metrics.lfMessageFont = font;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_ICONTITLEFONT:
|
|
state->iconTitleFont = font;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
static BOOL parse_handle_nonclient_size (struct PARSENONCLIENTSTATE* state,
|
|
int iPropertyId, LPCWSTR lpValue,
|
|
DWORD dwValueLen)
|
|
{
|
|
int size;
|
|
LPCWSTR lpValueEnd = lpValue + dwValueLen;
|
|
if(MSSTYLES_GetNextInteger(lpValue, lpValueEnd, &lpValue, &size)) {
|
|
switch (iPropertyId)
|
|
{
|
|
case TMT_SIZINGBORDERWIDTH:
|
|
state->metrics.iBorderWidth = size;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_SCROLLBARWIDTH:
|
|
state->metrics.iScrollWidth = size;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_SCROLLBARHEIGHT:
|
|
state->metrics.iScrollHeight = size;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_CAPTIONBARWIDTH:
|
|
state->metrics.iCaptionWidth = size;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_CAPTIONBARHEIGHT:
|
|
state->metrics.iCaptionHeight = size;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_SMCAPTIONBARWIDTH:
|
|
state->metrics.iSmCaptionWidth = size;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_SMCAPTIONBARHEIGHT:
|
|
state->metrics.iSmCaptionHeight = size;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_MENUBARWIDTH:
|
|
state->metrics.iMenuWidth = size;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
case TMT_MENUBARHEIGHT:
|
|
state->metrics.iMenuHeight = size;
|
|
state->metricsDirty = TRUE;
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
static void parse_apply_nonclient (struct PARSENONCLIENTSTATE* state)
|
|
{
|
|
if (state->metricsDirty)
|
|
{
|
|
SystemParametersInfoW (SPI_SETNONCLIENTMETRICS, sizeof (state->metrics),
|
|
&state->metrics, 0);
|
|
SystemParametersInfoW (SPI_SETICONTITLELOGFONT, sizeof (state->iconTitleFont),
|
|
&state->iconTitleFont, 0);
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_ParseThemeIni
|
|
*
|
|
* Parse the theme ini for the selected color/style
|
|
*
|
|
* PARAMS
|
|
* tf Theme to parse
|
|
*/
|
|
static void MSSTYLES_ParseThemeIni(PTHEME_FILE tf, BOOL setMetrics)
|
|
{
|
|
static const WCHAR szSysMetrics[] = {'S','y','s','M','e','t','r','i','c','s','\0'};
|
|
static const WCHAR szGlobals[] = {'g','l','o','b','a','l','s','\0'};
|
|
PTHEME_CLASS cls;
|
|
PTHEME_CLASS globals;
|
|
PTHEME_PARTSTATE ps;
|
|
PUXINI_FILE ini;
|
|
WCHAR szAppName[MAX_THEME_APP_NAME];
|
|
WCHAR szClassName[MAX_THEME_CLASS_NAME];
|
|
WCHAR szPropertyName[MAX_THEME_VALUE_NAME];
|
|
int iPartId;
|
|
int iStateId;
|
|
int iPropertyPrimitive;
|
|
int iPropertyId;
|
|
DWORD dwLen;
|
|
LPCWSTR lpName;
|
|
DWORD dwValueLen;
|
|
LPCWSTR lpValue;
|
|
|
|
ini = MSSTYLES_GetActiveThemeIni(tf);
|
|
|
|
while((lpName=UXINI_GetNextSection(ini, &dwLen))) {
|
|
if(CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lpName, dwLen, szSysMetrics, -1) == CSTR_EQUAL) {
|
|
struct PARSECOLORSTATE colorState;
|
|
struct PARSENONCLIENTSTATE nonClientState;
|
|
|
|
parse_init_color (&colorState);
|
|
parse_init_nonclient (&nonClientState);
|
|
|
|
while((lpName=UXINI_GetNextValue(ini, &dwLen, &lpValue, &dwValueLen))) {
|
|
lstrcpynW(szPropertyName, lpName, min(dwLen+1, sizeof(szPropertyName)/sizeof(szPropertyName[0])));
|
|
if(MSSTYLES_LookupProperty(szPropertyName, &iPropertyPrimitive, &iPropertyId)) {
|
|
if(iPropertyId >= TMT_FIRSTCOLOR && iPropertyId <= TMT_LASTCOLOR) {
|
|
if (!parse_handle_color_property (&colorState, iPropertyId,
|
|
lpValue, dwValueLen))
|
|
FIXME("Invalid color value for %s\n",
|
|
debugstr_w(szPropertyName));
|
|
}
|
|
else if (setMetrics && (iPropertyId == TMT_FLATMENUS)) {
|
|
BOOL flatMenus = (*lpValue == 'T') || (*lpValue == 't');
|
|
SystemParametersInfoW (SPI_SETFLATMENU, 0, (PVOID)(INT_PTR)flatMenus, 0);
|
|
}
|
|
else if ((iPropertyId >= TMT_FIRSTFONT)
|
|
&& (iPropertyId <= TMT_LASTFONT))
|
|
{
|
|
if (!parse_handle_nonclient_font (&nonClientState,
|
|
iPropertyId, lpValue, dwValueLen))
|
|
FIXME("Invalid font value for %s\n",
|
|
debugstr_w(szPropertyName));
|
|
}
|
|
else if ((iPropertyId >= TMT_FIRSTSIZE)
|
|
&& (iPropertyId <= TMT_LASTSIZE))
|
|
{
|
|
if (!parse_handle_nonclient_size (&nonClientState,
|
|
iPropertyId, lpValue, dwValueLen))
|
|
FIXME("Invalid size value for %s\n",
|
|
debugstr_w(szPropertyName));
|
|
}
|
|
/* Catch all metrics, including colors */
|
|
MSSTYLES_AddMetric(tf, iPropertyPrimitive, iPropertyId, lpValue, dwValueLen);
|
|
}
|
|
else {
|
|
TRACE("Unknown system metric %s\n", debugstr_w(szPropertyName));
|
|
}
|
|
}
|
|
if (setMetrics)
|
|
{
|
|
parse_apply_color (&colorState);
|
|
parse_apply_nonclient (&nonClientState);
|
|
}
|
|
continue;
|
|
}
|
|
if(MSSTYLES_ParseIniSectionName(lpName, dwLen, szAppName, szClassName, &iPartId, &iStateId)) {
|
|
BOOL isGlobal = FALSE;
|
|
if(!lstrcmpiW(szClassName, szGlobals)) {
|
|
isGlobal = TRUE;
|
|
}
|
|
cls = MSSTYLES_AddClass(tf, szAppName, szClassName);
|
|
ps = MSSTYLES_AddPartState(cls, iPartId, iStateId);
|
|
|
|
while((lpName=UXINI_GetNextValue(ini, &dwLen, &lpValue, &dwValueLen))) {
|
|
lstrcpynW(szPropertyName, lpName, min(dwLen+1, sizeof(szPropertyName)/sizeof(szPropertyName[0])));
|
|
if(MSSTYLES_LookupProperty(szPropertyName, &iPropertyPrimitive, &iPropertyId)) {
|
|
MSSTYLES_AddProperty(ps, iPropertyPrimitive, iPropertyId, lpValue, dwValueLen, isGlobal);
|
|
}
|
|
else {
|
|
TRACE("Unknown property %s\n", debugstr_w(szPropertyName));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* App/Class combos override values defined by the base class, map these overrides */
|
|
globals = MSSTYLES_FindClass(tf, NULL, szGlobals);
|
|
cls = tf->classes;
|
|
while(cls) {
|
|
if(*cls->szAppName) {
|
|
cls->overrides = MSSTYLES_FindClass(tf, NULL, cls->szClassName);
|
|
if(!cls->overrides) {
|
|
TRACE("No overrides found for app %s class %s\n", debugstr_w(cls->szAppName), debugstr_w(cls->szClassName));
|
|
}
|
|
else {
|
|
cls->overrides = globals;
|
|
}
|
|
}
|
|
else {
|
|
/* Everything overrides globals..except globals */
|
|
if(cls != globals) cls->overrides = globals;
|
|
}
|
|
cls = cls->next;
|
|
}
|
|
UXINI_CloseINI(ini);
|
|
|
|
if(!tf->classes) {
|
|
ERR("Failed to parse theme ini\n");
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_OpenThemeClass
|
|
*
|
|
* Open a theme class, uses the current active theme
|
|
*
|
|
* PARAMS
|
|
* pszAppName Application name, for theme styles specific
|
|
* to a particular application
|
|
* pszClassList List of requested classes, semicolon delimited
|
|
*/
|
|
PTHEME_CLASS MSSTYLES_OpenThemeClass(LPCWSTR pszAppName, LPCWSTR pszClassList)
|
|
{
|
|
PTHEME_CLASS cls = NULL;
|
|
WCHAR szClassName[MAX_THEME_CLASS_NAME];
|
|
LPCWSTR start;
|
|
LPCWSTR end;
|
|
DWORD len;
|
|
|
|
if(!tfActiveTheme) {
|
|
TRACE("there is no active theme\n");
|
|
return NULL;
|
|
}
|
|
if(!tfActiveTheme->classes) {
|
|
return NULL;
|
|
}
|
|
|
|
start = pszClassList;
|
|
while((end = strchrW(start, ';'))) {
|
|
len = end-start;
|
|
lstrcpynW(szClassName, start, min(len+1, sizeof(szClassName)/sizeof(szClassName[0])));
|
|
start = end+1;
|
|
cls = MSSTYLES_FindClass(tfActiveTheme, pszAppName, szClassName);
|
|
if(cls) break;
|
|
}
|
|
if(!cls && *start) {
|
|
lstrcpynW(szClassName, start, sizeof(szClassName)/sizeof(szClassName[0]));
|
|
cls = MSSTYLES_FindClass(tfActiveTheme, pszAppName, szClassName);
|
|
}
|
|
if(cls) {
|
|
TRACE("Opened app %s, class %s from list %s\n", debugstr_w(cls->szAppName), debugstr_w(cls->szClassName), debugstr_w(pszClassList));
|
|
cls->tf = tfActiveTheme;
|
|
cls->tf->dwRefCount++;
|
|
}
|
|
return cls;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_CloseThemeClass
|
|
*
|
|
* Close a theme class
|
|
*
|
|
* PARAMS
|
|
* tc Theme class to close
|
|
*
|
|
* NOTES
|
|
* The MSSTYLES_CloseThemeFile decreases the refcount of the owning
|
|
* theme file and cleans it up, if needed.
|
|
*/
|
|
HRESULT MSSTYLES_CloseThemeClass(PTHEME_CLASS tc)
|
|
{
|
|
MSSTYLES_CloseThemeFile (tc->tf);
|
|
return S_OK;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_FindProperty
|
|
*
|
|
* Locate a property in a class. Part and state IDs will be used as a
|
|
* preference, but may be ignored in the attempt to locate the property.
|
|
* Will scan the entire chain of overrides for this class.
|
|
*/
|
|
PTHEME_PROPERTY MSSTYLES_FindProperty(PTHEME_CLASS tc, int iPartId, int iStateId, int iPropertyPrimitive, int iPropertyId)
|
|
{
|
|
PTHEME_CLASS next = tc;
|
|
PTHEME_PARTSTATE ps;
|
|
PTHEME_PROPERTY tp;
|
|
|
|
TRACE("(%p, %d, %d, %d)\n", tc, iPartId, iStateId, iPropertyId);
|
|
/* Try and find an exact match on part & state */
|
|
while(next && (ps = MSSTYLES_FindPartState(next, iPartId, iStateId, &next))) {
|
|
if((tp = MSSTYLES_PSFindProperty(ps, iPropertyPrimitive, iPropertyId))) {
|
|
return tp;
|
|
}
|
|
}
|
|
/* If that fails, and we didn't already try it, search for just part */
|
|
if(iStateId != 0)
|
|
iStateId = 0;
|
|
/* As a last ditch attempt..go for just class */
|
|
else if(iPartId != 0)
|
|
iPartId = 0;
|
|
else
|
|
return NULL;
|
|
|
|
if((tp = MSSTYLES_FindProperty(tc, iPartId, iStateId, iPropertyPrimitive, iPropertyId)))
|
|
return tp;
|
|
return NULL;
|
|
}
|
|
|
|
/* Prepare a bitmap to be used for alpha blending */
|
|
static BOOL prepare_alpha (HBITMAP bmp, BOOL* hasAlpha)
|
|
{
|
|
DIBSECTION dib;
|
|
int n;
|
|
BYTE* p;
|
|
|
|
*hasAlpha = FALSE;
|
|
|
|
if (!bmp || GetObjectW( bmp, sizeof(dib), &dib ) != sizeof(dib))
|
|
return FALSE;
|
|
|
|
if(dib.dsBm.bmBitsPixel != 32)
|
|
/* nothing to do */
|
|
return TRUE;
|
|
|
|
*hasAlpha = TRUE;
|
|
p = dib.dsBm.bmBits;
|
|
n = dib.dsBmih.biHeight * dib.dsBmih.biWidth;
|
|
/* AlphaBlend() wants premultiplied alpha, so do that now */
|
|
while (n-- > 0)
|
|
{
|
|
int a = p[3]+1;
|
|
p[0] = (p[0] * a) >> 8;
|
|
p[1] = (p[1] * a) >> 8;
|
|
p[2] = (p[2] * a) >> 8;
|
|
p += 4;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
HBITMAP MSSTYLES_LoadBitmap (PTHEME_CLASS tc, LPCWSTR lpFilename, BOOL* hasAlpha)
|
|
{
|
|
WCHAR szFile[MAX_PATH];
|
|
LPWSTR tmp;
|
|
PTHEME_IMAGE img;
|
|
lstrcpynW(szFile, lpFilename, sizeof(szFile)/sizeof(szFile[0]));
|
|
tmp = szFile;
|
|
do {
|
|
if(*tmp == '\\') *tmp = '_';
|
|
if(*tmp == '/') *tmp = '_';
|
|
if(*tmp == '.') *tmp = '_';
|
|
} while(*tmp++);
|
|
|
|
/* Try to locate in list of loaded images */
|
|
img = tc->tf->images;
|
|
while (img)
|
|
{
|
|
if (lstrcmpiW (szFile, img->name) == 0)
|
|
{
|
|
TRACE ("found %p %s: %p\n", img, debugstr_w (img->name), img->image);
|
|
*hasAlpha = img->hasAlpha;
|
|
return img->image;
|
|
}
|
|
img = img->next;
|
|
}
|
|
/* Not found? Load from resources */
|
|
img = HeapAlloc (GetProcessHeap(), 0, sizeof (THEME_IMAGE));
|
|
img->image = LoadImageW(tc->hTheme, szFile, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION);
|
|
prepare_alpha (img->image, hasAlpha);
|
|
img->hasAlpha = *hasAlpha;
|
|
/* ...and stow away for later reuse. */
|
|
lstrcpyW (img->name, szFile);
|
|
img->next = tc->tf->images;
|
|
tc->tf->images = img;
|
|
TRACE ("new %p %s: %p\n", img, debugstr_w (img->name), img->image);
|
|
return img->image;
|
|
}
|
|
|
|
static BOOL MSSTYLES_GetNextInteger(LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR *lpValEnd, int *value)
|
|
{
|
|
LPCWSTR cur = lpStringStart;
|
|
int total = 0;
|
|
BOOL gotNeg = FALSE;
|
|
|
|
while(cur < lpStringEnd && (*cur < '0' || *cur > '9' || *cur == '-')) cur++;
|
|
if(cur >= lpStringEnd) {
|
|
return FALSE;
|
|
}
|
|
if(*cur == '-') {
|
|
cur++;
|
|
gotNeg = TRUE;
|
|
}
|
|
while(cur < lpStringEnd && (*cur >= '0' && *cur <= '9')) {
|
|
total = total * 10 + (*cur - '0');
|
|
cur++;
|
|
}
|
|
if(gotNeg) total = -total;
|
|
*value = total;
|
|
if(lpValEnd) *lpValEnd = cur;
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL MSSTYLES_GetNextToken(LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR *lpValEnd, LPWSTR lpBuff, DWORD buffSize) {
|
|
LPCWSTR cur = lpStringStart;
|
|
LPCWSTR start;
|
|
LPCWSTR end;
|
|
|
|
while(cur < lpStringEnd && (isspace(*cur) || *cur == ',')) cur++;
|
|
if(cur >= lpStringEnd) {
|
|
return FALSE;
|
|
}
|
|
start = cur;
|
|
while(cur < lpStringEnd && *cur != ',') cur++;
|
|
end = cur;
|
|
while(isspace(*end)) end--;
|
|
|
|
lstrcpynW(lpBuff, start, min(buffSize, end-start+1));
|
|
|
|
if(lpValEnd) *lpValEnd = cur;
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_GetPropertyBool
|
|
*
|
|
* Retrieve a color value for a property
|
|
*/
|
|
HRESULT MSSTYLES_GetPropertyBool(PTHEME_PROPERTY tp, BOOL *pfVal)
|
|
{
|
|
*pfVal = FALSE;
|
|
if(*tp->lpValue == 't' || *tp->lpValue == 'T')
|
|
*pfVal = TRUE;
|
|
return S_OK;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_GetPropertyColor
|
|
*
|
|
* Retrieve a color value for a property
|
|
*/
|
|
HRESULT MSSTYLES_GetPropertyColor(PTHEME_PROPERTY tp, COLORREF *pColor)
|
|
{
|
|
LPCWSTR lpEnd;
|
|
LPCWSTR lpCur;
|
|
int red, green, blue;
|
|
|
|
lpCur = tp->lpValue;
|
|
lpEnd = tp->lpValue + tp->dwValueLen;
|
|
|
|
if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &red)) {
|
|
TRACE("Could not parse color property\n");
|
|
return E_PROP_ID_UNSUPPORTED;
|
|
}
|
|
if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &green)) {
|
|
TRACE("Could not parse color property\n");
|
|
return E_PROP_ID_UNSUPPORTED;
|
|
}
|
|
if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &blue)) {
|
|
TRACE("Could not parse color property\n");
|
|
return E_PROP_ID_UNSUPPORTED;
|
|
}
|
|
*pColor = RGB(red,green,blue);
|
|
return S_OK;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_GetPropertyColor
|
|
*
|
|
* Retrieve a color value for a property
|
|
*/
|
|
static HRESULT MSSTYLES_GetFont (LPCWSTR lpCur, LPCWSTR lpEnd,
|
|
LPCWSTR *lpValEnd, LOGFONTW* pFont)
|
|
{
|
|
static const WCHAR szBold[] = {'b','o','l','d','\0'};
|
|
static const WCHAR szItalic[] = {'i','t','a','l','i','c','\0'};
|
|
static const WCHAR szUnderline[] = {'u','n','d','e','r','l','i','n','e','\0'};
|
|
static const WCHAR szStrikeOut[] = {'s','t','r','i','k','e','o','u','t','\0'};
|
|
int pointSize;
|
|
WCHAR attr[32];
|
|
|
|
if(!MSSTYLES_GetNextToken(lpCur, lpEnd, &lpCur, pFont->lfFaceName, LF_FACESIZE)) {
|
|
TRACE("Property is there, but failed to get face name\n");
|
|
*lpValEnd = lpCur;
|
|
return E_PROP_ID_UNSUPPORTED;
|
|
}
|
|
if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pointSize)) {
|
|
TRACE("Property is there, but failed to get point size\n");
|
|
*lpValEnd = lpCur;
|
|
return E_PROP_ID_UNSUPPORTED;
|
|
}
|
|
pFont->lfHeight = pointSize;
|
|
pFont->lfWeight = FW_REGULAR;
|
|
pFont->lfCharSet = DEFAULT_CHARSET;
|
|
while(MSSTYLES_GetNextToken(lpCur, lpEnd, &lpCur, attr, sizeof(attr)/sizeof(attr[0]))) {
|
|
if(!lstrcmpiW(szBold, attr)) pFont->lfWeight = FW_BOLD;
|
|
else if(!lstrcmpiW(szItalic, attr)) pFont->lfItalic = TRUE;
|
|
else if(!lstrcmpiW(szUnderline, attr)) pFont->lfUnderline = TRUE;
|
|
else if(!lstrcmpiW(szStrikeOut, attr)) pFont->lfStrikeOut = TRUE;
|
|
}
|
|
*lpValEnd = lpCur;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT MSSTYLES_GetPropertyFont(PTHEME_PROPERTY tp, HDC hdc, LOGFONTW *pFont)
|
|
{
|
|
LPCWSTR lpCur = tp->lpValue;
|
|
LPCWSTR lpEnd = tp->lpValue + tp->dwValueLen;
|
|
HRESULT hr;
|
|
|
|
ZeroMemory(pFont, sizeof(LOGFONTW));
|
|
hr = MSSTYLES_GetFont (lpCur, lpEnd, &lpCur, pFont);
|
|
if (SUCCEEDED (hr))
|
|
pFont->lfHeight = -MulDiv(pFont->lfHeight, GetDeviceCaps(hdc, LOGPIXELSY), 72);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_GetPropertyInt
|
|
*
|
|
* Retrieve an int value for a property
|
|
*/
|
|
HRESULT MSSTYLES_GetPropertyInt(PTHEME_PROPERTY tp, int *piVal)
|
|
{
|
|
if(!MSSTYLES_GetNextInteger(tp->lpValue, (tp->lpValue + tp->dwValueLen), NULL, piVal)) {
|
|
TRACE("Could not parse int property\n");
|
|
return E_PROP_ID_UNSUPPORTED;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_GetPropertyIntList
|
|
*
|
|
* Retrieve an int list value for a property
|
|
*/
|
|
HRESULT MSSTYLES_GetPropertyIntList(PTHEME_PROPERTY tp, INTLIST *pIntList)
|
|
{
|
|
int i;
|
|
LPCWSTR lpCur = tp->lpValue;
|
|
LPCWSTR lpEnd = tp->lpValue + tp->dwValueLen;
|
|
|
|
for(i=0; i < MAX_INTLIST_COUNT; i++) {
|
|
if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pIntList->iValues[i]))
|
|
break;
|
|
}
|
|
pIntList->iValueCount = i;
|
|
return S_OK;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_GetPropertyPosition
|
|
*
|
|
* Retrieve a position value for a property
|
|
*/
|
|
HRESULT MSSTYLES_GetPropertyPosition(PTHEME_PROPERTY tp, POINT *pPoint)
|
|
{
|
|
int x,y;
|
|
LPCWSTR lpCur = tp->lpValue;
|
|
LPCWSTR lpEnd = tp->lpValue + tp->dwValueLen;
|
|
|
|
if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &x)) {
|
|
TRACE("Could not parse position property\n");
|
|
return E_PROP_ID_UNSUPPORTED;
|
|
}
|
|
if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &y)) {
|
|
TRACE("Could not parse position property\n");
|
|
return E_PROP_ID_UNSUPPORTED;
|
|
}
|
|
pPoint->x = x;
|
|
pPoint->y = y;
|
|
return S_OK;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_GetPropertyString
|
|
*
|
|
* Retrieve a string value for a property
|
|
*/
|
|
HRESULT MSSTYLES_GetPropertyString(PTHEME_PROPERTY tp, LPWSTR pszBuff, int cchMaxBuffChars)
|
|
{
|
|
lstrcpynW(pszBuff, tp->lpValue, min(tp->dwValueLen+1, cchMaxBuffChars));
|
|
return S_OK;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_GetPropertyRect
|
|
*
|
|
* Retrieve a rect value for a property
|
|
*/
|
|
HRESULT MSSTYLES_GetPropertyRect(PTHEME_PROPERTY tp, RECT *pRect)
|
|
{
|
|
LPCWSTR lpCur = tp->lpValue;
|
|
LPCWSTR lpEnd = tp->lpValue + tp->dwValueLen;
|
|
|
|
MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pRect->left);
|
|
MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pRect->top);
|
|
MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pRect->right);
|
|
if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pRect->bottom)) {
|
|
TRACE("Could not parse rect property\n");
|
|
return E_PROP_ID_UNSUPPORTED;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MSSTYLES_GetPropertyMargins
|
|
*
|
|
* Retrieve a margins value for a property
|
|
*/
|
|
HRESULT MSSTYLES_GetPropertyMargins(PTHEME_PROPERTY tp, RECT *prc, MARGINS *pMargins)
|
|
{
|
|
LPCWSTR lpCur = tp->lpValue;
|
|
LPCWSTR lpEnd = tp->lpValue + tp->dwValueLen;
|
|
|
|
MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pMargins->cxLeftWidth);
|
|
MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pMargins->cxRightWidth);
|
|
MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pMargins->cyTopHeight);
|
|
if(!MSSTYLES_GetNextInteger(lpCur, lpEnd, &lpCur, &pMargins->cyBottomHeight)) {
|
|
TRACE("Could not parse margins property\n");
|
|
return E_PROP_ID_UNSUPPORTED;
|
|
}
|
|
return S_OK;
|
|
}
|