[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
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\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
  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
        break;\r
\r
      case SCAN_RIGHT:\r
        if (CurrentCursor < (GetStringWidth (StringPtr) / 2 - 1)) {\r
          CurrentCursor++;\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
        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
\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
\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
        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
          TempString[Index] = CHAR_NULL;\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
      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
        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
      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
/**\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
    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
    *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
    *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
    *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
    *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
          Maximum = 29;\r
        } else {\r
          Maximum = 28;\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
\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
          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
        Key.UnicodeChar = CHAR_NULL;\r
        goto TheKey2;\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
          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
        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
          break;\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
      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
        // 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
      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
    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
      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
          // 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
      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
            // 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
        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
        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
}\r
\r