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