// 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;

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

//

// Static func to check windows

//

	{

	RWsSession ws;

	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:

					{

					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

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

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

	}

	{

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

	{

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

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

		count=rotations->Count();

		TEST(count>=1);

		if (count<1)

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

			{

			TEST(count<=2);

			if (count>2)

			if (count==2)

				{

				}

			}

		found=EFalse;

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

			{

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

				{

				found=ETrue;

				break;

				}

			}

		TEST(found);

		if (!found)

		if (count>1)

			{

			currentRotation=sizeAndRotation.iRotation;

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

				{

				screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);

				screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation2);

				}

			screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);

			screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation2);

			}

		}

	}

void CTScrMode::MoreScreenRotationsL()

	{

	TPixelsAndRotation sizeAndRotation;

	TInt currentRotation;

	TInt currentMode=FindCurrentMode();

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

	TInt currentScreenMode;

	TInt count;

	CleanupStack::PushL(currentRotations);

	currentRotations->ResizeL(numModes);

	CleanupStack::PushL(originalRotation);

	originalRotation->ResizeL(numModes);

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

		screen->GetDefaultScreenSizeAndRotation(sizeAndRotation);

		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];

			(*currentRotations)[ii]=currentRotation;

			}

		}

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

		{

		TInt mode=TheClient->iScreenModes[ii];

		screen->SetScreenMode(mode);

		screen->GetDefaultScreenSizeAndRotation(sizeAndRotation);

		currentRotation=(*currentRotations)[ii];

		TEST(sizeAndRotation.iRotation==currentRotation);

		screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);

		TEST(sizeAndRotation.iRotation==currentRotation);

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

		}

	screen->SetScreenMode(currentMode);

	}

TInt CTScrMode::FindCurrentMode()

	{

	TPixelsTwipsAndRotation sizeAndRotation;

	TPixelsTwipsAndRotation sizeAndRotation2;

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