// 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
		TheClient->iScreen->ReleaseFont(font);
		return;
		}
	User::LeaveIfError(res);
	CleanupClosePushL(drawableSource);	
	//-------end create image---------
#endif	
	remoteGc->ResetCommandBuffer();
	remoteGc->BeginDraw(TRect(0, 0, TestWin->Size().iWidth, TestWin->Size().iHeight));
	//Capturing the commands in remote gc
	remoteGc->Clear();
	remoteGc->DrawRect(TRect(10,10,30,30));
	remoteGc->Clear(TRect(10,10,11,11));
	remoteGc->CopyRect(TPoint(5,5), TRect(25,25,30,30));
	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
	CFbsBitmap* bitmapMask = new (ELeave) CFbsBitmap;
	User::LeaveIfError(bitmap->Load(_L("Z:\\WSTEST\\WSAUTOTEST.MBM"), EMbmWsautotestCircles24b));
	User::LeaveIfError(bitmapMask->Load(_L("Z:\\WSTEST\\WSAUTOTEST.MBM"), EMbmWsautotestCircles_mask2b));
	remoteGc->BitBlt(TPoint(100,100), bitmap);
	remoteGc->BitBlt(TPoint(0,0), bitmap, TRect(0,0,1,1));	
	remoteGc->BitBltMasked(TPoint(0,5), bitmap, TRect(0,0,1,1), bitmapMask, EFalse);
	CWsBitmap* bitmapWs = new (ELeave) CWsBitmap(TheClient->iWs);
	CWsBitmap* bitmapWsMask = new (ELeave) CWsBitmap(TheClient->iWs);
	User::LeaveIfError(bitmapWs->Load(_L("Z:\\WSTEST\\TEST.MBM"), 0));
	remoteGc->BitBlt(TPoint(110,110), bitmapWs);
	remoteGc->BitBlt(TPoint(5,0), bitmapWs, TRect(0,0,1,1));
	remoteGc->BitBltMasked(TPoint(10,0), bitmap, TRect(0,0,1,1), bitmapWsMask, EFalse);
	remoteGc->SetFadingParameters(128,128);
	remoteGc->SetFaded(EFalse);	
	remoteGc->AlphaBlendBitmaps(TPoint(2,2), bitmap, TRect(0,0,1,1), bitmapMask, TPoint(2,2));
	remoteGc->AlphaBlendBitmaps(TPoint(3,3), bitmapWs, TRect(0,0,1,1), bitmapWsMask, TPoint(2,2));
	remoteGc->SetOrigin(TPoint(0,30));
	remoteGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
	remoteGc->SetClippingRect(TRect(0,0,10,10));
	remoteGc->SetPenStyle(CGraphicsContext::ESolidPen);
	remoteGc->SetPenSize(TSize(1,2));
	remoteGc->UseBrushPattern(bitmap);
	remoteGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	remoteGc->SetBrushOrigin(TPoint(0,0));
	remoteGc->DrawPie(TRect(0,0,15,15),TPoint(0,8),TPoint(15,8));
	remoteGc->CancelClippingRect();
	remoteGc->DiscardBrushPattern();
	remoteGc->CancelClippingRegion();
	remoteGc->Reset();
	remoteGc->SetOrigin(TPoint(0,0));
	remoteGc->SetUnderlineStyle(EUnderlineOff);
	remoteGc->SetStrikethroughStyle(EStrikethroughOff);
	remoteGc->SetWordJustification(1,2);
	remoteGc->SetCharJustification(1,2);
	remoteGc->UseFont(font);
	remoteGc->DrawText(KBuffText,TRect(50,0,100,50),10,CGraphicsContext::ELeft,0);
	remoteGc->DrawTextVertical(KBuffText,TPoint(170,20),EFalse);
	remoteGc->DrawTextVertical(KBuffText,TRect(120,20,150,100),5,EFalse,CGraphicsContext::ELeft,0);	
	remoteGc->MoveTo(TPoint(25,150));
	remoteGc->MoveBy(TPoint(5,5));
	remoteGc->DrawLineTo(TPoint(35,160));
	remoteGc->DrawLine(TPoint(35,160),TPoint(25,150));
	remoteGc->DrawLineBy(TPoint(15,6));	
	remoteGc->Plot(TPoint(5,5));	
	remoteGc->DrawArc(TRect(0,80,10,90),TPoint(0,85),TPoint(10,85));
	remoteGc->DrawEllipse(TRect(0,90,10,100));	
	remoteGc->DrawRoundRect(TRect(30,80,50,100),TSize(5,5));	
	remoteGc->DrawBitmap(TPoint(150,150),bitmap);	
	remoteGc->DrawBitmap(TRect(160,160,170,170), bitmap);	
	remoteGc->DrawBitmap(TRect(175,175,180,180), bitmap, TRect(0,5,5,10));	
	remoteGc->DrawBitmapMasked(TRect(185,185,190,190), bitmap, TRect(0,50,5,55),bitmapMask,EFalse);
	remoteGc->DrawBitmapMasked(TRect(195,195,200,200), bitmapWs, TRect(0,50,5,55),bitmapWsMask,EFalse);		
	CArrayFixFlat<TPoint>* polyPoints = new(ELeave) CArrayFixFlat<TPoint>(3); //CArrayFixFlat
	CleanupStack::PushL(polyPoints);
	TRect rect (200,0,200,100);
	polyPoints->AppendL(rect.iTl);
	polyPoints->AppendL(rect.Center());
	polyPoints->AppendL(TPoint(rect.iBr.iX, rect.iTl.iY));	
	remoteGc->DrawPolyLine(polyPoints);
	remoteGc->DrawPolyLine(&polyPoints->At(0), 3);
	remoteGc->DrawPolygon(polyPoints, CGraphicsContext::EWinding);
	remoteGc->DrawPolygon(&polyPoints->At(0), 3, CGraphicsContext::EAlternate);
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA
	MWsDrawResource* dr = static_cast<MWsDrawResource*>(remoteGc->Interface(KMWsDrawResourceInterfaceUid));
	if(dr)
		dr->DrawResource(TPoint(30, 40), drawableSource);
#endif
	RRegion region;
	remoteGc->SetClippingRegion(region);
	remoteGc->DiscardFont();
	remoteGc->EndDraw();

	RWsGraphicMsgBuf msgBuf;
	CleanupClosePushL(msgBuf);
	//Externalize the captured commands from remote gc in to a buffer
	remoteGc->ExternalizeL(msgBuf, EFalse);
	
	CCommandBuffer* cmdBuf = CCommandBuffer::NewL();
	CleanupStack::PushL(cmdBuf);
	const CCommandBuffer* testCmdBuf = CCommandBuffer::NewL();
	if(cmdBuf->IsIdentical(*testCmdBuf)==EFalse)
		{
		User::Panic(_L("TestCommandBufferL"), KErrGeneral);
		}
	delete testCmdBuf;
	//Internalize the buffer with captured commands (from CRemoteGC) 
	//in to CCommandBuffer
	cmdBuf->InternalizeL(msgBuf.Pckg());
	
	TheGc->Activate(*TestWin->Win());
	TestWin->Win()->Invalidate();
	
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
	/*
	 * Make sure anything that can leave is done outside the
	 * BeginRedraw/EndRedraw bracket.
	 */
	CWSGraphicsRes* wsGrap=new(ELeave) CWSGraphicsRes();
	CleanupStack::PushL(wsGrap);
#endif
	/*
	 * Note we need to still do BeginRedraw/EndRedraw for the TestWin Window
	 * even though the CRemoteGc we are going to Play into TestWin already has
	 * BeginRedraw/EndRedraw commands issued into it.  Those commands just allow
	 * for replacement of draw ops already in the CRemoteGc to be replaced by
	 * new draw ops covering the same area.  The BeginRedraw/EndRedraws never 
	 * get Play()'ed into TestWin.
	 */
	TestWin->Win()->BeginRedraw();
	TheGc->Clear();
	//Play the commands on test window using command buffer
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA
	cmdBuf->Play(TPoint(), NULL, TRect(TestWin->Size()), TheClient->iWs, *TheGc);
#endif
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
	cmdBuf->Play(TPoint(),TRect(TestWin->Size()),*wsGrap,*TheGc);
	CleanupStack::PopAndDestroy(wsGrap);
#endif
	TheGc->Deactivate();
	TestWin->Win()->EndRedraw();
	remoteGc->ResetCommandBuffer();
	BaseWin->Win()->Invalidate();
	BaseWin->Win()->BeginRedraw();
	TheGc->Activate(*BaseWin->Win());
	TheGc->Clear();
	TheGc->DrawRect(TRect(10,10,30,30));
	TheGc->Clear(TRect(10,10,11,11));
	TheGc->CopyRect(TPoint(5,5), TRect(25,25,30,30));
	TheGc->BitBlt(TPoint(100,100), bitmap);
	TheGc->BitBlt(TPoint(0,0), bitmap, TRect(0,0,1,1));	
	TheGc->BitBltMasked(TPoint(0,5), bitmap, TRect(0,0,1,1), bitmapMask, EFalse);
	TheGc->BitBlt(TPoint(110,110), bitmapWs);
	TheGc->BitBlt(TPoint(5,0), bitmapWs, TRect(0,0,1,1));
	TheGc->BitBltMasked(TPoint(10,0), bitmap, TRect(0,0,1,1), bitmapWsMask, EFalse);
	TheGc->SetFadingParameters(128,128);
	TheGc->SetFaded(EFalse);	
	TheGc->AlphaBlendBitmaps(TPoint(2,2), bitmap, TRect(0,0,1,1), bitmapMask, TPoint(2,2));
	TheGc->AlphaBlendBitmaps(TPoint(3,3), bitmapWs, TRect(0,0,1,1), bitmapWsMask, TPoint(2,2));
	TheGc->SetOrigin(TPoint(0,30));
	TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
	TheGc->SetClippingRect(TRect(0,0,10,10));
	TheGc->SetPenStyle(CGraphicsContext::ESolidPen);
	TheGc->SetPenSize(TSize(1,2));
	TheGc->UseBrushPattern(bitmap);
	TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	TheGc->SetBrushOrigin(TPoint(0,0));
	TheGc->DrawPie(TRect(0,0,15,15),TPoint(0,8),TPoint(15,8));
	TheGc->CancelClippingRect();
	TheGc->DiscardBrushPattern();
	TheGc->CancelClippingRegion();
	TheGc->Reset();
	TheGc->SetOrigin(TPoint(0,0));
	TheGc->SetUnderlineStyle(EUnderlineOff);
	TheGc->SetStrikethroughStyle(EStrikethroughOff);
	TheGc->SetWordJustification(1,2);
	TheGc->SetCharJustification(1,2);
	TheGc->UseFont(font);
	TheGc->DrawText(KBuffText,TRect(50,0,100,50),10,CGraphicsContext::ELeft,0);
	TheGc->DrawTextVertical(KBuffText,TPoint(170,20),EFalse);
	TheGc->DrawTextVertical(KBuffText,TRect(120,20,150,100),5,EFalse,CGraphicsContext::ELeft,0);	
	TheGc->MoveTo(TPoint(25,150));
	TheGc->MoveBy(TPoint(5,5));
	TheGc->DrawLineTo(TPoint(35,160));
	TheGc->DrawLine(TPoint(35,160),TPoint(25,150));
	TheGc->DrawLineBy(TPoint(15,6));	
	TheGc->Plot(TPoint(5,5));	
	TheGc->DrawArc(TRect(0,80,10,90),TPoint(0,85),TPoint(10,85));
	TheGc->DrawEllipse(TRect(0,90,10,100));	
	TheGc->DrawRoundRect(TRect(30,80,50,100),TSize(5,5));	
	TheGc->DrawBitmap(TPoint(150,150),bitmap);	
	TheGc->DrawBitmap(TRect(160,160,170,170), bitmap);	
	TheGc->DrawBitmap(TRect(175,175,180,180), bitmap, TRect(0,5,5,10));	
	TheGc->DrawBitmapMasked(TRect(185,185,190,190), bitmap, TRect(0,50,5,55),bitmapMask,EFalse);
	TheGc->DrawBitmapMasked(TRect(195,195,200,200), bitmapWs, TRect(0,50,5,55),bitmapWsMask,EFalse);
	TheGc->DrawPolyLine(polyPoints);
	TheGc->DrawPolyLine(&polyPoints->At(0), 3);
	TheGc->DrawPolygon(polyPoints, CGraphicsContext::EWinding);
	TheGc->DrawPolygon(&polyPoints->At(0), 3, CGraphicsContext::EAlternate);
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA
	TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	TheGc->SetBrushColor(KRgbRed);
	TheGc->SetPenColor(KRgbRed);
	TheGc->DrawRect(TRect(30, 40, 32, 42));
#endif
	TheGc->DiscardFont();
	TheGc->Deactivate();
	BaseWin->Win()->EndRedraw();
	TheClient->Flush();
	TheClient->WaitForRedrawsToFinish();

	//Check the text drawn on base and test windows.
	TBool err = CheckRect(BaseWin, TestWin, TRect(0, 0, BaseWin->Size().iWidth, BaseWin->Size().iHeight), _L("CTGc::TestCommandBufferL()"));
	if (err)
	    {
	    INFO_PRINTF1(_L("The CheckRect function returned error."));
	    }
	delete bitmap;
	INFO_PRINTF1(_L("bitmap deleted."));
	delete bitmapMask;
	INFO_PRINTF1(_L("bitmapMask deleted."));
	delete bitmapWs;
	INFO_PRINTF1(_L("bitmapWs deleted."));
	delete bitmapWsMask;
	INFO_PRINTF1(_L("bitmapWsMask deleted."));
	
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA
	CleanupStack::PopAndDestroy(7, remoteGc);
#else
	CleanupStack::PopAndDestroy(4, remoteGc);
#endif	
	CleanupStack::Pop();//font
	INFO_PRINTF1(_L("CleanupStack popped."));
	TheClient->iScreen->ReleaseFont(font);
	}

/**
@SYMTestCaseID		GRAPHICS-WSERV-0482
@SYMPREQ            1841
@SYMTestCaseDesc    Play empty command buffer.
@SYMTestPriority    Medium
@SYMTestStatus      Implemented
@SYMTestActions
@SYMTestExpectedResults return KErrEof error
*/
void CTGc::TestEmptyCommandBufferL()
	{
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
	CWSGraphicsRes* wsGrap = new (ELeave) CWSGraphicsRes();
	CleanupStack::PushL(wsGrap);
#endif

	CCommandBuffer* cmdBuf = CCommandBuffer::NewL();
	CleanupStack::PushL(cmdBuf);

	TheGc->Activate(*TestWin->Win());
	TheGc->Clear();
	//Play the commands on test window using command buffer
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
	TInt err = cmdBuf->Play(TPoint(),TRect(TestWin->Size()),*wsGrap,*TheGc);
#else
	TInt err = cmdBuf->Play(TPoint(),NULL,TRect(TestWin->Size()),TheClient->iWs,*TheGc);
#endif
	if(err!=KErrEof)
		{
		User::Panic(_L("TestEmptyCommandBufferL"), KErrGeneral);
		}
	TheGc->Deactivate();
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
	CleanupStack::PopAndDestroy(2, wsGrap); //cmdBuf, wsGrap, msgBuf and remoteGc
#else
	CleanupStack::PopAndDestroy(cmdBuf);
#endif
	}

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA
/**
@SYMTestCaseID		GRAPHICS-WSERV-0486
@SYMPREQ            PREQ2095
@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, also use ClippingRect 
and ClippingRegion. Record the commands using CRemoteGc and play the recorded commands on a 
bitmap using MWsGraphicsContext. Use the same commands in CWindowGc and draw text on a 
different window
@SYMTestExpectedResults Text drawn using CWindowGc and CRemoteGc(MWsGraphicsContext) should be same
*/
void CTGc::TestCRemoteGcAndMWsGraphicsContextClippingRectL()
	{
	const TRect KTestRect(0, 0, TestWin->Size().iWidth, TestWin->Size().iHeight);
	const TRegionFix<1> KTestRegion(KTestRect);
	const TRect KClippingRect1(5, 5, TestWin->Size().iWidth-10, 90);
	const TRegionFix<1> KClippingRegion(KClippingRect1);
	const TRect KClippingRect2(15, 15, TestWin->Size().iWidth-10, TestWin->Size().iHeight-10);
	
	CWsScreenDevice* device = TheClient->iScreen;
	/*
	 * On hardware, the first screen runs in 64K colors, but the second screen (TV OUT)
	 * cannot run in this mode, it instead falls back to 16M colors.  We need to ensure
	 * that we use matching color depths for our off-screen bitmaps so that accuracy is
	 * not lost since we compare bitmaps from the screen versus off-screen.
	 */
    
	TDisplayMode displayMode = device->DisplayMode();
    if (TDisplayModeUtils::NumDisplayModeBitsPerPixel(displayMode) == 32)
        {
        displayMode = EColor16MAP;
        }

	_LIT(KText,"RemoteGc & MWsGraphicsContext");
	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));

	//Record the commands using CRemoteGc
	CRemoteGc* remoteGc = CRemoteGc::NewL(device);
	CleanupStack::PushL(remoteGc);
	remoteGc->BeginDraw(KTestRect);
	//fill background with white
	remoteGc->SetPenStyle(CFbsBitGc::ENullPen);
	remoteGc->SetBrushStyle(CFbsBitGc::ESolidBrush);
	remoteGc->SetBrushColor(KRgbWhite);
	remoteGc->DrawRect(TRect(TPoint(0,0), TestWin->Size()));
	remoteGc->SetPenStyle(CFbsBitGc::ESolidPen);
	//Capturing the commands in remote gc
	remoteGc->SetClippingRect(KClippingRect2);
	remoteGc->SetClippingRegion(KClippingRegion);
	remoteGc->SetBrushStyle(CFbsBitGc::ESolidBrush);
	remoteGc->SetBrushColor(TRgb(0,150,150));
	remoteGc->DrawRect(TRect(TPoint(0,0), TSize(160,60)));
	remoteGc->SetBrushColor(TRgb(150,100,150));
	remoteGc->DrawRect(TRect(TPoint(0,60), TSize(160,60)));
	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);
	
	CCommandBuffer* cmdBuf = CCommandBuffer::NewL();
	CleanupStack::PushL(cmdBuf);
	//Internalize the buffer with captured commands (from CRemoteGC) 
	//in to CCommandBuffer
	cmdBuf->InternalizeL(msgBuf.Pckg());
	
	CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static();
	User::LeaveIfNull(theDGdiDriver);
	
	TSgImageInfo info;
	info.iUsage = ESgUsageDirectGdiTarget | ESgUsageDirectGdiSource | ESgUsageCompositionSource;
	info.iSizeInPixels = TestWin->Size();
	info.iPixelFormat = PixelFormatFromDisplayMode(displayMode);
	
	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);
	
	CDirectGdiGcWrapper* directGdiGcWrapper = CDirectGdiGcWrapper::NewL(imageTarget);
	CleanupStack::PushL(directGdiGcWrapper);
	
	//Dummy class created
	CWSGraphicsRes* wsGrap = new (ELeave) CWSGraphicsRes();
	CleanupStack::PushL(wsGrap);

	//Play the commands on test window using command buffer
	cmdBuf->Play(TPoint(),&KTestRegion,KTestRect,*wsGrap,*directGdiGcWrapper);

	//Set window back to same as test bitmap background
	BaseWin->Win()->SetBackgroundColor(KRgbWhite);

	BaseWin->Win()->Invalidate();
	BaseWin->Win()->BeginRedraw();
	TheGc->Activate(*BaseWin->Win());
	TheGc->Clear();
	TheGc->SetClippingRect(KClippingRect2);
	TheGc->SetClippingRegion(KClippingRegion);
	TheGc->SetBrushStyle(CFbsBitGc::ESolidBrush);
	TheGc->SetBrushColor(TRgb(0,150,150));
	TheGc->DrawRect(TRect(TPoint(0,0), TSize(160,60)));
	TheGc->SetBrushColor(TRgb(150,100,150));
	TheGc->DrawRect(TRect(TPoint(0,60), TSize(160,60)));
	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();

	//Create a bitmap and then copy the screen to it
	TRect rc(TRect(BaseWin->Win()->AbsPosition(), BaseWin->Win()->Size()));
	CFbsBitmap *screenBitmap = new (ELeave) CFbsBitmap();
	User::LeaveIfError(screenBitmap->Create(rc.Size(), displayMode));
	CleanupStack::PushL(screenBitmap);
	TheClient->iScreen->CopyScreenToBitmap(screenBitmap, rc);

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
	CleanupStack::PushL(bitmap);

	image.GetInfo(info);
	bitmap->Create(info.iSizeInPixels, displayMode);
	TRect rect(info.iSizeInPixels);
	CopyImageToBitmapL(bitmap, image, rect);

	//Test to see if the bitmap drawn to using CRemoteGc is the same as the screen copy bitmap
	TInt differentPixels = 0;
	res = LossyCompareBitmapRecord(*bitmap, *screenBitmap, KTestRect, EFalse, differentPixels, Logger());
	if (differentPixels != 0)
		{
		INFO_PRINTF2(_L(" Pixels different %d"), differentPixels);
		}
	TEST(res);
	CleanupStack::PopAndDestroy(10, remoteGc); //screenBitmap, imageCollection, image, imageTarget, directGdiGcWrapper, cmdBuf, wsGrap, msgBuf, remoteGc, bitmap
	CleanupStack::Pop();//font
	TheClient->iScreen->ReleaseFont(font);
	}

/**
@SYMTestCaseID		GRAPHICS-WSERV-0487
@SYMPREQ            PREQ2095
@SYMTestCaseDesc    Draw text using CRemoteGc and DrawText(const TDesC&,const TTextParameters*,const TPoint&)
@SYMTestPriority    High
@SYMTestStatus      Implemented
@SYMTestActions     Create a font.  Draw text to a bitmap with the font using CFbsBitGc::DrawText. Draw text with the font using CFbsBitGc::DrawText.
Record the same DrawText commands using CRemoteGc and play the recorded commands on a 
bitmap using MWsGraphicsContext. Compare the two bitmaps.
@SYMTestExpectedResults Text drawn using CFbsBitGc and CRemoteGc(MWsGraphicsContext) should be the same
*/
void CTGc::TestCRemoteGcDrawTextInContextPointL()
	{
	CDrawTextInContextTestPoint* test = CDrawTextInContextTestPoint::NewL();
	CleanupStack::PushL(test);
	test->Test();
	TEST(test->HasPassedTest());
	CleanupStack::PopAndDestroy(); //test
	}

/**
@SYMTestCaseID		GRAPHICS-WSERV-0488
@SYMPREQ            PREQ2095
@SYMTestCaseDesc    Draw text using CRemoteGc and DrawText(const TDesC&,const TTextParameters*,const TRect&,TInt,TTextAlign,TInt)
@SYMTestPriority    High
@SYMTestStatus      Implemented
@SYMTestActions     Create a font.  Draw text to a bitmap with the font using CFbsBitGc::DrawText. Draw text with the font using CFbsBitGc::DrawText.
Record the same DrawText commands using CRemoteGc and play the recorded commands on a 
bitmap using MWsGraphicsContext. Compare the two bitmaps.
@SYMTestExpectedResults Text drawn using CFbsBitGc and CRemoteGc(MWsGraphicsContext) should be the same
*/
void CTGc::TestCRemoteGcDrawTextInContextBoxL()
	{
	CDrawTextInContextTestBox* test = CDrawTextInContextTestBox::NewL();
	CleanupStack::PushL(test);
	test->Test();
	TEST(test->HasPassedTest());
	CleanupStack::PopAndDestroy(); //test
	}

/**
@SYMTestCaseID		GRAPHICS-WSERV-0489
@SYMPREQ            PREQ2095
@SYMTestCaseDesc    Draw text using CRemoteGc and DrawTextVertical(const TDesC&,const TTextParameters*,const TPoint&)
@SYMTestPriority    High
@SYMTestStatus      Implemented
@SYMTestActions     Create a font.  Draw text to a bitmap with the font using CFbsBitGc::DrawTextVertical. Draw text with the font using CFbsBitGc::DrawText.
Record the same DrawText commands using CRemoteGc and play the recorded commands on a 
bitmap using MWsGraphicsContext. Compare the two bitmaps.
@SYMTestExpectedResults Text drawn using CFbsBitGc and CRemoteGc(MWsGraphicsContext) should be the same
*/
void CTGc::TestCRemoteGcDrawTextInContextPointVerticalL()
	{
	CDrawTextInContextTestPointVertical* test = CDrawTextInContextTestPointVertical::NewL();
	CleanupStack::PushL(test);
	test->Test();
	TEST(test->HasPassedTest());
	CleanupStack::PopAndDestroy(); //test
	}

/**
@SYMTestCaseID		GRAPHICS-WSERV-0490
@SYMPREQ            PREQ2095
@SYMTestCaseDesc    Draw text using CRemoteGc and DrawTextVertical(const TDesC&,const TTextParameters*,const TRect&,TInt,TTextAlign,TInt)
@SYMTestPriority    High
@SYMTestStatus      Implemented
@SYMTestActions     Create a font.  Draw text to a bitmap with the font using CFbsBitGc::DrawTextVertical. Draw text with the font using CFbsBitGc::DrawText.
Record the same DrawText commands using CRemoteGc and play the recorded commands on a 
bitmap using MWsGraphicsContext. Compare the two bitmaps.
@SYMTestExpectedResults Text drawn using CFbsBitGc and CRemoteGc(MWsGraphicsContext) should be the same
*/
void CTGc::TestCRemoteGcDrawTextInContextBoxVerticalL()
	{
	CDrawTextInContextTestBoxVertical* test = CDrawTextInContextTestBoxVertical::NewL();
	CleanupStack::PushL(test);
	test->Test();
	TEST(test->HasPassedTest());
	CleanupStack::PopAndDestroy(); //test
	}
#endif //TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

/**
@SYMTestCaseID		GRAPHICS-WSERV-0494
@SYMDEF				DEF131255
@SYMTestCaseDesc    Negative test to show that using SetBrushStyle() will not panic WServ with different
					brush bitmaps.
@SYMTestPriority    High
@SYMTestStatus      Implemented
@SYMTestActions		Four seperate panic situations are tested:
					1)
                    Create a regular CFbsBitmap, set as brush pattern, and set brush style to EPatternedBrush.
                    Draw a line to force the playback to occur.
                    Call Finish on the GC.
                    Destroy the brush bitmap.
                    2)
                    Create a regular CFbsBitmap, set as brush pattern, and set brush style to EPatternedBrush.
                    Draw a line to force the playback to occur.
                    Destroy the brush bitmap. 
                    Call Finish on the GC.
                    3+4)
                    Create an extended bitmap, set as the brush pattern, and set the brush style to EPatternedBrush.
                    Draw a line to force the playback to occur.
                    Set the brush bitmap and style again.
                    Call Finish on the GC.
                    Destroy the brush bitmap. 
@SYMTestExpectedResults The calls to SetBrushStyle() should not cause WServ to panic when Finish() is called.
*/
void CTGc::TestGcSetBrushPatternL()
	{
	// Extended bitmap test data.
	const TUint8 KTestData[] = "TEST DATA";
	const TInt KTestDataSize = sizeof(KTestData);
	const TUid KTestExtendedBitmapUid = TUid::Uid(0xFFFFFFFF);
	
	// First try using a regular bitmap as the brush pattern.
	BaseWin->Win()->Invalidate();
	BaseWin->Win()->BeginRedraw();
	TheGc->Activate(*BaseWin->Win());	
	CFbsBitmap* bitmapRegular = new (ELeave) CFbsBitmap;
	CleanupStack::PushL(bitmapRegular);
	TInt res = bitmapRegular->Create(TSize(10,10), EColor64K);
	TEST(res == KErrNone);
	//Record the commands using CWindowGc.
	TheGc->UseBrushPattern(bitmapRegular);
	TheGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);
	// DrawLine() is only used here to force playback of the commands.
	TheGc->DrawLine(TPoint(0,0), TPoint(1,1));	
	TheGc->Deactivate();
	BaseWin->Win()->EndRedraw();
	TheClient->iWs.Finish();
	CleanupStack::PopAndDestroy(1, bitmapRegular);
	
	// Secondly, try using a regular bitmap as the brush pattern, but deleting the bitmap
	// before calling Finish().
	BaseWin->Win()->Invalidate();
	BaseWin->Win()->BeginRedraw();
	TheGc->Activate(*BaseWin->Win());		
	bitmapRegular = new (ELeave) CFbsBitmap;
	CleanupStack::PushL(bitmapRegular);
	res = bitmapRegular->Create(TSize(10,10), EColor64K);		
	TEST(res == KErrNone);
	//Record the commands using CWindowGc.
	TheGc->UseBrushPattern(bitmapRegular);
	TheGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);
	TheGc->DrawLine(TPoint(0,0), TPoint(1,1));
	CleanupStack::PopAndDestroy(1, bitmapRegular);	
	TheGc->Deactivate();
	BaseWin->Win()->EndRedraw();
	TheClient->iWs.Finish();
	
	// Thirdly, try using an extended bitmap (which is unsupported by DirectGDI) as 
	// the brush pattern.
	BaseWin->Win()->Invalidate();
	BaseWin->Win()->BeginRedraw();
	TheGc->Activate(*BaseWin->Win());
	// Create a dummy extended bitmap to use as a brush bitmap.
	// This is unsupported by the default implementation of DirectGDI.
	CFbsBitmap* bitmapExtended = new (ELeave) CFbsBitmap;
	CleanupStack::PushL(bitmapExtended);
	res = bitmapExtended->CreateExtendedBitmap(TSize(10,10), EColor64K, KTestExtendedBitmapUid, KTestData, KTestDataSize);
	TEST(res == KErrNone);	
	//Record the commands using CWindowGc.
	TheGc->UseBrushPattern(bitmapExtended);
	TheGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);
	TheGc->DrawLine(TPoint(0,0), TPoint(100,100));
	TheGc->UseBrushPattern(bitmapExtended);
	// Forth, do it twice so that we test the state commands and the drawops commands.
	TheGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);
	TheGc->DrawLine(TPoint(0,0), TPoint(100,100));
	TheGc->Deactivate();
	BaseWin->Win()->EndRedraw();
	TheClient->iWs.Finish();
	CleanupStack::PopAndDestroy(1, bitmapExtended);	
	}

/**
@SYMTestCaseID      GRAPHICS-WSERV-0576
@SYMDEF             
@SYMTestCaseDesc    Checks window server is still able to draw a bitmap, even after the client has released its handle to the bitmap.
@SYMTestPriority    High
@SYMTestStatus      Implemented
@SYMTestActions     - Draw the bitmap to TestWin (keeping the window hidden)
                    - Delete the bitmap
                    - Show TestWin to cause it to be drawn on screen (after the bitmap has been deleted)
                    - Draw the same bitmap (same image, different bitmap object instance) to BaseWin
                    - Compare contents of TestWin with BaseWin
@SYMTestExpectedResults TestWin and BaseWin should both show the bitmap.
*/
void CTGc::TestGcDeleteBitmap1L()
    {
    CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
    CleanupStack::PushL(bitmap);
    TInt ret = bitmap->Load(TEST_BITMAP_NAME,0);
    TEST(ret == KErrNone);

    // send drawing to hidden window
    TestWin->SetVisible(EFalse);
    TestWin->Win()->Invalidate();
    TestWin->Win()->BeginRedraw();
    TheGc->Activate(*TestWin->Win());
    TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
    TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
    TheGc->SetBrushColor(TRgb(255, 0, 0));
    TheGc->Clear();
    TheGc->BitBlt(TPoint(0,0), bitmap);
    CleanupStack::PopAndDestroy(bitmap); // before the bitmap is actually deleted, WsFbsDestroyCallBack flushes the command buffer to ensure the bitmap is duplicated in the window server thread
    bitmap = NULL;
    TheGc->Deactivate();
    TestWin->Win()->EndRedraw();
    TheClient->iWs.Flush(); // calling Flush rather than Finish, as we don't need to wait for any drawing to happen (as the window is currently hidden)

    // make window visible (forcing it to draw)
    TestWin->SetVisible(ETrue);
    TheClient->iWs.Finish(); // ensure the bitmap has been drawn on test win

    // window server should have duplicated the bitmap when the BitBlt was added to the redraw store, so drawing
    // the window now (by making it visible above) should display the bitmap on screen, even
    // though we've deleted it in this thread

    // now create the bitmap again, and draw it to the base win (for comparison with test win)
    bitmap = new (ELeave) CFbsBitmap;
    CleanupStack::PushL(bitmap);
    ret = bitmap->Load(TEST_BITMAP_NAME,0);
    TEST(ret == KErrNone);
    BaseWin->SetVisible(ETrue);
    BaseWin->Win()->Invalidate();
    BaseWin->Win()->BeginRedraw();
    TheGc->Activate(*BaseWin->Win());   
    TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
    TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
    TheGc->SetBrushColor(TRgb(255, 0, 0));
    TheGc->Clear();
    TheGc->BitBlt(TPoint(0,0), bitmap);
    TheGc->Deactivate();
    BaseWin->Win()->EndRedraw();
    TheClient->iWs.Finish(); // ensure the bitmap has been drawn on base win
    
    CleanupStack::PopAndDestroy(bitmap);

    // the test bitmap should be shown in both base win and test win, so we now check that the
    // contents of base win and test win are the same
    CheckRect(BaseWin, TestWin, TRect(0, 0, BaseWin->Size().iWidth, BaseWin->Size().iHeight), _L("CTGc::TestGcDeleteBitmap1L()"));
    }

/**
@SYMTestCaseID      GRAPHICS-WSERV-0577
@SYMDEF             
@SYMTestCaseDesc    Check window server is still able to use a bitmap required by window drawing, even
                    after the client has released its handle to the bitmap. Also check window server 
                    releases the bitmap, when it's no longer used by window drawing.
@SYMTestPriority    High
@SYMTestStatus      Implemented
@SYMTestActions     - Clean BaseWin and TestWin from content that has been left over from previous test
                    - Draw test bitmap to TestWin
                    - Delete the bitmap
                    - Using a different bitmap object instance, duplicate bitmap (the bitmap is still used by window drawing)
                    - Delete the bitmap
                    - Draw new content to TestWin, so that previously drawn bitmap is covered
                    - Duplicate bitmap (the bitmap is no longer used by window drawing)
@SYMTestExpectedResults Bitmap duplication succeeds, when the bitmap used by window drawing, whereas
                        bitmap duplication fails, when the bitmap is no longer used by window drawing.
*/
void CTGc::TestGcDeleteBitmap2L()
    {
    //send new drawing to test and base windows, in order to cover 
    //any content has been left on them (through previous test)
    BaseWin->SetVisible(ETrue);
    BaseWin->Win()->Invalidate();
    BaseWin->Win()->BeginRedraw();
    TheGc->Activate(*BaseWin->Win());   
    TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
    TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
    TheGc->SetBrushColor(TRgb(0, 0, 255));
    TheGc->Clear();
    TheGc->Deactivate();
    BaseWin->Win()->EndRedraw();
    
    TestWin->SetVisible(ETrue);
    TestWin->Win()->Invalidate();
    TestWin->Win()->BeginRedraw();
    TheGc->Activate(*TestWin->Win());   
    TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
    TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
    TheGc->SetBrushColor(TRgb(0, 0, 255));
    TheGc->Clear();
    TheGc->Deactivate();
    TestWin->Win()->EndRedraw();
    
    TheClient->iWs.Flush(); 
    TheClient->iWs.Finish();
        
    //load test bitmap
    CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
    CleanupStack::PushL(bitmap);
    TInt ret = bitmap->Load(_L("Z:\\WSTEST\\TESTCIRCLES.MBM"),0);
    TEST(ret == KErrNone);
    TInt bitmapHandle = bitmap->Handle();
    
    //send bitmap drawing to test window
    TestWin->Win()->Invalidate();
    TestWin->Win()->BeginRedraw();
    TheGc->Activate(*TestWin->Win());
    TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
    TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
    TheGc->SetBrushColor(TRgb(0, 255, 0));
    TheGc->Clear();
    TheGc->BitBlt(TPoint(0,0), bitmap);
    TheGc->Deactivate();
    TestWin->Win()->EndRedraw();
    
    CleanupStack::PopAndDestroy(bitmap);

    TheClient->iWs.Flush(); 
    TheClient->iWs.Finish();
    
    //using a new bitmap object instance check that wserv can still duplicate test bitmap (even though
    //the initial bitmap object is deleted) , since there is a window segment using it
    bitmap = new (ELeave) CFbsBitmap;
    CleanupStack::PushL(bitmap);
    ret = bitmap->Duplicate(bitmapHandle);
    TEST(ret == KErrNone);
    CleanupStack::PopAndDestroy(bitmap);

    //send new drawing to test window, in order to cover the bitmap that was previously drawn
    TestWin->Win()->Invalidate();
    TestWin->Win()->BeginRedraw();
    TheGc->Activate(*TestWin->Win());
    TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
    TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
    TheGc->SetBrushColor(TRgb(0, 0, 255));
    TheGc->Clear();
    TheGc->Deactivate();
    TestWin->Win()->EndRedraw();
    
    TheClient->iWs.Flush(); 
    TheClient->iWs.Finish();
    
    //check that wserv can't duplicate test bitmap, since no window segment uses it any more
    bitmap = new (ELeave) CFbsBitmap;
    CleanupStack::PushL(bitmap);
    ret = bitmap->Duplicate(bitmapHandle);
    TEST(ret != KErrNone);
    CleanupStack::PopAndDestroy(bitmap);
    }

void CTGc::RunTestCaseL(TInt /*aCurTestCase*/)
	{
	((CTGcStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
	switch(++iTest->iState)
		{
	case 1:
		((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0437"));
		iTest->LogSubTest(_L("CRemoteGc&CWindowGc, outline and shadow text"));
		TestOutlineAndShadowL();		
		break;	
	case 2:
		((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0471"));
		iTest->LogSubTest(_L("Test GC clip rect and origin attributes."));		 
		TestGcClipRectOrigin();
		break;
	case 3:
		((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0469"));
		iTest->LogSubTest(_L("CRemoteGc&CWindowGc, reset with background colour"));		
		TestResetWithBackgroundColorL();
		break;
	case 4:
		((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0481"));
		iTest->LogSubTest(_L("CRemoteGc&CCommandBuffer, coverage tests"));
		TestCommandBufferL();
		break;			
	case 5:
		((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0482"));
		iTest->LogSubTest(_L("CCommandBuffer, coverage tests"));
		TestEmptyCommandBufferL();
		break;
	case 6:
		((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0494"));
		iTest->LogSubTest(_L("CWindowGc, Brush Pattern test"));
		TestGcSetBrushPatternL();
		break;
    case 7:
        ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0576"));
        iTest->LogSubTest(_L("CWindowGc, delete bitmap 1"));
        TestGcDeleteBitmap1L();
        break;
    case 8:
        ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0577"));
        iTest->LogSubTest(_L("CWindowGc, delete bitmap 2"));
        TestGcDeleteBitmap2L();
        break;
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA
	case 9:
		 ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0471"));
		 iTest->LogSubTest(_L("Test GC clip rect and origin attributes."));
		 TestGcClipRectOrigin();
		 break;
	case 10:
		((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0469"));
		iTest->LogSubTest(_L("CRemoteGc&CWindowGc, reset with background colour"));
		TestResetWithBackgroundColorL();
		break;
	case 11:
		((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0486"));
		iTest->LogSubTest(_L("CRemoteGc&MWsGraphicsContext, clipping rect test"));
		TestCRemoteGcAndMWsGraphicsContextClippingRectL();
		break;
	case 12:
		((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0487"));
		iTest->LogSubTest(_L("CRemoteGc, DrawTextInContext Position test"));
		TestCRemoteGcDrawTextInContextPointL();
		break;
	case 13:
		((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0488"));
		iTest->LogSubTest(_L("CRemoteGc, DrawTextInContext ClipRect test"));
		TestCRemoteGcDrawTextInContextBoxL();
		break;
	case 14:
		((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0489"));
		iTest->LogSubTest(_L("CRemoteGc, DrawTextInContext Pos Vertical  test"));
		TestCRemoteGcDrawTextInContextPointVerticalL();
		break;
	case 15:
		((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0490"));
		iTest->LogSubTest(_L("CRemoteGc, DrawTextInContext ClipRect Vert  test"));
		TestCRemoteGcDrawTextInContextBoxVerticalL();
		break;
#endif //TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA
	default:
		((CTGcStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
		((CTGcStep*)iStep)->CloseTMSGraphicsStep();
		TestComplete();
		break;
		}
	((CTGcStep*)iStep)->RecordTestResultL();
	}

__CONSTRUCT_STEP__(Gc)