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