src/main/symbian/SDL_main.cpp

   1 #include "epoc_sdl.h"
   2 #include "sdlepocapi.h"
   3 #include <e32base.h>
   4 #include <estlib.h>
   5 #include <stdio.h>
   6 #include <badesca.h>
   7 #include "vectorbuffer.h"
   8 #include <w32std.h>
   9 #include <aknappui.h>
  10 #include <aknapp.h>
  11 #include "SDL_epocevents_c.h"
  12 #include "SDL_keysym.h"
  13 #include "dsa.h"
  14 #include "SDL_loadso.h"
  15
  16 extern SDLKey* KeyMap();
  17 extern void ResetKeyMap();
  18
  19 class CCurrentAppUi;
  20 class CEikonEnv;
  21 class CSdlAppServ;
  22 class CEventQueue;
  23
  24 NONSHARABLE_CLASS(EpocSdlEnvData)
  25 {
  26         public:
  27                 void Free();
  28                 void Delete();
  29                 CEventQueue*            iEventQueue;
  30                 TMainFunc                               iMain;
  31                 TInt                            iEpocEnvFlags;
  32                 int                     iArgc;
  33                 char**                  iArgv;
  34                 CDsa*                   iDsa;
  35                 CSdlAppServ*            iAppSrv;
  36                 TThreadId               iId;
  37                 CArrayFix<TSdlCleanupItem>* iCleanupItems;
  38                 CEikAppUi*                              iAppUi;
  39                 CSDL*                                   iSdl;
  40                 CIdle*                                  iCaller;
  41                 TRequestStatus*                 iCallerStatus;
  42 };
  43
  44 EpocSdlEnvData* gEpocEnv;
  45
  46 NONSHARABLE_CLASS(EnvUtils)
  47 {
  48         public:
  49                 static inline TBool IsOwnThreaded();
  50                 static void DisableKeyBlocking();
  51                 static TBool Rendezvous(RThread& aThread, TRequestStatus& aStatus);
  52                 static void RunSingleThread();
  53 };
  54
  55 inline TBool EnvUtils::IsOwnThreaded()
  56 {
  57         return gEpocEnv->iEpocEnvFlags & CSDL::EOwnThread;
  58 }
  59
  60 void EnvUtils::RunSingleThread()
  61 {
  62         if(!EnvUtils::IsOwnThreaded())
  63         {
  64                 TInt count = RThread().RequestCount();
  65                 if(count > 0)
  66                 {
  67                         TInt err;
  68                         if(CActiveScheduler::RunIfReady(err, CActive::EPriorityIdle))
  69                         {
  70                                 CActiveScheduler::Current()->WaitForAnyRequest();
  71                         }
  72                 }
  73         }
  74 }
  75
  76 TInt Panic(TInt aErr, TInt aLine)
  77 {
  78         TBuf<64> b;
  79         b.Format(_L("Main at %d"), aLine);
  80         User::Panic(b, aErr);
  81         return 0;
  82 }
  83
  84
  85 NONSHARABLE_CLASS(CCurrentAppUi) : public CAknAppUi
  86 {
  87         public:
  88                 static CCurrentAppUi* Cast(CEikAppUi* aUi);
  89                 void DisableKeyBlocking();
  90 };
  91
  92
  93 CCurrentAppUi* CCurrentAppUi::Cast(CEikAppUi* aUi)
  94 {
  95         return static_cast<CCurrentAppUi*>(aUi);
  96 }
  97
  98 void CCurrentAppUi::DisableKeyBlocking()
  99 {
 100         SetKeyBlockMode(ENoKeyBlock);
 101 }
 102
 103
 104 class CEventQueue : public CBase, public MEventQueue
 105 {
 106         public:
 107                 void ConstructL();
 108                 ~CEventQueue();
 109                 TInt Append(const TWsEvent& aEvent);
 110                 const TWsEvent& Shift();
 111                 void Lock();
 112                 void Unlock();
 113                 TBool HasData();
 114
 115         private:
 116                 TVector<TWsEvent, 64> iVector;
 117                 RCriticalSection iCS;
 118 };
 119
 120 void CEventQueue::ConstructL()
 121 {
 122         if(EnvUtils::IsOwnThreaded())
 123                 User::LeaveIfError(iCS.CreateLocal());
 124 }
 125
 126 CEventQueue::~CEventQueue()
 127 {
 128         iCS.Close();
 129 }
 130
 131 TInt CEventQueue::Append(const TWsEvent& aEvent)
 132 {
 133         Lock();
 134         const TInt err = iVector.Append(aEvent);
 135         Unlock();
 136         return err;
 137 }
 138
 139
 140 TBool CEventQueue::HasData()
 141 {
 142         EnvUtils::RunSingleThread();
 143         return iVector.Size() > 0;
 144 }
 145
 146 void CEventQueue::Lock()
 147 {
 148         if(EnvUtils::IsOwnThreaded())
 149                 iCS.Wait();
 150 }
 151
 152 void CEventQueue::Unlock()
 153 {
 154         if(EnvUtils::IsOwnThreaded())
 155                 iCS.Signal();
 156 }
 157
 158 const TWsEvent& CEventQueue::Shift()
 159 {
 160         const TWsEvent& event = iVector.Shift();
 161         return event;
 162 }
 163
 164
 165 TSdlCleanupItem::TSdlCleanupItem(TSdlCleanupOperation aOperation, TAny* aItem) :
 166         iOperation(aOperation), iItem(aItem), iThread(RThread().Id())
 167 {}
 168
 169 #define MAINFUNC(x) EXPORT_C TMainFunc::TMainFunc(mainfunc##x aFunc){Mem::FillZ(iMainFunc, sizeof(iMainFunc)); iMainFunc[x - 1] = (void*) aFunc;}
 170
 171         MAINFUNC(1)
 172         MAINFUNC(2)
 173         MAINFUNC(3)
 174         MAINFUNC(4)
 175         MAINFUNC(5)
 176 MAINFUNC(6)
 177
 178 EXPORT_C TMainFunc::TMainFunc()
 179 {
 180         Mem::FillZ(iMainFunc, sizeof(iMainFunc));
 181 }
 182
 183
 184 const void* TMainFunc::operator[](TInt aIndex) const
 185 {
 186         return iMainFunc[aIndex];
 187 }
 188
 189
 190 NONSHARABLE_CLASS(CSdlAppServ) : public CActive
 191 {
 192         public:
 193                 enum
 194                 {
 195                         EAppSrvNoop = CDsa::ELastDsaRequest,
 196                         EAppSrvWindowWidth,
 197                         EAppSrvWindowHeight,
 198                         EAppSrvWindowDisplayMode,
 199                         EAppSrvWindowPointerCursorMode,
 200                         EAppSrvDsaStatus,
 201                         EAppSrvStopThread,
 202                         EAppSrvWaitDsa
 203                 };
 204                 CSdlAppServ();
 205                 void ConstructL();
 206                 ~CSdlAppServ();
 207                 TInt Request(TInt aService);
 208                 TInt RequestValue(TInt aService);
 209                 void Init();
 210                 void PanicMain(TInt aReason);
 211                 void PanicMain(const TDesC& aInfo, TInt aReason);
 212                 void SetObserver(MSDLObserver* aObserver);
 213                 TInt ObserverEvent(TInt aEvent, TInt aParam);
 214                 void SetParam(TInt aParam);
 215                 void HandleObserverValue(TInt aService, TInt aReturnValue, TBool aMainThread);
 216                 MSDLObserver* Observer();
 217
 218         private:
 219                 void RunL();
 220                 void DoCancel();
 221                 const TThreadId iMainId;
 222                 RThread iAppThread;
 223                 TInt iService;
 224                 TInt iReturnValue;
 225                 RSemaphore iSema;
 226                 MSDLObserver* iObserver;
 227                 TRequestStatus* iStatusPtr;
 228 };
 229
 230 CSdlAppServ::CSdlAppServ() : CActive(CActive::EPriorityHigh), iMainId(RThread().Id())
 231 {}
 232
 233
 234 MSDLObserver* CSdlAppServ::Observer()
 235 {
 236         return iObserver;
 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 && EnvUtils::IsOwnThreaded())
 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         if(EnvUtils::IsOwnThreaded())
 275                 User::LeaveIfError(iSema.CreateLocal(1));
 276         iStatus = KRequestPending;
 277         iStatusPtr = &iStatus;
 278         SetActive();
 279 }
 280
 281 CSdlAppServ::~CSdlAppServ()
 282 {
 283         Cancel();
 284         if(iSema.Handle() != NULL)
 285                 iSema.Signal();
 286         iSema.Close();
 287         iAppThread.Close();
 288 }
 289
 290 TInt CSdlAppServ::Request(TInt aService)
 291 {
 292         if(EnvUtils::IsOwnThreaded())
 293         {
 294                 if(RThread().Id() == iAppThread.Id())
 295                         return KErrBadHandle;
 296                 iSema.Wait();
 297         }
 298         EnvUtils::RunSingleThread();
 299         iService = aService;
 300         iAppThread.RequestComplete(iStatusPtr, KErrNone);
 301         return KErrNone;
 302 }
 303
 304 TInt CSdlAppServ::RequestValue(TInt aService)
 305 {
 306         Request(aService);
 307         Request(EAppSrvNoop);
 308         return iReturnValue;
 309 }
 310
 311 void CSdlAppServ::Init()
 312 {
 313         PANIC_IF_ERROR(iAppThread.Open(iMainId));
 314 }
 315
 316 void CSdlAppServ::SetParam(TInt aParam)
 317 {
 318         iReturnValue = aParam;
 319 }
 320
 321 void CSdlAppServ::HandleObserverValue(TInt aService, TInt aReturnValue, TBool aMainThread)
 322 {
 323         if(iObserver != NULL && aMainThread)
 324         {
 325                 switch(aService)
 326                 {
 327                         case MSDLObserver::EEventScreenSizeChanged:
 328                                 if(aReturnValue == MSDLObserver::EScreenSizeChangedDefaultPalette)
 329                                         EpocSdlEnv::LockPalette(EFalse);
 330                                 break;
 331                 }
 332         }
 333         if(!aMainThread && aService == MSDLObserver::EEventSuspend)
 334         {
 335                 if(iObserver == NULL || (gEpocEnv->iDsa != NULL && gEpocEnv->iDsa->Stopped() && aReturnValue != MSDLObserver::ESuspendNoSuspend))
 336                 {
 337                         EpocSdlEnv::Suspend();
 338                 }
 339         }
 340 }
 341
 342 void CSdlAppServ::RunL()
 343 {
 344         if(iStatus == KErrNone)
 345         {
 346                 switch(iService)
 347                 {
 348                         case CSdlAppServ::EAppSrvWaitDsa:
 349                                 EpocSdlEnv::SetWaitDsa();
 350                                 iReturnValue = EpocSdlEnv::IsDsaAvailable();
 351                                 break;
 352
 353                         case CSdlAppServ::EAppSrvStopThread:
 354                                 if(gEpocEnv->iDsa != NULL)
 355                                         gEpocEnv->iDsa->SetSuspend();
 356                                 break;
 357
 358                         case EpocSdlEnv::EDisableKeyBlocking:
 359                                 EnvUtils::DisableKeyBlocking();
 360                                 break;
 361
 362                         case EAppSrvWindowPointerCursorMode:
 363                                 iReturnValue = gEpocEnv->iDsa != NULL ? gEpocEnv->iDsa->Session().PointerCursorMode() : KErrNotReady;
 364                                 break;
 365
 366                         case EAppSrvDsaStatus:
 367                                 if(gEpocEnv->iDsa != NULL)
 368                                         gEpocEnv->iDsa->Stop();
 369                                 iReturnValue = KErrNone;
 370                                 break;
 371
 372                         case CDsa::ERequestUpdate:
 373                                 gEpocEnv->iDsa->UnlockHWSurfaceRequestComplete();
 374                                 break;
 375
 376                         case EAppSrvNoop:
 377                                 break;
 378
 379                         case MSDLObserver::EEventResume:
 380                         case MSDLObserver::EEventSuspend:
 381                         case MSDLObserver::EEventScreenSizeChanged:
 382                         case MSDLObserver::EEventWindowReserved:
 383                         case MSDLObserver::EEventKeyMapInit:
 384                         case MSDLObserver::EEventWindowNotAvailable:
 385                         case MSDLObserver::EEventMainExit:
 386                                 iReturnValue = ObserverEvent(iService, iReturnValue);
 387                                 HandleObserverValue(iService, iReturnValue, ETrue);
 388                                 break;
 389
 390                         default:
 391                                 PANIC(KErrNotSupported);
 392                                 break;
 393                 }
 394
 395                 iStatus = KRequestPending;
 396                 iStatusPtr = &iStatus;
 397                 SetActive();
 398         }
 399
 400         if(EnvUtils::IsOwnThreaded())
 401                 iSema.Signal();
 402 }
 403
 404 void CSdlAppServ::DoCancel()
 405 {
 406         if(EnvUtils::IsOwnThreaded())
 407                 iSema.Wait();
 408         TRequestStatus* s = &iStatus;
 409         iAppThread.RequestComplete(s, KErrCancel);
 410 }
 411
 412 MEventQueue& EpocSdlEnv::EventQueue()
 413 {
 414         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 415         return *gEpocEnv->iEventQueue;
 416 }
 417
 418
 419 TBool EpocSdlEnv::Flags(TInt aFlag)
 420 {
 421         const TInt flag = gEpocEnv->iEpocEnvFlags & aFlag;
 422         return flag == aFlag;
 423 }
 424
 425 TInt EpocSdlEnv::Argc()
 426 {
 427         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 428         return gEpocEnv->iArgc;
 429 }
 430
 431 char** EpocSdlEnv::Argv()
 432 {
 433         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 434         return gEpocEnv->iArgv;
 435 }
 436
 437 TBool EpocSdlEnv::IsDsaAvailable()
 438 {
 439         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 440         return gEpocEnv->iDsa != NULL && gEpocEnv->iDsa->IsDsaAvailable();
 441 }
 442
 443 void EpocSdlEnv::WaitDsaAvailable()
 444 {
 445         EpocSdlEnv::ObserverEvent(MSDLObserver::EEventWindowNotAvailable, 0);
 446         gEpocEnv->iAppSrv->Request(CSdlAppServ::EAppSrvStopThread);
 447         if(EpocSdlEnv::Flags(CSDL::EEnableFocusStop))
 448         {
 449                 EpocSdlEnv::ObserverEvent(MSDLObserver::EEventSuspend, 0);
 450         }
 451 }
 452
 453 void EpocSdlEnv::Suspend()
 454 {
 455         if(gEpocEnv->iDsa != NULL && (gEpocEnv->iDsa->Stopped() || EpocSdlEnv::Flags(CSDL::EEnableFocusStop)))
 456         {
 457                 gEpocEnv->iDsa->SetSuspend();
 458                 if(EnvUtils::IsOwnThreaded())
 459                 {
 460                         RThread().Suspend();
 461                         EpocSdlEnv::ObserverEvent(MSDLObserver::EEventResume, 0);
 462                 }
 463         }
 464 }
 465
 466 void EpocSdlEnv::SetWaitDsa()
 467 {
 468         if(!IsDsaAvailable())
 469         {
 470                 if(EnvUtils::IsOwnThreaded())
 471                 {
 472                         RThread th;
 473                         th.Open(gEpocEnv->iId);
 474                         th.Suspend();
 475                         th.Close();
 476                 }
 477                 if(gEpocEnv->iDsa != NULL)
 478                         gEpocEnv->iDsa->SetSuspend();
 479         }
 480 }
 481
 482 void EpocSdlEnv::Resume()
 483 {
 484         if(gEpocEnv->iDsa != NULL)
 485         {
 486                 gEpocEnv->iDsa->Resume();
 487         }
 488         if(EnvUtils::IsOwnThreaded())
 489         {
 490                 RThread th;
 491                 th.Open(gEpocEnv->iId);
 492                 th.Resume();
 493                 th.Close();
 494         }
 495         const TInt value = gEpocEnv->iAppSrv->ObserverEvent(MSDLObserver::EEventResume, 0);
 496         gEpocEnv->iAppSrv->HandleObserverValue(MSDLObserver::EEventResume, value, ETrue);
 497 }
 498
 499
 500 TInt EpocSdlEnv::AllocSwSurface(const TSize& aSize, TDisplayMode aMode)
 501 {
 502         return gEpocEnv->iDsa->AllocSurface(EFalse, aSize, aMode);
 503 }
 504
 505 TInt EpocSdlEnv::AllocHwSurface(const TSize& aSize, TDisplayMode aMode)
 506 {
 507         return gEpocEnv->iDsa->AllocSurface(ETrue, aSize, aMode);
 508 }
 509
 510 void EpocSdlEnv::UnlockHwSurface()
 511 {
 512         gEpocEnv->iDsa->UnlockHwSurface();
 513 }
 514
 515 TUint8* EpocSdlEnv::LockHwSurface()
 516 {
 517         return gEpocEnv->iDsa->LockHwSurface();
 518 }
 519
 520 void EpocSdlEnv::UpdateSwSurface()
 521 {
 522         gEpocEnv->iDsa->UpdateSwSurface();
 523 }
 524
 525 TBool EpocSdlEnv::AddUpdateRect(TUint8* aAddress, const TRect& aUpdateRect, const TRect& aRect)
 526 {
 527         return gEpocEnv->iDsa->AddUpdateRect(aAddress, aUpdateRect, aRect);
 528 }
 529
 530 void EpocSdlEnv::Request(TInt aService)
 531 {
 532         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 533         gEpocEnv->iAppSrv->Request(aService);
 534 }
 535
 536 TSize EpocSdlEnv::WindowSize(const TSize& aRequestedSize)
 537 {
 538         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 539         if(gEpocEnv->iDsa != NULL && EpocSdlEnv::Flags(CSDL::EAllowImageResize) && gEpocEnv->iDsa->WindowSize() != aRequestedSize)
 540         {
 541                 TRAP_IGNORE(gEpocEnv->iDsa->CreateZoomerL(aRequestedSize));
 542         }
 543         return gEpocEnv->iDsa == NULL ? TSize(0, 0) : gEpocEnv->iDsa->WindowSize();
 544 }
 545
 546 TSize EpocSdlEnv::WindowSize()
 547 {
 548         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 549         return gEpocEnv->iDsa == NULL ? TSize(0, 0) : gEpocEnv->iDsa->WindowSize();
 550 }
 551
 552 TDisplayMode EpocSdlEnv::DisplayMode()
 553 {
 554         return gEpocEnv->iDsa == NULL ? ENone : gEpocEnv->iDsa->DisplayMode();
 555 }
 556
 557 TPointerCursorMode EpocSdlEnv::PointerMode()
 558 {
 559         return static_cast<TPointerCursorMode>(gEpocEnv->iAppSrv->RequestValue(CSdlAppServ::EAppSrvWindowPointerCursorMode));
 560 }
 561
 562 TInt EpocSdlEnv::SetPalette(TInt aFirstcolor, TInt aColorCount, TUint32* aPalette)
 563 {
 564         return  gEpocEnv->iDsa->SetPalette(aFirstcolor, aColorCount, aPalette);
 565 }
 566
 567 void EpocSdlEnv::PanicMain(TInt aErr)
 568 {
 569         gEpocEnv->iAppSrv->PanicMain(aErr);
 570 }
 571
 572
 573 TInt EpocSdlEnv::AppendCleanupItem(const TSdlCleanupItem& aItem)
 574 {
 575         TRAPD(err, gEpocEnv->iCleanupItems->AppendL(aItem));
 576         return err;
 577 }
 578
 579 void EpocSdlEnv::RemoveCleanupItem(TAny* aItem)
 580 {
 581         for(TInt i = 0; i < gEpocEnv->iCleanupItems->Count(); i++)
 582         {
 583                 if(gEpocEnv->iCleanupItems->At(i).iItem == aItem)
 584                         gEpocEnv->iCleanupItems->Delete(i);
 585         }
 586 }
 587
 588 void EpocSdlEnv::CleanupItems()
 589 {
 590         const TThreadId id = RThread().Id();
 591         TInt last = gEpocEnv->iCleanupItems->Count() - 1;
 592         TInt i;
 593
 594         for(i = last; i >= 0 ; i--)
 595         {
 596                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 597                 if(item.iThread == id)
 598                 {
 599                         item.iThread = TThreadId(0);
 600                         item.iOperation(item.iItem);
 601                 }
 602         }
 603
 604         last = gEpocEnv->iCleanupItems->Count() - 1;
 605
 606         for(i = last; i >= 0 ; i--)
 607         {
 608                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 609                 if(item.iThread == TThreadId(0))
 610                 {
 611                         gEpocEnv->iCleanupItems->Delete(i);
 612                 }
 613         }
 614 }
 615
 616 void EpocSdlEnv::FreeSurface()
 617 {
 618         Request(CSdlAppServ::EAppSrvDsaStatus);
 619         if(gEpocEnv->iDsa != NULL)
 620                 gEpocEnv->iDsa->Free();
 621 }
 622
 623 void EpocSdlEnv::LockPalette(TBool aLock)
 624 {
 625         gEpocEnv->iDsa->LockPalette(aLock);
 626 }
 627
 628 void EpocSdlEnv::ObserverEvent(TInt aService, TInt aParam)
 629 {
 630         const TBool sdlThread = RThread().Id() == gEpocEnv->iId;
 631         const TInt valuea = gEpocEnv->iAppSrv->ObserverEvent(aService, aParam);
 632         gEpocEnv->iAppSrv->HandleObserverValue(aService, valuea, !sdlThread);
 633         if(sdlThread)
 634         {
 635                 gEpocEnv->iAppSrv->SetParam(aParam);
 636                 const TInt valuet = gEpocEnv->iAppSrv->RequestValue(aService);
 637                 gEpocEnv->iAppSrv->HandleObserverValue(aService, valuet, EFalse);
 638         }
 639 }
 640
 641 TPoint EpocSdlEnv::WindowCoordinates(const TPoint& aPoint)
 642 {
 643         return gEpocEnv->iDsa == NULL ? aPoint : gEpocEnv->iDsa->WindowCoordinates(aPoint);
 644 }
 645
 646 void EpocSdlEnv::PanicMain(const TDesC& aInfo, TInt aErr)
 647 {
 648         gEpocEnv->iAppSrv->PanicMain(aInfo, aErr);
 649 }
 650
 651 //Dsa is a low priority ao, it has to wait if its pending event, but ws
 652 //event has been prioritized before it
 653 //this is not called from app thread!
 654 void EpocSdlEnv::WaitDeviceChange()
 655 {
 656         LockPalette(ETrue);
 657         gEpocEnv->iAppSrv->RequestValue(CSdlAppServ::EAppSrvWaitDsa);
 658         const TSize sz = WindowSize();
 659         const TInt param = reinterpret_cast<TInt>(&sz);
 660         ObserverEvent(MSDLObserver::EEventScreenSizeChanged, param);
 661 }
 662
 663 LOCAL_C TBool CheckSdl()
 664 {
 665         TInt isExit = ETrue;
 666         RThread sdl;
 667         if(sdl.Open(gEpocEnv->iId) == KErrNone)
 668         {
 669                 if(sdl.ExitType() == EExitPending)
 670                 {
 671                         isExit = EFalse;
 672                 }
 673                 sdl.Close();
 674         }
 675         return isExit;
 676 }
 677
 678 void EpocSdlEnvData::Free()
 679 {
 680         if(RThread().Id() == gEpocEnv->iId)
 681         {
 682                 if(iDsa != NULL)
 683                         iDsa->Free();
 684                 return;
 685         }
 686
 687         __ASSERT_ALWAYS(iArgv == NULL || CheckSdl(), PANIC(KErrNotReady));
 688 }
 689
 690 void EpocSdlEnvData::Delete()
 691 {
 692         for(TInt i = 0; i <= iArgc; i++)
 693         {
 694                 if(iArgv != NULL)
 695                         User::Free( iArgv[i] );
 696         }
 697
 698         User::Free(iArgv);
 699
 700         iArgv = NULL;
 701         iArgc = 0;
 702
 703         delete iEventQueue;
 704
 705         if(iDsa != NULL)
 706                 iDsa->Free();
 707
 708         delete iDsa;
 709         delete iAppSrv;
 710
 711         delete gEpocEnv->iCaller;
 712 }
 713
 714 _LIT(KSDLMain, "SDLMain");
 715
 716 LOCAL_C int MainL()
 717 {
 718         gEpocEnv->iCleanupItems = new (ELeave) CArrayFixFlat<TSdlCleanupItem>(8);
 719
 720         char** envp=0;
 721         /* !! process exits here if there is "exit()" in main! */
 722         int ret = 0;
 723         for(TInt i = 0; i < 6; i++)
 724         {
 725                 void* f = (void*) gEpocEnv->iMain[i];
 726                 if(f != NULL)
 727                 {
 728                         switch(i)
 729                         {
 730                                 case 0:
 731                                         ret = ((mainfunc1)f)();
 732                                         return ret;
 733
 734                                 case 3:
 735                                         ((mainfunc1)f)();
 736                                         return ret;
 737
 738                                 case 1:
 739                                         ret = ((mainfunc2)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv());
 740                                         return ret;
 741
 742                                 case 4:
 743                                         ((mainfunc2)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv());
 744                                         return ret;
 745
 746                                 case 2:
 747                                         ret = ((mainfunc3)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv(), envp);
 748                                         return ret;
 749
 750                                 case 5:
 751                                         ((mainfunc3)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv(), envp);
 752                                         return ret;
 753                         }
 754                 }
 755         }
 756         PANIC(KErrNotFound);
 757         return 0;
 758 }
 759
 760 LOCAL_C TInt DoMain(TAny* /*aParam*/)
 761 {
 762         TBool fbsconnected = EFalse;
 763         CTrapCleanup* cleanup = NULL;
 764
 765         if(EnvUtils::IsOwnThreaded())
 766         {
 767                 cleanup = CTrapCleanup::New();
 768
 769                 if(RFbsSession::GetSession() == NULL)
 770                 {
 771                         PANIC_IF_ERROR(RFbsSession::Connect());
 772                         fbsconnected = ETrue;
 773                 }
 774         }
 775         gEpocEnv->iAppSrv->Init();
 776
 777         // Call stdlib main
 778         int ret = 0;
 779         if(EnvUtils::IsOwnThreaded())
 780         {
 781                 //completes waiting rendesvous
 782                 RThread::Rendezvous(KErrNone);
 783         }
 784
 785         TRAPD(err, err = MainL());
 786
 787         EpocSdlEnv::ObserverEvent(MSDLObserver::EEventMainExit, err);
 788
 789         // Free resources and return
 790         EpocSdlEnv::CleanupItems();
 791
 792         gEpocEnv->iCleanupItems->Reset();
 793         delete gEpocEnv->iCleanupItems;
 794         gEpocEnv->iCleanupItems = NULL;
 795
 796         gEpocEnv->Free(); //free up in thread resources
 797
 798         if(fbsconnected)
 799                 RFbsSession::Disconnect();
 800
 801         delete cleanup;
 802
 803         if(gEpocEnv->iCallerStatus != NULL)
 804         {
 805                 User::RequestComplete(gEpocEnv->iCallerStatus, err);
 806                 return 0;
 807         }
 808         else
 809         {
 810                 return err == KErrNone ? ret : err;
 811         }
 812 }
 813
 814 EXPORT_C CSDL::~CSDL()
 815 {
 816         gEpocEnv->Free();
 817         gEpocEnv->Delete();
 818
 819         User::Free(gEpocEnv);
 820         gEpocEnv = NULL;
 821 }
 822
 823 EXPORT_C CSDL* CSDL::NewL(TInt aFlags)
 824 {
 825         __ASSERT_ALWAYS(gEpocEnv == NULL, PANIC(KErrAlreadyExists));
 826         gEpocEnv = (EpocSdlEnvData*) User::AllocL(sizeof(EpocSdlEnvData));
 827         Mem::FillZ(gEpocEnv, sizeof(EpocSdlEnvData));
 828
 829         gEpocEnv->iEpocEnvFlags = aFlags;
 830         gEpocEnv->iEventQueue = new (ELeave) CEventQueue();
 831         gEpocEnv->iAppSrv = new (ELeave) CSdlAppServ();
 832
 833         CSDL* sdl = new (ELeave) CSDL();
 834
 835         gEpocEnv->iSdl = sdl;
 836
 837         return sdl;
 838 }
 839
 840 EXPORT_C void CSDL::SetContainerWindowL(RWindow& aWindow, RWsSession& aSession, CWsScreenDevice& aDevice)
 841 {
 842         if(gEpocEnv->iDsa == NULL)
 843                 gEpocEnv->iDsa = CDsa::CreateL(aSession);
 844         gEpocEnv->iDsa->ConstructL(aWindow, aDevice);
 845 }
 846
 847 TInt EpocSdlEnv::ApplyGlesDsa()
 848 {
 849         CDsa* dsa = NULL;
 850         TRAPD(err, dsa = gEpocEnv->iDsa->CreateGlesDsaL());
 851         gEpocEnv->iDsa = dsa;
 852         return err;
 853 }
 854
 855 RWindow* EpocSdlEnv::Window()
 856 {
 857         return gEpocEnv->iDsa->Window();
 858 }
 859
 860 EXPORT_C TThreadId CSDL::CallMainL(const TMainFunc& aFunc, TRequestStatus* const aStatus, const CDesC8Array* const aArg, TInt aFlags, TInt aStackSize)
 861 {
 862         ASSERT(gEpocEnv != NULL);
 863         gEpocEnv->iMain = aFunc;
 864         const TBool args = aArg != NULL;
 865
 866         if(gEpocEnv->iArgv != NULL)
 867                 User::Leave(KErrAlreadyExists);
 868
 869         gEpocEnv->iArgc = args ? aArg->Count() + 1 : 0;
 870         gEpocEnv->iArgv = (char**) User::AllocL(sizeof(char*) * (gEpocEnv->iArgc + 2));
 871
 872         TInt k = 0;
 873         const TFileName processName = RProcess().FileName();
 874         const TInt len = processName.Length();
 875         gEpocEnv->iArgv[k] = (char*) User::AllocL(len + 1);
 876         Mem::Copy(gEpocEnv->iArgv[k], processName.Ptr(), len);
 877         gEpocEnv->iArgv[k][len] = 0;
 878
 879         for(TInt i =  0; args && (i < aArg->Count()); i++)
 880         {
 881                 k++;
 882                 const TInt len = aArg->MdcaPoint(i).Length();
 883                 gEpocEnv->iArgv[k] = (char*) User::AllocL(len + 1);
 884                 Mem::Copy(gEpocEnv->iArgv[k], aArg->MdcaPoint(i).Ptr(), len);
 885                 gEpocEnv->iArgv[k][len] = 0;
 886         }
 887
 888         gEpocEnv->iArgv[k + 1] = NULL;
 889
 890         //For legacy, set to be threaded if resume is requested
 891         if(aFlags & CSDL::ERequestResume)
 892         { //unless explicitly told not to
 893                 if(!(gEpocEnv->iEpocEnvFlags & EMainThread))
 894                 {
 895                         gEpocEnv->iEpocEnvFlags |= EOwnThread;
 896                 }
 897         }
 898
 899         gEpocEnv->iEventQueue->ConstructL();
 900         gEpocEnv->iAppSrv->ConstructL();
 901
 902         if(EnvUtils::IsOwnThreaded())
 903         {
 904                 RThread thread;
 905                 User::LeaveIfError(thread.Create(KSDLMain, DoMain, aStackSize, NULL, NULL));
 906
 907                 if(aStatus != NULL)
 908                 {
 909                         thread.Logon(*aStatus);
 910                 }
 911
 912                 gEpocEnv->iId = thread.Id();
 913                 thread.SetPriority(EPriorityLess);
 914                 if((aFlags & CSDL::ERequestResume) == 0)
 915                 {
 916                         thread.Resume();
 917                 }
 918                 thread.Close();
 919         }
 920         else
 921         {
 922                 gEpocEnv->iCaller = CIdle::NewL(CActive::EPriorityIdle);
 923                 gEpocEnv->iCaller->Start(TCallBack(DoMain));
 924                 gEpocEnv->iCallerStatus = aStatus;
 925                 if(aStatus != NULL)
 926                         *aStatus = KRequestPending;
 927                 gEpocEnv->iId = RThread().Id();
 928                 RThread().SetPriority(EPriorityLess);
 929         }
 930
 931         return gEpocEnv->iId;
 932 }
 933
 934 EXPORT_C TInt CSDL::AppendWsEvent(const TWsEvent& aEvent)
 935 {
 936         return EpocSdlEnv::EventQueue().Append(aEvent);
 937 }
 938
 939 EXPORT_C void CSDL::SDLPanic(const TDesC& aInfo, TInt aErr)
 940 {
 941         EpocSdlEnv::PanicMain(aInfo, aErr);
 942 }
 943
 944 EXPORT_C TInt CSDL::GetSDLCode(TInt aScanCode)
 945 {
 946         if(aScanCode < 0)
 947                 return MAX_SCANCODE;
 948         if(aScanCode >= MAX_SCANCODE)
 949                 return -1;
 950         return KeyMap()[aScanCode];
 951 }
 952
 953 EXPORT_C TInt CSDL::SDLCodesCount() const
 954 {
 955         return MAX_SCANCODE;
 956 }
 957
 958 EXPORT_C void CSDL::ResetSDLCodes()
 959 {
 960         ResetKeyMap();
 961 }
 962
 963 EXPORT_C void CSDL::SetOrientation(TOrientationMode aMode)
 964 {
 965         CDsa::TOrientationMode mode = CDsa::EViewOrientation0;
 966         switch(aMode)
 967         {
 968                 case EOrientation0: mode = CDsa::EViewOrientation0; break;
 969                 case EOrientation90: mode = CDsa::EViewOrientation90; break;
 970                 case EOrientation180: mode = CDsa::EViewOrientation180; break;
 971                 case EOrientation270: mode = CDsa::EViewOrientation270; break;
 972         }
 973         gEpocEnv->iDsa->SetOrientation(mode);
 974 }
 975
 976 EXPORT_C TInt CSDL::SetSDLCode(TInt aScanCode, TInt aSDLCode)
 977 {
 978         const TInt current = GetSDLCode(aScanCode);
 979         if(aScanCode >= 0 && aScanCode < MAX_SCANCODE)
 980                 KeyMap()[aScanCode] = static_cast<SDLKey>(aSDLCode);
 981         return current;
 982 }
 983
 984
 985 EXPORT_C MSDLObserver* CSDL::Observer()
 986 {
 987         return gEpocEnv->iAppSrv->Observer();
 988 }
 989
 990 EXPORT_C void CSDL::SetObserver(MSDLObserver* aObserver)
 991 {
 992         gEpocEnv->iAppSrv->SetObserver(aObserver);
 993 }
 994
 995 EXPORT_C void CSDL::Resume()
 996 {
 997         EpocSdlEnv::Resume();
 998 }
 999
1000 EXPORT_C void CSDL::Suspend()
1001 {
1002         if(gEpocEnv->iDsa != NULL)
1003                 gEpocEnv->iDsa->DoStop();
1004 }
1005
1006 EXPORT_C CSDL::CSDL()
1007 {}
1008
1009 EXPORT_C void CSDL::DisableKeyBlocking(CAknAppUi& aAppUi) const
1010 {
1011         gEpocEnv->iAppUi = &aAppUi;
1012         EnvUtils::DisableKeyBlocking();
1013 }
1014
1015 EXPORT_C TInt CSDL::SetBlitter(MBlitter* aBlitter)
1016 {
1017         if(gEpocEnv && gEpocEnv->iDsa)
1018         {
1019                 gEpocEnv->iDsa->SetBlitter(aBlitter);
1020                 return KErrNone;
1021         }
1022         return KErrNotReady;
1023 }
1024
1025
1026 EXPORT_C TInt CSDL::AppendOverlay(MOverlay& aOverlay, TInt aPriority)
1027 {
1028         if(gEpocEnv && gEpocEnv->iDsa)
1029         {
1030                 return gEpocEnv->iDsa->AppendOverlay(aOverlay, aPriority);
1031         }
1032         return KErrNotReady;
1033 }
1034
1035 EXPORT_C TInt CSDL::RemoveOverlay(MOverlay& aOverlay)
1036 {
1037         if(gEpocEnv && gEpocEnv->iDsa)
1038         {
1039                 return gEpocEnv->iDsa->RemoveOverlay(aOverlay);
1040         }
1041         return KErrNotReady;
1042 }
1043
1044 EXPORT_C TInt CSDL::RedrawRequest()
1045 {
1046         if(gEpocEnv && gEpocEnv->iDsa)
1047         {
1048                 const TInt err =  gEpocEnv->iDsa->RedrawRequest();
1049                 EnvUtils::RunSingleThread();
1050                 return err;
1051         }
1052         return KErrNotReady;
1053 }
1054
1055 void EnvUtils::DisableKeyBlocking()
1056 {
1057         if(gEpocEnv->iAppUi != NULL)
1058                 return CCurrentAppUi::Cast(gEpocEnv->iAppUi)->DisableKeyBlocking();
1059 }
1060
1061 TBool EnvUtils::Rendezvous(RThread& aThread, TRequestStatus& aStatus)
1062 {
1063         if(gEpocEnv->iId != TThreadId(0) &&
1064                         aThread.Open(gEpocEnv->iId) &&
1065                         aThread.ExitType() == EExitPending)
1066         {
1067                 aThread.Rendezvous(aStatus);
1068                 return ETrue;
1069         }
1070         return EFalse;
1071 }
1072
1073 void* SDL_LoadObject(const char *sofile)
1074 {
1075         RLibrary* lib = new RLibrary();
1076         if(lib == NULL)
1077                 return NULL;
1078         TFileName name;
1079         name.Copy(TPtrC8((const TUint8*)sofile));
1080         if(KErrNone == lib->Load(name))
1081                 return lib;
1082         delete lib;
1083         return NULL;
1084 }
1085
1086 void* SDL_LoadFunction(void *handle, const char *name)
1087 {
1088         TLex8 v((const TUint8*)(name));
1089         TInt ord;
1090
1091         if(KErrNone != v.Val(ord))
1092                 return NULL;
1093
1094         const RLibrary* lib = reinterpret_cast<RLibrary*>(handle);
1095         TLibraryFunction f = lib->Lookup(ord);
1096         return (void*)(f);
1097 }
1098
1099 void SDL_UnloadObject(void *handle)
1100 {
1101         RLibrary* lib = reinterpret_cast<RLibrary*>(handle);
1102         lib->Close();
1103         delete lib;
1104 }