Settings.cpp

// Classic Shell (c) 2009-2017, Ivo Beltchev
// Open-Shell (c) 2017-2018, The Open-Shell Team
// Confidential information of Ivo Beltchev. Not for disclosure or distribution without prior written consent from the author

#include <stdafx.h>
#include "resource.h"
#include "Settings.h"
#include "SettingsParser.h"
#include "SettingsUIHelper.h"
#include "ResourceHelper.h"
#include "StringUtils.h"
#include "FNVHash.h"
#include <Uxtheme.h>
#include <VSStyle.h>
#include <propkey.h>
#include <htmlhelp.h>
#include <vector>
#include <map>
#include <algorithm>

#ifdef BUILD_SETUP
#define DOC_PATH L""
#else
#define DOC_PATH L"..\\..\\Docs\\Help\\"
#endif

///////////////////////////////////////////////////////////////////////////////

// Read/Write lock for accessing the settings. Can't be acquired recursively. Only the main UI thread (the one displaying the settings UI)
// can write the settings, and because of that it shouldn't lock when reading the settings. The settings editing code shouldn't use
// GetSettings#### at all to avoid deadlocks
static SRWLOCK g_SettingsLock;

#ifdef _DEBUG
static _declspec(thread) int g_LockState; // 0 - none, 1 - read, 2 - write
static _declspec(thread) bool g_bUIThread; // set to true in the thread that edits the settings
#endif

CSettingsLockRead::CSettingsLockRead( void )
{
#ifdef _DEBUG
	Assert(g_LockState==0);
	g_LockState=1;
#endif
	AcquireSRWLockShared(&g_SettingsLock);
}

CSettingsLockRead::~CSettingsLockRead( void )
{
#ifdef _DEBUG
	Assert(g_LockState==1);
	g_LockState=0;
#endif
	ReleaseSRWLockShared(&g_SettingsLock);
}

CSettingsLockWrite::CSettingsLockWrite( void )
{
#ifdef _DEBUG
	Assert(g_LockState==0);
	g_LockState=2;
#endif
	AcquireSRWLockExclusive(&g_SettingsLock);
}

CSettingsLockWrite::~CSettingsLockWrite( void )
{
#ifdef _DEBUG
	Assert(g_LockState==2);
	g_LockState=0;
#endif
	ReleaseSRWLockExclusive(&g_SettingsLock);
}

static bool IsVariantTrue( const CComVariant &var )
{
	return (var.vt==VT_I4 && var.intVal==1);
}

bool CSetting::IsEnabled( void ) const
{
	if (IsLocked())
		return false;

	if (depend)
	{
		const wchar_t *name=depend;
		bool checkEnabled=(*name=='#');
		if (checkEnabled)
			name++;

		int len=Strlen(name);
		int val=0;
		wchar_t operation='~';
		const wchar_t operations[]=L"=~<>";
		for (const wchar_t *c=operations;*c;c++)
		{
			const wchar_t *p=wcschr(name,*c);
			if (p)
			{
				operation=*c;
				len=(int)(p-name);
				val=_wtol(p+1);
				break;
			}
		}
		int style, styleMask;
		GetSettingsStyle(style,styleMask);
		for (const CSetting *pSetting=GetAllSettings();pSetting->name;pSetting++)
		{
			if (_wcsnicmp(pSetting->name,name,len)==0 && pSetting->name[len]==0)
			{
				if ((pSetting->flags&styleMask) && !(pSetting->flags&style))
					return true; // if the master setting is not visible in this style, ignore the dependency
				if (checkEnabled && !pSetting->IsEnabled())
					return false;
				if ((pSetting->type==CSetting::TYPE_BOOL || pSetting->type==CSetting::TYPE_INT) && pSetting->GetValue().vt==VT_I4)
				{
					if (operation=='=' && pSetting->GetValue().intVal!=val)
						return false;
					if (operation=='~' && pSetting->GetValue().intVal==val)
						return false;
					if (operation=='<' && pSetting->GetValue().intVal>=val)
						return false;
					if (operation=='>' && pSetting->GetValue().intVal<=val)
						return false;
				}
				if ((pSetting->type==CSetting::TYPE_STRING || pSetting->type==CSetting::TYPE_BITMAP || pSetting->type==CSetting::TYPE_BITMAP_JPG) && pSetting->GetValue().vt==VT_BSTR)
				{
					if (operation=='~' && *pSetting->GetValue().bstrVal==0)
						return false;
				}
				break;
			}
		}
	}
	return true;
}

bool CSetting::MatchFilter( const wchar_t *filter ) const
{
	if (!*filter) return true;
	CString string=LoadStringEx(nameID);
	StringUpper(string);
	if (wcsstr(string,filter)) return true;
	string=LoadStringEnglish(nameID);
	StringUpper(string);
	if (wcsstr(string,filter)) return true;
	return false;
}

bool CSetting::ShouldLoad( bool bShared ) const
{
	if (type==TYPE_GROUP || type==TYPE_RADIO || pLinkTo)
		return false;
	return (flags&FLAG_SHARED)?bShared:!bShared;
}

bool CSetting::ReadValue( CRegKey &regKey, const wchar_t *valName )
{
	// bool, int, hotkey, color
	if (type==CSetting::TYPE_BOOL || (type==CSetting::TYPE_INT && this[1].type!=CSetting::TYPE_RADIO) || type==CSetting::TYPE_HOTKEY || type==CSetting::TYPE_HOTKEY_ANY || type==CSetting::TYPE_COLOR)
	{
		DWORD val;
		if (regKey.QueryDWORDValue(valName,val)==ERROR_SUCCESS)
		{
			if (type==CSetting::TYPE_BOOL)
				value=CComVariant(val?1:0);
			else
				value=CComVariant((int)val);
			return true;
		}
		return false;
	}

	// radio
	if (type==CSetting::TYPE_INT && this[1].type==CSetting::TYPE_RADIO)
	{
		ULONG len;
		DWORD val;
		if (regKey.QueryStringValue(valName,NULL,&len)==ERROR_SUCCESS)
		{
			CString text;
			regKey.QueryStringValue(valName,text.GetBuffer(len),&len);
			text.ReleaseBuffer(len);
			val=0;
			for (const CSetting *pRadio=this+1;pRadio->type==CSetting::TYPE_RADIO;pRadio++,val++)
			{
				if (_wcsicmp(text,pRadio->name)==0)
				{
					value=CComVariant((int)val);
					return true;
				}
			}
		}
		else if (regKey.QueryDWORDValue(valName,val)==ERROR_SUCCESS)
		{
			value=CComVariant((int)val);
			return true;
		}
		return false;
	}

	// string
	if (type>=CSetting::TYPE_STRING && type<CSetting::TYPE_MULTISTRING)
	{
		ULONG len;
		if (regKey.QueryStringValue(valName,NULL,&len)==ERROR_SUCCESS)
		{
			value.vt=VT_BSTR;
			value.bstrVal=SysAllocStringLen(NULL,len-1);
			regKey.QueryStringValue(valName,value.bstrVal,&len);
			return true;
		}
		return false;
	}

	// multistring
	if (type==CSetting::TYPE_MULTISTRING)
	{
		ULONG len;
		if (regKey.QueryMultiStringValue(valName,NULL,&len)==ERROR_SUCCESS)
		{
			value.vt=VT_BSTR;
			value.bstrVal=SysAllocStringLen(NULL,len-1);
			regKey.QueryMultiStringValue(valName,value.bstrVal,&len);
			for (int i=0;i<(int)len-1;i++)
				if (value.bstrVal[i]==0)
					value.bstrVal[i]='\n';
			return true;
		}
		else if (regKey.QueryStringValue(valName,NULL,&len)==ERROR_SUCCESS)
		{
			value.vt=VT_BSTR;
			value.bstrVal=SysAllocStringLen(NULL,len);
			regKey.QueryStringValue(valName,value.bstrVal,&len);
			if (len>0)
			{
				value.bstrVal[len-1]='\n';
				value.bstrVal[len]=0;
			}
			return true;
		}
		return false;
	}

	Assert(0);
	return false;
}

void CSetting::LoadValue( CRegKey &regSettings, CRegKey &regSettingsUser, CRegKey &regPolicy, CRegKey &regPolicyUser )
{
	if (!(flags&CSetting::FLAG_NODEFAULT))
		flags|=CSetting::FLAG_DEFAULT;
	flags&=~CSetting::FLAG_LOCKED_REG;
	value=defValue;
	flags&=~CSetting::FLAG_FORCED_DEFAULT;

	wchar_t name2[256];

	// load HKLM group policies
	if (regPolicy)
	{
		Sprintf(name2,_countof(name2),L"%s_State",name);
		DWORD val;
		if (regPolicy.QueryDWORDValue(name2,val)==ERROR_SUCCESS && val<=2)
		{
			if (ReadValue(regPolicy,name))
			{
				if (val==0) // locked to value
				{
					flags|=CSetting::FLAG_LOCKED_REG;
					flags&=~CSetting::FLAG_DEFAULT;
					return;
				}
				else if (val==1) // locked to default
				{
					flags|=CSetting::FLAG_LOCKED_REG;
					return;
				}
				else // change default
				{
					defValue=value;
					flags|=CSetting::FLAG_FORCED_DEFAULT;
				}
			}
		}
	}

	if (regSettings)
	{
		// load HKLM settings
		DWORD val;
		if (regSettings.QueryDWORDValue(name,val)==ERROR_SUCCESS && val==0xDEFA)
		{
			flags|=CSetting::FLAG_LOCKED_REG;
			return;
		}
		else if (ReadValue(regSettings,name))
		{
			flags|=CSetting::FLAG_LOCKED_REG;
			flags&=~CSetting::FLAG_DEFAULT;
			return;
		}
		else
		{
			// check if a default value is selected in HKLM
			Sprintf(name2,_countof(name2),L"%s_Default",name);
			if (ReadValue(regSettings,name2))
			{
				defValue=value;
				flags|=CSetting::FLAG_FORCED_DEFAULT;
			}
		}
	}

	// load HKCU group policies
	if (regPolicyUser)
	{
		Sprintf(name2,_countof(name2),L"%s_State",name);
		DWORD val;
		if (regPolicyUser.QueryDWORDValue(name2,val)==ERROR_SUCCESS && val<=2)
		{
			if (ReadValue(regPolicyUser,name))
			{
				if (val==0) // locked to value
				{
					flags|=CSetting::FLAG_LOCKED_REG;
					flags&=~CSetting::FLAG_DEFAULT;
					return;
				}
				else if (val==1) // locked to default
				{
					flags|=CSetting::FLAG_LOCKED_REG;
					return;
				}
				else // change default
				{
					defValue=value;
					flags|=CSetting::FLAG_FORCED_DEFAULT;
				}
			}
		}
	}

	// load HKCU settings
	if (regSettingsUser)
	{
		if (ReadValue(regSettingsUser,name))
		{
			flags&=~CSetting::FLAG_DEFAULT;
			return;
		}
	}
}

class CSettingsManager
{
public:
	CSettingsManager( void );
	~CSettingsManager( void );
	void Init( CSetting *pSettings, TSettingsComponent component, ICustomSettings *pCustom );

	bool GetSettingBool( const wchar_t *name ) const;
	bool GetSettingBool( const wchar_t *name, bool &bDef ) const;
	int GetSettingInt( const wchar_t *name ) const;
	int GetSettingInt( const wchar_t *name, bool &bDef ) const;
	CString GetSettingString( const wchar_t *name ) const;

	void SaveSettings( bool bShared );
	void LoadSettings( bool bShared );
	CString LoadSettingsXml( const wchar_t *fname );
	CString SaveSettingsXml( const wchar_t *fname );
	void ResetSettings( void );

	CSetting *GetSettings( void ) const { return m_pSettings; }
	ICustomSettings *GetCustom( void ) const { return m_pCustom; }
	bool SetSettingsStyle( int style, int mask ) { if (m_SettingsStyle==style && m_SettingsMask==mask) return false; m_SettingsStyle=style; m_SettingsMask=mask; return true; }
	void GetSettingsStyle( int &style, int &mask ) const { style=m_SettingsStyle; mask=m_SettingsMask; }
	HIMAGELIST GetImageList( HWND tree );
	void ResetImageList( void );
	const wchar_t *GetRegPath( void ) const { return m_RegPath; }
	const wchar_t *GetXMLName( void ) const { return m_XMLName; }

private:
	CSetting *m_pSettings;
	ICustomSettings *m_pCustom;
	int m_SettingsStyle;
	int m_SettingsMask;
	HIMAGELIST m_ImageList;
	const wchar_t *m_RegPath;
	const wchar_t *m_RegPathShared;
	const wchar_t *m_GpPath;
	const wchar_t *m_GpPathShared;
	const wchar_t *m_CompName;
	const wchar_t *m_XMLName;
};

static CSettingsManager g_SettingsManager;

CSettingsManager::CSettingsManager( void )
{
	m_pSettings=NULL;
	m_pCustom=NULL;
	m_SettingsStyle=m_SettingsMask=0;
	m_ImageList=NULL;
	m_RegPath=m_RegPathShared=m_GpPath=m_GpPathShared=m_CompName=m_XMLName=NULL;
}

static void GetRegPaths( TSettingsComponent component, const wchar_t *&regPath, const wchar_t *&gpPath )
{
	switch (component)
	{
		case COMPONENT_EXPLORER:
			regPath=L"Software\\OpenShell\\ClassicExplorer";
			gpPath=L"Software\\Policies\\OpenShell\\ClassicExplorer";
			break;
		case COMPONENT_MENU:
			regPath=L"Software\\OpenShell\\StartMenu";
			gpPath=L"Software\\Policies\\OpenShell\\StartMenu";
			break;
		case COMPONENT_IE:
			regPath=L"Software\\OpenShell\\ClassicIE";
			gpPath=L"Software\\Policies\\OpenShell\\ClassicIE";
			break;
		case COMPONENT_UPDATE:
			regPath=L"";
			gpPath=L"";
			break;
		case COMPONENT_SHARED:
			regPath=L"Software\\OpenShell\\OpenShell";
			gpPath=L"Software\\Policies\\OpenShell\\OpenShell";
			break;
	}
}

void CSettingsManager::Init( CSetting *pSettings, TSettingsComponent component, ICustomSettings *pCustom )
{
	GetRegPaths(component,m_RegPath,m_GpPath);
	GetRegPaths(COMPONENT_SHARED,m_RegPathShared,m_GpPathShared);
	switch (component)
	{
		case COMPONENT_EXPLORER:
			m_CompName=L"Explorer";
			m_XMLName=L"Explorer Settings.xml";
			break;
		case COMPONENT_MENU:
			m_CompName=L"StartMenu";
			m_XMLName=L"Menu Settings.xml";
			break;
		case COMPONENT_IE:
			m_CompName=L"IE";
			m_XMLName=L"IE Settings.xml";
			break;
		case COMPONENT_UPDATE:
			m_CompName=L"";
			m_XMLName=L"";
			break;
	}
	
	m_pSettings=pSettings;
	m_pCustom=pCustom;
	m_SettingsStyle=m_SettingsMask=0;
	InitializeSRWLock(&g_SettingsLock);
	CSettingsLockWrite lock;
	for (CSetting *pSetting=m_pSettings;pSetting->name;pSetting++)
	{
		if (pSetting->type<0) continue;
#ifdef _DEBUG
		if (pSetting->type==CSetting::TYPE_BOOL)
		{
			Assert(pSetting->defValue.vt==VT_I4 && (pSetting->defValue.intVal==0 || pSetting->defValue.intVal==1));
		}
		else if (pSetting->type==CSetting::TYPE_INT || pSetting->type==CSetting::TYPE_HOTKEY  || pSetting->type==CSetting::TYPE_HOTKEY_ANY || pSetting->type==CSetting::TYPE_COLOR)
		{
			Assert(pSetting->defValue.vt==VT_I4);
		}
		else if (pSetting->type>=CSetting::TYPE_STRING)
		{
			Assert(pSetting->defValue.vt==VT_BSTR);
		}
#endif
		pSetting->value=pSetting->defValue;
		if (!(pSetting->flags&CSetting::FLAG_NODEFAULT))
			pSetting->flags|=CSetting::FLAG_DEFAULT;
	}
	LoadSettings(false);
	LoadSettings(true);
	UpdateSettings();
	m_ImageList=NULL;
}

CSettingsManager::~CSettingsManager( void )
{
	ResetImageList();
}

bool CSettingsManager::GetSettingBool( const wchar_t *name ) const
{
	for (const CSetting *pSetting=m_pSettings;pSetting->name;pSetting++)
	{
		if (pSetting->type==CSetting::TYPE_BOOL && _wcsicmp(pSetting->name,name)==0)
		{
			Assert(!pSetting->pLinkTo);
			CSettingsLockRead lock;
			return IsVariantTrue(pSetting->value);
		}
	}
	Assert(0);
	return false;
}

bool CSettingsManager::GetSettingBool( const wchar_t *name, bool &bDef ) const
{
	for (const CSetting *pSetting=m_pSettings;pSetting->name;pSetting++)
	{
		if (pSetting->type==CSetting::TYPE_BOOL && _wcsicmp(pSetting->name,name)==0)
		{
			Assert(!pSetting->pLinkTo);
			CSettingsLockRead lock;
			bDef=pSetting->IsDefault() && !pSetting->IsForcedDefault();
			return IsVariantTrue(pSetting->value);
		}
	}
	Assert(0);
	bDef=false;
	return 0;
}

int CSettingsManager::GetSettingInt( const wchar_t *name ) const
{
	for (const CSetting *pSetting=m_pSettings;pSetting->name;pSetting++)
	{
		if ((pSetting->type==CSetting::TYPE_INT || pSetting->type==CSetting::TYPE_HOTKEY || pSetting->type==CSetting::TYPE_HOTKEY_ANY || pSetting->type==CSetting::TYPE_COLOR) && _wcsicmp(pSetting->name,name)==0)
		{
			Assert(!pSetting->pLinkTo);
			CSettingsLockRead lock;
			Assert(pSetting->value.vt==VT_I4);
			return pSetting->value.intVal;
		}
	}
	Assert(0);
	return 0;
}

int CSettingsManager::GetSettingInt( const wchar_t *name, bool &bDef ) const
{
	for (const CSetting *pSetting=m_pSettings;pSetting->name;pSetting++)
	{
		if ((pSetting->type==CSetting::TYPE_INT || pSetting->type==CSetting::TYPE_HOTKEY || pSetting->type==CSetting::TYPE_HOTKEY_ANY || pSetting->type==CSetting::TYPE_COLOR) && _wcsicmp(pSetting->name,name)==0)
		{
			Assert(!pSetting->pLinkTo);
			CSettingsLockRead lock;
			Assert(pSetting->value.vt==VT_I4);
			bDef=pSetting->IsDefault() && !pSetting->IsForcedDefault();
			return pSetting->value.intVal;
		}
	}
	Assert(0);
	bDef=false;
	return 0;
}

CString CSettingsManager::GetSettingString( const wchar_t *name ) const
{
	for (const CSetting *pSetting=m_pSettings;pSetting->name;pSetting++)
	{
		if (pSetting->type>=CSetting::TYPE_STRING && _wcsicmp(pSetting->name,name)==0)
		{
			Assert(!pSetting->pLinkTo);
			CSettingsLockRead lock;
			Assert(pSetting->value.vt==VT_BSTR);
			return pSetting->value.bstrVal;
		}
	}
	Assert(0);
	return CString();
}

static bool OpenSettingsKeys( const wchar_t *regPath, const wchar_t *gpPath, CRegKey &regSettings, CRegKey &regSettingsUser, CRegKey &regPolicy, CRegKey &regPolicyUser )
{
	bool bUpgrade=false;
	if (*regPath)
	{
		regSettings.Open(HKEY_LOCAL_MACHINE,regPath,KEY_READ|KEY_WOW64_64KEY);

		wchar_t regPathNew[_MAX_PATH];
		Sprintf(regPathNew,_countof(regPathNew),L"%s\\Settings",regPath);
		if (regSettingsUser.Open(HKEY_CURRENT_USER,regPathNew,KEY_READ|KEY_WOW64_64KEY)!=ERROR_SUCCESS)
		{
			if (regSettingsUser.Open(HKEY_CURRENT_USER,regPath,KEY_READ|KEY_WOW64_64KEY)==ERROR_SUCCESS)
				bUpgrade=true;
		}
	}

	regPolicy.Open(HKEY_LOCAL_MACHINE,gpPath,KEY_READ|KEY_WOW64_64KEY);
	regPolicyUser.Open(HKEY_CURRENT_USER,gpPath,KEY_READ|KEY_WOW64_64KEY);
	return bUpgrade;
}

void CSettingsManager::LoadSettings( bool bShared )
{
	Assert(g_LockState==2);

	// load settings from registry
	CRegKey regSettings, regSettingsUser, regPolicy, regPolicyUser;
	bool bUpgrade=OpenSettingsKeys(bShared?m_RegPathShared:m_RegPath, bShared?m_GpPathShared:m_GpPath, regSettings, regSettingsUser, regPolicy, regPolicyUser);

	for (CSetting *pSetting=m_pSettings;pSetting->name;pSetting++)
	{
		if (pSetting->ShouldLoad(bShared))
			pSetting->LoadValue(regSettings,regSettingsUser,regPolicy,regPolicyUser);
	}
	if (bUpgrade)
		UpgradeSettings(bShared);
}

void CSettingsManager::SaveSettings( bool bShared )
{
	// doesn't need to acquire the lock because it can only run from the UI editing code
	Assert(g_bUIThread);

	const wchar_t *regPath=bShared?m_RegPathShared:m_RegPath;
	if (!*regPath) return;
	wchar_t regPathNew[_MAX_PATH];
	Sprintf(regPathNew,_countof(regPathNew),L"%s\\Settings",regPath);

	// save non-default to HKCU
	CRegKey regSettings;
	if (regSettings.Open(HKEY_CURRENT_USER,regPathNew)!=ERROR_SUCCESS)
		regSettings.Create(HKEY_CURRENT_USER,regPathNew);

	if (!bShared)
	{
		DWORD version=GetVersionEx(g_Instance);
		regSettings.SetDWORDValue(L"Version",version);
	}
	for (const CSetting *pSetting=m_pSettings;pSetting->name;pSetting++)
	{
		if (pSetting->type==CSetting::TYPE_GROUP || pSetting->type==CSetting::TYPE_RADIO || pSetting->pLinkTo)
			continue;
		if (pSetting->flags&(CSetting::FLAG_LOCKED_REG|CSetting::FLAG_NOSAVE))
			continue;
		if (pSetting->flags&CSetting::FLAG_SHARED)
		{
			if (!bShared) continue;
		}
		else
		{
			if (bShared) continue;
		}
		if (pSetting->flags&CSetting::FLAG_DEFAULT)
		{
			regSettings.DeleteValue(pSetting->name);
			continue;
		}
		if (pSetting->type==CSetting::TYPE_BOOL || (pSetting->type==CSetting::TYPE_INT && pSetting[1].type!=CSetting::TYPE_RADIO) || pSetting->type==CSetting::TYPE_HOTKEY || pSetting->type==CSetting::TYPE_HOTKEY_ANY || pSetting->type==CSetting::TYPE_COLOR)
		{
			DWORD val=0;
			if (pSetting->value.vt==VT_I4)
				val=pSetting->value.intVal;
			regSettings.SetDWORDValue(pSetting->name,val);
		}
		if (pSetting->type==CSetting::TYPE_INT && pSetting[1].type==CSetting::TYPE_RADIO)
		{
			DWORD val=0;
			if (pSetting->value.vt==VT_I4)
				val=pSetting->value.intVal;
			for (const CSetting *pRadio=pSetting+1;pRadio->type==CSetting::TYPE_RADIO;pRadio++,val--)
			{
				if (val==0)
				{
					regSettings.SetStringValue(pSetting->name,pRadio->name);
					break;
				}
			}
		}
		if (pSetting->type==CSetting::TYPE_MULTISTRING)
		{
			if (pSetting->value.vt==VT_BSTR)
			{
				int len=Strlen(pSetting->value.bstrVal);
				for (int i=0;i<len;i++)
					if (pSetting->value.bstrVal[i]=='\n')
						pSetting->value.bstrVal[i]=0;
				regSettings.SetMultiStringValue(pSetting->name,pSetting->value.bstrVal);
				for (int i=0;i<len;i++)
					if (pSetting->value.bstrVal[i]==0)
						pSetting->value.bstrVal[i]='\n';
			}
			else
				regSettings.SetMultiStringValue(pSetting->name,L"\0");
		}
		else if (pSetting->type>=CSetting::TYPE_STRING)
		{
			if (pSetting->value.vt==VT_BSTR)
				regSettings.SetStringValue(pSetting->name,pSetting->value.bstrVal);
			else
				regSettings.SetStringValue(pSetting->name,L"");
		}
	}
}

static CComBSTR g_bstrValue(L"value");
static CComBSTR g_bstrTab(L"\n\t");

CString CSettingsManager::LoadSettingsXml( const wchar_t *fname )
{
	CSettingsLockWrite lock;
	CComPtr<IXMLDOMDocument> pDoc;
	if (FAILED(pDoc.CoCreateInstance(L"Msxml2.FreeThreadedDOMDocument")))
		return L"Failed to initialize XML parser";
	pDoc->put_async(VARIANT_FALSE);
	VARIANT_BOOL loaded;
	if (pDoc->load(CComVariant(fname),&loaded)!=S_OK || loaded!=VARIANT_TRUE)
	{
		CComPtr<IXMLDOMParseError> pError;
		pDoc->get_parseError(&pError);
		CComBSTR reason;
		if (pError && SUCCEEDED(pError->get_reason(&reason)))
		{
			return CString(L"XML parsing error: ")+reason;
		}
		return CString(L"XML parsing error");
	}

	CComPtr<IXMLDOMNode> node;
	HRESULT res=pDoc->selectSingleNode(CComBSTR(L"Settings"),&node);
	if (res!=S_OK)
		return CString(L"XML parsing error: The tag 'Settings' is missing.");

	DWORD ver=0;
	{
		CComVariant value;
		CComQIPtr<IXMLDOMElement> element(node);
		if (!element || element->getAttribute(CComBSTR(L"component"),&value)!=S_OK || value.vt!=VT_BSTR)
			return CString(L"XML parsing error: The tag 'Settings' is missing the 'component' attribute.");
		if (_wcsicmp(value.bstrVal,m_CompName)!=0)
		{
			CString error;
			error.Format(L"XML parsing error: This settings file is intended for another component '%s'.",value.bstrVal);
			return error;
		}

		value.Clear();
		if (element && element->getAttribute(CComBSTR(L"version"),&value)==S_OK && value.vt==VT_BSTR)
		{
			wchar_t token[10];
			const wchar_t *str=GetToken(value.bstrVal,token,_countof(token),L".");
			ver=(_wtol(token)&0xFF)<<24;
			str=GetToken(str,token,_countof(token),L".");
			ver|=(_wtol(token)&0xFF)<<16;
			ver|=_wtol(str)&0xFFFF;
		}
	}

	ResetSettings();
	CComPtr<IXMLDOMNode> child;
	node->get_firstChild(&child);
	while (child)
	{
		CComBSTR name;
		child->get_nodeName(&name);

		for (CSetting *pSetting=g_SettingsManager.GetSettings();pSetting->name;pSetting++)
		{
			if (pSetting->type==CSetting::TYPE_GROUP || pSetting->type==CSetting::TYPE_RADIO || pSetting->pLinkTo)
				continue;
			if (pSetting->type>=0 && _wcsicmp(pSetting->name,name)==0)
			{
				if (pSetting->flags&(CSetting::FLAG_LOCKED_REG|CSetting::FLAG_SHARED))
					break;
				if (pSetting->type==CSetting::TYPE_MULTISTRING)
				{
					// load Lines
					CComPtr<IXMLDOMNode> child2;
					child->get_firstChild(&child2);
					std::vector<wchar_t> string;
					while (child2)
					{
						CComBSTR text;
						if (child2->get_text(&text)==S_OK)
						{
							int len=(int)text.Length();
							int pos=(int)string.size();
							string.resize(pos+len+1);
							memcpy(&string[pos],(const wchar_t*)text,len*2);
							string[pos+len]='\n';
						}
						CComPtr<IXMLDOMNode> next;
						child2->get_nextSibling(&next);
						child2=next;
					}
					string.push_back(0);
					pSetting->value=CComVariant(&string[0]);
					pSetting->flags&=~CSetting::FLAG_DEFAULT;
				}
				else
				{
					CComQIPtr<IXMLDOMElement> element(child);
					if (element)
					{
						CComVariant value;
						if (element->getAttribute(g_bstrValue,&value)==S_OK && value.vt==VT_BSTR)
						{
							if (pSetting->type>=CSetting::TYPE_STRING)
							{
								pSetting->value=value;
								pSetting->flags&=~CSetting::FLAG_DEFAULT;
							}
							else if (pSetting->type==CSetting::TYPE_BOOL || (pSetting->type==CSetting::TYPE_INT && pSetting[1].type!=CSetting::TYPE_RADIO) || pSetting->type==CSetting::TYPE_HOTKEY || pSetting->type==CSetting::TYPE_HOTKEY_ANY || pSetting->type==CSetting::TYPE_COLOR)
							{
								int val=_wtol(value.bstrVal);
								if (pSetting->type==CSetting::TYPE_BOOL)
									pSetting->value=CComVariant(val?1:0);
								else
									pSetting->value=CComVariant(val);
								pSetting->flags&=~CSetting::FLAG_DEFAULT;
							}
							else if (pSetting->type==CSetting::TYPE_INT && pSetting[1].type==CSetting::TYPE_RADIO)
							{
								int val=0;
								for (CSetting *pRadio=pSetting+1;pRadio->type==CSetting::TYPE_RADIO;pRadio++,val++)
								{
									if (_wcsicmp(pRadio->name,value.bstrVal)==0)
									{
										pSetting->value=CComVariant(val);
										pSetting->flags&=~CSetting::FLAG_DEFAULT;
										break;
									}
								}
							}
						}
					}
				}
			}
		}

		CComPtr<IXMLDOMNode> next;
		if (child->get_nextSibling(&next)!=S_OK)
			break;
		child=next;
	}
	if (ver<0x03090000)
		UpgradeSettings(false);
	UpdateSettings();
	return CString();
}

static void SaveSettingValue( IXMLDOMDocument *pDoc, IXMLDOMNode *pParent, const wchar_t *name, const CComVariant &value )
{
	CComPtr<IXMLDOMElement> setting;
	pDoc->createElement(CComBSTR(name),&setting);
	setting->setAttribute(g_bstrValue,value);
	CComPtr<IXMLDOMText> text;
	CComPtr<IXMLDOMNode> nu;
	pDoc->createTextNode(g_bstrTab,&text);
	pParent->appendChild(text,&nu);
	nu=NULL;
	pParent->appendChild(setting,&nu);
}

CString CSettingsManager::SaveSettingsXml( const wchar_t *fname )
{
	// doesn't need to acquire the lock because it can only run from the UI editing code
	Assert(g_bUIThread);

	CComPtr<IXMLDOMDocument> pDoc;
	HRESULT res=pDoc.CoCreateInstance(L"Msxml2.FreeThreadedDOMDocument");
	if (FAILED(res))
		return L"Failed to initialize XML parser";

	CComPtr<IXMLDOMElement> pRoot;
	pDoc->createElement(CComBSTR(L"Settings"),&pRoot);
	CComPtr<IXMLDOMProcessingInstruction> pi;
	if (SUCCEEDED(pDoc->createProcessingInstruction(CComBSTR(L"xml"),CComBSTR(L"version=\"1.0\""),&pi)))
	{
		CComPtr<IXMLDOMNode> nu;
		pDoc->appendChild(pi,&nu);
	}

	{
		CComPtr<IXMLDOMNode> nu;
		pDoc->appendChild(pRoot,&nu);
	}

	pRoot->setAttribute(CComBSTR(L"component"),CComVariant(m_CompName));

	wchar_t version[100];
	DWORD ver=GetVersionEx(g_Instance);
	Sprintf(version,_countof(version),L"%d.%d.%d",ver>>24,(ver>>16)&0xFF,ver&0xFFFF);
	pRoot->setAttribute(CComBSTR(L"version"),CComVariant(version));

	for (const CSetting *pSetting=m_pSettings;pSetting->name;pSetting++)
	{
		if (pSetting->type==CSetting::TYPE_GROUP || pSetting->type==CSetting::TYPE_RADIO || pSetting->pLinkTo)
			continue;
		if (pSetting->flags&(CSetting::FLAG_LOCKED_REG|CSetting::FLAG_NOSAVE|CSetting::FLAG_DEFAULT|CSetting::FLAG_SHARED))
			continue;
		if (pSetting->type==CSetting::TYPE_MULTISTRING)
		{
			CComPtr<IXMLDOMElement> setting;
			pDoc->createElement(CComBSTR(pSetting->name),&setting);
			CComPtr<IXMLDOMText> text;
			CComPtr<IXMLDOMNode> nu;
			pDoc->createTextNode(g_bstrTab,&text);
			pRoot->appendChild(text,&nu);
			nu=NULL;
			pRoot->appendChild(setting,&nu);
			CComBSTR tabs(L"\n\t\t");
			CComBSTR name(L"Line");
			if (pSetting->value.vt==VT_BSTR)
			{
				for (const wchar_t *str=pSetting->value.bstrVal;*str;)
				{
					int len;
					const wchar_t *end=wcschr(str,'\n');
					if (end)
						len=(int)(end-str);
					else
						len=Strlen(str);
					CComPtr<IXMLDOMElement> line;
					pDoc->createElement(name,&line);
					line->put_text(CComBSTR(len,str));
					nu=NULL;
					text=NULL;
					pDoc->createTextNode(tabs,&text);
					setting->appendChild(text,&nu);
					nu=NULL;
					setting->appendChild(line,&nu);
					if (!end) break;
					str=end+1;
				}
			}
			nu=NULL;
			text=NULL;
			pDoc->createTextNode(g_bstrTab,&text);
			setting->appendChild(text,&nu);
			continue;
		}
		else if (pSetting->type==CSetting::TYPE_BOOL || (pSetting->type==CSetting::TYPE_INT && pSetting[1].type!=CSetting::TYPE_RADIO) || pSetting->type>=CSetting::TYPE_HOTKEY || pSetting->type>=CSetting::TYPE_HOTKEY_ANY || pSetting->type>=CSetting::TYPE_STRING)
		{
			SaveSettingValue(pDoc,pRoot,pSetting->name,pSetting->value);
		}
		else if (pSetting->type==CSetting::TYPE_INT && pSetting[1].type==CSetting::TYPE_RADIO)
		{
			DWORD val=0;
			if (pSetting->value.vt==VT_I4)
				val=pSetting->value.intVal;
			for (const CSetting *pRadio=pSetting+1;pRadio->type==CSetting::TYPE_RADIO;pRadio++,val--)
			{
				if (val==0)
				{
					SaveSettingValue(pDoc,pRoot,pSetting->name,CComVariant(pRadio->name));
					break;
				}
			}
		}
	}
	CComPtr<IXMLDOMText> text;
	CComPtr<IXMLDOMNode> nu;
	pDoc->createTextNode(CComBSTR(L"\n"),&text);
	pRoot->appendChild(text,&nu);
	if (FAILED(pDoc->save(CComVariant(fname))))
		return CString(L"Failed to save XML file ")+fname;
	return CString();
}

void CSettingsManager::ResetSettings( void )
{
	Assert(g_LockState==2); // must be locked for writing
	for (CSetting *pSetting=m_pSettings;pSetting->name;pSetting++)
	{
		if (pSetting->type==CSetting::TYPE_GROUP || pSetting->type==CSetting::TYPE_RADIO || pSetting->pLinkTo)
			continue;
		if (pSetting->flags&(CSetting::FLAG_LOCKED_REG|CSetting::FLAG_NORESET))
			continue;
		if (!(pSetting->flags&CSetting::FLAG_NODEFAULT))
			pSetting->flags|=CSetting::FLAG_DEFAULT;
		pSetting->value=pSetting->defValue;
	}
}

HIMAGELIST CSettingsManager::GetImageList( HWND tree )
{
	if (m_ImageList) return m_ImageList;
	HTHEME theme=OpenThemeData(tree,L"button");
	HDC hdc=CreateCompatibleDC(NULL);
	int iconSize=(TreeView_GetItemHeight(tree)<32)?16:32;
	int checkSize=16;
	if (theme)
	{
		SIZE val={16,16};
		if (GetThemePartSize(theme,hdc,BP_RADIOBUTTON,RBS_UNCHECKEDNORMAL,NULL,TS_DRAW,&val)==S_OK)
			checkSize=val.cx;
	}
	int imageSize=iconSize>checkSize?iconSize:checkSize;
	int iconOffset=(imageSize-iconSize)/2;
	int checkOffset=(imageSize-checkSize)/2;
	m_ImageList=ImageList_Create(imageSize,imageSize,ILC_COLOR32|ILC_MASK|((GetWindowLong(tree,GWL_EXSTYLE)&WS_EX_LAYOUTRTL)?ILC_MIRROR:0),0,23);