// 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 <gdi.h>

#include "talphablend.h"

const TInt KIterationsToTest = 100;

const TInt KDrawRectIterationsToTest = KIterationsToTest*5;	// More as faster simpler drawing than bitblits

const TInt KDrawVertLineIterationsToTest = KIterationsToTest*5;

const TInt KDrawTextIterationsToTest = KIterationsToTest*2;// More as drawing fewer pixels than blits.

const TInt KDrawVertTextIterationsToTest = KIterationsToTest;// Slow, less iterations.

    _LIT(KFontTypeface,"DejaVu Sans Condensed");

//

// We have two overloads of this test, the normal version that runs all tests except...

//

CAlphaBlendTestNormal::CAlphaBlendTestNormal()

	{

	SetTestStepName(KAlphaBlendTest);

	}

TVerdict CAlphaBlendTestNormal::doTestStepL()

	{	

	return(CAlphaBlendTest::doTestStepL(EFalse));

	}

/*

...the iType font variant, this needs the rom configured differently so can not be run with the other tests

to configure the rom for iType fonts you need to use:

..\iType\binaries\ityperast install

and to remove them and swich back to normal

 ..\iType\binaries\ityperast uninstall

*/

CAlphaBlendTestIType::CAlphaBlendTestIType()

	{

	SetTestStepName(KAlphaBlendTestIType);

	}

TVerdict CAlphaBlendTestIType::doTestStepL()

	{	

	return(CAlphaBlendTest::doTestStepL(ETrue));

	}

/**

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.

@return - TVerdict code

*/

TVerdict CAlphaBlendTest::doTestStepL(TBool aIType)

	{	

	RWsSession wsSession;

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

	CleanupClosePushL(wsSession);

	//

	// Uncomment to debug WSERV redraw problems.

	// wsSession.SetAutoFlush(ETrue); 

	CWsScreenDevice* windowDevice = new (ELeave) CWsScreenDevice(wsSession);

	CleanupStack::PushL(windowDevice);

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

	CWindowGc* windowGc=NULL;	

	User::LeaveIfError(windowDevice->CreateContext(windowGc)); // create graphics context	

	CleanupStack::PushL(windowGc);	

	RWindowGroup group;	

	group  = RWindowGroup(wsSession);

	CleanupClosePushL(group);

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

	RWindow background;

	background = RWindow(wsSession);

	CleanupClosePushL(background);

	User::LeaveIfError(background.Construct(group, 2));

	RWindow window;

	window = RWindow(wsSession);

	CleanupClosePushL(window);

	User::LeaveIfError(window.Construct(group, 3));

	TSize        windowSize = windowDevice->SizeInPixels();

	TDisplayMode windowMode = windowDevice->DisplayMode();

	background.Activate();

	background.Invalidate();

	ClearWindow(wsSession, background, windowGc, BLACK_SEMI_TRANSPARENT);	

	ClearWindow(wsSession, window, windowGc, BLACK_SEMI_TRANSPARENT);

	window.SetTransparencyAlphaChannel();	

	window.Activate();

	window.Invalidate();

	if (aIType)

		{

		if (CheckMonoTypeInstalledL())

			DoDrawBlendedTestsL(EBlendTestDrawTextIType,wsSession, KDrawVertTextIterationsToTest);

		else

			{

			INFO_PRINTF1(_L("Monotype fonts not installed, skipping test"));

			}

		}

	else

		{

/*

Test speed of blended draw rects on all modes supporting alpha blending

*/	

		DoDrawBlendedTestsL(EBlendTestDrawRect,wsSession, KDrawRectIterationsToTest);

/*

Test speed of blended draw vertical line calls on all modes supporting alpha blending

*/	

		DoDrawBlendedTestsL(EBlendTestVerticalLine,wsSession, KDrawVertLineIterationsToTest);

/*

Test speed of blended draw text calls on all modes supporting alpha blending

*/	

		DoDrawBlendedTestsL(EBlendTestDrawText,wsSession, KDrawTextIterationsToTest);

		DoDrawBlendedTestsL(EBlendTestDrawTextAntiAliased,wsSession, KDrawVertTextIterationsToTest);

		DoDrawBlendedTestsL(EBlendTestDrawVerticalText,wsSession, KDrawVertTextIterationsToTest);

/**

   @SYMTestCaseID

   GRAPHICS-UI-BENCH-0022

   @SYMTestCaseDesc

   Alphablend test BITBLT with EColor16MA source and EColor16MU destination.

   @SYMTestActions

   Compare the results over time

   @SYMTestExpectedResults

*/

		RDebug::Printf("Alpha Tests: EColor16MU, EColor16MA");

		RDebug::Printf("Alpha Blend");	

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

		DoAlphaBlendBitmapsBitmapTestL(EColor16MA, EColor16MU, wsSession, window, windowGc, KIterationsToTest);	

		RecordTestResultL();

/**

   @SYMTestCaseID

   GRAPHICS-UI-BENCH-0023

   @SYMTestCaseDesc

   Test BITBLT with EColor16MA source and EColor16MU destination.

   @SYMTestActions

   Compare the results over time

   @SYMTestExpectedResults

*/

		RDebug::Printf("BitBlt Alpha");

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

		DoBitBltAlphaBitmapTestL(EColor16MA, EColor16MU, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

   @SYMTestCaseID

   GRAPHICS-UI-BENCH-0024

   @SYMTestCaseDesc

   Alpha blend test BITBLT with EColor16MA source and EColor16MA destination.

   @SYMTestActions

   Compare the results over time

   @SYMTestExpectedResults

*/

		RDebug::Printf("Alpha Tests: EColor16MA, EColor16MA");

		RDebug::Printf("Alpha Blend");	

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

		DoAlphaBlendBitmapsBitmapTestL(EColor16MA,EColor16MA, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

   @SYMTestCaseID

   GRAPHICS-UI-BENCH-0025

   @SYMTestCaseDesc

   Test BITBLT with EColor16MA source and EColor16MA destination.

   @SYMTestActions

   Compare the results over time

   @SYMTestExpectedResults

*/

		RDebug::Printf("BitBlt Alpha");

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

		DoBitBltAlphaBitmapTestL(EColor16MA, EColor16MA, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

	@SYMTestCaseID

	GRAPHICS-UI-BENCH-0063

	@SYMTestCaseDesc

	Test BITBLT with EColor16MAP source and EColor16MAP destination.

	@SYMTestActions

	Compare the results over several iterations over time.

	@SYMTestExpectedResults

*/

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

		DoNormalBitBltL(EFalse, EColor16MAP,EColor16MAP, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

	@SYMTestCaseID

	GRAPHICS-UI-BENCH-0064

	@SYMTestCaseDesc

	Test BITBLT with EColor16MA source and EColor16MA destination.

	@SYMTestActions

	Compare the results over several iterations over time.

	@SYMTestExpectedResults

*/

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

		DoNormalBitBltL(EFalse, EColor16MA,EColor16MA, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

	@SYMTestCaseID

	GRAPHICS-UI-BENCH-0065

	@SYMTestCaseDesc

	Test BITBLT with EColor16MAP source and EColor16MA destination.

	@SYMTestActions

	Compare the results over several iterations over time.

	@SYMTestExpectedResults

*/

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

		DoNormalBitBltL(EFalse, EColor16MAP,EColor16MA, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

	@SYMTestCaseID

	GRAPHICS-UI-BENCH-0066

	@SYMTestCaseDesc

	Test BITBLT with EColor16MA source and EColor16MAP destination.

	@SYMTestActions

	Compare the results over several iterations over time.

	@SYMTestExpectedResults

*/

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

		DoNormalBitBltL(EFalse, EColor16MA,EColor16MAP, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

	@SYMTestCaseID

	GRAPHICS-UI-BENCH-0067

	@SYMTestCaseDesc

	Test BITBLT with EColor16MU source and EColor16MU destination.

	@SYMTestActions

	Compare the results over several iterations over time.

	@SYMTestExpectedResults

*/

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

		DoNormalBitBltL(EFalse, EColor16MU,EColor16MU, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

	@SYMTestCaseID

	GRAPHICS-UI-BENCH-0068

	@SYMTestCaseDesc

	Test BITBLT with EColor16MAP source and EColor16MU destination.

	@SYMTestActions

	Compare the results over several iterations over time.

	@SYMTestExpectedResults

*/

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

		DoNormalBitBltL(EFalse, EColor16MAP,EColor16MU, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

	@SYMTestCaseID

	GRAPHICS-UI-BENCH-0069

	@SYMTestCaseDesc

	Test BITBLT with EColor16MU source and EColor16MAP destination.

	@SYMTestActions

	Compare the results over several iterations over time.

	@SYMTestExpectedResults

*/

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

		DoNormalBitBltL(EFalse, EColor16MU,EColor16MAP, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

	@SYMTestCaseID

	GRAPHICS-UI-BENCH-0070

	@SYMTestCaseDesc

	Test BITBLT with EColor64K source and EColor16MU destination.

	@SYMTestActions

	Compare the results over several iterations over time.

	@SYMTestExpectedResults

*/

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

		DoNormalBitBltL(ETrue, EColor64K,EColor16MU, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

	@SYMTestCaseID

	GRAPHICS-UI-BENCH-0071

	@SYMTestCaseDesc

	Test DrawBitmap with different sizes (STRETCHED) with EColor16MAP source and EColor16MAP destination.

	@SYMTestActions

	Compare the results over several iterations over time.

	@SYMTestExpectedResults

*/

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

		DoDrawBitmapL(EFalse, EColor16MAP, EColor16MAP, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

	@SYMTestCaseID

	GRAPHICS-UI-BENCH-0072

	@SYMTestCaseDesc

	Test DrawBitmap with different sizes (STRETCHED) with EColor16MA source and EColor16MA destination.

	@SYMTestActions

	Compare the results over several iterations over time.

	@SYMTestExpectedResults

*/

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

		DoDrawBitmapL(EFalse, EColor16MA, EColor16MA, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

	@SYMTestCaseID

	GRAPHICS-UI-BENCH-0073

	@SYMTestCaseDesc

	Test DrawBitmap (using alpha mask) with different sizes (STRETCHED) with EColor16MU source and EColor16MU destination.

	@SYMTestActions

	Compare the results over several iterations over time.

	@SYMTestExpectedResults

*/	

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

		DoDrawBitmapL(ETrue, EColor16MU, EColor16MU, wsSession, window, windowGc, KIterationsToTest);

		RecordTestResultL();

/**

	@SYMTestCaseID

	GRAPHICS-UI-BENCH-0057

	@SYMTestCaseDesc

	Test DrawBitmap (using alpha mask) with different sizes (STRETCHED) with EColor16MAP source and EColor16MAP destination.

	@SYMTestActions

	Compare the results over several iterations over time.

	@SYMTestExpectedResults

*/

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

		DoDrawBitmapL(ETrue, EColor16MAP, EColor16MAP, wsSession, window, windowGc, KIterationsToTest);	

		RecordTestResultL();

		}

	CleanupStack::PopAndDestroy(6, &wsSession);

	return TestStepResult();

	}

void CAlphaBlendTest::DoDrawBlendedTestsL(TBlendTestFunc aTestFunc, RWsSession& aSession, TInt aNumIterations)

	{

	TDisplayMode blendModes[]={EColor16MAP,EColor16MA,EColor16MU,EColor64K};

	const TInt KNumBlendTestModes=sizeof(blendModes)/sizeof(TDisplayMode);

	for(TInt modeIndex=0;modeIndex<KNumBlendTestModes;modeIndex++)

		{

		DoDrawBlendedTestL(aTestFunc, 0x40, blendModes[modeIndex], aSession, aNumIterations);

		DoDrawBlendedTestL(aTestFunc, 0xFF, blendModes[modeIndex], aSession, aNumIterations);

		DoDrawBlendedTestL(aTestFunc, 0, blendModes[modeIndex], aSession, aNumIterations);

		}

	}

void CAlphaBlendTest::DoDrawBlendedTestL(TBlendTestFunc aTestFunc, TInt aAlpha, TDisplayMode aDisplayMode, RWsSession& aSession, TInt aNumIterations)

	{

	SetScreenModeL(aDisplayMode);

	const TSize devSize = iScreenDevice->SizeInPixels();

	// For fair back to back tests of rotated mode we need graphics clipped to a square test area.

	// Although if we aren't going to be comparing rotated results against each other it might be better

	// to allow the tests to use the full available area.

	TSize testSize;

	testSize.iWidth=Min(devSize.iWidth,devSize.iHeight);

	testSize.iHeight=testSize.iWidth;

	TFontSpec testFontSpec; 

	if (aTestFunc==EBlendTestDrawTextAntiAliased || aTestFunc==EBlendTestDrawTextIType)

		{

		testFontSpec.iTypeface.iName=KFontTypeface;

		if (aTestFunc==EBlendTestDrawTextAntiAliased)

			{

			testFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

			}

		else

			{

			testFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

			testFontSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue);

			testFontSpec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue);

			}

		}

	testFontSpec.iHeight=12;

	// Set bold because sets more pixels, so tests blending code more

	testFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

	_LIT(KTestBlendTextString,"BLENDTESTWITHBIGSOLIDCHARACTERS0123456789HAVEWERUNOUTOFSCREENYET?OKAFEWMORECHARACTERSJUSTTOMAKESURE");

	const TInt maxTextLen=KTestBlendTextString().Length();

//

	TBool orientations[4];

	iGc->OrientationsAvailable(orientations);

// Use for loop to test across multiple rotations, however the implementation hardly varies at the moment

// so very little point in testing the differences, if in future an optimised route is added for normal

// rotation this test would be worth switching back to looping upto EGraphicsOrientationRotated270.

//

//	const TInt KMaxOrientation=CFbsBitGc::EGraphicsOrientationRotated270;

	const TInt KMaxOrientation=CFbsBitGc::EGraphicsOrientationNormal;

	for (TInt orient = CFbsBitGc::EGraphicsOrientationNormal; orient <= KMaxOrientation; orient++)

		{

		if (orientations[orient])

			{

			iGc->SetOrientation((CFbsBitGc::TGraphicsOrientation)orient);

			User::After(100000);	// Let rotate sort itself out

			iGc->Reset();

			iGc->SetClippingRect(TRect(testSize));

			iGc->SetPenStyle(CGraphicsContext::ESolidPen);

			iGc->SetBrushColor(TRgb(0x80,0x80,0xFF));

			iGc->Clear();

			iGc->SetBrushColor(TRgb(10,128,240,aAlpha));

			iGc->SetPenColor(TRgb(240,128,10,aAlpha));

			iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

			aSession.Flush();

			CFbsFont* font=NULL;

			TInt fontHeight=0;

			TInt testParam=0;

			TSize orientatedTestSize=testSize;

			TBuf <32> testName;	

			TGlyphBitmapType checkGlyphBitmapType=EDefaultGlyphBitmap;

			TGlyphBitmapType actualGlyphBitmapType=EDefaultGlyphBitmap;

			TPtrC textPtr;

			switch(aTestFunc)

				{

			case EBlendTestVerticalLine:

				_LIT(KDrawRectVerticalLine,"DrawRectVertLine");

				testName=KDrawRectVerticalLine;

				break;

			case EBlendTestDrawRect:

				_LIT(KDrawRectAlpha,"DrawRectAlpha");

				testName=KDrawRectAlpha;

				iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

				iGc->SetPenStyle(CGraphicsContext::ENullPen);

				break;

			case EBlendTestDrawTextIType:

				_LIT(KDrawTextIType,"DrawTextIT");

				testName=KDrawTextIType;

				testParam=testSize.iHeight;

				checkGlyphBitmapType=EFourColourBlendGlyphBitmap;

				goto drawTextTest;

			case EBlendTestDrawTextAntiAliased:

				_LIT(KDrawTextAA,"DrawTextAA");

				testName=KDrawTextAA;

				testParam=testSize.iHeight;

				checkGlyphBitmapType=EAntiAliasedGlyphBitmap;

				goto drawTextTest;

			case EBlendTestDrawVerticalText:

				_LIT(KDrawTextVert,"DrawTextVert");

				orientatedTestSize.SetSize(orientatedTestSize.iHeight,orientatedTestSize.iWidth);

				testName=KDrawTextVert;

				testParam=testSize.iWidth;

				checkGlyphBitmapType=EMonochromeGlyphBitmap;

				goto drawTextTest;

			case EBlendTestDrawText:

				_LIT(KDrawText,"DrawText");

				testParam=testSize.iHeight;

				testName=KDrawText;

				checkGlyphBitmapType=EMonochromeGlyphBitmap;

drawTextTest:	User::LeaveIfError(iScreenDevice->BitmapDevice().GetNearestFontInPixels((CFont* &)font,testFontSpec));

				fontHeight=font->HeightInPixels();

				iGc->UseFont(font);

				actualGlyphBitmapType=font->FontSpecInTwips().iFontStyle.BitmapType();

				TInt displayLen=Min(font->TextCount(KTestBlendTextString,orientatedTestSize.iWidth)+1,maxTextLen);

				textPtr.Set(KTestBlendTextString().Left(displayLen));

				iScreenDevice->BitmapDevice().ReleaseFont(font);

				break;

				}

			if (checkGlyphBitmapType!=EDefaultGlyphBitmap)

				{

				if (actualGlyphBitmapType!=checkGlyphBitmapType)

					{

					INFO_PRINTF3(_L("Failed to load correct glyph type font, wanted %d, got %d"),checkGlyphBitmapType, actualGlyphBitmapType);

					break;

					}

				}

			_LIT(KAppendAlphaTxt,"[A=0x%02x]");

			testName.AppendFormat(KAppendAlphaTxt,aAlpha);

			iProfiler->InitResults();	

			for(TInt iter=0; iter<aNumIterations; iter++)

				{

				switch(aTestFunc)

					{

				case EBlendTestVerticalLine:

					for(TInt xpos=0; xpos<testSize.iWidth; xpos++)

						iGc->DrawLine(TPoint(xpos,0),TPoint(xpos,testSize.iHeight));

					break;

				case EBlendTestDrawRect:

					iGc->DrawRect(TRect(testSize));

					break;

				case EBlendTestDrawText:

				case EBlendTestDrawVerticalText:

				case EBlendTestDrawTextAntiAliased:

				case EBlendTestDrawTextIType:

					{

					for(TInt pos=0;pos<testParam;pos+=fontHeight)

						{

						if (aTestFunc==EBlendTestDrawVerticalText)

							iGc->DrawTextVertical(textPtr,TPoint(pos,0),EFalse);

						else

							iGc->DrawText(textPtr,TPoint(0,pos));

						}

					break;

					}

					}

				iProfiler->MarkResultSetL();

				}

			INFO_PRINTF3(_L("%S %S"), &testName, &ColorModeName(aDisplayMode));

			iProfiler->ResultsAnalysis(testName, orient, aDisplayMode, aDisplayMode, aNumIterations);

			}

		}

	iGc->SetOrientation(CFbsBitGc::EGraphicsOrientationNormal);

	}

TBool CAlphaBlendTest::CheckMonoTypeInstalledL()

	{

	SetScreenModeL(EColor16MU);

//

	TFontSpec fontSpec;

	fontSpec.iTypeface.iName = KFontTypeface;

	fontSpec.iHeight = 20;

	fontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

	fontSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue);

	fontSpec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue);

	CFont* font;

	User::LeaveIfError(iScreenDevice->BitmapDevice().GetNearestFontToDesignHeightInPixels((CFont*&)font,fontSpec));

	TBool monoTypeInstalled=font->FontSpecInTwips().iFontStyle.BitmapType()==EFourColourBlendGlyphBitmap;

	iScreenDevice->BitmapDevice().ReleaseFont(font);

	return(monoTypeInstalled);

	}

/**

Bitblt test

@param aSrcMode is the source display mode

@param aDstMode is the destination display mode

@param aSession is the windows server session

@param aWindow is a reference to the window

@param aGc is the graphics context of the window

@param aNumIterations is the number of iterations to run the test

*/		

void CAlphaBlendTest::DoBitBltAlphaBitmapTestL(TDisplayMode aSrcMode,TDisplayMode aDstMode, RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TInt aNumIterations)

	{	

	const TSize bitmapSize = aWindow.Size();

	CFbsBitmap* bitmapTarget = CreateSoftwareBitmapLC(bitmapSize, aDstMode);

	CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmapTarget);

	CleanupStack::PushL(bitmapDevice);

	CFbsBitGc* bitmapGc = NULL;	

	User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc));	

	CleanupStack::PushL(bitmapGc);

	CFbsBitmap* source = CreateSoftwareBitmapLC(bitmapSize, aSrcMode);

	CFbsBitmap* sourceAlpha = CreateSoftwareBitmapLC(bitmapSize, EGray256);	// match size to src

	VerticalGradientAlphaL(sourceAlpha, TRgb(0x01010101), TRgb(0xfefefefe));

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

	TPoint point(0,0);

	bitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	bitmapGc->SetBrushColor(TRANSPARENT_BLACK);

	bitmapGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

	bitmapGc->Clear();

	bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

	bitmapGc->BitBlt(point, source);

	aGc->Activate(aWindow);

	aGc->BitBlt(point, bitmapTarget);

	aGc->Deactivate();

	aSession.Flush();

	iProfiler->InitResults();		

	for(TInt i=0; i<aNumIterations; i++)

	{

		bitmapGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

		bitmapGc->Clear();

		bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

		bitmapGc->BitBlt(point, source);

		iProfiler->MarkResultSetL();

	}

	iProfiler->ResultsAnalysis(_L("DoBitBltAlphaBitmapTestL"), 0, aSrcMode, aDstMode, aNumIterations);

	// copy up to screen for sanity check

	aGc->Activate(aWindow);

	aGc->BitBlt(TPoint(), bitmapTarget);

	aGc->Deactivate();

	CleanupStack::PopAndDestroy(5, bitmapTarget); //sourceAlpha, source, bitmapGc, bitmapDevice, bitmapTarget

	}

/**

Clears the window to a colour

@param aSession is the windows server session

@param aWindow is a reference to the window

@param aGc is the graphics context of the window

@param aColor is the colour to clear the window with

*/

void CAlphaBlendTest::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();

}

/**

BitBlts a bitmap to the windows GC.

@param aSession is the windows server session

@param aWindow is a reference to the window

@param aGc is the graphics context of the window

@param aImage is the bitmap to bitblt

*/		

void CAlphaBlendTest::BitBlt(RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, CFbsBitmap& aImage)

	{

	aWindow.Invalidate();

	aWindow.BeginRedraw();

	aGc->Activate(aWindow);

	aGc->BitBlt(TPoint(0,0), &aImage);

	aGc->Deactivate();

	aWindow.EndRedraw();	

	aSession.Flush();	

	}

/**

Alpha blends two bitmaps together

@param aDisplayMode1 is the source display mode

@param aDisplayMode2 is the destination display mode

@param aSession is the windows server session

@param aWindow is a reference to the window

@param aGc is the graphics context of the window

@param aNumIterations is the number of iterations to run the test

*/	

void CAlphaBlendTest::DoAlphaBlendBitmapsBitmapTestL(TDisplayMode aSrcMode, TDisplayMode aDstMode, RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TInt aNumIterations)

	{

	const TSize bitmapSize = aWindow.Size();	

	CFbsBitmap* bitmapTarget = CreateSoftwareBitmapLC(bitmapSize, aDstMode);

	CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmapTarget);

	CleanupStack::PushL(bitmapDevice);

	CFbsBitGc* bitmapGc=NULL;

	User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc));	

	CleanupStack::PushL(bitmapGc);

	CFbsBitmap* sourceUnder  = CreateSoftwareBitmapLC(bitmapSize, aDstMode);

	CFbsBitmap* sourceOver   = CreateSoftwareBitmapLC(bitmapSize, aSrcMode);

	CFbsBitmap* sourceAlpha  = CreateSoftwareBitmapLC(bitmapSize, EGray256);

	VerticalGradientAlphaL(sourceAlpha, TRgb(0x01010101), TRgb(0xfefefefe));

	VerticalGradientAlphaL(sourceUnder, TRgb(0xff000000), TRgb(0x00ffffff));

	VerticalGradientAlphaL(sourceOver, TRgb(0x00ffffff), TRgb(0xff000000));

	RDebug::Printf("DABBBT 2");

	TPoint point(0,0);

	TRect  rect(bitmapSize);

	bitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	bitmapGc->SetBrushColor(TRANSPARENT_BLACK);

	bitmapGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

	bitmapGc->Clear();

	bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

	bitmapGc->AlphaBlendBitmaps(point, sourceUnder, sourceOver, rect, point, sourceAlpha, point);		

	aGc->Activate(aWindow);

	aGc->BitBlt(point, bitmapTarget);

	aGc->Deactivate();

	aSession.Flush();

	iProfiler->InitResults();

	// blend sourceUnder with sourceOver using alpha mask

	for(TInt i=0; i<aNumIterations; i++)

	{

		bitmapGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

		bitmapGc->Clear();

		bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

		bitmapGc->AlphaBlendBitmaps(point, sourceUnder, sourceOver, rect, point, sourceAlpha, point);

		iProfiler->MarkResultSetL();

	}

	iProfiler->ResultsAnalysis(_L("DoAlphaBlendBitmapsBitmapTestL"), 0, aSrcMode, aDstMode, aNumIterations);

	// copy up to screen for sanity check

	BitBlt(aSession, aWindow, aGc, *bitmapTarget);	

	CleanupStack::PopAndDestroy(6, bitmapTarget); // sourceAlpha, sourceOver, sourceUnder, bitmapGc, bitmapDevice, bitmapTarget

	}	

/**

Draws a stretched bitmap with or without a mask.

@param aUseMask set to ETrue to use a alpha mask. Normally used for 16MU display modes that do not store the alpha.

@param aSrcMode is the source display mode

@param aDstMode is the destination display mode

@param aSession is the windows server session

@param aWindow is a reference to the window

@param aGc is the graphics context of the window

@param aNumIterations is the number of iterations to run the test

*/

void CAlphaBlendTest::DoDrawBitmapL(TBool aUseMask, TDisplayMode aSrcMode, TDisplayMode aDstMode, RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TInt aNumIterations)

	{		

	const TSize bitmapSize = aWindow.Size();

	// Construct target bitmap.

	CFbsBitmap* bitmapTarget = CreateSoftwareBitmapLC(bitmapSize, aDstMode);

	CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmapTarget);

	CleanupStack::PushL(bitmapDevice);

	// Construct GC.

	CFbsBitGc* bitmapGc = NULL;

	User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc));

	CleanupStack::PushL(bitmapGc);

	// Construct source bitmap.	

	TSize smallerSize(bitmapSize.iWidth/2,  bitmapSize.iHeight/2);

	CFbsBitmap* source = CreateSoftwareBitmapLC(smallerSize, aSrcMode);

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

	CFbsBitmap* sourceAlpha = CreateSoftwareBitmapLC(smallerSize, EGray256);	// match size to src

	VerticalGradientAlphaL(sourceAlpha, TRgb(0x01010101), TRgb(0xfefefefe));

	bitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	bitmapGc->SetBrushColor(TRANSPARENT_BLACK);

	bitmapGc->Clear();

	bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

	aGc->Activate(aWindow);

	TPoint point(0,0);

	bitmapGc->BitBlt(point, bitmapTarget);

	aGc->Deactivate();

	aSession.Flush();

	TBuf <20> testName;

	if (!aUseMask)

		{

		testName=_L("DrawBitmap");

		iProfiler->InitResults();

		for(int i=0; i<aNumIterations; i++)

			{

			bitmapGc->DrawBitmap(TRect(point, bitmapSize), source);

			iProfiler->MarkResultSetL();

			}

		}

	else

		{

		testName=_L("DrawBitmapMasked");

		iProfiler->InitResults();

		for(int i=0; i<aNumIterations; i++)

			{

			bitmapGc->DrawBitmapMasked(TRect(point, bitmapSize), source,TRect(point, smallerSize), sourceAlpha, EFalse);

			iProfiler->MarkResultSetL();

			}

		}

	INFO_PRINTF4(_L("%S(Stretched) with src = %S, dst = %S"), &testName, &ColorModeName(aSrcMode), &ColorModeName(aDstMode));

	iProfiler->ResultsAnalysis(testName, 0, aSrcMode, aDstMode, aNumIterations);

	// copy up to screen for sanity check

	BitBlt(aSession, aWindow, aGc, *bitmapTarget);

	CleanupStack::PopAndDestroy(5, bitmapTarget);

	}

/**

Performs a BitBlt with or without a mask

@param aUseMask set to ETrue to use a alpha mask. Normally used for 16MU display modes that do not store the alpha.

@param aSrcMode is the source display mode

@param aDstMode is the destination display mode

@param aSession is the windows server session

@param aWindow is a reference to the window

@param aGc is the graphics context of the window

@param aNumIterations is the number of iterations to run the test

*/

void CAlphaBlendTest::DoNormalBitBltL(TBool aUseMask, TDisplayMode aSrcMode, TDisplayMode aDstMode, RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TInt aNumIterations)

	{	

	const TSize bitmapSize = aWindow.Size();

	// Construct target bitmap

	CFbsBitmap* bitmapTarget = CreateSoftwareBitmapLC(bitmapSize, aDstMode);

	CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmapTarget);

	CleanupStack::PushL(bitmapDevice);

	// Construct GC

	CFbsBitGc* bitmapGc = NULL;	

	User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc));

	CleanupStack::PushL(bitmapGc);

	// Construct source bitmap

	CFbsBitmap* source = CreateSoftwareBitmapLC(bitmapSize, aSrcMode);

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

	CFbsBitmap* sourceAlpha = CreateSoftwareBitmapLC(bitmapSize, EGray256);	// match size to src

	VerticalGradientAlphaL(sourceAlpha, TRgb(0x01010101), TRgb(0xfefefefe));

	bitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	bitmapGc->SetBrushColor(TRANSPARENT_BLACK);

	bitmapGc->Clear();

	bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

	TPoint point(0,0);

	TRect rect(bitmapSize);

	if (aUseMask)		

		bitmapGc->AlphaBlendBitmaps(point, source, rect, sourceAlpha, point);		

	else

		bitmapGc->BitBlt(point, source);	// BitBlt source to target bitmap		

	aGc->Activate(aWindow);

	aGc->BitBlt(point, bitmapTarget);	// BitBlt bitmapTarget to screen

	aGc->Deactivate();

	aSession.Flush();	

	TBuf <20> testName;	

	if (aUseMask)

		{

		testName=_L("AlphaBlendBitmaps");

		// blend sourceUnder with sourceOver using alpha mask

		iProfiler->InitResults();		

		for(TInt i=0; i<aNumIterations; i++)

			{

			bitmapGc->Clear();

			bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

			bitmapGc->AlphaBlendBitmaps(point, source, rect, sourceAlpha, point);

			iProfiler->MarkResultSetL();

			}

		}

	else

		{

		testName=_L("Normal BitBlt");

		iProfiler->InitResults();

		for(TInt i=0; i<aNumIterations; i++)

			{

			bitmapGc->BitBlt(point, source);

			iProfiler->MarkResultSetL();

			}

		}

	INFO_PRINTF4(_L("%S with src = %S, dst = %S"), &testName, &ColorModeName(aSrcMode), &ColorModeName(aDstMode));

	iProfiler->ResultsAnalysis(testName, 0, aSrcMode, aDstMode, aNumIterations);

	// copy up to screen for sanity check

	BitBlt(aSession, aWindow, aGc, *bitmapTarget);

	CleanupStack::PopAndDestroy(5, bitmapTarget);

	}