// 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 screen mode switching

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TSCRMODE.H"

const TInt KBlankWinPosX=10;

const TInt KBlankWinPosY=20;

const TInt KBlankWinSizeX=30;

const TInt KBlankWinSizeY=25;

const TInt KScreenMode0=0;

const TInt KScreenMode1=1;

_LIT(KScreenModeDisplayMode,"GetScreenModeDisplayMode");

CTScrMode::CTScrMode(CTestStep* aStep) : CTWsGraphicsBase(aStep)

	{

	}

//

// Static func to check windows

//

LOCAL_C TInt DoPanicTest(TInt aInt, TAny *aScreenNumber)

	{

	RWsSession ws;

	CWsScreenDevice *screen=NULL;

	if (ws.Connect()==KErrNone)

		{

		screen = new (ELeave) CWsScreenDevice(ws);

		if (screen && screen->Construct((TInt)aScreenNumber)==KErrNone)

			{

			TPixelsTwipsAndRotation sar;

			CFbsBitGc::TGraphicsOrientation rot=CFbsBitGc::EGraphicsOrientationNormal;

			TInt mode=0;

			switch(aInt)

				{

				case 0:

				case 1:

					screen->SetScreenMode(aInt==0?1000:-1);

					break;

				case 2:

				case 3:

					screen->GetScreenModeSizeAndRotation(aInt==2?screen->NumScreenModes():-100000, sar);

					break;

				case 4:

				case 5:

					screen->GetScreenModeSizeAndRotation(aInt==4?screen->NumScreenModes()+100:-10, sar);

					break;

				case 6:

					mode=screen->NumScreenModes();

					goto SetRot;

				case 7:

					mode=-55;

					goto SetRot;

				case 8:

					mode=234;

					goto SetRot;

				case 9:

					mode=screen->NumScreenModes()+2;

					rot=CFbsBitGc::EGraphicsOrientationRotated270;

				SetRot:

					screen->SetCurrentRotations(mode,rot);

					break;

				case 10:

				case 11:

					ws.SetPointerCursorArea(aInt==10?1000:-1,TRect());

					break;

				case 12:

				case 13:

					ws.PointerCursorArea(aInt==12?1003:-2);

					break;

				case 14:

				case 15:

					{

					CArrayFixFlat<TInt> *rotations=new(ELeave) CArrayFixFlat<TInt>(1);

					screen->GetRotationsList(aInt==12?1003:-2,rotations);

					}

					break;

				case 100:

					rot=CFbsBitGc::EGraphicsOrientationRotated90;

					goto SetRot;

				case 101:

					rot=CFbsBitGc::EGraphicsOrientationRotated270;

					goto SetRot;

				case 102:

					mode=1;

					rot=CFbsBitGc::EGraphicsOrientationRotated270;

					goto SetRot;

				case 103:

					mode=1;

				#if defined(__EPOC32__)

					rot=CFbsBitGc::EGraphicsOrientationRotated180;

				#else

					rot=CFbsBitGc::EGraphicsOrientationNormal;

				#endif

					goto SetRot;

				}

			ws.Flush();

			}

		}

	return(EWsExitReasonBad);

	}

void SetupTestRWindowLC(RWindow& aWindow, const TPoint& aPos, const TSize& aSize, TDisplayMode aDisplayMode)

	{

	CleanupClosePushL(aWindow);

	User::LeaveIfError(aWindow.Construct(*TheClient->iGroup->GroupWin(), (TUint)&aWindow));

	aWindow.SetExtent(aPos, aSize);

	User::LeaveIfError(aWindow.SetRequiredDisplayMode(aDisplayMode));

	aWindow.Activate();

	}

void CTScrMode::TestPanicsL()

	{

	TInt ii;

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

		TEST(iTest->TestWsPanicL(DoPanicTest,EWservPanicScreenModeNumber,ii,(TAny*)iTest->iScreenNumber));

	for (ii=100;ii<104;++ii)

		TEST(iTest->TestWsPanicL(DoPanicTest,EWservPanicRotation,ii,(TAny*)iTest->iScreenNumber));

	iTest->CloseAllPanicWindows();

	}

CTScrMode::~CTScrMode()

	{

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

	delete iSecondConnection;

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

	SetScreenModeEnforcement(iOldEnfMode);

	}

void CTScrMode::ConstructL()

	{

	//Remove next line when bitmaps are stored correctly

	TestWin->Win()->EnableRedrawStore(EFalse);

	BaseWin->Win()->EnableRedrawStore(EFalse);

//

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

//

	//TheClient->iWs.SetAutoFlush(ETrue);

	ValidateWin(BaseWin,TRgb::Gray256(204));

	ValidateWin(TestWin,TRgb::Gray256(204));

//

	iWinState=0;

	iWinPos=TPoint(2*TheClient->iGroup->Size().iWidth/3,0);

//

	iSecondConnection=new(ELeave) CSecondConnection;

	iSecondConnection->ConstructL(iTest->iScreenNumber, TRect(KBlankWinPosX,KBlankWinPosY,KBlankWinPosX+KBlankWinSizeX,KBlankWinPosY+KBlankWinSizeY),iTest,iStep);

//

	iOldEnfMode=TheClient->iScreen->ScreenModeEnforcement();

	if (TheClient->iScreenModes.Count()<2)

		{

		iTest->iState=1000;	// Miss all tests

		_LIT(KLog,"Skipping all tests as less that 2 screen size modes");

		LOG_MESSAGE(KLog);

		}

	else

		{

		SetScreenModeEnforcement(ESizeEnforcementNone);

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

		}

	}

void CTScrMode::SetScreenModeEnforcement(TScreenModeEnforcement aMode)

	{

	iCurEnforcement=aMode;

	TheClient->iScreen->SetScreenModeEnforcement(iCurEnforcement);

	}

void CTScrMode::ScaledDrawingL()

	{

	const TInt KLineXPos=10;

	const TInt KLineYPos=30;

	const TInt KLineLength=10;

	const TInt KXScaleFactor=4;

	const TInt KYScaleFactor=3;

//

	// Draw rectangle onto TestWin

 	CWindowGc *gc=TheClient->iGc;

	gc->Activate(*(TestWin->Win()));

	gc->SetBrushColor(KRgbBlack);

	gc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	gc->DrawRect(TRect(TPoint(KLineXPos,KLineYPos),TSize(KLineLength*KXScaleFactor,KYScaleFactor)));

	gc->Deactivate();

//

	// Draw scaled bitmap onto BaseWin

	TSize bitSize(KLineLength,1);

	TSize bitTwipSize(TheClient->iScreen->HorizontalPixelsToTwips(bitSize.iWidth*KXScaleFactor),

					  TheClient->iScreen->VerticalPixelsToTwips(bitSize.iHeight*KYScaleFactor));

	CFbsBitGc *bitGc=NULL;

	CFbsBitmapDevice *device=NULL;

	CFbsBitmap *bitmap=NULL;

	bitmap=new(ELeave) CFbsBitmap();

	CleanupStack::PushL(bitmap);

	User::LeaveIfError(bitmap->Create(bitSize,EGray16));

	bitmap->SetSizeInTwips(bitTwipSize);

	device=CFbsBitmapDevice::NewL(bitmap);

	CleanupStack::PushL(device);

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

	bitGc->SetBrushColor(KRgbBlack);

	bitGc->Clear();

	delete bitGc;

//

 	gc->Activate(*(BaseWin->Win()));

	gc->DrawBitmap(TPoint(KLineXPos,KLineYPos),bitmap);

	gc->Deactivate();

//

	TheClient->iWs.Flush();

	CleanupStack::PopAndDestroy(2);	// bitmap,device

	CompareWindows(_L("CTScrMode::ScaledDrawingL() CompareWindows() failed"));

	}

void CTScrMode::ValidateWin(TestWindow *aWin, TRgb aColor)

	{

	aWin->Win()->Invalidate();

	RedrawWin(*aWin->Win(),aColor);

	}

void CTScrMode::RedrawWin(RWindow &aWin, TRgb aColor)

	{

	aWin.BeginRedraw();

	TheClient->iGc->Activate(aWin);

	TheClient->iGc->SetBrushColor(aColor);

	TheClient->iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	TheClient->iGc->SetPenStyle(CGraphicsContext::ENullPen);

	TheClient->iGc->Clear();

	TheClient->iGc->Deactivate();

	aWin.EndRedraw();

	}

void CTScrMode::CheckWindows(TBool aWinIsVis)

	{

	iSecondConnection->SetWindow2Visibility(aWinIsVis);

	TheClient->WaitForRedrawsToFinish();

	TheClient->iWs.Finish();

	CompareWindows(_L("CTScrMode::CheckWindows() CompareWindows() failed"));

	}

void CTScrMode::ScreenRotationsL()

	{

	CWsScreenDevice *screen=TheClient->iScreen;

	CArrayFixFlat<TInt> *rotations=new(ELeave) CArrayFixFlat<TInt>(1);

	CFbsBitGc::TGraphicsOrientation currentRotation;

	TPixelsAndRotation sizeAndRotation;

	TPixelsTwipsAndRotation sizeAndRotation2;

	TBool found;

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

	TInt count;

	TInt ii,jj;

	CleanupStack::PushL(rotations);

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

		{

		TInt mode=TheClient->iScreenModes[ii];

		User::LeaveIfError(screen->GetRotationsList(mode,rotations));

		screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);

		screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation2);

		TEST(sizeAndRotation.iPixelSize.iWidth==sizeAndRotation2.iPixelSize.iWidth);

		if (sizeAndRotation.iPixelSize.iWidth!=sizeAndRotation2.iPixelSize.iWidth)

			INFO_PRINTF3(_L("sizeAndRotation.iPixelSize.iWidth==sizeAndRotation2.iPixelSize.iWidth  - Expected: %d, Actual: %d"), sizeAndRotation.iPixelSize.iWidth, sizeAndRotation2.iPixelSize.iWidth);

		TEST(sizeAndRotation.iPixelSize.iHeight==sizeAndRotation2.iPixelSize.iHeight);

		if (sizeAndRotation.iPixelSize.iHeight!=sizeAndRotation2.iPixelSize.iHeight)

			INFO_PRINTF3(_L("sizeAndRotation.iPixelSize.iHeight==sizeAndRotation2.iPixelSize.iHeight  - Expected: %d, Actual: %d"), sizeAndRotation.iPixelSize.iHeight, sizeAndRotation2.iPixelSize.iHeight);

		count=rotations->Count();

		TEST(count>=1);

		if (count<1)

			INFO_PRINTF3(_L("rotations->Count() return value  - Expected: %d or more, Actual: %d"), 1, count);

		TBool retVal;

		if (sizeAndRotation.iPixelSize.iWidth!=sizeAndRotation.iPixelSize.iHeight)

			{

			TEST(count<=2);

			if (count>2)

				INFO_PRINTF3(_L("rotations->Count() return value  - Expected: %d or less, Actual: %d"), 2, count);

			if (count==2)

				{

				retVal = (*rotations)[0]+2==(*rotations)[1];

				TEST(retVal);		//Must only have rotations 180 degrees apart

				if (!retVal)

					INFO_PRINTF3(_L("(*rotations)[0]+2==(*rotations)[1]  - Expected: %d, Actual: %d"), ETrue, retVal);

				}

			}

		found=EFalse;

		for (jj=0;jj<count;++jj)

			{

			if ((*rotations)[jj]==sizeAndRotation.iRotation)

				{

				retVal = (*rotations)[jj]==sizeAndRotation2.iRotation;

				TEST(retVal);

				if (!retVal)

					INFO_PRINTF3(_L("(*rotations)[jj]==sizeAndRotation2.iRotation  - Expected: %d, Actual: %d"), ETrue, retVal);

				found=ETrue;

				break;

				}

			}

		TEST(found);

		if (!found)

				INFO_PRINTF3(_L("found  - Expected: %d, Actual: %d"), ETrue, found);

		if (count>1)

			{

			currentRotation=sizeAndRotation.iRotation;

			for (jj=0;jj<count;++jj)

				{

				screen->SetCurrentRotations(mode,REINTERPRET_CAST(CFbsBitGc::TGraphicsOrientation&,(*rotations)[jj]));

				screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);

				screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation2);

				retVal = (*rotations)[jj]==sizeAndRotation.iRotation;

				TEST(retVal);

				if (!retVal)

					INFO_PRINTF3(_L("(*rotations)[jj]==sizeAndRotation.iRotation  - Expected: %d, Actual: %d"), ETrue, retVal);

				retVal = (*rotations)[jj]==sizeAndRotation2.iRotation;

				TEST(retVal);

				if (!retVal)

					INFO_PRINTF3(_L("(*rotations)[jj]==sizeAndRotation2.iRotation  - Expected: %d, Actual: %d"), ETrue, retVal);

				}

			screen->SetCurrentRotations(mode,REINTERPRET_CAST(CFbsBitGc::TGraphicsOrientation&,currentRotation));

			screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);

			screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation2);

			retVal = currentRotation==sizeAndRotation.iRotation;

			TEST(retVal);

			if (!retVal)

				INFO_PRINTF3(_L("currentRotation==sizeAndRotation.iRotation  - Expected: %d, Actual: %d"), ETrue, retVal);

			retVal = currentRotation==sizeAndRotation2.iRotation;

			TEST(retVal);

			if (!retVal)

				INFO_PRINTF3(_L("currentRotation==sizeAndRotation2.iRotation  - Expected: %d, Actual: %d"), ETrue, retVal);

			}

		}

	CleanupStack::PopAndDestroy();

	}

void CTScrMode::MoreScreenRotationsL()

	{

	RWindow shield4Gray(TheClient->iWs);

	// The default display mode needs to be updated to EColor64K for Oghma integ

	SetupTestRWindowLC(shield4Gray,TPoint(),TSize(100000,100000),EColor64K);

//

	CWsScreenDevice *screen=TheClient->iScreen;

	//CFbsBitGc::TGraphicsOrientation currentRotation;

	TPixelsAndRotation sizeAndRotation;

	TInt currentRotation;

	TInt currentMode=FindCurrentMode();

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

	TInt currentScreenMode;

	TInt count;

	TInt ii,jj;

	CArrayFixFlat<TInt> *currentRotations=new(ELeave) CArrayFixFlat<TInt>(1);

	CleanupStack::PushL(currentRotations);

	currentRotations->ResizeL(numModes);

	CArrayFixFlat<TInt> *originalRotation=new(ELeave) CArrayFixFlat<TInt>(1);

	CleanupStack::PushL(originalRotation);

	originalRotation->ResizeL(numModes);

	CArrayFixFlat<TInt> *rotations=new(ELeave) CArrayFixFlat<TInt>(1);

	CleanupStack::PushL(rotations);

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

		{

		TInt mode=TheClient->iScreenModes[ii];

		screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);

		(*currentRotations)[ii]=sizeAndRotation.iRotation;

		(*originalRotation)[ii]=sizeAndRotation.iRotation;

		}

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

		{

		TInt mode=TheClient->iScreenModes[ii];

		screen->SetScreenMode(mode);

		currentScreenMode = screen->CurrentScreenMode();

		TEST(currentScreenMode == mode);

		if (currentScreenMode != mode)

			INFO_PRINTF3(_L("screen->CurrentScreenMode() return value - Expected: %d, Actual: %d"), mode, currentScreenMode);

		screen->GetDefaultScreenSizeAndRotation(sizeAndRotation);

		currentRotation=(*currentRotations)[ii];

		TEST(sizeAndRotation.iRotation==currentRotation);

		screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);

		TEST(sizeAndRotation.iRotation==currentRotation);

		User::LeaveIfError(screen->GetRotationsList(mode,rotations));

		count=rotations->Count();

		if (count>1)

			{

			for (jj=0;jj<count;)

				{

				if ((*rotations)[jj++]==currentRotation)

					break;

				}

			if (jj==count)

				jj=0;

			currentRotation=(*rotations)[jj];

			screen->SetCurrentRotations(mode,REINTERPRET_CAST(CFbsBitGc::TGraphicsOrientation&,currentRotation));

			(*currentRotations)[ii]=currentRotation;

			}

		}

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

		{

		TInt mode=TheClient->iScreenModes[ii];

		screen->SetScreenMode(mode);

		currentScreenMode = screen->CurrentScreenMode();

		TEST(currentScreenMode == mode);

		if (currentScreenMode != mode)

			INFO_PRINTF3(_L("(screen->CurrentScreenMode() return value - Expected: %d, Actual: %d"), mode, currentScreenMode);

		screen->GetDefaultScreenSizeAndRotation(sizeAndRotation);

		currentRotation=(*currentRotations)[ii];

		TEST(sizeAndRotation.iRotation==currentRotation);

		if (sizeAndRotation.iRotation != currentRotation)

			INFO_PRINTF3(_L("(screen->GetDefaultScreenSizeAndRotation() return value - Expected: %d, Actual: %d"), currentRotation, sizeAndRotation.iRotation);

		screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);

		TEST(sizeAndRotation.iRotation==currentRotation);

		if (sizeAndRotation.iRotation != currentRotation)

			INFO_PRINTF3(_L("(screen->GetDefaultScreenSizeAndRotation() return value - Expected: %d, Actual: %d"), currentRotation, sizeAndRotation.iRotation);

		if (currentRotation!=(*originalRotation)[ii])

			screen->SetCurrentRotations(mode,REINTERPRET_CAST(CFbsBitGc::TGraphicsOrientation&,(*originalRotation)[ii]));

		}

	screen->SetScreenMode(currentMode);

	currentScreenMode = screen->CurrentScreenMode();

	TEST(currentScreenMode == currentMode);

	if (currentScreenMode != currentMode)

		INFO_PRINTF3(_L("(screen->CurrentScreenMode() return value - Expected: %d, Actual: %d"), currentMode, currentScreenMode);

	CleanupStack::PopAndDestroy(4,&shield4Gray);

	}

TInt CTScrMode::FindCurrentMode()

	{

	CWsScreenDevice *screen=TheClient->iScreen;

	TPixelsTwipsAndRotation sizeAndRotation;

	TPixelsTwipsAndRotation sizeAndRotation2;

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

	TInt ii;

	screen->GetDefaultScreenSizeAndRotation(sizeAndRotation);

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

		{

		TInt mode=TheClient->iScreenModes[ii];

		screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation2);

		if (Equal(sizeAndRotation,sizeAndRotation2))

			return mode;

		}

	TEST(EFalse);

	return -1;

	}

TBool CTScrMode::Equal(const TPixelsTwipsAndRotation& aLeft,const TPixelsTwipsAndRotation& aRight)

	{

	if (aLeft.iPixelSize!=aRight.iPixelSize)

		return EFalse;

	if (aLeft.iRotation!=aRight.iRotation)

		return EFalse;

	if (aLeft.iTwipsSize!=aRight.iTwipsSize)

		return EFalse;

	return ETrue;

	}

TBool CTScrMode::RectClearBugL()

	{

	CWsScreenDevice *screen=TheClient->iScreen;

	TPixelsTwipsAndRotation sizeAndRotation1;

	TPixelsTwipsAndRotation sizeAndRotation2;

	TInt screenMode=FindCurrentMode();

	TInt largeMode=0;

	TInt smallMode=1;

	INFO_PRINTF1(_L("Rotation 1"));

	screen->GetScreenModeSizeAndRotation(0,sizeAndRotation1);

	INFO_PRINTF1(_L("Rotation 2"));

	screen->GetScreenModeSizeAndRotation(1,sizeAndRotation2);

	TSize winSize=TSize(Max(sizeAndRotation1.iPixelSize.iWidth,sizeAndRotation2.iPixelSize.iWidth)

						,Max(sizeAndRotation1.iPixelSize.iHeight,sizeAndRotation2.iPixelSize.iHeight));

	if (sizeAndRotation1.iPixelSize.iWidth<=sizeAndRotation2.iPixelSize.iWidth

									&& sizeAndRotation1.iPixelSize.iHeight<=sizeAndRotation2.iPixelSize.iHeight)

		{

		largeMode=1;

		smallMode=0;

		}

	if (screenMode!=largeMode)

	{

		INFO_PRINTF2(_L("Large Mode %d\r\n"),largeMode);

		screen->SetScreenMode(largeMode);

	}

	CBlankWindow *blankWin=new(ELeave) CBlankWindow(TRgb::Gray256(204));

	CleanupStack::PushL(blankWin);

	blankWin->SetUpL(TPoint(),winSize,TheClient->iGroup,*TheClient->iGc);

	TheClient->iGc->Activate(*blankWin->Win());		//blankWin->Win()->Invalidate();

	blankWin->Draw();

	TheClient->iWs.Flush();

	blankWin->Win()->SetRequiredDisplayMode(EGray4);

	INFO_PRINTF2(_L("Small Mode %d\r\n"),smallMode);

	screen->SetScreenMode(smallMode);

	TheClient->iWs.Flush();

	TheClient->iGc->Deactivate();

	CleanupStack::PopAndDestroy();

	if (screenMode!=smallMode)

	{

		INFO_PRINTF2(_L("Screen Mode %d\r\n"),screenMode);

		screen->SetScreenMode(screenMode);