--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/tauto/TPointer.CPP	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1087 @@
+// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Test pointer event handling
+// Coverted from TMan test code (TMPOINTR.CPP) October 2000
+// 
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+#include "TPointer.H"
+
+
+//#define LOGGING
+
+#if defined(LOGGING)
+	LOCAL_D TLogMessageText LogMessageText;
+#endif
+
+
+CPointerWindow::CPointerWindow(CTPointer *aTest) : CTWin(), iTest(aTest)
+	{}
+
+void CPointerWindow::SetState(TInt aState)
+	{
+#if defined(LOGGING)
+	_LIT(KState,"CPointerWindow::SetState(%d) OldState=%d");
+	LogMessageText.Format(KState,aState,iState);
+	TheClient->LogMessage(LogMessageText);
+#endif
+	iState=aState;
+	iWin.Invalidate();
+	switch(aState)
+		{
+		case KStateWaitingForTest1:
+		case KStateWaitingForTest2:
+		case KStateWaitingForTest3:
+		case KStateWaitingForTest4:
+		case KStateWaitingForTest5:
+		case KStateWaitingForTest6:
+		case KStateWaitingForTest8:
+		case KStateWaitingForTest7:
+			iRepeatRect=TRect();
+			break;
+		case KStateTesting8:
+			iWin.Close();
+			Client()->iWs.Flush();
+			User::After(500000);
+			FinishedTests();
+			break;
+		}
+	TheClient->WaitForRedrawsToFinish();
+	SendEvent();
+	}
+
+void CPointerWindow::ResetTest(TInt aState)
+	{
+	TInt newState=KStateFinished;
+	switch(aState)
+		{
+		case KStateTesting1:
+			newState=KStateWaitingForTest1;
+			break;
+		case KStateTesting2:
+			newState=KStateWaitingForTest2;
+			break;
+		case KStateTesting3:
+			newState=KStateWaitingForTest3;
+			break;
+		case KStateTesting4:
+			newState=KStateWaitingForTest4;
+			break;
+		case KStateTesting5:
+			newState=KStateWaitingForTest5;
+			break;
+		case KStateTesting6:
+			newState=KStateWaitingForTest6;
+			break;
+		case KStateTesting8:
+			newState=KStateWaitingForTest8;
+			break;
+		case KStateTesting7:
+			newState=KStateWaitingForTest7;
+			break;
+		}
+	TheClient->iWs.PurgePointerEvents();
+	SetState(newState);
+	}
+
+void CPointerWindow::SetUpLD(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc)
+	{
+	ConstructExtLD(*parent,pos,size);
+	iTl=pos;
+	iSize=size;
+	Activate();
+	AssignGC(aGc);
+	SetState(KStateWaitingForTest1);
+	BaseWin()->EnableOnEvents();
+	}
+
+void CPointerWindow::Draw()
+	{
+	iGc->Clear();
+	iGc->DrawRect(Size());
+	iGc->DrawRect(iRepeatRect);
+	TBuf<0x80> buf;
+	TBuf<0x80> buf2;
+	switch(iState)
+		{
+		case KStateWaitingForTest1:
+			{
+			_LIT(Draw1,"Click anywhere in the window and hold the pointer steady");
+			buf.Format(Draw1);
+			}
+			break;
+		case KStateTesting1:
+			{
+			_LIT(Draw2,"Hold pointer inside the box");
+			buf.Format(Draw2);
+			}
+			break;
+		case KStateWaitingForTest2:
+			{
+			_LIT(Draw3,"Release the pointer then click in the window and hold the pointer steady");
+			buf.Format(Draw3);
+			}
+			break;
+		case KStateTesting2:
+			{
+			_LIT(Draw4,"Drag the pointer outside the box");
+			buf.Format(Draw4);
+			}
+			break;
+		case KStateWaitingForTest3:
+			{
+			_LIT(Draw5,"Release the pointer then click in the window and hold the pointer steady");
+			buf.Format(Draw5);
+			}
+			break;
+		case KStateTesting3:
+			{
+			_LIT(Draw6,"Release the pointer");
+			buf.Format(Draw6);
+			}
+			break;
+		case KStateWaitingForTest4:
+			{
+			_LIT(Draw7,"Click anywhere in the window and move the pointer slightly");
+			buf.Format(Draw7);
+			}
+			break;
+		case KStateTesting4:
+			{
+			_LIT(Draw8,"Release the pointer");
+			buf.Format(Draw8);
+			}
+			break;
+		case KStateWaitingForTest5:
+			{
+			_LIT(Draw9,"Click anywhere in the window and move the pointer slightly");
+			buf.Format(Draw9);
+			}
+			break;
+		case KStateTesting5:
+			{
+			_LIT(Draw10,"Release the pointer");
+			buf.Format(Draw10);
+			break;
+			}
+		case KStateWaitingForTest6:
+			{
+			_LIT(Draw11,"Click anywhere in the window");
+			buf.Format(Draw11);
+			}
+			break;
+		case KStateTesting6:
+			{
+			_LIT(Draw12,"Move the pointer");
+			buf.Format(Draw12);
+			}
+			break;
+		case KStateWaitingForTest8:
+			{
+			_LIT(Draw13,"Click anywhere in the window, and keep the pointer pressed");
+			buf.Format(Draw13);
+			}
+			break;
+		case KStateTesting8:
+			buf.Format(KNullDesC);
+			break;
+		case KStateWaitingForTest7:
+			{
+			_LIT(Draw14,"Switch off and touch the center of the screen");
+			buf.Format(Draw14);
+			}
+			break;
+		case KStateTesting7:
+			buf.Format(KNullDesC);
+			break;
+		}
+	switch(iState)
+		{
+		case KStateTesting1:
+			{
+			_LIT(Repeat2,"Repeat (%d/%d), interval=%d.%d");
+			buf2.Format(Repeat2,iRepeatCount,KRepeatCount,iInterval.Int()/1000000,(iInterval.Int()%1000000)/100000);
+			}
+			break;
+		case KStateTesting2:
+		case KStateTesting3:
+			{
+			_LIT(Repeat1,"Repeat (%d), interval=%d.%d");
+			buf2.Format(Repeat1,iRepeatCount,iInterval.Int()/1000000,(iInterval.Int()%1000000)/100000);
+			}
+			break;
+		}
+	iGc->DrawText(buf,TPoint(10,20));
+	iGc->DrawText(buf2,TPoint(10,40));
+	}
+
+void CPointerWindow::FinishedTests()
+	{
+	iState=KStateFinished;
+	}
+
+void CPointerWindow::StartNextRepeatTest()
+	{
+	iInterval=0;
+	iRepeatCount=0;
+	if (iState==KStateWaitingForTest4)
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+	else if (iState==KStateWaitingForTest5)
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+	QueueNextRepeat();
+	switch(iState)
+		{
+		case KStateWaitingForTest1:
+			SetState(KStateTesting1);
+			break;
+		case KStateWaitingForTest2:
+			SetState(KStateTesting2);
+			break;
+		case KStateWaitingForTest3:
+			SetState(KStateTesting3);
+			break;
+		case KStateWaitingForTest4:
+			SetState(KStateTesting4);
+			break;
+		case KStateWaitingForTest5:
+			SetState(KStateTesting5);
+			break;
+		case KStateWaitingForTest6:
+			SetState(KStateTesting6);
+			break;
+		case KStateWaitingForTest8:
+			SetState(KStateTesting8);
+			break;
+		case KStateWaitingForTest7:
+			SetState(KStateTesting7);
+			break;
+		}
+	}
+
+void CPointerWindow::QueueNextRepeat()
+	{
+	iInterval=iInterval.Int()+KRepeatIntervalIncrements;
+#if defined(LOGGING)
+	/*_LIT(KRequestRepeat,"Request Repeat, State=%d, Interval=%d");
+	TLogMessageText buf;
+	buf.Format(KRequestRepeat,iState,iInterval.Int());
+	TheClient->LogMessage(buf);*/
+#endif
+	iWin.RequestPointerRepeatEvent(TTimeIntervalMicroSeconds32(iInterval),TRect(iRepeatRect));
+	iPrevTime.HomeTime();
+	iWin.Invalidate();
+	}
+
+void CPointerWindow::PointerL(const TPointerEvent &aPointer,const TTime &aTime)
+	{
+#if defined(LOGGING)
+	_LIT(KPointer,"CPointerWindow::PointerL(Type=%d, Pos=(%d,%d), ParPos=(%d,%d), Mod=0x%x) State=%d");
+	LogMessageText.Format(KPointer,aPointer.iType,aPointer.iPosition.iX,aPointer.iPosition.iY,aPointer.iParentPosition.iX,aPointer.iParentPosition.iY,aPointer.iModifiers,iState);
+	TheClient->LogMessage(LogMessageText);
+#endif
+	if (aPointer.iType==TPointerEvent::EButtonRepeat)
+		{
+		if (iState!=KStateTesting1 && iState!=KStateTesting2 && iState!=KStateTesting3 && iState!=KStateTesting4)
+			TestFailed();
+		else
+			{
+			TTimeIntervalMicroSeconds32 interval(I64LOW(aTime.MicroSecondsFrom(iPrevTime).Int64()));
+			TBool fail1=(interval.Int()<(iInterval.Int()-KRepeatMargin) || interval.Int()>(iInterval.Int()+KRepeatMargin));
+			if (fail1)
+				{
+				_LIT(KPointerRepeat1,"Pointer Repeat Interval, Exp=%d, Act=%d, F1=%d, F2=%d");
+				TLogMessageText buf;
+				TBool fail2=(interval.Int()<(iInterval.Int()-2*KRepeatMargin) || interval.Int()>(iInterval.Int()+3*KRepeatMargin));
+				buf.Format(KPointerRepeat1,iInterval.Int(),interval.Int(),fail1,fail2);
+				TheClient->LogMessage(buf);
+				}
+			if (interval.Int()<(iInterval.Int()-
+		#if defined(__MARM_ARM4__)
+												2*
+		#endif
+												  KRepeatMargin) || interval.Int()>(iInterval.Int()+
+		#if defined(__MARM_ARM4__)
+																								    3*
+		#endif
+																									  KRepeatMargin))
+				TestFailed();
+			else
+				{
+				if (!iRepeatRect.Contains(aPointer.iPosition) ||
+					aPointer.iParentPosition!=(aPointer.iPosition+iWin.InquireOffset(*Parent()->WinTreeNode())))
+					TestFailed();
+				else
+					{
+					iRepeatCount++;
+					if (iState==KStateTesting1 && iRepeatCount==KRepeatCount)
+						{
+						QueueNextRepeat();
+						Client()->iWs.Flush();
+						User::After(TTimeIntervalMicroSeconds32(iRepeatCount*KRepeatIntervalIncrements));
+						iWin.CancelPointerRepeatEventRequest();
+						SetState(KStateWaitingForTest2);
+						}
+					else
+						QueueNextRepeat();
+					}
+				}
+			}
+		}
+	else switch(iState)
+		{
+		case KStateWaitingForTest1:
+		case KStateWaitingForTest2:
+		case KStateWaitingForTest3:
+		case KStateWaitingForTest4:
+		case KStateWaitingForTest8:
+			if (aPointer.iType==TPointerEvent::EButton1Down)
+				{
+				iRepeatRect.iTl=aPointer.iPosition-TPoint(KRepeatRectXExtra,KRepeatRectYExtra);
+				iRepeatRect.iBr=aPointer.iPosition+TPoint(KRepeatRectXExtra,KRepeatRectYExtra);
+				StartNextRepeatTest();
+				}
+			break;
+		case KStateWaitingForTest5:
+			if (aPointer.iType==TPointerEvent::EButton1Down)
+				{
+				iRepeatRect.iTl=aPointer.iPosition;
+				iRepeatRect.iBr=aPointer.iPosition+TPoint(1,1);
+				StartNextRepeatTest();
+				}
+			break;
+		case KStateWaitingForTest6:
+			if (aPointer.iType==TPointerEvent::EButton1Down)
+				{
+				iRepeatRect.iTl=aPointer.iPosition+TPoint(KRepeatRectXExtra,KRepeatRectYExtra);
+				iRepeatRect.iBr=aPointer.iPosition+TPoint(2*KRepeatRectXExtra,2*KRepeatRectYExtra);
+				StartNextRepeatTest();
+				}
+			break;
+		case KStateTesting1:
+			{
+			TBool isDrag=(aPointer.iType==TPointerEvent::EDrag);
+			TestFailed(isDrag);
+			if (isDrag)
+				{
+				iTest->SimulatePointer(TRawEvent::EButton1Down,aPointer.iPosition.iX,aPointer.iPosition.iY);
+				iTest->SimulatePointer(TRawEvent::EButton1Up,aPointer.iPosition.iX,aPointer.iPosition.iY);
+				}
+			}
+			break;
+		case KStateTesting2:
+			if (aPointer.iType==TPointerEvent::EDrag)
+				SetState(KStateWaitingForTest3);
+			else
+				TestFailed();
+			break;
+		case KStateTesting3:
+			if (aPointer.iType==TPointerEvent::EButton1Up)
+				SetState(KStateWaitingForTest4);
+			else
+				TestFailed();
+			break;
+		case KStateTesting4:
+			if (aPointer.iType==TPointerEvent::EButton1Up)
+				SetState(KStateWaitingForTest5);
+			else
+				TestFailed();
+			break;
+		case KStateTesting5:
+			if (aPointer.iType==TPointerEvent::EButton1Up)
+				SetState(KStateWaitingForTest6);
+			else if (aPointer.iType!=TPointerEvent::EDrag)
+				TestFailed();
+			break;
+		case KStateTesting6:
+			if (aPointer.iType==TPointerEvent::EDrag)
+				{
+		//#if !defined(__WINS__)	// Can't emulate touching dig when switched off under WINS
+		//		if (iTest->Digitiser())
+					SetState(KStateWaitingForTest7);
+		/*		else
+		#endif
+					SetState(KStateWaitingForTest8);*/
+				}
+			else
+				TestFailed();
+			break;
+		case KStateWaitingForTest7:
+			if (aPointer.iType==TPointerEvent::EButton1Down || aPointer.iType==TPointerEvent::ESwitchOn)
+				TestFailed();
+			break;
+		case KStateTesting7:
+			if (aPointer.iType!=TPointerEvent::ESwitchOn)
+				TestFailed();
+			else
+				SetState(KStateWaitingForTest8);
+			break;
+		case KStateTesting8:
+			break;
+		}
+	}
+
+void CPointerWindow::TestFailed(TBool aRetest/*=EFalse*/)
+	{
+	if (iState!=KStateFailed)
+		{
+		TInt oldState=iState;
+		iState=KStateFailed;
+		if (iTest->TestFailed(oldState,aRetest) || aRetest)
+			ResetTest(oldState);
+		}
+	}
+
+void CPointerWindow::WinKeyL(const TKeyEvent &aKey,const TTime &)
+	{
+#if defined(LOGGING)
+	_LIT(KKey,"CPointerWindow::WinKeyL(Code=%d, ScanCode=%d) State=%d");
+	LogMessageText.Format(KKey,aKey.iCode,aKey.iScanCode,iState);
+	TheClient->LogMessage(LogMessageText);
+#endif
+	if (aKey.iCode==EKeyEscape)
+		FinishedTests();	// Simply skip this test if the Escape key is pressed
+	}
+
+void CPointerWindow::SwitchOn(const TTime &)
+	{
+#if defined(LOGGING)
+	_LIT(KOn,"CPointerWindow::SwitchOn() State=%d");
+	LogMessageText.Format(KOn,iState);
+	TheClient->LogMessage(LogMessageText);
+#endif
+	if (iState==KStateWaitingForTest7)
+		SetState(KStateTesting7);
+	else
+		TestFailed();
+	}
+
+void CPointerWindow::SendEvent()
+	{	
+#if defined(LOGGING)
+	_LIT(KSend,"CPointerWindow::SendEvent() State=%d");
+	LogMessageText.Format(KSend,iState);
+	TheClient->LogMessage(LogMessageText);
+#endif
+	switch (iState)
+		{
+	case KStateWaitingForTest1:
+		iTest->SimulatePointer(TRawEvent::EButton1Down,iTl.iX+iSize.iWidth/4,iTl.iY+iSize.iHeight/4);
+		break;
+	//case KStateTesting1:			//Do Nothing
+	//	break;
+	case KStateWaitingForTest2:
+		iTest->SimulatePointer(TRawEvent::EButton1Up,iTl.iX+iSize.iWidth/4,iTl.iY+iSize.iHeight/4);
+		iTest->SimulatePointer(TRawEvent::EButton1Down,iTl.iX+iSize.iWidth/2,iTl.iY+iSize.iHeight/4);
+		break;
+	case KStateTesting2:
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+5*iSize.iWidth/8,iTl.iY+iSize.iHeight/4+2);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+3*iSize.iWidth/4,iTl.iY+iSize.iHeight/4+4);
+		break;
+	case KStateWaitingForTest3:
+		iTest->SimulatePointer(TRawEvent::EButton1Up,iTl.iX+3*iSize.iWidth/4,iTl.iY+iSize.iHeight/4+4);
+		iTest->SimulatePointer(TRawEvent::EButton1Down,iTl.iX+iSize.iWidth/4,iTl.iY+iSize.iHeight/2);
+		break;
+	case KStateTesting3:
+		iTest->SimulatePointer(TRawEvent::EButton1Up,iTl.iX+iSize.iWidth/4,iTl.iY+iSize.iHeight/2);
+		break;
+	case KStateWaitingForTest4:
+		iTest->SimulatePointer(TRawEvent::EButton1Down,iTl.iX+iSize.iWidth/2,iTl.iY+iSize.iHeight/2);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+iSize.iWidth/2+3,iTl.iY+iSize.iHeight/2+1);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+iSize.iWidth/2+6,iTl.iY+iSize.iHeight/2+2);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+iSize.iWidth/2+9,iTl.iY+iSize.iHeight/2+3);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+iSize.iWidth/2+12,iTl.iY+iSize.iHeight/2+4);
+		break;
+	case KStateTesting4:
+		iTest->SimulatePointer(TRawEvent::EButton1Up,iTl.iX+iSize.iWidth/2+12,iTl.iY+iSize.iHeight/2+4);
+		break;
+	case KStateWaitingForTest5:
+		iTest->SimulatePointer(TRawEvent::EButton1Down,iTl.iX+iSize.iWidth/2,iTl.iY+3*iSize.iHeight/4);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+iSize.iWidth/2+3,iTl.iY+3*iSize.iHeight/4+1);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+iSize.iWidth/2+6,iTl.iY+3*iSize.iHeight/4+2);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+iSize.iWidth/2+9,iTl.iY+3*iSize.iHeight/4+3);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+iSize.iWidth/2+12,iTl.iY+3*iSize.iHeight/4+4);
+		break;
+	case KStateTesting5:
+		iTest->SimulatePointer(TRawEvent::EButton1Up,iTl.iX+iSize.iWidth/2+12,iTl.iY+3*iSize.iHeight/4+4);
+		break;
+	case KStateWaitingForTest6:
+		iTest->SimulatePointer(TRawEvent::EButton1Down,iTl.iX+3*iSize.iWidth/4,iTl.iY+3*iSize.iHeight/4);
+		break;
+	case KStateTesting6:
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+3*iSize.iWidth/4+4,iTl.iY+3*iSize.iHeight/4+2);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+3*iSize.iWidth/4+8,iTl.iY+3*iSize.iHeight/4+4);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+3*iSize.iWidth/4+12,iTl.iY+3*iSize.iHeight/4+6);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+3*iSize.iWidth/4+16,iTl.iY+3*iSize.iHeight/4+8);
+		break;
+	case KStateWaitingForTest8:
+		iTest->SimulatePointer(TRawEvent::EButton1Down,iTl.iX+iSize.iWidth/2,iTl.iY+3*iSize.iHeight/4);
+		break;
+	case KStateTesting8:
+		break;
+	case KStateWaitingForTest7:
+		iTest->SimulatePointer(TRawEvent::EButton1Up,iTl.iX+3*iSize.iWidth/4+16,iTl.iY+3*iSize.iHeight/4+8);
+		iTest->SimulateEvent(TRawEvent::ESwitchOn);
+		iTest->SimulatePointer(TRawEvent::EPointerSwitchOn,iTl.iX+iSize.iWidth/2-1,iTl.iY+iSize.iHeight/2-1);
+		break;
+	//case KStateTesting7:		//Do Nothing
+	//	break;
+	/*case KStateFailed:
+		break;
+	case KStateFinished:
+		break;*/
+		}
+	}
+
+//
+// CGrabWindow //
+//
+
+CGrabWindow::CGrabWindow(CTPointer *aTest) : iTest(aTest)
+	{
+	}
+
+void CGrabWindow::SetUpLD(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc)
+	{
+	ConstructExtLD(*parent,pos,size);
+	iTl=pos;
+	iSize=size;
+	Activate();
+	AssignGC(aGc);
+	SetState(KGrabStateWaitingForDown);
+	}
+
+void CGrabWindow::Draw()
+	{
+	iGc->Clear();
+	iGc->DrawRect(Size());
+	TBuf<0x80> buf;
+	switch(iState)
+		{
+		case KGrabStateWaitingForDown:
+		case KGrabStateWaitingForDown2:
+		case KGrabStateWaitingForDown5:
+			{
+			_LIT(Draw1,"Press the pointer inside the window");
+			buf.Copy(Draw1);
+			}
+			break;
+		case KGrabStateWaitingForDown3:
+		case KGrabStateWaitingForUp3a:
+			{
+			_LIT(Draw2,"Press and release the pointer inside the window");
+			buf.Copy(Draw2);
+			}
+			break;
+		case KGrabStateWaitingForDragOut:
+			{
+			_LIT(Draw3,"Drag the pointer outside into the outside window");
+			buf.Copy(Draw3);
+			}
+			break;
+		case KGrabStateWaitingForUp:
+		case KGrabStateWaitingForUp2b:
+		case KGrabStateWaitingForUp5:
+			{
+			_LIT(Draw4,"Release the pointer");
+			buf.Copy(Draw4);
+			}
+			break;
+		case KGrabStateWaitingForDown4:
+			{
+			_LIT(Draw5,"Press then release the pointer");
+			buf.Copy(Draw5);
+			}
+			break;
+		default:;
+		}
+	iGc->DrawText(buf,TPoint(10,20));
+	}
+
+void CGrabWindow::PointerL(const TPointerEvent &aPointer,const TTime&)
+	{
+#if defined(LOGGING)
+	_LIT(KPointer,"CGrabWindow::PointerL(Type=%d, Pos=(%d,%d), ParPos=(%d,%d), Mod=0x%x) State=%d");
+	LogMessageText.Format(KPointer,aPointer.iType,aPointer.iPosition.iX,aPointer.iPosition.iY,aPointer.iParentPosition.iX,aPointer.iParentPosition.iY,aPointer.iModifiers,iState);
+	TheClient->LogMessage(LogMessageText);
+#endif
+	switch(iState)
+		{
+		case KGrabStateWaitingForDown:
+			if (aPointer.iType==TPointerEvent::EButton1Down)
+				SetState(KGrabStateWaitingForDragOut);
+			break;
+		case KGrabStateWaitingForDragOut:
+			if (aPointer.iType!=TPointerEvent::EDrag)
+				TestFailed();
+			else
+				{
+				if (!TRect(Size()).Contains(aPointer.iPosition))
+					SetState(KGrabStateWaitingForUp);
+				}
+			break;
+		case KGrabStateWaitingForUp:
+			if (aPointer.iType==TPointerEvent::EDrag)
+				break;
+			if (aPointer.iType==TPointerEvent::EButton1Up)
+				SetState(KGrabStateWaitingForDown2);
+			else
+				TestFailed();
+			break;
+		case KGrabStateWaitingForDown2:
+			if (aPointer.iType!=TPointerEvent::EButton1Down)
+				TestFailed();
+			else
+				{
+				iTest->GrabWin2()->BaseWin()->ClaimPointerGrab();
+				iTest->GrabWin2()->BaseWin()->ClaimPointerGrab();	// Call twice to check it's harmless
+				SetState(KGrabStateWaitingForUp2a);
+				}
+			break;
+		case KGrabStateWaitingForUp2a:
+			SetState(KGrabStateWaitingForDrag2);
+			break;
+		case KGrabStateWaitingForDrag2:
+			break;
+		case KGrabStateWaitingForUp2b:
+			TestFailed();
+			break;
+		case KGrabStateWaitingForDown3:
+			if (aPointer.iType!=TPointerEvent::EButton1Down)
+				TestFailed();
+			else
+				SetState(KGrabStateWaitingForUp3a);
+			break;
+		case KGrabStateWaitingForUp3a:
+			if (aPointer.iType==TPointerEvent::EButton1Up)
+				{
+				iTest->GrabWin2()->BaseWin()->ClaimPointerGrab();
+				SetState(KGrabStateWaitingForUp3b);
+				}
+			break;
+		case KGrabStateWaitingForUp3b:
+			TestFailed();
+			break;
+		case KGrabStateWaitingForDown5:
+			if (aPointer.iType!=TPointerEvent::EButton1Down)
+				TestFailed();
+			else
+				{
+				iTest->GrabWin2()->BaseWin()->ClaimPointerGrab(EFalse);
+				SetState(KGrabStateWaitingForDrag5);
+				}
+			break;
+		case KGrabStateWaitingForDrag5:
+			if (aPointer.iType==TPointerEvent::EButton1Up)
+				TestFailed();
+			break;
+		case KGrabStateWaitingForUp5:
+			TestFailed();
+			break;
+		case KGrabStateWaitingForDown4:
+			iWin.Close();	// Close the window with the grab captured in it
+			SetState(KGrabStateWaitingForUp4);
+			break;
+		case KGrabStateFinished:
+			break;
+		}
+	}
+
+void CGrabWindow::ResetTest()
+	{
+	TheClient->iWs.PurgePointerEvents();
+	SetState(KGrabStateWaitingForDown);
+	}
+
+void CGrabWindow::Pointer2(const TPointerEvent &aPointer)
+	{
+	switch(iState)
+		{
+		case KGrabStateWaitingForDrag2:
+			{
+			if (aPointer.iType==TPointerEvent::EDrag)
+				{
+				SetState(KGrabStateWaitingForUp2b);
+				}
+			else
+				{
+				if (iTest->TestFailed(iState))
+					ResetTest();
+				}
+			break;
+			}
+		case KGrabStateWaitingForUp2b:
+			if (aPointer.iType==TPointerEvent::EDrag)	// Harmless
+				break;
+			if (aPointer.iType==TPointerEvent::EButton1Up)
+				SetState(KGrabStateWaitingForDown3);
+			else
+				TestFailed();
+			break;
+		case KGrabStateWaitingForUp3b:
+			if (aPointer.iType==TPointerEvent::EButton1Up)
+				SetState(KGrabStateWaitingForDown5);
+			else
+				TestFailed();
+			break;
+		case KGrabStateWaitingForUp4:
+			FinishedTests();
+			break;
+		case KGrabStateWaitingForDrag5:
+			{
+			if (aPointer.iType==TPointerEvent::EDrag)
+				SetState(KGrabStateWaitingForUp5);
+			else if (iTest->TestFailed(iState))
+				ResetTest();
+			break;
+			}
+		case KGrabStateWaitingForUp5:
+			if (aPointer.iType==TPointerEvent::EDrag)	// Harmless
+				break;
+			if (aPointer.iType==TPointerEvent::EButton1Up)
+				SetState(KGrabStateWaitingForDown4);
+			else
+				TestFailed();
+			break;
+		default:;
+		}
+	}
+
+void CGrabWindow::SetState(TInt aState)
+	{
+	iState=aState;
+	if (aState!=KGrabStateWaitingForUp4)
+		iWin.Invalidate();
+	TheClient->WaitForRedrawsToFinish();	
+	SendEvent();
+	}
+
+void CGrabWindow::TestFailed()
+	{
+#if defined(LOGGING)
+	_LIT(KFail,"CGrabWindow::TestFailed() State=%d");
+	LogMessageText.Format(KFail,iState);
+	TheClient->LogMessage(LogMessageText);
+#endif
+	if (iState!=KStateFailed)
+		{
+		TInt oldState=iState;
+		iState=KStateFailed;
+		if (iTest->TestFailed(oldState))
+			ResetTest();
+		}
+	}
+
+void CGrabWindow::FinishedTests()
+	{
+	iState=KGrabStateFinished;
+	}
+
+void CGrabWindow::WinKeyL(const TKeyEvent &aKey,const TTime &)
+	{
+#if defined(LOGGING)
+	_LIT(KKey,"CGrabWindow::WinKeyL(Code=%d, ScanCode=%d) State=%d");
+	LogMessageText.Format(KKey,aKey.iCode,aKey.iScanCode,iState);
+	TheClient->LogMessage(LogMessageText);
+#endif
+	if (aKey.iCode==EKeyEscape)
+		FinishedTests();	// Simply skip this test if the Escape key is pressed
+	}
+
+void CGrabWindow::SendEvent()
+	{
+	switch (iState)
+		{
+	case KGrabStateWaitingForDown:
+		iTest->SimulatePointer(TRawEvent::EButton1Down,iTl.iX+iSize.iWidth/3,iTl.iY+iSize.iHeight/3);
+		break;
+	case KGrabStateWaitingForDragOut:
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+iSize.iWidth/6,iTl.iY+iSize.iHeight/6);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+1,iTl.iY+1);
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX-10,iTl.iY-10);
+		break;
+	case KGrabStateWaitingForUp:
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX-8,iTl.iY-8);
+		iTest->SimulatePointer(TRawEvent::EButton1Up,iTl.iX-5,iTl.iY-5);
+		break;
+	case KGrabStateWaitingForDown2:
+		iTest->SimulatePointer(TRawEvent::EButton1Down,iTl.iX+2*iSize.iWidth/3,iTl.iY+iSize.iHeight/3);
+		break;
+	/*case KGrabStateWaitingForUp2a:		//Don't need to do anything for these cases
+		break;
+	case KGrabStateWaitingForDrag2:
+		break;*/
+	case KGrabStateWaitingForUp2b:
+		iTest->SimulatePointer(TRawEvent::EPointerMove,iTl.iX+2*iSize.iWidth/3-3,iTl.iY+iSize.iHeight/3+3);
+		iTest->SimulatePointer(TRawEvent::EButton1Up,iTl.iX+2*iSize.iWidth/3,iTl.iY+iSize.iHeight/3);
+		break;
+	case KGrabStateWaitingForDown3:
+		iTest->SimulatePointer(TRawEvent::EButton1Down,iTl.iX+2*iSize.iWidth/3,2*iTl.iY+iSize.iHeight/3);
+		break;
+	case KGrabStateWaitingForUp3a:
+		iTest->SimulatePointer(TRawEvent::EButton1Up,iTl.iX+2*iSize.iWidth/3,2*iTl.iY+iSize.iHeight/3);
+		break;
+	case KGrabStateWaitingForUp3b:
+		break;
+	case KGrabStateWaitingForDown4:
+		iTest->SimulatePointer(TRawEvent::EButton1Down,iTl.iX+2*iSize.iWidth/5,iTl.iY+iSize.iHeight/3);
+		break;
+	case KGrabStateWaitingForUp4:
+		iTest->SimulatePointer(TRawEvent::EButton1Up,iTl.iX+2*iSize.iWidth/5,iTl.iY+iSize.iHeight/3);
+		break;
+	case KGrabStateWaitingForDown5:
+		iTest->SimulatePointer(TRawEvent::EButton1Down,iTl.iX+iSize.iWidth/3,2*iTl.iY+iSize.iHeight/3);
+		break;
+	case KGrabStateWaitingForUp5:
+		iTest->SimulatePointer(TRawEvent::EButton1Up,iTl.iX+iSize.iWidth/3,2*iTl.iY+iSize.iHeight/3);
+		break;
+	//case KGrabStateWaitingForDrag5:		//Don't need to do anything for these cases
+	//	break;
+	/*case KStateFailed:
+		break;
+	case KGrabStateFinished:
+		break;*/
+	default:;
+		}
+	TheClient->iWs.Flush();
+	}
+
+
+//
+// CGrabWindow2, used as part of grab tests //
+//
+
+CGrabWindow2::CGrabWindow2(CGrabWindow *aWindow) : iGrabWindow(aWindow)
+	{
+	}
+
+void CGrabWindow2::Draw()
+	{
+	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+	iGc->SetBrushColor(TRgb::Gray4(2));
+	iGc->DrawRect(Size());
+	}
+
+void CGrabWindow2::PointerL(const TPointerEvent &aPointer,const TTime&)
+	{
+#if defined(LOGGING)
+	_LIT(KPointer,"CGrabWindow2::PointerL(Type=%d, Pos=(%d,%d), ParPos=(%d,%d), Mod=0x%x)");
+	LogMessageText.Format(KPointer,aPointer.iType,aPointer.iPosition.iX,aPointer.iPosition.iY,aPointer.iParentPosition.iX,aPointer.iParentPosition.iY,aPointer.iModifiers);
+	TheClient->LogMessage(LogMessageText);
+#endif
+	iGrabWindow->Pointer2(aPointer);
+	}
+
+//
+// CTPointTest //
+//
+
+CTPointer::CTPointer(CTestStep* aStep) : CTWsGraphicsBase(aStep)
+	{
+	iState = 0;
+	}
+
+
+CTPointer::~CTPointer()
+	{
+	HAL::Set(HALData::EPenDisplayOn,iOldPointerState);
+	delete iRepeatWin;
+	delete iGrabWin;
+	delete iGrabWin2;
+	Client()->ResetFocus();
+	delete iTimeOut;
+	}
+
+void CTPointer::ConstructL()
+	{
+	iTimeOut=new(ELeave) CTimeOut();
+	iTimeOut->ConstructL();
+	iTimeOut->Start(KTimeOutAfter,TCallBack(CTPointer::TimeOut,this));
+	
+	TheClient->iWs.SetPointerCursorArea(iTest->iNormalPointerCursorArea);
+	iRepeatWin=new(ELeave) CPointerWindow(this);
+	TSize screenSize(Client()->iScreen->SizeInPixels());
+	if (TestBase()->ConfigurationSupportsPointerEventTesting())
+	    {
+	    iRepeatWin->SetUpLD(TPoint(screenSize.iWidth/8,screenSize.iHeight/8),TSize(screenSize.iWidth*3/4,screenSize.iHeight*3/4),Client()->iGroup,*Client()->iGc);
+	    }
+	Client()->iGroup->SetCurrentWindow(iRepeatWin);
+	iNoDigitiser=EFalse;
+	TInt err=HAL::Get(HALData::EPenDisplayOn,iOldPointerState);
+	if (err==KErrNotSupported)
+		iNoDigitiser=ETrue;
+	else if (err==KErrNone)
+		err=HAL::Set(HALData::EPenDisplayOn,ETrue);
+	if (err==KErrNotSupported)
+		iNoDigitiser=(!iOldPointerState);
+	else
+		{
+		TEST(err==KErrNone);
+		if (err!=KErrNone)
+		INFO_PRINTF3(_L("HAL::Set(HALData::EPenDisplayOn,ETrue) return value - Expected: %d, Actual: %d"), KErrNone, err);			
+		}
+	
+	}
+
+TInt CTPointer::TimeOut(TAny* aTest)		//static
+	{
+	static_cast<CTPointer*>(aTest)->TimeOut();
+	return(KErrNone);
+	}
+
+void CTPointer::TimeOut()
+	{
+	TLogMessageText buf;
+	_LIT(KPointerTimeOut,"TIMEOUT: Pointer Test, %d, %S");
+	buf.AppendFormat(KPointerTimeOut,iState,&(iTest->iSubTitle));
+	TheClient->LogMessage(buf);
+	++iTimeOutCount;
+	if (!TestFailed(-1) && iState<2)
+		{
+		iTimeOut->Start(KTimeOutAfter,TCallBack(CTPointer::TimeOut,this));
+		}
+	}
+
+TBool CTPointer::TestFailed(TInt aCase,TBool aRetry/*=EFalse*/)
+	{
+	_LIT(KPointerTest,": Pointer Test, %d, %S, Case %d");
+	_LIT(KRetry,"Retry");
+	_LIT(KFail,"FAIL");
+	TLogMessageText buf;
+	TInt ret=0;
+	if (aRetry)
+		buf.Append(KRetry);
+	else
+		{
+		ret=1;
+		buf.Append(KFail);
+		}
+	buf.AppendFormat(KPointerTest,iState,&(iTest->iSubTitle),aCase);
+	TheClient->LogMessage(buf);
+#if !defined(DISABLE_FAIL_DIALOG)
+	if (!aRetry)
+		{
+		__DEBUGGER();
+		TRAPD(err,ret=doTestFailedL());
+		}
+#endif
+	switch(ret)
+		{
+		case 0:
+			return(ETrue);	// Re-try test
+		case 1:
+			break;
+		}
+	return(EFalse);
+	}
+
+TInt CTPointer::doTestFailedL()
+	{
+	//_LIT(Failed,"Pointer repeat test failed");
+	_LIT(Retest,"Retest");
+	_LIT(Fail,"Fail");
+	CTDialog *dialog=new(ELeave) CTDialog();
+	dialog->SetNumButtons(2);
+	dialog->SetButtonText(0,Retest);
+	dialog->SetButtonText(1,Fail);
+	dialog->ConstructLD(*Client()->iGroup,*Client()->iGc);
+	dialog->SetTitle(_L("Pointer repeat test failed"));
+	dialog->SetFlags(CTDialog::EDialogWaitForButtonUp);
+	return dialog->Display();
+	}
+
+CGrabWindow2 *CTPointer::GrabWin2() const
+	{
+	return(iGrabWin2);
+	}
+
+void CTPointer::StartGrabTestL()
+	{
+	iGrabWin=new(ELeave) CGrabWindow(this);
+	iGrabWin2=new(ELeave) CGrabWindow2(iGrabWin);
+//
+	TSize screenSize(Client()->iScreen->SizeInPixels());
+	iGrabWin2->SetUpL(TPoint(screenSize.iWidth/8,screenSize.iHeight/8),TSize(screenSize.iWidth*3/4,screenSize.iHeight*3/4),Client()->iGroup,*Client()->iGc);
+	Client()->iGroup->SetCurrentWindow(iGrabWin2);
+//
+	iGrabWin->SetUpLD(TPoint(screenSize.iWidth/4,screenSize.iHeight/4),TSize(screenSize.iWidth/2,screenSize.iHeight/2),Client()->iGroup,*Client()->iGc);
+	Client()->iGroup->SetCurrentWindow(iGrabWin);
+//
+	}
+
+
+void CTPointer::RunTestCaseL(TInt /*aCurTestCase*/)
+	{
+	_LIT(Repeat,"Repeat tests");
+	_LIT(Grab,"Grab tests");
+
+	iTest->iState=iState;
+	
+	if (!TestBase()->ConfigurationSupportsPointerEventTesting())
+	    {
+	    INFO_PRINTF1(_L("Test skipped because config does not support pointer event testing"));
+	    TestComplete();
+	    return;
+	    }
+	
+	((CTPointerStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
+	switch(iState)
+		{
+		case 0:
+			((CTPointerStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+			iTest->LogSubTest(Repeat);
+			iState++;
+			break;
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0310
+  
+  @SYMDEF             DEF081259
+ 
+  @SYMTestCaseDesc Test pointer event handling
+    
+  @SYMTestPriority High
+ 
+  @SYMTestStatus Implemented
+ 
+  @SYMTestActions Simulate pointer events and check the events are then handled correctly
+  
+  @SYMTestExpectedResults Pointer events are handled correctly
+ 
+*/
+		case 1:
+			((CTPointerStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0310"));
+			iTest->LogSubTest(Grab);
+			
+			StartGrabTestL();
+			iState++;
+			break;
+		default:
+			((CTPointerStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+			((CTPointerStep*)iStep)->CloseTMSGraphicsStep();
+			iTimeOut->Cancel();
+			if (iTimeOutCount>0) TEST(EFalse);
+			if (iTest->IsFullRomL()) User::After(5000000);
+			TestComplete();
+		}
+	((CTPointerStep*)iStep)->RecordTestResultL();
+	}
+
+
+__WS_CONSTRUCT_STEP__(Pointer)