// 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)