19b8a8e4bfb18a8ad66d7f5db8a665be7fe09d7c
[reactos.git] / reactos / base / applications / regedit / framewnd.c
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 Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <regedit.h>
22
23 /********************************************************************************
24 * Global and Local Variables:
25 */
26
27 #define FAVORITES_MENU_POSITION 3
28
29 static WCHAR s_szFavoritesRegKey[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Applets\\Regedit\\Favorites";
30
31 static BOOL bInMenuLoop = FALSE; /* Tells us if we are in the menu loop */
32
33 /*******************************************************************************
34 * Local module support methods
35 */
36
37 static void resize_frame_rect(HWND hWnd, PRECT prect)
38 {
39 RECT rt;
40 /*
41 if (IsWindowVisible(hToolBar)) {
42 SendMessageW(hToolBar, WM_SIZE, 0, 0);
43 GetClientRect(hToolBar, &rt);
44 prect->top = rt.bottom+3;
45 prect->bottom -= rt.bottom+3;
46 }
47 */
48 if (IsWindowVisible(hStatusBar))
49 {
50 SetupStatusBar(hWnd, TRUE);
51 GetClientRect(hStatusBar, &rt);
52 prect->bottom -= rt.bottom;
53 }
54 MoveWindow(g_pChildWnd->hWnd, prect->left, prect->top, prect->right, prect->bottom, TRUE);
55 }
56
57 static void resize_frame_client(HWND hWnd)
58 {
59 RECT rect;
60
61 GetClientRect(hWnd, &rect);
62 resize_frame_rect(hWnd, &rect);
63 }
64
65 /********************************************************************************/
66
67 static void OnInitMenu(HWND hWnd)
68 {
69 LONG lResult;
70 HKEY hKey = NULL;
71 DWORD dwIndex, cbValueName, cbValueData, dwType;
72 WCHAR szValueName[256];
73 BYTE abValueData[256];
74 static int s_nFavoriteMenuSubPos = -1;
75 HMENU hMenu;
76 BOOL bDisplayedAny = FALSE;
77
78 /* Find Favorites menu and clear it out */
79 hMenu = GetSubMenu(GetMenu(hWnd), FAVORITES_MENU_POSITION);
80 if (!hMenu)
81 goto done;
82 if (s_nFavoriteMenuSubPos < 0)
83 {
84 s_nFavoriteMenuSubPos = GetMenuItemCount(hMenu);
85 }
86 else
87 {
88 while(RemoveMenu(hMenu, s_nFavoriteMenuSubPos, MF_BYPOSITION)) ;
89 }
90
91 lResult = RegOpenKeyW(HKEY_CURRENT_USER, s_szFavoritesRegKey, &hKey);
92 if (lResult != ERROR_SUCCESS)
93 goto done;
94
95 dwIndex = 0;
96 do
97 {
98 cbValueName = COUNT_OF(szValueName);
99 cbValueData = sizeof(abValueData);
100 lResult = RegEnumValueW(hKey, dwIndex, szValueName, &cbValueName, NULL, &dwType, abValueData, &cbValueData);
101 if ((lResult == ERROR_SUCCESS) && (dwType == REG_SZ))
102 {
103 if (!bDisplayedAny)
104 {
105 AppendMenu(hMenu, MF_SEPARATOR, 0, NULL);
106 bDisplayedAny = TRUE;
107 }
108 AppendMenu(hMenu, 0, ID_FAVORITES_MIN + GetMenuItemCount(hMenu), szValueName);
109 }
110 dwIndex++;
111 }
112 while(lResult == ERROR_SUCCESS);
113
114 done:
115 if (hKey)
116 RegCloseKey(hKey);
117 }
118
119 static void OnEnterMenuLoop(HWND hWnd)
120 {
121 int nParts;
122 UNREFERENCED_PARAMETER(hWnd);
123
124 /* Update the status bar pane sizes */
125 nParts = -1;
126 SendMessageW(hStatusBar, SB_SETPARTS, 1, (LPARAM)&nParts);
127 bInMenuLoop = TRUE;
128 SendMessageW(hStatusBar, SB_SETTEXTW, (WPARAM)0, (LPARAM)L"");
129 }
130
131 static void OnExitMenuLoop(HWND hWnd)
132 {
133 bInMenuLoop = FALSE;
134 /* Update the status bar pane sizes*/
135 SetupStatusBar(hWnd, TRUE);
136 UpdateStatusBar();
137 }
138
139 static void OnMenuSelect(HWND hWnd, UINT nItemID, UINT nFlags, HMENU hSysMenu)
140 {
141 WCHAR str[100];
142
143 wcscpy(str, L"");
144 if (nFlags & MF_POPUP)
145 {
146 if (hSysMenu != GetMenu(hWnd))
147 {
148 if (nItemID == 2) nItemID = 5;
149 }
150 }
151 if (LoadStringW(hInst, nItemID, str, 100))
152 {
153 /* load appropriate string*/
154 LPWSTR lpsz = str;
155 /* first newline terminates actual string*/
156 lpsz = wcschr(lpsz, L'\n');
157 if (lpsz != NULL)
158 *lpsz = L'\0';
159 }
160 SendMessageW(hStatusBar, SB_SETTEXTW, 0, (LPARAM)str);
161 }
162
163 void SetupStatusBar(HWND hWnd, BOOL bResize)
164 {
165 RECT rc;
166 int nParts;
167 GetClientRect(hWnd, &rc);
168 nParts = rc.right;
169 /* nParts = -1;*/
170 if (bResize)
171 SendMessageW(hStatusBar, WM_SIZE, 0, 0);
172 SendMessageW(hStatusBar, SB_SETPARTS, 1, (LPARAM)&nParts);
173 }
174
175 void UpdateStatusBar(void)
176 {
177 NMHDR nmhdr;
178 ZeroMemory(&nmhdr, sizeof(NMHDR));
179 nmhdr.code = TVN_SELCHANGED;
180 SendMessageW(g_pChildWnd->hWnd, WM_NOTIFY, (WPARAM)TREE_WINDOW, (LPARAM)&nmhdr);
181 }
182
183 static void toggle_child(HWND hWnd, UINT cmd, HWND hchild)
184 {
185 BOOL vis = IsWindowVisible(hchild);
186 HMENU hMenuView = GetSubMenu(hMenuFrame, ID_VIEW_MENU);
187
188 CheckMenuItem(hMenuView, cmd, vis?MF_BYCOMMAND:MF_BYCOMMAND|MF_CHECKED);
189 ShowWindow(hchild, vis?SW_HIDE:SW_SHOW);
190 resize_frame_client(hWnd);
191 }
192
193 static BOOL CheckCommDlgError(HWND hWnd)
194 {
195 DWORD dwErrorCode = CommDlgExtendedError();
196 UNREFERENCED_PARAMETER(hWnd);
197 switch (dwErrorCode)
198 {
199 case CDERR_DIALOGFAILURE:
200 break;
201 case CDERR_FINDRESFAILURE:
202 break;
203 case CDERR_NOHINSTANCE:
204 break;
205 case CDERR_INITIALIZATION:
206 break;
207 case CDERR_NOHOOK:
208 break;
209 case CDERR_LOCKRESFAILURE:
210 break;
211 case CDERR_NOTEMPLATE:
212 break;
213 case CDERR_LOADRESFAILURE:
214 break;
215 case CDERR_STRUCTSIZE:
216 break;
217 case CDERR_LOADSTRFAILURE:
218 break;
219 case FNERR_BUFFERTOOSMALL:
220 break;
221 case CDERR_MEMALLOCFAILURE:
222 break;
223 case FNERR_INVALIDFILENAME:
224 break;
225 case CDERR_MEMLOCKFAILURE:
226 break;
227 case FNERR_SUBCLASSFAILURE:
228 break;
229 default:
230 break;
231 }
232 return TRUE;
233 }
234
235 WCHAR FileNameBuffer[_MAX_PATH];
236 WCHAR FileTitleBuffer[_MAX_PATH];
237
238 typedef struct
239 {
240 UINT DisplayID;
241 UINT FilterID;
242 } FILTERPAIR, *PFILTERPAIR;
243
244 void
245 BuildFilterStrings(WCHAR *Filter, PFILTERPAIR Pairs, int PairCount)
246 {
247 int i, c;
248
249 c = 0;
250 for(i = 0; i < PairCount; i++)
251 {
252 c += LoadStringW(hInst, Pairs[i].DisplayID, &Filter[c], 255 * sizeof(WCHAR));
253 Filter[++c] = L'\0';
254 c += LoadStringW(hInst, Pairs[i].FilterID, &Filter[c], 255 * sizeof(WCHAR));
255 Filter[++c] = L'\0';
256 }
257 Filter[++c] = L'\0';
258 }
259
260 static BOOL InitOpenFileName(HWND hWnd, OPENFILENAME* pofn)
261 {
262 FILTERPAIR FilterPairs[4];
263 static WCHAR Filter[1024];
264
265 memset(pofn, 0, sizeof(OPENFILENAME));
266 pofn->lStructSize = sizeof(OPENFILENAME);
267 pofn->hwndOwner = hWnd;
268 pofn->hInstance = hInst;
269
270 /* create filter string */
271 FilterPairs[0].DisplayID = IDS_FLT_REGFILES;
272 FilterPairs[0].FilterID = IDS_FLT_REGFILES_FLT;
273 FilterPairs[1].DisplayID = IDS_FLT_HIVFILES;
274 FilterPairs[1].FilterID = IDS_FLT_HIVFILES_FLT;
275 FilterPairs[2].DisplayID = IDS_FLT_REGEDIT4;
276 FilterPairs[2].FilterID = IDS_FLT_REGEDIT4_FLT;
277 FilterPairs[3].DisplayID = IDS_FLT_ALLFILES;
278 FilterPairs[3].FilterID = IDS_FLT_ALLFILES_FLT;
279 BuildFilterStrings(Filter, FilterPairs, COUNT_OF(FilterPairs));
280
281 pofn->lpstrFilter = Filter;
282 pofn->lpstrFile = FileNameBuffer;
283 pofn->nMaxFile = _MAX_PATH;
284 pofn->lpstrFileTitle = FileTitleBuffer;
285 pofn->nMaxFileTitle = _MAX_PATH;
286 pofn->Flags = OFN_HIDEREADONLY;
287 pofn->lpstrDefExt = L"reg";
288 return TRUE;
289 }
290
291 #define LOADHIVE_KEYNAMELENGTH 128
292
293 static INT_PTR CALLBACK LoadHive_KeyNameInHookProc(HWND hWndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
294 {
295 static LPWSTR sKey = NULL;
296 switch(uMsg)
297 {
298 case WM_INITDIALOG:
299 sKey = (LPWSTR)lParam;
300 break;
301 case WM_COMMAND:
302 switch(LOWORD(wParam))
303 {
304 case IDOK:
305 if(GetDlgItemTextW(hWndDlg, IDC_EDIT_KEY, sKey, LOADHIVE_KEYNAMELENGTH))
306 return EndDialog(hWndDlg, -1);
307 else
308 return EndDialog(hWndDlg, 0);
309 case IDCANCEL:
310 return EndDialog(hWndDlg, 0);
311 }
312 break;
313 }
314 return FALSE;
315 }
316
317 static BOOL EnablePrivilege(LPCWSTR lpszPrivilegeName, LPCWSTR lpszSystemName, BOOL bEnablePrivilege)
318 {
319 BOOL bRet = FALSE;
320 HANDLE hToken = NULL;
321
322 if (OpenProcessToken(GetCurrentProcess(),
323 TOKEN_ADJUST_PRIVILEGES,
324 &hToken))
325 {
326 TOKEN_PRIVILEGES tp;
327
328 tp.PrivilegeCount = 1;
329 tp.Privileges[0].Attributes = (bEnablePrivilege ? SE_PRIVILEGE_ENABLED : 0);
330
331 if (LookupPrivilegeValueW(lpszSystemName,
332 lpszPrivilegeName,
333 &tp.Privileges[0].Luid))
334 {
335 bRet = AdjustTokenPrivileges(hToken, FALSE, &tp, 0, NULL, NULL);
336
337 if (GetLastError() == ERROR_NOT_ALL_ASSIGNED)
338 bRet = FALSE;
339 }
340
341 CloseHandle(hToken);
342 }
343
344 return bRet;
345 }
346
347 static BOOL LoadHive(HWND hWnd)
348 {
349 OPENFILENAME ofn;
350 WCHAR Caption[128];
351 LPCWSTR pszKeyPath;
352 WCHAR xPath[LOADHIVE_KEYNAMELENGTH];
353 HKEY hRootKey;
354 WCHAR Filter[1024];
355 FILTERPAIR filter;
356 /* get the item key to load the hive in */
357 pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
358 /* initialize the "open file" dialog */
359 InitOpenFileName(hWnd, &ofn);
360 /* build the "All Files" filter up */
361 filter.DisplayID = IDS_FLT_ALLFILES;
362 filter.FilterID = IDS_FLT_ALLFILES_FLT;
363 BuildFilterStrings(Filter, &filter, sizeof(filter));
364 ofn.lpstrFilter = Filter;
365 /* load and set the caption and flags for dialog */
366 LoadStringW(hInst, IDS_LOAD_HIVE, Caption, COUNT_OF(Caption));
367 ofn.lpstrTitle = Caption;
368 ofn.Flags |= OFN_ENABLESIZING;
369 /* ofn.lCustData = ;*/
370 /* now load the hive */
371 if (GetOpenFileName(&ofn))
372 {
373 if (DialogBoxParamW(hInst, MAKEINTRESOURCEW(IDD_LOADHIVE), hWnd,
374 &LoadHive_KeyNameInHookProc, (LPARAM)xPath))
375 {
376 LONG regLoadResult;
377
378 /* Enable the 'restore' privilege, load the hive, disable the privilege */
379 EnablePrivilege(SE_RESTORE_NAME, NULL, TRUE);
380 regLoadResult = RegLoadKeyW(hRootKey, xPath, ofn.lpstrFile);
381 EnablePrivilege(SE_RESTORE_NAME, NULL, FALSE);
382
383 if(regLoadResult == ERROR_SUCCESS)
384 {
385 /* refresh tree and list views */
386 RefreshTreeView(g_pChildWnd->hTreeWnd);
387 pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
388 RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);
389 }
390 else
391 {
392 ErrorMessageBox(hWnd, Caption, regLoadResult);
393 return FALSE;
394 }
395 }
396 }
397 else
398 {
399 CheckCommDlgError(hWnd);
400 }
401 return TRUE;
402 }
403
404 static BOOL UnloadHive(HWND hWnd)
405 {
406 WCHAR Caption[128];
407 LPCWSTR pszKeyPath;
408 HKEY hRootKey;
409 LONG regUnloadResult;
410
411 /* get the item key to unload */
412 pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
413 /* load and set the caption and flags for dialog */
414 LoadStringW(hInst, IDS_UNLOAD_HIVE, Caption, COUNT_OF(Caption));
415
416 /* Enable the 'restore' privilege, unload the hive, disable the privilege */
417 EnablePrivilege(SE_RESTORE_NAME, NULL, TRUE);
418 regUnloadResult = RegUnLoadKeyW(hRootKey, pszKeyPath);
419 EnablePrivilege(SE_RESTORE_NAME, NULL, FALSE);
420
421 if(regUnloadResult == ERROR_SUCCESS)
422 {
423 /* refresh tree and list views */
424 RefreshTreeView(g_pChildWnd->hTreeWnd);
425 pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
426 RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);
427 }
428 else
429 {
430 ErrorMessageBox(hWnd, Caption, regUnloadResult);
431 return FALSE;
432 }
433 return TRUE;
434 }
435
436 static BOOL ImportRegistryFile(HWND hWnd)
437 {
438 BOOL bRet = FALSE;
439 OPENFILENAME ofn;
440 WCHAR Caption[128], szTitle[512], szText[512];
441 HKEY hKeyRoot;
442 LPCWSTR pszKeyPath;
443
444 /* Figure out in which key path we are importing */
445 pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
446
447 InitOpenFileName(hWnd, &ofn);
448 LoadStringW(hInst, IDS_IMPORT_REG_FILE, Caption, COUNT_OF(Caption));
449 ofn.lpstrTitle = Caption;
450 ofn.Flags |= OFN_ENABLESIZING;
451 /* ofn.lCustData = ;*/
452 if (GetOpenFileName(&ofn))
453 {
454 /* Look at the extension of the file to determine its type */
455 if (ofn.nFileExtension >= 1 &&
456 wcsicmp(ofn.lpstrFile + ofn.nFileExtension, L"reg") == 0) /* REGEDIT4 or Windows Registry Editor Version 5.00 */
457 {
458 /* Open the file */
459 FILE* fp = _wfopen(ofn.lpstrFile, L"r");
460
461 /* Import it */
462 if (fp == NULL || !import_registry_file(fp))
463 {
464 /* Error opening the file */
465 LoadStringW(hInst, IDS_APP_TITLE, szTitle, COUNT_OF(szTitle));
466 LoadStringW(hInst, IDS_IMPORT_ERROR, szText, COUNT_OF(szText));
467 InfoMessageBox(hWnd, MB_OK | MB_ICONERROR, szTitle, szText, ofn.lpstrFile);
468 bRet = FALSE;
469 }
470 else
471 {
472 /* Show successful import */
473 LoadStringW(hInst, IDS_APP_TITLE, szTitle, COUNT_OF(szTitle));
474 LoadStringW(hInst, IDS_IMPORT_OK, szText, COUNT_OF(szText));
475 InfoMessageBox(hWnd, MB_OK | MB_ICONINFORMATION, szTitle, szText, ofn.lpstrFile);
476 bRet = TRUE;
477 }
478
479 /* Close the file */
480 if (fp) fclose(fp);
481 }
482 else /* Registry Hive Files */
483 {
484 LoadStringW(hInst, IDS_QUERY_IMPORT_HIVE_CAPTION, szTitle, COUNT_OF(szTitle));
485 LoadStringW(hInst, IDS_QUERY_IMPORT_HIVE_MSG, szText, COUNT_OF(szText));
486
487 /* Display a confirmation message */
488 if (MessageBoxW(g_pChildWnd->hWnd, szText, szTitle, MB_ICONWARNING | MB_YESNO) == IDYES)
489 {
490 LONG lResult;
491 HKEY hSubKey;
492
493 /* Open the subkey */
494 lResult = RegOpenKeyExW(hKeyRoot, pszKeyPath, 0, KEY_WRITE, &hSubKey);
495 if (lResult == ERROR_SUCCESS)
496 {
497 /* Enable the 'restore' privilege, restore the hive then disable the privilege */
498 EnablePrivilege(SE_RESTORE_NAME, NULL, TRUE);
499 lResult = RegRestoreKey(hSubKey, ofn.lpstrFile, REG_FORCE_RESTORE);
500 EnablePrivilege(SE_RESTORE_NAME, NULL, FALSE);
501
502 /* Flush the subkey and close it */
503 RegFlushKey(hSubKey);
504 RegCloseKey(hSubKey);
505 }
506
507 /* Set the return value */
508 bRet = (lResult == ERROR_SUCCESS);
509
510 /* Display error, if any */
511 if (!bRet) ErrorMessageBox(hWnd, Caption, lResult);
512 }
513 }
514 }
515 else
516 {
517 CheckCommDlgError(hWnd);
518 }
519
520 /* refresh tree and list views */
521 RefreshTreeView(g_pChildWnd->hTreeWnd);
522 pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
523 RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, pszKeyPath);
524
525 return bRet;
526 }
527
528 static UINT_PTR CALLBACK ExportRegistryFile_OFNHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
529 {
530 HWND hwndExportAll;
531 HWND hwndExportBranch;
532 HWND hwndExportBranchText;
533 UINT_PTR iResult = 0;
534 OPENFILENAME *pOfn;
535 LPWSTR pszSelectedKey;
536 OFNOTIFY *pOfnNotify;
537
538 UNREFERENCED_PARAMETER(wParam);
539
540 switch(uiMsg)
541 {
542 case WM_INITDIALOG:
543 pOfn = (OPENFILENAME *) lParam;
544 pszSelectedKey = (LPWSTR) pOfn->lCustData;
545
546 hwndExportAll = GetDlgItem(hdlg, IDC_EXPORT_ALL);
547 if (hwndExportAll)
548 SendMessageW(hwndExportAll, BM_SETCHECK, pszSelectedKey ? BST_UNCHECKED : BST_CHECKED, 0);
549
550 hwndExportBranch = GetDlgItem(hdlg, IDC_EXPORT_BRANCH);
551 if (hwndExportBranch)
552 SendMessageW(hwndExportBranch, BM_SETCHECK, pszSelectedKey ? BST_CHECKED : BST_UNCHECKED, 0);
553
554 hwndExportBranchText = GetDlgItem(hdlg, IDC_EXPORT_BRANCH_TEXT);
555 if (hwndExportBranchText)
556 SetWindowTextW(hwndExportBranchText, pszSelectedKey);
557 break;
558
559 case WM_NOTIFY:
560 if (((NMHDR *) lParam)->code == CDN_FILEOK)
561 {
562 pOfnNotify = (OFNOTIFY *) lParam;
563 pszSelectedKey = (LPWSTR) pOfnNotify->lpOFN->lCustData;
564
565 hwndExportBranch = GetDlgItem(hdlg, IDC_EXPORT_BRANCH);
566 hwndExportBranchText = GetDlgItem(hdlg, IDC_EXPORT_BRANCH_TEXT);
567 if (hwndExportBranch && hwndExportBranchText
568 && (SendMessageW(hwndExportBranch, BM_GETCHECK, 0, 0) == BST_CHECKED))
569 {
570 GetWindowTextW(hwndExportBranchText, pszSelectedKey, _MAX_PATH);
571 }
572 else
573 {
574 pszSelectedKey[0] = L'\0';
575 }
576 }
577 break;
578 }
579 return iResult;
580 }
581
582 BOOL ExportRegistryFile(HWND hWnd)
583 {
584 BOOL bRet = FALSE;
585 OPENFILENAME ofn;
586 WCHAR ExportKeyPath[_MAX_PATH];
587 WCHAR Caption[128], szTitle[512], szText[512];
588 HKEY hKeyRoot;
589 LPCWSTR pszKeyPath;
590
591 /* Figure out which key path we are exporting */
592 pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
593 GetKeyName(ExportKeyPath, COUNT_OF(ExportKeyPath), hKeyRoot, pszKeyPath);
594
595 InitOpenFileName(hWnd, &ofn);
596 LoadStringW(hInst, IDS_EXPORT_REG_FILE, Caption, COUNT_OF(Caption));
597 ofn.lpstrTitle = Caption;
598
599 /* Only set the path if a key (not the root node) is selected */
600 if (hKeyRoot != 0)
601 {
602 ofn.lCustData = (LPARAM) ExportKeyPath;
603 }
604 ofn.Flags = OFN_ENABLETEMPLATE | OFN_EXPLORER | OFN_ENABLEHOOK | OFN_OVERWRITEPROMPT;
605 ofn.lpfnHook = ExportRegistryFile_OFNHookProc;
606 ofn.lpTemplateName = MAKEINTRESOURCEW(IDD_EXPORTRANGE);
607 if (GetSaveFileName(&ofn))
608 {
609 switch (ofn.nFilterIndex)
610 {
611 case 2: /* Registry Hive Files */
612 {
613 LONG lResult;
614 HKEY hSubKey;
615
616 /* Open the subkey */
617 lResult = RegOpenKeyExW(hKeyRoot, pszKeyPath, 0, KEY_READ, &hSubKey);
618 if (lResult == ERROR_SUCCESS)
619 {
620 /* Enable the 'backup' privilege, save the hive then disable the privilege */
621 EnablePrivilege(SE_BACKUP_NAME, NULL, TRUE);
622 lResult = RegSaveKeyW(hSubKey, ofn.lpstrFile, NULL);
623 if (lResult == ERROR_ALREADY_EXISTS)
624 {
625 /*
626 * We are here, that means that we already said "yes" to the confirmation dialog.
627 * So we absolutely want to replace the hive file.
628 */
629 if (DeleteFileW(ofn.lpstrFile))
630 {
631 /* Try again */
632 lResult = RegSaveKeyW(hSubKey, ofn.lpstrFile, NULL);
633 }
634 }
635 EnablePrivilege(SE_BACKUP_NAME, NULL, FALSE);
636
637 if (lResult != ERROR_SUCCESS)
638 {
639 /*
640 * If we are here, it's because RegSaveKeyW has failed for any reason.
641 * The problem is that even if it has failed, it has created or
642 * replaced the exported hive file with a new empty file. We don't
643 * want to keep this file, so we delete it.
644 */
645 DeleteFileW(ofn.lpstrFile);
646 }
647
648 /* Close the subkey */
649 RegCloseKey(hSubKey);
650 }
651
652 /* Set the return value */
653 bRet = (lResult == ERROR_SUCCESS);
654
655 /* Display error, if any */
656 if (!bRet) ErrorMessageBox(hWnd, Caption, lResult);
657
658 break;
659 }
660
661 case 1: /* Windows Registry Editor Version 5.00 */
662 case 3: /* REGEDIT4 */
663 default: /* All files ==> use Windows Registry Editor Version 5.00 */
664 {
665 if (!export_registry_key(ofn.lpstrFile, ExportKeyPath,
666 (ofn.nFilterIndex == 3 ? REG_FORMAT_4
667 : REG_FORMAT_5)))
668 {
669 /* Error creating the file */
670 LoadStringW(hInst, IDS_APP_TITLE, szTitle, COUNT_OF(szTitle));
671 LoadStringW(hInst, IDS_EXPORT_ERROR, szText, COUNT_OF(szText));
672 InfoMessageBox(hWnd, MB_OK | MB_ICONERROR, szTitle, szText, ofn.lpstrFile);
673 bRet = FALSE;
674 }
675 else
676 {
677 bRet = TRUE;
678 }
679
680 break;
681 }
682 }
683 }
684 else
685 {
686 CheckCommDlgError(hWnd);
687 }
688
689 return bRet;
690 }
691
692 BOOL PrintRegistryHive(HWND hWnd, LPWSTR path)
693 {
694 #if 1
695 PRINTDLG pd;
696 UNREFERENCED_PARAMETER(path);
697
698 ZeroMemory(&pd, sizeof(PRINTDLG));
699 pd.lStructSize = sizeof(PRINTDLG);
700 pd.hwndOwner = hWnd;
701 pd.hDevMode = NULL; /* Don't forget to free or store hDevMode*/
702 pd.hDevNames = NULL; /* Don't forget to free or store hDevNames*/
703 pd.Flags = PD_USEDEVMODECOPIESANDCOLLATE | PD_RETURNDC;
704 pd.nCopies = 1;
705 pd.nFromPage = 0xFFFF;
706 pd.nToPage = 0xFFFF;
707 pd.nMinPage = 1;
708 pd.nMaxPage = 0xFFFF;
709 if (PrintDlg(&pd))
710 {
711 /* GDI calls to render output. */
712 DeleteDC(pd.hDC); /* Delete DC when done.*/
713 }
714 #else
715 HRESULT hResult;
716 PRINTDLGEX pd;
717
718 hResult = PrintDlgEx(&pd);
719 if (hResult == S_OK)
720 {
721 switch (pd.dwResultAction)
722 {
723 case PD_RESULT_APPLY:
724 /*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. */
725 break;
726 case PD_RESULT_CANCEL:
727 /*The user clicked the Cancel button. The information in the PRINTDLGEX structure is unchanged. */
728 break;
729 case PD_RESULT_PRINT:
730 /*The user clicked the Print button. The PRINTDLGEX structure contains the information specified by the user. */
731 break;
732 default:
733 break;
734 }
735 }
736 else
737 {
738 switch (hResult)
739 {
740 case E_OUTOFMEMORY:
741 /*Insufficient memory. */
742 break;
743 case E_INVALIDARG:
744 /* One or more arguments are invalid. */
745 break;
746 case E_POINTER:
747 /*Invalid pointer. */
748 break;
749 case E_HANDLE:
750 /*Invalid handle. */
751 break;
752 case E_FAIL:
753 /*Unspecified error. */
754 break;
755 default:
756 break;
757 }
758 return FALSE;
759 }
760 #endif
761 return TRUE;
762 }
763
764 static void ChooseFavorite(LPCWSTR pszFavorite)
765 {
766 HKEY hKey = NULL;
767 WCHAR szFavoritePath[512];
768 DWORD cbData, dwType;
769
770 if (RegOpenKeyExW(HKEY_CURRENT_USER, s_szFavoritesRegKey, 0, KEY_QUERY_VALUE, &hKey) != ERROR_SUCCESS)
771 goto done;
772
773 cbData = (sizeof(szFavoritePath) / sizeof(szFavoritePath[0])) - 1;
774 memset(szFavoritePath, 0, sizeof(szFavoritePath));
775 if (RegQueryValueExW(hKey, pszFavorite, NULL, &dwType, (LPBYTE) szFavoritePath, &cbData) != ERROR_SUCCESS)
776 goto done;
777
778 if (dwType == REG_SZ)
779 SelectNode(g_pChildWnd->hTreeWnd, szFavoritePath);
780
781 done:
782 if (hKey)
783 RegCloseKey(hKey);
784 }
785
786 BOOL CopyKeyName(HWND hWnd, HKEY hRootKey, LPCWSTR keyName)
787 {
788 BOOL bClipboardOpened = FALSE;
789 BOOL bSuccess = FALSE;
790 WCHAR szBuffer[512];
791 HGLOBAL hGlobal;
792 LPWSTR s;
793
794 if (!OpenClipboard(hWnd))
795 goto done;
796 bClipboardOpened = TRUE;
797
798 if (!EmptyClipboard())
799 goto done;
800
801 if (!GetKeyName(szBuffer, COUNT_OF(szBuffer), hRootKey, keyName))
802 goto done;
803
804 hGlobal = GlobalAlloc(GMEM_MOVEABLE, (wcslen(szBuffer) + 1) * sizeof(WCHAR));
805 if (!hGlobal)
806 goto done;
807
808 s = GlobalLock(hGlobal);
809 wcscpy(s, szBuffer);
810 GlobalUnlock(hGlobal);
811
812 SetClipboardData(CF_UNICODETEXT, hGlobal);
813 bSuccess = TRUE;
814
815 done:
816 if (bClipboardOpened)
817 CloseClipboard();
818 return bSuccess;
819 }
820
821 static BOOL CreateNewValue(HKEY hRootKey, LPCWSTR pszKeyPath, DWORD dwType)
822 {
823 WCHAR szNewValueFormat[128];
824 WCHAR szNewValue[128];
825 int iIndex = 1;
826 BYTE data[128];
827 DWORD dwExistingType, cbData;
828 LONG lResult;
829 HKEY hKey;
830 LVFINDINFO lvfi;
831
832 if (RegOpenKeyExW(hRootKey, pszKeyPath, 0, KEY_QUERY_VALUE | KEY_SET_VALUE,
833 &hKey) != ERROR_SUCCESS)
834 return FALSE;
835
836 LoadStringW(hInst, IDS_NEW_VALUE, szNewValueFormat, COUNT_OF(szNewValueFormat));
837
838 do
839 {
840 wsprintf(szNewValue, szNewValueFormat, iIndex++);
841 cbData = sizeof(data);
842 lResult = RegQueryValueExW(hKey, szNewValue, NULL, &dwExistingType, data, &cbData);
843 }
844 while(lResult == ERROR_SUCCESS);
845
846 switch(dwType)
847 {
848 case REG_DWORD:
849 cbData = sizeof(DWORD);
850 break;
851 case REG_SZ:
852 case REG_EXPAND_SZ:
853 cbData = sizeof(WCHAR);
854 break;
855 case REG_MULTI_SZ:
856 cbData = sizeof(WCHAR) * 2;
857 break;
858 case REG_QWORD:
859 cbData = sizeof(DWORD) * 2;
860 break;
861 default:
862 cbData = 0;
863 break;
864 }
865 memset(data, 0, cbData);
866 lResult = RegSetValueExW(hKey, szNewValue, 0, dwType, data, cbData);
867 RegCloseKey(hKey);
868 if (lResult != ERROR_SUCCESS)
869 {
870 return FALSE;
871 }
872
873 RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);
874
875 /* locate the newly added value, and get ready to rename it */
876 memset(&lvfi, 0, sizeof(lvfi));
877 lvfi.flags = LVFI_STRING;
878 lvfi.psz = szNewValue;
879 iIndex = ListView_FindItem(g_pChildWnd->hListWnd, -1, &lvfi);
880 if (iIndex >= 0)
881 (void)ListView_EditLabel(g_pChildWnd->hListWnd, iIndex);
882
883 return TRUE;
884 }
885
886 static HRESULT
887 InitializeRemoteRegistryPicker(OUT IDsObjectPicker **pDsObjectPicker)
888 {
889 HRESULT hRet;
890
891 *pDsObjectPicker = NULL;
892
893 hRet = CoCreateInstance(&CLSID_DsObjectPicker,
894 NULL,
895 CLSCTX_INPROC_SERVER,
896 &IID_IDsObjectPicker,
897 (LPVOID*)pDsObjectPicker);
898 if (SUCCEEDED(hRet))
899 {
900 DSOP_INIT_INFO InitInfo;
901 static DSOP_SCOPE_INIT_INFO Scopes[] =
902 {
903 {
904 sizeof(DSOP_SCOPE_INIT_INFO),
905 DSOP_SCOPE_TYPE_USER_ENTERED_UPLEVEL_SCOPE | DSOP_SCOPE_TYPE_USER_ENTERED_DOWNLEVEL_SCOPE |
906 DSOP_SCOPE_TYPE_GLOBAL_CATALOG | DSOP_SCOPE_TYPE_EXTERNAL_UPLEVEL_DOMAIN |
907 DSOP_SCOPE_TYPE_EXTERNAL_DOWNLEVEL_DOMAIN | DSOP_SCOPE_TYPE_WORKGROUP |
908 DSOP_SCOPE_TYPE_UPLEVEL_JOINED_DOMAIN | DSOP_SCOPE_TYPE_DOWNLEVEL_JOINED_DOMAIN,
909 0,
910 {
911 {
912 DSOP_FILTER_COMPUTERS,
913 0,
914 0
915 },
916 DSOP_DOWNLEVEL_FILTER_COMPUTERS
917 },
918 NULL,
919 NULL,
920 S_OK
921 },
922 };
923
924 InitInfo.cbSize = sizeof(InitInfo);
925 InitInfo.pwzTargetComputer = NULL;
926 InitInfo.cDsScopeInfos = COUNT_OF(Scopes);
927 InitInfo.aDsScopeInfos = Scopes;
928 InitInfo.flOptions = 0;
929 InitInfo.cAttributesToFetch = 0;
930 InitInfo.apwzAttributeNames = NULL;
931
932 hRet = (*pDsObjectPicker)->lpVtbl->Initialize(*pDsObjectPicker,
933 &InitInfo);
934
935 if (FAILED(hRet))
936 {
937 /* delete the object picker in case initialization failed! */
938 (*pDsObjectPicker)->lpVtbl->Release(*pDsObjectPicker);
939 }
940 }
941
942 return hRet;
943 }
944
945 static HRESULT
946 InvokeRemoteRegistryPickerDialog(IN IDsObjectPicker *pDsObjectPicker,
947 IN HWND hwndParent OPTIONAL,
948 OUT LPWSTR lpBuffer,
949 IN UINT uSize)
950 {
951 IDataObject *pdo = NULL;
952 HRESULT hRet;
953
954 hRet = pDsObjectPicker->lpVtbl->InvokeDialog(pDsObjectPicker,
955 hwndParent,
956 &pdo);
957 if (hRet == S_OK)
958 {
959 STGMEDIUM stm;
960 FORMATETC fe;
961
962 fe.cfFormat = (CLIPFORMAT) RegisterClipboardFormatW(CFSTR_DSOP_DS_SELECTION_LIST);
963 fe.ptd = NULL;
964 fe.dwAspect = DVASPECT_CONTENT;
965 fe.lindex = -1;
966 fe.tymed = TYMED_HGLOBAL;
967
968 hRet = pdo->lpVtbl->GetData(pdo,
969 &fe,
970 &stm);
971 if (SUCCEEDED(hRet))
972 {
973 PDS_SELECTION_LIST SelectionList = (PDS_SELECTION_LIST)GlobalLock(stm.hGlobal);
974 if (SelectionList != NULL)
975 {
976 if (SelectionList->cItems == 1)
977 {
978 size_t nlen = wcslen(SelectionList->aDsSelection[0].pwzName);
979 if (nlen >= uSize)
980 {
981 nlen = uSize - 1;
982 }
983
984 memcpy(lpBuffer,
985 SelectionList->aDsSelection[0].pwzName,
986 nlen * sizeof(WCHAR));
987
988 lpBuffer[nlen] = L'\0';
989 }
990
991 GlobalUnlock(stm.hGlobal);
992 }
993
994 ReleaseStgMedium(&stm);
995 }
996
997 pdo->lpVtbl->Release(pdo);
998 }
999
1000 return hRet;
1001 }
1002
1003 static VOID
1004 FreeObjectPicker(IN IDsObjectPicker *pDsObjectPicker)
1005 {
1006 pDsObjectPicker->lpVtbl->Release(pDsObjectPicker);
1007 }
1008
1009 /*******************************************************************************
1010 *
1011 * FUNCTION: _CmdWndProc(HWND, unsigned, WORD, LONG)
1012 *
1013 * PURPOSE: Processes WM_COMMAND messages for the main frame window.
1014 *
1015 */
1016 static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
1017 {
1018 HKEY hKeyRoot = 0, hKey = 0;
1019 LPCWSTR keyPath;
1020 LPCWSTR valueName;
1021 BOOL result = TRUE;
1022 REGSAM regsam = KEY_READ;
1023 LONG lRet;
1024 int item;
1025
1026 UNREFERENCED_PARAMETER(lParam);
1027 UNREFERENCED_PARAMETER(message);
1028
1029 switch (LOWORD(wParam))
1030 {
1031 case ID_REGISTRY_LOADHIVE:
1032 LoadHive(hWnd);
1033 return TRUE;
1034 case ID_REGISTRY_UNLOADHIVE:
1035 UnloadHive(hWnd);
1036 return TRUE;
1037 case ID_REGISTRY_IMPORTREGISTRYFILE:
1038 ImportRegistryFile(hWnd);
1039 return TRUE;
1040 case ID_REGISTRY_EXPORTREGISTRYFILE:
1041 ExportRegistryFile(hWnd);
1042 return TRUE;
1043 case ID_REGISTRY_CONNECTNETWORKREGISTRY:
1044 {
1045 IDsObjectPicker *ObjectPicker;
1046 WCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1];
1047 HRESULT hRet;
1048
1049 hRet = CoInitialize(NULL);
1050 if (SUCCEEDED(hRet))
1051 {
1052 hRet = InitializeRemoteRegistryPicker(&ObjectPicker);
1053 if (SUCCEEDED(hRet))
1054 {
1055 hRet = InvokeRemoteRegistryPickerDialog(ObjectPicker,
1056 hWnd,
1057 szComputerName,
1058 COUNT_OF(szComputerName));
1059 if (hRet == S_OK)
1060 {
1061 /* FIXME - connect to the registry */
1062 }
1063
1064 FreeObjectPicker(ObjectPicker);
1065 }
1066
1067 CoUninitialize();
1068 }
1069
1070 return TRUE;
1071 }
1072 case ID_REGISTRY_DISCONNECTNETWORKREGISTRY:
1073 return TRUE;
1074 case ID_REGISTRY_PRINT:
1075 PrintRegistryHive(hWnd, L"");
1076 return TRUE;
1077 case ID_REGISTRY_EXIT:
1078 DestroyWindow(hWnd);
1079 return TRUE;
1080 case ID_VIEW_STATUSBAR:
1081 toggle_child(hWnd, LOWORD(wParam), hStatusBar);
1082 return TRUE;
1083 case ID_HELP_HELPTOPICS:
1084 WinHelpW(hWnd, getAppName(), HELP_FINDER, 0);
1085 return TRUE;
1086 case ID_HELP_ABOUT:
1087 ShowAboutBox(hWnd);
1088 return TRUE;
1089 case ID_VIEW_SPLIT:
1090 {
1091 RECT rt;
1092 POINT pt, pts;
1093 GetClientRect(g_pChildWnd->hWnd, &rt);
1094 pt.x = rt.left + g_pChildWnd->nSplitPos;
1095 pt.y = (rt.bottom / 2);
1096 pts = pt;
1097 if(ClientToScreen(g_pChildWnd->hWnd, &pts))
1098 {
1099 SetCursorPos(pts.x, pts.y);
1100 SetCursor(LoadCursorW(0, IDC_SIZEWE));
1101 SendMessageW(g_pChildWnd->hWnd, WM_LBUTTONDOWN, 0, MAKELPARAM(pt.x, pt.y));
1102 }
1103 return TRUE;
1104 }
1105 case ID_EDIT_RENAME:
1106 case ID_EDIT_MODIFY:
1107 case ID_EDIT_MODIFY_BIN:
1108 case ID_EDIT_DELETE:
1109 regsam |= KEY_WRITE;
1110 break;
1111 }
1112
1113 keyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
1114 valueName = GetValueName(g_pChildWnd->hListWnd, -1);
1115 if (keyPath)
1116 {
1117 lRet = RegOpenKeyExW(hKeyRoot, keyPath, 0, regsam, &hKey);
1118 if (lRet != ERROR_SUCCESS) hKey = 0;
1119 }
1120
1121 switch (LOWORD(wParam))
1122 {
1123 case ID_EDIT_MODIFY:
1124 if (valueName && ModifyValue(hWnd, hKey, valueName, FALSE))
1125 RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath);
1126 break;
1127 case ID_EDIT_MODIFY_BIN:
1128 if (valueName && ModifyValue(hWnd, hKey, valueName, TRUE))
1129 RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath);
1130 break;
1131 case ID_EDIT_RENAME:
1132 if (GetFocus() == g_pChildWnd->hListWnd)
1133 {
1134 if(ListView_GetSelectedCount(g_pChildWnd->hListWnd) == 1)
1135 {
1136 item = ListView_GetNextItem(g_pChildWnd->hListWnd, -1, LVNI_SELECTED);
1137 if(item > -1)
1138 {
1139 (void)ListView_EditLabel(g_pChildWnd->hListWnd, item);
1140 }
1141 }
1142 }
1143 else if (GetFocus() == g_pChildWnd->hTreeWnd)
1144 {
1145 /* Get focused entry of treeview (if any) */
1146 HTREEITEM hItem = TreeView_GetSelection(g_pChildWnd->hTreeWnd);
1147 if (hItem != NULL)
1148 (void)TreeView_EditLabel(g_pChildWnd->hTreeWnd, hItem);
1149 }
1150 break;
1151 case ID_EDIT_DELETE:
1152 {
1153 if (GetFocus() == g_pChildWnd->hListWnd)
1154 {
1155 UINT nSelected = ListView_GetSelectedCount(g_pChildWnd->hListWnd);
1156 if(nSelected >= 1)
1157 {
1158 WCHAR msg[128], caption[128];
1159 LoadStringW(hInst, IDS_QUERY_DELETE_CONFIRM, caption, COUNT_OF(caption));
1160 LoadStringW(hInst, (nSelected == 1 ? IDS_QUERY_DELETE_ONE : IDS_QUERY_DELETE_MORE), msg, COUNT_OF(msg));
1161 if(MessageBoxW(g_pChildWnd->hWnd, msg, caption, MB_ICONQUESTION | MB_YESNO) == IDYES)
1162 {
1163 int ni, errs;
1164
1165 item = -1;
1166 errs = 0;
1167 while((ni = ListView_GetNextItem(g_pChildWnd->hListWnd, item, LVNI_SELECTED)) > -1)
1168 {
1169 valueName = GetValueName(g_pChildWnd->hListWnd, item);
1170 if(RegDeleteValueW(hKey, valueName) != ERROR_SUCCESS)
1171 {
1172 errs++;
1173 }
1174 item = ni;
1175 }
1176
1177 RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath);
1178 if(errs > 0)
1179 {
1180 LoadStringW(hInst, IDS_ERR_DELVAL_CAPTION, caption, COUNT_OF(caption));
1181 LoadStringW(hInst, IDS_ERR_DELETEVALUE, msg, COUNT_OF(msg));
1182 MessageBoxW(g_pChildWnd->hWnd, msg, caption, MB_ICONSTOP);
1183 }
1184 }
1185 }
1186 }
1187 else if (GetFocus() == g_pChildWnd->hTreeWnd)
1188 {
1189 if (keyPath == 0 || *keyPath == 0)
1190 {
1191 MessageBeep(MB_ICONHAND);
1192 }
1193 else if (DeleteKey(hWnd, hKeyRoot, keyPath))
1194 {
1195 DeleteNode(g_pChildWnd->hTreeWnd, 0);
1196 RefreshTreeView(g_pChildWnd->hTreeWnd);
1197 }
1198 }
1199 break;
1200 }
1201 case ID_EDIT_NEW_STRINGVALUE:
1202 CreateNewValue(hKeyRoot, keyPath, REG_SZ);
1203 break;
1204 case ID_EDIT_NEW_BINARYVALUE:
1205 CreateNewValue(hKeyRoot, keyPath, REG_BINARY);
1206 break;
1207 case ID_EDIT_NEW_DWORDVALUE:
1208 CreateNewValue(hKeyRoot, keyPath, REG_DWORD);
1209 break;
1210 case ID_EDIT_NEW_MULTISTRINGVALUE:
1211 CreateNewValue(hKeyRoot, keyPath, REG_MULTI_SZ);
1212 break;
1213 case ID_EDIT_NEW_EXPANDABLESTRINGVALUE:
1214 CreateNewValue(hKeyRoot, keyPath, REG_EXPAND_SZ);
1215 break;
1216 case ID_EDIT_FIND:
1217 FindDialog(hWnd);
1218 break;
1219 case ID_EDIT_FINDNEXT:
1220 FindNext(hWnd);
1221 break;
1222 case ID_EDIT_COPYKEYNAME:
1223 CopyKeyName(hWnd, hKeyRoot, keyPath);
1224 break;
1225 case ID_EDIT_PERMISSIONS:
1226 RegKeyEditPermissions(hWnd, hKeyRoot, NULL, keyPath);
1227 break;
1228 case ID_REGISTRY_PRINTERSETUP:
1229 /*PRINTDLG pd;*/
1230 /*PrintDlg(&pd);*/
1231 /*PAGESETUPDLG psd;*/
1232 /*PageSetupDlg(&psd);*/
1233 break;
1234 case ID_REGISTRY_OPENLOCAL:
1235 break;
1236
1237 case ID_VIEW_REFRESH:
1238 RefreshTreeView(g_pChildWnd->hTreeWnd);
1239 keyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
1240 RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath);
1241 break;
1242 /*case ID_OPTIONS_TOOLBAR:*/
1243 /* toggle_child(hWnd, LOWORD(wParam), hToolBar);*/
1244 /* break;*/
1245 case ID_EDIT_NEW_KEY:
1246 CreateNewKey(g_pChildWnd->hTreeWnd, TreeView_GetSelection(g_pChildWnd->hTreeWnd));
1247 break;
1248 default:
1249 if ((LOWORD(wParam) >= ID_FAVORITES_MIN) && (LOWORD(wParam) <= ID_FAVORITES_MAX))
1250 {
1251 HMENU hMenu;
1252 MENUITEMINFO mii;
1253 WCHAR szFavorite[512];
1254
1255 hMenu = GetSubMenu(GetMenu(hWnd), FAVORITES_MENU_POSITION);
1256
1257 memset(&mii, 0, sizeof(mii));
1258 mii.cbSize = sizeof(mii);
1259 mii.fMask = MIIM_TYPE;
1260 mii.fType = MFT_STRING;
1261 mii.dwTypeData = szFavorite;
1262 mii.cch = COUNT_OF(szFavorite);
1263
1264 if (GetMenuItemInfo(hMenu, LOWORD(wParam) - ID_FAVORITES_MIN, TRUE, &mii))
1265 {
1266 ChooseFavorite(szFavorite);
1267 }
1268 }
1269 else
1270 {
1271 result = FALSE;
1272 }
1273 break;
1274 }
1275
1276 if(hKey)
1277 RegCloseKey(hKey);
1278 return result;
1279 }
1280
1281 /********************************************************************************
1282 *
1283 * FUNCTION: FrameWndProc(HWND, unsigned, WORD, LONG)
1284 *
1285 * PURPOSE: Processes messages for the main frame window.
1286 *
1287 * WM_COMMAND - process the application menu
1288 * WM_DESTROY - post a quit message and return
1289 *
1290 */
1291
1292 LRESULT CALLBACK FrameWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
1293 {
1294 switch (message)
1295 {
1296 case WM_CREATE:
1297 CreateWindowExW(0, szChildClass, NULL, WS_CHILD | WS_VISIBLE,
1298 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1299 hWnd, (HMENU)0, hInst, 0);
1300 break;
1301 case WM_COMMAND:
1302 if (!_CmdWndProc(hWnd, message, wParam, lParam))
1303 return DefWindowProcW(hWnd, message, wParam, lParam);
1304 break;
1305 case WM_ACTIVATE:
1306 if (LOWORD(hWnd))
1307 SetFocus(g_pChildWnd->hWnd);
1308 break;
1309 case WM_SIZE:
1310 resize_frame_client(hWnd);
1311 break;
1312 case WM_TIMER:
1313 break;
1314 case WM_INITMENU:
1315 OnInitMenu(hWnd);
1316 break;
1317 case WM_ENTERMENULOOP:
1318 OnEnterMenuLoop(hWnd);
1319 break;
1320 case WM_EXITMENULOOP:
1321 OnExitMenuLoop(hWnd);
1322 break;
1323 case WM_MENUSELECT:
1324 OnMenuSelect(hWnd, LOWORD(wParam), HIWORD(wParam), (HMENU)lParam);
1325 break;
1326 case WM_SYSCOLORCHANGE:
1327 /* Forward WM_SYSCOLORCHANGE to common controls */
1328 SendMessageW(g_pChildWnd->hListWnd, WM_SYSCOLORCHANGE, 0, 0);
1329 SendMessageW(g_pChildWnd->hTreeWnd, WM_SYSCOLORCHANGE, 0, 0);
1330 break;
1331 case WM_DESTROY:
1332 WinHelpW(hWnd, getAppName(), HELP_QUIT, 0);
1333 SaveSettings();
1334 PostQuitMessage(0);
1335 default:
1336 return DefWindowProcW(hWnd, message, wParam, lParam);
1337 }
1338 return 0;
1339 }