// Copyright (c) 2004-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:

//

#include <hal.h>

#include <e32math.h>

#include "TAlphaBlend.h"

const TInt KWidth = 10;//Used in alpha blending tests

const TInt KHeight = 3;//Used in alpha blending tests

const TInt KMaximumAttempts = 2;	// Allow retries on some tests, due to spurious InfoPrints 

TBool iExtraLogging1=EFalse;		//Used to trigger logging at times the test fails

TBool iExtraLogging2=EFalse;		//Used to trigger logging at times the test fails

CTAlphaBlending::CTAlphaBlending(CTestStep* aStep):

	CTGraphicsBase(aStep),

	iDevice(NULL),

	iGc(NULL)

	{

	}

CTAlphaBlending::~CTAlphaBlending()

	{

	DeleteGraphicsContext();

	DeleteScreenDevice();

	}

void CTAlphaBlending::RunTestCaseL(TInt aCurTestCase)

	{

	((CTAlphaBlendingStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(aCurTestCase)

		{

	case 1:

		((CTAlphaBlendingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0024"));

		INFO_PRINTF1(_L("Alpha blending"));

		TestAlphaBlendingL();

		break;		

	case 2:

/**

@SYMTestCaseID		GRAPHICS-BITGDI-0114

*/

		((CTAlphaBlendingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0114"));

		INFO_PRINTF1(_L("Alpha blending 2"));

		TestAlphaBlending2L();

		break;

	case 3:

		((CTAlphaBlendingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0085"));

 		INFO_PRINTF1(_L("Alpha blending Correctness test 16MU 16MA"));

 		TestAlphaBlendCorrect(EColor16MU, EColor16MU);

 		break;

 	case 4:

 		((CTAlphaBlendingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0097"));

 		INFO_PRINTF1(_L("Alpha plot test"));

		TestAlphaBlendingPlotL();

		break;

	case 5:

/**

@SYMTestCaseID		GRAPHICS-BITGDI-0115

*/

		((CTAlphaBlendingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0115"));

		INFO_PRINTF1(_L("Draw bitmap blending"));

		DoDrawBitmapTestsL();

		break;

	case 6:

		//DEF118268

		((CTAlphaBlendingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0085"));

		INFO_PRINTF1(_L("Alpha blending Correctness test 16M 16MA"));

		TestAlphaBlendCorrect(EColor16M, EColor16MA);

		break;

	case 7:

		((CTAlphaBlendingStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		((CTAlphaBlendingStep*)iStep)->CloseTMSGraphicsStep();

		TestComplete();

		break;

		}

	((CTAlphaBlendingStep*)iStep)->RecordTestResultL();

	}

TInt CTAlphaBlending::CreateScreenDevice(TDisplayMode aDisplayMode, CFbsBitGc::TGraphicsOrientation aOrientation)

	{

	DeleteGraphicsContext();

	DeleteScreenDevice();

	TRAPD(err, iDevice = CFbsScreenDevice::NewL(_L("scdv"), aDisplayMode));

	if(err == KErrNotSupported)

		{

		return err;

		}

	TEST2(err, KErrNone);

	err = iDevice->CreateContext((CGraphicsContext*&)iGc);

	TEST2(err, KErrNone);

	if (!iGc->SetOrientation(aOrientation))

		{

		return(KErrNotSupported);

		}

	iGc->SetUserDisplayMode(aDisplayMode);

	iDevice->ChangeScreenDevice(NULL);

	iDevice->SetAutoUpdate(EFalse);

	return err;

	}

void CTAlphaBlending::DeleteScreenDevice()

	{

	delete iDevice;

	iDevice = NULL;

	}

void CTAlphaBlending::DeleteGraphicsContext()

	{

	delete iGc;

	iGc = NULL;

	}

// returns the pixel colour from the provided bitmap in aarrggbb format

// if pixel is outside the bitmaps limits return top left pixel

TUint32 CTAlphaBlending::GetRawPixel(CFbsBitmap* aBitmap, TPoint aPos)

	{

	TBitmapUtil bmpUtil(aBitmap);	

	TUint32 value = 0;

	ASSERT(aPos.iX>=0 && aPos.iY>=0);

	ASSERT(aPos.iX<aBitmap->SizeInPixels().iWidth && aPos.iY<aBitmap->SizeInPixels().iHeight);

	bmpUtil.Begin(aPos);

	value = bmpUtil.GetPixel();

	bmpUtil.End();

	return value;	

	}

/**

@SYMTestCaseID		GRAPHICS-BITGDI-0097

@SYMDEF             DEF113229

@SYMTestCaseDesc    CDrawThirtyTwoBppBitmapCommon::WriteRgb did not change the dest alpha value to 255 when 

					the dest alpha was >0 and <255 and the a soure pen had an alpha of 255	

@SYMTestPriority    Normal

@SYMTestStatus      Implemented

@SYMTestActions     Creates a bitmap, clears it to black (destination) 50% opaque then plots a series of points 

					with a 100% opaque pen on it. Tests the resultant alpha value.

@SYMTestExpectedResults Final alpha value should be 255

**/

void CTAlphaBlending::TestAlphaBlendingPlotL()

	{

	const TSize KRectSize(100,100);

	const TRect KTargetRect(TPoint(0,0), KRectSize);

	// create the target bitmap

	CFbsBitmap* destBmp = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(destBmp);

	User::LeaveIfError(destBmp->Create(KRectSize, EColor16MA));

	destBmp->SetSizeInTwips(KRectSize);

	// create bitmap device and graphics context

	CFbsBitmapDevice* destBmpDevice = CFbsBitmapDevice::NewL(destBmp);

	CleanupStack::PushL(destBmpDevice);

	CFbsBitGc* destGc = NULL;

	User::LeaveIfError(destBmpDevice->CreateContext(destGc));

	CleanupStack::PushL(destGc);

	destGc->SetPenStyle(CGraphicsContext::ENullPen);

	destGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	TDisplayMode screenMode = EColor16MA;

	TInt err = CreateScreenDevice(screenMode);

	if (err != KErrNone)

		{

		screenMode = EColor64K;

		err = CreateScreenDevice(screenMode);

		}

	if(err==KErrNone)

		{

		const TInt KSqrMin=45;

		const TInt KSqrMax=55;

		iGc->SetUserDisplayMode(screenMode);

		destGc->SetBrushColor(TRgb(0,0,0,127));

		destGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

		destGc->Clear(KTargetRect);

		// copy over to screen dc for anyone watching

		iGc->BitBlt(TPoint(0,0), destBmp, KTargetRect);

		iDevice->Update();

		// set the pen colour to white and plot some points

		destGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

		destGc->SetPenStyle(CGraphicsContext::ESolidPen);

		destGc->SetPenColor(TRgb(0,70,130,255));

		for( TInt y=KSqrMin;y<=KSqrMax;y++)

			{

			for( TInt x=KSqrMin;x<=KSqrMax;x++)

				{

				destGc->Plot(TPoint(x,y));

				}

			}

		// copy over to screen dc for anyone watching

		iGc->BitBlt(TPoint(0,0), destBmp, KTargetRect);

		iDevice->Update();

		TUint32 actualValue=0;

		// check the resulting values alpha values are 0xFF in the square we drew

		for( TInt y=KSqrMin;y<=KSqrMax;y++)

			{

			for( TInt x=KSqrMin;x<=KSqrMax;x++)

				{

				actualValue = GetRawPixel(destBmp, TPoint(x,y));

				if( (actualValue&0xFF000000) != 0xFF000000 )

					{

					TEST(EFalse);

					INFO_PRINTF2(_L("TestAlphaBlendingPlotL() ***FAILED*** - expected alpha value 0xFF got %d "),((actualValue&0xFF000000)>>24));

					}

				}

			}

		}

		CleanupStack::PopAndDestroy(3); //destGc,destBmpDevice,destBmp

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0024

  @SYMDEF             

  @SYMTestCaseDesc 

	System, GT0173 System Libraries, BITGDI support required for semi-transparent windows

	DEF039083 - Using BitBltMasked to do alpha-blending only works if your brush style is "null"

	DEF039409 - Wrong part of Alpha Bitmap is used when there is a clipping region 

	DEF039669 - The UserDisplayMode is not honoured during the AlphaBlendBitmap function. 

	REQ3413 Second overload of CFbsBitGc's AlphaBlendBitmaps - "Supply a second overload of 

	CFbsBitGc's AlphaBlendBitmaps function, but with one of the source bitmaps being passed 

	as a CFbsBitGc object, so that the screen can be used as a source."

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions 

  	Tests alpha blending - for all display modes, some brush styles, user display modes, 

	different positions on the screen.

	Shadow/fade mode is no more tested, because the existing BitBltMasked() and the new 

	AlphaBlendBitmaps() methods treat it a different way - see MAlphaBlend interface in

	ScreenDriver component.

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

void CTAlphaBlending::TestAlphaBlendingL()

	{

	TPoint originPt(0, 0);

	TPoint destPt(0, 0);

	TRect scrRc1(0, 0, KWidth, KHeight);

	TPoint srcPt2(0, 0);

	TPoint alphaPt(0, 0);

	//

	//If we compare CFbsBitGc::BitBltMasked() aguments with CFbsBitGc::AlphaBlending() arguments,

	//we will see that AlphaBlending() has more arguments than BitBltMasked() - 

	//srcPt2, alphaPt. To make it possible - the comparison between these two methods,

	//we have to change aAlphaPt and aSrcPt2 values accordingly with the changes of scrRc1 value.

	//

	//test 1 - the origin is moved

	originPt = TPoint(97, 33);

	DoAlphaBlendingTestsL(originPt, destPt, scrRc1, srcPt2, alphaPt);

#if !defined(__X86GCC__)	//These test take too long to run in X86GCC

	//test 2 - the origin is (0, 0)

	originPt = TPoint(0, 0);

	DoAlphaBlendingTestsL(originPt, destPt, scrRc1, srcPt2, alphaPt);

	//test 3 - scrRect1 is not (0, 0, KWidth, KHeight)

	scrRc1 = TRect(3, 1, KWidth, KHeight);

	alphaPt = TPoint(3, 1);

	DoAlphaBlendingTestsL(originPt, destPt, scrRc1, srcPt2, alphaPt);

	//test 4 - restore scrRc1 and alphaPt, move the destination point

	scrRc1 = TRect(0, 0, KWidth, KHeight);

	alphaPt = TPoint(0, 0);

	destPt = TPoint(13, 17);

	iExtraLogging1=ETrue;

	DoAlphaBlendingTestsL(originPt, destPt, scrRc1, srcPt2, alphaPt);

	iExtraLogging1=EFalse;

#endif	//__X86GCC__

	}

void CTAlphaBlending::DoDrawBitmapTestsL()

	{

	TDisplayMode modes[] = {EColor16MA, EColor16MAP, EColor16MU, EColor16M, EColor256, EColor4K, EColor64K, 

						   EGray256, EGray16, EGray4, EGray2, EColor16};

	const TInt KNumTestDisplayModes=sizeof(modes)/sizeof(modes[0]);

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

		{

		TDisplayMode screenMode=modes[modeIndex];

		if (CreateScreenDevice(screenMode)!=KErrNone)

			continue;

		DoDrawBitmapTestL(screenMode);

		}

	}

void CTAlphaBlending::DoDrawBitmapTestL(TDisplayMode aTestDisplayMode)

	{

	iGc->Reset();

	TBool alphaSupported=(aTestDisplayMode==EColor16MA || aTestDisplayMode==EColor16MAP);

	TSize screenSize=iDevice->SizeInPixels();

//

	const TInt KNumTestSrcSizes=4;

	const TSize testSrcSizes[KNumTestSrcSizes]={TSize(2,2),TSize(20,10),TSize(200,5),TSize(55,555)};

	for(TInt srcSizeIndex=0;srcSizeIndex<KNumTestSrcSizes;srcSizeIndex++)

		{

		TSize srcSize(testSrcSizes[srcSizeIndex]);

//

		CFbsBitmap* srcBmp=new(ELeave) CFbsBitmap;

		CleanupStack::PushL(srcBmp);

		User::LeaveIfError(srcBmp->Create(srcSize,aTestDisplayMode));

		CFbsBitmapDevice* srcDevice = CFbsBitmapDevice::NewL(srcBmp);

		CleanupStack::PushL(srcDevice);

		CFbsBitGc* srcGc=NULL;

		User::LeaveIfError(srcDevice->CreateContext(srcGc));

		CleanupStack::PushL(srcGc);

//

		CFbsBitmap* srcAlpha=new(ELeave) CFbsBitmap;

		CleanupStack::PushL(srcAlpha);

		User::LeaveIfError(srcAlpha->Create(srcSize,aTestDisplayMode));

		CFbsBitmapDevice* srcAlphaDevice = CFbsBitmapDevice::NewL(srcAlpha);

		CleanupStack::PushL(srcAlphaDevice);

		CFbsBitGc* srcAlphaGc=NULL;

		User::LeaveIfError(srcAlphaDevice->CreateContext(srcAlphaGc));

		CleanupStack::PushL(srcAlphaGc);

		srcAlphaGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

//

		CFbsBitmap* srcMask=new(ELeave) CFbsBitmap;

		CleanupStack::PushL(srcMask);

		User::LeaveIfError(srcMask->Create(srcSize,EGray256));

		CFbsBitmapDevice* srcMaskDevice = CFbsBitmapDevice::NewL(srcMask);

		CleanupStack::PushL(srcMaskDevice);

		CFbsBitGc* srcMaskGc=NULL;

		User::LeaveIfError(srcMaskDevice->CreateContext(srcMaskGc));

		CleanupStack::PushL(srcMaskGc);

//

		TInt maxX=srcSize.iWidth-1;

		TInt maxY=srcSize.iHeight-1;

		for(TInt yLoop=0;yLoop<srcSize.iHeight;yLoop++)

			{

			for(TInt xLoop=0;xLoop<srcSize.iWidth;xLoop++)

				{

				TPoint plotPos(xLoop,yLoop);

				TRgb pen(xLoop*255/maxX,yLoop*255/maxY,(xLoop+yLoop)*128/(maxX+maxY));

				srcGc->SetPenColor(pen);

				srcGc->Plot(plotPos);

				TInt alpha=(xLoop+yLoop)*255/(maxX+maxY);

				pen.SetAlpha(alpha);

				srcAlphaGc->SetBrushColor(pen);

				srcAlphaGc->Clear(TRect(plotPos,TSize(1,1)));

				srcMaskGc->SetPenColor(TRgb::Gray256(alpha));

				srcMaskGc->Plot(plotPos);

				}

			}

		const TInt KNumTestTargSizes=5;

		const TSize testTargSizes[KNumTestTargSizes]={TSize(0,0), TSize(20,1),TSize(30,20),TSize(200,31),TSize(55,5)};

		for(TInt targSizeIndex=0;targSizeIndex<KNumTestSrcSizes;targSizeIndex++)

			{

			TSize targSize(testTargSizes[targSizeIndex]);

			if (targSizeIndex==0)

				{

				targSize=srcSize;	// Special case with no scaling

				if (targSize.iWidth>screenSize.iWidth)

					targSize.iWidth=screenSize.iWidth;

				TInt maxHeight=screenSize.iHeight/3;

				if (targSize.iHeight>maxHeight)

					targSize.iHeight=maxHeight;

				}

//

			CFbsBitmap* targBmp=new(ELeave) CFbsBitmap;

			CleanupStack::PushL(targBmp);

			User::LeaveIfError(targBmp->Create(targSize,aTestDisplayMode));

			CFbsBitmapDevice* targBmpDevice = CFbsBitmapDevice::NewL(targBmp);

			CleanupStack::PushL(targBmpDevice);

			CFbsBitGc* targGc=NULL;

			User::LeaveIfError(targBmpDevice->CreateContext(targGc));

			CleanupStack::PushL(targGc);

//

			CFbsBitmap* targMask=new(ELeave) CFbsBitmap;

			CleanupStack::PushL(targMask);

			User::LeaveIfError(targMask->Create(targSize,EGray256));

			CFbsBitmapDevice* targMaskDevice = CFbsBitmapDevice::NewL(targMask);

			CleanupStack::PushL(targMaskDevice);

			CFbsBitGc* targMaskGc=NULL;

			User::LeaveIfError(targMaskDevice->CreateContext(targMaskGc));

			CleanupStack::PushL(targMaskGc);

//

			TPoint drawPos;

			TRect testRect1(targSize);

			iGc->Clear();

// First we pre-stretch the source and mask bitmaps into temp bitmaps

			targGc->DrawBitmap(TRect(targSize),srcBmp);

			targMaskGc->DrawBitmap(TRect(targSize),srcMask);

// Then blend them onto the screen with a call to BitBltMasked

			iGc->BitBltMasked(drawPos,targBmp,TRect(targSize),targMask,EFalse);

			drawPos.iY+=targSize.iHeight;

			TRect testRect2(drawPos,targSize);

// Next we combine the stretching and masking with one call to DrawBitmapMasked,

// this should give the same end result.

			iGc->DrawBitmapMasked(testRect2,srcBmp,TRect(srcSize),srcMask,EFalse);

			TRect testRect3;

			if (alphaSupported)

				{

// Finally if alpha blending supported we stretch and blend, again to achieve the exact same end result

// as the two previous calls. This was specificially done to catch DEF116427.

				drawPos.iY+=targSize.iHeight;

				testRect3=TRect(drawPos,targSize);

				iGc->DrawBitmap(testRect3,srcAlpha);

				}

//Use this just to check what we've put in the test bitmaps

/*

			drawPos.iY+=targSize.iHeight+1;

			iGc->BitBlt(drawPos,srcBmp);

			drawPos.iY+=srcSize.iHeight+1;

			iGc->BitBlt(drawPos,srcMask);

			drawPos.iY+=srcSize.iHeight+1;

			if (alphaSupported)

				iGc->BitBlt(drawPos,srcAlpha);

*/

		   	iDevice->Update();

			TBool ret1=iDevice->RectCompare(testRect1,*iDevice,testRect2);

		   	TBool ret2=alphaSupported?iDevice->RectCompare(testRect1,*iDevice,testRect3):ETrue;

			if (!ret1 || !ret2)

				{

				INFO_PRINTF4(_L("DrawBitmapTest, ret1=%d, ret2=%d, Screen mode=%d"),ret1,ret2,aTestDisplayMode);

				TEST(EFalse);

				}

			CleanupStack::PopAndDestroy(3,targMask);

			CleanupStack::PopAndDestroy(3,targBmp);

			}

		CleanupStack::PopAndDestroy(3,srcMask);

		CleanupStack::PopAndDestroy(3,srcAlpha);

		CleanupStack::PopAndDestroy(3,srcBmp);

		}

	}

//Tests alpha blending - for all display modes, some brush styles, user display modes, 

//different positions on the screen.

void CTAlphaBlending::DoAlphaBlendingTestsL(const TPoint& aOrigin,

										const TPoint& aDestPt, 

										const TRect& aSrcRc1, 

										const TPoint& aScrPt2,

										const TPoint& aAlphaPt)

	{

	TBuf<128> buf;

	_LIT(KLog,"Origin=(%d,%d) DestPt=(%d,%d) SrcRect=(%d,%d,%d,%d) ScrPt=(%d,%d) AlphaPt=(%d,%d)");

	buf.Format(KLog,aOrigin.iX,aOrigin.iY,aDestPt.iX,aDestPt.iY,aSrcRc1.iTl.iX,aSrcRc1.iTl.iY

						,aSrcRc1.iBr.iX,aSrcRc1.iBr.iY,aScrPt2.iX,aScrPt2.iY,aAlphaPt.iX,aAlphaPt.iY);

	INFO_PRINTF1(buf);

	TDisplayMode mode[] = {EColor16MA, EColor16MAP, EColor16MU, EColor16M, EColor256, EColor4K, EColor64K,

						   EGray256, EGray16, EGray4, EGray2, EColor16};

	CFbsBitmap* screenBmp = NULL;

	CFbsBitmap* srcBmp = NULL;

	CFbsBitmap* alphaBmp = NULL;

	CGraphicsContext::TBrushStyle brushStyle[] = {CGraphicsContext::ENullBrush, CGraphicsContext::ESolidBrush};

	for(TInt i=0;i<TInt(sizeof(mode)/sizeof(mode[0]));i++)

		{

		for(TInt orientation=0;orientation<=CFbsBitGc::EGraphicsOrientationRotated270;orientation++)

			{

			if (CreateScreenDevice(mode[i],(CFbsBitGc::TGraphicsOrientation)orientation) != KErrNone)

				{

				continue;

				}

			iExtraLogging2=(iExtraLogging1 && mode[i]==11);

	 		INFO_PRINTF3(_L("Mode=%d, Orientation=%d"), mode[i], orientation);

			CreateAlphaBlendingBitmapsLC(screenBmp, srcBmp, alphaBmp, mode[i]);

			for(TInt j=0;j<TInt(sizeof(brushStyle)/sizeof(brushStyle[0]));j++)

				{

				if(mode[i] == EGray4 && brushStyle[j] == CGraphicsContext::ESolidBrush)

					{

					//When the display mode is EGray4 - Flicker-free blitting is not enabled.

					//The screen will be filled with 0xFF color, which is not the same color used by

					//the test - 0x00. And BitBltMasked and AlphaBlendBitmaps will produce different results.

					continue;

					}

				iGc->SetOrigin(aOrigin);

				iGc->SetBrushStyle(brushStyle[j]);

				TDisplayMode userDisplayMode[] = {EColor16MA, EColor16MAP, EColor16MU, EColor16M, EColor256, 

												  EColor4K, EColor64K, EGray256, 

												  EGray16, EGray4, EGray2, EColor16};

				for(TInt l=0;l<TInt(sizeof(userDisplayMode)/sizeof(userDisplayMode[0]));l++)

					{

					iGc->SetUserDisplayMode(userDisplayMode[l]);

					TSize scrDevSize = iDevice->SizeInPixels();

					TRect clipRc[] = {TRect(0, 0, scrDevSize.iWidth, scrDevSize.iHeight),

										TRect(0, 1, scrDevSize.iWidth, scrDevSize.iHeight), // Tests Y clipping only

										TRect(5, 0, scrDevSize.iWidth, scrDevSize.iHeight), // Tests X clipping only

										TRect(5, 1, scrDevSize.iWidth, scrDevSize.iHeight),

										TRect(3, 0, 14, 23)};//14 and 23 values are not accidental! 

															 //Sometimes the method is called with aDestPt(13, 17).

					for(TInt k=0;k<TInt(sizeof(clipRc)/sizeof(clipRc[0]));k++)

						{

						if (iExtraLogging2)

							{

							_LIT(KLog,"  BrushStyle=%d UserDisplayMode=%d ClipRect=(%d,%d,%d,%d)");

			 				INFO_PRINTF7(KLog,j,l,clipRc[k].iTl.iX,clipRc[k].iTl.iY,clipRc[k].iBr.iX,clipRc[k].iBr.iY);

							}

						iGc->Clear();

						iGc->SetClippingRect(clipRc[k]);

						DoAlphaBlendingTestL(screenBmp, srcBmp, alphaBmp, aDestPt, aSrcRc1, aScrPt2, aAlphaPt);

						iGc->CancelClippingRect();

						}

					}//end of - for(TInt l=0;l<TInt(sizeof(userDisplayMode)/sizeof(userDisplayMode[0]));l++)

				iGc->SetOrientation(CFbsBitGc::EGraphicsOrientationNormal);

				}

			DestroyAlphaBlendingBitmaps(screenBmp, srcBmp, alphaBmp);

			}//end of - for(TInt j=0;j<TInt(sizeof(brushStyle)/sizeof(brushStyle[0]));j++)

		}//end of - for(TInt i=0;i<TInt(sizeof(mode)/sizeof(mode[0]));i++)

	}

//The method compares results of two alpha blending methods:

//iGc->BitBltMasked() and iGc->AlphaBlendBitmaps().

//To make that possible, aScreenBmp is copied to the screen before the call of

//iGc->BitBltMasked().