reactos.h File Reference

#include <stdlib.h>
#include <stdarg.h>
#include <tchar.h>
#include <windef.h>
#include <winbase.h>
#include <winreg.h>
#include <wingdi.h>
#include <winuser.h>
#include <strsafe.h>
#include <commctrl.h>
#include <windowsx.h>
#include "treelist.h"
#include <setupapi.h>
#include <devguid.h>
#include <ndk/cmtypes.h>
#include <ndk/iofuncs.h>
#include <ndk/rtlfuncs.h>
#include <../lib/setuplib.h>

Include dependency graph for reactos.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_UI_CONTEXT
struct	_NT_WIN32_PATH_MAPPING
struct	_NT_WIN32_PATH_MAPPING_LIST
struct	_SETUPDATA
struct	_VOL_CREATE_INFO
	Data structure stored when a partition/volume needs to be formatted. More...

Macros
#define	WIN32_NO_STATUS
#define	EnableDlgItem(hDlg, nID, bEnable)    EnableWindow(GetDlgItem((hDlg), (nID)), (bEnable))
#define	ShowDlgItem(hDlg, nID, nCmdShow)    ShowWindow(GetDlgItem((hDlg), (nID)), (nCmdShow))
#define	IDC_TAB_CONTROL   0x3020
#define	ID_APPLY_NOW   0x3021
#define	ID_WIZBACK   0x3023
#define	ID_WIZNEXT   0x3024
#define	ID_WIZFINISH   0x3025
#define	NTOS_MODE_USER

Typedefs
typedef struct _UI_CONTEXT	UI_CONTEXT
typedef struct _UI_CONTEXT *	PUI_CONTEXT
typedef struct _NT_WIN32_PATH_MAPPING	NT_WIN32_PATH_MAPPING
typedef struct _NT_WIN32_PATH_MAPPING *	PNT_WIN32_PATH_MAPPING
typedef struct _NT_WIN32_PATH_MAPPING_LIST	NT_WIN32_PATH_MAPPING_LIST
typedef struct _NT_WIN32_PATH_MAPPING_LIST *	PNT_WIN32_PATH_MAPPING_LIST
typedef struct _SETUPDATA	SETUPDATA
typedef struct _SETUPDATA *	PSETUPDATA
typedef struct _VOL_CREATE_INFO	VOL_CREATE_INFO
	Data structure stored when a partition/volume needs to be formatted.
typedef struct _VOL_CREATE_INFO *	PVOL_CREATE_INFO

Functions
PVOL_CREATE_INFO	FindVolCreateInTreeByVolume (_In_ HWND hTreeList, _In_ PVOLENTRY Volume)
BOOL	ConvertNtPathToWin32Path (IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList, OUT PWSTR pwszPath, IN DWORD cchPathMax, IN PCWSTR pwszNTPath)
INT_PTR CALLBACK	DriveDlgProc (_In_ HWND hwndDlg, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam)
BOOL	CreateListViewColumns (IN HINSTANCE hInstance, IN HWND hWndListView, IN const UINT *pIDs, IN const INT *pColsWidth, IN const INT *pColsAlign, IN UINT nNumOfColumns)
INT	DisplayMessageV (_In_opt_ HWND hWnd, _In_ UINT uType, _In_opt_ PCWSTR pszTitle, _In_opt_ PCWSTR pszFormatMessage, _In_ va_list args)
INT __cdecl	DisplayMessage (_In_opt_ HWND hWnd, _In_ UINT uType, _In_opt_ PCWSTR pszTitle, _In_opt_ PCWSTR pszFormatMessage,...)
INT __cdecl	DisplayError (_In_opt_ HWND hWnd, _In_ UINT uIDTitle, _In_ UINT uIDMessage,...)
VOID	SetWindowResTextW (_In_ HWND hWnd, _In_opt_ HINSTANCE hInstance, _In_ UINT uID)
VOID	SetWindowResPrintfVW (_In_ HWND hWnd, _In_opt_ HINSTANCE hInstance, _In_ UINT uID, _In_ va_list args)
VOID __cdecl	SetWindowResPrintfW (_In_ HWND hWnd, _In_opt_ HINSTANCE hInstance, _In_ UINT uID,...)

Variables
UI_CONTEXT	UiContext
HANDLE	ProcessHeap
BOOLEAN	IsUnattendedSetup
SETUPDATA	SetupData
PPARTENTRY	InstallPartition
PPARTENTRY	SystemPartition

Macro Definition Documentation

EnableDlgItem

#define EnableDlgItem	(		hDlg,
			nID,
			bEnable
	)		EnableWindow(GetDlgItem((hDlg), (nID)), (bEnable))

Definition at line 48 of file reactos.h.

ID_APPLY_NOW

#define ID_APPLY_NOW   0x3021

Definition at line 57 of file reactos.h.

ID_WIZBACK

#define ID_WIZBACK   0x3023

Definition at line 58 of file reactos.h.

ID_WIZFINISH

#define ID_WIZFINISH   0x3025

Definition at line 60 of file reactos.h.

ID_WIZNEXT

#define ID_WIZNEXT   0x3024

Definition at line 59 of file reactos.h.

IDC_TAB_CONTROL

#define IDC_TAB_CONTROL   0x3020

Definition at line 56 of file reactos.h.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 68 of file reactos.h.

ShowDlgItem

#define ShowDlgItem	(		hDlg,
			nID,
			nCmdShow
	)		ShowWindow(GetDlgItem((hDlg), (nID)), (nCmdShow))

Definition at line 51 of file reactos.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 36 of file reactos.h.

Typedef Documentation

NT_WIN32_PATH_MAPPING

typedef struct _NT_WIN32_PATH_MAPPING NT_WIN32_PATH_MAPPING

NT_WIN32_PATH_MAPPING_LIST

typedef struct _NT_WIN32_PATH_MAPPING_LIST NT_WIN32_PATH_MAPPING_LIST

PNT_WIN32_PATH_MAPPING

typedef struct _NT_WIN32_PATH_MAPPING * PNT_WIN32_PATH_MAPPING

PNT_WIN32_PATH_MAPPING_LIST

typedef struct _NT_WIN32_PATH_MAPPING_LIST * PNT_WIN32_PATH_MAPPING_LIST

PSETUPDATA

typedef struct _SETUPDATA * PSETUPDATA

PUI_CONTEXT

typedef struct _UI_CONTEXT * PUI_CONTEXT

PVOL_CREATE_INFO

typedef struct _VOL_CREATE_INFO * PVOL_CREATE_INFO

SETUPDATA

typedef struct _SETUPDATA SETUPDATA

UI_CONTEXT

typedef struct _UI_CONTEXT UI_CONTEXT

VOL_CREATE_INFO

typedef struct _VOL_CREATE_INFO VOL_CREATE_INFO

Data structure stored when a partition/volume needs to be formatted.

Function Documentation

ConvertNtPathToWin32Path()

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

Definition at line 2469 of file reactos.c.

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

Referenced by SetupOpenInfFileExW().

CreateListViewColumns()

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

Definition at line 479 of file reactos.c.

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

Referenced by UpgradeRepairDlgProc().

DisplayError()

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

Definition at line 230 of file reactos.c.

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

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

DisplayMessage()

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

Definition at line 211 of file reactos.c.

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

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

DisplayMessageV()

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

Definition at line 109 of file reactos.c.

{
    INT iRes;
    HINSTANCE hInstance = NULL;
    MSGBOXPARAMSW mb = {0};
    LPWSTR Format;
    size_t MsgLen;
    WCHAR  StaticBuffer[256];
    LPWSTR 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)) do
    {
        // LoadAllocStringW()
        PCWSTR pStr;
 
        /* Try to load the string from the resource */
        MsgLen = LoadStringW(hInstance, PtrToUlong(pszFormatMessage), (LPWSTR)&pStr, 0);
        if (MsgLen == 0)
        {
            /* No resource string was found, return NULL */
            Format = NULL;
            break;
        }
 
        /* Allocate a new buffer, adding a NULL-terminator */
        Format = HeapAlloc(GetProcessHeap(), 0, (MsgLen + 1) * sizeof(WCHAR));
        if (!Format)
        {
            MsgLen = 0;
            break;
        }
 
        /* Copy the string, NULL-terminated */
        StringCchCopyNW(Format, MsgLen + 1, pStr, MsgLen);
    } while (0);
    else
    {
        Format = (LPWSTR)pszFormatMessage;
    }
 
    if (Format)
    {
        /*
         * Retrieve the message length. If it is too long, allocate
         * an auxiliary buffer; otherwise use the static buffer.
         * The string is built to be NULL-terminated.
         */
        MsgLen = _vscwprintf(Format, args);
        if (MsgLen >= _countof(StaticBuffer))
        {
            Buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (MsgLen + 1) * sizeof(WCHAR));
            if (!Buffer)
            {
                /* Allocation failed, use the original format string verbatim */
                Buffer = Format;
            }
        }
        if (Buffer != Format)
        {
            /* Do the printf as we use the caller's format string */
            StringCchVPrintfW(Buffer, MsgLen + 1, Format, args);
        }
    }
    else
    {
        Format = (LPWSTR)pszFormatMessage;
        Buffer = Format;
    }
 
    /* Display the message */
    mb.cbSize = sizeof(mb);
    mb.hwndOwner = hWnd;
    mb.hInstance = hInstance;
    mb.lpszText = Buffer;
    mb.lpszCaption = pszTitle;
    mb.dwStyle = uType;
    mb.dwLanguageId = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
    iRes = MessageBoxIndirectW(&mb);
 
    /* Free the buffers if needed */
    if ((Buffer != StaticBuffer) && (Buffer != Format))
        HeapFree(GetProcessHeap(), 0, Buffer);
 
    if (Format && (Format != pszFormatMessage))
        HeapFree(GetProcessHeap(), 0, Format);
 
    return iRes;
}

Referenced by DisplayError(), and DisplayMessage().

DriveDlgProc()

INT_PTR CALLBACK DriveDlgProc	(	_In_ HWND	hwndDlg,
		_In_ UINT	uMsg,
		_In_ WPARAM	wParam,
		_In_ LPARAM	lParam
	)

Definition at line 1634 of file drivepage.c.

{
    PSETUPDATA pSetupData;
    HWND hList;
 
    /* Retrieve pointer to the global setup data */
    pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Save pointer to the global setup data */
            pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
            SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (LONG_PTR)pSetupData);
 
            /* Initially hide and disable all partitioning buttons */
            ShowDlgItem(hwndDlg, IDC_INITDISK, SW_HIDE);
            EnableDlgItem(hwndDlg, IDC_INITDISK, FALSE);
            ShowDlgItem(hwndDlg, IDC_PARTCREATE, SW_HIDE);
            EnableDlgItem(hwndDlg, IDC_PARTCREATE, FALSE);
            ShowDlgItem(hwndDlg, IDC_PARTFORMAT, SW_HIDE);
            EnableDlgItem(hwndDlg, IDC_PARTFORMAT, FALSE);
            ShowDlgItem(hwndDlg, IDC_PARTDELETE, SW_HIDE);
            EnableDlgItem(hwndDlg, IDC_PARTDELETE, FALSE);
 
            /* Initialize the partitions list */
            hList = GetDlgItem(hwndDlg, IDC_PARTITION);
            UiContext.hPartList = hList;
            InitPartitionList(pSetupData->hInstance, hList);
            DrawPartitionList(hList, pSetupData->PartitionList);
 
            // HACK: Wine "kwality" code doesn't still implement
            // PSN_QUERYINITIALFOCUS so we "emulate" its call there...
            {
            PSHNOTIFY pshn = {{hwndDlg, GetWindowLong(hwndDlg, GWL_ID), PSN_QUERYINITIALFOCUS}, (LPARAM)hList};
            SendMessageW(hwndDlg, WM_NOTIFY, (WPARAM)pshn.hdr.idFrom, (LPARAM)&pshn);
            }
            break;
        }
 
        case WM_DESTROY:
        {
            hList = GetDlgItem(hwndDlg, IDC_PARTITION);
            ASSERT(UiContext.hPartList == hList);
            UiContext.hPartList = NULL;
            CleanupPartitionList(hList);
            return TRUE;
        }
 
        case WM_COMMAND:
        {
            switch (LOWORD(wParam))
            {
                case IDC_PARTMOREOPTS:
                {
                    DialogBoxParamW(pSetupData->hInstance,
                                    MAKEINTRESOURCEW(IDD_ADVINSTOPTS),
                                    hwndDlg,
                                    MoreOptDlgProc,
                                    (LPARAM)pSetupData);
                    break;
                }
 
                case IDC_INITDISK:
                {
                    // TODO: Implement disk partitioning initialization
                    break;
                }
 
                case IDC_PARTCREATE:
                {
                    HTLITEM hItem;
                    PPARTITEM PartItem;
                    PPARTENTRY PartEntry;
                    ULONGLONG PartSize;
                    ULONGLONG MaxPartSize;
                    ULONG MaxSizeMB;
                    INT_PTR ret;
                    PARTCREATE_CTX PartCreateCtx = {0};
 
                    hList = GetDlgItem(hwndDlg, IDC_PARTITION);
                    PartItem = GetSelectedPartition(hList, &hItem);
                    if (!PartItem)
                    {
                        /* If the button was clicked, an empty disk
                         * region should have been selected first */
                        ASSERT(FALSE);
                        break;
                    }
                    PartEntry = PartItem->PartEntry;
                    if (PartEntry->IsPartitioned)
                    {
                        /* Don't create a partition when one already exists */
                        ASSERT(FALSE);
                        break;
                    }
                    ASSERT(!PartEntry->Volume);
 
                    /* Get the partition info stored in the TreeList */
                    PartCreateCtx.PartItem = PartItem;
 
                    /* Retrieve the maximum size in MB (rounded up) the partition can have */
                    MaxPartSize = GetPartEntrySizeInBytes(PartEntry);
                    MaxSizeMB = (ULONG)RoundingDivide(MaxPartSize, MB);
                    PartCreateCtx.MaxSizeMB = MaxSizeMB;
 
                    /* Don't force formatting by default */
                    PartCreateCtx.ForceFormat = FALSE;
 
                    /* Show the partitioning dialog */
                    ret = DialogBoxParamW(pSetupData->hInstance,
                                          MAKEINTRESOURCEW(IDD_PARTITION),
                                          hwndDlg,
                                          PartitionDlgProc,
                                          (LPARAM)&PartCreateCtx);
                    if (ret != IDOK)
                        break;
 
                    /*
                     * If the input size, given in MB, specifies the maximum partition
                     * size, it may slightly under- or over-estimate the latter due to
                     * rounding error. In this case, use all of the unpartitioned space.
                     * Otherwise, directly convert the size to bytes.
                     */
                    PartSize = PartCreateCtx.PartSizeMB;
                    if (PartSize == MaxSizeMB)
                        PartSize = MaxPartSize;
                    else // if (PartSize < MaxSizeMB)
                        PartSize *= MB;
 
                    ASSERT(PartSize <= MaxPartSize);
 
                    if (!DoCreatePartition(hList, pSetupData->PartitionList,
                                           &hItem, &PartItem,
                                           PartSize,
                                           !PartCreateCtx.MBRExtPart
                                               ? 0 : PARTITION_EXTENDED))
                    {
                        DisplayError(GetParent(hwndDlg),
                                     IDS_ERROR_CREATE_PARTITION_TITLE,
                                     IDS_ERROR_CREATE_PARTITION);
                    }
 
                    break;
                }
 
                case IDC_PARTFORMAT:
                {
                    HTLITEM hItem;
                    PPARTITEM PartItem;
                    PPARTENTRY PartEntry;
                    INT_PTR ret;
                    PARTCREATE_CTX PartCreateCtx = {0};
 
                    hList = GetDlgItem(hwndDlg, IDC_PARTITION);
                    PartItem = GetSelectedPartition(hList, &hItem);
                    if (!PartItem)
                    {
                        /* If the button was clicked, an empty disk
                         * region should have been selected first */
                        ASSERT(FALSE);
                        break;
                    }
                    PartEntry = PartItem->PartEntry;
                    if (!PartEntry->Volume)
                    {
                        /* Don't format an unformattable partition */
                        ASSERT(FALSE);
                        break;
                    }
 
                    /* Show the formatting dialog */
                    PartCreateCtx.PartItem = PartItem;
                    ret = DialogBoxParamW(pSetupData->hInstance,
                                          MAKEINTRESOURCEW(IDD_FORMAT),
                                          hwndDlg,
                                          FormatDlgProc,
                                          (LPARAM)&PartCreateCtx);
                    DBG_UNREFERENCED_PARAMETER(ret);
                    break;
                }
 
                case IDC_PARTDELETE:
                {
                    PPARTITEM PartItem;
                    PPARTENTRY PartEntry;
                    HTLITEM hItem;
                    UINT uIDWarnMsg;
 
                    hList = GetDlgItem(hwndDlg, IDC_PARTITION);
                    PartItem = GetSelectedPartition(hList, &hItem);
                    if (!PartItem)
                    {
                        // If the button was clicked, a partition
                        // should have been selected first...
                        ASSERT(FALSE);
                        break;
                    }
                    PartEntry = PartItem->PartEntry;
                    if (!PartEntry->IsPartitioned)
                    {
                        /* Don't delete an unpartitioned disk region */
                        ASSERT(FALSE);
                        break;
                    }
 
                    /* Choose the correct warning message to display:
                     * MBR-extended (container) vs. standard partition */
                    if (PartEntry == PartEntry->DiskEntry->ExtendedPartition)
                        uIDWarnMsg = IDS_WARN_DELETE_MBR_EXTENDED_PARTITION;
                    else
                        uIDWarnMsg = IDS_WARN_DELETE_PARTITION;
 
                    /* If the user really wants to delete the partition... */
                    if (DisplayMessage(GetParent(hwndDlg),
                                       MB_YESNO | MB_DEFBUTTON2 | MB_ICONWARNING,
                                       MAKEINTRESOURCEW(IDS_WARN_DELETE_PARTITION_TITLE),
                                       MAKEINTRESOURCEW(uIDWarnMsg)) == IDYES)
                    {
                        /* ... make it so! */
                        if (!DoDeletePartition(hList, pSetupData->PartitionList,
                                               &hItem, PartItem))
                        {
                            // TODO: Show error if partition couldn't be deleted?
                        }
                    }
 
                    break;
                }
            }
            break;
        }
 
        case WM_NOTIFY:
        {
            LPNMHDR lpnm = (LPNMHDR)lParam;
 
            // On Vista+ we can use TVN_ITEMCHANGED instead, with NMTVITEMCHANGE* pointer
            if (lpnm->idFrom == IDC_PARTITION && lpnm->code == TVN_SELCHANGED)
            {
                LPNMTREEVIEW pnmv = (LPNMTREEVIEW)lParam;
 
                // if (!(pnmv->uChanged & TVIF_STATE)) /* The state has changed */
                if (!(pnmv->itemNew.mask & TVIF_STATE))
                    break;
 
                /* The item has been (de)selected */
                // if (pnmv->uNewState & TVIS_SELECTED)
                if (pnmv->itemNew.state & TVIS_SELECTED)
                {
                    HTLITEM hParentItem = TreeList_GetParent(lpnm->hwndFrom, pnmv->itemNew.hItem);
                    /* May or may not be a PPARTENTRY: this is a PPARTENTRY only when hParentItem != NULL */
 
                    if (!hParentItem)
                    {
                        /* Hard disk */
                        PDISKENTRY DiskEntry = (PDISKENTRY)pnmv->itemNew.lParam;
                        ASSERT(DiskEntry);
 
                        /* Show the "Initialize" disk button and hide and disable the others */
                        ShowDlgItem(hwndDlg, IDC_INITDISK, SW_SHOW);
 
#if 0 // FIXME: Init disk not implemented yet!
                        EnableDlgItem(hwndDlg, IDC_INITDISK,
                                      DiskEntry->DiskStyle == PARTITION_STYLE_RAW);
#else
                        EnableDlgItem(hwndDlg, IDC_INITDISK, FALSE);
#endif
 
                        ShowDlgItem(hwndDlg, IDC_PARTCREATE, SW_HIDE);
                        EnableDlgItem(hwndDlg, IDC_PARTCREATE, FALSE);
 
                        ShowDlgItem(hwndDlg, IDC_PARTFORMAT, SW_HIDE);
                        EnableDlgItem(hwndDlg, IDC_PARTFORMAT, FALSE);
 
                        ShowDlgItem(hwndDlg, IDC_PARTDELETE, SW_HIDE);
                        EnableDlgItem(hwndDlg, IDC_PARTDELETE, FALSE);
 
                        /* Disable the "Next" button */
                        goto DisableWizNext;
                    }
                    else
                    {
                        /* Partition or unpartitioned space */
                        PPARTITEM PartItem = (PPARTITEM)pnmv->itemNew.lParam;
                        PPARTENTRY PartEntry;
                        ASSERT(PartItem);
                        PartEntry = PartItem->PartEntry;
                        ASSERT(PartEntry);
 
                        /* Hide and disable the "Initialize" disk button */
                        ShowDlgItem(hwndDlg, IDC_INITDISK, SW_HIDE);
                        EnableDlgItem(hwndDlg, IDC_INITDISK, FALSE);
 
                        if (!PartEntry->IsPartitioned)
                        {
                            /* Show and enable the "Create" partition button */
                            ShowDlgItem(hwndDlg, IDC_PARTCREATE, SW_SHOW);
                            EnableDlgItem(hwndDlg, IDC_PARTCREATE, TRUE);
 
                            /* Hide and disable the "Format" button */
                            ShowDlgItem(hwndDlg, IDC_PARTFORMAT, SW_HIDE);
                            EnableDlgItem(hwndDlg, IDC_PARTFORMAT, FALSE);
                        }
                        else
                        {
                            /* Hide and disable the "Create" partition button */
                            ShowDlgItem(hwndDlg, IDC_PARTCREATE, SW_HIDE);
                            EnableDlgItem(hwndDlg, IDC_PARTCREATE, FALSE);
 
                            /* Show the "Format" button, but enable or disable it if a formattable volume is present */
                            ShowDlgItem(hwndDlg, IDC_PARTFORMAT, SW_SHOW);
                            EnableDlgItem(hwndDlg, IDC_PARTFORMAT, !!PartEntry->Volume);
                        }
 
                        /* Show the "Delete" partition button, but enable or disable it if the disk region is partitioned */
                        ShowDlgItem(hwndDlg, IDC_PARTDELETE, SW_SHOW);
                        EnableDlgItem(hwndDlg, IDC_PARTDELETE, PartEntry->IsPartitioned);
 
                        /*
                         * Enable the "Next" button if:
                         *
                         * 1. the selected disk region is partitioned:
                         *    it can either have a volume attached (and be either
                         *    formatted or ready to be formatted),
                         *    or it's not yet formatted (the installer will prompt
                         *    for formatting parameters).
                         *
                         * 2. Or, the selected disk region is not partitioned but
                         *    can be partitioned according to the disk's partitioning
                         *    scheme (the installer will auto-partition the region
                         *    and prompt for formatting parameters).
                         *
                         * In all other cases, the "Next" button is disabled.
                         */
 
                        // TODO: In the future: first test needs to be augmented with:
                        // (... && PartEntry->Volume->IsSimpleVolume)
                        if ((PartEntry->IsPartitioned && PartEntry->Volume) ||
                            (!PartEntry->IsPartitioned && (PartitionCreationChecks(PartEntry) == NOT_AN_ERROR)))
                        {
                            // ASSERT(PartEntry != PartEntry->DiskEntry->ExtendedPartition);
                            ASSERT(!IsContainerPartition(PartEntry->PartitionType));
                            PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
                        }
                        else
                        {
                            goto DisableWizNext;
                        }
                    }
                }
                else
                {
DisableWizNext:
                    /* Keep the "Next" button disabled. It will be enabled
                     * only when the user selects a valid partition. */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
                }
 
                break;
            }
 
            if (lpnm->idFrom == IDC_PARTITION && lpnm->code == TVN_DELETEITEM)
            {
                /* Deleting an item from the partition list */
                LPNMTREEVIEW pnmv = (LPNMTREEVIEW)lParam;
                DeleteTreeItem(lpnm->hwndFrom, (TLITEMW*)&pnmv->itemOld);
                break;
            }
 
            switch (lpnm->code)
            {
                case PSN_SETACTIVE:
                {
                    /* Keep the "Next" button disabled. It will be enabled
                     * only when the user selects a valid partition. */
                    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
                    break;
                }
 
                case PSN_QUERYINITIALFOCUS:
                {
                    /* Give the focus on and select the first item */
                    hList = GetDlgItem(hwndDlg, IDC_PARTITION);
                    // TreeList_SetFocusItem(hList, 1, 1);
                    TreeList_SelectItem(hList, 1);
                    SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)hList);
                    return TRUE;
                }
 
                case PSN_QUERYCANCEL:
                {
                    if (DisplayMessage(GetParent(hwndDlg),
                                       MB_YESNO | MB_ICONQUESTION,
                                       MAKEINTRESOURCEW(IDS_ABORTSETUP2),
                                       MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
                    {
                        /* Go to the Terminate page */
                        PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_RESTARTPAGE);
                    }
 
                    /* Do not close the wizard too soon */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
                    return TRUE;
                }
 
                case PSN_WIZNEXT: /* Set the selected data */
                {
                    HTLITEM hItem;
                    PPARTITEM PartItem;
                    PPARTENTRY PartEntry;
 
                    hList = GetDlgItem(hwndDlg, IDC_PARTITION);
                    PartItem = GetSelectedPartition(hList, &hItem);
                    if (!PartItem)
                    {
                        /* Fail and don't continue the installation */
                        SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
                        return TRUE;
                    }
                    PartEntry = PartItem->PartEntry;
                    ASSERT(PartEntry);
 
                    /*
                     * Check whether the user wants to install ReactOS on a disk that
                     * is not recognized by the computer's firmware and if so, display
                     * a warning since such disks may not be bootable.
                     */
                    if (PartEntry->DiskEntry->MediaType == FixedMedia &&
                        !PartEntry->DiskEntry->BiosFound)
                    {
                        INT nRet;
 
                        nRet = DisplayMessage(hwndDlg,
                                              MB_OKCANCEL | MB_ICONWARNING,
                                              L"Warning",
                                              L"The disk you have selected for installing ReactOS\n"
                                              L"is not visible by the firmware of your computer,\n"
                                              L"and so may not be bootable.\n"
                                              L"\nClick on OK to continue anyway."
                                              L"\nClick on CANCEL to go back to the partitions list.");
                        if (nRet != IDOK)
                        {
                            /* Fail and don't continue the installation */
                            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
                            return TRUE;
                        }
                    }
 
                    /* If this is an empty region, auto-create the partition if conditions are OK */
                    if (!PartEntry->IsPartitioned)
                    {
                        ULONG Error;
 
                        Error = PartitionCreationChecks(PartEntry);
                        if (Error != NOT_AN_ERROR)
                        {
                            // MUIDisplayError(Error, Ir, POPUP_WAIT_ANY_KEY);
                            DisplayMessage(hwndDlg, MB_OK | MB_ICONERROR, NULL,
                                           L"Could not create a partition on the selected disk region");
 
                            /* Fail and don't continue the installation */
                            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
                            return TRUE;
                        }
 
                        /* Automatically create the partition on the whole empty space;
                         * it will be formatted later with default parameters */
                        if (!DoCreatePartition(hList, pSetupData->PartitionList,
                                               &hItem, &PartItem,
                                               0ULL,
                                               0))
                        {
                            DisplayError(GetParent(hwndDlg),
                                         IDS_ERROR_CREATE_PARTITION_TITLE,
                                         IDS_ERROR_CREATE_PARTITION);
 
                            /* Fail and don't continue the installation */
                            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
                            return TRUE;
                        }
                        /* Update PartEntry */
                        PartEntry = PartItem->PartEntry;
                    }
 
                    ASSERT(PartEntry->IsPartitioned);
                    // ASSERT(PartEntry != PartEntry->DiskEntry->ExtendedPartition);
                    ASSERT(!IsContainerPartition(PartEntry->PartitionType));
                    ASSERT(PartEntry->Volume);
 
#if 0 // TODO: Implement!
                    if (!IsPartitionLargeEnough(PartEntry))
                    {
                        MUIDisplayError(ERROR_INSUFFICIENT_PARTITION_SIZE, Ir, POPUP_WAIT_ANY_KEY,
                                        USetupData.RequiredPartitionDiskSpace);
 
                        /* Fail and don't continue the installation */
                        SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
                        return TRUE;
                    }
#endif
 
                    /* Force formatting only if the partition doesn't have a volume (may or may not be formatted) */
                    if (PartEntry->Volume &&
                        ((PartEntry->Volume->FormatState == Formatted) ||
                         (PartItem->VolCreate && *PartItem->VolCreate->FileSystemName)))
                    {
                        /*NOTHING*/;
                    }
                    else /* Request formatting of the selected region if it's not already formatted */
                    {
                        INT_PTR ret;
                        PARTCREATE_CTX PartCreateCtx = {0};
 
                        /* Show the formatting dialog */
                        PartCreateCtx.PartItem = PartItem;
                        ret = DialogBoxParamW(pSetupData->hInstance,
                                              MAKEINTRESOURCEW(IDD_FORMAT),
                                              hwndDlg,
                                              FormatDlgProc,
                                              (LPARAM)&PartCreateCtx);
 
                        /* If the user refuses to format the partition,
                         * fail and don't continue the installation */
                        if (ret != IDOK)
                        {
                            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
                            return TRUE;
                        }
 
                        /* The partition will be formatted */
                    }
 
                    InstallPartition = PartEntry;
                    break;
                }
 
                default:
                    break;
            }
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by _tWinMain().

FindVolCreateInTreeByVolume()

PVOL_CREATE_INFO FindVolCreateInTreeByVolume	(	_In_ HWND	hTreeList,
		_In_ PVOLENTRY	Volume
	)

Definition at line 852 of file drivepage.c.

{
    HTLITEM hItem;
 
    /* Enumerate every cached data in the TreeList, and for each, check
     * whether its corresponding PPARTENTRY is the one we are looking for */
    // for (hItem = TVI_ROOT; hItem; hItem = TreeList_GetNextItem(...)) { }
    hItem = TVI_ROOT;
    while ((hItem = TreeList_GetNextItem(hTreeList, hItem, TVGN_NEXTITEM)))
    {
        PPARTITEM PartItem = GetItemPartition(hTreeList, hItem);
        if (!PartItem || !PartItem->VolCreate /* || !PartItem->Volume */)
            continue;
 
        if (PartItem->Volume == Volume)
        {
            /* Found it, return the associated volume-create structure */
            return PartItem->VolCreate;
        }
    }
 
    /* Nothing was found */
    return NULL;
}

Referenced by FsVolCallback().

SetWindowResPrintfVW()

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

Definition at line 261 of file reactos.c.

{
    WCHAR ResBuffer[256];
    WCHAR szText[256];
 
    LoadStringW(hInstance, uID, ResBuffer, _countof(ResBuffer));
    StringCchVPrintfW(szText, _countof(szText), ResBuffer, args);
    SetWindowTextW(hWnd, szText);
}

Referenced by RegistryStatus(), and SetWindowResPrintfW().

SetWindowResPrintfW()

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

Definition at line 277 of file reactos.c.

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

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

SetWindowResTextW()

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

Definition at line 250 of file reactos.c.

{
    WCHAR szText[256];
    LoadStringW(hInstance, uID, szText, _countof(szText));
    SetWindowTextW(hWnd, szText);
}

Referenced by PrepareAndDoCopyThread(), and SummaryDlgProc().

Variable Documentation

InstallPartition

PPARTENTRY InstallPartition

extern

Definition at line 45 of file reactos.c.

Referenced by DriveDlgProc(), InitSystemPartition(), PrepareAndDoCopyThread(), and SummaryDlgProc().

IsUnattendedSetup

BOOLEAN IsUnattendedSetup

extern

Definition at line 41 of file reactos.c.

ProcessHeap

HANDLE ProcessHeap

extern

• Internal Headers *‍/

Definition at line 15 of file servman.c.

SetupData

SETUPDATA SetupData

extern

Definition at line 42 of file reactos.c.

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

SystemPartition

PPARTENTRY SystemPartition

extern

Definition at line 50 of file reactos.c.

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

UiContext

UI_CONTEXT UiContext

extern

Definition at line 55 of file reactos.c.

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