Question : Enregistrement, Winlogon, erreurs de KEY_WOW64_64KEY

Ceci me conduit NUTS !

In Windows 7 x64 que je dois changer, programatically, la coquille de Windows de mon application, de nouveau à l'explorateur, puis de nouveau au mien. Si vous voulez un explination quant à pourquoi juste ask.

Anyway : Fondamentalement je veux ouvrir cette clef : class= " lineNumbers " >

1 de >
HKLM \ LOGICIEL \ Microsoft " de 

I de 
1 de >
 :
2 :
3 :
4 :
5 :
le >With " de 

But de 
1 de >HKEY_LOCAL_MACHINE \ LOGICIEL \ Wow6432Node \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon
class= >


So de 

Any ? 

class= de

Réponse : Enregistrement, Winlogon, erreurs de KEY_WOW64_64KEY

Bonjour,

J'ai eu ce problème trop… ainsi avec quelques modifications et employer une autre manière d'accéder à l'enregistrement de Windows (pas using Registry.pas) j'ai fait sans des problèmes…

Le code ci-dessous est un remplacement de litghtweight pour Registry.pas avec des modifications au travail avec des drapeaux de KEY_WOW64_64KEY/KEY_WOW64_32KEY

Utilisation de base dans votre cas

Installation de votre programme comme Shell
[code] WinRegSetString (HKEY_LOCAL_MACHINE, « LOGICIEL \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell », « YourProgram.exe », rectifient) ; [/code]

si vous mettez un « Blackslash » à la clef comme (« LOGICIEL \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell \ ") il créera une nouvelle « clef » Shell appelé… sans le blackslash qu'elle accédera à une valeur appelée Shell… les mêmes pour toutes les fonctions

Revenir à Windows Shell
[code] WinRegSetString (HKEY_LOCAL_MACHINE, « LOGICIEL \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell », « Explorer.exe », rectifient) ; [/code]

Lecture de la coquille courante
[code] variété
szBuff : Corde ;
commencer
WinRegGetString (HKEY_LOCAL_MACHINE, « LOGICIEL \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell », szBuff, rectifient) ;
ShowMessage (« « » + szBuff + « « ") ; [/code]

Espoir il aide vous !
Respect,
Carlos

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 :
220 :
221 :
222 :
223 :
224 :
225 :
226 :
227 :
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 :
236 :
237 :
238 :
239 :
240 :
241 :
242 :
243 :
244 :
245 :
246 :
247 :
248 :
249 :
250 :
251 :
252 :
253 :
254 :
255 :
256 :
257 :
258 :
259 :
260 :
261 :
262 :
263 :
264 :
265 :
266 :
267 :
268 :
269 :
270 :
271 :
272 :
273 :
274 :
275 :
276 :
277 :
278 :
279 :
280 :
281 :
282 :
283 :
284 :
285 :
286 :
287 :
288 :
289 :
290 :
291 :
292 :
293 :
294 :
295 :
296 :
297 :
298 :
299 :
300 :
301 :
302 :
303 :
304 :
305 :
306 :
307 :
308 :
309 :
310 :
311 :
312 :
313 :
314 :
315 :
316 :
317 :
318 :
319 :
320 :
321 :
322 :
323 :
324 :
325 :
326 :
327 :
328 :
329 :
330 :
331 :
332 :
333 :
334 :
335 :
336 :
337 :
338 :
339 :
340 :
341 :
342 :
343 :
344 :
345 :
346 :
347 :
348 :
349 :
350 :
351 :
352 :
353 :
354 :
355 :
356 :
357 :
358 :
359 :
360 :
361 :
362 :
363 :
364 :
365 :
366 :
367 :
368 :
369 :
370 :
371 :
372 :
373 :
374 :
375 :
376 :
377 :
378 :
379 :
380 :
381 :
382 :
383 :
384 :
385 :
386 :
387 :
388 :
389 :
390 :
391 :
392 :
393 :
394 :
395 :
396 :
397 :
398 :
399 :
400 :
401 :
402 :
403 :
404 :
405 :
406 :
407 :
408 :
409 :
410 :
411 :
412 :
413 :
414 :
415 :
416 :
417 :
418 :
419 :
420 :
421 :
422 :
423 :
424 :
425 :
426 :
427 :
428 :
429 :
430 :
431 :
432 :
433 :
434 :
435 :
436 :
437 :
438 :
439 :
440 :
441 :
442 :
443 :
444 :
445 :
446 :
447 :
448 :
449 :
450 :
451 :
452 :
453 :
454 :
455 :
456 :
457 :
458 :
459 :
460 :
461 :
462 :
463 :
464 :
465 :
466 :
467 :
468 :
469 :
470 :
471 :
472 :
473 :
474 :
475 :
476 :
477 :
478 :
479 :
480 :
481 :
482 :
483 :
484 :
485 :
486 :
487 :
488 :
489 :
490 :
491 :
492 :
493 :
494 :
495 :
496 :
497 :
498 :
499 :
500 :
501 :
502 :
503 :
504 :
505 :
506 :
507 :
508 :
509 :
510 :
511 :
512 :
513 :



unité UTILS_Reg ;

interface

utilisations
  Windows,
  SysUtils,
  Classes ;

  fonction WinRegConnect (MachineName : Corde ; RootKey : HKEY ; variété RemoteKey : HKEY) : booléen ;
  fonction WinRegDisconnect (RemoteKey : HKEY) : booléen ;
  fonction WinRegValueExists (RootKey : HKEY ; Nom : Corde ; Wow64 : Booléen) : booléen ;
  fonction WinRegGetValueType (RootKey : HKEY ; Nom : Corde ; valeur de variété : Cardinal ; Wow64 : Booléen) : booléen ;
  fonction WinRegKeyExists (RootKey : HKEY ; Nom : Corde ; Wow64 : Booléen) : booléen ;
  fonction WinRegDelValue (RootKey : HKEY ; Nom : Corde ; Wow64 : Booléen) : booléen ;
  fonction WinRegDelKey (RootKey : HKEY ; Nom : Corde ; Wow64 : Booléen) : booléen ;
  fonction WinRegEnum (hRootKey : HKEY ; szKey : Corde ; Amortisseur : TStringList ; bKeys : Booléen ; Wow64 : Booléen) : Booléen ;
  fonction WinRegSetString (RootKey : HKEY ; Nom : Corde ; Valeur : Corde ; Wow64 : Booléen) : booléen ;
  fonction WinRegSetMultiString (RootKey : HKEY ; Nom : Corde ; Valeur : Corde ; Wow64 : Booléen) : booléen ;
  fonction WinRegSetExpandString (RootKey : HKEY ; Nom : Corde ; Valeur : Corde ; Wow64 : Booléen) : booléen ;
  fonction WinRegSetDword (RootKey : HKEY ; Nom : Corde ; Valeur : Cardinal ; Wow64 : Booléen) : booléen ;
  fonction WinRegSetBinary (RootKey : HKEY ; Nom : Corde ; Valeur : Choix de byte ; Wow64 : Booléen) : booléen ;
  fonction WinRegGetString (RootKey : HKEY ; Nom : Corde ; Valeur de variété : Corde ; Wow64 : Booléen) : booléen ;
  fonction WinRegGetMultiString (RootKey : HKEY ; Nom : Corde ; Valeur de variété : Corde ; Wow64 : Booléen) : booléen ;
  fonction WinRegGetExpandString (RootKey : HKEY ; Nom : Corde ; Valeur de variété : Corde ; Wow64 : Booléen) : booléen ;
  fonction WinRegGetDWORD (RootKey : HKEY ; Nom : Corde ; Valeur de variété : Cardinal ; Wow64 : Booléen) : booléen ;
  fonction WinRegGetBinary (RootKey : HKEY ; Nom : Corde ; Valeur de variété : Corde ; Wow64 : Booléen) : booléen ;
  fonction Binary2DateTime (RootKey : HKEY ; Nom : Corde ; valeur de variété : TDateTime ; Wow64 : Booléen) : Booléen ;
  fonction DateTime2Binary (RootKey : HKEY ; Nom : Corde ; valeur de variété : TDateTime ; Wow64 : Booléen) : Booléen ;
  fonction Binary2Integer (RootKey : HKEY ; Nom : Corde ; valeur de variété : Nombre entier ; Wow64 : Booléen) : Booléen ;
  fonction Integer2Binary (RootKey : HKEY ; Nom : Corde ; valeur de variété : Nombre entier ; Wow64 : Booléen) : Booléen ;

exécution

fonction IsWow64 : Booléen ;
type
  TIsWow64Process = fonction (type de // d'IsWow64Process api F-N
    Poignée : Windows.THandle ; recherche de variété : Windows.BOOL
  ) : Windows.BOOL ; stdcall ;
variété
  IsWow64Result : Windows.BOOL ;      Résultat de // d'IsWow64Process
  IsWow64Process : TIsWow64Process ;  Référence de // IsWow64Process F-N
commencer
  Essai de // pour charger la fonction required de kernel32
  IsWow64Process : = Windows.GetProcAddress (
    Windows.GetModuleHandle (« kernel32.dll "), « IsWow64Process »
  ) ;
  si assigné (IsWow64Process) alors
  commencer
    La fonction de // est mise en application : l'appeler
    sinon IsWow64Process (
      Windows.GetCurrentProcess, IsWow64Result
    ) puis
      augmenter SysUtils.Exception.Create (« IsWow64 : mauvaise poignée de processus ") ;
    Résultat de retour de // de fonction
    Résultat : = IsWow64Result ;
  extrémité
  autrement
    Fonction de // non mise en application : ne peut pas courir sur Wow64
    Résultat : = faux ;
extrémité ;

fonction Binary2DateTime (RootKey : HKEY ; Nom : Corde ; valeur de variété : TDateTime ; Wow64 : Booléen) : Booléen ;
variété
  dtBuff : TDateTime ;
  dtBytes : choix [1..8] de dtBuff d'absolu de byte ;
  szBin : corde ;
  i : nombre entier ;
commencer
  Résultat : = WinRegGetBinary (RootKey, nom, szBin, Wow64) ;

  si résultat alors
  Résultat : = longueur (szBin) = 8 ;

  si résultat alors
  commencer
    pour I : = 1 à 8 font
    dtBytes [I] : = ord (szBin [I]) ;
    Valeur : = dtBuff ;
  extrémité ;
extrémité ;

fonction DateTime2Binary (RootKey : HKEY ; Nom : Corde ; valeur de variété : TDateTime ; Wow64 : Booléen) : Booléen ;
variété
  dtBuff : TDateTime ;
  dtBytes : choix [1..8] de dtBuff d'absolu de byte ;
commencer
  dtBuff : = valeur ;
  Résultat : = WinRegSetBinary (RootKey, nom, dtBytes, Wow64) ;
extrémité ;

fonction Binary2Integer (RootKey : HKEY ; Nom : Corde ; valeur de variété : Nombre entier ; Wow64 : Booléen) : Booléen ;
variété
  iBuff : Nombre entier ;
  dtBytes : choix [1..4] d'iBuff d'absolu de byte ;
  szBin : corde ;
  i : nombre entier ;
commencer
  Résultat : = WinRegGetBinary (RootKey, nom, szBin, Wow64) ;

  si résultat alors
  Résultat : = longueur (szBin) = 4 ;

  si résultat alors
  commencer
    pour I : = 1 à 4 font
    dtBytes [I] : = ord (szBin [I]) ;
    Valeur : = iBuff ;
  extrémité ;
extrémité ;

fonction Integer2Binary (RootKey : HKEY ; Nom : Corde ; valeur de variété : Nombre entier ; Wow64 : Booléen) : Booléen ;
variété
  iBuff : Nombre entier ;
  dtBytes : choix [1..4] d'iBuff d'absolu de byte ;
commencer
  iBuff : = valeur ;
  Résultat : = WinRegSetBinary (RootKey, nom, dtBytes, Wow64) ;
extrémité ;

fonction LastPos (aiguille : Char ; Meule de foin : Corde) : nombre entier ;
commencer
  pour le résultat : = le downto 1 de longueur (meule de foin) font
  si meule de foin [résultat] = aiguille alors
  Coupure ;
extrémité ;

fonction WinRegConnect (MachineName : Corde ; RootKey : HKEY ; variété RemoteKey : HKEY) : booléen ;
commencer
  Résultat : = (RegConnectRegistry (PChar (MachineName), RootKey, RemoteKey) = ERROR_SUCCESS) ;
extrémité ;

fonction WinRegDisconnect (RemoteKey : HKEY) : booléen ;
commencer
  Résultat : = (RegCloseKey (RemoteKey) = ERROR_SUCCESS) ;
extrémité ;

fonction RegSetValue (RootKey : HKEY ; Nom : Corde ; ValType : Cardinal ; PVal : Indicateur ; ValSize : Cardinal ; Wow64 : Booléen) : booléen ;
variété
  SubKey : Corde ;
  n : nombre entier ;
  dispo : DWORD ;
  hTemp : HKEY ;
  bSuccess : Booléen ;
  _hKey : Cardinal ;
commencer
  Résultat : = faux ;
  
  n : = LastPos (« \ », nom) ;
  si n > 0 puis
  commencer
    SubKey : = copie (nom, 1, n - 1) ;

    si Wow64 et IsWow64 alors
    _hKey : = KEY_WRITE ou KEY_WOW64_64KEY autrement
    s'IsWow64 et pas puis Wow64
    _hKey : = KEY_WRITE ou KEY_WOW64_32KEY autrement
    _hKey : = KEY_WRITE ;

    bSuccess : = RegCreateKeyEx (RootKey, PChar (SubKey), 0, zéro, REG_OPTION_NON_VOLATILE, _hKey, zéro, hTemp, @dispo) = ERROR_SUCCESS ;

    si bSuccess alors
    commencer
      SubKey : = copie (nom, n + 1, longueur (nom) - n) ;
      Résultat : = (RegSetValueEx (hTemp, PChar (SubKey), 0, ValType, PVal, ValSize) = ERROR_SUCCESS) ;
      RegCloseKey (hTemp) ;
    extrémité ;
  extrémité ;
extrémité ;

fonction RegGetValue (RootKey : HKEY ; Nom : Corde ; ValType : Cardinal ; variété PVal : Indicateur ;
  variété ValSize : Cardinal ; Wow64 : Booléen) : booléen ;
variété
  SubKey : Corde ;
  n : nombre entier ;
  MyValType : DWORD ;
  hTemp : HKEY ;
  Buf : Indicateur ;
  BufSize : Cardinal ;
  _hKey : Cardinal ;
commencer
  Résultat : = faux ;
  n : = LastPos (« \ », nom) ;
  si n > 0 puis
  commencer
    SubKey : = copie (nom, 1, n - 1) ;

    si Wow64 et IsWow64 alors
    _hKey : = KEY_READ ou KEY_WOW64_64KEY autrement
    s'IsWow64 et pas puis Wow64
    _hKey : = KEY_READ ou KEY_WOW64_32KEY autrement
    _hKey : = KEY_READ ;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS alors
    commencer
      SubKey : = copie (nom, n + 1, longueur (nom) - n) ;
      si RegQueryValueEx (le hTemp, PChar (SubKey), zéro, @MyValType, zéro, @BufSize) = ERROR_SUCCESS alors
      commencer
        GetMem (Buf, BufSize) ;
        si RegQueryValueEx (le hTemp, PChar (SubKey), zéro, @MyValType, Buf, @BufSize) = ERROR_SUCCESS alors
        commencer
          si ValType = puis MyValType
          commencer
            PVal : = Buf ;
            ValSize : = BufSize ;
            Résultat : = rectifier ;
          extrémité
          autrement
          FreeMem (Buf) ;
        extrémité
        autrement
        FreeMem (Buf) ;
      extrémité ;
      RegCloseKey (hTemp) ;
    extrémité ;
  extrémité ;
extrémité ;

fonction WinRegValueExists (RootKey : HKEY ; Nom : Corde ; Wow64 : Booléen) : booléen ;
variété
  SubKey : Corde ;
  n : nombre entier ;
  hTemp : HKEY ;
  _hKey : Poignée en T ;
commencer
  Résultat : = faux ;
  n : = LastPos (« \ », nom) ;
  si n > 0 puis
  commencer
    SubKey : = copie (nom, 1, n - 1) ;

    si Wow64 et IsWow64 alors
    _hKey : = KEY_READ ou KEY_WOW64_64KEY autrement
    s'IsWow64 et pas puis Wow64
    _hKey : = KEY_READ ou KEY_WOW64_32KEY autrement
    _hKey : = KEY_READ ;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS alors
    commencer
      SubKey : = copie (nom, n + 1, longueur (nom) - n) ;
      Résultat : = (RegQueryValueEx (hTemp, PChar (SubKey), zéro, zéro, zéro, zéro) = ERROR_SUCCESS) ;
      RegCloseKey (hTemp) ;
    extrémité ;
  extrémité ;
extrémité ;

fonction WinRegGetValueType (RootKey : HKEY ; Nom : Corde ; valeur de variété : Cardinal ; Wow64 : Booléen) : booléen ;
variété
  SubKey : Corde ;
  n : nombre entier ;
  hTemp : HKEY ;
  ValType : Cardinal ;
  _hKey : Cardinal ;
commencer
  Résultat : = faux ;
  Valeur : = REG_NONE ;
  n : = LastPos (« \ », nom) ;
  si n > 0 puis
  commencer
    SubKey : = copie (nom, 1, n - 1) ;

    si Wow64 et IsWow64 alors
    _hKey : = KEY_READ ou KEY_WOW64_64KEY autrement
    s'IsWow64 et pas puis Wow64
    _hKey : = KEY_READ ou KEY_WOW64_32KEY autrement
    _hKey : = KEY_READ ;

    si (RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS) puis
    commencer
      SubKey : = copie (nom, n + 1, longueur (nom) - n) ;
      Résultat : = (RegQueryValueEx (hTemp, PChar (SubKey), zéro, @ValType, zéro, zéro) = ERROR_SUCCESS) ;
      si résultat alors
      Valeur : = ValType ;
      RegCloseKey (hTemp) ;
    extrémité ;
  extrémité ;
extrémité ;

fonction WinRegKeyExists (RootKey : HKEY ; Nom : Corde ; Wow64 : Booléen) : booléen ;
variété
  SubKey : Corde ;
  n : nombre entier ;
  hTemp : HKEY ;
  _hKey : Cardinal ;
commencer
  Résultat : = faux ;
  n : = LastPos (« \ », nom) ;
  si n > 0 puis
  commencer
    SubKey : = copie (nom, 1, n - 1) ;

    si Wow64 et IsWow64 alors
    _hKey : = KEY_READ ou KEY_WOW64_64KEY autrement
    s'IsWow64 et pas puis Wow64
    _hKey : = KEY_READ ou KEY_WOW64_32KEY autrement
    _hKey : = KEY_READ ;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS alors
    commencer
      Résultat : = rectifier ;
      RegCloseKey (hTemp) ;
    extrémité ;
  extrémité ;
extrémité ;

fonction WinRegDelValue (RootKey : HKEY ; Nom : Corde ; Wow64 : Booléen) : booléen ;
variété
  SubKey : Corde ;
  n : nombre entier ;
  hTemp : HKEY ;
  _hKey : Cardinal ;
commencer
  Résultat : = faux ;
  n : = LastPos (« \ », nom) ;
  si n > 0 puis
  commencer
    SubKey : = copie (nom, 1, n - 1) ;

    si Wow64 et IsWow64 alors
    _hKey : = KEY_WRITE ou KEY_WOW64_64KEY autrement
    s'IsWow64 et pas puis Wow64
    _hKey : = KEY_WRITE ou KEY_WOW64_32KEY autrement
    _hKey : = KEY_WRITE ;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS alors
    commencer
      SubKey : = copie (nom, n + 1, longueur (nom) - n) ;
      Résultat : = (RegDeleteValue (hTemp, PChar (SubKey)) = ERROR_SUCCESS) ;
      RegCloseKey (hTemp) ;
    extrémité ;
  extrémité ;
extrémité ;

fonction WinRegDelKey (RootKey : HKEY ; Nom : Corde ; Wow64 : Booléen) : booléen ;
variété
  SubKey : Corde ;
  n : nombre entier ;
  hTemp : HKEY ;
  _hKey : Cardinal ;
commencer
  Résultat : = faux ;
  n : = LastPos (« \ », nom) ;
  si n > 0 puis
  commencer
    SubKey : = copie (nom, 1, n - 1) ;

    si Wow64 et IsWow64 alors
    _hKey : = KEY_WRITE ou KEY_WOW64_64KEY autrement
    s'IsWow64 et pas puis Wow64
    _hKey : = KEY_WRITE ou KEY_WOW64_32KEY autrement
    _hKey : = KEY_WRITE ;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS alors
    commencer
      SubKey : = copie (nom, n + 1, longueur (nom) - n) ;
      Résultat : = (RegDeleteKey (hTemp, PChar (SubKey)) = ERROR_SUCCESS) ;
      RegCloseKey (hTemp) ;
    extrémité ;
  extrémité ;
extrémité ;

fonction WinRegEnum (hRootKey : HKEY ; szKey : Corde ; Amortisseur : TStringList ; bKeys : Booléen ; Wow64 : Booléen) : Booléen ;
variété
  i : nombre entier ;
  colères : nombre entier ;
  s : Corde ;
  hTemp : HKEY ;
  Buf : Indicateur ;
  BufSize : Cardinal ;
  _hKey : Cardinal ;
commencer
  Résultat : = faux ;
  Buffer.Clear ;

  si Wow64 et IsWow64 alors
  _hKey : = KEY_READ ou KEY_WOW64_64KEY autrement
  s'IsWow64 et pas puis Wow64
  _hKey : = KEY_READ ou KEY_WOW64_32KEY autrement
  _hKey : = KEY_READ ;

  si RegOpenKeyEx (hRootKey, PChar (szKey), 0, _hKey, hTemp) = ERROR_SUCCESS alors
  commencer
    Résultat : = rectifier ;
    BufSize : = 1024 ;
    GetMem (buf, BufSize) ;
    i : = 0 ;
    colères : = ERROR_SUCCESS ;
    tandis que les colères = les ERROR_SUCCESS font
    commencer
      BufSize : = 1024 ;
      si bKeys alors
        colères : = RegEnumKeyEx (hTemp, I, buf, BufSize, zéro, zéro, zéro, zéro)
      autrement
        colères : = RegEnumValue (hTemp, I, buf, BufSize, zéro, zéro, zéro, zéro) ;
      si colères = puis ERROR_SUCCESS
      commencer
        SetLength (s, BufSize) ;
        CopyMemory (@s [1], buf, BufSize) ;
        Buffer.Add ;
        inc. (i) ;
      extrémité ;
    extrémité ;
    FreeMem (buf) ;
    RegCloseKey (hTemp) ;
  extrémité ;
extrémité ;

fonction WinRegSetString (RootKey : HKEY ; Nom : Corde ; Valeur : Corde ; Wow64 : Booléen) : booléen ;
commencer
  Résultat : = RegSetValue (RootKey, nom, REG_SZ, PChar (valeur + #0), longueur (valeur) + 1, Wow64) ;
extrémité ;

fonction WinRegSetMultiString (RootKey : HKEY ; Nom : Corde ; Valeur : Corde ; Wow64 : Booléen) : booléen ;
commencer
  Résultat : = RegSetValue (RootKey, nom, REG_MULTI_SZ, PChar (valeur + #0#0), longueur (valeur) + 2, Wow64) ;
extrémité ;

fonction WinRegSetExpandString (RootKey : HKEY ; Nom : Corde ; Valeur : Corde ; Wow64 : Booléen) : booléen ;
commencer
  Résultat : = RegSetValue (RootKey, nom, REG_EXPAND_SZ, PChar (valeur + #0), longueur (valeur) + 1, Wow64) ;
extrémité ;

fonction WinRegSetDword (RootKey : HKEY ; Nom : Corde ; Valeur : Cardinal ; Wow64 : Booléen) : booléen ;
commencer
  Résultat : = RegSetValue (RootKey, nom, REG_DWORD, @Value, SizeOf (cardinal), Wow64) ;
extrémité ;

fonction WinRegSetBinary (RootKey : HKEY ; Nom : Corde ; Valeur : Choix de byte ; Wow64 : Booléen) : booléen ;
commencer
  Résultat : = RegSetValue (RootKey, nom, REG_BINARY, @Value, SizeOf (valeur), Wow64) ;
extrémité ;

fonction WinRegGetString (RootKey : HKEY ; Nom : Corde ; Valeur de variété : Corde ; Wow64 : Booléen) : booléen ;
variété
  Buf : Indicateur ;
  BufSize : Cardinal ;
commencer
  Résultat : = faux ;
  si RegGetValue (RootKey, nom, REG_SZ, Buf, BufSize, Wow64) puis
  commencer
    Décembre (BufSize) ;
    SetLength (valeur, BufSize) ;
    si BufSize > 0 puis
      CopyMemory (@Value [1], Buf, BufSize) ;
    FreeMem (Buf) ;
    Résultat : = rectifier ;
  extrémité ;
extrémité ;

fonction WinRegGetMultiString (RootKey : HKEY ; Nom : Corde ; Valeur de variété : Corde ; Wow64 : Booléen) : booléen ;
variété
  Buf : Indicateur ;
  BufSize : Cardinal ;
commencer
  Résultat : = faux ;
  si RegGetValue (RootKey, nom, REG_MULTI_SZ, Buf, BufSize, Wow64) puis
  commencer
    Décembre (BufSize) ;
    SetLength (valeur, BufSize) ;
    si BufSize > 0 puis
      CopyMemory (@Value [1], Buf, BufSize) ;
    FreeMem (Buf) ;
    Résultat : = rectifier ;
  extrémité ;
extrémité ;

fonction WinRegGetExpandString (RootKey : HKEY ; Nom : Corde ; Valeur de variété : Corde ; Wow64 : Booléen) : booléen ;
variété
  Buf : Indicateur ;
  BufSize : Cardinal ;
commencer
  Résultat : = faux ;
  si RegGetValue (RootKey, nom, REG_EXPAND_SZ, Buf, BufSize, Wow64) puis
  commencer
    Décembre (BufSize) ;
    SetLength (valeur, BufSize) ;
    si BufSize > 0 puis
      CopyMemory (@Value [1], Buf, BufSize) ;
    FreeMem (Buf) ;
    Résultat : = rectifier ;
  extrémité ;
extrémité ;

fonction WinRegGetDWORD (RootKey : HKEY ; Nom : Corde ; Valeur de variété : Cardinal ; Wow64 : Booléen) : booléen ;
variété
  Buf : Indicateur ;
  BufSize : Cardinal ;
commencer
  Résultat : = faux ;
  si RegGetValue (RootKey, nom, REG_DWORD, Buf, BufSize, Wow64) puis
  commencer
    CopyMemory (@Value, Buf, BufSize) ;
    FreeMem (Buf) ;
    Résultat : = rectifier ;
  extrémité ;
extrémité ;

fonction WinRegGetBinary (RootKey : HKEY ; Nom : Corde ; Valeur de variété : Corde ; Wow64 : Booléen) : booléen ;
variété
  Buf : Indicateur ;
  BufSize : Cardinal ;
commencer
  Résultat : = faux ;
  si RegGetValue (RootKey, nom, REG_BINARY, Buf, BufSize, Wow64) puis
  commencer
    SetLength (valeur, BufSize) ;
    CopyMemory (@Value [1], Buf, BufSize) ;
    FreeMem (Buf) ;
    Résultat : = rectifier ;
  extrémité ;
extrémité ;

extrémité.

Autres solutions

MS Excel 2007 et pdf - l'exportation vers le pdf prend de longues heures !

Dans le Perl, comment j'ajoute une valeur à la liste, puis le contrôle pour voir si la valeur existent avant d'ajouter une nouvelle valeur

Comment fais j'initialiser de la HP BL460c G6 de san et de la HP XP 240000

Comment fais j'employer une clef de permis de volume sur un ordinateur de HP avec du CD de restauration

Emplacement primaire de deux SCCM dans l'annuaire actif

L'initiateur et la HP D2D de l'iSCSI R2 du serveur 2008 de Windows GERCENT l'issue

Stocker le dossier dans le mysql using connector.net et le champ de goutte

Carte vidéo d'USB - bit 32 sur le matériel travaillant au niveau du bit 64 ?

asp.net que j'essaye de convertir une forme de HTML en forme d'aspx ou ? ce qui jamais. Aide du besoin sur la façon dont à à elle.

Winzip 12 issues de secours du travail ?