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	_REGISTRATIONNOTIFY
struct	_ITEMSDATA
struct	_REGISTRATIONDATA
struct	_TIMEZONE_ENTRY
struct	_PRODUCT_OPTION_DATA
struct	ThemeInfo

Macros
#define	NDEBUG
#define	PM_REGISTRATION_NOTIFY   (WM_APP + 1)
#define	PM_ITEM_START   (WM_APP + 2)
#define	PM_ITEM_END   (WM_APP + 3)
#define	PM_STEP_START   (WM_APP + 4)
#define	PM_STEP_END   (WM_APP + 5)
#define	PM_ITEMS_DONE   (WM_APP + 6)
#define	MAX_LAYOUTS_PER_LANGID   0x10000

Typedefs
typedef struct _REGISTRATIONNOTIFY	REGISTRATIONNOTIFY
typedef struct _REGISTRATIONNOTIFY *	PREGISTRATIONNOTIFY
typedef struct _ITEMSDATA	ITEMSDATA
typedef struct _ITEMSDATA *	PITEMSDATA
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)
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 (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.

PM_ITEM_END

#define PM_ITEM_END   (WM_APP + 3)

Definition at line 38 of file wizard.c.

PM_ITEM_START

#define PM_ITEM_START   (WM_APP + 2)

Definition at line 37 of file wizard.c.

PM_ITEMS_DONE

#define PM_ITEMS_DONE   (WM_APP + 6)

Definition at line 41 of file wizard.c.

PM_REGISTRATION_NOTIFY

#define PM_REGISTRATION_NOTIFY   (WM_APP + 1)

Definition at line 30 of file wizard.c.

PM_STEP_END

#define PM_STEP_END   (WM_APP + 5)

Definition at line 40 of file wizard.c.

PM_STEP_START

#define PM_STEP_START   (WM_APP + 4)

Definition at line 39 of file wizard.c.

Typedef Documentation

ITEMSDATA

typedef struct _ITEMSDATA ITEMSDATA

PFNREQUESTWIZARDPAGES

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

Definition at line 3134 of file wizard.c.

PITEMSDATA

typedef struct _ITEMSDATA * PITEMSDATA

PREGISTRATIONDATA

typedef struct _REGISTRATIONDATA * PREGISTRATIONDATA

PREGISTRATIONNOTIFY

typedef struct _REGISTRATIONNOTIFY * PREGISTRATIONNOTIFY

PRODUCT_OPTION_DATA

typedef struct _PRODUCT_OPTION_DATA PRODUCT_OPTION_DATA

PTIMEZONE_ENTRY

typedef struct _TIMEZONE_ENTRY * PTIMEZONE_ENTRY

REGISTRATIONDATA

typedef struct _REGISTRATIONDATA REGISTRATIONDATA

REGISTRATIONNOTIFY

typedef struct _REGISTRATIONNOTIFY REGISTRATIONNOTIFY

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 303 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 2911 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 84 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);
}

Referenced by WelcomeDlgProc().

ComputerPageDlgProc()

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

static

Definition at line 1067 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_THEMEPAGE);
                        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 1050 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 129 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 1597 of file wizard.c.

{
    EnumerateTimeZoneList(RetrieveTimeZone, SetupData);
}

Referenced by DateTimePageDlgProc().

CreateTitleFont()

static HFONT CreateTitleFont ( VOID  )

static

Definition at line 108 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;
}

Referenced by InstallWizard().

DateTimePageDlgProc()

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

static

Definition at line 1783 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, SetupData->uFirstNetworkWizardPage);
                        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 1603 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 551 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 468 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().

FinishDlgProc()

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

static

Definition at line 2454 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;
}

Referenced by InstallWizard().

GenerateComputerName()

static void GenerateComputerName ( LPWSTR  lpBuffer )

static

Definition at line 1049 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 2553 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 1499 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 1700 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 150 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 3137 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 2187 of file wizard.c.

{
    PITEMSDATA pItemsData;
    HWND hwndDlg;

    pItemsData = (PITEMSDATA)Parameter;
    hwndDlg = pItemsData->hwndDlg;

    RegisterDlls(pItemsData);

    RegisterTypeLibraries(hSysSetupInf, L"TypeLibraries");

    /* 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 1414 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 663 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 822 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 2885 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 2331 of file wizard.c.

{
    PSETUPDATA SetupData;
    PREGISTRATIONNOTIFY RegistrationNotify;

    /* 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_TASKTEXT2), SW_HIDE);
            ShowWindow(GetDlgItem(hwndDlg, IDC_TASKTEXT3), SW_HIDE);
            ShowWindow(GetDlgItem(hwndDlg, IDC_TASKTEXT4), SW_HIDE);
            break;

        case WM_NOTIFY:
            switch (((LPNMHDR)lParam)->code)
            {
                case PSN_SETACTIVE:
                    /* Disable the Back and Next buttons */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), 0);
                    RunItemCompletionThread(hwndDlg);
                    break;

                case PSN_WIZNEXT:
                    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);
            break;

        case PM_ITEM_END:
            DPRINT("PM_ITEM_END\n");
            if (lParam == ERROR_SUCCESS)
            {
            }
            else
            {
                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 3002 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 2610 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 686 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().

RegisterDlls()

static DWORD RegisterDlls ( PITEMSDATA  pItemsData )

static

Definition at line 2111 of file wizard.c.

{
    REGISTRATIONDATA RegistrationData;
    WCHAR SectionName[512];
    INFCONTEXT Context;
    LONG DllCount = 0;
    DWORD LastError = 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 FALSE;
    }

    if (!SetupGetStringFieldW(&Context, 1, SectionName,
                              ARRAYSIZE(SectionName),
                              NULL))
    {
        DPRINT1("Unable to retrieve section name\n");
        return FALSE;
    }

    DllCount = SetupGetLineCountW(hSysSetupInf, SectionName);
    DPRINT1("SectionName %S DllCount %ld\n", SectionName, DllCount);
    if (DllCount < 0)
    {
        SetLastError(STATUS_NOT_FOUND);
        return FALSE;
    }

    RegistrationData.DllCount = (ULONG)DllCount;
    RegistrationData.DefaultContext = SetupInitDefaultQueueCallback(RegistrationData.hwndDlg);

    SendMessage(pItemsData->hwndDlg, PM_ITEM_START, 0, (LPARAM)RegistrationData.DllCount);

    _SEH2_TRY
    {
        if (!SetupInstallFromInfSectionW(GetParent(RegistrationData.hwndDlg),
                                         hSysSetupInf,
                                         L"RegistrationPhase2",
                                         SPINST_REGISTRY | SPINST_REGISTERCALLBACKAWARE | SPINST_REGSVR,
                                         0,
                                         NULL,
                                         0,
                                         RegistrationNotificationProc,
                                         &RegistrationData,
                                         NULL,
                                         NULL))
        {
            LastError = GetLastError();
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        DPRINT("Catching exception\n");
        LastError = RtlNtStatusToDosError(_SEH2_GetExceptionCode());
    }
    _SEH2_END;

    SetupTermDefaultQueueCallback(RegistrationData.DefaultContext);

    SendMessage(pItemsData->hwndDlg, PM_ITEM_END, 0, LastError);

    return 0;
}

Referenced by ItemCompletionThread().

RegistrationNotificationProc()

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

static

Definition at line 2016 of file wizard.c.

{
    PREGISTRATIONDATA RegistrationData;
    REGISTRATIONNOTIFY RegistrationNotify;
    PSP_REGISTER_CONTROL_STATUSW StatusInfo;
    UINT MessageID;

    RegistrationData = (PREGISTRATIONDATA)Context;

    if (Notification == SPFILENOTIFY_STARTREGISTRATION ||
        Notification == SPFILENOTIFY_ENDREGISTRATION)
    {
        StatusInfo = (PSP_REGISTER_CONTROL_STATUSW) Param1;
        RegistrationNotify.CurrentItem = wcsrchr(StatusInfo->FileName, L'\\');
        if (RegistrationNotify.CurrentItem == NULL)
        {
            RegistrationNotify.CurrentItem = StatusInfo->FileName;
        }
        else
        {
            RegistrationNotify.CurrentItem++;
        }

        if (Notification == SPFILENOTIFY_STARTREGISTRATION)
        {
            DPRINT("Received SPFILENOTIFY_STARTREGISTRATION notification for %S\n",
                   StatusInfo->FileName);
            RegistrationNotify.ErrorMessage = NULL;
            RegistrationNotify.Progress = RegistrationData->Registered;
            SendMessage(RegistrationData->hwndDlg, PM_STEP_START, 0, (LPARAM)&RegistrationNotify);
        }
        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;
                }

                RegistrationNotify.MessageID = MessageID;
                RegistrationNotify.LastError = StatusInfo->Win32Error;
            }
            else
            {
                RegistrationNotify.MessageID = 0;
                RegistrationNotify.LastError = ERROR_SUCCESS;
            }

            if (RegistrationData->Registered < RegistrationData->DllCount)
            {
                RegistrationData->Registered++;
            }

            RegistrationNotify.Progress = RegistrationData->Registered;
            SendMessage(RegistrationData->hwndDlg, PM_STEP_END, 0, (LPARAM)&RegistrationNotify);
        }

        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 1516 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 1332 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;
}