Sauvegarde des parametres de votre application

Télécharger le projet
Commenter

Description

Cette class permet de sauvegarder l'état de vos composants (TEDit, TCheckBox, TComboBox, et TListBox) et de les restaurer au prochain lancement de votre application. (A condition de le faire au bon evenements).

Source + Zip exemple !

Source / Exemple : 


{ --------------------------------------------------
	Elguevel (c) 2006
	
	Système de sauvegarde et restauration 
	de l'etat d'une application
	
	Ecrit Par LEVEUGLE Damien
	Avec Delphi 7 Personnel
	
  -------------------------------------------------- }

unit ElgRegistre;

interface

{ Librairies }
uses Windows, Classes, Registry, SysUtils, StdCtrls;

{ -------------- Ma classe TRegistre hérité de TRegistry  -------------- }

type TRegistre = class( TRegistry )

    private
      { Attributs }
      Path : String;  //  OpenKey();

      { Methodes privées }
      function  Slach   ( Chemin      : String ) : String;

      procedure SetListe( Liste       : TStrings; SousChemin : String );
      function  GetListe( SousChemin  : String ) : TStrings;

      procedure SetPath( NouveauChemin : String );
      property  GetPath : String Read Path;

    public
      { Constructeur }
      constructor Create; overload;
      constructor Create( Chemin : String ); overload;
      constructor Create( Chemin : String; ForcerEcriture : Boolean ); overload;

      { Methodes publics }
      procedure EcritCle( Cle : string; CEdit   : TCustomEdit     );  overload;
      procedure EcritCle( Cle : string; CCombo  : TCustomComboBox );  overload;
      procedure EcritCle( Cle : string; CCheck  : TCheckBox       );  overload;
      procedure EcritCle( Cle : string; CListBox: TCustomListBox  );  overload;

      procedure LireCle( Cle : string; CEdit    : TCustomEdit     );  overload;
      procedure LireCle( Cle : string; CCombo   : TCustomComboBox );  overload;
      procedure LireCle( Cle : string; CCheck   : TCheckBox       );  overload;
      procedure LireCle( Cle : string; CListBox : TCustomListBox  );  overload;

end;

{ ---------------------------------------------------------------------- }

const
    DEFAULT_REG_KEY    = 'Software\Elguevel\';    { Chemin par défault }

{ .CODE }    
implementation

// ****************************************
// ************ CONSTRUCTEUR *************
// ****************************************

{ Constructeur : ouvre le registre à la clé par default }
constructor TRegistre.Create();
begin
    inherited Create;
    RootKey := HKEY_CURRENT_USER;
    Path := DEFAULT_REG_KEY;
    OpenKey(DEFAULT_REG_KEY, True);
end;

{ Constructeur : ouvre le registre à la clé specifier }
constructor TRegistre.Create( Chemin : string );
begin
    if ( Trim(Chemin) = '' ) then Chemin := DEFAULT_REG_KEY;
    inherited Create;
    RootKey := HKEY_CURRENT_USER;
    Path := Chemin;
    OpenKey(Chemin, True);
end;

{ Constructeur : ouvre le registre à la clé specifier
  et offre la possibilité de forcer ou pas l'écriture de la clé }
constructor TRegistre.Create( Chemin : string; ForcerEcriture : boolean );
begin
    if ( Trim(Chemin) = '' ) then Chemin := DEFAULT_REG_KEY;
    inherited Create;
    RootKey := HKEY_CURRENT_USER;
    Path := Chemin;
    OpenKey(Chemin, ForcerEcriture);
end;

// *******************************************
// ************ METHODES PRIVEES *************
// *******************************************

{ Change chemin du registre courant }
procedure TRegistre.SetPath( NouveauChemin : string );
begin
    Path := Slach(NouveauChemin);
    CloseKey;
    OpenKey( Slach(NouveauChemin), True );
end;

{ Ecrit une TStringList dans une clé de registre }
procedure TRegistre.SetListe( Liste : TStrings; SousChemin : string ) ;
var
  I, J      : Cardinal;
  ListeReg  : TStrings;
  Memoire   : string;
begin
    try
        { Change chemin }
        Memoire := Path;
        SetPath( Slach(Path) + SousChemin );
        { Efface anciennes valeurs }
        ListeReg := TStringList.Create;
        GetValueNames( ListeReg );
        if ( ListeReg.Count > 0 ) then for I := 0 to ( ListeReg.Count - 1 ) do
        DeleteValue( ListeReg.Strings[I] );
        ListeReg.Free;
        {Reecrit nouvelle valeur dans sous chemin }
        if ( Liste.Count > 0 ) then for J := 0 to ( Liste.Count - 1 ) do
        WriteString( IntToStr(J), Liste.Strings[J] );
    finally
      { Retablie chemin d'origine }
      SetPath( Memoire );
    end;
end;

{ Recupere une clé de registre sous forme de TStringList }
function TRegistre.GetListe( SousChemin : string ) : TStrings;
var
  ListeCle    : TStrings;
  ListeValeur : TStrings;
  I       : Cardinal;
  Memoire : string;
begin
    try
      { Change chemin }
      Memoire := Path;
      SetPath( Slach(Path) + SousChemin );
      { Crée les listes virtuelles }
      ListeCle := TStringList.Create;
      ListeValeur := TStringList.Create;
      { Recupère la liste des clés }
      GetValueNames( ListeCle );
      { Recupère la liste des valeurs }
      if ( ListeCle.Count > 0 ) then for I := 0 to ( ListeCle.Count - 1 )
      do ListeValeur.Add( ReadString( ListeCle.Strings[I] ) );
    finally
      { Retablie chemin d'origine }
      SetPath( Memoire );
      { Renvoi le resultat }
      Result := ListeValeur;
      { detruit objets }
      ListeCle.Free;
    end;
end;

{ Ajoute un '/' en fin de chemin s'il n'y est pas }
function TRegistre.Slach( Chemin : string ) : string;
begin
  if ( Trim( Copy( Chemin, Length(Chemin), 1 ) ) <> '\' ) then
    Result := Trim(Chemin) + '\'
  else
    Result := Trim(Chemin);
end;

// *******************************************
// ************ METHODES PUBLICS *************
// *******************************************

{ Sauvegarde un TEdit }
procedure TRegistre.EcritCle( Cle : string; CEdit : TCustomEdit );
begin
    WriteString( Cle, CEdit.Text );
end;

{ Sauvegarde une ComboBox }
procedure TRegistre.EcritCle( Cle : string; CCombo : TCustomComboBox );
begin
    WriteInteger( Cle, CCombo.ItemIndex );
end;

{ Sauvegarde une CheckBox }
procedure TRegistre.EcritCle( Cle : string; CCheck : TCheckBox );
begin
    WriteBool( Cle, CCheck.Checked );
end;

{ Sauvegarde contenu d'une ListBox }
procedure TRegistre.EcritCle( Cle : String; CListBox : TCustomListBox );
begin
    if ( CListBox.Count > 0 ) then SetListe( CListBox.Items, Cle );
end;

{ Recupère un TEdit }
procedure TRegistre.LireCle( Cle : string; CEdit : TCustomEdit );
begin
    try
      CEdit.Text := ReadString( Cle );
    except
      on ERegistryException do CEdit.Text := '';
    end;
end;

{ Recupère une ComboBox}
procedure TRegistre.LireCle( Cle : string; CCombo : TCustomComboBox );
begin
    try
      CCombo.ItemIndex := ReadInteger( Cle );
    except
      on ERegistryException do CCombo.ItemIndex := 0;
    end;
end;

{ Recupère une CheckBox }
procedure TRegistre.LireCle( Cle : string; CCheck : TCheckBox );
begin
    try
      CCheck.Checked := ReadBool( Cle );
    except
      on ERegistryException do CCheck.Checked := False;
    end;
end;

{ Recupère contenu d'une TlistBox }
procedure TRegistre.LireCle ( Cle : String; CListBox : TCustomListBox );
begin
    CListBox.Items := GetListe( Cle );
end;

end.

Conclusion :


Laissez vos commentaires et vos notes !
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (elguevel)