diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/screendriver/tsrc/TScdvScaling.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/screendriver/tsrc/TScdvScaling.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1341 @@
+// 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:
+//
+
+#include <e32math.h>
+#include <hal.h>
+#include <bitdraw.h>
+#include <bitdrawscaling.h>
+#include <bitdraworigin.h>
+#include <bitdrawinterfaceid.h>
+#include <graphics/gdi/gdiconsts.h>
+#include "TScdvScaling.h"
+
+
+
+//Test line properties: 
+//[iX, iY] - the starting point of the line
+//iLength - line length
+struct TLineProps
+	{
+	TInt iX;
+	TInt iY;
+	TInt iLength;
+	};
+//
+//Constants
+//
+//This structure defines [TDrawMode <-> clear screen color value] relation
+//When the test uses KDrawMode[i].iDrawMode, then the screen will be cleared using
+//KDrawMode[i].iClearColorVal value
+struct TDrawModeProps
+	{
+	CGraphicsContext::TDrawMode iDrawMode;
+	// keep the color value 8-bit in both EColor256 and EColor64K, special care need
+	// to be done when filling the buffer, e.g color=0x55 
+	// in EColor256 clearing means filling 0x55 0x55 0x55 etc, but
+	// in EColor64K it has to be 0x0055 0x0055 0x0055 etc
+	TUint8 iClearColorVal;
+	};
+const TDrawModeProps KDrawMode[] = 
+	{
+		{CGraphicsContext::EDrawModePEN,		0xFF},
+		{CGraphicsContext::EDrawModeAND,		0x37},
+		{CGraphicsContext::EDrawModeXOR,		0x38},
+		{CGraphicsContext::EDrawModeOR,			0xB1},
+		{CGraphicsContext::EDrawModeNOTSCREEN,	0xC0},
+		{CGraphicsContext::EDrawModeNOTPEN,		0x1D}
+	};
+const TInt KDrawModesCnt = sizeof(KDrawMode) / sizeof(KDrawMode[0]);
+//Shadow/Fade modes
+const CFbsDrawDevice::TShadowMode KShadowMode[] = 
+	{
+	CFbsDrawDevice::EShadow,
+	CFbsDrawDevice::EFade,
+	CFbsDrawDevice::EShadowFade
+	};
+const TInt KShadowModesCnt = sizeof(KShadowMode) / sizeof(KShadowMode[0]);
+//Test pixel color value
+const TUint8 KTestColorVal = 0x55;
+//All possible orientations
+const CFbsDrawDevice::TOrientation KOrientation[] = 
+	{
+	CFbsDrawDevice::EOrientationNormal,
+	CFbsDrawDevice::EOrientationRotated90,
+	CFbsDrawDevice::EOrientationRotated180,
+	CFbsDrawDevice::EOrientationRotated270
+	};
+const TInt KOrientationsCnt = sizeof(KOrientation) / sizeof(KOrientation[0]);
+//Width and Height of legacy application screen
+const TInt KLegacyAppSizeWidth = 60;
+const TInt KLegacyAppSizeHeight = 40;
+//Scaling factors: X and Y
+const TInt KScalingFactorX = 3;
+const TInt KScalingFactorY = 2;
+const TInt KMaxScalingFactor = 3;		//Max of previous 2 values
+
+//
+//Declarations
+//
+GLDEF_C TInt ByteSize(TDisplayMode aDisplayMode,TInt aWidth)
+	{
+	TInt wordSize=aWidth;
+	switch(aDisplayMode)
+		{
+		case EGray2:
+			wordSize = (wordSize + 31) / 32;
+			break;
+		case EGray4:
+			wordSize = (wordSize + 15) / 16;
+			break;
+		case EGray16:
+		case EColor16:
+			wordSize = (wordSize + 7) / 8;
+			break;
+		case EGray256:
+		case EColor256:
+			wordSize = (wordSize + 3) / 4;
+			break;
+		case EColor4K:
+		case EColor64K:
+			wordSize = (wordSize + 1) / 2;
+			break;
+		case EColor16M:
+			wordSize = ((wordSize + 3) / 4) * 3;
+			break;
+		case EColor16MU:
+		case EColor16MA:
+			//Doesn't need changing
+			break;
+		default:
+			break;
+		};
+	return wordSize * 4;
+	}
+
+static inline TInt ByteSize(TDisplayMode aDisplayMode, TSize aSize)
+	{
+	return ByteSize(aDisplayMode,aSize.iWidth) * aSize.iHeight;
+	}
+
+template <class TPixelType> 
+inline void MemFill(TPixelType* aBuffer, TInt aSize, TPixelType aValue)
+	{
+	TPixelType* p = aBuffer;
+	TInt i = 0;
+	while (i++<aSize)
+		*p++ = aValue;
+	}
+	
+//Generic test class for both Color256 and Color64K
+template <class TPixelType> class CTScaling: public CTGraphicsBase
+	{
+public:
+	CTScaling(CTestStep *aTest, TDisplayMode aDisplayMode);
+	~CTScaling();
+	void RunTestCaseL(TInt aCurTestCase);
+private:
+	void ConstructL();
+	void CreateScreenDeviceL();
+	void SetScalingSettings(const TPoint& aOrigin, TInt aFx, TInt aFy, TInt aDivX, TInt aDivY);
+	void CheckLine(const TLineProps& aLineProps, const TPoint& aOrg, const TDrawModeProps& aDrawModeProps, TPixelType aClearColorValue);
+	void CheckWriteRgbMulti(const TRect& aRcProps, const TPoint& aOrg, const TDrawModeProps& aDrawModeProps, TPixelType aClearColorValue);
+	void CheckRgbAlphaLine(const TLineProps& aLineProps, const TPoint& aOrg, TPixelType aClearColorValue);
+	void CheckRect(const TRect& aRc, const TPoint& aOrg, TPixelType aClearColorValue);
+	void WriteLine();
+	void ClearScreen(const TDrawModeProps& aDrawModeProps);
+	void SetTestData();
+	void CheckChangedPixels(TInt aChangedPixelsCnt, TPixelType aClearColorVal);
+	void CheckWriteBinary(const TPoint& aPt, const TPoint& aOrg, TPixelType aClearColorValue, TInt aLength, TInt aHeight);
+	void CheckVertLine(const TLineProps& aLineProps, const TPoint& aOrg, TPixelType aClearColorValue);
+	void WriteRgb();
+	void WriteRgbMulti();
+	void WriteRgbAlphaLine();
+	void WriteBinary();
+	void WriteBinaryLineVertical();
+	void WriteBinaryLine();
+	void WriteRgbAlphaMulti();
+	void ShadowArea();
+	void WriteRgbAlphaLine2();
+	void TestScalingSettingsInterface();
+	void PerformanceTest();
+private:
+	//Test data array
+	TPixelType iTestData[KLegacyAppSizeWidth];
+	//The device used in the tests
+	CFbsDrawDevice* iDrawDevice;
+	//Width and Height of the screen
+	TSize iPhysSize;
+	//The test allocates block of memory for a screen with PhysSize size 
+	//mode. iBits will point to the allocated memory block.
+	TPixelType* iBits;
+	TDisplayMode iDisplayMode;
+	//The scaling interface
+	MScalingSettings* iScalingSettings;
+	//The origin interface
+	MDrawDeviceOrigin* iOriginInterface;
+	TInt iCurOrientation;
+	TInt iScalingFactorX;
+	TInt iScalingFactorY;
+	};
+typedef CTScaling<TUint8> CTestNone;
+typedef CTScaling<TUint8> CTestColor256;
+typedef CTScaling<TUint16> CTestColor64K;
+
+
+
+//
+//Test code
+//
+/*template <class TPixelType>
+CTScaling<TPixelType>* CTScaling<TPixelType>::NewL(TDisplayMode aDisplayMode)	
+	{
+	CTScaling<TPixelType>* self = new (ELeave) CTScaling<TPixelType>;
+	CleanupStack::PushL(self);
+	self->ConstructL(aDisplayMode);
+	CleanupStack::Pop(self);
+	return self;
+	}
+*/	
+
+template <class TPixelType>
+CTScaling<TPixelType>::CTScaling(CTestStep *aTest, TDisplayMode aDisplayMode) :
+				CTGraphicsBase(aTest),
+				iDisplayMode(aDisplayMode)
+	{
+	INFO_PRINTF1(_L("Scaling tests"));
+	}
+	
+
+template <class TPixelType>
+void CTScaling<TPixelType>::ConstructL()	
+	{
+	CreateScreenDeviceL();
+	}
+	
+template <class TPixelType>
+CTScaling<TPixelType>::~CTScaling()
+	{
+	((CTScalingStep*)iStep)->CloseTMSGraphicsStep();
+	delete[] iBits;
+	delete iDrawDevice;	
+	}
+	
+template <class TPixelType>
+void CTScaling<TPixelType>::SetScalingSettings(const TPoint& aOrigin, TInt aFx, TInt aFy, TInt aDivX, TInt aDivY)
+	{
+	TEST(iDrawDevice != NULL);	
+	if(!iScalingSettings)
+		{
+		TInt err = iDrawDevice->GetInterface(KScalingSettingsInterfaceID, 
+											  reinterpret_cast <TAny*&> (iScalingSettings));
+		TEST2(err, KErrNone);
+		}
+	TEST(iScalingSettings != NULL);
+	TInt err = iScalingSettings->Set(aFx, aFy, aDivX, aDivY);
+	TEST2(err, KErrNone);
+	if(!iOriginInterface)
+		{
+		TInt err = iDrawDevice->GetInterface(KDrawDeviceOriginInterfaceID, 
+											  reinterpret_cast <TAny*&> (iOriginInterface));
+		TEST2(err, KErrNone);
+		}
+	TEST(iOriginInterface != NULL);
+	err = iOriginInterface->Set(aOrigin);
+	TEST2(err, KErrNone);
+	}
+
+//Clears the screen initializing each screen pixel with aDrawModeProps.iClearColorVal value
+template <class TPixelType>
+void CTScaling<TPixelType>::ClearScreen(const TDrawModeProps& aDrawModeProps)
+	{
+	::MemFill(iBits, ::ByteSize(EColor256, iPhysSize), TPixelType(aDrawModeProps.iClearColorVal));
+	}
+
+//Initializes iTestData array with KTestColorVal value
+template <class TPixelType>
+void CTScaling<TPixelType>::SetTestData()
+	{
+	::MemFill(iTestData, KLegacyAppSizeWidth, TPixelType(KTestColorVal));
+	}
+
+template <class TPixelType>
+void CTScaling<TPixelType>::CheckChangedPixels(TInt aChangedPixelsCnt, TPixelType aClearColorVal)
+	{
+	const TInt KByteSize = ::ByteSize(EColor256, iPhysSize);
+	TInt changedPixelsCnt = 0;
+	for(TInt ii=0;ii<KByteSize;++ii)
+		{
+		if(iBits[ii]!=aClearColorVal)
+			{
+			++changedPixelsCnt;
+			}
+		}
+	TEST(changedPixelsCnt == aChangedPixelsCnt);
+	if (changedPixelsCnt!=aChangedPixelsCnt)
+		{
+		_LIT(KLog,"Wrong number of changed pixels, expected=%d, actual=%d, color=0x%x");
+		INFO_PRINTF4(KLog,aChangedPixelsCnt,changedPixelsCnt,aClearColorVal);
+		}
+	}
+
+//Checks a set of horisontal lines , which starting point is 
+//[aOrg.iX + aLineProps.iX * iScalingFactorX, aOrg.iY + aLineProps.iY * iScalingFactorY]
+//and length is aLineProps.iLength * iScalingFactorX. For each nexh line y-coordinate
+//is incremented by 1.
+//The screen lines pixel values are tested against aClearColorValue value.
+//Then the screen is testsed pixel by pixel that nothing is written outside the tested lines.
+template <class TPixelType>
+void CTScaling<TPixelType>::CheckLine(const TLineProps& aLineProps, 
+					  const TPoint& aOrg, 
+					  const TDrawModeProps& aDrawModeProps, 
+					  TPixelType aClearColorValue)
+	{
+	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];
+	TInt ii;
+	for(ii=0;ii<iScalingFactorY;++ii)
+		{
+		Mem::Fill(data, sizeof(data), 0x00);
+		iDrawDevice->ReadLine(aOrg.iX + aLineProps.iX * iScalingFactorX, 
+							   aOrg.iY + aLineProps.iY * iScalingFactorY + ii, 
+							   aLineProps.iLength * iScalingFactorX, 
+							   data, 
+							   iDisplayMode);
+		const TInt length=aLineProps.iLength*iScalingFactorX;
+		TInt firstErr=length;
+		TInt numErrs=0;
+		for(TInt jj=0;jj<length;++jj)
+			{
+			//TEST(data[jj]!=aClearColorValue);
+			if (data[jj]==aClearColorValue)
+				{
+				++numErrs;
+				if (jj<firstErr)
+					firstErr=jj;
+				}
+			}
+		TEST(numErrs==0);
+		if (numErrs>0)
+			{
+			_LIT(KLog,"Line %d (of %d) of length %d has %d errors first one at %d,  ClearCol=0x%x");
+			INFO_PRINTF7(KLog,ii,iScalingFactorY,length,numErrs,firstErr,aClearColorValue);
+			}
+		}
+	TInt changedPixelsCnt = iScalingFactorY * aLineProps.iLength * iScalingFactorX;
+	CheckChangedPixels(changedPixelsCnt, aDrawModeProps.iClearColorVal);
+	}
+
+//Checks the rectangle filled using CFbsScreenDevice::WriteRgbMulti. 
+//The screen lines pixel values are tested against aClearColorValue value.
+//Then the screen is testsed pixel by pixel that nothing is written outside the tested rectangle.
+template <class TPixelType>
+void CTScaling<TPixelType>::CheckWriteRgbMulti(const TRect& aRcProps, 
+							   const TPoint& aOrg, 
+							   const TDrawModeProps& aDrawModeProps, 
+							   TPixelType aClearColorValue)
+	{
+	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];
+	TInt ii;
+	TInt xx = aOrg.iX + aRcProps.iTl.iX * iScalingFactorX;
+	TInt yy = aOrg.iY + aRcProps.iTl.iY * iScalingFactorY;
+	for(ii=0;ii<(iScalingFactorY * aRcProps.Height());++ii)
+		{
+		Mem::Fill(data, sizeof(data), 0x00);
+		iDrawDevice->ReadLine(xx, yy+ii, aRcProps.Width()*iScalingFactorX, data, iDisplayMode);
+		const TInt width=aRcProps.Width()*iScalingFactorX;
+		TInt firstErr=width;
+		TInt numErrs=0;
+		for(TInt jj=0;jj<width;++jj)
+			{
+			//TEST(data[jj]!=aClearColorValue);
+			if (data[jj]==aClearColorValue)
+				{
+				++numErrs;
+				if (jj<firstErr)
+					firstErr=jj;
+				}
+			}
+		TEST(numErrs==0);
+		if (numErrs>0)
+			{
+			_LIT(KLog,"Line %d of width %d has %d errors first one at %d,  ClearCol=0x%x");
+			INFO_PRINTF6(KLog,ii,width,numErrs,firstErr,aClearColorValue);
+			}
+		}
+	TInt changedPixelsCnt = iScalingFactorY * aRcProps.Width() * aRcProps.Height() * iScalingFactorX;
+	CheckChangedPixels(changedPixelsCnt, aDrawModeProps.iClearColorVal);
+	}
+
+//Checks a set of horisontal lines , which starting point is 
+//[aOrg.iX + aLineProps.iX * iScalingFactorX, aOrg.iY + aLineProps.iY * iScalingFactorY]
+//and length is aLineProps.iLength * iScalingFactorX. For each nexh line y-coordinate
+//is incremented by 1.
+//The screen lines pixel values are tested against aClearColorValue value.
+//Then the screen is testsed pixel by pixel that nothing is written outside the tested lines.
+template <class TPixelType>
+void CTScaling<TPixelType>::CheckRgbAlphaLine(const TLineProps& aLineProps, 
+							  const TPoint& aOrg, 
+							  TPixelType aClearColorValue)
+	{
+	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];
+	for(TInt ii=0;ii<iScalingFactorY;++ii)
+		{
+		Mem::Fill(data, sizeof(data), 0x00);
+		iDrawDevice->ReadLine(aOrg.iX + aLineProps.iX * iScalingFactorX, 
+							   aOrg.iY + aLineProps.iY * iScalingFactorY + ii, 
+							   aLineProps.iLength * iScalingFactorX, 
+							   data, 
+							   iDisplayMode);
+		const TInt length=aLineProps.iLength*iScalingFactorX;
+		TInt firstErr=length;
+		TInt numErrs=0;
+		for(TInt jj=0;jj<(aLineProps.iLength * iScalingFactorX);++jj)
+			{
+			//TEST(data[jj]!=aClearColorValue);
+			if (data[jj]==aClearColorValue)
+				{
+				++numErrs;
+				if (jj<firstErr)
+					firstErr=jj;
+				}
+			}
+		TEST(numErrs==0);
+		if (numErrs>0)
+			{
+			_LIT(KLog,"Line %d of length %d has %d errors first one at %d,  ClearCol=0x%x");
+			INFO_PRINTF6(KLog,ii,length,numErrs,firstErr,aClearColorValue);
+			}
+		}
+	TInt changedPixelsCnt = iScalingFactorY * aLineProps.iLength * iScalingFactorX;
+	CheckChangedPixels(changedPixelsCnt, aClearColorValue);
+	}
+
+//Checks the rectangle filled using CFbsScreenDevice::WriteBinary. 
+//The screen lines pixel values are tested against aClearColorValue value.
+//Then the screen is testsed pixel by pixel that nothing is written outside the tested rectangle.
+template <class TPixelType>
+void CTScaling<TPixelType>::CheckWriteBinary(const TPoint& aPt, 
+							 const TPoint& aOrg, 
+							 TPixelType aClearColorValue, 
+							 TInt aLength, TInt aHeight)
+	{
+	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];
+	TInt ii;
+	TInt xx = aOrg.iX + aPt.iX * iScalingFactorX;
+	TInt yy = aOrg.iY + aPt.iY * iScalingFactorY;
+	for(ii=0;ii<(iScalingFactorY * aHeight);++ii)
+		{
+		Mem::Fill(data, sizeof(data), 0x00);
+		iDrawDevice->ReadLine(xx, yy + ii, aLength * iScalingFactorX, data, iDisplayMode);
+		const TInt length=aLength*iScalingFactorX;
+		TInt firstErr=length;
+		TInt numErrs=0;
+		for(TInt jj=0;jj<length;++jj)
+			{
+			//TEST(data[jj] != aClearColorValue);
+			if (data[jj]==aClearColorValue)
+				{
+				++numErrs;
+				if (jj<firstErr)
+					firstErr=jj;
+				}
+			}
+		TEST(numErrs==0);
+		if (numErrs>0)
+			{
+			_LIT(KLog,"Line %d of length %d has %d errors first one at %d,  ClearCol=0x%x");
+			INFO_PRINTF6(KLog,ii,length,numErrs,firstErr,aClearColorValue);
+			}
+		}
+	TInt changedPixelsCnt = iScalingFactorY * aLength * aHeight * iScalingFactorX;
+	CheckChangedPixels(changedPixelsCnt, aClearColorValue);
+	}
+
+//Checks a set of vertical lines , which starting point is 
+//[aOrg.iX + aLineProps.iX * iScalingFactorX, aOrg.iY + aLineProps.iY * iScalingFactorY]
+//and length is aLineProps.iLength * iScalingFactorX. For each nexh line y-coordinate
+//is incremented by 1.
+//The screen lines pixel values are tested against aClearColorValue value.
+//Then the screen is testsed pixel by pixel that nothing is written outside the tested lines.
+template <class TPixelType>
+void CTScaling<TPixelType>::CheckVertLine(const TLineProps& aLineProps, const TPoint& aOrg, TPixelType aClearColorValue)
+	{
+	TInt x = aOrg.iX + aLineProps.iX * iScalingFactorX;
+	TInt y = aOrg.iY + aLineProps.iY * iScalingFactorY;
+	for(TInt i=0;i<iScalingFactorX;++i)
+		{
+		for(TInt j=0;j<(aLineProps.iLength * iScalingFactorY);++j)
+			{
+			TRgb val = iDrawDevice->ReadPixel(x + i, y + j);				   
+			switch (iDisplayMode)
+				{
+				case EColor64K:
+				TEST(val.Color64K() != aClearColorValue);
+				break;
+				
+				case EColor256:
+				TEST(val.Color256() != aClearColorValue);
+				break;
+				
+				default:
+				TEST(EFalse);
+				}
+			}
+		}
+	TInt changedPixelsCnt = iScalingFactorX * aLineProps.iLength * iScalingFactorY;
+	CheckChangedPixels(changedPixelsCnt, aClearColorValue);
+	}
+
+//Checks the rectangle filled using CFbsScreenDevice::ShadowArea
+//The screen lines pixel values are tested against aClearColorValue value.
+//Then the screen is testsed pixel by pixel that nothing is written outside the tested rectangle.
+template <class TPixelType>
+void CTScaling<TPixelType>::CheckRect(const TRect& aRc, const TPoint& aOrg, TPixelType aClearColorValue)
+	{
+	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];
+	TInt i;
+	TInt x = aOrg.iX + aRc.iTl.iX * iScalingFactorX;
+	TInt y = aOrg.iY + aRc.iTl.iY * iScalingFactorY;
+	for(i=0;i<(iScalingFactorY * aRc.Height());++i)
+		{
+		Mem::Fill(data, sizeof(data), 0x00);
+		iDrawDevice->ReadLine(x, y + i, aRc.Width() * iScalingFactorX, data, iDisplayMode);
+		for(TInt j=0;j<(aRc.Width() * iScalingFactorX);++j)
+			{
+			TEST(data[j] != aClearColorValue);
+			}
+		}
+	TInt changedPixelsCnt = iScalingFactorY * aRc.Width() * aRc.Height() * iScalingFactorX;
+	CheckChangedPixels(changedPixelsCnt, aClearColorValue);
+	}
+
+//CFbsScreenDevice::WriteLine() and CFbsScreenDevice::ReadLine() test.
+//(Set of test lines) X (Set of origins) X (Set of drawing modes) number of test cases.
+template <class TPixelType>
+void CTScaling<TPixelType>::WriteLine()
+	{
+	INFO_PRINTF1(_L("CFbsDrawDevice::WriteLine"));
+
+	TLineProps lineProps[] = 
+		{
+		{0, 0, KLegacyAppSizeWidth - 1}, 
+		{0, KLegacyAppSizeHeight - 1, KLegacyAppSizeWidth - 1},
+		{10, 20, KLegacyAppSizeWidth / 2},
+		{-2, -5, 20},
+		{-3, 1, 21},
+		{2, -2, 11},
+		{0, -4, 31},
+		{-1, 11, 11}
+		};
+	const TInt KLinesCnt = sizeof(lineProps) / sizeof(lineProps[0]);
+	TPoint ptOrg[] = 
+		{
+		TPoint(13, 21),
+		TPoint(10, 17)
+		};
+	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
+	for(TInt ll=0;ll<KOriginsCnt;++ll)
+		{
+		for(TInt line=0;line<KLinesCnt;++line)
+			{
+			for(TInt kk=0;kk<KDrawModesCnt;++kk)
+				{
+				ClearScreen(KDrawMode[kk]);
+				SetTestData();
+				SetScalingSettings(ptOrg[ll], KScalingFactorX, KScalingFactorY, 1, 1);
+				iDrawDevice->WriteLine(lineProps[line].iX, lineProps[line].iY,
+									  lineProps[line].iLength, 
+									  reinterpret_cast <TUint32*> (iTestData), 
+									  KDrawMode[kk].iDrawMode);
+				if(KDrawMode[kk].iDrawMode == CGraphicsContext::EDrawModePEN)
+					{
+					TPixelType writtenData[KLegacyAppSizeWidth];
+					Mem::FillZ(writtenData, sizeof(writtenData));
+					iDrawDevice->ReadLine(lineProps[line].iX, lineProps[line].iY,
+										   lineProps[line].iLength, 
+										   writtenData, iDisplayMode);
+					for(TInt ii=0;ii<lineProps[line].iLength;++ii)
+						{
+						TEST(writtenData[ii] == iTestData[ii]);
+						}
+					}
+				SetScalingSettings(TPoint(), 1, 1, 1, 1);
+				CheckLine(lineProps[line], ptOrg[ll], KDrawMode[kk], KDrawMode[kk].iClearColorVal);
+				}
+			}
+		}
+	}
+
+//CFbsScreenDevice::WriteRgb() and CFbsScreenDevice::ReadPixel() test.
+//(Set of test points) X (Set of origins) X (Set of drawing modes) number of test cases.
+template <class TPixelType>
+void CTScaling<TPixelType>::WriteRgb()
+	{
+	INFO_PRINTF1(_L("CFbsDrawDevice::WriteRgb"));
+
+	TPoint pt[] = 
+		{
+		TPoint(0, 0), 
+		TPoint(KLegacyAppSizeWidth - 1, 0), 
+		TPoint(0, KLegacyAppSizeHeight - 1), 
+		TPoint(KLegacyAppSizeWidth - 1, KLegacyAppSizeHeight - 1),
+		TPoint(KLegacyAppSizeWidth / 2, KLegacyAppSizeHeight / 2),
+		TPoint(-2, -3), 
+		TPoint(0, -1),
+		TPoint(-3, 0)
+		};
+	const TInt KPointsCnt = sizeof(pt) / sizeof(pt[0]);
+	TPoint ptOrg[] = 
+		{
+		TPoint(9, 22),
+		TPoint(17, 11)
+		};
+	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
+	for(TInt l=0;l<KOriginsCnt;++l)
+		{
+		for(TInt i=0;i<KPointsCnt;++i)
+			{
+			for(TInt k=0;k<KDrawModesCnt;++k)
+				{
+				ClearScreen(KDrawMode[k]);
+				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
+				TRgb val(KTestColorVal);
+				iDrawDevice->WriteRgb(pt[i].iX, pt[i].iY, val, KDrawMode[k].iDrawMode);
+				if(KDrawMode[k].iDrawMode == CGraphicsContext::EDrawModePEN)
+					{
+					TRgb writtenVal = iDrawDevice->ReadPixel(pt[i].iX, pt[i].iY);
+					switch (iDisplayMode)
+						{
+						case EColor64K:
+						TEST(writtenVal == TRgb::Color64K(val.Color64K()));
+						break;
+						
+						case EColor256:
+						TEST(writtenVal == val);
+						break;
+						
+						default:
+						TEST(EFalse);
+						}
+					}
+				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
+				TLineProps props;
+				props.iX = pt[i].iX;
+				props.iY = pt[i].iY;
+				props.iLength = 1;
+				CheckLine(props, ptOrg[l], KDrawMode[k], KDrawMode[k].iClearColorVal);
+				}
+			}
+		}
+	}
+
+//CFbsScreenDevice::WriteRgbMulti() test.
+template <class TPixelType>
+void CTScaling<TPixelType>::WriteRgbMulti()
+	{
+	INFO_PRINTF1(_L("CFbsDrawDevice::WriteRgbMulti"));
+
+	TRect rcProps[] =
+		{
+		TRect(TPoint(0, 0), TSize(KLegacyAppSizeWidth - 1, KLegacyAppSizeHeight - 1)), 
+		TRect(TPoint(17, 11), TSize(KLegacyAppSizeWidth / 2, KLegacyAppSizeHeight / 2)),
+		TRect(TPoint(-1, -4), TSize(31, 12)), 
+		TRect(TPoint(-3, -1), TSize(11, 11)), 
+		TRect(TPoint(0, -2), TSize(6, 17))
+		};
+	const TInt KRcCnt = sizeof(rcProps) / sizeof(rcProps[0]);
+	TPoint ptOrg[] = 
+		{
+		TPoint(21, 29),
+		TPoint(12, 14)
+		};
+	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
+	for(TInt l=0;l<KOriginsCnt;++l)
+		{
+		for(TInt i=0;i<KRcCnt;++i)
+			{
+			for(TInt k=0;k<KDrawModesCnt;++k)
+				{
+				ClearScreen(KDrawMode[k]);
+				SetTestData();
+				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
+				TRgb val(KTestColorVal);
+				iDrawDevice->WriteRgbMulti(rcProps[i].iTl.iX, rcProps[i].iTl.iY,
+									  rcProps[i].Width(), rcProps[i].Height(),
+									  val, 
+									  KDrawMode[k].iDrawMode);
+				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
+				CheckWriteRgbMulti(rcProps[i], ptOrg[l], KDrawMode[k], KDrawMode[k].iClearColorVal);
+				}
+			}
+		}
+	}
+
+//CFbsScreenDevice::WriteRgbAlphaLine() test.
+//(Set of test lines) X (Set of origins) X (Set of drawing modes) number of test cases.
+template <class TPixelType>
+void CTScaling<TPixelType>::WriteRgbAlphaLine()
+	{
+	INFO_PRINTF1(_L("CFbsDrawDevice::WriteRgbAlphaLine"));
+
+	TLineProps lineProps[] = 
+		{
+		{0, 0, KLegacyAppSizeWidth - 1}, 
+		{0, KLegacyAppSizeHeight - 1, KLegacyAppSizeWidth - 1},
+		{17, 3, KLegacyAppSizeWidth / 2},
+		{-1, -2, 11},
+		{-4, -5, 1},
+		{0, -1, 3},
+		{1, -3, 7}
+		};
+	const TInt KLinesCnt = sizeof(lineProps) / sizeof(lineProps[0]);
+	TPoint ptOrg[] = 
+		{
+		TPoint(19, 17),
+		TPoint(29, 25)
+		};
+	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
+	for(TInt l=0;l<KOriginsCnt;++l)
+		{
+		for(TInt i=0;i<KLinesCnt;++i)
+			{
+			for(TInt k=0;k<KDrawModesCnt;++k)
+				{
+				ClearScreen(KDrawMode[k]);
+				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
+				TUint8 rgbBuff[KLegacyAppSizeWidth * 3];
+				Mem::Fill(rgbBuff, sizeof(rgbBuff), KTestColorVal);
+				TUint8 maskBuff[KLegacyAppSizeWidth];
+				TUint8 maskChar = 0xF1;
+				Mem::Fill(maskBuff, sizeof(maskBuff), maskChar);
+				iDrawDevice->WriteRgbAlphaLine(lineProps[i].iX, lineProps[i].iY,
+									  lineProps[i].iLength, rgbBuff, maskBuff, CGraphicsContext::EDrawModePEN);
+				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
+				CheckRgbAlphaLine(lineProps[i], ptOrg[l], KDrawMode[k].iClearColorVal);
+				}
+			}
+		}
+	}
+
+//CFbsScreenDevice::WriteBinary() test.
+template <class TPixelType>
+void CTScaling<TPixelType>::WriteBinary()
+	{
+	INFO_PRINTF1(_L("CFbsDrawDevice::WriteBinary"));
+
+	TPoint pt[] =
+		{
+		TPoint(0, 0), 
+		TPoint(27, 19),
+		TPoint(-4, -4),
+		TPoint(-1, -2),
+		TPoint(-1, -2),
+		TPoint(5, -5),
+		TPoint(-5, 0)
+		};
+	const TInt KPtCnt = sizeof(pt) / sizeof(pt[0]);
+	TPoint ptOrg[] = 
+		{
+		TPoint(19, 24),
+		TPoint(29, 26)
+		};
+	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
+	for(TInt l=0;l<KOriginsCnt;++l)
+		{
+		for(TInt i=0;i<KPtCnt;++i)
+			{
+			for(TInt k=0;k<KDrawModesCnt;++k)
+				{
+				ClearScreen(KDrawMode[k]);
+				SetTestData();
+				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
+				const TInt KHeight = 5;
+				const TInt KLength = 11;
+				TUint32 buff[KHeight];
+				TUint32 buffChar = 0xFFFFFFFF;
+				for(TInt ooo=0;ooo<KHeight;++ooo)
+					{
+					buff[ooo] = buffChar;
+					}
+				TRgb val(KTestColorVal);
+				iDrawDevice->WriteBinary(pt[i].iX, pt[i].iY, buff, KLength, KHeight,
+										  val, KDrawMode[k].iDrawMode);
+				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
+				CheckWriteBinary(pt[i], ptOrg[l], KDrawMode[k].iClearColorVal, KLength, KHeight);
+				}
+			}
+		}
+	}
+
+//CFbsScreenDevice::WriteBinaryLineVertical() test.
+template <class TPixelType>
+void CTScaling<TPixelType>::WriteBinaryLineVertical()
+	{
+	INFO_PRINTF1(_L("CFbsDrawDevice::WriteBinaryLineVertical"));
+
+	TLineProps lineProps[] = 
+		{
+		{0, 0, KLegacyAppSizeHeight - 1}, 
+		{KLegacyAppSizeWidth - 1, 0, KLegacyAppSizeHeight - 1},
+		{17, 3, 23},
+		{-2, -5, 10},
+		{-6, 24, 11},
+		{18, -6, 12},
+		{0, -3, 13},
+		{-1, 0, 14}
+		};
+	const TInt KLinesCnt = sizeof(lineProps) / sizeof(lineProps[0]);
+	TPoint ptOrg[] = 
+		{
+		TPoint(22, 22),
+		TPoint(19, 20)
+		};
+	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
+	for(TInt l=0;l<KOriginsCnt;++l)
+		{
+		for(TInt i=0;i<KLinesCnt;++i)
+			{
+			for(TInt k=0;k<KDrawModesCnt;++k)
+				{
+				ClearScreen(KDrawMode[k]);
+				SetTestData();
+				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
+				const TInt KLength = 30;
+				TUint32 buff[KLength];
+				TUint32 buffChar = 0xFFFFFFFF;
+				for(TInt ooo=0;ooo<KLength;++ooo)
+					{
+					buff[ooo] = buffChar;
+					}
+				TRgb val(KTestColorVal);
+				iDrawDevice->WriteBinaryLineVertical(lineProps[i].iX, lineProps[i].iY,
+													  buff, lineProps[i].iLength, val, 
+													  KDrawMode[k].iDrawMode, EFalse);
+				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
+				CheckVertLine(lineProps[i], ptOrg[l], KDrawMode[k].iClearColorVal);
+				}
+			}
+		}
+	}
+
+//CFbsScreenDevice::WriteBinaryLine() test.
+template <class TPixelType>
+void CTScaling<TPixelType>::WriteBinaryLine()
+	{
+	INFO_PRINTF1(_L("CFbsDrawDevice::WriteBinaryLiine"));
+
+	TPoint pt[] =
+		{
+		TPoint(0, 0), 
+		TPoint(1, 7),
+		TPoint(18, -8),
+		TPoint(-7, 26),
+		TPoint(-4, -7),
+		TPoint(0, -2),
+		TPoint(34, -1),
+		TPoint(-1, 17)
+		};
+	const TInt KPtCnt = sizeof(pt) / sizeof(pt[0]);
+	TPoint ptOrg[] = 
+		{
+		TPoint(21, 35),
+		TPoint(40, 28)
+		};
+	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
+	for(TInt l=0;l<KOriginsCnt;++l)
+		{
+		for(TInt i=0;i<KPtCnt;++i)
+			{
+			for(TInt k=0;k<KDrawModesCnt;++k)
+				{
+				ClearScreen(KDrawMode[k]);
+				SetTestData();
+				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
+				const TInt KHeight = 1;
+				const TInt KLength = 11;
+				TUint32 buff[KHeight];
+				TUint32 buffChar = 0xFFFFFFFF;
+				for(TInt ooo=0;ooo<KHeight;++ooo)
+					{
+					buff[ooo] = buffChar;
+					}
+				TRgb val(KTestColorVal);
+				iDrawDevice->WriteBinaryLine(pt[i].iX, pt[i].iY, buff, KLength,
+											  val, KDrawMode[k].iDrawMode);
+				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
+				CheckWriteBinary(pt[i], ptOrg[l], KDrawMode[k].iClearColorVal, KLength, KHeight);
+				}
+			}
+		}
+	}
+
+//CFbsScreenDevice::WriteRgbAlphaMulti() test.
+template <class TPixelType>
+void CTScaling<TPixelType>::WriteRgbAlphaMulti()
+	{
+	INFO_PRINTF1(_L("CFbsDrawDevice::WriteRgbAlphaMulti"));
+
+	TLineProps lineProps[] = 
+		{
+		{0, 0, KLegacyAppSizeWidth - 1}, 
+		{0, KLegacyAppSizeHeight - 1, KLegacyAppSizeWidth - 1},
+		{17, 3, KLegacyAppSizeWidth / 2},
+		{-8, -8, 11},
+		{-3, 15, 12},
+		{29, -4, 13},
+		{0, -3, 14},
+		{-5, 0, 15}
+		};
+	const TInt KLinesCnt = sizeof(lineProps) / sizeof(lineProps[0]);
+	TPoint ptOrg[] = 
+		{
+		TPoint(24, 17),
+		TPoint(27, 20)
+		};
+	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
+	for(TInt l=0;l<KOriginsCnt;++l)
+		{
+		for(TInt i=0;i<KLinesCnt;++i)
+			{
+			for(TInt k=0;k<KDrawModesCnt;++k)
+				{
+				ClearScreen(KDrawMode[k]);
+				SetTestData();
+				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
+				TUint8 maskBuff[KLegacyAppSizeWidth];
+				TUint8 maskChar = 0xF1;
+				Mem::Fill(maskBuff, sizeof(maskBuff), maskChar);
+				TRgb val(KTestColorVal);
+				iDrawDevice->WriteRgbAlphaMulti(lineProps[i].iX, lineProps[i].iY,
+												 lineProps[i].iLength, val, maskBuff);
+				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
+				CheckRgbAlphaLine(lineProps[i], ptOrg[l], KDrawMode[k].iClearColorVal);
+				}
+			}
+		}
+	}
+
+//CFbsScreenDevice::ShadowArea() test.
+template <class TPixelType>
+void CTScaling<TPixelType>::ShadowArea()
+	{
+	INFO_PRINTF1(_L("CFbsDrawDevice::ShadowArea"));
+
+	TRect rcProps[] =
+		{
+		TRect(TPoint(0, 0), TSize(KLegacyAppSizeWidth - 1, KLegacyAppSizeHeight - 1)), 
+		TRect(TPoint(17, 11), TSize(KLegacyAppSizeWidth / 2, KLegacyAppSizeHeight / 2)),
+		TRect(TPoint(-1, -1), TSize(1, 1)),
+		TRect(TPoint(-4, -5), TSize(11, 8)),
+		TRect(TPoint(0, -6), TSize(3, 23)),
+		TRect(TPoint(-7, 0), TSize(24, 2)),
+		TRect(TPoint(5, -2), TSize(8, 9)),
+		TRect(TPoint(-4, 16), TSize(11, 8))
+		};
+	const TInt KRcCnt = sizeof(rcProps) / sizeof(rcProps[0]);
+	TPoint ptOrg[] = 
+		{
+		TPoint(25, 24),
+		TPoint(31, 29)
+		};
+	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
+	for(TInt l=0;l<KOriginsCnt;++l)
+		{
+		for(TInt i=0;i<KRcCnt;++i)
+			{
+			for(TInt k=0;k<KDrawModesCnt;++k)
+				{
+				TDrawModeProps drawModeProps(KDrawMode[k]);
+				--drawModeProps.iClearColorVal;//I want to avoid "255" clear color value.
+				for(TInt m=0;m<KShadowModesCnt;++m)
+					{
+					iDrawDevice->SetShadowMode(KShadowMode[m]);
+					ClearScreen(drawModeProps);
+					SetTestData();
+					SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
+					iDrawDevice->ShadowArea(rcProps[i]);
+					SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
+					CheckRect(rcProps[i], ptOrg[l], drawModeProps.iClearColorVal);
+					}
+				}
+			}
+		}
+	iDrawDevice->SetShadowMode(CFbsDrawDevice::ENoShadow);
+	}
+
+//CFbsScreenDevice::WriteRgbAlphaLine() test.
+template <class TPixelType>
+void CTScaling<TPixelType>::WriteRgbAlphaLine2()
+	{
+	INFO_PRINTF1(_L("CFbsDrawDevice::WriteRgbAlphaLine-2"));
+
+	TLineProps lineProps[] = 
+		{
+		{0, 0, KLegacyAppSizeWidth - 1}, 
+		{0, KLegacyAppSizeHeight - 1, KLegacyAppSizeWidth - 1},
+		{17, 3, KLegacyAppSizeWidth / 2},
+		{-1, -7, 11},
+		{0, -5, 12},
+		{-3, 0, 13},
+		{15, -7, 14},
+		{-1, -7, 15},
+		{-1, -7, 16}
+		};
+	const TInt KLinesCnt = sizeof(lineProps) / sizeof(lineProps[0]);
+	TPoint ptOrg[] = 
+		{
+		TPoint(18, 28),
+		TPoint(15, 15)
+		};
+	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
+	for(TInt l=0;l<KOriginsCnt;++l)
+		{
+		for(TInt i=0;i<KLinesCnt;++i)
+			{
+			for(TInt k=0;k<KDrawModesCnt;++k)
+				{
+				ClearScreen(KDrawMode[k]);
+				SetTestData();
+				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
+				TUint8 rgbBuff1[KLegacyAppSizeWidth * 3];
+				TUint8 rgbBuff2[KLegacyAppSizeWidth * 3];
+				Mem::Fill(rgbBuff1, sizeof(rgbBuff1), KTestColorVal - 15);
+				Mem::Fill(rgbBuff2, sizeof(rgbBuff2), KTestColorVal + 22);
+				TUint8 maskBuff[KLegacyAppSizeWidth];
+				TUint8 maskChar = 0xF1;
+				Mem::Fill(maskBuff, sizeof(maskBuff), maskChar);
+				iDrawDevice->WriteRgbAlphaLine(lineProps[i].iX, lineProps[i].iY,
+									  lineProps[i].iLength, rgbBuff1, rgbBuff2, maskBuff,
+									  KDrawMode[k].iDrawMode);
+				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
+				CheckRgbAlphaLine(lineProps[i], ptOrg[l], KDrawMode[k].iClearColorVal);
+				}
+			}
+		}
+	}
+
+template <class TPixelType>
+void CTScaling<TPixelType>::TestScalingSettingsInterface()
+	{
+	INFO_PRINTF1(_L("MScalingSettings functionality test"));
+	TEST(iDrawDevice != NULL);	
+
+	MScalingSettings* scalingSettings = NULL;
+	TInt err = iDrawDevice->GetInterface(KScalingSettingsInterfaceID, 
+										  reinterpret_cast <TAny*&> (scalingSettings));
+	TEST2(err, KErrNone);
+	TEST(scalingSettings != NULL);
+
+	TEST(scalingSettings->IsScalingOff());
+
+	const TInt factorXIn = 10, factorYIn = 13, divisorXIn = 1, divisorYIn = 1;
+	TInt factorXOut = -1, factorYOut = -1, divisorXOut = -1, divisorYOut = -1;
+
+	err = scalingSettings->Set(factorXIn, factorYIn, divisorXIn, divisorYIn);
+	TEST2(err, KErrNone);
+	TEST(!scalingSettings->IsScalingOff());
+	scalingSettings->Get(factorXOut, factorYOut, divisorXOut, divisorYOut);
+
+	TEST(factorXOut == factorXOut);
+	TEST(factorYIn == factorYOut);
+	TEST(divisorXIn == divisorXOut);
+	TEST(divisorYIn == divisorYOut);
+
+	MDrawDeviceOrigin* originInterface = NULL;
+	err = iDrawDevice->GetInterface(KDrawDeviceOriginInterfaceID, 
+									 reinterpret_cast <TAny*&> (originInterface));
+	TEST2(err, KErrNone);
+	TEST(originInterface != NULL);
+
+	const TPoint ptOriginIn(20, 45);
+	TPoint ptOriginOut;
+	err = originInterface->Set(ptOriginIn);
+	TEST2(err, KErrNone);
+	originInterface->Get(ptOriginOut);
+	TEST(ptOriginIn == ptOriginOut);
+
+	SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
+	}
+
+//Creates screen device and initializes ::DrawDevice global variable.
+template <class TPixelType>
+void CTScaling<TPixelType>::CreateScreenDeviceL()
+	{
+	if (iDisplayMode == ENone)
+		return;
+	
+	TInt address = NULL;
+	User::LeaveIfError(HAL::Get(KDefaultScreenNo, HALData::EDisplayMemoryAddress,address));
+	User::LeaveIfError(HAL::Get(KDefaultScreenNo, HALData::EDisplayXPixels, iPhysSize.iWidth));
+	User::LeaveIfError(HAL::Get(KDefaultScreenNo, HALData::EDisplayYPixels, iPhysSize.iHeight));
+	__ASSERT_DEBUG(iPhysSize.iWidth > 0 && iPhysSize.iHeight > 0 && address != NULL, User::Invariant());
+
+	TPckgBuf<TScreenInfoV01> info;
+	info().iScreenAddressValid = ETrue;
+	info().iScreenAddress = reinterpret_cast <void*> (address);
+	info().iScreenSize = iPhysSize;
+
+	iDrawDevice = CFbsDrawDevice::NewScreenDeviceL(info(), iDisplayMode);
+	TestScalingSettingsInterface();
+	iBits = new (ELeave) TPixelType[::ByteSize(EColor256, iPhysSize)];
+	iDrawDevice->SetUserDisplayMode(iDisplayMode);
+	iDrawDevice->SetAutoUpdate(EFalse);
+	iDrawDevice->SetBits(iBits);
+	
+
+	}
+
+template <class TPixelType>
+void CTScaling<TPixelType>::PerformanceTest()
+	{
+	INFO_PRINTF1(_L("CFbsDrawDevice, scaling - WriteRgb() performance test"));
+
+	const TInt KDrawingsCnt = 1000000;
+	TInt i, x, y;
+
+	TUint time1 = User::TickCount();
+	x = y = 0;
+	for(i=0;i<KDrawingsCnt;i++)
+		{
+		if(++x > 50)
+			{
+			x = 0;
+			if(++y > 50)
+				{
+				y = 0;
+				}
+			}
+		TRgb val(0x11, 0x12, i);
+		iDrawDevice->WriteRgb(x, y, val, CGraphicsContext::EDrawModePEN);
+		}
+	time1 = User::TickCount() - time1;
+
+	TPoint ptOrigin(5, 3);
+	SetScalingSettings(ptOrigin, KScalingFactorX, KScalingFactorY, 1, 1);
+
+	TUint time2 = User::TickCount();
+	x = y = 0;
+	for(i=0;i<KDrawingsCnt;i++)
+		{
+		if(++x > 50)
+			{
+			x = 0;
+			if(++y > 50)
+				{
+				y = 0;
+				}
+			}
+		TRgb val(0x11, 0x12, i);
+		iDrawDevice->WriteRgb(x, y, val, CGraphicsContext::EDrawModePEN);
+		}
+	time2 = User::TickCount() - time2;
+
+	SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
+
+	RDebug::Print(_L("Non-scaled device, time=%d\r\n"), time1);
+	RDebug::Print(_L("Scaled device, time=%d\r\n"), time2);
+	}
+
+template <class TPixelType>
+void CTScaling<TPixelType>::RunTestCaseL(TInt aCurTestCase)
+	{
+	// EColor64K and EColor256 is not supported, stop the test
+	if (iDisplayMode == ENone)
+		{
+		INFO_PRINTF1(_L("EColor64K and EColor256 are not supported, The test is not run"));
+		TestComplete();
+		}
+	
+	else
+		{
+	    ((CTScalingStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
+		switch(aCurTestCase)
+			{
+		case 1:
+			{
+			if(iCurOrientation >= KOrientationsCnt)
+				{
+				((CTScalingStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+				TestComplete();
+				}
+			else
+				{
+				((CTScalingStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+				if (iCurOrientation==CFbsDrawDevice::EOrientationRotated90 || iCurOrientation==CFbsDrawDevice::EOrientationRotated270)
+					{
+					iScalingFactorX=KScalingFactorY;
+					iScalingFactorY=KScalingFactorX;
+					}
+				else
+					{
+					iScalingFactorX=KScalingFactorX;
+					iScalingFactorY=KScalingFactorY;
+					}
+				INFO_PRINTF3(_L("Set scalling %d,%d"),iScalingFactorX,iScalingFactorY);
+				if(iDrawDevice->SetOrientation(KOrientation[iCurOrientation]))
+					{
+					INFO_PRINTF2(_L("Set orientation: ===EOrientation%S==="),&RotationName(iCurOrientation));
+					}
+				else
+					{
+					INFO_PRINTF2(_L("Failed to set orientation: ===EOrientation%S==="),&RotationName(iCurOrientation));
+					ResetCounter();
+					}
+				iCurOrientation++;
+				}	
+			}	
+			break;
+		case 2:
+/**
+	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0022
+*/
+            ((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0022"));
+			WriteLine();
+			break;
+		case 3:
+/**
+	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0023
+*/
+			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0023"));
+			WriteRgb();
+			break;
+		case 4:
+/**
+	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0024
+*/
+			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0024"));
+			WriteRgbMulti();
+			break;
+		case 5:
+/**
+	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0025
+*/
+			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0025"));
+			WriteRgbAlphaLine();
+			break;
+		case 6:
+/**
+	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0026
+*/
+			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0026"));
+			WriteBinary();
+			break;
+		case 7:
+/**
+	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0027
+*/
+			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0027"));
+			WriteBinaryLineVertical();
+			break;
+		case 8:
+/**
+	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0028
+*/
+			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0028"));
+			WriteBinaryLine();
+			break;
+		case 9:
+/**
+	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0029
+*/
+			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0029"));
+			WriteRgbAlphaMulti();
+			break;
+		case 10:
+/**
+	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0030
+*/
+			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0030"));
+			ShadowArea();
+			break;
+		case 11:
+/**
+	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0031
+*/
+			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0031"));
+			WriteRgbAlphaLine2();
+			break;
+		case 12:
+/**
+	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0032
+*/
+			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0032"));
+			PerformanceTest();
+			break;
+		case 13:
+			((CTScalingStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+			ResetCounter();
+			break;
+			}
+           ((CTScalingStep*)iStep)->RecordTestResultL();
+		}
+	}
+	
+static TDisplayMode GetDisplayModeL()
+	{
+	TDisplayMode mode = EColor64K;
+	CFbsDrawDevice* device = NULL;
+	TRAPD(err, device = CFbsDrawDevice::NewScreenDeviceL(KDefaultScreenNo, mode));
+	if (err!=KErrNone)
+		{
+		mode = EColor256;
+		TRAPD(err, device = CFbsDrawDevice::NewScreenDeviceL(KDefaultScreenNo, mode));
+		
+		if (err == KErrNotSupported)
+			{
+			return ENone;
+			}
+		}
+	delete device;
+	return mode;
+	}
+
+//---------------
+CTScalingStep::CTScalingStep() 
+	{ 
+	SetTestStepName(KTScalingStep); 
+	} 
+	 
+CTGraphicsBase* CTScalingStep::CreateTestL()
+	{ 
+	CTGraphicsBase* theTest = NULL;
+	switch (GetDisplayModeL())
+		{
+		case EColor64K:
+			{
+			INFO_PRINTF1(_L("Scaling - EColor64K"));
+			theTest = new (ELeave) CTestColor64K(this, EColor64K);
+			}
+			break;
+	
+		case EColor256:
+			{
+			INFO_PRINTF1(_L("Scaling - EColor256"));
+			theTest = new (ELeave) CTestColor256(this, EColor256);
+			}
+			break;
+
+		default:
+			INFO_PRINTF1(_L("EColor64K and EColor256 are not supported"));
+			theTest = new (ELeave) CTestNone(this, ENone);			
+		}
+	return 	theTest;		
+	} 
+
+void CTScalingStep::TestSetupL()
+	{
+	TInt temp = 0;
+	HAL::Get(KDefaultScreenNo, HALData::EDisplayColors, temp);//force HAL memory allocation
+	
+	}