Gere Le registre comme un arbre un peu a la manière d'un parseur xml
Permet de créé, supprimer et modifier clef, sous clef et valeurs
Classe :
CTreeReg : Prend les infos sur la première branche et
crée le tree, retourne un ptr sur la
1ere branche
CNodeReg : Chaque tree est composé d'une node mére et
de nodes fils, cet objett reprensente une node
qui peut avoir des fils ou pas, chaque node
connait sont pére et la liste de ces fils
CKeyReg : CNodeReg dervive de cette classe, car chaque node
est aussi une clef. Chaque clef contient la liste
de ces valeurs.
(cette classe et transparente pour l'utilisateur)
CValReg : C'est le dernier element, chaque objet de cette
classe représente une valeur dans la bdr.
Cette classe gere la création, la modification
et la suppresion de valeurs dans le registre
CKeyReg contient un liste de CValReg
(cette classe et transparente pour l'utilisateur)
CDWORDReg
CStringReg
CBinaryReg
CMultiStringReg : Derive de CValReg et contienne
les données de la valeurs
Exemple d'utilisation :
CTreeReg TreeTest;
CNodeReg * pFirstNode = TreeTest.CreateTree("SOFTWARE\\Adobe",HKEY_LOCAL_MACHINE);
pFirstNode seront donc adobe vous pouvrer ensuite naviger dans les clef et les sous clef et aussi gerer les valeur de chaque clef
Il faut ajouter /Gr ds les option de compilation
Ecrit avec vc6
Source / Exemple :
//---------------------------------------------------------------------
class CKeyReg;
class CTreeReg;
class CValReg
{
friend class CKeyReg; //pour eviter que certaines fct soit publique
friend class CTreeReg;
public:
/**********************************************************
Ces fct peuvent etre utilisées directement depuis un
ptr sur un CValReg
virtual ~CValReg() {};
//Retourne la clef qui contient cette valeur
CKeyReg * GetValKey() const {return m_pOnKey;}
//Retourne le Nom, le type et les data de la valeur
CString GetValName() const {return m_strValName;}
//Retourne le type de la valeur
int GetValType() const {return m_iTypeVal;}
//Retourne un ptr sur le CTreeReg
CTreeReg * GetTree();
protected :
/**********************************************************
Ces fct ne doivent pas etre utiliser
directement, elle sont donc protected
//Constructeur
CValReg(CKeyReg * pKey, CString strValName, int iTypeVal);
//Supprime cette valeur ds le registre
//Ne pas Appeler directement
bool DeleteThisKey();
//Retourne vrai si la valeur existe ds le registre
bool IsExistInReg();
virtual CString GetValString() const { return "Bad Type";}
virtual bool SetValData(void * pData) = 0;
virtual bool SetValName(CString strNewName) = 0;
virtual DWORD GetValDWORD (bool bHexa = true) const { return VAL_BAD_TYPE;}
virtual const CList<CString,CString> * GetValMultiString() const {return NULL;}
virtual const CList<BYTE,BYTE> * GetValBinary() const {return NULL;}
protected :
CString m_strValName;//Nom de la valeur
int m_iTypeVal;//Type DWORD, REG_SZ, BINARY...
int m_iValSize;//taille des data
CKeyReg * m_pOnKey;//ptr sur la clef contenant la valeur
};
//------------------------------------------------------------
class CKeyReg
{
public:
CKeyReg(HKEY hKey, int iType);
virtual ~CKeyReg();
/***********Ajout de valeurs*******************/
//Ajoute une valeur a la clef
int AddValueEx(CString strValName, int iType, void * pData);
//Ajoute une valeur de type REG_SZ a la clef
int AddValue(CString strValName, CString strData);
//Ajoute une valeur de type DWORD a la clef
//La valeur dans le DWORD doit etre en hexa
int AddValue(CString strValName, DWORD dwData);
//Ajout une valeur de type REG_MULTI_SZ
int AddValue(CString strValName, CList<CString,CString> * pList);
//Ajout une valeur de type REG_BINARY
int AddValue(CString strValName, CList<BYTE,BYTE> * pList);
/**********************************************/
/************Recuperation des valeurs***********/
//Recupere la première valeur de la liste
POSITION GetFirstValue();
//Récupere la valeur suivante ds la liste
CValReg * GetNextValue(POSITION &pos);
//Retourne les données d'une valeur DWORD (REG_DWORD)
DWORD GetValueDWORD(CString strValName, bool bHexa = true);
//Retourne les données d'une valeur string (REG_SZ)
CString GetValueString(CString strValName);
//Retourne un ptr constant sur la liste des
//chaines d'une valeur (REG_MULTI_SZ)
const CList<CString,CString> * GetValueStringList(CString strValName);
//Retourne la chaine a l'index iIndex dans la liste de string
//pour une valeur de type REG_MULTI_SZ
//Retourne une chaine vide si index hors bornes
CString GetValueStringFromList(CString strValName,int iIndex);
//Retourne un ptr constant sur la liste des
//BYTE d'une valeur (REG_BINARY)
const CList<BYTE,BYTE> * GetValueBinary(CString strValName);
//Remplit le tableau de BYTE avec les données de la valeur
//retourne la taille du tableau
BYTE * GetValueTabBinary(CString strValName, int * p_iSize);
//Retourne une valeur par sont nom
//Retourne le ptr sur la classe CValReg
CValReg * GetValueByName(CString strValName);
//Retourne le type de la valeur en param
int GetValueType(CString strValName);
/**********************************************/
/**********Modification des valeurs************/
//Toutes ces fct retourne VAL_NOT_EXIST si
//vous essayer de modifier une valeur
//qui n'existe pas
//Ces 2 fct retourne VAL_BAD_TYPE si vous essayer de modifier
//une valeurs du mauvais type ( par ex passer un CString alors
//que la valeur est de type DWORD)
int ChangeValueData(CString strValName, CString strNewString);
int ChangeValueData(CString strValName, DWORD dwNewWord);
//La liste et copier ds la memoire par la fct
//Vs pouvez passer un ptr sur une variable en mem ds la pile
int ChangeValueData(CString strValName, CList<CString,CString> * pList);
//Permet d'ajouter une chaine a la liste d'un valeur de type
//REG_MULTI_SZ, bAddHead = true pour ajouter en debut de liste
int ChangeValueAddString(CString strValName, CString strData, bool bAddHead = false);
//La liste et copier ds la memoire par la fct
//Vs pouvez passer un ptr sur une variable en mem ds la pile
int ChangeValueData(CString strValName, CList<BYTE,BYTE> * pList);
//Remplace le nom d'une valeur retourne VAL_NAME_EXIST
//si le nom existe deja
int ChangeValueName(CString strValName, CString strValNewName);
/**********************************************/
/************Suppresion des valeurs*************/
//Supprime une valeur en fct de sont nom
bool DeleteValue(CString strValName);
//Supprime toutes les valeurs de la clef
bool DeleteAllKeyValues();
/***************** Autres ***********************/
//Retourne le nom de la clef
CString GetKeyName() {return m_strKeyName;}
//Retourne la date de dernière modif de la clef
SYSTEMTIME GetLastModifTime() {return m_SysTime;}
//Retourne le nbr de valeurs pour cette clef
int GetNbVal() {return m_MapValues.GetCount();}
//Retourne le HKEy de la clef
HKEY GetHKEY() {return m_hKey;}
/**************************************************/
//Fct non utilisateur
//Reconnecte un valeur a la clef
void ReconnectValue(CValReg * pVal);
private :
//Lit les infos de la clef
void ReadKeys(HKEY hKey);
//Crée un nouvelle clef
void CreateKey(HKEY hKey);
//Supprime une clef dans la map
bool DeleteInMap(CValReg * pVal);
//Changes les données de la valeur
int ChangeValueDataEx(CString strValName, void * pData);
protected :
HKEY m_hKey;
CString m_strKeyName;//Nom de la clef
int m_iNextIndex;//index de la prochaine clef
SYSTEMTIME m_SysTime; //Date de dernière modif
//Map contenant toutes les valeurs de la clef
CMap<int, int, CValReg*, CValReg*> m_MapValues;
};
//------------------------------------------------------------
class CTreeReg;
class CNodeReg : public CKeyReg
{
public:
virtual ~CNodeReg();
//Créé ou lit une node et tous ces fils
CNodeReg(HKEY hKey, HKEY hCommunKey, CString strPath, CString strNodeName, CNodeReg * pParentNode, int iType, CTreeReg * pTree);
/************** Navigation ds l'arbre *************************/
//Retourne un ptr sur la node parent
CNodeReg * GetParentNode() const;
//Retourne un ptr sur une node enfant en fct de sont HKEY
CNodeReg * GetChildNodeByKey(HKEY hKey);
//Retourne un ptr sur une node enfant en fct de sont Nom
CNodeReg * GetChildNodeByName(CString strNodeName);
//Retourne le premier fils de la node
POSITION GetFirstChildNode();
//Retourne le fils suivant
CNodeReg * GetNextChildNode(POSITION &pos);
//retourne vrai si la node a des fils
bool IsFatherNode() const {return m_bIsFatherNode;}
/**************************************************************/
/********************** Ajout *********************************/
//Ajoute une node fils a la node en cour
//Retourne un ptr sur cette node si ok sinon null
//un code d'erreur sera mis ds iRet sauf si Null
CNodeReg * AddChildNode(CString strChildNodeName, int * iRet = NULL);
/**************************************************************/
/********************** Suppresion ****************************/
//Supprime un node fils de la node en cour
bool DeleteChildNode(CString strChildNodeName);
//Supprime tous les fils de la node en cour
bool DeleteAllChildNode();
//Supprime la node en cour (Attention le ptr sera null ensuite)
bool DeleteThisNode();
/**************************************************************/
//Retourne le nbr de fils pour cette node
int GetNbrChildNode () {return m_MapChildNode.GetCount();}
//Retourne le path de la node
CString GetPath() {return m_strPath;}
//Sauvgarde cette node, tous ces fils et toutes leurs valeurs
//dans un fichier
bool SaveNodeInFile(CString m_strFileName);
/*************************************************************
Fct interne (l'utilisateur ne devrez pas les appeller)
//Retourne le nom du fils de la clef HKEY en fct de l'index
//(Attention l'index n'est pas ds l'odre d'affichage)
static CString GetChildName(HKEY &hKey, int iIndex);
//Retourne un ptr constant sur la liste des node enfant
//Utiliser plutot les fa fct GetChildNodeByName
const CMap<HKEY, HKEY, CNodeReg*, CNodeReg*> * GetPtrOnChildList() const {return &m_MapChildNode;}
//Vide la liste des nodes enfants (utiliser ds CTreeReg)
//ATTENTION : A manier avec precaution sinon Memory Leak
//Normalement l'utilisateur ne doit pas l'utiliser
void ClearNodeList() {m_MapChildNode.RemoveAll();}
//Met a NULL le pere de la node m_pParentNode
//Utiliser ds CTreeReg
void ClearParentNode() {m_pParentNode = NULL;}
//Retourne le ptr sur CTreeReg
CTreeReg * GetTreeReg() {return m_pTree;}
//Retourne le hTreeItem de la node ds le tree associer
HTREEITEM GethTreeItem(){return m_hNodeItem;}
//maj du hTreeItem de la node ds le tree associer
void SethTreeItem(HTREEITEM hItem) {m_hNodeItem = hItem;}
private :
//Supprime la node en param de la map
//Fait un DELETE sur la node
bool DeleteInMap(CNodeReg * pNode);
//Crée une nouvelle node
void CreateNode(HKEY hKey, HKEY hCommunKey, CString strPath, CString strNodeName, CNodeReg * pParentNode);
//Lit la node
void ReadReg(HKEY hKey, HKEY hCommunKey, CString strPath, CString strNodeName, CNodeReg * pParentNode, int iType);
//Supprime la clef du registre
//Ne pas Appeler directement
bool DeleteInReg();
protected :
CMap<HKEY, HKEY, CNodeReg*, CNodeReg*> m_MapChildNode;
CString m_strPath;//Chemin de la node
bool m_bIsFatherNode;//A vrai si la node a des fils
CTreeReg * m_pTree; //ptr sur le treeReg
CNodeReg * m_pParentNode;//Ptr sur la node parent
HKEY m_hCommunKey;//Clef Commune (HKEY_LOCAL_MACHINE par exemple)
//Pour le cas ou on utilise le linkedTreeCtrl
HTREEITEM m_hNodeItem;
};
//------------------------------------------------------------
class CTreeReg
{
public:
CTreeReg();
virtual ~CTreeReg();
/********************** Fct de Gestion ****************************/
//Permet de choisir le chemin du registre a analyser
//strPath doit contenir le chemin complet (Ex : "SOFTWARE\\Adobe\CommunFile")
//bCreate si le chemin n'existe pas il sera créé
//Retourne un ptr sur la première node
//ATTENTION : La première node sera la dernière clef du chemin
//(Ex : "SOFTWARE\\Adobe\CommunFile") la première node sera "CommunFile"
//Meme si elle n'existait pas et qu'elle a été créé, dans ce cas la première
//node n'aura logiquement aucune valeurs ni aucun fils
//ATTENTION 2 : si vous passer un path comm SOFTWARE seul qui contient enormement de clef
//vous risquer d'avoir un Memory Overflow.
CNodeReg * CreateTree(CString strPath, HKEY hCommunKey = HKEY_LOCAL_MACHINE, bool bCreate = false);
//Retourne un ptr sur la node de plus haut niveau
//(Celle qui contient toutes les autres, Celle retourné par CreateTree())
CNodeReg * GetPtrOnFistNode() const {return m_pFirstNode;}
//Savgarde l'arbre ds un fichier reg
bool SaveTreeInFile(CString m_strFileName);
/********************************************************************/
/************************* Valeur virtuelle **************************/
//Si vrai a chaque modif, ajout, suppr de valeurs ds l'abre,
//le registre n'est pas mit a jour et il le sera qu'a l'appel
//de WriteVirtualValues()
//ATTENTION : Si vs appeler UseVirtualValues(false) sans avoir
//fait un WriteVirtualValues() avant , sinon les modif seront perdu !!
void UseVirtualValues(bool bVirtualVal = true);
//Efface la dernière action sur une valeurs (en mode virtual value)
//bool Undo();
//Ecrit les valeurs virtuelle ds le registre
bool WriteVirtualValues();
//----------------------------------------------------------
//Fct non utilisateur (utiliser pour le traitement interne)
//----------------------------------------------------------
//Indique si on est en mode virtuel ou pas
bool IsVirtualVal() {return m_bVirtualVal;}
//Ajoute / supprime a la liste des valeurs virtuelle
bool DelFromVirtualList(CValReg * pVal);
void AddToVirtualList(CValReg * pVal);
void AddToVirtualDeadList(CValReg * pVal);
/*******************************************************************/
/********************** Fct de Recherches ***************************/
//Retourne chaque node ayant le nom du strKeyName
const CList<CNodeReg*,CNodeReg*> * FindKeysByName(CString strKeyName);
//Retourne chaque valeur ayant le Nom strValName
const CList<CValReg*,CValReg*> * FindValuesByName(CString strValName);
//Retourne la node correspondante au hKey
CNodeReg * FindKeyByhKey(HKEY hKey);
/*******************************************************************/
/********************* Tree Ctrl ***********************************/
//Permet d'assosier le treeReg a un treeCtrl
//bAssocied -> chaque modif ds le treereg est reporter ds le treeCtrl
//bConstruct -> Construit le tree imediatement
//bClearTree -> Vide le tree avant de commancé
int SetLinkedTreeCtrl(CTreeCtrl * pTreeCtrl, bool bAssocied = true, bool bConstruct = false, bool bClearTree = true);
//a utiliser apres SetLinkedTreeCtrl pouyr construire le treeCtrl si bConstruct etait a false
int ConstructTreeCtrl();
//retourne vrai si le treeReg est associer avec un treeCtrl
bool IsAssociedTree() {return m_bAssociedTree;}
//Ajoute un item ds le treeCtrl Assosier
HTREEITEM AddItemInLinkedTree(HTREEITEM hFatherItem, CNodeReg * pNode);
//Supprime un item ds le treeCtrl Assosier
int DeleteItemInLinkedTree(HTREEITEM hItem);
private :
//créé recursivement le tree ctrl
void RecursifTreeCreate(CNodeReg * pNode,HTREEITEM hFatherItem);
/******************************************************************/
private :
//Retourne la liste des clef dans le path
//Chaques entrées dans le vecteur correspont
//a une clef du chemin strPath
std::vector<CString> GetKeysList(CString strPath);
//fct recursive utiliser pour parcourir toutes les branches de l'arbre
void GetNext(CNodeReg * pNode, int iSearchType);
protected :
//Var de gestion de l'arbre
CNodeReg * m_pFirstNode;//Pointeur le la première node
CString m_strStartNodeName; //Nom de la première node
CString m_strPath; //Chemin de la première node
HKEY m_hCommunKey;//Clef commune
HKEY m_hStartKey; //Clef de la première node
bool m_bValidPath;//A vrai si le chemin de SetTreeStart existe
bool m_bVirtualVal;//créé des valeurs virtuelle si a vraix
//Var de recherche
CString m_strFind;
CList<CNodeReg*,CNodeReg*> m_FindNodeList;//Liste de node correspondant a la recherche
CList<CValReg*,CValReg*> m_FindValueList;//Liste de valeurs correspondant a la recherche
HKEY m_hSearchKey;
CNodeReg * m_pSearchNode;
//Liste des valeurs virtuele
CList<CValReg*,CValReg*> m_VirtualValList; //Liste des vleur a ajouter ou modifier
CList<CValReg*,CValReg*> m_VirtualValToDelList; //liste des valeurs a supprimer
int m_iOldAction;//utiliser pour les val virtuelles
//Pour le TreeCtrl
CTreeCtrl * m_pLinkedTree;// ptr vers le treectrl associer
bool m_bUseTreeCtrl;//a vrai si on utilise le treectrl
bool m_bAssociedTree;//a vrai si il faut mettre a jour le treectrl lors d'un modif
};
/************************************************************************
- Classe type de données ************************
- (Herites toutes de CValReg) ********************
//---------------------------------------------------------------------
class CDWORDReg : public CValReg
{
public:
CString GetName();
//Lit une valeur
CDWORDReg(CKeyReg * pKey, CString strValName);
//Ecrit une Valeur
CDWORDReg(CKeyReg * pKey, CString strValName, DWORD dwData);
//Change les datas
virtual bool SetValData(void * pData);
//Change le nom de la valeur
virtual bool SetValName(CString strName);
//Retourne la valeur sous forme hexa si bHexa = true
//ou sous forme decimale bHexa = false
virtual DWORD GetValDWORD(bool bHexa = true) const;
protected :
DWORD m_dwValue; //données de la valeur
};
//---------------------------------------------------------------------
class CStringReg : public CValReg
{
public :
//Lit une valeur
CStringReg(CKeyReg * pKey, CString strValName);
//Ecrit une Valeur
CStringReg(CKeyReg * pKey, CString strValName, CString strData);
//Change les datas
virtual bool SetValData(void * pData);
//Change le nom de la valeur
virtual bool SetValName(CString strName);
//Retourne la valeur CString
virtual CString GetValString() const;
protected :
CString m_strValue; //données de la valeur
};
//---------------------------------------------------------------------
class CMultiStringReg : public CValReg
{
public :
//Lit une valeur
CMultiStringReg(CKeyReg * pKey, CString strValName);
//Ecrit une Valeur
CMultiStringReg(CKeyReg * pKey, CString strValName, CList<CString,CString> * p_strDataList);
//Ajoute une chaine a la liste
bool AddStringToList(CString strData, bool bAddHead);
//Retourne la chaine d'index iIndex dans la liste
CString GetStringFromList(int iIndex);
//Change les data
virtual bool SetValData(void * pData);
//Change le nom de la valeur
virtual bool SetValName(CString strName);
//Retourne la valeur sous forme d'une CList
virtual const CList<CString,CString> * GetValMultiString() const;
private :
//Remplit m_strValueList a partir des données du registre
void MakeList(unsigned char * pUChar);
//retourne un ptr sur un chaine formater pour etre ecrite ds le registre
unsigned char * MakeListForReg();
//Vide la liste m_strValueList
void EmptyList();
//Copy la list en param dans m_strValueList
void CopyList (CList<CString,CString> * p_strDataList);
protected :
CList<CString,CString> m_strValueList; //données de la valeur
bool m_bNewData; //a faux si les data n'ont pas changer
};
//---------------------------------------------------------------------
class CBinaryReg : public CValReg
{
public :
//destructeur
virtual ~CBinaryReg();
//Lit une valeur
CBinaryReg(CKeyReg * pKey, CString strValName);
//Ecrit une Valeur
CBinaryReg(CKeyReg * pKey, CString strValName, CList<BYTE,BYTE> * pList);
//Change les datas
virtual bool SetValData(void * pData);
//Change le nom de la valeur
virtual bool SetValName(CString strName);
//Retourne un Clist contenant chaque byte
virtual const CList<BYTE,BYTE> * GetValBinary() const;
//Remplit le tableau avec les données de la liste
//Retourne la taille du tableau
BYTE * GetValTabBinary(int * p_iSize);
private :
void CopyList(CList<BYTE,BYTE> * p_byDataList);
BYTE * CBinaryReg::MakeByteTabForReg();
protected :
CList<BYTE,BYTE> m_bytValueList; //données de la valeur
BYTE * m_pByteTab;
bool m_bNewData;
};
Conclusion :
Un certain nombre de variable sont instanciées sur la pile ce qui risque de provoquer un stack overflow si vous essayer d'ouvrir un clef avec trop de sous clef comme SOFTWARE en entier par ex
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.