tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
audk/IntelFrameworkModulePkg/Universal/SetupBrowserDxe/InputHandler.c

1571 lines
52 KiB
C
Raw Blame History

/*++
Copyright (c) 2006 - 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
InputHandler.C
Abstract:
Implementation for handling user input from the User Interface
Revision History
--*/
#include "Setup.h"
#include "Ui.h"
#include "Colors.h"
#define EFI_MAX(_a, _b) ((_a) > (_b) ? (_a) : (_b))
EFI_STATUS
ReadString(
IN UI_MENU_OPTION *MenuOption,
OUT CHAR16 *StringPtr
)
{
EFI_STATUS Status;
EFI_INPUT_KEY Key;
CHAR16 NullCharacter;
UINTN ScreenSize;
EFI_TAG *Tag;
CHAR16 Space[2];
CHAR16 KeyPad[2];
BOOLEAN SelectionComplete;
CHAR16 *TempString;
CHAR16 *BufferedString;
UINTN Index;
UINTN Count;
UINTN Start;
UINTN Top;
CHAR16 *PromptForDataString;
UINTN DimensionsWidth;
UINTN DimensionsHeight;
BOOLEAN CursorVisible;
DimensionsWidth = gScreenDimensions.RightColumn - gScreenDimensions.LeftColumn;
DimensionsHeight = gScreenDimensions.BottomRow - gScreenDimensions.TopRow;
PromptForDataString = GetToken (STRING_TOKEN (PROMPT_FOR_DATA), gHiiHandle);
NullCharacter = CHAR_NULL;
ScreenSize = GetStringWidth (PromptForDataString) / 2;
Tag = MenuOption->ThisTag;
Space[0] = L' ';
Space[1] = CHAR_NULL;
SelectionComplete = FALSE;
TempString = AllocateZeroPool (MenuOption->ThisTag->Maximum * 2);
ASSERT (TempString);
if (ScreenSize < (Tag->Maximum / (UINTN) 2)) {
ScreenSize = Tag->Maximum / 2;
}
if ((ScreenSize + 2) > DimensionsWidth) {
ScreenSize = DimensionsWidth - 2;
}
BufferedString = AllocateZeroPool (ScreenSize * 2);
ASSERT (BufferedString);
Start = (DimensionsWidth - ScreenSize - 2) / 2 + gScreenDimensions.LeftColumn + 1;
Top = ((DimensionsHeight - 6) / 2) + gScreenDimensions.TopRow - 1;
//
// Display prompt for string
//
CreatePopUp (ScreenSize, 4, &NullCharacter, PromptForDataString, Space, &NullCharacter);
FreePool (PromptForDataString);
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_BLACK, EFI_LIGHTGRAY));
CursorVisible = gST->ConOut->Mode->CursorVisible;
gST->ConOut->EnableCursor (gST->ConOut, TRUE);
do {
Status = WaitForKeyStroke (&Key);
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_BLACK, EFI_LIGHTGRAY));
switch (Key.UnicodeChar) {
case CHAR_NULL:
switch (Key.ScanCode) {
case SCAN_LEFT:
break;
case SCAN_RIGHT:
break;
case SCAN_ESC:
FreePool (TempString);
FreePool (BufferedString);
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
gST->ConOut->EnableCursor (gST->ConOut, CursorVisible);
return EFI_DEVICE_ERROR;
default:
break;
}
break;
case CHAR_CARRIAGE_RETURN:
if (GetStringWidth (StringPtr) >= MenuOption->ThisTag->Minimum) {
SelectionComplete = TRUE;
FreePool (TempString);
FreePool (BufferedString);
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
gST->ConOut->EnableCursor (gST->ConOut, CursorVisible);
return EFI_SUCCESS;
} else {
ScreenSize = GetStringWidth (gMiniString) / 2;
CreatePopUp (ScreenSize, 4, &NullCharacter, gMiniString, gPressEnter, &NullCharacter);
//
// Simply create a popup to tell the user that they had typed in too few characters.
// To save code space, we can then treat this as an error and return back to the menu.
//
do {
Status = WaitForKeyStroke (&Key);
} while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
FreePool (TempString);
FreePool (BufferedString);
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
gST->ConOut->EnableCursor (gST->ConOut, CursorVisible);
return EFI_DEVICE_ERROR;
}
break;
case CHAR_BACKSPACE:
if (StringPtr[0] != CHAR_NULL) {
for (Index = 0; StringPtr[Index] != CHAR_NULL; Index++) {
TempString[Index] = StringPtr[Index];
}
//
// Effectively truncate string by 1 character
//
TempString[Index - 1] = CHAR_NULL;
StrCpy (StringPtr, TempString);
}
default:
//
// If it is the beginning of the string, don't worry about checking maximum limits
//
if ((StringPtr[0] == CHAR_NULL) && (Key.UnicodeChar != CHAR_BACKSPACE)) {
StrnCpy (StringPtr, &Key.UnicodeChar, 1);
StrnCpy (TempString, &Key.UnicodeChar, 1);
} else if ((GetStringWidth (StringPtr) < MenuOption->ThisTag->Maximum) && (Key.UnicodeChar != CHAR_BACKSPACE)) {
KeyPad[0] = Key.UnicodeChar;
KeyPad[1] = CHAR_NULL;
StrCat (StringPtr, KeyPad);
StrCat (TempString, KeyPad);
}
//
// If the width of the input string is now larger than the screen, we nee to
// adjust the index to start printing portions of the string
//
SetUnicodeMem (BufferedString, ScreenSize - 1, L' ');
PrintStringAt (Start + 1, Top + 3, BufferedString);
if ((GetStringWidth (StringPtr) / 2) > (DimensionsWidth - 2)) {
Index = (GetStringWidth (StringPtr) / 2) - DimensionsWidth + 2;
} else {
Index = 0;
}
for (Count = 0; Index + 1 < GetStringWidth (StringPtr) / 2; Index++, Count++) {
BufferedString[Count] = StringPtr[Index];
}
PrintStringAt (Start + 1, Top + 3, BufferedString);
break;
}
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
gST->ConOut->SetCursorPosition (gST->ConOut, Start + GetStringWidth (StringPtr) / 2, Top + 3);
} while (!SelectionComplete);
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
gST->ConOut->EnableCursor (gST->ConOut, CursorVisible);
return Status;
}
EFI_STATUS
ReadPassword (
IN UI_MENU_OPTION *MenuOption,
IN BOOLEAN PromptForPassword,
IN EFI_TAG *Tag,
IN EFI_IFR_DATA_ARRAY *PageData,
IN BOOLEAN SecondEntry,
IN EFI_FILE_FORM_TAGS *FileFormTags,
OUT CHAR16 *StringPtr
)
{
EFI_STATUS Status;
UINTN ScreenSize;
CHAR16 NullCharacter;
CHAR16 Space[2];
EFI_INPUT_KEY Key;
CHAR16 KeyPad[2];
UINTN Index;
UINTN Start;
UINTN Top;
CHAR16 *TempString;
CHAR16 *TempString2;
BOOLEAN Confirmation;
BOOLEAN ConfirmationComplete;
EFI_HII_CALLBACK_PACKET *Packet;
EFI_FORM_CALLBACK_PROTOCOL *FormCallback;
EFI_VARIABLE_DEFINITION *VariableDefinition;
UINTN DimensionsWidth;
UINTN DimensionsHeight;
EFI_IFR_DATA_ENTRY *DataEntry;
UINTN WidthOfString;
DimensionsWidth = gScreenDimensions.RightColumn - gScreenDimensions.LeftColumn;
DimensionsHeight = gScreenDimensions.BottomRow - gScreenDimensions.TopRow;
VariableDefinition = NULL;
NullCharacter = CHAR_NULL;
Space[0] = L' ';
Space[1] = CHAR_NULL;
Confirmation = FALSE;
ConfirmationComplete = FALSE;
Status = EFI_SUCCESS;
FormCallback = NULL;
Packet = NULL;
//
// Remember that dynamic pages in an environment where all pages are not
// dynamic require us to call back to the user to give them an opportunity
// to register fresh information in the HII database so that we can extract it.
//
Status = gBS->HandleProtocol (
(VOID *) (UINTN) MenuOption->Tags[0].CallbackHandle,
&gEfiFormCallbackProtocolGuid,
(VOID **) &FormCallback
);
TempString = AllocateZeroPool (MenuOption->ThisTag->Maximum * 2);
TempString2 = AllocateZeroPool (MenuOption->ThisTag->Maximum * 2);
ASSERT (TempString);
ASSERT (TempString2);
if (Tag->Flags & EFI_IFR_FLAG_INTERACTIVE) {
//
// Password requires a callback to determine if a password exists
//
DataEntry = (EFI_IFR_DATA_ENTRY *) (PageData + 1);
DataEntry->OpCode = EFI_IFR_PASSWORD_OP;
DataEntry->Length = 3;
ExtractRequestedNvMap (FileFormTags, Tag->VariableNumber, &VariableDefinition);
//
// The user is about to be prompted with a password field, Data = 0 (Return Status determines the type of prompt)
//
DataEntry->Data = (VOID *) (UINTN) (UINT8) (0 + SecondEntry * 2);
PageData->NvRamMap = VariableDefinition->NvRamMap;
if ((FormCallback != NULL) && (FormCallback->Callback != NULL)) {
Status = FormCallback->Callback (
FormCallback,
Tag->Key,
PageData,
&Packet
);
}
//
// If error on return, continue with the reading of a typed in password to verify user knows password
// If no error, there is no password set, so prompt for new password
// if the previous callback was to verify the user knew password, and user typed it correctly - should return no error
//
if (!EFI_ERROR (Status)) {
PromptForPassword = FALSE;
//
// Simulate this as the second entry into this routine for an interactive behavior
//
SecondEntry = TRUE;
} else if (Status == EFI_NOT_READY) {
Error:
if (Packet != NULL) {
//
// Upon error, we will likely receive a string to print out
// Display error popup
//
WidthOfString = GetStringWidth (Packet->String);
ScreenSize = EFI_MAX(WidthOfString, GetStringWidth (gPressEnter)) / 2;
CreatePopUp (ScreenSize, 4, &NullCharacter, Packet->String, gPressEnter, &NullCharacter);
FreePool (Packet);
do {
Status = WaitForKeyStroke (&Key);
} while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
}
Status = EFI_NOT_READY;
goto Done;
}
}
do {
//
// Display PopUp Screen
//
ScreenSize = GetStringWidth (gPromptForNewPassword) / 2;
if (GetStringWidth (gConfirmPassword) / 2 > ScreenSize) {
ScreenSize = GetStringWidth (gConfirmPassword) / 2;
}
Start = (DimensionsWidth - ScreenSize - 4) / 2 + gScreenDimensions.LeftColumn + 2;
Top = ((DimensionsHeight - 6) / 2) + gScreenDimensions.TopRow - 1;
if (!Confirmation) {
if (PromptForPassword) {
CreatePopUp (ScreenSize, 4, &NullCharacter, gPromptForPassword, Space, &NullCharacter);
} else {
CreatePopUp (ScreenSize, 4, &NullCharacter, gPromptForNewPassword, Space, &NullCharacter);
}
} else {
CreatePopUp (ScreenSize, 4, &NullCharacter, gConfirmPassword, Space, &NullCharacter);
StringPtr[0] = CHAR_NULL;
}
do {
Status = WaitForKeyStroke (&Key);
switch (Key.UnicodeChar) {
case CHAR_NULL:
if (Key.ScanCode == SCAN_ESC) {
return EFI_NOT_READY;
}
ConfirmationComplete = FALSE;
break;
case CHAR_CARRIAGE_RETURN:
if (Tag->Flags & EFI_IFR_FLAG_INTERACTIVE) {
//
// User just typed a string in
//
DataEntry = (EFI_IFR_DATA_ENTRY *) (PageData + 1);
DataEntry->OpCode = EFI_IFR_PASSWORD_OP;
//
// If the user just typed in a password, Data = 1
// If the user just typed in a password to confirm the previous password, Data = 2
//
if (!Confirmation) {
DataEntry->Length = 3;
DataEntry->Data = (VOID *) (UINTN) (UINT8) (1 + SecondEntry * 2);
if ((FormCallback != NULL) && (FormCallback->Callback != NULL)) {
Status = FormCallback->Callback (
FormCallback,
Tag->Key,
PageData,
&Packet
);
}
DataEntry->Length = sizeof (EFI_IFR_DATA_ENTRY);
DataEntry->Data = (VOID *) TempString;
} else {
DataEntry->Length = 3;
DataEntry->Data = (VOID *) (UINTN) (UINT8) (2 + SecondEntry * 2);
if ((FormCallback != NULL) && (FormCallback->Callback != NULL)) {
Status = FormCallback->Callback (
FormCallback,
Tag->Key,
PageData,
&Packet
);
}
DataEntry->Length = sizeof (EFI_IFR_DATA_ENTRY);
DataEntry->Data = (VOID *) TempString2;
}
if ((FormCallback != NULL) && (FormCallback->Callback != NULL)) {
Status = FormCallback->Callback (
FormCallback,
Tag->Key,
PageData,
&Packet
);
}
//
// If this was the confirmation round of callbacks
// and an error comes back, display an error
//
if (Confirmation) {
if (EFI_ERROR (Status)) {
if (Packet->String == NULL) {
WidthOfString = GetStringWidth (gConfirmError);
ScreenSize = EFI_MAX (WidthOfString, GetStringWidth (gPressEnter)) / 2;
CreatePopUp (ScreenSize, 4, &NullCharacter, gConfirmError, gPressEnter, &NullCharacter);
} else {
WidthOfString = GetStringWidth (Packet->String);
ScreenSize = EFI_MAX (WidthOfString, GetStringWidth (gPressEnter)) / 2;
CreatePopUp (ScreenSize, 4, &NullCharacter, Packet->String, gPressEnter, &NullCharacter);
FreePool (Packet);
}
StringPtr[0] = CHAR_NULL;
do {
Status = WaitForKeyStroke (&Key);
if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
Status = EFI_NOT_READY;
goto Done;
}
} while (1);
} else {
Status = EFI_NOT_READY;
goto Done;
}
} else {
//
// User typed a string in and it wasn't valid somehow from the callback
// For instance, callback may have said that some invalid characters were contained in the string
//
if (Status == EFI_NOT_READY) {
goto Error;
}
if (PromptForPassword && EFI_ERROR (Status)) {
Status = EFI_DEVICE_ERROR;
goto Done;
}
}
}
if (Confirmation) {
//
// Compare tempstring and tempstring2, if the same, return with StringPtr success
// Otherwise, kick and error box, and return an error
//
if (StrCmp (TempString, TempString2) == 0) {
Status = EFI_SUCCESS;
goto Done;
} else {
WidthOfString = GetStringWidth (gConfirmError);
ScreenSize = EFI_MAX (WidthOfString, GetStringWidth (gPressEnter)) / 2;
CreatePopUp (ScreenSize, 4, &NullCharacter, gConfirmError, gPressEnter, &NullCharacter);
StringPtr[0] = CHAR_NULL;
do {
Status = WaitForKeyStroke (&Key);
if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
Status = EFI_DEVICE_ERROR;
goto Done;
}
} while (1);
}
}
if (PromptForPassword) {
//
// I was asked for a password, return it back in StringPtr
//
Status = EFI_SUCCESS;
goto Done;
} else {
//
// If the two passwords were not the same kick an error popup
//
Confirmation = TRUE;
ConfirmationComplete = TRUE;
break;
}
case CHAR_BACKSPACE:
if (StringPtr[0] != CHAR_NULL) {
if (!Confirmation) {
for (Index = 0; StringPtr[Index] != CHAR_NULL; Index++) {
TempString[Index] = StringPtr[Index];
}
//
// Effectively truncate string by 1 character
//
TempString[Index - 1] = CHAR_NULL;
StrCpy (StringPtr, TempString);
} else {
for (Index = 0; StringPtr[Index] != CHAR_NULL; Index++) {
TempString2[Index] = StringPtr[Index];
}
//
// Effectively truncate string by 1 character
//
TempString2[Index - 1] = CHAR_NULL;
StrCpy (StringPtr, TempString2);
}
ConfirmationComplete = FALSE;
} else {
ConfirmationComplete = FALSE;
}
//
// Must be a character we are interested in!
//
default:
if ((StringPtr[0] == CHAR_NULL) && (Key.UnicodeChar != CHAR_BACKSPACE)) {
if (!Confirmation) {
StrnCpy (StringPtr, &Key.UnicodeChar, 1);
StrnCpy (TempString, &Key.UnicodeChar, 1);
} else {
StrnCpy (StringPtr, &Key.UnicodeChar, 1);
StrnCpy (TempString2, &Key.UnicodeChar, 1);
ConfirmationComplete = FALSE;
}
} else if ((GetStringWidth (StringPtr) / 2 <= (UINTN) (MenuOption->ThisTag->Maximum - 1) / 2) &&
(Key.UnicodeChar != CHAR_BACKSPACE)
) {
KeyPad[0] = Key.UnicodeChar;
KeyPad[1] = CHAR_NULL;
if (!Confirmation) {
StrCat (StringPtr, KeyPad);
StrCat (TempString, KeyPad);
} else {
StrCat (StringPtr, KeyPad);
StrCat (TempString2, KeyPad);
}
}
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_BLACK, EFI_LIGHTGRAY));
for (Index = 1; Index < ScreenSize; Index++) {
PrintCharAt (Start + Index, Top + 3, L' ');
}
gST->ConOut->SetCursorPosition (
gST->ConOut,
(DimensionsWidth - GetStringWidth (StringPtr) / 2) / 2 + gScreenDimensions.LeftColumn,
Top + 3
);
for (Index = 0; Index + 1 < GetStringWidth (StringPtr) / 2; Index++) {
PrintChar (L'*');
}
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
break;
}
//
// end switch
//
} while (!ConfirmationComplete);
} while (1);
Done:
FreePool (TempString);
FreePool (TempString2);
return Status;
}
VOID
EncodePassword (
IN CHAR16 *Password,
IN UINT8 MaxSize
)
{
UINTN Index;
UINTN Loop;
CHAR16 *Buffer;
CHAR16 *Key;
Key = (CHAR16 *) L"MAR10648567";
Buffer = AllocateZeroPool (MaxSize);
ASSERT (Buffer);
for (Index = 0; Key[Index] != 0; Index++) {
for (Loop = 0; Loop < (UINT8) (MaxSize / 2); Loop++) {
Buffer[Loop] = (CHAR16) (Password[Loop] ^ Key[Index]);
}
}
CopyMem (Password, Buffer, MaxSize);
FreePool (Buffer);
return ;
}
EFI_STATUS
GetNumericInput (
IN UI_MENU_OPTION *MenuOption,
IN EFI_FILE_FORM_TAGS *FileFormTagsHead,
IN BOOLEAN ManualInput,
IN EFI_TAG *Tag,
IN UINTN NumericType,
OUT UINT16 *Value
)
/*++
Routine Description:
This routine reads a numeric value from the user input.
Arguments:
MenuOption - Pointer to the current input menu.
FileFormTagsHead - Pointer to the root of formset.
ManualInput - If the input is manual or not.
Tag - Pointer to all the attributes and values associated with a tag.
Value - Pointer to the numeric value that is going to be read.
Returns:
EFI_SUCCESS - If numerical input is read successfully
EFI_DEVICE_ERROR - If operation fails
--*/
{
EFI_INPUT_KEY Key;
BOOLEAN SelectionComplete;
UINTN Column;
UINTN Row;
CHAR16 FormattedNumber[6];
UINTN PreviousNumber[6];
INTN Number;
UINTN Count;
UINT16 BackupValue;
STRING_REF PopUp;
CHAR16 NullCharacter;
CHAR16 *StringPtr;
EFI_FILE_FORM_TAGS *FileFormTags;
EFI_VARIABLE_DEFINITION *VariableDefinition;
UINTN Loop;
NullCharacter = CHAR_NULL;
StringPtr = NULL;
Column = MenuOption->OptCol;
Row = MenuOption->Row;
Number = 0;
PreviousNumber[0] = 0;
Count = 0;
SelectionComplete = FALSE;
BackupValue = Tag->Value;
FileFormTags = FileFormTagsHead;
if (ManualInput) {
PrintAt (Column, Row, (CHAR16 *) L"[ ]");
Column++;
if (Tag->Operand != EFI_IFR_TIME_OP) {
*Value = BackupValue;
}
}
//
// First time we enter this handler, we need to check to see if
// we were passed an increment or decrement directive
//
do {
Key.UnicodeChar = CHAR_NULL;
if (gDirection != 0) {
Key.ScanCode = gDirection;
gDirection = 0;
goto TheKey2;
}
WaitForKeyStroke (&Key);
TheKey2:
switch (Key.UnicodeChar) {
case '+':
case '-':
if ((Tag->Operand == EFI_IFR_DATE_OP) || (Tag->Operand == EFI_IFR_TIME_OP)) {
Key.UnicodeChar = CHAR_NULL;
if (Key.UnicodeChar == '+') {
Key.ScanCode = SCAN_RIGHT;
} else {
Key.ScanCode = SCAN_LEFT;
}
goto TheKey2;
}
break;
case CHAR_NULL:
switch (Key.ScanCode) {
case SCAN_LEFT:
case SCAN_RIGHT:
if ((Tag->Operand == EFI_IFR_DATE_OP) || (Tag->Operand == EFI_IFR_TIME_OP)) {
//
// By setting this value, we will return back to the caller.
// We need to do this since an auto-refresh will destroy the adjustment
// based on what the real-time-clock is showing. So we always commit
// upon changing the value.
//
gDirection = SCAN_DOWN;
}
if (!ManualInput) {
Tag->Value = *Value;
if (Key.ScanCode == SCAN_LEFT) {
Number = *Value - Tag->Step;
if (Number < Tag->Minimum) {
Number = Tag->Minimum;
}
} else if (Key.ScanCode == SCAN_RIGHT) {
Number = *Value + Tag->Step;
if (Number > Tag->Maximum) {
Number = Tag->Maximum;
}
}
Tag->Value = (UINT16) Number;
*Value = (UINT16) Number;
UnicodeValueToString (
FormattedNumber,
FALSE,
(UINTN) Number,
(sizeof (FormattedNumber) / sizeof (FormattedNumber[0]))
);
Number = (UINT16) GetStringWidth (FormattedNumber);
gST->ConOut->SetAttribute (gST->ConOut, FIELD_TEXT | FIELD_BACKGROUND);
if ((Tag->Operand == EFI_IFR_DATE_OP) || (Tag->Operand == EFI_IFR_TIME_OP)) {
for (Loop = 0; Loop < (UINTN) ((Number >= 8) ? 4 : 2); Loop++) {
PrintAt (MenuOption->OptCol + Loop, MenuOption->Row, (CHAR16 *) L" ");
}
} else {
for (Loop = 0; Loop < gOptionBlockWidth; Loop++) {
PrintAt (MenuOption->OptCol + Loop, MenuOption->Row, (CHAR16 *) L" ");
}
}
gST->ConOut->SetAttribute (gST->ConOut, FIELD_TEXT_HIGHLIGHT | FIELD_BACKGROUND_HIGHLIGHT);
if ((MenuOption->Col + gPromptBlockWidth + 1) == MenuOption->OptCol) {
PrintCharAt (MenuOption->OptCol, Row, LEFT_NUMERIC_DELIMITER);
Column = MenuOption->OptCol + 1;
}
//
// If Number looks like "3", convert it to "03/"
//
if (Number == 4 && (NumericType == DATE_NUMERIC)) {
FormattedNumber[3] = FormattedNumber[1];
FormattedNumber[2] = DATE_SEPARATOR;
FormattedNumber[1] = FormattedNumber[0];
FormattedNumber[0] = L'0';
Number = 8;
}
//
// If Number looks like "13", convert it to "13/"
//
if (Number == 6 && (NumericType == DATE_NUMERIC)) {
FormattedNumber[3] = FormattedNumber[2];
FormattedNumber[2] = DATE_SEPARATOR;
Number = 8;
}
if (Number == 4 &&
(NumericType == TIME_NUMERIC) &&
(MenuOption->Col + gPromptBlockWidth + 8) != MenuOption->OptCol
) {
FormattedNumber[3] = FormattedNumber[1];
FormattedNumber[2] = TIME_SEPARATOR;
FormattedNumber[1] = FormattedNumber[0];
FormattedNumber[0] = L'0';
Number = 8;
}
if (Number == 4 &&
(NumericType == TIME_NUMERIC) &&
(MenuOption->Col + gPromptBlockWidth + 8) == MenuOption->OptCol
) {
FormattedNumber[3] = FormattedNumber[1];
FormattedNumber[2] = RIGHT_NUMERIC_DELIMITER;
FormattedNumber[1] = FormattedNumber[0];
FormattedNumber[0] = L'0';
Number = 8;
}
PrintStringAt (Column, Row, FormattedNumber);
if (Number == 10 && (NumericType == DATE_NUMERIC)) {
PrintChar (RIGHT_NUMERIC_DELIMITER);
}
if (NumericType == REGULAR_NUMERIC) {
PrintChar (RIGHT_NUMERIC_DELIMITER);
}
}
break;
case SCAN_UP:
case SCAN_DOWN:
goto EnterCarriageReturn;
case SCAN_ESC:
return EFI_DEVICE_ERROR;
default:
break;
}
break;
EnterCarriageReturn:
case CHAR_CARRIAGE_RETURN:
//
// Check to see if the Value is something reasonable against consistency limitations.
// If not, let's kick the error specified.
//
//
// This gives us visibility to the FileFormTags->NvRamMap to check things
// ActiveIfr is a global maintained by the menuing code to ensure that we
// are pointing to the correct formset's file data.
//
for (Count = 0; Count < gActiveIfr; Count++) {
FileFormTags = FileFormTags->NextFile;
}
ExtractRequestedNvMap (FileFormTags, Tag->VariableNumber, &VariableDefinition);
CopyMem (&VariableDefinition->NvRamMap[Tag->StorageStart], &Tag->Value, Tag->StorageWidth);
//
// Data associated with a NULL device (in the fake NV storage)
//
if (Tag->StorageWidth == (UINT16) 0) {
CopyMem (&VariableDefinition->FakeNvRamMap[Tag->StorageStart], &Tag->Value, 2);
}
//
// If a late check is required save off the information. This is used when consistency checks
// are required, but certain values might be bound by an impossible consistency check such as
// if two questions are bound by consistency checks and each only has two possible choices, there
// would be no way for a user to switch the values. Thus we require late checking.
//
if (Tag->Flags & EFI_IFR_FLAG_LATE_CHECK) {
CopyMem (&Tag->OldValue, &BackupValue, Tag->StorageWidth);
} else {
//
// In theory, passing the value and the Id are sufficient to determine what needs
// to be done. The Id is the key to look for the entry needed in the Inconsistency
// database. That will yields operand and ID data - and since the ID's correspond
// to the NV storage, we can determine the values for other IDs there.
//
if (ValueIsNotValid (TRUE, 0, Tag, FileFormTags, &PopUp)) {
if (PopUp == 0x0000) {
SelectionComplete = TRUE;
break;
}
StringPtr = GetToken (PopUp, MenuOption->Handle);
CreatePopUp (GetStringWidth (StringPtr) / 2, 3, &NullCharacter, StringPtr, &NullCharacter);
do {
WaitForKeyStroke (&Key);
switch (Key.UnicodeChar) {
case CHAR_CARRIAGE_RETURN:
SelectionComplete = TRUE;
FreePool (StringPtr);
break;
default:
break;
}
} while (!SelectionComplete);
Tag->Value = BackupValue;
*Value = BackupValue;
CopyMem (&VariableDefinition->NvRamMap[Tag->StorageStart], &Tag->Value, Tag->StorageWidth);
//
// Data associated with a NULL device (in the fake NV storage)
//
if (Tag->StorageWidth == (UINT16) 0) {
CopyMem (&VariableDefinition->FakeNvRamMap[Tag->StorageStart], &Tag->Value, 2);
}
return EFI_DEVICE_ERROR;
}
}
return EFI_SUCCESS;
break;
case CHAR_BACKSPACE:
if (ManualInput) {
if (Count == 0) {
break;
}
//
// Remove a character
//
Number = PreviousNumber[Count - 1];
*Value = (UINT16) Number;
UpdateStatusBar (INPUT_ERROR, Tag->Flags, FALSE);
Count--;
Column--;
PrintAt (Column, Row, (CHAR16 *) L" ");
}
break;
default:
if (ManualInput) {
if (Key.UnicodeChar > L'9' || Key.UnicodeChar < L'0') {
UpdateStatusBar (INPUT_ERROR, Tag->Flags, TRUE);
break;
}
//
// If Count 0-4 is complete, there is no way more is valid
//
if (Count > 4) {
break;
}
//
// Someone typed something valid!
//
if (Count != 0) {
Number = Number * 10 + (Key.UnicodeChar - L'0');
} else {
Number = Key.UnicodeChar - L'0';
}
if (Number > Tag->Maximum) {
UpdateStatusBar (INPUT_ERROR, Tag->Flags, TRUE);
Number = PreviousNumber[Count];
break;
} else {
UpdateStatusBar (INPUT_ERROR, Tag->Flags, FALSE);
}
Count++;
PreviousNumber[Count] = Number;
*Value = (UINT16) Number;
Tag->Value = (UINT16) Number;
PrintCharAt (Column, Row, Key.UnicodeChar);
Column++;
}
break;
}
} while (!SelectionComplete);
return EFI_SUCCESS;
}
//
// Notice that this is at least needed for the ordered list manipulation.
// Left/Right doesn't make sense for this op-code
//
EFI_STATUS
GetSelectionInputPopUp (
IN UI_MENU_OPTION *MenuOption,
IN EFI_TAG *Tag,
IN UINTN ValueCount,
OUT UINT16 *Value,
OUT UINT16 *KeyValue
)
{
EFI_INPUT_KEY Key;
UINTN Index;
UINTN TempIndex;
CHAR16 *StringPtr;
CHAR16 *TempStringPtr;
UINT16 Token;
UINTN Index2;
UINTN TopOptionIndex;
UINTN HighlightPosition;
UINTN Start;
UINTN End;
UINTN Top;
UINTN Bottom;
UINT16 TempValue;
UINTN Count;
UINTN PopUpMenuLines;
UINTN MenuLinesInView;
UINTN PopUpWidth;
CHAR16 Character;
BOOLEAN FirstOptionFoundFlag;
INT32 SavedAttribute;
EFI_TAG TagBackup;
UINT8 *ValueArray;
UINT8 *ValueArrayBackup;
UINT8 ValueBackup;
BOOLEAN Initialized;
BOOLEAN KeyInitialized;
BOOLEAN ShowDownArrow;
BOOLEAN ShowUpArrow;
UINTN DimensionsWidth;
DimensionsWidth = gScreenDimensions.RightColumn - gScreenDimensions.LeftColumn;
TempValue = 0;
TempIndex = 0;
ValueArray = (UINT8 *) Value;
ValueArrayBackup = NULL;
Initialized = FALSE;
KeyInitialized = FALSE;
ShowDownArrow = FALSE;
ShowUpArrow = FALSE;
if (Tag->Operand == EFI_IFR_ORDERED_LIST_OP) {
ValueArrayBackup = AllocateZeroPool (Tag->StorageWidth);
ASSERT (ValueArrayBackup != NULL);
CopyMem (ValueArrayBackup, ValueArray, ValueCount);
TempValue = *(UINT8 *) (ValueArray);
if (ValueArray[0] != 0x00) {
Initialized = TRUE;
}
for (Index = 0; ValueArray[Index] != 0x00; Index++)
;
ValueCount = Index;
} else {
TempValue = *Value;
}
Count = 0;
PopUpWidth = 0;
FirstOptionFoundFlag = FALSE;
StringPtr = AllocateZeroPool ((gOptionBlockWidth + 1) * 2);
ASSERT (StringPtr);
//
// Initialization for "One of" pop-up menu
//
//
// Get the number of one of options present and its size
//
for (Index = MenuOption->TagIndex; MenuOption->Tags[Index].Operand != EFI_IFR_END_ONE_OF_OP; Index++) {
if (MenuOption->Tags[Index].Operand == EFI_IFR_ONE_OF_OPTION_OP &&
!MenuOption->Tags[Index].Suppress) {
if (!FirstOptionFoundFlag) {
FirstOptionFoundFlag = TRUE;
}
Count++;
Token = MenuOption->Tags[Index].Text;
//
// If this is an ordered list that is initialized
//
if (Initialized) {
for (ValueBackup = (UINT8) MenuOption->TagIndex;
MenuOption->Tags[ValueBackup].Operand != EFI_IFR_END_OP;
ValueBackup++
) {
if (MenuOption->Tags[ValueBackup].Value == ((UINT8 *) ValueArrayBackup)[Index - MenuOption->TagIndex - 1]) {
StringPtr = GetToken (MenuOption->Tags[ValueBackup].Text, MenuOption->Handle);
break;
}
}
} else {
StringPtr = GetToken (Token, MenuOption->Handle);
}
if (StrLen (StringPtr) > PopUpWidth) {
PopUpWidth = StrLen (StringPtr);
}
FreePool (StringPtr);
}
}
//
// Perform popup menu initialization.
//
PopUpMenuLines = Count;
PopUpWidth = PopUpWidth + POPUP_PAD_SPACE_COUNT;
SavedAttribute = gST->ConOut->Mode->Attribute;
gST->ConOut->SetAttribute (gST->ConOut, POPUP_TEXT | POPUP_BACKGROUND);
if ((PopUpWidth + POPUP_FRAME_WIDTH) > DimensionsWidth) {
PopUpWidth = DimensionsWidth - POPUP_FRAME_WIDTH;
}
Start = (DimensionsWidth - PopUpWidth - POPUP_FRAME_WIDTH) / 2 + gScreenDimensions.LeftColumn;
End = Start + PopUpWidth + POPUP_FRAME_WIDTH;
Top = gScreenDimensions.TopRow + NONE_FRONT_PAGE_HEADER_HEIGHT;
Bottom = gScreenDimensions.BottomRow - STATUS_BAR_HEIGHT - FOOTER_HEIGHT;
MenuLinesInView = Bottom - Top - 1;
if (MenuLinesInView >= PopUpMenuLines) {
Top = Top + (MenuLinesInView - PopUpMenuLines) / 2;
Bottom = Top + PopUpMenuLines + 1;
} else {
TempValue = MenuOption->Tags[MenuOption->TagIndex + 1].Value;
ShowDownArrow = TRUE;
}
TopOptionIndex = 1;
HighlightPosition = 0;
do {
if (Initialized) {
for (Index = MenuOption->TagIndex, Index2 = 0; Index2 < ValueCount; Index++, Index2++) {
//
// Set the value for the item we are looking for
//
Count = ValueArrayBackup[Index2];
//
// If we hit the end of the Array, we are complete
//
if (Count == 0) {
break;
}
if (MenuOption->Tags[Index].Operand == EFI_IFR_ONE_OF_OPTION_OP) {
for (ValueBackup = (UINT8) MenuOption->TagIndex;
MenuOption->Tags[ValueBackup].Operand != EFI_IFR_END_ONE_OF_OP;
ValueBackup++
) {
//
// We just found what we are looking for
//
if (MenuOption->Tags[ValueBackup].Value == Count) {
//
// As long as the two indexes aren't the same, we have
// two different op-codes we need to swap internally
//
if (Index != ValueBackup) {
//
// Backup destination tag, then copy source to destination, then copy backup to source location
//
CopyMem (&TagBackup, &MenuOption->Tags[Index], sizeof (EFI_TAG));
CopyMem (&MenuOption->Tags[Index], &MenuOption->Tags[ValueBackup], sizeof (EFI_TAG));
CopyMem (&MenuOption->Tags[ValueBackup], &TagBackup, sizeof (EFI_TAG));
} else {
//
// If the indexes are the same, then the op-code is where he belongs
//
}
}
}
} else {
//
// Since this wasn't an option op-code (likely the ordered list op-code) decerement Index2
//
Index2--;
}
}
}
//
// Clear that portion of the screen
//
ClearLines (Start, End, Top, Bottom, POPUP_TEXT | POPUP_BACKGROUND);
//
// Draw "One of" pop-up menu
//
Character = (CHAR16) BOXDRAW_DOWN_RIGHT;
PrintCharAt (Start, Top, Character);
for (Index = Start; Index + 2 < End; Index++) {
if ((ShowUpArrow) && ((Index + 1) == (Start + End) / 2)) {
Character = (CHAR16) GEOMETRICSHAPE_UP_TRIANGLE;
} else {
Character = (CHAR16) BOXDRAW_HORIZONTAL;
}
PrintChar (Character);
}
Character = (CHAR16) BOXDRAW_DOWN_LEFT;
PrintChar (Character);
Character = (CHAR16) BOXDRAW_VERTICAL;
for (Index = Top + 1; Index < Bottom; Index++) {
PrintCharAt (Start, Index, Character);
PrintCharAt (End - 1, Index, Character);
}
//
// Display the One of options
//
Index2 = Top + 1;
for (Index = MenuOption->TagIndex + TopOptionIndex;
(MenuOption->Tags[Index].Operand != EFI_IFR_END_ONE_OF_OP) && (Index2 < Bottom);
Index++
) {
if (MenuOption->Tags[Index].Operand == EFI_IFR_ONE_OF_OPTION_OP) {
Token = MenuOption->Tags[Index].Text;
if (Initialized) {
for (ValueBackup = (UINT8) MenuOption->TagIndex;
MenuOption->Tags[ValueBackup].Operand != EFI_IFR_END_ONE_OF_OP;
ValueBackup++
) {
if (MenuOption->Tags[ValueBackup].Value == ((UINT8 *) ValueArrayBackup)[Index - MenuOption->TagIndex - 1]) {
StringPtr = GetToken (MenuOption->Tags[ValueBackup].Text, MenuOption->Handle);
break;
}
}
} else {
ValueBackup = (UINT8) Index;
StringPtr = GetToken (Token, MenuOption->Handle);
}
//
// If the string occupies multiple lines, truncate it to fit in one line,
// and append a "..." for indication.
//
if (StrLen (StringPtr) > (PopUpWidth - 1)) {
TempStringPtr = AllocateZeroPool (sizeof (CHAR16) * (PopUpWidth - 1));
ASSERT (TempStringPtr != NULL);
CopyMem (TempStringPtr, StringPtr, (sizeof (CHAR16) * (PopUpWidth - 5)));
FreePool (StringPtr);
StringPtr = TempStringPtr;
StrCat (StringPtr, (CHAR16 *) L"...");
}
//
// Code to display the text should go here. Follwed by the [*]
//
if (MenuOption->Tags[ValueBackup].Suppress == TRUE) {
//
// Don't show the one, so decrease the Index2 for balance
//
Index2--;
} else if (MenuOption->Tags[ValueBackup].GrayOut == TRUE) {
//
// Gray Out the one
//
gST->ConOut->SetAttribute (gST->ConOut, FIELD_TEXT_GRAYED | POPUP_BACKGROUND);
PrintStringAt (Start + 2, Index2, StringPtr);
gST->ConOut->SetAttribute (gST->ConOut, POPUP_TEXT | POPUP_BACKGROUND);
} else if (MenuOption->Tags[ValueBackup].Value == TempValue) {
//
// Highlight the selected one
//
gST->ConOut->SetAttribute (gST->ConOut, PICKLIST_HIGHLIGHT_TEXT | PICKLIST_HIGHLIGHT_BACKGROUND);
PrintStringAt (Start + 2, Index2, StringPtr);
gST->ConOut->SetAttribute (gST->ConOut, POPUP_TEXT | POPUP_BACKGROUND);
HighlightPosition = Index2;
} else {
gST->ConOut->SetAttribute (gST->ConOut, POPUP_TEXT | POPUP_BACKGROUND);
PrintStringAt (Start + 2, Index2, StringPtr);
}
FreePool (StringPtr);
Index2 = Index2 + 1;
}
}
Character = (CHAR16) BOXDRAW_UP_RIGHT;
PrintCharAt (Start, Bottom, Character);
for (Index = Start; Index + 2 < End; Index++) {
if ((ShowDownArrow) && ((Index + 1) == (Start + End) / 2)) {
Character = (CHAR16) GEOMETRICSHAPE_DOWN_TRIANGLE;
} else {
Character = (CHAR16) BOXDRAW_HORIZONTAL;
}
PrintChar (Character);
}
Character = (CHAR16) BOXDRAW_UP_LEFT;
PrintChar (Character);
//
// Get User selection and change TempValue if necessary
//
//
// Stop: One of pop-up menu
//
Key.UnicodeChar = CHAR_NULL;
if ((gDirection == SCAN_UP) || (gDirection == SCAN_DOWN)) {
Key.ScanCode = gDirection;
gDirection = 0;
goto TheKey;
}
if (!KeyInitialized) {
if (MenuOption->ThisTag->Operand == EFI_IFR_ONE_OF_OP) {
*KeyValue = MenuOption->Tags[MenuOption->TagIndex + 1].Key;
} else {
*KeyValue = MenuOption->ThisTag->Key;
}
KeyInitialized = TRUE;
}
WaitForKeyStroke (&Key);
TheKey:
switch (Key.UnicodeChar) {
case '+':
case '-':
//
// If an ordered list op-code, we will allow for a popup of +/- keys
// to create an ordered list of items
//
if (Tag->Operand == EFI_IFR_ORDERED_LIST_OP) {
if (Key.UnicodeChar == '+') {
if ((TopOptionIndex > 1) && (HighlightPosition == (Top + 1))) {
//
// Highlight reaches the top of the popup window, scroll one menu item.
//
TopOptionIndex--;
ShowDownArrow = TRUE;
}
if (TopOptionIndex == 1) {
ShowUpArrow = FALSE;
}
} else {
if (((TopOptionIndex + MenuLinesInView) <= PopUpMenuLines) && (HighlightPosition == (Bottom - 1))) {
//
// Highlight reaches the bottom of the popup window, scroll one menu item.
//
TopOptionIndex++;
ShowUpArrow = TRUE;
}
if ((TopOptionIndex + MenuLinesInView) == (PopUpMenuLines + 1)) {
ShowDownArrow = FALSE;
}
}
for (Index = MenuOption->TagIndex + TopOptionIndex;
MenuOption->Tags[Index].Operand != EFI_IFR_END_ONE_OF_OP;
Index++
) {
if (MenuOption->Tags[Index].Operand == EFI_IFR_ORDERED_LIST_OP) {
continue;
}
if (Key.UnicodeChar == '+') {
TempIndex = Index - 1;
} else {
TempIndex = Index + 1;
}
//
// Is this the current tag we are on?
//
if (MenuOption->Tags[Index].Value == TempValue) {
//
// Is this prior tag a valid choice? If not, bail out
//
if (MenuOption->Tags[TempIndex].Operand == EFI_IFR_ONE_OF_OPTION_OP) {
//
// Copy the destination tag to the local variable
//
CopyMem (&TagBackup, &MenuOption->Tags[TempIndex], sizeof (EFI_TAG));
//
// Copy the current tag to the tag location before us
//
CopyMem (&MenuOption->Tags[TempIndex], &MenuOption->Tags[Index], sizeof (EFI_TAG));
//
// Copy the backed up tag to the current location
//
CopyMem (&MenuOption->Tags[Index], &TagBackup, sizeof (EFI_TAG));
//
// Adjust the array of values
//
for (Index = 0; Index < ValueCount; Index++) {
if (ValueArrayBackup[Index] == (UINT8) TempValue) {
if (Key.UnicodeChar == '+') {
if (Index == 0) {
//
// It is the top of the array already
//
break;
}
TempIndex = Index - 1;
} else {
if ((Index + 1) == ValueCount) {
//
// It is the bottom of the array already
//
break;
}
TempIndex = Index + 1;
}
ValueBackup = ValueArrayBackup[TempIndex];
ValueArrayBackup[TempIndex] = ValueArrayBackup[Index];
ValueArrayBackup[Index] = ValueBackup;
Initialized = TRUE;
break;
}
}
break;
} else {
break;
}
}
}
}
break;
case CHAR_NULL:
switch (Key.ScanCode) {
case SCAN_UP:
case SCAN_DOWN:
if (Key.ScanCode == SCAN_UP) {
if ((TopOptionIndex > 1) && (HighlightPosition == (Top + 1))) {
//
// Highlight reaches the top of the popup window, scroll one menu item.
//
TopOptionIndex--;
ShowDownArrow = TRUE;
}
if (TopOptionIndex == 1) {
ShowUpArrow = FALSE;
}
} else {
if (((TopOptionIndex + MenuLinesInView) <= PopUpMenuLines) && (HighlightPosition == (Bottom - 1))) {
//
// Highlight reaches the bottom of the popup window, scroll one menu item.
//
TopOptionIndex++;
ShowUpArrow = TRUE;
}
if ((TopOptionIndex + MenuLinesInView) == (PopUpMenuLines + 1)) {
ShowDownArrow = FALSE;
}
}
for (Index = MenuOption->TagIndex + TopOptionIndex;
MenuOption->Tags[Index].Operand != EFI_IFR_END_ONE_OF_OP;
Index++
) {
if (MenuOption->Tags[Index].Operand == EFI_IFR_ONE_OF_OPTION_OP) {
if (Initialized) {
for (Index = 0; (ValueArrayBackup[Index] != TempValue) && (Index < ValueCount); Index++)
;
//
// Did we hit the end of the array? Either get the first TempValue or the next one
//
if (Key.ScanCode == SCAN_UP) {
if (Index == 0) {
TempValue = ValueArrayBackup[0];
} else {
TempValue = ValueArrayBackup[Index - 1];
}
} else {
if ((Index + 1) == ValueCount) {
TempValue = ValueArrayBackup[Index];
} else {
TempValue = ValueArrayBackup[Index + 1];
}
}
break;
} else {
if (Key.ScanCode == SCAN_UP) {
TempIndex = Index - 1;
//
// Keep going until meets meaningful tag.
//
while ((MenuOption->Tags[TempIndex].Operand != EFI_IFR_ONE_OF_OPTION_OP &&
MenuOption->Tags[TempIndex].Operand != EFI_IFR_ONE_OF_OP &&
MenuOption->Tags[TempIndex].Operand != EFI_IFR_END_ONE_OF_OP)
||
(MenuOption->Tags[TempIndex].Operand == EFI_IFR_ONE_OF_OPTION_OP &&
(MenuOption->Tags[TempIndex].Suppress || MenuOption->Tags[TempIndex].GrayOut))) {
TempIndex--;
}
} else {
TempIndex = Index + 1;
//
// Keep going until meets meaningful tag.
//
while ((MenuOption->Tags[TempIndex].Operand != EFI_IFR_ONE_OF_OPTION_OP &&
MenuOption->Tags[TempIndex].Operand != EFI_IFR_ONE_OF_OP &&
MenuOption->Tags[TempIndex].Operand != EFI_IFR_END_ONE_OF_OP)
||
(MenuOption->Tags[TempIndex].Operand == EFI_IFR_ONE_OF_OPTION_OP &&
(MenuOption->Tags[TempIndex].Suppress || MenuOption->Tags[TempIndex].GrayOut))) {
TempIndex++;
}
}
//
// The option value is the same as what is stored in NV store. This is where we take action
//
if (MenuOption->Tags[Index].Value == TempValue) {
//
// Only if the previous op-code is an option can we select it, otherwise we are at the left-most option
//
if (MenuOption->Tags[TempIndex].Operand == EFI_IFR_ONE_OF_OPTION_OP) {
TempValue = MenuOption->Tags[TempIndex].Value;
*KeyValue = MenuOption->Tags[TempIndex].Key;
} else {
TempValue = MenuOption->Tags[Index].Value;
*KeyValue = MenuOption->Tags[Index].Key;
}
break;
}
}
}
}
break;
case SCAN_ESC:
gST->ConOut->SetAttribute (gST->ConOut, SavedAttribute);
if (ValueArrayBackup != NULL) {
FreePool (ValueArrayBackup);
}
return EFI_DEVICE_ERROR;
default:
break;
}
break;
case CHAR_CARRIAGE_RETURN:
//
// return the current selection
//
if (Tag->Operand == EFI_IFR_ORDERED_LIST_OP) {
CopyMem (ValueArray, ValueArrayBackup, ValueCount);
FreePool (ValueArrayBackup);
} else {
*Value = TempValue;
}
goto Done;
default:
break;
}
} while (1);
Done:
gST->ConOut->SetAttribute (gST->ConOut, SavedAttribute);
return EFI_SUCCESS;
}
EFI_STATUS
WaitForKeyStroke (
OUT EFI_INPUT_KEY *Key
)
{
EFI_STATUS Status;
do {
UiWaitForSingleEvent (gST->ConIn->WaitForKey, 0);
Status = gST->ConIn->ReadKeyStroke (gST->ConIn, Key);
} while (EFI_ERROR(Status));
return Status;
}
Reference in New Issue View Git Blame Copy Permalink