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

CTDrawBitmapMasked::CTDrawBitmapMasked()

	{

	SetTestStepName(KTDirectGdiDrawBitmapMaskedStep);

	}

CTDrawBitmapMasked::~CTDrawBitmapMasked()

	{

	}

/**

Override of base class pure virtual

Lists the tests to be run

*/

void CTDrawBitmapMasked::RunTestsL()

	{

	if (iUseDirectGdi && !iUseSwDirectGdi)

		{

		// In the event that a test leaves after a BitBlt() or DrawBitmap() has occurred

		// the vgimage cache will need to be reset.

		// This needs to be the first item on the cleanupstack, 

		// as some tests perform pushes and pops of bitmaps.

		CleanupStack::PushL(TCleanupItem(ResetCache, iVgImageCache));

		}

	BeginMaskIteration();

	// to minimize tests call number these tests are processed only for one mask

	if(!iLargeTarget)

		{

		SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0003"));

		TestInvalidParametersL();

		RecordTestResultL();

		SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0005"));

		TestSourceBitmapCloningL();

		RecordTestResultL();

		SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0006"));

		TestMaskCloningL();

		RecordTestResultL();

		}

	do

		{

		if(!iLargeTarget)

			{

			iTestParams.iDoCompressed = ETrue;

			SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0001"));

			TestBasicL();

			RecordTestResultL();

			iTestParams.iDoCompressed = EFalse;

			SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0007"));

			TestDrawModeL();

			RecordTestResultL();

			SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0008"));

			TestWithSameBitmapsL();

			RecordTestResultL();

			SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0009"));	

			TestSetOriginL();

			RecordTestResultL();

			}

		else

			{

			SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0002"));

			TestPositioningL();

			RecordTestResultL();

			SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0004"));

			TestScalingL();

			RecordTestResultL();

			if (iMaskType == EMaskL8)

				{

				iTestParams.iDoCompressed = ETrue;

				SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0004"));

				TestScalingL();

				RecordTestResultL();

				iTestParams.iDoCompressed = EFalse;

				}

			}

		}

	while(NextMaskIteration());

	if (iUseDirectGdi && !iUseSwDirectGdi)

		{

		CleanupStack::PopAndDestroy(iVgImageCache);

		}

	}

/**

@SYMTestCaseID  	

	GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0001

@SYMPREQ 			

	PREQ39

@SYMREQ

	REQ9199 

	REQ9204 

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc	

	Bitmap drawing with masking basic functionality test.

@SYMTestPriority	

	Critical

@SYMTestStatus 		

	Implemented

@SYMTestActions 	

	Test bitmap drawing with masking for simple and valid parameters.

@SYMTestExpectedResults 

	Source bitmap should be drawn masked in the target area. Valid bitmap 

	should be created. This bitmap shall be compared to a reference bitmap.

*/

void CTDrawBitmapMasked::TestBasicL()

	{	

	_LIT(KTestName, "DrawBitmapMasked-Basic");		

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	ResetGc();

	CFbsBitmap* bitmap;

	CFbsBitmap* mask;

	if(iTestParams.iDoCompressed)

		{

		bitmap = iCompressedBitmap;

		mask = iCompressedMaskL8;

		}

	else

		{

		bitmap = iCheckedBoardBitmap2;

		mask = iCurrentMask1;

		}

	TSize bmpSize(bitmap->SizeInPixels());

	iGc->DrawBitmapMasked(TRect(TPoint(20, 20), bmpSize), *bitmap, TRect(TPoint(0, 0), bmpSize), *mask, iInvertMask);

	TESTNOERRORL(iGc->GetError());

	if(!iTestParams.iDoCompressed)

		WriteTargetOutput(KTestName());

	}

/**

@SYMTestCaseID  	

	GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0002

@SYMPREQ 			

	PREQ39

@SYMREQ

	REQ9199 

	REQ9204 

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc	

	Test regularity of bitmap with masking positioning.

@SYMTestPriority	

	Critical

@SYMTestStatus 		

	Implemented

@SYMTestActions 	

	Test positioning functionality of DrawBitmapMasked() methods.

 	Test boundary conditions and clipping to surface area.

@SYMTestExpectedResults 

*/

void CTDrawBitmapMasked::TestPositioningL()

	{	

	_LIT(KTestName, "DrawBitmapMasked-Positioning"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	iTestParams.iDoCompressed = ETrue;

	TestPositioningBaseL(KTestName(), EDrawBitmapMasked);

	iTestParams.iDoCompressed = EFalse;

	TestPositioningBaseL(KTestName(), EDrawBitmapMasked);

	}

/**

@SYMTestCaseID  	

	GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0003

@SYMPREQ 			

	PREQ39

@SYMREQ

	REQ9199 

	REQ9204 

	REQ9195

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc	

	Test functions behaviour after calling with invalid parameters.

@SYMTestPriority	

	Critical

@SYMTestStatus 		

	Implemented

@SYMTestActions 	

	Replace valid parameters with invalid ones:

		Invalid mask

			zero size mask

			not initialized mask

		see DrawBitmap-InvalidParameters for rest of invalid parameters.

@SYMTestExpectedResults 

	Function should detect invalid parameters and return. Nothing should be

 	drawn in  target area.

*/

void CTDrawBitmapMasked::TestInvalidParametersL()

	{	

	_LIT(KTestName, "DrawBitmapMasked-InvalidParameters"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	TestInvalidParametersBaseL(KTestName(), EDrawBitmapMasked);

	}

/**

@SYMTestCaseID 

	GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0004

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9199 

	REQ9204 

	REQ9195 

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Test regularity of bitmap scaling.

@SYMTestPriority	

	Critical

@SYMTestStatus 

	Implemented

@SYMTestActions 

	Test scaling down and up of a source bitmap. Test scaling down and tiling of a mask.

@SYMTestExpectedResults 

	Scaled bitmap should be drawn in a target area. Masking should be proceeded

	correctly. Valid bitmap should be created. The bitmap should be properly

	scaled. This bitmap shall be compared to a reference bitmap.

*/

void CTDrawBitmapMasked::TestScalingL()

	{

	_LIT(KTestName, "DrawBitmapMasked-Scaling"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	TInt width = iGdiTarget->SizeInPixels().iWidth;

	TInt height = iGdiTarget->SizeInPixels().iHeight;

	CFbsBitmap* bitmap1 = NULL;

	CFbsBitmap* bitmap2 = NULL;

	CFbsBitmap* mask = NULL;

	if(iTestParams.iDoCompressed)

		{

		bitmap1 = iCompressedBitmapSmall;

		bitmap2 = iCompressedBitmap;

		mask = iCompressedMaskL8;

		}

	else

		{

		bitmap1 = iCheckedBoardBitmap1;

		bitmap2 = iCheckedBoardBitmap2;

		mask = iCurrentMask1;

		}

	TInt bmp1Width = bitmap1->SizeInPixels().iWidth;

	TInt bmp1Height = bitmap1->SizeInPixels().iHeight;

	TInt bmp2Width = bitmap2->SizeInPixels().iWidth;

	TInt bmp2Height = bitmap2->SizeInPixels().iHeight;

	ResetGc();

	// small bitmap - extreme magnification

	TReal32 scale = 1.0f;

	TReal32 scaleFactor = 1.55f;

	TInt posX = 1;

	for(TInt jj=0; jj<6; jj++)

		{

		TSize size(static_cast<TInt>(bmp1Width*scale), static_cast<TInt>(bmp1Height*scale));

		TPoint pos(posX, height/4-size.iHeight/2);

		iGc->DrawBitmapMasked(TRect(pos, size), *bitmap1,

				TRect(TPoint(0, 0), TSize(bmp1Width, bmp1Height)), *mask, iInvertMask);

		posX += size.iWidth+2;

		scale *= scaleFactor;

		}

	// large bitmap - extreme minification

	scale /= scaleFactor;

	posX = 1;

	for(TInt jj=5; jj>=0; jj--)

		{

		TSize size(static_cast<TInt>(bmp1Width*scale), static_cast<TInt>(bmp1Height*scale));

		TPoint pos(posX, 3*height/4-size.iHeight/2);

		iGc->DrawBitmapMasked(TRect(pos, size), *bitmap2,

				TRect(TPoint(0, 0), bitmap2->SizeInPixels()), *mask, iInvertMask);

		posX += size.iWidth+2;

		scale /= scaleFactor;

		}

	TESTNOERRORL(iGc->GetError());

	WriteTargetOutput(KTestName());

	}

/**

@SYMTestCaseID  	

	GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0005

@SYMPREQ 			

	PREQ39

@SYMREQ

	REQ9199 

	REQ9204 

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc	

	Deleting source bitmap object after issuing draw bitmap  with masking requests.

@SYMTestPriority	

	Critical

@SYMTestStatus 		

	Implemented

@SYMTestActions 	

	1. Call method with valid parameters (see  DrawBitmapMasked-Basic). 

	2. Right after returning from method call, destroy the source bitmap.

	3. Call the method again with the same bitmap parameter.

	Repeat  p. 1-3 a few times.

@SYMTestExpectedResults 

	Source bitmap should be copied into target area. Memory leaks should not

	be created. Valid bitmap should be created. This bitmap should be the same

	as a reference bitmap.

*/

void CTDrawBitmapMasked::TestSourceBitmapCloningL()

	{	

	_LIT(KTestName, "DrawBitmapMasked-SourceBitmapCloning"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	iTestParams.iDoCompressed = ETrue;

	TestSourceBitmapCloningBaseL(KTestName(), EDrawBitmapMasked);

	iTestParams.iDoCompressed = EFalse;

	TestSourceBitmapCloningBaseL(KTestName(), EDrawBitmapMasked);

	}

/**

@SYMTestCaseID  	

	GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0006

@SYMPREQ 			

	PREQ39

@SYMREQ

	REQ9199 

	REQ9204 

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc	

	Deleting mask objects after issuing draw bitmap with masking  request.

@SYMTestPriority	

	Critical

@SYMTestStatus 		

	Implemented

@SYMTestActions 	

	1. Call DrawBitmapMasked() method with valid parameters (see DrawBitmapMasked-Basic). 

	2. Right after returning from DrawBitmapMasked() call, destroy the source mask (aMaskBitmap).

	3. Call the DrawBitmapMasked() method again with the same mask parameter.

	Repeat  p. 1-3 a few times.

@SYMTestExpectedResults 

	Source bitmap should be copied into target area based on a mask data.

	Memory leaks should not be created. Valid bitmap should be created. This bitmap

	should be the same as a reference bitmap.

*/

void CTDrawBitmapMasked::TestMaskCloningL()

	{	

	_LIT(KTestName, "DrawBitmapMasked-MaskCloning"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	iTestParams.iDoCompressed = ETrue;

	TestMaskCloningBaseL(KTestName(), EDrawBitmapMasked);

	iTestParams.iDoCompressed = EFalse;

	TestMaskCloningBaseL(KTestName(), EDrawBitmapMasked);

	}

/**

@SYMTestCaseID  	

	GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0007

@SYMPREQ 			

	PREQ39

@SYMREQ

	REQ9199 

	REQ9204 

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc	

	Test correctness of bitmap drawing with mask in all possible draw modes.

@SYMTestPriority	

	Critical

@SYMTestStatus 		

	Implemented

@SYMTestActions 	

	Set valid parameters (see DrawBitmapMasked-Basic).

	Use the semi-transparent source bitmap (aBitmap).

	Set drawmode to EDrawModeWriteAlpha and call the methods.

	Set drawmode to EDrawModePEN and call the methods.

	Set drawmode to EDrawModeWriteAlpha and call the methods.

@SYMTestExpectedResults 

	The image drawn in the center should be drawn masked and blended 

	(EDrawModePEN) and the images at the right and left should be drawn masked and 

	opaque (EDrawModeWriteAlpha). Valid bitmap should be created.

	This bitmap should be the same as a reference bitmap.

*/

void CTDrawBitmapMasked::TestDrawModeL()

	{

	_LIT(KTestName, "DrawBitmapMasked-DrawMode"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	ResetGc();

	TSize bmpSize(iCheckedBoardWithAlphaBitmap->SizeInPixels());

	TInt halfHeight = (bmpSize.iHeight  >> 1);	

	TInt quaterWidth  = (bmpSize.iWidth  >> 2);

	TInt y1 = halfHeight - (bmpSize.iHeight >> 2);	

	TSize vertRectSize  (quaterWidth, bmpSize.iHeight);

	TSize horizRectSize (bmpSize.iWidth, halfHeight);

	// EDrawModeWriteAlpha is not supported in the following modes

	// This is tested under invalid parameter tests.