serverbrowsertabpc.c

Go to the documentation of this file.

class ServerBrowserTabPc extends ServerBrowserTab
{
    protected const int SERVERS_VISIBLE_COUNT   = 24;
    protected const int PAGES_BUTTONS_COUNT     = 10;
    
    protected int                                   m_TotalServersCount; //UNUSED
    protected int                                   m_PageIndex;
    protected int                                   m_PageStartNum;
    protected int                                   m_PageEndNum;
    protected int                                   m_PagesCount;
    protected int                                   m_ServersEstimateCount;
        
    protected Widget                                m_PnlPagesPanel;
    protected TextWidget                            m_PnlPagesLoadingText;
    protected ButtonWidget                          m_BtnPagesFirst;
    protected ButtonWidget                          m_BtnPagesLast;
    
    protected Widget                                m_FilterSearchIP;
    protected Widget                                m_FilterSearchIPBox;
    protected Widget                                m_FilterPanelPing;
    protected Widget                                m_FilterPanelAccTime;
    
    protected ref array<ButtonWidget>               m_BtnPages;
    protected ref array<ref ServerBrowserEntry>     m_ServerListEntries;
    
    protected ref TStringArray m_TempTime = new TStringArray;
    
    protected override void Construct( Widget parent, ServerBrowserMenuNew menu, TabType type )
    {
        #ifdef PLATFORM_CONSOLE
            m_Root                  = GetGame().GetWorkspace().CreateWidgets( "gui/layouts/new_ui/server_browser/xbox/server_browser_tab.layout", parent );
        #else
        #ifdef PLATFORM_WINDOWS
            m_Root                  = GetGame().GetWorkspace().CreateWidgets( "gui/layouts/new_ui/server_browser/pc/server_browser_tab_pages.layout", parent );
        #endif
        #endif
        
        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_ServerListEntries     = new array<ref ServerBrowserEntry>;        
        m_EntryWidgets          = new map<string, ref ServerBrowserEntry>;
        m_SortInverted          = new map<ESortType, ESortOrder>;
        m_EntriesSorted         = new map<ESortType, ref array<ref GetServersResultRow>>;
        m_EntryMods             = new map<string, ref array<string>>;
        
        m_EntriesSorted[ESortType.HOST]         = new array<ref GetServersResultRow>;
        m_EntriesSorted[ESortType.TIME]         = new array<ref GetServersResultRow>;
        m_EntriesSorted[ESortType.POPULATION]   = new array<ref GetServersResultRow>;
        m_EntriesSorted[ESortType.SLOTS]        = new array<ref GetServersResultRow>;
        m_EntriesSorted[ESortType.PING]         = new array<ref GetServersResultRow>;
        m_EntriesSorted[ESortType.FAVORITE]     = new array<ref GetServersResultRow>;
        m_EntriesSorted[ESortType.PASSWORDED]   = new array<ref GetServersResultRow>;
        
        m_Menu                  = menu;
        m_TabType               = type;
        
        m_ApplyFilter           = m_Root.FindAnyWidget( "apply_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_setting" );
        m_FilterSearchTextBox   = m_Root.FindAnyWidget( "search_name_setting_option" );
        m_FilterSearchIP        = m_Root.FindAnyWidget( "search_ip_setting" );
        m_FilterSearchIPBox     = m_Root.FindAnyWidget( "search_ip_setting_option" );
        
        m_FilterPanelAccTime    = m_Root.FindAnyWidget( "accelerated_time_setting" );
        m_FilterPanelPing       = m_Root.FindAnyWidget( "ping_setting" );
        //m_FilterPanelPing.SetHandler( this );
        
        m_LoadingText           = TextWidget.Cast( m_Root.FindAnyWidget( "loading_servers_info" ) );
        
        ButtonDisable( m_ApplyFilter );
        
        if ( type == TabType.LAN)
        {
            DisableFilters();
        }
        
        m_Filters = new ServerBrowserFilterContainer( m_Root.FindAnyWidget( "filters_content" ), this );
                
        m_Root.SetHandler( this );      
        
        SetSort(ESortType.HOST, ESortOrder.ASCENDING);
        
        m_BtnPages = new array<ButtonWidget>();
        
        int page_button_num = 1;
        ButtonWidget page_button = ButtonWidget.Cast( m_Root.FindAnyWidget( "servers_navigation_page"+ page_button_num ) );
        
        if ( PAGES_BUTTONS_COUNT < 3 || PAGES_BUTTONS_COUNT > 10 )
        {
            Error("ServerBrowserTabPage->PAGES_BUTTONS_COUNT must be in range 3 - 10!");
            return;
        }
        
        while ( page_button )
        {
            page_button.Show(false);
            
            if ( page_button_num <= PAGES_BUTTONS_COUNT )
            {
                m_BtnPages.Insert( page_button );
            }
            
            page_button_num++;
            page_button = ButtonWidget.Cast( m_Root.FindAnyWidget( "servers_navigation_page"+ page_button_num ) );
        }       
        
        m_ResetFilters          = ButtonWidget.Cast( m_Root.FindAnyWidget( "reset_filter_button" ) ) ;
        
        m_PnlPagesPanel         = m_Root.FindAnyWidget( "servers_navigation_spacer" );
        m_BtnPagePrev           = ButtonWidget.Cast( m_Root.FindAnyWidget( "servers_navigation_prev" ) ) ;
        m_BtnPageNext           = ButtonWidget.Cast( m_Root.FindAnyWidget( "servers_navigation_next" ) ) ;
        m_BtnPagesFirst         = ButtonWidget.Cast( m_Root.FindAnyWidget( "servers_navigation_page_first" ) ) ;
        m_BtnPagesLast          = ButtonWidget.Cast( m_Root.FindAnyWidget( "servers_navigation_page_last" ) ) ;
        m_PageIndex             = 0;
        m_PnlPagesPanel.Show( true );
        
        UpdatePageButtons();
    }
    
    void ~ServerBrowserTabPc()
    {
        
    }
    
    void DisableFilters()
    {
        m_Root.FindAnyWidget( "filters_content" ).Show( false );
        m_Root.FindAnyWidget( "spacer" ).Show( false );
        m_Root.FindAnyWidget( "spacer2" ).Show( false );
        m_Root.FindAnyWidget( "reset_filter_button" ).Show( false );
        m_ApplyFilter.Show( false );
        m_FiltersChanged.Show( false );
    }
    
    override void RefreshList()
    {
        for ( int i = 0; i < m_EntriesSorted.Count(); i++ )
        {
            m_EntriesSorted.GetElement(i).Clear();
        }
        
        OnlineServices.m_ServersAsyncInvoker.Insert( m_Menu.OnLoadServersAsync, EScriptInvokerInsertFlags.NONE );
        
        m_LoadingFinished = false;
        m_Loading = true;
        m_TotalServersCount = 0;
        m_TotalLoadedServers = 0;
        m_ServersEstimateCount = 0;
        m_PageIndex = 0;        
        
        super.RefreshList();
        
        m_ServerListScroller.VScrollToPos01( 0 );
        ButtonRefreshToCancel();
        UpdateServerList();
        UpdatePageButtons();
        UpdateStatusBar();
    }
    
    override void ResetFilters()
    {
        m_Filters.ResetFilters();
        
        ButtonEnable( m_ApplyFilter );
        
        if ( !m_Loading )
        {
            ButtonDisable( m_RefreshList );
        }
    }
    
    override void ApplyFilters()
    {
        m_Filters.SaveFilters();
        //m_CurrentFilterInput = m_Filters.GetFilterOptionsPC();        
        RefreshList();
        ButtonDisable( m_ApplyFilter );
        ButtonEnable( m_RefreshList );
    }
    
    void LoadingServersStop()
    {
        OnlineServices.m_ServersAsyncInvoker.Remove( m_Menu.OnLoadServersAsync );
        
        m_LoadingFinished = true;
        m_Loading = false;
        
        ButtonCancelToRefresh();        
        
        UpdateServerList();
        UpdateStatusBar();
    }
    
    override void OnLoadServersAsyncPC( ref GetServersResult result_list, EBiosError error, string response )
    {
        if ( result_list )
        {           
            int count = result_list.m_Results.Count();
            if ( count > 0 )
            {               
                for ( int i = 0; i < count; i++ )
                {
                    GetServersResultRow result = result_list.m_Results[i];
                    m_TotalServersCount++;
                    
                    result.m_SortName = result.m_Name.ToInt();
                    result.m_SortTime = GetTimeOfDayEnum( result.m_TimeOfDay );                 
                    
                    if ( PassFilter( result ) )
                    {
                        int sorted_index = AddSorted( result );
                        if ( sorted_index < (m_PageIndex * SERVERS_VISIBLE_COUNT + SERVERS_VISIBLE_COUNT) )
                        {
                            UpdateServerList();
                            UpdatePageButtons();
                        }
                    }
                    
                    if ( !m_Menu || m_Menu.GetServersLoadingTab() != m_TabType )
                    {
                        return;
                    }
                }
            }
            else
            {
                m_Menu.SetServersLoadingTab( TabType.NONE );
            }
 
        }
        else
        {
            m_Menu.SetServersLoadingTab( TabType.NONE );
        }
        
        if ( response == "thelastone" )
        {
            OnLoadServersAsyncPCFinished();
        }
        else
        {
            m_ServersEstimateCount = result_list.m_NumServers;
        }
        
        UpdateServerList();
        UpdateStatusBar();  
    }
    
    void OnLoadServersAsyncPCFinished()
    {
        LoadingServersStop();
    }
    
    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 )
                {
                    LoadingServersStop();
                }
                else
                {
                    RefreshList();
                }
                
                return true;
            }
            else if ( w == m_BtnPagePrev )
            {
                OnClickPagePrev();
                return true;
            }
            else if ( w == m_BtnPageNext )
            {
                OnClickPageNext();
                return true;
            }
            else if ( w == m_BtnPagesLast )
            {
                OnClickPageEnd();
                return true;
            }
            else if ( w == m_BtnPagesFirst )
            {
                OnClickPageFirst();
                return true;
            }
            else
            {
                bool click = OnClickPage( w );
                
                if ( click )
                {
                    return true;
                }
                
                return false;
            }
        }
        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;
            }
            else if ( w == m_FilterSearchIP )
            {
                SetFocus( m_FilterSearchIPBox );
                return true;
            }
            
            return true;
        }
        return false;
    }
    
    override bool OnMouseLeave( Widget w, Widget enterW, int x, int y )
    {       
        if ( IsFocusable( w ) )
        {
            ColorNormal( w );
            
            if ( w == m_FilterSearchText || w == m_FilterSearchIP )
            {
                SetFocus( null );
            }
            
            return true;
        }
        return false;
    }
    
    override bool OnMouseButtonUp( Widget w, int x, int y, int button )
    {
        //Print("SG OnMouseButtonUp: "+ w.GetName());
        
        if ( button == MouseState.LEFT )
        {
            if ( w == m_HostSort )
            {
                ToggleSort( ESortType.HOST );
                UpdateServerList();
                return true;
            }
            else if ( w == m_TimeSort )
            {
                ToggleSort( ESortType.TIME );
                UpdateServerList();
                return true;
            }
            else if ( w == m_PopulationSort )
            {
                ToggleSort( ESortType.POPULATION );
                UpdateServerList();
                return true;
            }
            else if ( w == m_SlotsSort )
            {
                ToggleSort( ESortType.SLOTS );
                UpdateServerList();
                return true;
            }
            else if ( w == m_PingSort )
            {
                ToggleSort( ESortType.PING );
                UpdateServerList();
                return true;
            }           
        }
        return false;
    }
    
    override void OnFilterChanged()
    {
        //m_FiltersChanged.Show( true );
        
        ButtonEnable( m_ApplyFilter );
        
        if ( !m_Loading )
        {
            ButtonDisable( m_RefreshList );
        }
    }
    
    void OnClickPagePrev()
    {
        if ( m_PageIndex > 0 )
        {
            SetPageIndex( m_PageIndex - 1);
        }
        else
        {
            SetPageIndex( m_PagesCount - 1 );
        }
    }
    
    void OnClickPageNext()
    {
        if ( m_PageIndex < (m_PagesCount - 1) )
        {
            SetPageIndex( m_PageIndex + 1 );
        }
        else
        {
            SetPageIndex( 0 );
        }
    }
    
    void OnClickPageEnd()
    {
        SetPageIndex( m_PagesCount - 1 );
    }
    
    void OnClickPageFirst()
    {
        SetPageIndex( 0 );
    }
    
    bool OnClickPage(Widget w)
    {
        for ( int i = 0; i < m_BtnPages.Count(); ++i )
        {
            if ( m_BtnPages[i] == w )
            {
                SetPageIndex( m_PageStartNum + i - 1 );
                return true;
            }
        }
        
        return false;
    }
    
    void SetPageIndex(int page_index)
    {
        m_PageIndex = page_index;
        UpdateServerList();
        UpdatePageButtons();
    }
    
    void ToggleSort( ESortType type )
    {
        ESortOrder order = ESortOrder.ASCENDING;
        
        if ( m_SortType != type )
        {
            if ( m_SortInverted[type] == true )
            {
                m_EntriesSorted[type].Invert();
            }
            
            m_SortInverted[type] = false;
        }
        else
        {
            if ( m_SortOrder == ESortOrder.ASCENDING )
            {
                m_EntriesSorted[type].Invert();             
                m_SortInverted[type] = true;                
                order = ESortOrder.DESCENDING;
            }
            else
            {
                m_EntriesSorted[type].Invert();             
                m_SortInverted[type] = false;           
            }
        }
        
        SetSort( type, order );
    }
    
    override void SetSort( ESortType type, ESortOrder order )
    {
        super.SetSort( type, order);
        
        #ifdef PLATFORM_WINDOWS
        m_Root.FindAnyWidget( "host_sort" ).Show( false );
        m_Root.FindAnyWidget( "population_sort" ).Show( false );
        m_Root.FindAnyWidget( "slots_sort" ).Show( false );
        
        m_Root.FindAnyWidget( "time_sort" ).Show( false );
        m_Root.FindAnyWidget( "ping_sort" ).Show( false );
        
        TextWidget root;
        root = TextWidget.Cast( m_Root.FindAnyWidget( "server_list_content_header_host_label" ) );
        root.SetColor( ARGBF( 1, 1, 1, 1 ) );
        root = TextWidget.Cast( m_Root.FindAnyWidget( "server_list_content_header_population_label" ) );
        root.SetColor( ARGBF( 1, 1, 1, 1 ) );
        root = TextWidget.Cast( m_Root.FindAnyWidget( "server_list_content_header_slots_label" ) );
        root.SetColor( ARGBF( 1, 1, 1, 1 ) );
        
        root = TextWidget.Cast( m_Root.FindAnyWidget( "server_list_content_header_ping_label" ) );
        root.SetColor( ARGBF( 1, 1, 1, 1 ) );
        root = TextWidget.Cast( m_Root.FindAnyWidget( "server_list_content_header_time_label" ) );
        root.SetColor( ARGBF( 1, 1, 1, 1 ) );
        
        string r_name;
        string w_name;
        
        switch ( type )
        {
            case ESortType.HOST:
            {
                r_name = "server_list_content_header_host_label";
                w_name = "host_sort";
                break;
            }
            case ESortType.TIME:
            {
                r_name = "server_list_content_header_time_label";
                w_name = "time_sort";
                break;
            }
            case ESortType.POPULATION:
            {
                r_name = "server_list_content_header_population_label";
                w_name = "population_sort";
                break;
            }
            case ESortType.SLOTS:
            {
                r_name = "server_list_content_header_slots_label";
                w_name = "slots_sort";
                break;
            }
            case ESortType.PING:
            {
                r_name = "server_list_content_header_ping_label";
                w_name = "ping_sort";
                break;
            }
        }
        
        root = TextWidget.Cast( m_Root.FindAnyWidget( r_name ) );
        root.SetColor( ARGBF( 1, 1, 0, 0 ) );
        
        m_Root.FindAnyWidget( w_name ).Show( true );
        m_Root.FindAnyWidget( w_name + "_asc" ).Show( !m_SortOrder );
        m_Root.FindAnyWidget( w_name + "_dsc" ).Show( m_SortOrder );        
        #endif
    }
    
    int GetTimeOfDayEnum( string time_of_day )
    {
        m_TempTime.Clear();
        
        time_of_day.Split( ":", m_TempTime );
        
        int minutes = 0;
        
        if ( m_TempTime.Count() > 0 )
        {
            int h = m_TempTime[0].ToInt();
            
            if ( h >= 5 )
            {
                h -= 5;
            }
            else
            {
                h += 24;
            }
            
            minutes = h * 60;
        }
        
        if ( m_TempTime.Count() > 1 )
        {
            int m = m_TempTime[0].ToInt();
            minutes += m;
        }
        
        return minutes;
    }
    
    // Return sorted index
    override int AddSorted( GetServersResultRow entry )
    {
        int index_host = SortedInsert( entry, ESortType.HOST );
        int index_time = SortedInsert( entry, ESortType.TIME );
        int index_popu = SortedInsert( entry, ESortType.POPULATION );
        int index_slot = SortedInsert( entry, ESortType.SLOTS );
        int index_ping = SortedInsert( entry, ESortType.PING );
        int index_favo = SortedInsert( entry, ESortType.FAVORITE );
        int index_pass = SortedInsert( entry, ESortType.PASSWORDED );
        
        switch ( m_SortType )
        {
            case ESortType.HOST:
                return index_host;
            case ESortType.TIME:
                return index_time;
            case ESortType.POPULATION:
                return index_popu;
            case ESortType.SLOTS:
                return index_slot;
            case ESortType.PING:
                return index_ping;
            case ESortType.FAVORITE:
                return index_favo;
            case ESortType.PASSWORDED:
                return index_pass;
        }
            
        return 0;
    }
    
    override void SelectServer( ServerBrowserEntry server )
    {
        super.SelectServer( server );
        
        #ifdef PLATFORM_CONSOLE
        ScrollToEntry( server );
        #endif
        
        m_SelectedServer = server;
        
        if (!m_Menu)
            return;
        
        m_Menu.SelectServer( server );
    }
        
    int SortedInsert(GetServersResultRow entry, ESortType sort_type)
    {
        return SortedInsertEx(entry, sort_type, m_SortInverted[sort_type]);
    }
 
    private int SortedInsertEx(GetServersResultRow entry, ESortType sortType, bool isDescending)
    {       
        array<ref GetServersResultRow> list = m_EntriesSorted[sortType];
        int indexMax = list.Count() - 1;
        int indexMin = 0;
        int targetIndex = Math.Floor( indexMax / 2 );
        int comparisonMultiplier = 1;
        
        // if order is descending, then invert comparison results
        if (isDescending == true)
        {
            comparisonMultiplier = -1;
        }
        
        if ( indexMax == -1 )
        {
            list.Insert( entry );
            return 0;
        }
        
        while ( true )
        {
            int comparisonResult = comparisonMultiplier * entry.CompareTo(list[targetIndex], sortType); 
            
            if ((indexMax - indexMin) <= 1)
            {
                for (int i = indexMin; i <= indexMax; i++ )
                {
                    comparisonResult = comparisonMultiplier * entry.CompareTo(list[i], sortType);       
                    
                    if ( comparisonResult > 0 )
                    {
                        list.InsertAt( entry, i );
                        return i;
                    }
                }
                
                // adding entry AFTER indexMax
                targetIndex = Math.Min(indexMax + 1, list.Count());
                list.InsertAt(entry, targetIndex);
                return targetIndex;
            }
            
            if (comparisonResult == 0)
            {
                list.InsertAt(entry, targetIndex);
                return targetIndex;
            }
            
            if (comparisonResult > 0)
            {
                indexMax = targetIndex;
            }
            
            else if (comparisonResult < 0)
            {
                indexMin = targetIndex;
            }
            
            targetIndex = indexMin + Math.Floor((indexMax - indexMin) / 2); 
        }
        
        return 0;
    }
    
    // DEPRECATED
    int SortedInsertAsc( GetServersResultRow entry, ESortType sort_type )
    {
        array<ref GetServersResultRow> list = m_EntriesSorted[sort_type];
        
        int i;
        int index_min = 0;
        int index_max = list.Count() - 1;
        int target_index = Math.Floor( index_max / 2 );
        
        if ( index_max == -1 )
        {
            list.Insert( entry );
            return 0;
        }
        
        if ( sort_type == ESortType.HOST )
        {
            string entry_value_str = entry.GetValueStr(ESortType.HOST);
            
            while ( true )
            {
                string target_value_str = list[target_index].GetValueStr(ESortType.HOST);
                
                if ( entry_value_str == target_value_str || ((index_max - index_min) <= 1) )
                {
                    for ( i = index_min; i <= index_max; i++ )
                    {
                        if ( entry_value_str <= list[i].GetValueStr(ESortType.HOST) )
                        {
                            list.InsertAt( entry, i );
                            return i;
                        }
                    }
                    
                    index_max++;
                    list.InsertAt( entry, index_max );
                    return target_index;
                }
                else if ( entry_value_str < target_value_str )
                {
                    index_max = target_index;
                    target_index = Math.Floor( target_index / 2 );
                }
                else if ( entry_value_str > target_value_str )
                {
                    index_min = target_index;
                    target_index += Math.Floor( (index_max - index_min) / 2 );
                }           
            }
        }
        else
        {
            int entry_value_int = entry.GetValueInt( sort_type );
            
            while ( true )
            {
                int target_value_int = list[target_index].GetValueInt( sort_type );
                
                if ( entry_value_int == target_value_int || ((index_max - index_min) <= 1) )
                {
                    for ( i = index_min; i <= index_max; i++ )
                    {
                        if ( entry_value_int <= list[i].GetValueInt( sort_type ) )
                        {
                            list.InsertAt( entry, i );
                            return i;
                        }
                    }
                    
                    index_max++;
                    list.InsertAt( entry, index_max );
                    return target_index;
                }
                else if ( entry_value_int < target_value_int )
                {
                    index_max = target_index;
                    target_index = Math.Floor( target_index / 2 );
                }
                else if ( entry_value_int > target_value_int )
                {
                    index_min = target_index;
                    target_index += Math.Floor( (index_max - index_min) / 2 );
                }           
            }
        }
        
        return target_index;
    }
    
    // DEPRECATED
    int SortedInsertDesc( GetServersResultRow entry, ESortType sort_type )
    {
        array<ref GetServersResultRow> list = m_EntriesSorted[sort_type];
        
        int i;
        int index_min = 0;
        int index_max = list.Count() - 1;
        int target_index = Math.Floor( index_max / 2 );
        
        if ( index_max == -1 )
        {
            list.Insert( entry );
            return 0;
        }
        
        if ( sort_type == ESortType.HOST )
        {
            string entry_value_str = entry.GetValueStr(ESortType.HOST);
            
            while ( true )
            {
                string target_value_str = list[target_index].GetValueStr(ESortType.HOST);
                
                if ( entry_value_str == target_value_str || ((index_max - index_min) <= 1) )
                {
                    for ( i = index_min; i <= index_max; i++ )
                    {
                        if ( entry_value_str >= list[i].GetValueStr(ESortType.HOST) )
                        {
                            list.InsertAt( entry, i );
                            return i;
                        }
                    }
                    
                    index_max++;
                    list.InsertAt( entry, index_max );
                    return target_index;
                }
                else if ( entry_value_str > target_value_str )
                {
                    index_max = target_index;
                    target_index = Math.Floor( target_index / 2 );
                }
                else if ( entry_value_str < target_value_str )
                {
                    index_min = target_index;
                    target_index += Math.Floor( (index_max - index_min) / 2 );
                }           
            }
        }
        else
        {
            int entry_value_int = entry.GetValueInt( sort_type );
            
            while ( true )
            {
                int target_value_int = list[target_index].GetValueInt( sort_type );
                
                if ( entry_value_int == target_value_int || ((index_max - index_min) <= 1) )
                {
                    for ( i = index_min; i <= index_max; i++ )
                    {
                        if ( entry_value_int >= list[i].GetValueInt( sort_type ) )
                        {
                            list.InsertAt( entry, i );
                            return i;
                        }
                    }
                    
                    index_max++;
                    list.InsertAt( entry, index_max );
                    return target_index;
                }
                else if ( entry_value_int > target_value_int )
                {
                    index_max = target_index;
                    target_index = Math.Floor( target_index / 2 );
                }
                else if ( entry_value_int < target_value_int )
                {
                    index_min = target_index;
                    target_index += Math.Floor( (index_max - index_min) / 2 );
                }           
            }
        }
        
        return target_index;
    }
 
    void UpdatePageButtons()
    {
        m_PagesCount = Math.Ceil( m_TotalLoadedServers / SERVERS_VISIBLE_COUNT );       
        if ( m_PagesCount > 1 )
        {
            m_PnlPagesPanel.Show( true );
            
            int i;
            int btn_index_center = Math.Round( PAGES_BUTTONS_COUNT / 2) - 1; 
            m_PageStartNum = 1;
            m_PageEndNum = PAGES_BUTTONS_COUNT;
            
            if ( m_PagesCount <= PAGES_BUTTONS_COUNT )
            {
                m_PageEndNum = m_PagesCount;
                
                // Pages are less like buttons - changing selected button
                for ( i = 1; i <= m_BtnPages.Count(); ++i )
                {
                    bool is_page_button_enable = ( i <= m_PagesCount );
                                        
                    int page_index = (i - 1);
                    m_BtnPages[page_index].Show( is_page_button_enable );
                    m_BtnPages[page_index].SetText( i.ToString() );
                    
                    if ( m_PageIndex == page_index )
                    {
                        m_BtnPages[page_index].SetState( true );
                    }
                    else
                    {
                        m_BtnPages[page_index].SetState( false );
                    }
                }
            }
            else
            {
                // Pages are more like buttons              
                if ( m_PageIndex <= btn_index_center )
                {
                    //Left side (start of pages)
                    //m_PageStartNum = 1;
                    //m_PageEndNum = PAGES_BUTTONS_COUNT;
                }
                else
                {
                    m_PageStartNum = m_PageIndex - btn_index_center + 1;
                    m_PageEndNum = m_PageIndex + (PAGES_BUTTONS_COUNT - btn_index_center);
                            
                    if ( m_PageEndNum > m_PagesCount )
                    {
                        // Right side (end of pages)
                        m_PageStartNum -= m_PageEndNum - m_PagesCount;
                        m_PageEndNum -= m_PageEndNum - m_PagesCount;
                    }
                }
                
                
                // Button Selection
                int selected_btn_index = m_PageIndex;
                if ( m_PageIndex > btn_index_center )
                {
                    if ( m_PageEndNum == m_PagesCount )
                    {
                        //Right
                         selected_btn_index = PAGES_BUTTONS_COUNT - (m_PagesCount - m_PageIndex);
                    }
                    else
                    {
                        //Center
                        selected_btn_index = btn_index_center;
                    }
                }
                
                
                for ( i = 0; i < m_BtnPages.Count(); ++i )
                {
                    m_BtnPages[i].SetText( (m_PageStartNum + i).ToString() );
                    m_BtnPages[i].SetState( ( i == selected_btn_index ) );
                }
            }
            
            // Button GoTo Prev Page
            if ( m_PageIndex > 0 )
            {
                m_BtnPagePrev.SetText( "<" );
                m_BtnPagePrev.Enable( true );
            }
            else
            {
                m_BtnPagePrev.SetText( "" );
                m_BtnPagePrev.Enable( false );                  
            }
            
            // Button GoTo Next Page
            if ( m_PageIndex < (m_PagesCount - 1) )
            {
                m_BtnPageNext.SetText( ">" );
                m_BtnPageNext.Enable( true );
            }
            else
            {
                m_BtnPageNext.SetText( "" );
                m_BtnPageNext.Enable( false );
            }
            
            // Button GoTo First Page
            if ( m_PageStartNum == 1 )
            {
                m_BtnPagesFirst.SetText( "" );
                m_BtnPagesFirst.Enable( false );
            }
            else
            {
                m_BtnPagesFirst.SetText( "<<" );
                m_BtnPagesFirst.Enable( true );
            }
            
            // Button GoTo Last Page
            if ( m_PageEndNum == m_PagesCount )
            {
                m_BtnPagesLast.SetText( "" );
                m_BtnPagesLast.Enable( false );
            }
            else
            {
                m_BtnPagesLast.SetText( ">>" );
                m_BtnPagesLast.Enable( true );
            }
        }
        else
        {
            m_PnlPagesPanel.Show(false);
        }
    }
    
    void UpdateServerList()
    {
        int lastFilledIndexOnPage = 0;
        m_TotalLoadedServers = m_EntriesSorted[m_SortType].Count();
        ServerBrowserEntry entry;
        
        m_EntryWidgets.Clear();
        
        for ( int i = 0; i < SERVERS_VISIBLE_COUNT; ++i )
        {
            int serverIndex = i + (SERVERS_VISIBLE_COUNT * m_PageIndex);
            
            if ( serverIndex < m_EntriesSorted[m_SortType].Count() )
            {               
                GetServersResultRow server_info = m_EntriesSorted[m_SortType][serverIndex];
                
                if ( server_info.m_Favorite )
                {
                    m_OnlineFavServers.Insert(server_info.m_Id);
                }
                
                entry = GetServerEntryByIndex(i, server_info.m_Id);
                entry.Show( true );
                entry.SetIsOnline( true );
                entry.FillInfo( server_info );
                entry.SetMods( m_EntryMods.Get( server_info.m_Id ) );
                entry.UpdateEntry();
                
                if ( GetRootMenu() && GetRootMenu().GetServersLoadingTab() != TabType.NONE )
                {
                    entry.SetName("#dayz_game_loading");
                }
                
                lastFilledIndexOnPage++;
            }
            else
            {
                entry = GetServerEntryByIndex(i, "-1");
                
                if ( entry )
                {
                    entry.Show( false );
                }
            }
        }
        LoadExtraEntries(lastFilledIndexOnPage);
        
        m_ServerList.Update();
    }
    
    void UpdateStatusBar()
    {
        string serversFound = string.Format("#servers_found: %1", m_TotalLoadedServers);
        if ( m_LoadingFinished )
        {
            m_LoadingText.SetText( serversFound );
        }
        else
        {           
            m_LoadingText.SetText( string.Format("#dayz_game_loading %1", serversFound) );
        }
    }
    
    override void OnLoadServerModsAsync( string server_id, array<string> mods )
    {
        super.OnLoadServerModsAsync( server_id, mods );
        
        if ( m_EntryWidgets.Contains( server_id ) )
        {
            m_EntryWidgets.Get( server_id ).SetMods( mods );
        }
    }
    
    protected ServerBrowserEntry GetServerEntryByIndex( int index, string server_id )
    {
        ref ServerBrowserEntry entry;
        
        if ( index >= 0 )
        {
            if ( index < m_ServerListEntries.Count() )
            {
                entry = m_ServerListEntries[index];
            }
            else
            {
                entry = new ServerBrowserEntry( null, index, this );
                m_ServerList.AddChild( entry.GetRoot(), false );
                
                m_ServerListEntries.Insert(entry);
            }
        }
        else
        {
            return null;
        }
        
        // Refresh list
        m_EntryWidgets.Insert( server_id, entry );
        
        return entry;
    }
    
    override bool IsFocusable( Widget w )
    {
        if ( w )
        {
            if ( super.IsFocusable( w ) )
            {
                return true;
            }
            
            if ( w == m_ServerListScroller )
            {
                return false;
            }
            
            if ( w == m_HostSort || w == m_TimeSort || w == m_PopulationSort || w == m_SlotsSort || w == m_PingSort || w == m_FilterSearchIP )
            {
                return true;
            }
            
            if ( w == m_FilterPanelAccTime || m_FilterPanelPing )
            {               
                return true;
            }
            
            return false;
        }
        return false;
    }
    
    void ButtonRefreshToCancel()
    {
        ButtonWidget btn = ButtonWidget.Cast( m_RefreshList );
        btn.SetText( "#menu_cancel" );
    }
    
    void ButtonCancelToRefresh()
    {
        ButtonWidget btn = ButtonWidget.Cast( m_RefreshList );
        btn.SetText( "#STR_server_browser_tab_root_filters_root_filters_content_refresh_list_button0" );
    }
}