Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 07:53:07 +00:00
Code Issues Projects Releases Packages Wiki Activity

[uxtheme]

Browse source 
- Do not apply non client metrics defined in the theme, while applying the theme. This is now done by desk.cpl
- Implement OpenThemeDataFromFile to let desk.cpl open a theme file and query the metrics stored in the theme file
- Make use of the HTHEME hTheme parameter in GetThemeSysBool, GetThemeSysColor, GetThemeSysFont, GetThemeSysInt, GetThemeSysSize and GetThemeSysString

svn path=/trunk/; revision=58831
This commit is contained in:
Giannis Adamopoulos 2013-04-22 16:46:43 +00:00
parent 8fe345032d
commit 3c3d41fec8
4 changed files with 164 additions and 334 deletions
Download patch file Download diff file Expand all files Collapse all files

30
reactos/dll/win32/uxtheme/metric.c
View file

@ -35,7 +35,9 @@ BOOL WINAPI GetThemeSysBool(HTHEME hTheme, int iBoolID)
TRACE("(%p, %d)\n", hTheme, iBoolID); TRACE("(%p, %d)\n", hTheme, iBoolID);
SetLastError(0); SetLastError(0);
if(hTheme) { if(hTheme) {
if((tp = MSSTYLES_FindMetric(TMT_BOOL, iBoolID))) { PTHEME_CLASS ptc = (PTHEME_CLASS) hTheme;
if((tp = MSSTYLES_FindMetric(ptc->tf, TMT_BOOL, iBoolID))) {
hr = MSSTYLES_GetPropertyBool(tp, &ret); hr = MSSTYLES_GetPropertyBool(tp, &ret);
if(SUCCEEDED(hr)) if(SUCCEEDED(hr))
return ret; return ret;
@ -62,10 +64,15 @@ COLORREF WINAPI GetThemeSysColor(HTHEME hTheme, int iColorID)
HRESULT hr; HRESULT hr;
PTHEME_PROPERTY tp; PTHEME_PROPERTY tp;
// TODO: Check if this is correct
if ( iColorID >= 0 && iColorID < 32)
iColorID += TMT_SCROLLBAR;
TRACE("(%p, %d)\n", hTheme, iColorID); TRACE("(%p, %d)\n", hTheme, iColorID);
SetLastError(0); SetLastError(0);
if(hTheme) { if(hTheme) {
if((tp = MSSTYLES_FindMetric(TMT_COLOR, iColorID))) { PTHEME_CLASS ptc = (PTHEME_CLASS) hTheme;
if((tp = MSSTYLES_FindMetric(ptc->tf, TMT_COLOR, iColorID))) {
COLORREF color; COLORREF color;
hr = MSSTYLES_GetPropertyColor(tp, &color); hr = MSSTYLES_GetPropertyColor(tp, &color);
if(SUCCEEDED(hr)) if(SUCCEEDED(hr))
@ -96,7 +103,8 @@ HRESULT WINAPI GetThemeSysFont(HTHEME hTheme, int iFontID, LOGFONTW *plf)
TRACE("(%p, %d)\n", hTheme, iFontID); TRACE("(%p, %d)\n", hTheme, iFontID);
if(hTheme) { if(hTheme) {
if((tp = MSSTYLES_FindMetric(TMT_FONT, iFontID))) { PTHEME_CLASS ptc = (PTHEME_CLASS) hTheme;
if((tp = MSSTYLES_FindMetric(ptc->tf, TMT_FONT, iFontID))) {
HDC hdc = GetDC(NULL); HDC hdc = GetDC(NULL);
hr = MSSTYLES_GetPropertyFont(tp, hdc, plf); hr = MSSTYLES_GetPropertyFont(tp, hdc, plf);
ReleaseDC(NULL, hdc); ReleaseDC(NULL, hdc);
@ -134,6 +142,7 @@ HRESULT WINAPI GetThemeSysFont(HTHEME hTheme, int iFontID, LOGFONTW *plf)
HRESULT WINAPI GetThemeSysInt(HTHEME hTheme, int iIntID, int *piValue) HRESULT WINAPI GetThemeSysInt(HTHEME hTheme, int iIntID, int *piValue)
{ {
PTHEME_PROPERTY tp; PTHEME_PROPERTY tp;
PTHEME_CLASS ptc = (PTHEME_CLASS) hTheme;
TRACE("(%p, %d)\n", hTheme, iIntID); TRACE("(%p, %d)\n", hTheme, iIntID);
if(!hTheme) if(!hTheme)
@ -142,7 +151,7 @@ HRESULT WINAPI GetThemeSysInt(HTHEME hTheme, int iIntID, int *piValue)
WARN("Unknown IntID: %d\n", iIntID); WARN("Unknown IntID: %d\n", iIntID);
return STG_E_INVALIDPARAMETER; return STG_E_INVALIDPARAMETER;
} }
if((tp = MSSTYLES_FindMetric(TMT_INT, iIntID))) if((tp = MSSTYLES_FindMetric(ptc->tf , TMT_INT, iIntID)))
return MSSTYLES_GetPropertyInt(tp, piValue); return MSSTYLES_GetPropertyInt(tp, piValue);
return E_PROP_ID_UNSUPPORTED; return E_PROP_ID_UNSUPPORTED;
} }
@ -168,6 +177,8 @@ int WINAPI GetThemeSysSize(HTHEME hTheme, int iSizeID)
}; };
if(hTheme) { if(hTheme) {
PTHEME_CLASS ptc = (PTHEME_CLASS) hTheme;
for(i=0; i<sizeof(metricMap)/sizeof(metricMap[0]); i+=2) { for(i=0; i<sizeof(metricMap)/sizeof(metricMap[0]); i+=2) {
if(metricMap[i] == iSizeID) { if(metricMap[i] == iSizeID) {
id = metricMap[i+1]; id = metricMap[i+1];
@ -176,7 +187,7 @@ int WINAPI GetThemeSysSize(HTHEME hTheme, int iSizeID)
} }
SetLastError(0); SetLastError(0);
if(id != -1) { if(id != -1) {
if((tp = MSSTYLES_FindMetric(TMT_SIZE, id))) { if((tp = MSSTYLES_FindMetric(ptc->tf, TMT_SIZE, id))) {
if(SUCCEEDED(MSSTYLES_GetPropertyInt(tp, &i))) { if(SUCCEEDED(MSSTYLES_GetPropertyInt(tp, &i))) {
return i; return i;
} }
@ -188,6 +199,12 @@ int WINAPI GetThemeSysSize(HTHEME hTheme, int iSizeID)
return 0; return 0;
} }
} }
// TODO: Check if this is correct
// In windows for SM_CXFRAME this function returns what seems to be the non client metric iBorderWidth
if (iSizeID == SM_CXFRAME)
return GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXDLGFRAME);
return GetSystemMetrics(iSizeID); return GetSystemMetrics(iSizeID);
} }
@ -198,6 +215,7 @@ HRESULT WINAPI GetThemeSysString(HTHEME hTheme, int iStringID,
LPWSTR pszStringBuff, int cchMaxStringChars) LPWSTR pszStringBuff, int cchMaxStringChars)
{ {
PTHEME_PROPERTY tp; PTHEME_PROPERTY tp;
PTHEME_CLASS ptc = (PTHEME_CLASS) hTheme;
TRACE("(%p, %d)\n", hTheme, iStringID); TRACE("(%p, %d)\n", hTheme, iStringID);
if(!hTheme) if(!hTheme)
@ -206,7 +224,7 @@ HRESULT WINAPI GetThemeSysString(HTHEME hTheme, int iStringID,
WARN("Unknown StringID: %d\n", iStringID); WARN("Unknown StringID: %d\n", iStringID);
return STG_E_INVALIDPARAMETER; return STG_E_INVALIDPARAMETER;
} }
if((tp = MSSTYLES_FindMetric(TMT_STRING, iStringID))) if((tp = MSSTYLES_FindMetric(ptc->tf, TMT_STRING, iStringID)))
return MSSTYLES_GetPropertyString(tp, pszStringBuff, cchMaxStringChars); return MSSTYLES_GetPropertyString(tp, pszStringBuff, cchMaxStringChars);
return E_PROP_ID_UNSUPPORTED; return E_PROP_ID_UNSUPPORTED;
} }

332
reactos/dll/win32/uxtheme/msstyles.c
View file

@ -30,7 +30,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(uxtheme);
static BOOL MSSTYLES_GetNextInteger(LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR *lpValEnd, int *value); 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 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); static HRESULT MSSTYLES_GetFont (LPCWSTR lpStringStart, LPCWSTR lpStringEnd, LPCWSTR *lpValEnd, LOGFONTW* logfont);
extern HINSTANCE hDllInst; extern HINSTANCE hDllInst;
@ -42,8 +41,6 @@ static const WCHAR szThemesIniResource[] = {
't','h','e','m','e','s','_','i','n','i','\0' 't','h','e','m','e','s','_','i','n','i','\0'
}; };
static PTHEME_FILE tfActiveTheme;
/***********************************************************************/ /***********************************************************************/
/********************************************************************** /**********************************************************************
@ -214,21 +211,13 @@ void MSSTYLES_CloseThemeFile(PTHEME_FILE tf)
} }
/*********************************************************************** /***********************************************************************
* MSSTYLES_SetActiveTheme * MSSTYLES_ReferenceTheme
* *
* Set the current active theme * Increase the reference count of the theme file
*/ */
HRESULT MSSTYLES_SetActiveTheme(PTHEME_FILE tf, BOOL setMetrics) HRESULT MSSTYLES_ReferenceTheme(PTHEME_FILE tf)
{ {
if(tfActiveTheme) tf->dwRefCount++;
MSSTYLES_CloseThemeFile(tfActiveTheme);
tfActiveTheme = tf;
if (tfActiveTheme)
{
tfActiveTheme->dwRefCount++;
if(!tfActiveTheme->classes)
MSSTYLES_ParseThemeIni(tfActiveTheme, setMetrics);
}
return S_OK; return S_OK;
} }
@ -545,7 +534,7 @@ static inline PTHEME_PROPERTY MSSTYLES_PSFindProperty(PTHEME_PARTSTATE ps, int i
} }
/*********************************************************************** /***********************************************************************
* MSSTYLES_FFindMetric * MSSTYLES_FindMetric
* *
* Find a metric property for a theme file * Find a metric property for a theme file
* *
@ -557,30 +546,11 @@ static inline PTHEME_PROPERTY MSSTYLES_PSFindProperty(PTHEME_PARTSTATE ps, int i
* RETURNS * RETURNS
* The property found, or NULL * The property found, or NULL
*/ */
static inline PTHEME_PROPERTY MSSTYLES_FFindMetric(PTHEME_FILE tf, int iPropertyPrimitive, int iPropertyId) PTHEME_PROPERTY MSSTYLES_FindMetric(PTHEME_FILE tf, int iPropertyPrimitive, int iPropertyId)
{ {
return MSSTYLES_LFindProperty(tf->metrics, iPropertyPrimitive, 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 * MSSTYLES_AddProperty
* *
@ -639,7 +609,7 @@ static PTHEME_PROPERTY MSSTYLES_AddProperty(PTHEME_PARTSTATE ps, int iPropertyPr
*/ */
static PTHEME_PROPERTY MSSTYLES_AddMetric(PTHEME_FILE tf, int iPropertyPrimitive, int iPropertyId, LPCWSTR lpValue, DWORD dwValueLen) static PTHEME_PROPERTY MSSTYLES_AddMetric(PTHEME_FILE tf, int iPropertyPrimitive, int iPropertyId, LPCWSTR lpValue, DWORD dwValueLen)
{ {
PTHEME_PROPERTY cur = MSSTYLES_FFindMetric(tf, iPropertyPrimitive, iPropertyId); PTHEME_PROPERTY cur = MSSTYLES_FindMetric(tf, iPropertyPrimitive, iPropertyId);
/* Should duplicate properties overwrite the original, or be ignored? */ /* Should duplicate properties overwrite the original, or be ignored? */
if(cur) return cur; if(cur) return cur;
@ -656,185 +626,6 @@ static PTHEME_PROPERTY MSSTYLES_AddMetric(PTHEME_FILE tf, int iPropertyPrimitive
return cur; return cur;
} }
/* Color-related state for theme ini parsing */
struct PARSECOLORSTATE
{
int colorCount;
int colorElements[TMT_LASTCOLOR-TMT_FIRSTCOLOR];
COLORREF colorRgb[TMT_LASTCOLOR-TMT_FIRSTCOLOR];
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 * MSSTYLES_ParseThemeIni
* *
@ -843,7 +634,7 @@ static void parse_apply_nonclient (struct PARSENONCLIENTSTATE* state)
* PARAMS * PARAMS
* tf Theme to parse * tf Theme to parse
*/ */
static void MSSTYLES_ParseThemeIni(PTHEME_FILE tf, BOOL setMetrics) void MSSTYLES_ParseThemeIni(PTHEME_FILE tf)
{ {
static const WCHAR szSysMetrics[] = {'S','y','s','M','e','t','r','i','c','s','\0'}; 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'}; static const WCHAR szGlobals[] = {'g','l','o','b','a','l','s','\0'};
@ -863,73 +654,50 @@ static void MSSTYLES_ParseThemeIni(PTHEME_FILE tf, BOOL setMetrics)
DWORD dwValueLen; DWORD dwValueLen;
LPCWSTR lpValue; LPCWSTR lpValue;
if(tf->classes)
return;
ini = MSSTYLES_GetActiveThemeIni(tf); ini = MSSTYLES_GetActiveThemeIni(tf);
while((lpName=UXINI_GetNextSection(ini, &dwLen))) { while((lpName=UXINI_GetNextSection(ini, &dwLen)))
if(CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lpName, dwLen, szSysMetrics, -1) == CSTR_EQUAL) { {
struct PARSECOLORSTATE colorState; if(CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lpName, dwLen, szSysMetrics, -1) == CSTR_EQUAL)
struct PARSENONCLIENTSTATE nonClientState; {
while((lpName=UXINI_GetNextValue(ini, &dwLen, &lpValue, &dwValueLen)))
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]))); lstrcpynW(szPropertyName, lpName, min(dwLen+1, sizeof(szPropertyName)/sizeof(szPropertyName[0])));
if(MSSTYLES_LookupProperty(szPropertyName, &iPropertyPrimitive, &iPropertyId)) { if(MSSTYLES_LookupProperty(szPropertyName, &iPropertyPrimitive, &iPropertyId))
if(iPropertyId >= TMT_FIRSTCOLOR && iPropertyId <= TMT_LASTCOLOR) { {
if (!parse_handle_color_property (&colorState, iPropertyId, /* Catch all metrics, including colors */
lpValue, dwValueLen)) MSSTYLES_AddMetric(tf, iPropertyPrimitive, 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 { else
{
TRACE("Unknown system metric %s\n", debugstr_w(szPropertyName)); TRACE("Unknown system metric %s\n", debugstr_w(szPropertyName));
} }
} }
if (setMetrics)
{
parse_apply_color (&colorState);
parse_apply_nonclient (&nonClientState);
}
continue; continue;
} }
if(MSSTYLES_ParseIniSectionName(lpName, dwLen, szAppName, szClassName, &iPartId, &iStateId)) {
if(MSSTYLES_ParseIniSectionName(lpName, dwLen, szAppName, szClassName, &iPartId, &iStateId))
{
BOOL isGlobal = FALSE; BOOL isGlobal = FALSE;
if(!lstrcmpiW(szClassName, szGlobals)) { if(!lstrcmpiW(szClassName, szGlobals))
{
isGlobal = TRUE; isGlobal = TRUE;
} }
cls = MSSTYLES_AddClass(tf, szAppName, szClassName); cls = MSSTYLES_AddClass(tf, szAppName, szClassName);
ps = MSSTYLES_AddPartState(cls, iPartId, iStateId); ps = MSSTYLES_AddPartState(cls, iPartId, iStateId);
while((lpName=UXINI_GetNextValue(ini, &dwLen, &lpValue, &dwValueLen))) { while((lpName=UXINI_GetNextValue(ini, &dwLen, &lpValue, &dwValueLen)))
{
lstrcpynW(szPropertyName, lpName, min(dwLen+1, sizeof(szPropertyName)/sizeof(szPropertyName[0]))); lstrcpynW(szPropertyName, lpName, min(dwLen+1, sizeof(szPropertyName)/sizeof(szPropertyName[0])));
if(MSSTYLES_LookupProperty(szPropertyName, &iPropertyPrimitive, &iPropertyId)) { if(MSSTYLES_LookupProperty(szPropertyName, &iPropertyPrimitive, &iPropertyId))
{
MSSTYLES_AddProperty(ps, iPropertyPrimitive, iPropertyId, lpValue, dwValueLen, isGlobal); MSSTYLES_AddProperty(ps, iPropertyPrimitive, iPropertyId, lpValue, dwValueLen, isGlobal);
} }
else { else
{
TRACE("Unknown property %s\n", debugstr_w(szPropertyName)); TRACE("Unknown property %s\n", debugstr_w(szPropertyName));
} }
} }
@ -939,19 +707,25 @@ static void MSSTYLES_ParseThemeIni(PTHEME_FILE tf, BOOL setMetrics)
/* App/Class combos override values defined by the base class, map these overrides */ /* App/Class combos override values defined by the base class, map these overrides */
globals = MSSTYLES_FindClass(tf, NULL, szGlobals); globals = MSSTYLES_FindClass(tf, NULL, szGlobals);
cls = tf->classes; cls = tf->classes;
while(cls) { while(cls)
if(*cls->szAppName) { {
if(*cls->szAppName)
{
cls->overrides = MSSTYLES_FindClass(tf, NULL, cls->szClassName); cls->overrides = MSSTYLES_FindClass(tf, NULL, cls->szClassName);
if(!cls->overrides) { if(!cls->overrides)
{
TRACE("No overrides found for app %s class %s\n", debugstr_w(cls->szAppName), debugstr_w(cls->szClassName)); TRACE("No overrides found for app %s class %s\n", debugstr_w(cls->szAppName), debugstr_w(cls->szClassName));
} }
else { else
{
cls->overrides = globals; cls->overrides = globals;
} }
} }
else { else
{
/* Everything overrides globals..except globals */ /* Everything overrides globals..except globals */
if(cls != globals) cls->overrides = globals; if(cls != globals)
cls->overrides = globals;
} }
cls = cls->next; cls = cls->next;
} }
@ -972,7 +746,7 @@ static void MSSTYLES_ParseThemeIni(PTHEME_FILE tf, BOOL setMetrics)
* to a particular application * to a particular application
* pszClassList List of requested classes, semicolon delimited * pszClassList List of requested classes, semicolon delimited
*/ */
PTHEME_CLASS MSSTYLES_OpenThemeClass(LPCWSTR pszAppName, LPCWSTR pszClassList) PTHEME_CLASS MSSTYLES_OpenThemeClass(PTHEME_FILE tf, LPCWSTR pszAppName, LPCWSTR pszClassList)
{ {
PTHEME_CLASS cls = NULL; PTHEME_CLASS cls = NULL;
WCHAR szClassName[MAX_THEME_CLASS_NAME]; WCHAR szClassName[MAX_THEME_CLASS_NAME];
@ -980,29 +754,25 @@ PTHEME_CLASS MSSTYLES_OpenThemeClass(LPCWSTR pszAppName, LPCWSTR pszClassList)
LPCWSTR end; LPCWSTR end;
DWORD len; DWORD len;
if(!tfActiveTheme) { if(!tf->classes) {
TRACE("there is no active theme\n");
return NULL; return NULL;
} }
if(!tfActiveTheme->classes) {
return NULL;
}
start = pszClassList; start = pszClassList;
while((end = strchrW(start, ';'))) { while((end = strchrW(start, ';'))) {
len = end-start; len = end-start;
lstrcpynW(szClassName, start, min(len+1, sizeof(szClassName)/sizeof(szClassName[0]))); lstrcpynW(szClassName, start, min(len+1, sizeof(szClassName)/sizeof(szClassName[0])));
start = end+1; start = end+1;
cls = MSSTYLES_FindClass(tfActiveTheme, pszAppName, szClassName); cls = MSSTYLES_FindClass(tf, pszAppName, szClassName);
if(cls) break; if(cls) break;
} }
if(!cls && *start) { if(!cls && *start) {
lstrcpynW(szClassName, start, sizeof(szClassName)/sizeof(szClassName[0])); lstrcpynW(szClassName, start, sizeof(szClassName)/sizeof(szClassName[0]));
cls = MSSTYLES_FindClass(tfActiveTheme, pszAppName, szClassName); cls = MSSTYLES_FindClass(tf, pszAppName, szClassName);
} }
if(cls) { if(cls) {
TRACE("Opened app %s, class %s from list %s\n", debugstr_w(cls->szAppName), debugstr_w(cls->szClassName), debugstr_w(pszClassList)); 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 = tf;
cls->tf->dwRefCount++; cls->tf->dwRefCount++;
} }
return cls; return cls;

122
reactos/dll/win32/uxtheme/system.c
View file

@ -51,9 +51,8 @@ static ATOM atSubIdList;
ATOM atWndContrext; ATOM atWndContrext;
static BOOL bThemeActive = FALSE; static BOOL bThemeActive = FALSE;
static WCHAR szCurrentTheme[MAX_PATH];
static WCHAR szCurrentColor[64]; static PTHEME_FILE ActiveThemeFile;
static WCHAR szCurrentSize[64];
/***********************************************************************/ /***********************************************************************/
@ -128,6 +127,19 @@ static DWORD query_reg_path (HKEY hKey, LPCWSTR lpszValue,
return dwRet; return dwRet;
} }
static HRESULT UXTHEME_SetActiveTheme(PTHEME_FILE tf)
{
if(ActiveThemeFile)
MSSTYLES_CloseThemeFile(ActiveThemeFile);
ActiveThemeFile = tf;
if (ActiveThemeFile)
{
MSSTYLES_ReferenceTheme(ActiveThemeFile);
MSSTYLES_ParseThemeIni(ActiveThemeFile);
}
return S_OK;
}
/*********************************************************************** /***********************************************************************
* UXTHEME_LoadTheme * UXTHEME_LoadTheme
* *
@ -140,6 +152,9 @@ void UXTHEME_LoadTheme(BOOL bLoad)
HRESULT hr; HRESULT hr;
WCHAR tmp[10]; WCHAR tmp[10];
PTHEME_FILE pt; PTHEME_FILE pt;
WCHAR szCurrentTheme[MAX_PATH];
WCHAR szCurrentColor[64];
WCHAR szCurrentSize[64];
if(bLoad == TRUE) if(bLoad == TRUE)
{ {
@ -180,23 +195,17 @@ void UXTHEME_LoadTheme(BOOL bLoad)
&pt); &pt);
if(FAILED(hr)) { if(FAILED(hr)) {
bThemeActive = FALSE; bThemeActive = FALSE;
szCurrentTheme[0] = '\0';
szCurrentColor[0] = '\0';
szCurrentSize[0] = '\0';
} }
else { else {
/* Make sure the global color & size match the theme */
lstrcpynW(szCurrentColor, pt->pszSelectedColor, sizeof(szCurrentColor)/sizeof(szCurrentColor[0]));
lstrcpynW(szCurrentSize, pt->pszSelectedSize, sizeof(szCurrentSize)/sizeof(szCurrentSize[0]));
MSSTYLES_SetActiveTheme(pt, FALSE);
TRACE("Theme active: %s %s %s\n", debugstr_w(szCurrentTheme), TRACE("Theme active: %s %s %s\n", debugstr_w(szCurrentTheme),
debugstr_w(szCurrentColor), debugstr_w(szCurrentSize)); debugstr_w(szCurrentColor), debugstr_w(szCurrentSize));
UXTHEME_SetActiveTheme(pt);
MSSTYLES_CloseThemeFile(pt); MSSTYLES_CloseThemeFile(pt);
} }
} }
if(!bThemeActive) { if(!bThemeActive) {
MSSTYLES_SetActiveTheme(NULL, FALSE); UXTHEME_SetActiveTheme(NULL);
TRACE("Theming not active\n"); TRACE("Theming not active\n");
} }
} }
@ -453,32 +462,26 @@ static void UXTHEME_SaveSystemMetrics(void)
} }
/*********************************************************************** /***********************************************************************
* UXTHEME_SetActiveTheme * UXTHEME_ApplyTheme
* *
* Change the current active theme * Change the current active theme
*/ */
static HRESULT UXTHEME_SetActiveTheme(PTHEME_FILE tf) static HRESULT UXTHEME_ApplyTheme(PTHEME_FILE tf)
{ {
HKEY hKey; HKEY hKey;
WCHAR tmp[2]; WCHAR tmp[2];
HRESULT hr; HRESULT hr;
if(tf && !bThemeActive) UXTHEME_BackupSystemMetrics(); if(tf && !bThemeActive) UXTHEME_BackupSystemMetrics();
hr = MSSTYLES_SetActiveTheme(tf, TRUE); hr = UXTHEME_SetActiveTheme(tf);
if(FAILED(hr)) if(FAILED(hr))
return hr; return hr;
if(tf) { if(tf) {
bThemeActive = TRUE; bThemeActive = TRUE;
lstrcpynW(szCurrentTheme, tf->szThemeFile, sizeof(szCurrentTheme)/sizeof(szCurrentTheme[0]));
lstrcpynW(szCurrentColor, tf->pszSelectedColor, sizeof(szCurrentColor)/sizeof(szCurrentColor[0]));
lstrcpynW(szCurrentSize, tf->pszSelectedSize, sizeof(szCurrentSize)/sizeof(szCurrentSize[0]));
} }
else { else {
UXTHEME_RestoreSystemMetrics(); UXTHEME_RestoreSystemMetrics();
bThemeActive = FALSE; bThemeActive = FALSE;
szCurrentTheme[0] = '\0';
szCurrentColor[0] = '\0';
szCurrentSize[0] = '\0';
} }
TRACE("Writing theme config to registry\n"); TRACE("Writing theme config to registry\n");
@ -487,12 +490,12 @@ static HRESULT UXTHEME_SetActiveTheme(PTHEME_FILE tf)
tmp[1] = '\0'; tmp[1] = '\0';
RegSetValueExW(hKey, szThemeActive, 0, REG_SZ, (const BYTE*)tmp, sizeof(WCHAR)*2); RegSetValueExW(hKey, szThemeActive, 0, REG_SZ, (const BYTE*)tmp, sizeof(WCHAR)*2);
if(bThemeActive) { if(bThemeActive) {
RegSetValueExW(hKey, szColorName, 0, REG_SZ, (const BYTE*)szCurrentColor, RegSetValueExW(hKey, szColorName, 0, REG_SZ, (const BYTE*)tf->pszSelectedColor,
(lstrlenW(szCurrentColor)+1)*sizeof(WCHAR)); (lstrlenW(tf->pszSelectedColor)+1)*sizeof(WCHAR));
RegSetValueExW(hKey, szSizeName, 0, REG_SZ, (const BYTE*)szCurrentSize, RegSetValueExW(hKey, szSizeName, 0, REG_SZ, (const BYTE*)tf->pszSelectedSize,
(lstrlenW(szCurrentSize)+1)*sizeof(WCHAR)); (lstrlenW(tf->pszSelectedSize)+1)*sizeof(WCHAR));
RegSetValueExW(hKey, szDllName, 0, REG_SZ, (const BYTE*)szCurrentTheme, RegSetValueExW(hKey, szDllName, 0, REG_SZ, (const BYTE*)tf->szThemeFile,
(lstrlenW(szCurrentTheme)+1)*sizeof(WCHAR)); (lstrlenW(tf->szThemeFile)+1)*sizeof(WCHAR));
} }
else { else {
RegDeleteValueW(hKey, szColorName); RegDeleteValueW(hKey, szColorName);
@ -619,10 +622,8 @@ static LPWSTR UXTHEME_GetWindowProperty(HWND hwnd, ATOM aProp, LPWSTR pszBuffer,
return NULL; return NULL;
} }
/*********************************************************************** static HTHEME WINAPI
* OpenThemeDataEx (UXTHEME.61) OpenThemeDataInternal(PTHEME_FILE ThemeFile, HWND hwnd, LPCWSTR pszClassList, DWORD flags)
*/
HTHEME WINAPI OpenThemeDataEx(HWND hwnd, LPCWSTR pszClassList, DWORD flags)
{ {
WCHAR szAppBuff[256]; WCHAR szAppBuff[256];
WCHAR szClassBuff[256]; WCHAR szClassBuff[256];
@ -649,7 +650,7 @@ HTHEME WINAPI OpenThemeDataEx(HWND hwnd, LPCWSTR pszClassList, DWORD flags)
pszUseClassList = pszClassList; pszUseClassList = pszClassList;
if (pszUseClassList) if (pszUseClassList)
hTheme = MSSTYLES_OpenThemeClass(pszAppName, pszUseClassList); hTheme = MSSTYLES_OpenThemeClass(ThemeFile, pszAppName, pszUseClassList);
} }
if(IsWindow(hwnd)) if(IsWindow(hwnd))
SetPropW(hwnd, (LPCWSTR)MAKEINTATOM(atWindowTheme), hTheme); SetPropW(hwnd, (LPCWSTR)MAKEINTATOM(atWindowTheme), hTheme);
@ -657,9 +658,24 @@ HTHEME WINAPI OpenThemeDataEx(HWND hwnd, LPCWSTR pszClassList, DWORD flags)
return hTheme; return hTheme;
} }
/***********************************************************************
* OpenThemeDataEx (UXTHEME.61)
*/
HTHEME WINAPI OpenThemeDataEx(HWND hwnd, LPCWSTR pszClassList, DWORD flags)
{
return OpenThemeDataInternal(ActiveThemeFile, hwnd, pszClassList, flags);
}
/***********************************************************************
* OpenThemeDataEx (UXTHEME.16)
*/
HTHEME WINAPI OpenThemeDataFromFile(HTHEMEFILE hThemeFile, HWND hwnd, LPCWSTR pszClassList, DWORD flags) HTHEME WINAPI OpenThemeDataFromFile(HTHEMEFILE hThemeFile, HWND hwnd, LPCWSTR pszClassList, DWORD flags)
{ {
return S_OK; PTHEME_FILE ThemeFile = (PTHEME_FILE)hThemeFile;
MSSTYLES_ParseThemeIni(ThemeFile);
return OpenThemeDataInternal(ThemeFile, hwnd, pszClassList, flags);
} }
/*********************************************************************** /***********************************************************************
@ -667,7 +683,7 @@ HTHEME WINAPI OpenThemeDataFromFile(HTHEMEFILE hThemeFile, HWND hwnd, LPCWSTR ps
*/ */
HTHEME WINAPI OpenThemeData(HWND hwnd, LPCWSTR classlist) HTHEME WINAPI OpenThemeData(HWND hwnd, LPCWSTR classlist)
{ {
return OpenThemeDataEx(hwnd, classlist, 0); return OpenThemeDataInternal(ActiveThemeFile, hwnd, classlist, 0);
} }
/*********************************************************************** /***********************************************************************
@ -720,11 +736,35 @@ HRESULT WINAPI GetCurrentThemeName(LPWSTR pszThemeFileName, int dwMaxNameChars,
LPWSTR pszColorBuff, int cchMaxColorChars, LPWSTR pszColorBuff, int cchMaxColorChars,
LPWSTR pszSizeBuff, int cchMaxSizeChars) LPWSTR pszSizeBuff, int cchMaxSizeChars)
{ {
if(!bThemeActive) int cchar;
return E_PROP_ID_UNSUPPORTED;
if(pszThemeFileName) lstrcpynW(pszThemeFileName, szCurrentTheme, dwMaxNameChars); if(ActiveThemeFile == NULL)
if(pszColorBuff) lstrcpynW(pszColorBuff, szCurrentColor, cchMaxColorChars); return E_PROP_ID_UNSUPPORTED;
if(pszSizeBuff) lstrcpynW(pszSizeBuff, szCurrentSize, cchMaxSizeChars);
if(pszThemeFileName)
{
cchar = lstrlenW(ActiveThemeFile->szThemeFile) + 1;
if(cchar > dwMaxNameChars)
return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
lstrcpynW(pszThemeFileName, ActiveThemeFile->szThemeFile, cchar);
}
if(pszColorBuff)
{
cchar = lstrlenW(ActiveThemeFile->pszSelectedColor) + 1;
if(cchar > cchMaxColorChars)
return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
lstrcpynW(pszColorBuff, ActiveThemeFile->pszSelectedColor, cchar);
}
if(pszSizeBuff)
{
cchar = lstrlenW(ActiveThemeFile->pszSelectedSize) + 1;
if(cchar > cchMaxSizeChars)
return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
lstrcpynW(pszSizeBuff, ActiveThemeFile->pszSelectedSize, cchar);
}
return S_OK; return S_OK;
} }
@ -936,7 +976,7 @@ HRESULT WINAPI ApplyTheme(HTHEMEFILE hThemeFile, char *unknown, HWND hWnd)
{ {
HRESULT hr; HRESULT hr;
TRACE("(%p,%s,%p)\n", hThemeFile, unknown, hWnd); TRACE("(%p,%s,%p)\n", hThemeFile, unknown, hWnd);
hr = UXTHEME_SetActiveTheme(hThemeFile); hr = UXTHEME_ApplyTheme(hThemeFile);
UXTHEME_broadcast_msg (NULL, WM_THEMECHANGED); UXTHEME_broadcast_msg (NULL, WM_THEMECHANGED);
return hr; return hr;
} }
@ -1229,6 +1269,6 @@ HRESULT WINAPI DrawNCPreview(HDC hDC,
PNONCLIENTMETRICSW pncMetrics, PNONCLIENTMETRICSW pncMetrics,
COLORREF* lpaRgbValues) COLORREF* lpaRgbValues)
{ {
return S_OK; return E_NOTIMPL;
} }

14
reactos/dll/win32/uxtheme/uxthemep.h
View file

@ -79,18 +79,20 @@ typedef struct _THEME_FILE {
typedef struct _UXINI_FILE *PUXINI_FILE; typedef struct _UXINI_FILE *PUXINI_FILE;
HRESULT MSSTYLES_OpenThemeFile(LPCWSTR lpThemeFile, LPCWSTR pszColorName, LPCWSTR pszSizeName, PTHEME_FILE *tf);
void MSSTYLES_CloseThemeFile(PTHEME_FILE tf);
HRESULT MSSTYLES_SetActiveTheme(PTHEME_FILE tf, BOOL setMetrics);
PTHEME_CLASS MSSTYLES_OpenThemeClass(LPCWSTR pszAppName, LPCWSTR pszClassList);
HRESULT MSSTYLES_CloseThemeClass(PTHEME_CLASS tc);
BOOL MSSTYLES_LookupProperty(LPCWSTR pszPropertyName, int *dwPrimitive, int *dwId); BOOL MSSTYLES_LookupProperty(LPCWSTR pszPropertyName, int *dwPrimitive, int *dwId);
BOOL MSSTYLES_LookupEnum(LPCWSTR pszValueName, int dwEnum, int *dwValue); BOOL MSSTYLES_LookupEnum(LPCWSTR pszValueName, int dwEnum, int *dwValue);
BOOL MSSTYLES_LookupPartState(LPCWSTR pszClass, LPCWSTR pszPart, LPCWSTR pszState, int *iPartId, int *iStateId); BOOL MSSTYLES_LookupPartState(LPCWSTR pszClass, LPCWSTR pszPart, LPCWSTR pszState, int *iPartId, int *iStateId);
HRESULT MSSTYLES_OpenThemeFile(LPCWSTR lpThemeFile, LPCWSTR pszColorName, LPCWSTR pszSizeName, PTHEME_FILE *tf);
HRESULT MSSTYLES_ReferenceTheme(PTHEME_FILE tf);
void MSSTYLES_CloseThemeFile(PTHEME_FILE tf);
void MSSTYLES_ParseThemeIni(PTHEME_FILE tf);
PTHEME_CLASS MSSTYLES_OpenThemeClass(PTHEME_FILE tf, LPCWSTR pszAppName, LPCWSTR pszClassList);
HRESULT MSSTYLES_CloseThemeClass(PTHEME_CLASS tc);
PUXINI_FILE MSSTYLES_GetThemeIni(PTHEME_FILE tf); PUXINI_FILE MSSTYLES_GetThemeIni(PTHEME_FILE tf);
PTHEME_PARTSTATE MSSTYLES_FindPartState(PTHEME_CLASS tc, int iPartId, int iStateId, PTHEME_CLASS *tcNext); PTHEME_PARTSTATE MSSTYLES_FindPartState(PTHEME_CLASS tc, int iPartId, int iStateId, PTHEME_CLASS *tcNext);
PTHEME_PROPERTY MSSTYLES_FindProperty(PTHEME_CLASS tc, int iPartId, int iStateId, int iPropertyPrimitive, int iPropertyId); PTHEME_PROPERTY MSSTYLES_FindProperty(PTHEME_CLASS tc, int iPartId, int iStateId, int iPropertyPrimitive, int iPropertyId);
PTHEME_PROPERTY MSSTYLES_FindMetric(int iPropertyPrimitive, int iPropertyId); PTHEME_PROPERTY MSSTYLES_FindMetric(PTHEME_FILE tf, int iPropertyPrimitive, int iPropertyId);
HBITMAP MSSTYLES_LoadBitmap(PTHEME_CLASS tc, LPCWSTR lpFilename, BOOL* hasAlpha); HBITMAP MSSTYLES_LoadBitmap(PTHEME_CLASS tc, LPCWSTR lpFilename, BOOL* hasAlpha);
HRESULT MSSTYLES_GetPropertyBool(PTHEME_PROPERTY tp, BOOL *pfVal); HRESULT MSSTYLES_GetPropertyBool(PTHEME_PROPERTY tp, BOOL *pfVal);