// 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 positioning CR

// GT 0164 Uikon: A3.26. IM 9.

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

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

// Note this feature is also in GT0199 as PREQ673"Screen Positioning".

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

// eg it is now possible to set in wsini.ini the position on the

// physical screen where the origin of the screen mode's screen will appear.

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TSCREENMODEPOSITIONING.H"

#include <graphics/displaycontrol.h>

//#define LOGGING on		//Uncomment this line to get extra logging useful when there is a tests that fails

LOCAL_D TSize FullScreenModeSize;

LOCAL_D TDisplayMode ScreenDisplayMode;

LOCAL_D TInt Copy2ndHalfOfScreen;

void CBasicWin::Draw()

	{

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iGc->SetPenStyle(CGraphicsContext::ENullPen);

	iGc->SetBrushColor(TRgb(255,0,0));

	TSize winSize=Size();

	iGc->DrawRect(TRect(winSize));

	iGc->SetBrushColor(TRgb(0,221,221));

	iGc->DrawEllipse(TRect(TPoint(winSize.iWidth/2,winSize.iHeight/2),winSize));

	iGc->DrawEllipse(TRect(TPoint(-winSize.iWidth/2,-winSize.iHeight/2),winSize));

	iDrawn=ETrue;

	}

void CSpriteWin::UpdateState(TInt aState)

	{

	SetState(aState);

	DrawNow();

	}

TPoint CheckSpritePos(233,60);

TPoint CheckSpritePos2(18,60);

void CSpriteWin::Draw()

	{

	switch(iState)

		{

		case 0:

			iGc->BitBlt(CheckSpritePos,&iSpriteBitmap);

			break;

		case 1:

			iGc->BitBlt(CheckSpritePos+TPoint(30,30),&iSpriteBitmap);

			iGc->BitBlt(CheckSpritePos,&iSpriteBitmap);

			break;

		case 2:

			iGc->BitBlt(CheckSpritePos2+TPoint(-10,40),&iSpriteBitmap);

			iGc->BitBlt(CheckSpritePos2+TPoint(-10,20),&iSpriteBitmap);

			break;

		case 3:

			iGc->BitBlt(TPoint(),&iSpriteBitmap);

			break;

		default:

			break;

		}

	}

CSpriteWin::~CSpriteWin()

	{

	}

void CBmpWin::Draw()

	{

	iGc->BitBlt(TPoint(),&iScreenBmp);

	}

CConnection2::~CConnection2()

	{

	delete iScreenBitmap;

	delete iBitmapWin;

	delete iSpriteWin;

	iGroup->GroupWin()->EnableReceiptOfFocus(EFalse);

	delete iGroup;

	delete iClient;

	}

void CConnection2::ConstructL(CTestBase *aTest,CFbsBitmap& aBitmap)

	{

	iClient=new(ELeave) CTClient;

	iClient->SetScreenNumber(aTest->ScreenNumber());

	iClient->ConstructL();

	iGroup=new(ELeave) CConnection2Group(iClient,this,aTest);

	iGroup->ConstructL();

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

	iClient->Flush();

	iSpriteWin=new(ELeave) CSpriteWin(aBitmap);

	iSpriteWin->ConstructExtLD(*iGroup,TPoint(),TSize(433,240));

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

	iSpriteWin->AssignGC(*iClient->iGc);

	iSpriteWin->Activate();

	iSpriteWin->SetVisible(EFalse);

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

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

	iScreenBitmap=new(ELeave) CFbsBitmap();

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

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

	iBitmapWin->ConstructExtLD(*iGroup,TPoint(FullScreenModeSize.iWidth/2,0),iScreenBitmap->SizeInPixels());

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

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

	iBitmapWin->Activate();

	iBitmapWin->SetVisible(EFalse);

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

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

	}

void CConnection2::DrawBitmapWin()

	{

	TPoint pos=(Copy2ndHalfOfScreen? TPoint() : TPoint(FullScreenModeSize.iWidth/2,0));

	iBitmapWin->SetPos(pos);

	iBitmapWin->SetVisible(ETrue);

	iBitmapWin->DrawNow();

	iClient->Flush();

	}

CConnection2Group::CConnection2Group(CTClient *aClient, CConnection2 *aSecondConnection, CTestBase *aTest) : CTWindowGroup(aClient), iTest(aTest), iConnection2(aSecondConnection)

	{}

//CTScreenModePositioning

CTScreenModePositioning::CTScreenModePositioning(CTestStep* aStep) : CTWsGraphicsBase(aStep)

	{

	}

CTScreenModePositioning::~CTScreenModePositioning()

	{

	delete iTestWin;

	delete iConnection2;

	delete iBlankWin;

	delete iBackedUpWin;

	delete iTestChildWin;

	}

void CTScreenModePositioning::ConstructL()

	{

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

	iScalingSupported=CheckScalingSupportedOrNot();

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

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

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

	iConnection2=new(ELeave) CConnection2;

	iConnection2->ConstructL(iTest,iSpriteBitmap);

	iBlankWin=new(ELeave) CTBlankWindow();

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

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

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

	iBlankWin->SetVisible(EFalse);

	iBlankWin->Activate();

	iTestWin=new(ELeave) CBasicWin;

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

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

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

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

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

	iTestWin->SetVisible(EFalse);

	iTestWin->Activate();

	iBackedUpWin=new(ELeave) CTBackedUpWin(EColor256);

	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();

	//The Cursor appearing on screen will affect the result of RectCompare function. 

	//Set it to the position out of the screen

	TheClient->iWs.SetPointerCursorPosition(TPoint(-1,-1));

	}

void CTScreenModePositioning::ChangeScreenMode(CTClient* aClient,TPixelsAndRotation aPixelsAndRotation,TInt aMode)

	{

	ChangeScreenMode(aClient,aPixelsAndRotation,ESizeEnforcementNone,aMode);

	}

void CTScreenModePositioning::ChangeScreenMode(CTClient* aClient,TPixelsAndRotation aPixelsAndRotation,TScreenModeEnforcement aScreenModeEnforcement,TInt aMode)

	{

	aClient->iScreen->SetScreenSizeAndRotation(aPixelsAndRotation);

	aClient->iScreen->SetScreenModeEnforcement(aScreenModeEnforcement);

	aClient->iScreen->SetScreenMode(aMode);

	}

void CTScreenModePositioning::SetScreenMode(CTClient* aClient,TInt aMode,TScreenModeEnforcement aScreenModeEnforcement)

	{

	TPixelsAndRotation pixelsAndRotation;

	aClient->iScreen->SetScreenModeEnforcement(aScreenModeEnforcement);

	aClient->iScreen->SetScreenMode(aMode);

	aClient->iScreen->GetDefaultScreenSizeAndRotation(pixelsAndRotation);

	aClient->iScreen->SetScreenSizeAndRotation(pixelsAndRotation);

	aClient->Flush();

	}

void CTScreenModePositioning::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());

	}

/**

@SYMTestCaseID		GRAPHICS-WSERV-0098

@SYMDEF  			DEF081259

@SYMTestCaseDesc    Window Tests. Please see test cases GRAPHICS-WSERV-(0099-0103) which are a subset of this test case.

					REQUIREMENT: CR PHAR-5SJGAM, PREQ673

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Tests on windows in different screen modes each with differing screen mode origin's defined in the

					wsini file. This test case only tests screen modes with 0 orientation.

					Goes through each screen mode defined in the wsini file and exercises test cases GRAPHICS-WSERV-(0099-0103) for each mode.

					For more details see test cases GRAPHICS-WSERV-(0099-0103) which are a subset of this test case.

@SYMTestExpectedResults

*/

void CTScreenModePositioning::WindowTestsL()

	{

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

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

	TInt ii;

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

		{

		iCurrentMode=TheClient->iScreenModes[ii];

		TPixelsAndRotation pixelsAndRotation;

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

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

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

		iCurrentScreenModeSize=pixelsAndRotation.iPixelSize;

		if (iCurrentScreenModeOrigin.iX<=FullScreenModeSize.iWidth/2-10 /*&& iCurrentScreenModeOrigin!=TPoint() */&& pixelsAndRotation.iRotation==CFbsBitGc::EGraphicsOrientationNormal)

			{

		#if defined(LOGGING)

			_LIT(KLog,"Test mode %d");

			LOG_MESSAGE2(KLog,ii);

		#endif

			TRAPD(ret,DoWindowTestsL());

			if (ret==KErrNone)

				continue;

			RestoreScreenMode();

			if (ret<KErrNone)

				TEST(EFalse);

			else

				User::Leave(ret);

			}

		}

	}

void CTScreenModePositioning::DoWindowTestsL()

	{

	// Make this visible so that the display mode remains EColor256

	iBlankWin->SetVisible(ETrue);

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

	TInt testWinWidth=Max(FullScreenModeSize.iWidth/2-iCurrentScreenModeOrigin.iX,iCurrentScreenModeOrigin.iX-FullScreenModeSize.iWidth/2);

	iTestWinSize=TSize(testWinWidth,FullScreenModeSize.iHeight-iCurrentScreenModeOrigin.iY-60);

	iTestWinSize.iWidth/=(iCurrentScreenModeScale.iWidth > 1 ? iCurrentScreenModeScale.iWidth*2 : iCurrentScreenModeScale.iWidth);

	iTestWinSize.iHeight/=(iCurrentScreenModeScale.iHeight > 1 ? iCurrentScreenModeScale.iHeight*2 : iCurrentScreenModeScale.iHeight);

#if defined(LOGGING)

	_LIT(KLog1,"  PosTest1");

	LOG_MESSAGE(KLog1);

#endif

	PositionTest1L(TPoint());

#if defined(LOGGING)

	_LIT(KLog2,"  PosTest2");

	LOG_MESSAGE(KLog2);

#endif

	PositionTest1L(TPoint(25,35));

#if defined(LOGGING)

	_LIT(KLog3,"  PosTest3");

	LOG_MESSAGE(KLog3);

#endif

	PositionTest2L(TPoint(10,10));

#if defined(LOGGING)

	_LIT(KLog4,"  GetInvalidRegion");

	LOG_MESSAGE(KLog4);

#endif

	GetInvalidRegionTestL(TPoint(10,10));

#if defined(LOGGING)

	_LIT(KLog5,"  CreateWin1");

	LOG_MESSAGE(KLog5);

#endif

	CreateWindowsTestL(TPoint());

#if defined(LOGGING)

	_LIT(KLog6,"  CreateWin2");

	LOG_MESSAGE(KLog6);

#endif

	CreateWindowsTestL(TPoint(33,15));

#if defined(LOGGING)

	_LIT(KLog7,"  NextMode");

	LOG_MESSAGE(KLog7);

#endif

	NextScreenModeTestL(TPoint(12,6));

	}

/**

@SYMTestCaseID		GRAPHICS-WSERV-0099

@SYMDEF  			DEF081259

@SYMTestCaseDesc    Position Test 1

					REQUIREMENT: CR PHAR-5SJGAM, PREQ673

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

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Sets the new screen mode on the main client's screen device. Checks that an window whose group window

					has this screen device is in the correct position and for the origin of the new screen mode.

					(Does this by copying the window to a bitmap, switching back to screen mode 0 and then setting the position

					of the window to be the expected position. Then the bitmap is blitted to the other half of the screen and the

					2 halves of the screen compared)

@SYMTestExpectedResults Checks the window is positioned correctly for the origin of the new screen mode.

*/

void CTScreenModePositioning::PositionTest1L(TPoint aPos)

	{

    ((CTScreenModePositioningStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0099"));    

	SetScreenMode(TheClient,iCurrentMode,ESizeEnforcementPixelsAndRotation);

	iTestWin->SetExt(aPos,iTestWinSize);

	iTestWin->SetVisible(ETrue);

	iTestWin->Invalidate();

	TheClient->Flush();

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

	TheClient->WaitForRedrawsToFinish();

	CopyAndCompareL(aPos);

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

	}

template <TBool newstate>

class TCleanupSetVisible:public TCleanupItem

	{

	static void Cleanup(void*v)

		{

			((CTWinBase*)v)[0].SetVisible(newstate);

		}

	public:

	TCleanupSetVisible(CTWinBase* v): 

		TCleanupItem(Cleanup,v)	

		{}

	};

/**

@SYMTestCaseID		GRAPHICS-WSERV-0100

@SYMDEF  			DEF081259

@SYMTestCaseDesc    Position Test 2

					REQUIREMENT: CR PHAR-5SJGAM, PREQ673

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

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     As in test case GRAPHICS-WSERV-0099 but also tests moving and resizing the window and also does these tests on a backed up child window.

@SYMTestExpectedResults Checks both the windows are positioned correctly for the origin of the new screen mode.

*/

void CTScreenModePositioning::PositionTest2L(TPoint aPos)

	{

	((CTScreenModePositioningStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0100"));

	SetScreenMode(TheClient,iCurrentMode,ESizeEnforcementPixelsAndRotation);

	iTestWin->SetPos(aPos);

	CleanupStack::PushL(TCleanupSetVisible<EFalse>(iBackedUpWin));

	iTestWin->SetVisible(ETrue);

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

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

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

	iBackedUpWin->SetVisible(ETrue);

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

	aPos+=TPoint(20,20);

	iTestWin->SetPos(aPos);

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

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

	iTestWin->Invalidate();

	TheClient->Flush();

	TheClient->WaitForRedrawsToFinish();

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

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

	CopyAndCompareL(aPos);

	CleanupStack::PopAndDestroy(iBackedUpWin);	//TCleanupSetVisible

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

	}

/**

@SYMTestCaseID		GRAPHICS-WSERV-0101

@SYMDEF  			DEF081259

@SYMTestCaseDesc    Invalid Region Test

					REQUIREMENT: CR PHAR-5SJGAM, PREQ673

					API: RWindow::GetInvalidRegion()

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Sets the new screen mode, then invalidates different parts of the test window. Checks that the above API gets

					the correct invalid area from the server. Also tests moving the invalid area.

@SYMTestExpectedResults Checks the invalid region is correct for the origin of the new screen mode.

*/

void CTScreenModePositioning::GetInvalidRegionTestL(TPoint aPos)

	{

	((CTScreenModePositioningStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0101"));

	SetScreenMode(TheClient,iCurrentMode,ESizeEnforcementPixelsAndRotation);

	iTestWin->SetExt(aPos,iTestWinSize);

	iTestWin->SetVisible(ETrue);

	iTestChildWin->SetExt(TPoint(iTestWinSize.iWidth>>2,iTestWinSize.iHeight>>2),TSize(iTestWinSize.iWidth>>1,iTestWinSize.iHeight>>1));

	iTestChildWin->SetVisible(ETrue);

	iTestWin->Win()->BeginRedraw();

	iTestWin->Win()->EndRedraw();

	const TInt KNumRects=3;

	TRect rects[KNumRects];

	rects[0]=TRect(1,1,5,2);

	rects[1]=TRect(TPoint(iTest->StdTestWindowSize().iWidth>>1,iTest->StdTestWindowSize().iHeight>>1),iTest->StdTestWindowSize());

	rects[2]=TRect(2,0,4,5);

	RRegion region;

	CleanupClosePushL(region);

	for (TInt index=0;index<KNumRects;++index)

		{

		iTestWin->Invalidate(rects[index]);

		region.AddRect(rects[index]);

		}

	//PeterI original wserv assumes a region hidden beneath a child is not invalid

	//Mk3 doesn't make this assumption 

	//TRect subRect;

	//subRect.iTl=iTestChildWin->BaseWin()->InquireOffset(*iTestWin->BaseWin());

	//subRect.SetSize(iTestChildWin->Size());

	//region.Tidy();

	//region.SubRect(subRect);

	//region.ClipRect(TRect(iTestWin->Size()));

	RRegion invalidRegion;

	CleanupClosePushL(invalidRegion);

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

	CompareRegionsL(region,invalidRegion);

	CleanupStack::PopAndDestroy(2,&region);

	TheClient->Flush();

	TheClient->WaitForRedrawsToFinish();

	iTestChildWin->SetVisible(EFalse);

	TRect rect1(TPoint(0,0),iTestWinSize);

	TestGetInvalidRegionL(rect1);

	TInt width=iTestWinSize.iWidth;

	TInt height=iTestWinSize.iHeight;

	TRect rect2(TPoint(width/6,height/6),TSize(width/3,height/3));

	TestGetInvalidRegionL(rect2);

	iTestWin->Invalidate();

	iTestWin->SetPos(TPoint(15,15));

	iTestWin->SetPos(TPoint());

	iTestWin->SetPos(TPoint(-15,-15));

	iTestWin->SetPos(aPos);

	RRegion invalid;

	RRegion testRegion(rect1);

	CleanupClosePushL(invalid);

	CleanupClosePushL(testRegion);

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

	TBool err=invalid.CheckError();

	TEST(!err);

	if (err)

		{

		_LIT(KLog,"Returned Invalid Region has an error");

		LOG_MESSAGE(KLog);

		}

	TEST(invalid.BoundingRect().iBr.iX<=iTestWinSize.iWidth);

	if (invalid.BoundingRect().iBr.iX>iTestWinSize.iWidth)

		{

		_LIT(KLog,"Invalid Region extends beyond right edge of window");

		LOG_MESSAGE(KLog);

		}

	CompareRegionsL(testRegion,invalid);

	CleanupStack::PopAndDestroy(2,&invalid);

	iTestWin->DrawNow();

	TheClient->Flush();

	CopyAndCompareL(aPos);

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

	}

void CTScreenModePositioning::CopyAndCompareL(TPoint aPos)

	{

	CopyScreenAndChangeBackToDefScrModeL();

	iTestWin->SetPos(iCurrentScreenModeOrigin+aPos);