--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/bitgdi/tbit/TBitgdiScaling.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,887 @@
+// 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;
+	}