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 the License "Symbian Foundation License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.symbianfoundation.org/legal/sfl-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 	if ( !dataOk )

   290 		{

   291 		SetBlockResult(EFail);

   292 		}

   293 	else

   294 		{	

   295 		// Execute command and log parameters

   296 		if (win)

   297 			{

   298 				INFO_PRINTF1(KLogInfoCmdConstruct1);

   299 				if (iAnim != NULL)

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

   301 			}

   302 

   303 		else

   304 			{

   305 				INFO_PRINTF1(KLogInfoCmdConstruct3);

   306 				if (iAnim != NULL)

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

   308 			}

   309 		

   310 		// Check the command return code

   311 		if(err != KErrNone)

   312 			{

   313 			ERR_PRINTF2(KLogErrConstruct, err);

   314 			SetError(err);

   315 			}

   316 		}

   317 	}

   318 

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

   320 	{

   321 	

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

   323 	TBool dataOk = ETrue;

   324 

   325 	// Get "TInt aOpcode"

   326 	TInt datOpcode;

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

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

   329 		{

   330 		dataOk = EFalse;

   331 		ERR_PRINTF2(KLogErrMissingPara, &KFldOpcode);

   332 		}

   333 

   334 	if (!dataOk)

   335 		{

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

   337 		INFO_PRINTF1(KFailed);

   338 		SetBlockResult(EFail);

   339 		}

   340 	switch (datOpcode)

   341 		{

   342 			//Util

   343 		case ECmdRetrieveResult:

   344 			DoCmdRetrieveResult(aSection, datOpcode);

   345 			break;

   346 		case ECmdUtilEatupMemory:

   347 			DoCmdEatupMemory(datOpcode);

   348 			break;

   349 		case ECmdUtilFreeEatenMemory:

   350 			DoCmdFreeEatenMemory(datOpcode);

   351 			break;

   352 			// The MAnimGeneralFunctioins

   353 		case ECmdGeneralAnimate:

   354 			DoCmdGeneralAnimate(aSection, datOpcode);

   355 			break;

   356 		case ECmdGeneralClient:

   357 			DoCmdGeneralClient(aSection, datOpcode);

   358 			break;

   359 		case ECmdGeneralFlashStateOn:

   360 			DoCmdGeneralFlashStateOn(aSection, datOpcode);

   361 			break;

   362 		case ECmdGeneralPanic:

   363 			DoCmdGeneralPanic(aSection, datOpcode) ;

   364 			break;

   365 		case ECmdGeneralScreenDevice:

   366 			DoCmdGeneralScreenDevice(aSection, datOpcode) ;

   367 			break;

   368 		case ECmdGeneralExtendedInterface:

   369 			DoCmdGeneralExtendedInterface(aSection, datOpcode) ;

   370 			break;

   371 		case ECmdGeneralWindowExtension:

   372 			DoCmdGeneralWindowExtension(aSection, datOpcode) ;

   373 			break;

   374 		case ECmdGeneralNumOfExtInterfaces:

   375 			DoCmdGeneralNumOfExtInterfaces(aSection, datOpcode) ;

   376 			break;

   377 		case ECmdGeneralEventExtension:

   378 			DoCmdGeneralEventExtension(aSection, datOpcode) ;

   379 			break;

   380 		case ECmdGeneralGetRawEvents:

   381 			DoCmdGeneralGetRawEvents(aSection, datOpcode);

   382 			break;

   383 		case ECmdGeneralPostRawEvent:

   384 			DoCmdGeneralPostRawEvent(aSection, datOpcode);

   385 			break;

   386 		case ECmdGeneralPostKeyEvent:

   387 			DoCmdGeneralPostKeyEventL(aSection, datOpcode);

   388 			break;

   389 		case ECmdGeneralSetSync:

   390 			DoCmdGeneralSetSync(aSection, datOpcode);

   391 			break;

   392 		case ECmdGeneralSync:

   393 			DoCmdGeneralSync(aSection, datOpcode);

   394 			break;

   395 		case ECmdGeneralSetInterval:

   396 			DoCmdGeneralSetInterval(aSection, datOpcode);

   397 			break;

   398 		case ECmdGeneralSetNextInterval:

   399 			DoCmdGeneralSetNextInterval(aSection, datOpcode);

   400 			break;

   401 		case ECmdGeneralSystemTime:

   402 			DoCmdGeneralSystemTime(aSection, datOpcode);

   403 			break;

   404 		case ECmdGeneralRegisterForNotis:

   405 			DoCmdGeneralRegisterForNotis(aSection, datOpcode);

   406 			break;

   407 		case ECmdGeneralMessage:

   408 			DoCmdGeneralMessage(aSection, datOpcode);

   409 			break;

   410 		case ECmdGeneralDuplicateBitmapL:

   411 			DoCmdGeneralDuplicateBitmapL(aSection, datOpcode);

   412 			break;

   413 		case ECmdGeneralDuplicateFontL:

   414 			DoCmdGeneralDuplicateFontL(aSection, datOpcode);

   415 			break;

   416 		case ECmdGeneralCloseFont:

   417 			DoCmdGeneralCloseFontL(aSection, datOpcode);

   418 			break;

   419 		case ECmdGeneralReplyBuf8:

   420 			DoCmdGeneralReplyBuf8(aSection, datOpcode);

   421 			break;

   422 		case ECmdGeneralReplyBuf16:

   423 			DoCmdGeneralReplyBuf16(aSection, datOpcode);

   424 			break;

   425 			// the MAnimSpriteFunctioins 

   426 		case ECmdSpriteGetSpriteMember:

   427 			DoCmdSpriteGetSpriteMember(aSection, datOpcode);

   428 			break;

   429 		case ECmdSpriteUpdateMember:

   430 			DoCmdSpriteUpdateMember(aSection, datOpcode) ;

   431 			break;

   432 		case ECmdSpriteActivate:

   433 			DoCmdSpriteActivate(aSection, datOpcode) ;

   434 			break;

   435 		case ECmdSpriteSpriteCanBeSeen:

   436 			DoCmdSpriteSpriteCanBeSeen(aSection, datOpcode) ;

   437 			break;

   438 		case ECmdSpriteSizeChangedL:

   439 			DoCmdSpriteSizeChangedL(aSection, datOpcode) ;

   440 			break;

   441 		case ECmdSpriteSetPosition:

   442 			DoCmdSpriteSetPosition(aSection, datOpcode) ;

   443 			break;

   444 			//MAnimWindowFunctions

   445 		case ECmdWindowActivateGc:

   446 			{

   447 			DoWindowActivateGc(datOpcode);

   448 			break;

   449 			}

   450 		case ECmdWindowSetRect:

   451 		case ECmdWindowIsStarted:

   452 			{

   453 			DoWindowSetRect(datOpcode, aSection);

   454 			break;

   455 			}

   456 		case ECmdWindowWindowSize:

   457 			{

   458 			DoWindowWindowSizeL(datOpcode, aSection);

   459 			break;

   460 			}

   461 		case ECmdWindowIsHidden:

   462 			{

   463 			DoWindowIsHidden(datOpcode, aSection);

   464 			break;

   465 			}

   466 		case ECmdWindowSetVisible:

   467 			{

   468 			DoWindowSetVisible(datOpcode, aSection);

   469 			break;

   470 			}

   471 		case ECmdWindowInvalidate:

   472 			{

   473 			DoWindowInvalidate(datOpcode, aSection);

   474 			break;

   475 			}

   476 		case ECmdWindowParameters:

   477 			{

   478 			DoWindowParametersL(datOpcode, aSection);

   479 			break;

   480 			}

   481 		case ECmdWindowVisibleRegion:

   482 			{

   483 			DoWindowVisibleRegion(datOpcode, aSection);

   484 			break;

   485 

   486 			}

   487 			//MAnimGeneralFunctionsWindowExtension

   488 		case ECmdGfweScreens:

   489 			{

   490 			DoGeneralExtScreensL(datOpcode, aSection);

   491 			break;

   492 			}

   493 		case ECmdGfweFocusScreens:

   494 			{

   495 			DoGeneralExtFocusScreensL(datOpcode, aSection);

   496 			break;

   497 			}

   498 		case ECmdGfweSetFocusScreen:

   499 			{

   500 			DoGeneralExtSetFocusScreen(datOpcode, aSection);

   501 			break;

   502 			}

   503 		case ECmdGfweWindowGroups:

   504 			{

   505 			DoGeneralExtWindowGroupsL(datOpcode, aSection);

   506 			break;

   507 			}

   508 		case ECmdGfweWindowGroupInfo:

   509 			{

   510 			DoGeneralExtWindowGroupInfoL(datOpcode, aSection);

   511 			break;

   512 			}

   513 		case ECmdGfweWindowGroupName:

   514 			{

   515 			DoGeneralExtWindowGroupNameL(datOpcode, aSection);

   516 			break;

   517 			}

   518 		case ECmdGfweSetOrdinalPosition:

   519 			{

   520 			DoGeneralExtSetOrdinalPositionL(datOpcode, aSection);

   521 			break;

   522 			}

   523 			//MAnimFreeTimerWindowFunctions

   524 		case ECmdFreeTimerWinDeactivateGc:

   525 			{

   526 			DoFreeTimerWinDeactivateGc(datOpcode);

   527 			break;

   528 			}

   529 		case ECmdFreeTimerWinUpdate:

   530 			{

   531 			DoFreeTimerWinUpdate(datOpcode);

   532 			break;

   533 			}

   534 		default:

   535 			{

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

   537 			INFO_PRINTF1(KFailed2);

   538 			break;

   539 			}

   540 		}

   541 	}

   542 

   543 void CT_DataAnimForMClass::DoCmdClose()

   544 	{

   545 	iAnim  = NULL ;

   546 	}

   547 

   548 void CT_DataAnimForMClass::DoCmdDestroy()

   549 	{

   550 	INFO_PRINTF1(KLogInfoCmdDestroy);

   551 	iAnim  = NULL ;

   552 	}

   553 

   554 void CT_DataAnimForMClass::DoCmdDestructor()

   555 	{

   556 	// Execute command and log parameters

   557 	INFO_PRINTF1(KLogInfoCmdDestructor1);

   558 	iAnim = NULL;

   559 	}

   560 

   561 //*************************MAnimWindowFunctions verifying********************************

   562 void CT_DataAnimForMClass::DoWindowActivateGc(TInt aOpcode)

   563 	{

   564 	INFO_PRINTF2(KLogInfoCmdCommandReply1, aOpcode);

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

   566 	INFO_PRINTF2(KLogErrCommandReply, err);

   567 

   568 	if (err != KErrNone)

   569 		{

   570 		ERR_PRINTF2(KLogErrCommandReply, err);

   571 		SetError(err);

   572 		}

   573 	}

   574 

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

   576 	{

   577 	switch (aOpcode)

   578 		{

   579 		case ECmdWindowSetRect:

   580 			{

   581 			TPtrC8 ptr;

   582 			TRect sendRect;

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

   584 				{

   585 				ERR_PRINTF2(KLogErrMissingPara, &KFldRect());

   586 				SetBlockResult(EFail);

   587 				}

   588 			TPckgBuf<TRect> sendVal(sendRect);

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

   590 			iIpcArgs.Set(1, &sendVal);

   591 

   592 			INFO_PRINTF2(KLogInfoCmdCommandReply3, aOpcode);

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

   594 			INFO_PRINTF2(KLogErrCommandReply, err);

   595 

   596 			if (err != KErrNone)

   597 				{

   598 				ERR_PRINTF2(KLogErrCommandReply, err);

   599 				SetError(err);

   600 				}

   601 			ResetIpcArg();

   602 			break;

   603 			}

   604 		case ECmdWindowIsStarted:

   605 			{

   606 			INFO_PRINTF2(KLogInfoCmdCommandReply1, aOpcode);

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

   608 			INFO_PRINTF2(KLogErrCommandReply, err);

   609 			if (err != KErrNone)

   610 				{

   611 				ERR_PRINTF2(KLogErrCommandReply, err);

   612 				SetError(err);

   613 				}

   614 			break;

   615 			}

   616 		}

   617 	}

   618 

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

   620 	{

   621 	TPtrC8 ptr;

   622 	TPtrC datWinName;

   623 	RWindowBase* win= NULL;

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

   625 		{

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

   627 		}

   628 	TSize expected=win->Size();

   629 	TSize resultBuf;

   630 	TPckgBuf<TSize> retrndPck(expected);

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

   632 	iIpcArgs.Set(1, &retrndPck);

   633 	INFO_PRINTF2(KLogInfoCmdCommandReply3, aOpcode);

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

   635 	INFO_PRINTF2(KLogErrCommandReply, err);

   636 

   637 	resultBuf=retrndPck();

   638 	if (expected!=resultBuf)

   639 		{

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

   641 		SetBlockResult(EFail);

   642 		}

   643 	ResetIpcArg();

   644 	} 

   645 

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

   647 	{

   648 	TBool expectedVal;

   649 

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

   651 		{

   652 		ERR_PRINTF2(KLogErrMissingPara, &KFldExpected());

   653 		SetBlockResult(EFail);

   654 		}

   655 	else

   656 		{

   657 		INFO_PRINTF2(KLogInfoCmdCommandReply1, aOpcode);

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

   659 		INFO_PRINTF2(KLogErrCommandReply, actual);

   660 		if (actual!=expectedVal)

   661 			{

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

   663 			SetBlockResult(EFail);

   664 			}

   665 		}

   666 	}

   667 

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

   669 	{

   670 	TBool setVisible;

   671 	TPtrC8 ptr;

   672 

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

   674 		{

   675 		ERR_PRINTF2(KLogErrMissingPara, &KFldState());

   676 		SetBlockResult(EFail);

   677 		}

   678 

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

   680 	TPckgBuf<TBool> setVisiblePck(setVisible);

   681 	iIpcArgs.Set(1, &setVisiblePck);

   682 	INFO_PRINTF2(KLogInfoCmdCommandReply3, aOpcode);

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

   684 	INFO_PRINTF2(KLogErrCommandReply, err);

   685 	if (err != KErrNone)

   686 		{

   687 		ERR_PRINTF2(KLogErrCommandReply, err);

   688 		SetError(err);

   689 		}

   690 	ResetIpcArg();

   691 	}

   692 

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

   694 	{

   695 	TPtrC datWinName;

   696 	TPtrC8 ptr;

   697 	TRect rectVal;

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

   699 		{

   700 		ERR_PRINTF2(KLogErrMissingPara, &KFldRect());

   701 		SetBlockResult(EFail);

   702 		}

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

   704 	TPckgBuf<TRect> rectValPck(rectVal);

   705 	iIpcArgs.Set(1, &rectValPck);

   706 	INFO_PRINTF2(KLogInfoCmdCommandReply3, aOpcode);

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

   708 	INFO_PRINTF2(KLogErrCommandReply, err);

   709 	if (err != KErrNone)

   710 		{

   711 		ERR_PRINTF2(KLogErrCommandReply, err);

   712 		SetError(err);

   713 		}

   714 	ResetIpcArg();

   715 	}

   716 

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

   718 	{

   719 	RWindowBase* win= NULL;

   720 	TSize expectedSize;

   721 	TInt expectedDisplyMd;

   722 	TPtrC val;

   723 	TPtrC8 ptr;

   724 	TPtrC datWinName;

   725 	TPckgBuf<TRect> retrndWindowPostn;

   726 	TPckgBuf<TInt> retrndDisplyMd;

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

   728 	iIpcArgs.Set(1, &retrndWindowPostn);

   729 	iIpcArgs.Set(2, &retrndDisplyMd);

   730 

   731 	//Send command to server

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

   733 	INFO_PRINTF2(KLogErrCommandReply, err);

   734 	if (err != KErrNone)

   735 		{

   736 		ERR_PRINTF2(KLogErrCommandReply, err);

   737 		SetError(err);

   738 		}

   739 	else

   740 		{

   741 		//Get the window's Size and Displaymode

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

   743 			{

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

   745 			}

   746 		expectedSize=win->Size();

   747 		expectedDisplyMd=win->DisplayMode();

   748 

   749 		TRect retrndWinInf=retrndWindowPostn();

   750 		TSize retrndSize=retrndWinInf.Size();

   751 		TInt retrndDisplyM=retrndDisplyMd();

   752 

   753 		if (retrndSize!=expectedSize)

   754 			{

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

   756 			SetBlockResult(EFail);

   757 			}

   758 		if (retrndDisplyM!=expectedDisplyMd)

   759 			{

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

   761 			SetBlockResult(EFail);

   762 			}

   763 		}

   764 	ResetIpcArg();

   765 	}

   766 

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

   768 	{

   769 	TInt expecteValue;

   770 	TInt actual;

   771 

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

   773 		{

   774 		ERR_PRINTF2(KLogErrMissingPara, &KFldExpected());

   775 		SetBlockResult(EFail);

   776 		}

   777 	else

   778 		{

   779 		actual=iAnim->CommandReply(aOpcode);

   780 		INFO_PRINTF2(KLogErrCommandReply, actual);

   781 		if (actual!=expecteValue)

   782 			{

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

   784 			SetBlockResult(EFail);

   785 			}

   786 		}

   787 	}

   788 

   789 //****************MAnimGeneralFunctionsWindowExtension verifying*******************************

   790 

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

   792 	{

   793 	RWsSession* ws;

   794 	TPtrC datWsName;

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

   796 		{

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

   798 		}

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

   800 	INFO_PRINTF2(KLogErrCommandReply, actualScreenNumb);

   801 	}

   802 

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

   804 	{

   805 	RWsSession* ws;

   806 	TPtrC datWsName;

   807 	TInt expectedVal;

   808 

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

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

   811 

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

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

   814 		{

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

   816 			{

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

   818 			}

   819 

   820 		expectedVal=ws->GetFocusScreen();

   821 		}

   822 

   823 	if (actual!=expectedVal)

   824 		{

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

   826 		SetBlockResult(EFail);

   827 		}

   828 	}

   829 

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

   831 	{

   832 	TInt screenNo;

   833 	TPtrC8 ptr;

   834 	TPtrC datWsName;

   835 

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

   837 		{

   838 		ERR_PRINTF2(KLogMissingParameter, &KFldScreenNumb());

   839 		SetBlockResult(EFail);

   840 		}

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

   842 	TPckgBuf<TInt> screenNoPck(screenNo);

   843 	iIpcArgs.Set(1, &screenNoPck);

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

   845 	INFO_PRINTF2(KLogErrCommandReply, actual);

   846 

   847 	ResetIpcArg();

   848 	}

   849 

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

   851 	{

   852 	TPtrC8 ptr;

   853 	TInt screenNo;

   854 	TPtrC datWsName;

   855 	RWsSession* ws;

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

   857 		{

   858 		ERR_PRINTF2(KLogErrMissingPara, &KFldScreenNumb());

   859 		SetBlockResult(EFail);

   860 		}

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

   862 	TPckgBuf<TInt> screenNoPck(screenNo);

   863 	iIpcArgs.Set(1, &screenNoPck);

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

   865 	INFO_PRINTF2(KLogErrCommandReply, actual);

   866 

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

   868 		{

   869 		ERR_PRINTF2(KLogErrMissingPara, &KFldWs());

   870 		SetBlockResult(EFail);

   871 		}

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

   873 	TInt expectedVal=ws->NumWindowGroups();

   874 

   875 	if (actual!=expectedVal)

   876 		{

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

   878 		SetBlockResult(EFail);

   879 		}

   880 	ResetIpcArg();

   881 	}

   882 

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

   884 	{

   885 	TInt screenNo;

   886 	TPtrC8 ptr;

   887 	TPtrC datWingrpName;

   888 	TInt retrnPck;

   889 	TInt expectedGrpInfo;

   890 	RWindowGroup* wingrp;

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

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

   893 		{

   894 		ERR_PRINTF2(KLogErrMissingPara, &KFldWingrp());

   895 		SetBlockResult(EFail);

   896 		}

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

   898 

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

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

   901 		{

   902 		ERR_PRINTF2(KLogErrMissingPara, &KFldScreenNumb());

   903 		SetBlockResult(EFail);

   904 		}

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

   906 	TPckgBuf<TInt> screenNoPck(screenNo);

   907 	iIpcArgs.Set(1, &screenNoPck);

   908 

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

   910 	TInt fullOrdiPostion;

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

   912 		{

   913 		fullOrdiPostion=wingrp->FullOrdinalPosition();

   914 		}

   915 	TPckgBuf<TInt> fullOrdiPostionPck(fullOrdiPostion);

   916 	iIpcArgs.Set(2, &fullOrdiPostionPck);

   917 

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

   919 	TPckgBuf<TInt> retrnWinGrpInfo;

   920 	iIpcArgs.Set(3, &retrnWinGrpInfo);

   921 

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

   923 	INFO_PRINTF2(KLogErrCommandReply, actual);

   924 	TBool expectedVal;

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

   926 		{

   927 		ERR_PRINTF2(KLogMissingParameter, &KFldExpected);

   928 		SetBlockResult(EFail);

   929 		}

   930 	if (actual!=expectedVal)

   931 		{

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

   933 		SetBlockResult(EFail);

   934 		}

   935 	if (actual!=EFalse)

   936 		{

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

   938 

   939 		expectedGrpInfo=wingrp->WindowGroupId();

   940 		if (retrnPck!=expectedGrpInfo)

   941 			{

   942 			ERR_PRINTF3(

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

   944 			expectedGrpInfo, retrnPck);

   945 			SetBlockResult(EFail);

   946 			}

   947 		}

   948 	ResetIpcArg();

   949 	}

   950 

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

   952 	{

   953 	TBuf<32> getWindowName;

   954 	TBool expectedVal;

   955 	TInt screenNo;

   956 	TInt fullOrdiPostion;

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

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

   959 		{

   960 		ERR_PRINTF2(KLogErrMissingPara, &KFldScreenNumb);

   961 		SetBlockResult(EFail);

   962 		}

   963 	TPtrC8 ptr;

   964 	TPckgBuf<TInt> screenNoPck(screenNo);

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

   966 	iIpcArgs.Set(1, &screenNoPck);

   967 

   968 	TPtrC datWingrpName;

   969 	RWindowGroup* wingrp;

   970 	//Get window group object

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

   972 		{

   973 		ERR_PRINTF2(KLogErrMissingPara, &KFldWingrp());

   974 		SetBlockResult(EFail);

   975 		}

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

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

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

   979 		{

   980 		fullOrdiPostion=wingrp->FullOrdinalPosition();

   981 		}

   982 

   983 	TPckgBuf<TInt> fullOrdiPostionPck(fullOrdiPostion);

   984 	iIpcArgs.Set(2, &fullOrdiPostionPck);

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

   986 	TBuf<32> retrnWindowName;

   987 	iIpcArgs.Set(3, &retrnWindowName);

   988 

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

   990 	INFO_PRINTF2(KLogErrCommandReply, actual);

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

   992 		{

   993 		ERR_PRINTF2(KLogMissingParameter, &KFldExpected);

   994 		SetBlockResult(EFail);

   995 		}

   996 	if (actual!=expectedVal)

   997 		{

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

   999 		SetBlockResult(EFail);

  1000 		}

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

  1002 	if (actual)

  1003 		{

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

  1005 		if (result!=KErrNone)

  1006 			{

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

  1008 			SetError(result);

  1009 			}

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

  1011 		if (getWindowName!=retrnWindowName)

  1012 			{

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

  1014 			SetBlockResult(EFail);

  1015 			}

  1016 		}

  1017 	ResetIpcArg();

  1018 	}

  1019 

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

  1021 	{

  1022 	TInt expectedVal;

  1023 	TPtrC8 ptr;

  1024 	TInt wingrpid;

  1025 	TInt newOrdinPrio;

  1026 	TInt newOrdinaPostn;

  1027 	TPtrC datWingrpName;

  1028 	RWindowGroup* wingrp;

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

  1030 		{

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

  1032 		}

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

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

  1035 		{

  1036 		wingrpid=wingrp->WindowGroupId();

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

  1038 		}

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

  1040 	TPckgBuf<TInt> wingrpidPck(wingrpid);

  1041 	iIpcArgs.Set(1, &wingrpidPck);

  1042 

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

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

  1045 		{

  1046 		newOrdinaPostn = wingrp->OrdinalPosition();

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

  1048 		}

  1049 	TPckgBuf<TInt> newOrdinaPostnPck(newOrdinaPostn);

  1050 	iIpcArgs.Set(2, &newOrdinaPostnPck);

  1051 

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

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

  1054 		{

  1055 		newOrdinPrio = wingrp->OrdinalPriority();

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

  1057 		}

  1058 	TPckgBuf<TInt> newOrdinPrioPck(newOrdinPrio);

  1059 	iIpcArgs.Set(3, &newOrdinPrioPck);

  1060 

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

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

  1063 		{

  1064 		ERR_PRINTF2(KLogMissingParameter, &KFldExpected);

  1065 		SetBlockResult(EFail);

  1066 		}

  1067 

  1068 	if (err!=expectedVal)

  1069 		{

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

  1071 		SetBlockResult(EFail);

  1072 		}

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

  1074 	if (err!=KErrNotFound)

  1075 		{

  1076 		TInt retrnOrdinPostn=wingrp->OrdinalPosition();

  1077 		TInt retrnOrdinPrio=wingrp->OrdinalPriority();

  1078 

  1079 		if (retrnOrdinPostn!=newOrdinaPostn)

  1080 			{

  1081 			ERR_PRINTF3(

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

  1083 			newOrdinaPostn, retrnOrdinPostn);

  1084 			SetBlockResult(EFail);

  1085 			}

  1086 

  1087 		if (retrnOrdinPrio!=newOrdinPrio)

  1088 			{

  1089 			ERR_PRINTF3(

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

  1091 			newOrdinPrio, retrnOrdinPrio);

  1092 			SetBlockResult(EFail);

  1093 			}

  1094 		}

  1095 	ResetIpcArg();

  1096 	}

  1097 

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

  1099 	{

  1100 	TInt screenNub;

  1101 	TBool expectedVal;

  1102 	TInt sendFullOrdinPstn;

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

  1104 		{

  1105 		ERR_PRINTF2(KLogErrMissingPara, &KFldScreenNumb);

  1106 		}

  1107 	TPtrC8 ptr;

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

  1109 	TPckgBuf<TInt> screenNubPck(screenNub);

  1110 	iIpcArgs.Set(1, &screenNubPck);

  1111 

  1112 	TPtrC datWingrpName;

  1113 	RWindowGroup* wingrp;

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

  1115 		{

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

  1117 		}

  1118 

  1119 	//Get animation window's FullOrdinalPosition as arg(IPC slot 2)

  1120 

  1121 	sendFullOrdinPstn = wingrp->FullOrdinalPosition();

  1122 	INFO_PRINTF2(_L("RWindowTreeNode::FullOrdinalPosition	= %d"), sendFullOrdinPstn);

  1123 	TPckgBuf<TInt> sendFullOrdinPstnPck(sendFullOrdinPstn);

  1124 	iIpcArgs.Set(2, &sendFullOrdinPstnPck);

  1125 

  1126 	//Check the CommandReply return value

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

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

  1129 		{

  1130 		ERR_PRINTF2(KLogMissingParameter, &KFldExpected);

  1131 		SetBlockResult(EFail);

  1132 		}

  1133 

  1134 	if (err!=expectedVal)