reactos/dll/win32/syssetup/wizard.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         System setup
   4  * FILE:            dll/win32/syssetup/wizard.c
   5  * PURPOSE:         GUI controls
   6  * PROGRAMMERS:     Eric Kohl
   7  *                  Pierre Schweitzer <heis_spiter@hotmail.com>
   8  */
   9
  10 /* INCLUDES *****************************************************************/
  11
  12 #include "precomp.h"
  13
  14 #define NDEBUG
  15 #include <debug.h>
  16
  17 #define VMWINST
  18
  19 #define PM_REGISTRATION_NOTIFY (WM_APP + 1)
  20 /* Private Message used to communicate progress from the background
  21    registration thread to the main thread.
  22    wParam = 0 Registration in progress
  23           = 1 Registration completed
  24    lParam = Pointer to a REGISTRATIONNOTIFY structure */
  25
  26 typedef struct _REGISTRATIONNOTIFY
  27 {
  28     ULONG Progress;
  29     UINT ActivityID;
  30     LPCWSTR CurrentItem;
  31     LPCWSTR ErrorMessage;
  32 } REGISTRATIONNOTIFY, *PREGISTRATIONNOTIFY;
  33
  34 typedef struct _REGISTRATIONDATA
  35 {
  36     HWND hwndDlg;
  37     ULONG DllCount;
  38     ULONG Registered;
  39     PVOID DefaultContext;
  40 } REGISTRATIONDATA, *PREGISTRATIONDATA;
  41
  42 /* GLOBALS ******************************************************************/
  43
  44 SETUPDATA SetupData;
  45
  46
  47 /* FUNCTIONS ****************************************************************/
  48
  49 extern void WINAPI Control_RunDLLW(HWND hWnd, HINSTANCE hInst, LPCWSTR cmd, DWORD nCmdShow);
  50
  51 BOOL
  52 GetRosInstallCD(WCHAR *pwszPath, DWORD cchPathMax);
  53
  54 #ifdef VMWINST
  55 static BOOL
  56 RunVMWInstall(HWND hWnd)
  57 {
  58     PROCESS_INFORMATION ProcInfo;
  59     MSG msg;
  60     DWORD ret;
  61     STARTUPINFOW si;
  62     WCHAR InstallName[] = L"vmwinst.exe";
  63
  64     ZeroMemory(&si, sizeof(si));
  65     si.cb = sizeof(si);
  66
  67     if(CreateProcessW(NULL, InstallName, NULL, NULL, TRUE, NORMAL_PRIORITY_CLASS,
  68                       NULL, NULL, &si, &ProcInfo))
  69     {
  70         EnableWindow(hWnd, FALSE);
  71         for (;;)
  72         {
  73             while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
  74             {
  75                 if (msg.message == WM_QUIT)
  76                     goto done;
  77                 TranslateMessage(&msg);
  78                 DispatchMessage(&msg);
  79             }
  80
  81             ret = MsgWaitForMultipleObjects(1, &ProcInfo.hProcess, FALSE, INFINITE, QS_ALLEVENTS | QS_ALLINPUT);
  82             if (ret == WAIT_OBJECT_0)
  83                 break;
  84         }
  85 done:
  86         EnableWindow(hWnd, TRUE);
  87
  88         CloseHandle(ProcInfo.hThread);
  89         CloseHandle(ProcInfo.hProcess);
  90         return TRUE;
  91     }
  92     return FALSE;
  93 }
  94 #endif
  95
  96 static VOID
  97 CenterWindow(HWND hWnd)
  98 {
  99     HWND hWndParent;
 100     RECT rcParent;
 101     RECT rcWindow;
 102
 103     hWndParent = GetParent(hWnd);
 104     if (hWndParent == NULL)
 105         hWndParent = GetDesktopWindow();
 106
 107     GetWindowRect(hWndParent, &rcParent);
 108     GetWindowRect(hWnd, &rcWindow);
 109
 110     SetWindowPos(hWnd,
 111                  HWND_TOP,
 112                  ((rcParent.right - rcParent.left) - (rcWindow.right - rcWindow.left)) / 2,
 113                  ((rcParent.bottom - rcParent.top) - (rcWindow.bottom - rcWindow.top)) / 2,
 114                  0,
 115                  0,
 116                  SWP_NOSIZE);
 117 }
 118
 119
 120 static HFONT
 121 CreateTitleFont(VOID)
 122 {
 123     NONCLIENTMETRICSW ncm;
 124     LOGFONTW LogFont;
 125     HDC hdc;
 126     INT FontSize;
 127     HFONT hFont;
 128
 129     ncm.cbSize = sizeof(NONCLIENTMETRICSW);
 130     SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
 131
 132     LogFont = ncm.lfMessageFont;
 133     LogFont.lfWeight = FW_BOLD;
 134     wcscpy(LogFont.lfFaceName, L"MS Shell Dlg");
 135
 136     hdc = GetDC(NULL);
 137     FontSize = 12;
 138     LogFont.lfHeight = 0 - GetDeviceCaps(hdc, LOGPIXELSY) * FontSize / 72;
 139     hFont = CreateFontIndirectW(&LogFont);
 140     ReleaseDC(NULL, hdc);
 141
 142     return hFont;
 143 }
 144
 145
 146 static INT_PTR CALLBACK
 147 GplDlgProc(HWND hwndDlg,
 148            UINT uMsg,
 149            WPARAM wParam,
 150            LPARAM lParam)
 151 {
 152     HRSRC GplTextResource;
 153     HGLOBAL GplTextMem;
 154     PVOID GplTextLocked;
 155     PCHAR GplText;
 156     DWORD Size;
 157
 158
 159     switch (uMsg)
 160     {
 161         case WM_INITDIALOG:
 162             GplTextResource = FindResourceW(hDllInstance, MAKEINTRESOURCE(IDR_GPL), L"RT_TEXT");
 163             if (NULL == GplTextResource)
 164             {
 165                 break;
 166             }
 167             Size = SizeofResource(hDllInstance, GplTextResource);
 168             if (0 == Size)
 169             {
 170                 break;
 171             }
 172             GplText = HeapAlloc(GetProcessHeap(), 0, Size + 1);
 173             if (NULL == GplText)
 174             {
 175                 break;
 176             }
 177             GplTextMem = LoadResource(hDllInstance, GplTextResource);
 178             if (NULL == GplTextMem)
 179             {
 180                 HeapFree(GetProcessHeap(), 0, GplText);
 181                 break;
 182             }
 183             GplTextLocked = LockResource(GplTextMem);
 184             if (NULL == GplTextLocked)
 185             {
 186                 HeapFree(GetProcessHeap(), 0, GplText);
 187                 break;
 188             }
 189             memcpy(GplText, GplTextLocked, Size);
 190             GplText[Size] = '\0';
 191             SendMessageA(GetDlgItem(hwndDlg, IDC_GPL_TEXT), WM_SETTEXT, 0, (LPARAM) GplText);
 192             HeapFree(GetProcessHeap(), 0, GplText);
 193             SetFocus(GetDlgItem(hwndDlg, IDOK));
 194             return FALSE;
 195
 196         case WM_CLOSE:
 197             EndDialog(hwndDlg, IDCANCEL);
 198             break;
 199
 200         case WM_COMMAND:
 201             if (HIWORD(wParam) == BN_CLICKED && IDOK == LOWORD(wParam))
 202             {
 203                 EndDialog(hwndDlg, IDOK);
 204             }
 205             break;
 206
 207         default:
 208             break;
 209     }
 210
 211     return FALSE;
 212 }
 213
 214
 215 static INT_PTR CALLBACK
 216 WelcomeDlgProc(HWND hwndDlg,
 217                UINT uMsg,
 218                WPARAM wParam,
 219                LPARAM lParam)
 220 {
 221     switch (uMsg)
 222     {
 223         case WM_INITDIALOG:
 224         {
 225             PSETUPDATA SetupData;
 226             HWND hwndControl;
 227             DWORD dwStyle;
 228
 229             /* Get pointer to the global setup data */
 230             SetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
 231
 232             hwndControl = GetParent(hwndDlg);
 233
 234             /* Center the wizard window */
 235             CenterWindow (hwndControl);
 236
 237             /* Hide the system menu */
 238             dwStyle = GetWindowLongPtr(hwndControl, GWL_STYLE);
 239             SetWindowLongPtr(hwndControl, GWL_STYLE, dwStyle & ~WS_SYSMENU);
 240
 241             /* Hide and disable the 'Cancel' button */
 242             hwndControl = GetDlgItem(GetParent(hwndDlg), IDCANCEL);
 243             ShowWindow (hwndControl, SW_HIDE);
 244             EnableWindow (hwndControl, FALSE);
 245
 246             /* Set title font */
 247             SendDlgItemMessage(hwndDlg,
 248                                IDC_WELCOMETITLE,
 249                                WM_SETFONT,
 250                                (WPARAM)SetupData->hTitleFont,
 251                                (LPARAM)TRUE);
 252         }
 253         break;
 254
 255
 256         case WM_NOTIFY:
 257         {
 258             LPNMHDR lpnm = (LPNMHDR)lParam;
 259
 260             switch (lpnm->code)
 261             {
 262                 case PSN_SETACTIVE:
 263                     /* Enable the Next button */
 264                     PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT);
 265                     if (SetupData.UnattendSetup)
 266                     {
 267                         SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, IDD_ACKPAGE);
 268                         return TRUE;
 269                     }
 270                     break;
 271
 272                 case PSN_WIZBACK:
 273                     SetupData.UnattendSetup = FALSE;
 274                     break;
 275
 276                 default:
 277                     break;
 278             }
 279         }
 280         break;
 281
 282         default:
 283             break;
 284     }
 285
 286     return FALSE;
 287 }
 288
 289
 290 static INT_PTR CALLBACK
 291 AckPageDlgProc(HWND hwndDlg,
 292                UINT uMsg,
 293                WPARAM wParam,
 294                LPARAM lParam)
 295 {
 296     LPNMHDR lpnm;
 297     PWCHAR Projects;
 298     PWCHAR End, CurrentProject;
 299     INT ProjectsSize, ProjectsCount;
 300
 301     switch (uMsg)
 302     {
 303         case WM_INITDIALOG:
 304         {
 305             Projects = NULL;
 306             ProjectsSize = 256;
 307             do
 308             {
 309                 Projects = HeapAlloc(GetProcessHeap(), 0, ProjectsSize * sizeof(WCHAR));
 310                 if (NULL == Projects)
 311                 {
 312                     return FALSE;
 313                 }
 314                 ProjectsCount =  LoadStringW(hDllInstance, IDS_ACKPROJECTS, Projects, ProjectsSize);
 315                 if (0 == ProjectsCount)
 316                 {
 317                     HeapFree(GetProcessHeap(), 0, Projects);
 318                     return FALSE;
 319                 }
 320                 if (ProjectsCount < ProjectsSize - 1)
 321                 {
 322                     break;
 323                 }
 324                 HeapFree(GetProcessHeap(), 0, Projects);
 325                 ProjectsSize *= 2;
 326             }
 327             while (1);
 328             CurrentProject = Projects;
 329             while (L'\0' != *CurrentProject)
 330             {
 331                 End = wcschr(CurrentProject, L'\n');
 332                 if (NULL != End)
 333                 {
 334                     *End = L'\0';
 335                 }
 336                 (void)ListBox_AddString(GetDlgItem(hwndDlg, IDC_PROJECTS), CurrentProject);
 337                 if (NULL != End)
 338                 {
 339                     CurrentProject = End + 1;
 340                 }
 341                 else
 342                 {
 343                     CurrentProject += wcslen(CurrentProject);
 344                 }
 345             }
 346             HeapFree(GetProcessHeap(), 0, Projects);
 347         }
 348         break;
 349
 350         case WM_COMMAND:
 351             if (HIWORD(wParam) == BN_CLICKED && IDC_VIEWGPL == LOWORD(wParam))
 352             {
 353                 DialogBox(hDllInstance, MAKEINTRESOURCE(IDD_GPL), NULL, GplDlgProc);
 354                 SetForegroundWindow(GetParent(hwndDlg));
 355             }
 356             break;
 357
 358         case WM_NOTIFY:
 359         {
 360             lpnm = (LPNMHDR)lParam;
 361
 362             switch (lpnm->code)
 363             {
 364                 case PSN_SETACTIVE:
 365                     /* Enable the Back and Next buttons */
 366                     PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
 367                     if (SetupData.UnattendSetup)
 368                     {
 369                         SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, IDD_LOCALEPAGE);
 370                         return TRUE;
 371                     }
 372                     break;
 373
 374                 case PSN_WIZBACK:
 375                     SetupData.UnattendSetup = FALSE;
 376                     break;
 377
 378                 default:
 379                     break;
 380             }
 381         }
 382         break;
 383
 384         default:
 385             break;
 386     }
 387
 388     return FALSE;
 389 }
 390
 391 static
 392 BOOL
 393 WriteOwnerSettings(WCHAR * OwnerName,
 394                    WCHAR * OwnerOrganization)
 395 {
 396     HKEY hKey;
 397     LONG res;
 398
 399
 400
 401     res = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
 402                         L"Software\\Microsoft\\Windows NT\\CurrentVersion",
 403                         0,
 404                         KEY_ALL_ACCESS,
 405                         &hKey);
 406
 407     if (res != ERROR_SUCCESS)
 408     {
 409         return FALSE;
 410     }
 411
 412     res = RegSetValueExW(hKey,
 413                          L"RegisteredOwner",
 414                          0,
 415                          REG_SZ,
 416                          (LPBYTE)OwnerName,
 417                          (wcslen(OwnerName) + 1) * sizeof(WCHAR));
 418
 419     if (res != ERROR_SUCCESS)
 420     {
 421         RegCloseKey(hKey);
 422         return FALSE;
 423     }
 424
 425     res = RegSetValueExW(hKey,
 426                          L"RegisteredOrganization",
 427                          0,
 428                          REG_SZ,
 429                          (LPBYTE)OwnerOrganization,
 430                          (wcslen(OwnerOrganization) + 1) * sizeof(WCHAR));
 431
 432     RegCloseKey(hKey);
 433     return (res == ERROR_SUCCESS);
 434 }
 435
 436 static INT_PTR CALLBACK
 437 OwnerPageDlgProc(HWND hwndDlg,
 438                  UINT uMsg,
 439                  WPARAM wParam,
 440                  LPARAM lParam)
 441 {
 442     WCHAR OwnerName[51];
 443     WCHAR OwnerOrganization[51];
 444     WCHAR Title[64];
 445     WCHAR ErrorName[256];
 446     LPNMHDR lpnm;
 447
 448     switch (uMsg)
 449     {
 450         case WM_INITDIALOG:
 451         {
 452             SendDlgItemMessage(hwndDlg, IDC_OWNERNAME, EM_LIMITTEXT, 50, 0);
 453             SendDlgItemMessage(hwndDlg, IDC_OWNERORGANIZATION, EM_LIMITTEXT, 50, 0);
 454
 455             /* Set focus to owner name */
 456             SetFocus(GetDlgItem(hwndDlg, IDC_OWNERNAME));
 457         }
 458         break;
 459
 460
 461         case WM_NOTIFY:
 462         {
 463             lpnm = (LPNMHDR)lParam;
 464
 465             switch (lpnm->code)
 466             {
 467                 case PSN_SETACTIVE:
 468                     /* Enable the Back and Next buttons */
 469                     PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
 470                     if (SetupData.UnattendSetup)
 471                     {
 472                         SendMessage(GetDlgItem(hwndDlg, IDC_OWNERNAME), WM_SETTEXT, 0, (LPARAM)SetupData.OwnerName);
 473                         SendMessage(GetDlgItem(hwndDlg, IDC_OWNERORGANIZATION), WM_SETTEXT, 0, (LPARAM)SetupData.OwnerOrganization);
 474                         if (WriteOwnerSettings(SetupData.OwnerName, SetupData.OwnerOrganization))
 475                         {
 476                             SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, IDD_COMPUTERPAGE);
 477                             return TRUE;
 478                         }
 479                     }
 480                     break;
 481
 482                 case PSN_WIZNEXT:
 483                     OwnerName[0] = 0;
 484                     if (GetDlgItemTextW(hwndDlg, IDC_OWNERNAME, OwnerName, 50) == 0)
 485                     {
 486                         if (0 == LoadStringW(hDllInstance, IDS_REACTOS_SETUP, Title, sizeof(Title) / sizeof(Title[0])))
 487                         {
 488                             wcscpy(Title, L"ReactOS Setup");
 489                         }
 490                         if (0 == LoadStringW(hDllInstance, IDS_WZD_NAME, ErrorName, sizeof(ErrorName) / sizeof(ErrorName[0])))
 491                         {
 492                             wcscpy(ErrorName, L"Setup cannot continue until you enter your name.");
 493                         }
 494                         MessageBoxW(hwndDlg, ErrorName, Title, MB_ICONERROR | MB_OK);
 495
 496                         SetFocus(GetDlgItem(hwndDlg, IDC_OWNERNAME));
 497                         SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, -1);
 498
 499                         return TRUE;
 500                     }
 501
 502                     OwnerOrganization[0] = 0;
 503                     GetDlgItemTextW(hwndDlg, IDC_OWNERORGANIZATION, OwnerOrganization, 50);
 504
 505                     if (!WriteOwnerSettings(OwnerName, OwnerOrganization))
 506                     {
 507                         SetFocus(GetDlgItem(hwndDlg, IDC_OWNERNAME));
 508                         SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, -1);
 509                         return TRUE;
 510                     }
 511
 512                 case PSN_WIZBACK:
 513                     SetupData.UnattendSetup = FALSE;
 514                     break;
 515
 516                 default:
 517                     break;
 518             }
 519         }
 520         break;
 521
 522         default:
 523             break;
 524     }
 525
 526     return FALSE;
 527 }
 528
 529 static
 530 BOOL
 531 WriteComputerSettings(WCHAR * ComputerName, HWND hwndDlg)
 532 {
 533     WCHAR Title[64];
 534     WCHAR ErrorComputerName[256];
 535
 536     if (!SetComputerNameW(ComputerName))
 537     {
 538         if (hwndDlg != NULL)
 539         {
 540             if (0 == LoadStringW(hDllInstance, IDS_REACTOS_SETUP, Title, sizeof(Title) / sizeof(Title[0])))
 541             {
 542                 wcscpy(Title, L"ReactOS Setup");
 543             }
 544             if (0 == LoadStringW(hDllInstance, IDS_WZD_SETCOMPUTERNAME, ErrorComputerName,
 545                                  sizeof(ErrorComputerName) / sizeof(ErrorComputerName[0])))
 546             {
 547                 wcscpy(ErrorComputerName, L"Setup failed to set the computer name.");
 548             }
 549             MessageBoxW(hwndDlg, ErrorComputerName, Title, MB_ICONERROR | MB_OK);
 550         }
 551
 552         return FALSE;
 553     }
 554
 555     /* Try to also set DNS hostname */
 556     SetComputerNameExW(ComputerNamePhysicalDnsHostname, ComputerName);
 557
 558     /* Set the account domain name */
 559     SetAccountDomain(ComputerName, NULL);
 560
 561     return TRUE;
 562 }
 563
 564 /* lpBuffer will be filled with a 15-char string (plus the null terminator) */
 565 static void
 566 GenerateComputerName(LPWSTR lpBuffer)
 567 {
 568     static const WCHAR Chars[] = L"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 569     static const unsigned cChars = sizeof(Chars) / sizeof(WCHAR) - 1;
 570     unsigned i;
 571
 572     wcscpy(lpBuffer, L"REACTOS-");
 573
 574     srand(GetTickCount());
 575
 576     /* fill in 7 characters */
 577     for (i = 8; i < 15; i++)
 578         lpBuffer[i] = Chars[rand() % cChars];
 579
 580     lpBuffer[15] = UNICODE_NULL; /* NULL-terminate */
 581 }
 582
 583 static INT_PTR CALLBACK
 584 ComputerPageDlgProc(HWND hwndDlg,
 585                     UINT uMsg,
 586                     WPARAM wParam,
 587                     LPARAM lParam)
 588 {
 589     WCHAR ComputerName[MAX_COMPUTERNAME_LENGTH + 1];
 590     WCHAR Password1[15];
 591     WCHAR Password2[15];
 592     PWCHAR Password;
 593     WCHAR Title[64];
 594     WCHAR EmptyComputerName[256], NotMatchPassword[256], WrongPassword[256];
 595     LPNMHDR lpnm;
 596
 597     if (0 == LoadStringW(hDllInstance, IDS_REACTOS_SETUP, Title, sizeof(Title) / sizeof(Title[0])))
 598     {
 599         wcscpy(Title, L"ReactOS Setup");
 600     }
 601
 602     switch (uMsg)
 603     {
 604         case WM_INITDIALOG:
 605         {
 606             /* Generate a new pseudo-random computer name */
 607             GenerateComputerName(ComputerName);
 608
 609             /* Display current computer name */
 610             SetDlgItemTextW(hwndDlg, IDC_COMPUTERNAME, ComputerName);
 611
 612             /* Set text limits */
 613             SendDlgItemMessage(hwndDlg, IDC_COMPUTERNAME, EM_LIMITTEXT, MAX_COMPUTERNAME_LENGTH, 0);
 614             SendDlgItemMessage(hwndDlg, IDC_ADMINPASSWORD1, EM_LIMITTEXT, 14, 0);
 615             SendDlgItemMessage(hwndDlg, IDC_ADMINPASSWORD2, EM_LIMITTEXT, 14, 0);
 616
 617             /* Set focus to computer name */
 618             SetFocus(GetDlgItem(hwndDlg, IDC_COMPUTERNAME));
 619             if (SetupData.UnattendSetup)
 620             {
 621                 SendMessage(GetDlgItem(hwndDlg, IDC_COMPUTERNAME), WM_SETTEXT, 0, (LPARAM)SetupData.ComputerName);
 622                 SendMessage(GetDlgItem(hwndDlg, IDC_ADMINPASSWORD1), WM_SETTEXT, 0, (LPARAM)SetupData.AdminPassword);
 623                 SendMessage(GetDlgItem(hwndDlg, IDC_ADMINPASSWORD2), WM_SETTEXT, 0, (LPARAM)SetupData.AdminPassword);
 624                 WriteComputerSettings(SetupData.ComputerName, NULL);
 625                 SetAdministratorPassword(SetupData.AdminPassword);
 626             }
 627
 628         }
 629         break;
 630
 631
 632         case WM_NOTIFY:
 633         {
 634             lpnm = (LPNMHDR)lParam;
 635
 636             switch (lpnm->code)
 637             {
 638                 case PSN_SETACTIVE:
 639                     /* Enable the Back and Next buttons */
 640                     PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
 641                     if (SetupData.UnattendSetup && WriteComputerSettings(SetupData.ComputerName, hwndDlg))
 642                     {
 643                         SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, IDD_DATETIMEPAGE);
 644                         return TRUE;
 645                     }
 646                     break;
 647
 648                 case PSN_WIZNEXT:
 649                     if (0 == GetDlgItemTextW(hwndDlg, IDC_COMPUTERNAME, ComputerName, MAX_COMPUTERNAME_LENGTH + 1))
 650                     {
 651                         if (0 == LoadStringW(hDllInstance, IDS_WZD_COMPUTERNAME, EmptyComputerName,
 652                                              sizeof(EmptyComputerName) / sizeof(EmptyComputerName[0])))
 653                         {
 654                             wcscpy(EmptyComputerName, L"Setup cannot continue until you enter the name of your computer.");
 655                         }
 656                         MessageBoxW(hwndDlg, EmptyComputerName, Title, MB_ICONERROR | MB_OK);
 657                         SetFocus(GetDlgItem(hwndDlg, IDC_COMPUTERNAME));
 658                         SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, -1);
 659                         return TRUE;
 660                     }
 661
 662                     /* No need to check computer name for invalid characters,
 663                      * SetComputerName() will do it for us */
 664
 665                     if (!WriteComputerSettings(ComputerName, hwndDlg))
 666                     {
 667                         SetFocus(GetDlgItem(hwndDlg, IDC_COMPUTERNAME));
 668                         SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, -1);
 669                         return TRUE;
 670                     }
 671
 672 #if 0
 673                     /* Check if admin passwords have been entered */
 674                     if ((GetDlgItemText(hwndDlg, IDC_ADMINPASSWORD1, Password1, 15) == 0) ||
 675                             (GetDlgItemText(hwndDlg, IDC_ADMINPASSWORD2, Password2, 15) == 0))
 676                     {
 677                         if (0 == LoadStringW(hDllInstance, IDS_WZD_PASSWORDEMPTY, EmptyPassword,
 678                                              sizeof(EmptyPassword) / sizeof(EmptyPassword[0])))
 679                         {
 680                             wcscpy(EmptyPassword, L"You must enter a password !");
 681                         }
 682                         MessageBoxW(hwndDlg, EmptyPassword, Title, MB_ICONERROR | MB_OK);
 683                         SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, -1);
 684                         return TRUE;
 685                     }
 686 #else
 687                     GetDlgItemTextW(hwndDlg, IDC_ADMINPASSWORD1, Password1, 15);
 688                     GetDlgItemTextW(hwndDlg, IDC_ADMINPASSWORD2, Password2, 15);
 689 #endif
 690                     /* Check if passwords match */
 691                     if (wcscmp(Password1, Password2))
 692                     {
 693                         if (0 == LoadStringW(hDllInstance, IDS_WZD_PASSWORDMATCH, NotMatchPassword,
 694                                              sizeof(NotMatchPassword) / sizeof(NotMatchPassword[0])))
 695                         {
 696                             wcscpy(NotMatchPassword, L"The passwords you entered do not match. Please enter the desired password again.");
 697                         }
 698                         MessageBoxW(hwndDlg, NotMatchPassword, Title, MB_ICONERROR | MB_OK);
 699                         SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, -1);
 700                         return TRUE;
 701                     }
 702
 703                     /* Check password for invalid characters */
 704                     Password = (PWCHAR)Password1;
 705                     while (*Password)
 706                     {
 707                         if (!isprint(*Password))
 708                         {
 709                             if (0 == LoadStringW(hDllInstance, IDS_WZD_PASSWORDCHAR, WrongPassword,
 710                                                  sizeof(WrongPassword) / sizeof(WrongPassword[0])))
 711                             {
 712                                 wcscpy(WrongPassword, L"The password you entered contains invalid characters. Please enter a cleaned password.");
 713                             }
 714                             MessageBoxW(hwndDlg, WrongPassword, Title, MB_ICONERROR | MB_OK);
 715                             SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, -1);
 716                             return TRUE;
 717                         }
 718                         Password++;
 719                     }
 720
 721                     /* Set admin password */
 722                     SetAdministratorPassword(Password1);
 723                     break;
 724
 725                 case PSN_WIZBACK:
 726                     SetupData.UnattendSetup = FALSE;
 727                     break;
 728
 729                 default:
 730                     break;
 731             }
 732         }
 733         break;
 734
 735         default:
 736             break;
 737     }
 738
 739     return FALSE;
 740 }
 741
 742
 743 static VOID
 744 SetKeyboardLayoutName(HWND hwnd)
 745 {
 746 #if 0
 747     TCHAR szLayoutPath[256];
 748     TCHAR szLocaleName[32];
 749     DWORD dwLocaleSize;
 750     HKEY hKey;
 751
 752     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
 753                      _T("SYSTEM\\CurrentControlSet\\Control\\NLS\\Locale"),
 754                      0,
 755                      KEY_ALL_ACCESS,
 756                      &hKey))
 757         return;
 758
 759     dwValueSize = 16 * sizeof(TCHAR);
 760     if (RegQueryValueEx(hKey,
 761                         NULL,
 762                         NULL,
 763                         NULL,
 764                         szLocaleName,
 765                         &dwLocaleSize))
 766     {
 767         RegCloseKey(hKey);
 768         return;
 769     }
 770
 771     _tcscpy(szLayoutPath,
 772             _T("SYSTEM\\CurrentControlSet\\Control\\Keyboard Layouts\\"));
 773     _tcscat(szLayoutPath,
 774             szLocaleName);
 775
 776     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
 777                      szLayoutPath,
 778                      0,
 779                      KEY_ALL_ACCESS,
 780                      &hKey))
 781         return;
 782
 783     dwValueSize = 32 * sizeof(TCHAR);
 784     if (RegQueryValueEx(hKey,
 785                         _T("Layout Text"),
 786                         NULL,
 787                         NULL,
 788                         szLocaleName,
 789                         &dwLocaleSize))
 790     {
 791         RegCloseKey(hKey);
 792         return;
 793     }
 794
 795     RegCloseKey(hKey);
 796 #endif
 797 }
 798
 799
 800 static BOOL
 801 RunControlPanelApplet(HWND hwnd, PCWSTR pwszCPLParameters)
 802 {
 803     if (pwszCPLParameters)
 804     {
 805         STARTUPINFOW StartupInfo;
 806         PROCESS_INFORMATION ProcessInformation;
 807         WCHAR CmdLine[MAX_PATH] = L"rundll32.exe shell32.dll,Control_RunDLL ";
 808
 809         ZeroMemory(&StartupInfo, sizeof(StartupInfo));
 810         StartupInfo.cb = sizeof(StartupInfo);
 811
 812         ASSERT(_countof(CmdLine) > wcslen(CmdLine) + wcslen(pwszCPLParameters));
 813         wcscat(CmdLine, pwszCPLParameters);
 814
 815         if (!CreateProcessW(NULL,
 816                             CmdLine,
 817                             NULL,
 818                             NULL,
 819                             FALSE,
 820                             0,
 821                             NULL,
 822                             NULL,
 823                             &StartupInfo,
 824                             &ProcessInformation))
 825         {
 826             MessageBoxW(hwnd, L"Error: Failed to launch the Control Panel Applet.", NULL, MB_ICONERROR);
 827             return FALSE;
 828         }
 829
 830         WaitForSingleObject(ProcessInformation.hProcess, INFINITE);
 831         CloseHandle(ProcessInformation.hThread);
 832         CloseHandle(ProcessInformation.hProcess);
 833         return TRUE;
 834     }
 835     else
 836     {
 837         MessageBoxW(hwnd, L"Error: Failed to launch the Control Panel Applet.", NULL, MB_ICONERROR);
 838         return FALSE;
 839     }
 840 }
 841
 842 static VOID
 843 WriteUserLocale(VOID)
 844 {
 845     HKEY hKey;
 846     LCID lcid;
 847     WCHAR Locale[12];
 848
 849     lcid = GetSystemDefaultLCID();
 850
 851     if (GetLocaleInfoW(MAKELCID(lcid, SORT_DEFAULT), LOCALE_ILANGUAGE, Locale, sizeof(Locale) / sizeof(Locale[0])) != 0)
 852     {
 853         if (RegCreateKeyExW(HKEY_CURRENT_USER, L"Control Panel\\International",
 854                             0, NULL, REG_OPTION_NON_VOLATILE,
 855                             KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS)
 856         {
 857             RegSetValueExW(hKey, L"Locale", 0, REG_SZ, (LPBYTE)Locale, (wcslen(Locale) + 1) * sizeof(WCHAR));
 858             RegCloseKey(hKey);
 859         }
 860     }
 861 }
 862
 863 static INT_PTR CALLBACK
 864 LocalePageDlgProc(HWND hwndDlg,
 865                   UINT uMsg,
 866                   WPARAM wParam,
 867                   LPARAM lParam)
 868 {
 869     PSETUPDATA SetupData;
 870
 871     /* Retrieve pointer to the global setup data */
 872     SetupData = (PSETUPDATA)GetWindowLongPtr (hwndDlg, GWL_USERDATA);
 873
 874     switch (uMsg)
 875     {
 876         case WM_INITDIALOG:
 877         {
 878             /* Save pointer to the global setup data */
 879             SetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
 880             SetWindowLongPtr(hwndDlg, GWL_USERDATA, (DWORD_PTR)SetupData);
 881             WriteUserLocale();
 882
 883             SetKeyboardLayoutName(GetDlgItem(hwndDlg, IDC_LAYOUTTEXT));
 884         }
 885         break;
 886
 887         case WM_COMMAND:
 888             if (HIWORD(wParam) == BN_CLICKED)
 889             {
 890                 switch (LOWORD(wParam))
 891                 {
 892                     case IDC_CUSTOMLOCALE:
 893                         RunControlPanelApplet(hwndDlg, L"intl.cpl,,5");
 894                         /* FIXME: Update input locale name */
 895                         break;
 896
 897                     case IDC_CUSTOMLAYOUT:
 898                         RunControlPanelApplet(hwndDlg, L"input.dll,@1");
 899                         break;
 900                 }
 901             }
 902             break;
 903
 904         case WM_NOTIFY:
 905         {
 906             LPNMHDR lpnm = (LPNMHDR)lParam;
 907
 908             switch (lpnm->code)
 909             {
 910                 case PSN_SETACTIVE:
 911                     /* Enable the Back and Next buttons */
 912                     PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
 913                     if (SetupData->UnattendSetup)
 914                     {
 915                         WCHAR wszPath[MAX_PATH];
 916                         if (GetRosInstallCD(wszPath, _countof(wszPath)))
 917                         {
 918                             WCHAR wszParams[1024];
 919                             swprintf(wszParams, L"intl.cpl,,/f:\"%sreactos\\unattend.inf\"", wszPath);
 920                             RunControlPanelApplet(hwndDlg, wszParams);
 921                         }
 922                         else
 923                         {
 924                             RunControlPanelApplet(hwndDlg, L"intl.cpl,,/f:\"unattend.inf\"");
 925                         }
 926
 927                         SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, IDD_OWNERPAGE);
 928                         return TRUE;
 929                     }
 930                     break;
 931
 932                 case PSN_WIZNEXT:
 933                     break;
 934
 935                 case PSN_WIZBACK:
 936                     SetupData->UnattendSetup = FALSE;
 937                     break;
 938
 939                 default:
 940                     break;
 941             }
 942         }
 943         break;
 944
 945         default:
 946             break;
 947     }
 948
 949     return FALSE;
 950 }
 951
 952
 953 static PTIMEZONE_ENTRY
 954 GetLargerTimeZoneEntry(PSETUPDATA SetupData, DWORD Index)
 955 {
 956     PTIMEZONE_ENTRY Entry;
 957
 958     Entry = SetupData->TimeZoneListHead;
 959     while (Entry != NULL)
 960     {
 961         if (Entry->Index >= Index)
 962             return Entry;
 963
 964         Entry = Entry->Next;
 965     }
 966
 967     return NULL;
 968 }
 969
 970
 971 static VOID
 972 CreateTimeZoneList(PSETUPDATA SetupData)
 973 {
 974     WCHAR szKeyName[256];
 975     DWORD dwIndex;
 976     DWORD dwNameSize;
 977     DWORD dwValueSize;
 978     LONG lError;
 979     HKEY hZonesKey;
 980     HKEY hZoneKey;
 981
 982     PTIMEZONE_ENTRY Entry;
 983     PTIMEZONE_ENTRY Current;
 984
 985     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
 986                       L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones",
 987                       0,
 988                       KEY_ALL_ACCESS,
 989                       &hZonesKey))
 990         return;
 991
 992     dwIndex = 0;
 993     while (TRUE)
 994     {
 995         dwNameSize = 256 * sizeof(WCHAR);
 996         lError = RegEnumKeyExW(hZonesKey,
 997                                dwIndex,
 998                                szKeyName,
 999                                &dwNameSize,
1000                                NULL,
1001                                NULL,
1002                                NULL,
1003                                NULL);
1004         if (lError != ERROR_SUCCESS && lError != ERROR_MORE_DATA)
1005             break;
1006
1007         if (RegOpenKeyExW(hZonesKey,
1008                           szKeyName,
1009                           0,
1010                           KEY_ALL_ACCESS,
1011                           &hZoneKey))
1012             break;
1013
1014         Entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TIMEZONE_ENTRY));
1015         if (Entry == NULL)
1016         {
1017             RegCloseKey(hZoneKey);
1018             break;
1019         }
1020
1021         dwValueSize = 64 * sizeof(WCHAR);
1022         if (RegQueryValueExW(hZoneKey,
1023                              L"Display",
1024                              NULL,
1025                              NULL,
1026                              (LPBYTE)&Entry->Description,
1027                              &dwValueSize))
1028         {
1029             RegCloseKey(hZoneKey);
1030             break;
1031         }
1032
1033         dwValueSize = 32 * sizeof(WCHAR);
1034         if (RegQueryValueExW(hZoneKey,
1035                              L"Std",
1036                              NULL,
1037                              NULL,
1038                              (LPBYTE)&Entry->StandardName,
1039                              &dwValueSize))
1040         {
1041             RegCloseKey(hZoneKey);
1042             break;
1043         }
1044
1045         dwValueSize = 32 * sizeof(WCHAR);
1046         if (RegQueryValueExW(hZoneKey,
1047                              L"Dlt",
1048                              NULL,
1049                              NULL,
1050                              (LPBYTE)&Entry->DaylightName,
1051                              &dwValueSize))
1052         {
1053             RegCloseKey(hZoneKey);
1054             break;
1055         }
1056
1057         dwValueSize = sizeof(DWORD);
1058         if (RegQueryValueExW(hZoneKey,
1059                              L"Index",
1060                              NULL,
1061                              NULL,
1062                              (LPBYTE)&Entry->Index,
1063                              &dwValueSize))
1064         {
1065             RegCloseKey(hZoneKey);
1066             break;
1067         }
1068
1069         dwValueSize = sizeof(TZ_INFO);
1070         if (RegQueryValueExW(hZoneKey,
1071                              L"TZI",
1072                              NULL,
1073                              NULL,
1074                              (LPBYTE)&Entry->TimezoneInfo,
1075                              &dwValueSize))
1076         {
1077             RegCloseKey(hZoneKey);
1078             break;
1079         }
1080
1081         RegCloseKey(hZoneKey);
1082
1083         if (SetupData->TimeZoneListHead == NULL &&
1084                 SetupData->TimeZoneListTail == NULL)
1085         {
1086             Entry->Prev = NULL;
1087             Entry->Next = NULL;
1088             SetupData->TimeZoneListHead = Entry;
1089             SetupData->TimeZoneListTail = Entry;
1090         }
1091         else
1092         {
1093             Current = GetLargerTimeZoneEntry(SetupData, Entry->Index);
1094             if (Current != NULL)
1095             {
1096                 if (Current == SetupData->TimeZoneListHead)
1097                 {
1098                     /* Prepend to head */
1099                     Entry->Prev = NULL;
1100                     Entry->Next = SetupData->TimeZoneListHead;
1101                     SetupData->TimeZoneListHead->Prev = Entry;
1102                     SetupData->TimeZoneListHead = Entry;
1103                 }
1104                 else
1105                 {
1106                     /* Insert before current */
1107                     Entry->Prev = Current->Prev;
1108                     Entry->Next = Current;
1109                     Current->Prev->Next = Entry;
1110                     Current->Prev = Entry;
1111                 }
1112             }
1113             else
1114             {
1115                 /* Append to tail */
1116                 Entry->Prev = SetupData->TimeZoneListTail;
1117                 Entry->Next = NULL;
1118                 SetupData->TimeZoneListTail->Next = Entry;
1119                 SetupData->TimeZoneListTail = Entry;
1120             }
1121         }
1122
1123         dwIndex++;
1124     }
1125
1126     RegCloseKey(hZonesKey);
1127 }
1128
1129
1130 static VOID
1131 DestroyTimeZoneList(PSETUPDATA SetupData)
1132 {
1133     PTIMEZONE_ENTRY Entry;
1134
1135     while (SetupData->TimeZoneListHead != NULL)
1136     {
1137         Entry = SetupData->TimeZoneListHead;
1138
1139         SetupData->TimeZoneListHead = Entry->Next;
1140         if (SetupData->TimeZoneListHead != NULL)
1141         {
1142             SetupData->TimeZoneListHead->Prev = NULL;
1143         }
1144
1145         HeapFree(GetProcessHeap(), 0, Entry);
1146     }
1147
1148     SetupData->TimeZoneListTail = NULL;
1149 }
1150
1151 static BOOL
1152 GetTimeZoneListIndex(LPDWORD lpIndex)
1153 {
1154     WCHAR szLanguageIdString[9];
1155     HKEY hKey;
1156     DWORD dwValueSize;
1157     DWORD Length;
1158     LPWSTR Buffer;
1159     LPWSTR Ptr;
1160     LPWSTR End;
1161     BOOL bFound = FALSE;
1162     unsigned long iLanguageID;
1163
1164     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
1165                       L"SYSTEM\\CurrentControlSet\\Control\\NLS\\Language",
1166                       0,
1167                       KEY_ALL_ACCESS,
1168                       &hKey))
1169         return FALSE;
1170
1171     dwValueSize = 9 * sizeof(WCHAR);
1172     if (RegQueryValueExW(hKey,
1173                          L"Default",
1174                          NULL,
1175                          NULL,
1176                          (LPBYTE)szLanguageIdString,
1177                          &dwValueSize))
1178     {
1179         RegCloseKey(hKey);
1180         return FALSE;
1181     }
1182
1183     iLanguageID = wcstoul(szLanguageIdString, NULL, 16);
1184     RegCloseKey(hKey);
1185
1186     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
1187                       L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones",
1188                       0,
1189                       KEY_ALL_ACCESS,
1190                       &hKey))
1191         return FALSE;
1192
1193     dwValueSize = 0;
1194     if (RegQueryValueExW(hKey,
1195                          L"IndexMapping",
1196                          NULL,
1197                          NULL,
1198                          NULL,
1199                          &dwValueSize))
1200     {
1201         RegCloseKey(hKey);
1202         return FALSE;
1203     }
1204
1205     Buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwValueSize);
1206     if (Buffer == NULL)
1207     {
1208         RegCloseKey(hKey);
1209         return FALSE;
1210     }
1211
1212     if (RegQueryValueExW(hKey,
1213                          L"IndexMapping",
1214                          NULL,
1215                          NULL,
1216                          (LPBYTE)Buffer,
1217                          &dwValueSize))
1218     {
1219         HeapFree(GetProcessHeap(), 0, Buffer);
1220         RegCloseKey(hKey);
1221         return FALSE;
1222     }
1223
1224     RegCloseKey(hKey);
1225
1226     Ptr = Buffer;
1227     while (*Ptr != 0)
1228     {
1229         Length = wcslen(Ptr);
1230         if (wcstoul(Ptr, NULL, 16) == iLanguageID)
1231             bFound = TRUE;
1232
1233         Ptr = Ptr + Length + 1;
1234         if (*Ptr == 0)
1235             break;
1236
1237         if (bFound)
1238         {
1239             *lpIndex = wcstoul(Ptr, &End, 10);
1240             HeapFree(GetProcessHeap(), 0, Buffer);
1241             return TRUE;
1242         }
1243
1244         Length = wcslen(Ptr);
1245         Ptr = Ptr + Length + 1;
1246     }
1247
1248     HeapFree(GetProcessHeap(), 0, Buffer);
1249
1250     return FALSE;
1251 }
1252
1253
1254 static VOID
1255 ShowTimeZoneList(HWND hwnd, PSETUPDATA SetupData, DWORD dwEntryIndex)
1256 {
1257     PTIMEZONE_ENTRY Entry;
1258     DWORD dwIndex = 0;
1259     DWORD dwCount;
1260
1261     GetTimeZoneListIndex(&dwEntryIndex);
1262
1263     Entry = SetupData->TimeZoneListHead;
1264     while (Entry != NULL)
1265     {
1266         dwCount = SendMessage(hwnd,
1267                               CB_ADDSTRING,
1268                               0,
1269                               (LPARAM)Entry->Description);
1270
1271         if (dwEntryIndex != 0 && dwEntryIndex == Entry->Index)
1272             dwIndex = dwCount;
1273
1274         Entry = Entry->Next;
1275     }
1276
1277     SendMessage(hwnd,
1278                 CB_SETCURSEL,
1279                 (WPARAM)dwIndex,
1280                 0);
1281 }
1282
1283
1284 static VOID
1285 SetLocalTimeZone(HWND hwnd, PSETUPDATA SetupData)
1286 {
1287     TIME_ZONE_INFORMATION TimeZoneInformation;
1288     PTIMEZONE_ENTRY Entry;
1289     DWORD dwIndex;
1290     DWORD i;
1291
1292     dwIndex = SendMessage(hwnd,
1293                           CB_GETCURSEL,
1294                           0,
1295                           0);
1296
1297     i = 0;
1298     Entry = SetupData->TimeZoneListHead;
1299     while (i < dwIndex)
1300     {
1301         if (Entry == NULL)
1302             return;
1303
1304         i++;
1305         Entry = Entry->Next;
1306     }
1307
1308     wcscpy(TimeZoneInformation.StandardName,
1309            Entry->StandardName);
1310     wcscpy(TimeZoneInformation.DaylightName,
1311            Entry->DaylightName);
1312
1313     TimeZoneInformation.Bias = Entry->TimezoneInfo.Bias;
1314     TimeZoneInformation.StandardBias = Entry->TimezoneInfo.StandardBias;
1315     TimeZoneInformation.DaylightBias = Entry->TimezoneInfo.DaylightBias;
1316
1317     memcpy(&TimeZoneInformation.StandardDate,
1318            &Entry->TimezoneInfo.StandardDate,
1319            sizeof(SYSTEMTIME));
1320     memcpy(&TimeZoneInformation.DaylightDate,
1321            &Entry->TimezoneInfo.DaylightDate,
1322            sizeof(SYSTEMTIME));
1323
1324     /* Set time zone information */
1325     SetTimeZoneInformation(&TimeZoneInformation);
1326 }
1327
1328
1329 static BOOL
1330 GetLocalSystemTime(HWND hwnd, PSETUPDATA SetupData)
1331 {
1332     SYSTEMTIME Date;
1333     SYSTEMTIME Time;
1334
1335     if (DateTime_GetSystemtime(GetDlgItem(hwnd, IDC_DATEPICKER), &Date) != GDT_VALID)
1336     {
1337         return FALSE;
1338     }
1339
1340     if (DateTime_GetSystemtime(GetDlgItem(hwnd, IDC_TIMEPICKER), &Time) != GDT_VALID)
1341     {
1342         return FALSE;
1343     }
1344
1345     SetupData->SystemTime.wYear = Date.wYear;
1346     SetupData->SystemTime.wMonth = Date.wMonth;
1347     SetupData->SystemTime.wDayOfWeek = Date.wDayOfWeek;
1348     SetupData->SystemTime.wDay = Date.wDay;
1349     SetupData->SystemTime.wHour = Time.wHour;
1350     SetupData->SystemTime.wMinute = Time.wMinute;
1351     SetupData->SystemTime.wSecond = Time.wSecond;
1352     SetupData->SystemTime.wMilliseconds = Time.wMilliseconds;
1353
1354     return TRUE;
1355 }
1356
1357
1358 static VOID
1359 SetAutoDaylightInfo(HWND hwnd)
1360 {
1361     HKEY hKey;
1362     DWORD dwValue = 1;
1363
1364     if (SendMessage(hwnd, BM_GETCHECK, 0, 0) == BST_UNCHECKED)
1365     {
1366         if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
1367                           L"SYSTEM\\CurrentControlSet\\Control\\TimeZoneInformation",
1368                           0,
1369                           KEY_SET_VALUE,
1370                           &hKey))
1371             return;
1372
1373         RegSetValueExW(hKey,
1374                        L"DisableAutoDaylightTimeSet",
1375                        0,
1376                        REG_DWORD,
1377                        (LPBYTE)&dwValue,
1378                        sizeof(DWORD));
1379         RegCloseKey(hKey);
1380     }
1381 }
1382
1383
1384 static BOOL
1385 SetSystemLocalTime(HWND hwnd, PSETUPDATA SetupData)
1386 {
1387     BOOL Ret = FALSE;
1388
1389     /*
1390      * Call SetLocalTime twice to ensure correct results
1391      */
1392     Ret = SetLocalTime(&SetupData->SystemTime) &&
1393           SetLocalTime(&SetupData->SystemTime);
1394
1395     return Ret;
1396 }
1397
1398 static BOOL
1399 WriteDateTimeSettings(HWND hwndDlg, PSETUPDATA SetupData)
1400 {
1401     WCHAR Title[64];
1402     WCHAR ErrorLocalTime[256];
1403     GetLocalSystemTime(hwndDlg, SetupData);
1404     SetLocalTimeZone(GetDlgItem(hwndDlg, IDC_TIMEZONELIST),
1405                      SetupData);
1406
1407     SetAutoDaylightInfo(GetDlgItem(hwndDlg, IDC_AUTODAYLIGHT));
1408     if(!SetSystemLocalTime(hwndDlg, SetupData))
1409     {
1410         if (0 == LoadStringW(hDllInstance, IDS_REACTOS_SETUP, Title, sizeof(Title) / sizeof(Title[0])))
1411         {
1412             wcscpy(Title, L"ReactOS Setup");
1413         }
1414         if (0 == LoadStringW(hDllInstance, IDS_WZD_LOCALTIME, ErrorLocalTime,
1415                              sizeof(ErrorLocalTime) / sizeof(ErrorLocalTime[0])))
1416         {
1417             wcscpy(ErrorLocalTime, L"Setup was unable to set the local time.");
1418         }
1419         MessageBoxW(hwndDlg, ErrorLocalTime, Title, MB_ICONWARNING | MB_OK);
1420         return FALSE;
1421     }
1422
1423     return TRUE;
1424 }
1425
1426 static INT_PTR CALLBACK
1427 DateTimePageDlgProc(HWND hwndDlg,
1428                     UINT uMsg,
1429                     WPARAM wParam,
1430                     LPARAM lParam)
1431 {
1432     PSETUPDATA SetupData;
1433
1434     /* Retrieve pointer to the global setup data */
1435     SetupData = (PSETUPDATA)GetWindowLongPtr (hwndDlg, GWL_USERDATA);
1436
1437     switch (uMsg)
1438     {
1439         case WM_INITDIALOG:
1440         {
1441             /* Save pointer to the global setup data */
1442             SetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
1443             SetWindowLongPtr(hwndDlg, GWL_USERDATA, (DWORD_PTR)SetupData);
1444
1445             CreateTimeZoneList(SetupData);
1446
1447             if (SetupData->UnattendSetup)
1448             {
1449                 ShowTimeZoneList(GetDlgItem(hwndDlg, IDC_TIMEZONELIST),
1450                                  SetupData, SetupData->TimeZoneIndex);
1451
1452                 if (!SetupData->DisableAutoDaylightTimeSet)
1453                 {
1454                     SendDlgItemMessage(hwndDlg, IDC_AUTODAYLIGHT, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
1455                 }
1456             }
1457             else
1458             {
1459                 ShowTimeZoneList(GetDlgItem(hwndDlg, IDC_TIMEZONELIST),
1460                                  SetupData, 85 /* GMT time zone */);
1461
1462                 SendDlgItemMessage(hwndDlg, IDC_AUTODAYLIGHT, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
1463             }
1464
1465         }
1466         break;
1467
1468
1469         case WM_NOTIFY:
1470         {
1471             LPNMHDR lpnm = (LPNMHDR)lParam;
1472
1473             switch (lpnm->code)
1474             {
1475                 case PSN_SETACTIVE:
1476                     /* Enable the Back and Next buttons */
1477                     PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
1478                     if (SetupData->UnattendSetup && WriteDateTimeSettings(hwndDlg, SetupData))
1479                     {
1480                         SetWindowLongPtr(hwndDlg, DWL_MSGRESULT, IDD_PROCESSPAGE);
1481                         return TRUE;
1482                     }
1483                     break;
1484
1485                 case PSN_WIZNEXT:
1486                 {
1487                     WriteDateTimeSettings(hwndDlg, SetupData);
1488                 }
1489                 break;
1490
1491                 case PSN_WIZBACK:
1492                     SetupData->UnattendSetup = FALSE;
1493                     break;
1494
1495                 default:
1496                     break;
1497             }
1498         }
1499         break;
1500
1501         case WM_DESTROY:
1502             DestroyTimeZoneList(SetupData);
1503             break;
1504
1505         default:
1506             break;
1507     }
1508
1509     return FALSE;
1510 }
1511
1512
1513 static UINT CALLBACK
1514 RegistrationNotificationProc(PVOID Context,
1515                              UINT Notification,
1516                              UINT_PTR Param1,
1517                              UINT_PTR Param2)
1518 {
1519     PREGISTRATIONDATA RegistrationData;
1520     REGISTRATIONNOTIFY RegistrationNotify;
1521     PSP_REGISTER_CONTROL_STATUSW StatusInfo;
1522     UINT MessageID;
1523     WCHAR ErrorMessage[128];
1524
1525     RegistrationData = (PREGISTRATIONDATA) Context;
1526
1527     if (SPFILENOTIFY_STARTREGISTRATION == Notification ||
1528             SPFILENOTIFY_ENDREGISTRATION == Notification)
1529     {
1530         StatusInfo = (PSP_REGISTER_CONTROL_STATUSW) Param1;
1531         RegistrationNotify.CurrentItem = wcsrchr(StatusInfo->FileName, L'\\');
1532         if (NULL == RegistrationNotify.CurrentItem)
1533         {
1534             RegistrationNotify.CurrentItem = StatusInfo->FileName;
1535         }
1536         else
1537         {
1538             RegistrationNotify.CurrentItem++;
1539         }
1540
1541         if (SPFILENOTIFY_STARTREGISTRATION == Notification)
1542         {
1543             DPRINT("Received SPFILENOTIFY_STARTREGISTRATION notification for %S\n",
1544                    StatusInfo->FileName);
1545             RegistrationNotify.ErrorMessage = NULL;
1546             RegistrationNotify.Progress = RegistrationData->Registered;
1547         }
1548         else
1549         {
1550             DPRINT("Received SPFILENOTIFY_ENDREGISTRATION notification for %S\n",
1551                    StatusInfo->FileName);
1552             DPRINT("Win32Error %u FailureCode %u\n", StatusInfo->Win32Error,
1553                    StatusInfo->FailureCode);
1554             if (SPREG_SUCCESS != StatusInfo->FailureCode)
1555             {
1556                 switch(StatusInfo->FailureCode)
1557                 {
1558                     case SPREG_LOADLIBRARY:
1559                         MessageID = IDS_LOADLIBRARY_FAILED;
1560                         break;
1561                     case SPREG_GETPROCADDR:
1562                         MessageID = IDS_GETPROCADDR_FAILED;
1563                         break;
1564                     case SPREG_REGSVR:
1565                         MessageID = IDS_REGSVR_FAILED;
1566                         break;
1567                     case SPREG_DLLINSTALL:
1568                         MessageID = IDS_DLLINSTALL_FAILED;
1569                         break;
1570                     case SPREG_TIMEOUT:
1571                         MessageID = IDS_TIMEOUT;
1572                         break;
1573                     default:
1574                         MessageID = IDS_REASON_UNKNOWN;
1575                         break;
1576                 }
1577                 if (0 == LoadStringW(hDllInstance, MessageID,
1578                                      ErrorMessage,
1579                                      sizeof(ErrorMessage) /
1580                                      sizeof(ErrorMessage[0])))
1581                 {
1582                     ErrorMessage[0] = L'\0';
1583                 }
1584                 if (SPREG_TIMEOUT != StatusInfo->FailureCode)
1585                 {
1586                     FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL,
1587                                    StatusInfo->Win32Error, 0,
1588                                    ErrorMessage + wcslen(ErrorMessage),
1589                                    sizeof(ErrorMessage) / sizeof(ErrorMessage[0]) -
1590                                    wcslen(ErrorMessage), NULL);
1591                 }
1592                 RegistrationNotify.ErrorMessage = ErrorMessage;
1593             }
1594             else
1595             {
1596                 RegistrationNotify.ErrorMessage = NULL;
1597             }
1598             if (RegistrationData->Registered < RegistrationData->DllCount)
1599             {
1600                 RegistrationData->Registered++;
1601             }
1602         }
1603
1604         RegistrationNotify.Progress = RegistrationData->Registered;
1605         RegistrationNotify.ActivityID = IDS_REGISTERING_COMPONENTS;
1606         SendMessage(RegistrationData->hwndDlg, PM_REGISTRATION_NOTIFY,
1607                     0, (LPARAM) &RegistrationNotify);
1608
1609         return FILEOP_DOIT;
1610     }
1611     else
1612     {
1613         DPRINT1("Received unexpected notification %u\n", Notification);
1614         return SetupDefaultQueueCallback(RegistrationData->DefaultContext,
1615                                          Notification, Param1, Param2);
1616     }
1617 }
1618
1619
1620 static DWORD CALLBACK
1621 RegistrationProc(LPVOID Parameter)
1622 {
1623     PREGISTRATIONDATA RegistrationData;
1624     REGISTRATIONNOTIFY RegistrationNotify;
1625     DWORD LastError = NO_ERROR;
1626     WCHAR UnknownError[84];
1627
1628     RegistrationData = (PREGISTRATIONDATA) Parameter;
1629     RegistrationData->Registered = 0;
1630     RegistrationData->DefaultContext = SetupInitDefaultQueueCallback(RegistrationData->hwndDlg);
1631
1632     _SEH2_TRY
1633     {
1634         if (!SetupInstallFromInfSectionW(GetParent(RegistrationData->hwndDlg),
1635         hSysSetupInf,
1636         L"RegistrationPhase2",
1637         SPINST_REGISTRY |
1638         SPINST_REGISTERCALLBACKAWARE  |
1639         SPINST_REGSVR,
1640         0,
1641         NULL,
1642         0,
1643         RegistrationNotificationProc,
1644         RegistrationData,
1645         NULL,
1646         NULL))
1647         {
1648             LastError = GetLastError();
1649         }
1650     }
1651     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1652     {
1653         DPRINT("Catching exception\n");
1654         LastError = RtlNtStatusToDosError(_SEH2_GetExceptionCode());
1655     }
1656     _SEH2_END;
1657
1658     if (NO_ERROR == LastError)
1659     {
1660         RegistrationNotify.ErrorMessage = NULL;
1661     }
1662     else
1663     {
1664         DPRINT1("SetupInstallFromInfSection failed with error %u\n",
1665                 LastError);
1666         if (0 == FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1667                                 FORMAT_MESSAGE_FROM_SYSTEM, NULL, LastError, 0,
1668                                 (LPWSTR) &RegistrationNotify.ErrorMessage, 0,
1669                                 NULL))
1670         {
1671             if (0 == LoadStringW(hDllInstance, IDS_UNKNOWN_ERROR,
1672                                  UnknownError,
1673                                  sizeof(UnknownError) / sizeof(UnknownError[0]) -
1674                                  20))
1675             {
1676                 wcscpy(UnknownError, L"Unknown error");
1677             }
1678             wcscat(UnknownError, L" ");
1679             _ultow(LastError, UnknownError + wcslen(UnknownError), 10);
1680             RegistrationNotify.ErrorMessage = UnknownError;
1681         }
1682     }
1683
1684     RegistrationNotify.Progress = RegistrationData->DllCount;
1685     RegistrationNotify.ActivityID = IDS_REGISTERING_COMPONENTS;
1686     RegistrationNotify.CurrentItem = NULL;
1687     SendMessage(RegistrationData->hwndDlg, PM_REGISTRATION_NOTIFY,
1688                 1, (LPARAM) &RegistrationNotify);
1689     if (NULL != RegistrationNotify.ErrorMessage &&
1690             UnknownError != RegistrationNotify.ErrorMessage)
1691     {
1692         LocalFree((PVOID) RegistrationNotify.ErrorMessage);
1693     }
1694
1695     SetupTermDefaultQueueCallback(RegistrationData->DefaultContext);
1696     HeapFree(GetProcessHeap(), 0, RegistrationData);
1697
1698     RegisterTypeLibraries(hSysSetupInf, L"TypeLibraries");
1699
1700     // FIXME: Move this call to a separate cleanup page!
1701     RtlCreateBootStatusDataFile();
1702
1703     return 0;
1704 }
1705
1706
1707 static BOOL
1708 StartComponentRegistration(HWND hwndDlg, PULONG MaxProgress)
1709 {
1710     HANDLE RegistrationThread;
1711     LONG DllCount;
1712     INFCONTEXT Context;
1713     WCHAR SectionName[512];
1714     PREGISTRATIONDATA RegistrationData;
1715
1716     DllCount = -1;
1717     if (! SetupFindFirstLineW(hSysSetupInf, L"RegistrationPhase2",
1718                               L"RegisterDlls", &Context))
1719     {
1720         DPRINT1("No RegistrationPhase2 section found\n");
1721         return FALSE;
1722     }
1723     if (! SetupGetStringFieldW(&Context, 1, SectionName,
1724                                sizeof(SectionName) / sizeof(SectionName[0]),
1725                                NULL))
1726     {
1727         DPRINT1("Unable to retrieve section name\n");
1728         return FALSE;
1729     }
1730     DllCount = SetupGetLineCountW(hSysSetupInf, SectionName);
1731     DPRINT("SectionName %S DllCount %ld\n", SectionName, DllCount);
1732     if (DllCount < 0)
1733     {
1734         SetLastError(STATUS_NOT_FOUND);
1735         return FALSE;
1736     }
1737
1738     *MaxProgress = (ULONG) DllCount;
1739
1740     /*
1741      * Create a background thread to do the actual registrations, so the
1742      * main thread can just run its message loop.
1743      */
1744     RegistrationThread = NULL;
1745     RegistrationData = HeapAlloc(GetProcessHeap(), 0,
1746                                  sizeof(REGISTRATIONDATA));
1747     if (RegistrationData != NULL)
1748     {
1749         RegistrationData->hwndDlg = hwndDlg;
1750         RegistrationData->DllCount = DllCount;
1751         RegistrationThread = CreateThread(NULL, 0, RegistrationProc,
1752                                           (LPVOID) RegistrationData, 0, NULL);
1753         if (RegistrationThread != NULL)
1754         {
1755             CloseHandle(RegistrationThread);
1756         }
1757         else
1758         {
1759             DPRINT1("CreateThread failed, error %u\n", GetLastError());
1760             HeapFree(GetProcessHeap(), 0, RegistrationData);
1761             return FALSE;
1762         }
1763     }
1764     else
1765     {
1766         DPRINT1("HeapAlloc() failed, error %u\n", GetLastError());
1767         return FALSE;
1768     }
1769
1770     return TRUE;
1771 }
1772
1773
1774 static INT_PTR CALLBACK
1775 ProcessPageDlgProc(HWND hwndDlg,
1776                    UINT uMsg,
1777                    WPARAM wParam,
1778                    LPARAM lParam)
1779 {
1780     PSETUPDATA SetupData;
1781     PREGISTRATIONNOTIFY RegistrationNotify;
1782     static UINT oldActivityID = -1;
1783     WCHAR Title[64];
1784
1785     /* Retrieve pointer to the global setup data */
1786     SetupData = (PSETUPDATA)GetWindowLongPtr (hwndDlg, GWL_USERDATA);
1787
1788     switch (uMsg)
1789     {
1790         case WM_INITDIALOG:
1791         {
1792             /* Save pointer to the global setup data */
1793             SetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
1794             SetWindowLongPtr(hwndDlg, GWL_USERDATA, (DWORD_PTR)SetupData);
1795         }
1796         break;
1797
1798         case WM_NOTIFY:
1799         {
1800             LPNMHDR lpnm = (LPNMHDR)lParam;
1801             ULONG MaxProgress = 0;
1802
1803             switch (lpnm->code)
1804             {
1805                 case PSN_SETACTIVE:
1806                     /* Disable the Back and Next buttons */
1807                     PropSheet_SetWizButtons(GetParent(hwndDlg), 0);
1808
1809                     StartComponentRegistration(hwndDlg, &MaxProgress);
1810
1811                     SendDlgItemMessage(hwndDlg, IDC_PROCESSPROGRESS, PBM_SETRANGE,
1812                                        0, MAKELPARAM(0, MaxProgress));
1813                     SendDlgItemMessage(hwndDlg, IDC_PROCESSPROGRESS, PBM_SETPOS,
1814                                        0, 0);
1815                     break;
1816
1817                 case PSN_WIZNEXT:
1818                     break;
1819
1820                 case PSN_WIZBACK:
1821                     SetupData->UnattendSetup = FALSE;
1822                     break;
1823
1824                 default:
1825                     break;
1826             }
1827         }
1828         break;
1829
1830         case PM_REGISTRATION_NOTIFY:
1831         {
1832             WCHAR Activity[64];
1833             RegistrationNotify = (PREGISTRATIONNOTIFY) lParam;
1834             // update if necessary only
1835             if (oldActivityID != RegistrationNotify->ActivityID)
1836             {
1837                 if (0 != LoadStringW(hDllInstance, RegistrationNotify->ActivityID,
1838                                      Activity,
1839                                      sizeof(Activity) / sizeof(Activity[0])))
1840                 {
1841                     SendDlgItemMessageW(hwndDlg, IDC_ACTIVITY, WM_SETTEXT,
1842                                         0, (LPARAM) Activity);
1843                 }
1844                 oldActivityID = RegistrationNotify->ActivityID;
1845             }
1846             SendDlgItemMessageW(hwndDlg, IDC_ITEM, WM_SETTEXT, 0,
1847                                 (LPARAM)(NULL == RegistrationNotify->CurrentItem ?
1848                                          L"" : RegistrationNotify->CurrentItem));
1849             SendDlgItemMessage(hwndDlg, IDC_PROCESSPROGRESS, PBM_SETPOS,
1850                                RegistrationNotify->Progress, 0);
1851             if (NULL != RegistrationNotify->ErrorMessage)
1852             {
1853                 if (0 == LoadStringW(hDllInstance, IDS_REACTOS_SETUP,
1854                                      Title, sizeof(Title) / sizeof(Title[0])))
1855                 {
1856                     wcscpy(Title, L"ReactOS Setup");
1857                 }
1858                 MessageBoxW(hwndDlg, RegistrationNotify->ErrorMessage,
1859                             Title, MB_ICONERROR | MB_OK);
1860
1861             }
1862
1863             if (wParam)
1864             {
1865 #ifdef VMWINST
1866                 if(!SetupData->UnattendSetup && !SetupData->DisableVmwInst)
1867                     RunVMWInstall(GetParent(hwndDlg));
1868 #endif
1869
1870                 /* Enable the Back and Next buttons */
1871                 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT);
1872                 PropSheet_PressButton(GetParent(hwndDlg), PSBTN_NEXT);
1873             }
1874         }
1875         return TRUE;
1876
1877         default:
1878             break;
1879     }
1880
1881     return FALSE;
1882 }
1883
1884
1885 static VOID
1886 SetInstallationCompleted(VOID)
1887 {
1888     HKEY hKey = 0;
1889     DWORD InProgress = 0;
1890     DWORD InstallDate;
1891
1892     if (RegOpenKeyExW( HKEY_LOCAL_MACHINE,
1893                        L"SYSTEM\\Setup",
1894                        0,
1895                        KEY_WRITE,
1896                        &hKey ) == ERROR_SUCCESS)
1897     {
1898         RegSetValueExW( hKey, L"SystemSetupInProgress", 0, REG_DWORD, (LPBYTE)&InProgress, sizeof(InProgress) );
1899         RegCloseKey( hKey );
1900     }
1901
1902     if (RegOpenKeyExW( HKEY_LOCAL_MACHINE,
1903                        L"Software\\Microsoft\\Windows NT\\CurrentVersion",
1904                        0,
1905                        KEY_WRITE,
1906                        &hKey ) == ERROR_SUCCESS)
1907     {
1908         InstallDate = (DWORD)time(NULL);
1909         RegSetValueExW( hKey, L"InstallDate", 0, REG_DWORD, (LPBYTE)&InstallDate, sizeof(InstallDate) );
1910         RegCloseKey( hKey );
1911     }
1912 }
1913
1914 static INT_PTR CALLBACK
1915 FinishDlgProc(HWND hwndDlg,
1916               UINT uMsg,
1917               WPARAM wParam,
1918               LPARAM lParam)
1919 {
1920
1921     switch (uMsg)
1922     {
1923         case WM_INITDIALOG:
1924         {
1925             /* Get pointer to the global setup data */
1926             PSETUPDATA SetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
1927
1928             /* Run the Wine Gecko prompt */
1929             Control_RunDLLW(GetDesktopWindow(), 0, L"appwiz.cpl install_gecko", SW_SHOW);
1930
1931             /* Set title font */
1932             SendDlgItemMessage(hwndDlg,
1933                                IDC_FINISHTITLE,
1934                                WM_SETFONT,
1935                                (WPARAM)SetupData->hTitleFont,
1936                                (LPARAM)TRUE);
1937             if (SetupData->UnattendSetup)
1938             {
1939                 KillTimer(hwndDlg, 1);
1940                 SetInstallationCompleted();
1941                 PostQuitMessage(0);
1942             }
1943         }
1944         break;
1945
1946         case WM_DESTROY:
1947         {
1948             SetInstallationCompleted();
1949             PostQuitMessage(0);
1950             return TRUE;
1951         }
1952
1953         case WM_TIMER:
1954         {
1955             INT Position;
1956             HWND hWndProgress;
1957
1958             hWndProgress = GetDlgItem(hwndDlg, IDC_RESTART_PROGRESS);
1959             Position = SendMessage(hWndProgress, PBM_GETPOS, 0, 0);
1960             if (Position == 300)
1961             {
1962                 KillTimer(hwndDlg, 1);
1963                 PropSheet_PressButton(GetParent(hwndDlg), PSBTN_FINISH);
1964             }
1965             else
1966             {
1967                 SendMessage(hWndProgress, PBM_SETPOS, Position + 1, 0);
1968             }
1969         }
1970         return TRUE;
1971
1972         case WM_NOTIFY:
1973         {
1974             LPNMHDR lpnm = (LPNMHDR)lParam;
1975
1976             switch (lpnm->code)
1977             {
1978                 case PSN_SETACTIVE:
1979                     /* Enable the correct buttons on for the active page */
1980                     PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_FINISH);
1981
1982                     SendDlgItemMessage(hwndDlg, IDC_RESTART_PROGRESS, PBM_SETRANGE, 0,
1983                                        MAKELPARAM(0, 300));
1984                     SendDlgItemMessage(hwndDlg, IDC_RESTART_PROGRESS, PBM_SETPOS, 0, 0);
1985                     SetTimer(hwndDlg, 1, 50, NULL);
1986                     break;
1987
1988                 case PSN_WIZFINISH:
1989                     DestroyWindow(GetParent(hwndDlg));
1990                     break;
1991
1992                 default:
1993                     break;
1994             }
1995         }
1996         break;
1997
1998         default:
1999             break;
2000     }
2001
2002     return FALSE;
2003 }
2004
2005
2006 BOOL
2007 ProcessUnattendInf(HINF hUnattendedInf)
2008 {
2009     INFCONTEXT InfContext;
2010     WCHAR szName[256];
2011     WCHAR szValue[MAX_PATH];
2012     DWORD LineLength;
2013     HKEY hKey;
2014
2015     if (!SetupFindFirstLineW(hUnattendedInf,
2016                              L"Unattend",
2017                              L"UnattendSetupEnabled",
2018                              &InfContext))
2019     {
2020         DPRINT1("Error: Cant find UnattendSetupEnabled Key! %d\n", GetLastError());
2021         return FALSE;
2022     }
2023
2024     if (!SetupGetStringFieldW(&InfContext,
2025                               1,
2026                               szValue,
2027                               sizeof(szValue) / sizeof(WCHAR),
2028                               &LineLength))
2029     {
2030         DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
2031         return FALSE;
2032     }
2033
2034     if (wcscmp(szValue, L"yes") != 0)
2035     {
2036         DPRINT("Unattend setup was disabled by UnattendSetupEnabled key.\n");
2037         return FALSE;
2038     }
2039
2040     if (!SetupFindFirstLineW(hUnattendedInf,
2041                              L"Unattend",
2042                              NULL,
2043                              &InfContext))
2044     {
2045         DPRINT1("Error: SetupFindFirstLine failed %d\n", GetLastError());
2046         return FALSE;
2047     }
2048
2049
2050     do
2051     {
2052         if (!SetupGetStringFieldW(&InfContext,
2053                                   0,
2054                                   szName,
2055                                   sizeof(szName) / sizeof(WCHAR),
2056                                   &LineLength))
2057         {
2058             DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
2059             return FALSE;
2060         }
2061
2062         if (!SetupGetStringFieldW(&InfContext,
2063                                   1,
2064                                   szValue,
2065                                   sizeof(szValue) / sizeof(WCHAR),
2066                                   &LineLength))
2067         {
2068             DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
2069             return FALSE;
2070         }
2071         DPRINT1("Name %S Value %S\n", szName, szValue);
2072         if (!wcscmp(szName, L"FullName"))
2073         {
2074             if ((sizeof(SetupData.OwnerName) / sizeof(TCHAR)) > LineLength)
2075             {
2076                 wcscpy(SetupData.OwnerName, szValue);
2077             }
2078         }
2079         else if (!wcscmp(szName, L"OrgName"))
2080         {
2081             if ((sizeof(SetupData.OwnerOrganization) / sizeof(WCHAR)) > LineLength)
2082             {
2083                 wcscpy(SetupData.OwnerOrganization, szValue);
2084             }
2085         }
2086         else if (!wcscmp(szName, L"ComputerName"))
2087         {
2088             if ((sizeof(SetupData.ComputerName) / sizeof(WCHAR)) > LineLength)
2089             {
2090                 wcscpy(SetupData.ComputerName, szValue);
2091             }
2092         }
2093         else if (!wcscmp(szName, L"AdminPassword"))
2094         {
2095             if ((sizeof(SetupData.AdminPassword) / sizeof(WCHAR)) > LineLength)
2096             {
2097                 wcscpy(SetupData.AdminPassword, szValue);
2098             }
2099         }
2100         else if (!wcscmp(szName, L"TimeZoneIndex"))
2101         {
2102             SetupData.TimeZoneIndex = _wtoi(szValue);
2103         }
2104         else if (!wcscmp(szName, L"DisableAutoDaylightTimeSet"))
2105         {
2106             SetupData.DisableAutoDaylightTimeSet = _wtoi(szValue);
2107         }
2108         else if (!wcscmp(szName, L"DisableVmwInst"))
2109         {
2110             if(!wcscmp(szValue, L"yes"))
2111                 SetupData.DisableVmwInst = 1;
2112             else
2113                 SetupData.DisableVmwInst = 0;
2114         }
2115
2116     }
2117     while (SetupFindNextLine(&InfContext, &InfContext));
2118
2119     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
2120                       L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce",
2121                       0,
2122                       KEY_SET_VALUE,
2123                       &hKey) != ERROR_SUCCESS)
2124     {
2125         DPRINT1("Error: failed to open HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce\n");
2126         return TRUE;
2127     }
2128
2129
2130     if (SetupFindFirstLineW(hUnattendedInf,
2131                             L"GuiRunOnce",
2132                             NULL,
2133                             &InfContext))
2134     {
2135
2136         int i = 0;
2137         do
2138         {
2139             if(SetupGetStringFieldW(&InfContext,
2140                                     0,
2141                                     szValue,
2142                                     sizeof(szValue) / sizeof(WCHAR),
2143                                     NULL))
2144             {
2145                 WCHAR szPath[MAX_PATH];
2146                 swprintf(szName, L"%d", i);
2147                 DPRINT("szName %S szValue %S\n", szName, szValue);
2148
2149                 if (ExpandEnvironmentStringsW(szValue, szPath, MAX_PATH))
2150                 {
2151                     DPRINT("value %S\n", szPath);
2152                     if (RegSetValueExW(hKey,
2153                                        szName,
2154                                        0,
2155                                        REG_SZ,
2156                                        (const BYTE*)szPath,
2157                                        (wcslen(szPath) + 1) * sizeof(WCHAR)) == ERROR_SUCCESS)
2158                     {
2159                         i++;
2160                     }
2161                 }
2162             }
2163         } while(SetupFindNextLine(&InfContext, &InfContext));
2164     }
2165
2166     RegCloseKey(hKey);
2167     return TRUE;
2168 }
2169
2170 /*
2171  * GetRosInstallCD should find the path to ros installation medium
2172  * BUG 1
2173  * If there are more than one CDDrive in it containing a ReactOS
2174  * installation cd, then it will pick the first one regardless if
2175  * it is really the installation cd
2176  *
2177  * The best way to implement this is to set the key
2178  * HKLM\Software\Microsoft\Windows NT\CurrentVersion\SourcePath (REG_SZ)
2179  */
2180
2181 BOOL
2182 GetRosInstallCD(WCHAR *pwszPath, DWORD cchPathMax)
2183 {
2184     WCHAR wszDrives[512];
2185     DWORD cchDrives;
2186     WCHAR *pwszDrive;
2187
2188     cchDrives = GetLogicalDriveStringsW(_countof(wszDrives) - 1, wszDrives);
2189     if (cchDrives == 0 || cchDrives >= _countof(wszDrives))
2190     {
2191         /* buffer too small or failure */
2192         LogItem(SYSSETUP_SEVERITY_INFORMATION, L"GetLogicalDriveStringsW failed");
2193         return FALSE;
2194     }
2195
2196     for (pwszDrive = wszDrives; pwszDrive[0]; pwszDrive += wcslen(pwszDrive) + 1)
2197     {
2198         if (GetDriveTypeW(pwszDrive) == DRIVE_CDROM)
2199         {
2200             WCHAR wszBuf[MAX_PATH];
2201             wsprintf(wszBuf, L"%sreactos\\system32\\ntoskrnl.exe", pwszDrive);
2202             LogItem(SYSSETUP_SEVERITY_INFORMATION, wszBuf);
2203             if (GetFileAttributesW(wszBuf) != INVALID_FILE_ATTRIBUTES)
2204             {
2205                 /* the file exists, so this is the right drive */
2206                 wcsncpy(pwszPath, pwszDrive, cchPathMax);
2207                 OutputDebugStringW(L"GetRosInstallCD: ");OutputDebugStringW(pwszPath);OutputDebugStringW(L"\n");
2208                 return TRUE;
2209             }
2210         }
2211     }
2212     return FALSE;
2213 }
2214
2215
2216 VOID
2217 ProcessUnattendSetup(VOID)
2218 {
2219     WCHAR szPath[MAX_PATH];
2220     HINF hUnattendedInf;
2221     DWORD dwLength;
2222
2223     if (!GetRosInstallCD(szPath, MAX_PATH))
2224     {
2225         /* no cd drive found */
2226         return;
2227     }
2228
2229     dwLength = wcslen(szPath);
2230     if (dwLength + 21 > MAX_PATH)
2231     {
2232         /* FIXME
2233          * allocate bigger buffer
2234          */
2235         return;
2236     }
2237
2238     wcscat(szPath, L"reactos\\unattend.inf");
2239
2240     hUnattendedInf = SetupOpenInfFileW(szPath,
2241                                        NULL,
2242                                        INF_STYLE_OLDNT,
2243                                        NULL);
2244
2245     if (hUnattendedInf != INVALID_HANDLE_VALUE)
2246     {
2247         SetupData.UnattendSetup = ProcessUnattendInf(hUnattendedInf);
2248         SetupCloseInfFile(hUnattendedInf);
2249     }
2250 }
2251
2252
2253 VOID
2254 InstallWizard(VOID)
2255 {
2256     PROPSHEETHEADER psh;
2257     HPROPSHEETPAGE ahpsp[8];
2258     PROPSHEETPAGE psp = {0};
2259     UINT nPages = 0;
2260     HWND hWnd;
2261     MSG msg;
2262
2263     /* Clear setup data */
2264     ZeroMemory(&SetupData, sizeof(SETUPDATA));
2265
2266     ProcessUnattendSetup();
2267
2268     /* Create the Welcome page */
2269     psp.dwSize = sizeof(PROPSHEETPAGE);
2270     psp.dwFlags = PSP_DEFAULT | PSP_HIDEHEADER;
2271     psp.hInstance = hDllInstance;
2272     psp.lParam = (LPARAM)&SetupData;
2273     psp.pfnDlgProc = WelcomeDlgProc;
2274     psp.pszTemplate = MAKEINTRESOURCE(IDD_WELCOMEPAGE);
2275     ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2276
2277     /* Create the Acknowledgements page */
2278     psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
2279     psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_ACKTITLE);
2280     psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_ACKSUBTITLE);
2281     psp.pszTemplate = MAKEINTRESOURCE(IDD_ACKPAGE);
2282     psp.pfnDlgProc = AckPageDlgProc;
2283     ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2284
2285     /* Create the Locale page */
2286     psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
2287     psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_LOCALETITLE);
2288     psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_LOCALESUBTITLE);
2289     psp.pfnDlgProc = LocalePageDlgProc;
2290     psp.pszTemplate = MAKEINTRESOURCE(IDD_LOCALEPAGE);
2291     ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2292
2293
2294     /* Create the Owner page */
2295     psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
2296     psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_OWNERTITLE);
2297     psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_OWNERSUBTITLE);
2298     psp.pszTemplate = MAKEINTRESOURCE(IDD_OWNERPAGE);
2299     psp.pfnDlgProc = OwnerPageDlgProc;
2300     ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2301
2302     /* Create the Computer page */
2303     psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
2304     psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_COMPUTERTITLE);
2305     psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_COMPUTERSUBTITLE);
2306     psp.pfnDlgProc = ComputerPageDlgProc;
2307     psp.pszTemplate = MAKEINTRESOURCE(IDD_COMPUTERPAGE);
2308     ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2309
2310
2311     /* Create the DateTime page */
2312     psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
2313     psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_DATETIMETITLE);
2314     psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_DATETIMESUBTITLE);
2315     psp.pfnDlgProc = DateTimePageDlgProc;
2316     psp.pszTemplate = MAKEINTRESOURCE(IDD_DATETIMEPAGE);
2317     ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2318
2319
2320     /* Create the Process page */
2321     psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
2322     psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_PROCESSTITLE);
2323     psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_PROCESSSUBTITLE);
2324     psp.pfnDlgProc = ProcessPageDlgProc;
2325     psp.pszTemplate = MAKEINTRESOURCE(IDD_PROCESSPAGE);
2326     ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2327
2328
2329     /* Create the Finish page */
2330     psp.dwFlags = PSP_DEFAULT | PSP_HIDEHEADER;
2331     psp.pfnDlgProc = FinishDlgProc;
2332     psp.pszTemplate = MAKEINTRESOURCE(IDD_FINISHPAGE);
2333     ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2334
2335     /* Create the property sheet */
2336     psh.dwSize = sizeof(PROPSHEETHEADER);
2337     psh.dwFlags = PSH_WIZARD97 | PSH_WATERMARK | PSH_HEADER | PSH_MODELESS;
2338     psh.hInstance = hDllInstance;
2339     psh.hwndParent = NULL;
2340     psh.nPages = nPages;
2341     psh.nStartPage = 0;
2342     psh.phpage = ahpsp;
2343     psh.pszbmWatermark = MAKEINTRESOURCE(IDB_WATERMARK);
2344     psh.pszbmHeader = MAKEINTRESOURCE(IDB_HEADER);
2345
2346     /* Create title font */
2347     SetupData.hTitleFont = CreateTitleFont();
2348
2349     /* Display the wizard */
2350     hWnd = (HWND)PropertySheet(&psh);
2351     ShowWindow(hWnd, SW_SHOW);
2352
2353     while (GetMessage(&msg, NULL, 0, 0))
2354     {
2355         if(!IsDialogMessage(hWnd, &msg))
2356         {
2357             TranslateMessage(&msg);
2358             DispatchMessage(&msg);
2359         }
2360     }
2361
2362     DeleteObject(SetupData.hTitleFont);
2363 }
2364
2365 /* EOF */