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

// Keyboard repeat test

// 

//

#include <e32std.h>

#include <e32svr.h>

#include "W32STD.H"

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

#include "TMAN.H"

class CRKWindow;

class TKRepeatTest : public CTestBase

	{

public:

	TKRepeatTest();

	~TKRepeatTest();

	TestState DoTestL();

	void ConstructL();

	void TestKeyboardRepeatRateL(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime);

	TBool CheckReportL();

public:

	TBool iAbort;

private:

	TTimeIntervalMicroSeconds32 iOldInitialTime;

	TTimeIntervalMicroSeconds32 iOldTime;

	CRKWindow *iWin;

	TSize iWinSize;

	TInt iState;

	};

class CRKWindow : public CTWin

	{

	enum TRKStates {

		EStateWaitingForKeyDown,

		EStateWaitingForKeyCode,

		EStateWaitingForFirstRepeat,

		EStateWaitingForNthRepeat,

		EStateWaitingForKeyUp,

		EStateInactive,

		EStateError,

		};

public:

	CRKWindow(TKRepeatTest *aTest);

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

	void SetState(TRKStates aState);

	void SetKeyboardRepeatRate(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime);

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

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

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

	void Draw();

	TDesC& Report();

	TBool CheckResults();

protected:

	TInt iConnIndex;

	TKRepeatTest *iTest;

	TRgb iBack;

	TRKStates iState;

	TInt iDownCode;

	TInt iRepCount;

	TTimeIntervalMicroSeconds32 iInitialRepeatSet;

	TTimeIntervalMicroSeconds32 iRepeatSet;

	TTime iPrevTime;

	TTimeIntervalMicroSeconds32 iInitialGap;

	TTimeIntervalMicroSeconds32 iTotalGap;

	TTimeIntervalMicroSeconds32 iMinGap;

	TTimeIntervalMicroSeconds32 iMaxGap;

	TBuf<0x40> iReport;

	};

GLDEF_C CTestBase *CreateKRepeatTest()

	{

	return(new(ELeave) TKRepeatTest());

	}

//

// CRKWindow, class //

//

CRKWindow::CRKWindow(TKRepeatTest *aTest) : CTWin(), iTest(aTest)

	{

	}

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

	{

	ConstructExtLD(*parent,pos,size);

	iWin.SetBackgroundColor(TRgb::Gray256(230));

	Activate();

	AssignGC(aGc);

	}

void CRKWindow::Draw()

	{

	iGc->Clear();

	switch(iState)

		{

		case EStateWaitingForKeyDown:

			iGc->DrawText(_L("Press and hold the space bar"), TPoint(10,20));

			break;

		case EStateWaitingForFirstRepeat:

		case EStateWaitingForNthRepeat:

			{

			TBuf<0x40> buf;

			buf.Format(TRefByValue<const TDesC>(_L("Keep space bar down (%d repeats so far)")),iRepCount);

			iGc->DrawText(buf, TPoint(10,20));

			}

			break;

		case EStateWaitingForKeyUp:

			iGc->DrawText(_L("Release space bar"), TPoint(10,20));

		default:

			break;

		}

	}

void CRKWindow::SetState(TRKStates aState)

	{

	iState=aState;

	DrawNow();

	}

TBool CRKWindow::CheckResults()

	{

//

// Checks repeat results, first convert everything to 10th's as that what is actually used 

// for the timer in the window server.

//

// Return ETrue if the inacuracy in the average time is greater than 1/10th either way

// Allow initial 2/10ths either

// Allow min 2/10ths below

// Allow max 2/10ths above

//

	if (iState!=EStateInactive)

		return(ETrue);

	TInt initial=iInitialGap.Int()/100000;

	TInt initialX=iInitialRepeatSet.Int()/100000;

	if (initialX==0)

		initialX=1;

	TInt average=(iTotalGap.Int()/100000)/(iRepCount-1);

	TInt repeatX=iRepeatSet.Int()/100000;

	if (repeatX==0)

		repeatX=1;

	TInt min=iMinGap.Int()/100000;

	TInt max=iMaxGap.Int()/100000;

	if (average>(repeatX+1) || average<(repeatX-1))

		return(ETrue);

	if (initial>(initialX+2) || initial<(initialX-2))

		return(ETrue);

	if (min>(repeatX+1) || min<(repeatX-2))

		return(ETrue);

	if (max>(repeatX+3) || max<repeatX)

		return(ETrue);

	return(EFalse);

	}

TDesC& CRKWindow::Report()

	{

	if (iState!=EStateInactive)

		{

		iReport.Format(_L("Error, test not completed"));

		}

	else

		{

		TInt initial=iInitialGap.Int()/10000;

		TInt initialX=iInitialRepeatSet.Int()/10000;

		TInt average=(iTotalGap.Int()/10000/(iRepCount-1));

		TInt repeatX=iRepeatSet.Int()/10000;

		TInt min=iMinGap.Int()/10000;

		TInt max=iMaxGap.Int()/10000;

		iReport.Format(TRefByValue<const TDesC>(_L("Initial=%d [%d], Av=%d [%d], Min=%d, Max=%d")),initial,initialX,average,repeatX,min,max);

		}

	return(iReport);

	}

void CRKWindow::KeyDownL(const TKeyEvent &aKey,const TTime &)

	{

	switch(iState)

		{

		case EStateWaitingForKeyDown:

			SetState(EStateWaitingForKeyCode);

			iDownCode=aKey.iScanCode;

			break;

		default:;

		}

	}

void CRKWindow::KeyUpL(const TKeyEvent &aKey,const TTime &)

	{

	if (aKey.iScanCode==iDownCode)

		{

		switch(iState)

			{

			case EStateWaitingForKeyUp:

				SetState(EStateInactive);

				break;

			default:

				SetState(EStateError);

				break;

			}

		CActiveScheduler::Stop();

		}

	}

void CRKWindow::WinKeyL(const TKeyEvent &aKey,const TTime &aTime)

	{

	if (aKey.iCode==EKeyEscape)

		{

		CActiveScheduler::Stop();

		iTest->iAbort=ETrue;

		}

	if (aKey.iCode==32)

		{

		switch(iState)

			{

			case EStateWaitingForKeyCode:

				SetState(EStateWaitingForFirstRepeat);

				iPrevTime=aTime;

				break;

			case EStateWaitingForFirstRepeat:

				iRepCount=1;

				iInitialGap = I64LOW(aTime.MicroSecondsFrom(iPrevTime).Int64());

				SetState(EStateWaitingForNthRepeat);

				break;

			case EStateWaitingForNthRepeat:

				if (iRepCount==5)

					SetState(EStateWaitingForKeyUp);

				else

					{

					TTimeIntervalMicroSeconds32 gap(I64LOW(aTime.MicroSecondsFrom(iPrevTime).Int64()));

					if (gap<iMinGap)

						iMinGap=gap;

					if (gap>iMaxGap)

						iMaxGap=gap;

					iTotalGap=iTotalGap.Int()+gap.Int();	// Horrible way to do a +=

					iRepCount++;

					SetState(EStateWaitingForNthRepeat);

					}

			case EStateWaitingForKeyUp: 	// Do nothing here

				break;

			default:

				iTest->TestL(EFalse);

			}

		iPrevTime=aTime;

		}

	}

void CRKWindow::SetKeyboardRepeatRate(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime)

	{

	iInitialRepeatSet=aInitialTime;

	iRepeatSet=aTime;

	iMinGap=TTimeIntervalMicroSeconds32(100000000);	// Any very big number will do

	iMaxGap=TTimeIntervalMicroSeconds32(0);

	iTotalGap=TTimeIntervalMicroSeconds32(0);

	SetState(EStateWaitingForKeyDown);

	Client()->iWs.Flush();

	}

//

TKRepeatTest::TKRepeatTest() : CTestBase(_L("KRepeat"))

	{}

TKRepeatTest::~TKRepeatTest()

	{

	CTWin::Delete(iWin);

	Client()->iWs.SetKeyboardRepeatRate(iOldInitialTime, iOldTime);

	}

void TKRepeatTest::ConstructL()

	{

	iWin=new(ELeave) CRKWindow(this);

	TSize screenSize=Client()->iGroup->Size();

	iWin->SetUpL(TPoint(5,5),TSize(screenSize.iWidth/2,screenSize.iHeight-10),Client()->iGroup,*Client()->iGc);

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

	Client()->iWs.GetKeyboardRepeatRate(iOldInitialTime, iOldTime);

	}

TInt TKRepeatTest::CheckReportL()

	{

	if (iWin->CheckResults())

		{

		CTDialog *dialog=new(ELeave) CTDialog();

		dialog->SetTitle(_L("Keyboard repeat innacuracies"));

		dialog->SetLine1(iWin->Report());

		dialog->SetNumButtons(2);

		dialog->SetButtonText(0,_L("Okay"));

		dialog->SetButtonText(1,_L("Retest"));

		dialog->SetButtonText(2,_L("Fail"));

		dialog->ConstructLD(*Client()->iGroup,*Client()->iGc);

		switch(dialog->Display())

			{

			case 0:

				break;

			case 1:

				return(ETrue);	// Redo test

			case 2:

				TestL(EFalse);

				break;

			}

		}

	return(EFalse);

	}

void TKRepeatTest::TestKeyboardRepeatRateL(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime)

	{

	do

		{

		Client()->iWs.SetKeyboardRepeatRate(aInitialTime, aTime);

		iWin->SetKeyboardRepeatRate(aInitialTime, aTime);

		CActiveScheduler::Start();

		if (iAbort)

			AbortL();

		} while(CheckReportL());

	}

TestState TKRepeatTest::DoTestL()

	{

	switch(iState)

		{

		case 0:

			LogSubTest(_L("Keyboard Repeat"),1);

			TestKeyboardRepeatRateL(TTimeIntervalMicroSeconds32(1000000), TTimeIntervalMicroSeconds32(500000));

			LogSubTest(_L("Keyboard Repeat"),2);

			TestKeyboardRepeatRateL(TTimeIntervalMicroSeconds32(200000), TTimeIntervalMicroSeconds32(100000));

			LogSubTest(_L("Keyboard Repeat"),3);

			TestKeyboardRepeatRateL(TTimeIntervalMicroSeconds32(0), TTimeIntervalMicroSeconds32(100000));

			LogSubTest(_L("Keyboard Repeat"),4);

			TestKeyboardRepeatRateL(TTimeIntervalMicroSeconds32(100000), TTimeIntervalMicroSeconds32(100000));

			iState++;

			break;

		default:

			return(EFinished);

		}

	return(ENext);

	}