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

CTClipping::CTClipping()
	{
	SetTestStepName(KTDirectGdiClippingStep);
	}

CTClipping::~CTClipping()
	{
	}
			
/**
@SYMTestCaseID  
	GRAPHICS-DIRECTGDI-CLIPPING-0001
	
@SYMPREQ 
	PREQ39

@SYMREQ
	REQ9195
	REQ9201 
	REQ9202 
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc  
	Tests setting clipping regions.
	
@SYMTestPriority  
	High
	
@SYMTestStatus 
	Implemented
	
@SYMTestActions 
	Set the clipping region consisting of a number of rectangles. Blit a bitmap. 
	Reset the clipping region.
	
@SYMTestExpectedResults 
	Bitmap should be drawn only within the clipped regions successfully.
*/
void CTClipping::TestClippingBasicL()
	{	
	_LIT(KTestName, "Clipping-Basic"); 
	if(!iRunningOomTests)
		{
		INFO_PRINTF1(KTestName);
		}
	
	CFbsBitmap* bitmap = CreateCheckedBoardBitmapL(iTestParams.iTargetPixelFormat, TSize(150,150));
	TESTL(bitmap != NULL);
	RRegion clippingRegion(8);
	clippingRegion.AddRect(TRect(10,10,40,40)); // normal square clipping rect
	clippingRegion.AddRect(TRect(60,70,67,132));	// normal rectangular clipping rect
	clippingRegion.AddRect(TRect(50,75,110,85));	// clipping rect crosses another clipping rect
	clippingRegion.AddRect(TRect(125,125,125,125));	// clipping rect with zero size
	clippingRegion.AddRect(TRect(50,30,45,25));	// clipping rect with negative size
	
	ResetGc();
	iGc->SetClippingRegion(clippingRegion);
	TESTNOERROR(iGc->GetError());
	iGc->BitBlt(TPoint(0, 0), *bitmap);
	TESTNOERROR(iGc->GetError());
	iGc->ResetClippingRegion();
	TESTNOERROR(iGc->GetError());
	clippingRegion.Close();
	delete bitmap;
	if (iUseDirectGdi && !iUseSwDirectGdi)
		{
		iVgImageCache->ResetCache();
		}

	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(KTestName)));
	}



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

@SYMREQ
	REQ9195
	REQ9201 
	REQ9202 
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc  
	Tests the argument checking within SetClippingRegion(TRegion&).
	
@SYMTestPriority  
	High
	
@SYMTestStatus 
	Implemented  
	
@SYMTestActions 
	1. Test a region that is outside the bounds of the target.  
	2. Test a region which is partially outside the bounds of the target.
	3. Test using a region which has its error flag set.
	
@SYMTestExpectedResults 
	Test should return KErrArgument.
*/
void CTClipping::TestClippingErrors()
	{	
	_LIT(KTestName, "Clipping-Errors"); 
	if(!iRunningOomTests)
		{
		INFO_PRINTF1(KTestName);
		}
	
	RRegion outOfBoundsRegion(TRect(200,200,220,220));	// clipping rect wholly outside target area
	RRegion partOutOfBoundsRegion(TRect(80,-10,100,25));	// clipping rect partially outside target area
	TRegionFix<1> regionWithError(TRect(50,75,110,85));
	//add more rects than region can hold to set error flag
	regionWithError.AddRect(TRect(0,0,5,5));

	ResetGc();
	
	// Test whether setting clipping region returns  error when passed invalid clipping regions
	// 1: Pass region wholly outside of target.
	iGc->SetClippingRegion(outOfBoundsRegion);
	TEST(KErrArgument == iGc->GetError());
	iGc->ResetClippingRegion();
	TESTNOERROR(iGc->GetError());
	// 2: Pass region partially outside of target.
	iGc->SetClippingRegion(partOutOfBoundsRegion);
	TEST(KErrArgument == iGc->GetError());
	iGc->ResetClippingRegion();
	TESTNOERROR(iGc->GetError());
	// 3: Pass region with error flag set.
	iGc->SetClippingRegion(regionWithError);
	TEST(KErrArgument == iGc->GetError());
	iGc->ResetClippingRegion();
	TESTNOERROR(iGc->GetError());
	outOfBoundsRegion.Close();
	partOutOfBoundsRegion.Close();
	}

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

@SYMREQ
	REQ9195
	REQ9201 
	REQ9202 
	REQ9222 
	REQ9223 
	REQ9236 
	REQ9237
	
@SYMTestCaseDesc  
	Tests using clipping regions while using various APIs to draw images, using a non-zero origin.
	
@SYMTestPriority  
	High
	
@SYMTestStatus 
	Implemented
	
@SYMTestActions 
	Create a bitmap.
	Set a clipping region rectangle (50,50) from the top-left of the target.
	Set the origin to 50,50.
	Draw an image using BitBlt() at (0,0).
	Reset the clipping.
	Set a clipping region rectangle (150,50) from the top-left of the target.
	Set the origin to 150,50.
	Draw an image using DrawBitmap() at (0,0).
	Reset the clipping.
	Set a clipping region rectangle (50,150) from the top-left of the target.
	Set the origin to 50,150.
	Draw an image using BitBltMasked() at (0,0).
	Reset the clipping.
	Set a clipping region rectangle (150,150) from the top-left of the target.
	Set the origin to 150,150.
	Draw an image using DrawBitmapMasked() at (0,0).
	
@SYMTestExpectedResults 
	The first bitmap should be drawn, 50,50 from the top-left of the target. 
	The second bitmap should be drawn, 100,50 from the top-left of the target.
	The third bitmap should be drawn, 50,100 from the top-left of the target.
	The fourth bitmap should be drawn, 100,100 from the top-left of the target.
	None of them should be clipped because although it is always being drawn at (0,0), the
	drawing and the clipping should take into account the Origin offset.
*/
void CTClipping::TestClippingWithOriginL()
	{	
	_LIT(KTestName, "Clipping-WithOrigin"); 
	if(!iRunningOomTests)
		{
		INFO_PRINTF1(KTestName);
		}
	
	ResetGc();
	
	const TSize bitmapSrcSize = TSize(40,40);
	
	CFbsBitmap* bitmap = CreateCheckedBoardBitmapL(iTestParams.iTargetPixelFormat, bitmapSrcSize);
	CleanupStack::PushL(bitmap);
	CFbsBitmap* mask = CreateBlackWhiteBitmapL(iTestParams.iTargetPixelFormat, bitmapSrcSize, TSize(2,2));
	CleanupStack::PushL(mask);
	
	// Test with BitBlt().
	iGc->SetOrigin(TPoint(50,50));
	RRegion clippingRegion(1);
	clippingRegion.AddRect(TRect(TPoint(50,50), TSize(50,50)));
	iGc->SetClippingRegion(clippingRegion);
	iGc->BitBlt(TPoint(0,0), *bitmap);
	iGc->ResetClippingRegion();
	clippingRegion.Close();
	TESTNOERROR(iGc->GetError());
	
	// Test with DrawBitmap() with scaling.
	iGc->SetOrigin(TPoint(150, 50));
	clippingRegion.AddRect(TRect(TPoint(150,50), TSize(50,50)));
	iGc->SetClippingRegion(clippingRegion);
	iGc->DrawBitmap(TRect(TPoint(0,0), TSize(50,50)), *bitmap, TRect(TPoint(0,0), bitmapSrcSize));
	iGc->ResetClippingRegion();
	clippingRegion.Close();
	TESTNOERROR(iGc->GetError());
	
	// Test with BitBltMasked().
	iGc->SetOrigin(TPoint(50, 150));
	clippingRegion.AddRect(TRect(TPoint(50,150), TSize(50,50)));
	iGc->SetClippingRegion(clippingRegion);
	iGc->BitBltMasked(TPoint(0,0), *bitmap, TRect(TPoint(0,0), bitmapSrcSize), *mask, EFalse);
	iGc->ResetClippingRegion();
	clippingRegion.Close();	
	TESTNOERROR(iGc->GetError());
	
	// Test with DrawBitmapMasked().
	iGc->SetOrigin(TPoint(150, 150));
	clippingRegion.AddRect(TRect(TPoint(150,150), TSize(50,50)));
	iGc->SetClippingRegion(clippingRegion);
	iGc->DrawBitmapMasked(TRect(TPoint(0,0), TSize(50,50)), *bitmap, TRect(TPoint(0,0), bitmapSrcSize), *mask, EFalse);
	iGc->ResetClippingRegion();
	clippingRegion.Close();	
	TESTNOERROR(iGc->GetError());
	
	CleanupStack::PopAndDestroy(2, bitmap);
	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(KTestName)));
	}

/**
Override of base class virtual
@leave Gets system wide error code
@return - TVerdict code
*/
TVerdict CTClipping::doTestStepPreambleL()
	{			
	CTDirectGdiStepBase::doTestStepPreambleL();	
	return TestStepResult();
	}
	
/** 
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.
@leave Gets system wide error code
@return TVerdict code
*/	
TVerdict CTClipping::doTestStepL()
	{
	// Test for each pixel format
	for(TInt targetPixelFormatIndex = iTargetPixelFormatArray.Count() - 1; targetPixelFormatIndex >= 0 ; targetPixelFormatIndex--)
		{
		iTestParams.iTargetPixelFormat = iTargetPixelFormatArray[targetPixelFormatIndex];
		SetTargetL(iTestParams.iTargetPixelFormat);	
		RunTestsL();
		// only run OOM tests for one target pixel format to prevent duplication of tests
		if (targetPixelFormatIndex == 0)
			{
			RunOomTestsL();  //from base class
			}
		}
	CloseTMSGraphicsStep();
	return TestStepResult();
	}

/**
Override of base class pure virtual
Lists the tests to be run
*/
void CTClipping::RunTestsL()
	{
	if(iUseDirectGdi && !iUseSwDirectGdi)
		{
		// At least one clipping test uses BitBlt() or DrawBitmap().
		// 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));
		}
	SetTestStepID(_L("GRAPHICS-DIRECTGDI-CLIPPING-0001"));
	TestClippingBasicL();
	RecordTestResultL();
	SetTestStepID(_L("GRAPHICS-DIRECTGDI-CLIPPING-0002"));
	TestClippingErrors();
	RecordTestResultL();
	SetTestStepID(_L("GRAPHICS-DIRECTGDI-CLIPPING-0003"));
	TestClippingWithOriginL();
	RecordTestResultL();
	if(iUseDirectGdi && !iUseSwDirectGdi)
		{
		CleanupStack::PopAndDestroy(iVgImageCache);
		}
	}