[mirror_edk2.git] / MdeModulePkg / Universal / DisplayEngineDxe / InputHandler.c

/** @file\r
Implementation for handling user input from the User Interfaces.\r
\r
Copyright (c) 2004 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "FormDisplay.h"\r
\r
/**\r
  Get maximum and minimum info from this opcode.\r
\r
  @param  OpCode            Pointer to the current input opcode.\r
  @param  Minimum           The minimum size info for this opcode.\r
  @param  Maximum           The maximum size info for this opcode.\r
\r
**/\r
VOID\r
GetFieldFromOp (\r
  IN   EFI_IFR_OP_HEADER  *OpCode,\r
  OUT  UINTN              *Minimum,\r
  OUT  UINTN              *Maximum\r
  )\r
{\r
  EFI_IFR_STRING    *StringOp;\r
  EFI_IFR_PASSWORD  *PasswordOp;\r
\r
  if (OpCode->OpCode == EFI_IFR_STRING_OP) {\r
    StringOp = (EFI_IFR_STRING *)OpCode;\r
    *Minimum = StringOp->MinSize;\r
    *Maximum = StringOp->MaxSize;\r
  } else if (OpCode->OpCode == EFI_IFR_PASSWORD_OP) {\r
    PasswordOp = (EFI_IFR_PASSWORD *)OpCode;\r
    *Minimum   = PasswordOp->MinSize;\r
    *Maximum   = PasswordOp->MaxSize;\r
  } else {\r
    *Minimum = 0;\r
    *Maximum = 0;\r
  }\r
}\r
\r
/**\r
  Get string or password input from user.\r
\r
  @param  MenuOption        Pointer to the current input menu.\r
  @param  Prompt            The prompt string shown on popup window.\r
  @param  StringPtr         Old user input and destination for use input string.\r
\r
  @retval EFI_SUCCESS       If string input is read successfully\r
  @retval EFI_DEVICE_ERROR  If operation fails\r
\r
**/\r
EFI_STATUS\r
ReadString (\r
  IN     UI_MENU_OPTION  *MenuOption,\r
  IN     CHAR16          *Prompt,\r
  IN OUT CHAR16          *StringPtr\r
  )\r
{\r
  EFI_STATUS                     Status;\r
  EFI_INPUT_KEY                  Key;\r
  CHAR16                         NullCharacter;\r
  UINTN                          ScreenSize;\r
  CHAR16                         Space[2];\r
  CHAR16                         KeyPad[2];\r
  CHAR16                         *TempString;\r
  CHAR16                         *BufferedString;\r
  UINTN                          Index;\r
  UINTN                          Index2;\r
  UINTN                          Count;\r
  UINTN                          Start;\r
  UINTN                          Top;\r
  UINTN                          DimensionsWidth;\r
  UINTN                          DimensionsHeight;\r
  UINTN                          CurrentCursor;\r
  BOOLEAN                        CursorVisible;\r
  UINTN                          Minimum;\r
  UINTN                          Maximum;\r
  FORM_DISPLAY_ENGINE_STATEMENT  *Question;\r
  BOOLEAN                        IsPassword;\r
  UINTN                          MaxLen;\r
\r
  DimensionsWidth  = gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn;\r
  DimensionsHeight = gStatementDimensions.BottomRow - gStatementDimensions.TopRow;\r
\r
  NullCharacter = CHAR_NULL;\r
  ScreenSize    = GetStringWidth (Prompt) / sizeof (CHAR16);\r
  Space[0]      = L' ';\r
  Space[1]      = CHAR_NULL;\r
\r
  Question = MenuOption->ThisTag;\r
  GetFieldFromOp (Question->OpCode, &Minimum, &Maximum);\r
\r
  if (Question->OpCode->OpCode == EFI_IFR_PASSWORD_OP) {\r
    IsPassword = TRUE;\r
  } else {\r
    IsPassword = FALSE;\r
  }\r
\r
  MaxLen     = Maximum + 1;\r
  TempString = AllocateZeroPool (MaxLen * sizeof (CHAR16));\r
  ASSERT (TempString);\r
\r
  if (ScreenSize < (Maximum + 1)) {\r
    ScreenSize = Maximum + 1;\r
  }\r
\r
  if ((ScreenSize + 2) > DimensionsWidth) {\r
    ScreenSize = DimensionsWidth - 2;\r
  }\r
\r
  BufferedString = AllocateZeroPool (ScreenSize * 2);\r
  ASSERT (BufferedString);\r
\r
  Start = (DimensionsWidth - ScreenSize - 2) / 2 + gStatementDimensions.LeftColumn + 1;\r
  Top   = ((DimensionsHeight - 6) / 2) + gStatementDimensions.TopRow - 1;\r
\r
  //\r
  // Display prompt for string\r
  //\r
  // CreateDialog (NULL, "", Prompt, Space, "", NULL);\r
  CreateMultiStringPopUp (ScreenSize, 4, &NullCharacter, Prompt, Space, &NullCharacter);\r
  gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_BLACK, EFI_LIGHTGRAY));\r
\r
  CursorVisible = gST->ConOut->Mode->CursorVisible;\r
  gST->ConOut->EnableCursor (gST->ConOut, TRUE);\r
\r
  CurrentCursor = GetStringWidth (StringPtr) / 2 - 1;\r
  if (CurrentCursor != 0) {\r
    //\r
    // Show the string which has beed saved before.\r
    //\r
    SetUnicodeMem (BufferedString, ScreenSize - 1, L' ');\r
    PrintStringAt (Start + 1, Top + 3, BufferedString);\r
\r
    if ((GetStringWidth (StringPtr) / 2) > (DimensionsWidth - 2)) {\r
      Index = (GetStringWidth (StringPtr) / 2) - DimensionsWidth + 2;\r
    } else {\r
      Index = 0;\r
    }\r
\r
    if (IsPassword) {\r
      gST->ConOut->SetCursorPosition (gST->ConOut, Start + 1, Top + 3);\r
    }\r
\r
    for (Count = 0; Index + 1 < GetStringWidth (StringPtr) / 2; Index++, Count++) {\r
      BufferedString[Count] = StringPtr[Index];\r
\r
      if (IsPassword) {\r
        PrintCharAt ((UINTN)-1, (UINTN)-1, L'*');\r
      }\r
    }\r
\r
    if (!IsPassword) {\r
      PrintStringAt (Start + 1, Top + 3, BufferedString);\r
    }\r
\r
    gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));\r
    gST->ConOut->SetCursorPosition (gST->ConOut, Start + GetStringWidth (StringPtr) / 2, Top + 3);\r
  }\r
\r
  do {\r
    Status = WaitForKeyStroke (&Key);\r
    ASSERT_EFI_ERROR (Status);\r
\r
    gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_BLACK, EFI_LIGHTGRAY));\r
    switch (Key.UnicodeChar) {\r
      case CHAR_NULL:\r
        switch (Key.ScanCode) {\r
          case SCAN_LEFT:\r
            if (CurrentCursor > 0) {\r
              CurrentCursor--;\r
            }\r
\r
            break;\r
\r
          case SCAN_RIGHT:\r
            if (CurrentCursor < (GetStringWidth (StringPtr) / 2 - 1)) {\r
              CurrentCursor++;\r
            }\r
\r
            break;\r
\r
          case SCAN_ESC:\r
            FreePool (TempString);\r
            FreePool (BufferedString);\r
            gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));\r
            gST->ConOut->EnableCursor (gST->ConOut, CursorVisible);\r
            return EFI_DEVICE_ERROR;\r
\r
          case SCAN_DELETE:\r
            for (Index = CurrentCursor; StringPtr[Index] != CHAR_NULL; Index++) {\r
              StringPtr[Index] = StringPtr[Index + 1];\r
              PrintCharAt (Start + Index + 1, Top + 3, IsPassword && StringPtr[Index] != CHAR_NULL ? L'*' : StringPtr[Index]);\r
            }\r
\r
            break;\r
\r
          default:\r
            break;\r
        }\r
\r
        break;\r
\r
      case CHAR_CARRIAGE_RETURN:\r
        if (GetStringWidth (StringPtr) >= ((Minimum + 1) * sizeof (CHAR16))) {\r
          FreePool (TempString);\r
          FreePool (BufferedString);\r
          gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));\r
          gST->ConOut->EnableCursor (gST->ConOut, CursorVisible);\r
          return EFI_SUCCESS;\r
        } else {\r
          //\r
          // Simply create a popup to tell the user that they had typed in too few characters.\r
          // To save code space, we can then treat this as an error and return back to the menu.\r
          //\r
          do {\r
            CreateDialog (&Key, &NullCharacter, gMiniString, gPressEnter, &NullCharacter, NULL);\r
          } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
\r
          FreePool (TempString);\r
          FreePool (BufferedString);\r
          gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));\r
          gST->ConOut->EnableCursor (gST->ConOut, CursorVisible);\r
          return EFI_DEVICE_ERROR;\r
        }\r
\r
      case CHAR_BACKSPACE:\r
        if ((StringPtr[0] != CHAR_NULL) && (CurrentCursor != 0)) {\r
          for (Index = 0; Index < CurrentCursor - 1; Index++) {\r
            TempString[Index] = StringPtr[Index];\r
          }\r
\r
          Count = GetStringWidth (StringPtr) / 2 - 1;\r
          if (Count >= CurrentCursor) {\r
            for (Index = CurrentCursor - 1, Index2 = CurrentCursor; Index2 < Count; Index++, Index2++) {\r
              TempString[Index] = StringPtr[Index2];\r
            }\r
\r
            TempString[Index] = CHAR_NULL;\r
          }\r
\r
          //\r
          // Effectively truncate string by 1 character\r
          //\r
          StrCpyS (StringPtr, MaxLen, TempString);\r
          CurrentCursor--;\r
        }\r
\r
      default:\r
        //\r
        // If it is the beginning of the string, don't worry about checking maximum limits\r
        //\r
        if ((StringPtr[0] == CHAR_NULL) && (Key.UnicodeChar != CHAR_BACKSPACE)) {\r
          StrnCpyS (StringPtr, MaxLen, &Key.UnicodeChar, 1);\r
          CurrentCursor++;\r
        } else if ((GetStringWidth (StringPtr) < ((Maximum + 1) * sizeof (CHAR16))) && (Key.UnicodeChar != CHAR_BACKSPACE)) {\r
          KeyPad[0] = Key.UnicodeChar;\r
          KeyPad[1] = CHAR_NULL;\r
          Count     = GetStringWidth (StringPtr) / 2 - 1;\r
          if (CurrentCursor < Count) {\r
            for (Index = 0; Index < CurrentCursor; Index++) {\r
              TempString[Index] = StringPtr[Index];\r
            }\r
\r
            TempString[Index] = CHAR_NULL;\r
            StrCatS (TempString, MaxLen, KeyPad);\r
            StrCatS (TempString, MaxLen, StringPtr + CurrentCursor);\r
            StrCpyS (StringPtr, MaxLen, TempString);\r
          } else {\r
            StrCatS (StringPtr, MaxLen, KeyPad);\r
          }\r
\r
          CurrentCursor++;\r
        }\r
\r
        //\r
        // If the width of the input string is now larger than the screen, we nee to\r
        // adjust the index to start printing portions of the string\r
        //\r
        SetUnicodeMem (BufferedString, ScreenSize - 1, L' ');\r
        PrintStringAt (Start + 1, Top + 3, BufferedString);\r
\r
        if ((GetStringWidth (StringPtr) / 2) > (DimensionsWidth - 2)) {\r
          Index = (GetStringWidth (StringPtr) / 2) - DimensionsWidth + 2;\r
        } else {\r
          Index = 0;\r
        }\r
\r
        if (IsPassword) {\r
          gST->ConOut->SetCursorPosition (gST->ConOut, Start + 1, Top + 3);\r
        }\r
\r
        for (Count = 0; Index + 1 < GetStringWidth (StringPtr) / 2; Index++, Count++) {\r
          BufferedString[Count] = StringPtr[Index];\r
\r
          if (IsPassword) {\r
            PrintCharAt ((UINTN)-1, (UINTN)-1, L'*');\r
          }\r
        }\r
\r
        if (!IsPassword) {\r
          PrintStringAt (Start + 1, Top + 3, BufferedString);\r
        }\r
\r
        break;\r
    }\r
\r
    gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));\r
    gST->ConOut->SetCursorPosition (gST->ConOut, Start + CurrentCursor + 1, Top + 3);\r
  } while (TRUE);\r
}\r
\r
/**\r
  Adjust the value to the correct one. Rules follow the sample:\r
  like:  Year change:  2012.02.29 -> 2013.02.29 -> 2013.02.01\r
         Month change: 2013.03.29 -> 2013.02.29 -> 2013.02.28\r
\r
  @param  QuestionValue     Pointer to current question.\r
  @param  Sequence          The sequence of the field in the question.\r
**/\r
VOID\r
AdjustQuestionValue (\r
  IN  EFI_HII_VALUE  *QuestionValue,\r
  IN  UINT8          Sequence\r
  )\r
{\r
  UINT8   Month;\r
  UINT16  Year;\r
  UINT8   Maximum;\r
  UINT8   Minimum;\r
\r
  Month   = QuestionValue->Value.date.Month;\r
  Year    = QuestionValue->Value.date.Year;\r
  Minimum = 1;\r
\r
  switch (Month) {\r
    case 2:\r
      if (((Year % 4) == 0) && (((Year % 100) != 0) || ((Year % 400) == 0))) {\r
        Maximum = 29;\r
      } else {\r
        Maximum = 28;\r
      }\r
\r
      break;\r
    case 4:\r
    case 6:\r
    case 9:\r
    case 11:\r
      Maximum = 30;\r
      break;\r
    default:\r
      Maximum = 31;\r
      break;\r
  }\r
\r
  //\r
  // Change the month area.\r
  //\r
  if (Sequence == 0) {\r
    if (QuestionValue->Value.date.Day > Maximum) {\r
      QuestionValue->Value.date.Day = Maximum;\r
    }\r
  }\r
\r
  //\r
  // Change the Year area.\r
  //\r
  if (Sequence == 2) {\r
    if (QuestionValue->Value.date.Day > Maximum) {\r
      QuestionValue->Value.date.Day = Minimum;\r
    }\r
  }\r
}\r
\r
/**\r
  Get field info from numeric opcode.\r
\r
  @param  OpCode            Pointer to the current input opcode.\r
  @param  IntInput          Whether question shows with EFI_IFR_DISPLAY_INT_DEC type.\r
  @param  QuestionValue     Input question value, with EFI_HII_VALUE type.\r
  @param  Value             Return question value, always return UINT64 type.\r
  @param  Minimum           The minimum size info for this opcode.\r
  @param  Maximum           The maximum size info for this opcode.\r
  @param  Step              The step size info for this opcode.\r
  @param  StorageWidth      The storage width info for this opcode.\r
\r
**/\r
VOID\r
GetValueFromNum (\r
  IN  EFI_IFR_OP_HEADER  *OpCode,\r
  IN  BOOLEAN            IntInput,\r
  IN  EFI_HII_VALUE      *QuestionValue,\r
  OUT UINT64             *Value,\r
  OUT UINT64             *Minimum,\r
  OUT UINT64             *Maximum,\r
  OUT UINT64             *Step,\r
  OUT UINT16             *StorageWidth\r
  )\r
{\r
  EFI_IFR_NUMERIC  *NumericOp;\r
\r
  NumericOp = (EFI_IFR_NUMERIC *)OpCode;\r
\r
  switch (NumericOp->Flags & EFI_IFR_NUMERIC_SIZE) {\r
    case EFI_IFR_NUMERIC_SIZE_1:\r
      if (IntInput) {\r
        *Minimum = (INT64)(INT8)NumericOp->data.u8.MinValue;\r
        *Maximum = (INT64)(INT8)NumericOp->data.u8.MaxValue;\r
        *Value   = (INT64)(INT8)QuestionValue->Value.u8;\r
      } else {\r
        *Minimum = NumericOp->data.u8.MinValue;\r
        *Maximum = NumericOp->data.u8.MaxValue;\r
        *Value   = QuestionValue->Value.u8;\r
      }\r
\r
      *Step         = NumericOp->data.u8.Step;\r
      *StorageWidth = (UINT16)sizeof (UINT8);\r
      break;\r
\r
    case EFI_IFR_NUMERIC_SIZE_2:\r
      if (IntInput) {\r
        *Minimum = (INT64)(INT16)NumericOp->data.u16.MinValue;\r
        *Maximum = (INT64)(INT16)NumericOp->data.u16.MaxValue;\r
        *Value   = (INT64)(INT16)QuestionValue->Value.u16;\r
      } else {\r
        *Minimum = NumericOp->data.u16.MinValue;\r
        *Maximum = NumericOp->data.u16.MaxValue;\r
        *Value   = QuestionValue->Value.u16;\r
      }\r
\r
      *Step         = NumericOp->data.u16.Step;\r
      *StorageWidth = (UINT16)sizeof (UINT16);\r
      break;\r
\r
    case EFI_IFR_NUMERIC_SIZE_4:\r
      if (IntInput) {\r
        *Minimum = (INT64)(INT32)NumericOp->data.u32.MinValue;\r
        *Maximum = (INT64)(INT32)NumericOp->data.u32.MaxValue;\r
        *Value   = (INT64)(INT32)QuestionValue->Value.u32;\r
      } else {\r
        *Minimum = NumericOp->data.u32.MinValue;\r
        *Maximum = NumericOp->data.u32.MaxValue;\r
        *Value   = QuestionValue->Value.u32;\r
      }\r
\r
      *Step         = NumericOp->data.u32.Step;\r
      *StorageWidth = (UINT16)sizeof (UINT32);\r
      break;\r
\r
    case EFI_IFR_NUMERIC_SIZE_8:\r
      if (IntInput) {\r
        *Minimum = (INT64)NumericOp->data.u64.MinValue;\r
        *Maximum = (INT64)NumericOp->data.u64.MaxValue;\r
        *Value   = (INT64)QuestionValue->Value.u64;\r
      } else {\r
        *Minimum = NumericOp->data.u64.MinValue;\r
        *Maximum = NumericOp->data.u64.MaxValue;\r
        *Value   = QuestionValue->Value.u64;\r
      }\r
\r
      *Step         = NumericOp->data.u64.Step;\r
      *StorageWidth = (UINT16)sizeof (UINT64);\r
      break;\r
\r
    default:\r
      break;\r
  }\r
\r
  if (*Maximum == 0) {\r
    *Maximum = (UINT64)-1;\r
  }\r
}\r
\r
/**\r
  This routine reads a numeric value from the user input.\r
\r
  @param  MenuOption        Pointer to the current input menu.\r
\r
  @retval EFI_SUCCESS       If numerical input is read successfully\r
  @retval EFI_DEVICE_ERROR  If operation fails\r
\r
**/\r
EFI_STATUS\r
GetNumericInput (\r
  IN  UI_MENU_OPTION  *MenuOption\r
  )\r
{\r
  UINTN                          Column;\r
  UINTN                          Row;\r
  CHAR16                         InputText[MAX_NUMERIC_INPUT_WIDTH];\r
  CHAR16                         FormattedNumber[MAX_NUMERIC_INPUT_WIDTH - 1];\r
  UINT64                         PreviousNumber[MAX_NUMERIC_INPUT_WIDTH - 3];\r
  UINTN                          Count;\r
  UINTN                          Loop;\r
  BOOLEAN                        ManualInput;\r
  BOOLEAN                        HexInput;\r
  BOOLEAN                        IntInput;\r
  BOOLEAN                        Negative;\r
  BOOLEAN                        ValidateFail;\r
  BOOLEAN                        DateOrTime;\r
  UINTN                          InputWidth;\r
  UINT64                         EditValue;\r
  UINT64                         Step;\r
  UINT64                         Minimum;\r
  UINT64                         Maximum;\r
  UINTN                          EraseLen;\r
  UINT8                          Digital;\r
  EFI_INPUT_KEY                  Key;\r
  EFI_HII_VALUE                  *QuestionValue;\r
  FORM_DISPLAY_ENGINE_STATEMENT  *Question;\r
  EFI_IFR_NUMERIC                *NumericOp;\r
  UINT16                         StorageWidth;\r
\r
  Column            = MenuOption->OptCol;\r
  Row               = MenuOption->Row;\r
  PreviousNumber[0] = 0;\r
  Count             = 0;\r
  InputWidth        = 0;\r
  Digital           = 0;\r
  StorageWidth      = 0;\r
  Minimum           = 0;\r
  Maximum           = 0;\r
  NumericOp         = NULL;\r
  IntInput          = FALSE;\r
  HexInput          = FALSE;\r
  Negative          = FALSE;\r
  ValidateFail      = FALSE;\r
\r
  Question      = MenuOption->ThisTag;\r
  QuestionValue = &Question->CurrentValue;\r
  ZeroMem (InputText, MAX_NUMERIC_INPUT_WIDTH * sizeof (CHAR16));\r
\r
  //\r
  // Only two case, user can enter to this function: Enter and +/- case.\r
  // In Enter case, gDirection = 0; in +/- case, gDirection = SCAN_LEFT/SCAN_WRIGHT\r
  //\r
  ManualInput = (BOOLEAN)(gDirection == 0 ? TRUE : FALSE);\r
\r
  if ((Question->OpCode->OpCode == EFI_IFR_DATE_OP) || (Question->OpCode->OpCode == EFI_IFR_TIME_OP)) {\r
    DateOrTime = TRUE;\r
  } else {\r
    DateOrTime = FALSE;\r
  }\r
\r
  //\r
  // Prepare Value to be edit\r
  //\r
  EraseLen  = 0;\r
  EditValue = 0;\r
  if (Question->OpCode->OpCode == EFI_IFR_DATE_OP) {\r
    Step    = 1;\r
    Minimum = 1;\r
\r
    switch (MenuOption->Sequence) {\r
      case 0:\r
        Maximum   = 12;\r
        EraseLen  = 4;\r
        EditValue = QuestionValue->Value.date.Month;\r
        break;\r
\r
      case 1:\r
        switch (QuestionValue->Value.date.Month) {\r
          case 2:\r
            if (((QuestionValue->Value.date.Year % 4) == 0) &&\r
                (((QuestionValue->Value.date.Year % 100) != 0) ||\r
                 ((QuestionValue->Value.date.Year % 400) == 0)))\r
            {\r
              Maximum = 29;\r
            } else {\r
              Maximum = 28;\r
            }\r
\r
            break;\r
          case 4:\r
          case 6:\r
          case 9:\r
          case 11:\r
            Maximum = 30;\r
            break;\r
          default:\r
            Maximum = 31;\r
            break;\r
        }\r
\r
        EraseLen  = 3;\r
        EditValue = QuestionValue->Value.date.Day;\r
        break;\r
\r
      case 2:\r
        Maximum   = 0xffff;\r
        EraseLen  = 5;\r
        EditValue = QuestionValue->Value.date.Year;\r
        break;\r
\r
      default:\r
        break;\r
    }\r
  } else if (Question->OpCode->OpCode == EFI_IFR_TIME_OP) {\r
    Step    = 1;\r
    Minimum = 0;\r
\r
    switch (MenuOption->Sequence) {\r
      case 0:\r
        Maximum   = 23;\r
        EraseLen  = 4;\r
        EditValue = QuestionValue->Value.time.Hour;\r
        break;\r
\r
      case 1:\r
        Maximum   = 59;\r
        EraseLen  = 3;\r
        EditValue = QuestionValue->Value.time.Minute;\r
        break;\r
\r
      case 2:\r
        Maximum   = 59;\r
        EraseLen  = 3;\r
        EditValue = QuestionValue->Value.time.Second;\r
        break;\r
\r
      default:\r
        break;\r
    }\r
  } else {\r
    ASSERT (Question->OpCode->OpCode == EFI_IFR_NUMERIC_OP);\r
    NumericOp = (EFI_IFR_NUMERIC *)Question->OpCode;\r
    GetValueFromNum (Question->OpCode, (NumericOp->Flags & EFI_IFR_DISPLAY) == 0, QuestionValue, &EditValue, &Minimum, &Maximum, &Step, &StorageWidth);\r
    EraseLen = gOptionBlockWidth;\r
  }\r
\r
  if ((Question->OpCode->OpCode == EFI_IFR_NUMERIC_OP) && (NumericOp != NULL)) {\r
    if ((NumericOp->Flags & EFI_IFR_DISPLAY) == EFI_IFR_DISPLAY_UINT_HEX) {\r
      HexInput = TRUE;\r
    } else if ((NumericOp->Flags & EFI_IFR_DISPLAY) == 0) {\r
      //\r
      // Display with EFI_IFR_DISPLAY_INT_DEC type. Support negative number.\r
      //\r
      IntInput = TRUE;\r
    }\r
  }\r
\r
  //\r
  // Enter from "Enter" input, clear the old word showing.\r
  //\r
  if (ManualInput) {\r
    if (Question->OpCode->OpCode == EFI_IFR_NUMERIC_OP) {\r
      if (HexInput) {\r
        InputWidth = StorageWidth * 2;\r
      } else {\r
        switch (StorageWidth) {\r
          case 1:\r
            InputWidth = 3;\r
            break;\r
\r
          case 2:\r
            InputWidth = 5;\r
            break;\r
\r
          case 4:\r
            InputWidth = 10;\r
            break;\r
\r
          case 8:\r
            InputWidth = 20;\r
            break;\r
\r
          default:\r
            InputWidth = 0;\r
            break;\r
        }\r
\r
        if (IntInput) {\r
          //\r
          // Support an extra '-' for negative number.\r
          //\r
          InputWidth += 1;\r
        }\r
      }\r
\r
      InputText[0] = LEFT_NUMERIC_DELIMITER;\r
      SetUnicodeMem (InputText + 1, InputWidth, L' ');\r
      ASSERT (InputWidth + 2 < MAX_NUMERIC_INPUT_WIDTH);\r
      InputText[InputWidth + 1] = RIGHT_NUMERIC_DELIMITER;\r
      InputText[InputWidth + 2] = L'\0';\r
\r
      PrintStringAt (Column, Row, InputText);\r
      Column++;\r
    }\r
\r
    if (Question->OpCode->OpCode == EFI_IFR_DATE_OP) {\r
      if (MenuOption->Sequence == 2) {\r
        InputWidth = 4;\r
      } else {\r
        InputWidth = 2;\r
      }\r
\r
      if (MenuOption->Sequence == 0) {\r
        InputText[0] = LEFT_NUMERIC_DELIMITER;\r
        SetUnicodeMem (InputText + 1, InputWidth, L' ');\r
        InputText[InputWidth + 1] = DATE_SEPARATOR;\r
        InputText[InputWidth + 2] = L'\0';\r
      } else if (MenuOption->Sequence == 1) {\r
        SetUnicodeMem (InputText, InputWidth, L' ');\r
        InputText[InputWidth]     = DATE_SEPARATOR;\r
        InputText[InputWidth + 1] = L'\0';\r
      } else {\r
        SetUnicodeMem (InputText, InputWidth, L' ');\r
        InputText[InputWidth]     = RIGHT_NUMERIC_DELIMITER;\r
        InputText[InputWidth + 1] = L'\0';\r
      }\r
\r
      PrintStringAt (Column, Row, InputText);\r
      if (MenuOption->Sequence == 0) {\r
        Column++;\r
      }\r
    }\r
\r
    if (Question->OpCode->OpCode == EFI_IFR_TIME_OP) {\r
      InputWidth = 2;\r
\r
      if (MenuOption->Sequence == 0) {\r
        InputText[0] = LEFT_NUMERIC_DELIMITER;\r
        SetUnicodeMem (InputText + 1, InputWidth, L' ');\r
        InputText[InputWidth + 1] = TIME_SEPARATOR;\r
        InputText[InputWidth + 2] = L'\0';\r
      } else if (MenuOption->Sequence == 1) {\r
        SetUnicodeMem (InputText, InputWidth, L' ');\r
        InputText[InputWidth]     = TIME_SEPARATOR;\r
        InputText[InputWidth + 1] = L'\0';\r
      } else {\r
        SetUnicodeMem (InputText, InputWidth, L' ');\r
        InputText[InputWidth]     = RIGHT_NUMERIC_DELIMITER;\r
        InputText[InputWidth + 1] = L'\0';\r
      }\r
\r
      PrintStringAt (Column, Row, InputText);\r
      if (MenuOption->Sequence == 0) {\r
        Column++;\r
      }\r
    }\r
  }\r
\r
  //\r
  // First time we enter this handler, we need to check to see if\r
  // we were passed an increment or decrement directive\r
  //\r
  do {\r
    Key.UnicodeChar = CHAR_NULL;\r
    if (gDirection != 0) {\r
      Key.ScanCode = gDirection;\r
      gDirection   = 0;\r
      goto TheKey2;\r
    }\r
\r
    WaitForKeyStroke (&Key);\r
\r
TheKey2:\r
    switch (Key.UnicodeChar) {\r
      case '+':\r
      case '-':\r
        if (ManualInput && IntInput) {\r
          //\r
          // In Manual input mode, check whether input the negative flag.\r
          //\r
          if (Key.UnicodeChar == '-') {\r
            if (Negative) {\r
              break;\r
            }\r
\r
            Negative = TRUE;\r
            PrintCharAt (Column++, Row, Key.UnicodeChar);\r
          }\r
        } else {\r
          if (Key.UnicodeChar == '+') {\r
            Key.ScanCode = SCAN_RIGHT;\r
          } else {\r
            Key.ScanCode = SCAN_LEFT;\r
          }\r
\r
          Key.UnicodeChar = CHAR_NULL;\r
          goto TheKey2;\r
        }\r
\r
        break;\r
\r
      case CHAR_NULL:\r
        switch (Key.ScanCode) {\r
          case SCAN_LEFT:\r
          case SCAN_RIGHT:\r
            if (DateOrTime && !ManualInput) {\r
              //\r
              // By setting this value, we will return back to the caller.\r
              // We need to do this since an auto-refresh will destroy the adjustment\r
              // based on what the real-time-clock is showing.  So we always commit\r
              // upon changing the value.\r
              //\r
              gDirection = SCAN_DOWN;\r
            }\r
\r
            if ((Step != 0) && !ManualInput) {\r
              if (Key.ScanCode == SCAN_LEFT) {\r
                if (IntInput) {\r
                  if ((INT64)EditValue >= (INT64)Minimum + (INT64)Step) {\r
                    EditValue = EditValue - Step;\r
                  } else if ((INT64)EditValue > (INT64)Minimum) {\r
                    EditValue = Minimum;\r
                  } else {\r
                    EditValue = Maximum;\r
                  }\r
                } else {\r
                  if (EditValue >= Minimum + Step) {\r
                    EditValue = EditValue - Step;\r
                  } else if (EditValue > Minimum) {\r
                    EditValue = Minimum;\r
                  } else {\r
                    EditValue = Maximum;\r
                  }\r
                }\r
              } else if (Key.ScanCode == SCAN_RIGHT) {\r
                if (IntInput) {\r
                  if ((INT64)EditValue + (INT64)Step <= (INT64)Maximum) {\r
                    EditValue = EditValue + Step;\r
                  } else if ((INT64)EditValue < (INT64)Maximum) {\r
                    EditValue = Maximum;\r
                  } else {\r
                    EditValue = Minimum;\r
                  }\r
                } else {\r
                  if (EditValue + Step <= Maximum) {\r
                    EditValue = EditValue + Step;\r
                  } else if (EditValue < Maximum) {\r
                    EditValue = Maximum;\r
                  } else {\r
                    EditValue = Minimum;\r
                  }\r
                }\r
              }\r
\r
              ZeroMem (FormattedNumber, 21 * sizeof (CHAR16));\r
              if (Question->OpCode->OpCode == EFI_IFR_DATE_OP) {\r
                if (MenuOption->Sequence == 2) {\r
                  //\r
                  // Year\r
                  //\r
                  UnicodeSPrint (FormattedNumber, 21 * sizeof (CHAR16), L"%04d", (UINT16)EditValue);\r
                } else {\r
                  //\r
                  // Month/Day\r
                  //\r
                  UnicodeSPrint (FormattedNumber, 21 * sizeof (CHAR16), L"%02d", (UINT8)EditValue);\r
                }\r
\r
                if (MenuOption->Sequence == 0) {\r
                  ASSERT (EraseLen >= 2);\r
                  FormattedNumber[EraseLen - 2] = DATE_SEPARATOR;\r
                } else if (MenuOption->Sequence == 1) {\r
                  ASSERT (EraseLen >= 1);\r
                  FormattedNumber[EraseLen - 1] = DATE_SEPARATOR;\r
                }\r
              } else if (Question->OpCode->OpCode == EFI_IFR_TIME_OP) {\r
                UnicodeSPrint (FormattedNumber, 21 * sizeof (CHAR16), L"%02d", (UINT8)EditValue);\r
\r
                if (MenuOption->Sequence == 0) {\r
                  ASSERT (EraseLen >= 2);\r
                  FormattedNumber[EraseLen - 2] = TIME_SEPARATOR;\r
                } else if (MenuOption->Sequence == 1) {\r
                  ASSERT (EraseLen >= 1);\r
                  FormattedNumber[EraseLen - 1] = TIME_SEPARATOR;\r
                }\r
              } else {\r
                QuestionValue->Value.u64 = EditValue;\r
                PrintFormattedNumber (Question, FormattedNumber, 21 * sizeof (CHAR16));\r
              }\r
\r
              gST->ConOut->SetAttribute (gST->ConOut, GetFieldTextColor ());\r
              for (Loop = 0; Loop < EraseLen; Loop++) {\r
                PrintStringAt (MenuOption->OptCol + Loop, MenuOption->Row, L" ");\r
              }\r
\r
              gST->ConOut->SetAttribute (gST->ConOut, GetHighlightTextColor ());\r
\r
              if (MenuOption->Sequence == 0) {\r
                PrintCharAt (MenuOption->OptCol, Row, LEFT_NUMERIC_DELIMITER);\r
                Column = MenuOption->OptCol + 1;\r
              }\r
\r
              PrintStringAt (Column, Row, FormattedNumber);\r
\r
              if (!DateOrTime || (MenuOption->Sequence == 2)) {\r
                PrintCharAt ((UINTN)-1, (UINTN)-1, RIGHT_NUMERIC_DELIMITER);\r
              }\r
            }\r
\r
            goto EnterCarriageReturn;\r
\r
          case SCAN_UP:\r
          case SCAN_DOWN:\r
            goto EnterCarriageReturn;\r
\r
          case SCAN_ESC:\r
            return EFI_DEVICE_ERROR;\r
\r
          default:\r
            break;\r
        }\r
\r
        break;\r
\r
EnterCarriageReturn:\r
\r
      case CHAR_CARRIAGE_RETURN:\r
        //\r
        // Validate input value with Minimum value.\r
        //\r
        ValidateFail = FALSE;\r
        if (IntInput) {\r
          //\r
          // After user input Enter, need to check whether the input value.\r
          // If input a negative value, should compare with maximum value.\r
          // else compare with the minimum value.\r
          //\r
          if (Negative) {\r
            ValidateFail = (INT64)EditValue > (INT64)Maximum ? TRUE : FALSE;\r
          } else {\r
            ValidateFail = (INT64)EditValue < (INT64)Minimum ? TRUE : FALSE;\r
          }\r
\r
          if (ValidateFail) {\r
            UpdateStatusBar (INPUT_ERROR, TRUE);\r
            break;\r
          }\r
        } else if (EditValue < Minimum) {\r
          UpdateStatusBar (INPUT_ERROR, TRUE);\r
          break;\r
        }\r
\r
        UpdateStatusBar (INPUT_ERROR, FALSE);\r
        CopyMem (&gUserInput->InputValue, &Question->CurrentValue, sizeof (EFI_HII_VALUE));\r
        QuestionValue = &gUserInput->InputValue;\r
        //\r
        // Store Edit value back to Question\r
        //\r
        if (Question->OpCode->OpCode == EFI_IFR_DATE_OP) {\r
          switch (MenuOption->Sequence) {\r
            case 0:\r
              QuestionValue->Value.date.Month = (UINT8)EditValue;\r
              break;\r
\r
            case 1:\r
              QuestionValue->Value.date.Day = (UINT8)EditValue;\r
              break;\r
\r
            case 2:\r
              QuestionValue->Value.date.Year = (UINT16)EditValue;\r
              break;\r
\r
            default:\r
              break;\r
          }\r
        } else if (Question->OpCode->OpCode  == EFI_IFR_TIME_OP) {\r
          switch (MenuOption->Sequence) {\r
            case 0:\r
              QuestionValue->Value.time.Hour = (UINT8)EditValue;\r
              break;\r
\r
            case 1:\r
              QuestionValue->Value.time.Minute = (UINT8)EditValue;\r
              break;\r
\r
            case 2:\r
              QuestionValue->Value.time.Second = (UINT8)EditValue;\r
              break;\r
\r
            default:\r
              break;\r
          }\r
        } else {\r
          //\r
          // Numeric\r
          //\r
          QuestionValue->Value.u64 = EditValue;\r
        }\r
\r
        //\r
        // Adjust the value to the correct one.\r
        // Sample like: 2012.02.29 -> 2013.02.29 -> 2013.02.01\r
        //              2013.03.29 -> 2013.02.29 -> 2013.02.28\r
        //\r
        if ((Question->OpCode->OpCode  == EFI_IFR_DATE_OP) &&\r
            ((MenuOption->Sequence == 0) || (MenuOption->Sequence == 2)))\r
        {\r
          AdjustQuestionValue (QuestionValue, (UINT8)MenuOption->Sequence);\r
        }\r
\r
        return EFI_SUCCESS;\r
\r
      case CHAR_BACKSPACE:\r
        if (ManualInput) {\r
          if (Count == 0) {\r
            if (Negative) {\r
              Negative = FALSE;\r
              Column--;\r
              PrintStringAt (Column, Row, L" ");\r
            }\r
\r
            break;\r
          }\r
\r
          //\r
          // Remove a character\r
          //\r
          EditValue = PreviousNumber[Count - 1];\r
          UpdateStatusBar (INPUT_ERROR, FALSE);\r
          Count--;\r
          Column--;\r
          PrintStringAt (Column, Row, L" ");\r
        }\r
\r
        break;\r
\r
      default:\r
        if (ManualInput) {\r
          if (HexInput) {\r
            if ((Key.UnicodeChar >= L'0') && (Key.UnicodeChar <= L'9')) {\r
              Digital = (UINT8)(Key.UnicodeChar - L'0');\r
            } else if ((Key.UnicodeChar >= L'A') && (Key.UnicodeChar <= L'F')) {\r
              Digital = (UINT8)(Key.UnicodeChar - L'A' + 0x0A);\r
            } else if ((Key.UnicodeChar >= L'a') && (Key.UnicodeChar <= L'f')) {\r
              Digital = (UINT8)(Key.UnicodeChar - L'a' + 0x0A);\r
            } else {\r
              UpdateStatusBar (INPUT_ERROR, TRUE);\r
              break;\r
            }\r
          } else {\r
            if ((Key.UnicodeChar > L'9') || (Key.UnicodeChar < L'0')) {\r
              UpdateStatusBar (INPUT_ERROR, TRUE);\r
              break;\r
            }\r
          }\r
\r
          //\r
          // If Count exceed input width, there is no way more is valid\r
          //\r
          if (Count >= InputWidth) {\r
            break;\r
          }\r
\r
          //\r
          // Someone typed something valid!\r
          //\r
          if (Count != 0) {\r
            if (HexInput) {\r
              EditValue = LShiftU64 (EditValue, 4) + Digital;\r
            } else if (IntInput && Negative) {\r
              //\r
              // Save the negative number.\r
              //\r
              EditValue = ~(MultU64x32 (~(EditValue - 1), 10) + (Key.UnicodeChar - L'0')) + 1;\r
            } else {\r
              EditValue = MultU64x32 (EditValue, 10) + (Key.UnicodeChar - L'0');\r
            }\r
          } else {\r
            if (HexInput) {\r
              EditValue = Digital;\r
            } else if (IntInput && Negative) {\r
              //\r
              // Save the negative number.\r
              //\r
              EditValue = ~(Key.UnicodeChar - L'0') + 1;\r
            } else {\r
              EditValue = Key.UnicodeChar - L'0';\r
            }\r
          }\r
\r
          if (IntInput) {\r
            ValidateFail = FALSE;\r
            //\r
            // When user input a new value, should check the current value.\r
            // If user input a negative value, should compare it with minimum\r
            // value, else compare it with maximum value.\r
            //\r
            if (Negative) {\r
              ValidateFail = (INT64)EditValue < (INT64)Minimum ? TRUE : FALSE;\r
            } else {\r
              ValidateFail = (INT64)EditValue > (INT64)Maximum ? TRUE : FALSE;\r
            }\r
\r
            if (ValidateFail) {\r
              UpdateStatusBar (INPUT_ERROR, TRUE);\r
              ASSERT (Count < ARRAY_SIZE (PreviousNumber));\r
              EditValue = PreviousNumber[Count];\r
              break;\r
            }\r
          } else {\r
            if (EditValue > Maximum) {\r
              UpdateStatusBar (INPUT_ERROR, TRUE);\r
              ASSERT (Count < ARRAY_SIZE (PreviousNumber));\r
              EditValue = PreviousNumber[Count];\r
              break;\r
            }\r
          }\r
\r
          UpdateStatusBar (INPUT_ERROR, FALSE);\r
\r
          Count++;\r
          ASSERT (Count < (ARRAY_SIZE (PreviousNumber)));\r
          PreviousNumber[Count] = EditValue;\r
\r
          gST->ConOut->SetAttribute (gST->ConOut, GetHighlightTextColor ());\r
          PrintCharAt (Column, Row, Key.UnicodeChar);\r
          Column++;\r
        }\r
\r
        break;\r
    }\r
  } while (TRUE);\r
}\r
\r
/**\r
  Adjust option order base on the question value.\r
\r
  @param  Question           Pointer to current question.\r
  @param  PopUpMenuLines     The line number of the pop up menu.\r
\r
  @retval EFI_SUCCESS       If Option input is processed successfully\r
  @retval EFI_DEVICE_ERROR  If operation fails\r
\r
**/\r
EFI_STATUS\r
AdjustOptionOrder (\r
  IN  FORM_DISPLAY_ENGINE_STATEMENT  *Question,\r
  OUT UINTN                          *PopUpMenuLines\r
  )\r
{\r
  UINTN                    Index;\r
  EFI_IFR_ORDERED_LIST     *OrderList;\r
  UINT8                    *ValueArray;\r
  UINT8                    ValueType;\r
  LIST_ENTRY               *Link;\r
  DISPLAY_QUESTION_OPTION  *OneOfOption;\r
  EFI_HII_VALUE            *HiiValueArray;\r
\r
  Link        = GetFirstNode (&Question->OptionListHead);\r
  OneOfOption = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);\r
  ValueArray  = Question->CurrentValue.Buffer;\r
  ValueType   =  OneOfOption->OptionOpCode->Type;\r
  OrderList   = (EFI_IFR_ORDERED_LIST *)Question->OpCode;\r
\r
  for (Index = 0; Index < OrderList->MaxContainers; Index++) {\r
    if (GetArrayData (ValueArray, ValueType, Index) == 0) {\r
      break;\r
    }\r
  }\r
\r
  *PopUpMenuLines = Index;\r
\r
  //\r
  // Prepare HiiValue array\r
  //\r
  HiiValueArray = AllocateZeroPool (*PopUpMenuLines * sizeof (EFI_HII_VALUE));\r
  ASSERT (HiiValueArray != NULL);\r
\r
  for (Index = 0; Index < *PopUpMenuLines; Index++) {\r
    HiiValueArray[Index].Type      = ValueType;\r
    HiiValueArray[Index].Value.u64 = GetArrayData (ValueArray, ValueType, Index);\r
  }\r
\r
  for (Index = 0; Index < *PopUpMenuLines; Index++) {\r
    OneOfOption = ValueToOption (Question, &HiiValueArray[*PopUpMenuLines - Index - 1]);\r
    if (OneOfOption == NULL) {\r
      return EFI_NOT_FOUND;\r
    }\r
\r
    RemoveEntryList (&OneOfOption->Link);\r
\r
    //\r
    // Insert to head.\r
    //\r
    InsertHeadList (&Question->OptionListHead, &OneOfOption->Link);\r
  }\r
\r
  FreePool (HiiValueArray);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Base on the type to compare the value.\r
\r
  @param  Value1                The first value need to compare.\r
  @param  Value2                The second value need to compare.\r
  @param  Type                  The value type for above two values.\r
\r
  @retval TRUE                  The two value are same.\r
  @retval FALSE                 The two value are different.\r
\r
**/\r
BOOLEAN\r
IsValuesEqual (\r
  IN EFI_IFR_TYPE_VALUE  *Value1,\r
  IN EFI_IFR_TYPE_VALUE  *Value2,\r
  IN UINT8               Type\r
  )\r
{\r
  switch (Type) {\r
    case EFI_IFR_TYPE_BOOLEAN:\r
    case EFI_IFR_TYPE_NUM_SIZE_8:\r
      return (BOOLEAN)(Value1->u8 == Value2->u8);\r
\r
    case EFI_IFR_TYPE_NUM_SIZE_16:\r
      return (BOOLEAN)(Value1->u16 == Value2->u16);\r
\r
    case EFI_IFR_TYPE_NUM_SIZE_32:\r
      return (BOOLEAN)(Value1->u32 == Value2->u32);\r
\r
    case EFI_IFR_TYPE_NUM_SIZE_64:\r
      return (BOOLEAN)(Value1->u64 == Value2->u64);\r
\r
    default:\r
      ASSERT (FALSE);\r
      return FALSE;\r
  }\r
}\r
\r
/**\r
  Base on the type to set the value.\r
\r
  @param  Dest                  The dest value.\r
  @param  Source                The source value.\r
  @param  Type                  The value type for above two values.\r
\r
**/\r
VOID\r
SetValuesByType (\r
  OUT EFI_IFR_TYPE_VALUE  *Dest,\r
  IN  EFI_IFR_TYPE_VALUE  *Source,\r
  IN  UINT8               Type\r
  )\r
{\r
  switch (Type) {\r
    case EFI_IFR_TYPE_BOOLEAN:\r
      Dest->b = Source->b;\r
      break;\r
\r
    case EFI_IFR_TYPE_NUM_SIZE_8:\r
      Dest->u8 = Source->u8;\r
      break;\r
\r
    case EFI_IFR_TYPE_NUM_SIZE_16:\r
      Dest->u16 = Source->u16;\r
      break;\r
\r
    case EFI_IFR_TYPE_NUM_SIZE_32:\r
      Dest->u32 = Source->u32;\r
      break;\r
\r
    case EFI_IFR_TYPE_NUM_SIZE_64:\r
      Dest->u64 = Source->u64;\r
      break;\r
\r
    default:\r
      ASSERT (FALSE);\r
      break;\r
  }\r
}\r
\r
/**\r
  Get selection for OneOf and OrderedList (Left/Right will be ignored).\r
\r
  @param  MenuOption        Pointer to the current input menu.\r
\r
  @retval EFI_SUCCESS       If Option input is processed successfully\r
  @retval EFI_DEVICE_ERROR  If operation fails\r
\r
**/\r
EFI_STATUS\r
GetSelectionInputPopUp (\r
  IN  UI_MENU_OPTION  *MenuOption\r
  )\r
{\r
  EFI_INPUT_KEY                  Key;\r
  UINTN                          Index;\r
  CHAR16                         *StringPtr;\r
  CHAR16                         *TempStringPtr;\r
  UINTN                          Index2;\r
  UINTN                          TopOptionIndex;\r
  UINTN                          HighlightOptionIndex;\r
  UINTN                          Start;\r
  UINTN                          End;\r
  UINTN                          Top;\r
  UINTN                          Bottom;\r
  UINTN                          PopUpMenuLines;\r
  UINTN                          MenuLinesInView;\r
  UINTN                          PopUpWidth;\r
  CHAR16                         Character;\r
  INT32                          SavedAttribute;\r
  BOOLEAN                        ShowDownArrow;\r
  BOOLEAN                        ShowUpArrow;\r
  UINTN                          DimensionsWidth;\r
  LIST_ENTRY                     *Link;\r
  BOOLEAN                        OrderedList;\r
  UINT8                          *ValueArray;\r
  UINT8                          *ReturnValue;\r
  UINT8                          ValueType;\r
  EFI_HII_VALUE                  HiiValue;\r
  DISPLAY_QUESTION_OPTION        *OneOfOption;\r
  DISPLAY_QUESTION_OPTION        *CurrentOption;\r
  FORM_DISPLAY_ENGINE_STATEMENT  *Question;\r
  INTN                           Result;\r
  EFI_IFR_ORDERED_LIST           *OrderList;\r
\r
  DimensionsWidth = gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn;\r
\r
  ValueArray    = NULL;\r
  ValueType     = 0;\r
  CurrentOption = NULL;\r
  ShowDownArrow = FALSE;\r
  ShowUpArrow   = FALSE;\r
\r
  ZeroMem (&HiiValue, sizeof (EFI_HII_VALUE));\r
\r
  Question = MenuOption->ThisTag;\r
  if (Question->OpCode->OpCode == EFI_IFR_ORDERED_LIST_OP) {\r
    Link        = GetFirstNode (&Question->OptionListHead);\r
    OneOfOption = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);\r
    ValueArray  = Question->CurrentValue.Buffer;\r
    ValueType   =  OneOfOption->OptionOpCode->Type;\r
    OrderedList = TRUE;\r
    OrderList   = (EFI_IFR_ORDERED_LIST *)Question->OpCode;\r
  } else {\r
    OrderedList = FALSE;\r
    OrderList   = NULL;\r
  }\r
\r
  //\r
  // Calculate Option count\r
  //\r
  PopUpMenuLines = 0;\r
  if (OrderedList) {\r
    AdjustOptionOrder (Question, &PopUpMenuLines);\r
  } else {\r
    Link = GetFirstNode (&Question->OptionListHead);\r
    while (!IsNull (&Question->OptionListHead, Link)) {\r
      OneOfOption = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);\r
      PopUpMenuLines++;\r
      Link = GetNextNode (&Question->OptionListHead, Link);\r
    }\r
  }\r
\r
  //\r
  // Get the number of one of options present and its size\r
  //\r
  PopUpWidth           = 0;\r
  HighlightOptionIndex = 0;\r
  Link                 = GetFirstNode (&Question->OptionListHead);\r
  for (Index = 0; Index < PopUpMenuLines; Index++) {\r
    OneOfOption = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);\r
\r
    StringPtr = GetToken (OneOfOption->OptionOpCode->Option, gFormData->HiiHandle);\r
    if (StrLen (StringPtr) > PopUpWidth) {\r
      PopUpWidth = StrLen (StringPtr);\r
    }\r
\r
    FreePool (StringPtr);\r
    HiiValue.Type = OneOfOption->OptionOpCode->Type;\r
    SetValuesByType (&HiiValue.Value, &OneOfOption->OptionOpCode->Value, HiiValue.Type);\r
    if (!OrderedList && (CompareHiiValue (&Question->CurrentValue, &HiiValue, &Result, NULL) == EFI_SUCCESS) && (Result == 0)) {\r
      //\r
      // Find current selected Option for OneOf\r
      //\r
      HighlightOptionIndex = Index;\r
    }\r
\r
    Link = GetNextNode (&Question->OptionListHead, Link);\r
  }\r
\r
  //\r
  // Perform popup menu initialization.\r
  //\r
  PopUpWidth = PopUpWidth + POPUP_PAD_SPACE_COUNT;\r
\r
  SavedAttribute = gST->ConOut->Mode->Attribute;\r
  gST->ConOut->SetAttribute (gST->ConOut, GetPopupColor ());\r
\r
  if ((PopUpWidth + POPUP_FRAME_WIDTH) > DimensionsWidth) {\r
    PopUpWidth = DimensionsWidth - POPUP_FRAME_WIDTH;\r
  }\r
\r
  Start  = (DimensionsWidth - PopUpWidth - POPUP_FRAME_WIDTH) / 2 + gStatementDimensions.LeftColumn;\r
  End    = Start + PopUpWidth + POPUP_FRAME_WIDTH;\r
  Top    = gStatementDimensions.TopRow;\r
  Bottom = gStatementDimensions.BottomRow - 1;\r
\r
  MenuLinesInView = Bottom - Top - 1;\r
  if (MenuLinesInView >= PopUpMenuLines) {\r
    Top    = Top + (MenuLinesInView - PopUpMenuLines) / 2;\r
    Bottom = Top + PopUpMenuLines + 1;\r
  } else {\r
    ShowDownArrow = TRUE;\r
  }\r
\r
  if (HighlightOptionIndex > (MenuLinesInView - 1)) {\r
    TopOptionIndex = HighlightOptionIndex - MenuLinesInView + 1;\r
  } else {\r
    TopOptionIndex = 0;\r
  }\r
\r
  do {\r
    //\r
    // Clear that portion of the screen\r
    //\r
    ClearLines (Start, End, Top, Bottom, GetPopupColor ());\r
\r
    //\r
    // Draw "One of" pop-up menu\r
    //\r
    Character = BOXDRAW_DOWN_RIGHT;\r
    PrintCharAt (Start, Top, Character);\r
    for (Index = Start; Index + 2 < End; Index++) {\r
      if ((ShowUpArrow) && ((Index + 1) == (Start + End) / 2)) {\r
        Character = GEOMETRICSHAPE_UP_TRIANGLE;\r
      } else {\r
        Character = BOXDRAW_HORIZONTAL;\r
      }\r
\r
      PrintCharAt ((UINTN)-1, (UINTN)-1, Character);\r
    }\r
\r
    Character = BOXDRAW_DOWN_LEFT;\r
    PrintCharAt ((UINTN)-1, (UINTN)-1, Character);\r
    Character = BOXDRAW_VERTICAL;\r
    for (Index = Top + 1; Index < Bottom; Index++) {\r
      PrintCharAt (Start, Index, Character);\r
      PrintCharAt (End - 1, Index, Character);\r
    }\r
\r
    //\r
    // Move to top Option\r
    //\r
    Link = GetFirstNode (&Question->OptionListHead);\r
    for (Index = 0; Index < TopOptionIndex; Index++) {\r
      Link = GetNextNode (&Question->OptionListHead, Link);\r
    }\r
\r
    //\r
    // Display the One of options\r
    //\r
    Index2 = Top + 1;\r
    for (Index = TopOptionIndex; (Index < PopUpMenuLines) && (Index2 < Bottom); Index++) {\r
      OneOfOption = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);\r
      Link        = GetNextNode (&Question->OptionListHead, Link);\r
\r
      StringPtr = GetToken (OneOfOption->OptionOpCode->Option, gFormData->HiiHandle);\r
      ASSERT (StringPtr != NULL);\r
      //\r
      // If the string occupies multiple lines, truncate it to fit in one line,\r
      // and append a "..." for indication.\r
      //\r
      if (StrLen (StringPtr) > (PopUpWidth - 1)) {\r
        TempStringPtr = AllocateZeroPool (sizeof (CHAR16) * (PopUpWidth - 1));\r
        ASSERT (TempStringPtr != NULL);\r
        CopyMem (TempStringPtr, StringPtr, (sizeof (CHAR16) * (PopUpWidth - 5)));\r
        FreePool (StringPtr);\r
        StringPtr = TempStringPtr;\r
        StrCatS (StringPtr, PopUpWidth - 1, L"...");\r
      }\r
\r
      if (Index == HighlightOptionIndex) {\r
        //\r
        // Highlight the selected one\r
        //\r
        CurrentOption = OneOfOption;\r
\r
        gST->ConOut->SetAttribute (gST->ConOut, GetPickListColor ());\r
        PrintStringAt (Start + 2, Index2, StringPtr);\r
        gST->ConOut->SetAttribute (gST->ConOut, GetPopupColor ());\r
      } else {\r
        gST->ConOut->SetAttribute (gST->ConOut, GetPopupColor ());\r
        PrintStringAt (Start + 2, Index2, StringPtr);\r
      }\r
\r
      Index2++;\r
      FreePool (StringPtr);\r
    }\r
\r
    Character = BOXDRAW_UP_RIGHT;\r
    PrintCharAt (Start, Bottom, Character);\r
    for (Index = Start; Index + 2 < End; Index++) {\r
      if ((ShowDownArrow) && ((Index + 1) == (Start + End) / 2)) {\r
        Character = GEOMETRICSHAPE_DOWN_TRIANGLE;\r
      } else {\r
        Character = BOXDRAW_HORIZONTAL;\r
      }\r
\r
      PrintCharAt ((UINTN)-1, (UINTN)-1, Character);\r
    }\r
\r
    Character = BOXDRAW_UP_LEFT;\r
    PrintCharAt ((UINTN)-1, (UINTN)-1, Character);\r
\r
    //\r
    // Get User selection\r
    //\r
    Key.UnicodeChar = CHAR_NULL;\r
    if ((gDirection == SCAN_UP) || (gDirection == SCAN_DOWN)) {\r
      Key.ScanCode = gDirection;\r
      gDirection   = 0;\r
      goto TheKey;\r
    }\r
\r
    WaitForKeyStroke (&Key);\r
\r
TheKey:\r
    switch (Key.UnicodeChar) {\r
      case '+':\r
        if (OrderedList) {\r
          if ((TopOptionIndex > 0) && (TopOptionIndex == HighlightOptionIndex)) {\r
            //\r
            // Highlight reaches the top of the popup window, scroll one menu item.\r
            //\r
            TopOptionIndex--;\r
            ShowDownArrow = TRUE;\r
          }\r
\r
          if (TopOptionIndex == 0) {\r
            ShowUpArrow = FALSE;\r
          }\r
\r
          if (HighlightOptionIndex > 0) {\r
            HighlightOptionIndex--;\r
\r
            ASSERT (CurrentOption != NULL);\r
            SwapListEntries (CurrentOption->Link.BackLink, &CurrentOption->Link);\r
          }\r
        }\r
\r
        break;\r
\r
      case '-':\r
        //\r
        // If an ordered list op-code, we will allow for a popup of +/- keys\r
        // to create an ordered list of items\r
        //\r
        if (OrderedList) {\r
          if (((TopOptionIndex + MenuLinesInView) < PopUpMenuLines) &&\r
              (HighlightOptionIndex == (TopOptionIndex + MenuLinesInView - 1)))\r
          {\r
            //\r
            // Highlight reaches the bottom of the popup window, scroll one menu item.\r
            //\r
            TopOptionIndex++;\r
            ShowUpArrow = TRUE;\r
          }\r
\r
          if ((TopOptionIndex + MenuLinesInView) == PopUpMenuLines) {\r
            ShowDownArrow = FALSE;\r
          }\r
\r
          if (HighlightOptionIndex < (PopUpMenuLines - 1)) {\r
            HighlightOptionIndex++;\r
\r
            ASSERT (CurrentOption != NULL);\r
            SwapListEntries (&CurrentOption->Link, CurrentOption->Link.ForwardLink);\r
          }\r
        }\r
\r
        break;\r
\r
      case CHAR_NULL:\r
        switch (Key.ScanCode) {\r
          case SCAN_UP:\r
          case SCAN_DOWN:\r
            if (Key.ScanCode == SCAN_UP) {\r
              if ((TopOptionIndex > 0) && (TopOptionIndex == HighlightOptionIndex)) {\r
                //\r
                // Highlight reaches the top of the popup window, scroll one menu item.\r
                //\r
                TopOptionIndex--;\r
                ShowDownArrow = TRUE;\r
              }\r
\r
              if (TopOptionIndex == 0) {\r
                ShowUpArrow = FALSE;\r
              }\r
\r
              if (HighlightOptionIndex > 0) {\r
                HighlightOptionIndex--;\r
              }\r
            } else {\r
              if (((TopOptionIndex + MenuLinesInView) < PopUpMenuLines) &&\r
                  (HighlightOptionIndex == (TopOptionIndex + MenuLinesInView - 1)))\r
              {\r
                //\r
                // Highlight reaches the bottom of the popup window, scroll one menu item.\r
                //\r
                TopOptionIndex++;\r
                ShowUpArrow = TRUE;\r
              }\r
\r
              if ((TopOptionIndex + MenuLinesInView) == PopUpMenuLines) {\r
                ShowDownArrow = FALSE;\r
              }\r
\r
              if (HighlightOptionIndex < (PopUpMenuLines - 1)) {\r
                HighlightOptionIndex++;\r
              }\r
            }\r
\r
            break;\r
\r
          case SCAN_ESC:\r
            gST->ConOut->SetAttribute (gST->ConOut, SavedAttribute);\r
\r
            //\r
            // Restore link list order for orderedlist\r
            //\r
            if (OrderedList) {\r
              HiiValue.Type      = ValueType;\r
              HiiValue.Value.u64 = 0;\r
              for (Index = 0; Index < OrderList->MaxContainers; Index++) {\r
                HiiValue.Value.u64 = GetArrayData (ValueArray, ValueType, Index);\r
                if (HiiValue.Value.u64 == 0) {\r
                  break;\r
                }\r
\r
                OneOfOption = ValueToOption (Question, &HiiValue);\r
                if (OneOfOption == NULL) {\r
                  return EFI_NOT_FOUND;\r
                }\r
\r
                RemoveEntryList (&OneOfOption->Link);\r
                InsertTailList (&Question->OptionListHead, &OneOfOption->Link);\r
              }\r
            }\r
\r
            return EFI_DEVICE_ERROR;\r
\r
          default:\r
            break;\r
        }\r
\r
        break;\r
\r
      case CHAR_CARRIAGE_RETURN:\r
        //\r
        // return the current selection\r
        //\r
        if (OrderedList) {\r
          ReturnValue = AllocateZeroPool (Question->CurrentValue.BufferLen);\r
          ASSERT (ReturnValue != NULL);\r
          Index = 0;\r
          Link  = GetFirstNode (&Question->OptionListHead);\r
          while (!IsNull (&Question->OptionListHead, Link)) {\r
            OneOfOption = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);\r
            Link        = GetNextNode (&Question->OptionListHead, Link);\r
\r
            SetArrayData (ReturnValue, ValueType, Index, OneOfOption->OptionOpCode->Value.u64);\r
\r
            Index++;\r
            if (Index > OrderList->MaxContainers) {\r
              break;\r
            }\r
          }\r
\r
          if (CompareMem (ReturnValue, ValueArray, Question->CurrentValue.BufferLen) == 0) {\r
            FreePool (ReturnValue);\r
            return EFI_DEVICE_ERROR;\r
          } else {\r
            gUserInput->InputValue.Buffer    = ReturnValue;\r
            gUserInput->InputValue.BufferLen = Question->CurrentValue.BufferLen;\r
          }\r
        } else {\r
          ASSERT (CurrentOption != NULL);\r
          gUserInput->InputValue.Type = CurrentOption->OptionOpCode->Type;\r
          if (IsValuesEqual (&Question->CurrentValue.Value, &CurrentOption->OptionOpCode->Value, gUserInput->InputValue.Type)) {\r
            return EFI_DEVICE_ERROR;\r
          } else {\r
            SetValuesByType (&gUserInput->InputValue.Value, &CurrentOption->OptionOpCode->Value, gUserInput->InputValue.Type);\r
          }\r
        }\r
\r
        gST->ConOut->SetAttribute (gST->ConOut, SavedAttribute);\r
\r
        return EFI_SUCCESS;\r
\r
      default:\r
        break;\r
    }\r
  } while (TRUE);\r
}\r