src/main/symbian/sdlexe.cpp

   1 #include <aknapp.h>
   2 #include <aknappui.h>
   3 #include <eikdoc.h>
   4 #include <sdlepocapi.h>
   5 #include <bautils.h>
   6 #include <eikstart.h>
   7 #include <badesca.h>
   8 #include <bautils.h>
   9 #include <apgcli.h>
  10 #include <sdlmain.h>
  11 #include <eikedwin.h>
  12 #include <eiklabel.h>
  13 #include <sdlexe.rsg>
  14 #include <aknglobalmsgquery.h>
  15 #include <apgwgnam.h>
  16
  17 class CApaDocument;
  18
  19 LOCAL_C void MakeCCmdLineL(const TDesC8& aParam, CDesC8Array& aArray)
  20 {
  21         const TChar dq('\"');
  22
  23         TLex8 lex(aParam);
  24         TBool in = EFalse;
  25
  26         lex.SkipSpaceAndMark();
  27
  28         while(!lex.Eos())
  29         {
  30                 TPtrC8 ptr;
  31                 if(in)
  32                 {
  33                         const TPtrC8 rem = lex.RemainderFromMark();
  34                         const int pos = rem.Locate(dq);
  35                         if(pos > 0)
  36                         {
  37                                 lex.Inc(pos);
  38                                 ptr.Set(lex.MarkedToken());
  39                                 lex.SkipAndMark(1);
  40                         }
  41                         else
  42                         {
  43                                 ptr.Set(rem);
  44                         }
  45                         in = EFalse;
  46                 }
  47                 else
  48                 {
  49                         ptr.Set(lex.NextToken());
  50                         const int pos = ptr.Locate(dq);
  51                         if(pos == 0)
  52                         {
  53                                 lex.UnGetToMark();
  54                                 lex.SkipAndMark(1);
  55                                 in = ETrue;
  56                                 continue; // back to in brace
  57                         }
  58                         else
  59                                 lex.SkipSpaceAndMark();
  60                 }
  61
  62                 aArray.AppendL(ptr);
  63         }
  64 }
  65
  66 NONSHARABLE_CLASS(TSdlClass)
  67 {
  68         public:
  69                 TSdlClass();
  70                 void SetMain(const TMainFunc& aFunc, int aFlags, MSDLMainObs* aObs, int aExeFlags);
  71                 int SdlFlags() const;
  72                 const TMainFunc& Main() const;
  73                 void SendEvent(int aEvent, int aParam, CSDL* aSDL);
  74                 int AppFlags() const;
  75                 void AppFlags(int aFlags);
  76
  77         private:
  78                 TMainFunc iFunc;
  79                 int iSdlFlags;
  80                 int iExeFlags;
  81                 MSDLMainObs* iObs;
  82 };
  83
  84
  85 void TSdlClass::AppFlags(int aFlags)
  86 {
  87         iExeFlags |= aFlags;
  88 }
  89
  90 void TSdlClass::SendEvent(int aEvent, int aParam, CSDL* aSDL)
  91 {
  92         if(iObs != NULL)
  93                 iObs->SDLMainEvent(aEvent, aParam, aSDL);
  94 }
  95
  96 int TSdlClass::AppFlags() const
  97 {
  98         return iExeFlags;
  99 }
 100
 101 void TSdlClass::SetMain(const TMainFunc& aFunc, int aFlags, MSDLMainObs* aObs, int aExeFlags)
 102 {
 103         iFunc = aFunc;
 104         iSdlFlags = aFlags;
 105         iExeFlags = aExeFlags;
 106         iObs = aObs;
 107 }
 108
 109 const TMainFunc& TSdlClass::Main() const
 110 {
 111         return iFunc;
 112 }
 113
 114
 115 int TSdlClass::SdlFlags() const
 116 {
 117         return iSdlFlags;
 118 }
 119
 120 TSdlClass::TSdlClass()
 121 {
 122         Mem::FillZ(this, sizeof(this));
 123 }
 124
 125 TSdlClass gSDLClass;
 126
 127 ////////////////////////////////////////////////////////////////
 128
 129 NONSHARABLE_CLASS(CSDLApplication) : public CAknApplication
 130 {
 131         public:
 132                 CSDLApplication();
 133
 134         private:
 135                 CApaDocument* CreateDocumentL();
 136                 TFileName ResourceFileName() const;
 137                 TUid AppDllUid() const;
 138                 void FindMeL();
 139
 140                 TUid iUid;
 141 };
 142
 143 NONSHARABLE_CLASS(CSDLDocument) : public CEikDocument
 144 {
 145         public:
 146                 CSDLDocument(CEikApplication& aApp);
 147
 148         private:
 149                 CEikAppUi* CreateAppUiL();
 150 };
 151
 152 ////////////////////////////////////////////////////////////////////
 153
 154 NONSHARABLE_CLASS(MExitWait)
 155 {
 156         public:
 157                 virtual void DoExit(int aErr) = 0;
 158 };
 159
 160 /////////////////////////////////////////////////////////////////////////
 161
 162 NONSHARABLE_CLASS(CExitWait) : public CActive
 163 {
 164         public:
 165                 CExitWait(MExitWait& aWait);
 166                 ~CExitWait();
 167
 168         private:
 169                 void RunL();
 170                 void DoCancel();
 171
 172                 MExitWait& iWait;
 173                 TRequestStatus* iStatusPtr;
 174 };
 175
 176 ////////////////////////////////////////////////////////////////////////
 177
 178 NONSHARABLE_CLASS(CSDLWin) : public CCoeControl
 179 {
 180         public:
 181                 void ConstructL(const TRect& aRect);
 182                 RWindow& GetWindow() const;
 183
 184         private:
 185                 void Draw(const TRect& aRect) const;
 186 };
 187
 188 ////////////////////////////////////////////////////////////////////////////
 189
 190 NONSHARABLE_CLASS(CSDLAppUi) : public CAknAppUi, public MExitWait, public MSDLObserver
 191 {
 192         public:
 193                 ~CSDLAppUi();
 194
 195         private:
 196                 void ConstructL();
 197                 void HandleCommandL(int aCommand);
 198                 void HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination);
 199                 void HandleResourceChangeL(int aType);
 200
 201                 void DoExit(int aErr);
 202
 203                 int SdlEvent(int aEvent, int aParam);
 204                 int SdlThreadEvent(int aEvent, int aParam);
 205
 206                 void StartL();
 207                 static TBool StartL(TAny* aThis);
 208
 209                 TBool ParamEditorL(TDes& aCheat);
 210
 211                 TBool ProcessCommandParametersL(CApaCommandLine &aCommandLine);
 212
 213                 void PrepareToExit();
 214                 void HandleConsoleWindowL();
 215                 void HandleConsoleWindow();
 216                 void HandleForegroundEventL(TBool aForeground);
 217
 218                 static TBool IdleRequestL(TAny* aThis);
 219
 220                 CExitWait* iWait;
 221                 CSDLWin* iSDLWin;
 222                 CSDL* iSdl;
 223                 CIdle* iStarter;
 224                 CDesC8Array* iParams;
 225                 int iResOffset;
 226                 CIdle* iIdle;
 227                 int iStdOut;
 228 };
 229
 230 ////////////////////////////////////////////////////////////////////////////////////////
 231
 232 CApaDocument* CSDLApplication::CreateDocumentL()
 233 {
 234         return new (ELeave) CSDLDocument(*this);
 235 }
 236
 237 TUid CSDLApplication::AppDllUid() const
 238 {
 239         return iUid;
 240 }
 241
 242 CSDLApplication::CSDLApplication()
 243 {
 244         TRAPD(err, FindMeL());
 245         ASSERT(err == KErrNone);
 246 }
 247
 248 void CSDLApplication::FindMeL()
 249 {
 250         RApaLsSession apa;
 251         User::LeaveIfError(apa.Connect());
 252         CleanupClosePushL(apa);
 253         User::LeaveIfError(apa.GetAllApps());
 254         TFileName name = RProcess().FileName();
 255         TApaAppInfo info;
 256         while(apa.GetNextApp(info) == KErrNone)
 257         {
 258                 if(info.iFullName.CompareF(name) == 0)
 259                 {
 260                         iUid = info.iUid;
 261                         break;
 262                 }
 263         }
 264         CleanupStack::PopAndDestroy();
 265 }
 266
 267 TFileName CSDLApplication::ResourceFileName() const
 268 {
 269         return KNullDesC();
 270 }
 271
 272 ///////////////////////////////////////////////////////////////////////////////////////////
 273
 274 CExitWait::CExitWait(MExitWait& aWait) : CActive(CActive::EPriorityStandard), iWait(aWait)
 275 {
 276         CActiveScheduler::Add(this);
 277         SetActive();
 278         iStatusPtr = &iStatus;
 279 }
 280
 281 CExitWait::~CExitWait()
 282 {
 283         Cancel();
 284 }
 285
 286 void CExitWait::RunL()
 287 {
 288         if(iStatusPtr != NULL)
 289                 iWait.DoExit(iStatus.Int());
 290 }
 291
 292 void CExitWait::DoCancel()
 293 {
 294         if(iStatusPtr != NULL)
 295                 User::RequestComplete(iStatusPtr, KErrCancel);
 296 }
 297
 298 //////////////////////////////////////////////////////////////////////////////////////////////
 299
 300 CSDLDocument::CSDLDocument(CEikApplication& aApp) : CEikDocument(aApp)
 301 {}
 302
 303 CEikAppUi* CSDLDocument::CreateAppUiL()
 304 {
 305         return new (ELeave) CSDLAppUi;
 306 }
 307
 308 ///////////////////////////////////////////////////////////////////////////
 309
 310 void CSDLWin::ConstructL(const TRect& aRect)
 311 {
 312         CreateWindowL();
 313         SetRect(aRect);
 314         ActivateL();
 315 }
 316
 317 RWindow& CSDLWin::GetWindow() const
 318 {
 319         return Window();
 320 }
 321
 322 void CSDLWin::Draw(const TRect& /*aRect*/) const
 323 {
 324         CWindowGc& gc = SystemGc();
 325         gc.SetPenStyle(CGraphicsContext::ESolidPen);
 326         gc.SetPenColor(KRgbGray);
 327         gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
 328         gc.SetBrushColor(0x000000);
 329         gc.DrawRect(Rect());
 330 }
 331
 332 /////////////////////////////////////////////////////////////////////////
 333
 334 CSDLAppUi::~CSDLAppUi()
 335 {
 336         if(iIdle)
 337                 iIdle->Cancel();
 338         delete iIdle;
 339         if(iStarter)
 340                 iStarter->Cancel();
 341         delete iStarter;
 342         delete iWait;
 343         delete iSdl;
 344         delete iSDLWin;
 345         delete iParams;
 346 }
 347
 348 void CSDLAppUi::ConstructL()
 349 {
 350         BaseConstructL(ENoAppResourceFile | ENoScreenFurniture);
 351
 352         RFs fs;
 353         fs.Connect();
 354         TFileName name;
 355         fs.PrivatePath(name);
 356         fs.Close();
 357         name.Append( _L("sdlexe.rsc") );
 358         name.Insert( 0, _L("C:") );
 359         iResOffset = iCoeEnv->AddResourceFileL(name);
 360
 361         iIdle = CIdle::NewL(CActive::EPriorityIdle);
 362
 363         iSDLWin = new (ELeave) CSDLWin;
 364         iSDLWin->ConstructL(ApplicationRect());
 365
 366         iSdl = CSDL::NewL(gSDLClass.SdlFlags());
 367
 368         gSDLClass.SendEvent(MSDLMainObs::ESDLCreated, 0, iSdl);
 369
 370         iSdl->SetObserver(this);
 371         iSdl->DisableKeyBlocking(*this);
 372         iSdl->SetContainerWindowL(
 373                         iSDLWin->GetWindow(),
 374                         iEikonEnv->WsSession(),
 375                         *iEikonEnv->ScreenDevice());
 376
 377         iStarter = CIdle::NewL(CActive::EPriorityLow);
 378         iStarter->Start(TCallBack(StartL, this));
 379 }
 380
 381 TBool CSDLAppUi::StartL(TAny* aThis)
 382 {
 383         static_cast<CSDLAppUi*>(aThis)->StartL();
 384         return EFalse;
 385 }
 386
 387 void CSDLAppUi::PrepareToExit()
 388 {
 389         CAknAppUiBase::PrepareToExit(); //aknappu::PrepareToExit crashes
 390         iCoeEnv->DeleteResourceFile(iResOffset);
 391 }
 392
 393 TBool CSDLAppUi::ProcessCommandParametersL(CApaCommandLine &aCommandLine)
 394 {
 395         const TPtrC8 cmdLine = aCommandLine.TailEnd();
 396         iParams = new (ELeave) CDesC8ArrayFlat(8);
 397         MakeCCmdLineL(cmdLine, *iParams);
 398         return EFalse;
 399 }
 400
 401 TBool CSDLAppUi::ParamEditorL(TDes& aCheat)
 402 {
 403         CAknTextQueryDialog* query = CAknTextQueryDialog::NewL(aCheat);
 404         CleanupStack::PushL(query);
 405         query->SetPromptL(_L("Enter parameters"));
 406         CleanupStack::Pop();
 407         return query->ExecuteLD(R_PARAMEDITOR);
 408 }
 409
 410 void CSDLAppUi::StartL()
 411 {
 412         if(gSDLClass.AppFlags() & SDLEnv::EParamQuery)
 413         {
 414                 TBuf8<256> cmd;
 415                 RFile file;
 416                 int err = file.Open(iEikonEnv->FsSession(), _L("sdl_param.txt"),EFileRead);
 417                 if(err == KErrNone)
 418                 {
 419                         file.Read(cmd);
 420                         file.Close();
 421                         MakeCCmdLineL(cmd, *iParams);
 422                 }
 423                 if(err != KErrNone || gSDLClass.AppFlags() & (SDLEnv::EParamQueryDialog ^ SDLEnv::EParamQuery))
 424                 {
 425                         TBuf<256> buffer;
 426                         if(ParamEditorL(buffer))
 427                         {
 428                                 cmd.Copy(buffer);
 429                                 MakeCCmdLineL(cmd, *iParams);
 430                         }
 431                 }
 432         }
 433         iWait = new (ELeave) CExitWait(*this);
 434         iSdl->CallMainL(gSDLClass.Main(), &iWait->iStatus, iParams, CSDL::ENoParamFlags, 0xA000);
 435 }
 436
 437 void CSDLAppUi::HandleCommandL(int aCommand)
 438 {
 439         switch(aCommand)
 440         {
 441                 case EAknSoftkeyBack:
 442                 case EAknSoftkeyExit:
 443                 case EAknCmdExit:
 444                 case EEikCmdExit:
 445                         gSDLClass.AppFlags(SDLEnv::EAllowConsoleView);
 446                         if(iWait == NULL || !iWait->IsActive() || iSdl == NULL)
 447                         {
 448                                 Exit();
 449                         }
 450                         else
 451                         {
 452                                 TWsEvent event;
 453                                 event.SetType(EEventSwitchOff), event.SetTimeNow();
 454                                 iSdl->AppendWsEvent(event);
 455                         }
 456                         break;
 457         }
 458 }
 459
 460 void CSDLAppUi::HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination)
 461 {
 462         if(iSdl && iWait)
 463                 iSdl->AppendWsEvent(aEvent);
 464         CAknAppUi::HandleWsEventL(aEvent, aDestination);
 465 }
 466
 467 void CSDLAppUi::HandleResourceChangeL(int aType)
 468 {
 469         CAknAppUi::HandleResourceChangeL(aType);
 470         if(aType == KEikDynamicLayoutVariantSwitch)
 471         {
 472                 iSDLWin->SetRect(ApplicationRect());
 473                 iSdl->SetContainerWindowL(
 474                                 iSDLWin->GetWindow(),
 475                                 iEikonEnv->WsSession(),
 476                                 *iEikonEnv->ScreenDevice());
 477         }
 478 }
 479
 480 void CSDLAppUi::DoExit(int/*Err*/)
 481 {
 482         Exit();
 483 }
 484
 485 int CSDLAppUi::SdlThreadEvent(int aEvent, int /*aParam*/)
 486 {
 487         switch(aEvent)
 488         {
 489                 case MSDLObserver::EEventResume:
 490                         break;
 491                 case MSDLObserver::EEventSuspend:
 492                         break;
 493                 case MSDLObserver::EEventWindowReserved:
 494                         break;
 495                 case MSDLObserver::EEventWindowNotAvailable:
 496                         break;
 497                 case MSDLObserver::EEventScreenSizeChanged:
 498                         break;
 499         }
 500         return MSDLObserver::EParameterNone;
 501 }
 502
 503 int CSDLAppUi::SdlEvent(int aEvent, int /*aParam*/)
 504 {
 505         switch(aEvent)
 506         {
 507                 case MSDLObserver::EEventResume:
 508                         break;
 509                 case MSDLObserver::EEventSuspend:
 510                         break;
 511                 case MSDLObserver::EEventWindowReserved:
 512                         break;
 513                 case MSDLObserver::EEventWindowNotAvailable:
 514                         {
 515                                 TRAP_IGNORE(HandleConsoleWindowL());
 516                         }
 517                         break;
 518                 case MSDLObserver::EEventScreenSizeChanged:
 519                         break;
 520                 case MSDLObserver::EEventKeyMapInit:
 521                         break;
 522                 case MSDLObserver::EEventMainExit:
 523                         if(iStdOut != 0)
 524                         {
 525                                 gSDLClass.AppFlags(SDLEnv::EAllowConsoleView);
 526                                 iEikonEnv->WsSession().SetWindowGroupOrdinalPosition(iStdOut, 0);
 527                         }
 528                         break;
 529         }
 530         return MSDLObserver::EParameterNone;
 531 }
 532
 533 void CSDLAppUi::HandleForegroundEventL(TBool aForeground)
 534 {
 535         CAknAppUi::HandleForegroundEventL(aForeground);
 536         if(!aForeground)
 537                 HandleConsoleWindow();
 538 }
 539
 540 void CSDLAppUi::HandleConsoleWindow()
 541 {
 542         if(!iIdle->IsActive())
 543                 iIdle->Start(TCallBack(IdleRequestL, this));
 544 }
 545
 546 TBool CSDLAppUi::IdleRequestL(TAny* aThis)
 547 {
 548         static_cast<CSDLAppUi*>(aThis)->HandleConsoleWindowL();
 549         return EFalse;
 550 }
 551
 552 void CSDLAppUi::HandleConsoleWindowL()
 553 {
 554         if(gSDLClass.AppFlags() & SDLEnv::EAllowConsoleView)
 555         {
 556                 return;
 557         }
 558         RWsSession& ses = iEikonEnv->WsSession();
 559         const int focus = ses.GetFocusWindowGroup();
 560         CApaWindowGroupName* name = CApaWindowGroupName::NewLC(ses, focus);
 561         const TPtrC caption = name->Caption();
 562         if(0 == caption.CompareF(_L("STDOUT")))
 563         {
 564                 iStdOut = focus;
 565                 ses.SetWindowGroupOrdinalPosition(iEikonEnv->RootWin().Identifier(), 0);
 566         }
 567         CleanupStack::PopAndDestroy(); //name
 568 }
 569
 570 ////////////////////////////////////////////////////////////////////////
 571
 572 CApaApplication* NewApplication()
 573 {
 574         return new CSDLApplication();
 575 }
 576
 577 EXPORT_C int SDLEnv::SetMain(const TMainFunc& aFunc, int aSdlFlags, MSDLMainObs* aObs, int aSdlExeFlags)
 578 {
 579         gSDLClass.SetMain(aFunc, aSdlFlags, aObs, aSdlExeFlags);
 580         return EikStart::RunApplication(NewApplication);
 581 }