// Copyright (c) 2004-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:

// This test application is used to test how the scaling works with CFbsBitGc drawing methods.

// TDrawComposite template class is used for the testing. When instantiated, it expects two

// template arguments - TDrawFunctor and TDrawParam:

// 1. TDrawFunctor class. It represents the "functor/function object" pattern and 

// must implement  "void operator()(CFbsBitGc* aGraphicsContext, TDrawParam* aPrm)" method.

// 2. TDrawParam class. This is a template argument for 

// "void TDrawFunctor::operator()(CFbsBitGc* aGraphicsContext, TDrawParam* aPrm)" method.

// If the overloaded "()" operator does not need a parameter, TEmpty class can be used as 

// a template parameter.

// When you instantiate TDrawComposite template class and call TDrawComposite::Draw() method,

// it will perform all pre- and post- drawing steps, calling 

// "void TDrawFunctor::operator()(CFbsBitGc* aGraphicsContext, TDrawParam* aPrm)" 

// at the right time.

// If you want to do the test step by step, set "aCallGetch" parameter of TDrawComposite's

// constructor to ETrue, when using it.

// 

//

#include <hal.h>

#include "TBitgdiScaling.h"

//

//Constants

//

//X and Y scaling factors.

const TInt KScalingFactorX = 3;

const TInt KScalingFactorY = 2;

//Test bitmap

_LIT(KTestBmp, "z:\\system\\data\\BmCTest.mbm");

//This clas might be used as a TDrawParam template parameter

class TEmpty

	{

	};

//This clas is used for testing CFbsBitGc drawing methods against the new scaling functionality.

template <class TDrawFunctor, class TDrawParam> class TDrawComposite

	{

public:

	TDrawComposite(const TPoint& aOrigin, TDrawFunctor& aFunctor, 

				   TDrawParam* aDrawParam, TBool aCallGetch = EFalse) :

		iOrigin(aOrigin),

		iFunctor(aFunctor),

		iPrm(aDrawParam),

		iCallGetch(aCallGetch)

		{

		}

	void Draw(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext, CTGraphicsBase* aTest)

		{

		__ASSERT_DEBUG(aScreenDevice, User::Invariant());

		__ASSERT_DEBUG(aGraphicsContext, User::Invariant());

		PreDrawStep(aScreenDevice, aGraphicsContext);

		iFunctor(aGraphicsContext, iPrm);

		TInt err = aScreenDevice->SetScalingFactor(iOrigin, KScalingFactorX, KScalingFactorY, 1, 1);

		aTest -> TEST2(err, KErrNone);

		aGraphicsContext->Activate(aScreenDevice);

		iFunctor(aGraphicsContext, iPrm);

		PostDrawStep(aScreenDevice, aGraphicsContext);

		err = aScreenDevice->SetScalingFactor(TPoint (0, 0), 1, 1, 1, 1);

		aTest -> TEST2(err, KErrNone);

		aGraphicsContext->Activate(aScreenDevice);

		}

private:

	void PreDrawStep(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

		{

		aGraphicsContext->Clear();

		TSize screenSize = aScreenDevice->SizeInPixels();

		TRect rc(iOrigin.iX, iOrigin.iY, screenSize.iWidth - 1, screenSize.iHeight - 1);

		aGraphicsContext->DrawRect(rc);

		aScreenDevice->Update();

		}

	void PostDrawStep(CFbsScreenDevice* aScreenDevice, CFbsBitGc*)

		{

		aScreenDevice->Update();

		}

private:

	TPoint iOrigin;

	TDrawFunctor& iFunctor;

	TDrawParam* iPrm;

	TBool iCallGetch;

	};

//

//TDrawTextFunctor class is used for CFbsBitGc text drawing/scaling tests

class TDrawTextFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, CFont* aFont)

		{

		__ASSERT_DEBUG(aFont, User::Invariant());

		_LIT(KTestText, "ABCDEFGH-0123456789");

		_LIT(KTestText2, "ijklmnopqrst");

		TPoint textPos = TPoint(0, aFont->AscentInPixels());

		TPoint textPos2 = TPoint(3, aFont->AscentInPixels() + 3);

		TInt text2Width = aFont->TextWidthInPixels(KTestText2);

		TPoint textPos3 = TPoint(aFont->HeightInPixels() * 3, aFont->AscentInPixels() + text2Width + 3);

		aGraphicsContext->DrawText(KTestText, textPos);

		aGraphicsContext->DrawTextVertical(KTestText2, textPos2, EFalse);

		aGraphicsContext->DrawTextVertical(KTestText2, textPos3, ETrue);

		}

	};

//

//TDrawBitmapFunctor class is used for CFbsBitGc bitmap (DrawBitmap) drawing/scaling tests

class TDrawBitmapFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, CFbsBitmap* aBitmap)

		{

		__ASSERT_DEBUG(aBitmap, User::Invariant());

		TSize size = aBitmap->SizeInPixels();

		aGraphicsContext->DrawBitmap(TRect(2, 2, size.iWidth + 2, size.iHeight + 2), aBitmap);

		}

	};

//

//TBitBltMaskedFunctor class is used for CFbsBitGc::BitBltMasked drawing/scaling tests

struct TMaskedBitmapPrm

	{

	CFbsBitmap* iBitmap;

	CFbsBitmap* iMaskBitmap;

	};

class TBitBltMaskedFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, TMaskedBitmapPrm* aPrm)

		{

		__ASSERT_DEBUG(aPrm, User::Invariant());

		TSize size = aPrm->iBitmap->SizeInPixels();

		TPoint pt(2, 2);

		TPoint pt2(pt.iX + size.iWidth + 10, pt.iY);

		TRect rc(pt, size);

		aGraphicsContext->BitBlt(pt, aPrm->iBitmap);

		aGraphicsContext->BitBltMasked(pt2, aPrm->iBitmap, rc, aPrm->iMaskBitmap, EFalse);

		}

	};

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

CTBitgdiScaling::CTBitgdiScaling(CTestStep* aStep) :

	CTGraphicsBase(aStep)

	{

	}

CTBitgdiScaling::~CTBitgdiScaling()

	{

	delete iScreenDevice;

	delete iGraphicsContext;

	delete iScreenDevice2;

	delete iGraphicsContext2;

	}

void CTBitgdiScaling::ConstructL()

	{

#if defined __WINS__ || defined __WINSCW__

 	ChangeScreenDeviceL();

#endif//defined __WINS__ || defined __WINSCW__

	TDisplayMode theDisplayMode = (static_cast<CTBitgdiScalingStep*>(iStep))->DisplayMode();

	_LIT(KLog,"Screen Display Mode %S");

	INFO_PRINTF2(KLog,&ColorModeName(theDisplayMode));

	TInt err = CreateScreenDeviceAndContextL(theDisplayMode, iScreenDevice, iGraphicsContext);

	TEST(err == KErrNone);

	err = CreateScreenDeviceAndContextL(theDisplayMode, iScreenDevice2, iGraphicsContext2);

	TSize size = iScreenDevice->SizeInPixels();

	_LIT(KSize,"[%d,%d] screen pixels");

	INFO_PRINTF3(KSize, size.iWidth, size.iHeight);

	TEST(err == KErrNone);

	}

void CTBitgdiScaling::RunTestCaseL(TInt aCurTestCase)

	{

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

	switch(aCurTestCase)

		{

	case 1:

		((CTBitgdiScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0032"));

		FontScalingL(iScreenDevice, iGraphicsContext);

		break;

	case 2:

		((CTBitgdiScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0033"));

		BitmapScalingL(iScreenDevice, iGraphicsContext);

		break;

	case 3:

		((CTBitgdiScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0034"));

		BitBltMaskedScalingL(iScreenDevice, iGraphicsContext);

		break;

	case 4:

		((CTBitgdiScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0035"));

		DrawingScalingL(iScreenDevice, iGraphicsContext);

		break;

	case 5:

		((CTBitgdiScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0036"));

		MapColors(iScreenDevice, iGraphicsContext);

		break;

	case 6:

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0117

*/

		((CTBitgdiScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0117"));

		BitmapScalingL(iScreenDevice, iGraphicsContext, iScreenDevice2, iGraphicsContext2);

		break;

	case 7:

		((CTBitgdiScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0037"));

		RunTests2L();

		return;

	case 8:

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

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

		TestComplete();

		break;

		}

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

	}

//This function creates screen device and graphics context objects and pushesh them on the

//cleanup stack.

TInt CTBitgdiScaling::CreateScreenDeviceAndContextL(TDisplayMode aDisplayMode,

									CFbsScreenDevice*& aScreenDevice,

									CFbsBitGc*& aGraphicsContext)

	{

	__ASSERT_DEBUG(!aScreenDevice, User::Invariant());

	__ASSERT_DEBUG(!aGraphicsContext, User::Invariant());

	TRAPD(err, aScreenDevice = CFbsScreenDevice::NewL(KNullDesC, aDisplayMode));

	if (err!=KErrNone)

		{

		_LIT(KLog,"Failed to create screen device for mode %S  err=%d");

		INFO_PRINTF3(KLog,&ColorModeName(aDisplayMode),err);

		}

	if(err == KErrNotSupported)

		{

		return err;

		}

	TEST(err == KErrNone);

	err = aScreenDevice->CreateContext((CGraphicsContext*&)aGraphicsContext);

	if (err!=KErrNone)

		{

		_LIT(KLog,"Failed to create screen graphics context  mode %S  err=%d");

		INFO_PRINTF3(KLog,&ColorModeName(aDisplayMode),err);

		}

	TEST(err == KErrNone);

	aGraphicsContext->SetUserDisplayMode(aDisplayMode);

	aScreenDevice->ChangeScreenDevice(NULL);

	aScreenDevice->SetAutoUpdate(EFalse);

	return err;

	}

#if defined __WINS__ || defined __WINSCW__

//This test function might be used to debug ChangeScreenDevice() call.

void CTBitgdiScaling::ChangeScreenDeviceL()

	{

	CFbsScreenDevice* screenDevice1=NULL;

	TInt leaveErr=KErrNone;;

	TInt depth1= EColor256;

	// Try to get a colour screendevice

	for (;depth1<EColorLast && !screenDevice1;depth1++)

		{

		TRAP(leaveErr,screenDevice1 = CFbsScreenDevice::NewL(KNullDesC, TDisplayMode(depth1)));

		}

	if (leaveErr != KErrNone || !screenDevice1)

		{

		// Try to get a greyscale screendevice as failed to get a colour one

		for (depth1=ENone;depth1<EColor256 && !screenDevice1;depth1++)

			{

			TRAP(leaveErr,screenDevice1 = CFbsScreenDevice::NewL(KNullDesC, TDisplayMode(depth1)));

			}

		if (leaveErr != KErrNone || !screenDevice1)

			{

			INFO_PRINTF1(_L("Failed to create any screen devices. Re-leaving"));

			User::Leave(leaveErr);

			}

		}

	CleanupStack::PushL(screenDevice1);

	CFbsBitGc* graphicsContext1 = NULL;

	User::LeaveIfError(screenDevice1->CreateContext(graphicsContext1));

	CleanupStack::PushL(graphicsContext1);

	graphicsContext1->SetUserDisplayMode(EColor256);

	screenDevice1->ChangeScreenDevice(NULL);

	screenDevice1->SetAutoUpdate(EFalse);

	TInt err = screenDevice1->SetScalingFactor(TPoint(440, 40), 1, 1, 1, 1);

	TEST(err == KErrNone);

	graphicsContext1->Activate(screenDevice1);

	TRect rect1;

	screenDevice1->GetDrawRect(rect1);

	CFbsScreenDevice* screenDevice2 = NULL;

	for (TInt depth2=ENone;depth2<EColorLast && ! screenDevice1;depth2++)

		if (depth2!=depth1)

			{

			TRAP(leaveErr,screenDevice2 = CFbsScreenDevice::NewL(KNullDesC, TDisplayMode(depth2)))

			}

	if (leaveErr != KErrNone || !screenDevice2)

		{

			INFO_PRINTF1(_L("Failed to create a different screen device - test skipped"));

		}

	else

		{

		CleanupStack::PushL(screenDevice2);

		TRect rect2;

		screenDevice2->GetDrawRect(rect2);

		screenDevice1->ChangeScreenDevice(screenDevice2);

		graphicsContext1->Activate(screenDevice1);

		screenDevice1->GetDrawRect(rect1);

		TEST(rect1 == rect2);

		TRegionFix<1> area(rect2);

		graphicsContext1->SetClippingRegion(&area);

		::CleanupStack::PopAndDestroy(screenDevice2);

		}

	::CleanupStack::PopAndDestroy(2);//screenDevice1 and graphicsContext1

	}

#endif//defined __WINS__ || defined __WINSCW__

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0032

  @SYMDEF             

  @SYMTestCaseDesc FontScalingL function is used for CFbsBitGc text drawing/scaling tests

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Tests the drawing of some text to screen in specified height

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

//

void CTBitgdiScaling::FontScalingL(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	__ASSERT_DEBUG(aScreenDevice, User::Invariant());

	__ASSERT_DEBUG(aGraphicsContext, User::Invariant());

	INFO_PRINTF1(_L("Font Scaling"));

	const TInt KTypeFacesCnt = aScreenDevice->NumTypefaces();

	for(TInt i=0;i<KTypeFacesCnt;++i)

		{

		TTypefaceSupport typeFaceSupport;

		aScreenDevice->TypefaceSupport(typeFaceSupport, i);

		TFontSpec fontSpec;

		fontSpec.iTypeface = typeFaceSupport.iTypeface;

		fontSpec.iHeight = 14;

		CFont* font = NULL;

		User::LeaveIfError(aScreenDevice->GetNearestFontToDesignHeightInPixels(font, fontSpec));

		TDesC& fontName = fontSpec.iTypeface.iName;

		RDebug::Print(_L("%S\r\n"), &fontName);

		aGraphicsContext->UseFont(font);

		DrawTestText(aScreenDevice, aGraphicsContext, font);

		aScreenDevice->ReleaseFont(font);

		}

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0033

  @SYMDEF             

  @SYMTestCaseDesc BitmapScalingL fucntion is used for CFbsBitGc bitmap (DrawBitmap) drawing/scaling tests

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Loads in a number of bitmaps then scales them to the screen

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

void CTBitgdiScaling::BitmapScalingL(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("Bitmap Scaling"));

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(bitmap);

	//8 - it is the number of bitmaps in mbm file - see GenBitmaps.mk where this mbm file is generated

	for(TInt i=0;i<8;i++)

		{

		bitmap->Reset();

		User::LeaveIfError(bitmap->Load(KTestBmp, i));

		TSize size = bitmap->SizeInPixels();

		TPoint ptOrigin(size.iWidth + 10, 3);

		TDrawBitmapFunctor functor;

		TDrawComposite<TDrawBitmapFunctor, CFbsBitmap> composite(ptOrigin, functor, bitmap);

		composite.Draw(aScreenDevice, aGraphicsContext, this);

		}

	CleanupStack::PopAndDestroy(bitmap);

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0034

  @SYMDEF             

  @SYMTestCaseDesc BitBltMaskedScalingL fucntion is used for CFbsBitGc::BitBltMasked drawing/scaling tests

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Loads in a number of bitmaps and their masks then scales them to the screen

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/	

void CTBitgdiScaling::BitBltMaskedScalingL(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("BitBltMasked Scaling"));

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(bitmap);

	User::LeaveIfError(bitmap->Load(KTestBmp, 0));

	TSize size = bitmap->SizeInPixels();

	CFbsBitmap* maskBitmap = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(maskBitmap);

	User::LeaveIfError(maskBitmap->Create(size, EGray256));

	TBitmapUtil bmpUtil(maskBitmap);

	bmpUtil.Begin(TPoint(0, 0));

	for(TInt i=0;i<size.iWidth;++i)

		{

		for(TInt j=0;j<size.iHeight;++j)

			{

			bmpUtil.SetPos(TPoint(i, j));

			bmpUtil.SetPixel(0x00555555);

			}

		}

	bmpUtil.End();

	TPoint ptOrigin(size.iWidth * 3, 7);

	TMaskedBitmapPrm prm = {bitmap, maskBitmap};

	TBitBltMaskedFunctor functor;

	TDrawComposite<TBitBltMaskedFunctor, TMaskedBitmapPrm> composite(ptOrigin, functor, &prm);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	CleanupStack::PopAndDestroy(2);//maskBitmap and bitmap

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0035

  @SYMDEF             

  @SYMTestCaseDesc DrawingScalingL function is used for CFbsBitGc::DrawXXX drawing/scaling tests

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Tests the scaling various basic graphic primitives

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

void CTBitgdiScaling::DrawingScalingL(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	DrawArc(aScreenDevice, aGraphicsContext);

	DrawPie(aScreenDevice, aGraphicsContext);

	DrawRoundRect(aScreenDevice, aGraphicsContext);

	DrawPolyLineL(aScreenDevice, aGraphicsContext);

	DrawPolyLineNoEndPointL(aScreenDevice, aGraphicsContext);

	DrawPolygonL(aScreenDevice, aGraphicsContext);

	DrawEllipse(aScreenDevice, aGraphicsContext);

	DrawLine(aScreenDevice, aGraphicsContext);

	DrawRect(aScreenDevice, aGraphicsContext);

	ShadowFade(aScreenDevice, aGraphicsContext);

	}

//

//TMapColorsFunctor class is used for CFbsBitGc::MapColors drawing/scaling tests

class TMapColorsFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, TEmpty*)

		{

		aGraphicsContext->DrawRect(TRect(7, 13, 45, 67));

		TRgb colors[] = {TRgb(0x00, 0x00, 0x00), TRgb(0xFF, 0x20, 0x20)};

		aGraphicsContext->MapColors(TRect(5, 10, 50, 70), colors);

		}

	};

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0036

  @SYMDEF             

  @SYMTestCaseDesc MapColors function is used for CFbsBitGc::MapColors drawing/scaling tests

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions tests scaling of mapp3ed colours

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

//

void CTBitgdiScaling::MapColors(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("MapColors scaling"));

	TMapColorsFunctor functor;

	TDrawComposite<TMapColorsFunctor, TEmpty> composite(TPoint(83, 11), functor, NULL);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	}

//BitmapScalingL fucntion is used for CFbsBitGc bitmap (DrawBitmap) drawing/scaling tests

//2 screen devices used - scaled and non-scaled

void CTBitgdiScaling::BitmapScalingL(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext, 

						   CFbsScreenDevice* aScreenDevice2, CFbsBitGc* aGraphicsContext2,

						   TBool aCallGetch)

	{

	__ASSERT_DEBUG(aScreenDevice, User::Invariant());

	__ASSERT_DEBUG(aGraphicsContext, User::Invariant());

	__ASSERT_DEBUG(aScreenDevice2, User::Invariant());

	__ASSERT_DEBUG(aGraphicsContext2, User::Invariant());

	INFO_PRINTF1(_L("Bitmap Scaling - 2 devices"));

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(bitmap);

	//8 - it is the number of bitmaps in mbm file - see GenBitmaps.mk where this mbm file is generated

	for(TInt i=0;i<8;i++)

		{

		bitmap->Reset();

		User::LeaveIfError(bitmap->Load(KTestBmp, i));

		TSize size = bitmap->SizeInPixels();

		TPoint ptOrigin(size.iWidth + 10, 3);

		TInt err = aScreenDevice2->SetScalingFactor(ptOrigin, KScalingFactorX, KScalingFactorY, 1, 1);

		TEST(err == KErrNone);

		aGraphicsContext2->Activate(aScreenDevice2);

		aGraphicsContext->Clear();

		aGraphicsContext2->Clear();

		TSize screenSize = aScreenDevice->SizeInPixels();

		TRect rc(0, 0, screenSize.iWidth - 1, screenSize.iHeight - 1);

		aGraphicsContext->DrawRect(rc);

		aGraphicsContext->DrawBitmap(TRect(2, 2, size.iWidth + 2, size.iHeight + 2), bitmap);

		TSize screenSize2 = aScreenDevice2->SizeInPixels();

		TRect rc2(0, 0, screenSize2.iWidth - 1, screenSize2.iHeight - 1);

		aGraphicsContext2->DrawRect(rc2);

		aGraphicsContext2->DrawBitmap(TRect(2, 2, size.iWidth + 2, size.iHeight + 2), bitmap);

		aScreenDevice->Update();

		aScreenDevice2->Update();

		if(aCallGetch)

			{

			//TheTest.Getch();

			}

		}

	CleanupStack::PopAndDestroy(bitmap);

	}

//DrawTestText function is used for CFbsBitGc text drawing/scaling tests

void CTBitgdiScaling::DrawTestText(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext, CFont* aFont)

	{

	__ASSERT_DEBUG(aFont, User::Invariant());

	TPoint ptOrigin(aFont->HeightInPixels() * 4, aFont->AscentInPixels() * 2);

	TDrawTextFunctor functor;

	TDrawComposite<TDrawTextFunctor, CFont> composite(ptOrigin, functor, aFont);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	}

//

//TDrawArcFunctor class is used for CFbsBitGc::DrawArc drawing/scaling tests

class TDrawArcFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, TEmpty*)

		{

		aGraphicsContext->DrawArc(TRect(0, 0, 40, 40), TPoint(0, 20), TPoint(40, 20));

		}

	};

//DrawArc function is used for CFbsBitGc::DrawArc drawing/scaling tests

void CTBitgdiScaling::DrawArc(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("DrawArc scaling"));

	TDrawArcFunctor functor;

	TDrawComposite<TDrawArcFunctor, TEmpty> composite(TPoint(40, 0), functor, NULL);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	}

//

//TDrawPieFunctor class is used for CFbsBitGc::DrawPie drawing/scaling tests

class TDrawPieFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, TEmpty*)

		{

		aGraphicsContext->DrawPie(TRect(0, 0, 40, 40), TPoint(0, 20), TPoint(40, 20));

		}

	};

//DrawPie function is used for CFbsBitGc::DrawPie drawing/scaling tests

void CTBitgdiScaling::DrawPie(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("DrawPie scaling"));

	TDrawPieFunctor functor;

	TDrawComposite<TDrawPieFunctor, TEmpty> composite(TPoint(40, 0), functor, NULL);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	}

//

//TDrawRoundRectFunctor class is used for CFbsBitGc::DrawRoundRect drawing/scaling tests

class TDrawRoundRectFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, TEmpty*)

		{

		aGraphicsContext->DrawRoundRect(TRect(0, 0, 40, 40), TSize(5, 5));

		}

	};

//DrawRoundRect function is used for CFbsBitGc::DrawRoundRect drawing/scaling tests

void CTBitgdiScaling::DrawRoundRect(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("DrawRoundRect scaling"));

	TDrawRoundRectFunctor functor;

	TDrawComposite<TDrawRoundRectFunctor, TEmpty> composite(TPoint(40, 0), functor, NULL);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	}

//

typedef CArrayFixFlat<TPoint> CPointArray;

//TDrawPolyLineFunctor class is used for CFbsBitGc::DrawPolyLine drawing/scaling tests

class TDrawPolyLineFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, CPointArray* aPoints)

		{

		aGraphicsContext->DrawPolyLine(aPoints);

		}

	};

//DrawPolyLineL function is used for CFbsBitGc::DrawPolyLine drawing/scaling tests

void CTBitgdiScaling::DrawPolyLineL(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("DrawPolyLine scaling"));

	CPointArray* points = new (ELeave) CPointArray (4);

	CleanupStack::PushL(points);

	TPoint pt(1, 1);

	points->AppendL(pt);

	pt.SetXY(77, 23);

	points->AppendL(pt);

	pt.SetXY(38, 63);

	points->AppendL(pt);

	pt.SetXY(70, 51);

	points->AppendL(pt);

	TDrawPolyLineFunctor functor;

	TDrawComposite<TDrawPolyLineFunctor, CPointArray> composite(TPoint(80, 0), functor,

																points);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	CleanupStack::PopAndDestroy(points);

	}

//

//TDrawPolyLineNoEndPointFunctor class is used for CFbsBitGc::DrawPolyLineNoEndPoint drawing/scaling tests

class TDrawPolyLineNoEndPointFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, CPointArray* aPoints)

		{

		aGraphicsContext->DrawPolyLineNoEndPoint(aPoints);

		}

	};

//DrawPolyLineNoEndPointL function is used for CFbsBitGc::DrawPolyLineNoEndPoint drawing/scaling tests

void CTBitgdiScaling::DrawPolyLineNoEndPointL(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("DrawPolyLineNoEndPoint scaling"));

	CPointArray* points = new (ELeave) CPointArray (4);

	CleanupStack::PushL(points);

	TPoint pt(1, 1);

	points->AppendL(pt);

	pt.SetXY(77, 23);

	points->AppendL(pt);

	pt.SetXY(38, 63);

	points->AppendL(pt);

	pt.SetXY(70, 51);

	points->AppendL(pt);

	TDrawPolyLineNoEndPointFunctor functor;

	TDrawComposite<TDrawPolyLineNoEndPointFunctor, CPointArray> composite(

																	TPoint(80, 0), functor,

																	points);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	CleanupStack::PopAndDestroy(points);

	}

//

//TDrawPolygonFunctor class is used for CFbsBitGc::DrawPolygon drawing/scaling tests

class TDrawPolygonFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, CPointArray* aPoints)

		{

		aGraphicsContext->DrawPolygon(aPoints);

		}

	};

//DrawPolygon function is used for CFbsBitGc::DrawPolygon drawing/scaling tests

void CTBitgdiScaling::DrawPolygonL(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("DrawPolygon scaling"));

	CPointArray* points = new (ELeave) CPointArray (6);

	CleanupStack::PushL(points);

	TPoint pt(1, 20);

	points->AppendL(pt);

	pt.SetXY(23, 3);

	points->AppendL(pt);

	pt.SetXY(61, 29);

	points->AppendL(pt);

	pt.SetXY(51, 47);

	points->AppendL(pt);

	pt.SetXY(31, 39);

	points->AppendL(pt);

	pt.SetXY(44, 17);

	points->AppendL(pt);

	TDrawPolygonFunctor functor;

	TDrawComposite<TDrawPolygonFunctor, CPointArray> composite(TPoint(80, 0), functor,

															   points);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	CleanupStack::PopAndDestroy(points);

	}

//

//TDrawEllipseFunctor class is used for CFbsBitGc::DrawEllipse drawing/scaling tests

class TDrawEllipseFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, TEmpty*)

		{

		aGraphicsContext->DrawEllipse(TRect(11, 13, 40, 70));

		}

	};

//DrawEllipse function is used for CFbsBitGc::DrawEllipse drawing/scaling tests

void CTBitgdiScaling::DrawEllipse(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("DrawEllipse scaling"));

	TDrawEllipseFunctor functor;

	TDrawComposite<TDrawEllipseFunctor, TEmpty> composite(TPoint(50, 27), functor, NULL);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	}

//

//TDrawLineFunctor class is used for CFbsBitGc::DrawLine drawing/scaling tests

class TDrawLineFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, TEmpty*)

		{

		aGraphicsContext->DrawLine(TPoint(7, 13), TPoint(45, 67));

		aGraphicsContext->DrawLineTo(TPoint(33, 53));

		aGraphicsContext->DrawLineBy(TPoint(11, 53));

		}

	};

//DrawLine function is used for CFbsBitGc::DrawLineXX drawing/scaling tests

void CTBitgdiScaling::DrawLine(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("DrawLineXX scaling"));

	TDrawLineFunctor functor;

	TDrawComposite<TDrawLineFunctor, TEmpty> composite(TPoint(83, 11), functor, NULL);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	}

//

//TDrawRectFunctor class is used for CFbsBitGc::DrawRect drawing/scaling tests

class TDrawRectFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, TEmpty*)

		{

		aGraphicsContext->DrawRect(TRect(7, 13, 45, 67));

		}

	};

//DrawRect function is used for CFbsBitGc::DrawRect drawing/scaling tests

void CTBitgdiScaling::DrawRect(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("DrawRect scaling"));

	TDrawRectFunctor functor;

	TDrawComposite<TDrawRectFunctor, TEmpty> composite(TPoint(83, 11), functor, NULL);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	}

//

//TShadowFadeFunctor class is used for CFbsBitGc::ShadowArea/FadeArea drawing/scaling tests

class TShadowFadeFunctor

	{

public:

	void operator()(CFbsBitGc* aGraphicsContext, TEmpty*)

		{

		aGraphicsContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

		aGraphicsContext->SetBrushColor(TRgb(0xBB, 0x34, 0x55));

		aGraphicsContext->DrawRect(TRect(1, 1, 40, 20));

		aGraphicsContext->DrawRect(TRect(20, 20, 40, 40));

		RRegion shadowRgn;

		shadowRgn.AddRect(TRect(1, 1, 40, 20));

		shadowRgn.AddRect(TRect(20, 20, 40, 40));

		aGraphicsContext->ShadowArea(&shadowRgn);

		shadowRgn.Close();

		aGraphicsContext->SetBrushColor(TRgb(0xFF, 0x00, 0xFF));

		aGraphicsContext->DrawRect(TRect(3, 25, 17, 33));

		aGraphicsContext->DrawRect(TRect(1, 43, 67, 55));

		RRegion fadeRgn;

		fadeRgn.AddRect(TRect(3, 25, 17, 33));

		fadeRgn.AddRect(TRect(1, 43, 67, 55));

		aGraphicsContext->FadeArea(&fadeRgn);

		fadeRgn.Close();

		aGraphicsContext->SetBrushColor(TRgb(0xFF, 0xFF, 0xFF));

		aGraphicsContext->SetBrushStyle(CGraphicsContext::ENullBrush);

		}

	};

//ShadowFade function is used for CFbsBitGc::ShadowArea/FadeArea drawing/scaling tests

void CTBitgdiScaling::ShadowFade(CFbsScreenDevice* aScreenDevice, CFbsBitGc* aGraphicsContext)

	{

	INFO_PRINTF1(_L("Shadow/Fade scaling"));

	TShadowFadeFunctor functor;

	TDrawComposite<TShadowFadeFunctor, TEmpty> composite(TPoint(83, 11), functor, NULL);

	composite.Draw(aScreenDevice, aGraphicsContext, this);

	}

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

__CONSTRUCT_STEP__(BitgdiScaling)

void CTBitgdiScalingStep::TestSetupL()

	{

	iDisplayMode = GetDisplayModeL();

	}

TDisplayMode CTBitgdiScalingStep::GetDisplayModeL()

	{

	CFbsScreenDevice* device = NULL;

	TDisplayMode mode = EColor64K;

	TRAPD(err, device = CFbsScreenDevice::NewL(KNullDesC, mode));

	if (err == KErrNotSupported)

		{

		mode = EColor256;

		TRAP(err, device = CFbsScreenDevice::NewL(KNullDesC, mode));

		}

	if (err == KErrNotSupported)

		{

		mode = EColor16MA;

		TRAP(err, device = CFbsScreenDevice::NewL(KNullDesC, mode));

		}

	if (err == KErrNotSupported)

		{

		mode = EColor16MAP;

		TRAP(err, device = CFbsScreenDevice::NewL(KNullDesC, mode));

		}

	TESTL(err == KErrNone);

	delete device;

	return mode;

	}