1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

procedure TForm1.BitBtn1Click(Sender: TObject);
  var
  Reg: TRegistry;
  RegKey: DWORD;
  Key: string;
begin
  begin
  begin
  reg := TRegistry.Create(KEY_READ);
  try
    Reg.RootKey :=  HKEY_CURRENT_USER;
    Key := 'Software\ahead\Nero - Burning Rom\General';
    if Reg.OpenKeyReadOnly(Key) then
    begin
      if Reg.KeyExists('Disable-ResetWhenDowngrading') then
      RegKey := Reg.ReadInteger('Disable-ResetWhenDowngrading');
        Reg.CloseKey;
        if (RegKey=1) then CheckBox3.Checked := true;
      end;					

1:
2:

if Reg.KeyExists('Disable-ResetWhenDowngrading') then
  RegKey := Reg.ReadInteger('Disable-ResetWhenDowngrading');					

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:

procedure TForm3.BitBtn1Click(Sender: TObject);
  var
  Reg: TRegistry;
  RegKey: DWORD;
  Key: string;
begin
  begin
  begin
  reg := TRegistry.Create(KEY_READ);
  try
    Key := 'SYSTEM\CurrentControlSet\Services';
    if Reg.OpenKeyReadOnly(Key) then
    begin
      if Reg.KeyExists('cdrmkaun') then CheckBox1.Checked := true;
      end;
  Key := 'SYSTEM\CurrentControlSet\Enum\Root';
    if Reg.OpenKeyReadOnly(Key) then
    begin
      if Reg.KeyExists('LEGACY_CDRMKAUN') then CheckBox2.Checked := true;
      end;
  Key := 'SYSTEM\CurrentControlSet1\Services';
    if Reg.OpenKeyReadOnly(Key) then
    begin
      if Reg.KeyExists('cdrmkaun') then CheckBox3.Checked := true;
      end;
  Key := 'SYSTEM\CurrentControlSet1\Enum\Root';
    if Reg.OpenKeyReadOnly(Key) then
    begin
      if Reg.KeyExists('LEGACY_CDRMKAUN') then CheckBox4.Checked := true;
      end;
  Key := 'SYSTEM\CurrentControlSet2\Services';
    if Reg.OpenKeyReadOnly(Key) then
    begin
      if Reg.KeyExists('cdrmkaun') then CheckBox5.Checked := true;
      end;
  Key := 'SYSTEM\CurrentControlSet2\Enum\Root';
    if Reg.OpenKeyReadOnly(Key) then
    begin
      if Reg.KeyExists('LEGACY_CDRMKAUN') then CheckBox6.Checked := true;
      end;
  finally
    Reg.Free
  end;
end;
begin
  CheckBox7.Checked := FileExists(TempDir + '\cdrmkaun.sys');
  CheckBox8.Checked := FileExists(TempDir + '\CmdLineExt02.dll');
  CheckBox9.Checked := FileExists(TempDir + '\SIntf16.dll');
  CheckBox10.Checked := FileExists(TempDir + '\SIntf32.dll');
  CheckBox11.Checked := FileExists(TempDir + '\SintfIcn.ani');
  CheckBox12.Checked := FileExists(TempDir + '\SintFNT.dll');
end;
end;
ShowMessage('ACHTUNG BETA-VERSION! Vor einer Änderung unbedingt Registry sichern!');
BitBtn2.Enabled:=True;
end;					

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:

procedure TForm1.BitBtn1Click(Sender: TObject);
  var
  Reg: TRegistry;
  RegKey: DWORD;
  RegKey2: DWORD;
  Key: string;
begin
  begin
  begin
  reg := TRegistry.Create(KEY_READ);
  try
    Reg.RootKey :=  HKEY_CURRENT_USER;
  Key := 'Software\ahead\Nero - Burning Rom\General';
    if Reg.OpenKeyReadOnly(Key) then
    begin
      if Reg.KeyExists('Disable-ResetWhenDowngrading') then
      RegKey2 := Reg.ReadInteger('Disable-ResetWhenDowngrading');
        Reg.CloseKey;
        if (RegKey2=1) then CheckBox3.Checked := true;
      end;
  Key := 'Software\Ahead\Nero - Burning Rom\Browser';
    if Reg.OpenKeyReadOnly(Key) then
    begin
      if Reg.KeyExists('ShowHiddenAndSystemFiles') then
      RegKey := Reg.ReadInteger('ShowHiddenAndSystemFiles');
        Reg.CloseKey;
        if (RegKey=1) then CheckBox4.Checked := true;
      end;
  Key := 'Software\Ahead\Nero - Burning Rom\Recorder';
    if Reg.OpenKeyReadOnly(Key) then
    begin
      if Reg.KeyExists('UseStaticWriteSpeedTable') then
      RegKey := Reg.ReadInteger('UseStaticWriteSpeedTable');
        Reg.CloseKey;
        if (RegKey=1) then CheckBox2.Checked := true;
      end;
  Key := 'Software\Ahead\Nero - Burning Rom\Recorder';
    if Reg.OpenKeyReadOnly(Key) then
    begin
      if Reg.KeyExists('ShowSingleRecorderSpeed') then
      RegKey := Reg.ReadInteger('ShowSingleRecorderSpeed');
        Reg.CloseKey;
        if (RegKey=1) then CheckBox1.Checked := true;
      end;
  finally
    Reg.Free
  end;
end;
end;
end;					

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:
214:
215:
216:
217:
218:
219:

uses
  Registry;

procedure ReadREG_MULTI_SZ(const CurrentKey: HKey; const Subkey, ValueName: string;
  Strings: TStrings);
var
  valueType: DWORD;
  valueLen: DWORD;
  p, buffer: PChar;
  key: HKEY;
begin
  // Clear TStrings
  // TStrings leeren
  Strings.Clear;
  // open the specified key
  // CurrentKey Schlüssel öffnen
  if RegOpenKeyEx(CurrentKey,
                  PChar(Subkey),
                  0, KEY_READ, key) = ERROR_SUCCESS then
  begin
    // retrieve the type and data for a specified value name
    // Den Typ und Wert des Eintrags Ermitteln.
    SetLastError(RegQueryValueEx(key,
                 PChar(ValueName),
                 nil,
                 @valueType,
                 nil,
                 @valueLen));
    if GetLastError = ERROR_SUCCESS then
      if valueType = REG_MULTI_SZ then
      begin
        GetMem(buffer, valueLen);
        try
          // receive the value's data (in an array).
          // Ein Array von Null-terminierten Strings
          // wird zurückgegeben
          RegQueryValueEx(key,
                          PChar(ValueName),
                          nil,
                          nil,
                          PBYTE(buffer),
                          @valueLen);
          // Add values to stringlist
          // Werte in String Liste einfügen
          p := buffer;
          while p^ <> #0 do
          begin
            Strings.Add(p);
            Inc(p, lstrlen(p) + 1)
          end
        finally
          FreeMem(buffer)
        end
      end
      else
        raise ERegistryException.Create('Stringlist expected/ String Liste erwartet...')
    else
      raise ERegistryException.Create('Cannot Read MULTI_SZ Value/'+
        'Kann den MULTI_SZ Wert nicht lesen...');
  end;
end;

// Test it, Testen:

procedure TForm1.Button1Click(Sender: TObject);
begin
  ReadREG_MULTI_SZ(HKEY_CURRENT_USER, 'Software\XYZ', 'Test44', Memo1.Lines);
end;

{******************************************}
{2. by Ralph Friedman }

{
 Question:
 I want to read out the binary-value "problems" of the path
 HKEY_DYN_DATA\Config Manager\Enum\[add the key of a hardware component] to
 detect if a hardware component is troubled and not working right.
 But I cannot handle the ReadBinaryData-Method of TRegistry correct.
 Everytime I use it, it always returns "4" as content of the buffer.
 How do I detect if the content of the binary-key "problems" is
 not "00 00 00 00" but something else like "16 00 00 00" or such?
}

{Answer: Here's an example of ReadBinaryData }


procedure TFrmReadBinary.Button1Click(Sender: TObject);
const
  CKeyName: string = 'System\Setup';
  CValName: string = 'NetcardDlls';
var
  keyGood: boolean;
  p: integer;
  regKey: TRegistry;
  tmpStr: string;
  vSize: integer;
begin
  regKey := TRegistry.Create;
  try
    regKey.RootKey := HKEY_LOCAL_MACHINE;
    keyGood  := regKey.OpenKey(CKeyName, False);

    if (keyGood) then
    begin
      vSize := regKey.GetDataSize(CValName);

      if (vSize > 0) then
      begin
        SetLength(tmpStr, vSize);
        regKey.ReadBinaryData(CValName, tmpstr[1], vSize);

        repeat
          p := Pos(#0, tmpStr);

          if p <> 0 then
          begin
            Delete(tmpStr, p, 1);
            Insert(#13#10, tmpStr, p);
          end;
        until p = 0;

        (*StringReplace(tmpStr, #0, #13#10, [rfReplaceAll]); *)

        ListBox1.Items.Text := tmpStr;
      end;
    end;
  finally
    regKey.Free;
  end;
end;

{******************************************}
{3. by Michael Winter }

procedure RaiseWin32Error(Code: Cardinal);
var
  Error: EWin32Error;
begin
  Error := EWin32Error.CreateResFmt(@SWin32Error, [Code,
    SysErrorMessage(Code)]);
  Error.ErrorCode := Code;
  raise Error;
end;

// Write REG_MULTI_SZ
procedure TForm1.Button1Click(Sender: TObject);
const
  Str = 'multiple'#0'strings'#0'in one'#0'registry'#0'value'#0;
var
  Reg: TRegistry;
  Res: Integer;
begin
  Reg := TRegistry.Create;
  try
    Reg.RootKey := HKEY_CURRENT_USER;
    if not Reg.OpenKey('\Software\Test\RegMultiSzTest', true) then
      raise Exception.Create('Can''t open key');
    Res := RegSetValueEx(
      Reg.CurrentKey,     // handle of key to set value for
      'TestValue',        // address of value to set
      0,                  // reserved
      REG_MULTI_SZ,       // flag for value type
      PChar(Str),         // address of value data
      Length(Str) + 1);   // size of value data
    if Res <> ERROR_SUCCESS then
      RaiseWin32Error(Res);
  finally
    Reg.Free;
  end;
end;

// Read REG_MULTI_SZ
procedure TForm1.Button2Click(Sender: TObject);
var
  Reg: TRegistry;
  DataType: Cardinal;
  DataSize: Cardinal;
  Res: Integer;
  Str: String;
  i: Integer;
begin
  Reg := TRegistry.Create;
  try
    Reg.RootKey := HKEY_CURRENT_USER;
    if not Reg.OpenKeyReadOnly('\Software\Test\RegMultiSzTest') then
      raise Exception.Create('Can''t open key');
    DataSize := 0;
    Res := RegQueryValueEx(
      Reg.CurrentKey,     // handle of key to query
      'TestValue',        // address of name of value to query
      nil,                // reserved
      @DataType,          // address of buffer for value type
      nil,                // address of data buffer
      @DataSize);         // address of data buffer size
    if Res <> ERROR_SUCCESS then
      RaiseWin32Error(Res);
    if DataType <> REG_MULTI_SZ then
      raise Exception.Create('Wrong data type');
    SetLength(Str, DataSize - 1);
    if DataSize > 1 then begin
      Res := RegQueryValueEx(
        Reg.CurrentKey,     // handle of key to query
        'TestValue',        // address of name of value to query
        nil,                // reserved
        @DataType,          // address of buffer for value type
        PByte(Str),         // address of data buffer
        @DataSize);         // address of data buffer size
      if Res <> ERROR_SUCCESS then
        RaiseWin32Error(Res);
    end;

    for i := Length(Str) downto 1 do
      if Str[i] = #0 then
        Str[i] := #13;
    ShowMessage(Str);
  finally
    Reg.Free;
  end;
end;