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     {
 765         WCHAR newKeyW[MAX_NEW_KEY_LEN];
 766         WCHAR* keyPathW = GetWideString(keyPath);
 767         if (CreateKey(hWnd, hKeyRoot, keyPathW, newKeyW)) {
 768             if (InsertNode(g_pChildWnd->hTreeWnd, 0, newKeyW))
 769                 StartKeyRename(g_pChildWnd->hTreeWnd);
 770         }
 771         HeapFree(GetProcessHeap(), 0, keyPathW);
 772     }
 773         break;
 774     case ID_EDIT_NEW_STRINGVALUE:
 775         valueType = REG_SZ;
 776         goto create_value;
 777     case ID_EDIT_NEW_MULTI_STRINGVALUE:
 778         valueType = REG_MULTI_SZ;
 779         goto create_value;
 780     case ID_EDIT_NEW_BINARYVALUE:
 781         valueType = REG_BINARY;
 782         goto create_value;
 783     case ID_EDIT_NEW_DWORDVALUE:
 784         valueType = REG_DWORD;
 785         /* fall through */
 786     create_value:
 787         if (CreateValue(hWnd, hKeyRoot, keyPath, valueType, newKey)) {
 788             RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath, newKey);
 789             StartValueRename(g_pChildWnd->hListWnd);
 790             /* FIXME: start rename */
 791         }
 792         break;
 793     case ID_EDIT_RENAME:
 794         if (keyPath == 0 || *keyPath == 0) {
 795             MessageBeep(MB_ICONHAND);
 796         } else if (GetFocus() == g_pChildWnd->hTreeWnd) {
 797             StartKeyRename(g_pChildWnd->hTreeWnd);
 798         } else if (GetFocus() == g_pChildWnd->hListWnd) {
 799             StartValueRename(g_pChildWnd->hListWnd);
 800         }
 801         break;
 802     case ID_REGISTRY_PRINTERSETUP:
 803         /*PRINTDLG pd;*/
 804         /*PrintDlg(&pd);*/
 805         /*PAGESETUPDLG psd;*/
 806         /*PageSetupDlg(&psd);*/
 807         break;
 808     case ID_REGISTRY_OPENLOCAL:
 809         break;
 810     case ID_REGISTRY_EXIT:
 811         DestroyWindow(hWnd);
 812         break;
 813     case ID_FAVORITES_ADDTOFAVORITES:
 814     {
 815         HKEY hKey;
 816         LPTSTR lpKeyPath = GetItemFullPath(g_pChildWnd->hTreeWnd, NULL, FALSE);
 817         if (lpKeyPath) {
 818             if (DialogBox(0, MAKEINTRESOURCE(IDD_ADDFAVORITE), hWnd, addtofavorites_dlgproc) == IDOK) {
 819                 if (RegCreateKeyEx(HKEY_CURRENT_USER, favoritesKey,
 820                     0, NULL, 0,
 821                     KEY_READ|KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
 822                     RegSetValueEx(hKey, favoriteName, 0, REG_SZ, (BYTE *)lpKeyPath, (_tcslen(lpKeyPath)+1)*sizeof(TCHAR));
 823                     RegCloseKey(hKey);
 824                 }
 825             }
 826             HeapFree(GetProcessHeap(), 0, lpKeyPath);
 827         }
 828         break;
 829     }
 830     case ID_FAVORITES_REMOVEFAVORITE:
 831     {
 832         if (DialogBox(0, MAKEINTRESOURCE(IDD_DELFAVORITE), hWnd, removefavorite_dlgproc) == IDOK) {
 833             HKEY hKey;
 834             if (RegOpenKeyEx(HKEY_CURRENT_USER, favoritesKey,
 835                 0, KEY_READ|KEY_WRITE, &hKey) == ERROR_SUCCESS) {
 836                 RegDeleteValue(hKey, favoriteName);
 837                 RegCloseKey(hKey);
 838             }
 839         }
 840         break;
 841     }
 842     case ID_VIEW_REFRESH:
 843         RefreshTreeView(g_pChildWnd->hTreeWnd);
 844         RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath, NULL);
 845         break;
 846    /*case ID_OPTIONS_TOOLBAR:*/
 847    /*   toggle_child(hWnd, LOWORD(wParam), hToolBar);*/
 848    /*    break;*/
 849     case ID_VIEW_STATUSBAR:
 850         toggle_child(hWnd, LOWORD(wParam), hStatusBar);
 851         break;
 852     case ID_HELP_HELPTOPICS:
 853     {
 854         const WCHAR help_regedit[] = {'r','e','g','e','d','i','t',0};
 855         WinHelpW(hWnd, help_regedit, HELP_FINDER, 0);
 856         break;
 857     }
 858     case ID_HELP_ABOUT:
 859         ShowAboutBox(hWnd);
 860         break;
 861     case ID_VIEW_SPLIT: {
 862         RECT rt;
 863         POINT pt, pts;
 864         GetClientRect(g_pChildWnd->hWnd, &rt);
 865         pt.x = rt.left + g_pChildWnd->nSplitPos;
 866         pt.y = (rt.bottom / 2);
 867         pts = pt;
 868         if(ClientToScreen(g_pChildWnd->hWnd, &pts)) {
 869             SetCursorPos(pts.x, pts.y);
 870             SetCursor(LoadCursor(0, IDC_SIZEWE));
 871             SendMessage(g_pChildWnd->hWnd, WM_LBUTTONDOWN, 0, MAKELPARAM(pt.x, pt.y));
 872         }
 873         return TRUE;
 874     }
 875     default:
 876         return FALSE;
 877     }
 878
 879     return TRUE;
 880 }
 881
 882 /********************************************************************************
 883  *
 884  *  FUNCTION: FrameWndProc(HWND, unsigned, WORD, LONG)
 885  *
 886  *  PURPOSE:  Processes messages for the main frame window.
 887  *
 888  *  WM_COMMAND  - process the application menu
 889  *  WM_DESTROY  - post a quit message and return
 890  *
 891  */
 892
 893 LRESULT CALLBACK FrameWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 894 {
 895     switch (message) {
 896     case WM_CREATE:
 897         CreateWindowEx(0, szChildClass, _T("regedit child window"), WS_CHILD | WS_VISIBLE,
 898                        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 899                        hWnd, NULL, hInst, 0);
 900         break;
 901     case WM_COMMAND:
 902         if (!_CmdWndProc(hWnd, message, wParam, lParam))
 903             return DefWindowProc(hWnd, message, wParam, lParam);
 904         break;
 905     case WM_ACTIVATE:
 906         if (LOWORD(hWnd))
 907             SetFocus(g_pChildWnd->hWnd);
 908         break;
 909     case WM_SIZE:
 910         resize_frame_client(hWnd);
 911         break;
 912     case WM_TIMER:
 913         break;
 914     case WM_ENTERMENULOOP:
 915         OnEnterMenuLoop(hWnd);
 916         break;
 917     case WM_EXITMENULOOP:
 918         OnExitMenuLoop(hWnd);
 919         break;
 920     case WM_INITMENUPOPUP:
 921         if (!HIWORD(lParam))
 922             OnInitMenuPopup(hWnd, (HMENU)wParam, LOWORD(lParam));
 923         break;
 924     case WM_MENUSELECT:
 925         OnMenuSelect(hWnd, LOWORD(wParam), HIWORD(wParam), (HMENU)lParam);
 926         break;
 927     case WM_DESTROY:
 928     {
 929         const WCHAR help_regedit[] = {'r','e','g','e','d','i','t',0};
 930         WinHelpW(hWnd, help_regedit, HELP_QUIT, 0);
 931         PostQuitMessage(0);
 932     }
 933     default:
 934         return DefWindowProc(hWnd, message, wParam, lParam);
 935     }
 936     return 0;
 937 }