#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	SetDlgItemFont(hDlg, nID, hFont, bRedraw) SetWindowFont(GetDlgItem((hDlg), (nID)), (hFont), (bRedraw))

#define	IDS_CLOSE 4160

#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

#define	InterlockedFlagsTestAndSet8(Target, Flags) !!(InterlockedOr8((PCHAR)(Target), (Flags)) & (Flags))

#define	InterlockedFlagsTestAndReset8(Target, Flags) !!(InterlockedAnd8((PCHAR)(Target), ~(Flags)) & (Flags))

#define	SETUP_ABORT_INSTALL 1

#define	SETUP_IS_CANCELLING 4

#define	SETUP_PAGE_SWITCHING 16

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)

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

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

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

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

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

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

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

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

Variables
UI_CONTEXT	UiContext

HANDLE	ProcessHeap

SETUPDATA	SetupData

PPARTENTRY	InstallPartition

PPARTENTRY	SystemPartition

Macro Definition Documentation

◆ EnableDlgItem

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

Definition at line 31 of file reactos.h.

◆ ID_APPLY_NOW

#define ID_APPLY_NOW 0x3021

Definition at line 45 of file reactos.h.

◆ ID_WIZBACK

#define ID_WIZBACK 0x3023

Definition at line 46 of file reactos.h.

◆ ID_WIZFINISH

#define ID_WIZFINISH 0x3025

Definition at line 48 of file reactos.h.

◆ ID_WIZNEXT

#define ID_WIZNEXT 0x3024

Definition at line 47 of file reactos.h.

◆ IDC_TAB_CONTROL

#define IDC_TAB_CONTROL 0x3020

Definition at line 44 of file reactos.h.

◆ IDS_CLOSE

#define IDS_CLOSE 4160

Definition at line 41 of file reactos.h.

◆ InterlockedFlagsTestAndReset8

#define InterlockedFlagsTestAndReset8	(	Target,
		Flags
	)	!!(InterlockedAnd8((PCHAR)(Target), ~(Flags)) & (Flags))

Definition at line 121 of file reactos.h.

◆ InterlockedFlagsTestAndSet8

#define InterlockedFlagsTestAndSet8	(	Target,
		Flags
	)	!!(InterlockedOr8((PCHAR)(Target), (Flags)) & (Flags))

Definition at line 118 of file reactos.h.

◆ NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 56 of file reactos.h.

◆ SetDlgItemFont

#define SetDlgItemFont	(	hDlg,
		nID,
		hFont,
		bRedraw
	)	SetWindowFont(GetDlgItem((hDlg), (nID)), (hFont), (bRedraw))

Definition at line 37 of file reactos.h.

◆ SETUP_ABORT_INSTALL

#define SETUP_ABORT_INSTALL 1

Definition at line 140 of file reactos.h.

◆ SETUP_IS_CANCELLING

#define SETUP_IS_CANCELLING 4

Definition at line 143 of file reactos.h.

◆ SETUP_PAGE_SWITCHING

#define SETUP_PAGE_SWITCHING 16

Definition at line 146 of file reactos.h.

◆ ShowDlgItem

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

Definition at line 34 of file reactos.h.

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 19 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 3013 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 599 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 264 of file reactos.c.

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

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

◆ DisplayMessage()

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

Definition at line 245 of file reactos.c.

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

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

◆ DisplayMessageV()

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

Definition at line 175 of file reactos.c.

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

Referenced by DisplayError(), and DisplayMessage().

◆ DriveDlgProc()

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

Definition at line 1684 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)((LPPROPSHEETPAGEW)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);
            break;
        }
 
        case WM_DESTROY:
        {
            hList = GetDlgItem(hwndDlg, IDC_PARTITION);
            ASSERT(UiContext.hPartList == hList);
            UiContext.hPartList = NULL;
            CleanupPartitionList(hList);
            return TRUE;
        }
 
        case WM_COMMAND:
        {
            if (HIWORD(wParam) == BN_CLICKED) switch (LOWORD(wParam))
            {
            case IDC_PARTMOREOPTS:
            {
                DialogBoxParamW(pSetupData->hInstance,
                                MAKEINTRESOURCEW(IDD_ADVINSTOPTS),
                                hwndDlg,
                                MoreOptDlgProc,
                                (LPARAM)pSetupData);
                return TRUE;
            }
 
            case IDC_INITDISK:
            {
                // TODO: Implement disk partitioning initialization
                return TRUE;
            }
 
            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:
            {
                PPARTITEM PartItem;
                PPARTENTRY PartEntry;
                INT_PTR ret;
                PARTCREATE_CTX PartCreateCtx = {0};
 
                hList = GetDlgItem(hwndDlg, IDC_PARTITION);
                PartItem = GetSelectedPartition(hList, NULL);
                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:
            {
                HTLITEM hItem;
                PPARTITEM PartItem;
                PPARTENTRY PartEntry;
                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_ICONWARNING | MB_YESNO | MB_DEFBUTTON2,
                                   MAKEINTRESOURCEW(IDS_WARN_DELETE_PARTITION_TITLE),
                                   MAKEINTRESOURCEW(uIDWarnMsg)) == IDYES)
                {
                    /* ... make it so! */
                    if (!DoDeletePartition(hList, pSetupData->PartitionList,
                                           &hItem, PartItem))
                    {
                        DisplayMessage(hwndDlg, MB_ICONERROR | MB_OK, NULL,
                                       L"Could not delete the selected partition.");
                    }
                }
                break;
            }
            }
            break;
        }
 
        case WM_NOTIFY:
        {
            LPNMHDR lpnm = (LPNMHDR)lParam;
 
            if (lpnm->idFrom == IDC_PARTITION) switch (lpnm->code)
            {
            case NM_RETURN:
            {
                /* If the currently selected item is a partition (and so, if
                 * the wizard "Next" button is enabled), pressing "Next" will
                 * attempt to select an install partition and go to the next
                 * page if successful. */
                HWND hWndParent = GetParent(hwndDlg);
                if (IsWindowEnabled(GetDlgItem(hWndParent, ID_WIZNEXT)))
                    PropSheet_PressButton(hWndParent, PSBTN_NEXT);
                break;
            }
 
            case TVN_KEYDOWN:
            {
                if (((LPTV_KEYDOWN_EX)lParam)->wVKey == VK_DELETE)
                {
                    /* Send the delete command only if IDC_PARTDELETE is
                     * enabled (i.e. the selected item IS a partition) */
                    if (IsWindowEnabled(GetDlgItem(hwndDlg, IDC_PARTDELETE)))
                        PostMessageW(hwndDlg, WM_COMMAND, MAKEWPARAM(IDC_PARTDELETE, BN_CLICKED), 0);
                }
                break;
            }
            }
 
            // On Vista+ we can use TVN_ITEMCHANGED instead, with NMTVITEMCHANGE* pointer
            if (lpnm->idFrom == IDC_PARTITION && lpnm->code == TVN_SELCHANGED)
            {
                LPNMTREEVIEW pnmv = (LPNMTREEVIEW)lParam;
 
                /* Check whether the item has been (de)selected */
#if 0 // When using NMTVITEMCHANGE
                if (!(pnmv->uChanged & TVIF_STATE) ||
                    !((pnmv->uStateOld ^ pnmv->uStateNew) & TVIS_SELECTED))
                { break; }
#endif
                if (!((pnmv->itemOld.mask | pnmv->itemNew.mask) & TVIF_STATE) ||
                    !((pnmv->itemOld.state ^ pnmv->itemNew.state) & TVIS_SELECTED))
                {
                    break;
                }
 
                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;
                        BOOL CanBePartitioned;
                        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);
 
                        /* Check whether the selected disk region is not partitioned, and
                         * can be partitioned according to the disk's partitioning scheme */
                        CanBePartitioned = (!PartEntry->IsPartitioned &&
                                            (PartitionCreateChecks(PartEntry, 0ULL, 0) == NOT_AN_ERROR));
 
                        if (!PartEntry->IsPartitioned)
                        {
                            /* Show the "Create" partition button, but enable it
                             * only if the selected disk region can be partitioned */
                            ShowDlgItem(hwndDlg, IDC_PARTCREATE, SW_SHOW);
                            EnableDlgItem(hwndDlg, IDC_PARTCREATE, CanBePartitioned);
 
                            /* 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 it only
                             * 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 it
                         * only 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) || CanBePartitioned)
                        {
                            // 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:
                {
                    /* Reselect the currently selected item, so as to refresh the UI buttons */
                    HTLITEM hItem;
                    hList = GetDlgItem(hwndDlg, IDC_PARTITION);
                    hItem = TreeList_GetSelection(hList);
                    if (hItem)
                    {
                        /* Don't use TreeList_SelectItem() directly. Instead,
                         * deselect first the item before reselecting it, so as to
                         * invalidate its cached state and have the TVN_SELCHANGED
                         * notification sent. */
                        TreeList_SetItemState(hList, hItem, 0, TVIS_SELECTED);
                        TreeList_SetItemState(hList, hItem, TVIS_SELECTED, TVIS_SELECTED);
                    }
 
                    /* Focus on the partition 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:
                {
                    /* Select the install partition and if success, go to the next page */
                    if (SelectInstallPartition(pSetupData, hwndDlg))
                        break;
                    /* Failed, stay on the page */
                    SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
                    return TRUE;
                }
 
                default:
                    break;
            }
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

◆ FindVolCreateInTreeByVolume()

PVOL_CREATE_INFO FindVolCreateInTreeByVolume	(	_In_ HWND	hTreeList,
		_In_ PVOLENTRY	Volume
	)

Definition at line 815 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().

◆ FormatAllocStringWV()

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

Definition at line 150 of file reactos.c.

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

Referenced by DisplayMessageV(), and SetWindowResPrintfVW().

◆ LoadAllocStringW()

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

Definition at line 115 of file reactos.c.

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

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

◆ SetWindowResPrintfVW()

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

Definition at line 303 of file reactos.c.

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

Referenced by RegistryStatus(), and SetWindowResPrintfW().

◆ SetWindowResPrintfW()

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

Definition at line 341 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 284 of file reactos.c.

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

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

Variable Documentation

◆ InstallPartition

PPARTENTRY InstallPartition

extern

Definition at line 28 of file reactos.c.

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

◆ ProcessHeap

HANDLE ProcessHeap

extern

Internal Headers *‍/

Definition at line 15 of file servman.c.

◆ SetupData

◆ SystemPartition

PPARTENTRY SystemPartition

extern

Definition at line 33 of file reactos.c.

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

◆ UiContext

UI_CONTEXT UiContext

extern

Definition at line 38 of file reactos.c.

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

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ EnableDlgItem

◆ ID_APPLY_NOW

◆ ID_WIZBACK

◆ ID_WIZFINISH

◆ ID_WIZNEXT

◆ IDC_TAB_CONTROL

◆ IDS_CLOSE

◆ InterlockedFlagsTestAndReset8

◆ InterlockedFlagsTestAndSet8

◆ NTOS_MODE_USER

◆ SetDlgItemFont

◆ SETUP_ABORT_INSTALL

◆ SETUP_IS_CANCELLING

◆ SETUP_PAGE_SWITCHING

◆ ShowDlgItem

◆ WIN32_NO_STATUS

Typedef Documentation

◆ NT_WIN32_PATH_MAPPING

◆ NT_WIN32_PATH_MAPPING_LIST

◆ PNT_WIN32_PATH_MAPPING

◆ PNT_WIN32_PATH_MAPPING_LIST

◆ PSETUPDATA

◆ PUI_CONTEXT

◆ PVOL_CREATE_INFO

◆ SETUPDATA

◆ UI_CONTEXT

◆ VOL_CREATE_INFO

Function Documentation

◆ ConvertNtPathToWin32Path()

◆ CreateListViewColumns()

◆ DisplayError()

◆ DisplayMessage()

◆ DisplayMessageV()

◆ DriveDlgProc()

◆ FindVolCreateInTreeByVolume()

◆ FormatAllocStringWV()

◆ LoadAllocStringW()

◆ SetWindowResPrintfVW()

◆ SetWindowResPrintfW()

◆ SetWindowResTextW()

Variable Documentation

◆ InstallPartition

◆ ProcessHeap

◆ SetupData

◆ SystemPartition

◆ UiContext