Question : Nouvel utilisateur de courrier ne révélant pas en gallon.

Ressemble à l'ANNONCE n'est pas droit. Un C.C qui loge le catalogue global ne voit pas les autres deux dans la réplique d'emplacement. Je pensais à rétrograder ce C.C, mais je crains le risque de perdre le network. class= de

Réponse : Nouvel utilisateur de courrier ne révélant pas en gallon.

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 ?
    •
     
    programming4us programming4us