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

// GDI.CPP

// Test GDI functions

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TGDI.H"

#define TAUTO_BITMAP_NAME _L("Z:\\WSTEST\\TAUTO.MBM")

//#define LOGGING on		//Uncomment this line to get extra test logging - useful if debugging a failure of one of the tests

typedef CGdiTestLowLevel *(*GdiTestFunc)();

_LIT(KMonospaceTestFontTypefaceName,"Arial");

const TInt KMaxFontSize = 200;

static inline TBool IsLengthEqual(TInt aLLen, TInt aRLen, TInt aBbLen)

	{

// The bounding box of a 'w' is one pixel wider than it should be. W overlaps in to the bounding box of 'x' as the two  

// are stuck together. So add a tolerance of -1.

	return (((aLLen+aRLen)==aBbLen) || ((aLLen+aRLen-1)==aBbLen));

	}

struct GdiTest

	{

	GdiTestFunc func;

	const TText *txt;

	};

GdiTest GdiTestFuncs[]={

	{BoxTextTest,_S("BoxText")},

	{VertTextTest,_S("VertText")},

	/*{JustifiedTextTest,_S("JustifiedText")},*/ // DEF107985 The test for JustifiedText has been removed as it was a bad/useless test

	{VertBoxTextTest,_S("VertBoxText")},

	{SetOriginTest,_S("SetOrigin")},

	{PolyLineTest,_S("PolyLine")},

	{PolygonTest,_S("Polygon")},

	{DrawArcTest,_S("DrawArc")},

	{DrawPieTest,_S("DrawPie")},

	{DrawRoundRectTest,_S("DrawRoundRect")},

	{WideLineTest,_S("WideLine")},

	{DrawTextTest,_S("DrawText")},

	{DrawRectTest,_S("DrawRect")},

	};

CTestWindow::CTestWindow(TRgb aCol) : CBlankWindow(aCol)

	{

	}

CTestWindow::~CTestWindow()

	{

	}

void CTestWindow::ConstructL(TPoint aPos,TSize aSize,CTWinBase* aParent, CWindowGc& aGc)

	{

	iWin=RWindow(TheClient->iWs);

	User::LeaveIfError(iWin.Construct(*(aParent->WinTreeNode()),ENullWsHandle));

	SetExt(aPos,aSize);

	Activate();

	AssignGC(aGc);

	}

void CGdiTestLowLevel::SetGdiTest(CTGdi *aGdiTest)

	{

	iGdiTest=aGdiTest;

	}

void CGdiTestLowLevel::AssignGdi(CWindowGc *aGc)

	{

	iGdi=aGc;

	}

void CGdiTestLowLevel::ConstructL(TInt)

	{

	}

void CGdiTestLowLevel::PreTestSetupL(const TRect &,TInt)

	{

	}

//=======================================//

// Individual GDI low level test classes //

//=======================================//

void CGdiRect::ConstructL(TInt)

	{

	}

void CGdiRect::PreTestSetupL(const TRect &, TInt aCount)

	{

	iBrushCol=TRgb::Gray256(aCount&0x1 ? 0xFF : 0x60);

	iPenCol=TRgb::Gray256(aCount&0x1 ? 0xA0 : 0x0);

	}

TInt CGdiRect::Count(TBool )

	{

	return(1);

	}

void CGdiDrawRect::BaseTest(const TRect &aRect, TInt aCount)

	{

	TheTest(aRect,aCount);

	}

void CGdiDrawRect::TheTest(const TRect &aRect, TInt)

	{

	iGdi->SetBrushColor(iBrushCol);

	iGdi->SetPenColor(iPenCol);

	iGdi->DrawRect(aRect);

	}

TInt CGdiDrawRect::Count(TBool aMode)

	{

	return(aMode ? 4:1);

	}

TInt CGdiDrawRoundRect::Count(TBool aMode)

	{

	return(aMode ? 4:1);

	}

void CGdiDrawRoundRect::BaseTest(const TRect &aRect, TInt aCount)

	{

	TheTest(aRect,aCount);

	}

void CGdiDrawRoundRect::TheTest(const TRect &aRect, TInt aCount)

	{

	iGdi->SetBrushColor(iBrushCol);

	iGdi->SetPenColor(iPenCol);

	TSize size((aRect.iBr.iX-aRect.iTl.iX)/4,(aRect.iBr.iY-aRect.iTl.iY)/4);

	switch(aCount)

		{

		case 0:

			size.SetSize((aRect.iBr.iX-aRect.iTl.iX)/4,(aRect.iBr.iY-aRect.iTl.iY)/4);

			break;

		case 1:

			size.SetSize(0,0);

			break;

		case 2:

			size.SetSize((aRect.iBr.iX-aRect.iTl.iX)/2,(aRect.iBr.iY-aRect.iTl.iY)/2);

			break;

		case 3:

			size.SetSize((aRect.iBr.iX-aRect.iTl.iX),(aRect.iBr.iY-aRect.iTl.iY));

			break;

		}

	iGdi->DrawRoundRect(aRect,size);

	}

TInt CGdiDrawACP::Count(TBool )

	{

	return(1);

	}

void CGdiDrawACP::ConstructL(TInt)

	{

	}

void CGdiDrawACP::PreTestSetupL(const TRect &, TInt )

	{

	iBrushCol=TRgb::Gray256(0xff);

	iPenCol=TRgb(0,0,0);

	}

void CGdiDrawArc::BaseTest(const TRect &aRect, TInt aCount)

	{

	TheTest(aRect,aCount);

	}

void CGdiDrawArc::TheTest(const TRect &aRect, TInt)

	{

	iGdi->SetBrushColor(iBrushCol);

	iGdi->SetPenColor(iPenCol);

	TPoint start(aRect.iTl.iX/2+aRect.iBr.iX,aRect.iTl.iY/2+aRect.iBr.iY);

	iGdi->DrawArc(aRect,start,TPoint(0,0));

	}

void CGdiDrawPie::BaseTest(const TRect &aRect, TInt aCount)

	{

	TheTest(aRect,aCount);

	}

void CGdiDrawPie::TheTest(const TRect &aRect, TInt)

	{

	iGdi->SetBrushColor(iBrushCol);

	iGdi->SetPenColor(iPenCol);

	TPoint start(aRect.iTl.iX/2+aRect.iBr.iX,aRect.iTl.iY/2+aRect.iBr.iY);

	iGdi->DrawPie(aRect,start,TPoint(0,0));

	}

//

// Polyline tests

//

CGdiPolyLine::CGdiPolyLine() : iPnts(5)

	{}

void CGdiPolyLine::PreTestSetupL(const TRect &aRect, TInt aCount)

	{

	iPnts.Reset();

	TInt wid=aRect.Width();

	TInt hgt=aRect.Height();

	if (aCount==0)

		{

		TInt pos;

		for(pos=0;pos<wid;pos+=10)

			{

			iPnts.AppendL(TPoint(aRect.iTl.iX+pos,aRect.iTl.iY));

			iPnts.AppendL(TPoint(aRect.iTl.iX+pos+5,aRect.iBr.iY));

			}

		for(pos=0;pos<hgt;pos+=10)

			{

			iPnts.AppendL(TPoint(aRect.iTl.iX,aRect.iTl.iY+pos));

			iPnts.AppendL(TPoint(aRect.iBr.iX,aRect.iTl.iY+pos+5));

			}

		}

	else

		{

		TInt hgt=aRect.Height();

		iPnts.AppendL(TPoint(aRect.iTl.iX,aRect.iTl.iY));

		iPnts.AppendL(TPoint(aRect.iBr.iX,aRect.iTl.iY+hgt/2));

		iPnts.AppendL(TPoint(aRect.iTl.iX,aRect.iBr.iY));

		iPnts.AppendL(TPoint(aRect.iBr.iX,aRect.iBr.iY));

		iPnts.AppendL(TPoint(aRect.iTl.iX,aRect.iTl.iY+hgt/2));

		iPnts.AppendL(TPoint(aRect.iBr.iX,aRect.iTl.iY));

		iPnts.AppendL(TPoint(aRect.iTl.iX,aRect.iTl.iY));

		}

	}

void CGdiPolyLine::ConstructL(TInt )

	{

	}

TInt CGdiPolyLine::Count(TBool aMainTests)

	{

	return(aMainTests ? 2 : 1);

	}

void CGdiPolyLine::BaseTest(const TRect &, TInt )

	{

	TPoint prev;

	TInt index;

	for(index=0;index<iPnts.Count();index++)

		{

		if (index>0)

			iGdi->DrawLine(prev,iPnts[index]);

		prev=iPnts[index];

		}

	if (index>0)

		iGdi->Plot(iPnts[index-1]);

	}

void CGdiPolyLine::TheTest(const TRect &, TInt )

	{

	iGdi->DrawPolyLine(&iPnts);

	}

//

// Polygon tests //

//

CGdiPolygon::CGdiPolygon() : iPnts(5)

	{}

void CGdiPolygon::PreTestSetupL(const TRect &aRect, TInt )

	{

	iPnts.Reset();

	TPoint pnt;

	TInt maxPoints=Min((TInt)KMaxPolygonPoints,Min(aRect.Width(),aRect.Height())/KPolygonStep);

	TInt numPoints=0;

	if (maxPoints>0)

		{

		iPnts.AppendL(aRect.iTl);

		while(numPoints<maxPoints)

			{

			if (numPoints&1)

				pnt.SetXY(aRect.iTl.iX+(numPoints+1)*KPolygonStep,aRect.iTl.iY+numPoints*KPolygonStep);

			else

				pnt.SetXY(aRect.iTl.iX+numPoints*KPolygonStep,aRect.iTl.iY+(numPoints+1)*KPolygonStep);

			iPnts.AppendL(pnt);

			numPoints++;

			}

		pnt.SetXY(aRect.iTl.iX+numPoints*KPolygonStep,aRect.iTl.iY+numPoints*KPolygonStep);

		iPnts.AppendL(pnt);

		while(numPoints>0)

			{

			numPoints--;

			if (numPoints&1)

				pnt.SetXY(aRect.iTl.iX+numPoints*KPolygonStep,aRect.iTl.iY+(numPoints+1)*KPolygonStep);

			else

				pnt.SetXY(aRect.iTl.iX+(numPoints+1)*KPolygonStep,aRect.iTl.iY+numPoints*KPolygonStep);

			iPnts.AppendL(pnt);

			}

		}

	}

void CGdiPolygon::ConstructL(TInt )

	{

	}

TInt CGdiPolygon::Count(TBool aMainTests)

	{

	return(aMainTests ? 2 : 1);

	}

void CGdiPolygon::BaseTest(const TRect &aRect, TInt )

	{

	iGdi->SetPenColor(TRgb::Gray4(2));

	iGdi->SetBrushColor(TRgb::Gray4(1));

	iGdi->SetBrushStyle(CGraphicsContext::ESolidBrush);

	TInt maxPoints=Min((TInt)KMaxPolygonPoints,Min(aRect.Width(),aRect.Height())/KPolygonStep);

	for(TInt numPoints=0;numPoints<maxPoints;numPoints++)

		iGdi->DrawRect(TRect(aRect.iTl.iX+numPoints*KPolygonStep + 1,aRect.iTl.iY+numPoints*KPolygonStep + 1,

							 aRect.iTl.iX+(numPoints+1)*KPolygonStep ,aRect.iTl.iY+(numPoints+1)*KPolygonStep));

	}

void CGdiPolygon::TheTest(const TRect &, TInt )

//This is the only one that can leave so it's not worth adding an 'L'

	{

	iGdi->SetPenColor(TRgb::Gray4(2));

	iGdi->SetBrushColor(TRgb::Gray4(1));

	iGdi->SetBrushStyle(CGraphicsContext::ESolidBrush);

	User::LeaveIfError(iGdi->DrawPolygon(&iPnts,CGraphicsContext::EAlternate));

	}

//

TInt CGdiWideLine::Count(TBool aMainTests)

	{

	return(aMainTests ? EMainNumWidths : EMinorNumWidths);

	}

void CGdiWideLine::ConstructL(TInt)

	{

	}

void CGdiWideLine::PreTestSetupL(const TRect &, TInt aCount)

	{

	TInt widths[]={1,4,50,-2,

				   48,12345,0,3,

				   48,123,0,3,

				   4,111,555,1000,

				   10,-1,-10,-100};

	iWidth=widths[aCount];

	}

void CGdiWideLine::BaseTest(const TRect &aRect, TInt)

	{

	iGdi->SetPenSize(TSize(iWidth,iWidth));

	iGdi->DrawLine(aRect.iTl,aRect.iBr);

	iGdi->MoveTo(aRect.iTl+TPoint(0,10));

	iGdi->DrawLineBy(aRect.iBr-aRect.iTl);

	iGdi->MoveBy(aRect.iTl-aRect.iBr+TPoint(0,10));

	iGdi->DrawLineTo(aRect.iBr+TPoint(0,20));

	}

void CGdiWideLine::TheTest(const TRect &aRect, TInt)

	{

	iGdi->SetPenSize(TSize(iWidth,iWidth));

	iGdi->MoveTo(aRect.iTl);

	iGdi->DrawLineBy(aRect.iBr-aRect.iTl);

	iGdi->MoveBy(aRect.iTl-aRect.iBr+TPoint(0,10));

	iGdi->DrawLineTo(aRect.iBr+TPoint(0,10));

	iGdi->DrawLine(aRect.iTl+TPoint(0,20),aRect.iBr+TPoint(0,20));

	}

//

// Set Origin //

//

CGdiSetOrigin::~CGdiSetOrigin()

	{

	delete iPolylineArray;

	delete iPolygonArray;

	TheClient->iScreen->ReleaseFont(iFont);

	}

TInt CGdiSetOrigin::Count(TBool )

	{

	return(1);

	}

void CGdiSetOrigin::ConstructL(TInt)

	{

	iPolylineArray=new(ELeave) CArrayFixFlat<TPoint>(3);

	iPolylineArray->AppendL(TPoint(40,1));

	iPolylineArray->AppendL(TPoint(50,11));

	iPolylineArray->AppendL(TPoint(40,21));

	iPolygonArray=new(ELeave) CArrayFixFlat<TPoint>(3);

	iPolygonArray->AppendL(TPoint(40,30));

	iPolygonArray->AppendL(TPoint(50,40));

	iPolygonArray->AppendL(TPoint(40,45));

	TFontSpec fspec(KMonospaceTestFontTypefaceName,KMaxFontSize);

	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)iFont,fspec));

	}

void CGdiSetOrigin::PreTestSetupL(const TRect &, TInt )

	{

	}

void CGdiSetOrigin::DrawIt(const TPoint &aOffset)

	{

	iGdi->DrawLine(TPoint(10,10)+aOffset,TPoint(20,30)+aOffset);

	iGdi->DrawLineBy(TPoint(-10,5));

	iGdi->DrawLineTo(TPoint(20,5)+aOffset);

	iGdi->MoveTo(TPoint(20,10)+aOffset);

	iGdi->DrawLineTo(TPoint(30,15)+aOffset);

	iGdi->MoveBy(TPoint(-10,2));

	iGdi->DrawLineBy(TPoint(10,0));

	iGdi->UseFont(iFont);

	iGdi->DrawText(_L("Set Origin Test"),TPoint(40,20)+aOffset);

	iGdi->DiscardFont();

	iGdi->DrawRect(TRect(TPoint(10,45)+aOffset,TPoint(20,55)+aOffset));

	iGdi->DrawRoundRect(TRect(TPoint(21,45)+aOffset,TPoint(30,55)+aOffset),TSize(3,2));

	iGdi->DrawEllipse(TRect(TPoint(31,45)+aOffset,TPoint(40,55)+aOffset));

	TInt index;

	for(index=0;index<iPolylineArray->Count();index++)

		(*iPolylineArray)[index]+=aOffset;

	iGdi->DrawPolyLine(iPolylineArray);

	for(index=0;index<iPolylineArray->Count();index++)

		(*iPolylineArray)[index]-=aOffset;

	for(index=0;index<iPolygonArray->Count();index++)

		(*iPolygonArray)[index]+=aOffset;

	iGdi->SetBrushStyle(CGraphicsContext::ESolidBrush);

	User::LeaveIfError(iGdi->DrawPolygon(iPolygonArray,CGraphicsContext::EAlternate));		//Doesn't cause any harm if it leaves

	for(index=0;index<iPolygonArray->Count();index++)

		(*iPolygonArray)[index]-=aOffset;

	}

void CGdiSetOrigin::BaseTest(const TRect &aRect, TInt)

	{

	DrawIt(aRect.iTl);

	}

void CGdiSetOrigin::TheTest(const TRect &aRect, TInt)

	{

	iGdi->SetOrigin(aRect.iTl);

	DrawIt(TPoint(0,0));

	}

//

// Draw text //

//

CGdiDrawText::~CGdiDrawText()

	{

	TheClient->iScreen->ReleaseFont(iFont);

	}

TInt CGdiDrawText::Count(TBool )

	{

	return(1);

	}

void CGdiDrawText::ConstructL(TInt)

	{

	TFontSpec fspec(KMonospaceTestFontTypefaceName,KMaxFontSize);

	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)iFont,fspec));

	TInt index;

	for(index=0;index<iBigBuffer.MaxLength();index++)

		iBigBuffer.Append(TChar((index%26)+'a'));

	const TInt characters=iBigBuffer.Length();

	TInt bbLen=iFont->TextWidthInPixels(iBigBuffer);

	for(index=0;index<iBigBuffer.MaxLength();index+=33)

		{

		TInt lLen=iFont->TextWidthInPixels(iBigBuffer.Left(index));

		TInt rLen=iFont->TextWidthInPixels(iBigBuffer.Right(characters-index));

		TBool result = IsLengthEqual(lLen,rLen,bbLen);

		iGdiTest->TEST(result);

		if (!result)

			{

			_LIT(KLog,"Font width metrics error, Width(%dchars)=%d, Width(%dchars)=%d, Width(%dchars)=%d");

			iGdiTest->LOG_MESSAGE7(KLog,index,lLen,characters-index,rLen,characters,bbLen);

			}

		}

	}

void CGdiDrawText::PreTestSetupL(const TRect&,TInt)

	{}

void CGdiDrawText::BaseTest(const TRect& aRect,TInt)

	{

	TInt bbLen=iFont->TextWidthInPixels(iBigBuffer);

	TInt fAscent=iFont->AscentInPixels();

	TInt fHeight=iFont->HeightInPixels();

	iGdi->UseFont(iFont);

//

	iGdi->DrawText(_L("Hello"), TPoint(aRect.iTl.iX, aRect.iTl.iY+fAscent));

	TInt missingChars=iFont->TextCount(iBigBuffer,bbLen-aRect.iBr.iX)-1;	// -1 so one off screen char is drawn to handle overhang

	if (missingChars>=0)

		{

		TPtrC bbb=iBigBuffer.Right(iBigBuffer.Length()-missingChars);

		TInt lLen=iFont->TextWidthInPixels(iBigBuffer.Left(missingChars));

		TInt rLen=iFont->TextWidthInPixels(bbb);

		TBool result = IsLengthEqual(lLen,rLen,bbLen);

		iGdiTest->TEST(result);

		if (!result)

			{

			_LIT(KLog,"Font width metrics error, missingChars=%d  %d+%d=%d");

			iGdiTest->LOG_MESSAGE5(KLog,missingChars,lLen,rLen,bbLen);

			}

		iGdi->DrawText(bbb,TPoint(aRect.iBr.iX-rLen,aRect.iTl.iY+fAscent+fHeight));

		}

	iGdi->DiscardFont();

	}

void CGdiDrawText::TheTest(const TRect& aRect,TInt)

	{