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

// Screen mode changing tests

// 

//

#include <e32std.h>

#include <e32def_private.h>

#include "W32STD.H"

#include "../tlib/testbase.h"

#include "TMAN.H"

class CTimeWindow;

class CQBlankWindow : public CBlankWindow

	{

public:

	static TInt iInitialColor;

public:

	//Virtual function from CTBaseWin

	void InitWin();

public:

	static TSize iSize;

	TSglQueLink iLink;

	};

class CFixScreenModeGroup : public CTWindowGroup

	{

public:

	static TInt iNoClientWins;

public:

	~CFixScreenModeGroup();

	CFixScreenModeGroup(CTClient *aClient);

	void ConstructL();

public:

	TSglQueLink iLink;

private:

	TSglQue<CQBlankWindow> iWindows;

	};

class CFlipClient : public CTClient

	{

public:

	void ConstructL();

private:

	};

class CScreenModeTimes : public CTestBase

	{

public:

	CScreenModeTimes();

	~CScreenModeTimes();

	TestState DoTestL();

	void ConstructL();

	void DoTimings();

private:

	void CreateGroupL(CTClient* aClient,TSglQue<CFixScreenModeGroup>& aQue);

	void DeleteGroups(TSglQue<CFixScreenModeGroup>& aQue);

	void BringToFront(TSglQue<CFixScreenModeGroup>& aQue);

private:

	TScreenModeEnforcement iEnforcementMode;

	CInfoDialog* iDialogue;

	CTimeWindow* iInfoWindow;

	CFlipClient* iFlipClient;

	TSglQue<CFixScreenModeGroup> iNormalGroupQue;

	TSglQue<CFixScreenModeGroup> iFlipGroupQue;

	TInt iNoGroupWins;

	TInt iState;

	};

class CTimeWindow : public CTTitledWindow

	{

public:

	void Construct(CTestBase* aTest);

	void SetNumWindows(TInt aGroup,TInt aWin);

	void SetTime1(TTimeIntervalMicroSeconds& aTime);

	void SetTime2(TTimeIntervalMicroSeconds& aTime);

	void DoDraw();

	//virtual function from CTWinBase overridden by CTBaseWin

	void WinKeyL(const TKeyEvent &aKey,const TTime &aTime);

	//virtual functions from CTBaseWin

	void SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc);

	void PointerL(const TPointerEvent &aPointer,const TTime &aTime);

	//virtual function from CTBaseWin overridden by CTTitledWindow

	void Draw();

private:

	inline CScreenModeTimes* Test() {return STATIC_CAST(CScreenModeTimes*,iTest);}

	void UpdateString1();

	void UpdateString2();

	void UpdateString3();

private:

	CTestBase* iTest;

	TInt iNumGroups;

	TInt iNumWins;

	TTimeIntervalMicroSeconds iTime1;

	TTimeIntervalMicroSeconds iTime2;

	TBuf<32> iString1;

	TBuf<32> iString2;

	TBuf<32> iString3;

	TBuf<32> iString4;

	TRect iRect1;

	TRect iRect2;

	TRect iRect3;

	TRect iRect4;

	TBool iPressed;

	TBool iExit;

	};

TSize CQBlankWindow::iSize;

TInt CQBlankWindow::iInitialColor;

TInt CFixScreenModeGroup::iNoClientWins=0;

GLDEF_C CTestBase *CreateScreenModeTimes()

	{

	return(new(ELeave) CScreenModeTimes());

	}

//

// CFlipClient

//

void CFlipClient::ConstructL()

	{

	CTClient::ConstructL();

	TPixelsAndRotation sizeAndRotation;

	iScreen->GetScreenModeSizeAndRotation(1,sizeAndRotation);

	iScreen->SetScreenSizeAndRotation(sizeAndRotation);

	}

//

// CTimeWindow

//

void CTimeWindow::Construct(CTestBase* aTest)

	{

	_LIT(Title,"StatusWindow");

	_LIT(String4,"Click here to finish");

	const TInt fontHeight=iFont->HeightInPixels();

	iTest=aTest;

	TWindowTitle title(Title);

	SetTitle(title);

	TInt yy=iTitleHeight+fontHeight+7;

	iRect1.SetRect(3,iTitleHeight+5,iSize.iWidth-1,yy);

	yy+=fontHeight/2;

	TInt yy1=yy+fontHeight+2;

	iRect2.SetRect(3,yy+3,iSize.iWidth-1,yy1);

	TInt yy2=yy1+iFont->HeightInPixels()+2;

	iRect3.SetRect(3,yy1+3,iSize.iWidth-1,yy2);

	yy2+=fontHeight/2;

	iRect4.SetRect(3,yy2+3,iSize.iWidth-1,yy2+iFont->HeightInPixels()+2);

	//

	iString4.Copy(String4);

	iExit=EFalse;

	}

void CTimeWindow::SetUpL(TPoint aPos,TSize aSize,CTWinBase *aParent,CWindowGc &aGc)

	{

	CTTitledWindow::SetUpL(aPos,aSize,aParent,aGc);

	}

void CTimeWindow::WinKeyL(const TKeyEvent &aKey,const TTime&)

	{

	switch(aKey.iCode)

		{

		case EKeyEscape:

			iTest->Request();

			break;

		default:;

		}

	}

void CTimeWindow::PointerL(const TPointerEvent &aPointer,const TTime &aTime)

	{

	if (iRect2.Contains(aPointer.iPosition) || iRect3.Contains(aPointer.iPosition))

		{

		if (aPointer.iType==TPointerEvent::EButton1Down)

			iPressed=ETrue;

		}

	else if (iRect4.Contains(aPointer.iPosition))

		iExit=ETrue;

	else

		CTTitledWindow::PointerL(aPointer,aTime);

	if ((iExit||iPressed) && aPointer.iType==TPointerEvent::EButton1Up)

		{

		if (iExit)

			iTest->Request();

		else

			{

			Test()->DoTimings();

			DoDraw();

			}

		}

	}

void CTimeWindow::Draw()

	{

	CTTitledWindow::Draw();

	TInt ascent=iFont->AscentInPixels()+1;

	iGc->DrawText(iString1,iRect1,ascent,CGraphicsContext::ELeft);

	iGc->DrawText(iString2,iRect2,ascent,CGraphicsContext::ELeft);

	iGc->DrawText(iString3,iRect3,ascent,CGraphicsContext::ELeft);

	iGc->DrawText(iString4,iRect4,ascent,CGraphicsContext::ELeft);

	}

void CTimeWindow::DoDraw()

	{

	iGc->Activate(iWin);

	iGc->UseFont((CFont *)iFont);

	Draw();

	iGc->Deactivate();

	}

void CTimeWindow::SetNumWindows(TInt aGroups,TInt aWins)

	{

	iNumGroups=aGroups;

	iNumWins=aWins;

	UpdateString1();

	}

void CTimeWindow::UpdateString1()

	{

	_LIT(NumberWin,"Groups (2x)%d, Windows %d");

	iString1.Format(NumberWin,iNumGroups,iNumWins);

	}

void CTimeWindow::SetTime1(TTimeIntervalMicroSeconds& aTime)

	{

	iTime1=aTime;

	UpdateString2();

	}

void CTimeWindow::SetTime2(TTimeIntervalMicroSeconds& aTime)

	{

	iTime2=aTime;

	UpdateString3();

	}

_LIT(TimeFormat,"Time%d = %d.%04dsecs");

void CTimeWindow::UpdateString2()

	{

	TInt time = I64LOW(iTime1.Int64());

	iString2.Format(TimeFormat,1,time/1000000,(time%1000000)/100);

	}

void CTimeWindow::UpdateString3()

	{

	TInt time = I64LOW(iTime2.Int64());

	iString3.Format(TimeFormat,2,time/1000000,(time%1000000)/100);

	}

//

// CQBlankWindow

//

void CQBlankWindow::InitWin()

	{

	SetColor(TRgb::Gray4(iInitialColor));

	iWin.SetSize(iSize);

	}

//

// CFixScreenModeGroup

//

CFixScreenModeGroup::~CFixScreenModeGroup()

	{

	GroupWin()->EnableReceiptOfFocus(EFalse);

	ClearCurrentWindow();

	CQBlankWindow* win;

	while (!iWindows.IsEmpty())

		{

		win=iWindows.First();

		iWindows.Remove(*win);

		delete win;

		}

	}

CFixScreenModeGroup::CFixScreenModeGroup(CTClient *aClient) : CTWindowGroup(aClient), iWindows(_FOFF(CQBlankWindow,iLink))

	{}

void CFixScreenModeGroup::ConstructL()

	{

	CTWindowGroup::ConstructL();

	CQBlankWindow* win;

	TInt ii;

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

		{

		win=new(ELeave) CQBlankWindow();

		CleanupStack::PushL(win);

		win->ConstructL(*this);

		win->Activate();

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

		iWindows.AddLast(*win);

		CleanupStack::Pop(win);

		Client()->Flush();

		}

	SetCurrentWindow(iWindows.First());

	}

/*void CFixScreenModeGroup::ScreenDeviceChanged()

	{

	iWindow->ScreenDeviceChanged();

	}*/

//

// CScreenModeTimes

//

_LIT(TestName,"Screen Mode Times");

CScreenModeTimes::CScreenModeTimes() : CTestBase(TestName)

								,iNormalGroupQue(_FOFF(CFixScreenModeGroup,iLink)),iFlipGroupQue(_FOFF(CFixScreenModeGroup,iLink))

	{}

CScreenModeTimes::~CScreenModeTimes()

	{

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

	Client()->iScreen->SetScreenMode(0);

	DeleteGroups(iNormalGroupQue);

	DeleteGroups(iFlipGroupQue);

	Client()->iGroup->SetCurrentWindow(NULL);

	delete iFlipClient;

	delete iInfoWindow;

	if (iEnforcementMode==ESizeEnforcementNone)

		 Client()->iScreen->SetScreenModeEnforcement(ESizeEnforcementNone);

	}

void CScreenModeTimes::ConstructL()

	{

	iEnforcementMode=Client()->iScreen->ScreenModeEnforcement();

	if (iEnforcementMode==ESizeEnforcementNone)

		 Client()->iScreen->SetScreenModeEnforcement(ESizeEnforcementPixelsAndRotation);

	iDialogue=new(ELeave) CInfoDialog(Client()->iGroup,Client()->iGc);

	iDialogue->ConstructLD();

	iFlipClient=new(ELeave) CFlipClient();

	iFlipClient->ConstructL();

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

	iNoGroupWins=12;		//20;

	CFixScreenModeGroup::iNoClientWins=20;		//30;

	TSize screenSize=Client()->iScreen->SizeInPixels();

	CQBlankWindow::iSize.iWidth=Max(screenSize.iHeight,screenSize.iWidth);

	CQBlankWindow::iSize.iHeight=CQBlankWindow::iSize.iWidth;

	TInt ii;

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

		{

		CQBlankWindow::iInitialColor=1;

		CreateGroupL(Client(),iNormalGroupQue);

		CQBlankWindow::iInitialColor=2;

		CreateGroupL(iFlipClient,iFlipGroupQue);

		}

	Client()->iGroup->GroupWin()->SetOrdinalPosition(0);

	iInfoWindow=new(ELeave) CTimeWindow();

	iInfoWindow->SetUpL(TPoint(Max(Min(415,screenSize.iWidth-210),0),Min(50,screenSize.iHeight-180)),TSize(210,180),Client()->iGroup,*Client()->iGc);

	Client()->iGroup->SetCurrentWindow(iInfoWindow);

	iInfoWindow->Construct(this);

	iInfoWindow->WinTreeNode()->SetOrdinalPosition(1);

	iInfoWindow->SetNumWindows(iNoGroupWins,CFixScreenModeGroup::iNoClientWins);

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

	Client()->iWs.SetAutoFlush(ETrue);

	iFlipClient->iWs.SetAutoFlush(ETrue);

	Client()->iWs.SetPointerCursorMode(EPointerCursorNone);

	}

void CScreenModeTimes::CreateGroupL(CTClient *aClient,TSglQue<CFixScreenModeGroup>& aQue)

	{

	CFixScreenModeGroup* group;

	group=new(ELeave) CFixScreenModeGroup(aClient);

	CleanupStack::PushL(group);

	group->ConstructL();

	aQue.AddLast(*group);

	CleanupStack::Pop(group);

	}

void CScreenModeTimes::DeleteGroups(TSglQue<CFixScreenModeGroup>& aQue)

	{

	CFixScreenModeGroup* group;

	while (!aQue.IsEmpty())

		{

		group=aQue.First();

		aQue.Remove(*group);

		delete group;

		}

	}

void CScreenModeTimes::BringToFront(TSglQue<CFixScreenModeGroup>& aQue)

	{

	TSglQueIter<CFixScreenModeGroup> iter(aQue);

	CFixScreenModeGroup* group=iter++;

	group->GroupWin()->SetOrdinalPosition(0);

	while ((group=iter++)!=NULL)

		group->GroupWin()->SetOrdinalPosition(1);

	}

void CScreenModeTimes::DoTimings()

	{

	//Timings 1 SCRDEV, DWsScreenDevice::CommandL, around call to SetScreenMode

	//Timings 2 GROUPWIN, CWsWindowGroup::SetScreenDeviceValidStates, around main body of function including calls to old way

	//Timings 3 CLIWIN, CWsTopClientWindow::SetScreenDeviceValidState, around call to ResetHiddenFlagAndAdjustRegions

	//Timings 3 GROUPWIN, CWsWindowGroup::SetScreenDeviceValidStates, around main body of function excluding calls to old way

	//Timings 4&5 CLIWIN, CWsClientWindow::ResetHiddenFlagAndAdjustRegions, going invisible and becomming visible sections

	Client()->iGroup->GroupWin()->SetOrdinalPosition(-2);

	Client()->Flush();

	TTime startTime;

	TTime middleTime;

	TTime endTime;

__PROFILE_START(0);

	startTime.HomeTime();

	BringToFront(iNormalGroupQue);

	Client()->iScreen->SetScreenMode(1);

	middleTime.HomeTime();

	BringToFront(iFlipGroupQue);

	Client()->iScreen->SetScreenMode(0);

	endTime.HomeTime();

__PROFILE_END(0);

#if defined(__PROFILING__)

	TProfile profile;

	RDebug::ProfileResult(&profile,3,1);

	if (profile.iCount>0)

		iDialogue->TimerResults(0);

#endif

	TTimeIntervalMicroSeconds time=middleTime.MicroSecondsFrom(startTime);

	iInfoWindow->SetTime1(time);

	time=endTime.MicroSecondsFrom(middleTime);

	iInfoWindow->SetTime2(time);

	Client()->iGroup->GroupWin()->SetOrdinalPosition(0);

#if defined(__PROFILING__)

	if (profile.iCount>0)

		iDialogue->Display();

#endif

	}

TestState CScreenModeTimes::DoTestL()

	{

	switch(iState)

		{

		case 0:

			LogSubTest(_L("Time ScreenMode Changes"),1);

			DoTimings();

			iState++;

			return EContinue;

		default:

			return EFinished;

		}

	}