diff options
Diffstat (limited to 'apps/plugins/sdl/src/main/symbian/EKA2/SDL_main.cpp')
-rw-r--r-- | apps/plugins/sdl/src/main/symbian/EKA2/SDL_main.cpp | 1035 |
1 files changed, 0 insertions, 1035 deletions
diff --git a/apps/plugins/sdl/src/main/symbian/EKA2/SDL_main.cpp b/apps/plugins/sdl/src/main/symbian/EKA2/SDL_main.cpp deleted file mode 100644 index 3dc69d4aad..0000000000 --- a/apps/plugins/sdl/src/main/symbian/EKA2/SDL_main.cpp +++ /dev/null | |||
@@ -1,1035 +0,0 @@ | |||
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 | |||