InGameMenuXbox.c

Go to the documentation of this file.

class InGameMenuXbox extends UIScriptedMenu
{
  // Widgets texts id
  protected string m_MuteButtonTextID;
  protected string m_UnmuteButtonTextID;
  protected string m_BackButtonTextID;
  protected string m_SelectButtonTextID;
  protected string m_OpenGameCardButtonTextID;
  protected string m_CurrentMuteButtonText;
 
  protected bool m_SelectAvailable;
  protected bool m_MuteAvailable;
  protected bool m_BackAvailable;
  protected bool m_GamercardAvailable;
 
  protected bool m_PlayerAlive;
 
  protected ref PlayerListScriptedWidget m_ServerInfoPanel;
 
  protected Widget m_OnlineMenu;
 
  protected ButtonWidget m_ContinueButton;
  protected ButtonWidget m_ExitButton;
  protected ButtonWidget m_RestartDeadButton;
  protected ButtonWidget m_RestartButton;
  protected ButtonWidget m_OptionsButton;
  protected ButtonWidget m_ControlsButton;
  protected ButtonWidget m_OnlineButton;
  protected ButtonWidget m_TutorialsButton;
 
  protected TextWidget m_Version;
 
  const int BUTTON_XBOX_CONTROLS = 201;
 
  void InGameMenuXbox()
  {
    GetGame().GetMission().GetOnInputPresetChanged().Insert(OnInputPresetChanged);
    GetGame().GetMission().GetOnInputDeviceChanged().Insert(OnInputDeviceChanged);
  }
 
  void ~InGameMenuXbox()
  {
    ClientData.SyncEvent_OnPlayerListUpdate.Remove(SyncEvent_OnRecievedPlayerList);
    OnlineServices.m_PermissionsAsyncInvoker.Remove(OnPermissionsUpdate);
 
    Mission mission = GetGame().GetMission();
    if (mission)
    {
      IngameHud hud = IngameHud.Cast(mission.GetHud());
      if (hud)
      {
        hud.ShowHudUI(true);
        hud.ShowQuickbarUI(true);
      }
 
      mission.Continue();
    }
 
    PPERequesterBank.GetRequester(PPERequester_MenuEffects).Stop();
  }
 
  protected void OnInputPresetChanged()
  {
#ifdef PLATFORM_CONSOLE
    UpdateControlsElements();
#endif
  }
 
  protected void OnInputDeviceChanged(EInputDeviceType pInputDeviceType)
  {
    UpdateControlsElements();
  }
 
  override Widget Init()
  {
    layoutRoot = GetGame().GetWorkspace().CreateWidgets("gui/layouts/xbox/day_z_ingamemenu_xbox.layout");
 
    m_OnlineMenu = GetGame().GetWorkspace().CreateWidgets("gui/layouts/xbox/ingamemenu_xbox/online_info_menu.layout", layoutRoot);
    m_OnlineMenu.Show(false);
 
    m_ContinueButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("continuebtn"));
    m_RestartDeadButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("restartbtn_dead"));
    m_ExitButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("exitbtn"));
    m_RestartButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("restartbtn"));
    m_OptionsButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("optionsbtn"));
    m_ControlsButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("controlsbtn"));
    m_OnlineButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("onlinebtn"));
    m_TutorialsButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("tutorialsbtn"));
    m_Version = TextWidget.Cast(layoutRoot.FindAnyWidget("version"));
 
    m_SelectAvailable = true;
    m_MuteAvailable = false;
    m_GamercardAvailable = false;
    m_BackAvailable = true;
 
    Man player = GetGame().GetPlayer();
    if (player)
    {
      int life_state = player.GetPlayerState();
 
      if (life_state == EPlayerStates.ALIVE)
        m_PlayerAlive = true;
    }
 
    UpdateMenuFocus();
 
    string version;
    GetGame().GetVersion(version);
#ifdef PLATFORM_CONSOLE
    version = "#main_menu_version" + " " + version + " (" + g_Game.GetDatabaseID() + ")";
#else
    version = "#main_menu_version" + " " + version;
#endif
    m_Version.SetText(version);
 
    if (GetGame().IsMultiplayer())
    {
      m_OnlineButton.Show(true);
 
      TextWidget w_text = TextWidget.Cast(m_OnlineMenu.FindAnyWidget("OnlineTextWidget"));
      w_text.SetText(g_Game.GetHostName());
 
      m_ServerInfoPanel = new PlayerListScriptedWidget(m_OnlineMenu.FindAnyWidget("ServerInfoPanel"));
 
      OnlineServices.m_PermissionsAsyncInvoker.Insert(OnPermissionsUpdate);
      ClientData.SyncEvent_OnPlayerListUpdate.Insert(SyncEvent_OnRecievedPlayerList);
 
      m_ServerInfoPanel.Reload(ClientData.m_PlayerList);
      m_ServerInfoPanel.ReloadLocal(OnlineServices.GetMuteList());
 
      string uid = m_ServerInfoPanel.FindPlayerByWidget(GetFocus());
      if (uid != "")
      {
        if (IsLocalPlayer(uid) || m_ServerInfoPanel.IsEmpty())
        {
          m_MuteAvailable = false;
          m_GamercardAvailable = false;
        }
        else
        {
          m_MuteAvailable = !GetGame().GetWorld().IsDisabledReceivingVoN();
#ifndef PLATFORM_PS4
          m_GamercardAvailable = true;
#endif
          SetMuteButtonText(OnlineServices.IsPlayerMuted(uid));
        }
 
        if (m_ServerInfoPanel.IsGloballyMuted(uid))
          m_MuteAvailable = false;
      }
    }
    else
    {
      layoutRoot.FindAnyWidget("onlinebtn").Show(false);
      layoutRoot.FindAnyWidget("invitebtn").Show(false);
    }
 
    //RESPAWN & RESTART
    ButtonWidget restart_btn = ButtonWidget.Cast(layoutRoot.FindAnyWidgetById(IDC_INT_RETRY));
    if (GetGame().IsMultiplayer())
      restart_btn.SetText("#main_menu_respawn");
    else
      restart_btn.SetText("#main_menu_restart");
 
    if (GetGame().IsMultiplayer() && !(GetGame().CanRespawnPlayer() || (player && player.IsUnconscious())))
    {
      restart_btn.Enable(false);
      restart_btn.Show(false);
    }
    //
 
#ifdef BULDOZER
    delete restart_btn;
#endif
 
    Mission mission = GetGame().GetMission();
    if (mission)
    {
      IngameHud hud = IngameHud.Cast(mission.GetHud());
      if (hud)
      {
        hud.ShowHudUI(false);
        hud.ShowQuickbarUI(false);
      }
 
      mission.Pause();
    }
 
    PPERequester_MenuEffects requester;
    Class.CastTo(requester, PPERequesterBank.GetRequester(PPERequester_MenuEffects));
    requester.SetVignetteIntensity(0.6);
 
    UpdateControlsElements();
    LoadTextStrings();
    LoadFooterButtonTexts();
 
    OnInputDeviceChanged(GetGame().GetInput().GetCurrentInputDevice());
 
    return layoutRoot;
  }
 
  override bool OnClick(Widget w, int x, int y, int button)
  {
    super.OnClick(w, x, y, button);
 
    switch (w.GetUserID())
    {
    case IDC_MAIN_CONTINUE:
    {
      GetGame().GetCallQueue(CALL_CATEGORY_GUI).Call(GetGame().GetMission().Continue);
      return true;
    }
    case IDC_MAIN_OPTIONS:
    {
      EnterScriptedMenu(MENU_OPTIONS);
      return true;
    }
    case BUTTON_XBOX_CONTROLS:
    {
      EnterScriptedMenu(MENU_XBOX_CONTROLS);
      return true;
    }
    case IDC_MAIN_QUIT:
    {
      GetGame().GetUIManager().ShowDialog("#main_menu_exit", "#main_menu_exit_desc", IDC_INT_EXIT, DBT_YESNO, DBB_YES, DMT_QUESTION, NULL);
      return true;
    }
    case IDC_INT_RETRY:
    {
      if (!GetGame().IsMultiplayer())
        GetGame().GetUIManager().ShowDialog("#main_menu_restart", "Are you sure you want to restart?", IDC_INT_RETRY, DBT_YESNO, DBB_YES, DMT_QUESTION, this);
      else
        GetGame().GetUIManager().ShowDialog("#main_menu_respawn", "#main_menu_respawn_question", IDC_INT_RETRY, DBT_YESNO, DBB_YES, DMT_QUESTION, this);
      return true;
    }
    case IDC_MAIN_ONLINE:
    {
      m_OnlineMenu.Show(true);
      m_SelectAvailable = false;
 
      UpdateControlsElements();
      m_ServerInfoPanel.FocusFirst();
      return true;
    }
    case 117:
    {
      EnterScriptedMenu(MENU_TUTORIAL);
      return true;
    }
    case IDC_MULTI_INVITE:
    {
      OnlineServices.ShowInviteScreen();
      return true;
    }
    }
 
    if (w == layoutRoot.FindAnyWidget("backbtn"))
      CloseOnline();
    else if (w == m_RestartDeadButton)
    {
      if (GetGame().GetMission().GetRespawnModeClient() == GameConstants.RESPAWN_MODE_CUSTOM)
        GetGame().GetCallQueue(CALL_CATEGORY_GUI).Call(GetGame().GetUIManager().EnterScriptedMenu, MENU_RESPAWN_DIALOGUE, this);
      else
        GameRetry(true);
      return true;
    }
 
    return false;
  }
 
  override bool OnModalResult(Widget w, int x, int y, int code, int result)
  {
    super.OnModalResult(w, x, y, code, result);
 
    if (code == IDC_INT_EXIT && result == DBB_YES)
    {
      if (GetGame().IsMultiplayer())
      {
        GetGame().LogoutRequestTime();
        GetGame().GetCallQueue(CALL_CATEGORY_GUI).Call(GetGame().GetMission().CreateLogoutMenu, this);
      }
      else
      {
        // skip logout screen in singleplayer
        GetGame().GetMission().AbortMission();
      }
      g_Game.CancelLoginTimeCountdown();
 
      return true;
 
    }
    else if (code == IDC_INT_EXIT && result == DBB_NO)
      g_Game.CancelLoginTimeCountdown();
    else if (code == IDC_INT_RETRY)
    {
      if (result == DBB_YES)
      {
        if (GetGame().GetMission().GetRespawnModeClient() == GameConstants.RESPAWN_MODE_CUSTOM)
          GetGame().GetCallQueue(CALL_CATEGORY_GUI).Call(GetGame().GetUIManager().EnterScriptedMenu, MENU_RESPAWN_DIALOGUE, this);
        else
        {
          GameRetry(true);
          return true;
        }
      }
      else
        UpdateMenuFocus();
    }
 
    return false;
  }
 
  void GameRetry(bool random)
  {
    if (GetGame().IsMultiplayer())
    {
      //GetGame().GetUIManager().CloseAll();
      GetGame().GetMenuDefaultCharacterData(false).SetRandomCharacterForced(random);
      GetGame().RespawnPlayer();
 
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
      if (player)
      {
        player.SimulateDeath(true);
        GetGame().GetCallQueue(CALL_CATEGORY_GUI).Call(player.ShowDeadScreen, true, 0);
      }
 
      MissionGameplay missionGP = MissionGameplay.Cast(GetGame().GetMission());
      missionGP.DestroyAllMenus();
      missionGP.SetPlayerRespawning(true);
      missionGP.Continue();
 
      Close();
    }
    else
      GetGame().RestartMission();
  }
 
  void MenuRequestRespawn(UIScriptedMenu menu, bool random)
  {
    if (RespawnDialogue.Cast(menu))
      GameRetry(random);
  }
 
  bool IsLocalPlayer(string uid)
  {
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    string local_uid;
    if (GetGame().GetUserManager())
      local_uid = GetGame().GetUserManager().GetSelectedUser().GetUid();
    return (uid == local_uid);
  }
 
  SyncPlayerList CreateFakePlayerList(int player_count)
  {
    SyncPlayerList player_list = new SyncPlayerList;
    player_list.m_PlayerList = new array<ref SyncPlayer>;
    for (int i = 0; i < player_count; i++)
    {
      SyncPlayer sync_player = new SyncPlayer;
      sync_player.m_UID = "uid" + i;
      sync_player.m_PlayerName = "Player " + i;
      player_list.m_PlayerList.Insert(sync_player);
    }
    return player_list;
  }
 
  override void Update(float timeslice)
  {
    UpdateGUI();
 
    if (GetGame().IsMultiplayer() && layoutRoot.FindAnyWidget("OnlineInfo").IsVisible())
    {
      PlayerListEntryScriptedWidget selected;
      if (m_ServerInfoPanel)
        selected = m_ServerInfoPanel.GetSelectedPlayer();
      if (GetUApi().GetInputByID(UAUICtrlX).LocalPress())
      {
        if (selected)
          m_ServerInfoPanel.ToggleMute(selected.GetUID());
        Refresh();
      }
 
#ifndef PLATFORM_PS4
      if (GetUApi().GetInputByID(UAUICtrlY).LocalPress())
      {
        if (selected)
          OnlineServices.ShowUserProfile(selected.GetUID());
      }
#endif
    }
  }
 
  bool ShouldRestartBeVisible(Man player)
  {
    return player && player.IsUnconscious() && !CfgGameplayHandler.GetDisableRespawnInUnconsciousness();
  }
 
 
  void UpdateGUI()
  {
    Man player = GetGame().GetPlayer();
    if (player)
    {
      int life_state = player.GetPlayerState();
      m_PlayerAlive = life_state == EPlayerStates.ALIVE;
    }
 
    if (m_PlayerAlive)
      m_RestartButton.Show(ShouldRestartBeVisible(player));
    else
      m_RestartButton.Show(false);
 
    m_ContinueButton.Show(m_PlayerAlive);
    m_RestartDeadButton.Show(!m_PlayerAlive);
  }
 
  bool IsOnlineOpen()
  {
    return m_OnlineMenu.IsVisible();
  }
 
  void CloseOnline()
  {
    m_OnlineMenu.Show(false);
    m_SelectAvailable = true;
    m_MuteAvailable = false;
    m_GamercardAvailable = false;
    UpdateControlsElements();
 
    SetFocus(m_OnlineButton);
  }
 
  void SelectServer()
  {
    if (m_ServerInfoPanel)
    {
      m_ServerInfoPanel.FocusFirst();
 
      Refresh();
    }
  }
 
  override bool OnItemSelected(Widget w, int x, int y, int row, int column, int oldRow, int oldColumn)
  {
    return false;
  }
 
  void SyncEvent_OnRecievedPlayerList(SyncPlayerList player_list)
  {
    m_ServerInfoPanel.Reload(player_list);
 
    Refresh();
  }
 
  void OnPermissionsUpdate(BiosPrivacyUidResultArray result_list)
  {
    m_ServerInfoPanel.Reload(result_list);
 
    Refresh();
  }
 
  override void OnShow()
  {
    super.OnShow();
    Man player = GetGame().GetPlayer();
    if (player)
    {
      int life_state = player.GetPlayerState();
 
      if (life_state == EPlayerStates.ALIVE)
        m_PlayerAlive = true;
    }
 
    if (m_PlayerAlive)
    {
      if (player)
        m_RestartButton.Show(player.IsUnconscious());
    }
    else
      m_RestartButton.Show(false);
    m_ContinueButton.Show(m_PlayerAlive);
    m_RestartDeadButton.Show(!m_PlayerAlive);
 
    UpdateMenuFocus();
 
#ifdef PLATFORM_CONSOLE
    bool mk = GetGame().GetInput().IsEnabledMouseAndKeyboard();
    bool mk_server = GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer();
    TextWidget warning = TextWidget.Cast(layoutRoot.FindAnyWidget("MouseAndKeyboardWarning"));
    if (mk)
    {
      if (mk_server)
        warning.SetText("#str_mouse_and_keyboard_server_warning");
      else
        warning.SetText("#str_controller_server_warning");
    }
 
    warning.Show(mk);
#endif
    UpdateControlsElements();
  }
 
  override bool OnMouseEnter(Widget w, int x, int y)
  {
    if (IsFocusable(w))
    {
      ColorHighlight(w);
      return true;
    }
    return false;
  }
 
  override bool OnMouseLeave(Widget w, Widget enterW, int x, int y)
  {
    if (IsFocusable(w))
    {
      ColorNormal(w);
      return true;
    }
    return false;
  }
 
  override bool OnFocus(Widget w, int x, int y)
  {
    if (IsFocusable(w))
    {
      ColorHighlight(w);
      return true;
    }
    return false;
  }
 
  override bool OnFocusLost(Widget w, int x, int y)
  {
    if (IsFocusable(w))
    {
      ColorNormal(w);
      return true;
    }
    return false;
  }
 
  bool IsFocusable(Widget w)
  {
    if (w)
    {
      if (w == m_ContinueButton || w == m_ExitButton || w == m_RestartButton || w == m_OptionsButton || w == m_ControlsButton || w == m_OnlineButton || w == m_TutorialsButton);
      return true;
    }
    return false;
  }
 
  override void Refresh()
  {
    string version;
    GetGame().GetVersion(version);
#ifdef PLATFORM_CONSOLE
    version = "#main_menu_version" + " " + version + " (" + g_Game.GetDatabaseID() + ")";
#else
    version = "#main_menu_version" + " " + version;
#endif
    m_Version.SetText(version);
 
    m_MuteAvailable = false;
    m_GamercardAvailable = false;
 
    if (GetGame().IsMultiplayer() && layoutRoot.FindAnyWidget("OnlineInfo").IsVisible() && m_ServerInfoPanel)
    {
      PlayerListEntryScriptedWidget selected = m_ServerInfoPanel.GetSelectedPlayer();
      if (selected && !selected.IsLocalPlayer())
      {
        m_MuteAvailable = !GetGame().GetWorld().IsDisabledReceivingVoN() && !selected.IsGloballyMuted();
#ifndef PLATFORM_PS4
        m_GamercardAvailable = true;
#endif
        SetMuteButtonText(selected.IsMuted());
      }
    }
 
    UpdateControlsElements();
  }
 
  void ColorDisable(Widget w)
  {
#ifdef PLATFORM_WINDOWS
    SetFocus(null);
#endif
 
    ButtonWidget button = ButtonWidget.Cast(w);
    if (button && button != m_ContinueButton)
      button.SetTextColor(ARGB(255, 255, 255, 255));
    ButtonSetColor(w, ARGB(0, 0, 0, 0));
    ButtonSetTextColor(w, ARGB(60, 0, 0, 0));
  }
 
  void ColorHighlight(Widget w)
  {
    if (!w)
      return;
 
    int color_pnl = ARGB(255, 0, 0, 0);
    int color_lbl = ARGB(255, 255, 0, 0);
 
#ifdef PLATFORM_CONSOLE
    color_pnl = ARGB(255, 200, 0, 0);
    color_lbl = ARGB(255, 255, 255, 255);
#endif
 
    ButtonSetColor(w, color_pnl);
    ButtonSetTextColor(w, color_lbl);
  }
 
  void ColorNormal(Widget w)
  {
    if (!w)
      return;
 
    int color_pnl = ARGB(0, 0, 0, 0);
    int color_lbl = ARGB(255, 255, 255, 255);
 
    ButtonSetColor(w, color_pnl);
    ButtonSetTextColor(w, color_lbl);
  }
 
  void ButtonSetText(Widget w, string text)
  {
    if (!w)
      return;
 
    TextWidget label = TextWidget.Cast(w.FindWidget(w.GetName() + "_label"));
 
    if (label)
      label.SetText(text);
 
  }
 
  void ButtonSetColor(Widget w, int color)
  {
    if (!w)
      return;
 
    Widget panel = w.FindWidget(w.GetName() + "_panel");
 
    if (panel)
      panel.SetColor(color);
  }
 
  void ButtonSetTextColor(Widget w, int color)
  {
    if (!w)
      return;
 
    TextWidget label = TextWidget.Cast(w.FindAnyWidget(w.GetName() + "_label"));
    TextWidget text = TextWidget.Cast(w.FindAnyWidget(w.GetName() + "_text"));
    TextWidget text2 = TextWidget.Cast(w.FindAnyWidget(w.GetName() + "_text_1"));
 
    if (label)
      label.SetColor(color);
 
    if (text)
      text.SetColor(color);
 
    if (text2)
      text2.SetColor(color);
  }
 
  protected void SetMuteButtonText(bool isMuted)
  {
    if (isMuted)
      m_CurrentMuteButtonText = m_UnmuteButtonTextID;
    else
      m_CurrentMuteButtonText = m_MuteButtonTextID;
  }
 
  protected void LoadTextStrings()
  {
#ifdef PLATFORM_PS4
    m_MuteButtonTextID = "#ps4_ingame_menu_mute";
    m_UnmuteButtonTextID = "#ps4_ingame_menu_unmute";
    m_BackButtonTextID = "#ps4_ingame_menu_back";
    m_SelectButtonTextID = "#ps4_ingame_menu_select";
    m_OpenGameCardButtonTextID = "#ps4_ingame_menu_opencard";
#else
    m_MuteButtonTextID = "#xbox_ingame_menu_mute";
    m_UnmuteButtonTextID = "#xbox_ingame_menu_unmute";
    m_BackButtonTextID = "#STR_rootFrame_toolbar_bg_ConsoleToolbar_Back_BackText0";
    m_SelectButtonTextID = "#layout_xbox_ingame_menu_select";
    m_OpenGameCardButtonTextID = "#layout_xbox_ingame_menu_gamecard";
#endif
  }
 
  protected void LoadFooterButtonTexts()
  {
    TextWidget uiGamecardText = TextWidget.Cast(layoutRoot.FindAnyWidget("GamercardText"));
    TextWidget uiBackText = TextWidget.Cast(layoutRoot.FindAnyWidget("BackText"));
    TextWidget uiSelectText = TextWidget.Cast(layoutRoot.FindAnyWidget("SelectText"));
 
    if (uiGamecardText)
      uiGamecardText.SetText(m_OpenGameCardButtonTextID);
    if (uiBackText)
      uiBackText.SetText(m_BackButtonTextID);
    if (uiSelectText)
      uiSelectText.SetText(m_SelectButtonTextID);
  }
 
  void UpdateMenuFocus()
  {
    Man player = GetGame().GetPlayer();
    if (m_PlayerAlive)
    {
      if (ShouldRestartBeVisible(player))
        SetFocus(m_RestartButton);
      else
        SetFocus(m_ContinueButton);
    }
    else
      SetFocus(m_RestartDeadButton);
  }
 
  protected void UpdateControlsElements()
  {
    bool toolbarShow = false;
#ifdef PLATFORM_CONSOLE
    toolbarShow = !GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer() || GetGame().GetInput().GetCurrentInputDevice() == EInputDeviceType.CONTROLLER;
#endif
 
    if (toolbarShow)
    {
      RichTextWidget toolbar_text = RichTextWidget.Cast(layoutRoot.FindAnyWidget("ContextToolbarText"));
      string text = "";
      if (m_SelectAvailable)
        text += string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUISelect", m_SelectButtonTextID, EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
      if (m_MuteAvailable)
        text += string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUICtrlX", m_CurrentMuteButtonText, EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
      if (m_BackAvailable)
        text += string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUIBack", m_BackButtonTextID, EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
      if (m_GamercardAvailable)
        text += string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUICtrlY", m_OpenGameCardButtonTextID, EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 
      toolbar_text.SetText(text);
    }
 
    RichTextWidget toolbar_b2 = RichTextWidget.Cast(layoutRoot.FindAnyWidget("BackIcon0"));
    toolbar_b2.SetText(InputUtils.GetRichtextButtonIconFromInputAction("UAUIBack", "", EUAINPUT_DEVICE_CONTROLLER));
 
    bool onlineOpen = IsOnlineOpen();
    layoutRoot.FindAnyWidget("toolbar_bg").Show(toolbarShow);
    layoutRoot.FindAnyWidget("play_panel_root").Show(!onlineOpen);
    layoutRoot.FindAnyWidget("play_panel_root2").Show(onlineOpen && !toolbarShow);
    layoutRoot.FindAnyWidget("dayz_logo").Show(!onlineOpen);
  }
}