// 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()

	{

	CDrawTextInContextTestPointVertical* self = new(ELeave) CDrawTextInContextTestPointVertical;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CDrawTextInContextTestPointVertical::ConstructL()

	{

	BaseConstructL();

	iPosition = TPoint(0,0);

	iUp = EFalse;

	}

void CDrawTextInContextTestPointVertical::DoDrawTextBitGc()

	{

	iRefBitGc->DrawTextVertical(iText,&iParam,iPosition,iUp);

	}

void CDrawTextInContextTestPointVertical::DoDrawTextRemoteGc()

	{

	iRemoteGc->DrawTextVertical(iText,&iParam,iPosition,iUp);

	}

//

// Class CDrawTextInContextTestBoxVertical

//

CDrawTextInContextTestBoxVertical::CDrawTextInContextTestBoxVertical(){}

CDrawTextInContextTestBoxVertical::~CDrawTextInContextTestBoxVertical(){}

CDrawTextInContextTestBoxVertical* CDrawTextInContextTestBoxVertical::NewL()

	{

	CDrawTextInContextTestBoxVertical* self = new(ELeave) CDrawTextInContextTestBoxVertical;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CDrawTextInContextTestBoxVertical::ConstructL()

	{

	BaseConstructL();

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

	iBaselineOffset = 40;

	iUp = EFalse;

	iTTextAlign = CGraphicsContext::ELeft;

	}

void CDrawTextInContextTestBoxVertical::DoDrawTextBitGc()

	{

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

	}

void CDrawTextInContextTestBoxVertical::DoDrawTextRemoteGc()

	{

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

	}

#endif //TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

void CleanUpFont(TAny* aFont)

	{

	//Will be called in case of a leave to release the font

	CFont* font= static_cast<CFont*>(aFont);

	TheClient->iScreen->ReleaseFont(font);

	}

/**

@SYMTestCaseID		GRAPHICS-WSERV-0437

@SYMPREQ            PREQ1543

@SYMTestCaseDesc    Draw text using CWindowGc and CRemoteGc with both outline and shadow

effect on.

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Create a font with both outline and shadow effects. Record the commands 

(like setting colours,drawing text etc) using CRemoteGc and play the recorded commands on a window. Use the same

commands in CWindowGc and draw text on a different window

@SYMTestExpectedResults Text drawn using CWindowGc and CRemoteGc should be same

*/

void CTGc::TestOutlineAndShadowL()

	{

	TRect sourceRect(0, 0, TestWin->Size().iWidth, TestWin->Size().iHeight);

	TRegionFix<1> clippingRegion(sourceRect);

	CWsScreenDevice* device = TheClient->iScreen;

	_LIT(KText,"Outline and shadow");

	TFontSpec fSpec(KTestFontTypefaceName,23);

	fSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

	fSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue);

	fSpec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue);

	CFont *font;

	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInPixels((CFont *&)font, fSpec));

	CleanupStack::PushL(TCleanupItem(CleanUpFont, font));

	CRemoteGc* remoteGc = CRemoteGc::NewL(device);

	CleanupStack::PushL(remoteGc);

	remoteGc->BeginDraw(sourceRect);

	//Capturing the commands in remote gc

	remoteGc->SetBrushColor(KRgbGreen);

	remoteGc->SetShadowColor(KRgbDarkRed);

	remoteGc->SetPenColor(KRgbBlack);

	remoteGc->UseFont(font);

	remoteGc->DrawText(KText, TPoint(2,40));

	remoteGc->DiscardFont();

	remoteGc->EndDraw();

	RWsGraphicMsgBuf msgBuf;

	CleanupClosePushL(msgBuf);

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

	remoteGc->ExternalizeL(msgBuf, ETrue);

	CWSGraphicsRes* wsGrap = new (ELeave) CWSGraphicsRes();

	CleanupStack::PushL(wsGrap);

	CCommandBuffer* cmdBuf = CCommandBuffer::NewL();

	CleanupStack::PushL(cmdBuf);

	//Internalize the buffer with captured commands (from CRemoteGC) 

	//in to CCommandBuffer

	cmdBuf->InternalizeL(msgBuf.Pckg());

	TestWin->Win()->Invalidate();

	TestWin->Win()->BeginRedraw();

	TheGc->Activate(*TestWin->Win());

	TheGc->Clear();

	//Play the commands on test window using command buffer

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

	cmdBuf->Play(TPoint(0, 0), &clippingRegion, sourceRect, TheClient->iWs, *TheGc);

#else

	cmdBuf->Play(TPoint(),TRect(TestWin->Size()),*wsGrap,*TheGc);

#endif

	TheGc->Deactivate();

	TestWin->Win()->EndRedraw();

	BaseWin->Win()->Invalidate();

	BaseWin->Win()->BeginRedraw();

	TheGc->Activate(*BaseWin->Win());

	TheGc->Clear();

	TheGc->SetBrushColor(KRgbGreen);

	TheGc->SetShadowColor(KRgbDarkRed);

	TheGc->SetPenColor(KRgbBlack);

	TheGc->UseFont(font);

	//Draw the text on base window using CWindowGC

	TheGc->DrawText(KText, TPoint(2, 40));

	TheGc->DiscardFont();

	TheGc->Deactivate();

	BaseWin->Win()->EndRedraw();

	TheClient->iWs.Finish();

	TheClient->WaitForRedrawsToFinish();

	//Check the text drawn on base and test windows.

	CheckRect(BaseWin, TestWin, TRect(0, 0, BaseWin->Size().iWidth, BaseWin->Size().iHeight), _L("CTGc::TestOutlineAndShadowL()"));

	CleanupStack::PopAndDestroy(4, remoteGc); //cmdBuf, wsGrap, msgBuf and remoteGc

	CleanupStack::Pop();//font

	TheClient->iScreen->ReleaseFont(font);

	}

void CTGc::TestGcClipRectOrigin_DrawContent(TestWindow& aWindow, TBool bActivateBeforeRedraw /*= ETrue*/)

	{

	TSize winSize = aWindow.Size();

	TPoint gcOrigin(winSize.iWidth >> 3, winSize.iWidth >> 3);

	TRect gcClipRect(0, 0, (winSize.iWidth * 3) >> 2, (winSize.iHeight * 3) >> 2);

	TRect ellipseRect(gcClipRect);

	// Shrink the ellipse for better visibility and to fit well within the clip area.

	ellipseRect.Shrink(3, 3);

	TSize penSize(1, 1);

	aWindow.Win()->SetBackgroundColor(KRgbGreen);

	aWindow.ClearWin();

	aWindow.Win()->Invalidate();

	if(!bActivateBeforeRedraw)

		{

		aWindow.Win()->BeginRedraw();

		}

	TheGc->Activate(*(aWindow.Win()));

	TheGc->SetOrigin(gcOrigin);

	TheGc->SetClippingRect(gcClipRect);

	if(bActivateBeforeRedraw)

		{

		aWindow.Win()->BeginRedraw();

		}

	TheGc->SetBrushColor(KRgbDarkRed);

	TheGc->SetPenColor(KRgbDarkRed);

	TheGc->SetPenSize(penSize);

	TheGc->SetPenStyle(CGraphicsContext::ESolidPen);

	TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	TheGc->DrawEllipse(ellipseRect);

	TheGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	TheGc->SetPenColor(KRgbYellow);

	TheGc->SetPenStyle(CGraphicsContext::EDashedPen);

	TheGc->DrawRect(gcClipRect);

	aWindow.Win()->EndRedraw();

	TheGc->Deactivate();

	}

/**

@SYMTestCaseID		GRAPHICS-WSERV-0471

@SYMTestCaseDesc    This test is to verify that the GC correctly applies the clip rect and

					origin attributes irrespective of whether the GC is activated on the

					window before or after the BeginRedraw.

@SYMDEF				PDEF120091

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     The test has following steps:

	1. For the Test window follow the steps:

		A. Activate the GC on Test window.

		B. Set the Origin of the GC to centre of the window.

		C. Set the Clipping rectangle of the GC to half the size of the window.

		D. In the BeginDraw and EndDraw call bracket perform the following:

			a. Draw an ellipse with the rectangle smaller by 5 pixels than the clip rectangle.

			b. Draw a rectangle that is size of the clip rectangle.

		E. Deactivate the GC. 

	2. For the Base window follow the steps:

		A. In the BeginDraw and EndDraw call bracket perform the following:

			a. Activate the GC on Base window.

			b. Set the Origin of the GC to centre of the window.

			c. Set the Clipping rectangle of the GC to half the size of the window.

			d. Draw an ellipse with the rectangle smaller by 5 pixels than the clip rectangle.

			e. Draw a rectangle that is size of the clip rectangle.

			f. Deactivate the GC. 

	3. Compare Test and Base window.

@SYMTestExpectedResults Both the Test and Base window should have the complete

						non-clipped ellipse completely encapsulated within the rectangle. 

*/

void CTGc::TestGcClipRectOrigin()

	{

	TestGcClipRectOrigin_DrawContent(*BaseWin, EFalse);

	TestGcClipRectOrigin_DrawContent(*TestWin, ETrue);

	TheClient->Flush();

	CheckRect(BaseWin, TestWin, TRect(0, 0, BaseWin->Size().iWidth, BaseWin->Size().iHeight), _L("CTGc::TestGcClipRectOriginL()"));

	}

/**

@SYMTestCaseID		GRAPHICS-WSERV-0469

@SYMDEF             INC116406

@SYMTestCaseDesc    Try playback on MWsGraphicsContext and CWindowGc to check that the background colour is

set correctly.

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions

@SYMTestExpectedResults Text drawn using CWindowGc should use the background colour of

the window, and MWsGraphicsContext should use transparent white.

*/

void CTGc::TestResetWithBackgroundColorL()

	{

	const TRect KSourceRect(0, 0, TestWin->Size().iWidth, TestWin->Size().iHeight);

	const TRegionFix<1> KClippingRegion(KSourceRect);

	CWsScreenDevice* device = TheClient->iScreen;

	CRemoteGc* remoteGc = CRemoteGc::NewL(device);

	CleanupStack::PushL(remoteGc);

	//note this remote GC has not been activated on any window

	remoteGc->BeginDraw(KSourceRect);

	//Draw the commands in remote gc

	remoteGc->SetBrushColor(KRgbGreen);  //nothing green is seen in this test

	remoteGc->Reset(); //This resets the brush colour to the background colour of the window

					   //where playback is, in the case of playing back to a window

					   //however with a CFbsBitGc the color is transparent white, as there is no window.

	remoteGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	remoteGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

	remoteGc->DrawRect(KSourceRect);

	remoteGc->EndDraw();

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

	CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static();

	User::LeaveIfNull(theDGdiDriver);

	TSgImageInfo info;

	info.iUsage = ESgUsageDirectGdiTarget | ESgUsageCompositionSource;

	info.iSizeInPixels = TSize(TestWin->Size().iWidth, TestWin->Size().iHeight);

	info.iPixelFormat = EUidPixelFormatXRGB_8888;//among display modes with alpha channel only pre-multiply alpha is supported in directGDI currently

	RSgImageCollection imageCollection;

	CleanupClosePushL(imageCollection);

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

	User::LeaveIfError(res);

	RSgImage image;

	CleanupClosePushL(image);

	res = imageCollection.OpenImage(0, image);

	User::LeaveIfError(res);

	RDirectGdiImageTarget imageTarget(*theDGdiDriver);

	CleanupClosePushL(imageTarget);

	res = imageTarget.Create(image);

	User::LeaveIfError(res);

#endif

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

	//create a bitmap

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

	User::LeaveIfError(bitmap->Create(TSize(TestWin->Size().iWidth, TestWin->Size().iHeight), EColor16MA));

	CleanupStack::PushL(bitmap);

	CFbsBitmapDevice  *fbsDevice = CFbsBitmapDevice::NewL(bitmap);

	CleanupStack::PushL(fbsDevice);

#endif

	//prepare the command buffer for playback

	RWsGraphicMsgBuf msgBuf;

	CleanupClosePushL(msgBuf);

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

	remoteGc->ExternalizeL(msgBuf, ETrue);

	CWSGraphicsRes* wsGrap = new (ELeave) CWSGraphicsRes();

	CleanupStack::PushL(wsGrap);

	CCommandBuffer* cmdBuf = CCommandBuffer::NewL();

	CleanupStack::PushL(cmdBuf);

	cmdBuf->InternalizeL(msgBuf.Pckg());

	TRgb color;

	TRgb testColor(KRgbWhite);

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

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

	CleanupStack::PushL(directGdiGcWrapper);

	cmdBuf->Play(TPoint(),&KClippingRegion,KSourceRect,*wsGrap,*directGdiGcWrapper);

	//check that the background has been cleared to transparent white.

	image.GetInfo(info);

	info.iUsage = ESgUsageNone;

	info.iCpuAccess = ESgCpuAccessReadOnly;

	RSgImage image1;

	CleanupClosePushL(image1);

	res = image1.Create(info, image);

	const TAny* data;

	TInt stride = 0;

	res = image1.MapReadOnly(data, stride);

	User::LeaveIfError(res);

	TPoint pixel(10,10);

	TInt offset = pixel.iY * stride + pixel.iX * 4;

	TAny* non_const_data = const_cast <TAny*> (data);

	TUint8* pointData = static_cast <TUint8*> (non_const_data) + offset;

	color = *(reinterpret_cast <TRgb*> (pointData));

	image1.Unmap();

#endif

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

	CFbsBitGc* fbsBitGc=NULL;

	User::LeaveIfError(fbsDevice->CreateContext(fbsBitGc));

	CleanupStack::PushL(fbsBitGc);

	fbsBitGc->Activate(fbsDevice);

	cmdBuf->Play(TPoint(0, 0), KSourceRect, *wsGrap, *fbsBitGc);

	bitmap->GetPixel(color, TPoint(10,10));

	testColor.SetAlpha(0);

#endif

	iStep->TEST(color==testColor);

	//now test drawing to a window to ensure that the brush colour is

	//the window background colour

	//display a blue window

	BaseWin->Win()->SetBackgroundColor(KRgbBlue);

	BaseWin->Win()->Invalidate();

	BaseWin->Win()->BeginRedraw();

	TheGc->Activate(*BaseWin->Win());

	TheGc->Clear();

	TheGc->Deactivate();

	BaseWin->Win()->EndRedraw();

	TheClient->iWs.Finish();

	TheClient->WaitForRedrawsToFinish();

	//start drawing the display commands with a green background

	BaseWin->Win()->SetBackgroundColor(KRgbYellow);

	BaseWin->Win()->Invalidate();

	BaseWin->Win()->BeginRedraw();

	TheGc->Activate(*BaseWin->Win());

	//Play the commands on test window using command buffer

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

	cmdBuf->Play(TPoint(0, 0), &KClippingRegion, KSourceRect, TheClient->iWs, *TheGc);

#else

	cmdBuf->Play(TPoint(0, 0), KSourceRect, *wsGrap, *TheGc);

#endif

	TheGc->Deactivate();

	BaseWin->Win()->EndRedraw();

	TheClient->iWs.Finish();

	TheClient->WaitForRedrawsToFinish();

	//check that the background has been cleared to yellow, using brush colour

	TPoint position = BaseWin->Win()->InquireOffset(*TheClient->iGroup->WinTreeNode());

	position.iX+=10;

	position.iY+=10;

	TheClient->iScreen->GetPixel(color, position);

	iStep->TEST(color==KRgbYellow);

	BaseWin->Win()->SetBackgroundColor(KRgbGreen); //set back to original backgroundcolor

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

	CleanupStack::PopAndDestroy(9, remoteGc);

#else

	CleanupStack::PopAndDestroy(7, remoteGc);

#endif

	}

/**

@SYMTestCaseID		GRAPHICS-WSERV-0481

@SYMPREQ            1841

@SYMTestCaseDesc    Create font and graphics with various effect effects. Record the commands 

(like setting colours,drawing text etc) using CRemoteGc and play the recorded commands on a window. Use the same

commands in CWindowGc and draw text on a different window

@SYMTestPriority    Medium

@SYMTestStatus      Implemented

@SYMTestActions

@SYMTestExpectedResults Text/graphics drawn using CWindowGc and CRemoteGc should be same

*/

void CTGc::TestCommandBufferL()

	{	

	CWsScreenDevice* device = TheClient->iScreen;

	_LIT(KBuffText,"Command Buffer");

	TFontSpec fSpec(KTestFontTypefaceName,23);

	fSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

	fSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue);

	fSpec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue);

	CFont *font;

	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInPixels((CFont *&)font, fSpec));

	CleanupStack::PushL(TCleanupItem(CleanUpFont, font));

	CRemoteGc* remoteGc = CRemoteGc::NewL(device);

	CleanupStack::PushL(remoteGc);	

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

	//-------create image---------

	CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static();

	User::LeaveIfNull(theDGdiDriver);

	const TSize KImageSize = TSize(2, 2);

	TSgImageInfo info;

	info.iUsage = ESgUsageWindowGcSource;

	info.iSizeInPixels = KImageSize;

	info.iPixelFormat = EUidPixelFormatRGB_565;

	info.iShareable = ETrue;

	const TInt stride = KImageSize.iWidth * 2;

	TUint8* buf = (TUint8*) (User::AllocL(KImageSize.iHeight * stride));

	CleanupStack::PushL(buf);

	TUint16* bufCur = ((TUint16*)buf);

	*bufCur = KRgbRed.Color64K();

	*(bufCur + 1) = KRgbRed.Color64K();

	*(bufCur + 2) = KRgbRed.Color64K();

	*(bufCur + 3) = KRgbRed.Color64K();

	RSgImage image;

	TInt res = image.Create(info, buf, stride);

	User::LeaveIfError(res);

	CleanupClosePushL(image);	

	RWsDrawableSource drawableSource(TheClient->iWs);

	res = drawableSource.Create(image, TheClient->iScreen->GetScreenNumber());

	if(res == KErrNotSupported)

		{

		INFO_PRINTF1(_L("The current screen is not supports drawable source. This test case terminates now."));

		CleanupStack::PopAndDestroy(3, remoteGc);

		CleanupStack::Pop();//font