serverbrowsertabconsolepages.c

Go to the documentation of this file.

class ServerBrowserTabConsolePages extends ServerBrowserTab
{
 private bool m_IsFilterChanged;
 private bool m_IsFilterFocused;
 protected bool m_MouseKeyboardControlled
 
 private Widget m_WidgetNavFilters;
 private Widget m_WidgetNavServers;
 
 protected Widget m_ButtonPageLeftImg;
 protected Widget m_ButtonPageRightImg;
 
 protected int m_PreviousPage;
 protected int m_TotalServersCount;
 protected int m_PageStartNum;
 protected int m_PageEndNum;
 protected int m_PagesCount;
 protected int m_ServersEstimateCount;
 protected int m_TimeLastServerRefresh;
 protected int m_TimeLastServerRefreshHoldButton;
 
 protected Widget m_PnlPagesPanel;
 protected TextWidget m_PnlPagesLoadingText;
 protected ref array<ref ServerBrowserEntry> m_ServerListEntiers;
 
 protected override void Construct( Widget parent, ServerBrowserMenuNew menu, TabType type )
 {
 m_Root = GetGame().GetWorkspace().CreateWidgets( "gui/layouts/new_ui/server_browser/xbox/server_browser_tab_console_pages.layout", parent );
 
 m_ServerListScroller = ScrollWidget.Cast( m_Root.FindAnyWidget( "server_list_scroller" ) );
 m_ServerList = SpacerBaseWidget.Cast( m_ServerListScroller.FindAnyWidget( "server_list_content" ) );
 m_ServerListScroller.VScrollToPos01( 0 );
 
 m_ServerListEntiers = new array<ref ServerBrowserEntry>;
 m_EntryWidgets = new map<string, ref ServerBrowserEntry>;
 m_EntriesSorted = new map<ESortType, ref array<ref GetServersResultRow>>;
 
 m_EntriesSorted[ESortType.HOST] = new array<ref GetServersResultRow>;
 m_EntriesSorted[ESortType.POPULATION] = new array<ref GetServersResultRow>;
 
 m_Menu = menu;
 m_TabType = type;
 
 m_ApplyFilter = m_Root.FindAnyWidget( "apply_filter_button" );
 m_ResetFilters = m_Root.FindAnyWidget( "reset_filter_button" );
 m_RefreshList = m_Root.FindAnyWidget( "refresh_list_button" );
 m_FiltersChanged = m_Root.FindAnyWidget( "unapplied_filters_notify" );
 m_HostSort = m_Root.FindAnyWidget( "server_list_content_header_host" );
 m_TimeSort = m_Root.FindAnyWidget( "server_list_content_header_time" );
 m_PopulationSort = m_Root.FindAnyWidget( "server_list_content_header_population" );
 m_SlotsSort = m_Root.FindAnyWidget( "server_list_content_header_slots" );
 m_PingSort = m_Root.FindAnyWidget( "server_list_content_header_ping" );
 m_FilterSearchText = m_Root.FindAnyWidget( "search_name_button" );
 m_FilterSearchTextBox = m_Root.FindAnyWidget( "search_name_setting_option" );
 m_LoadingText = TextWidget.Cast( m_Root.FindAnyWidget( "loading_servers_info" ) );
 m_WidgetNavFilters = m_Root.FindAnyWidget( "filters_root_nav_wrapper" );
 m_WidgetNavServers = m_Root.FindAnyWidget( "server_list_root_nav_wrapper" );
 
 m_BtnPagePrev = ButtonWidget.Cast( m_Root.FindAnyWidget( "servers_navigation_prev" ) ) ;
 m_BtnPageNext = ButtonWidget.Cast( m_Root.FindAnyWidget( "servers_navigation_next" ) ) ;
 
 #ifdef PLATFORM_PS4
 m_ButtonPageLeftImg = m_Root.FindAnyWidget( "servers_navigation_page_prev_icon_ps4" );
 m_ButtonPageRightImg = m_Root.FindAnyWidget( "servers_navigation_page_next_icon_ps4" );
 m_Root.FindAnyWidget( "servers_navigation_page_prev_icon_xbox" ).Show( false );
 m_Root.FindAnyWidget( "servers_navigation_page_next_icon_xbox" ).Show( false );
 #else
 m_ButtonPageLeftImg = m_Root.FindAnyWidget( "servers_navigation_page_prev_icon_xbox" );
 m_ButtonPageRightImg = m_Root.FindAnyWidget( "servers_navigation_page_next_icon_xbox" );
 m_Root.FindAnyWidget( "servers_navigation_page_prev_icon_ps4" ).Show( false );
 m_Root.FindAnyWidget( "servers_navigation_page_next_icon_ps4" ).Show( false );
 #endif
 
 ShowHideConsoleWidgets(); 
 
 m_Filters = new ServerBrowserFilterContainer( m_Root.FindAnyWidget( "filters_content" ), this );
 
 m_PnlPagesPanel = m_Root.FindAnyWidget( "servers_navigation_spacer" );
 m_PreviousPage = 1;
 SetCurrentPage( 1 );
 m_PnlPagesPanel.Show( true );
 m_LoadingFinished = true;
 
 m_Filters.OnSortChanged( m_Filters.m_SortingFilter.GetValue() );
 SetFocusFilters();
 UpdatePageButtons();
 
 m_Root.SetHandler( this );
 m_FilterSearchTextBox.SetHandler( this );
 
 GetGame().GetMission().GetOnInputDeviceChanged().Insert(OnInputDeviceChanged);
 
 OnInputDeviceChanged(GetGame().GetInput().GetCurrentInputDevice());
 }
 
 void ShowHideConsoleWidgets()
 {
 bool is_xbox = true;
 
#ifdef PLATFORM_PS4
 is_xbox = false;
#endif
 
 m_Root.FindAnyWidget( "filters_button_wrapper" ).Show( GetGame().GetInput().IsEnabledMouseAndKeyboard() );
 
 m_Root.FindAnyWidget( "filters_root_nav_img_lb_xbox" ).Show( is_xbox );
 m_Root.FindAnyWidget( "filters_root_nav_img_rb_xbox" ).Show( is_xbox );
 m_Root.FindAnyWidget( "server_list_root_nav_img_lb_xbox" ).Show( is_xbox );
 m_Root.FindAnyWidget( "server_list_root_nav_img_rb_xbox" ).Show( is_xbox );
 
 m_Root.FindAnyWidget( "filters_root_nav_img_l1_ps4" ).Show( !is_xbox );
 m_Root.FindAnyWidget( "filters_root_nav_img_r1_ps4" ).Show( !is_xbox );
 m_Root.FindAnyWidget( "server_list_root_nav_img_l1_ps4" ).Show( !is_xbox );
 m_Root.FindAnyWidget( "server_list_root_nav_img_r1_ps4" ).Show( !is_xbox );
 }
 
 protected void OnInputDeviceChanged(EInputDeviceType pInputDeviceType)
 {
 switch (pInputDeviceType)
 {
 case EInputDeviceType.CONTROLLER:
 ShowHideConsoleWidgets();
 UpdatePageButtons();
 m_WidgetNavFilters.Show(m_IsFilterFocused);
 m_WidgetNavServers.Show(!m_IsFilterFocused);
 m_MouseKeyboardControlled = false;
 break;
 
 default:
 if (GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer())
 {
 m_WidgetNavFilters.Show(false);
 m_WidgetNavServers.Show(false);
 m_ButtonPageLeftImg.Show(false);
 m_ButtonPageRightImg.Show(false);
 m_MouseKeyboardControlled = true;
 }
 break;
 }
 }
 
 override void OnLoadServersAsyncConsole( GetServersResult result_list, EBiosError error, string response )
 { 
 if ( error != EBiosError.OK )
 {
 m_LoadingText.SetText( string.Format("Error: %1", ErrorModuleHandler.GetClientMessage(ErrorCategory.BIOSError, error)) );
 m_Menu.SetServersLoadingTab( TabType.NONE );
 m_LoadingFinished = true;
 SetFocusFilters();
 return;
 }
 
 m_PagesCount = result_list.m_Pages;
 m_TotalServersCount = result_list.m_NumServers;
 
 LoadEntries( result_list.m_Page, result_list.m_Results ); 
 
 if (m_TotalLoadedServers == 0)
 {
 SetFocusFilters();
 }
 
 OnLoadServersAsyncFinished();
 UpdatePageButtons();
 }
 
 void OnLoadServersAsyncFinished()
 {
 string msg = "#servers_found: " + m_TotalLoadedServers;
 if ( m_TotalLoadedServers == 0 )
 {
 msg = "#server_browser_tab_unable_to_get_server";
 }
 m_LoadingText.SetText( msg );
 m_LoadingFinished = true;
 
 m_Menu.SetServersLoadingTab( TabType.NONE );
 }
 
 protected void LoadEntries( int cur_page_index , GetServersResultRowArray page_entries )
 {
 int index = 0;
 ServerBrowserEntry entry;
 m_TotalLoadedServers = m_TotalServersCount;
 
 if ( !m_Menu || m_Menu.GetServersLoadingTab() != m_TabType )
 {
 return;
 }
 
 // only load servers if they correspond to current page
 if (cur_page_index != m_CurrentPageNum)
 {
 return;
 }
 
 if ( m_PagesCount && page_entries )
 {
 foreach ( GetServersResultRow result : page_entries )
 {
 if ( PassFilter( result ) )
 {
 string ipPort = result.GetIpPort();
 bool isFavorited = m_Menu.IsFavorited(ipPort);
 
 entry = GetServerEntryByIndex( index );
 entry.SetIsOnline(true);
 entry.FillInfo( result );
 entry.SetFavorite(isFavorited);
 entry.UpdateEntry();
 
 if (isFavorited && m_OnlineFavServers.Find(ipPort) == -1)
 {
 m_OnlineFavServers.Insert(ipPort);
 }
 
 m_EntryWidgets.Insert(ipPort, entry);
 m_EntriesSorted[m_SortType].Insert( result );
 
 index++;
 }
 
 if ( !m_Menu || m_Menu.GetServersLoadingTab() != m_TabType )
 {
 return;
 }
 }
 }
 
 LoadExtraEntries(index);
 m_ServerList.Update();
 SetFocusServers();
 }
 
 protected ServerBrowserEntry GetServerEntryByIndex( int index )
 {
 ServerBrowserEntry entry;
 
 if ( index >= 0 )
 {
 if ( index < m_ServerListEntiers.Count() )
 {
 entry = m_ServerListEntiers[index];
 }
 else
 {
 entry = new ServerBrowserEntry( m_ServerList, index, this ); 
 m_ServerListEntiers.Insert(entry);
 }
 }
 else
 {
 return null;
 }
 
 entry.Show( true );
 
 return entry;
 }
 
 override void OnFilterChanged()
 {
 m_IsFilterChanged = true;
 }
 
 bool CanRefreshServerList()
 { 
 return m_LoadingFinished;
 }
 
 override void RefreshList()
 {
 for ( int i = 0; i < m_ServerListEntiers.Count(); i++ )
 {
 m_ServerListEntiers[i].Show(false);
 }
 
 for ( int j = 0; j < m_EntriesSorted.Count(); j++ )
 {
 array<ref GetServersResultRow> result_rows = m_EntriesSorted.GetElement(j);
 
 if ( result_rows )
 {
 result_rows.Clear();
 }
 }
 
 m_IsFilterChanged = false;
 m_Filters.SaveFilters();
 
 super.RefreshList();
 
 m_ServerListScroller.VScrollToPos01( 0 );
 
 m_LoadingText.SetText( "#dayz_game_loading" );
 }
 
 override void ResetFilters()
 {
 super.ResetFilters();
 
 m_IsFilterChanged = false;
 }
 
 override void ApplyFilters()
 {
 if ( m_IsFilterChanged )
 {
 SetCurrentPage(1);
 }
 
 m_IsFilterChanged = false;
 m_CurrentFilterInput = m_Filters.GetFilterOptionsConsoles();
 RefreshList();
 }
 
 override void PressA()
 {
 
 }
 
 override void PressX()
 {
 if ( (GetGame().GetTime() - m_TimeLastServerRefresh) > 1000 )
 {
 m_TimeLastServerRefresh = GetGame().GetTime();
 
 if ( m_IsFilterChanged)
 {
 SetCurrentPage(1);
 }
 m_OnlineFavServers.Clear();
 RefreshList();
 }
 
 }
 
 override void PressY()
 {
 switch ( m_SelectedPanel )
 {
 case SelectedPanel.BROWSER:
 {
 if ( m_SelectedServer )
 {
 m_Menu.ServerListFocus( true, m_SelectedServer.ToggleFavorite() );
 }
 break;
 }
 case SelectedPanel.FILTERS:
 {
 if ( m_Filters )
 {
 m_Filters.ResetFilters();
 }
 break;
 }
 }
 }
 
 override void Left()
 {
 if ( !m_IsFilterFocused )
 {
 int curr_page = GetCurrentPage();
 m_PreviousPage = curr_page;
 if ( curr_page > 1 )
 {
 SetCurrentPage( curr_page - 1 );
 UpdatePageButtons();
 }
 }
 }
 
 override void LeftHold()
 {
 if ( !m_IsFilterFocused )
 {
 if ( (GetGame().GetTime() - m_TimeLastServerRefreshHoldButton) > 100 )
 {
 m_TimeLastServerRefreshHoldButton = GetGame().GetTime();
 Left();
 }
 } 
 }
 
 override void LeftRelease()
 {
 if ( !m_IsFilterFocused && GetCurrentPage() != m_PreviousPage )
 {
 RefreshList();
 }
 }
 
 override void Right()
 {
 if ( !m_IsFilterFocused )
 {
 int curr_page = GetCurrentPage();
 m_PreviousPage = curr_page;
 if ( curr_page < m_PagesCount )
 {
 SetCurrentPage( curr_page + 1 );
 UpdatePageButtons();
 }
 }
 }
 
 override void RightHold()
 {
 if ( !m_IsFilterFocused )
 {
 if ( (GetGame().GetTime() - m_TimeLastServerRefreshHoldButton) > 100 )
 { 
 m_TimeLastServerRefreshHoldButton = GetGame().GetTime();
 Right();
 }
 }
 }
 
 override void RightRelease()
 {
 if ( !m_IsFilterFocused && GetCurrentPage() != m_PreviousPage )
 {
 RefreshList();
 }
 }
 
 override void PressSholderLeft()
 {
 if ( m_IsFilterFocused )
 {
 SetFocusServers();
 }
 else
 {
 SetFocusFilters();
 }
 }
 
 override void PressSholderRight()
 {
 if ( m_IsFilterFocused )
 {
 SetFocusServers();
 }
 else
 {
 SetFocusFilters();
 }
 }
 override void Focus()
 {
 if ( m_EntryWidgets.Contains( m_CurrentSelectedServer ) )
 {
 m_EntryWidgets.Get( m_CurrentSelectedServer ).Focus();
 ScrollToEntry( m_EntryWidgets.Get( m_CurrentSelectedServer ) );
 }
 
 array<ref GetServersResultRow> entries = m_EntriesSorted[m_SortType];
 if ( entries && entries.Count() > 0 )
 SetFocusServers();
 else
 SetFocusFilters();
 }
 
 
 void SetFocusFilters()
 {
 SetEnableFilters(true);
 SetEnableServers(false);
 
 // if loaded servers is 0, then hide Top navigation menu <Left / Right>
 if (!m_MouseKeyboardControlled)
 {
 m_WidgetNavFilters.Show(true);
 m_WidgetNavServers.Show(false);
 }
 
 m_Filters.Focus();
 m_IsFilterFocused = true;
 
 UpdatePageButtons();
 }
 
 void SetFocusServers()
 {
 SetEnableServers(true);
 SetEnableFilters(false);
 
 if (!m_MouseKeyboardControlled)
 {
 m_WidgetNavFilters.Show(false);
 m_WidgetNavServers.Show(true);
 }
 
 array<ref GetServersResultRow> entries = m_EntriesSorted[m_SortType];
 if ( entries && entries.Count() > 0 )
 {
 m_EntryWidgets.Get(entries.Get(0).GetIpPort()).Focus();
 }
 else
 {
 SetFocus( null );
 }
 
 m_IsFilterFocused = false;
 m_Menu.ShowYButton(true);
 m_Menu.ShowAButton(true);
 
 UpdatePageButtons();
 }
 
 void SetEnableFilters(bool enable)
 { 
 Widget w_filters = m_Root.FindAnyWidget("filters_content");
 Widget w_content = m_Root.FindAnyWidget("server_list_scroller");
 w_content.Enable( !enable );
 
 if ( enable )
 {
 SetFocus( ButtonWidget.Cast(w_filters.FindWidget("sort_button")) );
 }
 }
 
 void SetEnableServers(bool enable)
 { 
 Widget w_filters = m_Root.FindAnyWidget("filters_content");
 Widget w_content = m_Root.FindAnyWidget("server_list_scroller");
 w_content.Enable( enable );
 }
 
 void UpdatePageButtons()
 {
 TextWidget wgt_page_stat = TextWidget.Cast( m_Root.FindAnyWidget( "servers_navigation_page_status" ) ); 
 
 wgt_page_stat.SetText( GetCurrentPage().ToString() +" / "+ m_PagesCount.ToString() );
 
 if ( !m_IsFilterFocused && (m_PagesCount > 1) && !m_MouseKeyboardControlled )
 {
 bool can_left = (GetCurrentPage() > 1);
 m_ButtonPageLeftImg.Show( can_left );
 m_BtnPagePrev.Show( can_left );
 
 bool can_right = (GetCurrentPage() < m_PagesCount);
 m_ButtonPageRightImg.Show( can_right );
 m_BtnPageNext.Show( can_right );
 }
 else
 {
 m_ButtonPageLeftImg.Show( false );
 m_BtnPagePrev.Show( false );
 m_ButtonPageRightImg.Show( false );
 m_BtnPageNext.Show( false );
 }
 }
 
 override bool OnClick( Widget w, int x, int y, int button )
 {
 super.OnClick( w, x, y, button );
 
 if ( button == MouseState.LEFT )
 {
 if ( w == m_ResetFilters )
 {
 ResetFilters();
 }
 else if ( w == m_ApplyFilter )
 {
 ApplyFilters();
 return true;
 }
 else if ( w == m_RefreshList )
 {
 if ( m_Loading && !m_LoadingFinished )
 {
 PressX();
 }
 else
 {
 RefreshList();
 }
 
 return true;
 }
 else if ( w == m_BtnPagePrev )
 {
 Left();
 return true;
 }
 else if ( w == m_BtnPageNext )
 {
 Right();
 return true;
 }
 }
 return false;
 }
 
 //Coloring functions (Until WidgetStyles are useful)
 override void ColorHighlight( Widget w )
 {
 if ( !w )
 {
 return;
 }
 
 w.SetColor( ARGB( 255, 200, 0, 0) );
 }
 
 override void ColorNormal( Widget w )
 {
 if ( !w )
 {
 return
 }
 
 if ( (w.GetFlags() & WidgetFlags.IGNOREPOINTER) == WidgetFlags.IGNOREPOINTER )
 {
 return;
 }
 
 if ( w.IsInherited( ButtonWidget ) )
 {
 ButtonWidget button = ButtonWidget.Cast( w );
 button.SetTextColor( ARGB( 255, 255, 255, 255 ) );
 }
 else if ( !w.IsInherited( EditBoxWidget ) )
 {
 w.SetColor( ARGB( 0, 255, 255, 255 ) );
 }
 
 TextWidget text1 = TextWidget.Cast(w.FindAnyWidget( w.GetName() + "_text" ) );
 TextWidget text2 = TextWidget.Cast(w.FindAnyWidget( w.GetName() + "_text_1" ) );
 TextWidget text3 = TextWidget.Cast(w.FindAnyWidget( w.GetName() + "_label" ) );
 ImageWidget image = ImageWidget.Cast( w.FindAnyWidget( w.GetName() + "_image" ) );
 
 Widget option = Widget.Cast( w.FindAnyWidget( w.GetName() + "_option_wrapper" ) );
 
 if ( text1 )
 {
 text1.SetColor( ARGB( 255, 255, 255, 255 ) );
 }
 
 if ( text2 )
 {
 text2.SetColor( ARGB( 255, 255, 255, 255 ) );
 }
 
 if ( text3 )
 {
 text3.SetColor( ARGB( 255, 255, 255, 255 ) );
 w.SetAlpha(0);
 }
 
 if ( image )
 {
 image.SetColor( ARGB( 255, 255, 255, 255 ) );
 }
 
 if ( option )
 {
 option.SetColor( ARGB( 150, 255, 255, 255 ) );
 }
 }
 
 override void ColorDisable( Widget w )
 {
 #ifdef PLATFORM_WINDOWS
 SetFocus( null );
 #endif
 
 ButtonWidget button = ButtonWidget.Cast( w );
 if ( button )
 {
 button.SetTextColor( ColorManager.COLOR_DISABLED_TEXT );
 }
 }
}