// Copyright (c) 1997-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:

//

#include <bitdev.h>

#include <hal.h>

#include "TBMP.H"

#include "TClip.h"

#include <graphics/fbsdefs.h>

//Note: Some display modes will be scaled - see 

//CreateTestEnvironment(), SetScalingFactor() call

//aTestAppNo is a new argument and it is not used yet.

//It can have 0 or 1 value depending on which test app 

//uses TestClip functionality - TClip or TClip2.

CTClip::CTClip(CTestStep* aStep,

					TInt aTestAppNo,

					CFbsScreenDevice* aDev,

					CFbsBitGc* aCon,

					CFbsBitmap* aBmp,

					CFbsFont* aFont,

				   	CFbsFont* aLargeFont):

	CTGraphicsBase(aStep),

	iTestAppNo(aTestAppNo),

	iDev(aDev),

	iCon(aCon),

	iClientRect(TRect(0,0,0,0)),

	iGopNum(EFirstGop),

	iClipList(NULL),

	iBitmap(aBmp),

	iBitmap64K(NULL),

	iBitmap16MU(NULL),

	iBitmap16MA(NULL), 

	iBitmapMask(NULL),

	iBitmapAlpha(NULL),

	iFont(aFont),

	iLargeFont(aLargeFont),

	iBmpSize(TSize(0,0))

	{}

void CTClip::ConstructL()

	{

	iClipList=(TRect*)User::Alloc(sizeof(TRect)*ERegions);

	if(!iClipList)

		User::Panic(_L("Construct failure"),KErrGeneral);

	iBmpSize=iBitmap->SizeInPixels();

	iBitmap64K=new(ELeave) CFbsBitmap();

	iBitmap16MU=new(ELeave) CFbsBitmap();

	iBitmap16MA=new(ELeave) CFbsBitmap();

	iBitmapMask=new(ELeave) CFbsBitmap();

	iBitmapAlpha=new(ELeave) CFbsBitmap();

	}

TBool CTClip::SetUpTest(TInt &aTestModeIndex)

	{

	CFbsBitGc::TGraphicsOrientation orientation;

	do

		{

		orientation=(CFbsBitGc::TGraphicsOrientation)(aTestModeIndex/2);

		if (orientation>CFbsBitGc::EGraphicsOrientationRotated270)

			return(EFalse);

		aTestModeIndex++;

		TPoint scalingOrigin(0,0);

		TInt scale=1;

		if ((aTestModeIndex&0x1)==CFbsBitGc::EGraphicsOrientationNormal)

			{

			scalingOrigin=TPoint(20, 10);

			scale=2;

			}

		iDev->SetScalingFactor(scalingOrigin, scale, scale, 1, 1);

		} while(!iCon->SetOrientation(orientation));

	iDev->GetDrawRect(iClientRect);

	TInt dims[2*ERegions]={0,0, 1,1, 1,2, 2,1, 2,2, 1,10, 10,1, 2,10, 10,2, 10,10};

	for(TUint count=0;count<ERegions;count++)

		{

		iClipList[count].iTl.iX=iClientRect.iBr.iX*2/3;

		iClipList[count].iTl.iY=iClientRect.iBr.iY/3;

		iClipList[count].iBr.iX=iClipList[count].iTl.iX+dims[count*2];

		iClipList[count].iBr.iY=iClipList[count].iTl.iY+dims[count*2+1];

		}

	iDev->SetAutoUpdate(ETrue);

	iCon->SetPenStyle(CGraphicsContext::ESolidPen);

	iCon->SetPenColor(KRgbBlack);

	iCon->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iCon->SetBrushColor(TRgb(170,170,170));

	Clear();

	iCon->UseBrushPattern(iBitmap);

	TSize halfScreen(iClientRect.Width()/2-2, iClientRect.Height()-2);

	User::LeaveIfError(iBitmap64K->Load(_L("z:\\system\\data\\16ram.mbm"),0,EFalse));

	User::LeaveIfError(iBitmap64K->Resize(halfScreen));

	User::LeaveIfError(iBitmap16MU->Load(_L("z:\\system\\data\\32ram.mbm"),0,EFalse));

	User::LeaveIfError(iBitmap16MU->Resize(halfScreen));

	User::LeaveIfError(iBitmap16MA->Load(_L("z:\\system\\data\\32ram.mbm"),0,EFalse));

	User::LeaveIfError(iBitmap16MA->Resize(halfScreen));

	User::LeaveIfError(iBitmapMask->Create(halfScreen, EGray2));

	User::LeaveIfError(iBitmapAlpha->Create(halfScreen, EGray256));

	return(ETrue);

	}

inline CTClipStep* CTClip::Step()

	{

	return static_cast<CTClipStep*>(iStep);

	}

void CTClip::Clear()

	{

	iCon->SetPenStyle(CGraphicsContext::ENullPen);

	iCon->SetBrushColor(KRgbWhite);

	iCon->DrawRect(iClientRect);

	iCon->SetPenStyle(CGraphicsContext::ESolidPen);

	iCon->SetBrushColor(TRgb(170,170,170));

	}

CTClip::~CTClip()

	{

	for(TInt i=0;i<ERegions;i++)

		{

		iClipList[i].~TRect();

		}

	User::Free(iClipList);

	delete iBitmap64K;

	delete iBitmap16MU;

	delete iBitmapMask;

	delete iBitmapAlpha;

	delete iBitmap16MA;

	}

void CTClip::RunTestCaseL(const TInt aCurTestCase)

	{

	((CTClipStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(aCurTestCase)

		{

	case 1:

		((CTClipStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0042"));

		TestComplexRgn();

		INFO_PRINTF1(_L("Complex Rgn Test complete"));

		break;

	case 2:

		((CTClipStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0038"));

		TestRectRgn();

		INFO_PRINTF1(_L("Rect Rgn Test complete"));

		break;

	case 3:

#if !defined(__X86GCC__)		//Tests take too long to run and don't test anything useful anyway

		((CTClipStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0039"));

		TestSimpleRgn();

		INFO_PRINTF1(_L("Simple Rgn Test complete"));

		break;

	case 4:

		((CTClipStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0041"));

		TestHoriRgn();

		INFO_PRINTF1(_L("Horizontal Rgn Test complete"));

		break;

	case 5:

		((CTClipStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0040"));

		TestVertRgn();

		INFO_PRINTF1(_L("Vertical Rgn Test complete"));

		break;

	case 6:

#endif	//__X86GCC__

		((CTClipStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		((CTClipStep*)iStep)->CloseTMSGraphicsStep();

		INFO_PRINTF1(_L("Test complete\n"));

		TestComplete();

		break;

		}

	((CTClipStep*)iStep)->RecordTestResultL();

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0038

  @SYMDEF             

  @SYMTestCaseDesc Tests clipping to a rect region

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Iterates through a number of regions and graphic operations testing clipping with each

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

void CTClip::TestRectRgn()

	{

	TInt testMode=0;

	while(SetUpTest(testMode))

		{

		for(TUint j=0;j<ERegions;j++)

			{

			TRect reg=iClipList[j];

			for(iGopNum=EFirstGop+1;iGopNum<EGraphicsOps;iGopNum++)

				{

				RRegion rectreg(reg);

				DrawToScreen(rectreg,iClientRect);

				rectreg.Close();

				ScanArea(iClientRect.iBr.iX/2,iClientRect.iTl.iY,iClientRect.iBr.iX/2,reg.iTl.iY-iClientRect.iTl.iY); // above

				ScanArea(iClientRect.iBr.iX/2,reg.iTl.iY,reg.iTl.iX-iClientRect.iBr.iX/2,reg.Height()); // left

				ScanArea(reg.iBr.iX,reg.iTl.iY,iClientRect.iBr.iX-reg.iBr.iX,reg.Height()); // right

				ScanArea(iClientRect.iBr.iX/2,reg.iBr.iY,iClientRect.iBr.iX/2,iClientRect.iBr.iY-reg.iBr.iY); // below

				CheckInside(reg,iClientRect);

				}

			}

		}

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0039

  @SYMDEF             

  @SYMTestCaseDesc Tests clipping to a simple region

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Iterates through a number of simple regions and graphic operations testing clipping with each

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

void CTClip::TestSimpleRgn()

	{

	TInt testMode=0;

	while(SetUpTest(testMode))

		{

		for(TUint j=0;j<ERegions;j++)

			{

			TRect reg=iClipList[j];

			for(iGopNum=EFirstGop+1;iGopNum<EGraphicsOps;iGopNum++)

				{

				DrawToScreen(reg,iClientRect);

				ScanArea(iClientRect.iBr.iX/2,iClientRect.iTl.iY,iClientRect.iBr.iX/2,reg.iTl.iY); // above

				ScanArea(iClientRect.iBr.iX/2,reg.iTl.iY,reg.iTl.iX-iClientRect.iBr.iX/2,reg.Height()); // left

				ScanArea(reg.iBr.iX,reg.iTl.iY,iClientRect.iBr.iX-reg.iBr.iX,reg.Height()); // right

				ScanArea(iClientRect.iBr.iX/2,reg.iBr.iY,iClientRect.iBr.iX/2,iClientRect.iBr.iY-reg.iBr.iY); // below

				CheckInside(reg,iClientRect);

				}

			}

		}

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0040

  @SYMDEF             

  @SYMTestCaseDesc Tests clipping to a vertical region

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Iterates through a number of regions of different widths and graphic operations testing clipping with each

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

void CTClip::TestVertRgn()

	{

	TInt widths[3]={1,2,5};

	TInt testMode=0;

	while(SetUpTest(testMode))

		{

		for(TInt count=0;count<3;count++) // check vertical strips

			{

			TInt i=widths[count];

			for(iGopNum=EFirstGop+1;iGopNum<EGraphicsOps;iGopNum++)

				{

				for(TInt j=0;j<iClientRect.iBr.iX/2-i;j+=35)

					{

					TRect reg=TRect(iClientRect.iBr.iX/2+j,iClientRect.iTl.iY,iClientRect.iBr.iX/2+j+i,iClientRect.iBr.iY);

					RRegion rectreg(reg);

					DrawToScreen(rectreg,iClientRect);

					rectreg.Close();

		 			ScanArea(iClientRect.iBr.iX/2,reg.iTl.iY,reg.iTl.iX-iClientRect.iBr.iX/2,reg.Height()); // left

					ScanArea(reg.iBr.iX,reg.iTl.iY,iClientRect.iBr.iX-reg.iBr.iX,reg.Height()); // right

					CheckInside(reg,iClientRect);

					}

				}

			}

		}

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0041

  @SYMDEF             

  @SYMTestCaseDesc Tests clipping to a horizontal region

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Iterates through a number of regions of different widths and graphic operations testing clipping with each

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

void CTClip::TestHoriRgn()

	{

	TInt widths[3]={1,2,5};

	TInt testMode=0;

	while(SetUpTest(testMode))

		{

		for(TInt count=0;count<3;count++) // check horizontal strips

			{

			TInt i=widths[count];

			for(iGopNum=EFirstGop+1;iGopNum<EGraphicsOps;iGopNum++)

				{

				for(TInt j=0;j<iClientRect.iBr.iY;j+=35)

					{

					TRect reg=TRect(iClientRect.iBr.iX/2,j,iClientRect.iBr.iX,j+i);

					RRegion rectreg(reg);

					DrawToScreen(rectreg,iClientRect);

					rectreg.Close();

					ScanArea(iClientRect.iBr.iX/2,iClientRect.iTl.iY,iClientRect.iBr.iX/2,reg.iTl.iY); // above

					ScanArea(iClientRect.iBr.iX/2,reg.iBr.iY,iClientRect.iBr.iX/2,iClientRect.iBr.iY-reg.iBr.iY); // below

					CheckInside(reg,iClientRect);

					}

				}

			}

		}

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0042

  @SYMDEF             

  @SYMTestCaseDesc Tests clipping to a complex region

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Creates a complex region then iterates through graphic operations testing clipping with each

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

void CTClip::TestComplexRgn()

	{

	TInt testMode=0;

	while(SetUpTest(testMode))

		{

		TRect rect[8];

		rect[0].SetRect(iClientRect.iBr.iX*12/20,0,iClientRect.iBr.iX*15/20,iClientRect.iBr.iY/4);

		rect[1].SetRect(iClientRect.iBr.iX*11/20,iClientRect.iBr.iY/8,iClientRect.iBr.iX*13/20,iClientRect.iBr.iY/2);

		rect[2].SetRect(iClientRect.iBr.iX*14/20,iClientRect.iBr.iY/8,iClientRect.iBr.iX*17/20,iClientRect.iBr.iY/2);

		rect[3].SetRect(iClientRect.iBr.iX*12/20,iClientRect.iBr.iY*3/8,iClientRect.iBr.iX*18/20,iClientRect.iBr.iY*5/8);

		rect[4].SetRect(iClientRect.iBr.iX*13/20,iClientRect.iBr.iY*9/16,iClientRect.iBr.iX*19/20,iClientRect.iBr.iY*7/8);

		rect[5].SetRect(iClientRect.iBr.iX*17/20,iClientRect.iBr.iY*3/4,iClientRect.iBr.iX,iClientRect.iBr.iY);

		rect[6].SetRect(iClientRect.iBr.iX*11/20,iClientRect.iBr.iY*5/8,iClientRect.iBr.iX*11/20+1,iClientRect.iBr.iY*5/8+1);

		rect[7].SetRect(iClientRect.iBr.iX*18/20,iClientRect.iBr.iY/8,iClientRect.iBr.iX*18/20,iClientRect.iBr.iY/8);

		TRect space[12];

		space[0].SetRect(iClientRect.iBr.iX/2,0,rect[1].iTl.iX,rect[1].iBr.iY);

		space[1].SetRect(space[0].iBr.iX,0,rect[0].iTl.iX,rect[1].iTl.iY);

		space[2].SetRect(rect[0].iBr.iX,0,rect[2].iBr.iX,rect[2].iTl.iY);

		space[3].SetRect(rect[2].iBr.iX,0,iClientRect.iBr.iX,rect[3].iTl.iY);

		space[4].SetRect(rect[1].iBr.iX,rect[0].iBr.iY,rect[2].iTl.iX,rect[3].iTl.iY);

		space[5].SetRect(iClientRect.iBr.iX/2,rect[1].iBr.iY,rect[3].iTl.iX,rect[6].iTl.iY);

		space[6].SetRect(iClientRect.iBr.iX/2,rect[6].iTl.iY,rect[6].iTl.iX,rect[6].iBr.iY);

		space[7].SetRect(iClientRect.iBr.iX/2,rect[6].iBr.iY,rect[6].iBr.iX,iClientRect.iBr.iY);

		space[8].SetRect(rect[6].iBr.iX,rect[6].iTl.iY,rect[4].iTl.iX,iClientRect.iBr.iY);

		space[9].SetRect(rect[4].iTl.iX,rect[4].iBr.iY,rect[5].iTl.iX,iClientRect.iBr.iY);

		space[10].SetRect(rect[4].iBr.iX,rect[4].iTl.iY,iClientRect.iBr.iX,rect[5].iTl.iY);

		space[11].SetRect(rect[3].iBr.iX,rect[3].iTl.iY,iClientRect.iBr.iX,rect[4].iTl.iY);

		RRegion creg(rect[0],8);

		creg.AddRect(rect[1]);

		creg.AddRect(rect[2]);

		creg.AddRect(rect[3]);

		creg.AddRect(rect[4]);

		creg.AddRect(rect[5]);

		creg.AddRect(rect[6]);

		creg.AddRect(rect[7]);

		for(iGopNum=EFirstGop+1;iGopNum<EGraphicsOps;iGopNum++)

			{

			DrawToScreen(creg,iClientRect);

			TInt count=0;

			for(;count<8;count++)

				CheckInside(rect[count],iClientRect);

			for(count=0;count<12;count++)

				ScanArea(space[count].iTl.iX,space[count].iTl.iY,space[count].iBr.iX-space[count].iTl.iX,space[count].iBr.iY-space[count].iTl.iY);

			}

		creg.Close();

		}

	}

void CTClip::ScanArea(TInt x,TInt y,TInt length,TInt height)

	{

	if (length<1 || height<1)

		{

		return;

		}

	HBufC8* buf = HBufC8::NewL(length * 4);

	TPtr8 des = buf->Des();

	for (TInt row=0; row<height; row++)

		{

		TPoint point(x, y+row);

		des.Zero();

		iDev->GetScanLine(des,point,length,EColor16MA);

		for(TInt i=0; i<des.Length(); i++)

			{

			if(des[i] != 0xFF)

				{

				INFO_PRINTF1(_L("Clipping failure outside!\n"));

				INFO_PRINTF2(_L("Graphics operation: %d\n"),iGopNum);

				INFO_PRINTF5(_L("x=%d, y=%d, length=%d, height=%d\n"),x,y,length,height);

				INFO_PRINTF3(_L("Index=%d, Found=%x, Expected=0xFF\n"),i,des[i]);

				TEST(0);

				delete buf;

				return;

				}

			}

		}

	delete buf;

	}

void CTClip::CheckInside(const TRect& aClip,const TRect& aRect)

	{

	const TInt length=aClip.Width();

	const TInt unOffsetX=-(aRect.iBr.iX/2);

#if defined(__X86GCC__) || defined(__MARM__)

	const TInt KMaxLinesToPrint=2;

#else

	const TInt KMaxLinesToPrint=10;

#endif

	HBufC8* unBuf = HBufC8::NewL(length * 4);

	HBufC8* clBuf = HBufC8::NewL(length * 4);

	TPtr8 unDes = unBuf->Des();

	TPtr8 clDes = clBuf->Des();

	TInt linesDiffs=0;

	for (TUint yy=aClip.iTl.iY; yy<aClip.iBr.iY; yy++)

		{

		TPoint unPoint(aClip.iTl.iX+unOffsetX, yy);

		TPoint clPoint(aClip.iTl.iX,           yy);

		unDes.Zero();

		clDes.Zero();

		iDev->GetScanLine(unDes,unPoint,length,EColor16MA);

		iDev->GetScanLine(clDes,clPoint,length,EColor16MA);

		TInt different = unDes.Compare(clDes);

		if (different)

			{

			if (linesDiffs++<KMaxLinesToPrint)

				{

				_LIT(KDots,"..");

				_LIT(KStart,"|.");

				_LIT(KEnd,".|");

				const TInt KMaxNumBytesToLog=14;

				TBuf<8*KMaxNumBytesToLog> buf1,buf2;

				TInt end=Min(length,KMaxNumBytesToLog);

				end*=4;

				TInt ii;

				TInt matches=ETrue;

				for (ii=0; ii<end; ++ii)

					{

					_LIT(KHex,"%02x");

					buf1.AppendFormat(KHex,unDes[ii]);

					if (unDes[ii]!=clDes[ii])

						{

						buf2.AppendFormat(KHex,clDes[ii]);

						matches=EFalse;

						}

					else

						{		//Show each pixel as |......| on the 2nd line if it matches

						TPtrC ptr(KDots);

						switch (ii%4)

							{

						case 0:

							ptr.Set(KStart);

							break;

						case 3:

							ptr.Set(KEnd);

							break;

							}

						buf2.Append(ptr);

						}

					}

				TBuf<256> buf;

				if (!matches)

					{

					_LIT(KLog,"ClipRect (%d,%d,%d,%d)  Row=%d  (First %d of %d pixels shown, only differing values shown on comparison line)");

					buf.Format(KLog,aClip.iTl.iX,aClip.iTl.iY,aClip.iBr.iX,aClip.iBr.iY,yy,end,aClip.Width());

					INFO_PRINTF1(buf);

					INFO_PRINTF1(buf1);

					INFO_PRINTF1(buf2);

					}

				else

					{

					_LIT(KLog,"ClipRect (%d,%d,%d,%d)  Row=%d  (First %d of %d pixels all match)");

					buf.Format(KLog,aClip.iTl.iX,aClip.iTl.iY,aClip.iBr.iX,aClip.iBr.iY,yy,end,aClip.Width());

					INFO_PRINTF1(buf);

					}

				}

			}

		}

	if (linesDiffs>0)

		{

		_LIT(KLog,"Clipping failure inside!  Graphics operation: %d  Lines With Diffs: %d/%d");

		INFO_PRINTF4(KLog,iGopNum,linesDiffs,aClip.iBr.iY-aClip.iTl.iY);

		}

	if (!Step()->IgnoreDiffs())

		TEST(linesDiffs==0);