internet explorer skinner

  1. // RegistreUtil.cpp: implementation of the CRegistreUtil class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  4.  
  5. #include "stdafx.h"
  6. #include "RegistreUtil.h"
  7. #include <string.h>
  8.  
  9. #ifdef _DEBUG
  10. #undef THIS_FILE
  11. static char THIS_FILE[]=__FILE__;
  12. #define new DEBUG_NEW
  13. #endif
  14.  
  15. //////////////////////////////////////////////////////////////////////
  16. // Construction/Destruction
  17. //////////////////////////////////////////////////////////////////////
  18.  
  19. CRegistreUtil::CRegistreUtil()
  20. {
  21.  
  22. }
  23.  
  24. CRegistreUtil::~CRegistreUtil()
  25. {
  26.  
  27. }
  28.  
  29. int CRegistreUtil::CreerCle (HKEY HK, char * cle) // Créé une clé dans la base de registre
  30. {
  31.         //---------------------------------------------------------------------
  32.         // créé une clé dans la base de registre !
  33.         // Dans la rubrique HK (ex : HKEY_CLASSES_ROOT), et de nom "clé"
  34.         // Pour créer des sous-clé, on peu directement taper :
  35.         // "cle01\\cle02\\cle03 ...." dans la variable "clé"
  36.         // La fonction crée directement les sous clés !
  37.         //---------------------------------------------------------------------
  38.  
  39.         SECURITY_ATTRIBUTES SecAtt;
  40.         SecAtt.nLength = sizeof (SECURITY_ATTRIBUTES);
  41.         SecAtt.lpSecurityDescriptor = NULL;
  42.         SecAtt.bInheritHandle = TRUE;
  43.  
  44.         HKEY Retour;
  45.         DWORD Action;
  46.  
  47.  
  48.         RegCreateKeyEx(HK,cle,0,"", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, & SecAtt, &Retour, &Action);
  49.  
  50.         RegCloseKey(Retour);
  51.  
  52.         return 0;
  53. }
  54.  
  55. int CRegistreUtil::DetruitCle (HKEY HK, char * cle) // Détruire une clé dans la base de registre
  56. {
  57.         //------------------------------------------------------------
  58.         // Cette fonction détruit une clé dans la base de registre !
  59.         // Vous ne pouvez détruir qu'une seule clé a la fois !
  60.         // et cette fonction ne détruit pas les sous clés !
  61.         //------------------------------------------------------------
  62.         RegDeleteKey(HK,cle);
  63.  
  64.         return 0;
  65.  
  66. }
  67.  
  68. int CRegistreUtil::EcrireTexte (HKEY HK, char * cle, char * nom, char * valeur) // Ecrit une valeur Texte dans une clé définie
  69. {
  70.         //------------------------------------------------------------
  71.         // Ecrit une valeur de type chaine de caractère dans la base de registre
  72.         // "nom" représente le nom de la valeur
  73.         // "valeur" représente la chaine de caractère
  74.         //------------------------------------------------------------
  75.  
  76.         SECURITY_ATTRIBUTES SecAtt;
  77.         SecAtt.nLength = sizeof (SECURITY_ATTRIBUTES);
  78.         SecAtt.lpSecurityDescriptor = NULL;
  79.         SecAtt.bInheritHandle = TRUE;
  80.  
  81.         HKEY Retour;
  82.         DWORD Action;
  83.  
  84.         RegCreateKeyEx(HK,cle,0,"", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, & SecAtt, &Retour, &Action);
  85.  
  86.        
  87.         RegSetValueEx(Retour,nom,0,REG_EXPAND_SZ ,(unsigned char *)valeur,strlen(valeur)+1);
  88.  
  89.  
  90.         RegCloseKey(Retour);
  91.  
  92.         return 0;
  93. }
  94.  
  95.  
  96. int CRegistreUtil::EcrireNombre (HKEY HK, char * cle, char * nom, long valeur) // Ecrit une valeur numérique dans la base de registre
  97. {
  98.         //------------------------------------------------------------
  99.         // Idem EcritTexte, mais la valeur est un nombre
  100.         //------------------------------------------------------------
  101.  
  102.         SECURITY_ATTRIBUTES SecAtt;
  103.         SecAtt.nLength = sizeof (SECURITY_ATTRIBUTES);
  104.         SecAtt.lpSecurityDescriptor = NULL;
  105.         SecAtt.bInheritHandle = TRUE;
  106.  
  107.         HKEY Retour;
  108.         DWORD Action;
  109.  
  110.         RegCreateKeyEx(HK,cle,0,"", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, & SecAtt, &Retour, &Action);
  111.  
  112.        
  113.         RegSetValueEx(Retour,nom,0,REG_DWORD,(unsigned char *)&valeur,4);
  114.  
  115.  
  116.         RegCloseKey(Retour);
  117.  
  118.         return 0;
  119. }
  120.  
  121.  
  122. int CRegistreUtil::LitNombre(HKEY HK, char * cle, char * nom, long *valeur)     // Lit une valeur numérique dans la base de registre
  123. {
  124.         //------------------------------------------------------------
  125.         // récupère la valeur (numérique) de la valeur "nom", dans la clé "cle"
  126.         //------------------------------------------------------------
  127.  
  128.         HKEY Retour;
  129.         RegOpenKeyEx(HK,cle,0,KEY_ALL_ACCESS,&Retour);
  130.  
  131.         unsigned long taille = 4; // initialisation obligatoire pour WIN 95- 98
  132.         unsigned long type;
  133.         RegQueryValueEx( Retour,nom,NULL,&type,(unsigned char *)valeur,&taille);
  134.  
  135.         RegCloseKey(Retour);
  136.  
  137.         return 0;
  138.  
  139. }
  140.  
  141. int CRegistreUtil::LitTexte (HKEY HK, char * cle, char * nom, char * valeur,unsigned long taille) // Lit une valeur alphanumérique dans la base de registre
  142. {
  143.         //------------------------------------------------------------
  144.         // lit la valeur "nom" dans la clé "cle"
  145.         // La valeur est une chaine de caractère
  146.         // La variable TAILLE doit contenir la taille du buffer // IMPERATIF sous win 95-98
  147.         //------------------------------------------------------------
  148.  
  149.         HKEY Retour;
  150.         RegOpenKeyEx(HK,cle,0,KEY_ALL_ACCESS,&Retour);
  151.  
  152.         unsigned long type;
  153.         RegQueryValueEx( Retour,nom,NULL,&type,(unsigned char *)valeur,&taille);
  154.  
  155.         RegCloseKey(Retour);
  156.         return 0;
  157. }
  158.  
  159. int CRegistreUtil::EnumVal(HKEY HK, char * cle, char **TableauNom, char **TableauVal, int NMax , int MaxCar) // Récupères toutes les valeurs d'un clé de la base de registre
  160. {
  161.         //------------------------------------------------------------
  162.         // Cette fonction lit toutes les valeurs d'une même clé (dans la limite de NMax)
  163.         // La valeur MaxCar définie la taille maximum d'une valeur, ainsi que du nom de la valeur
  164.         //
  165.         // Les tableaux, correspondent au donnée récupérée dans la base !
  166.         // ATTENTION : LES TABLEAUX DOIVENT ETRES INITIALISES !!!
  167.         // leur taille doit être identique, et égale a NMAX,
  168.         // et chaque chaine du tableau doit être égale a MaxCar
  169.         //------------------------------------------------------------
  170.         HKEY Retour;
  171.         RegOpenKeyEx(HK,cle,0,KEY_ALL_ACCESS,&Retour);
  172.        
  173.         char * NomVal;
  174.         NomVal = new char[MaxCar];
  175.         char * Valeur;
  176.         Valeur = new char[MaxCar];
  177.         unsigned long NNom=MaxCar;
  178.         unsigned long NVal=MaxCar;
  179.         unsigned long Ty=0;
  180.         int n=0;
  181.         long Ret;
  182.  
  183.         do
  184.         {
  185.                 Ret =RegEnumValue( Retour,n,(char *)NomVal,&NNom,0,&Ty,(unsigned char *)Valeur,&NVal );
  186.        
  187.                 strcpy(TableauNom[n],NomVal);
  188.                 strcpy(TableauVal[n],Valeur);
  189.  
  190.                 n++;
  191.                 NNom = MaxCar;
  192.                 NVal = MaxCar;
  193.         } while ( (Ret != ERROR_NO_MORE_ITEMS) && (n<NMax) );
  194.  
  195.  
  196.         RegCloseKey(Retour);
  197.  
  198.         return n-1;
  199. }
  200.  
  201.  
  202. int CRegistreUtil::EnumCle(HKEY HK, char *cle, char **Tableau,int NMax,int MaxCar) // Liste toutes les sous-clés d'une même clé
  203. {
  204.         //------------------------------------------------------------
  205.         // Le tableau doit être initialisé a NMAX, et MaxCar
  206.         // NMAX, correspond au nombre maximum de sous clés
  207.         // MaxCar est la taille maximum du nom de la sous clé
  208.         //------------------------------------------------------------
  209.  
  210.         HKEY Retour;
  211.         RegOpenKeyEx(HK,cle,0,KEY_ALL_ACCESS,&Retour);
  212.        
  213.         char * NomVal;
  214.         NomVal = new char[MaxCar];
  215.         unsigned long NNom=MaxCar;
  216.         int n=0;
  217.         long Ret;
  218.  
  219.         do
  220.         {
  221.                 Ret =RegEnumKeyEx( Retour,n,NomVal,&NNom,NULL,NULL,NULL,NULL );
  222.        
  223.                 strcpy(Tableau[n],NomVal);
  224.        
  225.                 n++;
  226.                 NNom = MaxCar;
  227.  
  228.  
  229.         } while ( (Ret != ERROR_NO_MORE_ITEMS) && (n<NMax) );
  230.  
  231.  
  232.         RegCloseKey(Retour);
  233.         return n-1;
  234.  
  235.  
  236. }

contact - faire un lien