src/main/symbian/SDL_main.cpp

   1 extern "C" {
   2 #include "SDL_events_c.h"
   3 }
   4 #include "epoc_sdl.h"
   5 #include "sdlepocapi.h"
   6 #include <e32base.h>
   7 #include <estlib.h>
   8 #include <stdio.h>
   9 #include <badesca.h>
  10 #include <w32std.h>
  11 #include <aknappui.h>
  12 #include <aknapp.h>
  13 #include "SDL_epocevents_c.h"
  14 #include "SDL_keysym.h"
  15 #include "dsa.h"
  16 #include "SDL_loadso.h"
  17 #include <remconcoreapitargetobserver.h>
  18 #include <remconinterfaceselector.h>
  19 #include <remconcoreapitarget.h>
  20
  21 class CCurrentAppUi;
  22 class CEikonEnv;
  23 class CSdlAppServ;
  24 class CEventQueue;
  25
  26 class EpocSdlEnvData
  27 {
  28         public:
  29                 void Free();
  30                 void Delete();
  31                 CEventQueue*            iEventQueue;
  32                 CDsa*                   iDsa;
  33                 CSdlAppServ*            iAppSrv;
  34                 CArrayFix<TSdlCleanupItem>* iCleanupItems;
  35                 CSDL*                   iSdl;
  36                 bool                    iWaitingForOrientationChange;
  37
  38                 TSize                   iSize;
  39                 TDisplayMode            iMode;
  40 };
  41
  42 EpocSdlEnvData* gEpocEnv;
  43
  44 static void RunSingleThread()
  45 {
  46         if(RThread().RequestCount() > 0)
  47         {
  48                 int err;
  49                 if(CActiveScheduler::RunIfReady(err, CActive::EPriorityIdle))
  50                 {
  51                         CActiveScheduler::Current()->WaitForAnyRequest();
  52                 }
  53         }
  54 }
  55
  56 int Panic(int aErr, int aLine)
  57 {
  58         TBuf<64> b;
  59         b.Format(_L("Main at %d"), aLine);
  60         User::Panic(b, aErr);
  61         return 0;
  62 }
  63
  64
  65 bool CEventQueue::HasData()
  66 {
  67         RunSingleThread();
  68         return !m_queue.empty();
  69 }
  70
  71 const TWsEvent CEventQueue::Shift()
  72 {
  73         const TWsEvent event = m_queue.front();
  74         m_queue.pop();
  75         return event;
  76 }
  77
  78
  79 TSdlCleanupItem::TSdlCleanupItem(TSdlCleanupOperation aOperation, void* aItem) :
  80         iOperation(aOperation), iItem(aItem), iThread(RThread().Id())
  81 {}
  82
  83 #define MAINFUNC(x) TMainFunc::TMainFunc(mainfunc##x aFunc){Mem::FillZ(iMainFunc, sizeof(iMainFunc)); iMainFunc[x - 1] = (void*) aFunc;}
  84
  85 MAINFUNC(1)
  86 MAINFUNC(2)
  87 MAINFUNC(3)
  88 MAINFUNC(4)
  89 MAINFUNC(5)
  90 MAINFUNC(6)
  91
  92 TMainFunc::TMainFunc()
  93 {
  94         Mem::FillZ(iMainFunc, sizeof(iMainFunc));
  95 }
  96
  97 const void* TMainFunc::operator[](int aIndex) const
  98 {
  99         return iMainFunc[aIndex];
 100 }
 101
 102 class CSdlAppServ : public CActive
 103 {
 104         public:
 105                 enum
 106                 {
 107                         EAppSrvDsaStatus,
 108                 };
 109                 CSdlAppServ();
 110                 void ConstructL();
 111                 ~CSdlAppServ();
 112                 int Request(int aService);
 113                 void Init();
 114                 void SetParam(int aParam);
 115
 116         private:
 117                 void RunL();
 118                 void DoCancel();
 119                 const TThreadId iMainId;
 120                 RThread iAppThread;
 121                 int iService;
 122                 int iReturnValue;
 123                 TRequestStatus* iStatusPtr;
 124 };
 125
 126 CSdlAppServ::CSdlAppServ() : CActive(CActive::EPriorityHigh), iMainId(RThread().Id())
 127 {}
 128
 129 void CSdlAppServ::ConstructL()
 130 {
 131         CActiveScheduler::Add(this);
 132         iStatus = KRequestPending;
 133         iStatusPtr = &iStatus;
 134         SetActive();
 135 }
 136
 137 CSdlAppServ::~CSdlAppServ()
 138 {
 139         Cancel();
 140         iAppThread.Close();
 141 }
 142
 143 int CSdlAppServ::Request(int aService)
 144 {
 145         RunSingleThread();
 146         iService = aService;
 147         iAppThread.RequestComplete(iStatusPtr, KErrNone);
 148         return KErrNone;
 149 }
 150
 151 void CSdlAppServ::Init()
 152 {
 153         PANIC_IF_ERROR(iAppThread.Open(iMainId));
 154 }
 155
 156 void CSdlAppServ::SetParam(int aParam)
 157 {
 158         iReturnValue = aParam;
 159 }
 160
 161 void CSdlAppServ::RunL()
 162 {
 163         if(iStatus == KErrNone)
 164         {
 165                 switch(iService)
 166                 {
 167                         case EAppSrvDsaStatus:
 168                                 if(gEpocEnv->iDsa != NULL)
 169                                         gEpocEnv->iDsa->Stop();
 170                                 iReturnValue = KErrNone;
 171                                 break;
 172
 173                         default:
 174                                 PANIC(KErrNotSupported);
 175                                 break;
 176                 }
 177
 178                 iStatus = KRequestPending;
 179                 iStatusPtr = &iStatus;
 180                 SetActive();
 181         }
 182 }
 183
 184 void CSdlAppServ::DoCancel()
 185 {
 186         TRequestStatus* s = &iStatus;
 187         iAppThread.RequestComplete(s, KErrCancel);
 188 }
 189
 190 CEventQueue& EpocSdlEnv::EventQueue()
 191 {
 192         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 193         return *gEpocEnv->iEventQueue;
 194 }
 195
 196 TBool EpocSdlEnv::IsDsaAvailable()
 197 {
 198         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 199         return gEpocEnv->iDsa != NULL && gEpocEnv->iDsa->IsDsaAvailable();
 200 }
 201
 202 int EpocSdlEnv::AllocSurface(const TSize& aSize, TDisplayMode aMode)
 203 {
 204         return gEpocEnv->iDsa->AllocSurface(aSize, aMode);
 205 }
 206
 207 void EpocSdlEnv::UnlockHwSurface()
 208 {
 209         gEpocEnv->iDsa->UnlockHwSurface();
 210 }
 211
 212 TUint8* EpocSdlEnv::LockHwSurface()
 213 {
 214         return gEpocEnv->iDsa->LockHwSurface();
 215 }
 216
 217 void EpocSdlEnv::UpdateSwSurface()
 218 {
 219         gEpocEnv->iDsa->UpdateSwSurface();
 220 }
 221
 222 TBool EpocSdlEnv::AddUpdateRect(TUint8* aAddress, const TRect& aUpdateRect, const TRect& aRect)
 223 {
 224         return gEpocEnv->iDsa->AddUpdateRect(aAddress, aUpdateRect, aRect);
 225 }
 226
 227 void EpocSdlEnv::Request(int aService)
 228 {
 229         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 230         gEpocEnv->iAppSrv->Request(aService);
 231 }
 232
 233 TDisplayMode EpocSdlEnv::DisplayMode()
 234 {
 235         return gEpocEnv->iDsa == NULL ? ENone : gEpocEnv->iDsa->DisplayMode();
 236 }
 237
 238 int EpocSdlEnv::SetPalette(int aFirstcolor, int aColorCount, TUint32* aPalette)
 239 {
 240         return  gEpocEnv->iDsa->SetPalette(aFirstcolor, aColorCount, aPalette);
 241 }
 242
 243 int EpocSdlEnv::AppendCleanupItem(const TSdlCleanupItem& aItem)
 244 {
 245         TRAPD(err, gEpocEnv->iCleanupItems->AppendL(aItem));
 246         return err;
 247 }
 248
 249 void EpocSdlEnv::RemoveCleanupItem(void* aItem)
 250 {
 251         for(int i = 0; i < gEpocEnv->iCleanupItems->Count(); i++)
 252         {
 253                 if(gEpocEnv->iCleanupItems->At(i).iItem == aItem)
 254                         gEpocEnv->iCleanupItems->Delete(i);
 255         }
 256 }
 257
 258 void EpocSdlEnv::CleanupItems()
 259 {
 260         const TThreadId id = RThread().Id();
 261         int last = gEpocEnv->iCleanupItems->Count() - 1;
 262         int i;
 263
 264         for(i = last; i >= 0 ; i--)
 265         {
 266                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 267                 if(item.iThread == id)
 268                 {
 269                         item.iThread = TThreadId(0);
 270                         item.iOperation(item.iItem);
 271                 }
 272         }
 273
 274         last = gEpocEnv->iCleanupItems->Count() - 1;
 275
 276         for(i = last; i >= 0 ; i--)
 277         {
 278                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 279                 if(item.iThread == TThreadId(0))
 280                 {
 281                         gEpocEnv->iCleanupItems->Delete(i);
 282                 }
 283         }
 284 }
 285
 286 void EpocSdlEnv::FreeSurface()
 287 {
 288         Request(CSdlAppServ::EAppSrvDsaStatus);
 289         if(gEpocEnv->iDsa != NULL)
 290                 gEpocEnv->iDsa->Free();
 291 }
 292
 293 void EpocSdlEnvData::Free()
 294 {
 295         if(iDsa != NULL)
 296                 iDsa->Free();
 297 }
 298
 299 void EpocSdlEnvData::Delete()
 300 {
 301         delete iEventQueue;
 302
 303         if(iDsa != NULL)
 304                 iDsa->Free();
 305
 306         delete iDsa;
 307         delete iAppSrv;
 308 }
 309
 310 static int MainL()
 311 {
 312         gEpocEnv->iCleanupItems = new CArrayFixFlat<TSdlCleanupItem>(8);
 313
 314         char** envp = 0;
 315         char** argv = new char*[1];
 316         argv[0] = new char[8];
 317         strcpy(argv[0], "app.exe");
 318
 319         TMainFunc iMain = SDL_main;
 320
 321         /* !! process exits here if there is "exit()" in main! */
 322         int ret = 0;
 323         for(int i = 0; i < 6; i++)
 324         {
 325                 void* f = (void*) iMain[i];
 326                 if(f != NULL)
 327                 {
 328                         switch(i)
 329                         {
 330                                 case 0:
 331                                         ret = ((mainfunc1)f)();
 332                                         break;
 333
 334                                 case 3:
 335                                         ((mainfunc1)f)();
 336                                         break;
 337
 338                                 case 1:
 339                                         ret = ((mainfunc2)f)(1, argv);
 340                                         break;
 341
 342                                 case 4:
 343                                         ((mainfunc2)f)(1, argv);
 344                                         break;
 345
 346                                 case 2:
 347                                         ret = ((mainfunc3)f)(1, argv, envp);
 348                                         break;
 349
 350                                 case 5:
 351                                         ((mainfunc3)f)(1, argv, envp);
 352                                         break;
 353
 354                                 default:
 355                                         break;
 356                         }
 357
 358                         delete[] argv[0];
 359                         delete[] argv;
 360                         return ret;
 361                 }
 362         }
 363
 364         PANIC(KErrNotFound);
 365         return 0;
 366 }
 367
 368 static int DoMain()
 369 {
 370         gEpocEnv->iAppSrv->Init();
 371
 372         TRAPD(err, err = MainL());
 373
 374         // Free resources and return
 375         EpocSdlEnv::CleanupItems();
 376
 377         gEpocEnv->iCleanupItems->Reset();
 378         delete gEpocEnv->iCleanupItems;
 379         gEpocEnv->iCleanupItems = NULL;
 380
 381         gEpocEnv->Free(); //free up in thread resources
 382
 383         return err;
 384 }
 385
 386 CSDL::CSDL()
 387 {
 388         __ASSERT_ALWAYS(gEpocEnv == NULL, PANIC(KErrAlreadyExists));
 389         gEpocEnv = new EpocSdlEnvData;
 390         Mem::FillZ(gEpocEnv, sizeof(EpocSdlEnvData));
 391
 392         gEpocEnv->iEventQueue = new CEventQueue();
 393         gEpocEnv->iAppSrv = new CSdlAppServ();
 394
 395         gEpocEnv->iSdl = this;
 396 }
 397
 398 CSDL::~CSDL()
 399 {
 400         gEpocEnv->Free();
 401         gEpocEnv->Delete();
 402
 403         delete gEpocEnv;
 404         gEpocEnv = NULL;
 405 }
 406
 407 void CSDL::SetContainerWindowL(RWindow& aWindow, RWsSession& aSession, CWsScreenDevice& aDevice)
 408 {
 409         if(gEpocEnv->iDsa == NULL)
 410                 gEpocEnv->iDsa = CDsa::CreateL(aSession);
 411         gEpocEnv->iDsa->ConstructL(aWindow, aDevice);
 412 }
 413
 414 int EpocSdlEnv::ApplyGlesDsa()
 415 {
 416         CDsa* dsa = NULL;
 417         TRAPD(err, dsa = gEpocEnv->iDsa->CreateGlesDsaL());
 418         gEpocEnv->iDsa = dsa;
 419         return err;
 420 }
 421
 422 RWindow* EpocSdlEnv::Window()
 423 {
 424         return gEpocEnv->iDsa->Window();
 425 }
 426
 427 void EpocSdlEnv::UpdateWholeScreen(bool val)
 428 {
 429         gEpocEnv->iDsa->m_updateWholeScreen = val;
 430 }
 431
 432 bool EpocSdlEnv::GetUpdateWholeScreen()
 433 {
 434         return gEpocEnv->iDsa->m_updateWholeScreen;
 435 }
 436
 437 void EpocSdlEnv::SetOrientation(CAknAppUi::TAppUiOrientation orientation, const TSize& aSize, TDisplayMode aMode)
 438 {
 439         gEpocEnv->iWaitingForOrientationChange = true;
 440         gEpocEnv->iSize = aSize;
 441         gEpocEnv->iMode = aMode;
 442
 443         TRAPD(err, static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->SetOrientationL(orientation));
 444 }
 445
 446 void CSDL::CallMainL()
 447 {
 448         ASSERT(gEpocEnv != NULL);
 449
 450         gEpocEnv->iAppSrv->ConstructL();
 451
 452         // for handling volume up/down keys
 453         CRemConInterfaceSelector *iSelector = CRemConInterfaceSelector::NewL();
 454         CRemConCoreApiTarget::NewL( *iSelector, *this );
 455         iSelector->OpenTargetL();
 456
 457         // when priority is not lowered screen updates much more frequently, which
 458         // may be undesired, for example in case of openttd's generating world dialog
 459         RThread().SetPriority(EPriorityLess);
 460         DoMain();
 461 }
 462
 463 void CSDL::AppendWsEvent(const TWsEvent& aEvent)
 464 {
 465         EpocSdlEnv::EventQueue().Append(aEvent);
 466 }
 467
 468 void CSDL::Resize()
 469 {
 470         if(gEpocEnv->iWaitingForOrientationChange)
 471         {
 472                 EpocSdlEnv::AllocSurface(gEpocEnv->iSize, gEpocEnv->iMode);
 473                 gEpocEnv->iWaitingForOrientationChange = false;
 474         }
 475         else
 476         {
 477                 TSize size = gEpocEnv->iDsa->Window()->Size();
 478                 SDL_PrivateResize(size.iWidth, size.iHeight);
 479         }
 480 }
 481
 482 void CSDL::MrccatoCommand(TRemConCoreApiOperationId aOperationId, TRemConCoreApiButtonAction aButtonAct)
 483 {
 484         if(aButtonAct != ERemConCoreApiButtonClick)
 485                 return;
 486
 487         TWsEvent event;
 488         event.SetType(EEventKey);
 489         event.SetTimeNow();
 490
 491         switch(aOperationId)
 492         {
 493         case ERemConCoreApiVolumeDown:
 494                 event.Key()->iScanCode = EStdKeyDecVolume;
 495                 event.SetType(EEventKeyDown);
 496                 AppendWsEvent(event);
 497                 event.SetType(EEventKeyUp);
 498                 AppendWsEvent(event);
 499                 break;
 500
 501         case ERemConCoreApiVolumeUp:
 502                 event.Key()->iScanCode = EStdKeyIncVolume;
 503                 event.SetType(EEventKeyDown);
 504                 AppendWsEvent(event);
 505                 event.SetType(EEventKeyUp);
 506                 AppendWsEvent(event);
 507                 break;
 508
 509         default:
 510                 break;
 511         }
 512 }