[CMAKE]
[reactos.git] / base / applications / regedit / edit.c
1 /*
2 * Registry editing UI functions.
3 *
4 * Copyright (C) 2003 Dimitrie O. Paun
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <regedit.h>
22
23 typedef enum _EDIT_MODE
24 {
25 EDIT_MODE_DEC,
26 EDIT_MODE_HEX
27 } EDIT_MODE;
28
29
30 static const TCHAR* editValueName;
31 static TCHAR* stringValueData;
32 static PVOID binValueData;
33 static DWORD dwordValueData;
34 static DWORD valueDataLen;
35 static EDIT_MODE dwordEditMode = EDIT_MODE_HEX;
36
37 void error(HWND hwnd, INT resId, ...)
38 {
39 va_list ap;
40 TCHAR title[256];
41 TCHAR errfmt[1024];
42 TCHAR errstr[1024];
43 HINSTANCE hInstance;
44
45 hInstance = GetModuleHandle(0);
46
47 if (!LoadString(hInstance, IDS_ERROR, title, COUNT_OF(title)))
48 _tcscpy(title, _T("Error"));
49
50 if (!LoadString(hInstance, resId, errfmt, COUNT_OF(errfmt)))
51 _tcscpy(errfmt, _T("Unknown error string!"));
52
53 va_start(ap, resId);
54 _vsntprintf(errstr, COUNT_OF(errstr), errfmt, ap);
55 va_end(ap);
56
57 MessageBox(hwnd, errstr, title, MB_OK | MB_ICONERROR);
58 }
59
60 static void error_code_messagebox(HWND hwnd, DWORD error_code)
61 {
62 TCHAR title[256];
63 if (!LoadString(hInst, IDS_ERROR, title, COUNT_OF(title)))
64 lstrcpy(title, TEXT("Error"));
65 ErrorMessageBox(hwnd, title, error_code);
66 }
67
68 void warning(HWND hwnd, INT resId, ...)
69 {
70 va_list ap;
71 TCHAR title[256];
72 TCHAR errfmt[1024];
73 TCHAR errstr[1024];
74 HINSTANCE hInstance;
75
76 hInstance = GetModuleHandle(0);
77
78 if (!LoadString(hInstance, IDS_WARNING, title, COUNT_OF(title)))
79 _tcscpy(title, _T("Warning"));
80
81 if (!LoadString(hInstance, resId, errfmt, COUNT_OF(errfmt)))
82 _tcscpy(errfmt, _T("Unknown error string!"));
83
84 va_start(ap, resId);
85 _vsntprintf(errstr, COUNT_OF(errstr), errfmt, ap);
86 va_end(ap);
87
88 MessageBox(hwnd, errstr, title, MB_OK | MB_ICONSTOP);
89 }
90
91 INT_PTR CALLBACK modify_string_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
92 {
93 TCHAR* valueData;
94 HWND hwndValue;
95 int len;
96
97 UNREFERENCED_PARAMETER(lParam);
98
99 switch(uMsg) {
100 case WM_INITDIALOG:
101 if(editValueName && _tcscmp(editValueName, _T("")))
102 {
103 SetDlgItemText(hwndDlg, IDC_VALUE_NAME, editValueName);
104 }
105 else
106 {
107 TCHAR buffer[255];
108 LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
109 SetDlgItemText(hwndDlg, IDC_VALUE_NAME, buffer);
110 }
111 SetDlgItemText(hwndDlg, IDC_VALUE_DATA, stringValueData);
112 SetFocus(GetDlgItem(hwndDlg, IDC_VALUE_DATA));
113 return FALSE;
114 case WM_COMMAND:
115 switch (LOWORD(wParam))
116 {
117 case IDOK:
118 if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA)))
119 {
120 if ((len = GetWindowTextLength(hwndValue)))
121 {
122 if (stringValueData)
123 {
124 if ((valueData = HeapReAlloc(GetProcessHeap(), 0, stringValueData, (len + 1) * sizeof(TCHAR))))
125 {
126 stringValueData = valueData;
127 if (!GetWindowText(hwndValue, stringValueData, len + 1))
128 *stringValueData = 0;
129 }
130 }
131 else
132 {
133 if ((valueData = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(TCHAR))))
134 {
135 stringValueData = valueData;
136 if (!GetWindowText(hwndValue, stringValueData, len + 1))
137 *stringValueData = 0;
138 }
139 }
140 }
141 else
142 {
143 if (stringValueData)
144 *stringValueData = 0;
145 }
146 }
147 EndDialog(hwndDlg, IDOK);
148 break;
149 case IDCANCEL:
150 EndDialog(hwndDlg, IDCANCEL);
151 return TRUE;
152 }
153 }
154 return FALSE;
155 }
156
157
158 INT_PTR CALLBACK modify_multi_string_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
159 {
160 TCHAR* valueData;
161 HWND hwndValue;
162 int len;
163
164 UNREFERENCED_PARAMETER(lParam);
165
166 switch(uMsg) {
167 case WM_INITDIALOG:
168 if(editValueName && _tcscmp(editValueName, _T("")))
169 {
170 SetDlgItemText(hwndDlg, IDC_VALUE_NAME, editValueName);
171 }
172 else
173 {
174 TCHAR buffer[255];
175 LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
176 SetDlgItemText(hwndDlg, IDC_VALUE_NAME, buffer);
177 }
178 SetDlgItemText(hwndDlg, IDC_VALUE_DATA, stringValueData);
179 SetFocus(GetDlgItem(hwndDlg, IDC_VALUE_DATA));
180 return FALSE;
181 case WM_COMMAND:
182 switch (LOWORD(wParam))
183 {
184 case IDOK:
185 if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA)))
186 {
187 if ((len = GetWindowTextLength(hwndValue)))
188 {
189 if (stringValueData)
190 {
191 if ((valueData = HeapReAlloc(GetProcessHeap(), 0, stringValueData, (len + 1) * sizeof(TCHAR))))
192 {
193 stringValueData = valueData;
194 if (!GetWindowText(hwndValue, stringValueData, len + 1))
195 *stringValueData = 0;
196 }
197 }
198 else
199 {
200 if ((valueData = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(TCHAR))))
201 {
202 stringValueData = valueData;
203 if (!GetWindowText(hwndValue, stringValueData, len + 1))
204 *stringValueData = 0;
205 }
206 }
207 }
208 else
209 {
210 if (stringValueData)
211 *stringValueData = 0;
212 }
213 }
214 EndDialog(hwndDlg, IDOK);
215 break;
216 case IDCANCEL:
217 EndDialog(hwndDlg, IDCANCEL);
218 return TRUE;
219 }
220 }
221 return FALSE;
222 }
223
224
225 LRESULT CALLBACK DwordEditSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
226 {
227 WNDPROC oldwndproc;
228
229 oldwndproc = (WNDPROC)(LONG_PTR)GetWindowLongPtr(hwnd, GWL_USERDATA);
230
231 switch (uMsg)
232 {
233 case WM_CHAR:
234 if (dwordEditMode == EDIT_MODE_DEC)
235 {
236 if (isdigit((int) wParam & 0xff) || iscntrl((int) wParam & 0xff))
237 {
238 break;
239 }
240 else
241 {
242 return 0;
243 }
244 }
245 else if (dwordEditMode == EDIT_MODE_HEX)
246 {
247 if (isxdigit((int) wParam & 0xff) || iscntrl((int) wParam & 0xff))
248 {
249 break;
250 }
251 else
252 {
253 return 0;
254 }
255 }
256 else
257 {
258 break;
259 }
260 }
261
262 return CallWindowProc(oldwndproc, hwnd, uMsg, wParam, lParam);
263 }
264
265
266 INT_PTR CALLBACK modify_dword_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
267 {
268 WNDPROC oldproc;
269 HWND hwndValue;
270 TCHAR ValueString[32];
271 LPTSTR Remainder;
272 DWORD Base;
273 DWORD Value = 0;
274
275 UNREFERENCED_PARAMETER(lParam);
276
277 switch(uMsg) {
278 case WM_INITDIALOG:
279 dwordEditMode = EDIT_MODE_HEX;
280
281 /* subclass the edit control */
282 hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA);
283 oldproc = (WNDPROC)(LONG_PTR)GetWindowLongPtr(hwndValue, GWL_WNDPROC);
284 SetWindowLongPtr(hwndValue, GWL_USERDATA, (DWORD_PTR)oldproc);
285 SetWindowLongPtr(hwndValue, GWL_WNDPROC, (DWORD_PTR)DwordEditSubclassProc);
286
287 if(editValueName && _tcscmp(editValueName, _T("")))
288 {
289 SetDlgItemText(hwndDlg, IDC_VALUE_NAME, editValueName);
290 }
291 else
292 {
293 TCHAR buffer[255];
294 LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
295 SetDlgItemText(hwndDlg, IDC_VALUE_NAME, buffer);
296 }
297 CheckRadioButton (hwndDlg, IDC_FORMAT_HEX, IDC_FORMAT_DEC, IDC_FORMAT_HEX);
298 _stprintf (ValueString, _T("%lx"), dwordValueData);
299 SetDlgItemText(hwndDlg, IDC_VALUE_DATA, ValueString);
300 SetFocus(GetDlgItem(hwndDlg, IDC_VALUE_DATA));
301 return FALSE;
302
303 case WM_COMMAND:
304 switch (LOWORD(wParam))
305 {
306 case IDC_FORMAT_HEX:
307 if (HIWORD(wParam) == BN_CLICKED && dwordEditMode == EDIT_MODE_DEC)
308 {
309 dwordEditMode = EDIT_MODE_HEX;
310 if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA)))
311 {
312 if (GetWindowTextLength(hwndValue))
313 {
314 if (GetWindowText(hwndValue, ValueString, 32))
315 {
316 Value = _tcstoul (ValueString, &Remainder, 10);
317 }
318 }
319 }
320 _stprintf (ValueString, _T("%lx"), Value);
321 SetDlgItemText(hwndDlg, IDC_VALUE_DATA, ValueString);
322 return TRUE;
323 }
324 break;
325
326 case IDC_FORMAT_DEC:
327 if (HIWORD(wParam) == BN_CLICKED && dwordEditMode == EDIT_MODE_HEX)
328 {
329 dwordEditMode = EDIT_MODE_DEC;
330 if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA)))
331 {
332 if (GetWindowTextLength(hwndValue))
333 {
334 if (GetWindowText(hwndValue, ValueString, 32))
335 {
336 Value = _tcstoul (ValueString, &Remainder, 16);
337 }
338 }
339 }
340 _stprintf (ValueString, _T("%lu"), Value);
341 SetDlgItemText(hwndDlg, IDC_VALUE_DATA, ValueString);
342 return TRUE;
343 }
344 break;
345
346 case IDOK:
347 if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA)))
348 {
349 if (GetWindowTextLength(hwndValue))
350 {
351 if (!GetWindowText(hwndValue, ValueString, 32))
352 {
353 EndDialog(hwndDlg, IDCANCEL);
354 return TRUE;
355 }
356
357 Base = (dwordEditMode == EDIT_MODE_HEX) ? 16 : 10;
358 dwordValueData = _tcstoul (ValueString, &Remainder, Base);
359 }
360 else
361 {
362 EndDialog(hwndDlg, IDCANCEL);
363 return TRUE;
364 }
365 }
366 EndDialog(hwndDlg, IDOK);
367 return TRUE;
368
369 case IDCANCEL:
370 EndDialog(hwndDlg, IDCANCEL);
371 return TRUE;
372 }
373 }
374 return FALSE;
375 }
376
377
378 INT_PTR CALLBACK modify_binary_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
379 {
380 HWND hwndValue;
381 UINT len;
382
383 UNREFERENCED_PARAMETER(lParam);
384
385 switch(uMsg) {
386 case WM_INITDIALOG:
387 if(editValueName && _tcscmp(editValueName, _T("")))
388 {
389 SetDlgItemText(hwndDlg, IDC_VALUE_NAME, editValueName);
390 }
391 else
392 {
393 TCHAR buffer[255];
394 LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
395 SetDlgItemText(hwndDlg, IDC_VALUE_NAME, buffer);
396 }
397 hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA);
398 HexEdit_LoadBuffer(hwndValue, binValueData, valueDataLen);
399 /* reset the hex edit control's font */
400 SendMessage(hwndValue, WM_SETFONT, 0, 0);
401 SetFocus(hwndValue);
402 return FALSE;
403 case WM_COMMAND:
404 switch (LOWORD(wParam))
405 {
406 case IDOK:
407 if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA)))
408 {
409 len = (UINT) HexEdit_GetBufferSize(hwndValue);
410 if (len > 0 && binValueData)
411 binValueData = HeapReAlloc(GetProcessHeap(), 0, binValueData, len);
412 else
413 binValueData = HeapAlloc(GetProcessHeap(), 0, len + 1);
414 HexEdit_CopyBuffer(hwndValue, binValueData, len);
415 valueDataLen = len;
416 }
417 EndDialog(hwndDlg, IDOK);
418 break;
419 case IDCANCEL:
420 EndDialog(hwndDlg, IDCANCEL);
421 return TRUE;
422 }
423 }
424 return FALSE;
425 }
426
427
428 BOOL ModifyValue(HWND hwnd, HKEY hKey, LPCTSTR valueName, BOOL EditBin)
429 {
430 DWORD type;
431 LONG lRet;
432 BOOL result = FALSE;
433
434 if (!hKey)
435 return FALSE;
436
437 editValueName = valueName;
438
439 lRet = RegQueryValueEx(hKey, valueName, 0, &type, 0, &valueDataLen);
440 if (lRet != ERROR_SUCCESS && (!_tcscmp(valueName, _T("")) || valueName == NULL))
441 {
442 lRet = ERROR_SUCCESS; /* Allow editing of (Default) values which don't exist */
443 type = REG_SZ;
444 valueDataLen = 0;
445 stringValueData = NULL;
446 binValueData = NULL;
447 }
448
449 if (lRet != ERROR_SUCCESS)
450 {
451 error(hwnd, IDS_BAD_VALUE, valueName);
452 goto done;
453 }
454
455 if (EditBin == FALSE && ((type == REG_SZ) || (type == REG_EXPAND_SZ)))
456 {
457 if (valueDataLen > 0)
458 {
459 if (!(stringValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen)))
460 {
461 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
462 goto done;
463 }
464 lRet = RegQueryValueEx(hKey, valueName, 0, 0, (LPBYTE)stringValueData, &valueDataLen);
465 if (lRet != ERROR_SUCCESS)
466 {
467 error(hwnd, IDS_BAD_VALUE, valueName);
468 goto done;
469 }
470 }
471 else
472 {
473 stringValueData = NULL;
474 }
475
476 if (DialogBox(0, MAKEINTRESOURCE(IDD_EDIT_STRING), hwnd, modify_string_dlgproc) == IDOK)
477 {
478 if (stringValueData)
479 {
480 lRet = RegSetValueEx(hKey, valueName, 0, type, (LPBYTE)stringValueData, (DWORD) (_tcslen(stringValueData) + 1) * sizeof(TCHAR));
481 }
482 else
483 {
484 lRet = RegSetValueEx(hKey, valueName, 0, type, NULL, 0);
485 }
486 if (lRet == ERROR_SUCCESS)
487 result = TRUE;
488 }
489 }
490 else if (EditBin == FALSE && type == REG_MULTI_SZ)
491 {
492 if (valueDataLen > 0)
493 {
494 size_t llen, listlen, nl_len;
495 LPTSTR src, lines = NULL;
496
497 if (!(stringValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen)))
498 {
499 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
500 goto done;
501 }
502 lRet = RegQueryValueEx(hKey, valueName, 0, 0, (LPBYTE)stringValueData, &valueDataLen);
503 if (lRet != ERROR_SUCCESS)
504 {
505 error(hwnd, IDS_BAD_VALUE, valueName);
506 goto done;
507 }
508
509 /* convert \0 to \r\n */
510 src = stringValueData;
511 nl_len = _tcslen(_T("\r\n")) * sizeof(TCHAR);
512 listlen = sizeof(TCHAR);
513 lines = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, listlen + sizeof(TCHAR));
514 while(*src != _T('\0'))
515 {
516 llen = _tcslen(src);
517 if(llen == 0)
518 break;
519 listlen += (llen * sizeof(TCHAR)) + nl_len;
520 lines = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lines, listlen);
521 _tcscat(lines, src);
522 _tcscat(lines, _T("\r\n"));
523 src += llen + 1;
524 }
525 HeapFree(GetProcessHeap(), 0, stringValueData);
526 stringValueData = lines;
527 }
528 else
529 {
530 stringValueData = NULL;
531 }
532
533 if (DialogBox(0, MAKEINTRESOURCE(IDD_EDIT_MULTI_STRING), hwnd, modify_multi_string_dlgproc) == IDOK)
534 {
535 if (stringValueData)
536 {
537 /* convert \r\n to \0 */
538 BOOL EmptyLines = FALSE;
539 LPTSTR src, lines, nl;
540 size_t linechars, buflen, c_nl, dest;
541
542 src = stringValueData;
543 buflen = sizeof(TCHAR);
544 lines = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen + sizeof(TCHAR));
545 c_nl = _tcslen(_T("\r\n"));
546 dest = 0;
547 while(*src != _T('\0'))
548 {
549 if((nl = _tcsstr(src, _T("\r\n"))))
550 {
551 linechars = nl - src;
552 if(nl == src)
553 {
554 EmptyLines = TRUE;
555 src = nl + c_nl;
556 continue;
557 }
558 }
559 else
560 {
561 linechars = _tcslen(src);
562 }
563 if(linechars > 0)
564 {
565 buflen += ((linechars + 1) * sizeof(TCHAR));
566 lines = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lines, buflen);
567 memcpy((lines + dest), src, linechars * sizeof(TCHAR));
568 dest += linechars;
569 lines[dest++] = _T('\0');
570 }
571 else
572 {
573 EmptyLines = TRUE;
574 }
575 src += linechars + (nl != NULL ? c_nl : 0);
576 }
577 lines[++dest] = _T('\0');
578
579 if(EmptyLines)
580 {
581 warning(hwnd, IDS_MULTI_SZ_EMPTY_STRING);
582 }
583
584 lRet = RegSetValueEx(hKey, valueName, 0, type, (LPBYTE)lines, (DWORD) buflen);
585 HeapFree(GetProcessHeap(), 0, lines);
586 }
587 else
588 {
589 lRet = RegSetValueEx(hKey, valueName, 0, type, NULL, 0);
590 }
591 if (lRet == ERROR_SUCCESS)
592 result = TRUE;
593 }
594 }
595 else if (EditBin == FALSE && type == REG_DWORD)
596 {
597 lRet = RegQueryValueEx(hKey, valueName, 0, 0, (LPBYTE)&dwordValueData, &valueDataLen);
598 if (lRet != ERROR_SUCCESS)
599 {
600 error(hwnd, IDS_BAD_VALUE, valueName);
601 goto done;
602 }
603
604 if (DialogBox(0, MAKEINTRESOURCE(IDD_EDIT_DWORD), hwnd, modify_dword_dlgproc) == IDOK)
605 {
606 lRet = RegSetValueEx(hKey, valueName, 0, type, (LPBYTE)&dwordValueData, sizeof(DWORD));
607 if (lRet == ERROR_SUCCESS)
608 result = TRUE;
609 }
610 }
611 else if (EditBin == TRUE || type == REG_NONE || type == REG_BINARY)
612 {
613 #ifndef UNICODE
614 LPWSTR u_valuename;
615 int len_vname = lstrlen(valueName);
616
617 if(len_vname > 0)
618 {
619 if(!(u_valuename = HeapAlloc(GetProcessHeap(), 0, (len_vname + 1) * sizeof(WCHAR))))
620 {
621 error(hwnd, IDS_TOO_BIG_VALUE, len_vname);
622 goto done;
623 }
624 /* convert the ansi value name to an unicode string */
625 MultiByteToWideChar(CP_ACP, 0, valueName, -1, u_valuename, len_vname + 1);
626 valueDataLen *= sizeof(WCHAR);
627 }
628 else
629 u_valuename = L"";
630 #endif
631 if(valueDataLen > 0)
632 {
633 if(!(binValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen + 1)))
634 {
635 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
636 goto done;
637 }
638
639 /* force to use the unicode version, so editing strings in binary mode is correct */
640 lRet = RegQueryValueExW(hKey,
641 #ifndef UNICODE
642 u_valuename,
643 #else
644 valueName,
645 #endif
646 0, 0, (LPBYTE)binValueData, &valueDataLen);
647 if (lRet != ERROR_SUCCESS)
648 {
649 HeapFree(GetProcessHeap(), 0, binValueData);
650 #ifndef UNICODE
651 if(len_vname > 0)
652 HeapFree(GetProcessHeap(), 0, u_valuename);
653 #endif
654 error(hwnd, IDS_BAD_VALUE, valueName);
655 goto done;
656 }
657 }
658 else
659 {
660 binValueData = NULL;
661 }
662
663 if (DialogBox(0, MAKEINTRESOURCE(IDD_EDIT_BIN_DATA), hwnd, modify_binary_dlgproc) == IDOK)
664 {
665 /* force to use the unicode version, so editing strings in binary mode is correct */
666 lRet = RegSetValueExW(hKey,
667 #ifndef UNICODE
668 u_valuename,
669 #else
670 valueName,
671 #endif
672 0, type, (LPBYTE)binValueData, valueDataLen);
673 if (lRet == ERROR_SUCCESS)
674 result = TRUE;
675 }
676 if(binValueData != NULL)
677 HeapFree(GetProcessHeap(), 0, binValueData);
678 #ifndef UNICODE
679 if(len_vname > 0)
680 HeapFree(GetProcessHeap(), 0, u_valuename);
681 #endif
682 }
683 else
684 {
685 error(hwnd, IDS_UNSUPPORTED_TYPE, type);
686 }
687
688 done:
689 if (stringValueData)
690 HeapFree(GetProcessHeap(), 0, stringValueData);
691 stringValueData = NULL;
692
693 return result;
694 }
695
696 static LONG CopyKey(HKEY hDestKey, LPCTSTR lpDestSubKey, HKEY hSrcKey, LPCTSTR lpSrcSubKey)
697 {
698 LONG lResult;
699 DWORD dwDisposition;
700 HKEY hDestSubKey = NULL;
701 HKEY hSrcSubKey = NULL;
702 DWORD dwIndex, dwType, cbName, cbData;
703 TCHAR szSubKey[256];
704 TCHAR szValueName[256];
705 BYTE szValueData[512];
706
707 FILETIME ft;
708
709 /* open the source subkey, if specified */
710 if (lpSrcSubKey)
711 {
712 lResult = RegOpenKeyEx(hSrcKey, lpSrcSubKey, 0, KEY_ALL_ACCESS, &hSrcSubKey);
713 if (lResult)
714 goto done;
715 hSrcKey = hSrcSubKey;
716 }
717
718 /* create the destination subkey */
719 lResult = RegCreateKeyEx(hDestKey, lpDestSubKey, 0, NULL, 0, KEY_WRITE, NULL,
720 &hDestSubKey, &dwDisposition);
721 if (lResult)
722 goto done;
723
724 /* copy all subkeys */
725 dwIndex = 0;
726 do
727 {
728 cbName = sizeof(szSubKey) / sizeof(szSubKey[0]);
729 lResult = RegEnumKeyEx(hSrcKey, dwIndex++, szSubKey, &cbName, NULL, NULL, NULL, &ft);
730 if (lResult == ERROR_SUCCESS)
731 {
732 lResult = CopyKey(hDestSubKey, szSubKey, hSrcKey, szSubKey);
733 if (lResult)
734 goto done;
735 }
736 }
737 while(lResult == ERROR_SUCCESS);
738
739 /* copy all subvalues */
740 dwIndex = 0;
741 do
742 {
743 cbName = sizeof(szValueName) / sizeof(szValueName[0]);
744 cbData = sizeof(szValueData) / sizeof(szValueData[0]);
745 lResult = RegEnumValue(hSrcKey, dwIndex++, szValueName, &cbName, NULL, &dwType, szValueData, &cbData);
746 if (lResult == ERROR_SUCCESS)
747 {
748 lResult = RegSetValueEx(hDestSubKey, szValueName, 0, dwType, szValueData, cbData);
749 if (lResult)
750 goto done;
751 }
752 }
753 while(lResult == ERROR_SUCCESS);
754
755 lResult = ERROR_SUCCESS;
756
757 done:
758 if (hSrcSubKey)
759 RegCloseKey(hSrcSubKey);
760 if (hDestSubKey)
761 RegCloseKey(hDestSubKey);
762 if (lResult != ERROR_SUCCESS)
763 SHDeleteKey(hDestKey, lpDestSubKey);
764 return lResult;
765 }
766
767 static LONG MoveKey(HKEY hDestKey, LPCTSTR lpDestSubKey, HKEY hSrcKey, LPCTSTR lpSrcSubKey)
768 {
769 LONG lResult;
770
771 if (!lpSrcSubKey)
772 return ERROR_INVALID_FUNCTION;
773
774 lResult = CopyKey(hDestKey, lpDestSubKey, hSrcKey, lpSrcSubKey);
775 if (lResult == ERROR_SUCCESS)
776 SHDeleteKey(hSrcKey, lpSrcSubKey);
777
778 return lResult;
779 }
780
781 BOOL DeleteKey(HWND hwnd, HKEY hKeyRoot, LPCTSTR keyPath)
782 {
783 TCHAR msg[128], caption[128];
784 BOOL result = FALSE;
785 LONG lRet;
786 HKEY hKey;
787
788 lRet = RegOpenKeyEx(hKeyRoot, keyPath, 0, KEY_READ|KEY_SET_VALUE, &hKey);
789 if (lRet != ERROR_SUCCESS) {
790 error_code_messagebox(hwnd, lRet);
791 return FALSE;
792 }
793
794 LoadString(hInst, IDS_QUERY_DELETE_KEY_CONFIRM, caption, sizeof(caption)/sizeof(TCHAR));
795 LoadString(hInst, IDS_QUERY_DELETE_KEY_ONE, msg, sizeof(msg)/sizeof(TCHAR));
796
797 if (MessageBox(g_pChildWnd->hWnd, msg, caption, MB_ICONQUESTION | MB_YESNO) != IDYES)
798 goto done;
799
800 lRet = SHDeleteKey(hKeyRoot, keyPath);
801 if (lRet != ERROR_SUCCESS) {
802 error(hwnd, IDS_BAD_KEY, keyPath);
803 goto done;
804 }
805 result = TRUE;
806
807 done:
808 RegCloseKey(hKey);
809 return result;
810 }
811
812 LONG RenameKey(HKEY hKey, LPCTSTR lpSubKey, LPCTSTR lpNewName)
813 {
814 LPCTSTR s;
815 LPTSTR lpNewSubKey = NULL;
816 LONG Ret = 0;
817
818 if (!lpSubKey)
819 return Ret;
820
821 s = _tcsrchr(lpSubKey, _T('\\'));
822 if (s)
823 {
824 s++;
825 lpNewSubKey = (LPTSTR) HeapAlloc(GetProcessHeap(), 0, (s - lpSubKey + _tcslen(lpNewName) + 1) * sizeof(TCHAR));
826 if (lpNewSubKey != NULL)
827 {
828 memcpy(lpNewSubKey, lpSubKey, (s - lpSubKey) * sizeof(TCHAR));
829 lstrcpy(lpNewSubKey + (s - lpSubKey), lpNewName);
830 lpNewName = lpNewSubKey;
831 }
832 else
833 return ERROR_NOT_ENOUGH_MEMORY;
834 }
835
836 Ret = MoveKey(hKey, lpNewName, hKey, lpSubKey);
837
838 if (lpNewSubKey)
839 {
840 HeapFree(GetProcessHeap(), 0, lpNewSubKey);
841 }
842 return Ret;
843 }
844
845 LONG RenameValue(HKEY hKey, LPCTSTR lpSubKey, LPCTSTR lpDestValue, LPCTSTR lpSrcValue)
846 {
847 LONG lResult;
848 HKEY hSubKey = NULL;
849 DWORD dwType, cbData;
850 BYTE data[512];
851
852 if (lpSubKey)
853 {
854 lResult = RegOpenKey(hKey, lpSubKey, &hSubKey);
855 if (lResult != ERROR_SUCCESS)
856 goto done;
857 hKey = hSubKey;
858 }
859
860 cbData = sizeof(data);
861 lResult = RegQueryValueEx(hKey, lpSrcValue, NULL, &dwType, data, &cbData);
862 if (lResult != ERROR_SUCCESS)
863 goto done;
864
865 lResult = RegSetValueEx(hKey, lpDestValue, 0, dwType, data, cbData);
866 if (lResult != ERROR_SUCCESS)
867 goto done;
868
869 RegDeleteValue(hKey, lpSrcValue);
870
871 done:
872 if (hSubKey)
873 RegCloseKey(hSubKey);
874 return lResult;
875 }
876
877 LONG QueryStringValue(HKEY hKey, LPCTSTR lpSubKey, LPCTSTR lpValueName, LPTSTR pszBuffer, DWORD dwBufferLen)
878 {
879 LONG lResult;
880 HKEY hSubKey = NULL;
881 DWORD cbData, dwType;
882
883 if (lpSubKey)
884 {
885 lResult = RegOpenKey(hKey, lpSubKey, &hSubKey);
886 if (lResult != ERROR_SUCCESS)
887 goto done;
888 hKey = hSubKey;
889 }
890
891 cbData = (dwBufferLen - 1) * sizeof(*pszBuffer);
892 lResult = RegQueryValueEx(hKey, lpValueName, NULL, &dwType, (LPBYTE) pszBuffer, &cbData);
893 if (lResult != ERROR_SUCCESS)
894 goto done;
895 if (dwType != REG_SZ)
896 {
897 lResult = -1;
898 goto done;
899 }
900
901 pszBuffer[cbData / sizeof(*pszBuffer)] = _T('\0');
902
903 done:
904 if (lResult != ERROR_SUCCESS)
905 pszBuffer[0] = _T('\0');
906 if (hSubKey)
907 RegCloseKey(hSubKey);
908 return lResult;
909 }
910
911 BOOL GetKeyName(LPTSTR pszDest, size_t iDestLength, HKEY hRootKey, LPCTSTR lpSubKey)
912 {
913 LPCTSTR pszRootKey;
914
915 if (hRootKey == HKEY_CLASSES_ROOT)
916 pszRootKey = TEXT("HKEY_CLASSES_ROOT");
917 else if (hRootKey == HKEY_CURRENT_USER)
918 pszRootKey = TEXT("HKEY_CURRENT_USER");
919 else if (hRootKey == HKEY_LOCAL_MACHINE)
920 pszRootKey = TEXT("HKEY_LOCAL_MACHINE");
921 else if (hRootKey == HKEY_USERS)
922 pszRootKey = TEXT("HKEY_USERS");
923 else if (hRootKey == HKEY_CURRENT_CONFIG)
924 pszRootKey = TEXT("HKEY_CURRENT_CONFIG");
925 else if (hRootKey == HKEY_DYN_DATA)
926 pszRootKey = TEXT("HKEY_DYN_DATA");
927 else
928 return FALSE;
929
930 if (lpSubKey[0])
931 _sntprintf(pszDest, iDestLength, TEXT("%s\\%s"), pszRootKey, lpSubKey);
932 else
933 _sntprintf(pszDest, iDestLength, TEXT("%s"), pszRootKey);
934 return TRUE;
935 }