// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// Test backed up windows
// 
//

/**
 @file
 @test
 @internalComponent - Internal Symbian test code
*/

#include "TBACKUPW.H"

CTBackedUpWindow::CTBackedUpWindow(CTestStep* aStep):
	CTWsGraphicsBase(aStep)
	{
	}


void CTBackedUpWindow::CheckWindow(CFbsBitmap *aBitmap)
	{
	TPoint oldPos=iBackedUpWindow.Position();
	iBackedUpWindow.SetPosition(TPoint(0,0));

	iCheckWindow.SetVisible(ETrue);
	iCheckWindow.SetPosition(iCheckPos);

	iCheckWindow.BeginRedraw();
	TheGc->Activate(iCheckWindow);
	TheGc->BitBlt(TPoint(0,0), aBitmap);
	TheGc->Deactivate();
	iCheckWindow.EndRedraw();

	TheClient->iWs.Flush();
	TheClient->WaitForRedrawsToFinish();
	TBool retVal = TheClient->iScreen->RectCompare(TRect(iSize),TRect(iCheckPos,iSize));
	TEST(retVal);
	if (!retVal)
		INFO_PRINTF3(_L("TheClient->iScreen->RectCompare(TRect(iSize),TRect(iCheckPos,iSize)) return value - Expected: %d , Actual: %d"), ETrue, retVal);		

	iCheckWindow.SetVisible(EFalse);
	iBackedUpWindow.SetPosition(oldPos);
	}

void CTBackedUpWindow::CheckWindow()
	{
	CheckWindow(&iBitmap);
	}

void CTBackedUpWindow::Draw(TInt aDrawFunc, TAny *aParam)
	{
	TheGc->Activate(iBackedUpWindow);
	Draw(aDrawFunc, aParam, TheGc, iBitGc);
	TheGc->Deactivate();
	}

void CTBackedUpWindow::DrawWithTwoGcsL()
	{
	RBlankWindow blank(TheClient->iWs);
	User::LeaveIfError(blank.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle));
	blank.Activate();
	CWindowGc *gc2;
	User::LeaveIfError(TheClient->iScreen->CreateContext(gc2));
	CleanupStack::PushL(gc2);

	CFbsFont *font1;
	TFontSpec fspec(KTestFontTypefaceName,200);
	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)font1,fspec));
	CFbsFont *font2;
	TFontSpec fspec2(KTestFontTypefaceName,400);
	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)font2,fspec2));

	gc2->Activate(iBackedUpWindow);
	gc2->UseFont(font2);
	TheGc->Activate(iBackedUpWindow);
	TheGc->UseFont(font1);
	_LIT(KText,"Testing123");
	TheGc->DrawText(KText,TPoint(20,20));
	gc2->DrawText(KText,TPoint(20,40));
	iBitGc->UseFont(font1);
	iBitGc->DrawText(KText,TPoint(20,20));
	iBitGc->UseFont(font2);
	iBitGc->DrawText(KText,TPoint(20,40));
	iBitGc->DiscardFont();
	TheGc->Deactivate();
	TheClient->iScreen->ReleaseFont(font2);
	TheClient->iScreen->ReleaseFont(font1);
	CleanupStack::PopAndDestroy();
	blank.Close();
	}

void CTBackedUpWindow::Draw(TInt aDrawFunc, TAny *aParam, CBitmapContext *gc1, CBitmapContext *gc2)			//DDD
	{
	CBitmapContext *gc;
	for(TInt mode=0;mode<2;mode++)
		{
		if (mode==0)
			gc=gc1;
		else
			gc=gc2;
		gc->Reset();
		switch(aDrawFunc)
			{
			case 0:
				gc->SetBrushColor(*((TRgb *)aParam));
				gc->SetBrushStyle(CGraphicsContext::ESolidBrush);
				gc->SetPenStyle(CGraphicsContext::ENullPen);
				gc->DrawRect(TRect(iSize));
				break;
			case 1:
				{
				TSize half(iSize.iWidth/2,iSize.iHeight/2);
				gc->DrawEllipse(TRect(half));
				gc->DrawEllipse(TRect(TPoint(0,half.iHeight),half));
				TRect rect1(half);
				gc->SetOrigin(TPoint(half.iWidth,0));
				gc->SetClippingRect(rect1);
				gc->DrawEllipse(rect1);
				gc->SetOrigin(TPoint(half.iWidth,half.iHeight));
				gc->SetClippingRect(rect1);
				gc->DrawEllipse(rect1);
				gc->SetOrigin(TPoint(0,0));
				gc->CancelClippingRect();
				}
				break;
			case 2:
				{
				TInt param= *((TInt *)aParam);
				if (param&0x1)
					gc->DrawLine(TPoint(param+(param*27)%iSize.iWidth,0),
								 TPoint(iSize.iWidth-((param<<1)+(param*19)%iSize.iWidth),iSize.iHeight));
				else
					gc->DrawLine(TPoint(0, (param<<1)+(param*7)%iSize.iHeight),
								 TPoint(iSize.iWidth,param+(param*13)%iSize.iHeight));
				}
				break;
			case 3:
				{
				TPoint pos;
				for(;pos.iX<iSize.iWidth;pos.iX+=10)
					gc->DrawLine(pos,pos+TSize(0,iSize.iHeight));
				for(pos.iX=0;pos.iY<iSize.iHeight;pos.iY+=10)
					gc->DrawLine(pos,pos+TSize(iSize.iWidth,0));
				}
				break;
			}
		}
	}

CTBackedUpWindow::~CTBackedUpWindow()
	{
	iBackedUpWindow.Close();
	iCheckWindow.Close();
	iOomFrontWindow.Close();
	delete iBitGc;
	delete iBitmapDevice;
	delete iTestBitmap;
	delete iMaskBitmap;
	}

void CopyToGray4L(CFbsBitmap*& aDestBitmap,const CFbsBitmap& aSrcBitmap)
	{
	aDestBitmap=new(ELeave) CFbsBitmap();
	CleanupStack::PushL(aDestBitmap);
	User::LeaveIfError(aDestBitmap->Create(aSrcBitmap.SizeInPixels(),EGray4));
	CFbsBitmapDevice* device=CFbsBitmapDevice::NewL(aDestBitmap);
	CleanupStack::PushL(device);
	CFbsBitGc* gc;
	User::LeaveIfError(device->CreateContext(gc));
	gc->BitBlt(TPoint(),&aSrcBitmap);
	delete gc;
	CleanupStack::PopAndDestroy(device);
	CleanupStack::Pop(aDestBitmap);
	}

void CTBackedUpWindow::ConstructL()
	{
	iBackedUpWindow=RBackedUpWindow(TheClient->iWs);
	iBackedUpWindow.Construct(*(TheClient->iGroup->GroupWin()),EGray4,ENullWsHandle);
	TSize size=TheClient->iScreen->SizeInTwips();
	iSize=TheClient->iScreen->SizeInPixels();
	iSize.iWidth>>=1;
	iSize.iHeight>>=1;
	size.iWidth>>=1;
	size.iHeight>>=1;
	size.iWidth-=1;			//Modification to get the mapping factor the same as the screen
	size.iHeight-=1;		//Ditto
	iWinPos.SetXY(iSize.iWidth>>1,iSize.iHeight>>1);
	User::LeaveIfError(iBackedUpWindow.SetExtentErr(iWinPos,iSize));
	iBackedUpWindow.Activate();

	iCheckPos.SetXY(iSize.iWidth,0);
	iCheckWindow=RWindow(TheClient->iWs);
	iCheckWindow.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle);
	iCheckWindow.SetSize(iSize);
	iCheckWindow.SetVisible(EFalse);
	iCheckWindow.Activate();

	TInt col,grey;
	TDisplayMode defMode=TheClient->iWs.GetDefModeMaxNumColors(col,grey);
	User::LeaveIfError(iBitmap.Create(iSize,defMode));
	iBitmap.SetSizeInTwips(size);
	iBitmapDevice=CFbsBitmapDevice::NewL(&iBitmap);
	User::LeaveIfError(iBitmapDevice->CreateContext(iBitGc));

	TRgb rgb(TRgb::Gray4(2));
	Draw(0,&rgb);

	iTestBitmap=new(ELeave) CFbsBitmap();
  	User::LeaveIfError(iTestBitmap->Load(TEST_BITMAP_NAME,0));
	iTestBitmap->SetSizeInTwips(TSize(1500,750));
	iMaskBitmap=new(ELeave) CFbsBitmap();
  	User::LeaveIfError(iMaskBitmap->Load(TEST_BITMAP_NAME,0));
  	TDisplayMode defMode2=iMaskBitmap->DisplayMode();
  	if (defMode>EGray4)
		{
		CFbsBitmap* bitmap=iTestBitmap;
		CopyToGray4L(iTestBitmap,*bitmap);
		delete bitmap;
		bitmap=iMaskBitmap;
		CopyToGray4L(iMaskBitmap,*bitmap);
		delete bitmap;
		}
	defMode2=iMaskBitmap->DisplayMode();
	defMode2=iMaskBitmap->DisplayMode();	
	}

void CTBackedUpWindow::InvisVis()
	{
	iBackedUpWindow.SetVisible(EFalse);
	TheClient->iWs.Flush();
	iBackedUpWindow.SetVisible(ETrue);
	TheClient->iWs.Flush();
	}

void CTBackedUpWindow::WindowOnTop()
	{
	RBlankWindow blank(TheClient->iWs);
	blank.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle);
	blank.Activate();
	blank.Close();
	TheClient->iWs.Flush();

	TPoint pos;
	TInt sizeMode=0;
	TInt draw=13;

	for(pos.iX=-iSize.iWidth;pos.iX<iSize.iWidth;pos.iX+=50)
		for(pos.iY=-iSize.iHeight;pos.iY<iSize.iHeight;pos.iY+=50)
			{
			blank=RBlankWindow(TheClient->iWs);
			blank.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle);
			blank.SetColor(TRgb::Gray256(220));
			blank.SetShadowHeight(2);
			blank.SetExtent(pos+iWinPos,TSize((sizeMode&0x1)?iSize.iWidth>>1:iSize.iWidth<<1,(sizeMode&0x2)?iSize.iHeight>>1:iSize.iHeight<<1));
			sizeMode=(sizeMode+1)%4;
			blank.Activate();
			Draw(2,&draw);
			TheClient->iWs.Flush();
			draw++;
			blank.Close();
			}
	}

void CTBackedUpWindow::Resize()
	{
	RBlankWindow blank(TheClient->iWs);
	blank.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle);
	blank.SetColor(TRgb::Gray256(128));
	blank.Activate();
	TInt xtop=(iSize.iWidth)-(iSize.iWidth>>2);
	TInt ytop=(iSize.iHeight)-(iSize.iHeight>>2);
	for(TInt winMode=0;winMode<3;winMode++)
		{
		switch(winMode)
			{
			case 0:
				blank.SetExtent(TPoint(0,ytop),TSize(iSize.iWidth,iSize.iHeight>>1));
				break;
			case 1:
				blank.SetExtent(TPoint(xtop,0),TSize(iSize.iWidth>>1,iSize.iHeight));
				break;
			case 2:
				blank.SetExtent(TPoint(xtop,ytop),TSize(iSize.iWidth>>1,iSize.iHeight>>1));
				break;
			}
		blank.SetShadowHeight(winMode);
		TPoint oldPos=iBackedUpWindow.Position();
		TPoint pos=oldPos;
		for(TUint i=0;i<sizeof(moveList)/sizeof(moveList[0]);i++)
			{
			pos+=moveList[i];
			iBackedUpWindow.SetPosition(pos);
			TheClient->iWs.Flush();
			}
		iBackedUpWindow.SetPosition(oldPos);
		}
	blank.Close();
	}

void CTBackedUpWindow::ChildWindows()
	{
	TPoint pos;
	TInt sizeMode=0;
	TInt draw=13;
	RBlankWindow blank(TheClient->iWs);
	for(pos.iX=-(iSize.iWidth>>1);pos.iX<iSize.iWidth;pos.iX+=33)
		for(pos.iY=-(iSize.iHeight>>1);pos.iY<iSize.iHeight;pos.iY+=33)
			{
			blank.Construct(iBackedUpWindow,ENullWsHandle);
			blank.SetColor(TRgb::Gray256(220));
			blank.SetShadowHeight(2);
			blank.SetExtent(pos,TSize((sizeMode&0x1)?iSize.iWidth>>2:iSize.iWidth,(sizeMode&0x2)?iSize.iHeight>>2:iSize.iHeight));
			sizeMode=(sizeMode+1)%4;
			blank.Activate();
			Draw(2,&draw);
			TheClient->iWs.Flush();
			draw++;
			blank.Close();
			}
	}

void CTBackedUpWindow::DupBitmapTestL()
	{
	INFO_PRINTF1(_L("AUTO  Dup Bitmap Test "));
	CFbsBitmap *dup=new(ELeave) CFbsBitmap();
	dup->Duplicate(iBackedUpWindow.BitmapHandle());
	CheckWindow(dup);
	TRgb rgb(TRgb::Gray4(1));
	Draw(0,&rgb);
	CheckWindow(dup);
	INFO_PRINTF1(_L(" Done Window Drawing Test"));

	CFbsBitmapDevice *dupDevice=NULL;
	TRAPD(err,dupDevice=CFbsBitmapDevice::NewL(dup));
	CFbsBitGc *gc;
	if (err==KErrNone && dupDevice->CreateContext(gc)==KErrNone)
		{
		Draw(3,NULL,gc,iBitGc);		// Draw directly to backup bitmap (and test bitmap)
		iBackedUpWindow.UpdateScreen();
		INFO_PRINTF1(_L(" First Bitmap Drawing"));
		CheckWindow();
		TRgb rgb(TRgb::Gray256(128));
		TInt col,grey;
		if (TheClient->iWs.GetDefModeMaxNumColors(col,grey)>EGray4)
			rgb=TRgb::Gray4(2);
		Draw(0,&rgb,gc,iBitGc);
		Draw(1,NULL,gc,iBitGc);
		iBackedUpWindow.UpdateScreen(TRegionFix<1>(TRect(iSize)));
		INFO_PRINTF1(_L(" Second Bitmap Drawing"));
		CheckWindow();
		delete gc;
		}
	delete dupDevice;
	delete dup;
	}

void CTBackedUpWindow::UpdateBitmapTestL()
	{
	INFO_PRINTF1(_L("AUTO  UpdateBitmap "));
	CheckWindow();
	CFbsBitmap *dup=new(ELeave) CFbsBitmap();
	dup->Duplicate(iBackedUpWindow.BitmapHandle());
	Draw(3,NULL);
	iBackedUpWindow.UpdateBackupBitmap();
	INFO_PRINTF1(_L(" First Drawing"));
	CheckWindow(dup);
	TRgb rgb;
	if (iSupState==0)
		rgb=TRgb::Gray256(128);
	else
		rgb=TRgb::Gray4(2);
	Draw(0,&rgb);
	Draw(1,NULL);
	iBackedUpWindow.UpdateBackupBitmap();
	INFO_PRINTF1(_L(" Second Drawing"));
	CheckWindow(dup);
	delete dup;
	}

void CTBackedUpWindow::OOML()
	{
	iOomFrontWindow=RBlankWindow(TheClient->iWs);
	TSize size(iBackedUpWindow.Size());
	size.iWidth>>=1;
	size.iHeight>>=1;
	TPoint pos(size.iWidth*3/2,size.iHeight*3/2);
	iOomFrontWindow.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle);
	iOomFrontWindow.SetColor(TRgb(TRgb::Gray4(1)));
	iOomFrontWindow.SetExtent(pos,size);
	iOomFrontWindow.Activate();
	TheClient->iWs.Flush();

	TPoint buwPos=iBackedUpWindow.Position();
	TSize buwSize=iBackedUpWindow.Size();
	for(TInt count=0;count<100;count++)
		{
		iOomFrontWindow.SetVisible(ETrue);
		TheClient->iWs.HeapSetFail(RHeap::EDeterministic,count);
		iBackedUpWindow.SetPosition(buwPos+TPoint(10,5));
		iBackedUpWindow.SetPosition(buwPos);
		iOomFrontWindow.SetSize(size+TSize(10,5));
		iOomFrontWindow.SetSize(size);
		iBackedUpWindow.SetSizeErr(buwSize+TSize(13,7));
		iBackedUpWindow.SetSizeErr(buwSize);
		iOomFrontWindow.SetVisible(EFalse);
		TheClient->iWs.HeapSetFail(RHeap::ENone,0);
		User::LeaveIfError(iBackedUpWindow.SetSizeErr(buwSize));
		TheClient->WaitForRedrawsToFinish();
		CheckWindow();
		}

	iOomFrontWindow.Close();
	}

void CTBackedUpWindow::doGraphicFunctionsL(CBitmapContext *gc,TBool aExtraDrawBitMap)
	{
	TSize size=iBackedUpWindow.Size();
	CFbsFont *aFont;
	_LIT(KFontName,"Swiss");
	TFontSpec fspec(KFontName,190);
	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)aFont,fspec));
	CFbsBitmap* aBitmap=iTestBitmap;
	CFbsBitmap* aMaskBitmap=iMaskBitmap;

	#include "DLLDRAW.H"	// Draws to a Gc called 'gc'
	
	TheClient->iScreen->ReleaseFont(aFont);
	}

void CTBackedUpWindow::AllGraphicFunctionsL(RBlankWindow &aBlank,TBool aExtraDrawBitMap/*=ETrue*/)
	{
	aExtraDrawBitMap=EFalse;		//Check out when bitblit scaling has changed again
	aBlank.SetVisible(ETrue);
	TheGc->Activate(iBackedUpWindow);
	TRAPD(err,doGraphicFunctionsL(TheGc,aExtraDrawBitMap));
	TheGc->Deactivate();
	User::LeaveIfError(err);
	iBitGc->Reset();
	iBitGc->SetUserDisplayMode(EGray4);
	doGraphicFunctionsL(iBitGc,aExtraDrawBitMap);
	aBlank.SetVisible(EFalse);
	CheckWindow();
	}

void CTBackedUpWindow::AllGraphicFunctionsTestsL()
	{
	RBlankWindow blank(TheClient->iWs);
	TInt xtop=(iSize.iWidth)-(iSize.iWidth>>1);
	TInt ytop=(iSize.iHeight)-(iSize.iHeight>>1);
	blank.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle);
	blank.SetColor(TRgb::Gray256(128));
	blank.Activate();
	blank.SetExtent(TPoint(0,ytop),TSize(iSize.iWidth,iSize.iHeight>>2));
	AllGraphicFunctionsL(blank);
	blank.SetExtent(TPoint(0,ytop+10),TSize(iSize.iWidth,iSize.iHeight>>2));
	AllGraphicFunctionsL(blank);
	blank.SetExtent(TPoint(xtop,ytop),TSize(iSize.iWidth>>1,iSize.iHeight));
	AllGraphicFunctionsL(blank,EFalse);
	blank.SetExtent(TPoint(xtop+(iSize.iWidth>>1),ytop),TSize(iSize.iWidth>>1,iSize.iHeight));
	AllGraphicFunctionsL(blank,EFalse);
	blank.SetExtent(TPoint(xtop+10,iSize.iHeight),TSize(iSize.iWidth,iSize.iHeight));
	AllGraphicFunctionsL(blank,EFalse);
	blank.SetExtent(TPoint(xtop,ytop),iSize);
	AllGraphicFunctionsL(blank,EFalse);
	blank.SetExtent(TPoint(0,0),TSize(0,0));
	AllGraphicFunctionsL(blank);
	blank.Close();
	}

void CTBackedUpWindow::RunTestCaseL(TInt /*aCurTestCase*/)
	{
	switch(iSupState)
		{
		case 0:
			for (TInt iSubTest=0;iSubTest<KLastSubtest;iSubTest++)
				{
				DoSubTestL(iSubTest);
				}
			iBackedUpWindow.MaintainBackup();		//Putting this line here is a work around
			break;
		case 1:
			for (TInt iSubTest=0;iSubTest<KLastSubtest;iSubTest++)
				{
				DoSubTestL(iSubTest);
				}
			break;
		default:
			TestComplete();
			break;
		}
	iSupState++;
	}

void CTBackedUpWindow::DoSubTestL(TInt iState)
	{
	_LIT(KTest0,"Simple draw");
	_LIT(KTest1,"Resizing");
	_LIT(KTest2,"Invisible/Visible");
	_LIT(KTest3,"Windows on top");
	_LIT(KTest4,"Child Windows");
	_LIT(KTest5,"OOM");
	_LIT(KTest6,"Update Bitmap");
	_LIT(KTest7,"Bitmap duplicate");
	_LIT(KTest8,"Two Graphic Contexts");
	_LIT(KTest9,"All Graphic Functions");
	_LIT(KTest10,"Reactivate");
	_LIT(KTest11,"DoDrawCommand");

	TRgb rgb1(255,255,255);
	TRgb rgb2(255,255,255);
	TRgb rgb3(255,255,255);
	TRgb rgb4(255,255,255);
	TRgb rgb5(255,255,255);
	TRgb rgb6(255,255,255);
	TRgb rgb7(255,255,255);
	TRgb color(TRgb::Gray4(2));

	iTest->iState=iState;
((CTBackedUpWindowStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
	switch(iState)
		{
/**
@SYMTestCaseID		GRAPHICS-WSERV-0202-0001

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test drawing in a backed up window

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Draw in a backed up window and a normal window and check
					the two drawings are the same

@SYMTestExpectedResults The two drawings are exactly the same
*/
		case 0:
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0202-0001"));
			iTest->LogSubTest(KTest0);
			Draw(1,NULL);
			CheckWindow();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0202-0002

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test drawing in a backed up window

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Draw in a backed up window and a normal window and check
					the two drawings are the same

@SYMTestExpectedResults The two drawings are exactly the same
*/
		case 1:
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0202-0002"));
			iTest->LogSubTest(KTest1);
			Draw(0,&rgb1);
			Draw(3,NULL);
			Resize();
			CheckWindow();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0203

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test making a backed up window invisible

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Draw in a backed up window and a normal window, make
					the backed up window invisible then visible and
					then check the two drawings are the same

@SYMTestExpectedResults The two drawings are exactly the same
*/
		case 2:
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0203"));
			iTest->LogSubTest(KTest2);
			Draw(0,&rgb2);
			Draw(1,NULL);
			InvisVis();
			CheckWindow();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0204

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test drawing in a backed up window and then placing a
					window on top of it

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Draw in a backed up window and a normal window, then
					place a window on top of the backed up window and then
					check the two drawings are the same

@SYMTestExpectedResults The two drawings are exactly the same
*/
		case 3:
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0204"));
			iTest->LogSubTest(KTest3);
			//TRgb rgb(220,220,220);
			Draw(0,&rgb3);
			Draw(1,NULL);
			WindowOnTop();
			CheckWindow();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0205

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test drawing in a backed up window and then drawing in
					a child window

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Draw in a backed up window and a normal window, then
					create and draw in a child window and then
					check the two original drawings are the same

@SYMTestExpectedResults The two drawings are exactly the same
*/
		case 4:
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0205"));
			iTest->LogSubTest(KTest4);
			Draw(0,&rgb4);
			Draw(3,NULL);
			ChildWindows();
			CheckWindow();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0206

@SYMDEF             DEF081259

@SYMTestCaseDesc    Out of memeory test for backed up windows

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Out of memeory test for backed up windows

@SYMTestExpectedResults Backed up window responds correctly when out
						of memory
*/
		case 5:
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0206"));
			iTest->LogSubTest(KTest5);
			if (!iTest->IsFullRomL())
				{
				Draw(0,&rgb5);
				Draw(3,NULL);
				OOML();
				CheckWindow();
				}
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0207

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test updating a bitmap in a backed up window

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Update a bitmap in a backed up window and a normal window
					and check the two bitmaps are the same

@SYMTestExpectedResults The two bitmaps are exactly the same
*/
		case 6:
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0207"));
			iTest->LogSubTest(KTest6);
			Draw(0,&rgb6);
			Draw(1,NULL);
			UpdateBitmapTestL();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0208

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test updating a duplicate bitmap in a backed up window

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Update a duplicated bitmap in a backed up window and a normal window
					and check the two bitmaps are the same

@SYMTestExpectedResults The two bitmaps are exactly the same
*/
		case 7:
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0208"));
			if (iSupState==0)		//Will fail unless the window is fully backup.
				break;
			iTest->LogSubTest(KTest7);
			Draw(0,&rgb7);
			Draw(1,NULL);
			DupBitmapTestL();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0209

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test drawing with two graphic contexts in a backed up window

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Draw using two graphic contexts in a backed up window and a normal
					window and check the two drawings are the same

@SYMTestExpectedResults The two drawings are exactly the same
*/
		case 8:
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0209"));
			iTest->LogSubTest(KTest8);
			Draw(0,&color);
			Draw(1,NULL);
			DrawWithTwoGcsL();
			CheckWindow();
			break;
			
/**
@SYMTestCaseID		GRAPHICS-WSERV-0210

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test drawing using all the graphic functions in a backed up window

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Draw using all the graphic functions in a backed up window and a normal
					window and check the two drawings are the same

@SYMTestExpectedResults The two drawings are exactly the same
*/
		case 9:
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0210"));
			iTest->LogSubTest(KTest9);
			if(TheClient->iScreen->SizeInPixels() == TSize(640,240))
				AllGraphicFunctionsTestsL();
			break;

		//A Coverage test, nothing spectacular just making the code
		//go into CWsGc::Reactivate
		case 10:
			{
/**
@SYMTestCaseID		GRAPHICS-WSERV-0502
*/
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0502"));
			iTest->LogSubTest(KTest10);
			TheGc->Deactivate();
			RBackedUpWindow extentWindow;
			extentWindow=RBackedUpWindow(TheClient->iWs);
			extentWindow.Construct(*(TheClient->iGroup->GroupWin()),EGray4,ENullWsHandle);
			TheGc->Activate(extentWindow);
			TheClient->Flush();
			User::LeaveIfError(extentWindow.SetExtentErr(TPoint(2,2), TSize(4,4)));
			extentWindow.Activate();
			extentWindow.Close();
			TheGc->Deactivate();
			break;
			}

		//Coverage for various messages for CWsGc::DoDrawCommand
		case 11:
			{
/**
@SYMTestCaseID		GRAPHICS-WSERV-0507
*/
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0507"));
			iTest->LogSubTest(KTest11);
			TheGc->Activate(iBackedUpWindow);
			TheGc->Reset();
			iBitGc->Reset();
			iBitGc->SetUserDisplayMode(EGray4);
			
			// EWsGcOpDrawWsGraphic
			TheGc->DrawWsGraphic(TWsGraphicId(0), TRect(0,0,10,10)); 
			
			//create a large junk buffer so that messages with Ptr suffix will be sent
			RBuf8 junkBuf8;
			RBuf  junkBuf;
			junkBuf8.CreateMax(650); // a large enough buffer to sent as Ptr (this value used to crash the code before)
			junkBuf.CreateMax(650); // a large enough buffer to sent as Ptr
			for (int i=0; i<junkBuf.MaxLength()-1;i++)
				{
				junkBuf8[i] = 'A';
				junkBuf[i] = 'A';
				}
			junkBuf8[junkBuf8.MaxLength()-1] = '\0';
			junkBuf[junkBuf.MaxLength()-1] = '\0';
			
			// EWsGcOpDrawWsGraphicPtr
			TheGc->DrawWsGraphic(TWsGraphicId(0), TRect(0,0,10,10), junkBuf8);
			
			// Set font for drawing on screen
			CFbsFont *font1;
			TFontSpec fspec(KTestFontTypefaceName,200);
			User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)font1,fspec));
			TheGc->UseFont(font1);
			iBitGc->UseFont(font1);
						
			// EWsGcOpDrawTextPtr
			TheGc->DrawText(junkBuf, TPoint(0,0));
			iBitGc->DrawText(junkBuf, TPoint(0,0));
			
			// EWsGcOpDrawBoxText - unreachable 299-too lo, 300-too hi

			// EWsGcOpDrawBoxTextPtr
			TheGc->DrawText(junkBuf, TRect(0,0,10,10), 0, CGraphicsContext::ELeft, 0); 
			iBitGc->DrawText(junkBuf, TRect(0,0,10,10), 0, CGraphicsContext::ELeft, 0); 
			
			// EWsGcOpDrawTextVerticalPtr
			TheGc->DrawTextVertical(junkBuf, TPoint(0,0), ETrue);
			iBitGc->DrawTextVertical(junkBuf, TPoint(0,0), ETrue);
			
			// EWsGcOpDrawBoxTextVerticalPtr
			TheGc->DrawTextVertical(junkBuf, TRect(0,0,10,10), 0, ETrue, CGraphicsContext::ELeft, 0);
			iBitGc->DrawTextVertical(junkBuf, TRect(0,0,10,10), 0, ETrue, CGraphicsContext::ELeft, 0);
			
			// EWsGcOpMoveBy
			TheGc->MoveBy(TPoint(2,2));
			iBitGc->MoveBy(TPoint(2,2));
			
			// a bitmap for bitblt ops
			CWsBitmap bmp(TheClient->iWs);
			bmp.Create(TSize(16,16), iBackedUpWindow.DisplayMode());
			
			// EWsGcOpGdiWsBlt2
			TheGc->BitBlt(TPoint(0,0), &bmp);
			iBitGc->BitBlt(TPoint(0,0), &bmp);
			
			// EWsGcOpGdiWsBlt3
			TheGc->BitBlt(TPoint(0,0), &bmp, TRect(0,0,10,10));
			iBitGc->BitBlt(TPoint(0,0), &bmp, TRect(0,0,10,10));
			
			// EWsGcOpGdiWsBltMasked
			TheGc->BitBltMasked(TPoint(0,0), &bmp, TRect(0,0,10,10), &bmp, EFalse);
			iBitGc->BitBltMasked(TPoint(0,0), &bmp, TRect(0,0,10,10), &bmp, EFalse);
			
			// EWsGcOpGdiWsAlphaBlendBitmaps
			TheGc->AlphaBlendBitmaps(TPoint(0,0), &bmp, TRect(0,0,10,10), &bmp, TPoint(1,1));
			iBitGc->AlphaBlendBitmaps(TPoint(0,0), &bmp, TRect(0,0,10,10), &bmp, TPoint(1,1));
			
			// EWsGcOpWsDrawBitmapMasked
			TheGc->DrawBitmapMasked(TRect(0,0,10,10), &bmp, TRect(0,0,8,8), &bmp, ETrue);
			iBitGc->DrawBitmapMasked(TRect(0,0,10,10), &bmp, TRect(0,0,8,8), &bmp, ETrue);
			
			// EWsGcOpDrawBitmap 
			TheGc->DrawBitmap(TPoint(0,0), &bmp);
			iBitGc->DrawBitmap(TPoint(0,0), &bmp);
			
			// EWsGcOpDrawBitmapMasked 
			TheGc->DrawBitmapMasked(TRect(0,0,10,10), static_cast<const CFbsBitmap*>(&bmp), 
					                TRect(0,0,8,8), static_cast<const CFbsBitmap*>(&bmp), 
					                EFalse);
			iBitGc->DrawBitmapMasked(TRect(0,0,10,10), static_cast<const CFbsBitmap*>(&bmp), 
	                				TRect(0,0,8,8), static_cast<const CFbsBitmap*>(&bmp), 
	                				EFalse);
			
			// EWsGcOpDrawPolyLineContinued
			TheGc->DrawPolyLine(reinterpret_cast<const TPoint*>(junkBuf8.Ptr()),
    				            TInt(junkBuf8.Size()/sizeof(TPoint)));
			iBitGc->DrawPolyLine(reinterpret_cast<const TPoint*>(junkBuf8.Ptr()),
		            			TInt(junkBuf8.Size()/sizeof(TPoint)));
			
			// EWsGcOpCopyRect
			TheGc->CopyRect(TPoint(0,0), TRect(0,0,10,10));
			iBitGc->CopyRect(TPoint(0,0), TRect(0,0,10,10));
			
			//cleanup
			TheClient->Flush();
			TheGc->DiscardFont();
			iBitGc->DiscardFont();
			TheClient->iScreen->ReleaseFont(font1);
			junkBuf.Close();
			junkBuf8.Close();
			TheGc->Deactivate();
		
			CheckWindow();
			
			//the following have no client equivalent methods
			// EWsGcOpMapColorsLocal
			// EWsGcOpDrawPolyLineLocalBufLen
			// EWsGcOpDrawPolyLineLocal
			// EWsGcOpDrawPolygonLocalBufLen
			// EWsGcOpDrawPolygonLocal
			// EWsGcOpDrawBitmapLocal
			// EWsGcOpDrawBitmap2Local
			// EWsGcOpDrawBitmap3Local
			// EWsGcOpDrawBitmapMaskedLocal
			// EWsGcOpDrawTextPtr1
			// EWsGcOpDrawBoxTextPtr1
			// EWsGcOpDrawTextVerticalPtr1
			// EWsGcOpDrawBoxTextVerticalPtr1
			// EWsGcOpDrawTextLocal
			// EWsGcOpDrawBoxTextLocal
			// EWsGcOpGdiBlt2Local
			// EWsGcOpGdiBlt3Local
			// EWsGcOpGdiBltMaskedLocal
			((CTBackedUpWindowStep*)iStep)->CloseTMSGraphicsStep();
			break;
			}

		default:
			((CTBackedUpWindowStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
			((CTBackedUpWindowStep*)iStep)->CloseTMSGraphicsStep();
			break;
		}
       ((CTBackedUpWindowStep*)iStep)->RecordTestResultL();
	}

__WS_CONSTRUCT_STEP__(BackedUpWindow)