loadgen/ui/hb/src/enginewrapper.cpp
branchRCL_3
changeset 21 b3cee849fa46
equal deleted inserted replaced
20:48060abbbeaf 21:b3cee849fa46
       
     1 /*
       
     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description: 
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #include <hbmainwindow.h>
       
    20 //#include <hbcommonnote.h>
       
    21 #include <hbpopup.h>
       
    22 #include <hbaction.h>
       
    23 
       
    24 #include <QString>
       
    25  #include <QStringList>
       
    26  
       
    27 #include <e32std.h>
       
    28 #include <e32base.h>
       
    29 
       
    30 #include "notifications.h"
       
    31 #include "enginewrapper.h"
       
    32 #include "settingsview.h"
       
    33 #include "engine.h"
       
    34 #include "mainview.h"
       
    35 
       
    36 QStringList LOADTYPES = (QStringList() << "CPU load" << "Memory eat" << "Phone calls" << "Messages" 
       
    37 									   << "Network conn." << "Key presses" << "Applications" << "Photo captures" 
       
    38 									   << "Bluetooth actions" << "Pointer events");
       
    39 
       
    40 // ---------------------------------------------------------------------------
       
    41 
       
    42 EngineWrapper::EngineWrapper(HbMainWindow &mainWindow, MainView &mainView)
       
    43 : mEngine(0), 
       
    44   mMainView(mainView),
       
    45   mMainWindow(mainWindow),
       
    46   mEditExistingLoad(false)
       
    47 {
       
    48 }
       
    49 
       
    50 // ---------------------------------------------------------------------------
       
    51 
       
    52 EngineWrapper::~EngineWrapper()
       
    53 {
       
    54     if (mEngine != 0) {
       
    55 		TRAP_IGNORE(mEngine->DeActivateEngineL());
       
    56         delete mEngine;
       
    57     }
       
    58 }
       
    59 
       
    60 // ---------------------------------------------------------------------------
       
    61 
       
    62 bool EngineWrapper::init()
       
    63 {
       
    64 	TInt err = KErrNone;
       
    65     TRAP(err, mEngine = CEngine::NewL(this));
       
    66     if(err != KErrNone) {
       
    67         return false;
       
    68     }
       
    69     else {
       
    70 		TRAP(err, mEngine->ActivateEngineL());
       
    71 		if (err != KErrNone) {
       
    72 			return false;
       
    73 		}
       
    74 		else {
       
    75 			return true;
       
    76 		}
       
    77     }
       
    78 }
       
    79 
       
    80 // ---------------------------------------------------------------------------	
       
    81 
       
    82 bool EngineWrapper::startNewLoad(int commandId)
       
    83 {
       
    84 	TRAPD(err, mEngine->StartNewLoadL(commandId));
       
    85 
       
    86 	// error handling
       
    87     if(err != KErrNone) {
       
    88         return false;
       
    89     }
       
    90     else {
       
    91         return true;
       
    92     }
       
    93 }
       
    94 
       
    95 // ---------------------------------------------------------------------------
       
    96 
       
    97 void EngineWrapper::launchPerfMonApp()
       
    98 {
       
    99 	TRAPD(err, mEngine->LaunchPerfMonL());
       
   100 	// error handling
       
   101     if(err != KErrNone) {
       
   102         Notifications::error("Perf Mon launch failed.");
       
   103     }
       
   104 }
       
   105 
       
   106 // ---------------------------------------------------------------------------
       
   107 
       
   108 void EngineWrapper::loadAddedOrEdited(TLoadGenCommandIds cmdId)
       
   109 {
       
   110 	if (mEditExistingLoad == false) {
       
   111 		TRAP_IGNORE(mEngine->DoStartNewLoadL(cmdId));
       
   112 	}
       
   113 	else {
       
   114 		TRAP_IGNORE(mEngine->ExistingLoadEditedL());
       
   115 	}
       
   116 }
       
   117 
       
   118 // ---------------------------------------------------------------------------
       
   119 
       
   120 void EngineWrapper::loadSettingsCanclled()
       
   121 {
       
   122 	if (mEditExistingLoad == true) {
       
   123 		TRAP_IGNORE(mEngine->ExistingLoadEditCancelled());
       
   124 	}
       
   125 }
       
   126 
       
   127 // ---------------------------------------------------------------------------
       
   128 
       
   129 void EngineWrapper::loadEdit(int rowIndex)
       
   130 {
       
   131 	TRAPD(err, mEngine->EditLoadL(rowIndex));
       
   132 	// error handling
       
   133     if(err != KErrNone) {
       
   134         Notifications::error("Load edit failed.");
       
   135     }
       
   136 }
       
   137 
       
   138 void EngineWrapper::StopLoadYesNoDialogClosed(HbAction *action)
       
   139 {
       
   140     if( action && !action->text().compare("yes", Qt::CaseInsensitive) ){
       
   141         const CArrayFix<TInt>* selectionIndexes = NULL;
       
   142         try{
       
   143             QT_TRAP_THROWING( selectionIndexes = QueryListSelectedIndexesOrCurrentItemL() );
       
   144             if(selectionIndexes)
       
   145                 QT_TRAP_THROWING( mEngine->StopSelectedOrHighlightedItemsL(selectionIndexes) );
       
   146         }
       
   147         catch(...){
       
   148             Notifications::error("Stop load failed.");
       
   149         }
       
   150         if(selectionIndexes)
       
   151             delete selectionIndexes;
       
   152     }
       
   153 }
       
   154 
       
   155 // ---------------------------------------------------------------------------
       
   156 bool EngineWrapper::stopLoad(bool stopAll)
       
   157 {
       
   158 	TInt err = KErrNone;
       
   159 	if (stopAll == true) {
       
   160 		TRAP(err, mEngine->StopAllLoadItemsL());
       
   161 		// error handling
       
   162         if(err != KErrNone) {
       
   163             return false;
       
   164         }
       
   165         else {
       
   166             return true;
       
   167         }   
       
   168 	}
       
   169 	else {
       
   170         // by default use selected items
       
   171         QList<int> listIndices = mMainView.listSelectionIndexes();
       
   172         if (listIndices.count() > 0)
       
   173             {
       
   174             QString message = QString("Stop %1 selections?").arg( listIndices.count() );
       
   175             HbMessageBox::question(message, this, SLOT(StopLoadYesNoDialogClosed(HbAction *)));
       
   176             }
       
   177         else{
       
   178              TInt currentItemIndex = mMainView.currentItemIndex();
       
   179              if (mEngine->LoadItemCount() > currentItemIndex && currentItemIndex >= 0)
       
   180                  {
       
   181                  QString message("Stop highlighted selections?");
       
   182                  HbMessageBox::question(message, this, SLOT(StopLoadYesNoDialogClosed(HbAction *)));
       
   183                  }
       
   184             }
       
   185         return true;
       
   186 	}
       
   187 	
       
   188 }
       
   189 
       
   190 // ---------------------------------------------------------------------------
       
   191 
       
   192 void EngineWrapper::resumeAllLoadItems()
       
   193 {
       
   194 	TRAPD(err, mEngine->ResumeAllLoadItemsL());
       
   195 	// error handling
       
   196     if(err != KErrNone) {
       
   197         Notifications::error("Error in loads resume.");
       
   198     }
       
   199 }
       
   200 
       
   201 // ---------------------------------------------------------------------------
       
   202 
       
   203 void EngineWrapper::suspendAllLoadItems()
       
   204 {
       
   205 	TRAPD(err, mEngine->SuspendAllLoadItemsL());
       
   206 	// error handling
       
   207     if(err != KErrNone) {
       
   208         Notifications::error("Error in loads resume.");
       
   209     }
       
   210 }
       
   211 
       
   212 // ---------------------------------------------------------------------------
       
   213 
       
   214 void EngineWrapper::suspendOrResumeSelectedOrHighlightedItems()
       
   215 {
       
   216 	TRAPD(err, mEngine->SuspendOrResumeSelectedOrHighlightedItemsL());
       
   217 	// error handling
       
   218     if(err != KErrNone) {
       
   219         Notifications::error("Error to show item action menu.");
       
   220     }
       
   221 }
       
   222 
       
   223 // ---------------------------------------------------------------------------
       
   224 
       
   225 void EngineWrapper::ShowErrorMessage(const TDesC& aErrorMessage)
       
   226 {
       
   227     QString errorMessage((QChar*)aErrorMessage.Ptr(),aErrorMessage.Length());
       
   228     Notifications::error(errorMessage);
       
   229  
       
   230 }
       
   231 
       
   232 // ---------------------------------------------------------------------------
       
   233 
       
   234 void EngineWrapper::ShowNote(const TDesC& aNoteMessage)
       
   235 {
       
   236     QString note((QChar*)aNoteMessage.Ptr(),aNoteMessage.Length());
       
   237     Notifications::showGlobalNote(note, HbMessageBox::MessageTypeInformation, HbPopup::StandardTimeout);
       
   238 }
       
   239  
       
   240 // ---------------------------------------------------------------------------
       
   241 
       
   242 TInt EngineWrapper::QueryCurrentItemIndex()
       
   243 {
       
   244 	return mMainView.currentItemIndex();
       
   245 }
       
   246 
       
   247 // ---------------------------------------------------------------------------
       
   248 
       
   249 const CArrayFix<TInt>*  EngineWrapper::QueryListSelectedIndexesOrCurrentItemL()
       
   250 {
       
   251 	QList<int> listIndices = mMainView.listSelectionIndexes();
       
   252 	TInt cnt = listIndices.count();
       
   253     CArrayFix<TInt>* indices = new(ELeave)CArrayFixFlat<TInt>( cnt > 0 ? cnt : 1 );
       
   254     CleanupDeletePushL(indices);
       
   255     if(cnt > 0){
       
   256         for (TInt i = 0; i < cnt; i++) {
       
   257             indices->AppendL(listIndices.at(i));
       
   258         }
       
   259     }
       
   260     else{
       
   261         indices->AppendL(mMainView.currentItemIndex());
       
   262     }
       
   263     CleanupStack::Pop(indices);
       
   264     return static_cast<const CArrayFix<TInt>*>(indices);	
       
   265 }
       
   266 
       
   267 // ---------------------------------------------------------------------------
       
   268 
       
   269 void EngineWrapper::OpenLoadSettings(TInt loadType, bool editExistingLoad)
       
   270 {
       
   271 	SettingsView* settings = new SettingsView((HbView&)ViewReference(), 
       
   272 											  WindowReference(), 
       
   273 											  *this);
       
   274 	mEditExistingLoad = editExistingLoad;
       
   275 
       
   276 	switch (loadType) {
       
   277 		case ELoadGenCmdNewLoadCPULoad: {
       
   278 			settings->open(LOADTYPES.at(Cpu), 
       
   279 			               (TLoadGenCommandIds)loadType);
       
   280 			break;
       
   281 		}
       
   282 		case ELoadGenCmdNewLoadEatMemory: {
       
   283 			settings->open(LOADTYPES.at(EatMemory), 
       
   284 			               (TLoadGenCommandIds)loadType);
       
   285 			break;
       
   286 		}
       
   287 		case ELoadGenCmdNewLoadPhoneCall: {
       
   288 			settings->open(LOADTYPES.at(PhoneCalls), 
       
   289 			               (TLoadGenCommandIds)loadType);
       
   290 			break;
       
   291 		}
       
   292 		case ELoadGenCmdNewLoadNetConn: {
       
   293 			settings->open(LOADTYPES.at(NWConnections),
       
   294                            (TLoadGenCommandIds)loadType);
       
   295 			break;
       
   296 		}
       
   297 		case ELoadGenCmdNewLoadKeyPress: {
       
   298 			settings->open(LOADTYPES.at(KeyPresses), 
       
   299 			               (TLoadGenCommandIds)loadType);
       
   300 			break;
       
   301 		}
       
   302 		case ELoadGenCmdNewLoadMessages: {
       
   303 			settings->open(LOADTYPES.at(Messages), 
       
   304 			               (TLoadGenCommandIds)loadType);
       
   305 			break;
       
   306 		}
       
   307 		case ELoadGenCmdNewLoadApplications: {
       
   308 			settings->open(LOADTYPES.at(Apps), 
       
   309 			               (TLoadGenCommandIds)loadType);
       
   310 			break;
       
   311 		}
       
   312 		case ELoadGenCmdNewLoadPhotoCaptures: {
       
   313 			settings->open(LOADTYPES.at(Photos), 
       
   314 			               (TLoadGenCommandIds)loadType);
       
   315 			break;
       
   316 		}
       
   317 		case ELoadGenCmdNewLoadBluetooth: {
       
   318 			settings->open(LOADTYPES.at(BTAct), 
       
   319 						   (TLoadGenCommandIds)loadType);
       
   320 			break;
       
   321 		}
       
   322 		case ELoadGenCmdNewLoadPointerEvent: {
       
   323 			settings->open(LOADTYPES.at(PointerEvents),
       
   324 						   (TLoadGenCommandIds)loadType);
       
   325 			break;
       
   326 		}
       
   327 		default: {
       
   328 			User::Panic(_L("Wrong new load"), 111);
       
   329 			break;
       
   330 		}
       
   331 	}
       
   332 }
       
   333 
       
   334 // ---------------------------------------------------------------------------	
       
   335 
       
   336 CPULoadAttributes EngineWrapper::getCpuLoadAttributes()
       
   337 {
       
   338     TCPULoadAttributes tCpuLoadAttributes = mEngine->GetCPULoadAttributes();
       
   339     CPULoadAttributes attributes;
       
   340 	
       
   341 	attributes.mId = tCpuLoadAttributes.iId;
       
   342 	attributes.mPriority = tCpuLoadAttributes.iPriority;
       
   343 	attributes.mMode = tCpuLoadAttributes.iMode;
       
   344 	attributes.mType = tCpuLoadAttributes.iType;
       
   345 	attributes.mLength = tCpuLoadAttributes.iLength;
       
   346 	attributes.mIdle = tCpuLoadAttributes.iIdle;
       
   347 	attributes.mRandomVariance = tCpuLoadAttributes.iRandomVariance;
       
   348 	attributes.mCpu = tCpuLoadAttributes.iCpu;
       
   349 	attributes.mCpuCount = tCpuLoadAttributes.iCpuCount;
       
   350 	return attributes;
       
   351 }
       
   352 
       
   353 // ---------------------------------------------------------------------------	
       
   354 
       
   355 void EngineWrapper::setCpuLoadAttributes(CPULoadAttributes attributes)
       
   356 {
       
   357     TCPULoadAttributes tCpuLoadAttributes;
       
   358 
       
   359 	tCpuLoadAttributes.iId = attributes.mId;
       
   360 	tCpuLoadAttributes.iPriority = attributes.mPriority;
       
   361 	tCpuLoadAttributes.iMode = attributes.mMode;
       
   362 	tCpuLoadAttributes.iType = attributes.mType;
       
   363 	tCpuLoadAttributes.iLength = attributes.mLength;
       
   364 	tCpuLoadAttributes.iIdle = attributes.mIdle;
       
   365 	tCpuLoadAttributes.iRandomVariance = attributes.mRandomVariance;
       
   366 	tCpuLoadAttributes.iCpu = attributes.mCpu;
       
   367 	tCpuLoadAttributes.iCpuCount = attributes.mCpuCount;	
       
   368 	
       
   369 	mEngine->ChangeCPULoadAttributes(tCpuLoadAttributes);
       
   370 }
       
   371 
       
   372 // ---------------------------------------------------------------------------	
       
   373 
       
   374 MemoryEatAttributes EngineWrapper::getMemoryEatAttributes()
       
   375 {
       
   376 
       
   377     TMemoryEatAttributes tMemoryEatAttributes = mEngine->GetMemoryEatAttributes();
       
   378     MemoryEatAttributes attributes;
       
   379 
       
   380     // Convert TMemoryEatAttributes to MemoryEatAttributes 
       
   381     attributes.mId         = tMemoryEatAttributes.iId;
       
   382     attributes.mPriority   = tMemoryEatAttributes.iPriority; 
       
   383 	attributes.mSource     = tMemoryEatAttributes.iSource;
       
   384 	attributes.mType       = tMemoryEatAttributes.iType;
       
   385 	attributes.mBuffer     = tMemoryEatAttributes.iBuffer;
       
   386 	attributes.mIdle       = tMemoryEatAttributes.iIdle;
       
   387 	attributes.mAmount     = tMemoryEatAttributes.iAmount;
       
   388 	attributes.mRandomMin  = tMemoryEatAttributes.iRandomMin;
       
   389 	attributes.mRandomMax  = tMemoryEatAttributes.iRandomMax;
       
   390 
       
   391     TBuf<64> amount;
       
   392     amount.Copy(tMemoryEatAttributes.iAmountDes);
       
   393     attributes.mAmountDes = QString((QChar*)amount.Ptr(), amount.Length()); 
       
   394 
       
   395     TBuf<64> min;
       
   396     min.Copy(tMemoryEatAttributes.iRandomMinDes);
       
   397     attributes.mAmountDes = QString((QChar*)min.Ptr(), min.Length()); 
       
   398 
       
   399     TBuf<64> max;
       
   400     max.Copy(tMemoryEatAttributes.iRandomMaxDes);
       
   401     attributes.mAmountDes = QString((QChar*)max.Ptr(), max.Length());
       
   402 	
       
   403 	attributes.mRandomVariance  = tMemoryEatAttributes.iRandomVariance;
       
   404     return attributes;
       
   405 }	
       
   406 
       
   407 // ---------------------------------------------------------------------------	
       
   408 
       
   409 void EngineWrapper::setMemoryEatAttributes(MemoryEatAttributes attributes)
       
   410 {
       
   411 	TMemoryEatAttributes tMemoryEatAttributes = mEngine->GetMemoryEatAttributes();//TMemoryEatAttributes tMemoryEatAttributes;
       
   412 
       
   413 	tMemoryEatAttributes.iId = attributes.mId;
       
   414 	tMemoryEatAttributes.iPriority = attributes.mPriority;
       
   415 	tMemoryEatAttributes.iSource = attributes.mSource;
       
   416 	tMemoryEatAttributes.iType = attributes.mType;
       
   417 	tMemoryEatAttributes.iBuffer = attributes.mBuffer;
       
   418 	tMemoryEatAttributes.iIdle = attributes.mIdle;
       
   419 	tMemoryEatAttributes.iAmount = attributes.mAmount;
       
   420 	tMemoryEatAttributes.iRandomMin = attributes.mRandomMin;
       
   421 	tMemoryEatAttributes.iRandomMax = attributes.mRandomMax;
       
   422 
       
   423     TBuf<64> amount = attributes.mAmountDes.utf16();
       
   424     tMemoryEatAttributes.iAmountDes.Copy(amount);	
       
   425 	
       
   426     TBuf<64> min = attributes.mRandomMinDes.utf16();
       
   427     tMemoryEatAttributes.iRandomMinDes.Copy(min);
       
   428       
       
   429     TBuf<64> max = attributes.mRandomMaxDes.utf16();
       
   430     tMemoryEatAttributes.iRandomMaxDes.Copy(max);
       
   431 	
       
   432 	tMemoryEatAttributes.iRandomVariance = attributes.mRandomVariance;
       
   433 	
       
   434 	mEngine->ChangeMemoryEatAttributes(tMemoryEatAttributes);
       
   435 }
       
   436 
       
   437 // ---------------------------------------------------------------------------	
       
   438 
       
   439 PhoneCallAttributes EngineWrapper::getPhoneCallAttributes()
       
   440 {
       
   441     TPhoneCallAttributes tPhoneCallAttributes = mEngine->GetPhoneCallAttributes();
       
   442     PhoneCallAttributes attributes;
       
   443 	
       
   444 	attributes.mId = tPhoneCallAttributes.iId;
       
   445 	attributes.mPriority = tPhoneCallAttributes.iPriority;
       
   446 
       
   447     TBuf<128> dest;
       
   448     dest.Copy(tPhoneCallAttributes.iDestination);
       
   449     attributes.mDestination = QString((QChar*)dest.Ptr(), dest.Length()); 	
       
   450 	
       
   451 	attributes.mLength = tPhoneCallAttributes.iLength;
       
   452 	attributes.mIdle = tPhoneCallAttributes.iIdle;
       
   453 	attributes.mRandomVariance = tPhoneCallAttributes.iRandomVariance;
       
   454 	return attributes;
       
   455 }
       
   456 
       
   457 // ---------------------------------------------------------------------------	
       
   458 
       
   459 void EngineWrapper::setPhoneCallAttributes(PhoneCallAttributes attributes)
       
   460 {
       
   461 	TPhoneCallAttributes tPhoneCallAttributes = mEngine->GetPhoneCallAttributes(); //TPhoneCallAttributes tPhoneCallAttributes;
       
   462 
       
   463 	tPhoneCallAttributes.iId = attributes.mId;
       
   464 	tPhoneCallAttributes.iPriority = attributes.mPriority;
       
   465 
       
   466     TBuf<128> dest = attributes.mDestination.utf16();
       
   467     tPhoneCallAttributes.iDestination.Copy(dest);	
       
   468 
       
   469 	tPhoneCallAttributes.iLength = attributes.mLength;
       
   470 	tPhoneCallAttributes.iIdle = attributes.mIdle;
       
   471 	tPhoneCallAttributes.iRandomVariance = attributes.mRandomVariance;
       
   472 	
       
   473 	mEngine->ChangePhoneCallAttributes(tPhoneCallAttributes);
       
   474 }
       
   475 
       
   476 // ---------------------------------------------------------------------------	
       
   477 
       
   478 NetConnAttributes EngineWrapper::getNetConnAttributes()
       
   479 {
       
   480     TNetConnAttributes tNetConnAttributes = mEngine->GetNetConnAttributes();
       
   481     NetConnAttributes attributes;
       
   482 	
       
   483 	attributes.mId = tNetConnAttributes.iId;
       
   484 	attributes.mPriority = tNetConnAttributes.iPriority;
       
   485 
       
   486     TBuf<128> dest;
       
   487     dest.Copy(tNetConnAttributes.iDestination);
       
   488     attributes.mDestination = QString((QChar*)dest.Ptr(), dest.Length()); 	
       
   489 
       
   490 	attributes.mIdle = tNetConnAttributes.iIdle;
       
   491 	attributes.mRandomVariance = tNetConnAttributes.iRandomVariance;
       
   492 	return attributes;
       
   493 }
       
   494 
       
   495 // ---------------------------------------------------------------------------	
       
   496 
       
   497 void EngineWrapper::setNetConnAttributes(NetConnAttributes attributes)
       
   498 {
       
   499 	TNetConnAttributes tNetConnAttributes = mEngine->GetNetConnAttributes(); //TNetConnAttributes tNetConnAttributes;
       
   500 
       
   501 	tNetConnAttributes.iId = attributes.mId;
       
   502 	tNetConnAttributes.iPriority = attributes.mPriority;
       
   503 
       
   504     TBuf<128> dest = attributes.mDestination.utf16();
       
   505     tNetConnAttributes.iDestination.Copy(dest);	
       
   506 
       
   507 	tNetConnAttributes.iIdle = attributes.mIdle;
       
   508 	tNetConnAttributes.iRandomVariance = attributes.mRandomVariance;
       
   509 	
       
   510 	mEngine->ChangeNetConnAttributes(tNetConnAttributes);
       
   511 }
       
   512 
       
   513 // ---------------------------------------------------------------------------	
       
   514 
       
   515 KeyPressAttributes EngineWrapper::getKeyPressAttributes()
       
   516 {
       
   517     TKeyPressAttributes tKeyPressAttributes = mEngine->GetKeyPressAttributes();
       
   518     KeyPressAttributes attributes;
       
   519 	
       
   520 	attributes.mId = tKeyPressAttributes.iId;
       
   521 	attributes.mPriority = tKeyPressAttributes.iPriority;
       
   522 	attributes.mHeartBeat = tKeyPressAttributes.iHeartBeat;	
       
   523 	attributes.mRandomVariance = tKeyPressAttributes.iRandomVariance;
       
   524 	return attributes;
       
   525 }
       
   526 
       
   527 // ---------------------------------------------------------------------------	
       
   528 
       
   529 void EngineWrapper::setKeyPressAttributes(KeyPressAttributes attributes)
       
   530 {
       
   531 	TKeyPressAttributes tKeyPressAttributes = mEngine->GetKeyPressAttributes(); //TKeyPressAttributes tKeyPressAttributes;
       
   532 
       
   533 	tKeyPressAttributes.iId = attributes.mId;
       
   534 	tKeyPressAttributes.iPriority = attributes.mPriority;
       
   535 	tKeyPressAttributes.iHeartBeat = attributes.mHeartBeat;
       
   536 	tKeyPressAttributes.iRandomVariance = attributes.mRandomVariance;
       
   537 	
       
   538 	mEngine->ChangeKeyPressAttributes(tKeyPressAttributes);
       
   539 }
       
   540 
       
   541 // ---------------------------------------------------------------------------	
       
   542 
       
   543 PointerEventAttributes EngineWrapper::getPointerEventAttributes()
       
   544 {
       
   545     TPointerEventAttributes tPointerEventAttributes = mEngine->GetPointerEventAttributes();
       
   546     PointerEventAttributes attributes;
       
   547 	
       
   548 	attributes.mId = tPointerEventAttributes.iId;
       
   549 	attributes.mPriority = tPointerEventAttributes.iPriority;
       
   550 	attributes.mHeartBeat = tPointerEventAttributes.iHeartBeat;	
       
   551 	attributes.mRandomVariance = tPointerEventAttributes.iRandomVariance;
       
   552 	return attributes;
       
   553 }
       
   554 
       
   555 // ---------------------------------------------------------------------------	
       
   556 
       
   557 void EngineWrapper::setPointerEventAttributes(PointerEventAttributes attributes)
       
   558 {
       
   559 	TPointerEventAttributes tPointerEventAttributes = mEngine->GetPointerEventAttributes();//TPointerEventAttributes tPointerEventAttributes;
       
   560 
       
   561 	tPointerEventAttributes.iId = attributes.mId;
       
   562 	tPointerEventAttributes.iPriority = attributes.mPriority;
       
   563 	tPointerEventAttributes.iHeartBeat = attributes.mHeartBeat;
       
   564 	tPointerEventAttributes.iRandomVariance = attributes.mRandomVariance;
       
   565 	
       
   566 	mEngine->ChangePointerEventAttributes(tPointerEventAttributes);
       
   567 }
       
   568 
       
   569 // ---------------------------------------------------------------------------	
       
   570 
       
   571 MessageAttributes EngineWrapper::getMessageAttributes()
       
   572 {
       
   573     TMessageAttributes tMessageAttributes = mEngine->GetMessageAttributes();
       
   574     MessageAttributes attributes;
       
   575 	
       
   576 	attributes.mId = tMessageAttributes.iId;
       
   577 	attributes.mMessageType = tMessageAttributes.iMessageType;
       
   578 
       
   579     TBuf<128> dest;
       
   580     dest.Copy(tMessageAttributes.iDestination);
       
   581     attributes.mDestination = QString((QChar*)dest.Ptr(), dest.Length()); 	
       
   582 	
       
   583 	attributes.mPriority = tMessageAttributes.iPriority;
       
   584 	attributes.mAmount = tMessageAttributes.iAmount;
       
   585 	attributes.mLength = tMessageAttributes.iLength;
       
   586 	attributes.mIdle = tMessageAttributes.iIdle;
       
   587 	attributes.mRandomVariance = tMessageAttributes.iRandomVariance;
       
   588 	return attributes;
       
   589 }
       
   590 
       
   591 // ---------------------------------------------------------------------------	
       
   592 
       
   593 void EngineWrapper::setMessageAttributes(MessageAttributes attributes)
       
   594 {
       
   595 	TMessageAttributes tMessageAttributes = mEngine->GetMessageAttributes();//TMessageAttributes tMessageAttributes;
       
   596 
       
   597 	tMessageAttributes.iId = attributes.mId;
       
   598 	tMessageAttributes.iMessageType = attributes.mMessageType;
       
   599     
       
   600 	TBuf<128> dest = attributes.mDestination.utf16();
       
   601     tMessageAttributes.iDestination.Copy(dest);	
       
   602 	
       
   603 	tMessageAttributes.iPriority = attributes.mPriority;
       
   604 	tMessageAttributes.iAmount = attributes.mAmount;
       
   605 	tMessageAttributes.iLength = attributes.mLength;
       
   606 	tMessageAttributes.iIdle = attributes.mIdle;
       
   607 	tMessageAttributes.iRandomVariance = attributes.mRandomVariance;
       
   608 	
       
   609 	mEngine->ChangeMessageAttributes(tMessageAttributes);
       
   610 }
       
   611 
       
   612 // ---------------------------------------------------------------------------	
       
   613 
       
   614 ApplicationsAttributes EngineWrapper::getApplicationsAttributes()
       
   615 {
       
   616     TApplicationsAttributes tApplicationsAttributes = mEngine->GetApplicationsAttributes();
       
   617     ApplicationsAttributes attributes;
       
   618 	
       
   619 	attributes.mId = tApplicationsAttributes.iId;
       
   620 	attributes.mPriority = tApplicationsAttributes.iPriority;
       
   621 	attributes.mLaunchingInterval = tApplicationsAttributes.iLaunchingInterval;
       
   622 	attributes.mKeyPressType = tApplicationsAttributes.iKeyPressType;
       
   623 	attributes.mMaxOpen = tApplicationsAttributes.iMaxOpen;
       
   624 	attributes.mHeartBeat = tApplicationsAttributes.iHeartBeat;
       
   625 	attributes.mRandomVariance = tApplicationsAttributes.iRandomVariance;
       
   626 
       
   627 	return attributes;
       
   628 }
       
   629 
       
   630 // ---------------------------------------------------------------------------	
       
   631 
       
   632 void EngineWrapper::setApplicationsAttributes(ApplicationsAttributes attributes)
       
   633 {
       
   634 	TApplicationsAttributes tApplicationsAttributes = mEngine->GetApplicationsAttributes(); //TApplicationsAttributes tApplicationsAttributes;
       
   635 
       
   636 	tApplicationsAttributes.iId = attributes.mId;
       
   637 	tApplicationsAttributes.iPriority = attributes.mPriority;
       
   638 	tApplicationsAttributes.iLaunchingInterval = attributes.mLaunchingInterval;
       
   639 	tApplicationsAttributes.iKeyPressType = attributes.mKeyPressType;
       
   640 	tApplicationsAttributes.iMaxOpen = attributes.mMaxOpen;
       
   641 	tApplicationsAttributes.iHeartBeat = attributes.mHeartBeat;	
       
   642 	tApplicationsAttributes.iRandomVariance = attributes.mRandomVariance;
       
   643 	
       
   644 	mEngine->ChangeApplicationsAttributes(tApplicationsAttributes);
       
   645 }
       
   646 
       
   647     QStringList mAppsArray;
       
   648 
       
   649 // ---------------------------------------------------------------------------	
       
   650 
       
   651 PhotoCaptureAttributes EngineWrapper::getPhotoCaptureAttributes()
       
   652 {
       
   653     TPhotoCaptureAttributes tPhotoCaptureAttributes = mEngine->GetPhotoCaptureAttributes();
       
   654     PhotoCaptureAttributes attributes;
       
   655 	
       
   656 	attributes.mId = tPhotoCaptureAttributes.iId;
       
   657 	attributes.mPriority = tPhotoCaptureAttributes.iPriority;
       
   658 	attributes.mCameraCount = tPhotoCaptureAttributes.iCameraCount;	
       
   659 	attributes.mCamera = tPhotoCaptureAttributes.iCamera;
       
   660 	attributes.mIdle = tPhotoCaptureAttributes.iIdle;
       
   661 	attributes.mRandomVariance = tPhotoCaptureAttributes.iRandomVariance;
       
   662 	return attributes;
       
   663 }
       
   664 
       
   665 // ---------------------------------------------------------------------------	
       
   666 
       
   667 void EngineWrapper::setPhotoCaptureAttributes(PhotoCaptureAttributes attributes)
       
   668 {
       
   669 	TPhotoCaptureAttributes tPhotoCaptureAttributes;
       
   670 
       
   671 	tPhotoCaptureAttributes.iId = attributes.mId;
       
   672 	tPhotoCaptureAttributes.iPriority = attributes.mPriority;
       
   673 	tPhotoCaptureAttributes.iCameraCount = attributes.mCameraCount;	
       
   674 	tPhotoCaptureAttributes.iCamera = attributes.mCamera;
       
   675 	tPhotoCaptureAttributes.iIdle = attributes.mIdle;
       
   676 	tPhotoCaptureAttributes.iRandomVariance = attributes.mRandomVariance;
       
   677 	
       
   678 	mEngine->ChangePhotoCaptureAttributes(tPhotoCaptureAttributes);
       
   679 }
       
   680 
       
   681 // ---------------------------------------------------------------------------	
       
   682 
       
   683 BluetoothAttributes EngineWrapper::getBluetoothAttributes()
       
   684 {
       
   685     TBluetoothAttributes tBluetoothAttributes = mEngine->GetBluetoothAttributes();
       
   686     BluetoothAttributes attributes;
       
   687 	
       
   688 	attributes.mId = tBluetoothAttributes.iId;
       
   689 	attributes.mPriority = tBluetoothAttributes.iPriority;
       
   690 	attributes.mIdle = tBluetoothAttributes.iIdle;
       
   691 	attributes.mRandomVariance = tBluetoothAttributes.iRandomVariance;
       
   692 	return attributes;
       
   693 }
       
   694 
       
   695 // ---------------------------------------------------------------------------	
       
   696 
       
   697 void EngineWrapper::setBluetoothAttributes(BluetoothAttributes attributes)
       
   698 {
       
   699     TBluetoothAttributes tBluetoothAttributes;
       
   700 
       
   701 	tBluetoothAttributes.iId = attributes.mId;
       
   702 	tBluetoothAttributes.iPriority = attributes.mPriority;
       
   703 	tBluetoothAttributes.iIdle = attributes.mIdle;
       
   704 	tBluetoothAttributes.iRandomVariance = attributes.mRandomVariance;
       
   705 	
       
   706 	mEngine->ChangeBluetoothAttributes(tBluetoothAttributes);
       
   707 }
       
   708 
       
   709 // ---------------------------------------------------------------------------
       
   710 
       
   711 void EngineWrapper::ReFreshView(CDesCArray* aTextArray) 
       
   712 {
       
   713 	QStringList itemList;
       
   714 	TInt arrayCnt = aTextArray->Count();
       
   715 	for (int i = 0; i < arrayCnt; i++) {
       
   716 		itemList.append(QString::fromUtf16(
       
   717 				  aTextArray->MdcaPoint(i).Ptr(),
       
   718 				  aTextArray->MdcaPoint(i).Length()));
       
   719 	}
       
   720 	mMainView.setLoadListData(itemList);
       
   721 }
       
   722 
       
   723 // ---------------------------------------------------------------------------	
       
   724 
       
   725 void EngineWrapper::ClearSelection()
       
   726 {
       
   727 	mMainView.clearListSelection();
       
   728 }
       
   729 
       
   730 // ---------------------------------------------------------------------------	
       
   731 
       
   732 void EngineWrapper::SetCurrentItemIndex(TInt aIndex) 
       
   733 {
       
   734 	mMainView.setCurrentItemIndex(aIndex); 
       
   735 }
       
   736 
       
   737 // ---------------------------------------------------------------------------