// 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 "tbrushandpen.h"

#include <e32math.h>

/**

default brush and pen drawing target size

*/

const TSize KDrawBrushPenDefaultSize(640, 450);

CTBrushAndPen::CTBrushAndPen()

	{

	SetTestStepName(KTDirectGdiBrushAndPenStep);

	}

CTBrushAndPen::~CTBrushAndPen()

	{

	}

/**

@SYMTestCaseID  

	GRAPHICS-DIRECTGDI-PENBRUSH-0001

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc  

	Test drawing with brush.

@SYMTestPriority 

	High

@SYMTestStatus

	Implemented

@SYMTestActions 

	Basic test for pen and brush methods.

	Test the following brush settings:

		- colour

		- style

		Call drawing functions with the following parameters:

			colours from the COLOR_TABLE.

			aBrushStyle

				ENullBrush

				ESolidBrush

				EPatternedBrush 

				EVerticalHatchBrush 

				EForwardDiagonalHatchBrush 

				EHorizontalHatchBrush 

				ERearwardDiagonalHatchBrush 

				ESquareCrossHatchBrush 

				EDiamondCrossHatchBrush 

	Issue shape drawing operations: DrawRect, DrawRoundRect, DrawEllipse, DrawPie, DrawPolygon.

	Draw overlapping shapes to test correctness of brush transparency. 

	Repeat the drawing in write alpha mode (DrawModeWriteAlpha bitmap).	

@SYMTestExpectedResults

	Brush colours and styles should be correctly drawn for each shape and each draw mode.

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

@param	aDrawMode	the draw mode to run this test in, only DirectGdi::EDrawModePEN and DirectGdi::EDrawModeWriteAlpha

		are supported

*/

void CTBrushAndPen::TestBrushColorAndStyleL(const DirectGdi::TDrawMode aDrawMode)

	{	

	_LIT(KTestName, "PenBrush-BrushColourStyle_%S"); //test case name		

	_LIT(KDrawModePEN, "DrawModePen"); 

	_LIT(KDrawModeWriteAlpha, "DrawModeWriteAlpha"); 

	TBuf<50> testCaseName;	

	switch (aDrawMode)

		{

		case DirectGdi::EDrawModePEN:

			testCaseName.Format(KTestName, &KDrawModePEN);

			break;		

		case DirectGdi::EDrawModeWriteAlpha:

			testCaseName.Format(KTestName, &KDrawModeWriteAlpha);

			break;		

		default:

			// This method should only be called aDrawMode set to DirectGdi::EDrawModePEN or DirectGdi::EDrawModeWriteAlpha

			TESTL(EFalse);

			break;

		}

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(testCaseName);	

		}

	ResetGc();

	// Set the draw mode

	iGc->SetDrawMode(aDrawMode);

	TESTNOERROR(iGc->GetError());

	iGc->SetPenStyle(DirectGdi::ESolidPen);

	// print two row of shapes

	// the second one has overlapping shapes to test alpha blending

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

		{

		// draw 8 columns of different shapes with various pen colours

		// brush colours, and brush styles 

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

			{			

			iGc->SetBrushStyle(KBrushStyleTable[i==1?1:i+1]);

			TInt startx = 10+i*70 - j*i*10;

			TInt endx = 70+i*70;

			TInt starty = j*263;

			//this is setter helper function, see below method definition

			SetHashColors(i,j,1);

			iGc->DrawRect(TRect(startx,starty+10,endx,starty+30));

			SetHashColors(i,j,2);

			iGc->DrawRoundRect(TRect(startx,starty+40,endx,starty+60), TSize(10,10));

			SetHashColors(i,j,3);

			iGc->DrawPie(TRect(startx,starty+65,endx,starty+125), TPoint(startx,starty+65) , TPoint(endx,starty+65));

			// below shapes are not necessary to test alpha blending,

			// so there are drawn only three above shapes with increasing overlap

			if(j == 0) 

				{

				SetHashColors(i,j,4);

				iGc->DrawEllipse(TRect(startx,starty+130 ,endx,starty+190 ));

				SetHashColors(i,j,5);

				CArrayFixFlat<TPoint>* pointList = new (ELeave) CArrayFixFlat<TPoint>(6);

				CleanupStack::PushL(pointList);

				pointList->AppendL(TPoint(startx,starty+192));

				pointList->AppendL(TPoint(startx + 50,starty+242));

				pointList->AppendL(TPoint(startx + 10,starty+242));

				pointList->AppendL(TPoint(endx,starty+192));

				pointList->AppendL(TPoint(endx,starty+262));

				pointList->AppendL(TPoint(startx,starty+262));

				DirectGdi::TFillRule fillrule = i%2==0 ? DirectGdi::EAlternate : DirectGdi::EWinding;

				iGc->DrawPolygon(*pointList ,fillrule);

				CleanupStack::PopAndDestroy(pointList);

				}

			}

		}

	// For coverage - test the BrushColor() method works correctly

	iGc->SetBrushColor(KRgbRed);

	TESTL(iGc->BrushColor() == KRgbRed);	

	TEST(KErrNone == WriteTargetOutput(iTestParams, TPtrC(testCaseName)));

	}

/**

Helper method that sets the current pen and brush colours from a color table. The color table used contains a 

palette of 16 standard colors ranging from white to black.

@param aGeneralIndex Used when indexing into the color table for the pen and brush colors, and for setting their alpha values.

@param aAlphaStep Used when setting an alpha value for the pen and the brush, the alpha value is set to (255-aAlphaStep*aGeneralIndex*32).

@param aPenBrushIndex Used when indexing into the color table for the pen and brush colors. The pen color is set to 

KColor16Table[(3*aGeneralIndex+aPenBrushIndex)%16] and the brush color is set to KColor16Table[(5*aGeneralIndex+aPenBrushIndex)%16]. 

 */

void CTBrushAndPen::SetHashColors(TInt aGeneralIndex, TInt aAlphaStep, TInt aPenBrushIndex)

	{

	TRgb penColor;

	TRgb brushColor;

	penColor = KColor16Table[(3*aGeneralIndex+aPenBrushIndex)%16];

	penColor.SetAlpha(255-aAlphaStep*aGeneralIndex*32);

	iGc->SetPenColor(penColor);

	brushColor = KColor16Table[(5*aGeneralIndex+aPenBrushIndex)%16];

	brushColor.SetAlpha(255-aAlphaStep*aGeneralIndex*32);

	iGc->SetBrushColor(brushColor);

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-PENBRUSH-0002

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Test for brush pattern functionality: set a brush pattern for a CDirectGdiContext object,

	then check it has a brush pattern. Test that the SetBrushOrigin() method works as expected.

@SYMTestPriority 

	High

@SYMTestStatus

	Implemented

@SYMTestActions

	Test various brush pattern usage scenarios:

	Set it's brush pattern, then check it has a brush pattern.

	Check setting a brush pattern both from a CFbsBitmap and from a handle.

	Test resetting of brush pattern.

	Call functions that use brush during shapes drawing.

	Create a brush pattern image and set it as the brush pattern. Draw a rectangle, move 

	the brush origin to various positions and draw more shapes.

@SYMTestExpectedResults

	The rectangle is filled correctly for each different brush origins.

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

*/ 

void CTBrushAndPen::TestBrushPatternOriginL()

	{	

	_LIT(KTestName, "PenBrush-BrushPatternOrigin"); //test case name

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	ResetGc();		

	// create patterns programatically so we can test EPatternedBrush		

	TUidPixelFormat pixelFormat = iTestParams.iTargetPixelFormat;

	TSize patternSize(56,56);

	CFbsBitmap* pattern = CreateCheckedBoardBitmapL(pixelFormat, patternSize);

	CleanupStack::PushL(pattern);	

	CFbsBitmap* pattern2 = CreateCheckedBoardBitmapL(pixelFormat, patternSize);

	CleanupStack::PushL(pattern2);	

	//draw nine columns of different shapes with various settings 

	// of brush style and brush origin

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

		{

		switch(i)

			{

			case 0:

				{

				// (for coverage)

				iGc->ResetBrushPattern();

				// Set a brush pattern using CFbsBitmap

				iGc->SetBrushPattern(*pattern);

				TESTNOERRORL(iGc->GetError());

				TEST(iGc->HasBrushPattern());

				iGc->SetBrushStyle(DirectGdi::EPatternedBrush);

				break;

				}

			case 1:

				{

				// Check that ResetBrushPattern works

				iGc->ResetBrushPattern();

				TEST(iGc->HasBrushPattern() == EFalse);

				// Set a brush pattern using a handle

				iGc->SetBrushPattern(pattern2->Handle());

				TEST(iGc->HasBrushPattern());

				iGc->SetBrushStyle(DirectGdi::EPatternedBrush);

				break;

				}

			//change brush origin, and use last settings of brush style	

			case 2:

				{

				// Set a NULL brush pattern, then set the pattern using the handle  

				// for pattern2 (for coverage)

				if(iUseDirectGdi)

					{

					iGc->SetBrushPattern(KNullHandle);				

					TESTL(iGc->GetError() == KErrBadHandle);

					}

				iGc->SetBrushPattern(pattern2->Handle());				

				iGc->SetBrushOrigin(TPoint(10,10));

				break;

				}

			//change brush style and set brush origin

			// in case 4 change only brush origin

			case 3:

				{

				iGc->SetBrushStyle(DirectGdi::EForwardDiagonalHatchBrush);

				iGc->SetPenColor(KRgbGreen);

				iGc->SetBrushColor(KRgbRed);

				iGc->SetBrushOrigin(TPoint(i,i));

				break;

				}

			//change brush style and set brush origin

			// in case 6 change only brush origin

			case 5:

				{

				iGc->SetBrushStyle(DirectGdi::ESquareCrossHatchBrush);

				iGc->SetPenColor(KRgbGreen);

				iGc->SetBrushColor(KRgbRed);

				iGc->SetBrushOrigin(TPoint(i,i));

				break;

				}

			//change brush style and set brush origin

			// in case 8 change only brush origin

			case 7:

				{

				iGc->SetBrushStyle(DirectGdi::EDiamondCrossHatchBrush);

				iGc->SetPenColor(KRgbGreen);

				iGc->SetBrushColor(KRgbRed);

				iGc->SetBrushOrigin(TPoint(i,i));

				break;

				}

			case 4:

			case 6:

			case 8:

				{

				iGc->SetBrushOrigin(TPoint(i,i));

				break;

				}

			}

		//draw a set of shapes using current brush

		TInt startx = 10+i*70;

		TInt endx = 70+i*70;

		TInt starty = 0;

		iGc->DrawRect(TRect(startx,starty+10,endx,starty+30));

		iGc->DrawRoundRect(TRect(startx,starty+40,endx,starty+60), TSize(10,10));

		iGc->DrawPie(TRect(startx,starty+70,endx,starty+130), TPoint(startx,starty+70) , TPoint(endx,starty+70));

		iGc->DrawEllipse(TRect(startx,starty+130 ,endx,starty+190 ));

		CArrayFixFlat<TPoint>* pointList = new (ELeave) CArrayFixFlat<TPoint>(6);

		CleanupStack::PushL(pointList);

		pointList->AppendL(TPoint(startx,starty+200));

		pointList->AppendL(TPoint(startx + 50,starty+250));

		pointList->AppendL(TPoint(startx + 10,starty+250));

		pointList->AppendL(TPoint(endx,starty+200));

		pointList->AppendL(TPoint(endx,starty+270));

		pointList->AppendL(TPoint(startx,starty+270));

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

		CleanupStack::PopAndDestroy(pointList);

		}

	// Check that ResetBrushPattern() works

	iGc->ResetBrushPattern();

	TEST(iGc->HasBrushPattern() == EFalse);				

	pattern2->Reset();

	TESTNOERROR(iGc->GetError());

	TEST(KErrNone == WriteTargetOutput(iTestParams, KTestName()));

	CleanupStack::PopAndDestroy(2, pattern);		

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-PENBRUSH-0003

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Test pen drawing functionality.

@SYMTestPriority 

	High

@SYMTestStatus

	Implemented.

@SYMTestActions

	Test setting pen colour and size.

	Change pen settings:

		colours from the COLOR_TABLE.

		Iterate over various pen sizes.

	Perform drawing operations that use the pen.

	Use also overlapping shapes to test alpha blending.

@SYMTestExpectedResults

	Valid bitmap should be created. Shapes will be drawn with correct pen colour and size.

	This bitmap shall be compared to a reference bitmap.

*/ 

void CTBrushAndPen::TestPenColorSizeL(const DirectGdi::TDrawMode aDrawMode)

	{

	_LIT(KTestName, "PenBrush-PenColorSize_%S"); //test case name

	_LIT(KDrawModePEN, "DrawModePen");

	_LIT(KDrawModeWriteAlpha, "DrawModeWriteAlpha");

	TBuf<50> testCaseName;

	switch (aDrawMode)

		{

		case DirectGdi::EDrawModePEN:

			testCaseName.Format(KTestName, &KDrawModePEN);

			break;

		case DirectGdi::EDrawModeWriteAlpha:

			testCaseName.Format(KTestName, &KDrawModeWriteAlpha);

			break;

		default:

			// This method should only be called aDrawMode set to DirectGdi::EDrawModePEN or DirectGdi::EDrawModeWriteAlpha

			TESTL(EFalse);

			break;

		}

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(testCaseName);	

		}

	ResetGc();

	//draw nine columns of different shapes

	// the last four overlaps to test alpha blending

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

		{

		if(i==0)

			{

			iGc->SetBrushStyle(DirectGdi::ESolidBrush);

			iGc->SetBrushColor(KRgbDarkRed);

			}

		else

			{

			iGc->SetBrushStyle(DirectGdi::ENullBrush);

			}

		TInt stfact = (i<5 ? 0 : i);

		TInt startx = 10+i*70 - stfact*10;

		TInt endx = 70+i*70;

		TRgb penColor;

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

		// The sw version allocates memory when you set a pen size and this memory is not freed

		// until after the __UHEAP_MARKEND macro when running OOM tests, this causes a memory 

		// leak when this test leaves. The following TCleanupItem has been added to reset the pen

		// size to 1,1 on account of a leave as settting the pen size to 1,1 deletes the allocated

		// pen memory.

		CleanupStack::PushL(TCleanupItem(ResetPenSize, iGc));

		penColor = KColor16Table[(5*i+1)%15+1];

		penColor.SetAlpha(255-stfact*30);

		iGc->SetPenColor(penColor);	

		iGc->DrawRect(TRect(startx,10,endx,30));

		penColor = KColor16Table[(5*i+2)%15+1];

		penColor.SetAlpha(255-stfact*30);

		iGc->SetPenColor(penColor);

		iGc->DrawRoundRect(TRect(startx,40,endx,60), TSize(10,10));

		penColor = KColor16Table[(5*i+3)%15+1];

		penColor.SetAlpha(255-stfact*30);

		iGc->SetPenColor(penColor);

		iGc->DrawPie(TRect(startx,70,endx,130), TPoint(startx,70), TPoint(endx,70));

		penColor = KColor16Table[(5*i+4)%15+1];

		penColor.SetAlpha(255-stfact*30);

		iGc->SetPenColor(penColor);

		iGc->DrawEllipse(TRect(startx,135 ,endx,195 ));

		penColor = KColor16Table[(5*i+5)%15+1];

		penColor.SetAlpha(255-stfact*30);

		CArrayFixFlat<TPoint>* pointList = new (ELeave) CArrayFixFlat<TPoint>(6);

		CleanupStack::PushL(pointList);

		pointList->AppendL(TPoint(startx,200));

		pointList->AppendL(TPoint(startx+50,250));

		pointList->AppendL(TPoint(startx+10,250));

		pointList->AppendL(TPoint(endx,200));

		pointList->AppendL(TPoint(endx,270));

		pointList->AppendL(TPoint(startx,270));

		iGc->SetPenColor(penColor);

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

		CleanupStack::PopAndDestroy(pointList);

		penColor = KColor16Table[(5*i+6)%15+1];

		penColor.SetAlpha(255-stfact*30);

		CArrayFixFlat<TPoint>* pointListPolyLine = new (ELeave) CArrayFixFlat<TPoint>(4);

		CleanupStack::PushL(pointListPolyLine);

	    pointListPolyLine->AppendL(TPoint(startx,280));

	    pointListPolyLine->AppendL(TPoint(endx,320));

	    pointListPolyLine->AppendL(TPoint(startx,320));

	    pointListPolyLine->AppendL(TPoint(endx,280));

		iGc->SetPenColor(penColor);

	    iGc->DrawPolyLine(*pointListPolyLine);

	    CleanupStack::PopAndDestroy(pointListPolyLine);

	    penColor = KColor16Table[(5*i+7)%15+1];

		penColor.SetAlpha(255-stfact*30);

		iGc->SetPenColor(penColor);

		iGc->DrawArc(TRect(startx,330 ,endx, 360),TPoint(endx,330),TPoint(startx,330));

	    penColor = KColor16Table[(5*i+8)%15+1];

		penColor.SetAlpha(255-stfact*30);

		iGc->SetPenColor(penColor);

	    iGc->DrawLine(TPoint(startx,355),TPoint(endx,375));

	    penColor = KColor16Table[(5*i+8)%15+1];