reactos.c File Reference

#include "reactos.h"
#include <winnls.h>
#include <ndk/obfuncs.h>
#include "resource.h"
#include <debug.h>
#include <ndk/exfuncs.h>
#include <delayimp.h>
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for reactos.c:

Go to the source code of this file.

Classes
struct	_FSVOL_CONTEXT
struct	_COPYCONTEXT
struct	_CLOSABLE_WND_INFO
struct	DLGTEMPLATEEX

Macros
#define	NTOS_MODE_USER
#define	NDEBUG
#define	InstallVolume   (InstallPartition->Volume)
#define	SystemVolume   (SystemPartition->Volume)
#define	IDS_LIST_COLUMN_FIRST   IDS_INSTALLATION_NAME
#define	IDS_LIST_COLUMN_LAST   IDS_INSTALLATION_VENDOR
#define	MAX_LIST_COLUMNS   (IDS_LIST_COLUMN_LAST - IDS_LIST_COLUMN_FIRST + 1)
#define	PM_INSTALL_START   (WM_APP + 1)
#define	PM_INSTALL_DONE   (WM_APP + 2)
#define	DECLARE_UNICODE_STRING_SIZE(_var, _size)
#define	DELAYIMP_INSECURE_WRITABLE_HOOKS
#define	REACTOS_SETUP_MUTEX   L"__ReactOS_Setup__"

Typedefs
typedef VOID(NTAPI *	PGET_ENTRY_DESCRIPTION) (IN PGENERIC_LIST_ENTRY Entry, OUT PWSTR Buffer, IN SIZE_T cchBufferSize)
typedef VOID(NTAPI *	PADD_ENTRY_ITEM) (IN HWND hWndList, IN LVITEM *plvItem, IN PGENERIC_LIST_ENTRY Entry, IN OUT PWSTR Buffer, IN SIZE_T cchBufferSize)
typedef struct _FSVOL_CONTEXT	FSVOL_CONTEXT
typedef struct _FSVOL_CONTEXT *	PFSVOL_CONTEXT
typedef struct _COPYCONTEXT	COPYCONTEXT
typedef struct _COPYCONTEXT *	PCOPYCONTEXT
typedef struct _CLOSABLE_WND_INFO	CLOSABLE_WND_INFO
typedef struct _CLOSABLE_WND_INFO *	PCLOSABLE_WND_INFO
typedef struct DLGTEMPLATEEX	DLGTEMPLATEEX
typedef struct DLGTEMPLATEEX *	LPDLGTEMPLATEEX

Functions
static VOID	CenterWindow (HWND hWnd)
static HFONT	CreateBoldFont (_In_opt_ HFONT hOrigFont, _In_opt_ INT PointSize)
	Create a bold font derived from the provided font.
static HFONT	CreateTitleFont (_In_opt_ HFONT hOrigFont)
size_t	LoadAllocStringW (_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _In_opt_ _Outptr_ PWSTR *pString, _In_opt_ size_t cchBufferLen)
size_t	FormatAllocStringWV (_In_opt_ _Outptr_ PWSTR *pString, _In_opt_ size_t cchBufferLen, _In_ PCWSTR pszFormat, _In_ va_list args)
INT	DisplayMessageV (_In_opt_ HWND hWnd, _In_ UINT uType, _In_opt_ PCWSTR pszTitle, _In_opt_ PCWSTR pszFormatMessage, _In_ va_list args)
INT __cdecl	DisplayMessage (_In_opt_ HWND hWnd, _In_ UINT uType, _In_opt_ PCWSTR pszTitle, _In_opt_ PCWSTR pszFormatMessage,...)
INT __cdecl	DisplayError (_In_opt_ HWND hWnd, _In_ UINT uIDTitle, _In_ UINT uIDMessage,...)
VOID	SetWindowResTextW (_In_ HWND hWnd, _In_opt_ HINSTANCE hInstance, _In_ UINT uID)
VOID	SetWindowResPrintfVW (_In_ HWND hWnd, _In_opt_ HINSTANCE hInstance, _In_ UINT uID, _In_ va_list args)
VOID __cdecl	SetWindowResPrintfW (_In_ HWND hWnd, _In_opt_ HINSTANCE hInstance, _In_ UINT uID,...)
static INT_PTR CALLBACK	StartDlgProc (IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
static INT_PTR CALLBACK	TypeDlgProc (IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
BOOL	CreateListViewColumns (IN HINSTANCE hInstance, IN HWND hWndListView, IN const UINT *pIDs, IN const INT *pColsWidth, IN const INT *pColsAlign, IN UINT nNumOfColumns)
VOID	InitGenericComboList (IN HWND hWndList, IN PGENERIC_LIST List, IN PGET_ENTRY_DESCRIPTION GetEntryDescriptionProc)
PVOID	GetSelectedComboListItem (IN HWND hWndList)
VOID	InitGenericListView (IN HWND hWndList, IN PGENERIC_LIST List, IN PADD_ENTRY_ITEM AddEntryItemProc)
PVOID	GetSelectedListViewItem (IN HWND hWndList)
static VOID NTAPI	GetSettingDescription (IN PGENERIC_LIST_ENTRY Entry, OUT PWSTR Buffer, IN SIZE_T cchBufferSize)
static VOID NTAPI	AddNTOSInstallationItem (IN HWND hWndList, IN LVITEM *plvItem, IN PGENERIC_LIST_ENTRY Entry, IN OUT PWSTR Buffer, IN SIZE_T cchBufferSize)
static INT_PTR CALLBACK	UpgradeRepairDlgProc (IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
static INT_PTR CALLBACK	DeviceDlgProc (IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
static INT_PTR CALLBACK	SummaryDlgProc (IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
static BOOLEAN NTAPI	FormatCallback (_In_ CALLBACKCOMMAND Command, _In_ ULONG Modifier, _In_ PVOID Argument)
static BOOLEAN NTAPI	ChkdskCallback (_In_ CALLBACKCOMMAND Command, _In_ ULONG Modifier, _In_ PVOID Argument)
static FSVOL_OP CALLBACK	FsVolCallback (_In_opt_ PVOID Context, _In_ FSVOLNOTIFY FormatStatus, _In_ ULONG_PTR Param1, _In_ ULONG_PTR Param2)
static UINT CALLBACK	FileCopyCallback (PVOID Context, UINT Notification, UINT_PTR Param1, UINT_PTR Param2)
static VOID __cdecl	RegistryStatus (IN REGISTRY_STATUS RegStatus,...)
VOID	PropSheet_SetCloseCancel (_In_ HWND hWndWiz, _In_ BOOL Enable)
	Enable or disable the Cancel and the Close title-bar property-sheet buttons.
static DWORD WINAPI	PrepareAndDoCopyThread (IN LPVOID Param)
static INT_PTR CALLBACK	ProcessDlgProc (IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
static BOOL	IsShellActive (VOID)
	Detects whether a Windows shell is active.
static BOOL CALLBACK	FindUserClosableWindowProc (_In_ HWND hWnd, _In_ LPARAM lParam)
static BOOL	AreThereInteractiveWindows (_In_opt_ HWND hWndExclude)
	Detects whether there exist interactive closable windows opened.
static INT_PTR CALLBACK	FinishDlgProc (IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
BOOL	LoadSetupData (IN OUT PSETUPDATA pSetupData)
VOID	InitNtToWin32PathMappingList (IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList)
VOID	FreeNtToWin32PathMappingList (IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList)
BOOL	ConvertNtPathToWin32Path (IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList, OUT PWSTR pwszPath, IN DWORD cchPathMax, IN PCWSTR pwszNTPath)
BOOL	EnablePrivilege (IN LPCWSTR lpszPrivilegeName, IN BOOL bEnablePrivilege)
static DWORD CALLBACK	HotkeyThread (LPVOID Parameter)
static PCWSTR	GetLocalSetupDllPath (VOID)
static FARPROC WINAPI	setupDelayHook (unsigned dliNotify, PDelayLoadInfo pdli)
	Controls the delay-loading of Setup DLLs from a suitable path.
static LRESULT CALLBACK	PrshtWndProc (HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
static int CALLBACK	PropSheetCallback (_In_ HWND hDlg, _In_ UINT message, _In_ LPARAM lParam)
static HANDLE	CheckForOtherInstance (_In_ HINSTANCE hInstance)
	Ensure only one ReactOS Setup instance is running. If another instance already exists, find and activate its window.
int WINAPI	_tWinMain (HINSTANCE hInst, HINSTANCE hPrevInstance, LPTSTR lpszCmdLine, int nCmdShow)

Variables
HANDLE	ProcessHeap
SETUPDATA	SetupData
PPARTENTRY	InstallPartition = NULL
PPARTENTRY	SystemPartition = NULL
UI_CONTEXT	UiContext
HCURSOR	hWaitCursor
static const UINT	column_ids [MAX_LIST_COLUMNS] = {IDS_LIST_COLUMN_FIRST, IDS_LIST_COLUMN_FIRST + 1, IDS_LIST_COLUMN_FIRST + 2}
static const INT	column_widths [MAX_LIST_COLUMNS] = {200, 150, 100}
static const INT	column_alignment [MAX_LIST_COLUMNS] = {LVCFMT_LEFT, LVCFMT_LEFT, LVCFMT_LEFT}
PfnDliHook	__pfnDliNotifyHook2 = setupDelayHook
	Custom delay-loading hooks for loading the Setup DLLs from a suitable path.
PfnDliHook	__pfnDliFailureHook2 = setupDelayHook
WNDPROC	wpOrgPrshtProc = NULL
struct {
BOOL   IncludeForUnattended
DWORD   dwFlags
PCWSTR   pszTemplate
PCWSTR   pszHeaderTitle
PCWSTR   pszHeaderSubTitle
DLGPROC   pfnDlgProc
}	WizardPages []

Macro Definition Documentation

DECLARE_UNICODE_STRING_SIZE

#define DECLARE_UNICODE_STRING_SIZE	(		_var,
			_size
	)

Value:

  WCHAR _var ## _buffer[_size]; \
  UNICODE_STRING _var = { 0, (_size) * sizeof(WCHAR) , _var ## _buffer }

Definition at line 3423 of file reactos.c.

DELAYIMP_INSECURE_WRITABLE_HOOKS

#define DELAYIMP_INSECURE_WRITABLE_HOOKS

Definition at line 3428 of file reactos.c.

IDS_LIST_COLUMN_FIRST

#define IDS_LIST_COLUMN_FIRST   IDS_INSTALLATION_NAME

Definition at line 820 of file reactos.c.

IDS_LIST_COLUMN_LAST

#define IDS_LIST_COLUMN_LAST   IDS_INSTALLATION_VENDOR

Definition at line 821 of file reactos.c.

InstallVolume

#define InstallVolume   (InstallPartition->Volume)

Definition at line 29 of file reactos.c.

MAX_LIST_COLUMNS

#define MAX_LIST_COLUMNS   (IDS_LIST_COLUMN_LAST - IDS_LIST_COLUMN_FIRST + 1)

Definition at line 823 of file reactos.c.

NDEBUG

#define NDEBUG

Definition at line 18 of file reactos.c.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 13 of file reactos.c.

PM_INSTALL_DONE

#define PM_INSTALL_DONE   (WM_APP + 2)

Definition at line 1950 of file reactos.c.

PM_INSTALL_START

#define PM_INSTALL_START   (WM_APP + 1)

Definition at line 1949 of file reactos.c.

REACTOS_SETUP_MUTEX

#define REACTOS_SETUP_MUTEX   L"__ReactOS_Setup__"

SystemVolume

#define SystemVolume   (SystemPartition->Volume)

Definition at line 34 of file reactos.c.

Typedef Documentation

CLOSABLE_WND_INFO

typedef struct _CLOSABLE_WND_INFO CLOSABLE_WND_INFO

COPYCONTEXT

typedef struct _COPYCONTEXT COPYCONTEXT

DLGTEMPLATEEX

typedef struct DLGTEMPLATEEX DLGTEMPLATEEX

FSVOL_CONTEXT

typedef struct _FSVOL_CONTEXT FSVOL_CONTEXT

LPDLGTEMPLATEEX

typedef struct DLGTEMPLATEEX * LPDLGTEMPLATEEX

PADD_ENTRY_ITEM

typedef VOID(NTAPI * PADD_ENTRY_ITEM) (IN HWND hWndList, IN LVITEM *plvItem, IN PGENERIC_LIST_ENTRY Entry, IN OUT PWSTR Buffer, IN SIZE_T cchBufferSize)

Definition at line 687 of file reactos.c.

PCLOSABLE_WND_INFO

typedef struct _CLOSABLE_WND_INFO * PCLOSABLE_WND_INFO

PCOPYCONTEXT

typedef struct _COPYCONTEXT * PCOPYCONTEXT

PFSVOL_CONTEXT

typedef struct _FSVOL_CONTEXT * PFSVOL_CONTEXT

PGET_ENTRY_DESCRIPTION

typedef VOID(NTAPI * PGET_ENTRY_DESCRIPTION) (IN PGENERIC_LIST_ENTRY Entry, OUT PWSTR Buffer, IN SIZE_T cchBufferSize)

Definition at line 630 of file reactos.c.

Function Documentation

_tWinMain()

int WINAPI _tWinMain	(	HINSTANCE	hInst,
		HINSTANCE	hPrevInstance,
		LPTSTR	lpszCmdLine,
		int	nCmdShow
	)

Definition at line 3758 of file reactos.c.

{
    ULONG Error;
    HANDLE hHotkeyThread;
    INITCOMMONCONTROLSEX iccx;
    PROPSHEETHEADERW psh = {0};
    PROPSHEETPAGEW psp = {0};
    HPROPSHEETPAGE ahpsp[_countof(WizardPages)];
    UINT nPages, i;
 
    /* Ensure only one instance is running */
    if (!CheckForOtherInstance(hInst))
        return 0;
 
    ProcessHeap = GetProcessHeap();
 
    SetupData.hInstance = hInst;
    SetupData.hInstallThread = NULL;
    SetupData.hHaltInstallEvent = NULL;
    SetupData.bStopInstall = FALSE;
 
    /* Initialize the NT to Win32 path prefix mapping list */
    InitNtToWin32PathMappingList(&SetupData.MappingList);
 
    /* Initialize Setup */
    Error = InitializeSetup(&SetupData.USetupData, NULL,
                            &SpFileExports, &SpInfExports);
    if (Error != ERROR_SUCCESS)
    {
        //
        // TODO: Write an error mapper (much like the MUIDisplayError of USETUP)
        //
        if (Error == ERROR_NO_SOURCE_DRIVE)
            MessageBoxW(NULL, L"GetSourcePaths failed!", NULL, MB_ICONERROR);
        else if (Error == ERROR_LOAD_TXTSETUPSIF)
            DisplayError(NULL, IDS_CAPTION, IDS_NO_TXTSETUP_SIF);
        else // FIXME!!
            MessageBoxW(NULL, L"Unknown error!", NULL, MB_ICONERROR);
 
        goto Quit;
    }
 
    /* Retrieve any supplemental options from the unattend file */
    SetupData.bUnattend = CheckUnattendedSetup(&SetupData.USetupData);
 
    /* Load extra setup data (HW lists etc...) */
    if (!LoadSetupData(&SetupData))
        goto Quit;
 
    hHotkeyThread = CreateThread(NULL, 0, HotkeyThread, NULL, 0, NULL);
 
    /* Whenever any of the common controls are used in your app,
     * you must call InitCommonControlsEx() to register the classes
     * for those controls. */
    iccx.dwSize = sizeof(iccx);
    iccx.dwICC = ICC_LISTVIEW_CLASSES | ICC_TREEVIEW_CLASSES | ICC_PROGRESS_CLASS;
    InitCommonControlsEx(&iccx);
 
    /* Register the TreeList control */
    // RegisterTreeListClass(hInst);
    TreeListRegister(hInst);
 
    /* Create the title and bold fonts */
    SetupData.hTitleFont = CreateTitleFont(NULL);
    SetupData.hBoldFont  = CreateBoldFont(NULL, 0);
 
    /* Create each page */
    psp.dwSize = sizeof(psp);
    psp.hInstance = hInst;
    psp.lParam = (LPARAM)&SetupData;
    for (nPages = 0, i = 0; i < _countof(WizardPages); ++i)
    {
        /* Skip pages that don't apply to unattended mode */
        if (SetupData.bUnattend && !WizardPages[i].IncludeForUnattended)
            continue;
 
        psp.dwFlags = PSP_DEFAULT | WizardPages[i].dwFlags;
        psp.pszTemplate = WizardPages[i].pszTemplate;
#if 1
        // FIXME: HACK: Wine comctl32 propsheet.c doesn't correctly set the wizard
        // dialog title when the pages don't have captions, even if the user sends
        // an initial PSM_SETTITLE message via the callback -- see CORE-20687.
        // To avert this problem, force-set the same title to each page, before
        // creating the wizard.
        psp.dwFlags |= PSP_USETITLE;
        psp.pszTitle = MAKEINTRESOURCEW(IDS_CAPTION);
#endif
        psp.pfnDlgProc = WizardPages[i].pfnDlgProc;
        psp.pszHeaderTitle = WizardPages[i].pszHeaderTitle;
        psp.pszHeaderSubTitle = WizardPages[i].pszHeaderSubTitle;
        ahpsp[nPages++] = CreatePropertySheetPage(&psp);
    }
 
    /* Create the property sheet */
    psh.dwSize = sizeof(psh);
    psh.dwFlags = PSH_WIZARD97 | PSH_USEICONID | PSH_USECALLBACK | PSH_WATERMARK | PSH_HEADER;
    psh.hInstance = hInst;
    psh.hwndParent = NULL;
    psh.pszIcon = MAKEINTRESOURCEW(IDI_MAIN);
    psh.nPages = nPages;
    psh.nStartPage = 0;
    psh.phpage = ahpsp;
    psh.pfnCallback = PropSheetCallback;
    psh.pszbmWatermark = MAKEINTRESOURCEW(IDB_WATERMARK);
    psh.pszbmHeader = MAKEINTRESOURCEW(IDB_HEADER);
 
    /* Display the wizard */
    PropertySheetW(&psh);
 
    if (SetupData.hBoldFont)
        DeleteFont(SetupData.hBoldFont);
    if (SetupData.hTitleFont)
        DeleteFont(SetupData.hTitleFont);
 
    /* Unregister the TreeList control */
    // UnregisterTreeListClass(hInst);
    TreeListUnregister(hInst);
 
    if (hHotkeyThread)
    {
        PostThreadMessageW(GetThreadId(hHotkeyThread), WM_QUIT, 0, 0);
        CloseHandle(hHotkeyThread);
    }
 
Quit:
    /* Setup has finished */
    FinishSetup(&SetupData.USetupData);
 
    /* Free the NT to Win32 path prefix mapping list */
    FreeNtToWin32PathMappingList(&SetupData.MappingList);
 
    /* Force reboot if there are no other user-interactive windows opened */
    SetupData.bMustReboot |= !AreThereInteractiveWindows(NULL);
 
    /* System rebooting will be done by Winlogon if necessary */
    if (SetupData.bMustReboot)
    {
#if 1 // TESTING: Disable for testing the installer locally.
        EnablePrivilege(SE_SHUTDOWN_NAME, TRUE);
        ExitWindowsEx(EWX_REBOOT, 0);
        EnablePrivilege(SE_SHUTDOWN_NAME, FALSE);
#else
        DisplayMessage(NULL, MB_ICONWARNING, L"Restarting", L"Setup is now restarting your computer!");
#endif
    }
    return 0;
}

AddNTOSInstallationItem()

static VOID NTAPI AddNTOSInstallationItem ( IN HWND  hWndList, IN LVITEM *  plvItem, IN PGENERIC_LIST_ENTRY  Entry, IN OUT PWSTR  Buffer, IN SIZE_T  cchBufferSize  )

static

Definition at line 764 of file reactos.c.

{
    PNTOS_INSTALLATION NtOsInstall = (PNTOS_INSTALLATION)GetListEntryData(Entry);
    PVOLINFO VolInfo = (NtOsInstall->Volume ? &NtOsInstall->Volume->Info : NULL);
 
    if (VolInfo && VolInfo->DriveLetter)
    {
        /* We have retrieved a partition that is mounted */
        StringCchPrintfW(Buffer, cchBufferSize,
                         L"%c:%s",
                         VolInfo->DriveLetter,
                         NtOsInstall->PathComponent);
    }
    else
    {
        /* We failed somewhere, just show the NT path */
        StringCchPrintfW(Buffer, cchBufferSize,
                         L"%wZ",
                         &NtOsInstall->SystemNtPath);
    }
 
    plvItem->mask = LVIF_IMAGE | LVIF_TEXT | LVIF_PARAM;
    plvItem->iItem = 0;
    plvItem->iSubItem = 0;
    plvItem->lParam = (LPARAM)Entry;
    plvItem->pszText = NtOsInstall->InstallationName;
 
    /* Associate vendor icon */
    if (FindSubStrI(NtOsInstall->VendorName, VENDOR_REACTOS))
    {
        plvItem->mask |= LVIF_IMAGE;
        plvItem->iImage = 0;
    }
    else if (FindSubStrI(NtOsInstall->VendorName, VENDOR_MICROSOFT))
    {
        plvItem->mask |= LVIF_IMAGE;
        plvItem->iImage = 1;
    }
 
    plvItem->iItem = SendMessageW(hWndList, LVM_INSERTITEMW, 0, (LPARAM)plvItem);
 
    plvItem->iSubItem = 1;
    plvItem->pszText = Buffer; // SystemRootPath;
    SendMessageW(hWndList, LVM_SETITEMTEXTW, plvItem->iItem, (LPARAM)plvItem);
 
    plvItem->iSubItem = 2;
    plvItem->pszText = NtOsInstall->VendorName;
    SendMessageW(hWndList, LVM_SETITEMTEXTW, plvItem->iItem, (LPARAM)plvItem);
}

Referenced by UpgradeRepairDlgProc().

AreThereInteractiveWindows()

static BOOL AreThereInteractiveWindows ( _In_opt_ HWND  hWndExclude )

static

Detects whether there exist interactive closable windows opened.

Definition at line 2676 of file reactos.c.

{
    /* Return success if a shell is active */
    if (IsShellActive())
    {
        return TRUE;
    }
    /* Otherwise, check for user-interactive closable windows */
    else
    {
        CLOSABLE_WND_INFO Info = {hWndExclude, FALSE};
        EnumWindows(FindUserClosableWindowProc, (LPARAM)&Info);
        return Info.Found;
    }
}

Referenced by _tWinMain(), and FinishDlgProc().

CenterWindow()

static VOID CenterWindow ( HWND  hWnd )

static

Definition at line 45 of file reactos.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 FinishDlgProc(), CEditCompatModes::OnInitDialog(), CConfirmReplace::OnInitDialog(), CZipPassword::OnInitDialog(), and PrshtWndProc().

CheckForOtherInstance()

static HANDLE CheckForOtherInstance ( _In_ HINSTANCE  hInstance )

static

Ensure only one ReactOS Setup instance is running. If another instance already exists, find and activate its window.

Returns

A handle to the instance mutex if this is the first instance, or NULL if another running instance already exists.

Definition at line 3704 of file reactos.c.

{
#define REACTOS_SETUP_MUTEX L"__ReactOS_Setup__"
 
    static HANDLE s_hMutex = NULL;
 
    /* If we are already running an instance, just return it */
    if (s_hMutex)
        return s_hMutex;
 
    /* Try to create or open the mutex. Use the Global namespace
     * if it exists; otherwise fall back to the default one. */
    s_hMutex = CreateMutexW(NULL, FALSE, L"Global\\" REACTOS_SETUP_MUTEX);
    if (!s_hMutex && (GetLastError() == ERROR_PATH_NOT_FOUND))
        s_hMutex = CreateMutexW(NULL, FALSE, REACTOS_SETUP_MUTEX);
    if (!s_hMutex)
        return NULL; /* Failed to create the mutex */
 
    if (GetLastError() == ERROR_ALREADY_EXISTS)
    {
        /* The mutex was created by another instance */
        WCHAR szCaption[128];
        PWSTR Title = szCaption; // Use the static buffer by default.
        HWND hWnd = NULL;
 
        /* Find and activate its window */
        (void)LoadAllocStringW(hInstance, IDS_CAPTION, &Title, _countof(szCaption));
        if (Title)
        {
            /* Locate the window (PropertySheetW uses the dialog class)
             * and retrieve the last popup it may have open */
            HWND hWndMain = FindWindowW(L"#32770", Title);
            hWnd = GetLastActivePopup(hWndMain);
            if (!hWnd) hWnd = hWndMain;
 
            if (Title != szCaption)
                HeapFree(GetProcessHeap(), 0, Title);
        }
        if (hWnd)
        {
            ShowWindow(hWnd, SW_SHOWNA);
            SwitchToThisWindow(hWnd, TRUE);
        }
 
        CloseHandle(s_hMutex);
        return NULL;
    }
 
    /* We are the first instance */
    return s_hMutex;
}

Referenced by _tWinMain().

ChkdskCallback()

static BOOLEAN NTAPI ChkdskCallback ( _In_ CALLBACKCOMMAND  Command, _In_ ULONG  Modifier, _In_ PVOID  Argument  )

static

Definition at line 1412 of file reactos.c.

{
    switch (Command)
    {
        default:
            DPRINT("Unknown callback %lu\n", (ULONG)Command);
            break;
    }
 
    return TRUE;
}

ConvertNtPathToWin32Path()

BOOL ConvertNtPathToWin32Path	(	IN OUT PNT_WIN32_PATH_MAPPING_LIST	MappingList,
		OUT PWSTR	pwszPath,
		IN DWORD	cchPathMax,
		IN PCWSTR	pwszNTPath
	)

Definition at line 3043 of file reactos.c.

{
    BOOL FoundDrive = FALSE, RetryOnce = FALSE;
    PLIST_ENTRY ListEntry;
    PNT_WIN32_PATH_MAPPING Entry;
    PCWSTR pwszNtPathToMap = pwszNTPath;
    PCWSTR pwszRemaining = NULL;
    DWORD cchDrives;
    PWCHAR pwszDrive;
    WCHAR wszDrives[512];
    WCHAR wszNTPath[MAX_PATH];
    WCHAR TargetPath[MAX_PATH];
 
    *pwszPath = UNICODE_NULL;
 
    /*
     * We find first a mapping inside the MappingList. If one is found, use it
     * to build the Win32 path. If there is none, we need to create one by
     * checking the Win32 drives (and possibly NT symlinks too).
     * In case of success, add the newly found mapping to the list and use it
     * to build the Win32 path.
     */
 
    for (ListEntry = MappingList->List.Flink;
         ListEntry != &MappingList->List;
         ListEntry = ListEntry->Flink)
    {
        Entry = CONTAINING_RECORD(ListEntry, NT_WIN32_PATH_MAPPING, ListEntry);
 
        DPRINT("Testing '%S' --> '%S'\n", Entry->Win32Path, Entry->NtPath);
 
        /* Check whether the queried NT path prefixes the user-provided NT path */
        FoundDrive = !_wcsnicmp(pwszNtPathToMap, Entry->NtPath, wcslen(Entry->NtPath));
        if (FoundDrive)
        {
            /* Found it! */
 
            /* Set the pointers and go build the Win32 path */
            pwszDrive = Entry->Win32Path;
            pwszRemaining = pwszNTPath + wcslen(Entry->NtPath);
            goto Quit;
        }
    }
 
    /*
     * No mapping exists for this path yet: try to find one now.
     */
 
    /* Retrieve the mounted drives (available drive letters) */
    cchDrives = GetLogicalDriveStringsW(_countof(wszDrives) - 1, wszDrives);
    if (cchDrives == 0 || cchDrives >= _countof(wszDrives))
    {
        /* Buffer too small or failure */
        DPRINT1("ConvertNtPathToWin32Path: GetLogicalDriveStringsW failed\n");
        return FALSE;
    }
 
/* We go back there once if RetryOnce == TRUE */
Retry:
 
    /* Enumerate the mounted drives */
    for (pwszDrive = wszDrives; *pwszDrive; pwszDrive += wcslen(pwszDrive) + 1)
    {
        /* 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
 
        DPRINT("Testing '%S' --> '%S'\n", pwszDrive, wszNTPath);
 
        /* Check whether the queried NT path prefixes the user-provided NT path */
        FoundDrive = !_wcsnicmp(pwszNtPathToMap, wszNTPath, wcslen(wszNTPath));
        if (!FoundDrive)
        {
            PWCHAR ptr, ptr2;
 
            /*
             * Check whether this was a network share that has a drive letter,
             * but the user-provided NT path points to this share without
             * mentioning the drive letter.
             *
             * The format is: \Device<network_redirector>\;X:<data>\share\path
             * The corresponding drive letter is 'X'.
             * A system-provided network redirector (LanManRedirector or Mup)
             * or a 3rd-party one may be used.
             *
             * We check whether the user-provided NT path has the form:
             * \Device<network_redirector><data>\share\path
             * as it obviously did not have the full form (the previous check
             * would have been OK otherwise).
             */
            if (!_wcsnicmp(wszNTPath, L"\\Device\\", _countof(L"\\Device\\")-1) &&
                (ptr = wcschr(wszNTPath + _countof(L"\\Device\\")-1, L'\\')) &&
                wcslen(++ptr) >= 3 && ptr[0] == L';' && ptr[2] == L':')
            {
                /*
                 * Normally the specified drive letter should correspond
                 * to the one used for the mapping. But we will ignore
                 * if it happens not to be the case.
                 */
                if (pwszDrive[0] != ptr[1])
                {
                    DPRINT1("Peculiar: expected network share drive letter %C different from actual one %C\n",
                            pwszDrive[0], ptr[1]);
                }
 
                /* Remove the drive letter from the NT network share path */
                ptr2 = ptr + 3;
                /* Swallow as many possible consecutive backslashes as there could be */
                while (*ptr2 == L'\\') ++ptr2;
 
                memmove(ptr, ptr2, (wcslen(ptr2) + 1) * sizeof(WCHAR));
 
                /* Now do the check again */
                FoundDrive = !_wcsnicmp(pwszNtPathToMap, wszNTPath, wcslen(wszNTPath));
            }
        }
        if (FoundDrive)
        {
            /* Found it! */
 
            pwszDrive[2] = UNICODE_NULL; // Remove the backslash
 
            if (pwszNtPathToMap == pwszNTPath)
            {
                ASSERT(!RetryOnce && pwszNTPath != TargetPath);
                pwszRemaining = pwszNTPath + wcslen(wszNTPath);
            }
            break;
        }
    }
 
    if (FoundDrive)
    {
        /* A mapping was found, add it to the cache */
        Entry = HeapAlloc(ProcessHeap, HEAP_ZERO_MEMORY, sizeof(*Entry));
        if (!Entry)
        {
            DPRINT1("ConvertNtPathToWin32Path: Cannot allocate memory\n");
            return FALSE;
        }
        StringCchCopyNW(Entry->NtPath, _countof(Entry->NtPath),
                        pwszNTPath, pwszRemaining - pwszNTPath);
        StringCchCopyW(Entry->Win32Path, _countof(Entry->Win32Path), pwszDrive);
 
        /* Insert it as the most recent entry */
        InsertHeadList(&MappingList->List, &Entry->ListEntry);
        MappingList->MappingsCount++;
 
        /* Set the pointers and go build the Win32 path */
        pwszDrive = Entry->Win32Path;
        goto Quit;
    }
 
    /*
     * We failed, perhaps because the beginning of the NT path used a symlink.
     * Try to see whether this is the case by attempting to resolve it.
     * If the symlink resolution gives nothing, or we already failed once,
     * there is no hope in converting the path to Win32.
     * Otherwise, symlink resolution succeeds but we need to recheck again
     * the drives list.
     */
 
    /*
     * In theory we would have to parse each element in the NT path and going
     * until finding a symlink object (otherwise we would fail straight away).
     * However here we can use guessing instead, since we know which kind of
     * NT paths we are likely to manipulate: \Device\HarddiskX\PartitionY\ and
     * the like (including \Device\HarddiskVolumeX\‍) and the other ones that
     * are supported in setuplib\utils\arcname.c .
     *
     * But actually, all the supported names in arcname.c are real devices,
     * and only \Device\HarddiskX\PartitionY\ may refer to a symlink, so we
     * just check for it.
     */
    if (!RetryOnce && !FoundDrive)
    {
        ULONG DiskNumber, PartitionNumber;
        INT Length;
 
        NTSTATUS Status;
        OBJECT_ATTRIBUTES ObjectAttributes;
        HANDLE LinkHandle;
        UNICODE_STRING SymLink, Target;
 
        if (swscanf(pwszNTPath, L"\\Device\\Harddisk%lu\\Partition%lu%n",
                    &DiskNumber, &PartitionNumber, &Length) != 2)
        {
            /* Definitively not a recognized path, bail out */
            return FALSE;
        }
 
        /* Check whether \Device\HarddiskX\PartitionY is a symlink */
        RtlInitEmptyUnicodeString(&SymLink, (PWCHAR)pwszNTPath, Length * sizeof(WCHAR));
        SymLink.Length = SymLink.MaximumLength;
 
        InitializeObjectAttributes(&ObjectAttributes,
                                   &SymLink,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);
        Status = NtOpenSymbolicLinkObject(&LinkHandle,
                                          SYMBOLIC_LINK_QUERY,
                                          &ObjectAttributes);
        if (!NT_SUCCESS(Status))
        {
            /* Not a symlink, or something else happened: bail out */
            DPRINT1("ConvertNtPathToWin32Path: NtOpenSymbolicLinkObject(%wZ) failed, Status 0x%08lx\n",
                    &SymLink, Status);
            return FALSE;
        }
 
        *TargetPath = UNICODE_NULL;
        RtlInitEmptyUnicodeString(&Target, TargetPath, sizeof(TargetPath));
 
        /* Resolve the link and close its handle */
        Status = NtQuerySymbolicLinkObject(LinkHandle, &Target, NULL);
        NtClose(LinkHandle);
 
        /* Check for success */
        if (!NT_SUCCESS(Status))
        {
            /* Not a symlink, or something else happened: bail out */
            DPRINT1("ConvertNtPathToWin32Path: NtQuerySymbolicLinkObject(%wZ) failed, Status 0x%08lx\n",
                    &SymLink, Status);
            return FALSE;
        }
 
        /* Set the pointers */
        pwszRemaining = pwszNTPath + Length;
        pwszNtPathToMap = TargetPath; // Point to our local buffer
 
        /* Retry once */
        RetryOnce = TRUE;
        goto Retry;
    }
 
    ASSERT(!FoundDrive);
 
Quit:
    if (FoundDrive)
    {
        StringCchPrintfW(pwszPath, cchPathMax,
                         L"%s%s",
                         pwszDrive,
                         pwszRemaining);
        DPRINT("ConvertNtPathToWin32Path: %S\n", pwszPath);
        return TRUE;
    }
 
    return FALSE;
}

Referenced by SetupOpenInfFileExW().

CreateBoldFont()

static HFONT CreateBoldFont ( _In_opt_ HFONT  hOrigFont, _In_opt_ INT  PointSize  )

static

Create a bold font derived from the provided font.

Definition at line 72 of file reactos.c.

{
    LOGFONTW lf = {0};
 
    if (hOrigFont)
    {
        GetObjectW(hOrigFont, sizeof(lf), &lf);
    }
    else
    {
        NONCLIENTMETRICSW ncm;
        ncm.cbSize = sizeof(ncm);
        SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
        lf = ncm.lfMessageFont;
    }
 
    /* Make the font bold, keeping the other attributes */
    lf.lfWeight = FW_BOLD;
 
    /* Determine the font height (logical units) if necessary */
    if (PointSize)
    {
        HDC hdc = GetDC(NULL);
        lf.lfHeight = -MulDiv(PointSize, GetDeviceCaps(hdc, LOGPIXELSY), 72);
        // lf.lfWidth = 0;
        ReleaseDC(NULL, hdc);
    }
 
    return CreateFontIndirect(&lf);
}

Referenced by _tWinMain(), CreateTitleFont(), and ProgressDlg::ProcessWindowMessage().

CreateListViewColumns()

BOOL CreateListViewColumns	(	IN HINSTANCE	hInstance,
		IN HWND	hWndListView,
		IN const UINT *	pIDs,
		IN const INT *	pColsWidth,
		IN const INT *	pColsAlign,
		IN UINT	nNumOfColumns
	)

Definition at line 598 of file reactos.c.

{
    UINT i;
    LVCOLUMN lvC;
    WCHAR szText[50];
 
    /* Create the columns */
    lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
    lvC.pszText = szText;
 
    /* Load the column labels from the resource file */
    for (i = 0; i < nNumOfColumns; i++)
    {
        lvC.iSubItem = i;
        lvC.cx = pColsWidth[i];
        lvC.fmt = pColsAlign[i];
 
        LoadStringW(hInstance, pIDs[i], szText, ARRAYSIZE(szText));
 
        if (ListView_InsertColumn(hWndListView, i, &lvC) == -1)
            return FALSE;
    }
 
    return TRUE;
}

Referenced by UpgradeRepairDlgProc().

CreateTitleFont()

static HFONT CreateTitleFont ( _In_opt_ HFONT  hOrigFont )

inlinestatic

Definition at line 106 of file reactos.c.

{
    /* Title font is 12pt bold */
    return CreateBoldFont(hOrigFont, 12);
}

Referenced by _tWinMain().

DeviceDlgProc()

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

static

Definition at line 1029 of file reactos.c.

{
    PSETUPDATA pSetupData;
    HWND hList;
 
    /* Retrieve pointer to the global setup data */
    pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Save pointer to the global setup data */
            pSetupData = (PSETUPDATA)((LPPROPSHEETPAGEW)lParam)->lParam;
            SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
 
            hList = GetDlgItem(hwndDlg, IDC_COMPUTER);
            InitGenericComboList(hList, pSetupData->USetupData.ComputerList, GetSettingDescription);
 
            hList = GetDlgItem(hwndDlg, IDC_DISPLAY);
            InitGenericComboList(hList, pSetupData->USetupData.DisplayList, GetSettingDescription);
 
            hList = GetDlgItem(hwndDlg, IDC_KEYBOARD);
            InitGenericComboList(hList, pSetupData->USetupData.KeyboardList, GetSettingDescription);
 
            // hList = GetDlgItem(hwndDlg, IDC_KEYBOARD_LAYOUT);
            // InitGenericComboList(hList, pSetupData->USetupData.LayoutList, GetSettingDescription);
 
            return TRUE;
        }
 
        case WM_NOTIFY:
        {
            LPNMHDR lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                {
                    /* In unattended mode, don't allow going backwards further, i.e.
                     * back to the Upgrade/Repair, the Install type, or the Start pages,
                     * in case the setup is interrupted and the user manually goes back. */
                    if (pSetupData->bUnattend)
                        PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT);
                    else
                        PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
 
                    /* In unattended mode, switch directly to the next page.
                     * TODO: *UNLESS* there are inconsistencies in the data,
                     * in which case we should stay on the page! */
                    if (pSetupData->bUnattend)
                    {
                        SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
                        return TRUE;
                    }
                    break;
                }
 
                case PSN_QUERYCANCEL:
                {
                    if (DisplayMessage(GetParent(hwndDlg),
                                       MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
                                       MAKEINTRESOURCEW(IDS_ABORTSETUP2),
                                       MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
                    {
                        /* Go to the Abort page */
                        PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_ABORTPAGE);
                    }
 
                    /* Do not close the wizard too soon */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
                    return TRUE;
                }
 
                case PSN_WIZNEXT: /* Set the selected data */
                {
                    hList = GetDlgItem(hwndDlg, IDC_COMPUTER);
                    SetCurrentListEntry(pSetupData->USetupData.ComputerList,
                                        GetSelectedComboListItem(hList));
 
                    hList = GetDlgItem(hwndDlg, IDC_DISPLAY);
                    SetCurrentListEntry(pSetupData->USetupData.DisplayList,
                                        GetSelectedComboListItem(hList));
 
                    hList = GetDlgItem(hwndDlg, IDC_KEYBOARD);
                    SetCurrentListEntry(pSetupData->USetupData.KeyboardList,
                                        GetSelectedComboListItem(hList));
 
                    // hList = GetDlgItem(hwndDlg, IDC_KEYBOARD_LAYOUT);
                    // SetCurrentListEntry(pSetupData->USetupData.LayoutList,
                    //                     GetSelectedComboListItem(hList));
 
                    return TRUE;
                }
 
                case PSN_WIZBACK:
                {
                    /* Return to the Install type selection page instead of the Repair/Upgrade page */
                    SetWindowLongW(hwndDlg, DWLP_MSGRESULT, IDD_TYPEPAGE);
                    return TRUE;
                }
 
                default:
                    break;
            }
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

DisplayError()

INT __cdecl DisplayError	(	_In_opt_ HWND	hWnd,
		_In_ UINT	uIDTitle,
		_In_ UINT	uIDMessage,
			...
	)

Definition at line 263 of file reactos.c.

{
    INT iRes;
    va_list args;
 
    va_start(args, uIDMessage);
    iRes = DisplayMessageV(hWnd, MB_ICONERROR | MB_OK,
                           MAKEINTRESOURCEW(uIDTitle),
                           MAKEINTRESOURCEW(uIDMessage),
                           args);
    va_end(args);
 
    return iRes;
}

Referenced by _tWinMain(), FsVolCallback(), and PrepareAndDoCopyThread().

DisplayMessage()

INT __cdecl DisplayMessage	(	_In_opt_ HWND	hWnd,
		_In_ UINT	uType,
		_In_opt_ PCWSTR	pszTitle,
		_In_opt_ PCWSTR	pszFormatMessage,
			...
	)

Definition at line 244 of file reactos.c.

{
    INT iRes;
    va_list args;
 
    va_start(args, pszFormatMessage);
    iRes = DisplayMessageV(hWnd, uType, pszTitle, pszFormatMessage, args);
    va_end(args);
 
    return iRes;
}

Referenced by _tWinMain(), AttachToConsoleInternal(), Bios32Post(), BiosRomBasic(), BrowseDlgProc(), CmdStartProcess(), ControlBop(), CpuSimulate(), DeviceDlgProc(), DosCreateProcess(), DosStartProcess32(), DriveDlgProc(), EjectFloppy(), EmulatorException(), FsVolCallback(), LoadInstallableVDD(), MountDisk(), MountFDI(), MountFloppy(), MountHDD(), PrepareAndDoCopyThread(), ProcessDlgProc(), RetrieveDisk(), SelectInstallPartition(), SummaryDlgProc(), TypeDlgProc(), UnmountDisk(), UpgradeRepairDlgProc(), VgaAttachToConsole(), VgaConsoleCreateTextScreen(), VgaEnterNewMode(), and WinNtVdmBiosReset().

DisplayMessageV()

INT DisplayMessageV	(	_In_opt_ HWND	hWnd,
		_In_ UINT	uType,
		_In_opt_ PCWSTR	pszTitle,
		_In_opt_ PCWSTR	pszFormatMessage,
		_In_ va_list	args
	)

Definition at line 174 of file reactos.c.

{
    INT iRes;
    HINSTANCE hInstance = NULL;
    MSGBOXPARAMSW mb = {0};
    PWSTR Format;
    WCHAR StaticBuffer[256];
    PWSTR Buffer = StaticBuffer; // Use the static buffer by default.
 
    /* We need to retrieve the current module's instance handle if either
     * the title or the format message is specified by a resource ID */
    if ((pszTitle && IS_INTRESOURCE(pszTitle)) || IS_INTRESOURCE(pszFormatMessage))
        hInstance = GetModuleHandleW(NULL); // SetupData.hInstance;
 
    /* Retrieve the format message string if this is a resource */
    if (pszFormatMessage && IS_INTRESOURCE(pszFormatMessage))
    {
        Format = NULL;
        (void)LoadAllocStringW(hInstance, PtrToUlong(pszFormatMessage), &Format, 0);
    }
    else
    {
        Format = (PWSTR)pszFormatMessage;
    }
 
    if (Format)
    {
        /* Format the message and retrieve its length. If it is too long,
         * an auxiliary buffer is allocated; otherwise the static buffer
         * is used. The string is built to be NUL-terminated. */
        (void)FormatAllocStringWV(&Buffer, _countof(StaticBuffer), Format, args);
        if (!Buffer)
        {
            /* Allocation failed, use the original format string verbatim */
            Buffer = Format;
        }
    }
    else
    {
        Format = (PWSTR)pszFormatMessage;
        Buffer = Format;
    }
 
    /* Display the message */
    mb.cbSize = sizeof(mb);
    mb.hwndOwner = hWnd;
    mb.hInstance = hInstance;
    mb.lpszText = Buffer;
    mb.lpszCaption = pszTitle;
    mb.dwStyle = uType;
    mb.dwLanguageId = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
    iRes = MessageBoxIndirectW(&mb);
 
    /* Free the buffers if needed */
    if ((Buffer != StaticBuffer) && (Buffer != Format))
        HeapFree(GetProcessHeap(), 0, Buffer);
 
    if (Format && (Format != pszFormatMessage))
        HeapFree(GetProcessHeap(), 0, Format);
 
    return iRes;
}

Referenced by DisplayError(), and DisplayMessage().

EnablePrivilege()

BOOL EnablePrivilege	(	IN LPCWSTR	lpszPrivilegeName,
		IN BOOL	bEnablePrivilege
	)

Definition at line 3302 of file reactos.c.

{
    BOOL   Success;
    HANDLE hToken;
    TOKEN_PRIVILEGES tp;
 
    Success = OpenProcessToken(GetCurrentProcess(),
                               TOKEN_ADJUST_PRIVILEGES,
                               &hToken);
    if (!Success) return Success;
 
    Success = LookupPrivilegeValueW(NULL,
                                    lpszPrivilegeName,
                                    &tp.Privileges[0].Luid);
    if (!Success) goto Quit;
 
    tp.PrivilegeCount = 1;
    tp.Privileges[0].Attributes = (bEnablePrivilege ? SE_PRIVILEGE_ENABLED : 0);
 
    Success = AdjustTokenPrivileges(hToken, FALSE, &tp, 0, NULL, NULL);
 
Quit:
    CloseHandle(hToken);
    return Success;
}

Referenced by _tWinMain().

FileCopyCallback()

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

static

Definition at line 1769 of file reactos.c.

{
    PCOPYCONTEXT CopyContext = (PCOPYCONTEXT)Context;
    PFILEPATHS_W FilePathInfo;
    PCWSTR SrcFileName, DstFileName;
 
    WaitForSingleObject(CopyContext->pSetupData->hHaltInstallEvent, INFINITE);
    if (CopyContext->pSetupData->bAbortInstall)
        return FILEOP_ABORT; // Stop committing files
 
    switch (Notification)
    {
        case SPFILENOTIFY_STARTSUBQUEUE:
        {
            CopyContext->TotalOperations = (ULONG)Param2;
            CopyContext->CompletedOperations = 0;
 
            /* Set up the progress bar */
            SendMessageW(UiContext.hWndProgress,
                         PBM_SETRANGE, 0,
                         MAKELPARAM(0, CopyContext->TotalOperations));
            SendMessageW(UiContext.hWndProgress,
                         PBM_SETSTEP, 1, 0);
            SendMessageW(UiContext.hWndProgress,
                         PBM_SETPOS, 0, 0);
            break;
        }
 
        case SPFILENOTIFY_STARTDELETE:
        case SPFILENOTIFY_STARTRENAME:
        case SPFILENOTIFY_STARTCOPY:
        {
            FilePathInfo = (PFILEPATHS_W)Param1;
 
            if (Notification == SPFILENOTIFY_STARTDELETE)
            {
                /* Display delete message */
                ASSERT(Param2 == FILEOP_DELETE);
 
                DstFileName = wcsrchr(FilePathInfo->Target, L'\\');
                if (DstFileName) ++DstFileName;
                else DstFileName = FilePathInfo->Target;
 
                SetWindowResPrintfW(UiContext.hWndItem,
                                    SetupData.hInstance,
                                    IDS_DELETING, // STRING_DELETING
                                    DstFileName);
            }
            else if (Notification == SPFILENOTIFY_STARTRENAME)
            {
                UINT uMsgID;
 
                /* Display move/rename message */
                ASSERT(Param2 == FILEOP_RENAME);
 
                SrcFileName = wcsrchr(FilePathInfo->Source, L'\\');
                if (SrcFileName) ++SrcFileName;
                else SrcFileName = FilePathInfo->Source;
 
                DstFileName = wcsrchr(FilePathInfo->Target, L'\\');
                if (DstFileName) ++DstFileName;
                else DstFileName = FilePathInfo->Target;
 
                if (!_wcsicmp(SrcFileName, DstFileName))
                    uMsgID = IDS_MOVING; // STRING_MOVING
                else
                    uMsgID = IDS_RENAMING; // STRING_RENAMING
                SetWindowResPrintfW(UiContext.hWndItem,
                                    SetupData.hInstance,
                                    uMsgID,
                                    SrcFileName, DstFileName);
            }
            else if (Notification == SPFILENOTIFY_STARTCOPY)
            {
                /* Display copy message */
                ASSERT(Param2 == FILEOP_COPY);
 
                DstFileName = wcsrchr(FilePathInfo->Target, L'\\');
                if (DstFileName) ++DstFileName;
                else DstFileName = FilePathInfo->Target;
 
                /* Whereas the repair/upgrade procedure may move, rename, or
                 * delete files, the regular installation only copies files.
                 * Therefore, display only the file name instead of the full
                 * "Copying..." message in this case. */
                if (SetupData.RepairUpdateFlag)
                {
                    SetWindowResPrintfW(UiContext.hWndItem,
                                        SetupData.hInstance,
                                        IDS_COPYING, // STRING_COPYING
                                        DstFileName);
                }
                else
                {
                    SetWindowTextW(UiContext.hWndItem, DstFileName);
                }
            }
            break;
        }
 
        case SPFILENOTIFY_COPYERROR:
        {
            FilePathInfo = (PFILEPATHS_W)Param1;
 
            DPRINT1("An error happened while trying to copy file '%S' (error 0x%08lx), skipping it...\n",
                    FilePathInfo->Target, FilePathInfo->Win32Error);
            return FILEOP_SKIP;
        }
 
        case SPFILENOTIFY_ENDDELETE:
        case SPFILENOTIFY_ENDRENAME:
        case SPFILENOTIFY_ENDCOPY:
        {
            CopyContext->CompletedOperations++;
 
            /* SYSREG checkpoint */
            if (CopyContext->TotalOperations >> 1 == CopyContext->CompletedOperations)
                DPRINT1("CHECKPOINT:HALF_COPIED\n");
 
            SendMessageW(UiContext.hWndProgress, PBM_STEPIT, 0, 0);
            break;
        }
    }
 
    return FILEOP_DOIT;
}

Referenced by PrepareAndDoCopyThread().

FindUserClosableWindowProc()

static BOOL CALLBACK FindUserClosableWindowProc ( _In_ HWND  hWnd, _In_ LPARAM  lParam  )

static

Definition at line 2641 of file reactos.c.

{
    PCLOSABLE_WND_INFO pInfo = (PCLOSABLE_WND_INFO)lParam;
    HMENU hSysMenu;
    MENUITEMINFOW mii;
 
    /* Skip the window to exclude */
    if (hWnd == pInfo->hWndExclude)
        return TRUE;
 
    /* Skip non-interactive windows */
    if (!IsWindowEnabled(hWnd) || !IsWindowVisible(hWnd))
        return TRUE;
 
    hSysMenu = GetSystemMenu(hWnd, FALSE);
    if (!hSysMenu)
        return TRUE; /* No menu: skip the window */
 
    mii.cbSize = sizeof(mii);
    mii.fMask = MIIM_STATE;
    if (!GetMenuItemInfoW(hSysMenu, SC_CLOSE, FALSE, &mii))
        return TRUE; /* No close item: skip the window */
 
    pInfo->Found |= !(mii.fState & MFS_DISABLED);
 
    /* Continue enumeration (return TRUE) if no close item is enabled;
     * otherwise stop the enumeration (return FALSE) */
    return !pInfo->Found;
}

Referenced by AreThereInteractiveWindows().

FinishDlgProc()

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

static

Definition at line 2694 of file reactos.c.

{
    PSETUPDATA pSetupData;
 
    /* Retrieve pointer to the global setup data */
    pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            HWND hWndParent = GetParent(hwndDlg);
            LPPROPSHEETPAGEW ppsp = (LPPROPSHEETPAGEW)lParam;
 
            /* Save pointer to the global setup data */
            pSetupData = (PSETUPDATA)ppsp->lParam;
            SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
 
            /* Set the stop-install flag if the user is aborting
             * the installation: TRUE if Abort, FALSE if Finish. */
            pSetupData->bStopInstall = (ppsp->pszTemplate == MAKEINTRESOURCEW(IDD_ABORTPAGE));
 
            /* Set title font */
            SetDlgItemFont(hwndDlg, IDC_FINISHTITLE, pSetupData->hTitleFont, TRUE);
 
            /* We need to reboot at the end of the installation if this is an
             * unattended setup, or if there is no shell active. If there are
             * other user-interactive windows opened, we pause in WM_ACTIVATE
             * the inevitable reboot countdown when the wizard is deactivated,
             * and restart it when the wizard is reactivated. */
            pSetupData->bMustReboot = SetupData.bUnattend;
            pSetupData->bMustReboot |= !IsShellActive();
 
            /* If we must reboot, display the countdown gauge. In any
             * case, let the user restart now or postpone it to later. */
            if (pSetupData->bMustReboot)
            {
                /* "Setup will now restart your computer..." is shown */
                EnableDlgItem(hwndDlg, IDC_RESTART_PROGRESS, TRUE);
                ShowDlgItem(hwndDlg, IDC_RESTART_PROGRESS, SW_SHOW);
            }
            else
            {
                /* We should not reboot automatically, change the finish
                 * text to "Setup needs to restart your computer..." */
                UINT uMsgID = (!pSetupData->bStopInstall ? IDS_FINISH_NO_REBOOT
                                                         : IDS_ABORT_NO_REBOOT);
                SetWindowResTextW(GetDlgItem(hwndDlg, IDC_FINISHTEXT),
                                  pSetupData->hInstance,
                                  uMsgID);
 
                /* Hide and disable the countdown gauge */
                EnableDlgItem(hwndDlg, IDC_RESTART_PROGRESS, FALSE);
                ShowDlgItem(hwndDlg, IDC_RESTART_PROGRESS, SW_HIDE);
            }
 
            /* Ensure that the wizard window is centered, made visible, and focused */
            CenterWindow(hWndParent);
            ShowWindow(hWndParent, SW_SHOW);
            SwitchToThisWindow(hWndParent, TRUE);
            return TRUE;
        }
 
        case WM_ACTIVATE:
        {
            /* Only care about (de)activation only if we must reboot */
            if (!pSetupData->bMustReboot)
                break;
 
            if (LOWORD(wParam) == WA_INACTIVE)
            {
                /* Wizard window is deactivated, check whether there are
                 * interactive windows. If so, pause the countdown. */
                if (AreThereInteractiveWindows(GetParent(hwndDlg)))
                    KillTimer(hwndDlg, 1);
            }
            else
            {
                /* Wizard window is reactivated, re-enable the countdown */
                SetTimer(hwndDlg, 1, 50, NULL);
            }
            break;
        }
 
        case WM_TIMER:
        {
            HWND hWndProgress;
            INT Position;
 
            hWndProgress = GetDlgItem(hwndDlg, IDC_RESTART_PROGRESS);
            Position = SendMessageW(hWndProgress, PBM_GETPOS, 0, 0);
            if (Position == 300)
            {
                KillTimer(hwndDlg, 1);
                PropSheet_PressButton(GetParent(hwndDlg), PSBTN_FINISH);
            }
            else
            {
                SendMessageW(hWndProgress, PBM_SETPOS, Position + 1, 0);
            }
            return TRUE;
        }
 
        case WM_NOTIFY:
        {
            LPNMHDR lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                {
                    HWND hWndParent = GetParent(hwndDlg);
 
                    /*
                     * Only "Finish" for closing the wizard, and hide "Back" and "Next".
                     * Don't use the PropSheet_SetWizButtons() macro, because its
                     * posted message would be handled after hiding the buttons.
                     * The message would then interfere with the hidden buttons
                     * (when both "Back" and "Next" are hidden, "Next" gets forcefully shown).
                     */
                    SendMessageW(hWndParent, PSM_SETWIZBUTTONS, 0, PSWIZB_FINISH);
                    // PropSheet_ShowWizButtons(hWndParent, 0, PSWIZB_BACK | PSWIZB_NEXT | PSWIZB_CANCEL);
                    ShowDlgItem(hWndParent, ID_WIZBACK, SW_HIDE);
                    ShowDlgItem(hWndParent, ID_WIZNEXT, SW_HIDE);
 
                    /* Change the "Finish" button text to "Restart" */
                    SetWindowResTextW(GetDlgItem(hWndParent, ID_WIZFINISH),
                                      pSetupData->hInstance,
                                      IDS_RESTARTBTN);
 
                    /* Skip the Finish page in unattended setup */
                    if (pSetupData->bUnattend /*&& !pSetupData->bStopInstall*/)
                    {
                        // FIXME: The macro should use PostMessageW, but our
                        // prsht.h is wrong and uses SendMessageW instead...
                        //PropSheet_PressButton(hWndParent, PSBTN_FINISH);
                        PostMessageW(hWndParent, PSM_PRESSBUTTON, PSBTN_FINISH, 0);
                        /* We need to "stay" on the page so that we can
                         * receive the PSN_WIZFINISH notification */
                        SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, 0);
                        return TRUE;
                    }
 
                    /* Re-enable the Close/Cancel buttons if we won't reboot */
                    if (!pSetupData->bMustReboot)
                        PropSheet_SetCloseCancel(hWndParent, TRUE);
 
                    if (pSetupData->bMustReboot)
                    {
                        RECT rcBtn1, rcBtn2;
 
                        /* Move the "Finish"/"Restart" button to where the "Cancel" button is */
                        GetWindowRect(GetDlgItem(hWndParent, ID_WIZFINISH), &rcBtn1);
                        MapWindowPoints(HWND_DESKTOP /*NULL*/, hWndParent, (LPPOINT)&rcBtn1, sizeof(RECT)/sizeof(POINT));
                        GetWindowRect(GetDlgItem(hWndParent, IDCANCEL), &rcBtn2);
                        MapWindowPoints(HWND_DESKTOP /*NULL*/, hWndParent, (LPPOINT)&rcBtn2, sizeof(RECT)/sizeof(POINT));
                        SetWindowPos(GetDlgItem(hWndParent, ID_WIZFINISH),
                                     HWND_TOP,
                                     rcBtn1.left + (rcBtn2.right - rcBtn1.right),
                                     rcBtn1.top,
                                     0, 0,
                                     SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
 
                        /* Hide and disable also the "Cancel" buttons since we can only finish now */
                        ShowDlgItem(hWndParent, IDCANCEL, SW_HIDE);
                        PropSheet_SetCloseCancel(hWndParent, FALSE);
 
                        /* Set up the reboot progress bar and countdown timer.
                         * 300 steps at 50 ms each: 15 seconds */
                        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);
                    }
                    else if (!pSetupData->bStopInstall)
                    {
                        /* Keep the "Cancel" button shown and change its text to "Postpone" */
                        SetWindowResTextW(GetDlgItem(hWndParent, IDCANCEL),
                                          pSetupData->hInstance,
                                          IDS_POSTPONEBTN);
                    }
                    else // (!bMustReboot && bStopInstall)
                    {
                        /* The installation is aborted, change the "Cancel" button text to "Close" */
                        SetWindowResTextW(GetDlgItem(hWndParent, IDCANCEL),
                                          GetModuleHandleW(L"comctl32.dll"),
                                          IDS_CLOSE);
                    }
                    break;
                }
 
                case PSN_KILLACTIVE:
                    KillTimer(hwndDlg, 1);
                    break;
 
                case PSN_WIZBACK:
                    /* Always disable going back */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
                    return TRUE;
 
                case PSN_WIZNEXT:
                case PSN_WIZFINISH:
                {
                    /* Press on "Finish"/"Restart" button */
                    pSetupData->bMustReboot = TRUE;
                    __fallthrough;
                }
                case PSN_QUERYCANCEL:
                    /* Press on "Cancel"/"Postpone" button */
                default:
                    break;
            }
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

FormatAllocStringWV()

size_t FormatAllocStringWV	(	_In_opt_ _Outptr_ PWSTR *	pString,
		_In_opt_ size_t	cchBufferLen,
		_In_ PCWSTR	pszFormat,
		_In_ va_list	args
	)

Definition at line 149 of file reactos.c.

{
    size_t Length;
 
    /* Retrieve the message length. If it is too long, allocate
     * an auxiliary buffer; otherwise use the caller's buffer. */
    Length = _vscwprintf(pszFormat, args); // Doesn't count the NUL-terminator.
    if (!*pString || (Length >= cchBufferLen))
    {
        /* Allocate a new buffer, adding a NUL-terminator */
        *pString = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (Length + 1) * sizeof(WCHAR));
        if (!*pString)
            return 0;
    }
 
    /* Do the printf */
    StringCchVPrintfW(*pString, Length + 1, pszFormat, args);
    return Length;
}

Referenced by DisplayMessageV(), and SetWindowResPrintfVW().

FormatCallback()

static BOOLEAN NTAPI FormatCallback ( _In_ CALLBACKCOMMAND  Command, _In_ ULONG  Modifier, _In_ PVOID  Argument  )

static

Definition at line 1364 of file reactos.c.

{
    switch (Command)
    {
        case PROGRESS:
        {
            PULONG Percent = (PULONG)Argument;
            DPRINT("%lu percent completed\n", *Percent);
            SendMessageW(UiContext.hWndProgress, PBM_SETPOS, *Percent, 0);
            break;
        }
 
#if 0
        case OUTPUT:
        {
            PTEXTOUTPUT output = (PTEXTOUTPUT)Argument;
            DPRINT("%s\n", output->Output);
            break;
        }
#endif
 
        case DONE:
        {
#if 0
            PBOOLEAN Success = (PBOOLEAN)Argument;
            if (*Success == FALSE)
            {
                DPRINT("FormatEx was unable to complete successfully.\n\n");
            }
#endif
            DPRINT("Done\n");
            break;
        }
 
        default:
            DPRINT("Unknown callback %lu\n", (ULONG)Command);
            break;
    }
 
    return TRUE;
}

Referenced by FsVolCallback().

FreeNtToWin32PathMappingList()

VOID FreeNtToWin32PathMappingList

(

IN OUT PNT_WIN32_PATH_MAPPING_LIST

MappingList

)

Definition at line 3022 of file reactos.c.

{
    PLIST_ENTRY ListEntry;
    PVOID Entry;
 
    while (!IsListEmpty(&MappingList->List))
    {
        ListEntry = RemoveHeadList(&MappingList->List);
        Entry = (PVOID)CONTAINING_RECORD(ListEntry, NT_WIN32_PATH_MAPPING, ListEntry);
        HeapFree(ProcessHeap, 0, Entry);
    }
 
    MappingList->MappingsCount = 0;
}

Referenced by _tWinMain().

FsVolCallback()

static FSVOL_OP CALLBACK FsVolCallback ( _In_opt_ PVOID  Context, _In_ FSVOLNOTIFY  FormatStatus, _In_ ULONG_PTR  Param1, _In_ ULONG_PTR  Param2  )

static

HACK!!

Definition at line 1430 of file reactos.c.

{
    PFSVOL_CONTEXT FsVolContext = (PFSVOL_CONTEXT)Context;
 
    switch (FormatStatus)
    {
    // FIXME: Deprecate!
    case ChangeSystemPartition:
    {
        // PPARTENTRY SystemPartition = (PPARTENTRY)Param1;
 
        // FsVolContext->NextPageOnAbort = SELECT_PARTITION_PAGE;
        // if (ChangeSystemPartitionPage(Ir, SystemPartition))
        //     return FSVOL_DOIT;
        return FSVOL_ABORT;
    }
 
    case FSVOLNOTIFY_PARTITIONERROR:
    {
        switch (Param1)
        {
        case STATUS_PARTITION_FAILURE:
        {
            // ERROR_WRITE_PTABLE
            DisplayError(NULL,
                         0, // Default to "Error"
                         IDS_ERROR_WRITE_PTABLE);
            // FsVolContext->NextPageOnAbort = QUIT_PAGE;
            // TODO: Go back to the partitioning page?
            break;
        }
 
        case ERROR_SYSTEM_PARTITION_NOT_FOUND:
        {
            /* FIXME: improve the error dialog */
            //
            // Error dialog should say that we cannot find a suitable
            // system partition and create one on the system. At this point,
            // it may be nice to ask the user whether he wants to continue,
            // or use an external drive as the system drive/partition
            // (e.g. floppy, USB drive, etc...)
            //
            DisplayError(NULL,
                         0, // Default to "Error"
                         IDS_ERROR_SYSTEM_PARTITION);
            // FsVolContext->NextPageOnAbort = SELECT_PARTITION_PAGE;
            // TODO: Go back to the partitioning page
            break;
        }
 
        default:
            break;
        }
        return FSVOL_ABORT;
    }
 
    case FSVOLNOTIFY_STARTQUEUE:
    case FSVOLNOTIFY_ENDQUEUE:
        // NOTE: If needed, clear progress gauges.
        return FSVOL_DOIT;
 
    case FSVOLNOTIFY_STARTSUBQUEUE:
    {
        if ((FSVOL_OP)Param1 == FSVOL_FORMAT)
        {
            /* In case we just repair an existing installation,
             * just go to the file system check step */
            if (FsVolContext->pSetupData->RepairUpdateFlag)
                return FSVOL_SKIP; 
            /* Set status text */
            SetDlgItemTextW(UiContext.hwndDlg, IDC_ITEM, L"");
        }
        else
        if ((FSVOL_OP)Param1 == FSVOL_CHECK)
        {
            /* Set status text */
            SetDlgItemTextW(UiContext.hwndDlg, IDC_ITEM, L"");
 
            /* Filechecking step: set progress marquee style and start it up */
            UiContext.dwPbStyle = GetWindowLongPtrW(UiContext.hWndProgress, GWL_STYLE);
            SetWindowLongPtrW(UiContext.hWndProgress, GWL_STYLE, UiContext.dwPbStyle | PBS_MARQUEE);
            SendMessageW(UiContext.hWndProgress, PBM_SETMARQUEE, TRUE, 0);
        }
 
        return FSVOL_DOIT;
    }
 
    case FSVOLNOTIFY_ENDSUBQUEUE:
    {
        if ((FSVOL_OP)Param1 == FSVOL_CHECK)
        {
            /* File-checking finished: stop the progress bar and restore its style */
            SendMessageW(UiContext.hWndProgress, PBM_SETMARQUEE, FALSE, 0);
            SetWindowLongPtrW(UiContext.hWndProgress, GWL_STYLE, UiContext.dwPbStyle);
        }
        return 0;
    }
 
    case FSVOLNOTIFY_FORMATERROR:
    {
        PFORMAT_VOLUME_INFO FmtInfo = (PFORMAT_VOLUME_INFO)Param1;
 
        // FIXME: See also FSVOLNOTIFY_PARTITIONERROR
        if (FmtInfo->ErrorStatus == STATUS_PARTITION_FAILURE)
        {
            // ERROR_WRITE_PTABLE
            DisplayError(NULL,
                         0, // Default to "Error"
                         IDS_ERROR_WRITE_PTABLE);
            // FsVolContext->NextPageOnAbort = QUIT_PAGE;
            // TODO: Go back to the partitioning page?
            return FSVOL_ABORT;
        }
        else
        if (FmtInfo->ErrorStatus == STATUS_UNRECOGNIZED_VOLUME)
        {
            /* FIXME: show an error dialog */
            // MUIDisplayError(ERROR_FORMATTING_PARTITION, Ir, POPUP_WAIT_ANY_KEY, PathBuffer);
            DisplayError(NULL,
                         0, // Default to "Error"
                         IDS_ERROR_FORMAT_UNRECOGNIZED_VOLUME);
            // FsVolContext->NextPageOnAbort = QUIT_PAGE;
            return FSVOL_ABORT;
        }
        else
        if (FmtInfo->ErrorStatus == STATUS_NOT_SUPPORTED)
        {
            INT nRet;
 
            nRet = DisplayMessage(NULL, MB_ICONERROR | MB_OKCANCEL,
                                  NULL, // Default to "Error"
                                  MAKEINTRESOURCEW(IDS_ERROR_COULD_NOT_FORMAT),
                                  FmtInfo->FileSystemName);
            if (nRet == IDCANCEL)
            {
                // FsVolContext->NextPageOnAbort = QUIT_PAGE;
                return FSVOL_ABORT;
            }
            else if (nRet == IDOK)
            {
                return FSVOL_RETRY;
            }
        }
        else if (!NT_SUCCESS(FmtInfo->ErrorStatus))
        {
            ASSERT(*FmtInfo->Volume->Info.DeviceName);
 
            DPRINT1("FormatPartition() failed with status 0x%08lx\n", FmtInfo->ErrorStatus);
 
            // ERROR_FORMATTING_PARTITION
            DisplayError(NULL,
                         0, // Default to "Error"
                         IDS_ERROR_FORMATTING_PARTITION,
                         FmtInfo->Volume->Info.DeviceName);
            // FsVolContext->NextPageOnAbort = QUIT_PAGE;
            return FSVOL_ABORT;
        }
 
        return FSVOL_RETRY;
    }
 
    case FSVOLNOTIFY_CHECKERROR:
    {
        PCHECK_VOLUME_INFO ChkInfo = (PCHECK_VOLUME_INFO)Param1;
 
        if (ChkInfo->ErrorStatus == STATUS_NOT_SUPPORTED)
        {
            INT nRet;
 
            nRet = DisplayMessage(NULL, MB_ICONERROR | MB_OKCANCEL,
                                  NULL, // Default to "Error"
                                  MAKEINTRESOURCEW(IDS_ERROR_COULD_NOT_CHECK),
                                  ChkInfo->Volume->Info.FileSystem);
            if (nRet == IDCANCEL)
            {
                // FsVolContext->NextPageOnAbort = QUIT_PAGE;
                return FSVOL_ABORT;
            }
            else if (nRet == IDOK)
            {
                return FSVOL_SKIP;
            }
        }
        else if (!NT_SUCCESS(ChkInfo->ErrorStatus))
        {
            DPRINT1("ChkdskPartition() failed with status 0x%08lx\n", ChkInfo->ErrorStatus);
 
            DisplayError(NULL,
                         0, // Default to "Error"
                         IDS_ERROR_CHECKING_PARTITION,
                         ChkInfo->ErrorStatus);
            return FSVOL_SKIP;
        }
 
        return FSVOL_SKIP;
    }
 
    case FSVOLNOTIFY_STARTFORMAT:
    {
        PFORMAT_VOLUME_INFO FmtInfo = (PFORMAT_VOLUME_INFO)Param1;
        PVOL_CREATE_INFO VolCreate;
 
        ASSERT((FSVOL_OP)Param2 == FSVOL_FORMAT);
 
        /* Find the volume info in the partition TreeList UI.
         * If none, don't format it. */
        VolCreate = FindVolCreateInTreeByVolume(UiContext.hPartList,
                                                FmtInfo->Volume);
        if (!VolCreate)
            return FSVOL_SKIP;
        ASSERT(VolCreate->Volume == FmtInfo->Volume);
 
        /* If there is no formatting information, skip it */
        if (!*VolCreate->FileSystemName)
            return FSVOL_SKIP;
 
        ASSERT(*FmtInfo->Volume->Info.DeviceName);
 
        /* Set status text */
        if (FmtInfo->Volume->Info.DriveLetter)
        {
            SetWindowResPrintfW(GetDlgItem(UiContext.hwndDlg, IDC_ITEM),
                                SetupData.hInstance,
                                IDS_FORMATTING_PROGRESS1, // L"Formatting volume %c: (%s) in %s..."
                                FmtInfo->Volume->Info.DriveLetter,
                                FmtInfo->Volume->Info.DeviceName,
                                VolCreate->FileSystemName);
        }
        else
        {
            SetWindowResPrintfW(GetDlgItem(UiContext.hwndDlg, IDC_ITEM),
                                SetupData.hInstance,
                                IDS_FORMATTING_PROGRESS2, // L"Formatting volume %s in %s..."
                                FmtInfo->Volume->Info.DeviceName,
                                VolCreate->FileSystemName);
        }
 
        // StartFormat(FmtInfo, FileSystemList->Selected);
        FmtInfo->FileSystemName = VolCreate->FileSystemName;
        FmtInfo->MediaFlag = VolCreate->MediaFlag;
        FmtInfo->Label = VolCreate->Label;
        FmtInfo->QuickFormat = VolCreate->QuickFormat;
        FmtInfo->ClusterSize = VolCreate->ClusterSize;
        FmtInfo->Callback = FormatCallback;
 
        /* Set up the progress bar */
        SendMessageW(UiContext.hWndProgress,
                     PBM_SETRANGE, 0, MAKELPARAM(0, 100));
        SendMessageW(UiContext.hWndProgress,
                     PBM_SETPOS, 0, 0);
 
        return FSVOL_DOIT;
    }
 
    case FSVOLNOTIFY_ENDFORMAT:
    {
        PFORMAT_VOLUME_INFO FmtInfo = (PFORMAT_VOLUME_INFO)Param1;
 
        // EndFormat(FmtInfo->ErrorStatus);
        if (FmtInfo->FileSystemName)
            *(PWSTR)FmtInfo->FileSystemName = UNICODE_NULL; // FIXME: HACK!
 
        // /* Reset the file system list */
        // ResetFileSystemList();
        return 0;
    }
 
    case FSVOLNOTIFY_STARTCHECK:
    {
        PCHECK_VOLUME_INFO ChkInfo = (PCHECK_VOLUME_INFO)Param1;
        PVOL_CREATE_INFO VolCreate;
 
        ASSERT((FSVOL_OP)Param2 == FSVOL_CHECK);
 
        /* Find the volume info in the partition TreeList UI.
         * If none, don't check it. */
        VolCreate = FindVolCreateInTreeByVolume(UiContext.hPartList,
                                                ChkInfo->Volume);
        if (!VolCreate)
            return FSVOL_SKIP;
        ASSERT(VolCreate->Volume == ChkInfo->Volume);
 
        ASSERT(*ChkInfo->Volume->Info.DeviceName);
 
        /* Set status text */
        if (ChkInfo->Volume->Info.DriveLetter)
        {
            SetWindowResPrintfW(GetDlgItem(UiContext.hwndDlg, IDC_ITEM),
                                SetupData.hInstance,
                                IDS_CHECKING_PROGRESS1, // L"Checking volume %c: (%s)..."
                                ChkInfo->Volume->Info.DriveLetter,
                                ChkInfo->Volume->Info.DeviceName);
        }
        else
        {
            SetWindowResPrintfW(GetDlgItem(UiContext.hwndDlg, IDC_ITEM),
                                SetupData.hInstance,
                                IDS_CHECKING_PROGRESS2, // L"Checking volume %s..."
                                ChkInfo->Volume->Info.DeviceName);
        }
 
        // StartCheck(ChkInfo);
        // TODO: Think about which values could be defaulted...
        ChkInfo->FixErrors = TRUE;
        ChkInfo->Verbose = FALSE;
        ChkInfo->CheckOnlyIfDirty = TRUE;
        ChkInfo->ScanDrive = FALSE;
        ChkInfo->Callback = ChkdskCallback;
 
        return FSVOL_DOIT;
    }
 
    case FSVOLNOTIFY_ENDCHECK:
    {
        // PCHECK_VOLUME_INFO ChkInfo = (PCHECK_VOLUME_INFO)Param1;
        // EndCheck(ChkInfo->ErrorStatus);
        return 0;
    }
    }
 
    return 0;
}

Referenced by DoChecking(), DoFormatting(), FsVolCommitOpsQueue(), InitSystemPartition(), and PrepareAndDoCopyThread().

GetLocalSetupDllPath()

static PCWSTR GetLocalSetupDllPath ( VOID  )

static

Definition at line 3381 of file reactos.c.

{
    static WCHAR SetupDllPath[MAX_PATH] = L"";
    static BOOL Init = FALSE;
    BOOL Success;
    DWORD PathSize;
 
    /* Don't rebuild the path if we did it already */
    if (Init)
        return SetupDllPath;
    Init = TRUE;
 
    /*
     * Retrieve the full path of the current running Setup instance.
     * From this we build the suitable path to the Setup DLL.
     */
    PathSize = GetModuleFileNameW(NULL, SetupDllPath, _countof(SetupDllPath));
    SetupDllPath[_countof(SetupDllPath) - 1] = UNICODE_NULL; // Ensure NUL-termination (see WinXP bug)
 
    Success = ((PathSize != 0) && (PathSize < _countof(SetupDllPath)) &&
               (GetLastError() != ERROR_INSUFFICIENT_BUFFER));
    if (Success)
    {
        /* Find the last path separator, remove it as well as the file name */
        PWCHAR pch = wcsrchr(SetupDllPath, L'\\');
        if (!pch)
            pch = SetupDllPath;
 
        /* The Setup DLL is inside the System32 sub-directory */
        PathSize = _countof(SetupDllPath) - (pch - SetupDllPath);
        Success = SUCCEEDED(StringCchCopyW(pch, PathSize, L"\\system32"));
    }
    if (!Success)
    {
        /* Failure: invalidate the path; the DLL won't be found and delay-loaded */
        *SetupDllPath = UNICODE_NULL;
    }
 
    return SetupDllPath;
}

Referenced by setupDelayHook().

GetSelectedComboListItem()

PVOID GetSelectedComboListItem

(

IN HWND

hWndList

)

Definition at line 675 of file reactos.c.

{
    INT Index;
 
    Index = ComboBox_GetCurSel(hWndList);
    if (Index == CB_ERR)
        return NULL;
 
    return (PVOID)ComboBox_GetItemData(hWndList, Index);
}

Referenced by DeviceDlgProc().

GetSelectedListViewItem()

PVOID GetSelectedListViewItem

(

IN HWND

hWndList

)

Definition at line 733 of file reactos.c.

{
    INT Index;
    LVITEM item;
 
    Index = ListView_GetSelectionMark(hWndList);
    if (Index == LB_ERR)
        return NULL;
 
    item.mask = LVIF_PARAM;
    item.iItem = Index;
    ListView_GetItem(hWndList, &item);
 
    return (PVOID)item.lParam;
}

Referenced by UpgradeRepairDlgProc().

GetSettingDescription()

static VOID NTAPI GetSettingDescription ( IN PGENERIC_LIST_ENTRY  Entry, OUT PWSTR  Buffer, IN SIZE_T  cchBufferSize  )

static

Definition at line 753 of file reactos.c.

{
    StringCchCopyW(Buffer, cchBufferSize,
                   ((PGENENTRY)GetListEntryData(Entry))->Value);
}

Referenced by DeviceDlgProc(), and SummaryDlgProc().

HotkeyThread()

static DWORD CALLBACK HotkeyThread ( LPVOID  Parameter )

static

Definition at line 3332 of file reactos.c.

{
    ATOM hotkey;
    MSG msg;
 
    DPRINT("HotkeyThread start\n");
 
    hotkey = GlobalAddAtomW(L"Setup Shift+F10 Hotkey");
    if (!RegisterHotKey(NULL, hotkey, MOD_SHIFT, VK_F10))
        DPRINT1("RegisterHotKey failed with %lu\n", GetLastError());
 
    while (GetMessageW(&msg, NULL, 0, 0))
    {
        if (msg.hwnd == NULL && msg.message == WM_HOTKEY && msg.wParam == hotkey)
        {
            WCHAR CmdLine[] = L"cmd.exe"; // CreateProcess can modify this buffer.
            STARTUPINFOW si = { sizeof(si) };
            PROCESS_INFORMATION pi;
 
            if (CreateProcessW(NULL,
                               CmdLine,
                               NULL,
                               NULL,
                               FALSE,
                               CREATE_NEW_CONSOLE,
                               NULL,
                               NULL,
                               &si,
                               &pi))
            {
                CloseHandle(pi.hProcess);
                CloseHandle(pi.hThread);
            }
            else
            {
                DPRINT1("Failed to launch command prompt: %lu\n", GetLastError());
            }
        }
    }
 
    UnregisterHotKey(NULL, hotkey);
    GlobalDeleteAtom(hotkey);
 
    DPRINT("HotkeyThread terminate\n");
    return 0;
}

Referenced by _tWinMain().

InitGenericComboList()

VOID InitGenericComboList	(	IN HWND	hWndList,
		IN PGENERIC_LIST	List,
		IN PGET_ENTRY_DESCRIPTION	GetEntryDescriptionProc
	)

Definition at line 637 of file reactos.c.

{
    INT Index, CurrentEntryIndex = 0;
    PGENERIC_LIST_ENTRY ListEntry;
    PLIST_ENTRY Entry;
    WCHAR CurrentItemText[256];
 
    for (Entry = List->ListHead.Flink;
         Entry != &List->ListHead;
         Entry = Entry->Flink)
    {
        ListEntry = CONTAINING_RECORD(Entry, GENERIC_LIST_ENTRY, Entry);
 
        if (GetEntryDescriptionProc)
        {
            GetEntryDescriptionProc(ListEntry,
                                    CurrentItemText,
                                    ARRAYSIZE(CurrentItemText));
            Index = SendMessageW(hWndList, CB_ADDSTRING, 0, (LPARAM)CurrentItemText);
        }
        else
        {
            Index = SendMessageW(hWndList, CB_ADDSTRING, 0, (LPARAM)L"n/a");
        }
 
        if (ListEntry == List->CurrentEntry)
            CurrentEntryIndex = Index;
 
        SendMessageW(hWndList, CB_SETITEMDATA, Index, (LPARAM)ListEntry);
    }
 
    SendMessageW(hWndList, CB_SETCURSEL, CurrentEntryIndex, 0);
}

Referenced by DeviceDlgProc().

InitGenericListView()

VOID InitGenericListView	(	IN HWND	hWndList,
		IN PGENERIC_LIST	List,
		IN PADD_ENTRY_ITEM	AddEntryItemProc
	)

Definition at line 696 of file reactos.c.

{
    INT CurrentEntryIndex = 0;
    LVITEM lvItem;
    PGENERIC_LIST_ENTRY ListEntry;
    PLIST_ENTRY Entry;
    WCHAR CurrentItemText[256];
 
    for (Entry = List->ListHead.Flink;
         Entry != &List->ListHead;
         Entry = Entry->Flink)
    {
        ListEntry = CONTAINING_RECORD(Entry, GENERIC_LIST_ENTRY, Entry);
 
        if (!AddEntryItemProc)
            continue;
 
        AddEntryItemProc(hWndList,
                         &lvItem,
                         ListEntry,
                         CurrentItemText,
                         ARRAYSIZE(CurrentItemText));
 
        if (ListEntry == List->CurrentEntry)
            CurrentEntryIndex = lvItem.iItem;
    }
 
    ListView_EnsureVisible(hWndList, CurrentEntryIndex, FALSE);
    ListView_SetItemState(hWndList, CurrentEntryIndex,
                          LVIS_FOCUSED | LVIS_SELECTED,
                          LVIS_FOCUSED | LVIS_SELECTED);
}

Referenced by UpgradeRepairDlgProc().

InitNtToWin32PathMappingList()

VOID InitNtToWin32PathMappingList

(

IN OUT PNT_WIN32_PATH_MAPPING_LIST

MappingList

)

Definition at line 3014 of file reactos.c.

{
    InitializeListHead(&MappingList->List);
    MappingList->MappingsCount = 0;
}

Referenced by _tWinMain().

IsShellActive()

static BOOL IsShellActive ( VOID  )

static

Detects whether a Windows shell is active.

Definition at line 2618 of file reactos.c.

{
/* See reactos/undocuser.h */
extern HWND WINAPI GetProgmanWindow(VOID);
 
    /* Return success if a shell window is present, valid, and interactive */
    HWND hWndProgman = GetProgmanWindow();
    if (!(hWndProgman && IsWindow(hWndProgman) &&
          IsWindowEnabled(hWndProgman) && IsWindowVisible(hWndProgman)))
    {
        hWndProgman = GetShellWindow();
    }
    return (hWndProgman && IsWindow(hWndProgman) &&
            IsWindowEnabled(hWndProgman) && IsWindowVisible(hWndProgman));
}

Referenced by AreThereInteractiveWindows(), and FinishDlgProc().

LoadAllocStringW()

size_t LoadAllocStringW	(	_In_opt_ HINSTANCE hInstance hInstance	,
		_In_ UINT	uID,
		_In_opt_ _Outptr_ PWSTR *	pString,
		_In_opt_ size_t	cchBufferLen
	)

Definition at line 114 of file reactos.c.

{
    PCWSTR pStr;
    size_t Length;
 
    /* Try to load the string from the resource */
    Length = LoadStringW(hInstance, uID, (PWSTR)&pStr, 0);
    if (Length == 0)
    {
        /* No resource string was found, return NULL */
        *pString = NULL;
        return 0;
    }
 
    /* If the caller gave a pointer to a buffer on input, verify whether it
     * is large enough to contain the string. If not, allocate a new buffer. */
    if (!*pString || (cchBufferLen < Length + 1))
    {
        /* Allocate a new buffer, adding a NUL-terminator */
        *pString = HeapAlloc(GetProcessHeap(), 0, (Length + 1) * sizeof(WCHAR));
        if (!*pString)
            return 0;
    }
 
    /* Copy the string, NUL-terminated */
    StringCchCopyNW(*pString, Length + 1, pStr, Length);
    return Length;
}

Referenced by CheckForOtherInstance(), DisplayMessageV(), SetWindowResPrintfVW(), and SetWindowResTextW().

LoadSetupData()

BOOL LoadSetupData

(

IN OUT PSETUPDATA

pSetupData

)

Definition at line 2919 of file reactos.c.

{
    pSetupData->PartitionList = CreatePartitionList();
    if (!pSetupData->PartitionList)
    {
        DPRINT1("Could not enumerate available disks; failing installation\n");
        return FALSE;
    }
 
    pSetupData->NtOsInstallsList = CreateNTOSInstallationsList(pSetupData->PartitionList);
    if (!pSetupData->NtOsInstallsList)
        DPRINT1("Failed to get a list of NTOS installations; continue installation...\n");
 
    /* Load the hardware, language and keyboard layout lists */
 
    pSetupData->USetupData.ComputerList = CreateComputerTypeList(pSetupData->USetupData.SetupInf);
    pSetupData->USetupData.DisplayList = CreateDisplayDriverList(pSetupData->USetupData.SetupInf);
    pSetupData->USetupData.KeyboardList = CreateKeyboardDriverList(pSetupData->USetupData.SetupInf);
 
    pSetupData->USetupData.LanguageList = CreateLanguageList(pSetupData->USetupData.SetupInf, pSetupData->DefaultLanguage);
 
    /* If not unattended, overwrite language and locale with
     * the current ones of the running ReactOS instance */
    if (!pSetupData->bUnattend)
    {
        LCID LocaleID = GetUserDefaultLCID();
 
        StringCchPrintfW(pSetupData->DefaultLanguage,
                         _countof(pSetupData->DefaultLanguage),
                         L"%08lx", LocaleID);
 
        StringCchPrintfW(pSetupData->USetupData.LocaleID,
                         _countof(pSetupData->USetupData.LocaleID),
                         L"%08lx", LocaleID);
    }
 
    /* new part */
    pSetupData->SelectedLanguageId = pSetupData->DefaultLanguage;
    wcscpy(pSetupData->DefaultLanguage, pSetupData->USetupData.LocaleID); // FIXME: In principle, only when unattended.
    pSetupData->USetupData.LanguageId = (LANGID)(wcstol(pSetupData->SelectedLanguageId, NULL, 16) & 0xFFFF);
 
    pSetupData->USetupData.LayoutList = CreateKeyboardLayoutList(pSetupData->USetupData.SetupInf,
                                                                 pSetupData->SelectedLanguageId,
                                                                 pSetupData->DefaultKBLayout);
 
    /* If not unattended, overwrite keyboard layout with
     * the current one of the running ReactOS instance */
    if (!pSetupData->bUnattend)
    {
        C_ASSERT(_countof(pSetupData->DefaultKBLayout) >= KL_NAMELENGTH);
        /* If the call fails, keep the default already stored in the buffer */
        GetKeyboardLayoutNameW(pSetupData->DefaultKBLayout);
    }
 
    /* Change the default entries in the language and keyboard layout lists */
    {
    PGENERIC_LIST LanguageList = pSetupData->USetupData.LanguageList;
    PGENERIC_LIST LayoutList = pSetupData->USetupData.LayoutList;
    PGENERIC_LIST_ENTRY ListEntry;
 
    /* Search for default language */
    for (ListEntry = GetFirstListEntry(LanguageList); ListEntry;
         ListEntry = GetNextListEntry(ListEntry))
    {
        PCWSTR LocaleId = ((PGENENTRY)GetListEntryData(ListEntry))->Id;
        if (!_wcsicmp(pSetupData->DefaultLanguage, LocaleId))
        {
            DPRINT("found %S in LanguageList\n", LocaleId);
            SetCurrentListEntry(LanguageList, ListEntry);
            break;
        }
    }
 
    /* Search for default layout */
    for (ListEntry = GetFirstListEntry(LayoutList); ListEntry;
         ListEntry = GetNextListEntry(ListEntry))
    {
        PCWSTR pszLayoutId = ((PGENENTRY)GetListEntryData(ListEntry))->Id;
        // FIXME: Temporary "fix" to set the best keyboard entry depending on the
        // selected language in unattended setup; see also usetup!SetupStartPage().
        if (( pSetupData->bUnattend && !_wcsicmp(pSetupData->DefaultLanguage, pszLayoutId)) ||
            (!pSetupData->bUnattend && !_wcsicmp(pSetupData->DefaultKBLayout, pszLayoutId)))
        {
            DPRINT("Found %S in LayoutList\n", pszLayoutId);
            SetCurrentListEntry(LayoutList, ListEntry);
            break;
        }
    }
    }
 
    return TRUE;
}

Referenced by _tWinMain().

PrepareAndDoCopyThread()

static DWORD WINAPI PrepareAndDoCopyThread ( IN LPVOID  Param )

static

Definition at line 1954 of file reactos.c.

{
    PSETUPDATA pSetupData;
    HWND hwndDlg = (HWND)Param;
    HWND hWndParent = GetParent(hwndDlg);
    HWND hWndProgress;
    LONG_PTR dwStyle;
    ERROR_NUMBER ErrorNumber;
    BOOLEAN Success;
    NTSTATUS Status;
    FSVOL_CONTEXT FsVolContext;
    COPYCONTEXT CopyContext;
    WCHAR PathBuffer[RTL_NUMBER_OF_FIELD(PARTENTRY, DeviceName) + 1];
 
    /* Retrieve pointer to the global setup data */
    pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
 
    /* Get the progress handle */
    hWndProgress = GetDlgItem(hwndDlg, IDC_PROCESSPROGRESS);
 
    /* Setup global UI context */
    UiContext.hwndDlg = hwndDlg;
    UiContext.hWndItem = GetDlgItem(hwndDlg, IDC_ITEM);
    UiContext.hWndProgress = hWndProgress;
    UiContext.dwPbStyle = 0;
 
 
    /* Disable the Close/Cancel buttons during all partition operations */
    // TODO: Consider, alternatively, to just show an info-box saying
    // that the installation process cannot be canceled at this stage?
    PropSheet_SetCloseCancel(hWndParent, FALSE);
 
 
    /*
     * Find/Set the system partition, and apply all pending partition operations.
     */
 
    /* Create context for the volume/partition operations */
    FsVolContext.pSetupData = pSetupData;
 
    /* Set status text */
    SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
                      pSetupData->hInstance,
                      IDS_CONFIG_SYSTEM_PARTITION);
    SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
 
    /* Find or set the active system partition before starting formatting */
    Success = InitSystemPartition(pSetupData->PartitionList,
                                  InstallPartition,
                                  &SystemPartition,
                                  FsVolCallback,
                                  &FsVolContext);
    // if (!Success)
    //     return FsVolContext.NextPageOnAbort;
    //
    // FIXME?? If cannot use any system partition, install FreeLdr on floppy / removable media??
    //
    if (!Success)
    {
        /* Display an error if an unexpected failure happened */
        MessageBoxW(hWndParent, L"Failed to find or set the system partition!", NULL, MB_ICONERROR);
 
        /* Re-enable the Close/Cancel buttons */
        PropSheet_SetCloseCancel(hWndParent, TRUE);
        goto Quit;
    }
 
 
    /* Set status text */
    SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
                      pSetupData->hInstance,
                      IDS_PREPARE_PARTITIONS);
    SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
 
    /* Apply all pending operations on partitions: formatting and checking */
    Success = FsVolCommitOpsQueue(pSetupData->PartitionList,
                                  SystemVolume,
                                  InstallVolume,
                                  FsVolCallback,
                                  &FsVolContext);
    if (!Success)
    {
        /* Display an error if an unexpected failure happened */
        MessageBoxW(hWndParent, L"Failed to prepare the partitions!", NULL, MB_ICONERROR);
 
        /* Re-enable the Close/Cancel buttons */
        PropSheet_SetCloseCancel(hWndParent, TRUE);
        goto Quit;
    }
 
 
    /* Re-enable the Close/Cancel buttons */
    PropSheet_SetCloseCancel(hWndParent, TRUE);
 
 
    /* Re-calculate the final destination paths */
    ASSERT(InstallPartition);
    Status = InitDestinationPaths(&pSetupData->USetupData,
                                  NULL, // pSetupData->USetupData.InstallationDirectory,
                                  InstallVolume);
    Success = NT_SUCCESS(Status);
    if (!Success)
    {
        DisplayMessage(hWndParent, MB_ICONERROR, NULL, L"InitDestinationPaths() failed with status 0x%08lx\n", Status);
        goto Quit;
    }
 
 
    /*
     * Preparation of the list of files to be copied
     */
 
    /* Set status text */
    SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
                      pSetupData->hInstance,
                      IDS_PREPARE_FILES);
    SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
 
    /* Set progress marquee style and start it up */
    dwStyle = GetWindowLongPtrW(hWndProgress, GWL_STYLE);
    SetWindowLongPtrW(hWndProgress, GWL_STYLE, dwStyle | PBS_MARQUEE);
    SendMessageW(hWndProgress, PBM_SETMARQUEE, TRUE, 0);
 
    /* Prepare the list of files */
    /* ErrorNumber = */ Success = PrepareFileCopy(&pSetupData->USetupData, NULL);
 
    /* Stop progress and restore its style */
    SendMessageW(hWndProgress, PBM_SETMARQUEE, FALSE, 0);
    SetWindowLongPtrW(hWndProgress, GWL_STYLE, dwStyle);
 
    if (/*ErrorNumber != ERROR_SUCCESS*/ !Success)
    {
        /* Display an error only if an unexpected failure happened, and not because the user cancelled the installation */
        if (!pSetupData->bAbortInstall)
            MessageBoxW(hWndParent, L"Failed to prepare the list of files!", NULL, MB_ICONERROR);
        goto Quit;
    }
 
 
    /*
     * Perform the file copy
     */
 
    /* Set status text */
    SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
                      pSetupData->hInstance,
                      IDS_COPYING_FILES);
    SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
 
    /* Create context for the copy process */
    CopyContext.pSetupData = pSetupData;
    CopyContext.TotalOperations = 0;
    CopyContext.CompletedOperations = 0;
 
    /* Do the file copying - The callback handles whether or not we should stop file copying */
    Success = DoFileCopy(&pSetupData->USetupData, FileCopyCallback, &CopyContext);
    if (!Success)
    {
        /* Display an error only if an unexpected failure happened, and not because the user cancelled the installation */
        if (!pSetupData->bAbortInstall)
            MessageBoxW(hWndParent, L"Failed to copy the files!", NULL, MB_ICONERROR);
        goto Quit;
    }
 
    // /* Set status text */
    // SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
    //                   pSetupData->hInstance,
    //                   IDS_INSTALL_FINALIZE);
    // SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
 
    /* Create the $winnt$.inf file */
    InstallSetupInfFile(&pSetupData->USetupData);
 
 
    /* Disable the Close/Cancel buttons for the remaining non-cancellable operations */
    // TODO: Consider, alternatively, to just show an info-box saying
    // that the installation process cannot be canceled at this stage?
    PropSheet_SetCloseCancel(hWndParent, FALSE);
 
    /*
     * Create or update the registry hives
     */
 
    /* Set status text */
    SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
                      pSetupData->hInstance,
                      pSetupData->RepairUpdateFlag ? IDS_UPDATE_REGISTRY
                                                   : IDS_CREATE_REGISTRY);
    SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
 
    /* Set up the progress bar */
    SendMessageW(hWndProgress,
                 PBM_SETRANGE, 0,
                 MAKELPARAM(0, 8)); // FIXME: hardcoded number of steps, see StringIDs[] array in RegistryStatus()
    SendMessageW(hWndProgress,
                 PBM_SETSTEP, 1, 0);
    SendMessageW(hWndProgress,
                 PBM_SETPOS, 0, 0);
 
    ErrorNumber = UpdateRegistry(&pSetupData->USetupData,
                                 pSetupData->RepairUpdateFlag,
                                 pSetupData->PartitionList,
                                 InstallVolume->Info.DriveLetter,
                                 pSetupData->SelectedLanguageId,
                                 RegistryStatus,
                                 NULL /* SubstSettings */);
    DBG_UNREFERENCED_PARAMETER(ErrorNumber);
    SendMessageW(UiContext.hWndProgress, PBM_SETPOS, 100, 0);
 
    /*
     * And finally, install the bootloader
     */
 
    /* Set status text */
    SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
                      pSetupData->hInstance,
                      IDS_INSTALL_BOOTLOADER);
    SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
 
    RtlFreeUnicodeString(&pSetupData->USetupData.SystemRootPath);
    StringCchPrintfW(PathBuffer, _countof(PathBuffer),
                     L"%s\\", SystemPartition->DeviceName);
    RtlCreateUnicodeString(&pSetupData->USetupData.SystemRootPath, PathBuffer);
    DPRINT1("SystemRootPath: %wZ\n", &pSetupData->USetupData.SystemRootPath);
 
    switch (pSetupData->USetupData.BootLoaderLocation)
    {
        /* Install on removable disk */
        case 1:
        {
            // TODO: So far SETUP only supports the 1st floppy.
            // Use a simple UI like comdlg32's DlgDirList* to show
            // a list of drives that the user could select.
            static const UNICODE_STRING FloppyDrive = RTL_CONSTANT_STRING(L"\\Device\\Floppy0\\");
            static const WCHAR DriveLetter = L'A';
 
            INT nRet;
        RetryCancel:
            nRet = DisplayMessage(hWndParent,
                                  MB_ICONINFORMATION | MB_OKCANCEL,
                                  L"Bootloader installation",
                                  L"Please insert a blank floppy disk in drive %c: .\n"
                                  L"All data in the floppy disk will be erased!\n"
                                  L"\nClick on OK to continue."
                                  L"\nClick on CANCEL to skip bootloader installation.",
                                  DriveLetter);
            if (nRet != IDOK)
                break; /* Skip installation */
 
        Retry:
            Status = InstallBootcodeToRemovable(pSetupData->USetupData.ArchType,
                                                &FloppyDrive,
                                                &pSetupData->USetupData.SourceRootPath,
                                                &pSetupData->USetupData.DestinationArcPath);
            if (Status == STATUS_SUCCESS)
                break; /* Successful installation */
 
            if (Status == STATUS_DEVICE_NOT_READY)
            {
                // ERROR_NO_FLOPPY
                nRet = DisplayMessage(hWndParent,
                                      MB_ICONWARNING | MB_RETRYCANCEL,
                                      NULL, // Default to "Error"
                                      L"No disk detected in drive %c: .",
                                      DriveLetter);
                if (nRet == IDRETRY)
                    goto Retry;
            }
            else if ((Status == ERROR_WRITE_BOOT) ||
                     (Status == ERROR_INSTALL_BOOTCODE))
            {
                /* Error when writing the boot code */
                DisplayError(hWndParent,
                             0, // Default to "Error"
                             IDS_ERROR_INSTALL_BOOTCODE_REMOVABLE);
            }
            else if (!NT_SUCCESS(Status))
            {
                /* Any other NTSTATUS failure code */
                DPRINT1("InstallBootcodeToRemovable() failed: Status 0x%lx\n", Status);
                DisplayError(hWndParent,
                             0, // Default to "Error"
                             IDS_ERROR_BOOTLDR_FAILED,
                             Status);
            }
            goto RetryCancel;
        }
 
        /* Install on hard-disk */
        case 2: // System partition / MBR and VBR (on BIOS-based PC)
        case 3: // VBR only (on BIOS-based PC)
        {
            /* Copy FreeLoader to the disk and save the boot entries */
            Status = InstallBootManagerAndBootEntries(
                        pSetupData->USetupData.ArchType,
                        &pSetupData->USetupData.SystemRootPath,
                        &pSetupData->USetupData.SourceRootPath,
                        &pSetupData->USetupData.DestinationArcPath,
                        (pSetupData->USetupData.BootLoaderLocation == 2)
                           ? 1 /* Install MBR and VBR */
                           : 0 /* Install VBR only */);
            if (Status == STATUS_SUCCESS)
                break; /* Successful installation */
 
            if (Status == ERROR_WRITE_BOOT)
            {
                /* Error when writing the VBR */
                DisplayError(hWndParent,
                             0, // Default to "Error"
                             IDS_ERROR_WRITE_BOOT,
                             SystemVolume->Info.FileSystem);
            }
            else if (Status == ERROR_INSTALL_BOOTCODE)
            {
                /* Error when writing the MBR */
                DisplayError(hWndParent,
                             0, // Default to "Error"
                             IDS_ERROR_INSTALL_BOOTCODE,
                             L"MBR");
            }
            else if (Status == STATUS_NOT_SUPPORTED)
            {
                DisplayError(hWndParent,
                             0, // Default to "Error"
                             IDS_ERROR_BOOTLDR_ARCH_UNSUPPORTED);
            }
            else if (!NT_SUCCESS(Status))
            {
                /* Any other NTSTATUS failure code */
                DPRINT1("InstallBootManagerAndBootEntries() failed: Status 0x%lx\n", Status);
                DisplayError(hWndParent,
                             0, // Default to "Error"
                             IDS_ERROR_BOOTLDR_FAILED,
                             Status);
            }
            Success = FALSE;
            goto Quit;
        }
 
        /* Skip installation */
        case 0:
        default:
            break;
    }
 
Quit:
    /* Signal the wizard page that we have succeeded or failed */
    PostMessage(hwndDlg, PM_INSTALL_DONE, Success, 0); // Status
    return Success;
}

Referenced by ProcessDlgProc().

ProcessDlgProc()

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

static

Definition at line 2310 of file reactos.c.

{
    PSETUPDATA pSetupData;
 
    /* Retrieve pointer to the global setup data */
    pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Save pointer to the global setup data */
            pSetupData = (PSETUPDATA)((LPPROPSHEETPAGEW)lParam)->lParam;
            SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
 
            /* Reset the status text and set the main label in bold */
            SetDlgItemTextW(hwndDlg, IDC_ACTIVITY, L"");
            SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
            SetDlgItemFont(hwndDlg, IDC_ACTIVITY, pSetupData->hBoldFont, TRUE);
            break;
        }
 
        case WM_SETCURSOR:
        {
            /* Set a page-wide cursor */
            if (!hWaitCursor)
                break;
            SetCursor(hWaitCursor);
            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
            return TRUE;
        }
 
        case WM_NOTIFY:
        {
            LPNMHDR lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                {
                    HWND hWndParent = GetParent(hwndDlg);
 
                    /*
                     * Disable all buttons during installation, and hide "Back" and "Next".
                     * Don't use the PropSheet_SetWizButtons() macro, because its
                     * posted message would be handled after hiding the buttons.
                     * The message would then interfere with the hidden buttons
                     * (when both "Back" and "Next" are hidden, "Next" gets forcefully shown).
                     */
                    SendMessageW(hWndParent, PSM_SETWIZBUTTONS, 0, 0);
                    // PropSheet_ShowWizButtons(hWndParent, 0, PSWIZB_BACK | PSWIZB_NEXT);
                    ShowDlgItem(hWndParent, ID_WIZBACK, SW_HIDE);
                    ShowDlgItem(hWndParent, ID_WIZNEXT, SW_HIDE);
 
                    /* Start the installation procedure once the page is fully displayed */
                    PostMessageW(hwndDlg, PM_INSTALL_START, 0, 0);
                    break;
                }
 
                case PSN_KILLACTIVE:
                {
                    /* Avoid reentrant calls caused by the message dispatching
                     * done below: allow only the first page change, and ignore
                     * all the others. */
                    if (InterlockedFlagsTestAndSet8(&pSetupData->bStopInstall,
                                                    SETUP_PAGE_SWITCHING))
                    {
                        SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
                        return TRUE;
                    }
 
                    /* If no installation is running, just change the page */
                    if (!pSetupData->hInstallThread)
                        break;
 
                    /* Wait for the installation thread to terminate.
                     * Since we dispatch messages in the meantime, we must
                     * guard the property sheet notification handlers from
                     * being invoked multiple times. */
                    DWORD dwStatus = WaitForSingleObject(pSetupData->hInstallThread, 0);
                    if (dwStatus == WAIT_TIMEOUT)
                    {
                        /* Show the hourglass cursor */
                        HCURSOR hOldCursor;
                        hWaitCursor = LoadCursor(NULL, IDC_WAIT);
                        hOldCursor = SetCursor(hWaitCursor);
                        ShowCursor(TRUE);
 
                        for (;;)
                        {
                            MSG msg;
                            dwStatus = MsgWaitForMultipleObjects(1, &pSetupData->hInstallThread,
                                                                 FALSE, INFINITE,
                                                                 QS_ALLINPUT | QS_ALLPOSTMESSAGE);
                            if (dwStatus != (WAIT_OBJECT_0 + 1))
                                break; // Stop if anything else (thread terminated, timeout or failure).
 
                            /* We still need to process main window messages to avoid freeze */
                            while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
                            {
                                TranslateMessage(&msg);
                                DispatchMessageW(&msg);
                            }
                        }
 
                        /* Restore the old cursor */
                        ShowCursor(FALSE);
                        SetCursor(hOldCursor);
                        hWaitCursor = NULL;
                    }
#if 0 && DBG
                    if (dwStatus == WAIT_OBJECT_0)
                    {
                        DWORD dwExitCode = NO_ERROR;
                        GetExitCodeThread(pSetupData->hInstallThread, &dwExitCode);
                        DBG_UNREFERENCED_PARAMETER(dwExitCode);
                    }
#endif
                    /* Cleanup; we can now change the page */
                    CloseHandle(pSetupData->hInstallThread);
                    pSetupData->hInstallThread = NULL;
                    CloseHandle(pSetupData->hHaltInstallEvent);
                    pSetupData->hHaltInstallEvent = NULL;
                    break;
                }
 
                case PSN_QUERYCANCEL:
                {
                    INT nRet;
 
                    if (pSetupData->bStopInstall)
                    {
                        /* The installation is terminating (either successfully,
                         * or cancelled by the user or due to an error), ignore all
                         * new requests since this is now too late to change bets. */
                        nRet = IDYES;
                    }
                    else
                    {
                        /* Halt the on-going file copy */
                        ResetEvent(pSetupData->hHaltInstallEvent);
 
                        nRet = DisplayMessage(GetParent(hwndDlg),
                                              MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
                                              MAKEINTRESOURCEW(IDS_ABORTSETUP2),
                                              MAKEINTRESOURCEW(IDS_ABORTSETUP));
                        if (nRet == IDYES)
                        {
                            /* Signal the file copy thread to stop */
                            InterlockedOr8((PCHAR)&pSetupData->bStopInstall, SETUP_ABORT_INSTALL);
                        }
                        /* else, we don't stop installation, resume file copy */
                        SetEvent(pSetupData->hHaltInstallEvent);
                    }
 
                    /* If we are not already in the process of cancelling
                     * the installation or switching to a page, do it now. */
                    if ((nRet == IDYES) && !pSetupData->bPageSwitching &&
                        !InterlockedFlagsTestAndSet8(&pSetupData->bStopInstall,
                                                     SETUP_IS_CANCELLING))
                    {
                        /* Go to the Abort page */
#ifdef TERMINATE_USE_PRESSBUTTON
                        PropSheet_SetCloseCancel(GetParent(hwndDlg), FALSE);
                        PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_ABORTPAGE);
#else
                        PostMessageW(hwndDlg, PM_INSTALL_DONE, FALSE, 0);
#endif
                    }
 
                    /* Do not close the wizard too soon */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
                    return TRUE;
                }
 
                case PSN_WIZBACK:
                    /* Always disable going back */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
                    return TRUE;
 
                case PSN_WIZNEXT:
                {
#ifdef TERMINATE_USE_PRESSBUTTON
                    LONG_PTR nNextPage = (!pSetupData->bAbortInstall ? IDD_FINISHPAGE : IDD_ABORTPAGE);
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, nNextPage);
#else
                    /* Always disable going next */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
#endif
                    return TRUE;
                }
 
                default:
                    break;
            }
            break;
        }
 
        case PM_INSTALL_START:
        {
            HWND hWndParent = GetParent(hwndDlg);
 
            ASSERT(pSetupData->hInstallThread == NULL);
 
            /* Force repainting first to make sure the wizard is visible */
            InvalidateRect(hWndParent, NULL, FALSE);
            UpdateWindow(hWndParent);
 
            /* Create the file-copy halt (manual-reset) event */
            pSetupData->hHaltInstallEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
            if (!pSetupData->hHaltInstallEvent)
            {
                DisplayMessage(hWndParent, MB_ICONERROR, NULL,
                               L"Cannot create the install event, error %lu\n", GetLastError());
                goto Fail;
            }
            /* Start the installation thread */
            pSetupData->bStopInstall = FALSE;
            pSetupData->hInstallThread = CreateThread(NULL, 0,
                                                      PrepareAndDoCopyThread,
                                                      (PVOID)hwndDlg,
                                                      0, NULL);
            if (!pSetupData->hInstallThread)
            {
                DisplayMessage(hWndParent, MB_ICONERROR, NULL,
                               L"Cannot create the installation thread, error %lu\n", GetLastError());
                CloseHandle(pSetupData->hHaltInstallEvent);
                pSetupData->hHaltInstallEvent = NULL;
        Fail:
                /* Cancel the installation */
                InterlockedOr8((PCHAR)&pSetupData->bStopInstall, SETUP_ABORT_INSTALL);
#ifdef TERMINATE_USE_PRESSBUTTON
                PropSheet_SetCloseCancel(hWndParent, FALSE);
                PropSheet_PressButton(hWndParent, PSBTN_CANCEL);
#else
                SendMessageW(hwndDlg, PM_INSTALL_DONE, FALSE, 0);
#endif
            }
            break;
        }
 
        case PM_INSTALL_DONE:
        {
            HWND hWndParent = GetParent(hwndDlg);
            BOOL Success = !!wParam;
            BOOL AutoSwitchPage = TRUE;
 
            /* If an unexpected error happened, stay on the copy page to allow
             * the user to view the current state, and keep the Close/Cancel
             * buttons to allow going to the Abort page.
             * Otherwise, we have been manually cancelled by the user and we
             * will directly switch to the Abort page. */
            if (!Success && !pSetupData->bStopInstall)
            {
                PropSheet_SetCloseCancel(hWndParent, TRUE);
                AutoSwitchPage = FALSE;
            }
            else
            {
                /* Disable the Close/Cancel buttons, since the installation has
                 * either successfully terminated, or was already cancelled by
                 * the user. */
                PropSheet_SetCloseCancel(hWndParent, FALSE);
            }
 
            if (!Success)
            {
                /* The installation was aborted */
                InterlockedOr8((PCHAR)&pSetupData->bStopInstall, SETUP_ABORT_INSTALL);
            }
            else if (pSetupData->bAbortInstall)
            {
                /* Override success in case the thread just terminated with some status
                 * while at the same time, the user chose to cancel the installation */
                Success = FALSE;
            }
 
            /* We are done! Switch to the Finish or the Abort page */
            if (!AutoSwitchPage)
                break;
            // TODO: if (!Success): Unwind installation.
#ifdef TERMINATE_USE_PRESSBUTTON
            // NOTE: In this case, PSN_QUERYCANCEL **CANNOT** call PM_INSTALL_DONE
            PropSheet_PressButton(hWndParent, Success ? PSBTN_NEXT : PSBTN_CANCEL);
#else
            if (!Success)
                InterlockedOr8((PCHAR)&pSetupData->bStopInstall, SETUP_IS_CANCELLING);
            PropSheet_SetCurSelByID(hWndParent, Success ? IDD_FINISHPAGE : IDD_ABORTPAGE);
#endif
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

PropSheet_SetCloseCancel()

VOID PropSheet_SetCloseCancel	(	_In_ HWND	hWndWiz,
		_In_ BOOL	Enable
	)

Enable or disable the Cancel and the Close title-bar property-sheet buttons.

The buttons are however kept visible in case they are disabled (this informs the user they are disabled only temporarily).

Definition at line 1939 of file reactos.c.

{
    EnableDlgItem(hWndWiz, IDCANCEL, Enable);
    EnableMenuItem(GetSystemMenu(hWndWiz, FALSE),
                   SC_CLOSE,
                   MF_BYCOMMAND | (Enable ? MF_ENABLED : MF_GRAYED));
}

Referenced by FinishDlgProc(), PrepareAndDoCopyThread(), and ProcessDlgProc().

PropSheetCallback()

static int CALLBACK PropSheetCallback ( _In_ HWND  hDlg, _In_ UINT  message, _In_ LPARAM  lParam  )

static

Definition at line 3569 of file reactos.c.

{
    switch (message)
    {
        case PSCB_PRECREATE:
        {
            LPDLGTEMPLATE   dlgTemplate   =   (LPDLGTEMPLATE)lParam;
            LPDLGTEMPLATEEX dlgTemplateEx = (LPDLGTEMPLATEEX)lParam;
            DWORD dwStyle = 0, dwStyleMask = 0;
 
            // FIXME: HACK: See hack in PropSheetCallback()::PSCB_INITIALIZED
            // Hide the dialog by default; DM_REPOSITION will center it on screen then show it.
            dwStyleMask |= WS_VISIBLE;
 
            dwStyle |= DS_CENTER; // Center the dialog -- But propsheet code repositions it afterwards...
            //dwStyleMask |= DS_CONTEXTHELP; // TODO: Enable if you want context help.
            dwStyle |= DS_SETFOREGROUND; // Ensure we are initially set to the foreground.
            dwStyleMask |= dwStyle;
 
            /* Set the property sheet dialog styles */
            if (dlgTemplateEx->signature == 0xFFFF)
                dlgTemplateEx->style = (dlgTemplateEx->style & ~dwStyleMask) | (dwStyle & dwStyleMask);
            else
                dlgTemplate->style = (dlgTemplate->style & ~dwStyleMask) | (dwStyle & dwStyleMask);
            break;
        }
 
        // NOTE: This callback is needed to set large icon correctly.
        case PSCB_INITIALIZED:
        {
            HICON hIcon = LoadIconW(SetupData.hInstance, MAKEINTRESOURCEW(IDI_MAIN));
            SendMessageW(hDlg, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
 
            /* Sub-class the property sheet window procedure */
            wpOrgPrshtProc = (WNDPROC)SetWindowLongPtrW(hDlg, DWLP_DLGPROC, (LONG_PTR)PrshtWndProc);
 
            // FIXME: HACK: Wine comctl32 propsheet.c doesn't send DM_REPOSITION
            // after creating, initializing and resizing the property sheet dialog,
            // so we simulate its call there...
            PostMessageW(hDlg, DM_REPOSITION, 0, 0);
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by _tWinMain().

PrshtWndProc()

static LRESULT CALLBACK PrshtWndProc ( HWND  hWnd, UINT  uMessage, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 3526 of file reactos.c.

{
    switch (uMessage)
    {
        case DM_REPOSITION:
        {
            /* Center the wizard window */
            CenterWindow(hWnd);
            // FIXME: HACK: See hack in PropSheetCallback()::PSCB_INITIALIZED
            ShowWindow(hWnd, SW_SHOWNORMAL);
            break;
        }
 
        case WM_SETCURSOR:
        {
            /* Set a wizard-wide cursor */
            // NOTE: There is a problem, where when hovering over the wizard
            // navigation buttons, the cursor would blink with the arrow.
            // To mitigate this problem, only show the custom cursor when
            // we are on the main wizard window.
            if (!(hWaitCursor && (wParam == (WPARAM)hWnd)))
                break;
            SetCursor(hWaitCursor);
            return TRUE;
        }
 
        case WM_DESTROY:
        {
            /* Restore the original dialog procedure */
            ASSERT(wpOrgPrshtProc);
            SetWindowLongPtrW(hWnd, DWLP_DLGPROC, (LONG_PTR)wpOrgPrshtProc);
        }
 
        default:
            break;
    }
 
    /* Invoke the original dialog procedure */
    return CallWindowProc(wpOrgPrshtProc, hWnd, uMessage, wParam, lParam);
}

Referenced by PropSheetCallback().

RegistryStatus()

static VOID __cdecl RegistryStatus ( IN REGISTRY_STATUS  RegStatus,   ...  )

static

Definition at line 1901 of file reactos.c.

{
    /* WARNING: Please keep this lookup table in sync with the resources! */
    static const UINT StringIDs[] =
    {
        IDS_REG_DONE,                   /* Success */
        IDS_REG_REGHIVEUPDATE,          /* RegHiveUpdate */
        IDS_REG_IMPORTFILE,             /* ImportRegHive */
        IDS_REG_DISPLAYSETTINGSUPDATE,  /* DisplaySettingsUpdate */
        IDS_REG_LOCALESETTINGSUPDATE,   /* LocaleSettingsUpdate */
        IDS_REG_ADDKBLAYOUTS,           /* KeybLayouts */
        IDS_REG_KEYBOARDSETTINGSUPDATE, /* KeybSettingsUpdate */
        IDS_REG_CODEPAGEINFOUPDATE,     /* CodePageInfoUpdate */
    };
 
    if (RegStatus < _countof(StringIDs))
    {
        va_list args;
        va_start(args, RegStatus);
        SetWindowResPrintfVW(UiContext.hWndItem, SetupData.hInstance, StringIDs[RegStatus], args);
        va_end(args);
    }
    else
    {
        SetWindowResPrintfW(UiContext.hWndItem, SetupData.hInstance, IDS_REG_UNKNOWN, RegStatus);
    }
 
    SendMessageW(UiContext.hWndProgress, PBM_STEPIT, 0, 0);
}

Referenced by PrepareAndDoCopyThread().

setupDelayHook()

static FARPROC WINAPI setupDelayHook ( unsigned  dliNotify, PDelayLoadInfo  pdli  )

static

Controls the delay-loading of Setup DLLs from a suitable path.

See also

https://stackoverflow.com/a/75325443 https://devblogs.microsoft.com/oldnewthing/20170126-00/?p=95265

Definition at line 3440 of file reactos.c.

{
    static CHAR dllPath[MAX_PATH];
    static PCWSTR setupDllPath = NULL;
 
    switch (dliNotify)
    {
        case dliNotePreLoadLibrary:
        {
            // NOTE: Add any other needed setup-specific DLLs there.
            if (_stricmp(pdli->szDll, "setuplib.dll") == 0)
            {
                if (!setupDllPath)
                    setupDllPath = GetLocalSetupDllPath();
                if (setupDllPath && *setupDllPath &&
                    SUCCEEDED(StringCchPrintfA(dllPath, _countof(dllPath), "%S\\%s",
                                               setupDllPath, pdli->szDll)))
                {
                    pdli->szDll = dllPath; /* Set szDll to the new path */
                }
            }
            break; /* Load the DLL using the modified path */
        }
 
        case dliFailLoadLib:
        {
            /*
             * Library loading failed.
             * Raise a hard error instead of the default
             * exception, and "cleanly" kill the process.
             */
            ANSI_STRING DllPathA;
            DECLARE_UNICODE_STRING_SIZE(DllPathU, MAX_PATH);
            ULONG_PTR Parameters[] = {(ULONG_PTR)&DllPathU};
            ULONG Response;
 
            RtlInitAnsiString(&DllPathA, pdli->szDll);
            RtlAnsiStringToUnicodeString(&DllPathU, &DllPathA, FALSE);
            NtRaiseHardError(STATUS_DLL_NOT_FOUND | HARDERROR_OVERRIDE_ERRORMODE,
                             _countof(Parameters),
                             0x1,
                             Parameters,
                             OptionOk,
                             &Response);
            ExitProcess(-1);
            break;
        }
 
        default:
            break;
    }
 
    return NULL;
}

SetWindowResPrintfVW()

VOID SetWindowResPrintfVW	(	_In_ HWND	hWnd,
		_In_opt_ HINSTANCE	hInstance,
		_In_ UINT	uID,
		_In_ va_list	args
	)

Definition at line 302 of file reactos.c.

{
    WCHAR ResBuffer[256];
    WCHAR szText[256];
    PWSTR ResFmt = ResBuffer; // Use the static buffers by default.
    PWSTR String = szText;
 
    /* Try to load the string from the resource */
    (void)LoadAllocStringW(hInstance, uID, &ResFmt, _countof(ResBuffer));
    if (!ResFmt)
        return;
 
    /* Format the string and retrieve its length. If it is too long,
     * an auxiliary buffer is allocated; otherwise the static buffer
     * is used. The string is built to be NUL-terminated. */
    (void)FormatAllocStringWV(&String, _countof(szText), ResFmt, args);
    if (!String)
    {
        /* Allocation failed, use the original format string verbatim */
        String = ResFmt;
    }
 
    SetWindowTextW(hWnd, String);
 
    /* Free the buffers if needed */
    if ((String != szText) && (String != ResFmt))
        HeapFree(GetProcessHeap(), 0, String);
 
    if (ResFmt && (ResFmt != ResBuffer))
        HeapFree(GetProcessHeap(), 0, ResFmt);
}

Referenced by RegistryStatus(), and SetWindowResPrintfW().

SetWindowResPrintfW()

VOID __cdecl SetWindowResPrintfW	(	_In_ HWND	hWnd,
		_In_opt_ HINSTANCE	hInstance,
		_In_ UINT	uID,
			...
	)

Definition at line 340 of file reactos.c.

{
    va_list args;
 
    va_start(args, uID);
    SetWindowResPrintfVW(hWnd, hInstance, uID, args);
    va_end(args);
}

Referenced by FileCopyCallback(), FsVolCallback(), and RegistryStatus().

SetWindowResTextW()

VOID SetWindowResTextW	(	_In_ HWND	hWnd,
		_In_opt_ HINSTANCE	hInstance,
		_In_ UINT	uID
	)

Definition at line 283 of file reactos.c.

{
    WCHAR szText[256];
    PWSTR String = szText; // Use the static buffer by default.
 
    /* Try to load the string from the resource */
    (void)LoadAllocStringW(hInstance, uID, &String, _countof(szText));
    if (!String)
        return;
    SetWindowTextW(hWnd, String);
    if (String != szText)
        HeapFree(GetProcessHeap(), 0, String);
}

Referenced by FinishDlgProc(), PrepareAndDoCopyThread(), and SummaryDlgProc().

StartDlgProc()

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

static

• Center the wizard window *‍/

Definition at line 354 of file reactos.c.

{
    PSETUPDATA pSetupData;
 
    /* Retrieve pointer to the global setup data */
    pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Save pointer to the global setup data */
            pSetupData = (PSETUPDATA)((LPPROPSHEETPAGEW)lParam)->lParam;
            SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
 
            /* Set title font */
            SetDlgItemFont(hwndDlg, IDC_STARTTITLE, pSetupData->hTitleFont, TRUE);
 
            // TEMPTEMP: Set the ReactOS-Alpha information in bold.
            // TODO: Remove once we reach 0.5/Beta :)
            SetDlgItemFont(hwndDlg, IDC_WARNTEXT1, pSetupData->hBoldFont, TRUE);
            SetDlgItemFont(hwndDlg, IDC_WARNTEXT2, pSetupData->hBoldFont, TRUE);
            SetDlgItemFont(hwndDlg, IDC_WARNTEXT3, pSetupData->hBoldFont, TRUE);
 
            //CenterWindow(GetParent(hwndDlg));
            return TRUE;
        }
 
        case WM_NOTIFY:
        {
            LPNMHDR lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                {
                    /* Only "Next" and "Cancel" for the first page and hide "Back".
                     * Don't use the PropSheet_SetWizButtons() macro, because its
                     * posted message could interfere with the hidden button. */
                    SendMessageW(GetParent(hwndDlg), PSM_SETWIZBUTTONS, 0, PSWIZB_NEXT);
                    // PropSheet_ShowWizButtons(GetParent(hwndDlg), 0, PSWIZB_BACK);
                    ShowDlgItem(GetParent(hwndDlg), ID_WIZBACK, SW_HIDE);
                    break;
                }
 
                case PSN_KILLACTIVE:
                {
                    /* Show "Back" button */
                    // PropSheet_ShowWizButtons(GetParent(hwndDlg), PSWIZB_BACK, PSWIZB_BACK);
                    ShowDlgItem(GetParent(hwndDlg), ID_WIZBACK, SW_SHOW);
                    break;
                }
 
                default:
                    break;
            }
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

SummaryDlgProc()

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

static

Definition at line 1149 of file reactos.c.

{
    static WCHAR szOrgWizNextBtnText[260]; // TODO: Make it dynamic
 
    PSETUPDATA pSetupData;
 
    /* Retrieve pointer to the global setup data */
    pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Save pointer to the global setup data */
            pSetupData = (PSETUPDATA)((LPPROPSHEETPAGEW)lParam)->lParam;
            SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
            break;
        }
 
        case WM_COMMAND:
        {
            if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_CONFIRM_INSTALL)
            {
                // Ideally we could add the PSWIZBF_ELEVATIONREQUIRED style.
                if (IsDlgButtonChecked(hwndDlg, IDC_CONFIRM_INSTALL) == BST_CHECKED)
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
                else
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
                return TRUE;
            }
            break;
        }
 
        case WM_NOTIFY:
        {
            LPNMHDR lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                {
                    WCHAR CurrentItemText[256];
 
                    ASSERT(InstallPartition);
 
                    /* Skip the Summary page in unattended setup */
                    if (pSetupData->bUnattend)
                    {
                        SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
                        return TRUE;
                    }
 
                    /* Show the current selected settings */
 
                    // FIXME! Localize
                    if (pSetupData->RepairUpdateFlag)
                    {
                        StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
                                         L"Upgrading/Repairing \"%s\" from \"%s\"",
                                         pSetupData->CurrentInstallation->InstallationName,
                                         pSetupData->CurrentInstallation->VendorName);
                    }
                    else
                    {
                        StringCchCopyW(CurrentItemText, ARRAYSIZE(CurrentItemText),
                                       L"New ReactOS installation");
                    }
                    SetDlgItemTextW(hwndDlg, IDC_INSTALLTYPE, CurrentItemText);
 
                    SetDlgItemTextW(hwndDlg, IDC_INSTALLSOURCE, L"n/a");
                    SetDlgItemTextW(hwndDlg, IDC_ARCHITECTURE, L"n/a");
 
                    GetSettingDescription(GetCurrentListEntry(pSetupData->USetupData.ComputerList),
                                          CurrentItemText,
                                          ARRAYSIZE(CurrentItemText));
                    SetDlgItemTextW(hwndDlg, IDC_COMPUTER, CurrentItemText);
 
                    GetSettingDescription(GetCurrentListEntry(pSetupData->USetupData.DisplayList),
                                          CurrentItemText,
                                          ARRAYSIZE(CurrentItemText));
                    SetDlgItemTextW(hwndDlg, IDC_DISPLAY, CurrentItemText);
 
                    GetSettingDescription(GetCurrentListEntry(pSetupData->USetupData.KeyboardList),
                                          CurrentItemText,
                                          ARRAYSIZE(CurrentItemText));
                    SetDlgItemTextW(hwndDlg, IDC_KEYBOARD, CurrentItemText);
 
                    if (InstallVolume->Info.DriveLetter)
                    {
#if 0
                        StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
                                         L"%c: \x2014 %wZ",
                                         InstallVolume->Info.DriveLetter,
                                         &pSetupData->USetupData.DestinationRootPath);
#else
                        StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
                                         L"%c: \x2014 Harddisk %lu, Partition %lu",
                                         InstallVolume->Info.DriveLetter,
                                         InstallPartition->DiskEntry->DiskNumber,
                                         InstallPartition->OnDiskPartitionNumber);
#endif
                    }
                    else
                    {
#if 0
                        StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
                                         L"%wZ",
                                         &pSetupData->USetupData.DestinationRootPath);
#else
                        StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
                                         L"Harddisk %lu, Partition %lu",
                                         InstallPartition->DiskEntry->DiskNumber,
                                         InstallPartition->OnDiskPartitionNumber);
#endif
                    }
                    SetDlgItemTextW(hwndDlg, IDC_DESTDRIVE, CurrentItemText);
 
                    SetDlgItemTextW(hwndDlg, IDC_PATH,
                                    pSetupData->USetupData.InstallationDirectory
                                    /*pSetupData->USetupData.InstallPath.Buffer*/);
 
 
                    /* Change the "Next" button text to "Install" */
                    // PropSheet_SetNextText(GetParent(hwndDlg), ...);
                    GetDlgItemTextW(GetParent(hwndDlg), ID_WIZNEXT,
                                    szOrgWizNextBtnText, ARRAYSIZE(szOrgWizNextBtnText));
                    SetWindowResTextW(GetDlgItem(GetParent(hwndDlg), ID_WIZNEXT),
                                      pSetupData->hInstance,
                                      IDS_INSTALLBTN);
 
                    /* Keep the "Next" button disabled. It will be enabled only
                     * when the user clicks on the installation approval checkbox. */
                    CheckDlgButton(hwndDlg, IDC_CONFIRM_INSTALL, BST_UNCHECKED);
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
                    break;
                }
 
                case PSN_QUERYINITIALFOCUS:
                {
                    /* Focus on the confirmation check-box */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)GetDlgItem(hwndDlg, IDC_CONFIRM_INSTALL));
                    return TRUE;
                }
 
                case PSN_KILLACTIVE:
                {
                    /* Restore the original "Next" button text */
                    SetDlgItemTextW(GetParent(hwndDlg), ID_WIZNEXT, szOrgWizNextBtnText);
                    break;
                }
 
                case PSN_QUERYCANCEL:
                {
                    if (DisplayMessage(GetParent(hwndDlg),
                                       MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
                                       MAKEINTRESOURCEW(IDS_ABORTSETUP2),
                                       MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
                    {
                        /* Go to the Abort page */
                        PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_ABORTPAGE);
                    }
 
                    /* Do not close the wizard too soon */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
                    return TRUE;
                }
 
                case PSN_WIZBACK:
                {
                    /* When the user performs a regular installation, go back to the previous page */
                    if (!pSetupData->RepairUpdateFlag)
                        break;
 
                    if (GetNumberOfListEntries(pSetupData->NtOsInstallsList) > 1)
                    {
                        /* Return to the Upgrade/Repair selection page, when the user is
                         * upgrading and there are more than one installation available */
                        SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_UPDATEREPAIRPAGE);
                    }
                    else
                    {
                        /* Return to the Install type selection page, when the user is
                         * upgrading and there is at most one installation available */
                        SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_TYPEPAGE);
                    }
                    return TRUE;
                }
 
                default:
                    break;
            }
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

TypeDlgProc()

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

static

Definition at line 426 of file reactos.c.

{
    PSETUPDATA pSetupData;
 
    /* Retrieve pointer to the global setup data */
    pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Save pointer to the global setup data */
            pSetupData = (PSETUPDATA)((LPPROPSHEETPAGEW)lParam)->lParam;
            SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
 
            /* Set the options in bold */
            SetDlgItemFont(hwndDlg, IDC_INSTALL, pSetupData->hBoldFont, TRUE);
            SetDlgItemFont(hwndDlg, IDC_UPDATE, pSetupData->hBoldFont, TRUE);
 
            /*
             * Enable double-click handling with the BS_NOTIFY style for both options.
             * Idea adapted from: https://devblogs.microsoft.com/oldnewthing/20050804-10/?p=34713
             */
            {
            HWND hRadio = GetDlgItem(hwndDlg, IDC_INSTALL);
            SetWindowLongPtrW(hRadio, GWL_STYLE, GetWindowLongPtrW(hRadio, GWL_STYLE) | BS_NOTIFY);
            hRadio = GetDlgItem(hwndDlg, IDC_UPDATE);
            SetWindowLongPtrW(hRadio, GWL_STYLE, GetWindowLongPtrW(hRadio, GWL_STYLE) | BS_NOTIFY);
            }
 
            /*
             * Enable the "Update" radio button and text only if we have
             * available NT installations, otherwise disable them.
             */
            if (pSetupData->NtOsInstallsList &&
                GetNumberOfListEntries(pSetupData->NtOsInstallsList) != 0)
            {
                EnableDlgItem(hwndDlg, IDC_UPDATE, TRUE);
                EnableDlgItem(hwndDlg, IDC_UPDATETEXT, TRUE);
            }
            else
            {
                EnableDlgItem(hwndDlg, IDC_UPDATE, FALSE);
                EnableDlgItem(hwndDlg, IDC_UPDATETEXT, FALSE);
            }
 
            /* Check the "Install ReactOS" radio button and ensure it is initially focused */
            CheckRadioButton(hwndDlg, IDC_INSTALL, IDC_UPDATE, IDC_INSTALL);
            SetFocus(GetDlgItem(hwndDlg, IDC_INSTALL));
            return FALSE;
        }
 
        case WM_COMMAND:
        {
            /*
             * Go to the next page if the user double-clicked one of the options.
             * Idea adapted from: https://devblogs.microsoft.com/oldnewthing/20050804-10/?p=34713
             */
            if (HIWORD(wParam) == BN_DBLCLK) switch (LOWORD(wParam))
            {
            case IDC_INSTALL:
            case IDC_UPDATE:
                PropSheet_PressButton(GetParent(hwndDlg), PSBTN_NEXT);
                return TRUE;
            }
            break;
        }
 
        case WM_NOTIFY:
        {
            LPNMHDR lpnm = (LPNMHDR)lParam;
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                {
                    /* Ensure the "Install ReactOS" radio button is checked if we don't have
                     * a selected installation (default case), which can also happen if the
                     * user clicked on the "Do not upgrade" button on the Upgrade/Repair
                     * selection page, then went back here. */
                    if (!pSetupData->CurrentInstallation)
                        CheckRadioButton(hwndDlg, IDC_INSTALL, IDC_UPDATE, IDC_INSTALL);
                    else
                        CheckRadioButton(hwndDlg, IDC_INSTALL, IDC_UPDATE, IDC_UPDATE);
 
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
                    break;
                }
 
                case PSN_QUERYCANCEL:
                {
                    if (DisplayMessage(GetParent(hwndDlg),
                                       MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
                                       MAKEINTRESOURCEW(IDS_ABORTSETUP2),
                                       MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
                    {
                        /* Go to the Abort page */
                        PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_ABORTPAGE);
                    }
 
                    /* Do not close the wizard too soon */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
                    return TRUE;
                }
 
                case PSN_WIZNEXT: /* Set the selected data */
                {
                    /*
                     * Go update only if we have available NT installations
                     * and we choose to do so.
                     */
                    if (pSetupData->NtOsInstallsList &&
                        GetNumberOfListEntries(pSetupData->NtOsInstallsList) != 0 &&
                        IsDlgButtonChecked(hwndDlg, IDC_UPDATE) == BST_CHECKED)
                    {
                        pSetupData->RepairUpdateFlag = TRUE;
 
                        /*
                         * Display the existing NT installations page only
                         * if we have more than one available NT installations.
                         */
                        if (GetNumberOfListEntries(pSetupData->NtOsInstallsList) > 1)
                        {
                            /* pSetupData->CurrentInstallation will be set from within IDD_UPDATEREPAIRPAGE */
 
                            /* Actually the best would be to dynamically insert the page only when needed */
                            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_UPDATEREPAIRPAGE);
                        }
                        else
                        {
                            /* Retrieve the current installation */
                            pSetupData->CurrentInstallation =
                                (PNTOS_INSTALLATION)GetListEntryData(GetCurrentListEntry(pSetupData->NtOsInstallsList));
                            InstallPartition = pSetupData->CurrentInstallation->Volume->PartEntry;
                            StringCchCopyW(pSetupData->USetupData.InstallationDirectory,
                                           _countof(pSetupData->USetupData.InstallationDirectory),
                                           pSetupData->CurrentInstallation->PathComponent);
 
                            /* Jump to the Summary page during repair/upgrade */
                            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_SUMMARYPAGE);
                        }
                    }
                    else
                    {
                        pSetupData->CurrentInstallation = NULL;
                        pSetupData->RepairUpdateFlag = FALSE;
                        SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_DEVICEPAGE);
                    }
 
                    return TRUE;
                }
 
                default:
                    break;
            }
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

UpgradeRepairDlgProc()

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

static

Definition at line 829 of file reactos.c.

{
    PSETUPDATA pSetupData;
    HWND hList;
    HIMAGELIST hSmall;
 
    /* Retrieve pointer to the global setup data */
    pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Save pointer to the global setup data */
            pSetupData = (PSETUPDATA)((LPPROPSHEETPAGEW)lParam)->lParam;
            SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
 
            hList = GetDlgItem(hwndDlg, IDC_NTOSLIST);
 
            ListView_SetExtendedListViewStyleEx(hList, LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);
 
            CreateListViewColumns(pSetupData->hInstance,
                                  hList,
                                  column_ids,
                                  column_widths,
                                  column_alignment,
                                  MAX_LIST_COLUMNS);
 
            /* Create the ImageList */
            hSmall = ImageList_Create(GetSystemMetrics(SM_CXSMICON),
                                      GetSystemMetrics(SM_CYSMICON),
                                      ILC_COLOR32 | ILC_MASK, // ILC_COLOR24
                                      1, 1);
 
            /* Add event type icons to the ImageList */
            ImageList_AddIcon(hSmall, LoadIconW(pSetupData->hInstance, MAKEINTRESOURCEW(IDI_ROSICON)));
            ImageList_AddIcon(hSmall, LoadIconW(pSetupData->hInstance, MAKEINTRESOURCEW(IDI_WINICON)));
 
            /* Assign the ImageList to the List View */
            ListView_SetImageList(hList, hSmall, LVSIL_SMALL);
 
            InitGenericListView(hList, pSetupData->NtOsInstallsList, AddNTOSInstallationItem);
            break;
        }
 
        case WM_DESTROY:
        {
            hList = GetDlgItem(hwndDlg, IDC_NTOSLIST);
            hSmall = ListView_GetImageList(hList, LVSIL_SMALL);
            ListView_SetImageList(hList, NULL, LVSIL_SMALL);
            ImageList_Destroy(hSmall);
            return TRUE;
        }
 
        case WM_COMMAND:
        {
            if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_SKIPUPGRADE)
            {
                /* Skip the upgrade and do the usual new-installation workflow */
                pSetupData->CurrentInstallation = NULL;
                pSetupData->RepairUpdateFlag = FALSE;
                PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_DEVICEPAGE);
                return TRUE;
            }
            break;
        }
 
        case WM_NOTIFY:
        {
            LPNMHDR lpnm = (LPNMHDR)lParam;
 
            if (lpnm->idFrom == IDC_NTOSLIST && lpnm->code == NM_DBLCLK)
            {
                /* Go to the next page if the user double-clicked on an installation */
                LPNMLISTVIEW pnmv = (LPNMLISTVIEW)lParam;
                if (pnmv->iItem != -1)
                    PropSheet_PressButton(GetParent(hwndDlg), PSBTN_NEXT);
                break;
            }
 
            if (lpnm->idFrom == IDC_NTOSLIST && lpnm->code == LVN_ITEMCHANGED)
            {
                LPNMLISTVIEW pnmv = (LPNMLISTVIEW)lParam;
 
                /* Check whether the item has been (de)selected */
                if (!(pnmv->uChanged & LVIF_STATE) ||
                    !((pnmv->uOldState ^ pnmv->uNewState) & LVIS_SELECTED))
                {
                    break;
                }
 
                /* Enable or disable the "Next" button when the user
                 * selects or deselects an installation to upgrade */
                if (pnmv->uNewState & LVIS_SELECTED)
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
                else
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
                break;
            }
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                {
                    /* Keep the "Next" button disabled. It will be enabled only
                     * when the user selects an installation to upgrade. */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
                    break;
                }
 
                case PSN_QUERYINITIALFOCUS:
                {
                    /* Reselect the currently selected item, so as to refresh the UI buttons */
                    INT Index;
                    hList = GetDlgItem(hwndDlg, IDC_NTOSLIST);
                    Index = ListView_GetSelectionMark(hList);
                    if (Index != LB_ERR)
                    {
                        /* Deselect first the item before reselecting it, so as to
                         * invalidate its cached state and have the LVN_ITEMCHANGED
                         * notification sent. */
                        //ListView_EnsureVisible(hList, Index, FALSE);
                        ListView_SetItemState(hList, Index, 0, LVIS_SELECTED);
                        ListView_SetItemState(hList, Index,
                                              LVIS_FOCUSED | LVIS_SELECTED,
                                              LVIS_FOCUSED | LVIS_SELECTED);
                    }
 
                    /* Focus on the installations list */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)hList);
                    return TRUE;
                }
 
                case PSN_QUERYCANCEL:
                {
                    if (DisplayMessage(GetParent(hwndDlg),
                                       MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
                                       MAKEINTRESOURCEW(IDS_ABORTSETUP2),
                                       MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
                    {
                        /* Go to the Abort page */
                        PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_ABORTPAGE);
                    }
 
                    /* Do not close the wizard too soon */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
                    return TRUE;
                }
 
                case PSN_WIZNEXT: /* Set the selected data */
                {
                    /*
                     * Go update only if we have available NT installations
                     * and we choose to do so.
                     */
                    if (!pSetupData->NtOsInstallsList ||
                        GetNumberOfListEntries(pSetupData->NtOsInstallsList) == 0)
                    {
                        pSetupData->CurrentInstallation = NULL;
                        pSetupData->RepairUpdateFlag = FALSE;
                        break;
                    }
 
                    hList = GetDlgItem(hwndDlg, IDC_NTOSLIST);
                    SetCurrentListEntry(pSetupData->NtOsInstallsList,
                                        GetSelectedListViewItem(hList));
 
                    /* Retrieve the current installation */
                    pSetupData->CurrentInstallation =
                        (PNTOS_INSTALLATION)GetListEntryData(GetCurrentListEntry(pSetupData->NtOsInstallsList));
                    InstallPartition = pSetupData->CurrentInstallation->Volume->PartEntry;
                    StringCchCopyW(pSetupData->USetupData.InstallationDirectory,
                                   _countof(pSetupData->USetupData.InstallationDirectory),
                                   pSetupData->CurrentInstallation->PathComponent);
 
                    /* We perform an upgrade */
                    pSetupData->RepairUpdateFlag = TRUE;
                    /* Jump to the Summary page during repair/upgrade */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_SUMMARYPAGE);
                    return TRUE;
                }
 
                default:
                    break;
            }
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

Variable Documentation

__pfnDliFailureHook2

PfnDliHook __pfnDliFailureHook2 = setupDelayHook

Definition at line 3502 of file reactos.c.

__pfnDliNotifyHook2

PfnDliHook __pfnDliNotifyHook2 = setupDelayHook

Custom delay-loading hooks for loading the Setup DLLs from a suitable path.

Definition at line 3501 of file reactos.c.

column_alignment

const INT column_alignment[MAX_LIST_COLUMNS] = {LVCFMT_LEFT, LVCFMT_LEFT, LVCFMT_LEFT}

static

Definition at line 826 of file reactos.c.

Referenced by UpgradeRepairDlgProc().

column_ids

const UINT column_ids[MAX_LIST_COLUMNS] = {IDS_LIST_COLUMN_FIRST, IDS_LIST_COLUMN_FIRST + 1, IDS_LIST_COLUMN_FIRST + 2}

static

Definition at line 824 of file reactos.c.

Referenced by UpgradeRepairDlgProc().

column_widths

const INT column_widths[MAX_LIST_COLUMNS] = {200, 150, 100}

static

Definition at line 825 of file reactos.c.

Referenced by UpgradeRepairDlgProc().

dwFlags

DWORD dwFlags

Definition at line 3625 of file reactos.c.

hWaitCursor

HCURSOR hWaitCursor

Definition at line 38 of file reactos.c.

Referenced by ProcessDlgProc(), and PrshtWndProc().

IncludeForUnattended

BOOL IncludeForUnattended

Definition at line 3624 of file reactos.c.

InstallPartition

PPARTENTRY InstallPartition = NULL

Definition at line 27 of file reactos.c.

Referenced by InitSystemPartition(), PrepareAndDoCopyThread(), SelectInstallPartition(), SummaryDlgProc(), TypeDlgProc(), and UpgradeRepairDlgProc().

pfnDlgProc

DLGPROC pfnDlgProc

Definition at line 3629 of file reactos.c.

Referenced by SH_CreatePropertySheetPage(), and SH_CreatePropertySheetPageEx().

ProcessHeap

HANDLE ProcessHeap

• Internal Headers *‍/

Definition at line 23 of file reactos.c.

Referenced by _tWinMain(), ConvertNtPathToWin32Path(), and FreeNtToWin32PathMappingList().

pszHeaderSubTitle

PCWSTR pszHeaderSubTitle

Definition at line 3628 of file reactos.c.

Referenced by free_prop_sheet_pages(), and prop_sheet_pages_AtoW().

pszHeaderTitle

PCWSTR pszHeaderTitle

Definition at line 3627 of file reactos.c.

Referenced by free_prop_sheet_pages(), and prop_sheet_pages_AtoW().

pszTemplate

PCWSTR pszTemplate

Definition at line 3626 of file reactos.c.

Referenced by free_prop_sheet_pages(), and prop_sheet_pages_AtoW().

SetupData

SETUPDATA SetupData

Definition at line 24 of file reactos.c.

Referenced by _tWinMain(), CreateTimeZoneList(), DateTimePageDlgProc(), DestroyTimeZoneList(), FileCopyCallback(), FinishDlgProc(), FormatDlgProcWorker(), FsVolCallback(), GetLargerTimeZoneEntry(), GetLocalSystemTime(), GetSelectedTimeZoneEntry(), GetTimeZoneEntryByIndex(), LocalePageDlgProc(), ProcessPageDlgProc(), PropSheetCallback(), RegistryStatus(), RetrieveTimeZone(), SetLocalTimeZone(), SetSystemLocalTime(), SetupOpenInfFileExW(), ShowErrorTip(), ShowTimeZoneList(), ThemePageDlgProc(), and WriteDateTimeSettings().

SystemPartition

PPARTENTRY SystemPartition = NULL

Definition at line 32 of file reactos.c.

Referenced by InitSystemPartition(), LoadAndBootWindows(), LoadAndBootWindowsCommon(), LoadReactOSSetup(), OpenBootStore(), PrepareAndDoCopyThread(), SmpTranslateSystemPartitionInformation(), and WinLdrInitializePhase1().

UiContext

UI_CONTEXT UiContext

Definition at line 37 of file reactos.c.

Referenced by DriveDlgProc(), FileCopyCallback(), FormatCallback(), FsVolCallback(), PrepareAndDoCopyThread(), and RegistryStatus().

const struct { ... } WizardPages[]

Referenced by _tWinMain().

wpOrgPrshtProc

WNDPROC wpOrgPrshtProc = NULL

Definition at line 3521 of file reactos.c.

Referenced by PropSheetCallback(), and PrshtWndProc().