// Copyright (c) 2007-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 "tdrawshapes.h"

#include <e32math.h>

CTDrawShapes::CTDrawShapes()

	{

	SetTestStepName(KTDirectGdiDrawShapeStep);

	}

CTDrawShapes::~CTDrawShapes()

	{

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-SHAPEDRAWING-0001

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Test shape drawing with basic parameters.

@SYMTestStatus

	Implemented

@SYMTestPriority

	Critical

@SYMTestActions

	Test various shape drawing methods:

	void Plot(const TPoint& aPoint)

		- Draw points on the destination surface in various colours (use colours from

		COLOR_TABLE), increasing the distance between the points.

	void DrawLine(const TPoint& aStart, const TPoint& aEnd)

		- Draw lines with various colours (use colours from COLOR_TABLE).

		- Draw line from top-left to bottom-right corner. Move starting point to the right

		and ending point to the left and draw again. Repeat increasing the distance between

		the previous and next starting and ending points, until reaching a position outside

		the destination surface.

		- Draw line from top-left to bottom-right corner. Move starting point down and ending

		point up and draw again. Repeat increasing the distance between the previous and next

		starting and ending points, until reaching a position outside the destination surface.

	void DrawLineTo(const TPoint& aPoint)

		- Draw lines with various colours (use colours from COLOR_TABLE).

		- Draw line from top-left corner to the bottom of the drawing area. Now draw a line

		in opposite direction, moving the end point a little to the right. Repeat, increasing

		the distance, by which the end point is moved right, until reaching a position outside

		the destination surface.

	void DrawLineBy(const TPoint& aVector)

		- Draw lines with various colours (use colours from COLOR_TABLE).

		- Draw line from top-left corner to the right end of the drawing area. Now draw a line

		in opposite direction, moving the end point a little down. Repeat, increasing the distance,

		by which the end point is moved down, until reaching a position outside the destination surface.

	void DrawRect(const TRect& aRect)

		- Draw empty and filled rectangles.

		- Draw rectangles with various colours (pen & brush colours; use colours from COLOR_TABLE).

		- Draw rectangle with size of the whole drawing area, shrink it and repeat until rectangle

		size reaches 0.

	void DrawRoundRect(const TRect& aRect, const TSize& aEllipse)

		- Draw empty and filled rectangles.

		- Draw rectangles with various colours (pen & brush colours; use colours from COLOR_TABLE).

		- Draw rectangle with size of the whole drawing area, shrink it, increase  the round corners

		size and repeat until rectangle size reaches 0.

	void DrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

		- Draw arcs with various colours (use colours from COLOR_TABLE).

		- Draw an arc within the rectangle size of entire drawing area.

		- Shrink the rectangle.

		- Repeat until rectangle size reaches zero, move arc's start and end points.

	void DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

		- Draw empty and filled pies.

		- Draw pies with various colours (pen & brush colours; use colours from COLOR_TABLE).

		- Draw a pie within the rectangle size of entire drawing area.

		- Shrink the rectangle.

		- Repeat until rectangle size reaches zero, move pie's start and end points.

	void DrawPolyLine(const TArray<TPoint>& aPointList)

	void DrawPolyLineNoEndPoint(const TArray<TPoint>& aPointList)

		- Draw a poly line in the target area, constructed from a large number of points.

	void DrawPolygon(const TArray<TPoint>& aPointList, CGraphicsContext::TFillRule aFillRule=CGraphicsContext::EAlternate)

		- Draw a polygon on the target area, constructed from a large number of points.

	void DrawEllipse(const TRect& aRect)

		- Draw empty and filled ellipses.

		- Draw ellipses with various colours (pen & brush colours; use colours from COLOR_TABLE).

		- Use rectangle (aRect) with size of the whole drawing area, shrink it and repeat until

		rectangle size reaches zero.

@SYMTestExpectedResults

	All graphic operations completed successfully without errors. Individual shapes should

	be drawn in the target area. Valid bitmap should be created. This bitmap should be

	the same as a reference one.

*/

void CTDrawShapes::TestBasicDrawShapeL()

	{

	_LIT(KTestName, "ShapeDrawing-Basic"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	ResetGc();

	TSize size(iGdiTarget->SizeInPixels().iWidth/4,

			   iGdiTarget->SizeInPixels().iHeight/4);

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

		{

		TPoint pos(size.iWidth*(i%4), size.iHeight*(i/4));

		iGc->Reset();

		switch(i)

			{

			case 0: // void Plot(const TPoint& aPoint)

				{

				TInt step = 0;

				for(TInt y=0; y<size.iHeight; y+=step)

					{

					for(TInt x=0; x<size.iWidth; x+=step)

						{

						iGc->SetPenColor(KColor16Table[step%16]);

						iGc->SetPenStyle(DirectGdi::ENullPen);

						iGc->Plot(TPoint(x, y)+pos);

						TESTNOERRORL(iGc->GetError());

						iGc->SetPenStyle(DirectGdi::ESolidPen);

						for(TInt penSize = 0; penSize <= 2; penSize++)

							{

							iGc->SetPenSize(TSize(penSize,penSize));

							iGc->Plot(TPoint(x, y)+pos);

							TESTNOERRORL(iGc->GetError());

							}						

						step++;

						}

					}

				break;

				}

			case 1: // void DrawLine(const TPoint& aStart, const TPoint& aEnd)

				{

				TInt step = 0;

				for(TInt x1=0,x2=size.iWidth-1; x1<size.iWidth; x1+=step,x2-=step)

					{

					iGc->SetPenColor(KColor16Table[step%16]);

					iGc->DrawLine(TPoint(x1, 0)+pos, TPoint(x2, size.iHeight-1)+pos);

					TESTNOERRORL(iGc->GetError());

					step++;

					}

				step = 0;

				for(TInt y1=0,y2=size.iHeight-1; y1<size.iHeight; y1+=step,y2-=step)

					{

					iGc->SetPenColor(KColor16Table[step%16]);

					iGc->DrawLine(TPoint(0, y1)+pos, TPoint(size.iWidth-1, y2)+pos);

					TESTNOERRORL(iGc->GetError());

					step++;

					}

				break;

				}

			case 2: // void DrawLineTo(const TPoint& aPoint), void DrawLineBy(const TPoint& aVector)

				{

				iGc->MoveTo(pos);

				for(TInt x1=1,a=1,s=1; x1<size.iWidth; a++,x1+=a,s=-s)

					{

					iGc->SetPenColor(KColor16Table[a%16]);

					iGc->DrawLineTo(TPoint(x1, (s>0)*(size.iHeight-1))+pos);

					TESTNOERRORL(iGc->GetError());

					}

				iGc->MoveTo(pos);

				for(TInt y1=1,a=1,s=1; y1<size.iHeight; a++,y1+=a,s=-s)

					{

					iGc->SetPenColor(KColor16Table[a%16]);

					iGc->DrawLineBy(TPoint(s*(size.iWidth-1), a));

					TESTNOERRORL(iGc->GetError());

					}

				break;

				}

			case 4: // void DrawRect(const TRect& aRect), filled

				{

				iGc->SetBrushStyle(DirectGdi::ESolidBrush);

				}

			case 3: // void DrawRect(const TRect& aRect)

				{

				TRect rect(pos, size);

				for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(3, 3))

					{

					iGc->SetPenColor(KColor16Table[a%16]);

					iGc->SetBrushColor(KColor16Table[(a+2)%16]);

					iGc->DrawRect(rect);

					TESTNOERRORL(iGc->GetError());

					}

				break;

				}

			case 6: // void DrawRoundRect(const TRect& aRect, const TSize& aEllipse), filled

				{

				iGc->SetBrushStyle(DirectGdi::ESolidBrush);

				}

			case 5: // void DrawRoundRect(const TRect& aRect, const TSize& aEllipse)

				{

				TRect rect(pos, size);

				TSize csize(1, 1);

				for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(5, 5),csize+=TSize(2, 2))

					{

					iGc->SetPenColor(KColor16Table[a%16]);

					iGc->SetBrushColor(KColor16Table[(a+2)%16]);

					for(TInt penSize = 0; penSize <= 1; penSize++)

						{

						iGc->SetPenSize(TSize(penSize,penSize));

						iGc->SetPenStyle(DirectGdi::ENullPen);

						iGc->DrawRoundRect(rect, csize);

						TESTNOERRORL(iGc->GetError());

						iGc->SetPenStyle(DirectGdi::ESolidPen);

						iGc->DrawRoundRect(rect, csize);

						TESTNOERRORL(iGc->GetError());

						iGc->SetPenStyle(DirectGdi::EDottedPen);

						iGc->DrawRoundRect(rect, csize);

						TESTNOERRORL(iGc->GetError());

						}

					}

				break;

				}

			case 7: // void DrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

				{

				TRect rect(pos, size);

				TPoint pos2(pos);

				pos2 += TPoint(size.iWidth/2, size.iHeight/2); // center

				TReal start = KPiBy2;

				TReal end = 0.0;

				for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(3, 3),start+=0.3,end+=0.2)

					{

					TReal ss;

					TReal cc;

					Math::Sin(ss, start);

					Math::Cos(cc, start);

					TInt32 startX;

					TInt32 startY;

					Math::Int(startX, cc*100);

					Math::Int(startY, ss*100);

					Math::Sin(ss, end);

					Math::Cos(cc, end);

					TInt32 endX;

					TInt32 endY;

					Math::Int(endX, cc*100);

					Math::Int(endY, ss*100);

					iGc->SetPenColor(KColor16Table[a%16]);

					iGc->DrawArc(rect, TPoint(startX, startY)+pos2, TPoint(endX, endY)+pos2);

					TESTNOERRORL(iGc->GetError());

					}

				break;

				}

			case 9: // void DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd), filled

					{

					iGc->SetBrushStyle(DirectGdi::ESolidBrush);

					}

			case 8: // void DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

				{

				TRect rect(pos, size);

				TPoint pos2(pos);

				pos2 += TPoint(size.iWidth/2, size.iHeight/2); // center

				TReal start = 0.0;

				TReal end = 0.1;

				for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(4, 4),start+=end,end+=0.04)

					{

					TReal ss;

					TReal cc;

					Math::Sin(ss, start+end);

					Math::Cos(cc, start+end);

					TInt32 startX;

					TInt32 startY;

					Math::Int(startX, cc*100);

					Math::Int(startY, ss*100);

					Math::Sin(ss, start);

					Math::Cos(cc, start);

					TInt32 endX;

					TInt32 endY;

					Math::Int(endX, cc*100);

					Math::Int(endY, ss*100);

					iGc->SetPenColor(KColor16Table[a%16]);

					iGc->SetBrushColor(KColor16Table[(a+2)%16]);

					iGc->DrawPie(rect, TPoint(startX, startY)+pos2, TPoint(endX, endY)+pos2);

					TESTNOERRORL(iGc->GetError());

					}

				break;

				}

			case 10: // void DrawPolyLine(const TArray<TPoint>* aPointList)

			case 11: // void DrawPolyLineNoEndPoint(const TArray<TPoint>* aPointList)

				{

				TInt numPoints = 60;

				CArrayFixFlat<TPoint> *array = new (ELeave)CArrayFixFlat<TPoint>(numPoints);

				CleanupStack::PushL(array);

				TPoint pos2(pos);

				pos2 += TPoint(size.iWidth/2, size.iHeight/2); // center

				TReal angle = 0.0;

				for(TInt r=numPoints; r>0; r--,angle+=0.47)

					{

					TReal ss;

					TReal cc;

					Math::Sin(ss, angle);

					Math::Cos(cc, angle);

					TInt32 x;

					TInt32 y;

					Math::Int(x, cc*r);

					Math::Int(y, ss*r);

					array->AppendL(TPoint(x, y)+pos2);

					}

				if(i == 10)

					{

					for(TInt penSize = 0; penSize <= 1; penSize++)

						{

						iGc->SetPenSize(TSize(penSize,penSize));

						iGc->DrawPolyLine(*array);

						}

					}

				else //if(i == 11)

					{

					iGc->DrawPolyLineNoEndPoint(*array);

					}

				TESTNOERRORL(iGc->GetError());

				CleanupStack::PopAndDestroy(array);

				break;

				}

			case 13:// TInt DrawPolygon(const TArray<TPoint>* aPointList, CGraphicsContext::TFillRule aFillRule=CGraphicsContext::EAlternate), filled

					{

					iGc->SetBrushStyle(DirectGdi::ESolidBrush);

					iGc->SetBrushColor(KColor16Table[1]);

					}

			case 12:// TInt DrawPolygon(const TArray<TPoint>* aPointList, CGraphicsContext::TFillRule aFillRule=CGraphicsContext::EAlternate)

				{

				TInt numPoints = 20;

				CArrayFixFlat<TPoint> *array = new (ELeave)CArrayFixFlat<TPoint>(numPoints);

				CleanupStack::PushL(array);

				TPoint pos2(pos);

				pos2 += TPoint(size.iWidth/2, size.iHeight/2); // center

				TReal angle = 0.0;

				for(TInt r=60; r>0; r-=3,angle+=0.47)

					{

					TReal ss;

					TReal cc;

					Math::Sin(ss, angle);

					Math::Cos(cc, angle);

					TInt32 x;

					TInt32 y;

					Math::Int(x, cc*r);

					Math::Int(y, ss*r);

					array->AppendL(TPoint(x, y)+pos2);

					}

				iGc->DrawPolygon(*array, DirectGdi::EAlternate);

				TESTNOERRORL(iGc->GetError());

				CleanupStack::PopAndDestroy(array);

				break;

				}

			case 15: // void DrawEllipse(const TRect& aRect), filled

				{

				iGc->SetBrushStyle(DirectGdi::ESolidBrush);

				}

			case 14: // void DrawEllipse(const TRect& aRect)

				{

				TRect rect(pos, size);

				for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(3, 5))

					{

					iGc->SetPenColor(KColor16Table[a%16]);

					iGc->SetBrushColor(KColor16Table[(a+2)%16]);

					iGc->DrawEllipse(rect);

					TESTNOERRORL(iGc->GetError());

					}

				break;

				}

			}

		TESTNOERRORL(iGc->GetError());

		}

	TESTNOERROR(WriteTargetOutput(iTestParams, KTestName()));

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-SHAPEDRAWING-0002

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Test line drawing with basic parameters.

@SYMTestStatus

	Implemented

@SYMTestPriority

	Critical

@SYMTestActions

	Set default pen.

		- Draw lines in all directions.

		- Draw lines starting or/and ending outside the target surface.		

	Call functions with valid parameters.

	void DrawLine(const TPoint& aStart, const TPoint& aEnd)

		The test is implemented the following way: lines will be drawn from a little

		distance from the centre (to avoid lines overlapping) to a point outside of the surface

		(testing surface boundary clipping). The next line will be drawn in opposite direction

		(from outside to the centre) at a slightly incremented angle. 

	void DrawLineBy(const TPoint& aVector)

		Test for DrawLineBy() is implemented in a similar way, with checking the continuity

		of line drawing (drawing the next line from the end of the previous one).

	void DrawLineTo(const TPoint& aPoint)

		Test for DrawLineTo() is implemented in a similar way, with checking the continuity

		of line drawing (drawing the next line from the end of the previous one).

@SYMTestExpectedResults

	Valid bitmap should be created. This bitmap shall be compared to a reference bitmap.

*/

void CTDrawShapes::TestDrawLineL(TDrawShapeAPI aApi)

	{

	_LIT(KDrawLine, "ShapeDrawing-DrawLine");

	_LIT(KDrawLineTo, "ShapeDrawing-DrawLineTo");

	_LIT(KDrawLineBy, "ShapeDrawing-DrawLineBy");

	TBuf<30> testName;

	if(aApi == EDrawLine)

		testName = KDrawLine();

	else if(aApi == EDrawLineTo)

		testName = KDrawLineTo();

	else if(aApi == EDrawLineBy)

		testName = KDrawLineBy();

	else

		ASSERT(EFalse); // test not supported for shapes other than those above

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(testName);

		}

	ResetGc();

	TPoint center(iGdiTarget->SizeInPixels().iWidth/2,

			iGdiTarget->SizeInPixels().iHeight/2);

	TInt steps = 180;

	TReal radius1 = 400.0;

	TReal radius2 = 70.0;

	TPoint pp;

	if(aApi != EDrawLine)

		{

		const TInt radius = 200;

		radius1 = radius;

		radius2 = 90.0;

		pp = center;

		pp.iX += radius;

		iGc->MoveTo(pp);

		}

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

		{

		TReal angle = KPi*2.0*i/steps;

		TReal angleSin, angleCos;

		Math::Sin(angleSin, angle);

		Math::Cos(angleCos, angle);

		TPoint p1(static_cast<TInt>(angleCos*radius1), static_cast<TInt>(angleSin*radius1));

		p1 += center;

		TPoint p2(static_cast<TInt>(angleCos*radius2), static_cast<TInt>(angleSin*radius2));

		p2 += center;

		if(i&1)

			{

			TPoint pp = p1;

			p1 = p2;

			p2 = pp;

			}