// 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.
	if (!((iMaskPixelFormat == EUidPixelFormatL_8) && 
		  ((iTestParams.iSourcePixelFormat == EUidPixelFormatARGB_8888) ||
		   (iTestParams.iSourcePixelFormat == EUidPixelFormatARGB_8888_PRE))))
		{
		// Render column to left
		iGc->SetDrawMode(DirectGdi::EDrawModeWriteAlpha);
		iGc->DrawBitmapMasked(
			TRect (TPoint(0, 0), vertRectSize), 
			*iCheckedBoardWithAlphaBitmap, 
			TRect(TPoint(0, 0), vertRectSize), *iCurrentMask2, iInvertMask);
		}
	
	// Render row in center
	iGc->SetDrawMode(DirectGdi::EDrawModePEN);
	iGc->DrawBitmapMasked(
		TRect (TPoint(0, y1), horizRectSize),
		*iCheckedBoardWithAlphaBitmap,
		TRect(TPoint(0, 0), horizRectSize), *iCurrentMask2, iInvertMask);

	// EDrawModeWriteAlpha is not supported in the following modes
	// This is tested under invalid parameter tests.
	if (!((iMaskPixelFormat == EUidPixelFormatL_8) && 
		  ((iTestParams.iSourcePixelFormat == EUidPixelFormatARGB_8888) ||
		   (iTestParams.iSourcePixelFormat == EUidPixelFormatARGB_8888_PRE))))
		{
		// Render column to right
		iGc->SetDrawMode(DirectGdi::EDrawModeWriteAlpha);
		iGc->DrawBitmapMasked(
			TRect (TPoint(bmpSize.iWidth - quaterWidth, 0), vertRectSize), 
			*iCheckedBoardWithAlphaBitmap, 
			TRect(TPoint(0, 0), vertRectSize), *iCurrentMask2, iInvertMask);
		}
	
	TESTNOERRORL(iGc->GetError());
	WriteTargetOutput(KTestName());
	}

/**
@SYMTestCaseID  	
	GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0008
	
@SYMPREQ 			
	PREQ39

@SYMREQ
	REQ9199 
	REQ9204 
	REQ9195
	REQ9201 
	REQ9202 
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc	
	Test the basic functionality of bit blitting with masking.
	
@SYMTestPriority	
	Critical
	
@SYMTestStatus 		
	Implemented
	
@SYMTestActions 	
	Test bitmap drawing with masking for same source and mask bitmaps.
	
@SYMTestExpectedResults 
	Source bitmap should be copied into target area. A mask should be
	considered during coping. Valid bitmap should be created. This bitmap
	shall be compared to a reference bitmap.
*/
void CTDrawBitmapMasked::TestWithSameBitmapsL()
	{	
	_LIT(KTestName, "DrawBitmapMasked-SameBitmaps"); 
	ResetGc();
	TSize bmpSize1(iBlackWhiteBitmap->SizeInPixels());
	iGc->DrawBitmapMasked(TRect(TPoint(0, 0), bmpSize1), *iBlackWhiteBitmap, TRect(TPoint(0, 0), bmpSize1), *iBlackWhiteBitmap, ETrue);
	iGc->DrawBitmapMasked(TRect(TPoint(0, 0), bmpSize1), *iBlackWhiteBitmap, TRect(TPoint(0, 0), bmpSize1), *iBlackWhiteBitmap, EFalse);
	TESTNOERROR(iGc->GetError());
	//Write target only if image is not empty. BitGDI is producing white images when Mask pixel format is EUidPixelFormatL_8 
	TBool pass = TestTargetL(KRgbWhite);
	if(!pass)
		{		
		WriteTargetOutput(KTestName());
		}	
	}

/**
@SYMTestCaseID  	
	GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0009
	
@SYMPREQ 			
	PREQ39

@SYMREQ
	REQ9199 
	REQ9204 
	REQ9195
	REQ9201 
	REQ9202 
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc	
	Test that DrawBitmapMasked() performs correctly if it is called after SetOrigin().
	
@SYMTestPriority	
	Critical
	
@SYMTestStatus 		
	Implemented
	
@SYMTestActions 	
	Call SetOrigin().
	Call DrawBitmapMasked().
	
@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::TestSetOriginL()
	{	
	_LIT(KTestName, "DrawBitmapMasked-SetOrigin");
	
	// Only do test for one pixel format to cut down on the number of images produced
	// as this is just a positional test and we don't need to test for all pixel formats.
	if (!((iTestParams.iTargetPixelFormat == EUidPixelFormatRGB_565) && (iTestParams.iSourcePixelFormat == EUidPixelFormatRGB_565)))
		{
		return;
		}
	
	if(!iRunningOomTests)
		{
		INFO_PRINTF1(KTestName);
		}
	
	ResetGc();

	CFbsBitmap* bitmap = iCheckedBoardBitmap2;
	CFbsBitmap* mask = iCurrentMask1;		
	TSize bmpSize(bitmap->SizeInPixels());

	iGc->SetOrigin(TPoint(-35, 80));
	iGc->DrawBitmapMasked(TRect(TPoint(55, -60), bmpSize), *bitmap, TRect(TPoint(0, 0), bmpSize), *mask, iInvertMask);

	TESTNOERRORL(iGc->GetError());	
	WriteTargetOutput(KTestName());
	}