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

#define __TREDRAW_H__

#include <e32std.h>

#include <w32std.h>

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

#include "AUTO.H"

#include "TScreenModeScaling.h"

#include "TGraphicsHarness.h"

class CTRedrawTest;

/**

 * Abstract base class to draw a pattern into a window.

 * 

 * This provides a default Draw() implementation which

 * DOES NOT set the clipping region before drawing.

 */

class CRedrawWindow : public CTWin

	{

	friend class CTRedrawTest;

public:

	enum TDrawPattern

		{

		EDrawGraphPaperlHatched = 0,

		EDrawSlantingHatched,

		EDrawCenteredRectangle

		};

public:

	CRedrawWindow(CTRedrawTest* aTest);

	~CRedrawWindow();

public:

	/*

	 * Draw the window, counting the number of calls.

	 * @post DrawRequests() returns a value increased by 1.

	 */

	virtual void Reset();

	virtual void PrepareInvalidation(const TRect& aRect) = 0;

	virtual void PerformInvalidation() = 0;

	//Virtual function from CTBaseWin

	void Draw();

public:

	void ActivateAndDraw(TInt aPattern);

	void DrawPattern(TInt aPattern);

	void VisibleRegion(RRegion& aRegion);

	void ValidateAndClear();

	void ActivateAndDraw(TInt aPattern,TRegion* aRegion);

	TInt DrawRequests() const;

protected:

	void ReceivedDrawRequest();

	TPoint iOffset;

	RRegion iInvalid;

	CTRedrawTest *iTest;

private:

	TInt iDrawRequests;

	};

/**

 * Concrete class to draw a pattern into a window.

 * 

 */

class CReferenceComparisonRedrawWindow : public CRedrawWindow

	{

public:

	CReferenceComparisonRedrawWindow(CTRedrawTest* aTest);

public:

	// from CRedrawWindow

	void PrepareInvalidation(const TRect& aRect);

	void PerformInvalidation();

	};

class CRedrawWindow2 : public CRedrawWindow

	{

public:

	CRedrawWindow2(CTRedrawTest* aTest);

public:

	//Virtual function from CTBaseWin overridden in CRedrawWindow

	void Draw();

	//Virtual function from CRedrawWindow

	void Reset();

	// from CRedrawWindow

	void PrepareInvalidation(const TRect& aRect);

	void PerformInvalidation();

private:

	TBool iClipped;

	};

class CRedrawWindow3 : public CRedrawWindow

	{

public:

	CRedrawWindow3(CTRedrawTest* aTest);

public:

	//Virtual function from CTBaseWin overridden in CRedrawWindow

	void Draw();

	// from CRedrawWindow

	void PrepareInvalidation(const TRect& aRect);

	void PerformInvalidation();

public:

	void SetUp1L(TPoint pos,TSize size,CTWinBase* parent,CWindowGc& aGc);

	void Activate();

	void Redraw(const TRect& aRect);

protected:

	TBool isActive;

	};

class CTRedrawOrderWindow : public CTWin

	{

public:

	CTRedrawOrderWindow(TInt aOrder, CTRedrawTest *aTest);

	static CTRedrawOrderWindow* NewLC(TInt aOrder,CTWinBase* aParent,const TPoint& aPos,const TSize& aSize,CTRedrawTest* aTest);

	inline static TInt RedrawNumber() {return iRedrawNumber;}

	static void ResetRedrawNumber();

	void Redraw(const TRect& aRect);

	void Draw();

private:

	CTRedrawTest* iTest;

	TInt iOrder;

	static TInt iRedrawNumber;

	};

class CTCheckDefectWin : public CBasicWin

	{

public:

	static CTCheckDefectWin *NewL(TPoint aPos,TSize aWinSize);

private:

	CTCheckDefectWin(){}

	};

class CInvalidRegionChecker : public CBase

	{

public:

	CInvalidRegionChecker(const CTRedrawTest& aGraphicsTest);

	~CInvalidRegionChecker();

	TInt CheckInvalidRegions(const CTWindowGroup* aGroup);	

	TBool ExcludedWindow(const CTWinBase* aTWinBase) const;	

	TInt AddExcludedWindow(const CTWinBase* aExcludedWindow);

	void RemoveExcludedWindow(const CTWinBase* aExcludedWindow);

private:

	void ProcessWindowGroup(const CTWinBase* aTWinBase);

	void ProcessChildWindow(const CTWinBase* aTWinBase);

	void ProcessWindow(const CTWinBase* aTWinBase);

private:

	TInt iInvalidRegionCount;

	RPointerArray<const CTWinBase> iExcludedWindowArray;

	const CTRedrawTest& iGraphicsTest;

	};

class CTRedrawTest : public CTWsGraphicsBase

	{

public:

	CTRedrawTest(CTestStep* aStep);

	~CTRedrawTest();

	void doDestruct();

	void ConstructL();

	void CheckRedrawWindows();

	void ProcessBaseInvalidate();

	void SetBackground(const TRgb& aRgb);

	void DumpRegion(const TRegion& aRegion);

	inline TInt WinContent();

	void InvalidateTestWins(const TRect& aRect);

	void MoveInvalidAreaL();

	void TestGetInvalidRegionL(const CArrayFixFlat<TRect>* aRectList);

	void GetInvalidRegionTestsL();

	void CompareRegionsL(const TRegion& aRegion1,const TRegion& aRegion2);

	void Failed(TInt aOrder);

	void CheckOrderL();

	void TestRect();

	void CheckDefectINC049554L();

	void CheckDefectPDEF099892L();

	void CheckOrdinalPositionDefectL();

	void CheckDefectPDEF117784L();

	void CheckMMSDefectL(TBool aMoveBlankWindow);

	void ConstructAndSetBlankWinLC(RBlankWindow& aWindow, TSize aSize, TPoint aPoint=TPoint(),

						   TRgb aBackgroundColor=TRgb(0,0,0));

	void ConstructWindowLC(RWindow& aWindow, TSize aSize, TPoint aPoint=TPoint(),

						   TRgb aBackgroundColor=TRgb(255,255,255), TBool aTransparencyByAlpha=EFalse,

						   TDisplayMode aDisplayMode=EColor64K);

	void ActivateAndSetGc(CWindowGc& aGc, RWindow& aWindow, CGraphicsContext::TBrushStyle aBrushStyle=CGraphicsContext::ESolidBrush, TRgb aBrushColor=TRgb(0,0,0),

						  		CGraphicsContext::TPenStyle aPenStyle=CGraphicsContext::ENullPen, TRgb aPenColor=TRgb(0,0,0));

	void DrawWin(CWindowGc& aGc, RWindow& aWin, TSize winSize, TRgb aRectColor1, TRgb aRectColor2, TInt aNewOrdinalPos=0, RWindow* aWinToMove=NULL, TBool aDrawAllPixels=EFalse);

	enum TRedrawCheckType

		{

		ECheckRedrawActiveObjectOnly,

		ECheckRedrawActiveObjectAndInvalidRegions	

		};

	TInt WaitForRedrawsToFinish(TRedrawCheckType aRedrawCheckType);

protected:

//from 	CTGraphicsStep

	virtual void RunTestCaseL(TInt aCurTestCase);

private:

	void ValidateAndClear(TestWindow *aWin);

private:

	TSize iWinSize;

	TBool iDoCheck;

	TInt iRedrawNo;

	CReferenceComparisonRedrawWindow *iBaseRedrawWin;

	CRedrawWindow2 *iTestRedrawWin;

	CBlankWindow *iBaseChildWin;

	CBlankWindow *iTestChildWin;

	TInt iDrawRequestsFromTestWindow;

	TInt iWinContent;

	CInvalidRegionChecker *iInvalidRegionChecker;

	};

class CTRedrawTestStep : public CTGraphicsStep

	{

public:

	CTRedrawTestStep();

protected:	

	//from CTGraphicsStep

	virtual CTGraphicsBase* CreateTestL();

	};

_LIT(KTRedrawTestStep,"TRedrawTest");

#endif