1 // Copyright (c) 2008-2009 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 		{

   138 		goto End;

   139 		}

   140 	

   141 	// if this is called accidentally

   142 	TInt count=iEventBuffer.Count();

   143 	if (count==0 && wsType==EEventFocusGained)

   144 		{

   145 		goto End;

   146 		}

   147 

   148 	iEventBuffer.Remove(&expectedEvent);

   149 

   150 	iEventCount++;

   151 	

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

   153 		{

   154 		GetMoveBufferAndCompareL();

   155 #if defined(FAILLOG)

   156 		TLogMessageText logText;

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

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

   159 		iTest->LOG_MESSAGE(logText);

   160 #endif

   161 #if defined(TESTMULTIPOINTER)		

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

   163 #endif

   164 		goto End;

   165 		}

   166 	

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

   168 #if defined(FAILLOG)	

   169 	TLogMessageText logText;

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

   171 	logText.Format(KEventCountCheck, iEventCount);

   172 	iTest->LOG_MESSAGE(logText);

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

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

   175 	iTest->LOG_MESSAGE(logText);

   176 #endif

   177 		

   178 #if defined(TESTMULTIPOINTER)

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

   180 #endif

   181 	// Test pointer number for Enter/Exit events

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

   183 		{

   184 #if defined(FAILLOG)

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

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

   187 		iTest->LOG_MESSAGE(logText);

   188 #endif

   189 #if defined(TESTMULTIPOINTER)		

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

   191 #endif

   192 		}

   193 		

   194     TAdvancedPointerEvent *expectedPointerEvent = expectedEvent.Pointer();

   195     TAdvancedPointerEvent *actualPointerEvent = wsEvent.Pointer();

   196 

   197     // Test only if it is a Pointer event  

   198 	if (wsType == EEventPointer)

   199 		{

   200 #if defined(FAILLOG)

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

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

   203 		iTest->LOG_MESSAGE(logText);

   204 #endif

   205 #if defined(TESTMULTIPOINTER)		

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

   207 #endif		

   208 #if defined(FAILLOG)

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

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

   211 		iTest->LOG_MESSAGE(logText);

   212 #endif

   213 #if defined(TESTMULTIPOINTER)

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

   215 #endif

   216 #if defined(FAILLOG)

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

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

   219 		iTest->LOG_MESSAGE(logText);

   220 #endif

   221 #if defined(TESTMULTIPOINTER)		

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

   223 #endif		

   224 #if defined(FAILLOG)

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

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

   227 		iTest->LOG_MESSAGE(logText);

   228 #endif

   229 #if defined(TESTMULTIPOINTER)		

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

   231 #endif

   232 #if defined(FAILLOG)

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

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

   235 		iTest->LOG_MESSAGE(logText);

   236 #endif

   237 #if defined(TESTMULTIPOINTER)		

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

   239 #endif		

   240 #if defined(FAILLOG)

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

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

   243 		iTest->LOG_MESSAGE(logText);

   244 #endif

   245 #if defined(TESTMULTIPOINTER)		

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

   247 #endif

   248 #if defined(FAILLOG)

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

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

   251 		iTest->LOG_MESSAGE(logText);

   252 #endif

   253 #if defined(TESTMULTIPOINTER)		

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

   255 #endif		

   256 		}

   257 End:

   258 	// Call NextSetOfEvents() only for primary client

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

   260 		{

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

   262 		}

   263 	

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

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

   266 		{

   267 		iNestedLoopStarted = EFalse;

   268 		CActiveScheduler::Stop();

   269 		}

   270 	}

   271 

   272 void CTMultiPtrEventBuffer::TestL(TInt aTest)

   273 	{

   274 	if (!aTest)

   275 		{

   276 		iTest->Failed();

   277 		User::Leave(ETestFailed);

   278 		}

   279 	}

   280 

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

   282     {

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

   284     if (aEvent)

   285         {

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

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

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

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

   290             {

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

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

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

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

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

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

   297             }

   298         else

   299             {

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

   301             }

   302         }

   303     else

   304         {

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

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

   307         }

   308     }

   309 

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

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

   312     {

   313     if (!aTest)

   314         {

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

   316         DumpEvent("actual", aEvent);

   317         DumpEvent("expected", aExpected);

   318         iTest->Failed();

   319         User::Leave(ETestFailed);

   320         }

   321     }

   322 

   323 

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

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

   326     {

   327     if (!aTest)

   328         {

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

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

   331         DumpEvent("actual", aEvent);

   332         DumpEvent("expected", aExpected);

   333         iTest->Failed();

   334         User::Leave(ETestFailed);

   335         }

   336     }

   337 

   338 //CTMultiPtrEventClient

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

   340 	: iTest(aTest), iSecondaryClient(aSecondaryClient)

   341 	{

   342 	}

   343 

   344 CTMultiPtrEventClient::~CTMultiPtrEventClient()

   345 	{

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

   347 		{

   348 		DeleteGroupBlankWin();

   349 		}

   350 	delete iChildWin;

   351 	delete iParentWin;

   352 	}

   353 

   354 void CTMultiPtrEventClient::ConstructL()

   355 	{

   356 	CTClient::ConstructL();

   357 	

   358 	// Create a group window and assign it iGroup

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

   360 	iGroup->ConstructL();

   361 	

   362 	iParentWinSize = iScreen->SizeInPixels();

   363 	iParentWinPos = TPoint();

   364 	

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

   366 	if (iSecondaryClient)

   367 		{

   368 		iParentWinSize.iWidth /= 2; 

   369 		iParentWinPos.iX = iParentWinSize.iWidth;

   370 		}

   371 	

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

   373 	iParentWin=new(ELeave) CTBlankWindow();

   374 	iParentWin->ConstructL(*iGroup);

   375 	iParentWin->SetExt(iParentWinPos, iParentWinSize);

   376 	iParentWin->SetColor(KRgbRed);

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

   378 		{

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

   380 		}

   381 	iParentWin->Activate();

   382 	

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

   384 	if (!iSecondaryClient)

   385 		{

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

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

   388 		

   389 		iChildWin=new(ELeave) CTBlankWindow();

   390 		iChildWin->ConstructL(*iGroup);

   391 		iChildWin->SetExt(iChildWinPos, iChildWinSize);

   392 		iChildWin->SetColor(KRgbRed);

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

   394 		iChildWin->Activate();

   395 		}

   396 	}

   397 

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

   399 	{

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

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

   402 	

   403 	// This is for Auto foreground test

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

   405 		{

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

   407 			{

   408 			aPos -= iWinPosAutoFocus1;

   409 			aEvent.SetHandle((TUint)iWinAutoFocus1);

   410 			}

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

   412 			{

   413 			aPos -= iWinPosAutoFocus2;

   414 			aEvent.SetHandle((TUint)iWinAutoFocus2);

   415 			}

   416 		goto SETOTHERDATA;

   417 		}

   418 

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

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

   421 	if (iSecondaryClient)

   422 		{

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

   424 			{

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

   426 			aPos -= iParentWinPos;

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

   428 			}

   429 		}

   430 	else

   431 		{

   432 		// If sent position is on blankWindow then

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

   434 			{

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

   436 			}

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

   438 			{

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

   440 			if (aPos.iX >= 0)

   441 				{

   442 				aPos -= iChildWinPos;	

   443 				}

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

   445 			}

   446 		}

   447 	

   448 SETOTHERDATA:	

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

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

   451 	if(iExpectNonAdvancedPointerEvents)

   452 		{

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

   454 		}

   455 	else

   456 		{

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

   458 		aEvent.SetPointerNumber(aPointerNumber);

   459 		aEvent.SetPointerZ(aZ);

   460 		}

   461 	}

   462 

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

   464 	{

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

   466 	}

   467 

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

   469 	{

   470 	TWsEvent ptrEvent;

   471 	ptrEvent.SetType(EEventPointer);

   472 	if (aType != TPointerEvent::ESwitchOn)

   473 		{

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

   475 		}

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

   477 	}

   478 

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

   480 	{

   481 	TWsEvent ptrEvent;

   482 	ptrEvent.SetType(aType);

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

   484 		{

   485 		*ptrEvent.Int() = aPointerNumber;

   486 		}

   487 	if (aType == EEventPointerBufferReady)

   488 		{

   489 		ptrEvent.SetHandle(aHandle);

   490 		}

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

   492 	}

   493 

   494 void CTMultiPtrEventClient::AddExpectedMovePoint(TPoint aPos)

   495 	{

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

   497 	}

   498 

   499 // Create and store CTMultiPtrEventBuffer in iEventHandler

   500 void CTMultiPtrEventClient::ConstructEventHandlerL()

   501 	{

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

   503 	eventBufferAndHandler->ConstructL();

   504 	iEventHandler = eventBufferAndHandler;

   505 	}

   506 

   507 // Create groupwindow and blank window for AutoFocus tests

   508 void CTMultiPtrEventClient::ConstructGroupBlankWinL()

   509 	{

   510 	iWinPosAutoFocus1 = TPoint(10,10);

   511 	iWinSizeAutoFocus1 = TSize(40,40);

   512 	

   513 	iWinPosAutoFocus2 = TPoint(50,50);

   514 	iWinSizeAutoFocus2 = TSize(80,80);

   515 	

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

   517 	iGroupWinAutoFocus1->ConstructL();

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

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

   520 	

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

   522 	iGroupWinAutoFocus2->ConstructL();

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

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

   525 	

   526 	iWinAutoFocus1=new(ELeave) CTBlankWindow();

   527 	iWinAutoFocus1->ConstructL(*iGroupWinAutoFocus1);

   528 	iWinAutoFocus1->SetExt(iWinPosAutoFocus1, iWinSizeAutoFocus1);

   529 	iWinAutoFocus1->SetColor(KRgbDarkYellow);

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

   531 	iWinAutoFocus1->Activate();

   532 	

   533 	iWinAutoFocus2=new(ELeave) CTBlankWindow();

   534 	iWinAutoFocus2->ConstructL(*iGroupWinAutoFocus2);

   535 	iWinAutoFocus2->SetExt(iWinPosAutoFocus2, iWinSizeAutoFocus2);

   536 	iWinAutoFocus2->SetColor(KRgbDarkCyan);

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

   538 	iWinAutoFocus2->Activate();

   539 	}

   540 

   541 void CTMultiPtrEventClient::DeleteGroupBlankWin()

   542 	{

   543 	delete iWinAutoFocus2;

   544 	iWinAutoFocus2 = NULL;

   545 	delete iGroupWinAutoFocus2;

   546 	iGroupWinAutoFocus2 = NULL;

   547 	delete iWinAutoFocus1;

   548 	iWinAutoFocus1 = NULL;

   549 	delete iGroupWinAutoFocus1;

   550 	iGroupWinAutoFocus1 = NULL;

   551 	}

   552 

   553 TBool CTMultiPtrEventClient::CheckOrdinalPosition(TInt aAutoFocusWin)

   554 	{

   555 	if (aAutoFocusWin == 1)

   556 		{

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

   558 		}

   559 	else

   560 		{

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

   562 		}

   563 	}

   564 

   565 //CTMultiPtrEventTest

   566 CTMultiPtrEventTest::CTMultiPtrEventTest(CTestStep* aStep)

   567 	: CTWsGraphicsBase(aStep)

   568 	{

   569 	}

   570 

   571 CTMultiPtrEventTest::~CTMultiPtrEventTest()

   572 	{

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

   574 	delete iMultiPtrEventClient;

   575 	DestroyAnimDllAndAnim();	

   576 	if (iPtrPluginLoaded)

   577 		{

   578 		iClick.Unload();

   579 		}

   580 	iClick.Close();

   581 	if (iHeap)

   582 		{

   583 		iHeap->Close();

   584 		iChunk.Close();

   585 		}

   586 	DeleteGroupWin();

   587 	}

   588 

   589 void CTMultiPtrEventTest::ConstructL()

   590 	{

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

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

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

   594 		{

   595 		TLogMessageText logText1;

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

   597 		logText1.Append(KWrongHALConfig);

   598 		LOG_MESSAGE(logText1);

   599 		TEST(EFalse);

   600 		User::Leave(ret);

   601 		}

   602 	

   603 	// Get the data by using HAL api

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

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

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

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

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

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

   610 	

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

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

   613     _LIT( KWsiniYShifting, "YSHIFTING");

   614     iniData->FindVar(KWsiniYShifting, iYOffset);

   615     delete iniData;

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

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

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

   619 	

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

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

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

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

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

   625 	TheGc->Deactivate();

   626 	

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

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

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

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

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

   632 	TheGc->Deactivate();

   633 	

   634 	TheClient->iWs.Flush();

   635 	}

   636 

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

   638 // use UserSvr for simulating the event

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

   640 	{

   641 	TRawEvent rawEvent;

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

   643 	UserSvr::AddEvent(rawEvent);

   644 	}

   645 

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

   647 	{

   648 	TRawEvent rawEvent;

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

   650 	UserSvr::AddEvent(rawEvent);

   651 	}

   652 

   653 // Simulate multipointer down and up event

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

   655 	{

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

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

   658 	}

   659 

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

   661 	{

   662 	TPckgBuf<TWsEvent> evtPkg;

   663 	TWsEvent& event=evtPkg();

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

   665 		aCode=aScanCode;

   666 	event.SetType(aEventCode);

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

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

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

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

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

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

   673 	}

   674 

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

   676 	{

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

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

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

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

   681 	}

   682 

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

   684 	{

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

   686 	}

   687 

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

   689 	{

   690 	if (aSecondaryClient)

   691 		{

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

   693 		}

   694 	else

   695 		{

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

   697 		}

   698 	}

   699 

   700 void CTMultiPtrEventTest::SetExpectNonAdvancedPointerEvents(TBool aSecondaryClient)

   701 	{

   702 	if (aSecondaryClient)

   703 		{

   704 		iSecMultiPtrEventClient->SetExpectNonAdvancedPointerEvents();

   705 		}

   706 	else

   707 		{

   708 		iMultiPtrEventClient->SetExpectNonAdvancedPointerEvents();

   709 		}

   710 	}

   711 

   712 void CTMultiPtrEventTest::ClearExpectNonAdvancedPointerEvents(TBool aSecondaryClient)

   713 	{

   714 	if (aSecondaryClient)

   715 		{

   716 		iSecMultiPtrEventClient->ClearExpectNonAdvancedPointerEvents();

   717 		}

   718 	else

   719 		{

   720 		iMultiPtrEventClient->ClearExpectNonAdvancedPointerEvents();

   721 		}

   722 	}

   723 

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

   725 	{

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

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

   728 	}

   729 

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

   731 	{

   732 	if (aSecondaryClient)

   733 		{

   734 		iSecMultiPtrEventClient->AddExpectedWsEvent(aType);

   735 		}

   736 	else

   737 		{

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

   739 		}

   740 	}

   741 

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

   743 	{

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

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

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

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

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

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

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

   751 	}

   752 

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

   754 	{

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

   756 		{

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

   758 		}

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

   760 		{

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

   762 		}

   763 	}

   764 

   765 void CTMultiPtrEventTest::TestFilteringForMultiPointer(TBool aFiltering)

   766 	{

   767 	TPoint ptrPos;

   768 	TInt ptrNum;

   769 	TInt xInc = iPhysicalScreenSize.iWidth/iMaxDevPointers;

   770 	TInt yInc = iPhysicalScreenSize.iHeight/iMaxDevPointers;

   771 	

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

   773 		{

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

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

   776 		if(!aFiltering)

   777 			{

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

   779 			}

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

   781 		ptrPos.iX += xInc/2;

   782 		ptrPos.iY += yInc/2;

   783 		}

   784 	

   785 	ptrPos.SetXY(0,0);

   786 	TPoint interPt = ptrPos;

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

   788 		{

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

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

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

   792 		if(!aFiltering)

   793 			{

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

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

   796 			}

   797 		ptrPos.iX += xInc/2;

   798 		ptrPos.iY += yInc/2;

   799 		interPt = ptrPos; 

   800 		}

   801 

   802 	ptrPos.SetXY(0,0);

   803 	interPt = ptrPos;

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

   805 		{

   806 		interPt.iX += 6;

   807 		interPt.iY += 3;

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

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

   810 		ptrPos.iX += xInc/2;

   811 		ptrPos.iY += yInc/2;

   812 		interPt = ptrPos; 

   813 		}

   814 	}

   815 

   816 void CTMultiPtrEventTest::TestGrabbingForMultiPointer(TBool aGrabbing)

   817 	{

   818 	TPoint ptrPos;

   819 	TInt ptrNum;

   820 	TInt xInc = iPhysicalScreenSize.iWidth/iMaxDevPointers;

   821 	TInt yInc = iPhysicalScreenSize.iHeight/iMaxDevPointers;

   822 	

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

   824 		{

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

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

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

   828 		ptrPos.iY += yInc/3;

   829 		}

   830 	

   831 	ptrPos.SetXY(0,0);

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

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

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

   835 		{

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

   837 		if(aGrabbing)

   838 			{

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

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

   841 			}

   842 		else

   843 			{

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

   845 			}

   846 		ptrPos.iX += xInc/3;

   847 		ptrPos.iY += yInc/3; 

   848 		}

   849 

   850 	ptrPos.SetXY(0,0);

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

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

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

   854 		{

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

   856 		if(aGrabbing)

   857 			{

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

   859 			}

   860 		else

   861 			{

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

   863 			}

   864 		ptrPos.iX += xInc/3;

   865 		ptrPos.iY += yInc/3;

   866 		}

   867 	}

   868 

   869 void CTMultiPtrEventTest::TestCapturingForMultiPointer(TBool aAllWinGroups)

   870 	{

   871 	TPoint ptrPos;

   872 	TInt ptrNum = 0;

   873 	TInt xInc = iPhysicalScreenSize.iWidth/iMaxDevPointers;

   874 	TInt yInc = iPhysicalScreenSize.iHeight/iMaxDevPointers;

   875 	

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

   877 	// 20mm to screen

   878 	// 50mm to screen

   879 	// 4N of pressure

   880 	// 2N of pressure

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

   882 	

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

   884 	

   885 	if(!aAllWinGroups)

   886 		{

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

   888 			{

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   906 			ptrPos.iY += yInc/3;

   907 			}		

   908 		}

   909 	else

   910 		{

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

   912 		ptrPos.iY = 0;

   913 		 		

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

   915 			{

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   930 			ptrPos.iX += xInc/3;	

   931 			ptrPos.iY += yInc/3;

   932 			}

   933 		}

   934 	}

   935 

   936 void CTMultiPtrEventTest::SetAutoFlush()

   937 	{

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

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

   940 	}

   941 

   942 void CTMultiPtrEventTest::ResetFlushStopAS()

   943 	{

   944 	if (iActiveSchedulerStarted)

   945 		{

   946 		iActiveSchedulerStarted = EFalse;

   947 		CActiveScheduler::Stop();

   948 		}

   949 	TheClient->iWs.SetAutoFlush(iTheClientFlush);

   950 	iMultiPtrEventClient->iWs.SetAutoFlush(iClientFlush);

   951 	}

   952 

   953 // Common function for all test cases

   954 void CTMultiPtrEventTest::RunTestsL()

   955 	{

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

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

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

   959 	iMultiPtrEventClient->ConstructL();

   960 	

   961 	iEventSet=0;

   962 

   963 	// Create secondary client for test case number 3

   964 	if (iTest->iState == 3)

   965 		{

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

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

   968 		iSecMultiPtrEventClient->ConstructL(); 

   969 		}

   970 	

   971 	TRAPD(err, NextSetOfEventsL());

   972 	if (err != KErrNone)

   973 		{

   974 		iFailed = ETrue;

   975 		}

   976 

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

   978 	if (!iFailed)

   979 		{

   980 		iActiveSchedulerStarted = ETrue;

   981 		CActiveScheduler::Start();

   982 		}

   983 

   984 	//

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

   986 	if (eventsRem > 0)

   987 		{

   988 		iFailed=ETrue;

   989 		}

   990 

   991 	// Delete secondary client for test case number 3

   992 	if (iTest->iState == 3)

   993 		{

   994 		delete iSecMultiPtrEventClient;

   995 		iSecMultiPtrEventClient = NULL;

   996 		}

   997 	

   998 	delete iMultiPtrEventClient;

   999 	iMultiPtrEventClient = NULL;

  1000 	}

  1001 

  1002 // Common function for all tests

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

  1004 void CTMultiPtrEventTest::NextSetOfEventsL()

  1005 	{

  1006 	// For each test case calls its respective tests

  1007 		

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

  1009 	switch (iTest->iState)

  1010 		{

  1011 	case 0:

  1012 /**

  1013 @SYMTestCaseID			GRAPHICS-WSERV-ADVANCEDPOINTER-0036

  1014 */

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

  1016 		MultiPointerEvents();

  1017 		break;

  1018 	case 1:

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

  1020 		PurgingMultiPointerEvents();

  1021 		break;

  1022 	case 2:

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

  1024 		MultiPointerEventsForAnimsL();

  1025 		break;

  1026 	case 3:

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

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

  1029 		MultiClientMultiPointerEvents();

  1030 		break;

  1031 	case 4:

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

  1033 		MultiPointerEventsForPointerClickL();

  1034 		break;

  1035 	case 5:

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

  1037 		MultiPointerEventsInDiffScreenModes();

  1038 		break;

  1039 	case 6:

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

  1041 		FilteringMultiPointerEvents();

  1042 		break;

  1043 	case 7:

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

  1045 		GrabbingMultiPointerEvents();

  1046 		break;

  1047 	case 8:

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

  1049 		VirtualKeyBoardForMultiplePointers();

  1050 		break;

  1051 	case 9:

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

  1053 		DoubleClickForMultiplePointers();

  1054 		break;

  1055 	case 10:

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

  1057 		MultiPointerOutOfRangeEvents();

  1058 		break;

  1059 	case 11:

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

  1061 		AutoForeGroundForMultiplePointersL();

  1062 		break;

  1063 	case 12:

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

  1065 		EmulationRulesForMultiplePointers();

  1066 		break;

  1067 	case 13:

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

  1069 		CloseProximityAndHighPressureEventsL();

  1070 		break;

  1071 	case 14:

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

  1073 		OutOfBoundValueTesting();

  1074 		break;	

  1075 	case 15:

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

  1077 		CapturingMultiPointerEvents();

  1078 		break;

  1079 	case 16:

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

  1081 		NegativeTestsForProximityPressureEventsL();

  1082 		break;

  1083 	case 17:

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

  1085 		PointerRepeatEventForMultiplePointers();

  1086 		break;

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

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

  1089 	default:

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

  1091 		AutoPanic(EAutoPanicWrongTest);

  1092 		}

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

  1094 	}

  1095 

  1096 /**

  1097 @SYMTestCaseID			GRAPHICS-WSERV-ADVANCEDPOINTER-0033

  1098 @SYMPREQ				PREQ1226

  1099 @SYMREQ					REQ9677

  1100 @SYMTestPriority		High

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

  1102 @SYMTestStatus			Implemented

  1103 

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

  1105 						over 4 seperate test cases. 

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

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

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

  1109 						Add EButtonRepeat to TWsEvent buffer.  

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

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

  1112 						to TWsEvent buffer.

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

  1114 						

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

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

  1117 						instead of EButtonRepeat. 

  1118 						

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

  1120 						CancelPointerRepeatEventRequest API.

  1121 						

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

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

  1124  						after calling RequestPointerRepeatEvent and time interval specified has elapsed.

  1125 						

  1126 */

  1127 void CTMultiPtrEventTest::PointerRepeatEventForMultiplePointers()

  1128 	{

  1129 	// Test PointerRepeatEvent for Multiple Pointers 

  1130 	TLogMessageText logText;

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

  1132 	logText.AppendFormat(KSet, iEventSet);

  1133 	LOG_MESSAGE(logText);

  1134 	

  1135 	if (!iEventSet)