/** @file

;******************************************************************************
;* Copyright (c) 2013 - 2021, Insyde Software Corp. All Rights Reserved.
;*
;* You may not reproduce, distribute, publish, display, perform, modify, adapt,
;* transmit, broadcast, present, recite, release, license or otherwise exploit
;* any part of this publication in any form, by any means, without the prior
;* written permission of Insyde Software Corporation.
;*
;******************************************************************************
*/

#include "H2ODisplayEngineLocalText.h"
#include "LTDEControl.h"
#include "LTDEPanels.h"
#include "LTDEQuestions.h"
#include "LTDEPrint.h"
#include "LTDEMisc.h"
#include <Guid/ZeroGuid.h>


EFI_STATUS
CheckFBHotKey (
  IN  H2O_DISPLAY_ENGINE_USER_INPUT_DATA      *UserInputData,
  OUT HOT_KEY_INFO                            *SelectedHotKey
  )
{
  if (UserInputData == NULL || SelectedHotKey == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  if (mDEPrivate->FBProtocol->CurrentP->HotKeyInfo == NULL) {
    return EFI_NOT_FOUND;
  }

  return GetSelectedHotKeyInfoByKeyData (&UserInputData->KeyData, mDEPrivate->FBProtocol->CurrentP->HotKeyInfo, SelectedHotKey);
}

EFI_STATUS
CheckDEHotKeyInVfcf (
  IN EFI_KEY_DATA                             *KeyData
  )
{
  EFI_STATUS                                  Status;
  UINT32                                      HotKeyCount;
  HOT_KEY_INFO                                *HotKey;
  H2O_FORM_BROWSER_SM                         *SetupMenuData;
  EFI_GUID                                    FormsetGuid;
  EFI_FORM_ID                                 FormId;
  EFI_QUESTION_ID                             QuestionId;
  HOT_KEY_INFO                                SelectedHotKeyInfo;

  if (KeyData == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  if (mDEPrivate->Layout == NULL) {
    return EFI_NOT_FOUND;
  }

  //
  // Based on current (Formset, Form, QuestionId) to get the hot key list of display engine.
  //
  Status = mDEPrivate->FBProtocol->GetSMInfo (mDEPrivate->FBProtocol, &SetupMenuData);
  if (!EFI_ERROR (Status)) {
    CopyGuid (&FormsetGuid, &SetupMenuData->FormSetGuid);
    FreeSetupMenuData (SetupMenuData);
  } else {
    ZeroMem (&FormsetGuid, sizeof (EFI_GUID));
  }
  FormId     = (mDEPrivate->FBProtocol->CurrentP != NULL) ? (EFI_FORM_ID) (mDEPrivate->FBProtocol->CurrentP->PageId & 0xFFFF) : 0;
  QuestionId = (mDEPrivate->FBProtocol->CurrentQ != NULL) ? mDEPrivate->FBProtocol->CurrentQ->QuestionId : 0;

  Status = GetHotKeyListByLayoutInfo (
             mDEPrivate->Layout,
             &FormsetGuid,
             FormId,
             QuestionId,
             &HotKeyCount,
             &HotKey
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = GetSelectedHotKeyInfoByKeyData (KeyData, HotKey, &SelectedHotKeyInfo);
  if (!EFI_ERROR (Status)) {
    SendEvtByHotKey (&SelectedHotKeyInfo);
  }

  FreePool (HotKey);
  return Status;
}

STATIC
EFI_STATUS
CheckDEHotKey (
  IN H2O_DISPLAY_ENGINE_USER_INPUT_DATA       *UserInputData
  )
{
  EFI_STATUS                                  Status;

  if (UserInputData == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  Status = CheckDEHotKeyInVfcf (&UserInputData->KeyData);
  if (!EFI_ERROR (Status)) {
    return Status;
  }

  Status = SetupPagePanelProcessHotKey (&UserInputData->KeyData.Key);
  if (!EFI_ERROR (Status)) {
    return Status;
  }

  Status = HelpTextPanelProcessUserInput (&UserInputData->KeyData.Key);
  if (!EFI_ERROR (Status)) {
    return Status;
  }

  return EFI_UNSUPPORTED;
}

EFI_STATUS
SendEvtByHotKey (
  IN HOT_KEY_INFO                             *HotKey
  )
{
  H2O_LTDE_PANEL                              *SetupMenuPanel;
  H2O_LTDE_PANEL                              *SetupPagePanel;
  H2O_LTDE_PANEL_ITEM                         *ContentItem;
  H2O_LTDE_CONTROL                            *Control;

  if (HotKey == 0) {
    return EFI_INVALID_PARAMETER;
  }

  switch (HotKey->HotKeyAction) {

  case HotKeySelectPreviousItem:
  case HotKeySelectNextItem:
    SetupPagePanel = GetPanel (SETUP_PAGE_PANEL_ID);
    if (SetupPagePanel != NULL) {
      SetupPagePanelProcessSelectQHotKey (SetupPagePanel, (BOOLEAN) (HotKey->HotKeyAction == HotKeySelectNextItem));
    }
    break;

  case HotKeyEnter:
    SetupPagePanel = GetPanel (SETUP_PAGE_PANEL_ID);
    if (SetupPagePanel == NULL) {
      break;
    }

    if (HotKey->HotKeyTargetQuestionId == 0) {
      SetupPagePanelProcessOpenQHotKey (SetupPagePanel, NULL);
    } else {
      ContentItem = GetPanelItem (SetupPagePanel, LTDE_PANEL_ITEM_ID_CONTENT);
      if (ContentItem == NULL) {
        break;
      }

      Control = GetControlByQuestionId (
                  ContentItem->ControlList,
                  ContentItem->ControlCount,
                  HotKey->HotKeyTargetQuestionId,
                  NULL
                  );
      if (Control == NULL) {
        break;
      }

      if (SetupPagePanel->SelectedControl == NULL ||
          SetupPagePanel->SelectedControl->QuestionId != Control->QuestionId) {
        SendSelectQNotify (Control->PageId, Control->QuestionId, Control->IfrOpCode);
      }
      SetupPagePanelProcessOpenQHotKey (SetupPagePanel, Control);
    }
    break;

  case HotKeyModifyPreviousValue:
  case HotKeyModifyNextValue:
    SetupPagePanel = GetPanel (SETUP_PAGE_PANEL_ID);
    if (SetupPagePanel != NULL) {
      SetupPagePanelProcessChangeQHotKey (SetupPagePanel, (BOOLEAN) (HotKey->HotKeyAction == HotKeyModifyNextValue));
    }
    break;

  case HotKeySelectPreviousMenu:
  case HotKeySelectNextMenu:
    SetupMenuPanel = GetPanel (SETUP_MENU_PANEL_ID);
    if (SetupMenuPanel != NULL) {
      SetupMenuPanelProcessSelectQHotKey (SetupMenuPanel, (BOOLEAN) (HotKey->HotKeyAction == HotKeySelectNextMenu));
    }
    break;

  case HotKeySaveAndExit:
    SendSubmitExitNotify ();
    break;

  case HotKeyDiscardAndExit:
    SendDiscardExitNotify ();
    break;

  case HotKeyShowHelp:
    SendShowHelpNotify ();
    break;

  case HotKeySave:
  case HotKeyLoadDefault:
  case HotKeyDiscard:
  case HotKeyGoTo:
  case HotKeyCallback:
  case HotKeySetQuestionValue:
    SendHotKeyNotify (HotKey);
    break;

  default:
    return EFI_NOT_FOUND;
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
GetLayout (
  H2O_LAYOUT_INFO                                **Layout
  )
{
  UINT32                                         LayoutId;
  EFI_STATUS                                     Status;
  H2O_FORM_BROWSER_SM                            *SetupMenuData;
  EFI_GUID                                       FormSetGuid;

  Status = mDEPrivate->FBProtocol->GetSMInfo (mDEPrivate->FBProtocol, &SetupMenuData);
  if (!EFI_ERROR (Status)) {
    CopyGuid (&FormSetGuid, &SetupMenuData->FormSetGuid);
    FreeSetupMenuData (SetupMenuData);
  } else {
    CopyGuid (&FormSetGuid, &gZeroGuid);
  }


  LayoutId = 0;
  Status = GetLayoutIdByGuid (&FormSetGuid, &LayoutId);
  if (EFI_ERROR (Status)) {
    Status = GetLayoutIdByGuid (&gZeroGuid, &LayoutId);
    ASSERT_EFI_ERROR (Status);
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }

  Status = GetLayoutById (
             LayoutId,
             &mDEPrivate->DisplayEngine.Id,
             Layout
             );
  if (EFI_ERROR (Status)) {
    Status = GetLayoutIdByGuid (&gZeroGuid, &LayoutId);
    ASSERT_EFI_ERROR (Status);

    Status = GetLayoutById (
               LayoutId,
               &mDEPrivate->DisplayEngine.Id,
               Layout
               );
  }

  ASSERT_EFI_ERROR (Status);

  return Status;
}

STATIC
EFI_STATUS
UpdatePanelFromVfcf (
  IN     H2O_PANEL_INFO                       *VfcfPanelInfo,
  IN     RECT                                 *ScreenField,
  IN OUT H2O_LTDE_PANEL                       *Panel
  )
{
  EFI_STATUS                                     Status;
  H2O_PROPERTY_INFO                              *Property;
  H2O_PROPERTY_VALUE                             PropValue;


  if (VfcfPanelInfo == NULL || ScreenField == NULL || Panel == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  Panel->VfcfPanelInfo   = VfcfPanelInfo;
  Panel->Vertical        = (VfcfPanelInfo->PanelId == SETUP_MENU_PANEL_ID) ? FALSE : TRUE;
  Panel->Visible         = IsVisibility (VfcfPanelInfo, NULL, H2O_IFR_STYLE_TYPE_PANEL, H2O_STYLE_PSEUDO_CLASS_NORMAL);
  Panel->BorderLineWidth = GetBorderWidth (VfcfPanelInfo, NULL, H2O_IFR_STYLE_TYPE_PANEL, H2O_STYLE_PSEUDO_CLASS_NORMAL);
  GetPanelField (VfcfPanelInfo, NULL, H2O_IFR_STYLE_TYPE_PANEL, H2O_STYLE_PSEUDO_CLASS_NORMAL, ScreenField, &Panel->PanelField);
  GetPanelColorAttribute (VfcfPanelInfo, NULL, H2O_IFR_STYLE_TYPE_PANEL, H2O_STYLE_PSEUDO_CLASS_NORMAL, &Panel->ColorAttribute);

  Panel->BorderColorAttribute = Panel->ColorAttribute;
  Status = GetPropertyFromVfrAndPanel (
             Panel->VfcfPanelInfo,
             NULL,
             H2O_IFR_STYLE_TYPE_PANEL,
             H2O_STYLE_PSEUDO_CLASS_NORMAL,
             "border-color",
             NULL,
             &Property,
             &PropValue
             );
  if (!EFI_ERROR (Status)) {
    Panel->BorderColorAttribute &= ~0x0F;
    Panel->BorderColorAttribute |= PropValue.Value.Color.Attribute;
  }

  return EFI_SUCCESS;
}

/**
 Determine if user is editing question at menu or not

 @retval TRUE                User is editing question at menu.
 @retval FALSE               User is not editing question at menu.
*/
BOOLEAN
IsUserEditingAtMenu (
  VOID
  )
{
  H2O_LTDE_PANEL             *SetupPagePanel;
  BOOLEAN                    Result;

  Result = FALSE;

  if (mDEPrivate->DEStatus != DISPLAY_ENGINE_STATUS_AT_MENU) {
    return Result;
  }

  SetupPagePanel = GetPanel (SETUP_PAGE_PANEL_ID);
  if (SetupPagePanel == NULL || SetupPagePanel->SelectedControl == NULL) {
    return Result;
  }

  switch (SetupPagePanel->SelectedControl->Operand) {

  case EFI_IFR_DATE_OP:
  case EFI_IFR_TIME_OP:
    Result = IsDateTimeOpCodeBeingModified (SetupPagePanel->SelectedControl);
    break;
  }

  return Result;
}

/**
  Reset all console device to initial status.

  @param[in] ConsoleDevListHead    Pointer to console device linked list
**/
STATIC
VOID
ResetConDevStatus (
  IN LIST_ENTRY                                  *ConsoleDevListHead
  )
{
  LIST_ENTRY                                     *Link;
  H2O_FORM_BROWSER_CONSOLE_DEV_NODE              *ConDevNode;

  Link = GetFirstNode (ConsoleDevListHead);
  while (!IsNull (ConsoleDevListHead, Link)) {
    ConDevNode = H2O_FORM_BROWSER_CONSOLE_DEV_NODE_FROM_LINK (Link);
    Link = GetNextNode (ConsoleDevListHead, Link);

    if (ConDevNode != NULL) {
      ConDevNode->ConDevStatus = CONSOLE_DEVICE_STATUS_INIT;
    }
  }
}

/**
  Remove all panel from list

  @param[in] PanelListHead        Pointer to panel linked list
**/
STATIC
VOID
RemovePanelList (
  IN LIST_ENTRY                               *PanelListHead
  )
{
  LIST_ENTRY                                  *Link;
  H2O_LTDE_PANEL                              *Panel;

  if (PanelListHead == NULL) {
    return;
  }

  if (IsListEmpty (PanelListHead)) {
    return;
  }

  Link = GetFirstNode (PanelListHead);
  while (!IsNull (PanelListHead, Link)) {
    Panel = H2O_LTDE_PANEL_FROM_LINK (Link);
    Link  = GetNextNode (PanelListHead, Link);
    FreePanel (Panel);
    //
    // BUGBUG: verify free panel is safe.
    //
    RemoveEntryList (&Panel->Link);
    FreePool (Panel);
  }
}

/**
 Initialize layout definition into PanelList of private data

 @retval EFI_SUCCESS                Initialize layout definition successfully
 @retval EFI_NOT_FOUND              There is no panel information for layout
 @retval Other                      Fail to get screen field or layout data
**/
STATIC
EFI_STATUS
InitLayout (
  VOID
  )
{
  EFI_STATUS                                     Status;
  RECT                                           ScreenField;
  H2O_LAYOUT_INFO                                *Layout;
  LIST_ENTRY                                     *Link;
  H2O_PANEL_INFO                                 *VfcfPanelInfo;
  H2O_LTDE_PANEL                                 *Panel;

  Status = GetScreenField (&ScreenField);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = GetLayout (&Layout);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (mDEPrivate->Layout != NULL &&
      mDEPrivate->Layout->LayoutId != Layout->LayoutId) {
    //
    // Layout is different. Reset console device status and remove all panel list.
    //
    ResetConDevStatus (&mDEPrivate->ConsoleDevListHead);
    RemovePanelList (&mDEPrivate->PanelListHead);
  }

  if (IsListEmpty (&Layout->PanelListHead)) {
    return EFI_NOT_FOUND;
  }

  Link = GetFirstNode (&Layout->PanelListHead);
  while (!IsNull (&Layout->PanelListHead, Link)) {
    VfcfPanelInfo = H2O_PANEL_INFO_NODE_FROM_LINK (Link);
    Link          = GetNextNode (&Layout->PanelListHead, Link);

    Panel = GetPanel (VfcfPanelInfo->PanelId);
    if (Panel == NULL) {
      Panel = CreatePanel ();
    }
    if (Panel != NULL) {
      UpdatePanelFromVfcf (VfcfPanelInfo, &ScreenField, Panel);
    }
  }

  mDEPrivate->Layout = Layout;

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
DERefreshQuestion (
  IN H2O_PAGE_ID                              PageId,
  IN EFI_QUESTION_ID                          QuestionId,
  IN EFI_IFR_OP_HEADER                        *IfrOpCode
  )
{
  EFI_STATUS                                  Status;
  BOOLEAN                                     IsHighlight;
  H2O_LTDE_PANEL                              *SetupPagePanel;
  H2O_LTDE_PANEL_ITEM                         *ContentItem;
  H2O_LTDE_CONTROL                            *Control;
  H2O_FORM_BROWSER_S                          *Statement;

  SetupPagePanel = GetPanel (SETUP_PAGE_PANEL_ID);
  if (SetupPagePanel == NULL) {
    return EFI_NOT_FOUND;
  }

  ContentItem = GetPanelItem (SetupPagePanel, LTDE_PANEL_ITEM_ID_CONTENT);
  if (ContentItem == NULL) {
    return EFI_NOT_FOUND;
  }

  IsHighlight = IsCurrentHighlight (PageId, QuestionId, IfrOpCode);
  if (IsHighlight && IsDateTimeOpCodeBeingModified (SetupPagePanel->SelectedControl)) {
    return EFI_ABORTED;
  }

  Control = GetControlByQuestionId (
              ContentItem->ControlList,
              ContentItem->ControlCount,
              QuestionId,
              IfrOpCode
              );
  if (Control == NULL) {
    return EFI_NOT_FOUND;
  }

  Status = mDEPrivate->FBProtocol->GetSInfo (mDEPrivate->FBProtocol, PageId, Control->StatementId, &Statement);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  FreeControlInfo (Control);
  UpdateSetupPageControl (SetupPagePanel, ContentItem, Statement, Control);
  SafeFreePool ((VOID **) &Statement);

  DisplaySetupPagePanelContentItemControl (SetupPagePanel, ContentItem, Control);
  if (!IsHighlight) {
    return EFI_SUCCESS;
  }

  Status = InitHelpTextPanel ();
  if (!EFI_ERROR (Status)) {
    DisplayHelpTextPanel ();
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
DERefreshSetupPageAndHelp (
  IN H2O_DISPLAY_ENGINE_PRIVATE_DATA          *Private
  )
{
  EFI_STATUS                                  Status;

  Status = InitSetupPagePanel ();
  if (!EFI_ERROR (Status)) {
    DisplaySetupPagePanel ();
  }

  Status = InitHelpTextPanel ();
  if (!EFI_ERROR (Status)) {
    DisplayHelpTextPanel ();
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
DEOpenLayout (
  IN H2O_DISPLAY_ENGINE_PRIVATE_DATA         *Private
  )
{
  EFI_STATUS                                 Status;

  Status = InitLayout ();
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = DisplayLayout ();
  if (EFI_ERROR (Status)) {
    return Status;
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
DEOpenPage (
  IN H2O_DISPLAY_ENGINE_PRIVATE_DATA         *Private
  )
{
  EFI_STATUS                                 Status;

  Status = InitTitlePanel ();
  if (!EFI_ERROR (Status)) {
    DisplayTitlePanel ();
  }

  Status = InitSetupMenuPanel ();
  if (!EFI_ERROR (Status)) {
    DisplaySetupMenuPanel ();
  }

  Status = InitHotKeyPanel ();
  if (!EFI_ERROR (Status)) {
    DisplayHotKeyPanel ();
  }

  //
  // Display Current Page Menu
  //
  Status = DERefreshSetupPageAndHelp (Private);

  return Status;
}

STATIC
EFI_STATUS
DEShutPage (
  IN H2O_DISPLAY_ENGINE_PRIVATE_DATA             *Private
  )
{
  LIST_ENTRY                                     *PanelLink;
  H2O_LTDE_PANEL                                 *Panel;

  if (IsListEmpty (&Private->PanelListHead)) {
    return EFI_NOT_FOUND;
  }

  PanelLink = GetFirstNode (&Private->PanelListHead);
  while (!IsNull (&Private->PanelListHead, PanelLink)) {
    Panel     = H2O_LTDE_PANEL_FROM_LINK (PanelLink);
    PanelLink = GetNextNode (&Private->PanelListHead, PanelLink);

    switch (Panel->VfcfPanelInfo->PanelId) {

    case HELP_TEXT_PANEL_ID:
    case QUESTION_PANEL_ID:
//      FreePanel (Panel);
      break;
    }
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
DESelectQuestion (
  IN H2O_DISPLAY_ENGINE_PRIVATE_DATA          *Private,
  IN H2O_DISPLAY_ENGINE_EVT_SELECT_Q          *SelectQ
  )
{
  EFI_STATUS                                  Status;
  H2O_LTDE_PANEL                              *SetupPagePanel;

  SetupPagePanel = GetPanel (SETUP_PAGE_PANEL_ID);
  if (SetupPagePanel == NULL) {
    return EFI_SUCCESS;
  }

  Status = SetupPagePanelProcessSelectQEvt (SetupPagePanel, SelectQ);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = InitHelpTextPanel ();
  if (!EFI_ERROR (Status)) {
    DisplayHelpTextPanel ();
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
DEShutQuestion (
  IN CONST H2O_DISPLAY_ENGINE_EVT             *Notify
  )
{
  EFI_STATUS                                  Status;

  Status = ProcessEvtInQuestionFunc ((H2O_DISPLAY_ENGINE_EVT *) Notify, NULL);
  mDEPrivate->DEStatus = DISPLAY_ENGINE_STATUS_AT_MENU;

  return Status;
}

EFI_STATUS
DEChangingQuestion (
  IN       H2O_FORM_BROWSER_PROTOCOL          *FBProtocol,
  IN CONST H2O_DISPLAY_ENGINE_EVT             *Notify
  )
{
  EFI_STATUS                                  Status;

  Status = ProcessEvtInQuestionFunc (Notify, NULL);
  if (Status == EFI_NOT_FOUND) {
    Status = EFI_SUCCESS;
  }

  return Status;
}

STATIC
EFI_STATUS
DEOpenDialog (
  IN     H2O_FORM_BROWSER_PROTOCOL            *FBProtocol,
  IN CONST H2O_DISPLAY_ENGINE_EVT             *Notify
  )
{
  EFI_STATUS                                  Status;
  H2O_LTDE_PANEL                              *QuestionPanel;

  if (IsListEmpty (&mDEPrivate->PanelListHead)) {
    Status = InitLayout ();
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }

  QuestionPanel = GetPanel (QUESTION_PANEL_ID);
  if (QuestionPanel == NULL) {
    return EFI_NOT_FOUND;
  }

  QuestionPanelProcessOpenDEvt (&((H2O_DISPLAY_ENGINE_EVT_OPEN_D *) Notify)->Dialog, QuestionPanel);

  if (mDEPrivate->DEStatus == DISPLAY_ENGINE_STATUS_AT_POPUP_DIALOG) {
    if (QuestionPanel->Data != NULL && 
        ((H2O_LTDE_QUESTION_PANEL_PRIVATE_DATA *) QuestionPanel->Data)->Dialog.DialogType == ((H2O_DISPLAY_ENGINE_EVT_OPEN_D *) Notify)->Dialog.DialogType) {
      QuestionPanelUpdateField (&((H2O_LTDE_QUESTION_PANEL_PRIVATE_DATA *) QuestionPanel->Data)->Dialog, QuestionPanel);
      return DisplayQuestionPanel (QuestionPanel);
    }
  }

  mDEPrivate->DEStatus = DISPLAY_ENGINE_STATUS_AT_POPUP_DIALOG;
  Status = ProcessEvtInQuestionFunc (Notify, NULL);
  if (EFI_ERROR (Status)) {
    mDEPrivate->DEStatus = DISPLAY_ENGINE_STATUS_AT_MENU;
  }
  if (Status == EFI_NOT_FOUND) {
    Status = EFI_SUCCESS;
  }

  return Status;
}

STATIC
EFI_STATUS
DEShutDialog (
  IN       H2O_DISPLAY_ENGINE_PRIVATE_DATA   *Private,
  IN CONST H2O_DISPLAY_ENGINE_EVT            *Notify
  )
{
  EFI_STATUS                                 Status;

  Status = ProcessEvtInQuestionFunc (Notify, NULL);
  Private->DEStatus = DISPLAY_ENGINE_STATUS_AT_MENU;
  if (Status == EFI_NOT_FOUND) {
    Status = EFI_SUCCESS;
  }

  if (Private->FBProtocol->CurrentP != NULL) {
    DisplayLayout ();
    DEOpenPage (Private);
  }
  DEConOutSetAttribute (EFI_LIGHTGRAY | EFI_BACKGROUND_BLACK);

  return Status;
}

EFI_STATUS
DEExit (
  VOID
  )
{
  RemovePanelList (&mDEPrivate->PanelListHead);
  mDEPrivate->Layout = NULL;
  mDEPrivate->DEStatus = DISPLAY_ENGINE_STATUS_AT_MENU;

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
GetUserInputData (
  IN CONST H2O_DISPLAY_ENGINE_EVT             *Notify,
  OUT      H2O_DISPLAY_ENGINE_USER_INPUT_DATA *UserInputData
  )
{
  EFI_STATUS                                  Status;
  H2O_DISPLAY_ENGINE_USER_INPUT_DATA          InputData;
  H2O_DISPLAY_ENGINE_EVT_REL_PTR_MOVE         *RelPtrMoveNotify;
  H2O_DISPLAY_ENGINE_EVT_ABS_PTR_MOVE         *AbsPtrMoveNotify;
  STATIC UINT32                               PreviousActiveButtons = 0;
  STATIC INT32                                RealMouseX = 0;
  STATIC INT32                                RealMouseY = 0;

  if (Notify == NULL || UserInputData == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  //
  // Read user input from input event
  //
  ZeroMem (&InputData, sizeof (H2O_DISPLAY_ENGINE_USER_INPUT_DATA));
  InputData.KeyData.KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID;
  InputData.KeyData.KeyState.KeyToggleState = EFI_TOGGLE_STATE_VALID;

  Status = EFI_SUCCESS;

  switch (Notify->Type) {

  case H2O_DISPLAY_ENGINE_EVT_TYPE_KEYPRESS:
    //
    // Keyboard
    //
    InputData.IsKeyboard = TRUE;
    CopyMem (&InputData.KeyData, &((H2O_DISPLAY_ENGINE_EVT_KEYPRESS *) Notify)->KeyData, sizeof (EFI_KEY_DATA));
    break;

  case H2O_DISPLAY_ENGINE_EVT_TYPE_REL_PTR_MOVE:
    RelPtrMoveNotify = (H2O_DISPLAY_ENGINE_EVT_REL_PTR_MOVE *) Notify;
    //
    // Rel Mouse
    //
    if (RelPtrMoveNotify->State.LeftButton) {
      InputData.KeyData.Key.ScanCode    = SCAN_NULL;
      InputData.KeyData.Key.UnicodeChar = CHAR_CARRIAGE_RETURN;
    }
    if (RelPtrMoveNotify->State.RightButton) {
      InputData.KeyData.Key.ScanCode    = SCAN_ESC;
      InputData.KeyData.Key.UnicodeChar = CHAR_NULL;
    }
    RealMouseX += RelPtrMoveNotify->State.RelativeMovementX;
    RealMouseY += RelPtrMoveNotify->State.RelativeMovementY;
    Status = TransferToTextModePosition (RealMouseX, RealMouseY, &InputData.CursorX, &InputData.CursorY);
    break;

  case H2O_DISPLAY_ENGINE_EVT_TYPE_ABS_PTR_MOVE:
    AbsPtrMoveNotify = (H2O_DISPLAY_ENGINE_EVT_ABS_PTR_MOVE *) Notify;
    //
    // Abs Mouse
    //
    if ((AbsPtrMoveNotify->AbsPtrState.ActiveButtons & EFI_ABSP_TouchActive) == EFI_ABSP_TouchActive &&
        (AbsPtrMoveNotify->AbsPtrState.ActiveButtons & EFI_ABSP_TouchActive) != (PreviousActiveButtons & EFI_ABSP_TouchActive)) {
      //
      // Left Button
      //
      InputData.KeyData.Key.ScanCode    = SCAN_NULL;
      InputData.KeyData.Key.UnicodeChar = CHAR_CARRIAGE_RETURN;
    }
    if ((AbsPtrMoveNotify->AbsPtrState.ActiveButtons & EFI_ABS_AltActive) == EFI_ABS_AltActive &&
        (AbsPtrMoveNotify->AbsPtrState.ActiveButtons & EFI_ABS_AltActive) != (PreviousActiveButtons & EFI_ABS_AltActive)) {
      //
      // Right Button
      //
      InputData.KeyData.Key.ScanCode    = SCAN_ESC;
      InputData.KeyData.Key.UnicodeChar = CHAR_NULL;
    }
    PreviousActiveButtons = AbsPtrMoveNotify->AbsPtrState.ActiveButtons;
    RealMouseX = (INT32)AbsPtrMoveNotify->AbsPtrState.CurrentX;
    RealMouseY = (INT32)AbsPtrMoveNotify->AbsPtrState.CurrentY;
    Status = TransferToTextModePosition (RealMouseX, RealMouseY, &InputData.CursorX, &InputData.CursorY);
    break;

  default:
    return EFI_UNSUPPORTED;
  }

  if (EFI_ERROR (Status)) {
    return Status;
  }

  CopyMem (UserInputData, &InputData, sizeof (H2O_DISPLAY_ENGINE_USER_INPUT_DATA));

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
ProcessMouseClick (
  IN H2O_DISPLAY_ENGINE_USER_INPUT_DATA       *UserInputData
  )
{
  EFI_STATUS                                  Status;
  LIST_ENTRY                                  *Link;
  H2O_LTDE_PANEL                              *SelectedPanel;
  H2O_LTDE_PANEL_ITEM                         *SelectedPanelItem;
  H2O_LTDE_CONTROL                            *SelectedControl;

  if (UserInputData == NULL ||
      UserInputData->IsKeyboard ||
      UserInputData->KeyData.Key.UnicodeChar != CHAR_CARRIAGE_RETURN) {
    return EFI_INVALID_PARAMETER;
  }

  if (IsListEmpty (&mDEPrivate->PanelListHead)) {
    return EFI_NOT_FOUND;
  }

  SelectedPanel     = NULL;
  SelectedPanelItem = NULL;
  SelectedControl   = NULL;
  Link              = GetFirstNode (&mDEPrivate->PanelListHead);
  while (!IsNull (&mDEPrivate->PanelListHead, Link)) {
    SelectedPanel = H2O_LTDE_PANEL_FROM_LINK (Link);
    Link          = GetNextNode (&mDEPrivate->PanelListHead, Link);
    if (!IsPointOnField (&SelectedPanel->PanelField, UserInputData->CursorX, UserInputData->CursorY)) {
      continue;
    }

    Status = GetControlByMouse (SelectedPanel, UserInputData->CursorX, UserInputData->CursorY, &SelectedPanelItem, &SelectedControl);
    if (!EFI_ERROR (Status)) {
      break;
    }
  }
  if (SelectedControl == NULL) {
    return EFI_NOT_FOUND;
  }

  switch (SelectedPanel->VfcfPanelInfo->PanelId) {

  case SETUP_PAGE_PANEL_ID:
    return SetupPagePanelProcessMouseClick (SelectedPanel, SelectedPanelItem, SelectedControl, UserInputData);

  case SETUP_MENU_PANEL_ID:
    return SetupMenuPanelProcessMouseClick (SelectedPanel, SelectedPanelItem, SelectedControl);

  case HELP_TEXT_PANEL_ID:
    return HelpTextPanelProcessMouseClick (SelectedPanelItem, SelectedControl);

  case HOTKEY_PANEL_ID:
    return HotKeyPanelProcessMouseClick (SelectedPanel, SelectedPanelItem, SelectedControl, UserInputData);
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
ProcessInputEvtAtMenu (
  IN       H2O_DISPLAY_ENGINE_PRIVATE_DATA    *Private,
  IN CONST H2O_DISPLAY_ENGINE_EVT             *Notify,
  IN       H2O_DISPLAY_ENGINE_USER_INPUT_DATA *UserInputData
  )
{
  EFI_STATUS                                  Status;
  HOT_KEY_INFO                                HotKey;

  Status = ProcessEvtInQuestionFunc (Notify, UserInputData);
  if (!EFI_ERROR (Status)) {
    return Status;
  }

  if (!UserInputData->IsKeyboard && UserInputData->KeyData.Key.ScanCode == SCAN_ESC) {
    UserInputData->IsKeyboard = TRUE;
  }

  if (UserInputData->IsKeyboard) {
    Status = CheckFBHotKey (UserInputData, &HotKey);
    if (!EFI_ERROR (Status)) {
      return SendEvtByHotKey (&HotKey);
    }

    CheckDEHotKey (UserInputData);
  } else {
    if (UserInputData->KeyData.Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
      return ProcessMouseClick (UserInputData);
    }
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
ProcessInputEvtAtPopUpDialog (
  IN       H2O_DISPLAY_ENGINE_PRIVATE_DATA    *Private,
  IN CONST H2O_DISPLAY_ENGINE_EVT             *Notify,
  IN       H2O_DISPLAY_ENGINE_USER_INPUT_DATA *UserInputData
  )
{
  EFI_STATUS                                  Status;

  Status = ProcessEvtInQuestionFunc (Notify, UserInputData);
  if (!EFI_ERROR (Status)) {
    return EFI_SUCCESS;
  }

  if (UserInputData->KeyData.Key.ScanCode == SCAN_ESC) {
    return SendShutDNotify ();
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
ProcessInputEvt (
  IN       H2O_DISPLAY_ENGINE_PRIVATE_DATA    *Private,
  IN CONST H2O_DISPLAY_ENGINE_EVT             *Notify
  )
{
  EFI_STATUS                                  Status;
  H2O_DISPLAY_ENGINE_USER_INPUT_DATA          UserInputData;


  Status = GetUserInputData (Notify, &UserInputData);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  switch (Private->DEStatus) {

  case DISPLAY_ENGINE_STATUS_AT_MENU:
    Status = ProcessInputEvtAtMenu (Private, Notify, &UserInputData);
    break;

  case DISPLAY_ENGINE_STATUS_AT_POPUP_DIALOG:
    Status = ProcessInputEvtAtPopUpDialog (Private, Notify, &UserInputData);
    break;

  default:
    return EFI_UNSUPPORTED;
  }

  return Status;
}

EFI_STATUS
DEEventCallback (
  IN       H2O_DISPLAY_ENGINE_PROTOCOL        *This,
  IN CONST H2O_DISPLAY_ENGINE_EVT             *Notify
  )
{
  H2O_DISPLAY_ENGINE_PRIVATE_DATA             *Private;
  EFI_STATUS                                  Status;
  H2O_FORM_BROWSER_PROTOCOL                   *FBProtocol;
  H2O_DISPLAY_ENGINE_EVT_REFRESH_Q            *RefreshQNotify;

  Private = H2O_DISPLAY_ENGINE_PRIVATE_DATA_FROM_PROTOCOL (This);

  if (IsListEmpty (&Private->ConsoleDevListHead)) {
    //
    // Do nothing
    //
    return EFI_SUCCESS;
  }

  FBProtocol = Private->FBProtocol;
  Status     = EFI_UNSUPPORTED;

  switch (Notify->Type) {

  case H2O_DISPLAY_ENGINE_EVT_TYPE_KEYPRESS:
  case H2O_DISPLAY_ENGINE_EVT_TYPE_REL_PTR_MOVE:
  case H2O_DISPLAY_ENGINE_EVT_TYPE_ABS_PTR_MOVE:
    Status = ProcessInputEvt (Private, Notify);
    break;

  case H2O_DISPLAY_ENGINE_EVT_TYPE_OPEN_L:
    Status = DEOpenLayout (Private);
    break;

  case H2O_DISPLAY_ENGINE_EVT_TYPE_OPEN_P:
    if (IsUserEditingAtMenu ()) {
      break;
    }
    Status = DEShutPage (Private);
    Status = DEOpenPage (Private);
    break;

  case H2O_DISPLAY_ENGINE_EVT_TYPE_OPEN_D:
    Status = DEOpenDialog (FBProtocol, Notify);
    break;

  case H2O_DISPLAY_ENGINE_EVT_TYPE_SHUT_D:
    Status = DEShutDialog (Private, Notify);
    break;

  case H2O_DISPLAY_ENGINE_EVT_TYPE_REFRESH:
    if (IsUserEditingAtMenu ()) {
      break;
    }
    Status = DERefreshSetupPageAndHelp (Private);
    break;

  case H2O_DISPLAY_ENGINE_EVT_TYPE_REFRESH_Q:
    if (Private->DEStatus == DISPLAY_ENGINE_STATUS_AT_POPUP_DIALOG) {
      break;
    }

    RefreshQNotify = (H2O_DISPLAY_ENGINE_EVT_REFRESH_Q *) Notify;
    Status = DERefreshQuestion (RefreshQNotify->PageId, RefreshQNotify->QuestionId, RefreshQNotify->IfrOpCode);
    break;

  case H2O_DISPLAY_ENGINE_EVT_TYPE_SELECT_Q:
    Status = DESelectQuestion (Private, (H2O_DISPLAY_ENGINE_EVT_SELECT_Q *) Notify);
    break;

  case H2O_DISPLAY_ENGINE_EVT_TYPE_SHUT_Q:
    Status = DEShutQuestion (Notify);
    break;

  case H2O_DISPLAY_ENGINE_EVT_TYPE_CHANGING_Q:
    Status = DEChangingQuestion (FBProtocol, Notify);
    break;

  case H2O_DISPLAY_ENGINE_EVT_TYPE_EXIT:
    Status = DEExit ();
    break;

  default:
    ASSERT (FALSE);
    break;
  }

  return Status;
}