ReactOS 0.4.15-dev-7906-g1b85a5f
partlist.c
Go to the documentation of this file.
1/*
2 * ReactOS kernel
3 * Copyright (C) 2002, 2003, 2004, 2005 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 text-mode setup
22 * FILE: base/setup/usetup/partlist.c
23 * PURPOSE: Partition list functions
24 * PROGRAMMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
25 */
26
27#include "usetup.h"
28
29#define NDEBUG
30#include <debug.h>
31
32/* HELPERS FOR DISK AND PARTITION DESCRIPTIONS ******************************/
33
34VOID
36 IN PPARTENTRY PartEntry,
37 OUT PSTR strBuffer,
39{
40 if (PartEntry->PartitionType == PARTITION_ENTRY_UNUSED)
41 {
44 }
45 else if (IsContainerPartition(PartEntry->PartitionType))
46 {
49 }
50 else
51 {
52 UINT i;
53
54 /* Do the table lookup */
55 if (PartEntry->DiskEntry->DiskStyle == PARTITION_STYLE_MBR)
56 {
57 for (i = 0; i < ARRAYSIZE(MbrPartitionTypes); ++i)
58 {
59 if (PartEntry->PartitionType == MbrPartitionTypes[i].Type)
60 {
63 return;
64 }
65 }
66 }
67#if 0 // TODO: GPT support!
68 else if (PartEntry->DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
69 {
70 for (i = 0; i < ARRAYSIZE(GptPartitionTypes); ++i)
71 {
72 if (IsEqualPartitionType(PartEntry->PartitionType,
74 {
77 return;
78 }
79 }
80 }
81#endif
82
83 /* We are here because the partition type is unknown */
84 if (cchBuffer > 0) *strBuffer = '\0';
85 }
86
87 if ((cchBuffer > 0) && (*strBuffer == '\0'))
88 {
91 PartEntry->PartitionType);
92 }
93}
94
95VOID
98 OUT PCSTR* Unit)
99{
100 ULONGLONG DiskSize = *Size;
101
102 if (DiskSize >= 10 * GB) /* 10 GB */
103 {
104 DiskSize = RoundingDivide(DiskSize, GB);
106 }
107 else
108 {
109 DiskSize = RoundingDivide(DiskSize, MB);
110 if (DiskSize == 0)
111 DiskSize = 1;
113 }
114
115 *Size = DiskSize;
116}
117
118VOID
121 OUT PCSTR* Unit)
122{
123 ULONGLONG PartSize = *Size;
124
125#if 0
126 if (PartSize >= 10 * GB) /* 10 GB */
127 {
128 PartSize = RoundingDivide(PartSize, GB);
130 }
131 else
132#endif
133 if (PartSize >= 10 * MB) /* 10 MB */
134 {
135 PartSize = RoundingDivide(PartSize, MB);
137 }
138 else
139 {
140 PartSize = RoundingDivide(PartSize, KB);
142 }
143
144 *Size = PartSize;
145}
146
147VOID
149 IN PPARTENTRY PartEntry,
150 OUT PSTR strBuffer,
152{
153 PSTR pBuffer = strBuffer;
154 size_t cchBufferSize = cchBuffer;
155 ULONGLONG PartSize;
156 PCSTR Unit;
157
158 /* Get the partition size */
159 PartSize = GetPartEntrySizeInBytes(PartEntry);
160 PrettifySize2(&PartSize, &Unit);
161
162 if (PartEntry->IsPartitioned == FALSE)
163 {
164 /* Unpartitioned space: Just display the description and size */
165 RtlStringCchPrintfExA(pBuffer, cchBufferSize,
166 &pBuffer, &cchBufferSize, 0,
167 " %s%-.30s",
168 PartEntry->LogicalPartition ? " " : "", // Optional indentation
170
171 RtlStringCchPrintfA(pBuffer, cchBufferSize,
172 "%*s%6I64u %s",
173 38 - min(strlen(strBuffer), 38), "", // Indentation
174 PartSize,
175 Unit);
176 return;
177 }
178
179//
180// NOTE: This could be done with the next case.
181//
182 if ((PartEntry->DiskEntry->DiskStyle == PARTITION_STYLE_MBR) &&
183 IsContainerPartition(PartEntry->PartitionType))
184 {
185 /* Extended partition container: Just display the partition's type and size */
186 RtlStringCchPrintfExA(pBuffer, cchBufferSize,
187 &pBuffer, &cchBufferSize, 0,
188 " %-.30s",
190
191 RtlStringCchPrintfA(pBuffer, cchBufferSize,
192 "%*s%6I64u %s",
193 38 - min(strlen(strBuffer), 38), "", // Indentation
194 PartSize,
195 Unit);
196 return;
197 }
198
199 /*
200 * Not an extended partition container.
201 */
202
203 /* Drive letter and partition number */
204 RtlStringCchPrintfExA(pBuffer, cchBufferSize,
205 &pBuffer, &cchBufferSize, 0,
206 "%c%c %c %s(%lu) ",
207 (PartEntry->DriveLetter == 0) ? '-' : (CHAR)PartEntry->DriveLetter,
208 (PartEntry->DriveLetter == 0) ? '-' : ':',
209 PartEntry->BootIndicator ? '*' : ' ',
210 PartEntry->LogicalPartition ? " " : "", // Optional indentation
211 PartEntry->PartitionNumber);
212
213 /*
214 * If the volume's file system is recognized, display the volume label
215 * (if any) and the file system name. Otherwise, display the partition
216 * type if it's not a new partition.
217 */
218 if (!PartEntry->New && *PartEntry->FileSystem &&
219 _wcsicmp(PartEntry->FileSystem, L"RAW") != 0)
220 {
221 size_t cchLabelSize = 0;
222 if (*PartEntry->VolumeLabel)
223 {
224 RtlStringCchPrintfExA(pBuffer, cchBufferSize,
225 &pBuffer, &cchLabelSize, 0,
226 "\"%-.11S\" ",
227 PartEntry->VolumeLabel);
228 cchLabelSize = cchBufferSize - cchLabelSize; // Actual length of the label part.
229 cchBufferSize -= cchLabelSize; // And reset cchBufferSize to what it should be.
230 }
231
232 // TODO: Group this part together with the similar one
233 // from below once the strings are in the same encoding...
234 RtlStringCchPrintfExA(pBuffer, cchBufferSize,
235 &pBuffer, &cchBufferSize, 0,
236 "[%-.*S]",
237 /* The minimum length can be at most 11 since
238 * cchLabelSize can be at most == 11 + 3 == 14 */
239 25 - min(cchLabelSize, 25),
240 PartEntry->FileSystem);
241 }
242 else
243 {
244 CHAR PartTypeString[32];
245 PCSTR PartType = PartTypeString;
246
247 if (PartEntry->New)
248 {
249 /* Use this description if the partition is new (and thus, not formatted) */
251 }
252 else
253 {
254 /* If the partition is not new but its file system is not recognized
255 * (or is not formatted), use the partition type description. */
256 GetPartitionTypeString(PartEntry,
257 PartTypeString,
258 ARRAYSIZE(PartTypeString));
259 PartType = PartTypeString;
260 }
261 if (!PartType || !*PartType)
262 {
264 }
265
266 // TODO: Group this part together with the similar one
267 // from above once the strings are in the same encoding...
268 RtlStringCchPrintfExA(pBuffer, cchBufferSize,
269 &pBuffer, &cchBufferSize, 0,
270 "[%-.*s]",
271 25,
272 PartType);
273 }
274
275 /* Show the remaining free space only if a FS is mounted */
276 // FIXME: We don't support that yet!
277#if 0
278 if (*PartEntry->FileSystem)
279 {
280 RtlStringCchPrintfA(pBuffer, cchBufferSize,
281 "%*s%6I64u %s (%6I64u %s %s)",
282 38 - min(strlen(strBuffer), 38), "", // Indentation
283 PartSize,
284 Unit,
285 PartFreeSize,
286 Unit,
287 "free");
288 }
289 else
290#endif
291 {
292 RtlStringCchPrintfA(pBuffer, cchBufferSize,
293 "%*s%6I64u %s",
294 38 - min(strlen(strBuffer), 38), "", // Indentation
295 PartSize,
296 Unit);
297 }
298}
299
300VOID
302 IN PDISKENTRY DiskEntry,
303 OUT PSTR strBuffer,
305{
306 ULONGLONG DiskSize;
307 PCSTR Unit;
308
309 /* Get the disk size */
310 DiskSize = GetDiskSizeInBytes(DiskEntry);
311 PrettifySize1(&DiskSize, &Unit);
312
313 //
314 // FIXME: We *MUST* use TXTSETUP.SIF strings from section "DiskDriverMap" !!
315 //
316 if (DiskEntry->DriverName.Length > 0)
317 {
320 DiskSize,
321 Unit,
322 DiskEntry->DiskNumber,
323 DiskEntry->Port,
324 DiskEntry->Bus,
325 DiskEntry->Id,
326 &DiskEntry->DriverName,
327 DiskEntry->DiskStyle == PARTITION_STYLE_MBR ? "MBR" :
328 DiskEntry->DiskStyle == PARTITION_STYLE_GPT ? "GPT" :
329 "RAW");
330 }
331 else
332 {
335 DiskSize,
336 Unit,
337 DiskEntry->DiskNumber,
338 DiskEntry->Port,
339 DiskEntry->Bus,
340 DiskEntry->Id,
341 DiskEntry->DiskStyle == PARTITION_STYLE_MBR ? "MBR" :
342 DiskEntry->DiskStyle == PARTITION_STYLE_GPT ? "GPT" :
343 "RAW");
344 }
345}
346
347
348/* FUNCTIONS ****************************************************************/
349
350VOID
352 IN OUT PPARTLIST_UI ListUi,
354 IN PPARTENTRY CurrentEntry OPTIONAL,
355 IN SHORT Left,
356 IN SHORT Top,
357 IN SHORT Right,
359{
360 ListUi->List = List;
361 // ListUi->FirstShown = NULL;
362 // ListUi->LastShown = NULL;
363
364 ListUi->Left = Left;
365 ListUi->Top = Top;
366 ListUi->Right = Right;
367 ListUi->Bottom = Bottom;
368
369 ListUi->Line = 0;
370 ListUi->Offset = 0;
371
372 // ListUi->Redraw = TRUE;
373
374 /* Search for first usable disk and partition */
375 if (!CurrentEntry)
376 {
377 ListUi->CurrentDisk = NULL;
378 ListUi->CurrentPartition = NULL;
379
380 if (!IsListEmpty(&List->DiskListHead))
381 {
382 ListUi->CurrentDisk = CONTAINING_RECORD(List->DiskListHead.Flink,
383 DISKENTRY, ListEntry);
384
385 if (!IsListEmpty(&ListUi->CurrentDisk->PrimaryPartListHead))
386 {
387 ListUi->CurrentPartition = CONTAINING_RECORD(ListUi->CurrentDisk->PrimaryPartListHead.Flink,
388 PARTENTRY, ListEntry);
389 }
390 }
391 }
392 else
393 {
394 /*
395 * The CurrentEntry must belong to the associated partition list,
396 * and the latter must therefore not be empty.
397 */
398 ASSERT(!IsListEmpty(&List->DiskListHead));
399 ASSERT(CurrentEntry->DiskEntry->PartList == List);
400
401 ListUi->CurrentPartition = CurrentEntry;
402 ListUi->CurrentDisk = CurrentEntry->DiskEntry;
403 }
404}
405
406static
407VOID
409 IN PPARTLIST_UI ListUi)
410{
411 COORD coPos;
412 ULONG Written;
415
416 Width = ListUi->Right - ListUi->Left - 1;
417 Height = ListUi->Bottom - ListUi->Top - 2;
418
419 coPos.X = ListUi->Left + 1;
420 coPos.Y = ListUi->Top + 1 + ListUi->Line;
421
422 if (ListUi->Line >= 0 && ListUi->Line <= Height)
423 {
426 Width,
427 coPos,
428 &Written);
429
431 ' ',
432 Width,
433 coPos,
434 &Written);
435 }
436
437 ListUi->Line++;
438}
439
440static
441VOID
443 IN PPARTLIST_UI ListUi,
444 IN PDISKENTRY DiskEntry,
445 IN PPARTENTRY PartEntry)
446{
447 COORD coPos;
448 ULONG Written;
451 UCHAR Attribute;
452 CHAR LineBuffer[100];
453
454 PartitionDescription(PartEntry, LineBuffer, ARRAYSIZE(LineBuffer));
455
456 Width = ListUi->Right - ListUi->Left - 1;
457 Height = ListUi->Bottom - ListUi->Top - 2;
458
459 coPos.X = ListUi->Left + 1;
460 coPos.Y = ListUi->Top + 1 + ListUi->Line;
461
462 Attribute = (ListUi->CurrentDisk == DiskEntry &&
463 ListUi->CurrentPartition == PartEntry) ?
466
467 if (ListUi->Line >= 0 && ListUi->Line <= Height)
468 {
470 ' ',
471 Width,
472 coPos,
473 &Written);
474 }
475 coPos.X += 4;
476 Width -= 8;
477 if (ListUi->Line >= 0 && ListUi->Line <= Height)
478 {
480 Attribute,
481 Width,
482 coPos,
483 &Written);
484 }
485 coPos.X++;
486 Width -= 2;
487 if (ListUi->Line >= 0 && ListUi->Line <= Height)
488 {
490 LineBuffer,
491 min(strlen(LineBuffer), Width),
492 coPos,
493 &Written);
494 }
495
496 ListUi->Line++;
497}
498
499static
500VOID
502 IN PPARTLIST_UI ListUi,
503 IN PDISKENTRY DiskEntry)
504{
505 PPARTENTRY PrimaryPartEntry, LogicalPartEntry;
506 PLIST_ENTRY PrimaryEntry, LogicalEntry;
507 COORD coPos;
508 ULONG Written;
511 CHAR LineBuffer[100];
512
513 DiskDescription(DiskEntry, LineBuffer, ARRAYSIZE(LineBuffer));
514
515 Width = ListUi->Right - ListUi->Left - 1;
516 Height = ListUi->Bottom - ListUi->Top - 2;
517
518 coPos.X = ListUi->Left + 1;
519 coPos.Y = ListUi->Top + 1 + ListUi->Line;
520
521 if (ListUi->Line >= 0 && ListUi->Line <= Height)
522 {
525 Width,
526 coPos,
527 &Written);
528
530 ' ',
531 Width,
532 coPos,
533 &Written);
534 }
535
536 coPos.X++;
537 if (ListUi->Line >= 0 && ListUi->Line <= Height)
538 {
540 LineBuffer,
541 min((USHORT)strlen(LineBuffer), Width - 2),
542 coPos,
543 &Written);
544 }
545
546 ListUi->Line++;
547
548 /* Print separator line */
549 PrintEmptyLine(ListUi);
550
551 /* Print partition lines */
552 for (PrimaryEntry = DiskEntry->PrimaryPartListHead.Flink;
553 PrimaryEntry != &DiskEntry->PrimaryPartListHead;
554 PrimaryEntry = PrimaryEntry->Flink)
555 {
556 PrimaryPartEntry = CONTAINING_RECORD(PrimaryEntry, PARTENTRY, ListEntry);
557
558 PrintPartitionData(ListUi,
559 DiskEntry,
560 PrimaryPartEntry);
561
562 if (IsContainerPartition(PrimaryPartEntry->PartitionType))
563 {
564 for (LogicalEntry = DiskEntry->LogicalPartListHead.Flink;
565 LogicalEntry != &DiskEntry->LogicalPartListHead;
566 LogicalEntry = LogicalEntry->Flink)
567 {
568 LogicalPartEntry = CONTAINING_RECORD(LogicalEntry, PARTENTRY, ListEntry);
569
570 PrintPartitionData(ListUi,
571 DiskEntry,
572 LogicalPartEntry);
573 }
574 }
575 }
576
577 /* Print separator line */
578 PrintEmptyLine(ListUi);
579}
580
581VOID
583 IN PPARTLIST_UI ListUi)
584{
585 PPARTLIST List = ListUi->List;
586 PLIST_ENTRY Entry, Entry2;
587 PDISKENTRY DiskEntry;
588 PPARTENTRY PartEntry = NULL;
589 COORD coPos;
590 ULONG Written;
593 SHORT i;
594 SHORT CurrentDiskLine;
595 SHORT CurrentPartLine;
596 SHORT LastLine;
597 BOOLEAN CurrentPartLineFound = FALSE;
598 BOOLEAN CurrentDiskLineFound = FALSE;
599
600 Width = ListUi->Right - ListUi->Left - 1;
601 Height = ListUi->Bottom - ListUi->Top - 2;
602
603 /* Calculate the line of the current disk and partition */
604 CurrentDiskLine = 0;
605 CurrentPartLine = 0;
606 LastLine = 0;
607
608 for (Entry = List->DiskListHead.Flink;
609 Entry != &List->DiskListHead;
610 Entry = Entry->Flink)
611 {
612 DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
613
614 LastLine += 2;
615 if (CurrentPartLineFound == FALSE)
616 {
617 CurrentPartLine += 2;
618 }
619
620 for (Entry2 = DiskEntry->PrimaryPartListHead.Flink;
621 Entry2 != &DiskEntry->PrimaryPartListHead;
622 Entry2 = Entry2->Flink)
623 {
624 PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
625 if (PartEntry == ListUi->CurrentPartition)
626 {
627 CurrentPartLineFound = TRUE;
628 }
629
630 if (CurrentPartLineFound == FALSE)
631 {
632 CurrentPartLine++;
633 }
634
635 LastLine++;
636 }
637
638 if (CurrentPartLineFound == FALSE)
639 {
640 for (Entry2 = DiskEntry->LogicalPartListHead.Flink;
641 Entry2 != &DiskEntry->LogicalPartListHead;
642 Entry2 = Entry2->Flink)
643 {
644 PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
645 if (PartEntry == ListUi->CurrentPartition)
646 {
647 CurrentPartLineFound = TRUE;
648 }
649
650 if (CurrentPartLineFound == FALSE)
651 {
652 CurrentPartLine++;
653 }
654
655 LastLine++;
656 }
657 }
658
659 if (DiskEntry == ListUi->CurrentDisk)
660 {
661 CurrentDiskLineFound = TRUE;
662 }
663
664 if (Entry->Flink != &List->DiskListHead)
665 {
666 if (CurrentDiskLineFound == FALSE)
667 {
668 CurrentPartLine++;
669 CurrentDiskLine = CurrentPartLine;
670 }
671
672 LastLine++;
673 }
674 else
675 {
676 LastLine--;
677 }
678 }
679
680 /* If it possible, make the disk name visible */
681 if (CurrentPartLine < ListUi->Offset)
682 {
683 ListUi->Offset = CurrentPartLine;
684 }
685 else if (CurrentPartLine - ListUi->Offset > Height)
686 {
687 ListUi->Offset = CurrentPartLine - Height;
688 }
689
690 if (CurrentDiskLine < ListUi->Offset && CurrentPartLine - CurrentDiskLine < Height)
691 {
692 ListUi->Offset = CurrentDiskLine;
693 }
694
695 /* Draw upper left corner */
696 coPos.X = ListUi->Left;
697 coPos.Y = ListUi->Top;
699 CharUpperLeftCorner, // '+',
700 1,
701 coPos,
702 &Written);
703
704 /* Draw upper edge */
705 coPos.X = ListUi->Left + 1;
706 coPos.Y = ListUi->Top;
707 if (ListUi->Offset == 0)
708 {
710 CharHorizontalLine, // '-',
711 Width,
712 coPos,
713 &Written);
714 }
715 else
716 {
718 CharHorizontalLine, // '-',
719 Width - 4,
720 coPos,
721 &Written);
722 {
723 CHAR szBuff[] = "(.)"; // "(up)"
724 szBuff[1] = CharUpArrow;
725 coPos.X = ListUi->Right - 5;
727 szBuff,
728 3,
729 coPos,
730 &Written);
731 }
732 coPos.X = ListUi->Right - 2;
734 CharHorizontalLine, // '-',
735 2,
736 coPos,
737 &Written);
738 }
739
740 /* Draw upper right corner */
741 coPos.X = ListUi->Right;
742 coPos.Y = ListUi->Top;
744 CharUpperRightCorner, // '+',
745 1,
746 coPos,
747 &Written);
748
749 /* Draw left and right edge */
750 for (i = ListUi->Top + 1; i < ListUi->Bottom; i++)
751 {
752 coPos.X = ListUi->Left;
753 coPos.Y = i;
755 CharVerticalLine, // '|',
756 1,
757 coPos,
758 &Written);
759
760 coPos.X = ListUi->Right;
762 CharVerticalLine, //'|',
763 1,
764 coPos,
765 &Written);
766 }
767
768 /* Draw lower left corner */
769 coPos.X = ListUi->Left;
770 coPos.Y = ListUi->Bottom;
772 CharLowerLeftCorner, // '+',
773 1,
774 coPos,
775 &Written);
776
777 /* Draw lower edge */
778 coPos.X = ListUi->Left + 1;
779 coPos.Y = ListUi->Bottom;
780 if (LastLine - ListUi->Offset <= Height)
781 {
783 CharHorizontalLine, // '-',
784 Width,
785 coPos,
786 &Written);
787 }
788 else
789 {
791 CharHorizontalLine, // '-',
792 Width - 4,
793 coPos,
794 &Written);
795 {
796 CHAR szBuff[] = "(.)"; // "(down)"
797 szBuff[1] = CharDownArrow;
798 coPos.X = ListUi->Right - 5;
800 szBuff,
801 3,
802 coPos,
803 &Written);
804 }
805 coPos.X = ListUi->Right - 2;
807 CharHorizontalLine, // '-',
808 2,
809 coPos,
810 &Written);
811 }
812
813 /* Draw lower right corner */
814 coPos.X = ListUi->Right;
815 coPos.Y = ListUi->Bottom;
817 CharLowerRightCorner, // '+',
818 1,
819 coPos,
820 &Written);
821
822 /* Print list entries */
823 ListUi->Line = -ListUi->Offset;
824
825 for (Entry = List->DiskListHead.Flink;
826 Entry != &List->DiskListHead;
827 Entry = Entry->Flink)
828 {
829 DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
830
831 /* Print disk entry */
832 PrintDiskData(ListUi, DiskEntry);
833 }
834}
835
836VOID
838 IN PPARTLIST_UI ListUi)
839{
840 PPARTENTRY NextPart = GetNextPartition(ListUi->List, ListUi->CurrentPartition);
841 if (NextPart)
842 {
843 ListUi->CurrentPartition = NextPart;
844 ListUi->CurrentDisk = NextPart->DiskEntry;
845 DrawPartitionList(ListUi);
846 }
847}
848
849VOID
851 IN PPARTLIST_UI ListUi)
852{
853 PPARTENTRY PrevPart = GetPrevPartition(ListUi->List, ListUi->CurrentPartition);
854 if (PrevPart)
855 {
856 ListUi->CurrentPartition = PrevPart;
857 ListUi->CurrentDisk = PrevPart->DiskEntry;
858 DrawPartitionList(ListUi);
859 }
860}
861
862/* EOF */
unsigned char BOOLEAN
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
const GPT_PARTITION_TYPE GptPartitionTypes[NUM_GPT_PARTITION_TYPES]
Definition: partinfo.c:271
const MBR_PARTITION_TYPE MbrPartitionTypes[NUM_MBR_PARTITION_TYPES]
Definition: partinfo.c:46
BOOL WINAPI WriteConsoleOutputCharacterA(HANDLE hConsoleOutput, IN LPCSTR lpCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten)
Definition: console.c:407
BOOL WINAPI FillConsoleOutputCharacterA(IN HANDLE hConsoleOutput, IN CHAR cCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten)
Definition: console.c:560
BOOL WINAPI FillConsoleOutputAttribute(IN HANDLE hConsoleOutput, IN WORD wAttribute, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfAttrsWritten)
Definition: console.c:525
static LPHIST_ENTRY Bottom
Definition: history.c:54
static LPHIST_ENTRY Top
Definition: history.c:53
#define BACKGROUND_BLUE
Definition: blue.h:65
#define FOREGROUND_BLUE
Definition: blue.h:61
#define PARTITION_ENTRY_UNUSED
Definition: disk.h:86
HANDLE StdOutput
Definition: consup.c:37
#define FOREGROUND_WHITE
Definition: consup.h:29
#define BACKGROUND_WHITE
Definition: consup.h:31
PartType
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
static const WCHAR Description[]
Definition: oid.c:1266
static DWORD cchBuffer
Definition: fusion.c:85
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
Unit
Definition: gdiplusenums.h:26
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
#define GetDiskSizeInBytes(DiskEntry)
Definition: partlist.h:233
#define GetPartEntrySizeInBytes(PartEntry)
Definition: partlist.h:230
#define ASSERT(a)
Definition: mode.c:44
@ PARTITION_STYLE_GPT
Definition: imports.h:202
@ PARTITION_STYLE_MBR
Definition: imports.h:201
#define min(a, b)
Definition: monoChain.cc:55
unsigned int UINT
Definition: ndis.h:50
__GNU_EXTENSION typedef unsigned __int64 * PULONGLONG
Definition: ntbasedef.h:383
#define IsContainerPartition(PartitionType)
Definition: ntdddisk.h:316
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
NTSTRSAFEAPI RtlStringCchCopyA(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cchDest, _In_ NTSTRSAFE_PCSTR pszSrc)
Definition: ntstrsafe.h:110
NTSTRSAFEVAPI RtlStringCchPrintfA(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cchDest, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1085
NTSTRSAFEVAPI RtlStringCchPrintfExA(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cchDest, _Outptr_opt_result_buffer_(*pcchRemaining) NTSTRSAFE_PSTR *ppszDestEnd, _Out_opt_ size_t *pcchRemaining, _In_ STRSAFE_DWORD dwFlags, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1218
#define L(x)
Definition: ntvdm.h:50
short SHORT
Definition: pedump.c:59
unsigned short USHORT
Definition: pedump.c:61
PVOID pBuffer
_Check_return_ _CRTIMP int __cdecl _wcsicmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
ULONGLONG RoundingDivide(IN ULONGLONG Dividend, IN ULONGLONG Divisor)
Definition: partlist.c:95
PPARTENTRY GetPrevPartition(IN PPARTLIST List, IN PPARTENTRY CurrentPart OPTIONAL)
Definition: partlist.c:2319
PPARTENTRY GetNextPartition(IN PPARTLIST List, IN PPARTENTRY CurrentPart OPTIONAL)
Definition: partlist.c:2227
VOID PartitionDescription(IN PPARTENTRY PartEntry, OUT PSTR strBuffer, IN SIZE_T cchBuffer)
Definition: partlist.c:148
VOID ScrollDownPartitionList(IN PPARTLIST_UI ListUi)
Definition: partlist.c:837
VOID DiskDescription(IN PDISKENTRY DiskEntry, OUT PSTR strBuffer, IN SIZE_T cchBuffer)
Definition: partlist.c:301
VOID ScrollUpPartitionList(IN PPARTLIST_UI ListUi)
Definition: partlist.c:850
VOID PrettifySize1(IN OUT PULONGLONG Size, OUT PCSTR *Unit)
Definition: partlist.c:96
static VOID PrintDiskData(IN PPARTLIST_UI ListUi, IN PDISKENTRY DiskEntry)
Definition: partlist.c:501
VOID GetPartitionTypeString(IN PPARTENTRY PartEntry, OUT PSTR strBuffer, IN ULONG cchBuffer)
Definition: partlist.c:35
VOID DrawPartitionList(IN PPARTLIST_UI ListUi)
Definition: partlist.c:582
static VOID PrintEmptyLine(IN PPARTLIST_UI ListUi)
Definition: partlist.c:408
VOID PrettifySize2(IN OUT PULONGLONG Size, OUT PCSTR *Unit)
Definition: partlist.c:119
static VOID PrintPartitionData(IN PPARTLIST_UI ListUi, IN PDISKENTRY DiskEntry, IN PPARTENTRY PartEntry)
Definition: partlist.c:442
VOID InitPartitionListUi(IN OUT PPARTLIST_UI ListUi, IN PPARTLIST List, IN PPARTENTRY CurrentEntry OPTIONAL, IN SHORT Left, IN SHORT Top, IN SHORT Right, IN SHORT Bottom)
Definition: partlist.c:351
#define KB
Definition: setuplib.h:55
#define GB
Definition: setuplib.h:57
#define MB
Definition: setuplib.h:56
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
base of all file and directory entries
Definition: entries.h:83
Definition: bl.h:1338
ULONG Y
Definition: bl.h:1340
ULONG X
Definition: bl.h:1339
LIST_ENTRY LogicalPartListHead
Definition: partlist.h:129
LIST_ENTRY PrimaryPartListHead
Definition: partlist.h:128
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
UCHAR PartitionType
Definition: partlist.h:53
struct _DISKENTRY * DiskEntry
Definition: partlist.h:46
char * PSTR
Definition: typedefs.h:51
ULONG_PTR SIZE_T
Definition: typedefs.h:80
const char * PCSTR
Definition: typedefs.h:52
#define IN
Definition: typedefs.h:39
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
uint64_t ULONGLONG
Definition: typedefs.h:67
#define OUT
Definition: typedefs.h:40
_In_ HFONT _Out_ PUINT _Out_ PUINT Width
Definition: font.h:89
_In_ HFONT _Out_ PUINT Height
Definition: font.h:88
CHAR CharHorizontalLine
Definition: mui.c:39
CHAR CharUpperRightCorner
Definition: mui.c:42
CHAR CharDownArrow
Definition: mui.c:38
CHAR CharLowerRightCorner
Definition: mui.c:44
PCSTR MUIGetString(ULONG Number)
Definition: mui.c:251
CHAR CharUpperLeftCorner
Definition: mui.c:41
CHAR CharVerticalLine
Definition: mui.c:40
CHAR CharLowerLeftCorner
Definition: mui.c:43
CHAR CharUpArrow
Definition: mui.c:37
#define STRING_HDDINFO2
Definition: mui.h:177
#define STRING_UNPSPACE
Definition: mui.h:178
#define STRING_FORMATUNUSED
Definition: mui.h:182
#define STRING_GB
Definition: mui.h:186
#define STRING_FORMATUNKNOWN
Definition: mui.h:183
#define STRING_UNFORMATTED
Definition: mui.h:180
#define STRING_HDDINFO1
Definition: mui.h:176
#define STRING_MB
Definition: mui.h:185
#define STRING_EXTENDED_PARTITION
Definition: mui.h:181
#define STRING_KB
Definition: mui.h:184
#define STRING_PARTTYPE
Definition: mui.h:175
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
unsigned char UCHAR
Definition: xmlstorage.h:181
char CHAR
Definition: xmlstorage.h:175