TREEREG (GESTION DU REGISTRE COMME UN ARBRE)

//---------------------------------------------------------------------
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;
};