implement input to avoid PD common dependency
[sdl_omap.git] / src / main / symbian / EKA2 / SDL_main.cpp
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