wizard.c File Reference

#include "precomp.h"
#include <stdlib.h>
#include <time.h>
#include <winnls.h>
#include <windowsx.h>
#include <wincon.h>
#include <shlobj.h>
#include <shlwapi.h>
#include <tzlib.h>
#include <strsafe.h>
#include <debug.h>

Include dependency graph for wizard.c:

Go to the source code of this file.

Classes
struct	_REGISTRATIONDATA
struct	_TIMEZONE_ENTRY
struct	_PRODUCT_OPTION_DATA
struct	ThemeInfo

Macros
#define	NDEBUG
#define	MAX_LAYOUTS_PER_LANGID   0x10000

Typedefs
typedef struct _REGISTRATIONDATA	REGISTRATIONDATA
typedef struct _REGISTRATIONDATA *	PREGISTRATIONDATA
typedef struct _TIMEZONE_ENTRY	TIMEZONE_ENTRY
typedef struct _TIMEZONE_ENTRY *	PTIMEZONE_ENTRY
typedef struct _PRODUCT_OPTION_DATA	PRODUCT_OPTION_DATA
typedef DWORD(WINAPI *	PFNREQUESTWIZARDPAGES) (PDWORD, HPROPSHEETPAGE *, PSETUPDATA)

Functions
void WINAPI	Control_RunDLLW (HWND hWnd, HINSTANCE hInst, LPCWSTR cmd, DWORD nCmdShow)
static VOID	CenterWindow (HWND hWnd)
static HFONT	CreateTitleFont (VOID)
static HFONT	CreateBoldFont (VOID)
static INT_PTR CALLBACK	GplDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static INT_PTR CALLBACK	WelcomeDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static INT_PTR CALLBACK	AckPageDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static BOOL	DoWriteSoundEvents (HKEY hKey, LPCWSTR lpSubkey, LPCWSTR lpEventsArray[][2], DWORD dwSize)
static BOOL	DoWriteProductOption (PRODUCT_OPTION nOption)
static void	OnChooseOption (HWND hwndDlg, PRODUCT_OPTION nOption)
static INT_PTR CALLBACK	ProductPageDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static BOOL	WriteOwnerSettings (WCHAR *OwnerName, WCHAR *OwnerOrganization)
static INT_PTR CALLBACK	OwnerPageDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static BOOL	WriteComputerSettings (WCHAR *ComputerName, HWND hwndDlg)
static BOOL	WriteDefaultLogonData (LPWSTR Domain)
static void	GenerateComputerName (LPWSTR lpBuffer)
static INT_PTR CALLBACK	ComputerPageDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static VOID	SetUserLocaleName (HWND hwnd)
static VOID	SetKeyboardLayoutName (HWND hwnd)
static BOOL	RunControlPanelApplet (HWND hwnd, PCWSTR pwszCPLParameters)
VOID	EnableVisualTheme (_In_opt_ HWND hwndParent, _In_opt_ PCWSTR ThemeFile)
static VOID	WriteUserLocale (VOID)
static INT_PTR CALLBACK	LocalePageDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static PTIMEZONE_ENTRY	GetLargerTimeZoneEntry (PSETUPDATA SetupData, DWORD Index)
static LONG	RetrieveTimeZone (IN HKEY hZoneKey, IN PVOID Context)
static VOID	CreateTimeZoneList (PSETUPDATA SetupData)
static VOID	DestroyTimeZoneList (PSETUPDATA SetupData)
static VOID	ShowTimeZoneList (HWND hwnd, PSETUPDATA SetupData, DWORD dwEntryIndex)
static VOID	SetLocalTimeZone (HWND hwnd, PSETUPDATA SetupData)
static BOOL	GetLocalSystemTime (HWND hwnd, PSETUPDATA SetupData)
static BOOL	SetSystemLocalTime (HWND hwnd, PSETUPDATA SetupData)
static VOID	UpdateLocalSystemTime (HWND hwnd, SYSTEMTIME LocalTime)
static BOOL	WriteDateTimeSettings (HWND hwndDlg, PSETUPDATA SetupData)
static INT_PTR CALLBACK	DateTimePageDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static INT_PTR CALLBACK	ThemePageDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static UINT CALLBACK	RegistrationNotificationProc (PVOID Context, UINT Notification, UINT_PTR Param1, UINT_PTR Param2)
static DWORD	RegisterDlls (_In_ PITEMSDATA pItemsData, _In_ PREGISTRATIONNOTIFY pNotify)
static VOID	RegisterComponents (PITEMSDATA pItemsData)
static DWORD CALLBACK	ItemCompletionThread (LPVOID Parameter)
static BOOL	RunItemCompletionThread (_In_ HWND hwndDlg)
static VOID	ShowItemError (HWND hwndDlg, DWORD LastError)
static VOID	ShowStepError (HWND hwndDlg, PREGISTRATIONNOTIFY RegistrationNotify)
static INT_PTR CALLBACK	ProcessPageDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static VOID	SetInstallationCompleted (VOID)
static INT_PTR CALLBACK	FinishDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static BOOL	GetInstallSourceWin32 (OUT PWSTR pwszPath, IN DWORD cchPathMax, IN PCWSTR pwszNTPath)
VOID	ProcessUnattendSection (IN OUT PSETUPDATA pSetupData)
static BOOL	PathIsEqual (IN LPCWSTR lpPath1, IN LPCWSTR lpPath2)
static VOID	AddInstallationSource (IN HKEY hKey, IN LPWSTR lpPath)
VOID	ProcessSetupInf (IN OUT PSETUPDATA pSetupData)
VOID	InstallWizard (VOID)

Variables
static const WCHAR	s_szProductOptions [] = L"SYSTEM\\CurrentControlSet\\Control\\ProductOptions"
static const WCHAR	s_szRosVersion [] = L"SYSTEM\\CurrentControlSet\\Control\\ReactOS\\Settings\\Version"
static const WCHAR	s_szControlWindows [] = L"SYSTEM\\CurrentControlSet\\Control\\Windows"
static const WCHAR	s_szWinlogon [] = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon"
static const WCHAR	s_szDefaultSoundEvents [] = L"AppEvents\\Schemes\\Apps\\.Default"
static const WCHAR	s_szExplorerSoundEvents [] = L"AppEvents\\Schemes\\Apps\\Explorer"
static const PRODUCT_OPTION_DATA	s_ProductOptionData []
static const WCHAR *	s_DefaultSoundEvents [][2]
static const WCHAR *	s_ExplorerSoundEvents [][2]
static struct ThemeInfo	Themes []

Macro Definition Documentation

MAX_LAYOUTS_PER_LANGID

#define MAX_LAYOUTS_PER_LANGID   0x10000

NDEBUG

#define NDEBUG

Definition at line 27 of file wizard.c.

Typedef Documentation

PFNREQUESTWIZARDPAGES

typedef DWORD(WINAPI * PFNREQUESTWIZARDPAGES) (PDWORD, HPROPSHEETPAGE *, PSETUPDATA)

Definition at line 3259 of file wizard.c.

PREGISTRATIONDATA

typedef struct _REGISTRATIONDATA * PREGISTRATIONDATA

PRODUCT_OPTION_DATA

typedef struct _PRODUCT_OPTION_DATA PRODUCT_OPTION_DATA

PTIMEZONE_ENTRY

typedef struct _TIMEZONE_ENTRY * PTIMEZONE_ENTRY

REGISTRATIONDATA

typedef struct _REGISTRATIONDATA REGISTRATIONDATA

TIMEZONE_ENTRY

typedef struct _TIMEZONE_ENTRY TIMEZONE_ENTRY

Function Documentation

AckPageDlgProc()

static INT_PTR CALLBACK AckPageDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 275 of file wizard.c.

{
    LPNMHDR lpnm;
    PWCHAR Projects;
    PWCHAR End, CurrentProject;
    INT ProjectsSize, ProjectsCount;
    PSETUPDATA pSetupData;
 
    pSetupData = (PSETUPDATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pSetupData);
 
            Projects = NULL;
            ProjectsSize = 256;
            while (TRUE)
            {
                Projects = HeapAlloc(GetProcessHeap(), 0, ProjectsSize * sizeof(WCHAR));
                if (NULL == Projects)
                {
                    return FALSE;
                }
                ProjectsCount =  LoadStringW(hDllInstance, IDS_ACKPROJECTS, Projects, ProjectsSize);
                if (0 == ProjectsCount)
                {
                    HeapFree(GetProcessHeap(), 0, Projects);
                    return FALSE;
                }
                if (ProjectsCount < ProjectsSize - 1)
                {
                    break;
                }
                HeapFree(GetProcessHeap(), 0, Projects);
                ProjectsSize *= 2;
            }
 
            CurrentProject = Projects;
            while (*CurrentProject != L'\0')
            {
                End = wcschr(CurrentProject, L'\n');
                if (NULL != End)
                {
                    *End = L'\0';
                }
                (void)ListBox_AddString(GetDlgItem(hwndDlg, IDC_PROJECTS), CurrentProject);
                if (NULL != End)
                {
                    CurrentProject = End + 1;
                }
                else
                {
                    CurrentProject += wcslen(CurrentProject);
                }
            }
            HeapFree(GetProcessHeap(), 0, Projects);
        }
        break;
 
        case WM_COMMAND:
            if (HIWORD(wParam) == BN_CLICKED && IDC_VIEWGPL == LOWORD(wParam))
            {
                DialogBox(hDllInstance, MAKEINTRESOURCE(IDD_GPL), NULL, GplDlgProc);
                SetForegroundWindow(GetParent(hwndDlg));
            }
            break;
 
        case WM_NOTIFY:
        {
            lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                    /* Enable the Back and Next buttons */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
                    if (pSetupData->UnattendSetup)
                    {
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, IDD_PRODUCT);
                        return TRUE;
                    }
                    break;
 
                case PSN_WIZBACK:
                    pSetupData->UnattendSetup = FALSE;
                    break;
 
                default:
                    break;
            }
        }
        break;
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by InstallWizard().

AddInstallationSource()

static VOID AddInstallationSource ( IN HKEY  hKey, IN LPWSTR  lpPath  )

static

Definition at line 3036 of file wizard.c.

{
    LONG res;
    DWORD dwRegType;
    DWORD dwPathLength = 0;
    DWORD dwNewLength = 0;
    LPWSTR Buffer = NULL;
    LPWSTR Path;
 
    res = RegQueryValueExW(
        hKey,
        L"Installation Sources",
        NULL,
        &dwRegType,
        NULL,
        &dwPathLength);
 
    if (res != ERROR_SUCCESS ||
        dwRegType != REG_MULTI_SZ ||
        dwPathLength == 0 ||
        dwPathLength % sizeof(WCHAR) != 0)
    {
        dwPathLength = 0;
        goto set;
    }
 
    /* Reserve space for existing data + new string */
    dwNewLength = dwPathLength + (wcslen(lpPath) + 1) * sizeof(WCHAR);
    Buffer = HeapAlloc(GetProcessHeap(), 0, dwNewLength);
    if (!Buffer)
        return;
 
    ZeroMemory(Buffer, dwNewLength);
 
    res = RegQueryValueExW(
        hKey,
        L"Installation Sources",
        NULL,
        NULL,
        (LPBYTE)Buffer,
        &dwPathLength);
 
    if (res != ERROR_SUCCESS)
    {
        HeapFree(GetProcessHeap(), 0, Buffer);
        dwPathLength = 0;
        goto set;
    }
 
    /* Sanity check, these should already be zeros */
    Buffer[dwPathLength / sizeof(WCHAR) - 2] = UNICODE_NULL;
    Buffer[dwPathLength / sizeof(WCHAR) - 1] = UNICODE_NULL;
 
    for (Path = Buffer; *Path; Path += wcslen(Path) + 1)
    {
        /* Check if path is already added */
        if (PathIsEqual(Path, lpPath))
            goto cleanup;
    }
 
    Path = Buffer + dwPathLength / sizeof(WCHAR) - 1;
 
set:
    if (dwPathLength == 0)
    {
        dwNewLength = (wcslen(lpPath) + 1 + 1) * sizeof(WCHAR);
        Buffer = HeapAlloc(GetProcessHeap(), 0, dwNewLength);
        if (!Buffer)
            return;
 
        Path = Buffer;
    }
 
    StringCbCopyW(Path, dwNewLength - (Path - Buffer) * sizeof(WCHAR), lpPath);
    Buffer[dwNewLength / sizeof(WCHAR) - 1] = UNICODE_NULL;
 
    RegSetValueExW(
        hKey,
        L"Installation Sources",
        0,
        REG_MULTI_SZ,
        (LPBYTE)Buffer,
        dwNewLength);
 
cleanup:
    HeapFree(GetProcessHeap(), 0, Buffer);
}

Referenced by ProcessSetupInf().

CenterWindow()

static VOID CenterWindow ( HWND  hWnd )

static

Definition at line 56 of file wizard.c.

{
    HWND hWndParent;
    RECT rcParent;
    RECT rcWindow;
 
    hWndParent = GetParent(hWnd);
    if (hWndParent == NULL)
        hWndParent = GetDesktopWindow();
 
    GetWindowRect(hWndParent, &rcParent);
    GetWindowRect(hWnd, &rcWindow);
 
    SetWindowPos(hWnd,
                 HWND_TOP,
                 ((rcParent.right - rcParent.left) - (rcWindow.right - rcWindow.left)) / 2,
                 ((rcParent.bottom - rcParent.top) - (rcWindow.bottom - rcWindow.top)) / 2,
                 0,
                 0,
                 SWP_NOSIZE);
}

ComputerPageDlgProc()

static INT_PTR CALLBACK ComputerPageDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1044 of file wizard.c.

{
    WCHAR ComputerName[MAX_COMPUTERNAME_LENGTH + 1];
    WCHAR Password1[128];
    WCHAR Password2[128];
    PWCHAR Password;
    WCHAR Title[64];
    WCHAR EmptyComputerName[256], NotMatchPassword[256], WrongPassword[256];
    LPNMHDR lpnm;
    PSETUPDATA pSetupData;
 
    pSetupData = (PSETUPDATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
 
    if (0 == LoadStringW(hDllInstance, IDS_REACTOS_SETUP, Title, ARRAYSIZE(Title)))
    {
        wcscpy(Title, L"ReactOS Setup");
    }
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
            pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pSetupData);
 
            /* Generate a new pseudo-random computer name */
            GenerateComputerName(ComputerName);
 
            /* Display current computer name */
            SetDlgItemTextW(hwndDlg, IDC_COMPUTERNAME, ComputerName);
 
            /* Set text limits */
            SendDlgItemMessage(hwndDlg, IDC_COMPUTERNAME, EM_LIMITTEXT, MAX_COMPUTERNAME_LENGTH, 0);
            SendDlgItemMessage(hwndDlg, IDC_ADMINPASSWORD1, EM_LIMITTEXT, 127, 0);
            SendDlgItemMessage(hwndDlg, IDC_ADMINPASSWORD2, EM_LIMITTEXT, 127, 0);
 
            /* Set focus to computer name */
            SetFocus(GetDlgItem(hwndDlg, IDC_COMPUTERNAME));
            if (pSetupData->UnattendSetup)
            {
                SendMessage(GetDlgItem(hwndDlg, IDC_COMPUTERNAME), WM_SETTEXT, 0, (LPARAM)pSetupData->ComputerName);
                SendMessage(GetDlgItem(hwndDlg, IDC_ADMINPASSWORD1), WM_SETTEXT, 0, (LPARAM)pSetupData->AdminPassword);
                SendMessage(GetDlgItem(hwndDlg, IDC_ADMINPASSWORD2), WM_SETTEXT, 0, (LPARAM)pSetupData->AdminPassword);
                WriteComputerSettings(pSetupData->ComputerName, NULL);
                SetAdministratorPassword(pSetupData->AdminPassword);
            }
 
            /* Store the administrator account name as the default user name */
            WriteDefaultLogonData(pSetupData->ComputerName);
            break;
 
 
        case WM_NOTIFY:
        {
            lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                    /* Enable the Back and Next buttons */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
                    if (pSetupData->UnattendSetup && WriteComputerSettings(pSetupData->ComputerName, hwndDlg))
                    {
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, IDD_DATETIMEPAGE);
                        return TRUE;
                    }
                    break;
 
                case PSN_WIZNEXT:
                    if (0 == GetDlgItemTextW(hwndDlg, IDC_COMPUTERNAME, ComputerName, MAX_COMPUTERNAME_LENGTH + 1))
                    {
                        if (0 == LoadStringW(hDllInstance, IDS_WZD_COMPUTERNAME, EmptyComputerName,
                                             ARRAYSIZE(EmptyComputerName)))
                        {
                            wcscpy(EmptyComputerName, L"Setup cannot continue until you enter the name of your computer.");
                        }
                        MessageBoxW(hwndDlg, EmptyComputerName, Title, MB_ICONERROR | MB_OK);
                        SetFocus(GetDlgItem(hwndDlg, IDC_COMPUTERNAME));
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1);
                        return TRUE;
                    }
 
                    /* No need to check computer name for invalid characters,
                     * SetComputerName() will do it for us */
 
                    if (!WriteComputerSettings(ComputerName, hwndDlg))
                    {
                        SetFocus(GetDlgItem(hwndDlg, IDC_COMPUTERNAME));
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1);
                        return TRUE;
                    }
 
#ifdef PASSWORDS_MANDATORY
                    /* Check if admin passwords have been entered */
                    if ((GetDlgItemText(hwndDlg, IDC_ADMINPASSWORD1, Password1, 128) == 0) ||
                        (GetDlgItemText(hwndDlg, IDC_ADMINPASSWORD2, Password2, 128) == 0))
                    {
                        if (0 == LoadStringW(hDllInstance, IDS_WZD_PASSWORDEMPTY, EmptyPassword,
                                             ARRAYSIZE(EmptyPassword)))
                        {
                            wcscpy(EmptyPassword, L"You must enter a password !");
                        }
                        MessageBoxW(hwndDlg, EmptyPassword, Title, MB_ICONERROR | MB_OK);
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1);
                        return TRUE;
                    }
#else
                    GetDlgItemTextW(hwndDlg, IDC_ADMINPASSWORD1, Password1, 128);
                    GetDlgItemTextW(hwndDlg, IDC_ADMINPASSWORD2, Password2, 128);
#endif
                    /* Check if passwords match */
                    if (wcscmp(Password1, Password2))
                    {
                        if (0 == LoadStringW(hDllInstance, IDS_WZD_PASSWORDMATCH, NotMatchPassword,
                                             ARRAYSIZE(NotMatchPassword)))
                        {
                            wcscpy(NotMatchPassword, L"The passwords you entered do not match. Please enter the desired password again.");
                        }
                        MessageBoxW(hwndDlg, NotMatchPassword, Title, MB_ICONERROR | MB_OK);
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1);
                        return TRUE;
                    }
 
                    /* Check password for invalid characters */
                    Password = (PWCHAR)Password1;
                    while (*Password)
                    {
                        if (!isprint(*Password))
                        {
                            if (0 == LoadStringW(hDllInstance, IDS_WZD_PASSWORDCHAR, WrongPassword,
                                                 ARRAYSIZE(WrongPassword)))
                            {
                                wcscpy(WrongPassword, L"The password you entered contains invalid characters. Please enter a cleaned password.");
                            }
                            MessageBoxW(hwndDlg, WrongPassword, Title, MB_ICONERROR | MB_OK);
                            SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1);
                            return TRUE;
                        }
                        Password++;
                    }
 
                    /* Set admin password */
                    SetAdministratorPassword(Password1);
                    break;
 
                case PSN_WIZBACK:
                    pSetupData->UnattendSetup = FALSE;
                    break;
 
                default:
                    break;
            }
        }
        break;
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by InstallWizard().

Control_RunDLLW()

void WINAPI Control_RunDLLW	(	HWND	hWnd,
		HINSTANCE	hInst,
		LPCWSTR	cmd,
		DWORD	nCmdShow
	)

Definition at line 1177 of file control.c.

{
    CPanel  panel;
 
    TRACE("(%p, %p, %s, 0x%08x)\n",
      hWnd, hInst, debugstr_w(cmd), nCmdShow);
 
#ifndef __REACTOS__
    memset(&panel, 0, sizeof(panel));
    list_init( &panel.applets );
#endif
 
    if (!cmd || !*cmd) {
        Control_DoWindow(&panel, hWnd, hInst);
    } else {
        Control_DoLaunch(&panel, hWnd, cmd);
    }
}

Referenced by FinishDlgProc().

CreateBoldFont()

static HFONT CreateBoldFont ( VOID  )

static

Definition at line 101 of file wizard.c.

{
    LOGFONTW tmpFont = {0};
    HFONT hBoldFont;
    HDC hDc;
 
    /* Grabs the Drawing Context */
    hDc = GetDC(NULL);
 
    tmpFont.lfHeight = -MulDiv(8, GetDeviceCaps(hDc, LOGPIXELSY), 72);
    tmpFont.lfWeight = FW_BOLD;
    wcscpy(tmpFont.lfFaceName, L"MS Shell Dlg");
 
    hBoldFont = CreateFontIndirectW(&tmpFont);
 
    ReleaseDC(NULL, hDc);
 
    return hBoldFont;
}

Referenced by InstallWizard().

CreateTimeZoneList()

static VOID CreateTimeZoneList ( PSETUPDATA  SetupData )

static

Definition at line 1658 of file wizard.c.

{
    EnumerateTimeZoneList(RetrieveTimeZone, SetupData);
}

Referenced by DateTimePageDlgProc().

CreateTitleFont()

static HFONT CreateTitleFont ( VOID  )

static

Definition at line 80 of file wizard.c.

{
    LOGFONTW LogFont = {0};
    HDC hdc;
    HFONT hFont;
 
    LogFont.lfWeight = FW_BOLD;
    wcscpy(LogFont.lfFaceName, L"MS Shell Dlg");
 
    hdc = GetDC(NULL);
    LogFont.lfHeight = -MulDiv(12, GetDeviceCaps(hdc, LOGPIXELSY), 72);
 
    hFont = CreateFontIndirectW(&LogFont);
 
    ReleaseDC(NULL, hdc);
 
    return hFont;
}

DateTimePageDlgProc()

static INT_PTR CALLBACK DateTimePageDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1844 of file wizard.c.

{
    PSETUPDATA SetupData;
 
    /* Retrieve pointer to the global setup data */
    SetupData = (PSETUPDATA)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Save pointer to the global setup data */
            SetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
            SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (DWORD_PTR)SetupData);
 
            CreateTimeZoneList(SetupData);
 
            if (SetupData->UnattendSetup)
            {
                ShowTimeZoneList(GetDlgItem(hwndDlg, IDC_TIMEZONELIST),
                                 SetupData, SetupData->TimeZoneIndex);
 
                if (!SetupData->DisableAutoDaylightTimeSet)
                {
                    SendDlgItemMessage(hwndDlg, IDC_AUTODAYLIGHT, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
                }
            }
            else
            {
                ShowTimeZoneList(GetDlgItem(hwndDlg, IDC_TIMEZONELIST),
                                 SetupData, -1);
 
                SendDlgItemMessage(hwndDlg, IDC_AUTODAYLIGHT, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
            }
            break;
        }
 
        case WM_TIMER:
        {
            SYSTEMTIME LocalTime;
 
            GetLocalTime(&LocalTime);
            UpdateLocalSystemTime(hwndDlg, LocalTime);
 
            // Reset timeout.
            SetTimer(hwndDlg, 1, 1000 - LocalTime.wMilliseconds, NULL);
            break;
        }
 
        case WM_NOTIFY:
            switch (((LPNMHDR)lParam)->code)
            {
                case PSN_SETACTIVE:
                {
                    SYSTEMTIME LocalTime;
 
                    GetLocalTime(&LocalTime);
                    UpdateLocalSystemTime(hwndDlg, LocalTime);
 
                    /* Enable the Back and Next buttons */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
 
                    if (SetupData->UnattendSetup && WriteDateTimeSettings(hwndDlg, SetupData))
                    {
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, IDD_THEMEPAGE);
                        return TRUE;
                    }
 
                    SetTimer(hwndDlg, 1, 1000 - LocalTime.wMilliseconds, NULL);
                    break;
                }
 
                case PSN_KILLACTIVE:
                case DTN_DATETIMECHANGE:
                    // NB: Not re-set until changing page (PSN_SETACTIVE).
                    KillTimer(hwndDlg, 1);
                    break;
 
                case PSN_WIZNEXT:
                    WriteDateTimeSettings(hwndDlg, SetupData);
                    break;
 
                case PSN_WIZBACK:
                    SetupData->UnattendSetup = FALSE;
                    break;
 
                default:
                    break;
            }
            break;
 
        case WM_DESTROY:
            DestroyTimeZoneList(SetupData);
            break;
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by InstallWizard().

DestroyTimeZoneList()

static VOID DestroyTimeZoneList ( PSETUPDATA  SetupData )

static

Definition at line 1664 of file wizard.c.

{
    PTIMEZONE_ENTRY Entry;
 
    while (SetupData->TimeZoneListHead != NULL)
    {
        Entry = SetupData->TimeZoneListHead;
 
        SetupData->TimeZoneListHead = Entry->Next;
        if (SetupData->TimeZoneListHead != NULL)
        {
            SetupData->TimeZoneListHead->Prev = NULL;
        }
 
        HeapFree(GetProcessHeap(), 0, Entry);
    }
 
    SetupData->TimeZoneListTail = NULL;
}

Referenced by DateTimePageDlgProc().

DoWriteProductOption()

static BOOL DoWriteProductOption ( PRODUCT_OPTION  nOption )

static

Definition at line 523 of file wizard.c.

{
    HKEY hKey;
    LONG error;
    LPCWSTR pszData;
    DWORD dwValue, cbData;
    const PRODUCT_OPTION_DATA *pData = &s_ProductOptionData[nOption];
    ASSERT(0 <= nOption && nOption < _countof(s_ProductOptionData));
 
    /* open ProductOptions key */
    error = RegOpenKeyExW(HKEY_LOCAL_MACHINE, s_szProductOptions, 0, KEY_WRITE, &hKey);
    if (error)
    {
        DPRINT1("RegOpenKeyExW failed\n");
        goto Error;
    }
 
    /* write ProductSuite */
    pszData = pData->ProductSuite;
    cbData = (lstrlenW(pszData) + 2) * sizeof(WCHAR);
    error = RegSetValueExW(hKey, L"ProductSuite", 0, REG_MULTI_SZ, (const BYTE *)pszData, cbData);
    if (error)
    {
        DPRINT1("RegSetValueExW failed\n");
        goto Error;
    }
 
    /* write ProductType */
    pszData = pData->ProductType;
    cbData = (lstrlenW(pszData) + 1) * sizeof(WCHAR);
    error = RegSetValueExW(hKey, L"ProductType", 0, REG_SZ, (const BYTE *)pszData, cbData);
    if (error)
    {
        DPRINT1("RegSetValueExW failed\n");
        goto Error;
    }
 
    RegCloseKey(hKey);
 
    /* open ReactOS version key */
    error = RegOpenKeyExW(HKEY_LOCAL_MACHINE, s_szRosVersion, 0, KEY_WRITE, &hKey);
    if (error)
    {
        DPRINT1("RegOpenKeyExW failed\n");
        goto Error;
    }
 
    /* write ReportAsWorkstation */
    dwValue = pData->ReportAsWorkstation;
    cbData = sizeof(dwValue);
    error = RegSetValueExW(hKey, L"ReportAsWorkstation", 0, REG_DWORD, (const BYTE *)&dwValue, cbData);
    if (error)
    {
        DPRINT1("RegSetValueExW failed\n");
        goto Error;
    }
 
    RegCloseKey(hKey);
 
    /* open Control Windows key */
    error = RegOpenKeyExW(HKEY_LOCAL_MACHINE, s_szControlWindows, 0, KEY_WRITE, &hKey);
    if (error)
    {
        DPRINT1("RegOpenKeyExW failed\n");
        goto Error;
    }
 
    /* write Control Windows CSDVersion */
    dwValue = pData->CSDVersion;
    cbData = sizeof(dwValue);
    error = RegSetValueExW(hKey, L"CSDVersion", 0, REG_DWORD, (const BYTE *)&dwValue, cbData);
    if (error)
    {
        DPRINT1("RegSetValueExW failed\n");
        goto Error;
    }
 
    RegCloseKey(hKey);
 
    /* open Winlogon key */
    error = RegOpenKeyExW(HKEY_LOCAL_MACHINE, s_szWinlogon, 0, KEY_WRITE, &hKey);
    if (error)
    {
        DPRINT1("RegOpenKeyExW failed\n");
        goto Error;
    }
 
    /* write LogonType */
    dwValue = pData->LogonType;
    cbData = sizeof(dwValue);
    error = RegSetValueExW(hKey, L"LogonType", 0, REG_DWORD, (const BYTE *)&dwValue, cbData);
    if (error)
    {
        DPRINT1("RegSetValueExW failed\n");
        goto Error;
    }
 
    if (nOption == PRODUCT_OPTION_WORKSTATION)
    {
        /* Write system sound events values for Workstation */
        DoWriteSoundEvents(HKEY_CURRENT_USER, s_szDefaultSoundEvents, s_DefaultSoundEvents, _countof(s_DefaultSoundEvents));
        DoWriteSoundEvents(HKEY_CURRENT_USER, s_szExplorerSoundEvents, s_ExplorerSoundEvents, _countof(s_ExplorerSoundEvents));
    }
 
Error:
    if (hKey)
        RegCloseKey(hKey);
 
    return error == ERROR_SUCCESS;
}

Referenced by ProductPageDlgProc().

DoWriteSoundEvents()

static BOOL DoWriteSoundEvents ( HKEY  hKey, LPCWSTR  lpSubkey, LPCWSTR  lpEventsArray[][2], DWORD  dwSize  )

static

Definition at line 440 of file wizard.c.

{
    HKEY hRootKey, hEventKey, hDefaultKey;
    LONG error;
    ULONG i;
    WCHAR szDest[MAX_PATH];
    DWORD dwAttribs;
    DWORD cbData;
 
    /* Open the sound events key */
    error = RegOpenKeyExW(hKey, lpSubkey, 0, KEY_READ, &hRootKey);
    if (error)
    {
        DPRINT1("RegOpenKeyExW failed\n");
        goto Error;
    }
 
    /* Set each sound event */
    for (i = 0; i < dwSize; i++)
    {
        /*
         * Verify that the sound file exists and is an actual file.
         */
 
        /* Expand the sound file path */
        if (!ExpandEnvironmentStringsW(lpEventsArray[i][1], szDest, _countof(szDest)))
        {
            /* Failed to expand, continue with the next sound event */
            continue;
        }
 
        /* Check if the sound file exists and isn't a directory */
        dwAttribs = GetFileAttributesW(szDest);
        if ((dwAttribs == INVALID_FILE_ATTRIBUTES) ||
            (dwAttribs & FILE_ATTRIBUTE_DIRECTORY))
        {
            /* It does not, just continue with the next sound event */
            continue;
        }
 
        /*
         * Create the sound event entry.
         */
 
        /* Open the sound event subkey */
        error = RegOpenKeyExW(hRootKey, lpEventsArray[i][0], 0, KEY_READ, &hEventKey);
        if (error)
        {
            /* Failed to open, continue with next sound event */
            continue;
        }
 
        /* Open .Default subkey */
        error = RegOpenKeyExW(hEventKey, L".Default", 0, KEY_WRITE, &hDefaultKey);
        RegCloseKey(hEventKey);
        if (error)
        {
            /* Failed to open, continue with next sound event */
            continue;
        }
 
        /* Associate the sound file to this sound event */
        cbData = (lstrlenW(lpEventsArray[i][1]) + 1) * sizeof(WCHAR);
        error = RegSetValueExW(hDefaultKey, NULL, 0, REG_EXPAND_SZ, (const BYTE *)lpEventsArray[i][1], cbData);
        RegCloseKey(hDefaultKey);
        if (error)
        {
            /* Failed to set the value, continue with next sound event */
            continue;
        }
    }
 
Error:
    if (hRootKey)
        RegCloseKey(hRootKey);
 
    return error == ERROR_SUCCESS;
}

Referenced by DoWriteProductOption().

EnableVisualTheme()

VOID EnableVisualTheme	(	_In_opt_ HWND	hwndParent,
		_In_opt_ PCWSTR	ThemeFile
	)

Definition at line 1371 of file wizard.c.

{
    enum { THEME_FILE, STYLE_FILE, UNKNOWN } fType;
    WCHAR szPath[MAX_PATH]; // Expanded path of the file to use.
    WCHAR szStyleFile[MAX_PATH];
 
    fType = THEME_FILE; // Default to Classic theme.
    if (ThemeFile)
    {
        /* Expand the path if possible */
        if (ExpandEnvironmentStringsW(ThemeFile, szPath, _countof(szPath)) != 0)
            ThemeFile = szPath;
 
        /* Determine the file type from its extension */
        fType = UNKNOWN; {
        PCWSTR pszExt = wcsrchr(ThemeFile, L'.'); // PathFindExtensionW(ThemeFile);
        if (pszExt)
        {
            if (_wcsicmp(pszExt, L".theme") == 0)
                fType = THEME_FILE;
            else if (_wcsicmp(pszExt, L".msstyles") == 0)
                fType = STYLE_FILE;
        } }
        if (fType == UNKNOWN)
        {
            DPRINT1("EnableVisualTheme(): Unknown file '%S'\n", ThemeFile);
            return;
        }
    }
 
    DPRINT1("Applying visual %s '%S'\n",
            (fType == THEME_FILE) ? "theme" : "style",
            ThemeFile ? ThemeFile : L"(Classic)");
 
//
// TODO: Use instead uxtheme!SetSystemVisualStyle() once it is implemented,
// https://stackoverflow.com/a/1036903
// https://pinvoke.net/default.aspx/uxtheme.SetSystemVisualStyle
// or ApplyTheme(NULL, 0, NULL) for restoring the classic theme.
//
// NOTE: The '/Action:ActivateMSTheme' is ReactOS-specific.
//
 
    if (ThemeFile && (fType == THEME_FILE))
    {
        /* Retrieve the visual style specified in the theme file.
         * If none, fall back to the classic theme. */
        if (GetPrivateProfileStringW(L"VisualStyles", L"Path", NULL,
                                     szStyleFile, _countof(szStyleFile), ThemeFile) && *szStyleFile)
        {
            /* Expand the path if possible */
            ThemeFile = szStyleFile;
            if (ExpandEnvironmentStringsW(ThemeFile, szPath, _countof(szPath)) != 0)
                ThemeFile = szPath;
        }
        else
        {
            ThemeFile = NULL;
        }
 
        DPRINT1("--> Applying visual style '%S'\n",
                ThemeFile ? ThemeFile : L"(Classic)");
    }
 
    if (ThemeFile)
    {
        WCHAR wszParams[1024];
        // FIXME: L"desk.cpl desk,@Appearance" regression, see commit 50d260a7f0
        PCWSTR format = L"desk.cpl,,2 /Action:ActivateMSTheme /file:\"%s\"";
 
        StringCchPrintfW(wszParams, _countof(wszParams), format, ThemeFile);
        RunControlPanelApplet(hwndParent, wszParams);
    }
    else
    {
        RunControlPanelApplet(hwndParent, L"desk.cpl,,2 /Action:ActivateMSTheme");
    }
}

Referenced by PreprocessUnattend(), and ThemePageDlgProc().

FinishDlgProc()

static INT_PTR CALLBACK FinishDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 2579 of file wizard.c.

{
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Get pointer to the global setup data */
            PSETUPDATA SetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
 
            if (!SetupData->UnattendSetup || !SetupData->DisableGeckoInst)
            {
                /* Run the Wine Gecko prompt */
                Control_RunDLLW(hwndDlg, 0, L"appwiz.cpl,,install_gecko", SW_SHOW);
            }
 
            /* Set title font */
            SendDlgItemMessage(hwndDlg,
                               IDC_FINISHTITLE,
                               WM_SETFONT,
                               (WPARAM)SetupData->hTitleFont,
                               (LPARAM)TRUE);
            if (SetupData->UnattendSetup)
            {
                KillTimer(hwndDlg, 1);
                SetInstallationCompleted();
                PostQuitMessage(0);
            }
        }
        break;
 
        case WM_DESTROY:
        {
            SetInstallationCompleted();
            PostQuitMessage(0);
            return TRUE;
        }
 
        case WM_TIMER:
        {
            INT Position;
            HWND hWndProgress;
 
            hWndProgress = GetDlgItem(hwndDlg, IDC_RESTART_PROGRESS);
            Position = SendMessage(hWndProgress, PBM_GETPOS, 0, 0);
            if (Position == 300)
            {
                KillTimer(hwndDlg, 1);
                PropSheet_PressButton(GetParent(hwndDlg), PSBTN_FINISH);
            }
            else
            {
                SendMessage(hWndProgress, PBM_SETPOS, Position + 1, 0);
            }
        }
        return TRUE;
 
        case WM_NOTIFY:
        {
            LPNMHDR lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                    /* Enable the correct buttons on for the active page */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_FINISH);
 
                    SendDlgItemMessage(hwndDlg, IDC_RESTART_PROGRESS, PBM_SETRANGE, 0,
                                       MAKELPARAM(0, 300));
                    SendDlgItemMessage(hwndDlg, IDC_RESTART_PROGRESS, PBM_SETPOS, 0, 0);
                    SetTimer(hwndDlg, 1, 50, NULL);
                    break;
 
                case PSN_WIZFINISH:
                    DestroyWindow(GetParent(hwndDlg));
                    break;
 
                default:
                    break;
            }
        }
        break;
 
        default:
            break;
    }
 
    return FALSE;
}

GenerateComputerName()

static void GenerateComputerName ( LPWSTR  lpBuffer )

static

Definition at line 1026 of file wizard.c.

{
    static const WCHAR Chars[] = L"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    static const unsigned cChars = sizeof(Chars) / sizeof(WCHAR) - 1;
    unsigned i;
 
    wcscpy(lpBuffer, L"REACTOS-");
 
    srand(GetTickCount());
 
    /* fill in 7 characters */
    for (i = 8; i < 15; i++)
        lpBuffer[i] = Chars[rand() % cChars];
 
    lpBuffer[15] = UNICODE_NULL; /* NULL-terminate */
}

Referenced by ComputerPageDlgProc().

GetInstallSourceWin32()

static BOOL GetInstallSourceWin32 ( OUT PWSTR  pwszPath, IN DWORD  cchPathMax, IN PCWSTR  pwszNTPath  )

static

Definition at line 2678 of file wizard.c.

{
    WCHAR wszDrives[512];
    WCHAR wszNTPath[512]; // MAX_PATH ?
    DWORD cchDrives;
    PWCHAR pwszDrive;
 
    *pwszPath = UNICODE_NULL;
 
    cchDrives = GetLogicalDriveStringsW(_countof(wszDrives) - 1, wszDrives);
    if (cchDrives == 0 || cchDrives >= _countof(wszDrives))
    {
        /* Buffer too small or failure */
        LogItem(NULL, L"GetLogicalDriveStringsW failed");
        return FALSE;
    }
 
    for (pwszDrive = wszDrives; *pwszDrive; pwszDrive += wcslen(pwszDrive) + 1)
    {
        WCHAR wszBuf[MAX_PATH];
 
        /* Retrieve the NT path corresponding to the current Win32 DOS path */
        pwszDrive[2] = UNICODE_NULL; // Temporarily remove the backslash
        QueryDosDeviceW(pwszDrive, wszNTPath, _countof(wszNTPath));
        pwszDrive[2] = L'\\';        // Restore the backslash
 
        wcscat(wszNTPath, L"\\");    // Concat a backslash
 
        /* Logging */
        wsprintf(wszBuf, L"Testing '%s' --> '%s' %s a CD",
                 pwszDrive, wszNTPath,
                 (GetDriveTypeW(pwszDrive) == DRIVE_CDROM) ? L"is" : L"is not");
        LogItem(NULL, wszBuf);
 
        /* Check whether the NT path corresponds to the NT installation source path */
        if (!_wcsicmp(wszNTPath, pwszNTPath))
        {
            /* Found it! */
            wcscpy(pwszPath, pwszDrive); // cchPathMax
 
            /* Logging */
            wsprintf(wszBuf, L"GetInstallSourceWin32: %s", pwszPath);
            LogItem(NULL, wszBuf);
            wcscat(wszBuf, L"\n");
            OutputDebugStringW(wszBuf);
 
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by ProcessSetupInf().

GetLargerTimeZoneEntry()

static PTIMEZONE_ENTRY GetLargerTimeZoneEntry ( PSETUPDATA  SetupData, DWORD  Index  )

static

Definition at line 1560 of file wizard.c.

{
    PTIMEZONE_ENTRY Entry;
 
    Entry = SetupData->TimeZoneListHead;
    while (Entry != NULL)
    {
        if (Entry->Index >= Index)
            return Entry;
 
        Entry = Entry->Next;
    }
 
    return NULL;
}

Referenced by RetrieveTimeZone().

GetLocalSystemTime()

static BOOL GetLocalSystemTime ( HWND  hwnd, PSETUPDATA  SetupData  )

static

Definition at line 1761 of file wizard.c.

{
    SYSTEMTIME Date;
    SYSTEMTIME Time;
 
    if (DateTime_GetSystemtime(GetDlgItem(hwnd, IDC_DATEPICKER), &Date) != GDT_VALID)
    {
        return FALSE;
    }
 
    if (DateTime_GetSystemtime(GetDlgItem(hwnd, IDC_TIMEPICKER), &Time) != GDT_VALID)
    {
        return FALSE;
    }
 
    SetupData->SystemTime.wYear = Date.wYear;
    SetupData->SystemTime.wMonth = Date.wMonth;
    SetupData->SystemTime.wDayOfWeek = Date.wDayOfWeek;
    SetupData->SystemTime.wDay = Date.wDay;
    SetupData->SystemTime.wHour = Time.wHour;
    SetupData->SystemTime.wMinute = Time.wMinute;
    SetupData->SystemTime.wSecond = Time.wSecond;
    SetupData->SystemTime.wMilliseconds = Time.wMilliseconds;
 
    return TRUE;
}

Referenced by WriteDateTimeSettings().

GplDlgProc()

static INT_PTR CALLBACK GplDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 122 of file wizard.c.

{
    HRSRC GplTextResource;
    HGLOBAL GplTextMem;
    PVOID GplTextLocked;
    PCHAR GplText;
    DWORD Size;
 
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
            GplTextResource = FindResourceW(hDllInstance, MAKEINTRESOURCE(IDR_GPL), L"RT_TEXT");
            if (NULL == GplTextResource)
            {
                break;
            }
            Size = SizeofResource(hDllInstance, GplTextResource);
            if (0 == Size)
            {
                break;
            }
            GplText = HeapAlloc(GetProcessHeap(), 0, Size + 1);
            if (NULL == GplText)
            {
                break;
            }
            GplTextMem = LoadResource(hDllInstance, GplTextResource);
            if (NULL == GplTextMem)
            {
                HeapFree(GetProcessHeap(), 0, GplText);
                break;
            }
            GplTextLocked = LockResource(GplTextMem);
            if (NULL == GplTextLocked)
            {
                HeapFree(GetProcessHeap(), 0, GplText);
                break;
            }
            memcpy(GplText, GplTextLocked, Size);
            GplText[Size] = '\0';
            SendMessageA(GetDlgItem(hwndDlg, IDC_GPL_TEXT), WM_SETTEXT, 0, (LPARAM) GplText);
            HeapFree(GetProcessHeap(), 0, GplText);
            SetFocus(GetDlgItem(hwndDlg, IDOK));
            return FALSE;
 
        case WM_CLOSE:
            EndDialog(hwndDlg, IDCANCEL);
            break;
 
        case WM_COMMAND:
            if (HIWORD(wParam) == BN_CLICKED && IDOK == LOWORD(wParam))
            {
                EndDialog(hwndDlg, IDOK);
            }
            break;
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by AckPageDlgProc().

InstallWizard()

VOID InstallWizard

(

VOID

)

Definition at line 3262 of file wizard.c.

{
    PROPSHEETHEADER psh = {0};
    HPROPSHEETPAGE *phpage = NULL;
    PROPSHEETPAGE psp = {0};
    UINT nPages = 0;
    HWND hWnd;
    MSG msg;
    PSETUPDATA pSetupData = NULL;
    HMODULE hNetShell = NULL;
    PFNREQUESTWIZARDPAGES pfn = NULL;
    DWORD dwPageCount = 10, dwNetworkPageCount = 0;
 
    LogItem(L"BEGIN_SECTION", L"InstallWizard");
 
    /* Allocate setup data */
    pSetupData = HeapAlloc(GetProcessHeap(),
                           HEAP_ZERO_MEMORY,
                           sizeof(SETUPDATA));
    if (pSetupData == NULL)
    {
        LogItem(NULL, L"SetupData allocation failed!");
        MessageBoxW(NULL,
                    L"Setup failed to allocate global data!",
                    L"ReactOS Setup",
                    MB_ICONERROR | MB_OK);
        goto done;
    }
    pSetupData->ProductOption = PRODUCT_OPTION_DEFAULT;
 
    hNetShell = LoadLibraryW(L"netshell.dll");
    if (hNetShell != NULL)
    {
        DPRINT("Netshell.dll loaded!\n");
 
        pfn = (PFNREQUESTWIZARDPAGES)GetProcAddress(hNetShell,
                                                    "NetSetupRequestWizardPages");
        if (pfn != NULL)
        {
            pfn(&dwNetworkPageCount, NULL, NULL);
            dwPageCount += dwNetworkPageCount;
        }
    }
 
    DPRINT("PageCount: %lu\n", dwPageCount);
 
    phpage = HeapAlloc(GetProcessHeap(),
                       HEAP_ZERO_MEMORY,
                       dwPageCount * sizeof(HPROPSHEETPAGE));
    if (phpage == NULL)
    {
        LogItem(NULL, L"Page array allocation failed!");
        MessageBoxW(NULL,
                    L"Setup failed to allocate page array!",
                    L"ReactOS Setup",
                    MB_ICONERROR | MB_OK);
        goto done;
    }
 
    /* Process the $winnt$.inf setup file */
    ProcessSetupInf(pSetupData);
 
    /* Create the Welcome page */
    psp.dwSize = sizeof(PROPSHEETPAGE);
    psp.dwFlags = PSP_DEFAULT | PSP_HIDEHEADER;
    psp.hInstance = hDllInstance;
    psp.lParam = (LPARAM)pSetupData;
    psp.pfnDlgProc = WelcomeDlgProc;
    psp.pszTemplate = MAKEINTRESOURCE(IDD_WELCOMEPAGE);
    phpage[nPages++] = CreatePropertySheetPage(&psp);
 
    /* Create the Acknowledgements page */
    psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
    psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_ACKTITLE);
    psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_ACKSUBTITLE);
    psp.pszTemplate = MAKEINTRESOURCE(IDD_ACKPAGE);
    psp.pfnDlgProc = AckPageDlgProc;
    phpage[nPages++] = CreatePropertySheetPage(&psp);
 
    /* Create the Product page */
    psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
    psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_PRODUCTTITLE);
    psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_PRODUCTSUBTITLE);
    psp.pszTemplate = MAKEINTRESOURCE(IDD_PRODUCT);
    psp.pfnDlgProc = ProductPageDlgProc;
    phpage[nPages++] = CreatePropertySheetPage(&psp);
 
    /* Create the Locale page */
    psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
    psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_LOCALETITLE);
    psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_LOCALESUBTITLE);
    psp.pfnDlgProc = LocalePageDlgProc;
    psp.pszTemplate = MAKEINTRESOURCE(IDD_LOCALEPAGE);
    phpage[nPages++] = CreatePropertySheetPage(&psp);
 
    /* Create the Owner page */
    psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
    psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_OWNERTITLE);
    psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_OWNERSUBTITLE);
    psp.pszTemplate = MAKEINTRESOURCE(IDD_OWNERPAGE);
    psp.pfnDlgProc = OwnerPageDlgProc;
    phpage[nPages++] = CreatePropertySheetPage(&psp);
 
    /* Create the Computer page */
    psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
    psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_COMPUTERTITLE);
    psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_COMPUTERSUBTITLE);
    psp.pfnDlgProc = ComputerPageDlgProc;
    psp.pszTemplate = MAKEINTRESOURCE(IDD_COMPUTERPAGE);
    phpage[nPages++] = CreatePropertySheetPage(&psp);
 
    /* Create the DateTime page */
    psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
    psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_DATETIMETITLE);
    psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_DATETIMESUBTITLE);
    psp.pfnDlgProc = DateTimePageDlgProc;
    psp.pszTemplate = MAKEINTRESOURCE(IDD_DATETIMEPAGE);
    phpage[nPages++] = CreatePropertySheetPage(&psp);
 
    /* Create the theme selection page */
    psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
    psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_THEMESELECTIONTITLE);
    psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_THEMESELECTIONSUBTITLE);
    psp.pfnDlgProc = ThemePageDlgProc;
    psp.pszTemplate = MAKEINTRESOURCE(IDD_THEMEPAGE);
    phpage[nPages++] = CreatePropertySheetPage(&psp);
 
    pSetupData->uFirstNetworkWizardPage = IDD_PROCESSPAGE;
    pSetupData->uPostNetworkWizardPage = IDD_PROCESSPAGE;
 
    if (pfn)
    {
        pfn(&dwNetworkPageCount, &phpage[nPages], pSetupData);
        nPages += dwNetworkPageCount;
    }
 
    /* Create the Process page */
    psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
    psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_PROCESSTITLE);
    psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_PROCESSSUBTITLE);
    psp.pfnDlgProc = ProcessPageDlgProc;
    psp.pszTemplate = MAKEINTRESOURCE(IDD_PROCESSPAGE);
    phpage[nPages++] = CreatePropertySheetPage(&psp);
 
    /* Create the Finish page */
    psp.dwFlags = PSP_DEFAULT | PSP_HIDEHEADER;
    psp.pfnDlgProc = FinishDlgProc;
    psp.pszTemplate = MAKEINTRESOURCE(IDD_FINISHPAGE);
    phpage[nPages++] = CreatePropertySheetPage(&psp);
 
    ASSERT(nPages == dwPageCount);
 
    /* Create the property sheet */
    psh.dwSize = sizeof(PROPSHEETHEADER);
    psh.dwFlags = PSH_WIZARD97 | PSH_WATERMARK | PSH_HEADER | PSH_MODELESS;
    psh.hInstance = hDllInstance;
    psh.hwndParent = NULL;
    psh.nPages = nPages;
    psh.nStartPage = 0;
    psh.phpage = phpage;
    psh.pszbmWatermark = MAKEINTRESOURCE(IDB_WATERMARK);
    psh.pszbmHeader = MAKEINTRESOURCE(IDB_HEADER);
 
    /* Create title font */
    pSetupData->hTitleFont = CreateTitleFont();
    pSetupData->hBoldFont  = CreateBoldFont();
 
    /* Display the wizard */
    hWnd = (HWND)PropertySheet(&psh);
    ShowWindow(hWnd, SW_SHOW);
 
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!IsDialogMessage(hWnd, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
 
    DeleteObject(pSetupData->hBoldFont);
    DeleteObject(pSetupData->hTitleFont);
 
    if (pSetupData->hSetupInf != INVALID_HANDLE_VALUE)
        SetupCloseInfFile(pSetupData->hSetupInf);
 
done:
    if (phpage != NULL)
        HeapFree(GetProcessHeap(), 0, phpage);
 
    if (hNetShell != NULL)
        FreeLibrary(hNetShell);
 
    if (pSetupData != NULL)
        HeapFree(GetProcessHeap(), 0, pSetupData);
 
    LogItem(L"END_SECTION", L"InstallWizard");
}

Referenced by InstallReactOS().

ItemCompletionThread()

static DWORD CALLBACK ItemCompletionThread ( LPVOID  Parameter )

static

Definition at line 2290 of file wizard.c.

{
    PITEMSDATA pItemsData;
    HWND hwndDlg;
 
    pItemsData = (PITEMSDATA)Parameter;
    hwndDlg = pItemsData->hwndDlg;
 
    /* Step 0 - Registering components */
    RegisterComponents(pItemsData);
 
    /* Step 1 - Installing start menu items */
    InstallStartMenuItems(pItemsData);
 
    /* FIXME: Add completion steps here! */
 
    // FIXME: Move this call to a separate cleanup page!
    RtlCreateBootStatusDataFile();
 
    /* Free the items data */
    HeapFree(GetProcessHeap(), 0, pItemsData);
 
    /* Tell the wizard page that we are done */
    PostMessage(hwndDlg, PM_ITEMS_DONE, 0, 0);
 
    return 0;
}

Referenced by RunItemCompletionThread().

LocalePageDlgProc()

static INT_PTR CALLBACK LocalePageDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1475 of file wizard.c.

{
    PSETUPDATA SetupData;
 
    /* Retrieve pointer to the global setup data */
    SetupData = (PSETUPDATA)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Save pointer to the global setup data */
            SetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
            SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (DWORD_PTR)SetupData);
            WriteUserLocale();
 
            SetUserLocaleName(GetDlgItem(hwndDlg, IDC_LOCALETEXT));
            SetKeyboardLayoutName(GetDlgItem(hwndDlg, IDC_LAYOUTTEXT));
        }
        break;
 
        case WM_COMMAND:
            if (HIWORD(wParam) == BN_CLICKED)
            {
                switch (LOWORD(wParam))
                {
                    case IDC_CUSTOMLOCALE:
                        RunControlPanelApplet(hwndDlg, L"intl.cpl,,5");
                        SetUserLocaleName(GetDlgItem(hwndDlg, IDC_LOCALETEXT));
                        break;
 
                    case IDC_CUSTOMLAYOUT:
                        RunControlPanelApplet(hwndDlg, L"input.dll,@1");
                        SetKeyboardLayoutName(GetDlgItem(hwndDlg, IDC_LAYOUTTEXT));
                        break;
                }
            }
            break;
 
        case WM_NOTIFY:
        {
            LPNMHDR lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                    /* Enable the Back and Next buttons */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
                    if (SetupData->UnattendSetup)
                    {
                        // if (!*SetupData->SourcePath)
                        {
                            RunControlPanelApplet(hwndDlg, L"intl.cpl,,/f:\"$winnt$.inf\""); // Should be in System32
                        }
 
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, IDD_OWNERPAGE);
                        return TRUE;
                    }
                    break;
 
                case PSN_WIZNEXT:
                    break;
 
                case PSN_WIZBACK:
                    SetupData->UnattendSetup = FALSE;
                    break;
 
                default:
                    break;
            }
        }
        break;
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by InstallWizard().

OnChooseOption()

static void OnChooseOption ( HWND  hwndDlg, PRODUCT_OPTION  nOption  )

static

Definition at line 635 of file wizard.c.

{
    WCHAR szText[256];
    ASSERT(0 <= nOption && nOption < _countof(s_ProductOptionData));
 
    switch (nOption)
    {
        case PRODUCT_OPTION_SERVER:
            LoadStringW(hDllInstance, IDS_PRODUCTSERVERINFO, szText, _countof(szText));
            break;
 
        case PRODUCT_OPTION_WORKSTATION:
            LoadStringW(hDllInstance, IDS_PRODUCTWORKSTATIONINFO, szText, _countof(szText));
            break;
 
        default:
            return;
    }
 
    SetDlgItemTextW(hwndDlg, IDC_PRODUCT_DESCRIPTION, szText);
}

Referenced by ProductPageDlgProc().

OwnerPageDlgProc()

static INT_PTR CALLBACK OwnerPageDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 794 of file wizard.c.

{
    WCHAR OwnerName[51];
    WCHAR OwnerOrganization[51];
    WCHAR Title[64];
    WCHAR ErrorName[256];
    LPNMHDR lpnm;
    PSETUPDATA pSetupData;
 
    pSetupData = (PSETUPDATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pSetupData);
 
            /* set a localized ('Owner') placeholder string as default */
            if (LoadStringW(hDllInstance, IDS_MACHINE_OWNER_NAME, OwnerName, _countof(OwnerName)))
            {
                SendDlgItemMessage(hwndDlg, IDC_OWNERNAME, WM_SETTEXT, 0, (LPARAM)OwnerName);
            }
 
            SendDlgItemMessage(hwndDlg, IDC_OWNERNAME, EM_LIMITTEXT, 50, 0);
            SendDlgItemMessage(hwndDlg, IDC_OWNERORGANIZATION, EM_LIMITTEXT, 50, 0);
 
            /* Set focus to owner name */
            SetFocus(GetDlgItem(hwndDlg, IDC_OWNERNAME));
 
            /* Select the default text to quickly overwrite it by typing */
            SendDlgItemMessage(hwndDlg, IDC_OWNERNAME, EM_SETSEL, 0, -1);
        }
        break;
 
 
        case WM_NOTIFY:
        {
            lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                    /* Enable the Back and Next buttons */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
                    if (pSetupData->UnattendSetup)
                    {
                        SendMessage(GetDlgItem(hwndDlg, IDC_OWNERNAME), WM_SETTEXT, 0, (LPARAM)pSetupData->OwnerName);
                        SendMessage(GetDlgItem(hwndDlg, IDC_OWNERORGANIZATION), WM_SETTEXT, 0, (LPARAM)pSetupData->OwnerOrganization);
                        if (WriteOwnerSettings(pSetupData->OwnerName, pSetupData->OwnerOrganization))
                        {
                            SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, IDD_COMPUTERPAGE);
                            return TRUE;
                        }
                    }
                    break;
 
                case PSN_WIZNEXT:
                    OwnerName[0] = 0;
                    if (GetDlgItemTextW(hwndDlg, IDC_OWNERNAME, OwnerName, 50) == 0)
                    {
                        if (0 == LoadStringW(hDllInstance, IDS_REACTOS_SETUP, Title, ARRAYSIZE(Title)))
                        {
                            wcscpy(Title, L"ReactOS Setup");
                        }
                        if (0 == LoadStringW(hDllInstance, IDS_WZD_NAME, ErrorName, ARRAYSIZE(ErrorName)))
                        {
                            wcscpy(ErrorName, L"Setup cannot continue until you enter your name.");
                        }
                        MessageBoxW(hwndDlg, ErrorName, Title, MB_ICONERROR | MB_OK);
 
                        SetFocus(GetDlgItem(hwndDlg, IDC_OWNERNAME));
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1);
 
                        return TRUE;
                    }
 
                    OwnerOrganization[0] = 0;
                    GetDlgItemTextW(hwndDlg, IDC_OWNERORGANIZATION, OwnerOrganization, 50);
 
                    if (!WriteOwnerSettings(OwnerName, OwnerOrganization))
                    {
                        SetFocus(GetDlgItem(hwndDlg, IDC_OWNERNAME));
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1);
                        return TRUE;
                    }
 
                case PSN_WIZBACK:
                    pSetupData->UnattendSetup = FALSE;
                    break;
 
                default:
                    break;
            }
        }
        break;
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by InstallWizard().

PathIsEqual()

static BOOL PathIsEqual ( IN LPCWSTR  lpPath1, IN LPCWSTR  lpPath2  )

static

Definition at line 3010 of file wizard.c.

{
    WCHAR szPath1[MAX_PATH];
    WCHAR szPath2[MAX_PATH];
 
    /* If something goes wrong, better return TRUE,
     * so the calling function returns early.
     */
    if (!PathCanonicalizeW(szPath1, lpPath1))
        return TRUE;
 
    if (!PathAddBackslashW(szPath1))
        return TRUE;
 
    if (!PathCanonicalizeW(szPath2, lpPath2))
        return TRUE;
 
    if (!PathAddBackslashW(szPath2))
        return TRUE;
 
    return (_wcsicmp(szPath1, szPath2) == 0);
}

Referenced by AddInstallationSource().

ProcessPageDlgProc()

static INT_PTR CALLBACK ProcessPageDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 2436 of file wizard.c.

{
    PSETUPDATA SetupData;
    PREGISTRATIONNOTIFY RegistrationNotify;
    static HICON s_hCheckIcon, s_hArrowIcon, s_hCrossIcon;
    static HFONT s_hNormalFont;
 
    /* Retrieve pointer to the global setup data */
    SetupData = (PSETUPDATA)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
            /* Save pointer to the global setup data */
            SetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
            SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (DWORD_PTR)SetupData);
            ShowWindow(GetDlgItem(hwndDlg, IDC_TASKTEXT3), SW_HIDE);
            ShowWindow(GetDlgItem(hwndDlg, IDC_TASKTEXT4), SW_HIDE);
            ShowWindow(GetDlgItem(hwndDlg, IDC_CHECK3), SW_HIDE);
            ShowWindow(GetDlgItem(hwndDlg, IDC_CHECK4), SW_HIDE);
            s_hCheckIcon = LoadImageW(hDllInstance, MAKEINTRESOURCEW(IDI_CHECKICON), IMAGE_ICON, 16, 16, 0);
            s_hArrowIcon = LoadImageW(hDllInstance, MAKEINTRESOURCEW(IDI_ARROWICON), IMAGE_ICON, 16, 16, 0);
            s_hCrossIcon = LoadImageW(hDllInstance, MAKEINTRESOURCEW(IDI_CROSSICON), IMAGE_ICON, 16, 16, 0);
            s_hNormalFont = (HFONT)SendDlgItemMessage(hwndDlg, IDC_TASKTEXT1, WM_GETFONT, 0, 0);
            break;
 
        case WM_DESTROY:
            DestroyIcon(s_hCheckIcon);
            DestroyIcon(s_hArrowIcon);
            DestroyIcon(s_hCrossIcon);
            break;
 
        case WM_NOTIFY:
            switch (((LPNMHDR)lParam)->code)
            {
                case PSN_SETACTIVE:
                    LogItem(L"BEGIN", L"ProcessPage");
 
                    /* Disable the Back and Next buttons */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), 0);
                    RunItemCompletionThread(hwndDlg);
                    break;
 
                case PSN_WIZNEXT:
                    LogItem(L"END", L"ProcessPage");
                    break;
 
                case PSN_WIZBACK:
                    SetupData->UnattendSetup = FALSE;
                    break;
 
                default:
                    break;
            }
            break;
 
        case PM_ITEM_START:
            DPRINT("PM_ITEM_START %lu\n", (ULONG)lParam);
            SendDlgItemMessage(hwndDlg, IDC_PROCESSPROGRESS, PBM_SETRANGE, 0, MAKELPARAM(0, (ULONG)lParam));
            SendDlgItemMessage(hwndDlg, IDC_PROCESSPROGRESS, PBM_SETPOS, 0, 0);
            SendDlgItemMessage(hwndDlg, IDC_TASKTEXT1 + wParam, WM_SETFONT, (WPARAM)SetupData->hBoldFont, (LPARAM)TRUE);
            SendDlgItemMessage(hwndDlg, IDC_CHECK1 + wParam, STM_SETIMAGE, IMAGE_ICON, (LPARAM)s_hArrowIcon);
            break;
 
        case PM_ITEM_END:
            DPRINT("PM_ITEM_END\n");
            SendDlgItemMessage(hwndDlg, IDC_TASKTEXT1 + wParam, WM_SETFONT, (WPARAM)s_hNormalFont, (LPARAM)TRUE);
            if (lParam == ERROR_SUCCESS)
            {
                SendDlgItemMessage(hwndDlg, IDC_CHECK1 + wParam, STM_SETIMAGE, IMAGE_ICON, (LPARAM)s_hCheckIcon);
            }
            else
            {
                SendDlgItemMessage(hwndDlg, IDC_CHECK1 + wParam, STM_SETIMAGE, IMAGE_ICON, (LPARAM)s_hCrossIcon);
                ShowItemError(hwndDlg, (DWORD)lParam);
            }
            break;
 
        case PM_STEP_START:
            DPRINT("PM_STEP_START\n");
            RegistrationNotify = (PREGISTRATIONNOTIFY)lParam;
            SendDlgItemMessage(hwndDlg, IDC_ITEM, WM_SETTEXT, 0,
                               (LPARAM)((RegistrationNotify->CurrentItem != NULL)? RegistrationNotify->CurrentItem : L""));
            break;
 
        case PM_STEP_END:
            DPRINT("PM_STEP_END\n");
            RegistrationNotify = (PREGISTRATIONNOTIFY)lParam;
            SendDlgItemMessage(hwndDlg, IDC_PROCESSPROGRESS, PBM_SETPOS, RegistrationNotify->Progress, 0);
            if (RegistrationNotify->LastError != ERROR_SUCCESS)
            {
                ShowStepError(hwndDlg, RegistrationNotify);
            }
            break;
 
        case PM_ITEMS_DONE:
            DPRINT("PM_ITEMS_DONE\n");
            /* Enable the Back and Next buttons */
            PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT);
            PropSheet_PressButton(GetParent(hwndDlg), PSBTN_NEXT);
            break;
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by InstallWizard().

ProcessSetupInf()

VOID ProcessSetupInf

(

IN OUT PSETUPDATA

pSetupData

)

Definition at line 3127 of file wizard.c.

{
    WCHAR szPath[MAX_PATH];
    WCHAR szValue[MAX_PATH];
    INFCONTEXT InfContext;
    DWORD LineLength;
    HKEY hKey;
    LONG res;
 
    pSetupData->hSetupInf = INVALID_HANDLE_VALUE;
 
    /* Retrieve the path of the setup INF */
    GetSystemDirectoryW(szPath, _countof(szPath));
    wcscat(szPath, L"\\$winnt$.inf");
 
    /* Open the setup INF */
    pSetupData->hSetupInf = SetupOpenInfFileW(szPath,
                                              NULL,
                                              INF_STYLE_OLDNT,
                                              NULL);
    if (pSetupData->hSetupInf == INVALID_HANDLE_VALUE)
    {
        DPRINT1("Error: Cannot open the setup information file %S with error %d\n", szPath, GetLastError());
        return;
    }
 
 
    /* Retrieve the NT source path from which the 1st-stage installer was run */
    if (!SetupFindFirstLineW(pSetupData->hSetupInf,
                             L"data",
                             L"sourcepath",
                             &InfContext))
    {
        DPRINT1("Error: Cannot find sourcepath Key! %d\n", GetLastError());
        return;
    }
 
    if (!SetupGetStringFieldW(&InfContext,
                              1,
                              szValue,
                              ARRAYSIZE(szValue),
                              &LineLength))
    {
        DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
        return;
    }
 
    *pSetupData->SourcePath = UNICODE_NULL;
 
    /* Close the setup INF as we are going to modify it manually */
    if (pSetupData->hSetupInf != INVALID_HANDLE_VALUE)
        SetupCloseInfFile(pSetupData->hSetupInf);
 
 
    /* Find the installation source path in Win32 format */
    if (!GetInstallSourceWin32(pSetupData->SourcePath,
                               _countof(pSetupData->SourcePath),
                               szValue))
    {
        *pSetupData->SourcePath = UNICODE_NULL;
    }
 
    /* Save the path in Win32 format in the setup INF */
    swprintf(szValue, L"\"%s\"", pSetupData->SourcePath);
    WritePrivateProfileStringW(L"data", L"dospath", szValue, szPath);
 
    /*
     * Save it also in the registry, in the following keys:
     * - HKLM\Software\Microsoft\Windows\CurrentVersion\Setup ,
     *   values "SourcePath" and "ServicePackSourcePath" (REG_SZ);
     * - HKLM\Software\Microsoft\Windows NT\CurrentVersion ,
     *   value "SourcePath" (REG_SZ); set to the full path (e.g. D:\I386).
     */
#if 0
    res = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                        L"Software\\Microsoft\\Windows NT\\CurrentVersion",
                        0,
                        KEY_ALL_ACCESS,
                        &hKey);
 
    if (res != ERROR_SUCCESS)
    {
        return FALSE;
    }
#endif
 
    res = RegCreateKeyExW(HKEY_LOCAL_MACHINE,
                          L"Software\\Microsoft\\Windows\\CurrentVersion\\Setup",
                          0, NULL,
                          REG_OPTION_NON_VOLATILE,
                          KEY_ALL_ACCESS, // KEY_WRITE
                          NULL,
                          &hKey,
                          NULL);
    if (res == ERROR_SUCCESS)
    {
        AddInstallationSource(hKey, pSetupData->SourcePath);
 
        res = RegSetValueExW(hKey,
                             L"SourcePath",
                             0,
                             REG_SZ,
                             (LPBYTE)pSetupData->SourcePath,
                             (wcslen(pSetupData->SourcePath) + 1) * sizeof(WCHAR));
 
        res = RegSetValueExW(hKey,
                             L"ServicePackSourcePath",
                             0,
                             REG_SZ,
                             (LPBYTE)pSetupData->SourcePath,
                             (wcslen(pSetupData->SourcePath) + 1) * sizeof(WCHAR));
 
        RegCloseKey(hKey);
    }
 
 
    /* Now, re-open the setup INF (this must succeed) */
    pSetupData->hSetupInf = SetupOpenInfFileW(szPath,
                                              NULL,
                                              INF_STYLE_OLDNT,
                                              NULL);
    if (pSetupData->hSetupInf == INVALID_HANDLE_VALUE)
    {
        DPRINT1("Error: Cannot open the setup information file %S with error %d\n", szPath, GetLastError());
        return;
    }
 
    /* Process the unattended section of the setup file */
    ProcessUnattendSection(pSetupData);
}

Referenced by InstallWizard().

ProcessUnattendSection()

VOID ProcessUnattendSection

(

IN OUT PSETUPDATA

pSetupData

)

Definition at line 2735 of file wizard.c.

{
    INFCONTEXT InfContext;
    WCHAR szName[256];
    WCHAR szValue[MAX_PATH];
    DWORD LineLength;
    HKEY hKey;
 
    if (!SetupFindFirstLineW(pSetupData->hSetupInf,
                             L"Unattend",
                             L"UnattendSetupEnabled",
                             &InfContext))
    {
        DPRINT1("Error: Cannot find UnattendSetupEnabled Key! %d\n", GetLastError());
        return;
    }
 
    if (!SetupGetStringFieldW(&InfContext,
                              1,
                              szValue,
                              ARRAYSIZE(szValue),
                              &LineLength))
    {
        DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
        return;
    }
 
    if (_wcsicmp(szValue, L"yes") != 0)
    {
        DPRINT("Unattend setup was disabled by UnattendSetupEnabled key.\n");
        return;
    }
 
    pSetupData->UnattendSetup = TRUE;
 
    if (!SetupFindFirstLineW(pSetupData->hSetupInf,
                             L"Unattend",
                             NULL,
                             &InfContext))
    {
        DPRINT1("Error: SetupFindFirstLine failed %d\n", GetLastError());
        return;
    }
 
    do
    {
        if (!SetupGetStringFieldW(&InfContext,
                                  0,
                                  szName,
                                  ARRAYSIZE(szName),
                                  &LineLength))
        {
            DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
            return;
        }
 
        if (!SetupGetStringFieldW(&InfContext,
                                  1,
                                  szValue,
                                  ARRAYSIZE(szValue),
                                  &LineLength))
        {
            DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
            return;
        }
        DPRINT1("Name %S Value %S\n", szName, szValue);
        if (!_wcsicmp(szName, L"FullName"))
        {
            if (ARRAYSIZE(pSetupData->OwnerName) > LineLength)
            {
                wcscpy(pSetupData->OwnerName, szValue);
            }
        }
        else if (!_wcsicmp(szName, L"OrgName"))
        {
            if (ARRAYSIZE(pSetupData->OwnerOrganization) > LineLength)
            {
                wcscpy(pSetupData->OwnerOrganization, szValue);
            }
        }
        else if (!_wcsicmp(szName, L"ComputerName"))
        {
            if (ARRAYSIZE(pSetupData->ComputerName) > LineLength)
            {
                wcscpy(pSetupData->ComputerName, szValue);
            }
        }
        else if (!_wcsicmp(szName, L"AdminPassword"))
        {
            if (ARRAYSIZE(pSetupData->AdminPassword) > LineLength)
            {
                wcscpy(pSetupData->AdminPassword, szValue);
            }
        }
        else if (!_wcsicmp(szName, L"TimeZoneIndex"))
        {
            pSetupData->TimeZoneIndex = _wtoi(szValue);
        }
        else if (!_wcsicmp(szName, L"DisableAutoDaylightTimeSet"))
        {
            pSetupData->DisableAutoDaylightTimeSet = _wtoi(szValue);
        }
        else if (!_wcsicmp(szName, L"DisableGeckoInst"))
        {
            if (!_wcsicmp(szValue, L"yes"))
                pSetupData->DisableGeckoInst = TRUE;
            else
                pSetupData->DisableGeckoInst = FALSE;
        }
        else if (!_wcsicmp(szName, L"ProductOption"))
        {
            pSetupData->ProductOption = (PRODUCT_OPTION)_wtoi(szValue);
        }
    } while (SetupFindNextLine(&InfContext, &InfContext));
 
    if (SetupFindFirstLineW(pSetupData->hSetupInf,
                            L"Display",
                            NULL,
                            &InfContext))
    {
        DEVMODEW dm = { { 0 } };
        dm.dmSize = sizeof(dm);
        if (EnumDisplaySettingsW(NULL, ENUM_CURRENT_SETTINGS, &dm))
        {
            do
            {
                int iValue;
                if (!SetupGetStringFieldW(&InfContext,
                                          0,
                                          szName,
                                          ARRAYSIZE(szName),
                                          &LineLength))
                {
                    DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
                    return;
                }
 
                if (!SetupGetStringFieldW(&InfContext,
                                          1,
                                          szValue,
                                          ARRAYSIZE(szValue),
                                          &LineLength))
                {
                    DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
                    return;
                }
                iValue = _wtoi(szValue);
                DPRINT1("Name %S Value %i\n", szName, iValue);
 
                if (!iValue)
                    continue;
 
                if (!_wcsicmp(szName, L"BitsPerPel"))
                {
                    dm.dmFields |= DM_BITSPERPEL;
                    dm.dmBitsPerPel = iValue;
                }
                else if (!_wcsicmp(szName, L"XResolution"))
                {
                    dm.dmFields |= DM_PELSWIDTH;
                    dm.dmPelsWidth = iValue;
                }
                else if (!_wcsicmp(szName, L"YResolution"))
                {
                    dm.dmFields |= DM_PELSHEIGHT;
                    dm.dmPelsHeight = iValue;
                }
                else if (!_wcsicmp(szName, L"VRefresh"))
                {
                    dm.dmFields |= DM_DISPLAYFREQUENCY;
                    dm.dmDisplayFrequency = iValue;
                }
            } while (SetupFindNextLine(&InfContext, &InfContext));
 
            ChangeDisplaySettingsW(&dm, CDS_UPDATEREGISTRY);
        }
    }
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                      L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce",
                      0,
                      KEY_SET_VALUE,
                      &hKey) != ERROR_SUCCESS)
    {
        DPRINT1("Error: failed to open HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce\n");
        return;
    }
 
    if (SetupFindFirstLineW(pSetupData->hSetupInf,
                            L"GuiRunOnce",
                            NULL,
                            &InfContext))
    {
        int i = 0;
        do
        {
            if (SetupGetStringFieldW(&InfContext,
                                     0,
                                     szValue,
                                     ARRAYSIZE(szValue),
                                     NULL))
            {
                WCHAR szPath[MAX_PATH];
                swprintf(szName, L"%d", i);
                DPRINT("szName %S szValue %S\n", szName, szValue);
 
                if (ExpandEnvironmentStringsW(szValue, szPath, MAX_PATH))
                {
                    DPRINT("value %S\n", szPath);
                    if (RegSetValueExW(hKey,
                                       szName,
                                       0,
                                       REG_SZ,
                                       (const BYTE*)szPath,
                                       (wcslen(szPath) + 1) * sizeof(WCHAR)) == ERROR_SUCCESS)
                    {
                        i++;
                    }
                }
            }
        } while (SetupFindNextLine(&InfContext, &InfContext));
    }
 
    RegCloseKey(hKey);
 
    if (SetupFindFirstLineW(pSetupData->hSetupInf,
        L"Env",
        NULL,
        &InfContext))
    {
        if (RegCreateKeyExW(
                HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment", 0, NULL,
                REG_OPTION_NON_VOLATILE, KEY_WRITE | KEY_READ, NULL, &hKey, NULL) != ERROR_SUCCESS)
        {
            DPRINT1("Error: failed to open HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment\n");
            return;
        }
        do
        {
            if (!SetupGetStringFieldW(&InfContext,
                0,
                szName,
                ARRAYSIZE(szName),
                &LineLength))
            {
                DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
                return;
            }
 
            if (!SetupGetStringFieldW(&InfContext,
                1,
                szValue,
                ARRAYSIZE(szValue),
                &LineLength))
            {
                DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
                return;
            }
            DPRINT1("[ENV] %S=%S\n", szName, szValue);
 
            DWORD dwType = wcschr(szValue, '%') != NULL ? REG_EXPAND_SZ : REG_SZ;
 
            if (RegSetValueExW(hKey, szName, 0, dwType, (const BYTE*)szValue, (DWORD)(wcslen(szValue) + 1) * sizeof(TCHAR)) != ERROR_SUCCESS)
            {
                DPRINT1(" - Error %d\n", GetLastError());
            }
 
        } while (SetupFindNextLine(&InfContext, &InfContext));
 
        RegCloseKey(hKey);
    }
}

Referenced by ProcessSetupInf().

ProductPageDlgProc()

static INT_PTR CALLBACK ProductPageDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 658 of file wizard.c.

{
    LPNMHDR lpnm;
    PSETUPDATA pSetupData;
    INT iItem;
    WCHAR szText[64], szDefault[64];
    HICON hIcon;
 
    pSetupData = (PSETUPDATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pSetupData);
 
            LoadStringW(hDllInstance, IDS_DEFAULT, szDefault, _countof(szDefault));
 
            LoadStringW(hDllInstance, IDS_PRODUCTSERVERNAME, szText, _countof(szText));
            if (PRODUCT_OPTION_DEFAULT == PRODUCT_OPTION_SERVER)
            {
                StringCchCatW(szText, _countof(szText), L" ");
                StringCchCatW(szText, _countof(szText), szDefault);
            }
            SendDlgItemMessageW(hwndDlg, IDC_PRODUCT_OPTIONS, CB_ADDSTRING, 0, (LPARAM)szText);
 
            LoadStringW(hDllInstance, IDS_PRODUCTWORKSTATIONNAME, szText, _countof(szText));
            if (PRODUCT_OPTION_DEFAULT == PRODUCT_OPTION_WORKSTATION)
            {
                StringCchCatW(szText, _countof(szText), L" ");
                StringCchCatW(szText, _countof(szText), szDefault);
            }
            SendDlgItemMessageW(hwndDlg, IDC_PRODUCT_OPTIONS, CB_ADDSTRING, 0, (LPARAM)szText);
 
            SendDlgItemMessageW(hwndDlg, IDC_PRODUCT_OPTIONS, CB_SETCURSEL, PRODUCT_OPTION_DEFAULT, 0);
            OnChooseOption(hwndDlg, PRODUCT_OPTION_DEFAULT);
 
            hIcon = LoadIcon(NULL, IDI_WINLOGO);
            SendDlgItemMessageW(hwndDlg, IDC_PRODUCT_ICON, STM_SETICON, (WPARAM)hIcon, 0);
            return TRUE;
        }
 
        case WM_COMMAND:
            if (HIWORD(wParam) == CBN_SELCHANGE && IDC_PRODUCT_OPTIONS == LOWORD(wParam))
            {
                iItem = SendDlgItemMessageW(hwndDlg, IDC_PRODUCT_OPTIONS, CB_GETCURSEL, 0, 0);
                OnChooseOption(hwndDlg, (PRODUCT_OPTION)iItem);
            }
            break;
 
        case WM_NOTIFY:
        {
            lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                    /* Enable the Back and Next buttons */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
                    if (pSetupData->UnattendSetup)
                    {
                        OnChooseOption(hwndDlg, pSetupData->ProductOption);
                        DoWriteProductOption(pSetupData->ProductOption);
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, IDD_LOCALEPAGE);
                        return TRUE;
                    }
                    break;
 
                case PSN_WIZNEXT:
                    iItem = SendDlgItemMessageW(hwndDlg, IDC_PRODUCT_OPTIONS, CB_GETCURSEL, 0, 0);
                    pSetupData->ProductOption = (PRODUCT_OPTION)iItem;
                    DoWriteProductOption(pSetupData->ProductOption);
                    break;
 
                case PSN_WIZBACK:
                    pSetupData->UnattendSetup = FALSE;
                    break;
 
                default:
                    break;
            }
        }
        break;
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by InstallWizard().

RegisterComponents()

static VOID RegisterComponents ( PITEMSDATA  pItemsData )

static

Definition at line 2241 of file wizard.c.

{
    WCHAR SectionName[512];
    INFCONTEXT Context;
    LONG Steps = 0;
    DWORD Error = NO_ERROR;
    REGISTRATIONNOTIFY Notify;
 
    ZeroMemory(&Notify, sizeof(Notify));
 
    /* Count the 'RegisterDlls' steps */
    if (!SetupFindFirstLineW(hSysSetupInf, L"RegistrationPhase2",
                             L"RegisterDlls", &Context))
    {
        DPRINT1("No RegistrationPhase2 section found\n");
        return;
    }
 
    if (!SetupGetStringFieldW(&Context, 1, SectionName,
                              ARRAYSIZE(SectionName),
                              NULL))
    {
        DPRINT1("Unable to retrieve section name\n");
        return;
    }
 
    Steps += SetupGetLineCountW(hSysSetupInf, SectionName);
 
    /* Count the 'TypeLibratries' steps */
    Steps += SetupGetLineCountW(hSysSetupInf, L"TypeLibraries");
 
    /* Start the item */
    DPRINT("Register Components: %ld Steps\n", Steps);
    SendMessage(pItemsData->hwndDlg, PM_ITEM_START, 0, (LPARAM)Steps);
 
    Error = RegisterDlls(pItemsData, &Notify);
    if (Error == ERROR_SUCCESS)
        RegisterTypeLibraries(pItemsData, &Notify, hSysSetupInf, L"TypeLibraries");
 
    /* End the item */
    DPRINT("Register Components: done\n");
    SendMessage(pItemsData->hwndDlg, PM_ITEM_END, 0, Error);
}

Referenced by ItemCompletionThread().

RegisterDlls()

static DWORD RegisterDlls ( _In_ PITEMSDATA  pItemsData, _In_ PREGISTRATIONNOTIFY  pNotify  )

static

Definition at line 2170 of file wizard.c.

{
    REGISTRATIONDATA RegistrationData;
    WCHAR SectionName[512];
    INFCONTEXT Context;
    LONG DllCount = 0;
    DWORD Error = NO_ERROR;
 
    ZeroMemory(&RegistrationData, sizeof(REGISTRATIONDATA));
    RegistrationData.hwndDlg = pItemsData->hwndDlg;
    RegistrationData.Registered = 0;
 
    if (!SetupFindFirstLineW(hSysSetupInf, L"RegistrationPhase2",
                             L"RegisterDlls", &Context))
    {
        DPRINT1("No RegistrationPhase2 section found\n");
        return GetLastError();
    }
 
    if (!SetupGetStringFieldW(&Context, 1, SectionName,
                              ARRAYSIZE(SectionName),
                              NULL))
    {
        DPRINT1("Unable to retrieve section name\n");
        return GetLastError();
    }
 
    DllCount = SetupGetLineCountW(hSysSetupInf, SectionName);
    DPRINT("SectionName %S DllCount %ld\n", SectionName, DllCount);
    if (DllCount < 0)
    {
        return STATUS_NOT_FOUND;
    }
 
    RegistrationData.DllCount = (ULONG)DllCount;
    RegistrationData.DefaultContext = SetupInitDefaultQueueCallback(RegistrationData.hwndDlg);
    RegistrationData.pNotify = pNotify;
 
    _SEH2_TRY
    {
        if (!SetupInstallFromInfSectionW(GetParent(RegistrationData.hwndDlg),
                                         hSysSetupInf,
                                         L"RegistrationPhase2",
                                         SPINST_REGISTRY | SPINST_REGISTERCALLBACKAWARE | SPINST_REGSVR,
                                         0,
                                         NULL,
                                         0,
                                         RegistrationNotificationProc,
                                         &RegistrationData,
                                         NULL,
                                         NULL))
        {
            Error = GetLastError();
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        DPRINT("Catching exception\n");
        Error = RtlNtStatusToDosError(_SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    SetupTermDefaultQueueCallback(RegistrationData.DefaultContext);
 
    return Error;
}

RegistrationNotificationProc()

static UINT CALLBACK RegistrationNotificationProc ( PVOID  Context, UINT  Notification, UINT_PTR  Param1, UINT_PTR  Param2  )

static

Definition at line 2074 of file wizard.c.

{
    PREGISTRATIONDATA RegistrationData;
    PSP_REGISTER_CONTROL_STATUSW StatusInfo;
    UINT MessageID;
 
    RegistrationData = (PREGISTRATIONDATA)Context;
 
    if (Notification == SPFILENOTIFY_STARTREGISTRATION ||
        Notification == SPFILENOTIFY_ENDREGISTRATION)
    {
        StatusInfo = (PSP_REGISTER_CONTROL_STATUSW) Param1;
        RegistrationData->pNotify->CurrentItem = wcsrchr(StatusInfo->FileName, L'\\');
        if (RegistrationData->pNotify->CurrentItem == NULL)
        {
            RegistrationData->pNotify->CurrentItem = StatusInfo->FileName;
        }
        else
        {
            RegistrationData->pNotify->CurrentItem++;
        }
 
        if (Notification == SPFILENOTIFY_STARTREGISTRATION)
        {
            DPRINT("Received SPFILENOTIFY_STARTREGISTRATION notification for %S\n",
                   StatusInfo->FileName);
            RegistrationData->pNotify->Progress = RegistrationData->Registered;
 
            DPRINT("RegisterDll: Start step %ld\n", RegistrationData->pNotify->Progress);
            SendMessage(RegistrationData->hwndDlg, PM_STEP_START, 0, (LPARAM)RegistrationData->pNotify);
        }
        else
        {
            DPRINT("Received SPFILENOTIFY_ENDREGISTRATION notification for %S\n",
                   StatusInfo->FileName);
            DPRINT("Win32Error %u FailureCode %u\n", StatusInfo->Win32Error,
                   StatusInfo->FailureCode);
            if (StatusInfo->FailureCode != SPREG_SUCCESS)
            {
                switch (StatusInfo->FailureCode)
                {
                    case SPREG_LOADLIBRARY:
                        MessageID = IDS_LOADLIBRARY_FAILED;
                        break;
                    case SPREG_GETPROCADDR:
                        MessageID = IDS_GETPROCADDR_FAILED;
                        break;
                    case SPREG_REGSVR:
                        MessageID = IDS_REGSVR_FAILED;
                        break;
                    case SPREG_DLLINSTALL:
                        MessageID = IDS_DLLINSTALL_FAILED;
                        break;
                    case SPREG_TIMEOUT:
                        MessageID = IDS_TIMEOUT;
                        break;
                    default:
                        MessageID = IDS_REASON_UNKNOWN;
                        break;
                }
 
                RegistrationData->pNotify->MessageID = MessageID;
                RegistrationData->pNotify->LastError = StatusInfo->Win32Error;
            }
            else
            {
                RegistrationData->pNotify->MessageID = 0;
                RegistrationData->pNotify->LastError = ERROR_SUCCESS;
            }
 
            if (RegistrationData->Registered < RegistrationData->DllCount)
            {
                RegistrationData->Registered++;
            }
 
            RegistrationData->pNotify->Progress = RegistrationData->Registered;
            DPRINT("RegisterDll: End step %ld\n", RegistrationData->pNotify->Progress);
            SendMessage(RegistrationData->hwndDlg, PM_STEP_END, 0, (LPARAM)RegistrationData->pNotify);
        }
 
        return FILEOP_DOIT;
    }
    else
    {
        DPRINT1("Received unexpected notification %u\n", Notification);
        return SetupDefaultQueueCallback(RegistrationData->DefaultContext,
                                         Notification, Param1, Param2);
    }
}

Referenced by RegisterDlls().

RetrieveTimeZone()

static LONG RetrieveTimeZone ( IN HKEY  hZoneKey, IN PVOID  Context  )

static

Definition at line 1577 of file wizard.c.

{
    LONG lError;
    PSETUPDATA SetupData = (PSETUPDATA)Context;
    PTIMEZONE_ENTRY Entry;
    PTIMEZONE_ENTRY Current;
    ULONG DescriptionSize;
    ULONG StandardNameSize;
    ULONG DaylightNameSize;
 
    Entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TIMEZONE_ENTRY));
    if (Entry == NULL)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    DescriptionSize  = sizeof(Entry->Description);
    StandardNameSize = sizeof(Entry->StandardName);
    DaylightNameSize = sizeof(Entry->DaylightName);
 
    lError = QueryTimeZoneData(hZoneKey,
                               &Entry->Index,
                               &Entry->TimezoneInfo,
                               Entry->Description,
                               &DescriptionSize,
                               Entry->StandardName,
                               &StandardNameSize,
                               Entry->DaylightName,
                               &DaylightNameSize);
    if (lError != ERROR_SUCCESS)
    {
        HeapFree(GetProcessHeap(), 0, Entry);
        return lError;
    }
 
    if (SetupData->TimeZoneListHead == NULL &&
        SetupData->TimeZoneListTail == NULL)
    {
        Entry->Prev = NULL;
        Entry->Next = NULL;
        SetupData->TimeZoneListHead = Entry;
        SetupData->TimeZoneListTail = Entry;
    }
    else
    {
        Current = GetLargerTimeZoneEntry(SetupData, Entry->Index);
        if (Current != NULL)
        {
            if (Current == SetupData->TimeZoneListHead)
            {
                /* Prepend to head */
                Entry->Prev = NULL;
                Entry->Next = SetupData->TimeZoneListHead;
                SetupData->TimeZoneListHead->Prev = Entry;
                SetupData->TimeZoneListHead = Entry;
            }
            else
            {
                /* Insert before current */
                Entry->Prev = Current->Prev;
                Entry->Next = Current;
                Current->Prev->Next = Entry;
                Current->Prev = Entry;
            }
        }
        else
        {
            /* Append to tail */
            Entry->Prev = SetupData->TimeZoneListTail;
            Entry->Next = NULL;
            SetupData->TimeZoneListTail->Next = Entry;
            SetupData->TimeZoneListTail = Entry;
        }
    }
 
    return ERROR_SUCCESS;
}

Referenced by CreateTimeZoneList().

RunControlPanelApplet()

static BOOL RunControlPanelApplet ( HWND  hwnd, PCWSTR  pwszCPLParameters  )

static

Definition at line 1309 of file wizard.c.

{
    MSG msg;
    HWND MainWindow = GetParent(hwnd);
    STARTUPINFOW StartupInfo;
    PROCESS_INFORMATION ProcessInformation;
    WCHAR CmdLine[MAX_PATH] = L"rundll32.exe shell32.dll,Control_RunDLL ";
 
    if (!pwszCPLParameters)
    {
        MessageBoxW(hwnd, L"Error: Failed to launch the Control Panel Applet.", NULL, MB_ICONERROR);
        return FALSE;
    }
 
    ZeroMemory(&StartupInfo, sizeof(StartupInfo));
    StartupInfo.cb = sizeof(StartupInfo);
    ZeroMemory(&ProcessInformation, sizeof(ProcessInformation));
 
    ASSERT(_countof(CmdLine) > wcslen(CmdLine) + wcslen(pwszCPLParameters));
    wcscat(CmdLine, pwszCPLParameters);
 
    if (!CreateProcessW(NULL,
                        CmdLine,
                        NULL,
                        NULL,
                        FALSE,
                        0,
                        NULL,
                        NULL,
                        &StartupInfo,
                        &ProcessInformation))
    {
        MessageBoxW(hwnd, L"Error: Failed to launch the Control Panel Applet.", NULL, MB_ICONERROR);
        return FALSE;
    }
 
    /* Disable the Back and Next buttons and the main window
     * while we're interacting with the control panel applet */
    PropSheet_SetWizButtons(MainWindow, 0);
    EnableWindow(MainWindow, FALSE);
 
    while ((MsgWaitForMultipleObjects(1, &ProcessInformation.hProcess, FALSE, INFINITE, QS_ALLINPUT|QS_ALLPOSTMESSAGE )) != WAIT_OBJECT_0)
    {
       /* We still need to process main window messages to avoid freeze */
       while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
       {
           TranslateMessage(&msg);
           DispatchMessageW(&msg);
       }
    }
    CloseHandle(ProcessInformation.hThread);
    CloseHandle(ProcessInformation.hProcess);
 
    /* Enable the Back and Next buttons and the main window again */
    PropSheet_SetWizButtons(MainWindow, PSWIZB_BACK | PSWIZB_NEXT);
    EnableWindow(MainWindow, TRUE);
 
    return TRUE;
}

Referenced by EnableVisualTheme(), and LocalePageDlgProc().

RunItemCompletionThread()

static BOOL RunItemCompletionThread ( _In_ HWND  hwndDlg )

static

Definition at line 2322 of file wizard.c.

{
    HANDLE hCompletionThread;
    PITEMSDATA pItemsData;
 
    pItemsData = HeapAlloc(GetProcessHeap(), 0, sizeof(ITEMSDATA));
    if (pItemsData == NULL)
        return FALSE;
 
    pItemsData->hwndDlg = hwndDlg;
 
    hCompletionThread = CreateThread(NULL,
                                     0,
                                     ItemCompletionThread,
                                     pItemsData,
                                     0,
                                     NULL);
    if (hCompletionThread == NULL)
    {
        HeapFree(GetProcessHeap(), 0, pItemsData);
    }
    else
    {
        CloseHandle(hCompletionThread);
        return TRUE;
    }
 
    return FALSE;
}

Referenced by ProcessPageDlgProc().

SetInstallationCompleted()

static VOID SetInstallationCompleted ( VOID  )

static

Definition at line 2550 of file wizard.c.

{
    HKEY hKey = 0;
    DWORD InProgress = 0;
    DWORD InstallDate;
 
    if (RegOpenKeyExW( HKEY_LOCAL_MACHINE,
                       L"SYSTEM\\Setup",
                       0,
                       KEY_WRITE,
                       &hKey ) == ERROR_SUCCESS)
    {
        RegSetValueExW( hKey, L"SystemSetupInProgress", 0, REG_DWORD, (LPBYTE)&InProgress, sizeof(InProgress) );
        RegCloseKey( hKey );
    }
 
    if (RegOpenKeyExW( HKEY_LOCAL_MACHINE,
                       L"Software\\Microsoft\\Windows NT\\CurrentVersion",
                       0,
                       KEY_WRITE,
                       &hKey ) == ERROR_SUCCESS)
    {
        InstallDate = (DWORD)time(NULL);
        RegSetValueExW( hKey, L"InstallDate", 0, REG_DWORD, (LPBYTE)&InstallDate, sizeof(InstallDate) );
        RegCloseKey( hKey );
    }
}

Referenced by FinishDlgProc().

SetKeyboardLayoutName()

static VOID SetKeyboardLayoutName ( HWND  hwnd )

static

Definition at line 1227 of file wizard.c.

{
    HKL hkl;
    BOOL LayoutSpecial = FALSE;
    WCHAR LayoutPath[256];
    WCHAR LocaleName[32];
    WCHAR SpecialId[5] = L"";
    WCHAR ResText[256] = L"";
    DWORD dwValueSize;
    HKEY hKey;
    UINT i;
 
    /* Get the default input language and method */
    if (!SystemParametersInfoW(SPI_GETDEFAULTINPUTLANG, 0, (LPDWORD)&hkl, 0))
    {
        hkl = GetKeyboardLayout(0);
    }
 
    if ((HIWORD(hkl) & 0xF000) == 0xF000)
    {
        /* Process keyboard layout with special id */
        StringCchPrintfW(SpecialId, ARRAYSIZE(SpecialId), L"%04x", (HIWORD(hkl) & 0x0FFF));
        LayoutSpecial = TRUE;
    }
 
#define MAX_LAYOUTS_PER_LANGID 0x10000
    for (i = 0; i < (LayoutSpecial ? MAX_LAYOUTS_PER_LANGID : 1); i++)
    {
        /* Generate a hexadecimal identifier for keyboard layout registry key */
        StringCchPrintfW(LocaleName, ARRAYSIZE(LocaleName), L"%08lx", (i << 16) | LOWORD(hkl));
 
        StringCchCopyW(LayoutPath, ARRAYSIZE(LayoutPath), L"SYSTEM\\CurrentControlSet\\Control\\Keyboard Layouts\\");
        StringCchCatW(LayoutPath, ARRAYSIZE(LayoutPath), LocaleName);
        *LocaleName = UNICODE_NULL;
 
        if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                          LayoutPath,
                          0,
                          KEY_ALL_ACCESS,
                          &hKey) == ERROR_SUCCESS)
        {
            /* Make sure the keyboard layout key we opened is the one we need.
             * If the layout has no special id, just pass this check. */
            dwValueSize = sizeof(LocaleName);
            if (!LayoutSpecial ||
                ((RegQueryValueExW(hKey,
                                   L"Layout Id",
                                   NULL,
                                   NULL,
                                   (PVOID)&LocaleName,
                                   &dwValueSize) == ERROR_SUCCESS) &&
                (wcscmp(LocaleName, SpecialId) == 0)))
            {
                *LocaleName = UNICODE_NULL;
                dwValueSize = sizeof(LocaleName);
                RegQueryValueExW(hKey,
                                 L"Layout Text",
                                 NULL,
                                 NULL,
                                 (PVOID)&LocaleName,
                                 &dwValueSize);
                /* Let the loop know where to stop */
                i = MAX_LAYOUTS_PER_LANGID;
            }
            RegCloseKey(hKey);
        }
        else
        {
            /* Keyboard layout registry keys are expected to go in order without gaps */
            break;
        }
    }
#undef MAX_LAYOUTS_PER_LANGID
 
    LoadStringW(hDllInstance, IDS_LAYOUTTEXT, ResText, ARRAYSIZE(ResText));
    StringCchPrintfW(LayoutPath, ARRAYSIZE(LayoutPath), ResText, LocaleName);
 
    SetWindowTextW(hwnd, LayoutPath);
}

Referenced by LocalePageDlgProc().

SetLocalTimeZone()

static VOID SetLocalTimeZone ( HWND  hwnd, PSETUPDATA  SetupData  )

static

Definition at line 1716 of file wizard.c.

{
    TIME_ZONE_INFORMATION TimeZoneInformation;
    PTIMEZONE_ENTRY Entry;
    DWORD dwIndex;
    DWORD i;
 
    dwIndex = SendMessage(hwnd,
                          CB_GETCURSEL,
                          0,
                          0);
 
    i = 0;
    Entry = SetupData->TimeZoneListHead;
    while (i < dwIndex)
    {
        if (Entry == NULL)
            return;
 
        i++;
        Entry = Entry->Next;
    }
 
    wcscpy(TimeZoneInformation.StandardName,
           Entry->StandardName);
    wcscpy(TimeZoneInformation.DaylightName,
           Entry->DaylightName);
 
    TimeZoneInformation.Bias = Entry->TimezoneInfo.Bias;
    TimeZoneInformation.StandardBias = Entry->TimezoneInfo.StandardBias;
    TimeZoneInformation.DaylightBias = Entry->TimezoneInfo.DaylightBias;
 
    memcpy(&TimeZoneInformation.StandardDate,
           &Entry->TimezoneInfo.StandardDate,
           sizeof(SYSTEMTIME));
    memcpy(&TimeZoneInformation.DaylightDate,
           &Entry->TimezoneInfo.DaylightDate,
           sizeof(SYSTEMTIME));
 
    /* Set time zone information */
    SetTimeZoneInformation(&TimeZoneInformation);
}

Referenced by WriteDateTimeSettings().

SetSystemLocalTime()

static BOOL SetSystemLocalTime ( HWND  hwnd, PSETUPDATA  SetupData  )

static

Definition at line 1790 of file wizard.c.

{
    BOOL Ret = FALSE;
 
    /*
     * Call SetLocalTime twice to ensure correct results
     */
    Ret = SetLocalTime(&SetupData->SystemTime) &&
          SetLocalTime(&SetupData->SystemTime);
 
    return Ret;
}

Referenced by WriteDateTimeSettings().

SetUserLocaleName()

static VOID SetUserLocaleName ( HWND  hwnd )

static

Definition at line 1210 of file wizard.c.

{
    WCHAR CurLocale[256] = L"";
    WCHAR CurGeo[256] = L"";
    WCHAR ResText[256] = L"";
    WCHAR LocaleText[256 * 2];
 
    GetLocaleInfoW(GetUserDefaultLCID(), LOCALE_SLANGUAGE, CurLocale, ARRAYSIZE(CurLocale));
    GetGeoInfoW(GetUserGeoID(GEOCLASS_NATION), GEO_FRIENDLYNAME, CurGeo, ARRAYSIZE(CurGeo), GetThreadLocale());
 
    LoadStringW(hDllInstance, IDS_LOCALETEXT, ResText, ARRAYSIZE(ResText));
    StringCchPrintfW(LocaleText, ARRAYSIZE(LocaleText), ResText, CurLocale, CurGeo);
 
    SetWindowTextW(hwnd, LocaleText);
}

Referenced by LocalePageDlgProc().

ShowItemError()

static VOID ShowItemError ( HWND  hwndDlg, DWORD  LastError  )

static

Definition at line 2355 of file wizard.c.

{
    LPWSTR ErrorMessage = NULL;
    WCHAR UnknownError[84];
    WCHAR Title[64];
 
    if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                       NULL, LastError, 0, ErrorMessage, 0, NULL) == 0)
    {
        if (LoadStringW(hDllInstance, IDS_UNKNOWN_ERROR,
                        UnknownError,
                        ARRAYSIZE(UnknownError) - 20) == 0)
        {
            wcscpy(UnknownError, L"Unknown error");
        }
        wcscat(UnknownError, L" ");
        _ultow(LastError, UnknownError + wcslen(UnknownError), 10);
        ErrorMessage = UnknownError;
    }
 
    if (ErrorMessage != NULL)
    {
        if (LoadStringW(hDllInstance, IDS_REACTOS_SETUP,
                        Title, ARRAYSIZE(Title)) == 0)
        {
            wcscpy(Title, L"ReactOS Setup");
        }
 
        MessageBoxW(hwndDlg, ErrorMessage, Title, MB_ICONERROR | MB_OK);
    }
 
    if (ErrorMessage != NULL &&
        ErrorMessage != UnknownError)
    {
        LocalFree(ErrorMessage);
    }
}

Referenced by ProcessPageDlgProc().

ShowStepError()

static VOID ShowStepError ( HWND  hwndDlg, PREGISTRATIONNOTIFY  RegistrationNotify  )

static

Definition at line 2398 of file wizard.c.

{
    WCHAR ErrorMessage[128];
    WCHAR Title[64];
 
    if (LoadStringW(hDllInstance, RegistrationNotify->MessageID,
                    ErrorMessage,
                    ARRAYSIZE(ErrorMessage)) == 0)
    {
        ErrorMessage[0] = L'\0';
    }
 
    if (RegistrationNotify->MessageID != IDS_TIMEOUT)
    {
        FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL,
                       RegistrationNotify->LastError, 0,
                       ErrorMessage + wcslen(ErrorMessage),
                       ARRAYSIZE(ErrorMessage) - wcslen(ErrorMessage),
                       NULL);
    }
 
    if (ErrorMessage[0] != L'\0')
    {
        if (LoadStringW(hDllInstance, IDS_REACTOS_SETUP,
                        Title, ARRAYSIZE(Title)) == 0)
        {
            wcscpy(Title, L"ReactOS Setup");
        }
 
        MessageBoxW(hwndDlg, ErrorMessage,
                    Title, MB_ICONERROR | MB_OK);
    }
}

Referenced by ProcessPageDlgProc().

ShowTimeZoneList()

static VOID ShowTimeZoneList ( HWND  hwnd, PSETUPDATA  SetupData, DWORD  dwEntryIndex  )

static

Definition at line 1686 of file wizard.c.

{
    PTIMEZONE_ENTRY Entry;
    DWORD dwIndex = 0;
    DWORD dwCount;
 
    GetTimeZoneListIndex(&dwEntryIndex);
 
    Entry = SetupData->TimeZoneListHead;
    while (Entry != NULL)
    {
        dwCount = SendMessage(hwnd,
                              CB_ADDSTRING,
                              0,
                              (LPARAM)Entry->Description);
 
        if (dwEntryIndex != 0 && dwEntryIndex == Entry->Index)
            dwIndex = dwCount;
 
        Entry = Entry->Next;
    }
 
    SendMessage(hwnd,
                CB_SETCURSEL,
                (WPARAM)dwIndex,
                0);
}

Referenced by DateTimePageDlgProc().

ThemePageDlgProc()

static INT_PTR CALLBACK ThemePageDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1963 of file wizard.c.

{
    PSETUPDATA SetupData;
    LPNMLISTVIEW pnmv;
 
    /* Retrieve pointer to the global setup data */
    SetupData = (PSETUPDATA)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            HWND hListView;
            HIMAGELIST himl;
            DWORD n;
            LVITEM lvi = {0};
 
            /* Save pointer to the global setup data */
            SetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
            SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (DWORD_PTR)SetupData);
 
            hListView = GetDlgItem(hwndDlg, IDC_THEMEPICKER);
 
            /* Common */
            himl = ImageList_Create(180, 163, ILC_COLOR32 | ILC_MASK, ARRAYSIZE(Themes), 1);
            lvi.mask = LVIF_TEXT | LVIF_IMAGE |LVIF_STATE;
 
            for (n = 0; n < ARRAYSIZE(Themes); ++n)
            {
                WCHAR DisplayName[100] = {0};
                /* Load the bitmap */
                HANDLE image = LoadImageW(hDllInstance, Themes[n].PreviewBitmap, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION);
                ImageList_AddMasked(himl, image, RGB(255,0,255));
 
                /* Load the string */
                LoadStringW(hDllInstance, Themes[n].DisplayName, DisplayName, ARRAYSIZE(DisplayName));
                DisplayName[ARRAYSIZE(DisplayName)-1] = UNICODE_NULL;
 
                /* Add the listview item */
                lvi.iItem  = n;
                lvi.iImage = n;
                lvi.pszText = DisplayName;
                ListView_InsertItem(hListView, &lvi);
            }
 
            /* Register the imagelist */
            ListView_SetImageList(hListView, himl, LVSIL_NORMAL);
            /* Transparent background */
            ListView_SetBkColor(hListView, CLR_NONE);
            ListView_SetTextBkColor(hListView, CLR_NONE);
            /* Reduce the size between the items */
            ListView_SetIconSpacing(hListView, 190, 173);
            break;
        }
 
        case WM_NOTIFY:
            switch (((LPNMHDR)lParam)->code)
            {
                //case LVN_ITEMCHANGING:
                case LVN_ITEMCHANGED:
                    pnmv = (LPNMLISTVIEW)lParam;
                    if ((pnmv->uChanged & LVIF_STATE) && (pnmv->uNewState & LVIS_SELECTED))
                    {
                        int iTheme = pnmv->iItem;
                        DPRINT1("Selected theme: %u\n", Themes[iTheme].DisplayName);
 
                        if (Themes[iTheme].ThemeFile)
                        {
                            WCHAR wszTheme[MAX_PATH];
                            SHGetFolderPathAndSubDirW(0, CSIDL_RESOURCES, NULL, SHGFP_TYPE_DEFAULT, Themes[iTheme].ThemeFile, wszTheme);
                            EnableVisualTheme(hwndDlg, wszTheme);
                        }
                        else
                        {
                            EnableVisualTheme(hwndDlg, Themes[iTheme].ThemeFile);
                        }
                    }
                    break;
                case PSN_SETACTIVE:
                    /* Enable the Back and Next buttons */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
                    if (SetupData->UnattendSetup)
                    {
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, SetupData->uFirstNetworkWizardPage);
                        return TRUE;
                    }
                    break;
 
                case PSN_WIZNEXT:
                    break;
 
                case PSN_WIZBACK:
                    SetupData->UnattendSetup = FALSE;
                    break;
 
                default:
                    break;
            }
            break;
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by InstallWizard().

UpdateLocalSystemTime()

static VOID UpdateLocalSystemTime ( HWND  hwnd, SYSTEMTIME  LocalTime  )

static

Definition at line 1805 of file wizard.c.

{
    DateTime_SetSystemtime(GetDlgItem(hwnd, IDC_DATEPICKER), GDT_VALID, &LocalTime);
    DateTime_SetSystemtime(GetDlgItem(hwnd, IDC_TIMEPICKER), GDT_VALID, &LocalTime);
}

Referenced by DateTimePageDlgProc().

WelcomeDlgProc()

static INT_PTR CALLBACK WelcomeDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 191 of file wizard.c.

{
    PSETUPDATA pSetupData;
 
    pSetupData = (PSETUPDATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            HWND hwndControl;
            DWORD dwStyle;
 
            /* Get pointer to the global setup data */
            pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pSetupData);
 
            hwndControl = GetParent(hwndDlg);
 
            /* Center the wizard window */
            CenterWindow (hwndControl);
 
            /* Hide the system menu */
            dwStyle = GetWindowLongPtr(hwndControl, GWL_STYLE);
            SetWindowLongPtr(hwndControl, GWL_STYLE, dwStyle & ~WS_SYSMENU);
 
            /* Hide and disable the 'Cancel' button */
            hwndControl = GetDlgItem(GetParent(hwndDlg), IDCANCEL);
            ShowWindow (hwndControl, SW_HIDE);
            EnableWindow (hwndControl, FALSE);
 
            /* Set title font */
            SendDlgItemMessage(hwndDlg,
                               IDC_WELCOMETITLE,
                               WM_SETFONT,
                               (WPARAM)pSetupData->hTitleFont,
                               (LPARAM)TRUE);
        }
        break;
 
 
        case WM_NOTIFY:
        {
            LPNMHDR lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                    LogItem(L"BEGIN", L"WelcomePage");
                    /* Enable the Next button */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT);
                    if (pSetupData->UnattendSetup)
                    {
                        SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, IDD_ACKPAGE);
                        return TRUE;
                    }
                    break;
 
                case PSN_WIZNEXT:
                    LogItem(L"END", L"WelcomePage");
                    break;
 
                case PSN_WIZBACK:
                    pSetupData->UnattendSetup = FALSE;
                    break;
 
                default:
                    break;
            }
        }
        break;
 
        default:
            break;
    }
 
    return FALSE;
}

WriteComputerSettings()

static BOOL WriteComputerSettings ( WCHAR *  ComputerName, HWND  hwndDlg  )

static

Definition at line 903 of file wizard.c.

{
    WCHAR Title[64];
    WCHAR ErrorComputerName[256];
    LONG lError;
    HKEY hKey = NULL;
 
    if (!SetComputerNameW(ComputerName))
    {
        if (hwndDlg != NULL)
        {
            if (0 == LoadStringW(hDllInstance, IDS_REACTOS_SETUP, Title, ARRAYSIZE(Title)))
            {
                wcscpy(Title, L"ReactOS Setup");
            }
            if (0 == LoadStringW(hDllInstance, IDS_WZD_SETCOMPUTERNAME, ErrorComputerName,
                                 ARRAYSIZE(ErrorComputerName)))
            {
                wcscpy(ErrorComputerName, L"Setup failed to set the computer name.");
            }
            MessageBoxW(hwndDlg, ErrorComputerName, Title, MB_ICONERROR | MB_OK);
        }
 
        return FALSE;
    }
 
    /* Set the physical DNS domain */
    SetComputerNameExW(ComputerNamePhysicalDnsDomain, L"");
 
    /* Set the physical DNS hostname */
    SetComputerNameExW(ComputerNamePhysicalDnsHostname, ComputerName);
 
    /* Set the accounts domain name */
    SetAccountsDomainSid(NULL, ComputerName);
 
    /* Now we need to set the Hostname */
    lError = RegCreateKeyExW(HKEY_LOCAL_MACHINE,
                             L"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters",
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_WRITE,
                             NULL,
                             &hKey,
                             NULL);
    if (lError == ERROR_SUCCESS)
    {
        lError = RegSetValueEx(hKey,
                               L"Hostname",
                               0,
                               REG_SZ,
                               (LPBYTE)ComputerName,
                               (wcslen(ComputerName) + 1) * sizeof(WCHAR));
        if (lError != ERROR_SUCCESS)
        {
            DPRINT1("RegSetValueEx(\"Hostname\") failed (%08lX)\n", lError);
        }
 
        RegCloseKey(hKey);
    }
    else
    {
        DPRINT1("RegCreateKeyExW for Tcpip\\Parameters failed (%08lX)\n", lError);
    }
 
    return TRUE;
}

Referenced by ComputerPageDlgProc().

WriteDateTimeSettings()

static BOOL WriteDateTimeSettings ( HWND  hwndDlg, PSETUPDATA  SetupData  )

static

Definition at line 1813 of file wizard.c.

{
    WCHAR Title[64];
    WCHAR ErrorLocalTime[256];
 
    GetLocalSystemTime(hwndDlg, SetupData);
    SetLocalTimeZone(GetDlgItem(hwndDlg, IDC_TIMEZONELIST),
                     SetupData);
 
    SetAutoDaylight(SendDlgItemMessage(hwndDlg, IDC_AUTODAYLIGHT,
                                       BM_GETCHECK, 0, 0) != BST_UNCHECKED);
    if (!SetSystemLocalTime(hwndDlg, SetupData))
    {
        if (0 == LoadStringW(hDllInstance, IDS_REACTOS_SETUP, Title, ARRAYSIZE(Title)))
        {
            wcscpy(Title, L"ReactOS Setup");
        }
        if (0 == LoadStringW(hDllInstance, IDS_WZD_LOCALTIME, ErrorLocalTime,
                             ARRAYSIZE(ErrorLocalTime)))
        {
            wcscpy(ErrorLocalTime, L"Setup was unable to set the local time.");
        }
        MessageBoxW(hwndDlg, ErrorLocalTime, Title, MB_ICONWARNING | MB_OK);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by DateTimePageDlgProc().

WriteDefaultLogonData()

static BOOL WriteDefaultLogonData ( LPWSTR  Domain )

static

Definition at line 974 of file wizard.c.

{
    WCHAR szAdministratorName[256];
    HKEY hKey = NULL;
    LONG lError;
 
    if (LoadStringW(hDllInstance,
                    IDS_ADMINISTRATOR_NAME,
                    szAdministratorName,
                    ARRAYSIZE(szAdministratorName)) == 0)
    {
        wcscpy(szAdministratorName, L"Administrator");
    }
 
    lError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                           L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon",
                           0,
                           KEY_SET_VALUE,
                           &hKey);
    if (lError != ERROR_SUCCESS)
        return FALSE;
 
    lError = RegSetValueEx(hKey,
                           L"DefaultDomainName",
                           0,
                           REG_SZ,
                           (LPBYTE)Domain,
                           (wcslen(Domain)+ 1) * sizeof(WCHAR));
    if (lError != ERROR_SUCCESS)
    {
        DPRINT1("RegSetValueEx(\"DefaultDomainName\") failed!\n");
    }
 
    lError = RegSetValueEx(hKey,
                           L"DefaultUserName",
                           0,
                           REG_SZ,
                           (LPBYTE)szAdministratorName,
                           (wcslen(szAdministratorName)+ 1) * sizeof(WCHAR));
    if (lError != ERROR_SUCCESS)
    {
        DPRINT1("RegSetValueEx(\"DefaultUserName\") failed!\n");
    }
 
    RegCloseKey(hKey);
 
    return TRUE;
}

Referenced by ComputerPageDlgProc().

WriteOwnerSettings()

static BOOL WriteOwnerSettings ( WCHAR *  OwnerName, WCHAR *  OwnerOrganization  )

static

Definition at line 752 of file wizard.c.

{
    HKEY hKey;
    LONG res;
 
    res = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                        L"Software\\Microsoft\\Windows NT\\CurrentVersion",
                        0,
                        KEY_ALL_ACCESS,
                        &hKey);
 
    if (res != ERROR_SUCCESS)
    {
        return FALSE;
    }
 
    res = RegSetValueExW(hKey,
                         L"RegisteredOwner",
                         0,
                         REG_SZ,
                         (LPBYTE)OwnerName,
                         (wcslen(OwnerName) + 1) * sizeof(WCHAR));
 
    if (res != ERROR_SUCCESS)
    {
        RegCloseKey(hKey);
        return FALSE;
    }
 
    res = RegSetValueExW(hKey,
                         L"RegisteredOrganization",
                         0,
                         REG_SZ,
                         (LPBYTE)OwnerOrganization,
                         (wcslen(OwnerOrganization) + 1) * sizeof(WCHAR));
 
    RegCloseKey(hKey);
    return (res == ERROR_SUCCESS);
}

Referenced by OwnerPageDlgProc().

WriteUserLocale()

static VOID WriteUserLocale ( VOID  )

static

Definition at line 1454 of file wizard.c.

{
    HKEY hKey;
    LCID lcid;
    WCHAR Locale[9] = L"0000";
 
    lcid = GetSystemDefaultLCID();
 
    if (GetLocaleInfoW(MAKELCID(lcid, SORT_DEFAULT), LOCALE_ILANGUAGE, &Locale[4], _countof(Locale) - 4) != 0)
    {
        if (RegCreateKeyExW(HKEY_CURRENT_USER, L"Control Panel\\International",
                            0, NULL, REG_OPTION_NON_VOLATILE,
                            KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS)
        {
            RegSetValueExW(hKey, L"Locale", 0, REG_SZ, (LPBYTE)Locale, (wcslen(Locale) + 1) * sizeof(WCHAR));
            RegCloseKey(hKey);
        }
    }
}

Referenced by LocalePageDlgProc().

Variable Documentation

s_DefaultSoundEvents

const WCHAR* s_DefaultSoundEvents[][2]

static

Initial value:

= 
{
    { L".Default", L"%SystemRoot%\\Media\\ReactOS_Default.wav" },
    { L"AppGPFault", L"" },
    { L"Close", L"" },
    { L"CriticalBatteryAlarm", L"%SystemRoot%\\Media\\ReactOS_Battery_Critical.wav" },
    { L"DeviceConnect",  L"%SystemRoot%\\Media\\ReactOS_Hardware_Insert.wav" },
    { L"DeviceDisconnect", L"%SystemRoot%\\Media\\ReactOS_Hardware_Remove.wav" },
    { L"DeviceFail", L"%SystemRoot%\\Media\\ReactOS_Hardware_Fail.wav" },
    { L"LowBatteryAlarm", L"%SystemRoot%\\Media\\ReactOS_Battery_Low.wav" },
    { L"MailBeep", L"%SystemRoot%\\Media\\ReactOS_Notify.wav" },
    { L"Maximize", L"%SystemRoot%\\Media\\ReactOS_Restore.wav" },
    { L"MenuCommand", L"%SystemRoot%\\Media\\ReactOS_Menu_Command.wav" },
    { L"MenuPopup", L"" },
    { L"Minimize", L"%SystemRoot%\\Media\\ReactOS_Minimize.wav" },
    { L"Open", L"" },
    { L"PrintComplete", L"%SystemRoot%\\Media\\ReactOS_Print_Complete.wav" },
    { L"RestoreDown", L"" },
    { L"RestoreUp", L"" },
    { L"SystemAsterisk", L"%SystemRoot%\\Media\\ReactOS_Ding.wav" },
    { L"SystemExclamation", L"%SystemRoot%\\Media\\ReactOS_Exclamation.wav" },
    { L"SystemExit", L"%SystemRoot%\\Media\\ReactOS_Shutdown.wav" },
    { L"SystemHand", L"%SystemRoot%\\Media\\ReactOS_Critical_Stop.wav" },
    { L"SystemNotification", L"%SystemRoot%\\Media\\ReactOS_Balloon.wav" },
    { L"SystemQuestion", L"%SystemRoot%\\Media\\ReactOS_Ding.wav" },
    { L"SystemStart", L"%SystemRoot%\\Media\\ReactOS_Startup.wav" },
    { L"WindowsLogoff", L"%SystemRoot%\\Media\\ReactOS_LogOff.wav" }
 
}

Definition at line 403 of file wizard.c.

Referenced by DoWriteProductOption().

s_ExplorerSoundEvents

const WCHAR* s_ExplorerSoundEvents[][2]

static

Initial value:

= 
{
    { L"EmptyRecycleBin", L"%SystemRoot%\\Media\\ReactOS_Recycle.wav" },
    { L"Navigating", L"%SystemRoot%\\Media\\ReactOS_Start.wav" }
}

Definition at line 433 of file wizard.c.

Referenced by DoWriteProductOption().

s_ProductOptionData

const PRODUCT_OPTION_DATA s_ProductOptionData[]

static

Initial value:

=
{
    { L"Terminal Server\0", L"ServerNT", 0, 0x200, 0 },
    { L"\0", L"WinNT", 1, 0x300, 1 }
}

Definition at line 397 of file wizard.c.

Referenced by DoWriteProductOption(), and OnChooseOption().

s_szControlWindows

const WCHAR s_szControlWindows[] = L"SYSTEM\\CurrentControlSet\\Control\\Windows"

static

Definition at line 383 of file wizard.c.

Referenced by DoWriteProductOption().

s_szDefaultSoundEvents

const WCHAR s_szDefaultSoundEvents[] = L"AppEvents\\Schemes\\Apps\\.Default"

static

Definition at line 385 of file wizard.c.

Referenced by DoWriteProductOption().

s_szExplorerSoundEvents

const WCHAR s_szExplorerSoundEvents[] = L"AppEvents\\Schemes\\Apps\\Explorer"

static

Definition at line 386 of file wizard.c.

Referenced by DoWriteProductOption().

s_szProductOptions

const WCHAR s_szProductOptions[] = L"SYSTEM\\CurrentControlSet\\Control\\ProductOptions"

static

Definition at line 381 of file wizard.c.

Referenced by DoWriteProductOption().

s_szRosVersion

const WCHAR s_szRosVersion[] = L"SYSTEM\\CurrentControlSet\\Control\\ReactOS\\Settings\\Version"

static

Definition at line 382 of file wizard.c.

Referenced by DoWriteProductOption().

s_szWinlogon

const WCHAR s_szWinlogon[] = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon"

static

Definition at line 384 of file wizard.c.

Referenced by DoWriteProductOption().

Themes

struct ThemeInfo Themes[]

static

Initial value:

= {
    { MAKEINTRESOURCE(IDB_CLASSIC), IDS_CLASSIC, NULL },
    { MAKEINTRESOURCE(IDB_LAUTUS), IDS_LAUTUS, L"themes\\lautus\\lautus.msstyles" },
    { MAKEINTRESOURCE(IDB_LUNAR), IDS_LUNAR, L"themes\\lunar\\lunar.msstyles" },
    { MAKEINTRESOURCE(IDB_MIZU), IDS_MIZU, L"themes\\mizu\\mizu.msstyles"},
}

Referenced by ThemePageDlgProc().