fREGISTRY

Quick Data

General Description

Nowadays, every program needs to be able to look at, read and write to the registry. So that's what this component does - look at, read, and write to the registry. I think you'll find it very useful.

Firstly, though, I will go over some definitions with you. The registry is a complex beast, and the descriptions are confusing, but all you can do is try your best to understand it.

Before you read these definitions, I trust you at least have an idea of what the registry is. If you don't, please go and find out first. If you want to see the registry, then click Start, then Run, and then type 'regedit' into the box. Click Ok, and the registry editor will load. Have a browse around - but don't change much unless you know what you are doing! I have deleted large keys before, only to cripple Windows to the point where I had to format my hard drive and start again. Just use some common sense, and you should be fine. Anyway, onto the descriptions:

• Key: a key is usually the 'folder' (if you like) where values are stored in. For example, a key could be: "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion". As you can see, it is almost like a pathname. The first part at the front, the HKEY_CURRENT_USER, could almost be a drive letter - as there are about five different names that are at the front. Everything after that first slash could be the folders under that drive.
• Value: a value is something stored under a key - or under the file system analogy, a value would be a file. The value can have multiple types - the three most common would be a string, a DWORD, or binary data. A string is... well... a string. A DWORD is equivalent of a long int - or four bytes of number. Binary data is just a block of binary data - say that which you might find in a file. A value also has a 'Name' - almost like a filename - and then a value part, which is what the value is.

The rule of thumb when writing to a registry, according to Microsoft, is to keep strings and binary data under two kilobytes. Any more than that, and the system "apparently" slows down and becomes less efficient. I can't see anybody saving more than that much in the registry anyway, but please just keep this in mind - after all, Microsoft designed the standard, and they should know how it works best.

Methods

These methods are split up a little bit to make navigating them a little easier.

Connecting to a registry, opening a key, or creating a key.

Writing values to the registry

To save stating the obvious over and over, all of these functions do similar things. They add a value to the registry. The new value has the name of ValueName, and the data specified by the second variable passed. If the value already exists, it is updated, and if the value does not exist, it is added. Simple as that. Also, each function returns TRUE if successful, or FALSE otherwise. Finally, any values added or updated are done so under the currently open key.

And past finally... you may have noticed in RegEdit that there is a "(Default)" value under every key. This value is simply a value without a name - and you are permitted to add and read these as well. Just specify "" for ValueName.

Prototype	Description
bool SetStringValue(char* ValueName, char* String);	This function writes a string value into the registry.
bool SetDWORDValueINT(char* ValueName, int Number);	This function sets a DWORD value in the registry, from an int number. There seems to be some incompatibility between DWORDS and int's - thus this function. A DWORD is actually a long unsigned int.
bool SetDWORDValue(char* ValueName, DWORD Number);	This function sets a DWORD value in the registry from a DWORD variable. Could be handy, considering that this seems to 'be' the number format when using the registry. Many programs use this like a bool - in that if a value is 1 (one), then it is true, and if it is 0 (Zero) it is false.
bool SetBinaryValue(char* ValueName, char* Data, int Size);	This function sets a binary value in the registry. This could be useful for storing things like floats, or just general binary data. Data specifies a pointer to the data, and Size indicates how many bytes to enter into the registry.

Getting key names from the registry

It can be quite useful to get what keys exist in the registry... a necessity if you are writing your own Regedit.

Getting the values (or a value) from the registry

Now here is something that is really lucrative... getting values from the registry. These functions do manage to do that task, although getting them working was a long and tiring experience.

Sample Code

The following snippet gives a basic idea of how to use this component.

//Now this is just a simple example... just to show some
//basic things.

//Firstly, we will recover the type of your primary CPU,
//which just so happens to be stored in the registry...
fREGISTRY Registry;

Registry.OpenKey(HKEY_LOCAL_MACHINE, 
                 "Hardware\\Description\\System\\CentralProcessor\\0");

//Note that I haven't shown any error checking. You should
//error check.

//Also note the double slashes (\\). That's the escape code for
//a single slash (\). You'll only need it if you hard-code a location,
//but when the user enters a location, say into an edit control,
//you will not need to have the double slash. You probably already
//know this, but just to make sure...

//Now find a certain value, and show it.
Registry.GetValue("Identifier");
if (Registry.IsTypeString())
   {
   MessageBox(NULL, Registry.GetData(),
              "And your primary processor is...", 0);
   }

//When you are done, or you wish to change keys, close the current
//key...
Registry.CloseKey();

//Now enumerate all the sub-keys under HKEY_LOCAL_MACHINE\Software
//(should be many keys).
Registry.OpenKey(HKEY_LOCAL_MACHINE, "Software");
for (int Temp = 0; Temp < Registry.GetNumberSubKeys(); Temp++)
    {
    ... = Registry.GetKeyName();
    }

//And that's it!
Registry.CloseKey();