MdeModulePkg/Universal/DisplayEngineDxe/FormDisplay.c

   1 /** @file
   2 Entry and initialization module for the browser.
   3
   4 Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR>
   5 Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "FormDisplay.h"
  17
  18 //
  19 // Search table for UiDisplayMenu()
  20 //
  21 SCAN_CODE_TO_SCREEN_OPERATION     gScanCodeToOperation[] = {
  22   {
  23     SCAN_UP,
  24     UiUp,
  25   },
  26   {
  27     SCAN_DOWN,
  28     UiDown,
  29   },
  30   {
  31     SCAN_PAGE_UP,
  32     UiPageUp,
  33   },
  34   {
  35     SCAN_PAGE_DOWN,
  36     UiPageDown,
  37   },
  38   {
  39     SCAN_ESC,
  40     UiReset,
  41   },
  42   {
  43     SCAN_LEFT,
  44     UiLeft,
  45   },
  46   {
  47     SCAN_RIGHT,
  48     UiRight,
  49   }
  50 };
  51
  52 UINTN mScanCodeNumber = sizeof (gScanCodeToOperation) / sizeof (gScanCodeToOperation[0]);
  53
  54 SCREEN_OPERATION_T0_CONTROL_FLAG  gScreenOperationToControlFlag[] = {
  55   {
  56     UiNoOperation,
  57     CfUiNoOperation,
  58   },
  59   {
  60     UiSelect,
  61     CfUiSelect,
  62   },
  63   {
  64     UiUp,
  65     CfUiUp,
  66   },
  67   {
  68     UiDown,
  69     CfUiDown,
  70   },
  71   {
  72     UiLeft,
  73     CfUiLeft,
  74   },
  75   {
  76     UiRight,
  77     CfUiRight,
  78   },
  79   {
  80     UiReset,
  81     CfUiReset,
  82   },
  83   {
  84     UiPageUp,
  85     CfUiPageUp,
  86   },
  87   {
  88     UiPageDown,
  89     CfUiPageDown
  90   },
  91   {
  92     UiHotKey,
  93     CfUiHotKey
  94   }
  95 };
  96
  97 EFI_GUID  gDisplayEngineGuid = {
  98   0xE38C1029, 0xE38F, 0x45b9, {0x8F, 0x0D, 0xE2, 0xE6, 0x0B, 0xC9, 0xB2, 0x62}
  99 };
 100
 101 BOOLEAN                       gMisMatch;
 102 EFI_SCREEN_DESCRIPTOR         gStatementDimensions;
 103 BOOLEAN                       mStatementLayoutIsChanged = TRUE;
 104 USER_INPUT                    *gUserInput;
 105 FORM_DISPLAY_ENGINE_FORM      *gFormData;
 106 EFI_HII_HANDLE                gHiiHandle;
 107 UINT16                        gDirection;
 108 LIST_ENTRY                    gMenuOption;
 109 DISPLAY_HIGHLIGHT_MENU_INFO   gHighligthMenuInfo = {0};
 110 BOOLEAN                       mIsFirstForm = TRUE;
 111 FORM_ENTRY_INFO               gOldFormEntry = {0};
 112
 113 //
 114 // Browser Global Strings
 115 //
 116 CHAR16            *gReconnectConfirmChanges;
 117 CHAR16            *gReconnectFail;
 118 CHAR16            *gReconnectRequired;
 119 CHAR16            *gChangesOpt;
 120 CHAR16            *gFormNotFound;
 121 CHAR16            *gNoSubmitIf;
 122 CHAR16            *gBrowserError;
 123 CHAR16            *gSaveFailed;
 124 CHAR16            *gNoSubmitIfFailed;
 125 CHAR16            *gSaveProcess;
 126 CHAR16            *gSaveNoSubmitProcess;
 127 CHAR16            *gDiscardChange;
 128 CHAR16            *gJumpToFormSet;
 129 CHAR16            *gCheckError;
 130 CHAR16            *gPromptForData;
 131 CHAR16            *gPromptForPassword;
 132 CHAR16            *gPromptForNewPassword;
 133 CHAR16            *gConfirmPassword;
 134 CHAR16            *gConfirmError;
 135 CHAR16            *gPassowordInvalid;
 136 CHAR16            *gPressEnter;
 137 CHAR16            *gEmptyString;
 138 CHAR16            *gMiniString;
 139 CHAR16            *gOptionMismatch;
 140 CHAR16            *gFormSuppress;
 141 CHAR16            *gProtocolNotFound;
 142 CHAR16            *gConfirmDefaultMsg;
 143 CHAR16            *gConfirmSubmitMsg;
 144 CHAR16            *gConfirmDiscardMsg;
 145 CHAR16            *gConfirmResetMsg;
 146 CHAR16            *gConfirmExitMsg;
 147 CHAR16            *gConfirmSubmitMsg2nd;
 148 CHAR16            *gConfirmDefaultMsg2nd;
 149 CHAR16            *gConfirmResetMsg2nd;
 150 CHAR16            *gConfirmExitMsg2nd;
 151 CHAR16            *gConfirmOpt;
 152 CHAR16            *gConfirmOptYes;
 153 CHAR16            *gConfirmOptNo;
 154 CHAR16            *gConfirmMsgConnect;
 155 CHAR16            *gConfirmMsgEnd;
 156 CHAR16            gModalSkipColumn;
 157 CHAR16            gPromptBlockWidth;
 158 CHAR16            gOptionBlockWidth;
 159 CHAR16            gHelpBlockWidth;
 160 CHAR16            *mUnknownString;
 161
 162 FORM_DISPLAY_DRIVER_PRIVATE_DATA  mPrivateData = {
 163   FORM_DISPLAY_DRIVER_SIGNATURE,
 164   NULL,
 165   {
 166     FormDisplay,
 167     DriverClearDisplayPage,
 168     ConfirmDataChange
 169   }
 170 };
 171
 172
 173 /**
 174   Get the string based on the StringId and HII Package List Handle.
 175
 176   @param  Token                  The String's ID.
 177   @param  HiiHandle              The package list in the HII database to search for
 178                                  the specified string.
 179
 180   @return The output string.
 181
 182 **/
 183 CHAR16 *
 184 GetToken (
 185   IN  EFI_STRING_ID                Token,
 186   IN  EFI_HII_HANDLE               HiiHandle
 187   )
 188 {
 189   EFI_STRING  String;
 190
 191   String = HiiGetString (HiiHandle, Token, NULL);
 192   if (String == NULL) {
 193     String = AllocateCopyPool (StrSize (mUnknownString), mUnknownString);
 194     ASSERT (String != NULL);
 195   }
 196
 197   return (CHAR16 *) String;
 198 }
 199
 200
 201 /**
 202   Initialize the HII String Token to the correct values.
 203
 204 **/
 205 VOID
 206 InitializeDisplayStrings (
 207   VOID
 208   )
 209 {
 210   gReconnectConfirmChanges = GetToken (STRING_TOKEN (RECONNECT_CONFIRM_CHANGES), gHiiHandle);
 211   mUnknownString        = GetToken (STRING_TOKEN (UNKNOWN_STRING), gHiiHandle);
 212   gSaveFailed           = GetToken (STRING_TOKEN (SAVE_FAILED), gHiiHandle);
 213   gNoSubmitIfFailed     = GetToken (STRING_TOKEN (NO_SUBMIT_IF_CHECK_FAILED), gHiiHandle);
 214   gReconnectFail        = GetToken (STRING_TOKEN (RECONNECT_FAILED), gHiiHandle);
 215   gReconnectRequired    = GetToken (STRING_TOKEN (RECONNECT_REQUIRED), gHiiHandle);
 216   gChangesOpt           = GetToken (STRING_TOKEN (RECONNECT_CHANGES_OPTIONS), gHiiHandle);
 217   gSaveProcess          = GetToken (STRING_TOKEN (DISCARD_OR_JUMP), gHiiHandle);
 218   gSaveNoSubmitProcess  = GetToken (STRING_TOKEN (DISCARD_OR_CHECK), gHiiHandle);
 219   gDiscardChange        = GetToken (STRING_TOKEN (DISCARD_OR_JUMP_DISCARD), gHiiHandle);
 220   gJumpToFormSet        = GetToken (STRING_TOKEN (DISCARD_OR_JUMP_JUMP), gHiiHandle);
 221   gCheckError           = GetToken (STRING_TOKEN (DISCARD_OR_CHECK_CHECK), gHiiHandle);
 222   gPromptForData        = GetToken (STRING_TOKEN (PROMPT_FOR_DATA), gHiiHandle);
 223   gPromptForPassword    = GetToken (STRING_TOKEN (PROMPT_FOR_PASSWORD), gHiiHandle);
 224   gPromptForNewPassword = GetToken (STRING_TOKEN (PROMPT_FOR_NEW_PASSWORD), gHiiHandle);
 225   gConfirmPassword      = GetToken (STRING_TOKEN (CONFIRM_PASSWORD), gHiiHandle);
 226   gConfirmError         = GetToken (STRING_TOKEN (CONFIRM_ERROR), gHiiHandle);
 227   gPassowordInvalid     = GetToken (STRING_TOKEN (PASSWORD_INVALID), gHiiHandle);
 228   gPressEnter           = GetToken (STRING_TOKEN (PRESS_ENTER), gHiiHandle);
 229   gEmptyString          = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
 230   gMiniString           = GetToken (STRING_TOKEN (MINI_STRING), gHiiHandle);
 231   gOptionMismatch       = GetToken (STRING_TOKEN (OPTION_MISMATCH), gHiiHandle);
 232   gFormSuppress         = GetToken (STRING_TOKEN (FORM_SUPPRESSED), gHiiHandle);
 233   gProtocolNotFound     = GetToken (STRING_TOKEN (PROTOCOL_NOT_FOUND), gHiiHandle);
 234   gFormNotFound         = GetToken (STRING_TOKEN (STATUS_BROWSER_FORM_NOT_FOUND), gHiiHandle);
 235   gNoSubmitIf           = GetToken (STRING_TOKEN (STATUS_BROWSER_NO_SUBMIT_IF), gHiiHandle);
 236   gBrowserError         = GetToken (STRING_TOKEN (STATUS_BROWSER_ERROR), gHiiHandle);
 237   gConfirmDefaultMsg    = GetToken (STRING_TOKEN (CONFIRM_DEFAULT_MESSAGE), gHiiHandle);
 238   gConfirmDiscardMsg    = GetToken (STRING_TOKEN (CONFIRM_DISCARD_MESSAGE), gHiiHandle);
 239   gConfirmSubmitMsg     = GetToken (STRING_TOKEN (CONFIRM_SUBMIT_MESSAGE), gHiiHandle);
 240   gConfirmResetMsg      = GetToken (STRING_TOKEN (CONFIRM_RESET_MESSAGE), gHiiHandle);
 241   gConfirmExitMsg       = GetToken (STRING_TOKEN (CONFIRM_EXIT_MESSAGE), gHiiHandle);
 242   gConfirmDefaultMsg2nd = GetToken (STRING_TOKEN (CONFIRM_DEFAULT_MESSAGE_2ND), gHiiHandle);
 243   gConfirmSubmitMsg2nd  = GetToken (STRING_TOKEN (CONFIRM_SUBMIT_MESSAGE_2ND), gHiiHandle);
 244   gConfirmResetMsg2nd   = GetToken (STRING_TOKEN (CONFIRM_RESET_MESSAGE_2ND), gHiiHandle);
 245   gConfirmExitMsg2nd    = GetToken (STRING_TOKEN (CONFIRM_EXIT_MESSAGE_2ND), gHiiHandle);
 246   gConfirmOpt           = GetToken (STRING_TOKEN (CONFIRM_OPTION), gHiiHandle);
 247   gConfirmOptYes        = GetToken (STRING_TOKEN (CONFIRM_OPTION_YES), gHiiHandle);
 248   gConfirmOptNo         = GetToken (STRING_TOKEN (CONFIRM_OPTION_NO), gHiiHandle);
 249   gConfirmMsgConnect    = GetToken (STRING_TOKEN (CONFIRM_OPTION_CONNECT), gHiiHandle);
 250   gConfirmMsgEnd        = GetToken (STRING_TOKEN (CONFIRM_OPTION_END), gHiiHandle);
 251 }
 252
 253 /**
 254   Free up the resource allocated for all strings required
 255   by Setup Browser.
 256
 257 **/
 258 VOID
 259 FreeDisplayStrings (
 260   VOID
 261   )
 262 {
 263   FreePool (mUnknownString);
 264   FreePool (gEmptyString);
 265   FreePool (gSaveFailed);
 266   FreePool (gNoSubmitIfFailed);
 267   FreePool (gReconnectFail);
 268   FreePool (gReconnectRequired);
 269   FreePool (gChangesOpt);
 270   FreePool (gReconnectConfirmChanges);
 271   FreePool (gSaveProcess);
 272   FreePool (gSaveNoSubmitProcess);
 273   FreePool (gDiscardChange);
 274   FreePool (gJumpToFormSet);
 275   FreePool (gCheckError);
 276   FreePool (gPromptForData);
 277   FreePool (gPromptForPassword);
 278   FreePool (gPromptForNewPassword);
 279   FreePool (gConfirmPassword);
 280   FreePool (gConfirmError);
 281   FreePool (gPassowordInvalid);
 282   FreePool (gPressEnter);
 283   FreePool (gMiniString);
 284   FreePool (gOptionMismatch);
 285   FreePool (gFormSuppress);
 286   FreePool (gProtocolNotFound);
 287   FreePool (gBrowserError);
 288   FreePool (gNoSubmitIf);
 289   FreePool (gFormNotFound);
 290   FreePool (gConfirmDefaultMsg);
 291   FreePool (gConfirmSubmitMsg);
 292   FreePool (gConfirmDiscardMsg);
 293   FreePool (gConfirmResetMsg);
 294   FreePool (gConfirmExitMsg);
 295   FreePool (gConfirmDefaultMsg2nd);
 296   FreePool (gConfirmSubmitMsg2nd);
 297   FreePool (gConfirmResetMsg2nd);
 298   FreePool (gConfirmExitMsg2nd);
 299   FreePool (gConfirmOpt);
 300   FreePool (gConfirmOptYes);
 301   FreePool (gConfirmOptNo);
 302   FreePool (gConfirmMsgConnect);
 303   FreePool (gConfirmMsgEnd);
 304 }
 305
 306 /**
 307   Get prompt string id from the opcode data buffer.
 308
 309   @param  OpCode                 The input opcode buffer.
 310
 311   @return The prompt string id.
 312
 313 **/
 314 EFI_STRING_ID
 315 GetPrompt (
 316   IN EFI_IFR_OP_HEADER     *OpCode
 317   )
 318 {
 319   EFI_IFR_STATEMENT_HEADER  *Header;
 320
 321   if (OpCode->Length <= sizeof (EFI_IFR_OP_HEADER)) {
 322     return 0;
 323   }
 324
 325   Header = (EFI_IFR_STATEMENT_HEADER  *) (OpCode + 1);
 326
 327   return Header->Prompt;
 328 }
 329
 330 /**
 331   Get the supported width for a particular op-code
 332
 333   @param  MenuOption             The menu option.
 334   @param  AdjustWidth            The width which is saved for the space.
 335
 336   @return Returns the number of CHAR16 characters that is support.
 337
 338 **/
 339 UINT16
 340 GetWidth (
 341   IN  UI_MENU_OPTION     *MenuOption,
 342   OUT UINT16             *AdjustWidth
 343   )
 344 {
 345   CHAR16                        *String;
 346   UINTN                         Size;
 347   EFI_IFR_TEXT                  *TestOp;
 348   UINT16                        ReturnWidth;
 349   FORM_DISPLAY_ENGINE_STATEMENT *Statement;
 350
 351   Statement = MenuOption->ThisTag;
 352
 353   //
 354   // For modal form, clean the entire row.
 355   //
 356   if ((gFormData->Attribute & HII_DISPLAY_MODAL) != 0) {
 357     if (AdjustWidth  != NULL) {
 358       *AdjustWidth = LEFT_SKIPPED_COLUMNS;
 359     }
 360     return (UINT16)(gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn - 2 * (gModalSkipColumn + LEFT_SKIPPED_COLUMNS));
 361   }
 362
 363   Size = 0;
 364
 365   //
 366   // See if the second text parameter is really NULL
 367   //
 368   if (Statement->OpCode->OpCode == EFI_IFR_TEXT_OP) {
 369     TestOp = (EFI_IFR_TEXT *) Statement->OpCode;
 370     if (TestOp->TextTwo != 0) {
 371       String = GetToken (TestOp->TextTwo, gFormData->HiiHandle);
 372       Size   = StrLen (String);
 373       FreePool (String);
 374     }
 375   }
 376
 377   if ((Statement->OpCode->OpCode == EFI_IFR_SUBTITLE_OP) ||
 378       (Statement->OpCode->OpCode == EFI_IFR_REF_OP) ||
 379       (Statement->OpCode->OpCode == EFI_IFR_PASSWORD_OP) ||
 380       (Statement->OpCode->OpCode == EFI_IFR_ACTION_OP) ||
 381       (Statement->OpCode->OpCode == EFI_IFR_RESET_BUTTON_OP) ||
 382       //
 383       // Allow a wide display if text op-code and no secondary text op-code
 384       //
 385       ((Statement->OpCode->OpCode == EFI_IFR_TEXT_OP) && (Size == 0))
 386       ) {
 387
 388     //
 389     // Return the space width.
 390     //
 391     if (AdjustWidth != NULL) {
 392       *AdjustWidth = 2;
 393     }
 394     //
 395     // Keep consistent with current behavior.
 396     //
 397     ReturnWidth = (UINT16) (gPromptBlockWidth + gOptionBlockWidth - 2);
 398   } else {
 399     if (AdjustWidth != NULL) {
 400       *AdjustWidth = 1;
 401     }
 402
 403     ReturnWidth =  (UINT16) (gPromptBlockWidth - 1);
 404   }
 405
 406   //
 407   // For nest in statement, should the subtitle indent.
 408   //
 409   if (MenuOption->NestInStatement) {
 410     ReturnWidth -= SUBTITLE_INDENT;
 411   }
 412
 413   return ReturnWidth;
 414 }
 415
 416 /**
 417   Will copy LineWidth amount of a string in the OutputString buffer and return the
 418   number of CHAR16 characters that were copied into the OutputString buffer.
 419   The output string format is:
 420     Glyph Info + String info + '\0'.
 421
 422   In the code, it deals \r,\n,\r\n same as \n\r, also it not process the \r or \g.
 423
 424   @param  InputString            String description for this option.
 425   @param  LineWidth              Width of the desired string to extract in CHAR16
 426                                  characters
 427   @param  GlyphWidth             The glyph width of the begin of the char in the string.
 428   @param  Index                  Where in InputString to start the copy process
 429   @param  OutputString           Buffer to copy the string into
 430
 431   @return Returns the number of CHAR16 characters that were copied into the OutputString
 432   buffer, include extra glyph info and '\0' info.
 433
 434 **/
 435 UINT16
 436 GetLineByWidth (
 437   IN      CHAR16                      *InputString,
 438   IN      UINT16                      LineWidth,
 439   IN OUT  UINT16                      *GlyphWidth,
 440   IN OUT  UINTN                       *Index,
 441   OUT     CHAR16                      **OutputString
 442   )
 443 {
 444   UINT16          StrOffset;
 445   UINT16          GlyphOffset;
 446   UINT16          OriginalGlyphWidth;
 447   BOOLEAN         ReturnFlag;
 448   UINT16          LastSpaceOffset;
 449   UINT16          LastGlyphWidth;
 450
 451   if (InputString == NULL || Index == NULL || OutputString == NULL) {
 452     return 0;
 453   }
 454
 455   if (LineWidth == 0 || *GlyphWidth == 0) {
 456     return 0;
 457   }
 458
 459   //
 460   // Save original glyph width.
 461   //
 462   OriginalGlyphWidth = *GlyphWidth;
 463   LastGlyphWidth     = OriginalGlyphWidth;
 464   ReturnFlag         = FALSE;
 465   LastSpaceOffset    = 0;
 466
 467   //
 468   // NARROW_CHAR can not be printed in screen, so if a line only contain  the two CHARs: 'NARROW_CHAR + CHAR_CARRIAGE_RETURN' , it is a empty line  in Screen.
 469   // To avoid displaying this  empty line in screen,  just skip  the two CHARs here.
 470   //
 471   if ((InputString[*Index] == NARROW_CHAR) && (InputString[*Index + 1] == CHAR_CARRIAGE_RETURN)) {
 472     *Index = *Index + 2;
 473   }
 474
 475   //
 476   // Fast-forward the string and see if there is a carriage-return in the string
 477   //
 478   for (StrOffset = 0, GlyphOffset = 0; GlyphOffset <= LineWidth; StrOffset++) {
 479     switch (InputString[*Index + StrOffset]) {
 480       case NARROW_CHAR:
 481         *GlyphWidth = 1;
 482         break;
 483
 484       case WIDE_CHAR:
 485         *GlyphWidth = 2;
 486         break;
 487
 488       case CHAR_CARRIAGE_RETURN:
 489       case CHAR_LINEFEED:
 490       case CHAR_NULL:
 491         ReturnFlag = TRUE;
 492         break;
 493
 494       default:
 495         GlyphOffset = GlyphOffset + *GlyphWidth;
 496
 497         //
 498         // Record the last space info in this line. Will be used in rewind.
 499         //
 500         if ((InputString[*Index + StrOffset] == CHAR_SPACE) && (GlyphOffset <= LineWidth)) {
 501           LastSpaceOffset = StrOffset;
 502           LastGlyphWidth  = *GlyphWidth;
 503         }
 504         break;
 505     }
 506
 507     if (ReturnFlag) {
 508       break;
 509     }
 510   }
 511
 512   //
 513   // Rewind the string from the maximum size until we see a space to break the line
 514   //
 515   if (GlyphOffset > LineWidth) {
 516     //
 517     // Rewind the string to last space char in this line.
 518     //
 519     if (LastSpaceOffset != 0) {
 520       StrOffset   = LastSpaceOffset;
 521       *GlyphWidth = LastGlyphWidth;
 522     } else {
 523       //
 524       // Roll back to last char in the line width.
 525       //
 526       StrOffset--;
 527     }
 528   }
 529
 530   //
 531   // The CHAR_NULL has process last time, this time just return 0 to stand for the end.
 532   //
 533   if (StrOffset == 0 && (InputString[*Index + StrOffset] == CHAR_NULL)) {
 534     return 0;
 535   }
 536
 537   //
 538   // Need extra glyph info and '\0' info, so +2.
 539   //
 540   *OutputString = AllocateZeroPool (((UINTN) (StrOffset + 2) * sizeof(CHAR16)));
 541   if (*OutputString == NULL) {
 542     return 0;
 543   }
 544
 545   //
 546   // Save the glyph info at the begin of the string, will used by Print function.
 547   //
 548   if (OriginalGlyphWidth == 1) {
 549     *(*OutputString) = NARROW_CHAR;
 550   } else  {
 551     *(*OutputString) = WIDE_CHAR;
 552   }
 553
 554   CopyMem ((*OutputString) + 1, &InputString[*Index], StrOffset * sizeof(CHAR16));
 555
 556   if (InputString[*Index + StrOffset] == CHAR_SPACE) {
 557     //
 558     // Skip the space info at the begin of next line.
 559     //
 560     *Index = (UINT16) (*Index + StrOffset + 1);
 561   } else if (InputString[*Index + StrOffset] == CHAR_LINEFEED) {
 562     //
 563     // Skip the /n or /n/r info.
 564     //
 565     if (InputString[*Index + StrOffset + 1] == CHAR_CARRIAGE_RETURN) {
 566       *Index = (UINT16) (*Index + StrOffset + 2);
 567     } else {
 568       *Index = (UINT16) (*Index + StrOffset + 1);
 569     }
 570   } else if (InputString[*Index + StrOffset] == CHAR_CARRIAGE_RETURN) {
 571     //
 572     // Skip the /r or /r/n info.
 573     //
 574     if (InputString[*Index + StrOffset + 1] == CHAR_LINEFEED) {
 575       *Index = (UINT16) (*Index + StrOffset + 2);
 576     } else {
 577       *Index = (UINT16) (*Index + StrOffset + 1);
 578     }
 579   } else {
 580     *Index = (UINT16) (*Index + StrOffset);
 581   }
 582
 583   //
 584   // Include extra glyph info and '\0' info, so +2.
 585   //
 586   return StrOffset + 2;
 587 }
 588
 589 /**
 590   Add one menu option by specified description and context.
 591
 592   @param  Statement              Statement of this Menu Option.
 593   @param  MenuItemCount          The index for this Option in the Menu.
 594   @param  NestIn                 Whether this statement is nest in another statement.
 595
 596 **/
 597 VOID
 598 UiAddMenuOption (
 599   IN FORM_DISPLAY_ENGINE_STATEMENT   *Statement,
 600   IN UINT16                          *MenuItemCount,
 601   IN BOOLEAN                         NestIn
 602   )
 603 {
 604   UI_MENU_OPTION   *MenuOption;
 605   UINTN            Index;
 606   UINTN            Count;
 607   CHAR16           *String;
 608   UINT16           NumberOfLines;
 609   UINT16           GlyphWidth;
 610   UINT16           Width;
 611   UINTN            ArrayEntry;
 612   CHAR16           *OutputString;
 613   EFI_STRING_ID    PromptId;
 614
 615   NumberOfLines = 1;
 616   ArrayEntry    = 0;
 617   GlyphWidth    = 1;
 618   Count         = 1;
 619   MenuOption    = NULL;
 620
 621   PromptId = GetPrompt (Statement->OpCode);
 622   ASSERT (PromptId != 0);
 623
 624   String = GetToken (PromptId, gFormData->HiiHandle);
 625   ASSERT (String != NULL);
 626
 627   if (Statement->OpCode->OpCode == EFI_IFR_DATE_OP || Statement->OpCode->OpCode == EFI_IFR_TIME_OP) {
 628     Count = 3;
 629   }
 630
 631   for (Index = 0; Index < Count; Index++) {
 632     MenuOption = AllocateZeroPool (sizeof (UI_MENU_OPTION));
 633     ASSERT (MenuOption);
 634
 635     MenuOption->Signature   = UI_MENU_OPTION_SIGNATURE;
 636     MenuOption->Description = String;
 637     MenuOption->Handle      = gFormData->HiiHandle;
 638     MenuOption->ThisTag     = Statement;
 639     MenuOption->NestInStatement = NestIn;
 640     MenuOption->EntryNumber = *MenuItemCount;
 641
 642     MenuOption->Sequence = Index;
 643
 644     if ((Statement->Attribute & HII_DISPLAY_GRAYOUT) != 0) {
 645       MenuOption->GrayOut = TRUE;
 646     } else {
 647       MenuOption->GrayOut = FALSE;
 648     }
 649
 650     if ((Statement->Attribute & HII_DISPLAY_LOCK) != 0 || (gFormData->Attribute & HII_DISPLAY_LOCK) != 0) {
 651       MenuOption->GrayOut = TRUE;
 652     }
 653
 654     //
 655     // If the form or the question has the lock attribute, deal same as grayout.
 656     //
 657     if ((gFormData->Attribute & HII_DISPLAY_LOCK) != 0 || (Statement->Attribute & HII_DISPLAY_LOCK) != 0) {
 658       MenuOption->GrayOut = TRUE;
 659     }
 660
 661     switch (Statement->OpCode->OpCode) {
 662     case EFI_IFR_ORDERED_LIST_OP:
 663     case EFI_IFR_ONE_OF_OP:
 664     case EFI_IFR_NUMERIC_OP:
 665     case EFI_IFR_TIME_OP:
 666     case EFI_IFR_DATE_OP:
 667     case EFI_IFR_CHECKBOX_OP:
 668     case EFI_IFR_PASSWORD_OP:
 669     case EFI_IFR_STRING_OP:
 670       //
 671       // User could change the value of these items
 672       //
 673       MenuOption->IsQuestion = TRUE;
 674       break;
 675     case EFI_IFR_TEXT_OP:
 676       if (FeaturePcdGet (PcdBrowserGrayOutTextStatement)) {
 677         //
 678         // Initializing GrayOut option as TRUE for Text setup options
 679         // so that those options will be Gray in colour and un selectable.
 680         //
 681         MenuOption->GrayOut = TRUE;
 682       }
 683       break;
 684     default:
 685       MenuOption->IsQuestion = FALSE;
 686       break;
 687     }
 688
 689     if ((Statement->Attribute & HII_DISPLAY_READONLY) != 0) {
 690       MenuOption->ReadOnly = TRUE;
 691       if (FeaturePcdGet (PcdBrowerGrayOutReadOnlyMenu)) {
 692         MenuOption->GrayOut = TRUE;
 693       }
 694     }
 695
 696     if (Index == 0 &&
 697       (Statement->OpCode->OpCode != EFI_IFR_DATE_OP) &&
 698       (Statement->OpCode->OpCode != EFI_IFR_TIME_OP)) {
 699       Width  = GetWidth (MenuOption, NULL);
 700       for (; GetLineByWidth (String, Width, &GlyphWidth,&ArrayEntry, &OutputString) != 0x0000;) {
 701         //
 702         // If there is more string to process print on the next row and increment the Skip value
 703         //
 704         if (StrLen (&String[ArrayEntry]) != 0) {
 705           NumberOfLines++;
 706         }
 707         FreePool (OutputString);
 708       }
 709     } else {
 710       //
 711       // Add three MenuOptions for Date/Time
 712       // Data format :      [01/02/2004]      [11:22:33]
 713       // Line number :        0  0    1         0  0  1
 714       //
 715       NumberOfLines = 0;
 716     }
 717
 718     if (Index == 2) {
 719       //
 720       // Override LineNumber for the MenuOption in Date/Time sequence
 721       //
 722       MenuOption->Skip = 1;
 723     } else {
 724       MenuOption->Skip = NumberOfLines;
 725     }
 726
 727     InsertTailList (&gMenuOption, &MenuOption->Link);
 728   }
 729
 730   (*MenuItemCount)++;
 731 }
 732
 733 /**
 734   Create the menu list base on the form data info.
 735
 736 **/
 737 VOID
 738 ConvertStatementToMenu (
 739   VOID
 740   )
 741 {
 742   UINT16                        MenuItemCount;
 743   LIST_ENTRY                    *Link;
 744   LIST_ENTRY                    *NestLink;
 745   FORM_DISPLAY_ENGINE_STATEMENT *Statement;
 746   FORM_DISPLAY_ENGINE_STATEMENT *NestStatement;
 747
 748   MenuItemCount = 0;
 749   InitializeListHead (&gMenuOption);
 750
 751   Link = GetFirstNode (&gFormData->StatementListHead);
 752   while (!IsNull (&gFormData->StatementListHead, Link)) {
 753     Statement = FORM_DISPLAY_ENGINE_STATEMENT_FROM_LINK (Link);
 754     Link = GetNextNode (&gFormData->StatementListHead, Link);
 755
 756     //
 757     // Skip the opcode not recognized by Display core.
 758     //
 759     if (Statement->OpCode->OpCode == EFI_IFR_GUID_OP) {
 760       continue;
 761     }
 762
 763     UiAddMenuOption (Statement, &MenuItemCount, FALSE);
 764
 765     //
 766     // Check the statement nest in this host statement.
 767     //
 768     NestLink = GetFirstNode (&Statement->NestStatementList);
 769     while (!IsNull (&Statement->NestStatementList, NestLink)) {
 770       NestStatement = FORM_DISPLAY_ENGINE_STATEMENT_FROM_LINK (NestLink);
 771       NestLink = GetNextNode (&Statement->NestStatementList, NestLink);
 772
 773       //
 774       // Skip the opcode not recognized by Display core.
 775       //
 776       if (NestStatement->OpCode->OpCode == EFI_IFR_GUID_OP) {
 777         continue;
 778       }
 779
 780       UiAddMenuOption (NestStatement, &MenuItemCount, TRUE);
 781     }
 782   }
 783 }
 784
 785 /**
 786   Count the storage space of a Unicode string.
 787
 788   This function handles the Unicode string with NARROW_CHAR
 789   and WIDE_CHAR control characters. NARROW_HCAR and WIDE_CHAR
 790   does not count in the resultant output. If a WIDE_CHAR is
 791   hit, then 2 Unicode character will consume an output storage
 792   space with size of CHAR16 till a NARROW_CHAR is hit.
 793
 794   If String is NULL, then ASSERT ().
 795
 796   @param String          The input string to be counted.
 797
 798   @return Storage space for the input string.
 799
 800 **/
 801 UINTN
 802 GetStringWidth (
 803   IN CHAR16               *String
 804   )
 805 {
 806   UINTN Index;
 807   UINTN Count;
 808   UINTN IncrementValue;
 809
 810   ASSERT (String != NULL);
 811   if (String == NULL) {
 812     return 0;
 813   }
 814
 815   Index           = 0;
 816   Count           = 0;
 817   IncrementValue  = 1;
 818
 819   do {
 820     //
 821     // Advance to the null-terminator or to the first width directive
 822     //
 823     for (;
 824          (String[Index] != NARROW_CHAR) && (String[Index] != WIDE_CHAR) && (String[Index] != 0);
 825          Index++, Count = Count + IncrementValue
 826         )
 827       ;
 828
 829     //
 830     // We hit the null-terminator, we now have a count
 831     //
 832     if (String[Index] == 0) {
 833       break;
 834     }
 835     //
 836     // We encountered a narrow directive - strip it from the size calculation since it doesn't get printed
 837     // and also set the flag that determines what we increment by.(if narrow, increment by 1, if wide increment by 2)
 838     //
 839     if (String[Index] == NARROW_CHAR) {
 840       //
 841       // Skip to the next character
 842       //
 843       Index++;
 844       IncrementValue = 1;
 845     } else {
 846       //
 847       // Skip to the next character
 848       //
 849       Index++;
 850       IncrementValue = 2;
 851     }
 852   } while (String[Index] != 0);
 853
 854   //
 855   // Increment by one to include the null-terminator in the size
 856   //
 857   Count++;
 858
 859   return Count * sizeof (CHAR16);
 860 }
 861
 862 /**
 863   Base on the input option string to update the skip value for a menu option.
 864
 865   @param  MenuOption             The MenuOption to be checked.
 866   @param  OptionString           The input option string.
 867
 868 **/
 869 VOID
 870 UpdateSkipInfoForMenu (
 871   IN UI_MENU_OPTION               *MenuOption,
 872   IN CHAR16                       *OptionString
 873   )
 874 {
 875   UINTN   Index;
 876   UINT16  Width;
 877   UINTN   Row;
 878   CHAR16  *OutputString;
 879   UINT16  GlyphWidth;
 880
 881   Width         = (UINT16) gOptionBlockWidth;
 882   GlyphWidth    = 1;
 883   Row           = 1;
 884
 885   for (Index = 0; GetLineByWidth (OptionString, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {
 886     if (StrLen (&OptionString[Index]) != 0) {
 887       Row++;
 888     }
 889
 890     FreePool (OutputString);
 891   }
 892
 893   if ((Row > MenuOption->Skip) &&
 894       (MenuOption->ThisTag->OpCode->OpCode != EFI_IFR_DATE_OP) &&
 895       (MenuOption->ThisTag->OpCode->OpCode != EFI_IFR_TIME_OP)) {
 896     MenuOption->Skip = Row;
 897   }
 898 }
 899
 900 /**
 901   Update display lines for a Menu Option.
 902
 903   @param  MenuOption             The MenuOption to be checked.
 904
 905 **/
 906 VOID
 907 UpdateOptionSkipLines (
 908   IN UI_MENU_OPTION               *MenuOption
 909   )
 910 {
 911   CHAR16  *OptionString;
 912
 913   OptionString  = NULL;
 914
 915   ProcessOptions (MenuOption, FALSE, &OptionString, TRUE);
 916   if (OptionString != NULL) {
 917     UpdateSkipInfoForMenu (MenuOption, OptionString);
 918
 919     FreePool (OptionString);
 920   }
 921
 922   if ((MenuOption->ThisTag->OpCode->OpCode  == EFI_IFR_TEXT_OP) && (((EFI_IFR_TEXT*)MenuOption->ThisTag->OpCode)->TextTwo != 0)) {
 923     OptionString   = GetToken (((EFI_IFR_TEXT*)MenuOption->ThisTag->OpCode)->TextTwo, gFormData->HiiHandle);
 924
 925     if (OptionString != NULL) {
 926       UpdateSkipInfoForMenu (MenuOption, OptionString);
 927
 928       FreePool (OptionString);
 929     }
 930   }
 931 }
 932
 933 /**
 934   Check whether this Menu Option could be print.
 935
 936   Check Prompt string, option string or text two string not NULL.
 937
 938   This is an internal function.
 939
 940   @param  MenuOption             The MenuOption to be checked.
 941
 942   @retval TRUE                   This Menu Option is printable.
 943   @retval FALSE                  This Menu Option could not be printable.
 944
 945 **/
 946 BOOLEAN
 947 PrintableMenu (
 948   UI_MENU_OPTION   *MenuOption
 949   )
 950 {
 951   EFI_STATUS    Status;
 952   EFI_STRING    OptionString;
 953
 954   OptionString = NULL;
 955
 956   if (MenuOption->Description[0] != '\0') {
 957     return TRUE;
 958   }
 959
 960   Status = ProcessOptions (MenuOption, FALSE, &OptionString, FALSE);
 961   if (EFI_ERROR (Status)) {
 962     return FALSE;
 963   }
 964   if (OptionString != NULL && OptionString[0] != '\0') {
 965     FreePool (OptionString);
 966     return TRUE;
 967   }
 968
 969   if ((MenuOption->ThisTag->OpCode->OpCode  == EFI_IFR_TEXT_OP) && (((EFI_IFR_TEXT*)MenuOption->ThisTag->OpCode)->TextTwo != 0)) {
 970     OptionString   = GetToken (((EFI_IFR_TEXT*)MenuOption->ThisTag->OpCode)->TextTwo, gFormData->HiiHandle);
 971     ASSERT (OptionString != NULL);
 972     if (OptionString[0] != '\0'){
 973       FreePool (OptionString);
 974       return TRUE;
 975     }
 976   }
 977
 978   return FALSE;
 979 }
 980
 981 /**
 982   Check whether this Menu Option could be highlighted.
 983
 984   This is an internal function.
 985
 986   @param  MenuOption             The MenuOption to be checked.
 987
 988   @retval TRUE                   This Menu Option is selectable.
 989   @retval FALSE                  This Menu Option could not be selected.
 990
 991 **/
 992 BOOLEAN
 993 IsSelectable (
 994   UI_MENU_OPTION   *MenuOption
 995   )
 996 {
 997   if ((MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_SUBTITLE_OP) ||
 998       MenuOption->GrayOut || MenuOption->ReadOnly || !PrintableMenu (MenuOption)) {
 999     return FALSE;
1000   } else {
1001     return TRUE;
1002   }
1003 }
1004
1005 /**
1006   Move to next selectable statement.
1007
1008   This is an internal function.
1009
1010   @param  GoUp                   The navigation direction. TRUE: up, FALSE: down.
1011   @param  CurrentPosition        Current position.
1012   @param  GapToTop               Gap position to top or bottom.
1013   @param  FindInForm             Whether find menu in current form or beyond.
1014
1015   @return The row distance from current MenuOption to next selectable MenuOption.
1016
1017   @retval -1       Reach the begin of the menu, still can't find the selectable menu.
1018   @retval Value    Find the selectable menu, maybe the truly selectable, maybe the
1019                    first menu showing beyond current form or last menu showing in
1020                    current form.
1021                    The value is the line number between the new selected menu and the
1022                    current select menu, not include the new selected menu.
1023
1024 **/
1025 INTN
1026 MoveToNextStatement (
1027   IN     BOOLEAN                   GoUp,
1028   IN OUT LIST_ENTRY                **CurrentPosition,
1029   IN     UINTN                     GapToTop,
1030   IN     BOOLEAN                   FindInForm
1031   )
1032 {
1033   INTN             Distance;
1034   LIST_ENTRY       *Pos;
1035   UI_MENU_OPTION   *NextMenuOption;
1036   UI_MENU_OPTION   *PreMenuOption;
1037
1038   Distance      = 0;
1039   Pos           = *CurrentPosition;
1040
1041   if (Pos == &gMenuOption) {
1042     return -1;
1043   }
1044
1045   PreMenuOption = MENU_OPTION_FROM_LINK (Pos);
1046
1047   while (TRUE) {
1048     NextMenuOption = MENU_OPTION_FROM_LINK (Pos);
1049     //
1050     // NextMenuOption->Row == 0 means this menu has not calculate
1051     // the NextMenuOption->Skip value yet, just calculate here.
1052     //
1053     if (NextMenuOption->Row == 0) {
1054       UpdateOptionSkipLines (NextMenuOption);
1055     }
1056
1057     if (IsSelectable (NextMenuOption)) {
1058       break;
1059     }
1060
1061     //
1062     // In this case, still can't find the selectable menu,
1063     // return the first one beyond the showing form.
1064     //
1065     if ((UINTN) Distance + NextMenuOption->Skip > GapToTop) {
1066       if (FindInForm) {
1067         NextMenuOption = PreMenuOption;
1068       }
1069       break;
1070     }
1071
1072     Distance += NextMenuOption->Skip;
1073
1074     //
1075     // Arrive at begin of the menu list.
1076     //
1077     if ((GoUp ? Pos->BackLink : Pos->ForwardLink) == &gMenuOption) {
1078       Distance = -1;
1079       break;
1080     }
1081
1082     Pos = (GoUp ? Pos->BackLink : Pos->ForwardLink);
1083     PreMenuOption = NextMenuOption;
1084   }
1085
1086   *CurrentPosition = &NextMenuOption->Link;
1087   return Distance;
1088 }
1089
1090
1091 /**
1092   Process option string for date/time opcode.
1093
1094   @param  MenuOption              Menu option point to date/time.
1095   @param  OptionString            Option string input for process.
1096   @param  AddOptCol               Whether need to update MenuOption->OptCol.
1097
1098 **/
1099 VOID
1100 ProcessStringForDateTime (
1101   UI_MENU_OPTION                  *MenuOption,
1102   CHAR16                          *OptionString,
1103   BOOLEAN                         AddOptCol
1104   )
1105 {
1106   UINTN Index;
1107   UINTN Count;
1108   FORM_DISPLAY_ENGINE_STATEMENT          *Statement;
1109   EFI_IFR_DATE                           *Date;
1110   EFI_IFR_TIME                           *Time;
1111
1112   ASSERT (MenuOption != NULL && OptionString != NULL);
1113
1114   Statement = MenuOption->ThisTag;
1115   Date      = NULL;
1116   Time      = NULL;
1117   if (Statement->OpCode->OpCode == EFI_IFR_DATE_OP) {
1118     Date = (EFI_IFR_DATE *) Statement->OpCode;
1119   } else if (Statement->OpCode->OpCode == EFI_IFR_TIME_OP) {
1120     Time = (EFI_IFR_TIME *) Statement->OpCode;
1121   }
1122
1123   //
1124   // If leading spaces on OptionString - remove the spaces
1125   //
1126   for (Index = 0; OptionString[Index] == L' '; Index++) {
1127     //
1128     // Base on the blockspace to get the option column info.
1129     //
1130     if (AddOptCol) {
1131       MenuOption->OptCol++;
1132     }
1133   }
1134
1135   for (Count = 0; OptionString[Index] != CHAR_NULL; Index++) {
1136     OptionString[Count] = OptionString[Index];
1137     Count++;
1138   }
1139   OptionString[Count] = CHAR_NULL;
1140
1141   //
1142   // Enable to suppress field in the opcode base on the flag.
1143   //
1144   if (Statement->OpCode->OpCode == EFI_IFR_DATE_OP) {
1145     //
1146     // OptionString format is: <**:  **: ****>
1147     //                        |month|day|year|
1148     //                          4     3    5
1149     //
1150     if ((Date->Flags & EFI_QF_DATE_MONTH_SUPPRESS) && (MenuOption->Sequence == 0)) {
1151       //
1152       // At this point, only "<**:" in the optionstring.
1153       // Clean the day's ** field, after clean, the format is "<  :"
1154       //
1155       SetUnicodeMem (&OptionString[1], 2, L' ');
1156     } else if ((Date->Flags & EFI_QF_DATE_DAY_SUPPRESS) && (MenuOption->Sequence == 1)) {
1157       //
1158       // At this point, only "**:" in the optionstring.
1159       // Clean the month's "**" field, after clean, the format is "  :"
1160       //
1161       SetUnicodeMem (&OptionString[0], 2, L' ');
1162     } else if ((Date->Flags & EFI_QF_DATE_YEAR_SUPPRESS) && (MenuOption->Sequence == 2)) {
1163       //
1164       // At this point, only "****>" in the optionstring.
1165       // Clean the year's "****" field, after clean, the format is "  >"
1166       //
1167       SetUnicodeMem (&OptionString[0], 4, L' ');
1168     }
1169   } else if (Statement->OpCode->OpCode == EFI_IFR_TIME_OP) {
1170     //
1171     // OptionString format is: <**:  **:    **>
1172     //                        |hour|minute|second|
1173     //                          4     3      3
1174     //
1175     if ((Time->Flags & QF_TIME_HOUR_SUPPRESS) && (MenuOption->Sequence == 0)) {
1176       //
1177       // At this point, only "<**:" in the optionstring.
1178       // Clean the hour's ** field, after clean, the format is "<  :"
1179       //
1180       SetUnicodeMem (&OptionString[1], 2, L' ');
1181     } else if ((Time->Flags & QF_TIME_MINUTE_SUPPRESS) && (MenuOption->Sequence == 1)) {
1182       //
1183       // At this point, only "**:" in the optionstring.
1184       // Clean the minute's "**" field, after clean, the format is "  :"
1185       //
1186       SetUnicodeMem (&OptionString[0], 2, L' ');
1187     } else if ((Time->Flags & QF_TIME_SECOND_SUPPRESS) && (MenuOption->Sequence == 2)) {
1188       //
1189       // At this point, only "**>" in the optionstring.
1190       // Clean the second's "**" field, after clean, the format is "  >"
1191       //
1192       SetUnicodeMem (&OptionString[0], 2, L' ');
1193     }
1194   }
1195 }
1196
1197
1198 /**
1199   Adjust Data and Time position accordingly.
1200   Data format :      [01/02/2004]      [11:22:33]
1201   Line number :        0  0    1         0  0  1
1202
1203   This is an internal function.
1204
1205   @param  DirectionUp            the up or down direction. False is down. True is
1206                                  up.
1207   @param  CurrentPosition        Current position. On return: Point to the last
1208                                  Option (Year or Second) if up; Point to the first
1209                                  Option (Month or Hour) if down.
1210
1211   @return Return line number to pad. It is possible that we stand on a zero-advance
1212   @return data or time opcode, so pad one line when we judge if we are going to scroll outside.
1213
1214 **/
1215 UINTN
1216 AdjustDateAndTimePosition (
1217   IN     BOOLEAN                     DirectionUp,
1218   IN OUT LIST_ENTRY                  **CurrentPosition
1219   )
1220 {
1221   UINTN           Count;
1222   LIST_ENTRY      *NewPosition;
1223   UI_MENU_OPTION  *MenuOption;
1224   UINTN           PadLineNumber;
1225
1226   PadLineNumber = 0;
1227   NewPosition   = *CurrentPosition;
1228   MenuOption    = MENU_OPTION_FROM_LINK (NewPosition);
1229
1230   if ((MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_DATE_OP) ||
1231       (MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_TIME_OP)) {
1232     //
1233     // Calculate the distance from current position to the last Date/Time MenuOption
1234     //
1235     Count = 0;
1236     while (MenuOption->Skip == 0) {
1237       Count++;
1238       NewPosition   = NewPosition->ForwardLink;
1239       MenuOption    = MENU_OPTION_FROM_LINK (NewPosition);
1240       PadLineNumber = 1;
1241     }
1242
1243     NewPosition = *CurrentPosition;
1244     if (DirectionUp) {
1245       //
1246       // Since the behavior of hitting the up arrow on a Date/Time MenuOption is intended
1247       // to be one that back to the previous set of MenuOptions, we need to advance to the first
1248       // Date/Time MenuOption and leave the remaining logic in CfUiUp intact so the appropriate
1249       // checking can be done.
1250       //
1251       while (Count++ < 2) {
1252         NewPosition = NewPosition->BackLink;
1253       }
1254     } else {
1255       //
1256       // Since the behavior of hitting the down arrow on a Date/Time MenuOption is intended
1257       // to be one that progresses to the next set of MenuOptions, we need to advance to the last
1258       // Date/Time MenuOption and leave the remaining logic in CfUiDown intact so the appropriate
1259       // checking can be done.
1260       //
1261       while (Count-- > 0) {
1262         NewPosition = NewPosition->ForwardLink;
1263       }
1264     }
1265
1266     *CurrentPosition = NewPosition;
1267   }
1268
1269   return PadLineNumber;
1270 }
1271
1272 /**
1273   Get step info from numeric opcode.
1274
1275   @param[in] OpCode     The input numeric op code.
1276
1277   @return step info for this opcode.
1278 **/
1279 UINT64
1280 GetFieldFromNum (
1281   IN  EFI_IFR_OP_HEADER     *OpCode
1282   )
1283 {
1284   EFI_IFR_NUMERIC       *NumericOp;
1285   UINT64                Step;
1286
1287   NumericOp = (EFI_IFR_NUMERIC *) OpCode;
1288
1289   switch (NumericOp->Flags & EFI_IFR_NUMERIC_SIZE) {
1290   case EFI_IFR_NUMERIC_SIZE_1:
1291     Step    = NumericOp->data.u8.Step;
1292     break;
1293
1294   case EFI_IFR_NUMERIC_SIZE_2:
1295     Step    = NumericOp->data.u16.Step;
1296     break;
1297
1298   case EFI_IFR_NUMERIC_SIZE_4:
1299     Step    = NumericOp->data.u32.Step;
1300     break;
1301
1302   case EFI_IFR_NUMERIC_SIZE_8:
1303     Step    = NumericOp->data.u64.Step;
1304     break;
1305
1306   default:
1307     Step = 0;
1308     break;
1309   }
1310
1311   return Step;
1312 }
1313
1314 /**
1315   Find the registered HotKey based on KeyData.
1316
1317   @param[in] KeyData     A pointer to a buffer that describes the keystroke
1318                          information for the hot key.
1319
1320   @return The registered HotKey context. If no found, NULL will return.
1321 **/
1322 BROWSER_HOT_KEY *
1323 GetHotKeyFromRegisterList (
1324   IN EFI_INPUT_KEY *KeyData
1325   )
1326 {
1327   LIST_ENTRY       *Link;
1328   BROWSER_HOT_KEY  *HotKey;
1329
1330   Link = GetFirstNode (&gFormData->HotKeyListHead);
1331   while (!IsNull (&gFormData->HotKeyListHead, Link)) {
1332     HotKey = BROWSER_HOT_KEY_FROM_LINK (Link);
1333
1334     if (HotKey->KeyData->ScanCode == KeyData->ScanCode) {
1335       return HotKey;
1336     }
1337
1338     Link = GetNextNode (&gFormData->HotKeyListHead, Link);
1339   }
1340
1341   return NULL;
1342 }
1343
1344
1345 /**
1346   Determine if the menu is the last menu that can be selected.
1347
1348   This is an internal function.
1349
1350   @param  Direction              The scroll direction. False is down. True is up.
1351   @param  CurrentPos             The current focus.
1352
1353   @return FALSE -- the menu isn't the last menu that can be selected.
1354   @return TRUE  -- the menu is the last menu that can be selected.
1355
1356 **/
1357 BOOLEAN
1358 ValueIsScroll (
1359   IN  BOOLEAN                     Direction,
1360   IN  LIST_ENTRY                  *CurrentPos
1361   )
1362 {
1363   LIST_ENTRY      *Temp;
1364
1365   Temp = Direction ? CurrentPos->BackLink : CurrentPos->ForwardLink;
1366
1367   if (Temp == &gMenuOption) {
1368     return TRUE;
1369   }
1370
1371   return FALSE;
1372 }
1373
1374 /**
1375   Wait for a given event to fire, or for an optional timeout to expire.
1376
1377   @param  Event                  The event to wait for
1378
1379   @retval UI_EVENT_TYPE          The type of the event which is trigged.
1380
1381 **/
1382 UI_EVENT_TYPE
1383 UiWaitForEvent (
1384   IN EFI_EVENT                Event
1385   )
1386 {
1387   EFI_STATUS  Status;
1388   UINTN       Index;
1389   UINTN       EventNum;
1390   UINT64      Timeout;
1391   EFI_EVENT   TimerEvent;
1392   EFI_EVENT   WaitList[3];
1393   UI_EVENT_TYPE  EventType;
1394
1395   TimerEvent = NULL;
1396   Timeout    = FormExitTimeout(gFormData);
1397
1398   if (Timeout != 0) {
1399     Status = gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &TimerEvent);
1400
1401     //
1402     // Set the timer event
1403     //
1404     gBS->SetTimer (
1405           TimerEvent,
1406           TimerRelative,
1407           Timeout
1408           );
1409   }
1410
1411   WaitList[0] = Event;
1412   EventNum    = 1;
1413   if (gFormData->FormRefreshEvent != NULL) {
1414     WaitList[EventNum] = gFormData->FormRefreshEvent;
1415     EventNum ++;
1416   }
1417
1418   if (Timeout != 0) {
1419     WaitList[EventNum] = TimerEvent;
1420     EventNum ++;
1421   }
1422
1423   Status = gBS->WaitForEvent (EventNum, WaitList, &Index);
1424   ASSERT_EFI_ERROR (Status);
1425
1426   switch (Index) {
1427   case 0:
1428    EventType = UIEventKey;
1429    break;
1430
1431   case 1:
1432     if (gFormData->FormRefreshEvent != NULL) {
1433       EventType = UIEventDriver;
1434     } else {
1435       ASSERT (Timeout != 0 && EventNum == 2);
1436       EventType = UIEventTimeOut;
1437     }
1438     break;
1439
1440   default:
1441     ASSERT (Index == 2 && EventNum == 3);
1442     EventType = UIEventTimeOut;
1443     break;
1444   }
1445
1446   if (Timeout != 0) {
1447     gBS->CloseEvent (TimerEvent);
1448   }
1449
1450   return EventType;
1451 }
1452
1453 /**
1454   Get question id info from the input opcode header.
1455
1456   @param  OpCode                 The input opcode header pointer.
1457
1458   @retval                        The question id for this opcode.
1459
1460 **/
1461 EFI_QUESTION_ID
1462 GetQuestionIdInfo (
1463   IN   EFI_IFR_OP_HEADER     *OpCode
1464   )
1465 {
1466   EFI_IFR_QUESTION_HEADER   *QuestionHeader;
1467
1468   if (OpCode->Length < sizeof (EFI_IFR_OP_HEADER) + sizeof (EFI_IFR_QUESTION_HEADER)) {
1469     return 0;
1470   }
1471
1472   QuestionHeader = (EFI_IFR_QUESTION_HEADER *)((UINT8 *) OpCode + sizeof(EFI_IFR_OP_HEADER));
1473
1474   return QuestionHeader->QuestionId;
1475 }
1476
1477
1478 /**
1479   Find the top of screen menu base on the current menu.
1480
1481   @param  CurPos                 Current input menu.
1482   @param  Rows                   Totol screen rows.
1483   @param  SkipValue              SkipValue for this new form.
1484
1485   @retval TopOfScreen            Top of screen menu for the new form.
1486
1487 **/
1488 LIST_ENTRY *
1489 FindTopOfScreenMenu (
1490   IN  LIST_ENTRY                      *CurPos,
1491   IN  UINTN                           Rows,
1492   OUT UINTN                           *SkipValue
1493   )
1494 {
1495   LIST_ENTRY        *Link;
1496   LIST_ENTRY        *TopOfScreen;
1497   UI_MENU_OPTION    *PreviousMenuOption;
1498
1499   Link = CurPos;
1500   PreviousMenuOption = NULL;
1501
1502   while (Link->BackLink != &gMenuOption) {
1503     Link = Link->BackLink;
1504     PreviousMenuOption = MENU_OPTION_FROM_LINK (Link);
1505     if (PreviousMenuOption->Row == 0) {
1506       UpdateOptionSkipLines (PreviousMenuOption);
1507     }
1508     if (Rows <= PreviousMenuOption->Skip) {
1509       break;
1510     }
1511     Rows = Rows - PreviousMenuOption->Skip;
1512   }
1513
1514   if (Link->BackLink == &gMenuOption) {
1515     TopOfScreen = gMenuOption.ForwardLink;
1516     if (PreviousMenuOption != NULL && Rows < PreviousMenuOption->Skip) {
1517       *SkipValue = PreviousMenuOption->Skip - Rows;
1518     } else {
1519       *SkipValue = 0;
1520     }
1521   } else {
1522     TopOfScreen = Link;
1523     *SkipValue = PreviousMenuOption->Skip - Rows;
1524   }
1525
1526   return TopOfScreen;
1527 }
1528
1529 /**
1530   Get the index info for this opcode.
1531
1532   @param  OpCode      The input opcode for the statement.
1533
1534   @retval  The index of this statement.
1535
1536 **/
1537 UINTN
1538 GetIndexInfoForOpcode (
1539   IN EFI_IFR_OP_HEADER  *OpCode
1540   )
1541 {
1542   LIST_ENTRY                      *NewPos;
1543   UI_MENU_OPTION                  *MenuOption;
1544   UINTN                           Index;
1545
1546   NewPos = gMenuOption.ForwardLink;
1547   Index  = 0;
1548
1549   for (NewPos = gMenuOption.ForwardLink; NewPos != &gMenuOption; NewPos = NewPos->ForwardLink){
1550     MenuOption = MENU_OPTION_FROM_LINK (NewPos);
1551
1552     if (CompareMem (MenuOption->ThisTag->OpCode, OpCode, OpCode->Length) == 0) {
1553       if (MenuOption->ThisTag->OpCode == OpCode) {
1554         return Index;
1555       }
1556
1557       Index ++;
1558     }
1559   }
1560
1561   return Index;
1562 }
1563
1564 /**
1565   Is this the saved highlight statement.
1566
1567   @param  HighLightedStatement      The input highlight statement.
1568
1569   @retval  TRUE   This is the highlight statement.
1570   @retval  FALSE  This is not the highlight statement.
1571
1572 **/
1573 BOOLEAN
1574 IsSavedHighlightStatement (
1575   IN FORM_DISPLAY_ENGINE_STATEMENT  *HighLightedStatement
1576   )
1577 {
1578   if ((gFormData->HiiHandle == gHighligthMenuInfo.HiiHandle) &&
1579       (gFormData->FormId == gHighligthMenuInfo.FormId)) {
1580     if (gHighligthMenuInfo.HLTQuestionId != 0) {
1581       return (BOOLEAN) (gHighligthMenuInfo.HLTQuestionId == GetQuestionIdInfo (HighLightedStatement->OpCode));
1582     } else {
1583       if (CompareMem (gHighligthMenuInfo.HLTOpCode, HighLightedStatement->OpCode, gHighligthMenuInfo.HLTOpCode->Length) == 0) {
1584         if (gHighligthMenuInfo.HLTIndex == 0 || gHighligthMenuInfo.HLTIndex == GetIndexInfoForOpcode(HighLightedStatement->OpCode)) {
1585           return TRUE;
1586         } else {
1587           return FALSE;
1588         }
1589       }
1590     }
1591   }
1592
1593   return FALSE;
1594 }
1595
1596 /**
1597   Is this the highlight menu.
1598
1599   @param  MenuOption      The input Menu option.
1600
1601   @retval  TRUE   This is the highlight menu option.
1602   @retval  FALSE  This is not the highlight menu option.
1603
1604 **/
1605 BOOLEAN
1606 IsHighLightMenuOption (
1607   IN UI_MENU_OPTION     *MenuOption
1608   )
1609 {
1610   if (gHighligthMenuInfo.HLTQuestionId != 0) {
1611     if (GetQuestionIdInfo(MenuOption->ThisTag->OpCode) == gHighligthMenuInfo.HLTQuestionId) {
1612       return (BOOLEAN) (MenuOption->Sequence == gHighligthMenuInfo.HLTSequence);
1613     }
1614   } else {
1615     if(CompareMem (gHighligthMenuInfo.HLTOpCode, MenuOption->ThisTag->OpCode, gHighligthMenuInfo.HLTOpCode->Length) == 0) {
1616       if (gHighligthMenuInfo.HLTIndex == 0 || gHighligthMenuInfo.HLTIndex == GetIndexInfoForOpcode(MenuOption->ThisTag->OpCode)) {
1617         return (BOOLEAN) (MenuOption->Sequence == gHighligthMenuInfo.HLTSequence);
1618       } else {
1619         return FALSE;
1620       }
1621     }
1622   }
1623
1624   return FALSE;
1625 }
1626
1627 /**
1628   Find the highlight menu.
1629
1630   If the input is NULL, base on the record highlight info in
1631   gHighligthMenuInfo to find the last highlight menu.
1632
1633   @param  HighLightedStatement      The input highlight statement.
1634
1635   @retval  The highlight menu index.
1636
1637 **/
1638 LIST_ENTRY *
1639 FindHighLightMenuOption (
1640  IN FORM_DISPLAY_ENGINE_STATEMENT  *HighLightedStatement
1641  )
1642 {
1643   LIST_ENTRY                      *NewPos;
1644   UI_MENU_OPTION                  *MenuOption;
1645
1646   NewPos = gMenuOption.ForwardLink;
1647   MenuOption = MENU_OPTION_FROM_LINK (NewPos);
1648
1649   if (HighLightedStatement != NULL) {
1650     while (MenuOption->ThisTag != HighLightedStatement) {
1651       NewPos     = NewPos->ForwardLink;
1652       if (NewPos == &gMenuOption) {
1653         //
1654         // Not Found it, break
1655         //
1656         break;
1657       }
1658       MenuOption = MENU_OPTION_FROM_LINK (NewPos);
1659     }
1660
1661     //
1662     // Must find the highlight statement.
1663     //
1664     ASSERT (NewPos != &gMenuOption);
1665
1666   } else {
1667     while (!IsHighLightMenuOption (MenuOption)) {
1668       NewPos     = NewPos->ForwardLink;
1669       if (NewPos == &gMenuOption) {
1670         //
1671         // Not Found it, break
1672         //
1673         break;
1674       }
1675       MenuOption = MENU_OPTION_FROM_LINK (NewPos);
1676     }
1677
1678     //
1679     // Highlight statement has disappear (suppressed/disableed)
1680     //
1681     if (NewPos == &gMenuOption) {
1682       NewPos = NULL;
1683     }
1684   }
1685
1686   return NewPos;
1687 }
1688
1689 /**
1690   Is this the Top of screen menu.
1691
1692   @param  MenuOption      The input Menu option.
1693
1694   @retval  TRUE   This is the Top of screen menu option.
1695   @retval  FALSE  This is not the Top of screen menu option.
1696
1697 **/
1698 BOOLEAN
1699 IsTopOfScreeMenuOption (
1700   IN UI_MENU_OPTION     *MenuOption
1701   )
1702 {
1703   if (gHighligthMenuInfo.TOSQuestionId != 0) {
1704     return (BOOLEAN) (GetQuestionIdInfo(MenuOption->ThisTag->OpCode) == gHighligthMenuInfo.TOSQuestionId);
1705   }
1706
1707   if(CompareMem (gHighligthMenuInfo.TOSOpCode, MenuOption->ThisTag->OpCode, gHighligthMenuInfo.TOSOpCode->Length) == 0) {
1708     if (gHighligthMenuInfo.TOSIndex == 0 || gHighligthMenuInfo.TOSIndex == GetIndexInfoForOpcode(MenuOption->ThisTag->OpCode)) {
1709       return TRUE;
1710     } else {
1711       return FALSE;
1712     }
1713   }
1714
1715   return FALSE;
1716 }
1717
1718 /**
1719   Find the Top of screen menu.
1720
1721   If the input is NULL, base on the record highlight info in
1722   gHighligthMenuInfo to find the last highlight menu.
1723
1724   @param  HighLightedStatement      The input highlight statement.
1725
1726   @retval  The highlight menu index.
1727
1728 **/
1729 LIST_ENTRY *
1730 FindTopOfScreenMenuOption (
1731  VOID
1732  )
1733 {
1734   LIST_ENTRY                      *NewPos;
1735   UI_MENU_OPTION                  *MenuOption;
1736
1737   NewPos = gMenuOption.ForwardLink;
1738   MenuOption = MENU_OPTION_FROM_LINK (NewPos);
1739
1740   while (!IsTopOfScreeMenuOption(MenuOption)) {
1741     NewPos     = NewPos->ForwardLink;
1742     if (NewPos == &gMenuOption) {
1743       //
1744       // Not Found it, break
1745       //
1746       break;
1747     }
1748     MenuOption = MENU_OPTION_FROM_LINK (NewPos);
1749   }
1750
1751   //
1752   // Last time top of screen menu has disappeared.
1753   //
1754   if (NewPos == &gMenuOption) {
1755     NewPos = NULL;
1756   }
1757
1758   return NewPos;
1759 }
1760
1761 /**
1762   Find the first menu which will be show at the top.
1763
1764   @param  FormData               The data info for this form.
1765   @param  TopOfScreen            The link_entry pointer to top menu.
1766   @param  HighlightMenu          The menu which will be highlight.
1767   @param  SkipValue              The skip value for the top menu.
1768
1769 **/
1770 VOID
1771 FindTopMenu (
1772   IN  FORM_DISPLAY_ENGINE_FORM  *FormData,
1773   OUT LIST_ENTRY                **TopOfScreen,
1774   OUT LIST_ENTRY                **HighlightMenu,
1775   OUT UINTN                     *SkipValue
1776   )
1777 {
1778   UINTN                           TopRow;
1779   UINTN                           BottomRow;
1780   UI_MENU_OPTION                  *MenuOption;
1781   UINTN                           TmpValue;
1782
1783   TopRow    = gStatementDimensions.TopRow    + SCROLL_ARROW_HEIGHT;
1784   BottomRow = gStatementDimensions.BottomRow - SCROLL_ARROW_HEIGHT;
1785
1786   if (gMisMatch) {
1787     //
1788     // Reenter caused by option mismatch or auto exit caused by refresh form(refresh interval/guid),
1789     // base on the record highlight info to find the highlight menu.
1790     //
1791     ASSERT (gFormData->HiiHandle == gHighligthMenuInfo.HiiHandle &&
1792             gFormData->FormId == gHighligthMenuInfo.FormId);
1793
1794     *HighlightMenu = FindHighLightMenuOption(NULL);
1795     if (*HighlightMenu != NULL) {
1796       //
1797       // Update skip info for this highlight menu.
1798       //
1799       MenuOption = MENU_OPTION_FROM_LINK (*HighlightMenu);
1800       UpdateOptionSkipLines (MenuOption);
1801
1802       //
1803       // Found the last time highlight menu.
1804       //
1805       *TopOfScreen = FindTopOfScreenMenuOption();
1806       if (*TopOfScreen != NULL) {
1807         //
1808         // Found the last time selectable top of screen menu.
1809         //
1810         AdjustDateAndTimePosition(TRUE, TopOfScreen);
1811         MenuOption = MENU_OPTION_FROM_LINK (*TopOfScreen);
1812         UpdateOptionSkipLines (MenuOption);
1813
1814         *SkipValue = gHighligthMenuInfo.SkipValue;
1815       } else {
1816         //
1817         // Not found last time top of screen menu, so base on current highlight menu
1818         // to find the new top of screen menu.
1819         // Make the current highlight menu at the bottom of the form to calculate the
1820         // top of screen menu.
1821         //
1822         if (MenuOption->Skip >= BottomRow - TopRow) {
1823           *TopOfScreen = *HighlightMenu;
1824           TmpValue     = 0;
1825         } else {
1826           *TopOfScreen = FindTopOfScreenMenu(*HighlightMenu, BottomRow - TopRow - MenuOption->Skip, &TmpValue);
1827         }
1828
1829         *SkipValue   = TmpValue;
1830       }
1831     } else {
1832       //
1833       // Last time highlight menu has disappear, find the first highlightable menu as the defalut one.
1834       //
1835       *HighlightMenu = gMenuOption.ForwardLink;
1836       if (!IsListEmpty (&gMenuOption)) {
1837         MoveToNextStatement (FALSE, HighlightMenu, BottomRow - TopRow, TRUE);
1838       }
1839       *TopOfScreen   = gMenuOption.ForwardLink;
1840       *SkipValue = 0;
1841     }
1842
1843     gMisMatch = FALSE;
1844   } else if (FormData->HighLightedStatement != NULL) {
1845     if (IsSavedHighlightStatement (FormData->HighLightedStatement)) {
1846       //
1847       // Input highlight menu is same as last time highlight menu.
1848       // Base on last time highlight menu to set the top of screen menu and highlight menu.
1849       //
1850       *HighlightMenu = FindHighLightMenuOption(NULL);
1851       ASSERT (*HighlightMenu != NULL);
1852
1853       //
1854       // Update skip info for this highlight menu.
1855       //
1856       MenuOption = MENU_OPTION_FROM_LINK (*HighlightMenu);
1857       UpdateOptionSkipLines (MenuOption);
1858
1859       *TopOfScreen = FindTopOfScreenMenuOption();
1860       if (*TopOfScreen == NULL) {
1861         //
1862         // Not found last time top of screen menu, so base on current highlight menu
1863         // to find the new top of screen menu.
1864         // Make the current highlight menu at the bottom of the form to calculate the
1865         // top of screen menu.
1866         //
1867         if (MenuOption->Skip >= BottomRow - TopRow) {
1868           *TopOfScreen = *HighlightMenu;
1869           TmpValue     = 0;
1870         } else {
1871           *TopOfScreen = FindTopOfScreenMenu(*HighlightMenu, BottomRow - TopRow - MenuOption->Skip, &TmpValue);
1872         }
1873
1874         *SkipValue   = TmpValue;
1875       } else {
1876         AdjustDateAndTimePosition(TRUE, TopOfScreen);
1877         MenuOption = MENU_OPTION_FROM_LINK (*TopOfScreen);
1878         UpdateOptionSkipLines (MenuOption);
1879
1880         *SkipValue = gHighligthMenuInfo.SkipValue;
1881       }
1882       AdjustDateAndTimePosition(TRUE, TopOfScreen);
1883     } else {
1884       //
1885       // Input highlight menu is not save as last time highlight menu.
1886       //
1887       *HighlightMenu = FindHighLightMenuOption(FormData->HighLightedStatement);
1888       MenuOption = MENU_OPTION_FROM_LINK (*HighlightMenu);
1889       UpdateOptionSkipLines (MenuOption);
1890
1891       //
1892       // Make the current highlight menu at the bottom of the form to calculate the
1893       // top of screen menu.
1894       //
1895       if (MenuOption->Skip >= BottomRow - TopRow) {
1896         *TopOfScreen = *HighlightMenu;
1897         TmpValue     = 0;
1898       } else {
1899         *TopOfScreen = FindTopOfScreenMenu(*HighlightMenu, BottomRow - TopRow - MenuOption->Skip, &TmpValue);
1900       }
1901
1902       *SkipValue   = TmpValue;
1903     }
1904     AdjustDateAndTimePosition(TRUE, TopOfScreen);
1905   } else {
1906     //
1907     // If not has input highlight statement, just return the first one in this form.
1908     //
1909     *TopOfScreen   = gMenuOption.ForwardLink;
1910     *HighlightMenu = gMenuOption.ForwardLink;
1911     if (!IsListEmpty (&gMenuOption)) {
1912       MoveToNextStatement (FALSE, HighlightMenu, BottomRow - TopRow, TRUE);
1913     }
1914     *SkipValue     = 0;
1915   }
1916
1917   //
1918   // First enter to show the menu, update highlight info.
1919   //
1920   UpdateHighlightMenuInfo (*HighlightMenu, *TopOfScreen, *SkipValue);
1921 }
1922
1923 /**
1924   Record the highlight menu and top of screen menu info.
1925
1926   @param  Highlight               The menu opton which is highlight.
1927   @param  TopOfScreen             The menu opton which is at the top of the form.
1928   @param  SkipValue               The skip line info for the top of screen menu.
1929
1930 **/
1931 VOID
1932 UpdateHighlightMenuInfo (
1933   IN  LIST_ENTRY                      *Highlight,
1934   IN  LIST_ENTRY                      *TopOfScreen,
1935   IN  UINTN                           SkipValue
1936   )
1937 {
1938   UI_MENU_OPTION                  *MenuOption;
1939   FORM_DISPLAY_ENGINE_STATEMENT   *Statement;
1940
1941   gHighligthMenuInfo.HiiHandle  = gFormData->HiiHandle;
1942   gHighligthMenuInfo.FormId     = gFormData->FormId;
1943   gHighligthMenuInfo.SkipValue  = (UINT16)SkipValue;
1944
1945   if (!IsListEmpty (&gMenuOption)) {
1946     MenuOption = MENU_OPTION_FROM_LINK (Highlight);
1947     Statement  = MenuOption->ThisTag;
1948
1949     gUserInput->SelectedStatement = Statement;
1950
1951     gHighligthMenuInfo.HLTSequence   = MenuOption->Sequence;
1952     gHighligthMenuInfo.HLTQuestionId = GetQuestionIdInfo(Statement->OpCode);
1953     if (gHighligthMenuInfo.HLTQuestionId == 0) {
1954       //
1955       // if question id == 0, save the opcode buffer..
1956       //
1957       if (gHighligthMenuInfo.HLTOpCode != NULL) {
1958         FreePool (gHighligthMenuInfo.HLTOpCode);
1959       }
1960       gHighligthMenuInfo.HLTOpCode = AllocateCopyPool (Statement->OpCode->Length, Statement->OpCode);
1961       ASSERT (gHighligthMenuInfo.HLTOpCode != NULL);
1962
1963       gHighligthMenuInfo.HLTIndex = GetIndexInfoForOpcode(Statement->OpCode);
1964     }
1965
1966     MenuOption = MENU_OPTION_FROM_LINK (TopOfScreen);
1967     Statement  = MenuOption->ThisTag;
1968
1969     gHighligthMenuInfo.TOSQuestionId = GetQuestionIdInfo(Statement->OpCode);
1970     if (gHighligthMenuInfo.TOSQuestionId == 0) {
1971       //
1972       // if question id == 0, save the opcode buffer..
1973       //
1974       if (gHighligthMenuInfo.TOSOpCode != NULL) {
1975         FreePool (gHighligthMenuInfo.TOSOpCode);
1976       }
1977       gHighligthMenuInfo.TOSOpCode = AllocateCopyPool (Statement->OpCode->Length, Statement->OpCode);
1978       ASSERT (gHighligthMenuInfo.TOSOpCode != NULL);
1979
1980       gHighligthMenuInfo.TOSIndex = GetIndexInfoForOpcode(Statement->OpCode);
1981     }
1982   } else {
1983     gUserInput->SelectedStatement    = NULL;
1984
1985     gHighligthMenuInfo.HLTSequence   = 0;
1986     gHighligthMenuInfo.HLTQuestionId = 0;
1987     if (gHighligthMenuInfo.HLTOpCode != NULL) {
1988       FreePool (gHighligthMenuInfo.HLTOpCode);
1989     }
1990     gHighligthMenuInfo.HLTOpCode     = NULL;
1991     gHighligthMenuInfo.HLTIndex      = 0;
1992
1993     gHighligthMenuInfo.TOSQuestionId = 0;
1994     if (gHighligthMenuInfo.TOSOpCode != NULL) {
1995       FreePool (gHighligthMenuInfo.TOSOpCode);
1996     }
1997     gHighligthMenuInfo.TOSOpCode     = NULL;
1998     gHighligthMenuInfo.TOSIndex      = 0;
1999   }
2000 }
2001
2002 /**
2003   Update attribut for this menu.
2004
2005   @param  MenuOption               The menu opton which this attribut used to.
2006   @param  Highlight                Whether this menu will be highlight.
2007
2008 **/
2009 VOID
2010 SetDisplayAttribute (
2011   IN UI_MENU_OPTION                  *MenuOption,
2012   IN BOOLEAN                         Highlight
2013   )
2014 {
2015   FORM_DISPLAY_ENGINE_STATEMENT   *Statement;
2016
2017   Statement = MenuOption->ThisTag;
2018
2019   if (Highlight) {
2020     gST->ConOut->SetAttribute (gST->ConOut, GetHighlightTextColor ());
2021     return;
2022   }
2023
2024   if (MenuOption->GrayOut) {
2025     gST->ConOut->SetAttribute (gST->ConOut, GetGrayedTextColor ());
2026   } else {
2027     if (Statement->OpCode->OpCode == EFI_IFR_SUBTITLE_OP) {
2028       gST->ConOut->SetAttribute (gST->ConOut, GetSubTitleTextColor ());
2029     } else {
2030       gST->ConOut->SetAttribute (gST->ConOut, GetFieldTextColor ());
2031     }
2032   }
2033 }
2034
2035 /**
2036   Print string for this menu option.
2037
2038   @param  MenuOption               The menu opton which this attribut used to.
2039   @param  Col                      The column that this string will be print at.
2040   @param  Row                      The row that this string will be print at.
2041   @param  String                   The string which need to print.
2042   @param  Width                    The width need to print, if string is less than the
2043                                    width, the block space will be used.
2044   @param  Highlight                Whether this menu will be highlight.
2045
2046 **/
2047 VOID
2048 DisplayMenuString (
2049   IN UI_MENU_OPTION         *MenuOption,
2050   IN UINTN                  Col,
2051   IN UINTN                  Row,
2052   IN CHAR16                 *String,
2053   IN UINTN                  Width,
2054   IN BOOLEAN                Highlight
2055   )
2056 {
2057   UINTN            Length;
2058
2059   //
2060   // Print string with normal color.
2061   //
2062   if (!Highlight) {
2063     PrintStringAtWithWidth (Col, Row, String, Width);
2064     return;
2065   }
2066
2067   //
2068   // Print the highlight menu string.
2069   // First print the highlight string.
2070   //
2071   SetDisplayAttribute(MenuOption, TRUE);
2072   Length = PrintStringAt (Col, Row, String);
2073
2074   //
2075   // Second, clean the empty after the string.
2076   //
2077   SetDisplayAttribute(MenuOption, FALSE);
2078   PrintStringAtWithWidth (Col + Length, Row, L"", Width - Length);
2079 }
2080
2081 /**
2082   Check whether this menu can has option string.
2083
2084   @param  MenuOption               The menu opton which this attribut used to.
2085
2086   @retval TRUE                     This menu option can have option string.
2087   @retval FALSE                    This menu option can't have option string.
2088
2089 **/
2090 BOOLEAN
2091 HasOptionString (
2092   IN UI_MENU_OPTION                  *MenuOption
2093   )
2094 {
2095   FORM_DISPLAY_ENGINE_STATEMENT   *Statement;
2096   CHAR16                          *String;
2097   UINTN                           Size;
2098   EFI_IFR_TEXT                    *TestOp;
2099
2100   Size = 0;
2101   Statement = MenuOption->ThisTag;
2102
2103   //
2104   // See if the second text parameter is really NULL
2105   //
2106   if (Statement->OpCode->OpCode == EFI_IFR_TEXT_OP) {
2107     TestOp = (EFI_IFR_TEXT *) Statement->OpCode;
2108     if (TestOp->TextTwo != 0) {
2109       String = GetToken (TestOp->TextTwo, gFormData->HiiHandle);
2110       Size   = StrLen (String);
2111       FreePool (String);
2112     }
2113   }
2114
2115   if ((Statement->OpCode->OpCode == EFI_IFR_SUBTITLE_OP) ||
2116     (Statement->OpCode->OpCode == EFI_IFR_REF_OP) ||
2117     (Statement->OpCode->OpCode == EFI_IFR_PASSWORD_OP) ||
2118     (Statement->OpCode->OpCode == EFI_IFR_ACTION_OP) ||
2119     (Statement->OpCode->OpCode == EFI_IFR_RESET_BUTTON_OP) ||
2120     //
2121     // Allow a wide display if text op-code and no secondary text op-code
2122     //
2123     ((Statement->OpCode->OpCode == EFI_IFR_TEXT_OP) && (Size == 0))
2124     ) {
2125
2126     return FALSE;
2127   }
2128
2129   return TRUE;
2130 }
2131
2132 /**
2133   Double confirm with user about the action.
2134
2135   @param  Action               The user input action.
2136
2137   @retval TRUE                 User confirm with the input or not need user confirm.
2138   @retval FALSE                User want ignore this input.
2139
2140 **/
2141 BOOLEAN
2142 FxConfirmPopup (
2143   IN UINT32   Action
2144   )
2145 {
2146   EFI_INPUT_KEY                   Key;
2147   CHAR16                          *CfmStr;
2148   UINTN                           CfmStrLen;
2149   UINT32                          CheckFlags;
2150   BOOLEAN                         RetVal;
2151   UINTN                           CatLen;
2152
2153   CfmStrLen = 0;
2154   CatLen    = StrLen (gConfirmMsgConnect);
2155
2156   //
2157   // Below action need extra popup dialog to confirm.
2158   //
2159   CheckFlags = BROWSER_ACTION_DISCARD |
2160                BROWSER_ACTION_DEFAULT |
2161                BROWSER_ACTION_SUBMIT |
2162                BROWSER_ACTION_RESET |
2163                BROWSER_ACTION_EXIT;
2164
2165   //
2166   // Not need to confirm with user, just return TRUE.
2167   //
2168   if ((Action & CheckFlags) == 0) {
2169     return TRUE;
2170   }
2171
2172   if ((Action & BROWSER_ACTION_DISCARD) == BROWSER_ACTION_DISCARD) {
2173     CfmStrLen += StrLen (gConfirmDiscardMsg);
2174   }
2175
2176   if ((Action & BROWSER_ACTION_DEFAULT) == BROWSER_ACTION_DEFAULT) {
2177     if (CfmStrLen != 0) {
2178       CfmStrLen += CatLen;
2179     }
2180
2181     CfmStrLen += StrLen (gConfirmDefaultMsg);
2182   }
2183
2184   if ((Action & BROWSER_ACTION_SUBMIT)  == BROWSER_ACTION_SUBMIT) {
2185     if (CfmStrLen != 0) {
2186       CfmStrLen += CatLen;
2187     }
2188
2189     CfmStrLen += StrLen (gConfirmSubmitMsg);
2190   }
2191
2192   if ((Action & BROWSER_ACTION_RESET)  == BROWSER_ACTION_RESET) {
2193     if (CfmStrLen != 0) {
2194       CfmStrLen += CatLen;
2195     }
2196
2197     CfmStrLen += StrLen (gConfirmResetMsg);
2198   }
2199
2200   if ((Action & BROWSER_ACTION_EXIT)  == BROWSER_ACTION_EXIT) {
2201     if (CfmStrLen != 0) {
2202       CfmStrLen += CatLen;
2203     }
2204
2205     CfmStrLen += StrLen (gConfirmExitMsg);
2206   }
2207
2208   //
2209   // Allocate buffer to save the string.
2210   // String + "?" + "\0"
2211   //
2212   CfmStr = AllocateZeroPool ((CfmStrLen + 1 + 1) * sizeof (CHAR16));
2213   ASSERT (CfmStr != NULL);
2214
2215   if ((Action & BROWSER_ACTION_DISCARD) == BROWSER_ACTION_DISCARD) {
2216     StrCpy (CfmStr, gConfirmDiscardMsg);
2217   }
2218
2219   if ((Action & BROWSER_ACTION_DEFAULT) == BROWSER_ACTION_DEFAULT) {
2220     if (CfmStr[0] != 0) {
2221       StrCat (CfmStr, gConfirmMsgConnect);
2222       StrCat (CfmStr, gConfirmDefaultMsg2nd);
2223     } else {
2224       StrCpy (CfmStr, gConfirmDefaultMsg);
2225     }
2226   }
2227
2228   if ((Action & BROWSER_ACTION_SUBMIT)  == BROWSER_ACTION_SUBMIT) {
2229     if (CfmStr[0] != 0) {
2230       StrCat (CfmStr, gConfirmMsgConnect);
2231       StrCat (CfmStr, gConfirmSubmitMsg2nd);
2232     } else {
2233       StrCpy (CfmStr, gConfirmSubmitMsg);
2234     }
2235   }
2236
2237   if ((Action & BROWSER_ACTION_RESET)  == BROWSER_ACTION_RESET) {
2238     if (CfmStr[0] != 0) {
2239       StrCat (CfmStr, gConfirmMsgConnect);
2240       StrCat (CfmStr, gConfirmResetMsg2nd);
2241     } else {
2242       StrCpy (CfmStr, gConfirmResetMsg);
2243     }
2244   }
2245
2246   if ((Action & BROWSER_ACTION_EXIT)  == BROWSER_ACTION_EXIT) {
2247     if (CfmStr[0] != 0) {
2248       StrCat (CfmStr, gConfirmMsgConnect);
2249       StrCat (CfmStr, gConfirmExitMsg2nd);
2250     } else {
2251       StrCpy (CfmStr, gConfirmExitMsg);
2252     }
2253   }
2254
2255   StrCat (CfmStr, gConfirmMsgEnd);
2256
2257   do {
2258     CreateDialog (&Key, gEmptyString, CfmStr, gConfirmOpt, gEmptyString, NULL);
2259   } while (((Key.UnicodeChar | UPPER_LOWER_CASE_OFFSET) != (gConfirmOptYes[0] | UPPER_LOWER_CASE_OFFSET)) &&
2260            ((Key.UnicodeChar | UPPER_LOWER_CASE_OFFSET) != (gConfirmOptNo[0] | UPPER_LOWER_CASE_OFFSET)));
2261
2262   if ((Key.UnicodeChar | UPPER_LOWER_CASE_OFFSET) == (gConfirmOptYes[0] | UPPER_LOWER_CASE_OFFSET)) {
2263     RetVal = TRUE;
2264   } else {
2265     RetVal = FALSE;
2266   }
2267
2268   FreePool (CfmStr);
2269
2270   return RetVal;
2271 }
2272
2273 /**
2274   Print string for this menu option.
2275
2276   @param  MenuOption               The menu opton which this attribut used to.
2277   @param  SkipWidth                The skip width between the left to the start of the prompt.
2278   @param  BeginCol                 The begin column for one menu.
2279   @param  SkipLine                 The skip line for this menu.
2280   @param  BottomRow                The bottom row for this form.
2281   @param  Highlight                Whether this menu will be highlight.
2282   @param  UpdateCol                Whether need to update the column info for Date/Time.
2283
2284   @retval EFI_SUCESSS              Process the user selection success.
2285
2286 **/
2287 EFI_STATUS
2288 DisplayOneMenu (
2289   IN UI_MENU_OPTION                  *MenuOption,
2290   IN UINTN                           SkipWidth,
2291   IN UINTN                           BeginCol,
2292   IN UINTN                           SkipLine,
2293   IN UINTN                           BottomRow,
2294   IN BOOLEAN                         Highlight,
2295   IN BOOLEAN                         UpdateCol
2296   )
2297 {
2298   FORM_DISPLAY_ENGINE_STATEMENT   *Statement;
2299   UINTN                           Index;
2300   UINT16                          Width;
2301   UINT16                          PromptWidth;
2302   CHAR16                          *StringPtr;
2303   CHAR16                          *OptionString;
2304   CHAR16                          *OutputString;
2305   UINT16                          GlyphWidth;
2306   UINTN                           Temp;
2307   UINTN                           Temp2;
2308   UINTN                           Temp3;
2309   EFI_STATUS                      Status;
2310   UINTN                           Row;
2311   BOOLEAN                         IsProcessingFirstRow;
2312   UINTN                           Col;
2313   UINTN                           PromptLineNum;
2314   UINTN                           OptionLineNum;
2315   CHAR16                          AdjustValue;
2316   UINTN                           MaxRow;
2317
2318   Statement = MenuOption->ThisTag;
2319   Temp      = SkipLine;
2320   Temp2     = SkipLine;
2321   Temp3     = SkipLine;
2322   AdjustValue   = 0;
2323   PromptLineNum = 0;
2324   OptionLineNum = 0;
2325   MaxRow        = 0;
2326   IsProcessingFirstRow = TRUE;
2327
2328   //
2329   // Set default color.
2330   //
2331   SetDisplayAttribute (MenuOption, FALSE);
2332
2333   //
2334   // 1. Paint the option string.
2335   //
2336   Status = ProcessOptions (MenuOption, FALSE, &OptionString, FALSE);
2337   if (EFI_ERROR (Status)) {
2338     return Status;
2339   }
2340
2341   if (OptionString != NULL) {
2342     if (Statement->OpCode->OpCode == EFI_IFR_DATE_OP || Statement->OpCode->OpCode == EFI_IFR_TIME_OP) {
2343       //
2344       // Adjust option string for date/time opcode.
2345       //
2346       ProcessStringForDateTime(MenuOption, OptionString, UpdateCol);
2347     }
2348
2349     Width       = (UINT16) gOptionBlockWidth - 1;
2350     Row         = MenuOption->Row;
2351     GlyphWidth  = 1;
2352     OptionLineNum = 0;
2353
2354     for (Index = 0; GetLineByWidth (OptionString, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {
2355       if (((Temp2 == 0)) && (Row <= BottomRow)) {
2356         if (Statement->OpCode->OpCode == EFI_IFR_DATE_OP || Statement->OpCode->OpCode == EFI_IFR_TIME_OP) {
2357           //
2358           // For date/time question, it has three menu options for this qustion.
2359           // The first/second menu options with the skip value is 0. the last one
2360           // with skip value is 1.
2361           //
2362           if (MenuOption->Skip != 0) {
2363             //
2364             // For date/ time, print the last past (year for date and second for time)
2365             // - 7 means skip [##/##/ for date and [##:##: for time.
2366             //
2367             DisplayMenuString (MenuOption,MenuOption->OptCol, Row, OutputString, Width + 1 - 7, Highlight);
2368           } else {
2369             //
2370             // For date/ time, print the first and second past (year for date and second for time)
2371             // The OutputString has a NARROW_CHAR or WIDE_CHAR at the begin of the string,
2372             // so need to - 1 to remove it, otherwise, it will clean 1 extr char follow it.
2373             DisplayMenuString (MenuOption, MenuOption->OptCol, Row, OutputString, StrLen (OutputString) - 1, Highlight);
2374           }
2375         } else {
2376           DisplayMenuString (MenuOption, MenuOption->OptCol, Row, OutputString, Width + 1, Highlight);
2377         }
2378         OptionLineNum++;
2379       }
2380
2381       //
2382       // If there is more string to process print on the next row and increment the Skip value
2383       //
2384       if (StrLen (&OptionString[Index]) != 0) {
2385         if (Temp2 == 0) {
2386           Row++;
2387           //
2388           // Since the Number of lines for this menu entry may or may not be reflected accurately
2389           // since the prompt might be 1 lines and option might be many, and vice versa, we need to do
2390           // some testing to ensure we are keeping this in-sync.
2391           //
2392           // If the difference in rows is greater than or equal to the skip value, increase the skip value
2393           //
2394           if ((Row - MenuOption->Row) >= MenuOption->Skip) {
2395             MenuOption->Skip++;
2396           }
2397         }
2398       }
2399
2400       FreePool (OutputString);
2401       if (Temp2 != 0) {
2402         Temp2--;
2403       }
2404     }
2405
2406     Highlight = FALSE;
2407
2408     FreePool (OptionString);
2409   }
2410
2411   //
2412   // 2. Paint the description.
2413   //
2414   PromptWidth   = GetWidth (MenuOption, &AdjustValue);
2415   Row           = MenuOption->Row;
2416   GlyphWidth    = 1;
2417   PromptLineNum = 0;
2418
2419   if (MenuOption->Description == NULL || MenuOption->Description[0] == '\0') {
2420     PrintStringAtWithWidth (BeginCol, Row, L"", PromptWidth + AdjustValue + SkipWidth);
2421     PromptLineNum++;
2422   } else {
2423     for (Index = 0; GetLineByWidth (MenuOption->Description, PromptWidth, &GlyphWidth, &Index, &OutputString) != 0x0000;) {
2424       if ((Temp == 0) && (Row <= BottomRow)) {
2425         //
2426         // 1.Clean the start LEFT_SKIPPED_COLUMNS
2427         //
2428         PrintStringAtWithWidth (BeginCol, Row, L"", SkipWidth);
2429
2430         if (Statement->OpCode->OpCode == EFI_IFR_REF_OP && MenuOption->Col >= 2 && IsProcessingFirstRow) {
2431           //
2432           // Print Arrow for Goto button.
2433           //
2434           PrintCharAt (
2435             MenuOption->Col - 2,
2436             Row,
2437             GEOMETRICSHAPE_RIGHT_TRIANGLE
2438             );
2439           IsProcessingFirstRow = FALSE;
2440         }
2441         DisplayMenuString (MenuOption, MenuOption->Col, Row, OutputString, PromptWidth + AdjustValue, Highlight);
2442         PromptLineNum ++;
2443       }
2444       //
2445       // If there is more string to process print on the next row and increment the Skip value
2446       //
2447       if (StrLen (&MenuOption->Description[Index]) != 0) {
2448         if (Temp == 0) {
2449           Row++;
2450         }
2451       }
2452
2453       FreePool (OutputString);
2454       if (Temp != 0) {
2455         Temp--;
2456       }
2457     }
2458
2459     Highlight = FALSE;
2460   }
2461
2462
2463   //
2464   // 3. If this is a text op with secondary text information
2465   //
2466   if ((Statement->OpCode->OpCode  == EFI_IFR_TEXT_OP) && (((EFI_IFR_TEXT*)Statement->OpCode)->TextTwo != 0)) {
2467     StringPtr   = GetToken (((EFI_IFR_TEXT*)Statement->OpCode)->TextTwo, gFormData->HiiHandle);
2468
2469     Width       = (UINT16) gOptionBlockWidth - 1;
2470     Row         = MenuOption->Row;
2471     GlyphWidth  = 1;
2472     OptionLineNum = 0;
2473
2474     for (Index = 0; GetLineByWidth (StringPtr, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {
2475       if ((Temp3 == 0) && (Row <= BottomRow)) {
2476         DisplayMenuString (MenuOption, MenuOption->OptCol, Row, OutputString, Width + 1, Highlight);
2477         OptionLineNum++;
2478       }
2479       //
2480       // If there is more string to process print on the next row and increment the Skip value
2481       //
2482       if (StrLen (&StringPtr[Index]) != 0) {
2483         if (Temp3 == 0) {
2484           Row++;
2485           //
2486           // If the rows for text two is greater than or equal to the skip value, increase the skip value
2487           //
2488           if ((Row - MenuOption->Row) >= MenuOption->Skip) {
2489             MenuOption->Skip++;
2490           }
2491         }
2492       }
2493
2494       FreePool (OutputString);
2495       if (Temp3 != 0) {
2496         Temp3--;
2497       }
2498     }
2499
2500     FreePool (StringPtr);
2501   }
2502
2503   //
2504   // 4.Line number for Option string and prompt string are not equal.
2505   //  Clean the column whose line number is less.
2506   //
2507   if (HasOptionString(MenuOption) && (OptionLineNum != PromptLineNum)) {
2508     Col    =  OptionLineNum < PromptLineNum ? MenuOption->OptCol : BeginCol;
2509     Row    = (OptionLineNum < PromptLineNum ? OptionLineNum : PromptLineNum) + MenuOption->Row;
2510     Width  = (UINT16) (OptionLineNum < PromptLineNum ? gOptionBlockWidth : PromptWidth + AdjustValue + SkipWidth);
2511     MaxRow = (OptionLineNum < PromptLineNum ? PromptLineNum : OptionLineNum) + MenuOption->Row - 1;
2512
2513     while (Row <= MaxRow) {
2514       DisplayMenuString (MenuOption, Col, Row++, L"", Width, FALSE);
2515     }
2516   }
2517
2518   return EFI_SUCCESS;
2519 }
2520
2521 /**
2522   Display menu and wait for user to select one menu option, then return it.
2523   If AutoBoot is enabled, then if user doesn't select any option,
2524   after period of time, it will automatically return the first menu option.
2525
2526   @param  FormData               The current form data info.
2527
2528   @retval EFI_SUCESSS            Process the user selection success.
2529   @retval EFI_NOT_FOUND          Process option string for orderedlist/Oneof fail.
2530
2531 **/
2532 EFI_STATUS
2533 UiDisplayMenu (
2534   IN  FORM_DISPLAY_ENGINE_FORM  *FormData
2535   )
2536 {
2537   UINTN                           SkipValue;
2538   INTN                            Difference;
2539   UINTN                           DistanceValue;
2540   UINTN                           Row;
2541   UINTN                           Col;
2542   UINTN                           Temp;
2543   UINTN                           Temp2;
2544   UINTN                           TopRow;
2545   UINTN                           BottomRow;
2546   UINTN                           Index;
2547   CHAR16                          *StringPtr;
2548   CHAR16                          *OptionString;
2549   CHAR16                          *HelpString;
2550   CHAR16                          *HelpHeaderString;
2551   CHAR16                          *HelpBottomString;
2552   BOOLEAN                         NewLine;
2553   BOOLEAN                         Repaint;
2554   BOOLEAN                         UpArrow;
2555   BOOLEAN                         DownArrow;
2556   EFI_STATUS                      Status;
2557   EFI_INPUT_KEY                   Key;
2558   LIST_ENTRY                      *Link;
2559   LIST_ENTRY                      *NewPos;
2560   LIST_ENTRY                      *TopOfScreen;
2561   LIST_ENTRY                      *SavedListEntry;
2562   UI_MENU_OPTION                  *MenuOption;
2563   UI_MENU_OPTION                  *NextMenuOption;
2564   UI_MENU_OPTION                  *SavedMenuOption;
2565   UI_CONTROL_FLAG                 ControlFlag;
2566   UI_SCREEN_OPERATION             ScreenOperation;
2567   FORM_DISPLAY_ENGINE_STATEMENT   *Statement;
2568   BROWSER_HOT_KEY                 *HotKey;
2569   UINTN                           HelpPageIndex;
2570   UINTN                           HelpPageCount;
2571   UINTN                           RowCount;
2572   UINTN                           HelpLine;
2573   UINTN                           HelpHeaderLine;
2574   UINTN                           HelpBottomLine;
2575   BOOLEAN                         MultiHelpPage;
2576   UINT16                          EachLineWidth;
2577   UINT16                          HeaderLineWidth;
2578   UINT16                          BottomLineWidth;
2579   EFI_STRING_ID                   HelpInfo;
2580   UI_EVENT_TYPE                   EventType;
2581   BOOLEAN                         SkipHighLight;
2582
2583   EventType           = UIEventNone;
2584   Status              = EFI_SUCCESS;
2585   HelpString          = NULL;
2586   HelpHeaderString    = NULL;
2587   HelpBottomString    = NULL;
2588   OptionString        = NULL;
2589   ScreenOperation     = UiNoOperation;
2590   NewLine             = TRUE;
2591   HelpPageCount       = 0;
2592   HelpLine            = 0;
2593   RowCount            = 0;
2594   HelpBottomLine      = 0;
2595   HelpHeaderLine      = 0;
2596   HelpPageIndex       = 0;
2597   MultiHelpPage       = FALSE;
2598   EachLineWidth       = 0;
2599   HeaderLineWidth     = 0;
2600   BottomLineWidth     = 0;
2601   UpArrow             = FALSE;
2602   DownArrow           = FALSE;
2603   SkipValue           = 0;
2604   SkipHighLight       = FALSE;
2605
2606   NextMenuOption      = NULL;
2607   SavedMenuOption     = NULL;
2608   HotKey              = NULL;
2609   Repaint             = TRUE;
2610   MenuOption          = NULL;
2611   gModalSkipColumn    = (CHAR16) (gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn) / 6;
2612
2613   ZeroMem (&Key, sizeof (EFI_INPUT_KEY));
2614
2615   TopRow    = gStatementDimensions.TopRow    + SCROLL_ARROW_HEIGHT;
2616   BottomRow = gStatementDimensions.BottomRow - SCROLL_ARROW_HEIGHT - 1;
2617
2618   Row = TopRow;
2619   if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2620     Col = gStatementDimensions.LeftColumn + LEFT_SKIPPED_COLUMNS + gModalSkipColumn;
2621   } else {
2622     Col = gStatementDimensions.LeftColumn + LEFT_SKIPPED_COLUMNS;
2623   }
2624
2625   FindTopMenu(FormData, &TopOfScreen, &NewPos, &SkipValue);
2626   if (!IsListEmpty (&gMenuOption)) {
2627     NextMenuOption = MENU_OPTION_FROM_LINK (NewPos);
2628     gUserInput->SelectedStatement = NextMenuOption->ThisTag;
2629   }
2630
2631   gST->ConOut->EnableCursor (gST->ConOut, FALSE);
2632
2633   ControlFlag = CfInitialization;
2634   while (TRUE) {
2635     switch (ControlFlag) {
2636     case CfInitialization:
2637       if ((gOldFormEntry.HiiHandle != FormData->HiiHandle) ||
2638           (!CompareGuid (&gOldFormEntry.FormSetGuid, &FormData->FormSetGuid))) {
2639         //
2640         // Clear Statement range if different formset is painted.
2641         //
2642         ClearLines (
2643           gStatementDimensions.LeftColumn,
2644           gStatementDimensions.RightColumn,
2645           TopRow - SCROLL_ARROW_HEIGHT,
2646           BottomRow + SCROLL_ARROW_HEIGHT,
2647           GetFieldTextColor ()
2648           );
2649
2650       }
2651       ControlFlag = CfRepaint;
2652       break;
2653
2654     case CfRepaint:
2655       ControlFlag = CfRefreshHighLight;
2656
2657       if (Repaint) {
2658         //
2659         // Display menu
2660         //
2661         DownArrow       = FALSE;
2662         UpArrow         = FALSE;
2663         Row             = TopRow;
2664
2665         gST->ConOut->SetAttribute (gST->ConOut, GetFieldTextColor ());
2666
2667         //
2668         // 1. Check whether need to print the arrow up.
2669         //
2670         if (!ValueIsScroll (TRUE, TopOfScreen)) {
2671           UpArrow = TRUE;
2672         }
2673
2674         if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2675           PrintStringAtWithWidth(gStatementDimensions.LeftColumn + gModalSkipColumn, TopRow - 1, L"", gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn - 2 * gModalSkipColumn);
2676         } else {
2677           PrintStringAtWithWidth(gStatementDimensions.LeftColumn, TopRow - 1, L"", gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn);
2678         }
2679         if (UpArrow) {
2680           gST->ConOut->SetAttribute (gST->ConOut, GetArrowColor ());
2681           PrintCharAt (
2682             gStatementDimensions.LeftColumn + gPromptBlockWidth + gOptionBlockWidth + 1,
2683             TopRow - SCROLL_ARROW_HEIGHT,
2684             ARROW_UP
2685             );
2686           gST->ConOut->SetAttribute (gST->ConOut, GetFieldTextColor ());
2687         }
2688
2689         //
2690         // 2.Paint the menu.
2691         //
2692         for (Link = TopOfScreen; Link != &gMenuOption; Link = Link->ForwardLink) {
2693           MenuOption          = MENU_OPTION_FROM_LINK (Link);
2694           MenuOption->Row     = Row;
2695           MenuOption->Col     = Col;
2696           if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2697             MenuOption->OptCol  = gStatementDimensions.LeftColumn + LEFT_SKIPPED_COLUMNS + gPromptBlockWidth + gModalSkipColumn;
2698           } else {
2699             MenuOption->OptCol  = gStatementDimensions.LeftColumn + LEFT_SKIPPED_COLUMNS + gPromptBlockWidth;
2700           }
2701
2702           if (MenuOption->NestInStatement) {
2703             MenuOption->Col += SUBTITLE_INDENT;
2704           }
2705
2706           //
2707           // Save the highlight menu, will be used in CfRefreshHighLight case.
2708           //
2709           if (Link == NewPos) {
2710             SavedMenuOption = MenuOption;
2711             SkipHighLight   = TRUE;
2712           }
2713
2714           if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2715             Status = DisplayOneMenu (MenuOption,
2716                             MenuOption->Col - gStatementDimensions.LeftColumn,
2717                             gStatementDimensions.LeftColumn + gModalSkipColumn,
2718                             Link == TopOfScreen ? SkipValue : 0,
2719                             BottomRow,
2720                             (BOOLEAN) ((Link == NewPos) && IsSelectable(MenuOption)),
2721                             TRUE
2722                             );
2723           } else {
2724             Status = DisplayOneMenu (MenuOption,
2725                             MenuOption->Col - gStatementDimensions.LeftColumn,
2726                             gStatementDimensions.LeftColumn,
2727                             Link == TopOfScreen ? SkipValue : 0,
2728                             BottomRow,
2729                             (BOOLEAN) ((Link == NewPos) && IsSelectable(MenuOption)),
2730                             TRUE
2731                             );
2732           }
2733
2734           if (EFI_ERROR (Status)) {
2735             if (gMisMatch) {
2736               return EFI_SUCCESS;
2737             } else {
2738               return Status;
2739             }
2740           }
2741           //
2742           // 3. Update the row info which will be used by next menu.
2743           //
2744           if (Link == TopOfScreen) {
2745             Row += MenuOption->Skip - SkipValue;
2746           } else {
2747             Row += MenuOption->Skip;
2748           }
2749
2750           if (Row > BottomRow) {
2751             if (!ValueIsScroll (FALSE, Link)) {
2752               DownArrow = TRUE;
2753             }
2754
2755             Row = BottomRow + 1;
2756             break;
2757           }
2758         }
2759
2760         //
2761         // 3. Menus in this form may not cover all form, clean the remain field.
2762         //
2763         while (Row <= BottomRow) {
2764           if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2765             PrintStringAtWithWidth(gStatementDimensions.LeftColumn + gModalSkipColumn, Row++, L"", gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn - 2 * gModalSkipColumn);
2766           } else {
2767             PrintStringAtWithWidth(gStatementDimensions.LeftColumn, Row++, L"", gStatementDimensions.RightColumn - gHelpBlockWidth - gStatementDimensions.LeftColumn);
2768           }
2769         }
2770
2771         //
2772         // 4. Print the down arrow row.
2773         //
2774         if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2775           PrintStringAtWithWidth(gStatementDimensions.LeftColumn + gModalSkipColumn, BottomRow + 1, L"", gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn - 2 *  + gModalSkipColumn);
2776         } else {
2777           PrintStringAtWithWidth(gStatementDimensions.LeftColumn, BottomRow + 1, L"", gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn);
2778         }
2779         if (DownArrow) {
2780           gST->ConOut->SetAttribute (gST->ConOut, GetArrowColor ());
2781           PrintCharAt (
2782             gStatementDimensions.LeftColumn + gPromptBlockWidth + gOptionBlockWidth + 1,
2783             BottomRow + SCROLL_ARROW_HEIGHT,
2784             ARROW_DOWN
2785             );
2786           gST->ConOut->SetAttribute (gST->ConOut, GetFieldTextColor ());
2787         }
2788
2789         MenuOption = NULL;
2790       }
2791       break;
2792
2793     case CfRefreshHighLight:
2794
2795       //
2796       // MenuOption: Last menu option that need to remove hilight
2797       //             MenuOption is set to NULL in Repaint
2798       // NewPos:     Current menu option that need to hilight
2799       //
2800       ControlFlag = CfUpdateHelpString;
2801
2802       UpdateHighlightMenuInfo(NewPos, TopOfScreen, SkipValue);
2803
2804       if (SkipHighLight) {
2805         SkipHighLight = FALSE;
2806         MenuOption    = SavedMenuOption;
2807         RefreshKeyHelp(gFormData, SavedMenuOption->ThisTag, FALSE);
2808         break;
2809       }
2810
2811       if (IsListEmpty (&gMenuOption)) {
2812         //
2813         // No menu option, just update the hotkey filed.
2814         //
2815         RefreshKeyHelp(gFormData, NULL, FALSE);
2816         break;
2817       }
2818
2819       if (MenuOption != NULL && TopOfScreen == &MenuOption->Link) {
2820         Temp = SkipValue;
2821       } else {
2822         Temp = 0;
2823       }
2824       if (NewPos == TopOfScreen) {
2825         Temp2 = SkipValue;
2826       } else {
2827         Temp2 = 0;
2828       }
2829
2830       if (NewPos != NULL && (MenuOption == NULL || NewPos != &MenuOption->Link)) {
2831         if (MenuOption != NULL) {
2832           //
2833           // Remove the old highlight menu.
2834           //
2835           Status = DisplayOneMenu (MenuOption,
2836                           MenuOption->Col - gStatementDimensions.LeftColumn,
2837                           gStatementDimensions.LeftColumn,
2838                           Temp,
2839                           BottomRow,
2840                           FALSE,
2841                           FALSE
2842                           );
2843         }
2844
2845         //
2846         // This is the current selected statement
2847         //
2848         MenuOption = MENU_OPTION_FROM_LINK (NewPos);
2849         RefreshKeyHelp(gFormData, MenuOption->ThisTag, FALSE);
2850
2851         if (!IsSelectable (MenuOption)) {
2852           break;
2853         }
2854
2855         Status = DisplayOneMenu (MenuOption,
2856                         MenuOption->Col - gStatementDimensions.LeftColumn,
2857                         gStatementDimensions.LeftColumn,
2858                         Temp2,
2859                         BottomRow,
2860                         TRUE,
2861                         FALSE
2862                         );
2863       }
2864       break;
2865
2866     case CfUpdateHelpString:
2867       ControlFlag = CfPrepareToReadKey;
2868       if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2869         break;
2870       }
2871
2872       //
2873       // NewLine means only update highlight menu (remove old highlight and highlith
2874       // the new one), not need to full repain the form.
2875       //
2876       if (Repaint || NewLine) {
2877         if (IsListEmpty (&gMenuOption)) {
2878           //
2879           // Don't print anything if no mwnu option.
2880           //
2881           StringPtr = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
2882         } else {
2883           //
2884           // Don't print anything if it is a NULL help token
2885           //
2886           ASSERT(MenuOption != NULL);
2887           HelpInfo = ((EFI_IFR_STATEMENT_HEADER *) ((CHAR8 *)MenuOption->ThisTag->OpCode + sizeof (EFI_IFR_OP_HEADER)))->Help;
2888           if (HelpInfo == 0 || !IsSelectable (MenuOption)) {
2889             StringPtr = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
2890           } else {
2891             StringPtr = GetToken (HelpInfo, gFormData->HiiHandle);
2892           }
2893         }
2894
2895         RowCount      = BottomRow - TopRow + 1;
2896         HelpPageIndex = 0;
2897         //
2898         // 1.Calculate how many line the help string need to print.
2899         //
2900         if (HelpString != NULL) {
2901           FreePool (HelpString);
2902           HelpString = NULL;
2903         }
2904         HelpLine = ProcessHelpString (StringPtr, &HelpString, &EachLineWidth, RowCount);
2905         FreePool (StringPtr);
2906
2907         if (HelpLine > RowCount) {
2908           MultiHelpPage   = TRUE;
2909           StringPtr       = GetToken (STRING_TOKEN(ADJUST_HELP_PAGE_UP), gHiiHandle);
2910           if (HelpHeaderString != NULL) {
2911             FreePool (HelpHeaderString);
2912             HelpHeaderString = NULL;
2913           }
2914           HelpHeaderLine  = ProcessHelpString (StringPtr, &HelpHeaderString, &HeaderLineWidth, 0);
2915           FreePool (StringPtr);
2916           StringPtr       = GetToken (STRING_TOKEN(ADJUST_HELP_PAGE_DOWN), gHiiHandle);
2917           if (HelpBottomString != NULL) {
2918             FreePool (HelpBottomString);
2919             HelpBottomString = NULL;
2920           }
2921           HelpBottomLine  = ProcessHelpString (StringPtr, &HelpBottomString, &BottomLineWidth, 0);
2922           FreePool (StringPtr);
2923           //
2924           // Calculate the help page count.
2925           //
2926           if (HelpLine > 2 * RowCount - 2) {
2927             HelpPageCount = (HelpLine - RowCount + 1) / (RowCount - 2) + 1;
2928             if ((HelpLine - RowCount + 1) % (RowCount - 2) > 1) {
2929               HelpPageCount += 1;
2930             }
2931           } else {
2932             HelpPageCount = 2;
2933           }
2934         } else {
2935           MultiHelpPage = FALSE;
2936         }
2937       }
2938
2939       //
2940       // Check whether need to show the 'More(U/u)' at the begin.
2941       // Base on current direct info, here shows aligned to the right side of the column.
2942       // If the direction is multi line and aligned to right side may have problem, so
2943       // add ASSERT code here.
2944       //
2945       if (HelpPageIndex > 0) {
2946         gST->ConOut->SetAttribute (gST->ConOut, GetInfoTextColor ());
2947         for (Index = 0; Index < HelpHeaderLine; Index++) {
2948           ASSERT (HelpHeaderLine == 1);
2949           ASSERT (GetStringWidth (HelpHeaderString) / 2 < (UINTN) (gHelpBlockWidth - 1));
2950           PrintStringAtWithWidth (
2951             gStatementDimensions.RightColumn - gHelpBlockWidth,
2952             Index + TopRow,
2953             gEmptyString,
2954             gHelpBlockWidth
2955             );
2956           PrintStringAt (
2957             gStatementDimensions.RightColumn - GetStringWidth (HelpHeaderString) / 2 - 1,
2958             Index + TopRow,
2959             &HelpHeaderString[Index * HeaderLineWidth]
2960             );
2961         }
2962       }
2963
2964       gST->ConOut->SetAttribute (gST->ConOut, GetHelpTextColor ());
2965       //
2966       // Print the help string info.
2967       //
2968       if (!MultiHelpPage) {
2969         for (Index = 0; Index < HelpLine; Index++) {
2970           PrintStringAtWithWidth (
2971             gStatementDimensions.RightColumn - gHelpBlockWidth,
2972             Index + TopRow,
2973             &HelpString[Index * EachLineWidth],
2974             gHelpBlockWidth
2975             );
2976         }
2977         for (; Index < RowCount; Index ++) {
2978           PrintStringAtWithWidth (
2979             gStatementDimensions.RightColumn - gHelpBlockWidth,
2980             Index + TopRow,
2981             gEmptyString,
2982             gHelpBlockWidth
2983             );
2984         }
2985         gST->ConOut->SetCursorPosition(gST->ConOut, gStatementDimensions.RightColumn-1, BottomRow);
2986       } else  {
2987         if (HelpPageIndex == 0) {
2988           for (Index = 0; Index < RowCount - HelpBottomLine; Index++) {
2989             PrintStringAtWithWidth (
2990               gStatementDimensions.RightColumn - gHelpBlockWidth,
2991               Index + TopRow,
2992               &HelpString[Index * EachLineWidth],
2993               gHelpBlockWidth
2994               );
2995           }
2996         } else {
2997           for (Index = 0; (Index < RowCount - HelpBottomLine - HelpHeaderLine) &&
2998               (Index + HelpPageIndex * (RowCount - 2) + 1 < HelpLine); Index++) {
2999             PrintStringAtWithWidth (
3000               gStatementDimensions.RightColumn - gHelpBlockWidth,
3001               Index + TopRow + HelpHeaderLine,
3002               &HelpString[(Index + HelpPageIndex * (RowCount - 2) + 1)* EachLineWidth],
3003               gHelpBlockWidth
3004               );
3005           }
3006           if (HelpPageIndex == HelpPageCount - 1) {
3007             for (; Index < RowCount - HelpHeaderLine; Index ++) {
3008               PrintStringAtWithWidth (
3009                 gStatementDimensions.RightColumn - gHelpBlockWidth,
3010                 Index + TopRow + HelpHeaderLine,
3011                 gEmptyString,
3012                 gHelpBlockWidth
3013                 );
3014             }
3015             gST->ConOut->SetCursorPosition(gST->ConOut, gStatementDimensions.RightColumn-1, BottomRow);
3016           }
3017         }
3018       }
3019
3020       //
3021       // Check whether need to print the 'More(D/d)' at the bottom.
3022       // Base on current direct info, here shows aligned to the right side of the column.
3023       // If the direction is multi line and aligned to right side may have problem, so
3024       // add ASSERT code here.
3025       //
3026       if (HelpPageIndex < HelpPageCount - 1 && MultiHelpPage) {
3027         gST->ConOut->SetAttribute (gST->ConOut, GetInfoTextColor ());
3028         for (Index = 0; Index < HelpBottomLine; Index++) {
3029           ASSERT (HelpBottomLine == 1);
3030           ASSERT (GetStringWidth (HelpBottomString) / 2 < (UINTN) (gHelpBlockWidth - 1));
3031           PrintStringAtWithWidth (
3032             gStatementDimensions.RightColumn - gHelpBlockWidth,
3033             BottomRow + Index - HelpBottomLine + 1,
3034             gEmptyString,
3035             gHelpBlockWidth
3036             );
3037           PrintStringAt (
3038             gStatementDimensions.RightColumn - GetStringWidth (HelpBottomString) / 2 - 1,
3039             BottomRow + Index - HelpBottomLine + 1,
3040             &HelpBottomString[Index * BottomLineWidth]
3041             );
3042         }
3043       }
3044       //
3045       // Reset this flag every time we finish using it.
3046       //
3047       Repaint = FALSE;
3048       NewLine = FALSE;
3049       break;
3050
3051     case CfPrepareToReadKey:
3052       ControlFlag = CfReadKey;
3053       ScreenOperation = UiNoOperation;
3054       break;
3055
3056     case CfReadKey:
3057       ControlFlag = CfScreenOperation;
3058
3059       //
3060       // Wait for user's selection
3061       //
3062       while (TRUE) {
3063         Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
3064         if (!EFI_ERROR (Status)) {
3065           EventType = UIEventKey;
3066           break;
3067         }
3068
3069         //
3070         // If we encounter error, continue to read another key in.
3071         //
3072         if (Status != EFI_NOT_READY) {
3073           continue;
3074         }
3075
3076         EventType = UiWaitForEvent(gST->ConIn->WaitForKey);
3077         if (EventType == UIEventKey) {
3078           gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
3079         }
3080         break;
3081       }
3082
3083       if (EventType == UIEventDriver) {
3084         gMisMatch = TRUE;
3085         gUserInput->Action = BROWSER_ACTION_NONE;
3086         ControlFlag = CfExit;
3087         break;
3088       }
3089
3090       if (EventType == UIEventTimeOut) {
3091         gUserInput->Action = BROWSER_ACTION_FORM_EXIT;
3092         ControlFlag = CfExit;
3093         break;
3094       }
3095
3096       switch (Key.UnicodeChar) {
3097       case CHAR_CARRIAGE_RETURN:
3098         if(MenuOption == NULL || MenuOption->GrayOut || MenuOption->ReadOnly) {
3099           ControlFlag = CfReadKey;
3100           break;
3101         }
3102
3103         ScreenOperation = UiSelect;
3104         gDirection      = 0;
3105         break;
3106
3107       //
3108       // We will push the adjustment of these numeric values directly to the input handler
3109       //  NOTE: we won't handle manual input numeric
3110       //
3111       case '+':
3112       case '-':
3113         //
3114         // If the screen has no menu items, and the user didn't select UiReset
3115         // ignore the selection and go back to reading keys.
3116         //
3117         ASSERT(MenuOption != NULL);
3118         if(IsListEmpty (&gMenuOption) || MenuOption->GrayOut || MenuOption->ReadOnly) {
3119           ControlFlag = CfReadKey;
3120           break;
3121         }
3122
3123         Statement = MenuOption->ThisTag;
3124         if ((Statement->OpCode->OpCode == EFI_IFR_DATE_OP)
3125           || (Statement->OpCode->OpCode == EFI_IFR_TIME_OP)
3126           || ((Statement->OpCode->OpCode == EFI_IFR_NUMERIC_OP) && (GetFieldFromNum(Statement->OpCode) != 0))
3127         ){
3128           if (Key.UnicodeChar == '+') {
3129             gDirection = SCAN_RIGHT;
3130           } else {
3131             gDirection = SCAN_LEFT;
3132           }
3133
3134           Status = ProcessOptions (MenuOption, TRUE, &OptionString, TRUE);
3135           if (OptionString != NULL) {
3136             FreePool (OptionString);
3137           }
3138           if (EFI_ERROR (Status)) {
3139             //
3140             // Repaint to clear possible error prompt pop-up
3141             //
3142             Repaint = TRUE;
3143             NewLine = TRUE;
3144           } else {
3145             ControlFlag = CfExit;
3146           }
3147         }
3148         break;
3149
3150       case '^':
3151         ScreenOperation = UiUp;
3152         break;
3153
3154       case 'V':
3155       case 'v':
3156         ScreenOperation = UiDown;
3157         break;
3158
3159       case ' ':
3160         if(IsListEmpty (&gMenuOption)) {
3161           ControlFlag = CfReadKey;
3162           break;
3163         }
3164
3165         ASSERT(MenuOption != NULL);
3166         if (MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_CHECKBOX_OP && !MenuOption->GrayOut && !MenuOption->ReadOnly) {
3167           ScreenOperation = UiSelect;
3168         }
3169         break;
3170
3171       case 'D':
3172       case 'd':
3173         if (!MultiHelpPage) {
3174           ControlFlag = CfReadKey;
3175           break;
3176         }
3177         ControlFlag    = CfUpdateHelpString;
3178         HelpPageIndex  = HelpPageIndex < HelpPageCount - 1 ? HelpPageIndex + 1 : HelpPageCount - 1;
3179         break;
3180
3181       case 'U':
3182       case 'u':
3183         if (!MultiHelpPage) {
3184           ControlFlag = CfReadKey;
3185           break;
3186         }
3187         ControlFlag    = CfUpdateHelpString;
3188         HelpPageIndex  = HelpPageIndex > 0 ? HelpPageIndex - 1 : 0;
3189         break;
3190
3191       case CHAR_NULL:
3192         for (Index = 0; Index < mScanCodeNumber; Index++) {
3193           if (Key.ScanCode == gScanCodeToOperation[Index].ScanCode) {
3194             ScreenOperation = gScanCodeToOperation[Index].ScreenOperation;
3195             break;
3196           }
3197         }
3198
3199         if (((FormData->Attribute & HII_DISPLAY_MODAL) != 0) && (Key.ScanCode == SCAN_ESC || Index == mScanCodeNumber)) {
3200           //
3201           // ModalForm has no ESC key and Hot Key.
3202           //
3203           ControlFlag = CfReadKey;
3204         } else if (Index == mScanCodeNumber) {
3205           //
3206           // Check whether Key matches the registered hot key.
3207           //
3208           HotKey = NULL;
3209           HotKey = GetHotKeyFromRegisterList (&Key);
3210           if (HotKey != NULL) {
3211             ScreenOperation = UiHotKey;
3212           }
3213         }
3214         break;
3215       }
3216       break;
3217
3218     case CfScreenOperation:
3219       if ((ScreenOperation != UiReset) && (ScreenOperation != UiHotKey)) {
3220         //
3221         // If the screen has no menu items, and the user didn't select UiReset or UiHotKey
3222         // ignore the selection and go back to reading keys.
3223         //
3224         if (IsListEmpty (&gMenuOption)) {
3225           ControlFlag = CfReadKey;
3226           break;
3227         }
3228       }
3229
3230       for (Index = 0;
3231            Index < sizeof (gScreenOperationToControlFlag) / sizeof (gScreenOperationToControlFlag[0]);
3232            Index++
3233           ) {
3234         if (ScreenOperation == gScreenOperationToControlFlag[Index].ScreenOperation) {
3235           ControlFlag = gScreenOperationToControlFlag[Index].ControlFlag;
3236           break;
3237         }
3238       }
3239       break;
3240
3241     case CfUiSelect:
3242       ControlFlag = CfRepaint;
3243
3244       ASSERT(MenuOption != NULL);
3245       Statement = MenuOption->ThisTag;
3246       if (Statement->OpCode->OpCode == EFI_IFR_TEXT_OP) {
3247         break;
3248       }
3249
3250       switch (Statement->OpCode->OpCode) {
3251       case EFI_IFR_REF_OP:
3252       case EFI_IFR_ACTION_OP:
3253       case EFI_IFR_RESET_BUTTON_OP:
3254         ControlFlag = CfExit;
3255         break;
3256
3257       default:
3258         //
3259         // Editable Questions: oneof, ordered list, checkbox, numeric, string, password
3260         //
3261         RefreshKeyHelp (gFormData, Statement, TRUE);
3262         Status = ProcessOptions (MenuOption, TRUE, &OptionString, TRUE);
3263
3264         if (OptionString != NULL) {
3265           FreePool (OptionString);
3266         }
3267
3268         if (EFI_ERROR (Status)) {
3269           Repaint = TRUE;
3270           NewLine = TRUE;
3271           RefreshKeyHelp (gFormData, Statement, FALSE);
3272           break;
3273         } else {
3274           ControlFlag = CfExit;
3275           break;
3276         }
3277       }
3278       break;
3279
3280     case CfUiReset:
3281       //
3282       // We come here when someone press ESC
3283       // If the policy is not exit front page when user press ESC, process here.
3284       //
3285       if (!FormExitPolicy()) {
3286         Repaint     = TRUE;
3287         NewLine     = TRUE;
3288         ControlFlag = CfRepaint;
3289         break;
3290       }
3291
3292       gUserInput->Action = BROWSER_ACTION_FORM_EXIT;
3293       ControlFlag = CfExit;
3294       break;
3295
3296     case CfUiHotKey:
3297       ControlFlag = CfRepaint;
3298
3299       ASSERT (HotKey != NULL);
3300
3301       if (FxConfirmPopup(HotKey->Action)) {
3302         gUserInput->Action = HotKey->Action;
3303         if ((HotKey->Action & BROWSER_ACTION_DEFAULT) == BROWSER_ACTION_DEFAULT) {
3304           gUserInput->DefaultId = HotKey->DefaultId;
3305         }
3306         ControlFlag = CfExit;
3307       } else {
3308         Repaint     = TRUE;
3309         NewLine     = TRUE;
3310         ControlFlag = CfRepaint;
3311       }
3312
3313       break;
3314
3315     case CfUiLeft:
3316       ControlFlag = CfRepaint;
3317       ASSERT(MenuOption != NULL);
3318       if ((MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_DATE_OP) || (MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_TIME_OP)) {
3319         if (MenuOption->Sequence != 0) {
3320           //
3321           // In the middle or tail of the Date/Time op-code set, go left.
3322           //
3323           ASSERT(NewPos != NULL);
3324           NewPos = NewPos->BackLink;
3325         }
3326       }
3327       break;
3328
3329     case CfUiRight:
3330       ControlFlag = CfRepaint;
3331       ASSERT(MenuOption != NULL);
3332       if ((MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_DATE_OP) || (MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_TIME_OP)) {
3333         if (MenuOption->Sequence != 2) {
3334           //
3335           // In the middle or tail of the Date/Time op-code set, go left.
3336           //
3337           ASSERT(NewPos != NULL);
3338           NewPos = NewPos->ForwardLink;
3339         }
3340       }
3341       break;
3342
3343     case CfUiUp:
3344       ControlFlag = CfRepaint;
3345       NewLine     = TRUE;
3346
3347       SavedListEntry = NewPos;
3348       ASSERT(NewPos != NULL);
3349
3350       MenuOption = MENU_OPTION_FROM_LINK (NewPos);
3351       ASSERT (MenuOption != NULL);
3352
3353       //
3354       // Adjust Date/Time position before we advance forward.
3355       //
3356       AdjustDateAndTimePosition (TRUE, &NewPos);
3357
3358       NewPos     = NewPos->BackLink;
3359       //
3360       // Find next selectable menu or the first menu beyond current form.
3361       //
3362       Difference = MoveToNextStatement (TRUE, &NewPos, MenuOption->Row - TopRow, FALSE);
3363       if (Difference < 0) {
3364         //
3365         // We hit the begining MenuOption that can be focused
3366         // so we simply scroll to the top.
3367         //
3368         Repaint     = TRUE;
3369         if (TopOfScreen != gMenuOption.ForwardLink || SkipValue != 0) {
3370           TopOfScreen = gMenuOption.ForwardLink;
3371           NewPos      = SavedListEntry;
3372           SkipValue = 0;
3373         } else {
3374           //
3375           // Scroll up to the last page when we have arrived at top page.
3376           //
3377           TopOfScreen = FindTopOfScreenMenu (gMenuOption.BackLink, BottomRow - TopRow, &SkipValue);
3378           NewPos = gMenuOption.BackLink;
3379           MoveToNextStatement (TRUE, &NewPos, BottomRow - TopRow, TRUE);
3380         }
3381       } else {
3382         NextMenuOption = MENU_OPTION_FROM_LINK (NewPos);
3383
3384         if (MenuOption->Row < TopRow + Difference + NextMenuOption->Skip) {
3385           //
3386           // Previous focus MenuOption is above the TopOfScreen, so we need to scroll
3387           //
3388           TopOfScreen = NewPos;
3389           Repaint     = TRUE;
3390           SkipValue   = 0;
3391         }
3392
3393         //
3394         // Check whether new highlight menu is selectable, if not, keep highlight on the old one.
3395         //
3396         // BottomRow - TopRow + 1 means the total rows current forms supported.
3397         // Difference + NextMenuOption->Skip + 1 means the distance between last highlight menu
3398         // and new top menu. New top menu will all shows in next form, but last highlight menu
3399         // may only shows 1 line. + 1 at right part means at least need to keep 1 line for the
3400         // last highlight menu.
3401         //
3402         if (!IsSelectable(NextMenuOption) && IsSelectable(MenuOption) &&
3403             (BottomRow - TopRow + 1 >= Difference + NextMenuOption->Skip + 1)) {
3404           NewPos = SavedListEntry;
3405         }
3406       }
3407
3408       UpdateStatusBar (INPUT_ERROR, FALSE);
3409
3410       //
3411       // If we encounter a Date/Time op-code set, rewind to the first op-code of the set.
3412       //
3413       AdjustDateAndTimePosition (TRUE, &TopOfScreen);
3414       AdjustDateAndTimePosition (TRUE, &NewPos);
3415
3416       UpdateHighlightMenuInfo(NewPos, TopOfScreen, SkipValue);
3417       break;
3418
3419     case CfUiPageUp:
3420       //
3421       // SkipValue means lines is skipped when show the top menu option.
3422       //
3423       ControlFlag = CfRepaint;
3424       NewLine     = TRUE;
3425       Repaint     = TRUE;
3426
3427       Link      = TopOfScreen;
3428       //
3429       // First minus the menu of the top screen, it's value is SkipValue.
3430       //
3431       if (SkipValue >= BottomRow - TopRow + 1) {
3432         //
3433         // SkipValue > (BottomRow - TopRow + 1) means current menu has more than one
3434         // form of options to be show, so just update the SkipValue to show the next
3435         // parts of options.
3436         //
3437         SkipValue -= BottomRow - TopRow + 1;
3438         NewPos     = TopOfScreen;
3439         break;
3440       } else {
3441         Index     = (BottomRow + 1) - SkipValue - TopRow;
3442       }
3443
3444       TopOfScreen = FindTopOfScreenMenu(TopOfScreen, Index, &SkipValue);
3445       NewPos = TopOfScreen;
3446       MoveToNextStatement (FALSE, &NewPos, BottomRow - TopRow, FALSE);
3447
3448       UpdateStatusBar (INPUT_ERROR, FALSE);
3449
3450       //
3451       // If we encounter a Date/Time op-code set, rewind to the first op-code of the set.
3452       // Don't do this when we are already in the first page.
3453       //
3454       AdjustDateAndTimePosition (TRUE, &TopOfScreen);
3455       AdjustDateAndTimePosition (TRUE, &NewPos);
3456
3457       UpdateHighlightMenuInfo(NewPos, TopOfScreen, SkipValue);
3458       break;
3459
3460     case CfUiPageDown:
3461       //
3462       // SkipValue means lines is skipped when show the top menu option.
3463       //
3464       ControlFlag = CfRepaint;
3465       NewLine     = TRUE;
3466       Repaint     = TRUE;
3467
3468       Link    = TopOfScreen;
3469       NextMenuOption = MENU_OPTION_FROM_LINK (Link);
3470       Index = TopRow + NextMenuOption->Skip - SkipValue;
3471       //
3472       // Count to the menu option which will show at the top of the next form.
3473       //
3474       while ((Index <= BottomRow + 1) && (Link->ForwardLink != &gMenuOption)) {
3475         Link           = Link->ForwardLink;
3476         NextMenuOption = MENU_OPTION_FROM_LINK (Link);
3477         Index = Index + NextMenuOption->Skip;
3478       }
3479
3480       if ((Link->ForwardLink == &gMenuOption) && (Index <= BottomRow + 1)) {
3481         //
3482         // Highlight on the last menu which can be highlight.
3483         //
3484         Repaint = FALSE;
3485         MoveToNextStatement (TRUE, &Link, Index - TopRow, TRUE);
3486       } else {
3487         //
3488         // Calculate the skip line for top of screen menu.
3489         //
3490         if (Link == TopOfScreen) {
3491           //
3492           // The top of screen menu option occupies the entire form.
3493           //
3494           SkipValue += BottomRow - TopRow + 1;
3495         } else {
3496           SkipValue = NextMenuOption->Skip - (Index - (BottomRow + 1));
3497         }
3498         TopOfScreen = Link;
3499         MenuOption = NULL;
3500         //
3501         // Move to the Next selectable menu.
3502         //
3503         MoveToNextStatement (FALSE, &Link, BottomRow - TopRow, TRUE);
3504       }
3505
3506       //
3507       // Save the menu as the next highlight menu.
3508       //
3509       NewPos  = Link;
3510
3511       UpdateStatusBar (INPUT_ERROR, FALSE);
3512
3513       //
3514       // If we encounter a Date/Time op-code set, rewind to the first op-code of the set.
3515       // Don't do this when we are already in the last page.
3516       //
3517       AdjustDateAndTimePosition (TRUE, &TopOfScreen);
3518       AdjustDateAndTimePosition (TRUE, &NewPos);
3519
3520       UpdateHighlightMenuInfo(NewPos, TopOfScreen, SkipValue);
3521       break;
3522
3523     case CfUiDown:
3524       //
3525       // SkipValue means lines is skipped when show the top menu option.
3526       // NewPos  points to the menu which is highlighted now.
3527       //
3528       ControlFlag = CfRepaint;
3529       NewLine     = TRUE;
3530
3531       if (NewPos == TopOfScreen) {
3532         Temp2 = SkipValue;
3533       } else {
3534         Temp2 = 0;
3535       }
3536
3537       SavedListEntry = NewPos;
3538       //
3539       // Since the behavior of hitting the down arrow on a Date/Time op-code is intended
3540       // to be one that progresses to the next set of op-codes, we need to advance to the last
3541       // Date/Time op-code and leave the remaining logic in UiDown intact so the appropriate
3542       // checking can be done.  The only other logic we need to introduce is that if a Date/Time
3543       // op-code is the last entry in the menu, we need to rewind back to the first op-code of
3544       // the Date/Time op-code.
3545       //
3546       AdjustDateAndTimePosition (FALSE, &NewPos);
3547
3548       MenuOption = MENU_OPTION_FROM_LINK (NewPos);
3549       NewPos     = NewPos->ForwardLink;
3550       //
3551       // Find the next selectable menu.
3552       //
3553       if (MenuOption->Row + MenuOption->Skip - Temp2 > BottomRow + 1) {
3554         if (gMenuOption.ForwardLink == NewPos || &gMenuOption == NewPos) {
3555           Difference = -1;
3556         } else {
3557           Difference = 0;
3558         }
3559       } else {
3560         Difference = MoveToNextStatement (FALSE, &NewPos, BottomRow + 1 - (MenuOption->Row + MenuOption->Skip - Temp2), FALSE);
3561       }
3562       if (Difference < 0) {
3563         //
3564         // Scroll to the first page.
3565         //
3566         if (TopOfScreen != gMenuOption.ForwardLink || SkipValue != 0) {
3567           TopOfScreen = gMenuOption.ForwardLink;
3568           Repaint     = TRUE;
3569           MenuOption  = NULL;
3570         } else {
3571           MenuOption = MENU_OPTION_FROM_LINK (SavedListEntry);
3572         }
3573         NewPos        = gMenuOption.ForwardLink;
3574         MoveToNextStatement (FALSE, &NewPos, BottomRow - TopRow, TRUE);
3575
3576         SkipValue = 0;
3577         //
3578         // If we are at the end of the list and sitting on a Date/Time op, rewind to the head.
3579         //
3580         AdjustDateAndTimePosition (TRUE, &TopOfScreen);
3581         AdjustDateAndTimePosition (TRUE, &NewPos);
3582
3583         UpdateHighlightMenuInfo(NewPos, TopOfScreen, SkipValue);
3584         break;
3585       }
3586
3587       //
3588       // Get next selected menu info.
3589       //
3590       AdjustDateAndTimePosition (FALSE, &NewPos);
3591       NextMenuOption  = MENU_OPTION_FROM_LINK (NewPos);
3592       if (NextMenuOption->Row == 0) {
3593         UpdateOptionSkipLines (NextMenuOption);
3594       }
3595
3596       //
3597       // Calculate new highlight menu end row.
3598       //
3599       Temp = (MenuOption->Row + MenuOption->Skip - Temp2) + Difference + NextMenuOption->Skip - 1;
3600       if (Temp > BottomRow) {
3601         //
3602         // Get the top screen menu info.
3603         //
3604         AdjustDateAndTimePosition (FALSE, &TopOfScreen);
3605         SavedMenuOption = MENU_OPTION_FROM_LINK (TopOfScreen);
3606
3607         //
3608         // Current Top screen menu occupy (SavedMenuOption->Skip - SkipValue) rows.
3609         // Full shows the new selected menu need to skip (Temp - BottomRow - 1) rows.
3610         //
3611         if ((Temp - BottomRow) >= (SavedMenuOption->Skip - SkipValue)) {
3612           //
3613           // Skip the top op-code
3614           //
3615           TopOfScreen   = TopOfScreen->ForwardLink;
3616           DistanceValue = (Temp - BottomRow) - (SavedMenuOption->Skip - SkipValue);
3617
3618           SavedMenuOption = MENU_OPTION_FROM_LINK (TopOfScreen);
3619
3620           //
3621           // If we have a remainder, skip that many more op-codes until we drain the remainder
3622           // Special case is the selected highlight menu has more than one form of menus.
3623           //
3624           while (DistanceValue >= SavedMenuOption->Skip && TopOfScreen != NewPos) {
3625             //
3626             // Since the Difference is greater than or equal to this op-code's skip value, skip it
3627             //
3628             DistanceValue   = DistanceValue - (INTN) SavedMenuOption->Skip;
3629             TopOfScreen     = TopOfScreen->ForwardLink;
3630             SavedMenuOption = MENU_OPTION_FROM_LINK (TopOfScreen);
3631           }
3632           //
3633           // Since we will act on this op-code in the next routine, and increment the
3634           // SkipValue, set the skips to one less than what is required.
3635           //
3636           if (TopOfScreen != NewPos) {
3637             SkipValue = DistanceValue;
3638           } else {
3639             SkipValue = 0;
3640           }
3641         } else {
3642           //
3643           // Since we will act on this op-code in the next routine, and increment the
3644           // SkipValue, set the skips to one less than what is required.
3645           //
3646           SkipValue += Temp - BottomRow;
3647         }
3648         Repaint       = TRUE;
3649       } else if (!IsSelectable (NextMenuOption)) {
3650         //
3651         // Continue to go down until scroll to next page or the selectable option is found.
3652         //
3653         ScreenOperation = UiDown;
3654         ControlFlag     = CfScreenOperation;
3655         break;
3656       }
3657
3658       MenuOption = MENU_OPTION_FROM_LINK (SavedListEntry);
3659
3660       //
3661       // Check whether new highlight menu is selectable, if not, keep highlight on the old one.
3662       //
3663       // BottomRow - TopRow + 1 means the total rows current forms supported.
3664       // Difference + NextMenuOption->Skip + 1 means the distance between last highlight menu
3665       // and new top menu. New top menu will all shows in next form, but last highlight menu
3666       // may only shows 1 line. + 1 at right part means at least need to keep 1 line for the
3667       // last highlight menu.
3668       //
3669       if (!IsSelectable (NextMenuOption) && IsSelectable (MenuOption) &&
3670          (BottomRow - TopRow + 1 >= Difference + NextMenuOption->Skip + 1)) {
3671         NewPos = SavedListEntry;
3672       }
3673
3674       UpdateStatusBar (INPUT_ERROR, FALSE);
3675
3676       //
3677       // If we are at the end of the list and sitting on a Date/Time op, rewind to the head.
3678       //
3679       AdjustDateAndTimePosition (TRUE, &TopOfScreen);
3680       AdjustDateAndTimePosition (TRUE, &NewPos);
3681
3682       UpdateHighlightMenuInfo(NewPos, TopOfScreen, SkipValue);
3683       break;
3684
3685     case CfUiNoOperation:
3686       ControlFlag = CfRepaint;
3687       break;
3688
3689     case CfExit:
3690       gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
3691       if (HelpString != NULL) {
3692         FreePool (HelpString);
3693       }
3694       if (HelpHeaderString != NULL) {
3695         FreePool (HelpHeaderString);
3696       }
3697       if (HelpBottomString != NULL) {
3698         FreePool (HelpBottomString);
3699       }
3700       return EFI_SUCCESS;
3701
3702     default:
3703       break;
3704     }
3705   }
3706 }
3707
3708 /**
3709
3710   Base on the browser status info to show an pop up message.
3711
3712 **/
3713 VOID
3714 BrowserStatusProcess (
3715   VOID
3716   )
3717 {
3718   CHAR16             *ErrorInfo;
3719   EFI_INPUT_KEY      Key;
3720   EFI_EVENT          WaitList[2];
3721   EFI_EVENT          RefreshIntervalEvent;
3722   EFI_EVENT          TimeOutEvent;
3723   UINT8              TimeOut;
3724   EFI_STATUS         Status;
3725   UINTN              Index;
3726   WARNING_IF_CONTEXT EventContext;
3727   EFI_IFR_OP_HEADER  *OpCodeBuf;
3728   EFI_STRING_ID      StringToken;
3729   CHAR16             DiscardChange;
3730   CHAR16             JumpToFormSet;
3731   CHAR16             *PrintString;
3732
3733   if (gFormData->BrowserStatus == BROWSER_SUCCESS) {
3734     return;
3735   }
3736
3737   StringToken          = 0;
3738   TimeOutEvent         = NULL;
3739   RefreshIntervalEvent = NULL;
3740   OpCodeBuf            = NULL;
3741   if (gFormData->HighLightedStatement != NULL) {
3742     OpCodeBuf = gFormData->HighLightedStatement->OpCode;
3743   }
3744
3745   if (gFormData->BrowserStatus == (BROWSER_WARNING_IF)) {
3746     ASSERT (OpCodeBuf != NULL && OpCodeBuf->OpCode == EFI_IFR_WARNING_IF_OP);
3747
3748     TimeOut     = ((EFI_IFR_WARNING_IF *) OpCodeBuf)->TimeOut;
3749     StringToken = ((EFI_IFR_WARNING_IF *) OpCodeBuf)->Warning;
3750   } else {
3751     TimeOut = 0;
3752     if ((gFormData->BrowserStatus == (BROWSER_NO_SUBMIT_IF)) &&
3753         (OpCodeBuf != NULL && OpCodeBuf->OpCode == EFI_IFR_NO_SUBMIT_IF_OP)) {
3754       StringToken = ((EFI_IFR_NO_SUBMIT_IF *) OpCodeBuf)->Error;
3755     } else if ((gFormData->BrowserStatus == (BROWSER_INCONSISTENT_IF)) &&
3756                (OpCodeBuf != NULL && OpCodeBuf->OpCode == EFI_IFR_INCONSISTENT_IF_OP)) {
3757       StringToken = ((EFI_IFR_INCONSISTENT_IF *) OpCodeBuf)->Error;
3758     }
3759   }
3760
3761   if (StringToken != 0) {
3762     ErrorInfo = GetToken (StringToken, gFormData->HiiHandle);
3763   } else if (gFormData->ErrorString != NULL) {
3764     //
3765     // Only used to compatible with old setup browser.
3766     // Not use this field in new browser core.
3767     //
3768     ErrorInfo = gFormData->ErrorString;
3769   } else {
3770     switch (gFormData->BrowserStatus) {
3771     case BROWSER_SUBMIT_FAIL:
3772       ErrorInfo = gSaveFailed;
3773       break;
3774
3775     case BROWSER_FORM_NOT_FOUND:
3776       ErrorInfo = gFormNotFound;
3777       break;
3778
3779     case BROWSER_FORM_SUPPRESS:
3780       ErrorInfo = gFormSuppress;
3781       break;
3782
3783     case BROWSER_PROTOCOL_NOT_FOUND:
3784       ErrorInfo = gProtocolNotFound;
3785       break;
3786
3787     case BROWSER_SUBMIT_FAIL_NO_SUBMIT_IF:
3788       ErrorInfo = gNoSubmitIfFailed;
3789       break;
3790
3791     case BROWSER_RECONNECT_FAIL:
3792       ErrorInfo = gReconnectFail;
3793       break;
3794
3795     case BROWSER_RECONNECT_SAVE_CHANGES:
3796       ErrorInfo = gReconnectConfirmChanges;
3797       break;
3798
3799     case BROWSER_RECONNECT_REQUIRED:
3800       ErrorInfo = gReconnectRequired;
3801       break;
3802
3803     default:
3804       ErrorInfo = gBrowserError;
3805       break;
3806     }
3807   }
3808
3809   switch (gFormData->BrowserStatus) {
3810   case BROWSER_SUBMIT_FAIL:
3811   case BROWSER_SUBMIT_FAIL_NO_SUBMIT_IF:
3812   case BROWSER_RECONNECT_SAVE_CHANGES:
3813     ASSERT (gUserInput != NULL);
3814     if (gFormData->BrowserStatus == (BROWSER_SUBMIT_FAIL)) {
3815       PrintString = gSaveProcess;
3816       JumpToFormSet = gJumpToFormSet[0];
3817       DiscardChange = gDiscardChange[0];
3818     } else if (gFormData->BrowserStatus == (BROWSER_RECONNECT_SAVE_CHANGES)){
3819       PrintString = gChangesOpt;
3820       JumpToFormSet = gConfirmOptYes[0];
3821       DiscardChange = gConfirmOptNo[0];
3822     } else {
3823       PrintString = gSaveNoSubmitProcess;
3824       JumpToFormSet = gCheckError[0];
3825       DiscardChange = gDiscardChange[0];
3826     }
3827
3828     do {
3829       CreateDialog (&Key, gEmptyString, ErrorInfo, PrintString, gEmptyString, NULL);
3830     } while (((Key.UnicodeChar | UPPER_LOWER_CASE_OFFSET) != (DiscardChange | UPPER_LOWER_CASE_OFFSET)) &&
3831              ((Key.UnicodeChar | UPPER_LOWER_CASE_OFFSET) != (JumpToFormSet | UPPER_LOWER_CASE_OFFSET)));
3832
3833     if ((Key.UnicodeChar | UPPER_LOWER_CASE_OFFSET) == (DiscardChange | UPPER_LOWER_CASE_OFFSET)) {
3834       gUserInput->Action = BROWSER_ACTION_DISCARD;
3835     } else {
3836       gUserInput->Action = BROWSER_ACTION_GOTO;
3837     }
3838     break;
3839
3840   default:
3841     if (TimeOut == 0) {
3842       do {
3843         CreateDialog (&Key, gEmptyString, ErrorInfo, gPressEnter, gEmptyString, NULL);
3844       } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
3845     } else {
3846       Status = gBS->CreateEvent (EVT_NOTIFY_WAIT, TPL_CALLBACK, EmptyEventProcess, NULL, &TimeOutEvent);
3847       ASSERT_EFI_ERROR (Status);
3848
3849       EventContext.SyncEvent = TimeOutEvent;
3850       EventContext.TimeOut   = &TimeOut;
3851       EventContext.ErrorInfo = ErrorInfo;
3852
3853       Status = gBS->CreateEvent (EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_CALLBACK, RefreshTimeOutProcess, &EventContext, &RefreshIntervalEvent);
3854       ASSERT_EFI_ERROR (Status);
3855
3856       //
3857       // Show the dialog first to avoid long time not reaction.
3858       //
3859       gBS->SignalEvent (RefreshIntervalEvent);
3860
3861       Status = gBS->SetTimer (RefreshIntervalEvent, TimerPeriodic, ONE_SECOND);
3862       ASSERT_EFI_ERROR (Status);
3863
3864       while (TRUE) {
3865         Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
3866         if (!EFI_ERROR (Status) && Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
3867           break;
3868         }
3869
3870         if (Status != EFI_NOT_READY) {
3871           continue;
3872         }
3873
3874         WaitList[0] = TimeOutEvent;
3875         WaitList[1] = gST->ConIn->WaitForKey;
3876
3877         Status = gBS->WaitForEvent (2, WaitList, &Index);
3878         ASSERT_EFI_ERROR (Status);
3879
3880         if (Index == 0) {
3881           //
3882           // Timeout occur, close the hoot time out event.
3883           //
3884           break;
3885         }
3886       }
3887
3888       gBS->CloseEvent (TimeOutEvent);
3889       gBS->CloseEvent (RefreshIntervalEvent);
3890     }
3891     break;
3892   }
3893
3894   if (StringToken != 0) {
3895     FreePool (ErrorInfo);
3896   }
3897 }
3898
3899 /**
3900   Display one form, and return user input.
3901
3902   @param FormData                Form Data to be shown.
3903   @param UserInputData           User input data.
3904
3905   @retval EFI_SUCCESS            1.Form Data is shown, and user input is got.
3906                                  2.Error info has show and return.
3907   @retval EFI_INVALID_PARAMETER  The input screen dimension is not valid
3908   @retval EFI_NOT_FOUND          New form data has some error.
3909 **/
3910 EFI_STATUS
3911 EFIAPI
3912 FormDisplay (
3913   IN  FORM_DISPLAY_ENGINE_FORM  *FormData,
3914   OUT USER_INPUT                *UserInputData
3915   )
3916 {
3917   EFI_STATUS  Status;
3918
3919   ASSERT (FormData != NULL);
3920   if (FormData == NULL) {
3921     return EFI_INVALID_PARAMETER;
3922   }
3923
3924   gUserInput = UserInputData;
3925   gFormData  = FormData;
3926
3927   //
3928   // Process the status info first.
3929   //
3930   BrowserStatusProcess();
3931   if (gFormData->BrowserStatus != BROWSER_SUCCESS) {
3932     //
3933     // gFormData->BrowserStatus != BROWSER_SUCCESS, means only need to print the error info, return here.
3934     //
3935     return EFI_SUCCESS;
3936   }
3937
3938   Status = DisplayPageFrame (FormData, &gStatementDimensions);
3939   if (EFI_ERROR (Status)) {
3940     return Status;
3941   }
3942
3943   //
3944   // Global Widths should be initialized before any MenuOption creation
3945   // or the GetWidth() used in UiAddMenuOption() will return incorrect value.
3946   //
3947   //
3948   //  Left                                              right
3949   //   |<-.->|<-.........->|<- .........->|<-...........->|
3950   //     Skip    Prompt         Option         Help
3951   //
3952   gOptionBlockWidth = (CHAR16) ((gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn) / 3) + 1;
3953   gHelpBlockWidth   = (CHAR16) (gOptionBlockWidth - 1 - LEFT_SKIPPED_COLUMNS);
3954   gPromptBlockWidth = (CHAR16) (gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn - 2 * (gOptionBlockWidth - 1) - 1);
3955
3956   ConvertStatementToMenu();
3957
3958   //
3959   // Check whether layout is changed.
3960   //
3961   if (mIsFirstForm
3962       || (gOldFormEntry.HiiHandle != FormData->HiiHandle)
3963       || (!CompareGuid (&gOldFormEntry.FormSetGuid, &FormData->FormSetGuid))
3964       || (gOldFormEntry.FormId != FormData->FormId)) {
3965     mStatementLayoutIsChanged = TRUE;
3966   } else {
3967     mStatementLayoutIsChanged = FALSE;
3968   }
3969
3970   Status = UiDisplayMenu(FormData);
3971
3972   //
3973   // Backup last form info.
3974   //
3975   mIsFirstForm            = FALSE;
3976   gOldFormEntry.HiiHandle = FormData->HiiHandle;
3977   CopyGuid (&gOldFormEntry.FormSetGuid, &FormData->FormSetGuid);
3978   gOldFormEntry.FormId    = FormData->FormId;
3979
3980   return Status;
3981 }
3982
3983 /**
3984   Clear Screen to the initial state.
3985 **/
3986 VOID
3987 EFIAPI
3988 DriverClearDisplayPage (
3989   VOID
3990   )
3991 {
3992   ClearDisplayPage ();
3993   mIsFirstForm = TRUE;
3994 }
3995
3996 /**
3997   Set Buffer to Value for Size bytes.
3998
3999   @param  Buffer                 Memory to set.
4000   @param  Size                   Number of bytes to set
4001   @param  Value                  Value of the set operation.
4002
4003 **/
4004 VOID
4005 SetUnicodeMem (
4006   IN VOID   *Buffer,
4007   IN UINTN  Size,
4008   IN CHAR16 Value
4009   )
4010 {
4011   CHAR16  *Ptr;
4012
4013   Ptr = Buffer;
4014   while ((Size--)  != 0) {
4015     *(Ptr++) = Value;
4016   }
4017 }
4018
4019 /**
4020   Initialize Setup Browser driver.
4021
4022   @param ImageHandle     The image handle.
4023   @param SystemTable     The system table.
4024
4025   @retval EFI_SUCCESS    The Setup Browser module is initialized correctly..
4026   @return Other value if failed to initialize the Setup Browser module.
4027
4028 **/
4029 EFI_STATUS
4030 EFIAPI
4031 InitializeDisplayEngine (
4032   IN EFI_HANDLE           ImageHandle,
4033   IN EFI_SYSTEM_TABLE     *SystemTable
4034   )
4035 {
4036   EFI_STATUS                          Status;
4037   EFI_INPUT_KEY                       HotKey;
4038   EFI_STRING                          NewString;
4039   EDKII_FORM_BROWSER_EXTENSION2_PROTOCOL *FormBrowserEx2;
4040
4041   //
4042   // Publish our HII data
4043   //
4044   gHiiHandle = HiiAddPackages (
4045                  &gDisplayEngineGuid,
4046                  ImageHandle,
4047                  DisplayEngineStrings,
4048                  NULL
4049                  );
4050   ASSERT (gHiiHandle != NULL);
4051
4052   //
4053   // Install Form Display protocol
4054   //
4055   Status = gBS->InstallProtocolInterface (
4056                   &mPrivateData.Handle,
4057                   &gEdkiiFormDisplayEngineProtocolGuid,
4058                   EFI_NATIVE_INTERFACE,
4059                   &mPrivateData.FromDisplayProt
4060                   );
4061   ASSERT_EFI_ERROR (Status);
4062
4063   InitializeDisplayStrings();
4064
4065   ZeroMem (&gHighligthMenuInfo, sizeof (gHighligthMenuInfo));
4066   ZeroMem (&gOldFormEntry, sizeof (gOldFormEntry));
4067
4068   //
4069   // Use BrowserEx2 protocol to register HotKey.
4070   //
4071   Status = gBS->LocateProtocol (&gEdkiiFormBrowserEx2ProtocolGuid, NULL, (VOID **) &FormBrowserEx2);
4072   if (!EFI_ERROR (Status)) {
4073     //
4074     // Register the default HotKey F9 and F10 again.
4075     //
4076     HotKey.UnicodeChar = CHAR_NULL;
4077     HotKey.ScanCode   = SCAN_F10;
4078     NewString         = HiiGetString (gHiiHandle, STRING_TOKEN (FUNCTION_TEN_STRING), NULL);
4079     ASSERT (NewString != NULL);
4080     FormBrowserEx2->RegisterHotKey (&HotKey, BROWSER_ACTION_SUBMIT, 0, NewString);
4081
4082     HotKey.ScanCode   = SCAN_F9;
4083     NewString         = HiiGetString (gHiiHandle, STRING_TOKEN (FUNCTION_NINE_STRING), NULL);
4084     ASSERT (NewString != NULL);
4085     FormBrowserEx2->RegisterHotKey (&HotKey, BROWSER_ACTION_DEFAULT, EFI_HII_DEFAULT_CLASS_STANDARD, NewString);
4086   }
4087
4088   return EFI_SUCCESS;
4089 }
4090
4091 /**
4092   This is the default unload handle for display core drivers.
4093
4094   @param[in]  ImageHandle       The drivers' driver image.
4095
4096   @retval EFI_SUCCESS           The image is unloaded.
4097   @retval Others                Failed to unload the image.
4098
4099 **/
4100 EFI_STATUS
4101 EFIAPI
4102 UnloadDisplayEngine (
4103   IN EFI_HANDLE             ImageHandle
4104   )
4105 {
4106   HiiRemovePackages(gHiiHandle);
4107
4108   FreeDisplayStrings ();
4109
4110   if (gHighligthMenuInfo.HLTOpCode != NULL) {
4111     FreePool (gHighligthMenuInfo.HLTOpCode);
4112   }
4113
4114   if (gHighligthMenuInfo.TOSOpCode != NULL) {
4115     FreePool (gHighligthMenuInfo.TOSOpCode);
4116   }
4117
4118   return EFI_SUCCESS;
4119 }