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