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

// Window redraw/validate/invalidate tests

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TREDRAW.H"

LOCAL_D TSize FullScreenModeSize;

const TRgb KRed = TRgb(255,0,0);

const TRgb KBlack = TRgb(0,0,0);

const TRgb KWhite = TRgb(255,255,255);

const TRgb KTransBisque = TRgb(255,228,196,128);

const TRgb KTransLightSalmon = TRgb(255,160,122,128);

const TRgb KLightSteelBlue = TRgb(176,196,222);

const TRgb KCadetBlue = TRgb(95,158,160);

TInt CTRedrawOrderWindow::iRedrawNumber=0;

#define InvalidRegionLogging

#if defined(InvalidRegionLogging)

#define BLOG_MESSAGE(p) (const_cast<CTRedrawTest*>(&iGraphicsTest))->LogMessage(((TText8*)__FILE__), __LINE__,(p))

#endif

//

//  //

//

CTCheckDefectWin* CTCheckDefectWin::NewL(TPoint aPos,TSize aWinSize)

	{

	CTCheckDefectWin* win=new(ELeave) CTCheckDefectWin;

	win->ConstructExtLD(*TheClient->iGroup,aPos,aWinSize);

	win->BaseWin()->SetRequiredDisplayMode(EColor256);

	win->AssignGC(*TheClient->iGc);

	win->BaseWin()->SetShadowDisabled(ETrue);

	win->BaseWin()->SetShadowHeight(0);

	TheClient->Flush();

	return win;

	}

CRedrawWindow::CRedrawWindow(CTRedrawTest *aTest) : CTWin(), iTest(aTest)

	{

	}

CRedrawWindow::~CRedrawWindow()

	{

	iInvalid.Close();

	}

void CRedrawWindow::Draw()

	{

	ReceivedDrawRequest();

	DrawPattern(iTest->WinContent());

	}

void CRedrawWindow::ReceivedDrawRequest()

	{

	iDrawRequests++;

	}

TInt CRedrawWindow::DrawRequests() const

	{

	return iDrawRequests;

	}

void CRedrawWindow::DrawPattern(TInt aPattern)

	{

	iGc->Clear();

	TPoint drawBase(-10,-20);

	TSize drawSize(iSize.iWidth-2*drawBase.iX,iSize.iHeight-2*drawBase.iY);

	TPoint offset=drawBase+iOffset;

	switch(aPattern)

		{

		case EDrawGraphPaperlHatched:

			{

			iGc->DrawRect(TRect(drawBase,drawBase+drawSize));

			iGc->SetPenColor(TRgb(85,85,85));

			iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);

			TInt xpos;

			for(xpos=0;xpos<drawSize.iWidth;xpos+=15)

				iGc->DrawLine(TPoint(xpos,0)+offset,TPoint(xpos,drawSize.iHeight)+offset);

			TInt ypos;

			for(ypos=0;ypos<drawSize.iHeight;ypos+=15)

				iGc->DrawLine(TPoint(0,ypos)+offset,TPoint(drawSize.iWidth,ypos)+offset);

			break;

			}

		case EDrawSlantingHatched:

			{

			iGc->SetPenColor(TRgb(255,255,255));

			iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);

			for(TInt xpos=0;xpos<drawSize.iWidth;xpos+=16)

				{

				iGc->DrawLine(TPoint(xpos,0)+offset,TPoint(drawSize.iWidth,xpos*drawSize.iHeight/drawSize.iWidth)+offset);

				iGc->DrawLine(TPoint(xpos,0)+offset,TPoint(0,drawSize.iHeight-xpos*drawSize.iHeight/drawSize.iWidth)+offset);

				iGc->DrawLine(TPoint(xpos,drawSize.iHeight)+offset,TPoint(drawSize.iWidth,drawSize.iHeight-xpos*drawSize.iHeight/drawSize.iWidth)+offset);

				iGc->DrawLine(TPoint(xpos,drawSize.iHeight)+offset,TPoint(0,xpos*drawSize.iHeight/drawSize.iWidth)+offset);

				}

			}

			break;

		case EDrawCenteredRectangle:

			{

			TRect rect(5,iSize.iHeight/4,iSize.iWidth-5,iSize.iHeight/2);

			iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);

			iGc->SetPenColor(TRgb(255,255,255));

			iGc->DrawRect(rect);

			}

			break;

		default:

			// Other pattern values requested are ignored

			break;

		}

	}

void CRedrawWindow::Reset()

	{

	iOffset=TPoint(0,0);

	iWin.Invalidate();

	iInvalid.Clear();

	}

/**

 * Calculate the window region minus the region covered by the child

 * window; this is the "visible region"

 */

void CRedrawWindow::VisibleRegion(RRegion &aRegion)

	{

	aRegion.Clear();

	aRegion.AddRect(TRect(Size()));

	TRect child;

	child.iTl=Child()->BaseWin()->InquireOffset(iWin);

	child.iBr=child.iTl+Child()->Size();

	aRegion.SubRect(child);

	}

void CRedrawWindow::ValidateAndClear()

	{

	Win()->Invalidate();

	Win()->BeginRedraw();

	iGc->Activate(*Win());

	iGc->Clear();

	iGc->Deactivate();

	Win()->EndRedraw();

	}

void CRedrawWindow::ActivateAndDraw(TInt aPattern, TRegion *aRegion)

	{

	iGc->Activate(*Win());

	if (aRegion)

		iGc->SetClippingRegion(*aRegion);

	DrawPattern(aPattern);

	iGc->Deactivate();

	}

CReferenceComparisonRedrawWindow::CReferenceComparisonRedrawWindow(CTRedrawTest *aTest) : CRedrawWindow(aTest)

	{}

/**

 * Prepare the invalid region.

 * 

 * Update the invalid region with a rectangle where such a rectangle is minus

 * any area covered by a child window.

 * 

 * @param aRect Rectangle to be added to the invalid region

 */

void CReferenceComparisonRedrawWindow::PrepareInvalidation(const TRect &aRect)

	{

	RRegion clipped_visible;

	VisibleRegion(clipped_visible);

	clipped_visible.ClipRect(aRect);

	iInvalid.Union(clipped_visible);

	clipped_visible.Close();

	iInvalid.Tidy();

	}

/**

 * Mop up all pending invalid regions and simulate a Draw().

 * 

 * Normally, we would rely on WServ to call this window's Draw() method

 * to obtain drawing operations to cover the currently invalid regions

 * of the window.

 * 

 * This method does that task by marking all invalid regions as clean and

 * then performs the drawing required in the invalid portions of the screen.

 * 

 * The purpose of this is to then allow a comparison to be made against a

 * different window which does rely on the WServ framework calling back

 * to do a Draw().

 * 

 * @post the window has no outstanding invalid regions

 */

void CReferenceComparisonRedrawWindow::PerformInvalidation()

	{

	for(TInt index=0;index<iInvalid.Count();index++)

		{

		iWin.Invalidate(iInvalid[index]);

		iWin.BeginRedraw(iInvalid[index]);

		iWin.EndRedraw();

		}

	iWin.BeginRedraw(iInvalid.BoundingRect());

	iGc->Activate(iWin);

	iGc->SetClippingRegion(iInvalid);

	DrawPattern(iTest->WinContent());

	iGc->Deactivate();

	iWin.EndRedraw();

	}

CRedrawWindow2::CRedrawWindow2(CTRedrawTest *aTest) : CRedrawWindow(aTest)

	{

	}

void CRedrawWindow2::Draw()

	{

	ReceivedDrawRequest();

	if (iClipped)

		iGc->SetClippingRegion(iInvalid);

	DrawPattern(iTest->WinContent());

	if (iClipped)

		iGc->CancelClippingRegion();

	}

/**

 * Prepare the invalid region.

 * @param aRect rectangle to be added to the invalid region

 */

void CRedrawWindow2::PrepareInvalidation(const TRect &aRect)

	{

	iInvalid.Clear();

	iInvalid.AddRect(aRect);

	}

/**

 * Perform invalidation by setting the window's invalid region.

 * 

 * The purpose of this method is to stimulate a call from WServ to the

 * Draw() method of this class.

 */

void CRedrawWindow2::PerformInvalidation()

	{

	iWin.Invalidate(iInvalid.BoundingRect());

	}

void CRedrawWindow2::Reset()

	{

	CRedrawWindow::Reset();

	iClipped=EFalse;

	}

CRedrawWindow3::CRedrawWindow3(CTRedrawTest *aTest) : CRedrawWindow(aTest)

	{

	}

void CRedrawWindow3::Draw()

	{

	ReceivedDrawRequest();

	iGc->Clear();

	iGc->SetPenStyle(CGraphicsContext::ENullPen);

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iGc->SetBrushColor(TRgb(0,255,255));

	iGc->DrawRect(TRect(TPoint(0,0),TSize(50,50)));

	}

void CRedrawWindow3::PrepareInvalidation(const TRect &aRect)

	{

	iInvalid.Clear();

	iInvalid.AddRect(aRect);

	}

void CRedrawWindow3::PerformInvalidation()

	{

	iWin.Invalidate(iInvalid.BoundingRect());

	}

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

	{

	ConstructL(*parent);

	SetExtL(pos,size);

	AssignGC(aGc);

	}

void CRedrawWindow3::Redraw(const TRect &aRect)

	{

	if(!isActive)

		{//make an empty redraw

		iWin.BeginRedraw(aRect);

		iWin.EndRedraw();

		}

	else

		{

		CTWin::Redraw(aRect);

		}	

	}

void CRedrawWindow3::Activate()

	{

	isActive = ETrue;

	Win()->Activate();

	}

//

CTRedrawOrderWindow::CTRedrawOrderWindow(TInt aOrder, CTRedrawTest *aTest) : iTest(aTest), iOrder(aOrder)

	{}

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

	{

	CTRedrawOrderWindow* self=new(ELeave) CTRedrawOrderWindow(aOrder,aTest);

	CleanupStack::PushL(self);

	self->SetUpL(aPos,aSize,aParent,*TheGc);

	return self;

	}

void CTRedrawOrderWindow::Draw()

	{

	iGc->SetBrushColor(TRgb::Gray16(iOrder*2));

	iGc->Clear();

	}

void CTRedrawOrderWindow::ResetRedrawNumber()

	{

	iRedrawNumber=0;

	}

void CTRedrawOrderWindow::Redraw(const TRect &aRect)

	{

	if (++iRedrawNumber!=iOrder)

		iTest->Failed(iOrder);

	CTWin::Redraw(aRect);

	}

//

TInt DestructCallback(TAny *aParam)

	{

	((CTRedrawTest *)aParam)->doDestruct();

	return(0);

	}

CTRedrawTest::CTRedrawTest(CTestStep* aStep):

	CTWsGraphicsBase(aStep)//, iInvalidRegionChecker(*this)

	{}

void CTRedrawTest::doDestruct()

	{

	BaseWin->SetVisible(ETrue);

	TestWin->SetVisible(ETrue);

	delete iBaseRedrawWin;

	delete iTestRedrawWin;

	delete iBaseChildWin;

	delete iTestChildWin;

	}

CTRedrawTest::~CTRedrawTest()

	{

	TCallBack callBack(DestructCallback,this);

	TheClient->SetRedrawCancelFunction(callBack);

	delete iInvalidRegionChecker;	

	}

void CTRedrawTest::ConstructL()

	{

#if defined(InvalidRegionLogging)

	LOG_MESSAGE(_L("  CTRedrawTest::ConstructL()"));

	LOG_MESSAGE4(_L("  Ex Wins 0x%08x, 0x%08x, 0x%08x"), BaseWin, TestWin, &(TheClient->StdLogWindow()));

#endif

	iInvalidRegionChecker = new(ELeave)CInvalidRegionChecker(*this);

	User::LeaveIfError(iInvalidRegionChecker->AddExcludedWindow(BaseWin));

	User::LeaveIfError(iInvalidRegionChecker->AddExcludedWindow(TestWin));

	User::LeaveIfError(iInvalidRegionChecker->AddExcludedWindow(&(TheClient->StdLogWindow())));

	WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);	

	iWinContent=0;

	BaseWin->SetVisible(EFalse);

	TestWin->SetVisible(EFalse);

	FullScreenModeSize=TheClient->iGroup->Size();

	TInt winWidth=(FullScreenModeSize.iWidth/3)-10;

	TInt winHeight=FullScreenModeSize.iHeight-10;

	iBaseRedrawWin=new(ELeave) CReferenceComparisonRedrawWindow(this);

	iBaseRedrawWin->SetUpL(TPoint(FullScreenModeSize.iWidth/3+5,5),TSize(winWidth,winHeight),TheClient->iGroup,*TheClient->iGc);

	iTestRedrawWin=new(ELeave) CRedrawWindow2(this);

	iTestRedrawWin->SetUpL(TPoint(FullScreenModeSize.iWidth/3*2+5,5),TSize(winWidth,winHeight),TheClient->iGroup,*TheClient->iGc);

	iBaseChildWin=new(ELeave) CBlankWindow();

	iBaseChildWin->SetUpL(TPoint(winWidth>>2,winHeight>>2),TSize(winWidth>>1,winHeight>>1),iBaseRedrawWin,*TheClient->iGc);

	iTestChildWin=new(ELeave) CBlankWindow();

	iTestChildWin->SetUpL(TPoint(winWidth>>2,winHeight>>2),TSize(winWidth>>1,winHeight>>1),iTestRedrawWin,*TheClient->iGc);

#if defined(InvalidRegionLogging)

	LOG_MESSAGE5(_L("  In Wins %08x, %08x, %08x, %08x"), iBaseRedrawWin, iBaseChildWin, iTestRedrawWin, iTestChildWin);

#endif

	WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);

#if defined(InvalidRegionLogging)

	LOG_MESSAGE(_L("  Done"));

#endif

	}

void CTRedrawTest::CheckRedrawWindows()

	{

	_LIT(KTest,"Redraw Test, SubTest %d ");

	TBuf<64> buf;

	buf.Format(KTest,iTest->iState);

	CheckRect(iBaseRedrawWin,iTestRedrawWin,TRect(iBaseRedrawWin->Size()),buf);

	}

void CTRedrawTest::InvalidateTestWins(const TRect &aRect)

	{

	iBaseRedrawWin->PrepareInvalidation(aRect);

	iTestRedrawWin->PrepareInvalidation(aRect);

	iBaseRedrawWin->PerformInvalidation();

	iTestRedrawWin->PerformInvalidation();

	}

inline TInt CTRedrawTest::WinContent()

	{

	return iWinContent;

	}

void CTRedrawTest::SetBackground(const TRgb &aRgb)

	{

	iBaseRedrawWin->iWin.SetBackgroundColor(aRgb);

	iTestRedrawWin->iWin.SetBackgroundColor(aRgb);

	}

void CTRedrawTest::DumpRegion(const TRegion &aRegion)

	{

	_LIT(KLog,"RegionRect %d: (%d,%d,%d,%d)");

	for (TInt ii=0;ii<aRegion.Count();++ii)

		{

		const TRect& rect=aRegion[ii];

		LOG_MESSAGE6(KLog,ii,rect.iTl.iX,rect.iTl.iY,rect.iBr.iX,rect.iBr.iY);

		}

	}

/**

 * Compare Regions to see if the region we think we have dirtied can be

 * completely covered by the WServ invalid region.

 * 

 * @param aDirtyRegion 			Region we have made dirty

 * @param aWservInvalidRegion	Region WServ thinks is dirty

 */

void CTRedrawTest::CompareRegionsL(const TRegion &aDirtyRegion,const TRegion &aWservInvalidRegion)

	{

	_LIT(KDirty,"Dirty Region, %d Rects");

	_LIT(KInvalid,"Invalid Region, %d Rects");

	_LIT(KDiff,"Diff Region, %d Rects");

	RRegion tmp;

	TBool loggedRegions=EFalse;

	tmp.Copy(aDirtyRegion);

	tmp.SubRegion(aWservInvalidRegion);

	if (tmp.CheckError())

		User::Leave(KErrNoMemory);

	TBool isEmpty=tmp.IsEmpty();

	TEST(isEmpty);

	if (!isEmpty)

		{

		_LIT(KLog,"DirtyRegion contains area not in WservInvalidRegion");

		LOG_MESSAGE(KLog);

		loggedRegions=ETrue;

		LOG_MESSAGE2(KDirty,aDirtyRegion.Count());

		DumpRegion(aDirtyRegion);

		LOG_MESSAGE2(KInvalid,aWservInvalidRegion.Count());

		DumpRegion(aWservInvalidRegion);

		LOG_MESSAGE2(KDiff,tmp.Count());

		DumpRegion(tmp);

		}

	tmp.Copy(aWservInvalidRegion);

	tmp.SubRegion(aDirtyRegion);

	if (tmp.CheckError())

		User::Leave(KErrNoMemory);

	isEmpty=tmp.IsEmpty();

	//TEST(isEmpty);		//This test currently fails and a defect will be raises about it

	if (!isEmpty)

		{

		_LIT(KLog,"WservInvalidRegion contains area not in DirtyRegion");

		LOG_MESSAGE(KLog);

		if (!loggedRegions)

			{

			LOG_MESSAGE2(KDirty,aDirtyRegion.Count());

			DumpRegion(aDirtyRegion);

			LOG_MESSAGE2(KInvalid,aWservInvalidRegion.Count());

			DumpRegion(aWservInvalidRegion);

			}

		LOG_MESSAGE2(KDiff,tmp.Count());

		DumpRegion(tmp);

		}

	tmp.Close();

	}

void CTRedrawTest::MoveInvalidAreaL()

	{

	TPoint old=iTestRedrawWin->iWin.Position();

	TSize screenSize=TheClient->iGroup->Size();

	iBaseRedrawWin->iWin.Invalidate();

	iTestRedrawWin->iWin.Invalidate();

	iTestRedrawWin->iWin.SetPosition(TPoint(10,10));

	iTestRedrawWin->iWin.SetPosition(TPoint(0,0));

	iTestRedrawWin->iWin.SetPosition(TPoint(-10,-10));

	iTestRedrawWin->iWin.SetPosition(TPoint(screenSize.iWidth-10,screenSize.iHeight-10));

	iTestRedrawWin->iWin.SetPosition(TPoint(screenSize.iWidth,screenSize.iHeight));

	iTestRedrawWin->iWin.SetPosition(TPoint(screenSize.iWidth+10,screenSize.iHeight+10));

	iTestRedrawWin->iWin.SetPosition(old);

	RRegion baseInvalidRegion;

	RRegion testInvalidRegion;

	iBaseRedrawWin->iWin.GetInvalidRegion(baseInvalidRegion);

	iTestRedrawWin->iWin.GetInvalidRegion(testInvalidRegion);

	CompareRegionsL(baseInvalidRegion,testInvalidRegion);

	baseInvalidRegion.Close();

	testInvalidRegion.Close();