// Copyright (c) 1998-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 Fading and UnFading of windows

// 

//

#include "TFADE.H"

#define __DISPLAY_MODE_64K_COLOR

//CRedrawWin

CRedrawWin::CRedrawWin(CTFade *aTest) : CTWin(), iTest(aTest)

	{}

CRedrawWin::~CRedrawWin()

	{

	}

void CRedrawWin::ConstructL(TRect aArea)

	{

	ConstructExtLD(*TheClient->iGroup,aArea.iTl,aArea.Size());

	AssignGC(*TheClient->iGc);

	Activate();

	iWin.BeginRedraw();

	iWin.EndRedraw();

	}

void CRedrawWin::Draw()

	{

	iTest->Drawing(iTest->Content(),iGc);

	}

//CFadeTest

CTFade::CTFade(CTestStep* aStep) : CTWsGraphicsBase(aStep)

	{

#if defined (__MARM_THUMB__)

	CanFade = false;

	CanFadeSet = false;

#endif

	}

void CTFade::ConstructL()

	{

	iDeviceDisplayMode=TheClient->iScreen->DisplayMode();

	iTestWinSize=StdTestWindowSize();

	iFadeDrawMode = iDeviceDisplayMode;

	iTestWinCopy = new (ELeave) CFbsBitmap();

	iTestWinCopy->Create(iTestWinSize,TheClient->iScreen->DisplayMode());

	iCheckWinCopy = new (ELeave) CFbsBitmap();

	iCheckWinCopy->Create(iTestWinSize,TheClient->iScreen->DisplayMode());

	}

CTFade::~CTFade()

	{

	__ASSERT_ALWAYS(!iBlankWin,AutoPanic(EAutoFadeWindow));

	delete iTestWinCopy;

	delete iCheckWinCopy;

	}

TInt CTFade::Content()

	{

	return iContent;

	}

void CTFade::CreateBlankWindowL()

	{

	__ASSERT_ALWAYS(!iBlankWin,AutoPanic(EAutoFadeWindow));

	TSize scrSize(TheClient->iScreen->SizeInPixels());

	iTestWinSize.SetSize(2*scrSize.iWidth/3-6,scrSize.iHeight-6);

	iBlankWin=new(ELeave) CTBlankWindow();

	iWindowRect.SetRect(TPoint(3+scrSize.iWidth/3,3),iTestWinSize);

	iBlankWin->SetUpL(iWindowRect.iTl,iTestWinSize,TheClient->iGroup,*TheClient->iGc);

	iBlankWin->BaseWin()->SetRequiredDisplayMode(EGray16);

	}

void CTFade::DestroyBlankWindow()

	{

	__ASSERT_ALWAYS(iBlankWin,AutoPanic(EAutoFadeWindow));

	delete iBlankWin;

	iBlankWin=NULL;

	}

void CTFade::CreateBackupWindowL(TBool aMaintainBackup)

	{

	__ASSERT_ALWAYS(!iWin,AutoPanic(EAutoFadeWindow));

	CTBackedUpWin* backUpWin=new(ELeave) CTBackedUpWin(MODE_LT_64K(iDeviceDisplayMode)?iFadeDrawMode:iDeviceDisplayMode);

	iWin=backUpWin;

	iOwnWindow=ETrue;

	iWindowRect.SetRect(TPoint(2*iTestWinSize.iWidth+35,7),iTestWinSize);

	backUpWin->ConstructExtLD(*TheClient->iGroup,iWindowRect.iTl,iTestWinSize);

	if (aMaintainBackup)

		backUpWin->BackedUpWin()->MaintainBackup();

	backUpWin->Activate();

	TheClient->WaitForRedrawsToFinish();		//Without this bitmaps won't draw into the window

	}

void CTFade::CreateRedrawWindowL()

	{

	__ASSERT_ALWAYS(!iWin,AutoPanic(EAutoFadeWindow));

	iWindowRect.SetRect(TPoint(2*iTestWinSize.iWidth+35,7),iTestWinSize);

	CRedrawWin* redrawWin=new(ELeave) CRedrawWin(this);

	redrawWin->ConstructL(iWindowRect);

	redrawWin->Win()->EnableRedrawStore(EFalse);

	iWin=redrawWin;

	iOwnWindow=ETrue;

	iWin->BaseWin()->SetRequiredDisplayMode(iFadeDrawMode);

	}

void CTFade::DestroyDrawableWindow()

	{

	__ASSERT_ALWAYS(iWin,AutoPanic(EAutoFadeWindow));

	if (iOwnWindow)

		delete iWin;

	iWin=NULL;

	}

void CTFade::CreateBitmapsL()

	{

	iTestWinSize=BaseWin->Size();

	iBaseRect.SetRect(BaseWin->BaseWin()->InquireOffset(*TheClient->iGroup->WinTreeNode()),iTestWinSize);

	iNormalBitmap.Create(iTestWinSize,MODE_LT_64K(iDeviceDisplayMode)?iFadeDrawMode:iDeviceDisplayMode);

	iFadedBitmap.Create(iTestWinSize,MODE_LT_64K(iDeviceDisplayMode)?iFadeDrawMode:iDeviceDisplayMode);

	iNormalBitmapDevice=CFbsBitmapDevice::NewL(&iNormalBitmap);

	iFadedBitmapDevice=CFbsBitmapDevice::NewL(&iFadedBitmap);

	User::LeaveIfError(iNormalBitmapDevice->CreateContext(iNormalBitGc));

	User::LeaveIfError(iFadedBitmapDevice->CreateContext(iFadedBitGc));

	iFadedBitGc->SetFadeMode(ETrue);

	iBaseWinMode=BaseWin->BaseWin()->DisplayMode();

	BaseWin->BaseWin()->SetRequiredDisplayMode(iFadeDrawMode);

	}

void CTFade::DestroyBitmaps()

	{

	delete iNormalBitGc;

	delete iFadedBitGc;

	delete iNormalBitmapDevice;

	delete iFadedBitmapDevice;

	BaseWin->BaseWin()->SetRequiredDisplayMode(iBaseWinMode);

	}

void CTFade::Drawing(TInt aDrawFunc, CBitmapContext *gc)

	{

	TRgb grey=TRgb::Gray4(2);

	TInt ii;

	gc->Reset();

	switch (aDrawFunc)

		{

	case 1:

	case 2:

		Draw(0,&grey,gc);

		gc->Reset();

		Draw(1,NULL,gc);

		if (aDrawFunc==1)

			break;

		gc->Reset();

		Draw(3,NULL,gc);

		break;

	case 3:

		Draw(0,&grey,gc);

		gc->Reset();

		Draw(3,NULL,gc);

		break;

	case 4:

		grey=TRgb::Gray4(1);

		gc->Reset();

		Draw(0,&grey,gc);

		gc->Reset();

		for (ii=1;ii<37;ii+=7)

			Draw(2,&ii,gc);

		break;

	case 5:

		Draw(0,&grey,gc);

		gc->Reset();

		Draw(1,NULL,gc);

		gc->Reset();

		for (ii=2;ii<60;ii+=11)

			Draw(2,&ii,gc);

		break;

	case 6:

	case 7:

		Draw(0,&grey,gc);

		gc->Reset();

		Draw(3,NULL,gc);

		gc->Reset();

		for (ii=3;ii<70;ii+=13)

			Draw(2,&ii,gc);

		if (aDrawFunc==6)

			break;

		gc->Reset();

		Draw(1,NULL,gc);

		break;

	default:;

		}

	}

void CTFade::Draw(TInt aDrawFunc, TAny *aParam, TBool aAlternativeFade/*=EFalse*/, TBool aFade/*=EFalse*/)

	{

	CWindowGc *gc=TheClient->iGc;

	gc->Activate(*iWin->DrawableWin());

	gc->Reset();

	if (aFade)

		gc->SetFaded(ETrue);

	iNormalBitGc->Reset();

	iFadedBitGc->Reset();

	iFadedBitGc->SetFadeMode(ETrue);

	if (aAlternativeFade)

		iFadedBitGc->SetFadingParameters(BLACK_ALTERNATE,WHITE_ALTERNATE);

	Draw(aDrawFunc,aParam,gc);

	Draw(aDrawFunc,aParam,iNormalBitGc);

	Draw(aDrawFunc,aParam,iFadedBitGc);

	gc->Deactivate();

	if (aAlternativeFade)

		iFadedBitGc->SetFadingParameters(BLACK_NORMAL,WHITE_NORMAL);

	}

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA // CWindowGc fading is deprecated in NGA

void CTFade::GCDraw(TInt aDrawFunc, TAny *aParam, TBool aAlternativeFade)

	{

	CWindowGc *gc=TheClient->iGc;

	gc->Activate(*iWin->DrawableWin());

	gc->Reset();

	Draw(aDrawFunc,aParam,gc);

	gc->Deactivate();

	gc->Activate(*BaseWin->DrawableWin());

	gc->Reset();

	gc->SetFaded(ETrue);

	if (aAlternativeFade)

		gc->SetFadingParameters(BLACK_ALTERNATE,WHITE_ALTERNATE);

	Draw(aDrawFunc,aParam,gc);

	gc->Deactivate();

	}

#endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

void CTFade::Draw(TInt aDrawFunc, TAny *aParam, CBitmapContext *aGc)

	{

	switch(aDrawFunc)

		{

		case 0:

			aGc->SetBrushColor(*((TRgb *)aParam));

			aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

			aGc->SetPenStyle(CGraphicsContext::ENullPen);

			aGc->DrawRect(TRect(iTestWinSize));

			break;

		case 1:

			{

			TSize half(iTestWinSize.iWidth/2,iTestWinSize.iHeight/2);

			TRect rect(half);

			aGc->DrawEllipse(rect);

			aGc->DrawEllipse(TRect(TPoint(0,half.iHeight),half));

			aGc->SetOrigin(TPoint(half.iWidth,0));

			aGc->SetClippingRect(rect);

			aGc->DrawEllipse(rect);

			aGc->SetOrigin(TPoint(half.iWidth,half.iHeight));

			aGc->SetClippingRect(rect);

			aGc->DrawEllipse(rect);

			aGc->SetOrigin(TPoint());

			aGc->CancelClippingRect();

			}

			break;

		case 2:

			{

			TInt param= *((TInt *)aParam);

			if (param&0x1)

				aGc->DrawLine(TPoint(param+(param*27)%iTestWinSize.iWidth,0),

							 TPoint(iTestWinSize.iWidth-((param<<1)+(param*19)%iTestWinSize.iWidth),iTestWinSize.iHeight));

			else

				aGc->DrawLine(TPoint(0, (param<<1)+(param*7)%iTestWinSize.iHeight),

							 TPoint(iTestWinSize.iWidth,param+(param*13)%iTestWinSize.iHeight));

			}

			break;

		case 3:

			{

			TPoint pos;

			for(;pos.iX<iTestWinSize.iWidth;pos.iX+=10)

				aGc->DrawLine(pos,pos+TSize(0,iTestWinSize.iHeight));

			for(pos.iX=0;pos.iY<iTestWinSize.iHeight;pos.iY+=10)

				aGc->DrawLine(pos,pos+TSize(iTestWinSize.iWidth,0));

			}

			break;

		}

	}

void CTFade::CompareWithBitmap(TBool aFade)

	{

	TBool match;

	CWindowGc& gc=*TheClient->iGc;

	CFbsBitmap* bitmap;

	TheClient->iWs.Flush();

	if (aFade)

		bitmap=&iFadedBitmap;

	else

		bitmap=&iNormalBitmap;

	gc.Activate(*BaseWin->DrawableWin());

	gc.Reset();

	gc.BitBlt(TPoint(),bitmap);

	gc.Deactivate();

	TheClient->iWs.Flush();

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

	match=TheClient->iScreen->RectCompare(iBaseRect,iWindowRect);

#else // In NGA comparison has to be lossy because fading can be implemented on hardware

	match=LossyCompareWindow(*TheClient->iScreen, *iTestWinCopy, *iCheckWinCopy, iWindowRect);

#endif

	TEST(match);

	if (!match)

			{

			_LIT(KLog,"Windows content don't match when they should");

			LOG_MESSAGE(KLog);

			}

	}

void CTFade::CompareWindows(TBool aAlternativeFade/*=EFalse*/)

	{

	if (aAlternativeFade)

		iWin->WinTreeNode()->SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly,BLACK_ALTERNATE,WHITE_ALTERNATE);

	else

		iWin->WinTreeNode()->SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly);

	TheClient->iWs.Flush();

	TBool retVal = TheClient->iScreen->RectCompare(iBaseRect,iWindowRect);

	TEST(retVal);

	if (!retVal)

		INFO_PRINTF3(_L("TheClient->iScreen->RectCompare(iBaseRect,iWindowRect) return value - Expected: %d, Actual: %d"), ETrue, retVal);		

	iWin->WinTreeNode()->SetFaded(EFalse,RWindowTreeNode::EFadeWindowOnly);

	TheClient->iWs.Flush();

	TheClient->WaitForRedrawsToFinish();

	}

#define FADE(n,col) n/2+col/2

TInt CTFade::Fade4(TInt aGray4)

	{

#if defined(__WINS__)

	return FADE(4,aGray4);

#elif defined (__MARM_THUMB__)

	return (CanFade ? FADE(4,aGray4):aGray4);

#elif defined (__MARM__)

	return FADE(4,aGray4);

#else

	return aGray4;

#endif

	}

TInt CTFade::Fade16(TInt aGray16)

	{

#if defined(__WINS__)

	return FADE(16,aGray16);

#elif defined (__MARM_THUMB__)

	return (CanFade ? FADE(16,aGray16):aGray16);

#elif defined (__MARM__)

	return FADE(16,aGray16);

#else

	return aGray16;

#endif

	}

TRgb CTFade::FadeRgb(TRgb aColor)

	{

	switch (iFadeDrawMode)

		{

	case EColor16M:

	case EColor16MU:		

	case EColor16MA:

	case EColor16MAP:

		break; 

	default:

		aColor=TRgb::Color64K(aColor.Color64K());

		break; 

		}

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA // Color fading calculation differs in NGA

	TInt fadeMapFactor=WHITE_NORMAL-BLACK_NORMAL+1;

#else

	TInt fadeMapFactor=WHITE_NORMAL-BLACK_NORMAL;

#endif

	TInt fadeMapOffset=BLACK_NORMAL;

	TInt value = aColor.Internal();

	TInt b = (((value & 0x000000ff) * fadeMapFactor) >> 8) + fadeMapOffset;

	TInt g = (((value & 0x0000ff00) * fadeMapFactor) >> 16) + fadeMapOffset;

	TInt r = (((value & 0x00ff0000) * fadeMapFactor) >> 24) + fadeMapOffset;

	return TRgb(r,g,b);

	}

TRgb CTFade::FadeRgb(TRgb aColor, TInt aFadeMapFactor, TInt aFadeMapOffset)

	{

	switch (iFadeDrawMode)

		{

	case EColor16M:

	case EColor16MU:

	case EColor16MA:

	case EColor16MAP:

		break; 

	default:

		aColor=TRgb::Color64K(aColor.Color64K());

		break; 

		}

	TInt value = aColor.Internal();

	TInt b = (((value & 0x000000ff) * aFadeMapFactor) >> 8) + aFadeMapOffset;

	TInt g = (((value & 0x0000ff00) * aFadeMapFactor) >> 16) + aFadeMapOffset;

	TInt r = (((value & 0x00ff0000) * aFadeMapFactor) >> 24) + aFadeMapOffset;

	return TRgb(r,g,b);

	}

inline void CTFade::ViewDelay()

	//

	//This routine can provide a delay which will allow the user to see the colors changing

	//

	{

	TheClient->iWs.Finish();

	/*TheClient->iWs.Flush();

	User::After(1000000);*/		// 1 sec

	}

void CTFade::ColorTest()

	{

	__ASSERT_ALWAYS(iBlankWin,AutoPanic(EAutoFadeWindow));

	TBool retVal;

	TSize size(iTestWinSize);

#if defined(SMALL_RECTS)

	size.iWidth=Min(SIZE_X,size.iWidth);

	size.iHeight=Min(SIZE_Y,size.iHeight);

#endif

	TRect windowRect(iBlankWin->BaseWin()->InquireOffset(*TheClient->iGroup->WinTreeNode()),size);

	TInt ii;

	iBlankWin->BaseWin()->SetRequiredDisplayMode(EGray4);

	TheClient->WaitForRedrawsToFinish();		//Force the screen into 4 gray mode

	TRgb fadedColor;

	for (ii=1;ii<4;ii+=2)		//0 and 3 now give dithered colors when fading so causing this test to fail

		{

		iBlankWin->SetColor(TRgb::Gray4(ii));

		ViewDelay();

		INFO_PRINTF1(_L(" Testing Normal Color"));

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

		retVal = CheckBlankWindow(windowRect,TRgb::Gray4(ii),TheClient->iScreen);

#else

		TheClient->iScreen->CopyScreenToBitmap(iTestWinCopy, windowRect);

		retVal = LossyCheckBlankWindow(*TheClient->iScreen, *iTestWinCopy, windowRect, TRgb::Gray4(ii));

#endif

		TEST(retVal);

		if (!retVal)

			INFO_PRINTF3(_L("CheckBlankWindow(windowRect,TRgb::Gray4(ii),TheClient->iScreen) return value - Expected: %d, Actual: %d"), ETrue, retVal);		

		iBlankWin->BaseWin()->SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly);

		ViewDelay();

		fadedColor=MODE_LT_64K(iDeviceDisplayMode)?TRgb::Gray4(Fade4(ii)):FadeRgb(TRgb::Gray4(ii));

#if defined (__MARM_THUMB__)

		if (ii==1)

			{

			CanFade=!CheckBlankWindow(windowRect,fadedColor,TheClient->iScreen);

			CanFadeSet=ETrue;

			fadedColor=MODE_LT_64K(iDeviceDisplayMode)?TRgb::Gray4(Fade4(ii)):FadeRgb(TRgb::Gray4(ii));

			}

#endif

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

		retVal = CheckBlankWindow(windowRect,fadedColor,TheClient->iScreen);

#else

		retVal = LossyCheckBlankWindow(*TheClient->iScreen, *iTestWinCopy, windowRect, fadedColor);

#endif

		TEST(retVal);

		if (!retVal)

			INFO_PRINTF3(_L("CheckBlankWindow(windowRect,fadedColor,TheClient->iScreen) return value - Expected: %d, Actual: %d"), ETrue, retVal);		

		iBlankWin->BaseWin()->SetFaded(EFalse,RWindowTreeNode::EFadeWindowOnly);

		ViewDelay();

		INFO_PRINTF1(_L(" Testing Unfaded Color"));

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

		retVal = CheckBlankWindow(windowRect,TRgb::Gray4(ii),TheClient->iScreen);

#else

		retVal = LossyCheckBlankWindow(*TheClient->iScreen, *iTestWinCopy, windowRect, TRgb::Gray4(ii));

#endif

		TEST(retVal);

		if (!retVal)

			INFO_PRINTF3(_L("CheckBlankWindow(windowRect,TRgb::Gray4(ii),TheClient->iScreen) return value - Expected: %d, Actual: %d"), ETrue, retVal);		

		}

	iBlankWin->BaseWin()->SetRequiredDisplayMode(EGray16);

	if (MaxGrays()==0 && MaxColors()<256)

		return;

	INFO_PRINTF1(_L(" Doing 16 Gray Colors"));

	for (ii=0;ii<16;++ii)

		{

		iBlankWin->SetColor(TRgb::Gray16(ii));

		ViewDelay();

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

		retVal = CheckBlankWindow(windowRect,TRgb::Gray16(ii),TheClient->iScreen);

#else

		retVal = LossyCheckBlankWindow(*TheClient->iScreen, *iTestWinCopy, windowRect, TRgb::Gray16(ii));

#endif

		TEST(retVal);

		if (!retVal)

			INFO_PRINTF3(_L("CheckBlankWindow(windowRect,TRgb::Gray16(ii),TheClient->iScreen) return value - Expected: %d, Actual: %d"), ETrue, retVal);		

		iBlankWin->BaseWin()->SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly);

		ViewDelay();

		fadedColor=MODE_LT_64K(iDeviceDisplayMode)?TRgb::Gray16(Fade16(ii)):FadeRgb(TRgb::Gray16(ii));

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

		retVal = CheckBlankWindow(windowRect,fadedColor,TheClient->iScreen);

#else

		retVal = LossyCheckBlankWindow(*TheClient->iScreen, *iTestWinCopy, windowRect, fadedColor);

#endif

		TEST(retVal);

		if (!retVal)

			INFO_PRINTF3(_L("CheckBlankWindow(windowRect,fadedColor,TheClient->iScreen) return value - Expected: %d, Actual: %d"), ETrue, retVal);		

		iBlankWin->BaseWin()->SetFaded(EFalse,RWindowTreeNode::EFadeWindowOnly);

		ViewDelay();

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

		retVal = CheckBlankWindow(windowRect,TRgb::Gray16(ii),TheClient->iScreen);

#else

		retVal = LossyCheckBlankWindow(*TheClient->iScreen, *iTestWinCopy, windowRect, TRgb::Gray16(ii));

#endif

		TEST(retVal);

		if (!retVal)

			INFO_PRINTF3(_L("CheckBlankWindow(windowRect,TRgb::Gray16(ii),TheClient->iScreen) return value - Expected: %d, Actual: %d"), ETrue, retVal);