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                 CSdlAppServ() : CActive(CActive::EPriorityIdle)
 106                 {
 107                         CActiveScheduler::Add(this);
 108                         SetActive();
 109                 }
 110                 ~CSdlAppServ() { Cancel(); }
 111                 void Request()
 112                 {
 113                         TRequestStatus* status = &iStatus;
 114                         User::RequestComplete(status, KErrNone);
 115                 }
 116
 117         private:
 118                 void RunL() {}
 119                 void DoCancel()
 120                 {
 121                         TRequestStatus* status = &iStatus;
 122                         User::RequestComplete(status, KErrCancel);
 123                 }
 124 };
 125
 126 CEventQueue& EpocSdlEnv::EventQueue()
 127 {
 128         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 129         return *gEpocEnv->iEventQueue;
 130 }
 131
 132 TBool EpocSdlEnv::IsDsaAvailable()
 133 {
 134         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 135         return gEpocEnv->iDsa != NULL && gEpocEnv->iDsa->IsDsaAvailable();
 136 }
 137
 138 int EpocSdlEnv::AllocSurface(const TSize& aSize, TDisplayMode aMode)
 139 {
 140         return gEpocEnv->iDsa->AllocSurface(aSize, aMode);
 141 }
 142
 143 void EpocSdlEnv::UnlockHwSurface()
 144 {
 145         gEpocEnv->iDsa->UnlockHwSurface();
 146 }
 147
 148 TUint8* EpocSdlEnv::LockHwSurface()
 149 {
 150         return gEpocEnv->iDsa->LockHwSurface();
 151 }
 152
 153 void EpocSdlEnv::UpdateSwSurface()
 154 {
 155         gEpocEnv->iDsa->UpdateSwSurface();
 156 }
 157
 158 TBool EpocSdlEnv::AddUpdateRect(TUint8* aAddress, const TRect& aUpdateRect, const TRect& aRect)
 159 {
 160         return gEpocEnv->iDsa->AddUpdateRect(aAddress, aUpdateRect, aRect);
 161 }
 162
 163 TDisplayMode EpocSdlEnv::DisplayMode()
 164 {
 165         return gEpocEnv->iDsa == NULL ? ENone : gEpocEnv->iDsa->DisplayMode();
 166 }
 167
 168 int EpocSdlEnv::SetPalette(int aFirstcolor, int aColorCount, TUint32* aPalette)
 169 {
 170         return  gEpocEnv->iDsa->SetPalette(aFirstcolor, aColorCount, aPalette);
 171 }
 172
 173 int EpocSdlEnv::AppendCleanupItem(const TSdlCleanupItem& aItem)
 174 {
 175         TRAPD(err, gEpocEnv->iCleanupItems->AppendL(aItem));
 176         return err;
 177 }
 178
 179 void EpocSdlEnv::RemoveCleanupItem(void* aItem)
 180 {
 181         for(int i = 0; i < gEpocEnv->iCleanupItems->Count(); i++)
 182         {
 183                 if(gEpocEnv->iCleanupItems->At(i).iItem == aItem)
 184                         gEpocEnv->iCleanupItems->Delete(i);
 185         }
 186 }
 187
 188 void EpocSdlEnv::CleanupItems()
 189 {
 190         const TThreadId id = RThread().Id();
 191         int last = gEpocEnv->iCleanupItems->Count() - 1;
 192         int i;
 193
 194         for(i = last; i >= 0 ; i--)
 195         {
 196                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 197                 if(item.iThread == id)
 198                 {
 199                         item.iThread = TThreadId(0);
 200                         item.iOperation(item.iItem);
 201                 }
 202         }
 203
 204         last = gEpocEnv->iCleanupItems->Count() - 1;
 205
 206         for(i = last; i >= 0 ; i--)
 207         {
 208                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 209                 if(item.iThread == TThreadId(0))
 210                 {
 211                         gEpocEnv->iCleanupItems->Delete(i);
 212                 }
 213         }
 214 }
 215
 216 void EpocSdlEnv::FreeSurface()
 217 {
 218         gEpocEnv->iAppSrv->Request();
 219
 220         if(gEpocEnv->iDsa != NULL)
 221         {
 222                 gEpocEnv->iDsa->Stop();
 223                 gEpocEnv->iDsa->Free();
 224         }
 225 }
 226
 227 void EpocSdlEnvData::Free()
 228 {
 229         if(iDsa != NULL)
 230                 iDsa->Free();
 231 }
 232
 233 void EpocSdlEnvData::Delete()
 234 {
 235         delete iEventQueue;
 236
 237         if(iDsa != NULL)
 238                 iDsa->Free();
 239
 240         delete iDsa;
 241         delete iAppSrv;
 242 }
 243
 244 static int MainL()
 245 {
 246         gEpocEnv->iCleanupItems = new CArrayFixFlat<TSdlCleanupItem>(8);
 247
 248         char** envp = 0;
 249         char** argv = new char*[1];
 250         argv[0] = new char[8];
 251         strcpy(argv[0], "app.exe");
 252
 253         TMainFunc iMain = SDL_main;
 254
 255         /* !! process exits here if there is "exit()" in main! */
 256         int ret = 0;
 257         for(int i = 0; i < 6; i++)
 258         {
 259                 void* f = (void*) iMain[i];
 260                 if(f != NULL)
 261                 {
 262                         switch(i)
 263                         {
 264                                 case 0:
 265                                         ret = ((mainfunc1)f)();
 266                                         break;
 267
 268                                 case 3:
 269                                         ((mainfunc1)f)();
 270                                         break;
 271
 272                                 case 1:
 273                                         ret = ((mainfunc2)f)(1, argv);
 274                                         break;
 275
 276                                 case 4:
 277                                         ((mainfunc2)f)(1, argv);
 278                                         break;
 279
 280                                 case 2:
 281                                         ret = ((mainfunc3)f)(1, argv, envp);
 282                                         break;
 283
 284                                 case 5:
 285                                         ((mainfunc3)f)(1, argv, envp);
 286                                         break;
 287
 288                                 default:
 289                                         break;
 290                         }
 291
 292                         delete[] argv[0];
 293                         delete[] argv;
 294                         return ret;
 295                 }
 296         }
 297
 298         PANIC(KErrNotFound);
 299         return 0;
 300 }
 301
 302 static int DoMain()
 303 {
 304         TRAPD(err, err = MainL());
 305
 306         // Free resources and return
 307         EpocSdlEnv::CleanupItems();
 308
 309         gEpocEnv->iCleanupItems->Reset();
 310         delete gEpocEnv->iCleanupItems;
 311         gEpocEnv->iCleanupItems = NULL;
 312
 313         gEpocEnv->Free(); //free up in thread resources
 314
 315         return err;
 316 }
 317
 318 CSDL::CSDL()
 319 {
 320         __ASSERT_ALWAYS(gEpocEnv == NULL, PANIC(KErrAlreadyExists));
 321         gEpocEnv = new EpocSdlEnvData;
 322         Mem::FillZ(gEpocEnv, sizeof(EpocSdlEnvData));
 323
 324         gEpocEnv->iEventQueue = new CEventQueue();
 325         gEpocEnv->iAppSrv = new CSdlAppServ();
 326
 327         gEpocEnv->iSdl = this;
 328 }
 329
 330 CSDL::~CSDL()
 331 {
 332         gEpocEnv->Free();
 333         gEpocEnv->Delete();
 334
 335         delete gEpocEnv;
 336         gEpocEnv = NULL;
 337 }
 338
 339 void CSDL::SetContainerWindowL(RWindow& aWindow, RWsSession& aSession, CWsScreenDevice& aDevice)
 340 {
 341         if(gEpocEnv->iDsa == NULL)
 342                 gEpocEnv->iDsa = CDsa::CreateL(aSession);
 343         gEpocEnv->iDsa->ConstructL(aWindow, aDevice);
 344 }
 345
 346 int EpocSdlEnv::ApplyGlesDsa()
 347 {
 348         CDsa* dsa = NULL;
 349         TRAPD(err, dsa = gEpocEnv->iDsa->CreateGlesDsaL());
 350         gEpocEnv->iDsa = dsa;
 351         return err;
 352 }
 353
 354 RWindow* EpocSdlEnv::Window()
 355 {
 356         return gEpocEnv->iDsa->Window();
 357 }
 358
 359 void EpocSdlEnv::UpdateWholeScreen(bool val)
 360 {
 361         gEpocEnv->iDsa->m_updateWholeScreen = val;
 362 }
 363
 364 bool EpocSdlEnv::GetUpdateWholeScreen()
 365 {
 366         return gEpocEnv->iDsa->m_updateWholeScreen;
 367 }
 368
 369 void EpocSdlEnv::SetOrientation(CAknAppUi::TAppUiOrientation orientation, const TSize& aSize, TDisplayMode aMode)
 370 {
 371         gEpocEnv->iWaitingForOrientationChange = true;
 372         gEpocEnv->iSize = aSize;
 373         gEpocEnv->iMode = aMode;
 374
 375         TRAPD(err, static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->SetOrientationL(orientation));
 376 }
 377
 378 void CSDL::CallMainL()
 379 {
 380         ASSERT(gEpocEnv != NULL);
 381
 382         // for handling volume up/down keys
 383         CRemConInterfaceSelector *iSelector = CRemConInterfaceSelector::NewL();
 384         CRemConCoreApiTarget::NewL( *iSelector, *this );
 385         iSelector->OpenTargetL();
 386
 387         // when priority is not lowered screen updates much more frequently, which
 388         // may be undesired, for example in case of openttd's generating world dialog
 389         RThread().SetPriority(EPriorityLess);
 390         DoMain();
 391 }
 392
 393 void CSDL::AppendWsEvent(const TWsEvent& aEvent)
 394 {
 395         EpocSdlEnv::EventQueue().Append(aEvent);
 396 }
 397
 398 void CSDL::Resize()
 399 {
 400         if(gEpocEnv->iWaitingForOrientationChange)
 401         {
 402                 EpocSdlEnv::AllocSurface(gEpocEnv->iSize, gEpocEnv->iMode);
 403                 gEpocEnv->iWaitingForOrientationChange = false;
 404         }
 405         else
 406         {
 407                 TSize size = gEpocEnv->iDsa->Window()->Size();
 408                 SDL_PrivateResize(size.iWidth, size.iHeight);
 409         }
 410 }
 411
 412 void CSDL::MrccatoCommand(TRemConCoreApiOperationId aOperationId, TRemConCoreApiButtonAction aButtonAct)
 413 {
 414         if(aButtonAct != ERemConCoreApiButtonClick)
 415                 return;
 416
 417         TWsEvent event;
 418         event.SetType(EEventKey);
 419         event.SetTimeNow();
 420
 421         switch(aOperationId)
 422         {
 423         case ERemConCoreApiVolumeDown:
 424                 event.Key()->iScanCode = EStdKeyDecVolume;
 425                 event.SetType(EEventKeyDown);
 426                 AppendWsEvent(event);
 427                 event.SetType(EEventKeyUp);
 428                 AppendWsEvent(event);
 429                 break;
 430
 431         case ERemConCoreApiVolumeUp:
 432                 event.Key()->iScanCode = EStdKeyIncVolume;
 433                 event.SetType(EEventKeyDown);
 434                 AppendWsEvent(event);
 435                 event.SetType(EEventKeyUp);
 436                 AppendWsEvent(event);
 437                 break;
 438
 439         default:
 440                 break;
 441         }
 442 }