MyRegistry.CPP

Go to the documentation of this file.

/* *************************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
        http://www.gnu.org/copyleft/gpl.html
************************************************************************************* */

#include <stdio.h>
#include <windows.h>
#include "MyRegistry.h"
#include "MyException.h"
#include "mylist.h"

void MyRegistry::SetAutoCreate(BOOL autoCreate)
{
        m_isAutoCreate = autoCreate;
}

BOOL MyRegistry::IsAutoCreate()
{
        return m_isAutoCreate;
}

BOOL NextSubKey(MyString &key,MyString &subKey,MyString &suite)
{
        for (int i=0;i<key.GetSize();i++)
        {
                if (key[i]=='\\')
                {
                        key[i]='\0';
                        subKey = key;
                        key[i]='\\';
                        suite=key.GetValue()+i+1; 
                        return TRUE;
                }
        }
        subKey=key;
        return FALSE;
}

void MyRegistry::HKeyToString (MyString &result)
{
        switch ((ULONG_PTR)m_hKey)
        {
                case HKEY_CLASSES_ROOT: result="HKEY_CLASSES_ROOT"; break;
                case HKEY_CURRENT_CONFIG: result="HKEY_CURRENT_CONFIG";break;
                case HKEY_CURRENT_USER: result="HKEY_CURRENT_USER"; break;
                case HKEY_LOCAL_MACHINE: result="HKEY_LOCAL_MACHINE"; break;
                case HKEY_USERS: result="HKEY_USERS";break;
                case HKEY_PERFORMANCE_DATA: result="HKEY_PERFORMANCE_DATA";break;
                case HKEY_DYN_DATA: result="HKEY_DYN_DATA"; break;
                default: result="";
        }
}

MyRegistry::MyRegistry(BOOL autoCreate)
{
        m_isAutoCreate = autoCreate;
        m_lastError = ERROR_SUCCESS;
}

BOOL MyRegistry::Open(char *nameKey)
{
        SetKeyName(nameKey);

        HKEY hKey;
        m_lastError = RegOpenKeyExA( m_hKey, m_postFixKey, 0 , KEY_READ, &hKey);
        if (m_lastError!=ERROR_SUCCESS) 
        {
                if (m_isAutoCreate) return Create(NULL);
                return FALSE;
        }
        RegCloseKey (hKey) ;
        return TRUE;
}

// ********************************************************************************

BOOL MyRegistry::SetKeyName(char *nameKey)
{
        // gestion des insertions et deplacement "." et "\" 
        char *letter = nameKey;
        BOOL modeRet=FALSE;
        BOOL modeAdd=TRUE;

        if (*letter=='.' || *letter=='\\')
        {
                while (*letter)
                {
                        switch (*letter)
                        {
                        case '.':
                                modeAdd=FALSE;
                                if (modeRet)
                                {
                                        m_postFixKey.Delete(-1,FALSE,1); // suprime le '\'
                                        if (!m_postFixKey.Delete(-1,FALSE,'\\')) m_postFixKey="";
                                        modeRet = FALSE;
                                }
                                else modeRet = TRUE;
                                break;

                        case '\\':
                                if (modeAdd&&m_postFixKey[-1]!='\\'&&nameKey-letter) 
                                        m_postFixKey<<'\\'; // ajout '\' si pas permiere lettre, ancienne lettre!='\' et si pas modeAdd
                                break;

                        default:
                                if (!modeAdd&&m_postFixKey.GetSize()) m_postFixKey<<'\\';
                                modeAdd=TRUE;
                                m_postFixKey<<*letter;
                                break;
                        }
                        letter++;
                }
        }
        else if (!SetPrefixAndPostfix(nameKey)) return FALSE;

        // quelque soit la clef elle doit se finir par '\'
        switch (m_postFixKey[-1])
        {
                case '\\': break;
                case '\0': break;
                default: m_postFixKey<<'\\';
        }
        return TRUE;
}

// ********************************************************************************

void MyRegistry::GetKeyName(MyString &result)
{ 
        HKeyToString(result);
        result<<"\\"<<m_postFixKey;
}

BOOL MyRegistry::SetPrefixAndPostfix (char *nameKey)
{
        MyString fullNameKey = nameKey;
        MyString subKey,nextKey;

        m_hKey = NULL;
        NextSubKey(fullNameKey,subKey,nextKey);
        if (subKey=="HKEY_CLASSES_ROOT" || subKey=="HKCR")                      
                m_hKey=HKEY_CLASSES_ROOT;
        else if (subKey=="HKEY_CURRENT_CONFIG" || subKey=="HKCC")       
                m_hKey=HKEY_CURRENT_CONFIG;
        else if (subKey=="HKEY_CURRENT_USER" || subKey=="HKCU")         
                m_hKey=HKEY_CURRENT_USER;
        else if (subKey=="HKEY_LOCAL_MACHINE" || subKey=="HKLM")        
                m_hKey=HKEY_LOCAL_MACHINE;
        else if (subKey=="HKEY_USERS" || subKey=="HKU")                         
                m_hKey=HKEY_USERS;
        else if (subKey=="HKEY_PERFORMANCE_DATA" || subKey=="HKPD")     
                m_hKey=HKEY_PERFORMANCE_DATA;
        else if (subKey=="HKEY_DYN_DATA" || subKey=="HKDD")                     
                m_hKey=HKEY_DYN_DATA;
        else 
        {
                m_hKey = NULL;
                return FALSE;
        }
        m_postFixKey = nextKey;
        return TRUE;
}

BOOL MyRegistry::Create(char *nameKey)
{
        if (nameKey) if (!SetKeyName(nameKey)) return FALSE;

        HKEY hKey; 
        m_lastError = RegCreateKeyA(m_hKey,m_postFixKey,&hKey);
        if (m_lastError!= ERROR_SUCCESS) return FALSE;
        RegCloseKey (hKey);
        return TRUE;
}


#include <shlwapi.h>
#pragma comment(lib, "shlwapi.lib")

BOOL MyRegistry::DeleteKey(char *nameKey)
{
        if (!nameKey) nameKey=m_postFixKey.GetValue();
        else if (!SetPrefixAndPostfix(nameKey)) return FALSE;

        SHDeleteKey(m_hKey,nameKey);
        SetKeyName("..");
        TestKey();
        return TRUE;
}

BOOL MyRegistry::DeleteValue(char *param)
{
        HKEY hKey ; 
        m_lastError = RegOpenKeyExA(m_hKey,m_postFixKey,0,KEY_SET_VALUE,&hKey);
        if (m_lastError!= ERROR_SUCCESS) return FALSE;
        m_lastError = RegDeleteValueA (hKey,param);
        RegCloseKey (hKey) ;
        return m_lastError== ERROR_SUCCESS?TRUE:FALSE;
}

BOOL MyRegistry::TestKey()
{
        HKEY hKey;
        m_lastError = RegOpenKeyExA(m_hKey,m_postFixKey,0,KEY_READ,&hKey);
        if (m_lastError==ERROR_SUCCESS)
        {
                RegCloseKey (hKey);
                return TRUE;
        }
        return FALSE;
}

// ****************************************************************************

BOOL MyRegistry::TestValue(char *param)
{
        HKEY hKey ;
        ULONG uType = REG_SZ ;
        DWORD dwSize=0;
        
        m_lastError = RegOpenKeyExA(m_hKey,m_postFixKey,0,KEY_QUERY_VALUE,&hKey);
        if (m_lastError!= ERROR_SUCCESS) return FALSE;
        m_lastError = RegQueryValueExA (hKey,param,NULL,NULL,NULL,NULL);
        RegCloseKey (hKey) ;
        return m_lastError==ERROR_SUCCESS;
}

int MyRegistry::GetValueSize(char *param)
{
        HKEY hKey ; 
        DWORD dwSize;

        m_lastError = RegOpenKeyExA(m_hKey,m_postFixKey,0,KEY_QUERY_VALUE ,&hKey);
        if (m_lastError!= ERROR_SUCCESS) return FALSE;
        m_lastError = RegQueryValueExA (hKey,param,NULL,NULL,NULL,&dwSize);
        RegCloseKey (hKey) ;

        return dwSize;
}

int MyRegistry::GetValueType(char *param)
{
        HKEY hKey ; 
        ULONG uType;

        m_lastError = RegOpenKeyExA(m_hKey,m_postFixKey,0,KEY_QUERY_VALUE ,&hKey);
        if (m_lastError!= ERROR_SUCCESS) return FALSE;
        m_lastError = RegQueryValueExA (hKey,param,NULL,&uType,NULL,NULL);
        RegCloseKey (hKey) ;

        return uType;
}

LPBYTE MyRegistry::GetValue(char *param ,DWORD uTypeResult)
{
        HKEY hKey ; 
        DWORD dwSize;
        ULONG uType;
        LPBYTE result;

        m_lastError = RegOpenKeyExA(m_hKey,m_postFixKey,0,KEY_QUERY_VALUE,&hKey);
        if (m_lastError!=ERROR_SUCCESS) return FALSE;
        m_lastError = RegQueryValueExA (hKey,param,NULL,&uType,NULL,NULL);
        if (m_lastError!=ERROR_SUCCESS || uTypeResult!=uType) { RegCloseKey (hKey); return FALSE; }
        m_lastError = RegQueryValueExA (hKey,param,NULL,NULL,NULL,&dwSize);
        if (m_lastError!=ERROR_SUCCESS) { RegCloseKey (hKey); return FALSE; }
        result = new BYTE[dwSize];
        ZeroMemory(result,dwSize);
        m_lastError = RegQueryValueExA (hKey,param,NULL,&uType,result,&dwSize);
        RegCloseKey (hKey);
        return m_lastError==ERROR_SUCCESS?result:NULL;
}

BOOL MyRegistry::GetValue(char *param , char *result , char *defValue)
{ 
        if (result) result[0]='\0';
        else return FALSE;
        MyString temp;
        temp=result;
        if (GetValue(param,temp,defValue)) 
        {
                strncpy(result,temp.GetValue(),temp.GetSize()+1);
                return TRUE;
        }
        else return FALSE;
}

BOOL MyRegistry::GetValue(char *param, MyString &result , char *defValue)
{
        LPBYTE res=NULL;
        DWORD uType = GetValueType(param);
        result="";

        switch (uType)
        {
                case REG_SZ:
                case REG_EXPAND_SZ:
                        res = GetValue(param,uType); 
                        if (!res) break;
                        result=(char *)res;
                        delete res;
                        return TRUE;

                case REG_MULTI_SZ: // retire tout les \0 qui separe les lignes
                        res = GetValue(param,uType); 
                        if (!res) break;
                        int size;
                        size = GetValueSize(param);
                        for (int i=0;i<size;i++)
                        {
                                if (res[i]=='\0') result<<' ';
                                else result+=(char)res[i];
                        }
                        result.Delete(-1,FALSE,1); // supression du dernier ' '
                        delete res;
                        return TRUE;
        }
        if (defValue) result = defValue;
        else result ="";
        return FALSE;
}

BOOL MyRegistry::GetValueMulti(char *param, MyList<MyString> &result , char *defValue)
{
        result.i.SuprAll();
        LPBYTE res = GetValue(param,REG_MULTI_SZ); 
        if (!res) 
        {
                MyString temp;
                if (!defValue) 
                {
                        temp = defValue;
                        result.i+=temp;
                }
                else result.i+=temp;
                return FALSE;
        }

        MyString current;
        int size = GetValueSize(param);
        current=(char *)res;
        if (size!=1)result.i+=current; // car ou c'est vide
        for (int i=0;i<size-1;i++)
        {
                if (res[i]=='\0')
                {
                        current=(char *)res+i+1;
                        result.i+=current;
                }
        }
        delete res;
        return TRUE;
}

BOOL MyRegistry::GetValueExpand(char *param, char *result , char *defValue)
{
        MyString temp;
        BOOL r = GetValueExpand(param,temp,defValue);
        strcpy(result,temp);
        return r;
}

BOOL MyRegistry::GetValueExpand(char *param, MyString &result , char *defValue)
{
        LPBYTE res = GetValue(param,REG_EXPAND_SZ); 
        if (!res) 
        {
                if (defValue) result = defValue;
                else result = "";
                return FALSE;
        }
        int newSize = ExpandEnvironmentStrings((LPCSTR)res,NULL,0);
        char *resExpand = new char[newSize];
        ExpandEnvironmentStrings((LPCSTR)res,resExpand,newSize);
        result=resExpand;
        delete resExpand;
        delete res;
        return TRUE;
}

BOOL MyRegistry::GetValue(char *param,int *result,int defValue)
{ 
        return GetValue(param,(DWORD *)result,defValue);
}

BOOL MyRegistry::GetValue(char *param,DWORD *result,DWORD defValue)
{
        DWORD uType = GetValueType(param);
        if (uType!=REG_DWORD && uType!=REG_DWORD_LITTLE_ENDIAN && uType!=REG_DWORD_BIG_ENDIAN) 
        {
                *result = defValue;
                return FALSE;
        }
        LPBYTE res = GetValue(param,uType); 
        if (res) 
        {
                *result=*(DWORD *)res;
                delete res;
                return TRUE;
        }
        *result = defValue;
        return FALSE;
}

BOOL MyRegistry::GetValue(char *param,LONGLONG *result, LONGLONG defValue)
{
        DWORD uType = GetValueType(param);
        if (uType!=REG_QWORD && uType!=REG_QWORD_LITTLE_ENDIAN) return FALSE;
        LPBYTE res = GetValue(param,uType); 
        if (res) 
        {
                *result=*(LONGLONG *)res;
                delete res;
                return TRUE;
        }
        *result = defValue;
        return FALSE;
}

BOOL MyRegistry::GetValue(char *param,float *result,float defValue)
{
        MyString temp,defValueString;
        defValueString=defValue;
        BOOL res = GetValue(param,temp,defValueString);
        *result = temp.ToFloat();
        return res;
}

BOOL MyRegistry::GetValue(char *param,double *result,double defValue)
{
        MyString temp,defValueString;
        defValueString=defValue;
        BOOL res = GetValue(param,temp,defValueString);
        *result = temp.ToDouble();
        return res;
}

LPBYTE MyRegistry::GetValue(char *param) 
{
        switch (GetValueType(param))
        {
                case REG_BINARY: return GetValue(param,REG_BINARY);
                case REG_NONE: return GetValue(param,(DWORD)REG_NONE)?(LPBYTE)TRUE:(LPBYTE)FALSE;
                default:return FALSE;
        }
}

BOOL MyRegistry::SetValue(char *param,LPBYTE source,ULONG uTypeSource,ULONG sizeSource)
{
        HKEY hKey ; 

        m_lastError = RegOpenKeyExA(m_hKey,m_postFixKey,0,KEY_SET_VALUE,&hKey);
        if (m_lastError!= ERROR_SUCCESS) return FALSE;
        m_lastError = RegSetValueExA (hKey, param, NULL, uTypeSource , source, sizeSource);
        RegCloseKey (hKey) ;
        return m_lastError== ERROR_SUCCESS?TRUE:FALSE;
}

BOOL MyRegistry::SetValue(char *param)
{ return SetValue(param,NULL,REG_NONE,0); }

BOOL MyRegistry::SetValue(char *param,int value)
{ return SetValue(param,(DWORD)value); }

BOOL MyRegistry::SetValue(char *param,DWORD value)
{ return SetValue(param,(LPBYTE)&value,REG_DWORD,4); }

BOOL MyRegistry::SetValueLittleEndian(char *param,DWORD value)
{ return SetValue(param,(LPBYTE)&value,REG_DWORD_LITTLE_ENDIAN,4); }

BOOL MyRegistry::SetValueBigEndian(char *param,DWORD value)
{ return SetValue(param,(LPBYTE)&value,REG_DWORD_BIG_ENDIAN,4); }

BOOL MyRegistry::SetValue(char *param,LONGLONG value)
{ return SetValue(param,(LPBYTE)&value,REG_QWORD,8); }

BOOL MyRegistry::SetValueLittleEndian(char *param,LONGLONG value)
{ return SetValue(param,(LPBYTE)&value,REG_QWORD_LITTLE_ENDIAN,8); }

BOOL MyRegistry::SetValue(char *param,char *value)
{ return SetValue(param,(LPBYTE)value,REG_SZ,(int)strlen(value)+1); }

BOOL MyRegistry::SetValueExpand(char *param,char *value)
{ return SetValue(param,(LPBYTE)value,REG_EXPAND_SZ,(int)strlen(value)+1); }

BOOL MyRegistry::SetValueMulti(char *param,char *str)
{
        BOOL isZero = FALSE;
        int size;
        for (size=0;;size++)
                if (str[size]=='\0') 
                        if (isZero) break;
                        else isZero=TRUE;
                else isZero=FALSE;

        return SetValue(param,(LPBYTE)str,REG_MULTI_SZ,size);
}

BOOL MyRegistry::SetValueMulti(char *param,MyList<MyString> &lString)
{ 
        MyString res;
        for (lString.i=0;lString.i.More();lString.i++) 
                res<<lString.i.GetElem()<<'\1';
        for (int i=0;i<res.GetSize();i++) if (res[i]=='\1') res[i]='\0';
        return SetValueMulti(param,res); 
}

BOOL MyRegistry::SetValue(char *param,float value)
{ 
        MyString temp;
        temp = value;
        return SetValue(param,temp); 
}

BOOL MyRegistry::SetValue(char *param,double value)
{ 
        MyString temp;
        temp = value;
        return SetValue(param,temp); 
}

BOOL MyRegistry::SetValue(char *param,LPBYTE data,int size)
{ return SetValue(param,data,REG_BINARY,size); }


// *************************************************************************************

BOOL MyRegistry::NextEnumKey (char *result)
{
        MyString str;
        BOOL res = NextEnumKey(str);
        strcpy(result,str.GetValue());
        return res;
}

BOOL MyRegistry::NextEnumKey(MyString &result)
{
        HKEY hKey ; 
        char res[261]; // taille max d'un nom de valeur
        DWORD size=261;
        result="";

        m_lastError = RegOpenKeyExA(m_hKey,m_postFixKey,0,KEY_ENUMERATE_SUB_KEYS,&hKey);
        if (m_lastError!= ERROR_SUCCESS) return FALSE;
        m_lastError = RegEnumKeyA(hKey,m_numEnumKey++,res,261);
        RegCloseKey (hKey);
        if (m_lastError==ERROR_SUCCESS)
        {
                result = res;
                return TRUE;
        }
        else
        {
                if (m_lastError==ERROR_NO_MORE_ITEMS) m_lastError = ERROR_SUCCESS;
                result="";
                return FALSE;
        }
}

// *************************************************************************************

BOOL MyRegistry::NextEnumValue (char *result)
{
        MyString str;
        BOOL res = NextEnumValue(str);
        strcpy(result,str.GetValue());
        return res;
}

BOOL MyRegistry::NextEnumValue (MyString &result)
{
        HKEY hKey ; 
        char res[261]; // taille max d'un nom de valeur
        DWORD size=261;
        result="";

        m_lastError = RegOpenKeyExA(m_hKey,m_postFixKey,0,KEY_QUERY_VALUE,&hKey);
        if (m_lastError!=ERROR_SUCCESS) return FALSE;
        m_lastError = RegEnumValueA(hKey,m_numEnumValue++,res,&size,NULL,NULL,NULL,NULL);
        RegCloseKey (hKey);     
        if (m_lastError==ERROR_SUCCESS) 
        {
                result = res;
                return TRUE;
        }
        else
        {
                if (m_lastError==ERROR_NO_MORE_ITEMS) m_lastError = ERROR_SUCCESS;
                result="";
                return FALSE;
        }
}

/* *************************************************************************************
        Ex.:
        MyRegistry reg("mySoftware");
        MyString string = reg("myParam1","getstring");
        reg("myParam2","setint")=12;
************************************************************************************* */
/*
MyString & MyRegistry::operator() (char *param,char *typeAction);
{
        MyString temp = typeAction;
        int interger;

        if (temp=="rint") 
        { 
                GetValue(param,&integer); 
                m_result = interger; 
                return m_result; 
        }
        else if (temp=="rstring") 
        { 
                GetValue(param,m_result); 
                return m_result; 
        }

        else if (temp=="wint") 
        { 
                SetValue(param,integer); 
        }
}
*/

---