// Copyright (c) 2005-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 "talphadrawing.h"

#include <hal.h>

// When enabled allows testing with a variable windows size rather than fixed size

#define _TESTWITHVARIABLEWINDOWSIZE

// Test bitmap file location

_LIT(KAlphaTestBitmap,"z:\\system\\data\\uibench_24bit.mbm");

const TInt KIterationsToTest = 100; 		// Number of iterations to run tests

const TInt KDelay = 100000; 		// 0.1 seconds

const TInt KRotationGranulatity = 8;// Rotation array granularity

/**

Clear window to selected colour

*/

LOCAL_C void ClearWindow(RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TRgb aColor)

{

	// clear so we can see bitmap version has completed

	aWindow.Invalidate();

	aWindow.BeginRedraw();

	aGc->Activate(aWindow);

	aGc->SetBrushColor(aColor);

	aGc->Clear();

	aGc->Deactivate();

	aWindow.EndRedraw();

	aSession.Flush();

}

/**

Draws a b/w checkerboard onto a RWindow

*/

LOCAL_C void ChessBoard(RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc)

	{

	const TSize size = aWindow.Size();

	aGc->Activate(aWindow);

	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	aGc->SetPenStyle(CGraphicsContext::ENullPen);

	aGc->SetBrushColor(KRgbBlack);

	aGc->Clear();

	aGc->SetBrushColor(KRgbWhite);

	TInt x0 = 0;

	TPoint point;

	const TInt checkerSize = 32;

	for(point.iY=0; point.iY < size.iHeight; point.iY += checkerSize)

		{

		for(point.iX=x0; point.iX < size.iWidth; point.iX += checkerSize*2)

			{

			TRect rect(point, TSize(checkerSize, checkerSize));

			aGc->DrawRect(rect);

			}

		x0 = checkerSize - x0;

		}

	aGc->Deactivate();

	aSession.Flush();

	}

/**

RBlankWindow on top layer gets set visible/invisible to measure timing of drawing the windows below

*/

void CTAlphaDrawing::DrawBlankWindowL (RWindow& /*aForeGndWin*/, TInt aIters)

	{	

	// Create a blank window that is the size of the screen so that we can set this visible to hide the window underneath

	// and then hide it to force redraw of the window underneath

	RBlankWindow blankWindow = RBlankWindow(iWsSession);

	CleanupClosePushL(blankWindow);

	User::LeaveIfError(blankWindow.Construct(iWinGroup, (TInt)this+1));	

	blankWindow.SetSize(iScreenDevice->SizeInPixels());

	blankWindow.SetColor(TRgb(0x3399ff));	

	blankWindow.Activate();

#ifdef _TESTWITHVARIABLEWINDOWSIZE

	// Create a small window that moves position

	RBlankWindow blankWindow2 = RBlankWindow(iWsSession);

	CleanupClosePushL(blankWindow2);

	User::LeaveIfError(blankWindow2.Construct(iWinGroup, (TInt)this+2));

	blankWindow2.SetSize(TSize(10,10));

	blankWindow2.SetColor(TRgb(0x99ff33));

	TInt px = iScreenDevice->SizeInPixels().iWidth/2;

	TInt py = iScreenDevice->SizeInPixels().iHeight/2;

	blankWindow2.SetPosition(TPoint(px, py));

	blankWindow2.Activate();

#endif	

	TBool onoff=ETrue;

	iProfiler->InitResults();

	for(TInt i=aIters; i>=0; i--)

		{

		blankWindow.SetVisible(onoff=!onoff);

#ifdef _TESTWITHVARIABLEWINDOWSIZE

		blankWindow2.SetSize(TSize(10+i, 10+i));

		blankWindow2.SetPosition(TPoint(px--, py--));

		if (px<0) px=150; 

		if (py<0) py=150;

#endif

		iWsSession.Flush();

		iProfiler->MarkResultSetL();

		}	

#ifdef _TESTWITHVARIABLEWINDOWSIZE

	CleanupStack::PopAndDestroy(&blankWindow2);

#endif

	CleanupStack::PopAndDestroy(&blankWindow);

	}

/**

Helper function to calculate processor cycles per pixel as a characteristic number for rendering speed

*/

TInt CTAlphaDrawing::CyclesPerPixel(TInt64 aDuration, TInt aIters, TInt aWidth, TInt aHeight, TInt aCPUSpeed) 

	{	

	TInt64 pixs=aWidth*aHeight;

	TInt64 cpuHz=aCPUSpeed;

	TInt64 ret=(aDuration*cpuHz)/pixs/1000/aIters;

	return ret;

	}

/*

Helper function that draws a window

*/

void CTAlphaDrawing::TestDrawWindowL(TDisplayMode aMode, TInt aIters, TTestCase aTestCase, const TDesC& aTestName)

	{

	RWindow foregndWindow = RWindow(iWsSession);

	User::LeaveIfError(foregndWindow.Construct(iWinGroup, (TInt)this+3));

	CFbsBitmap * bmpModeDep = CreateSoftwareBitmapLC(iScreenDevice->SizeInPixels(), aMode);

	CopyBitmapL(bmpModeDep, iSourceImage);

	foregndWindow.BeginRedraw();

	iWindowGc->Activate(foregndWindow);

	iWindowGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	iWindowGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

	iWindowGc->DrawBitmap(iScreenDevice->SizeInPixels(), bmpModeDep, bmpModeDep->SizeInPixels());

	iWindowGc->Deactivate();

	foregndWindow.EndRedraw();

	iWsSession.Flush();

	switch (aTestCase)

		{

		case EUseOpaqueDraw:

			foregndWindow.SetNonTransparent();	

			break;

		case EUseTransparencyFactor:

			User::LeaveIfError(foregndWindow.SetTransparencyFactor(TRgb(0xbbbbbb,128)));

			break;

		}

	foregndWindow.Activate();

	// Start performance test and analyse results

	DrawBlankWindowL(foregndWindow, aIters);

	iProfiler->ResultsAnalysis(aTestName, 0, aMode, 0, aIters);

	foregndWindow.Close();

	CleanupStack::PopAndDestroy(bmpModeDep);

	User::After(KDelay);

	}

/**

   @SYMTestCaseID

   GRAPHICS-UI-BENCH-0013

   @SYMTestCaseDesc

   The test determines how long it takes to draw an opaque (non-transparent) window composition.

   @SYMTestActions

   Compare the results over time, and before and after changes to wserv code.

   @SYMTestExpectedResults

   Test should pass and display total test time and cycles per pixel

*/

void CTAlphaDrawing::DoTestDrawOpaqueWindowL(TDisplayMode aMode, TInt aIters) 

	{

	TestDrawWindowL(aMode, aIters, EUseOpaqueDraw, _L("WinOpaque"));

	}

/**

   @SYMTestCaseID

   GRAPHICS-UI-BENCH-0014

   @SYMTestCaseDesc

   The test determines how long it takes to draw transparent window compositions with window SetTransparencyFactor.

   @SYMTestActions

   Compare the results over time, and before and after changes to wserv code.

   @SYMTestExpectedResults

   Test should pass and display total test time and cycles per pixel

*/

void CTAlphaDrawing::DoTestDrawTransparentWindowFactorL(TDisplayMode aMode, TInt aIters) 

	{	

	TestDrawWindowL(aMode, aIters, EUseTransparencyFactor, _L("WinTrFac"));	

	}

/**

   @SYMTestCaseID

   GRAPHICS-UI-BENCH-0015

   @SYMTestCaseDesc

   The test determines how long it takes to draw transparent window compositions with SetTransparencyBitmap.

   @SYMTestActions

   Compare the results over time, and before and after changes to wserv code.

   @SYMTestExpectedResults

   Test should pass and display total test time and cycles per pixel

*/

void CTAlphaDrawing::DoTestDrawTransparentWindowBitmapL(TDisplayMode aMode, TInt aIters) 

	{	

	RWindow foregndWindow;

	foregndWindow = RWindow(iWsSession);

	User::LeaveIfError(foregndWindow.Construct(iWinGroup, (TInt)this+5));

	CFbsBitmap * sourceAlpha  = CreateSoftwareBitmapLC(iScreenDevice->SizeInPixels(), EGray256);

	VerticalGradientAlphaL(sourceAlpha, TRgb(0xffffffff), TRgb(0x00000000));

	CFbsBitmap * bmpModeDep  = CreateSoftwareBitmapLC(iScreenDevice->SizeInPixels(), aMode);

	CopyBitmapL(bmpModeDep, iSourceImage);

	foregndWindow.BeginRedraw();

	iWindowGc->Activate(foregndWindow);

	iWindowGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	iWindowGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

	iWindowGc->DrawBitmap(iScreenDevice->SizeInPixels(), bmpModeDep, bmpModeDep->SizeInPixels());

	// Set transparency bitmap for this window

	User::LeaveIfError(foregndWindow.SetTransparencyBitmap(*sourceAlpha));

	iWindowGc->Deactivate();

	foregndWindow.EndRedraw();

	iWsSession.Flush();

	foregndWindow.Activate();

	DrawBlankWindowL(foregndWindow,aIters);

	iProfiler->ResultsAnalysis(_L("WinTrBmp"), 0, aMode, 0, aIters);

	foregndWindow.Close();

	CleanupStack::PopAndDestroy(2, sourceAlpha);

	User::After(KDelay);

	}

/**

@SYMTestCaseID GRAPHICS-UI-BENCH-0016

@SYMTestPriority High

@SYMREQ 0000

@SYMTestCaseDesc 

Test test determines how long it takes to draw transparent window compositions with SetTransparencyAlphaChannel.

@SYMTestActions

Compare the results over time, and before and after changes to wserv code.

@SYMTestExpectedResults

Test should pass and display total test time and cycles per pixel

*/

void CTAlphaDrawing::DoTestDrawTransparentWindowAlphaChannelL(TDisplayMode aMode, TInt aIters) 

	{		

	RWindow foregndWindow;

	foregndWindow = RWindow(iWsSession);

	User::LeaveIfError(foregndWindow.Construct(iWinGroup, (TInt)this+6));	

	CFbsBitmap * sourceAlpha  = CreateSoftwareBitmapLC(iSourceImage->SizeInPixels(), EGray256);

	VerticalGradientAlphaL(sourceAlpha, TRgb(0xffffffff), TRgb(0x00000000));

	CFbsBitmap * bmpModeDep  = CreateSoftwareBitmapLC(iScreenDevice->SizeInPixels(), aMode);

	CopyBitmapL(bmpModeDep, iSourceImage);

	TPoint point;

	TRect  rect(iScreenDevice->SizeInPixels());

	foregndWindow.BeginRedraw();

	iWindowGc->Activate(foregndWindow);

	iWindowGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	iWindowGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

	iWindowGc->DrawBitmapMasked(rect, bmpModeDep, bmpModeDep->SizeInPixels(), sourceAlpha, EFalse);

	User::LeaveIfError(foregndWindow.SetTransparencyAlphaChannel());

	iWindowGc->Deactivate();

	foregndWindow.EndRedraw();

	iWsSession.Flush();

	foregndWindow.Activate();

	DrawBlankWindowL(foregndWindow,aIters);

	iProfiler->ResultsAnalysis(_L("WinTrAlphaCh"), 0, aMode, 0, aIters);

	foregndWindow.Close();

	CleanupStack::PopAndDestroy(2, sourceAlpha);			

	User::After(KDelay);

	}

/**

   @SYMTestCaseID

   GRAPHICS-UI-BENCH-0017

   @SYMTestCaseDesc

   Creates foreground window with alpha channel transparency.

   An image with alpha mask is bitblitted to this window.

   The test determines how long it takes to create a window

   @SYMTestActions

   Compare the results over time, and before and after changes to wserv code.

   @SYMTestExpectedResults

   Test should pass and display total test time and cycles per pixel

*/

void CTAlphaDrawing::DoTestCreateWindowL(TDisplayMode aMode, TInt aIters) 

	{

	RWindow foregndWindow;

	CFbsBitmap * sourceAlpha  = CreateSoftwareBitmapLC(iSourceImage->SizeInPixels(), EGray256);

	VerticalGradientAlphaL(sourceAlpha, TRgb(0xffffffff), TRgb(0x00000000));

	CFbsBitmap * bmpModeDep  = CreateSoftwareBitmapLC(iScreenDevice->SizeInPixels(), aMode);

	CopyBitmapL(bmpModeDep, iSourceImage);

	TPoint point;

	TRect  rect(iScreenDevice->SizeInPixels());

	iProfiler->InitResults();

	for(TInt i=KIterationsToTest; i>=0; i--)

		{

		foregndWindow = RWindow(iWsSession);

		User::LeaveIfError(foregndWindow.Construct(iWinGroup, (TInt)this+7));

		foregndWindow.BeginRedraw();

		iWindowGc->Activate(foregndWindow);

		iWindowGc->SetBrushStyle(CGraphicsContext::ENullBrush);

		iWindowGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

		iWindowGc->DrawBitmapMasked(rect, bmpModeDep, bmpModeDep->SizeInPixels(), sourceAlpha, EFalse);

		TInt ret = foregndWindow.SetTransparencyAlphaChannel();

		if (ret == KErrNotSupported)

			ERR_PRINTF1(_L("Transparency not enabled - Turn on transparency in wsini.ini file"));			

		User::LeaveIfError(ret);			

		iWindowGc->Deactivate();

		foregndWindow.EndRedraw();

		iWsSession.Flush();

		foregndWindow.Activate();

		iWsSession.Flush();

		iProfiler->MarkResultSetL();

		foregndWindow.Close();

		}

	iProfiler->ResultsAnalysis(_L("WinCreation"), 0, aMode, 0, aIters);

	CleanupStack::PopAndDestroy(2, sourceAlpha);					

	User::After(KDelay);

	}

CTAlphaDrawing::~CTAlphaDrawing()

	{

	delete iSourceImage;

	delete iWindowGc;	

	delete iScreenDevice;

	iBackgndWindow.Close();

	iWinGroup.Close();

	iWsSession.Close();

	RFbsSession::Disconnect();

	}

CTAlphaDrawing::CTAlphaDrawing()

	{

	SetTestStepName(KTAlphaDrawing);

	}

/**

Override of base class virtual

@return - TVerdict code

*/

TVerdict CTAlphaDrawing::doTestStepPreambleL()

	{			

	CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL();

	HAL::Get(HALData::ECPUSpeed,iCPUSpeed);

	User::LeaveIfError(RFbsSession::Connect());

	User::LeaveIfError(iWsSession.Connect());

	iScreenDevice = new (ELeave) CWsScreenDevice(iWsSession);

	User::LeaveIfError(iScreenDevice->Construct(0));	// screen number (0 is first screen)

	iSourceImage  = LoadBitmapL(KAlphaTestBitmap,0);

	iWindowGc = new (ELeave) CWindowGc(iScreenDevice);

	User::LeaveIfError(iWindowGc->Construct());

	TDisplayMode windowMode = iScreenDevice->DisplayMode();

	iWinGroup  = RWindowGroup(iWsSession);

	User::LeaveIfError(iWinGroup.Construct(1, EFalse));

	iBackgndWindow = RWindow(iWsSession);

	User::LeaveIfError(iBackgndWindow.Construct(iWinGroup, (TInt)this+8));

	iBackgndWindow.Activate();

	iBackgndWindow.SetNonTransparent();	

	iBackgndWindow.Invalidate();

	iWsSession.Flush();	

	return TestStepResult();

	}

/** 

Override of base class pure virtual

Our implementation only gets called if the base class doTestStepPreambleL() did

not leave. That being the case, the current test result value will be EPass.

Creates background window with black & white checker board. 

This background windows is used for each test case in this file

@return TVerdict code

*/	

TVerdict CTAlphaDrawing::doTestStepL()

	{	

	TInt iters = KIterationsToTest;

	INFO_PRINTF5(_L("TAlphaDrawing - Iterations:%d, CPUSpeed:%d kHz, Width: %d px, Height: %d px"),iters,iCPUSpeed,iScreenDevice->SizeInPixels().iWidth,iScreenDevice->SizeInPixels().iHeight);

	// tests to execute

	TBool iniok; TInt inival;

	iniok = GetIntFromConfig(_L("AlphaDrawingTests"), _L("testCreateWindowAlpha"), inival);

	TBool testCreateWindowAlpha					= ((iniok==EFalse) || (inival > 0));

	iniok = GetIntFromConfig(_L("AlphaDrawingTests"), _L("testDrawOpaqueWindow"), inival);	

	TBool testDrawOpaqueWindow					= ((iniok==EFalse) || (inival > 0));

	iniok = GetIntFromConfig(_L("AlphaDrawingTests"), _L("testDrawTransparentFactorWindow"), inival);

	TBool testDrawTransparentFactorWindow			= ((iniok==EFalse) || (inival > 0));

	iniok = GetIntFromConfig(_L("AlphaDrawingTests"), _L("testDrawTransparentWindowPerPixel"), inival);

	TBool testDrawTransparentWindowPerPixel			= ((iniok==EFalse) || (inival > 0));

	iniok = GetIntFromConfig(_L("AlphaDrawingTests"), _L("testDrawTransparentWindowPerPixelAlpha"), inival);

	TBool testDrawTransparentWindowPerPixelAlpha 	= ((iniok==EFalse) || (inival > 0));

	const TSize iWindowSize=iBackgndWindow.Size();

	// Initalise test - clear window and create checker board on background windows

	ClearWindow(iWsSession, iBackgndWindow, iWindowGc, BLACK_SEMI_TRANSPARENT);

	ChessBoard(iWsSession, iBackgndWindow, iWindowGc);

	iWsSession.Flush();

	TInt screenModesCnt=iScreenDevice->NumScreenModes();

	CArrayFixFlat<TInt> * rotationList=NULL;

	rotationList = new (ELeave) CArrayFixFlat<TInt>(KRotationGranulatity);

	CleanupStack::PushL(rotationList);

	for (TInt scm=0; scm<screenModesCnt; scm++) 

		{			

		iScreenDevice->GetRotationsList(scm,rotationList);

		for (TInt rot = 0; rot < rotationList->Count(); rot++) 

			{		

			TPixelsAndRotation	pxrot;

			pxrot.iPixelSize	=iWindowSize;

			iRotation=(CFbsBitGc::TGraphicsOrientation)rotationList->At(rot);

			pxrot.iRotation	=iRotation;

			iScreenDevice->SetScreenSizeAndRotation(pxrot);

			for(int m=0; m<1; m++)

				{

				// test drawing speed of window creation and destruction

				if ( testCreateWindowAlpha )

					{

					SetTestStepID(_L("GRAPHICS-UI-BENCH-0017"));

					DoTestCreateWindowL(KValidDisplayModes[m],iters);	

					RecordTestResultL();

					}

				// test drawing speed of an opaque window composition

				if ( testDrawOpaqueWindow )

					{	

					SetTestStepID(_L("GRAPHICS-UI-BENCH-0013"));

					DoTestDrawOpaqueWindowL(KValidDisplayModes[m],iters);	

					RecordTestResultL();

					}

				// test drawing speed of a transparent window composition with a transparency factor

				if ( testDrawTransparentFactorWindow )

					{

					SetTestStepID(_L("GRAPHICS-UI-BENCH-0014"));

					DoTestDrawTransparentWindowFactorL(KValidDisplayModes[m],iters);	

					RecordTestResultL();

					}

				// test drawing speed of a transparent window composition with a transparency bitmap

				if ( testDrawTransparentWindowPerPixel )

					{

					SetTestStepID(_L("GRAPHICS-UI-BENCH-0015"));

					DoTestDrawTransparentWindowBitmapL(KValidDisplayModes[m],iters);	

					RecordTestResultL();

					}

				// test drawing speed of a transparent window composition with alpha channel transparency

				if ( testDrawTransparentWindowPerPixelAlpha )

					{

					SetTestStepID(_L("GRAPHICS-UI-BENCH-0016"));

					DoTestDrawTransparentWindowAlphaChannelL(KValidDisplayModes[m],iters);	

					RecordTestResultL();

					}						

				} // m...Modes				

			} // rot ... Rotations			

		}	

	CleanupStack::PopAndDestroy(rotationList);

	TVerdict a = TestStepResult();

	return TestStepResult();

	}