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

const TDisplayMode KDisplayMode[] = {EColor16MAP, EColor16MA, EColor16MU, EColor16M, EColor64K, 

						   EColor4K, EColor256, EColor16, EGray256, EGray16, EGray4, EGray2};

// The only display modes supported by the example rasterizer are EGray256, EColor64K,

// EColor16MU and EColor16MAP, these tests will fail if KBitmapMode is changed to a

// display mode that is not one of these modes.

const TDisplayMode KBitmapMode = EColor16MAP;

const TSize KBitmapSize(640,240);

const TInt KNumColors = 3;

const TRgb KColors[KNumColors] = {TRgb(0,255,255), TRgb(255,0,255), TRgb(255,255,0)};

const TUid KUidExampleExtendedBitmap = {0x10285A78};

//----------------------------------------------------------------------------

// Positive Extended Bitmap Tests

//----------------------------------------------------------------------------

CTExtendedBitmap::CTExtendedBitmap(CTestStep* aStep) :

	CTGraphicsBase(aStep)

	{

	}

void CTExtendedBitmap::ConstructL()

	{

#ifdef USE_SCREEN_DEVICE

	// Create a screen device

	TInt ii = 0;

	TInt err = KErrNotSupported;

	for(;(ii<TInt(sizeof(KDisplayMode)/sizeof(KDisplayMode[0]))) && (err == KErrNotSupported);++ii)

		{

		TRAP(err, iDevice = CFbsScreenDevice::NewL(_L("scdv"),KDisplayMode[ii]));

		}

	if (err != KErrNone)

		{

		_LIT(KLog,"Failed to create screen device %S return value %d");

		INFO_PRINTF3(KLog,&ColorModeName(KDisplayMode[ii]),err);

		User::Leave(err);

		}

	else

		{

		_LIT(KLog,"Created Screen Device with mode %S");

		INFO_PRINTF2(KLog,&ColorModeName(KDisplayMode[ii]));

		}

	static_cast<CFbsScreenDevice*>(iDevice)->SetAutoUpdate(ETrue);

#else

	// Create a standard bitmap, bitmap device

	iBitmap = new(ELeave) CFbsBitmap;

	User::LeaveIfError(iBitmap->Create(KBitmapSize, KBitmapMode));

	iDevice = CFbsBitmapDevice::NewL(iBitmap);

#endif

	INFO_PRINTF2(_L("Testing CFbsBitGc with an extended bitmap, display mode %d"), KBitmapMode);

	// Create a graphics context from chosen device

	User::LeaveIfError(iDevice->CreateContext(iBitGc));

	// Check to see if the example rasterizer is available

	CTExtendedBitmapGc::TDrawMode drawMode = CTExtendedBitmapGc::EDrawFlag;

	if (CFbsBitmap::Rasterizer() == NULL)

		drawMode = CTExtendedBitmapGc::EDrawWhite;

	switch (drawMode)

		{

		case CTExtendedBitmapGc::EDrawFlag:

			INFO_PRINTF1(_L("Testing WITH the example rasterizer - Rasterizer Available"));

			break;

		case CTExtendedBitmapGc::EDrawWhite:

			INFO_PRINTF1(_L("Testing WITHOUT the example rasterizer - Rasterizer NOT Available"));

			break;

		default:

			ERR_PRINTF1(_L("Unknown draw mode"));

			break;

		}				

	iExtendedBitmapGcTests = CTExtendedBitmapGc::NewL(this, *iBitGc, drawMode, KBitmapMode);

	}

CTExtendedBitmap::~CTExtendedBitmap()

	{

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

	delete iExtendedBitmapGcTests;

	delete iBitGc;

	delete iDevice;

#ifndef USE_SCREEN_DEVICE

	delete iBitmap;

#endif

	}

/**

@SYMTestCaseID

	GRAPHICS-BITGDI-0103

@SYMTestCaseDesc

	Test extended bitmaps are drawn correctly to an offscreen bitmap using CFbsBitGc.

	Test that shapes are filled correctly when an extended bitmap is set as the brush pattern 

	using CFbsBitGc::UseBrushPattern().

@SYMPREQ 

	PREQ2096

@SYMREQ

	REQ10847

	REQ10857

	REQ10859

@SYMTestPriority  

	High

@SYMTestStatus 

	Implemented

@SYMTestActions

	Create an extended bitmap with extended data to generate a flag pattern when rendered,

	if the example rasterizer is available.	

	Create a matching standard bitmap.

	Draw the extended bitmap on the left of the screen and the standard bitmap on the right, 

	using each of the following CFbsBitGc APIs.

	This is done with both vertical and horizonatal flag orientations,

	and with and without an active region of interest:	 	

		- BitBlt() (one version tested as both versions call through to DoBitBlt())

		- BitBltMasked()

		- DrawBitmap() (one version tested as both versions call through to DoDrawBitmap())

		- DrawBitmapMasked()

		- UseBrushPattern()

		- AlphaBlendBitmaps(const TPoint& aDestPt, const CFbsBitmap* aSrcBmp1, const CFbsBitmap* aSrcBmp2, const TRect& aSrcRect1, const TPoint& aSrcPt2, 

				const CFbsBitmap* aAlphaBmp, const TPoint& aAlphaPt);

		- AlphaBlendBitmaps(const TPoint& aDestPt, const CFbsBitmap* aSrcBmp, const TRect& aSrcRect, const CFbsBitmap* aAlphaBmp, const TPoint& aAlphaPt);

	To test that shapes are filled correctly using an extended bitmap, an extended bitmap that would generate 

	a flag pattern if the example rasterizer is available, and a matching standard bitmap are in turn set as 

	the brush pattern using CFbsBitGc::UseBrushPattern(). Each of the following APIs are used to draw a shape,

	using the extended bitmap as a brush on the left, and the standard bitmap on the right. Calling each

	of these APIs is necessary as each one contains code specific to extended bitmaps.

		- DrawPie()

		- DrawRoundRect()

		- DrawPolygon() (2 versions)

		- DrawEllipse()

		- DrawRect()

		- DrawText()

		- DrawTextVertical()

	Note that the test cases are actually run from a separate test DLL that is built as part of the FbServ

	tests (textendedbitmapgc.dll). This DLL allows the same extended bitmap tests to be run using different graphics

	contexts. 

@SYMTestExpectedResults

	When the rasterizer is available both sides of the test screen should show a horizontally/vertically striped rectangle for every 

	test case, when the rasterizer is not present both sides of the test screen should show a white rectangle for each test case.

	The left and right side of the test should always match exactly for each test case, i.e. what is drawn using an

	extended bitmap on the left of the screen should match what is drawn using a corresponding standard bitmap on the right of

	the screen.

*/

void CTExtendedBitmap::RunTestCaseL(TInt aCurTestCase)

	{

	((CTExtendedBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0103"));

	iExtendedBitmapGcTests->RunTestCaseL(aCurTestCase);

	// Compare the two sides of the screen, they should match exactly

	TSize scrSize = iDevice->SizeInPixels();

	TEST(iDevice->RectCompare(TRect(0,0,scrSize.iWidth>>1,scrSize.iHeight), *iDevice, TRect(scrSize.iWidth>>1,0,scrSize.iWidth,scrSize.iHeight)));

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

	}

CTestExecuteLogger& CTExtendedBitmap::Logger()

	{

	return CTGraphicsBase::Logger();

	}

void CTExtendedBitmap::TestTrue(TBool aCondition)

	{

	TEST(aCondition);

	}

void CTExtendedBitmap::TestComplete()

	{

	CTGraphicsBase::TestComplete();

	}

__CONSTRUCT_STEP__(ExtendedBitmap)

//----------------------------------------------------------------------------

// Negative Extended Bitmap Tests

//----------------------------------------------------------------------------

CTExtendedBitmapNegative::CTExtendedBitmapNegative(CTestStep* aStep) :

	CTGraphicsBase(aStep)

	{

	}

void CTExtendedBitmapNegative::RunTestCaseL(TInt aCurTestCase)

	{	

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

	switch(aCurTestCase)

		{	

	case 1:

		((CTExtendedBitmapNegativeStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0104"));

		TestCFbsBitmapDeviceNewLLeavesL();

		break;

	default:

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

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

		TestComplete();

		break;	

		}	

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

	}

/**

@SYMTestCaseID

	GRAPHICS-BITGDI-0104

@SYMTestCaseDesc

	Test that passing an extended bitmap to CFbsBitmapDevice::NewL() leaves with error KErrAccessDenied.

@SYMPREQ 

	PREQ2096

@SYMREQ

	REQ10847

	REQ10856	

@SYMTestPriority  

	High

@SYMTestStatus 

	Implemented

@SYMTestActions

	Create an extended bitmap using test data and test Uid.

	Call CFbsBitmapDevice::NewL() with the extended bitmap as the parameter.

@SYMTestExpectedResults

	CFbsBitmapDevice::NewL() leaves with error KErrAccessDenied.

*/

void CTExtendedBitmapNegative::TestCFbsBitmapDeviceNewLLeavesL()

	{

	INFO_PRINTF1(_L("Test that CFbsBitmapDevice leaves with KErrAccessDenied when created with an extended bitmap"));			

	TInt dataSize = sizeof(KColors)+sizeof(TUint8); // estimate the data size

	TUint8* data = new(ELeave) TUint8[dataSize];

	CleanupStack::PushL(data);	

	// Write the colours to be used in the extended bitmap to the data	

	CTExtendedBitmapGc::WriteExtendedBitmapInfoL(data, dataSize, KColors, CTExtendedBitmapGc::EHorizontalStripe);

	CFbsBitmap* bmp = new(ELeave) CFbsBitmap;

	CleanupStack::PushL(bmp);

	TInt err = bmp->CreateExtendedBitmap(TSize(10,10), KBitmapMode, KUidExampleExtendedBitmap, data, dataSize);

	TEST(err == KErrNone);

	// CFbsBitmapDevice::NewL() should leave with KErrAccessDenied

	CFbsBitmapDevice* bmpDevice1 = NULL;

	TRAPD(error, bmpDevice1 = CFbsBitmapDevice::NewL(bmp));	

	TEST(error == KErrAccessDenied);	

	delete bmpDevice1;

	CleanupStack::PopAndDestroy(2, data);

	}

__CONSTRUCT_STEP__(ExtendedBitmapNegative)