serverbrowsertab.c

Go to the documentation of this file.

enum TabType
{
 OFFICIAL,
 COMMUNITY,
 LAN,
 FAVORITE,
 NONE
}
 
enum SelectedPanel
{
 BROWSER,
 FILTERS,
 MENU
}
 
class ServerBrowserTab extends ScriptedWidgetEventHandler
{
 protected Widget m_Root;
 protected ScrollWidget m_ServerListScroller;
 protected SpacerBaseWidget m_ServerList;
 
 //protected ref array<ref GetServersResultRow> m_Entries;
 
 protected ref map<string, ref ServerBrowserEntry> m_EntryWidgets;
 protected ref map<string, ref array<string>> m_EntryMods;
 
 protected ref ServerBrowserFilterContainer m_Filters;
 
 protected ServerBrowserMenuNew m_Menu;
 protected ServerBrowserEntry m_SelectedServer;
 
 protected TabType m_TabType;
 protected ESortType m_SortType;
 protected ESortOrder m_SortOrder;
 
 protected SelectedPanel m_SelectedPanel;
 protected bool m_Initialized;
 protected bool m_BegunLoading;
 protected bool m_Loading;
 protected int m_TotalServers; // UNUSED
 protected int m_TotalLoadedServers;
 protected int m_LastLoadedPage;
 protected int m_TotalPages;
 protected bool m_LoadingFinished;
 protected int m_CurrentPageNum;
 
 protected string m_CurrentSelectedServer;
 protected int m_CurrentLoadedPage;
 protected ref GetServersInput m_CurrentFilterInput;
 
 protected Widget m_ApplyFilter;
 protected Widget m_RefreshList;
 protected Widget m_ResetFilters;
 protected Widget m_FiltersChanged;
 protected Widget m_HostSort;
 protected Widget m_TimeSort;
 protected Widget m_PopulationSort;
 protected Widget m_SlotsSort;
 protected Widget m_PingSort;
 protected Widget m_FilterSearchText;
 protected Widget m_FilterSearchTextBox;
 protected TextWidget m_LoadingText;
 protected ButtonWidget m_BtnPagePrev;
 protected ButtonWidget m_BtnPageNext;
 
 protected ref map<ESortType, ref array<ref GetServersResultRow>> m_EntriesSorted;
 protected ref map<ESortType, ESortOrder> m_SortInverted;
 protected ref set<string> m_OnlineFavServers;
 
 void ServerBrowserTab( Widget parent, ServerBrowserMenuNew menu, TabType type )
 {
 Construct(parent, menu, type);
 m_OnlineFavServers = new set<string>();
 GetGame().GetContentDLCService().m_OnChange.Insert(OnDLCChange);
 }
 
 protected void Construct( Widget parent, ServerBrowserMenuNew menu, TabType type )
 {
 m_SortInverted = new map<ESortType, ESortOrder>;
 m_EntriesSorted = new map<ESortType, ref array<ref GetServersResultRow>>;
 m_EntryMods = new map<string, ref array<string>>;
 m_LoadingText = TextWidget.Cast( m_Root.FindAnyWidget( "loading_servers_info" ) );
 }
 
 void ~ServerBrowserTab()
 {
 if ( m_Filters )
 m_Filters.SaveFilters();
 
 if (m_Root)
 delete m_Root;
 
 if (GetGame().GetContentDLCService())
 GetGame().GetContentDLCService().m_OnChange.Remove(OnDLCChange);
 }
 
 ServerBrowserMenuNew GetRootMenu()
 {
 return m_Menu;
 }
 
 bool GetIsServerLoadingFinished()
 {
 return m_LoadingFinished;
 }
 
 override bool OnClick( Widget w, int x, int y, int button )
 {
 
 }
 
 void OnDLCChange(EDLCId dlcId)
 {
 switch (dlcId)
 {
 case EDLCId.DLC_BLISS:
 {
 array<ServerBrowserEntry> serverEntries = m_EntryWidgets.GetValueArray();
 foreach (ServerBrowserEntry entry : serverEntries)
 {
 entry.RefreshDLCIcon();
 }
 break;
 }
 
 default:
 break;
 }
 }
 
 void ScrollToEntry( ServerBrowserEntry entry )
 {
 if ( entry )
 {
 float x, y;
 float x_s, y_s;
 float x_l, y_l;
 
 Widget root = entry.GetRoot();
 Widget first_child = root.GetParent().GetChildren();
 Widget last_child = first_child;
 while ( last_child )
 {
 if ( last_child.GetSibling() )
 last_child = last_child.GetSibling();
 else
 break;
 }
 
 root.GetParent().Update();
 root.Update();
 
 m_ServerListScroller.GetScreenPos( x, y );
 m_ServerListScroller.GetScreenSize( x_s, y_s );
 
 float bottom_pos = y + y_s;
 
 root.GetScreenPos( x_l, y_l );
 root.GetScreenSize( x_s, y_s );
 
 if ( root == first_child )
 {
 m_ServerListScroller.VScrollToPos01( 0 );
 }
 else if ( root == last_child )
 {
 m_ServerListScroller.VScrollToPos01( 1 );
 }
 else if ( y_l + y_s >= bottom_pos )
 {
 m_ServerListScroller.VScrollToPos( m_ServerListScroller.GetVScrollPos() + y_s );
 }
 else if ( y_l <= y )
 {
 m_ServerListScroller.VScrollToPos( m_ServerListScroller.GetVScrollPos() - y_s );
 }
 }
 }
 
 void Focus()
 {
 if ( m_EntryWidgets.Contains( m_CurrentSelectedServer ) )
 {
 m_EntryWidgets.Get( m_CurrentSelectedServer ).Focus();
 ScrollToEntry( m_EntryWidgets.Get( m_CurrentSelectedServer ) );
 }
 }
 
 void OnFilterFocusLost( Widget w )
 {
 m_SelectedPanel = SelectedPanel.FILTERS;
 m_Menu.FilterFocus( false );
 }
 
 void OnFilterFocus( Widget w )
 {
 m_SelectedPanel = SelectedPanel.FILTERS;
 m_Menu.FilterFocus( true );
 }
 
 void OnFilterChanged()
 {
 
 }
 
 void ServerListFocus( bool focus, bool favorite )
 {
 m_SelectedPanel = SelectedPanel.BROWSER;
 
 if (!m_Menu)
 return;
 
 m_Menu.ServerListFocus( focus, favorite );
 }
 
 override bool OnFocus( Widget w, int x, int y )
 {
 if ( IsFocusable( w ) )
 {
 if ( w == m_FilterSearchTextBox )
 {
 ColorHighlight( m_FilterSearchText );
 return false;
 }
 else
 {
 ColorHighlight( w );
 }
 return true;
 }
 return false;
 }
 
 override bool OnFocusLost( Widget w, int x, int y )
 {
 if ( IsFocusable( w ) )
 {
 if ( w == m_FilterSearchTextBox )
 {
 ColorNormal( m_FilterSearchText );
 return true;
 }
 else
 {
 ColorNormal( w );
 }
 return true;
 }
 return false;
 }
 
 override bool OnMouseEnter( Widget w, int x, int y )
 { 
 if ( IsFocusable( w ) )
 {
 ColorHighlight( w );
 if ( w == m_FilterSearchText )
 {
 SetFocus( m_FilterSearchTextBox );
 return true;
 }
 return true;
 }
 return false;
 }
 
 override bool OnMouseLeave( Widget w, Widget enterW, int x, int y )
 { 
 if ( IsFocusable( w ) )
 {
 if ( enterW == m_FilterSearchText || enterW == m_FilterSearchTextBox )
 {
 }
 else
 {
 ColorNormal( w );
 }
 return true;
 }
 return false;
 }
 
 bool IsFocusable( Widget w )
 {
 if ( w )
 {
 return ( w == m_ApplyFilter || w == m_RefreshList || w == m_ResetFilters || w == m_FilterSearchText || w == m_FilterSearchTextBox );
 }
 return false;
 }
 
 void SetPanelFocus()
 {
 
 }
 
 void PressA()
 {
 
 }
 
 void PressX()
 {
 if ( m_Menu.GetServersLoadingTab() == TabType.NONE )
 RefreshList();
 }
 
 void PressY();
 void PressSholderLeft();
 void PressSholderRight();
 void Left();
 void LeftHold();
 void LeftRelease();
 void Right();
 void RightHold();
 void RightRelease();
 void Up();
 void Down();
 
 void OnLoadServerModsAsync(string server_id, array<string> mods)
 {
 m_EntryMods.Set( server_id, mods );
 }
 
 void GetNextEntry()
 {
 Widget focused = GetFocus();
 if ( !focused )
 return;
 Widget sibling = focused.GetSibling();
 if ( !sibling )
 return;
 
 if ( focused.GetName() == "server_browser_list_entry_root" )
 {
 if ( sibling )
 SetFocus( focused.GetSibling() );
 else
 SetFocus( focused.GetParent().GetSibling().GetChildren() );
 }
 }
 
 void GetPrevEntry()
 {
 Widget focused = GetFocus();
 if ( focused && focused.GetName() == "server_browser_list_entry_root" )
 {
 Widget sibling = focused.GetParent().GetChildren();
 if ( focused == sibling )
 return;
 
 while ( sibling )
 {
 if ( sibling && sibling.GetSibling() == focused )
 {
 SetFocus( sibling );
 }
 else
 {
 sibling = sibling.GetSibling();
 }
 }
 }
 }
 
 void GetNextFilter()
 {
 
 }
 
 void GetPrevFilter()
 {
 
 }
 
 void SetCurrentPage(int page_num)
 {
 m_CurrentPageNum = page_num;
 }
 
 int GetCurrentPage()
 {
 return m_CurrentPageNum;
 }
 
 bool IsNotInitialized()
 {
 return !m_Initialized || !m_LoadingFinished;
 }
 
 void ResetFilters()
 {
 m_Filters.ResetFilters();
 }
 
 void ApplyFilters()
 {
 
 }
 
 void AddFavoritesToFilter( ref GetServersInput input )
 {
 m_Menu.AddFavoritesToFilter( input );
 }
 
 void RefreshList()
 {
 m_Menu.SetServersLoadingTab( m_TabType );
 
 m_LoadingFinished = false;
 m_Initialized = true;
 m_BegunLoading = false;
 m_LastLoadedPage = 0;
 m_TotalPages = -1;
 m_TotalServers = 0;
 m_TotalLoadedServers = 0;
 m_CurrentLoadedPage = 0;
 
 m_EntryWidgets.Clear();
 
 #ifndef PLATFORM_WINDOWS // XBOX OR PS
 m_CurrentFilterInput = m_Filters.GetFilterOptionsConsoles();
 m_CurrentFilterInput.m_Page = GetCurrentPage();
 m_CurrentFilterInput.m_SortBy = GetSortOption();
 m_CurrentFilterInput.m_SortOrder = m_SortOrder;
 #else // PLATFORM_WINDOWS
 m_CurrentFilterInput = m_Filters.GetFilterOptionsPC();
 #ifdef PLATFORM_CONSOLE // PC client with -XBOX flag
 m_CurrentFilterInput.m_Page = GetCurrentPage();
 #else 
 m_CurrentFilterInput.m_Page = 0;
 #endif
 #endif
 
 m_Loading = true;
 switch ( m_TabType )
 {
 case TabType.OFFICIAL:
 {
 m_CurrentFilterInput.SetOfficialFilter( true );
 OnlineServices.LoadServers( m_CurrentFilterInput );
 break;
 }
 case TabType.COMMUNITY:
 {
 m_CurrentFilterInput.SetOfficialFilter( false );
 OnlineServices.LoadServers( m_CurrentFilterInput );
 break;
 }
 case TabType.LAN:
 {
 m_CurrentFilterInput.SetLAN();
 OnlineServices.LoadServers( m_CurrentFilterInput );
 break;
 }
 }
 }
 
 void GetNextPage()
 {
 if ( m_TotalPages > 0 && m_LastLoadedPage < m_TotalPages )
 {
 m_CurrentFilterInput.m_Page = m_LastLoadedPage + 1;
 OnlineServices.LoadServers( m_CurrentFilterInput );
 }
 }
 
 void SelectServer( ServerBrowserEntry server )
 {
#ifdef PLATFORM_CONSOLE
 ScrollToEntry( server );
#endif
 
 m_SelectedServer = server;
 
 if (!m_Menu)
 return;
 
 m_Menu.SelectServer( server );
 }
 
 void OnLoadServersAsyncPC( ref GetServersResult result_list, EBiosError error, string response )
 {
 
 }
 
 void OnLoadServersAsyncConsole( GetServersResult result_list, EBiosError error, string response )
 {
 
 }
 
 void SetSort( ESortType type, ESortOrder order )
 {
 m_SortOrder = order;
 m_SortType = type;
 }
 
 bool IsPingInRange( int ping, string max_ping )
 {
 int max = max_ping.Substring( 1, max_ping.Length() - 1 ).ToInt();
 
 if ( ping < max )
 return true;
 return false;
 }
 
 bool PassFilter( GetServersResultRow result )
 { 
 if ( !m_Menu || m_Menu.GetServersLoadingTab() != m_TabType )
 {
 return false;
 }
 
 if ( m_Filters.m_PingFilter.IsSet() )
 {
 if ( !IsPingInRange( result.m_Ping, m_Filters.m_PingFilter.GetStringValue() ) )
 {
 return false;
 }
 }
 
 if ( m_Filters.m_PreviouslyPlayedFilter.IsSet() )
 {
 bool is_visited = g_Game.IsVisited( result.m_HostIp, result.m_HostPort );
 
 if ( !is_visited && m_Filters.m_PreviouslyPlayedFilter.IsEnabled() )
 {
 return false;
 }
 
 if ( is_visited && m_Filters.m_PreviouslyPlayedFilter.IsEnabled() )
 {
 return false;
 }
 }
 
 return true;
 }
 
 // Adds extra servers to the END of the list
 protected void LoadExtraEntries(int index)
 {
 
 }
 
 void Connect( ServerBrowserEntry server )
 {
 if ( !m_Menu )
 return;
 
 if ( m_Menu.GetServersLoadingTab() != TabType.NONE )
 return;
 
 m_SelectedServer = server;
 m_Menu.Connect( server );
 }
 
 string GetSortOption()
 {
 switch ( m_SortType )
 {
 case ESortType.HOST:
 {
 return "name";
 }
 case ESortType.TIME:
 {
 return "name";
 }
 case ESortType.POPULATION:
 {
 return "currentNumberPlayers";
 }
 case ESortType.SLOTS:
 {
 return "freeSlots";
 }
 case ESortType.PING:
 {
 return "name";
 }
 }
 return "";
 }
 
 int AddSorted( GetServersResultRow entry )
 { 
 return -1;
 }
 
 void Unfavorite( string uid )
 {
 ServerBrowserEntry entry;
 if ( m_EntryWidgets.Find( uid, entry ) )
 {
 entry.SetFavorite( false );
 }
 }
 
 TabType GetTabType()
 {
 return m_TabType;
 }
 
 void ButtonEnable( Widget w )
 {
 w.ClearFlags( WidgetFlags.IGNOREPOINTER );
 ColorNormal(w);
 }
 
 void ButtonDisable( Widget w )
 {
 w.SetFlags( WidgetFlags.IGNOREPOINTER );
 ColorDisable(w);
 }
 
 //Coloring functions (Until WidgetStyles are useful)
 void ColorHighlight( Widget w )
 {
 if ( w.IsInherited( ButtonWidget ) )
 {
 ButtonWidget button = ButtonWidget.Cast( w );
 button.SetTextColor( ARGB( 255, 200, 0, 0 ) );
 }
 
 w.SetColor( ARGB( 255, 0, 0, 0) );
 
 TextWidget text1 = TextWidget.Cast(w.FindAnyWidget( w.GetName() + "_text" ) );
 TextWidget text2 = TextWidget.Cast(w.FindAnyWidget( w.GetName() + "_label" ) );
 TextWidget text3 = TextWidget.Cast(w.FindAnyWidget( w.GetName() + "_text_1" ) );
 ImageWidget image = ImageWidget.Cast( w.FindAnyWidget( w.GetName() + "_image" ) );
 Widget option = Widget.Cast( w.FindAnyWidget( w.GetName() + "_option_wrapper" ) );
 Widget option_label = w.FindAnyWidget( "option_label" );
 
 if ( text1 )
 {
 text1.SetColor( ARGB( 255, 255, 0, 0 ) );
 }
 
 if ( text2 )
 {
 text2.SetColor( ARGB( 255, 255, 0, 0 ) );
 }
 
 if ( text3 )
 {
 text3.SetColor( ARGB( 255, 255, 0, 0 ) );
 w.SetAlpha(1);
 }
 
 if ( image )
 {
 image.SetColor( ARGB( 255, 200, 0, 0 ) );
 }
 
 if ( option )
 {
 option.SetColor( ARGB( 255, 255, 0, 0 ) );
 }
 
 if ( option_label )
 {
 option_label.SetColor( ARGB( 255, 255, 0, 0 ) );
 }
 }
 
 void ColorNormal( Widget w )
 {
 if ( (w.GetFlags() & WidgetFlags.IGNOREPOINTER) == WidgetFlags.IGNOREPOINTER )
 {
 return;
 }
 
 if ( w.IsInherited( ButtonWidget ) )
 {
 ButtonWidget button = ButtonWidget.Cast( w );
 button.SetTextColor( ARGB( 255, 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 = w.FindAnyWidget( w.GetName() + "_option_wrapper" );
 Widget option_label = w.FindAnyWidget( "option_label" );
 
 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 ) );
 }
 
 if ( option_label )
 {
 option_label.SetColor( ARGB( 255, 255, 255, 255 ) );
 }
 }
 
 void ColorDisable( Widget w )
 {
 #ifdef PLATFORM_WINDOWS
 SetFocus( null );
 #endif
 
 if ( w )
 {
 ButtonWidget button = ButtonWidget.Cast( w );
 if ( button )
 {
 button.SetTextColor( ColorManager.COLOR_DISABLED_TEXT );
 }
 }
 }
}