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

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "tgc.h"

#include "RemoteGc.h"

#include "CommandBuffer.h"

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

#include "directgdigcwrapper.h"

#include <graphics/directgdidriver.h>

#include <graphics/sgutils.h>

#include <graphics/wsdrawresource.h>

#endif

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

GLDEF_C void CopyImageToBitmapL(CFbsBitmap* aBitmap, const RSgImage& aImage, const TRect& aRect);

GLDEF_C void CopyImageToDestination(TAny* aDataAddressDest, TInt aDataStrideDest, TDisplayMode aDisplayModeDest, 

				TAny* aDataAddressSrc, TInt aDataStrideSrc, TDisplayMode aDisplayModeSrc, const TRect& aRect);

GLDEF_C void CopyImageToDestination64K(TAny* aDataAddressDest, TInt aDataStrideDest, TDisplayMode aDisplayModeDest, 

		TUint16* aDataAddressSrc, TInt aDataStrideSrc, const TRect& aRect);

GLDEF_C void CopyImageToBitmapL(CFbsBitmap* aBitmap, const RSgImage& aImage, const TRect& aRect)

	{

	TSgImageInfo info;

	TInt res = aImage.GetInfo(info);

	if(res == KErrNone)

		{

		info.iUsage = ESgUsageNone;

		info.iCpuAccess = ESgCpuAccessReadOnly;

		RSgImage image;

		res = image.Create(info, aImage);

		if(res == KErrNone)

			{	

			const TAny* dataAddressSrc = NULL; 

			TInt dataStrideSrc = 0;

			res = image.MapReadOnly(dataAddressSrc, dataStrideSrc);

			if(res == KErrNone)

				{

				const TDisplayMode displayModeDest = aBitmap->DisplayMode();

				const TDisplayMode displayModeSrc = SgUtils::PixelFormatToDisplayMode(info.iPixelFormat);

				TUint32* dataAddressDest = aBitmap->DataAddress();

				const TInt dataStrideDest = aBitmap -> DataStride();

				TSize bitmapSize = aBitmap->SizeInPixels();

				TRect rect = aRect;

				TRect rectDest = info.iSizeInPixels;

				rect.Intersection(rectDest);

				if(rect.Height() > bitmapSize.iHeight)

					{

					rect.SetHeight(bitmapSize.iHeight);

					}

				if(rect.Width() > bitmapSize.iWidth)

					{

					rect.SetWidth(bitmapSize.iWidth);

					}

				CopyImageToDestination((TAny*)dataAddressDest, dataStrideDest, displayModeDest, (TAny*)dataAddressSrc, 

								dataStrideSrc, displayModeSrc, rect);

				image.Unmap();

				}

			image.Close();

			}

		}

	}

GLDEF_C void CopyImageToDestination(TAny* aDataAddressDest, TInt aDataStrideDest, TDisplayMode aDisplayModeDest, 

				TAny* aDataAddressSrc, TInt aDataStrideSrc, TDisplayMode aDisplayModeSrc, const TRect& aRect) 

	{

	if(aRect.IsEmpty())

		return;

	if((aDisplayModeDest == aDisplayModeSrc) && (aDataStrideSrc == aDataStrideDest))

		{

		Mem::Copy(aDataAddressDest, aDataAddressSrc, aDataStrideDest * aRect.Height());

		return;

		}

	switch(aDisplayModeSrc)

		{

	case EColor64K:

		{

		CopyImageToDestination64K(aDataAddressDest, aDataStrideDest, aDisplayModeDest, 

						(TUint16*)aDataAddressSrc, aDataStrideSrc, aRect);

		break;

		}

	default:

		break;

		}

	}

GLDEF_C void CopyImageToDestination64K(TAny* aDataAddressDest, TInt aDataStrideDest, TDisplayMode aDisplayModeDest, 

		TUint16* aDataAddressSrc, TInt aDataStrideSrc, const TRect& aRect) 

	{

	const TInt bppSrc = 2;

	const TInt width = aRect.Width();

	const TInt height = aRect.Height();

	const TInt dataStrideLengthSrc = aDataStrideSrc / bppSrc;

	TUint16* dataAddressSrc =  aDataAddressSrc + aRect.iTl.iY * dataStrideLengthSrc + aRect.iTl.iX; 

	const TUint16* dataAddressSrcEnd = dataAddressSrc + dataStrideLengthSrc *  height;  

	switch(aDisplayModeDest)

		{

	case EColor64K:

		{

		TUint16* dataAddressDest = static_cast<TUint16*> (aDataAddressDest); 

		const TInt dataStrideLengthDest = aDataStrideDest / bppSrc;

		while(dataAddressSrcEnd > dataAddressSrc)

			{

			Mem::Copy(dataAddressDest, dataAddressSrc, width * bppSrc);

			dataAddressSrc += dataStrideLengthSrc;

			dataAddressDest += dataStrideLengthDest;

			}

		break;

		}

	case EColor16MU:

		{

		const TInt bppDest = 4;

		TUint32* dataAddressDest = static_cast<TUint32*> (aDataAddressDest); 

		const TInt dataStrideLengthDest = aDataStrideDest / bppDest;

		while(dataAddressSrcEnd > dataAddressSrc)

			{

			const TUint16* dataAddressSrcLineEnd = dataAddressSrc + width;

			TUint32* dataAddressDestCur = dataAddressDest;

			TUint16* dataAddressSrcCur = dataAddressSrc;

			while(dataAddressSrcLineEnd > dataAddressSrcCur)

				{

				*dataAddressDestCur = TRgb::Color64K(*dataAddressSrcCur).Color16MU();

				dataAddressDestCur++;

				dataAddressSrcCur++;

				}

			dataAddressSrc += dataStrideLengthSrc;

			dataAddressDest += dataStrideLengthDest;

			}

		break;

		}

	case EGray4:

		{

		TUint8* dataAddressDest = static_cast<TUint8*> (aDataAddressDest);

		const TInt dataStrideLengthDest = aDataStrideDest;

		while(dataAddressSrcEnd > dataAddressSrc)

			{

			const TUint8* dataAddressDstLineEnd = dataAddressDest + aDataStrideDest;

			TUint8* dataAddressDestCur = dataAddressDest;

			TUint16* dataAddressSrcCur = dataAddressSrc;

			while(dataAddressDstLineEnd > dataAddressDestCur)

				{

				*dataAddressDestCur = 0;

				for(TInt index = 0; index < 8; index +=2)

					{

					TInt col = TRgb::Color64K(*dataAddressSrcCur).Gray4();

					col <<= index;

					*dataAddressDestCur |= col;

					dataAddressSrcCur++;

					}

				dataAddressDestCur++;

				}

			dataAddressSrc += dataStrideLengthSrc;

			dataAddressDest += dataStrideLengthDest;

			}

		break;

		}

	case EColor256:

		{

		TUint8* dataAddressDest = static_cast<TUint8*> (aDataAddressDest);

		const TInt dataStrideLengthDest = aDataStrideDest;

		while(dataAddressSrcEnd > dataAddressSrc)

			{

			const TUint8* dataAddressDstLineEnd = dataAddressDest + aDataStrideDest;

			TUint8* dataAddressDestCur = dataAddressDest;

			TUint16* dataAddressSrcCur = dataAddressSrc;

			while(dataAddressDstLineEnd > dataAddressDestCur)

				{

				*dataAddressDestCur = TRgb::Color64K(*dataAddressSrcCur).Color256();

				dataAddressSrcCur++;

				dataAddressDestCur++;

				}

			dataAddressSrc += dataStrideLengthSrc;

			dataAddressDest += dataStrideLengthDest;

			}

		break;

		}

	default:

		break;

		}

	}

TDisplayMode DisplayModeFromPixelFormat(TUidPixelFormat aPixelFormat)

	{

	switch(aPixelFormat)

		{

	case EUidPixelFormatARGB_8888_PRE:

		return EColor16MAP;

	case EUidPixelFormatARGB_8888:

		return EColor16MA;

	case EUidPixelFormatRGB_565:

		return EColor64K;

	default:

		break;

		}

	return ENone;

	}

TUidPixelFormat PixelFormatFromDisplayMode(TDisplayMode aDisplayMode)

	{

	switch (aDisplayMode)

		{

		case EGray2:

		case EGray4:

		case EGray16:

		case EGray256:

		case EColor16:

		case EColor256:

		case EColor16M:

		case EColor16MU:

			{

			return EUidPixelFormatXRGB_8888;

			}

		case EColor4K:

			{

			return EUidPixelFormatXRGB_4444;

			}

		case EColor64K:

			{

			return EUidPixelFormatRGB_565;

			}

		case EColor16MA:

			{

			return EUidPixelFormatARGB_8888;

			}

		case EColor16MAP:

			{

			return EUidPixelFormatARGB_8888_PRE;

			}

		default:

			{

			return EUidPixelFormatUnknown;

			}

		}

	}

#endif

CTGc::CTGc(CTestStep* aStep) : CTWsGraphicsBase(aStep)

	{

	}

CTGc::~CTGc()

	{

	delete iTest;

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

	SgDriver::Close();

	CDirectGdiDriver *directGdiDriver = CDirectGdiDriver::Static();

	if(directGdiDriver)

		{

		directGdiDriver->Close();

		}

#endif

	}

void CTGc::ConstructL()

	{

	_LIT(KTestName,"GC Test");

	iTest=new(ELeave) CTestBase(KTestName,this);

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

	TInt err = CDirectGdiDriver::Open();

	User::LeaveIfError(err);

	err = SgDriver::Open();

	if(err != KErrNone)

		{

		CDirectGdiDriver *directGdiDriver = CDirectGdiDriver::Static();

		if(directGdiDriver)

			{

			directGdiDriver->Close();

			}

		User::Leave(err);

		}

#endif

	}

//Class derived from MWsGraphicResolver. Used for playing the commands from command buffer

class CWSGraphicsRes: public CBase, public MWsGraphicResolver

	{

public:

	void DrawWsGraphic(TInt /*aId*/, TBool /*aIsUid*/, const TRect& /*aRect*/, const TDesC8& /*aData*/) const

		{

		//Orveriding by giving empty implemention

		}

	};

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

//

//Class CDrawTextInContextTest

//

CDrawTextInContextTest::CDrawTextInContextTest(){}

CDrawTextInContextTest::~CDrawTextInContextTest()

	{

	delete iRefBitmap;

	delete iRefDevice;

	delete iRefBitGc;

	delete iRemoteGc;

	iMsgBuf.Close();

	delete iCommandBuffer;

	delete iWsGraphicRes;

	TheClient->iScreen->ReleaseFont(iFont);

	delete iDirectGdiGcWrapper;

	if(iWrapperImageTarget)

		{

		iWrapperImageTarget->Close();

		}

	delete iWrapperImageTarget;

	iWrapperImage.Close();

	iWrapperImageCollection.Close();

	}

void CDrawTextInContextTest::BaseConstructL()

	{

	//Initialise font settings

	TFontSpec fsp;

	fsp.iTypeface.iName=_L("Series 60 Sans");

	fsp.iHeight=430;

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

	//Initialise TTextParameter

	iParam.iStart = 27;

	iParam.iEnd = 60;

	//Text to draw

	iText.Set(_L("This text will not be drawnK.,!\"\x00A3$%^&*()_+-=;'#:@~/<>? Latin This text will not be drawn"));

	//For reference bitmap

	iRefBitmap = new(ELeave) CFbsBitmap();

	User::LeaveIfError(iRefBitmap->Create(KBitmapSize, EColor64K));

	iRefDevice = CFbsBitmapDevice::NewL(iRefBitmap);

	User::LeaveIfError(iRefDevice->CreateContext(iRefBitGc));

	CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static();

	User::LeaveIfNull(theDGdiDriver);

	TSgImageInfo info;

	info.iUsage = ESgUsageDirectGdiTarget | ESgUsageDirectGdiSource | ESgUsageCompositionSource;

	info.iSizeInPixels = KBitmapSize;

	info.iPixelFormat = EUidPixelFormatRGB_565;

	TInt res = iWrapperImageCollection.Create(info, 1);

	User::LeaveIfError(res);

	res = iWrapperImageCollection.OpenImage(0, iWrapperImage);

	User::LeaveIfError(res);

	iWrapperImageTarget = new (ELeave) RDirectGdiImageTarget(*theDGdiDriver);

	res = iWrapperImageTarget->Create(iWrapperImage);

	User::LeaveIfError(res);

	iDirectGdiGcWrapper = CDirectGdiGcWrapper::NewL(*iWrapperImageTarget);

	//clean image-----------------

	CDirectGdiGcWrapper* directGdiGcWrapper = CDirectGdiGcWrapper::NewL(*iWrapperImageTarget);

	CleanupStack::PushL(directGdiGcWrapper);

	directGdiGcWrapper->SetDrawMode(MWsGraphicsContext::EDrawModeWriteAlpha);

	directGdiGcWrapper->SetBrushColor(KRgbWhite);

	directGdiGcWrapper->Clear();

	CleanupStack::PopAndDestroy(1, directGdiGcWrapper);

	//------------------

	//Used to record draw commands

	iRemoteGc = CRemoteGc::NewL(TheClient->iScreen);

	//Used to play recorded draw commands

	iCommandBuffer = CCommandBuffer::NewL();

	//Dummy class created required for CCommandBuffer::Play

	iWsGraphicRes = new (ELeave) CWSGraphicsRes();

	//Offset for CCommandBuffer::Play

	iOffset = TPoint(0,0);

	//Result of doing the test

	iHasPassedTest = EFalse;

	}

void CDrawTextInContextTest::Test()

	{	

	/* Create reference bitmap by drawing using bitgc */

	iRefBitGc->UseFont(iFont);

	DoDrawTextBitGc();

	iRefBitGc->DiscardFont();

	/* Drawing using CBitGcWrapper via CRemotGc*/

	//Capturing the commands in remote gc

	iRemoteGc->BeginDraw(KBitmapRect);

	iRemoteGc->UseFont(iFont);

	DoDrawTextRemoteGc();

	iRemoteGc->DiscardFont();

	iRemoteGc->EndDraw();

	//Externalize the captured commands from remote gc in to a buffer

	iRemoteGc->ExternalizeL(iMsgBuf, ETrue);

	//Internalize the buffer with captured commands (from CRemoteGC) in to CCommandBuffer

	iCommandBuffer->InternalizeL(iMsgBuf.Pckg());

	//Play the commands on test window using command buffer

	iCommandBuffer->Play(iOffset,&KBitmapRegion,KBitmapRect,*iWsGraphicRes,*iDirectGdiGcWrapper);

	//Test to see if the bitmap drawn to using CRemoteGc is the same as the reference bitmap

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(bitmap);

	TSgImageInfo info;

	iWrapperImage.GetInfo(info);

	TDisplayMode displayMode = DisplayModeFromPixelFormat(info.iPixelFormat);

	bitmap->Create(info.iSizeInPixels, displayMode);

	TRect rect(info.iSizeInPixels);

	CopyImageToBitmapL(bitmap, iWrapperImage, rect);

	iHasPassedTest = LossyCompareBitmap(*iRefBitmap, *bitmap, KBitmapRect, EFalse);

	CleanupStack::PopAndDestroy(bitmap);

	}

TBool CDrawTextInContextTest::HasPassedTest()

	{

	return iHasPassedTest;

	}

//

// Class DrawTextInContextTestPoint

//

CDrawTextInContextTestPoint::CDrawTextInContextTestPoint(){}

CDrawTextInContextTestPoint::~CDrawTextInContextTestPoint(){}

CDrawTextInContextTestPoint* CDrawTextInContextTestPoint::NewL()

	{

	CDrawTextInContextTestPoint* self = new(ELeave) CDrawTextInContextTestPoint;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CDrawTextInContextTestPoint::ConstructL()

	{

	BaseConstructL();

	iPosition = TPoint(0,0);

	}

void CDrawTextInContextTestPoint::DoDrawTextBitGc()

	{

	iRefBitGc->DrawText(iText,&iParam,iPosition);

	}

void CDrawTextInContextTestPoint::DoDrawTextRemoteGc()

	{

	iRemoteGc->DrawText(iText,&iParam,iPosition);

	}

//

// Class DrawTextInContextTestBox

//

CDrawTextInContextTestBox::CDrawTextInContextTestBox(){}

CDrawTextInContextTestBox::~CDrawTextInContextTestBox(){}

CDrawTextInContextTestBox* CDrawTextInContextTestBox::NewL()

	{

	CDrawTextInContextTestBox* self = new(ELeave) CDrawTextInContextTestBox;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CDrawTextInContextTestBox::ConstructL()

	{

	BaseConstructL();

	iClipFillRect = TRect(10,50,640,120);

	iBaselineOffset = 40;

	iTTextAlign = CGraphicsContext::ELeft;

	}

void CDrawTextInContextTestBox::DoDrawTextBitGc()

	{

	iRefBitGc->DrawText(iText,&iParam,iClipFillRect,iBaselineOffset,iTTextAlign);

	}

void CDrawTextInContextTestBox::DoDrawTextRemoteGc()

	{

	iRemoteGc->DrawText(iText,&iParam,iClipFillRect,iBaselineOffset,iTTextAlign);

	}

//

// Class CDrawTextInContextTestPointVertical

//

CDrawTextInContextTestPointVertical::CDrawTextInContextTestPointVertical(){}

CDrawTextInContextTestPointVertical::~CDrawTextInContextTestPointVertical(){}

CDrawTextInContextTestPointVertical* CDrawTextInContextTestPointVertical::NewL()

	{