A Registry Class A Registry Library

Home Back To Tips Page

This represents a handy set of classes I built to ease the pain of dealing with the Registry. In addition to a set of high-level classes, defined in RegVars.h, there is a separate library, used by the RegVars module, Registry.h. This includes the download link for the complete source for all four files. The rest of this document describes the interface.

• Overview
•     The Registry Classes
•         RegistryString
•         RegistryInt
•         RegistryInt64
•         RegistryGUID
•         RegistryFont
•         RegistryWindowPlacement
•         RegistryDWordArray
•     The Registry Library
• Class Descriptions
•     RegistryInt
•     RegistryString
• Library Descriptions
•     [Get/Set]RegistryString
•     [Get/Set]RegistryInt
•     [Get/Set]RegistryInt64
•     [Get/Set]RegistryGUID
•     [Get/Set]RegistryFont
•     [Get/Set]RegistryWindowPlacement
•     [Get/Set]RegistryDWordArray
•     DeleteRegistry[Key/Value]
•     [Get/Find]RegistryKey
•     EnumRegistry[Keys/Values]
•     GetKeyPath
•     [Create/Open]Key

Overview

Using the Registry can be inconvenient. You have to learn all the Registry APIs, learn how to create keys, and then discover that you have to create the keys recursively. A real pain.

I created these classes and library to make it easy to do simple tasks with the Registry. It requires that you defined several strings in the String Table of the module that contains it, the most important one being

IDS_PROGRAM_ROOT  "Software\\YourCompanyName\\YourProductName"

All accesses to the Registry via this library will be relative to this key.

The Registry Classes           

For most simple cases, such as integers or strings, you can use the Registry classes RegistryInt, RegistryInt64 RegistryString, RegistryGUID, RegistryWindowPlacement, RegistryFont,  and RegistryDWordArray.

To use these, you simply declare a String Table entry with the desired access key, which itself may contain \ characters for sub-paths. For example, a simple value could stored using a simple string. First, create in the STRINGTABLE a variable with the desired name.

IDS_REGISTRY_COUNT  "Count"

and then declare a variable of the form

RegistryInt count(IDS_REGISTRY_COUNT);

and to load it you write

count.load(defaultvalue); // argument optional, 0 assumed

You can then access the value, which is of type int, by using

count.value

If you want to store the value in the Registry, set count.value to the value you want to store, and do

count.store();

and the value is stored in the Registry. If the steps of the path do not exist, they will be created.

The corresponding string type is RegistryString and the .value member is a CString.

RegistryString s(IDS_REGISTRY_NAME);
s.load();; // defaults to ""

will load a string value from the Registry. 

To use a structured value, you can just use the \ in the path name. For example,

IDS_REGISTRY_COLOR_RED    "Color\Red"
IDS_REGISTTRY_COLOR_GREEN "Color\Green"
IDS_REGISTRY_COLOR_BLUE   "Color\Blue"

To save the color information for the application, you could write something like

void SaveColor(COLORREF c)
   {
     RegistryInt red(IDS_REGISTRY_COLOR_RED);
     red.value = GetRValue(c);
     red.store();
     RegistryInt green(IDS_REGISTRY_COLOR_GREEN);
     green.value = GetGValue(c);
     green.store();
     RegistryInt blue(IDS_REGISTRY_COLOR_BLUE);
     blue.value = GetBValue(c);
     blue.store();
   }

The Registry Library          

The Registry Library underlies the Registry classes, and provides more detailed control. I did not provide classes for some of the interfaces because they are used infrequently enough that I didn't bother creating classes for them.

The Registry Library allows for the setting and retrieving of string values, integer values, 64-bit integer values, GUIDs, font descriptions, window placement descriptions, and arrays of DWORD values, as well as the ability to delete keys and values, enumerating keys and values, and simply getting a handle to a key for more detailed Registry API operations. 

Like the Registry classes, these always work relative to IDS_PROGRAM_ROOT and automatically create steps of the path on setting operations.

Whenever a string ID is derived from the STRINGTABLE, I use the notation %id% to indicate the result obtained by doing LoadString(id). So if IDS_PROGRAM_ROOT is "JMNCO\MyProgram" and IDS_COLOR is "Color", then the string %IDS_PROGRAM_ROOT%\%IDS_COLOR% represents the string JMNCO\MyProgram\Color.

Compiling and Linking

You must compile and link in Registry.cpp to get any of these facilities. You only need to include Registry.h if you are using specific functions. RegVars.h defines the RegistryInt and RegistryString variables, and does not require Registry.h to be included in your compilations, but you must also compile and link in RegVars.cpp to get these classes.

This package requires you link with shlwapi.lib to get a correct link.

RegVars.h

Although to use this you only need to include this header file, you must link with the Registry library, which the methods used by these classes call to perform the actual Registry operations. If you include this file in any of your project files, you must include RegVars.cpp in your project or link with the compiled version RegVars.obj.

All registry variable types have the following method defined:

BOOL RegistryVar::remove();

Deletes the registry variable. If this method returns FALSE, then ::GetLastError will return the reason for the failure.

RegistryInt          

RegistryInt::RegistryInt(UINT id, HKEY r = HKEY_CURRENT_USER)

Constructs a variable of type RegistryInt.  This will save any 32-bit signed or unsigned value. Shorter values should be saved as this type. The Registry value is stored as a REG_DWORD.

Parmeters:

UINT id

HKEY r

r\%IDS_PROGRAM_ROOT%\%id%

BOOL RegistryInt::load(int def = 0);

Loads a value from the Registry. Provides for a default value. The .value member of the variable will have either the value from the Registry or the default value when this method returns. If it returns FALSE, use ::GetLastError to determine why it failed. If the value in the Registry is not a REG_DWORD, the operation will fail with ERROR_INVALID_DATATYPE. If the value is not found in the Registry, the return type will be TRUE. In this case, ::GetLastError will return ERROR_FILE_NOT_FOUND. If the return type is TRUE and ::GetLastError returns ERROR_SUCCESS it means the value was actually read from the Registry.

int def

BOOL RegistryInt::store();

Stores the value to the Registry under the key specified for the variable. The current contents of the .value member is what will be stored. If it returns FALSE, use ::GetLastError to determine why it failed.

int value;

This is the .value member of the class.

RegistryInt64          

RegistryInt64::RegistryInt64(UINT id, HKEY r = HKEY_CURRENT_USER)

Constructs a variable of type RegistryInt64.  This will save any 32-bit signed or unsigned value. Shorter values should be saved as this type. The Registry value is stored as a REG_BINARY.

Parmeters:

UINT id

HKEY r

r\%IDS_PROGRAM_ROOT%\%id%

BOOL RegistryInt64::load(__int64 def = 0);

Loads a value from the Registry. Provides for a default value. The .value member of the variable will have either the value from the Registry or the default value when this method returns. If it returns FALSE, use ::GetLastError to determine why it failed. If the value in the Registry is not a REG_BINARY the operation will fail with ERROR_INVALID_DATATYPE. If the length of the value is not sizeof(__int64) the operation will fail with ERROR_INVALID_DATA. If the value is not found in the Registry, the return type will be TRUE. In this case, ::GetLastError will return ERROR_FILE_NOT_FOUND. If the return type is TRUE and ::GetLastError returns ERROR_SUCCESS it means the value was actually read from the Registry.

__int64 def

::GetLastError()

ERROR_INVALID_DATA_TYPE

ERROR_INVALID_DATA

ERROR_FILE_NOT_FOUND

BOOL RegistryInt64::store();

Stores the value to the Registry under the key specified for the variable. The current contents of the .value member is what will be stored. If it returns FALSE, use ::GetLastError to determine why it failed.

__int64 value;

This is the .value member of the class.

RegistryString          

RegistryString::RegistryString(UINT id, HKEY r = HKEY_CURRENT_USER)

Constructs a variable of type RegistryString. 

Parmeters:

UINT id

HKEY r

r\%IDS_PROGRAM_ROOT%\%id%

BOOL RegistryString::load(LPCTSTR def = NULL);

Loads a value from the Registry. Provides for a default value. The .value member of the variable, a CString, will have either the value from the Registry or the default value when this method returns. If the string parameter value is NULL, the .value member is set to the empty string. If it returns FALSE, use ::GetLastError to determine why it failed. If the value was not found in the Registry and the default value is used, the value returned is TRUE, and ::GetLastError will return ERROR_FILE_NOT_FOUND. If the value was found, the value returned is TRUE and ::GetLastError will return ERROR_SUCCESS.

int def

::GetLastError()

ERROR_INVALID_DATA_TYPE

ERROR_FILE_NOT_FOUND

BOOL RegistryString::store();

Stores the value to the Registry under the key specified for the variable. The current contents of the .value member is what will be stored. If it returns FALSE, use ::GetLastError to determine why it failed.

CString value;

This is the .value member of the class.

RegistryGUID          

RegistryGUID::RegistryGUID(UINT id, HKEY r = HKEY_CURRENT_USER)

Constructs a variable of type RegistryGUID  The Registry value is stored as a REG_BINARY.

Parmeters:

UINT id

HKEY r

r\%IDS_PROGRAM_ROOT%\%id%

BOOL RegistryGUID::load(GUID * def = NULL);

Loads a value from the Registry. Provides for a default value. The .value member of the variable will have either the value from the Registry or the default value when this method returns. If it returns FALSE, use ::GetLastError to determine why it failed. If the value in the Registry is not REG_BINARY the operation will fail with ERROR_INVALID_DATATYPE. If the length of the value in the Registry is not sizeof(GUID) the operation will fail with ERROR_INVALID_DATA. If the value is not found in the Registry, and def is not NULL, the return type will be TRUE and the value will be set to the contents of the referenced GUID. In this case, ::GetLastError will return ERROR_FILE_NOT_FOUND. If the default is NULL, and the key is not found, the return value will be FALSE and the value member is not changed; If the return type is TRUE and ::GetLastError returns ERROR_SUCCESS it means the value was actually read from the Registry.

GUID * def

::GetLastError()

ERROR_INVALID_DATA_TYPE

ERROR_INVALID_DATA

ERROR_FILE_NOT_FOUND

BOOL RegistryGUID::store();

Stores the value to the Registry under the key specified for the variable. The current contents of the .value member is what will be stored. If it returns FALSE, use ::GetLastError to determine why it failed.

GUID value;

This is the .value member of the class.

RegistryFont          

RegistryFont::RegistryFont(UINT id, HKEY r = HKEY_CURRENT_USER)

Constructs a variable of type RegistryFont.  The Registry value is stored as a set of values under the registry key.

Parmeters:

UINT id

HKEY r

r\%IDS_PROGRAM_ROOT%\%id%

Remarks:

Not all of the LOGFONT members are stored; only those indicated in the table below are recorded. In the table the value %r% is symbolic for the HKEY parameter of the constructor; the value %IDS_ROOT% is whatever the string value of the IDS_ROOT string is in the STRINGTABLE; and the value %id% represents the ID value obtained from the STRINGTABLE based on the id parameter to the constructor.

%r%\%IDS_PROGRAM_ROOT%\%id%\lfHeight

%r%\%IDS_PROGRAM_ROOT%\%id%\lfWeight

%r%\%IDS_PROGRAM_ROOT%\%id%\lfItalic

%r%\%IDS_PROGRAM_ROOT%\%id%\lfUnderline

%r%\%IDS_PROGRAM_ROOT%\%id%\lfStrikeout

%r%\%IDS_PROGRAM_ROOT%\%id%\lfFaceName

BOOL RegistryFont::load(LOGFONT * def = NULL);

Loads a value from the Registry. Provides for a default value. The .value member of the variable will have either the value from the Registry or the default value when this method returns. If it returns FALSE, use ::GetLastError to determine why it failed. If the value in the Registry is not REG_DWORD for integer values or REG_SZ for the face name, the operation will fail with ERROR_INVALID_DATATYPE. If any integer value is not sizeof(DWORD)  or the lfFaceName is longer than LF_FACESIZE then the operation will fail with ERROR_INVALID_DATA.

If the value is not found in the Registry, and def is not NULL, the return type will be TRUE and the value will be set to the contents of the referenced LOGFONT. In this case, ::GetLastError will return ERROR_FILE_NOT_FOUND. If the default is NULL, and the key is not found, the return value will be FALSE and the value member is not changed; If the return type is TRUE and ::GetLastError returns ERROR_SUCCESS it means the value was actually read from the Registry.

GUID * def

::GetLastError()

ERROR_INVALID_DATA_TYPE

ERROR_INVALID_DATA

ERROR_FILE_NOT_FOUND

BOOL RegistryFont::store();

Stores the value to the Registry under the key specified for the variable. The current contents of the .value member is what will be stored. If it returns FALSE, use ::GetLastError to determine why it failed.

LOGFONT value;

This is the .value member of the class.

RegistryWindowPlacement          

RegistryWindowPlacement::RegistryWindowPlacement(UINT id, HKEY r = HKEY_CURRENT_USER)

Constructs a variable of type RegistryWindowPlacement.  This will save any 32-bit signed or unsigned value. Shorter values should be saved as this type. The Registry value is stored as a subtree of the registry key.

Parmeters:

UINT id

HKEY r

r\%IDS_PROGRAM_ROOT%\%id%

Remarks:

The WINDOWPLACEMENT is stored as a set of values and subkeys of the specified key of the constructor. In the table the value %r% is symbolic for the HKEY parameter of the constructor; the value %IDS_ROOT% is whatever the string value of the IDS_ROOT string is in the STRINGTABLE; and the value %id% represents the ID value obtained from the STRINGTABLE based on the id parameter to the constructor.

%r%\%IDS_PROGRAM_ROOT%\%id%\flags

%r%\%IDS_PROGRAM_ROOT%\%id%\showCmd

%r%\%IDS_PROGRAM_ROOT%\%id%\ptMinPosition

%r%\%IDS_PROGRAM_ROOT%\%id%\ptMinPosition\x

%r%\%IDS_PROGRAM_ROOT%\%id%\ptMinPosition\y

%r%\%IDS_PROGRAM_ROOT%\%id%\ptMaxPosition

%r%\%IDS_PROGRAM_ROOT%\%id%\ptMaxPosition\x

%r%\%IDS_PROGRAM_ROOT%\%id%\ptMaxPosition\y

%r%\%IDS_PROGRAM_ROOT%\%id%\rcNormalPosition

%r%\%IDS_PROGRAM_ROOT%\%id%\rcNormalPosition\left

%r%\%IDS_PROGRAM_ROOT%\%id%\rcNormalPosition\top

%r%\%IDS_PROGRAM_ROOT%\%id%\rcNormalPosition\right

%r%\%IDS_PROGRAM_ROOT%\%id%\rcNormalPosition\bottom

BOOL RegistryWindowPlacement::load(WINDOWPLACEMENT * def = NULL);

Loads a value from the Registry. Provides for a default value. The .value member of the variable will have either the value from the Registry or the default value when this method returns. If it returns FALSE, use ::GetLastError to determine why it failed. If the values in the Registry are not REG_DWORD the operation will fail with ERROR_INVALID_DATATYPE. If the value is not found in the Registry, and def is not NULL, the return type will be TRUE and the value will be set to the contents of the referenced WINDOWPLACEMENT. In this case, ::GetLastError will return ERROR_FILE_NOT_FOUND. If the default is NULL, and the key is not found, the return value will be FALSE and the value member is not changed; If the return type is TRUE and ::GetLastError returns ERROR_SUCCESS it means the value was actually read from the Registry.

WINDOWPLACEMENT * def

::GetLastError()

ERROR_INVALID_DATA_TYPE

ERROR_FILE_NOT_FOUND

BOOL RegistryWindowPlacement::store();

Stores the value to the Registry under the key specified for the variable. The current contents of the .value member is what will be stored. If it returns FALSE, use ::GetLastError to determine why it failed.

WINDOWPLACEMENT value;

This is the .value member of the class.

RegistryDWordArray

This uses a single key stored as REG_BINARY to hold the contents of a CDWordArray. See also RegistryByteArray.

RegistryDWordArray::RegistryDWordArray(UINT id, HKEY r = HKEY_CURRENT_USER)

Constructs a variable of type RegistryDWordArray The Registry value is stored as a REG_BINARY.

Parmeters:

UINT id

HKEY r

r\%IDS_PROGRAM_ROOT%\%id%

BOOL RegistryDWordArray::load();

Loads a value from the Registry. Provides for a default value. Note there is no explicit default value; if the key is not found, an empy value array results. The .value member of the variable will have the value from the Registry, interpreted as an array of DWORD values, when this method returns. If it returns FALSE, use ::GetLastError to determine why it failed. If the value in the Registry is not REG_BINARY the operation will fail with ERROR_INVALID_DATATYPE. If the length of the value in the Registry is not an integer multiple of sizeof(DWORD) the operation will fail with ERROR_INVALID_DATA. If the value is not found in the Registry, and def is not NULL, the return type will be TRUE and the value will be set to the contents of the referenced GUID. In this case, ::GetLastError will return ERROR_FILE_NOT_FOUND.

::GetLastError()

ERROR_INVALID_DATA_TYPE

ERROR_INVALID_DATA

ERROR_FILE_NOT_FOUND

BOOL RegistryDWordArray::store();

Stores the value to the Registry under the key specified for the variable. The current contents of the .value member is what will be stored. If it returns FALSE, use ::GetLastError to determine why it failed.

DWordArray value;

This is the .value member of the class.

Registry.h          

The Registry.cpp module provides for more direct access to the Registry. All operations are performed relative to the string specified by the String Table entry IDS_PROGRAM_ROOT.

These functions are used when you need closer control, for example, in creating non-constant Registry keys that are computed on the fly.

To simplify the notation, I've adapted the notation for expansion of environment strings. In this case, I use %name% to indicate the expansion of the string identified in the String Table by the value name. Thus %IDS_PROGRAM_ROOT% should be replaced, in the descriptions that follow, by the string that IDS_PROGRAM_ROOTrepresents, and if the name defines a variable or parameter in the program, by the string which is retrieved by the integer represented by that variable or parameter.

In all cases, if the function returns FALSE, the error can found by calling ::GetLastError(). In addition to the standard errors that can be returned from the Registry API calls, if the value is the wrong type for the operation, or of the wrong length, ::GetLastErro() will return ERROR_INVALID_DATA.

The default value is always present for scalar values, and optional for other types of values. When a default value is provided, the operation will always succeed and return TRUE even if the key is not found in the Registry. However, if TRUE is returned and ::GetLastError returns ERROR_FILE_NOT_FOUND, it means the key was not found and the default value was used. If it returns TRUE and the key was found, ::GetLastError will return ERROR_SUCCESS. If the default value is optional (usually indicated by a NULL pointer to a value), the operation will always return FALSE if the default is NULL and the key is not found in the Registry.

In addition to the normal Registry errors that can be returned by ::GetLastError, the library will return ERROR_INVALID_DATA_TYPE or ERROR_INVALID_DATA if the Registry type is incorrect or the data does not meet certain size criteria.

If you use this header file, or if you use the RegVars.cpp module, you must either include this in your compilation or link with the compiled RegVars.obj file. 

[Get/Set]RegistryString          

BOOL GetRegistryString(HKEY root, const CString & var, CString & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

CString & val

::GetLastError()

ERROR_INVALID_DATA_TYPE

BOOL SetRegistryString(HKEY root, const CString & var, const CString & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

const CString & val

::GetLastError()

ERROR_INVALID_DATA_TYPE

BOOL GetRegistryString(HKEY root, const CString & path, UINT var, CString & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\path\%var%

const CString & path

UINT var

CString & val

::GetLastError()

ERROR_INVALID_DATA_TYPE

BOOL SetRegistryString(HKEY root, const CString & path, UINT var, const CString & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\path\%var%

const CString & path

UINT var

const CString & val

BOOL GetRegistryString(HKEY root, const CString & path, const CString & var, CString & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\path\var

const CString & path

const CString & var

CString & val

::GetLastError()

ERROR_INVALID_DATA_TYPE

BOOL SetRegistryString(HKEY root, const CString & path, const CString & var, const CString & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\path\var

const CString & path

const CString & var

const CString & val

[Get/Set]RegistryInt         

BOOL GetRegistryInt(HKEY root, const CString & var, DWORD & val);
BOOL GetRegistryInt(HKEY root, const CString & var, int & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

DWORD & val
int & val	

::GetLastError()

ERROR_INVALID_DATA_TYPE

BOOL SetRegistryInt(HKEY root, const CString & var, DWORD val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

DWORD val

BOOL GetRegistryInt(HKEY root, const CString & path, UINT var, DWORD & val);
BOOL GetRegistryInt(HKEY root, const CString & path, UINT var, int & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\path\%var%

const CString & path

UINT var

DWORD & val
int & val

::GetLastError()

ERROR_INVALID_DATA_TYPE

BOOL SetRegistryInt(HKEY root, const CString & path, UINT var, DWORD val);
BOOL SetRegistryInt(HKEY root, const CString & path, UINT var, int val);

HKEY root

root\%IDS_PROGRAM_ROOT%\path\%var%

const CString & path

UINT var

DWORD val
int val

BOOL GetRegistryInt(HKEY root, const CString & path, const CString & var, DWORD & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\path\var

const CString & path

const CString & var

DWORD & val

::GetLastError()

ERROR_INVALID_DATA_TYPE

BOOL SetRegistryInt(HKEY root, const CString & path, const CString & var, DWORD val);

HKEY root

root\%IDS_PROGRAM_ROOT%\path\var

const CString & path

const CString & var

DWORD val

[Get/Set]RegistryInt64          

BOOL GetRegistryInt64(HKEY root, const CString & var,          __int64 & val);
BOOL GetRegistryInt64(HKEY root, const CString & var, unsigned __int64 & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

__int64 & val
unsigned __int64 & val

::GetLastError()

ERROR_INVALID_DATA_TYPE

ERROR_INVALID_DATA

BOOL SetRegistryInt64(HKEY root, const CString & var,          __int64 val);
BOOL SetRegistryInt64(HKEY root, const CString & var, unsigned __int64 val); 

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

__int64 val
unsigned __int64 val

::GetLastError()

ERROR_INVALID_DATA_TYPE

ERROR_INVALID_DATA

[Get/Set]RegistryGUID          

BOOL GetRegistryGUID(HKEY root, const CString & var, GUID & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

GUID & val

::GetLastError()

ERROR_INVALID_DATA_TYPE

ERROR_INVALID_DATA

BOOL SetRegistryGUID(HKEY root, const CString & var, const GUID & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

GUID val

[Get/Set]RegistryFont          

BOOL GetRegistryFont(HKEY root, const CString & var, LPLOGFONT val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

LPLOGFONT val

BOOL SetRegistryFont(HKEY root, const CString & var, const LOGFONT * val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

const LOGFONT * val

For a font, the var represents not a value, but a key under which the values are stored. The following components of the LOGFONT structure are stored. Note that this is not the complete set of possible values. For example, I had no need to store font rotation information.

REG_DWORD

REG_DWORD

REG_WORD

REG_DWORD

REG_DWORD

REG_SZ

In the example below, certain keys representing proprietary information have been blanked out. What you see here are two keys, one for font and one for window placement. The Font resource is shown expanded. Note that I do not save all of the LOGFONT structure because I only needed the subset shown; if you need more, the generalization should be obvious. The WindowPlacement entry simply stores the coordinates of a WindowPlacement structure.

[Get/Set]RegistryWindowPlacement          

BOOL GetRegistryWindowPlacement(HKEY root, const CString & var, WINDOWPLACEMENT & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

WINDOWPLACEMENT & val

BOOL SetRegistryWindowPlacement(HKEY root, const CString & var, const WINDOWPLACEMENT & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

const WINDOWPLACEMENT & val

For a font, the var represents not a value, but a key under which the values are stored.

%r%\%IDS_PROGRAM_ROOT%\%id%\flags

%r%\%IDS_PROGRAM_ROOT%\%id%\showCmd

%r%\%IDS_PROGRAM_ROOT%\%id%\ptMinPosition

%r%\%IDS_PROGRAM_ROOT%\%id%\ptMinPosition\x

%r%\%IDS_PROGRAM_ROOT%\%id%\ptMinPosition\y

%r%\%IDS_PROGRAM_ROOT%\%id%\fUnderline

%r%\%IDS_PROGRAM_ROOT%\%id%\ptMaxPosition\x

%r%\%IDS_PROGRAM_ROOT%\%id%\ptMaxPosition\y

%r%\%IDS_PROGRAM_ROOT%\%id%\rcNormalPosition

%r%\%IDS_PROGRAM_ROOT%\%id%\rcNormalPosition\left

%r%\%IDS_PROGRAM_ROOT%\%id%\rcNormalPosition\top

%r%\%IDS_PROGRAM_ROOT%\%id%\rcNormalPosition\right

%r%\%IDS_PROGRAM_ROOT%\%id%\rcNormalPosition\bottom

[Get/Set]RegistryDWordArray          

BOOL GetRegistryDWordArray(HKEY root, const CString & var, CDWordArray & result);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

::GetLastError()

ERROR_INVALID_DATA_TYPE

ERROR_INVALID_DATA

BOOL SetRegistryDWordArray(HKEY root, const CString & var, const CDWordArray & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

CDWordArray & val

BOOL SetRegistryDWordArray(HKEY root, UINT var, const CDWordArray & val);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

UINT var

CDWordArray & val

DeleteRegistry[Key/Value]          

Note that this can be invoked also by using the remove member of the RegistryVar superclass.

BOOL DeleteRegistryKey(HKEY root, const CString & keyname);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & keyname

BOOL DeleteRegistryValue(HKEY root, const CString & var);

HKEY root

root\%IDS_PROGRAM_ROOT%\var

const CString & var

[Get/Find]RegistryKey          

BOOL GetRegistryKey(HKEY root, const CString & keyname, HKEY & key, DWORD access = KEY_ALL_ACCESS);

HKEY root

root\%IDS_PROGRAM_ROOT%\keyname

const CString & keyname

HKEY & key

BOOL FindRegistryKey(HKEY root, const CString & keyname, HKEY & key, DWORD access = KEY_ALL_ACCESS);

HKEY root

root\%IDS_PROGRAM_ROOT%\keyname

const CString & keyname

HKEY & key

EnumRegistry[Keys/Values]          

BOOL EnumRegistryKeys(HKEY root, const CString & keyname, CStringArray & keys);

HKEY root

root\%IDS_PROGRAM_ROOT%\keyname

const CString & keyname

BOOL EnumRegistryKeys(HKEY root, UINT keyname, CStringArray & keys);

HKEY root

root\%IDS_PROGRAM_ROOT%\%keyname%

UINT keyname

BOOL EnumRegistryValues(HKEY root, const CString & keyname, CStringArray & keys);

HKEY root

root\%IDS_PROGRAM_ROOT%\keyname

const CString & keyname

[Set/Get]RegistryValues

The idea of this is to have a CStringArray or CDWordArray of values which will be stored as individual values in the Registry. The values will be stored as a sequence of names 00000, 00001, 00002, and so on. This can conveniently be used to store sequences of string or DWORD values.

BOOL SetRegistryValues(HKEY root, const CString & keyname, const CStringArray & values);

HKEY root

root\%IDS_PROGRAM_ROOT%\keyname

const CString & keyname

BOOL SetRegistryValues(HKEY root, UINT keyid, const CStringArray & values);

HKEY root

root\%IDS_PROGRAM_ROOT%\keyname

UINT keyid

BOOL SetRegistryValues(HKEY root, const CString & keyname, const DWordArray & values);

HKEY root

root\%IDS_PROGRAM_ROOT%\keyname

const CString & keyname

BOOL SetRegistryValues(HKEY root, UINT keyid, const CDWordArray & values);

HKEY root

root\%IDS_PROGRAM_ROOT%\keyname

UINT keyid

BOOL GetRegistryValues(HKEY root, const CString & keyname, CStringArray & values);

HKEY root

root\%IDS_PROGRAM_ROOT%\keyname

const CString & keyname

BOOL GetRegistryValues(HKEY root, UINT keyid, CStringArray & values);

HKEY root

root\%IDS_PROGRAM_ROOT%\keyname

UINT keyid

BOOL GetRegistryValues(HKEY root, const CString & keyname, DWordArray & values);

HKEY root

root\%IDS_PROGRAM_ROOT%\keyname

const CString & keyname

BOOL SetRegistryValues(HKEY root, UINT keyid, CDWordArray & values);

HKEY root

root\%IDS_PROGRAM_ROOT%\keyname

UINT keyid

GetKeyPath       

This function is used to obtain the key path given a string name or STRINGTABLE id

CString GetKeyPath(const CString & key)
CString GetKeyPath(UINT keyid)

const CString & key

%IDS_PROGRAM_ROOT%\key

UINT keyid

%IDS_PROGRAM_ROOT%\%keyid%

[Create/Open]Key   

CreateKey creates an actual key entry in the Registry. If an absolute key name is provided, that key is created. If a relative key name is provided, it is created under the IDS_PROGRAM_ROOT value. The key is created in the Registry and then closed.

BOOL CreateKey(HKEY root, const CString & key, DWORD access = KEY_ALL_ACCESS)

HKEY root

const CString & key

root\%IDS_PROGRAM_ROOT%\key

DWORD access

 OpenKey opens a key and returns the HKEY value. This is to allow explicit operations to be performed. If an absolute key name is provided, that key is opened. If a relative key name is provided, it is created under the IDS_PROGRAM_ROOT value. The return value is the HKEY, or NULL if an error occured

HKEY OpenKey(HKEY root, const CString & key, DWORD access = KEY_ALL_ACCESS)

HKEY root

const CString & key

root\%IDS_PROGRAM_ROOT%\key

DWORD access

Restrospective

(2001) There are probably some things I would do differently today (I wrote most of this code in 1996), such as passing in references to arrays instead of returning pointers to created arrays, but this is the code as it stands today.

(2005) I have made significant upgrades. New classes for RegistryDWordArray, RegistryGUID, RegistryInt64, and RegistryWindowPlacement have been added. The enumeration functions now take reference parameters, and the methods which formerly returned allocated arrays now take array reference parameters and fill them in. The load and store methods now return BOOL instead of void, and consistently the substitution of the default value is indicated by returning a success indicator with ::GetLastError returning ERROR_FILE_NOT_FOUND; if the value is found and the default is not used, ::GetLastError will return ERROR_SUCCESS. A new remove method has been added. I added GetKeyPath so the program can handle other explicit Registry operations.

The views expressed in these essays are those of the author, and in no way represent, nor are they endorsed by, Microsoft.

Send mail to newcomer@flounder.com with questions or comments about this web site.
Copyright © 2001 The Joseph M. Newcomer Co. All Rights Reserved.
Last modified: May 14, 2011