Entwickler-Ecke :: Thema anzeigen - Sehr einfach auf INI und REG zugreifen mit EasyIni und ...

Popov - Fr 06.02.04 17:59
Titel: Sehr einfach auf INI und REG zugreifen mit EasyIni und ...

Bei den Units EasyIniAppExe, EasyIniAppDataExe und EasyRegAppExe handelt es sich um vereinfachte Zugriffe auf Dateien der Ini und Registry. Allerdings mit der Einschränkung, daß die Units den Speicherort der Daten automatisch bestimmen.

Die Units sind auf schnelles Arbeiten mit Ini und Registry ausgelegt, soweit es sich um Einstellungen (Optionen) des Programms handelt. Das erreichen die Units in dem sie einige Schritte automatisieren.

Die großen Vorteile der Units gegenüber dem Arbeiten mit IniFiles und Registry sind:

die Suche nach dem geeigneten Speicherplatz für die Daten entfällt; wird automatisch ermittelt
der Speicherort ist Windows XP ff konform, z.B. bei eingeschränkten Benutzerrechten
das Arbeiten mit IniFile und RegIniFile Klassen entfällt. Die Unit erstellt und gibt Instanzen automatisch frei
sofort einsetzbar. Unit einfügen und schon können Werte gespeichert und abrufen werden
schneller Wechsel zwischen Ini und Registry möglich. Durch Wechsel der Unit kann ohne weitere Änderungen am Programm von Ini auf Regisry gewechselt werden und umgekehrt

Nachteile der Units gegenüber dem Arbeiten mit IniFiles und Registry sind:

die Unit bestimmt den Ort der Speicherung automatisch und ist auf das Speichern der Einstellungen des aktuellen Programms spezialisiert. Zugriffe auf fremde Ini-Dateien (bei Ini) oder Registry-Pfade (bei Registry) sind mit der Unit nicht möglich.

Der Speicherort der Daten wird abhängig von der Unit automatisch ermittelt. Ein Eingriff ist nicht nötig. Es gibt mehrere Units mit unterschiedlichen Speicherorten. Es reicht die Unit auszuwechseln um mit gleichem Befehlssatz die Daten an andere Stelle zu speichern. Der Name der Ini-Datei und Reg-Schlüssel wird aus dem Namen des Programms generiert. Speicherorte sich unterschiedlich je nach Unit. EasyIniAppExe speichert die Ini im gleichen Ordner wie Programm, EasyIniAppDataExe speichert die Ini im Anwendungsdaten- Ordner des Kontos, EasyRegAppExe speichert die Daten in der Registry im Software Pfad der HKCU.

Eine Besonderheit der Units ist, daß sie untereinander kompatibel sind. Es reicht nur die Unit auszutauschen und schon schreibt das Programm nicht in die Ini, sondern in die Registry. An den Namen der Funktionen und Prozeduren ändert sich nichts.

Die Hauptfunktionen der Unit sind ähnlich IniFiles und RegIniFiles Unit, d.h. man kann String-, Integer-, Booleanwerte lesen und speichern, Sektoren und Schlüssel auslesen und löschen. Natürlich ist es auch möglich die Units zu erweitern und Time, Date oder Color Funktionen zu schreiben.

Funktionen und Prozeduren:

Im Grunde genommen funktioniert das fast wie bei TIniFile und TRegIniFile. Hier sind die ganzen Methoden gekapselt. Alledings gibt es auch einige Info-Funktionen. Beschrieben werden hier nur die öffentlichen Funktionen und Prozeduren. Die Angaben gelten, soweit nicht anders Hingewiesen, für alle Units:

Hauptfunktionen:

Da die Units das Deklarieren und Initialisieren selbst übernehmen, kann mit den Funktionen direkt gearbeitet werden.

Delphi-Quelltext

1:
2:
3:

function EasyRegIniType: String;

s := EasyRegIniType;

- Gibt den Wert "INI" bei der Ini Unit, "INI_APPDATA" bei der Anwendingsdaten-Ordner Unit und "REG" bei der Registry Unit zurück. Auf diese Weise kann man prüfen welche Unit man benutzt.

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:

function ReadIniString(Section, Ident, Default: String): String;
function ReadIniInteger(Section, Ident: String; Default: Longint): Longint;
function ReadIniBool(Section, Ident: String; Default: Boolean): Boolean;

s := ReadIniString('Sektion', 'Schluessel', '');
i := ReadIniInteger ('Sektion', 'Schluessel', 0);
b := ReadIniBool ('Sektion', 'Schluessel', True);

- Lesen einen String, Integer oder Boolean Wert aus INI oder REG.

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:

procedure WriteIniString(Section, Ident, Value: String);
procedure WriteIniInteger(Section, Ident: String; Value: Longint);
procedure WriteIniBool(Section, Ident: String; Value: Boolean);

WriteIniString('Sektion', 'Schluessel', s);
WriteIniInteger('Sektion', 'Schluessel', i);
WriteIniBool('Sektion', 'Schluessel', b);

- Schreiben einen String, Integer oder Boolean Wert in INI oder REG.

Delphi-Quelltext

1:
2:
3:

procedure DeleteIniKey(Section, Ident: String);

DeleteIniKey('Sektion', 'Schluessel');

- Löscht einen Ident-Schlüssel inc. Wert aus der INI oder REG.

Delphi-Quelltext

1:
2:
3:

procedure EraseIniSection(Section: String);

EraseIniSection('Sektion');

- Löscht die ganze ganze Sektion aus der INI oder REG.

Delphi-Quelltext

1:
2:
3:

procedure ReadIniSection(Section: String; Strings: TStrings);

ReadIniSection('Sektion', ListBox1.Items);

- Liest alle Ident-Schlüsselnamen einer Sektion (ohne Werte) aus der INI oder REG.

Delphi-Quelltext

1:
2:
3:

procedure ReadIniSections(Strings: TStrings);

ReadIniSections(ListBox1.Items);

- Liest alle Sektionsnamen aus der INI oder REG.

Für die letzten beiden Prozeduren wird ein TStrings wie z.B. ListBox oder StringList als Behälter für die Rückgabewerte benötigt.

INFO Funktionen:

Delphi-Quelltext

1:	function Info_IniExists: Boolean;

- Prüft ob die Ini Datei existiert (FileExists) in der Ini-Unit. In der Reg-Unit ist der Wert immer True.

Delphi-Quelltext

1:	function Info_IniRedOnly: ShortInt;

- Prüft ob die Ini Datei schreibgeschützt ist in der Ini-Unit (-1 = Datei existiert nicht, 0 = Datei ist nicht schreibgeschützt, 1 = Datei ist schreibeschützt). In der Reg-Unit ist der Wert immer 0.

Delphi-Quelltext

1:	function Info_IniSize: Integer;

- Gibt die Größe der Ini Datei in der Ini-Unit (einzusetzen wegen der 64Kbyte Grenze bei IniFiles). In der Reg-Unit ist der Wert immer 0.

Delphi-Quelltext

1:	function Info_IniWriteTest: Boolean;

- Macht einen Schreib-Lesetest mit der INI in der Ini-Unit. Alle Testwerte werden wieder entfernt. Eventuell wird eine Leere INI Datei erstellt wenn keine INI vorhanden war. Die Werte sind True, wenn der Test erfolgreich war und False, wenn er nicht erfolgreich war. In der Reg-Unit ist der Wert immer True.

EDIT: Text neu formuliert und Beispiele hinzugefügt.

Popov - Fr 06.02.04 18:05

Hier die EasyIniAppExe. Sie schreibt die Werte in eine INI-Datei. Sie sollte nicht zusammen mit der EasyRegAppExe genutzt werden, da die beiden Units die gleiche Funktionen und Prozeduren haben. Durch das Austauschen der/des Unit/Namen kann man erreichen, daß die Werte entweder in die Ini oder in die Registry geschrieben werden.

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:

{------------------------------------------------------------------------------}
{  Unit     : EasyIniAppExe                                                    }
{  Version  : 1.1.0                                                            }
{  Autor    : Popov                                                            }
{  eMail    : popov3@lycos.de                                                  }
{  Internet : http://www.popov.de.ms                                           }
{  Copyright: (c) 2001-2004 by Popov                                           }
{                                                                              }
{  Prozeduren und Funktionen mit denen man sehr einfach auf die INI zugreifen  }
{  kann. Es entfällt das Einbinden der IniFiles und das Initialisieren eines   }
{  IniFile Objekts.                                                            }
{------------------------------------------------------------------------------}

{------------------------------------------------------------------------------}
{ Version 1.0.0:                                                               }
{ Alle Hauptfunktionen.                                                        }
{                                                                              }
{ Version 1.1.0:                                                               }
{ Neu: Info_IniExists, Info_IniRedOnly, Info_IniSize, Info_IniWriteTest.       }
{------------------------------------------------------------------------------}

unit EasyIniAppExe;

interface

uses
  Classes, SysUtils, IniFiles;

  function EasyRegIniType: String;
  function ReadIniString(Section, Ident, Default: String): String;
  function ReadIniInteger(Section, Ident: String; Default: Longint): Longint;
  function ReadIniBool(Section, Ident: String; Default: Boolean): Boolean;
  procedure WriteIniString(Section, Ident, Value: String);
  procedure WriteIniInteger(Section, Ident: String; Value: Longint);
  procedure WriteIniBool(Section, Ident: String; Value: Boolean);
  procedure DeleteIniKey(Section, Ident: String);
  procedure EraseIniSection(Section: String);
  procedure ReadIniSection(Section: String; Strings: TStrings);
  procedure ReadIniSections(Strings: TStrings);
  {----ERWEITERUNGEN----}
  {---INFO FUNKTIONEN---}
  function Info_IniExists: Boolean;
  function Info_IniRedOnly: ShortInt;
  function Info_IniSize: Integer;
  function Info_IniWriteTest: Boolean;

implementation

{------------------------------------------------------------------------------}
{ HAUPTFUNKTIONEN UND PROZEDUREN                                               }
{------------------------------------------------------------------------------}

function EasyRegIniType: String;
begin
  Result := 'INI';
end;

function IniFile: String;
begin
  Result := ChangeFileExt(ParamStr(0), '.ini');
end;

function ReadIniString(Section, Ident, Default: String): String;
begin
  with TIniFile.Create(IniFile) do try
    Result := ReadString(Section, Ident, Default)
  finally Free end;
end;

function ReadIniInteger(Section, Ident: String; Default: Longint): Longint;
begin
  with TIniFile.Create(IniFile) do try
    Result := ReadInteger(Section, Ident, Default)
  finally Free end;
end;

function ReadIniBool(Section, Ident: String; Default: Boolean): Boolean;
begin
  with TIniFile.Create(IniFile) do try
    Result := ReadBool(Section, Ident, Default);
  finally Free end;
end;

procedure WriteIniString(Section, Ident, Value: String);
begin
  with TIniFile.Create(IniFile) do try
    WriteString(Section, Ident, Value)
  finally Free end;
end;

procedure WriteIniInteger(Section, Ident: String; Value: Longint);
begin
  with TIniFile.Create(IniFile) do try
    WriteInteger(Section, Ident, Value)
  finally Free end;
end;

procedure WriteIniBool(Section, Ident: String; Value: Boolean);
begin
  with TIniFile.Create(IniFile) do try
    WriteBool(Section, Ident, Value);
  finally Free end;
end;

procedure DeleteIniKey(Section, Ident: String);
begin
  with TIniFile.Create(IniFile) do try
    DeleteKey(Section, Ident);
  finally Free end;
end;

procedure EraseIniSection(Section: String);
begin
  with TIniFile.Create(IniFile) do try
    EraseSection(Section);
  finally Free end;
end;

procedure ReadIniSection(Section: String; Strings: TStrings);
begin
  with TIniFile.Create(IniFile) do try
    ReadSection(Section, Strings);
  finally Free end;
end;

procedure ReadIniSections(Strings: TStrings);
begin
  with TIniFile.Create(IniFile) do try
    ReadSections(Strings);
  finally Free end;
end;

{------------------------------------------------------------------------------}
{ ERWEITERUNGEN                                                                }
{------------------------------------------------------------------------------}

{------------------------------------------------------------------------------}
{ INFO FUNKTIONEN                                                              }
{------------------------------------------------------------------------------}

function Info_IniExists: Boolean;
begin
  Result := FileExists(IniFile);
end;

function Info_IniRedOnly: ShortInt;
var SR: TSearchRec;
begin
  Result := -1;
  try if FindFirst(IniFile, faAnyFile, SR) = 0 then
    Result := Ord((SR.Attr and faReadOnly) > 0);
  finally SysUtils.FindClose(SR) end;
end;

function Info_IniSize: Integer;
var SR: TSearchRec;
begin
  Result := -1;
  try if FindFirst(IniFile, faAnyFile, SR) = 0 then
    Result := SR.Size;
  finally SysUtils.FindClose(SR) end;
end;

function Info_IniWriteTest: Boolean;
var
  k: ShortInt;
  s: String;
begin
  s := DateTimeToStr(Now);
  for k := Length(s) downto 1 do
    if not (s[k] in ['0'..'9']) then Delete(s, k, 1);

  try
    WriteIniString(s, s, s);
    Result := ReadIniString(s, s, '') = s;
    EraseIniSection(s);
  except
    Result := False;
  end;
end;

end.

Popov - Fr 06.02.04 18:07

Hier die EasyRegAppExe. Sie schreibt die Werte in die Registry. Sie sollte nicht zusammen mit der EasyIniAppExe genutzt werden, da die beiden Units die gleiche Funktionen und Prozeduren haben. Durch das Austauschen der/des Unit/Namen kann man erreichen, daß die Werte entweder in die Ini oder in die Registry geschrieben werden.

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:

{------------------------------------------------------------------------------}
{  Unit     : EasyRegAppExe                                                    }
{  Version  : 1.1.0                                                            }
{  Autor    : Popov                                                            }
{  eMail    : popov3@lycos.de                                                  }
{  Internet : http://www.popov.de.ms                                           }
{  Copyright: (c) 2001-2004 by Popov                                           }
{                                                                              }
{  Prozeduren und Funktionen mit denen man sehr einfach auf die REG zugreifen  }
{  kann. Es entfällt das Einbinden der Registry und das Initialisieren eines   }
{  RegIniFile Objekts.                                                         }
{------------------------------------------------------------------------------}

{------------------------------------------------------------------------------}
{ Version 1.0.0:                                                               }
{ Alle Hauptfunktionen.                                                        }
{                                                                              }
{ Version 1.1.0:                                                               }
{ Neu: Info_IniExists, Info_IniRedOnly, Info_IniSize, Info_IniWriteTest.       }
{------------------------------------------------------------------------------}

unit EasyRegAppExe;

interface

uses
  Classes, SysUtils, Registry;

  function EasyRegIniType: String;
  function ReadIniString(Section, Ident, Default: String): String;
  function ReadIniInteger(Section, Ident: String; Default: Longint): Longint;
  function ReadIniBool(Section, Ident: String; Default: Boolean): Boolean;
  procedure WriteIniString(Section, Ident, Value: String);
  procedure WriteIniInteger(Section, Ident: String; Value: Longint);
  procedure WriteIniBool(Section, Ident: String; Value: Boolean);
  procedure DeleteIniKey(Section, Ident: String);
  procedure EraseIniSection(Section: String);
  procedure ReadIniSection(Section: String; Strings: TStrings);
  procedure ReadIniSections(Strings: TStrings);
  {----ERWEITERUNGEN----}
  {---INFO FUNKTIONEN---}
  function Info_IniExists: Boolean;
  function Info_IniRedOnly: ShortInt;
  function Info_IniSize: Integer;
  function Info_IniWriteTest: Boolean;

implementation

{------------------------------------------------------------------------------}
{ HAUPTFUNKTIONEN UND PROZEDUREN                                               }
{------------------------------------------------------------------------------}

function EasyRegIniType: String;
begin
  Result := 'REG';
end;

function RegFile: String;
begin
  Result := 'Software\' + ChangeFileExt(ExtractFileName(ParamStr(0)), '');
end;

function ReadIniString(Section, Ident, Default: String): String;
begin
  with TRegIniFile.Create(RegFile) do try
    Result := ReadString(Section, Ident, Default)
  finally Free end;
end;

function ReadIniInteger(Section, Ident: String; Default: Longint): Longint;
begin
  with TRegIniFile.Create(RegFile) do try
    Result := ReadInteger(Section, Ident, Default)
  finally Free end;
end;

function ReadIniBool(Section, Ident: String; Default: Boolean): Boolean;
begin
  with TRegIniFile.Create(RegFile) do try
    Result := ReadBool(Section, Ident, Default);
  finally Free end;
end;

procedure WriteIniString(Section, Ident, Value: String);
begin
  with TRegIniFile.Create(RegFile) do try
    WriteString(Section, Ident, Value)
  finally Free end;
end;

procedure WriteIniInteger(Section, Ident: String; Value: Longint);
begin
  with TRegIniFile.Create(RegFile) do try
    WriteInteger(Section, Ident, Value)
  finally Free end;
end;

procedure WriteIniBool(Section, Ident: String; Value: Boolean);
begin
  with TRegIniFile.Create(RegFile) do try
    WriteBool(Section, Ident, Value);
  finally Free end;
end;

procedure DeleteIniKey(Section, Ident: String);
begin
  with TRegIniFile.Create(RegFile) do try
    DeleteKey(Section, Ident);
  finally Free end;
end;

procedure EraseIniSection(Section: String);
begin
  with TRegIniFile.Create(RegFile) do try
    EraseSection(Section);
  finally Free end;
end;

procedure ReadIniSection(Section: String; Strings: TStrings);
begin
  with TRegIniFile.Create(RegFile) do try
    ReadSection(Section, Strings);
  finally Free end;
end;

procedure ReadIniSections(Strings: TStrings);
begin
  with TRegIniFile.Create(RegFile) do try
    ReadSections(Strings);
  finally Free end;
end;

{------------------------------------------------------------------------------}
{ ERWEITERUNGEN                                                                }
{------------------------------------------------------------------------------}

{------------------------------------------------------------------------------}
{ INFO FUNKTIONEN                                                              }
{------------------------------------------------------------------------------}

function Info_IniExists: Boolean;
begin
  Result := True;
end;

function Info_IniRedOnly: ShortInt;
begin
  Result := 0;
end;

function Info_IniSize: Integer;
begin
  Result := 0;
end;

function Info_IniWriteTest: Boolean;
begin
  Result := True;
end;

end.

Popov - Mo 02.05.05 17:34

Hier die EasyIniAppDataExe. Sie schreibt die Werte in eine INI-Datei, aber im Gegensatz zu EasyIniAppExe schreibt sie es in den jeweiligen Anwendungsdaten Ordner. Somit hat jedes Benutzerkonto seine eigene Einstelungen. Sie sollte nicht zusammen mit der EasyRegAppExe genutzt werden, da die beiden Units die gleiche Funktionen und Prozeduren haben. Durch das Austauschen der/des Unit/Namen kann man erreichen, daß die Werte entweder in die Ini oder in die Registry geschrieben werden.

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:

{------------------------------------------------------------------------------}
{  Unit     : EasyIniAppDataExe                                                }
{  Version  : 1.1.0                                                            }
{  Autor    : Popov                                                            }
{  eMail    : popov3@lycos.de                                                  }
{  Internet : http://www.popov.de.ms                                           }
{  Copyright: (c) 2001-2005 by Popov                                           }
{                                                                              }
{  Prozeduren und Funktionen mit denen man sehr einfach auf die INI zugreifen  }
{  kann. Es entfällt das Einbinden der IniFiles und das Initialisieren eines   }
{  IniFile Objekts.                                                            }
{                                                                              }
{  WICHTIG: Hier wird die INI in Anwendungsdaten Verzeichnis gespeichert.      }
{------------------------------------------------------------------------------}

{------------------------------------------------------------------------------}
{ Version 1.0.0:                                                               }
{ Alle Hauptfunktionen.                                                        }
{                                                                              }
{ Version 1.1.0:                                                               }
{ Neu: Info_IniExists, Info_IniRedOnly, Info_IniSize, Info_IniWriteTest.       }
{------------------------------------------------------------------------------}

unit EasyIniAppDataExe;

interface

uses
  Classes, SysUtils, IniFiles;

  function EasyRegIniType: String;
  function ReadIniString(Section, Ident, Default: String): String;
  function ReadIniInteger(Section, Ident: String; Default: Longint): Longint;
  function ReadIniBool(Section, Ident: String; Default: Boolean): Boolean;
  procedure WriteIniString(Section, Ident, Value: String);
  procedure WriteIniInteger(Section, Ident: String; Value: Longint);
  procedure WriteIniBool(Section, Ident: String; Value: Boolean);
  procedure DeleteIniKey(Section, Ident: String);
  procedure EraseIniSection(Section: String);
  procedure ReadIniSection(Section: String; Strings: TStrings);
  procedure ReadIniSections(Strings: TStrings);
  {----ERWEITERUNGEN----}
  {---INFO FUNKTIONEN---}
  function Info_IniExists: Boolean;
  function Info_IniRedOnly: ShortInt;
  function Info_IniSize: Integer;
  function Info_IniWriteTest: Boolean;

implementation

uses Windows, FileCtrl, Shlobj;

{------------------------------------------------------------------------------}
{ ALLGENEINE FUNKTIONEN UND PROZEDUREN                                         }
{------------------------------------------------------------------------------}

function SpecialDirectory(ID: Integer): String; 
var
  pidl : PItemIDList;
  Path : PChar;
begin  {Liefert den Pfad eines virtuellen Ordners //uses Shlobj;}
  if SUCCEEDED(SHGetSpecialFolderLocation(0, ID, pidl)) then
  begin
    Path := StrAlloc(max_path);
    SHGetPathFromIDList(pidl, Path);
    Result := String(Path);
    if Result[Length(Result)] <> '\' then Result := Result + '\';
  end
    else Result := '';
end;

{------------------------------------------------------------------------------}
{ HAUPTFUNKTIONEN UND PROZEDUREN                                               }
{------------------------------------------------------------------------------}

function EasyRegIniType: String;
begin
  Result := 'INI_APPDATA';
end;

function IniFile: String;
var
  IniFileName, FileFolder, AppDataFolder: String;
begin
  FileFolder := ChangeFileExt(ExtractFileName(ParamStr(0)), '');
  AppDataFolder := SpecialDirectory(CSIDL_APPDATA);
  IniFileName := ChangeFileExt(ExtractFileName(ParamStr(0)), '.ini');

  ForceDirectories(AppDataFolder + FileFolder);

  Result := AppDataFolder + FileFolder + '\' + IniFileName;
end;

function ReadIniString(Section, Ident, Default: String): String;
begin
  with TIniFile.Create(IniFile) do try
    Result := ReadString(Section, Ident, Default)
  finally Free end;
end;

function ReadIniInteger(Section, Ident: String; Default: Longint): Longint;
begin
  with TIniFile.Create(IniFile) do try
    Result := ReadInteger(Section, Ident, Default)
  finally Free end;
end;

function ReadIniBool(Section, Ident: String; Default: Boolean): Boolean;
begin
  with TIniFile.Create(IniFile) do try
    Result := ReadBool(Section, Ident, Default);
  finally Free end;
end;

procedure WriteIniString(Section, Ident, Value: String);
begin
  with TIniFile.Create(IniFile) do try
    WriteString(Section, Ident, Value)
  finally Free end;
end;

procedure WriteIniInteger(Section, Ident: String; Value: Longint);
begin
  with TIniFile.Create(IniFile) do try
    WriteInteger(Section, Ident, Value)
  finally Free end;
end;

procedure WriteIniBool(Section, Ident: String; Value: Boolean);
begin
  with TIniFile.Create(IniFile) do try
    WriteBool(Section, Ident, Value);
  finally Free end;
end;

procedure DeleteIniKey(Section, Ident: String);
begin
  with TIniFile.Create(IniFile) do try
    DeleteKey(Section, Ident);
  finally Free end;
end;

procedure EraseIniSection(Section: String);
begin
  with TIniFile.Create(IniFile) do try
    EraseSection(Section);
  finally Free end;
end;

procedure ReadIniSection(Section: String; Strings: TStrings);
begin
  with TIniFile.Create(IniFile) do try
    ReadSection(Section, Strings);
  finally Free end;
end;

procedure ReadIniSections(Strings: TStrings);
begin
  with TIniFile.Create(IniFile) do try
    ReadSections(Strings);
  finally Free end;
end;

{------------------------------------------------------------------------------}
{ ERWEITERUNGEN                                                                }
{------------------------------------------------------------------------------}

{------------------------------------------------------------------------------}
{ INFO FUNKTIONEN                                                              }
{------------------------------------------------------------------------------}

function Info_IniExists: Boolean;
begin
  Result := FileExists(IniFile);
end;

function Info_IniRedOnly: ShortInt;
var SR: TSearchRec;
begin
  Result := -1;
  try if FindFirst(IniFile, faAnyFile, SR) = 0 then
    Result := Ord((SR.Attr and faReadOnly) > 0);
  finally SysUtils.FindClose(SR) end;
end;

function Info_IniSize: Integer;
var SR: TSearchRec;
begin
  Result := -1;
  try if FindFirst(IniFile, faAnyFile, SR) = 0 then
    Result := SR.Size;
  finally SysUtils.FindClose(SR) end;
end;

function Info_IniWriteTest: Boolean;
var
  k: ShortInt;
  s: String;
begin
  s := DateTimeToStr(Now);
  for k := Length(s) downto 1 do
    if not (s[k] in ['0'..'9']) then Delete(s, k, 1);

  try
    WriteIniString(s, s, s);
    Result := ReadIniString(s, s, '') = s;
    EraseIniSection(s);
  except
    Result := False;
  end;
end;

end.

Entwickler-Ecke.de based on phpBB
Copyright 2002 - 2011 by Tino Teuber, Copyright 2011 - 2025 by Christian Stelzmann Alle Rechte vorbehalten.
Alle Beiträge stammen von dritten Personen und dürfen geltendes Recht nicht verletzen.
Entwickler-Ecke und die zugehörigen Webseiten distanzieren sich ausdrücklich von Fremdinhalten jeglicher Art!