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

// Converted from TMan test code (TMPNTKEY.CPP) May 2001

// Test Pointer move/drag buffer

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TPNTKEY.H"

#define LOGGING on	//Uncomment this line to get more logging

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

CTPntKeyWindow::CTPntKeyWindow(CTPntKey *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(TInt aWhere)

	{

	iTest->Failed(aWhere);

	}

void CTPntKeyWindow::NextKey()

	{

	if (++iKeyCount!=ENumPntKeyTests)

		{

	#if defined(LOGGING)

		_LIT(KLog,"Next Key  KeyCount=%d");

		iTest->LOG_MESSAGE2(KLog,iKeyCount);

	#endif

		if (iKeyCount==2)

			iWin.RemoveAllKeyRects();

		else if (iKeyCount==3)

			iWin.AddKeyRect(iKey3,'C',EFalse);

		else if (iKeyCount==4)

			{

	#if !defined(__WINS__)

			if (iTest->NoDigitiser())

				{

				return;

				}

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

		}

	SendEvent();

	}

void CTPntKeyWindow::SendEvent()

	{

	TheClient->WaitForRedrawsToFinish();

#if defined(LOGGING)

	_LIT(KLog,"SendEvent  KeyCount=%d");

	iTest->LOG_MESSAGE2(KLog,iKeyCount);

#endif

	switch(iKeyCount)

		{

		case 0:

			SimulatePointerDownUp(iKey1);

			break;

		case 1:

			iTest->TestBase()->SimulateKey(TRawEvent::EKeyDown,EStdKeyLeftShift);

			SimulatePointerDownUp(iKey2);

			iTest->TestBase()->SimulateKey(TRawEvent::EKeyUp,EStdKeyLeftShift);

			break;

		case 2:

		case 5:

			{

			TPoint pos=Position();

			TSize size=Size();

			iTest->TestBase()->SimulatePointerDownUp(pos.iX+size.iWidth/2,pos.iY+size.iHeight/4);

			}

			break;

		case 3:

			SimulatePointerDownUp(iKey3);

			break;

		case 4:

			iTest->TestBase()->SimulateKeyDownUp(EStdKeyEnter);

			break;

		}

	}

void CTPntKeyWindow::SimulatePointerDownUp(const TRect& aRect)

	{

	iTest->TestBase()->SimulatePointerDownUp((aRect.iTl.iX+aRect.iBr.iX)/2,(aRect.iTl.iY+aRect.iBr.iY)/2);

	}

void CTPntKeyWindow::Test(TInt aCheck)

	{

	if (!aCheck)

		Error(3);

	}

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

	{

	if (aKey.iScanCode==iTestScanCodes[iKeyCount])

		NextKey();

	}

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

	{

#if defined(LOGGING)

	_LIT(KLog,"KeyDownL  ScanCode=%d '%c' (%d)  KeyCount=%d");

	iTest->LOG_MESSAGE5(KLog,aKey.iScanCode,aKey.iScanCode,iTestScanCodes[iKeyCount],iKeyCount);

#endif

	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)

		{

#if defined(LOGGING)

		_LIT(KLog1,"WinKeyL1  ScanCode=%d (%d)  Code=%d '%c' (%d)");

		_LIT(KLog2,"WinKeyL2  ScanCode=%d  Modifiers=0x%x (0x%x) KeyCount=%d");

		iTest->LOG_MESSAGE6(KLog1,aKey.iScanCode,iTestScanCodes[iKeyCount],aKey.iCode,aKey.iCode,iTestCodes[iKeyCount]);

		iTest->LOG_MESSAGE5(KLog2,aKey.iScanCode,aKey.iModifiers&EModifierMask,iTestModifiers[iKeyCount]&EModifierMask,iKeyCount);

#endif

		Test(aKey.iScanCode==iTestScanCodes[iKeyCount]);

		Test(aKey.iCode==iTestCodes[iKeyCount]);

		Test((aKey.iModifiers&EModifierMask)==(iTestModifiers[iKeyCount]&EModifierMask));

		}

	}

void CTPntKeyWindow::SwitchOn(const TTime &)

	{

#if defined(LOGGING)

	_LIT(KLog,"SwitchOn  KeyCount=%d");

	iTest->LOG_MESSAGE2(KLog,iKeyCount);

#endif

	if (iKeyCount==4)

		NextKey();

 	else if (iKeyCount!=5)

		Error(2);

	}

void CTPntKeyWindow::PointerL(const TPointerEvent &aPointer,const TTime &)

	{

#if defined(LOGGING)

	_LIT(KLog,"Pointer Event  Type=%d  Pos=(%d,%d)  PPos=(%d,%d)  KeyCount=%d");

	iTest->LOG_MESSAGE7(KLog,aPointer.iType,aPointer.iPosition.iX,aPointer.iPosition.iY

						,aPointer.iParentPosition.iX,aPointer.iParentPosition.iY,iKeyCount);

#endif

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

		{

		if (iKeyCount!=2)

			Error(1);

		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("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("Switch off and touch the screen to switch on again"), TPoint(10,20));

#endif

			break;

		}

	}

CTPntKey::CTPntKey(CTestStep* aStep):

	CTWsGraphicsBase(aStep)

	{

	}

CTPntKey::~CTPntKey()

	{

	HAL::Set(HALData::EPenDisplayOn,iOldPointerState);

	CTWin::Delete(iWin);

	Client()->ResetFocus();

	delete iTimeOut;

	}

TInt CTPntKey::TimeOut(TAny* aTest)		//static

	{

	static_cast<CTPntKey*>(aTest)->TimeOut();

	return(KErrNone);

	}

void CTPntKey::TimeOut()

	{

	TLogMessageText buf;

	_LIT(KPntKeyTimeOut,"TIMEOUT: Pointer Key, %d, %S");

	buf.AppendFormat(KPntKeyTimeOut,iState,&TestBase()->iSubTitle);

	TheClient->LogMessage(buf);

	Failed(4);

	}

void CTPntKey::Failed(TInt aWhere)

	{

	_LIT(KLog,"Failed at %d");

	LOG_MESSAGE2(KLog,aWhere);

	if (!iFailed)

		{

		iFailed=ETrue;

		Client()->iGroup->ClearCurrentWindow();

		}

	}

void CTPntKey::ConstructL()

	{

	TInt mods=TheClient->iWs.GetModifierState();

	if (mods&EModifierCapsLock)

		iTest->SimulateKeyDownUp(EStdKeyCapsLock);

	//Make sure all the keys we test are in the up state

	iTest->SimulateKeyDownUp(EStdKeyLeftShift);

	iTest->SimulateKeyDownUp(EStdKeyRightShift);

	iTest->SimulateKeyDownUp(EStdKeyLeftFunc);

	iTest->SimulateKeyDownUp(EStdKeyLeftCtrl);

	iTest->SimulateKeyDownUp(EStdKeyRightCtrl);

	mods=TheClient->iWs.GetModifierState();

	_LIT(KLog,"Initial Modifiers state 0x%x (ideally should be zero)");

	LOG_MESSAGE2(KLog,mods);

	TheClient->iScreen->SetScreenMode(0);		//May sure we are in the right screen size mode

	TheClient->iScreen->SetAppScreenMode(0);

	TheClient->iWs.SetPointerCursorArea(TestBase()->iNormalPointerCursorArea);

	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

		{

		TEST(EFalse);

		}

	TheClient->WaitForRedrawsToFinish();	//Make sure all pending events have been delt with (redraw events are lowest priority)

	iTimeOut=new(ELeave) CTimeOut();

	iTimeOut->ConstructL();

	iTimeOut->Start(KTimeOutAfter,TCallBack(CTPntKey::TimeOut,this));

	}

void CTPntKey::RunTestCaseL(TInt /*aCurTestCase*/)

	{

	_LIT(KTestName,"Key set 1");

	TEST(!iFailed);

	if (iFailed)

		{

		_LIT(KLog,"Test Failed  Substate=%d  KeyCount=%d");

		LOG_MESSAGE3(KLog,iTest->iState,iWin->KeyCount());

		}

	((CTPntKeyStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(++iTest->iState)

		{

/**

@SYMTestCaseID		GRAPHICS-WSERV-0200

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test Pointer move/drag buffer

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Exercise the pointer move/drag buffer and check

					that it functions correctly

@SYMTestExpectedResults The buffer functions correctly

*/

		case 1:

			((CTPntKeyStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0200"));

			iTest->LogSubTest(KTestName);

			if (TestBase()->ConfigurationSupportsPointerEventTesting())

			    {

			    iWin->SendEvent();

			    TheClient->Flush();

			    }

			else

			    {

			    INFO_PRINTF1(_L("Test skipped because config does not support pointer event testing"));

			    }

			break;

		case 2:

			((CTPntKeyStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

			((CTPntKeyStep*)iStep)->CloseTMSGraphicsStep();

			if (TestBase()->ConfigurationSupportsPointerEventTesting())

			    {

                iTimeOut->Cancel();

			    }

			TestComplete();

			break;

		}

	((CTPntKeyStep*)iStep)->RecordTestResultL();

	}

__WS_CONSTRUCT_STEP__(PntKey)