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

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#ifndef __TDIRECTA_H__

#define __TDIRECTA_H__

#include "AUTO.H"

#include <e32msgqueue.h>

#include <time.h>

#include "TGraphicsHarness.h"

//#define LOGGING

class CColorAnimation;

class CScrollText;

class CScrollingTextDrawer;

class CDirectScreenAccessOld;

struct TDirectThreadParam

	{

	TRect iRect;

	TInt iScreenNumber;

	TBool iIsInFront;

	};

class MAnimCallBacks

	{

public:

	virtual void LogLeave(TInt aErr)=0;

	virtual void Fail()=0;

	virtual void Finished(TInt aId)=0;

	virtual TDisplayMode DisplayMode(TInt aId)=0;

	virtual TRgb BrushColorL(TInt aId,TInt& aColor,TBool& aFinished)=0;

	virtual TInt TimerInterval(TInt aId)=0;

	virtual void FailedReStart(TInt aId,TInt aReason)=0;

	virtual TInt SlowStopping(TInt aId,TInt aCount)=0;

	virtual void Log(const TText8* aFile, TInt aLine, TInt aSeverity,const TDesC& aString)=0;

public:

	CTBlankWindow* iCallBackWin;

	};

class CTDirect : public CTWsGraphicsBase, public MAbortDirectScreenAccess, public MAnimCallBacks

	{

public:

	enum

		{

		eDirectNumFrames=10

		};

	enum

		{

		eDirectControlSem=0x01,

		eDirectWindowSem=0x02,

		eFontSet=0x04,

		eMultiAnim=0x08,

		};

public:

	CTDirect(CTestStep* aStep);

	~CTDirect();

	void ConstructL();

	TBool DrawFrame();

	TBool Restart();

	void ChangeToNextScreenModeL();

	void ChangeScreenScale();

	//The Tests

	TestState AnimateWindowL();

	TestState AnimationDiesL();

	TestState PackagingClassL();

	TestState MultipleL();

	TestState FailCodesL();

	TestState ScrolingText1L();

	TestState RClassL();

	TestState ScrolingText2L();

	TestState ScrolingText3L();

	TestState ScrolingText4L();

	TestState DefectFix_KAA_5J3BLW_L();

	TestState KillAnimationL();

	TestState DSAWithScreenModeOffset1L();

	TestState DSAWithScreenModeOffset2L();

	TestState WindowPoistionRelativeToScreenL();

	TestState ScreenModeScalingTestL();

	TestState ScreenModeTestForScalingL();

	TestState MultipleDSAsOnSameWindowL();

	TestState TemporaryDeadlockL();

	TestState RegionTrackingOnlyNotificationsL(TUint aId);

	TestState MixDsaAndRegionTrackingOnlyL(TBool aWhoExitsLast);

	TestState TryDifferentSupportedModesL();

protected:

//from 	CTGraphicsStep

	virtual void RunTestCaseL(TInt aCurTestCase);

private:

	void ConstrucBlankWindowL();

	void ScanTypeFacesL();

	void InitialiseAnimationL();

	void DestroyAnimation();

	void ResetScreenSizeMode();

	void StartDirect();

	void SignalWindow();

	void ModeSwitch();

	void ScrolingTextL(TInt aId,TRect aWinRect,TBool aStartThread,TInt aScreenMode=0);

	void AnimTestL(TInt aId,TRect aWinRect,CTWinBase& aParent);

	//Pure virtual function from MAbortDirectScreenAccess

	void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);

	//Pure virtual functions from MAnimCallBacks

	void LogLeave(TInt aErr);

	void Fail();

	void Finished(TInt aId);

	void DeleteMoveWindow();

	void DeleteScroll();

	TDisplayMode DisplayMode(TInt aId);

	TRgb BrushColorL(TInt aId,TInt& aColor,TBool& aFinished);

	TInt TimerInterval(TInt aId);

	void FailedReStart(TInt aId,TInt aReason);

	TInt SlowStopping(TInt aId,TInt aCount);

	void Log(const TText8* aFile, TInt aLine, TInt aSeverity,const TDesC& aString);

	void SetScreenMode(TInt aMode,TPixelsAndRotation& aPixelsAndRotation);

	void CreateAnimForScreenModeL(TInt aAnimIndex,CTWinBase& aParent,TRect aRect,TInt aId);

	void BlankTopClientWindowL(CTBlankWindow& aBlankWindow,TRect aRect);

	void TestDifferentOriginAndScaleL(TSizeMode &aMode,TPoint aOrigin);

	void CheckForTemporaryDeadlock();

private:

	CProcess* iProcess;

	CProcess* iMoveWin;

	RSemaphore iControlSem;

	RMsgQueueBase iControlQueue;

	RSemaphore iWinSem;

	TRequestStatus iThreadStatus;

	TUint iFlags;

	CTBlankWindow* iWin;

	CTBlankWindow* iWin2;

	CFbsScreenDevice* iScrDev;

	CFbsBitGc* iGc;

	CFont* iFont;

	CPeriodic* iTimer;

	CIdle* iRestart;

	CDirectScreenAccessOld* iDirect;

	RRegion* iDrawingRegion;

	TSize iScrSize;

	TRect iDrawRect;

	TInt iDrawHeight;

	TInt iFrameNo;

	TInt iLastTextWidth;

	TInt iLastMaxTextWidth;

	TInt iFrameToSignalAfter;

	TBool iDelay;

	TBool iCancelNext;

	TBool iWindowDead;

	CColorAnimation* iAnim;

	CColorAnimation* iAnims[13];

	TInt iCount;

	CScrollText* iScroll;

	TInt iCycles;

	TScreenModeEnforcement iModeBackup;

	TThreadStartUp iFirstFunction;

	TInt iNumThreadHandles;

	CTBlankWindow* iBlankTopClientWin1;

	CTBlankWindow* iBlankTopClientWin2;

	CPeriodic* iChangeScreenModeTimer;

	TInt iCurrentMode;

	TInt iNumOfModes;

	TPoint iCurrentScreenModeOrigin;

	TSize iCurrentScreenModeScale;

	TInt iNumAnimation;

	TSizeMode iModeData;

	CPeriodic* iScreenModeTimer;

	TInt iIsScalingSupported;

	TInt iNumOfCallBack;

	TBool iTestJustFailed;

	TBool iTestJustCompleted;

	TInt iState;

	TBool iNextFrameFinished;

	TBool iPackagingFinished;

	TBool iTimerRunning;

	};

class CDirectScreenAccessOld : public CActive

	{

public:

	static CDirectScreenAccessOld* NewL(RWsSession& aWs,MAbortDirectScreenAccess& aAborter);

	~CDirectScreenAccessOld();

	TInt Request(RRegion*& aRegion, RWindowBase& aWindow);

private:

	inline CDirectScreenAccessOld(RWsSession& aWs,MAbortDirectScreenAccess& aAborter)

		: CActive(RDirectScreenAccess::EPriorityVeryHigh), iDirectAccess(aWs), iAborter(aAborter) {}

	void ConstructL();

	//Pure virtual functions from CActive

	void DoCancel();

	void RunL();

private:

	RDirectScreenAccess iDirectAccess;

	MAbortDirectScreenAccess& iAborter;

	TBool iAborting;

	};

class CColorAnimation : public CBase, public MDirectScreenAccess

	{

public:

	enum

		{

		eStopNow=EFalse,

		eStopDelayed=ETrue,

		eAbort=2,

		eAbortAll,

		};

public:

	static TInt DrawColorL(TAny* aAnimation);

	static TInt IdlingL(TAny* aAnimation);

	static CColorAnimation* NewL(TInt aScreenNumber,TInt aId,MAnimCallBacks& aCallBack,CTWinBase& aParent,TRect aExtent,TBool aStart,TBool aRegionTrackingOnly = EFalse);

	inline CColorAnimation(TInt aScreenNumber,TInt aId,MAnimCallBacks& aCallBack) :iId(aId), iCallBack(aCallBack), iScreenNumber(aScreenNumber) {}

	~CColorAnimation();

	void ConstructL(CTWinBase& aParent,TRect aExtent,TBool aRegionTrackingOnly,TInt aTypeWindow=0,TInt aSingleWinForMultipleDSA=0);

	void StartL(TBool aChildWindow=EFalse);

	void StartOrPanic();

	void Stop();

	void BringWindowToFront();

	void ChangeModeL(TDisplayMode aMode);

	TBool inline IsTimerActive() {return iTimer->IsActive();}

	inline MAnimCallBacks& CallBack() { return iCallBack; }

	TPoint AbsoluteWindowPosition(TInt aWindowId=0);

	inline CDirectScreenAccess* GetDrawer();

	void FinishTest();

	TBool TestGcAndScreenDeviceValues();

	//inline TBool IsReadyToAbort(){return (iDrawer->iStatus!=KRequestPending);}

protected:

	void DrawColorL();

	void IdlingL();

	/*pure virtual function from MAbortDirectScreenAccess*/

	void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);

	/*pure virtual function from MDirectScreenAccess*/

	void Restart(RDirectScreenAccess::TTerminationReasons aReason);

private:

	TInt iId;

	CTBlankWindow* iWindow;

	CTBlankWindow* iWindow2;

	TSize iWinSize;

	CDirectScreenAccess* iDrawer;

	CPeriodic* iTimer;

	MAnimCallBacks& iCallBack;

	TInt iColor;

	TInt iCount;

	TUint iIdling;

	TInt iScreenNumber;

	TInt iSingleWinForMultipleDSA;

	TBool iRegionTrackingOnly;

	};

class CScrollingTextDrawer : public CBase

	{

public:

	static CScrollingTextDrawer* NewL(TInt aScreenNumber,CFbsScreenDevice*& aDevice,CFbsBitGc& aGc);

	~CScrollingTextDrawer();

	inline void SetScrollJump(TInt aJump) {iJump=aJump;}

	void SetBottomOfTest(TInt aBottom);

	void Scroll();

private:

	inline CScrollingTextDrawer(CFbsScreenDevice*& aDevice,CFbsBitGc& aGc) : iDevice(aDevice), iGc(&aGc) {}

	void ConstructL(TInt aScreenNumber);

	void CreateFontL();

private:

	CFbsScreenDevice*& iDevice;

	CFbsScreenDevice* iFontDevice;

	CFbsBitGc* iGc;

	CFont* iFont;

	TBuf<32> iText;

	TRect iDrawRect;

	TInt iDrawHeight;

	TInt iCharWidth;

	TInt iFirstChar;

	TInt iJump;

#if defined(LOGGING)

	RWsSession iWs;

#endif

	};

class CScrollText : public CBase, public MDirectScreenAccess

	{

public:

	static TInt DrawText(TAny* aAnimation);

	static CScrollText* NewL(TInt aScreenNumber,TInt aId,CTWindowGroup& aParent,TInt aScrollJump,TBool aStart=EFalse);

	inline CScrollText(TInt aId,TInt aScrollJump,TInt aScreenNumber) :iId(aId), iScrollJump(aScrollJump), iScreenNumber(aScreenNumber) {}

	~CScrollText();

	void ConstructL(CTWindowGroup& aParent);

	void StartL();

	void Stop();

	void ContinueL();

	inline TBool IsRunning() {return iTimer->IsActive();}

	inline void SetCountDown(TInt aCountDown) {iAbortCountDown=aCountDown; iCounting=ETrue;}

	inline void SetBottomOfTest(TInt aBottom) {iTextDraw->SetBottomOfTest(aBottom);}

private:

	void ScrollText();

	void DoContinueL();

	/*pure virtual function from MAbortDirectScreenAccess*/

	void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);

	/*pure virtual function from MDirectScreenAccess*/

	void Restart(RDirectScreenAccess::TTerminationReasons aReason);

private:

	TInt iId;

	CTBlankWindow* iWindow;

	TSize iWinSize;

	CDirectScreenAccess* iDrawer;

	CScrollingTextDrawer* iTextDraw;

	CPeriodic* iTimer;

	TInt iScrollJump;

	TBool iCounting;

	TInt iAbortCountDown;

	TInt iScreenNumber;

	};

/**

 A simple class based on CScrollText constructs a blank window that has

 a blank window child, used for functional coverage testing of CWsClientWindow

 */

class CWindowWithChild : public CBase, public MDirectScreenAccess

	{

public:

	static CWindowWithChild* NewL(TInt aScreenNumber, CTWindowGroup& aParent,TBool aStart=EFalse);

	inline CWindowWithChild(TInt aScreenNumber) : iScreenNumber(aScreenNumber) {}

	~CWindowWithChild();

	void ConstructL(CTWindowGroup& aParent);

	void StartL();

	void Stop();

	void ContinueL();

	inline TBool IsRunning() {return iRunning;}

	void PerformCoverageCalls();

	RWindow *ChildWindow()    {return iChildWindow->Win();}

private:

	void DoContinueL();

	/*pure virtual function from MAbortDirectScreenAccess*/

	void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);

	/*pure virtual function from MDirectScreenAccess*/

	void Restart(RDirectScreenAccess::TTerminationReasons aReason);

private:

	CTBlankWindow* iWindow;

	CTWin * iChildWindow;

	TSize iWinSize;

	CDirectScreenAccess* iDrawer;

	TInt iScreenNumber;

	TBool iRunning;

	};

class CWsBase : public CBase

	{

public:

protected:

	~CWsBase();

	void ConstructL(TInt aScreenNumber,TInt aHandle);

	void CreateBlankWindowL(RBlankWindow& iWin,TInt aHandle);

protected:

	RWsSession iWs;

	CWsScreenDevice *iScrDev;

	RWindowGroup iGroup;

	};

class CAnimating : public CWsBase, public MAbortDirectScreenAccess

	{

public:

	static TInt StartLC(TAny* aScreenNumber);

	//static CAnimating* NewLC();

	void DrawFrame();

	/*pure virtual function from MAbortDirectScreenAccess*/

	void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);

private:

	void ConstructL(TInt aScreenNumber);

	~CAnimating();

	void StartAnimatingL();

private:

	RSemaphore iControlSem;

	RMsgQueueBase iControlQueue;

	TBool iSemCreated;

	RBlankWindow iWindow;

	CFbsScreenDevice* iScrDev;

	CFbsBitGc* iGc;

	TSize iScrSize;

	CDirectScreenAccessOld* iDirect;

	RRegion* iDrawingRegion;

	CPeriodic* iTimer;

	TInt iColor;

	};

class CMoveWindow : public CWsBase

	{

public:

	static TInt StartLC(TAny* aScreenNumber);

	static TInt StateChange(TAny* aMoveWin);

	static TInt FlipChange(TAny*);

	//Call Backs

	void MoveWindow();

private:

	inline static CMoveWindow* Cast(TAny* aMoveWin) {return STATIC_CAST(CMoveWindow*,aMoveWin);}

	~CMoveWindow();

	void ConstructL(TInt aScreenNumber);

	void CreateTimerL();

	void StateChange();

	void ToggleDisplayMode();

	void FlipChange();

private:

	CPeriodic* iFlipTimer;

	CPeriodic* iStateTimer;

	CPeriodic* iTimer;

	CWsScreenDevice* iDevice;

	RBlankWindow iWindow;

	TDisplayMode iDisplayMode;

	RBackedUpWindow iBackUpWin;

	CWindowGc* iGc;

	TRect iBounceArea;

	TSize iScrSize;

	TPoint iTl;

	TSize iSize;

	TSize iDelta;

	TInt iStateCountDown;

	TInt iNumOfModes;

	TInt iCurrentMode;

	};

class CBugFixColorAnimation : public CColorAnimation

	{

public:

	static CBugFixColorAnimation* NewL(TInt aScreenNumber,TInt aId,MAnimCallBacks& aCallBack,CTWindowGroup& aParent,TRect aExtent,TBool aStart=EFalse);

	~CBugFixColorAnimation();

	inline void Started() { iSem.Signal(); }

private:

	CBugFixColorAnimation(TInt aScreenNumber,TInt aId,MAnimCallBacks& aCallBack);

	void ConstructL(CTWindowGroup& aParent,TRect aExtent);

private:

	/*pure virtual function from MAbortDirectScreenAccess*/

	void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);

	/*pure virtual function from MDirectScreenAccess*/

	void Restart(RDirectScreenAccess::TTerminationReasons aReason);

private:

	CProcess* iThread;

	CIdle* iTestFailed;

	TRect iAnimRect;

	TDirectThreadParam iThreadParam;

	RSemaphore iSem;

	};

class CRegionTrackingOnly : public CColorAnimation

	{

public:

	static CRegionTrackingOnly* NewL(TInt aScreenNumber,TInt aId,MAnimCallBacks& aCallBack,CTWindowGroup& aParent,TRect aExtent,TBool aStart,TBool aOpenWindowInFrontDsa);

	void ConstructL(CTWindowGroup& aParent,TRect aExtent,TBool aOpenWindowInFrontDsa);

	~CRegionTrackingOnly();

	inline void Started() { iSem.Signal(); }

private:

	CRegionTrackingOnly(TInt aScreenNumber,TInt aId,MAnimCallBacks& aCallBack);

	/*Overriding of bases class virtual functions*/

	void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);

	void Restart(RDirectScreenAccess::TTerminationReasons aReason);

private:

	CProcess* iThread;

	TRect iAnimRect;

	TBool iExpectedToAbort;	

	TDirectThreadParam iThreadParam;

	RSemaphore iSem;

	};

/*CPanicDirect*/

 class CPanicDirect : public CBase

 	{

 public:

	static TInt DoTestOnNewScheduler(TInt aInt, TAny* aPtr);

	static TInt DoTestOnNewSchedulerL(TInt aInt, TAny* aPtr);

 private:

 	inline CPanicDirect() {}

 	~CPanicDirect();

 	void ConstructL(TInt aScreenNumber, TInt aInt);

	static void DoTestNowL(TInt aInt, TAny* aPtr);

 	void TestL();

 	void DoDrawingL();

private:

	TInt iTestNo;

	RWsSession iWs;

	CWsScreenDevice* iWsScrDev;

	RWindowGroup iGroup;

	RBlankWindow iBlankWin;

	RDirectScreenAccess iDirect;

	TRequestStatus iDirectStatus;

	RRegion* iRegion;

	RTimer iTimer;

	TRequestStatus iTimerStatus;

	TBool iDrawingAllowed;

	CFbsScreenDevice* iScreenDevice;

	CFbsBitGc* iGc;

	TDisplayMode iDisplayMode;

	CScrollingTextDrawer* iTextDraw;

	TInt iCount;

	TInt iScreenNumber;

	};

class CTDirectStep : public CTGraphicsStep

	{

public:

	CTDirectStep();

protected:

	//from CTGraphicsStep

	virtual CTGraphicsBase* CreateTestL();

	};

_LIT(KTDirectStep,"TDirect");

#endif