Initial commit

1 files changed, 2767 insertions, 0 deletions

diff --git a/Minecraft.Client/Common/XUI/XUI_MultiGameJoinLoad.cpp b/Minecraft.Client/Common/XUI/XUI_MultiGameJoinLoad.cpp
new file mode 100644
index 00000000..73f25da5
--- /dev/null
+++ b/Minecraft.Client/Common/XUI/XUI_MultiGameJoinLoad.cpp
@@ -0,0 +1,2767 @@
+#include "stdafx.h"
+#include <xuiresource.h>
+#include <xuiapp.h>
+#include <assert.h>
+#include "..\..\..\Minecraft.World\StringHelpers.h"
+#include "..\..\Common\Tutorial\TutorialMode.h"
+#include "..\..\..\Minecraft.World\ConsoleSaveFileIO.h"
+#include "..\..\LocalPlayer.h"
+#include "..\..\Minecraft.h"
+#include "..\..\ProgressRenderer.h"
+#include "..\..\..\Minecraft.World\AABB.h"
+#include "..\..\..\Minecraft.World\Vec3.h"
+#include "..\..\..\Minecraft.World\ArrayWithLength.h"
+#include "..\..\..\Minecraft.World\File.h"
+#include "..\..\..\Minecraft.World\InputOutputStream.h"
+#include "XUI_Ctrl_4JList.h"
+#include "XUI_Ctrl_4JIcon.h"
+#include "XUI_LoadSettings.h"
+#include "XUI_MultiGameInfo.h"
+#include "XUI_MultiGameJoinLoad.h"
+#include "XUI_MultiGameCreate.h"
+#include "..\..\MinecraftServer.h"
+#include "..\..\Options.h"
+
+#include "..\GameRules\LevelGenerationOptions.h"
+#include "..\..\TexturePackRepository.h"
+#include "..\..\TexturePack.h"
+#include "..\..\..\Minecraft.World\LevelSettings.h"
+
+#define CHECKFORAVAILABLETEXTUREPACKS_TIMER_ID 3
+#define CHECKFORAVAILABLETEXTUREPACKS_TIMER_TIME 100
+
+//----------------------------------------------------------------------------------
+// Performs initialization tasks - retrieves controls.
+//----------------------------------------------------------------------------------
+HRESULT CScene_MultiGameJoinLoad::OnInit( XUIMessageInit* pInitData, BOOL& bHandled )
+{
+
+	m_iPad=*(int *)pInitData->pvInitData;
+	m_bReady=false;
+	MapChildControls();
+
+	m_iTexturePacksNotInstalled=0;
+	m_iConfigA=NULL;
+	
+	XuiControlSetText(m_LabelNoGames,app.GetString(IDS_NO_GAMES_FOUND));
+	XuiControlSetText(m_GamesList,app.GetString(IDS_JOIN_GAME));
+	XuiControlSetText(m_SavesList,app.GetString(IDS_START_GAME));
+
+
+	const DWORD LOCATOR_SIZE = 256; // Use this to allocate space to hold a ResourceLocator string 
+	WCHAR szResourceLocator[ LOCATOR_SIZE ];
+
+	const ULONG_PTR c_ModuleHandle = (ULONG_PTR)GetModuleHandle(NULL);
+	swprintf(szResourceLocator, LOCATOR_SIZE ,L"section://%X,%ls#%ls",c_ModuleHandle,L"media", L"media/Graphics/TexturePackIcon.png");
+
+	m_DefaultMinecraftIconSize = 0;
+	HRESULT hr = XuiResourceLoadAllNoLoc(szResourceLocator, &m_DefaultMinecraftIconData, &m_DefaultMinecraftIconSize);
+
+	m_localPlayers = 1;
+	m_bKillSaveInfoEnumerate=false;
+
+	m_bShowingPartyGamesOnly = false;
+
+	m_bRetrievingSaveInfo=false;
+	m_bSaveTransferInProgress=false;
+	
+	// check for a default custom cloak in the global storage
+	// 4J-PB - changed to a config file
+// 	if(ProfileManager.IsSignedInLive( m_iPad ))
+// 	{		
+// 		app.InstallDefaultCape();
+// 	}
+
+	m_initData= new JoinMenuInitData();
+	m_bMultiplayerAllowed = ProfileManager.IsSignedInLive( m_iPad ) && ProfileManager.AllowedToPlayMultiplayer(m_iPad);
+	
+	XPARTY_USER_LIST partyList;
+
+	if((XPartyGetUserList(  &partyList ) != XPARTY_E_NOT_IN_PARTY ) && (partyList.dwUserCount>1))
+	{
+		m_bInParty=true;
+	}
+	else
+	{
+		m_bInParty=false;
+	}
+
+	int iLB = -1;
+	if(m_bInParty) iLB = IDS_TOOLTIPS_PARTY_GAMES;
+
+	XuiSetTimer(m_hObj,JOIN_LOAD_ONLINE_TIMER_ID,JOIN_LOAD_ONLINE_TIMER_TIME);
+	
+	m_iSaveInfoC=0;
+
+	VOID *pObj;
+	XuiObjectFromHandle( m_SavesList, &pObj );
+	m_pSavesList = (CXuiCtrl4JList *)pObj;
+
+	XuiObjectFromHandle( m_GamesList, &pObj );
+	m_pGamesList = (CXuiCtrl4JList *)pObj;
+
+	// block input if we're waiting for DLC to install, and wipe the saves list. The end of dlc mounting custom message will fill the list again
+	if(app.StartInstallDLCProcess(m_iPad)==true)
+	{
+		// not doing a mount, so enable input
+		m_bIgnoreInput=true;
+	}
+	else
+	{
+		// if we're waiting for DLC to mount, don't fill the save list. The custom message on end of dlc mounting will do that
+		m_bIgnoreInput=false;
+	
+
+
+		m_iChangingSaveGameInfoIndex = 0;
+
+		m_generators = app.getLevelGenerators();
+		m_iDefaultButtonsC = 0;
+		m_iMashUpButtonsC=0;
+
+		// check if we're in the trial version
+		if(ProfileManager.IsFullVersion()==false)
+		{
+			ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK, -1, -1, -1, -1,iLB);
+
+			AddDefaultButtons();
+
+			m_pSavesList->SetCurSelVisible(0);
+		}
+		else if(StorageManager.GetSaveDisabled())
+		{
+			if(StorageManager.GetSaveDeviceSelected(m_iPad))
+			{
+				// saving is disabled, but we should still be able to load from a selected save device
+
+				ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_CHANGEDEVICE,-1,-1,-1,iLB,IDS_TOOLTIPS_DELETESAVE);
+			
+				GetSaveInfo();
+			}
+			else
+			{
+				ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_SELECTDEVICE,-1,-1,-1,iLB);
+
+				AddDefaultButtons();
+				m_SavesListTimer.SetShow( FALSE );
+
+				m_pSavesList->SetCurSelVisible(0);
+			}
+		}
+		else
+		{
+			// 4J-PB - we need to check that there is enough space left to create a copy of the save (for a rename)
+			bool bCanRename = StorageManager.EnoughSpaceForAMinSaveGame();
+			ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_CHANGEDEVICE,-1,-1,-1,-1,bCanRename?IDS_TOOLTIPS_SAVEOPTIONS:IDS_TOOLTIPS_DELETESAVE);
+		
+			GetSaveInfo();
+		}
+	}
+	//XuiElementSetDisableFocusRecursion( m_pGamesList->m_hObj, TRUE);
+
+	UpdateGamesList();
+
+	g_NetworkManager.SetSessionsUpdatedCallback( &CScene_MultiGameJoinLoad::UpdateGamesListCallback, this );
+
+	// 4J Stu - Fix for #12530 -TCR 001 BAS Game Stability: Title will crash if the player disconnects while starting a new world and then opts to play the tutorial once they have been returned to the Main Menu.
+	MinecraftServer::resetFlags();
+	
+	// If we're not ignoring input, then we aren't still waiting for the DLC to mount, and can now check for corrupt dlc. Otherwise this will happen when the dlc has finished mounting.
+	if( !m_bIgnoreInput)
+	{
+		app.m_dlcManager.checkForCorruptDLCAndAlert();
+	}
+
+
+	// 4J-PB - Load up any texture pack data we have locally in the XZP
+	for(int i=0;i<TMS_COUNT;i++)
+	{
+		if(app.TMSFileA[i].eTMSType==eTMSFileType_TexturePack)
+		{
+			app.LoadLocalTMSFile(app.TMSFileA[i].wchFilename,app.TMSFileA[i].eEXT);
+			app.AddMemoryTPDFile(app.TMSFileA[i].iConfig, app.TMSFileA[i].pbData,app.TMSFileA[i].uiSize);
+		}
+	}
+
+	// 4J-PB - there may be texture packs we don't have, so use the info from TMS for this
+
+	DLC_INFO *pDLCInfo=NULL;
+
+	// first pass - look to see if there are any that are not in the list
+	bool bTexturePackAlreadyListed;
+	bool bNeedToGetTPD=false;
+	Minecraft *pMinecraft = Minecraft::GetInstance();
+	int texturePacksCount = pMinecraft->skins->getTexturePackCount();	
+	//CXuiCtrl4JList::LIST_ITEM_INFO ListInfo;
+	//HRESULT hr;
+
+
+	for(unsigned int i = 0; i < app.GetDLCInfoTexturesOffersCount(); ++i)
+	{
+		bTexturePackAlreadyListed=false;
+		ULONGLONG ull=app.GetDLCInfoTexturesFullOffer(i);
+		pDLCInfo=app.GetDLCInfoForFullOfferID(ull);
+		for(unsigned int i = 0; i < texturePacksCount; ++i)
+		{
+			TexturePack *tp = pMinecraft->skins->getTexturePackByIndex(i);
+			if(pDLCInfo->iConfig==tp->getDLCParentPackId())
+			{
+				bTexturePackAlreadyListed=true;
+			}
+		}
+		if(bTexturePackAlreadyListed==false)
+		{
+			// some missing
+			bNeedToGetTPD=true;
+
+			m_iTexturePacksNotInstalled++;
+		}
+	}
+
+	if(bNeedToGetTPD==true)
+	{
+		// add a TMS request for them
+		app.DebugPrintf("+++ Adding TMSPP request for texture pack data\n");
+		app.AddTMSPPFileTypeRequest(e_DLC_TexturePackData);
+		m_iConfigA= new int [m_iTexturePacksNotInstalled];
+		m_iTexturePacksNotInstalled=0;
+
+		for(unsigned int i = 0; i < app.GetDLCInfoTexturesOffersCount(); ++i)
+		{
+			bTexturePackAlreadyListed=false;
+			ULONGLONG ull=app.GetDLCInfoTexturesFullOffer(i);
+			pDLCInfo=app.GetDLCInfoForFullOfferID(ull);
+			for(unsigned int i = 0; i < texturePacksCount; ++i)
+			{
+				TexturePack *tp = pMinecraft->skins->getTexturePackByIndex(i);
+				if(pDLCInfo->iConfig==tp->getDLCParentPackId())
+				{
+					bTexturePackAlreadyListed=true;
+				}
+			}
+			if(bTexturePackAlreadyListed==false)
+			{
+				m_iConfigA[m_iTexturePacksNotInstalled++]=pDLCInfo->iConfig;
+			}
+		}
+	}
+
+	XuiSetTimer(m_hObj,CHECKFORAVAILABLETEXTUREPACKS_TIMER_ID,CHECKFORAVAILABLETEXTUREPACKS_TIMER_TIME);
+
+	return S_OK;
+}
+
+void CScene_MultiGameJoinLoad::AddDefaultButtons()
+{
+	CXuiCtrl4JList::LIST_ITEM_INFO ListInfo;
+
+	// Add two for New Game and Tutorial
+	ZeroMemory(&ListInfo,sizeof(CXuiCtrl4JList::LIST_ITEM_INFO));
+
+	ListInfo.pwszText = app.GetString(IDS_CREATE_NEW_WORLD);
+	ListInfo.fEnabled = TRUE;
+	ListInfo.iData = -1;
+	m_pSavesList->AddData(ListInfo);
+
+	int iSavesListIndex = 0;
+	int iGeneratorIndex = 0;
+	m_iMashUpButtonsC=0;
+
+	for(AUTO_VAR(it, m_generators->begin()); it != m_generators->end(); ++it)
+	{
+		LevelGenerationOptions *levelGen = *it;
+		ListInfo.pwszText = levelGen->getWorldName();
+		ListInfo.fEnabled = TRUE;
+		ListInfo.iData = iGeneratorIndex++; // used to index into the list of generators
+
+		// need to check if the user has disabled this pack in the save display list
+		unsigned int uiTexturePackID=levelGen->getRequiredTexturePackId();
+
+		if(uiTexturePackID!=0)
+		{
+			unsigned int uiMashUpWorldsBitmask=app.GetMashupPackWorlds(m_iPad);
+
+			if((uiMashUpWorldsBitmask & (1<<(uiTexturePackID-1024)))==0)
+			{
+				// this world is hidden, so skip
+				continue;
+			}
+		}
+		m_pSavesList->AddData(ListInfo);
+
+		// retrieve the save icon from the texture pack, if there is one
+		if(uiTexturePackID!=0)
+		{
+			// increment the count of the mash-up pack worlds in the save list
+			m_iMashUpButtonsC++;
+			TexturePack *tp = Minecraft::GetInstance()->skins->getTexturePackById(levelGen->getRequiredTexturePackId());
+			DWORD dwImageBytes;	
+			PBYTE pbImageData = tp->getPackIcon(dwImageBytes);
+			HXUIBRUSH hXuiBrush;
+
+			if(dwImageBytes > 0 && pbImageData)
+			{
+				XuiCreateTextureBrushFromMemory(pbImageData,dwImageBytes,&hXuiBrush);
+				// the index inside the list item for this will be i+1 because they start at m_vListData.size(), so the first etry (tutorial) is 1
+				m_pSavesList->UpdateGraphic(iSavesListIndex+1,hXuiBrush);
+			}
+		}
+
+		++iSavesListIndex;
+	}
+
+	m_iDefaultButtonsC = iSavesListIndex + 1;
+}
+
+
+HRESULT CScene_MultiGameJoinLoad::GetSaveInfo(  )
+{
+	unsigned int uiSaveC=0;
+
+	// This will return with the number retrieved in uiSaveC
+
+	if(app.DebugSettingsOn() && app.GetLoadSavesFromFolderEnabled())
+	{
+		uiSaveC = 0;
+		File savesDir(L"GAME:\\Saves");
+		if( savesDir.exists() )
+		{
+			m_saves = savesDir.listFiles();
+			uiSaveC = (unsigned int)m_saves->size();
+		}
+		// add the New Game and Tutorial after the saves list is retrieved, if there are any saves
+
+		// Add two for New Game and Tutorial
+		unsigned int listItems = uiSaveC;
+
+		CXuiCtrl4JList::LIST_ITEM_INFO ListInfo;
+		ZeroMemory(&ListInfo,sizeof(CXuiCtrl4JList::LIST_ITEM_INFO));
+
+		AddDefaultButtons();
+
+		for(unsigned int i=0;i<listItems;i++)
+		{
+
+			wstring wName = m_saves->at(i)->getName();
+			wchar_t *name = new wchar_t[wName.size()+1];
+			for(unsigned int j = 0; j < wName.size(); ++j)
+			{
+				name[j] = wName[j];
+			}
+			name[wName.size()] = 0;
+			ListInfo.pwszText = name;
+			ListInfo.fEnabled=TRUE;
+			ListInfo.iData = -1;
+			m_pSavesList->AddData(ListInfo);
+		}	
+		m_pSavesList->SetCurSelVisible(0);	
+	}
+	else
+	{
+		m_bRetrievingSaveInfo=true; // we're blocking the exit from this scene until complete
+
+		// clear the saves list
+		m_pSavesList->RemoveAllData();
+
+		m_iSaveInfoC=0;
+#ifdef _XBOX
+		C4JStorage::ESGIStatus eSGIStatus=StorageManager.GetSavesInfo(ProfileManager.GetPrimaryPad(),&CScene_MultiGameJoinLoad::GetSavesInfoCallback,this,"savegame.dat");
+
+		if(eSGIStatus==C4JStorage::ESGIStatus_NoSaves)
+		{
+			uiSaveC=0;
+			m_SavesListTimer.SetShow( FALSE );
+			m_SavesList.SetEnable(TRUE);
+		}
+#else
+
+		//C4JStorage::ESaveGameState eStatus=StorageManager.GetSavesInfo(ProfileManager.GetPrimaryPad(),&CScene_MultiGameJoinLoad::GetSavesInfoCallback,this,"savegame.dat");
+
+#endif
+	}
+
+	return S_OK;
+}
+
+HRESULT CScene_MultiGameJoinLoad::OnDestroy()
+{
+	g_NetworkManager.SetSessionsUpdatedCallback( NULL, NULL );
+
+	for(AUTO_VAR(it, currentSessions.begin()); it < currentSessions.end(); ++it)
+	{
+		delete (*it);
+	}
+
+	if(m_bSaveTransferInProgress)
+	{
+		CancelSaveUploadCallback(this);
+	}
+
+	// Reset the background downloading, in case we changed it by attempting to download a texture pack
+	XBackgroundDownloadSetMode(XBACKGROUND_DOWNLOAD_MODE_AUTO);
+
+	// clear out the texture pack data
+	for(int i=0;i<TMS_COUNT;i++)
+	{
+		if(app.TMSFileA[i].eTMSType==eTMSFileType_TexturePack)
+		{
+			app.RemoveMemoryTPDFile(app.TMSFileA[i].iConfig);
+		}
+	}
+	app.FreeLocalTMSFiles(eTMSFileType_TexturePack);
+
+	return S_OK;
+}
+
+
+int CScene_MultiGameJoinLoad::DeviceRemovedDialogReturned(void *pParam,int iPad,C4JStorage::EMessageResult result)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+
+	// results switched for this dialog
+	if(result==C4JStorage::EMessage_ResultDecline) 
+	{
+		StorageManager.SetSaveDisabled(true);
+		StorageManager.SetSaveDeviceSelected(ProfileManager.GetPrimaryPad(),false);
+		// use the device select returned function to wipe the saves list and change the tooltip
+		CScene_MultiGameJoinLoad::DeviceSelectReturned(pClass,true);
+	}
+	else // continue without saving
+	{
+		// Change device
+		StorageManager.SetSaveDevice(&CScene_MultiGameJoinLoad::DeviceSelectReturned,pClass,true);
+	}
+
+	pClass->m_bIgnoreInput=false;
+	return 0;
+}
+//----------------------------------------------------------------------------------
+// Handler for the button press message.
+//----------------------------------------------------------------------------------
+HRESULT CScene_MultiGameJoinLoad::OnNotifyPressEx(HXUIOBJ hObjPressed, XUINotifyPress* pNotifyPressData, BOOL& rfHandled)
+{
+	if(m_bIgnoreInput) return S_OK;
+
+	// if we're retrieving save info, ignore key presses
+	if(m_bRetrievingSaveInfo)
+	{
+		return S_OK;
+	}
+
+	// This assumes all buttons can only be pressed with the A button
+	ui.AnimateKeyPress(pNotifyPressData->UserIndex, VK_PAD_A);
+
+	if ( hObjPressed == m_GamesList )
+	{
+		m_bIgnoreInput=true;
+
+		DWORD nIndex = m_pGamesList->GetCurSel();
+
+		if( m_pGamesList->GetItemCount() > 0 && nIndex < currentSessions.size() )
+		{
+			//CScene_MultiGameInfo::JoinMenuInitData *initData = new CScene_MultiGameInfo::JoinMenuInitData();
+			m_initData->iPad = m_iPad;
+			m_initData->selectedSession = currentSessions.at( nIndex );
+		
+			// check that we have the texture pack available
+			// If it's not the default texture pack
+			if(m_initData->selectedSession->data.texturePackParentId!=0)
+			{
+				int texturePacksCount = Minecraft::GetInstance()->skins->getTexturePackCount();
+				bool bHasTexturePackInstalled=false;
+
+				for(int i=0;i<texturePacksCount;i++)
+				{
+					TexturePack *tp = Minecraft::GetInstance()->skins->getTexturePackByIndex(i);
+					if(tp->getDLCParentPackId()==m_initData->selectedSession->data.texturePackParentId)
+					{
+						bHasTexturePackInstalled=true;
+						break;
+					}
+				}
+
+				if(bHasTexturePackInstalled==false)
+				{
+					// upsell the texture pack
+					// tell sentient about the upsell of the full version of the skin pack
+					ULONGLONG ullOfferID_Full;
+					app.GetDLCFullOfferIDForPackID(m_initData->selectedSession->data.texturePackParentId,&ullOfferID_Full);
+
+					TelemetryManager->RecordUpsellPresented(pNotifyPressData->UserIndex, eSet_UpsellID_Texture_DLC, ullOfferID_Full & 0xFFFFFFFF);
+
+					UINT uiIDA[3];
+
+					// Need to check if the texture pack has both Full and Trial versions - we may do some as free ones, so only Full
+					DLC_INFO *pDLCInfo=app.GetDLCInfoForFullOfferID(ullOfferID_Full);
+
+					if(pDLCInfo->ullOfferID_Trial!=0LL)
+					{
+						uiIDA[0]=IDS_TEXTUREPACK_FULLVERSION;
+						uiIDA[1]=IDS_TEXTURE_PACK_TRIALVERSION;
+						uiIDA[2]=IDS_CONFIRM_CANCEL;
+						// Give the player a warning about the texture pack missing
+						StorageManager.RequestMessageBox(IDS_DLC_TEXTUREPACK_NOT_PRESENT_TITLE, IDS_DLC_TEXTUREPACK_NOT_PRESENT, uiIDA, 3, ProfileManager.GetPrimaryPad(),&CScene_MultiGameJoinLoad::TexturePackDialogReturned,this,app.GetStringTable());
+					}
+					else
+					{
+						uiIDA[0]=IDS_TEXTUREPACK_FULLVERSION;
+						uiIDA[1]=IDS_CONFIRM_CANCEL;
+						// Give the player a warning about the texture pack missing
+						StorageManager.RequestMessageBox(IDS_DLC_TEXTUREPACK_NOT_PRESENT_TITLE, IDS_DLC_TEXTUREPACK_NOT_PRESENT, uiIDA, 2, ProfileManager.GetPrimaryPad(),&CScene_MultiGameJoinLoad::TexturePackDialogReturned,this,app.GetStringTable());
+					}
+
+					return S_OK;
+				}
+			}
+			
+			m_NetGamesListTimer.SetShow( FALSE );
+
+			// Reset the background downloading, in case we changed it by attempting to download a texture pack
+			XBackgroundDownloadSetMode(XBACKGROUND_DOWNLOAD_MODE_AUTO);
+
+			// kill the texture pack check timer
+			XuiKillTimer(m_hObj,CHECKFORAVAILABLETEXTUREPACKS_TIMER_ID);
+			app.NavigateToScene(pNotifyPressData->UserIndex,eUIScene_JoinMenu,m_initData);
+		}
+	}
+	else if(hObjPressed==m_SavesList)
+	{
+		m_bIgnoreInput=true;
+
+		CXuiControl pItem;
+		int iIndex;
+		// get the selected item
+		iIndex=m_SavesList.GetCurSel(&pItem);
+
+		CXuiCtrl4JList::LIST_ITEM_INFO info = m_pSavesList->GetData(iIndex);
+
+		if(iIndex == JOIN_LOAD_CREATE_BUTTON_INDEX)
+		{		
+			app.SetTutorialMode( false );
+			m_NetGamesListTimer.SetShow( FALSE );
+
+			app.SetCorruptSaveDeleted(false);
+
+			CreateWorldMenuInitData *params = new CreateWorldMenuInitData();
+			params->iPad = m_iPad;
+			app.NavigateToScene(pNotifyPressData->UserIndex,eUIScene_CreateWorldMenu,(void *)params);
+		}
+		else if(info.iData >= 0)
+		{
+			LevelGenerationOptions *levelGen = m_generators->at(info.iData);
+			app.SetTutorialMode( levelGen->isTutorial() );
+			// Reset the autosave time
+			app.SetAutosaveTimerTime();
+
+			if(levelGen->isTutorial())
+			{
+				LoadLevelGen(levelGen);
+			}
+			else
+			{
+				LoadMenuInitData *params = new LoadMenuInitData();
+				params->iPad = m_iPad;
+				// need to get the iIndex from the list item, since the position in the list doesn't correspond to the GetSaveGameInfo list because of sorting
+				params->iSaveGameInfoIndex=-1;
+				//params->pbSaveRenamed=&m_bSaveRenamed;
+				params->levelGen = levelGen;
+
+				// navigate to the settings scene
+				app.NavigateToScene(ProfileManager.GetPrimaryPad(),eUIScene_LoadMenu, params);
+			}
+		}
+		else
+		{			
+			// check if this is a damaged save
+			if(m_pSavesList->GetData(iIndex).bIsDamaged)
+			{
+				// give the option to delete the save
+				UINT uiIDA[2];
+				uiIDA[0]=IDS_CONFIRM_CANCEL;
+				uiIDA[1]=IDS_CONFIRM_OK;
+				StorageManager.RequestMessageBox(IDS_CORRUPT_OR_DAMAGED_SAVE_TITLE, IDS_CORRUPT_OR_DAMAGED_SAVE_TEXT, uiIDA, 2, pNotifyPressData->UserIndex,&CScene_MultiGameJoinLoad::DeleteSaveDialogReturned,this, app.GetStringTable());
+			}
+			else
+			{		
+				app.SetTutorialMode( false );
+				if(app.DebugSettingsOn() && app.GetLoadSavesFromFolderEnabled())
+				{
+					LoadSaveFromDisk(m_saves->at(iIndex-m_iDefaultButtonsC));
+				}
+				else
+				{
+					LoadMenuInitData *params = new LoadMenuInitData();
+					params->iPad = m_iPad;
+					// need to get the iIndex from the list item, since the position in the list doesn't correspond to the GetSaveGameInfo list because of sorting
+					params->iSaveGameInfoIndex=m_pSavesList->GetData(iIndex).iIndex-m_iDefaultButtonsC;
+					//params->pbSaveRenamed=&m_bSaveRenamed;
+					params->levelGen = NULL;
+
+					// kill the texture pack timer
+					XuiKillTimer(m_hObj,CHECKFORAVAILABLETEXTUREPACKS_TIMER_ID);
+					// navigate to the settings scene
+					app.NavigateToScene(ProfileManager.GetPrimaryPad(),eUIScene_LoadMenu, params);
+				}
+			}
+		}
+	}
+	
+	return S_OK;
+}
+
+HRESULT CScene_MultiGameJoinLoad::OnKeyDown(XUIMessageInput* pInputData, BOOL& rfHandled)
+{
+	if(m_bIgnoreInput) return S_OK;
+
+	// if we're retrieving save info, ignore key presses
+	if(m_bRetrievingSaveInfo)
+	{
+		return S_OK;
+	}
+
+	ui.AnimateKeyPress(pInputData->UserIndex, pInputData->dwKeyCode);
+
+	HRESULT hr = S_OK;
+
+	// Explicitly handle B button presses
+	switch(pInputData->dwKeyCode)
+	{
+	case VK_PAD_B:
+	case VK_ESCAPE:
+		m_NetGamesListTimer.SetShow( FALSE );
+
+		app.NavigateBack(XUSER_INDEX_ANY);
+		rfHandled = TRUE;
+		break;		
+	case VK_PAD_X:
+
+		// Change device
+		// Fix for #12531 - TCR 001: BAS Game Stability: When a player selects to change a storage 
+		// device, and repeatedly backs out of the SD screen, disconnects from LIVE, and then selects a SD, the title crashes.
+		m_bIgnoreInput=true;
+		StorageManager.SetSaveDevice(&CScene_MultiGameJoinLoad::DeviceSelectReturned,this,true);
+		CXuiSceneBase::PlayUISFX(eSFX_Press);
+		break;
+	case VK_PAD_Y:
+		if(m_pGamesList->TreeHasFocus() && m_pGamesList->GetItemCount() > 0)
+		{
+			DWORD nIndex = m_pGamesList->GetCurSel();
+			FriendSessionInfo *pSelectedSession = currentSessions.at( nIndex );
+
+			PlayerUID xuid = pSelectedSession->data.hostPlayerUID;
+			if( xuid != INVALID_XUID )
+				hr = XShowGamerCardUI(ProfileManager.GetLockedProfile(), xuid);
+			CXuiSceneBase::PlayUISFX(eSFX_Press);
+		}
+		else if(DoesSavesListHaveFocus())
+		{
+			// save transfer - make sure they want to overwrite a save that is up there
+			if(ProfileManager.IsSignedInLive( m_iPad ))
+			{	
+				// 4J-PB - required for a delete of the save if it's found to be a corrupted save
+				DWORD nIndex = m_pSavesList->GetCurSel();
+				m_iChangingSaveGameInfoIndex=m_pSavesList->GetData(nIndex).iIndex;
+
+				UINT uiIDA[2];
+				uiIDA[0]=IDS_UPLOAD_SAVE;
+				uiIDA[1]=IDS_CONFIRM_CANCEL;
+
+				ui.RequestMessageBox(IDS_SAVE_TRANSFER_TITLE, IDS_SAVE_TRANSFER_TEXT, uiIDA, 2, pInputData->UserIndex,&CScene_MultiGameJoinLoad::SaveTransferDialogReturned,this, app.GetStringTable());
+			}
+		}		
+		break;
+	case VK_PAD_RSHOULDER:
+		if(DoesSavesListHaveFocus())
+		{
+			m_bIgnoreInput = true;
+			
+			int iIndex=m_SavesList.GetCurSel();
+			m_iChangingSaveGameInfoIndex=m_pSavesList->GetData(iIndex).iIndex;
+
+			// Could be delete save or Save Options
+			if(StorageManager.GetSaveDisabled())
+			{
+				// delete the save game
+				// Have to ask the player if they are sure they want to delete this game
+				UINT uiIDA[2];
+				uiIDA[0]=IDS_CONFIRM_CANCEL;
+				uiIDA[1]=IDS_CONFIRM_OK;
+				StorageManager.RequestMessageBox(IDS_TOOLTIPS_DELETESAVE, IDS_TEXT_DELETE_SAVE, uiIDA, 2, pInputData->UserIndex,&CScene_MultiGameJoinLoad::DeleteSaveDialogReturned,this, app.GetStringTable());
+			}
+			else
+			{
+				if(StorageManager.EnoughSpaceForAMinSaveGame())
+				{
+					UINT uiIDA[3];
+					uiIDA[0]=IDS_CONFIRM_CANCEL;
+					uiIDA[1]=IDS_TITLE_RENAMESAVE;
+					uiIDA[2]=IDS_TOOLTIPS_DELETESAVE;
+					StorageManager.RequestMessageBox(IDS_TOOLTIPS_SAVEOPTIONS, IDS_TEXT_SAVEOPTIONS, uiIDA, 3, pInputData->UserIndex,&CScene_MultiGameJoinLoad::SaveOptionsDialogReturned,this, app.GetStringTable());
+				}
+				else
+				{
+					// delete the save game
+					// Have to ask the player if they are sure they want to delete this game
+					UINT uiIDA[2];
+					uiIDA[0]=IDS_CONFIRM_CANCEL;
+					uiIDA[1]=IDS_CONFIRM_OK;
+					StorageManager.RequestMessageBox(IDS_TOOLTIPS_DELETESAVE, IDS_TEXT_DELETE_SAVE, uiIDA, 2, pInputData->UserIndex,&CScene_MultiGameJoinLoad::DeleteSaveDialogReturned,this, app.GetStringTable());
+				}
+			}
+			CXuiSceneBase::PlayUISFX(eSFX_Press);
+
+		}
+		else if(DoesMashUpWorldHaveFocus())
+		{
+			// hiding a mash-up world
+			// get the mash-up pack id
+			CXuiControl pItem;
+			int iIndex;
+			iIndex=m_SavesList.GetCurSel(&pItem);
+
+			CXuiCtrl4JList::LIST_ITEM_INFO info = m_pSavesList->GetData(iIndex);
+			if((iIndex != JOIN_LOAD_CREATE_BUTTON_INDEX) && (info.iData >= 0))
+			{
+				LevelGenerationOptions *levelGen = m_generators->at(info.iData);
+
+				if(!levelGen->isTutorial())
+				{
+					if(levelGen->requiresTexturePack())
+					{
+						unsigned int uiPackID=levelGen->getRequiredTexturePackId();
+
+						m_bIgnoreInput = true;
+						app.HideMashupPackWorld(m_iPad,uiPackID);
+
+						// update the saves list
+						m_pSavesList->RemoveAllData();
+						m_iSaveInfoC=0;
+						GetSaveInfo();
+						m_bIgnoreInput = false;
+					}
+				}
+			}
+
+			CXuiSceneBase::PlayUISFX(eSFX_Press);
+
+		}
+		break;
+	case VK_PAD_LSHOULDER:
+		if( m_bInParty )
+		{
+			m_bShowingPartyGamesOnly = !m_bShowingPartyGamesOnly;
+			UpdateGamesList();
+			CXuiSceneBase::PlayUISFX(eSFX_Press);
+		}
+		break;
+	}
+	
+	return hr;
+}
+
+HRESULT CScene_MultiGameJoinLoad::OnNavReturn(HXUIOBJ hSceneFrom,BOOL& rfHandled)
+{
+	
+	CXuiSceneBase::ShowLogo( DEFAULT_XUI_MENU_USER, TRUE );
+	// start the texture pack timer again
+	XuiSetTimer(m_hObj,CHECKFORAVAILABLETEXTUREPACKS_TIMER_ID,CHECKFORAVAILABLETEXTUREPACKS_TIMER_TIME);
+
+	m_bMultiplayerAllowed = ProfileManager.IsSignedInLive( m_iPad ) && ProfileManager.AllowedToPlayMultiplayer(m_iPad); 
+	
+	// re-enable button presses
+	m_bIgnoreInput=false;
+
+	if( m_bMultiplayerAllowed )
+	{
+		HXUICLASS hClassFullscreenProgress = XuiFindClass( L"CScene_FullscreenProgress" );
+		HXUICLASS hClassConnectingProgress = XuiFindClass( L"CScene_ConnectingProgress" );
+
+		// If we are navigating back from a full screen progress scene, then that means a connection attempt failed
+		if( XuiIsInstanceOf( hSceneFrom, hClassFullscreenProgress ) || XuiIsInstanceOf( hSceneFrom, hClassConnectingProgress ) )
+		{
+			UpdateGamesList();
+		}
+	}
+	else
+	{
+		m_pGamesList->RemoveAllData();
+		//m_GamesList.DeleteItems(0, m_GamesList.GetItemCount() );
+		m_pGamesList->SetEnable(FALSE);
+		//XuiElementSetDisableFocusRecursion( m_pGamesList->m_hObj, TRUE);
+		m_NetGamesListTimer.SetShow( TRUE );
+		m_LabelNoGames.SetShow( FALSE );
+		m_SavesList.InitFocus(m_iPad);
+	}
+
+	// are we back here because of a delete of a corrupt save?
+
+	if(app.GetCorruptSaveDeleted())
+	{
+		// need to re-get the saves list and update the display
+		// clear the saves list
+		m_pSavesList->RemoveAllData();
+		m_iSaveInfoC=0;
+		GetSaveInfo();
+		app.SetCorruptSaveDeleted(false);
+	}
+
+	int iY = -1;
+	int iRB=-1;
+	if( DoesGamesListHaveFocus() )
+	{
+		iY = IDS_TOOLTIPS_VIEW_GAMERCARD;
+	}
+	else if(DoesSavesListHaveFocus())
+	{	
+		if(ProfileManager.IsSignedInLive( m_iPad ))
+		{
+			iY=IDS_TOOLTIPS_UPLOAD_SAVE_FOR_XBOXONE;
+		}
+
+		if(StorageManager.GetSaveDisabled())
+		{
+			iRB=IDS_TOOLTIPS_DELETESAVE;
+		}
+		else
+		{
+			// 4J-PB - we need to check that there is enough space left to create a copy of the save (for a rename)
+
+			if(StorageManager.EnoughSpaceForAMinSaveGame())
+			{
+				iRB=IDS_TOOLTIPS_SAVEOPTIONS;
+			}
+			else
+			{
+				iRB=IDS_TOOLTIPS_DELETESAVE;
+
+			}
+		}
+	}
+	else if(DoesMashUpWorldHaveFocus())
+	{
+		// If it's a mash-up pack world, give the Hide option
+		iRB=IDS_TOOLTIPS_HIDE;
+	}
+
+	int iLB = -1;
+	if(m_bInParty)
+	{
+		if( m_bShowingPartyGamesOnly ) iLB = IDS_TOOLTIPS_ALL_GAMES;
+		else iLB = IDS_TOOLTIPS_PARTY_GAMES;
+	}
+
+	if(ProfileManager.IsFullVersion()==false )
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, -1, -1,-1,-1,iLB);
+	}
+	else if(StorageManager.GetSaveDisabled())
+	{
+		// clear out the saves list, since the disable save may have happened in the load screen because of a device removal
+
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_SELECTDEVICE,iY,-1,-1,iLB,iRB);
+	}
+	else
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, IDS_TOOLTIPS_CHANGEDEVICE, iY,-1,-1,iLB,iRB);
+	}
+
+	return S_OK;
+}
+
+HRESULT CScene_MultiGameJoinLoad::OnNotifySelChanged(HXUIOBJ hObjSource, XUINotifySelChanged *pNotifySelChangedData, BOOL& bHandled)
+{
+
+	if(m_bReady)
+	{
+		CXuiSceneBase::PlayUISFX(eSFX_Focus);
+	}
+
+	return S_OK;
+}
+
+
+HRESULT CScene_MultiGameJoinLoad::OnTransitionStart( XUIMessageTransition *pTransition, BOOL& bHandled )
+{
+	//if(pTransition->dwTransAction==XUI_TRANSITION_ACTION_DESTROY ) return S_OK;
+
+	if(pTransition->dwTransAction==XUI_TRANSITION_ACTION_DESTROY ||
+		pTransition->dwTransType == XUI_TRANSITION_FROM  || pTransition->dwTransType == XUI_TRANSITION_BACKFROM)
+	{
+		// 4J Stu - We may have had to unload our font renderer in this scene if one of the save files
+		// uses characters not in our font (eg asian chars) so restore our font renderer
+		// This will not do anything if our font renderer is already loaded
+		app.OverrideFontRenderer(true,true);
+
+		KillTimer(JOIN_LOAD_ONLINE_TIMER_ID);
+	}
+	else if(pTransition->dwTransType == XUI_TRANSITION_TO || pTransition->dwTransType == XUI_TRANSITION_BACKTO)
+	{
+		SetTimer(JOIN_LOAD_ONLINE_TIMER_ID,JOIN_LOAD_ONLINE_TIMER_TIME);
+		// 4J-PB - Need to check for installed DLC, which might have happened while you were on the info scene
+		if(pTransition->dwTransType == XUI_TRANSITION_BACKTO)
+		{
+			// Can't call this here because if you back out of the load info screen and then go back in and load a game, it will attempt to use the dlc as it's running a mount of the dlc
+			
+			// block input if we're waiting for DLC to install, and wipe the saves list. The end of dlc mounting custom message will fill the list again
+			if(app.StartInstallDLCProcess(m_iPad)==false)
+			{
+				// not doing a mount, so re-enable input
+				m_bIgnoreInput=false;
+			}
+			else
+			{
+				m_bIgnoreInput=true;
+				m_pSavesList->RemoveAllData();
+				m_SavesListTimer.SetShow( TRUE );
+			}
+		}
+	}
+
+	return S_OK;
+}
+
+HRESULT CScene_MultiGameJoinLoad::OnFontRendererChange()
+{
+	// update the tooltips
+	// if the saves list has focus, then we should show the Delete Save tooltip
+	// if the games list has focus, then we should the the View Gamercard tooltip
+	int iRB=-1;	
+	int iY = -1;
+	if( DoesGamesListHaveFocus() )
+	{
+		iY = IDS_TOOLTIPS_VIEW_GAMERCARD;
+	}	
+	else if(DoesSavesListHaveFocus())
+	{	
+		if(ProfileManager.IsSignedInLive( m_iPad ))
+		{
+			iY=IDS_TOOLTIPS_UPLOAD_SAVE_FOR_XBOXONE;
+		}
+		if(StorageManager.GetSaveDisabled())
+		{
+			iRB=IDS_TOOLTIPS_DELETESAVE;
+		}
+		else
+		{
+			if(StorageManager.EnoughSpaceForAMinSaveGame())
+			{
+				iRB=IDS_TOOLTIPS_SAVEOPTIONS;
+			}
+			else
+			{
+				iRB=IDS_TOOLTIPS_DELETESAVE;
+			}
+		}
+	}
+	else if(DoesMashUpWorldHaveFocus())
+	{
+		// If it's a mash-up pack world, give the Hide option
+		iRB=IDS_TOOLTIPS_HIDE;
+	}
+
+	int iLB = -1;
+	if(m_bInParty)
+	{
+		if( m_bShowingPartyGamesOnly ) iLB = IDS_TOOLTIPS_ALL_GAMES;
+		else iLB = IDS_TOOLTIPS_PARTY_GAMES;
+	}
+
+	if(ProfileManager.IsFullVersion()==false )
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, -1, iY,-1,-1,iLB,-1,-1,true);
+	}
+	else if(StorageManager.GetSaveDisabled())
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_SELECTDEVICE,iY,-1,-1,iLB,iRB,-1,true);
+	}
+	else
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, IDS_TOOLTIPS_CHANGEDEVICE, iY,-1,-1,iLB,iRB,-1,true);
+	}
+	return S_OK;
+}
+
+HRESULT CScene_MultiGameJoinLoad::OnNotifySetFocus(HXUIOBJ hObjSource, XUINotifyFocus *pNotifyFocusData, BOOL& bHandled)
+{
+	// update the tooltips
+	// if the saves list has focus, then we should show the Delete Save tooltip
+	// if the games list has focus, then we should the the View Gamercard tooltip
+	int iRB=-1;	
+	int iY = -1;
+	if( DoesGamesListHaveFocus() )
+	{
+		iY = IDS_TOOLTIPS_VIEW_GAMERCARD;
+	}	
+	else if(DoesSavesListHaveFocus())
+	{
+		if(ProfileManager.IsSignedInLive( m_iPad ))
+		{
+			iY=IDS_TOOLTIPS_UPLOAD_SAVE_FOR_XBOXONE;
+		}
+		if(StorageManager.GetSaveDisabled())
+		{
+			iRB=IDS_TOOLTIPS_DELETESAVE;
+		}
+		else
+		{
+			if(StorageManager.EnoughSpaceForAMinSaveGame())
+			{
+				iRB=IDS_TOOLTIPS_SAVEOPTIONS;
+			}
+			else
+			{
+				iRB=IDS_TOOLTIPS_DELETESAVE;
+			}
+		}
+	}
+	else if(DoesMashUpWorldHaveFocus())
+	{
+		// If it's a mash-up pack world, give the Hide option
+		iRB=IDS_TOOLTIPS_HIDE;
+	}
+
+	int iLB = -1;
+	if(m_bInParty)
+	{
+		if( m_bShowingPartyGamesOnly ) iLB = IDS_TOOLTIPS_ALL_GAMES;
+		else iLB = IDS_TOOLTIPS_PARTY_GAMES;
+	}
+
+	if(ProfileManager.IsFullVersion()==false )
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, -1, iY,-1,-1,iLB,-1);
+	}
+	else if(StorageManager.GetSaveDisabled())
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_SELECTDEVICE,iY,-1,-1,iLB,iRB);
+	}
+	else
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, IDS_TOOLTIPS_CHANGEDEVICE, iY,-1,-1,iLB,iRB);
+	}
+	return S_OK;
+}
+
+HRESULT CScene_MultiGameJoinLoad::OnNotifyKillFocus(HXUIOBJ hObjSource, XUINotifyFocus *pNotifyFocusData, BOOL& bHandled)
+{
+	return S_OK;
+}
+
+bool CScene_MultiGameJoinLoad::DoesSavesListHaveFocus()
+{
+	HXUIOBJ hParentObj,hObj=TreeGetFocus();
+
+	if(hObj!=NULL)
+	{
+		// get the parent and see if it's the saves list
+		XuiElementGetParent(hObj,&hParentObj);
+		if(hParentObj==m_SavesList.m_hObj)
+		{
+			// check it's not the first or second element (new world or tutorial)
+			if(m_SavesList.GetCurSel()>(m_iDefaultButtonsC-1))
+			{
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+bool CScene_MultiGameJoinLoad::DoesMashUpWorldHaveFocus()
+{
+	HXUIOBJ hParentObj,hObj=TreeGetFocus();
+
+	if(hObj!=NULL)
+	{
+		// get the parent and see if it's the saves list
+		XuiElementGetParent(hObj,&hParentObj);
+		if(hParentObj==m_SavesList.m_hObj)
+		{
+			// check it's not the first or second element (new world or tutorial)
+			if(m_SavesList.GetCurSel()>(m_iDefaultButtonsC-1))
+			{
+				return false;
+			}
+
+			if(m_SavesList.GetCurSel()>(m_iDefaultButtonsC - 1 - m_iMashUpButtonsC))
+			{
+				return true;
+			}
+			else return false;
+		}
+		else return false;
+	}
+	return false;
+}
+
+bool CScene_MultiGameJoinLoad::DoesGamesListHaveFocus()
+{
+	HXUIOBJ hParentObj,hObj=TreeGetFocus();
+
+	if(hObj!=NULL)
+	{
+		// get the parent and see if it's the saves list
+		XuiElementGetParent(hObj,&hParentObj);
+		if(hParentObj==m_pGamesList->m_hObj)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+void CScene_MultiGameJoinLoad::UpdateGamesListCallback(LPVOID lpParam)
+{
+	if(lpParam != NULL)
+	{
+		CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad *) lpParam;
+		// check this there's no save transfer in progress
+		if(!pClass->m_bSaveTransferInProgress)
+		{
+				pClass->UpdateGamesList();	
+		}
+	}
+}
+
+void CScene_MultiGameJoinLoad::UpdateGamesList()
+{
+	if( m_bIgnoreInput ) return;
+
+	// if we're retrieving save info, don't show the list yet as we will be ignoring press events
+	if(m_bRetrievingSaveInfo)
+	{
+		return;
+	}
+
+	DWORD nIndex = -1;
+	FriendSessionInfo *pSelectedSession = NULL;
+	if(m_pGamesList->TreeHasFocus() && m_pGamesList->GetItemCount() > 0)
+	{
+		nIndex = m_pGamesList->GetCurSel();
+		pSelectedSession = currentSessions.at( nIndex );
+	}
+
+	SessionID selectedSessionId;
+	if( pSelectedSession != NULL )selectedSessionId = pSelectedSession->sessionId;
+	pSelectedSession = NULL;
+
+	for(AUTO_VAR(it, currentSessions.begin()); it < currentSessions.end(); ++it)
+	{
+		delete (*it);
+	}
+	currentSessions.clear();
+	
+	m_NetGamesListTimer.SetShow( FALSE );
+		
+	// if the saves list has focus, then we should show the Delete Save tooltip
+	// if the games list has focus, then we should show the View Gamercard tooltip
+	int iRB=-1;	
+	int iY = -1;
+
+	if( DoesGamesListHaveFocus() )
+	{
+		iY = IDS_TOOLTIPS_VIEW_GAMERCARD;
+	}
+	else if(DoesSavesListHaveFocus())
+	{	
+		if(ProfileManager.IsSignedInLive( m_iPad ))
+		{
+			iY=IDS_TOOLTIPS_UPLOAD_SAVE_FOR_XBOXONE;
+		}
+		if(StorageManager.GetSaveDisabled())
+		{
+			iRB=IDS_TOOLTIPS_DELETESAVE;
+		}
+		else
+		{
+			if(StorageManager.EnoughSpaceForAMinSaveGame())
+			{
+				iRB=IDS_TOOLTIPS_SAVEOPTIONS;
+			}
+			else
+			{
+				iRB=IDS_TOOLTIPS_DELETESAVE;
+			}
+		}
+	}
+	else if(DoesMashUpWorldHaveFocus())
+	{
+		// If it's a mash-up pack world, give the Hide option
+		iRB=IDS_TOOLTIPS_HIDE;
+	}
+
+	int iLB = -1;
+	if(m_bInParty)
+	{
+		if( m_bShowingPartyGamesOnly ) iLB = IDS_TOOLTIPS_ALL_GAMES;
+		else iLB = IDS_TOOLTIPS_PARTY_GAMES;
+	}
+
+	if(ProfileManager.IsFullVersion()==false )
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, -1, iY,-1,-1,iLB,-1);
+	}
+	else if(StorageManager.GetSaveDisabled())
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_SELECTDEVICE,iY,-1,-1,iLB,iRB);
+	}
+	else
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, IDS_TOOLTIPS_CHANGEDEVICE, iY,-1,-1,iLB,iRB);
+	}
+
+	currentSessions = *g_NetworkManager.GetSessionList( m_iPad, m_localPlayers, m_bShowingPartyGamesOnly );
+
+	// Update the xui list displayed
+	unsigned int xuiListSize = m_pGamesList->GetItemCount();
+	unsigned int filteredListSize = (unsigned int)currentSessions.size();
+
+	BOOL gamesListHasFocus = m_pGamesList->TreeHasFocus();
+
+	if(filteredListSize > 0)
+	{
+		if( !m_pGamesList->IsEnabled() )
+		{
+			m_pGamesList->SetEnable(TRUE);
+			//XuiElementSetDisableFocusRecursion( m_pGamesList->m_hObj, FALSE);
+			m_pGamesList->SetCurSel( 0 );
+		}
+		m_LabelNoGames.SetShow( FALSE );
+		m_NetGamesListTimer.SetShow( FALSE );
+	}
+	else
+	{
+		m_pGamesList->SetEnable(FALSE);
+		//XuiElementSetDisableFocusRecursion(m_pGamesList->m_hObj, TRUE);
+		m_NetGamesListTimer.SetShow( FALSE );
+		m_LabelNoGames.SetShow( TRUE );
+
+		if( gamesListHasFocus ) m_pGamesList->InitFocus(m_iPad);
+	}
+
+	// clear out the games list and re-fill
+	m_pGamesList->RemoveAllData();
+
+	if( filteredListSize > 0 )
+	{
+		// Reset the focus to the selected session if it still exists
+		unsigned int sessionIndex = 0;
+		m_pGamesList->SetCurSel(0);
+
+		for( AUTO_VAR(it, currentSessions.begin()); it < currentSessions.end(); ++it)
+		{
+			FriendSessionInfo *sessionInfo = *it;
+			HXUIBRUSH hXuiBrush;
+			CXuiCtrl4JList::LIST_ITEM_INFO ListInfo;
+
+			ZeroMemory(&ListInfo,sizeof(CXuiCtrl4JList::LIST_ITEM_INFO));
+
+			ListInfo.pwszText = sessionInfo->displayLabel;
+			ListInfo.fEnabled = TRUE;
+			ListInfo.iData = sessionIndex;
+			m_pGamesList->AddData(ListInfo);
+			// display an icon too
+
+			// Is this a default game or a texture pack game?
+			if(sessionInfo->data.texturePackParentId!=0)
+			{
+				// Do we have the texture pack
+				Minecraft *pMinecraft = Minecraft::GetInstance();
+				TexturePack *tp = pMinecraft->skins->getTexturePackById(sessionInfo->data.texturePackParentId);
+				HRESULT hr;
+
+				DWORD dwImageBytes=0;
+				PBYTE pbImageData=NULL;
+
+				if(tp==NULL)
+				{
+					DWORD dwBytes=0;
+					PBYTE pbData=NULL;
+					app.GetTPD(sessionInfo->data.texturePackParentId,&pbData,&dwBytes);
+
+					// is it in the tpd data ?
+					app.GetFileFromTPD(eTPDFileType_Icon,pbData,dwBytes,&pbImageData,&dwImageBytes );
+					if(dwImageBytes > 0 && pbImageData)
+					{	
+						hr=XuiCreateTextureBrushFromMemory(pbImageData,dwImageBytes,&hXuiBrush);
+						m_pGamesList->UpdateGraphic(sessionIndex,hXuiBrush);
+					}
+				}
+				else
+				{
+					pbImageData = tp->getPackIcon(dwImageBytes);
+					if(dwImageBytes > 0 && pbImageData)
+					{			
+						hr=XuiCreateTextureBrushFromMemory(pbImageData,dwImageBytes,&hXuiBrush);
+						m_pGamesList->UpdateGraphic(sessionIndex,hXuiBrush);
+					}
+				}
+			}
+			else
+			{
+				// default texture pack
+				XuiCreateTextureBrushFromMemory(m_DefaultMinecraftIconData,m_DefaultMinecraftIconSize,&hXuiBrush);
+				m_pGamesList->UpdateGraphic(sessionIndex,hXuiBrush);
+			}
+			
+
+			if(memcmp( &selectedSessionId, &sessionInfo->sessionId, sizeof(SessionID) ) == 0)
+			{
+				m_pGamesList->SetCurSel(sessionIndex);
+				break;
+			}
+			++sessionIndex;
+		}
+	}
+}
+
+void CScene_MultiGameJoinLoad::UpdateGamesList(DWORD dwNumResults, IQNetGameSearch *pGameSearch)
+{
+	// We don't use the QNet callback, but could resurrect this if we ever do normal matchmaking, but updated to work as the function above
+#if 0
+	const XSESSION_SEARCHRESULT *pSearchResult;
+    const XNQOSINFO * pxnqi;
+
+	if(m_searches>0)
+		--m_searches;
+	
+	if(m_searches==0)
+	{
+		m_NetGamesListTimer.SetShow( FALSE );
+		
+		// if the saves list has focus, then we should show the Delete Save tooltip
+		// if the games list has focus, then we should show the View Gamercard tooltip
+		int iRB=-1;	
+		int iY = -1;
+
+		if( DoesGamesListHaveFocus() )
+		{
+			iY = IDS_TOOLTIPS_VIEW_GAMERCARD;
+		}
+		else if(DoesSavesListHaveFocus())
+		{
+			iRB=IDS_TOOLTIPS_DELETESAVE;
+		}
+
+		int iLB = -1;
+		if(m_bInParty)
+		{
+			if( m_bShowingPartyGamesOnly ) iLB = IDS_TOOLTIPS_ALL_GAMES
+			else iLB = IDS_TOOLTIPS_PARTY_GAMES;
+		}
+
+		if(ProfileManager.IsFullVersion()==false )
+		{
+			ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, -1, iY,-1,-1,iLB,iRB);
+		}
+		else if(StorageManager.GetSaveDisabled())
+		{
+			ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_SELECTDEVICE,iY,-1,-1,iLB,iRB);
+		}
+		else
+		{
+			ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, IDS_TOOLTIPS_CHANGEDEVICE, iY,-1,-1,iLB,iRB);
+		}
+	}
+
+	if( dwNumResults == 0 )
+	{
+		if(m_searches==0 && m_GamesList.GetItemCount() == 0)
+		{
+			m_LabelNoGames.SetShow( TRUE );
+		}
+		return;
+	}
+
+	unsigned int startOffset = m_GamesList.GetItemCount();
+	//m_GamesList.InsertItems(startOffset,dwNumResults);	
+	//m_GamesList.SetEnable(TRUE);
+	//XuiElementSetDisableFocusRecursion( m_GamesList.m_hObj, FALSE);
+
+	// Loop through all the results.
+    for( DWORD dwResult = 0; dwResult < pGameSearch->GetNumResults(); dwResult++ )
+    {
+
+        pSearchResult = pGameSearch->GetSearchResultAtIndex( dwResult );
+
+		// No room for us, so ignore it
+		if(pSearchResult->dwOpenPublicSlots < m_localPlayers)
+			continue;
+
+		FriendSessionInfo *sessionInfo = NULL;
+		bool foundSession = false;
+		for(AUTO_VAR(it, friendsSessions.begin()); it < friendsSessions.end(); ++it)
+		{
+			sessionInfo = *it;
+			if(memcmp( &pSearchResult->info.sessionID, &sessionInfo->sessionId, sizeof(SessionID) ) == 0)
+			{
+				sessionInfo->searchResult = *pSearchResult;
+				sessionInfo->displayLabel = new wchar_t[100];
+				foundSession = true;
+				break;
+			}
+		}
+
+		// We received a search result for a session no longer in our list of friends sessions
+		if(!foundSession)
+			continue;
+
+        // Print some info about this result.
+        //printf( "Search result %u:\n", dwResult );
+        //printf( "    public slots open = %u, filled = %u\n", pSearchResult->dwOpenPublicSlots, pSearchResult->dwFilledPublicSlots );
+        //printf( "    private slots open = %u, filled = %u\n", pSearchResult->dwOpenPrivateSlots, pSearchResult->dwFilledPrivateSlots );
+
+        // See if this result was contacted successfully via QoS probes.
+        pxnqi = pGameSearch->GetQosInfoAtIndex( dwResult );
+        if( pxnqi->bFlags & XNET_XNQOSINFO_TARGET_CONTACTED )
+        {
+            // Print the round trip time and the rough estimation of
+            // bandwidth.
+            app.DebugPrintf( "    RTT min = %u, med = %u\n", pxnqi->wRttMinInMsecs, pxnqi->wRttMedInMsecs );
+            app.DebugPrintf( "    bps up = %u, down = %u\n", pxnqi->dwUpBitsPerSec, pxnqi->dwDnBitsPerSec );
+
+			if(pxnqi->cbData > 0)
+			{
+				sessionInfo->data = *(GameSessionData *)pxnqi->pbData;
+
+				wstring gamerName = convStringToWstring(sessionInfo->data.hostName);
+				swprintf(sessionInfo->displayLabel,L"%ls's Game", gamerName.c_str() );
+			}
+			else
+			{
+				swprintf(sessionInfo->displayLabel,L"Unknown host Game");
+			}
+
+            // If this host wasn't disabled use this one.
+            if( !( pxnqi->bFlags & XNET_XNQOSINFO_TARGET_DISABLED ) && sessionInfo->data.netVersion == MINECRAFT_NET_VERSION )
+            {
+				//printf("This game is valid\n");
+				filteredResults.push_back(sessionInfo);
+				m_GamesList.InsertItems(startOffset,1);
+				m_GamesList.SetText(startOffset,sessionInfo->displayLabel);
+				startOffset++;
+            }
+#ifndef _CONTENT_PACKAGE
+			if( sessionInfo->data.netVersion != MINECRAFT_NET_VERSION )
+			{
+				wprintf(L"%ls version of %d does not match our version of %d\n", sessionInfo->displayLabel, sessionInfo->data.netVersion, MINECRAFT_NET_VERSION);
+			}
+#endif
+        }
+    }
+	
+	if( m_GamesList.GetItemCount() == 0)
+	{
+		m_LabelNoGames.SetShow( TRUE );
+	}
+	else
+	{
+		m_GamesList.SetEnable(TRUE);
+		XuiElementSetDisableFocusRecursion( m_GamesList.m_hObj, FALSE);
+		if( DoesGamesListHaveFocus() )
+		{
+			m_GamesList.SetCurSel(0);
+		}
+	}
+#endif
+}
+
+/*void CScene_MultiGameJoinLoad::UpdateGamesListLabels()
+{
+	for( unsigned int i = 0; i < currentSessions.size(); ++i )
+	{
+		FriendSessionInfo *sessionInfo = currentSessions.at(i);
+		m_GamesList.SetText(i,sessionInfo->displayLabel);
+		HXUIBRUSH hBrush;
+		CXuiCtrl4JList::LIST_ITEM_INFO info = m_pGamesList->GetData(i);
+
+		// display an icon too
+		XuiCreateTextureBrushFromMemory(m_DefaultMinecraftIconData,m_DefaultMinecraftIconSize,&hBrush);
+		m_pGamesList->UpdateGraphic(i,hBrush);
+	}
+#if 0
+	XUIRect xuiRect;
+	HXUIOBJ item = XuiListGetItemControl(m_GamesList,0);
+
+	HXUIOBJ hObj=NULL;
+	HXUIOBJ hTextPres=NULL;
+ 	HRESULT hr=XuiControlGetVisual(item,&hObj);
+	hr=XuiElementGetChildById(hObj,L"text_Label",&hTextPres);
+
+	unsigned char displayLabelViewableStartIndex = 0;
+	for( unsigned int i = 0; i < currentSessions.size(); ++i )
+	{
+		FriendSessionInfo *sessionInfo = currentSessions.at(i);
+
+		if(hTextPres != NULL )
+		{
+			hr=XuiTextPresenterMeasureText(hTextPres, sessionInfo->displayLabel, &xuiRect);
+
+			float fWidth, fHeight;
+			XuiElementGetBounds(hTextPres,&fWidth,&fHeight);
+			int characters = (fWidth/xuiRect.right) * sessionInfo->displayLabelLength;
+
+			if( characters < sessionInfo->displayLabelLength )
+			{
+				static wchar_t temp[100];
+				ZeroMemory(temp, (100)*sizeof(wchar_t));
+				wcsncpy_s( temp, sessionInfo->displayLabel+sessionInfo->displayLabelViewableStartIndex, characters );
+				m_GamesList.SetText(i,temp);
+				sessionInfo->displayLabelViewableStartIndex++;
+				if( sessionInfo->displayLabelViewableStartIndex >= sessionInfo->displayLabelLength ) sessionInfo->displayLabelViewableStartIndex = 0;
+			}
+		}
+	}
+#endif
+}*/
+
+void CScene_MultiGameJoinLoad::SearchForGameCallback(void *param, DWORD dwNumResults, IQNetGameSearch *pGameSearch)
+{
+#if 0
+	HXUIOBJ hObj = (HXUIOBJ)param;
+
+	void *pObj;
+	XuiObjectFromHandle( hObj, &pObj);
+	CScene_MultiGameJoinLoad *MultiGameJoinLoad = (CScene_MultiGameJoinLoad *)pObj;
+
+	MultiGameJoinLoad->UpdateGamesList(dwNumResults, pGameSearch);
+#endif
+}
+
+int CScene_MultiGameJoinLoad::DeviceSelectReturned(void *pParam,bool bContinue)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+	//HRESULT hr;
+
+	if(bContinue==true)
+	{
+		// if the saves list has focus, then we should show the Delete Save tooltip
+		// if the games list has focus, then we should show the View Gamercard tooltip
+		int iRB=-1;	
+		int iY = -1;
+		if( pClass->DoesGamesListHaveFocus() )
+		{
+			iY = IDS_TOOLTIPS_VIEW_GAMERCARD;
+		}
+		else if(pClass->DoesSavesListHaveFocus())
+		{	
+			if(ProfileManager.IsSignedInLive( pClass->m_iPad ))
+			{
+				iY=IDS_TOOLTIPS_UPLOAD_SAVE_FOR_XBOXONE;
+			}
+			if(StorageManager.GetSaveDisabled())
+			{
+				iRB=IDS_TOOLTIPS_DELETESAVE;
+			}
+			else
+			{
+				if(StorageManager.EnoughSpaceForAMinSaveGame())
+				{
+					iRB=IDS_TOOLTIPS_SAVEOPTIONS;
+				}
+				else
+				{
+					iRB=IDS_TOOLTIPS_DELETESAVE;
+				}
+			}
+		}
+		else if(pClass->DoesMashUpWorldHaveFocus())
+		{
+			// If it's a mash-up pack world, give the Hide option
+			iRB=IDS_TOOLTIPS_HIDE;
+		}
+
+		int iLB = -1;
+		if(pClass->m_bInParty)
+		{
+			if( pClass->m_bShowingPartyGamesOnly ) iLB = IDS_TOOLTIPS_ALL_GAMES;
+			else iLB = IDS_TOOLTIPS_PARTY_GAMES;
+		}
+
+		//BOOL bOnlineGame=pClass->m_CheckboxOnline.IsChecked();
+
+		// refresh the saves list (if there is a device selected)
+
+		// clear out the list first
+
+		if(StorageManager.GetSaveDisabled())
+		{
+			if(StorageManager.GetSaveDeviceSelected(pClass->m_iPad))
+			{
+				ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_CHANGEDEVICE,iY,-1,-1,iLB,iRB);
+				// saving is disabled, but we should still be able to load from a selected save device
+				pClass->GetSaveInfo();
+			}
+			else
+			{		
+				ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_SELECTDEVICE,iY,-1,-1,iLB,iRB);
+				// clear the saves list
+				pClass->m_pSavesList->RemoveAllData();
+
+				pClass->m_iSaveInfoC=0;
+				//pClass->m_iThumbnailsLoadedC=0;
+
+				pClass->AddDefaultButtons();
+
+				pClass->m_SavesListTimer.SetShow( FALSE );
+
+				pClass->m_pSavesList->SetCurSelVisible(0);
+			}
+		}
+		else
+		{
+			ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_CHANGEDEVICE,iY,-1,-1,iLB,iRB);
+			pClass->GetSaveInfo();
+		}
+	}
+
+	// enable input again
+	pClass->m_bIgnoreInput=false;
+
+	return 0;
+}
+
+HRESULT CScene_MultiGameJoinLoad::OnTimer( XUIMessageTimer *pTimer, BOOL& bHandled )
+{
+	// 4J-PB - TODO - Don't think we can do this - if a 2nd player signs in here with an offline profile, the signed in LIVE player gets re-logged in, and bMultiplayerAllowed is false briefly 
+	switch(pTimer->nId)
+	{
+
+	
+	case JOIN_LOAD_ONLINE_TIMER_ID:
+	{
+		XPARTY_USER_LIST partyList;
+
+		if((XPartyGetUserList(  &partyList ) != XPARTY_E_NOT_IN_PARTY ) && (partyList.dwUserCount>1))
+		{
+			m_bInParty=true;
+		}
+		else
+		{
+			m_bInParty=false;
+		}
+
+		bool bMultiplayerAllowed = ProfileManager.IsSignedInLive( m_iPad ) && ProfileManager.AllowedToPlayMultiplayer(m_iPad);
+		if(bMultiplayerAllowed != m_bMultiplayerAllowed)
+		{
+			if( bMultiplayerAllowed )
+			{
+// 					m_CheckboxOnline.SetEnable(TRUE);
+// 					m_CheckboxPrivate.SetEnable(TRUE);
+			}
+			else
+			{
+				m_bInParty = false;
+				m_pGamesList->RemoveAllData();
+				//m_GamesList.DeleteItems(0, m_GamesList.GetItemCount() );
+				m_pGamesList->SetEnable(FALSE);
+				//XuiElementSetDisableFocusRecursion( m_pGamesList->m_hObj, TRUE);
+				m_NetGamesListTimer.SetShow( TRUE );
+				m_LabelNoGames.SetShow( FALSE );
+			}
+
+			int iLB = -1;
+			if(m_bInParty)
+			{
+				if( m_bShowingPartyGamesOnly ) iLB = IDS_TOOLTIPS_ALL_GAMES;
+				else iLB = IDS_TOOLTIPS_PARTY_GAMES;
+			}
+			int iRB=-1;
+			int iY=-1;
+
+			if( DoesGamesListHaveFocus() )
+			{
+			}
+			else if(DoesSavesListHaveFocus())
+			{	
+				if(ProfileManager.IsSignedInLive( m_iPad ))
+				{
+					iY=IDS_TOOLTIPS_UPLOAD_SAVE_FOR_XBOXONE;
+				}
+
+				if(StorageManager.GetSaveDisabled())
+				{
+					iRB=IDS_TOOLTIPS_DELETESAVE;
+				}
+				else
+				{
+					if(StorageManager.EnoughSpaceForAMinSaveGame())
+					{
+						iRB=IDS_TOOLTIPS_SAVEOPTIONS;
+					}
+					else
+					{
+						iRB=IDS_TOOLTIPS_DELETESAVE;
+					}
+				}
+			}
+			else if(DoesMashUpWorldHaveFocus())
+			{
+				// If it's a mash-up pack world, give the Hide option
+				iRB=IDS_TOOLTIPS_HIDE;
+			}
+
+			if(ProfileManager.IsFullVersion()==false )
+			{
+				ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, -1, -1,-1,-1,iLB);
+			}
+			else if(StorageManager.GetSaveDisabled())
+			{
+				ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_SELECTDEVICE,-1,-1,-1,iLB,iRB);
+			}
+			else
+			{
+				ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, IDS_TOOLTIPS_CHANGEDEVICE,iY,-1,-1,iLB,iRB);
+			}
+			m_bMultiplayerAllowed = bMultiplayerAllowed;
+		}
+	}
+	break;
+	case JOIN_LOAD_SEARCH_MINIMUM_TIMER_ID:
+	{
+		XuiKillTimer( m_hObj, JOIN_LOAD_SEARCH_MINIMUM_TIMER_ID );
+		m_NetGamesListTimer.SetShow( FALSE );
+		m_LabelNoGames.SetShow( TRUE );
+	}
+	break;
+	case JOIN_LOAD_SCROLL_GAME_NAMES_TIMER_ID:
+	{
+		// This is called by the gameslist callback function, so isn't needed on a timer
+		//UpdateGamesListLabels();
+	}
+	break;
+		case CHECKFORAVAILABLETEXTUREPACKS_TIMER_ID:
+			{
+				// also check for any new texture packs info being available
+				// for each item in the mem list, check it's in the data list
+
+				//CXuiCtrl4JList::LIST_ITEM_INFO ListInfo;
+				// for each iConfig, check if the data is available, and add it to the List, then remove it from the viConfig
+				
+				for(int i=0;i<m_iTexturePacksNotInstalled;i++)
+				{
+					if(m_iConfigA[i]!=-1)
+					{
+						DWORD dwBytes=0;
+						PBYTE pbData=NULL;
+						//app.DebugPrintf("Retrieving iConfig %d from TPD\n",m_iConfigA[i]);
+
+						app.GetTPD(m_iConfigA[i],&pbData,&dwBytes);
+
+						if(dwBytes > 0 && pbData)
+						{
+							//update the games list
+							UpdateGamesList();
+
+							m_iConfigA[i]=-1;
+						}
+					}
+				}
+				bool bAllDone=true;
+				for(int i=0;i<m_iTexturePacksNotInstalled;i++)
+				{
+					if(m_iConfigA[i]!=-1) 
+					{
+						bAllDone = false;
+					}
+				}
+
+				if(bAllDone)
+				{
+					// kill this timer
+					XuiKillTimer(m_hObj,CHECKFORAVAILABLETEXTUREPACKS_TIMER_ID);
+				}
+			}
+			break;
+			}
+
+	return S_OK;
+}
+
+/*
+int CScene_MultiGameJoinLoad::LoadSaveDataReturned(void *pParam,bool bContinue)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+
+	if(bContinue==true)
+	{
+		bool isClientSide = ProfileManager.IsSignedInLive(ProfileManager.GetPrimaryPad());
+
+		// 4J Stu - If we only have one controller connected, then don't show the sign-in UI again
+		DWORD connectedControllers = 0;
+		for(unsigned int i = 0; i < XUSER_MAX_COUNT; ++i)
+		{
+			if( InputManager.IsPadConnected(i) || ProfileManager.IsSignedIn(i) ) ++connectedControllers;
+		}
+
+		if(!isClientSide || connectedControllers == 1 || !RenderManager.IsHiDef())
+		{
+			DWORD dwLocalUsersMask = CGameNetworkManager::GetLocalPlayerMask(ProfileManager.GetPrimaryPad());
+
+			// No guest problems so we don't need to force a sign-in of players here
+			StartGameFromSave(pClass, dwLocalUsersMask);
+		}
+		else
+		{
+			ProfileManager.RequestSignInUI(false, false, false, true, false,&CScene_MultiGameJoinLoad::StartGame_SignInReturned, pParam,ProfileManager.GetPrimaryPad());
+		}
+	}
+	else
+	{
+		pClass->m_bIgnoreInput=false;
+	}
+	return 0;
+}
+*/
+
+int CScene_MultiGameJoinLoad::StartGame_SignInReturned(void *pParam,bool bContinue, int iPad)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+
+	if(bContinue==true)
+	{
+		// It's possible that the player has not signed in - they can back out
+		if(ProfileManager.IsSignedIn(iPad))
+		{
+			DWORD dwLocalUsersMask = 0;
+
+			for(unsigned int index = 0; index < XUSER_MAX_COUNT; ++index)
+			{
+				if(ProfileManager.IsSignedIn(index) )
+				{
+					dwLocalUsersMask |= CGameNetworkManager::GetLocalPlayerMask(index);
+				}
+			}
+			StartGameFromSave(pClass, dwLocalUsersMask);
+		}
+	}
+	else
+	{
+		pClass->m_bIgnoreInput=false;
+	}
+	return 0;
+}
+
+// 4J Stu - Shared functionality that is the same whether we needed a quadrant sign-in or not
+void CScene_MultiGameJoinLoad::StartGameFromSave(CScene_MultiGameJoinLoad* pClass, DWORD dwLocalUsersMask)
+{
+	/*bool isClientSide = ProfileManager.IsSignedInLive(ProfileManager.GetPrimaryPad()) && pClass->m_CheckboxOnline.IsChecked() == TRUE;
+	//bool isPrivate = pClass->m_CheckboxPrivate.IsChecked() == TRUE;
+
+	SenStatGameEvent(ProfileManager.GetPrimaryPad(),eTelemetryGameEvent_Load,Minecraft::GetInstance()->options->difficulty, isClientSide, ProfileManager.IsFullVersion(), 1,0 );
+
+	g_NetworkManager.HostGame(dwLocalUsersMask,isClientSide,isPrivate,MINECRAFT_NET_MAX_PLAYERS,0);
+
+	LoadingInputParams *loadingParams = new LoadingInputParams();
+	loadingParams->func = &CGameNetworkManager::RunNetworkGameThreadProc;
+	loadingParams->lpParam = NULL;
+
+	UIFullscreenProgressCompletionData *completionData = new UIFullscreenProgressCompletionData();
+	completionData->bShowBackground=TRUE;
+	completionData->bShowLogo=TRUE;
+	completionData->type = e_ProgressCompletion_CloseAllPlayersUIScenes;
+	completionData->iPad = DEFAULT_XUI_MENU_USER;
+	loadingParams->completionData = completionData;
+
+	app.NavigateToScene(ProfileManager.GetPrimaryPad(),eUIScene_FullscreenProgress, loadingParams);*/
+}
+
+int CScene_MultiGameJoinLoad::DeleteSaveDataReturned(void *pParam,bool bSuccess)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+
+	if(bSuccess==true)
+	{
+		// need to re-get the saves list and update the display
+		// clear the saves list
+		pClass->m_pSavesList->RemoveAllData();
+		pClass->m_iSaveInfoC=0;
+		pClass->GetSaveInfo();
+	}
+	
+	pClass->m_bIgnoreInput=false;
+
+	return 0;
+}
+
+void CScene_MultiGameJoinLoad::LoadLevelGen(LevelGenerationOptions *levelGen)
+{	
+	// Load data from disc
+	//File saveFile( L"Tutorial\\Tutorial" );
+	//LoadSaveFromDisk(&saveFile);
+
+	// clear out the app's terrain features list
+	app.ClearTerrainFeaturePosition();
+		
+	StorageManager.ResetSaveData();
+	// Make our next save default to the name of the level
+	StorageManager.SetSaveTitle(levelGen->getDefaultSaveName().c_str());
+	
+	bool isClientSide = false;
+	bool isPrivate = false;
+	int maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
+
+	if( app.GetTutorialMode() )
+	{
+		isClientSide = false;
+		maxPlayers = 4;
+	}
+
+	g_NetworkManager.HostGame(0,isClientSide,isPrivate,maxPlayers,0);
+
+	NetworkGameInitData *param = new NetworkGameInitData();
+	param->seed = 0;
+	param->saveData = NULL;
+	param->settings = app.GetGameHostOption( eGameHostOption_Tutorial );
+	param->levelGen = levelGen;
+
+	if(levelGen->requiresTexturePack())
+	{
+		param->texturePackId = levelGen->getRequiredTexturePackId();
+	
+		Minecraft *pMinecraft = Minecraft::GetInstance();
+		pMinecraft->skins->selectTexturePackById(param->texturePackId);
+		//pMinecraft->skins->updateUI();
+	}
+
+	LoadingInputParams *loadingParams = new LoadingInputParams();
+	loadingParams->func = &CGameNetworkManager::RunNetworkGameThreadProc;
+	loadingParams->lpParam = (LPVOID)param;
+
+	UIFullscreenProgressCompletionData *completionData = new UIFullscreenProgressCompletionData();
+	completionData->bShowBackground=TRUE;
+	completionData->bShowLogo=TRUE;
+	completionData->type = e_ProgressCompletion_CloseAllPlayersUIScenes;
+	completionData->iPad = DEFAULT_XUI_MENU_USER;
+	loadingParams->completionData = completionData;
+
+	app.NavigateToScene(ProfileManager.GetPrimaryPad(),eUIScene_FullscreenProgress, loadingParams);
+}
+
+void CScene_MultiGameJoinLoad::LoadSaveFromDisk(File *saveFile)
+{	
+	// we'll only be coming in here when the tutorial is loaded now
+
+	StorageManager.ResetSaveData();
+
+	// Make our next save default to the name of the level
+	StorageManager.SetSaveTitle(saveFile->getName().c_str());
+
+	__int64 fileSize = saveFile->length();
+	FileInputStream fis(*saveFile);
+	byteArray ba(fileSize);
+	fis.read(ba);
+	fis.close();
+	
+	bool isClientSide = false;
+	bool isPrivate = false;
+	int maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
+
+	if( app.GetTutorialMode() )
+	{
+		isClientSide = false;
+		maxPlayers = 4;
+	}
+	
+	app.SetGameHostOption(eGameHostOption_GameType,GameType::CREATIVE->getId());
+
+	g_NetworkManager.HostGame(0,isClientSide,isPrivate,maxPlayers,0);
+
+	LoadSaveDataThreadParam *saveData = new LoadSaveDataThreadParam(ba.data, ba.length, saveFile->getName());
+
+	NetworkGameInitData *param = new NetworkGameInitData();
+	param->seed = 0;
+	param->saveData = saveData;
+	param->settings = app.GetGameHostOption( eGameHostOption_All );
+
+	LoadingInputParams *loadingParams = new LoadingInputParams();
+	loadingParams->func = &CGameNetworkManager::RunNetworkGameThreadProc;
+	loadingParams->lpParam = (LPVOID)param;
+
+	UIFullscreenProgressCompletionData *completionData = new UIFullscreenProgressCompletionData();
+	completionData->bShowBackground=TRUE;
+	completionData->bShowLogo=TRUE;
+	completionData->type = e_ProgressCompletion_CloseAllPlayersUIScenes;
+	completionData->iPad = DEFAULT_XUI_MENU_USER;
+	loadingParams->completionData = completionData;
+
+	app.NavigateToScene(ProfileManager.GetPrimaryPad(),eUIScene_FullscreenProgress, loadingParams);
+}
+
+int CScene_MultiGameJoinLoad::DeleteSaveDialogReturned(void *pParam,int iPad,C4JStorage::EMessageResult result)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+	// results switched for this dialog
+	if(result==C4JStorage::EMessage_ResultDecline) 
+	{
+		if(app.DebugSettingsOn() && app.GetLoadSavesFromFolderEnabled())
+		{
+			pClass->m_bIgnoreInput=false;
+		}
+		else
+		{
+			XCONTENT_DATA XContentData;
+			StorageManager.GetSaveCacheFileInfo(pClass->m_iChangingSaveGameInfoIndex-pClass->m_iDefaultButtonsC,XContentData);
+			StorageManager.DeleteSaveData(&XContentData,CScene_MultiGameJoinLoad::DeleteSaveDataReturned,pClass);
+			pClass->m_SavesListTimer.SetShow( TRUE );
+		}
+	}
+	else
+	{
+		pClass->m_bIgnoreInput=false;
+	}
+	return 0;
+}
+
+int CScene_MultiGameJoinLoad::SaveTransferDialogReturned(void *pParam,int iPad,C4JStorage::EMessageResult result)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+	// results switched for this dialog
+	if(result==C4JStorage::EMessage_ResultAccept) 
+	{
+		// upload the save
+
+		// first load the save
+		int iIndex=pClass->m_pSavesList->GetData(pClass->m_pSavesList->GetCurSel()).iIndex-pClass->m_iDefaultButtonsC;
+		XCONTENT_DATA ContentData;
+
+		// 4J-PB - ensure we've switched to the right title group id for uploading to
+		app.TMSPP_SetTitleGroupID(SAVETRANSFER_GROUP_ID);
+		StorageManager.GetSaveCacheFileInfo(iIndex,ContentData);
+		C4JStorage::ELoadGameStatus eLoadStatus=StorageManager.LoadSaveData(&ContentData,CScene_MultiGameJoinLoad::LoadSaveDataReturned,pClass);
+
+		pClass->m_bIgnoreInput=false;
+	}
+	else
+	{
+		pClass->m_bIgnoreInput=false;
+	}
+	return 0;
+}
+
+int CScene_MultiGameJoinLoad::UploadSaveForXboxOneThreadProc( LPVOID lpParameter )
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad *) lpParameter;
+	Minecraft *pMinecraft = Minecraft::GetInstance();	
+
+	pMinecraft->progressRenderer->progressStart(IDS_SAVE_TRANSFER_TITLE);
+	pMinecraft->progressRenderer->progressStage( IDS_SAVE_TRANSFER_UPLOADING );
+
+	// Delete the marker file
+	DeleteFile(pClass, "completemarker");
+	if(!WaitForTransferComplete(pClass)) return 0;
+
+	// Upload the save data
+	{
+		unsigned int uiSaveBytes;
+		uiSaveBytes=StorageManager.GetSaveSize();
+		pClass->m_pbSaveTransferData=new BYTE [uiSaveBytes];
+
+		StorageManager.GetSaveData(pClass->m_pbSaveTransferData,&uiSaveBytes);
+
+		app.DebugPrintf("Uploading save data (%d bytes)\n", uiSaveBytes);
+		UploadFile(pClass, "savedata", pClass->m_pbSaveTransferData, uiSaveBytes);
+	}
+
+	if(!WaitForTransferComplete(pClass)) return 0;
+	if(pClass->m_bTransferFail)
+	{
+		// something went wrong, user has been informed
+		pMinecraft->progressRenderer->progressStage( IDS_SAVE_TRANSFER_UPLOADFAILED );
+		return 0;
+	}
+
+	// Upload the metadata and thumbnail
+	{
+		ByteArrayOutputStream baos;
+		DataOutputStream dos(&baos);
+
+		LPCWSTR title = StorageManager.GetSaveTitle();
+		dos.writeUTF(title);
+
+		char szUniqueMapName[14];
+		StorageManager.GetSaveUniqueFilename(szUniqueMapName);
+		dos.writeUTF(convStringToWstring(szUniqueMapName));
+
+		{
+			// set the save icon
+			PBYTE pbImageData=NULL;
+			DWORD dwImageBytes=0;
+			XCONTENT_DATA XContentData;
+			int iIndex=pClass->m_pSavesList->GetData(pClass->m_pSavesList->GetCurSel()).iIndex-pClass->m_iDefaultButtonsC;
+			StorageManager.GetSaveCacheFileInfo(iIndex,XContentData);
+			StorageManager.GetSaveCacheFileInfo(iIndex,&pbImageData,&dwImageBytes);
+
+			// if there is no thumbnail, retrieve the default one from the file. 
+			// Don't delete the image data after creating the xuibrush, since we'll use it in the rename of the save
+			if(pbImageData==NULL)
+			{
+				DWORD dwResult=XContentGetThumbnail(ProfileManager.GetPrimaryPad(),&XContentData,NULL,&dwImageBytes,NULL);
+				if(dwResult==ERROR_SUCCESS)
+				{
+					pClass->m_pbSaveTransferData = new BYTE[dwImageBytes];
+					pbImageData = pClass->m_pbSaveTransferData; // Copy pointer so that we can use the same name as the library owned one, but m_pbSaveTransferData will get deleted when done
+					XContentGetThumbnail(ProfileManager.GetPrimaryPad(),&XContentData,pbImageData,&dwImageBytes,NULL);
+				}
+			}
+
+			dos.writeInt(dwImageBytes);
+
+			byteArray ba(pbImageData, dwImageBytes);
+			dos.write(ba);
+		}
+
+		pClass->m_pbSaveTransferData=new BYTE [baos.size()];
+		memcpy(pClass->m_pbSaveTransferData,baos.buf.data,baos.size());
+
+		app.DebugPrintf("Uploading meta data (%d bytes)\n", baos.size());
+		UploadFile(pClass, "metadata", pClass->m_pbSaveTransferData, baos.size());
+	}
+
+	// Wait for metadata and thumbnail
+	if(!WaitForTransferComplete(pClass)) return 0;
+	if(pClass->m_bTransferFail)
+	{
+		// something went wrong, user has been informed
+		pMinecraft->progressRenderer->progressStage( IDS_SAVE_TRANSFER_UPLOADFAILED );
+		return 0;
+	}
+
+	// Upload the marker file
+	{
+		char singleByteData[1] = {1};
+		app.DebugPrintf("Uploading marker (%d bytes)\n", 1);
+		UploadFile(pClass, "completemarker", &singleByteData, 1);
+	}
+
+	// Wait for marker
+	if(!WaitForTransferComplete(pClass)) return 0;
+	if(pClass->m_bTransferFail)
+	{
+		// something went wrong, user has been informed
+		pMinecraft->progressRenderer->progressStage( IDS_SAVE_TRANSFER_UPLOADFAILED );
+
+		return 0;
+	}
+	// change text for completion confirmation 
+	pMinecraft->progressRenderer->progressStage( IDS_SAVE_TRANSFER_UPLOADCOMPLETE );
+
+	// done
+	return 0;
+}
+
+void CScene_MultiGameJoinLoad::DeleteFile(CScene_MultiGameJoinLoad *pClass, char *filename)
+{
+	pClass->m_fProgress=0.0f;
+	pClass->m_bTransferComplete=false;
+
+	C4JStorage::ETMSStatus result = StorageManager.TMSPP_DeleteFile(
+		ProfileManager.GetPrimaryPad(),
+		filename,
+		C4JStorage::TMS_FILETYPE_BINARY,
+		&CScene_MultiGameJoinLoad::DeleteComplete,
+		pClass,
+		NULL);
+
+	if(result != C4JStorage::ETMSStatus_DeleteInProgress)
+	{
+		DeleteComplete(pClass,ProfileManager.GetPrimaryPad(), -1);
+	}
+}
+
+void CScene_MultiGameJoinLoad::UploadFile(CScene_MultiGameJoinLoad *pClass, char *filename, LPVOID data, DWORD size)
+{
+	pClass->m_fProgress=0.0f;
+	pClass->m_bTransferComplete=false;
+
+	C4JStorage::ETMSStatus result = StorageManager.TMSPP_WriteFileWithProgress(
+			ProfileManager.GetPrimaryPad(),
+			C4JStorage::eGlobalStorage_TitleUser,
+			C4JStorage::TMS_FILETYPE_BINARY,
+			C4JStorage::TMS_UGCTYPE_NONE,
+			filename,
+			(CHAR *)data, 
+			size,
+			&CScene_MultiGameJoinLoad::TransferComplete,pClass, 0,
+			&CScene_MultiGameJoinLoad::Progress,pClass);
+
+#ifdef _DEBUG_MENUS_ENABLED
+	if(app.GetWriteSavesToFolderEnabled())
+	{
+		File targetFileDir(L"GAME:\\FakeTMSPP");
+		if(!targetFileDir.exists()) targetFileDir.mkdir();
+		string path = string( wstringtofilename( targetFileDir.getPath() ) ).append("\\").append(filename);
+		HANDLE hSaveFile = CreateFile( path.c_str(), GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_RANDOM_ACCESS, NULL);
+
+		DWORD numberOfBytesWritten = 0;
+		WriteFile( hSaveFile,data,size,&numberOfBytesWritten,NULL);
+		assert(numberOfBytesWritten == size);
+
+		CloseHandle(hSaveFile);
+	}
+#endif
+
+	if(result != C4JStorage::ETMSStatus_WriteInProgress)
+	{
+		TransferComplete(pClass,ProfileManager.GetPrimaryPad(), -1);
+	}
+}
+
+bool CScene_MultiGameJoinLoad::WaitForTransferComplete( CScene_MultiGameJoinLoad *pClass )
+{
+	Minecraft *pMinecraft = Minecraft::GetInstance();
+	// loop until complete
+	while(pClass->m_bTransferComplete==false)
+	{
+		// check for a cancel
+		if(pClass->m_bSaveTransferInProgress==false)
+		{
+			// cancelled
+			return false;
+		}
+		Sleep(50);		
+		// update the progress
+		pMinecraft->progressRenderer->progressStagePercentage((unsigned int)(pClass->m_fProgress*100.0f));
+	}
+
+	// was there a transfer error?
+
+	return true;
+}
+
+int CScene_MultiGameJoinLoad::SaveOptionsDialogReturned(void *pParam,int iPad,C4JStorage::EMessageResult result)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+
+	// results switched for this dialog
+	// EMessage_ResultAccept means cancel
+	if(result==C4JStorage::EMessage_ResultDecline || result==C4JStorage::EMessage_ResultThirdOption) 
+	{
+		if(result==C4JStorage::EMessage_ResultDecline) // rename
+		{
+			ZeroMemory(pClass->m_wchNewName,sizeof(WCHAR)*XCONTENT_MAX_DISPLAYNAME_LENGTH);
+			// bring up a keyboard
+			InputManager.RequestKeyboard(IDS_RENAME_WORLD_TITLE,L"",IDS_RENAME_WORLD_TEXT,iPad,pClass->m_wchNewName,XCONTENT_MAX_DISPLAYNAME_LENGTH,&CScene_MultiGameJoinLoad::KeyboardReturned,pClass,C_4JInput::EKeyboardMode_Default,app.GetStringTable());
+		}
+		else // delete
+		{
+			// delete the save game
+			// Have to ask the player if they are sure they want to delete this game
+			UINT uiIDA[2];
+			uiIDA[0]=IDS_CONFIRM_CANCEL;
+			uiIDA[1]=IDS_CONFIRM_OK;
+			StorageManager.RequestMessageBox(IDS_TOOLTIPS_DELETESAVE, IDS_TEXT_DELETE_SAVE, uiIDA, 2, iPad,&CScene_MultiGameJoinLoad::DeleteSaveDialogReturned,pClass, app.GetStringTable());
+			//pClass->m_bIgnoreInput=false;
+		}
+	}
+	else
+	{
+		pClass->m_bIgnoreInput=false;
+	}
+	return 0;
+}
+
+int CScene_MultiGameJoinLoad::LoadSaveDataReturned(void *pParam,bool bContinue)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+
+	if(bContinue==true)
+	{
+		pClass->m_bSaveTransferInProgress=true;
+		LoadingInputParams *loadingParams = new LoadingInputParams();
+		loadingParams->func = &CScene_MultiGameJoinLoad::UploadSaveForXboxOneThreadProc;
+		loadingParams->lpParam = (LPVOID)pParam;
+
+		UIFullscreenProgressCompletionData *completionData = new UIFullscreenProgressCompletionData();
+		completionData->bShowBackground=TRUE;
+		completionData->bShowLogo=TRUE;
+		completionData->type = e_ProgressCompletion_NavigateBack;
+		completionData->iPad = DEFAULT_XUI_MENU_USER;
+		completionData->bRequiresUserAction=TRUE;
+		loadingParams->completionData = completionData;
+
+		loadingParams->cancelFunc=&CScene_MultiGameJoinLoad::CancelSaveUploadCallback;
+		loadingParams->completeFunc=&CScene_MultiGameJoinLoad::SaveUploadCompleteCallback;
+		loadingParams->m_cancelFuncParam=pClass;
+		loadingParams->m_completeFuncParam=pClass;
+		loadingParams->cancelText=IDS_TOOLTIPS_CANCEL;
+
+		app.NavigateToScene(ProfileManager.GetPrimaryPad(),eUIScene_FullscreenProgress, loadingParams);
+	}
+	else
+	{
+		// switch back to the normal title group id
+		app.TMSPP_SetTitleGroupID(GROUP_ID);
+
+		// the save is corrupt!
+
+		pClass->SetShow( TRUE );
+		pClass->m_bIgnoreInput=false;
+
+		// give the option to delete the save
+		UINT uiIDA[2];
+		uiIDA[0]=IDS_CONFIRM_CANCEL;
+		uiIDA[1]=IDS_CONFIRM_OK;
+		StorageManager.RequestMessageBox(IDS_CORRUPT_OR_DAMAGED_SAVE_TITLE, IDS_CORRUPT_OR_DAMAGED_SAVE_TEXT, uiIDA, 2, 
+			pClass->m_iPad,&CScene_MultiGameJoinLoad::DeleteSaveDialogReturned,pClass, app.GetStringTable());
+	
+	}
+
+	return 0;
+}
+
+int CScene_MultiGameJoinLoad::Progress(void *pParam,float fProgress)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+
+	app.DebugPrintf("Progress - %f\n",fProgress);
+	pClass->m_fProgress=fProgress;
+	return 0;
+}
+
+int CScene_MultiGameJoinLoad::TransferComplete(void *pParam,int iPad, int iResult)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+
+	delete [] pClass->m_pbSaveTransferData;
+	pClass->m_pbSaveTransferData = NULL;
+	if(iResult!=0)
+	{
+		// There was a transfer fail
+		// Display a dialog
+		UINT uiIDA[1];
+		uiIDA[0]=IDS_CONFIRM_OK;
+		StorageManager.RequestMessageBox(IDS_SAVE_TRANSFER_TITLE, IDS_SAVE_TRANSFER_UPLOADFAILED, uiIDA, 1, ProfileManager.GetPrimaryPad(),NULL,NULL,app.GetStringTable());
+		pClass->m_bTransferFail=true;
+	}
+	else
+	{
+		pClass->m_bTransferFail=false;
+	}
+	pClass->m_bTransferComplete=true;
+	//pClass->m_bSaveTransferInProgress=false;
+	return 0;
+}
+
+int CScene_MultiGameJoinLoad::DeleteComplete(void *pParam,int iPad, int iResult)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+	pClass->m_bTransferComplete=true;
+	return 0;
+}
+
+int CScene_MultiGameJoinLoad::KeyboardReturned(void *pParam,bool bSet)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+	HRESULT hr = S_OK;
+
+	// if the user has left the name empty, treat this as backing out
+	if((pClass->m_wchNewName[0]!=0) && bSet)
+	{
+#ifdef _XBOX
+		XCONTENT_DATA XContentData;
+		StorageManager.GetSaveCacheFileInfo(pClass->m_iChangingSaveGameInfoIndex-pClass->m_iDefaultButtonsC,XContentData);
+
+		C4JStorage::ELoadGameStatus eLoadStatus=StorageManager.LoadSaveData(&XContentData,CScene_MultiGameJoinLoad::LoadSaveDataForRenameReturned,pClass);
+
+		if(eLoadStatus==C4JStorage::ELoadGame_DeviceRemoved)
+		{
+			// disable saving 
+			StorageManager.SetSaveDisabled(true);
+			StorageManager.SetSaveDeviceSelected(ProfileManager.GetPrimaryPad(),false);
+			UINT uiIDA[1];
+			uiIDA[0]=IDS_OK;
+			StorageManager.RequestMessageBox(IDS_STORAGEDEVICEPROBLEM_TITLE, IDS_FAILED_TO_LOADSAVE_TEXT, uiIDA, 1, ProfileManager.GetPrimaryPad(),&CScene_MultiGameJoinLoad::DeviceRemovedDialogReturned,pClass);
+		}
+#else
+		// rename the save
+		
+#endif
+	}
+	else
+	{		
+		pClass->m_bIgnoreInput=false;
+	}
+
+	return hr;
+}
+
+int CScene_MultiGameJoinLoad::LoadSaveDataForRenameReturned(void *pParam,bool bContinue)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+#ifdef _XBOX
+	if(bContinue==true)
+	{
+		// set the save icon
+		PBYTE pbImageData=NULL;
+		DWORD dwImageBytes=0;
+		HXUIBRUSH hXuiBrush;
+		XCONTENT_DATA XContentData;
+		StorageManager.GetSaveCacheFileInfo(pClass->m_iChangingSaveGameInfoIndex-pClass->m_iDefaultButtonsC,XContentData);
+		StorageManager.GetSaveCacheFileInfo(pClass->m_iChangingSaveGameInfoIndex-pClass->m_iDefaultButtonsC,&pbImageData,&dwImageBytes);
+
+		// if there is no thumbnail, retrieve the default one from the file. 
+		// Don't delete the image data after creating the xuibrush, since we'll use it in the rename of the save
+		if(pbImageData==NULL)
+		{
+			DWORD dwResult=XContentGetThumbnail(ProfileManager.GetPrimaryPad(),&XContentData,NULL,&dwImageBytes,NULL);
+			if(dwResult==ERROR_SUCCESS)
+			{
+				pbImageData = new BYTE[dwImageBytes];
+				XContentGetThumbnail(ProfileManager.GetPrimaryPad(),&XContentData,pbImageData,&dwImageBytes,NULL);
+				XuiCreateTextureBrushFromMemory(pbImageData,dwImageBytes,&hXuiBrush);
+			}
+		}
+		else
+		{
+			XuiCreateTextureBrushFromMemory(pbImageData,dwImageBytes,&hXuiBrush);
+		}
+		// save the data with this icon
+		StorageManager.CopySaveDataToNewSave( pbImageData,dwImageBytes,pClass->m_wchNewName,&CScene_MultiGameJoinLoad::CopySaveReturned,pClass);
+	}
+	else
+#endif
+	{
+		//pClass->SetShow( TRUE );
+		pClass->m_bIgnoreInput=false;
+	}
+	return 0;
+}
+
+int CScene_MultiGameJoinLoad::CopySaveReturned(void *pParam,bool bResult)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad*)pParam;
+#ifdef _XBOX
+	if(bResult)
+	{
+		// and delete the old save
+		XCONTENT_DATA XContentData;
+		StorageManager.GetSaveCacheFileInfo(pClass->m_iChangingSaveGameInfoIndex-pClass->m_iDefaultButtonsC,XContentData);
+		StorageManager.DeleteSaveData(&XContentData,CScene_MultiGameJoinLoad::DeleteSaveDataReturned,pClass);
+		pClass->m_SavesListTimer.SetShow( TRUE );
+	}
+	else
+#endif
+	{
+		//pClass->SetShow( TRUE );
+		pClass->m_bIgnoreInput=false;
+	}
+
+	return 0;
+}
+
+int CScene_MultiGameJoinLoad::TexturePackDialogReturned(void *pParam,int iPad,C4JStorage::EMessageResult result)
+{
+	CScene_MultiGameJoinLoad *pClass = (CScene_MultiGameJoinLoad *)pParam;
+
+	// Exit with or without saving
+	// Decline means install full version of the texture pack in this dialog
+	if(result==C4JStorage::EMessage_ResultDecline || result==C4JStorage::EMessage_ResultAccept) 
+	{
+		// we need to enable background downloading for the DLC
+		XBackgroundDownloadSetMode(XBACKGROUND_DOWNLOAD_MODE_ALWAYS_ALLOW);
+
+		ULONGLONG ullOfferID_Full;
+		ULONGLONG ullIndexA[1];
+		app.GetDLCFullOfferIDForPackID(pClass->m_initData->selectedSession->data.texturePackParentId,&ullOfferID_Full);
+
+		if( result==C4JStorage::EMessage_ResultAccept ) // Full version
+		{
+			ullIndexA[0]=ullOfferID_Full;
+			StorageManager.InstallOffer(1,ullIndexA,NULL,NULL);
+
+		}
+		else // trial version
+		{
+			// if there is no trial version, this is a Cancel
+			DLC_INFO *pDLCInfo=app.GetDLCInfoForFullOfferID(ullOfferID_Full);
+			if(pDLCInfo->ullOfferID_Trial!=0LL)
+			{
+				ullIndexA[0]=pDLCInfo->ullOfferID_Trial;
+				StorageManager.InstallOffer(1,ullIndexA,NULL,NULL);
+			}
+		}		
+	}
+	pClass->m_bIgnoreInput=false;
+	return 0;
+}
+
+HRESULT CScene_MultiGameJoinLoad::OnCustomMessage_DLCInstalled()
+{
+	// mounted DLC may have changed
+	
+	if(app.StartInstallDLCProcess(m_iPad)==false)
+	{
+		// not doing a mount, so re-enable input
+		m_bIgnoreInput=false;
+	}
+	else
+	{
+		m_bIgnoreInput=true;
+		// clear out the saves list and re-fill
+
+		m_pSavesList->RemoveAllData();
+		m_SavesListTimer.SetShow( TRUE );
+	}
+	// this will send a CustomMessage_DLCMountingComplete when done
+	return S_OK;
+}
+
+HRESULT CScene_MultiGameJoinLoad::OnCustomMessage_DLCMountingComplete()
+{	
+
+	VOID *pObj;
+	XuiObjectFromHandle( m_SavesList, &pObj );
+	m_pSavesList = (CXuiCtrl4JList *)pObj;
+
+	m_iChangingSaveGameInfoIndex = 0;
+
+	m_generators = app.getLevelGenerators();
+	m_iDefaultButtonsC = 0;
+	m_iMashUpButtonsC = 0;
+	XPARTY_USER_LIST partyList;
+
+	if((XPartyGetUserList(  &partyList ) != XPARTY_E_NOT_IN_PARTY ) && (partyList.dwUserCount>1))
+	{
+		m_bInParty=true;
+	}
+	else
+	{
+		m_bInParty=false;
+	}
+
+	int iLB = -1;
+
+	int iY=-1;
+	if(DoesSavesListHaveFocus())
+	{	
+		if(ProfileManager.IsSignedInLive( m_iPad ))
+		{
+			iY=IDS_TOOLTIPS_UPLOAD_SAVE_FOR_XBOXONE;
+		}
+	}
+	if(m_bInParty) iLB = IDS_TOOLTIPS_PARTY_GAMES;
+	// check if we're in the trial version
+	if(ProfileManager.IsFullVersion()==false)
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK, -1, -1, -1, -1,iLB);
+
+		AddDefaultButtons();
+
+		m_pSavesList->SetCurSelVisible(0);
+	}
+	else if(StorageManager.GetSaveDisabled())
+	{
+		if(StorageManager.GetSaveDeviceSelected(m_iPad))
+		{
+			// saving is disabled, but we should still be able to load from a selected save device
+
+			ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_CHANGEDEVICE,iY,-1,-1,iLB,IDS_TOOLTIPS_DELETESAVE);
+
+			GetSaveInfo();
+		}
+		else
+		{
+			ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_SELECTDEVICE,iY,-1,-1,iLB);
+
+			AddDefaultButtons();
+			m_SavesListTimer.SetShow( FALSE );
+
+			m_pSavesList->SetCurSelVisible(0);
+		}
+	}
+	else
+	{
+		// 4J-PB - we need to check that there is enough space left to create a copy of the save (for a rename)
+		bool bCanRename = StorageManager.EnoughSpaceForAMinSaveGame();
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK,IDS_TOOLTIPS_CHANGEDEVICE,iY,-1,-1,-1,bCanRename?IDS_TOOLTIPS_SAVEOPTIONS:IDS_TOOLTIPS_DELETESAVE);
+
+		GetSaveInfo();
+	}
+
+	m_bIgnoreInput=false;
+	app.m_dlcManager.checkForCorruptDLCAndAlert();
+	return S_OK;
+}
+
+/*
+void CScene_MultiGameJoinLoad::UpdateTooltips()
+{
+	int iA=IDS_TOOLTIPS_SELECT;
+	int iB=IDS_TOOLTIPS_BACK;
+	int iX=-1;
+	int iY=-1
+	int iLB = -1;
+	XPARTY_USER_LIST partyList;
+
+	if((XPartyGetUserList(  &partyList ) != XPARTY_E_NOT_IN_PARTY ) && (partyList.dwUserCount>1))
+	{
+		m_bInParty=true;
+	}
+	else
+	{
+		m_bInParty=false;
+	}
+
+	if(m_bInParty) iLB = IDS_TOOLTIPS_PARTY_GAMES;
+
+	if(ProfileManager.IsFullVersion()==false)
+	{
+		ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,IDS_TOOLTIPS_BACK, -1, -1, -1, -1,iLB);
+	}
+	else if(StorageManager.GetSaveDisabled())
+	{
+		if(StorageManager.GetSaveDeviceSelected(m_iPad))
+		{
+			// saving is disabled, but we should still be able to load from a selected save device
+			iX=IDS_TOOLTIPS_CHANGEDEVICE;
+			iRB=IDS_TOOLTIPS_DELETESAVE;
+		}
+		else
+		{
+			iX=IDS_TOOLTIPS_SELECTDEVICE;
+		}
+	}
+	else
+	{
+		// 4J-PB - we need to check that there is enough space left to create a copy of the save (for a rename)
+		bool bCanRename = StorageManager.EnoughSpaceForAMinSaveGame();
+
+		if(bCanRename) 
+		{
+			iRB=IDS_TOOLTIPS_SAVEOPTIONS;
+		}
+		else
+		{
+			iRB=IDS_TOOLTIPS_DELETESAVE;
+		}
+	}
+
+	ui.SetTooltips( DEFAULT_XUI_MENU_USER, iA,iB, iX, iY, iLT, iRT,iLB, iRB);
+}
+*/
+
+
+
+#ifdef _XBOX
+bool CScene_MultiGameJoinLoad::GetSavesInfoCallback(LPVOID pParam,int iTotalSaveInfoC, C4JStorage::CACHEINFOSTRUCT *InfoA, int iPad, HRESULT hResult)
+{
+	CScene_MultiGameJoinLoad *pClass=(CScene_MultiGameJoinLoad *)pParam;
+	CXuiCtrl4JList::LIST_ITEM_INFO ListInfo;
+	PBYTE pbImageData=(PBYTE)InfoA;
+	PBYTE pbCurrentImagePtr;
+	HXUIBRUSH hXuiBrush;
+	HRESULT hr;
+
+	// move the image data pointer to the right place
+	if(iTotalSaveInfoC!=0)
+	{
+		pbImageData+=sizeof(C4JStorage::CACHEINFOSTRUCT)*iTotalSaveInfoC;
+	}
+
+	pClass->m_SavesListTimer.SetShow( FALSE );
+	pClass->m_SavesList.SetEnable(TRUE);
+
+	pClass->AddDefaultButtons();
+
+	for(int i=0;i<iTotalSaveInfoC;i++)
+	{
+		ZeroMemory(&ListInfo,sizeof(CXuiCtrl4JList::LIST_ITEM_INFO));
+		// Add these to the save list
+		if(!(app.DebugSettingsOn() && app.GetLoadSavesFromFolderEnabled()))
+		{
+			// if the save is corrupt, display this instead of the title
+			if(InfoA[i].dwImageBytes==0)
+			{
+				ListInfo.pwszText=app.GetString(IDS_CORRUPT_OR_DAMAGED_SAVE_TITLE);
+				ListInfo.bIsDamaged=true;
+			}
+			else
+			{
+				ListInfo.pwszText=InfoA[i].wchDisplayName;
+				ListInfo.bIsDamaged=false;
+			}
+			ListInfo.fEnabled=TRUE;
+			ListInfo.iData = -1;
+
+			pClass->m_pSavesList->AddData(ListInfo,-1);
+
+			// update the graphic on the list item
+
+			// if there is no thumbnail, this is a corrupt file
+			if(InfoA[i].dwImageBytes!=0)
+			{
+				pbCurrentImagePtr=pbImageData+InfoA[i].dwImageOffset;
+				hr=XuiCreateTextureBrushFromMemory(pbCurrentImagePtr,InfoA[i].dwImageBytes,&hXuiBrush);
+				pClass->m_pSavesList->UpdateGraphic(i+pClass->m_iDefaultButtonsC,hXuiBrush );
+			}	
+			else
+			{
+				// we could put in a damaged save icon here
+				const DWORD LOCATOR_SIZE = 256; // Use this to allocate space to hold a ResourceLocator string 
+				WCHAR szResourceLocator[ LOCATOR_SIZE ];
+				const ULONG_PTR c_ModuleHandle = (ULONG_PTR)GetModuleHandle(NULL);
+
+				swprintf(szResourceLocator, LOCATOR_SIZE, L"section://%X,%ls#%ls",c_ModuleHandle,L"media", L"media/Graphics/MinecraftBrokenIcon.png");
+
+				XuiCreateTextureBrush(szResourceLocator,&hXuiBrush);
+				pClass->m_pSavesList->UpdateGraphic(i+pClass->m_iDefaultButtonsC,hXuiBrush );
+			}
+		}
+	}
+
+	pClass->m_iSaveInfoC=iTotalSaveInfoC;
+
+	// If there are some saves, then set the focus to be on the most recent one, which will be the first one after the create and tutorial
+	if(iTotalSaveInfoC>0)
+	{
+		pClass->m_pSavesList->SetCurSelVisible(pClass->m_iDefaultButtonsC);
+		pClass->m_bReady=true;
+	}
+
+	pClass->m_bRetrievingSaveInfo=false;
+
+	// It's possible that the games list is updated but we haven't displayed it yet as we were still waiting on saves list to load
+	// This is to fix a bug where joining a game before the saves list has loaded causes a crash when this callback is called
+	// as the scene no longer exists
+	pClass->UpdateGamesList();	
+
+	// Fix for #45154 - Frontend: DLC: Content can only be downloaded from the frontend if you have not joined/exited multiplayer
+	XBackgroundDownloadSetMode(XBACKGROUND_DOWNLOAD_MODE_AUTO);
+
+	return false;
+}
+#else
+int CScene_MultiGameJoinLoad::GetSavesInfoCallback(LPVOID lpParam,const bool)
+{
+	return true;
+}
+#endif
+
+void CScene_MultiGameJoinLoad::CancelSaveUploadCallback(LPVOID lpParam)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad *) lpParam;
+
+	StorageManager.TMSPP_CancelWriteFileWithProgress(pClass->m_iPad);
+
+	pClass->m_bSaveTransferInProgress=false;
+
+	// change back to the normal title group id
+	app.TMSPP_SetTitleGroupID(GROUP_ID);
+// 	app.getRemoteStorage()->abort();
+// 	pClass->m_eSaveUploadState = eSaveUpload_Idle;
+
+	UINT uiIDA[1] = { IDS_CONFIRM_OK };
+	ui.RequestMessageBox(IDS_XBONE_CANCEL_UPLOAD_TITLE, IDS_XBONE_CANCEL_UPLOAD_TEXT, uiIDA, 1, pClass->m_iPad, NULL, NULL, app.GetStringTable());
+}
+
+void CScene_MultiGameJoinLoad::SaveUploadCompleteCallback(LPVOID lpParam)
+{
+	CScene_MultiGameJoinLoad* pClass = (CScene_MultiGameJoinLoad *) lpParam;
+
+	pClass->m_bSaveTransferInProgress=false;
+	// change back to the normal title group id
+	app.TMSPP_SetTitleGroupID(GROUP_ID);
+	// 	app.getRemoteStorage()->abort();
+	// 	pClass->m_eSaveUploadState = eSaveUpload_Idle;
+}
\ No newline at end of file