partlist.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_PARTLIST_UI

Typedefs
typedef enum _FORMATMACHINESTATE	FORMATMACHINESTATE
typedef enum _FORMATMACHINESTATE *	PFORMATMACHINESTATE
typedef struct _PARTLIST_UI	PARTLIST_UI
typedef struct _PARTLIST_UI *	PPARTLIST_UI

Enumerations
enum	_FORMATMACHINESTATE {   Start , FormatSystemPartition , FormatInstallPartition , FormatOtherPartition ,   FormatDone }

Functions
VOID	GetPartitionTypeString (IN PPARTENTRY PartEntry, OUT PSTR strBuffer, IN ULONG cchBuffer)
VOID	PartitionDescription (IN PPARTENTRY PartEntry, OUT PSTR strBuffer, IN SIZE_T cchBuffer)
VOID	DiskDescription (IN PDISKENTRY DiskEntry, OUT PSTR strBuffer, IN SIZE_T cchBuffer)
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)
VOID	ScrollDownPartitionList (IN PPARTLIST_UI ListUi)
VOID	ScrollUpPartitionList (IN PPARTLIST_UI ListUi)
VOID	DrawPartitionList (IN PPARTLIST_UI ListUi)

Typedef Documentation

FORMATMACHINESTATE

typedef enum _FORMATMACHINESTATE FORMATMACHINESTATE

PARTLIST_UI

typedef struct _PARTLIST_UI PARTLIST_UI

PFORMATMACHINESTATE

typedef enum _FORMATMACHINESTATE * PFORMATMACHINESTATE

PPARTLIST_UI

typedef struct _PARTLIST_UI * PPARTLIST_UI

Enumeration Type Documentation

_FORMATMACHINESTATE

enum _FORMATMACHINESTATE

Enumerator
Start
FormatSystemPartition
FormatInstallPartition
FormatOtherPartition
FormatDone

Definition at line 31 of file partlist.h.

{
    Start,
    FormatSystemPartition,
    FormatInstallPartition,
    FormatOtherPartition,
    FormatDone,
    // CheckSystemPartition,
    // CheckInstallPartition,
    // CheckOtherPartition,
    // CheckDone
} FORMATMACHINESTATE, *PFORMATMACHINESTATE;

Function Documentation

DiskDescription()

VOID DiskDescription	(	IN PDISKENTRY	DiskEntry,
		OUT PSTR	strBuffer,
		IN SIZE_T	cchBuffer
	)

Definition at line 301 of file partlist.c.

{
    ULONGLONG DiskSize;
    PCSTR Unit;
 
    /* Get the disk size */
    DiskSize = DiskEntry->SectorCount.QuadPart * DiskEntry->BytesPerSector;
    PrettifySize1(&DiskSize, &Unit);
 
    //
    // FIXME: We *MUST* use TXTSETUP.SIF strings from section "DiskDriverMap" !!
    //
    if (DiskEntry->DriverName.Length > 0)
    {
        RtlStringCchPrintfA(strBuffer, cchBuffer,
                            MUIGetString(STRING_HDDINFO1),
                            DiskSize,
                            Unit,
                            DiskEntry->DiskNumber,
                            DiskEntry->Port,
                            DiskEntry->Bus,
                            DiskEntry->Id,
                            &DiskEntry->DriverName,
                            DiskEntry->DiskStyle == PARTITION_STYLE_MBR ? "MBR" :
                            DiskEntry->DiskStyle == PARTITION_STYLE_GPT ? "GPT" :
                                                                          "RAW");
    }
    else
    {
        RtlStringCchPrintfA(strBuffer, cchBuffer,
                            MUIGetString(STRING_HDDINFO2),
                            DiskSize,
                            Unit,
                            DiskEntry->DiskNumber,
                            DiskEntry->Port,
                            DiskEntry->Bus,
                            DiskEntry->Id,
                            DiskEntry->DiskStyle == PARTITION_STYLE_MBR ? "MBR" :
                            DiskEntry->DiskStyle == PARTITION_STYLE_GPT ? "GPT" :
                                                                          "RAW");
    }
}

Referenced by CheckFileSystemPage(), CreatePartitionPage(), DeletePartitionPage(), FormatPartitionPage(), PrintDiskData(), and SelectFileSystemPage().

DrawPartitionList()

VOID DrawPartitionList

(

IN PPARTLIST_UI

ListUi

)

Definition at line 582 of file partlist.c.

{
    PPARTLIST List = ListUi->List;
    PLIST_ENTRY Entry, Entry2;
    PDISKENTRY DiskEntry;
    PPARTENTRY PartEntry = NULL;
    COORD coPos;
    ULONG Written;
    USHORT Width;
    USHORT Height;
    SHORT i;
    SHORT CurrentDiskLine;
    SHORT CurrentPartLine;
    SHORT LastLine;
    BOOLEAN CurrentPartLineFound = FALSE;
    BOOLEAN CurrentDiskLineFound = FALSE;
 
    Width = ListUi->Right - ListUi->Left - 1;
    Height = ListUi->Bottom - ListUi->Top - 2;
 
    /* Calculate the line of the current disk and partition */
    CurrentDiskLine = 0;
    CurrentPartLine = 0;
    LastLine = 0;
 
    for (Entry = List->DiskListHead.Flink;
         Entry != &List->DiskListHead;
         Entry = Entry->Flink)
    {
        DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
 
        LastLine += 2;
        if (CurrentPartLineFound == FALSE)
        {
            CurrentPartLine += 2;
        }
 
        for (Entry2 = DiskEntry->PrimaryPartListHead.Flink;
             Entry2 != &DiskEntry->PrimaryPartListHead;
             Entry2 = Entry2->Flink)
        {
            PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
            if (PartEntry == ListUi->CurrentPartition)
            {
                CurrentPartLineFound = TRUE;
            }
 
            if (CurrentPartLineFound == FALSE)
            {
                CurrentPartLine++;
            }
 
            LastLine++;
        }
 
        if (CurrentPartLineFound == FALSE)
        {
            for (Entry2 = DiskEntry->LogicalPartListHead.Flink;
                 Entry2 != &DiskEntry->LogicalPartListHead;
                 Entry2 = Entry2->Flink)
            {
                PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
                if (PartEntry == ListUi->CurrentPartition)
                {
                    CurrentPartLineFound = TRUE;
                }
 
                if (CurrentPartLineFound == FALSE)
                {
                    CurrentPartLine++;
                }
 
                LastLine++;
            }
        }
 
        if (DiskEntry == ListUi->CurrentDisk)
        {
            CurrentDiskLineFound = TRUE;
        }
 
        if (Entry->Flink != &List->DiskListHead)
        {
            if (CurrentDiskLineFound == FALSE)
            {
                CurrentPartLine++;
                CurrentDiskLine = CurrentPartLine;
            }
 
            LastLine++;
        }
        else
        {
            LastLine--;
        }
    }
 
    /* If it possible, make the disk name visible */
    if (CurrentPartLine < ListUi->Offset)
    {
        ListUi->Offset = CurrentPartLine;
    }
    else if (CurrentPartLine - ListUi->Offset > Height)
    {
        ListUi->Offset = CurrentPartLine - Height;
    }
 
    if (CurrentDiskLine < ListUi->Offset && CurrentPartLine - CurrentDiskLine < Height)
    {
        ListUi->Offset = CurrentDiskLine;
    }
 
    /* Draw upper left corner */
    coPos.X = ListUi->Left;
    coPos.Y = ListUi->Top;
    FillConsoleOutputCharacterA(StdOutput,
                                CharUpperLeftCorner, // '+',
                                1,
                                coPos,
                                &Written);
 
    /* Draw upper edge */
    coPos.X = ListUi->Left + 1;
    coPos.Y = ListUi->Top;
    if (ListUi->Offset == 0)
    {
        FillConsoleOutputCharacterA(StdOutput,
                                    CharHorizontalLine, // '-',
                                    Width,
                                    coPos,
                                    &Written);
    }
    else
    {
        FillConsoleOutputCharacterA(StdOutput,
                                    CharHorizontalLine, // '-',
                                    Width - 4,
                                    coPos,
                                    &Written);
        {
            CHAR szBuff[] = "(.)"; // "(up)"
            szBuff[1] = CharUpArrow;
            coPos.X = ListUi->Right - 5;
            WriteConsoleOutputCharacterA(StdOutput,
                                         szBuff,
                                         3,
                                         coPos,
                                         &Written);
        }
        coPos.X = ListUi->Right - 2;
        FillConsoleOutputCharacterA(StdOutput,
                                    CharHorizontalLine, // '-',
                                    2,
                                    coPos,
                                    &Written);
    }
 
    /* Draw upper right corner */
    coPos.X = ListUi->Right;
    coPos.Y = ListUi->Top;
    FillConsoleOutputCharacterA(StdOutput,
                                CharUpperRightCorner, // '+',
                                1,
                                coPos,
                                &Written);
 
    /* Draw left and right edge */
    for (i = ListUi->Top + 1; i < ListUi->Bottom; i++)
    {
        coPos.X = ListUi->Left;
        coPos.Y = i;
        FillConsoleOutputCharacterA(StdOutput,
                                    CharVerticalLine, // '|',
                                    1,
                                    coPos,
                                    &Written);
 
        coPos.X = ListUi->Right;
        FillConsoleOutputCharacterA(StdOutput,
                                    CharVerticalLine, //'|',
                                    1,
                                    coPos,
                                    &Written);
    }
 
    /* Draw lower left corner */
    coPos.X = ListUi->Left;
    coPos.Y = ListUi->Bottom;
    FillConsoleOutputCharacterA(StdOutput,
                                CharLowerLeftCorner, // '+',
                                1,
                                coPos,
                                &Written);
 
    /* Draw lower edge */
    coPos.X = ListUi->Left + 1;
    coPos.Y = ListUi->Bottom;
    if (LastLine - ListUi->Offset <= Height)
    {
        FillConsoleOutputCharacterA(StdOutput,
                                    CharHorizontalLine, // '-',
                                    Width,
                                    coPos,
                                    &Written);
    }
    else
    {
        FillConsoleOutputCharacterA(StdOutput,
                                    CharHorizontalLine, // '-',
                                    Width - 4,
                                    coPos,
                                    &Written);
        {
            CHAR szBuff[] = "(.)"; // "(down)"
            szBuff[1] = CharDownArrow;
            coPos.X = ListUi->Right - 5;
            WriteConsoleOutputCharacterA(StdOutput,
                                         szBuff,
                                         3,
                                         coPos,
                                         &Written);
        }
       coPos.X = ListUi->Right - 2;
       FillConsoleOutputCharacterA(StdOutput,
                                   CharHorizontalLine, // '-',
                                   2,
                                   coPos,
                                   &Written);
    }
 
    /* Draw lower right corner */
    coPos.X = ListUi->Right;
    coPos.Y = ListUi->Bottom;
    FillConsoleOutputCharacterA(StdOutput,
                                CharLowerRightCorner, // '+',
                                1,
                                coPos,
                                &Written);
 
    /* Print list entries */
    ListUi->Line = -ListUi->Offset;
 
    for (Entry = List->DiskListHead.Flink;
         Entry != &List->DiskListHead;
         Entry = Entry->Flink)
    {
        DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
 
        /* Print disk entry */
        PrintDiskData(ListUi, DiskEntry);
    }
}

Referenced by ScrollDownPartitionList(), and ScrollUpPartitionList().

GetPartitionTypeString()

VOID GetPartitionTypeString	(	IN PPARTENTRY	PartEntry,
		OUT PSTR	strBuffer,
		IN ULONG	cchBuffer
	)

Definition at line 237 of file drivepage.c.

{
    if (PartEntry->PartitionType == PARTITION_ENTRY_UNUSED)
    {
        StringCchCopyA(strBuffer, cchBuffer,
                       "Unused" /* MUIGetString(STRING_FORMATUNUSED) */);
    }
    else if (IsContainerPartition(PartEntry->PartitionType))
    {
        StringCchCopyA(strBuffer, cchBuffer,
                       "Extended Partition" /* MUIGetString(STRING_EXTENDED_PARTITION) */);
    }
    else
    {
        UINT i;
 
        /* Do the table lookup */
        if (PartEntry->DiskEntry->DiskStyle == PARTITION_STYLE_MBR)
        {
            for (i = 0; i < ARRAYSIZE(MbrPartitionTypes); ++i)
            {
                if (PartEntry->PartitionType == MbrPartitionTypes[i].Type)
                {
                    StringCchCopyA(strBuffer, cchBuffer,
                                   MbrPartitionTypes[i].Description);
                    return;
                }
            }
        }
#if 0 // TODO: GPT support!
        else if (PartEntry->DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
        {
            for (i = 0; i < ARRAYSIZE(GptPartitionTypes); ++i)
            {
                if (IsEqualPartitionType(PartEntry->PartitionType,
                                         GptPartitionTypes[i].Guid))
                {
                    StringCchCopyA(strBuffer, cchBuffer,
                                   GptPartitionTypes[i].Description);
                    return;
                }
            }
        }
#endif
 
        /* We are here because the partition type is unknown */
        if (cchBuffer > 0) *strBuffer = '\0';
    }
 
    if ((cchBuffer > 0) && (*strBuffer == '\0'))
    {
        StringCchPrintfA(strBuffer, cchBuffer,
                         // MUIGetString(STRING_PARTTYPE),
                         "Type 0x%02x",
                         PartEntry->PartitionType);
    }
}

Referenced by PartitionDescription(), and PrintPartitionData().

InitPartitionListUi()

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 at line 351 of file partlist.c.

{
    ListUi->List = List;
    // ListUi->FirstShown = NULL;
    // ListUi->LastShown = NULL;
 
    ListUi->Left = Left;
    ListUi->Top = Top;
    ListUi->Right = Right;
    ListUi->Bottom = Bottom;
 
    ListUi->Line = 0;
    ListUi->Offset = 0;
 
    // ListUi->Redraw = TRUE;
 
    /* Search for first usable disk and partition */
    if (!CurrentEntry)
    {
        ListUi->CurrentDisk = NULL;
        ListUi->CurrentPartition = NULL;
 
        if (!IsListEmpty(&List->DiskListHead))
        {
            ListUi->CurrentDisk = CONTAINING_RECORD(List->DiskListHead.Flink,
                                                    DISKENTRY, ListEntry);
 
            if (!IsListEmpty(&ListUi->CurrentDisk->PrimaryPartListHead))
            {
                ListUi->CurrentPartition = CONTAINING_RECORD(ListUi->CurrentDisk->PrimaryPartListHead.Flink,
                                                             PARTENTRY, ListEntry);
            }
        }
    }
    else
    {
        /*
         * The CurrentEntry must belong to the associated partition list,
         * and the latter must therefore not be empty.
         */
        ASSERT(!IsListEmpty(&List->DiskListHead));
        ASSERT(CurrentEntry->DiskEntry->PartList == List);
 
        ListUi->CurrentPartition = CurrentEntry;
        ListUi->CurrentDisk = CurrentEntry->DiskEntry;
    }
}

Referenced by SelectPartitionPage().

PartitionDescription()

VOID PartitionDescription	(	IN PPARTENTRY	PartEntry,
		OUT PSTR	strBuffer,
		IN SIZE_T	cchBuffer
	)

Definition at line 148 of file partlist.c.

{
    PSTR pBuffer = strBuffer;
    size_t cchBufferSize = cchBuffer;
    ULONGLONG PartSize;
    PCSTR Unit;
 
    /* Get the partition size */
    PartSize = PartEntry->SectorCount.QuadPart * PartEntry->DiskEntry->BytesPerSector;
    PrettifySize2(&PartSize, &Unit);
 
    if (PartEntry->IsPartitioned == FALSE)
    {
        /* Unpartitioned space: Just display the description and size */
        RtlStringCchPrintfExA(pBuffer, cchBufferSize,
                              &pBuffer, &cchBufferSize, 0,
                              "     %s%-.30s",
                              PartEntry->LogicalPartition ? "  " : "", // Optional indentation
                              MUIGetString(STRING_UNPSPACE));
 
        RtlStringCchPrintfA(pBuffer, cchBufferSize,
                            "%*s%6I64u %s",
                            38 - min(strlen(strBuffer), 38), "", // Indentation
                            PartSize,
                            Unit);
        return;
    }
 
//
// NOTE: This could be done with the next case.
//
    if ((PartEntry->DiskEntry->DiskStyle == PARTITION_STYLE_MBR) &&
        IsContainerPartition(PartEntry->PartitionType))
    {
        /* Extended partition container: Just display the partition's type and size */
        RtlStringCchPrintfExA(pBuffer, cchBufferSize,
                              &pBuffer, &cchBufferSize, 0,
                              "     %-.30s",
                              MUIGetString(STRING_EXTENDED_PARTITION));
 
        RtlStringCchPrintfA(pBuffer, cchBufferSize,
                            "%*s%6I64u %s",
                            38 - min(strlen(strBuffer), 38), "", // Indentation
                            PartSize,
                            Unit);
        return;
    }
 
    /*
     * Not an extended partition container.
     */
 
    /* Drive letter and partition number */
    RtlStringCchPrintfExA(pBuffer, cchBufferSize,
                          &pBuffer, &cchBufferSize, 0,
                          "%c%c %c %s(%lu) ",
                          (PartEntry->DriveLetter == 0) ? '-' : (CHAR)PartEntry->DriveLetter,
                          (PartEntry->DriveLetter == 0) ? '-' : ':',
                          PartEntry->BootIndicator ? '*' : ' ',
                          PartEntry->LogicalPartition ? "  " : "", // Optional indentation
                          PartEntry->PartitionNumber);
 
    /*
     * If the volume's file system is recognized, display the volume label
     * (if any) and the file system name. Otherwise, display the partition
     * type if it's not a new partition.
     */
    if (!PartEntry->New && *PartEntry->FileSystem &&
        _wcsicmp(PartEntry->FileSystem, L"RAW") != 0)
    {
        size_t cchLabelSize = 0;
        if (*PartEntry->VolumeLabel)
        {
            RtlStringCchPrintfExA(pBuffer, cchBufferSize,
                                  &pBuffer, &cchLabelSize, 0,
                                  "\"%-.11S\" ",
                                  PartEntry->VolumeLabel);
            cchLabelSize = cchBufferSize - cchLabelSize; // Actual length of the label part.
            cchBufferSize -= cchLabelSize; // And reset cchBufferSize to what it should be.
        }
 
        // TODO: Group this part together with the similar one
        // from below once the strings are in the same encoding...
        RtlStringCchPrintfExA(pBuffer, cchBufferSize,
                              &pBuffer, &cchBufferSize, 0,
                              "[%-.*S]",
                              /* The minimum length can be at most 11 since
                               * cchLabelSize can be at most == 11 + 3 == 14 */
                              25 - min(cchLabelSize, 25),
                              PartEntry->FileSystem);
    }
    else
    {
        CHAR PartTypeString[32];
        PCSTR PartType = PartTypeString;
 
        if (PartEntry->New)
        {
            /* Use this description if the partition is new (and thus, not formatted) */
            PartType = MUIGetString(STRING_UNFORMATTED);
        }
        else
        {
            /* If the partition is not new but its file system is not recognized
             * (or is not formatted), use the partition type description. */
            GetPartitionTypeString(PartEntry,
                                   PartTypeString,
                                   ARRAYSIZE(PartTypeString));
            PartType = PartTypeString;
        }
        if (!PartType || !*PartType)
        {
            PartType = MUIGetString(STRING_FORMATUNKNOWN);
        }
 
        // TODO: Group this part together with the similar one
        // from above once the strings are in the same encoding...
        RtlStringCchPrintfExA(pBuffer, cchBufferSize,
                              &pBuffer, &cchBufferSize, 0,
                              "[%-.*s]",
                              25,
                              PartType);
    }
 
    /* Show the remaining free space only if a FS is mounted */
    // FIXME: We don't support that yet!
#if 0
    if (*PartEntry->FileSystem)
    {
        RtlStringCchPrintfA(pBuffer, cchBufferSize,
                            "%*s%6I64u %s (%6I64u %s %s)",
                            38 - min(strlen(strBuffer), 38), "", // Indentation
                            PartSize,
                            Unit,
                            PartFreeSize,
                            Unit,
                            "free");
    }
    else
#endif
    {
        RtlStringCchPrintfA(pBuffer, cchBufferSize,
                            "%*s%6I64u %s",
                            38 - min(strlen(strBuffer), 38), "", // Indentation
                            PartSize,
                            Unit);
    }
}

Referenced by CheckFileSystemPage(), DeletePartitionPage(), FormatPartitionPage(), PrintPartitionData(), and SelectFileSystemPage().

ScrollDownPartitionList()

VOID ScrollDownPartitionList

(

IN PPARTLIST_UI

ListUi

)

Definition at line 837 of file partlist.c.

{
    PPARTENTRY NextPart = GetNextPartition(ListUi->List, ListUi->CurrentPartition);
    if (NextPart)
    {
        ListUi->CurrentPartition = NextPart;
        ListUi->CurrentDisk = NextPart->DiskEntry;
        DrawPartitionList(ListUi);
    }
}

Referenced by SelectPartitionPage().

ScrollUpPartitionList()

VOID ScrollUpPartitionList

(

IN PPARTLIST_UI

ListUi

)

Definition at line 850 of file partlist.c.

{
    PPARTENTRY PrevPart = GetPrevPartition(ListUi->List, ListUi->CurrentPartition);
    if (PrevPart)
    {
        ListUi->CurrentPartition = PrevPart;
        ListUi->CurrentDisk = PrevPart->DiskEntry;
        DrawPartitionList(ListUi);
    }
}

Referenced by SelectPartitionPage().