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 #include "settingsview.h"

    19 #include "enginewrapper.h"

    20 #include "loadgen.hrh"

    21 #include "loadgen_loadattributes.h"

    22 #include <hbmainwindow.h>

    23 #include <hbview.h>

    24 //#include <hbformitem.h>

    25 #include <hbmenu.h>

    26 #include <hbaction.h>

    27 #include <hbmessagebox.h>

    28 //#include <hbcommonnote.h>

    29 #include <hbtoolbar.h>

    30 #include <hbdataform.h>

    31 #include <hbdataformmodelitem.h>

    32 #include <hbdataformmodel.h>

    33 #include <hbdataformviewitem.h>

    34 #include <hbabstractviewitem.h>

    35 #include <hbradiobuttonlist.h>

    36 

    37 

    38 #include <QStringList>

    39 

    40 QStringList PRIORITIES = (QStringList() << "Much less (-20)" << "Less (-10)" << "Normal (0)" << "More (10)" 

    41 						 << "Much more (20)" << "Real time (30)" << "Abs. very low (100)" << "Abs. low (200)" 

    42 						 << "Abs. backgr. (300)" << "Abs. foregr. (400)" << "Abs. high (500)");

    43 QStringList LOADMODES = (QStringList() << "Yielding" << "Blocking");

    44 QStringList CPULOADTYPES = (QStringList() << "Continuous" << "Periodic");		   

    45 QStringList MEMSOURCES = (QStringList() << "RAM" << "C:" << "D:" << "E:" << "F:" << "G:" << "H:" << "J:" << "K:" 

    46 										<< "L:" << "M:" << "N:");

    47 QStringList MEMEATTYPES = (QStringList() << "Memory to eat" << "Memory to be left" << "Alternate min/max");

    48 QStringList KEYPRESSTYPES = (QStringList() << "None" << "Arrow keys");

    49 QStringList MESSAGETYPES = (QStringList() << "SMS" << "MMS");

    50 

    51 		   

    52 SettingsView::SettingsView(HbView &mainView, HbMainWindow &parent, EngineWrapper &engine)

    53                           

    54     : mMainWindow(parent),

    55       mMainView(mainView),

    56       mEngineWrapper(engine),

    57 	  mAmount(NULL),

    58 	  mMinAmountToBeLeft(NULL),

    59 	  mMaxAmountToBeLeft(NULL),

    60 	  mLength(NULL),

    61 	  mIdle(NULL),

    62 	  mRandomVar(NULL)

    63 {

    64 }

    65 

    66 SettingsView::~SettingsView()

    67 {

    68 

    69 }

    70 

    71 // TODO HbDataFormModelItem data operations does not work correctly with WK38.

    72 // Item data does not get updated correctly as set by initial settings(HbDataFormModelItem::RadioButtonListItem) 

    73 // or user settings.(HbDataFormModelItem::TextItem)

    74 

    75 // ---------------------------------------------------------------------------

    76 

    77 void SettingsView::open(const QString &settingsName, TLoadGenCommandIds cmdId)

    78 {

    79 	mCmdId = cmdId;

    80     // Remove main view from main window and add this view to main window

    81     mMainWindow.addView(this);

    82     mMainWindow.setCurrentView(this);

    83     setTitle(settingsName);

    84 

    85     //create toolbar showing launch popup

    86     HbToolBar *toolBar = this->toolBar();

    87     HbAction *actionOk = new HbAction("Ok", toolBar);

    88     HbAction *actionCancel = new HbAction("Cancel", toolBar);

    89     toolBar->addAction( actionOk );

    90     toolBar->addAction( actionCancel );	

    91 

    92     //create setting form

    93     mSettingForm = new HbDataForm();

    94     

    95     //create a model class

    96     mModel = new HbDataFormModel(this);

    97 	createItems(mModel, 0);

    98     // Set created model to form

    99     mSettingForm->setModel(mModel);

   100     setWidget(mSettingForm);

   101 	loadAttributes();	

   102 	

   103     connect(actionOk, SIGNAL(triggered()), this, SLOT(okExit()));

   104 	connect(actionCancel, SIGNAL(triggered()), this, SLOT(cancelled()));

   105 	connect(this, SIGNAL(aboutToClose()), this, SLOT(backButtonPressed()));

   106 	//connect(mSettingForm, SIGNAL(activated(const QModelIndex)), this, SLOT(dataItemDisplayed(const QModelIndex)));

   107 	show();

   108 }

   109 

   110 // ---------------------------------------------------------------------------

   111 

   112 void SettingsView::createItems(HbDataFormModel *model, 

   113 							   HbDataFormModelItem *parent)

   114 {

   115 	switch (mCmdId) {

   116 		case ELoadGenCmdNewLoadCPULoad: {

   117 			createCpuLoadItems(model, parent);

   118 			break;

   119 		}

   120 		case ELoadGenCmdNewLoadEatMemory: {

   121 			createEatMemoryItems(model, parent);

   122 			break;

   123 		}

   124 		case ELoadGenCmdNewLoadPhoneCall: {

   125 			createPhoneCallItems(model, parent);

   126 			break;

   127 		}

   128 		case ELoadGenCmdNewLoadNetConn: {

   129 			createNetConnItems(model, parent);

   130 			break;

   131 		}

   132 		case ELoadGenCmdNewLoadKeyPress:

   133 		case ELoadGenCmdNewLoadPointerEvent: {

   134 			createKeyOrPointerItems(model, parent);

   135 			break;

   136 		}

   137 		case ELoadGenCmdNewLoadMessages: {

   138 			createMessageItems(model, parent);

   139 			break;

   140 		}

   141 		case ELoadGenCmdNewLoadApplications: {

   142 			createAppsItems(model, parent);

   143 			break;

   144 		}

   145 		case ELoadGenCmdNewLoadPhotoCaptures: {

   146 			createPhotoItems(model, parent);

   147 			break;

   148 		}

   149 		case ELoadGenCmdNewLoadBluetooth: {

   150 			createBtItems(model, parent);

   151 			break;

   152 		}

   153 		default: {

   154 			break;

   155 		}

   156 	}

   157 }

   158 

   159 // ---------------------------------------------------------------------------

   160 

   161 void SettingsView::createCpuLoadItems(HbDataFormModel *model, HbDataFormModelItem *parent)

   162 {

   163 

   164 	mLoadSettings = model->appendDataFormGroup(QString("CPU load settings"), parent);

   165 	

   166 	// DataFormItem for priority selection

   167 	mPriority = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   168 										  QString("Priority"), 

   169 										  mLoadSettings);

   170 	mPriority->setContentWidgetData(QString("items"), PRIORITIES);

   171 

   172 	// DataFormItem for load mode selection

   173 	mLoadMode = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   174 										  QString("Load mode"), 

   175 										  mLoadSettings);

   176 	mLoadMode->setContentWidgetData(QString("items"), LOADMODES);		

   177 

   178 	// DataFormItem for load type selection

   179 	mType = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   180 									  QString("Type"), 

   181 									  mLoadSettings);

   182 	mType->setContentWidgetData(QString("items"), CPULOADTYPES);

   183 

   184 	mSettingForm->addConnection(mType,SIGNAL(itemSelected(int)),this,SLOT(selectionChanged(int)));

   185 }

   186 

   187 // ---------------------------------------------------------------------------

   188 

   189 void SettingsView::createEatMemoryItems(HbDataFormModel *model, HbDataFormModelItem *parent)

   190 {

   191 	mLoadSettings = model->appendDataFormGroup(QString("Eat memory settings"), parent);

   192 	

   193 	// DataFormItem for priority selection

   194 	mPriority = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   195 										  QString("Priority"), 

   196 										  mLoadSettings);

   197 	mPriority->setContentWidgetData(QString("items"), PRIORITIES);

   198 

   199 	// DataFormItem for memory eat type selection

   200 	mSource = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   201 									  QString("Source"), 

   202 									  mLoadSettings);

   203 	mSource->setContentWidgetData(QString("items"), MEMSOURCES);

   204 

   205 	

   206 	// DataFormItem for memory eat type selection

   207 	mType = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   208 									  QString("Type"), 

   209 									  mLoadSettings);

   210 	mType->setContentWidgetData(QString("items"), MEMEATTYPES);

   211 

   212 	// DataFormItem for idle length selection

   213 	mBuffer = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   214 									  QString("Buffer (B)"), 

   215 									  mLoadSettings);

   216 	mBuffer->setContentWidgetData("maximum" , 999999999);

   217 	mBuffer->setContentWidgetData("minimum", 0);	

   218 	

   219 	// DataFormItem for idle length selection

   220 	mIdle = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   221 									  QString("Idle after buffer (ms)"), 

   222 									  mLoadSettings);

   223 	mIdle->setContentWidgetData("maximum" , 999999999);

   224 	mIdle->setContentWidgetData("minimum", 0);			

   225 

   226 	mRandomVar = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   227 										   QString("Random variance (%)"), 

   228 										   mLoadSettings);

   229 	mRandomVar->setContentWidgetData("maximum" , 100);

   230 	mRandomVar->setContentWidgetData("minimum", 0);	

   231 	

   232 	mSettingForm->addConnection(mType,SIGNAL(itemSelected(int)),this,SLOT(selectionChanged(int)));

   233 }	

   234 

   235 // ---------------------------------------------------------------------------

   236 

   237 void SettingsView::createPhoneCallItems(HbDataFormModel *model, HbDataFormModelItem *parent)

   238 {

   239 

   240 	mLoadSettings = model->appendDataFormGroup(QString("Phone calls settings"), parent);

   241 	

   242 	// DataFormItem for priority selection

   243 	mPriority = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   244 										  QString("Priority"), 

   245 										  mLoadSettings);

   246 	mPriority->setContentWidgetData(QString("items"), PRIORITIES);

   247 

   248 	mDestination = mModel->appendDataFormItem(HbDataFormModelItem::TextItem, 

   249 										QString("Phone number:"), 

   250 										mLoadSettings);

   251 	mDestination->setContentWidgetData("maximum" , 99999999999999999999.0 );

   252 	mDestination->setContentWidgetData("minimum", 0);

   253 

   254 	mLength = mModel->appendDataFormItem(HbDataFormModelItem::TextItem, 

   255 										QString("Length (ms)"), 

   256 										mLoadSettings);

   257 	mLength->setContentWidgetData("maximum" , 999999999);

   258 	mLength->setContentWidgetData("minimum", 0);

   259 	

   260 	// DataFormItem for idle length selection

   261 	mIdle = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   262 									  QString("Idle (ms)"), 

   263 									  mLoadSettings);

   264 	mIdle->setContentWidgetData("maximum" , 999999999);

   265 	mIdle->setContentWidgetData("minimum", 0);			

   266 

   267 	mRandomVar = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   268 										   QString("Random variance (%)"), 

   269 										   mLoadSettings);

   270 	mRandomVar->setContentWidgetData("maximum" , 100);

   271 	mRandomVar->setContentWidgetData("minimum", 0);	

   272 }

   273 

   274 // ---------------------------------------------------------------------------

   275 

   276 void SettingsView::createNetConnItems(HbDataFormModel *model, HbDataFormModelItem *parent)

   277 {

   278 

   279 	mLoadSettings = model->appendDataFormGroup(QString("Network conn. settings"), parent);

   280 	

   281 	// DataFormItem for priority selection

   282 	mPriority = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   283 										  QString("Priority"), 

   284 										  mLoadSettings);

   285 	mPriority->setContentWidgetData(QString("items"), PRIORITIES);

   286 

   287 	mDestination = mModel->appendDataFormItem(HbDataFormModelItem::TextItem, 

   288 										QString("Destination URL:"), 

   289 										mLoadSettings);

   290 	

   291 	// DataFormItem for idle length selection

   292 	mIdle = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   293 									  QString("Idle (ms)"), 

   294 									  mLoadSettings);

   295 	mIdle->setContentWidgetData("maximum" , 999999999);

   296 	mIdle->setContentWidgetData("minimum", 0);			

   297 

   298 	mRandomVar = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   299 										   QString("Random variance (%)"), 

   300 										   mLoadSettings);

   301 	mRandomVar->setContentWidgetData("maximum" , 100);

   302 	mRandomVar->setContentWidgetData("minimum", 0);	

   303 }

   304 

   305 // ---------------------------------------------------------------------------

   306 

   307 void SettingsView::createKeyOrPointerItems(HbDataFormModel *model, HbDataFormModelItem *parent)

   308 {

   309 	QString settingsName;

   310 	if (mCmdId == ELoadGenCmdNewLoadPointerEvent) {

   311 		settingsName = "Pointer events settings";

   312 	}

   313 	else {

   314 		settingsName = "Key presses settings";

   315 	}

   316 	mLoadSettings = model->appendDataFormGroup(settingsName, parent);

   317 	

   318 	// DataFormItem for priority selection

   319 	mPriority = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   320 										  QString("Priority"), 

   321 										  mLoadSettings);

   322 	mPriority->setContentWidgetData(QString("items"), PRIORITIES);

   323 

   324 	

   325 	// DataFormItem for heartbeat length selection

   326 	mHeartBeat = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   327 									  QString("Heartbeat (ms)"), 

   328 									  mLoadSettings);

   329 	mHeartBeat->setContentWidgetData("maximum" , 999999999);

   330 	mHeartBeat->setContentWidgetData("minimum", 0);		

   331 	

   332 	// Random variance

   333 	mRandomVar = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   334 										   QString("Random variance (%)"), 

   335 										   mLoadSettings);

   336 	mRandomVar->setContentWidgetData("maximum" , 100);

   337 	mRandomVar->setContentWidgetData("minimum", 0);	

   338 }

   339 

   340 // ---------------------------------------------------------------------------

   341 

   342 void SettingsView::createMessageItems(HbDataFormModel *model, HbDataFormModelItem *parent)

   343 {

   344 	mLoadSettings = model->appendDataFormGroup(QString("Messages settings"), parent);

   345 	

   346 	// DataFormItem for priority selection

   347 	mPriority = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   348 										  QString("Priority"), 

   349 										  mLoadSettings);

   350 	mPriority->setContentWidgetData(QString("items"), PRIORITIES);

   351 

   352 	

   353 	mType = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   354 									  QString("Type"), 

   355 									  mLoadSettings);

   356 	mType->setContentWidgetData(QString("items"), MESSAGETYPES);	

   357 

   358 

   359 	mDestination = mModel->appendDataFormItem(HbDataFormModelItem::TextItem, 

   360 										QString("Phone number:"), 

   361 										mLoadSettings);

   362 	mDestination->setContentWidgetData("maximum" , 99999999999999999999.0 );

   363 	mDestination->setContentWidgetData("minimum", 0);

   364 	

   365 	mAmount	= mModel->insertDataFormItem(3, HbDataFormModelItem::TextItem, 

   366 									  QString("Maximum amount of messages"), 

   367 									  mLoadSettings);

   368 	mAmount->setContentWidgetData("maximum" , 1000);

   369 	mAmount->setContentWidgetData("minimum", 0);

   370 

   371 	mLength = mModel->appendDataFormItem(HbDataFormModelItem::TextItem, 

   372 										QString("Message length"), 

   373 										mLoadSettings);

   374 	mLength->setContentWidgetData("maximum" , 999999999);

   375 	mLength->setContentWidgetData("minimum", 0);

   376 

   377 	// DataFormItem for idle length selection

   378 	mIdle = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   379 									  QString("Idle (ms)"), 

   380 									  mLoadSettings);

   381 	mIdle->setContentWidgetData("maximum" , 999999999);

   382 	mIdle->setContentWidgetData("minimum", 0);			

   383 

   384 	mRandomVar = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   385 										   QString("Random variance (%)"), 

   386 										   mLoadSettings);

   387 	mRandomVar->setContentWidgetData("maximum" , 100);

   388 	mRandomVar->setContentWidgetData("minimum", 0);	

   389 }

   390 

   391 // ---------------------------------------------------------------------------

   392 

   393 void SettingsView::createAppsItems(HbDataFormModel *model, HbDataFormModelItem *parent)

   394 {

   395 	mLoadSettings = model->appendDataFormGroup(QString("Applications settings"), parent);

   396 	

   397 	// DataFormItem for priority selection

   398 	mPriority = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   399 										  QString("Priority"), 

   400 										  mLoadSettings);

   401 	mPriority->setContentWidgetData(QString("items"), PRIORITIES);

   402 

   403 	mMaxParallelApps = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   404 									  QString("Max parallel applications"), 

   405 									  mLoadSettings);

   406 	mMaxParallelApps->setContentWidgetData("maximum" , 100);

   407 	mMaxParallelApps->setContentWidgetData("minimum", 0);	

   408 

   409 

   410 	// DataFormItem for launching interval length selection

   411 	mLaunchingInterval = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   412 									  QString("Launching interval (ms)"), 

   413 									  mLoadSettings);

   414 	mLaunchingInterval->setContentWidgetData("maximum" , 999999999);

   415 	mLaunchingInterval->setContentWidgetData("minimum", 0);	

   416 	

   417 	// DataFormItem for key press type selection

   418 	mKeyPressType = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   419 										  QString("Key press type"), 

   420 										  mLoadSettings);

   421 	mKeyPressType->setContentWidgetData(QString("items"), KEYPRESSTYPES);	

   422 

   423 	// DataFormItem for heartbeat length selection

   424 	mHeartBeat = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   425 									  QString("Key press interval (ms)"), 

   426 									  mLoadSettings);

   427 	mHeartBeat->setContentWidgetData("maximum" , 999999999);

   428 	mHeartBeat->setContentWidgetData("minimum", 0);		

   429 	

   430 	// Random variance

   431 	mRandomVar = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   432 										   QString("Random variance (%)"), 

   433 										   mLoadSettings);

   434 	mRandomVar->setContentWidgetData("maximum" , 100);

   435 	mRandomVar->setContentWidgetData("minimum", 0);	

   436 }

   437 

   438 // ---------------------------------------------------------------------------

   439 

   440 void SettingsView::createPhotoItems(HbDataFormModel *model, HbDataFormModelItem *parent)

   441 {

   442 	mLoadSettings = model->appendDataFormGroup(QString("Camera settings"), parent);

   443 	

   444 	// DataFormItem for priority selection

   445 	mPriority = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   446 										  QString("Priority"), 

   447 										  mLoadSettings);

   448 	mPriority->setContentWidgetData(QString("items"), PRIORITIES);

   449 

   450 	

   451 	// DataFormItem for idle length selection

   452 	mIdle = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   453 									  QString("Idle (ms)"), 

   454 									  mLoadSettings);

   455 	mIdle->setContentWidgetData("maximum" , 999999999);

   456 	mIdle->setContentWidgetData("minimum", 0);		

   457 	

   458 	// Random variance

   459 	mRandomVar = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   460 										   QString("Random variance (%)"), 

   461 										   mLoadSettings);

   462 	mRandomVar->setContentWidgetData("maximum" , 100);

   463 	mRandomVar->setContentWidgetData("minimum", 0);	

   464 }

   465 

   466 // ---------------------------------------------------------------------------

   467 

   468 void SettingsView::createBtItems(HbDataFormModel *model, HbDataFormModelItem *parent)

   469 {

   470 	mLoadSettings = model->appendDataFormGroup(QString("Bluetooth settings"), parent);

   471 	

   472 	// DataFormItem for priority selection

   473 	mPriority = model->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   474 										  QString("Priority"), 

   475 										  mLoadSettings);

   476 	mPriority->setContentWidgetData(QString("items"), PRIORITIES);

   477 

   478 	

   479 	// DataFormItem for idle length selection

   480 	mIdle = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   481 									  QString("Idle (ms)"), 

   482 									  mLoadSettings);

   483 	mIdle->setContentWidgetData("maximum" , 999999999);

   484 	mIdle->setContentWidgetData("minimum", 0);		

   485 	

   486 	// Random variance

   487 	mRandomVar = model->appendDataFormItem(HbDataFormModelItem::TextItem, 

   488 										   QString("Random variance (%)"), 

   489 										   mLoadSettings);

   490 	mRandomVar->setContentWidgetData("maximum" , 100);

   491 	mRandomVar->setContentWidgetData("minimum", 0);	

   492 }

   493 

   494 // ---------------------------------------------------------------------------

   495 // Load attributes from engine & set the data into each form model item:

   496 

   497 void SettingsView::loadAttributes()

   498 {

   499 	switch (mCmdId)

   500 	{

   501 		case ELoadGenCmdNewLoadCPULoad: {

   502 			mCPULoadAttributes = mEngineWrapper.getCpuLoadAttributes();

   503 			mPriority->setContentWidgetData(QString("selected"), mCPULoadAttributes.mPriority);

   504 			mLoadMode->setContentWidgetData(QString("selected"), mCPULoadAttributes.mMode);

   505 			mType->setContentWidgetData(QString("selected"), mCPULoadAttributes.mType);

   506 			

   507 			if (mCPULoadAttributes.mType == ECpuLoadTypePeriodic) {	//if (mCPULoadAttributes.mMode == ECpuLoadTypePeriodic) {

   508 			// Create and append to model these items: Length, Idle, Random variance, if load type is peridodic.

   509 				

   510 				// DataFormItem for load length selection

   511 				mLength = mModel->appendDataFormItem(HbDataFormModelItem::TextItem, 

   512 													QString("Length (ms)"), 

   513 													mLoadSettings);

   514 				mLength->setContentWidgetData("maximum" , 999999999);

   515 				mLength->setContentWidgetData("minimum", 0);

   516 				

   517 				

   518 				// DataFormItem for load length selection

   519 				mIdle = mModel->appendDataFormItem(HbDataFormModelItem::TextItem, 

   520 												  QString("Idle (ms)"), 

   521 												  mLoadSettings);

   522 				mIdle->setContentWidgetData("maximum" , 999999999);

   523 				mIdle->setContentWidgetData("minimum", 0);			

   524 

   525 				mRandomVar = mModel->appendDataFormItem(HbDataFormModelItem::TextItem, 

   526 													   QString("Random variance (%)"), 

   527 													   mLoadSettings);

   528 				mRandomVar->setContentWidgetData("maximum" , 100);

   529 				mRandomVar->setContentWidgetData("minimum", 0);	

   530 			

   531 				mLength->setContentWidgetData(QString("text"), mCPULoadAttributes.mLength);

   532 				mIdle->setContentWidgetData(QString("text"), mCPULoadAttributes.mIdle);

   533 				mRandomVar->setContentWidgetData(QString("text"), mCPULoadAttributes.mRandomVariance);

   534 			}

   535 

   536 			// if there's more than one cpu available in the system, 

   537 			// insert possibility to select which cpu the load is generated to

   538 			if (mCPULoadAttributes.mCpuCount > 1)

   539             {

   540 				QStringList cpuArray;

   541 				cpuArray.append("Free scheduling");

   542 				// add cpus to list:

   543 				for (int i = 0; i < mCPULoadAttributes.mCpuCount; i++) 

   544 					{

   545 					QString cpu = QString("CPU%1").arg(i);

   546 					cpuArray.append(cpu);

   547 					}    

   548 				// "All CPUs" means that one thread is started for each CPU.	

   549 				cpuArray.append("All CPUs");

   550 

   551 				mCpu = mModel->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   552 													 QString("CPU"), 

   553 													 mLoadSettings);

   554 				mCpu->setContentWidgetData(QString("items"), cpuArray);				

   555 

   556 				if (mCPULoadAttributes.mCpu < 0) {

   557 					mCpu->setContentWidgetData(QString("selected"), 0);

   558 				}				

   559 

   560 				else if (mCPULoadAttributes.mCpu == KCPUSelection_AllCPUs) {

   561 					mCpu->setContentWidgetData(QString("selected"), cpuArray.count()-1);

   562 				}

   563 				// CPU is defined, set the correct CPU as default selection in query list

   564 				else {

   565 				// mCpu starts from zero (i.e. CPU0 is first CPU), but index zero

   566 				// in settings Ui form item is reserved for "Free scheduling", hence iCpu+1.

   567 					mCpu->setContentWidgetData(QString("selected"), mCPULoadAttributes.mCpu+1);

   568 				}

   569             }

   570 			break;

   571 		}

   572 		case ELoadGenCmdNewLoadEatMemory: {

   573 			mMemoryEatAttributes = mEngineWrapper.getMemoryEatAttributes();

   574 			mPriority->setContentWidgetData(QString("selected"), mMemoryEatAttributes.mPriority);

   575 			mSource->setContentWidgetData(QString("selected"), mMemoryEatAttributes.mSource);

   576 			mType->setContentWidgetData(QString("selected"), mMemoryEatAttributes.mType);

   577 			

   578 			if (mMemoryEatAttributes.mType == EMemoryEatTypeWavy) {

   579 				mMinAmountToBeLeft	= mModel->insertDataFormItem(3, HbDataFormModelItem::TextItem, 

   580 												  QString("Min to be left (B)"), 

   581 												  mLoadSettings);

   582 				mMinAmountToBeLeft->setContentWidgetData("maximum" , 99999999999999);

   583 				mMinAmountToBeLeft->setContentWidgetData("minimum", 0);

   584 				

   585 				mMaxAmountToBeLeft	= mModel->insertDataFormItem(4, HbDataFormModelItem::TextItem, 

   586 												  QString("Max to be left (B)"), 

   587 												  mLoadSettings);

   588 				mMaxAmountToBeLeft->setContentWidgetData("maximum" , 99999999999999);

   589 				mMaxAmountToBeLeft->setContentWidgetData("minimum", 0);

   590 

   591 				mMinAmountToBeLeft->setContentWidgetData(QString("text"), mMemoryEatAttributes.mRandomMinDes);

   592 				mMaxAmountToBeLeft->setContentWidgetData(QString("text"), mMemoryEatAttributes.mRandomMaxDes);

   593 			}

   594 			else if (mMemoryEatAttributes.mType == EMemoryEatTypeMemoryToEat ||

   595 			         mMemoryEatAttributes.mType == EMemoryEatTypeMemoryToBeLeft ) {

   596 				mAmount	= mModel->insertDataFormItem(3, HbDataFormModelItem::TextItem, 

   597 												  QString("Amout(B)"), 

   598 												  mLoadSettings);

   599 				mAmount->setContentWidgetData("maximum" , 99999999999999);

   600 				mAmount->setContentWidgetData("minimum", 0);

   601 				

   602 				mAmount->setContentWidgetData(QString("text"), mMemoryEatAttributes.mAmount);	 

   603 			}

   604 			mBuffer->setContentWidgetData(QString("text"), mMemoryEatAttributes.mBuffer);

   605 			mIdle->setContentWidgetData(QString("text"), mMemoryEatAttributes.mIdle);

   606 			mRandomVar->setContentWidgetData(QString("text"), mMemoryEatAttributes.mRandomVariance);

   607 			break;

   608 		}

   609 		case ELoadGenCmdNewLoadPhoneCall: {

   610 			mPhoneCallAttributes = mEngineWrapper.getPhoneCallAttributes();

   611 			mPriority->setContentWidgetData(QString("selected"), mPhoneCallAttributes.mPriority);

   612 			mDestination->setContentWidgetData(QString("text"), mPhoneCallAttributes.mDestination);

   613 			mLength->setContentWidgetData(QString("text"), mPhoneCallAttributes.mLength);

   614 			mIdle->setContentWidgetData(QString("text"), mPhoneCallAttributes.mIdle);

   615 			mRandomVar->setContentWidgetData(QString("text"), mPhoneCallAttributes.mRandomVariance);

   616 			break;

   617 		}

   618 		case ELoadGenCmdNewLoadNetConn: {

   619 			mNetConnAttributes = mEngineWrapper.getNetConnAttributes();

   620 			mPriority->setContentWidgetData(QString("selected"), mNetConnAttributes.mPriority);

   621 			mDestination->setContentWidgetData(QString("text"), mNetConnAttributes.mDestination);

   622 			mIdle->setContentWidgetData(QString("text"), mNetConnAttributes.mIdle);

   623 			mRandomVar->setContentWidgetData(QString("text"), mNetConnAttributes.mRandomVariance);

   624 			break;

   625 		}

   626 		case ELoadGenCmdNewLoadKeyPress: {

   627 			mKeyPressAttributes = mEngineWrapper.getKeyPressAttributes();

   628 			mPriority->setContentWidgetData(QString("selected"), mKeyPressAttributes.mPriority);

   629 			mHeartBeat->setContentWidgetData(QString("text"), mKeyPressAttributes.mHeartBeat);

   630 			mRandomVar->setContentWidgetData(QString("text"), mKeyPressAttributes.mRandomVariance);			

   631 			break;

   632 		}

   633 		case ELoadGenCmdNewLoadPointerEvent: { 

   634 			mPointerEventAttributes = mEngineWrapper.getPointerEventAttributes();

   635 			mPriority->setContentWidgetData(QString("selected"), mPointerEventAttributes.mPriority);

   636 			mHeartBeat->setContentWidgetData(QString("text"), mPointerEventAttributes.mHeartBeat);

   637 			mRandomVar->setContentWidgetData(QString("text"), mPointerEventAttributes.mRandomVariance);				

   638 			break;

   639 		}

   640 		case ELoadGenCmdNewLoadMessages: {

   641 			mMessageAttributes = mEngineWrapper.getMessageAttributes();

   642 			mPriority->setContentWidgetData(QString("selected"), mMessageAttributes.mPriority);

   643 			mType->setContentWidgetData(QString("selected"), mMessageAttributes.mMessageType);

   644 			mDestination->setContentWidgetData(QString("text"), mMessageAttributes.mDestination);

   645 			mAmount->setContentWidgetData(QString("text"), mMessageAttributes.mAmount);	 

   646 			mLength->setContentWidgetData(QString("text"), mMessageAttributes.mLength);

   647 			mIdle->setContentWidgetData(QString("text"), mMessageAttributes.mIdle);

   648 			mRandomVar->setContentWidgetData(QString("text"), mMessageAttributes.mRandomVariance);

   649 			break;

   650 		}

   651 		case ELoadGenCmdNewLoadApplications: {

   652 			mApplicationsAttributes = mEngineWrapper.getApplicationsAttributes();

   653 			mPriority->setContentWidgetData(QString("selected"), mApplicationsAttributes.mPriority);

   654 			mMaxParallelApps->setContentWidgetData(QString("text"), mApplicationsAttributes.mMaxOpen);

   655 			mHeartBeat->setContentWidgetData(QString("text"), mApplicationsAttributes.mHeartBeat);

   656 			mLaunchingInterval->setContentWidgetData(QString("text"), mApplicationsAttributes.mLaunchingInterval);

   657 			mKeyPressType->setContentWidgetData(QString("selected"), mApplicationsAttributes.mKeyPressType);

   658 			mRandomVar->setContentWidgetData(QString("text"), mApplicationsAttributes.mRandomVariance);						

   659 			break;

   660 		}

   661 		case ELoadGenCmdNewLoadPhotoCaptures: {

   662 			mPhotoCaptureAttributes = mEngineWrapper.getPhotoCaptureAttributes();

   663 			mPriority->setContentWidgetData(QString("selected"), mPhotoCaptureAttributes.mPriority);

   664 			mIdle->setContentWidgetData(QString("text"), mPhotoCaptureAttributes.mIdle);

   665 			mRandomVar->setContentWidgetData(QString("text"), mPhotoCaptureAttributes.mRandomVariance);

   666 			

   667 			// if there's any cameras avaialable in system, construct form item for it/them:

   668 			if (mPhotoCaptureAttributes.mCameraCount > 0)

   669             {

   670 				QStringList devices;

   671 				// add cameras to list:

   672 				for (int i = 0; i < mPhotoCaptureAttributes.mCameraCount; i++) 

   673 					{

   674 					QString cam = QString("Camera %1").arg(i);

   675 					devices.append(cam);

   676 					}    

   677 				mCamera = mModel->insertDataFormItem(1, HbDataFormModelItem::RadioButtonListItem, 

   678 													 QString("Device"), 

   679 													 mLoadSettings);

   680 				mCamera->setContentWidgetData(QString("items"), devices);

   681 				mCamera->setContentWidgetData(QString("selected"), mPhotoCaptureAttributes.mCamera);

   682             }

   683 			break;

   684 		}

   685 		case ELoadGenCmdNewLoadBluetooth: {

   686 			mBluetoothAttributes = mEngineWrapper.getBluetoothAttributes();

   687 			mPriority->setContentWidgetData(QString("selected"), mBluetoothAttributes.mPriority);

   688 			mIdle->setContentWidgetData(QString("text"), mBluetoothAttributes.mIdle);

   689 			mRandomVar->setContentWidgetData(QString("text"), mBluetoothAttributes.mRandomVariance);	

   690 			break;

   691 		}

   692 		

   693 		default: {

   694 			break;

   695 		}

   696 	}

   697 }

   698 

   699 // ---------------------------------------------------------------------------

   700 

   701 void SettingsView::setDefaultSettings()

   702 {

   703 

   704 }

   705 

   706 // ---------------------------------------------------------------------------

   707 

   708 void SettingsView::backButtonPressed()

   709 {

   710 	okExit();	

   711 }

   712 

   713 // ---------------------------------------------------------------------------

   714 

   715 void SettingsView::saveSettings()

   716 {

   717 	switch (mCmdId) {

   718 		case ELoadGenCmdNewLoadCPULoad: {

   719 			saveCpuLoadSettings();

   720 			break;

   721 		}

   722 		case ELoadGenCmdNewLoadEatMemory: {

   723 			saveEatMemorySettings();

   724 			break;

   725 		}

   726 		case ELoadGenCmdNewLoadPhoneCall: {

   727 			savePhoneCallSettings();

   728 			break;

   729 		}

   730 		case ELoadGenCmdNewLoadNetConn: {

   731 			saveNetConnSettings();

   732 			break;

   733 		}

   734 		case ELoadGenCmdNewLoadKeyPress: {

   735 			saveKeyPressSettings();

   736 			break;

   737 		}

   738 		case ELoadGenCmdNewLoadPointerEvent: {

   739 			savePointerEventSettings();

   740 			break;

   741 		}

   742 		case ELoadGenCmdNewLoadMessages: {

   743 			saveMessageSettings();

   744 			break;

   745 		}

   746 		case ELoadGenCmdNewLoadApplications: {

   747 			saveApplicationsSettings();

   748 			break;

   749 		}

   750 		case ELoadGenCmdNewLoadPhotoCaptures: {

   751 			savePhotoSettings();

   752 			break;

   753 		}

   754 		case ELoadGenCmdNewLoadBluetooth: {

   755 			saveBtSettings();

   756 			break;

   757 		}

   758 		default: {

   759 			break;

   760 		}

   761 	}

   762 }

   763 

   764 // ---------------------------------------------------------------------------	

   765 	

   766 void SettingsView::saveCpuLoadSettings()

   767 {

   768 	mCPULoadAttributes.mPriority = mPriority->contentWidgetData("selected").toInt();

   769 	mCPULoadAttributes.mMode = mLoadMode->contentWidgetData("selected").toInt();

   770 	mCPULoadAttributes.mType = mType->contentWidgetData("selected").toInt();

   771 	if (mType->contentWidgetData("selected").toInt() == ECpuLoadTypePeriodic) {

   772 		// TODO: remove temp checks if (mLength != NULL) etc. when HbDataFormModelItem bugs fixed.

   773 		if (mLength != NULL) {

   774 			mCPULoadAttributes.mLength = mLength->contentWidgetData("text").toInt();

   775 		}

   776 		if (mIdle != NULL) {			

   777 			mCPULoadAttributes.mIdle = mIdle->contentWidgetData("text").toInt();

   778 		}

   779 		if (mRandomVar != NULL) {

   780 			int randVar = mRandomVar->contentWidgetData("text").toInt();

   781 			if( randVar >=0 && randVar <= mRandomVar->contentWidgetData("maximum").toInt() )

   782 				{

   783 				mCPULoadAttributes.mRandomVariance = mRandomVar->contentWidgetData("text").toInt();

   784 				}

   785 			else

   786 				{

   787 				mCPULoadAttributes.mRandomVariance = mRandomVar->contentWidgetData("maximum").toInt();

   788 				}

   789 		}

   790 	}

   791 

   792 	// we are running in SMP environment

   793 	if (mCPULoadAttributes.mCpuCount > 1)

   794 		{

   795 		TInt currentValueIndex = mCpu->contentWidgetData("selected").toInt();

   796 		// user selected a specific CPU in which the load thread should be run in.

   797 		if (currentValueIndex == 0)

   798 			{

   799 			// User selected "Free scheduling"

   800 			mCPULoadAttributes.mCpu = KCPUSelection_FreeScheduling;

   801 			}            

   802 		else if( currentValueIndex == (mCpu->childCount()-1) )

   803 			{

   804 			// User selected "All CPUs", which is the last item in the form radio button selection list

   805 			mCPULoadAttributes.mCpu = KCPUSelection_AllCPUs;

   806 			}

   807 		else

   808 			{                

   809 			// mCpu should start from zero (CPU0 is the first cpu)

   810 			// but zero in Ui form item index means "Free scheduling". CPU0 in

   811 			// index of form radio button list is at index 1, hence -1.

   812 			mCPULoadAttributes.mCpu = currentValueIndex - 1;

   813 			}

   814 		}

   815 

   816 	

   817 }

   818 

   819 // ---------------------------------------------------------------------------

   820 

   821 void SettingsView::saveEatMemorySettings()

   822 {

   823 	mMemoryEatAttributes.mPriority = mPriority->contentWidgetData("selected").toInt();

   824 	mMemoryEatAttributes.mSource = mSource->contentWidgetData("selected").toInt();

   825 	mMemoryEatAttributes.mType = mType->contentWidgetData("selected").toInt();

   826 	

   827 	if (mType->contentWidgetData("selected").toInt() == EMemoryEatTypeWavy) {

   828 		// TODO: remove temp checks if (mLength != NULL) etc. when HbDataFormModelItem bugs fixed.

   829 		if (mMinAmountToBeLeft != NULL) {

   830 			mMemoryEatAttributes.mRandomMin = 

   831 				mMinAmountToBeLeft->contentWidgetData("text").toInt();

   832 		}

   833 		if (mMaxAmountToBeLeft != NULL) {

   834 			mMemoryEatAttributes.mRandomMax = 

   835 				mMaxAmountToBeLeft->contentWidgetData("text").toInt();

   836 		}

   837 	}

   838 	else if (mType->contentWidgetData("selected").toInt() == EMemoryEatTypeMemoryToEat ||

   839 	         mType->contentWidgetData("selected").toInt() == EMemoryEatTypeMemoryToBeLeft) {

   840 		if (mAmount != NULL) {

   841 			mMemoryEatAttributes.mAmount = mAmount->contentWidgetData("text").toInt();

   842 		}

   843 	}

   844 	mMemoryEatAttributes.mBuffer = mBuffer->contentWidgetData("text").toInt();

   845 	mMemoryEatAttributes.mIdle = mIdle->contentWidgetData("text").toInt();

   846 	

   847 	int randVar = mRandomVar->contentWidgetData("text").toInt();

   848 	if( randVar >=0 && randVar <= mRandomVar->contentWidgetData("maximum").toInt() )

   849 		{

   850 		mMemoryEatAttributes.mRandomVariance = mRandomVar->contentWidgetData("text").toInt();

   851 		}

   852 	else

   853 		{

   854 		mMemoryEatAttributes.mRandomVariance = mRandomVar->contentWidgetData("maximum").toInt();

   855 		}

   856 	

   857     // swap min- & max values if they are in wrong order

   858 	if (mMemoryEatAttributes.mRandomMin > mMemoryEatAttributes.mRandomMax)

   859 		{

   860 		qint64 temp(mMemoryEatAttributes.mRandomMin);

   861 		mMemoryEatAttributes.mRandomMin = mMemoryEatAttributes.mRandomMax;

   862 		mMemoryEatAttributes.mRandomMax = temp; 

   863 		}	

   864 }

   865 

   866 // ---------------------------------------------------------------------------	

   867 	

   868 void SettingsView::savePhoneCallSettings()

   869 {

   870 	mPhoneCallAttributes.mPriority = mPriority->contentWidgetData("selected").toInt();

   871 	mPhoneCallAttributes.mLength   = mLength->contentWidgetData("text").toInt();

   872 	mPhoneCallAttributes.mIdle     = mIdle->contentWidgetData("text").toInt();

   873 	

   874 	int randVar = mRandomVar->contentWidgetData("text").toInt();

   875 	if( randVar >=0 && randVar <= mRandomVar->contentWidgetData("maximum").toInt() )

   876 		{

   877 		mPhoneCallAttributes.mRandomVariance = mRandomVar->contentWidgetData("text").toInt();

   878 		}

   879 	else

   880 		{

   881 		mPhoneCallAttributes.mRandomVariance = mRandomVar->contentWidgetData("maximum").toInt();

   882 		}

   883 	

   884 	

   885 	mPhoneCallAttributes.mDestination    = mDestination->contentWidgetData("text").toString();

   886 }

   887 

   888 // ---------------------------------------------------------------------------	

   889 	

   890 void SettingsView::saveNetConnSettings()

   891 {

   892 	mPhoneCallAttributes.mPriority = mPriority->contentWidgetData("selected").toInt();

   893 	mPhoneCallAttributes.mIdle     = mIdle->contentWidgetData("text").toInt();

   894 	int randVar = mRandomVar->contentWidgetData("text").toInt();

   895 	if( randVar >=0 && randVar <= mRandomVar->contentWidgetData("maximum").toInt() )

   896 		{

   897 		mPhoneCallAttributes.mRandomVariance = mRandomVar->contentWidgetData("text").toInt();

   898 		}

   899 	else

   900 		{

   901 		mPhoneCallAttributes.mRandomVariance = mRandomVar->contentWidgetData("maximum").toInt();

   902 		}

   903 	mPhoneCallAttributes.mDestination    = mDestination->contentWidgetData("text").toString();

   904 }

   905 

   906 // ---------------------------------------------------------------------------

   907 

   908 void SettingsView::saveKeyPressSettings()

   909 {

   910 	mKeyPressAttributes.mPriority  = mPriority->contentWidgetData("selected").toInt();

   911 	mKeyPressAttributes.mHeartBeat = mHeartBeat->contentWidgetData("text").toInt();

   912 	int randVar = mRandomVar->contentWidgetData("text").toInt();

   913 	if( randVar >=0 && randVar <= mRandomVar->contentWidgetData("maximum").toInt() )

   914 		{

   915 		mKeyPressAttributes.mRandomVariance = mRandomVar->contentWidgetData("text").toInt();

   916 		}

   917 	else

   918 		{

   919 		mKeyPressAttributes.mRandomVariance =  mRandomVar->contentWidgetData("maximum").toInt();

   920 		}

   921 	

   922 }

   923 

   924 // ---------------------------------------------------------------------------

   925 

   926 void SettingsView::savePointerEventSettings()

   927 {

   928 	mPointerEventAttributes.mPriority  = mPriority->contentWidgetData("selected").toInt();

   929 	mPointerEventAttributes.mHeartBeat = mHeartBeat->contentWidgetData("text").toInt();

   930 	int randVar = mRandomVar->contentWidgetData("text").toInt();

   931 	if( randVar >=0 && randVar <= mRandomVar->contentWidgetData("maximum").toInt() )

   932 		{

   933 		mPointerEventAttributes.mRandomVariance = mRandomVar->contentWidgetData("text").toInt();

   934 		}

   935 	else

   936 		{

   937 		mPointerEventAttributes.mRandomVariance = mRandomVar->contentWidgetData("maximum").toInt();

   938 		}

   939 	

   940 }

   941 

   942 // ---------------------------------------------------------------------------

   943 

   944 void SettingsView::saveMessageSettings()

   945 {

   946 	mMessageAttributes.mPriority    = mPriority->contentWidgetData("selected").toInt();

   947 	mMessageAttributes.mMessageType = mType->contentWidgetData("selected").toInt();

   948 	mMessageAttributes.mDestination = mDestination->contentWidgetData("text").toString();

   949 	int amount = mAmount->contentWidgetData("text").toInt();

   950 	if( amount  >=0 && amount <= mAmount->contentWidgetData("maximum").toInt() )

   951 		{

   952 		mMessageAttributes.mAmount = mAmount->contentWidgetData("text").toInt();

   953 		}

   954 	else

   955 		{

   956 		mMessageAttributes.mAmount = mAmount->contentWidgetData("maximum").toInt();

   957 		}

   958 	mMessageAttributes.mLength = mLength->contentWidgetData("text").toInt();

   959 	mMessageAttributes.mIdle = mIdle->contentWidgetData("text").toInt();

   960 	int randVar = mRandomVar->contentWidgetData("text").toInt();

   961 	if( randVar >=0 && randVar <= mRandomVar->contentWidgetData("maximum").toInt() )

   962 		{

   963 		mMessageAttributes.mRandomVariance = mRandomVar->contentWidgetData("text").toInt();

   964 		}

   965 	else

   966 		{

   967 		mMessageAttributes.mRandomVariance =  mRandomVar->contentWidgetData("maximum").toInt();

   968 		}

   969 

   970 }

   971 

   972 // ---------------------------------------------------------------------------

   973 

   974 void SettingsView::saveApplicationsSettings()

   975 {

   976 	mApplicationsAttributes.mPriority  = mPriority->contentWidgetData("selected").toInt();

   977 	int maxApps = mMaxParallelApps->contentWidgetData("text").toInt();

   978 	if( maxApps >=0 && maxApps <= mMaxParallelApps->contentWidgetData("maximum").toInt() )

   979 		{

   980 		mApplicationsAttributes.mMaxOpen   = mMaxParallelApps->contentWidgetData("text").toInt();

   981 		}

   982 	else

   983 		{

   984 		mApplicationsAttributes.mMaxOpen   = mMaxParallelApps->contentWidgetData("maximum").toInt();

   985 		}

   986 	mApplicationsAttributes.mLaunchingInterval   = mLaunchingInterval->contentWidgetData("text").toInt();

   987 	mApplicationsAttributes.mKeyPressType  = mKeyPressType->contentWidgetData("selected").toInt();

   988 	mPointerEventAttributes.mHeartBeat = mHeartBeat->contentWidgetData("text").toInt();

   989 	int randVar = mRandomVar->contentWidgetData("text").toInt();

   990 	if( randVar >=0 && randVar <= mRandomVar->contentWidgetData("maximum").toInt() )

   991 		{

   992 		mApplicationsAttributes.mRandomVariance = mRandomVar->contentWidgetData("text").toInt();

   993 		}

   994 	else

   995 		{

   996 		mApplicationsAttributes.mRandomVariance = mRandomVar->contentWidgetData("maximum").toInt();

   997 		}

   998 }

   999 

  1000 // ---------------------------------------------------------------------------

  1001 

  1002 void SettingsView::savePhotoSettings()

  1003 {

  1004 	mPhotoCaptureAttributes.mPriority  = mPriority->contentWidgetData("selected").toInt();

  1005 	mPhotoCaptureAttributes.mIdle = mIdle->contentWidgetData("text").toInt();

  1006 	int randVar = mRandomVar->contentWidgetData("text").toInt();

  1007 	if( randVar >=0 && randVar <= mRandomVar->contentWidgetData("maximum").toInt() )

  1008 		{

  1009 		mPhotoCaptureAttributes.mRandomVariance = mRandomVar->contentWidgetData("text").toInt();

  1010 		}

  1011 	else

  1012 		{

  1013 		mPhotoCaptureAttributes.mRandomVariance = mRandomVar->contentWidgetData("maximum").toInt();

  1014 		}

  1015 	

  1016 	// update only if there's more than one camera device available in the system, 

  1017 	// for use case of one camera available, the selection cannot be changed by user.

  1018 	if (mPhotoCaptureAttributes.mCameraCount > 1)

  1019 	{

  1020 	mPhotoCaptureAttributes.mCamera = mCamera->contentWidgetData("selected").toInt();

  1021 	}

  1022 }

  1023 

  1024 // ---------------------------------------------------------------------------

  1025 

  1026 void SettingsView::saveBtSettings()

  1027 {

  1028 	mBluetoothAttributes.mPriority  = mPriority->contentWidgetData("selected").toInt();

  1029 	mBluetoothAttributes.mIdle = mIdle->contentWidgetData("text").toInt();

  1030 	int randVar = mRandomVar->contentWidgetData("text").toInt();

  1031 	if( randVar >=0 && randVar <= mRandomVar->contentWidgetData("maximum").toInt() )

  1032 		{

  1033 		mBluetoothAttributes.mRandomVariance = mRandomVar->contentWidgetData("text").toInt();

  1034 		}

  1035 	else

  1036 		{

  1037 		mBluetoothAttributes.mRandomVariance =  mRandomVar->contentWidgetData("maximum").toInt();

  1038 		}

  1039 	

  1040 }

  1041 

  1042 // ---------------------------------------------------------------------------

  1043 

  1044 void SettingsView::cancelled()

  1045 {

  1046 	connect(this, 

  1047 		SIGNAL(loadCanclled()), 

  1048 		&mEngineWrapper, 

  1049 		SLOT(loadSettingsCanclled()));

  1050 	emit loadCanclled();

  1051 	

  1052     mMainWindow.removeView(this);

  1053     mMainWindow.setCurrentView(&mMainView, true);

  1054     deleteLater();

  1055 }

  1056 

  1057 // ---------------------------------------------------------------------------

  1058 

  1059 void SettingsView::okExit()

  1060 {

  1061 	saveSettings();

  1062 	setLoadAttributes();

  1063     connect(this, 

  1064 			SIGNAL(loadCompleted(TLoadGenCommandIds)), 

  1065 			&mEngineWrapper, 

  1066 			SLOT(loadAddedOrEdited(TLoadGenCommandIds)));

  1067 	emit loadCompleted(mCmdId);

  1068 			

  1069     mMainWindow.removeView(this);

  1070     mMainWindow.setCurrentView(&mMainView, true);

  1071     deleteLater();

  1072 }

  1073 

  1074 // ---------------------------------------------------------------------------

  1075 

  1076 void SettingsView::setLoadAttributes()

  1077 {

  1078 	switch (mCmdId) {

  1079 		case ELoadGenCmdNewLoadCPULoad: {

  1080 			mEngineWrapper.setCpuLoadAttributes(mCPULoadAttributes);

  1081 			break;

  1082 		}

  1083 		case ELoadGenCmdNewLoadEatMemory: {

  1084 			mEngineWrapper.setMemoryEatAttributes(mMemoryEatAttributes);

  1085 			break;

  1086 		}

  1087 		case ELoadGenCmdNewLoadPhoneCall: {

  1088 			mEngineWrapper.setPhoneCallAttributes(mPhoneCallAttributes);

  1089 			break;

  1090 		}

  1091 		case ELoadGenCmdNewLoadNetConn: {

  1092 			mEngineWrapper.setNetConnAttributes(mNetConnAttributes);

  1093 			break;

  1094 		}

  1095 		case ELoadGenCmdNewLoadKeyPress: {

  1096 			mEngineWrapper.setKeyPressAttributes(mKeyPressAttributes);

  1097 			break;

  1098 		}

  1099 		case ELoadGenCmdNewLoadPointerEvent: {

  1100 			mEngineWrapper.setPointerEventAttributes(mPointerEventAttributes);

  1101 			break;

  1102 		}

  1103 		case ELoadGenCmdNewLoadMessages: {

  1104 			mEngineWrapper.setMessageAttributes(mMessageAttributes);

  1105 			break;

  1106 		}

  1107 		case ELoadGenCmdNewLoadApplications: {

  1108 			mEngineWrapper.setApplicationsAttributes(mApplicationsAttributes);

  1109 			break;

  1110 		}

  1111 		case ELoadGenCmdNewLoadPhotoCaptures: {

  1112 			mEngineWrapper.setPhotoCaptureAttributes(mPhotoCaptureAttributes); 

  1113 			break;		

  1114 		}

  1115 		case ELoadGenCmdNewLoadBluetooth: {

  1116 			mEngineWrapper.setBluetoothAttributes(mBluetoothAttributes);

  1117 			break;

  1118 		}

  1119 		default: {

  1120 			break;

  1121 		}

  1122 	}

  1123 }

  1124 

  1125 // ---------------------------------------------------------------------------

  1126 

  1127 void SettingsView::dataItemDisplayed(const QModelIndex &index)

  1128 {

  1129 	HbDataFormViewItem *item = static_cast<HbDataFormViewItem*>(mSettingForm->itemByIndex(index)); 

  1130 	HbWidget *contentWidget = static_cast<HbWidget*>(item->dataItemContentWidget());

  1131 	switch(mCmdId){

  1132 		case ELoadGenCmdNewLoadCPULoad: {

  1133 			if (index.row() == 2) { // Cpu load type selection is in this row: periodic vs. continuous

  1134 				mModes = static_cast<HbRadioButtonList*>(contentWidget);