src/main/symbian/SDL_main.cpp

   1 extern "C" {
   2 #include "SDL_events_c.h"
   3 }
   4 #include "epoc_sdl.h"
   5 #include "sdlepocapi.h"
   6 #include <e32base.h>
   7 #include <estlib.h>
   8 #include <stdio.h>
   9 #include <badesca.h>
  10 #include <w32std.h>
  11 #include <aknappui.h>
  12 #include <aknapp.h>
  13 #include "SDL_epocevents_c.h"
  14 #include "SDL_keysym.h"
  15 #include "dsa.h"
  16 #include "SDL_loadso.h"
  17 #include <remconcoreapitargetobserver.h>
  18 #include <remconinterfaceselector.h>
  19 #include <remconcoreapitarget.h>
  20
  21 extern SDLKey* KeyMap();
  22 extern void ResetKeyMap();
  23
  24 class CCurrentAppUi;
  25 class CEikonEnv;
  26 class CSdlAppServ;
  27 class CEventQueue;
  28
  29 class EpocSdlEnvData
  30 {
  31         public:
  32                 void Free();
  33                 void Delete();
  34                 CEventQueue*            iEventQueue;
  35                 TMainFunc               iMain;
  36                 int                     iArgc;
  37                 char**                  iArgv;
  38                 CDsa*                   iDsa;
  39                 CSdlAppServ*            iAppSrv;
  40                 TThreadId               iId;
  41                 CArrayFix<TSdlCleanupItem>* iCleanupItems;
  42                 CSDL*                   iSdl;
  43                 TRequestStatus*         iCallerStatus;
  44                 bool                    iWaitingForOrientationChange;
  45
  46                 TSize                   iSize;
  47                 TDisplayMode            iMode;
  48 };
  49
  50 EpocSdlEnvData* gEpocEnv;
  51
  52 static void RunSingleThread()
  53 {
  54         int count = RThread().RequestCount();
  55         if(count > 0)
  56         {
  57                 int err;
  58                 if(CActiveScheduler::RunIfReady(err, CActive::EPriorityIdle))
  59                 {
  60                         CActiveScheduler::Current()->WaitForAnyRequest();
  61                 }
  62         }
  63 }
  64
  65 int Panic(int aErr, int aLine)
  66 {
  67         TBuf<64> b;
  68         b.Format(_L("Main at %d"), aLine);
  69         User::Panic(b, aErr);
  70         return 0;
  71 }
  72
  73
  74 bool CEventQueue::HasData()
  75 {
  76         RunSingleThread();
  77         return !m_queue.empty();
  78 }
  79
  80 const TWsEvent CEventQueue::Shift()
  81 {
  82         const TWsEvent event = m_queue.front();
  83         m_queue.pop();
  84         return event;
  85 }
  86
  87
  88 TSdlCleanupItem::TSdlCleanupItem(TSdlCleanupOperation aOperation, TAny* aItem) :
  89         iOperation(aOperation), iItem(aItem), iThread(RThread().Id())
  90 {}
  91
  92 #define MAINFUNC(x) TMainFunc::TMainFunc(mainfunc##x aFunc){Mem::FillZ(iMainFunc, sizeof(iMainFunc)); iMainFunc[x - 1] = (void*) aFunc;}
  93
  94 MAINFUNC(1)
  95 MAINFUNC(2)
  96 MAINFUNC(3)
  97 MAINFUNC(4)
  98 MAINFUNC(5)
  99 MAINFUNC(6)
 100
 101 TMainFunc::TMainFunc()
 102 {
 103         Mem::FillZ(iMainFunc, sizeof(iMainFunc));
 104 }
 105
 106
 107 const void* TMainFunc::operator[](int aIndex) const
 108 {
 109         return iMainFunc[aIndex];
 110 }
 111
 112
 113 class CSdlAppServ : public CActive
 114 {
 115         public:
 116                 enum
 117                 {
 118                         EAppSrvNoop = CDsa::ELastDsaRequest,
 119                         EAppSrvWindowWidth,
 120                         EAppSrvWindowHeight,
 121                         EAppSrvWindowDisplayMode,
 122                         EAppSrvWindowPointerCursorMode,
 123                         EAppSrvDsaStatus,
 124                         EAppSrvStopThread,
 125                         EAppSrvWaitDsa
 126                 };
 127                 CSdlAppServ();
 128                 void ConstructL();
 129                 ~CSdlAppServ();
 130                 int Request(int aService);
 131                 int RequestValue(int aService);
 132                 void Init();
 133                 void PanicMain(int aReason);
 134                 void PanicMain(const TDesC& aInfo, int aReason);
 135                 void SetParam(int aParam);
 136
 137         private:
 138                 void RunL();
 139                 void DoCancel();
 140                 const TThreadId iMainId;
 141                 RThread iAppThread;
 142                 int iService;
 143                 int iReturnValue;
 144                 TRequestStatus* iStatusPtr;
 145 };
 146
 147 CSdlAppServ::CSdlAppServ() : CActive(CActive::EPriorityHigh), iMainId(RThread().Id())
 148 {}
 149
 150 void CSdlAppServ::PanicMain(int aReason)
 151 {
 152         iAppThread.Panic(RThread().Name(), aReason);
 153 }
 154
 155 void CSdlAppServ::PanicMain(const TDesC& aInfo, int aReason)
 156 {
 157         iAppThread.Panic(aInfo, aReason);
 158 }
 159
 160 void CSdlAppServ::ConstructL()
 161 {
 162         CActiveScheduler::Add(this);
 163         iStatus = KRequestPending;
 164         iStatusPtr = &iStatus;
 165         SetActive();
 166 }
 167
 168 CSdlAppServ::~CSdlAppServ()
 169 {
 170         Cancel();
 171         iAppThread.Close();
 172 }
 173
 174 int CSdlAppServ::Request(int aService)
 175 {
 176         RunSingleThread();
 177         iService = aService;
 178         iAppThread.RequestComplete(iStatusPtr, KErrNone);
 179         return KErrNone;
 180 }
 181
 182 int CSdlAppServ::RequestValue(int aService)
 183 {
 184         Request(aService);
 185         Request(EAppSrvNoop);
 186         return iReturnValue;
 187 }
 188
 189 void CSdlAppServ::Init()
 190 {
 191         PANIC_IF_ERROR(iAppThread.Open(iMainId));
 192 }
 193
 194 void CSdlAppServ::SetParam(int aParam)
 195 {
 196         iReturnValue = aParam;
 197 }
 198
 199 void CSdlAppServ::RunL()
 200 {
 201         if(iStatus == KErrNone)
 202         {
 203                 switch(iService)
 204                 {
 205                         case CSdlAppServ::EAppSrvWaitDsa:
 206                                 EpocSdlEnv::SetWaitDsa();
 207                                 iReturnValue = EpocSdlEnv::IsDsaAvailable();
 208                                 break;
 209
 210                         case CSdlAppServ::EAppSrvStopThread:
 211                                 if(gEpocEnv->iDsa != NULL)
 212                                         gEpocEnv->iDsa->SetSuspend();
 213                                 break;
 214
 215                         case EAppSrvWindowPointerCursorMode:
 216                                 iReturnValue = gEpocEnv->iDsa != NULL ? gEpocEnv->iDsa->Session().PointerCursorMode() : KErrNotReady;
 217                                 break;
 218
 219                         case EAppSrvDsaStatus:
 220                                 if(gEpocEnv->iDsa != NULL)
 221                                         gEpocEnv->iDsa->Stop();
 222                                 iReturnValue = KErrNone;
 223                                 break;
 224
 225                         case EAppSrvNoop:
 226                                 break;
 227
 228                         default:
 229                                 PANIC(KErrNotSupported);
 230                                 break;
 231                 }
 232
 233                 iStatus = KRequestPending;
 234                 iStatusPtr = &iStatus;
 235                 SetActive();
 236         }
 237 }
 238
 239 void CSdlAppServ::DoCancel()
 240 {
 241         TRequestStatus* s = &iStatus;
 242         iAppThread.RequestComplete(s, KErrCancel);
 243 }
 244
 245 CEventQueue& EpocSdlEnv::EventQueue()
 246 {
 247         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 248         return *gEpocEnv->iEventQueue;
 249 }
 250
 251 int EpocSdlEnv::Argc()
 252 {
 253         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 254         return gEpocEnv->iArgc;
 255 }
 256
 257 char** EpocSdlEnv::Argv()
 258 {
 259         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 260         return gEpocEnv->iArgv;
 261 }
 262
 263 TBool EpocSdlEnv::IsDsaAvailable()
 264 {
 265         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 266         return gEpocEnv->iDsa != NULL && gEpocEnv->iDsa->IsDsaAvailable();
 267 }
 268
 269 void EpocSdlEnv::WaitDsaAvailable()
 270 {
 271         gEpocEnv->iAppSrv->Request(CSdlAppServ::EAppSrvStopThread);
 272 }
 273
 274 void EpocSdlEnv::Suspend()
 275 {
 276         if(gEpocEnv->iDsa != NULL)
 277         {
 278                 gEpocEnv->iDsa->SetSuspend();
 279         }
 280 }
 281
 282 void EpocSdlEnv::SetWaitDsa()
 283 {
 284         if(!IsDsaAvailable())
 285         {
 286                 if(gEpocEnv->iDsa != NULL)
 287                         gEpocEnv->iDsa->SetSuspend();
 288         }
 289 }
 290
 291 void EpocSdlEnv::Resume()
 292 {
 293         if(gEpocEnv->iDsa != NULL)
 294         {
 295                 gEpocEnv->iDsa->Resume();
 296         }
 297 }
 298
 299 int EpocSdlEnv::AllocSurface(const TSize& aSize, TDisplayMode aMode)
 300 {
 301         return gEpocEnv->iDsa->AllocSurface(aSize, aMode);
 302 }
 303
 304 void EpocSdlEnv::UnlockHwSurface()
 305 {
 306         gEpocEnv->iDsa->UnlockHwSurface();
 307 }
 308
 309 TUint8* EpocSdlEnv::LockHwSurface()
 310 {
 311         return gEpocEnv->iDsa->LockHwSurface();
 312 }
 313
 314 void EpocSdlEnv::UpdateSwSurface()
 315 {
 316         gEpocEnv->iDsa->UpdateSwSurface();
 317 }
 318
 319 TBool EpocSdlEnv::AddUpdateRect(TUint8* aAddress, const TRect& aUpdateRect, const TRect& aRect)
 320 {
 321         return gEpocEnv->iDsa->AddUpdateRect(aAddress, aUpdateRect, aRect);
 322 }
 323
 324 void EpocSdlEnv::Request(int aService)
 325 {
 326         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 327         gEpocEnv->iAppSrv->Request(aService);
 328 }
 329
 330 TDisplayMode EpocSdlEnv::DisplayMode()
 331 {
 332         return gEpocEnv->iDsa == NULL ? ENone : gEpocEnv->iDsa->DisplayMode();
 333 }
 334
 335 TPointerCursorMode EpocSdlEnv::PointerMode()
 336 {
 337         return static_cast<TPointerCursorMode>(gEpocEnv->iAppSrv->RequestValue(CSdlAppServ::EAppSrvWindowPointerCursorMode));
 338 }
 339
 340 int EpocSdlEnv::SetPalette(int aFirstcolor, int aColorCount, TUint32* aPalette)
 341 {
 342         return  gEpocEnv->iDsa->SetPalette(aFirstcolor, aColorCount, aPalette);
 343 }
 344
 345 void EpocSdlEnv::PanicMain(int aErr)
 346 {
 347         gEpocEnv->iAppSrv->PanicMain(aErr);
 348 }
 349
 350
 351 int EpocSdlEnv::AppendCleanupItem(const TSdlCleanupItem& aItem)
 352 {
 353         TRAPD(err, gEpocEnv->iCleanupItems->AppendL(aItem));
 354         return err;
 355 }
 356
 357 void EpocSdlEnv::RemoveCleanupItem(TAny* aItem)
 358 {
 359         for(int i = 0; i < gEpocEnv->iCleanupItems->Count(); i++)
 360         {
 361                 if(gEpocEnv->iCleanupItems->At(i).iItem == aItem)
 362                         gEpocEnv->iCleanupItems->Delete(i);
 363         }
 364 }
 365
 366 void EpocSdlEnv::CleanupItems()
 367 {
 368         const TThreadId id = RThread().Id();
 369         int last = gEpocEnv->iCleanupItems->Count() - 1;
 370         int i;
 371
 372         for(i = last; i >= 0 ; i--)
 373         {
 374                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 375                 if(item.iThread == id)
 376                 {
 377                         item.iThread = TThreadId(0);
 378                         item.iOperation(item.iItem);
 379                 }
 380         }
 381
 382         last = gEpocEnv->iCleanupItems->Count() - 1;
 383
 384         for(i = last; i >= 0 ; i--)
 385         {
 386                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 387                 if(item.iThread == TThreadId(0))
 388                 {
 389                         gEpocEnv->iCleanupItems->Delete(i);
 390                 }
 391         }
 392 }
 393
 394 void EpocSdlEnv::FreeSurface()
 395 {
 396         Request(CSdlAppServ::EAppSrvDsaStatus);
 397         if(gEpocEnv->iDsa != NULL)
 398                 gEpocEnv->iDsa->Free();
 399 }
 400
 401 void EpocSdlEnv::PanicMain(const TDesC& aInfo, int aErr)
 402 {
 403         gEpocEnv->iAppSrv->PanicMain(aInfo, aErr);
 404 }
 405
 406 //Dsa is a low priority ao, it has to wait if its pending event, but ws
 407 //event has been prioritized before it
 408 //this is not called from app thread!
 409 void EpocSdlEnv::WaitDeviceChange()
 410 {
 411         gEpocEnv->iAppSrv->RequestValue(CSdlAppServ::EAppSrvWaitDsa);
 412 }
 413
 414 static TBool CheckSdl()
 415 {
 416         int isExit = ETrue;
 417         RThread sdl;
 418         if(sdl.Open(gEpocEnv->iId) == KErrNone)
 419         {
 420                 if(sdl.ExitType() == EExitPending)
 421                 {
 422                         isExit = EFalse;
 423                 }
 424                 sdl.Close();
 425         }
 426         return isExit;
 427 }
 428
 429 void EpocSdlEnvData::Free()
 430 {
 431         if(RThread().Id() == gEpocEnv->iId)
 432         {
 433                 if(iDsa != NULL)
 434                         iDsa->Free();
 435                 return;
 436         }
 437
 438         __ASSERT_ALWAYS(iArgv == NULL || CheckSdl(), PANIC(KErrNotReady));
 439 }
 440
 441 void EpocSdlEnvData::Delete()
 442 {
 443         for(int i = 0; i <= iArgc; i++)
 444         {
 445                 if(iArgv != NULL)
 446                         delete[] iArgv[i];
 447         }
 448
 449         delete[] iArgv;
 450
 451         iArgv = NULL;
 452         iArgc = 0;
 453
 454         delete iEventQueue;
 455
 456         if(iDsa != NULL)
 457                 iDsa->Free();
 458
 459         delete iDsa;
 460         delete iAppSrv;
 461 }
 462
 463 static int MainL()
 464 {
 465         gEpocEnv->iCleanupItems = new CArrayFixFlat<TSdlCleanupItem>(8);
 466
 467         char** envp=0;
 468         /* !! process exits here if there is "exit()" in main! */
 469         int ret = 0;
 470         for(int i = 0; i < 6; i++)
 471         {
 472                 void* f = (void*) gEpocEnv->iMain[i];
 473                 if(f != NULL)
 474                 {
 475                         switch(i)
 476                         {
 477                                 case 0:
 478                                         ret = ((mainfunc1)f)();
 479                                         return ret;
 480
 481                                 case 3:
 482                                         ((mainfunc1)f)();
 483                                         return ret;
 484
 485                                 case 1:
 486                                         ret = ((mainfunc2)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv());
 487                                         return ret;
 488
 489                                 case 4:
 490                                         ((mainfunc2)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv());
 491                                         return ret;
 492
 493                                 case 2:
 494                                         ret = ((mainfunc3)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv(), envp);
 495                                         return ret;
 496
 497                                 case 5:
 498                                         ((mainfunc3)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv(), envp);
 499                                         return ret;
 500                         }
 501                 }
 502         }
 503         PANIC(KErrNotFound);
 504         return 0;
 505 }
 506
 507 static int DoMain()
 508 {
 509         TBool fbsconnected = EFalse;
 510
 511         gEpocEnv->iAppSrv->Init();
 512
 513         TRAPD(err, err = MainL());
 514
 515         // Free resources and return
 516         EpocSdlEnv::CleanupItems();
 517
 518         gEpocEnv->iCleanupItems->Reset();
 519         delete gEpocEnv->iCleanupItems;
 520         gEpocEnv->iCleanupItems = NULL;
 521
 522         gEpocEnv->Free(); //free up in thread resources
 523
 524         if(fbsconnected)
 525                 RFbsSession::Disconnect();
 526
 527         if(gEpocEnv->iCallerStatus != NULL)
 528         {
 529                 User::RequestComplete(gEpocEnv->iCallerStatus, err);
 530                 return 0;
 531         }
 532         else
 533         {
 534                 return err == KErrNone ? 0 : err;
 535         }
 536 }
 537
 538 CSDL::~CSDL()
 539 {
 540         gEpocEnv->Free();
 541         gEpocEnv->Delete();
 542
 543         delete gEpocEnv;
 544         gEpocEnv = NULL;
 545 }
 546
 547 CSDL* CSDL::NewL()
 548 {
 549         __ASSERT_ALWAYS(gEpocEnv == NULL, PANIC(KErrAlreadyExists));
 550         gEpocEnv = new EpocSdlEnvData;
 551         Mem::FillZ(gEpocEnv, sizeof(EpocSdlEnvData));
 552
 553         gEpocEnv->iEventQueue = new CEventQueue();
 554         gEpocEnv->iAppSrv = new CSdlAppServ();
 555
 556         CSDL* sdl = new CSDL();
 557
 558         gEpocEnv->iSdl = sdl;
 559
 560         return sdl;
 561 }
 562
 563 void CSDL::SetContainerWindowL(RWindow& aWindow, RWsSession& aSession, CWsScreenDevice& aDevice)
 564 {
 565         if(gEpocEnv->iDsa == NULL)
 566                 gEpocEnv->iDsa = CDsa::CreateL(aSession);
 567         gEpocEnv->iDsa->ConstructL(aWindow, aDevice);
 568 }
 569
 570 int EpocSdlEnv::ApplyGlesDsa()
 571 {
 572         CDsa* dsa = NULL;
 573         TRAPD(err, dsa = gEpocEnv->iDsa->CreateGlesDsaL());
 574         gEpocEnv->iDsa = dsa;
 575         return err;
 576 }
 577
 578 RWindow* EpocSdlEnv::Window()
 579 {
 580         return gEpocEnv->iDsa->Window();
 581 }
 582
 583 void EpocSdlEnv::UpdateWholeScreen(bool val)
 584 {
 585         gEpocEnv->iDsa->m_updateWholeScreen = val;
 586 }
 587
 588 bool EpocSdlEnv::GetUpdateWholeScreen()
 589 {
 590         return gEpocEnv->iDsa->m_updateWholeScreen;
 591 }
 592
 593 void EpocSdlEnv::SetOrientation(CAknAppUi::TAppUiOrientation orientation, const TSize& aSize, TDisplayMode aMode)
 594 {
 595         gEpocEnv->iWaitingForOrientationChange = true;
 596         gEpocEnv->iSize = aSize;
 597         gEpocEnv->iMode = aMode;
 598
 599         TRAPD(err, static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->SetOrientationL(orientation));
 600 }
 601
 602 TThreadId CSDL::CallMainL(const TMainFunc& aFunc, TRequestStatus* const aStatus, const CDesC8Array* const aArg)
 603 {
 604         ASSERT(gEpocEnv != NULL);
 605         gEpocEnv->iMain = aFunc;
 606         const TBool args = aArg != NULL;
 607
 608         gEpocEnv->iArgc = args ? aArg->Count() + 1 : 0;
 609         gEpocEnv->iArgv = new char*[gEpocEnv->iArgc + 2];
 610
 611         int k = 0;
 612         const TFileName processName = RProcess().FileName();
 613         const int len = processName.Length();
 614         gEpocEnv->iArgv[k] = new char[len + 1];
 615         Mem::Copy(gEpocEnv->iArgv[k], processName.Ptr(), len);
 616         gEpocEnv->iArgv[k][len] = 0;
 617
 618         for(int i = 0; args && (i < aArg->Count()); i++)
 619         {
 620                 k++;
 621                 const int len = aArg->MdcaPoint(i).Length();
 622                 gEpocEnv->iArgv[k] = new char[len + 1];
 623                 Mem::Copy(gEpocEnv->iArgv[k], aArg->MdcaPoint(i).Ptr(), len);
 624                 gEpocEnv->iArgv[k][len] = 0;
 625         }
 626
 627         gEpocEnv->iArgv[k + 1] = NULL;
 628
 629         gEpocEnv->iAppSrv->ConstructL();
 630
 631         // for handling volume up/down keys
 632         CRemConInterfaceSelector *iSelector = CRemConInterfaceSelector::NewL();
 633         CRemConCoreApiTarget::NewL( *iSelector, *this );
 634         iSelector->OpenTargetL();
 635
 636         gEpocEnv->iCallerStatus = aStatus;
 637         if(aStatus != NULL)
 638                 *aStatus = KRequestPending;
 639         gEpocEnv->iId = RThread().Id();
 640         // when priority is not lowered screen updates much more frequently, which
 641         // may be undesired, for example in case of openttd's generating world dialog
 642         RThread().SetPriority(EPriorityLess);
 643         DoMain();
 644
 645         return gEpocEnv->iId;
 646 }
 647
 648 void CSDL::AppendWsEvent(const TWsEvent& aEvent)
 649 {
 650         EpocSdlEnv::EventQueue().Append(aEvent);
 651 }
 652
 653 void CSDL::SDLPanic(const TDesC& aInfo, int aErr)
 654 {
 655         EpocSdlEnv::PanicMain(aInfo, aErr);
 656 }
 657
 658 int CSDL::GetSDLCode(int aScanCode)
 659 {
 660         if(aScanCode < 0)
 661                 return MAX_SCANCODE;
 662         if(aScanCode >= MAX_SCANCODE)
 663                 return -1;
 664         return KeyMap()[aScanCode];
 665 }
 666
 667 int CSDL::SDLCodesCount() const
 668 {
 669         return MAX_SCANCODE;
 670 }
 671
 672 void CSDL::ResetSDLCodes()
 673 {
 674         ResetKeyMap();
 675 }
 676
 677 int CSDL::SetSDLCode(int aScanCode, int aSDLCode)
 678 {
 679         const int current = GetSDLCode(aScanCode);
 680         if(aScanCode >= 0 && aScanCode < MAX_SCANCODE)
 681                 KeyMap()[aScanCode] = static_cast<SDLKey>(aSDLCode);
 682         return current;
 683 }
 684
 685 void CSDL::Resume()
 686 {
 687         EpocSdlEnv::Resume();
 688 }
 689
 690 void CSDL::Suspend()
 691 {
 692         if(gEpocEnv->iDsa != NULL)
 693                 gEpocEnv->iDsa->DoStop();
 694 }
 695
 696 void CSDL::Resize()
 697 {
 698         if(gEpocEnv->iWaitingForOrientationChange)
 699         {
 700                 EpocSdlEnv::AllocSurface(gEpocEnv->iSize, gEpocEnv->iMode);
 701                 gEpocEnv->iWaitingForOrientationChange = false;
 702         }
 703         else
 704         {
 705                 TSize size = gEpocEnv->iDsa->Window()->Size();
 706                 SDL_PrivateResize(size.iWidth, size.iHeight);
 707         }
 708 }
 709
 710 void CSDL::MrccatoCommand(TRemConCoreApiOperationId aOperationId, TRemConCoreApiButtonAction aButtonAct)
 711 {
 712         if(aButtonAct != ERemConCoreApiButtonClick)
 713                 return;
 714
 715         TWsEvent event;
 716         event.SetType(EEventKey);
 717         event.SetTimeNow();
 718
 719         switch(aOperationId)
 720         {
 721         case ERemConCoreApiVolumeDown:
 722                 event.Key()->iScanCode = EStdKeyDecVolume;
 723                 event.SetType(EEventKeyDown);
 724                 AppendWsEvent(event);
 725                 event.SetType(EEventKeyUp);
 726                 AppendWsEvent(event);
 727                 break;
 728
 729         case ERemConCoreApiVolumeUp:
 730                 event.Key()->iScanCode = EStdKeyIncVolume;
 731                 event.SetType(EEventKeyDown);
 732                 AppendWsEvent(event);
 733                 event.SetType(EEventKeyUp);
 734                 AppendWsEvent(event);
 735                 break;
 736
 737         default:
 738                 break;
 739         }
 740 }