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

// Test wrapper to bitgdi component of graphics.

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code 

*/

#include <tgdi.mbg>

#include "TGDI.H"

#include "TBMP.H"

#include <bitdev.h>

#define MAXCOLORS 255

_LIT(KT23BitmapFileName,"z:\\system\\data\\tgdi.mbm");

// TestGdi methods

EXPORT_C TestGdi::TestGdi():

	iDev(NULL),

	iCon(NULL),

	iSize(0,0),

	iSection(NULL)

	{}

// This function is modified. contents are moved to below function

EXPORT_C void TestGdi::Construct(CBitmapDevice* aDevice,CFbsBitGc* aContext,TDes& aFailureSection)

	{

	TRAP_IGNORE(ConstructL(aDevice, aContext, aFailureSection));

	}

// This is additional function with suffix L

EXPORT_C void TestGdi::ConstructL(CBitmapDevice* aDevice,CFbsBitGc* aContext,TDes& aFailureSection)

	{

	__ASSERT_ALWAYS(aFailureSection.MaxLength() == KFailureSectionNameBufferLength,User::Panic(_L("TGDI"),KErrBadDescriptor));

	iDev = aDevice;

	iCon = aContext;

	iSize = iDev->SizeInPixels();

	iSection = &aFailureSection;

	iCon->SetPenSize(TSize(1,1));

	iCon->SetDrawMode(CGraphicsContext::EDrawModePEN);

	iCon->SetPenColor(KRgbBlack);

	iCon->SetPenStyle(CGraphicsContext::ESolidPen);

	iCon->SetBrushColor(KRgbBlack);

	iCon->SetBrushStyle(CGraphicsContext::ENullBrush);

	iRect.iTl.iX=iSize.iWidth/3;

	iRect.iTl.iY=iSize.iHeight/3;

	iRect.iBr.iX=iSize.iWidth*2/3;

	iRect.iBr.iY=iSize.iHeight*2/3;

	iBitmapWidth=50;

	iBitmapHeight=87;

	iZeroRect.SetRect(iRect.iTl,iRect.iTl);

	iUnitRect.SetRect(iRect.iTl,iRect.iTl+TPoint(1,1));

	iUnNormRect.iTl=iRect.iBr;

	iUnNormRect.iBr=iRect.iTl;

	iLargeRect.SetRect(-iSize.iWidth,-iSize.iHeight,iSize.iWidth*2,iSize.iHeight*2);

	iCentredRect.iTl=TPoint(0,0)-iRect.iTl;

	iCentredRect.iBr=iRect.iTl;

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

		iOffScreenRects[count]=iRect;

	iOffScreenRects[0].Move(-iSize.iWidth,-iSize.iHeight);

	iOffScreenRects[1].Move(0,-iSize.iHeight);

	iOffScreenRects[2].Move(iSize.iWidth,-iSize.iHeight);

	iOffScreenRects[3].Move(iSize.iWidth,0);

	iOffScreenRects[4].Move(iSize.iWidth,iSize.iHeight);

	iOffScreenRects[5].Move(0,iSize.iHeight);

	iOffScreenRects[6].Move(-iSize.iWidth,iSize.iHeight);

	iOffScreenRects[7].Move(-iSize.iWidth,0);

	TInt ret = iBitmap.Load(_L("z:\\system\\data\\tbmp.mbm"),EMbmTbmpTgdigen,EFalse);

	User::LeaveIfError(ret);

	ret = iBitmap2.Load(_L("z:\\system\\data\\tbmp.mbm"),EMbmTbmpTblank,EFalse);

	User::LeaveIfError(ret);

	}

EXPORT_C TBool TestGdi::Test()

	{

	// Get FBSERV to create its long lived objects to avoid trigering memory leaks.

	CFbsBitmap* srcBmp = new CFbsBitmap;

	if (srcBmp==NULL || srcBmp->Create(iSize,EColor16MU)!=KErrNone)

		{

		return EFalse;

		}

	delete srcBmp;

	CFbsBitmap* t23SrcBmp = new (ELeave) CFbsBitmap();

	TInt ret = t23SrcBmp->Load(KT23BitmapFileName,EMbmTgdiDef064071_sourcebitmap);

	delete t23SrcBmp;

	if(ret != KErrNone)

		{

		return EFalse;

		}

	TRAPD(err,DoTestL());

	if (err != KErrNone)

		iSection->AppendFormat(_L(", error %d"), err);

	iBitmap.Reset();

	iBitmap2.Reset();

	return err == KErrNone;

	}

void TestGdi::DoTestL()

	{

	*iSection = _L("Testing graphics functions");

	CheckL(iSize!=TSize(0,0));

	Clear();

	TRgb col;

	iDev->GetPixel(col,TPoint(iSize.iWidth/2,iSize.iHeight/2));

	CheckL(col==KRgbWhite);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	Clear();

	CheckClearL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0001

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0001"));

	DoArcL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0002

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0002"));

	DoEllipseL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0003

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0003"));

	DoRoundRectL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0004

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0004"));

	DoPieL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0005

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0005"));

	DoModeL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0006

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0006"));

	DoColorL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0007

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0007"));

	DoLineL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0008

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0008"));

	DoWideLineL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0009

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0009"));

	DoRectL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0010

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0010"));

	DoPolygonArrayL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0011

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0011"));

	DoPolygonPtrL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0012

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0012"));

	DoPolygonPtr0();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0013

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0013"));

	DoText();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0014

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0014"));

	DoPaintL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0015

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0015"));

	DoCopyL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0016

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0016"));

	DoBltL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0017

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0017"));

	DoBltMaskedL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0018

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0018"));

	DoShadowL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0019

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0019"));

	DoFadeL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0020

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0020"));

	DoDrawBitmapSemiTransparentMaskedL();

	RecordTestResultL();

	// If DoDrawBitmapMaskedL causes a User Panic 21, it might be a positive failure of case #24. 

	SetTestStepID(_L("GRAPHICS-TestGdi-DoDrawBitmapMaskedL-0001"));	

	DoDrawBitmapMaskedL(ETrue);

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-TestGdi-DoDrawBitmapMaskedL-0001"));

	DoDrawBitmapMaskedL(EFalse);

	RecordTestResultL();

	//test bitmap width 52 (wordalignable)

	iBitmapWidth=52;

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0021

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0021"));

	DoBltL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0022

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0022"));

	DoBltMaskedL();

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-TestGdi-DoDrawBitmapMaskedL-0001"));

	DoDrawBitmapMaskedL(ETrue);

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-TestGdi-DoDrawBitmapMaskedL-0001"));

	DoDrawBitmapMaskedL(EFalse);

	RecordTestResultL();

	//test with compressed bitmaps

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0023

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0023"));

	DoBltCompressedL();

	RecordTestResultL();

/**

 @SYMTestCaseID GRAPHICS-TestGdi-0024

*/

	SetTestStepID(_L("GRAPHICS-TestGdi-0024"));

	DoBoxTextVertical();

	RecordTestResultL();

	}

void TestGdi::CheckL(TBool aValue)

	{

	if (!aValue)

		User::Leave(KErrGeneral);

	}

void TestGdi::Clear()

	{

	iCon->SetDrawMode(CGraphicsContext::EDrawModePEN);

	iCon->SetPenStyle(CGraphicsContext::ENullPen);

	iCon->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iCon->SetBrushColor(KRgbWhite);

	iCon->DrawRect(TRect(TPoint(0,0),iSize));

	iCon->SetPenStyle(CGraphicsContext::ESolidPen);

	iCon->SetPenColor(KRgbBlack);

	iCon->SetBrushColor(KRgbBlack);

	}

LOCAL_C void FreeAlloc(TAny* aPtr)

	{

	TRgb* scanline = reinterpret_cast <TRgb*> (aPtr);

	User::Free(scanline);

	}

void TestGdi::ScanAreaL(TInt x,TInt y,TInt length,TInt height,TRgb Color)

	{

	if(x>iSize.iWidth)

		return;

	if(x<0)

		{

		length=length+x;

		x=0;

		}

	if(x+length>iSize.iWidth)

		length=iSize.iWidth-x;

	if(length<=0)

		return;

	TRgb* scanline=(TRgb*)User::Alloc(sizeof(TRgb)*length);

	CleanupStack::PushL(TCleanupItem(FreeAlloc, scanline));

	TPtr8 scln((TUint8*)scanline,length*sizeof(TRgb));

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

		{

		if(y+row>=0 && y+row<iSize.iHeight)

			{

			iDev->GetScanLine(scln,TPoint(x,y+row),length,ERgb);

			for(TInt index=0;index<length;index++)

				{

				CheckL(scanline[index] == Color);

				}

			}

		}

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

		{

		scanline[i].~TRgb();

		}

	CleanupStack::PopAndDestroy(scanline);

	}

void TestGdi::CheckClearL()

	{

	TInt quarht=iSize.iHeight>>2;

	TInt halfht=iSize.iHeight>>1;

	TInt thrqht=quarht+halfht;

	ScanAreaL(0,0,iSize.iWidth,1,KRgbWhite);

	ScanAreaL(0,quarht,iSize.iWidth,quarht+1,KRgbWhite);

	ScanAreaL(0,halfht,iSize.iWidth,halfht+1,KRgbWhite);

	ScanAreaL(0,thrqht,iSize.iWidth,thrqht+1,KRgbWhite);

	ScanAreaL(0,iSize.iHeight-1,iSize.iWidth,iSize.iHeight,KRgbWhite);

	ScanAreaL(iRect.iTl.iX,iRect.iTl.iY,1,1,KRgbWhite);

	}

void TestGdi::CheckPlotL(const TPoint& pt)

	{

	ScanAreaL(pt.iX,pt.iY,1,1,KRgbBlack);

	ScanAreaL(pt.iX-1,pt.iY-1,3,1,KRgbWhite);

	ScanAreaL(pt.iX-1,pt.iY+1,3,1,KRgbWhite);

	ScanAreaL(pt.iX-1,pt.iY,1,1,KRgbWhite);

	ScanAreaL(pt.iX+1,pt.iY,1,1,KRgbWhite);

	Clear();

	}

void TestGdi::CheckRectInsideL(const TRect& rect)

	{

	ScanAreaL(rect.iTl.iX,rect.iTl.iY,rect.iBr.iX-rect.iTl.iX,1,KRgbBlack);

	ScanAreaL(rect.iTl.iX,rect.iBr.iY-1,rect.iBr.iX-rect.iTl.iX,1,KRgbBlack);

	}

void TestGdi::CheckRectOutsideL(const TRect& rect)

	{

	ScanAreaL(rect.iTl.iX-1,rect.iTl.iY-1,rect.iBr.iX-rect.iTl.iX,1,KRgbWhite);

	ScanAreaL(rect.iTl.iX-1,rect.iBr.iY,rect.iBr.iX-rect.iTl.iX+1,1,KRgbWhite);

	}

void TestGdi::CheckQuadOutsideL(const TRect& rect)

	{

	ScanAreaL(rect.iTl.iX-1,rect.iTl.iY-6,rect.iBr.iX-rect.iTl.iX+1,1,KRgbWhite);

	ScanAreaL(rect.iTl.iX-1,rect.iBr.iY-5,rect.iBr.iX-rect.iTl.iX+1,1,KRgbWhite);

	}

void TestGdi::CheckQuadInsideL(const TRect& rect)

	{

	if(rect.iBr.iX-rect.iTl.iX-11>0)

		ScanAreaL(rect.iTl.iX+5,(rect.iTl.iY+rect.iBr.iY)/2,rect.iBr.iX-rect.iTl.iX-11,1,KRgbBlack);

	}

void TestGdi::DoModeL()

	{

	if(iDev->DisplayMode()==EGray2) return;

	*iSection = _L("Drawing mode");

	Clear();

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTPEN);

	iCon->SetPenColor(KRgbWhite);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	iCon->SetPenColor(KRgbDarkGray);

	iCon->Plot(iRect.iTl);

	iCon->SetDrawMode(CGraphicsContext::EDrawModeAND);

	iCon->SetPenColor(KRgbGray);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	iCon->SetPenColor(KRgbGray);

	iCon->Plot(iRect.iTl);

	iCon->SetDrawMode(CGraphicsContext::EDrawModeANDNOT);

	iCon->SetPenColor(KRgbGray);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	iCon->Plot(iRect.iTl);

	iCon->SetDrawMode(CGraphicsContext::EDrawModeOR);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	iCon->Plot(iRect.iTl);

	iCon->SetDrawMode(CGraphicsContext::EDrawModeORNOT);

	iCon->SetPenColor(KRgbWhite);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	iCon->SetPenColor(KRgbGray);

	iCon->Plot(iRect.iTl);

	iCon->SetDrawMode(CGraphicsContext::EDrawModeXOR);

	iCon->SetPenColor(KRgbGray);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	iCon->SetPenColor(KRgbDarkGray);

	iCon->Plot(iRect.iTl);

	iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTXOR);

	iCon->SetPenColor(KRgbGray);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTAND);

	iCon->SetPenColor(KRgbWhite);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	iCon->Plot(iRect.iTl);

	iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTANDNOT);

	iCon->SetPenColor(KRgbWhite);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTOR);

	iCon->SetPenColor(KRgbBlack);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTORNOT);

	iCon->SetPenColor(KRgbWhite);

	iCon->Plot(iRect.iTl);

	CheckPlotL(iRect.iTl);

	}

void TestGdi::DoColorL()

	{

	*iSection = _L("Colors");

	Clear();

	for(TInt count=0;count<256;count++)

		{

		iCon->SetPenColor(TRgb::Gray256(count));

		iCon->Plot(iRect.iTl);

		TRgb screencolor;

		iDev->GetPixel(screencolor,iRect.iTl);

		switch(iDev->DisplayMode())

			{

		case EGray2:

			CheckL(screencolor.Gray2()==count>>7);

			break;

		case EGray4:

			CheckL(Abs(screencolor.Gray4()-(count>>6))<2);

			break;

		case EGray16:

			if(screencolor.Gray16()!=(count>>4))

				CheckL(Abs(screencolor.Gray4()-(count>>6))<2);

			break;

		case EGray256:

			CheckL(screencolor.Gray256()==count);

			break;

		default:

			break;

			}

		iCon->SetPenColor(KRgbWhite);

		iCon->Plot(iRect.iTl);

		iDev->GetPixel(screencolor,iRect.iTl);

		CheckL(screencolor==KRgbWhite);

		}

	}

void TestGdi::DoLineL()

	{

	*iSection = _L("Line drawing");

	Clear();

	iCon->DrawLine(iRect.iTl,iRect.iTl);

	iCon->DrawLine(iRect.iTl,iRect.iTl+TPoint(1,1));

	CheckPlotL(iRect.iTl);

	Clear();

	iCon->DrawLine(iRect.iTl,TPoint(iRect.iBr.iX,iRect.iTl.iY));

	CheckRectInsideL(TRect(iRect.iTl,TPoint(iRect.iBr.iX,iRect.iTl.iY+1)));

	CheckRectOutsideL(TRect(iRect.iTl,TPoint(iRect.iBr.iX,iRect.iTl.iY+1)));

	Clear();