programs/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 St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define WIN32_LEAN_AND_MEAN     /* Exclude rarely-used stuff from Windows headers */
  22
  23 #include <windows.h>
  24 #include <tchar.h>
  25 #include <commctrl.h>
  26 #include <commdlg.h>
  27 #include <cderr.h>
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <shellapi.h>
  31 #include <shlwapi.h>
  32
  33 #include "wine/unicode.h"
  34 #include "main.h"
  35 #include "regproc.h"
  36 #include "resource.h"
  37
  38 static const WCHAR* editValueName;
  39 static WCHAR* stringValueData;
  40 static BOOL isDecimal;
  41
  42 struct edit_params
  43 {
  44     HKEY    hKey;
  45     LPCWSTR lpszValueName;
  46     void   *pData;
  47     LONG    cbData;
  48 };
  49
  50 static INT vmessagebox(HWND hwnd, INT buttons, INT titleId, INT resId, va_list ap)
  51 {
  52     static const WCHAR errorW[] = {'E','r','r','o','r',0};
  53     static const WCHAR unknownW[] = {'U','n','k','n','o','w','n',' ','e','r','r','o','r',' ','s','t','r','i','n','g','!',0};
  54
  55     WCHAR title[256];
  56     WCHAR errfmt[1024];
  57     WCHAR errstr[1024];
  58
  59     if (!LoadStringW(hInst, titleId, title, COUNT_OF(title))) lstrcpyW(title, errorW);
  60     if (!LoadStringW(hInst, resId, errfmt, COUNT_OF(errfmt))) lstrcpyW(errfmt, unknownW);
  61
  62     vsnprintfW(errstr, COUNT_OF(errstr), errfmt, ap);
  63
  64     return MessageBoxW(hwnd, errstr, title, buttons);
  65 }
  66
  67 static INT messagebox(HWND hwnd, INT buttons, INT titleId, INT resId, ...)
  68 {
  69     va_list ap;
  70     INT result;
  71
  72     va_start(ap, resId);
  73     result = vmessagebox(hwnd, buttons, titleId, resId, ap);
  74     va_end(ap);
  75
  76     return result;
  77 }
  78
  79 void error(HWND hwnd, INT resId, ...)
  80 {
  81     va_list ap;
  82
  83     va_start(ap, resId);
  84     vmessagebox(hwnd, MB_OK | MB_ICONERROR, IDS_ERROR, resId, ap);
  85     va_end(ap);
  86 }
  87
  88 static void error_code_messagebox(HWND hwnd, DWORD error_code)
  89 {
  90     LPWSTR lpMsgBuf;
  91     DWORD status;
  92     WCHAR title[256];
  93     static WCHAR fallback[] = {'E','r','r','o','r',' ','d','i','s','p','l','a','y','i','n','g',' ','e','r','r','o','r',' ','m','e','s','s','a','g','e','.','\n',0};
  94     static const WCHAR title_error[] = {'E','r','r','o','r',0};
  95
  96     if (!LoadStringW(hInst, IDS_ERROR, title, COUNT_OF(title)))
  97         lstrcpyW(title, title_error);
  98     status = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  99                            NULL, error_code, 0, (LPWSTR)&lpMsgBuf, 0, NULL);
 100     if (!status)
 101         lpMsgBuf = fallback;
 102     MessageBoxW(hwnd, lpMsgBuf, title, MB_OK | MB_ICONERROR);
 103     if (lpMsgBuf != fallback)
 104         LocalFree(lpMsgBuf);
 105 }
 106
 107 static BOOL change_dword_base(HWND hwndDlg, BOOL toHex)
 108 {
 109     TCHAR buf[128];
 110     DWORD val;
 111
 112     if (!GetDlgItemText(hwndDlg, IDC_VALUE_DATA, buf, COUNT_OF(buf))) return FALSE;
 113     if (!_stscanf(buf, toHex ? "%u" : "%x", &val)) return FALSE;
 114     wsprintf(buf, toHex ? "%x" : "%u", val);
 115     return SetDlgItemText(hwndDlg, IDC_VALUE_DATA, buf);
 116 }
 117
 118 static INT_PTR CALLBACK modify_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 119 {
 120     WCHAR* valueData;
 121     HWND hwndValue;
 122     int len;
 123
 124     switch(uMsg) {
 125     case WM_INITDIALOG:
 126         SetDlgItemTextW(hwndDlg, IDC_VALUE_NAME, editValueName);
 127         SetDlgItemTextW(hwndDlg, IDC_VALUE_DATA, stringValueData);
 128         CheckRadioButton(hwndDlg, IDC_DWORD_HEX, IDC_DWORD_DEC, isDecimal ? IDC_DWORD_DEC : IDC_DWORD_HEX);
 129         return TRUE;
 130     case WM_COMMAND:
 131         switch (LOWORD(wParam)) {
 132         case IDC_DWORD_HEX:
 133             if (isDecimal && change_dword_base(hwndDlg, TRUE)) isDecimal = FALSE;
 134         break;
 135         case IDC_DWORD_DEC:
 136             if (!isDecimal && change_dword_base(hwndDlg, FALSE)) isDecimal = TRUE;
 137         break;
 138         case IDOK:
 139             if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA))) {
 140                 len = GetWindowTextLengthW(hwndValue);
 141                 if ((valueData = HeapReAlloc(GetProcessHeap(), 0, stringValueData, (len + 1) * sizeof(WCHAR)))) {
 142                     stringValueData = valueData;
 143                     if (!GetWindowTextW(hwndValue, stringValueData, len + 1))
 144                         *stringValueData = 0;
 145                 }
 146             }
 147             /* Fall through */
 148         case IDCANCEL:
 149             EndDialog(hwndDlg, wParam);
 150             return TRUE;
 151         }
 152     }
 153     return FALSE;
 154 }
 155
 156 static INT_PTR CALLBACK bin_modify_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 157 {
 158     struct edit_params *params;
 159     LPBYTE pData;
 160     LONG cbData;
 161     LONG lRet;
 162
 163     switch(uMsg) {
 164     case WM_INITDIALOG:
 165         params = (struct edit_params *)lParam;
 166         SetWindowLongPtr(hwndDlg, DWLP_USER, (ULONG_PTR)params);
 167         if (params->lpszValueName)
 168             SetDlgItemTextW(hwndDlg, IDC_VALUE_NAME, params->lpszValueName);
 169         else
 170             SetDlgItemTextW(hwndDlg, IDC_VALUE_NAME, g_pszDefaultValueName);
 171         SendDlgItemMessage(hwndDlg, IDC_VALUE_DATA, HEM_SETDATA, (WPARAM)params->cbData, (LPARAM)params->pData);
 172         return TRUE;
 173     case WM_COMMAND:
 174         switch (LOWORD(wParam)) {
 175         case IDOK:
 176             params = (struct edit_params *)GetWindowLongPtr(hwndDlg, DWLP_USER);
 177             cbData = SendDlgItemMessage(hwndDlg, IDC_VALUE_DATA, HEM_GETDATA, 0, 0);
 178             pData = HeapAlloc(GetProcessHeap(), 0, cbData);
 179
 180             if (pData)
 181             {
 182                 SendDlgItemMessageW(hwndDlg, IDC_VALUE_DATA, HEM_GETDATA, (WPARAM)cbData, (LPARAM)pData);
 183                 lRet = RegSetValueExW(params->hKey, params->lpszValueName, 0, REG_BINARY, pData, cbData);
 184             }
 185             else
 186                 lRet = ERROR_OUTOFMEMORY;
 187
 188             if (lRet == ERROR_SUCCESS)
 189                 EndDialog(hwndDlg, 1);
 190             else
 191             {
 192                 error_code_messagebox(hwndDlg, lRet);
 193                 EndDialog(hwndDlg, 0);
 194             }
 195             return TRUE;
 196         case IDCANCEL:
 197             EndDialog(hwndDlg, 0);
 198             return TRUE;
 199         }
 200     }
 201     return FALSE;
 202 }
 203
 204 static BOOL check_value(HWND hwnd, HKEY hKey, LPCWSTR valueName)
 205 {
 206     WCHAR empty = 0;
 207     LONG lRet = RegQueryValueExW(hKey, valueName ? valueName : &empty, 0, NULL, 0, NULL);
 208     if(lRet != ERROR_SUCCESS) return FALSE;
 209     return TRUE;
 210 }
 211
 212 static LPWSTR read_value(HWND hwnd, HKEY hKey, LPCWSTR valueName, DWORD *lpType, LONG *len)
 213 {
 214     DWORD valueDataLen;
 215     LPWSTR buffer = NULL;
 216     LONG lRet;
 217         WCHAR empty = 0;
 218
 219     lRet = RegQueryValueExW(hKey, valueName ? valueName : &empty, 0, lpType, 0, &valueDataLen);
 220     if (lRet != ERROR_SUCCESS) {
 221         if (lRet == ERROR_FILE_NOT_FOUND && !valueName) { /* no default value here, make it up */
 222             if (len) *len = 1;
 223             if (lpType) *lpType = REG_SZ;
 224             buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR));
 225             *buffer = '\0';
 226             return buffer;
 227         }
 228         error(hwnd, IDS_BAD_VALUE, valueName);
 229         goto done;
 230     }
 231     if ( *lpType == REG_DWORD ) valueDataLen = sizeof(DWORD);
 232     if (!(buffer = HeapAlloc(GetProcessHeap(), 0, valueDataLen+sizeof(WCHAR)))) {
 233         error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
 234         goto done;
 235     }
 236     lRet = RegQueryValueExW(hKey, valueName, 0, 0, (LPBYTE)buffer, &valueDataLen);
 237     if (lRet != ERROR_SUCCESS) {
 238         error(hwnd, IDS_BAD_VALUE, valueName);
 239         goto done;
 240     }
 241     if((valueDataLen % sizeof(WCHAR)) == 0)
 242         buffer[valueDataLen / sizeof(WCHAR)] = 0;
 243     if(len) *len = valueDataLen;
 244     return buffer;
 245
 246 done:
 247     HeapFree(GetProcessHeap(), 0, buffer);
 248     return NULL;
 249 }
 250
 251 BOOL CreateKey(HWND hwnd, HKEY hKeyRoot, LPCWSTR keyPath, LPWSTR keyName)
 252 {
 253     BOOL result = FALSE;
 254     LONG lRet = ERROR_SUCCESS;
 255     HKEY retKey = NULL;
 256     WCHAR newKey[MAX_NEW_KEY_LEN - 4];
 257     int keyNum;
 258     HKEY hKey;
 259
 260     lRet = RegOpenKeyExW(hKeyRoot, keyPath, 0, KEY_CREATE_SUB_KEY, &hKey);
 261     if (lRet != ERROR_SUCCESS) {
 262         error_code_messagebox(hwnd, lRet);
 263         goto done;
 264     }
 265
 266     if (!LoadStringW(GetModuleHandle(0), IDS_NEWKEY, newKey, COUNT_OF(newKey))) goto done;
 267
 268     /* try to find out a name for the newly create key (max 100 times) */
 269     for (keyNum = 1; keyNum < 100; keyNum++) {
 270         wsprintfW(keyName, newKey, keyNum);
 271         lRet = RegOpenKeyW(hKey, keyName, &retKey);
 272         if (lRet != ERROR_SUCCESS) break;
 273         RegCloseKey(retKey);
 274     }
 275     if (lRet == ERROR_SUCCESS) goto done;
 276
 277     lRet = RegCreateKeyW(hKey, keyName, &retKey);
 278     if (lRet != ERROR_SUCCESS) {
 279         error_code_messagebox(hwnd, lRet);
 280         goto done;
 281     }
 282
 283     result = TRUE;
 284
 285 done:
 286     RegCloseKey(retKey);
 287     return result;
 288 }
 289
 290 BOOL ModifyValue(HWND hwnd, HKEY hKeyRoot, LPCWSTR keyPath, LPCWSTR valueName)
 291 {
 292     BOOL result = FALSE;
 293     DWORD type;
 294     LONG lRet;
 295     HKEY hKey;
 296     LONG len;
 297
 298     lRet = RegOpenKeyExW(hKeyRoot, keyPath, 0, KEY_READ | KEY_SET_VALUE, &hKey);
 299     if (lRet != ERROR_SUCCESS) {
 300         error_code_messagebox(hwnd, lRet);
 301         return FALSE;
 302     }
 303
 304     editValueName = valueName ? valueName : g_pszDefaultValueName;
 305     if(!(stringValueData = read_value(hwnd, hKey, valueName, &type, &len))) goto done;
 306
 307     if ( (type == REG_SZ) || (type == REG_EXPAND_SZ) ) {
 308         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_STRING), hwnd, modify_dlgproc) == IDOK) {
 309             lRet = RegSetValueExW(hKey, valueName, 0, type, (LPBYTE)stringValueData, (lstrlenW(stringValueData) + 1) * sizeof(WCHAR));
 310             if (lRet == ERROR_SUCCESS) result = TRUE;
 311             else error_code_messagebox(hwnd, lRet);
 312         }
 313     } else if ( type == REG_DWORD ) {
 314         const WCHAR u[] = {'%','u',0};
 315         const WCHAR x[] = {'%','x',0};
 316         wsprintfW(stringValueData, isDecimal ? u : x, *((DWORD*)stringValueData));
 317         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_DWORD), hwnd, modify_dlgproc) == IDOK) {
 318             DWORD val;
 319             CHAR* valueA = GetMultiByteString(stringValueData);
 320             if (_stscanf(valueA, isDecimal ? "%u" : "%x", &val)) {
 321                 lRet = RegSetValueExW(hKey, valueName, 0, type, (BYTE*)&val, sizeof(val));
 322                 if (lRet == ERROR_SUCCESS) result = TRUE;
 323                 else error_code_messagebox(hwnd, lRet);
 324             }
 325             HeapFree(GetProcessHeap(), 0, valueA);
 326         }
 327     } else if ( type == REG_BINARY ) {
 328         struct edit_params params;
 329         params.hKey = hKey;
 330         params.lpszValueName = valueName;
 331         params.pData = stringValueData;
 332         params.cbData = len;
 333         result = DialogBoxParam(NULL, MAKEINTRESOURCE(IDD_EDIT_BINARY), hwnd,
 334             bin_modify_dlgproc, (LPARAM)&params);
 335     } else if ( type == REG_MULTI_SZ ) {
 336         WCHAR char1 = '\r', char2 = '\n';
 337         WCHAR *tmpValueData = NULL;
 338         INT i, j, count;
 339
 340         for ( i = 0, count = 0; i < len - 1; i++)
 341             if ( !stringValueData[i] && stringValueData[i + 1] )
 342                 count++;
 343         tmpValueData = HeapAlloc( GetProcessHeap(), 0, ( len + count ) * sizeof(WCHAR));
 344         if ( !tmpValueData ) goto done;
 345
 346         for ( i = 0, j = 0; i < len - 1; i++)
 347         {
 348             if ( !stringValueData[i] && stringValueData[i + 1])
 349             {
 350                 tmpValueData[j++] = char1;
 351                 tmpValueData[j++] = char2;
 352             }
 353             else
 354                 tmpValueData[j++] = stringValueData[i];
 355         }
 356         tmpValueData[j] = stringValueData[i];
 357         HeapFree( GetProcessHeap(), 0, stringValueData);
 358         stringValueData = tmpValueData;
 359         tmpValueData = NULL;
 360
 361         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_MULTI_STRING), hwnd, modify_dlgproc) == IDOK)
 362         {
 363             len = lstrlenW( stringValueData );
 364             tmpValueData = HeapAlloc( GetProcessHeap(), 0, (len + 2) * sizeof(WCHAR));
 365             if ( !tmpValueData ) goto done;
 366
 367             for ( i = 0, j = 0; i < len - 1; i++)
 368             {
 369                 if ( stringValueData[i] == char1 && stringValueData[i + 1] == char2)
 370                 {
 371                     if ( tmpValueData[j - 1] != 0)
 372                         tmpValueData[j++] = 0;
 373                     i++;
 374                 }
 375                 else
 376                     tmpValueData[j++] = stringValueData[i];
 377             }
 378             tmpValueData[j++] = stringValueData[i];
 379             tmpValueData[j++] = 0;
 380             tmpValueData[j++] = 0;
 381             HeapFree( GetProcessHeap(), 0, stringValueData);
 382             stringValueData = tmpValueData;
 383
 384             lRet = RegSetValueExW(hKey, valueName, 0, type, (LPBYTE)stringValueData, j * sizeof(WCHAR));
 385             if (lRet == ERROR_SUCCESS) result = TRUE;
 386             else error_code_messagebox(hwnd, lRet);
 387         }
 388     } else {
 389         error(hwnd, IDS_UNSUPPORTED_TYPE, type);
 390     }
 391
 392 done:
 393     HeapFree(GetProcessHeap(), 0, stringValueData);
 394     stringValueData = NULL;
 395     RegCloseKey(hKey);
 396     return result;
 397 }
 398
 399 BOOL DeleteKey(HWND hwnd, HKEY hKeyRoot, LPCWSTR keyPath)
 400 {
 401     BOOL result = FALSE;
 402     LONG lRet;
 403     HKEY hKey;
 404
 405     lRet = RegOpenKeyExW(hKeyRoot, keyPath, 0, KEY_READ|KEY_SET_VALUE, &hKey);
 406     if (lRet != ERROR_SUCCESS) {
 407         error_code_messagebox(hwnd, lRet);
 408         return FALSE;
 409     }
 410
 411     if (messagebox(hwnd, MB_YESNO | MB_ICONEXCLAMATION, IDS_DELETE_BOX_TITLE, IDS_DELETE_BOX_TEXT, keyPath) != IDYES)
 412         goto done;
 413
 414     lRet = SHDeleteKeyW(hKeyRoot, keyPath);
 415     if (lRet != ERROR_SUCCESS) {
 416         error(hwnd, IDS_BAD_KEY, keyPath);
 417         goto done;
 418     }
 419     result = TRUE;
 420
 421 done:
 422     RegCloseKey(hKey);
 423     return result;
 424 }
 425
 426 BOOL DeleteValue(HWND hwnd, HKEY hKeyRoot, LPCWSTR keyPath, LPCWSTR valueName, BOOL showMessageBox)
 427 {
 428     BOOL result = FALSE;
 429     LONG lRet;
 430     HKEY hKey;
 431     LPCWSTR visibleValueName = valueName ? valueName : g_pszDefaultValueName;
 432     WCHAR empty = 0;
 433
 434     lRet = RegOpenKeyExW(hKeyRoot, keyPath, 0, KEY_READ | KEY_SET_VALUE, &hKey);
 435     if (lRet != ERROR_SUCCESS) return FALSE;
 436
 437     if (showMessageBox)
 438     {
 439         if (messagebox(hwnd, MB_YESNO | MB_ICONEXCLAMATION, IDS_DELETE_BOX_TITLE, IDS_DELETE_BOX_TEXT, visibleValueName) != IDYES)
 440             goto done;
 441     }
 442
 443     lRet = RegDeleteValueW(hKey, valueName ? valueName : &empty);
 444     if (lRet != ERROR_SUCCESS && valueName) {
 445         error(hwnd, IDS_BAD_VALUE, valueName);
 446     }
 447     if (lRet != ERROR_SUCCESS) goto done;
 448     result = TRUE;
 449
 450 done:
 451     RegCloseKey(hKey);
 452     return result;
 453 }
 454
 455 BOOL CreateValue(HWND hwnd, HKEY hKeyRoot, LPCWSTR keyPath, DWORD valueType, LPWSTR valueName)
 456 {
 457     LONG lRet = ERROR_SUCCESS;
 458     WCHAR newValue[256];
 459     DWORD valueDword = 0;
 460     BOOL result = FALSE;
 461     int valueNum;
 462     HKEY hKey;
 463
 464     lRet = RegOpenKeyExW(hKeyRoot, keyPath, 0, KEY_READ | KEY_SET_VALUE, &hKey);
 465     if (lRet != ERROR_SUCCESS) {
 466         error_code_messagebox(hwnd, lRet);
 467         return FALSE;
 468     }
 469
 470     if (!LoadStringW(GetModuleHandle(0), IDS_NEWVALUE, newValue, COUNT_OF(newValue))) goto done;
 471
 472     /* try to find out a name for the newly create key (max 100 times) */
 473     for (valueNum = 1; valueNum < 100; valueNum++) {
 474         wsprintfW(valueName, newValue, valueNum);
 475         lRet = RegQueryValueExW(hKey, valueName, 0, 0, 0, 0);
 476         if (lRet == ERROR_FILE_NOT_FOUND) break;
 477     }
 478     if (lRet != ERROR_FILE_NOT_FOUND) {
 479         error_code_messagebox(hwnd, lRet);
 480         goto done;
 481     }
 482
 483     lRet = RegSetValueExW(hKey, valueName, 0, valueType, (BYTE*)&valueDword, sizeof(DWORD));
 484     if (lRet != ERROR_SUCCESS) {
 485         error_code_messagebox(hwnd, lRet);
 486         goto done;
 487     }
 488     result = TRUE;
 489
 490 done:
 491     RegCloseKey(hKey);
 492     return result;
 493 }
 494
 495 BOOL RenameValue(HWND hwnd, HKEY hKeyRoot, LPCWSTR keyPath, LPCWSTR oldName, LPCWSTR newName)
 496 {
 497     LPWSTR value = NULL;
 498     DWORD type;
 499     LONG len, lRet;
 500     BOOL result = FALSE;
 501     HKEY hKey;
 502
 503     if (!oldName) return FALSE;
 504     if (!newName) return FALSE;
 505
 506     lRet = RegOpenKeyExW(hKeyRoot, keyPath, 0, KEY_READ | KEY_SET_VALUE, &hKey);
 507     if (lRet != ERROR_SUCCESS) {
 508         error_code_messagebox(hwnd, lRet);
 509         return FALSE;
 510     }
 511     /* check if value already exists */
 512     if (check_value(hwnd, hKey, newName)) goto done;
 513     value = read_value(hwnd, hKey, oldName, &type, &len);
 514     if(!value) goto done;
 515     lRet = RegSetValueExW(hKey, newName, 0, type, (BYTE*)value, len);
 516     if (lRet != ERROR_SUCCESS) {
 517         error_code_messagebox(hwnd, lRet);
 518         goto done;
 519     }
 520     lRet = RegDeleteValueW(hKey, oldName);
 521     if (lRet != ERROR_SUCCESS) {
 522         RegDeleteValueW(hKey, newName);
 523         error_code_messagebox(hwnd, lRet);
 524         goto done;
 525     }
 526     result = TRUE;
 527
 528 done:
 529     HeapFree(GetProcessHeap(), 0, value);
 530     RegCloseKey(hKey);
 531     return result;
 532 }
 533
 534
 535 BOOL RenameKey(HWND hwnd, HKEY hRootKey, LPCWSTR keyPath, LPCWSTR newName)
 536 {
 537     LPWSTR parentPath = 0;
 538     LPCWSTR srcSubKey = 0;
 539     HKEY parentKey = 0;
 540     HKEY destKey = 0;
 541     BOOL result = FALSE;
 542     LONG lRet;
 543     DWORD disposition;
 544
 545     if (!keyPath || !newName) return FALSE;
 546
 547     if (!strrchrW(keyPath, '\\')) {
 548         parentKey = hRootKey;
 549         srcSubKey = keyPath;
 550     } else {
 551         LPWSTR srcSubKey_copy;
 552
 553         parentPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(keyPath)+1)*sizeof(WCHAR));
 554         lstrcpyW(parentPath, keyPath);
 555         srcSubKey_copy = strrchrW(parentPath, '\\');
 556         *srcSubKey_copy = 0;
 557         srcSubKey = srcSubKey_copy + 1;
 558         lRet = RegOpenKeyExW(hRootKey, parentPath, 0, KEY_READ | KEY_CREATE_SUB_KEY, &parentKey);
 559         if (lRet != ERROR_SUCCESS) {
 560             error_code_messagebox(hwnd, lRet);
 561             goto done;
 562         }
 563     }
 564
 565     /* The following fails if the old name is the same as the new name. */
 566     if (!lstrcmpW(srcSubKey, newName)) goto done;
 567
 568     lRet = RegCreateKeyExW(parentKey, newName, 0, NULL, REG_OPTION_NON_VOLATILE,
 569         KEY_WRITE, NULL /* FIXME */, &destKey, &disposition);
 570     if (disposition == REG_OPENED_EXISTING_KEY)
 571         lRet = ERROR_FILE_EXISTS; /* FIXME: we might want a better error message than this */
 572     if (lRet != ERROR_SUCCESS) {
 573         error_code_messagebox(hwnd, lRet);
 574         goto done;
 575     }
 576
 577     /* FIXME: SHCopyKey does not copy the security attributes */
 578     lRet = SHCopyKeyW(parentKey, srcSubKey, destKey, 0);
 579     if (lRet != ERROR_SUCCESS) {
 580         RegCloseKey(destKey);
 581         RegDeleteKeyW(parentKey, newName);
 582         error_code_messagebox(hwnd, lRet);
 583         goto done;
 584     }
 585
 586     lRet = SHDeleteKeyW(hRootKey, keyPath);
 587     if (lRet != ERROR_SUCCESS) {
 588         error_code_messagebox(hwnd, lRet);
 589         goto done;
 590     }
 591
 592     result = TRUE;
 593
 594 done:
 595     RegCloseKey(destKey);
 596     if (parentKey) {
 597         RegCloseKey(parentKey);
 598         HeapFree(GetProcessHeap(), 0, parentPath);
 599     }
 600     return result;
 601 }