ReactOS 0.4.16-dev-1-gcf26321
reactos.c
Go to the documentation of this file.
1/*
2 * ReactOS applications
3 * Copyright (C) 2004-2008 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19/*
20 * COPYRIGHT: See COPYING in the top level directory
21 * PROJECT: ReactOS GUI first stage setup application
22 * FILE: base/setup/reactos/reactos.c
23 * PROGRAMMERS: Matthias Kupfer
24 * Dmitry Chapyshev (dmitry@reactos.org)
25 */
26
27#include "reactos.h"
28#include <winnls.h> // For GetUserDefaultLCID()
29
30#define NTOS_MODE_USER
31#include <ndk/obfuncs.h>
32
33#include "resource.h"
34
35#define NDEBUG
36#include <debug.h>
37
38/* GLOBALS ******************************************************************/
39
40HANDLE ProcessHeap;
41BOOLEAN IsUnattendedSetup = FALSE;
42SETUPDATA SetupData;
43
44/* The partition where to perform the installation */
45PPARTENTRY InstallPartition = NULL;
46// static PVOLENTRY InstallVolume = NULL;
47#define InstallVolume (InstallPartition->Volume)
48
49/* The system partition we will actually use */
50PPARTENTRY SystemPartition = NULL;
51// static PVOLENTRY SystemVolume = NULL;
52#define SystemVolume (SystemPartition->Volume)
53
54/* UI elements */
55UI_CONTEXT UiContext;
56
57
58/* FUNCTIONS ****************************************************************/
59
60static VOID
61CenterWindow(HWND hWnd)
62{
63 HWND hWndParent;
64 RECT rcParent;
65 RECT rcWindow;
66
67 hWndParent = GetParent(hWnd);
68 if (hWndParent == NULL)
69 hWndParent = GetDesktopWindow();
70
71 GetWindowRect(hWndParent, &rcParent);
72 GetWindowRect(hWnd, &rcWindow);
73
74 SetWindowPos(hWnd,
75 HWND_TOP,
76 ((rcParent.right - rcParent.left) - (rcWindow.right - rcWindow.left)) / 2,
77 ((rcParent.bottom - rcParent.top) - (rcWindow.bottom - rcWindow.top)) / 2,
78 0,
79 0,
80 SWP_NOSIZE);
81}
82
83static HFONT
84CreateTitleFont(VOID)
85{
86 NONCLIENTMETRICS ncm;
87 LOGFONT LogFont;
88 HDC hdc;
89 INT FontSize;
90 HFONT hFont;
91
92 ncm.cbSize = sizeof(NONCLIENTMETRICS);
93 SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
94
95 LogFont = ncm.lfMessageFont;
96 LogFont.lfWeight = FW_BOLD;
97 _tcscpy(LogFont.lfFaceName, _T("MS Shell Dlg"));
98
99 hdc = GetDC(NULL);
100 FontSize = 12;
101 LogFont.lfHeight = 0 - GetDeviceCaps (hdc, LOGPIXELSY) * FontSize / 72;
102 hFont = CreateFontIndirect(&LogFont);
103 ReleaseDC(NULL, hdc);
104
105 return hFont;
106}
107
108INT
109DisplayMessageV(
110 _In_opt_ HWND hWnd,
111 _In_ UINT uType,
112 _In_opt_ PCWSTR pszTitle,
113 _In_opt_ PCWSTR pszFormatMessage,
114 _In_ va_list args)
115{
116 INT iRes;
117 HINSTANCE hInstance = NULL;
118 MSGBOXPARAMSW mb = {0};
119 LPWSTR Format;
120 size_t MsgLen;
121 WCHAR StaticBuffer[256];
122 LPWSTR Buffer = StaticBuffer; // Use the static buffer by default.
123
124 /* We need to retrieve the current module's instance handle if either
125 * the title or the format message is specified by a resource ID */
126 if ((pszTitle && IS_INTRESOURCE(pszTitle)) || IS_INTRESOURCE(pszFormatMessage))
127 hInstance = GetModuleHandleW(NULL); // SetupData.hInstance;
128
129 /* Retrieve the format message string if this is a resource */
130 if (pszFormatMessage && IS_INTRESOURCE(pszFormatMessage)) do
131 {
132 // LoadAllocStringW()
133 PCWSTR pStr;
134
135 /* Try to load the string from the resource */
136 MsgLen = LoadStringW(hInstance, PtrToUlong(pszFormatMessage), (LPWSTR)&pStr, 0);
137 if (MsgLen == 0)
138 {
139 /* No resource string was found, return NULL */
140 Format = NULL;
141 break;
142 }
143
144 /* Allocate a new buffer, adding a NULL-terminator */
145 Format = HeapAlloc(GetProcessHeap(), 0, (MsgLen + 1) * sizeof(WCHAR));
146 if (!Format)
147 {
148 MsgLen = 0;
149 break;
150 }
151
152 /* Copy the string, NULL-terminated */
153 StringCchCopyNW(Format, MsgLen + 1, pStr, MsgLen);
154 } while (0);
155 else
156 {
157 Format = (LPWSTR)pszFormatMessage;
158 }
159
160 if (Format)
161 {
162 /*
163 * Retrieve the message length. If it is too long, allocate
164 * an auxiliary buffer; otherwise use the static buffer.
165 * The string is built to be NULL-terminated.
166 */
167 MsgLen = _vscwprintf(Format, args);
168 if (MsgLen >= _countof(StaticBuffer))
169 {
170 Buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (MsgLen + 1) * sizeof(WCHAR));
171 if (!Buffer)
172 {
173 /* Allocation failed, use the original format string verbatim */
174 Buffer = Format;
175 }
176 }
177 if (Buffer != Format)
178 {
179 /* Do the printf as we use the caller's format string */
180 StringCchVPrintfW(Buffer, MsgLen + 1, Format, args);
181 }
182 }
183 else
184 {
185 Format = (LPWSTR)pszFormatMessage;
186 Buffer = Format;
187 }
188
189 /* Display the message */
190 mb.cbSize = sizeof(mb);
191 mb.hwndOwner = hWnd;
192 mb.hInstance = hInstance;
193 mb.lpszText = Buffer;
194 mb.lpszCaption = pszTitle;
195 mb.dwStyle = uType;
196 mb.dwLanguageId = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
197 iRes = MessageBoxIndirectW(&mb);
198
199 /* Free the buffers if needed */
200 if ((Buffer != StaticBuffer) && (Buffer != Format))
201 HeapFree(GetProcessHeap(), 0, Buffer);
202
203 if (Format && (Format != pszFormatMessage))
204 HeapFree(GetProcessHeap(), 0, Format);
205
206 return iRes;
207}
208
209INT
210__cdecl
211DisplayMessage(
212 _In_opt_ HWND hWnd,
213 _In_ UINT uType,
214 _In_opt_ PCWSTR pszTitle,
215 _In_opt_ PCWSTR pszFormatMessage,
216 ...)
217{
218 INT iRes;
219 va_list args;
220
221 va_start(args, pszFormatMessage);
222 iRes = DisplayMessageV(hWnd, uType, pszTitle, pszFormatMessage, args);
223 va_end(args);
224
225 return iRes;
226}
227
228INT
229__cdecl
230DisplayError(
231 _In_opt_ HWND hWnd,
232 _In_ UINT uIDTitle,
233 _In_ UINT uIDMessage,
234 ...)
235{
236 INT iRes;
237 va_list args;
238
239 va_start(args, uIDMessage);
240 iRes = DisplayMessageV(hWnd, MB_OK | MB_ICONERROR,
241 MAKEINTRESOURCEW(uIDTitle),
242 MAKEINTRESOURCEW(uIDMessage),
243 args);
244 va_end(args);
245
246 return iRes;
247}
248
249VOID
250SetWindowResTextW(
251 _In_ HWND hWnd,
252 _In_opt_ HINSTANCE hInstance,
253 _In_ UINT uID)
254{
255 WCHAR szText[256];
256 LoadStringW(hInstance, uID, szText, _countof(szText));
257 SetWindowTextW(hWnd, szText);
258}
259
260VOID
261SetWindowResPrintfVW(
262 _In_ HWND hWnd,
263 _In_opt_ HINSTANCE hInstance,
264 _In_ UINT uID,
265 _In_ va_list args)
266{
267 WCHAR ResBuffer[256];
268 WCHAR szText[256];
269
270 LoadStringW(hInstance, uID, ResBuffer, _countof(ResBuffer));
271 StringCchVPrintfW(szText, _countof(szText), ResBuffer, args);
272 SetWindowTextW(hWnd, szText);
273}
274
275VOID
276__cdecl
277SetWindowResPrintfW(
278 _In_ HWND hWnd,
279 _In_opt_ HINSTANCE hInstance,
280 _In_ UINT uID,
281 ...)
282{
283 va_list args;
284
285 va_start(args, uID);
286 SetWindowResPrintfVW(hWnd, hInstance, uID, args);
287 va_end(args);
288}
289
290static INT_PTR CALLBACK
291StartDlgProc(
292 IN HWND hwndDlg,
293 IN UINT uMsg,
294 IN WPARAM wParam,
295 IN LPARAM lParam)
296{
297 PSETUPDATA pSetupData;
298
299 /* Retrieve pointer to the global setup data */
300 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
301
302 switch (uMsg)
303 {
304 case WM_INITDIALOG:
305 {
306 /* Save pointer to the global setup data */
307 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
308 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
309
310 /* Set title font */
311 SendDlgItemMessage(hwndDlg,
312 IDC_STARTTITLE,
313 WM_SETFONT,
314 (WPARAM)pSetupData->hTitleFont,
315 (LPARAM)TRUE);
316
317 /* Center the wizard window */
318 CenterWindow(GetParent(hwndDlg));
319 break;
320 }
321
322 case WM_NOTIFY:
323 {
324 LPNMHDR lpnm = (LPNMHDR)lParam;
325
326 switch (lpnm->code)
327 {
328 case PSN_SETACTIVE:
329 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT);
330 break;
331
332 default:
333 break;
334 }
335 }
336 break;
337
338 default:
339 break;
340
341 }
342
343 return FALSE;
344}
345
346static INT_PTR CALLBACK
347TypeDlgProc(
348 IN HWND hwndDlg,
349 IN UINT uMsg,
350 IN WPARAM wParam,
351 IN LPARAM lParam)
352{
353 PSETUPDATA pSetupData;
354
355 /* Retrieve pointer to the global setup data */
356 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
357
358 switch (uMsg)
359 {
360 case WM_INITDIALOG:
361 {
362 /* Save pointer to the global setup data */
363 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
364 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
365
366 /* Check the 'install' radio button */
367 CheckDlgButton(hwndDlg, IDC_INSTALL, BST_CHECKED);
368
369 /*
370 * Enable the 'update' radio button and text only if we have
371 * available NT installations, otherwise disable them.
372 */
373 if (pSetupData->NtOsInstallsList &&
374 GetNumberOfListEntries(pSetupData->NtOsInstallsList) != 0)
375 {
376 EnableWindow(GetDlgItem(hwndDlg, IDC_UPDATE), TRUE);
377 EnableWindow(GetDlgItem(hwndDlg, IDC_UPDATETEXT), TRUE);
378 }
379 else
380 {
381 EnableWindow(GetDlgItem(hwndDlg, IDC_UPDATE), FALSE);
382 EnableWindow(GetDlgItem(hwndDlg, IDC_UPDATETEXT), FALSE);
383 }
384
385 break;
386 }
387
388 case WM_NOTIFY:
389 {
390 LPNMHDR lpnm = (LPNMHDR)lParam;
391
392 switch (lpnm->code)
393 {
394 case PSN_SETACTIVE:
395 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
396 break;
397
398 case PSN_QUERYINITIALFOCUS:
399 {
400 /* Focus on "Install ReactOS" */
401 SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)GetDlgItem(hwndDlg, IDC_INSTALL));
402 return TRUE;
403 }
404
405 case PSN_QUERYCANCEL:
406 {
407 if (DisplayMessage(GetParent(hwndDlg),
408 MB_YESNO | MB_ICONQUESTION,
409 MAKEINTRESOURCEW(IDS_ABORTSETUP2),
410 MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
411 {
412 /* Go to the Terminate page */
413 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_RESTARTPAGE);
414 }
415
416 /* Do not close the wizard too soon */
417 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
418 return TRUE;
419 }
420
421 case PSN_WIZNEXT: /* Set the selected data */
422 {
423 /*
424 * Go update only if we have available NT installations
425 * and we choose to do so.
426 */
427 if (pSetupData->NtOsInstallsList &&
428 GetNumberOfListEntries(pSetupData->NtOsInstallsList) != 0 &&
429 IsDlgButtonChecked(hwndDlg, IDC_UPDATE) == BST_CHECKED)
430 {
431 pSetupData->RepairUpdateFlag = TRUE;
432
433 /*
434 * Display the existing NT installations page only
435 * if we have more than one available NT installations.
436 */
437 if (GetNumberOfListEntries(pSetupData->NtOsInstallsList) > 1)
438 {
439 /* pSetupData->CurrentInstallation will be set from within IDD_UPDATEREPAIRPAGE */
440
441 /* Actually the best would be to dynamically insert the page only when needed */
442 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_UPDATEREPAIRPAGE);
443 }
444 else
445 {
446 /* Retrieve the current installation */
447 pSetupData->CurrentInstallation =
448 (PNTOS_INSTALLATION)GetListEntryData(GetCurrentListEntry(pSetupData->NtOsInstallsList));
449
450 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_DEVICEPAGE);
451 }
452 }
453 else
454 {
455 pSetupData->CurrentInstallation = NULL;
456 pSetupData->RepairUpdateFlag = FALSE;
457 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, IDD_DEVICEPAGE);
458 }
459
460 return TRUE;
461 }
462
463 default:
464 break;
465 }
466 }
467 break;
468
469 default:
470 break;
471
472 }
473 return FALSE;
474}
475
476
477
478BOOL
479CreateListViewColumns(
480 IN HINSTANCE hInstance,
481 IN HWND hWndListView,
482 IN const UINT* pIDs,
483 IN const INT* pColsWidth,
484 IN const INT* pColsAlign,
485 IN UINT nNumOfColumns)
486{
487 UINT i;
488 LVCOLUMN lvC;
489 WCHAR szText[50];
490
491 /* Create the columns */
492 lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
493 lvC.pszText = szText;
494
495 /* Load the column labels from the resource file */
496 for (i = 0; i < nNumOfColumns; i++)
497 {
498 lvC.iSubItem = i;
499 lvC.cx = pColsWidth[i];
500 lvC.fmt = pColsAlign[i];
501
502 LoadStringW(hInstance, pIDs[i], szText, ARRAYSIZE(szText));
503
504 if (ListView_InsertColumn(hWndListView, i, &lvC) == -1)
505 return FALSE;
506 }
507
508 return TRUE;
509}
510
511typedef VOID
512(NTAPI *PGET_ENTRY_DESCRIPTION)(
513 IN PGENERIC_LIST_ENTRY Entry,
514 OUT PWSTR Buffer,
515 IN SIZE_T cchBufferSize);
516
517VOID
518InitGenericComboList(
519 IN HWND hWndList,
520 IN PGENERIC_LIST List,
521 IN PGET_ENTRY_DESCRIPTION GetEntryDescriptionProc)
522{
523 INT Index, CurrentEntryIndex = 0;
524 PGENERIC_LIST_ENTRY ListEntry;
525 PLIST_ENTRY Entry;
526 WCHAR CurrentItemText[256];
527
528 for (Entry = List->ListHead.Flink;
529 Entry != &List->ListHead;
530 Entry = Entry->Flink)
531 {
532 ListEntry = CONTAINING_RECORD(Entry, GENERIC_LIST_ENTRY, Entry);
533
534 if (GetEntryDescriptionProc)
535 {
536 GetEntryDescriptionProc(ListEntry,
537 CurrentItemText,
538 ARRAYSIZE(CurrentItemText));
539 Index = SendMessageW(hWndList, CB_ADDSTRING, 0, (LPARAM)CurrentItemText);
540 }
541 else
542 {
543 Index = SendMessageW(hWndList, CB_ADDSTRING, 0, (LPARAM)L"n/a");
544 }
545
546 if (ListEntry == List->CurrentEntry)
547 CurrentEntryIndex = Index;
548
549 SendMessageW(hWndList, CB_SETITEMDATA, Index, (LPARAM)ListEntry);
550 }
551
552 SendMessageW(hWndList, CB_SETCURSEL, CurrentEntryIndex, 0);
553}
554
555PVOID
556GetSelectedComboListItem(
557 IN HWND hWndList)
558{
559 INT Index;
560
561 Index = ComboBox_GetCurSel(hWndList);
562 if (Index == CB_ERR)
563 return NULL;
564
565 return (PVOID)ComboBox_GetItemData(hWndList, Index);
566}
567
568typedef VOID
569(NTAPI *PADD_ENTRY_ITEM)(
570 IN HWND hWndList,
571 IN LVITEM* plvItem,
572 IN PGENERIC_LIST_ENTRY Entry,
573 IN OUT PWSTR Buffer,
574 IN SIZE_T cchBufferSize);
575
576VOID
577InitGenericListView(
578 IN HWND hWndList,
579 IN PGENERIC_LIST List,
580 IN PADD_ENTRY_ITEM AddEntryItemProc)
581{
582 INT CurrentEntryIndex = 0;
583 LVITEM lvItem;
584 PGENERIC_LIST_ENTRY ListEntry;
585 PLIST_ENTRY Entry;
586 WCHAR CurrentItemText[256];
587
588 for (Entry = List->ListHead.Flink;
589 Entry != &List->ListHead;
590 Entry = Entry->Flink)
591 {
592 ListEntry = CONTAINING_RECORD(Entry, GENERIC_LIST_ENTRY, Entry);
593
594 if (!AddEntryItemProc)
595 continue;
596
597 AddEntryItemProc(hWndList,
598 &lvItem,
599 ListEntry,
600 CurrentItemText,
601 ARRAYSIZE(CurrentItemText));
602
603 if (ListEntry == List->CurrentEntry)
604 CurrentEntryIndex = lvItem.iItem;
605 }
606
607 ListView_EnsureVisible(hWndList, CurrentEntryIndex, FALSE);
608 ListView_SetItemState(hWndList, CurrentEntryIndex,
609 LVIS_FOCUSED | LVIS_SELECTED,
610 LVIS_FOCUSED | LVIS_SELECTED);
611}
612
613PVOID
614GetSelectedListViewItem(
615 IN HWND hWndList)
616{
617 INT Index;
618 LVITEM item;
619
620 Index = ListView_GetSelectionMark(hWndList);
621 if (Index == LB_ERR)
622 return NULL;
623
624 item.mask = LVIF_PARAM;
625 item.iItem = Index;
626 ListView_GetItem(hWndList, &item);
627
628 return (PVOID)item.lParam;
629}
630
631
632static VOID
633NTAPI
634GetSettingDescription(
635 IN PGENERIC_LIST_ENTRY Entry,
636 OUT PWSTR Buffer,
637 IN SIZE_T cchBufferSize)
638{
639 StringCchCopyW(Buffer, cchBufferSize,
640 ((PGENENTRY)GetListEntryData(Entry))->Value);
641}
642
643static VOID
644NTAPI
645AddNTOSInstallationItem(
646 IN HWND hWndList,
647 IN LVITEM* plvItem,
648 IN PGENERIC_LIST_ENTRY Entry,
649 IN OUT PWSTR Buffer, // SystemRootPath
650 IN SIZE_T cchBufferSize)
651{
652 PNTOS_INSTALLATION NtOsInstall = (PNTOS_INSTALLATION)GetListEntryData(Entry);
653 PVOLINFO VolInfo = (NtOsInstall->Volume ? &NtOsInstall->Volume->Info : NULL);
654
655 if (VolInfo && VolInfo->DriveLetter)
656 {
657 /* We have retrieved a partition that is mounted */
658 StringCchPrintfW(Buffer, cchBufferSize,
659 L"%c:%s",
660 VolInfo->DriveLetter,
661 NtOsInstall->PathComponent);
662 }
663 else
664 {
665 /* We failed somewhere, just show the NT path */
666 StringCchPrintfW(Buffer, cchBufferSize,
667 L"%wZ",
668 &NtOsInstall->SystemNtPath);
669 }
670
671 plvItem->mask = LVIF_IMAGE | LVIF_TEXT | LVIF_PARAM;
672 plvItem->iItem = 0;
673 plvItem->iSubItem = 0;
674 plvItem->lParam = (LPARAM)Entry;
675 plvItem->pszText = NtOsInstall->InstallationName;
676
677 /* Associate vendor icon */
678 if (FindSubStrI(NtOsInstall->VendorName, VENDOR_REACTOS))
679 {
680 plvItem->mask |= LVIF_IMAGE;
681 plvItem->iImage = 0;
682 }
683 else if (FindSubStrI(NtOsInstall->VendorName, VENDOR_MICROSOFT))
684 {
685 plvItem->mask |= LVIF_IMAGE;
686 plvItem->iImage = 1;
687 }
688
689 plvItem->iItem = SendMessageW(hWndList, LVM_INSERTITEMW, 0, (LPARAM)plvItem);
690
691 plvItem->iSubItem = 1;
692 plvItem->pszText = Buffer; // SystemRootPath;
693 SendMessageW(hWndList, LVM_SETITEMTEXTW, plvItem->iItem, (LPARAM)plvItem);
694
695 plvItem->iSubItem = 2;
696 plvItem->pszText = NtOsInstall->VendorName;
697 SendMessageW(hWndList, LVM_SETITEMTEXTW, plvItem->iItem, (LPARAM)plvItem);
698}
699
700
701#define IDS_LIST_COLUMN_FIRST IDS_INSTALLATION_NAME
702#define IDS_LIST_COLUMN_LAST IDS_INSTALLATION_VENDOR
703
704#define MAX_LIST_COLUMNS (IDS_LIST_COLUMN_LAST - IDS_LIST_COLUMN_FIRST + 1)
705static const UINT column_ids[MAX_LIST_COLUMNS] = {IDS_LIST_COLUMN_FIRST, IDS_LIST_COLUMN_FIRST + 1, IDS_LIST_COLUMN_FIRST + 2};
706static const INT column_widths[MAX_LIST_COLUMNS] = {200, 150, 100};
707static const INT column_alignment[MAX_LIST_COLUMNS] = {LVCFMT_LEFT, LVCFMT_LEFT, LVCFMT_LEFT};
708
709static INT_PTR CALLBACK
710UpgradeRepairDlgProc(
711 IN HWND hwndDlg,
712 IN UINT uMsg,
713 IN WPARAM wParam,
714 IN LPARAM lParam)
715{
716 PSETUPDATA pSetupData;
717 HWND hList;
718 HIMAGELIST hSmall;
719
720 /* Retrieve pointer to the global setup data */
721 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
722
723 switch (uMsg)
724 {
725 case WM_INITDIALOG:
726 {
727 /* Save pointer to the global setup data */
728 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
729 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
730
731 /*
732 * Keep the "Next" button disabled. It will be enabled only
733 * when the user selects an installation to upgrade.
734 */
735 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
736
737 hList = GetDlgItem(hwndDlg, IDC_NTOSLIST);
738
739 ListView_SetExtendedListViewStyleEx(hList, LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);
740
741 CreateListViewColumns(pSetupData->hInstance,
742 hList,
743 column_ids,
744 column_widths,
745 column_alignment,
746 MAX_LIST_COLUMNS);
747
748 /* Create the ImageList */
749 hSmall = ImageList_Create(GetSystemMetrics(SM_CXSMICON),
750 GetSystemMetrics(SM_CYSMICON),
751 ILC_COLOR32 | ILC_MASK, // ILC_COLOR24
752 1, 1);
753
754 /* Add event type icons to the ImageList */
755 ImageList_AddIcon(hSmall, LoadIconW(pSetupData->hInstance, MAKEINTRESOURCEW(IDI_ROSICON)));
756 ImageList_AddIcon(hSmall, LoadIconW(pSetupData->hInstance, MAKEINTRESOURCEW(IDI_WINICON)));
757
758 /* Assign the ImageList to the List View */
759 ListView_SetImageList(hList, hSmall, LVSIL_SMALL);
760
761 InitGenericListView(hList, pSetupData->NtOsInstallsList, AddNTOSInstallationItem);
762 break;
763 }
764
765 case WM_DESTROY:
766 {
767 hList = GetDlgItem(hwndDlg, IDC_NTOSLIST);
768 hSmall = ListView_GetImageList(hList, LVSIL_SMALL);
769 ListView_SetImageList(hList, NULL, LVSIL_SMALL);
770 ImageList_Destroy(hSmall);
771 return TRUE;
772 }
773
774 case WM_COMMAND:
775 switch (LOWORD(wParam))
776 {
777 case IDC_SKIPUPGRADE:
778 {
779 /* Skip the upgrade and do the usual new-installation workflow */
780 pSetupData->CurrentInstallation = NULL;
781 pSetupData->RepairUpdateFlag = FALSE;
782 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_DEVICEPAGE);
783 return TRUE;
784 }
785 }
786 break;
787
788 case WM_NOTIFY:
789 {
790 LPNMHDR lpnm = (LPNMHDR)lParam;
791
792 if (lpnm->idFrom == IDC_NTOSLIST && lpnm->code == LVN_ITEMCHANGED)
793 {
794 LPNMLISTVIEW pnmv = (LPNMLISTVIEW)lParam;
795
796 if (pnmv->uChanged & LVIF_STATE) /* The state has changed */
797 {
798 /* The item has been (de)selected */
799 if (pnmv->uNewState & (LVIS_FOCUSED | LVIS_SELECTED))
800 {
801 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
802 }
803 else
804 {
805 /*
806 * Keep the "Next" button disabled. It will be enabled only
807 * when the user selects an installation to upgrade.
808 */
809 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
810 }
811 }
812
813 break;
814 }
815
816 switch (lpnm->code)
817 {
818#if 0
819 case PSN_SETACTIVE:
820 {
821 /*
822 * Keep the "Next" button disabled. It will be enabled only
823 * when the user selects an installation to upgrade.
824 */
825 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
826 break;
827 }
828#endif
829
830 case PSN_QUERYINITIALFOCUS:
831 {
832 /* Give the focus on and select the first item */
833 hList = GetDlgItem(hwndDlg, IDC_NTOSLIST);
834 ListView_SetItemState(hList, 0, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);
835 SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)hList);
836 return TRUE;
837 }
838
839 case PSN_QUERYCANCEL:
840 {
841 if (DisplayMessage(GetParent(hwndDlg),
842 MB_YESNO | MB_ICONQUESTION,
843 MAKEINTRESOURCEW(IDS_ABORTSETUP2),
844 MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
845 {
846 /* Go to the Terminate page */
847 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_RESTARTPAGE);
848 }
849
850 /* Do not close the wizard too soon */
851 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
852 return TRUE;
853 }
854
855 case PSN_WIZNEXT: /* Set the selected data */
856 {
857 /*
858 * Go update only if we have available NT installations
859 * and we choose to do so.
860 */
861 if (!pSetupData->NtOsInstallsList ||
862 GetNumberOfListEntries(pSetupData->NtOsInstallsList) == 0)
863 {
864 pSetupData->CurrentInstallation = NULL;
865 pSetupData->RepairUpdateFlag = FALSE;
866 break;
867 }
868
869 hList = GetDlgItem(hwndDlg, IDC_NTOSLIST);
870 SetCurrentListEntry(pSetupData->NtOsInstallsList,
871 GetSelectedListViewItem(hList));
872
873 /* Retrieve the current installation */
874 pSetupData->CurrentInstallation =
875 (PNTOS_INSTALLATION)GetListEntryData(GetCurrentListEntry(pSetupData->NtOsInstallsList));
876
877 /* We perform an upgrade */
878 pSetupData->RepairUpdateFlag = TRUE;
879 return TRUE;
880 }
881
882 default:
883 break;
884 }
885 }
886 break;
887
888 default:
889 break;
890
891 }
892 return FALSE;
893}
894
895static INT_PTR CALLBACK
896DeviceDlgProc(
897 IN HWND hwndDlg,
898 IN UINT uMsg,
899 IN WPARAM wParam,
900 IN LPARAM lParam)
901{
902 PSETUPDATA pSetupData;
903 HWND hList;
904
905 /* Retrieve pointer to the global setup data */
906 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
907
908 switch (uMsg)
909 {
910 case WM_INITDIALOG:
911 {
912 /* Save pointer to the global setup data */
913 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
914 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
915
916 hList = GetDlgItem(hwndDlg, IDC_COMPUTER);
917 InitGenericComboList(hList, pSetupData->USetupData.ComputerList, GetSettingDescription);
918
919 hList = GetDlgItem(hwndDlg, IDC_DISPLAY);
920 InitGenericComboList(hList, pSetupData->USetupData.DisplayList, GetSettingDescription);
921
922 hList = GetDlgItem(hwndDlg, IDC_KEYBOARD);
923 InitGenericComboList(hList, pSetupData->USetupData.KeyboardList, GetSettingDescription);
924
925 // hList = GetDlgItem(hwndDlg, IDC_KEYBOARD_LAYOUT);
926 // InitGenericComboList(hList, pSetupData->USetupData.LayoutList, GetSettingDescription);
927
928 break;
929 }
930
931 case WM_NOTIFY:
932 {
933 LPNMHDR lpnm = (LPNMHDR)lParam;
934
935 switch (lpnm->code)
936 {
937 case PSN_SETACTIVE:
938 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
939 break;
940
941 case PSN_QUERYINITIALFOCUS:
942 {
943 /* Focus on "Computer" list */
944 SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)GetDlgItem(hwndDlg, IDC_COMPUTER));
945 return TRUE;
946 }
947
948 case PSN_QUERYCANCEL:
949 {
950 if (DisplayMessage(GetParent(hwndDlg),
951 MB_YESNO | MB_ICONQUESTION,
952 MAKEINTRESOURCEW(IDS_ABORTSETUP2),
953 MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
954 {
955 /* Go to the Terminate page */
956 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_RESTARTPAGE);
957 }
958
959 /* Do not close the wizard too soon */
960 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
961 return TRUE;
962 }
963
964 case PSN_WIZNEXT: /* Set the selected data */
965 {
966 hList = GetDlgItem(hwndDlg, IDC_COMPUTER);
967 SetCurrentListEntry(pSetupData->USetupData.ComputerList,
968 GetSelectedComboListItem(hList));
969
970 hList = GetDlgItem(hwndDlg, IDC_DISPLAY);
971 SetCurrentListEntry(pSetupData->USetupData.DisplayList,
972 GetSelectedComboListItem(hList));
973
974 hList = GetDlgItem(hwndDlg, IDC_KEYBOARD);
975 SetCurrentListEntry(pSetupData->USetupData.KeyboardList,
976 GetSelectedComboListItem(hList));
977
978 // hList = GetDlgItem(hwndDlg, IDC_KEYBOARD_LAYOUT);
979 // SetCurrentListEntry(pSetupData->USetupData.LayoutList,
980 // GetSelectedComboListItem(hList));
981
982 return TRUE;
983 }
984
985 default:
986 break;
987 }
988 }
989 break;
990
991 default:
992 break;
993
994 }
995 return FALSE;
996}
997
998static INT_PTR CALLBACK
999SummaryDlgProc(
1000 IN HWND hwndDlg,
1001 IN UINT uMsg,
1002 IN WPARAM wParam,
1003 IN LPARAM lParam)
1004{
1005 static WCHAR szOrgWizNextBtnText[260]; // TODO: Make it dynamic
1006
1007 PSETUPDATA pSetupData;
1008
1009 /* Retrieve pointer to the global setup data */
1010 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
1011
1012 switch (uMsg)
1013 {
1014 case WM_INITDIALOG:
1015 {
1016 /* Save pointer to the global setup data */
1017 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
1018 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
1019 break;
1020 }
1021
1022 case WM_COMMAND:
1023 {
1024 if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_CONFIRM_INSTALL)
1025 {
1026 if (IsDlgButtonChecked(hwndDlg, IDC_CONFIRM_INSTALL) == BST_CHECKED)
1027 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT);
1028 else
1029 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
1030 }
1031 break;
1032 }
1033
1034 case WM_NOTIFY:
1035 {
1036 LPNMHDR lpnm = (LPNMHDR)lParam;
1037
1038 switch (lpnm->code)
1039 {
1040 case PSN_SETACTIVE:
1041 {
1042 WCHAR CurrentItemText[256];
1043
1044 ASSERT(InstallPartition);
1045
1046 /* Show the current selected settings */
1047
1048 // FIXME! Localize
1049 if (pSetupData->RepairUpdateFlag)
1050 {
1051 StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
1052 L"Upgrading/Repairing \"%s\" from \"%s\"",
1053 pSetupData->CurrentInstallation->InstallationName,
1054 pSetupData->CurrentInstallation->VendorName);
1055 }
1056 else
1057 {
1058 StringCchCopyW(CurrentItemText, ARRAYSIZE(CurrentItemText),
1059 L"New ReactOS installation");
1060 }
1061 SetDlgItemTextW(hwndDlg, IDC_INSTALLTYPE, CurrentItemText);
1062
1063 SetDlgItemTextW(hwndDlg, IDC_INSTALLSOURCE, L"n/a");
1064 SetDlgItemTextW(hwndDlg, IDC_ARCHITECTURE, L"n/a");
1065
1066 GetSettingDescription(GetCurrentListEntry(pSetupData->USetupData.ComputerList),
1067 CurrentItemText,
1068 ARRAYSIZE(CurrentItemText));
1069 SetDlgItemTextW(hwndDlg, IDC_COMPUTER, CurrentItemText);
1070
1071 GetSettingDescription(GetCurrentListEntry(pSetupData->USetupData.DisplayList),
1072 CurrentItemText,
1073 ARRAYSIZE(CurrentItemText));
1074 SetDlgItemTextW(hwndDlg, IDC_DISPLAY, CurrentItemText);
1075
1076 GetSettingDescription(GetCurrentListEntry(pSetupData->USetupData.KeyboardList),
1077 CurrentItemText,
1078 ARRAYSIZE(CurrentItemText));
1079 SetDlgItemTextW(hwndDlg, IDC_KEYBOARD, CurrentItemText);
1080
1081 if (InstallVolume->Info.DriveLetter)
1082 {
1083#if 0
1084 StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
1085 L"%c: \x2014 %wZ",
1086 InstallVolume->Info.DriveLetter,
1087 &pSetupData->USetupData.DestinationRootPath);
1088#else
1089 StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
1090 L"%c: \x2014 Harddisk %lu, Partition %lu",
1091 InstallVolume->Info.DriveLetter,
1092 InstallPartition->DiskEntry->DiskNumber,
1093 InstallPartition->OnDiskPartitionNumber);
1094#endif
1095 }
1096 else
1097 {
1098#if 0
1099 StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
1100 L"%wZ",
1101 &pSetupData->USetupData.DestinationRootPath);
1102#else
1103 StringCchPrintfW(CurrentItemText, ARRAYSIZE(CurrentItemText),
1104 L"Harddisk %lu, Partition %lu",
1105 InstallPartition->DiskEntry->DiskNumber,
1106 InstallPartition->OnDiskPartitionNumber);
1107#endif
1108 }
1109 SetDlgItemTextW(hwndDlg, IDC_DESTDRIVE, CurrentItemText);
1110
1111 SetDlgItemTextW(hwndDlg, IDC_PATH,
1112 pSetupData->USetupData.InstallationDirectory
1113 /*pSetupData->USetupData.InstallPath.Buffer*/);
1114
1115
1116 /* Change the "Next" button text to "Install" */
1117 // PropSheet_SetNextText(GetParent(hwndDlg), ...);
1118 GetDlgItemTextW(GetParent(hwndDlg), ID_WIZNEXT,
1119 szOrgWizNextBtnText, ARRAYSIZE(szOrgWizNextBtnText));
1120 SetDlgItemTextW(GetParent(hwndDlg), ID_WIZNEXT, L"Install"); // FIXME: Localize!
1121
1122 /*
1123 * Keep the "Next" button disabled. It will be enabled only
1124 * when the user clicks on the installation approval checkbox.
1125 */
1126 CheckDlgButton(hwndDlg, IDC_CONFIRM_INSTALL, BST_UNCHECKED);
1127 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK);
1128 break;
1129 }
1130
1131 case PSN_QUERYINITIALFOCUS:
1132 {
1133 /* Focus on the confirmation check-box */
1134 SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)GetDlgItem(hwndDlg, IDC_CONFIRM_INSTALL));
1135 return TRUE;
1136 }
1137
1138 case PSN_KILLACTIVE:
1139 {
1140 /* Restore the original "Next" button text */
1141 SetDlgItemTextW(GetParent(hwndDlg), ID_WIZNEXT, szOrgWizNextBtnText);
1142 break;
1143 }
1144
1145 case PSN_QUERYCANCEL:
1146 {
1147 if (DisplayMessage(GetParent(hwndDlg),
1148 MB_YESNO | MB_ICONQUESTION,
1149 MAKEINTRESOURCEW(IDS_ABORTSETUP2),
1150 MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
1151 {
1152 /* Go to the Terminate page */
1153 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_RESTARTPAGE);
1154 }
1155
1156 /* Do not close the wizard too soon */
1157 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
1158 return TRUE;
1159 }
1160
1161 default:
1162 break;
1163 }
1164 break;
1165 }
1166
1167 default:
1168 break;
1169 }
1170
1171 return FALSE;
1172}
1173
1174
1175typedef struct _FSVOL_CONTEXT
1176{
1177 PSETUPDATA pSetupData;
1178 // PAGE_NUMBER NextPageOnAbort;
1179} FSVOL_CONTEXT, *PFSVOL_CONTEXT;
1180
1181static
1182BOOLEAN
1183NTAPI
1184FormatCallback(
1185 _In_ CALLBACKCOMMAND Command,
1186 _In_ ULONG Modifier,
1187 _In_ PVOID Argument)
1188{
1189 switch (Command)
1190 {
1191 case PROGRESS:
1192 {
1193 PULONG Percent = (PULONG)Argument;
1194 DPRINT("%lu percent completed\n", *Percent);
1195 SendMessageW(UiContext.hWndProgress, PBM_SETPOS, *Percent, 0);
1196 break;
1197 }
1198
1199#if 0
1200 case OUTPUT:
1201 {
1202 PTEXTOUTPUT output = (PTEXTOUTPUT)Argument;
1203 DPRINT("%s\n", output->Output);
1204 break;
1205 }
1206#endif
1207
1208 case DONE:
1209 {
1210#if 0
1211 PBOOLEAN Success = (PBOOLEAN)Argument;
1212 if (*Success == FALSE)
1213 {
1214 DPRINT("FormatEx was unable to complete successfully.\n\n");
1215 }
1216#endif
1217 DPRINT("Done\n");
1218 break;
1219 }
1220
1221 default:
1222 DPRINT("Unknown callback %lu\n", (ULONG)Command);
1223 break;
1224 }
1225
1226 return TRUE;
1227}
1228
1229static
1230BOOLEAN
1231NTAPI
1232ChkdskCallback(
1233 _In_ CALLBACKCOMMAND Command,
1234 _In_ ULONG Modifier,
1235 _In_ PVOID Argument)
1236{
1237 switch (Command)
1238 {
1239 default:
1240 DPRINT("Unknown callback %lu\n", (ULONG)Command);
1241 break;
1242 }
1243
1244 return TRUE;
1245}
1246
1247// PFSVOL_CALLBACK
1248static FSVOL_OP
1249CALLBACK
1250FsVolCallback(
1251 _In_opt_ PVOID Context,
1252 _In_ FSVOLNOTIFY FormatStatus,
1253 _In_ ULONG_PTR Param1,
1254 _In_ ULONG_PTR Param2)
1255{
1256 PFSVOL_CONTEXT FsVolContext = (PFSVOL_CONTEXT)Context;
1257 WCHAR Buffer[MAX_PATH];
1258
1259 switch (FormatStatus)
1260 {
1261 // FIXME: Deprecate!
1262 case ChangeSystemPartition:
1263 {
1264 // PPARTENTRY SystemPartition = (PPARTENTRY)Param1;
1265
1266 // FsVolContext->NextPageOnAbort = SELECT_PARTITION_PAGE;
1267 // if (ChangeSystemPartitionPage(Ir, SystemPartition))
1268 // return FSVOL_DOIT;
1269 return FSVOL_ABORT;
1270 }
1271
1272 case FSVOLNOTIFY_PARTITIONERROR:
1273 {
1274 switch (Param1)
1275 {
1276 case STATUS_PARTITION_FAILURE:
1277 {
1278 // ERROR_WRITE_PTABLE
1279 DisplayError(NULL,
1280 0, // Default to "Error"
1281 IDS_ERROR_WRITE_PTABLE);
1282 // FsVolContext->NextPageOnAbort = QUIT_PAGE;
1283 // TODO: Go back to the partitioning page?
1284 break;
1285 }
1286
1287 case ERROR_SYSTEM_PARTITION_NOT_FOUND:
1288 {
1289 /* FIXME: improve the error dialog */
1290 //
1291 // Error dialog should say that we cannot find a suitable
1292 // system partition and create one on the system. At this point,
1293 // it may be nice to ask the user whether he wants to continue,
1294 // or use an external drive as the system drive/partition
1295 // (e.g. floppy, USB drive, etc...)
1296 //
1297 DisplayError(NULL,
1298 0, // Default to "Error"
1299 IDS_ERROR_SYSTEM_PARTITION);
1300 // FsVolContext->NextPageOnAbort = SELECT_PARTITION_PAGE;
1301 // TODO: Go back to the partitioning page
1302 break;
1303 }
1304
1305 default:
1306 break;
1307 }
1308 return FSVOL_ABORT;
1309 }
1310
1311 case FSVOLNOTIFY_STARTQUEUE:
1312 case FSVOLNOTIFY_ENDQUEUE:
1313 // NOTE: If needed, clear progress gauges.
1314 return FSVOL_DOIT;
1315
1316 case FSVOLNOTIFY_STARTSUBQUEUE:
1317 {
1318 if ((FSVOL_OP)Param1 == FSVOL_FORMAT)
1319 {
1320 /*
1321 * In case we just repair an existing installation, or make
1322 * an unattended setup without formatting, just go to the
1323 * filesystem check step.
1324 */
1325 if (FsVolContext->pSetupData->RepairUpdateFlag)
1326 return FSVOL_SKIP;
1328 if (IsUnattendedSetup && !FsVolContext->pSetupData->USetupData.FormatPartition)
1329 return FSVOL_SKIP;
1331 /* Set status text */
1332 SetDlgItemTextW(UiContext.hwndDlg, IDC_ITEM, L"");
1333 }
1334 else
1335 if ((FSVOL_OP)Param1 == FSVOL_CHECK)
1336 {
1337 /* Set status text */
1338 SetDlgItemTextW(UiContext.hwndDlg, IDC_ITEM, L"");
1339
1340 /* Filechecking step: set progress marquee style and start it up */
1341 UiContext.dwPbStyle = GetWindowLongPtrW(UiContext.hWndProgress, GWL_STYLE);
1342 SetWindowLongPtrW(UiContext.hWndProgress, GWL_STYLE, UiContext.dwPbStyle | PBS_MARQUEE);
1343 SendMessageW(UiContext.hWndProgress, PBM_SETMARQUEE, TRUE, 0);
1344 }
1345
1346 return FSVOL_DOIT;
1347 }
1348
1349 case FSVOLNOTIFY_ENDSUBQUEUE:
1350 {
1351 if ((FSVOL_OP)Param1 == FSVOL_CHECK)
1352 {
1353 /* File-checking finished: stop the progress bar and restore its style */
1354 SendMessageW(UiContext.hWndProgress, PBM_SETMARQUEE, FALSE, 0);
1355 SetWindowLongPtrW(UiContext.hWndProgress, GWL_STYLE, UiContext.dwPbStyle);
1356 }
1357 return 0;
1358 }
1359
1360 case FSVOLNOTIFY_FORMATERROR:
1361 {
1362 PFORMAT_VOLUME_INFO FmtInfo = (PFORMAT_VOLUME_INFO)Param1;
1363
1364 // FIXME: See also FSVOLNOTIFY_PARTITIONERROR
1365 if (FmtInfo->ErrorStatus == STATUS_PARTITION_FAILURE)
1366 {
1367 // ERROR_WRITE_PTABLE
1368 DisplayError(NULL,
1369 0, // Default to "Error"
1370 IDS_ERROR_WRITE_PTABLE);
1371 // FsVolContext->NextPageOnAbort = QUIT_PAGE;
1372 // TODO: Go back to the partitioning page?
1373 return FSVOL_ABORT;
1374 }
1375 else
1376 if (FmtInfo->ErrorStatus == STATUS_UNRECOGNIZED_VOLUME)
1377 {
1378 /* FIXME: show an error dialog */
1379 // MUIDisplayError(ERROR_FORMATTING_PARTITION, Ir, POPUP_WAIT_ANY_KEY, PathBuffer);
1380 DisplayError(NULL,
1381 0, // Default to "Error"
1382 IDS_ERROR_FORMAT_UNRECOGNIZED_VOLUME);
1383 // FsVolContext->NextPageOnAbort = QUIT_PAGE;
1384 return FSVOL_ABORT;
1385 }
1386 else
1387 if (FmtInfo->ErrorStatus == STATUS_NOT_SUPPORTED)
1388 {
1389 INT nRet;
1390
1391 nRet = DisplayMessage(NULL, MB_ICONERROR | MB_OKCANCEL,
1392 NULL, // Default to "Error"
1393 MAKEINTRESOURCEW(IDS_ERROR_COULD_NOT_FORMAT),
1394 FmtInfo->FileSystemName);
1395 if (nRet == IDCANCEL)
1396 {
1397 // FsVolContext->NextPageOnAbort = QUIT_PAGE;
1398 return FSVOL_ABORT;
1399 }
1400 else if (nRet == IDOK)
1401 {
1402 return FSVOL_RETRY;
1403 }
1404 }
1405 else if (!NT_SUCCESS(FmtInfo->ErrorStatus))
1406 {
1407 ASSERT(*FmtInfo->Volume->Info.DeviceName);
1408
1409 DPRINT1("FormatPartition() failed with status 0x%08lx\n", FmtInfo->ErrorStatus);
1410
1411 // ERROR_FORMATTING_PARTITION
1412 DisplayError(NULL,
1413 0, // Default to "Error"
1414 IDS_ERROR_FORMATTING_PARTITION,
1415 FmtInfo->Volume->Info.DeviceName);
1416 // FsVolContext->NextPageOnAbort = QUIT_PAGE;
1417 return FSVOL_ABORT;
1418 }
1419
1420 return FSVOL_RETRY;
1421 }
1422
1423 case FSVOLNOTIFY_CHECKERROR:
1424 {
1425 PCHECK_VOLUME_INFO ChkInfo = (PCHECK_VOLUME_INFO)Param1;
1426
1427 if (ChkInfo->ErrorStatus == STATUS_NOT_SUPPORTED)
1428 {
1429 INT nRet;
1430
1431 nRet = DisplayMessage(NULL, MB_ICONERROR | MB_OKCANCEL,
1432 NULL, // Default to "Error"
1433 MAKEINTRESOURCEW(IDS_ERROR_COULD_NOT_CHECK),
1434 ChkInfo->Volume->Info.FileSystem);
1435 if (nRet == IDCANCEL)
1436 {
1437 // FsVolContext->NextPageOnAbort = QUIT_PAGE;
1438 return FSVOL_ABORT;
1439 }
1440 else if (nRet == IDOK)
1441 {
1442 return FSVOL_SKIP;
1443 }
1444 }
1445 else if (!NT_SUCCESS(ChkInfo->ErrorStatus))
1446 {
1447 DPRINT1("ChkdskPartition() failed with status 0x%08lx\n", ChkInfo->ErrorStatus);
1448
1449 DisplayError(NULL,
1450 0, // Default to "Error"
1451 IDS_ERROR_CHECKING_PARTITION,
1452 ChkInfo->ErrorStatus);
1453 return FSVOL_SKIP;
1454 }
1455
1456 return FSVOL_SKIP;
1457 }
1458
1459 case FSVOLNOTIFY_STARTFORMAT:
1460 {
1461 PFORMAT_VOLUME_INFO FmtInfo = (PFORMAT_VOLUME_INFO)Param1;
1462 PVOL_CREATE_INFO VolCreate;
1463
1464 ASSERT((FSVOL_OP)Param2 == FSVOL_FORMAT);
1465
1466 /* Find the volume info in the partition TreeList UI.
1467 * If none, don't format it. */
1468 VolCreate = FindVolCreateInTreeByVolume(UiContext.hPartList,
1469 FmtInfo->Volume);
1470 if (!VolCreate)
1471 return FSVOL_SKIP;
1472 ASSERT(VolCreate->Volume == FmtInfo->Volume);
1473
1474 /* If there is no formatting information, skip it */
1475 if (!*VolCreate->FileSystemName)
1476 return FSVOL_SKIP;
1477
1478 ASSERT(*FmtInfo->Volume->Info.DeviceName);
1479
1480 /* Set status text */
1481 if (FmtInfo->Volume->Info.DriveLetter)
1482 {
1483 StringCchPrintfW(Buffer, ARRAYSIZE(Buffer),
1484 L"Formatting volume %c: (%s) in %s...", // IDS_FORMATTING_PROGRESS1
1485 FmtInfo->Volume->Info.DriveLetter,
1486 FmtInfo->Volume->Info.DeviceName,
1487 VolCreate->FileSystemName);
1488 }
1489 else
1490 {
1491 StringCchPrintfW(Buffer, ARRAYSIZE(Buffer),
1492 L"Formatting volume %s in %s...", // IDS_FORMATTING_PROGRESS2
1493 FmtInfo->Volume->Info.DeviceName,
1494 VolCreate->FileSystemName);
1495 }
1496 SetDlgItemTextW(UiContext.hwndDlg, IDC_ITEM, Buffer);
1497
1498 // StartFormat(FmtInfo, FileSystemList->Selected);
1499 FmtInfo->FileSystemName = VolCreate->FileSystemName;
1500 FmtInfo->MediaFlag = VolCreate->MediaFlag;
1501 FmtInfo->Label = VolCreate->Label;
1502 FmtInfo->QuickFormat = VolCreate->QuickFormat;
1503 FmtInfo->ClusterSize = VolCreate->ClusterSize;
1504 FmtInfo->Callback = FormatCallback;
1505
1506 /* Set up the progress bar */
1507 SendMessageW(UiContext.hWndProgress,
1508 PBM_SETRANGE, 0, MAKELPARAM(0, 100));
1509 SendMessageW(UiContext.hWndProgress,
1510 PBM_SETPOS, 0, 0);
1511
1512 return FSVOL_DOIT;
1513 }
1514
1515 case FSVOLNOTIFY_ENDFORMAT:
1516 {
1517 PFORMAT_VOLUME_INFO FmtInfo = (PFORMAT_VOLUME_INFO)Param1;
1518
1519 // EndFormat(FmtInfo->ErrorStatus);
1520 if (FmtInfo->FileSystemName)
1521 *(PWSTR)FmtInfo->FileSystemName = UNICODE_NULL; // FIXME: HACK!
1522
1523 // /* Reset the file system list */
1524 // ResetFileSystemList();
1525 return 0;
1526 }
1527
1528 case FSVOLNOTIFY_STARTCHECK:
1529 {
1530 PCHECK_VOLUME_INFO ChkInfo = (PCHECK_VOLUME_INFO)Param1;
1531 PVOL_CREATE_INFO VolCreate;
1532
1533 ASSERT((FSVOL_OP)Param2 == FSVOL_CHECK);
1534
1535 /* Find the volume info in the partition TreeList UI.
1536 * If none, don't check it. */
1537 VolCreate = FindVolCreateInTreeByVolume(UiContext.hPartList,
1538 ChkInfo->Volume);
1539 if (!VolCreate)
1540 return FSVOL_SKIP;
1541 ASSERT(VolCreate->Volume == ChkInfo->Volume);
1542
1543 ASSERT(*ChkInfo->Volume->Info.DeviceName);
1544
1545 /* Set status text */
1546 if (ChkInfo->Volume->Info.DriveLetter)
1547 {
1548 StringCchPrintfW(Buffer, ARRAYSIZE(Buffer),
1549 L"Checking volume %c: (%s)...", // IDS_CHECKING_PROGRESS1
1550 ChkInfo->Volume->Info.DriveLetter,
1551 ChkInfo->Volume->Info.DeviceName);
1552 }
1553 else
1554 {
1555 StringCchPrintfW(Buffer, ARRAYSIZE(Buffer),
1556 L"Checking volume %s...", // IDS_CHECKING_PROGRESS2
1557 ChkInfo->Volume->Info.DeviceName);
1558 }
1559 SetDlgItemTextW(UiContext.hwndDlg, IDC_ITEM, Buffer);
1560
1561 // StartCheck(ChkInfo);
1562 // TODO: Think about which values could be defaulted...
1563 ChkInfo->FixErrors = TRUE;
1564 ChkInfo->Verbose = FALSE;
1565 ChkInfo->CheckOnlyIfDirty = TRUE;
1566 ChkInfo->ScanDrive = FALSE;
1567 ChkInfo->Callback = ChkdskCallback;
1568
1569 return FSVOL_DOIT;
1570 }
1571
1572 case FSVOLNOTIFY_ENDCHECK:
1573 {
1574 // PCHECK_VOLUME_INFO ChkInfo = (PCHECK_VOLUME_INFO)Param1;
1575 // EndCheck(ChkInfo->ErrorStatus);
1576 return 0;
1577 }
1578 }
1579
1580 return 0;
1581}
1582
1583
1584
1585typedef struct _COPYCONTEXT
1586{
1587 PSETUPDATA pSetupData;
1588 ULONG TotalOperations;
1589 ULONG CompletedOperations;
1590} COPYCONTEXT, *PCOPYCONTEXT;
1591
1592static UINT
1593CALLBACK
1594FileCopyCallback(PVOID Context,
1595 UINT Notification,
1596 UINT_PTR Param1,
1597 UINT_PTR Param2)
1598{
1599 PCOPYCONTEXT CopyContext = (PCOPYCONTEXT)Context;
1600 PFILEPATHS_W FilePathInfo;
1601 PCWSTR SrcFileName, DstFileName;
1602 WCHAR Status[1024];
1603
1604 WaitForSingleObject(CopyContext->pSetupData->hHaltInstallEvent, INFINITE);
1605 if (CopyContext->pSetupData->bStopInstall)
1606 return FILEOP_ABORT; // Stop committing files
1607
1608 switch (Notification)
1609 {
1610 case SPFILENOTIFY_STARTSUBQUEUE:
1611 {
1612 CopyContext->TotalOperations = (ULONG)Param2;
1613 CopyContext->CompletedOperations = 0;
1614
1615 /* Set up the progress bar */
1616 SendMessageW(UiContext.hWndProgress,
1617 PBM_SETRANGE, 0,
1618 MAKELPARAM(0, CopyContext->TotalOperations));
1619 SendMessageW(UiContext.hWndProgress,
1620 PBM_SETSTEP, 1, 0);
1621 SendMessageW(UiContext.hWndProgress,
1622 PBM_SETPOS, 0, 0);
1623 break;
1624 }
1625
1626 case SPFILENOTIFY_STARTDELETE:
1627 case SPFILENOTIFY_STARTRENAME:
1628 case SPFILENOTIFY_STARTCOPY:
1629 {
1630 FilePathInfo = (PFILEPATHS_W)Param1;
1631
1632 if (Notification == SPFILENOTIFY_STARTDELETE)
1633 {
1634 /* Display delete message */
1635 ASSERT(Param2 == FILEOP_DELETE);
1636
1637 DstFileName = wcsrchr(FilePathInfo->Target, L'\\');
1638 if (DstFileName) ++DstFileName;
1639 else DstFileName = FilePathInfo->Target;
1640
1641 // STRING_DELETING
1642 StringCchPrintfW(Status, ARRAYSIZE(Status), L"Deleting %s", DstFileName);
1643 SetWindowTextW(UiContext.hWndItem, Status);
1644 }
1645 else if (Notification == SPFILENOTIFY_STARTRENAME)
1646 {
1647 /* Display move/rename message */
1648 ASSERT(Param2 == FILEOP_RENAME);
1649
1650 SrcFileName = wcsrchr(FilePathInfo->Source, L'\\');
1651 if (SrcFileName) ++SrcFileName;
1652 else SrcFileName = FilePathInfo->Source;
1653
1654 DstFileName = wcsrchr(FilePathInfo->Target, L'\\');
1655 if (DstFileName) ++DstFileName;
1656 else DstFileName = FilePathInfo->Target;
1657
1658 // STRING_MOVING or STRING_RENAMING
1659 if (!wcsicmp(SrcFileName, DstFileName))
1660 StringCchPrintfW(Status, ARRAYSIZE(Status), L"Moving %s to %s", SrcFileName, DstFileName);
1661 else
1662 StringCchPrintfW(Status, ARRAYSIZE(Status), L"Renaming %s to %s", SrcFileName, DstFileName);
1663
1664 SetWindowTextW(UiContext.hWndItem, Status);
1665 }
1666 else if (Notification == SPFILENOTIFY_STARTCOPY)
1667 {
1668 /* Display copy message */
1669 ASSERT(Param2 == FILEOP_COPY);
1670
1671 DstFileName = wcsrchr(FilePathInfo->Target, L'\\');
1672 if (DstFileName) ++DstFileName;
1673 else DstFileName = FilePathInfo->Target;
1674
1675 // STRING_COPYING
1676 StringCchPrintfW(Status, ARRAYSIZE(Status), L"Copying %s", DstFileName);
1677 SetWindowTextW(UiContext.hWndItem, Status);
1678 }
1679 break;
1680 }
1681
1682 case SPFILENOTIFY_COPYERROR:
1683 {
1684 FilePathInfo = (PFILEPATHS_W)Param1;
1685
1686 DPRINT1("An error happened while trying to copy file '%S' (error 0x%08lx), skipping it...\n",
1687 FilePathInfo->Target, FilePathInfo->Win32Error);
1688 return FILEOP_SKIP;
1689 }
1690
1691 case SPFILENOTIFY_ENDDELETE:
1692 case SPFILENOTIFY_ENDRENAME:
1693 case SPFILENOTIFY_ENDCOPY:
1694 {
1695 CopyContext->CompletedOperations++;
1696
1697 /* SYSREG checkpoint */
1698 if (CopyContext->TotalOperations >> 1 == CopyContext->CompletedOperations)
1699 DPRINT1("CHECKPOINT:HALF_COPIED\n");
1700
1701 SendMessageW(UiContext.hWndProgress, PBM_STEPIT, 0, 0);
1702 break;
1703 }
1704 }
1705
1706 return FILEOP_DOIT;
1707}
1708
1709static VOID
1710__cdecl
1711RegistryStatus(IN REGISTRY_STATUS RegStatus, ...)
1712{
1713 /* WARNING: Please keep this lookup table in sync with the resources! */
1714 static const UINT StringIDs[] =
1715 {
1716 IDS_REG_DONE, /* Success */
1717 IDS_REG_REGHIVEUPDATE, /* RegHiveUpdate */
1718 IDS_REG_IMPORTFILE, /* ImportRegHive */
1719 IDS_REG_DISPLAYSETTINGSUPDATE, /* DisplaySettingsUpdate */
1720 IDS_REG_LOCALESETTINGSUPDATE, /* LocaleSettingsUpdate */
1721 IDS_REG_ADDKBLAYOUTS, /* KeybLayouts */
1722 IDS_REG_KEYBOARDSETTINGSUPDATE, /* KeybSettingsUpdate */
1723 IDS_REG_CODEPAGEINFOUPDATE, /* CodePageInfoUpdate */
1724 };
1725
1726 if (RegStatus < _countof(StringIDs))
1727 {
1728 va_list args;
1729 va_start(args, RegStatus);
1730 SetWindowResPrintfVW(UiContext.hWndItem, SetupData.hInstance, StringIDs[RegStatus], args);
1731 va_end(args);
1732 }
1733 else
1734 {
1735 SetWindowResPrintfW(UiContext.hWndItem, SetupData.hInstance, IDS_REG_UNKNOWN, RegStatus);
1736 }
1737
1738 SendMessageW(UiContext.hWndProgress, PBM_STEPIT, 0, 0);
1739}
1740
1746VOID
1747PropSheet_SetCloseCancel(
1748 _In_ HWND hWndWiz,
1749 _In_ BOOL Enable)
1750{
1751 EnableDlgItem(hWndWiz, IDCANCEL, Enable);
1752 // ShowDlgItem(hWndWiz, IDCANCEL, Enable ? SW_SHOW : SW_HIDE);
1753 EnableMenuItem(GetSystemMenu(hWndWiz, FALSE),
1754 SC_CLOSE,
1755 MF_BYCOMMAND | (Enable ? MF_ENABLED : MF_GRAYED));
1756}
1757
1758static DWORD
1759WINAPI
1760PrepareAndDoCopyThread(
1761 IN LPVOID Param)
1762{
1763 PSETUPDATA pSetupData;
1764 HWND hwndDlg = (HWND)Param;
1765 HWND hWndProgress;
1766 LONG_PTR dwStyle;
1767 ERROR_NUMBER ErrorNumber;
1768 BOOLEAN Success;
1769 NTSTATUS Status;
1770 FSVOL_CONTEXT FsVolContext;
1771 COPYCONTEXT CopyContext;
1772 // WCHAR PathBuffer[MAX_PATH];
1773
1774 /* Retrieve pointer to the global setup data */
1775 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
1776
1777 /* Get the progress handle */
1778 hWndProgress = GetDlgItem(hwndDlg, IDC_PROCESSPROGRESS);
1779
1780 /* Setup global UI context */
1781 UiContext.hwndDlg = hwndDlg;
1782 UiContext.hWndItem = GetDlgItem(hwndDlg, IDC_ITEM);
1783 UiContext.hWndProgress = hWndProgress;
1784 UiContext.dwPbStyle = 0;
1785
1786
1787 /* Disable the Close/Cancel buttons during all partition operations */
1788 // TODO: Consider, alternatively, to just show an info-box saying
1789 // that the installation process cannot be canceled at this stage?
1790 // PropSheet_SetWizButtons(GetParent(hwndDlg), 0);
1791 PropSheet_SetCloseCancel(GetParent(hwndDlg), FALSE);
1792
1793
1794 /*
1795 * Find/Set the system partition, and apply all pending partition operations.
1796 */
1797
1798 /* Create context for the volume/partition operations */
1799 FsVolContext.pSetupData = pSetupData;
1800
1801 /* Set status text */
1802 SetDlgItemTextW(hwndDlg, IDC_ACTIVITY, L"Setting the system partition...");
1803 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
1804
1805 /* Find or set the active system partition before starting formatting */
1806 Success = InitSystemPartition(pSetupData->PartitionList,
1807 InstallPartition,
1808 &SystemPartition,
1809 FsVolCallback,
1810 &FsVolContext);
1811 // if (!Success)
1812 // return FsVolContext.NextPageOnAbort;
1813 //
1814 // FIXME?? If cannot use any system partition, install FreeLdr on floppy / removable media??
1815 //
1816 if (!Success)
1817 {
1818 /* Display an error if an unexpected failure happened */
1819 MessageBoxW(GetParent(hwndDlg), L"Failed to find or set the system partition!", L"Error", MB_ICONERROR);
1820
1821 /* Re-enable the Close/Cancel buttons */
1822 PropSheet_SetCloseCancel(GetParent(hwndDlg), TRUE);
1823
1824 /*
1825 * We failed due to an unexpected error, keep on the copy page to view the current state,
1826 * but enable the "Next" button to allow the user to continue to the terminate page.
1827 */
1828 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT);
1829 return 1;
1830 }
1831
1832
1833 /* Set status text */
1834 SetDlgItemTextW(hwndDlg, IDC_ACTIVITY, L"Preparing partitions...");
1835 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
1836
1837 /* Apply all pending operations on partitions: formatting and checking */
1838 Success = FsVolCommitOpsQueue(pSetupData->PartitionList,
1839 SystemVolume,
1840 InstallVolume,
1841 FsVolCallback,
1842 &FsVolContext);
1843 if (!Success)
1844 {
1845 /* Display an error if an unexpected failure happened */
1846 MessageBoxW(GetParent(hwndDlg), L"Failed to prepare the partitions!", L"Error", MB_ICONERROR);
1847
1848 /* Re-enable the Close/Cancel buttons */
1849 PropSheet_SetCloseCancel(GetParent(hwndDlg), TRUE);
1850
1851 /*
1852 * We failed due to an unexpected error, keep on the copy page to view the current state,
1853 * but enable the "Next" button to allow the user to continue to the terminate page.
1854 */
1855 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT);
1856 return 1;
1857 }
1858
1859
1860 /* Re-enable the Close/Cancel buttons */
1861 PropSheet_SetCloseCancel(GetParent(hwndDlg), TRUE);
1862
1863
1864
1865 /* Re-calculate the final destination paths */
1866 ASSERT(InstallPartition);
1867 Status = InitDestinationPaths(&pSetupData->USetupData,
1868 NULL, // pSetupData->USetupData.InstallationDirectory,
1869 InstallVolume);
1870 if (!NT_SUCCESS(Status))
1871 {
1872 DisplayMessage(GetParent(hwndDlg), MB_ICONERROR, L"Error", L"InitDestinationPaths() failed with status 0x%08lx\n", Status);
1873
1874 /*
1875 * We failed due to an unexpected error, keep on the copy page to view the current state,
1876 * but enable the "Next" button to allow the user to continue to the terminate page.
1877 */
1878 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT);
1879 return 1;
1880 }
1881
1882
1883
1884 /*
1885 * Preparation of the list of files to be copied
1886 */
1887
1888 /* Set status text */
1889 SetDlgItemTextW(hwndDlg, IDC_ACTIVITY, L"Preparing the list of files to be copied, please wait...");
1890 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
1891
1892 /* Set progress marquee style and start it up */
1893 dwStyle = GetWindowLongPtrW(hWndProgress, GWL_STYLE);
1894 SetWindowLongPtrW(hWndProgress, GWL_STYLE, dwStyle | PBS_MARQUEE);
1895 SendMessageW(hWndProgress, PBM_SETMARQUEE, TRUE, 0);
1896
1897 /* Prepare the list of files */
1898 /* ErrorNumber = */ Success = PrepareFileCopy(&pSetupData->USetupData, NULL);
1899
1900 /* Stop progress and restore its style */
1901 SendMessageW(hWndProgress, PBM_SETMARQUEE, FALSE, 0);
1902 SetWindowLongPtrW(hWndProgress, GWL_STYLE, dwStyle);
1903
1904 if (/*ErrorNumber != ERROR_SUCCESS*/ !Success)
1905 {
1906 /* Display an error only if an unexpected failure happened, and not because the user cancelled the installation */
1907 if (!pSetupData->bStopInstall)
1908 MessageBoxW(GetParent(hwndDlg), L"Failed to prepare the list of files!", L"Error", MB_ICONERROR);
1909
1910 /*
1911 * If we failed due to an unexpected error, keep on the copy page to view the current state,
1912 * but enable the "Next" button to allow the user to continue to the terminate page.
1913 * Otherwise we have been cancelled by the user, who has already switched to the Terminate page.
1914 */
1915 if (!pSetupData->bStopInstall)
1916 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT);
1917 return 1;
1918 }
1919
1920
1921 /*
1922 * Perform the file copy
1923 */
1924
1925 /* Set status text */
1926 SetDlgItemTextW(hwndDlg, IDC_ACTIVITY, L"Copying the files...");
1927 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
1928
1929 /* Create context for the copy process */
1930 CopyContext.pSetupData = pSetupData;
1931 CopyContext.TotalOperations = 0;
1932 CopyContext.CompletedOperations = 0;
1933
1934 /* Do the file copying - The callback handles whether or not we should stop file copying */
1935 if (!DoFileCopy(&pSetupData->USetupData, FileCopyCallback, &CopyContext))
1936 {
1937 /* Display an error only if an unexpected failure happened, and not because the user cancelled the installation */
1938 if (!pSetupData->bStopInstall)
1939 MessageBoxW(GetParent(hwndDlg), L"Failed to copy the files!", L"Error", MB_ICONERROR);
1940
1941 /*
1942 * If we failed due to an unexpected error, keep on the copy page to view the current state,
1943 * but enable the "Next" button to allow the user to continue to the terminate page.
1944 * Otherwise we have been cancelled by the user, who has already switched to the Terminate page.
1945 */
1946 if (!pSetupData->bStopInstall)
1947 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT);
1948 return 1;
1949 }
1950
1951 // /* Set status text */
1952 // SetDlgItemTextW(hwndDlg, IDC_ACTIVITY, L"Finalizing the installation...");
1953 // SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
1954
1955 /* Create the $winnt$.inf file */
1956 InstallSetupInfFile(&pSetupData->USetupData);
1957
1958
1959 /*
1960 * Create or update the registry hives
1961 */
1962
1963 /* Set status text */
1964 SetWindowResTextW(GetDlgItem(hwndDlg, IDC_ACTIVITY),
1965 pSetupData->hInstance,
1966 pSetupData->RepairUpdateFlag ? IDS_UPDATE_REGISTRY
1967 : IDS_CREATE_REGISTRY);
1968 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
1969
1970 /* Set up the progress bar */
1971 SendMessageW(hWndProgress,
1972 PBM_SETRANGE, 0,
1973 MAKELPARAM(0, 8)); // FIXME: hardcoded number of steps, see StringIDs[] array in RegistryStatus()
1974 SendMessageW(hWndProgress,
1975 PBM_SETSTEP, 1, 0);
1976 SendMessageW(hWndProgress,
1977 PBM_SETPOS, 0, 0);
1978
1979 ErrorNumber = UpdateRegistry(&pSetupData->USetupData,
1980 pSetupData->RepairUpdateFlag,
1981 pSetupData->PartitionList,
1982 InstallVolume->Info.DriveLetter,
1983 pSetupData->SelectedLanguageId,
1984 RegistryStatus,
1985 NULL /* SubstSettings */);
1986 DBG_UNREFERENCED_PARAMETER(ErrorNumber);
1987 SendMessageW(UiContext.hWndProgress, PBM_SETPOS, 100, 0);
1988
1989
1990 /* We are done! Switch to the Terminate page */
1991 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_RESTARTPAGE);
1992 return 0;
1993}
1994
1995
1996static INT_PTR CALLBACK
1997ProcessDlgProc(
1998 IN HWND hwndDlg,
1999 IN UINT uMsg,
2000 IN WPARAM wParam,
2001 IN LPARAM lParam)
2002{
2003 PSETUPDATA pSetupData;
2004
2005 /* Retrieve pointer to the global setup data */
2006 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
2007
2008 switch (uMsg)
2009 {
2010 case WM_INITDIALOG:
2011 {
2012 /* Save pointer to the global setup data */
2013 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
2014 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
2015
2016 /* Reset status text */
2017 SetDlgItemTextW(hwndDlg, IDC_ACTIVITY, L"");
2018 SetDlgItemTextW(hwndDlg, IDC_ITEM, L"");
2019
2020 break;
2021 }
2022
2023 case WM_NOTIFY:
2024 {
2025 LPNMHDR lpnm = (LPNMHDR)lParam;
2026
2027 switch (lpnm->code)
2028 {
2029 case PSN_SETACTIVE:
2030 {
2031 /* Create the file-copy halt (manual-reset) event */
2032 pSetupData->hHaltInstallEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
2033 if (!pSetupData->hHaltInstallEvent)
2034 break;
2035 pSetupData->bStopInstall = FALSE;
2036
2037 /* Start the prepare-and-copy files thread */
2038 pSetupData->hInstallThread =
2039 CreateThread(NULL, 0,
2040 PrepareAndDoCopyThread,
2041 (PVOID)hwndDlg,
2042 CREATE_SUSPENDED,
2043 NULL);
2044 if (!pSetupData->hInstallThread)
2045 {
2046 CloseHandle(pSetupData->hHaltInstallEvent);
2047 pSetupData->hHaltInstallEvent = NULL;
2048
2049 MessageBoxW(GetParent(hwndDlg), L"Cannot create the prepare-and-copy files thread!", L"Error", MB_ICONERROR);
2050 break;
2051 }
2052
2053 /* Disable all buttons during installation process - buttons will be reenabled by the installation thread */
2054 PropSheet_SetWizButtons(GetParent(hwndDlg), 0);
2055
2056 /* Resume the installation thread */
2057 ResumeThread(pSetupData->hInstallThread);
2058
2059 break;
2060 }
2061
2062 case PSN_QUERYCANCEL:
2063 {
2064 /* Halt the on-going file copy */
2065 ResetEvent(pSetupData->hHaltInstallEvent);
2066
2067 if (DisplayMessage(GetParent(hwndDlg),
2068 MB_YESNO | MB_ICONQUESTION,
2069 MAKEINTRESOURCEW(IDS_ABORTSETUP2),
2070 MAKEINTRESOURCEW(IDS_ABORTSETUP)) == IDYES)
2071 {
2072 /* Stop the file copy thread */
2073 pSetupData->bStopInstall = TRUE;
2074 SetEvent(pSetupData->hHaltInstallEvent);
2075
2076#if 0
2077 /* Wait for any pending installation */
2078 WaitForSingleObject(pSetupData->hInstallThread, INFINITE);
2079 CloseHandle(pSetupData->hInstallThread);
2080 pSetupData->hInstallThread = NULL;
2081 CloseHandle(pSetupData->hHaltInstallEvent);
2082 pSetupData->hHaltInstallEvent = NULL;
2083#endif
2084
2085 // TODO: Unwind installation?!
2086
2087 /* Go to the Terminate page */
2088 PropSheet_SetCurSelByID(GetParent(hwndDlg), IDD_RESTARTPAGE);
2089 }
2090 else
2091 {
2092 /* We don't stop installation, resume file copy */
2093 SetEvent(pSetupData->hHaltInstallEvent);
2094 }
2095
2096 /* Do not close the wizard too soon */
2097 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
2098 return TRUE;
2099 }
2100
2101 default:
2102 break;
2103 }
2104 }
2105 break;
2106
2107 default:
2108 break;
2109
2110 }
2111
2112 return FALSE;
2113}
2114
2115static INT_PTR CALLBACK
2116RestartDlgProc(
2117 IN HWND hwndDlg,
2118 IN UINT uMsg,
2119 IN WPARAM wParam,
2120 IN LPARAM lParam)
2121{
2122 PSETUPDATA pSetupData;
2123
2124 /* Retrieve pointer to the global setup data */
2125 pSetupData = (PSETUPDATA)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
2126
2127 switch (uMsg)
2128 {
2129 case WM_INITDIALOG:
2130 /* Save pointer to the global setup data */
2131 pSetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;
2132 SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pSetupData);
2133
2134 /* Set title font */
2135 SendDlgItemMessage(hwndDlg,
2136 IDC_FINISHTITLE,
2137 WM_SETFONT,
2138 (WPARAM)pSetupData->hTitleFont,
2139 (LPARAM)TRUE);
2140 break;
2141
2142 case WM_TIMER:
2143 {
2144 INT Position;
2145 HWND hWndProgress;
2146
2147 hWndProgress = GetDlgItem(hwndDlg, IDC_RESTART_PROGRESS);
2148 Position = SendMessageW(hWndProgress, PBM_GETPOS, 0, 0);
2149 if (Position == 300)
2150 {
2151 KillTimer(hwndDlg, 1);
2152 PropSheet_PressButton(GetParent(hwndDlg), PSBTN_FINISH);
2153 }
2154 else
2155 {
2156 SendMessageW(hWndProgress, PBM_SETPOS, Position + 1, 0);
2157 }
2158 return TRUE;
2159 }
2160
2161 case WM_DESTROY:
2162 return TRUE;
2163
2164 case WM_NOTIFY:
2165 {
2166 LPNMHDR lpnm = (LPNMHDR)lParam;
2167
2168 switch (lpnm->code)
2169 {
2170 case PSN_SETACTIVE:
2171 {
2172 /* Only "Finish" for closing the wizard */
2173 ShowDlgItem(GetParent(hwndDlg), IDCANCEL, SW_HIDE);
2174 PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_FINISH);
2175
2176 /* Set up the reboot progress bar */
2177 SendDlgItemMessage(hwndDlg, IDC_RESTART_PROGRESS, PBM_SETRANGE, 0, MAKELPARAM(0, 300));
2178 SendDlgItemMessage(hwndDlg, IDC_RESTART_PROGRESS, PBM_SETPOS, 0, 0);
2179 SetTimer(hwndDlg, 1, 50, NULL);
2180 break;
2181 }
2182
2183 default:
2184 break;
2185 }
2186 }
2187 break;
2188
2189 default:
2190 break;
2191
2192 }
2193
2194 return FALSE;
2195}
2196
2197BOOL LoadSetupData(
2198 IN OUT PSETUPDATA pSetupData)
2199{
2200 pSetupData->PartitionList = CreatePartitionList();
2201 if (!pSetupData->PartitionList)
2202 {
2203 DPRINT1("Could not enumerate available disks; failing installation\n");
2204 return FALSE;
2205 }
2206
2207 pSetupData->NtOsInstallsList = CreateNTOSInstallationsList(pSetupData->PartitionList);
2208 if (!pSetupData->NtOsInstallsList)
2209 DPRINT1("Failed to get a list of NTOS installations; continue installation...\n");
2210
2211 /* Load the hardware, language and keyboard layout lists */
2212
2213 pSetupData->USetupData.ComputerList = CreateComputerTypeList(pSetupData->USetupData.SetupInf);
2214 pSetupData->USetupData.DisplayList = CreateDisplayDriverList(pSetupData->USetupData.SetupInf);
2215 pSetupData->USetupData.KeyboardList = CreateKeyboardDriverList(pSetupData->USetupData.SetupInf);
2216
2217 pSetupData->USetupData.LanguageList = CreateLanguageList(pSetupData->USetupData.SetupInf, pSetupData->DefaultLanguage);
2218
2219 /* If not unattended, overwrite language and locale with
2220 * the current ones of the running ReactOS instance */
2221 if (!IsUnattendedSetup)
2222 {
2223 LCID LocaleID = GetUserDefaultLCID();
2224
2225 StringCchPrintfW(pSetupData->DefaultLanguage,
2226 _countof(pSetupData->DefaultLanguage),
2227 L"%08lx", LocaleID);
2228
2229 StringCchPrintfW(pSetupData->USetupData.LocaleID,
2230 _countof(pSetupData->USetupData.LocaleID),
2231 L"%08lx", LocaleID);
2232 }
2233
2234 /* new part */
2235 pSetupData->SelectedLanguageId = pSetupData->DefaultLanguage;
2236 wcscpy(pSetupData->DefaultLanguage, pSetupData->USetupData.LocaleID); // FIXME: In principle, only when unattended.
2237 pSetupData->USetupData.LanguageId = (LANGID)(wcstol(pSetupData->SelectedLanguageId, NULL, 16) & 0xFFFF);
2238
2239 pSetupData->USetupData.LayoutList = CreateKeyboardLayoutList(pSetupData->USetupData.SetupInf,
2240 pSetupData->SelectedLanguageId,
2241 pSetupData->DefaultKBLayout);
2242
2243 /* If not unattended, overwrite keyboard layout with
2244 * the current one of the running ReactOS instance */
2245 if (!IsUnattendedSetup)
2246 {
2247 C_ASSERT(_countof(pSetupData->DefaultKBLayout) >= KL_NAMELENGTH);
2248 /* If the call fails, keep the default already stored in the buffer */
2249 GetKeyboardLayoutNameW(pSetupData->DefaultKBLayout);
2250 }
2251
2252 /* Change the default entries in the language and keyboard layout lists */
2253 {
2254 PGENERIC_LIST LanguageList = pSetupData->USetupData.LanguageList;
2255 PGENERIC_LIST LayoutList = pSetupData->USetupData.LayoutList;
2256 PGENERIC_LIST_ENTRY ListEntry;
2257
2258 /* Search for default language */
2259 for (ListEntry = GetFirstListEntry(LanguageList); ListEntry;
2260 ListEntry = GetNextListEntry(ListEntry))
2261 {
2262 PCWSTR LocaleId = ((PGENENTRY)GetListEntryData(ListEntry))->Id;
2263 if (!wcsicmp(pSetupData->DefaultLanguage, LocaleId))
2264 {
2265 DPRINT("found %S in LanguageList\n", LocaleId);
2266 SetCurrentListEntry(LanguageList, ListEntry);
2267 break;
2268 }
2269 }
2270
2271 /* Search for default layout */
2272 for (ListEntry = GetFirstListEntry(LayoutList); ListEntry;
2273 ListEntry = GetNextListEntry(ListEntry))
2274 {
2275 PCWSTR pszLayoutId = ((PGENENTRY)GetListEntryData(ListEntry))->Id;
2276 if (!wcsicmp(pSetupData->DefaultKBLayout, pszLayoutId))
2277 {
2278 DPRINT("Found %S in LayoutList\n", pszLayoutId);
2279 SetCurrentListEntry(LayoutList, ListEntry);
2280 break;
2281 }
2282 }
2283 }
2284
2285 return TRUE;
2286}
2287
2288VOID
2289InitNtToWin32PathMappingList(
2290 IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList)
2291{
2292 InitializeListHead(&MappingList->List);
2293 MappingList->MappingsCount = 0;
2294}
2295
2296VOID
2297FreeNtToWin32PathMappingList(
2298 IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList)
2299{
2300 PLIST_ENTRY ListEntry;
2301 PVOID Entry;
2302
2303 while (!IsListEmpty(&MappingList->List))
2304 {
2305 ListEntry = RemoveHeadList(&MappingList->List);
2306 Entry = (PVOID)CONTAINING_RECORD(ListEntry, NT_WIN32_PATH_MAPPING, ListEntry);
2307 HeapFree(ProcessHeap, 0, Entry);
2308 }
2309
2310 MappingList->MappingsCount = 0;
2311}
2312
2313/*
2314 * Attempts to convert a pure NT file path into a corresponding Win32 path.
2315 * Adapted from GetInstallSourceWin32() in dll/win32/syssetup/wizard.c
2316 */
2317BOOL
2318ConvertNtPathToWin32Path(
2319 IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList,
2320 OUT PWSTR pwszPath,
2321 IN DWORD cchPathMax,
2322 IN PCWSTR pwszNTPath)
2323{
2324 BOOL FoundDrive = FALSE, RetryOnce = FALSE;
2325 PLIST_ENTRY ListEntry;
2326 PNT_WIN32_PATH_MAPPING Entry;
2327 PCWSTR pwszNtPathToMap = pwszNTPath;
2328 PCWSTR pwszRemaining = NULL;
2329 DWORD cchDrives;
2330 PWCHAR pwszDrive;
2331 WCHAR wszDrives[512];
2332 WCHAR wszNTPath[MAX_PATH];
2333 WCHAR TargetPath[MAX_PATH];
2334
2335 *pwszPath = UNICODE_NULL;
2336
2337 /*
2338 * We find first a mapping inside the MappingList. If one is found, use it
2339 * to build the Win32 path. If there is none, we need to create one by
2340 * checking the Win32 drives (and possibly NT symlinks too).
2341 * In case of success, add the newly found mapping to the list and use it
2342 * to build the Win32 path.
2343 */
2344
2345 for (ListEntry = MappingList->List.Flink;
2346 ListEntry != &MappingList->List;
2347 ListEntry = ListEntry->Flink)
2348 {
2349 Entry = CONTAINING_RECORD(ListEntry, NT_WIN32_PATH_MAPPING, ListEntry);
2350
2351 DPRINT("Testing '%S' --> '%S'\n", Entry->Win32Path, Entry->NtPath);
2352
2353 /* Check whether the queried NT path prefixes the user-provided NT path */
2354 FoundDrive = !_wcsnicmp(pwszNtPathToMap, Entry->NtPath, wcslen(Entry->NtPath));
2355 if (FoundDrive)
2356 {
2357 /* Found it! */
2358
2359 /* Set the pointers and go build the Win32 path */
2360 pwszDrive = Entry->Win32Path;
2361 pwszRemaining = pwszNTPath + wcslen(Entry->NtPath);
2362 goto Quit;
2363 }
2364 }
2365
2366 /*
2367 * No mapping exists for this path yet: try to find one now.
2368 */
2369
2370 /* Retrieve the mounted drives (available drive letters) */
2371 cchDrives = GetLogicalDriveStringsW(_countof(wszDrives) - 1, wszDrives);
2372 if (cchDrives == 0 || cchDrives >= _countof(wszDrives))
2373 {
2374 /* Buffer too small or failure */
2375 DPRINT1("ConvertNtPathToWin32Path: GetLogicalDriveStringsW failed\n");
2376 return FALSE;
2377 }
2378
2379/* We go back there once if RetryOnce == TRUE */
2380Retry:
2381
2382 /* Enumerate the mounted drives */
2383 for (pwszDrive = wszDrives; *pwszDrive; pwszDrive += wcslen(pwszDrive) + 1)
2384 {
2385 /* Retrieve the NT path corresponding to the current Win32 DOS path */
2386 pwszDrive[2] = UNICODE_NULL; // Temporarily remove the backslash
2387 QueryDosDeviceW(pwszDrive, wszNTPath, _countof(wszNTPath));
2388 pwszDrive[2] = L'\\'; // Restore the backslash
2389
2390 DPRINT("Testing '%S' --> '%S'\n", pwszDrive, wszNTPath);
2391
2392 /* Check whether the queried NT path prefixes the user-provided NT path */
2393 FoundDrive = !_wcsnicmp(pwszNtPathToMap, wszNTPath, wcslen(wszNTPath));
2394 if (!FoundDrive)
2395 {
2396 PWCHAR ptr, ptr2;
2397
2398 /*
2399 * Check whether this was a network share that has a drive letter,
2400 * but the user-provided NT path points to this share without
2401 * mentioning the drive letter.
2402 *
2403 * The format is: \Device<network_redirector>\;X:<data>\share\path
2404 * The corresponding drive letter is 'X'.
2405 * A system-provided network redirector (LanManRedirector or Mup)
2406 * or a 3rd-party one may be used.
2407 *
2408 * We check whether the user-provided NT path has the form:
2409 * \Device<network_redirector><data>\share\path
2410 * as it obviously did not have the full form (the previous check
2411 * would have been OK otherwise).
2412 */
2413 if (!_wcsnicmp(wszNTPath, L"\\Device\\", _countof(L"\\Device\\")-1) &&
2414 (ptr = wcschr(wszNTPath + _countof(L"\\Device\\")-1, L'\\')) &&
2415 wcslen(++ptr) >= 3 && ptr[0] == L';' && ptr[2] == L':')
2416 {
2417 /*
2418 * Normally the specified drive letter should correspond
2419 * to the one used for the mapping. But we will ignore
2420 * if it happens not to be the case.
2421 */
2422 if (pwszDrive[0] != ptr[1])
2423 {
2424 DPRINT1("Peculiar: expected network share drive letter %C different from actual one %C\n",
2425 pwszDrive[0], ptr[1]);
2426 }
2427
2428 /* Remove the drive letter from the NT network share path */
2429 ptr2 = ptr + 3;
2430 /* Swallow as many possible consecutive backslashes as there could be */
2431 while (*ptr2 == L'\\') ++ptr2;
2432
2433 memmove(ptr, ptr2, (wcslen(ptr2) + 1) * sizeof(WCHAR));
2434
2435 /* Now do the check again */
2436 FoundDrive = !_wcsnicmp(pwszNtPathToMap, wszNTPath, wcslen(wszNTPath));
2437 }
2438 }
2439 if (FoundDrive)
2440 {
2441 /* Found it! */
2442
2443 pwszDrive[2] = UNICODE_NULL; // Remove the backslash
2444
2445 if (pwszNtPathToMap == pwszNTPath)
2446 {
2447 ASSERT(!RetryOnce && pwszNTPath != TargetPath);
2448 pwszRemaining = pwszNTPath + wcslen(wszNTPath);
2449 }
2450 break;
2451 }
2452 }
2453
2454 if (FoundDrive)
2455 {
2456 /* A mapping was found, add it to the cache */
2457 Entry = HeapAlloc(ProcessHeap, HEAP_ZERO_MEMORY, sizeof(*Entry));
2458 if (!Entry)
2459 {
2460 DPRINT1("ConvertNtPathToWin32Path: Cannot allocate memory\n");
2461 return FALSE;
2462 }
2463 StringCchCopyNW(Entry->NtPath, _countof(Entry->NtPath),
2464 pwszNTPath, pwszRemaining - pwszNTPath);
2465 StringCchCopyW(Entry->Win32Path, _countof(Entry->Win32Path), pwszDrive);
2466
2467 /* Insert it as the most recent entry */
2468 InsertHeadList(&MappingList->List, &Entry->ListEntry);
2469 MappingList->MappingsCount++;
2470
2471 /* Set the pointers and go build the Win32 path */
2472 pwszDrive = Entry->Win32Path;
2473 goto Quit;
2474 }
2475
2476 /*
2477 * We failed, perhaps because the beginning of the NT path used a symlink.
2478 * Try to see whether this is the case by attempting to resolve it.
2479 * If the symlink resolution gives nothing, or we already failed once,
2480 * there is no hope in converting the path to Win32.
2481 * Otherwise, symlink resolution succeeds but we need to recheck again
2482 * the drives list.
2483 */
2484
2485 /*
2486 * In theory we would have to parse each element in the NT path and going
2487 * until finding a symlink object (otherwise we would fail straight away).
2488 * However here we can use guessing instead, since we know which kind of
2489 * NT paths we are likely to manipulate: \Device\HarddiskX\PartitionY\ and
2490 * the like (including \Device\HarddiskVolumeX\‍) and the other ones that
2491 * are supported in setuplib\utils\arcname.c .
2492 *
2493 * But actually, all the supported names in arcname.c are real devices,
2494 * and only \Device\HarddiskX\PartitionY\ may refer to a symlink, so we
2495 * just check for it.
2496 */
2497 if (!RetryOnce && !FoundDrive)
2498 {
2499 ULONG DiskNumber, PartitionNumber;
2500 INT Length;
2501
2502 NTSTATUS Status;
2503 OBJECT_ATTRIBUTES ObjectAttributes;
2504 HANDLE LinkHandle;
2505 UNICODE_STRING SymLink, Target;
2506
2507 if (swscanf(pwszNTPath, L"\\Device\\Harddisk%lu\\Partition%lu%n",
2508 &DiskNumber, &PartitionNumber, &Length) != 2)
2509 {
2510 /* Definitively not a recognized path, bail out */
2511 return FALSE;
2512 }
2513
2514 /* Check whether \Device\HarddiskX\PartitionY is a symlink */
2515 RtlInitEmptyUnicodeString(&SymLink, (PWCHAR)pwszNTPath, Length * sizeof(WCHAR));
2516 SymLink.Length = SymLink.MaximumLength;
2517
2518 InitializeObjectAttributes(&ObjectAttributes,
2519 &SymLink,
2520 OBJ_CASE_INSENSITIVE,
2521 NULL,
2522 NULL);
2523 Status = NtOpenSymbolicLinkObject(&LinkHandle,
2524 SYMBOLIC_LINK_QUERY,
2525 &ObjectAttributes);
2526 if (!NT_SUCCESS(Status))
2527 {
2528 /* Not a symlink, or something else happened: bail out */
2529 DPRINT1("ConvertNtPathToWin32Path: NtOpenSymbolicLinkObject(%wZ) failed, Status 0x%08lx\n",
2530 &SymLink, Status);
2531 return FALSE;
2532 }
2533
2534 *TargetPath = UNICODE_NULL;
2535 RtlInitEmptyUnicodeString(&Target, TargetPath, sizeof(TargetPath));
2536
2537 /* Resolve the link and close its handle */
2538 Status = NtQuerySymbolicLinkObject(LinkHandle, &Target, NULL);
2539 NtClose(LinkHandle);
2540
2541 /* Check for success */
2542 if (!NT_SUCCESS(Status))
2543 {
2544 /* Not a symlink, or something else happened: bail out */
2545 DPRINT1("ConvertNtPathToWin32Path: NtQuerySymbolicLinkObject(%wZ) failed, Status 0x%08lx\n",
2546 &SymLink, Status);
2547 return FALSE;
2548 }
2549
2550 /* Set the pointers */
2551 pwszRemaining = pwszNTPath + Length;
2552 pwszNtPathToMap = TargetPath; // Point to our local buffer
2553
2554 /* Retry once */
2555 RetryOnce = TRUE;
2556 goto Retry;
2557 }
2558
2559 ASSERT(!FoundDrive);
2560
2561Quit:
2562 if (FoundDrive)
2563 {
2564 StringCchPrintfW(pwszPath, cchPathMax,
2565 L"%s%s",
2566 pwszDrive,
2567 pwszRemaining);
2568 DPRINT("ConvertNtPathToWin32Path: %S\n", pwszPath);
2569 return TRUE;
2570 }
2571
2572 return FALSE;
2573}
2574
2575/* Used to enable and disable the shutdown privilege */
2576/* static */ BOOL
2577EnablePrivilege(
2578 IN LPCWSTR lpszPrivilegeName,
2579 IN BOOL bEnablePrivilege)
2580{
2581 BOOL Success;
2582 HANDLE hToken;
2583 TOKEN_PRIVILEGES tp;
2584
2585 Success = OpenProcessToken(GetCurrentProcess(),
2586 TOKEN_ADJUST_PRIVILEGES,
2587 &hToken);
2588 if (!Success) return Success;
2589
2590 Success = LookupPrivilegeValueW(NULL,
2591 lpszPrivilegeName,
2592 &tp.Privileges[0].Luid);
2593 if (!Success) goto Quit;
2594
2595 tp.PrivilegeCount = 1;
2596 tp.Privileges[0].Attributes = (bEnablePrivilege ? SE_PRIVILEGE_ENABLED : 0);
2597
2598 Success = AdjustTokenPrivileges(hToken, FALSE, &tp, 0, NULL, NULL);
2599
2600Quit:
2601 CloseHandle(hToken);
2602 return Success;
2603}
2604
2605/* Copied from HotkeyThread() in dll/win32/syssetup/install.c */
2606static DWORD CALLBACK
2607HotkeyThread(LPVOID Parameter)
2608{
2609 ATOM hotkey;
2610 MSG msg;
2611
2612 DPRINT("HotkeyThread start\n");
2613
2614 hotkey = GlobalAddAtomW(L"Setup Shift+F10 Hotkey");
2615
2616 if (!RegisterHotKey(NULL, hotkey, MOD_SHIFT, VK_F10))
2617 DPRINT1("RegisterHotKey failed with %lu\n", GetLastError());
2618
2619 while (GetMessageW(&msg, NULL, 0, 0))
2620 {
2621 if (msg.hwnd == NULL && msg.message == WM_HOTKEY && msg.wParam == hotkey)
2622 {
2623 STARTUPINFOW si = { sizeof(si) };
2624 PROCESS_INFORMATION pi;
2625
2626 if (CreateProcessW(L"cmd.exe",
2627 NULL,
2628 NULL,
2629 NULL,
2630 FALSE,
2631 CREATE_NEW_CONSOLE,
2632 NULL,
2633 NULL,
2634 &si,
2635 &pi))
2636 {
2637 CloseHandle(pi.hProcess);
2638 CloseHandle(pi.hThread);
2639 }
2640 else
2641 {
2642 DPRINT1("Failed to launch command prompt: %lu\n", GetLastError());
2643 }
2644 }
2645 }
2646
2647 UnregisterHotKey(NULL, hotkey);
2648 GlobalDeleteAtom(hotkey);
2649
2650 DPRINT("HotkeyThread terminate\n");
2651 return 0;
2652}
2653
2654int WINAPI
2655_tWinMain(HINSTANCE hInst,
2656 HINSTANCE hPrevInstance,
2657 LPTSTR lpszCmdLine,
2658 int nCmdShow)
2659{
2660 ULONG Error;
2661 HANDLE hHotkeyThread;
2662 INITCOMMONCONTROLSEX iccx;
2663 PROPSHEETHEADER psh;
2664 HPROPSHEETPAGE ahpsp[8];
2665 PROPSHEETPAGE psp = {0};
2666 UINT nPages = 0;
2667
2668 ProcessHeap = GetProcessHeap();
2669
2670 SetupData.hInstance = hInst;
2671 SetupData.hInstallThread = NULL;
2672 SetupData.hHaltInstallEvent = NULL;
2673 SetupData.bStopInstall = FALSE;
2674
2675 /* Initialize the NT to Win32 path prefix mapping list */
2676 InitNtToWin32PathMappingList(&SetupData.MappingList);
2677
2678 /* Initialize Setup, phase 0 */
2679 InitializeSetup(&SetupData.USetupData, 0);
2680
2681 /* Initialize Setup, phase 1 */
2682 Error = InitializeSetup(&SetupData.USetupData, 1);
2683 if (Error != ERROR_SUCCESS)
2684 {
2685 //
2686 // TODO: Write an error mapper (much like the MUIDisplayError of USETUP)
2687 //
2688 if (Error == ERROR_NO_SOURCE_DRIVE)
2689 MessageBoxW(NULL, L"GetSourcePaths failed!", L"Error", MB_ICONERROR);
2690 else if (Error == ERROR_LOAD_TXTSETUPSIF)
2691 DisplayError(NULL, IDS_CAPTION, IDS_NO_TXTSETUP_SIF);
2692 else // FIXME!!
2693 MessageBoxW(NULL, L"Unknown error!", L"Error", MB_ICONERROR);
2694
2695 goto Quit;
2696 }
2697
2698 /* Retrieve any supplemental options from the unattend file */
2699 CheckUnattendedSetup(&SetupData.USetupData);
2700 SetupData.bUnattend = IsUnattendedSetup; // FIXME :-)
2701
2702 /* Load extra setup data (HW lists etc...) */
2703 if (!LoadSetupData(&SetupData))
2704 goto Quit;
2705
2706 hHotkeyThread = CreateThread(NULL, 0, HotkeyThread, NULL, 0, NULL);
2707
2708 /* Whenever any of the common controls are used in your app,
2709 * you must call InitCommonControlsEx() to register the classes
2710 * for those controls. */
2711 iccx.dwSize = sizeof(iccx);
2712 iccx.dwICC = ICC_LISTVIEW_CLASSES | ICC_TREEVIEW_CLASSES | ICC_PROGRESS_CLASS;
2713 InitCommonControlsEx(&iccx);
2714
2715 /* Register the TreeList control */
2716 // RegisterTreeListClass(hInst);
2717 TreeListRegister(hInst);
2718
2719 /* Create title font */
2720 SetupData.hTitleFont = CreateTitleFont();
2721
2722 if (!SetupData.bUnattend)
2723 {
2724 /* Create the Start page, until setup is working */
2725 // NOTE: What does "until setup is working" mean??
2726 psp.dwSize = sizeof(PROPSHEETPAGE);
2727 psp.dwFlags = PSP_DEFAULT | PSP_HIDEHEADER;
2728 psp.hInstance = hInst;
2729 psp.lParam = (LPARAM)&SetupData;
2730 psp.pfnDlgProc = StartDlgProc;
2731 psp.pszTemplate = MAKEINTRESOURCEW(IDD_STARTPAGE);
2732 ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2733
2734 /* Create the install type selection page */
2735 psp.dwSize = sizeof(PROPSHEETPAGE);
2736 psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
2737 psp.pszHeaderTitle = MAKEINTRESOURCEW(IDS_TYPETITLE);
2738 psp.pszHeaderSubTitle = MAKEINTRESOURCEW(IDS_TYPESUBTITLE);
2739 psp.hInstance = hInst;
2740 psp.lParam = (LPARAM)&SetupData;
2741 psp.pfnDlgProc = TypeDlgProc;
2742 psp.pszTemplate = MAKEINTRESOURCEW(IDD_TYPEPAGE);
2743 ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2744
2745 /* Create the upgrade/repair selection page */
2746 psp.dwSize = sizeof(PROPSHEETPAGE);
2747 psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
2748 psp.pszHeaderTitle = MAKEINTRESOURCEW(IDS_TYPETITLE);
2749 psp.pszHeaderSubTitle = MAKEINTRESOURCEW(IDS_TYPESUBTITLE);
2750 psp.hInstance = hInst;
2751 psp.lParam = (LPARAM)&SetupData;
2752 psp.pfnDlgProc = UpgradeRepairDlgProc;
2753 psp.pszTemplate = MAKEINTRESOURCEW(IDD_UPDATEREPAIRPAGE);
2754 ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2755
2756 /* Create the device settings page */
2757 psp.dwSize = sizeof(PROPSHEETPAGE);
2758 psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
2759 psp.pszHeaderTitle = MAKEINTRESOURCEW(IDS_DEVICETITLE);
2760 psp.pszHeaderSubTitle = MAKEINTRESOURCEW(IDS_DEVICESUBTITLE);
2761 psp.hInstance = hInst;
2762 psp.lParam = (LPARAM)&SetupData;
2763 psp.pfnDlgProc = DeviceDlgProc;
2764 psp.pszTemplate = MAKEINTRESOURCEW(IDD_DEVICEPAGE);
2765 ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2766
2767 /* Create the install device settings page / boot method / install directory */
2768 psp.dwSize = sizeof(PROPSHEETPAGE);
2769 psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
2770 psp.pszHeaderTitle = MAKEINTRESOURCEW(IDS_DRIVETITLE);
2771 psp.pszHeaderSubTitle = MAKEINTRESOURCEW(IDS_DRIVESUBTITLE);
2772 psp.hInstance = hInst;
2773 psp.lParam = (LPARAM)&SetupData;
2774 psp.pfnDlgProc = DriveDlgProc;
2775 psp.pszTemplate = MAKEINTRESOURCEW(IDD_DRIVEPAGE);
2776 ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2777
2778 /* Create the summary page */
2779 psp.dwSize = sizeof(PROPSHEETPAGE);
2780 psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
2781 psp.pszHeaderTitle = MAKEINTRESOURCEW(IDS_SUMMARYTITLE);
2782 psp.pszHeaderSubTitle = MAKEINTRESOURCEW(IDS_SUMMARYSUBTITLE);
2783 psp.hInstance = hInst;
2784 psp.lParam = (LPARAM)&SetupData;
2785 psp.pfnDlgProc = SummaryDlgProc;
2786 psp.pszTemplate = MAKEINTRESOURCEW(IDD_SUMMARYPAGE);
2787 ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2788 }
2789
2790 /* Create the installation progress page */
2791 psp.dwSize = sizeof(PROPSHEETPAGE);
2792 psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
2793 psp.pszHeaderTitle = MAKEINTRESOURCEW(IDS_PROCESSTITLE);
2794 psp.pszHeaderSubTitle = MAKEINTRESOURCEW(IDS_PROCESSSUBTITLE);
2795 psp.hInstance = hInst;
2796 psp.lParam = (LPARAM)&SetupData;
2797 psp.pfnDlgProc = ProcessDlgProc;
2798 psp.pszTemplate = MAKEINTRESOURCEW(IDD_PROCESSPAGE);
2799 ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2800
2801 /* Create the finish-and-reboot page */
2802 psp.dwSize = sizeof(PROPSHEETPAGE);
2803 psp.dwFlags = PSP_DEFAULT | PSP_HIDEHEADER;
2804 psp.hInstance = hInst;
2805 psp.lParam = (LPARAM)&SetupData;
2806 psp.pfnDlgProc = RestartDlgProc;
2807 psp.pszTemplate = MAKEINTRESOURCEW(IDD_RESTARTPAGE);
2808 ahpsp[nPages++] = CreatePropertySheetPage(&psp);
2809
2810 /* Create the property sheet */
2811 psh.dwSize = sizeof(PROPSHEETHEADER);
2812 psh.dwFlags = PSH_WIZARD97 | PSH_WATERMARK | PSH_HEADER;
2813 psh.hInstance = hInst;
2814 psh.hwndParent = NULL;
2815 psh.nPages = nPages;
2816 psh.nStartPage = 0;
2817 psh.phpage = ahpsp;
2818 psh.pszbmWatermark = MAKEINTRESOURCEW(IDB_WATERMARK);
2819 psh.pszbmHeader = MAKEINTRESOURCEW(IDB_HEADER);
2820
2821 /* Display the wizard */
2822 PropertySheet(&psh);
2823
2824 /* Wait for any pending installation */
2825 WaitForSingleObject(SetupData.hInstallThread, INFINITE);
2826 CloseHandle(SetupData.hInstallThread);
2827 SetupData.hInstallThread = NULL;
2828 CloseHandle(SetupData.hHaltInstallEvent);
2829 SetupData.hHaltInstallEvent = NULL;
2830
2831 if (SetupData.hTitleFont)
2832 DeleteObject(SetupData.hTitleFont);
2833
2834 /* Unregister the TreeList control */
2835 // UnregisterTreeListClass(hInst);
2836 TreeListUnregister(hInst);
2837
2838 if (hHotkeyThread)
2839 {
2840 PostThreadMessageW(GetThreadId(hHotkeyThread), WM_QUIT, 0, 0);
2841 CloseHandle(hHotkeyThread);
2842 }
2843
2844Quit:
2845 /* Setup has finished */
2846 FinishSetup(&SetupData.USetupData);
2847
2848 /* Free the NT to Win32 path prefix mapping list */
2849 FreeNtToWin32PathMappingList(&SetupData.MappingList);
2850
2851#if 0 // NOTE: Disabled for testing purposes only!
2852 EnablePrivilege(SE_SHUTDOWN_NAME, TRUE);
2853 ExitWindowsEx(EWX_REBOOT, 0);
2854 EnablePrivilege(SE_SHUTDOWN_NAME, FALSE);
2855#endif
2856
2857 return 0;
2858}
2859
2860/* EOF */
Id
DWORD Id
Definition: CLayerUIPropPage.cpp:47
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
hWndList
static HWND hWndList[5+1]
Definition: SetParent.c:10
__cdecl
#define __cdecl
Definition: accygwin.h:79
VOID
#define VOID
Definition: acefi.h:82
va_list
char * va_list
Definition: acmsvcex.h:78
va_end
#define va_end(ap)
Definition: acmsvcex.h:90
va_start
#define va_start(ap, A)
Definition: acmsvcex.h:91
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
hFont
HFONT hFont
Definition: main.c:53
DoFileCopy
BOOLEAN DoFileCopy(IN OUT PUSETUP_DATA pSetupData, IN PSP_FILE_CALLBACK_W MsgHandler, IN PVOID Context OPTIONAL)
Definition: install.c:826
PrepareFileCopy
BOOLEAN PrepareFileCopy(IN OUT PUSETUP_DATA pSetupData, IN PFILE_COPY_STATUS_ROUTINE StatusRoutine OPTIONAL)
Definition: install.c:684
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
SetWindowResPrintfW
VOID __cdecl SetWindowResPrintfW(_In_ HWND hWnd, _In_opt_ HINSTANCE hInstance, _In_ UINT uID,...)
Definition: reactos.c:277
CreateTitleFont
static HFONT CreateTitleFont(VOID)
Definition: reactos.c:84
CenterWindow
static VOID CenterWindow(HWND hWnd)
Definition: reactos.c:61
PropSheet_SetCloseCancel
VOID PropSheet_SetCloseCancel(_In_ HWND hWndWiz, _In_ BOOL Enable)
Enables or disables the Cancel and the Close title-bar property-sheet window buttons.
Definition: reactos.c:1747
ProcessDlgProc
static INT_PTR CALLBACK ProcessDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:1997
FSVOL_CONTEXT
struct _FSVOL_CONTEXT FSVOL_CONTEXT
RegistryStatus
static VOID __cdecl RegistryStatus(IN REGISTRY_STATUS RegStatus,...)
Definition: reactos.c:1711
GetSelectedListViewItem
PVOID GetSelectedListViewItem(IN HWND hWndList)
Definition: reactos.c:614
FsVolCallback
static FSVOL_OP CALLBACK FsVolCallback(_In_opt_ PVOID Context, _In_ FSVOLNOTIFY FormatStatus, _In_ ULONG_PTR Param1, _In_ ULONG_PTR Param2)
Definition: reactos.c:1250
PCOPYCONTEXT
struct _COPYCONTEXT * PCOPYCONTEXT
TypeDlgProc
static INT_PTR CALLBACK TypeDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:347
column_widths
static const INT column_widths[MAX_LIST_COLUMNS]
Definition: reactos.c:706
SystemVolume
#define SystemVolume
Definition: reactos.c:52
RestartDlgProc
static INT_PTR CALLBACK RestartDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:2116
MAX_LIST_COLUMNS
#define MAX_LIST_COLUMNS
Definition: reactos.c:704
InstallVolume
#define InstallVolume
Definition: reactos.c:47
FormatCallback
static BOOLEAN NTAPI FormatCallback(_In_ CALLBACKCOMMAND Command, _In_ ULONG Modifier, _In_ PVOID Argument)
Definition: reactos.c:1184
ConvertNtPathToWin32Path
BOOL ConvertNtPathToWin32Path(IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList, OUT PWSTR pwszPath, IN DWORD cchPathMax, IN PCWSTR pwszNTPath)
Definition: reactos.c:2318
ProcessHeap
HANDLE ProcessHeap
Definition: reactos.c:40
LoadSetupData
BOOL LoadSetupData(IN OUT PSETUPDATA pSetupData)
Definition: reactos.c:2197
UiContext
UI_CONTEXT UiContext
Definition: reactos.c:55
column_alignment
static const INT column_alignment[MAX_LIST_COLUMNS]
Definition: reactos.c:707
UpgradeRepairDlgProc
static INT_PTR CALLBACK UpgradeRepairDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:710
InstallPartition
PPARTENTRY InstallPartition
Definition: reactos.c:45
GetSelectedComboListItem
PVOID GetSelectedComboListItem(IN HWND hWndList)
Definition: reactos.c:556
InitGenericListView
VOID InitGenericListView(IN HWND hWndList, IN PGENERIC_LIST List, IN PADD_ENTRY_ITEM AddEntryItemProc)
Definition: reactos.c:577
DisplayError
INT __cdecl DisplayError(_In_opt_ HWND hWnd, _In_ UINT uIDTitle, _In_ UINT uIDMessage,...)
Definition: reactos.c:230
SetWindowResPrintfVW
VOID SetWindowResPrintfVW(_In_ HWND hWnd, _In_opt_ HINSTANCE hInstance, _In_ UINT uID, _In_ va_list args)
Definition: reactos.c:261
PFSVOL_CONTEXT
struct _FSVOL_CONTEXT * PFSVOL_CONTEXT
FreeNtToWin32PathMappingList
VOID FreeNtToWin32PathMappingList(IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList)
Definition: reactos.c:2297
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:479
GetSettingDescription
static VOID NTAPI GetSettingDescription(IN PGENERIC_LIST_ENTRY Entry, OUT PWSTR Buffer, IN SIZE_T cchBufferSize)
Definition: reactos.c:634
IDS_LIST_COLUMN_FIRST
#define IDS_LIST_COLUMN_FIRST
Definition: reactos.c:701
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:569
DeviceDlgProc
static INT_PTR CALLBACK DeviceDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:896
SummaryDlgProc
static INT_PTR CALLBACK SummaryDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:999
DisplayMessage
INT __cdecl DisplayMessage(_In_opt_ HWND hWnd, _In_ UINT uType, _In_opt_ PCWSTR pszTitle, _In_opt_ PCWSTR pszFormatMessage,...)
Definition: reactos.c:211
InitNtToWin32PathMappingList
VOID InitNtToWin32PathMappingList(IN OUT PNT_WIN32_PATH_MAPPING_LIST MappingList)
Definition: reactos.c:2289
PGET_ENTRY_DESCRIPTION
VOID(NTAPI * PGET_ENTRY_DESCRIPTION)(IN PGENERIC_LIST_ENTRY Entry, OUT PWSTR Buffer, IN SIZE_T cchBufferSize)
Definition: reactos.c:512
SystemPartition
PPARTENTRY SystemPartition
Definition: reactos.c:50
SetWindowResTextW
VOID SetWindowResTextW(_In_ HWND hWnd, _In_opt_ HINSTANCE hInstance, _In_ UINT uID)
Definition: reactos.c:250
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:645
IsUnattendedSetup
BOOLEAN IsUnattendedSetup
Definition: reactos.c:41
StartDlgProc
static INT_PTR CALLBACK StartDlgProc(IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: reactos.c:291
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:109
SetupData
SETUPDATA SetupData
Definition: reactos.c:42
COPYCONTEXT
struct _COPYCONTEXT COPYCONTEXT
HotkeyThread
static DWORD CALLBACK HotkeyThread(LPVOID Parameter)
Definition: reactos.c:2607
EnablePrivilege
BOOL EnablePrivilege(IN LPCWSTR lpszPrivilegeName, IN BOOL bEnablePrivilege)
Definition: reactos.c:2577
column_ids
static const UINT column_ids[MAX_LIST_COLUMNS]
Definition: reactos.c:705
InitGenericComboList
VOID InitGenericComboList(IN HWND hWndList, IN PGENERIC_LIST List, IN PGET_ENTRY_DESCRIPTION GetEntryDescriptionProc)
Definition: reactos.c:518
PrepareAndDoCopyThread
static DWORD WINAPI PrepareAndDoCopyThread(IN LPVOID Param)
Definition: reactos.c:1760
FileCopyCallback
static UINT CALLBACK FileCopyCallback(PVOID Context, UINT Notification, UINT_PTR Param1, UINT_PTR Param2)
Definition: reactos.c:1594
ShowDlgItem
#define ShowDlgItem(hDlg, nID, nCmdShow)
Definition: reactos.h:51
ID_WIZNEXT
#define ID_WIZNEXT
Definition: reactos.h:59
PSETUPDATA
struct _SETUPDATA * PSETUPDATA
IDS_ERROR_SYSTEM_PARTITION
#define IDS_ERROR_SYSTEM_PARTITION
Definition: resource.h:165
IDC_KEYBOARD
#define IDC_KEYBOARD
Definition: resource.h:34
IDS_TYPETITLE
#define IDS_TYPETITLE
Definition: resource.h:83
IDD_DRIVEPAGE
#define IDD_DRIVEPAGE
Definition: resource.h:37
IDS_ERROR_FORMAT_UNRECOGNIZED_VOLUME
#define IDS_ERROR_FORMAT_UNRECOGNIZED_VOLUME
Definition: resource.h:168
IDS_DRIVESUBTITLE
#define IDS_DRIVESUBTITLE
Definition: resource.h:88
IDS_PROCESSSUBTITLE
#define IDS_PROCESSSUBTITLE
Definition: resource.h:90
IDS_TYPESUBTITLE
#define IDS_TYPESUBTITLE
Definition: resource.h:84
IDC_COMPUTER
#define IDC_COMPUTER
Definition: resource.h:32
IDI_WINICON
#define IDI_WINICON
Definition: resource.h:10
IDS_ERROR_COULD_NOT_CHECK
#define IDS_ERROR_COULD_NOT_CHECK
Definition: resource.h:177
IDS_PROCESSTITLE
#define IDS_PROCESSTITLE
Definition: resource.h:89
IDC_UPDATE
#define IDC_UPDATE
Definition: resource.h:24
IDS_REG_REGHIVEUPDATE
#define IDS_REG_REGHIVEUPDATE
Definition: resource.h:134
IDD_RESTARTPAGE
#define IDD_RESTARTPAGE
Definition: resource.h:62
IDI_ROSICON
#define IDI_ROSICON
Definition: resource.h:9
IDS_REG_CODEPAGEINFOUPDATE
#define IDS_REG_CODEPAGEINFOUPDATE
Definition: resource.h:140
IDC_UPDATETEXT
#define IDC_UPDATETEXT
Definition: resource.h:25
IDS_REG_DONE
#define IDS_REG_DONE
Definition: resource.h:133
IDS_REG_IMPORTFILE
#define IDS_REG_IMPORTFILE
Definition: resource.h:135
IDS_ERROR_CHECKING_PARTITION
#define IDS_ERROR_CHECKING_PARTITION
Definition: resource.h:180
IDS_REG_UNKNOWN
#define IDS_REG_UNKNOWN
Definition: resource.h:141
IDS_ERROR_COULD_NOT_FORMAT
#define IDS_ERROR_COULD_NOT_FORMAT
Definition: resource.h:171
IDS_REG_KEYBOARDSETTINGSUPDATE
#define IDS_REG_KEYBOARDSETTINGSUPDATE
Definition: resource.h:139
IDS_CAPTION
#define IDS_CAPTION
Definition: resource.h:98
IDC_PROCESSPROGRESS
#define IDC_PROCESSPROGRESS
Definition: resource.h:60
IDS_DEVICETITLE
#define IDS_DEVICETITLE
Definition: resource.h:85
IDD_SUMMARYPAGE
#define IDD_SUMMARYPAGE
Definition: resource.h:46
IDS_DRIVETITLE
#define IDS_DRIVETITLE
Definition: resource.h:87
IDC_FINISHTITLE
#define IDC_FINISHTITLE
Definition: resource.h:63
IDC_CONFIRM_INSTALL
#define IDC_CONFIRM_INSTALL
Definition: resource.h:55
IDC_SKIPUPGRADE
#define IDC_SKIPUPGRADE
Definition: resource.h:29
IDS_REG_ADDKBLAYOUTS
#define IDS_REG_ADDKBLAYOUTS
Definition: resource.h:138
IDS_UPDATE_REGISTRY
#define IDS_UPDATE_REGISTRY
Definition: resource.h:131
IDB_WATERMARK
#define IDB_WATERMARK
Definition: resource.h:4
IDC_ARCHITECTURE
#define IDC_ARCHITECTURE
Definition: resource.h:49
IDC_PATH
#define IDC_PATH
Definition: resource.h:67
IDC_NTOSLIST
#define IDC_NTOSLIST
Definition: resource.h:28
IDD_PROCESSPAGE
#define IDD_PROCESSPAGE
Definition: resource.h:57
IDS_NO_TXTSETUP_SIF
#define IDS_NO_TXTSETUP_SIF
Definition: resource.h:97
IDC_ACTIVITY
#define IDC_ACTIVITY
Definition: resource.h:58
IDS_REG_LOCALESETTINGSUPDATE
#define IDS_REG_LOCALESETTINGSUPDATE
Definition: resource.h:137
IDD_UPDATEREPAIRPAGE
#define IDD_UPDATEREPAIRPAGE
Definition: resource.h:27
IDC_ITEM
#define IDC_ITEM
Definition: resource.h:59
IDS_SUMMARYTITLE
#define IDS_SUMMARYTITLE
Definition: resource.h:95
IDS_DEVICESUBTITLE
#define IDS_DEVICESUBTITLE
Definition: resource.h:86
IDS_SUMMARYSUBTITLE
#define IDS_SUMMARYSUBTITLE
Definition: resource.h:96
IDS_ABORTSETUP2
#define IDS_ABORTSETUP2
Definition: resource.h:94
IDS_REG_DISPLAYSETTINGSUPDATE
#define IDS_REG_DISPLAYSETTINGSUPDATE
Definition: resource.h:136
IDC_DESTDRIVE
#define IDC_DESTDRIVE
Definition: resource.h:53
IDD_TYPEPAGE
#define IDD_TYPEPAGE
Definition: resource.h:21
IDC_INSTALLTYPE
#define IDC_INSTALLTYPE
Definition: resource.h:47
IDC_STARTTITLE
#define IDC_STARTTITLE
Definition: resource.h:19
IDS_CREATE_REGISTRY
#define IDS_CREATE_REGISTRY
Definition: resource.h:130
IDC_INSTALLSOURCE
#define IDC_INSTALLSOURCE
Definition: resource.h:48
IDC_RESTART_PROGRESS
#define IDC_RESTART_PROGRESS
Definition: resource.h:64
IDD_DEVICEPAGE
#define IDD_DEVICEPAGE
Definition: resource.h:31
IDS_ABORTSETUP
#define IDS_ABORTSETUP
Definition: resource.h:93
IDS_ERROR_WRITE_PTABLE
#define IDS_ERROR_WRITE_PTABLE
Definition: resource.h:161
IDD_STARTPAGE
#define IDD_STARTPAGE
Definition: resource.h:18
IDS_ERROR_FORMATTING_PARTITION
#define IDS_ERROR_FORMATTING_PARTITION
Definition: resource.h:174
Error
BOOL Error
Definition: chkdsk.c:66
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:900
ObjectAttributes
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
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
ImageList_Destroy
BOOL WINAPI ImageList_Destroy(HIMAGELIST himl)
Definition: imagelist.c:928
ImageList_Create
HIMAGELIST WINAPI ImageList_Create(INT cx, INT cy, UINT flags, INT cInitial, INT cGrow)
Definition: imagelist.c:804
CloseHandle
#define CloseHandle
Definition: compat.h:739
wcschr
#define wcschr
Definition: compat.h:17
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
wcsrchr
#define wcsrchr
Definition: compat.h:16
HWND
HANDLE HWND
Definition: compat.h:19
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
GetCurrentProcess
#define GetCurrentProcess()
Definition: compat.h:759
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
wcsicmp
#define wcsicmp
Definition: compat.h:15
GlobalDeleteAtom
ATOM WINAPI GlobalDeleteAtom(ATOM nAtom)
Definition: atom.c:454
GlobalAddAtomW
ATOM WINAPI GlobalAddAtomW(LPCWSTR lpString)
Definition: atom.c:444
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
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:4592
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:1210
FindVolCreateInTreeByVolume
PVOL_CREATE_INFO FindVolCreateInTreeByVolume(_In_ HWND hTreeList, _In_ PVOLENTRY Volume)
Definition: drivepage.c:852
DriveDlgProc
INT_PTR CALLBACK DriveDlgProc(_In_ HWND hwndDlg, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam)
Definition: drivepage.c:1634
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
PtrToUlong
#define PtrToUlong(u)
Definition: config.h:107
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_LOAD_TXTSETUPSIF
@ ERROR_LOAD_TXTSETUPSIF
Definition: errorcode.h:24
ERROR_NO_SOURCE_DRIVE
@ ERROR_NO_SOURCE_DRIVE
Definition: errorcode.h:23
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:67
OUTPUT
@ OUTPUT
Definition: fmifs.h:82
PROGRESS
@ PROGRESS
Definition: fmifs.h:68
IDC_INSTALL
#define IDC_INSTALL
Definition: fontview.h:13
DeleteObject
pKey DeleteObject()
Status
Status
Definition: gdiplustypes.h:25
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
MOD_SHIFT
#define MOD_SHIFT
Definition: imm.h:186
swscanf
_Check_return_ _CRTIMP int __cdecl swscanf(_In_z_ const wchar_t *_Src, _In_z_ _Scanf_format_string_ const wchar_t *_Format,...)
_vscwprintf
_Check_return_ _CRTIMP int __cdecl _vscwprintf(_In_z_ _Printf_format_string_ const wchar_t *_Format, va_list _ArgList)
wcstol
_Check_return_ long __cdecl wcstol(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
_tcscpy
#define _tcscpy
Definition: tchar.h:623
_tWinMain
#define _tWinMain
Definition: tchar.h:498
wcslen
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
OBJ_CASE_INSENSITIVE
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
C_ASSERT
#define C_ASSERT(e)
Definition: intsafe.h:73
LANGID
USHORT LANGID
Definition: mui.h:9
SetCurrentListEntry
VOID SetCurrentListEntry(IN PGENERIC_LIST List, IN PGENERIC_LIST_ENTRY Entry)
Definition: genlist.c:87
GetFirstListEntry
PGENERIC_LIST_ENTRY GetFirstListEntry(IN PGENERIC_LIST List)
Definition: genlist.c:104
GetCurrentListEntry
PGENERIC_LIST_ENTRY GetCurrentListEntry(IN PGENERIC_LIST List)
Definition: genlist.c:97
GetNumberOfListEntries
ULONG GetNumberOfListEntries(IN PGENERIC_LIST List)
Definition: genlist.c:140
GetListEntryData
PVOID GetListEntryData(IN PGENERIC_LIST_ENTRY Entry)
Definition: genlist.c:126
GetNextListEntry
PGENERIC_LIST_ENTRY GetNextListEntry(IN PGENERIC_LIST_ENTRY Entry)
Definition: genlist.c:114
hList
HWND hList
Definition: livecd.c:10
memmove
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
ASSERT
#define ASSERT(a)
Definition: mode.c:44
PSN_QUERYINITIALFOCUS
#define PSN_QUERYINITIALFOCUS
Definition: settings.cpp:98
ptr
static PVOID ptr
Definition: dispmode.c:27
hdc
HDC hdc
Definition: main.c:9
HDC
static HDC
Definition: imagelist.c:88
HFONT
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
InitializeObjectAttributes
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
pi
static refpint_t pi[]
Definition: server.c:96
item
static ATOM item
Definition: dde.c:856
_In_
#define _In_
Definition: ms_sal.h:308
_In_opt_
#define _In_opt_
Definition: ms_sal.h:309
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
UINT
unsigned int UINT
Definition: ndis.h:50
SYMBOLIC_LINK_QUERY
#define SYMBOLIC_LINK_QUERY
Definition: nt_native.h:1265
NtClose
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
UNICODE_NULL
#define UNICODE_NULL
DBG_UNREFERENCED_PARAMETER
#define DBG_UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:318
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_NOT_SUPPORTED
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:423
STATUS_PARTITION_FAILURE
#define STATUS_PARTITION_FAILURE
Definition: ntstatus.h:604
L
#define L(x)
Definition: ntvdm.h:50
CreateNTOSInstallationsList
PGENERIC_LIST 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:763
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
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
PropSheet_SetCurSelByID
#define PropSheet_SetCurSelByID(d, i)
Definition: prsht.h:354
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
WM_NOTIFY
#define WM_NOTIFY
Definition: richedit.h:61
DONE
#define DONE
Definition: rnr20lib.h:14
wcscpy
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
_wcsnicmp
_Check_return_ _CRTIMP int __cdecl _wcsnicmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
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
args
#define args
Definition: format.c:66
FsVolCommitOpsQueue
BOOLEAN FsVolCommitOpsQueue(_In_ PPARTLIST PartitionList, _In_ PVOLENTRY SystemVolume, _In_ PVOLENTRY InstallVolume, _In_opt_ PFSVOL_CALLBACK FsVolCallback, _In_opt_ PVOID Context)
Definition: fsutil.c:1087
FSVOLNOTIFY_STARTCHECK
@ FSVOLNOTIFY_STARTCHECK
Definition: fsutil.h:146
FSVOLNOTIFY_ENDQUEUE
@ FSVOLNOTIFY_ENDQUEUE
Definition: fsutil.h:138
FSVOLNOTIFY_STARTSUBQUEUE
@ FSVOLNOTIFY_STARTSUBQUEUE
Definition: fsutil.h:139
FSVOLNOTIFY_ENDFORMAT
@ FSVOLNOTIFY_ENDFORMAT
Definition: fsutil.h:144
FSVOLNOTIFY_STARTFORMAT
@ FSVOLNOTIFY_STARTFORMAT
Definition: fsutil.h:143
FSVOLNOTIFY_STARTQUEUE
@ FSVOLNOTIFY_STARTQUEUE
Definition: fsutil.h:137
FSVOLNOTIFY_ENDSUBQUEUE
@ FSVOLNOTIFY_ENDSUBQUEUE
Definition: fsutil.h:140
FSVOLNOTIFY_PARTITIONERROR
@ FSVOLNOTIFY_PARTITIONERROR
Definition: fsutil.h:142
FSVOLNOTIFY_CHECKERROR
@ FSVOLNOTIFY_CHECKERROR
Definition: fsutil.h:148
ChangeSystemPartition
@ ChangeSystemPartition
Definition: fsutil.h:149
FSVOLNOTIFY_FORMATERROR
@ FSVOLNOTIFY_FORMATERROR
Definition: fsutil.h:145
FSVOLNOTIFY_ENDCHECK
@ FSVOLNOTIFY_ENDCHECK
Definition: fsutil.h:147
FSVOL_OP
enum _FSVOL_OP FSVOL_OP
PFORMAT_VOLUME_INFO
struct _FORMAT_VOLUME_INFO * PFORMAT_VOLUME_INFO
FSVOL_FORMAT
@ FSVOL_FORMAT
Definition: fsutil.h:155
FSVOL_CHECK
@ FSVOL_CHECK
Definition: fsutil.h:156
FSVOL_DOIT
@ FSVOL_DOIT
Definition: fsutil.h:159
FSVOL_ABORT
@ FSVOL_ABORT
Definition: fsutil.h:158
FSVOL_RETRY
@ FSVOL_RETRY
Definition: fsutil.h:160
FSVOL_SKIP
@ FSVOL_SKIP
Definition: fsutil.h:161
FSVOLNOTIFY
enum _FSVOLNOTIFY FSVOLNOTIFY
PCHECK_VOLUME_INFO
struct _CHECK_VOLUME_INFO * PCHECK_VOLUME_INFO
CreatePartitionList
PPARTLIST CreatePartitionList(VOID)
Definition: partlist.c:1925
InitDestinationPaths
NTSTATUS InitDestinationPaths(_Inout_ PUSETUP_DATA pSetupData, _In_ PCWSTR InstallationDir, _In_ PVOLENTRY Volume)
Definition: setuplib.c:797
InitSystemPartition
BOOLEAN 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:614
FinishSetup
VOID FinishSetup(IN OUT PUSETUP_DATA pSetupData)
Definition: setuplib.c:1048
CheckUnattendedSetup
VOID CheckUnattendedSetup(IN OUT PUSETUP_DATA pSetupData)
Definition: setuplib.c:28
UpdateRegistry
ERROR_NUMBER 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:1098
InstallSetupInfFile
VOID InstallSetupInfFile(IN OUT PUSETUP_DATA pSetupData)
Definition: setuplib.c:202
InitializeSetup
ERROR_NUMBER InitializeSetup(IN OUT PUSETUP_DATA pSetupData, IN ULONG InitPhase)
Definition: setuplib.c:952
ERROR_SYSTEM_PARTITION_NOT_FOUND
#define ERROR_SYSTEM_PARTITION_NOT_FOUND
Definition: setuplib.h:181
REGISTRY_STATUS
enum _REGISTRY_STATUS REGISTRY_STATUS
DPRINT
#define DPRINT
Definition: sndvol32.h:73
_countof
#define _countof(array)
Definition: sndvol32.h:70
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
Command
Definition: shell.h:41
Entry
base of all file and directory entries
Definition: entries.h:83
LOGFONTA::lfHeight
LONG lfHeight
Definition: dimm.idl:42
LOGFONTA::lfWeight
LONG lfWeight
Definition: dimm.idl:46
LOGFONTA::lfFaceName
CHAR lfFaceName[LF_FACESIZE]
Definition: dimm.idl:55
MSGBOXPARAMSW::dwLanguageId
DWORD dwLanguageId
Definition: winuser.h:3348
MSGBOXPARAMSW::lpszCaption
LPCWSTR lpszCaption
Definition: winuser.h:3343
MSGBOXPARAMSW::hwndOwner
HWND hwndOwner
Definition: winuser.h:3340
MSGBOXPARAMSW::lpszText
LPCWSTR lpszText
Definition: winuser.h:3342
MSGBOXPARAMSW::hInstance
HINSTANCE hInstance
Definition: winuser.h:3341
MSGBOXPARAMSW::dwStyle
DWORD dwStyle
Definition: winuser.h:3344
TEXTOUTPUT::Output
PCHAR Output
Definition: fmifs.h:33
_CHECK_VOLUME_INFO
Definition: fsutil.h:181
_CHECK_VOLUME_INFO::Verbose
BOOLEAN Verbose
Definition: fsutil.h:188
_CHECK_VOLUME_INFO::ErrorStatus
NTSTATUS ErrorStatus
Definition: fsutil.h:184
_CHECK_VOLUME_INFO::Volume
PVOLENTRY Volume
Definition: fsutil.h:182
_CHECK_VOLUME_INFO::Callback
PFMIFSCALLBACK Callback
Definition: fsutil.h:191
_CHECK_VOLUME_INFO::CheckOnlyIfDirty
BOOLEAN CheckOnlyIfDirty
Definition: fsutil.h:189
_CHECK_VOLUME_INFO::FixErrors
BOOLEAN FixErrors
Definition: fsutil.h:187
_CHECK_VOLUME_INFO::ScanDrive
BOOLEAN ScanDrive
Definition: fsutil.h:190
_COPYCONTEXT
Definition: reactos.c:1586
_COPYCONTEXT::TotalOperations
ULONG TotalOperations
Definition: reactos.c:1588
_COPYCONTEXT::CompletedOperations
ULONG CompletedOperations
Definition: reactos.c:1589
_COPYCONTEXT::pSetupData
PSETUPDATA pSetupData
Definition: reactos.c:1587
_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:165
_FORMAT_VOLUME_INFO::Callback
PFMIFSCALLBACK Callback
Definition: fsutil.h:176
_FORMAT_VOLUME_INFO::QuickFormat
BOOLEAN QuickFormat
Definition: fsutil.h:174
_FORMAT_VOLUME_INFO::ClusterSize
ULONG ClusterSize
Definition: fsutil.h:175
_FORMAT_VOLUME_INFO::ErrorStatus
NTSTATUS ErrorStatus
Definition: fsutil.h:168
_FORMAT_VOLUME_INFO::Volume
PVOLENTRY Volume
Definition: fsutil.h:166
_FORMAT_VOLUME_INFO::MediaFlag
FMIFS_MEDIA_FLAG MediaFlag
Definition: fsutil.h:172
_FORMAT_VOLUME_INFO::FileSystemName
PCWSTR FileSystemName
Definition: fsutil.h:171
_FORMAT_VOLUME_INFO::Label
PCWSTR Label
Definition: fsutil.h:173
_FSVOL_CONTEXT
Definition: reactos.c:1176
_FSVOL_CONTEXT::pSetupData
PSETUPDATA pSetupData
Definition: reactos.c:1177
_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:115
_NT_WIN32_PATH_MAPPING
Definition: reactos.h:107
_OBJECT_ATTRIBUTES
Definition: umtypes.h:182
_PARTENTRY
Definition: partlist.h:62
_PARTENTRY::DiskEntry
struct _DISKENTRY * DiskEntry
Definition: partlist.h:66
_PARTENTRY::OnDiskPartitionNumber
ULONG OnDiskPartitionNumber
Definition: partlist.h:74
_PROCESS_INFORMATION
Definition: winbase.h:872
_SETUPDATA
Definition: reactos.h:131
_SETUPDATA::USetupData
USETUP_DATA USetupData
Definition: reactos.h:144
_SETUPDATA::hInstance
HINSTANCE hInstance
Definition: reactos.h:133
_SETUPDATA::SelectedLanguageId
PCWSTR SelectedLanguageId
Definition: reactos.h:159
_SETUPDATA::hTitleFont
HFONT hTitleFont
Definition: reactos.h:136
_SETUPDATA::bStopInstall
BOOL bStopInstall
Definition: reactos.h:140
_SETUPDATA::hInstallThread
HANDLE hInstallThread
Definition: reactos.h:138
_SETUPDATA::CurrentInstallation
PNTOS_INSTALLATION CurrentInstallation
Definition: reactos.h:149
_SETUPDATA::PartitionList
PPARTLIST PartitionList
Definition: reactos.h:148
_SETUPDATA::hHaltInstallEvent
HANDLE hHaltInstallEvent
Definition: reactos.h:139
_SETUPDATA::NtOsInstallsList
PGENERIC_LIST NtOsInstallsList
Definition: reactos.h:150
_SETUPDATA::MappingList
NT_WIN32_PATH_MAPPING_LIST MappingList
Definition: reactos.h:142
_SETUPDATA::RepairUpdateFlag
BOOLEAN RepairUpdateFlag
Definition: reactos.h:146
_SETUPDATA::bUnattend
BOOL bUnattend
Definition: reactos.h:134
_STARTUPINFOW
Definition: winbase.h:851
_TOKEN_PRIVILEGES
Definition: setypes.h:1022
_UI_CONTEXT
Definition: reactos.h:81
_UI_CONTEXT::hWndItem
HWND hWndItem
Definition: reactos.h:84
_UI_CONTEXT::hPartList
HWND hPartList
Definition: reactos.h:82
_UI_CONTEXT::hWndProgress
HWND hWndProgress
Definition: reactos.h:85
_UI_CONTEXT::dwPbStyle
LONG_PTR dwPbStyle
Definition: reactos.h:86
_UI_CONTEXT::hwndDlg
HWND hwndDlg
Definition: reactos.h:83
_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:130
_USETUP_DATA::DestinationRootPath
UNICODE_STRING DestinationRootPath
Definition: setuplib.h:115
_USETUP_DATA::ComputerList
PGENERIC_LIST ComputerList
Definition: setuplib.h:129
_USETUP_DATA::InstallationDirectory
WCHAR InstallationDirectory[MAX_PATH]
Definition: setuplib.h:148
_USETUP_DATA::KeyboardList
PGENERIC_LIST KeyboardList
Definition: setuplib.h:131
_USETUP_DATA::FormatPartition
LONG FormatPartition
Definition: setuplib.h:124
_VOLENTRY::Info
VOLINFO Info
Definition: partlist.h:47
_VOLINFO
Definition: volutil.h:11
_VOLINFO::DeviceName
WCHAR DeviceName[MAX_PATH]
NT device name: "\Device\HarddiskVolumeN".
Definition: volutil.h:13
_VOLINFO::FileSystem
WCHAR FileSystem[MAX_PATH+1]
Definition: volutil.h:17
_VOLINFO::DriveLetter
WCHAR DriveLetter
Definition: volutil.h:15
_VOL_CREATE_INFO
Data structure stored when a partition/volume needs to be formatted.
Definition: reactos.h:177
_VOL_CREATE_INFO::ClusterSize
ULONG ClusterSize
Definition: reactos.h:189
_VOL_CREATE_INFO::QuickFormat
BOOLEAN QuickFormat
Definition: reactos.h:188
_VOL_CREATE_INFO::Volume
PVOLENTRY Volume
Definition: reactos.h:178
_VOL_CREATE_INFO::FileSystemName
WCHAR FileSystemName[MAX_PATH+1]
Definition: reactos.h:185
_VOL_CREATE_INFO::MediaFlag
FMIFS_MEDIA_FLAG MediaFlag
Definition: reactos.h:186
_VOL_CREATE_INFO::Label
PCWSTR Label
Definition: reactos.h:187
args
Definition: match.c:390
tagNMHDR::idFrom
UINT_PTR idFrom
Definition: winuser.h:3161
tagNMHDR::code
UINT code
Definition: winuser.h:3162
tagNMLISTVIEW::uNewState
UINT uNewState
Definition: commctrl.h:3041
tagRECT::right
LONG right
Definition: windef.h:308
tagRECT::bottom
LONG bottom
Definition: windef.h:309
tagRECT::top
LONG top
Definition: windef.h:307
tagRECT::left
LONG left
Definition: windef.h:306
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:651
SetEvent
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
ResetEvent
BOOL WINAPI DECLSPEC_HOTPATCH ResetEvent(IN HANDLE hEvent)
Definition: synch.c:714
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
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
_T
#define _T(x)
Definition: vfdio.h:22
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
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
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
CREATE_SUSPENDED
#define CREATE_SUSPENDED
Definition: winbase.h:178
CREATE_NEW_CONSOLE
#define CREATE_NEW_CONSOLE
Definition: winbase.h:180
LPARAM
LONG_PTR LPARAM
Definition: windef.h:208
WPARAM
UINT_PTR WPARAM
Definition: windef.h:207
WINAPI
#define WINAPI
Definition: msvc.h:6
ComboBox_GetItemData
#define ComboBox_GetItemData(hwndCtl, index)
Definition: windowsx.h:54
ComboBox_GetCurSel
#define ComboBox_GetCurSel(hwndCtl)
Definition: windowsx.h:49
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:4444
SE_SHUTDOWN_NAME
#define SE_SHUTDOWN_NAME
Definition: winnt_old.h:384
LB_ERR
#define LB_ERR
Definition: winuser.h:2435
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:1969
SW_HIDE
#define SW_HIDE
Definition: winuser.h:771
MF_BYCOMMAND
#define MF_BYCOMMAND
Definition: winuser.h:202
GetWindowLongPtrW
#define GetWindowLongPtrW
Definition: winuser.h:4832
WM_QUIT
#define WM_QUIT
Definition: winuser.h:1626
MAKELPARAM
#define MAKELPARAM(l, h)
Definition: winuser.h:4011
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:834
VK_F10
#define VK_F10
Definition: winuser.h:2267
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)
LoadStringW
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
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:1743
IS_INTRESOURCE
#define IS_INTRESOURCE(i)
Definition: winuser.h:580
CB_ERR
#define CB_ERR
Definition: winuser.h:2438
CB_SETCURSEL
#define CB_SETCURSEL
Definition: winuser.h:1964
SM_CYSMICON
#define SM_CYSMICON
Definition: winuser.h:1016
SetDlgItemTextW
BOOL WINAPI SetDlgItemTextW(_In_ HWND, _In_ int, _In_ LPCWSTR)
SWP_NOSIZE
#define SWP_NOSIZE
Definition: winuser.h:1248
WM_INITDIALOG
#define WM_INITDIALOG
Definition: winuser.h:1742
GetSystemMenu
HMENU WINAPI GetSystemMenu(_In_ HWND, _In_ BOOL)
MB_YESNO
#define MB_YESNO
Definition: winuser.h:820
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:833
SetTimer
UINT_PTR WINAPI SetTimer(_In_opt_ HWND, _In_ UINT_PTR, _In_ UINT, _In_opt_ TIMERPROC)
GetDesktopWindow
HWND WINAPI GetDesktopWindow(void)
Definition: window.c:628
MB_ICONERROR
#define MB_ICONERROR
Definition: winuser.h:790
MB_OKCANCEL
#define MB_OKCANCEL
Definition: winuser.h:807
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:1015
EWX_REBOOT
#define EWX_REBOOT
Definition: winuser.h:638
HWND_TOP
#define HWND_TOP
Definition: winuser.h:1210
RegisterHotKey
BOOL WINAPI RegisterHotKey(_In_opt_ HWND, _In_ int, _In_ UINT, _In_ UINT)
MF_ENABLED
#define MF_ENABLED
Definition: winuser.h:128
PostThreadMessageW
BOOL WINAPI PostThreadMessageW(_In_ DWORD, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
WM_SETFONT
#define WM_SETFONT
Definition: winuser.h:1653
WM_TIMER
#define WM_TIMER
Definition: winuser.h:1745
CB_ADDSTRING
#define CB_ADDSTRING
Definition: winuser.h:1939
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:2595
MB_OK
#define MB_OK
Definition: winuser.h:793
GetParent
HWND WINAPI GetParent(_In_ HWND)
MB_ICONQUESTION
#define MB_ICONQUESTION
Definition: winuser.h:792
ExitWindowsEx
BOOL WINAPI ExitWindowsEx(_In_ UINT, _In_ DWORD)
DWLP_MSGRESULT
#define DWLP_MSGRESULT
Definition: winuser.h:873
MessageBoxIndirectW
int WINAPI MessageBoxIndirectW(_In_ CONST MSGBOXPARAMSW *lpmbp)
WM_HOTKEY
#define WM_HOTKEY
Definition: winuser.h:1882
BN_CLICKED
#define BN_CLICKED
Definition: winuser.h:1928
WM_DESTROY
#define WM_DESTROY
Definition: winuser.h:1612
MAKEINTRESOURCEW
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
IDYES
#define IDYES
Definition: winuser.h:838
KillTimer
BOOL WINAPI KillTimer(_In_opt_ HWND, _In_ UINT_PTR)
SystemParametersInfo
#define SystemParametersInfo
Definition: winuser.h:5870
SetWindowLongPtrW
#define SetWindowLongPtrW
Definition: winuser.h:5358
GWL_STYLE
#define GWL_STYLE
Definition: winuser.h:855
SendDlgItemMessage
#define SendDlgItemMessage
Definition: winuser.h:5854
EnableMenuItem
BOOL WINAPI EnableMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
LoadIconW
HICON WINAPI LoadIconW(_In_opt_ HINSTANCE hInstance, _In_ LPCWSTR lpIconName)
Definition: cursoricon.c:2119
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:930
SE_PRIVILEGE_ENABLED
#define SE_PRIVILEGE_ENABLED
Definition: setypes.h:63
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
LPTSTR
CHAR * LPTSTR
Definition: xmlstorage.h:192
LPCWSTR
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185