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