programs/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 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 }