partlist.c File Reference

#include "usetup.h"
#include <debug.h>

Include dependency graph for partlist.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID	GetPartitionTypeString (IN PPARTENTRY PartEntry, OUT PSTR strBuffer, IN ULONG cchBuffer)
VOID	PrettifySize1 (IN OUT PULONGLONG Size, OUT PCSTR *Unit)
VOID	PrettifySize2 (IN OUT PULONGLONG Size, OUT PCSTR *Unit)
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)
static VOID	PrintEmptyLine (IN PPARTLIST_UI ListUi)
static VOID	PrintPartitionData (IN PPARTLIST_UI ListUi, IN PDISKENTRY DiskEntry, IN PPARTENTRY PartEntry)
static VOID	PrintDiskData (IN PPARTLIST_UI ListUi, IN PDISKENTRY DiskEntry)
VOID	DrawPartitionList (IN PPARTLIST_UI ListUi)
VOID	ScrollDownPartitionList (IN PPARTLIST_UI ListUi)
VOID	ScrollUpPartitionList (IN PPARTLIST_UI ListUi)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 29 of file partlist.c.

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_HDDINFO_1),
                            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_HDDINFO_2),
                            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 CreateExtendedPartitionPage(), CreateLogicalPartitionPage(), CreatePrimaryPartitionPage(), DeletePartitionPage(), 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 35 of file partlist.c.

{
    if (PartEntry->PartitionType == PARTITION_ENTRY_UNUSED)
    {
        RtlStringCchCopyA(strBuffer, cchBuffer,
                          MUIGetString(STRING_FORMATUNUSED));
    }
    else if (IsContainerPartition(PartEntry->PartitionType))
    {
        RtlStringCchCopyA(strBuffer, cchBuffer,
                          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)
                {
                    RtlStringCchCopyA(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))
                {
                    RtlStringCchCopyA(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'))
    {
        RtlStringCchPrintfA(strBuffer, cchBuffer,
                            MUIGetString(STRING_PARTTYPE),
                            PartEntry->PartitionType);
    }
}

Referenced by PartitionDescription().

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 DeletePartitionPage(), PrintPartitionData(), and SelectFileSystemPage().

PrettifySize1()

VOID PrettifySize1	(	IN OUT PULONGLONG	Size,
		OUT PCSTR *	Unit
	)

Definition at line 96 of file partlist.c.

{
    ULONGLONG DiskSize = *Size;
 
    if (DiskSize >= 10 * GB) /* 10 GB */
    {
        DiskSize = RoundingDivide(DiskSize, GB);
        *Unit = MUIGetString(STRING_GB);
    }
    else
    {
        DiskSize = RoundingDivide(DiskSize, MB);
        if (DiskSize == 0)
            DiskSize = 1;
        *Unit = MUIGetString(STRING_MB);
    }
 
    *Size = DiskSize;
}

Referenced by DiskDescription().

PrettifySize2()

VOID PrettifySize2	(	IN OUT PULONGLONG	Size,
		OUT PCSTR *	Unit
	)

Definition at line 119 of file partlist.c.

{
    ULONGLONG PartSize = *Size;
 
#if 0
    if (PartSize >= 10 * GB) /* 10 GB */
    {
        PartSize = RoundingDivide(PartSize, GB);
        *Unit = MUIGetString(STRING_GB);
    }
    else
#endif
    if (PartSize >= 10 * MB) /* 10 MB */
    {
        PartSize = RoundingDivide(PartSize, MB);
        *Unit = MUIGetString(STRING_MB);
    }
    else
    {
        PartSize = RoundingDivide(PartSize, KB);
        *Unit = MUIGetString(STRING_KB);
    }
 
    *Size = PartSize;
}

Referenced by PartitionDescription().

PrintDiskData()

static VOID PrintDiskData ( IN PPARTLIST_UI  ListUi, IN PDISKENTRY  DiskEntry  )

static

Definition at line 501 of file partlist.c.

{
    PPARTENTRY PrimaryPartEntry, LogicalPartEntry;
    PLIST_ENTRY PrimaryEntry, LogicalEntry;
    COORD coPos;
    ULONG Written;
    USHORT Width;
    USHORT Height;
    CHAR LineBuffer[100];
 
    DiskDescription(DiskEntry, LineBuffer, ARRAYSIZE(LineBuffer));
 
    Width = ListUi->Right - ListUi->Left - 1;
    Height = ListUi->Bottom - ListUi->Top - 2;
 
    coPos.X = ListUi->Left + 1;
    coPos.Y = ListUi->Top + 1 + ListUi->Line;
 
    if (ListUi->Line >= 0 && ListUi->Line <= Height)
    {
        FillConsoleOutputAttribute(StdOutput,
                                   FOREGROUND_WHITE | BACKGROUND_BLUE,
                                   Width,
                                   coPos,
                                   &Written);
 
        FillConsoleOutputCharacterA(StdOutput,
                                    ' ',
                                    Width,
                                    coPos,
                                    &Written);
    }
 
    coPos.X++;
    if (ListUi->Line >= 0 && ListUi->Line <= Height)
    {
        WriteConsoleOutputCharacterA(StdOutput,
                                     LineBuffer,
                                     min((USHORT)strlen(LineBuffer), Width - 2),
                                     coPos,
                                     &Written);
    }
 
    ListUi->Line++;
 
    /* Print separator line */
    PrintEmptyLine(ListUi);
 
    /* Print partition lines */
    for (PrimaryEntry = DiskEntry->PrimaryPartListHead.Flink;
         PrimaryEntry != &DiskEntry->PrimaryPartListHead;
         PrimaryEntry = PrimaryEntry->Flink)
    {
        PrimaryPartEntry = CONTAINING_RECORD(PrimaryEntry, PARTENTRY, ListEntry);
 
        PrintPartitionData(ListUi,
                           DiskEntry,
                           PrimaryPartEntry);
 
        if (IsContainerPartition(PrimaryPartEntry->PartitionType))
        {
            for (LogicalEntry = DiskEntry->LogicalPartListHead.Flink;
                 LogicalEntry != &DiskEntry->LogicalPartListHead;
                 LogicalEntry = LogicalEntry->Flink)
            {
                LogicalPartEntry = CONTAINING_RECORD(LogicalEntry, PARTENTRY, ListEntry);
 
                PrintPartitionData(ListUi,
                                   DiskEntry,
                                   LogicalPartEntry);
            }
        }
    }
 
    /* Print separator line */
    PrintEmptyLine(ListUi);
}

Referenced by DrawPartitionList().

PrintEmptyLine()

static VOID PrintEmptyLine ( IN PPARTLIST_UI  ListUi )

static

Definition at line 408 of file partlist.c.

{
    COORD coPos;
    ULONG Written;
    USHORT Width;
    USHORT Height;
 
    Width = ListUi->Right - ListUi->Left - 1;
    Height = ListUi->Bottom - ListUi->Top - 2;
 
    coPos.X = ListUi->Left + 1;
    coPos.Y = ListUi->Top + 1 + ListUi->Line;
 
    if (ListUi->Line >= 0 && ListUi->Line <= Height)
    {
        FillConsoleOutputAttribute(StdOutput,
                                   FOREGROUND_WHITE | BACKGROUND_BLUE,
                                   Width,
                                   coPos,
                                   &Written);
 
        FillConsoleOutputCharacterA(StdOutput,
                                    ' ',
                                    Width,
                                    coPos,
                                    &Written);
    }
 
    ListUi->Line++;
}

Referenced by PrintDiskData().

PrintPartitionData()

static VOID PrintPartitionData ( IN PPARTLIST_UI  ListUi, IN PDISKENTRY  DiskEntry, IN PPARTENTRY  PartEntry  )

static

Definition at line 442 of file partlist.c.

{
    COORD coPos;
    ULONG Written;
    USHORT Width;
    USHORT Height;
    UCHAR Attribute;
    CHAR LineBuffer[100];
 
    PartitionDescription(PartEntry, LineBuffer, ARRAYSIZE(LineBuffer));
 
    Width = ListUi->Right - ListUi->Left - 1;
    Height = ListUi->Bottom - ListUi->Top - 2;
 
    coPos.X = ListUi->Left + 1;
    coPos.Y = ListUi->Top + 1 + ListUi->Line;
 
    Attribute = (ListUi->CurrentDisk == DiskEntry &&
                 ListUi->CurrentPartition == PartEntry) ?
                 FOREGROUND_BLUE | BACKGROUND_WHITE :
                 FOREGROUND_WHITE | BACKGROUND_BLUE;
 
    if (ListUi->Line >= 0 && ListUi->Line <= Height)
    {
        FillConsoleOutputCharacterA(StdOutput,
                                    ' ',
                                    Width,
                                    coPos,
                                    &Written);
    }
    coPos.X += 4;
    Width -= 8;
    if (ListUi->Line >= 0 && ListUi->Line <= Height)
    {
        FillConsoleOutputAttribute(StdOutput,
                                   Attribute,
                                   Width,
                                   coPos,
                                   &Written);
    }
    coPos.X++;
    Width -= 2;
    if (ListUi->Line >= 0 && ListUi->Line <= Height)
    {
        WriteConsoleOutputCharacterA(StdOutput,
                                     LineBuffer,
                                     min(strlen(LineBuffer), Width),
                                     coPos,
                                     &Written);
    }
 
    ListUi->Line++;
}

Referenced by PrintDiskData().

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().