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, LPCTSTR path)
 379 {
 380 #if 1
 381     PRINTDLG 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 (PrintDlg(&pd)) {
 395         /* GDI calls to render output. */
 396         DeleteDC(pd.hDC); /* Delete DC when done.*/
 397     }
 398 #else
 399     HRESULT hResult;
 400     PRINTDLGEX pd;
 401
 402     hResult = PrintDlgEx(&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, LPCTSTR keyName)
 444 {
 445     BOOL result;
 446
 447     result = OpenClipboard(hWnd);
 448     if (result) {
 449         result = EmptyClipboard();
 450         if (result) {
 451             int len = (_tcslen(keyName)+1)*sizeof(TCHAR);
 452             HANDLE hClipData = GlobalAlloc(GHND, len);
 453             LPVOID pLoc = GlobalLock(hClipData);
 454             _tcscpy(pLoc, keyName);
 455             GlobalUnlock(hClipData);
 456             hClipData = SetClipboardData(CF_TEXT, 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         PrintRegistryHive(hWnd, _T(""));
 675         break;
 676     case ID_EDIT_DELETE:
 677         if (GetFocus() == g_pChildWnd->hTreeWnd) {
 678             if (keyPath == 0 || *keyPath == 0) {
 679                 MessageBeep(MB_ICONHAND);
 680             } else if (DeleteKey(hWnd, hKeyRoot, keyPath)) {
 681                 DeleteNode(g_pChildWnd->hTreeWnd, 0);
 682             }
 683         } else if (GetFocus() == g_pChildWnd->hListWnd) {
 684         curIndex = ListView_GetNextItem(g_pChildWnd->hListWnd, -1, LVNI_SELECTED);
 685         while(curIndex != -1) {
 686             valueName = GetItemText(g_pChildWnd->hListWnd, curIndex);
 687             curIndex = ListView_GetNextItem(g_pChildWnd->hListWnd, curIndex, LVNI_SELECTED);
 688             if(curIndex != -1 && firstItem) {
 689                 TCHAR title[256];
 690                 TCHAR text[1024];
 691                 if(!LoadString(hInst, IDS_DELETE_BOX_TITLE, title, COUNT_OF(title)))
 692                     lstrcpy(title, "Error");
 693                 if(!LoadString(hInst, IDS_DELETE_BOX_TEXT_MULTIPLE, text, COUNT_OF(text)))
 694                     lstrcpy(text, "Unknown error string!");
 695                 if (MessageBox(hWnd, text, title, MB_YESNO | MB_ICONEXCLAMATION) != IDYES)
 696                     break;
 697             }
 698             if (!DeleteValue(hWnd, hKeyRoot, keyPath, valueName, curIndex==-1 && firstItem))
 699                 break;
 700             firstItem = FALSE;
 701         }
 702                 RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath, NULL);
 703         }
 704         break;
 705     case ID_EDIT_MODIFY:
 706         valueName = GetValueName(g_pChildWnd->hListWnd);
 707         if (ModifyValue(hWnd, hKeyRoot, keyPath, valueName))
 708             RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath, valueName);
 709         break;
 710     case ID_EDIT_FIND:
 711     case ID_EDIT_FINDNEXT:
 712     {
 713         HTREEITEM hItem;
 714         if (LOWORD(wParam) == ID_EDIT_FIND &&
 715             DialogBox(0, MAKEINTRESOURCE(IDD_FIND), hWnd, find_dlgproc) != IDOK)
 716             break;
 717         if (!*searchString)
 718             break;
 719         hItem = TreeView_GetSelection(g_pChildWnd->hTreeWnd);
 720         if (hItem) {
 721             int row = ListView_GetNextItem(g_pChildWnd->hListWnd, -1, LVNI_FOCUSED);
 722             HCURSOR hcursorOld = SetCursor(LoadCursor(NULL, IDC_WAIT));
 723             hItem = FindNext(g_pChildWnd->hTreeWnd, hItem, searchString, searchMask, &row);
 724             SetCursor(hcursorOld);
 725             if (hItem) {
 726                 SendMessage( g_pChildWnd->hTreeWnd, TVM_SELECTITEM, TVGN_CARET, (LPARAM) hItem );
 727                 InvalidateRect(g_pChildWnd->hTreeWnd, NULL, TRUE);
 728                 UpdateWindow(g_pChildWnd->hTreeWnd);
 729                 if (row != -1) {
 730                     ListView_SetItemState(g_pChildWnd->hListWnd, -1, 0, LVIS_FOCUSED|LVIS_SELECTED);
 731                     ListView_SetItemState(g_pChildWnd->hListWnd, row, LVIS_FOCUSED|LVIS_SELECTED, LVIS_FOCUSED|LVIS_SELECTED);
 732                     SetFocus(g_pChildWnd->hListWnd);
 733                 } else {
 734                     SetFocus(g_pChildWnd->hTreeWnd);
 735                 }
 736             } else {
 737                 error(hWnd, IDS_NOTFOUND, searchString);
 738             }
 739         }
 740         break;
 741     }
 742     case ID_EDIT_COPYKEYNAME:
 743     {
 744         LPTSTR fullPath = GetItemFullPath(g_pChildWnd->hTreeWnd, NULL, FALSE);
 745         if (fullPath) {
 746             CopyKeyName(hWnd, fullPath);
 747             HeapFree(GetProcessHeap(), 0, fullPath);
 748         }
 749         break;
 750     }
 751     case ID_EDIT_NEW_KEY:
 752         if (CreateKey(hWnd, hKeyRoot, keyPath, newKey)) {
 753             if (InsertNode(g_pChildWnd->hTreeWnd, 0, newKey))
 754                 StartKeyRename(g_pChildWnd->hTreeWnd);
 755         }
 756         break;
 757     case ID_EDIT_NEW_STRINGVALUE:
 758         valueType = REG_SZ;
 759         goto create_value;
 760     case ID_EDIT_NEW_MULTI_STRINGVALUE:
 761         valueType = REG_MULTI_SZ;
 762         goto create_value;
 763     case ID_EDIT_NEW_BINARYVALUE:
 764         valueType = REG_BINARY;
 765         goto create_value;
 766     case ID_EDIT_NEW_DWORDVALUE:
 767         valueType = REG_DWORD;
 768         /* fall through */
 769     create_value:
 770         if (CreateValue(hWnd, hKeyRoot, keyPath, valueType, newKey)) {
 771             RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath, newKey);
 772             StartValueRename(g_pChildWnd->hListWnd);
 773             /* FIXME: start rename */
 774         }
 775         break;
 776     case ID_EDIT_RENAME:
 777         if (keyPath == 0 || *keyPath == 0) {
 778             MessageBeep(MB_ICONHAND);
 779         } else if (GetFocus() == g_pChildWnd->hTreeWnd) {
 780             StartKeyRename(g_pChildWnd->hTreeWnd);
 781         } else if (GetFocus() == g_pChildWnd->hListWnd) {
 782             StartValueRename(g_pChildWnd->hListWnd);
 783         }
 784         break;
 785     case ID_REGISTRY_PRINTERSETUP:
 786         /*PRINTDLG pd;*/
 787         /*PrintDlg(&pd);*/
 788         /*PAGESETUPDLG psd;*/
 789         /*PageSetupDlg(&psd);*/
 790         break;
 791     case ID_REGISTRY_OPENLOCAL:
 792         break;
 793     case ID_REGISTRY_EXIT:
 794         DestroyWindow(hWnd);
 795         break;
 796     case ID_FAVORITES_ADDTOFAVORITES:
 797     {
 798         HKEY hKey;
 799         LPTSTR lpKeyPath = GetItemFullPath(g_pChildWnd->hTreeWnd, NULL, FALSE);
 800         if (lpKeyPath) {
 801             if (DialogBox(0, MAKEINTRESOURCE(IDD_ADDFAVORITE), hWnd, addtofavorites_dlgproc) == IDOK) {
 802                 if (RegCreateKeyEx(HKEY_CURRENT_USER, favoritesKey,
 803                     0, NULL, 0,
 804                     KEY_READ|KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
 805                     RegSetValueEx(hKey, favoriteName, 0, REG_SZ, (BYTE *)lpKeyPath, (_tcslen(lpKeyPath)+1)*sizeof(TCHAR));
 806                     RegCloseKey(hKey);
 807                 }
 808             }
 809             HeapFree(GetProcessHeap(), 0, lpKeyPath);
 810         }
 811         break;
 812     }
 813     case ID_FAVORITES_REMOVEFAVORITE:
 814     {
 815         if (DialogBox(0, MAKEINTRESOURCE(IDD_DELFAVORITE), hWnd, removefavorite_dlgproc) == IDOK) {
 816             HKEY hKey;
 817             if (RegOpenKeyEx(HKEY_CURRENT_USER, favoritesKey,
 818                 0, KEY_READ|KEY_WRITE, &hKey) == ERROR_SUCCESS) {
 819                 RegDeleteValue(hKey, favoriteName);
 820                 RegCloseKey(hKey);
 821             }
 822         }
 823         break;
 824     }
 825     case ID_VIEW_REFRESH:
 826         RefreshTreeView(g_pChildWnd->hTreeWnd);
 827         RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath, NULL);
 828         break;
 829    /*case ID_OPTIONS_TOOLBAR:*/
 830    /*   toggle_child(hWnd, LOWORD(wParam), hToolBar);*/
 831    /*    break;*/
 832     case ID_VIEW_STATUSBAR:
 833         toggle_child(hWnd, LOWORD(wParam), hStatusBar);
 834         break;
 835     case ID_HELP_HELPTOPICS:
 836         WinHelp(hWnd, _T("regedit"), HELP_FINDER, 0);
 837         break;
 838     case ID_HELP_ABOUT:
 839         ShowAboutBox(hWnd);
 840         break;
 841     case ID_VIEW_SPLIT: {
 842         RECT rt;
 843         POINT pt, pts;
 844         GetClientRect(g_pChildWnd->hWnd, &rt);
 845         pt.x = rt.left + g_pChildWnd->nSplitPos;
 846         pt.y = (rt.bottom / 2);
 847         pts = pt;
 848         if(ClientToScreen(g_pChildWnd->hWnd, &pts)) {
 849             SetCursorPos(pts.x, pts.y);
 850             SetCursor(LoadCursor(0, IDC_SIZEWE));
 851             SendMessage(g_pChildWnd->hWnd, WM_LBUTTONDOWN, 0, MAKELPARAM(pt.x, pt.y));
 852         }
 853         return TRUE;
 854     }
 855     default:
 856         return FALSE;
 857     }
 858
 859     return TRUE;
 860 }
 861
 862 /********************************************************************************
 863  *
 864  *  FUNCTION: FrameWndProc(HWND, unsigned, WORD, LONG)
 865  *
 866  *  PURPOSE:  Processes messages for the main frame window.
 867  *
 868  *  WM_COMMAND  - process the application menu
 869  *  WM_DESTROY  - post a quit message and return
 870  *
 871  */
 872
 873 LRESULT CALLBACK FrameWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 874 {
 875     switch (message) {
 876     case WM_CREATE:
 877         CreateWindowEx(0, szChildClass, _T("regedit child window"), WS_CHILD | WS_VISIBLE,
 878                        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 879                        hWnd, NULL, hInst, 0);
 880         break;
 881     case WM_COMMAND:
 882         if (!_CmdWndProc(hWnd, message, wParam, lParam))
 883             return DefWindowProc(hWnd, message, wParam, lParam);
 884         break;
 885     case WM_ACTIVATE:
 886         if (LOWORD(hWnd))
 887             SetFocus(g_pChildWnd->hWnd);
 888         break;
 889     case WM_SIZE:
 890         resize_frame_client(hWnd);
 891         break;
 892     case WM_TIMER:
 893         break;
 894     case WM_ENTERMENULOOP:
 895         OnEnterMenuLoop(hWnd);
 896         break;
 897     case WM_EXITMENULOOP:
 898         OnExitMenuLoop(hWnd);
 899         break;
 900     case WM_INITMENUPOPUP:
 901         if (!HIWORD(lParam))
 902             OnInitMenuPopup(hWnd, (HMENU)wParam, LOWORD(lParam));
 903         break;
 904     case WM_MENUSELECT:
 905         OnMenuSelect(hWnd, LOWORD(wParam), HIWORD(wParam), (HMENU)lParam);
 906         break;
 907     case WM_DESTROY:
 908         WinHelp(hWnd, _T("regedit"), HELP_QUIT, 0);
 909         PostQuitMessage(0);
 910     default:
 911         return DefWindowProc(hWnd, message, wParam, lParam);
 912     }
 913     return 0;
 914 }