// 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 Pointer move/drag buffer
// 
//

#include <e32std.h>
#include <hal.h>
#include "W32STD.H"
#include "../tlib/testbase.h"
#include "TMAN.H"

const TInt ENumPntKeyTests=6;
const TUint EModifierMask=EModifierCtrl|EModifierShift|EModifierFunc;

class CTPntKeyTest;

class CTPntKeyWindow : public CTWin
	{
private:
	enum {KPointerMoveBufferSize=32};
public:
	CTPntKeyWindow(CTPntKeyTest *aTest);
	~CTPntKeyWindow();
	void SetUpLD(TPoint pos,TSize size,CTWinBase *parent);
	void PointerL(const TPointerEvent &pointer,const TTime &aTime);
	void KeyUpL(const TKeyEvent &aKey,const TTime &);
	void KeyDownL(const TKeyEvent &aKey,const TTime &);
	void WinKeyL(const TKeyEvent &aKey,const TTime &);
	void SwitchOn(const TTime &aTime);
	void SetState(TInt iState);
	void NextKey();
	void Test(TInt aCheck);
	void Error();
	void DrawButton(const TRect &aRect, const TDesC &aText);
	void Draw();
private:
	CTPntKeyTest *iTest;
	TInt iKeyCount;
	TRect iKey1;
	TRect iKey2;
	TRect iKey3;
	static TInt iTestScanCodes[ENumPntKeyTests];
	static TUint iTestCodes[ENumPntKeyTests];
	static TUint iTestModifiers[ENumPntKeyTests];
	};

class CTPntKeyTest : public CTestBase
	{
public:
	CTPntKeyTest();
	~CTPntKeyTest();
	TestState DoTestL();
	void FinishedTests();
	void ConstructL();
	void Failed();
	inline TBool NoDigitiser() const {return iNoDigitiser;}
private:
	CTPntKeyWindow *iWin;
	TSize iWinSize;
	TInt iState;
	TBool iFailed;
	TBool iOldPointerState;
	TBool iNoDigitiser;
	};

TInt CTPntKeyWindow::iTestScanCodes[ENumPntKeyTests]={'A','B',0,'C',EStdKeyEnter,'Y'};
TUint CTPntKeyWindow::iTestCodes[ENumPntKeyTests]={'a','B',0,'c',EKeyEnter,'y'};
TUint CTPntKeyWindow::iTestModifiers[ENumPntKeyTests]={0,EModifierShift,0,0,0,0};

GLDEF_C CTestBase *CreatePointerKeyTest()
	{
	return(new(ELeave) CTPntKeyTest());
	}

CTPntKeyWindow::CTPntKeyWindow(CTPntKeyTest *aTest) : iTest(aTest)
	{}

CTPntKeyWindow::~CTPntKeyWindow()
	{
	}

void CTPntKeyWindow::SetUpLD(TPoint pos,TSize size,CTWinBase *parent)
	{
	ConstructExtLD(*parent,pos,size);
	iWin.SetPointerGrab(ETrue);
	iKey1=TRect(size.iWidth*1/16,size.iHeight/2,size.iWidth*5/16,size.iHeight);
	iKey2=TRect(size.iWidth*6/16,size.iHeight/2,size.iWidth*10/16,size.iHeight);
	iKey3=TRect(size.iWidth*11/16,size.iHeight/2,size.iWidth*15/16,size.iHeight);
	iWin.AddKeyRect(iKey1,'A',EFalse);
	iWin.AddKeyRect(iKey2,'B',EFalse);
	AssignGC(*Client()->iGc);
	BaseWin()->EnableOnEvents();
	Activate();
	}

void CTPntKeyWindow::Error()
	{
	iTest->Failed();
	}

void CTPntKeyWindow::SetState(TInt iState)
	{
	iKeyCount=iState-1;
	NextKey();
	iTest->Client()->Flush();
	}

void CTPntKeyWindow::NextKey()
	{
	if (++iKeyCount==ENumPntKeyTests || iKeyCount>4)
		iTest->FinishedTests();
	else
		{
		if (iKeyCount==2)
			iWin.RemoveAllKeyRects();
		else if (iKeyCount==3)
			iWin.AddKeyRect(iKey3,'C',EFalse);
		else if (iKeyCount==4)
			{
	#if !defined(__WINS__)
			if (iTest->NoDigitiser())
				iTest->FinishedTests();
	#endif
			iWin.RemoveAllKeyRects();
			iWin.AddKeyRect(TRect(Client()->iScreen->SizeInPixels()),'Z',EFalse);
			}
		else if (iKeyCount==5)
			{
			iWin.RemoveAllKeyRects();
			Client()->iWs.Flush();
			User::After(500000);	// Wait half a second
			iWin.AddKeyRect(TRect(Client()->iScreen->SizeInPixels()),'Y',ETrue);
			}
		Invalidate();
		}
	}

void CTPntKeyWindow::Test(TInt aCheck)
	{
	if (!aCheck)
		Error();
	}

void CTPntKeyWindow::KeyUpL(const TKeyEvent &aKey,const TTime&)
	{
	if (aKey.iScanCode==iTestScanCodes[iKeyCount])
		NextKey();
	}

void CTPntKeyWindow::KeyDownL(const TKeyEvent &aKey,const TTime &)
	{
	if (aKey.iScanCode!=EStdKeyLeftFunc && aKey.iScanCode!=EStdKeyRightFunc && 
		 aKey.iScanCode!=EStdKeyLeftAlt && aKey.iScanCode!=EStdKeyRightAlt &&
		 aKey.iScanCode!=EStdKeyLeftCtrl && aKey.iScanCode!=EStdKeyRightCtrl &&
		 aKey.iScanCode!=EStdKeyLeftShift && aKey.iScanCode!=EStdKeyRightShift && 
		 aKey.iScanCode!=EStdKeyOff &&
		 aKey.iScanCode!=EStdKeyEscape)
		Test(aKey.iScanCode==iTestScanCodes[iKeyCount]);
	}

void CTPntKeyWindow::WinKeyL(const TKeyEvent &aKey,const TTime &)
	{
	if (aKey.iCode==EKeyEscape)
		iTest->FinishedTests();
	else
		{
		Test(aKey.iScanCode==iTestScanCodes[iKeyCount]);
		Test(aKey.iCode==iTestCodes[iKeyCount]);
		Test((aKey.iModifiers&EModifierMask)==(iTestModifiers[iKeyCount]&EModifierMask));
		}
	}

void CTPntKeyWindow::SwitchOn(const TTime &)
	{
	if (iKeyCount==4)
		NextKey();
	else if (iKeyCount!=5)
		Error();
	}

void CTPntKeyWindow::PointerL(const TPointerEvent &aPointer,const TTime &)
	{
	if (aPointer.iType==TPointerEvent::EButton1Down)
		{
		if (iKeyCount!=2)
			Error();
		else
			NextKey();
		}
	}

void CTPntKeyWindow::DrawButton(const TRect &aRect, const TDesC &aText)
	{
	iGc->DrawRect(aRect);
	iGc->DrawText(aText, TPoint((aRect.iBr.iX+aRect.iTl.iX)/2,(aRect.iBr.iY+aRect.iTl.iY)/2));
	}

void CTPntKeyWindow::Draw()
	{
	iGc->SetBrushColor(TRgb::Gray4(0));
	iGc->SetPenColor(TRgb::Gray4(3));
	iGc->Clear();
	DrawButton(iKey1,_L("A"));
	DrawButton(iKey2,_L("B"));
	DrawButton(iKey3,_L("C"));
	switch(iKeyCount)
		{
		case 0:
			iGc->DrawText(_L("Click on 'A'"), TPoint(10,20));
			break;
		case 1:
			iGc->DrawText(_L("Shift-Click on 'B'"), TPoint(10,20));
			break;
		case 2:
			iGc->DrawText(_L("Click anywhere in this window"), TPoint(10,20));
			break;
		case 3:
			iGc->DrawText(_L("Click on 'C'"), TPoint(10,20));
			break;
		case 4:
#if defined(__WINS__)	// Can't emulate touching dig when switched off under WINS
			iGc->DrawText(_L("Switch off and on (or press Enter)"), TPoint(10,20));
#else
			iGc->DrawText(_L("1st Switch off, then touch the screen to switch on"), TPoint(10,20));
#endif
			break;
		case 5:
#if defined(__WINS__)	// Can't emulate touching dig when switched off under WINS
			iGc->DrawText(_L("Touch anywhere in the window"), TPoint(10,20));
#else
			iGc->DrawText(_L("2nd Switch off and touch the screen to switch on"), TPoint(10,20));
#endif
			break;
		}
	}

CTPntKeyTest::CTPntKeyTest() : CTestBase(_L("Pointer Key Test"))
	{}

CTPntKeyTest::~CTPntKeyTest()
	{
	HAL::Set(HALData::EPenDisplayOn,iOldPointerState);
	CTWin::Delete(iWin);
	Client()->ResetFocus();
	}

void CTPntKeyTest::Failed()
	{
	if (!iFailed)
		{
		iFailed=ETrue;
		FinishedTests();
		}
	}

void CTPntKeyTest::FinishedTests()
	{
	Request();
	}

void CTPntKeyTest::ConstructL()
	{
	CTPntKeyWindow *win=new(ELeave) CTPntKeyWindow(this);
	win->SetUpLD(TPoint(20,20),Client()->iScreen->SizeInPixels()-TSize(40,40),Client()->iGroup);
	iWin=win;
	Client()->iGroup->SetCurrentWindow(iWin);
	iNoDigitiser=EFalse;
	TInt err=HAL::Get(HALData::EPenDisplayOn,iOldPointerState);
	if (err==KErrNotSupported)
		iNoDigitiser=ETrue;
	else if (err==KErrNone)
		err=HAL::Set(HALData::EPenDisplayOn,ETrue);
	if (err==KErrNotSupported)
		iNoDigitiser=(!iOldPointerState);
	else
		TestL(err==KErrNone);
	}

TestState CTPntKeyTest::DoTestL()
	{
	TestL(!iFailed);
	switch(iState)
		{
		case 0:
			LogSubTest(_L("Key set 1"),1);
			iWin->SetState(4);
			iState++;
			return(EContinue);
		default:
			return(EFinished);
		}
//	return(ENext);
	}