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

 	}