1 /*

     2     SDL_Main.cpp

     3     Symbian OS services for SDL

     4 

     5     Markus Mertama

     6 */

     7 

     8 

     9 #include "epoc_sdl.h"

    10 

    11 #include"sdlepocapi.h"

    12 #include <e32base.h>

    13 #include <estlib.h>

    14 #include <stdio.h>

    15 #include <badesca.h>

    16 

    17 #include "vectorbuffer.h"

    18 #include <w32std.h>

    19 #include <aknappui.h>

    20 #include <aknapp.h>

    21 #include "SDL_epocevents_c.h"

    22 #include "SDL_keysym.h"

    23 #include "dsa.h"

    24 

    25 

    26 #ifdef SYMBIANC

    27 #include <reent.h>

    28 #endif

    29 

    30 //Markus Mertama

    31 

    32 

    33 extern SDLKey* KeyMap();

    34 extern void ResetKeyMap();

    35 

    36 class CCurrentAppUi;

    37 

    38 //const TUid KSDLUid =  { 0xF01F3D69 };

    39 

    40 NONSHARABLE_CLASS(EnvUtils)

    41 	{

    42 	public:

    43 	static void DisableKeyBlocking();

    44 	static TBool Rendezvous(RThread& aThread, TRequestStatus& aStatus);

    45 	};

    46 

    47 TInt Panic(TInt aErr, TInt aLine)

    48 	{

    49 	TBuf<64> b;

    50 	b.Format(_L("Main at %d"), aLine);

    51 	User::Panic(b, aErr);

    52 	return 0;	

    53 	}

    54 	

    55 

    56 NONSHARABLE_CLASS(CCurrentAppUi) : public CAknAppUi

    57 	{

    58 	public:

    59 	static CCurrentAppUi* Cast(CEikAppUi* aUi);

    60 	void DisableKeyBlocking();

    61 	};

    62 	

    63 	

    64 CCurrentAppUi* CCurrentAppUi::Cast(CEikAppUi* aUi)

    65 	{

    66 	return static_cast<CCurrentAppUi*>(aUi);	

    67 	}

    68 	

    69 void CCurrentAppUi::DisableKeyBlocking()	

    70 	{

    71 	SetKeyBlockMode(ENoKeyBlock);	

    72 	}

    73 

    74 

    75 class CEventQueue : public CBase, public MEventQueue

    76     {

    77     public:

    78         static CEventQueue* NewL();

    79         ~CEventQueue();

    80     public:

    81         TInt Append(const TWsEvent& aEvent);

    82        	const TWsEvent& Shift();

    83        	void Lock();

    84        	void Unlock();

    85         TBool HasData();

    86     private:

    87         TVector<TWsEvent, 64> iVector;

    88         RCriticalSection iCS;

    89     };

    90     

    91  CEventQueue* CEventQueue::NewL()

    92     {

    93     CEventQueue* q = new (ELeave) CEventQueue();

    94     CleanupStack::PushL(q);

    95     User::LeaveIfError(q->iCS.CreateLocal());

    96     CleanupStack::Pop();

    97     return q;

    98     }

    99     

   100 CEventQueue::~CEventQueue()

   101     {

   102     iCS.Close();

   103     }

   104     

   105 TInt CEventQueue::Append(const TWsEvent& aEvent)

   106     {

   107     iCS.Wait();

   108    	const TInt err = iVector.Append(aEvent);

   109     iCS.Signal();

   110     return err;

   111     }

   112     

   113     

   114 TBool CEventQueue::HasData()

   115     {

   116     return iVector.Size() > 0;

   117     }

   118 

   119 

   120 void CEventQueue::Lock()

   121 	{

   122     iCS.Wait();

   123 	}

   124 	

   125 void CEventQueue::Unlock()

   126 	{

   127 	iCS.Signal();

   128 	}

   129 

   130 const TWsEvent& CEventQueue::Shift()

   131     {

   132     const TWsEvent& event =  iVector.Shift();

   133     return event;

   134     }

   135 

   136 

   137 TSdlCleanupItem::TSdlCleanupItem(TSdlCleanupOperation aOperation, TAny* aItem) :

   138 iOperation(aOperation), iItem(aItem), iThread(RThread().Id())

   139     {

   140     }

   141 

   142 class CEikonEnv;

   143 class CSdlAppServ;

   144 

   145     

   146 NONSHARABLE_CLASS(EpocSdlEnvData)

   147     {

   148     public:

   149     void Free();

   150     CEventQueue*            iEventQueue;

   151     TMainFunc				iMain;

   152     TInt            		iEpocEnvFlags;

   153     int                     iArgc;

   154     char**                  iArgv;

   155     CDsa*                   iDsa;

   156     CSdlAppServ*            iAppSrv;

   157     TThreadId               iId;

   158     CArrayFix<TSdlCleanupItem>* iCleanupItems; 

   159     CEikAppUi*				iAppUi;

   160     CSDL*					iSdl;

   161     };

   162   

   163    

   164 EpocSdlEnvData* gEpocEnv;

   165 

   166 #define MAINFUNC(x) EXPORT_C TMainFunc::TMainFunc(mainfunc##x aFunc){Mem::FillZ(iMainFunc, sizeof(iMainFunc)); iMainFunc[x - 1] = (void*) aFunc;}

   167     

   168 MAINFUNC(1)

   169 MAINFUNC(2)

   170 MAINFUNC(3)

   171 MAINFUNC(4)

   172 MAINFUNC(5)

   173 MAINFUNC(6)

   174 

   175 EXPORT_C TMainFunc::TMainFunc() 

   176 	{

   177 	Mem::FillZ(iMainFunc, sizeof(iMainFunc));

   178 	}

   179 	

   180 

   181 const void* TMainFunc::operator[](TInt aIndex) const

   182 	{

   183 	return iMainFunc[aIndex];

   184 	}

   185 

   186 

   187 NONSHARABLE_CLASS(CSdlAppServ) : public CActive

   188     {

   189     public:

   190         enum

   191             {

   192             EAppSrvNoop = CDsa::ELastDsaRequest,

   193             EAppSrvWindowWidth,

   194             EAppSrvWindowHeight,

   195             EAppSrvWindowDisplayMode,

   196             EAppSrvWindowPointerCursorMode,

   197             EAppSrvDsaStatus,

   198             EAppSrvStopThread,

   199             EAppSrvWaitDsa

   200             };

   201         CSdlAppServ();

   202         void ConstructL();

   203         ~CSdlAppServ();

   204         TInt Request(TInt aService);

   205         TInt RequestValue(TInt aService);

   206         void Init(); 

   207         void PanicMain(TInt aReason);

   208         void PanicMain(const TDesC& aInfo, TInt aReason);

   209         void SetObserver(MSDLObserver* aObserver);

   210         TInt ObserverEvent(TInt aEvent, TInt aParam);

   211         void SetParam(TInt aParam);

   212         void HandleObserverValue(TInt aService, TInt aReturnValue, TBool aMainThread);

   213         MSDLObserver* Observer();

   214     private:

   215         void RunL();

   216         void DoCancel();

   217     private:

   218         const TThreadId iMainId;

   219         RThread iAppThread;

   220         TInt iService;

   221         TInt iReturnValue;

   222         RSemaphore iSema;

   223         MSDLObserver* iObserver;

   224         TRequestStatus* iStatusPtr;

   225     };

   226     

   227 CSdlAppServ::CSdlAppServ() : CActive(CActive::EPriorityHigh), iMainId(RThread().Id())

   228     {

   229     }

   230     

   231     

   232     

   233 MSDLObserver* CSdlAppServ::Observer()

   234 	{

   235 	return iObserver;

   236 	}

   237 	

   238 	

   239 void CSdlAppServ::SetObserver(MSDLObserver* aObserver)

   240 	{

   241 	iObserver = aObserver;

   242 	}	

   243 	

   244 TInt CSdlAppServ::ObserverEvent(TInt aEvent, TInt aParam)

   245 	{

   246 	if(iObserver != NULL)

   247 		{

   248 		if(RThread().Id() == gEpocEnv->iId)

   249 			{

   250 			return iObserver->SdlThreadEvent(aEvent, aParam);

   251 			}

   252 		else if(RThread().Id() == iMainId)

   253 			{

   254 			return iObserver->SdlEvent(aEvent, aParam);

   255 			}

   256 		PANIC(KErrNotSupported);

   257 		}

   258 	return 0;

   259 	}

   260 	

   261 void CSdlAppServ::PanicMain(TInt aReason)    

   262     {

   263     iAppThread.Panic(RThread().Name(), aReason);

   264     }

   265     

   266 void CSdlAppServ::PanicMain(const TDesC& aInfo, TInt aReason)    

   267     {

   268     iAppThread.Panic(aInfo, aReason);

   269     }    

   270     

   271 void CSdlAppServ::ConstructL()

   272     {

   273     CActiveScheduler::Add(this);

   274     User::LeaveIfError(iSema.CreateLocal(1));

   275     iStatus = KRequestPending;

   276     iStatusPtr = &iStatus;

   277     SetActive();

   278     }

   279         

   280  CSdlAppServ::~CSdlAppServ()

   281     {

   282     Cancel();

   283     if(iSema.Handle() != NULL)

   284         iSema.Signal();

   285     iSema.Close();

   286     iAppThread.Close();

   287     }

   288     

   289 TInt CSdlAppServ::Request(TInt aService)

   290     {

   291     if(RThread().Id() != iAppThread.Id())

   292     	{

   293     	iSema.Wait();

   294     	iService = aService;

   295     	iAppThread.RequestComplete(iStatusPtr, KErrNone); 

   296     	return KErrNone;

   297     	}

   298     return KErrBadHandle;

   299     }

   300     

   301 TInt CSdlAppServ::RequestValue(TInt aService)

   302     {

   303     Request(aService);

   304     Request(EAppSrvNoop);

   305     return iReturnValue;

   306     }

   307    

   308 void CSdlAppServ::Init()

   309     {

   310     PANIC_IF_ERROR(iAppThread.Open(iMainId));

   311     }

   312 

   313 void CSdlAppServ::SetParam(TInt aParam)

   314 	{

   315 	iReturnValue = aParam;

   316 	}

   317 	

   318 void CSdlAppServ::HandleObserverValue(TInt aService, TInt aReturnValue, TBool aMainThread)

   319 	{

   320 	if(iObserver != NULL && aMainThread)

   321 		{

   322 		switch(aService)

   323 			{

   324 			case MSDLObserver::EEventScreenSizeChanged:

   325 			if(aReturnValue == MSDLObserver::EScreenSizeChangedDefaultPalette)

   326 				EpocSdlEnv::LockPalette(EFalse);

   327 			break;

   328 			}

   329 		}

   330 	if(!aMainThread && aService == MSDLObserver::EEventSuspend)

   331 		{

   332 		if(iObserver == NULL || 

   333 		(gEpocEnv->iDsa->Stopped() && aReturnValue != MSDLObserver::ESuspendNoSuspend))

   334 			{

   335 			EpocSdlEnv::Suspend();

   336 			}

   337 		}

   338 	}

   339 

   340 void CSdlAppServ::RunL()

   341     {

   342     if(iStatus == KErrNone)

   343         {

   344         switch(iService)

   345             {

   346             case CSdlAppServ::EAppSrvWaitDsa:

   347             	EpocSdlEnv::SetWaitDsa();

   348             	iReturnValue = EpocSdlEnv::IsDsaAvailable();

   349             //		}

   350             //	gEpocEnv->iDsa->Stop();

   351             //	gEpocEnv->iDsa->RestartL();

   352             	break;

   353            	 case CSdlAppServ::EAppSrvStopThread:

   354             	gEpocEnv->iDsa->SetSuspend();

   355             	break;

   356             case EpocSdlEnv::EDisableKeyBlocking:

   357                 EnvUtils::DisableKeyBlocking();

   358                 break;

   359           

   360             case EAppSrvWindowPointerCursorMode:

   361                 iReturnValue = gEpocEnv->iDsa != NULL ?

   362                  gEpocEnv->iDsa->Session().PointerCursorMode() : KErrNotReady; 

   363                 break;

   364             case EAppSrvDsaStatus:

   365             	gEpocEnv->iDsa->Stop();

   366                 iReturnValue = KErrNone;

   367                 break;

   368             case CDsa::ERequestUpdate:

   369             	gEpocEnv->iDsa->UnlockHWSurfaceRequestComplete();

   370             	break;

   371             case EAppSrvNoop:

   372                 break;

   373             case MSDLObserver::EEventResume:

   374             case MSDLObserver::EEventSuspend:

   375             case MSDLObserver::EEventScreenSizeChanged:

   376             case MSDLObserver::EEventWindowReserved:

   377             case MSDLObserver::EEventKeyMapInit:

   378             case MSDLObserver::EEventWindowNotAvailable:

   379             case MSDLObserver::EEventMainExit:

   380             	iReturnValue = ObserverEvent(iService, iReturnValue);

   381             	HandleObserverValue(iService, iReturnValue, ETrue);

   382             	break;

   383             default:

   384                 PANIC(KErrNotSupported);

   385             }

   386         iStatus = KRequestPending;

   387         iStatusPtr = &iStatus;

   388         SetActive();

   389         }

   390     iSema.Signal();

   391     }

   392     

   393 void CSdlAppServ::DoCancel()

   394     {

   395     iSema.Wait();

   396     TRequestStatus* s = &iStatus;

   397     iAppThread.RequestComplete(s, KErrCancel); 

   398     }

   399  

   400 

   401 

   402 MEventQueue& EpocSdlEnv::EventQueue()

   403     {

   404     __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));

   405     return *gEpocEnv->iEventQueue;

   406     }

   407 

   408 

   409 TBool EpocSdlEnv::Flags(TInt aFlag)

   410     {

   411 	const TInt flag = gEpocEnv->iEpocEnvFlags & aFlag;

   412 	return flag == aFlag;

   413     }

   414 

   415 TInt EpocSdlEnv::Argc()

   416     {

   417     __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));

   418     return gEpocEnv->iArgc;

   419     }

   420     

   421     

   422 char** EpocSdlEnv::Argv()

   423     {

   424     __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));

   425     return gEpocEnv->iArgv;

   426     }

   427     

   428     

   429 TBool EpocSdlEnv::IsDsaAvailable()

   430     {

   431     __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));

   432     return gEpocEnv->iDsa != NULL && gEpocEnv->iDsa->IsDsaAvailable();

   433     }

   434 

   435   

   436 void EpocSdlEnv::WaitDsaAvailable()

   437 	{

   438 	EpocSdlEnv::ObserverEvent(MSDLObserver::EEventWindowNotAvailable, 0);

   439 	gEpocEnv->iAppSrv->Request(CSdlAppServ::EAppSrvStopThread);

   440 	if(EpocSdlEnv::Flags(CSDL::EEnableFocusStop))

   441 		{

   442 		EpocSdlEnv::ObserverEvent(MSDLObserver::EEventSuspend, 0);

   443 		}

   444 	}

   445 	

   446 void EpocSdlEnv::Suspend()

   447 	{

   448 	if(gEpocEnv->iDsa->Stopped() || EpocSdlEnv::Flags(CSDL::EEnableFocusStop))

   449 		{

   450 	//	gEpocEnv->iDsa->ReleaseStop(); 

   451 		gEpocEnv->iDsa->SetSuspend(); 

   452 		RThread().Suspend();

   453 		EpocSdlEnv::ObserverEvent(MSDLObserver::EEventResume, 0);

   454 		}

   455 	}

   456 	

   457 void EpocSdlEnv::SetWaitDsa()

   458 	{

   459 	if(!IsDsaAvailable())

   460 		{

   461 		RThread th;

   462 		th.Open(gEpocEnv->iId);

   463 		th.Suspend();

   464 		th.Close();

   465 		gEpocEnv->iDsa->SetSuspend(); 

   466 		}

   467 	}

   468 	

   469 void EpocSdlEnv::Resume()

   470 	{

   471 	gEpocEnv->iDsa->Resume();

   472 	RThread th;

   473 	th.Open(gEpocEnv->iId);

   474 	th.Resume();

   475 	th.Close();

   476 	

   477 	const TInt value = gEpocEnv->iAppSrv->ObserverEvent(MSDLObserver::EEventResume, 0);

   478 	gEpocEnv->iAppSrv->HandleObserverValue(MSDLObserver::EEventResume, value, ETrue);

   479 	}

   480     

   481 

   482 TInt EpocSdlEnv::AllocSwSurface(const TSize& aSize, TDisplayMode aMode)

   483 	{

   484 	return gEpocEnv->iDsa->AllocSurface(EFalse, aSize, aMode);

   485 	}

   486 	

   487 TInt EpocSdlEnv::AllocHwSurface(const TSize& aSize, TDisplayMode aMode)

   488 	{

   489 	return gEpocEnv->iDsa->AllocSurface(ETrue, aSize, aMode);

   490 	}

   491 		

   492 	

   493 void EpocSdlEnv::UnlockHwSurface()

   494 	{

   495 	gEpocEnv->iDsa->UnlockHwSurface();

   496 	}

   497 	

   498 TUint8* EpocSdlEnv::LockHwSurface()

   499 	{

   500 	return gEpocEnv->iDsa->LockHwSurface();

   501 	}

   502 

   503 

   504 void EpocSdlEnv::UpdateSwSurface()

   505 	{

   506 	gEpocEnv->iDsa->UpdateSwSurface();

   507 	}

   508 	

   509 TBool EpocSdlEnv::AddUpdateRect(TUint8* aAddress, const TRect& aUpdateRect, const TRect& aRect)

   510 	{

   511 	return gEpocEnv->iDsa->AddUpdateRect(aAddress, aUpdateRect, aRect);

   512 	}

   513 	

   514 void EpocSdlEnv::Request(TInt aService)

   515     {

   516     __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));

   517     gEpocEnv->iAppSrv->Request(aService);

   518     }

   519     

   520     

   521 TSize EpocSdlEnv::WindowSize(const TSize& aRequestedSize)

   522     { 

   523     __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));

   524     if(EpocSdlEnv::Flags(CSDL::EAllowImageResize) && gEpocEnv->iDsa->WindowSize() != aRequestedSize)

   525     	{

   526     	TRAP_IGNORE(gEpocEnv->iDsa->CreateZoomerL(aRequestedSize));

   527     	}

   528     return gEpocEnv->iDsa->WindowSize();

   529     }

   530     

   531  TSize EpocSdlEnv::WindowSize()

   532     { 

   533     __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));

   534     return gEpocEnv->iDsa->WindowSize();

   535     }   

   536     

   537 TDisplayMode EpocSdlEnv::DisplayMode()

   538     {

   539     return gEpocEnv->iDsa->DisplayMode();

   540     }

   541     

   542 TPointerCursorMode EpocSdlEnv::PointerMode()

   543     {

   544     return static_cast<TPointerCursorMode>

   545     (gEpocEnv->iAppSrv->RequestValue(CSdlAppServ::EAppSrvWindowPointerCursorMode));

   546     }

   547     

   548 TInt EpocSdlEnv::SetPalette(TInt aFirstcolor, TInt aColorCount, TUint32* aPalette)  

   549 	{

   550 	return 	gEpocEnv->iDsa->SetPalette(aFirstcolor, aColorCount, aPalette);

   551 	}

   552 

   553 void EpocSdlEnv::PanicMain(TInt aErr)

   554     {

   555     gEpocEnv->iAppSrv->PanicMain(aErr);

   556     }

   557     

   558     

   559 TInt EpocSdlEnv::AppendCleanupItem(const TSdlCleanupItem& aItem)

   560     {

   561     TRAPD(err, gEpocEnv->iCleanupItems->AppendL(aItem));

   562     return err;

   563     }

   564     

   565 void EpocSdlEnv::RemoveCleanupItem(TAny* aItem)

   566     {

   567     for(TInt i = 0; i < gEpocEnv->iCleanupItems->Count(); i++)

   568         {

   569         if(gEpocEnv->iCleanupItems->At(i).iItem == aItem)

   570             gEpocEnv->iCleanupItems->Delete(i);

   571         }

   572     }

   573     

   574 void EpocSdlEnv::CleanupItems()     

   575 	{

   576 	const TThreadId id = RThread().Id();

   577 	TInt last = gEpocEnv->iCleanupItems->Count() - 1;

   578 	TInt i;

   579 	for(i = last; i >= 0 ; i--)

   580         {

   581         TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);

   582         if(item.iThread == id)

   583         	{

   584         	item.iThread = TThreadId(0); 

   585         	item.iOperation(item.iItem);

   586         	}

   587         }

   588     last = gEpocEnv->iCleanupItems->Count() - 1;

   589 	for(i = last; i >= 0 ; i--)

   590         {

   591         TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);

   592         if(item.iThread == TThreadId(0))

   593         	{

   594         	gEpocEnv->iCleanupItems->Delete(i);

   595         	}

   596         }

   597 	}

   598 	

   599 void EpocSdlEnv::FreeSurface()

   600 	{

   601 	Request(CSdlAppServ::EAppSrvDsaStatus);

   602 	gEpocEnv->iDsa->Free();

   603 	}

   604   

   605 void EpocSdlEnv::LockPalette(TBool aLock)

   606 	{

   607 	gEpocEnv->iDsa->LockPalette(aLock);

   608 	}

   609     

   610 void EpocSdlEnv::ObserverEvent(TInt aService, TInt aParam)

   611 	{

   612 	const TBool sdlThread = RThread().Id() == gEpocEnv->iId;

   613 	const TInt valuea = gEpocEnv->iAppSrv->ObserverEvent(aService, aParam);

   614 	gEpocEnv->iAppSrv->HandleObserverValue(aService, valuea, !sdlThread);

   615 	if(sdlThread)

   616 		{

   617 		gEpocEnv->iAppSrv->SetParam(aParam);

   618 		const TInt valuet = gEpocEnv->iAppSrv->RequestValue(aService);

   619 		gEpocEnv->iAppSrv->HandleObserverValue(aService, valuet, EFalse);	

   620 		}

   621 	}

   622 			

   623     

   624 TPoint EpocSdlEnv::WindowCoordinates(const TPoint& aPoint)    

   625     {

   626     return gEpocEnv->iDsa->WindowCoordinates(aPoint);	

   627     }

   628     

   629 void EpocSdlEnv::PanicMain(const TDesC& aInfo, TInt aErr)

   630     {

   631     gEpocEnv->iAppSrv->PanicMain(aInfo, aErr);

   632     }

   633 //Dsa is a low priority ao, it has to wait if its pending event, but ws

   634 //event has been prioritized before it

   635 //this is not called from app thread!

   636 void EpocSdlEnv::WaitDeviceChange() 

   637     {

   638   	LockPalette(ETrue);

   639     gEpocEnv->iAppSrv->RequestValue(CSdlAppServ::EAppSrvWaitDsa);

   640     const TSize sz = WindowSize();

   641     const TInt param = reinterpret_cast<TInt>(&sz);

   642     ObserverEvent(MSDLObserver::EEventScreenSizeChanged, param);

   643     	

   644    // RThread().Suspend();

   645     }  

   646     

   647 LOCAL_C TBool CheckSdl() 

   648     {

   649     TInt isExit = ETrue;

   650     RThread sdl;

   651     if(sdl.Open(gEpocEnv->iId) == KErrNone)

   652         {

   653         if(sdl.ExitType() == EExitPending)

   654             {

   655             isExit = EFalse;

   656             }

   657         sdl.Close();

   658         }

   659     return isExit;

   660     }

   661     

   662 void EpocSdlEnvData::Free()

   663     {

   664     if(RThread().Id() == gEpocEnv->iId)

   665     	{

   666     	iDsa->Free();

   667     	return;

   668     	}

   669    

   670     __ASSERT_ALWAYS(iArgv == NULL || CheckSdl(), PANIC(KErrNotReady));

   671         

   672     for(TInt i = 0; i < iArgc; i++)

   673         User::Free( iArgv[i] );

   674         

   675     User::Free(iArgv);	

   676      

   677     

   678     delete iEventQueue;

   679     

   680     if(iDsa != NULL)

   681     	iDsa->Free();

   682     

   683 	delete iDsa;

   684 	delete iAppSrv;

   685     }

   686 

   687 _LIT(KSDLMain, "SDLMain");

   688 

   689 LOCAL_C int MainL()

   690     {

   691     gEpocEnv->iCleanupItems = new (ELeave) CArrayFixFlat<TSdlCleanupItem>(8);

   692     

   693     char** envp=0;

   694      /* !! process exits here if there is "exit()" in main! */

   695     int ret = 0;

   696     for(TInt i = 0; i  < 6; i++)

   697         {

   698         void* f = (void*) gEpocEnv->iMain[i];

   699         if(f != NULL)

   700             {

   701             switch(i)

   702                 {

   703                 case 0:

   704                     ret = ((mainfunc1)f)(); 

   705                     return ret;

   706                 case 3:

   707                     ((mainfunc1)f)(); 

   708                     return ret;

   709                 case 1:

   710                     ret = ((mainfunc2)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv());

   711                     return ret;

   712                 case 4:

   713                     ((mainfunc2)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv());

   714                     return ret;

   715                 case 2:

   716                     ret = ((mainfunc3)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv(), envp);

   717                     return ret;

   718                 case 5:

   719                     ((mainfunc3)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv(), envp);

   720                     return ret;

   721                 }

   722             }

   723         }

   724     PANIC(KErrNotFound);

   725     return 0;

   726     }

   727 

   728 LOCAL_C TInt DoMain(TAny* /*aParam*/)

   729     {

   730     

   731     

   732     CTrapCleanup* cleanup = CTrapCleanup::New();

   733       	

   734 	TBool fbsconnected = EFalse;

   735 	if(RFbsSession::GetSession() == NULL)

   736 	    {

   737 	    PANIC_IF_ERROR(RFbsSession::Connect());

   738 	    fbsconnected = ETrue;

   739 	    }

   740 	

   741  	gEpocEnv->iAppSrv->Init();	

   742 

   743 #ifdef SYMBIANC 

   744     // Create stdlib 

   745     _REENT;

   746 #endif

   747 

   748     // Call stdlib main

   749     int ret = 0;

   750     

   751     //completes waiting rendesvous

   752     RThread::Rendezvous(KErrNone);

   753     

   754     TRAPD(err, err = MainL());

   755     

   756     EpocSdlEnv::ObserverEvent(MSDLObserver::EEventMainExit, err);

   757    

   758     // Free resources and return

   759     

   760   	EpocSdlEnv::CleanupItems();

   761         

   762     gEpocEnv->iCleanupItems->Reset();

   763     delete gEpocEnv->iCleanupItems;

   764     gEpocEnv->iCleanupItems = NULL;

   765     

   766     gEpocEnv->Free(); //free up in thread resources 

   767     

   768 #ifdef SYMBIANC    

   769     _cleanup(); //this is normally called at exit, I call it here

   770 #endif

   771 

   772     if(fbsconnected)

   773         RFbsSession::Disconnect();

   774     

   775 #ifdef SYMBIANC     

   776     CloseSTDLIB();

   777 #endif

   778        

   779  //   delete as;

   780    	delete cleanup;	

   781 

   782     return err == KErrNone ? ret : err;;

   783     }

   784     

   785 

   786     

   787 EXPORT_C CSDL::~CSDL()

   788     {

   789    	gEpocEnv->Free();

   790     User::Free(gEpocEnv);

   791     gEpocEnv->iSdl = NULL;

   792     }

   793 

   794 EXPORT_C CSDL* CSDL::NewL(TInt aFlags)

   795     {

   796     __ASSERT_ALWAYS(gEpocEnv == NULL, PANIC(KErrAlreadyExists));

   797     gEpocEnv = (EpocSdlEnvData*) User::AllocL(sizeof(EpocSdlEnvData));

   798     Mem::FillZ(gEpocEnv, sizeof(EpocSdlEnvData));

   799    

   800     gEpocEnv->iEpocEnvFlags = aFlags;

   801     gEpocEnv->iEventQueue = CEventQueue::NewL();

   802    

   803     gEpocEnv->iAppSrv = new (ELeave) CSdlAppServ();

   804     gEpocEnv->iAppSrv->ConstructL();

   805     

   806     CSDL* sdl = new (ELeave) CSDL();

   807     

   808     gEpocEnv->iSdl = sdl;

   809     

   810     return sdl;

   811     }

   812     

   813   /*  

   814 EXPORT_C void CSDL::ReInitL(TFlags aFlags)

   815 	{

   816 	const TFlags prevFlags = gEpocEnv->iEpocEnvFlags;

   817 	gEpocEnv->iEpocEnvFlags = aFlags;

   818 	TInt err = KErrNone;

   819 	if(((prevFlags & EDrawModeDSB) != (aFlags & EDrawModeDSB)) && gEpocEnv->iDsa)

   820 		{

   821 		delete gEpocEnv->iDsa;

   822 		gEpocEnv->iDsa = NULL;

   823 		gEpocEnv->iDsa = CDsa::RecreateL(EpocSdlEnv::Flags(CSDL::EDrawModeDSB));

   824 		}

   825 	}

   826  */

   827 

   828 

   829 EXPORT_C void CSDL::SetContainerWindowL(RWindow& aWindow, RWsSession& aSession, CWsScreenDevice& aDevice)

   830     {

   831     if(gEpocEnv->iDsa == NULL)

   832     	gEpocEnv->iDsa = CDsa::CreateL(aSession);

   833     gEpocEnv->iDsa->ConstructL(aWindow, aDevice);

   834     }

   835         

   836    

   837 EXPORT_C TThreadId CSDL::CallMainL(const TMainFunc& aFunc, TRequestStatus* const aStatus, const CDesC8Array* const aArg, TInt aFlags, TInt aStackSize)

   838     {

   839     ASSERT(gEpocEnv != NULL);

   840     gEpocEnv->iMain = aFunc;

   841     const TBool args = aArg != NULL;

   842     

   843     gEpocEnv->iArgc = aArg->Count() + 1;

   844     gEpocEnv->iArgv = (char**) User::AllocL(sizeof(char*) * (gEpocEnv->iArgc + 1));  

   845       

   846     TInt k = 0;

   847     const TFileName processName = RProcess().FileName();

   848     const TInt len = processName.Length();

   849     gEpocEnv->iArgv[k] = (char*) User::AllocL(len + 1);

   850     Mem::Copy(gEpocEnv->iArgv[k], processName.Ptr(), len);

   851     gEpocEnv->iArgv[k][len] = 0;

   852       

   853     for(TInt i =  0; args && (i < aArg->Count()); i++)

   854         {

   855         k++;

   856         const TInt len = aArg->MdcaPoint(i).Length();

   857         gEpocEnv->iArgv[k] = (char*) User::AllocL(len + 1);

   858         Mem::Copy(gEpocEnv->iArgv[k], aArg->MdcaPoint(i).Ptr(), len);

   859         gEpocEnv->iArgv[k][len] = 0;

   860         }

   861         

   862     gEpocEnv->iArgv[gEpocEnv->iArgc] = NULL;

   863          

   864     RThread thread;

   865     User::LeaveIfError(thread.Create(KSDLMain, DoMain, aStackSize, NULL, NULL));

   866     

   867     if(aStatus != NULL)

   868     	{

   869     	thread.Logon(*aStatus);

   870     	}

   871     	

   872     gEpocEnv->iId = thread.Id();

   873     thread.SetPriority(EPriorityLess);

   874     if((aFlags & CSDL::ERequestResume) == 0)

   875         {

   876         thread.Resume();

   877         }

   878     thread.Close();

   879     return gEpocEnv->iId;

   880     }

   881     

   882 EXPORT_C TInt CSDL::AppendWsEvent(const TWsEvent& aEvent)

   883     {

   884     return EpocSdlEnv::EventQueue().Append(aEvent);

   885     }

   886     

   887 EXPORT_C void CSDL::SDLPanic(const TDesC& aInfo, TInt aErr)

   888     {

   889     EpocSdlEnv::PanicMain(aInfo, aErr);

   890     }

   891     

   892 EXPORT_C TInt CSDL::GetSDLCode(TInt aScanCode)

   893     {

   894     if(aScanCode < 0)

   895         return MAX_SCANCODE;

   896     if(aScanCode >= MAX_SCANCODE)

   897         return -1;

   898     return KeyMap()[aScanCode];

   899     }

   900     

   901 EXPORT_C TInt CSDL::SDLCodesCount() const

   902 	{

   903 	return MAX_SCANCODE;

   904 	}

   905 	

   906 EXPORT_C void CSDL::ResetSDLCodes()

   907 	{

   908 	ResetKeyMap();

   909 	}

   910     

   911 EXPORT_C void CSDL::SetOrientation(TOrientationMode aMode)

   912 	{

   913 	gEpocEnv->iDsa->SetOrientation(aMode);

   914 	}

   915     

   916 EXPORT_C TInt CSDL::SetSDLCode(TInt aScanCode, TInt aSDLCode)

   917     {

   918     const TInt current = GetSDLCode(aScanCode);

   919     if(aScanCode >= 0 && aScanCode < MAX_SCANCODE)

   920         KeyMap()[aScanCode] = static_cast<SDLKey>(aSDLCode);

   921     return current;

   922     }

   923 

   924 

   925 EXPORT_C MSDLObserver* CSDL::Observer()

   926 	{

   927 	return gEpocEnv->iAppSrv->Observer();

   928 	}    

   929     

   930 EXPORT_C void CSDL::SetObserver(MSDLObserver* aObserver)

   931 	{

   932 	gEpocEnv->iAppSrv->SetObserver(aObserver);

   933 	}

   934 	

   935 EXPORT_C void CSDL::Resume()

   936 	{

   937 	EpocSdlEnv::Resume();

   938 	}

   939 	

   940 EXPORT_C void CSDL::Suspend()

   941 	{

   942 	gEpocEnv->iDsa->DoStop();

   943 	}

   944 	

   945 EXPORT_C CSDL::CSDL()

   946     {

   947     }

   948 

   949 EXPORT_C void CSDL::DisableKeyBlocking(CAknAppUi& aAppUi) const

   950 	{

   951 	gEpocEnv->iAppUi = &aAppUi;

   952 	EnvUtils::DisableKeyBlocking();

   953 	}

   954 

   955 EXPORT_C TInt CSDL::SetBlitter(MBlitter* aBlitter)

   956 	{

   957 	if(gEpocEnv && gEpocEnv->iDsa)

   958 		{

   959 		gEpocEnv->iDsa->SetBlitter(aBlitter);

   960 		return KErrNone;

   961 		}

   962 	return KErrNotReady;

   963 	}

   964 		

   965 	

   966 EXPORT_C TInt CSDL::AppendOverlay(MOverlay& aOverlay, TInt aPriority)

   967 	{

   968 	if(gEpocEnv && gEpocEnv->iDsa)

   969 		{

   970 		return gEpocEnv->iDsa->AppendOverlay(aOverlay, aPriority);

   971 		}

   972 	return KErrNotReady;

   973 	}

   974 

   975 EXPORT_C TInt CSDL::RemoveOverlay(MOverlay& aOverlay)	

   976 	{

   977 	if(gEpocEnv && gEpocEnv->iDsa)

   978 		{

   979 		return gEpocEnv->iDsa->RemoveOverlay(aOverlay);

   980 		}

   981 	return KErrNotReady;

   982 	}

   983 

   984 EXPORT_C TInt CSDL::RedrawRequest()

   985 	{

   986 	if(gEpocEnv && gEpocEnv->iDsa)

   987 		{

   988 		return gEpocEnv->iDsa->RedrawRequest();

   989 		}

   990 	return KErrNotReady;

   991 	}

   992 	

   993 /*

   994 EXPORT_C CSDL* CSDL::Current()

   995     {

   996     return gEpocEnv != NULL ? gEpocEnv->iSdl : NULL;

   997     }

   998 

   999     

  1000 EXPORT_C TInt CSDL::SetVolume(TInt aVolume)

  1001     {

  1002     return EpocSdlEnv::SetVolume(aVolume);

  1003     } 

  1004     

  1005 EXPORT_C TInt CSDL::Volume() const

  1006     {

  1007     return EpocSdlEnv::Volume();

  1008     }     

  1009 	

  1010 EXPORT_C TInt CSDL::MaxVolume() const

  1011     {

  1012     return EpocSdlEnv::MaxVolume();

  1013     } 	

  1014 */

  1015 			

  1016 void EnvUtils::DisableKeyBlocking()

  1017 	{

  1018 	if(gEpocEnv->iAppUi != NULL)

  1019 		return CCurrentAppUi::Cast(gEpocEnv->iAppUi)->DisableKeyBlocking();

  1020 	}

  1021 	

  1022 TBool EnvUtils::Rendezvous(RThread& aThread, TRequestStatus& aStatus)

  1023 	{

  1024 	if(gEpocEnv->iId != TThreadId(0) &&

  1025     		 	aThread.Open(gEpocEnv->iId) &&

  1026     		  	aThread.ExitType() == EExitPending)

  1027     			{

  1028     			aThread.Rendezvous(aStatus);

  1029     			return ETrue;

  1030     			}

  1031     return EFalse;

  1032 	}

  1033 	

  1034 	

  1035