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

// Test code for screen mode scaling CR

// Test code for the Scaling part of Change Request PHAR-5SJGAM 

// ("Enable screen mode positioning and scaling").

// Tests screen scale being configurable for a screen mode -  

// eg it is now possible to set in wsini.ini amount by which a screen 

// mode's screen will be scaled when drawn on the physical screen. 

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TScreenModeScaling.h"

#define MY_TEST_BITMAP _L("Z:\\WSTEST\\MYTEST.MBM")

LOCAL_D TSize FullScreenModeSize;

LOCAL_D TInt Copy2ndHalfOfScreen;

void ClearBitmap(CFbsBitmap* aBitMap)

	{

	// clear the content of bitmap before it is used for copying

	CFbsBitmapDevice *device=CFbsBitmapDevice::NewL(aBitMap);

	CleanupStack::PushL(device);

	CFbsBitGc *gc=NULL;

	User::LeaveIfError(device->CreateContext(gc));

	CleanupStack::PushL(gc);

	gc->Clear();

	CleanupStack::PopAndDestroy(2,device);

	}

/*CBitMapWin*/

void CBitMapWin::Draw()

	{

	iGc->BitBlt(TPoint(),&iBackup->Bitmap());

	}

/*CTestSpriteWin*/

CTestSpriteWin::~CTestSpriteWin()

	{

	}

void CTestSpriteWin::UpdateWin(TPoint aOrigin)

	{

	SetOrigin(aOrigin);

	DrawNow();

	}

void CTestSpriteWin::Draw()

	{

	iGc->BitBlt(iOrigin,&iSpriteBitmap);

	}

/*CTScreenModeScaling*/

CTScreenModeScaling::CTScreenModeScaling(CTestStep* aStep) : CTWsGraphicsBase(aStep)

	{

	}

CTScreenModeScaling::~CTScreenModeScaling()

	{

	delete iTestWin;

	delete iBlankWin;

	delete iBackedUpWin;

	delete iTestChildWin;

	delete iScreenBitmap;

	delete iBitmapWin;

	delete iCheckWin;

	delete iTransWin;

	delete iBackgroundWin;

	delete iCheckBitmap;

	delete iTransparencyBitmap;

	delete iBackgroundBitmap;

	delete iForegroundBitmap;

	}

void CTScreenModeScaling::ConstructL()

	{

	iDisplayMode=TheClient->iScreen->DisplayMode();

	if (iDisplayMode<EColor256)

		iDisplayMode=EColor256;

	User::LeaveIfError(iSpriteBitmap.Load(MY_TEST_BITMAP,0));

	TheClient->iScreen->SetAppScreenMode(TheClient->iScreenModes[0]);

	FullScreenModeSize=TheClient->iScreen->SizeInPixels();

	iBlankWin=new(ELeave) CTBlankWindow();

	iBlankWin->ConstructL(*TheClient->iGroup);

	User::LeaveIfError(iBlankWin->BaseWin()->SetRequiredDisplayMode(EColor256));

	iBlankWin->SetExt(TPoint(),FullScreenModeSize);

	iBlankWin->Activate();

	iTestWin=new(ELeave) CBasicWin;

	iTestWin->ConstructExtLD(*TheClient->iGroup,TPoint(),FullScreenModeSize);

	User::LeaveIfError(iTestWin->BaseWin()->SetRequiredDisplayMode(EColor256));

	iTestWin->AssignGC(*TheClient->iGc);

	iTestWin->SetVisible(EFalse);

	iTestWin->Activate();

	iTestWin->BaseWin()->SetShadowDisabled(ETrue);

	iTestWin->BaseWin()->SetShadowHeight(0);

	iBackedUpWin=new(ELeave) CTBackedUpWin(iDisplayMode);

	iBackedUpWin->ConstructExtLD(*iTestWin,TPoint(),FullScreenModeSize);

	iBackedUpWin->SetVisible(EFalse);

	iBackedUpWin->Activate();

	iTestChildWin=new(ELeave) CTBlankWindow();

	iTestChildWin->ConstructL(*iTestWin);

	User::LeaveIfError(iTestChildWin->BaseWin()->SetRequiredDisplayMode(EColor256));

	iTestChildWin->BaseWin()->SetShadowDisabled(ETrue);

	iTestChildWin->SetColor(KRgbGreen);

	iTestChildWin->BaseWin()->SetVisible(EFalse);

	iTestChildWin->Activate();

	iScreenBitmap=new(ELeave) CFbsBitmap();

	User::LeaveIfError(iScreenBitmap->Create(TSize(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight),iDisplayMode));

	iBitmapWin=new(ELeave) CBmpWin(*iScreenBitmap);

	iBitmapWin->ConstructExtLD(*TheClient->iGroup,TPoint(),iScreenBitmap->SizeInPixels());

	User::LeaveIfError(iBitmapWin->BaseWin()->SetRequiredDisplayMode(EColor256));

	iBitmapWin->AssignGC(*TheClient->iGc);

	iBitmapWin->Activate();

	iBitmapWin->SetVisible(EFalse);

	iBitmapWin->BaseWin()->SetShadowDisabled(ETrue);

	iBitmapWin->BaseWin()->SetShadowHeight(0);

	//.. Create all the bitmaps and transparent windows

	iWinSize.SetSize(20,20);

	iTransparencyBitmap=CBitmap::NewL(iWinSize,EGray256);

	iBackgroundBitmap=CBitmap::NewL(iWinSize,iDisplayMode);

	iForegroundBitmap=CBitmap::NewL(iWinSize,iDisplayMode);

	CBitMapWin* backgroundWin=new(ELeave) CBitMapWin(iBackgroundBitmap);

	backgroundWin->ConstructExtLD(*TheClient->iGroup,TPoint(),iWinSize);

	iBackgroundWin=backgroundWin;

	User::LeaveIfError(iBackgroundWin->BaseWin()->SetRequiredDisplayMode(EColor256));

	iBackgroundWin->SetVisible(EFalse);

	iBackgroundWin->BaseWin()->SetShadowDisabled(ETrue);

	iBackgroundWin->BaseWin()->SetShadowHeight(0);

	iBackgroundWin->AssignGC(*TheClient->iGc);

	iBackgroundWin->Activate();

	CBitMapWin* transWin=new(ELeave) CBitMapWin(iForegroundBitmap);

	transWin->ConstructExtLD(*TheClient->iGroup,TPoint(),iWinSize);

	iTransWin=transWin;

	RWindowBase& transWinB=*iTransWin->BaseWin();

	User::LeaveIfError(transWinB.SetRequiredDisplayMode(EColor256));

	transWinB.SetShadowDisabled(ETrue);

	transWinB.SetShadowHeight(0);

	iTransWin->SetVisible(EFalse);

	iTransWin->AssignGC(*TheClient->iGc);

	iTransWin->Win()->SetTransparencyBitmap(iTransparencyBitmap->Bitmap());

	iTransWin->Activate();

	CTBackedUpWin* checkWin=new(ELeave) CTBackedUpWin(iDisplayMode);

	checkWin->ConstructExtLD(*TheClient->iGroup,TPoint(iWinSize.iWidth+1,0),iWinSize);

	iCheckWin=checkWin;

	RBackedUpWindow& win=*iCheckWin->BackedUpWin();

	win.SetShadowHeight(0);

	iCheckWin->Activate();

	win.MaintainBackup();

	iCheckBitmap=CBitmap::NewL(win.BitmapHandle());

	iCheckWin->BaseWin()->SetShadowDisabled(ETrue);

	iCheckWin->BaseWin()->SetShadowHeight(0);

	iCheckWin->BaseWin()->SetVisible(EFalse);

	TheClient->Flush();

	TheClient->WaitForRedrawsToFinish();

	}

void CTScreenModeScaling::TestTopClientWindowPositionAPIs(TPoint aPos,RWindowBase* aWin)

	{

	TEST(aWin->AbsPosition()==aPos);

	TEST(aWin->Position()==aPos);

	TEST(aWin->InquireOffset(*TheClient->iGroup->GroupWin())==aPos);

	}

void CTScreenModeScaling::TestChildWindowPositionAPIs(TPoint aPos,TPoint aParentPos,RWindowBase* aWin,RWindowBase* aParentWin)

	{

	TEST(aWin->AbsPosition()==aParentPos+aPos);

	TEST(aWin->Position()==aPos);

	TEST(aWin->InquireOffset(*TheClient->iGroup->GroupWin())==aParentPos+aPos);

	TEST(aWin->InquireOffset(*aParentWin)==aPos);

	}

void CTScreenModeScaling::TestRect()

	{

	// Here if the width or height of the screen cannot be divided by 2 

	// then make both the rect size same by reducing the first or second which ever is smaller

	// and make sure that top left corner is not disturbed.

	TRect rect1=TRect(PhysicalToLogical(TPoint()-iCurrentScreenModeOrigin,iCurrentScreenModeScale),

					  PhysicalToLogical(TPoint(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight)-iCurrentScreenModeOrigin,

										iCurrentScreenModeScale)

					  );

	TRect rect2=TRect(PhysicalToLogical(TPoint(FullScreenModeSize.iWidth/2,0)-iCurrentScreenModeOrigin,

										iCurrentScreenModeScale),

					  PhysicalToLogical(FullScreenModeSize.AsPoint()-iCurrentScreenModeOrigin,

										iCurrentScreenModeScale)

					  );

	if ((Abs(rect1.iBr.iX-rect1.iTl.iX)>Abs(rect2.iBr.iX-rect2.iTl.iX)) || (Abs(rect1.iBr.iY-rect1.iTl.iY)>Abs(rect2.iBr.iY-rect2.iTl.iY)))

		{

		rect1.SetRect(rect1.iTl,rect2.Size());

		}

	if ((Abs(rect1.iBr.iX-rect1.iTl.iX)<Abs(rect2.iBr.iX-rect2.iTl.iX)) || (Abs(rect1.iBr.iY-rect1.iTl.iY)<Abs(rect2.iBr.iY-rect2.iTl.iY)))

		{

		rect2.SetRect(rect2.iTl,rect1.Size());

		}

	TBool retVal = TheClient->iScreen->RectCompare(rect1,rect2);

	TEST(retVal);

	if (!retVal)

		INFO_PRINTF3(_L("TheClient->iScreen->RectCompare(rect1,rect2) return value  - Expected: %d, Actual: %d"), ETrue, retVal);		

	}

void CTScreenModeScaling::CompareRegionsL(const TRegion &aRegion1,const TRegion &aRegion2)

	{

	RRegion tmp;

	tmp.Copy(aRegion1);

	tmp.SubRegion(aRegion2);

	if (tmp.CheckError())

		User::Leave(KErrNoMemory);	

	TBool retVal = tmp.IsEmpty();

	TEST(retVal);

	if (!retVal)

		INFO_PRINTF3(_L("RRegion1.IsEmpty() return value  - Expected: %d, Actual: %d"), ETrue, retVal);		

	tmp.Copy(aRegion2);

	tmp.SubRegion(aRegion1);

	if (tmp.CheckError())

		User::Leave(KErrNoMemory);

	retVal = tmp.IsEmpty();

	TEST(retVal);

	if (!retVal)

		INFO_PRINTF3(_L("RRegion2.IsEmpty() return value  - Expected: %d, Actual: %d"), ETrue, retVal);		

	tmp.Close();

	}

void CTScreenModeScaling::SetUpSpriteLC(RWsSprite &aSprite, RWsSession &aSession, RWindowTreeNode &aWindow,TInt aFlags)

	{

	aSprite=RWsSprite(aSession);

	User::LeaveIfError(aSprite.Construct(aWindow,TPoint(),aFlags));

	CleanupClosePushL(aSprite);

	TSpriteMember member;

	iTest->SetUpMember(member);

	member.iBitmap=&iSpriteBitmap;

	User::LeaveIfError(aSprite.AppendMember(member));

	User::LeaveIfError(aSprite.Activate());

	}

void CTScreenModeScaling::TestGetInvalidRegionL(TRect& aRect)

	{

	RRegion testRegion;

	RRegion invalid;

	iTestWin->Invalidate(aRect);

	testRegion.AddRect(aRect);

	iTestWin->Win()->GetInvalidRegion(invalid);

	CleanupClosePushL(testRegion);

	CleanupClosePushL(invalid);

	CompareRegionsL(testRegion, invalid);

	CleanupStack::PopAndDestroy(2, &testRegion);

	TheClient->WaitForRedrawsToFinish();

	}

void CTScreenModeScaling::CopyAndCompareL()

	{

	TInt oldOrdinalPriority = TheClient->iGroup->GroupWin()->OrdinalPriority();

	TInt oldOrdinalPosition = TheClient->iGroup->GroupWin()->OrdinalPosition();

	// the following line makes sure that a console object hidden outside of

	// screens range doesn't affect test results ocerlapping the bitmap window

	TheClient->iGroup->GroupWin()->SetOrdinalPosition(0, 65535); 

	// clear the content of bitmap before it is used for copying

	ClearBitmap(iScreenBitmap);	

	// Copy first half or second half of the screen to a bitmap then paste it to second or first half of the screen

	TRect testWinRect(PhysicalToLogical(TPoint((Copy2ndHalfOfScreen ? FullScreenModeSize.iWidth/2 : 0),0)-iCurrentScreenModeOrigin,iCurrentScreenModeScale),

					  PhysicalToLogical(TPoint((Copy2ndHalfOfScreen ? FullScreenModeSize.iWidth : FullScreenModeSize.iWidth/2),FullScreenModeSize.iHeight)-iCurrentScreenModeOrigin,iCurrentScreenModeScale)

					  );

	TheClient->iScreen->CopyScreenToBitmap(iScreenBitmap,testWinRect);

	iBitmapWin->SetExt(PhysicalToLogical(TPoint((Copy2ndHalfOfScreen ? 0 : FullScreenModeSize.iWidth/2),0)-iCurrentScreenModeOrigin,iCurrentScreenModeScale),testWinRect.Size());

	iBitmapWin->SetVisible(ETrue);

	iBitmapWin->DrawNow();

	TheClient->Flush();

	TestRect();

	iBitmapWin->SetVisible(EFalse);

	iTestWin->SetVisible(EFalse);

	TheClient->Flush();

	TheClient->iGroup->GroupWin()->SetOrdinalPosition(oldOrdinalPosition, oldOrdinalPriority); 

	}

/**

@SYMTestCaseID		GRAPHICS-WSERV-0093

@SYMDEF             DEF081259, DEF111847

@SYMTestCaseDesc    Window tests

					REQUIREMENT: PREQ673 (Screen Scaling)

					API: RWindowBase::InquireOffset(), RWindowBase::AbsPosition(),RWindowBase::Position()

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Loops through all the screen modes present in the wsini file, and then moves to the test screen

	mode where it goes on changing the screen scale and origin. In each of the wsini screen modes and test

	screen modes, it checks the test window's API's RWindowBase::InquireOffset(), RWindowBase::AbsPosition()

	RWindowBase::Position(). Then it copies the content from either first or second half to second or first

	half and compares both the regions so that its content are same.

	Additionally, as part of defect fix DEF111847, this also loops through all the display modes, and if possible

	tests each with the above described method. Previously, it use to only test Color256.

@SYMTestExpectedResults The content of both halves of the screen should match.

*/		

void CTScreenModeScaling::WindowTestsL()

	{

	INFO_PRINTF1(_L("AUTO  WindowTests : "));

	TDisplayMode curDispMode; // Holds the current display mode being tested 

	for(curDispMode = EGray2; curDispMode < EColorLast; curDispMode = TDisplayMode(curDispMode+1))

		{

		if (curDispMode == ERgb)

			{

			continue;

			}

		CTClient* client=new(ELeave) CTClient();

		CleanupStack::PushL(client);

		client->SetScreenNumber(iTest->iScreenNumber);

		client->ConstructL();

		client->iGroup=new(ELeave) TestWindowGroup(client);

		client->iGroup->ConstructL();

		client->iGroup->WinTreeNode()->SetOrdinalPosition(1);

		RBlankWindow testWindow(client->iWs);

		User::LeaveIfError(testWindow.Construct(*TheClient->iGroup->GroupWin(),ENullWsHandle));

		CleanupClosePushL(testWindow);

		TInt setDispMode; // Holds the actual display mode that was set

		setDispMode = testWindow.SetRequiredDisplayMode(curDispMode);

		//Only do the tests if the requested mode was actually set

		if(curDispMode == setDispMode)

			{

			//Create and show DisplayMode details message

			_LIT(KModeDetails, "Display Mode: ");

			TBuf<30> modeDetailsMessage(KModeDetails);

			modeDetailsMessage.Append(DisplayModeAsString(curDispMode));

			LOG_MESSAGE(modeDetailsMessage);

			testWindow.Activate();

			TheClient->iGroup->GroupWin()->EnableScreenChangeEvents();

			TInt numOfModes=TheClient->iScreenModes.Count();

			TInt ii;

			for (ii=0; ii<numOfModes; ++ii)

				{

				INFO_PRINTF1(_L(" Start of Loop"));

				iCurrentMode=TheClient->iScreenModes[ii];

				TPixelsAndRotation pixelsAndRotation;

				iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(iCurrentMode);

				iCurrentScreenModeScale=TheClient->iScreen->GetScreenModeScale(iCurrentMode);

				TheClient->iScreen->GetScreenModeSizeAndRotation(iCurrentMode,pixelsAndRotation);

				if (pixelsAndRotation.iRotation==CFbsBitGc::EGraphicsOrientationNormal)

					{

					INFO_PRINTF1(_L(" Do Tests"));

					TRAPD(ret,DoWindowTestsL());

					TEST(ret==KErrNone);

					if (ret!=KErrNone)

						{

						INFO_PRINTF3(_L("DoWindowTestsL() return value  - Expected: %d, Actual: %d"), KErrNone, ret);		

						}

					INFO_PRINTF1(_L(" Window Trees"));

					client->iScreen->SetAppScreenMode(iCurrentMode);

					client->Flush();

					}

				}

				TestDifferentScales(numOfModes-1);

			}

		CleanupStack::PopAndDestroy(2,client);

		}

	}

void CTScreenModeScaling::TestDifferentScales(TInt aLastModeIdx)

	{

	if (aLastModeIdx<0) return;

	TPixelsAndRotation pixelsAndRotation;

	for (TInt modeCount=aLastModeIdx;modeCount>=0;--modeCount)

		{

		TheClient->iScreen->GetScreenModeSizeAndRotation(TheClient->iScreenModes[modeCount],pixelsAndRotation);

		if (pixelsAndRotation.iRotation==CFbsBitGc::EGraphicsOrientationNormal)

			break;

		}

	iCurrentMode=TheClient->iScreenModes[aLastModeIdx];

	TheClient->iScreen->SetAppScreenMode(iCurrentMode);

	TheClient->iScreen->SetScreenMode(iCurrentMode);

	TSizeMode storeModeData=TheClient->iScreen->GetCurrentScreenModeAttributes();

	TSizeMode testMode=storeModeData;

	for (TInt xScale=1;xScale<4;++xScale)

		{

		for (TInt yScale=1;yScale<4;++yScale)

			{

			testMode.iScreenScale=TSize(xScale,yScale);

			TestDifferentOrigin(testMode,TPoint(20,20));

			TestDifferentOrigin(testMode,TPoint(20,30));

			TestDifferentOrigin(testMode,TPoint(30,20));

			TestDifferentOrigin(testMode,TPoint(FullScreenModeSize.iWidth/2+640/FullScreenModeSize.iWidth*10,60));

			}

		}

	TheClient->iScreen->SetScreenMode(iCurrentMode);

	TheClient->iScreen->SetCurrentScreenModeAttributes(storeModeData);

	TInt defaultMode=TheClient->iScreenModes[0];

	TheClient->iScreen->SetAppScreenMode(defaultMode);

	TheClient->iScreen->SetScreenMode(defaultMode);

	}

void CTScreenModeScaling::TestDifferentOrigin(TSizeMode &aMode,TPoint aOrigin)

	{

	TheClient->iScreen->SetScreenMode(iCurrentMode);//.. this is required because at the end of next screenmode test it will be set to zero screen mode

	aMode.iOrigin=aOrigin;

	TheClient->iScreen->SetCurrentScreenModeAttributes(aMode);

	TheClient->iScreen->SetAppScreenMode(iCurrentMode);

	TheClient->iScreen->SetScreenMode(iCurrentMode);

	iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(iCurrentMode);

	iCurrentScreenModeScale=TheClient->iScreen->GetScreenModeScale(iCurrentMode);

	TRAPD(ret,DoWindowTestsL());

	TEST(ret==KErrNone);

	if (ret!=KErrNone)

		INFO_PRINTF3(_L("DoWindowTestsL() return value  - Expected: %d, Actual: %d"), KErrNone, ret);		

	}

void CTScreenModeScaling::DoWindowTestsL()

	{

	TheClient->iScreen->SetAppScreenMode(iCurrentMode);

	TheClient->iScreen->SetScreenMode(iCurrentMode);

	Copy2ndHalfOfScreen=(iCurrentScreenModeOrigin.iX>FullScreenModeSize.iWidth/2? 1 : 0);

	TRect testWinRect(PhysicalToLogical(TPoint(),iCurrentScreenModeScale),

					  PhysicalToLogical(TPoint((Copy2ndHalfOfScreen ? FullScreenModeSize.iWidth 

																	: FullScreenModeSize.iWidth/2),

											   FullScreenModeSize.iHeight)-iCurrentScreenModeOrigin,iCurrentScreenModeScale) 

					  );

	testWinRect.Shrink(10,10);

	iTestWinSize=testWinRect.Size();

	PositionTestL(testWinRect.iTl);

	testWinRect.Shrink(10,10);

	iTestWinSize=testWinRect.Size();

	PositionTestL(testWinRect.iTl);

	BackedUpChildWindowTestL(testWinRect.iTl);

	GetInvalidRegionTestL(testWinRect.iTl);

	//NextScreenModeTestL(testWinRect.iTl);		//This test needs a lot more work ###

	}

void CTScreenModeScaling::PositionTestL(TPoint aPostion)

	{

	iTestWin->SetExt(aPostion,iTestWinSize);

	iTestWin->SetVisible(ETrue);

	iTestWin->Invalidate();

	TheClient->Flush();

	TheClient->WaitForRedrawsToFinish();

	TestTopClientWindowPositionAPIs(aPostion,iTestWin->BaseWin());

	CopyAndCompareL();

	}

void CTScreenModeScaling::BackedUpChildWindowTestL(TPoint aPostion)

	{

	iTestWin->SetVisible(ETrue);

	TPoint backedUpWinPt=TPoint(iTestWinSize.iWidth/3,iTestWinSize.iHeight/4);

	iBackedUpWin->SetExtL(backedUpWinPt,TSize(iTestWinSize.iWidth/6,iTestWinSize.iHeight/6));

	iBackedUpWin->SetVisible(ETrue);

	TestChildWindowPositionAPIs(backedUpWinPt,aPostion,iBackedUpWin->BaseWin(),iTestWin->BaseWin());

	aPostion+=TPoint(10,10);

	iTestWin->SetPos(aPostion);

	TestTopClientWindowPositionAPIs(aPostion,iTestWin->BaseWin());

	TestChildWindowPositionAPIs(backedUpWinPt,aPostion,iBackedUpWin->BaseWin(),iTestWin->BaseWin());

	iTestWin->Invalidate();

	TheClient->Flush();

	TheClient->WaitForRedrawsToFinish();

	TestTopClientWindowPositionAPIs(aPostion,iTestWin->BaseWin());

	TestChildWindowPositionAPIs(backedUpWinPt,aPostion,iBackedUpWin->BaseWin(),iTestWin->BaseWin());

	CopyAndCompareL();

	iBackedUpWin->SetVisible(EFalse);

	}

void CTScreenModeScaling::NextScreenModeTestL(TPoint aPos)

	{

	TInt numOfModes=TheClient->iScreenModes.Count();

	TInt defaultMode=TheClient->iScreenModes[0];

	TInt lastMode=TheClient->iScreenModes[numOfModes-1];

	TInt mode=(iCurrentMode<lastMode? iCurrentMode:defaultMode);

	// find current mode index

	TInt ii;

	TInt modeIdx=0;

	for (ii=0; ii<numOfModes; ++ii)

		{

		if (mode==TheClient->iScreenModes[ii])

			{

			modeIdx=ii;

			break;

			}

		}

	TPoint screenModeOrigin(0,0);

	TPixelsAndRotation pixelsAndRotation;

	while (screenModeOrigin==TPoint()||(pixelsAndRotation.iRotation!=CFbsBitGc::EGraphicsOrientationNormal))

		{

		mode=(mode==lastMode? defaultMode : TheClient->iScreenModes[++modeIdx]);

		if (mode==iCurrentMode)

			{

			return;

			}

		screenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(mode);

		TheClient->iScreen->GetScreenModeSizeAndRotation(mode,pixelsAndRotation);

		}

	iTestWin->SetExt(aPos,iTestWinSize);

	iTestWin->SetVisible(ETrue);