// 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);