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

// Auto test Animated DLL functions

// 

//

#include <e32std.h>

#include <w32std.h>

#include <w32adll.h>

#include <bitstd.h>

#include "AUTODLL.H"

#include "TAnimDraw.h"

#include "eventdd.h"

#include <gdi.h>

#include <fbs.h>

union TAnimArgUnion

	{

	const TAny* any;

	const TBool* Bool;

	const TInt* Int;

	const TPoint* Point;

	const TSize* Size;

	const TRect* Rect;

	const TSpriteMemberInfo* SpriteMemberInfo;

	const TShadowDrawTest* ShadowDrawTest;

	const TDrawTestScreen* DrawTestScreen;

	const TSyncTests* SyncTests;

	const TTimeChangeTest* TimeChangeTest;

	const TAnimRawEvent* AnimRawEvent;

	const TWindowGroupInfoParms* WindowGroupInfoParms;

	const TSetOrdinalParms* SetOrdinalParms;

	const TFrameData* FrameData;

	const TRawEvent* RawEvent;

	};

class CPanicAnim : public CWindowAnim

	{

	enum TSyncState

		{

		ESyncStateNull,

		ESyncStateStarting,

		ESyncStateCounting,

		ESyncLeave,

		ESyncStateTimeChange1,

		ESyncStateTimeChange2,

		ESyncStateTimeChange3

		};

	enum {ESyncCount=8};

public:

	~CPanicAnim();

	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

	virtual void Animate(TDateTime *aDateTime);

	virtual void Redraw();

	virtual void Command(TInt aOpcode, TAny *aArgs);

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	virtual void FocusChanged(TBool aState);

	//Pure virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

private:

	void StartSyncTest(MAnimGeneralFunctions::TAnimSync aSync);

	void StartTimeChangeTest();

	void DoLeaveInActiveCallback();

	static TInt LeaveInActiveCallback(TAny *aThis);

private:

	TRequestStatus *iStatusPtr;

	TRequestStatus *iStatusPtr2;

	TTime iTime;

	TInt iSyncCount;

	TSyncState iSyncState;

	MAnimGeneralFunctions::TAnimSync iSyncMode;

	TBool iLeaveInRedraw;

	CIdle* iActivePanicIdle;

	};

class CPanicAnim2 : public CWindowAnim

//

// Simply panics in the ConstructL()

//

	{

public:

	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

	virtual void Animate(TDateTime *aDateTime);

	virtual void Redraw();

	virtual void Command(TInt aOpcode, TAny *aArgs);

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	virtual void FocusChanged(TBool aState);

	//Pure virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

	};

class CAutoAnim3 : public CWindowAnim

//

// test drawing/redrawing

//

	{

public:

	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

	virtual void Animate(TDateTime *aDateTime);

	virtual void Redraw();

	virtual void Command(TInt aOpcode, TAny *aArgs);

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	virtual void FocusChanged(TBool aState);

	void Draw(const TRect &aRect);

	void DrawTestScreenL(const TDrawTestScreen* aParams);

	//Pure virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

private:

	TRequestStatus *iStatusPtr;

	CFbsFont *iFont;

	TRect iRect;

	TRect iBaseRect;

	TInt iMode;

	};

class CAutoAnimScrBack : public CWindowAnim

//

// test anim drawing behind a backed up window

//

	{

public:

	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

	virtual void Animate(TDateTime *aDateTime);

	virtual void Redraw();

	virtual void Command(TInt aOpcode, TAny *aArgs);

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	virtual void FocusChanged(TBool aState);

	void Draw();

	//Pure virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

private:

	TRect iRect;

	TInt iMode;

	};

class CTestSpriteAnim : public CSpriteAnim

	{

public:

	virtual void ConstructL(TAny *aArgs);

	virtual void Animate(TDateTime *aDateTime);

	virtual void Command(TInt aOpcode, TAny *aArgs);

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	//Pure virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

private:

	TBool CheckMember(const TSpriteMemberInfo& aMemInfo);

	void DrawMemberL(TInt aMember);

	void DrawMemberL();

	};

/**

Used by CAnimTimer below

*/

class MAnimTimerObserver

    {

public:

    virtual void DisplayNextFrameL()=0;

    };

/**

This class is used by CTestFreeTimerAnim to determine when to swap the current frame with the next one.

*/

class CAnimTimer : public CTimer

    {

public:

    ~CAnimTimer();

    static CAnimTimer* NewL(MAnimTimerObserver& aObserver);

    void RunL();

private:

    CAnimTimer(MAnimTimerObserver& aObserver);

    void ConstructL();

private:

    MAnimTimerObserver& iAnim;

    };

class CTestFreeTimerAnim : public CFreeTimerWindowAnim, public MAnimTimerObserver

	{

public:

    //from CBase 

    ~CTestFreeTimerAnim();

	//from CAnim

	void Animate(TDateTime *aDateTime);

	void Command(TInt aOpcode, TAny *aArgs);

	TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	//from CWindowAnim 

    void ConstructL(TAny *aArgs, TBool aHasFocus);

    void Redraw();

    void FocusChanged(TBool aState);

	//from MEventHandler

	TBool OfferRawEvent(const TRawEvent &aRawEvent);

private:

    void DisplayNextFrameL();

private:

    CAnimTimer* iTimer;

    TInt iFrameTime;

    TRgb iColour;

    TRect iRect;    

	};

class CEventTestAnimBase : public CWindowAnim

	{

	enum {EEventBufferSize=40};

public:

	virtual ~CEventTestAnimBase();

	//Pure virtual functions from CAnim

	virtual void Animate(TDateTime *aDateTime);

	virtual void Command(TInt aOpcode, TAny *aArgs);

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	//Pure virtual functions from CWindowAnim

	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

	virtual void Redraw();

	virtual void FocusChanged(TBool aState);

	//Pure virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

protected:

	void Fail();

	TBool IsIgnorableEvent(const TRawEvent& aRawEvent) const;

	TBool GetNextExpectedEvent(TAnimRawEvent& aRawEvent);

	TBool CompareEvents(const TRawEvent& aExpectedEvent, const TRawEvent& aActualEvent) const;

	TBool HandleRecursiveEvent(const TRawEvent& aRawEvent);

	TInt Error() const;

	TInt EventCount() const;

	void ResetEventCount();

	TInt TotalExpectedEvents() const;

	TInt AddEvent(const TAnimRawEvent* event);

private:

	virtual TInt AddExpectedEvent(const TAnimRawEvent* event)=0;

private:

	CCirBuf<TAnimRawEvent> iExpectedEvents;

	TInt iError;

	TInt iEventCount;

	};

class CEventTestAnim : public CEventTestAnimBase

	{

public:

	~CEventTestAnim();

	//Pure virtual functions from CWindowAnim overridden in CEventTestAnimBase

	void ConstructL(TAny* aArgs,TBool aHasFocus);

	//Pure virtual functions from CAnim overridden in CEventTestAnimBase

	TInt CommandReplyL(TInt aOpcode,TAny* aArgs);

	void Command(TInt aOpcode,TAny* aArgs);

private:

	TInt UnloadDeviceDriver();

	//Pure virtual function from CEventTestAnimBase

	TInt AddExpectedEvent(const TAnimRawEvent* event);

private:

	TBool iDevDriverLoaded;

	REventDD iLdd;

	};

class CEventPostingAnim : public CEventTestAnimBase

	{

public:

	~CEventPostingAnim();

	//Virtual functions from CEventTestAnimBase

	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

	//Virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

private:

	//Pure virtual function from CEventTestAnimBase

	virtual TInt AddExpectedEvent(const TAnimRawEvent* event);

	};

class CRemovableAnim : public CEventTestAnimBase

	{

public:

	~CRemovableAnim();

	//Virtual functions from CEventTestAnimBase

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

private:

	//Pure virtual function from CEventTestAnimBase

	virtual TInt AddExpectedEvent(const TAnimRawEvent* event);

private:

	TInt iLifetime;

	};

class CTimerTestAnim : public CWindowAnim

	{

public:

	~CTimerTestAnim();

	//Pure virtual functions from CAnim

	virtual void Animate(TDateTime *aDateTime);

	virtual void Command(TInt aOpcode, TAny *aArgs);

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	//Pure virtual functions from CWindowAnim

	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

	virtual void Redraw();

	virtual void FocusChanged(TBool aState);

	//Pure virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

private:

	TInt iTimerCount;

	TBool iExpectingTicks;

	TBool iFail;

	};

class CWinFunctionTestAnim : public CWindowAnim

	{

	//enum {EEventBufferSize=40};

public:

	~CWinFunctionTestAnim();

	//Pure virtual functions from CAnim

	virtual void Animate(TDateTime *aDateTime);

	virtual void Command(TInt aOpcode, TAny *aArgs);

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	//Pure virtual functions from CWindowAnim

	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

	virtual void Redraw();

	virtual void FocusChanged(TBool aState);

	//Pure virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

private:

	MAnimGeneralFunctionsWindowExtension* iWinFunctions;

	};

class CNotificationTestAnim : public CWindowAnim

	{

public:

	CNotificationTestAnim();

	~CNotificationTestAnim();

	//Pure virtual functions from CAnim

	virtual void HandleNotification(const TWsEvent& aEvent);

	virtual void Animate(TDateTime *aDateTime);

	virtual void Command(TInt aOpcode, TAny *aArgs);

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	//Pure virtual functions from CWindowAnim

	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

	virtual void Redraw();

	virtual void FocusChanged(TBool aState);

	//Pure virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

private:

	TFixedArray<TBool,2> iDSA;

	TBool iHeartbeatState;

	TBool iScreenDeviceChanged;

	TTime iLastAnimTime;

	};

class CTransAnim : public CWindowAnim

//

// Test drawing/redrawing in Transparent window.

//

	{

public:

	//Implementaion for pure virtual functions from CAnim

	void ConstructL(TAny* aArgs, TBool aHasFocus);

	void Animate(TDateTime* aDateTime);

	void Redraw();

	void Command(TInt aOpcode, TAny* aArgs);

	TInt CommandReplyL(TInt aOpcode, TAny* aArgs);

	void FocusChanged(TBool aState);

	TBool OfferRawEvent(const TRawEvent &aRawEvent);

private:

	CFbsFont* iFont;

	TRect iRect;

	TInt iMode;

	TInt iDraw;

	TRgb iColor;

	TInt iCount;

	};

class CTestHandlerAnim : public CWindowAnim

	{

	public:

		~CTestHandlerAnim();

		void ConstructL(TAny* aArgs, TBool aHasFocus);

		void Redraw();

		void FocusChanged(TBool aState);

		TInt CommandReplyL(TInt aOpcode, TAny* aArgs);

		void Command(TInt aOpcode, TAny* aArgs);

		void Animate(TDateTime* aDateTime);

		TBool OfferRawEvent(const TRawEvent &aRawEvent);

	private:

	};

class CCoverageAnim : public CWindowAnim

/**

 This class adds functional coverage to CWsAnimGc. 

 The actual work is handled by the 'Draw' method which calls

 each method in turn.

 Mostly copied from CAutoAnimScrBack and CAutoAnim3.

 @SYMTestCaseID 

 @SYMPREQ 1841 Add Coverage tests.

 @SYMTestCaseDesc  Functional coverage.

 @SYMTestActions Run functional coverage test on CWsAnimGc.

 */

	{

public:

	~CCoverageAnim();

	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

	virtual void Animate(TDateTime *aDateTime);

	virtual void Redraw();

	virtual void Command(TInt aOpcode, TAny *aArgs);

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	virtual void FocusChanged(TBool aState);

	void Draw();

	//Pure virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

private:

	TRect iRect; /** rectangle used for all draw ops that require one */

	CFbsFont* iFont;

	};

class CMultiPointerAnim : public CWindowAnim

	{

	enum {EEventBufferSize=40};

public:

	virtual ~CMultiPointerAnim();

	//Pure virtual functions from CAnim

	virtual void Animate(TDateTime *aDateTime);

	virtual void Command(TInt aOpcode, TAny *aArgs);

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

	//Pure virtual functions from CWindowAnim

	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

	virtual void Redraw();

	virtual void FocusChanged(TBool aState);

	//Pure virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

protected:

	TInt AddEvent(const TAnimRawEvent* aEvent);

	TBool CompareEvents(const TRawEvent& aExpectedEvent, const TRawEvent& aActualEvent);

private:

	CCirBuf<TAnimRawEvent> iExpectedEvents;

	TBuf<255> iErrorDes;

	TInt iEventCount;

	TInt iError;

	};

class CTestAnimDll : public CAnimDll

	{

public:

	CAnim *CreateInstanceL(TInt aType);

private:

	};

/*#if defined(__WINS__)

#pragma data_seg(".E32_UID")

__WINS_UID(0, KWservAnimDllUidValue, 0)

#pragma data_seg()

#endif*/

EXPORT_C CAnimDll *CreateCAnimDllL()

	{

	return(new(ELeave) CTestAnimDll());

	}

// Panic Tests //

void CPanicAnim::ConstructL(TAny *, TBool )

	{

	iWindowFunctions->SetRect(TRect(0,0,1,1));

	iFunctions->SetSync(MAnimGeneralFunctions::ESyncSecond);

	if (iFunctions->Sync()!=MAnimGeneralFunctions::ESyncSecond)

		User::Leave(KErrGeneral);

// Check the anim time is not ahead of and not more than 2 secs behind the system time

	TTime now;

	now.UniversalTime();

	TDateTime dt=now.DateTime();

	TDateTime adt=iFunctions->SystemTime();

	if (adt.Day()!=dt.Day())

		User::Leave(KErrGeneral);

	iFunctions->SetSync(MAnimGeneralFunctions::ESyncNone);

	if (iFunctions->Sync()!=MAnimGeneralFunctions::ESyncNone)

		User::Leave(KErrGeneral);

	}

CPanicAnim::~CPanicAnim()

	{

	delete iActivePanicIdle;

	}

void CPanicAnim::Animate(TDateTime *aDateTime)

	{

	switch(iSyncState)

		{

		case ESyncStateNull:

			break;

		case ESyncStateStarting:

			iTime=iFunctions->SystemTime();

			iSyncState=ESyncStateCounting;

			iSyncCount=0;

			break;

		case ESyncStateCounting:

			if (aDateTime)

				{

				TTimeIntervalSeconds interval;

				TTime(*aDateTime).SecondsFrom(iTime, interval);

				iSyncCount=interval.Int();

				}

			else

				iSyncCount++;

			if (iSyncCount==ESyncCount)

				{

				TTimeIntervalMicroSeconds minInterval(0);

				TTimeIntervalMicroSeconds maxInterval(0);

				iSyncState=ESyncStateNull;

				switch(iSyncMode)

					{

					case MAnimGeneralFunctions::ESyncSecond:

						minInterval=iSyncCount*1000000-100000;

						maxInterval=iSyncCount*1000000+100000;

						break;

					default:;

					}

				TTime time(iFunctions->SystemTime());

				TTimeIntervalMicroSeconds interval=time.MicroSecondsFrom(iTime);

				TInt ret=KErrNone;

				if (interval<minInterval || interval>maxInterval)

					ret=KErrGeneral;

				iFunctions->Client().RequestComplete(iStatusPtr,ret);

				}

			break;

		case ESyncLeave: