--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicstest/uibench/src/talphadrawing.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,540 @@
+// 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();
+	}