1 // Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Multi pointer and Z-coordinate test code

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20  @test

    21  @internalComponent - Internal Symbian test code 

    22 */

    23 

    24 #ifndef __INIPARSER_H__

    25 #define __INIPARSER_H__

    26 #endif // __INIPARSER_H__

    27 

    28 #include "PARSEINIDATA.H"

    29 #include "tmultiptrevent.h"

    30 #include <e32cmn.h>

    31 #include <hal.h>

    32 

    33 //#define FAILLOG 1			// Uncomment this code to get detailed log

    34 #define TESTMULTIPOINTER 1	// Comment this line to get detailed log without testing

    35 

    36 _LIT(KMultiPtrPluginDll, "multiptrclick.dll");

    37 

    38 const TInt KErrDescSize = 128;

    39 const TInt KMaxQueueSize = 32;	// Queue size of wserv. In any test we cannot test more than MaxQueueSize events. 

    40 

    41 LOCAL_C void DestroyAnim(TAny* aAnim)

    42 	{

    43 	(static_cast<RMultiPointerAnim*>(aAnim))->Destroy();

    44 	}

    45 

    46 

    47 //CTMultiPtrEventBuffer

    48 CTMultiPtrEventBuffer::CTMultiPtrEventBuffer(RWsSession *aWs, CTMultiPtrEventTest *aTest, CTMultiPtrEventClient* aClient) 

    49 	: CTEvent(aWs), iTest(aTest), iClient(aClient)

    50 	{

    51 	}

    52 

    53 void CTMultiPtrEventBuffer::ConstructL()

    54 	{

    55 	CTEventBase::Construct();

    56 	iEventBuffer.SetLengthL(EEventBufferSize);

    57 	iMovePtsBuffer.SetLengthL(EMovePtsBuffer);

    58 	}

    59 

    60 void CTMultiPtrEventBuffer::AddExpectedEvent(TWsEvent &aEvent)

    61 	{

    62 	iEventBuffer.Add(&aEvent);

    63 	}

    64 

    65 void CTMultiPtrEventBuffer::AddExpectedMovePtEvent(TPoint &aMovePt)

    66 	{

    67 	iMovePtsBuffer.Add(&aMovePt);

    68 	}

    69 

    70 TInt CTMultiPtrEventBuffer::EventsRemaining()

    71 	{

    72 	return iEventBuffer.Count();

    73 	}

    74 

    75 void CTMultiPtrEventBuffer::GetMoveBufferAndCompareL()

    76 	{

    77 	TBuf8<EMovePtsBuffer*sizeof(TPoint)> buf;

    78 	iClient->ParentWin()->BaseWin()->RetrievePointerMoveBuffer(buf);

    79 	

    80 	TUint bufferSize = buf.Length();

    81 	TUint numLoop = bufferSize/sizeof(TPoint);

    82 	

    83 	if (iMovePtsBuffer.Count() != numLoop)

    84 		{

    85 #if defined(FAILLOG)

    86 		TLogMessageText logText;

    87 		_LIT(KPointerNumber, "Actual number of move/drag buffer points from Wserv = %d Expected number of move/drag buffer points = %d ");

    88 		logText.Format(KPointerNumber, numLoop, iMovePtsBuffer.Count());

    89 		iTest->LOG_MESSAGE(logText);

    90 #endif

    91 		TestL(EFalse);

    92 		}

    93 	

    94 	TPoint wsPoint;

    95 	TPoint expPoint;

    96 	TUint8* BasePtr = const_cast<TUint8*>(buf.Ptr());

    97 	for (TUint count = 0; count < numLoop; count++)

    98 		{

    99 		wsPoint = *(reinterpret_cast<TPoint*>(BasePtr));

   100 		iMovePtsBuffer.Remove(&expPoint);

   101 		if (wsPoint != expPoint)

   102 			{

   103 #if defined(FAILLOG)

   104 			TLogMessageText logText;

   105 			_LIT(KMoveBufferPoint, "Actual move/drag buffer point from Wserv = ([%d], [%d]) Expected move/drag buffer point = ([%d], [%d])");

   106 			logText.Format(KMoveBufferPoint, wsPoint.iX, wsPoint.iY, expPoint.iX, expPoint.iY);

   107 			iTest->LOG_MESSAGE(logText);

   108 #endif

   109 			TestL(EFalse);

   110 			}

   111 		BasePtr = BasePtr + sizeof(TPoint);

   112 		}

   113 	}

   114 

   115 

   116 #define TESTXL(expr1, oper, expr2, event, expected) \

   117     TestL(expr1 oper expr2, expr1, expr2, #oper, #expr1 ## #oper ## #expr2, \

   118             event, expected, __FILE__, __LINE__);

   119 

   120 // Main function which gets the event, checks with the event in buffer

   121 // Then calls function NextSetOfEventsL for running other tests of a particualar test case

   122 void CTMultiPtrEventBuffer::doRunL()

   123 	{

   124 	// Get the event from wserv

   125 	TWsEvent wsEvent;

   126 	iWs->GetEvent(wsEvent);

   127 

   128 	TWsEvent expectedEvent;

   129 	TInt wsType=wsEvent.Type();

   130 	if (wsEvent.Type()==EEventNull)

   131 		{

   132 		TESTXL(wsEvent.Handle(), ==, 0, &wsEvent, NULL);

   133 		goto End;

   134 		}

   135 	// This code is for running successive anim test code 

   136 	if (wsEvent.Type()==EEventPointer && wsEvent.Pointer()->iType==TPointerEvent::ESwitchOn)

   137 		goto End;

   138 	// if this is called accidentally

   139 	if (iEventBuffer.Count()==0 && wsType==EEventFocusGained)

   140 		goto End;

   141 

   142 	iEventBuffer.Remove(&expectedEvent);

   143 	iEventCount++;

   144 

   145 	if (wsEvent.Type() == EEventPointerBufferReady)

   146 		{

   147 		GetMoveBufferAndCompareL();

   148 #if defined(FAILLOG)

   149 		TLogMessageText logText;

   150 		_LIT(KEventHandle, "Actual Window Handle from Wserv = %d Expected Window Handle = %d ");

   151 		logText.Format(KEventHandle, wsEvent.Handle(), expectedEvent.Handle());

   152 		iTest->LOG_MESSAGE(logText);

   153 #endif

   154 #if defined(TESTMULTIPOINTER)

   155 		TESTXL(wsEvent.Handle(), ==, expectedEvent.Handle(), &wsEvent, &expectedEvent);

   156 #endif

   157 		goto End;

   158 		}

   159 

   160 	// Test wsEvent and expected event have same handle, position and type.

   161 #if defined(FAILLOG)

   162 	{

   163 	TLogMessageText logText;

   164 	_LIT(KEventCountCheck, "Checking event number = %d");

   165 	logText.Format(KEventCountCheck, iEventCount);

   166 	iTest->LOG_MESSAGE(logText);

   167 	_LIT(KEventType, "Actual Event type from Wserv = %d Expected Event Type = %d ");

   168 	logText.Format(KEventType, wsEvent.Type(), expectedEvent.Type());

   169 	iTest->LOG_MESSAGE(logText);

   170 	}

   171 #endif

   172 

   173 #if defined(TESTMULTIPOINTER)

   174 	TESTXL(wsEvent.Type(), ==, expectedEvent.Type(), &wsEvent, &expectedEvent);

   175 #endif

   176 	// Test pointer number for Enter/Exit events

   177 	if (wsType == EEventPointerEnter || wsType == EEventPointerExit)

   178 		{

   179 #if defined(FAILLOG)

   180 		TLogMessageText logText;

   181 		_LIT(KPointerNumber, "Actual PointerNumber for Enter/Exit event from Wserv = %d Expected PointerNumber for Enter/Exit event = %d ");

   182 		logText.Format(KPointerNumber, *wsEvent.Int(), *expectedEvent.Int());

   183 		iTest->LOG_MESSAGE(logText);

   184 #endif

   185 #if defined(TESTMULTIPOINTER)

   186 		TESTXL(*wsEvent.Int(), ==, *expectedEvent.Int(), &wsEvent, &expectedEvent);

   187 #endif

   188 		}

   189 

   190 	// Test only if it is a Pointer event

   191 	if (wsType==EEventPointer)

   192 		{

   193 		TAdvancedPointerEvent* expectedPointerEvent=expectedEvent.Pointer();

   194 		TAdvancedPointerEvent* actualPointerEvent=wsEvent.Pointer();

   195 #if defined(FAILLOG)

   196 		TLogMessageText logText;

   197 		_LIT(KEventHandle, "Actual Window Handle from Wserv = %d Expected Window Handle = %d ");

   198 		logText.Format(KEventHandle, wsEvent.Handle(), expectedEvent.Handle());

   199 		iTest->LOG_MESSAGE(logText);

   200 #endif

   201 #if defined(TESTMULTIPOINTER)

   202 		TESTXL(wsEvent.Handle(), ==, expectedEvent.Handle(), &wsEvent, &expectedEvent);

   203 #endif

   204 #if defined(FAILLOG)

   205 		_LIT(KPointerType, "Actual PointerType from Wserv = %d Expected PointerType = %d ");

   206 		logText.Format(KPointerType, actualPointerEvent->iType, expectedPointerEvent->iType);

   207 		iTest->LOG_MESSAGE(logText);

   208 #endif

   209 #if defined(TESTMULTIPOINTER)

   210 		TESTXL(actualPointerEvent->iType, ==, expectedPointerEvent->iType, &wsEvent, &expectedEvent);

   211 #endif

   212 #if defined(FAILLOG)

   213 		_LIT(KPointerPosition, "Actual PointerPosition from Wserv = (%d, %d) Expected PointerPosition = (%d, %d) ");

   214 		logText.Format(KPointerPosition, actualPointerEvent->iPosition.iX, actualPointerEvent->iPosition.iY, expectedPointerEvent->iPosition.iX, expectedPointerEvent->iPosition.iY);

   215 		iTest->LOG_MESSAGE(logText);

   216 #endif

   217 #if defined(TESTMULTIPOINTER)		

   218 		TESTXL(actualPointerEvent->iPosition, ==, expectedPointerEvent->iPosition, &wsEvent, &expectedEvent);

   219 #endif		

   220 #if defined(FAILLOG)

   221 		_LIT(KPointerNumber, "Actual PointerNumber from Wserv = %d Expected PointerNumber = %d ");

   222 		logText.Format(KPointerNumber, actualPointerEvent->PointerNumber(), expectedPointerEvent->PointerNumber());

   223 		iTest->LOG_MESSAGE(logText);

   224 #endif

   225 #if defined(TESTMULTIPOINTER)		

   226 		TESTXL(actualPointerEvent->PointerNumber(), ==, expectedPointerEvent->PointerNumber(), &wsEvent, &expectedEvent);

   227 #endif

   228 #if defined(FAILLOG)

   229 		_LIT(KPointerProximity, "Actual PointerProximity from Wserv = %d Expected PointerProximity = %d ");

   230 		logText.Format(KPointerProximity, actualPointerEvent->Proximity(), expectedPointerEvent->Proximity());

   231 		iTest->LOG_MESSAGE(logText);

   232 #endif

   233 #if defined(TESTMULTIPOINTER)		

   234 		TESTXL(actualPointerEvent->Proximity(), ==, expectedPointerEvent->Proximity(), &wsEvent, &expectedEvent);

   235 #endif		

   236 #if defined(FAILLOG)

   237 		_LIT(KPointerPressure, "Actual PointerPressure from Wserv = %d Expected PointerPressure = %d ");

   238 		logText.Format(KPointerPressure, actualPointerEvent->Pressure(), expectedPointerEvent->Pressure());

   239 		iTest->LOG_MESSAGE(logText);

   240 #endif

   241 #if defined(TESTMULTIPOINTER)		

   242 		TESTXL(actualPointerEvent->Pressure(), ==, expectedPointerEvent->Pressure(), &wsEvent, &expectedEvent);

   243 #endif

   244 #if defined(FAILLOG)

   245 		_LIT(KPointerModifier, "Actual Modifier value from Wserv = 0x%08x Expected Modfier value = 0x%08x ");

   246 		logText.Format(KPointerModifier, actualPointerEvent->iModifiers, expectedPointerEvent->iModifiers);

   247 		iTest->LOG_MESSAGE(logText);

   248 #endif

   249 #if defined(TESTMULTIPOINTER)		

   250 		TESTXL((actualPointerEvent->iModifiers&expectedPointerEvent->iModifiers), ==, expectedPointerEvent->iModifiers, &wsEvent, &expectedEvent);

   251 #endif		

   252 		}

   253 End:

   254 	// Call NextSetOfEvents() only for primary client

   255 	if (iEventBuffer.Count()==0 && !iClient->IsSecondaryClient())	

   256 		{

   257 		iTest->NextSetOfEventsL();		// Cannot Leave

   258 		}

   259 	

   260 	// If this is for secondary client and active scheduler(nested loop) has started, this code stops that scheduler

   261 	if (iEventBuffer.Count()==0 && iClient->IsSecondaryClient() && iNestedLoopStarted)

   262 		{

   263 		iNestedLoopStarted = EFalse;

   264 		CActiveScheduler::Stop();

   265 		}

   266 	}

   267 

   268 void CTMultiPtrEventBuffer::TestL(TInt aTest)

   269 	{

   270 	if (!aTest)

   271 		{

   272 		iTest->Failed();

   273 		User::Leave(ETestFailed);

   274 		}

   275 	}

   276 

   277 static void DumpEvent(const char *aName, const TWsEvent *aEvent)

   278     {

   279     // aEvent may be NULL - if it isn't NULL, we print it's data.

   280     if (aEvent)

   281         {

   282         RDebug::Printf("%s:", aName);

   283         RDebug::Printf("handle = %u", aEvent->Handle());

   284         RDebug::Printf("type() = %d", aEvent->Type());

   285         if (aEvent->Type() == EEventPointer)

   286             {

   287             TAdvancedPointerEvent *pointer = aEvent->Pointer();

   288             RDebug::Printf("pointer type = %d, position = (%d, %d)", 

   289                     pointer->iType, pointer->iPosition.iX, pointer->iPosition.iY);

   290             RDebug::Printf("PointerNumber() = %d, proximity=%d, pressure=%d", 

   291                     pointer->PointerNumber(), pointer->Proximity(), pointer->Pressure());

   292             RDebug::Printf("modifiers = 0x%08x", pointer->iModifiers);

   293             }

   294         else

   295             {

   296             RDebug::Printf("Not a pointer event, event type");

   297             }

   298         }

   299     else

   300         {

   301         // aEvent is NULL, just let us know it is. 

   302         RDebug::Printf("%s: is NULL which means not applicapable");

   303         }

   304     }

   305 

   306 void CTMultiPtrEventBuffer::TestL(TInt aTest, TInt aVal1, TInt aVal2, const char *aOper, const char *aTestStr, 

   307         const TWsEvent *aEvent, const TWsEvent *aExpected, const char *aFile, TUint aLine)

   308     {

   309     if (!aTest)

   310         {

   311         RDebug::Printf("Expression %d %s %d [%s] (=%d) failed [call from %s:%d]", aVal1, aOper, aVal2, aTestStr, aTest, aFile, aLine);

   312         DumpEvent("actual", aEvent);

   313         DumpEvent("expected", aExpected);

   314         iTest->Failed();

   315         User::Leave(ETestFailed);

   316         }

   317     }

   318 

   319 

   320 void CTMultiPtrEventBuffer::TestL(TInt aTest, TPoint aVal1, TPoint aVal2, const char *oper, const char *aTestStr, 

   321         const TWsEvent *aEvent, const TWsEvent *aExpected, const char *aFile, TUint aLine)

   322     {

   323     if (!aTest)

   324         {

   325         RDebug::Printf("Expression (%d, %d) %s (%d, %d) [%s] (=%d) failed [call from %s:%d]", 

   326                 aVal1.iX, aVal1.iY, oper, aVal2.iX, aVal2.iY, aTestStr, aTest, aFile, aLine);

   327         DumpEvent("actual", aEvent);

   328         DumpEvent("expected", aExpected);

   329         iTest->Failed();

   330         User::Leave(ETestFailed);

   331         }

   332     }

   333 

   334 //CTMultiPtrEventClient

   335 CTMultiPtrEventClient::CTMultiPtrEventClient(CTMultiPtrEventTest *aTest, TBool aSecondaryClient) 

   336 	: iTest(aTest), iSecondaryClient(aSecondaryClient)

   337 	{

   338 	}

   339 

   340 CTMultiPtrEventClient::~CTMultiPtrEventClient()

   341 	{

   342 	if (iWinAutoFocus1 || iWinAutoFocus2 || iGroupWinAutoFocus2 || iGroupWinAutoFocus1)

   343 		{

   344 		DeleteGroupBlankWin();

   345 		}

   346 	delete iChildWin;

   347 	delete iParentWin;

   348 	}

   349 

   350 void CTMultiPtrEventClient::ConstructL()

   351 	{

   352 	CTClient::ConstructL();

   353 	

   354 	// Create a group window and assign it iGroup

   355 	iGroup = new(ELeave) CTWindowGroup(this);

   356 	iGroup->ConstructL();

   357 	

   358 	iParentWinSize = iScreen->SizeInPixels();

   359 	iParentWinPos = TPoint();

   360 	

   361 	// Change the parent window size and position for secondary client

   362 	if (iSecondaryClient)

   363 		{

   364 		iParentWinSize.iWidth /= 2; 

   365 		iParentWinPos.iX = iParentWinSize.iWidth;

   366 		}

   367 	

   368 	// Create window/s for this client so that events can come to this client

   369 	iParentWin=new(ELeave) CTBlankWindow();

   370 	iParentWin->ConstructL(*iGroup);

   371 	iParentWin->SetExt(iParentWinPos, iParentWinSize);

   372 	iParentWin->SetColor(KRgbRed);

   373 	if (iTest->TestBase()->iState != 12)

   374 		{

   375 		iParentWin->BaseWin()->EnableAdvancedPointers();

   376 		}

   377 	iParentWin->Activate();

   378 	

   379 	// Don't create child window for secodary client

   380 	if (!iSecondaryClient)

   381 		{

   382 		iChildWinSize = TSize(iParentWinSize.iWidth/2, iParentWinSize.iHeight);

   383 		iChildWinPos = TPoint(iParentWinSize.iWidth/2,0);

   384 		

   385 		iChildWin=new(ELeave) CTBlankWindow();

   386 		iChildWin->ConstructL(*iGroup);

   387 		iChildWin->SetExt(iChildWinPos, iChildWinSize);

   388 		iChildWin->SetColor(KRgbRed);

   389 		iChildWin->BaseWin()->EnableAdvancedPointers();

   390 		iChildWin->Activate();

   391 		}

   392 	}

   393 

   394 void CTMultiPtrEventClient::CalculatePtrPosAndSet3Ddata(TWsEvent& aEvent, TPointerEvent::TType aType, TPoint aPos, TUint aModifiers, TInt aZ, TUint8 aPointerNumber, TUint aHandle)

   395 	{

   396 	// If in future you need to change parent position then put this in corresponding if statements

   397 	aEvent.Pointer()->iParentPosition = aPos;

   398 	

   399 	// This is for Auto foreground test

   400 	if (iTest->TestBase()->iState == 11)

   401 		{

   402 		if (TRect(iWinPosAutoFocus1, iWinSizeAutoFocus1).Contains(aPos))

   403 			{

   404 			aPos -= iWinPosAutoFocus1;

   405 			aEvent.SetHandle((TUint)iWinAutoFocus1);

   406 			}

   407 		else if (TRect(iWinPosAutoFocus2, iWinSizeAutoFocus2).Contains(aPos))

   408 			{

   409 			aPos -= iWinPosAutoFocus2;

   410 			aEvent.SetHandle((TUint)iWinAutoFocus2);

   411 			}

   412 		goto SETOTHERDATA;

   413 		}

   414 

   415 	// Here simulated pointer position is w.r.t to 0,0

   416 	// Actual pointer position is w.r.t windowPosition

   417 	if (iSecondaryClient)

   418 		{

   419 		if (TRect(iParentWinPos, TSize(iParentWinSize.iWidth, iParentWinSize.iHeight)).Contains(aPos))

   420 			{

   421 			// Since for secondary client parent window is at half of screensize

   422 			aPos -= iParentWinPos;

   423 			aEvent.SetHandle((aHandle == 0) ? (TUint)iParentWin : aHandle);

   424 			}

   425 		}

   426 	else

   427 		{

   428 		// If sent position is on blankWindow then

   429 		if (TRect(iParentWinPos, TSize(iParentWinSize.iWidth/2, iParentWinSize.iHeight)).Contains(aPos))

   430 			{

   431 			aEvent.SetHandle((aHandle == 0) ? (TUint)iParentWin : aHandle);

   432 			}

   433 		else // else the pointer event occured on child window

   434 			{

   435 			// if aPos < 0 then position has been generated in test code and should not be adjusted

   436 			if (aPos.iX >= 0)

   437 				{

   438 				aPos -= iChildWinPos;	

   439 				}

   440 			aEvent.SetHandle((aHandle == 0) ? (TUint)iChildWin : aHandle);

   441 			}

   442 		}

   443 	

   444 SETOTHERDATA:	

   445 	aEvent.Pointer()->iType = aType;

   446 	aEvent.Pointer()->iPosition = aPos;

   447 	if(iExpectNonAdvancedPointerEvents)

   448 		{

   449 		aEvent.Pointer()->iModifiers = aModifiers;		

   450 		}

   451 	else

   452 		{

   453 		aEvent.Pointer()->iModifiers = aModifiers|EModifierAdvancedPointerEvent;

   454 		aEvent.SetPointerNumber(aPointerNumber);

   455 		aEvent.SetPointerZ(aZ);

   456 		}

   457 	}

   458 

   459 void CTMultiPtrEventClient::AddExpectedPointerEvent(TPointerEvent::TType aType, TPoint aPos, TUint8 aPointerNumber, TUint aHandle)

   460 	{

   461 	AddExpectedPointerEvent(aType, aPos, 0, 0, aPointerNumber, aHandle);

   462 	}

   463 

   464 void CTMultiPtrEventClient::AddExpectedPointerEvent(TPointerEvent::TType aType, TPoint aPos, TInt aZ, TUint aModifier, TUint8 aPointerNumber, TUint aHandle)

   465 	{

   466 	TWsEvent ptrEvent;

   467 	ptrEvent.SetType(EEventPointer);

   468 	if (aType != TPointerEvent::ESwitchOn)

   469 		{

   470 		CalculatePtrPosAndSet3Ddata(ptrEvent, aType, aPos, aModifier, aZ, aPointerNumber, aHandle);

   471 		}

   472 	static_cast<CTMultiPtrEventBuffer*>(iEventHandler)->AddExpectedEvent(ptrEvent);

   473 	}

   474 

   475 void CTMultiPtrEventClient::AddExpectedWsEvent(TEventCode aType, TInt aPointerNumber, TUint aHandle)

   476 	{

   477 	TWsEvent ptrEvent;

   478 	ptrEvent.SetType(aType);

   479 	if (aType == EEventPointerEnter || aType == EEventPointerExit)

   480 		{

   481 		*ptrEvent.Int() = aPointerNumber;

   482 		}

   483 	if (aType == EEventPointerBufferReady)

   484 		{

   485 		ptrEvent.SetHandle(aHandle);

   486 		}

   487 	static_cast<CTMultiPtrEventBuffer*>(iEventHandler)->AddExpectedEvent(ptrEvent);

   488 	}

   489 

   490 void CTMultiPtrEventClient::AddExpectedMovePoint(TPoint aPos)

   491 	{

   492 	static_cast<CTMultiPtrEventBuffer*>(iEventHandler)->AddExpectedMovePtEvent(aPos);

   493 	}

   494 

   495 // Create and store CTMultiPtrEventBuffer in iEventHandler

   496 void CTMultiPtrEventClient::ConstructEventHandlerL()

   497 	{

   498 	CTMultiPtrEventBuffer* eventBufferAndHandler = new(ELeave) CTMultiPtrEventBuffer(&iWs, iTest, this);

   499 	eventBufferAndHandler->ConstructL();

   500 	iEventHandler = eventBufferAndHandler;

   501 	}

   502 

   503 // Create groupwindow and blank window for AutoFocus tests

   504 void CTMultiPtrEventClient::ConstructGroupBlankWinL()

   505 	{

   506 	iWinPosAutoFocus1 = TPoint(10,10);

   507 	iWinSizeAutoFocus1 = TSize(40,40);

   508 	

   509 	iWinPosAutoFocus2 = TPoint(50,50);

   510 	iWinSizeAutoFocus2 = TSize(80,80);

   511 	

   512 	iGroupWinAutoFocus1 = new(ELeave) CTWindowGroup(this);

   513 	iGroupWinAutoFocus1->ConstructL();

   514 	iGroupWinAutoFocus1->GroupWin()->AutoForeground(ETrue);

   515 	iGroupWinAutoFocus1->GroupWin()->EnableFocusChangeEvents();

   516 	

   517 	iGroupWinAutoFocus2 = new(ELeave) CTWindowGroup(this);

   518 	iGroupWinAutoFocus2->ConstructL();

   519 	iGroupWinAutoFocus2->GroupWin()->AutoForeground(ETrue);

   520 	iGroupWinAutoFocus2->GroupWin()->EnableFocusChangeEvents();

   521 	

   522 	iWinAutoFocus1=new(ELeave) CTBlankWindow();

   523 	iWinAutoFocus1->ConstructL(*iGroupWinAutoFocus1);

   524 	iWinAutoFocus1->SetExt(iWinPosAutoFocus1, iWinSizeAutoFocus1);

   525 	iWinAutoFocus1->SetColor(KRgbDarkYellow);

   526 	iWinAutoFocus1->BaseWin()->EnableAdvancedPointers();

   527 	iWinAutoFocus1->Activate();

   528 	

   529 	iWinAutoFocus2=new(ELeave) CTBlankWindow();

   530 	iWinAutoFocus2->ConstructL(*iGroupWinAutoFocus2);

   531 	iWinAutoFocus2->SetExt(iWinPosAutoFocus2, iWinSizeAutoFocus2);

   532 	iWinAutoFocus2->SetColor(KRgbDarkCyan);

   533 	iWinAutoFocus2->BaseWin()->EnableAdvancedPointers();

   534 	iWinAutoFocus2->Activate();

   535 	}

   536 

   537 void CTMultiPtrEventClient::DeleteGroupBlankWin()

   538 	{

   539 	delete iWinAutoFocus2;

   540 	iWinAutoFocus2 = NULL;

   541 	delete iGroupWinAutoFocus2;

   542 	iGroupWinAutoFocus2 = NULL;

   543 	delete iWinAutoFocus1;

   544 	iWinAutoFocus1 = NULL;

   545 	delete iGroupWinAutoFocus1;

   546 	iGroupWinAutoFocus1 = NULL;

   547 	}

   548 

   549 TBool CTMultiPtrEventClient::CheckOrdinalPosition(TInt aAutoFocusWin)

   550 	{

   551 	if (aAutoFocusWin == 1)

   552 		{

   553 		return iWinAutoFocus1->BaseWin()->OrdinalPosition() == 0;

   554 		}

   555 	else

   556 		{

   557 		return iWinAutoFocus2->BaseWin()->OrdinalPosition() == 0;

   558 		}

   559 	}

   560 

   561 //CTMultiPtrEventTest

   562 CTMultiPtrEventTest::CTMultiPtrEventTest(CTestStep* aStep)

   563 	: CTWsGraphicsBase(aStep)

   564 	{

   565 	}

   566 

   567 CTMultiPtrEventTest::~CTMultiPtrEventTest()

   568 	{

   569 	((CTMultiPtrEventTestStep*)iStep)->CloseTMSGraphicsStep();

   570 	delete iMultiPtrEventClient;

   571 	DestroyAnimDllAndAnim();	

   572 	if (iPtrPluginLoaded)

   573 		{

   574 		iClick.Unload();

   575 		}

   576 	iClick.Close();

   577 	if (iHeap)

   578 		{

   579 		iHeap->Close();

   580 		iChunk.Close();

   581 		}

   582 	DeleteGroupWin();

   583 	}

   584 

   585 void CTMultiPtrEventTest::ConstructL()

   586 	{

   587 	// Here check if the HAL configuration are correct if not then finish the test case

   588 	TInt ret = HAL::Get(HALData::EPointerMaxPointers, iMaxDevPointers);

   589 	if (ret != KErrNone || iMaxDevPointers < 2 || iMaxDevPointers > 8)

   590 		{

   591 		TLogMessageText logText1;

   592 		_LIT(KWrongHALConfig, "HAL configuration are incorrect. \n");

   593 		logText1.Append(KWrongHALConfig);

   594 		LOG_MESSAGE(logText1);

   595 		TEST(EFalse);

   596 		User::Leave(ret);

   597 		}

   598 	

   599 	// Get the data by using HAL api

   600   	User::LeaveIfError(HAL::Get(HALData::EPointerMaxPointers,iMaxDevPointers));

   601   	User::LeaveIfError(HAL::Get(HALData::EPointerNumberOfPointers,iMaxUiPointers));

   602   	User::LeaveIfError(HAL::Get(HALData::EPointer3DMaxPressure, iMaxPressure));

   603   	User::LeaveIfError(HAL::Get(HALData::EPointer3DPressureStep, iPressureStep));

   604   	User::LeaveIfError(HAL::Get(HALData::EPointer3DMaxProximity, iMaxProximity));

   605   	User::LeaveIfError(HAL::Get(HALData::EPointer3DProximityStep, iProximityStep));

   606 	

   607     _LIT(KWsIniFile, "z:\\system\\data\\wsini.ini");

   608     CIniData* iniData = CIniData::NewL(KWsIniFile, ' ');

   609     _LIT( KWsiniYShifting, "YSHIFTING");

   610     iniData->FindVar(KWsiniYShifting, iYOffset);

   611     delete iniData;

   612 	TheClient->iScreen->SetAppScreenMode(0);

   613 	TheClient->iScreen->SetScreenMode(0);

   614 	iPhysicalScreenSize = TheClient->iScreen->SizeInPixels();

   615 	

   616 	TheGc->Activate(*BaseWin->Win());

   617 	TheGc->SetBrushColor(TRgb::Gray16(12));

   618 	TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   619 	TheGc->SetPenStyle(CGraphicsContext::ENullPen);

   620 	TheGc->DrawRect(TRect(BaseWin->Win()->Size()));

   621 	TheGc->Deactivate();

   622 	

   623 	TheGc->Activate(*TestWin->Win());

   624 	TheGc->SetBrushColor(TRgb::Gray16(4));

   625 	TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   626 	TheGc->SetPenStyle(CGraphicsContext::ENullPen);

   627 	TheGc->DrawRect(TRect(TestWin->Win()->Size()));

   628 	TheGc->Deactivate();

   629 	

   630 	TheClient->iWs.Flush();

   631 	}

   632 

   633 // Create raw event setting type, X, Y, Z and pointernumber for rawevent

   634 // use UserSvr for simulating the event

   635 void CTMultiPtrEventTest::SimulatePointerEvent(TRawEvent::TType aType, TInt aX, TInt aY, TUint8 aPointerNumber)

   636 	{

   637 	TRawEvent rawEvent;

   638 	rawEvent.Set(aType, aX, aY+iYOffset, aPointerNumber);

   639 	UserSvr::AddEvent(rawEvent);

   640 	}

   641 

   642 void CTMultiPtrEventTest::SimulatePointerEvent(TRawEvent::TType aType, TInt aX, TInt aY, TInt aZ, TUint8 aPointerNumber)

   643 	{

   644 	TRawEvent rawEvent;

   645 	rawEvent.Set(aType, aX, aY+iYOffset, aZ, aPointerNumber);

   646 	UserSvr::AddEvent(rawEvent);

   647 	}

   648 

   649 // Simulate multipointer down and up event

   650 void CTMultiPtrEventTest::SimulatePointerDownUp(TInt aX, TInt aY, TInt aZ, TUint8 aPointerNumber)

   651 	{

   652 	SimulatePointerEvent(TRawEvent::EButton1Down, aX, aY, aZ, aPointerNumber);

   653 	SimulatePointerEvent(TRawEvent::EButton1Up, aX, aY, aZ, aPointerNumber);

   654 	}

   655 

   656 void CTMultiPtrEventTest::AddExpectedKey(TInt aEventCode, TInt aScanCode, TInt aCode/*=0*/, TInt aRepeats/*=0*/, TUint aModifiers/*=0*/)

   657 	{

   658 	TPckgBuf<TWsEvent> evtPkg;

   659 	TWsEvent& event=evtPkg();

   660 	if (aEventCode==EEventKey && aCode==0)

   661 		aCode=aScanCode;

   662 	event.SetType(aEventCode);

   663 	event.SetHandle((TUint)iMultiPtrEventClient->iGroup);

   664 	event.Key()->iCode=aCode;

   665 	event.Key()->iScanCode=aScanCode;

   666 	event.Key()->iModifiers=aModifiers;

   667 	event.Key()->iRepeats=aRepeats;

   668 	iMultiPtrEventClient->EventBuffer()->AddExpectedEvent(event);

   669 	}

   670 

   671 void CTMultiPtrEventTest::AddExpectedKeyDownUp(TInt aScanCode, TInt aCode/*=0*/, TInt aRepeats/*=0*/, TUint aModifiers/*=0*/)

   672 	{

   673 	__ASSERT_DEBUG(aScanCode<'a' || aScanCode>'z',AutoPanic(EAutoPanicScanCapital));

   674 	AddExpectedKey(EEventKeyDown,aScanCode,0,aRepeats,aModifiers);

   675 	AddExpectedKey(EEventKey,aScanCode,aCode,aRepeats,aModifiers);

   676 	AddExpectedKey(EEventKeyUp,aScanCode,0,aRepeats,aModifiers);

   677 	}

   678 

   679 void CTMultiPtrEventTest::AddExpectedPointerEvent(TPointerEvent::TType aType, TPoint aPos, TUint8 aPointerNumber, TUint aHandle)

   680 	{

   681 	AddExpectedPointerEvent(aType, aPos, 0, 0, aPointerNumber, aHandle);

   682 	}

   683 

   684 void CTMultiPtrEventTest::AddExpectedPointerEvent(TPointerEvent::TType aType, TPoint aPos, TInt aZ, TUint aModifier, TUint8 aPointerNumber, TUint aHandle, TBool aSecondaryClient)

   685 	{

   686 	if (aSecondaryClient)

   687 		{

   688 		iSecMultiPtrEventClient->AddExpectedPointerEvent(aType, aPos, aZ, aModifier, aPointerNumber, aHandle);

   689 		}

   690 	else

   691 		{

   692 		iMultiPtrEventClient->AddExpectedPointerEvent(aType, aPos, aZ, aModifier, aPointerNumber, aHandle);

   693 		}

   694 	}

   695 

   696 void CTMultiPtrEventTest::SetExpectNonAdvancedPointerEvents(TBool aSecondaryClient)

   697 	{

   698 	if (aSecondaryClient)

   699 		{

   700 		iSecMultiPtrEventClient->SetExpectNonAdvancedPointerEvents();

   701 		}

   702 	else

   703 		{

   704 		iMultiPtrEventClient->SetExpectNonAdvancedPointerEvents();

   705 		}

   706 	}

   707 

   708 void CTMultiPtrEventTest::ClearExpectNonAdvancedPointerEvents(TBool aSecondaryClient)

   709 	{

   710 	if (aSecondaryClient)

   711 		{

   712 		iSecMultiPtrEventClient->ClearExpectNonAdvancedPointerEvents();

   713 		}

   714 	else

   715 		{

   716 		iMultiPtrEventClient->ClearExpectNonAdvancedPointerEvents();

   717 		}

   718 	}

   719 

   720 void CTMultiPtrEventTest::AddExpectedPointerDownUp(TPoint aPos, TInt aZ, TUint8 aPointerNumber)

   721 	{

   722 	AddExpectedPointerEvent(TPointerEvent::EButton1Down, aPos, aZ, 0, aPointerNumber);

   723 	AddExpectedPointerEvent(TPointerEvent::EButton1Up, aPos, aZ, 0, aPointerNumber);

   724 	}

   725 

   726 void CTMultiPtrEventTest::AddExpectedWsEvent(TEventCode aType, TBool aSecondaryClient, TInt aPointerNumber, TUint aHandle)

   727 	{

   728 	if (aSecondaryClient)

   729 		{

   730 		iSecMultiPtrEventClient->AddExpectedWsEvent(aType);

   731 		}

   732 	else

   733 		{

   734 		iMultiPtrEventClient->AddExpectedWsEvent(aType, aPointerNumber, aHandle);

   735 		}

   736 	}

   737 

   738 void CTMultiPtrEventTest::TestDragForMultiPointer(TPoint aPtrPos, TInt aPrValue, TUint8 aPointerNumber)

   739 	{

   740 	SimulatePointerEvent(TRawEvent::EButton1Down, aPtrPos.iX, aPtrPos.iY, aPrValue, aPointerNumber);

   741 	SimulatePointerEvent(TRawEvent::EPointerMove, aPtrPos.iX+2, aPtrPos.iY+1, aPrValue, aPointerNumber);

   742 	SimulatePointerEvent(TRawEvent::EButton1Up, aPtrPos.iX+2, aPtrPos.iY+1, 0, aPointerNumber);

   743 	AddExpectedPointerEvent(TPointerEvent::EButton1Down, aPtrPos, aPrValue, 0, aPointerNumber);

   744 	aPtrPos.iX += 2; aPtrPos.iY += 1;

   745 	AddExpectedPointerEvent(TPointerEvent::EDrag, aPtrPos, aPrValue, 0, aPointerNumber);

   746 	AddExpectedPointerEvent(TPointerEvent::EButton1Up, aPtrPos, 0, 0, aPointerNumber);

   747 	}

   748 

   749 void CTMultiPtrEventTest::SimulateAndAddLoneUpEvents(TInt aNumSimulation, TInt aNumAddition, TPoint aPos)

   750 	{

   751 	for (TInt count = 0; count < aNumSimulation; count++)

   752 		{

   753 		SimulatePointerEvent(TRawEvent::EButton1Up, aPos.iX, aPos.iY, 0, 0);

   754 		}

   755 	for (TInt count = 0; count < aNumAddition; count++)

   756 		{

   757 		AddExpectedPointerEvent(TPointerEvent::EButton1Up, aPos, 0, 0, 0);

   758 		}

   759 	}

   760 

   761 void CTMultiPtrEventTest::TestFilteringForMultiPointer(TBool aFiltering)

   762 	{

   763 	TPoint ptrPos;

   764 	TInt ptrNum;

   765 	TInt xInc = iPhysicalScreenSize.iWidth/iMaxDevPointers;

   766 	TInt yInc = iPhysicalScreenSize.iHeight/iMaxDevPointers;

   767 	

   768 	for (ptrNum = 0; ptrNum < iMaxDevPointers/2; ptrNum++)

   769 		{

   770 		SimulatePointerEvent(TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, 0, ptrNum);

   771 		SimulatePointerEvent(TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, 0, ptrNum);

   772 		if(!aFiltering)

   773 			{

   774 			AddExpectedPointerEvent(TPointerEvent::EMove, ptrPos, ptrNum);

   775 			}

   776 		AddExpectedPointerEvent(TPointerEvent::EButton1Down, ptrPos, ptrNum);

   777 		ptrPos.iX += xInc/2;

   778 		ptrPos.iY += yInc/2;

   779 		}

   780 	

   781 	ptrPos.SetXY(0,0);

   782 	TPoint interPt = ptrPos;

   783 	for (ptrNum = 0; ptrNum < iMaxDevPointers/2; ptrNum++)

   784 		{

   785 		SimulatePointerEvent(TRawEvent::EPointerMove, interPt.iX+2, interPt.iY+1, 0, ptrNum);

   786 		SimulatePointerEvent(TRawEvent::EPointerMove, interPt.iX+4, interPt.iY+2, 0, ptrNum);

   787 		SimulatePointerEvent(TRawEvent::EPointerMove, interPt.iX+6, interPt.iY+3, 0, ptrNum);

   788 		if(!aFiltering)

   789 			{

   790 			interPt.iX += 6; interPt.iY += 3;

   791 			AddExpectedPointerEvent(TPointerEvent::EDrag, interPt, ptrNum);

   792 			}

   793 		ptrPos.iX += xInc/2;

   794 		ptrPos.iY += yInc/2;

   795 		interPt = ptrPos; 

   796 		}

   797 

   798 	ptrPos.SetXY(0,0);

   799 	interPt = ptrPos;

   800 	for (ptrNum = 0; ptrNum < iMaxDevPointers/2; ptrNum++)

   801 		{

   802 		interPt.iX += 6;

   803 		interPt.iY += 3;

   804 		SimulatePointerEvent(TRawEvent::EButton1Up, interPt.iX, interPt.iY, 0, ptrNum);

   805 		AddExpectedPointerEvent(TPointerEvent::EButton1Up, interPt, ptrNum);

   806 		ptrPos.iX += xInc/2;

   807 		ptrPos.iY += yInc/2;

   808 		interPt = ptrPos; 

   809 		}

   810 	}

   811 

   812 void CTMultiPtrEventTest::TestGrabbingForMultiPointer(TBool aGrabbing)

   813 	{

   814 	TPoint ptrPos;

   815 	TInt ptrNum;

   816 	TInt xInc = iPhysicalScreenSize.iWidth/iMaxDevPointers;

   817 	TInt yInc = iPhysicalScreenSize.iHeight/iMaxDevPointers;

   818 	

   819 	for (ptrNum = 0; ptrNum < iMaxDevPointers; ptrNum++)

   820 		{

   821 		SimulatePointerEvent(TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, 0, ptrNum);

   822 		AddExpectedPointerEvent(TPointerEvent::EButton1Down, ptrPos, ptrNum);

   823 		ptrPos.iX += xInc/3;	// Ensure all Button1Down events are on iParentWin

   824 		ptrPos.iY += yInc/3;

   825 		}

   826 	

   827 	ptrPos.SetXY(0,0);

   828 	ptrPos.iX += iPhysicalScreenSize.iWidth/2;		// Ensure all Drag and Button1Up events are on iChildWin

   829 	ptrPos.iY += iPhysicalScreenSize.iHeight/2;

   830 	for (ptrNum = 0; ptrNum < iMaxDevPointers; ptrNum++)

   831 		{

   832 		SimulatePointerEvent(TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, 0, ptrNum);

   833 		if(aGrabbing)

   834 			{

   835 			// CalculatePtrPosAndSet3Ddata will subtract iChildWinPos from ptrPos if pointer event occured on child window. Thus we add iChildWinPos here.

   836 			AddExpectedPointerEvent(TPointerEvent::EDrag, ptrPos+iMultiPtrEventClient->ChildWin()->Position(), ptrNum, (TUint)iMultiPtrEventClient->ParentWin());	

   837 			}

   838 		else

   839 			{

   840 			AddExpectedPointerEvent(TPointerEvent::EDrag, ptrPos, ptrNum);

   841 			}

   842 		ptrPos.iX += xInc/3;

   843 		ptrPos.iY += yInc/3; 

   844 		}

   845 

   846 	ptrPos.SetXY(0,0);

   847 	ptrPos.iX += iPhysicalScreenSize.iWidth/2;

   848 	ptrPos.iY += iPhysicalScreenSize.iHeight/2;

   849 	for (ptrNum = 0; ptrNum < iMaxDevPointers; ptrNum++)

   850 		{

   851 		SimulatePointerEvent(TRawEvent::EButton1Up, ptrPos.iX, ptrPos.iY, 0, ptrNum);

   852 		if(aGrabbing)

   853 			{

   854 			AddExpectedPointerEvent(TPointerEvent::EButton1Up, ptrPos+iMultiPtrEventClient->ChildWin()->Position(), ptrNum, (TUint)iMultiPtrEventClient->ParentWin());

   855 			}

   856 		else

   857 			{

   858 			AddExpectedPointerEvent(TPointerEvent::EButton1Up, ptrPos, ptrNum);

   859 			}

   860 		ptrPos.iX += xInc/3;

   861 		ptrPos.iY += yInc/3;

   862 		}

   863 	}

   864 

   865 void CTMultiPtrEventTest::TestCapturingForMultiPointer(TBool aAllWinGroups)

   866 	{

   867 	TPoint ptrPos;

   868 	TInt ptrNum = 0;

   869 	TInt xInc = iPhysicalScreenSize.iWidth/iMaxDevPointers;

   870 	TInt yInc = iPhysicalScreenSize.iHeight/iMaxDevPointers;

   871 	

   872 	// These are some typical values which are used only for testing purposes.

   873 	// 20mm to screen

   874 	// 50mm to screen

   875 	// 4N of pressure

   876 	// 2N of pressure

   877 	SetThresholdValues(-20,-50,4000,2000);

   878 	

   879 	iMultiPtrEventClient->ChildWin()->BaseWin()->PointerFilter(EPointerMoveEvents, 0);

   880 	

   881 	if(!aAllWinGroups)

   882 		{

   883 		for (ptrNum = 0; ptrNum < iMaxDevPointers/2; ptrNum++)

   884 			{

   885 			SimulatePointerEvent(TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, -30, ptrNum);

   886 			AddExpectedPointerEvent(TPointerEvent::EMove, ptrPos-iMultiPtrEventClient->ChildWin()->Position(), -30, 0, ptrNum, (TInt)iMultiPtrEventClient->ChildWin());

   887 			SimulatePointerEvent(TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, -10, ptrNum);

   888 			AddExpectedPointerEvent(TPointerEvent::EEnterCloseProximity, ptrPos-iMultiPtrEventClient->ChildWin()->Position(), -10, 0, ptrNum, (TInt)iMultiPtrEventClient->ChildWin());

   889 			SimulatePointerEvent(TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, 0, ptrNum);

   890 			AddExpectedPointerEvent(TPointerEvent::EButton1Down, ptrPos-iMultiPtrEventClient->ChildWin()->Position(), 0, 0, ptrNum, (TInt)iMultiPtrEventClient->ChildWin());

   891 			SimulatePointerEvent(TRawEvent::EPointerMove, ptrPos.iX+=2, ptrPos.iY+=2, 5000, ptrNum);

   892 			AddExpectedPointerEvent(TPointerEvent::EEnterHighPressure, ptrPos-iMultiPtrEventClient->ChildWin()->Position(), 5000, 0, ptrNum, (TInt)iMultiPtrEventClient->ChildWin());

   893 			SimulatePointerEvent(TRawEvent::EPointerMove, ptrPos.iX-=2, ptrPos.iY-=2, 1000, ptrNum);

   894 			AddExpectedPointerEvent(TPointerEvent::EExitHighPressure, ptrPos-iMultiPtrEventClient->ChildWin()->Position(), 1000, 0, ptrNum, (TInt)iMultiPtrEventClient->ChildWin());

   895 			SimulatePointerEvent(TRawEvent::EPointerMove, ptrPos.iX+=2, ptrPos.iY+=2, 1000, ptrNum);

   896 			AddExpectedPointerEvent(TPointerEvent::EDrag, ptrPos-iMultiPtrEventClient->ChildWin()->Position(), 1000, 0, ptrNum, (TInt)iMultiPtrEventClient->ChildWin());

   897 			SimulatePointerEvent(TRawEvent::EButton1Up, ptrPos.iX, ptrPos.iY, 0, ptrNum);

   898 			AddExpectedPointerEvent(TPointerEvent::EButton1Up, ptrPos-iMultiPtrEventClient->ChildWin()->Position(), 0, 0, ptrNum, (TInt)iMultiPtrEventClient->ChildWin());

   899 			SimulatePointerEvent(TRawEvent::EPointerMove, ptrPos.iX-=2, ptrPos.iY-=2, -60, ptrNum);

   900 			AddExpectedPointerEvent(TPointerEvent::EExitCloseProximity, ptrPos-iMultiPtrEventClient->ChildWin()->Position(), -60, 0, ptrNum, (TInt)iMultiPtrEventClient->ChildWin());

   901 			ptrPos.iX += xInc/3;	// Ensure all Pointer events are on iParentWin

   902 			ptrPos.iY += yInc/3;

   903 			}		

   904 		}

   905 	else

   906 		{

   907 		ptrPos.iX = iPhysicalScreenSize.iWidth/2 + xInc/3;

   908 		ptrPos.iY = 0;

   909 		 		

   910 		for (ptrNum = 0; ptrNum < iMaxDevPointers/2; ptrNum++)

   911 			{

   912 			SimulatePointerEvent(TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, -10, ptrNum);

   913 			AddExpectedPointerEvent(TPointerEvent::EEnterCloseProximity, TPoint(ptrPos.iX+iPhysicalScreenSize.iWidth/2, ptrPos.iY), -10, 0, ptrNum, (TInt)iWinForCapturing);

   914 			SimulatePointerEvent(TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, 0, ptrNum);

   915 			AddExpectedPointerEvent(TPointerEvent::EButton1Down, TPoint(ptrPos.iX+iPhysicalScreenSize.iWidth/2, ptrPos.iY), 0, 0, ptrNum, (TInt)iWinForCapturing);		

   916 			SimulatePointerEvent(TRawEvent::EPointerMove, ptrPos.iX+=2, ptrPos.iY+=2, 5000, ptrNum);

   917 			AddExpectedPointerEvent(TPointerEvent::EEnterHighPressure, TPoint(ptrPos.iX+iPhysicalScreenSize.iWidth/2, ptrPos.iY), 5000, 0, ptrNum, (TInt)iWinForCapturing);			

   918 			SimulatePointerEvent(TRawEvent::EPointerMove, ptrPos.iX-=2, ptrPos.iY-=2, 1000, ptrNum);

   919 			AddExpectedPointerEvent(TPointerEvent::EExitHighPressure, TPoint(ptrPos.iX+iPhysicalScreenSize.iWidth/2, ptrPos.iY), 1000, 0, ptrNum, (TInt)iWinForCapturing);

   920 			SimulatePointerEvent(TRawEvent::EPointerMove, ptrPos.iX+=2, ptrPos.iY+=2, 1000, ptrNum);

   921 			AddExpectedPointerEvent(TPointerEvent::EDrag, TPoint(ptrPos.iX+iPhysicalScreenSize.iWidth/2, ptrPos.iY), 1000, 0, ptrNum, (TInt)iWinForCapturing);

   922 			SimulatePointerEvent(TRawEvent::EButton1Up, ptrPos.iX, ptrPos.iY, 0, ptrNum);

   923 			AddExpectedPointerEvent(TPointerEvent::EButton1Up, TPoint(ptrPos.iX+iPhysicalScreenSize.iWidth/2, ptrPos.iY), 0, 0, ptrNum, (TInt)iWinForCapturing);

   924 			SimulatePointerEvent(TRawEvent::EPointer3DOutOfRange, 0, 0, 0, ptrNum);

   925 			AddExpectedPointerEvent(TPointerEvent::EOutOfRange, TPoint(ptrPos.iX+iPhysicalScreenSize.iWidth/2, ptrPos.iY), 0, 0, ptrNum, (TInt)iWinForCapturing);

   926 			ptrPos.iX += xInc/3;	

   927 			ptrPos.iY += yInc/3;

   928 			}

   929 		}

   930 	}

   931 

   932 void CTMultiPtrEventTest::SetAutoFlush()

   933 	{

   934 	iTheClientFlush = TheClient->iWs.SetAutoFlush(ETrue);

   935 	iClientFlush = iMultiPtrEventClient->iWs.SetAutoFlush(ETrue);

   936 	}

   937 

   938 void CTMultiPtrEventTest::ResetFlushStopAS()

   939 	{

   940 	if (iActiveSchedulerStarted)

   941 		{

   942 		iActiveSchedulerStarted = EFalse;

   943 		CActiveScheduler::Stop();

   944 		}

   945 	TheClient->iWs.SetAutoFlush(iTheClientFlush);

   946 	iMultiPtrEventClient->iWs.SetAutoFlush(iClientFlush);

   947 	}

   948 

   949 // Common function for all test cases

   950 void CTMultiPtrEventTest::RunTestsL()

   951 	{

   952 	// Create CTMultiPtrEventClient for each test case and call NextSetOfEventsL()

   953 	iMultiPtrEventClient = new(ELeave) CTMultiPtrEventClient(this);

   954 	iMultiPtrEventClient->SetScreenNumber(iTest->iScreenNumber);

   955 	iMultiPtrEventClient->ConstructL();

   956 	

   957 	iEventSet=0;

   958 

   959 	// Create secondary client for test case number 3

   960 	if (iTest->iState == 3)

   961 		{

   962 		iSecMultiPtrEventClient = new(ELeave) CTMultiPtrEventClient(this, 1);

   963 		iSecMultiPtrEventClient->SetScreenNumber(iTest->iScreenNumber);

   964 		iSecMultiPtrEventClient->ConstructL(); 

   965 		}

   966 	

   967 	TRAPD(err, NextSetOfEventsL());

   968 	if (err != KErrNone)

   969 		{

   970 		iFailed = ETrue;

   971 		}

   972 

   973 	// Start nested activescheduler if it is not failed for the first attempt

   974 	if (!iFailed)

   975 		{

   976 		iActiveSchedulerStarted = ETrue;

   977 		CActiveScheduler::Start();

   978 		}

   979 

   980 	//

   981 	TInt eventsRem = iMultiPtrEventClient->EventBuffer()->EventsRemaining();

   982 	if (eventsRem > 0)

   983 		{

   984 		iFailed=ETrue;

   985 		}

   986 

   987 	// Delete secondary client for test case number 3

   988 	if (iTest->iState == 3)

   989 		{

   990 		delete iSecMultiPtrEventClient;

   991 		iSecMultiPtrEventClient = NULL;

   992 		}

   993 	

   994 	delete iMultiPtrEventClient;

   995 	iMultiPtrEventClient = NULL;

   996 	}

   997 

   998 // Common function for all tests

   999 // Important point to remember is that this function should not leave when running tests

  1000 void CTMultiPtrEventTest::NextSetOfEventsL()

  1001 	{

  1002 	// For each test case calls its respective tests

  1003 		

  1004 	((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

  1005 	switch (iTest->iState)

  1006 		{

  1007 	case 0:

  1008 /**

  1009 @SYMTestCaseID			GRAPHICS-WSERV-ADVANCEDPOINTER-0036

  1010 */

  1011 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0036"));

  1012 		MultiPointerEvents();

  1013 		break;

  1014 	case 1:

  1015 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0014"));

  1016 		PurgingMultiPointerEvents();

  1017 		break;

  1018 	case 2:

  1019 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0013"));

  1020 		MultiPointerEventsForAnimsL();

  1021 		break;

  1022 	case 3:

  1023 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0011"));

  1024 		GetRemainingEventsFromSecondaryClient();	// Does nothing for first time

  1025 		MultiClientMultiPointerEvents();

  1026 		break;

  1027 	case 4:

  1028 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0027"));

  1029 		MultiPointerEventsForPointerClickL();

  1030 		break;

  1031 	case 5:

  1032 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0028"));

  1033 		MultiPointerEventsInDiffScreenModes();

  1034 		break;

  1035 	case 6:

  1036 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0025"));

  1037 		FilteringMultiPointerEvents();

  1038 		break;

  1039 	case 7:

  1040 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0021"));

  1041 		GrabbingMultiPointerEvents();

  1042 		break;

  1043 	case 8:

  1044 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0031"));

  1045 		VirtualKeyBoardForMultiplePointers();

  1046 		break;

  1047 	case 9:

  1048 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0032"));

  1049 		DoubleClickForMultiplePointers();

  1050 		break;

  1051 	case 10:

  1052 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0015"));

  1053 		MultiPointerOutOfRangeEvents();

  1054 		break;

  1055 	case 11:

  1056 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0026"));

  1057 		AutoForeGroundForMultiplePointersL();

  1058 		break;

  1059 	case 12:

  1060 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0029"));

  1061 		EmulationRulesForMultiplePointers();

  1062 		break;

  1063 	case 13:

  1064 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0034"));

  1065 		CloseProximityAndHighPressureEventsL();

  1066 		break;

  1067 	case 14:

  1068 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0017"));

  1069 		OutOfBoundValueTesting();

  1070 		break;	

  1071 	case 15:

  1072 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0019"));

  1073 		CapturingMultiPointerEvents();

  1074 		break;

  1075 	case 16:

  1076 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0035"));

  1077 		NegativeTestsForProximityPressureEventsL();

  1078 		break;

  1079 	case 17:

  1080 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-ADVANCEDPOINTER-0034"));

  1081 		PointerRepeatEventForMultiplePointers();

  1082 		break;

  1083 	// Any new test case should be added here.

  1084 	// because some of the above tests use testcase number for certain checks

  1085 	default:

  1086 		((CTMultiPtrEventTestStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

  1087 		AutoPanic(EAutoPanicWrongTest);

  1088 		}

  1089 	((CTMultiPtrEventTestStep*)iStep)->RecordTestResultL();

  1090 	}

  1091 

  1092 /**

  1093 @SYMTestCaseID			GRAPHICS-WSERV-ADVANCEDPOINTER-0033

  1094 @SYMPREQ				PREQ1226

  1095 @SYMREQ					REQ9677

  1096 @SYMTestPriority		High

  1097 @SYMTestCaseDesc		To check Wserv sends Pointer Repeat Events for all pointers. 

  1098 @SYMTestStatus			Implemented

  1099 

  1100 @SYMTestActions			Simulate events being passed to the client by implementing each discrete test 

  1101 						over 4 seperate test cases. 

  1102 						In the first test case simulate EButton1Down and add event to a TWsEvent buffer. 

  1103 						In the second test case call RequestPointerRepeatEvent on the base window passing 

  1104 						in a time interval,	a rectangle (the 'hitbox') and pointer number. 

  1105 						Add EButtonRepeat to TWsEvent buffer.  

  1106 						In the third test case simulate EPointerMove event within the hitbox, then simulate 

  1107 						an elapsed period of time longer that specified interval. Add only a EButtonRepeat

  1108 						to TWsEvent buffer.

  1109 						In the final test case simulate EButton1Up and add event to TWsEvent buffer.

  1110 						

  1111 						Repeat steps for the second discrete test, however, in the third test case simulate 

  1112 						EPointerMove event outside the hitbox. In addition add EDrag to TWsEvent buffer 

  1113 						instead of EButtonRepeat. 

  1114 						

  1115 						A third discrete test will be executed over two test cases and will test

  1116 						CancelPointerRepeatEventRequest API.

  1117 						

  1118 @SYMTestExpectedResults The received events must match the events added to the buffer except where EPointerMove

  1119  						events should be filtered out. In addition, EButtonRepeat will be generated by wserv

  1120  						after calling RequestPointerRepeatEvent and time interval specified has elapsed.

  1121 						

  1122 */

  1123 void CTMultiPtrEventTest::PointerRepeatEventForMultiplePointers()

  1124 	{

  1125 	// Test PointerRepeatEvent for Multiple Pointers 

  1126 	TLogMessageText logText;

  1127 	_LIT(KSet, "PointerRepeatEventForMultiplePointers SetOfEvents: %d of 10");

  1128 	logText.AppendFormat(KSet, iEventSet);

  1129 	LOG_MESSAGE(logText);

  1130 	

  1131 	if (!iEventSet)

  1132 		{

  1133 		SetAutoFlush();

  1134 		AddExpectedWsEvent(EEventFocusGained);