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