[sdl_omap.git] / src / main / symbian / EKA2 / sdlexe.cpp

//  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);   
    iStarter->Start(TCallBack(StartL, this));
    
    
 	}
 	

TBool CSDLAppUi::StartL(TAny* aThis)
	{
	static_cast<CSDLAppUi*>(aThis)->StartL();
	return EFalse;
	}
	
	
void CSDLAppUi::PrepareToExit()
	{
	CAknAppUiBase::PrepareToExit(); //aknappu::PrepareToExit crashes
	iCoeEnv->DeleteResourceFile(iResOffset);
	}
	
TBool CSDLAppUi::ProcessCommandParametersL(CApaCommandLine &aCommandLine)
	{
	const TPtrC8 cmdLine = aCommandLine.TailEnd();
	iParams = new (ELeave) CDesC8ArrayFlat(8);
	MakeCCmdLineL(cmdLine, *iParams);
	return EFalse;
	}
 	
 
 TBool CSDLAppUi::ParamEditorL(TDes& aCheat)
	{
	CAknTextQueryDialog* query = CAknTextQueryDialog::NewL(aCheat);
	CleanupStack::PushL(query);
	query->SetPromptL(_L("Enter parameters"));
	CleanupStack::Pop();
	return query->ExecuteLD(R_PARAMEDITOR);
	}
 	
 void CSDLAppUi::StartL()	
 	{ 		
 	if(gSDLClass.AppFlags() & SDLEnv::EParamQuery)
 		{
 		TBuf8<256> cmd;
 		RFile file;
 		TInt err = file.Open(iEikonEnv->FsSession(), _L("sdl_param.txt"),EFileRead);
 		if(err == KErrNone)
 			{
 			file.Read(cmd);
 			file.Close();	
 			MakeCCmdLineL(cmd, *iParams);
 			}
 		if(err != KErrNone || gSDLClass.AppFlags() & (SDLEnv::EParamQueryDialog ^ SDLEnv::EParamQuery))
 			{
 			TBuf<256> buffer;
 			if(ParamEditorL(buffer))
 				{
 				cmd.Copy(buffer);
 				MakeCCmdLineL(cmd, *iParams);
 				}	
 			}
 		}
 	iWait = new (ELeave) CExitWait(*this);
 	iSdl->CallMainL(gSDLClass.Main(), &iWait->iStatus, iParams, CSDL::ENoParamFlags, 0xA000);
 	}
 	
void CSDLAppUi::HandleCommandL(TInt aCommand)
	{
	switch(aCommand)
		{
		case EAknSoftkeyBack:
 		case EAknSoftkeyExit:
		case EAknCmdExit:
		case EEikCmdExit:
			gSDLClass.AppFlags(SDLEnv::EAllowConsoleView); 
		    if(iWait == NULL || !iWait->IsActive() || iSdl == NULL)
		    	{
		    	Exit();
		    	}	
			  else if(!iExitRequest)
			  	{
			  	iExitRequest = ETrue; //trick how SDL can be closed!
			  	iSdl->Suspend();
			  	} 
			break;
		}
	}
	

TBool CSDLAppUi::HandleKeyL(const TWsEvent& aEvent)
	{
	const TInt type = aEvent.Type();
	if(!(type == EEventKey || type == EEventKeyUp || type == EEventKeyDown))
 			{
 			return ETrue;
 			}
 	const TKeyEvent& key = *aEvent.Key();
	if((key.iScanCode == EStdKeyYes) && (gSDLClass.AppFlags() & SDLEnv::EVirtualMouse))
 		{
 		if(type == EEventKeyUp)
 			{
 			iCursor.Toggle();
 			iSdl->RedrawRequest();	
 			}
 		return EFalse;
		}
	if(iCursor.IsOn())
		{
		switch(key.iScanCode)
			{
			case EStdKeyUpArrow:
				iCursor.Move(0, -1);
				break;
			case EStdKeyDownArrow:
				iCursor.Move(0, 1);
				break;
			case EStdKeyLeftArrow:
				iCursor.Move(-1, 0);
				break;
			case EStdKeyRightArrow:
				iCursor.Move(1, 0);
				break; 
			case EStdKeyDevice3:
				if(type == EEventKeyUp)
					{
					TWsEvent event;
					iCursor.MakeEvent(event, iSDLWin->Position());
					iSdl->AppendWsEvent(event);
					}
				return EFalse;
			default:
				return ETrue;
			}
		iSdl->RedrawRequest();	
		return EFalse;
		}
	return ETrue;
	}
 		
 void CSDLAppUi::HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination)
 	{
 	if(iSdl && iWait && HandleKeyL(aEvent))
 		iSdl->AppendWsEvent(aEvent);
 	CAknAppUi::HandleWsEventL(aEvent, aDestination);
 	}
 	
 void CSDLAppUi::HandleResourceChangeL(TInt aType)
 	{
    CAknAppUi::HandleResourceChangeL(aType);
    if(aType == KEikDynamicLayoutVariantSwitch)
        {  	
        iSDLWin->SetRect(ApplicationRect());
      	iSdl->SetContainerWindowL(
      				iSDLWin->GetWindow(),
        			iEikonEnv->WsSession(),
        			*iEikonEnv->ScreenDevice());
        }
 	}
 	
 	
void CSDLAppUi::DoExit(TInt/*Err*/)
   	{
   	iExitRequest = ETrue;
   	Exit();
   	}

    
 TInt CSDLAppUi::SdlThreadEvent(TInt aEvent, TInt /*aParam*/)    
	{
	switch(aEvent)
		{
		case MSDLObserver::EEventResume:
			break;
		case MSDLObserver::EEventSuspend:
			if(iExitRequest)
				return MSDLObserver::ESuspendNoSuspend;
			break;
		case MSDLObserver::EEventWindowReserved:
			break;
		case MSDLObserver::EEventWindowNotAvailable:
			break;
		case MSDLObserver::EEventScreenSizeChanged:
            break;
		}
	return MSDLObserver::EParameterNone;	
	}
	    
TInt CSDLAppUi::SdlEvent(TInt aEvent, TInt /*aParam*/)    
	{
	switch(aEvent)
		{
		case MSDLObserver::EEventResume:
			break;
		case MSDLObserver::EEventSuspend:
			if(iExitRequest)
				return MSDLObserver::ESuspendNoSuspend;
			break;
		case MSDLObserver::EEventWindowReserved:
			break;
		case MSDLObserver::EEventWindowNotAvailable:
			{
			TRAP_IGNORE(HandleConsoleWindowL());
			}
			break;
		case MSDLObserver::EEventScreenSizeChanged:
     		break;
		case MSDLObserver::EEventKeyMapInit:
			break;
		case MSDLObserver::EEventMainExit:
			if(iStdOut != 0)
				{
				gSDLClass.AppFlags(SDLEnv::EAllowConsoleView); 
				iEikonEnv->WsSession().SetWindowGroupOrdinalPosition(iStdOut, 0);
				}
			break;
		}
	return MSDLObserver::EParameterNone;
	}
	
void CSDLAppUi::HandleForegroundEventL(TBool aForeground)
	{
	CAknAppUi::HandleForegroundEventL(aForeground);	
	if(!aForeground)
		HandleConsoleWindow();
	}
	
void CSDLAppUi::HandleConsoleWindow()
	{
	if(!iIdle->IsActive())
		iIdle->Start(TCallBack(IdleRequestL, this));
	}
	
TBool CSDLAppUi::IdleRequestL(TAny* aThis)
	{
	static_cast<CSDLAppUi*>(aThis)->HandleConsoleWindowL();
	return EFalse;
	}

void CSDLAppUi::HandleConsoleWindowL()
	{
	if(gSDLClass.AppFlags() & SDLEnv::EAllowConsoleView)
		{
		return;
		}
	RWsSession& ses = iEikonEnv->WsSession();
	const TInt focus = ses.GetFocusWindowGroup();
	CApaWindowGroupName* name = CApaWindowGroupName::NewLC(ses, focus);
	const TPtrC caption = name->Caption();
	if(0 == caption.CompareF(_L("STDOUT")))
		{
		iStdOut = focus;
		ses.SetWindowGroupOrdinalPosition(iEikonEnv->RootWin().Identifier(), 0);
		}
	CleanupStack::PopAndDestroy(); //name
	}
	
	
////////////////////////////////////////////////////////////////////////


CApaApplication* NewApplication()
    {
    return new CSDLApplication();
    }

	
EXPORT_C TInt SDLEnv::SetMain(const TMainFunc& aFunc, TInt aSdlFlags, MSDLMainObs* aObs, TInt aSdlExeFlags)
	{
	gSDLClass.SetMain(aFunc, aSdlFlags, aObs, aSdlExeFlags);
  	return EikStart::RunApplication(NewApplication);
	}	
	
//////////////////////////////////////////////////////////////////////

TInt SDLUiPrint(const TDesC8& /*aInfo*/)
    {
    return KErrNotFound;
    }
Commit	Line	Data
e14743d1	1	// INCLUDES
	2	#include <aknapp.h>
	3	#include <aknappui.h>
	4	#include <eikdoc.h>
	5	#include <sdlepocapi.h>
	6	#include <bautils.h>
	7	#include <eikstart.h>
	8	#include <badesca.h>
	9	#include <bautils.h>
	10	#include <apgcli.h>
	11	#include <sdlmain.h>
	12	#include <eikedwin.h>
	13	#include <eiklabel.h>
	14	#include <sdlexe.rsg>
	15	#include <aknglobalmsgquery.h>
	16	#include <apgwgnam.h>
	17
	18
	19
	20	// FORWARD DECLARATIONS
	21	class CApaDocument;
	22
	23
	24	//const TUid KSDLUID = { 0xF01F605E };
	25
	26	LOCAL_C void MakeCCmdLineL(const TDesC8& aParam, CDesC8Array& aArray)
	27	{
	28
	29	const TChar dq('\"');
	30
	31	TLex8 lex(aParam);
	32	TBool in = EFalse;
	33
	34	lex.SkipSpaceAndMark();
	35
	36	while(!lex.Eos())
	37	{
	38	TPtrC8 ptr;
	39	if(in)
	40	{
	41	const TPtrC8 rem = lex.RemainderFromMark();
	42	const TInt pos = rem.Locate(dq);
	43	if(pos > 0)
	44	{
	45	lex.Inc(pos);
	46	ptr.Set(lex.MarkedToken());
	47	lex.SkipAndMark(1);
	48	}
	49	else
	50	{
	51	ptr.Set(rem);
	52	}
	53	in = EFalse;
	54	}
	55	else
	56	{
	57	ptr.Set(lex.NextToken());
	58	const TInt pos = ptr.Locate(dq);
	59	if(pos == 0)
	60	{
	61	lex.UnGetToMark();
	62	lex.SkipAndMark(1);
	63	in = ETrue;
	64	continue; // back to in brace
65	}
66	else
67	lex.SkipSpaceAndMark();
68	}
69
70	aArray.AppendL(ptr);
71
72	}
73	}
74
75	NONSHARABLE_CLASS(TVirtualCursor) : public MOverlay
76	{
77	public:
78	TVirtualCursor();
79	void Set(const TRect& aRect, CFbsBitmap* aBmp, CFbsBitmap* aAlpha);
80	void Move(TInt aX, TInt aY);
81	void MakeEvent(TWsEvent& aEvent, const TPoint& aBasePos) const;
82	void Toggle();
83	TBool IsOn() const;
84	private:
85	void Draw(CBitmapContext& aGc, const TRect& aTargetRect, const TSize& aSize);
86	private:
87	TRect iRect;
88	TPoint iInc;
89	TPoint iPos;
90	TBool iIsOn;
91	CFbsBitmap* iCBmp;
92	CFbsBitmap* iAlpha;
93	};
94
95
96	TVirtualCursor::TVirtualCursor() : iInc(0, 0), iIsOn(EFalse), iCBmp(NULL)
97	{
98	}
99
100	const TInt KMaxMove = 10;
101
102	void TVirtualCursor::Move(TInt aX, TInt aY)
103	{
104	if(aX > 0 && iInc.iX > 0)
105	++iInc.iX;
106	else if(aX < 0 && iInc.iX < 0)
107	--iInc.iX;
108	else
109	iInc.iX = aX;
110
111	if(aY > 0 && iInc.iY > 0)
112	++iInc.iY;
113	else if(aY < 0 && iInc.iY < 0)
114	--iInc.iY;
115	else
116	iInc.iY = aY;
117
118	iInc.iX = Min(KMaxMove, iInc.iX);
119
120	iInc.iX = Max(-KMaxMove, iInc.iX);
121
122	iInc.iY = Min(KMaxMove, iInc.iY);
123
124	iInc.iY =Max(-KMaxMove, iInc.iY);
125
126	const TPoint pos = iPos + iInc;
127	if(iRect.Contains(pos))
128	{
129	iPos = pos;
130	}
131	else
132	{
133	iInc = TPoint(0, 0);
134	}
135	}
136
137
138	void TVirtualCursor::Toggle()
139	{
140	iIsOn = !iIsOn;
141	}
142
143
144	TBool TVirtualCursor::IsOn() const
145	{
146	return iIsOn;
147	}
148
149	void TVirtualCursor::Set(const TRect& aRect, CFbsBitmap* aBmp, CFbsBitmap* aAlpha)
150	{
151	iRect = aRect;
152	iCBmp = aBmp;
153	iAlpha = aAlpha;
154	}
155
156
157	void TVirtualCursor::MakeEvent(TWsEvent& aEvent, const TPoint& aBasePos) const
158	{
159	aEvent.SetType(EEventPointer),
160	aEvent.SetTimeNow();
161	TPointerEvent& pointer = *aEvent.Pointer();
162	pointer.iType = TPointerEvent::EButton1Down;
163	pointer.iPosition = iPos;
164	pointer.iParentPosition = aBasePos;
165	}
166
167
168	void TVirtualCursor::Draw(CBitmapContext& aGc, const TRect& /aTargetRect/, const TSize& /aSize/)
169	{
170	if(iIsOn && iCBmp != NULL)
171	{
172	const TRect rect(TPoint(0, 0), iCBmp->SizeInPixels());
173	aGc.AlphaBlendBitmaps(iPos, iCBmp, rect, iAlpha, TPoint(0, 0));
174	}
175
176	}
177
178	NONSHARABLE_CLASS(TSdlClass)
179	{
180	public:
181	TSdlClass();
182	void SetMain(const TMainFunc& aFunc, TInt aFlags, MSDLMainObs* aObs, TInt aExeFlags);
183	TInt SdlFlags() const;
184	const TMainFunc& Main() const;
185	void SendEvent(TInt aEvent, TInt aParam, CSDL* aSDL);
186	TInt AppFlags() const;
187	void AppFlags(TInt aFlags);
188	private:
189	TMainFunc iFunc;
190	TInt iSdlFlags;
191	TInt iExeFlags;
192	MSDLMainObs* iObs;
193	};
194
195
196	void TSdlClass::AppFlags(TInt aFlags)
197	{
198	iExeFlags \|= aFlags;
199	}
200
201	void TSdlClass::SendEvent(TInt aEvent, TInt aParam, CSDL* aSDL)
202	{
203	if(iObs != NULL)
204	iObs->SDLMainEvent(aEvent, aParam, aSDL);
205	}
206
207	TInt TSdlClass::AppFlags() const
208	{
209	return iExeFlags;
210	}
211
212	void TSdlClass::SetMain(const TMainFunc& aFunc, TInt aFlags, MSDLMainObs* aObs, TInt aExeFlags)
213	{
214	iFunc = aFunc;
215	iSdlFlags = aFlags;
216	iExeFlags = aExeFlags;
217	iObs = aObs;
218	}
219
220	const TMainFunc& TSdlClass::Main() const
221	{
222	return iFunc;
223	}
224
225
226	TInt TSdlClass::SdlFlags() const
227	{
228	return iSdlFlags;
229	}
230
231
232
233	TSdlClass::TSdlClass()
234	{
235	Mem::FillZ(this, sizeof(this));
236	}
237
238	TSdlClass gSDLClass;
239
240
241	////////////////////////////////////////////////////////////////
242
243	NONSHARABLE_CLASS(CSDLApplication) : public CAknApplication
244	{
245	public:
246	CSDLApplication();
247	private:
248	CApaDocument* CreateDocumentL();
249	TFileName ResourceFileName() const;
250	TUid AppDllUid() const;
251	void FindMeL();
252	TUid iUid;
253	};
254
255	NONSHARABLE_CLASS(CSDLDocument) : public CEikDocument
256	{
257	public:
258	CSDLDocument(CEikApplication& aApp);
259	private:
260	CEikAppUi* CreateAppUiL();
261
262	};
263
264	////////////////////////////////////////////////////////////////////
265
266
267	NONSHARABLE_CLASS(MExitWait)
268	{
269	public:
270	virtual void DoExit(TInt aErr) = 0;
271	};
272
273	/////////////////////////////////////////////////////////////////////////
274
275	NONSHARABLE_CLASS(CExitWait) : public CActive
276	{
277	public:
278	CExitWait(MExitWait& aWait);
279	~CExitWait();
280	private:
281	void RunL();
282	void DoCancel();
283	private:
284	MExitWait& iWait;
285	TRequestStatus* iStatusPtr;
286	};
287
288	////////////////////////////////////////////////////////////////////////
289
290
291	NONSHARABLE_CLASS(CSDLWin) : public CCoeControl
292	{
293	public:
294	void ConstructL(const TRect& aRect);
295	RWindow& GetWindow() const;
296	void SetNoDraw();
297	private:
298	void Draw(const TRect& aRect) const;
299	private:
300	TBool iNoDraw;
301	};
302
303
304	////////////////////////////////////////////////////////////////////////////
305
306	NONSHARABLE_CLASS(CSDLAppUi) : public CAknAppUi, public MExitWait, MSDLObserver
307	{
308	public:
309	~CSDLAppUi();
310	private: // New functions
311	void ConstructL();
312	void HandleCommandL(TInt aCommand);
313	void HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination);
314	void HandleResourceChangeL(TInt aType);
315
316	void DoExit(TInt aErr);
317
318	TInt SdlEvent(TInt aEvent, TInt aParam);
319	TInt SdlThreadEvent(TInt aEvent, TInt aParam);
320
321	void StartL();
322	static TBool StartL(TAny* aThis);
323
324	TBool ParamEditorL(TDes& aCheat);
325
326	TBool ProcessCommandParametersL(CApaCommandLine &aCommandLine);
327
328	void PrepareToExit();
329	void HandleConsoleWindowL();
330	void HandleConsoleWindow();
331	void HandleForegroundEventL(TBool aForeground);
332
333	static TBool IdleRequestL(TAny* aThis);
334
335	TBool HandleKeyL(const TWsEvent& aEvent);
336
337
338	private:
339	CExitWait* iWait;
340	CSDLWin* iSDLWin;
341	CSDL* iSdl;
342	CIdle* iStarter;
343	TBool iExitRequest;
344	CDesC8Array* iParams;
345	TInt iResOffset;
346	CIdle* iIdle;
347	TInt iStdOut;
348	TVirtualCursor iCursor;
349	CFbsBitmap* iCBmp;
350	CFbsBitmap* iAlpha;
351	// TTime iLastPress;
352	// CSDL::TOrientationMode iOrientation;
353	};
354
355	////////////////////////////////////////////////////////////////////////////////////////7
356
357	CApaDocument* CSDLApplication::CreateDocumentL()
358	{
359	return new (ELeave) CSDLDocument(*this);
360	}
361
362	TUid CSDLApplication::AppDllUid() const
363	{
364	return iUid;
365	}
366
367
368	CSDLApplication::CSDLApplication()
369	{
370	TRAPD(err, FindMeL());
371	ASSERT(err == KErrNone);
372	}
373
374	void CSDLApplication::FindMeL()
375	{
376	RApaLsSession apa;
377	User::LeaveIfError(apa.Connect());
378	CleanupClosePushL(apa);
379	User::LeaveIfError(apa.GetAllApps());
380	TFileName name = RProcess().FileName();
381	TApaAppInfo info;
382	while(apa.GetNextApp(info) == KErrNone)
383	{
384	if(info.iFullName.CompareF(name) == 0)
385	{
386	iUid = info.iUid;
387	break;
388	}
389	}
390	CleanupStack::PopAndDestroy();
391	}
392
393	TFileName CSDLApplication::ResourceFileName() const
394	{
395	return KNullDesC();
396	}
397
398	///////////////////////////////////////////////////////////////////////////////////////////
399
400	CExitWait::CExitWait(MExitWait& aWait) : CActive(CActive::EPriorityStandard), iWait(aWait)
401	{
402	CActiveScheduler::Add(this);
403	SetActive();
404	iStatusPtr = &iStatus;
405	}
406
407	CExitWait::~CExitWait()
408	{
409	Cancel();
410	}
411
412	void CExitWait::RunL()
413	{
414	if(iStatusPtr != NULL )
415	iWait.DoExit(iStatus.Int());
416	}
417
418	void CExitWait::DoCancel()
419	{
420	if(iStatusPtr != NULL )
421	User::RequestComplete(iStatusPtr , KErrCancel);
422	}
423
424
425	//////////////////////////////////////////////////////////////////////////////////////////////
426
427	CSDLDocument::CSDLDocument(CEikApplication& aApp) : CEikDocument(aApp)
428	{}
429
430	CEikAppUi* CSDLDocument::CreateAppUiL()
431	{
432	return new (ELeave) CSDLAppUi;
433	}
434
435	///////////////////////////////////////////////////////////////////////////
436
437	void CSDLWin:: ConstructL(const TRect& aRect)
438	{
439	CreateWindowL();
440	SetRect(aRect);
441	ActivateL();
442	}
443
444
445	RWindow& CSDLWin::GetWindow() const
446	{
447	return Window();
448	}
449
450
451	void CSDLWin::Draw(const TRect& /aRect/) const
452	{
453	if(!iNoDraw)
454	{
455	CWindowGc& gc = SystemGc();
456	gc.SetPenStyle(CGraphicsContext::ESolidPen);
457	gc.SetPenColor(KRgbGray);
458	gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
459	gc.SetBrushColor(0xaaaaaa);
460	gc.DrawRect(Rect());
461	}
462	}
463
464	void CSDLWin::SetNoDraw()
465	{
466	iNoDraw = ETrue;
467	}
468
469	/////////////////////////////////////////////////////////////////////////
470
471	CSDLAppUi::~CSDLAppUi()
472	{
473	if(iIdle)
474	iIdle->Cancel();
475	delete iIdle;
476	if(iStarter != NULL)
477	iStarter->Cancel();
478	delete iStarter;
479	delete iWait;
480	delete iSdl;
481	delete iSDLWin;
482	delete iParams;
483	delete iCBmp;
484	delete iAlpha;
485	}
486
487
488	void CSDLAppUi::ConstructL()
489	{
490	BaseConstructL(ENoAppResourceFile \| ENoScreenFurniture);
491
492
493	RLibrary lib;
494	User::LeaveIfError(lib.Load(_L("sdlexe.dll")));
495	TFileName name = lib.FileName();
496	lib.Close();
497	name.Replace(3, name.Length() - 3, _L("resource\\apps\\sdlexe.rsc"));
498	BaflUtils::NearestLanguageFile(iEikonEnv->FsSession(), name);
499	iResOffset = iCoeEnv->AddResourceFileL(name);
500
501	name.Replace(name.Length() - 3, 3, _L("mbm"));
502
503	TEntry e;
504	const TInt err = iEikonEnv->FsSession().Entry(name, e);
505
506	iCBmp = iEikonEnv->CreateBitmapL(name, 0);
507	iAlpha = iEikonEnv->CreateBitmapL(name, 1);
508
509	iIdle = CIdle::NewL(CActive::EPriorityIdle);
510
511	iSDLWin = new (ELeave) CSDLWin;
512	iSDLWin->ConstructL(ApplicationRect());
513
514	iSdl = CSDL::NewL(gSDLClass.SdlFlags());
515
516	gSDLClass.SendEvent(MSDLMainObs::ESDLCreated, 0, iSdl);
517
518	iSdl->SetObserver(this);
519	iSdl->DisableKeyBlocking(*this);
520	iSdl->SetContainerWindowL(
521	iSDLWin->GetWindow(),
522	iEikonEnv->WsSession(),
523	*iEikonEnv->ScreenDevice());
524	iSdl->AppendOverlay(iCursor, 0);
525
526	iCursor.Set(TRect(TPoint(0, 0), iSDLWin->Size()), iCBmp, iAlpha);
527
528	iStarter = CIdle::NewL(CActive::EPriorityLow);
529	iStarter->Start(TCallBack(StartL, this));
530
531
532	}
533
534
535
536	TBool CSDLAppUi::StartL(TAny* aThis)
537	{
538	static_cast<CSDLAppUi*>(aThis)->StartL();
539	return EFalse;
540	}
541
542
543	void CSDLAppUi::PrepareToExit()
544	{
545	CAknAppUiBase::PrepareToExit(); //aknappu::PrepareToExit crashes
546	iCoeEnv->DeleteResourceFile(iResOffset);
547	}
548
549	TBool CSDLAppUi::ProcessCommandParametersL(CApaCommandLine &aCommandLine)
550	{
551	const TPtrC8 cmdLine = aCommandLine.TailEnd();
552	iParams = new (ELeave) CDesC8ArrayFlat(8);
553	MakeCCmdLineL(cmdLine, *iParams);
554	return EFalse;
555	}
556
557
558	TBool CSDLAppUi::ParamEditorL(TDes& aCheat)
559	{
560	CAknTextQueryDialog* query = CAknTextQueryDialog::NewL(aCheat);
561	CleanupStack::PushL(query);
562	query->SetPromptL(_L("Enter parameters"));
563	CleanupStack::Pop();
564	return query->ExecuteLD(R_PARAMEDITOR);
565	}
566
567	void CSDLAppUi::StartL()
568	{
569	if(gSDLClass.AppFlags() & SDLEnv::EParamQuery)
570	{
571	TBuf8<256> cmd;
572	RFile file;
573	TInt err = file.Open(iEikonEnv->FsSession(), _L("sdl_param.txt"),EFileRead);
574	if(err == KErrNone)
575	{
576	file.Read(cmd);
577	file.Close();
578	MakeCCmdLineL(cmd, *iParams);
579	}
580	if(err != KErrNone \|\| gSDLClass.AppFlags() & (SDLEnv::EParamQueryDialog ^ SDLEnv::EParamQuery))
581	{
582	TBuf<256> buffer;
583	if(ParamEditorL(buffer))
584	{
585	cmd.Copy(buffer);
586	MakeCCmdLineL(cmd, *iParams);
587	}
588	}
589	}
590	iWait = new (ELeave) CExitWait(*this);
591	iSdl->CallMainL(gSDLClass.Main(), &iWait->iStatus, iParams, CSDL::ENoParamFlags, 0xA000);
592	}
593
594	void CSDLAppUi::HandleCommandL(TInt aCommand)
595	{
596	switch(aCommand)
597	{
598	case EAknSoftkeyBack:
599	case EAknSoftkeyExit:
600	case EAknCmdExit:
601	case EEikCmdExit:
602	gSDLClass.AppFlags(SDLEnv::EAllowConsoleView);
603	if(iWait == NULL \|\| !iWait->IsActive() \|\| iSdl == NULL)
604	{
605	Exit();
606	}
607	else if(!iExitRequest)
608	{
609	iExitRequest = ETrue; //trick how SDL can be closed!
610	iSdl->Suspend();
611	}
612	break;
613	}
614	}
615
616
617
618	TBool CSDLAppUi::HandleKeyL(const TWsEvent& aEvent)
619	{
620	const TInt type = aEvent.Type();
621	if(!(type == EEventKey \|\| type == EEventKeyUp \|\| type == EEventKeyDown))
622	{
623	return ETrue;
624	}
625	const TKeyEvent& key = *aEvent.Key();
626	if((key.iScanCode == EStdKeyYes) && (gSDLClass.AppFlags() & SDLEnv::EVirtualMouse))
627	{
628	if(type == EEventKeyUp)
629	{
630	iCursor.Toggle();
631	iSdl->RedrawRequest();
632	}
633	return EFalse;
634	}
635	if(iCursor.IsOn())
636	{
637	switch(key.iScanCode)
638	{
639	case EStdKeyUpArrow:
640	iCursor.Move(0, -1);
641	break;
642	case EStdKeyDownArrow:
643	iCursor.Move(0, 1);
644	break;
645	case EStdKeyLeftArrow:
646	iCursor.Move(-1, 0);
647	break;
648	case EStdKeyRightArrow:
649	iCursor.Move(1, 0);
650	break;
651	case EStdKeyDevice3:
652	if(type == EEventKeyUp)
653	{
654	TWsEvent event;
655	iCursor.MakeEvent(event, iSDLWin->Position());
656	iSdl->AppendWsEvent(event);
657	}
658	return EFalse;
659	default:
660	return ETrue;
661	}
662	iSdl->RedrawRequest();
663	return EFalse;
664	}
665	return ETrue;
666	}
667
668	void CSDLAppUi::HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination)
669	{
670	if(iSdl && iWait && HandleKeyL(aEvent))
671	iSdl->AppendWsEvent(aEvent);
672	CAknAppUi::HandleWsEventL(aEvent, aDestination);
673	}
674
675	void CSDLAppUi::HandleResourceChangeL(TInt aType)
676	{
677	CAknAppUi::HandleResourceChangeL(aType);
678	if(aType == KEikDynamicLayoutVariantSwitch)
679	{
680	iSDLWin->SetRect(ApplicationRect());
681	iSdl->SetContainerWindowL(
682	iSDLWin->GetWindow(),
683	iEikonEnv->WsSession(),
684	*iEikonEnv->ScreenDevice());
685	}
686	}
687
688
689	void CSDLAppUi::DoExit(TInt/Err/)
690	{
691	iExitRequest = ETrue;
692	Exit();
693	}
694
695
696	TInt CSDLAppUi::SdlThreadEvent(TInt aEvent, TInt /aParam/)
697	{
698	switch(aEvent)
699	{
700	case MSDLObserver::EEventResume:
701	break;
702	case MSDLObserver::EEventSuspend:
703	if(iExitRequest)
704	return MSDLObserver::ESuspendNoSuspend;
705	break;
706	case MSDLObserver::EEventWindowReserved:
707	break;
708	case MSDLObserver::EEventWindowNotAvailable:
709	break;
710	case MSDLObserver::EEventScreenSizeChanged:
711	break;
712	}
713	return MSDLObserver::EParameterNone;
714	}
715
716	TInt CSDLAppUi::SdlEvent(TInt aEvent, TInt /aParam/)
717	{
718	switch(aEvent)
719	{
720	case MSDLObserver::EEventResume:
721	break;
722	case MSDLObserver::EEventSuspend:
723	if(iExitRequest)
724	return MSDLObserver::ESuspendNoSuspend;
725	break;
726	case MSDLObserver::EEventWindowReserved:
727	break;
728	case MSDLObserver::EEventWindowNotAvailable:
729	{
730	TRAP_IGNORE(HandleConsoleWindowL());
731	}
732	break;
733	case MSDLObserver::EEventScreenSizeChanged:
734	break;
735	case MSDLObserver::EEventKeyMapInit:
736	break;
737	case MSDLObserver::EEventMainExit:
738	if(iStdOut != 0)
739	{
740	gSDLClass.AppFlags(SDLEnv::EAllowConsoleView);
741	iEikonEnv->WsSession().SetWindowGroupOrdinalPosition(iStdOut, 0);
742	}
743	break;
744	}
745	return MSDLObserver::EParameterNone;
746	}
747
748	void CSDLAppUi::HandleForegroundEventL(TBool aForeground)
749	{
750	CAknAppUi::HandleForegroundEventL(aForeground);
751	if(!aForeground)
752	HandleConsoleWindow();
753	}
754
755	void CSDLAppUi::HandleConsoleWindow()
756	{
757	if(!iIdle->IsActive())
758	iIdle->Start(TCallBack(IdleRequestL, this));
759	}
760
761	TBool CSDLAppUi::IdleRequestL(TAny* aThis)
762	{
763	static_cast<CSDLAppUi*>(aThis)->HandleConsoleWindowL();
764	return EFalse;
765	}
766
767	void CSDLAppUi::HandleConsoleWindowL()
768	{
769	if(gSDLClass.AppFlags() & SDLEnv::EAllowConsoleView)
770	{
771	return;
772	}
773	RWsSession& ses = iEikonEnv->WsSession();
774	const TInt focus = ses.GetFocusWindowGroup();
775	CApaWindowGroupName* name = CApaWindowGroupName::NewLC(ses, focus);
776	const TPtrC caption = name->Caption();
777	if(0 == caption.CompareF(_L("STDOUT")))
778	{
779	iStdOut = focus;
780	ses.SetWindowGroupOrdinalPosition(iEikonEnv->RootWin().Identifier(), 0);
781	}
782	CleanupStack::PopAndDestroy(); //name
783	}
784
785
786	////////////////////////////////////////////////////////////////////////
787
788
789	CApaApplication* NewApplication()
790	{
791	return new CSDLApplication();
792	}
793
794
795	EXPORT_C TInt SDLEnv::SetMain(const TMainFunc& aFunc, TInt aSdlFlags, MSDLMainObs* aObs, TInt aSdlExeFlags)
796	{
797	gSDLClass.SetMain(aFunc, aSdlFlags, aObs, aSdlExeFlags);
798	return EikStart::RunApplication(NewApplication);
799	}
800
801	//////////////////////////////////////////////////////////////////////
802
803	TInt SDLUiPrint(const TDesC8& /aInfo/)
804	{
805	return KErrNotFound;
806	}
807
808
809