// appui.cpp
//
// Copyright (c) 2000 Symbian Ltd.  All rights reserved.
//

#include "appui.h"
#include "controller.h"
#include "appview.h"

#include <eikenv.h>
#include <eikbutb.h>
#include <eiktbar.h>
#include <eikdialg.h>
#include <eikedwin.h>
#include <eikfnlab.h>
#include <eikchlst.h>

#include <gdp.h>

#include <qiknumbereditor.h>


// for use with r_game_gdp_protocols
TInt GDPProtocolIDToChoiceList(TUid aProtocol);
TUid ChoiceListToGDPProtocol(TInt aIndex);

/*
	CGameSendDialog
*/

class CGameSendDialog : public CEikDialog
	{
public:
	CGameSendDialog(CGameController* aController);
private:
	// from CEikDialog
	void PreLayoutDynInitL(); // initialization
	TBool OkToExitL(TInt aKeycode); // termination
private:
	CGameController* iController;
	};

CGameSendDialog::CGameSendDialog(CGameController* aController)
	: iController(aController)
	{
	}

void CGameSendDialog::PreLayoutDynInitL() // initialization
	{
	static_cast<CEikEdwin*>(Control(EGameControlIdSendText))->SetTextL(&(iController->iEngine->LastSent()));
	}

TBool CGameSendDialog::OkToExitL(TInt /* aKeycode */) // termination
	{
	CEikEdwin* edwin=STATIC_CAST(CEikEdwin*, Control(EGameControlIdSendText));
	HBufC* string=edwin->GetTextInHBufL();
	if (!string)
		string=_L("").AllocL();
	CleanupStack::PushL(string);
	iController->CmdSendMessageL(*string);
	CleanupStack::PopAndDestroy(); // string
	return ETrue;
	}

/*
	CGameInitiateDialog
*/

class CGameInitiateDialog : public CEikDialog
	{
public:
	CGameInitiateDialog(CGameController* aController);
private:
	// from CEikDialog
	void PreLayoutDynInitL(); // initialization
	TBool OkToExitL(TInt aKeycode); // termination
private:
	CGameController* iController;
	};

CGameInitiateDialog::CGameInitiateDialog(CGameController* aController)
	: iController(aController)
	{
	}

void CGameInitiateDialog::PreLayoutDynInitL() // initialization
	{
	_LIT(KBlank,"");
	static_cast<CEikEdwin*>(Control(EGameControlIdSendText))->SetTextL(&KBlank);
	static_cast<CEikEdwin*>(Control(EGameControlIdOtherAddress))->SetTextL(&KBlank);
	}

TBool CGameInitiateDialog::OkToExitL(TInt /* aKeycode */) // termination
	{
	// reset controller if necessary
	if (!iController->iEngine->IsBlank())
		iController->Reset();
	// get other address
	CEikEdwin* edwin=STATIC_CAST(CEikEdwin*, Control(EGameControlIdOtherAddress));
	HBufC* address=edwin->GetTextInHBufL();
	if (!address)
		address=_L("").AllocL();
	CleanupStack::PushL(address);
	// get string to send
	edwin=STATIC_CAST(CEikEdwin*, Control(EGameControlIdSendText));
	HBufC* string=edwin->GetTextInHBufL();
	if (!string)
		string=_L("").AllocL();
	CleanupStack::PushL(string);
	// get controller to handle set up
	iController->InitiateL(*address, *string);
	iEikonEnv->InfoMsg(R_GAME_HAVE_INITIATED);
	// clean up and return
	CleanupStack::PopAndDestroy(2); // string, address
	return ETrue;
	}



/*
	CGameSetMeDialog
*/

class CGameSetMeDialog : public CEikDialog
	{
public:
	CGameSetMeDialog(CGameController* aController);
private:
	// from CEikDialog
	void PreLayoutDynInitL(); // initialization
	TBool OkToExitL(TInt aKeycode); // termination

private:
	CGameController* iController;
	};

CGameSetMeDialog::CGameSetMeDialog(CGameController* aController)
	: iController(aController)
	{
	}

void CGameSetMeDialog::PreLayoutDynInitL() // initialization
	{
	TInt cursor = GDPProtocolIDToChoiceList(iController->iGsdp.GetGdpProtocol());
 	static_cast<CEikChoiceListBase*>(Control(EGameControlIdProtocol))->SetCurrentItem(cursor);
  	}

TBool CGameSetMeDialog::OkToExitL(TInt /* aKeycode */) // termination
	{
	// reset controller if necessary
	if (!iController->iEngine->IsBlank())
		iController->Reset();
	// get protocol
	TInt cursor = static_cast<CEikChoiceListBase*>(Control(EGameControlIdProtocol))->CurrentItem() + 1;
	// get controller to handle set up
	iController->SetupMeL(ChoiceListToGDPProtocol(cursor));
	iEikonEnv->InfoMsg(R_GAME_HAVE_SETME);
	// clean up and return
	return ETrue;
	}

// ordering in these two functions must match resource file
TInt GDPProtocolIDToChoiceList(TUid aProtocol)
	{
	if (aProtocol == KGdpLoopbackUid) return 0;
	else if (aProtocol == KGdpBTUid) return 1;
	else if (aProtocol == KGdpSmsUid) return 2;
	else return 0;
	}

TUid ChoiceListToGDPProtocol(TInt aIndex)
	{
	switch (aIndex)
		{
	case 1: return KGdpLoopbackUid;
	case 2: return KGdpBTUid;
	case 3: return KGdpSmsUid;
	default: return KGdpLoopbackUid;
		}
	}

/*
	CGameDisplaySettingsDialog
*/

class CGameDisplaySettingsDialog : public CEikDialog
	{
public:
	CGameDisplaySettingsDialog(CGameController* aController);
private:
	// from CEikDialog
	void PreLayoutDynInitL(); // initialization
private:
	CGameController* iController;
	};

CGameDisplaySettingsDialog::CGameDisplaySettingsDialog(CGameController* aController)
	: iController(aController)
	{
	}

void CGameDisplaySettingsDialog::PreLayoutDynInitL() // initialization
	{
 	static_cast<CEikChoiceListBase*>(Control(EGameControlIdState))->SetCurrentItem(iController->iEngine->State());
 	static_cast<CEikChoiceListBase*>(Control(EGameControlIdProtocol))->SetCurrentItem(GDPProtocolIDToChoiceList(iController->iEngine->GetGdpProtocol()));

	TBuf<10> port;
	port.AppendNum(TUint(iController->iEngine->MyPort()));
 	static_cast<CEikEdwin*>(Control(EGameControlIdMyPort))->SetTextL(&port);


	static_cast<CEikEdwin*>(Control(EGameControlIdOtherAddress))->SetTextL(&(iController->iEngine->OtherAddress()));

	port.Zero();
	port.AppendNum(TUint(iController->iEngine->OtherPort()));
	static_cast<CEikEdwin*>(Control(EGameControlIdOtherPort))->SetTextL(&port);
	}

/*
	CGameAppUi
*/

void CGameAppUi::ConstructL()
    {
    BaseConstructL();
	// construct comms interfaces and controller for player 1
	iController=new(ELeave) CGameController;
	iController->ConstructL(STATIC_CAST(CGameDocument*, Document())->iEngine, this);
	iController->Reset();
    }

CGameAppUi::~CGameAppUi()
	{
	delete iController;
	}

void CGameAppUi::HandleCommandL(TInt aCommand)
	{
	switch (aCommand)
		{
	case EGameCmdSend:
		CmdSendL();
		break;
	case EGameCmdReceiveAll:
		CmdReceiveAll();
		break;
	case EGameCmdDisplaySettings:
		CmdDisplaySettingsL();
		break;
	case EGameCmdReset:
		CmdResetL();
		break;
	case EGameCmdSetMe:
		CmdSetMeL();
		break;
	case EGameCmdInitiate:
		CmdInitiateL();
		break;
	case EGameCmdListen:
		CmdListenL();
		break;
	case EEikCmdExit: 
		SaveL();
		Exit();
		break;
		}
	}

void CGameAppUi::CmdSetMeL()
	{
	// user-friendly checks
	if (!iController->iEngine->IsBlank() && !iEikonEnv->QueryWinL(R_GAME_CONFIRM_SETME))
		return;
	// do it
	CEikDialog* dialog=new(ELeave) CGameSetMeDialog(iController);
	dialog->ExecuteLD(R_GAME_SET_ME_DIALOG);
	}

void CGameAppUi::CmdDisplaySettingsL()
	{
	CEikDialog* dialog=new(ELeave) CGameDisplaySettingsDialog(iController);
	dialog->ExecuteLD(R_GAME_DISPLAY_SETTINGS_DIALOG);
	}

void CGameAppUi::CmdListenL()
	{
	// user-friendly checks
	if (!iController->iEngine->IsBlank() && !iEikonEnv->QueryWinL(R_GAME_CONFIRM_LISTEN))
		return;
	// do it
	iController->Reset();
	iController->Listen();
	iEikonEnv->InfoMsg(R_GAME_AM_LISTENING);
	}

void CGameAppUi::CmdInitiateL()
	{
	// user-friendly checks
	if (!iController->iEngine->IsBlank() && !iEikonEnv->QueryWinL(R_GAME_CONFIRM_INITIATE))
		return;
	// do it
	CEikDialog* dialog=new(ELeave) CGameInitiateDialog(iController);
	dialog->ExecuteLD(R_GAME_INITIATE_DIALOG);
	}

void CGameAppUi::CmdResetL()
	{
	// user-friendly checks and messages
	if (iController->iEngine->IsBlank())
		iEikonEnv->LeaveWithInfoMsg(R_GAME_ALREADY_RESET);
	if (!iEikonEnv->QueryWinL(R_GAME_CONFIRM_RESET))
		return;
	// ok, do it
	iController->Reset();
	iEikonEnv->InfoMsg(R_GAME_HAVE_RESET);
	}

void CGameAppUi::CmdSendL()
	{
	// user-friendly check
	if (!iController->iEngine->IsBound())
		iEikonEnv->LeaveWithInfoMsg(R_GAME_CANT_SEND);
	// do it
	CEikDialog* dialog=new(ELeave) CGameSendDialog(iController);
	dialog->ExecuteLD(R_GAME_SEND_DIALOG);
	}

void CGameAppUi::CmdReceiveAll()
	{
	iController->ReceiveAll();
	}

// file-based app framework

TBool CGameAppUi::ProcessCommandParametersL(TApaCommand aCommand, TFileName& aDocumentName, const TDesC& /*aTail*/)
	{
	return CEikAppUi::ProcessCommandParametersL(aCommand, aDocumentName);
	}

void CGameAppUi::HandleModelChangeL()
	{
	iController->SetEngineL(STATIC_CAST(CGameDocument*, Document())->iEngine);
	iEikonEnv->UpdateTaskNameL();
	}

/*
	CGameDocument
*/

CGameDocument::CGameDocument(CEikApplication& aApp)
		: CEikDocument(aApp)
	{
	}

void CGameDocument::ConstructL()
	{
	iEngine=new(ELeave) CGameEngine;
	}

CGameDocument::~CGameDocument()
	{
	delete iEngine;
	}

CEikAppUi* CGameDocument::CreateAppUiL()
	{
    return new(ELeave) CGameAppUi;
	}

void CGameDocument::NewDocumentL()
	{
	iEngine->Reset();
	}

void CGameDocument::RestoreL(const CStreamStore& aStore,const CStreamDictionary& aStreamDict)
	{
	CGameEngine* engine=new(ELeave) CGameEngine;
	CleanupStack::PushL(engine);
	TStreamId id=aStreamDict.At(KUidExample);
	engine->RestoreL(aStore, id);
	CleanupStack::Pop();
	delete iEngine;
	iEngine=engine;
	}

void CGameDocument::StoreL(CStreamStore& aStore,CStreamDictionary& aStreamDict) const
	{
	TStreamId id=iEngine->StoreL(aStore);
	aStreamDict.AssignL(KUidExample,id);
	}

/*
	CGameApplication
*/

TUid CGameApplication::AppDllUid() const
	{
	return KUidExample;
	}

CApaDocument* CGameApplication::CreateDocumentL()
	{
	CGameDocument* doc=new(ELeave) CGameDocument(*this);
	CleanupStack::PushL(doc);
	doc->ConstructL();
	CleanupStack::Pop();
	return doc;
	}

// DLL interface stuff

EXPORT_C CApaApplication* NewApplication()
	{
	return new CGameApplication;
	}

GLDEF_C TInt E32Dll(TDllReason)
	{
	return KErrNone;
	}