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);
    }
}