|
3975
|
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
|
