// Copyright (c) 2008-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:

//

#include "TConeMultiPtrStep.h"

#include "tconemultiptrtestappui.h"

#include "tconemultiptrconst.h"

#include <hal.h>

// Global function for panic

void ConeTestPanic(TConeTestPanic aPanic)

	{

	User::Panic(_L("MultiPointerConeTest Panic"),aPanic);

	}

/**

 CTestStep derived class which implements RunTestStepL. It creates CoEnv & AppUi objects.

 Logic involved, RunTestStepL will call RunTestsL() which will create new control/s for each

 test case and calls NextSetOfEventsL() which does testing of all different use cases 

 i,e by simulating the events and adding the events to a buffer. 

 Then RunTestStepL() starts the active scheduler, which will result in a call to

 control's HandlePointerEventL, which will test expected event in buffer with actual event.

*/

CConeMultiPtrTestAppUi::CConeMultiPtrTestAppUi(CTmsTestStep* aStep) 

: CTestCoeAppUi(aStep)

	{

	}

void CConeMultiPtrTestAppUi::ConstructL()

	{

	RDebug::Print( _L(">CConeMultiPtrTestAppUi::ConstructL") );

	CTestCoeAppUi::ConstructL();

	iNormalPointerCursorArea = iCoeEnv->WsSession().PointerCursorArea();

	User::LeaveIfError( HAL::Get(HALData::EPointerMaxPointers, iMaxPointers) );

	User::LeaveIfError( HAL::Get(HALData::EPointerNumberOfPointers, iNumberOfPointers) );

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

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

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

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

	RDebug::Print( _L("CConeMultiPtrTestAppUi::ConstructL 1") );

	iPressureNominal = iPressureStep * (iMaxPressure / (iPressureStep * 2) ); // Somewhere in the middle

	iProximityNominal = iProximityStep * (iMaxProximity / (iProximityStep * 2) ); // Somewhere in the middle

	// Certain tests (MultiPointerGrab) can induce anomalous double-click key-modifiers.

	// Therefore, disable by setting the double-click max interval to zero.

	// This is restored in doTestStepPostambleL().

	RWsSession wsSession;

	TTimeIntervalMicroSeconds32 interval;

	TInt distance;

	User::LeaveIfError( wsSession.Connect() );

	wsSession.GetDoubleClickSettings( interval, distance);

	wsSession.SetDoubleClick( 0, distance);

	wsSession.Close();	

	AutoTestManager().StartAutoTest();

	RDebug::Print( _L("CConeMultiPtrTestAppUi::ConstructL>") );

	}

CConeMultiPtrTestAppUi::~CConeMultiPtrTestAppUi()

	{

	delete iControl;

	}

// Function called for each new test case from CTestManager active object.

void CConeMultiPtrTestAppUi::RunTestStepL(TInt /*aStepNum*/)

	{

    if (!ConfigurationSupportsPointerEventTesting())

        {

        INFO_PRINTF1(_L("Test skipped because config does not support pointer event testing"));

        AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass);

        return;

        }

	switch(iTestCase)

		{

		case 0:

		case 1:

		case 2:

		case 3:

		case 4:

		case 5:

		case 6:

			RunTestsL();

			break;

		default:

			AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass);

			break;

		}

	if (iFailed)

		{

		TEST(EFalse);

		iFailed=EFalse;

		}

	++iTestCase;

	}

/**

 Function called for each new test case from RunTestStepL.

 This creates control/s calls NextSetOfEventsL and starts activescheduler

 */

void CConeMultiPtrTestAppUi::RunTestsL()

	{

	iEventSet = 0;

	iCoeEnv->WsSession().SetAutoFlush(ETrue);

	iControl = CMultiPtrTestControl::NewL( KMultiPtrTestControlParentPosition, TSize(300,200) );

    AddToStackL(iControl);

    iEventCount = 0;

	TRAPD(err, NextSetOfEventsL());

	if (err != KErrNone)

		{

		INFO_PRINTF1( _L("ERROR INFO LOGGED IN epocwind.out") );

		iFailed = ETrue;

		return;

		}

	// Start nested activescheduler

	CActiveScheduler::Start();

	TInt eventsLeft = iControl->EventsLeft();

	if (eventsLeft > 0)

		{

		INFO_PRINTF1( _L("ERROR INFO LOGGED IN epocwind.out") );

		iFailed=ETrue;

		}

	RemoveFromStack(iControl);

	delete iControl;

	iControl = NULL;

	}

/**

 * Determine if the configuration supports pointer event testing.

 * 

 * There are certain circumstances where we want to skip pointer event

 * testing because we are simulating pointer events, and don't want to

 * simulate a pointer event from an impossible co-ordinate.  We'd rather

 * just identify that there is no point in doing the test and skip over

 * to the next test case.

 * 

 * In particular, when a ROM configured with a digitiser is deployed on a

 * Naviengine, with hardware configuration DIP switches which say that there

 * is an external screen connected, then no touch pad is active.

 * The base port under these conditions returns a digitiser area (0,0,0,0)

 * 

 * @return ETrue if the configuration supports pointer event testing, otherwise

 *         return EFalse.

 */

TBool CConeMultiPtrTestAppUi::ConfigurationSupportsPointerEventTesting() const

    {

    if (iNormalPointerCursorArea.IsEmpty())

        {

        return EFalse;

        }

    return ETrue;

    }

/**

 Simulates pointer event, by making use of UserSvr::AddEvent. Also takes a Z parameter.

*/

void CConeMultiPtrTestAppUi::SimulatePointer(TRawEvent::TType aType, TInt aX, TInt aY, TInt aZ, TUint8 aPointerNumber)

	{

	__ASSERT_DEBUG(ConfigurationSupportsPointerEventTesting(), ConeTestPanic(EConePanicNoDigitiser));

	TRawEvent rawEvent;

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

	UserSvr::AddEvent(rawEvent);

	}

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

	{

	SimulatePointer(TRawEvent::EButton1Down, aX, aY, aZ, aPointerNumber);

	SimulatePointer(TRawEvent::EButton1Up, aX, aY, aZ, aPointerNumber);

	}

void CConeMultiPtrTestAppUi::AddExpectedPointer( TAdvancedPointerEvent::TType aType, TPoint aPos, TInt aZ, TUint8 aPointerNumber, TInt /*Handle*/ )

	{

	TWsEvent event;

	TPoint3D point3D;

	point3D.iX = aPos.iX;

	point3D.iY = aPos.iY;

	point3D.iZ = aZ;

	// Note: this setter does not initialise the parent-position parameter.

	// Note: The modifier value is or'd in, as it is a bit-field. The TAdvancedPointerEvent Init()function 

	// should initialise it to EModifierAdvancedPointerEvent.

    event.InitAdvancedPointerEvent( aType, 0, point3D, aPointerNumber ); 

    event.Pointer()->iParentPosition.SetXY( KMultiPtrTestControlParentPosition.iX, KMultiPtrTestControlParentPosition.iY );

	iControl->AddExpectedEvent( *event.Pointer() );

	}

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

	{

	// Pointer position is with respect to the window's Top Left position

	// Here we may want to write a function which will set sent position with respect to control/window 

	// on which we are simulating the events. 

	aPos -= iControl->Position();

	AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, aPos, aZ, aPointerNumber );

	AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, aPos, aZ, aPointerNumber );

	}

/**

 once all the events for a given sub test are tested. So that next subtest case can proceed with it.

 */

void CConeMultiPtrTestAppUi::NextSetOfEventsL()

	{

	switch(iTestCase)

		{

	case 0:

		SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0002"));

		MultiPointerEventsL();

		RecordTestResultL();

		break;

	case 1:

		SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0006"));

		PressureAndProximityL();

		RecordTestResultL();

		break;	

	case 2:

		SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0008"));		

		MoveAndDragL();

		RecordTestResultL();

		break;

	case 3:

		SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0016"));

		MoveAndOutOfRangeL();

		RecordTestResultL();

		break;

	case 4:

		SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0018"));

		PointerNumberOutOfRangeL();

		RecordTestResultL();

		break;

	case 5:

		SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0020"));

		MultiPointerCaptureL();

		RecordTestResultL();

		break;

	case 6:

		SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0022"));

		MultiPointerGrabL();

		RecordTestResultL();

		CloseTMSGraphicsStep();

		break;

	default:

		ConeTestPanic(EConeTestPanicWrongTest);

		break;

		}

	}

/**

@SYMTestCaseID 			UIF-WSERV-ADVANCEDPOINTER-0002

@SYMPREQ 				PREQ1226

@SYMTestType			UT

@SYMTestPriority		Critical

@SYMTestStatus 			Implemented

@SYMTestCaseDesc		Multi-touch pointer events in Cone.

@SYMTestActions			

@SYMTestExpectedResults  The received events should match the simulated raw events.

*/

void CConeMultiPtrTestAppUi::MultiPointerEventsL()

	{

	INFO_PRINTF1( _L(">MultiPointerEventsL") );

	RDebug::Print( _L(">MultiPointerEventsL") );

	if( iNumberOfPointers <= 1 )

		{

		User::Leave( KErrNotSupported );

		}

	switch( iEventSet++ )

		{

		case 0:

			{

			INFO_PRINTF1( _L("MultiPointerEventsL case 0") );

			TPoint ptrPos( 60, 60 );

			TInt z = iPressureNominal;

			TInt i = 0;

			for(; i < iNumberOfPointers; i++ )

				{

				ptrPos.iX += KMultiPtrTestCoOrdinateIncrement;

				ptrPos.iY += KMultiPtrTestCoOrdinateIncrement;

				SimulatePointerDownUp( ptrPos.iX, ptrPos.iY, z, i );

				AddExpectedPointerDownUp( ptrPos, z, i );

				}

			}

			break;

		default:

			{

			CActiveScheduler::Stop();

			iEventSet = 0;

			INFO_PRINTF1( _L("MultiPointerEventsL STOP\n") );

			RDebug::Print( _L("MultiPointerEventsL STOP") );

			RDebug::Print( _L("") );

			}

			break;

		}

	}

/**

@SYMTestCaseID 			UIF-WSERV-ADVANCEDPOINTER-0006

@SYMPREQ 				PREQ1226

@SYMTestType			UT

@SYMTestPriority		Critical

@SYMTestStatus 			Implemented

@SYMTestCaseDesc		To check events received by the control (from different pointers) 

						have pressure and proximity and move events in them.

@SYMTestActions			

@SYMTestExpectedResults  Simulated events are correctly conveyed.

*/

void CConeMultiPtrTestAppUi::PressureAndProximityL()

	{

	INFO_PRINTF1( _L(">PressureAndProximityL") );

	RDebug::Print( _L(">PressureAndProximityL") );

	if( iNumberOfPointers <= 1 )

		{

		User::Leave( KErrNotSupported );

		}

	const TInt KPressureProximityInitialX = 60;

	const TInt KPressureProximityInitialY = 60;

	TPoint ptrPos( KPressureProximityInitialX, KPressureProximityInitialY );

	TPoint incPoint( KMultiPtrTestCoOrdinateIncrement, KMultiPtrTestCoOrdinateIncrement );

	iControl->SetDrags();

	switch( iEventSet++ )

		{ 

		case 0:

			{

			INFO_PRINTF1( _L("PressureAndProximityL case 0") );

			RDebug::Print( _L("PressureAndProximityL case 0") );

			// Two pointers. Some pressure. Position is wrt the screen

			SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, iPressureNominal, KMultiPtrTestPointerNumberLowest );

			SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, (iPressureNominal + iPressureStep), KMultiPtrTestPointerNumberLowest + 1 );

			// Reported position is wrt the control.

			ptrPos -= iControl->Position();

			AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, ptrPos, iPressureNominal, KMultiPtrTestPointerNumberLowest );

			AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, ptrPos, (iPressureNominal + iPressureStep), KMultiPtrTestPointerNumberLowest + 1 );

			}

			break;

		case 1:

			{

			INFO_PRINTF1( _L("PressureAndProximityL case 1") );

			RDebug::Print( _L("PressureAndProximityL case 1") );

			// Two pointers. Max pressure. Position is wrt the screen

			ptrPos += incPoint;

			SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, iMaxPressure, KMultiPtrTestPointerNumberLowest );

			SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, iMaxPressure, KMultiPtrTestPointerNumberLowest + 1 );

			// Reported position is wrt the control.

			ptrPos -= iControl->Position();

			AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, ptrPos, iMaxPressure, KMultiPtrTestPointerNumberLowest );

			AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, ptrPos, iMaxPressure, KMultiPtrTestPointerNumberLowest + 1 );

			}

			break;		

		case 2:

			{

			INFO_PRINTF1( _L("PressureAndProximityL case 2") );

			RDebug::Print( _L("PressureAndProximityL case 2") );

			// Two pointers. Some proximity plus pointer-move events. 

			//Differentiate ptr no's so WServe does not translate to EDrag because of the above button-down events.

			ptrPos += incPoint;

			SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, iProximityNominal, KMultiPtrTestPointerNumberLowest + 2 );

			SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest + 3 );

			ptrPos -= iControl->Position();

			AddExpectedPointer( TAdvancedPointerEvent::EMove, ptrPos, iProximityNominal, KMultiPtrTestPointerNumberLowest + 2 );

			AddExpectedPointer( TAdvancedPointerEvent::EMove, ptrPos, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest + 3 );

			}

			break;

		case 3:

			{

			INFO_PRINTF1( _L("PressureAndProximityL case 3") );

			RDebug::Print( _L("PressureAndProximityL case 3") );

			// Two pointers. Max proximity plus pointer-move events.

			ptrPos += incPoint;

			SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, iMaxProximity, KMultiPtrTestPointerNumberLowest + 2 );

			SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, iMaxProximity, KMultiPtrTestPointerNumberLowest + 3 );

			ptrPos -= iControl->Position();

			AddExpectedPointer( TAdvancedPointerEvent::EMove, ptrPos, iMaxProximity, KMultiPtrTestPointerNumberLowest + 2 );

			AddExpectedPointer( TAdvancedPointerEvent::EMove, ptrPos, iMaxProximity, KMultiPtrTestPointerNumberLowest + 3 );

			}

			break;		

		default:

			{

			INFO_PRINTF1( _L("PressureAndProximityL STOP\n") );

			RDebug::Print( _L("PressureAndProximityL STOP") );

			RDebug::Print( _L("") );

			CActiveScheduler::Stop();

			iEventSet = 0;

			}

			break;

		}	

	}

/**

@SYMTestCaseID 			UIF-WSERV-ADVANCEDPOINTER-0008

@SYMPREQ 				PREQ1226

@SYMTestType			UT

@SYMTestPriority		Critical

@SYMTestStatus 			Implemented

@SYMTestCaseDesc		To check the Control receives move and drags from different pointers 

						and that moves are delivered as moves, or translated to drags 

						dependent upon whether the pointer is up or down.

@SYMTestActions			

@SYMTestExpectedResults  The received events must match the simulated raw events. Moves being 

						 translated to drags in the button-down state.

*/

void CConeMultiPtrTestAppUi::MoveAndDragL()

	{

	INFO_PRINTF1( _L(">MoveAndDragL") );

	RDebug::Print( _L(">MoveAndDragL") );

	if( iNumberOfPointers <= 1 )

		{

		User::Leave( KErrNotSupported );

		}

	const TInt KMoveAndDragInitialX = 100;

	const TInt KMoveAndDragInitialY = 100;

	TPoint ptrPos( KMoveAndDragInitialX, KMoveAndDragInitialY );

	TPoint incPoint( KMultiPtrTestCoOrdinateIncrement, KMultiPtrTestCoOrdinateIncrement );

	TPoint exPos( ptrPos - iControl->Position() ); // The initial expected position adjusted for the control's offset

	iControl->SetDrags();

	switch( iEventSet++ )

		{

		case 0:

			{

			INFO_PRINTF1( _L("MoveAndDragL case 0") );

			RDebug::Print( _L("MoveAndDragL case 0") );

			// Anomalous: Send button-up so that EPointerMove -> EMove

			SimulatePointer( TRawEvent::EButton1Up, ptrPos.iX, ptrPos.iY, iProximityNominal, KMultiPtrTestPointerNumberLowest );

			AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, exPos, iProximityNominal, KMultiPtrTestPointerNumberLowest );			

			ptrPos += incPoint;

			exPos +=incPoint;

			SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest );			

			AddExpectedPointer( TAdvancedPointerEvent::EMove, exPos, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest );

			// Send button-down so that EPointerMove -> EDrag

			SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest );			

			AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, exPos, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest );

			ptrPos += incPoint;

			exPos +=incPoint;

			SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, (iProximityNominal + (2 * iProximityStep)), KMultiPtrTestPointerNumberLowest );	

			AddExpectedPointer( TAdvancedPointerEvent::EDrag, exPos, (iProximityNominal + (2 * iProximityStep)), KMultiPtrTestPointerNumberLowest );

			// Anomalous: Send button-up so that EPointerMove -> EMove

			SimulatePointer( TRawEvent::EButton1Up, ptrPos.iX, ptrPos.iY, iProximityNominal, KMultiPtrTestPointerNumberLowest );

			AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, exPos, iProximityNominal, KMultiPtrTestPointerNumberLowest );			

			ptrPos += incPoint;

			exPos +=incPoint;

			SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest );			

			AddExpectedPointer( TAdvancedPointerEvent::EMove, exPos, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest );

			}

			break;

		case 1:

			{

			INFO_PRINTF1( _L("MoveAndDragL case 1") );

			RDebug::Print( _L("MoveAndDragL case 1") );

			// Replicate case 0 for another pointer number.

			const TInt pointerNumber = KMultiPtrTestPointerNumberLowest + 1;