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

#include <hal.h>

#include <hal_data.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

//

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.SetBackgroundColor(TRgb(255,127,0));		//Orange

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

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

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

					|| sizeAndRotation.iPixelSize.iHeight!=sizeAndRotation2.iPixelSize.iHeight)

			{

			_LIT(KLog,"Height and/or Width don't match (%d,%d)!=(%d,%d) for mode %d");

			LOG_MESSAGE6(KLog,sizeAndRotation.iPixelSize.iWidth,sizeAndRotation.iPixelSize.iHeight

							,sizeAndRotation2.iPixelSize.iWidth,sizeAndRotation2.iPixelSize.iHeight,ii);

			}

		count=rotations->Count();

		TEST(count>=1);

		if (count<1)

			{

			_LIT(KLog,"No rotations supported for mode %d");

			LOG_MESSAGE2(KLog,ii);

			}

		TBool match;

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

			{

			TEST(count<=2);

			if (count>2)

				{

				_LIT(KLog,"Non-square mode %d supports more than 2 rotations (actual rotations=%d)");

				LOG_MESSAGE3(KLog,ii,count);

				}

			if (count==2)

				{

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

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

				if (!match)

					{

					_LIT(KLog,"In non-square mode %d the two rotations do not differ by 180degrees, rot1=%d, rot2=%d");

					LOG_MESSAGE4(KLog,ii,(*rotations)[0],(*rotations)[1]);

					}

				}

			}

		found=EFalse;

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

			{

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

				{

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

				TEST(match);

				if (!match)

					{

					_LIT(KLog,"Rotations don't match %d!=%d for mode %d");

					LOG_MESSAGE4(KLog,sizeAndRotation.iRotation,sizeAndRotation2.iRotation,ii);

					}

				found=ETrue;

				break;

				}

			}

		TEST(found);

		if (!found)

			{

			_LIT(KLog,"In mode %d the current rotation (%d) is not one of the allowable rotations");

			LOG_MESSAGE3(KLog,ii,sizeAndRotation.iRotation);

			}

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

				match=(((*rotations)[jj]==sizeAndRotation.iRotation) && ((*rotations)[jj]==sizeAndRotation2.iRotation));

				TEST(match);

				if (!match)

					{

					_LIT(KLog,"Rotations don't match %d!=%d (both should be %d) after switching to rotation number %d of mode %d");

					LOG_MESSAGE6(KLog,sizeAndRotation.iRotation,sizeAndRotation2.iRotation,(*rotations)[jj],jj,ii);

					}

				}

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

			screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);

			screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation2);

			match=((currentRotation==sizeAndRotation.iRotation) && (currentRotation==sizeAndRotation2.iRotation));

			TEST(match);

			if (!match)

					{

					_LIT(KLog,"Rotations don't match %d!=%d (both should be %d) after switching to the original rotation of mode %d");

					LOG_MESSAGE5(KLog,sizeAndRotation.iRotation,sizeAndRotation2.iRotation,currentRotation,ii);

					}

			}

		}

	CleanupStack::PopAndDestroy(rotations);

	}

/**

  Validate that the screen orienation matchs wiht the screeen orientation stored/set by Wserv in the HAL storage attribute. 

  @param aGcOrientation Input orientation to valudate.

 */

void CTScrMode::CheckHalSetting(TInt aGcOrientation)

    {

    HALData::TDigitiserOrientation halOrientationExp = static_cast<HALData::TDigitiserOrientation>

            (HALData::EDigitiserOrientation_000 + (aGcOrientation - CFbsBitGc::EGraphicsOrientationNormal));

    TInt halOrientation;

    TInt err = HAL::Get(iTest->iScreenNumber, HALData::EDigitiserOrientation, halOrientation);

    // Validate if it's supported by HAL

    if (err != KErrNotSupported)

        {

        if (err != KErrNone)

            {

            _LIT(KLog,"Getting HAL orientation attribute returned error %d when no error expected");

            LOG_MESSAGE2(KLog,err);

            }

        TEST(err==KErrNone);

        if (halOrientationExp != halOrientation)

            {

            _LIT(KLog,"HAL orientation is %d when expected to be %d");

            LOG_MESSAGE3(KLog,halOrientation,halOrientationExp);

            }

        TEST(halOrientationExp==halOrientation);

        }

    else

        {

        _LIT(KLog,"HAL-Orientation HALData::EDigitiserOrientation isn't supported by Driver");

        LOG_MESSAGE(KLog);

        }

    }

void CTScrMode::MoreScreenRotationsL()

	{

	RWindow shield64Color(TheClient->iWs);

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

	CWsScreenDevice* screen=TheClient->iScreen;

	TPixelsAndRotation sizeAndRotation;

	TInt currentRotation;

	TInt currentMode=FindCurrentMode();

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

	TInt currentScreenMode;

	TInt count;

	TInt ii;

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

		}

	_LIT(KModeSwitchFail,"Change to screen mode %d, resulted in screen being in mode %d");

	_LIT(KRotDiff,"Rotations dont match %d!=%d for mode %d");

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

		{

		TInt mode=TheClient->iScreenModes[ii];

		screen->SetScreenMode(mode);

		currentScreenMode=screen->CurrentScreenMode();

		TEST(currentScreenMode==mode);

		if (currentScreenMode!=mode)

			LOG_MESSAGE3(KModeSwitchFail,mode,currentScreenMode);

		screen->GetDefaultScreenSizeAndRotation(sizeAndRotation);

		currentRotation=sizeAndRotation.iRotation;

		TEST((*currentRotations)[ii]==currentRotation);

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

			LOG_MESSAGE4(KRotDiff,(*currentRotations)[ii],currentRotation,ii);

		screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);

		TEST(sizeAndRotation.iRotation==currentRotation);

		if (sizeAndRotation.iRotation!=currentRotation)

			LOG_MESSAGE4(KRotDiff,sizeAndRotation.iRotation,currentRotation,ii);

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

			LOG_MESSAGE3(KModeSwitchFail,mode,currentScreenMode);

		_LIT(KRotDiff,"Switching to mode %d with rotations %d caused the rotation to become %d");

		screen->GetDefaultScreenSizeAndRotation(sizeAndRotation);

		currentRotation=(*currentRotations)[ii];

		TEST(sizeAndRotation.iRotation==currentRotation);

		if (sizeAndRotation.iRotation!=currentRotation)

			{

			_LIT(KRotDiff,"Switching to mode %d with rotations %d caused the rotation to become %d");

			LOG_MESSAGE4(KRotDiff,mode,currentRotation,sizeAndRotation.iRotation);

			}

		screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);

		TEST(sizeAndRotation.iRotation==currentRotation);

		if (sizeAndRotation.iRotation!=currentRotation)

			LOG_MESSAGE4(KRotDiff,sizeAndRotation.iRotation,currentRotation,ii);

		CheckHalSetting(currentRotation);

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

			{

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

			CheckHalSetting(currentRotation);

			}

		}

	screen->SetScreenMode(currentMode);

	currentScreenMode=screen->CurrentScreenMode();

	TEST(currentScreenMode==currentMode);

	if (currentScreenMode!=currentMode)

		LOG_MESSAGE3(KModeSwitchFail,currentMode,currentScreenMode);

	CleanupStack::PopAndDestroy(4,&shield64Color);

	}

TInt CTScrMode::FindCurrentMode()

	{

	CWsScreenDevice* screen=TheClient->iScreen;

	TPixelsTwipsAndRotation sizeAndRotation;

	TPixelsTwipsAndRotation sizeAndRotation2;

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