// 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 "tbitbltmasked.h"

CTBitBltMasked::CTBitBltMasked()
	{
	SetTestStepName(KTDirectGdiBitBltMaskedStep);
	}

CTBitBltMasked::~CTBitBltMasked()
	{
	}

/**
Override of base class pure virtual
Lists the tests to be run
*/
void CTBitBltMasked::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-BITBLTMASKED-0003"));
		TestInvalidParametersL();
		RecordTestResultL();
		SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0004"));
		TestSourceBitmapCloningL();
		RecordTestResultL();
		SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0005"));
		TestMaskCloningL();
		RecordTestResultL();
		}
	do
		{
		if(!iLargeTarget)
			{
			iTestParams.iDoCompressed = ETrue;
			SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0001"));
			TestBasicL();
			RecordTestResultL();
			iTestParams.iDoCompressed = EFalse;
			SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0006"));
			TestDrawModeL();			
			RecordTestResultL();
			SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0007"));
			TestWithSameBitmapsL();
			RecordTestResultL();
			SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0008"));
			TestSetOriginL();
			RecordTestResultL();
			}
		else
			{
			SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0002"));
			TestPositioningL();
			RecordTestResultL();
			}
		}
	while(NextMaskIteration());

	if(iUseDirectGdi && !iUseSwDirectGdi)
		{
		CleanupStack::PopAndDestroy(iVgImageCache);
		}
	}

/**
@SYMTestCaseID  	
	GRAPHICS-DIRECTGDI-BITBLTMASKED-0001
	
@SYMPREQ 			
	PREQ39

@SYMREQ
	REQ9198
	REQ9204 
	REQ9195
	REQ9201 
	REQ9202 
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc	
	Bit blitting with masking basic functionality.
	
@SYMTestPriority	
	Critical
	
@SYMTestStatus 		
	Implemented
	
@SYMTestActions 	
	Test bit blitting with masking for basic and valid parameters.
	
@SYMTestExpectedResults 
	Source bitmap should be copied into target area. Basic or inverted
	masking should be considered. Valid bitmap should be created. This
	bitmap should be the same as a reference bitmap.
*/
void CTBitBltMasked::TestBasicL()
	{	
	_LIT(KTestName, "BitBltMasked-Basic"); 
	_LIT(KTestNameNegative, "BitBltMasked-Basic-NegativeMaskPosition");	
	if(!iRunningOomTests)
		{
		INFO_PRINTF1(KTestName);
		}

	ResetGc();
	CFbsBitmap* bitmap;
	CFbsBitmap* mask;
	if(iTestParams.iDoCompressed)
		{
		bitmap = iCompressedBitmap;
		mask = iCompressedMaskL8;
		}
	else
		{
		bitmap = iCheckedBoardBitmap2;
		mask = iCurrentMask1;
		}
	
	TRect bmpRect(TPoint(0, 0), bitmap->SizeInPixels());	
	if(iMaskPixelFormat == EUidPixelFormatL_1)
		{
		iGc->BitBltMasked(TPoint(20, 20), *bitmap, bmpRect, *mask, iInvertMask);
		iGc->BitBltMasked(TPoint(20, 20), *bitmap, bmpRect, *mask, ETrue);
		}
	else
		{
		iGc->BitBltMasked(TPoint(20, 20), *bitmap, bmpRect, *mask, TPoint(0, 0));
		}
	TESTNOERROR(iGc->GetError());
	if(!iTestParams.iDoCompressed)
		WriteTargetOutput(KTestName());
	
	// negative mask position
	iGc->BitBltMasked(TPoint(-35, 180), *bitmap, bmpRect, *iMask1L8, TPoint(-1, -1));
	TESTNOERROR(iGc->GetError());	
	
	// mask position greater than mask size
	iGc->BitBltMasked(TPoint(-35, 200), *bitmap, bmpRect, *iMask1L8, iMask1L8->SizeInPixels().AsPoint());
	CheckErrorsL(KErrNone, KErrArgument, (TText8*)__FILE__, __LINE__);
	
	if(!iTestParams.iDoCompressed)
		TESTNOERRORL(WriteTargetOutput(KTestNameNegative()));
	}

/**
@SYMTestCaseID  	
	GRAPHICS-DIRECTGDI-BITBLTMASKED-0002
	
@SYMPREQ 			
	PREQ39

@SYMREQ
	REQ9197
	REQ9198
	REQ9204 
	REQ9195
	REQ9201 
	REQ9202 
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc	
	Various combinations of destination positions, source position and size
 	of a bitmap are tested. Test also covers mask alignment, tiling and boundary
 	parameters.
 	
@SYMTestPriority	
	Critical
	
@SYMTestStatus 		
	Implemented
	
@SYMTestActions
	Covers the whole target bitmap starting from TPoint(-30,-30) with staggered blits of a small 8x8 bitmap. 	
	Test positioning functionality of BitBltMasked() methods. Test boundary
 	conditions, tiling and clipping to surface area.
 	
@SYMTestExpectedResults 
*/
void CTBitBltMasked::TestPositioningL()
	{	
	_LIT(KTestName, "BitBltMasked-Positioning"); 
	if(!iRunningOomTests)
		{
		INFO_PRINTF1(KTestName);
		}
	iTestParams.iDoCompressed = ETrue;
	TestPositioningBaseL(KTestName(), EBitBltMasked);
	iTestParams.iDoCompressed = EFalse;
	TestPositioningBaseL(KTestName(), EBitBltMasked);
	}

/**
@SYMTestCaseID  	
	GRAPHICS-DIRECTGDI-BITBLTMASKED-0003
	
@SYMPREQ 			
	PREQ39

@SYMREQ
	REQ9197
	REQ9198
	REQ9204 
	REQ9195
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc	
	Calling BitBltMasked() method with invalid parameters
	
@SYMTestPriority	
	Critical
	
@SYMTestStatus 		
	Implemented
	
@SYMTestActions 	
	Invalid source rect:
		- TRect(-30, -30, -10, -10);
		- TRect(bmpWidth+10, bmpHeight+10, bmpWidth+20, bmpHeight+20);
		- TRect(bmpWidth, bmpHeight, 0, 0);
		- TRect(-10, -10, -30, -30);
		- TRect(0, 0, 0, 0);
	Invalid mask (aMaskBitmap):
		- zero size mask
		- not initialized mask
	Mask position greater than mask size: aMaskPt = TPoint(mask_width, mask_height)
    Invalid source bitmap:
		- zero size bitmap
        - not initialised bitmap

@SYMTestExpectedResults 
	Function should detect invalid parameters and return. Nothing should be drawn
 	in a target area.
*/
void CTBitBltMasked::TestInvalidParametersL()
	{	
	_LIT(KTestName, "BitBltMasked-InvalidParameters"); 
	if(!iRunningOomTests)
		{
		INFO_PRINTF1(KTestName);
		}
	TestInvalidParametersBaseL(KTestName(), EBitBltMasked);
	}

/**
@SYMTestCaseID  	
	GRAPHICS-DIRECTGDI-BITBLTMASKED-0004
	
@SYMPREQ 			
	PREQ39

@SYMREQ
	REQ9197
	REQ9204 
	REQ9195
	REQ9201 
	REQ9202 
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc	
	Tests that masked bitmaps are drawn correctly if they 
	are deleted immediately after BitBltMasked() is called, but before Finish() is called.
	
@SYMTestPriority	
	Critical
	
@SYMTestStatus 		
	Implemented
	
@SYMTestActions 	
	Set valid mask parameters (see BitBltMasked-Basic).
	For test description see BitBlt-SourceBitmapCloning.
	 
@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 CTBitBltMasked::TestSourceBitmapCloningL()
	{	
	_LIT(KTestName, "BitBltMasked-SourceBitmapCloning"); 
	if(!iRunningOomTests)
		{
		INFO_PRINTF1(KTestName);
		}
	iTestParams.iDoCompressed = ETrue;
	TestSourceBitmapCloningBaseL(KTestName(), EBitBltMasked);
	iTestParams.iDoCompressed = EFalse;	
	TestSourceBitmapCloningBaseL(KTestName(), EBitBltMasked);
	}

/**
@SYMTestCaseID  	
	GRAPHICS-DIRECTGDI-BITBLTMASKED-0005
	
@SYMPREQ 			
	PREQ39

@SYMREQ
	REQ9197
	REQ9204 
	REQ9195
	REQ9201 
	REQ9202 
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc	
	Tests that masked bitmaps are drawn correctly if the mask 
	is deleted immediately after BitBltMasked() is called, but before Finish() is called.
	
@SYMTestPriority	
	Critical
	
@SYMTestStatus 		
	Implemented

@SYMTestActions 	
	1. Invoke the BitBltMasked() method with valid parameters (see BitBltMasked-Basic). 
	2. Right after returning from BitBltMasked() call, destroy the source mask (aMaskBitmap).
	3. Call the BitBltMasked() method again with the same mask parameter.
	Repeat  p. 1-3 a few times.
	
@SYMTestExpectedResults 
	Source bitmap should be copied into target area and should be correctly masked.
 	Memory leaks should not be created. Valid bitmap should be created. This bitmap
 	should be the same as a reference bitmap.
*/	
void CTBitBltMasked::TestMaskCloningL()
	{	
	_LIT(KTestName, "BitBltMasked-MaskCloning"); 
	if(!iRunningOomTests)
		{
		INFO_PRINTF1(KTestName);
		}
	iTestParams.iDoCompressed = ETrue;
	TestMaskCloningBaseL(KTestName(), EBitBltMasked);
	iTestParams.iDoCompressed = EFalse;
	TestMaskCloningBaseL(KTestName(), EBitBltMasked);
	}

/**
@SYMTestCaseID  	
	GRAPHICS-DIRECTGDI-BITBLTMASKED-0006
	
@SYMPREQ 			
	PREQ39

@SYMREQ
	REQ9198
	REQ9204 
	REQ9195
	REQ9201 
	REQ9202 
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc	
	Test correctness of bit blitting with mask in all possible draw modes.
	
@SYMTestPriority	
	Critical
	
@SYMTestStatus 		
	Implemented
	
@SYMTestActions 	
	Set valid parameters (see BitBltMasked-Basic).
	Use the semi-transparent source bitmap (iCheckedBoardWithAlphaBitmap).
	Set drawmode to EDrawModePEN and call the methods.
	Set drawmode to EDrawModeWriteAlpha and call the methods.
	
@SYMTestExpectedResults 
	Semi-transparent (for  EDrawModePEN) and opaque (for  EDrawModeWriteAlpha)
 	should be copied into rendering target. Valid bitmap should be created.
 	This bitmap should be the same as a reference bitmap.
*/
void CTBitBltMasked::TestDrawModeL()
	{
	_LIT(KTestName, "BitBltMasked-DrawMode"); 
	if(!iRunningOomTests)
		{
		INFO_PRINTF1(KTestName);
		}
	ResetGc();

	TSize bmpSize(iCheckedBoardWithAlphaBitmap->SizeInPixels());

	TInt halfHeight = (bmpSize.iHeight  >> 1);	
	TInt quarterWidth  = (bmpSize.iWidth  >> 2);
	TInt y1 = halfHeight - (bmpSize.iHeight >> 2);	
	TSize vertRectSize  (quarterWidth, 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->BitBltMasked(
			TPoint(0, 0),
			*iCheckedBoardWithAlphaBitmap,
			TRect(TPoint(0, 0), vertRectSize), 
			*iCurrentMask2, 
			TPoint(0, 0));
		}

	// Render row in center
	iGc->SetDrawMode(DirectGdi::EDrawModePEN);
	iGc->BitBltMasked(
		TPoint(0, y1), 
		*iCheckedBoardWithAlphaBitmap, 
		TRect(TPoint(0, 0), horizRectSize),
		*iCurrentMask2, 
		TPoint(0, 0));
	
	// 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->BitBltMasked(
			TPoint(bmpSize.iWidth - quarterWidth, 0),
			*iCheckedBoardWithAlphaBitmap,
			TRect(TPoint(0, 0), vertRectSize), 
			*iCurrentMask2, 
			TPoint(0, 0));
		}
	
	TESTNOERRORL(iGc->GetError());

	TESTNOERRORL(WriteTargetOutput(KTestName()));
	}

/**
@SYMTestCaseID  	
	GRAPHICS-DIRECTGDI-BITBLTMASKED-0007
	
@SYMPREQ 			
	PREQ39

@SYMREQ
	REQ9198
	REQ9204 
	REQ9195
	REQ9201 
	REQ9202 
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc	
	Test the basic functionality of bit blitting with masking.
	
@SYMTestPriority	
	Critical
	
@SYMTestStatus 		
	Implemented
	
@SYMTestActions 	
	Test bit blitting with masking for same source and mask bitmaps.
	
@SYMTestExpectedResults 
	Source bitmap should be copied into target area. Basic or inverted
 	masking should be considered. Valid bitmap should be created. This
 	bitmap should be the same as a reference bitmap.
*/
void CTBitBltMasked::TestWithSameBitmapsL()
	{	
	_LIT(KTestName, "BitBltMasked-SameBitmaps"); 
	ResetGc();
	TRect bmpRect1(TPoint(0, 0), iBlackWhiteBitmap->SizeInPixels());
	iGc->SetOrigin(TPoint(30, 30));
	iGc->BitBltMasked(TPoint(0, 0), *iBlackWhiteBitmap, bmpRect1, *iBlackWhiteBitmap, ETrue);
	iGc->BitBltMasked(TPoint(0, 0), *iBlackWhiteBitmap, bmpRect1, *iBlackWhiteBitmap, EFalse);
	TESTNOERRORL(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)
		{		
		TESTNOERRORL(WriteTargetOutput(KTestName()));
		}	
	}

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

@SYMREQ
	REQ9198
	REQ9204 
	REQ9195
	REQ9201 
	REQ9202 
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc	
	Test that BitBltMasked() performs correctly when it is called after SetOrigin().
	
@SYMTestPriority	
	Critical
	
@SYMTestStatus 		
	Implemented
	
@SYMTestActions 	
	Call SetOrigin().
	Call BitBltMasked().
	
@SYMTestExpectedResults 
	Source bitmap should be copied into target area. Basic or inverted
	masking should be considered. Valid bitmap should be created. This
	bitmap should be the same as a reference bitmap.
*/
void CTBitBltMasked::TestSetOriginL()
	{	
	_LIT(KTestName, "BitBltMasked-SetOrigin"); 
	_LIT(KTestNameNegative, "BitBltMasked-SetOrigin-NegativeMaskPosition");
	
	// 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;	
	
	TRect bmpRect(TPoint(0, 0), bitmap->SizeInPixels());
	iGc->SetOrigin(TPoint(-35, 80));
	if(iMaskPixelFormat == EUidPixelFormatL_1)
		{
		iGc->BitBltMasked(TPoint(55, -60), *bitmap, bmpRect, *mask, iInvertMask);
		iGc->BitBltMasked(TPoint(55, -60), *bitmap, bmpRect, *mask, ETrue);
		}
	else
		{
		iGc->BitBltMasked(TPoint(55, -60), *bitmap, bmpRect, *mask, TPoint(0, 0));
		}
	TESTNOERROR(iGc->GetError());	
	TESTNOERRORL(WriteTargetOutput(KTestName()));
	
	// negative mask position
	iGc->BitBltMasked(TPoint(0, 100), *bitmap, bmpRect, *iMask1L8, TPoint(-1, -1));
	TESTNOERROR(iGc->GetError());	
	
	// mask position greater than mask size
	iGc->BitBltMasked(TPoint(0, 120), *bitmap, bmpRect, *iMask1L8, iMask1L8->SizeInPixels().AsPoint());
	CheckErrorsL(KErrNone, KErrArgument, (TText8*)__FILE__, __LINE__);
		
	TESTNOERRORL(WriteTargetOutput(KTestNameNegative()));
	}