// 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:

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code 

*/

#ifndef TMULTIPTREVENT_H_

#define TMULTIPTREVENT_H_

#include <e32std.h>

#include <e32cmn.h>

#include "w32std.h"

#include "../tlib/testbase.h"

#include "AUTO.H"

#include "AUTODLL.H"

#include "../TClick/multiptrclick.h"

#include "TGraphicsHarness.h"

class CTMultiPtrEventTest;

class CTMultiPtrEventClient;

/*

 * CTEvent derived class which acts as eventhandler and eventbuffer 

 * Stores the events in buffer, which is used for comparing events received from wserv.

 */ 

class CTMultiPtrEventBuffer : public CTEvent

	{

	enum {EEventBufferSize=40, EMovePtsBuffer=10};

public:

	CTMultiPtrEventBuffer(RWsSession *aWs, CTMultiPtrEventTest *aTest, CTMultiPtrEventClient* aClient);

	void ConstructL();

	void AddExpectedEvent(TWsEvent &aEvent);

	void AddExpectedMovePtEvent(TPoint &aMovePt);

	TInt EventsRemaining();

	void SetEventCount(TInt aCount) {iEventCount = aCount;}

	void SetNestedLoopState(TBool aLoopStart) {iNestedLoopStarted = aLoopStart;}

	TBool NestedLoopState() {return iNestedLoopStarted;}

	void GetMoveBufferAndCompareL();

protected:

	// Pure virtual from CTEventBase

	void doRunL();

private:

	void TestL(TInt aTest);

	void TestL(TInt aTest, TInt aVal1, TInt aVal2,const char *oper, const char *aTestStr, 

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

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

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

private:

	CCirBuf<TWsEvent> iEventBuffer;

	CCirBuf<TPoint> iMovePtsBuffer;

	CTMultiPtrEventTest* iTest;

	TInt iEventCount;

	CTMultiPtrEventClient* iClient;

	TBool iNestedLoopStarted;

	};

/* 

 * CTClient derived class which gives Wserv client environment 

 * i,e iWs, iScreen, iGc, iGroup, iEventHandler etc...

 * Owns CTMultiPtrEventBuffer and stores in iEventhandler of its base class

 * Accepts the event from test class and passes them on to buffer class

 */ 

class CTMultiPtrEventClient : public CTClient

	{

public:

	CTMultiPtrEventClient(CTMultiPtrEventTest *aTest, TBool aSecondaryClient = EFalse);

	~CTMultiPtrEventClient();

	void ConstructL();

	inline CTBlankWindow* ParentWin() { return iParentWin; }

	inline CTBlankWindow* ChildWin() { return iChildWin; }

	inline CTMultiPtrEventBuffer* EventBuffer() {return static_cast<CTMultiPtrEventBuffer*>(iEventHandler);}

	inline void SetExpectNonAdvancedPointerEvents() {iExpectNonAdvancedPointerEvents=ETrue;};

	inline void ClearExpectNonAdvancedPointerEvents() {iExpectNonAdvancedPointerEvents=EFalse;};

	TBool IsSecondaryClient() {return iSecondaryClient;}

	void AddExpectedPointerEvent(TPointerEvent::TType aType, TPoint aPos, TUint8 aPointerNumber, TUint aHandle = 0);

	void AddExpectedPointerEvent(TPointerEvent::TType aType, TPoint aPos, TInt aZ, TUint aModifier, TUint8 aPointerNumber, TUint aHandle = 0);

	void AddExpectedWsEvent(TEventCode aType, TInt aPointerNumber = 0, TUint aHandle = 0);

	void AddExpectedMovePoint(TPoint aPos);

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

	void ConstructGroupBlankWinL();

	void DeleteGroupBlankWin();

	TBool CheckOrdinalPosition(TInt aWinAutoFocus1);

	// Virtual from CTClient

	void ConstructEventHandlerL();

private:

	CTMultiPtrEventTest* iTest;

	TSize iParentWinSize;

	TPoint iParentWinPos;

	TSize iChildWinSize;

	TPoint iChildWinPos;

	CTBlankWindow* iParentWin;

	CTBlankWindow* iChildWin;

	TBool iSecondaryClient;

	// For AutoFocus test

	CTWindowGroup* iGroupWinAutoFocus1;

	CTWindowGroup* iGroupWinAutoFocus2;

	CTBlankWindow* iWinAutoFocus1;

	CTBlankWindow* iWinAutoFocus2;

	TSize iWinSizeAutoFocus1;

	TPoint iWinPosAutoFocus1;

	TSize iWinSizeAutoFocus2;

	TPoint iWinPosAutoFocus2;

	TBool iExpectNonAdvancedPointerEvents;

	};

class RMultiPointerAnim : public RTestAnim

	{

public:

	static RMultiPointerAnim* NewL(RWindowBase* aWin, RAnimDll* aDll);

	RMultiPointerAnim(RAnimDll* aDll) :RTestAnim(*aDll) {}

	TInt AddExpectedAnimPointerEvent(TRawEvent::TType aType, TPoint aPos, TInt aZ, TUint aModifier, TUint8 aPointerNumber, TBool aEat = ETrue);

	};

/*

 * CTWsGraphicsBase derived class which implements RunTestCaseL pure virtual.

 * Runs all the testcases for multi poniter events.

 * For each test case it creates CTMultiPtrEventClient object and creates a nested activescheduler

 * Calls NextSetOfEventsL() which in turn calls respective tests depending upong the testcase number

 * For each test simulates the events and adds the same event to CTMultiPtrEventBuffer

 * When all the tests for a particular testcase completes stops activescheduler

 * Repeats the same for all testcases

 */ 

class CTMultiPtrEventTest : public CTWsGraphicsBase

	{

public:

	CTMultiPtrEventTest(CTestStep* aStep);

	~CTMultiPtrEventTest();

	void ConstructL();

	void NextSetOfEventsL();

	void Failed();

	// Functions for simulating events, which use UserSvr::AddEvent

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

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

	void SimulatePointerDownUp(TInt aX, TInt aY, TInt aZ, TUint8 aPointerNumber);

	// Functions for adding event, calls the client's AddExpectedPointer

	void AddExpectedPointerEvent(TPointerEvent::TType aType, TPoint aPos, TUint8 aPointerNumber, TUint aHandle = 0);

	void AddExpectedPointerEvent(TPointerEvent::TType aType, TPoint aPos, TInt aZ, TUint aModifier, TUint8 aPointerNumber, TUint aHandle = 0, TBool aSecondaryClient = EFalse);

	void AddExpectedPointerDownUp(TPoint aPos, TInt aZ, TUint8 aPointerNumber);

	void AddExpectedWsEvent(TEventCode aType, TBool aSecondaryClient = EFalse, TInt aPointerNumber = 0, TUint aHandle = 0);

	void AddExpectedMultiPtrClickEvent(TPointerEvent::TType aType, TPoint aPos, TInt aZ, TUint aModifier, TUint8 aPointerNumber, TUint aHandle = 0);

	void AddExpectedMultiPtrClickOtherEvent(TPointerEvent::TType aType, TPoint aPos, TInt aZ, TUint aModifier, TUint8 aPointerNumber, TUint aHandle);

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

	void AddExpectedKeyDownUp(TInt aScanCode, TInt aCode=0, TInt aRepeats=0, TUint aModifiers=0);	

	// Supplementary function for tests

	void TestDragForMultiPointer(TPoint aPtrPos, TInt aPrValue, TUint8 aPointerNumber);

	void SimulateAndAddLoneUpEvents(TInt aNumSimulation, TInt aNumAddition, TPoint aPos);

	void TestAndDisplayAnimError();

	void GetRemainingEventsFromSecondaryClient();

	void TestAndDisplayPtrClickError();

	void CreatePointerClickPluginL();

	void SetAutoFlush();

	void ResetFlushStopAS();

	void TestFilteringForMultiPointer(TBool aFiltering);

	void TestGrabbingForMultiPointer(TBool aGrabbing);

	void CreateGroupWinL();

	void DeleteGroupWin();

	void CreateGroupWinForCapturingL();

	void DeleteGroupWinForCapturing();

	void CreateAnimDllAndAnimL();

	void DestroyAnimDllAndAnim();

	void TestCloseProximityHighPressureAPIsL();

	void TestCapturingForMultiPointer(TBool aAllGroups);

	void SetThresholdValues(TInt aEnterCloseProx, TInt aExitCloseProx, TInt aEnterHighPres, TInt aExitHighPres);

	void NegativeTestingOfProximityPressureAPIsL();

	void TestErrorCodeL(TInt aExpErrCode, TInt aActualErrCode);

	void SimulateProximityAndPressureEvents(TInt aCloseProxEnterValue, TInt aCloseProxExitValue, TInt aHighPresEnterValue, TInt aHighPresExitValue);

	void SetDefaultScreenMode();

	TPoint GetPointerPostionOnRotatedMode(TPoint aPointerPos, CFbsBitGc::TGraphicsOrientation aRotation);

	void LogEventsAdded();

	// All tests

	void MultiPointerEvents();

	void PurgingMultiPointerEvents();

	void MultiPointerEventsForAnimsL();

	void MultiClientMultiPointerEvents();

	void MultiPointerEventsForPointerClickL();

	void MultiPointerEventsInDiffScreenModes();

	void FilteringMultiPointerEvents();

	void GrabbingMultiPointerEvents();

	void VirtualKeyBoardForMultiplePointers();

	void DoubleClickForMultiplePointers();

	void MultiPointerOutOfRangeEvents();

	void AutoForeGroundForMultiplePointersL();

	void EmulationRulesForMultiplePointers();

    void CloseProximityAndHighPressureEventsL();

	void OutOfBoundValueTesting();

	void CapturingMultiPointerEvents();

	void NegativeTestsForProximityPressureEventsL();

	void PointerRepeatEventForMultiplePointers();

	void SetExpectNonAdvancedPointerEvents(TBool aSecondaryClient=EFalse);

	void ClearExpectNonAdvancedPointerEvents(TBool aSecondaryClient=EFalse);

protected:

	void RunTestCaseL(TInt aCurTestCase);

private:

	void RunTestsL();

private:

	TInt iEventSet;			// Set of events for one particular test case

	TBool iFailed;

	TBool iActiveSchedulerStarted;

	TBool iTheClientFlush;

	TBool iClientFlush;

	TBool iSecClientFlush;

	TSize iPhysicalScreenSize;

	TRect iOrigPtrCursorArea;

	TUint iPointerNumber;

	TInt iMaxDevPointers;

	TInt iMaxUiPointers;

	TInt iMaxPressure;

	TInt iPressureStep;

	TInt iMaxProximity;

	TInt iProximityStep;

	TInt iEnterCloseProximityThreshold;

	TInt iExitCloseProximityThreshold;

	TInt iEnterHighPressureThreshold;

	TInt iExitHighPressureThreshold;	

	CTMultiPtrEventClient *iMultiPtrEventClient;

	CTMultiPtrEventClient *iSecMultiPtrEventClient;

	RAnimDll* iAnimDll;

	RMultiPointerAnim* iAnim;

	RSoundPlugIn iClick;

	TBool iPtrPluginLoaded;

	RChunk iChunk;

	RHeap* iHeap;

	TAny* iErrDesc;

	TInt iCurrentScreenMode;

	TBool iChangeScreenMode;

	CTWindowGroup* iGroupWinForEmul;

	CTBlankWindow* iWinForEmul;

	CTWindowGroup* iGroupWinForCapturing;

	CTBlankWindow* iWinForCapturing;

	TInt iYOffset;

	};

class CTMultiPtrEventTestStep : public CTGraphicsStep

	{

public:

	CTMultiPtrEventTestStep();

protected:

	//from CTGraphicsStep

	virtual CTGraphicsBase* CreateTestL();

	};

_LIT(KTMultiPtrEventTestStep, "TMultiPtrEventTest");

#endif /*TMULTIPTREVENT_H_*/