ReactOS 0.4.17-dev-540-g8f54750
reactos.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS GUI first stage setup application
3 * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
4 * PURPOSE: Main file
5 * COPYRIGHT: Copyright 2008-2010 Matthias Kupfer <mkupfer@reactos.org>
6 * Copyright 2008-2009 Dmitry Chapyshev <dmitry@reactos.org>
7 * Copyright 2018-2026 Hermès Bélusca-Maïto <hermes.belusca-maito@reactos.org>
8 */
9
10#include "reactos.h"
11#include <winnls.h> // For GetUserDefaultLCID()
12
13#define NTOS_MODE_USER
14#include <ndk/obfuncs.h>
15
16#include "resource.h"
17
18#define NDEBUG
19#include <debug.h>
20
21/* GLOBALS ******************************************************************/
22
23HANDLE ProcessHeap;
24SETUPDATA SetupData;
25static BOOLEAN IsUnattendedSetup;
26
27/* The partition where to perform the installation */
28PPARTENTRY InstallPartition = NULL;
29// static PVOLENTRY InstallVolume = NULL;
30#define InstallVolume (InstallPartition->Volume)
31
32/* The system partition we will actually use */
33PPARTENTRY SystemPartition = NULL;
34// static PVOLENTRY SystemVolume = NULL;
35#define SystemVolume (SystemPartition->Volume)
36
37/* UI elements */
38UI_CONTEXT UiContext;
39HCURSOR hWaitCursor;
40
41
42/* FUNCTIONS ****************************************************************/
43
44// See also setupapi!pSetupCenterWindowRelativeToParent()
45static VOID
46CenterWindow(HWND hWnd)
47{
48 HWND hWndParent;
49 RECT rcParent;
50 RECT rcWindow;
51
52 hWndParent = GetParent(hWnd);
53 if (hWndParent == NULL)
54 hWndParent = GetDesktopWindow();
55
56 GetWindowRect(hWndParent, &rcParent);
57 GetWindowRect(hWnd, &rcWindow);
58
59 SetWindowPos(hWnd,
60 HWND_TOP,
61 ((rcParent.right - rcParent.left) - (rcWindow.right - rcWindow.left)) / 2,
62 ((rcParent.bottom - rcParent.top) - (rcWindow.bottom - rcWindow.top)) / 2,
63 0,
64 0,
65 SWP_NOSIZE);
66}
67
72static HFONT
73CreateBoldFont(
74 _In_opt_ HFONT hOrigFont,
75 _In_opt_ INT PointSize)
76{
77 LOGFONTW lf = {0};
78
79 if (hOrigFont)
80 {
81 GetObjectW(hOrigFont, sizeof(lf), &lf);
82 }
83 else
84 {
85 NONCLIENTMETRICSW ncm;
86 ncm.cbSize = sizeof(ncm);
87 SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
88 lf = ncm.lfMessageFont;
89 }
90
91 /* Make the font bold, keeping the other attributes */
92 lf.lfWeight = FW_BOLD;
93
94 /* Determine the font height (logical units) if necessary */
95 if (PointSize)
96 {
97 HDC hdc = GetDC(NULL);
98 lf.lfHeight = -MulDiv(PointSize, GetDeviceCaps(hdc, LOGPIXELSY), 72);
99 // lf.lfWidth = 0;
100 ReleaseDC(NULL, hdc);
101 }
102
103 return CreateFontIndirect(&lf);
104}
105
106static inline HFONT
107CreateTitleFont(
108 _In_opt_ HFONT hOrigFont)
109{
110 /* Title font is 12pt bold */
111 return CreateBoldFont(hOrigFont, 12);
112}
113
114size_t
115LoadAllocStringW(
116 _In_opt_ HINSTANCE hInstance,
117 _In_ UINT uID,
118 _In_opt_ _Outptr_ PWSTR* pString,
119 _In_opt_ size_t cchBufferLen /*,
120 _In_opt_ PCWSTR pDefaultString*/)
121{
122 PCWSTR pStr;
123 size_t Length;
124
125 /* Try to load the string from the resource */
126 Length = LoadStringW(hInstance, uID, (PWSTR)&pStr, 0);
127 if (Length == 0)
128 {
129 /* No resource string was found, return NULL */
130 *pString = NULL;
131 return 0;
132 }
133
134 /* If the caller gave a pointer to a buffer on input, verify whether it
135 * is large enough to contain the string. If not, allocate a new buffer. */
136 if (!*pString || (cchBufferLen < Length + 1))
137 {
138 /* Allocate a new buffer, adding a NUL-terminator */
139 *pString = HeapAlloc(GetProcessHeap(), 0, (Length + 1) * sizeof(WCHAR));
140 if (!*pString)
141 return 0;
142 }
143
144 /* Copy the string, NUL-terminated */
145 StringCchCopyNW(*pString, Length + 1, pStr, Length);
146 return Length;
147}
148
149size_t
150FormatAllocStringWV(
151 _In_opt_ _Outptr_ PWSTR* pString,
152 _In_opt_ size_t cchBufferLen,
153 _In_ PCWSTR pszFormat,
154 _In_ va_list args)
155{
156 size_t Length;
157
158 /* Retrieve the message length. If it is too long, allocate
159 * an auxiliary buffer; otherwise use the caller's buffer. */
160 Length = _vscwprintf(pszFormat, args); // Doesn't count the NUL-terminator.
161 if (!*pString || (Length >= cchBufferLen))
162 {
163 /* Allocate a new buffer, adding a NUL-terminator */
164 *pString = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (Length + 1) * sizeof(WCHAR));
165 if (!*pString)
166 return 0;
167 }
168
169 /* Do the printf */
170 StringCchVPrintfW(*pString, Length + 1, pszFormat, args);
171 return Length;
172}
173
174INT
175DisplayMessageV(
176 _In_opt_ HWND hWnd,
177 _In_ UINT uType,
178 _In_opt_ PCWSTR pszTitle,
179 _In_opt_ PCWSTR pszFormatMessage,
180 _In_ va_list args)
181{
182 INT iRes;
183 HINSTANCE hInstance = NULL;
184 MSGBOXPARAMSW mb = {0};
185 PWSTR Format;
186 WCHAR StaticBuffer[256];
187 PWSTR Buffer = StaticBuffer; // Use the static buffer by default.
188
189 /* We need to retrieve the current module's instance handle if either
190 * the title or the format message is specified by a resource ID */
191 if ((pszTitle && IS_INTRESOURCE(pszTitle)) || IS_INTRESOURCE(pszFormatMessage))
192 hInstance = GetModuleHandleW(NULL); // SetupData.hInstance;
193
194 /* Retrieve the format message string if this is a resource */
195 if (pszFormatMessage && IS_INTRESOURCE(pszFormatMessage))
196 {
197 Format = NULL;
198 (void)LoadAllocStringW(hInstance, PtrToUlong(pszFormatMessage), &Format, 0);
199 }
200 else
201 {
202 Format = (PWSTR)pszFormatMessage;
203 }
204
205 if (Format)
206 {
207 /* Format the message and retrieve its length. If it is too long,
208 * an auxiliary buffer is allocated; otherwise the static buffer
209 * is used. The string is built to be NUL-terminated. */
210 (void)FormatAllocStringWV(&Buffer, _countof(StaticBuffer), Format, args);
211 if (!Buffer)
212 {
213 /* Allocation failed, use the original format string verbatim */
214 Buffer = Format;
215 }
216 }
217 else
218 {
219 Format = (PWSTR)pszFormatMessage;
220 Buffer = Format;
221 }
222
223 /* Display the message */
224 mb.cbSize = sizeof(mb);
225 mb.hwndOwner = hWnd;
226 mb.hInstance = hInstance;
227 mb.lpszText = Buffer;
228 mb.lpszCaption = pszTitle;
229 mb.dwStyle = uType;
230 mb.dwLanguageId = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
231 iRes = MessageBoxIndirectW(&mb);
232
233 /* Free the buffers if needed */
234 if ((Buffer != StaticBuffer) && (Buffer != Format))
235 HeapFree(GetProcessHeap(), 0, Buffer);
236
237 if (Format && (Format != pszFormatMessage))
238 HeapFree(GetProcessHeap(), 0, Format);
239
240 return iRes;
241}
242
243INT
244__cdecl
245DisplayMessage(
246 _In_opt_ HWND hWnd,
247 _In_ UINT uType,
248 _In_opt_ PCWSTR pszTitle,
249 _In_opt_ PCWSTR pszFormatMessage,
250 ...)
251{
252 INT iRes;
253 va_list args;
254
255 va_start(args, pszFormatMessage);
256 iRes = DisplayMessageV(hWnd, uType, pszTitle, pszFormatMessage, args);
257 va_end(args);
258
259 return iRes;
260}
261
262INT
263__cdecl
264DisplayError(
265 _In_opt_ HWND hWnd,
266 _In_ UINT uIDTitle,
267 _In_ UINT uIDMessage,
268 ...)
269{
270 INT iRes;
271 va_list args;
272
273 va_start(args, uIDMessage);
274 iRes = DisplayMessageV(hWnd, MB_ICONERROR | MB_OK,
275 MAKEINTRESOURCEW(uIDTitle),
276 MAKEINTRESOURCEW(uIDMessage),
277 args);
278 va_end(args);
279
280 return iRes;
281}
282
283VOID
284SetWindowResTextW(
285 _In_ HWND hWnd,
286 _In_opt_ HINSTANCE hInstance,
287 _In_ UINT uID /*,
288 _In_opt_ PCWSTR pDefaultString*/)
289{
290 WCHAR szText[256];
291 PWSTR String = szText; // Use the static buffer by default.
292
293 /* Try to load the string from the resource */
294 (void)LoadAllocStringW(hInstance, uID, &String, _countof(szText));
295 if (!String)
296 return;
297 SetWindowTextW(hWnd, String);
298 if (String != szText)
299 HeapFree(GetProcessHeap(), 0, String);
300}
301
302VOID
303SetWindowResPrintfVW(
304 _In_ HWND hWnd,
305 _In_opt_ HINSTANCE hInstance,
306 _In_ UINT uID,
307 _In_ va_list args)
308{
309 WCHAR ResBuffer[256];
310 WCHAR szText[256];
311 PWSTR ResFmt = ResBuffer; // Use the static buffers by default.
312 PWSTR String = szText;
313
314 /* Try to load the string from the resource */
315 (void)LoadAllocStringW(hInstance, uID, &ResFmt, _countof(ResBuffer));
316 if (!ResFmt)
317 return;
318
319 /* Format the string and retrieve its length. If it is too long,
320 * an auxiliary buffer is allocated; otherwise the static buffer
321 * is used. The string is built to be NUL-terminated. */
322 (void)FormatAllocStringWV(&String, _countof(szText), ResFmt, args);
323 if (!String)
324 {
325 /* Allocation failed, use the original format string verbatim */
326 String = ResFmt;
327 }
328
329 SetWindowTextW(hWnd, String);
330
331 /* Free the buffers if needed */
332 if ((String != szText) && (String != ResFmt))
333 HeapFree(GetProcessHeap(), 0, String);
334
335 if (ResFmt && (ResFmt != ResBuffer))
336 HeapFree(GetProcessHeap(), 0, ResFmt);
337}
338
339VOID
340__cdecl
341SetWindowResPrintfW(
342 _In_ HWND hWnd,
343 _In_opt_ HINSTANCE hInstance,
344 _In_ UINT uID,
345 ...)
346{
347 va_list args;
348
349 va_start(args, uID);
350 SetWindowResPrintfVW(hWnd, hInstance, uID, args);
351 va_end(args);
352}
353
354static INT_PTR CALLBACK
355StartDlgProc(
356 IN HWND hwndDlg,
357 IN UINT uMsg,
358 IN WPARAM wParam,
359 IN LPARAM lParam)
360{
361 PSETUPDATA pSetupData;
362
363 /* Retrieve pointer to the global setup data */
364 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
365
366 switch (uMsg)
367 {
368 case WM_INITDIALOG:
369 {
370 /* Save pointer to the global setup data */
371 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGEW)lParam)->lParam;
372 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
373
374 /* Set title font */
375 SetDlgItemFont(hwndDlg, IDC_STARTTITLE, pSetupData->hTitleFont, TRUE);
376
377 // TEMPTEMP: Set the ReactOS-Alpha information in bold.
378 // TODO: Remove once we reach 0.5/Beta :)
379 SetDlgItemFont(hwndDlg, IDC_WARNTEXT1, pSetupData->hBoldFont, TRUE);
380 SetDlgItemFont(hwndDlg, IDC_WARNTEXT2, pSetupData->hBoldFont, TRUE);
381 SetDlgItemFont(hwndDlg, IDC_WARNTEXT3, pSetupData->hBoldFont, TRUE);
382
384 //CenterWindow(GetParent(hwndDlg));
385 return TRUE;
386 }
387
388 case WM_NOTIFY:
389 {
390 LPNMHDR lpnm = (LPNMHDR)lParam;
391
392 switch (lpnm->code)
393 {
394 case PSN_SETACTIVE:
395 {
396 /* Only "Next" and "Cancel" for the first page and hide "Back".
397 * Don't use the PropSheet_SetWizButtons() macro, because its
398 * posted message could interfere with the hidden button. */
399 SendMessageW(GetParent(hwndDlg), PSM_SETWIZBUTTONS, 0, PSWIZB_NEXT);
400 // PropSheet_ShowWizButtons(GetParent(hwndDlg), 0, PSWIZB_BACK);
401 ShowDlgItem(GetParent(hwndDlg), ID_WIZBACK, SW_HIDE);
402 break;
403 }
404
405 case PSN_KILLACTIVE:
406 {
407 /* Show "Back" button */
408 // PropSheet_ShowWizButtons(GetParent(hwndDlg), PSWIZB_BACK, PSWIZB_BACK);
409 ShowDlgItem(GetParent(hwndDlg), ID_WIZBACK, SW_SHOW);
410 break;
411 }
412
413 default:
414 break;
415 }
416 break;
417 }
418
419 default:
420 break;
421 }
422
423 return FALSE;
424}
425
426static INT_PTR CALLBACK
427TypeDlgProc(
428 IN HWND hwndDlg,
429 IN UINT uMsg,
430 IN WPARAM wParam,
431 IN LPARAM lParam)
432{
433 PSETUPDATA pSetupData;
434
435 /* Retrieve pointer to the global setup data */
436 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
437
438 switch (uMsg)
439 {
440 case WM_INITDIALOG:
441 {
442 /* Save pointer to the global setup data */
443 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGEW)lParam)->lParam;
444 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
445
446 /* Set the options in bold */
447 SetDlgItemFont(hwndDlg, IDC_INSTALL, pSetupData->hBoldFont, TRUE);
448 SetDlgItemFont(hwndDlg, IDC_UPDATE, pSetupData->hBoldFont, TRUE);
449
450 /* Check the "Install" radio button */
451 CheckDlgButton(hwndDlg, IDC_INSTALL, BST_CHECKED);
452
453 /*
454 * Enable the "Update" radio button and text only if we have
455 * available NT installations, otherwise disable them.
456 */
457 if (pSetupData->NtOsInstallsList &&
458 GetNumberOfListEntries(pSetupData->NtOsInstallsList) != 0)
459 {
460 EnableDlgItem(hwndDlg, IDC_UPDATE, TRUE);
461 EnableDlgItem(hwndDlg, IDC_UPDATETEXT, TRUE);
462 }
463 else
464 {
465 EnableDlgItem(hwndDlg, IDC_UPDATE, FALSE);
466 EnableDlgItem(hwndDlg, IDC_UPDATETEXT, FALSE);
467 }
468
469 /* Ensure "Install ReactOS" is initially focused */
470 SetFocus(GetDlgItem(hwndDlg, IDC_INSTALL));
471 return FALSE;
472 }
473
474 case WM_NOTIFY:
475 {
476 LPNMHDR lpnm = (LPNMHDR)lParam;
477
478 switch (lpnm->code)
479 {
480 case PSN_SETACTIVE:
481 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
482 break;
483
484 case PSN_QUERYCANCEL:
485 {
486 if (DisplayMessage(GetParent(hwndDlg),
487 MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
488 MAKEINTRESOURCEW(IDS_ABORTSETUP2),
489 MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
490 {
491 /* Go to the Abort page */
492 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_ABORTPAGE);
493 }
494
495 /* Do not close the wizard too soon */
496 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
497 return TRUE;
498 }
499
500 case PSN_WIZNEXT: /* Set the selected data */
501 {
502 /*
503 * Go update only if we have available NT installations
504 * and we choose to do so.
505 */
506 if (pSetupData->NtOsInstallsList &&
507 GetNumberOfListEntries(pSetupData->NtOsInstallsList) != 0 &&
508 IsDlgButtonChecked(hwndDlg, IDC_UPDATE) == BST_CHECKED)
509 {
510 pSetupData->RepairUpdateFlag = TRUE;
511
512 /*
513 * Display the existing NT installations page only
514 * if we have more than one available NT installations.
515 */
516 if (GetNumberOfListEntries(pSetupData->NtOsInstallsList) > 1)
517 {
518 /* pSetupData->CurrentInstallation will be set from within IDD_UPDATEREPAIRPAGE */
519
520 /* Actually the best would be to dynamically insert the page only when needed */
521 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_UPDATEREPAIRPAGE);
522 }
523 else
524 {
525 /* Retrieve the current installation */
526 pSetupData->CurrentInstallation =
527 (PNTOS_INSTALLATION)GetListEntryData(GetCurrentListEntry(pSetupData->NtOsInstallsList));
528 InstallPartition = pSetupData->CurrentInstallation->Volume->PartEntry;
529 StringCchCopyW(pSetupData->USetupData.InstallationDirectory,
530 _countof(pSetupData->USetupData.InstallationDirectory),
531 pSetupData->CurrentInstallation->PathComponent);
532
533 /* Jump to the Summary page during repair/upgrade */
534 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_SUMMARYPAGE);
535 }
536 }
537 else
538 {
539 pSetupData->CurrentInstallation = NULL;
540 pSetupData->RepairUpdateFlag = FALSE;
541 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_DEVICEPAGE);
542 }
543
544 return TRUE;
545 }
546
547 default:
548 break;
549 }
550 break;
551 }
552
553 default:
554 break;
555 }
556
557 return FALSE;
558}
559
560
561
562BOOL
563CreateListViewColumns(
564 IN HINSTANCE hInstance,
565 IN HWND hWndListView,
566 IN const UINT* pIDs,
567 IN const INT* pColsWidth,
568 IN const INT* pColsAlign,
569 IN UINT nNumOfColumns)
570{
571 UINT i;
572 LVCOLUMN lvC;
573 WCHAR szText[50];
574
575 /* Create the columns */
576 lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
577 lvC.pszText = szText;
578
579 /* Load the column labels from the resource file */
580 for (i = 0; i < nNumOfColumns; i++)
581 {
582 lvC.iSubItem = i;
583 lvC.cx = pColsWidth[i];
584 lvC.fmt = pColsAlign[i];
585
586 LoadStringW(hInstance, pIDs[i], szText, ARRAYSIZE(szText));
587
588 if (ListView_InsertColumn(hWndListView, i, &lvC) == -1)
589 return FALSE;
590 }
591
592 return TRUE;
593}
594
595typedef VOID
596(NTAPI *PGET_ENTRY_DESCRIPTION)(
597 IN PGENERIC_LIST_ENTRY Entry,
598 OUT PWSTR Buffer,
599 IN SIZE_T cchBufferSize);
600
601VOID
602InitGenericComboList(
603 IN HWND hWndList,
604 IN PGENERIC_LIST List,
605 IN PGET_ENTRY_DESCRIPTION GetEntryDescriptionProc)
606{
607 INT Index, CurrentEntryIndex = 0;
608 PGENERIC_LIST_ENTRY ListEntry;
609 PLIST_ENTRY Entry;
610 WCHAR CurrentItemText[256];
611
612 for (Entry = List->ListHead.Flink;
613 Entry != &List->ListHead;
614 Entry = Entry->Flink)
615 {
616 ListEntry = CONTAINING_RECORD(Entry, GENERIC_LIST_ENTRY, Entry);
617
618 if (GetEntryDescriptionProc)
619 {
620 GetEntryDescriptionProc(ListEntry,
621 CurrentItemText,
622 ARRAYSIZE(CurrentItemText));
623 Index = SendMessageW(hWndList, CB_ADDSTRING, 0, (LPARAM)CurrentItemText);
624 }
625 else
626 {
627 Index = SendMessageW(hWndList, CB_ADDSTRING, 0, (LPARAM)L"n/a");
628 }
629
630 if (ListEntry == List->CurrentEntry)
631 CurrentEntryIndex = Index;
632
633 SendMessageW(hWndList, CB_SETITEMDATA, Index, (LPARAM)ListEntry);
634 }
635
636 SendMessageW(hWndList, CB_SETCURSEL, CurrentEntryIndex, 0);
637}
638
639PVOID
640GetSelectedComboListItem(
641 IN HWND hWndList)
642{
643 INT Index;
644
645 Index = ComboBox_GetCurSel(hWndList);
646 if (Index == CB_ERR)
647 return NULL;
648
649 return (PVOID)ComboBox_GetItemData(hWndList, Index);
650}
651
652typedef VOID
653(NTAPI *PADD_ENTRY_ITEM)(
654 IN HWND hWndList,
655 IN LVITEM* plvItem,
656 IN PGENERIC_LIST_ENTRY Entry,
657 IN OUT PWSTR Buffer,
658 IN SIZE_T cchBufferSize);
659
660VOID
661InitGenericListView(
662 IN HWND hWndList,
663 IN PGENERIC_LIST List,
664 IN PADD_ENTRY_ITEM AddEntryItemProc)
665{
666 INT CurrentEntryIndex = 0;
667 LVITEM lvItem;
668 PGENERIC_LIST_ENTRY ListEntry;
669 PLIST_ENTRY Entry;
670 WCHAR CurrentItemText[256];
671
672 for (Entry = List->ListHead.Flink;
673 Entry != &List->ListHead;
674 Entry = Entry->Flink)
675 {
676 ListEntry = CONTAINING_RECORD(Entry, GENERIC_LIST_ENTRY, Entry);
677
678 if (!AddEntryItemProc)
679 continue;
680
681 AddEntryItemProc(hWndList,
682 &lvItem,
683 ListEntry,
684 CurrentItemText,
685 ARRAYSIZE(CurrentItemText));
686
687 if (ListEntry == List->CurrentEntry)
688 CurrentEntryIndex = lvItem.iItem;
689 }
690
691 ListView_EnsureVisible(hWndList, CurrentEntryIndex, FALSE);
692 ListView_SetItemState(hWndList, CurrentEntryIndex,
693 LVIS_FOCUSED | LVIS_SELECTED,
694 LVIS_FOCUSED | LVIS_SELECTED);
695}
696
697PVOID
698GetSelectedListViewItem(
699 IN HWND hWndList)
700{
701 INT Index;
702 LVITEM item;
703
704 Index = ListView_GetSelectionMark(hWndList);
705 if (Index == LB_ERR)
706 return NULL;
707
708 item.mask = LVIF_PARAM;
709 item.iItem = Index;
710 ListView_GetItem(hWndList, &item);
711
712 return (PVOID)item.lParam;
713}
714
715
716static VOID
717NTAPI
718GetSettingDescription(
719 IN PGENERIC_LIST_ENTRY Entry,
720 OUT PWSTR Buffer,
721 IN SIZE_T cchBufferSize)
722{
723 StringCchCopyW(Buffer, cchBufferSize,
724 ((PGENENTRY)GetListEntryData(Entry))->Value);
725}
726
727static VOID
728NTAPI
729AddNTOSInstallationItem(
730 IN HWND hWndList,
731 IN LVITEM* plvItem,
732 IN PGENERIC_LIST_ENTRY Entry,
733 IN OUT PWSTR Buffer, // SystemRootPath
734 IN SIZE_T cchBufferSize)
735{
736 PNTOS_INSTALLATION NtOsInstall = (PNTOS_INSTALLATION)GetListEntryData(Entry);
737 PVOLINFO VolInfo = (NtOsInstall->Volume ? &NtOsInstall->Volume->Info : NULL);
738
739 if (VolInfo && VolInfo->DriveLetter)
740 {
741 /* We have retrieved a partition that is mounted */
742 StringCchPrintfW(Buffer, cchBufferSize,
743 L"%c:%s",
744 VolInfo->DriveLetter,
745 NtOsInstall->PathComponent);
746 }
747 else
748 {
749 /* We failed somewhere, just show the NT path */
750 StringCchPrintfW(Buffer, cchBufferSize,
751 L"%wZ",
752 &NtOsInstall->SystemNtPath);
753 }
754
755 plvItem->mask = LVIF_IMAGE | LVIF_TEXT | LVIF_PARAM;
756 plvItem->iItem = 0;
757 plvItem->iSubItem = 0;
758 plvItem->lParam = (LPARAM)Entry;
759 plvItem->pszText = NtOsInstall->InstallationName;
760
761 /* Associate vendor icon */
762 if (FindSubStrI(NtOsInstall->VendorName, VENDOR_REACTOS))
763 {
764 plvItem->mask |= LVIF_IMAGE;
765 plvItem->iImage = 0;
766 }
767 else if (FindSubStrI(NtOsInstall->VendorName, VENDOR_MICROSOFT))
768 {
769 plvItem->mask |= LVIF_IMAGE;
770 plvItem->iImage = 1;
771 }
772
773 plvItem->iItem = SendMessageW(hWndList, LVM_INSERTITEMW, 0, (LPARAM)plvItem);
774
775 plvItem->iSubItem = 1;
776 plvItem->pszText = Buffer; // SystemRootPath;
777 SendMessageW(hWndList, LVM_SETITEMTEXTW, plvItem->iItem, (LPARAM)plvItem);
778
779 plvItem->iSubItem = 2;
780 plvItem->pszText = NtOsInstall->VendorName;
781 SendMessageW(hWndList, LVM_SETITEMTEXTW, plvItem->iItem, (LPARAM)plvItem);
782}
783
784
785#define IDS_LIST_COLUMN_FIRST IDS_INSTALLATION_NAME
786#define IDS_LIST_COLUMN_LAST IDS_INSTALLATION_VENDOR
787
788#define MAX_LIST_COLUMNS (IDS_LIST_COLUMN_LAST - IDS_LIST_COLUMN_FIRST + 1)
789static const UINT column_ids[MAX_LIST_COLUMNS] = {IDS_LIST_COLUMN_FIRST, IDS_LIST_COLUMN_FIRST + 1, IDS_LIST_COLUMN_FIRST + 2};
790static const INT column_widths[MAX_LIST_COLUMNS] = {200, 150, 100};
791static const INT column_alignment[MAX_LIST_COLUMNS] = {LVCFMT_LEFT, LVCFMT_LEFT, LVCFMT_LEFT};
792
793static INT_PTR CALLBACK
794UpgradeRepairDlgProc(
795 IN HWND hwndDlg,
796 IN UINT uMsg,
797 IN WPARAM wParam,
798 IN LPARAM lParam)
799{
800 PSETUPDATA pSetupData;
801 HWND hList;
802 HIMAGELIST hSmall;
803
804 /* Retrieve pointer to the global setup data */
805 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
806
807 switch (uMsg)
808 {
809 case WM_INITDIALOG:
810 {
811 /* Save pointer to the global setup data */
812 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGEW)lParam)->lParam;
813 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
814
815 hList = GetDlgItem(hwndDlg, IDC_NTOSLIST);
816
817 ListView_SetExtendedListViewStyleEx(hList, LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);
818
819 CreateListViewColumns(pSetupData->hInstance,
820 hList,
821 column_ids,
822 column_widths,
823 column_alignment,
824 MAX_LIST_COLUMNS);
825
826 /* Create the ImageList */
827 hSmall = ImageList_Create(GetSystemMetrics(SM_CXSMICON),
828 GetSystemMetrics(SM_CYSMICON),
829 ILC_COLOR32 | ILC_MASK, // ILC_COLOR24
830 1, 1);
831
832 /* Add event type icons to the ImageList */
833 ImageList_AddIcon(hSmall, LoadIconW(pSetupData->hInstance, MAKEINTRESOURCEW(IDI_ROSICON)));
834 ImageList_AddIcon(hSmall, LoadIconW(pSetupData->hInstance, MAKEINTRESOURCEW(IDI_WINICON)));
835
836 /* Assign the ImageList to the List View */
837 ListView_SetImageList(hList, hSmall, LVSIL_SMALL);
838
839 InitGenericListView(hList, pSetupData->NtOsInstallsList, AddNTOSInstallationItem);
840 break;
841 }
842
843 case WM_DESTROY:
844 {
845 hList = GetDlgItem(hwndDlg, IDC_NTOSLIST);
846 hSmall = ListView_GetImageList(hList, LVSIL_SMALL);
847 ListView_SetImageList(hList, NULL, LVSIL_SMALL);
848 ImageList_Destroy(hSmall);
849 return TRUE;
850 }
851
852 case WM_COMMAND:
853 switch (LOWORD(wParam))
854 {
855 case IDC_SKIPUPGRADE:
856 {
857 /* Skip the upgrade and do the usual new-installation workflow */
858 pSetupData->CurrentInstallation = NULL;
859 pSetupData->RepairUpdateFlag = FALSE;
860 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_DEVICEPAGE);
861 return TRUE;
862 }
863 }
864 break;
865
866 case WM_NOTIFY:
867 {
868 LPNMHDR lpnm = (LPNMHDR)lParam;
869
870 if (lpnm->idFrom == IDC_NTOSLIST && lpnm->code == LVN_ITEMCHANGED)
871 {
872 LPNMLISTVIEW pnmv = (LPNMLISTVIEW)lParam;
873
874 /* Check whether the item has been (de)selected */
875 if (!(pnmv->uChanged & LVIF_STATE) ||
876 !((pnmv->uOldState ^ pnmv->uNewState) & LVIS_SELECTED))
877 {
878 break;
879 }
880
881 /* Enable or disable the "Next" button when the user
882 * selects or deselects an installation to upgrade */
883 if (pnmv->uNewState & LVIS_SELECTED)
884 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
885 else
886 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
887 break;
888 }
889
890 switch (lpnm->code)
891 {
892 case PSN_SETACTIVE:
893 {
894 /* Keep the "Next" button disabled. It will be enabled only
895 * when the user selects an installation to upgrade. */
896 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
897 break;
898 }
899
900 case PSN_QUERYINITIALFOCUS:
901 {
902 /* Reselect the currently selected item, so as to refresh the UI buttons */
903 INT Index;
904 hList = GetDlgItem(hwndDlg, IDC_NTOSLIST);
905 Index = ListView_GetSelectionMark(hList);
906 if (Index != LB_ERR)
907 {
908 /* Deselect first the item before reselecting it, so as to
909 * invalidate its cached state and have the LVN_ITEMCHANGED
910 * notification sent. */
911 //ListView_EnsureVisible(hList, Index, FALSE);
912 ListView_SetItemState(hList, Index, 0, LVIS_SELECTED);
913 ListView_SetItemState(hList, Index,
914 LVIS_FOCUSED | LVIS_SELECTED,
915 LVIS_FOCUSED | LVIS_SELECTED);
916 }
917
918 /* Focus on the installations list */
919 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)hList);
920 return TRUE;
921 }
922
923 case PSN_QUERYCANCEL:
924 {
925 if (DisplayMessage(GetParent(hwndDlg),
926 MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
927 MAKEINTRESOURCEW(IDS_ABORTSETUP2),
928 MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
929 {
930 /* Go to the Abort page */
931 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_ABORTPAGE);
932 }
933
934 /* Do not close the wizard too soon */
935 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
936 return TRUE;
937 }
938
939 case PSN_WIZNEXT: /* Set the selected data */
940 {
941 /*
942 * Go update only if we have available NT installations
943 * and we choose to do so.
944 */
945 if (!pSetupData->NtOsInstallsList ||
946 GetNumberOfListEntries(pSetupData->NtOsInstallsList) == 0)
947 {
948 pSetupData->CurrentInstallation = NULL;
949 pSetupData->RepairUpdateFlag = FALSE;
950 break;
951 }
952
953 hList = GetDlgItem(hwndDlg, IDC_NTOSLIST);
954 SetCurrentListEntry(pSetupData->NtOsInstallsList,
955 GetSelectedListViewItem(hList));
956
957 /* Retrieve the current installation */
958 pSetupData->CurrentInstallation =
959 (PNTOS_INSTALLATION)GetListEntryData(GetCurrentListEntry(pSetupData->NtOsInstallsList));
960 InstallPartition = pSetupData->CurrentInstallation->Volume->PartEntry;
961 StringCchCopyW(pSetupData->USetupData.InstallationDirectory,
962 _countof(pSetupData->USetupData.InstallationDirectory),
963 pSetupData->CurrentInstallation->PathComponent);
964
965 /* We perform an upgrade */
966 pSetupData->RepairUpdateFlag = TRUE;
967 /* Jump to the Summary page during repair/upgrade */
968 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_SUMMARYPAGE);
969 return TRUE;
970 }
971
972 default:
973 break;
974 }
975 break;
976 }
977
978 default:
979 break;
980 }
981
982 return FALSE;
983}
984
985static INT_PTR CALLBACK
986DeviceDlgProc(
987 IN HWND hwndDlg,
988 IN UINT uMsg,
989 IN WPARAM wParam,
990 IN LPARAM lParam)
991{
992 PSETUPDATA pSetupData;
993 HWND hList;
994
995 /* Retrieve pointer to the global setup data */
996 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
997
998 switch (uMsg)
999 {
1000 case WM_INITDIALOG:
1001 {
1002 /* Save pointer to the global setup data */
1003 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGEW)lParam)->lParam;
1004 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
1005
1006 hList = GetDlgItem(hwndDlg, IDC_COMPUTER);
1007 InitGenericComboList(hList, pSetupData->USetupData.ComputerList, GetSettingDescription);
1008
1009 hList = GetDlgItem(hwndDlg, IDC_DISPLAY);
1010 InitGenericComboList(hList, pSetupData->USetupData.DisplayList, GetSettingDescription);
1011
1012 hList = GetDlgItem(hwndDlg, IDC_KEYBOARD);
1013 InitGenericComboList(hList, pSetupData->USetupData.KeyboardList, GetSettingDescription);
1014
1015 // hList = GetDlgItem(hwndDlg, IDC_KEYBOARD_LAYOUT);
1016 // InitGenericComboList(hList, pSetupData->USetupData.LayoutList, GetSettingDescription);
1017
1018 return TRUE;
1019 }
1020
1021 case WM_NOTIFY:
1022 {
1023 LPNMHDR lpnm = (LPNMHDR)lParam;
1024
1025 switch (lpnm->code)
1026 {
1027 case PSN_SETACTIVE:
1028 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
1029 break;
1030
1031 case PSN_QUERYCANCEL:
1032 {
1033 if (DisplayMessage(GetParent(hwndDlg),
1034 MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
1035 MAKEINTRESOURCEW(IDS_ABORTSETUP2),
1036 MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
1037 {
1038 /* Go to the Abort page */
1039 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_ABORTPAGE);
1040 }
1041
1042 /* Do not close the wizard too soon */
1043 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
1044 return TRUE;
1045 }
1046
1047 case PSN_WIZNEXT: /* Set the selected data */
1048 {
1049 hList = GetDlgItem(hwndDlg, IDC_COMPUTER);
1050 SetCurrentListEntry(pSetupData->USetupData.ComputerList,
1051 GetSelectedComboListItem(hList));
1052
1053 hList = GetDlgItem(hwndDlg, IDC_DISPLAY);
1054 SetCurrentListEntry(pSetupData->USetupData.DisplayList,
1055 GetSelectedComboListItem(hList));
1056
1057 hList = GetDlgItem(hwndDlg, IDC_KEYBOARD);
1058 SetCurrentListEntry(pSetupData->USetupData.KeyboardList,
1059 GetSelectedComboListItem(hList));
1060
1061 // hList = GetDlgItem(hwndDlg, IDC_KEYBOARD_LAYOUT);
1062 // SetCurrentListEntry(pSetupData->USetupData.LayoutList,
1063 // GetSelectedComboListItem(hList));
1064
1065 return TRUE;
1066 }
1067
1068 case PSN_WIZBACK:
1069 {
1070 /* Return to the Install type selection page instead of the Repair/Upgrade page */
1071 SetWindowLongW(hwndDlg, DWLP_MSGRESULT, IDD_TYPEPAGE);
1072 return TRUE;
1073 }
1074
1075 default:
1076 break;
1077 }
1078 break;
1079 }
1080
1081 default:
1082 break;
1083 }
1084
1085 return FALSE;
1086}
1087
1088static INT_PTR CALLBACK
1089SummaryDlgProc(
1090 IN HWND hwndDlg,
1091 IN UINT uMsg,
1092 IN WPARAM wParam,
1093 IN LPARAM lParam)
1094{
1095 static WCHAR szOrgWizNextBtnText[260]; // TODO: Make it dynamic
1096
1097 PSETUPDATA pSetupData;
1098
1099 /* Retrieve pointer to the global setup data */
1100 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
1101
1102 switch (uMsg)
1103 {
1104 case WM_INITDIALOG:
1105 {
1106 /* Save pointer to the global setup data */
1107 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGEW)lParam)->lParam;
1108 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
1109 break;
1110 }
1111
1112 case WM_COMMAND:
1113 {
1114 if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_CONFIRM_INSTALL)
1115 {
1116 // Ideally we could add the PSWIZBF_ELEVATIONREQUIRED style.
1117 if (IsDlgButtonChecked(hwndDlg, IDC_CONFIRM_INSTALL) == BST_CHECKED)
1118 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
1119 else
1120 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
1121 }
1122 break;
1123 }
1124
1125 case WM_NOTIFY:
1126 {
1127 LPNMHDR lpnm = (LPNMHDR)lParam;
1128
1129 switch (lpnm->code)
1130 {
1131 case PSN_SETACTIVE:
1132 {
1133 WCHAR CurrentItemText[256];
1134
1135 ASSERT(InstallPartition);
1136
1137 /* Show the current selected settings */
1138
1139 // FIXME! Localize
1140 if (pSetupData->RepairUpdateFlag)
1141 {
1142 StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
1143 L"Upgrading/Repairing \"%s\" from \"%s\"",
1144 pSetupData->CurrentInstallation->InstallationName,
1145 pSetupData->CurrentInstallation->VendorName);
1146 }
1147 else
1148 {
1149 StringCchCopyW(CurrentItemText, ARRAYSIZE(CurrentItemText),
1150 L"New ReactOS installation");
1151 }
1152 SetDlgItemTextW(hwndDlg, IDC_INSTALLTYPE, CurrentItemText);
1153
1154 SetDlgItemTextW(hwndDlg, IDC_INSTALLSOURCE, L"n/a");
1155 SetDlgItemTextW(hwndDlg, IDC_ARCHITECTURE, L"n/a");
1156
1157 GetSettingDescription(GetCurrentListEntry(pSetupData->USetupData.ComputerList),
1158 CurrentItemText,
1159 ARRAYSIZE(CurrentItemText));
1160 SetDlgItemTextW(hwndDlg, IDC_COMPUTER, CurrentItemText);
1161
1162 GetSettingDescription(GetCurrentListEntry(pSetupData->USetupData.DisplayList),
1163 CurrentItemText,
1164 ARRAYSIZE(CurrentItemText));
1165 SetDlgItemTextW(hwndDlg, IDC_DISPLAY, CurrentItemText);
1166
1167 GetSettingDescription(GetCurrentListEntry(pSetupData->USetupData.KeyboardList),
1168 CurrentItemText,
1169 ARRAYSIZE(CurrentItemText));
1170 SetDlgItemTextW(hwndDlg, IDC_KEYBOARD, CurrentItemText);
1171
1172 if (InstallVolume->Info.DriveLetter)
1173 {
1174#if 0
1175 StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
1176 L"%c: \x2014 %wZ",
1177 InstallVolume->Info.DriveLetter,
1178 &pSetupData->USetupData.DestinationRootPath);
1179#else
1180 StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
1181 L"%c: \x2014 Harddisk %lu, Partition %lu",
1182 InstallVolume->Info.DriveLetter,
1183 InstallPartition->DiskEntry->DiskNumber,
1184 InstallPartition->OnDiskPartitionNumber);
1185#endif
1186 }
1187 else
1188 {
1189#if 0
1190 StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
1191 L"%wZ",
1192 &pSetupData->USetupData.DestinationRootPath);
1193#else
1194 StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
1195 L"Harddisk %lu, Partition %lu",
1196 InstallPartition->DiskEntry->DiskNumber,
1197 InstallPartition->OnDiskPartitionNumber);
1198#endif
1199 }
1200 SetDlgItemTextW(hwndDlg, IDC_DESTDRIVE, CurrentItemText);
1201
1202 SetDlgItemTextW(hwndDlg, IDC_PATH,
1203 pSetupData->USetupData.InstallationDirectory
1204 /*pSetupData->USetupData.InstallPath.Buffer*/);
1205
1206
1207 /* Change the "Next" button text to "Install" */
1208 // PropSheet_SetNextText(GetParent(hwndDlg), ...);
1209 GetDlgItemTextW(GetParent(hwndDlg), ID_WIZNEXT,
1210 szOrgWizNextBtnText, ARRAYSIZE(szOrgWizNextBtnText));
1211 SetWindowResTextW(GetDlgItem(GetParent(hwndDlg), ID_WIZNEXT),
1212 pSetupData->hInstance,
1213 IDS_INSTALLBTN);
1214
1215 /* Keep the "Next" button disabled. It will be enabled only
1216 * when the user clicks on the installation approval checkbox. */
1217 CheckDlgButton(hwndDlg, IDC_CONFIRM_INSTALL, BST_UNCHECKED);
1218 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
1219 break;
1220 }
1221
1222 case PSN_QUERYINITIALFOCUS:
1223 {
1224 /* Focus on the confirmation check-box */
1225 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)GetDlgItem(hwndDlg, IDC_CONFIRM_INSTALL));
1226 return TRUE;
1227 }
1228
1229 case PSN_KILLACTIVE:
1230 {
1231 /* Restore the original "Next" button text */
1232 SetDlgItemTextW(GetParent(hwndDlg), ID_WIZNEXT, szOrgWizNextBtnText);
1233 break;
1234 }
1235
1236 case PSN_QUERYCANCEL:
1237 {
1238 if (DisplayMessage(GetParent(hwndDlg),
1239 MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
1240 MAKEINTRESOURCEW(IDS_ABORTSETUP2),
1241 MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
1242 {
1243 /* Go to the Abort page */
1244 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_ABORTPAGE);
1245 }
1246
1247 /* Do not close the wizard too soon */
1248 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
1249 return TRUE;
1250 }
1251
1252 case PSN_WIZBACK:
1253 {
1254 /* When the user performs a regular installation, go back to the previous page */
1255 if (!pSetupData->RepairUpdateFlag)
1256 break;
1257
1258 if (GetNumberOfListEntries(pSetupData->NtOsInstallsList) > 1)
1259 {
1260 /* Return to the Upgrade/Repair selection page, when the user is
1261 * upgrading and there are more than one installation available */
1262 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_UPDATEREPAIRPAGE);
1263 }
1264 else
1265 {
1266 /* Return to the Install type selection page, when the user is
1267 * upgrading and there is at most one installation available */
1268 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_TYPEPAGE);
1269 }
1270 return TRUE;
1271 }
1272
1273 default:
1274 break;
1275 }
1276 break;
1277 }
1278
1279 default:
1280 break;
1281 }
1282
1283 return FALSE;
1284}
1285
1286
1287typedef struct _FSVOL_CONTEXT
1288{
1289 PSETUPDATA pSetupData;
1290 // PAGE_NUMBER NextPageOnAbort;
1291} FSVOL_CONTEXT, *PFSVOL_CONTEXT;
1292
1293static
1294BOOLEAN
1295NTAPI
1296FormatCallback(
1297 _In_ CALLBACKCOMMAND Command,
1298 _In_ ULONG Modifier,
1299 _In_ PVOID Argument)
1300{
1301 switch (Command)
1302 {
1303 case PROGRESS:
1304 {
1305 PULONG Percent = (PULONG)Argument;
1306 DPRINT("%lu percent completed\n", *Percent);
1307 SendMessageW(UiContext.hWndProgress, PBM_SETPOS, *Percent, 0);
1308 break;
1309 }
1310
1311#if 0
1312 case OUTPUT:
1313 {
1314 PTEXTOUTPUT output = (PTEXTOUTPUT)Argument;
1315 DPRINT("%s\n", output->Output);
1316 break;
1317 }
1318#endif
1319
1320 case DONE:
1321 {
1322#if 0
1323 PBOOLEAN Success = (PBOOLEAN)Argument;
1324 if (*Success == FALSE)
1325 {
1326 DPRINT("FormatEx was unable to complete successfully.\n\n");
1327 }
1328#endif
1329 DPRINT("Done\n");
1330 break;
1331 }
1332
1333 default:
1334 DPRINT("Unknown callback %lu\n", (ULONG)Command);
1335 break;
1336 }
1337
1338 return TRUE;
1339}
1340
1341static
1342BOOLEAN
1343NTAPI
1344ChkdskCallback(
1345 _In_ CALLBACKCOMMAND Command,
1346 _In_ ULONG Modifier,
1347 _In_ PVOID Argument)
1348{
1349 switch (Command)
1350 {
1351 default:
1352 DPRINT("Unknown callback %lu\n", (ULONG)Command);
1353 break;
1354 }
1355
1356 return TRUE;
1357}
1358
1359// PFSVOL_CALLBACK
1360static FSVOL_OP
1361CALLBACK
1362FsVolCallback(
1363 _In_opt_ PVOID Context,
1364 _In_ FSVOLNOTIFY FormatStatus,
1365 _In_ ULONG_PTR Param1,
1366 _In_ ULONG_PTR Param2)
1367{
1368 PFSVOL_CONTEXT FsVolContext = (PFSVOL_CONTEXT)Context;
1369
1370 switch (FormatStatus)
1371 {
1372 // FIXME: Deprecate!
1373 case ChangeSystemPartition:
1374 {
1375 // PPARTENTRY SystemPartition = (PPARTENTRY)Param1;
1376
1377 // FsVolContext->NextPageOnAbort = SELECT_PARTITION_PAGE;
1378 // if (ChangeSystemPartitionPage(Ir, SystemPartition))
1379 // return FSVOL_DOIT;
1380 return FSVOL_ABORT;
1381 }
1382
1383 case FSVOLNOTIFY_PARTITIONERROR:
1384 {
1385 switch (Param1)
1386 {
1387 case STATUS_PARTITION_FAILURE:
1388 {
1389 // ERROR_WRITE_PTABLE
1390 DisplayError(NULL,
1391 0, // Default to "Error"
1392 IDS_ERROR_WRITE_PTABLE);
1393 // FsVolContext->NextPageOnAbort = QUIT_PAGE;
1394 // TODO: Go back to the partitioning page?
1395 break;
1396 }
1397
1398 case ERROR_SYSTEM_PARTITION_NOT_FOUND:
1399 {
1400 /* FIXME: improve the error dialog */
1401 //
1402 // Error dialog should say that we cannot find a suitable
1403 // system partition and create one on the system. At this point,
1404 // it may be nice to ask the user whether he wants to continue,
1405 // or use an external drive as the system drive/partition
1406 // (e.g. floppy, USB drive, etc...)
1407 //
1408 DisplayError(NULL,
1409 0, // Default to "Error"
1410 IDS_ERROR_SYSTEM_PARTITION);
1411 // FsVolContext->NextPageOnAbort = SELECT_PARTITION_PAGE;
1412 // TODO: Go back to the partitioning page
1413 break;
1414 }
1415
1416 default:
1417 break;
1418 }
1419 return FSVOL_ABORT;
1420 }
1421
1422 case FSVOLNOTIFY_STARTQUEUE:
1423 case FSVOLNOTIFY_ENDQUEUE:
1424 // NOTE: If needed, clear progress gauges.
1425 return FSVOL_DOIT;
1426
1427 case FSVOLNOTIFY_STARTSUBQUEUE:
1428 {
1429 if ((FSVOL_OP)Param1 == FSVOL_FORMAT)
1430 {
1431 /*
1432 * In case we just repair an existing installation, or make
1433 * an unattended setup without formatting, just go to the
1434 * filesystem check step.
1435 */
1436 if (FsVolContext->pSetupData->RepairUpdateFlag)
1437 return FSVOL_SKIP;
1439 if (IsUnattendedSetup && !FsVolContext->pSetupData->USetupData.FormatPartition)
1440 return FSVOL_SKIP;
1442 /* Set status text */
1443 SetDlgItemTextW(UiContext.hwndDlg, IDC_ITEM, L"");
1444 }
1445 else
1446 if ((FSVOL_OP)Param1 == FSVOL_CHECK)
1447 {
1448 /* Set status text */
1449 SetDlgItemTextW(UiContext.hwndDlg, IDC_ITEM, L"");
1450
1451 /* Filechecking step: set progress marquee style and start it up */
1452 UiContext.dwPbStyle = GetWindowLongPtrW(UiContext.hWndProgress, GWL_STYLE);
1453 SetWindowLongPtrW(UiContext.hWndProgress, GWL_STYLE, UiContext.dwPbStyle | PBS_MARQUEE);
1454 SendMessageW(UiContext.hWndProgress, PBM_SETMARQUEE, TRUE, 0);
1455 }
1456
1457 return FSVOL_DOIT;
1458 }
1459
1460 case FSVOLNOTIFY_ENDSUBQUEUE:
1461 {
1462 if ((FSVOL_OP)Param1 == FSVOL_CHECK)
1463 {
1464 /* File-checking finished: stop the progress bar and restore its style */
1465 SendMessageW(UiContext.hWndProgress, PBM_SETMARQUEE, FALSE, 0);
1466 SetWindowLongPtrW(UiContext.hWndProgress, GWL_STYLE, UiContext.dwPbStyle);
1467 }
1468 return 0;
1469 }
1470
1471 case FSVOLNOTIFY_FORMATERROR:
1472 {
1473 PFORMAT_VOLUME_INFO FmtInfo = (PFORMAT_VOLUME_INFO)Param1;
1474
1475 // FIXME: See also FSVOLNOTIFY_PARTITIONERROR
1476 if (FmtInfo->ErrorStatus == STATUS_PARTITION_FAILURE)
1477 {
1478 // ERROR_WRITE_PTABLE
1479 DisplayError(NULL,
1480 0, // Default to "Error"
1481 IDS_ERROR_WRITE_PTABLE);
1482 // FsVolContext->NextPageOnAbort = QUIT_PAGE;
1483 // TODO: Go back to the partitioning page?
1484 return FSVOL_ABORT;
1485 }
1486 else
1487 if (FmtInfo->ErrorStatus == STATUS_UNRECOGNIZED_VOLUME)
1488 {
1489 /* FIXME: show an error dialog */
1490 // MUIDisplayError(ERROR_FORMATTING_PARTITION, Ir, POPUP_WAIT_ANY_KEY, PathBuffer);
1491 DisplayError(NULL,
1492 0, // Default to "Error"
1493 IDS_ERROR_FORMAT_UNRECOGNIZED_VOLUME);
1494 // FsVolContext->NextPageOnAbort = QUIT_PAGE;
1495 return FSVOL_ABORT;
1496 }
1497 else
1498 if (FmtInfo->ErrorStatus == STATUS_NOT_SUPPORTED)
1499 {
1500 INT nRet;
1501
1502 nRet = DisplayMessage(NULL, MB_ICONERROR | MB_OKCANCEL,
1503 NULL, // Default to "Error"
1504 MAKEINTRESOURCEW(IDS_ERROR_COULD_NOT_FORMAT),
1505 FmtInfo->FileSystemName);
1506 if (nRet == IDCANCEL)
1507 {
1508 // FsVolContext->NextPageOnAbort = QUIT_PAGE;
1509 return FSVOL_ABORT;
1510 }
1511 else if (nRet == IDOK)
1512 {
1513 return FSVOL_RETRY;
1514 }
1515 }
1516 else if (!NT_SUCCESS(FmtInfo->ErrorStatus))
1517 {
1518 ASSERT(*FmtInfo->Volume->Info.DeviceName);
1519
1520 DPRINT1("FormatPartition() failed with status 0x%08lx\n", FmtInfo->ErrorStatus);
1521
1522 // ERROR_FORMATTING_PARTITION
1523 DisplayError(NULL,
1524 0, // Default to "Error"
1525 IDS_ERROR_FORMATTING_PARTITION,
1526 FmtInfo->Volume->Info.DeviceName);
1527 // FsVolContext->NextPageOnAbort = QUIT_PAGE;
1528 return FSVOL_ABORT;
1529 }
1530
1531 return FSVOL_RETRY;
1532 }
1533
1534 case FSVOLNOTIFY_CHECKERROR:
1535 {
1536 PCHECK_VOLUME_INFO ChkInfo = (PCHECK_VOLUME_INFO)Param1;
1537
1538 if (ChkInfo->ErrorStatus == STATUS_NOT_SUPPORTED)
1539 {
1540 INT nRet;
1541
1542 nRet = DisplayMessage(NULL, MB_ICONERROR | MB_OKCANCEL,
1543 NULL, // Default to "Error"
1544 MAKEINTRESOURCEW(IDS_ERROR_COULD_NOT_CHECK),
1545 ChkInfo->Volume->Info.FileSystem);
1546 if (nRet == IDCANCEL)
1547 {
1548 // FsVolContext->NextPageOnAbort = QUIT_PAGE;
1549 return FSVOL_ABORT;
1550 }
1551 else if (nRet == IDOK)
1552 {
1553 return FSVOL_SKIP;
1554 }
1555 }
1556 else if (!NT_SUCCESS(ChkInfo->ErrorStatus))
1557 {
1558 DPRINT1("ChkdskPartition() failed with status 0x%08lx\n", ChkInfo->ErrorStatus);
1559
1560 DisplayError(NULL,
1561 0, // Default to "Error"
1562 IDS_ERROR_CHECKING_PARTITION,
1563 ChkInfo->ErrorStatus);
1564 return FSVOL_SKIP;
1565 }
1566
1567 return FSVOL_SKIP;
1568 }
1569
1570 case FSVOLNOTIFY_STARTFORMAT:
1571 {
1572 PFORMAT_VOLUME_INFO FmtInfo = (PFORMAT_VOLUME_INFO)Param1;
1573 PVOL_CREATE_INFO VolCreate;
1574
1575 ASSERT((FSVOL_OP)Param2 == FSVOL_FORMAT);
1576
1577 /* Find the volume info in the partition TreeList UI.
1578 * If none, don't format it. */
1579 VolCreate = FindVolCreateInTreeByVolume(UiContext.hPartList,
1580 FmtInfo->Volume);
1581 if (!VolCreate)
1582 return FSVOL_SKIP;
1583 ASSERT(VolCreate->Volume == FmtInfo->Volume);
1584
1585 /* If there is no formatting information, skip it */
1586 if (!*VolCreate->FileSystemName)
1587 return FSVOL_SKIP;
1588
1589 ASSERT(*FmtInfo->Volume->Info.DeviceName);
1590
1591 /* Set status text */
1592 if (FmtInfo->Volume->Info.DriveLetter)
1593 {
1594 SetWindowResPrintfW(GetDlgItem(UiContext.hwndDlg, IDC_ITEM),
1595 SetupData.hInstance,
1596 IDS_FORMATTING_PROGRESS1, // L"Formatting volume %c: (%s) in %s..."
1597 FmtInfo->Volume->Info.DriveLetter,
1598 FmtInfo->Volume->Info.DeviceName,
1599 VolCreate->FileSystemName);
1600 }
1601 else
1602 {
1603 SetWindowResPrintfW(GetDlgItem(UiContext.hwndDlg, IDC_ITEM),
1604 SetupData.hInstance,
1605 IDS_FORMATTING_PROGRESS2, // L"Formatting volume %s in %s..."
1606 FmtInfo->Volume->Info.DeviceName,
1607 VolCreate->FileSystemName);
1608 }
1609
1610 // StartFormat(FmtInfo, FileSystemList->Selected);
1611 FmtInfo->FileSystemName = VolCreate->FileSystemName;
1612 FmtInfo->MediaFlag = VolCreate->MediaFlag;
1613 FmtInfo->Label = VolCreate->Label;
1614 FmtInfo->QuickFormat = VolCreate->QuickFormat;
1615 FmtInfo->ClusterSize = VolCreate->ClusterSize;
1616 FmtInfo->Callback = FormatCallback;
1617
1618 /* Set up the progress bar */
1619 SendMessageW(UiContext.hWndProgress,
1620 PBM_SETRANGE, 0, MAKELPARAM(0, 100));
1621 SendMessageW(UiContext.hWndProgress,
1622 PBM_SETPOS, 0, 0);
1623
1624 return FSVOL_DOIT;
1625 }
1626
1627 case FSVOLNOTIFY_ENDFORMAT:
1628 {
1629 PFORMAT_VOLUME_INFO FmtInfo = (PFORMAT_VOLUME_INFO)Param1;
1630
1631 // EndFormat(FmtInfo->ErrorStatus);
1632 if (FmtInfo->FileSystemName)
1633 *(PWSTR)FmtInfo->FileSystemName = UNICODE_NULL; // FIXME: HACK!
1634
1635 // /* Reset the file system list */
1636 // ResetFileSystemList();
1637 return 0;
1638 }
1639
1640 case FSVOLNOTIFY_STARTCHECK:
1641 {
1642 PCHECK_VOLUME_INFO ChkInfo = (PCHECK_VOLUME_INFO)Param1;
1643 PVOL_CREATE_INFO VolCreate;
1644
1645 ASSERT((FSVOL_OP)Param2 == FSVOL_CHECK);
1646
1647 /* Find the volume info in the partition TreeList UI.
1648 * If none, don't check it. */
1649 VolCreate = FindVolCreateInTreeByVolume(UiContext.hPartList,
1650 ChkInfo->Volume);
1651 if (!VolCreate)
1652 return FSVOL_SKIP;
1653 ASSERT(VolCreate->Volume == ChkInfo->Volume);
1654
1655 ASSERT(*ChkInfo->Volume->Info.DeviceName);
1656
1657 /* Set status text */
1658 if (ChkInfo->Volume->Info.DriveLetter)
1659 {
1660 SetWindowResPrintfW(GetDlgItem(UiContext.hwndDlg, IDC_ITEM),
1661 SetupData.hInstance,
1662 IDS_CHECKING_PROGRESS1, // L"Checking volume %c: (%s)..."
1663 ChkInfo->Volume->Info.DriveLetter,
1664 ChkInfo->Volume->Info.DeviceName);
1665 }
1666 else
1667 {
1668 SetWindowResPrintfW(GetDlgItem(UiContext.hwndDlg, IDC_ITEM),
1669 SetupData.hInstance,
1670 IDS_CHECKING_PROGRESS2, // L"Checking volume %s..."
1671 ChkInfo->Volume->Info.DeviceName);
1672 }
1673
1674 // StartCheck(ChkInfo);
1675 // TODO: Think about which values could be defaulted...
1676 ChkInfo->FixErrors = TRUE;
1677 ChkInfo->Verbose = FALSE;
1678 ChkInfo->CheckOnlyIfDirty = TRUE;
1679 ChkInfo->ScanDrive = FALSE;
1680 ChkInfo->Callback = ChkdskCallback;
1681
1682 return FSVOL_DOIT;
1683 }
1684
1685 case FSVOLNOTIFY_ENDCHECK:
1686 {
1687 // PCHECK_VOLUME_INFO ChkInfo = (PCHECK_VOLUME_INFO)Param1;
1688 // EndCheck(ChkInfo->ErrorStatus);
1689 return 0;
1690 }
1691 }
1692
1693 return 0;
1694}
1695
1696
1697
1698typedef struct _COPYCONTEXT
1699{
1700 PSETUPDATA pSetupData;
1701 ULONG TotalOperations;
1702 ULONG CompletedOperations;
1703} COPYCONTEXT, *PCOPYCONTEXT;
1704
1705static UINT
1706CALLBACK
1707FileCopyCallback(PVOID Context,
1708 UINT Notification,
1709 UINT_PTR Param1,
1710 UINT_PTR Param2)
1711{
1712 PCOPYCONTEXT CopyContext = (PCOPYCONTEXT)Context;
1713 PFILEPATHS_W FilePathInfo;
1714 PCWSTR SrcFileName, DstFileName;
1715
1716 WaitForSingleObject(CopyContext->pSetupData->hHaltInstallEvent, INFINITE);
1717 if (CopyContext->pSetupData->bAbortInstall)
1718 return FILEOP_ABORT; // Stop committing files
1719
1720 switch (Notification)
1721 {
1722 case SPFILENOTIFY_STARTSUBQUEUE:
1723 {
1724 CopyContext->TotalOperations = (ULONG)Param2;
1725 CopyContext->CompletedOperations = 0;
1726
1727 /* Set up the progress bar */
1728 SendMessageW(UiContext.hWndProgress,
1729 PBM_SETRANGE, 0,
1730 MAKELPARAM(0, CopyContext->TotalOperations));
1731 SendMessageW(UiContext.hWndProgress,
1732 PBM_SETSTEP, 1, 0);
1733 SendMessageW(UiContext.hWndProgress,
1734 PBM_SETPOS, 0, 0);
1735 break;
1736 }
1737
1738 case SPFILENOTIFY_STARTDELETE:
1739 case SPFILENOTIFY_STARTRENAME:
1740 case SPFILENOTIFY_STARTCOPY:
1741 {
1742 FilePathInfo = (PFILEPATHS_W)Param1;
1743
1744 if (Notification == SPFILENOTIFY_STARTDELETE)
1745 {
1746 /* Display delete message */
1747 ASSERT(Param2 == FILEOP_DELETE);
1748
1749 DstFileName = wcsrchr(FilePathInfo->Target, L'\\');
1750 if (DstFileName) ++DstFileName;
1751 else DstFileName = FilePathInfo->Target;
1752
1753 SetWindowResPrintfW(UiContext.hWndItem,
1754 SetupData.hInstance,
1755 IDS_DELETING, // STRING_DELETING
1756 DstFileName);
1757 }
1758 else if (Notification == SPFILENOTIFY_STARTRENAME)
1759 {
1760 UINT uMsgID;
1761
1762 /* Display move/rename message */
1763 ASSERT(Param2 == FILEOP_RENAME);
1764
1765 SrcFileName = wcsrchr(FilePathInfo->Source, L'\\');
1766 if (SrcFileName) ++SrcFileName;
1767 else SrcFileName = FilePathInfo->Source;
1768
1769 DstFileName = wcsrchr(FilePathInfo->Target, L'\\');
1770 if (DstFileName) ++DstFileName;
1771 else DstFileName = FilePathInfo->Target;
1772
1773 if (!_wcsicmp(SrcFileName, DstFileName))
1774 uMsgID = IDS_MOVING; // STRING_MOVING
1775 else
1776 uMsgID = IDS_RENAMING; // STRING_RENAMING
1777 SetWindowResPrintfW(UiContext.hWndItem,
1778 SetupData.hInstance,
1779 uMsgID,
1780 SrcFileName, DstFileName);
1781 }
1782 else if (Notification == SPFILENOTIFY_STARTCOPY)
1783 {
1784 /* Display copy message */
1785 ASSERT(Param2 == FILEOP_COPY);
1786
1787 DstFileName = wcsrchr(FilePathInfo->Target, L'\\');
1788 if (DstFileName) ++DstFileName;
1789 else DstFileName = FilePathInfo->Target;
1790
1791 /* Whereas the repair/upgrade procedure may move, rename, or
1792 * delete files, the regular installation only copies files.
1793 * Therefore, display only the file name instead of the full
1794 * "Copying..." message in this case. */
1795 if (SetupData.RepairUpdateFlag)
1796 {
1797 SetWindowResPrintfW(UiContext.hWndItem,
1798 SetupData.hInstance,
1799 IDS_COPYING, // STRING_COPYING
1800 DstFileName);
1801 }
1802 else
1803 {
1804 SetWindowTextW(UiContext.hWndItem, DstFileName);
1805 }
1806 }
1807 break;
1808 }
1809
1810 case SPFILENOTIFY_COPYERROR:
1811 {
1812 FilePathInfo = (PFILEPATHS_W)Param1;
1813
1814 DPRINT1("An error happened while trying to copy file '%S' (error 0x%08lx), skipping it...\n",
1815 FilePathInfo->Target, FilePathInfo->Win32Error);
1816 return FILEOP_SKIP;
1817 }
1818
1819 case SPFILENOTIFY_ENDDELETE:
1820 case SPFILENOTIFY_ENDRENAME:
1821 case SPFILENOTIFY_ENDCOPY:
1822 {
1823 CopyContext->CompletedOperations++;
1824
1825 /* SYSREG checkpoint */
1826 if (CopyContext->TotalOperations >> 1 == CopyContext->CompletedOperations)
1827 DPRINT1("CHECKPOINT:HALF_COPIED\n");
1828
1829 SendMessageW(UiContext.hWndProgress, PBM_STEPIT, 0, 0);
1830 break;
1831 }
1832 }
1833
1834 return FILEOP_DOIT;
1835}
1836
1837static VOID
1838__cdecl
1839RegistryStatus(IN REGISTRY_STATUS RegStatus, ...)
1840{
1841 /* WARNING: Please keep this lookup table in sync with the resources! */
1842 static const UINT StringIDs[] =
1843 {
1844 IDS_REG_DONE, /* Success */
1845 IDS_REG_REGHIVEUPDATE, /* RegHiveUpdate */
1846 IDS_REG_IMPORTFILE, /* ImportRegHive */
1847 IDS_REG_DISPLAYSETTINGSUPDATE, /* DisplaySettingsUpdate */
1848 IDS_REG_LOCALESETTINGSUPDATE, /* LocaleSettingsUpdate */
1849 IDS_REG_ADDKBLAYOUTS, /* KeybLayouts */
1850 IDS_REG_KEYBOARDSETTINGSUPDATE, /* KeybSettingsUpdate */
1851 IDS_REG_CODEPAGEINFOUPDATE, /* CodePageInfoUpdate */
1852 };
1853
1854 if (RegStatus < _countof(StringIDs))
1855 {
1856 va_list args;
1857 va_start(args, RegStatus);
1858 SetWindowResPrintfVW(UiContext.hWndItem, SetupData.hInstance, StringIDs[RegStatus], args);
1859 va_end(args);
1860 }
1861 else
1862 {
1863 SetWindowResPrintfW(UiContext.hWndItem, SetupData.hInstance, IDS_REG_UNKNOWN, RegStatus);
1864 }
1865
1866 SendMessageW(UiContext.hWndProgress, PBM_STEPIT, 0, 0);
1867}
1868
1876VOID
1877PropSheet_SetCloseCancel(
1878 _In_ HWND hWndWiz,
1879 _In_ BOOL Enable)
1880{
1881 EnableDlgItem(hWndWiz, IDCANCEL, Enable);
1882 EnableMenuItem(GetSystemMenu(hWndWiz, FALSE),
1883 SC_CLOSE,
1884 MF_BYCOMMAND | (Enable ? MF_ENABLED : MF_GRAYED));
1885}
1886
1887#define PM_INSTALL_START (WM_APP + 1)
1888#define PM_INSTALL_DONE (WM_APP + 2)
1889
1890static DWORD
1891WINAPI
1892PrepareAndDoCopyThread(
1893 IN LPVOID Param)
1894{
1895 PSETUPDATA pSetupData;
1896 HWND hwndDlg = (HWND)Param;
1897 HWND hWndParent = GetParent(hwndDlg);
1898 HWND hWndProgress;
1899 LONG_PTR dwStyle;
1900 ERROR_NUMBER ErrorNumber;
1901 BOOLEAN Success;
1902 NTSTATUS Status;
1903 FSVOL_CONTEXT FsVolContext;
1904 COPYCONTEXT CopyContext;
1905 WCHAR PathBuffer[RTL_NUMBER_OF_FIELD(PARTENTRY, DeviceName) + 1];
1906
1907 /* Retrieve pointer to the global setup data */
1908 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
1909
1910 /* Get the progress handle */
1911 hWndProgress = GetDlgItem(hwndDlg, IDC_PROCESSPROGRESS);
1912
1913 /* Setup global UI context */
1914 UiContext.hwndDlg = hwndDlg;
1915 UiContext.hWndItem = GetDlgItem(hwndDlg, IDC_ITEM);
1916 UiContext.hWndProgress = hWndProgress;
1917 UiContext.dwPbStyle = 0;
1918
1919
1920 /* Disable the Close/Cancel buttons during all partition operations */
1921 // TODO: Consider, alternatively, to just show an info-box saying
1922 // that the installation process cannot be canceled at this stage?
1923 PropSheet_SetCloseCancel(hWndParent, FALSE);
1924
1925
1926 /*
1927 * Find/Set the system partition, and apply all pending partition operations.
1928 */
1929
1930 /* Create context for the volume/partition operations */
1931 FsVolContext.pSetupData = pSetupData;
1932
1933 /* Set status text */
1934 SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
1935 pSetupData->hInstance,
1936 IDS_CONFIG_SYSTEM_PARTITION);
1937 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
1938
1939 /* Find or set the active system partition before starting formatting */
1940 Success = InitSystemPartition(pSetupData->PartitionList,
1941 InstallPartition,
1942 &SystemPartition,
1943 FsVolCallback,
1944 &FsVolContext);
1945 // if (!Success)
1946 // return FsVolContext.NextPageOnAbort;
1947 //
1948 // FIXME?? If cannot use any system partition, install FreeLdr on floppy / removable media??
1949 //
1950 if (!Success)
1951 {
1952 /* Display an error if an unexpected failure happened */
1953 MessageBoxW(hWndParent, L"Failed to find or set the system partition!", NULL, MB_ICONERROR);
1954
1955 /* Re-enable the Close/Cancel buttons */
1956 PropSheet_SetCloseCancel(hWndParent, TRUE);
1957 goto Quit;
1958 }
1959
1960
1961 /* Set status text */
1962 SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
1963 pSetupData->hInstance,
1964 IDS_PREPARE_PARTITIONS);
1965 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
1966
1967 /* Apply all pending operations on partitions: formatting and checking */
1968 Success = FsVolCommitOpsQueue(pSetupData->PartitionList,
1969 SystemVolume,
1970 InstallVolume,
1971 FsVolCallback,
1972 &FsVolContext);
1973 if (!Success)
1974 {
1975 /* Display an error if an unexpected failure happened */
1976 MessageBoxW(hWndParent, L"Failed to prepare the partitions!", NULL, MB_ICONERROR);
1977
1978 /* Re-enable the Close/Cancel buttons */
1979 PropSheet_SetCloseCancel(hWndParent, TRUE);
1980 goto Quit;
1981 }
1982
1983
1984 /* Re-enable the Close/Cancel buttons */
1985 PropSheet_SetCloseCancel(hWndParent, TRUE);
1986
1987
1988 /* Re-calculate the final destination paths */
1989 ASSERT(InstallPartition);
1990 Status = InitDestinationPaths(&pSetupData->USetupData,
1991 NULL, // pSetupData->USetupData.InstallationDirectory,
1992 InstallVolume);
1993 Success = NT_SUCCESS(Status);
1994 if (!Success)
1995 {
1996 DisplayMessage(hWndParent, MB_ICONERROR, NULL, L"InitDestinationPaths() failed with status 0x%08lx\n", Status);
1997 goto Quit;
1998 }
1999
2000
2001 /*
2002 * Preparation of the list of files to be copied
2003 */
2004
2005 /* Set status text */
2006 SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
2007 pSetupData->hInstance,
2008 IDS_PREPARE_FILES);
2009 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
2010
2011 /* Set progress marquee style and start it up */
2012 dwStyle = GetWindowLongPtrW(hWndProgress, GWL_STYLE);
2013 SetWindowLongPtrW(hWndProgress, GWL_STYLE, dwStyle | PBS_MARQUEE);
2014 SendMessageW(hWndProgress, PBM_SETMARQUEE, TRUE, 0);
2015
2016 /* Prepare the list of files */
2017 /* ErrorNumber = */ Success = PrepareFileCopy(&pSetupData->USetupData, NULL);
2018
2019 /* Stop progress and restore its style */
2020 SendMessageW(hWndProgress, PBM_SETMARQUEE, FALSE, 0);
2021 SetWindowLongPtrW(hWndProgress, GWL_STYLE, dwStyle);
2022
2023 if (/*ErrorNumber != ERROR_SUCCESS*/ !Success)
2024 {
2025 /* Display an error only if an unexpected failure happened, and not because the user cancelled the installation */
2026 if (!pSetupData->bAbortInstall)
2027 MessageBoxW(hWndParent, L"Failed to prepare the list of files!", NULL, MB_ICONERROR);
2028 goto Quit;
2029 }
2030
2031
2032 /*
2033 * Perform the file copy
2034 */
2035
2036 /* Set status text */
2037 SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
2038 pSetupData->hInstance,
2039 IDS_COPYING_FILES);
2040 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
2041
2042 /* Create context for the copy process */
2043 CopyContext.pSetupData = pSetupData;
2044 CopyContext.TotalOperations = 0;
2045 CopyContext.CompletedOperations = 0;
2046
2047 /* Do the file copying - The callback handles whether or not we should stop file copying */
2048 Success = DoFileCopy(&pSetupData->USetupData, FileCopyCallback, &CopyContext);
2049 if (!Success)
2050 {
2051 /* Display an error only if an unexpected failure happened, and not because the user cancelled the installation */
2052 if (!pSetupData->bAbortInstall)
2053 MessageBoxW(hWndParent, L"Failed to copy the files!", NULL, MB_ICONERROR);
2054 goto Quit;
2055 }
2056
2057 // /* Set status text */
2058 // SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
2059 // pSetupData->hInstance,
2060 // IDS_INSTALL_FINALIZE);
2061 // SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
2062
2063 /* Create the $winnt$.inf file */
2064 InstallSetupInfFile(&pSetupData->USetupData);
2065
2066
2067 /* Disable the Close/Cancel buttons for the remaining non-cancellable operations */
2068 // TODO: Consider, alternatively, to just show an info-box saying
2069 // that the installation process cannot be canceled at this stage?
2070 PropSheet_SetCloseCancel(hWndParent, FALSE);
2071
2072 /*
2073 * Create or update the registry hives
2074 */
2075
2076 /* Set status text */
2077 SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
2078 pSetupData->hInstance,
2079 pSetupData->RepairUpdateFlag ? IDS_UPDATE_REGISTRY
2080 : IDS_CREATE_REGISTRY);
2081 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
2082
2083 /* Set up the progress bar */
2084 SendMessageW(hWndProgress,
2085 PBM_SETRANGE, 0,
2086 MAKELPARAM(0, 8)); // FIXME: hardcoded number of steps, see StringIDs[] array in RegistryStatus()
2087 SendMessageW(hWndProgress,
2088 PBM_SETSTEP, 1, 0);
2089 SendMessageW(hWndProgress,
2090 PBM_SETPOS, 0, 0);
2091
2092 ErrorNumber = UpdateRegistry(&pSetupData->USetupData,
2093 pSetupData->RepairUpdateFlag,
2094 pSetupData->PartitionList,
2095 InstallVolume->Info.DriveLetter,
2096 pSetupData->SelectedLanguageId,
2097 RegistryStatus,
2098 NULL /* SubstSettings */);
2099 DBG_UNREFERENCED_PARAMETER(ErrorNumber);
2100 SendMessageW(UiContext.hWndProgress, PBM_SETPOS, 100, 0);
2101
2102 /*
2103 * And finally, install the bootloader
2104 */
2105
2106 /* Set status text */
2107 SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
2108 pSetupData->hInstance,
2109 IDS_INSTALL_BOOTLOADER);
2110 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
2111
2112 RtlFreeUnicodeString(&pSetupData->USetupData.SystemRootPath);
2113 StringCchPrintfW(PathBuffer, _countof(PathBuffer),
2114 L"%s\\", SystemPartition->DeviceName);
2115 RtlCreateUnicodeString(&pSetupData->USetupData.SystemRootPath, PathBuffer);
2116 DPRINT1("SystemRootPath: %wZ\n", &pSetupData->USetupData.SystemRootPath);
2117
2118 switch (pSetupData->USetupData.BootLoaderLocation)
2119 {
2120 /* Install on removable disk */
2121 case 1:
2122 {
2123 // TODO: So far SETUP only supports the 1st floppy.
2124 // Use a simple UI like comdlg32's DlgDirList* to show
2125 // a list of drives that the user could select.
2126 static const UNICODE_STRING FloppyDrive = RTL_CONSTANT_STRING(L"\\Device\\Floppy0\\");
2127 static const WCHAR DriveLetter = L'A';
2128
2129 INT nRet;
2130 RetryCancel:
2131 nRet = DisplayMessage(hWndParent,
2132 MB_ICONINFORMATION | MB_OKCANCEL,
2133 L"Bootloader installation",
2134 L"Please insert a blank floppy disk in drive %c: .\n"
2135 L"All data in the floppy disk will be erased!\n"
2136 L"\nClick on OK to continue."
2137 L"\nClick on CANCEL to skip bootloader installation.",
2138 DriveLetter);
2139 if (nRet != IDOK)
2140 break; /* Skip installation */
2141
2142 Retry:
2143 Status = InstallBootcodeToRemovable(pSetupData->USetupData.ArchType,
2144 &FloppyDrive,
2145 &pSetupData->USetupData.SourceRootPath,
2146 &pSetupData->USetupData.DestinationArcPath);
2147 if (Status == STATUS_SUCCESS)
2148 break; /* Successful installation */
2149
2150 if (Status == STATUS_DEVICE_NOT_READY)
2151 {
2152 // ERROR_NO_FLOPPY
2153 nRet = DisplayMessage(hWndParent,
2154 MB_ICONWARNING | MB_RETRYCANCEL,
2155 NULL, // Default to "Error"
2156 L"No disk detected in drive %c: .",
2157 DriveLetter);
2158 if (nRet == IDRETRY)
2159 goto Retry;
2160 }
2161 else if ((Status == ERROR_WRITE_BOOT) ||
2162 (Status == ERROR_INSTALL_BOOTCODE))
2163 {
2164 /* Error when writing the boot code */
2165 DisplayError(hWndParent,
2166 0, // Default to "Error"
2167 IDS_ERROR_INSTALL_BOOTCODE_REMOVABLE);
2168 }
2169 else if (!NT_SUCCESS(Status))
2170 {
2171 /* Any other NTSTATUS failure code */
2172 DPRINT1("InstallBootcodeToRemovable() failed: Status 0x%lx\n", Status);
2173 DisplayError(hWndParent,
2174 0, // Default to "Error"
2175 IDS_ERROR_BOOTLDR_FAILED,
2176 Status);
2177 }
2178 goto RetryCancel;
2179 }
2180
2181 /* Install on hard-disk */
2182 case 2: // System partition / MBR and VBR (on BIOS-based PC)
2183 case 3: // VBR only (on BIOS-based PC)
2184 {
2185 /* Copy FreeLoader to the disk and save the boot entries */
2186 Status = InstallBootManagerAndBootEntries(
2187 pSetupData->USetupData.ArchType,
2188 &pSetupData->USetupData.SystemRootPath,
2189 &pSetupData->USetupData.SourceRootPath,
2190 &pSetupData->USetupData.DestinationArcPath,
2191 (pSetupData->USetupData.BootLoaderLocation == 2)
2192 ? 1 /* Install MBR and VBR */
2193 : 0 /* Install VBR only */);
2194 if (Status == STATUS_SUCCESS)
2195 break; /* Successful installation */
2196
2197 if (Status == ERROR_WRITE_BOOT)
2198 {
2199 /* Error when writing the VBR */
2200 DisplayError(hWndParent,
2201 0, // Default to "Error"
2202 IDS_ERROR_WRITE_BOOT,
2203 SystemVolume->Info.FileSystem);
2204 }
2205 else if (Status == ERROR_INSTALL_BOOTCODE)
2206 {
2207 /* Error when writing the MBR */
2208 DisplayError(hWndParent,
2209 0, // Default to "Error"
2210 IDS_ERROR_INSTALL_BOOTCODE,
2211 L"MBR");
2212 }
2213 else if (Status == STATUS_NOT_SUPPORTED)
2214 {
2215 DisplayError(hWndParent,
2216 0, // Default to "Error"
2217 IDS_ERROR_BOOTLDR_ARCH_UNSUPPORTED);
2218 }
2219 else if (!NT_SUCCESS(Status))
2220 {
2221 /* Any other NTSTATUS failure code */
2222 DPRINT1("InstallBootManagerAndBootEntries() failed: Status 0x%lx\n", Status);
2223 DisplayError(hWndParent,
2224 0, // Default to "Error"
2225 IDS_ERROR_BOOTLDR_FAILED,
2226 Status);
2227 }
2228 Success = FALSE;
2229 goto Quit;
2230 }
2231
2232 /* Skip installation */
2233 case 0:
2234 default:
2235 break;
2236 }
2237
2238Quit:
2239 /* Signal the wizard page that we have succeeded or failed */
2240 PostMessage(hwndDlg, PM_INSTALL_DONE, Success, 0); // Status
2241 return Success;
2242}
2243
2244// TODO: Determine later which method is the best.
2245//#define TERMINATE_USE_PRESSBUTTON
2246
2247static INT_PTR CALLBACK
2248ProcessDlgProc(
2249 IN HWND hwndDlg,
2250 IN UINT uMsg,
2251 IN WPARAM wParam,
2252 IN LPARAM lParam)
2253{
2254 PSETUPDATA pSetupData;
2255
2256 /* Retrieve pointer to the global setup data */
2257 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
2258
2259 switch (uMsg)
2260 {
2261 case WM_INITDIALOG:
2262 {
2263 /* Save pointer to the global setup data */
2264 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGEW)lParam)->lParam;
2265 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
2266
2267 /* Reset the status text and set the main label in bold */
2268 SetDlgItemTextW(hwndDlg, IDC_ACTIVITY, L"");
2269 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
2270 SetDlgItemFont(hwndDlg, IDC_ACTIVITY, pSetupData->hBoldFont, TRUE);
2271 break;
2272 }
2273
2274 case WM_SETCURSOR:
2275 {
2276 /* Set a page-wide cursor */
2277 if (!hWaitCursor)
2278 break;
2279 SetCursor(hWaitCursor);
2280 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
2281 return TRUE;
2282 }
2283
2284 case WM_NOTIFY:
2285 {
2286 LPNMHDR lpnm = (LPNMHDR)lParam;
2287
2288 switch (lpnm->code)
2289 {
2290 case PSN_SETACTIVE:
2291 {
2292 HWND hWndParent = GetParent(hwndDlg);
2293
2294 /*
2295 * Disable all buttons during installation, and hide "Back" and "Next".
2296 * Don't use the PropSheet_SetWizButtons() macro, because its
2297 * posted message would be handled after hiding the buttons.
2298 * The message would then interfere with the hidden buttons
2299 * (when both "Back" and "Next" are hidden, "Next" gets forcefully shown).
2300 */
2301 SendMessageW(hWndParent, PSM_SETWIZBUTTONS, 0, 0);
2302 // PropSheet_ShowWizButtons(hWndParent, 0, PSWIZB_BACK | PSWIZB_NEXT);
2303 ShowDlgItem(hWndParent, ID_WIZBACK, SW_HIDE);
2304 ShowDlgItem(hWndParent, ID_WIZNEXT, SW_HIDE);
2305
2306 /* Start the installation procedure once the page is fully displayed */
2307 PostMessageW(hwndDlg, PM_INSTALL_START, 0, 0);
2308 break;
2309 }
2310
2311 case PSN_KILLACTIVE:
2312 {
2313 /* Avoid reentrant calls caused by the message dispatching
2314 * done below: allow only the first page change, and ignore
2315 * all the others. */
2316 if (InterlockedFlagsTestAndSet8(&pSetupData->bStopInstall,
2317 SETUP_PAGE_SWITCHING))
2318 {
2319 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
2320 return TRUE;
2321 }
2322
2323 /* If no installation is running, just change the page */
2324 if (!pSetupData->hInstallThread)
2325 break;
2326
2327 /* Wait for the installation thread to terminate.
2328 * Since we dispatch messages in the meantime, we must
2329 * guard the property sheet notification handlers from
2330 * being invoked multiple times. */
2331 DWORD dwStatus = WaitForSingleObject(pSetupData->hInstallThread, 0);
2332 if (dwStatus == WAIT_TIMEOUT)
2333 {
2334 /* Show the hourglass cursor */
2335 HCURSOR hOldCursor;
2336 hWaitCursor = LoadCursor(NULL, IDC_WAIT);
2337 hOldCursor = SetCursor(hWaitCursor);
2338 ShowCursor(TRUE);
2339
2340 for (;;)
2341 {
2342 MSG msg;
2343 dwStatus = MsgWaitForMultipleObjects(1, &pSetupData->hInstallThread,
2344 FALSE, INFINITE,
2345 QS_ALLINPUT | QS_ALLPOSTMESSAGE);
2346 if (dwStatus != (WAIT_OBJECT_0 + 1))
2347 break; // Stop if anything else (thread terminated, timeout or failure).
2348
2349 /* We still need to process main window messages to avoid freeze */
2350 while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
2351 {
2352 TranslateMessage(&msg);
2353 DispatchMessageW(&msg);
2354 }
2355 }
2356
2357 /* Restore the old cursor */
2358 ShowCursor(FALSE);
2359 SetCursor(hOldCursor);
2360 hWaitCursor = NULL;
2361 }
2362#if 0 && DBG
2363 if (dwStatus == WAIT_OBJECT_0)
2364 {
2365 DWORD dwExitCode = NO_ERROR;
2366 GetExitCodeThread(pSetupData->hInstallThread, &dwExitCode);
2367 DBG_UNREFERENCED_PARAMETER(dwExitCode);
2368 }
2369#endif
2370 /* Cleanup; we can now change the page */
2371 CloseHandle(pSetupData->hInstallThread);
2372 pSetupData->hInstallThread = NULL;
2373 CloseHandle(pSetupData->hHaltInstallEvent);
2374 pSetupData->hHaltInstallEvent = NULL;
2375 break;
2376 }
2377
2378 case PSN_QUERYCANCEL:
2379 {
2380 INT nRet;
2381
2382 if (pSetupData->bStopInstall)
2383 {
2384 /* The installation is terminating (either successfully,
2385 * or cancelled by the user or due to an error), ignore all
2386 * new requests since this is now too late to change bets. */
2387 nRet = IDYES;
2388 }
2389 else
2390 {
2391 /* Halt the on-going file copy */
2392 ResetEvent(pSetupData->hHaltInstallEvent);
2393
2394 nRet = DisplayMessage(GetParent(hwndDlg),
2395 MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
2396 MAKEINTRESOURCEW(IDS_ABORTSETUP2),
2397 MAKEINTRESOURCEW(IDS_ABORTSETUP));
2398 if (nRet == IDYES)
2399 {
2400 /* Signal the file copy thread to stop */
2401 InterlockedOr8((PCHAR)&pSetupData->bStopInstall, SETUP_ABORT_INSTALL);
2402 }
2403 /* else, we don't stop installation, resume file copy */
2404 SetEvent(pSetupData->hHaltInstallEvent);
2405 }
2406
2407 /* If we are not already in the process of cancelling
2408 * the installation or switching to a page, do it now. */
2409 if ((nRet == IDYES) && !pSetupData->bPageSwitching &&
2410 !InterlockedFlagsTestAndSet8(&pSetupData->bStopInstall,
2411 SETUP_IS_CANCELLING))
2412 {
2413 /* Go to the Abort page */
2414#ifdef TERMINATE_USE_PRESSBUTTON
2415 PropSheet_SetCloseCancel(GetParent(hwndDlg), FALSE);
2416 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_ABORTPAGE);
2417#else
2418 PostMessageW(hwndDlg, PM_INSTALL_DONE, FALSE, 0);
2419#endif
2420 }
2421
2422 /* Do not close the wizard too soon */
2423 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
2424 return TRUE;
2425 }
2426
2427 case PSN_WIZBACK:
2428 /* Always disable going back */
2429 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
2430 return TRUE;
2431
2432 case PSN_WIZNEXT:
2433 {
2434#ifdef TERMINATE_USE_PRESSBUTTON
2435 LONG_PTR nNextPage = (!pSetupData->bAbortInstall ? IDD_FINISHPAGE : IDD_ABORTPAGE);
2436 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, nNextPage);
2437#else
2438 /* Always disable going next */
2439 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
2440#endif
2441 return TRUE;
2442 }
2443
2444 default:
2445 break;
2446 }
2447 break;
2448 }
2449
2450 case PM_INSTALL_START:
2451 {
2452 HWND hWndParent = GetParent(hwndDlg);
2453
2454 ASSERT(pSetupData->hInstallThread == NULL);
2455
2456 /* Force repainting first to make sure the wizard is visible */
2457 InvalidateRect(hWndParent, NULL, FALSE);
2458 UpdateWindow(hWndParent);
2459
2460 /* Create the file-copy halt (manual-reset) event */
2461 pSetupData->hHaltInstallEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
2462 if (!pSetupData->hHaltInstallEvent)
2463 {
2464 DisplayMessage(hWndParent, MB_ICONERROR, NULL,
2465 L"Cannot create the install event, error %lu\n", GetLastError());
2466 goto Fail;
2467 }
2468 /* Start the installation thread */
2469 pSetupData->bStopInstall = FALSE;
2470 pSetupData->hInstallThread = CreateThread(NULL, 0,
2471 PrepareAndDoCopyThread,
2472 (PVOID)hwndDlg,
2473 0, NULL);
2474 if (!pSetupData->hInstallThread)
2475 {
2476 DisplayMessage(hWndParent, MB_ICONERROR, NULL,
2477 L"Cannot create the installation thread, error %lu\n", GetLastError());
2478 CloseHandle(pSetupData->hHaltInstallEvent);
2479 pSetupData->hHaltInstallEvent = NULL;
2480 Fail:
2481 /* Cancel the installation */
2482 InterlockedOr8((PCHAR)&pSetupData->bStopInstall, SETUP_ABORT_INSTALL);
2483#ifdef TERMINATE_USE_PRESSBUTTON
2484 PropSheet_SetCloseCancel(hWndParent, FALSE);
2485 PropSheet_PressButton(hWndParent, PSBTN_CANCEL);
2486#else
2487 SendMessageW(hwndDlg, PM_INSTALL_DONE, FALSE, 0);
2488#endif
2489 }
2490 break;
2491 }
2492
2493 case PM_INSTALL_DONE:
2494 {
2495 HWND hWndParent = GetParent(hwndDlg);
2496 BOOL Success = !!wParam;
2497 BOOL AutoSwitchPage = TRUE;
2498
2499 /* If an unexpected error happened, stay on the copy page to allow
2500 * the user to view the current state, and keep the Close/Cancel
2501 * buttons to allow going to the Abort page.
2502 * Otherwise, we have been manually cancelled by the user and we
2503 * will directly switch to the Abort page. */
2504 if (!Success && !pSetupData->bStopInstall)
2505 {
2506 PropSheet_SetCloseCancel(hWndParent, TRUE);
2507 AutoSwitchPage = FALSE;
2508 }
2509 else
2510 {
2511 /* Disable the Close/Cancel buttons, since the installation has
2512 * either successfully terminated, or was already cancelled by
2513 * the user. */
2514 PropSheet_SetCloseCancel(hWndParent, FALSE);
2515 }
2516
2517 if (!Success)
2518 {
2519 /* The installation was aborted */
2520 InterlockedOr8((PCHAR)&pSetupData->bStopInstall, SETUP_ABORT_INSTALL);
2521 }
2522 else if (pSetupData->bAbortInstall)
2523 {
2524 /* Override success in case the thread just terminated with some status
2525 * while at the same time, the user chose to cancel the installation */
2526 Success = FALSE;
2527 }
2528
2529 /* We are done! Switch to the Finish or the Abort page */
2530 if (!AutoSwitchPage)
2531 break;
2532 // TODO: if (!Success): Unwind installation.
2533#ifdef TERMINATE_USE_PRESSBUTTON
2534 // NOTE: In this case, PSN_QUERYCANCEL **CANNOT** call PM_INSTALL_DONE
2535 PropSheet_PressButton(hWndParent, Success ? PSBTN_NEXT : PSBTN_CANCEL);
2536#else
2537 if (!Success)
2538 InterlockedOr8((PCHAR)&pSetupData->bStopInstall, SETUP_IS_CANCELLING);
2539 PropSheet_SetCurSelByID(hWndParent, Success ? IDD_FINISHPAGE : IDD_ABORTPAGE);
2540#endif
2541 break;
2542 }
2543
2544 default:
2545 break;
2546 }
2547
2548 return FALSE;
2549}
2550
2551
2555static BOOL
2556IsShellActive(VOID)
2557{
2558/* See reactos/undocuser.h */
2559extern HWND WINAPI GetProgmanWindow(VOID);
2560
2561 /* Return success if a shell window is present, valid, and interactive */
2562 HWND hWndProgman = GetProgmanWindow();
2563 if (!(hWndProgman && IsWindow(hWndProgman) &&
2564 IsWindowEnabled(hWndProgman) && IsWindowVisible(hWndProgman)))
2565 {
2566 hWndProgman = GetShellWindow();
2567 }
2568 return (hWndProgman && IsWindow(hWndProgman) &&
2569 IsWindowEnabled(hWndProgman) && IsWindowVisible(hWndProgman));
2570}
2571
2572typedef struct _CLOSABLE_WND_INFO
2573{
2574 HWND hWndExclude;
2575 BOOL Found;
2576} CLOSABLE_WND_INFO, *PCLOSABLE_WND_INFO;
2577static BOOL
2578CALLBACK
2579FindUserClosableWindowProc(
2580 _In_ HWND hWnd,
2581 _In_ LPARAM lParam)
2582{
2583 PCLOSABLE_WND_INFO pInfo = (PCLOSABLE_WND_INFO)lParam;
2584 HMENU hSysMenu;
2585 MENUITEMINFOW mii;
2586
2587 /* Skip the window to exclude */
2588 if (hWnd == pInfo->hWndExclude)
2589 return TRUE;
2590
2591 /* Skip non-interactive windows */
2592 if (!IsWindowEnabled(hWnd) || !IsWindowVisible(hWnd))
2593 return TRUE;
2594
2595 hSysMenu = GetSystemMenu(hWnd, FALSE);
2596 if (!hSysMenu)
2597 return TRUE; /* No menu: skip the window */
2598
2599 mii.cbSize = sizeof(mii);
2600 mii.fMask = MIIM_STATE;
2601 if (!GetMenuItemInfoW(hSysMenu, SC_CLOSE, FALSE, &mii))
2602 return TRUE; /* No close item: skip the window */
2603
2604 pInfo->Found |= !(mii.fState & MFS_DISABLED);
2605
2606 /* Continue enumeration (return TRUE) if no close item is enabled;
2607 * otherwise stop the enumeration (return FALSE) */
2608 return !pInfo->Found;
2609}
2613static BOOL
2614AreThereInteractiveWindows(
2615 _In_opt_ HWND hWndExclude)
2616{
2617 /* Return success if a shell is active */
2618 if (IsShellActive())
2619 {
2620 return TRUE;
2621 }
2622 /* Otherwise, check for user-interactive closable windows */
2623 else
2624 {
2625 CLOSABLE_WND_INFO Info = {hWndExclude, FALSE};
2626 EnumWindows(FindUserClosableWindowProc, (LPARAM)&Info);
2627 return Info.Found;
2628 }
2629}
2630
2631static INT_PTR CALLBACK
2632FinishDlgProc(
2633 IN HWND hwndDlg,
2634 IN UINT uMsg,
2635 IN WPARAM wParam,
2636 IN LPARAM lParam)
2637{
2638 PSETUPDATA pSetupData;
2639
2640 /* Retrieve pointer to the global setup data */
2641 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
2642
2643 switch (uMsg)
2644 {
2645 case WM_INITDIALOG:
2646 {
2647 HWND hWndParent = GetParent(hwndDlg);
2648 LPPROPSHEETPAGEW ppsp = (LPPROPSHEETPAGEW)lParam;
2649
2650 /* Save pointer to the global setup data */
2651 pSetupData = (PSETUPDATA)ppsp->lParam;
2652 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
2653
2654 /* Set the stop-install flag if the user is aborting
2655 * the installation: TRUE if Abort, FALSE if Finish. */
2656 pSetupData->bStopInstall = (ppsp->pszTemplate == MAKEINTRESOURCEW(IDD_ABORTPAGE));
2657
2658 /* Set title font */
2659 SetDlgItemFont(hwndDlg, IDC_FINISHTITLE, pSetupData->hTitleFont, TRUE);
2660
2661 /* We need to reboot at the end of the installation if this is an
2662 * unattended setup, or if there is no shell active. If there are
2663 * other user-interactive windows opened, we pause in WM_ACTIVATE
2664 * the inevitable reboot countdown when the wizard is deactivated,
2665 * and restart it when the wizard is reactivated. */
2666 pSetupData->bMustReboot = SetupData.bUnattend;
2667 pSetupData->bMustReboot |= !IsShellActive();
2668
2669 /* If we must reboot, display the countdown gauge. In any
2670 * case, let the user restart now or postpone it to later. */
2671 if (pSetupData->bMustReboot)
2672 {
2673 /* "Setup will now restart your computer..." is shown */
2674 EnableDlgItem(hwndDlg, IDC_RESTART_PROGRESS, TRUE);
2675 ShowDlgItem(hwndDlg, IDC_RESTART_PROGRESS, SW_SHOW);
2676 }
2677 else
2678 {
2679 /* We should not reboot automatically, change the finish
2680 * text to "Setup needs to restart your computer..." */
2681 UINT uMsgID = (!pSetupData->bStopInstall ? IDS_FINISH_NO_REBOOT
2682 : IDS_ABORT_NO_REBOOT);
2683 SetWindowResTextW(GetDlgItem(hwndDlg, IDC_FINISHTEXT),
2684 pSetupData->hInstance,
2685 uMsgID);
2686
2687 /* Hide and disable the countdown gauge */
2688 EnableDlgItem(hwndDlg, IDC_RESTART_PROGRESS, FALSE);
2689 ShowDlgItem(hwndDlg, IDC_RESTART_PROGRESS, SW_HIDE);
2690 }
2691
2692 /* Ensure that the wizard window is centered, made visible, and focused */
2693 CenterWindow(hWndParent);
2694 ShowWindow(hWndParent, SW_SHOW);
2695 SwitchToThisWindow(hWndParent, TRUE);
2696 return TRUE;
2697 }
2698
2699 case WM_ACTIVATE:
2700 {
2701 /* Only care about (de)activation only if we must reboot */
2702 if (!pSetupData->bMustReboot)
2703 break;
2704
2705 if (LOWORD(wParam) == WA_INACTIVE)
2706 {
2707 /* Wizard window is deactivated, check whether there are
2708 * interactive windows. If so, pause the countdown. */
2709 if (AreThereInteractiveWindows(GetParent(hwndDlg)))
2710 KillTimer(hwndDlg, 1);
2711 }
2712 else
2713 {
2714 /* Wizard window is reactivated, re-enable the countdown */
2715 SetTimer(hwndDlg, 1, 50, NULL);
2716 }
2717 break;
2718 }
2719
2720 case WM_TIMER:
2721 {
2722 HWND hWndProgress;
2723 INT Position;
2724
2725 hWndProgress = GetDlgItem(hwndDlg, IDC_RESTART_PROGRESS);
2726 Position = SendMessageW(hWndProgress, PBM_GETPOS, 0, 0);
2727 if (Position == 300)
2728 {
2729 KillTimer(hwndDlg, 1);
2730 PropSheet_PressButton(GetParent(hwndDlg), PSBTN_FINISH);
2731 }
2732 else
2733 {
2734 SendMessageW(hWndProgress, PBM_SETPOS, Position + 1, 0);
2735 }
2736 return TRUE;
2737 }
2738
2739 case WM_NOTIFY:
2740 {
2741 LPNMHDR lpnm = (LPNMHDR)lParam;
2742
2743 switch (lpnm->code)
2744 {
2745 case PSN_SETACTIVE:
2746 {
2747 HWND hWndParent = GetParent(hwndDlg);
2748
2749 /*
2750 * Only "Finish" for closing the wizard, and hide "Back" and "Next".
2751 * Don't use the PropSheet_SetWizButtons() macro, because its
2752 * posted message would be handled after hiding the buttons.
2753 * The message would then interfere with the hidden buttons
2754 * (when both "Back" and "Next" are hidden, "Next" gets forcefully shown).
2755 */
2756 SendMessageW(hWndParent, PSM_SETWIZBUTTONS, 0, PSWIZB_FINISH);
2757 // PropSheet_ShowWizButtons(hWndParent, 0, PSWIZB_BACK | PSWIZB_NEXT | PSWIZB_CANCEL);
2758 ShowDlgItem(hWndParent, ID_WIZBACK, SW_HIDE);
2759 ShowDlgItem(hWndParent, ID_WIZNEXT, SW_HIDE);
2760
2761 /* Change the "Finish" button text to "Restart" */
2762 SetWindowResTextW(GetDlgItem(hWndParent, ID_WIZFINISH),
2763 pSetupData->hInstance,
2764 IDS_RESTARTBTN);
2765
2766 /* Re-enable the Close/Cancel buttons if we won't reboot */
2767 if (!pSetupData->bMustReboot)
2768 PropSheet_SetCloseCancel(hWndParent, TRUE);
2769
2770 if (pSetupData->bMustReboot)
2771 {
2772 RECT rcBtn1, rcBtn2;
2773
2774 /* Move the "Finish"/"Restart" button to where the "Cancel" button is */
2775 GetWindowRect(GetDlgItem(hWndParent, ID_WIZFINISH), &rcBtn1);
2776 MapWindowPoints(HWND_DESKTOP /*NULL*/, hWndParent, (LPPOINT)&rcBtn1, sizeof(RECT)/sizeof(POINT));
2777 GetWindowRect(GetDlgItem(hWndParent, IDCANCEL), &rcBtn2);
2778 MapWindowPoints(HWND_DESKTOP /*NULL*/, hWndParent, (LPPOINT)&rcBtn2, sizeof(RECT)/sizeof(POINT));
2779 SetWindowPos(GetDlgItem(hWndParent, ID_WIZFINISH),
2780 HWND_TOP,
2781 rcBtn1.left + (rcBtn2.right - rcBtn1.right),
2782 rcBtn1.top,
2783 0, 0,
2784 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
2785
2786 /* Hide and disable also the "Cancel" buttons since we can only finish now */
2787 ShowDlgItem(hWndParent, IDCANCEL, SW_HIDE);
2788 PropSheet_SetCloseCancel(hWndParent, FALSE);
2789
2790 /* Set up the reboot progress bar and countdown timer.
2791 * 300 steps at 50 ms each: 15 seconds */
2792 SendDlgItemMessage(hwndDlg, IDC_RESTART_PROGRESS, PBM_SETRANGE, 0, MAKELPARAM(0, 300));
2793 SendDlgItemMessage(hwndDlg, IDC_RESTART_PROGRESS, PBM_SETPOS, 0, 0);
2794 SetTimer(hwndDlg, 1, 50, NULL);
2795 }
2796 else if (!pSetupData->bStopInstall)
2797 {
2798 /* Keep the "Cancel" button shown and change its text to "Postpone" */
2799 SetWindowResTextW(GetDlgItem(hWndParent, IDCANCEL),
2800 pSetupData->hInstance,
2801 IDS_POSTPONEBTN);
2802 }
2803 else // (!bMustReboot && bStopInstall)
2804 {
2805 /* The installation is aborted, change the "Cancel" button text to "Close" */
2806 SetWindowResTextW(GetDlgItem(hWndParent, IDCANCEL),
2807 GetModuleHandleW(L"comctl32.dll"),
2808 IDS_CLOSE);
2809 }
2810 break;
2811 }
2812
2813 case PSN_KILLACTIVE:
2814 KillTimer(hwndDlg, 1);
2815 break;
2816
2817 case PSN_WIZBACK:
2818 /* Always disable going back */
2819 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, -1);
2820 return TRUE;
2821
2822 case PSN_WIZNEXT:
2823 case PSN_WIZFINISH:
2824 {
2825 /* Press on "Finish"/"Restart" button */
2826 pSetupData->bMustReboot = TRUE;
2827 __fallthrough;
2828 }
2829 case PSN_QUERYCANCEL:
2830 /* Press on "Cancel"/"Postpone" button */
2831 default:
2832 break;
2833 }
2834 break;
2835 }
2836
2837 default:
2838 break;
2839 }
2840
2841 return FALSE;
2842}
2843
2844BOOL LoadSetupData(
2845 IN OUT PSETUPDATA pSetupData)
2846{
2847 pSetupData->PartitionList = CreatePartitionList();
2848 if (!pSetupData->PartitionList)
2849 {
2850 DPRINT1("Could not enumerate available disks; failing installation\n");
2851 return FALSE;
2852 }
2853
2854 pSetupData->NtOsInstallsList = CreateNTOSInstallationsList(pSetupData->PartitionList);
2855 if (!pSetupData->NtOsInstallsList)
2856 DPRINT1("Failed to get a list of NTOS installations; continue installation...\n");
2857
2858 /* Load the hardware, language and keyboard layout lists */
2859
2860 pSetupData->USetupData.ComputerList = CreateComputerTypeList(pSetupData->USetupData.SetupInf);
2861 pSetupData->USetupData.DisplayList = CreateDisplayDriverList(pSetupData->USetupData.SetupInf);
2862 pSetupData->USetupData.KeyboardList = CreateKeyboardDriverList(pSetupData->USetupData.SetupInf);
2863
2864 pSetupData->USetupData.LanguageList = CreateLanguageList(pSetupData->USetupData.SetupInf, pSetupData->DefaultLanguage);
2865
2866 /* If not unattended, overwrite language and locale with
2867 * the current ones of the running ReactOS instance */
2868 if (!IsUnattendedSetup)
2869 {
2870 LCID LocaleID = GetUserDefaultLCID();
2871
2872 StringCchPrintfW(pSetupData->DefaultLanguage,
2873 _countof(pSetupData->DefaultLanguage),
2874 L"%08lx", LocaleID);
2875
2876 StringCchPrintfW(pSetupData->USetupData.LocaleID,
2877 _countof(pSetupData->USetupData.LocaleID),
2878 L"%08lx", LocaleID);
2879 }
2880
2881 /* new part */
2882 pSetupData->SelectedLanguageId = pSetupData->DefaultLanguage;
2883 wcscpy(pSetupData->DefaultLanguage, pSetupData->USetupData.LocaleID); // FIXME: In principle, only when unattended.
2884 pSetupData->USetupData.LanguageId = (LANGID)(wcstol(pSetupData->SelectedLanguageId, NULL, 16) & 0xFFFF);
2885
2886 pSetupData->USetupData.LayoutList = CreateKeyboardLayoutList(pSetupData->USetupData.SetupInf,
2887 pSetupData->SelectedLanguageId,
2888 pSetupData->DefaultKBLayout);
2889
2890 /* If not unattended, overwrite keyboard layout with
2891 * the current one of the running ReactOS instance */
2892 if (!IsUnattendedSetup)
2893 {
2894 C_ASSERT(_countof(pSetupData->DefaultKBLayout) >= KL_NAMELENGTH);
2895 /* If the call fails, keep the default already stored in the buffer */
2896 GetKeyboardLayoutNameW(pSetupData->DefaultKBLayout);
2897 }
2898
2899 /* Change the default entries in the language and keyboard layout lists */
2900 {
2901 PGENERIC_LIST LanguageList = pSetupData->USetupData.LanguageList;
2902 PGENERIC_LIST LayoutList = pSetupData->USetupData.LayoutList;
2903 PGENERIC_LIST_ENTRY ListEntry;
2904
2905 /* Search for default language */
2906 for (ListEntry = GetFirstListEntry(LanguageList); ListEntry;
2907 ListEntry = GetNextListEntry(ListEntry))
2908 {
2909 PCWSTR LocaleId = ((PGENENTRY)GetListEntryData(ListEntry))->Id;
2910 if (!_wcsicmp(pSetupData->DefaultLanguage, LocaleId))
2911 {
2912 DPRINT("found %S in LanguageList\n", LocaleId);
2913 SetCurrentListEntry(LanguageList, ListEntry);
2914 break;
2915 }
2916 }
2917
2918 /* Search for default layout */
2919 for (ListEntry = GetFirstListEntry(LayoutList); ListEntry;
2920 ListEntry = GetNextListEntry(ListEntry))
2921 {
2922 PCWSTR pszLayoutId = ((PGENENTRY)GetListEntryData(ListEntry))->Id;
2923 // FIXME: Temporary "fix" to set the best keyboard entry depending on the
2924 // selected language in unattended setup; see also usetup!SetupStartPage().
2925 if (( pSetupData->bUnattend && !_wcsicmp(pSetupData->DefaultLanguage, pszLayoutId)) ||
2926 (!pSetupData->bUnattend && !_wcsicmp(pSetupData->DefaultKBLayout, pszLayoutId)))
2927 {
2928 DPRINT("Found %S in LayoutList\n", pszLayoutId);
2929 SetCurrentListEntry(LayoutList, ListEntry);
2930 break;
2931 }
2932 }
2933 }
2934
2935 return TRUE;
2936}
2937
2938VOID
2939InitNtToWin32PathMappingList(
2940 IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList)
2941{
2942 InitializeListHead(&MappingList->List);
2943 MappingList->MappingsCount = 0;
2944}
2945
2946VOID
2947FreeNtToWin32PathMappingList(
2948 IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList)
2949{
2950 PLIST_ENTRY ListEntry;
2951 PVOID Entry;
2952
2953 while (!IsListEmpty(&MappingList->List))
2954 {
2955 ListEntry = RemoveHeadList(&MappingList->List);
2956 Entry = (PVOID)CONTAINING_RECORD(ListEntry, NT_WIN32_PATH_MAPPING, ListEntry);
2957 HeapFree(ProcessHeap, 0, Entry);
2958 }
2959
2960 MappingList->MappingsCount = 0;
2961}
2962
2963/*
2964 * Attempts to convert a pure NT file path into a corresponding Win32 path.
2965 * Adapted from GetInstallSourceWin32() in dll/win32/syssetup/wizard.c
2966 */
2967BOOL
2968ConvertNtPathToWin32Path(
2969 IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList,
2970 OUT PWSTR pwszPath,
2971 IN DWORD cchPathMax,
2972 IN PCWSTR pwszNTPath)
2973{
2974 BOOL FoundDrive = FALSE, RetryOnce = FALSE;
2975 PLIST_ENTRY ListEntry;
2976 PNT_WIN32_PATH_MAPPING Entry;
2977 PCWSTR pwszNtPathToMap = pwszNTPath;
2978 PCWSTR pwszRemaining = NULL;
2979 DWORD cchDrives;
2980 PWCHAR pwszDrive;
2981 WCHAR wszDrives[512];
2982 WCHAR wszNTPath[MAX_PATH];
2983 WCHAR TargetPath[MAX_PATH];
2984
2985 *pwszPath = UNICODE_NULL;
2986
2987 /*
2988 * We find first a mapping inside the MappingList. If one is found, use it
2989 * to build the Win32 path. If there is none, we need to create one by
2990 * checking the Win32 drives (and possibly NT symlinks too).
2991 * In case of success, add the newly found mapping to the list and use it
2992 * to build the Win32 path.
2993 */
2994
2995 for (ListEntry = MappingList->List.Flink;
2996 ListEntry != &MappingList->List;
2997 ListEntry = ListEntry->Flink)
2998 {
2999 Entry = CONTAINING_RECORD(ListEntry, NT_WIN32_PATH_MAPPING, ListEntry);
3000
3001 DPRINT("Testing '%S' --> '%S'\n", Entry->Win32Path, Entry->NtPath);
3002
3003 /* Check whether the queried NT path prefixes the user-provided NT path */
3004 FoundDrive = !_wcsnicmp(pwszNtPathToMap, Entry->NtPath, wcslen(Entry->NtPath));
3005 if (FoundDrive)
3006 {
3007 /* Found it! */
3008
3009 /* Set the pointers and go build the Win32 path */
3010 pwszDrive = Entry->Win32Path;
3011 pwszRemaining = pwszNTPath + wcslen(Entry->NtPath);
3012 goto Quit;
3013 }
3014 }
3015
3016 /*
3017 * No mapping exists for this path yet: try to find one now.
3018 */
3019
3020 /* Retrieve the mounted drives (available drive letters) */
3021 cchDrives = GetLogicalDriveStringsW(_countof(wszDrives) - 1, wszDrives);
3022 if (cchDrives == 0 || cchDrives >= _countof(wszDrives))
3023 {
3024 /* Buffer too small or failure */
3025 DPRINT1("ConvertNtPathToWin32Path: GetLogicalDriveStringsW failed\n");
3026 return FALSE;
3027 }
3028
3029/* We go back there once if RetryOnce == TRUE */
3030Retry:
3031
3032 /* Enumerate the mounted drives */
3033 for (pwszDrive = wszDrives; *pwszDrive; pwszDrive += wcslen(pwszDrive) + 1)
3034 {
3035 /* Retrieve the NT path corresponding to the current Win32 DOS path */
3036 pwszDrive[2] = UNICODE_NULL; // Temporarily remove the backslash
3037 QueryDosDeviceW(pwszDrive, wszNTPath, _countof(wszNTPath));
3038 pwszDrive[2] = L'\\'; // Restore the backslash
3039
3040 DPRINT("Testing '%S' --> '%S'\n", pwszDrive, wszNTPath);
3041
3042 /* Check whether the queried NT path prefixes the user-provided NT path */
3043 FoundDrive = !_wcsnicmp(pwszNtPathToMap, wszNTPath, wcslen(wszNTPath));
3044 if (!FoundDrive)
3045 {
3046 PWCHAR ptr, ptr2;
3047
3048 /*
3049 * Check whether this was a network share that has a drive letter,
3050 * but the user-provided NT path points to this share without
3051 * mentioning the drive letter.
3052 *
3053 * The format is: \Device<network_redirector>\;X:<data>\share\path
3054 * The corresponding drive letter is 'X'.
3055 * A system-provided network redirector (LanManRedirector or Mup)
3056 * or a 3rd-party one may be used.
3057 *
3058 * We check whether the user-provided NT path has the form:
3059 * \Device<network_redirector><data>\share\path
3060 * as it obviously did not have the full form (the previous check
3061 * would have been OK otherwise).
3062 */
3063 if (!_wcsnicmp(wszNTPath, L"\\Device\\", _countof(L"\\Device\\")-1) &&
3064 (ptr = wcschr(wszNTPath + _countof(L"\\Device\\")-1, L'\\')) &&
3065 wcslen(++ptr) >= 3 && ptr[0] == L';' && ptr[2] == L':')
3066 {
3067 /*
3068 * Normally the specified drive letter should correspond
3069 * to the one used for the mapping. But we will ignore
3070 * if it happens not to be the case.
3071 */
3072 if (pwszDrive[0] != ptr[1])
3073 {
3074 DPRINT1("Peculiar: expected network share drive letter %C different from actual one %C\n",
3075 pwszDrive[0], ptr[1]);
3076 }
3077
3078 /* Remove the drive letter from the NT network share path */
3079 ptr2 = ptr + 3;
3080 /* Swallow as many possible consecutive backslashes as there could be */
3081 while (*ptr2 == L'\\') ++ptr2;
3082
3083 memmove(ptr, ptr2, (wcslen(ptr2) + 1) * sizeof(WCHAR));
3084
3085 /* Now do the check again */
3086 FoundDrive = !_wcsnicmp(pwszNtPathToMap, wszNTPath, wcslen(wszNTPath));
3087 }
3088 }
3089 if (FoundDrive)
3090 {
3091 /* Found it! */
3092
3093 pwszDrive[2] = UNICODE_NULL; // Remove the backslash
3094
3095 if (pwszNtPathToMap == pwszNTPath)
3096 {
3097 ASSERT(!RetryOnce && pwszNTPath != TargetPath);
3098 pwszRemaining = pwszNTPath + wcslen(wszNTPath);
3099 }
3100 break;
3101 }
3102 }
3103
3104 if (FoundDrive)
3105 {
3106 /* A mapping was found, add it to the cache */
3107 Entry = HeapAlloc(ProcessHeap, HEAP_ZERO_MEMORY, sizeof(*Entry));
3108 if (!Entry)
3109 {
3110 DPRINT1("ConvertNtPathToWin32Path: Cannot allocate memory\n");
3111 return FALSE;
3112 }
3113 StringCchCopyNW(Entry->NtPath, _countof(Entry->NtPath),
3114 pwszNTPath, pwszRemaining - pwszNTPath);
3115 StringCchCopyW(Entry->Win32Path, _countof(Entry->Win32Path), pwszDrive);
3116
3117 /* Insert it as the most recent entry */
3118 InsertHeadList(&MappingList->List, &Entry->ListEntry);
3119 MappingList->MappingsCount++;
3120
3121 /* Set the pointers and go build the Win32 path */
3122 pwszDrive = Entry->Win32Path;
3123 goto Quit;
3124 }
3125
3126 /*
3127 * We failed, perhaps because the beginning of the NT path used a symlink.
3128 * Try to see whether this is the case by attempting to resolve it.
3129 * If the symlink resolution gives nothing, or we already failed once,
3130 * there is no hope in converting the path to Win32.
3131 * Otherwise, symlink resolution succeeds but we need to recheck again
3132 * the drives list.
3133 */
3134
3135 /*
3136 * In theory we would have to parse each element in the NT path and going
3137 * until finding a symlink object (otherwise we would fail straight away).
3138 * However here we can use guessing instead, since we know which kind of
3139 * NT paths we are likely to manipulate: \Device\HarddiskX\PartitionY\ and
3140 * the like (including \Device\HarddiskVolumeX\‍) and the other ones that
3141 * are supported in setuplib\utils\arcname.c .
3142 *
3143 * But actually, all the supported names in arcname.c are real devices,
3144 * and only \Device\HarddiskX\PartitionY\ may refer to a symlink, so we
3145 * just check for it.
3146 */
3147 if (!RetryOnce && !FoundDrive)
3148 {
3149 ULONG DiskNumber, PartitionNumber;
3150 INT Length;
3151
3152 NTSTATUS Status;
3153 OBJECT_ATTRIBUTES ObjectAttributes;
3154 HANDLE LinkHandle;
3155 UNICODE_STRING SymLink, Target;
3156
3157 if (swscanf(pwszNTPath, L"\\Device\\Harddisk%lu\\Partition%lu%n",
3158 &DiskNumber, &PartitionNumber, &Length) != 2)
3159 {
3160 /* Definitively not a recognized path, bail out */
3161 return FALSE;
3162 }
3163
3164 /* Check whether \Device\HarddiskX\PartitionY is a symlink */
3165 RtlInitEmptyUnicodeString(&SymLink, (PWCHAR)pwszNTPath, Length * sizeof(WCHAR));
3166 SymLink.Length = SymLink.MaximumLength;
3167
3168 InitializeObjectAttributes(&ObjectAttributes,
3169 &SymLink,
3170 OBJ_CASE_INSENSITIVE,
3171 NULL,
3172 NULL);
3173 Status = NtOpenSymbolicLinkObject(&LinkHandle,
3174 SYMBOLIC_LINK_QUERY,
3175 &ObjectAttributes);
3176 if (!NT_SUCCESS(Status))
3177 {
3178 /* Not a symlink, or something else happened: bail out */
3179 DPRINT1("ConvertNtPathToWin32Path: NtOpenSymbolicLinkObject(%wZ) failed, Status 0x%08lx\n",
3180 &SymLink, Status);
3181 return FALSE;
3182 }
3183
3184 *TargetPath = UNICODE_NULL;
3185 RtlInitEmptyUnicodeString(&Target, TargetPath, sizeof(TargetPath));
3186
3187 /* Resolve the link and close its handle */
3188 Status = NtQuerySymbolicLinkObject(LinkHandle, &Target, NULL);
3189 NtClose(LinkHandle);
3190
3191 /* Check for success */
3192 if (!NT_SUCCESS(Status))
3193 {
3194 /* Not a symlink, or something else happened: bail out */
3195 DPRINT1("ConvertNtPathToWin32Path: NtQuerySymbolicLinkObject(%wZ) failed, Status 0x%08lx\n",
3196 &SymLink, Status);
3197 return FALSE;
3198 }
3199
3200 /* Set the pointers */
3201 pwszRemaining = pwszNTPath + Length;
3202 pwszNtPathToMap = TargetPath; // Point to our local buffer
3203
3204 /* Retry once */
3205 RetryOnce = TRUE;
3206 goto Retry;
3207 }
3208
3209 ASSERT(!FoundDrive);
3210
3211Quit:
3212 if (FoundDrive)
3213 {
3214 StringCchPrintfW(pwszPath, cchPathMax,
3215 L"%s%s",
3216 pwszDrive,
3217 pwszRemaining);
3218 DPRINT("ConvertNtPathToWin32Path: %S\n", pwszPath);
3219 return TRUE;
3220 }
3221
3222 return FALSE;
3223}
3224
3225/* Used to enable and disable the shutdown privilege */
3226/* static */ BOOL
3227EnablePrivilege(
3228 IN LPCWSTR lpszPrivilegeName,
3229 IN BOOL bEnablePrivilege)
3230{
3231 BOOL Success;
3232 HANDLE hToken;
3233 TOKEN_PRIVILEGES tp;
3234
3235 Success = OpenProcessToken(GetCurrentProcess(),
3236 TOKEN_ADJUST_PRIVILEGES,
3237 &hToken);
3238 if (!Success) return Success;
3239
3240 Success = LookupPrivilegeValueW(NULL,
3241 lpszPrivilegeName,
3242 &tp.Privileges[0].Luid);
3243 if (!Success) goto Quit;
3244
3245 tp.PrivilegeCount = 1;
3246 tp.Privileges[0].Attributes = (bEnablePrivilege ? SE_PRIVILEGE_ENABLED : 0);
3247
3248 Success = AdjustTokenPrivileges(hToken, FALSE, &tp, 0, NULL, NULL);
3249
3250Quit:
3251 CloseHandle(hToken);
3252 return Success;
3253}
3254
3255/* Copied from HotkeyThread() in dll/win32/syssetup/install.c */
3256static DWORD CALLBACK
3257HotkeyThread(LPVOID Parameter)
3258{
3259 ATOM hotkey;
3260 MSG msg;
3261
3262 DPRINT("HotkeyThread start\n");
3263
3264 hotkey = GlobalAddAtomW(L"Setup Shift+F10 Hotkey");
3265 if (!RegisterHotKey(NULL, hotkey, MOD_SHIFT, VK_F10))
3266 DPRINT1("RegisterHotKey failed with %lu\n", GetLastError());
3267
3268 while (GetMessageW(&msg, NULL, 0, 0))
3269 {
3270 if (msg.hwnd == NULL && msg.message == WM_HOTKEY && msg.wParam == hotkey)
3271 {
3272 WCHAR CmdLine[] = L"cmd.exe"; // CreateProcess can modify this buffer.
3273 STARTUPINFOW si = { sizeof(si) };
3274 PROCESS_INFORMATION pi;
3275
3276 if (CreateProcessW(NULL,
3277 CmdLine,
3278 NULL,
3279 NULL,
3280 FALSE,
3281 CREATE_NEW_CONSOLE,
3282 NULL,
3283 NULL,
3284 &si,
3285 &pi))
3286 {
3287 CloseHandle(pi.hProcess);
3288 CloseHandle(pi.hThread);
3289 }
3290 else
3291 {
3292 DPRINT1("Failed to launch command prompt: %lu\n", GetLastError());
3293 }
3294 }
3295 }
3296
3297 UnregisterHotKey(NULL, hotkey);
3298 GlobalDeleteAtom(hotkey);
3299
3300 DPRINT("HotkeyThread terminate\n");
3301 return 0;
3302}
3303
3304
3305static PCWSTR
3306GetLocalSetupDllPath(VOID)
3307{
3308 static WCHAR SetupDllPath[MAX_PATH] = L"";
3309 static BOOL Init = FALSE;
3310 BOOL Success;
3311 DWORD PathSize;
3312
3313 /* Don't rebuild the path if we did it already */
3314 if (Init)
3315 return SetupDllPath;
3316 Init = TRUE;
3317
3318 /*
3319 * Retrieve the full path of the current running Setup instance.
3320 * From this we build the suitable path to the Setup DLL.
3321 */
3322 PathSize = GetModuleFileNameW(NULL, SetupDllPath, _countof(SetupDllPath));
3323 SetupDllPath[_countof(SetupDllPath) - 1] = UNICODE_NULL; // Ensure NUL-termination (see WinXP bug)
3324
3325 Success = ((PathSize != 0) && (PathSize < _countof(SetupDllPath)) &&
3326 (GetLastError() != ERROR_INSUFFICIENT_BUFFER));
3327 if (Success)
3328 {
3329 /* Find the last path separator, remove it as well as the file name */
3330 PWCHAR pch = wcsrchr(SetupDllPath, L'\\');
3331 if (!pch)
3332 pch = SetupDllPath;
3333
3334 /* The Setup DLL is inside the System32 sub-directory */
3335 PathSize = _countof(SetupDllPath) - (pch - SetupDllPath);
3336 Success = SUCCEEDED(StringCchCopyW(pch, PathSize, L"\\system32"));
3337 }
3338 if (!Success)
3339 {
3340 /* Failure: invalidate the path; the DLL won't be found and delay-loaded */
3341 *SetupDllPath = UNICODE_NULL;
3342 }
3343
3344 return SetupDllPath;
3345}
3346
3347#ifndef DECLARE_UNICODE_STRING_SIZE
3348#define DECLARE_UNICODE_STRING_SIZE(_var, _size) \
3349 WCHAR _var ## _buffer[_size]; \
3350 UNICODE_STRING _var = { 0, (_size) * sizeof(WCHAR) , _var ## _buffer }
3351#endif
3352#include <ndk/exfuncs.h> // For NtRaiseHardError()
3353#define DELAYIMP_INSECURE_WRITABLE_HOOKS
3354#include <delayimp.h>
3355
3364static FARPROC
3365WINAPI setupDelayHook(unsigned dliNotify, PDelayLoadInfo pdli)
3366{
3367 static CHAR dllPath[MAX_PATH];
3368 static PCWSTR setupDllPath = NULL;
3369
3370 switch (dliNotify)
3371 {
3372 case dliNotePreLoadLibrary:
3373 {
3374 // NOTE: Add any other needed setup-specific DLLs there.
3375 if (_stricmp(pdli->szDll, "setuplib.dll") == 0)
3376 {
3377 if (!setupDllPath)
3378 setupDllPath = GetLocalSetupDllPath();
3379 if (setupDllPath && *setupDllPath &&
3380 SUCCEEDED(StringCchPrintfA(dllPath, _countof(dllPath), "%S\\%s",
3381 setupDllPath, pdli->szDll)))
3382 {
3383 pdli->szDll = dllPath; /* Set szDll to the new path */
3384 }
3385 }
3386 break; /* Load the DLL using the modified path */
3387 }
3388
3389 case dliFailLoadLib:
3390 {
3391 /*
3392 * Library loading failed.
3393 * Raise a hard error instead of the default
3394 * exception, and "cleanly" kill the process.
3395 */
3396 ANSI_STRING DllPathA;
3397 DECLARE_UNICODE_STRING_SIZE(DllPathU, MAX_PATH);
3398 ULONG_PTR Parameters[] = {(ULONG_PTR)&DllPathU};
3399 ULONG Response;
3400
3401 RtlInitAnsiString(&DllPathA, pdli->szDll);
3402 RtlAnsiStringToUnicodeString(&DllPathU, &DllPathA, FALSE);
3403 NtRaiseHardError(STATUS_DLL_NOT_FOUND | HARDERROR_OVERRIDE_ERRORMODE,
3404 _countof(Parameters),
3405 0x1,
3406 Parameters,
3407 OptionOk,
3408 &Response);
3409 ExitProcess(-1);
3410 break;
3411 }
3412
3413 default:
3414 break;
3415 }
3416
3417 return NULL;
3418}
3419
3424// NOTE: MSVC 2015 Update 3 makes this a const variable.
3425// #if (_MSC_VER > 1900) || (_MSC_VER == 1900 && _MSC_FULL_VER >= 190024210) ...
3426/*ExternC*/ PfnDliHook __pfnDliNotifyHook2 = setupDelayHook;
3427/*ExternC*/ PfnDliHook __pfnDliFailureHook2 = setupDelayHook;
3428
3429
3430#include <pshpack1.h>
3431typedef struct DLGTEMPLATEEX
3432{
3433 WORD dlgVer;
3434 WORD signature;
3435 DWORD helpID;
3436 DWORD exStyle;
3437 DWORD style;
3438 WORD cDlgItems;
3439 short x;
3440 short y;
3441 short cx;
3442 short cy;
3443} DLGTEMPLATEEX, *LPDLGTEMPLATEEX;
3444#include <poppack.h>
3445
3446WNDPROC wpOrgPrshtProc = NULL;
3447
3448/* Message handler for property sheet dialog */
3449static LRESULT
3450CALLBACK
3451PrshtWndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
3452{
3453 switch (uMessage)
3454 {
3455 case DM_REPOSITION:
3456 {
3457 /* Center the wizard window */
3458 CenterWindow(hWnd);
3459 // FIXME: HACK: See hack in PropSheetCallback()::PSCB_INITIALIZED
3460 ShowWindow(hWnd, SW_SHOWNORMAL);
3461 break;
3462 }
3463
3464 case WM_SETCURSOR:
3465 {
3466 /* Set a wizard-wide cursor */
3467 // NOTE: There is a problem, where when hovering over the wizard
3468 // navigation buttons, the cursor would blink with the arrow.
3469 // To mitigate this problem, only show the custom cursor when
3470 // we are on the main wizard window.
3471 if (!(hWaitCursor && (wParam == (WPARAM)hWnd)))
3472 break;
3473 SetCursor(hWaitCursor);
3474 return TRUE;
3475 }
3476
3477 case WM_DESTROY:
3478 {
3479 /* Restore the original dialog procedure */
3480 ASSERT(wpOrgPrshtProc);
3481 SetWindowLongPtrW(hWnd, DWLP_DLGPROC, (LONG_PTR)wpOrgPrshtProc);
3482 }
3483
3484 default:
3485 break;
3486 }
3487
3488 /* Invoke the original dialog procedure */
3489 return CallWindowProc(wpOrgPrshtProc, hWnd, uMessage, wParam, lParam);
3490}
3491
3492static int
3493CALLBACK
3494PropSheetCallback(
3495 _In_ HWND hDlg,
3496 _In_ UINT message,
3497 _In_ LPARAM lParam)
3498{
3499 switch (message)
3500 {
3501 case PSCB_PRECREATE:
3502 {
3503 LPDLGTEMPLATE dlgTemplate = (LPDLGTEMPLATE)lParam;
3504 LPDLGTEMPLATEEX dlgTemplateEx = (LPDLGTEMPLATEEX)lParam;
3505 DWORD dwStyle = 0, dwStyleMask = 0;
3506
3507 // FIXME: HACK: See hack in PropSheetCallback()::PSCB_INITIALIZED
3508 // Hide the dialog by default; DM_REPOSITION will center it on screen then show it.
3509 dwStyleMask |= WS_VISIBLE;
3510
3511 dwStyle |= DS_CENTER; // Center the dialog -- But propsheet code repositions it afterwards...
3512 //dwStyleMask |= DS_CONTEXTHELP; // TODO: Enable if you want context help.
3513 dwStyle |= DS_SETFOREGROUND; // Ensure we are initially set to the foreground.
3514 dwStyleMask |= dwStyle;
3515
3516 /* Set the property sheet dialog styles */
3517 if (dlgTemplateEx->signature == 0xFFFF)
3518 dlgTemplateEx->style = (dlgTemplateEx->style & ~dwStyleMask) | (dwStyle & dwStyleMask);
3519 else
3520 dlgTemplate->style = (dlgTemplate->style & ~dwStyleMask) | (dwStyle & dwStyleMask);
3521 break;
3522 }
3523
3524 // NOTE: This callback is needed to set large icon correctly.
3525 case PSCB_INITIALIZED:
3526 {
3527 HICON hIcon = LoadIconW(SetupData.hInstance, MAKEINTRESOURCEW(IDI_MAIN));
3528 SendMessageW(hDlg, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
3529
3530 /* Sub-class the property sheet window procedure */
3531 wpOrgPrshtProc = (WNDPROC)SetWindowLongPtrW(hDlg, DWLP_DLGPROC, (LONG_PTR)PrshtWndProc);
3532
3533 // FIXME: HACK: Wine comctl32 propsheet.c doesn't send DM_REPOSITION
3534 // after creating, initializing and resizing the property sheet dialog,
3535 // so we simulate its call there...
3536 PostMessageW(hDlg, DM_REPOSITION, 0, 0);
3537 break;
3538 }
3539
3540 default:
3541 break;
3542 }
3543
3544 return FALSE;
3545}
3546
3547static const struct
3548{
3549 BOOL IncludeForUnattended;
3550 DWORD dwFlags;
3551 PCWSTR pszTemplate;
3552 PCWSTR pszHeaderTitle;
3553 PCWSTR pszHeaderSubTitle;
3554 DLGPROC pfnDlgProc;
3555} WizardPages[] =
3556{
3557 /* Start page */
3558 {FALSE, PSP_HIDEHEADER,
3559 MAKEINTRESOURCEW(IDD_STARTPAGE), NULL, NULL, StartDlgProc},
3560
3561 /* Install type selection page */
3562 {FALSE, PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE,
3563 MAKEINTRESOURCEW(IDD_TYPEPAGE),
3564 MAKEINTRESOURCEW(IDS_TYPETITLE), MAKEINTRESOURCEW(IDS_TYPESUBTITLE),
3565 TypeDlgProc},
3566
3567 /* Upgrade/Repair selection page */
3568 {FALSE, PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE,
3569 MAKEINTRESOURCEW(IDD_UPDATEREPAIRPAGE),
3570 MAKEINTRESOURCEW(IDS_UPDATETITLE), MAKEINTRESOURCEW(IDS_UPDATESUBTITLE),
3571 UpgradeRepairDlgProc},
3572
3573 /* Device Settings page */
3574 {FALSE, PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE,
3575 MAKEINTRESOURCEW(IDD_DEVICEPAGE),
3576 MAKEINTRESOURCEW(IDS_DEVICETITLE), MAKEINTRESOURCEW(IDS_DEVICESUBTITLE),
3577 DeviceDlgProc},
3578
3579 /* Install device settings page / boot method / install directory */
3580 {FALSE, PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE,
3581 MAKEINTRESOURCEW(IDD_DRIVEPAGE),
3582 MAKEINTRESOURCEW(IDS_DRIVETITLE), MAKEINTRESOURCEW(IDS_DRIVESUBTITLE),
3583 DriveDlgProc},
3584
3585 /* Summary page */
3586 {FALSE, PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE,
3587 MAKEINTRESOURCEW(IDD_SUMMARYPAGE),
3588 MAKEINTRESOURCEW(IDS_SUMMARYTITLE), MAKEINTRESOURCEW(IDS_SUMMARYSUBTITLE),
3589 SummaryDlgProc},
3590
3591 /* Installation Progress page */
3592 {TRUE, PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE,
3593 MAKEINTRESOURCEW(IDD_PROCESSPAGE),
3594 MAKEINTRESOURCEW(IDS_PROCESSTITLE), MAKEINTRESOURCEW(IDS_PROCESSSUBTITLE),
3595 ProcessDlgProc},
3596
3597 /* Finish page */
3598 {TRUE, PSP_HIDEHEADER,
3599 MAKEINTRESOURCEW(IDD_FINISHPAGE), NULL, NULL,
3600 FinishDlgProc},
3601
3602 /* Abort page */
3603 {TRUE, PSP_HIDEHEADER,
3604 MAKEINTRESOURCEW(IDD_ABORTPAGE), NULL, NULL,
3605 FinishDlgProc}, // Same dialog procedure as the Finish page.
3606};
3607
3608int WINAPI
3609_tWinMain(HINSTANCE hInst,
3610 HINSTANCE hPrevInstance,
3611 LPTSTR lpszCmdLine,
3612 int nCmdShow)
3613{
3614 ULONG Error;
3615 HANDLE hHotkeyThread;
3616 INITCOMMONCONTROLSEX iccx;
3617 PROPSHEETHEADERW psh = {0};
3618 PROPSHEETPAGEW psp = {0};
3619 HPROPSHEETPAGE ahpsp[_countof(WizardPages)];
3620 UINT nPages, i;
3621
3622 ProcessHeap = GetProcessHeap();
3623
3624 SetupData.hInstance = hInst;
3625 SetupData.hInstallThread = NULL;
3626 SetupData.hHaltInstallEvent = NULL;
3627 SetupData.bStopInstall = FALSE;
3628
3629 /* Initialize the NT to Win32 path prefix mapping list */
3630 InitNtToWin32PathMappingList(&SetupData.MappingList);
3631
3632 /* Initialize Setup */
3633 Error = InitializeSetup(&SetupData.USetupData, NULL,
3634 &SpFileExports, &SpInfExports);
3635 if (Error != ERROR_SUCCESS)
3636 {
3637 //
3638 // TODO: Write an error mapper (much like the MUIDisplayError of USETUP)
3639 //
3640 if (Error == ERROR_NO_SOURCE_DRIVE)
3641 MessageBoxW(NULL, L"GetSourcePaths failed!", NULL, MB_ICONERROR);
3642 else if (Error == ERROR_LOAD_TXTSETUPSIF)
3643 DisplayError(NULL, IDS_CAPTION, IDS_NO_TXTSETUP_SIF);
3644 else // FIXME!!
3645 MessageBoxW(NULL, L"Unknown error!", NULL, MB_ICONERROR);
3646
3647 goto Quit;
3648 }
3649
3650 /* Retrieve any supplemental options from the unattend file */
3651 SetupData.bUnattend = IsUnattendedSetup = CheckUnattendedSetup(&SetupData.USetupData);
3652
3653 /* Load extra setup data (HW lists etc...) */
3654 if (!LoadSetupData(&SetupData))
3655 goto Quit;
3656
3657 hHotkeyThread = CreateThread(NULL, 0, HotkeyThread, NULL, 0, NULL);
3658
3659 /* Whenever any of the common controls are used in your app,
3660 * you must call InitCommonControlsEx() to register the classes
3661 * for those controls. */
3662 iccx.dwSize = sizeof(iccx);
3663 iccx.dwICC = ICC_LISTVIEW_CLASSES | ICC_TREEVIEW_CLASSES | ICC_PROGRESS_CLASS;
3664 InitCommonControlsEx(&iccx);
3665
3666 /* Register the TreeList control */
3667 // RegisterTreeListClass(hInst);
3668 TreeListRegister(hInst);
3669
3670 /* Create the title and bold fonts */
3671 SetupData.hTitleFont = CreateTitleFont(NULL);
3672 SetupData.hBoldFont = CreateBoldFont(NULL, 0);
3673
3674 /* Create each page */
3675 psp.dwSize = sizeof(psp);
3676 psp.hInstance = hInst;
3677 psp.lParam = (LPARAM)&SetupData;
3678 for (nPages = 0, i = 0; i < _countof(WizardPages); ++i)
3679 {
3680 /* Skip pages that don't apply to unattended mode */
3681 if (SetupData.bUnattend && !WizardPages[i].IncludeForUnattended)
3682 continue;
3683
3684 psp.dwFlags = PSP_DEFAULT | WizardPages[i].dwFlags;
3685 psp.pszTemplate = WizardPages[i].pszTemplate;
3686#if 1
3687 // FIXME: HACK: Wine comctl32 propsheet.c doesn't correctly set the wizard
3688 // dialog title when the pages don't have captions, even if the user sends
3689 // an initial PSM_SETTITLE message via the callback -- see CORE-20687.
3690 // To avert this problem, force-set the same title to each page, before
3691 // creating the wizard.
3692 psp.dwFlags |= PSP_USETITLE;
3693 psp.pszTitle = MAKEINTRESOURCEW(IDS_CAPTION);
3694#endif
3695 psp.pfnDlgProc = WizardPages[i].pfnDlgProc;
3696 psp.pszHeaderTitle = WizardPages[i].pszHeaderTitle;
3697 psp.pszHeaderSubTitle = WizardPages[i].pszHeaderSubTitle;
3698 ahpsp[nPages++] = CreatePropertySheetPage(&psp);
3699 }
3700
3701 /* Create the property sheet */
3702 psh.dwSize = sizeof(psh);
3703 psh.dwFlags = PSH_WIZARD97 | PSH_USEICONID | PSH_USECALLBACK | PSH_WATERMARK | PSH_HEADER;
3704 psh.hInstance = hInst;
3705 psh.hwndParent = NULL;
3706 psh.pszIcon = MAKEINTRESOURCEW(IDI_MAIN);
3707 psh.nPages = nPages;
3708 psh.nStartPage = 0;
3709 psh.phpage = ahpsp;
3710 psh.pfnCallback = PropSheetCallback;
3711 psh.pszbmWatermark = MAKEINTRESOURCEW(IDB_WATERMARK);
3712 psh.pszbmHeader = MAKEINTRESOURCEW(IDB_HEADER);
3713
3714 /* Display the wizard */
3715 PropertySheetW(&psh);
3716
3717 if (SetupData.hBoldFont)
3718 DeleteFont(SetupData.hBoldFont);
3719 if (SetupData.hTitleFont)
3720 DeleteFont(SetupData.hTitleFont);
3721
3722 /* Unregister the TreeList control */
3723 // UnregisterTreeListClass(hInst);
3724 TreeListUnregister(hInst);
3725
3726 if (hHotkeyThread)
3727 {
3728 PostThreadMessageW(GetThreadId(hHotkeyThread), WM_QUIT, 0, 0);
3729 CloseHandle(hHotkeyThread);
3730 }
3731
3732Quit:
3733 /* Setup has finished */
3734 FinishSetup(&SetupData.USetupData);
3735
3736 /* Free the NT to Win32 path prefix mapping list */
3737 FreeNtToWin32PathMappingList(&SetupData.MappingList);
3738
3739 /* Force reboot if there are no other user-interactive windows opened */
3740 SetupData.bMustReboot |= !AreThereInteractiveWindows(NULL);
3741
3742 /* System rebooting will be done by Winlogon if necessary */
3743 if (SetupData.bMustReboot)
3744 {
3745#if 1 // TESTING: Disable for testing the installer locally.
3746 EnablePrivilege(SE_SHUTDOWN_NAME, TRUE);
3747 ExitWindowsEx(EWX_REBOOT, 0);
3748 EnablePrivilege(SE_SHUTDOWN_NAME, FALSE);
3749#else
3750 DisplayMessage(NULL, MB_ICONWARNING, L"Restarting", L"Setup is now restarting your computer!");
3751#endif
3752 }
3753 return 0;
3754}
3755
3756/* EOF */
Id
DWORD Id
Definition: CLayerUIPropPage.cpp:47
hWndList
static HWND hWndList[5+1]
Definition: SetParent.c:10
VOID
#define VOID
Definition: acefi.h:82
BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127
msg
#define msg(x)
Definition: auth_time.c:54
IDC_DISPLAY
#define IDC_DISPLAY
Definition: resource.h:19
hWnd
HWND hWnd
Definition: settings.c:17
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
IDI_MAIN
#define IDI_MAIN
Definition: resource.h:4
IDB_HEADER
#define IDB_HEADER
Definition: resource.h:30
DPRINT1
#define DPRINT1
Definition: precomp.h:8
PrepareFileCopy
BOOLEAN NTAPI PrepareFileCopy(IN OUT PUSETUP_DATA pSetupData, IN PFILE_COPY_STATUS_ROUTINE StatusRoutine OPTIONAL)
Definition: install.c:685
DoFileCopy
BOOLEAN NTAPI DoFileCopy(IN OUT PUSETUP_DATA pSetupData, IN PSP_FILE_CALLBACK_W MsgHandler, IN PVOID Context OPTIONAL)
Definition: install.c:828
CreateKeyboardDriverList
PGENERIC_LIST CreateKeyboardDriverList(IN HINF InfFile)
Definition: settings.c:1072
CreateComputerTypeList
PGENERIC_LIST CreateComputerTypeList(IN HINF InfFile)
Definition: settings.c:524
CreateDisplayDriverList
PGENERIC_LIST CreateDisplayDriverList(IN HINF InfFile)
Definition: settings.c:708
CreateKeyboardLayoutList
PGENERIC_LIST CreateKeyboardLayoutList(IN HINF InfFile, IN PCWSTR LanguageId, OUT PWSTR DefaultKBLayout)
Definition: settings.c:1209
CreateLanguageList
PGENERIC_LIST CreateLanguageList(IN HINF InfFile, OUT PWSTR DefaultLanguage)
Definition: settings.c:1159
PGENENTRY
struct _GENENTRY * PGENENTRY
__pfnDliFailureHook2
PfnDliHook __pfnDliFailureHook2
Definition: reactos.c:3427
SetWindowResPrintfW
VOID __cdecl SetWindowResPrintfW(_In_ HWND hWnd, _In_opt_ HINSTANCE hInstance, _In_ UINT uID,...)
Definition: reactos.c:341
CenterWindow
static VOID CenterWindow(HWND hWnd)
Definition: reactos.c:46
PropSheet_SetCloseCancel
VOID PropSheet_SetCloseCancel(_In_ HWND hWndWiz, _In_ BOOL Enable)
Enable or disable the Cancel and the Close title-bar property-sheet buttons.
Definition: reactos.c:1877
ProcessDlgProc
static INT_PTR CALLBACK ProcessDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:2248
FSVOL_CONTEXT
struct _FSVOL_CONTEXT FSVOL_CONTEXT
RegistryStatus
static VOID __cdecl RegistryStatus(IN REGISTRY_STATUS RegStatus,...)
Definition: reactos.c:1839
GetSelectedListViewItem
PVOID GetSelectedListViewItem(IN HWND hWndList)
Definition: reactos.c:698
FsVolCallback
static FSVOL_OP CALLBACK FsVolCallback(_In_opt_ PVOID Context, _In_ FSVOLNOTIFY FormatStatus, _In_ ULONG_PTR Param1, _In_ ULONG_PTR Param2)
Definition: reactos.c:1362
PCOPYCONTEXT
struct _COPYCONTEXT * PCOPYCONTEXT
IsShellActive
static BOOL IsShellActive(VOID)
Detects whether a Windows shell is active.
Definition: reactos.c:2556
LPDLGTEMPLATEEX
struct DLGTEMPLATEEX * LPDLGTEMPLATEEX
TypeDlgProc
static INT_PTR CALLBACK TypeDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:427
setupDelayHook
static FARPROC WINAPI setupDelayHook(unsigned dliNotify, PDelayLoadInfo pdli)
Controls the delay-loading of Setup DLLs from a suitable path.
Definition: reactos.c:3365
column_widths
static const INT column_widths[MAX_LIST_COLUMNS]
Definition: reactos.c:790
SystemVolume
#define SystemVolume
Definition: reactos.c:35
DECLARE_UNICODE_STRING_SIZE
#define DECLARE_UNICODE_STRING_SIZE(_var, _size)
Definition: reactos.c:3348
MAX_LIST_COLUMNS
#define MAX_LIST_COLUMNS
Definition: reactos.c:788
InstallVolume
#define InstallVolume
Definition: reactos.c:30
FormatCallback
static BOOLEAN NTAPI FormatCallback(_In_ CALLBACKCOMMAND Command, _In_ ULONG Modifier, _In_ PVOID Argument)
Definition: reactos.c:1296
pfnDlgProc
DLGPROC pfnDlgProc
Definition: reactos.c:3554
__pfnDliNotifyHook2
PfnDliHook __pfnDliNotifyHook2
Custom delay-loading hooks for loading the Setup DLLs from a suitable path.
Definition: reactos.c:3426
GetLocalSetupDllPath
static PCWSTR GetLocalSetupDllPath(VOID)
Definition: reactos.c:3306
CreateBoldFont
static HFONT CreateBoldFont(_In_opt_ HFONT hOrigFont, _In_opt_ INT PointSize)
Create a bold font derived from the provided font.
Definition: reactos.c:73
AreThereInteractiveWindows
static BOOL AreThereInteractiveWindows(_In_opt_ HWND hWndExclude)
Detects whether there exist interactive closable windows opened.
Definition: reactos.c:2614
ConvertNtPathToWin32Path
BOOL ConvertNtPathToWin32Path(IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList, OUT PWSTR pwszPath, IN DWORD cchPathMax, IN PCWSTR pwszNTPath)
Definition: reactos.c:2968
ProcessHeap
HANDLE ProcessHeap
Definition: reactos.c:23
dwFlags
DWORD dwFlags
Definition: reactos.c:3550
LoadSetupData
BOOL LoadSetupData(IN OUT PSETUPDATA pSetupData)
Definition: reactos.c:2844
UiContext
UI_CONTEXT UiContext
Definition: reactos.c:38
column_alignment
static const INT column_alignment[MAX_LIST_COLUMNS]
Definition: reactos.c:791
UpgradeRepairDlgProc
static INT_PTR CALLBACK UpgradeRepairDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:794
PM_INSTALL_DONE
#define PM_INSTALL_DONE
Definition: reactos.c:1888
CreateTitleFont
static HFONT CreateTitleFont(_In_opt_ HFONT hOrigFont)
Definition: reactos.c:107
InstallPartition
PPARTENTRY InstallPartition
Definition: reactos.c:28
GetSelectedComboListItem
PVOID GetSelectedComboListItem(IN HWND hWndList)
Definition: reactos.c:640
LoadAllocStringW
size_t LoadAllocStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _In_opt_ _Outptr_ PWSTR *pString, _In_opt_ size_t cchBufferLen)
Definition: reactos.c:115
PropSheetCallback
static int CALLBACK PropSheetCallback(_In_ HWND hDlg, _In_ UINT message, _In_ LPARAM lParam)
Definition: reactos.c:3494
InitGenericListView
VOID InitGenericListView(IN HWND hWndList, IN PGENERIC_LIST List, IN PADD_ENTRY_ITEM AddEntryItemProc)
Definition: reactos.c:661
DisplayError
INT __cdecl DisplayError(_In_opt_ HWND hWnd, _In_ UINT uIDTitle, _In_ UINT uIDMessage,...)
Definition: reactos.c:264
SetWindowResPrintfVW
VOID SetWindowResPrintfVW(_In_ HWND hWnd, _In_opt_ HINSTANCE hInstance, _In_ UINT uID, _In_ va_list args)
Definition: reactos.c:303
FinishDlgProc
static INT_PTR CALLBACK FinishDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:2632
PFSVOL_CONTEXT
struct _FSVOL_CONTEXT * PFSVOL_CONTEXT
hWaitCursor
HCURSOR hWaitCursor
Definition: reactos.c:39
FreeNtToWin32PathMappingList
VOID FreeNtToWin32PathMappingList(IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList)
Definition: reactos.c:2947
pszHeaderSubTitle
PCWSTR pszHeaderSubTitle
Definition: reactos.c:3553
WizardPages
static const struct @76 WizardPages[]
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: reactos.c:563
CLOSABLE_WND_INFO
struct _CLOSABLE_WND_INFO CLOSABLE_WND_INFO
GetSettingDescription
static VOID NTAPI GetSettingDescription(IN PGENERIC_LIST_ENTRY Entry, OUT PWSTR Buffer, IN SIZE_T cchBufferSize)
Definition: reactos.c:718
IDS_LIST_COLUMN_FIRST
#define IDS_LIST_COLUMN_FIRST
Definition: reactos.c:785
PADD_ENTRY_ITEM
VOID(NTAPI * PADD_ENTRY_ITEM)(IN HWND hWndList, IN LVITEM *plvItem, IN PGENERIC_LIST_ENTRY Entry, IN OUT PWSTR Buffer, IN SIZE_T cchBufferSize)
Definition: reactos.c:653
DeviceDlgProc
static INT_PTR CALLBACK DeviceDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:986
SummaryDlgProc
static INT_PTR CALLBACK SummaryDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:1089
DisplayMessage
INT __cdecl DisplayMessage(_In_opt_ HWND hWnd, _In_ UINT uType, _In_opt_ PCWSTR pszTitle, _In_opt_ PCWSTR pszFormatMessage,...)
Definition: reactos.c:245
InitNtToWin32PathMappingList
VOID InitNtToWin32PathMappingList(IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList)
Definition: reactos.c:2939
PGET_ENTRY_DESCRIPTION
VOID(NTAPI * PGET_ENTRY_DESCRIPTION)(IN PGENERIC_LIST_ENTRY Entry, OUT PWSTR Buffer, IN SIZE_T cchBufferSize)
Definition: reactos.c:596
PM_INSTALL_START
#define PM_INSTALL_START
Definition: reactos.c:1887
FormatAllocStringWV
size_t FormatAllocStringWV(_In_opt_ _Outptr_ PWSTR *pString, _In_opt_ size_t cchBufferLen, _In_ PCWSTR pszFormat, _In_ va_list args)
Definition: reactos.c:150
SystemPartition
PPARTENTRY SystemPartition
Definition: reactos.c:33
PCLOSABLE_WND_INFO
struct _CLOSABLE_WND_INFO * PCLOSABLE_WND_INFO
pszTemplate
PCWSTR pszTemplate
Definition: reactos.c:3551
wpOrgPrshtProc
WNDPROC wpOrgPrshtProc
Definition: reactos.c:3446
SetWindowResTextW
VOID SetWindowResTextW(_In_ HWND hWnd, _In_opt_ HINSTANCE hInstance, _In_ UINT uID)
Definition: reactos.c:284
AddNTOSInstallationItem
static VOID NTAPI AddNTOSInstallationItem(IN HWND hWndList, IN LVITEM *plvItem, IN PGENERIC_LIST_ENTRY Entry, IN OUT PWSTR Buffer, IN SIZE_T cchBufferSize)
Definition: reactos.c:729
PrshtWndProc
static LRESULT CALLBACK PrshtWndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
Definition: reactos.c:3451
IsUnattendedSetup
static BOOLEAN IsUnattendedSetup
Definition: reactos.c:25
StartDlgProc
static INT_PTR CALLBACK StartDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:355
DisplayMessageV
INT DisplayMessageV(_In_opt_ HWND hWnd, _In_ UINT uType, _In_opt_ PCWSTR pszTitle, _In_opt_ PCWSTR pszFormatMessage, _In_ va_list args)
Definition: reactos.c:175
IncludeForUnattended
BOOL IncludeForUnattended
Definition: reactos.c:3549
SetupData
SETUPDATA SetupData
Definition: reactos.c:24
COPYCONTEXT
struct _COPYCONTEXT COPYCONTEXT
HotkeyThread
static DWORD CALLBACK HotkeyThread(LPVOID Parameter)
Definition: reactos.c:3257
EnablePrivilege
BOOL EnablePrivilege(IN LPCWSTR lpszPrivilegeName, IN BOOL bEnablePrivilege)
Definition: reactos.c:3227
FindUserClosableWindowProc
static BOOL CALLBACK FindUserClosableWindowProc(_In_ HWND hWnd, _In_ LPARAM lParam)
Definition: reactos.c:2579
pszHeaderTitle
PCWSTR pszHeaderTitle
Definition: reactos.c:3552
column_ids
static const UINT column_ids[MAX_LIST_COLUMNS]
Definition: reactos.c:789
InitGenericComboList
VOID InitGenericComboList(IN HWND hWndList, IN PGENERIC_LIST List, IN PGET_ENTRY_DESCRIPTION GetEntryDescriptionProc)
Definition: reactos.c:602
PrepareAndDoCopyThread
static DWORD WINAPI PrepareAndDoCopyThread(IN LPVOID Param)
Definition: reactos.c:1892
FileCopyCallback
static UINT CALLBACK FileCopyCallback(PVOID Context, UINT Notification, UINT_PTR Param1, UINT_PTR Param2)
Definition: reactos.c:1707
IDS_CLOSE
#define IDS_CLOSE
Definition: reactos.h:41
SETUP_ABORT_INSTALL
#define SETUP_ABORT_INSTALL
Definition: reactos.h:140
SETUP_PAGE_SWITCHING
#define SETUP_PAGE_SWITCHING
Definition: reactos.h:146
ShowDlgItem
#define ShowDlgItem(hDlg, nID, nCmdShow)
Definition: reactos.h:34
ID_WIZFINISH
#define ID_WIZFINISH
Definition: reactos.h:48
SetDlgItemFont
#define SetDlgItemFont(hDlg, nID, hFont, bRedraw)
Definition: reactos.h:37
SETUP_IS_CANCELLING
#define SETUP_IS_CANCELLING
Definition: reactos.h:143
ID_WIZNEXT
#define ID_WIZNEXT
Definition: reactos.h:47
PSETUPDATA
struct _SETUPDATA * PSETUPDATA
InterlockedFlagsTestAndSet8
#define InterlockedFlagsTestAndSet8(Target, Flags)
Definition: reactos.h:118
ID_WIZBACK
#define ID_WIZBACK
Definition: reactos.h:46
IDS_ERROR_SYSTEM_PARTITION
#define IDS_ERROR_SYSTEM_PARTITION
Definition: resource.h:187
IDC_KEYBOARD
#define IDC_KEYBOARD
Definition: resource.h:46
IDS_TYPETITLE
#define IDS_TYPETITLE
Definition: resource.h:98
IDS_RESTARTBTN
#define IDS_RESTARTBTN
Definition: resource.h:116
IDS_ABORT_NO_REBOOT
#define IDS_ABORT_NO_REBOOT
Definition: resource.h:114
IDC_FINISHTEXT
#define IDC_FINISHTEXT
Definition: resource.h:76
IDD_DRIVEPAGE
#define IDD_DRIVEPAGE
Definition: resource.h:49
IDS_CONFIG_SYSTEM_PARTITION
#define IDS_CONFIG_SYSTEM_PARTITION
Definition: resource.h:146
IDS_ERROR_FORMAT_UNRECOGNIZED_VOLUME
#define IDS_ERROR_FORMAT_UNRECOGNIZED_VOLUME
Definition: resource.h:190
IDS_DRIVESUBTITLE
#define IDS_DRIVESUBTITLE
Definition: resource.h:105
IDS_PROCESSSUBTITLE
#define IDS_PROCESSSUBTITLE
Definition: resource.h:109
IDS_FORMATTING_PROGRESS1
#define IDS_FORMATTING_PROGRESS1
Definition: resource.h:138
IDS_TYPESUBTITLE
#define IDS_TYPESUBTITLE
Definition: resource.h:99
IDC_COMPUTER
#define IDC_COMPUTER
Definition: resource.h:44
IDS_COPYING_FILES
#define IDS_COPYING_FILES
Definition: resource.h:149
IDS_ERROR_BOOTLDR_FAILED
#define IDS_ERROR_BOOTLDR_FAILED
Definition: resource.h:212
IDI_WINICON
#define IDI_WINICON
Definition: resource.h:19
IDS_UPDATETITLE
#define IDS_UPDATETITLE
Definition: resource.h:100
IDS_ERROR_COULD_NOT_CHECK
#define IDS_ERROR_COULD_NOT_CHECK
Definition: resource.h:199
IDS_PROCESSTITLE
#define IDS_PROCESSTITLE
Definition: resource.h:108
IDC_UPDATE
#define IDC_UPDATE
Definition: resource.h:36
IDS_REG_REGHIVEUPDATE
#define IDS_REG_REGHIVEUPDATE
Definition: resource.h:156
IDI_ROSICON
#define IDI_ROSICON
Definition: resource.h:18
IDS_INSTALLBTN
#define IDS_INSTALLBTN
Definition: resource.h:115
IDS_REG_CODEPAGEINFOUPDATE
#define IDS_REG_CODEPAGEINFOUPDATE
Definition: resource.h:162
IDS_UPDATESUBTITLE
#define IDS_UPDATESUBTITLE
Definition: resource.h:101
IDS_DELETING
#define IDS_DELETING
Definition: resource.h:145
IDC_UPDATETEXT
#define IDC_UPDATETEXT
Definition: resource.h:37
IDS_PREPARE_FILES
#define IDS_PREPARE_FILES
Definition: resource.h:148
IDS_REG_DONE
#define IDS_REG_DONE
Definition: resource.h:155
IDS_REG_IMPORTFILE
#define IDS_REG_IMPORTFILE
Definition: resource.h:157
IDS_PREPARE_PARTITIONS
#define IDS_PREPARE_PARTITIONS
Definition: resource.h:147
IDS_ERROR_CHECKING_PARTITION
#define IDS_ERROR_CHECKING_PARTITION
Definition: resource.h:202
IDS_ERROR_BOOTLDR_ARCH_UNSUPPORTED
#define IDS_ERROR_BOOTLDR_ARCH_UNSUPPORTED
Definition: resource.h:210
IDS_REG_UNKNOWN
#define IDS_REG_UNKNOWN
Definition: resource.h:163
IDS_ERROR_COULD_NOT_FORMAT
#define IDS_ERROR_COULD_NOT_FORMAT
Definition: resource.h:193
IDS_MOVING
#define IDS_MOVING
Definition: resource.h:143
IDS_REG_KEYBOARDSETTINGSUPDATE
#define IDS_REG_KEYBOARDSETTINGSUPDATE
Definition: resource.h:161
IDS_CAPTION
#define IDS_CAPTION
Definition: resource.h:97
IDC_PROCESSPROGRESS
#define IDC_PROCESSPROGRESS
Definition: resource.h:72
IDS_DEVICETITLE
#define IDS_DEVICETITLE
Definition: resource.h:102
IDC_WARNTEXT2
#define IDC_WARNTEXT2
Definition: resource.h:30
IDD_ABORTPAGE
#define IDD_ABORTPAGE
Definition: resource.h:78
IDD_SUMMARYPAGE
#define IDD_SUMMARYPAGE
Definition: resource.h:58
IDS_DRIVETITLE
#define IDS_DRIVETITLE
Definition: resource.h:104
IDS_ERROR_INSTALL_BOOTCODE
#define IDS_ERROR_INSTALL_BOOTCODE
Definition: resource.h:207
IDS_ERROR_WRITE_BOOT
#define IDS_ERROR_WRITE_BOOT
Definition: resource.h:205
IDC_FINISHTITLE
#define IDC_FINISHTITLE
Definition: resource.h:75
IDC_CONFIRM_INSTALL
#define IDC_CONFIRM_INSTALL
Definition: resource.h:67
IDC_SKIPUPGRADE
#define IDC_SKIPUPGRADE
Definition: resource.h:41
IDS_COPYING
#define IDS_COPYING
Definition: resource.h:142
IDS_ERROR_INSTALL_BOOTCODE_REMOVABLE
#define IDS_ERROR_INSTALL_BOOTCODE_REMOVABLE
Definition: resource.h:208
IDS_CHECKING_PROGRESS2
#define IDS_CHECKING_PROGRESS2
Definition: resource.h:141
IDS_RENAMING
#define IDS_RENAMING
Definition: resource.h:144
IDS_REG_ADDKBLAYOUTS
#define IDS_REG_ADDKBLAYOUTS
Definition: resource.h:160
IDS_CHECKING_PROGRESS1
#define IDS_CHECKING_PROGRESS1
Definition: resource.h:140
IDS_UPDATE_REGISTRY
#define IDS_UPDATE_REGISTRY
Definition: resource.h:151
IDS_POSTPONEBTN
#define IDS_POSTPONEBTN
Definition: resource.h:117
IDB_WATERMARK
#define IDB_WATERMARK
Definition: resource.h:13
IDC_ARCHITECTURE
#define IDC_ARCHITECTURE
Definition: resource.h:61
IDC_PATH
#define IDC_PATH
Definition: resource.h:81
IDC_NTOSLIST
#define IDC_NTOSLIST
Definition: resource.h:40
IDD_PROCESSPAGE
#define IDD_PROCESSPAGE
Definition: resource.h:69
IDS_NO_TXTSETUP_SIF
#define IDS_NO_TXTSETUP_SIF
Definition: resource.h:112
IDC_ACTIVITY
#define IDC_ACTIVITY
Definition: resource.h:70
IDC_WARNTEXT1
#define IDC_WARNTEXT1
Definition: resource.h:29
IDS_REG_LOCALESETTINGSUPDATE
#define IDS_REG_LOCALESETTINGSUPDATE
Definition: resource.h:159
IDC_WARNTEXT3
#define IDC_WARNTEXT3
Definition: resource.h:31
IDD_UPDATEREPAIRPAGE
#define IDD_UPDATEREPAIRPAGE
Definition: resource.h:39
IDC_ITEM
#define IDC_ITEM
Definition: resource.h:71
IDS_SUMMARYTITLE
#define IDS_SUMMARYTITLE
Definition: resource.h:106
IDS_DEVICESUBTITLE
#define IDS_DEVICESUBTITLE
Definition: resource.h:103
IDD_FINISHPAGE
#define IDD_FINISHPAGE
Definition: resource.h:74
IDS_FORMATTING_PROGRESS2
#define IDS_FORMATTING_PROGRESS2
Definition: resource.h:139
IDS_SUMMARYSUBTITLE
#define IDS_SUMMARYSUBTITLE
Definition: resource.h:107
IDS_ABORTSETUP2
#define IDS_ABORTSETUP2
Definition: resource.h:111
IDS_REG_DISPLAYSETTINGSUPDATE
#define IDS_REG_DISPLAYSETTINGSUPDATE
Definition: resource.h:158
IDC_DESTDRIVE
#define IDC_DESTDRIVE
Definition: resource.h:65
IDD_TYPEPAGE
#define IDD_TYPEPAGE
Definition: resource.h:33
IDC_INSTALLTYPE
#define IDC_INSTALLTYPE
Definition: resource.h:59
IDS_FINISH_NO_REBOOT
#define IDS_FINISH_NO_REBOOT
Definition: resource.h:113
IDS_INSTALL_BOOTLOADER
#define IDS_INSTALL_BOOTLOADER
Definition: resource.h:153
IDC_STARTTITLE
#define IDC_STARTTITLE
Definition: resource.h:28
IDS_CREATE_REGISTRY
#define IDS_CREATE_REGISTRY
Definition: resource.h:150
IDC_INSTALLSOURCE
#define IDC_INSTALLSOURCE
Definition: resource.h:60
IDC_RESTART_PROGRESS
#define IDC_RESTART_PROGRESS
Definition: resource.h:77
IDD_DEVICEPAGE
#define IDD_DEVICEPAGE
Definition: resource.h:43
IDS_ABORTSETUP
#define IDS_ABORTSETUP
Definition: resource.h:110
IDS_ERROR_WRITE_PTABLE
#define IDS_ERROR_WRITE_PTABLE
Definition: resource.h:183
IDD_STARTPAGE
#define IDD_STARTPAGE
Definition: resource.h:27
IDS_ERROR_FORMATTING_PARTITION
#define IDS_ERROR_FORMATTING_PARTITION
Definition: resource.h:196
Error
BOOL Error
Definition: chkdsk.c:66
InstallBootcodeToRemovable
NTSTATUS NTAPI InstallBootcodeToRemovable(_In_ ARCHITECTURE_TYPE ArchType, _In_ PCUNICODE_STRING RemovableRootPath, _In_ PCUNICODE_STRING SourceRootPath, _In_ PCUNICODE_STRING DestinationArcPath)
Definition: bootsup.c:1830
InstallBootManagerAndBootEntries
NTSTATUS NTAPI InstallBootManagerAndBootEntries(_In_ ARCHITECTURE_TYPE ArchType, _In_ PCUNICODE_STRING SystemRootPath, _In_ PCUNICODE_STRING SourceRootPath, _In_ PCUNICODE_STRING DestinationArcPath, _In_ ULONG_PTR Options)
Installs FreeLoader on the system and configure the boot entries.
Definition: bootsup.c:1674
_stricmp
#define _stricmp
Definition: cat.c:22
hInstance
HINSTANCE hInstance
Definition: charmap.c:19
Buffer
Definition: bufpool.h:45
Retry
_In_ PSCSI_REQUEST_BLOCK _Out_ NTSTATUS _Inout_ BOOLEAN * Retry
Definition: classpnp.h:312
wParam
WPARAM wParam
Definition: combotst.c:138
lParam
LPARAM lParam
Definition: combotst.c:139
InitCommonControlsEx
BOOL WINAPI InitCommonControlsEx(const INITCOMMONCONTROLSEX *lpInitCtrls)
Definition: commctrl.c:904
RtlCreateUnicodeString
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
ObjectAttributes
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
STATUS_NOT_SUPPORTED
#define STATUS_NOT_SUPPORTED
Definition: d3dkmdt.h:48
NO_ERROR
#define NO_ERROR
Definition: dderror.h:5
WAIT_TIMEOUT
#define WAIT_TIMEOUT
Definition: dderror.h:14
ERROR_INSUFFICIENT_BUFFER
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
PfnDliHook
FARPROC(WINAPI * PfnDliHook)(unsigned, PDelayLoadInfo)
Definition: delayimp.h:77
dliFailLoadLib
@ dliFailLoadLib
Definition: delayimp.h:37
dliNotePreLoadLibrary
@ dliNotePreLoadLibrary
Definition: delayimp.h:35
DLGPROC
#define DLGPROC
Definition: maze.c:62
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
ATOM
WORD ATOM
Definition: dimm.idl:113
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
ARRAYSIZE
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
LookupPrivilegeValueW
BOOL WINAPI LookupPrivilegeValueW(LPCWSTR lpSystemName, LPCWSTR lpPrivilegeName, PLUID lpLuid)
Definition: misc.c:782
AdjustTokenPrivileges
BOOL WINAPI AdjustTokenPrivileges(HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength)
Definition: security.c:374
OpenProcessToken
BOOL WINAPI OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle)
Definition: security.c:294
RTL_CONSTANT_STRING
#define RTL_CONSTANT_STRING(s)
Definition: combase.c:35
ImageList_Destroy
BOOL WINAPI ImageList_Destroy(HIMAGELIST himl)
Definition: imagelist.c:941
ImageList_Create
HIMAGELIST WINAPI ImageList_Create(INT cx, INT cy, UINT flags, INT cInitial, INT cGrow)
Definition: imagelist.c:814
PropertySheetW
INT_PTR WINAPI PropertySheetW(LPCPROPSHEETHEADERW lppsh)
Definition: propsheet.c:2950
CloseHandle
#define CloseHandle
Definition: compat.h:739
wcschr
#define wcschr
Definition: compat.h:17
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
FARPROC
int(* FARPROC)()
Definition: compat.h:36
wcsrchr
#define wcsrchr
Definition: compat.h:16
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
GetCurrentProcess
#define GetCurrentProcess()
Definition: compat.h:759
HWND
HANDLE HWND
Definition: compat.h:19
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735
CALLBACK
#define CALLBACK
Definition: compat.h:35
HEAP_ZERO_MEMORY
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
GlobalDeleteAtom
ATOM WINAPI GlobalDeleteAtom(ATOM nAtom)
Definition: atom.c:444
GlobalAddAtomW
ATOM WINAPI GlobalAddAtomW(LPCWSTR lpString)
Definition: atom.c:434
QueryDosDeviceW
DWORD WINAPI QueryDosDeviceW(LPCWSTR lpDeviceName, LPWSTR lpTargetPath, DWORD ucchMax)
Definition: dosdev.c:542
GetLogicalDriveStringsW
DWORD WINAPI GetLogicalDriveStringsW(IN DWORD nBufferLength, IN LPWSTR lpBuffer)
Definition: disk.c:73
GetModuleFileNameW
DWORD WINAPI GetModuleFileNameW(HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize)
Definition: loader.c:600
GetModuleHandleW
HMODULE WINAPI GetModuleHandleW(LPCWSTR lpModuleName)
Definition: loader.c:838
CreateProcessW
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
Definition: proc.c:4441
ExitProcess
VOID WINAPI ExitProcess(IN UINT uExitCode)
Definition: proc.c:1330
CreateThread
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
GetThreadId
DWORD WINAPI GetThreadId(IN HANDLE Thread)
Definition: thread.c:913
GetExitCodeThread
BOOL WINAPI GetExitCodeThread(IN HANDLE hThread, OUT LPDWORD lpExitCode)
Definition: thread.c:541
GetUserDefaultLCID
LCID WINAPI GetUserDefaultLCID(void)
Definition: locale.c:1216
IS_INTRESOURCE
#define IS_INTRESOURCE(x)
Definition: loader.c:613
OUTPUT
#define OUTPUT(ch)
CopyContext
BOOL WINAPI CopyContext(CONTEXT *dst, DWORD context_flags, CONTEXT *src)
Definition: memory.c:1633
SYMBOLIC_LINK_QUERY
#define SYMBOLIC_LINK_QUERY
Definition: volume.c:47
__cdecl
#define __cdecl
Definition: corecrt.h:121
_vscwprintf
_ACRTIMP int __cdecl _vscwprintf(const wchar_t *, va_list)
Definition: wcs.c:1787
swscanf
_ACRTIMP int __cdecl swscanf(const wchar_t *, const wchar_t *,...)
Definition: scanf.c:438
wcstol
_ACRTIMP __msvcrt_long __cdecl wcstol(const wchar_t *, wchar_t **, int)
Definition: wcs.c:2752
_wcsicmp
_ACRTIMP int __cdecl _wcsicmp(const wchar_t *, const wchar_t *)
Definition: wcs.c:164
wcslen
_ACRTIMP size_t __cdecl wcslen(const wchar_t *)
Definition: wcs.c:2988
_wcsnicmp
_ACRTIMP int __cdecl _wcsnicmp(const wchar_t *, const wchar_t *, size_t)
Definition: wcs.c:200
va_end
#define va_end(v)
Definition: stdarg.h:28
va_start
#define va_start(v, l)
Definition: stdarg.h:26
va_list
char * va_list
Definition: vadefs.h:50
CmdLine
static const WCHAR CmdLine[]
Definition: install.c:48
FindVolCreateInTreeByVolume
PVOL_CREATE_INFO FindVolCreateInTreeByVolume(_In_ HWND hTreeList, _In_ PVOLENTRY Volume)
Definition: drivepage.c:835
DriveDlgProc
INT_PTR CALLBACK DriveDlgProc(_In_ HWND hwndDlg, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam)
Definition: drivepage.c:1704
L
#define L(x)
Definition: resources.c:13
tp
_In_ uint64_t _In_ uint64_t _In_ uint64_t _In_opt_ traverse_ptr * tp
Definition: btrfs.c:2996
INFINITE
#define INFINITE
Definition: serial.h:102
ULONG_PTR
#define ULONG_PTR
Definition: config.h:101
PtrToUlong
#define PtrToUlong(u)
Definition: config.h:107
FloppyDrive
static PDISK_IMAGE FloppyDrive[2]
Definition: dskbios32.c:36
hInst
HINSTANCE hInst
Definition: dxdiag.c:13
Fail
int Fail
Definition: ehthrow.cxx:24
InsertHeadList
#define InsertHeadList(ListHead, Entry)
Definition: env_spec_w32.h:1022
IsListEmpty
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
RemoveHeadList
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964
InitializeListHead
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
ERROR_NUMBER
enum _ERROR_NUMBER ERROR_NUMBER
ERROR_WRITE_BOOT
@ ERROR_WRITE_BOOT
Definition: errorcode.h:28
ERROR_LOAD_TXTSETUPSIF
@ ERROR_LOAD_TXTSETUPSIF
Definition: errorcode.h:24
ERROR_NO_SOURCE_DRIVE
@ ERROR_NO_SOURCE_DRIVE
Definition: errorcode.h:23
ERROR_INSTALL_BOOTCODE
@ ERROR_INSTALL_BOOTCODE
Definition: errorcode.h:35
Success
@ Success
Definition: eventcreate.c:712
EnableDlgItem
#define EnableDlgItem(hDlg, nID, bEnable)
Definition: eventvwr.h:55
SPFILENOTIFY_ENDDELETE
#define SPFILENOTIFY_ENDDELETE
Definition: fileqsup.h:28
FILEOP_COPY
#define FILEOP_COPY
Definition: fileqsup.h:42
PFILEPATHS_W
struct _FILEPATHS_W * PFILEPATHS_W
FILEOP_SKIP
#define FILEOP_SKIP
Definition: fileqsup.h:49
SPFILENOTIFY_STARTDELETE
#define SPFILENOTIFY_STARTDELETE
Definition: fileqsup.h:27
SPFILENOTIFY_STARTSUBQUEUE
#define SPFILENOTIFY_STARTSUBQUEUE
Definition: fileqsup.h:24
FILEOP_DOIT
#define FILEOP_DOIT
Definition: fileqsup.h:48
SPFILENOTIFY_ENDCOPY
#define SPFILENOTIFY_ENDCOPY
Definition: fileqsup.h:36
SPFILENOTIFY_STARTCOPY
#define SPFILENOTIFY_STARTCOPY
Definition: fileqsup.h:35
SPFILENOTIFY_COPYERROR
#define SPFILENOTIFY_COPYERROR
Definition: fileqsup.h:37
FILEOP_RENAME
#define FILEOP_RENAME
Definition: fileqsup.h:43
SPFILENOTIFY_STARTRENAME
#define SPFILENOTIFY_STARTRENAME
Definition: fileqsup.h:31
SPFILENOTIFY_ENDRENAME
#define SPFILENOTIFY_ENDRENAME
Definition: fileqsup.h:32
FILEOP_DELETE
#define FILEOP_DELETE
Definition: fileqsup.h:44
FILEOP_ABORT
#define FILEOP_ABORT
Definition: fileqsup.h:47
WORD
unsigned short WORD
Definition: ntddk_ex.h:93
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
PTEXTOUTPUT
struct TEXTOUTPUT * PTEXTOUTPUT
CALLBACKCOMMAND
CALLBACKCOMMAND
Definition: fmifs.h:82
PROGRESS
@ PROGRESS
Definition: fmifs.h:83
IDC_INSTALL
#define IDC_INSTALL
Definition: fontview.h:13
pString
FxString * pString
Definition: fxdeviceapi.cpp:180
Status
Status
Definition: gdiplustypes.h:24
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
UINT
unsigned int UINT
Definition: sysinfo.c:13
NtRaiseHardError
NTSTATUS NTAPI NtRaiseHardError(IN NTSTATUS ErrorStatus, IN ULONG NumberOfParameters, IN ULONG UnicodeStringParameterMask, IN PULONG_PTR Parameters, IN ULONG ValidResponseOptions, OUT PULONG Response)
Definition: harderr.c:551
MOD_SHIFT
#define MOD_SHIFT
Definition: imm.h:186
_tWinMain
#define _tWinMain
Definition: tchar.h:498
InterlockedOr8
#define InterlockedOr8
Definition: interlocked.h:244
SUCCEEDED
#define SUCCEEDED(hr)
Definition: intsafe.h:50
C_ASSERT
#define C_ASSERT(e)
Definition: intsafe.h:73
LANGID
USHORT LANGID
Definition: mui.h:9
SpFileExports
SPFILE_EXPORTS SpFileExports
Definition: fileqsup.c:23
SpInfExports
SPINF_EXPORTS SpInfExports
Definition: infsupp.c:24
GetNumberOfListEntries
ULONG NTAPI GetNumberOfListEntries(IN PGENERIC_LIST List)
Definition: genlist.c:149
SetCurrentListEntry
VOID NTAPI SetCurrentListEntry(IN PGENERIC_LIST List, IN PGENERIC_LIST_ENTRY Entry)
Definition: genlist.c:91
GetFirstListEntry
PGENERIC_LIST_ENTRY NTAPI GetFirstListEntry(IN PGENERIC_LIST List)
Definition: genlist.c:110
GetNextListEntry
PGENERIC_LIST_ENTRY NTAPI GetNextListEntry(IN PGENERIC_LIST_ENTRY Entry)
Definition: genlist.c:121
GetCurrentListEntry
PGENERIC_LIST_ENTRY NTAPI GetCurrentListEntry(IN PGENERIC_LIST List)
Definition: genlist.c:102
GetListEntryData
PVOID NTAPI GetListEntryData(IN PGENERIC_LIST_ENTRY Entry)
Definition: genlist.c:134
hList
HWND hList
Definition: livecd.c:10
LPARAM
LONG_PTR LPARAM
Definition: minwindef.h:175
LRESULT
LONG_PTR LRESULT
Definition: minwindef.h:176
WPARAM
UINT_PTR WPARAM
Definition: minwindef.h:174
pch
#define pch(ap)
Definition: match.c:418
memmove
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
ASSERT
#define ASSERT(a)
Definition: mode.c:44
ptr
static PVOID ptr
Definition: dispmode.c:27
hdc
HDC hdc
Definition: main.c:9
HDC
static HDC
Definition: imagelist.c:88
HICON
static HICON
Definition: imagelist.c:80
pi
static PROCESS_INFORMATION pi
Definition: debugger.c:2303
si
static SYSTEM_INFO si
Definition: virtual.c:39
InitializeObjectAttributes
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:115
HMENU
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:60
LPTSTR
LPSTR LPTSTR
Definition: ms-dtyp.idl:131
hIcon
HICON hIcon
Definition: msconfig.c:44
HPROPSHEETPAGE
struct _PSP * HPROPSHEETPAGE
Definition: mstask.idl:90
LONG_PTR
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
UINT_PTR
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
MulDiv
INT WINAPI MulDiv(INT nNumber, INT nNumerator, INT nDenominator)
Definition: muldiv.c:25
HARDERROR_OVERRIDE_ERRORMODE
#define HARDERROR_OVERRIDE_ERRORMODE
Definition: extypes.h:146
OptionOk
@ OptionOk
Definition: extypes.h:187
_Outptr_
#define _Outptr_
Definition: no_sal2.h:262
_In_
#define _In_
Definition: no_sal2.h:158
_In_opt_
#define _In_opt_
Definition: no_sal2.h:212
RtlAnsiStringToUnicodeString
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NtClose
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3411
RtlFreeUnicodeString
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
RtlInitAnsiString
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
RTL_NUMBER_OF_FIELD
#define RTL_NUMBER_OF_FIELD(type, field)
Definition: ntbasedef.h:715
UNICODE_NULL
#define UNICODE_NULL
DBG_UNREFERENCED_PARAMETER
#define DBG_UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:330
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
Enable
_In_ ULONGLONG _In_ ULONGLONG _In_ BOOLEAN Enable
Definition: ntddpcm.h:142
STATUS_DLL_NOT_FOUND
#define STATUS_DLL_NOT_FOUND
Definition: ntstatus.h:639
STATUS_PARTITION_FAILURE
#define STATUS_PARTITION_FAILURE
Definition: ntstatus.h:698
CreateNTOSInstallationsList
PGENERIC_LIST NTAPI CreateNTOSInstallationsList(_In_ PPARTLIST PartList)
Create a list of available NT OS installations on the computer, by searching for recognized ones on e...
Definition: osdetect.c:768
VENDOR_MICROSOFT
#define VENDOR_MICROSOFT
Definition: osdetect.h:13
PNTOS_INSTALLATION
struct _NTOS_INSTALLATION * PNTOS_INSTALLATION
VENDOR_REACTOS
#define VENDOR_REACTOS
Definition: osdetect.h:12
LOWORD
#define LOWORD(l)
Definition: pedump.c:82
WCHAR
short WCHAR
Definition: pedump.c:58
WS_VISIBLE
#define WS_VISIBLE
Definition: pedump.c:620
CHAR
char CHAR
Definition: pedump.c:57
PSBTN_CANCEL
#define PSBTN_CANCEL
Definition: prsht.h:151
PropSheet_PressButton
#define PropSheet_PressButton(d, i)
Definition: prsht.h:348
CreatePropertySheetPage
#define CreatePropertySheetPage
Definition: prsht.h:399
PSCB_PRECREATE
#define PSCB_PRECREATE
Definition: prsht.h:76
PSM_SETWIZBUTTONS
#define PSM_SETWIZBUTTONS
Definition: prsht.h:157
PSH_USECALLBACK
#define PSH_USECALLBACK
Definition: prsht.h:48
PSP_USETITLE
#define PSP_USETITLE
Definition: prsht.h:26
PSN_QUERYCANCEL
#define PSN_QUERYCANCEL
Definition: prsht.h:123
PSN_WIZNEXT
#define PSN_WIZNEXT
Definition: prsht.h:121
PSP_DEFAULT
#define PSP_DEFAULT
Definition: prsht.h:22
PSWIZB_NEXT
#define PSWIZB_NEXT
Definition: prsht.h:154
PSWIZB_FINISH
#define PSWIZB_FINISH
Definition: prsht.h:155
PSN_KILLACTIVE
#define PSN_KILLACTIVE
Definition: prsht.h:116
PSBTN_FINISH
#define PSBTN_FINISH
Definition: prsht.h:148
PSWIZB_BACK
#define PSWIZB_BACK
Definition: prsht.h:153
PSBTN_NEXT
#define PSBTN_NEXT
Definition: prsht.h:147
PropSheet_SetWizButtons
#define PropSheet_SetWizButtons(d, f)
Definition: prsht.h:357
PSN_QUERYINITIALFOCUS
#define PSN_QUERYINITIALFOCUS
Definition: prsht.h:126
PSN_WIZFINISH
#define PSN_WIZFINISH
Definition: prsht.h:122
PropSheet_SetCurSelByID
#define PropSheet_SetCurSelByID(d, i)
Definition: prsht.h:354
LPPROPSHEETPAGEW
struct _PROPSHEETPAGEW * LPPROPSHEETPAGEW
PSH_USEICONID
#define PSH_USEICONID
Definition: prsht.h:42
PSCB_INITIALIZED
#define PSCB_INITIALIZED
Definition: prsht.h:75
PSN_WIZBACK
#define PSN_WIZBACK
Definition: prsht.h:120
PSN_SETACTIVE
#define PSN_SETACTIVE
Definition: prsht.h:115
LVSIL_SMALL
#define LVSIL_SMALL
Definition: commctrl.h:2304
LVM_SETITEMTEXTW
#define LVM_SETITEMTEXTW
Definition: commctrl.h:2692
ListView_SetItemState
#define ListView_SetItemState(hwndLV, i, data, mask)
Definition: commctrl.h:2678
ListView_SetExtendedListViewStyleEx
#define ListView_SetExtendedListViewStyleEx(hwndLV, dwMask, dw)
Definition: commctrl.h:2731
PBM_SETSTEP
#define PBM_SETSTEP
Definition: commctrl.h:2191
PBM_GETPOS
#define PBM_GETPOS
Definition: commctrl.h:2199
ICC_TREEVIEW_CLASSES
#define ICC_TREEVIEW_CLASSES
Definition: commctrl.h:59
ListView_InsertColumn
#define ListView_InsertColumn(hwnd, iCol, pcol)
Definition: commctrl.h:2641
PBS_MARQUEE
#define PBS_MARQUEE
Definition: commctrl.h:2203
LVIF_STATE
#define LVIF_STATE
Definition: commctrl.h:2317
ListView_SetImageList
#define ListView_SetImageList(hwnd, himl, iImageList)
Definition: commctrl.h:2309
LVCF_WIDTH
#define LVCF_WIDTH
Definition: commctrl.h:2592
ListView_GetImageList
#define ListView_GetImageList(hwnd, iImageList)
Definition: commctrl.h:2301
ILC_COLOR32
#define ILC_COLOR32
Definition: commctrl.h:358
LVS_EX_FULLROWSELECT
#define LVS_EX_FULLROWSELECT
Definition: commctrl.h:2739
PBM_SETPOS
#define PBM_SETPOS
Definition: commctrl.h:2189
PBM_SETRANGE
#define PBM_SETRANGE
Definition: commctrl.h:2188
LVIS_SELECTED
#define LVIS_SELECTED
Definition: commctrl.h:2324
ICC_PROGRESS_CLASS
#define ICC_PROGRESS_CLASS
Definition: commctrl.h:63
ListView_GetSelectionMark
#define ListView_GetSelectionMark(hwnd)
Definition: commctrl.h:2794
LVITEM
#define LVITEM
Definition: commctrl.h:2380
PBM_STEPIT
#define PBM_STEPIT
Definition: commctrl.h:2192
LVIF_PARAM
#define LVIF_PARAM
Definition: commctrl.h:2316
LPNMLISTVIEW
struct tagNMLISTVIEW * LPNMLISTVIEW
LVIF_TEXT
#define LVIF_TEXT
Definition: commctrl.h:2314
LVCF_FMT
#define LVCF_FMT
Definition: commctrl.h:2591
ImageList_AddIcon
#define ImageList_AddIcon(himl, hicon)
Definition: commctrl.h:415
LVCF_SUBITEM
#define LVCF_SUBITEM
Definition: commctrl.h:2594
LVCFMT_LEFT
#define LVCFMT_LEFT
Definition: commctrl.h:2603
ILC_MASK
#define ILC_MASK
Definition: commctrl.h:351
LVIF_IMAGE
#define LVIF_IMAGE
Definition: commctrl.h:2315
LVN_ITEMCHANGED
#define LVN_ITEMCHANGED
Definition: commctrl.h:3136
LVM_INSERTITEMW
#define LVM_INSERTITEMW
Definition: commctrl.h:2409
LVCF_TEXT
#define LVCF_TEXT
Definition: commctrl.h:2593
LVIS_FOCUSED
#define LVIS_FOCUSED
Definition: commctrl.h:2323
ListView_GetItem
#define ListView_GetItem(hwnd, pitem)
Definition: commctrl.h:2399
PBM_SETMARQUEE
#define PBM_SETMARQUEE
Definition: commctrl.h:2204
LVCOLUMN
#define LVCOLUMN
Definition: commctrl.h:2586
ListView_EnsureVisible
#define ListView_EnsureVisible(hwndLV, i, fPartialOK)
Definition: commctrl.h:2524
ICC_LISTVIEW_CLASSES
#define ICC_LISTVIEW_CLASSES
Definition: commctrl.h:58
dwStatus
DWORD dwStatus
Definition: mediaobj.idl:95
uID
_In_ UINT uID
Definition: shlwapi.h:156
OBJ_CASE_INSENSITIVE
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
WM_NOTIFY
#define WM_NOTIFY
Definition: richedit.h:61
DONE
#define DONE
Definition: rnr20lib.h:14
__fallthrough
#define __fallthrough
Definition: sal_old.h:314
LANG_NEUTRAL
#define LANG_NEUTRAL
Definition: nls.h:22
MAKELANGID
#define MAKELANGID(p, s)
Definition: nls.h:15
SUBLANG_DEFAULT
#define SUBLANG_DEFAULT
Definition: nls.h:168
LCID
DWORD LCID
Definition: nls.h:13
wcscpy
wcscpy
Definition: corecrt_wstring.h:120
LoadStringW
#define LoadStringW
Definition: utils.h:64
args
#define args
Definition: format.c:66
Entry
Entry
Definition: section.c:5216
FsVolCommitOpsQueue
BOOLEAN NTAPI FsVolCommitOpsQueue(_In_ PPARTLIST PartitionList, _In_ PVOLENTRY SystemVolume, _In_ PVOLENTRY InstallVolume, _In_opt_ PFSVOL_CALLBACK FsVolCallback, _In_opt_ PVOID Context)
Definition: fsutil.c:1097
FSVOLNOTIFY_STARTCHECK
@ FSVOLNOTIFY_STARTCHECK
Definition: fsutil.h:153
FSVOLNOTIFY_ENDQUEUE
@ FSVOLNOTIFY_ENDQUEUE
Definition: fsutil.h:145
FSVOLNOTIFY_STARTSUBQUEUE
@ FSVOLNOTIFY_STARTSUBQUEUE
Definition: fsutil.h:146
FSVOLNOTIFY_ENDFORMAT
@ FSVOLNOTIFY_ENDFORMAT
Definition: fsutil.h:151
FSVOLNOTIFY_STARTFORMAT
@ FSVOLNOTIFY_STARTFORMAT
Definition: fsutil.h:150
FSVOLNOTIFY_STARTQUEUE
@ FSVOLNOTIFY_STARTQUEUE
Definition: fsutil.h:144
FSVOLNOTIFY_ENDSUBQUEUE
@ FSVOLNOTIFY_ENDSUBQUEUE
Definition: fsutil.h:147
FSVOLNOTIFY_PARTITIONERROR
@ FSVOLNOTIFY_PARTITIONERROR
Definition: fsutil.h:149
FSVOLNOTIFY_CHECKERROR
@ FSVOLNOTIFY_CHECKERROR
Definition: fsutil.h:155
ChangeSystemPartition
@ ChangeSystemPartition
Definition: fsutil.h:156
FSVOLNOTIFY_FORMATERROR
@ FSVOLNOTIFY_FORMATERROR
Definition: fsutil.h:152
FSVOLNOTIFY_ENDCHECK
@ FSVOLNOTIFY_ENDCHECK
Definition: fsutil.h:154
FSVOL_OP
enum _FSVOL_OP FSVOL_OP
PFORMAT_VOLUME_INFO
struct _FORMAT_VOLUME_INFO * PFORMAT_VOLUME_INFO
FSVOL_FORMAT
@ FSVOL_FORMAT
Definition: fsutil.h:162
FSVOL_CHECK
@ FSVOL_CHECK
Definition: fsutil.h:163
FSVOL_DOIT
@ FSVOL_DOIT
Definition: fsutil.h:166
FSVOL_ABORT
@ FSVOL_ABORT
Definition: fsutil.h:165
FSVOL_RETRY
@ FSVOL_RETRY
Definition: fsutil.h:167
FSVOL_SKIP
@ FSVOL_SKIP
Definition: fsutil.h:168
FSVOLNOTIFY
enum _FSVOLNOTIFY FSVOLNOTIFY
PCHECK_VOLUME_INFO
struct _CHECK_VOLUME_INFO * PCHECK_VOLUME_INFO
CreatePartitionList
PPARTLIST NTAPI CreatePartitionList(VOID)
Definition: partlist.c:2043
InstallSetupInfFile
VOID NTAPI InstallSetupInfFile(IN OUT PUSETUP_DATA pSetupData)
Definition: setuplib.c:208
InitializeSetup
ERROR_NUMBER NTAPI InitializeSetup(_Inout_ PUSETUP_DATA pSetupData, _In_opt_ PSETUP_ERROR_ROUTINE ErrorRoutine, _In_ PSPFILE_EXPORTS pSpFileExports, _In_ PSPINF_EXPORTS pSpInfExports)
Definition: setuplib.c:1022
InitDestinationPaths
NTSTATUS NTAPI InitDestinationPaths(_Inout_ PUSETUP_DATA pSetupData, _In_ PCWSTR InstallationDir, _In_ PVOLENTRY Volume)
Definition: setuplib.c:866
InitSystemPartition
BOOLEAN NTAPI InitSystemPartition(_In_ PPARTLIST PartitionList, _In_ PPARTENTRY InstallPartition, _Out_ PPARTENTRY *pSystemPartition, _In_opt_ PFSVOL_CALLBACK FsVolCallback, _In_opt_ PVOID Context)
Find or set the active system partition.
Definition: setuplib.c:681
CheckUnattendedSetup
BOOLEAN NTAPI CheckUnattendedSetup(IN OUT PUSETUP_DATA pSetupData)
Definition: setuplib.c:32
FinishSetup
VOID NTAPI FinishSetup(IN OUT PUSETUP_DATA pSetupData)
Definition: setuplib.c:1106
UpdateRegistry
ERROR_NUMBER NTAPI UpdateRegistry(IN OUT PUSETUP_DATA pSetupData, IN BOOLEAN RepairUpdateFlag, IN PPARTLIST PartitionList, IN WCHAR DestinationDriveLetter, IN PCWSTR SelectedLanguageId, IN PREGISTRY_STATUS_ROUTINE StatusRoutine OPTIONAL, IN PFONTSUBSTSETTINGS SubstSettings OPTIONAL)
Definition: setuplib.c:1157
ERROR_SYSTEM_PARTITION_NOT_FOUND
#define ERROR_SYSTEM_PARTITION_NOT_FOUND
Definition: setuplib.h:188
REGISTRY_STATUS
enum _REGISTRY_STATUS REGISTRY_STATUS
STATUS_DEVICE_NOT_READY
#define STATUS_DEVICE_NOT_READY
Definition: shellext.h:70
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
DPRINT
#define DPRINT
Definition: sndvol32.h:73
_countof
#define _countof(array)
Definition: sndvol32.h:70
Context
_In_ PVOID Context
Definition: storport.h:2269
FindSubStrI
LPTSTR FindSubStrI(LPCTSTR str, LPCTSTR strSearch)
Definition: stringutils.c:183
StringCchPrintfW
STRSAFEAPI StringCchPrintfW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:530
StringCchVPrintfW
STRSAFEAPI StringCchVPrintfW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszFormat, va_list argList)
Definition: strsafe.h:490
StringCchCopyW
STRSAFEAPI StringCchCopyW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:149
StringCchCopyNW
STRSAFEAPI StringCchCopyNW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc, size_t cchToCopy)
Definition: strsafe.h:236
StringCchPrintfA
STRSAFEAPI StringCchPrintfA(STRSAFE_LPSTR pszDest, size_t cchDest, STRSAFE_LPCSTR pszFormat,...)
Definition: strsafe.h:520
Command
Definition: shell.h:41
DLGTEMPLATEEX::signature
WORD signature
Definition: msconfig.c:127
DLGTEMPLATEEX::helpID
DWORD helpID
Definition: msconfig.c:128
DLGTEMPLATEEX::cDlgItems
WORD cDlgItems
Definition: msconfig.c:131
DLGTEMPLATEEX::exStyle
DWORD exStyle
Definition: msconfig.c:129
DLGTEMPLATEEX::style
DWORD style
Definition: msconfig.c:130
DLGTEMPLATE::style
DWORD style
Definition: winuser.h:3167
DelayLoadInfo::szDll
LPCSTR szDll
Definition: delayimp.h:70
LOGFONTW::lfHeight
LONG lfHeight
Definition: dimm.idl:59
LOGFONTW::lfWeight
LONG lfWeight
Definition: dimm.idl:63
MSGBOXPARAMSW::dwLanguageId
DWORD dwLanguageId
Definition: winuser.h:3453
MSGBOXPARAMSW::lpszCaption
LPCWSTR lpszCaption
Definition: winuser.h:3448
MSGBOXPARAMSW::hwndOwner
HWND hwndOwner
Definition: winuser.h:3445
MSGBOXPARAMSW::lpszText
LPCWSTR lpszText
Definition: winuser.h:3447
MSGBOXPARAMSW::hInstance
HINSTANCE hInstance
Definition: winuser.h:3446
MSGBOXPARAMSW::dwStyle
DWORD dwStyle
Definition: winuser.h:3449
Response
Definition: ncftp.h:89
TEXTOUTPUT::Output
PCHAR Output
Definition: fmifs.h:33
_ANSI_STRING
Definition: env_spec_w32.h:375
_CHECK_VOLUME_INFO
Definition: fsutil.h:188
_CHECK_VOLUME_INFO::Verbose
BOOLEAN Verbose
Definition: fsutil.h:195
_CHECK_VOLUME_INFO::ErrorStatus
NTSTATUS ErrorStatus
Definition: fsutil.h:191
_CHECK_VOLUME_INFO::Volume
PVOLENTRY Volume
Definition: fsutil.h:189
_CHECK_VOLUME_INFO::Callback
PFMIFSCALLBACK Callback
Definition: fsutil.h:198
_CHECK_VOLUME_INFO::CheckOnlyIfDirty
BOOLEAN CheckOnlyIfDirty
Definition: fsutil.h:196
_CHECK_VOLUME_INFO::FixErrors
BOOLEAN FixErrors
Definition: fsutil.h:194
_CHECK_VOLUME_INFO::ScanDrive
BOOLEAN ScanDrive
Definition: fsutil.h:197
_CLOSABLE_WND_INFO
Definition: reactos.c:2573
_CLOSABLE_WND_INFO::Found
BOOL Found
TRUE if a closable window was found; FALSE if not.
Definition: reactos.c:2575
_CLOSABLE_WND_INFO::hWndExclude
HWND hWndExclude
Window to exclude from search.
Definition: reactos.c:2574
_COPYCONTEXT
Definition: reactos.c:1699
_COPYCONTEXT::TotalOperations
ULONG TotalOperations
Definition: reactos.c:1701
_COPYCONTEXT::CompletedOperations
ULONG CompletedOperations
Definition: reactos.c:1702
_COPYCONTEXT::pSetupData
PSETUPDATA pSetupData
Definition: reactos.c:1700
_FILEPATHS_W
Definition: fileqsup.h:59
_FILEPATHS_W::Win32Error
UINT Win32Error
Definition: fileqsup.h:62
_FILEPATHS_W::Source
PCWSTR Source
Definition: fileqsup.h:61
_FILEPATHS_W::Target
PCWSTR Target
Definition: fileqsup.h:60
_FORMAT_VOLUME_INFO
Definition: fsutil.h:172
_FORMAT_VOLUME_INFO::Callback
PFMIFSCALLBACK Callback
Definition: fsutil.h:183
_FORMAT_VOLUME_INFO::QuickFormat
BOOLEAN QuickFormat
Definition: fsutil.h:181
_FORMAT_VOLUME_INFO::ClusterSize
ULONG ClusterSize
Definition: fsutil.h:182
_FORMAT_VOLUME_INFO::ErrorStatus
NTSTATUS ErrorStatus
Definition: fsutil.h:175
_FORMAT_VOLUME_INFO::Volume
PVOLENTRY Volume
Definition: fsutil.h:173
_FORMAT_VOLUME_INFO::MediaFlag
FMIFS_MEDIA_FLAG MediaFlag
Definition: fsutil.h:179
_FORMAT_VOLUME_INFO::FileSystemName
PCWSTR FileSystemName
Definition: fsutil.h:178
_FORMAT_VOLUME_INFO::Label
PCWSTR Label
Definition: fsutil.h:180
_FSVOL_CONTEXT
Definition: reactos.c:1288
_FSVOL_CONTEXT::pSetupData
PSETUPDATA pSetupData
Definition: reactos.c:1289
_GENENTRY
Definition: settings.h:31
_GENERIC_LIST_ENTRY
Definition: genlist.h:11
_GENERIC_LIST
Definition: genlist.h:19
_IMAGELIST
Definition: imagelist.c:84
_LIST_ENTRY
Definition: typedefs.h:120
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
_NTOS_INSTALLATION
Definition: osdetect.h:16
_NTOS_INSTALLATION::InstallationName
WCHAR InstallationName[MAX_PATH]
Definition: osdetect.h:26
_NTOS_INSTALLATION::SystemNtPath
UNICODE_STRING SystemNtPath
Definition: osdetect.h:21
_NTOS_INSTALLATION::VendorName
WCHAR VendorName[MAX_PATH]
Definition: osdetect.h:27
_NTOS_INSTALLATION::Volume
PVOLENTRY Volume
Definition: osdetect.h:25
_NTOS_INSTALLATION::PathComponent
PCWSTR PathComponent
Definition: osdetect.h:22
_NT_WIN32_PATH_MAPPING_LIST
Definition: reactos.h:103
_NT_WIN32_PATH_MAPPING
Definition: reactos.h:95
_OBJECT_ATTRIBUTES
Definition: umtypes.h:184
_PARTENTRY
Definition: partlist.h:62
_PARTENTRY::DeviceName
WCHAR DeviceName[MAX_PATH]
NT device name: "\Device\HarddiskM\PartitionN".
Definition: partlist.h:77
_PARTENTRY::DiskEntry
struct _DISKENTRY * DiskEntry
Definition: partlist.h:66
_PARTENTRY::OnDiskPartitionNumber
ULONG OnDiskPartitionNumber
Definition: partlist.h:74
_PROCESS_INFORMATION
Definition: processthreadsapi.h:65
_PROCESS_INFORMATION::hThread
HANDLE hThread
Definition: processthreadsapi.h:67
_PROCESS_INFORMATION::hProcess
HANDLE hProcess
Definition: processthreadsapi.h:66
_PROPSHEETHEADERW
Definition: prsht.h:292
_PROPSHEETHEADERW::hInstance
HINSTANCE hInstance
Definition: prsht.h:296
_PROPSHEETHEADERW::dwSize
DWORD dwSize
Definition: prsht.h:293
_PROPSHEETHEADERW::dwFlags
DWORD dwFlags
Definition: prsht.h:294
_PROPSHEETHEADERW::pszIcon
LPCWSTR pszIcon
Definition: prsht.h:299
_PROPSHEETHEADERW::hwndParent
HWND hwndParent
Definition: prsht.h:295
_PROPSHEETHEADERW::pfnCallback
PFNPROPSHEETCALLBACK pfnCallback
Definition: prsht.h:311
_PROPSHEETHEADERW::phpage
HPROPSHEETPAGE * phpage
Definition: prsht.h:309
_PROPSHEETHEADERW::nStartPage
UINT nStartPage
Definition: prsht.h:304
_PROPSHEETHEADERW::nPages
UINT nPages
Definition: prsht.h:302
_PROPSHEETPAGEW
Definition: prsht.h:213
_PROPSHEETPAGEW::pfnDlgProc
DLGPROC pfnDlgProc
Definition: prsht.h:226
_PROPSHEETPAGEW::dwSize
DWORD dwSize
Definition: prsht.h:214
_PROPSHEETPAGEW::dwFlags
DWORD dwFlags
Definition: prsht.h:215
_PROPSHEETPAGEW::lParam
LPARAM lParam
Definition: prsht.h:227
_PROPSHEETPAGEW::pszTemplate
LPCWSTR pszTemplate
Definition: prsht.h:218
_PROPSHEETPAGEW::pszTitle
LPCWSTR pszTitle
Definition: prsht.h:225
_PROPSHEETPAGEW::hInstance
HINSTANCE hInstance
Definition: prsht.h:216
_SETUPDATA
Definition: reactos.h:125
_SETUPDATA::bStopInstall
BOOLEAN bStopInstall
Definition: reactos.h:151
_SETUPDATA::USetupData
USETUP_DATA USetupData
Definition: reactos.h:156
_SETUPDATA::hInstance
HINSTANCE hInstance
Definition: reactos.h:127
_SETUPDATA::bAbortInstall
UCHAR bAbortInstall
Definition: reactos.h:141
_SETUPDATA::hBoldFont
HFONT hBoldFont
Definition: reactos.h:132
_SETUPDATA::SelectedLanguageId
PCWSTR SelectedLanguageId
Definition: reactos.h:171
_SETUPDATA::hTitleFont
HFONT hTitleFont
Definition: reactos.h:131
_SETUPDATA::hInstallThread
HANDLE hInstallThread
Definition: reactos.h:134
_SETUPDATA::CurrentInstallation
PNTOS_INSTALLATION CurrentInstallation
Definition: reactos.h:161
_SETUPDATA::bMustReboot
BOOL bMustReboot
Definition: reactos.h:129
_SETUPDATA::PartitionList
PPARTLIST PartitionList
Definition: reactos.h:160
_SETUPDATA::bPageSwitching
UCHAR bPageSwitching
Definition: reactos.h:147
_SETUPDATA::hHaltInstallEvent
HANDLE hHaltInstallEvent
Definition: reactos.h:135
_SETUPDATA::NtOsInstallsList
PGENERIC_LIST NtOsInstallsList
Definition: reactos.h:162
_SETUPDATA::MappingList
NT_WIN32_PATH_MAPPING_LIST MappingList
Definition: reactos.h:154
_SETUPDATA::RepairUpdateFlag
BOOLEAN RepairUpdateFlag
Definition: reactos.h:158
_SETUPDATA::bUnattend
BOOL bUnattend
Definition: reactos.h:128
_STARTUPINFOW
Definition: processthreadsapi.h:37
_TOKEN_PRIVILEGES
Definition: setypes.h:1034
_UI_CONTEXT
Definition: reactos.h:69
_UI_CONTEXT::hWndItem
HWND hWndItem
Definition: reactos.h:72
_UI_CONTEXT::hPartList
HWND hPartList
Definition: reactos.h:70
_UI_CONTEXT::hWndProgress
HWND hWndProgress
Definition: reactos.h:73
_UI_CONTEXT::dwPbStyle
LONG_PTR dwPbStyle
Definition: reactos.h:74
_UI_CONTEXT::hwndDlg
HWND hwndDlg
Definition: reactos.h:71
_UNICODE_STRING
Definition: env_spec_w32.h:368
_UNICODE_STRING::Length
USHORT Length
Definition: env_spec_w32.h:369
_UNICODE_STRING::MaximumLength
USHORT MaximumLength
Definition: env_spec_w32.h:370
_USETUP_DATA::DisplayList
PGENERIC_LIST DisplayList
Definition: setuplib.h:139
_USETUP_DATA::DestinationRootPath
UNICODE_STRING DestinationRootPath
Definition: setuplib.h:124
_USETUP_DATA::ComputerList
PGENERIC_LIST ComputerList
Definition: setuplib.h:138
_USETUP_DATA::SystemRootPath
UNICODE_STRING SystemRootPath
Definition: setuplib.h:119
_USETUP_DATA::SourceRootPath
UNICODE_STRING SourceRootPath
Definition: setuplib.h:101
_USETUP_DATA::InstallationDirectory
WCHAR InstallationDirectory[MAX_PATH]
Definition: setuplib.h:157
_USETUP_DATA::BootLoaderLocation
LONG BootLoaderLocation
Definition: setuplib.h:132
_USETUP_DATA::ArchType
ARCHITECTURE_TYPE ArchType
Definition: setuplib.h:145
_USETUP_DATA::KeyboardList
PGENERIC_LIST KeyboardList
Definition: setuplib.h:140
_USETUP_DATA::DestinationArcPath
UNICODE_STRING DestinationArcPath
Definition: setuplib.h:122
_USETUP_DATA::FormatPartition
LONG FormatPartition
Definition: setuplib.h:133
_VOLENTRY::Info
VOLINFO Info
Definition: partlist.h:47
_VOLENTRY::PartEntry
PPARTENTRY PartEntry
Definition: partlist.h:57
_VOLINFO
Definition: volutil.h:16
_VOLINFO::DeviceName
WCHAR DeviceName[MAX_PATH]
NT device name: "\Device\HarddiskVolumeN".
Definition: volutil.h:18
_VOLINFO::FileSystem
WCHAR FileSystem[MAX_PATH+1]
Definition: volutil.h:22
_VOLINFO::DriveLetter
WCHAR DriveLetter
Definition: volutil.h:20
_VOL_CREATE_INFO
Data structure stored when a partition/volume needs to be formatted.
Definition: reactos.h:187
_VOL_CREATE_INFO::ClusterSize
ULONG ClusterSize
Definition: reactos.h:199
_VOL_CREATE_INFO::QuickFormat
BOOLEAN QuickFormat
Definition: reactos.h:198
_VOL_CREATE_INFO::Volume
PVOLENTRY Volume
Definition: reactos.h:188
_VOL_CREATE_INFO::FileSystemName
WCHAR FileSystemName[MAX_PATH+1]
Definition: reactos.h:195
_VOL_CREATE_INFO::MediaFlag
FMIFS_MEDIA_FLAG MediaFlag
Definition: reactos.h:196
_VOL_CREATE_INFO::Label
PCWSTR Label
Definition: reactos.h:197
args
Definition: match.c:390
message
Definition: tftpd.h:60
tagNMHDR::idFrom
UINT_PTR idFrom
Definition: winuser.h:3266
tagNMHDR::code
UINT code
Definition: winuser.h:3267
tagNMLISTVIEW::uNewState
UINT uNewState
Definition: commctrl.h:3041
tagNMLISTVIEW::uOldState
UINT uOldState
Definition: commctrl.h:3042
tagRECT::right
LONG right
Definition: windef.h:108
tagRECT::bottom
LONG bottom
Definition: windef.h:109
tagRECT::top
LONG top
Definition: windef.h:107
tagRECT::left
LONG left
Definition: windef.h:106
Position
static COORD Position
Definition: mouse.c:34
WaitForSingleObject
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
CreateEventW
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:587
SetEvent
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:669
ResetEvent
BOOL WINAPI DECLSPEC_HOTPATCH ResetEvent(IN HANDLE hEvent)
Definition: synch.c:650
ICON_BIG
#define ICON_BIG
Definition: tnclass.cpp:51
GWLP_USERDATA
#define GWLP_USERDATA
Definition: treelist.c:63
TreeListRegister
int TreeListRegister(HINSTANCE hInstance)
Definition: treelist.c:394
TreeListUnregister
BOOL TreeListUnregister(HINSTANCE hInstance)
Definition: treelist.c:429
MSG
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
PWSTR
uint16_t * PWSTR
Definition: typedefs.h:56
INT_PTR
int32_t INT_PTR
Definition: typedefs.h:64
PULONG
uint32_t * PULONG
Definition: typedefs.h:59
PCWSTR
const uint16_t * PCWSTR
Definition: typedefs.h:57
LPCWSTR
const uint16_t * LPCWSTR
Definition: typedefs.h:57
DWORD_PTR
uint32_t DWORD_PTR
Definition: typedefs.h:65
PBOOLEAN
unsigned char * PBOOLEAN
Definition: typedefs.h:53
NTAPI
#define NTAPI
Definition: typedefs.h:36
PVOID
void * PVOID
Definition: typedefs.h:50
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
INT
int32_t INT
Definition: typedefs.h:58
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
IN
#define IN
Definition: typedefs.h:39
PWCHAR
uint16_t * PWCHAR
Definition: typedefs.h:56
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
ULONG
uint32_t ULONG
Definition: typedefs.h:59
HIWORD
#define HIWORD(l)
Definition: typedefs.h:247
OUT
#define OUT
Definition: typedefs.h:40
PCHAR
char * PCHAR
Definition: typedefs.h:51
STATUS_UNRECOGNIZED_VOLUME
#define STATUS_UNRECOGNIZED_VOLUME
Definition: udferr_usr.h:173
ChkdskCallback
PFMIFSCALLBACK ChkdskCallback
Definition: vfatlib.c:43
Info
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:690
Index
_In_ WDFCOLLECTION _In_ ULONG Index
Definition: wdfcollection.h:182
Notification
_In_ PWDFDEVICE_INIT _In_ PFN_WDF_DEVICE_SHUTDOWN_NOTIFICATION Notification
Definition: wdfcontrol.h:115
String
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFSTRING String
Definition: wdfdevice.h:2439
DeviceName
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3281
Parameters
_Must_inspect_result_ _In_ WDFQUEUE _In_opt_ WDFREQUEST _In_opt_ WDFFILEOBJECT _Inout_opt_ PWDF_REQUEST_PARAMETERS Parameters
Definition: wdfio.h:869
LocaleId
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_ PCUNICODE_STRING _In_ PCUNICODE_STRING _In_ LCID LocaleId
Definition: wdfpdo.h:437
Value
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
Target
_In_ WDFIOTARGET Target
Definition: wdfrequest.h:306
List
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
GetDlgItemTextW
UINT WINAPI GetDlgItemTextW(HWND hDlg, int nIDDlgItem, LPWSTR lpString, int nMaxCount)
Definition: dialog.c:2263
SwitchToThisWindow
VOID WINAPI SwitchToThisWindow(HWND hwnd, BOOL fAltTab)
Definition: window.c:82
GetProgmanWindow
HWND WINAPI GetProgmanWindow(void)
Definition: input.c:992
GetShellWindow
HWND WINAPI GetShellWindow(void)
Definition: input.c:974
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
WAIT_OBJECT_0
#define WAIT_OBJECT_0
Definition: winbase.h:383
CREATE_NEW_CONSOLE
#define CREATE_NEW_CONSOLE
Definition: winbase.h:185
HCURSOR
HICON HCURSOR
Definition: windef.h:99
WINAPI
#define WINAPI
Definition: msvc.h:6
DeleteFont
#define DeleteFont(hfont)
Definition: windowsx.h:78
ComboBox_GetItemData
#define ComboBox_GetItemData(hwndCtl, index)
Definition: windowsx.h:54
ComboBox_GetCurSel
#define ComboBox_GetCurSel(hwndCtl)
Definition: windowsx.h:49
GetObjectW
int WINAPI GetObjectW(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
GetDeviceCaps
int WINAPI GetDeviceCaps(_In_opt_ HDC, _In_ int)
FW_BOLD
#define FW_BOLD
Definition: wingdi.h:378
LOGPIXELSY
#define LOGPIXELSY
Definition: wingdi.h:719
CreateFontIndirect
#define CreateFontIndirect
Definition: wingdi.h:4890
SE_SHUTDOWN_NAME
#define SE_SHUTDOWN_NAME
Definition: winnt_old.h:427
SW_SHOWNORMAL
#define SW_SHOWNORMAL
Definition: winuser.h:781
LB_ERR
#define LB_ERR
Definition: winuser.h:2468
ReleaseDC
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
GetKeyboardLayoutNameW
BOOL WINAPI GetKeyboardLayoutNameW(_Out_writes_(KL_NAMELENGTH) LPWSTR)
CB_SETITEMDATA
#define CB_SETITEMDATA
Definition: winuser.h:1995
IsWindow
BOOL WINAPI IsWindow(_In_opt_ HWND)
SW_HIDE
#define SW_HIDE
Definition: winuser.h:779
SWP_NOACTIVATE
#define SWP_NOACTIVATE
Definition: winuser.h:1253
MF_BYCOMMAND
#define MF_BYCOMMAND
Definition: winuser.h:202
GetWindowLongPtrW
#define GetWindowLongPtrW
Definition: winuser.h:4983
WM_QUIT
#define WM_QUIT
Definition: winuser.h:1651
TranslateMessage
BOOL WINAPI TranslateMessage(_In_ const MSG *)
MAKELPARAM
#define MAKELPARAM(l, h)
Definition: winuser.h:4116
ShowWindow
BOOL WINAPI ShowWindow(_In_ HWND, _In_ int)
CheckDlgButton
BOOL WINAPI CheckDlgButton(_In_ HWND, _In_ int, _In_ UINT)
KL_NAMELENGTH
#define KL_NAMELENGTH
Definition: winuser.h:122
CallWindowProc
#define CallWindowProc
Definition: winuser.h:5901
IDCANCEL
#define IDCANCEL
Definition: winuser.h:842
VK_F10
#define VK_F10
Definition: winuser.h:2300
DWLP_DLGPROC
#define DWLP_DLGPROC
Definition: winuser.h:882
GetMessageW
BOOL WINAPI GetMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT)
BST_UNCHECKED
#define BST_UNCHECKED
Definition: winuser.h:199
PostMessageW
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
GetWindowRect
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
SetWindowPos
BOOL WINAPI SetWindowPos(_In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
UnregisterHotKey
BOOL WINAPI UnregisterHotKey(_In_opt_ HWND, _In_ int)
SetWindowLongW
LONG WINAPI SetWindowLongW(_In_ HWND, _In_ int, _In_ LONG)
WM_COMMAND
#define WM_COMMAND
Definition: winuser.h:1768
CB_ERR
#define CB_ERR
Definition: winuser.h:2471
CB_SETCURSEL
#define CB_SETCURSEL
Definition: winuser.h:1990
SM_CYSMICON
#define SM_CYSMICON
Definition: winuser.h:1024
ShowCursor
int WINAPI ShowCursor(_In_ BOOL)
Definition: cursoricon.c:3071
MFS_DISABLED
#define MFS_DISABLED
Definition: winuser.h:760
SetDlgItemTextW
BOOL WINAPI SetDlgItemTextW(_In_ HWND, _In_ int, _In_ LPCWSTR)
QS_ALLPOSTMESSAGE
#define QS_ALLPOSTMESSAGE
Definition: winuser.h:893
QS_ALLINPUT
#define QS_ALLINPUT
Definition: winuser.h:914
SetCursor
HCURSOR WINAPI SetCursor(_In_opt_ HCURSOR)
MB_RETRYCANCEL
#define MB_RETRYCANCEL
Definition: winuser.h:816
SWP_NOSIZE
#define SWP_NOSIZE
Definition: winuser.h:1256
WA_INACTIVE
#define WA_INACTIVE
Definition: winuser.h:2664
WM_INITDIALOG
#define WM_INITDIALOG
Definition: winuser.h:1767
GetSystemMenu
HMENU WINAPI GetSystemMenu(_In_ HWND, _In_ BOOL)
MB_YESNO
#define MB_YESNO
Definition: winuser.h:828
MsgWaitForMultipleObjects
DWORD WINAPI MsgWaitForMultipleObjects(_In_ DWORD nCount, _In_reads_opt_(nCount) CONST HANDLE *pHandles, _In_ BOOL fWaitAll, _In_ DWORD dwMilliseconds, _In_ DWORD dwWakeMask)
MapWindowPoints
int WINAPI MapWindowPoints(_In_opt_ HWND hWndFrom, _In_opt_ HWND hWndTo, _Inout_updates_(cPoints) LPPOINT lpPoints, _In_ UINT cPoints)
MessageBoxW
int WINAPI MessageBoxW(_In_opt_ HWND hWnd, _In_opt_ LPCWSTR lpText, _In_opt_ LPCWSTR lpCaption, _In_ UINT uType)
GetDlgItem
HWND WINAPI GetDlgItem(_In_opt_ HWND, _In_ int)
IDOK
#define IDOK
Definition: winuser.h:841
SetTimer
UINT_PTR WINAPI SetTimer(_In_opt_ HWND, _In_ UINT_PTR, _In_ UINT, _In_opt_ TIMERPROC)
MIIM_STATE
#define MIIM_STATE
Definition: winuser.h:732
HWND_DESKTOP
#define HWND_DESKTOP
Definition: winuser.h:1220
WM_ACTIVATE
#define WM_ACTIVATE
Definition: winuser.h:1640
GetDesktopWindow
HWND WINAPI GetDesktopWindow(void)
Definition: window.c:628
MB_ICONERROR
#define MB_ICONERROR
Definition: winuser.h:798
MB_OKCANCEL
#define MB_OKCANCEL
Definition: winuser.h:815
SetWindowTextW
BOOL WINAPI SetWindowTextW(_In_ HWND, _In_opt_ LPCWSTR)
IsDlgButtonChecked
UINT WINAPI IsDlgButtonChecked(_In_ HWND, _In_ int)
SM_CXSMICON
#define SM_CXSMICON
Definition: winuser.h:1023
EWX_REBOOT
#define EWX_REBOOT
Definition: winuser.h:646
HWND_TOP
#define HWND_TOP
Definition: winuser.h:1218
RegisterHotKey
BOOL WINAPI RegisterHotKey(_In_opt_ HWND, _In_ int, _In_ UINT, _In_ UINT)
SetFocus
HWND WINAPI SetFocus(_In_opt_ HWND)
EnumWindows
BOOL WINAPI EnumWindows(_In_ WNDENUMPROC lpEnumFunc, _In_ LPARAM lParam)
MF_ENABLED
#define MF_ENABLED
Definition: winuser.h:128
PeekMessageW
BOOL WINAPI PeekMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT, _In_ UINT)
PostThreadMessageW
BOOL WINAPI PostThreadMessageW(_In_ DWORD, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
WM_TIMER
#define WM_TIMER
Definition: winuser.h:1770
PM_REMOVE
#define PM_REMOVE
Definition: winuser.h:1207
CB_ADDSTRING
#define CB_ADDSTRING
Definition: winuser.h:1965
LPDLGTEMPLATE
struct DLGTEMPLATE * LPDLGTEMPLATE
DS_CENTER
#define DS_CENTER
Definition: winuser.h:369
UpdateWindow
BOOL WINAPI UpdateWindow(_In_ HWND)
LPNMHDR
struct tagNMHDR * LPNMHDR
LoadCursor
#define LoadCursor
Definition: winuser.h:5978
GetDC
HDC WINAPI GetDC(_In_opt_ HWND)
SC_CLOSE
#define SC_CLOSE
Definition: winuser.h:2628
MB_OK
#define MB_OK
Definition: winuser.h:801
SystemParametersInfoW
BOOL WINAPI SystemParametersInfoW(_In_ UINT uiAction, _In_ UINT uiParam, _Inout_opt_ PVOID pvParam, _In_ UINT fWinIni)
IsWindowEnabled
BOOL WINAPI IsWindowEnabled(_In_ HWND)
MB_ICONWARNING
#define MB_ICONWARNING
Definition: winuser.h:797
PostMessage
#define PostMessage
Definition: winuser.h:5998
GetParent
HWND WINAPI GetParent(_In_ HWND)
GetMenuItemInfoW
BOOL WINAPI GetMenuItemInfoW(_In_ HMENU, _In_ UINT, _In_ BOOL, _Inout_ LPMENUITEMINFOW)
DispatchMessageW
LRESULT WINAPI DispatchMessageW(_In_ const MSG *)
MB_ICONQUESTION
#define MB_ICONQUESTION
Definition: winuser.h:800
ExitWindowsEx
BOOL WINAPI ExitWindowsEx(_In_ UINT, _In_ DWORD)
DS_SETFOREGROUND
#define DS_SETFOREGROUND
Definition: winuser.h:379
DWLP_MSGRESULT
#define DWLP_MSGRESULT
Definition: winuser.h:881
MB_ICONINFORMATION
#define MB_ICONINFORMATION
Definition: winuser.h:813
SWP_NOOWNERZORDER
#define SWP_NOOWNERZORDER
Definition: winuser.h:1260
MessageBoxIndirectW
int WINAPI MessageBoxIndirectW(_In_ CONST MSGBOXPARAMSW *lpmbp)
WM_SETCURSOR
#define WM_SETCURSOR
Definition: winuser.h:1664
WM_HOTKEY
#define WM_HOTKEY
Definition: winuser.h:1907
MB_DEFBUTTON2
#define MB_DEFBUTTON2
Definition: winuser.h:810
IDC_WAIT
#define IDC_WAIT
Definition: winuser.h:697
BN_CLICKED
#define BN_CLICKED
Definition: winuser.h:1954
SW_SHOW
#define SW_SHOW
Definition: winuser.h:786
WM_DESTROY
#define WM_DESTROY
Definition: winuser.h:1637
InvalidateRect
BOOL WINAPI InvalidateRect(_In_opt_ HWND, _In_opt_ LPCRECT, _In_ BOOL)
MAKEINTRESOURCEW
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
WNDPROC
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:3014
IDYES
#define IDYES
Definition: winuser.h:846
SWP_NOZORDER
#define SWP_NOZORDER
Definition: winuser.h:1258
IDRETRY
#define IDRETRY
Definition: winuser.h:844
KillTimer
BOOL WINAPI KillTimer(_In_opt_ HWND, _In_ UINT_PTR)
SetWindowLongPtrW
#define SetWindowLongPtrW
Definition: winuser.h:5512
GWL_STYLE
#define GWL_STYLE
Definition: winuser.h:863
SendDlgItemMessage
#define SendDlgItemMessage
Definition: winuser.h:6008
DM_REPOSITION
#define DM_REPOSITION
Definition: winuser.h:2136
IsWindowVisible
BOOL WINAPI IsWindowVisible(_In_ HWND)
EnableMenuItem
BOOL WINAPI EnableMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
LoadIconW
HICON WINAPI LoadIconW(_In_opt_ HINSTANCE hInstance, _In_ LPCWSTR lpIconName)
Definition: cursoricon.c:2444
GetSystemMetrics
int WINAPI GetSystemMetrics(_In_ int)
SendMessageW
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
BST_CHECKED
#define BST_CHECKED
Definition: winuser.h:197
MF_GRAYED
#define MF_GRAYED
Definition: winuser.h:129
PartitionNumber
_In_ ULONG _In_ ULONG PartitionNumber
Definition: iofuncs.h:2061
Parameter
_Inout_opt_ PVOID Parameter
Definition: rtltypes.h:336
TOKEN_ADJUST_PRIVILEGES
#define TOKEN_ADJUST_PRIVILEGES
Definition: setypes.h:942
SE_PRIVILEGE_ENABLED
#define SE_PRIVILEGE_ENABLED
Definition: setypes.h:63