?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
regedit: Fix passing null pointer.
[wine/multimedia.git] / programs / regedit / framewnd.c
blob51c94cc955c3f716205439498f32d56486c862d9
1 /*
2 * Regedit frame window
3 *
4 * Copyright (C) 2002 Robert Dickenson <robd@reactos.org>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define WIN32_LEAN_AND_MEAN /* Exclude rarely-used stuff from Windows headers */
22
23 #include <windows.h>
24 #include <tchar.h>
25 #include <commctrl.h>
26 #include <commdlg.h>
27 #include <cderr.h>
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <shellapi.h>
31
32 #include "main.h"
33 #include "regproc.h"
34
35 /********************************************************************************
36 * Global and Local Variables:
37 */
38
39 static TCHAR favoritesKey[] = _T("Software\\Microsoft\\Windows\\CurrentVersion\\Applets\\RegEdit\\Favorites");
40 static BOOL bInMenuLoop = FALSE; /* Tells us if we are in the menu loop */
41 static TCHAR favoriteName[128];
42 static TCHAR searchString[128];
43 static int searchMask = SEARCH_KEYS | SEARCH_VALUES | SEARCH_CONTENT;
44
45 static TCHAR FileNameBuffer[_MAX_PATH];
46 static TCHAR FileTitleBuffer[_MAX_PATH];
47 static TCHAR FilterBuffer[_MAX_PATH];
48
49 /*******************************************************************************
50 * Local module support methods
51 */
52
53 static void resize_frame_rect(HWND hWnd, PRECT prect)
54 {
55 RECT rt;
56 /*
57 if (IsWindowVisible(hToolBar)) {
58 SendMessage(hToolBar, WM_SIZE, 0, 0);
59 GetClientRect(hToolBar, &rt);
60 prect->top = rt.bottom+3;
61 prect->bottom -= rt.bottom+3;
62 }
63 */
64 if (IsWindowVisible(hStatusBar)) {
65 SetupStatusBar(hWnd, TRUE);
66 GetClientRect(hStatusBar, &rt);
67 prect->bottom -= rt.bottom;
68 }
69 MoveWindow(g_pChildWnd->hWnd, prect->left, prect->top, prect->right, prect->bottom, TRUE);
70 }
71
72 static void resize_frame_client(HWND hWnd)
73 {
74 RECT rect;
75
76 GetClientRect(hWnd, &rect);
77 resize_frame_rect(hWnd, &rect);
78 }
79
80 /********************************************************************************/
81
82 static void OnEnterMenuLoop(HWND hWnd)
83 {
84 int nParts;
85
86 /* Update the status bar pane sizes */
87 nParts = -1;
88 SendMessage(hStatusBar, SB_SETPARTS, 1, (long)&nParts);
89 bInMenuLoop = TRUE;
90 SendMessage(hStatusBar, SB_SETTEXT, (WPARAM)0, (LPARAM)_T(""));
91 }
92
93 static void OnExitMenuLoop(HWND hWnd)
94 {
95 bInMenuLoop = FALSE;
96 /* Update the status bar pane sizes*/
97 SetupStatusBar(hWnd, TRUE);
98 UpdateStatusBar();
99 }
100
101 static void UpdateMenuItems(HMENU hMenu) {
102 HWND hwndTV = g_pChildWnd->hTreeWnd;
103 BOOL bAllowEdit = FALSE;
104 HKEY hRootKey = NULL;
105 LPCTSTR keyName;
106 keyName = GetItemPath(hwndTV, TreeView_GetSelection(hwndTV), &hRootKey);
107 if (GetFocus() != hwndTV || (keyName && *keyName)) { /* can't modify root keys, but allow for their values */
108 bAllowEdit = TRUE;
109 }
110 EnableMenuItem(hMenu, ID_EDIT_FIND, MF_ENABLED | MF_BYCOMMAND);
111 EnableMenuItem(hMenu, ID_EDIT_FINDNEXT, MF_ENABLED | MF_BYCOMMAND);
112 EnableMenuItem(hMenu, ID_EDIT_MODIFY, (bAllowEdit ? MF_ENABLED : MF_GRAYED) | MF_BYCOMMAND);
113 EnableMenuItem(hMenu, ID_EDIT_DELETE, (bAllowEdit ? MF_ENABLED : MF_GRAYED) | MF_BYCOMMAND);
114 EnableMenuItem(hMenu, ID_EDIT_RENAME, (bAllowEdit ? MF_ENABLED : MF_GRAYED) | MF_BYCOMMAND);
115 EnableMenuItem(hMenu, ID_FAVORITES_ADDTOFAVORITES, (hRootKey ? MF_ENABLED : MF_GRAYED) | MF_BYCOMMAND);
116 EnableMenuItem(hMenu, ID_FAVORITES_REMOVEFAVORITE,
117 (GetMenuItemCount(hMenu)>2 ? MF_ENABLED : MF_GRAYED) | MF_BYCOMMAND);
118 }
119
120 static void OnInitMenuPopup(HWND hWnd, HMENU hMenu, short wItem)
121 {
122 if (wItem == 3) {
123 HKEY hKey;
124 while(GetMenuItemCount(hMenu)>2)
125 DeleteMenu(hMenu, 2, MF_BYPOSITION);
126 if (RegOpenKeyEx(HKEY_CURRENT_USER, favoritesKey,
127 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
128 TCHAR namebuf[KEY_MAX_LEN];
129 BYTE valuebuf[4096];
130 int i = 0;
131 BOOL sep = FALSE;
132 DWORD ksize, vsize, type;
133 LONG error;
134 do {
135 ksize = KEY_MAX_LEN;
136 vsize = sizeof(valuebuf);
137 error = RegEnumValue(hKey, i, namebuf, &ksize, NULL, &type, valuebuf, &vsize);
138 if (error != ERROR_SUCCESS)
139 break;
140 if (type == REG_SZ) {
141 if (!sep) {
142 AppendMenu(hMenu, MF_SEPARATOR, -1, NULL);
143 sep = TRUE;
144 }
145 AppendMenu(hMenu, MF_STRING, ID_FAVORITE_FIRST+i, namebuf);
146 }
147 i++;
148 } while(error == ERROR_SUCCESS);
149 RegCloseKey(hKey);
150 }
151 }
152 UpdateMenuItems(hMenu);
153 }
154
155 static void OnMenuSelect(HWND hWnd, UINT nItemID, UINT nFlags, HMENU hSysMenu)
156 {
157 TCHAR str[100];
158
159 _tcscpy(str, _T(""));
160 if (nFlags & MF_POPUP) {
161 if (hSysMenu != GetMenu(hWnd)) {
162 if (nItemID == 2) nItemID = 5;
163 }
164 }
165 if (LoadString(hInst, nItemID, str, 100)) {
166 /* load appropriate string*/
167 LPTSTR lpsz = str;
168 /* first newline terminates actual string*/
169 lpsz = _tcschr(lpsz, '\n');
170 if (lpsz != NULL)
171 *lpsz = '\0';
172 }
173 SendMessage(hStatusBar, SB_SETTEXT, 0, (LPARAM)str);
174 }
175
176 void SetupStatusBar(HWND hWnd, BOOL bResize)
177 {
178 RECT rc;
179 int nParts;
180 GetClientRect(hWnd, &rc);
181 nParts = rc.right;
182 /* nParts = -1;*/
183 if (bResize)
184 SendMessage(hStatusBar, WM_SIZE, 0, 0);
185 SendMessage(hStatusBar, SB_SETPARTS, 1, (LPARAM)&nParts);
186 UpdateStatusBar();
187 }
188
189 void UpdateStatusBar(void)
190 {
191 LPTSTR fullPath = GetItemFullPath(g_pChildWnd->hTreeWnd, NULL, TRUE);
192 SendMessage(hStatusBar, SB_SETTEXT, 0, (LPARAM)fullPath);
193 HeapFree(GetProcessHeap(), 0, fullPath);
194 }
195
196 static void toggle_child(HWND hWnd, UINT cmd, HWND hchild)
197 {
198 BOOL vis = IsWindowVisible(hchild);
199 HMENU hMenuView = GetSubMenu(hMenuFrame, ID_VIEW_MENU);
200
201 CheckMenuItem(hMenuView, cmd, vis?MF_BYCOMMAND:MF_BYCOMMAND|MF_CHECKED);
202 ShowWindow(hchild, vis?SW_HIDE:SW_SHOW);
203 resize_frame_client(hWnd);
204 }
205
206 static BOOL CheckCommDlgError(HWND hWnd)
207 {
208 DWORD dwErrorCode = CommDlgExtendedError();
209 switch (dwErrorCode) {
210 case CDERR_DIALOGFAILURE:
211 break;
212 case CDERR_FINDRESFAILURE:
213 break;
214 case CDERR_NOHINSTANCE:
215 break;
216 case CDERR_INITIALIZATION:
217 break;
218 case CDERR_NOHOOK:
219 break;
220 case CDERR_LOCKRESFAILURE:
221 break;
222 case CDERR_NOTEMPLATE:
223 break;
224 case CDERR_LOADRESFAILURE:
225 break;
226 case CDERR_STRUCTSIZE:
227 break;
228 case CDERR_LOADSTRFAILURE:
229 break;
230 case FNERR_BUFFERTOOSMALL:
231 break;
232 case CDERR_MEMALLOCFAILURE:
233 break;
234 case FNERR_INVALIDFILENAME:
235 break;
236 case CDERR_MEMLOCKFAILURE:
237 break;
238 case FNERR_SUBCLASSFAILURE:
239 break;
240 default:
241 break;
242 }
243 return TRUE;
244 }
245
246 static void ExportRegistryFile_StoreSelection(HWND hdlg, OPENFILENAME *pOpenFileName)
247 {
248 if (IsDlgButtonChecked(hdlg, IDC_EXPORT_SELECTED))
249 {
250 INT len = SendDlgItemMessage(hdlg, IDC_EXPORT_PATH, WM_GETTEXTLENGTH, 0, 0);
251 pOpenFileName->lCustData = (LPARAM)HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(TCHAR));
252 SendDlgItemMessage(hdlg, IDC_EXPORT_PATH, WM_GETTEXT, len+1, pOpenFileName->lCustData);
253 }
254 else
255 pOpenFileName->lCustData = (LPARAM)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TCHAR));
256 }
257
258 static UINT CALLBACK ExportRegistryFile_OFNHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
259 {
260 static OPENFILENAME* pOpenFileName;
261 OFNOTIFY *pOfNotify;
262 LPTSTR path;
263
264 switch (uiMsg) {
265 case WM_INITDIALOG:
266 pOpenFileName = (OPENFILENAME*)lParam;
267 break;
268 case WM_COMMAND:
269 if (LOWORD(wParam) == IDC_EXPORT_PATH && HIWORD(wParam) == EN_UPDATE)
270 CheckRadioButton(hdlg, IDC_EXPORT_ALL, IDC_EXPORT_SELECTED, IDC_EXPORT_SELECTED);
271 break;
272 case WM_NOTIFY:
273 pOfNotify = (OFNOTIFY*)lParam;
274 switch (pOfNotify->hdr.code)
275 {
276 case CDN_INITDONE:
277 path = GetItemFullPath(g_pChildWnd->hTreeWnd, NULL, FALSE);
278 SendDlgItemMessage(hdlg, IDC_EXPORT_PATH, WM_SETTEXT, 0, (LPARAM)path);
279 HeapFree(GetProcessHeap(), 0, path);
280 CheckRadioButton(hdlg, IDC_EXPORT_ALL, IDC_EXPORT_SELECTED, pOpenFileName->lCustData ? IDC_EXPORT_SELECTED : IDC_EXPORT_ALL);
281 break;
282 case CDN_FILEOK:
283 ExportRegistryFile_StoreSelection(hdlg, pOpenFileName);
284 break;
285 }
286 break;
287 default:
288 break;
289 }
290 return 0L;
291 }
292
293
294 static BOOL InitOpenFileName(HWND hWnd, OPENFILENAME *pofn)
295 {
296 memset(pofn, 0, sizeof(OPENFILENAME));
297 pofn->lStructSize = sizeof(OPENFILENAME);
298 pofn->hwndOwner = hWnd;
299 pofn->hInstance = hInst;
300
301 if (FilterBuffer[0] == 0)
302 LoadString(hInst, IDS_FILEDIALOG_FILTER, FilterBuffer, _MAX_PATH);
303 pofn->lpstrFilter = FilterBuffer;
304 pofn->nFilterIndex = 1;
305 pofn->lpstrFile = FileNameBuffer;
306 pofn->nMaxFile = _MAX_PATH;
307 pofn->lpstrFileTitle = FileTitleBuffer;
308 pofn->nMaxFileTitle = _MAX_PATH;
309 pofn->Flags = OFN_HIDEREADONLY;
310 /* some other fields may be set by the caller */
311 return TRUE;
312 }
313
314 static BOOL import_registry_filename(LPTSTR filename)
315 {
316 BOOL Success;
317 FILE* reg_file = fopen(filename, "r");
318
319 if(!reg_file)
320 return FALSE;
321
322 Success = import_registry_file(reg_file);
323
324 if(fclose(reg_file) != 0)
325 Success = FALSE;
326
327 return Success;
328 }
329
330 static BOOL ImportRegistryFile(HWND hWnd)
331 {
332 OPENFILENAME ofn;
333 TCHAR title[128];
334
335 InitOpenFileName(hWnd, &ofn);
336 LoadString(hInst, IDS_FILEDIALOG_IMPORT_TITLE, title, COUNT_OF(title));
337 ofn.lpstrTitle = title;
338 if (GetOpenFileName(&ofn)) {
339 if (!import_registry_filename(ofn.lpstrFile)) {
340 /*printf("Can't open file \"%s\"\n", ofn.lpstrFile);*/
341 return FALSE;
342 }
343 } else {
344 CheckCommDlgError(hWnd);
345 }
346 RefreshTreeView(g_pChildWnd->hTreeWnd);
347 return TRUE;
348 }
349
350
351 static BOOL ExportRegistryFile(HWND hWnd, BOOL export_branch)
352 {
353 OPENFILENAME ofn;
354 TCHAR ExportKeyPath[_MAX_PATH];
355 TCHAR title[128];
356
357 ExportKeyPath[0] = _T('\0');
358 InitOpenFileName(hWnd, &ofn);
359 LoadString(hInst, IDS_FILEDIALOG_EXPORT_TITLE, title, COUNT_OF(title));
360 ofn.lpstrTitle = title;
361 ofn.lCustData = export_branch;
362 ofn.Flags = OFN_ENABLETEMPLATE | OFN_ENABLEHOOK | OFN_EXPLORER | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
363 ofn.lpfnHook = ExportRegistryFile_OFNHookProc;
364 ofn.lpTemplateName = MAKEINTRESOURCE(IDD_EXPORT_TEMPLATE);
365 if (GetSaveFileName(&ofn)) {
366 BOOL result;
367 result = export_registry_key(ofn.lpstrFile, (LPTSTR)ofn.lCustData);
368 if (!result) {
369 /*printf("Can't open file \"%s\"\n", ofn.lpstrFile);*/
370 return FALSE;
371 }
372 } else {
373 CheckCommDlgError(hWnd);
374 }
375 return TRUE;
376 }
377
378 static BOOL PrintRegistryHive(HWND hWnd, LPCWSTR path)
379 {
380 #if 1
381 PRINTDLGW pd;
382
383 ZeroMemory(&pd, sizeof(PRINTDLG));
384 pd.lStructSize = sizeof(PRINTDLG);
385 pd.hwndOwner = hWnd;
386 pd.hDevMode = NULL; /* Don't forget to free or store hDevMode*/
387 pd.hDevNames = NULL; /* Don't forget to free or store hDevNames*/
388 pd.Flags = PD_USEDEVMODECOPIESANDCOLLATE | PD_RETURNDC;
389 pd.nCopies = 1;
390 pd.nFromPage = 0xFFFF;
391 pd.nToPage = 0xFFFF;
392 pd.nMinPage = 1;
393 pd.nMaxPage = 0xFFFF;
394 if (PrintDlgW(&pd)) {
395 /* GDI calls to render output. */
396 DeleteDC(pd.hDC); /* Delete DC when done.*/
397 }
398 #else
399 HRESULT hResult;
400 PRINTDLGEXW pd;
401
402 hResult = PrintDlgExW(&pd);
403 if (hResult == S_OK) {
404 switch (pd.dwResultAction) {
405 case PD_RESULT_APPLY:
406 /*The user clicked the Apply button and later clicked the Cancel button. This indicates that the user wants to apply the changes made in the property sheet, but does not yet want to print. The PRINTDLGEX structure contains the information specified by the user at the time the Apply button was clicked. */
407 break;
408 case PD_RESULT_CANCEL:
409 /*The user clicked the Cancel button. The information in the PRINTDLGEX structure is unchanged. */
410 break;
411 case PD_RESULT_PRINT:
412 /*The user clicked the Print button. The PRINTDLGEX structure contains the information specified by the user. */
413 break;
414 default:
415 break;
416 }
417 } else {
418 switch (hResult) {
419 case E_OUTOFMEMORY:
420 /*Insufficient memory. */
421 break;
422 case E_INVALIDARG:
423 /* One or more arguments are invalid. */
424 break;
425 case E_POINTER:
426 /*Invalid pointer. */
427 break;
428 case E_HANDLE:
429 /*Invalid handle. */
430 break;
431 case E_FAIL:
432 /*Unspecified error. */
433 break;
434 default:
435 break;
436 }
437 return FALSE;
438 }
439 #endif
440 return TRUE;
441 }
442
443 static BOOL CopyKeyName(HWND hWnd, LPCWSTR keyName)
444 {
445 BOOL result;
446
447 result = OpenClipboard(hWnd);
448 if (result) {
449 result = EmptyClipboard();
450 if (result) {
451 int len = (lstrlenW(keyName)+1)*sizeof(WCHAR);
452 HANDLE hClipData = GlobalAlloc(GHND, len);
453 LPVOID pLoc = GlobalLock(hClipData);
454 lstrcpyW(pLoc, keyName);
455 GlobalUnlock(hClipData);
456 hClipData = SetClipboardData(CF_UNICODETEXT, hClipData);
457
458 } else {
459 /* error emptying clipboard*/
460 /* DWORD dwError = GetLastError(); */
461 ;
462 }
463 if (!CloseClipboard()) {
464 /* error closing clipboard*/
465 /* DWORD dwError = GetLastError(); */
466 ;
467 }
468 } else {
469 /* error opening clipboard*/
470 /* DWORD dwError = GetLastError(); */
471 ;
472 }
473 return result;
474 }
475
476 static INT_PTR CALLBACK find_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
477 {
478 HWND hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_NAME);
479
480 switch(uMsg) {
481 case WM_INITDIALOG:
482 EnableWindow(GetDlgItem(hwndDlg, IDOK), FALSE);
483 CheckDlgButton(hwndDlg, IDC_FIND_KEYS, searchMask&SEARCH_KEYS ? BST_CHECKED : BST_UNCHECKED);
484 CheckDlgButton(hwndDlg, IDC_FIND_VALUES, searchMask&SEARCH_VALUES ? BST_CHECKED : BST_UNCHECKED);
485 CheckDlgButton(hwndDlg, IDC_FIND_CONTENT, searchMask&SEARCH_CONTENT ? BST_CHECKED : BST_UNCHECKED);
486 CheckDlgButton(hwndDlg, IDC_FIND_WHOLE, searchMask&SEARCH_WHOLE ? BST_CHECKED : BST_UNCHECKED);
487 SendMessage(hwndValue, EM_SETLIMITTEXT, 127, 0);
488 SetWindowText(hwndValue, searchString);
489 return TRUE;
490 case WM_COMMAND:
491 switch(LOWORD(wParam)) {
492 case IDC_VALUE_NAME:
493 if (HIWORD(wParam) == EN_UPDATE) {
494 EnableWindow(GetDlgItem(hwndDlg, IDOK), GetWindowTextLength(hwndValue)>0);
495 return TRUE;
496 }
497 break;
498 case IDOK:
499 if (GetWindowTextLength(hwndValue)>0) {
500 int mask = 0;
501 if (IsDlgButtonChecked(hwndDlg, IDC_FIND_KEYS)) mask |= SEARCH_KEYS;
502 if (IsDlgButtonChecked(hwndDlg, IDC_FIND_VALUES)) mask |= SEARCH_VALUES;
503 if (IsDlgButtonChecked(hwndDlg, IDC_FIND_CONTENT)) mask |= SEARCH_CONTENT;
504 if (IsDlgButtonChecked(hwndDlg, IDC_FIND_WHOLE)) mask |= SEARCH_WHOLE;
505 searchMask = mask;
506 GetWindowText(hwndValue, searchString, 128);
507 EndDialog(hwndDlg, IDOK);
508 }
509 return TRUE;
510 case IDCANCEL:
511 EndDialog(hwndDlg, IDCANCEL);
512 return TRUE;
513 }
514 break;
515 }
516 return FALSE;
517 }
518
519 static INT_PTR CALLBACK addtofavorites_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
520 {
521 HWND hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_NAME);
522
523 switch(uMsg) {
524 case WM_INITDIALOG:
525 {
526 HKEY hKeyRoot = NULL;
527 LPSTR ItemPath = GetItemPath(g_pChildWnd->hTreeWnd, NULL, &hKeyRoot);
528
529 if(!ItemPath || !*ItemPath)
530 ItemPath = GetItemFullPath(g_pChildWnd->hTreeWnd, NULL, FALSE);
531 EnableWindow(GetDlgItem(hwndDlg, IDOK), FALSE);
532 SetWindowText(hwndValue, ItemPath);
533 SendMessage(hwndValue, EM_SETLIMITTEXT, 127, 0);
534 return TRUE;
535 }
536 case WM_COMMAND:
537 switch(LOWORD(wParam)) {
538 case IDC_VALUE_NAME:
539 if (HIWORD(wParam) == EN_UPDATE) {
540 EnableWindow(GetDlgItem(hwndDlg, IDOK), GetWindowTextLength(hwndValue)>0);
541 return TRUE;
542 }
543 break;
544 case IDOK:
545 if (GetWindowTextLength(hwndValue)>0) {
546 GetWindowText(hwndValue, favoriteName, 128);
547 EndDialog(hwndDlg, IDOK);
548 }
549 return TRUE;
550 case IDCANCEL:
551 EndDialog(hwndDlg, IDCANCEL);
552 return TRUE;
553 }
554 break;
555 }
556 return FALSE;
557 }
558
559 static INT_PTR CALLBACK removefavorite_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
560 {
561 HWND hwndList = GetDlgItem(hwndDlg, IDC_NAME_LIST);
562
563 switch(uMsg) {
564 case WM_INITDIALOG: {
565 HKEY hKey;
566 int i = 0;
567 EnableWindow(GetDlgItem(hwndDlg, IDOK), FALSE);
568 if (RegOpenKeyEx(HKEY_CURRENT_USER, favoritesKey,
569 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
570 TCHAR namebuf[KEY_MAX_LEN];
571 BYTE valuebuf[4096];
572 DWORD ksize, vsize, type;
573 LONG error;
574 do {
575 ksize = KEY_MAX_LEN;
576 vsize = sizeof(valuebuf);
577 error = RegEnumValue(hKey, i, namebuf, &ksize, NULL, &type, valuebuf, &vsize);
578 if (error != ERROR_SUCCESS)
579 break;
580 if (type == REG_SZ) {
581 SendMessage(hwndList, LB_ADDSTRING, 0, (LPARAM)namebuf);
582 }
583 i++;
584 } while(error == ERROR_SUCCESS);
585 RegCloseKey(hKey);
586 }
587 else
588 return FALSE;
589 EnableWindow(GetDlgItem(hwndDlg, IDOK), i != 0);
590 SendMessage(hwndList, LB_SETCURSEL, 0, 0);
591 return TRUE;
592 }
593 case WM_COMMAND:
594 switch(LOWORD(wParam)) {
595 case IDC_NAME_LIST:
596 if (HIWORD(wParam) == LBN_SELCHANGE) {
597 EnableWindow(GetDlgItem(hwndDlg, IDOK), lParam != -1);
598 return TRUE;
599 }
600 break;
601 case IDOK: {
602 int pos = SendMessage(hwndList, LB_GETCURSEL, 0, 0);
603 int len = SendMessage(hwndList, LB_GETTEXTLEN, pos, 0);
604 if (len>0) {
605 LPTSTR lpName = HeapAlloc(GetProcessHeap(), 0, sizeof(TCHAR)*(len+1));
606 SendMessage(hwndList, LB_GETTEXT, pos, (LPARAM)lpName);
607 if (len>127)
608 lpName[127] = '\0';
609 _tcscpy(favoriteName, lpName);
610 EndDialog(hwndDlg, IDOK);
611 HeapFree(GetProcessHeap(), 0, lpName);
612 }
613 return TRUE;
614 }
615 case IDCANCEL:
616 EndDialog(hwndDlg, IDCANCEL);
617 return TRUE;
618 }
619 break;
620 }
621 return FALSE;
622 }
623
624 /*******************************************************************************
625 *
626 * FUNCTION: _CmdWndProc(HWND, unsigned, WORD, LONG)
627 *
628 * PURPOSE: Processes WM_COMMAND messages for the main frame window.
629 *
630 */
631 static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
632 {
633 HKEY hKeyRoot = 0;
634 LPCTSTR keyPath;
635 LPCTSTR valueName;
636 TCHAR newKey[MAX_NEW_KEY_LEN];
637 DWORD valueType;
638 int curIndex;
639 BOOL firstItem = TRUE;
640
641 keyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
642
643 if (LOWORD(wParam) >= ID_FAVORITE_FIRST && LOWORD(wParam) <= ID_FAVORITE_LAST) {
644 HKEY hKey;
645 if (RegOpenKeyEx(HKEY_CURRENT_USER, favoritesKey,
646 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
647 TCHAR namebuf[KEY_MAX_LEN];
648 BYTE valuebuf[4096];
649 DWORD ksize = KEY_MAX_LEN, vsize = sizeof(valuebuf), type = 0;
650 if (RegEnumValue(hKey, LOWORD(wParam) - ID_FAVORITE_FIRST, namebuf, &ksize, NULL,
651 &type, valuebuf, &vsize) == ERROR_SUCCESS) {
652 SendMessage( g_pChildWnd->hTreeWnd, TVM_SELECTITEM, TVGN_CARET,
653 (LPARAM) FindPathInTree(g_pChildWnd->hTreeWnd, (TCHAR *)valuebuf) );
654 }
655 RegCloseKey(hKey);
656 }
657 return TRUE;
658 }
659 switch (LOWORD(wParam)) {
660 case ID_REGISTRY_IMPORTREGISTRYFILE:
661 ImportRegistryFile(hWnd);
662 break;
663 case ID_EDIT_EXPORT:
664 ExportRegistryFile(hWnd, TRUE);
665 break;
666 case ID_REGISTRY_EXPORTREGISTRYFILE:
667 ExportRegistryFile(hWnd, FALSE);
668 break;
669 case ID_REGISTRY_CONNECTNETWORKREGISTRY:
670 break;
671 case ID_REGISTRY_DISCONNECTNETWORKREGISTRY:
672 break;
673 case ID_REGISTRY_PRINT:
674 {
675 const WCHAR empty = 0;
676 PrintRegistryHive(hWnd, &empty);
677 break;
678 }
679 case ID_EDIT_DELETE:
680 if (GetFocus() == g_pChildWnd->hTreeWnd) {
681 WCHAR* keyPathW = GetWideString(keyPath);
682 if (keyPath == 0 || *keyPath == 0) {
683 MessageBeep(MB_ICONHAND);
684 } else if (DeleteKey(hWnd, hKeyRoot, keyPathW)) {
685 DeleteNode(g_pChildWnd->hTreeWnd, 0);
686 }
687 HeapFree(GetProcessHeap(), 0, keyPathW);
688 } else if (GetFocus() == g_pChildWnd->hListWnd) {
689 curIndex = ListView_GetNextItem(g_pChildWnd->hListWnd, -1, LVNI_SELECTED);
690 while(curIndex != -1) {
691 WCHAR* valueNameW;
692 WCHAR* keyPathW;
693
694 valueName = GetItemText(g_pChildWnd->hListWnd, curIndex);
695 curIndex = ListView_GetNextItem(g_pChildWnd->hListWnd, curIndex, LVNI_SELECTED);
696 if(curIndex != -1 && firstItem) {
697 if (MessageBoxW(hWnd, MAKEINTRESOURCEW(IDS_DELETE_BOX_TEXT_MULTIPLE),
698 MAKEINTRESOURCEW(IDS_DELETE_BOX_TITLE),
699 MB_YESNO | MB_ICONEXCLAMATION) != IDYES)
700 break;
701 }
702 valueNameW = GetWideString(valueName);
703 keyPathW = GetWideString(keyPath);
704 if (!DeleteValue(hWnd, hKeyRoot, keyPathW, valueNameW, curIndex==-1 && firstItem))
705 {
706 HeapFree(GetProcessHeap(), 0, valueNameW);
707 HeapFree(GetProcessHeap(), 0, keyPathW);
708 break;
709 }
710 firstItem = FALSE;
711 HeapFree(GetProcessHeap(), 0, valueNameW);
712 HeapFree(GetProcessHeap(), 0, keyPathW);
713 }
714 RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath, NULL);
715 }
716 break;
717 case ID_EDIT_MODIFY:
718 valueName = GetValueName(g_pChildWnd->hListWnd);
719 if (ModifyValue(hWnd, hKeyRoot, keyPath, valueName))
720 RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath, valueName);
721 break;
722 case ID_EDIT_FIND:
723 case ID_EDIT_FINDNEXT:
724 {
725 HTREEITEM hItem;
726 if (LOWORD(wParam) == ID_EDIT_FIND &&
727 DialogBox(0, MAKEINTRESOURCE(IDD_FIND), hWnd, find_dlgproc) != IDOK)
728 break;
729 if (!*searchString)
730 break;
731 hItem = TreeView_GetSelection(g_pChildWnd->hTreeWnd);
732 if (hItem) {
733 int row = ListView_GetNextItem(g_pChildWnd->hListWnd, -1, LVNI_FOCUSED);
734 HCURSOR hcursorOld = SetCursor(LoadCursor(NULL, IDC_WAIT));
735 hItem = FindNext(g_pChildWnd->hTreeWnd, hItem, searchString, searchMask, &row);
736 SetCursor(hcursorOld);
737 if (hItem) {
738 SendMessage( g_pChildWnd->hTreeWnd, TVM_SELECTITEM, TVGN_CARET, (LPARAM) hItem );
739 InvalidateRect(g_pChildWnd->hTreeWnd, NULL, TRUE);
740 UpdateWindow(g_pChildWnd->hTreeWnd);
741 if (row != -1) {
742 ListView_SetItemState(g_pChildWnd->hListWnd, -1, 0, LVIS_FOCUSED|LVIS_SELECTED);
743 ListView_SetItemState(g_pChildWnd->hListWnd, row, LVIS_FOCUSED|LVIS_SELECTED, LVIS_FOCUSED|LVIS_SELECTED);
744 SetFocus(g_pChildWnd->hListWnd);
745 } else {
746 SetFocus(g_pChildWnd->hTreeWnd);
747 }
748 } else {
749 error(hWnd, IDS_NOTFOUND, searchString);
750 }
751 }
752 break;
753 }
754 case ID_EDIT_COPYKEYNAME:
755 {
756 LPWSTR fullPath = GetItemFullPathW(g_pChildWnd->hTreeWnd, NULL, FALSE);
757 if (fullPath) {
758 CopyKeyName(hWnd, fullPath);
759 HeapFree(GetProcessHeap(), 0, fullPath);
760 }
761 break;
762 }
763 case ID_EDIT_NEW_KEY:
764 if (CreateKey(hWnd, hKeyRoot, keyPath, newKey)) {
765 if (InsertNode(g_pChildWnd->hTreeWnd, 0, newKey))
766 StartKeyRename(g_pChildWnd->hTreeWnd);
767 }
768 break;
769 case ID_EDIT_NEW_STRINGVALUE:
770 valueType = REG_SZ;
771 goto create_value;
772 case ID_EDIT_NEW_MULTI_STRINGVALUE:
773 valueType = REG_MULTI_SZ;
774 goto create_value;
775 case ID_EDIT_NEW_BINARYVALUE:
776 valueType = REG_BINARY;
777 goto create_value;
778 case ID_EDIT_NEW_DWORDVALUE:
779 valueType = REG_DWORD;
780 /* fall through */
781 create_value:
782 if (CreateValue(hWnd, hKeyRoot, keyPath, valueType, newKey)) {
783 RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath, newKey);
784 StartValueRename(g_pChildWnd->hListWnd);
785 /* FIXME: start rename */
786 }
787 break;
788 case ID_EDIT_RENAME:
789 if (keyPath == 0 || *keyPath == 0) {
790 MessageBeep(MB_ICONHAND);
791 } else if (GetFocus() == g_pChildWnd->hTreeWnd) {
792 StartKeyRename(g_pChildWnd->hTreeWnd);
793 } else if (GetFocus() == g_pChildWnd->hListWnd) {
794 StartValueRename(g_pChildWnd->hListWnd);
795 }
796 break;
797 case ID_REGISTRY_PRINTERSETUP:
798 /*PRINTDLG pd;*/
799 /*PrintDlg(&pd);*/
800 /*PAGESETUPDLG psd;*/
801 /*PageSetupDlg(&psd);*/
802 break;
803 case ID_REGISTRY_OPENLOCAL:
804 break;
805 case ID_REGISTRY_EXIT:
806 DestroyWindow(hWnd);
807 break;
808 case ID_FAVORITES_ADDTOFAVORITES:
809 {
810 HKEY hKey;
811 LPTSTR lpKeyPath = GetItemFullPath(g_pChildWnd->hTreeWnd, NULL, FALSE);
812 if (lpKeyPath) {
813 if (DialogBox(0, MAKEINTRESOURCE(IDD_ADDFAVORITE), hWnd, addtofavorites_dlgproc) == IDOK) {
814 if (RegCreateKeyEx(HKEY_CURRENT_USER, favoritesKey,
815 0, NULL, 0,
816 KEY_READ|KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
817 RegSetValueEx(hKey, favoriteName, 0, REG_SZ, (BYTE *)lpKeyPath, (_tcslen(lpKeyPath)+1)*sizeof(TCHAR));
818 RegCloseKey(hKey);
819 }
820 }
821 HeapFree(GetProcessHeap(), 0, lpKeyPath);
822 }
823 break;
824 }
825 case ID_FAVORITES_REMOVEFAVORITE:
826 {
827 if (DialogBox(0, MAKEINTRESOURCE(IDD_DELFAVORITE), hWnd, removefavorite_dlgproc) == IDOK) {
828 HKEY hKey;
829 if (RegOpenKeyEx(HKEY_CURRENT_USER, favoritesKey,
830 0, KEY_READ|KEY_WRITE, &hKey) == ERROR_SUCCESS) {
831 RegDeleteValue(hKey, favoriteName);
832 RegCloseKey(hKey);
833 }
834 }
835 break;
836 }
837 case ID_VIEW_REFRESH:
838 RefreshTreeView(g_pChildWnd->hTreeWnd);
839 RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath, NULL);
840 break;
841 /*case ID_OPTIONS_TOOLBAR:*/
842 /* toggle_child(hWnd, LOWORD(wParam), hToolBar);*/
843 /* break;*/
844 case ID_VIEW_STATUSBAR:
845 toggle_child(hWnd, LOWORD(wParam), hStatusBar);
846 break;
847 case ID_HELP_HELPTOPICS:
848 {
849 const WCHAR help_regedit[] = {'r','e','g','e','d','i','t',0};
850 WinHelpW(hWnd, help_regedit, HELP_FINDER, 0);
851 break;
852 }
853 case ID_HELP_ABOUT:
854 ShowAboutBox(hWnd);
855 break;
856 case ID_VIEW_SPLIT: {
857 RECT rt;
858 POINT pt, pts;
859 GetClientRect(g_pChildWnd->hWnd, &rt);
860 pt.x = rt.left + g_pChildWnd->nSplitPos;
861 pt.y = (rt.bottom / 2);
862 pts = pt;
863 if(ClientToScreen(g_pChildWnd->hWnd, &pts)) {
864 SetCursorPos(pts.x, pts.y);
865 SetCursor(LoadCursor(0, IDC_SIZEWE));
866 SendMessage(g_pChildWnd->hWnd, WM_LBUTTONDOWN, 0, MAKELPARAM(pt.x, pt.y));
867 }
868 return TRUE;
869 }
870 default:
871 return FALSE;
872 }
873
874 return TRUE;
875 }
876
877 /********************************************************************************
878 *
879 * FUNCTION: FrameWndProc(HWND, unsigned, WORD, LONG)
880 *
881 * PURPOSE: Processes messages for the main frame window.
882 *
883 * WM_COMMAND - process the application menu
884 * WM_DESTROY - post a quit message and return
885 *
886 */
887
888 LRESULT CALLBACK FrameWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
889 {
890 switch (message) {
891 case WM_CREATE:
892 CreateWindowEx(0, szChildClass, _T("regedit child window"), WS_CHILD | WS_VISIBLE,
893 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
894 hWnd, NULL, hInst, 0);
895 break;
896 case WM_COMMAND:
897 if (!_CmdWndProc(hWnd, message, wParam, lParam))
898 return DefWindowProc(hWnd, message, wParam, lParam);
899 break;
900 case WM_ACTIVATE:
901 if (LOWORD(hWnd))
902 SetFocus(g_pChildWnd->hWnd);
903 break;
904 case WM_SIZE:
905 resize_frame_client(hWnd);
906 break;
907 case WM_TIMER:
908 break;
909 case WM_ENTERMENULOOP:
910 OnEnterMenuLoop(hWnd);
911 break;
912 case WM_EXITMENULOOP:
913 OnExitMenuLoop(hWnd);
914 break;
915 case WM_INITMENUPOPUP:
916 if (!HIWORD(lParam))
917 OnInitMenuPopup(hWnd, (HMENU)wParam, LOWORD(lParam));
918 break;
919 case WM_MENUSELECT:
920 OnMenuSelect(hWnd, LOWORD(wParam), HIWORD(wParam), (HMENU)lParam);
921 break;
922 case WM_DESTROY:
923 {
924 const WCHAR help_regedit[] = {'r','e','g','e','d','i','t',0};
925 WinHelpW(hWnd, help_regedit, HELP_QUIT, 0);
926 PostQuitMessage(0);
927 }
928 default:
929 return DefWindowProc(hWnd, message, wParam, lParam);
930 }
931 return 0;
932 }
Maarten's multimedia branch