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 #define NTOS_MODE_USER
  24 #include <ndk/cmtypes.h>
  25
  26 typedef enum _EDIT_MODE
  27 {
  28     EDIT_MODE_DEC,
  29     EDIT_MODE_HEX
  30 } EDIT_MODE;
  31
  32
  33 static const WCHAR* editValueName;
  34 static WCHAR* stringValueData;
  35 static PVOID binValueData;
  36 static DWORD dwordValueData;
  37 static PCM_RESOURCE_LIST resourceValueData;
  38 static INT fullResourceIndex = -1;
  39 static DWORD valueDataLen;
  40 static EDIT_MODE dwordEditMode = EDIT_MODE_HEX;
  41
  42 void error(HWND hwnd, INT resId, ...)
  43 {
  44     va_list ap;
  45     WCHAR title[256];
  46     WCHAR errfmt[1024];
  47     WCHAR errstr[1024];
  48     HINSTANCE hInstance;
  49
  50     hInstance = GetModuleHandle(0);
  51
  52     if (!LoadStringW(hInstance, IDS_ERROR, title, COUNT_OF(title)))
  53         wcscpy(title, L"Error");
  54
  55     if (!LoadStringW(hInstance, resId, errfmt, COUNT_OF(errfmt)))
  56         wcscpy(errfmt, L"Unknown error string!");
  57
  58     va_start(ap, resId);
  59     _vsnwprintf(errstr, COUNT_OF(errstr), errfmt, ap);
  60     va_end(ap);
  61
  62     MessageBoxW(hwnd, errstr, title, MB_OK | MB_ICONERROR);
  63 }
  64
  65 static void error_code_messagebox(HWND hwnd, DWORD error_code)
  66 {
  67     WCHAR title[256];
  68     if (!LoadStringW(hInst, IDS_ERROR, title, COUNT_OF(title)))
  69         wcscpy(title, L"Error");
  70     ErrorMessageBox(hwnd, title, error_code);
  71 }
  72
  73 void warning(HWND hwnd, INT resId, ...)
  74 {
  75     va_list ap;
  76     WCHAR title[256];
  77     WCHAR errfmt[1024];
  78     WCHAR errstr[1024];
  79     HINSTANCE hInstance;
  80
  81     hInstance = GetModuleHandle(0);
  82
  83     if (!LoadStringW(hInstance, IDS_WARNING, title, COUNT_OF(title)))
  84         wcscpy(title, L"Warning");
  85
  86     if (!LoadStringW(hInstance, resId, errfmt, COUNT_OF(errfmt)))
  87         wcscpy(errfmt, L"Unknown error string!");
  88
  89     va_start(ap, resId);
  90     _vsnwprintf(errstr, COUNT_OF(errstr), errfmt, ap);
  91     va_end(ap);
  92
  93     MessageBoxW(hwnd, errstr, title, MB_OK | MB_ICONSTOP);
  94 }
  95
  96 INT_PTR CALLBACK modify_string_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
  97 {
  98     WCHAR* valueData;
  99     HWND hwndValue;
 100     int len;
 101
 102     UNREFERENCED_PARAMETER(lParam);
 103
 104     switch(uMsg)
 105     {
 106     case WM_INITDIALOG:
 107         if (editValueName && wcscmp(editValueName, L""))
 108         {
 109             SetDlgItemTextW(hwndDlg, IDC_VALUE_NAME, editValueName);
 110         }
 111         else
 112         {
 113             WCHAR buffer[255];
 114             LoadStringW(hInst, IDS_DEFAULT_VALUE_NAME, buffer, COUNT_OF(buffer));
 115             SetDlgItemTextW(hwndDlg, IDC_VALUE_NAME, buffer);
 116         }
 117         SetDlgItemTextW(hwndDlg, IDC_VALUE_DATA, stringValueData);
 118         SendMessage(GetDlgItem(hwndDlg, IDC_VALUE_DATA), EM_SETSEL, 0, -1);
 119         SetFocus(GetDlgItem(hwndDlg, IDC_VALUE_DATA));
 120         return FALSE;
 121     case WM_COMMAND:
 122         switch (LOWORD(wParam))
 123         {
 124         case IDOK:
 125             if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA)))
 126             {
 127                 if ((len = GetWindowTextLength(hwndValue)))
 128                 {
 129                     if (stringValueData)
 130                     {
 131                         if ((valueData = HeapReAlloc(GetProcessHeap(), 0, stringValueData, (len + 1) * sizeof(WCHAR))))
 132                         {
 133                             stringValueData = valueData;
 134                             if (!GetWindowTextW(hwndValue, stringValueData, len + 1))
 135                                 *stringValueData = 0;
 136                         }
 137                     }
 138                     else
 139                     {
 140                         if ((valueData = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR))))
 141                         {
 142                             stringValueData = valueData;
 143                             if (!GetWindowTextW(hwndValue, stringValueData, len + 1))
 144                                 *stringValueData = 0;
 145                         }
 146                     }
 147                 }
 148                 else
 149                 {
 150                     if (stringValueData)
 151                         *stringValueData = 0;
 152                 }
 153             }
 154             EndDialog(hwndDlg, IDOK);
 155             break;
 156         case IDCANCEL:
 157             EndDialog(hwndDlg, IDCANCEL);
 158             return TRUE;
 159         }
 160     }
 161     return FALSE;
 162 }
 163
 164
 165 INT_PTR CALLBACK modify_multi_string_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 166 {
 167     WCHAR* valueData;
 168     HWND hwndValue;
 169     int len;
 170
 171     UNREFERENCED_PARAMETER(lParam);
 172
 173     switch(uMsg)
 174     {
 175     case WM_INITDIALOG:
 176         if (editValueName && wcscmp(editValueName, L""))
 177         {
 178             SetDlgItemTextW(hwndDlg, IDC_VALUE_NAME, editValueName);
 179         }
 180         else
 181         {
 182             WCHAR buffer[255];
 183             LoadStringW(hInst, IDS_DEFAULT_VALUE_NAME, buffer, COUNT_OF(buffer));
 184             SetDlgItemTextW(hwndDlg, IDC_VALUE_NAME, buffer);
 185         }
 186         SetDlgItemTextW(hwndDlg, IDC_VALUE_DATA, stringValueData);
 187         SetFocus(GetDlgItem(hwndDlg, IDC_VALUE_DATA));
 188         return FALSE;
 189     case WM_COMMAND:
 190         switch (LOWORD(wParam))
 191         {
 192         case IDOK:
 193             if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA)))
 194             {
 195                 if ((len = GetWindowTextLength(hwndValue)))
 196                 {
 197                     if (stringValueData)
 198                     {
 199                         if ((valueData = HeapReAlloc(GetProcessHeap(), 0, stringValueData, (len + 1) * sizeof(WCHAR))))
 200                         {
 201                             stringValueData = valueData;
 202                             if (!GetWindowTextW(hwndValue, stringValueData, len + 1))
 203                                 *stringValueData = 0;
 204                         }
 205                     }
 206                     else
 207                     {
 208                         if ((valueData = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR))))
 209                         {
 210                             stringValueData = valueData;
 211                             if (!GetWindowTextW(hwndValue, stringValueData, len + 1))
 212                                 *stringValueData = 0;
 213                         }
 214                     }
 215                 }
 216                 else
 217                 {
 218                     if (stringValueData)
 219                         *stringValueData = 0;
 220                 }
 221             }
 222             EndDialog(hwndDlg, IDOK);
 223             break;
 224         case IDCANCEL:
 225             EndDialog(hwndDlg, IDCANCEL);
 226             return TRUE;
 227         }
 228     }
 229     return FALSE;
 230 }
 231
 232
 233 LRESULT CALLBACK DwordEditSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 234 {
 235     WNDPROC oldwndproc;
 236
 237     oldwndproc = (WNDPROC)GetWindowLongPtr(hwnd, GWLP_USERDATA);
 238
 239     switch (uMsg)
 240     {
 241     case WM_CHAR:
 242         if (dwordEditMode == EDIT_MODE_DEC)
 243         {
 244             if (isdigit((int) wParam & 0xff) || iscntrl((int) wParam & 0xff))
 245             {
 246                 break;
 247             }
 248             else
 249             {
 250                 return 0;
 251             }
 252         }
 253         else if (dwordEditMode == EDIT_MODE_HEX)
 254         {
 255             if (isxdigit((int) wParam & 0xff) || iscntrl((int) wParam & 0xff))
 256             {
 257                 break;
 258             }
 259             else
 260             {
 261                 return 0;
 262             }
 263         }
 264         else
 265         {
 266             break;
 267         }
 268     }
 269
 270     return CallWindowProcW(oldwndproc, hwnd, uMsg, wParam, lParam);
 271 }
 272
 273
 274 INT_PTR CALLBACK modify_dword_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 275 {
 276     WNDPROC oldproc;
 277     HWND hwndValue;
 278     WCHAR ValueString[32];
 279     LPWSTR Remainder;
 280     DWORD Base;
 281     DWORD Value = 0;
 282
 283     UNREFERENCED_PARAMETER(lParam);
 284
 285     switch(uMsg)
 286     {
 287     case WM_INITDIALOG:
 288         dwordEditMode = EDIT_MODE_HEX;
 289
 290         /* subclass the edit control */
 291         hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA);
 292         oldproc = (WNDPROC)GetWindowLongPtr(hwndValue, GWLP_WNDPROC);
 293         SetWindowLongPtr(hwndValue, GWLP_USERDATA, (DWORD_PTR)oldproc);
 294         SetWindowLongPtr(hwndValue, GWLP_WNDPROC, (DWORD_PTR)DwordEditSubclassProc);
 295
 296         if (editValueName && wcscmp(editValueName, L""))
 297         {
 298             SetDlgItemTextW(hwndDlg, IDC_VALUE_NAME, editValueName);
 299         }
 300         else
 301         {
 302             WCHAR buffer[255];
 303             LoadStringW(hInst, IDS_DEFAULT_VALUE_NAME, buffer, COUNT_OF(buffer));
 304             SetDlgItemTextW(hwndDlg, IDC_VALUE_NAME, buffer);
 305         }
 306         CheckRadioButton (hwndDlg, IDC_FORMAT_HEX, IDC_FORMAT_DEC, IDC_FORMAT_HEX);
 307         swprintf(ValueString, L"%lx", dwordValueData);
 308         SetDlgItemTextW(hwndDlg, IDC_VALUE_DATA, ValueString);
 309         SendMessage(GetDlgItem(hwndDlg, IDC_VALUE_DATA), EM_SETSEL, 0, -1);
 310         SetFocus(GetDlgItem(hwndDlg, IDC_VALUE_DATA));
 311         return FALSE;
 312
 313     case WM_COMMAND:
 314         switch (LOWORD(wParam))
 315         {
 316         case IDC_FORMAT_HEX:
 317             if (HIWORD(wParam) == BN_CLICKED && dwordEditMode == EDIT_MODE_DEC)
 318             {
 319                 dwordEditMode = EDIT_MODE_HEX;
 320                 if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA)))
 321                 {
 322                     if (GetWindowTextLength(hwndValue))
 323                     {
 324                         if (GetWindowTextW(hwndValue, ValueString, 32))
 325                         {
 326                             Value = wcstoul (ValueString, &Remainder, 10);
 327                         }
 328                     }
 329                 }
 330                 swprintf(ValueString, L"%lx", Value);
 331                 SetDlgItemTextW(hwndDlg, IDC_VALUE_DATA, ValueString);
 332                 return TRUE;
 333             }
 334             break;
 335
 336         case IDC_FORMAT_DEC:
 337             if (HIWORD(wParam) == BN_CLICKED && dwordEditMode == EDIT_MODE_HEX)
 338             {
 339                 dwordEditMode = EDIT_MODE_DEC;
 340                 if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA)))
 341                 {
 342                     if (GetWindowTextLength(hwndValue))
 343                     {
 344                         if (GetWindowTextW(hwndValue, ValueString, 32))
 345                         {
 346                             Value = wcstoul (ValueString, &Remainder, 16);
 347                         }
 348                     }
 349                 }
 350                 swprintf(ValueString, L"%lu", Value);
 351                 SetDlgItemTextW(hwndDlg, IDC_VALUE_DATA, ValueString);
 352                 return TRUE;
 353             }
 354             break;
 355
 356         case IDOK:
 357             if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA)))
 358             {
 359                 if (GetWindowTextLength(hwndValue))
 360                 {
 361                     if (!GetWindowTextW(hwndValue, ValueString, 32))
 362                     {
 363                         EndDialog(hwndDlg, IDCANCEL);
 364                         return TRUE;
 365                     }
 366
 367                     Base = (dwordEditMode == EDIT_MODE_HEX) ? 16 : 10;
 368                     dwordValueData = wcstoul (ValueString, &Remainder, Base);
 369                 }
 370                 else
 371                 {
 372                     EndDialog(hwndDlg, IDCANCEL);
 373                     return TRUE;
 374                 }
 375             }
 376             EndDialog(hwndDlg, IDOK);
 377             return TRUE;
 378
 379         case IDCANCEL:
 380             EndDialog(hwndDlg, IDCANCEL);
 381             return TRUE;
 382         }
 383     }
 384     return FALSE;
 385 }
 386
 387
 388 INT_PTR CALLBACK modify_binary_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 389 {
 390     HWND hwndValue;
 391     UINT len;
 392
 393     UNREFERENCED_PARAMETER(lParam);
 394
 395     switch(uMsg)
 396     {
 397     case WM_INITDIALOG:
 398         if (editValueName && wcscmp(editValueName, L""))
 399         {
 400             SetDlgItemTextW(hwndDlg, IDC_VALUE_NAME, editValueName);
 401         }
 402         else
 403         {
 404             WCHAR buffer[255];
 405             LoadStringW(hInst, IDS_DEFAULT_VALUE_NAME, buffer, COUNT_OF(buffer));
 406             SetDlgItemTextW(hwndDlg, IDC_VALUE_NAME, buffer);
 407         }
 408         hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA);
 409         HexEdit_LoadBuffer(hwndValue, binValueData, valueDataLen);
 410         /* reset the hex edit control's font */
 411         SendMessageW(hwndValue, WM_SETFONT, 0, 0);
 412         SetFocus(hwndValue);
 413         return FALSE;
 414     case WM_COMMAND:
 415         switch (LOWORD(wParam))
 416         {
 417         case IDOK:
 418             if ((hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA)))
 419             {
 420                 len = (UINT) HexEdit_GetBufferSize(hwndValue);
 421                 if (len > 0 && binValueData)
 422                     binValueData = HeapReAlloc(GetProcessHeap(), 0, binValueData, len);
 423                 else
 424                     binValueData = HeapAlloc(GetProcessHeap(), 0, len + 1);
 425                 HexEdit_CopyBuffer(hwndValue, binValueData, len);
 426                 valueDataLen = len;
 427             }
 428             EndDialog(hwndDlg, IDOK);
 429             break;
 430         case IDCANCEL:
 431             EndDialog(hwndDlg, IDCANCEL);
 432             return TRUE;
 433         }
 434     }
 435     return FALSE;
 436 }
 437
 438
 439 static BOOL CreateResourceColumns(HWND hwnd)
 440 {
 441     WCHAR szText[80];
 442     RECT rc;
 443     LVCOLUMN lvC;
 444     HWND hwndLV;
 445     INT width;
 446
 447     /* Create columns. */
 448     lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
 449     lvC.pszText = szText;
 450     lvC.fmt = LVCFMT_LEFT;
 451
 452     hwndLV = GetDlgItem(hwnd, IDC_DMA_LIST);
 453     ListView_SetExtendedListViewStyle(hwndLV, LVS_EX_FULLROWSELECT);
 454     GetClientRect(hwndLV, &rc);
 455
 456     /* Load the column labels from the resource file. */
 457     lvC.iSubItem = 0;
 458     lvC.cx = (rc.right - rc.left) / 2;
 459     LoadStringW(hInst, IDS_DMA_CHANNEL, szText, COUNT_OF(szText));
 460     if (ListView_InsertColumn(hwndLV, 0, &lvC) == -1)
 461         return FALSE;
 462
 463     lvC.iSubItem = 1;
 464     lvC.cx = (rc.right - rc.left) - lvC.cx;
 465     LoadStringW(hInst, IDS_DMA_PORT, szText, COUNT_OF(szText));
 466     if (ListView_InsertColumn(hwndLV, 1, &lvC) == -1)
 467         return FALSE;
 468
 469
 470     /* Interrupt list */
 471     hwndLV = GetDlgItem(hwnd, IDC_IRQ_LIST);
 472     ListView_SetExtendedListViewStyle(hwndLV, LVS_EX_FULLROWSELECT);
 473     GetClientRect(hwndLV, &rc);
 474     width = (rc.right - rc.left) / 4;
 475
 476     /* Load the column labels from the resource file. */
 477     lvC.iSubItem = 0;
 478     lvC.cx = width;
 479     LoadStringW(hInst, IDS_INTERRUPT_VECTOR, szText, COUNT_OF(szText));
 480     if (ListView_InsertColumn(hwndLV, 0, &lvC) == -1)
 481         return FALSE;
 482
 483     lvC.iSubItem = 1;
 484     LoadStringW(hInst, IDS_INTERRUPT_LEVEL, szText, COUNT_OF(szText));
 485     if (ListView_InsertColumn(hwndLV, 1, &lvC) == -1)
 486         return FALSE;
 487
 488     lvC.iSubItem = 2;
 489     LoadStringW(hInst, IDS_INTERRUPT_AFFINITY, szText, COUNT_OF(szText));
 490     if (ListView_InsertColumn(hwndLV, 2, &lvC) == -1)
 491         return FALSE;
 492
 493     lvC.iSubItem = 3;
 494     lvC.cx = (rc.right - rc.left) - 3 * width;
 495     LoadStringW(hInst, IDS_INTERRUPT_TYPE, szText, COUNT_OF(szText));
 496     if (ListView_InsertColumn(hwndLV, 3, &lvC) == -1)
 497         return FALSE;
 498
 499
 500     /* Memory list */
 501     hwndLV = GetDlgItem(hwnd, IDC_MEMORY_LIST);
 502     ListView_SetExtendedListViewStyle(hwndLV, LVS_EX_FULLROWSELECT);
 503     GetClientRect(hwndLV, &rc);
 504     width = (rc.right - rc.left) / 3;
 505
 506     /* Load the column labels from the resource file. */
 507     lvC.iSubItem = 0;
 508     lvC.cx = width;
 509     LoadStringW(hInst, IDS_MEMORY_ADDRESS, szText, COUNT_OF(szText));
 510     if (ListView_InsertColumn(hwndLV, 0, &lvC) == -1)
 511         return FALSE;
 512
 513     lvC.iSubItem = 1;
 514     LoadStringW(hInst, IDS_MEMORY_LENGTH, szText, COUNT_OF(szText));
 515     if (ListView_InsertColumn(hwndLV, 1, &lvC) == -1)
 516         return FALSE;
 517
 518     lvC.iSubItem = 2;
 519     lvC.cx = (rc.right - rc.left) - 2 * width;
 520     LoadStringW(hInst, IDS_MEMORY_ACCESS, szText, COUNT_OF(szText));
 521     if (ListView_InsertColumn(hwndLV, 2, &lvC) == -1)
 522         return FALSE;
 523
 524
 525     /* Port list */
 526     hwndLV = GetDlgItem(hwnd, IDC_PORT_LIST);
 527     ListView_SetExtendedListViewStyle(hwndLV, LVS_EX_FULLROWSELECT);
 528     GetClientRect(hwndLV, &rc);
 529     width = (rc.right - rc.left) / 3;
 530
 531     /* Load the column labels from the resource file. */
 532     lvC.iSubItem = 0;
 533     lvC.cx = width;
 534     LoadStringW(hInst, IDS_PORT_ADDRESS, szText, COUNT_OF(szText));
 535     if (ListView_InsertColumn(hwndLV, 0, &lvC) == -1)
 536         return FALSE;
 537
 538     lvC.iSubItem = 1;
 539     LoadStringW(hInst, IDS_PORT_LENGTH, szText, COUNT_OF(szText));
 540     if (ListView_InsertColumn(hwndLV, 1, &lvC) == -1)
 541         return FALSE;
 542
 543     lvC.iSubItem = 2;
 544     lvC.cx = (rc.right - rc.left) - 2 * width;
 545     LoadStringW(hInst, IDS_PORT_ACCESS, szText, COUNT_OF(szText));
 546     if (ListView_InsertColumn(hwndLV, 2, &lvC) == -1)
 547         return FALSE;
 548
 549     /* Device specific list */
 550     hwndLV = GetDlgItem(hwnd, IDC_DEVICE_LIST);
 551     ListView_SetExtendedListViewStyle(hwndLV, LVS_EX_FULLROWSELECT);
 552     GetClientRect(hwndLV, &rc);
 553     width = (rc.right - rc.left) / 3;
 554
 555     /* Load the column labels from the resource file. */
 556     lvC.iSubItem = 0;
 557     lvC.cx = width;
 558     LoadStringW(hInst, IDS_SPECIFIC_RESERVED1, szText, COUNT_OF(szText));
 559     if (ListView_InsertColumn(hwndLV, 0, &lvC) == -1)
 560         return FALSE;
 561
 562     lvC.iSubItem = 1;
 563     LoadStringW(hInst, IDS_SPECIFIC_RESERVED2, szText, COUNT_OF(szText));
 564     if (ListView_InsertColumn(hwndLV, 1, &lvC) == -1)
 565         return FALSE;
 566
 567     lvC.iSubItem = 2;
 568     lvC.cx = (rc.right - rc.left) - 2 * width;
 569     LoadStringW(hInst, IDS_SPECIFIC_DATASIZE, szText, COUNT_OF(szText));
 570     if (ListView_InsertColumn(hwndLV, 2, &lvC) == -1)
 571         return FALSE;
 572
 573     return TRUE;
 574 }
 575
 576 static VOID
 577 GetInterfaceType(INTERFACE_TYPE InterfaceType,
 578                  LPWSTR pBuffer,
 579                  DWORD dwLength)
 580 {
 581 //    LPWSTR lpInterfaceType;
 582
 583     switch (InterfaceType)
 584     {
 585         case InterfaceTypeUndefined:
 586             LoadStringW(hInst, IDS_BUS_UNDEFINED, pBuffer, dwLength);
 587 //            lpInterfaceType = L"Undefined";
 588             break;
 589         case Internal:
 590             LoadStringW(hInst, IDS_BUS_INTERNAL, pBuffer, dwLength);
 591 //            lpInterfaceType = L"Internal";
 592             break;
 593         case Isa:
 594             LoadStringW(hInst, IDS_BUS_ISA, pBuffer, dwLength);
 595 //            lpInterfaceType = L"Isa";
 596             break;
 597         case Eisa:
 598             LoadStringW(hInst, IDS_BUS_EISA, pBuffer, dwLength);
 599 //            lpInterfaceType = L"Eisa";
 600             break;
 601         case MicroChannel:
 602             LoadStringW(hInst, IDS_BUS_MICROCHANNEL, pBuffer, dwLength);
 603 //            lpInterfaceType = L"MicroChannel";
 604             break;
 605         case TurboChannel:
 606             LoadStringW(hInst, IDS_BUS_TURBOCHANNEL, pBuffer, dwLength);
 607 //            lpInterfaceType = L"TurboChannel";
 608             break;
 609         case PCIBus:
 610             LoadStringW(hInst, IDS_BUS_PCIBUS, pBuffer, dwLength);
 611 //            lpInterfaceType = L"PCIBus";
 612             break;
 613         case VMEBus:
 614             LoadStringW(hInst, IDS_BUS_VMEBUS, pBuffer, dwLength);
 615 //            lpInterfaceType = L"VMEBus";
 616             break;
 617         case NuBus:
 618             LoadStringW(hInst, IDS_BUS_NUBUS, pBuffer, dwLength);
 619 //            lpInterfaceType = L"NuBus";
 620             break;
 621         case PCMCIABus:
 622             LoadStringW(hInst, IDS_BUS_PCMCIABUS, pBuffer, dwLength);
 623 //            lpInterfaceType = L"PCMCIABus";
 624             break;
 625         case CBus:
 626             LoadStringW(hInst, IDS_BUS_CBUS, pBuffer, dwLength);
 627 //            lpInterfaceType = L"CBus";
 628             break;
 629         case MPIBus:
 630             LoadStringW(hInst, IDS_BUS_MPIBUS, pBuffer, dwLength);
 631 //            lpInterfaceType = L"MPIBus";
 632             break;
 633         case MPSABus:
 634             LoadStringW(hInst, IDS_BUS_MPSABUS, pBuffer, dwLength);
 635 //            lpInterfaceType = L"MPSABus";
 636             break;
 637         case ProcessorInternal:
 638             LoadStringW(hInst, IDS_BUS_PROCESSORINTERNAL, pBuffer, dwLength);
 639 //            lpInterfaceType = L"ProcessorInternal";
 640             break;
 641         case InternalPowerBus:
 642             LoadStringW(hInst, IDS_BUS_INTERNALPOWERBUS, pBuffer, dwLength);
 643 //            lpInterfaceType = L"InternalPowerBus";
 644             break;
 645         case PNPISABus:
 646             LoadStringW(hInst, IDS_BUS_PNPISABUS, pBuffer, dwLength);
 647 //            lpInterfaceType = L"PNPISABus";
 648             break;
 649         case PNPBus:
 650             LoadStringW(hInst, IDS_BUS_PNPBUS, pBuffer, dwLength);
 651 //            lpInterfaceType = L"PNPBus";
 652             break;
 653         default:
 654             LoadStringW(hInst, IDS_BUS_UNKNOWNTYPE, pBuffer, dwLength);
 655 //            lpInterfaceType = L"Unknown interface type";
 656             break;
 657     }
 658
 659 //    wcscpy(pBuffer, lpInterfaceType);
 660 }
 661
 662
 663 static VOID
 664 ParseResources(HWND hwnd)
 665 {
 666     PCM_FULL_RESOURCE_DESCRIPTOR pFullDescriptor;
 667     PCM_PARTIAL_RESOURCE_LIST pPartialResourceList;
 668     PCM_PARTIAL_RESOURCE_DESCRIPTOR pDescriptor;
 669     ULONG i;
 670     HWND hwndLV;
 671
 672     WCHAR buffer[80];
 673     LVITEMW item;
 674     INT iItem;
 675
 676     pFullDescriptor = &resourceValueData->List[0];
 677     for (i = 0; i < fullResourceIndex; i++)
 678     {
 679         pFullDescriptor = (PVOID)(pFullDescriptor->PartialResourceList.PartialDescriptors +
 680                                   pFullDescriptor->PartialResourceList.Count);
 681     }
 682     pPartialResourceList = &pFullDescriptor->PartialResourceList;
 683
 684     /* Interface type */
 685     GetInterfaceType(pFullDescriptor->InterfaceType, buffer, 80);
 686     SetDlgItemTextW(hwnd, IDC_INTERFACETYPE, buffer);
 687
 688     /* Busnumber */
 689     SetDlgItemInt(hwnd, IDC_BUSNUMBER, (UINT)pFullDescriptor->BusNumber, FALSE);
 690
 691     /* Version */
 692     SetDlgItemInt(hwnd, IDC_VERSION, (UINT)pPartialResourceList->Version, FALSE);
 693
 694     /* Revision */
 695     SetDlgItemInt(hwnd, IDC_REVISION, (UINT)pPartialResourceList->Revision, FALSE);
 696
 697     for (i = 0; i < pPartialResourceList->Count; i++)
 698     {
 699         pDescriptor = &pPartialResourceList->PartialDescriptors[i];
 700
 701         switch (pDescriptor->Type)
 702         {
 703             case CmResourceTypePort:
 704                 hwndLV = GetDlgItem(hwnd, IDC_PORT_LIST);
 705
 706 #ifdef _M_AMD64
 707                 wsprintf(buffer, L"0x%016I64x", pDescriptor->u.Port.Start.QuadPart);
 708 #else
 709                 wsprintf(buffer, L"0x%08lx", pDescriptor->u.Port.Start.u.LowPart);
 710 #endif
 711
 712                 item.mask = LVIF_TEXT | LVIF_PARAM;
 713                 item.iItem = 1000;
 714                 item.iSubItem = 0;
 715                 item.state = 0;
 716                 item.stateMask = 0;
 717                 item.pszText = buffer;
 718                 item.cchTextMax = (int)wcslen(item.pszText);
 719                 item.lParam = (LPARAM)pDescriptor;
 720
 721                 iItem = ListView_InsertItem(hwndLV, &item);
 722                 if (iItem != -1)
 723                 {
 724                     wsprintf(buffer, L"0x%lx", pDescriptor->u.Port.Length);
 725                     ListView_SetItemText(hwndLV, iItem, 1, buffer);
 726
 727                     if (pDescriptor->Flags & CM_RESOURCE_PORT_IO)
 728                         LoadStringW(hInst, IDS_PORT_PORT_IO, buffer, COUNT_OF(buffer));
 729                     else
 730                         LoadStringW(hInst, IDS_PORT_MEMORY_IO, buffer, COUNT_OF(buffer));
 731                     ListView_SetItemText(hwndLV, iItem, 2, buffer);
 732                 }
 733                 break;
 734
 735             case CmResourceTypeInterrupt:
 736                 hwndLV = GetDlgItem(hwnd, IDC_IRQ_LIST);
 737
 738                 wsprintf(buffer, L"%lu", pDescriptor->u.Interrupt.Vector);
 739
 740                 item.mask = LVIF_TEXT | LVIF_PARAM;
 741                 item.iItem = 1000;
 742                 item.iSubItem = 0;
 743                 item.state = 0;
 744                 item.stateMask = 0;
 745                 item.pszText = buffer;
 746                 item.cchTextMax = (int)wcslen(item.pszText);
 747                 item.lParam = (LPARAM)pDescriptor;
 748
 749                 iItem = ListView_InsertItem(hwndLV, &item);
 750                 if (iItem != -1)
 751                 {
 752                     wsprintf(buffer, L"%lu", pDescriptor->u.Interrupt.Level);
 753                     ListView_SetItemText(hwndLV, iItem, 1, buffer);
 754
 755                     wsprintf(buffer, L"0x%08lx", pDescriptor->u.Interrupt.Affinity);
 756                     ListView_SetItemText(hwndLV, iItem, 2, buffer);
 757
 758                     if (pDescriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED)
 759                         LoadStringW(hInst, IDS_INTERRUPT_EDGE_SENSITIVE, buffer, COUNT_OF(buffer));
 760                     else
 761                         LoadStringW(hInst, IDS_INTERRUPT_LEVEL_SENSITIVE, buffer, COUNT_OF(buffer));
 762
 763                     ListView_SetItemText(hwndLV, iItem, 3, buffer);
 764                 }
 765                 break;
 766
 767             case CmResourceTypeMemory:
 768                 hwndLV = GetDlgItem(hwnd, IDC_MEMORY_LIST);
 769
 770 #ifdef _M_AMD64
 771                 wsprintf(buffer, L"0x%016I64x", pDescriptor->u.Memory.Start.QuadPart);
 772 #else
 773                 wsprintf(buffer, L"0x%08lx", pDescriptor->u.Memory.Start.u.LowPart);
 774 #endif
 775
 776                 item.mask = LVIF_TEXT | LVIF_PARAM;
 777                 item.iItem = 1000;
 778                 item.iSubItem = 0;
 779                 item.state = 0;
 780                 item.stateMask = 0;
 781                 item.pszText = buffer;
 782                 item.cchTextMax = (int)wcslen(item.pszText);
 783                 item.lParam = (LPARAM)pDescriptor;
 784
 785                 iItem = ListView_InsertItem(hwndLV, &item);
 786                 if (iItem != -1)
 787                 {
 788                     wsprintf(buffer, L"0x%lx", pDescriptor->u.Memory.Length);
 789                     ListView_SetItemText(hwndLV, iItem, 1, buffer);
 790
 791                     switch (pDescriptor->Flags & (CM_RESOURCE_MEMORY_READ_ONLY | CM_RESOURCE_MEMORY_WRITE_ONLY))
 792                     {
 793                         case CM_RESOURCE_MEMORY_READ_ONLY:
 794                             LoadStringW(hInst, IDS_MEMORY_READ_ONLY, buffer, COUNT_OF(buffer));
 795                             break;
 796
 797                         case CM_RESOURCE_MEMORY_WRITE_ONLY:
 798                             LoadStringW(hInst, IDS_MEMORY_WRITE_ONLY, buffer, COUNT_OF(buffer));
 799                             break;
 800
 801                         default:
 802                             LoadStringW(hInst, IDS_MEMORY_READ_WRITE, buffer, COUNT_OF(buffer));
 803                             break;
 804                     }
 805
 806                     ListView_SetItemText(hwndLV, iItem, 2, buffer);
 807                 }
 808                 break;
 809
 810             case CmResourceTypeDma:
 811                 hwndLV = GetDlgItem(hwnd, IDC_DMA_LIST);
 812
 813                 wsprintf(buffer, L"%lu", pDescriptor->u.Dma.Channel);
 814
 815                 item.mask = LVIF_TEXT | LVIF_PARAM;
 816                 item.iItem = 1000;
 817                 item.iSubItem = 0;
 818                 item.state = 0;
 819                 item.stateMask = 0;
 820                 item.pszText = buffer;
 821                 item.cchTextMax = (int)wcslen(item.pszText);
 822                 item.lParam = (LPARAM)pDescriptor;
 823
 824                 iItem = ListView_InsertItem(hwndLV, &item);
 825                 if (iItem != -1)
 826                 {
 827                     wsprintf(buffer, L"%lu", pDescriptor->u.Dma.Port);
 828                     ListView_SetItemText(hwndLV, iItem, 1, buffer);
 829                 }
 830                 break;
 831
 832             case CmResourceTypeDeviceSpecific:
 833                 hwndLV = GetDlgItem(hwnd, IDC_DEVICE_LIST);
 834
 835                 wsprintf(buffer, L"0x%08lx", pDescriptor->u.DeviceSpecificData.Reserved1);
 836
 837                 item.mask = LVIF_TEXT | LVIF_PARAM;
 838                 item.iItem = 1000;
 839                 item.iSubItem = 0;
 840                 item.state = 0;
 841                 item.stateMask = 0;
 842                 item.pszText = buffer;
 843                 item.cchTextMax = (int)wcslen(item.pszText);
 844                 item.lParam = (LPARAM)pDescriptor;
 845
 846                 iItem = ListView_InsertItem(hwndLV, &item);
 847                 if (iItem != -1)
 848                 {
 849                     wsprintf(buffer, L"0x%08lx", pDescriptor->u.DeviceSpecificData.Reserved2);
 850                     ListView_SetItemText(hwndLV, iItem, 1, buffer);
 851
 852                     wsprintf(buffer, L"0x%lx", pDescriptor->u.DeviceSpecificData.DataSize);
 853                     ListView_SetItemText(hwndLV, iItem, 2, buffer);
 854                 }
 855                 break;
 856         }
 857     }
 858 }
 859
 860
 861 static BOOL
 862 OnResourceNotify(HWND hwndDlg, NMHDR *phdr)
 863 {
 864     LPNMLISTVIEW lpnmlv = (LPNMLISTVIEW)phdr;
 865
 866     switch (phdr->idFrom)
 867     {
 868         case IDC_PORT_LIST:
 869         case IDC_MEMORY_LIST:
 870         case IDC_DMA_LIST:
 871         case IDC_IRQ_LIST:
 872         case IDC_DEVICE_LIST:
 873             switch(phdr->code)
 874             {
 875                 case NM_CLICK:
 876                     if (lpnmlv->iItem != -1)
 877                     {
 878                         PCM_PARTIAL_RESOURCE_DESCRIPTOR pDescriptor;
 879                         LVITEMW item;
 880
 881                         item.mask = LVIF_PARAM;
 882                         item.iItem = lpnmlv->iItem;
 883                         item.iSubItem = 0;
 884
 885                         if (ListView_GetItem(phdr->hwndFrom, &item))
 886                         {
 887                             pDescriptor = (PCM_PARTIAL_RESOURCE_DESCRIPTOR)item.lParam;
 888
 889                             EnableWindow(GetDlgItem(hwndDlg, IDC_UNDETERMINED),
 890                                          (pDescriptor->ShareDisposition == CmResourceShareUndetermined));
 891
 892                             EnableWindow(GetDlgItem(hwndDlg, IDC_SHARED),
 893                                          (pDescriptor->ShareDisposition == CmResourceShareShared));
 894
 895                             EnableWindow(GetDlgItem(hwndDlg, IDC_DEVICE_EXCLUSIVE),
 896                                          (pDescriptor->ShareDisposition == CmResourceShareDeviceExclusive));
 897
 898                             EnableWindow(GetDlgItem(hwndDlg, IDC_DRIVER_EXCLUSIVE),
 899                                          (pDescriptor->ShareDisposition == CmResourceShareDriverExclusive));
 900                         }
 901                     }
 902                     else
 903                     {
 904                         EnableWindow(GetDlgItem(hwndDlg, IDC_UNDETERMINED), FALSE);
 905                         EnableWindow(GetDlgItem(hwndDlg, IDC_SHARED), FALSE);
 906                         EnableWindow(GetDlgItem(hwndDlg, IDC_DEVICE_EXCLUSIVE), FALSE);
 907                         EnableWindow(GetDlgItem(hwndDlg, IDC_DRIVER_EXCLUSIVE), FALSE);
 908                     }
 909                     break;
 910             }
 911             break;
 912     }
 913
 914     return FALSE;
 915 }
 916
 917
 918 static INT_PTR CALLBACK modify_resource_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 919 {
 920     UNREFERENCED_PARAMETER(lParam);
 921
 922     switch(uMsg)
 923     {
 924     case WM_INITDIALOG:
 925         CreateResourceColumns(hwndDlg);
 926         ParseResources(hwndDlg);
 927         return FALSE;
 928
 929     case WM_NOTIFY:
 930         return OnResourceNotify(hwndDlg, (NMHDR *)lParam);
 931
 932     case WM_COMMAND:
 933         switch (LOWORD(wParam))
 934         {
 935         case IDOK:
 936             EndDialog(hwndDlg, IDOK);
 937             break;
 938         case IDCANCEL:
 939             EndDialog(hwndDlg, IDCANCEL);
 940             return TRUE;
 941         }
 942     }
 943     return FALSE;
 944 }
 945
 946 static BOOL CreateResourceListColumns(HWND hWndListView)
 947 {
 948     WCHAR szText[80];
 949     RECT rc;
 950     LVCOLUMN lvC;
 951
 952     ListView_SetExtendedListViewStyle(hWndListView, LVS_EX_FULLROWSELECT);
 953
 954     GetClientRect(hWndListView, &rc);
 955
 956     /* Create columns. */
 957     lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
 958     lvC.pszText = szText;
 959     lvC.fmt = LVCFMT_LEFT;
 960
 961     /* Load the column labels from the resource file. */
 962     lvC.iSubItem = 0;
 963     lvC.cx = (rc.right - rc.left) / 2;
 964     LoadStringW(hInst, IDS_BUSNUMBER, szText, COUNT_OF(szText));
 965     if (ListView_InsertColumn(hWndListView, 0, &lvC) == -1)
 966         return FALSE;
 967
 968     lvC.iSubItem = 1;
 969     lvC.cx = (rc.right - rc.left) - lvC.cx;
 970     LoadStringW(hInst, IDS_INTERFACE, szText, COUNT_OF(szText));
 971     if (ListView_InsertColumn(hWndListView, 1, &lvC) == -1)
 972         return FALSE;
 973
 974     return TRUE;
 975 }
 976
 977 static VOID AddFullResourcesToList(HWND hwnd)
 978 {
 979     PCM_FULL_RESOURCE_DESCRIPTOR pFullDescriptor;
 980     WCHAR buffer[80];
 981     LVITEMW item;
 982     ULONG i;
 983     INT iItem;
 984
 985     pFullDescriptor = &resourceValueData->List[0];
 986     for (i = 0; i < resourceValueData->Count; i++)
 987     {
 988         wsprintf(buffer, L"%lu", pFullDescriptor->BusNumber);
 989
 990         item.mask = LVIF_TEXT;
 991         item.iItem = i;
 992         item.iSubItem = 0;
 993         item.state = 0;
 994         item.stateMask = 0;
 995         item.pszText = buffer;
 996         item.cchTextMax = (int)wcslen(item.pszText);
 997
 998         iItem = ListView_InsertItem(hwnd, &item);
 999         if (iItem != -1)
1000         {
1001             GetInterfaceType(pFullDescriptor->InterfaceType, buffer, 80);
1002             ListView_SetItemText(hwnd, iItem, 1, buffer);
1003         }
1004         pFullDescriptor = (PVOID)(pFullDescriptor->PartialResourceList.PartialDescriptors +
1005                                   pFullDescriptor->PartialResourceList.Count);
1006     }
1007 }
1008
1009 static BOOL
1010 OnResourceListNotify(HWND hwndDlg, NMHDR *phdr)
1011 {
1012     LPNMLISTVIEW lpnmlv = (LPNMLISTVIEW)phdr;
1013
1014     switch (phdr->idFrom)
1015     {
1016         case IDC_RESOURCE_LIST:
1017             switch(phdr->code)
1018             {
1019                 case NM_CLICK:
1020                     fullResourceIndex = lpnmlv->iItem;
1021                     EnableWindow(GetDlgItem(hwndDlg, IDC_SHOW_RESOURCE), (lpnmlv->iItem != -1));
1022                     break;
1023
1024                 case NM_DBLCLK:
1025                     if (lpnmlv->iItem != -1)
1026                     {
1027                         fullResourceIndex = lpnmlv->iItem;
1028                         DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_RESOURCE), hwndDlg, modify_resource_dlgproc);
1029                     }
1030                     break;
1031             }
1032             break;
1033     }
1034
1035     return FALSE;
1036 }
1037
1038
1039 static INT_PTR CALLBACK modify_resource_list_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
1040 {
1041     UNREFERENCED_PARAMETER(lParam);
1042
1043     switch(uMsg)
1044     {
1045     case WM_INITDIALOG:
1046         CreateResourceListColumns(GetDlgItem(hwndDlg, IDC_RESOURCE_LIST));
1047         AddFullResourcesToList(GetDlgItem(hwndDlg, IDC_RESOURCE_LIST));
1048         return FALSE;
1049
1050     case WM_NOTIFY:
1051         return OnResourceListNotify(hwndDlg, (NMHDR *)lParam);
1052
1053     case WM_COMMAND:
1054         switch (LOWORD(wParam))
1055         {
1056         case IDC_SHOW_RESOURCE:
1057             if (fullResourceIndex != -1)
1058                 DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_RESOURCE), hwndDlg, modify_resource_dlgproc);
1059             break;
1060         case IDOK:
1061             EndDialog(hwndDlg, IDOK);
1062             break;
1063         case IDCANCEL:
1064             EndDialog(hwndDlg, IDCANCEL);
1065             return TRUE;
1066         }
1067     }
1068     return FALSE;
1069 }
1070
1071
1072 BOOL ModifyValue(HWND hwnd, HKEY hKey, LPCWSTR valueName, BOOL EditBin)
1073 {
1074     DWORD type;
1075     LONG lRet;
1076     BOOL result = FALSE;
1077
1078     if (!hKey)
1079         return FALSE;
1080
1081     editValueName = valueName;
1082
1083     lRet = RegQueryValueExW(hKey, valueName, 0, &type, 0, &valueDataLen);
1084     if (lRet != ERROR_SUCCESS && (valueName == NULL || !valueName[0]))
1085     {
1086         lRet = ERROR_SUCCESS; /* Allow editing of (Default) values which don't exist */
1087         type = REG_SZ;
1088         valueDataLen = 0;
1089         stringValueData = NULL;
1090         binValueData = NULL;
1091     }
1092
1093     if (lRet != ERROR_SUCCESS)
1094     {
1095         error(hwnd, IDS_BAD_VALUE, valueName);
1096         goto done;
1097     }
1098
1099     if (EditBin == FALSE && ((type == REG_SZ) || (type == REG_EXPAND_SZ)))
1100     {
1101         if (valueDataLen > 0)
1102         {
1103             if (!(stringValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen)))
1104             {
1105                 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
1106                 goto done;
1107             }
1108             lRet = RegQueryValueExW(hKey, valueName, 0, 0, (LPBYTE)stringValueData, &valueDataLen);
1109             if (lRet != ERROR_SUCCESS)
1110             {
1111                 error(hwnd, IDS_BAD_VALUE, valueName);
1112                 goto done;
1113             }
1114         }
1115         else
1116         {
1117             stringValueData = NULL;
1118         }
1119
1120         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_STRING), hwnd, modify_string_dlgproc) == IDOK)
1121         {
1122             if (stringValueData)
1123             {
1124                 lRet = RegSetValueExW(hKey, valueName, 0, type, (LPBYTE)stringValueData, (DWORD) (wcslen(stringValueData) + 1) * sizeof(WCHAR));
1125             }
1126             else
1127             {
1128                 lRet = RegSetValueExW(hKey, valueName, 0, type, NULL, 0);
1129             }
1130             if (lRet == ERROR_SUCCESS)
1131                 result = TRUE;
1132         }
1133     }
1134     else if (EditBin == FALSE && type == REG_MULTI_SZ)
1135     {
1136         if (valueDataLen > 0)
1137         {
1138             size_t llen, listlen, nl_len;
1139             LPWSTR src, lines = NULL;
1140
1141             if (!(stringValueData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, valueDataLen + sizeof(WCHAR))))
1142             {
1143                 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
1144                 goto done;
1145             }
1146             lRet = RegQueryValueExW(hKey, valueName, 0, 0, (LPBYTE)stringValueData, &valueDataLen);
1147             if (lRet != ERROR_SUCCESS)
1148             {
1149                 error(hwnd, IDS_BAD_VALUE, valueName);
1150                 goto done;
1151             }
1152
1153             /* convert \0 to \r\n */
1154             src = stringValueData;
1155             nl_len = wcslen(L"\r\n") * sizeof(WCHAR);
1156             listlen = sizeof(WCHAR);
1157             lines = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, listlen + sizeof(WCHAR));
1158             while(*src != L'\0')
1159             {
1160                 llen = wcslen(src);
1161                 if(llen == 0)
1162                     break;
1163                 listlen += (llen * sizeof(WCHAR)) + nl_len;
1164                 lines = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lines, listlen);
1165                 wcscat(lines, src);
1166                 wcscat(lines, L"\r\n");
1167                 src += llen + 1;
1168             }
1169             HeapFree(GetProcessHeap(), 0, stringValueData);
1170             stringValueData = lines;
1171         }
1172         else
1173         {
1174             stringValueData = NULL;
1175         }
1176
1177         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_MULTI_STRING), hwnd, modify_multi_string_dlgproc) == IDOK)
1178         {
1179             if (stringValueData)
1180             {
1181                 /* convert \r\n to \0 */
1182                 BOOL EmptyLines = FALSE;
1183                 LPWSTR src, lines, nl;
1184                 size_t linechars, buflen, c_nl, dest;
1185
1186                 src = stringValueData;
1187                 buflen = sizeof(WCHAR);
1188                 lines = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen + sizeof(WCHAR));
1189                 c_nl = wcslen(L"\r\n");
1190                 dest = 0;
1191                 while(*src != L'\0')
1192                 {
1193                     if((nl = wcsstr(src, L"\r\n")))
1194                     {
1195                         linechars = nl - src;
1196                         if(nl == src)
1197                         {
1198                             EmptyLines = TRUE;
1199                             src = nl + c_nl;
1200                             continue;
1201                         }
1202                     }
1203                     else
1204                     {
1205                         linechars = wcslen(src);
1206                     }
1207                     if(linechars > 0)
1208                     {
1209                         buflen += ((linechars + 1) * sizeof(WCHAR));
1210                         lines = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lines, buflen);
1211                         memcpy((lines + dest), src, linechars * sizeof(WCHAR));
1212                         dest += linechars;
1213                         lines[dest++] = L'\0';
1214                     }
1215                     else
1216                     {
1217                         EmptyLines = TRUE;
1218                     }
1219                     src += linechars + (nl != NULL ? c_nl : 0);
1220                 }
1221                 lines[++dest] = L'\0';
1222
1223                 if(EmptyLines)
1224                 {
1225                     warning(hwnd, IDS_MULTI_SZ_EMPTY_STRING);
1226                 }
1227
1228                 lRet = RegSetValueExW(hKey, valueName, 0, type, (LPBYTE)lines, (DWORD) buflen);
1229                 HeapFree(GetProcessHeap(), 0, lines);
1230             }
1231             else
1232             {
1233                 lRet = RegSetValueExW(hKey, valueName, 0, type, NULL, 0);
1234             }
1235             if (lRet == ERROR_SUCCESS)
1236                 result = TRUE;
1237         }
1238     }
1239     else if (EditBin == FALSE && type == REG_DWORD)
1240     {
1241         lRet = RegQueryValueExW(hKey, valueName, 0, 0, (LPBYTE)&dwordValueData, &valueDataLen);
1242         if (lRet != ERROR_SUCCESS)
1243         {
1244             error(hwnd, IDS_BAD_VALUE, valueName);
1245             goto done;
1246         }
1247
1248         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_DWORD), hwnd, modify_dword_dlgproc) == IDOK)
1249         {
1250             lRet = RegSetValueExW(hKey, valueName, 0, type, (LPBYTE)&dwordValueData, sizeof(DWORD));
1251             if (lRet == ERROR_SUCCESS)
1252                 result = TRUE;
1253         }
1254     }
1255     else if (EditBin == FALSE && type == REG_RESOURCE_LIST)
1256     {
1257         if (valueDataLen > 0)
1258         {
1259             resourceValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen);
1260             if (resourceValueData == NULL)
1261             {
1262                 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
1263                 goto done;
1264             }
1265
1266             lRet = RegQueryValueExW(hKey, valueName, 0, 0, (LPBYTE)resourceValueData, &valueDataLen);
1267             if (lRet != ERROR_SUCCESS)
1268             {
1269                 error(hwnd, IDS_BAD_VALUE, valueName);
1270                 goto done;
1271             }
1272         }
1273         else
1274         {
1275             resourceValueData = NULL;
1276         }
1277
1278         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_RESOURCE_LIST), hwnd, modify_resource_list_dlgproc) == IDOK)
1279         {
1280         }
1281     }
1282     else if (EditBin == FALSE && type == REG_FULL_RESOURCE_DESCRIPTOR)
1283     {
1284         if (valueDataLen > 0)
1285         {
1286             resourceValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen + sizeof(ULONG));
1287             if (resourceValueData == NULL)
1288             {
1289                 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
1290                 goto done;
1291             }
1292
1293             lRet = RegQueryValueExW(hKey, valueName, 0, 0, (LPBYTE)&resourceValueData->List[0], &valueDataLen);
1294             if (lRet != ERROR_SUCCESS)
1295             {
1296                 error(hwnd, IDS_BAD_VALUE, valueName);
1297                 goto done;
1298             }
1299
1300             resourceValueData->Count = 1;
1301             fullResourceIndex = 0;
1302         }
1303         else
1304         {
1305             resourceValueData = NULL;
1306         }
1307
1308         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_RESOURCE), hwnd, modify_resource_dlgproc) == IDOK)
1309         {
1310         }
1311     }
1312     else if ((EditBin != FALSE) || (type == REG_NONE) || (type == REG_BINARY))
1313     {
1314         if(valueDataLen > 0)
1315         {
1316             if(!(binValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen + 1)))
1317             {
1318                 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
1319                 goto done;
1320             }
1321
1322             /* Use the unicode version, so editing strings in binary mode is correct */
1323             lRet = RegQueryValueExW(hKey, valueName,
1324                                     0, 0, (LPBYTE)binValueData, &valueDataLen);
1325             if (lRet != ERROR_SUCCESS)
1326             {
1327                 HeapFree(GetProcessHeap(), 0, binValueData);
1328                 error(hwnd, IDS_BAD_VALUE, valueName);
1329                 goto done;
1330             }
1331         }
1332         else
1333         {
1334             binValueData = NULL;
1335         }
1336
1337         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_BIN_DATA), hwnd, modify_binary_dlgproc) == IDOK)
1338         {
1339             /* Use the unicode version, so editing strings in binary mode is correct */
1340             lRet = RegSetValueExW(hKey, valueName,
1341                                   0, type, (LPBYTE)binValueData, valueDataLen);
1342             if (lRet == ERROR_SUCCESS)
1343                 result = TRUE;
1344         }
1345         if(binValueData != NULL)
1346             HeapFree(GetProcessHeap(), 0, binValueData);
1347     }
1348     else
1349     {
1350         error(hwnd, IDS_UNSUPPORTED_TYPE, type);
1351     }
1352
1353 done:
1354     if (resourceValueData)
1355         HeapFree(GetProcessHeap(), 0, resourceValueData);
1356     resourceValueData = NULL;
1357
1358     if (stringValueData)
1359         HeapFree(GetProcessHeap(), 0, stringValueData);
1360     stringValueData = NULL;
1361
1362     return result;
1363 }
1364
1365 static LONG CopyKey(HKEY hDestKey, LPCWSTR lpDestSubKey, HKEY hSrcKey, LPCWSTR lpSrcSubKey)
1366 {
1367     LONG lResult;
1368     DWORD dwDisposition;
1369     HKEY hDestSubKey = NULL;
1370     HKEY hSrcSubKey = NULL;
1371     DWORD dwIndex, dwType, cbName, cbData;
1372     WCHAR szSubKey[256];
1373     WCHAR szValueName[256];
1374     BYTE szValueData[512];
1375
1376     FILETIME ft;
1377
1378     /* open the source subkey, if specified */
1379     if (lpSrcSubKey)
1380     {
1381         lResult = RegOpenKeyExW(hSrcKey, lpSrcSubKey, 0, KEY_ALL_ACCESS, &hSrcSubKey);
1382         if (lResult)
1383             goto done;
1384         hSrcKey = hSrcSubKey;
1385     }
1386
1387     /* create the destination subkey */
1388     lResult = RegCreateKeyExW(hDestKey, lpDestSubKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL,
1389                              &hDestSubKey, &dwDisposition);
1390     if (lResult)
1391         goto done;
1392
1393     /* copy all subkeys */
1394     dwIndex = 0;
1395     do
1396     {
1397         cbName = sizeof(szSubKey) / sizeof(szSubKey[0]);
1398         lResult = RegEnumKeyExW(hSrcKey, dwIndex++, szSubKey, &cbName, NULL, NULL, NULL, &ft);
1399         if (lResult == ERROR_SUCCESS)
1400         {
1401             lResult = CopyKey(hDestSubKey, szSubKey, hSrcKey, szSubKey);
1402             if (lResult)
1403                 goto done;
1404         }
1405     }
1406     while(lResult == ERROR_SUCCESS);
1407
1408     /* copy all subvalues */
1409     dwIndex = 0;
1410     do
1411     {
1412         cbName = sizeof(szValueName) / sizeof(szValueName[0]);
1413         cbData = sizeof(szValueData) / sizeof(szValueData[0]);
1414         lResult = RegEnumValueW(hSrcKey, dwIndex++, szValueName, &cbName, NULL, &dwType, szValueData, &cbData);
1415         if (lResult == ERROR_SUCCESS)
1416         {
1417             lResult = RegSetValueExW(hDestSubKey, szValueName, 0, dwType, szValueData, cbData);
1418             if (lResult)
1419                 goto done;
1420         }
1421     }
1422     while(lResult == ERROR_SUCCESS);
1423
1424     lResult = ERROR_SUCCESS;
1425
1426 done:
1427     if (hSrcSubKey)
1428         RegCloseKey(hSrcSubKey);
1429     if (hDestSubKey)
1430         RegCloseKey(hDestSubKey);
1431     if (lResult != ERROR_SUCCESS)
1432         SHDeleteKey(hDestKey, lpDestSubKey);
1433     return lResult;
1434 }
1435
1436 static LONG MoveKey(HKEY hDestKey, LPCWSTR lpDestSubKey, HKEY hSrcKey, LPCWSTR lpSrcSubKey)
1437 {
1438     LONG lResult;
1439
1440     if (!lpSrcSubKey)
1441         return ERROR_INVALID_FUNCTION;
1442
1443     if (_wcsicmp(lpDestSubKey, lpSrcSubKey) == 0)
1444     {
1445         /* Destination name equals source name */
1446         return ERROR_SUCCESS;
1447     }
1448
1449     lResult = CopyKey(hDestKey, lpDestSubKey, hSrcKey, lpSrcSubKey);
1450     if (lResult == ERROR_SUCCESS)
1451         SHDeleteKey(hSrcKey, lpSrcSubKey);
1452
1453     return lResult;
1454 }
1455
1456 BOOL DeleteKey(HWND hwnd, HKEY hKeyRoot, LPCWSTR keyPath)
1457 {
1458     WCHAR msg[128], caption[128];
1459     BOOL result = FALSE;
1460     LONG lRet;
1461     HKEY hKey;
1462
1463     lRet = RegOpenKeyExW(hKeyRoot, keyPath, 0, KEY_READ|KEY_SET_VALUE, &hKey);
1464     if (lRet != ERROR_SUCCESS)
1465     {
1466         error_code_messagebox(hwnd, lRet);
1467         return FALSE;
1468     }
1469
1470     LoadStringW(hInst, IDS_QUERY_DELETE_KEY_CONFIRM, caption, COUNT_OF(caption));
1471     LoadStringW(hInst, IDS_QUERY_DELETE_KEY_ONE, msg, COUNT_OF(msg));
1472
1473     if (MessageBoxW(g_pChildWnd->hWnd, msg, caption, MB_ICONQUESTION | MB_YESNO) != IDYES)
1474         goto done;
1475
1476     lRet = SHDeleteKey(hKeyRoot, keyPath);
1477     if (lRet != ERROR_SUCCESS)
1478     {
1479         error(hwnd, IDS_BAD_KEY, keyPath);
1480         goto done;
1481     }
1482     result = TRUE;
1483
1484 done:
1485     RegCloseKey(hKey);
1486     return result;
1487 }
1488
1489 LONG RenameKey(HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpNewName)
1490 {
1491     LPCWSTR s;
1492     LPWSTR lpNewSubKey = NULL;
1493     LONG Ret = 0;
1494
1495     if (!lpSubKey)
1496         return Ret;
1497
1498     s = wcsrchr(lpSubKey, L'\\');
1499     if (s)
1500     {
1501         s++;
1502         lpNewSubKey = (LPWSTR) HeapAlloc(GetProcessHeap(), 0, (s - lpSubKey + wcslen(lpNewName) + 1) * sizeof(WCHAR));
1503         if (lpNewSubKey != NULL)
1504         {
1505             memcpy(lpNewSubKey, lpSubKey, (s - lpSubKey) * sizeof(WCHAR));
1506             wcscpy(lpNewSubKey + (s - lpSubKey), lpNewName);
1507             lpNewName = lpNewSubKey;
1508         }
1509         else
1510             return ERROR_NOT_ENOUGH_MEMORY;
1511     }
1512
1513     Ret = MoveKey(hKey, lpNewName, hKey, lpSubKey);
1514
1515     if (lpNewSubKey)
1516     {
1517         HeapFree(GetProcessHeap(), 0, lpNewSubKey);
1518     }
1519     return Ret;
1520 }
1521
1522 LONG RenameValue(HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpDestValue, LPCWSTR lpSrcValue)
1523 {
1524     LONG lResult;
1525     HKEY hSubKey = NULL;
1526     DWORD dwType, cbData;
1527     BYTE data[512];
1528
1529     if (lpSubKey)
1530     {
1531         lResult = RegOpenKeyW(hKey, lpSubKey, &hSubKey);
1532         if (lResult != ERROR_SUCCESS)
1533             goto done;
1534         hKey = hSubKey;
1535     }
1536
1537     cbData = sizeof(data);
1538     lResult = RegQueryValueExW(hKey, lpSrcValue, NULL, &dwType, data, &cbData);
1539     if (lResult != ERROR_SUCCESS)
1540         goto done;
1541
1542     lResult = RegSetValueExW(hKey, lpDestValue, 0, dwType, data, cbData);
1543     if (lResult != ERROR_SUCCESS)
1544         goto done;
1545
1546     RegDeleteValue(hKey, lpSrcValue);
1547
1548 done:
1549     if (hSubKey)
1550         RegCloseKey(hSubKey);
1551     return lResult;
1552 }
1553
1554 LONG QueryStringValue(HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpValueName, LPWSTR pszBuffer, DWORD dwBufferLen)
1555 {
1556     LONG lResult;
1557     HKEY hSubKey = NULL;
1558     DWORD cbData, dwType;
1559
1560     if (lpSubKey)
1561     {
1562         lResult = RegOpenKeyW(hKey, lpSubKey, &hSubKey);
1563         if (lResult != ERROR_SUCCESS)
1564             goto done;
1565         hKey = hSubKey;
1566     }
1567
1568     cbData = (dwBufferLen - 1) * sizeof(*pszBuffer);
1569     lResult = RegQueryValueExW(hKey, lpValueName, NULL, &dwType, (LPBYTE) pszBuffer, &cbData);
1570     if (lResult != ERROR_SUCCESS)
1571         goto done;
1572     if (dwType != REG_SZ)
1573     {
1574         lResult = -1;
1575         goto done;
1576     }
1577
1578     pszBuffer[cbData / sizeof(*pszBuffer)] = L'\0';
1579
1580 done:
1581     if (lResult != ERROR_SUCCESS)
1582         pszBuffer[0] = L'\0';
1583     if (hSubKey)
1584         RegCloseKey(hSubKey);
1585     return lResult;
1586 }
1587
1588 BOOL GetKeyName(LPWSTR pszDest, size_t iDestLength, HKEY hRootKey, LPCWSTR lpSubKey)
1589 {
1590     LPCWSTR pszRootKey;
1591
1592     if (hRootKey == HKEY_CLASSES_ROOT)
1593         pszRootKey = L"HKEY_CLASSES_ROOT";
1594     else if (hRootKey == HKEY_CURRENT_USER)
1595         pszRootKey = L"HKEY_CURRENT_USER";
1596     else if (hRootKey == HKEY_LOCAL_MACHINE)
1597         pszRootKey = L"HKEY_LOCAL_MACHINE";
1598     else if (hRootKey == HKEY_USERS)
1599         pszRootKey = L"HKEY_USERS";
1600     else if (hRootKey == HKEY_CURRENT_CONFIG)
1601         pszRootKey = L"HKEY_CURRENT_CONFIG";
1602     else if (hRootKey == HKEY_DYN_DATA)
1603         pszRootKey = L"HKEY_DYN_DATA";
1604     else
1605         return FALSE;
1606
1607     if (lpSubKey[0])
1608         _snwprintf(pszDest, iDestLength, L"%s\\%s", pszRootKey, lpSubKey);
1609     else
1610         _snwprintf(pszDest, iDestLength, L"%s", pszRootKey);
1611     return TRUE;
1612 }