whats new ¦  programming tips ¦  indy articles ¦  intraweb articles ¦  informations ¦  links ¦  interviews
 misc ¦  tutorials ¦  Add&Win Game

Tips (1548)

Database (90)
Files (137)
Forms (107)
Graphic (116)
IDE (21)
Indy (5)
Internet / LAN (131)
IntraWeb (0)
Math (76)
Misc (127)
Multimedia (45)
Objects/
ActiveX (51)

OpenTools API (3)
Printing (35)
Strings (83)
System (268)
VCL (243)

Top15

Tips sort by
component


Search Tip

Add new Tip

Add&Win Game

Advertising

14 Visitors Online


 
... save (object) configuration data easily?
Autor: Sven Lorenz
Homepage: http://www.Sven-of-Nine.de
[ Print tip ]  

Tip Rating (21):  
     


unit Unit_UserConfig;
//////////////////////////////////////////////////////////////////////
///
/// Unit zur vereinfachten Speicherung von User-Daten
///
/// Mittels Save werden die Eigenschaften ALLER Child-Komponenten einer
/// Komponente gespeichert.
/// Load holt diese dann wieder
///
/// In Datei speichern
/// UserConfig:=TUserConfig.Create(0); //Nur auf Festplatte speichern
/// aufruf z.B. SaveToFile  (GroupBox1,'configuratio.cfg');
///             LoadFromFile(GroupBox1,'configuratio.cfg');
///
/// In Speicher ablegen
/// (Damit kann z.B eine Undo-Funktion für Optionen realisiert werden)
/// UserConfig:=TUserConfig.Create(10); //Plätze zur Speicherung bereithalten
/// aufruf z.B. SaveToFile  (Form1,5); //Auf Platz 5 speichern
///             LoadFromFile(Form1,5); //von Platz 4 laden
///
///
///(c) 2005 Borg@Sven-of-Nine.de
///
///Beispielprogramm unter www.Sven-of-Nine.de
///
//////////////////////////////////////////////////////////////////////

interface

uses 
Classes;

type
  
TUserConfig = class(TObject)
  private
    
{ Private-Deklarationen }
    //Direkter Zugriff auf Eigenschaften
    //set properties using winapi
    
function IsProperty(Obj: TObject; sProp: string): Boolean;
    function SetProperty(Obj: TObject; sProp: string; vValue: Variant): Boolean;
    function HasAncestor(Child: TComponent; Name: string): Boolean;

  public
    
{ Public-Deklarationen }
    
constructor Create(MaxMemory: Integer = 10);
    destructor Destroy(); override;

    //Komponenten in Datei schreiben
    //save/load components to/from file
    
function SaveToFile(Component: TComponent; sFilename: string): Boolean;
    function LoadFromFile(Component: TComponent; sFilename: string): Boolean;

    //Komponenten in Speicher schreiben (UNDO-Funktion)
    //save/load components to/from mem
    
function SaveToMemory(Component: TComponent; Index: Integer): Boolean;
    function LoadFromMemory(Component: TComponent; Index: Integer): Boolean;
  end;

implementation

uses 
Windows, SysUtils, Controls, Forms, TypInfo;

var
  
aMemStream: array of TMemoryStream;
  //////////////////////////////////////////////////////////////////////
  /// Konstruktor und Destruktor
  //////////////////////////////////////////////////////////////////////
constructor TUserConfig.Create(MaxMemory: Integer = 10);
var
  
iIndex: Integer;
begin
  
//Alle angeforderten Speicherstreams initialisieren
  //initialize memorystreams
  
if (MaxMemory > 255) then MaxMemory := 255;
  try
    
SetLength(aMemStream, MaxMemory);
    for iIndex := 0 to MaxMemory - 1 do
    begin
      
aMemStream[iIndex] := TMemoryStream.Create;
    end;
  finally
  end
;
end;

destructor TUserConfig.Destroy();
var
  
iIndex: Integer;
begin
  
//Alle angeforderten Speicherstreams freimachen
  //free all
  
for iIndex := 0 to Length(aMemStream) - 1 do
  begin
    
aMemStream[iIndex].Free;
  end;
  SetLength(aMemStream, 0);
end;

//////////////////////////////////////////////////////////////////////
/// Prüfen, ob ein Object die gewünschte Eigenschaft hat
/// Check for properties
//////////////////////////////////////////////////////////////////////
function TUserConfig.IsProperty(Obj: TObject; sProp: string): Boolean;
var
  
plList: tPropList;
  iIndex1: Integer;

  iIndex2: Integer;
begin
  
Result := False;
  //Alle verfügbaren Properties holen
  //get properties
  
iIndex2 := GetPropList(PTypeInfo(Obj.ClassInfo),
    [tkUnknown, tkVariant, tkInteger, tkInt64, tkFloat,
    tkString, tkWString, tkLString, tkChar, tkWChar,
    tkEnumeration, tkSet, tkClass, tkMethod, tkArray,
    tkDynArray, tkRecord, tkInterface], @plList);
  //nach der gewünschten suchen
  //search for the wanted
  
iIndex1 := 0;
  while (iIndex1 < iIndex2) do
  begin
    if 
plList[iIndex1].Name = sProp then
    begin
      
Result  := True;
      iIndex1 := iIndex2;
    end;
    Inc(iIndex1);
  end;
end;

//////////////////////////////////////////////////////////////////////
/// Eine Egenschaft direkt setzen
/// set properties
//////////////////////////////////////////////////////////////////////
function TUserConfig.SetProperty(Obj: TObject; sProp: string; vValue: Variant): Boolean;
begin
  if 
(IsProperty(Obj, sProp)) then
  begin
    
SetPropValue(Obj, sProp, vValue);
    Result := True;
  end
  else
  begin
    
Result := False;
  end;
end;

//////////////////////////////////////////////////////////////////////
/// Nach einem Vorfahr mit dem Namen "Name" suchen
/// check for ancestor named "Name"
//////////////////////////////////////////////////////////////////////
function TUserConfig.HasAncestor(Child: TComponent; Name: string): Boolean;
var
  
cWork: TComponent;
begin
  
Result := False;
  cWork  := Child;
  while (cWork.HasParent) do
  begin
    
//Eltern holen
    
cWork := cWork.GetParentComponent;
    //Sind die Eltern die gesuchten ?
    
if (cWork.Name = Name) then
    begin
      
//Dann Suche beenden
      
Result := True;
      break;
    end;
  end;
  cWork := nil;
end;



//////////////////////////////////////////////////////////////////////
/// Save all components to disk
/// alle komponenten in datei speichern
//////////////////////////////////////////////////////////////////////
function TUserConfig.SaveToFile(Component: TComponent; sFilename: string): Boolean;
var
  
hFile: THandle;
  Stream: THandleStream;
  iIndex: Integer;
  sName: string[255];
  cWork: TComponent;
begin
  
Result := False;

  //Datei auf jeden Fall immer neu erzeugen
  //Create File
  
hFile := FileCreate(sFilename);
  if (hFile > 0) then
  begin
    
//Die Hauptkomponente finden (das Formular)
    //Find parent
    
cWork := Component;
    while (cWork.HasParent) do
    begin
      
cWork := cWork.GetParentComponent;
    end;
    //Stream erzeugen
    //Create stream
    
Stream := THandleStream.Create(hFile);
    try
      
//Und los
      //enumerate all
      
for iIndex := 0 to cWork.ComponentCount - 1 do
      begin
        
//Ist es ein Win-Control und eine Nachfahre der gewünschten Componente?
        //save only TWinControls and childs of Component
        
if (cWork.Components[iIndex] is TWinControl) and
          
(HasAncestor(cWork.Components[iIndex], Component.Name)) then
        begin
          
//Hier ein paar Ausnahmen
          //some exceptions
          
if (cWork.Components[iIndex].ClassName <> 'TFlatTitlebar')
            and
            
(cWork.Components[iIndex].ClassName <>
            'TFlatSpinEd1itInteger') then
          begin
            
//Erst den Namen
            //save name first
            
sName := cWork.Components[iIndex].Name;
            Stream.Write(sName, Length(sName) + 1);

            //Und dann die Komponente hinterher
            //and component
            
Stream.WriteComponent(cWork.Components[iIndex]);
          end;
        end;
      end;
      Result := True;
    finally
      
//Fertig
      //done
      
Stream.Free;
    end;
    //close handle
    
FileClose(hFile);
  end;
  cWork := nil;
end;


//////////////////////////////////////////////////////////////////////
/// load all components from disk
/// alle komponenten aus datei laden
//////////////////////////////////////////////////////////////////////
function TUserConfig.LoadFromFile(Component: TComponent; sFilename: string): Boolean;
var
  
hFile: THandle;
  Stream: THandleStream;
  iIndex: Integer;
  sName: string[255];
  iName: Integer;
  cWork: TComponent;
begin
  
Result := False;
  //Date öffnen
  //open read
  
hFile := FileOpen(sFilename, fmOPENREAD);
  if (hFile > 0) then
  begin
    
//Das die Hauptkomponente finden (das Formular)
    
cWork := Component;
    while (cWork.HasParent) do
    begin
      
cWork := cWork.GetParentComponent;
    end;

    //Stream erzeugen
    //create stream
    
Stream := THandleStream.Create(hFile);
    try
      
//Vorne anfangen
      //from the beginning
      
Stream.Position := 0;
      //Und kpl. durchwurstem
      //the whole file
      
while (Stream.Position < Stream.Size) do
      begin
        
//erstes byte des namens
        //first byte of Name
        
Stream.read(sName[0], 1);
        //Größe rausholen
        //get size
        
iName := Byte(sName[0]);
        //Und den ganzen Namen lesen
        //Read the whole name
        
Stream.read(sName[1], iName);

        //Object holen
        //get object
        
try
          
//Nach dem namen suchens
          //search for the name
          
for iIndex := 0 to cWork.ComponentCount - 1 do
          begin
            if 
(cWork.Components[iIndex].Name = sName) then
            begin
              
//Bei allem, was Checked hat, dies erst auf FALSE
              // setzen
              //Uncheck all "checkables"
              
SetProperty(cWork.Components[iIndex],
                'Checked', False);

              //Und dann erst laden
              //load
              
Stream.ReadComponent(cWork.Components[iIndex]);
            end;
          end;
        except
        end
;
      end;
    finally
      
//done
      
Stream.Free;
    end;
    FileClose(hFile);
  end;
  cWork := nil;
end;

//////////////////////////////////////////////////////////////////////
/// Save all components to memory
/// alle komponenten in speicher schreiben
//////////////////////////////////////////////////////////////////////
function TUserConfig.SaveToMemory(Component: TComponent; Index: Integer): Boolean;
var
  
iIndex: Integer;
  sName: string[255];
  cWork: TComponent;
begin
  
Result := False;
  if (Index < 0) or (Index >= Length(aMemStream)) then Exit;
  try
    
//Die Hauptkomponente finden (das Formular)
    
cWork := Component;
    while (cWork.HasParent) do
    begin
      
cWork := cWork.GetParentComponent;
    end;

    for iIndex := 0 to cWork.ComponentCount - 1 do
    begin
      if 
(cWork.Components[iIndex] is TWinControl) and
        
(HasAncestor(cWork.Components[iIndex], Component.Name)) then
      begin
        if 
(cWork.Components[iIndex].ClassName <> 'TFlatTitlebar') and
          
(cWork.Components[iIndex].ClassName <> 'TFlatSpinEd1itInteger') then
        begin
          
sName := Component.Components[iIndex].Name;
          aMemStream[Index].Write(sName, Length(sName) + 1);
          aMemStream[Index].WriteComponent(cWork.Components[iIndex]);
        end;
      end;
    end;
    Result := True;
  finally
    
cWork := nil;
  end;
end;

//////////////////////////////////////////////////////////////////////
/// load components[index] from memory
/// komponenten[index] aus speicher lesen
//////////////////////////////////////////////////////////////////////
function TUserConfig.LoadFromMemory(Component: TComponent; Index: Integer): Boolean;
var
  
iIndex: Integer;
  sName: string[255];
  iName: Integer;
  cWork: TComponent;
begin
  
Result := False;
  if (Index < 0) or (Index >= Length(aMemStream)) then Exit;
  try
    
cWork := Component;
    while (cWork.HasParent) do
    begin
      
cWork := cWork.GetParentComponent;
    end;

    aMemStream[Index].Position := 0;
    while (aMemStream[Index].Position < aMemStream[Index].Size) do
    begin
      
aMemStream[Index].read(sName[0], 1);
      iName := Byte(sName[0]);
      aMemStream[Index].read(sName[1], iName);
      try
        for 
iIndex := 0 to cWork.ComponentCount - 1 do
        begin
          if 
(cWork.Components[iIndex].Name = sName) then
          begin
            
SetProperty(cWork.Components[iIndex],
              'Checked', False);
            aMemStream[Index].ReadComponent
            (cWork.Components[iIndex]);
          end;
        end;
      except
      end
;
    end;
    Result := True;
  finally
    
cWork := nil;
  end;
end;


end.


 

Rate this tip:

poor
very good


Copyright © by SwissDelphiCenter.ch
All trademarks are the sole property of their respective owners