Renegade/Code/Commando/dlgmpwolgamelist.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : Combat																		  *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/Commando/dlgmpwolgamelist.cpp      $*
 *                                                                                             *
 *                       Author:: Patrick Smith                                                *
 *                                                                                             *
 *                     $Modtime:: 11/24/02 4:52p                                              $*
 *                                                                                             *
 *                    $Revision:: 76                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include "DlgMPWOLGameList.h"
#include "specialbuilds.h"
#include "cNetwork.h"
#include "BandwidthCheck.h"
#include "UserOptions.h"
#include "GameInitMgr.h"
#include "DlgMPWOLPageBuddy.h"
#include "DlgMessageBox.h"
#include "DlgPasswordPrompt.h"
#include <Combat\PlayerType.h>
#include "WOLJoinGame.h"
#include "WOLLogonMgr.h"
#include <WWOnline\WOLServer.h>
#include <WWOnline\WOLChannel.h>
#include <WWUI\DialogMgr.h>
#include <WWUI\ShortcutBarCtrl.h>
#include <WWUI\ButtonCtrl.h>
#include <WWUI\CheckBoxCtrl.h>
#include <WWUI\ListCtrl.h>
#include "String_IDs.h"
#include <WWTranslateDB\TranslateDB.h>
#include "dlgmplanhostoptions.h"
#include "debug.h"
#include "init.h"

using namespace WWOnline;

// Game List columns
static enum
	{
	COL_ICON = 0,
	COL_HOST_NAME,
	COL_GAME_TITLE,
	COL_GAME_MAP,
	COL_PLAYERS,
	COL_PING
	};

#define CLAN_ENTRY_MARKER 0x0C1A0C1A

#define PING_GREEN_THRESHOLD 655
#define PING_YELLOW_THRESHOLD 2621

// Sorting flags for game attributes
#define FLAGSORT_DEDICATED  0x01
#define FLAGSORT_LADDERED   0x02
#define FLAGSORT_PASSWORDED 0x04
#define FLAGSORT_CLAN       0x08

static void SetGameTypeFlags(ListCtrlClass* list, int itemIndex, const WOLGameInfo& gameInfo);
static void SetPingTimeIcon(ListCtrlClass* list, int itemIndex, long pingTime);
static int CALLBACK FlagsSortCallback(ListCtrlClass* list, int item1, int item2, uint32 param);
static int CALLBACK NumericSortCallback(ListCtrlClass* list, int item1, int item2, uint32 param);
static int CALLBACK AlphaSortCallback(ListCtrlClass* list, int index1, int index2, uint32 param);


MPWolGameListMenuClass* MPWolGameListMenuClass::_mInstance = NULL;

/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::DoDialog
*
* DESCRIPTION
*     Display the Westwood Online advanced game listings dialog.
*
* INPUTS
*     NONE
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::DoDialog(void)
	{
	//	Create the dialog if necessary, otherwise simply bring it to the front
	if (_mInstance == NULL)
		{
		MPWolGameListMenuClass* dialog = new MPWolGameListMenuClass;
		WWASSERT(dialog != NULL && "Failed to create WOL GameList dialog");
		
		if (dialog)
			{
			dialog->Start_Dialog();
			dialog->Release_Ref();
			}
		}
	else
		{
		if (_mInstance->Is_Active_Menu() == false)
			{
			DialogMgrClass::Rollback(_mInstance);
			}
		}
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::MPWolGameListMenuClass
*
* DESCRIPTION
*     Constructor
*
* INPUTS
*     NONE
*
* RESULT
*     NONE
*
******************************************************************************/

MPWolGameListMenuClass::MPWolGameListMenuClass(void) :
		MenuDialogClass(IDD_MP_WOL_GAME_LIST),
		mChannelListPending(false),
		mSortColumn(COL_HOST_NAME),
		mIsSortAscending(true),
		mSortFlags(0)
	{
	WWDEBUG_SAY(("MPWolGameListMenuClass Instantiated\n"));
	WWASSERT(_mInstance == NULL);
	_mInstance = this;

	mWOLSession = Session::GetInstance(false);
	WWASSERT_PRINT(mWOLSession.IsValid(), "WOLSession not instantiated!");
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::~MPWolGameListMenuClass
*
* DESCRIPTION
*     Destructor
*
* INPUTS
*     NONE
*
* RESULT
*     NONE
*
******************************************************************************/

MPWolGameListMenuClass::~MPWolGameListMenuClass(void)
	{
	WWDEBUG_SAY(("MPWolGameListMenuClass Destroyed\n"));
	_mInstance = NULL;
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::On_Init_Dialog
*
* DESCRIPTION
*     One time dialog initialization
*
* INPUTS
*     NONE
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::On_Init_Dialog(void)
	{
	#ifdef FREEDEDICATEDSERVER
	Enable_Dlg_Item(IDC_JOIN_GAME_BUTTON, false);
	#endif // FREEDEDICATEDSERVER

	//---------------------------------------------------------------------------
	// Configure the shortcut bar
	//---------------------------------------------------------------------------
	ShortcutBarCtrlClass* bar = (ShortcutBarCtrlClass*)Get_Dlg_Item(IDC_SHORTCUT_BAR);

	if (bar)
		{
		bar->Add_Button(IDC_MP_SHORTCUT_CHAT, TRANSLATE(IDS_MP_SHORTCUT_CHAT));
		bar->Add_Button(IDC_MP_SHORTCUT_BUDDIES, TRANSLATE(IDS_MP_SHORTCUT_BUDDIES));
		bar->Add_Button(IDC_MP_SHORTCUT_INTERNET_OPTIONS, TRANSLATE(IDS_INTERNET_OPTIONS));
		bar->Add_Button(IDC_MP_SHORTCUT_NEWS, TRANSLATE(IDS_MP_SHORTCUT_NEWS));
		bar->Add_Button(IDC_MP_SHORTCUT_CLANS, TRANSLATE(IDS_MP_SHORTCUT_CLANS));
		bar->Add_Button(IDC_MP_SHORTCUT_RANKINGS, TRANSLATE(IDS_MP_SHORTCUT_RANKINGS));
		bar->Add_Button(IDC_MP_SHORTCUT_NET_STATUS, TRANSLATE(IDS_MP_SHORTCUT_NET_STATUS));
		}

	//---------------------------------------------------------------------------
	// Show the current login and server
	//---------------------------------------------------------------------------
	WideStringClass serverName(64, true);
	WOLLogonMgr::GetServerName(serverName);

	WideStringClass string(128, true);
	string.Format(TRANSLATE (IDS_MENU_CONNECTED_TO_FORMAT), serverName);
	Set_Dlg_Item_Text(IDC_SERVERNAME, string);

	WideStringClass loginName(64, true);
	WOLLogonMgr::GetLoginName(loginName);

	string.Format(TRANSLATE (IDS_MENU_LOGIN_NAME_FORMAT), loginName);
	Set_Dlg_Item_Text(IDC_LOGINNAME, string);

	WideStringClass conn(BandwidthCheckerClass::Get_Bandwidth_As_String(), true);
	string.Format(TRANSLATE (IDS_MENU_SPEED_FORMAT), conn);
	Set_Dlg_Item_Text(IDC_CONNECTIONSPEED, string);

	//---------------------------------------------------------------------------
	// Configure sorting buttons
	//---------------------------------------------------------------------------
	ButtonCtrlClass* button = (ButtonCtrlClass*)Get_Dlg_Item(IDC_SORT_DEDICATED_BUTTON);

	if (button)
		{
		button->Set_Bitmap("mul_spec.tga", "mul_nopts.tga");
		button->Set_Tooltip_Text(TRANSLATE (IDS_MENU_TOOLTIP_SORT_01));
		}

	button = (ButtonCtrlClass*)Get_Dlg_Item(IDC_SORT_PASSWORD_BUTTON);

	if (button)
		{
		button->Set_Bitmap("mul_pswrd.tga", "mul_nopts.tga");
		button->Set_Tooltip_Text(TRANSLATE (IDS_MENU_TOOLTIP_SORT_02));
		}

	button = (ButtonCtrlClass*)Get_Dlg_Item(IDC_SORT_LADDERED_BUTTON);

	if (button)
		{
		button->Set_Bitmap("mul_pts.tga", "mul_nopts.tga");
		button->Set_Tooltip_Text(TRANSLATE (IDS_MENU_TOOLTIP_SORT_03));
		}

	button = (ButtonCtrlClass*)Get_Dlg_Item(IDC_SORT_CLAN_BUTTON);

	if (button)
		{
		button->Set_Bitmap("mul_btlcln.tga", "mul_nopts.tga");
		button->Set_Tooltip_Text(TRANSLATE (IDS_MENU_TOOLTIP_SORT_04));
		}

	//---------------------------------------------------------------------------
	// Configure game listing control
	//---------------------------------------------------------------------------
	ListCtrlClass* list_ctrl = (ListCtrlClass*)Get_Dlg_Item(IDC_GAME_LIST_CTRL);

	if (list_ctrl)
		{
		Vector3 color(1,1,1);
		list_ctrl->Add_Column(TRANSLATE(IDS_MP_GAME_LIST_HEADER_ICON), 0.1F, color);
		list_ctrl->Add_Column(TRANSLATE(IDS_MP_GAME_LIST_HEADER_HOST_NAME), 0.175F, color);
		list_ctrl->Add_Column(TRANSLATE(IDS_MP_GAME_LIST_HEADER_GAME_NAME), 0.325F, color);
		list_ctrl->Add_Column(TRANSLATE(IDS_MP_GAME_LIST_HEADER_GAME_MAP), 0.2F, color);
		list_ctrl->Add_Column(TRANSLATE(IDS_MP_GAME_LIST_HEADER_PLAYERS), 0.1F, color);
		list_ctrl->Add_Column(TRANSLATE(IDS_MP_GAME_LIST_HEADER_PING), 0.1F, color);

		list_ctrl->Allow_NoSelection(true);

		Observer<ChannelListEvent>::NotifyMe(*mWOLSession);
		Observer<ServerError>::NotifyMe(*mWOLSession);
		Observer<SquadEvent>::NotifyMe(*mWOLSession);

		RequestGameList();
		}

	//---------------------------------------------------------------------------
	// Configure game details list control
	//---------------------------------------------------------------------------
	list_ctrl = (ListCtrlClass*)Get_Dlg_Item(IDC_DETAILS_LIST);

	if (list_ctrl)
		{
		list_ctrl->Allow_Selection(false);
		list_ctrl->Set_Tabstop(20.0f);
		}

	MenuDialogClass::On_Init_Dialog();
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::On_Command
*
* DESCRIPTION
*     Respond to command messages from UI controls
*
* INPUTS
*     ID    - ID of control originating the message
*     Msg   - Message identifier
*     Param - Message specific parameter
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::On_Command(int id, int msg, DWORD param)
	{
	switch (id)
		{
		case IDC_PAGE_BUDDY_BUTTON:
			START_DIALOG(MPWolPageBuddyPopupClass);
			break;

		case IDC_REFRESH_GAME_LIST:
			RequestGameList();
			break;

		case IDC_SORT_DEDICATED_BUTTON:
			SortGameChannels(COL_ICON, true, FLAGSORT_DEDICATED);
			break;

		case IDC_SORT_PASSWORD_BUTTON:
			SortGameChannels(COL_ICON, true, FLAGSORT_PASSWORDED);
			break;

		case IDC_SORT_LADDERED_BUTTON:
			SortGameChannels(COL_ICON, true, FLAGSORT_LADDERED);
			break;

		case IDC_SORT_CLAN_BUTTON:
			SortGameChannels(COL_ICON, true, FLAGSORT_CLAN);
			break;

		case IDC_JOIN_GAME_BUTTON:
			Join_Game();
			break;

		case IDC_MENU_MP_LAN_HOST_BUTTON:
			// Return to the game list on exit
			GameInitMgrClass::Set_WOL_Return_Dialog(RenegadeDialogMgrClass::LOC_INTERNET_GAME_LIST);

			//	Create the new game data
			if ( PTheGameData != NULL ) {
				delete PTheGameData;
				PTheGameData = NULL;
			}
			PTheGameData = cGameData::Create_Game_Of_Type(cGameData::GAME_TYPE_CNC);
			WWASSERT(PTheGameData != NULL);

			// WOL games default as quickmatch servers
			The_Game()->Set_QuickMatch_Server(true);

			// Load server preferences.
			The_Game()->Load_From_Server_Config();

			//	Move to the next menu
			DialogBaseClass* dialog = new MPLanHostOptionsMenuClass;
			dialog->Start_Dialog();
			REF_PTR_RELEASE(dialog);
			break;
		}

	MenuDialogClass::On_Command(id, msg, param);
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::On_Key_Down
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

bool MPWolGameListMenuClass::On_Key_Down(uint32 key_id, uint32 key_data)
	{
	if (VK_F5 == key_id)
		{
		RequestGameList();
		return true;
		}

	return MenuDialogClass::On_Key_Down(key_id, key_data);
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::Join_Game
*
* DESCRIPTION
*     Join the currently selected game
*
* INPUTS
*     NONE
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::Join_Game(void)
	{
	ListCtrlClass* list = (ListCtrlClass*)Get_Dlg_Item(IDC_GAME_LIST_CTRL);

	if (list)
		{
		// Get the currently selected index
		int index = list->Get_Curr_Sel();

		if (index >= 0)
			{
			RefPtr<ChannelData> channel = (ChannelData*)list->Get_Entry_Data(index, COL_HOST_NAME);

			// If the channel is invalid then do not proceed
			if (!channel.IsValid())
				{
				return;
				}

			WOLGameInfo selectedGame(channel);

			// If the channel data is invalid then do not proceed
			if (!selectedGame.IsDataValid())
				{
				return;
				}

			// If the user cannot join this game then do not proceed.
			if (!selectedGame.CanUserJoin(mWOLSession->GetCurrentUser()))
				{
				return;
				}

			// Return to the game list on exit
			GameInitMgrClass::Set_WOL_Return_Dialog(RenegadeDialogMgrClass::LOC_INTERNET_GAME_LIST);

			// If the game to join is passworded then it is necessary for the user to
			// supply the correct password. Therefore prompt the user to enter the
			// password. We will attempt to connect to the game when we receive a
			// signal from the dialog that the user has entered a password.
			if (channel->IsPassworded())
				{
				mGameToJoin = channel;
				DlgPasswordPrompt::DoDialog(this);
				}
			else
				{
				// No password require
				WOLJoinGame::JoinTheGame(channel->GetName(), L"", true);
				}
			}
		}
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::ReceiveSignal
*
* DESCRIPTION
*     Handle receipt of password entered signal from the password prompt dialog.
*
* INPUTS
*     Signal - Signal that the user has entered a password.
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::ReceiveSignal(DlgPasswordPrompt& passwordDialog)
	{
	if (mGameToJoin.IsValid())
		{
		WOLJoinGame::JoinTheGame(mGameToJoin->GetName(), passwordDialog.GetPassword(), true);
		mGameToJoin.Release();
		}
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::RequestGameList
*
* DESCRIPTION
*     Submit a request for an updated game list.
*
* INPUTS
*     NONE
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::RequestGameList(void)
	{
	if (mChannelListPending == false)
		{
		if (mWOLSession->RequestGameChannelList())
			{
			mChannelListPending = true;
			Enable_Dlg_Item(IDC_REFRESH_GAME_LIST, false);

			ListCtrlClass* list = (ListCtrlClass*)Get_Dlg_Item(IDC_DETAILS_LIST);

			if (list)
				{
				list->Delete_All_Entries();
				list->Add_Column(L"", 1.0F, Vector3(1, 1, 1));
				list->Insert_Entry(0, TRANSLATE (IDS_MENU_REQUESTING_NEW_CHANNELS));
				}
			}
		}
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::UpdateChannels
*
* DESCRIPTION
*     Update the list of game channels.
*
* INPUTS
*     List     - List control to view channels.
*     Channels - List of channels
*
* RESULT
*     True if the list changed.
*
******************************************************************************/

void MPWolGameListMenuClass::UpdateChannels(ListCtrlClass* list, const ChannelList& chanList)
	{
	// Get current selection so we can reselect it.
	WideStringClass selectedGameName(64, true);
	int selIndex = list->Get_Curr_Sel();

	if (selIndex >= 0)
		{
		selectedGameName = list->Get_Entry_Text(selIndex, COL_HOST_NAME);
		}

	selIndex = -1;

	int listIndex = list->Get_Entry_Count();
	ChannelList::const_iterator chanIter = chanList.begin();

	while (chanIter != chanList.end())
		{
		RefPtr<ChannelData> channel = (*chanIter);

		if (channel.IsValid())
			{
			WOLGameInfo gameInfo(channel);

			// Only show the channel if it is a valid game channel
			if (gameInfo.IsDataValid())
				{
				bool newlyAdded = false;

				// Check if the channel entry is already in the listbox.
				int itemIndex = list->Find_Entry(COL_HOST_NAME, channel->GetName());

				// If the channel was not found then add it now.
				if (itemIndex == -1)
					{
					itemIndex = list->Insert_Entry(listIndex, L"");
					newlyAdded = true;
					}

				// Update the channel in the listbox
				if (itemIndex >= 0)
					{
					// Associate the channel data inside with the entry
					if (newlyAdded)
						{
						ChannelData* rawChannel = channel.ReferencedObject();
						rawChannel->AddReference();
						list->Set_Entry_Data(itemIndex, COL_HOST_NAME, (unsigned long)rawChannel);

						// Show the game channel name
						list->Set_Entry_Text(itemIndex, COL_HOST_NAME, channel->GetName());
						}

					WideStringClass title(0, true);
					title.Convert_From(gameInfo.Title());
					list->Set_Entry_Text(itemIndex, COL_GAME_TITLE, title);

					// Show the game type icons
					SetGameTypeFlags(list, itemIndex, gameInfo);

					// Show the map name
					WideStringClass mapName(64, true);					

					//
					//	If this is a mod'd game, then display the mod_name\map_name...
					//
					if (gameInfo.ModName() != NULL && gameInfo.ModName()[0] != 0) {
						
						//
						//	Strip off the extension for both the map and the mod package
						//
						char map_name[_MAX_FNAME] = { 0 };
						char mod_name[_MAX_FNAME] = { 0 };
						::_splitpath (gameInfo.MapName(), NULL, NULL, map_name, NULL);
						::_splitpath (gameInfo.ModName(), NULL, NULL, mod_name, NULL);

						//
						//	Create the map name from the aggregate of the mod and map
						//
						StringClass ascii_map_name;
						ascii_map_name.Format ("%s\\%s", mod_name, map_name);
						mapName.Convert_From (ascii_map_name);
					} else {
						mapName = gameInfo.MapName();
					}

					list->Set_Entry_Text(itemIndex, COL_GAME_MAP, mapName);

					// Show the number of current / max players
					list->Set_Entry_Data(itemIndex, COL_PLAYERS, MAKELONG(gameInfo.NumPlayers(), gameInfo.MaxPlayers()));

					WideStringClass playersString(64, true);
					playersString.Format(L"%u/%u", gameInfo.NumPlayers(), gameInfo.MaxPlayers());
					list->Set_Entry_Text(itemIndex, COL_PLAYERS, playersString);
					
					// Show the ping time ranking
					SetPingTimeIcon(list, itemIndex, gameInfo.PingTime());

					if ((selIndex == -1) && (selectedGameName.Compare_No_Case(channel->GetName()) == 0))
						{
						selIndex = itemIndex;
						}

					if (gameInfo.Version() != (unsigned long)cNetwork::Get_Exe_Key() || !gameInfo.IsMapValid())
						{
						ChannelData* rawChannel = (ChannelData*)list->Get_Entry_Data(itemIndex, COL_HOST_NAME);

						if (rawChannel)
							{
							rawChannel->ReleaseReference();
							}

						list->Set_Entry_Data(itemIndex, COL_HOST_NAME, 0);
						if (gameInfo.IsMapValid()) {
							list->Set_Entry_Text(itemIndex, COL_GAME_TITLE, TRANSLATE(IDS_MENU_VERSION_MISMATCH));
						}

						/*
						WideStringClass diagnostic;
						diagnostic.Format(L"Version Mismatch (v. %u.%u)",
							HIWORD(gameInfo.Version()), LOWORD(gameInfo.Version()));
						list->Set_Entry_Text(itemIndex, COL_GAME_TITLE, diagnostic);
						*/

						Vector3 grey(0.5F, 0.5F, 0.5F);
						list->Set_Entry_Color(itemIndex, COL_ICON, grey);
						list->Set_Entry_Color(itemIndex, COL_HOST_NAME, grey);
						list->Set_Entry_Color(itemIndex, COL_GAME_TITLE, grey);
						list->Set_Entry_Color(itemIndex, COL_GAME_MAP, grey);
						list->Set_Entry_Color(itemIndex, COL_PLAYERS, grey);
						list->Set_Entry_Color(itemIndex, COL_PING, grey);
						list->Set_Entry_Data(itemIndex, 0, 0);
						}
					}
				}

			++listIndex;
			}

		++chanIter;
		}

	// Select the previously selected entry
	if ((selIndex != -1) && (list->Get_Entry_Count() > 0))
		{
		list->Set_Curr_Sel(selIndex);
		}
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::HandleNotification(ChannelListEvent)
*
* DESCRIPTION
*     Process the receipt of a game channel list.
*
* INPUTS
*     Channels - List of channels
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::HandleNotification(ChannelListEvent& event)
	{
	// Ignore chat channels
	if (event.GetChannelType() == 0)
		{
		return;
		}

	// Update the channel listbox
	ListCtrlClass* list = (ListCtrlClass*)Get_Dlg_Item(IDC_GAME_LIST_CTRL);

	if (list)
		{
		bool sort = false;

		switch (event.GetEvent())
			{
			default:
			case ChannelListEvent::Error:
			case ChannelListEvent::NewList:
				{
				ChannelList& chanList = event.Subject();
				bool listEmpty = chanList.empty();

				ListCtrlClass* details = (ListCtrlClass*)Get_Dlg_Item(IDC_DETAILS_LIST);

				if (details)
					{
					details->Delete_All_Entries();

					if (listEmpty)
						{
						details->Insert_Entry(0, TRANSLATE(IDS_MENU_NO_GAME_SERVERS_FOUND));
						}
					}

				Enable_Dlg_Item(IDC_JOIN_GAME_BUTTON, !listEmpty);
				Enable_Dlg_Item(IDC_REFRESH_GAME_LIST, true);
				mChannelListPending = false;
				}
				break;

			case ChannelListEvent::Update:
				UpdateChannels(list, event.Subject());
				sort = true;
				break;

			case ChannelListEvent::Remove:
				{
				ChannelList& chanList = event.Subject();
				ChannelList::iterator chanIter = chanList.begin();

				while (chanIter != chanList.end())
					{
					RefPtr<ChannelData> channel = (*chanIter);
					int index = list->Find_Entry(COL_HOST_NAME, channel->GetName());

					if (index >= 0)
						{
						list->Delete_Entry(index);
						sort = true;
						}

					++chanIter;
					}
				}
				break;
			}

		if (sort)
			{
			SortGameChannels(mSortColumn, mIsSortAscending, mSortFlags);
			}
		}
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::On_ListCtrl_Delete_Entry
*
* DESCRIPTION
*     Handle the deletion of a listbox entry
*
* INPUTS
*     List  - Pointer to list control originating notification.
*     ID    - Identifier of list control originating notification.
*     Index - Index of entry being deleted
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::On_ListCtrl_Delete_Entry(ListCtrlClass* list, int id, int index)
	{
	if (IDC_GAME_LIST_CTRL == id)
		{
		ChannelData* rawChannel = (ChannelData*)list->Get_Entry_Data(index, COL_HOST_NAME);

		if (rawChannel)
			{
			rawChannel->ReleaseReference();
			}
		}
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::On_ListCtrl_Sel_Change
*
* DESCRIPTION
*     Handle user selecting a game entry.
*
* INPUTS
*     List   - Pointer to list control originating notification.
*     ID     - Identifier of list control originating notification.
*     OldSel - Index of previous selection
*     NewSel - Index of new selection
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::On_ListCtrl_Sel_Change(ListCtrlClass* list, int id, int oldIndex, int newIndex)
	{
	if (IDC_GAME_LIST_CTRL == id)
		{
		Enable_Dlg_Item(IDC_JOIN_GAME_BUTTON, false);

		mSelectedGame.Reset();

		// Clear any detailed game information.
		ListCtrlClass* detailsList = (ListCtrlClass*)Get_Dlg_Item(IDC_DETAILS_LIST);
		detailsList->Delete_All_Entries();

		if (newIndex >= 0)
			{
			RefPtr<ChannelData> channel = (ChannelData*)list->Get_Entry_Data(newIndex, COL_HOST_NAME);

			if (channel.IsValid())
				{
				mSelectedGame.ImportFromChannel(channel);

				if (mSelectedGame.IsDataValid())
					{
					WideStringClass text(255, true);

					// Show host name and exe version
// Denzil 02/14/02 The version encoded in the channel is NOT the printable version.
// Just show the EXE version until we can work this out.
#if(0)
					text.Format(TRANSLATE(IDS_MENU_HOST_INFO_FORMAT), (const WCHAR*)channel->GetName(),
							mSelectedGame.Title(), HIWORD(mSelectedGame.Version()), LOWORD(mSelectedGame.Version()));
#else
					unsigned long verMajor = 0;
					unsigned long verMinor = 0;
					Get_Version_Number(&verMajor,&verMinor);

					text.Format(TRANSLATE(IDS_MENU_HOST_INFO_FORMAT), (const WCHAR*)channel->GetName(),
							mSelectedGame.Title(), HIWORD(verMajor), LOWORD(verMajor));
#endif
					detailsList->Insert_Entry(0, text);

					// If this is a clan game then show the opposing clans
					if (mSelectedGame.IsClanGame()) {
						GetClanVSClanString(mSelectedGame, text);
						int entryIndex = detailsList->Insert_Entry(detailsList->Get_Entry_Count(), text);
						detailsList->Set_Entry_Data(entryIndex, 0, CLAN_ENTRY_MARKER);
					}

					// Show server settings
					text.Format(TRANSLATE(IDS_MENU_HOST_OPTIONS_INFO_FORMAT),
							mSelectedGame.IsDedicated() ? TRANSLATE(IDS_MENU_TEXT463) : TRANSLATE(IDS_MENU_TEXT464),
							mSelectedGame.IsPassworded() ? TRANSLATE(IDS_MENU_TEXT463) : TRANSLATE(IDS_MENU_TEXT464),
							mSelectedGame.IsLaddered() ? TRANSLATE(IDS_MENU_TEXT463) : TRANSLATE(IDS_MENU_TEXT464),
							mSelectedGame.IsQuickmatch() ? TRANSLATE(IDS_MENU_TEXT463) : TRANSLATE(IDS_MENU_TEXT464));

					detailsList->Insert_Entry(detailsList->Get_Entry_Count(), text);

					text.Format(TRANSLATE(IDS_MENU_HOST_OPTIONS_INFO2_FORMAT),
							mSelectedGame.IsClanGame() ? TRANSLATE (IDS_MENU_ON) : TRANSLATE(IDS_MENU_OFF),
							mSelectedGame.IsTeamChange() ? TRANSLATE (IDS_MENU_ON) : TRANSLATE(IDS_MENU_OFF),
							mSelectedGame.IsTeamRemix() ? TRANSLATE (IDS_MENU_ON) : TRANSLATE(IDS_MENU_OFF),
							mSelectedGame.IsFriendlyFire() ? TRANSLATE (IDS_MENU_ON) : TRANSLATE(IDS_MENU_OFF));

					detailsList->Insert_Entry(detailsList->Get_Entry_Count(), text);

					text.Format(TRANSLATE(IDS_MENU_HOST_OPTIONS_INFO3_FORMAT),
							mSelectedGame.IsDriverGunner() ? TRANSLATE(IDS_MENU_ON) : TRANSLATE(IDS_MENU_OFF),
							mSelectedGame.IsSpawnWeapons() ? TRANSLATE(IDS_MENU_ON) : TRANSLATE(IDS_MENU_OFF),
							mSelectedGame.IsRepairBuildings() ? TRANSLATE(IDS_MENU_ON) : TRANSLATE(IDS_MENU_OFF));

					detailsList->Insert_Entry(detailsList->Get_Entry_Count(), text);
					}

				bool canJoin = mSelectedGame.CanUserJoin(mWOLSession->GetCurrentUser());
				Enable_Dlg_Item(IDC_JOIN_GAME_BUTTON, canJoin);
				}
			}
		}
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::GetClanVSClanString(WOLGameInfo& gameInfo, WideStringClass& text)
	{
	const char* clan1Name = "____";
	const char* clan2Name = "____";

	RefPtr<SquadData> clan = SquadData::FindByID(gameInfo.ClanID1());

	if (clan.IsValid())
		{
		clan1Name = clan->GetName();
		}
	else if (gameInfo.ClanID1() != 0)
		{
		clan1Name = "????";
		mWOLSession->RequestSquadInfoByID(gameInfo.ClanID1());
		}

	clan = SquadData::FindByID(gameInfo.ClanID2());

	if (clan.IsValid())
		{
		clan2Name = clan->GetName();
		}
	else if (gameInfo.ClanID2() != 0)
		{
		clan2Name = "????";
		mWOLSession->RequestSquadInfoByID(gameInfo.ClanID2());
		}

	text.Format(L"%S  -VS-  %S", clan1Name, clan2Name);
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::On_ListCtrl_Column_Click
*
* DESCRIPTION
*     Respond to user clicking on a column header of a list control.
*
* INPUTS
*     List   - Pointer to list control originating notification.
*     ID     - Identifier of list control originating notification.
*     Column - Number of column clicked.
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::On_ListCtrl_Column_Click(ListCtrlClass* list, int id, int column)
	{
	if (IDC_GAME_LIST_CTRL == id)
		{
		// If clicking the same column then toggle ascending / descending
		if (mSortColumn == column)
			{
			SortGameChannels(column, !mIsSortAscending, mSortFlags);
			}
		else
			{
			SortGameChannels(column, true, mSortFlags);
			}
		}
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::On_ListCtrl_DblClk
*
* DESCRIPTION
*     Automatically attempt to join a game if the user double-clicks on the
*     game entry.
*
* INPUTS
*     List  - List control
*     ID    - Identifier of list control
*     Index - Entry index double-clicked
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::On_ListCtrl_DblClk(ListCtrlClass* list, int id, int index)
	{
	if (IDC_GAME_LIST_CTRL == id)
		{
		Join_Game();
		}
	}


/******************************************************************************
*
* NAME
*     On_Last_Menu_Ending
*
* DESCRIPTION
*     Callback from menu class signifying the close of the last menu
*
* INPUTS
*
* RESULT
*
******************************************************************************/

void MPWolGameListMenuClass::On_Last_Menu_Ending (void)
	{
	RenegadeDialogMgrClass::Goto_Location(RenegadeDialogMgrClass::LOC_INTERNET_MAIN);
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::HandleNotification(ServerError)
*
* DESCRIPTION
*     Handle server error notifications from WWOnline session.
*
* INPUTS
*     Error - Server error
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::HandleNotification(ServerError& error)
	{
	if (CHAT_E_BANNED == error.GetErrorCode())
		{
//		DlgMsgBox::DoDialog(TRANSLATE(IDS_WOL_SERVERMESSAGE), TRANSLATE(IDS_WOL_BANNED));
		DlgMsgBox::DoDialog(TRANSLATE (IDS_MENU_SERVER_MESSAGE_TITLE), TRANSLATE (IDS_MENU_WOL_BAN_USER_MESSAGE));
		End_Dialog();
		}
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::HandleNotification(SquadEvent)
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::HandleNotification(WWOnline::SquadEvent& event)
	{
	if (!mSelectedGame.IsDataValid() && mSelectedGame.IsClanGame())
		{
		return;
		}

	RefPtr<SquadData> squad = event.GetSquadData();

	if (squad.IsValid())
		{
		unsigned long squadID = squad->GetID();

		if (mSelectedGame.ClanID1() == squadID || mSelectedGame.ClanID2() == squadID)
			{
			ListCtrlClass* detailsList = (ListCtrlClass*)Get_Dlg_Item(IDC_DETAILS_LIST);

			if (detailsList)
				{
				// Find entry with marker indicating clan vs clan
				const int count = detailsList->Get_Entry_Count();
		
				for (int index = 0; index < count; ++index)
					{
					int marker = detailsList->Get_Entry_Data(index, 0);

					if (CLAN_ENTRY_MARKER == marker)
						{
						WideStringClass text(0, true);
						GetClanVSClanString(mSelectedGame, text);
						detailsList->Set_Entry_Text(index, 0, text);
						break;
						}
					}
				}
			}
		}
	}


/******************************************************************************
*
* NAME
*     SetGameTypeFlags
*
* DESCRIPTION
*     Setup the game type flags in the icon column of the game listings.
*
* INPUTS
*     List     - Pointer to list control to work with.
*     Index    - Entry index to set type flags for.
*     GameInfo - Game information
*
* RESULT
*
******************************************************************************/

void SetGameTypeFlags(ListCtrlClass* list, int itemIndex, const WOLGameInfo& gameInfo)
	{
	WWASSERT(list != NULL);

	list->Reset_Icons(itemIndex, COL_ICON);
	uint32 flags = 0;

	if (gameInfo.IsLaddered())
		{
		list->Add_Icon(itemIndex, COL_ICON, "MUL_pts.tga");
		flags |= FLAGSORT_LADDERED;
		}
	else
		{
		list->Add_Icon(itemIndex, COL_ICON, "MUL_NoPts.tga");
		}

	if (gameInfo.IsDedicated())
		{
		list->Add_Icon(itemIndex, COL_ICON, "MUL_Spec.tga");
		flags |= FLAGSORT_DEDICATED;
		}

	if (gameInfo.IsPassworded())
		{
		list->Add_Icon(itemIndex, COL_ICON, "MUL_Pswrd.tga");
		flags |= FLAGSORT_PASSWORDED;
		}

	if (gameInfo.IsClanGame())
		{
		list->Add_Icon(itemIndex, COL_ICON, "MUL_Btlcln.tga");
		flags |= FLAGSORT_CLAN;
		}

	list->Set_Entry_Data(itemIndex, COL_ICON, flags);
	}


/******************************************************************************
*
* NAME
*     SetPingTimeIcon
*
* DESCRIPTION
*     Set an icon reflecting the latency for this game.
*
* INPUTS
*     List  - List control
*     Index - Entry index
*     Time  - Latency
*
* RESULT
*     NONE
*
******************************************************************************/

void SetPingTimeIcon(ListCtrlClass* list, int itemIndex, long pingTime)
	{
	const char* pingIcon = NULL;

	if (pingTime <= PING_GREEN_THRESHOLD)
		{
		pingIcon = "mul_statg.tga";
		}
	else if (pingTime <= PING_YELLOW_THRESHOLD)
		{
		pingIcon = "mul_staty.tga";
		}
	else
		{
		pingIcon = "mul_statr.tga";
		}

	list->Reset_Icons(itemIndex, COL_PING);
	list->Add_Icon(itemIndex, COL_PING, pingIcon);

	unsigned long displayPing = (unsigned long)((1000.0 / 256.0) * (sqrt(double(pingTime))));
	list->Set_Entry_Data(itemIndex, COL_PING, displayPing);

	WideStringClass text(32, true);
	text.Format(L" (%lu)", displayPing);
	list->Set_Entry_Text(itemIndex, COL_PING, text);
	}


/******************************************************************************
*
* NAME
*     MPWolGameListMenuClass::SortGameChannels
*
* DESCRIPTION
*     Sort the game channels
*
* INPUTS
*     Column    - Number of column to sort by.
*     Ascending - True to sort ascending; false to sort descending
*     Flags     - Game flags to sort by if column is COL_ICON
*
* RESULT
*     NONE
*
******************************************************************************/

void MPWolGameListMenuClass::SortGameChannels(int column, bool isAscending, unsigned long param)
	{
	mSortColumn = column;
	mIsSortAscending = isAscending;
	mSortFlags = param;

	ListCtrlClass* list = (ListCtrlClass*)Get_Dlg_Item(IDC_GAME_LIST_CTRL);

	if (list)
		{
		ListCtrlClass::SORT_TYPE sortDirection = ListCtrlClass::SORT_DESCENDING;

		if (isAscending)
			{
			sortDirection = ListCtrlClass::SORT_ASCENDING;
			}

		if (COL_ICON == column)
			{
			list->Sort(FlagsSortCallback, mSortFlags);
			}
		else if (COL_PLAYERS == column || COL_PING == column)
			{
			list->Sort(NumericSortCallback, MAKELONG(column, sortDirection));
			}
		else
			{
			list->Sort(AlphaSortCallback, MAKELONG(column, sortDirection));
			}

		list->Set_Sort_Designator(column, sortDirection);
		}
	}


/******************************************************************************
*
* NAME
*     FlagSortCallback
*
* DESCRIPTION
*     Sort list entries by game type flags.
*
* INPUTS
*     List   - List control performing sort.
*     Index1 - First entry to compare
*     Index2 - Second entry to compare
*
* RESULT
*     0  - Items are equal
*     -1 - Item1 is less than item2
*     1  - Item1 is greater than item2
*
******************************************************************************/

int CALLBACK FlagsSortCallback(ListCtrlClass* list, int index1, int index2, uint32 mask)
	{
	uint32 flags1 = list->Get_Entry_Data(index1, COL_ICON);
	flags1 &= mask;

	uint32 flags2 = list->Get_Entry_Data(index2, COL_ICON);
	flags2 &= mask;

	if (flags1 && !flags2)
		{
		return -1;
		}
	else if (!flags1 && flags2)
		{
		return 1;
		}
	else if (flags1 && flags2)
		{
		// Secondary sort by ping time
		int ping1 = list->Get_Entry_Data(index1, COL_PING);
		int ping2 = list->Get_Entry_Data(index2, COL_PING);

		int delta = (ping1 - ping2);

		if (delta < 0)
			{
			return -1;
			}
		else if (delta > 0)
			{
			return 1;
			}

		const WCHAR* name1 = list->Get_Entry_Text(index1, COL_HOST_NAME);
		const WCHAR* name2 = list->Get_Entry_Text(index2, COL_HOST_NAME);
		return wcsicmp(name1, name2);
		}

	return 0;
	}


/******************************************************************************
*
* NAME
*     NumericSortCallback
*
* DESCRIPTION
*     Sort list entries numerically from the numbers contained in the entries
*     data field.
*
* INPUTS
*     List   - List control performing sort.
*     Index1 - First entry to compare
*     Index2 - Second entry to compare
*
* RESULT
*    -1 - Item1 is less than item2
*     0 - Items are equal
*     1 - Item1 is greater than item2
*
******************************************************************************/

int CALLBACK NumericSortCallback(ListCtrlClass* list, int index1, int index2, uint32 param)
	{
	// Sort by numeric value stored in entry data field
	int	column = LOWORD(param);

	uint32 data1 = list->Get_Entry_Data(index1, column);
	uint32 data2 = list->Get_Entry_Data(index2, column);

	int retval = (data1 - data2);

	if (retval < 0)
		{
		retval = -1;
		}
	else if (retval > 0)
		{
		retval = 1;
		}
	else
		{
		if (column != COL_PING)
			{
			// Secondary sort by ping time
			data1 = list->Get_Entry_Data(index1, COL_PING);
			data2 = list->Get_Entry_Data(index2, COL_PING);

			retval = (data1 - data2);

			if (retval < 0)
				{
				retval = -1;
				}
			else if (retval > 0)
				{
				retval = 1;
				}
			}

		if (retval == 0)
			{
			const WCHAR* name1 = list->Get_Entry_Text(index1, COL_HOST_NAME);
			const WCHAR* name2 = list->Get_Entry_Text(index2, COL_HOST_NAME);
			retval = wcsicmp(name1, name2);
			}
		}

	// Invert the return value if we are sorting descendingly
	ListCtrlClass::SORT_TYPE sortType = (ListCtrlClass::SORT_TYPE)HIWORD(param);

	if (ListCtrlClass::SORT_DESCENDING == sortType)
		{
		return -retval;
		}

	return retval;
	}


/******************************************************************************
*
* NAME
*     NumericSortCallback
*
* DESCRIPTION
*     Sort list entries alphbetically then by ping time.
*
* INPUTS
*     List   - List control performing sort.
*     Index1 - First entry to compare
*     Index2 - Second entry to compare
*
* RESULT
*    -1 - Item1 is less than item2
*     0 - Items are equal
*     1 - Item1 is greater than item2
*
******************************************************************************/

int CALLBACK AlphaSortCallback(ListCtrlClass* list, int index1, int index2, uint32 param)
	{
	// Sort by numeric value stored in entry data field
	int	column = LOWORD(param);

	const WCHAR* text1 = list->Get_Entry_Text(index1, column);
	const WCHAR* text2 = list->Get_Entry_Text(index2, column);
	int retval = wcsicmp(text1, text2);

	// If the strings match then secondary sort by ping time.
	if (retval == 0)
		{
		uint32 data1 = list->Get_Entry_Data(index1, COL_PING);
		uint32 data2 = list->Get_Entry_Data(index2, COL_PING);

		retval = (data1 - data2);

		if (retval < 0)
			{
			retval = -1;
			}
		else if (retval > 0)
			{
			retval = 1;
			}
		}

	// Invert the return value if we are sorting descendingly
	ListCtrlClass::SORT_TYPE sortType = (ListCtrlClass::SORT_TYPE)HIWORD(param);

	if (ListCtrlClass::SORT_DESCENDING == sortType)
		{
		return -retval;
		}

	return retval;
	}