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