windows-xp/Source/XPSP1/NT/sdktools/efinvram/menu.c

/*++

Copyright (c) 1993 Microsoft Corporation

Module Name:

    spmenu.c

Abstract:

    Text setup menu support.

Author:

    Ted Miller (tedm) 8-September-1993

Revision History:

--*/


#include "efinvram.h"

WCHAR line[512];

HANDLE InputHandle;
HANDLE OutputHandle;
HANDLE OriginalOutputHandle = NULL;
CONSOLE_SCREEN_BUFFER_INFO OriginalConsoleInfo;
CONSOLE_CURSOR_INFO OriginalCursorInfo;
DWORD OriginalInputMode;
WORD NormalAttribute;
WORD HighlightAttribute;
DWORD NumberOfColumns;
DWORD NumberOfRows;
DWORD NumberOfMenuLines;

#define MENUITEM_NORMAL     0x00000000
#define MENUITEM_STATIC     0x00000001


typedef struct _MENU_ITEM {

    PWSTR Text;

    ULONG Flags;

    ULONG LeftX;

    ULONG_PTR UserData;

    SIZE_T OriginalLength;

} MENU_ITEM, *PMENU_ITEM;


typedef struct _MENU {

    PMENU_ITEM Items;
    ULONG      ItemCount;

    ULONG      TopY;
    ULONG      Height;

    ULONG      LeftX;
    ULONG      Width;

    ULONG      TopDisplayedIndex;

    BOOLEAN    MoreUp,MoreDown;

} MENU, *PMENU;


BOOL
AddItems (
    PVOID Menu,
    PWSTR StaticText,
    PLIST_ENTRY ListHead
    );

VOID
DisplayMainMenuKeys (
    VOID
    );

VOID
DisplayEditMenuKeys (
    VOID
    );

VOID
EditBootEntry (
    IN PMY_BOOT_ENTRY BootEntry,
    IN OUT PBOOL ChangesMade
    );

VOID
EditTimeout (
    IN OUT PBOOL ChangesMade
    );

BOOL
PromptToSaveChanges (
    VOID
    );

PVOID
SpMnCreate(
    IN ULONG   LeftX,
    IN ULONG   TopY,
    IN ULONG   Width,
    IN ULONG   Height
    );

VOID
SpMnDestroy(
    IN PVOID Menu
    );

BOOLEAN
SpMnAddItem(
    IN PVOID   Menu,
    IN PWSTR   Text,
    IN ULONG   LeftX,
    IN ULONG   Width,
    IN BOOLEAN Selectable,
    IN ULONG_PTR UserData
    );

PWSTR
SpMnGetText(
    IN PVOID Menu,
    IN ULONG_PTR UserData
    );

PWSTR
SpMnGetTextDup(
    IN PVOID Menu,
    IN ULONG_PTR UserData
    );

VOID
SpMnDisplay(
    IN  PVOID                  Menu,
    IN  ULONG_PTR              UserDataOfHighlightedItem,
    IN  PULONG                 ValidKeys,
    OUT PULONG                 KeyPressed,
    OUT PULONG_PTR             UserDataOfSelectedItem
    );

VOID
SpMnClearArea (
    IN ULONG Top,
    IN ULONG Bottom
    );

ULONG
SpWaitValidKey(
    IN PULONG ValidKeys1,
    IN PULONG ValidKeys2 OPTIONAL
    );

VOID
WriteConsoleLine (
    ULONG Row,
    ULONG Column,
    PWSTR Text,
    BOOL Highlight
    );

VOID
pSpMnDrawMenu(
    IN PMENU   pMenu,
    IN ULONG   SelectedIndex,
    IN BOOLEAN IndicateMore,
    IN PWSTR   MoreUpText,
    IN PWSTR   MoreDownText
    );


PVOID
SpMnCreate(
    IN ULONG   LeftX,
    IN ULONG   TopY,
    IN ULONG   Width,
    IN ULONG   Height
    )

/*++

Routine Description:

    Create a new menu by allocating space for a new menu structure
    and initializing its fields.

Arguments:

    LeftX - supplies the 0-based X coordinate of the leftmost column
        of the menu.

    TopY - supplies the 0-based Y coordinate of the topmost line
        of the menu.

    Width - supplies the maximum displayed width for lines in the menu.

    Height - supplies the maximum displayed height of the menu.
        The menu will scroll if it is too long to fit in the
        allotted space.

Return Value:

    Menu handle (expressed as a pvoid) of NULL if memory couldn't
    be allocated.

--*/

{
    PMENU p;

    p = MemAlloc( sizeof(MENU) );

    RtlZeroMemory( p, sizeof(MENU) );

    p->Items = MemAlloc( 0 );
    p->LeftX = LeftX;
    p->TopY = TopY;
    p->Width = Width;
    p->Height = Height;

    return p;
}


VOID
SpMnDestroy(
    IN PVOID Menu
    )

/*++

Routine Description:

    Destroy a menu, releasing all memory associated with it.

Arguments:

    Menu - supplies handle to menu to destroy.

Return Value:

    None.

--*/

{
    PMENU pMenu = Menu;
    ULONG u;


    for(u=0; u<pMenu->ItemCount; u++) {
        if(pMenu->Items[u].Text) {
            MemFree(pMenu->Items[u].Text);
        }
    }

    MemFree(pMenu->Items);

    MemFree(pMenu);
}



BOOLEAN
SpMnAddItem(
    IN PVOID   Menu,
    IN PWSTR   Text,
    IN ULONG   LeftX,
    IN ULONG   Width,
    IN BOOLEAN Selectable,
    IN ULONG_PTR UserData
    )

/*++

Routine Description:

    Add an item to a menu.

Arguments:

    Menu - supplies handle to menu to which the item is to be added.

    Text - supplies text that comprises the menu selection.  This routine
        will make a copy of the text.

    LeftX - supplies 0-based x coordinate of leftmost character of the text
        when it is displayed.

    Width - supplies width in characters of the field for this selection.
        If this is larger than the number of characters in the text, then
        the text is padded to the right with blanks when highlighted.

    Selectable - if FALSE, then this text is static -- ie, not selectable.

    UserData - supplies a ulong's worth of caller-specific data to be associated
        with this menu item.

Return Value:

    TRUE if the menu item was added successfully; FALSE if insufficient memory.

--*/

{
    PMENU pMenu = Menu;
    PMENU_ITEM p;
    SIZE_T TextLen;
    SIZE_T PaddedLen;
    PWSTR String;
    ULONG u;
    SIZE_T ColumnLen;
    SIZE_T FillLen;

    //
    // Build a string that is padded to the right with blanks to make
    // it the right width.
    //
    TextLen = wcslen(Text);
    PaddedLen = max(TextLen,Width);
    ColumnLen = TextLen;
    FillLen = (PaddedLen <= ColumnLen) ? 0 : PaddedLen - ColumnLen;

    String = MemAlloc((PaddedLen+1)*sizeof(WCHAR));
    if(!String) {
        return(FALSE);
    }

    wcsncpy(String,Text,TextLen);
    for(u=0; u<FillLen; u++) {
        String[TextLen+u] = L' ';
    }
    String[TextLen+u] = 0;

    //
    // Make space for the item.
    //
    if((p = MemRealloc(pMenu->Items,(pMenu->ItemCount+1) * sizeof(MENU_ITEM))) == NULL) {
        MemFree(String);
        return(FALSE);
    }

    pMenu->Items = p;

    //
    // Calculate the address of the new menu item and
    // indicate that there is now an additional item in the menu.
    //
    p = &pMenu->Items[pMenu->ItemCount++];

    //
    // Set the fields of the menu.
    //
    p->LeftX = LeftX;
    p->UserData = UserData;

    p->Flags = Selectable ? MENUITEM_NORMAL : MENUITEM_STATIC;

    p->Text = String;

    p->OriginalLength = TextLen;

    return(TRUE);
}


PWSTR
SpMnGetText(
    IN PVOID Menu,
    IN ULONG_PTR UserData
    )
{
    PMENU pMenu = Menu;
    ULONG i;

    for(i=0; i<pMenu->ItemCount; i++) {
        if(pMenu->Items[i].UserData == UserData) {
            return(pMenu->Items[i].Text);
        }
    }

    return(NULL);
}

PWSTR
SpMnGetTextDup(
    IN PVOID Menu,
    IN ULONG_PTR UserData
    )
{
    PMENU pMenu = Menu;
    ULONG i;
    PWSTR p;

    for(i=0; i<pMenu->ItemCount; i++) {
        if(pMenu->Items[i].UserData == UserData) {
            //
            // Make a duplicate; leave off trailing pad spaces.
            //
            p = MemAlloc((pMenu->Items[i].OriginalLength+1)*sizeof(WCHAR));
            wcsncpy(p,pMenu->Items[i].Text,pMenu->Items[i].OriginalLength);
            p[pMenu->Items[i].OriginalLength] = 0;
            return(p);
        }
    }

    return(NULL);
}


VOID
SpMnDisplay(
    IN  PVOID                  Menu,
    IN  ULONG_PTR              UserDataOfHighlightedItem,
    IN  PULONG                 ValidKeys,
    OUT PULONG                 KeyPressed,
    OUT PULONG_PTR             UserDataOfSelectedItem
    )

/*++

Routine Description:

    Display a menu and accept keystrokes.

    When the user presses a menu keystroke (up/down arrow keys), this
    routine automatically updates the highlight and calls a callback function
    to inform the caller that a new item has the highlight.

    When the user presses a keystroke in a list provided by the caller,
    this routine returns, providing information about the key pressed and
    the item that was highlighted when the key was pressed.

Arguments:

    Menu - supplies handle to menu to be displayed.

    UserDataOfHighlightedItem - supplies user data of the menu item which
        is to receive the highlight initially.

    ValidKeys - supplies a list of keystrokes that cause this routine to
        return to the caller.  The list must be terminated with a 0 entry.

    KeyPressed - receives the key press that caused this routine to exit.
        This will be a valid from the ValidKeys array.

    UserDataOfSelectedItem - receives the UserData of the item that had the
        highlight when the user pressed a key in ValidKeys.

Return Value:

    None.

--*/


{
    ULONG ValidMenuKeys[3] = { VK_UP, VK_DOWN, 0 };
    ULONG key;
    PMENU pMenu = Menu;
    ULONG SelectedIndex,OldIndex;
    BOOLEAN FoundNewItem;
    ULONG NewTopDisplayedIndex;
    BOOLEAN MustScroll;
    PWSTR MoreUpText,MoreDownText;
    CONSOLE_CURSOR_INFO cursorInfo;

    cursorInfo = OriginalCursorInfo;
    cursorInfo.bVisible = FALSE;
    SetConsoleCursorInfo( OutputHandle, &cursorInfo );

    //
    // Get the text for the text that indicate that there are more
    // selections.
    //
    MoreUpText =   L"[More above...]";
    MoreDownText = L"[More below...]";

    //
    // Locate the seleccted item.
    //
    for(SelectedIndex=0; SelectedIndex<pMenu->ItemCount; SelectedIndex++) {
        if(!(pMenu->Items[SelectedIndex].Flags & MENUITEM_STATIC)
        && (pMenu->Items[SelectedIndex].UserData == UserDataOfHighlightedItem))
        {
            break;
        }
    }
    ASSERT(SelectedIndex < pMenu->ItemCount);

    //
    // Make sure the selected item will be visible when we draw the menu.
    //
    pMenu->TopDisplayedIndex = 0;
    while(SelectedIndex >= pMenu->TopDisplayedIndex + pMenu->Height) {
        pMenu->TopDisplayedIndex += pMenu->Height;
    }

    //
    // Draw the menu itself.
    //
    pSpMnDrawMenu(pMenu,SelectedIndex,TRUE,MoreUpText,MoreDownText);

    while ( TRUE ) {

        //
        // Wait for a valid keypress.
        //
        key = SpWaitValidKey(ValidKeys,ValidMenuKeys);

        //
        // If the key is a menu keystroke, handle it here.
        //
        FoundNewItem = FALSE;
        MustScroll = FALSE;
        NewTopDisplayedIndex = 0;
        OldIndex = SelectedIndex;

        switch(key) {

        case VK_UP:

            //
            // Locate the previous selectable item.
            //
            if(SelectedIndex) {

                for(SelectedIndex=SelectedIndex-1; (LONG)SelectedIndex>=0; SelectedIndex--) {
                    if(!(pMenu->Items[SelectedIndex].Flags & MENUITEM_STATIC)) {
                        FoundNewItem = TRUE;
                        break;
                    }
                }

                if(FoundNewItem) {
                    //
                    // Figure out whether we have to scroll the menu.
                    //
                    if(SelectedIndex < pMenu->TopDisplayedIndex) {
                        MustScroll = TRUE;
                        NewTopDisplayedIndex = SelectedIndex;
                    }
                } else {
                    //
                    // If the first lines are static text, there might be no
                    // way to get them back on the screen -- the tests above
                    // fail in this case.  So if the user hits the up arrow
                    // when he's at the topmost selectable item but there are
                    // static items above him, we'll simply scroll the menu
                    // so that item #0 is at the top.
                    //
                    FoundNewItem = TRUE;
                    NewTopDisplayedIndex = 0;
                    MustScroll = TRUE;
                    SelectedIndex = OldIndex;
                }
            }
            break;

        case VK_DOWN:

            //
            // Locate the next selectable item.
            //
            if(SelectedIndex < pMenu->ItemCount) {

                for(SelectedIndex=SelectedIndex+1; SelectedIndex < pMenu->ItemCount; SelectedIndex++) {

                    if(!(pMenu->Items[SelectedIndex].Flags & MENUITEM_STATIC)) {
                        FoundNewItem = TRUE;
                        break;
                    }
                }

                if(FoundNewItem) {
                    //
                    // Figure out whether we have to scroll the menu.
                    //
                    if(SelectedIndex >= pMenu->TopDisplayedIndex + pMenu->Height) {
                        MustScroll = TRUE;
                        NewTopDisplayedIndex = pMenu->TopDisplayedIndex + SelectedIndex - OldIndex;
                    }
                }
            }
            break;

        default:

            //
            // User pressed a non-menu key.
            //
            *KeyPressed = key;
            *UserDataOfSelectedItem = pMenu->Items[SelectedIndex].UserData;

            SetConsoleCursorInfo( OutputHandle, &OriginalCursorInfo );
            return;
        }


        if(FoundNewItem) {

            //
            // Unhighlight the currently selected item.
            //
            WriteConsoleLine(
                pMenu->TopY + OldIndex - pMenu->TopDisplayedIndex,
                pMenu->Items[OldIndex].LeftX,
                pMenu->Items[OldIndex].Text,
                FALSE
                );


            //
            // Highlight the newly selected item.  This may involve
            // scrolling the menu.
            //
            if(MustScroll) {
                //
                // Redraw the menu so the newly highlighted line is in view.
                //
                pMenu->TopDisplayedIndex = NewTopDisplayedIndex;

                pSpMnDrawMenu(pMenu,SelectedIndex,TRUE,MoreUpText,MoreDownText);
            }

            //
            // Highlight the newly selected item.
            //
            WriteConsoleLine(
                pMenu->TopY + SelectedIndex - pMenu->TopDisplayedIndex,
                pMenu->Items[SelectedIndex].LeftX,
                pMenu->Items[SelectedIndex].Text,
                TRUE
                );


        } else {
            SelectedIndex = OldIndex;
        }
    }
}


VOID
pSpMnDrawMenu(
    IN PMENU   pMenu,
    IN ULONG   SelectedIndex,
    IN BOOLEAN IndicateMore,
    IN PWSTR   MoreUpText,
    IN PWSTR   MoreDownText
    )
{
    ULONG item;
    BOOLEAN MoreUp,MoreDown,MoreStatusChanged;

    //
    // Blank out the on-screen menu display.
    //
    for ( item = pMenu->TopY; item < (pMenu->TopY + pMenu->Height); item++ ) {
        WriteConsoleLine( item, 0, NULL, FALSE );
    }


    MoreUp = (BOOLEAN)(pMenu->TopDisplayedIndex > 0);
    MoreDown = (BOOLEAN)(pMenu->TopDisplayedIndex + pMenu->Height < pMenu->ItemCount);

    MoreStatusChanged = (BOOLEAN)(    IndicateMore
                                   && (    (pMenu->MoreUp != MoreUp)
                                        || (pMenu->MoreDown != MoreDown)
                                      )
                                 );

    //
    // Draw each item that is currently on-screen.
    //
    ASSERT(pMenu->TopDisplayedIndex < pMenu->ItemCount);
    for(item = pMenu->TopDisplayedIndex;
        item < min(pMenu->TopDisplayedIndex+pMenu->Height,pMenu->ItemCount);
        item++)
    {
        WriteConsoleLine(
            pMenu->TopY + item - pMenu->TopDisplayedIndex,
            pMenu->Items[item].LeftX,
            pMenu->Items[item].Text,
            (BOOLEAN)(item == SelectedIndex)
            );
    }


    //
    // If there are more selections above or below us,
    // indicate so by placing a small bit of text on the frame.
    // Note that the arrow chars can sometimes be DBCS.
    //
    if(MoreStatusChanged) {

        if(MoreUp) {
            WriteConsoleLine(
                pMenu->TopY - 1,
                pMenu->LeftX + 4,
                MoreUpText,
                FALSE
                );
        } else {
            WriteConsoleLine(
                pMenu->TopY - 1,
                0,
                NULL,
                FALSE
                );
        }

        if(MoreDown) {
            WriteConsoleLine(
                pMenu->TopY + pMenu->Height,
                pMenu->LeftX + 4,
                MoreDownText,
                FALSE
                );
        } else {
            WriteConsoleLine(
                pMenu->TopY + pMenu->Height,
                0,
                NULL,
                FALSE
                );
        }

        pMenu->MoreUp = MoreUp;
        pMenu->MoreDown = MoreDown;
    }
}

VOID
InitializeMenuSystem (
    VOID
    )
{
    DWORD error;
    COORD windowSize;
    CONSOLE_CURSOR_INFO cursorInfo;
    cursorInfo = OriginalCursorInfo;
    cursorInfo.bVisible = FALSE;

    InputHandle = GetStdHandle( STD_INPUT_HANDLE );
    if ( InputHandle == NULL ) {
        error = GetLastError( );
        FatalError( error, L"Unable to get stdin handle: %d\n", error );
    }

    if ( !GetConsoleMode( InputHandle, &OriginalInputMode ) ) {
        error = GetLastError( );
        FatalError( error, L"Unable to get stdin mode: %d\n", error );
    }

    OriginalOutputHandle = GetStdHandle( STD_OUTPUT_HANDLE );
    if ( OriginalOutputHandle == NULL ) {
        error = GetLastError( );
        FatalError( error, L"Unable to get stdout handle: %d\n", error );
    }

    OutputHandle = CreateConsoleScreenBuffer(
                        GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_WRITE | FILE_SHARE_READ,
                        NULL,
                        CONSOLE_TEXTMODE_BUFFER,
                        NULL
                        );
    if ( OutputHandle == NULL ) {
        error = GetLastError( );
        FatalError( error, L"Unable to create console screen buffer: %d\n", error );
    }

    if ( !GetConsoleScreenBufferInfo( OriginalOutputHandle, &OriginalConsoleInfo ) ) {
        error = GetLastError( );
        FatalError( error, L"Unable to get console screen buffer info: %d\n", error );
    }
    
    if ( !GetConsoleCursorInfo( OriginalOutputHandle, &OriginalCursorInfo ) ) {
        error = GetLastError( );
        FatalError( error, L"Unable to get console screen buffer info: %d\n", error );
    }
    
    NormalAttribute = 0x1F;
    HighlightAttribute = 0x71;
    NumberOfColumns = OriginalConsoleInfo.srWindow.Right - OriginalConsoleInfo.srWindow.Left + 1;
    NumberOfRows = OriginalConsoleInfo.srWindow.Bottom - OriginalConsoleInfo.srWindow.Top + 1;
    NumberOfMenuLines = NumberOfRows - (3 + 1 + 1 + 1 + 8);
    if ( NumberOfMenuLines > 12 ) {
        NumberOfMenuLines = 12;
    }

    if ( NumberOfRows < 20 ) {
        FatalError(
            ERROR_INVALID_PARAMETER,
            L"Please run this program in a console window with 20 or more lines\n"
            );
    }
    if ( NumberOfColumns < 80 ) {
        FatalError(
            ERROR_INVALID_PARAMETER,
            L"Please run this program in a console window with 80 or more columns\n"
            );
    }

    windowSize.X = (SHORT)NumberOfColumns;
    windowSize.Y = (SHORT)NumberOfRows;

    if ( !SetConsoleScreenBufferSize( OutputHandle, windowSize ) ) {
        error = GetLastError( );
        FatalError( error, L"Unable to set console screen buffer size: %d\n", error );
    }

    if ( !SetConsoleActiveScreenBuffer( OutputHandle ) ) {
        error = GetLastError( );
        FatalError( error, L"Unable to set active screen buffer: %d\n", error );
    }

    if ( !SetConsoleMode( InputHandle, 0 ) ) {
        error = GetLastError( );
        FatalError( error, L"Unable to set console mode: %d\n", error );
    }

    return;

} // InitializeMenuSystem

VOID
FatalError (
    DWORD Error,
    PWSTR Format,
    ...
    )
{
    va_list marker;

    if ( OutputHandle != NULL ) {
        SetConsoleCursorInfo( OutputHandle, &OriginalCursorInfo );
        CloseHandle( OutputHandle );
        if ( OriginalOutputHandle != NULL ) {
            SetConsoleActiveScreenBuffer( OriginalOutputHandle );
            SetConsoleMode( InputHandle, OriginalInputMode );
        }
    }

    va_start( marker, Format );
    vwprintf( Format, marker );
    va_end( marker );

    if ( Error == NO_ERROR ) {
        Error = ERROR_GEN_FAILURE;
    }
    exit( Error );

} // FatalError

VOID
WriteConsoleLine (
    ULONG Row,
    ULONG Column,
    PWSTR Text,
    BOOL Highlight
    )
{
    BOOL ok;
    DWORD error;
    COORD writeCoord;
    DWORD numberWritten;
    DWORD textLength;

    writeCoord.X = 0;
    writeCoord.Y = (SHORT)Row;

    ok = FillConsoleOutputCharacter(
            OutputHandle,
            ' ',
            NumberOfColumns,
            writeCoord,
            &numberWritten
            );
    if ( !ok ) {
        error = GetLastError( );
        FatalError( error, L"Error filling console line: %d\n", error );
    }

    ok = FillConsoleOutputAttribute(
            OutputHandle,
            OriginalConsoleInfo.wAttributes,
            NumberOfColumns,
            writeCoord,
            &numberWritten
            );
    if ( !ok ) {
        error = GetLastError( );
        FatalError( error, L"Error filling console attributes: %d\n", error );
    }

    if ( (Text == NULL) || ((textLength = (DWORD)wcslen( Text )) == 0) ) {
        return;
    }

    writeCoord.X = (SHORT)Column;

    ok = WriteConsoleOutputCharacter(
            OutputHandle,
            Text,
            textLength,
            writeCoord,
            &numberWritten
            );
    if ( !ok ) {
        error = GetLastError( );
        FatalError( error, L"Error writing console line: %d\n", error );
    }

    if (Highlight) {

        WORD attr = ((OriginalConsoleInfo.wAttributes & 0xf0) >> 4) +
                    ((OriginalConsoleInfo.wAttributes & 0x0f) << 4);

        ok = FillConsoleOutputAttribute(
                OutputHandle,
                attr,
                textLength,
                writeCoord,
                &numberWritten
                );
        if ( !ok ) {
            error = GetLastError( );
            FatalError( error, L"Error writing console attributes: %d\n", error );
        }
    }

    return;

} // WriteConsoleLine

ULONG
SpWaitValidKey(
    IN PULONG ValidKeys1,
    IN PULONG ValidKeys2 OPTIONAL
    )

/*++

Routine Description:

    Wait for a key to be pressed that appears in a list of valid keys.

Arguments:

    ValidKeys1 - supplies list of valid keystrokes.  The list must be
        terminated with a 0 entry.

    ValidKeys2 - if specified, supplies an additional list of valid keystrokes.

Return Value:

    The key that was pressed (see above).

--*/

{
    ULONG c;
    ULONG i;
    INPUT_RECORD InputRecord;
    ULONG NumberOfInputRecords;

    FlushConsoleInputBuffer( InputHandle );

    while ( TRUE ) {

        WaitForSingleObject( InputHandle, INFINITE );
        if ( ReadConsoleInput( InputHandle, &InputRecord, 1, &NumberOfInputRecords ) &&
             InputRecord.EventType == KEY_EVENT &&
             InputRecord.Event.KeyEvent.bKeyDown ) {

            c = InputRecord.Event.KeyEvent.wVirtualKeyCode;

            //
            // Check for normal key.
            //
    
            for(i=0; ValidKeys1[i]; i++) {
                if(c == ValidKeys1[i]) {
                    return(c);
                }
            }
    
            //
            // Check secondary list.
            //
            if(ValidKeys2) {
                for(i=0; ValidKeys2[i]; i++) {
                    if(c == ValidKeys2[i]) {
                        return(c);
                    }
                }
            }
        }
    }
}

VOID
SpMnClearArea (
    IN ULONG Top,
    IN ULONG Bottom
    )
{
    ULONG row;

    for ( row = Top; row <= Bottom; row++ ) {
        WriteConsoleLine( row, 0, NULL, FALSE );
    }

    return;

} // SpMnClearArea

VOID
MainMenu (
    VOID
    )
{
    BOOL b;
    PLIST_ENTRY listEntry;
    PLIST_ENTRY listEntry2;
    PMY_BOOT_ENTRY bootEntry;
    PMY_BOOT_ENTRY currentBootEntry;
    ULONG validKeys[] = {
        VK_ESCAPE,
        VK_RETURN,
        VK_PRIOR,
        VK_NEXT,
        VK_HOME,
        VK_END,
        VK_DELETE,
        'Q',
        'U',
        'D',
        'T',
        'B',
        'X',
        'A',
        'O',
        'E',
        'M',
        'S',
        0
        };
    PVOID menu;
    ULONG pressedKey;
    BOOL changesMade = FALSE;

    WriteConsoleLine( 1, 1, L"Windows Whistler EFI NVRAM Editor", FALSE );

    listEntry = BootEntries.Flink;
    if ( listEntry != &BootEntries ) {
        currentBootEntry = CONTAINING_RECORD( listEntry, MY_BOOT_ENTRY, ListEntry );
    } else {
        currentBootEntry = NULL;
    }

    while ( TRUE ) {

        menu = SpMnCreate( 4, 4, NumberOfColumns - 4, NumberOfMenuLines );

        b = AddItems(
                menu,
                NULL,
                &BootEntries
                );
        b |= AddItems(
                menu,
                L"The following boot entries are marked active, but are not in the boot order list:",
                &ActiveUnorderedBootEntries
                );
        b |= AddItems(
                menu,
                L"The following boot entries are marked inactive, and are not in the boot order list:",
                &InactiveUnorderedBootEntries
                );

        if ( !b ) {
    
            swprintf( line, L"No boot entries to display" );
            SpMnAddItem(
                menu,
                line,
                4,
                (ULONG)wcslen( line ),
                TRUE,
                (ULONG_PTR)NULL
                );
            currentBootEntry = NULL;
        }
    
        DisplayMainMenuKeys( );

        SpMnDisplay(
            menu,
            (ULONG_PTR)currentBootEntry,
            validKeys,
            &pressedKey,
            (ULONG_PTR *)&bootEntry
            );
    
        SpMnDestroy( menu );

        if ( (pressedKey == 'Q') || (pressedKey == VK_ESCAPE) ) {
            if ( changesMade ) {
                if ( PromptToSaveChanges( ) ) {
                    ClearMenuArea( );
                    SaveChanges( NULL );
                }
            }
            break;
        }

        if ( bootEntry != NULL ) {

            currentBootEntry = bootEntry;

            if ( bootEntry->ListHead == &BootEntries ) {
            
                if ( (pressedKey == 'U') || (pressedKey == VK_PRIOR) ) {
    
                    listEntry2 = bootEntry->ListEntry.Blink;
                    if ( listEntry2 != &BootEntries ) {
                        RemoveEntryList( &bootEntry->ListEntry );
                        InsertTailList( listEntry2, &bootEntry->ListEntry );
                        changesMade = TRUE;
                    }
                    continue;
            
                } else if ( (pressedKey == 'D') || (pressedKey == VK_NEXT) ) {
    
                    listEntry2 = bootEntry->ListEntry.Flink;
                    if ( listEntry2 != &BootEntries ) {
                        RemoveEntryList( &bootEntry->ListEntry );
                        InsertHeadList( listEntry2, &bootEntry->ListEntry );
                        changesMade = TRUE;
                    }
                    continue;
            
                } else if ( (pressedKey == 'T') || (pressedKey == VK_HOME) ) {
    
                    listEntry2 = bootEntry->ListEntry.Blink;
                    if ( listEntry2 != &BootEntries ) {
                        RemoveEntryList( &bootEntry->ListEntry );
                        InsertHeadList( &BootEntries, &bootEntry->ListEntry );
                        changesMade = TRUE;
                    }
                    continue;
            
                } else if ( (pressedKey == 'B') || (pressedKey == VK_END) ) {
    
                    listEntry2 = bootEntry->ListEntry.Flink;
                    if ( listEntry2 != &BootEntries ) {
                        RemoveEntryList( &bootEntry->ListEntry );
                        InsertTailList( &BootEntries, &bootEntry->ListEntry );
                        changesMade = TRUE;
                    }
                    continue;
                }
        
            }

            if ( (pressedKey == 'X') || (pressedKey == VK_DELETE) ) {

                MBE_SET_DELETED( bootEntry );
                listEntry2 = bootEntry->ListEntry.Flink;
                currentBootEntry = CONTAINING_RECORD( listEntry2, MY_BOOT_ENTRY, ListEntry );
                if ( listEntry2 == bootEntry->ListHead ) {
                    listEntry2 = bootEntry->ListEntry.Blink;
                    currentBootEntry = CONTAINING_RECORD( listEntry2, MY_BOOT_ENTRY, ListEntry );
                    if ( listEntry2 == bootEntry->ListHead ) {
                        currentBootEntry = NULL;
                    }
                }
                RemoveEntryList( &bootEntry->ListEntry );
                InsertTailList( &DeletedBootEntries, &bootEntry->ListEntry );
                bootEntry->ListHead = &DeletedBootEntries;
                changesMade = TRUE;

            } else if ( (pressedKey == 'E') || (pressedKey == VK_RETURN) ) {

                EditBootEntry( bootEntry, &changesMade );

            } else if ( pressedKey == 'M' ) {

                EditTimeout( &changesMade );

            } else if ( pressedKey == 'S' ) {

                if ( changesMade ) {
                    ClearMenuArea( );
                    currentBootEntry = SaveChanges( currentBootEntry );
                    changesMade = FALSE;
                }

            } else if ( pressedKey == 'A' ) {

                if ( MBE_IS_ACTIVE( bootEntry ) ) {

                    MBE_CLEAR_ACTIVE( bootEntry );
                    MBE_SET_MODIFIED( bootEntry );
                    if ( bootEntry->ListHead == &ActiveUnorderedBootEntries ) {
                        RemoveEntryList( &bootEntry->ListEntry );
                        InsertTailList( &InactiveUnorderedBootEntries, &bootEntry->ListEntry );
                        bootEntry->ListHead = &InactiveUnorderedBootEntries;
                    }

                } else {

                    MBE_SET_ACTIVE( bootEntry );
                    MBE_SET_MODIFIED( bootEntry );
                    if ( bootEntry->ListHead == &InactiveUnorderedBootEntries ) {
                        RemoveEntryList( &bootEntry->ListEntry );
                        InsertTailList( &ActiveUnorderedBootEntries, &bootEntry->ListEntry );
                        bootEntry->ListHead = &ActiveUnorderedBootEntries;
                    }
                }
                changesMade = TRUE;

            } else if ( pressedKey == 'O' ) {

                RemoveEntryList( &bootEntry->ListEntry );

                if ( bootEntry->ListHead == &BootEntries ) {

                    if ( MBE_IS_ACTIVE( bootEntry ) ) {
                        InsertTailList( &ActiveUnorderedBootEntries, &bootEntry->ListEntry );
                        bootEntry->ListHead = &ActiveUnorderedBootEntries;
                    } else {
                        InsertTailList( &InactiveUnorderedBootEntries, &bootEntry->ListEntry );
                        bootEntry->ListHead = &InactiveUnorderedBootEntries;
                    }

                } else {

                    InsertTailList( &BootEntries, &bootEntry->ListEntry );
                    bootEntry->ListHead = &BootEntries;
                }
                changesMade = TRUE;
            }
        }
    }

} // MainMenu

BOOL
AddItems (
    PVOID Menu,
    PWSTR StaticText,
    PLIST_ENTRY ListHead
    )
{
    PLIST_ENTRY listEntry;
    PMY_BOOT_ENTRY bootEntry;

    if ( ListHead->Flink != ListHead ) {

        if ( ARGUMENT_PRESENT(StaticText) ) {
        
            SpMnAddItem(
                Menu,
                L"",
                4,
                0,
                FALSE,
                (ULONG_PTR)NULL
                );
            SpMnAddItem(
                Menu,
                StaticText,
                4,
                (ULONG)wcslen( StaticText ),
                FALSE,
                (ULONG_PTR)NULL
                );
        }

        for ( listEntry = ListHead->Flink;
              listEntry != ListHead;
              listEntry = listEntry->Flink ) {

            PWSTR osDirectoryNtName = NULL;

            bootEntry = CONTAINING_RECORD( listEntry, MY_BOOT_ENTRY, ListEntry );

            if ( MBE_IS_NT( bootEntry ) ) {

                osDirectoryNtName = GetNtNameForFilePath( bootEntry->OsFilePath );
            }

            if ( osDirectoryNtName != NULL) {
                swprintf(
                    line,
                    L"%-40ws %ws",
                    bootEntry->FriendlyName,
                    osDirectoryNtName
                    );
            } else {
                swprintf(
                    line,
                    L"%ws",
                    bootEntry->FriendlyName
                    );
            }
            SpMnAddItem(
                Menu,
                line,
                6,
                (ULONG)wcslen( line ),
                TRUE,
                (ULONG_PTR)bootEntry
                );

            if ( osDirectoryNtName != NULL ) {
                MemFree( osDirectoryNtName );
            }
        }

        return TRUE;
    }

    return FALSE;

} // AddItems

VOID
EditFriendlyName (
    IN OUT PMY_BOOT_ENTRY BootEntry,
    IN OUT PBOOL ChangesMade
    )
{
    COORD position;
    DWORD numberRead;

    SpMnClearArea( 3, 3 + NumberOfMenuLines + 1 );

    swprintf( line, L"Current friendly name: %ws", BootEntry->FriendlyName );
    WriteConsoleLine( 4, 4, line, FALSE );

    swprintf( line, L"    New friendly name: " );
    WriteConsoleLine( 6, 4, line, FALSE );

    position.X = (USHORT)(4 + wcslen( line ));
    position.Y = 6;
    SetConsoleCursorPosition( OutputHandle, position );

    SetConsoleMode( InputHandle, OriginalInputMode );
    ReadConsole( InputHandle, line, 511, &numberRead, NULL );
    SetConsoleMode( InputHandle, 0 );

    if ( numberRead >= 2 ) {
        numberRead -= 2;
    }

    if ( numberRead != 0 ) {

        line[numberRead] = 0;

        if ( wcscmp( BootEntry->FriendlyName, line ) != 0 ) {
            FREE_IF_SEPARATE_ALLOCATION( BootEntry, FriendlyName );
            BootEntry->FriendlyNameLength = (numberRead + 1) * sizeof(WCHAR);
            BootEntry->FriendlyName = MemAlloc( BootEntry->FriendlyNameLength );
            wcscpy( BootEntry->FriendlyName, line );
            MBE_SET_MODIFIED( BootEntry );
            *ChangesMade = TRUE;
        }
    }
    
    return;

} // EditFriendlyName

VOID
EditLoadOptions (
    IN OUT PMY_BOOT_ENTRY BootEntry,
    IN OUT PBOOL ChangesMade
    )
{
    COORD position;
    DWORD numberRead;

    SpMnClearArea( 3, 3 + NumberOfMenuLines + 1 );

    swprintf( line, L"Current load options: %ws", BootEntry->OsLoadOptions );
    WriteConsoleLine( 4, 4, line, FALSE );

    swprintf( line, L"    New load options: " );
    WriteConsoleLine( 6, 4, line, FALSE );

    position.X = (USHORT)(4 + wcslen( line ));
    position.Y = 6;
    SetConsoleCursorPosition( OutputHandle, position );

    SetConsoleMode( InputHandle, OriginalInputMode );
    ReadConsole( InputHandle, line, 511, &numberRead, NULL );
    SetConsoleMode( InputHandle, 0 );

    if ( numberRead >= 2 ) {
        numberRead -= 2;
    }

    if ( numberRead != 0 ) {

        line[numberRead] = 0;

        if ( wcscmp( BootEntry->OsLoadOptions, line ) != 0 ) {
            FREE_IF_SEPARATE_ALLOCATION( BootEntry, OsLoadOptions );
            BootEntry->OsLoadOptionsLength = (numberRead + 1) * sizeof(WCHAR);
            BootEntry->OsLoadOptions = MemAlloc( BootEntry->OsLoadOptionsLength );
            wcscpy( BootEntry->OsLoadOptions, line );
            MBE_SET_MODIFIED( BootEntry );
            *ChangesMade = TRUE;
        }
    }
    
    return;

} // EditLoadOptions

VOID
EditBootEntry (
    IN PMY_BOOT_ENTRY BootEntry,
    IN OUT PBOOL ChangesMade
    )
{
    ULONG numValidKeys;
    ULONG validKeys[20];
    PVOID menu;
    ULONG pressedKey;
    ULONG_PTR itemToEdit;

    while ( TRUE ) {

        menu = SpMnCreate( 4, 4, NumberOfColumns - 4, NumberOfMenuLines );

        numValidKeys = 0;
        validKeys[numValidKeys++] = VK_ESCAPE;
        validKeys[numValidKeys++] = 'Q';
        validKeys[numValidKeys++] = VK_RETURN;
        validKeys[numValidKeys++] = 'E';

        swprintf(
            line,
            L"Friendly name: %ws",
            BootEntry->FriendlyName
            );
        SpMnAddItem(
            menu,
            line,
            4,
            (ULONG)wcslen( line ),
            TRUE,
            1
            );
        validKeys[numValidKeys++] = 'F';

        if ( MBE_IS_NT( BootEntry ) ) {
        
            swprintf(
                line,
                L"Load options: %ws",
                BootEntry->OsLoadOptions
                );
            SpMnAddItem(
                menu,
                line,
                4,
                (ULONG)wcslen( line ),
                TRUE,
                2
                );
            validKeys[numValidKeys++] = 'L';
        }
    
        validKeys[numValidKeys] = 0;

        DisplayEditMenuKeys( );

        SpMnDisplay(
            menu,
            1,
            validKeys,
            &pressedKey,
            &itemToEdit
            );
    
        SpMnDestroy( menu );

        if ( (pressedKey == 'Q') || (pressedKey == VK_ESCAPE) ) {
            break;
        }

        if ( (itemToEdit == 1) || (pressedKey == 'F') ) {
            EditFriendlyName( BootEntry, ChangesMade );
        } else if ( (itemToEdit == 2) || (pressedKey == 'L') ) {
            EditLoadOptions( BootEntry, ChangesMade );
        }
    }

    return;

} // EditBootEntry

VOID
EditTimeout (
    IN OUT PBOOL ChangesMade
    )
{
    COORD position;
    DWORD numberRead;
    ULONG timeout;
    ULONG i;
    PWSTR p;

    SpMnClearArea( 3, 3 + NumberOfMenuLines + 1 );

    swprintf( line, L"Current timeout: %d", BootOptions->Timeout );
    WriteConsoleLine( 4, 4, line, FALSE );

again:

    swprintf( line, L"    New timeout: " );
    WriteConsoleLine( 6, 4, line, FALSE );

    position.X = (USHORT)(4 + wcslen( line ));
    position.Y = 6;
    SetConsoleCursorPosition( OutputHandle, position );

    SetConsoleMode( InputHandle, OriginalInputMode );
    ReadConsole( InputHandle, line, 511, &numberRead, NULL );
    SetConsoleMode( InputHandle, 0 );

    if ( numberRead >= 2 ) {
        numberRead -= 2;
    }

    if ( numberRead != 0 ) {

        line[numberRead] = 0;

        timeout = 0;
        p = line;

        while ( *p != 0 ) {

            if ( (*p < L'0') || (*p > L'9') ) {
                swprintf( line, L"Invalid characters in number" );
                WriteConsoleLine( 8, 4, line, TRUE );
                goto again;
            }

            i = (timeout * 10) + (*p - L'0');

            if ( i < timeout ) {
                swprintf( line, L"Overflow in number %d %d", i, timeout );
                WriteConsoleLine( 8, 4, line, TRUE );
                goto again;
            }

            timeout = i;

            p++;
        }

        if ( timeout != BootOptions->Timeout ) {
            BootOptions->Timeout = timeout;
            *ChangesMade = TRUE;
        }
    }
    
    return;

} // EditTimeout

BOOL
PromptToSaveChanges (
    VOID
    )
{
    COORD position;
    ULONG keys[] = { 'Y', 'N', 0 };
    ULONG key;

    SpMnClearArea( 3, 3 + NumberOfMenuLines + 1 );

    swprintf( line, L"Save changes?" );
    WriteConsoleLine( 4, 4, line, TRUE );

    position.X = (USHORT)(4 + wcslen( line ));
    position.Y = 4;
    SetConsoleCursorPosition( OutputHandle, position );

    key = SpWaitValidKey( keys, NULL );

    return (BOOL)(key == 'Y');

} // PromptToSaveChanges

VOID
ClearMenuArea (
    VOID
    )
{
    SpMnClearArea( 3, 3 + NumberOfMenuLines + 1 );
}

VOID
SetStatusLine (
    PWSTR Status
    )
{
    COORD position;

    WriteConsoleLine( 4, 4, Status, TRUE );

    position.X = (USHORT)(4 + wcslen( Status ));
    position.Y = 4;
    SetConsoleCursorPosition( OutputHandle, position );
}

VOID
SetStatusLineAndWait (
    PWSTR Status
    )
{
    ULONG keys[] = { VK_ESCAPE, VK_RETURN, VK_SPACE, 0 };

    SetStatusLine( Status );

    SpWaitValidKey( keys, NULL );
}

VOID
SetStatusLine2 (
    PWSTR Status
    )
{
    COORD position;

    WriteConsoleLine( 6, 4, Status, TRUE );

    position.X = (USHORT)(4 + wcslen( Status ));
    position.Y = 6;
    SetConsoleCursorPosition( OutputHandle, position );
}

VOID
SetStatusLine2AndWait (
    PWSTR Status
    )
{
    ULONG keys[] = { VK_ESCAPE, VK_RETURN, VK_SPACE, 0 };

    SetStatusLine2( Status );

    SpWaitValidKey( keys, NULL );
}

VOID
DisplayMainMenuKeys (
    VOID
    )
{
    ULONG startLine = 3 + 1 + NumberOfMenuLines + 1 + 1;

    SpMnClearArea( startLine, NumberOfRows - 1 );

    WriteConsoleLine(
        startLine,
        1,
        L"PGUP/U = Move up      | HOME/T = Move to top    | DELETE/X = Delete",
        FALSE
        );
    WriteConsoleLine(
        startLine + 1,
        1,
        L"PGDN/D = Move down    |  END/B = Move to bottom | RETURN/E = Edit",
        FALSE
        );

    WriteConsoleLine(
        startLine + 3,
        1,
        L"     A = [De]activate |      O = Remove from/add to boot order",
        FALSE
        );

    WriteConsoleLine(
        startLine + 5,
        1,
        L"     M = Set timeout",
        FALSE
        );

    WriteConsoleLine(
        startLine + 7,
        1,
        L" ESC/Q = Quit         |      S = Save changes",
        FALSE
        );

    return;

} // DisplayMainMenuKeys

VOID
DisplayEditMenuKeys (
    VOID
    )
{
    ULONG startLine = 3 + 1 + NumberOfMenuLines + 1 + 1 + 1;

    SpMnClearArea( startLine, NumberOfRows - 1 );

    WriteConsoleLine(
        startLine + 1,
        1,
        L" ESC/Q = Quit         |                         | RETURN/E = Edit",
        FALSE
        );

    return;

} // DisplayEditMenuKeys