//  INCLUDES

#include <aknapp.h>

#include <aknappui.h>

#include <eikdoc.h>

#include <sdlepocapi.h>

#include <bautils.h>

#include <eikstart.h>

#include <badesca.h>

#include <bautils.h>

#include <apgcli.h>

#include <sdlmain.h>

#include <eikedwin.h>

#include <eiklabel.h>

#include <sdlexe.rsg>

#include <aknglobalmsgquery.h>

#include <apgwgnam.h> 

//  FORWARD DECLARATIONS

class CApaDocument;

//const TUid KSDLUID = { 0xF01F605E };

LOCAL_C void MakeCCmdLineL(const TDesC8& aParam, CDesC8Array& aArray)

    { 

    const TChar dq('\"');

    TLex8 lex(aParam);

    TBool in = EFalse;

    lex.SkipSpaceAndMark();

    while(!lex.Eos())

        {

        TPtrC8 ptr;

        if(in)

            {

            const TPtrC8 rem = lex.RemainderFromMark();

            const TInt pos = rem.Locate(dq);

            if(pos > 0)

                {

                lex.Inc(pos);

                ptr.Set(lex.MarkedToken());

                lex.SkipAndMark(1);

                }

            else

                {

                ptr.Set(rem);

                }

            in = EFalse;

            }

        else

            {

            ptr.Set(lex.NextToken());

            const TInt pos = ptr.Locate(dq);

            if(pos == 0)

                {

                lex.UnGetToMark();

                lex.SkipAndMark(1);

                in = ETrue;

                continue; // back to in brace

                }

            else

                lex.SkipSpaceAndMark();

            }

        aArray.AppendL(ptr);

        }

    }  

NONSHARABLE_CLASS(TVirtualCursor) : public MOverlay

	{

	public:

		TVirtualCursor();

		void Set(const TRect& aRect, CFbsBitmap* aBmp, CFbsBitmap* aAlpha);

		void Move(TInt aX, TInt aY);

		void MakeEvent(TWsEvent& aEvent, const TPoint& aBasePos) const;

		void Toggle();

		TBool IsOn() const;

	private:

    	void Draw(CBitmapContext& aGc, const TRect& aTargetRect, const TSize& aSize);

	private:

		TRect iRect;

		TPoint iInc;

		TPoint iPos;

		TBool iIsOn;

		CFbsBitmap* iCBmp;

		CFbsBitmap* iAlpha;

	};

TVirtualCursor::TVirtualCursor() :  iInc(0, 0), iIsOn(EFalse), iCBmp(NULL)

	{	

	}

const TInt KMaxMove = 10;	

void TVirtualCursor::Move(TInt aX, TInt aY)

	{

	if(aX > 0 && iInc.iX > 0)

			++iInc.iX;

	else if(aX < 0 && iInc.iX < 0)

			--iInc.iX;

	else

		iInc.iX = aX;

	if(aY > 0 && iInc.iY > 0)

			++iInc.iY;

	else if(aY < 0 && iInc.iY < 0)

			--iInc.iY;

	else

			iInc.iY = aY;

	iInc.iX = Min(KMaxMove, iInc.iX); 

	iInc.iX = Max(-KMaxMove, iInc.iX);

	iInc.iY = Min(KMaxMove, iInc.iY);

	iInc.iY =Max(-KMaxMove, iInc.iY);

	const TPoint pos = iPos + iInc;

	if(iRect.Contains(pos))

		{

		iPos = pos;

		}

	else

		{

		iInc = TPoint(0, 0);	

		}

	}

void TVirtualCursor::Toggle()

	{

	iIsOn = !iIsOn;

	}

TBool TVirtualCursor::IsOn() const

	{

	return iIsOn;

	}

void TVirtualCursor::Set(const TRect& aRect, CFbsBitmap* aBmp, CFbsBitmap* aAlpha)

	{

	iRect = aRect;

	iCBmp = aBmp;

	iAlpha = aAlpha;

	}

void TVirtualCursor::MakeEvent(TWsEvent& aEvent, const TPoint& aBasePos) const

	{

 	aEvent.SetType(EEventPointer),

	aEvent.SetTimeNow();

	TPointerEvent& pointer = *aEvent.Pointer();	

	pointer.iType = TPointerEvent::EButton1Down;

	pointer.iPosition = iPos;

	pointer.iParentPosition = aBasePos;

	}

void TVirtualCursor::Draw(CBitmapContext& aGc, const TRect& /*aTargetRect*/, const TSize& /*aSize*/)

	{

	if(iIsOn && iCBmp != NULL)

		{

		const TRect rect(TPoint(0, 0), iCBmp->SizeInPixels());

		aGc.AlphaBlendBitmaps(iPos, iCBmp, rect, iAlpha, TPoint(0, 0));

		}

	}	

NONSHARABLE_CLASS(TSdlClass)

	{

	public:

		TSdlClass();

		void SetMain(const TMainFunc& aFunc, TInt aFlags, MSDLMainObs* aObs, TInt aExeFlags);

		TInt SdlFlags() const;

		const TMainFunc& Main() const;

		void SendEvent(TInt aEvent, TInt aParam, CSDL* aSDL);

		TInt AppFlags() const; 

		void AppFlags(TInt aFlags); 

	private:

		TMainFunc iFunc;

		TInt iSdlFlags;

		TInt iExeFlags;

		MSDLMainObs* iObs;

	};

void TSdlClass::AppFlags(TInt aFlags)

	{

	iExeFlags |= aFlags;

	}

void TSdlClass::SendEvent(TInt aEvent, TInt aParam, CSDL* aSDL)

	{

	if(iObs != NULL)

		iObs->SDLMainEvent(aEvent, aParam, aSDL);

	}

TInt TSdlClass::AppFlags() const

	{

	return iExeFlags;

	}

void TSdlClass::SetMain(const TMainFunc& aFunc, TInt aFlags, MSDLMainObs* aObs, TInt aExeFlags)

	{	

	iFunc = aFunc;

	iSdlFlags = aFlags;

	iExeFlags = aExeFlags;

	iObs = aObs;

	}

const TMainFunc& TSdlClass::Main() const

	{

	return iFunc;

	}

 TInt TSdlClass::SdlFlags() const

 	{

 	return iSdlFlags;

 	}

TSdlClass::TSdlClass()

	{

	Mem::FillZ(this, sizeof(this));

	}

TSdlClass gSDLClass;    

////////////////////////////////////////////////////////////////    

NONSHARABLE_CLASS(CSDLApplication) : public CAknApplication

    {

    public:

    	CSDLApplication();

    private:

        CApaDocument* CreateDocumentL(); 

        TFileName ResourceFileName() const;

        TUid AppDllUid() const; 

      		void FindMeL();

     		TUid iUid;

    };

NONSHARABLE_CLASS(CSDLDocument)  : public CEikDocument

    {

    public:

        CSDLDocument(CEikApplication& aApp);

     private:

     	CEikAppUi* CreateAppUiL();

     };

 ////////////////////////////////////////////////////////////////////

NONSHARABLE_CLASS(MExitWait)

 	{

 	public:

 		virtual void DoExit(TInt aErr) = 0;

 	};   

///////////////////////////////////////////////////////////////////////// 

NONSHARABLE_CLASS(CExitWait) : public CActive

 	{

 	public:

 		CExitWait(MExitWait& aWait);

 		~CExitWait();

 	private:

 		void RunL();

 		void DoCancel();

 	private:

 		MExitWait& iWait;

 		TRequestStatus* iStatusPtr;

 	};

//////////////////////////////////////////////////////////////////////// 

NONSHARABLE_CLASS(CSDLWin) : public CCoeControl

	{

	public:

		void ConstructL(const TRect& aRect);

		RWindow& GetWindow() const;

		void SetNoDraw();

	private:

		void Draw(const TRect& aRect) const;

	private:

		TBool iNoDraw;

	}; 	

////////////////////////////////////////////////////////////////////////////	

NONSHARABLE_CLASS(CSDLAppUi) : public CAknAppUi, public MExitWait, MSDLObserver

	{

	public:

		~CSDLAppUi();

   	private: // New functions

 		void ConstructL(); 

   	void HandleCommandL(TInt aCommand);

 		void HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination);

 		void HandleResourceChangeL(TInt aType);

   		void DoExit(TInt aErr);

   		TInt SdlEvent(TInt aEvent, TInt aParam);

    	TInt SdlThreadEvent(TInt aEvent, TInt aParam);

    	void StartL();

    	static TBool StartL(TAny* aThis);

    	TBool ParamEditorL(TDes& aCheat);

    	TBool ProcessCommandParametersL(CApaCommandLine &aCommandLine);

    	void PrepareToExit();

    	void HandleConsoleWindowL();

    	void HandleConsoleWindow();

    	void HandleForegroundEventL(TBool aForeground);

    	static TBool IdleRequestL(TAny* aThis);

    	TBool HandleKeyL(const TWsEvent& aEvent);

	private:

		CExitWait* iWait;

		CSDLWin* iSDLWin;

		CSDL* iSdl;

		CIdle* iStarter;

		TBool iExitRequest;

		CDesC8Array* iParams;

		TInt iResOffset;

		CIdle* iIdle;

		TInt iStdOut;

		TVirtualCursor iCursor;

		CFbsBitmap*	iCBmp;

		CFbsBitmap*	iAlpha;

	//	TTime iLastPress;

	//	CSDL::TOrientationMode iOrientation;

	};

////////////////////////////////////////////////////////////////////////////////////////7

CApaDocument* CSDLApplication::CreateDocumentL()

	{

	return new (ELeave) CSDLDocument(*this);

	}

TUid CSDLApplication::AppDllUid() const

	{

	return iUid;

	}

CSDLApplication::CSDLApplication()

	{

	TRAPD(err, FindMeL());

	ASSERT(err == KErrNone);

	}	

void CSDLApplication::FindMeL()

	{

	RApaLsSession apa;

	User::LeaveIfError(apa.Connect());

	CleanupClosePushL(apa);

	User::LeaveIfError(apa.GetAllApps());

	TFileName name = RProcess().FileName();

	TApaAppInfo info;

	while(apa.GetNextApp(info) == KErrNone)

		{

		if(info.iFullName.CompareF(name) == 0)

			{

			iUid = info.iUid;

			break;

			}

		}

	CleanupStack::PopAndDestroy();

	}

TFileName CSDLApplication::ResourceFileName() const

	{

	return KNullDesC();

	}

///////////////////////////////////////////////////////////////////////////////////////////

CExitWait::CExitWait(MExitWait& aWait) : CActive(CActive::EPriorityStandard), iWait(aWait)

	{

	CActiveScheduler::Add(this);

	SetActive();

	iStatusPtr = &iStatus;

	}

CExitWait::~CExitWait()

	{

	Cancel();

	}

void CExitWait::RunL()

	{

	if(iStatusPtr != NULL )

		iWait.DoExit(iStatus.Int());

	}

void CExitWait::DoCancel()

	{

	if(iStatusPtr != NULL )

		User::RequestComplete(iStatusPtr , KErrCancel);

	}

//////////////////////////////////////////////////////////////////////////////////////////////

CSDLDocument::CSDLDocument(CEikApplication& aApp) : CEikDocument(aApp)

	{}

CEikAppUi* CSDLDocument::CreateAppUiL()

	{

	return new (ELeave) CSDLAppUi;

	}

///////////////////////////////////////////////////////////////////////////	

void CSDLWin:: ConstructL(const TRect& aRect)	

	{

	CreateWindowL();

	SetRect(aRect);

	ActivateL();

	}

RWindow& CSDLWin::GetWindow() const

	{

	return Window();

	}

void CSDLWin::Draw(const TRect& /*aRect*/) const

	{

	if(!iNoDraw)

		{

		CWindowGc& gc = SystemGc();

		gc.SetPenStyle(CGraphicsContext::ESolidPen);

		gc.SetPenColor(KRgbGray);

		gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

		gc.SetBrushColor(0xaaaaaa);

		gc.DrawRect(Rect());

		}

	}	

void CSDLWin::SetNoDraw()

	{

	iNoDraw = ETrue;

	}

/////////////////////////////////////////////////////////////////////////			

CSDLAppUi::~CSDLAppUi()

	{

	if(iIdle)

		iIdle->Cancel();

	delete iIdle;

	if(iStarter != NULL)

		iStarter->Cancel();

	delete iStarter;

	delete iWait;

	delete iSdl;

	delete iSDLWin;

	delete iParams;

	delete iCBmp;

	delete iAlpha;

	}

void CSDLAppUi::ConstructL()

 	{

 	BaseConstructL(ENoAppResourceFile | ENoScreenFurniture);

 	RLibrary lib;

 	User::LeaveIfError(lib.Load(_L("sdlexe.dll")));

 	TFileName name = lib.FileName();

 	lib.Close();

 	name.Replace(3, name.Length() - 3, _L("resource\\apps\\sdlexe.rsc"));

 	BaflUtils::NearestLanguageFile(iEikonEnv->FsSession(), name);

 	iResOffset = iCoeEnv->AddResourceFileL(name);

 	name.Replace(name.Length() - 3, 3, _L("mbm"));

	TEntry e;

	const TInt err = iEikonEnv->FsSession().Entry(name, e);

	iCBmp = iEikonEnv->CreateBitmapL(name, 0);

	iAlpha = iEikonEnv->CreateBitmapL(name, 1);	

 	iIdle = CIdle::NewL(CActive::EPriorityIdle);

 	iSDLWin = new (ELeave) CSDLWin;

 	iSDLWin->ConstructL(ApplicationRect());

 	iSdl = CSDL::NewL(gSDLClass.SdlFlags());

 	gSDLClass.SendEvent(MSDLMainObs::ESDLCreated, 0, iSdl);

 	iSdl->SetObserver(this);

 	iSdl->DisableKeyBlocking(*this);

 	iSdl->SetContainerWindowL(

 					iSDLWin->GetWindow(), 

        			iEikonEnv->WsSession(),

        			*iEikonEnv->ScreenDevice());

    iSdl->AppendOverlay(iCursor, 0);

    iCursor.Set(TRect(TPoint(0, 0), iSDLWin->Size()), iCBmp, iAlpha);

    iStarter = CIdle::NewL(CActive::EPriorityLow);