reactos.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS GUI first stage setup application
 * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
 * PURPOSE:     Main file
 * COPYRIGHT:   Copyright 2008-2010 Matthias Kupfer <mkupfer@reactos.org>
 *              Copyright 2008-2009 Dmitry Chapyshev <dmitry@reactos.org>
 *              Copyright 2018-2026 Hermès Bélusca-Maïto <hermes.belusca-maito@reactos.org>
 */
 
#include "reactos.h"
#include <winnls.h> // For GetUserDefaultLCID()
 
#define NTOS_MODE_USER
#include <ndk/obfuncs.h>
 
#include "resource.h"
 
#define NDEBUG
#include <debug.h>
 
/* GLOBALS ******************************************************************/
 
HANDLE ProcessHeap;
SETUPDATA SetupData;
 
/* The partition where to perform the installation */
PPARTENTRY InstallPartition = NULL;
// static PVOLENTRY InstallVolume = NULL;
#define InstallVolume (InstallPartition->Volume)
 
/* The system partition we will actually use */
PPARTENTRY SystemPartition = NULL;
// static PVOLENTRY SystemVolume = NULL;
#define SystemVolume (SystemPartition->Volume)
 
/* UI elements */
UI_CONTEXT UiContext;
HCURSOR hWaitCursor;
 
 
/* FUNCTIONS ****************************************************************/
 
// See also setupapi!pSetupCenterWindowRelativeToParent()
static VOID
CenterWindow(HWND hWnd)
{
    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);
}
 
static HFONT
CreateBoldFont(
    _In_opt_ HFONT hOrigFont,
    _In_opt_ INT PointSize)
{
    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);
}
 
static inline HFONT
CreateTitleFont(
    _In_opt_ HFONT hOrigFont)
{
    /* Title font is 12pt bold */
    return CreateBoldFont(hOrigFont, 12);
}
 
size_t
LoadAllocStringW(
    _In_opt_ HINSTANCE hInstance,
    _In_ UINT uID,
    _In_opt_ _Outptr_ PWSTR* pString,
    _In_opt_ size_t cchBufferLen /*,
    _In_opt_ PCWSTR pDefaultString*/)
{
    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;
}
 
size_t
FormatAllocStringWV(
    _In_opt_ _Outptr_ PWSTR* pString,
    _In_opt_ size_t cchBufferLen,
    _In_ PCWSTR pszFormat,
    _In_ va_list args)
{
    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;
}
 
INT
DisplayMessageV(
    _In_opt_ HWND hWnd,
    _In_ UINT uType,
    _In_opt_ PCWSTR pszTitle,
    _In_opt_ PCWSTR pszFormatMessage,
    _In_ va_list args)
{
    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;
}
 
INT
__cdecl
DisplayMessage(
    _In_opt_ HWND hWnd,
    _In_ UINT uType,
    _In_opt_ PCWSTR pszTitle,
    _In_opt_ PCWSTR pszFormatMessage,
    ...)
{
    INT iRes;
    va_list args;
 
    va_start(args, pszFormatMessage);
    iRes = DisplayMessageV(hWnd, uType, pszTitle, pszFormatMessage, args);
    va_end(args);
 
    return iRes;
}
 
INT
__cdecl
DisplayError(
    _In_opt_ HWND hWnd,
    _In_ UINT uIDTitle,
    _In_ UINT uIDMessage,
    ...)
{
    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;
}
 
VOID
SetWindowResTextW(
    _In_ HWND hWnd,
    _In_opt_ HINSTANCE hInstance,
    _In_ UINT uID /*,
    _In_opt_ PCWSTR pDefaultString*/)
{
    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);
}
 
VOID
SetWindowResPrintfVW(
    _In_ HWND hWnd,
    _In_opt_ HINSTANCE hInstance,
    _In_ UINT uID,
    _In_ va_list args)
{
    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);
}
 
VOID
__cdecl
SetWindowResPrintfW(
    _In_ HWND hWnd,
    _In_opt_ HINSTANCE hInstance,
    _In_ UINT uID,
    ...)
{
    va_list args;
 
    va_start(args, uID);
    SetWindowResPrintfVW(hWnd, hInstance, uID, args);
    va_end(args);
}
 
static INT_PTR CALLBACK
StartDlgProc(
    IN HWND hwndDlg,
    IN UINT uMsg,
    IN WPARAM wParam,
    IN LPARAM lParam)
{
    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;
}
 
static INT_PTR CALLBACK
TypeDlgProc(
    IN HWND hwndDlg,
    IN UINT uMsg,
    IN WPARAM wParam,
    IN LPARAM lParam)
{
    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;
}
 
 
 
BOOL
CreateListViewColumns(
    IN HINSTANCE hInstance,
    IN HWND hWndListView,
    IN const UINT* pIDs,
    IN const INT* pColsWidth,
    IN const INT* pColsAlign,
    IN UINT nNumOfColumns)
{
    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;
}
 
typedef VOID
(NTAPI *PGET_ENTRY_DESCRIPTION)(
    IN PGENERIC_LIST_ENTRY Entry,
    OUT PWSTR Buffer,
    IN SIZE_T cchBufferSize);
 
VOID
InitGenericComboList(
    IN HWND hWndList,
    IN PGENERIC_LIST List,
    IN PGET_ENTRY_DESCRIPTION GetEntryDescriptionProc)
{
    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);
}
 
PVOID
GetSelectedComboListItem(
    IN HWND hWndList)
{
    INT Index;
 
    Index = ComboBox_GetCurSel(hWndList);
    if (Index == CB_ERR)
        return NULL;
 
    return (PVOID)ComboBox_GetItemData(hWndList, Index);
}
 
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);
 
VOID
InitGenericListView(
    IN HWND hWndList,
    IN PGENERIC_LIST List,
    IN PADD_ENTRY_ITEM AddEntryItemProc)
{
    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);
}
 
PVOID
GetSelectedListViewItem(
    IN HWND hWndList)
{
    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;
}
 
 
static VOID
NTAPI
GetSettingDescription(
    IN PGENERIC_LIST_ENTRY Entry,
    OUT PWSTR Buffer,
    IN SIZE_T cchBufferSize)
{
    StringCchCopyW(Buffer, cchBufferSize,
                   ((PGENENTRY)GetListEntryData(Entry))->Value);
}
 
static VOID
NTAPI
AddNTOSInstallationItem(
    IN HWND hWndList,
    IN LVITEM* plvItem,
    IN PGENERIC_LIST_ENTRY Entry,
    IN OUT PWSTR Buffer, // SystemRootPath
    IN SIZE_T cchBufferSize)
{
    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);
}
 
 
#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)
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};
 
static INT_PTR CALLBACK
UpgradeRepairDlgProc(
    IN HWND hwndDlg,
    IN UINT uMsg,
    IN WPARAM wParam,
    IN LPARAM lParam)
{
    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;
}
 
static INT_PTR CALLBACK
DeviceDlgProc(
    IN HWND hwndDlg,
    IN UINT uMsg,
    IN WPARAM wParam,
    IN LPARAM lParam)
{
    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;
}
 
static INT_PTR CALLBACK
SummaryDlgProc(
    IN HWND hwndDlg,
    IN UINT uMsg,
    IN WPARAM wParam,
    IN LPARAM lParam)
{
    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;
}
 
 
typedef struct _FSVOL_CONTEXT
{
    PSETUPDATA pSetupData;
    // PAGE_NUMBER NextPageOnAbort;
} FSVOL_CONTEXT, *PFSVOL_CONTEXT;
 
static
BOOLEAN
NTAPI
FormatCallback(
    _In_ CALLBACKCOMMAND Command,
    _In_ ULONG Modifier,
    _In_ PVOID Argument)
{
    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;
}
 
static
BOOLEAN
NTAPI
ChkdskCallback(
    _In_ CALLBACKCOMMAND Command,
    _In_ ULONG Modifier,
    _In_ PVOID Argument)
{
    switch (Command)
    {
        default:
            DPRINT("Unknown callback %lu\n", (ULONG)Command);
            break;
    }
 
    return TRUE;
}
 
// PFSVOL_CALLBACK
static FSVOL_OP
CALLBACK
FsVolCallback(
    _In_opt_ PVOID Context,
    _In_ FSVOLNOTIFY FormatStatus,
    _In_ ULONG_PTR Param1,
    _In_ ULONG_PTR Param2)
{
    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;
}
 
 
 
typedef struct _COPYCONTEXT
{
    PSETUPDATA pSetupData;
    ULONG TotalOperations;
    ULONG CompletedOperations;
} COPYCONTEXT, *PCOPYCONTEXT;
 
static UINT
CALLBACK
FileCopyCallback(PVOID Context,
                 UINT Notification,
                 UINT_PTR Param1,
                 UINT_PTR Param2)
{
    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;
}
 
static VOID
__cdecl
RegistryStatus(IN REGISTRY_STATUS RegStatus, ...)
{
    /* 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);
}
 
VOID
PropSheet_SetCloseCancel(
    _In_ HWND hWndWiz,
    _In_ BOOL Enable)
{
    EnableDlgItem(hWndWiz, IDCANCEL, Enable);
    EnableMenuItem(GetSystemMenu(hWndWiz, FALSE),
                   SC_CLOSE,
                   MF_BYCOMMAND | (Enable ? MF_ENABLED : MF_GRAYED));
}
 
#define PM_INSTALL_START    (WM_APP + 1)
#define PM_INSTALL_DONE     (WM_APP + 2)
 
static DWORD
WINAPI
PrepareAndDoCopyThread(
    IN LPVOID Param)
{
    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;
}
 
// TODO: Determine later which method is the best.
//#define TERMINATE_USE_PRESSBUTTON
 
static INT_PTR CALLBACK
ProcessDlgProc(
    IN HWND hwndDlg,
    IN UINT uMsg,
    IN WPARAM wParam,
    IN LPARAM lParam)
{
    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;
}
 
 
static BOOL
IsShellActive(VOID)
{
/* 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));
}
 
typedef struct _CLOSABLE_WND_INFO
{
    HWND hWndExclude; 
    BOOL Found;       
} CLOSABLE_WND_INFO, *PCLOSABLE_WND_INFO;
static BOOL
CALLBACK
FindUserClosableWindowProc(
    _In_ HWND hWnd,
    _In_ LPARAM lParam)
{
    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;
}
static BOOL
AreThereInteractiveWindows(
    _In_opt_ HWND hWndExclude)
{
    /* 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;
    }
}
 
static INT_PTR CALLBACK
FinishDlgProc(
    IN HWND hwndDlg,
    IN UINT uMsg,
    IN WPARAM wParam,
    IN LPARAM lParam)
{
    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;
}
 
BOOL LoadSetupData(
    IN OUT PSETUPDATA pSetupData)
{
    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;
}
 
VOID
InitNtToWin32PathMappingList(
    IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList)
{
    InitializeListHead(&MappingList->List);
    MappingList->MappingsCount = 0;
}
 
VOID
FreeNtToWin32PathMappingList(
    IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList)
{
    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;
}
 
/*
 * Attempts to convert a pure NT file path into a corresponding Win32 path.
 * Adapted from GetInstallSourceWin32() in dll/win32/syssetup/wizard.c
 */
BOOL
ConvertNtPathToWin32Path(
    IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList,
    OUT PWSTR pwszPath,
    IN DWORD cchPathMax,
    IN PCWSTR pwszNTPath)
{
    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;
}
 
/* Used to enable and disable the shutdown privilege */
/* static */ BOOL
EnablePrivilege(
    IN LPCWSTR lpszPrivilegeName,
    IN BOOL bEnablePrivilege)
{
    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;
}
 
/* Copied from HotkeyThread() in dll/win32/syssetup/install.c */
static DWORD CALLBACK
HotkeyThread(LPVOID Parameter)
{
    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;
}
 
 
static PCWSTR
GetLocalSetupDllPath(VOID)
{
    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;
}
 
#ifndef DECLARE_UNICODE_STRING_SIZE
#define DECLARE_UNICODE_STRING_SIZE(_var, _size) \
  WCHAR _var ## _buffer[_size]; \
  UNICODE_STRING _var = { 0, (_size) * sizeof(WCHAR) , _var ## _buffer }
#endif
#include <ndk/exfuncs.h> // For NtRaiseHardError()
#define DELAYIMP_INSECURE_WRITABLE_HOOKS
#include <delayimp.h>
 
static FARPROC
WINAPI setupDelayHook(unsigned dliNotify, PDelayLoadInfo pdli)
{
    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;
}
 
// NOTE: MSVC 2015 Update 3 makes this a const variable.
// #if (_MSC_VER > 1900) || (_MSC_VER == 1900 && _MSC_FULL_VER >= 190024210) ...
/*ExternC*/ PfnDliHook __pfnDliNotifyHook2  = setupDelayHook;
/*ExternC*/ PfnDliHook __pfnDliFailureHook2 = setupDelayHook;
 
 
#include <pshpack1.h>
typedef struct DLGTEMPLATEEX
{
    WORD dlgVer;
    WORD signature;
    DWORD helpID;
    DWORD exStyle;
    DWORD style;
    WORD cDlgItems;
    short x;
    short y;
    short cx;
    short cy;
} DLGTEMPLATEEX, *LPDLGTEMPLATEEX;
#include <poppack.h>
 
WNDPROC wpOrgPrshtProc = NULL;
 
/* Message handler for property sheet dialog */
static LRESULT
CALLBACK
PrshtWndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    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);
}
 
static int
CALLBACK
PropSheetCallback(
    _In_ HWND hDlg,
    _In_ UINT message,
    _In_ LPARAM lParam)
{
    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;
}
 
static const struct
{
    BOOL IncludeForUnattended;
    DWORD dwFlags;
    PCWSTR pszTemplate;
    PCWSTR pszHeaderTitle;
    PCWSTR pszHeaderSubTitle;
    DLGPROC pfnDlgProc;
} WizardPages[] =
{
    /*
     * These pages are useful only in the interactive installation scenario.
     * In ReactOS unattended setup, we directly perform a new installation,
     * possibly erasing any old one, but no upgrades.
     * NOTE: This may be subject to changes in the future.
     */
 
    /* Start page */
    {FALSE, PSP_HIDEHEADER,
     MAKEINTRESOURCEW(IDD_STARTPAGE), NULL, NULL, StartDlgProc},
 
    /* Install type selection page */
    {FALSE, PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE,
     MAKEINTRESOURCEW(IDD_TYPEPAGE),
     MAKEINTRESOURCEW(IDS_TYPETITLE), MAKEINTRESOURCEW(IDS_TYPESUBTITLE),
     TypeDlgProc},
 
    /* Upgrade/Repair selection page */
    {FALSE, PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE,
     MAKEINTRESOURCEW(IDD_UPDATEREPAIRPAGE),
     MAKEINTRESOURCEW(IDS_UPDATETITLE), MAKEINTRESOURCEW(IDS_UPDATESUBTITLE),
     UpgradeRepairDlgProc},
 
    /*
     * These pages are common to both interactive and unattended setup scenarios.
     */
 
    /* Device Settings page */
    {TRUE, PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE,
     MAKEINTRESOURCEW(IDD_DEVICEPAGE),
     MAKEINTRESOURCEW(IDS_DEVICETITLE), MAKEINTRESOURCEW(IDS_DEVICESUBTITLE),
     DeviceDlgProc},
 
    /* Install device settings page / boot method / install directory */
    {TRUE, PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE,
     MAKEINTRESOURCEW(IDD_DRIVEPAGE),
     MAKEINTRESOURCEW(IDS_DRIVETITLE), MAKEINTRESOURCEW(IDS_DRIVESUBTITLE),
     DriveDlgProc},
 
    /* Summary page */
    {TRUE, PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE,
     MAKEINTRESOURCEW(IDD_SUMMARYPAGE),
     MAKEINTRESOURCEW(IDS_SUMMARYTITLE), MAKEINTRESOURCEW(IDS_SUMMARYSUBTITLE),
     SummaryDlgProc},
 
    /* Installation Progress page */
    {TRUE, PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE,
     MAKEINTRESOURCEW(IDD_PROCESSPAGE),
     MAKEINTRESOURCEW(IDS_PROCESSTITLE), MAKEINTRESOURCEW(IDS_PROCESSSUBTITLE),
     ProcessDlgProc},
 
    /* Finish page */
    {TRUE, PSP_HIDEHEADER,
     MAKEINTRESOURCEW(IDD_FINISHPAGE), NULL, NULL,
     FinishDlgProc},
 
    /* Abort page */
    {TRUE, PSP_HIDEHEADER,
     MAKEINTRESOURCEW(IDD_ABORTPAGE), NULL, NULL,
     FinishDlgProc}, // Same dialog procedure as the Finish page.
};
 
static HANDLE
CheckForOtherInstance(
    _In_ HINSTANCE hInstance)
{
#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;
}
 
int WINAPI
_tWinMain(HINSTANCE hInst,
          HINSTANCE hPrevInstance,
          LPTSTR lpszCmdLine,
          int nCmdShow)
{
    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;
}
 
/* EOF */