mirror of
https://bitbucket.org/theswgsource/src-1.2.git
synced 2026-09-28 13:12:56 -04:00
271 lines
9.1 KiB
C++
271 lines
9.1 KiB
C++
#ifndef REGISTRY_KEY_H
|
|
#define REGISTRY_KEY_H
|
|
|
|
// ======================================================================
|
|
//
|
|
// RegistryKey.h
|
|
// Todd Fiala
|
|
//
|
|
// copyright 1998 Bootprint Entertainment
|
|
//
|
|
// ======================================================================
|
|
|
|
// provide read and write access to the Windows Registry
|
|
//
|
|
// Remarks:
|
|
//
|
|
// Each RegistryKey can create or open a subkey relative to that
|
|
// key. This process produces another RegistryKey. RegistryKeys
|
|
// provide a mechanism to enumerate all the child subkeys and values
|
|
// associated with the key. In addition, clients may query for
|
|
// the presence, type and size of a specific value, get a specific
|
|
// value's data, and set a named value's data and type.
|
|
//
|
|
// The RegistryKey class provides the client with six RegistryKey
|
|
// objects as starting points into the registry. See documentation
|
|
// for install() for more info on these starting points.
|
|
//
|
|
// The client must install() the RegistryKey class before using it.
|
|
|
|
class RegistryKey
|
|
{
|
|
public:
|
|
// ----------------------------------------------------------------------
|
|
// flags used to indicate what type of access (e.g. read, write) should
|
|
// be granted when creating or opening a key.
|
|
//
|
|
// See Also:
|
|
//
|
|
// createSubkey(), openSubkey()
|
|
|
|
enum // AccessFlags
|
|
{
|
|
AF_READ = BINARY1(0001), // query values, enumerate subkeys
|
|
AF_WRITE = BINARY1(0010) // set values, create subkeys
|
|
};
|
|
|
|
// ----------------------------------------------------------------------
|
|
// callback prototype for subkey enumeration
|
|
//
|
|
// Return Value:
|
|
//
|
|
// A return value of true indicates the enumeration of subkeys should
|
|
// continue. A return value of false stops further enumeration of
|
|
// subkeys.
|
|
//
|
|
// Remarks:
|
|
//
|
|
// The context parameter is specified in the call to
|
|
// enumerateSubkeys(). One use for this could be to pass a class
|
|
// instance, with the callack defined as a static member function.
|
|
// The function can then cast the context to a pointer to class
|
|
// instance, allowing the static function to access per-instance
|
|
// data explicitly in place of an assumed this pointer.
|
|
//
|
|
// See Also:
|
|
//
|
|
// enumerateSubkeys()
|
|
|
|
typedef bool (*EnumerateKeyCallback)(
|
|
void *context, // [IN] user-specified context variable
|
|
const char *keyName, // [IN] name of the key being enumerated
|
|
const FILETIME *lastWriteTime // [IN] last time this key was modified
|
|
);
|
|
|
|
// ----------------------------------------------------------------------
|
|
// callback prototype for value enumeration
|
|
//
|
|
// Return Value:
|
|
//
|
|
// A return value of true indicates the enumeration of values should
|
|
// continue. A return value of false stops further enumeration of
|
|
// values .
|
|
//
|
|
// Remarks:
|
|
//
|
|
// The context parameter is specified in the call to
|
|
// enumerateValues(). One use for this could be to pass a class
|
|
// instance, with the callack defined as a static member function.
|
|
// The function can then cast the context to a pointer to class
|
|
// instance, allowing the static function to access per-instance
|
|
// data explicitly in place of an assumed this pointer.
|
|
//
|
|
// See Also:
|
|
//
|
|
// enumerateValues()
|
|
|
|
typedef bool (*EnumerateValueCallback)(
|
|
void *context, // [IN] user-specified context variable
|
|
const char *valueName, // [IN] name of the value being enumerated
|
|
uint32 valueSize, // [IN] number of bytes occupied by this value's data
|
|
DWORD valueType // [IN] type of value (one of REG_* as in RegSetValueEx documentation)
|
|
);
|
|
|
|
private:
|
|
static const char * const PRODUCT_REGISTRY_PATH_KEYNAME;
|
|
static const char * const DEFAULT_PRODUCT_REGISTRY_PATH;
|
|
|
|
#if USE_REGISTRY_EXECUTION_STATISTICS
|
|
static const char * const STATISTICS_KEYNAME;
|
|
static const char * const STAT_EXEC_STARTED_COUNT_VALUENAME;
|
|
static const char * const STAT_EXEC_INCOMPLETE_COUNT_VALUENAME;
|
|
static const char * const STAT_TIME_AVERAGE_VALUENAME;
|
|
static const char * const STAT_TIME_MIN_VALUENAME;
|
|
static const char * const STAT_TIME_MAX_VALUENAME;
|
|
static const char * const STAT_TIME_START_VALUENAME;
|
|
#endif
|
|
|
|
static bool installed;
|
|
static bool setProductKeyPathFromConfig;
|
|
|
|
// private instance member variables
|
|
HKEY keyHandle;
|
|
bool closeKeyOnDestroy;
|
|
|
|
private:
|
|
// public member variables
|
|
static RegistryKey *usersKey;
|
|
static RegistryKey *currentUserKey;
|
|
static RegistryKey *classRootKey;
|
|
static RegistryKey *localMachineKey;
|
|
static RegistryKey *productUserKey;
|
|
static RegistryKey *productMachineKey;
|
|
|
|
private:
|
|
// private member functions
|
|
static void remove(void);
|
|
RegistryKey(HKEY newKeyHandle, bool newCloseKeyOnDestroy);
|
|
|
|
#if USE_REGISTRY_EXECUTION_STATISTICS
|
|
static void updateStartupKey(RegistryKey *key);
|
|
static void updateShutdownKey(RegistryKey *key);
|
|
static bool enumValueInfoPrint(void *context, const char *valueName, uint32 valueSize, DWORD valueType);
|
|
|
|
static void updateStartupStatistics(void);
|
|
static void updateShutdownStatistics(void);
|
|
#endif
|
|
|
|
private:
|
|
// disable: default constructor, copy constructor, assignment operator
|
|
// NOTE: last two can be implemented, but must be specially handled
|
|
RegistryKey(void);
|
|
RegistryKey(const RegistryKey&);
|
|
RegistryKey &operator =(const RegistryKey&);
|
|
|
|
public:
|
|
// public member functions
|
|
|
|
static void install(const char *productKeyRelativePath = 0);
|
|
static void setProductKeyPath(const char *productKeyRelativePath);
|
|
|
|
// pre-defined RegistryKey retrieval
|
|
static RegistryKey *getUsersKey(void);
|
|
static RegistryKey *getCurrentUserKey(void);
|
|
static RegistryKey *getClassRootKey(void);
|
|
static RegistryKey *getLocalMachineKey(void);
|
|
static RegistryKey *getProductUserKey(void);
|
|
static RegistryKey *getProductMachineKey(void);
|
|
|
|
~RegistryKey(void);
|
|
|
|
// subkey interface
|
|
void enumerateSubkeys(void *context, EnumerateKeyCallback callback) const;
|
|
RegistryKey *openSubkey(const char *subkeyName, uint32 accessFlags = AF_READ) const;
|
|
RegistryKey *createSubkey(const char *subkeyName, uint32 accessFlags = AF_READ | AF_WRITE) const;
|
|
void deleteSubkey(const char *subkeyName);
|
|
bool subKeyExists(const char *subkeyName);
|
|
|
|
// value interface
|
|
void enumerateValues(void *context, EnumerateValueCallback callback) const;
|
|
void setValue(const char *valueName, const void *dataPtr, uint32 dataSize, DWORD valueType = REG_BINARY);
|
|
void deleteValue(const char *valueName);
|
|
|
|
void getValueInfo(const char *valueName, bool *doesExist, uint32 *valueSize = 0, DWORD *valueType = 0) const;
|
|
void getValue(const char *valueName, void *dataPtr, uint32 maxDataSize, uint32 *valueDataSize, DWORD *valueType = 0) const;
|
|
bool getStringValue(const char *valueName, const char *defaultValue, char *dest, DWORD destSize, bool optional = false);
|
|
|
|
};
|
|
|
|
// ======================================================================
|
|
// retrieve a key to the HKEY_USERS registry key with read access
|
|
|
|
inline RegistryKey *RegistryKey::getUsersKey(void)
|
|
{
|
|
DEBUG_FATAL(!installed, ("Attempted to use RegistryKey when not installed\n"));
|
|
return usersKey;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
/**
|
|
* retrieve a key to the HKEY_CURRENT_USER registry key with read/write
|
|
* access.
|
|
*/
|
|
|
|
inline RegistryKey *RegistryKey::getCurrentUserKey(void)
|
|
{
|
|
DEBUG_FATAL(!installed, ("Attempted to use RegistryKey when not installed\n"));
|
|
return currentUserKey;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
/**
|
|
* retrieve a key to the HKEY_CLASSES_ROOT registry key with read/write
|
|
* access.
|
|
*/
|
|
|
|
inline RegistryKey *RegistryKey::getClassRootKey(void)
|
|
{
|
|
DEBUG_FATAL(!installed, ("Attempted to use RegistryKey when not installed\n"));
|
|
return classRootKey;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
/**
|
|
* retrieve a key to the HKEY_LOCAL_MACHINE registry key with read/write
|
|
* access.
|
|
*/
|
|
|
|
inline RegistryKey *RegistryKey::getLocalMachineKey(void)
|
|
{
|
|
DEBUG_FATAL(!installed, ("Attempted to use RegistryKey when not installed\n"));
|
|
return localMachineKey;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
/**
|
|
* retrieve a key to the product's user key with read/write access.
|
|
*
|
|
* The product user key is the root key for storing user-specific
|
|
* product-related information. install() describes where this
|
|
* information exists in the registry.
|
|
*
|
|
* @see install(), getProductMachineKey()
|
|
*/
|
|
|
|
inline RegistryKey *RegistryKey::getProductUserKey(void)
|
|
{
|
|
DEBUG_FATAL(!installed, ("Attempted to use RegistryKey when not installed\n"));
|
|
return productUserKey;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
/**
|
|
* retrieve a key to the product's machine key with read/write access.
|
|
*
|
|
* The product machine key is the root key for storing machine-specific
|
|
* product-related information. install() describes where this
|
|
* information exists in the registry.
|
|
*
|
|
* @see install(), getProductUserKey()
|
|
*/
|
|
|
|
inline RegistryKey *RegistryKey::getProductMachineKey(void)
|
|
{
|
|
DEBUG_FATAL(!installed, ("Attempted to use RegistryKey when not installed\n"));
|
|
return productMachineKey;
|
|
}
|
|
|
|
// ======================================================================
|
|
|
|
#endif
|