1 /*

     2 * Copyright (c) 2005-2009 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 "T_DataAnimForMClass.h"

    19 #include "T_GraphicsUtil.h"

    20 #include "T_AnimDef.h"

    21 #include "../AnimPlugin/inc/T_AnimDef.h"

    22 #include <w32adll.h>

    23 #include <e32keys.h>

    24 #include "w32std.h" 

    25 #define KMaxBufSize 250

    26 

    27 /*@{*/

    28 _LIT(KDataClassname,							"RAnimForMClass");

    29 

    30 ///	Fields

    31 

    32 _LIT(KFldWin, 									"win");

    33 _LIT(KFldWingrp, 								"wingrp");

    34 _LIT(KFldSprite, 								"sprite");

    35 _LIT(KFldType, 									"type");

    36 

    37 

    38 _LIT(KFldOpcode, 								"opcode");

    39 

    40 

    41 _LIT(KFldExpected, 								"expected");

    42 _LIT(KFldRect, 									"rect");

    43 _LIT(KFldState, 								"state");

    44 _LIT(KFldWs, 									"ws");

    45 _LIT(KFldWingrpId, 								"windowgroupid");

    46 _LIT(KFldOrdinalPosition, 						"pos");

    47 _LIT(KFldOrdinalPriority, 						"ordinalpriority");

    48 _LIT(KFldScreenNumb, 							"screennumber");

    49 _LIT(KFldFullOrdinPostn, 						"fullpos");

    50 _LIT(KFldExpectedPoint, 						"expectedpoint");

    51 _LIT(KFldGetEvent, 								"getevent");

    52 _LIT(KFldInterface, 							"interface");

    53 _LIT(KFldPostRawEvent, 							"rawevent");

    54 

    55 

    56 

    57 

    58 _LIT(KFldSyncMode, 								"animsync");

    59 _LIT(KFldInterval, 								"interval");

    60 _LIT(KFldNotifications, 						"notification");

    61 _LIT(KFldMessage, 								"message");

    62 _LIT(KFldHandleBitmap, 							"bitmap");

    63 _LIT(KFldHandleFont, 							"font");

    64 _LIT(KFldMemberIndex, 							"member_index");

    65 _LIT(KFldIsFullUpdate, 							"isfullupdate");

    66 _LIT(KFldIsActivate, 							"isactivate");

    67 _LIT(KFldSetReplyBufHandle1, 					"slot2");

    68 _LIT(KFldSetReplyBufHandle2, 					"slot3");

    69 _LIT(KFldPointPosition,							"pos");

    70 _LIT(KFldRAnim,						        	"anim");

    71 

    72 _LIT(KESyncNone , 								"ESyncNone");

    73 _LIT(KESyncFlash, 								"ESyncFlash");

    74 _LIT(KESyncSecond, 								"ESyncSecond");

    75 _LIT(KESyncMinute, 								"ESyncMinute");

    76 _LIT(KESyncDay, 								"ESyncDay");

    77 

    78 _LIT(KENone, 									"ENone");

    79 _LIT(KEPointerMove, 							"EPointerMove");

    80 _LIT(KEPointerSwitchOn, 						"EPointerSwitchOn");

    81 _LIT(KEKeyDown, 								"EKeyDown");

    82 _LIT(KEKeyUp, 									"EKeyUp");

    83 _LIT(KERedraw, 									"ERedraw");

    84 _LIT(KESwitchOn, 								"ESwitchOn");

    85 _LIT(KEActive, 								    "EActive");

    86 _LIT(KEInactive,                                "EInactive");

    87 _LIT(KEUpdateModifiers,                         "EUpdateModifiers");

    88 _LIT(KEButton1Down,                             "EButton1Down");

    89 _LIT(KEButton1Up,                               "EButton1Up");

    90 _LIT(KEButton2Down,                             "EButton2Down");

    91 _LIT(KEButton2Up,                               "EButton2Up");

    92 _LIT(KEButton3Down,                             "EButton3Down");

    93 _LIT(KEButton3Up,                               "EButton3Up");

    94 _LIT(KESwitchOff,                               "ESwitchOff");

    95 _LIT(KEKeyRepeat,                               "EKeyRepeat");

    96 _LIT(KECaseOpen,                                "ECaseOpen");

    97 _LIT(KECaseClose,                               "ECaseClose");

    98 _LIT(KERestartSystem,                           "ERestartSystem");

    99 

   100 

   101 

   102 ///	Commands

   103 _LIT(KCmdnew, 									"new");

   104 _LIT(KCmdDestructorGeneral, 					"~");

   105 _LIT(KCmdDestructor, 							"~RAnimForMClass");

   106 _LIT(KCmdConstruct, 							"Construct");

   107 _LIT(KCmdCommandReply, 							"CommandReply");

   108 _LIT(KCmdDestroy, 								"Destroy");

   109 _LIT(KCmdClose, 								"Close");

   110 

   111 ///	Logging

   112 _LIT(KLogErrMissingPara, "Missing parameter '%S'");

   113 

   114 

   115 _LIT(KLogErrConstruct, "Construct return err = %d");

   116 _LIT(KLogInfoCmdConstruct1, "execute RAnimForMClass::Construct(const RWindowBase &, TInt, const TDesC8 &)");

   117 

   118 _LIT(KLogInfoCmdConstruct3, "execute RAnimForMClass::Construct(const RWsSprite &, TInt, const TDesC8 &)");

   119 

   120 _LIT(KLogErrCommandReply, "CommandReply return err = %d");

   121 _LIT(KLogInfoCmdCommandReply1, "execute RAnimForMClass::CommandReply(TInt),opcode=%d");

   122 

   123 _LIT(KLogInfoCmdCommandReply3, "execute RAnimForMClass::CommandReply(TInt, const TDesC8 &, const TIpcArgs &),opcode=%d");

   124 

   125 _LIT(KLogInfoCmdDestroy, "execute RAnimForMClass::Destroy()");

   126 _LIT(KLogInfoCmdDestructor1, "execute ~RAnimForMClass()");

   127 _LIT(KLogMissingParameter, "Missing parameter '%S'");

   128 _LIT(KlogDateTime, "DateTime");

   129 /*@}*/

   130 

   131 CT_DataAnimForMClass* CT_DataAnimForMClass::NewL()

   132 	{

   133 	CT_DataAnimForMClass*	ret = new (ELeave) CT_DataAnimForMClass();

   134 	CleanupStack::PushL(ret);

   135 	ret->ConstructL();

   136 	CleanupStack::Pop(ret);

   137 	return ret;

   138 	}

   139 

   140 CT_DataAnimForMClass::CT_DataAnimForMClass()

   141 :	iActiveCallback(NULL)

   142 	,iAnim(NULL)

   143 	{

   144 	}

   145 

   146 void CT_DataAnimForMClass::ConstructL()

   147 	{

   148 	iSendBuf.CreateL(KMaxBufSize);

   149 	iSendBuf.FillZ(1);

   150 	

   151 	for (TInt i=0;i<KIpcArgNum;i++)	

   152 		iIpcBuf[i].CreateL(KMaxBufSize);

   153 	}

   154 

   155 CT_DataAnimForMClass::~CT_DataAnimForMClass()

   156 	{

   157 	INFO_PRINTF1(KLogInfoCmdDestructor1);

   158 	DestroyData();

   159 	iSendBuf.Close();

   160 	

   161 	for (TInt i=0;i<KIpcArgNum;i++)	

   162 		iIpcBuf[i].Close();	

   163 	}

   164 

   165 TAny* CT_DataAnimForMClass::GetObject()

   166 	{

   167     return iAnim;

   168 	}

   169 

   170 void CT_DataAnimForMClass::SetObjectL(TAny* aAny)

   171 	{

   172 	DestroyData();

   173     iAnim = static_cast<T_RAnimChild*> (aAny);

   174 	}

   175 

   176 void CT_DataAnimForMClass::DisownObjectL()

   177 	{

   178     iAnim = NULL;

   179 	}

   180 

   181 void CT_DataAnimForMClass::DestroyData()

   182 	{

   183 	DoCmdDestroy();

   184 	}

   185 

   186 /**

   187 * Process a command read from the ini file

   188 *

   189 * @param aCommand			the command to process

   190 * @param aSection			the entry in the ini file requiring the command to be processed

   191 * @return ETrue if the command is processed

   192 */

   193 TBool CT_DataAnimForMClass::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection,const TInt)

   194 	{

   195 	TBool	ret = ETrue;

   196 

   197 	if ( aCommand==KCmdDestructorGeneral || aCommand==KCmdDestructor )

   198 		{

   199 		DoCmdDestructor();

   200 		}

   201 	else if ( aCommand==KCmdnew || aCommand==KDataClassname )

   202 		{

   203 		DoCmdnewL(aSection);

   204 		}

   205 	else if ( aCommand==KCmdConstruct )

   206 		{

   207 		DoCmdConstructL(aSection);

   208 		}

   209 	else if ( aCommand==KCmdCommandReply )

   210 		{

   211 		DoCmdCommandReplyL(aSection);

   212 		}

   213 	else if ( aCommand==KCmdDestroy )

   214 		{

   215 		DoCmdDestroy();

   216 		}

   217 	else if ( aCommand==KCmdClose )

   218 		{

   219 		DoCmdClose();

   220 		}

   221 	else

   222 		{

   223 		ret=EFalse;

   224 		}

   225 

   226 	return ret;

   227 	}

   228 

   229 void CT_DataAnimForMClass::DoCmdnewL(const TDesC& aSection)

   230 	{

   231 	DestroyData();

   232 	TPtrC  datRAnimName ; 

   233 	if ( GetStringFromConfig(aSection, KFldRAnim, datRAnimName))

   234 		{

   235 		iAnim = static_cast<T_RAnimChild*>(GetDataObjectL(datRAnimName));

   236 		}

   237 	else 

   238 		ERR_PRINTF2(KLogErrMissingPara, &KFldWin);

   239 	}

   240 

   241 void CT_DataAnimForMClass::ResetIpcArg()

   242 	{

   243 	for (TInt i=0; i<KIpcArgNum; i++)

   244 		{

   245 		iIpcArgs.Set(i, TIpcArgs::ENothing);

   246 		}

   247 	}

   248 

   249 void CT_DataAnimForMClass::DoCmdConstructL(const TDesC& aSection)

   250 	{

   251 	TInt err = KErrNone;

   252 	

   253 	// Get test data for command input parameter(s)

   254 	TBool dataOk = ETrue;

   255 

   256 	// Get "const RWindowBase &aDevice" or "const RWsSprite &aDevice"

   257 	TPtrC        datWinName;

   258 	RWindowBase* win = NULL;

   259 	TPtrC        datSpriteName;

   260 	RWsSprite*   sprite = NULL;

   261 	if ( GetStringFromConfig(aSection, KFldWin, datWinName))

   262 		{

   263 		win = static_cast<RWindowBase*>(GetDataObjectL(datWinName));

   264 		}

   265 	else if ( GetStringFromConfig(aSection, KFldSprite, datSpriteName))

   266 		{

   267 		sprite = static_cast<RWsSprite*>(GetDataObjectL(datSpriteName));

   268 		}

   269 	if (!win && !sprite )

   270 		{

   271 		dataOk = EFalse;

   272 		ERR_PRINTF2(KLogErrMissingPara, &KFldWin);

   273 		ERR_PRINTF2(KLogErrMissingPara, &KFldSprite);

   274 		}

   275 	

   276 	//Get "TInt aType"

   277 	TInt datType;

   278 	if ( !CT_GraphicsUtil::ReadAnimType(*this,aSection, KFldType, datType))

   279 		{

   280 		dataOk = EFalse;

   281 		ERR_PRINTF2(KLogErrMissingPara, &KFldType);

   282 		}

   283 	

   284 	// Get "const TDesC8 &aArgs"

   285 	TPtrC 	inputStr;

   286 

   287 	// get "const TIpcArgs &aIpcArgs"

   288 

   289 

   290 	if ( !dataOk )

   291 		{

   292 		SetBlockResult(EFail);

   293 		}

   294 	else

   295 		{	

   296 		// Execute command and log parameters

   297 		if (win)

   298 			{

   299 				INFO_PRINTF1(KLogInfoCmdConstruct1);

   300 				if (iAnim != NULL)

   301 				     err = iAnim->Construct(*win, datType, iSendBuf);	

   302 			}

   303 

   304 		else

   305 			{

   306 				INFO_PRINTF1(KLogInfoCmdConstruct3);

   307 				TInt len=iSendBuf.Length();

   308 				if (iAnim != NULL)

   309 					err = iAnim->Construct(*sprite, datType, iSendBuf);	

   310 				    

   311 				 

   312 			}

   313 		

   314 		// Check the command return code

   315 		if(err != KErrNone)

   316 			{

   317 			ERR_PRINTF2(KLogErrConstruct, err);

   318 			SetError(err);

   319 			}

   320 		}

   321 	}

   322 

   323 void CT_DataAnimForMClass::DoCmdCommandReplyL(const TDesC& aSection)

   324 	{

   325 

   326 	// Get test data for command input parameter(s)

   327 	TBool dataOk = ETrue;

   328 

   329 	// Get "TInt aOpcode"

   330 	TInt datOpcode;

   331 	if ( !CT_GraphicsUtil::ReadAnimCommand(*this, aSection, KFldOpcode,

   332 			datOpcode))//ReadAnimCommand():Convert datOpcode from string type to Int type

   333 		{

   334 		dataOk = EFalse;

   335 		ERR_PRINTF2(KLogErrMissingPara, &KFldOpcode);

   336 		}

   337 

   338 	if (!dataOk)

   339 		{

   340 		_LIT(KFailed, "Can not read the Operation code from the config file. Failed. ");

   341 		INFO_PRINTF1(KFailed);

   342 		SetBlockResult(EFail);

   343 		}

   344 	switch (datOpcode)

   345 		{

   346 			//Util

   347 		case ECmdRetrieveResult:

   348 			DoCmdRetrieveResult(aSection, datOpcode);

   349 			break;

   350 		case ECmdUtilEatupMemory:

   351 			DoCmdEatupMemory(datOpcode);

   352 			break;

   353 		case ECmdUtilFreeEatenMemory:

   354 			DoCmdFreeEatenMemory(datOpcode);

   355 			break;

   356 			// The MAnimGeneralFunctioins

   357 		case ECmdGeneralAnimate:

   358 			DoCmdGeneralAnimate(aSection, datOpcode);

   359 			break;

   360 		case ECmdGeneralClient:

   361 			DoCmdGeneralClient(aSection, datOpcode);

   362 			break;

   363 		case ECmdGeneralFlashStateOn:

   364 			DoCmdGeneralFlashStateOn(aSection, datOpcode);

   365 			break;

   366 		case ECmdGeneralPanic:

   367 			DoCmdGeneralPanic(aSection, datOpcode) ;

   368 			break;

   369 		case ECmdGeneralScreenDevice:

   370 			DoCmdGeneralScreenDevice(aSection, datOpcode) ;

   371 			break;

   372 		case ECmdGeneralExtendedInterface:

   373 			DoCmdGeneralExtendedInterface(aSection, datOpcode) ;

   374 			break;

   375 		case ECmdGeneralWindowExtension:

   376 			DoCmdGeneralWindowExtension(aSection, datOpcode) ;

   377 			break;

   378 		case ECmdGeneralNumOfExtInterfaces:

   379 			DoCmdGeneralNumOfExtInterfaces(aSection, datOpcode) ;

   380 			break;

   381 		case ECmdGeneralEventExtension:

   382 			DoCmdGeneralEventExtension(aSection, datOpcode) ;

   383 			break;

   384 		case ECmdGeneralGetRawEvents:

   385 			DoCmdGeneralGetRawEvents(aSection, datOpcode);

   386 			break;

   387 		case ECmdGeneralPostRawEvent:

   388 			DoCmdGeneralPostRawEvent(aSection, datOpcode);

   389 			break;

   390 		case ECmdGeneralPostKeyEvent:

   391 			DoCmdGeneralPostKeyEventL(aSection, datOpcode);

   392 			break;

   393 		case ECmdGeneralSetSync:

   394 			DoCmdGeneralSetSync(aSection, datOpcode);

   395 			break;

   396 		case ECmdGeneralSync:

   397 			DoCmdGeneralSync(aSection, datOpcode);

   398 			break;

   399 		case ECmdGeneralSetInterval:

   400 			DoCmdGeneralSetInterval(aSection, datOpcode);

   401 			break;

   402 		case ECmdGeneralSetNextInterval:

   403 			DoCmdGeneralSetNextInterval(aSection, datOpcode);

   404 			break;

   405 		case ECmdGeneralSystemTime:

   406 			DoCmdGeneralSystemTime(aSection, datOpcode);

   407 			break;

   408 		case ECmdGeneralRegisterForNotis:

   409 			DoCmdGeneralRegisterForNotis(aSection, datOpcode);

   410 			break;

   411 		case ECmdGeneralMessage:

   412 			DoCmdGeneralMessage(aSection, datOpcode);

   413 			break;

   414 		case ECmdGeneralDuplicateBitmapL:

   415 			DoCmdGeneralDuplicateBitmapL(aSection, datOpcode);

   416 			break;

   417 		case ECmdGeneralDuplicateFontL:

   418 			DoCmdGeneralDuplicateFontL(aSection, datOpcode);

   419 			break;

   420 		case ECmdGeneralCloseFont:

   421 			DoCmdGeneralCloseFontL(aSection, datOpcode);

   422 			break;

   423 		case ECmdGeneralReplyBuf8:

   424 			DoCmdGeneralReplyBuf8(aSection, datOpcode);

   425 			break;

   426 		case ECmdGeneralReplyBuf16:

   427 			DoCmdGeneralReplyBuf16(aSection, datOpcode);

   428 			break;

   429 			// the MAnimSpriteFunctioins 

   430 		case ECmdSpriteGetSpriteMember:

   431 			DoCmdSpriteGetSpriteMember(aSection, datOpcode);

   432 			break;

   433 		case ECmdSpriteUpdateMember:

   434 			DoCmdSpriteUpdateMember(aSection, datOpcode) ;

   435 			break;

   436 		case ECmdSpriteActivate:

   437 			DoCmdSpriteActivate(aSection, datOpcode) ;

   438 			break;

   439 		case ECmdSpriteSpriteCanBeSeen:

   440 			DoCmdSpriteSpriteCanBeSeen(aSection, datOpcode) ;

   441 			break;

   442 		case ECmdSpriteSizeChangedL:

   443 			DoCmdSpriteSizeChangedL(aSection, datOpcode) ;

   444 			break;

   445 		case ECmdSpriteSetPosition:

   446 			DoCmdSpriteSetPosition(aSection, datOpcode) ;

   447 			break;

   448 			//MAnimWindowFunctions

   449 		case ECmdWindowActivateGc:

   450 			{

   451 			DoWindowActivateGc(datOpcode);

   452 			break;

   453 			}

   454 		case ECmdWindowSetRect:

   455 		case ECmdWindowIsStarted:

   456 			{

   457 			DoWindowSetRect(datOpcode, aSection);

   458 			break;

   459 			}

   460 		case ECmdWindowWindowSize:

   461 			{

   462 			DoWindowWindowSizeL(datOpcode, aSection);

   463 			break;

   464 			}

   465 		case ECmdWindowIsHidden:

   466 			{

   467 			DoWindowIsHidden(datOpcode, aSection);

   468 			break;

   469 			}

   470 		case ECmdWindowSetVisible:

   471 			{

   472 			DoWindowSetVisible(datOpcode, aSection);

   473 			break;

   474 			}

   475 		case ECmdWindowInvalidate:

   476 			{

   477 			DoWindowInvalidate(datOpcode, aSection);

   478 			break;

   479 			}

   480 		case ECmdWindowParameters:

   481 			{

   482 			DoWindowParametersL(datOpcode, aSection);

   483 			break;

   484 			}

   485 		case ECmdWindowVisibleRegion:

   486 			{

   487 			DoWindowVisibleRegion(datOpcode, aSection);

   488 			break;

   489 

   490 			}

   491 			//MAnimGeneralFunctionsWindowExtension

   492 		case ECmdGfweScreens:

   493 			{

   494 			DoGeneralExtScreensL(datOpcode, aSection);

   495 			break;

   496 			}

   497 		case ECmdGfweFocusScreens:

   498 			{

   499 			DoGeneralExtFocusScreensL(datOpcode, aSection);

   500 			break;

   501 			}

   502 		case ECmdGfweSetFocusScreen:

   503 			{

   504 			DoGeneralExtSetFocusScreen(datOpcode, aSection);

   505 			break;

   506 			}

   507 		case ECmdGfweWindowGroups:

   508 			{

   509 			DoGeneralExtWindowGroupsL(datOpcode, aSection);

   510 			break;

   511 			}

   512 		case ECmdGfweWindowGroupInfo:

   513 			{

   514 			DoGeneralExtWindowGroupInfoL(datOpcode, aSection);

   515 			break;

   516 			}

   517 		case ECmdGfweWindowGroupName:

   518 			{

   519 			DoGeneralExtWindowGroupNameL(datOpcode, aSection);

   520 			break;

   521 			}

   522 		case ECmdGfweSetOrdinalPosition:

   523 			{

   524 			DoGeneralExtSetOrdinalPositionL(datOpcode, aSection);

   525 			break;

   526 			}

   527 		case ECmdGfweWindowConfig:

   528 			{

   529 			DoGeneralExtWindowConfigL(datOpcode, aSection);

   530 			break;

   531 			}

   532 			//MAnimFreeTimerWindowFunctions

   533 		case ECmdFreeTimerWinDeactivateGc:

   534 			{

   535 			DoFreeTimerWinDeactivateGc(datOpcode);

   536 			break;

   537 			}

   538 		case ECmdFreeTimerWinUpdate:

   539 			{

   540 			DoFreeTimerWinUpdate(datOpcode);

   541 			break;

   542 			}

   543 		default:

   544 			{

   545 			_LIT(KFailed2, "Unsupported operation code. ");

   546 			INFO_PRINTF1(KFailed2);

   547 			break;

   548 			}

   549 		}

   550 	}

   551 

   552 void CT_DataAnimForMClass::DoCmdClose()

   553 	{

   554 	iAnim  = NULL ;

   555 	}

   556 

   557 void CT_DataAnimForMClass::DoCmdDestroy()

   558 	{

   559 	INFO_PRINTF1(KLogInfoCmdDestroy);

   560 	iAnim  = NULL ;

   561 	}

   562 

   563 void CT_DataAnimForMClass::DoCmdDestructor()

   564 	{

   565 	// Execute command and log parameters

   566 	INFO_PRINTF1(KLogInfoCmdDestructor1);

   567 	iAnim = NULL;

   568 	}

   569 

   570 //*************************MAnimWindowFunctions verifying********************************

   571 void CT_DataAnimForMClass::DoWindowActivateGc(TInt aOpcode)

   572 	{

   573 	INFO_PRINTF2(KLogInfoCmdCommandReply1, aOpcode);

   574 	TInt err=iAnim->CommandReply(aOpcode);

   575 	INFO_PRINTF2(KLogErrCommandReply, err);

   576 

   577 	if (err != KErrNone)

   578 		{

   579 		ERR_PRINTF2(KLogErrCommandReply, err);

   580 		SetError(err);

   581 		}

   582 	}

   583 

   584 void CT_DataAnimForMClass::DoWindowSetRect(TInt aOpcode, const TDesC& aSection)

   585 	{

   586 	switch (aOpcode)

   587 		{

   588 		case ECmdWindowSetRect:

   589 			{

   590 			TPtrC8 ptr;

   591 			TRect sendRect;

   592 			if (!GetRectFromConfig(aSection, KFldRect, sendRect))

   593 				{

   594 				ERR_PRINTF2(KLogErrMissingPara, &KFldRect());

   595 				SetBlockResult(EFail);

   596 				}

   597 			TPckgBuf<TRect> sendVal(sendRect);

   598 			iIpcArgs.Set(0, TIpcArgs::ENothing);

   599 			iIpcArgs.Set(1, &sendVal);

   600 

   601 			INFO_PRINTF2(KLogInfoCmdCommandReply3, aOpcode);

   602 			TInt err=iAnim->CommandReply(aOpcode, ptr, iIpcArgs);

   603 			INFO_PRINTF2(KLogErrCommandReply, err);

   604 

   605 			if (err != KErrNone)

   606 				{

   607 				ERR_PRINTF2(KLogErrCommandReply, err);

   608 				SetError(err);

   609 				}

   610 			ResetIpcArg();

   611 			break;

   612 			}

   613 		case ECmdWindowIsStarted:

   614 			{

   615 			INFO_PRINTF2(KLogInfoCmdCommandReply1, aOpcode);

   616 			TInt err=iAnim->CommandReply(aOpcode);

   617 			INFO_PRINTF2(KLogErrCommandReply, err);

   618 			if (err != KErrNone)

   619 				{

   620 				ERR_PRINTF2(KLogErrCommandReply, err);

   621 				SetError(err);

   622 				}

   623 			break;

   624 			}

   625 		}

   626 	}

   627 

   628 void CT_DataAnimForMClass::DoWindowWindowSizeL(TInt aOpcode,const TDesC& aSection)

   629 	{

   630 	TPtrC8 ptr;

   631 	TPtrC datWinName;

   632 	RWindowBase* win= NULL;

   633 	if (GetStringFromConfig(aSection, KFldWin, datWinName))

   634 		{

   635 		win = static_cast<RWindowBase*>(GetDataObjectL(datWinName));

   636 		}

   637 	TSize expected=win->Size();

   638 	TSize resultBuf;

   639 	TPckgBuf<TSize> retrndPck(expected);

   640 	iIpcArgs.Set(0, TIpcArgs::ENothing);

   641 	iIpcArgs.Set(1, &retrndPck);

   642 	INFO_PRINTF2(KLogInfoCmdCommandReply3, aOpcode);

   643 	TInt err=iAnim->CommandReply(aOpcode, ptr, iIpcArgs);

   644 	INFO_PRINTF2(KLogErrCommandReply, err);

   645 

   646 	resultBuf=retrndPck();

   647 	if (expected!=resultBuf)

   648 		{

   649 		ERR_PRINTF5(_L("The returned value is not as expected, expected: (%d,%d), actual: (%d,%d)"), expected.iWidth,expected.iHeight, resultBuf.iWidth,resultBuf.iHeight);

   650 		SetBlockResult(EFail);

   651 		}

   652 	ResetIpcArg();

   653 	} 

   654 

   655 void CT_DataAnimForMClass::DoWindowIsHidden(TInt aOpcode,const TDesC& aSection)

   656 	{

   657 	TBool expectedVal;

   658 

   659 	if (!GetBoolFromConfig(aSection, KFldExpected, expectedVal))

   660 		{

   661 		ERR_PRINTF2(KLogErrMissingPara, &KFldExpected());

   662 		SetBlockResult(EFail);

   663 		}

   664 	else

   665 		{

   666 		INFO_PRINTF2(KLogInfoCmdCommandReply1, aOpcode);

   667 		TInt actual=iAnim->CommandReply(aOpcode);

   668 		INFO_PRINTF2(KLogErrCommandReply, actual);

   669 		if (actual!=expectedVal)

   670 			{

   671 			ERR_PRINTF3(_L("The returned value is not as expected, expected: %d, actual: %d"), expectedVal, actual);

   672 			SetBlockResult(EFail);

   673 			}

   674 		}

   675 	}

   676 

   677 void CT_DataAnimForMClass::DoWindowSetVisible(TInt aOpcode,const TDesC& aSection)

   678 	{

   679 	TBool setVisible;

   680 	TPtrC8 ptr;

   681 

   682 	if (!GetBoolFromConfig(aSection, KFldState, setVisible))

   683 		{

   684 		ERR_PRINTF2(KLogErrMissingPara, &KFldState());

   685 		SetBlockResult(EFail);

   686 		}

   687 

   688 	iIpcArgs.Set(0, TIpcArgs::ENothing);

   689 	TPckgBuf<TBool> setVisiblePck(setVisible);

   690 	iIpcArgs.Set(1, &setVisiblePck);

   691 	INFO_PRINTF2(KLogInfoCmdCommandReply3, aOpcode);

   692 	TInt err=iAnim->CommandReply(aOpcode, ptr, iIpcArgs);

   693 	INFO_PRINTF2(KLogErrCommandReply, err);

   694 	if (err != KErrNone)

   695 		{

   696 		ERR_PRINTF2(KLogErrCommandReply, err);

   697 		SetError(err);

   698 		}

   699 	ResetIpcArg();

   700 	}

   701 

   702 void CT_DataAnimForMClass::DoWindowInvalidate(TInt aOpcode,const TDesC& aSection)

   703 	{

   704 

   705 	TPtrC datWinName;

   706 	TPtrC8 ptr;

   707 	TRect rectVal;

   708 	if (!GetRectFromConfig(aSection, KFldRect, rectVal))

   709 		{

   710 		ERR_PRINTF2(KLogErrMissingPara, &KFldRect());

   711 		SetBlockResult(EFail);

   712 		}

   713 	iIpcArgs.Set(0, TIpcArgs::ENothing);

   714 	TPckgBuf<TRect> rectValPck(rectVal);

   715 	iIpcArgs.Set(1, &rectValPck);

   716 	INFO_PRINTF2(KLogInfoCmdCommandReply3, aOpcode);

   717 	TInt err=iAnim->CommandReply(aOpcode, ptr, iIpcArgs);

   718 	INFO_PRINTF2(KLogErrCommandReply, err);

   719 	if (err != KErrNone)

   720 		{

   721 		ERR_PRINTF2(KLogErrCommandReply, err);

   722 		SetError(err);

   723 		}

   724 	ResetIpcArg();

   725 	}

   726 

   727 void CT_DataAnimForMClass::DoWindowParametersL(TInt aOpcode,const TDesC& aSection)

   728 	{

   729 	RWindowBase* win= NULL;

   730 	TSize expectedSize;

   731 	TInt expectedDisplyMd;

   732 	TPtrC val;

   733 	TPtrC8 ptr;

   734 	TPtrC datWinName;

   735 	TPckgBuf<TRect> retrndWindowPostn;

   736 	TPckgBuf<TInt> retrndDisplyMd;

   737 	iIpcArgs.Set(0, TIpcArgs::ENothing);

   738 	iIpcArgs.Set(1, &retrndWindowPostn);

   739 	iIpcArgs.Set(2, &retrndDisplyMd);

   740 

   741 	//Send command to server

   742 	TInt err=iAnim->CommandReply(aOpcode, ptr, iIpcArgs);

   743 	INFO_PRINTF2(KLogErrCommandReply, err);

   744 	if (err != KErrNone)

   745 		{

   746 		ERR_PRINTF2(KLogErrCommandReply, err);

   747 		SetError(err);

   748 		}

   749 	else

   750 		{

   751 		//Get the window's Size and Displaymode

   752 		if (GetStringFromConfig(aSection, KFldWin, datWinName))

   753 			{

   754 			win = static_cast<RWindowBase*>(GetDataObjectL(datWinName));

   755 			}

   756 		expectedSize=win->Size();

   757 		expectedDisplyMd=win->DisplayMode();

   758 

   759 		TRect retrndWinInf=retrndWindowPostn();

   760 		TSize retrndSize=retrndWinInf.Size();

   761 		TInt retrndDisplyM=retrndDisplyMd();

   762 

   763 		if (retrndSize!=expectedSize)

   764 			{

   765 			ERR_PRINTF5(_L("The value is not as expected! expected: (%d,%d), actual: (%d,%d)"), expectedSize.iWidth,expectedSize.iHeight, retrndSize.iWidth,retrndSize.iHeight);

   766 			SetBlockResult(EFail);

   767 			}

   768 		if (retrndDisplyM!=expectedDisplyMd)

   769 			{

   770 			ERR_PRINTF3(_L("The value is not as expected! expected: %d, actual: %d"), expectedDisplyMd, retrndDisplyM);

   771 			SetBlockResult(EFail);

   772 			}

   773 		}

   774 	ResetIpcArg();

   775 	}

   776 

   777 void CT_DataAnimForMClass::DoWindowVisibleRegion(TInt aOpcode,const TDesC& aSection)

   778 	{

   779 	TInt expecteValue;

   780 	TInt actual;

   781 

   782 	if (!GetIntFromConfig(aSection, KFldExpected, expecteValue))

   783 		{

   784 		ERR_PRINTF2(KLogErrMissingPara, &KFldExpected());

   785 		SetBlockResult(EFail);

   786 		}

   787 	else

   788 		{

   789 		actual=iAnim->CommandReply(aOpcode);

   790 		INFO_PRINTF2(KLogErrCommandReply, actual);

   791 		if (actual!=expecteValue)

   792 			{

   793 			ERR_PRINTF3(_L("The returned value is not as expected, expected: %d, actual: %d"), expecteValue, actual);

   794 			SetBlockResult(EFail);

   795 			}

   796 		}

   797 	}

   798 

   799 //****************MAnimGeneralFunctionsWindowExtension verifying*******************************

   800 

   801 void CT_DataAnimForMClass::DoGeneralExtScreensL(TInt aOpcode,const TDesC& aSection)

   802 	{

   803 	RWsSession* ws;

   804 	TPtrC datWsName;

   805 	if (GetStringFromConfig(aSection, KFldWs, datWsName))

   806 		{

   807 		ws = static_cast<RWsSession*>(GetDataObjectL(datWsName));

   808 		}

   809 	TInt expectedScreenNumb=ws->NumberOfScreens();

   810 	//Send Command, no data to server, check the returned value from Server by comparing with RWsSession::NumberOfScreens

   811 	TInt actualScreenNumb=iAnim->CommandReply(aOpcode);

   812 	INFO_PRINTF2(KLogErrCommandReply, actualScreenNumb);

   813 	if (actualScreenNumb!=expectedScreenNumb)

   814 		{

   815 		ERR_PRINTF3(_L("The returned value is not as expected, expected: %d, actual: %d"), expectedScreenNumb, actualScreenNumb);

   816 		SetBlockResult(EFail);

   817 		}

   818 	}

   819 

   820 void CT_DataAnimForMClass::DoGeneralExtFocusScreensL(TInt aOpcode,const TDesC& aSection)

   821 	{

   822 	RWsSession* ws;

   823 	TPtrC datWsName;

   824 	TInt expectedVal;

   825 

   826 	TInt actual=iAnim->CommandReply(aOpcode);

   827 	INFO_PRINTF2(_L("FocuseScreens is %d"),actual);

   828 

   829 	//If there is no expected value set in ini file, get the focus screen; 

   830 	if (!GetIntFromConfig(aSection, KFldExpected, expectedVal))

   831 		{

   832 		if (GetStringFromConfig(aSection, KFldWs, datWsName))

   833 			{

   834 			ws = static_cast<RWsSession*>(GetDataObjectL(datWsName));

   835 			}

   836 

   837 		expectedVal=ws->GetFocusScreen();

   838 		}

   839 

   840 	if (actual!=expectedVal)

   841 		{

   842 		ERR_PRINTF3(_L("The returned value is not as expected, expected: %d, actual: %d"), expectedVal, actual);

   843 		SetBlockResult(EFail);

   844 		}

   845 	}

   846 

   847 void CT_DataAnimForMClass::DoGeneralExtSetFocusScreen(TInt aOpcode,const TDesC& aSection)

   848 	{

   849 	TInt screenNo;

   850 	TPtrC8 ptr;

   851 	TPtrC datWsName;

   852 

   853 	if (!GetIntFromConfig(aSection, KFldScreenNumb, screenNo))

   854 		{

   855 		ERR_PRINTF2(KLogMissingParameter, &KFldScreenNumb());

   856 		SetBlockResult(EFail);

   857 		}

   858 	iIpcArgs.Set(0, TIpcArgs::ENothing);

   859 	TPckgBuf<TInt> screenNoPck(screenNo);

   860 	iIpcArgs.Set(1, &screenNoPck);

   861 	TInt actual=iAnim->CommandReply(aOpcode, ptr, iIpcArgs);

   862 	INFO_PRINTF2(KLogErrCommandReply, actual);

   863 

   864 	ResetIpcArg();

   865 	}

   866 

   867 void CT_DataAnimForMClass::DoGeneralExtWindowGroupsL(TInt aOpcode,const TDesC& aSection)

   868 	{

   869 	TPtrC8 ptr;

   870 	TInt screenNo;

   871 	TPtrC datWsName;

   872 	RWsSession* ws;

   873 	if (!GetIntFromConfig(aSection, KFldScreenNumb, screenNo))

   874 		{

   875 		ERR_PRINTF2(KLogErrMissingPara, &KFldScreenNumb());

   876 		SetBlockResult(EFail);

   877 		}

   878 	iIpcArgs.Set(0, TIpcArgs::ENothing);

   879 	TPckgBuf<TInt> screenNoPck(screenNo);

   880 	iIpcArgs.Set(1, &screenNoPck);

   881 	TInt actual=iAnim->CommandReply(aOpcode, ptr, iIpcArgs);

   882 	INFO_PRINTF2(KLogErrCommandReply, actual);

   883 

   884 	if (!GetStringFromConfig(aSection, KFldWs, datWsName))

   885 		{

   886 		ERR_PRINTF2(KLogErrMissingPara, &KFldWs());

   887 		SetBlockResult(EFail);

   888 		}

   889 	ws = static_cast<RWsSession*>(GetDataObjectL(datWsName));

   890 	TInt expectedVal=ws->NumWindowGroups();

   891 

   892 	if (actual!=expectedVal)

   893 		{

   894 		ERR_PRINTF3(_L("The returned value is not as expected, expected: %d, actual: %d"), expectedVal, actual);

   895 		SetBlockResult(EFail);

   896 		}

   897 	ResetIpcArg();

   898 	}

   899 

   900 void CT_DataAnimForMClass::DoGeneralExtWindowGroupInfoL(TInt aOpcode,const TDesC& aSection)

   901 	{

   902 	TInt screenNo;

   903 	TPtrC8 ptr;

   904 	TPtrC datWingrpName;

   905 	TInt retrnPck;

   906 	TInt expectedGrpInfo;

   907 	RWindowGroup* wingrp;

   908 	//Get window group object in order to verify the window group's name's existance.

   909 	if (!GetStringFromConfig(aSection, KFldWingrp, datWingrpName))

   910 		{

   911 		ERR_PRINTF2(KLogErrMissingPara, &KFldWingrp());

   912 		SetBlockResult(EFail);

   913 		}

   914 	wingrp = static_cast<RWindowGroup*>(GetDataObjectL(datWingrpName));

   915 

   916 	//Get screen number from ini file and set to IPC slot 1.

   917 	if (!GetIntFromConfig(aSection, KFldScreenNumb, screenNo))

   918 		{

   919 		ERR_PRINTF2(KLogErrMissingPara, &KFldScreenNumb());

   920 		SetBlockResult(EFail);

   921 		}

   922 	iIpcArgs.Set(0, TIpcArgs::ENothing);

   923 	TPckgBuf<TInt> screenNoPck(screenNo);

   924 	iIpcArgs.Set(1, &screenNoPck);

   925 

   926 	//Get fullOrdipostion from ini or by using FullOrdinalPosition method and set to IPC slot 2.

   927 	TInt fullOrdiPostion;

   928 	if (!GetIntFromConfig(aSection, KFldFullOrdinPostn, fullOrdiPostion))

   929 		{

   930 		fullOrdiPostion=wingrp->FullOrdinalPosition();

   931 		}

   932 	TPckgBuf<TInt> fullOrdiPostionPck(fullOrdiPostion);

   933 	iIpcArgs.Set(2, &fullOrdiPostionPck);

   934 

   935 	//Set IPC slot 3 to receive ID of the TWindowGroupInfo.

   936 	TPckgBuf<TInt> retrnWinGrpInfo;

   937 	iIpcArgs.Set(3, &retrnWinGrpInfo);

   938 

   939 	TInt actual=iAnim->CommandReply(aOpcode, ptr, iIpcArgs);

   940 	INFO_PRINTF2(KLogErrCommandReply, actual);

   941 	TBool expectedVal;

   942 	if (!GetBoolFromConfig(aSection, KFldExpected, expectedVal))

   943 		{

   944 		ERR_PRINTF2(KLogMissingParameter, &KFldExpected);

   945 		SetBlockResult(EFail);

   946 		}

   947 	if (actual!=expectedVal)

   948 		{

   949 		ERR_PRINTF3(_L("The returned value is not as expected, expected: %d, actual: %d"), expectedVal, actual);

   950 		SetBlockResult(EFail);

   951 		}

   952 	if (actual!=EFalse)

   953 		{

   954 		retrnPck=retrnWinGrpInfo();//Get returned window group ID

   955 

   956 		expectedGrpInfo=wingrp->WindowGroupId();

   957 		if (retrnPck!=expectedGrpInfo)

   958 			{

   959 			ERR_PRINTF3(

   960 			_L("The returned value is not as expected, expected: %d, actual: %d"),

   961 			expectedGrpInfo, retrnPck);

   962 			SetBlockResult(EFail);

   963 			}

   964 		}

   965 	ResetIpcArg();

   966 	}

   967 

   968 void CT_DataAnimForMClass::DoGeneralExtWindowGroupNameL(TInt aOpcode,const TDesC& aSection)

   969 	{

   970 	TBuf<32> getWindowName;

   971 	TBool expectedVal;

   972 	TInt screenNo;

   973 	TInt fullOrdiPostion;

   974 	//Get Screen number from ini and set to IPC slot 1.

   975 	if (!GetIntFromConfig(aSection, KFldScreenNumb, screenNo))

   976 		{

   977 		ERR_PRINTF2(KLogErrMissingPara, &KFldScreenNumb);

   978 		SetBlockResult(EFail);

   979 		}

   980 	TPtrC8 ptr;

   981 	TPckgBuf<TInt> screenNoPck(screenNo);

   982 	iIpcArgs.Set(0, TIpcArgs::ENothing);

   983 	iIpcArgs.Set(1, &screenNoPck);

   984 

   985 	TPtrC datWingrpName;

   986 	RWindowGroup* wingrp;

   987 	//Get window group object

   988 	if (!GetStringFromConfig(aSection, KFldWingrp, datWingrpName))

   989 		{

   990 		ERR_PRINTF2(KLogErrMissingPara, &KFldWingrp());

   991 		SetBlockResult(EFail);

   992 		}

   993 	wingrp = static_cast<RWindowGroup*>(GetDataObjectL(datWingrpName));

   994 	//Get fullOrdinary position and set to IPC slot 2.

   995 	if (!GetIntFromConfig(aSection, KFldFullOrdinPostn, fullOrdiPostion))

   996 		{

   997 		fullOrdiPostion=wingrp->FullOrdinalPosition();

   998 		}

   999 

  1000 	TPckgBuf<TInt> fullOrdiPostionPck(fullOrdiPostion);

  1001 	iIpcArgs.Set(2, &fullOrdiPostionPck);

  1002 	//Set IPC slot 3 to receive the window name returned from server side.

  1003 	TBuf<32> retrnWindowName;

  1004 	iIpcArgs.Set(3, &retrnWindowName);

  1005 

  1006 	TInt actual=iAnim->CommandReply(aOpcode, ptr, iIpcArgs);

  1007 	INFO_PRINTF2(KLogErrCommandReply, actual);

  1008 	if (!GetBoolFromConfig(aSection, KFldExpected, expectedVal))

  1009 		{

  1010 		ERR_PRINTF2(KLogMissingParameter, &KFldExpected);

  1011 		SetBlockResult(EFail);

  1012 		}

  1013 	if (actual!=expectedVal)

  1014 		{

  1015 		ERR_PRINTF3(_L("The returned value is not as expected, expected: %d, actual: %d"), expectedVal, actual);

  1016 		SetBlockResult(EFail);

  1017 		}

  1018 	//If commandreply returns ETrue then check the window group's name.

  1019 	if (actual)

  1020 		{

  1021 		TInt result=wingrp->Name(getWindowName);

  1022 		if (result!=KErrNone)

  1023 			{

  1024 			ERR_PRINTF1(_L("Failed to get the window group's name!"));

  1025 			SetError(result);

  1026 			}

  1027 		INFO_PRINTF3(_L("Check the group name is expected. expected: %d,actual: %d"),&getWindowName,&retrnWindowName);

  1028 		if (getWindowName!=retrnWindowName)

  1029 			{

  1030 			ERR_PRINTF1(_L("The returned window group name is not expected"));

  1031 			SetBlockResult(EFail);

  1032 			}

  1033 		}

  1034 	ResetIpcArg();

  1035 	}

  1036 

  1037 void CT_DataAnimForMClass::DoGeneralExtSetOrdinalPositionL(TInt aOpcode,const TDesC& aSection)

  1038 	{

  1039 	TInt expectedVal;

  1040 	TPtrC8 ptr;

  1041 	TInt wingrpid;

  1042 	TInt newOrdinPrio;

  1043 	TInt newOrdinaPostn;

  1044 	TPtrC datWingrpName;

  1045 	RWindowGroup* wingrp;

  1046 	if (GetStringFromConfig(aSection, KFldWingrp, datWingrpName))

  1047 		{

  1048 		wingrp = static_cast<RWindowGroup*>(GetDataObjectL(datWingrpName));

  1049 		}

  1050 	//Before sending command, get window group ID from wrapper or ini as arg(IPC slot 1)

  1051 	if (!GetIntFromConfig(aSection, KFldWingrpId, wingrpid))

  1052 		{

  1053 		wingrpid=wingrp->WindowGroupId();

  1054 		INFO_PRINTF2(_L("RWindowTreeNode::WindowGroupId	= %d"), wingrpid);

  1055 		}

  1056 	iIpcArgs.Set(0, TIpcArgs::ENothing);

  1057 	TPckgBuf<TInt> wingrpidPck(wingrpid);

  1058 	iIpcArgs.Set(1, &wingrpidPck);

  1059 

  1060 	//Get Group Id from wrapper or ini and send to server as IPC slot2

  1061 	if (!GetIntFromConfig(aSection, KFldOrdinalPosition, newOrdinaPostn))

  1062 		{

  1063 		newOrdinaPostn = wingrp->OrdinalPosition();

  1064 		INFO_PRINTF2(_L("RWindowTreeNode::FullOrdinalPosition	= %d"), newOrdinaPostn);

  1065 		}

  1066 	TPckgBuf<TInt> newOrdinaPostnPck(newOrdinaPostn);

  1067 	iIpcArgs.Set(2, &newOrdinaPostnPck);

  1068 

  1069 	//Get new ordinal priority of the window as arg(IPC slot 3) from ini file;

  1070 	if (!GetIntFromConfig(aSection, KFldOrdinalPriority, newOrdinPrio))

  1071 		{

  1072 		newOrdinPrio = wingrp->OrdinalPriority();

  1073 		INFO_PRINTF2(_L("RWindowTreeNode::FullOrdinalPriority	= %d"), newOrdinPrio);

  1074 		}

  1075 	TPckgBuf<TInt> newOrdinPrioPck(newOrdinPrio);

  1076 	iIpcArgs.Set(3, &newOrdinPrioPck);

  1077 

  1078 	TInt err=iAnim->CommandReply(aOpcode, ptr, iIpcArgs);

  1079 	if (!GetIntFromConfig(aSection, KFldExpected, expectedVal))

  1080 		{

  1081 		ERR_PRINTF2(KLogMissingParameter, &KFldExpected);

  1082 		SetBlockResult(EFail);

  1083 		}

  1084 

  1085 	if (err!=expectedVal)

  1086 		{

  1087 		ERR_PRINTF3(_L("The returned value is not as expected, expected: %d, actual: %d"), expectedVal, err);

  1088 		SetBlockResult(EFail);

  1089 		}

  1090 	//Get the new OrdinalPostion and Priority using window group methods;

  1091 	if (err!=KErrNotFound)

  1092 		{

  1093 		TInt retrnOrdinPostn=wingrp->OrdinalPosition();

  1094 		TInt retrnOrdinPrio=wingrp->OrdinalPriority();

  1095 

  1096 		if (retrnOrdinPostn!=newOrdinaPostn)

  1097 			{

  1098 			ERR_PRINTF3(

  1099 			_L("The returned ordinalposition is not as expected, expected: %d, actual: %d"),

  1100 			newOrdinaPostn, retrnOrdinPostn);

  1101 			SetBlockResult(EFail);

  1102 			}

  1103 

  1104 		if (retrnOrdinPrio!=newOrdinPrio)

  1105 			{

  1106 			ERR_PRINTF3(

  1107 			_L("The returned ordinalpriority is not as expected, expected: %d, actual: %d"),

  1108 			newOrdinPrio, retrnOrdinPrio);

  1109 			SetBlockResult(EFail);

  1110 			}

  1111 		}

  1112 	ResetIpcArg();

  1113 	}

  1114 

  1115 void CT_DataAnimForMClass::DoGeneralExtIsFocusableL(TInt aOpcode, const TDesC& aSection)

  1116 	{

  1117 	TInt screenNub;

  1118 	TBool expectedVal;

  1119 	TInt sendFullOrdinPstn;

  1120 	if (!GetIntFromConfig(aSection, KFldScreenNumb, screenNub))

  1121 		{

  1122 		ERR_PRINTF2(KLogErrMissingPara, &KFldScreenNumb);

  1123 		}

  1124 	TPtrC8 ptr;

  1125 	iIpcArgs.Set(0, TIpcArgs::ENothing);

  1126 	TPckgBuf<TInt> screenNubPck(screenNub);

  1127 	iIpcArgs.Set(1, &screenNubPck);

  1128 

  1129 	TPtrC datWingrpName;

  1130 	RWindowGroup* wingrp;

  1131 	if (GetStringFromConfig(aSection, KFldWingrp, datWingrpName))

  1132 		{

  1133 		wingrp = static_cast<RWindowGroup*>(GetDataObjectL(datWingrpName));

  1134 		}

  1135