User-settings class for ATL/WTL projects

I did a few simple updates on the functions for VC++ .NET so that they no longer call deprecated 6.0 CRegKey methods.

appsettings.h

-Dave Marble

Your link is broken, Dave. But I've done the same as follows:

// appsettings.h
//
// Utility class for storing/reading profile values from the Registry
// (C) 2000 Peter Kenyon
//
// You may freely distribute this source code, providing that you do not charge for it
// and that this copyright notice remains intact.
//
// Please report any bugs to Peter@bizinf.co.nz
//
// Edited for VC 7.1 to avoid ATL_DEPRECATED warnings
//

#ifndef _APPSETTINGS_H
#define _APPSETTINGS_H

class CAppSettings
{
public:
	// Must be called once to set the name of the key under HKLM\\Software
	// or HKCU\\Software.
	// Normally this will be of the form "[company name]\\[app name]"
	void SetRegKey(LPCTSTR pszKey)
	{
		m_strRegKeyName = _T("Software\\");
		m_strRegKeyName += pszKey;
	}

	CString GetUserProfileString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszDefault = NULL)
	{
		CString strKey = CatKeyAndSubkeyNames(lpszSection);
		CRegKey key;

		if(key.Open(HKEY_CURRENT_USER, strKey, KEY_READ) == ERROR_SUCCESS)
		{
			DWORD dwcbNeeded = 0;
			if(key.QueryValue(lpszEntry, NULL, NULL, &dwcbNeeded) == ERROR_SUCCESS)
			{
				CString strVal;
				LPTSTR pszVal = strVal.GetBuffer(dwcbNeeded);
				if(key.QueryStringValue(lpszEntry, pszVal, &dwcbNeeded) == ERROR_SUCCESS) {
					strVal.ReleaseBuffer();
					key.Close();
					return strVal;
				}
				else {
					strVal.ReleaseBuffer(0);
				}
			}
		}

		key.Close();
		return CString(lpszDefault);
	}

	CString GetMachineProfileString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszDefault = NULL)
	{
		CString strKey = CatKeyAndSubkeyNames(lpszSection);
		CRegKey key;

		if(key.Open(HKEY_LOCAL_MACHINE, strKey, KEY_READ) == ERROR_SUCCESS)
		{
			DWORD dwcbNeeded = 0;
			if(key.QueryValue(lpszEntry, NULL, NULL, &dwcbNeeded) == ERROR_SUCCESS)
			{
				CString strVal;
				LPTSTR pszVal = strVal.GetBuffer(dwcbNeeded);

				if(key.QueryStringValue(lpszEntry, pszVal, &dwcbNeeded) == ERROR_SUCCESS)
				{
					strVal.ReleaseBuffer();
					key.Close();
					return strVal;
				}
				else
				{
					strVal.ReleaseBuffer(0);
				}
			}
		}

		key.Close();
		return CString(lpszDefault);
	}

	DWORD GetUserProfileDword(LPCTSTR lpszSection, LPCTSTR lpszEntry, DWORD dwDefault = 0)
	{
		CString strKey = CatKeyAndSubkeyNames(lpszSection);
		CRegKey key;

		if(key.Open(HKEY_CURRENT_USER, strKey, KEY_READ) == ERROR_SUCCESS)
		{
			DWORD dwVal;
			if(key.QueryDWORDValue(lpszEntry, dwVal) == ERROR_SUCCESS)
			{
				key.Close();
				return dwVal;
			}
		}

		key.Close();
		return dwDefault;;
	}

	DWORD GetMachineProfileDword(LPCTSTR lpszSection, LPCTSTR lpszEntry, DWORD dwDefault = 0)
	{
		CString strKey = CatKeyAndSubkeyNames(lpszSection);
		CRegKey key;

		if(key.Open(HKEY_LOCAL_MACHINE, strKey, KEY_READ) == ERROR_SUCCESS)
		{
			DWORD dwVal;
			if(key.QueryDWORDValue(lpszEntry, dwVal) == ERROR_SUCCESS)
			{
				key.Close();
				return dwVal;
			}
		}

		key.Close();
		return dwDefault;;
	}

	template <class T> BOOL GetMachineProfileStruct(LPCTSTR lpszSection, LPCTSTR lpszEntry, T& obj)
	{
		CString strKey = CatKeyAndSubkeyNames(lpszSection);
		CRegKey key;

		if(key.Open(HKEY_LOCAL_MACHINE, strKey, KEY_READ) == ERROR_SUCCESS)
		{
			DWORD dwcbSize = sizeof(T);
			if(::RegQueryValueEx(key, lpszEntry, NULL, NULL, (LPBYTE)&obj, &dwcbSize) == ERROR_SUCCESS)
			{
				key.Close();
				return TRUE;
			}
		}

		key.Close();
		return FALSE;
	}

	template <class T> BOOL GetUserProfileStruct(LPCTSTR lpszSection, LPCTSTR lpszEntry, T& obj)
	{
		CString strKey = CatKeyAndSubkeyNames(lpszSection);
		CRegKey key;

		if(key.Open(HKEY_CURRENT_USER, strKey, KEY_READ) == ERROR_SUCCESS)
		{
			DWORD dwcbSize = sizeof(T);
			if(::RegQueryValueEx(key, lpszEntry, NULL, NULL, (LPBYTE)&obj, &dwcbSize) == ERROR_SUCCESS)
			{
				key.Close();
				return TRUE;
			}
		}

		key.Close();
		return FALSE;
	}

	BOOL WriteMachineProfileString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszVal)
	{
		CString strKey = CatKeyAndSubkeyNames(lpszSection);
		CRegKey key;

		if(key.Create(HKEY_LOCAL_MACHINE, strKey, REG_NONE, REG_OPTION_NON_VOLATILE, KEY_WRITE) == ERROR_SUCCESS)
		{
			if(key.SetStringValue(lpszEntry, lpszVal) == ERROR_SUCCESS)
			{
				key.Close();
				return TRUE;
			}
		}

		key.Close();
		return FALSE;
	}

	template <class T> BOOL WriteMachineProfileStruct(LPCTSTR lpszSection, LPCTSTR lpszEntry, T& obj)
	{
		CString strKey = CatKeyAndSubkeyNames(lpszSection);
		CRegKey key;

		if(key.Create(HKEY_LOCAL_MACHINE, strKey, REG_NONE, REG_OPTION_NON_VOLATILE, KEY_WRITE) == ERROR_SUCCESS)
		{
			if(::RegSetValueEx(key, lpszEntry, 0, REG_BINARY, (LPBYTE)&obj, sizeof(T)) == ERROR_SUCCESS)
			{
				key.Close();
				return TRUE;
			}
		}

		key.Close();
		return FALSE;
	}

	template <class T> BOOL WriteUserProfileStruct(LPCTSTR lpszSection, LPCTSTR lpszEntry, T& obj)
	{
		CString strKey = CatKeyAndSubkeyNames(lpszSection);
		CRegKey key;

		if(key.Create(HKEY_CURRENT_USER, strKey, REG_NONE, REG_OPTION_NON_VOLATILE, KEY_WRITE) == ERROR_SUCCESS)
		{
			if(::RegSetValueEx(key, lpszEntry, 0, REG_BINARY, (LPBYTE)&obj, sizeof(T)) == ERROR_SUCCESS)
			{
				key.Close();
				return TRUE;
			}
		}

		key.Close();
		return FALSE;
	}

	BOOL WriteMachineProfileDword(LPCTSTR lpszSection, LPCTSTR lpszEntry, DWORD dwVal)
	{
		CString strKey = CatKeyAndSubkeyNames(lpszSection);
		CRegKey key;

		if(key.Create(HKEY_LOCAL_MACHINE, strKey, REG_NONE, REG_OPTION_NON_VOLATILE, KEY_WRITE) == ERROR_SUCCESS)
		{
			if(key.SetDWORDValue(lpszEntry, dwVal) == ERROR_SUCCESS)
			{
				key.Close();
				return TRUE;
			}
		}

		key.Close();
		return FALSE;
	}

	BOOL WriteUserProfileString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszVal)
	{
		CString strKey = CatKeyAndSubkeyNames(lpszSection);
		CRegKey key;

		if(key.Create(HKEY_CURRENT_USER, strKey, REG_NONE, REG_OPTION_NON_VOLATILE, KEY_WRITE) == ERROR_SUCCESS)
		{
			if(key.SetStringValue(lpszEntry, lpszVal) == ERROR_SUCCESS)
			{
				key.Close();
				return TRUE;
			}
		}

		key.Close();
		return FALSE;
	}

	BOOL WriteUserProfileDword(LPCTSTR lpszSection, LPCTSTR lpszEntry, DWORD dwVal)
	{
		CString strKey = CatKeyAndSubkeyNames(lpszSection);
		CRegKey key;

		if(key.Create(HKEY_CURRENT_USER, strKey, REG_NONE, REG_OPTION_NON_VOLATILE, KEY_WRITE) == ERROR_SUCCESS)
		{
			if(key.SetDWORDValue(lpszEntry, dwVal) == ERROR_SUCCESS)
			{
				key.Close();
				return TRUE;
			}
		}

		key.Close();
		return FALSE;
	}

private:
	CString CatKeyAndSubkeyNames(LPCTSTR lpszSection)
	{
		ATLASSERT(!m_strRegKeyName.IsEmpty());
		CString strKey = m_strRegKeyName;

		if(lpszSection)
		{
			strKey += _T("\\");
			strKey += lpszSection;
		}

		return strKey;
	}

	CString m_strRegKeyName;
};

#endif // _APPSETTINGS_H

Rob

This class works great with MFC as well

well done

Big Grin | :-D

Peter,

Using inheritance in a way you do in C++ means establishing IS-A relationship. This means that your main frame is an app setting. Nedless to say, this is extremely ugly, plus you use multiple inheritance.

Instead you should use HAS-A relationship and bind it to your application, not your main frame.

I had this neat idea about implementing registry values based on templates (if anyone cares to play with it?). Compliant with ATL/WTL philosophy one could have
something like:

UserSetting<int> iNrOfOpenedWindows;
MachineSetting<string> sCustomerIdForAutoUpdate;

Then one could say iNrOfOpenedWindows=1 (treat it as integer) and iNrOfOpenedWindows.Save("MyCompanyName/MyAppKey"). You could provide different Save/Load pre-implementations for some known types using C++ traits...

Advantage: when using generic names such as UserSetting, MachineSetting you're not coupling the implementation and Microsoft's technologies.

Another possible implementation would be using streams. Something like

regstream rs;
rs << value("keyname","valuename",10);

or using manipulators:

rs >> setregpos("keyname","valuename") >> i >> j;

Tomaz

Tomaz Stih, B.Sc.SE

What I meant was:

UserSetting<int> iNrOfOpenedWindows;

and

MachineSetting<std::string> sCustomerId...

Tomaz

Thanks for your comments.

> Using inheritance in a way you do in C++ means establishing IS-A relationship. This
> means that your main frame is an app setting. Nedless to say, this is extremely ugly,
> plus you use multiple inheritance.
>
> Instead you should use HAS-A relationship and bind it to your application, not your main
> frame.

Actually it doesn't matter what class you bind it to, it doesn't have to be the main frame at all. You could derive a class from CComModule and associate it with that.

You don't need to use multi inheritance, although if you are using ATL/WTL most of your classes will be multi inheritance anyway. You can make CAppSettings a member of a containing class. So you can use whatever methodology you prefer.

> I had this neat idea about implementing registry values based on templates (if anyone
> cares to play with it?). Compliant with ATL/WTL philosophy one could have something like:
>
> UserSetting<int> iNrOfOpenedWindows;
> MachineSetting<std::string> sCustomerIdForAutoUpdate;
>
> Then one could say iNrOfOpenedWindows=1 (treat it as integer) and
> iNrOfOpenedWindows.Save("MyCompanyName/MyAppKey"). You could provide different Save/Load
> pre-implementations for some known types using C++ traits...

I like this idea. Why not have something like this:

UserSetting<int, _T("MyCompany\\Screen")> iNrOfOpenedWindows

Then put the code to load the value in the constructor and the code to save the value in the destructor. That way the value is loaded when the app starts up and saved when it terminates.

Peter

> I like this idea. Why not have something like this:
> UserSetting<int, _t("mycompany\\screen")=""> iNrOfOpenedWindows
> Then put the code to load the value in the constructor and the
> code to save the value in the destructor. That way the
> value is loaded when the app starts up and saved when it terminates.

And it would work for stack variables just as well (as stack is
unwinded the vars are saved). But I'd prefer to assign key at
runtime (templates are expanded at compile time). Something like:

MachineSetting<int> iNrOfOpenedWindows(_T("path\to\value"));

Same thing, but you can provide variable for the key.

Note however, that in real life automatic Load and Save are not always desireable. Imagine a classic configuration dialog (i.e. Control Panel applet). It comes in the form of a wizard or a property sheet. You store values to member variables. If the user cancels the wizard or the sheet then values should not be written to the registry.

For this case I would have a base class Setting with Load and Save virtuals. Then derive MachineSetting : public Setting.
A class called SettingsManager would have methods Append(Setting &) and SaveAll(). You append your settings to the setting manager and on Ok or Apply call sm.SaveAll().

If you hate to loose automation you could have traits for AutoSave
and AutoLoad and for ManualSave and ManualLoad. Default to manual...

How'bout someone implementing our wonderful design now that we did "all the work" Cool | :cool:

.

Tomaz

Tomaz Stih, B.Sc.SE

// RegSetting.h
// By providing template arguments, your setting will autoload and save into the
// registry path you provide. If you use the default arguments, you must explicitly call
// SetRegKey(), Load() and Save().

template <class ValueType, LPCTSTR pszKeyName = NULL, bool bMachineSetting = false, bool bAutoSaveLoad = false>
class CRegSetting
{
public:

// Initializes private member variables based on the template arguments.
CRegSetting(const ValueType = ValueType());
virtual ~CRegSetting();

// Changes autosave behaviour at runtime
void SetAutoSaveLoad(bool bAutoSaveLoad = true);

// Assigns the registry key path at runtime
void SetRegKey(LPCTSTR pszKeyName, bool bMachineSetting = false);
BOOL Save();
BOOL Load();

// Provides access to the underlying value type
inline operator = (const ValueType value) { m_Value = value; }
inline operator ValueType () { return m_Value; }

private:
bool m_bAutoSaveLoad;
bool m_bMachineSetting;
CString m_strKeyName;
ValueType m_Value;
} ;

class CMachineSettingManual<class ValueType>
: CRegSetting<ValueType> ;
class CMachineSettingAuto<class ValueType, LPCTSTR pszKeyName>
: CRegSetting<ValueType, pszKeyName, true, true> ;

// etc....

Now all we need is an implementation. Maybe when I have some free time... Cool | :cool:

Peter

Good effort but bit archaic, me thinks?
Here is my recipe:
1. Use WSH features for registry manipulation
2. Code in JavaScript (nice & pure OO)
3. Package into WSC and make available to everything everywhere and anytime. And any language.
Speed is not crucial here, resuability and encapsulation are. Use COM

A good idea, but that not the purpose which I designed it for. All it is meant to do is make access to the Registry easier for ATL/WTL projects. Having a separate COM object to do this would be overkill

Huh? Are you for real? 1. WSH - Disabled on many machines because of its recent infamy regarding the Melissa/I Love You viruses. Secondly, "make available to everything everywhere and anytime. And any language" - Last time I checked, WSH stood for WINDOWS scripting host... Where's the Mac/Linux port of WSH? 2. JavaScript - An interpreted language that is probably 100 times slower than C++...

Dude, your "recipe" is a recipe for disaster... You don't do much professional coding, do you? I'd love to see the faces of my clients if you proposed a WSH/JavaScript solution to them... Heh heh

I forgot to mention that the class uses WTL's CString. So you will need to install the WTL headers if you want to use it as part of an ATL project.

User-settings class for ATL/WTL projects

User-settings class for ATL/WTL Projects

Functions

License

Comments and Discussions