src/main/symbian/EKA2/sdlexe.cpp

   1 //  INCLUDES
   2 #include <aknapp.h>
   3 #include <aknappui.h>
   4 #include <eikdoc.h>
   5 #include <sdlepocapi.h>
   6 #include <bautils.h>
   7 #include <eikstart.h>
   8 #include <badesca.h>
   9 #include <bautils.h>
  10 #include <apgcli.h>
  11 #include <sdlmain.h>
  12 #include <eikedwin.h>
  13 #include <eiklabel.h>
  14 #include <sdlexe.rsg>
  15 #include <aknglobalmsgquery.h>
  16 #include <apgwgnam.h>
  17
  18
  19
  20 //  FORWARD DECLARATIONS
  21 class CApaDocument;
  22
  23
  24 //const TUid KSDLUID = { 0xF01F605E };
  25
  26 LOCAL_C void MakeCCmdLineL(const TDesC8& aParam, CDesC8Array& aArray)
  27     {
  28
  29     const TChar dq('\"');
  30
  31     TLex8 lex(aParam);
  32     TBool in = EFalse;
  33
  34     lex.SkipSpaceAndMark();
  35
  36     while(!lex.Eos())
  37         {
  38         TPtrC8 ptr;
  39         if(in)
  40             {
  41             const TPtrC8 rem = lex.RemainderFromMark();
  42             const TInt pos = rem.Locate(dq);
  43             if(pos > 0)
  44                 {
  45                 lex.Inc(pos);
  46                 ptr.Set(lex.MarkedToken());
  47                 lex.SkipAndMark(1);
  48                 }
  49             else
  50                 {
  51                 ptr.Set(rem);
  52                 }
  53             in = EFalse;
  54             }
  55         else
  56             {
  57             ptr.Set(lex.NextToken());
  58             const TInt pos = ptr.Locate(dq);
  59             if(pos == 0)
  60                 {
  61                 lex.UnGetToMark();
  62                 lex.SkipAndMark(1);
  63                 in = ETrue;
  64                 continue; // back to in brace
  65                 }
  66             else
  67                 lex.SkipSpaceAndMark();
  68             }
  69
  70         aArray.AppendL(ptr);
  71
  72         }
  73     }
  74
  75 NONSHARABLE_CLASS(TVirtualCursor) : public MOverlay
  76         {
  77         public:
  78                 TVirtualCursor();
  79                 void Set(const TRect& aRect, CFbsBitmap* aBmp, CFbsBitmap* aAlpha);
  80                 void Move(TInt aX, TInt aY);
  81                 void MakeEvent(TWsEvent& aEvent, const TPoint& aBasePos) const;
  82                 void Toggle();
  83                 TBool IsOn() const;
  84         private:
  85         void Draw(CBitmapContext& aGc, const TRect& aTargetRect, const TSize& aSize);
  86         private:
  87                 TRect iRect;
  88                 TPoint iInc;
  89                 TPoint iPos;
  90                 TBool iIsOn;
  91                 CFbsBitmap* iCBmp;
  92                 CFbsBitmap* iAlpha;
  93         };
  94
  95
  96 TVirtualCursor::TVirtualCursor() :  iInc(0, 0), iIsOn(EFalse), iCBmp(NULL)
  97         {
  98         }
  99
 100 const TInt KMaxMove = 10;
 101
 102 void TVirtualCursor::Move(TInt aX, TInt aY)
 103         {
 104         if(aX > 0 && iInc.iX > 0)
 105                         ++iInc.iX;
 106         else if(aX < 0 && iInc.iX < 0)
 107                         --iInc.iX;
 108         else
 109                 iInc.iX = aX;
 110
 111         if(aY > 0 && iInc.iY > 0)
 112                         ++iInc.iY;
 113         else if(aY < 0 && iInc.iY < 0)
 114                         --iInc.iY;
 115         else
 116                         iInc.iY = aY;
 117
 118         iInc.iX = Min(KMaxMove, iInc.iX);
 119
 120         iInc.iX = Max(-KMaxMove, iInc.iX);
 121
 122         iInc.iY = Min(KMaxMove, iInc.iY);
 123
 124         iInc.iY =Max(-KMaxMove, iInc.iY);
 125
 126         const TPoint pos = iPos + iInc;
 127         if(iRect.Contains(pos))
 128                 {
 129                 iPos = pos;
 130                 }
 131         else
 132                 {
 133                 iInc = TPoint(0, 0);
 134                 }
 135         }
 136
 137
 138 void TVirtualCursor::Toggle()
 139         {
 140         iIsOn = !iIsOn;
 141         }
 142
 143
 144 TBool TVirtualCursor::IsOn() const
 145         {
 146         return iIsOn;
 147         }
 148
 149 void TVirtualCursor::Set(const TRect& aRect, CFbsBitmap* aBmp, CFbsBitmap* aAlpha)
 150         {
 151         iRect = aRect;
 152         iCBmp = aBmp;
 153         iAlpha = aAlpha;
 154         }
 155
 156
 157 void TVirtualCursor::MakeEvent(TWsEvent& aEvent, const TPoint& aBasePos) const
 158         {
 159         aEvent.SetType(EEventPointer),
 160         aEvent.SetTimeNow();
 161         TPointerEvent& pointer = *aEvent.Pointer();
 162         pointer.iType = TPointerEvent::EButton1Down;
 163         pointer.iPosition = iPos;
 164         pointer.iParentPosition = aBasePos;
 165         }
 166
 167
 168 void TVirtualCursor::Draw(CBitmapContext& aGc, const TRect& /*aTargetRect*/, const TSize& /*aSize*/)
 169         {
 170         if(iIsOn && iCBmp != NULL)
 171                 {
 172                 const TRect rect(TPoint(0, 0), iCBmp->SizeInPixels());
 173                 aGc.AlphaBlendBitmaps(iPos, iCBmp, rect, iAlpha, TPoint(0, 0));
 174                 }
 175
 176         }
 177
 178 NONSHARABLE_CLASS(TSdlClass)
 179         {
 180         public:
 181                 TSdlClass();
 182                 void SetMain(const TMainFunc& aFunc, TInt aFlags, MSDLMainObs* aObs, TInt aExeFlags);
 183                 TInt SdlFlags() const;
 184                 const TMainFunc& Main() const;
 185                 void SendEvent(TInt aEvent, TInt aParam, CSDL* aSDL);
 186                 TInt AppFlags() const;
 187                 void AppFlags(TInt aFlags);
 188         private:
 189                 TMainFunc iFunc;
 190                 TInt iSdlFlags;
 191                 TInt iExeFlags;
 192                 MSDLMainObs* iObs;
 193         };
 194
 195
 196 void TSdlClass::AppFlags(TInt aFlags)
 197         {
 198         iExeFlags |= aFlags;
 199         }
 200
 201 void TSdlClass::SendEvent(TInt aEvent, TInt aParam, CSDL* aSDL)
 202         {
 203         if(iObs != NULL)
 204                 iObs->SDLMainEvent(aEvent, aParam, aSDL);
 205         }
 206
 207 TInt TSdlClass::AppFlags() const
 208         {
 209         return iExeFlags;
 210         }
 211
 212 void TSdlClass::SetMain(const TMainFunc& aFunc, TInt aFlags, MSDLMainObs* aObs, TInt aExeFlags)
 213         {
 214         iFunc = aFunc;
 215         iSdlFlags = aFlags;
 216         iExeFlags = aExeFlags;
 217         iObs = aObs;
 218         }
 219
 220 const TMainFunc& TSdlClass::Main() const
 221         {
 222         return iFunc;
 223         }
 224
 225
 226  TInt TSdlClass::SdlFlags() const
 227         {
 228         return iSdlFlags;
 229         }
 230
 231
 232
 233 TSdlClass::TSdlClass()
 234         {
 235         Mem::FillZ(this, sizeof(this));
 236         }
 237
 238 TSdlClass gSDLClass;
 239
 240
 241 ////////////////////////////////////////////////////////////////
 242
 243 NONSHARABLE_CLASS(CSDLApplication) : public CAknApplication
 244     {
 245     public:
 246         CSDLApplication();
 247     private:
 248         CApaDocument* CreateDocumentL();
 249         TFileName ResourceFileName() const;
 250         TUid AppDllUid() const;
 251                 void FindMeL();
 252                 TUid iUid;
 253     };
 254
 255 NONSHARABLE_CLASS(CSDLDocument)  : public CEikDocument
 256     {
 257     public:
 258         CSDLDocument(CEikApplication& aApp);
 259      private:
 260         CEikAppUi* CreateAppUiL();
 261
 262      };
 263
 264  ////////////////////////////////////////////////////////////////////
 265
 266
 267 NONSHARABLE_CLASS(MExitWait)
 268         {
 269         public:
 270                 virtual void DoExit(TInt aErr) = 0;
 271         };
 272
 273 /////////////////////////////////////////////////////////////////////////
 274
 275 NONSHARABLE_CLASS(CExitWait) : public CActive
 276         {
 277         public:
 278                 CExitWait(MExitWait& aWait);
 279                 ~CExitWait();
 280         private:
 281                 void RunL();
 282                 void DoCancel();
 283         private:
 284                 MExitWait& iWait;
 285                 TRequestStatus* iStatusPtr;
 286         };
 287
 288 ////////////////////////////////////////////////////////////////////////
 289
 290
 291 NONSHARABLE_CLASS(CSDLWin) : public CCoeControl
 292         {
 293         public:
 294                 void ConstructL(const TRect& aRect);
 295                 RWindow& GetWindow() const;
 296                 void SetNoDraw();
 297         private:
 298                 void Draw(const TRect& aRect) const;
 299         private:
 300                 TBool iNoDraw;
 301         };
 302
 303
 304 ////////////////////////////////////////////////////////////////////////////
 305
 306 NONSHARABLE_CLASS(CSDLAppUi) : public CAknAppUi, public MExitWait, MSDLObserver
 307         {
 308         public:
 309                 ~CSDLAppUi();
 310         private: // New functions
 311                 void ConstructL();
 312         void HandleCommandL(TInt aCommand);
 313                 void HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination);
 314                 void HandleResourceChangeL(TInt aType);
 315
 316                 void DoExit(TInt aErr);
 317
 318                 TInt SdlEvent(TInt aEvent, TInt aParam);
 319         TInt SdlThreadEvent(TInt aEvent, TInt aParam);
 320
 321         void StartL();
 322         static TBool StartL(TAny* aThis);
 323
 324         TBool ParamEditorL(TDes& aCheat);
 325
 326         TBool ProcessCommandParametersL(CApaCommandLine &aCommandLine);
 327
 328         void PrepareToExit();
 329         void HandleConsoleWindowL();
 330         void HandleConsoleWindow();
 331         void HandleForegroundEventL(TBool aForeground);
 332
 333         static TBool IdleRequestL(TAny* aThis);
 334
 335         TBool HandleKeyL(const TWsEvent& aEvent);
 336
 337
 338         private:
 339                 CExitWait* iWait;
 340                 CSDLWin* iSDLWin;
 341                 CSDL* iSdl;
 342                 CIdle* iStarter;
 343                 TBool iExitRequest;
 344                 CDesC8Array* iParams;
 345                 TInt iResOffset;
 346                 CIdle* iIdle;
 347                 TInt iStdOut;
 348                 TVirtualCursor iCursor;
 349                 CFbsBitmap*     iCBmp;
 350                 CFbsBitmap*     iAlpha;
 351         //      TTime iLastPress;
 352         //      CSDL::TOrientationMode iOrientation;
 353         };
 354
 355 ////////////////////////////////////////////////////////////////////////////////////////7
 356
 357 CApaDocument* CSDLApplication::CreateDocumentL()
 358         {
 359         return new (ELeave) CSDLDocument(*this);
 360         }
 361
 362 TUid CSDLApplication::AppDllUid() const
 363         {
 364         return iUid;
 365         }
 366
 367
 368 CSDLApplication::CSDLApplication()
 369         {
 370         TRAPD(err, FindMeL());
 371         ASSERT(err == KErrNone);
 372         }
 373
 374 void CSDLApplication::FindMeL()
 375         {
 376         RApaLsSession apa;
 377         User::LeaveIfError(apa.Connect());
 378         CleanupClosePushL(apa);
 379         User::LeaveIfError(apa.GetAllApps());
 380         TFileName name = RProcess().FileName();
 381         TApaAppInfo info;
 382         while(apa.GetNextApp(info) == KErrNone)
 383                 {
 384                 if(info.iFullName.CompareF(name) == 0)
 385                         {
 386                         iUid = info.iUid;
 387                         break;
 388                         }
 389                 }
 390         CleanupStack::PopAndDestroy();
 391         }
 392
 393 TFileName CSDLApplication::ResourceFileName() const
 394         {
 395         return KNullDesC();
 396         }
 397
 398 ///////////////////////////////////////////////////////////////////////////////////////////
 399
 400 CExitWait::CExitWait(MExitWait& aWait) : CActive(CActive::EPriorityStandard), iWait(aWait)
 401         {
 402         CActiveScheduler::Add(this);
 403         SetActive();
 404         iStatusPtr = &iStatus;
 405         }
 406
 407 CExitWait::~CExitWait()
 408         {
 409         Cancel();
 410         }
 411
 412 void CExitWait::RunL()
 413         {
 414         if(iStatusPtr != NULL )
 415                 iWait.DoExit(iStatus.Int());
 416         }
 417
 418 void CExitWait::DoCancel()
 419         {
 420         if(iStatusPtr != NULL )
 421                 User::RequestComplete(iStatusPtr , KErrCancel);
 422         }
 423
 424
 425 //////////////////////////////////////////////////////////////////////////////////////////////
 426
 427 CSDLDocument::CSDLDocument(CEikApplication& aApp) : CEikDocument(aApp)
 428         {}
 429
 430 CEikAppUi* CSDLDocument::CreateAppUiL()
 431         {
 432         return new (ELeave) CSDLAppUi;
 433         }
 434
 435 ///////////////////////////////////////////////////////////////////////////
 436
 437 void CSDLWin:: ConstructL(const TRect& aRect)
 438         {
 439         CreateWindowL();
 440         SetRect(aRect);
 441         ActivateL();
 442         }
 443
 444
 445 RWindow& CSDLWin::GetWindow() const
 446         {
 447         return Window();
 448         }
 449
 450
 451 void CSDLWin::Draw(const TRect& /*aRect*/) const
 452         {
 453         if(!iNoDraw)
 454                 {
 455                 CWindowGc& gc = SystemGc();
 456                 gc.SetPenStyle(CGraphicsContext::ESolidPen);
 457                 gc.SetPenColor(KRgbGray);
 458                 gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
 459                 gc.SetBrushColor(0xaaaaaa);
 460                 gc.DrawRect(Rect());
 461                 }
 462         }
 463
 464 void CSDLWin::SetNoDraw()
 465         {
 466         iNoDraw = ETrue;
 467         }
 468
 469 /////////////////////////////////////////////////////////////////////////
 470
 471 CSDLAppUi::~CSDLAppUi()
 472         {
 473         if(iIdle)
 474                 iIdle->Cancel();
 475         delete iIdle;
 476         if(iStarter != NULL)
 477                 iStarter->Cancel();
 478         delete iStarter;
 479         delete iWait;
 480         delete iSdl;
 481         delete iSDLWin;
 482         delete iParams;
 483         delete iCBmp;
 484         delete iAlpha;
 485         }
 486
 487
 488 void CSDLAppUi::ConstructL()
 489         {
 490         BaseConstructL(ENoAppResourceFile | ENoScreenFurniture);
 491
 492
 493         RLibrary lib;
 494         User::LeaveIfError(lib.Load(_L("sdlexe.dll")));
 495         TFileName name = lib.FileName();
 496         lib.Close();
 497         name.Replace(3, name.Length() - 3, _L("resource\\apps\\sdlexe.rsc"));
 498         BaflUtils::NearestLanguageFile(iEikonEnv->FsSession(), name);
 499         iResOffset = iCoeEnv->AddResourceFileL(name);
 500
 501         name.Replace(name.Length() - 3, 3, _L("mbm"));
 502
 503         TEntry e;
 504         const TInt err = iEikonEnv->FsSession().Entry(name, e);
 505
 506         iCBmp = iEikonEnv->CreateBitmapL(name, 0);
 507         iAlpha = iEikonEnv->CreateBitmapL(name, 1);
 508
 509         iIdle = CIdle::NewL(CActive::EPriorityIdle);
 510
 511         iSDLWin = new (ELeave) CSDLWin;
 512         iSDLWin->ConstructL(ApplicationRect());
 513
 514         iSdl = CSDL::NewL(gSDLClass.SdlFlags());
 515
 516         gSDLClass.SendEvent(MSDLMainObs::ESDLCreated, 0, iSdl);
 517
 518         iSdl->SetObserver(this);
 519         iSdl->DisableKeyBlocking(*this);
 520         iSdl->SetContainerWindowL(
 521                                         iSDLWin->GetWindow(),
 522                                 iEikonEnv->WsSession(),
 523                                 *iEikonEnv->ScreenDevice());
 524     iSdl->AppendOverlay(iCursor, 0);
 525
 526     iCursor.Set(TRect(TPoint(0, 0), iSDLWin->Size()), iCBmp, iAlpha);
 527
 528     iStarter = CIdle::NewL(CActive::EPriorityLow);
 529     iStarter->Start(TCallBack(StartL, this));
 530
 531
 532         }
 533
 534
 535
 536 TBool CSDLAppUi::StartL(TAny* aThis)
 537         {
 538         static_cast<CSDLAppUi*>(aThis)->StartL();
 539         return EFalse;
 540         }
 541
 542
 543 void CSDLAppUi::PrepareToExit()
 544         {
 545         CAknAppUiBase::PrepareToExit(); //aknappu::PrepareToExit crashes
 546         iCoeEnv->DeleteResourceFile(iResOffset);
 547         }
 548
 549 TBool CSDLAppUi::ProcessCommandParametersL(CApaCommandLine &aCommandLine)
 550         {
 551         const TPtrC8 cmdLine = aCommandLine.TailEnd();
 552         iParams = new (ELeave) CDesC8ArrayFlat(8);
 553         MakeCCmdLineL(cmdLine, *iParams);
 554         return EFalse;
 555         }
 556
 557
 558  TBool CSDLAppUi::ParamEditorL(TDes& aCheat)
 559         {
 560         CAknTextQueryDialog* query = CAknTextQueryDialog::NewL(aCheat);
 561         CleanupStack::PushL(query);
 562         query->SetPromptL(_L("Enter parameters"));
 563         CleanupStack::Pop();
 564         return query->ExecuteLD(R_PARAMEDITOR);
 565         }
 566
 567  void CSDLAppUi::StartL()
 568         {
 569         if(gSDLClass.AppFlags() & SDLEnv::EParamQuery)
 570                 {
 571                 TBuf8<256> cmd;
 572                 RFile file;
 573                 TInt err = file.Open(iEikonEnv->FsSession(), _L("sdl_param.txt"),EFileRead);
 574                 if(err == KErrNone)
 575                         {
 576                         file.Read(cmd);
 577                         file.Close();
 578                         MakeCCmdLineL(cmd, *iParams);
 579                         }
 580                 if(err != KErrNone || gSDLClass.AppFlags() & (SDLEnv::EParamQueryDialog ^ SDLEnv::EParamQuery))
 581                         {
 582                         TBuf<256> buffer;
 583                         if(ParamEditorL(buffer))
 584                                 {
 585                                 cmd.Copy(buffer);
 586                                 MakeCCmdLineL(cmd, *iParams);
 587                                 }
 588                         }
 589                 }
 590         iWait = new (ELeave) CExitWait(*this);
 591         iSdl->CallMainL(gSDLClass.Main(), &iWait->iStatus, iParams, CSDL::ENoParamFlags, 0xA000);
 592         }
 593
 594 void CSDLAppUi::HandleCommandL(TInt aCommand)
 595         {
 596         switch(aCommand)
 597                 {
 598                 case EAknSoftkeyBack:
 599                 case EAknSoftkeyExit:
 600                 case EAknCmdExit:
 601                 case EEikCmdExit:
 602                         gSDLClass.AppFlags(SDLEnv::EAllowConsoleView);
 603                     if(iWait == NULL || !iWait->IsActive() || iSdl == NULL)
 604                         {
 605                         Exit();
 606                         }
 607                           else if(!iExitRequest)
 608                                 {
 609                                 iExitRequest = ETrue; //trick how SDL can be closed!
 610                                 iSdl->Suspend();
 611                                 }
 612                         break;
 613                 }
 614         }
 615
 616
 617
 618 TBool CSDLAppUi::HandleKeyL(const TWsEvent& aEvent)
 619         {
 620         const TInt type = aEvent.Type();
 621         if(!(type == EEventKey || type == EEventKeyUp || type == EEventKeyDown))
 622                         {
 623                         return ETrue;
 624                         }
 625         const TKeyEvent& key = *aEvent.Key();
 626         if((key.iScanCode == EStdKeyYes) && (gSDLClass.AppFlags() & SDLEnv::EVirtualMouse))
 627                 {
 628                 if(type == EEventKeyUp)
 629                         {
 630                         iCursor.Toggle();
 631                         iSdl->RedrawRequest();
 632                         }
 633                 return EFalse;
 634                 }
 635         if(iCursor.IsOn())
 636                 {
 637                 switch(key.iScanCode)
 638                         {
 639                         case EStdKeyUpArrow:
 640                                 iCursor.Move(0, -1);
 641                                 break;
 642                         case EStdKeyDownArrow:
 643                                 iCursor.Move(0, 1);
 644                                 break;
 645                         case EStdKeyLeftArrow:
 646                                 iCursor.Move(-1, 0);
 647                                 break;
 648                         case EStdKeyRightArrow:
 649                                 iCursor.Move(1, 0);
 650                                 break;
 651                         case EStdKeyDevice3:
 652                                 if(type == EEventKeyUp)
 653                                         {
 654                                         TWsEvent event;
 655                                         iCursor.MakeEvent(event, iSDLWin->Position());
 656                                         iSdl->AppendWsEvent(event);
 657                                         }
 658                                 return EFalse;
 659                         default:
 660                                 return ETrue;
 661                         }
 662                 iSdl->RedrawRequest();
 663                 return EFalse;
 664                 }
 665         return ETrue;
 666         }
 667
 668  void CSDLAppUi::HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination)
 669         {
 670         if(iSdl && iWait && HandleKeyL(aEvent))
 671                 iSdl->AppendWsEvent(aEvent);
 672         CAknAppUi::HandleWsEventL(aEvent, aDestination);
 673         }
 674
 675  void CSDLAppUi::HandleResourceChangeL(TInt aType)
 676         {
 677     CAknAppUi::HandleResourceChangeL(aType);
 678     if(aType == KEikDynamicLayoutVariantSwitch)
 679         {
 680         iSDLWin->SetRect(ApplicationRect());
 681         iSdl->SetContainerWindowL(
 682                                 iSDLWin->GetWindow(),
 683                                 iEikonEnv->WsSession(),
 684                                 *iEikonEnv->ScreenDevice());
 685         }
 686         }
 687
 688
 689 void CSDLAppUi::DoExit(TInt/*Err*/)
 690         {
 691         iExitRequest = ETrue;
 692         Exit();
 693         }
 694
 695
 696  TInt CSDLAppUi::SdlThreadEvent(TInt aEvent, TInt /*aParam*/)
 697         {
 698         switch(aEvent)
 699                 {
 700                 case MSDLObserver::EEventResume:
 701                         break;
 702                 case MSDLObserver::EEventSuspend:
 703                         if(iExitRequest)
 704                                 return MSDLObserver::ESuspendNoSuspend;
 705                         break;
 706                 case MSDLObserver::EEventWindowReserved:
 707                         break;
 708                 case MSDLObserver::EEventWindowNotAvailable:
 709                         break;
 710                 case MSDLObserver::EEventScreenSizeChanged:
 711             break;
 712                 }
 713         return MSDLObserver::EParameterNone;
 714         }
 715
 716 TInt CSDLAppUi::SdlEvent(TInt aEvent, TInt /*aParam*/)
 717         {
 718         switch(aEvent)
 719                 {
 720                 case MSDLObserver::EEventResume:
 721                         break;
 722                 case MSDLObserver::EEventSuspend:
 723                         if(iExitRequest)
 724                                 return MSDLObserver::ESuspendNoSuspend;
 725                         break;
 726                 case MSDLObserver::EEventWindowReserved:
 727                         break;
 728                 case MSDLObserver::EEventWindowNotAvailable:
 729                         {
 730                         TRAP_IGNORE(HandleConsoleWindowL());
 731                         }
 732                         break;
 733                 case MSDLObserver::EEventScreenSizeChanged:
 734                 break;
 735                 case MSDLObserver::EEventKeyMapInit:
 736                         break;
 737                 case MSDLObserver::EEventMainExit:
 738                         if(iStdOut != 0)
 739                                 {
 740                                 gSDLClass.AppFlags(SDLEnv::EAllowConsoleView);
 741                                 iEikonEnv->WsSession().SetWindowGroupOrdinalPosition(iStdOut, 0);
 742                                 }
 743                         break;
 744                 }
 745         return MSDLObserver::EParameterNone;
 746         }
 747
 748 void CSDLAppUi::HandleForegroundEventL(TBool aForeground)
 749         {
 750         CAknAppUi::HandleForegroundEventL(aForeground);
 751         if(!aForeground)
 752                 HandleConsoleWindow();
 753         }
 754
 755 void CSDLAppUi::HandleConsoleWindow()
 756         {
 757         if(!iIdle->IsActive())
 758                 iIdle->Start(TCallBack(IdleRequestL, this));
 759         }
 760
 761 TBool CSDLAppUi::IdleRequestL(TAny* aThis)
 762         {
 763         static_cast<CSDLAppUi*>(aThis)->HandleConsoleWindowL();
 764         return EFalse;
 765         }
 766
 767 void CSDLAppUi::HandleConsoleWindowL()
 768         {
 769         if(gSDLClass.AppFlags() & SDLEnv::EAllowConsoleView)
 770                 {
 771                 return;
 772                 }
 773         RWsSession& ses = iEikonEnv->WsSession();
 774         const TInt focus = ses.GetFocusWindowGroup();
 775         CApaWindowGroupName* name = CApaWindowGroupName::NewLC(ses, focus);
 776         const TPtrC caption = name->Caption();
 777         if(0 == caption.CompareF(_L("STDOUT")))
 778                 {
 779                 iStdOut = focus;
 780                 ses.SetWindowGroupOrdinalPosition(iEikonEnv->RootWin().Identifier(), 0);
 781                 }
 782         CleanupStack::PopAndDestroy(); //name
 783         }
 784
 785
 786 ////////////////////////////////////////////////////////////////////////
 787
 788
 789 CApaApplication* NewApplication()
 790     {
 791     return new CSDLApplication();
 792     }
 793
 794
 795 EXPORT_C TInt SDLEnv::SetMain(const TMainFunc& aFunc, TInt aSdlFlags, MSDLMainObs* aObs, TInt aSdlExeFlags)
 796         {
 797         gSDLClass.SetMain(aFunc, aSdlFlags, aObs, aSdlExeFlags);
 798         return EikStart::RunApplication(NewApplication);
 799         }
 800
 801 //////////////////////////////////////////////////////////////////////
 802
 803 TInt SDLUiPrint(const TDesC8& /*aInfo*/)
 804     {
 805     return KErrNotFound;
 806     }
 807
 808
 809