// Copyright (c) 1995-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 capture key

// 

//

#include <e32std.h>

#include <e32svr.h>

#include <e32keys.h>

#include "W32STD.H"

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

#include "TMAN.H"

enum TTestMode

	{

	EModeNormalCapture,

	EModeWaitingForFirstDown,

	EModeKeyUpsAndDowns,

	EModeAbortKeys,

	};

enum TCapKeyRetValues

	{

	ECapKeyOkay,

	ECapKeyRetry,

	ECapKeyFail,

	};

struct SCapKeyParams

	{

	TInt connIndex;		// Connection that should capture this key

	TUint keyCode;

	TUint modifier_mask;

	TUint modifiers;

	};

struct SCapKeyTestParams

	{

	TText *txt;			// Text message telling user what to do

	TInt connIndex;		// Connection that receive the key press

	TUint keyCode;		// Expected key code

	TUint modifier_mask;// Modifiers mask for expected modifiers

	TUint modifiers;	// Expected modifiers

	};

struct SAbortKeyTests

	{

	TUint keyCode;		// Expected key code

	TUint modifier_mask;// Modifiers mask for expected modifiers

	TUint modifiers;	// Expected modifiers

	};

LOCAL_D SCapKeyParams capKeys[]={

	{1,19,EModifierFunc|EModifierCtrl,EModifierFunc|EModifierCtrl},

	{2,'b',EModifierFunc|EModifierCtrl,EModifierFunc},

	{2,'n',EModifierFunc|EModifierCtrl,EModifierFunc},

	{0,3,EModifierFunc|EModifierCtrl,EModifierFunc|EModifierCtrl},

	{2,'q',0,0},

	{2,'w',0,0},

	};

LOCAL_D SCapKeyParams capUpAndDownKeys[]={

	{2,EStdKeySpace,EModifierFunc|EModifierCtrl|EModifierShift,0},

	{2,EStdKeyEnter,EModifierFunc|EModifierCtrl|EModifierShift,EModifierShift},

	};

LOCAL_D SCapKeyTestParams capKeyTests[]={

	{(TText *)_S("Press q"),2,'q',EModifierFunc|EModifierCtrl|EModifierShift,0},

	//{(TText *)_S("Press <Alt>q"),2,'q',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},

	{(TText *)_S("Press <Alt>w"),2,'w',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},

	{(TText *)_S("Press a"),0,'a',0},

	//{(TText *)_S("Press <Ctrl><Alt>a"),1,1,EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc|EModifierCtrl},

	{(TText *)_S("Press <Ctrl><Alt>s"),1,19,EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc|EModifierCtrl},

	//{(TText *)_S("Press <Alt>b"),2,'b',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},

	{(TText *)_S("Press <Alt>n"),2,'n',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},

	{(TText *)_S("Press <Ctrl><Alt>b"),0,2,EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc|EModifierCtrl},

	//{(TText *)_S("Press <Alt>c"),0,'c',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},

	{(TText *)_S("Press <Alt>d"),0,'d',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},

	{(TText *)_S("Press <Ctrl><Alt>c"),0,3,EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc|EModifierCtrl},

//

// Capture ups and downs

//

	{(TText *)_S("Press <Space>"),2,EStdKeySpace,EModifierFunc|EModifierCtrl|EModifierShift,0},

	{(TText *)_S("Press <Enter>"),0,EStdKeyEnter,EModifierShift,0},

	{(TText *)_S("Press <Shift><Space>"),0,EStdKeySpace,EModifierFunc|EModifierCtrl|EModifierShift,EModifierShift},

	{(TText *)_S("Press <Shift><Enter>"),2,EStdKeyEnter,EModifierShift,EModifierShift},

//

// Priority keys

//

	{(TText *)_S("Press <Ctrl>c"),0,0,0,0},

	{(TText *)_S("Press <Ctrl>d"),0,0,0,0},

	{(TText *)_S("Press z"),0,0,0,0},

	};

LOCAL_D SAbortKeyTests abortKeyTests[]={

	{3,EModifierCtrl,EModifierCtrl},

	{4,EModifierCtrl,EModifierCtrl},

	{'z',EModifierFunc|EModifierCtrl|EModifierShift,0}

	};

struct SErrorCapKey

	{

	TInt keyCode;

	TUint modifier_mask;

	TUint modifiers;

	};

LOCAL_D SErrorCapKey errorKeys[]={

	{'a',EModifierFunc|EModifierShift,EModifierFunc|EModifierCtrl},

	{'1',0,EModifierFunc},

	{3,EModifierCtrl,EModifierCtrl|EModifierShift},

	};

const TInt numCapKeys=sizeof(capKeys)/sizeof(capKeys[0]);

const TInt numTests=sizeof(capKeyTests)/sizeof(capKeyTests[0]);

const TInt numErrorKeys=sizeof(errorKeys)/sizeof(errorKeys[0]);

const TInt numAbortKeyTests=sizeof(abortKeyTests)/sizeof(abortKeyTests[0]);

const TInt numUpDownKeys=sizeof(capUpAndDownKeys)/sizeof(capUpAndDownKeys[0]);

const TInt numUpDownKeyTests=4;

const TInt numCapKeyTests=numTests-numAbortKeyTests-numUpDownKeyTests;

LOCAL_D TInt capKeyHandle[numCapKeys];

LOCAL_D TInt capUpDownKeyHandle[numUpDownKeys];

class CCKWindow;

class TCaptureKeyTest;

class CCKAbortConnection;

class CCKConnectionBase : public CTClient

	{

public:

	CCKConnectionBase(TCaptureKeyTest *aTest);

	void ConstructL();

protected:

	TCaptureKeyTest *iTest;

	};

class CCKConnection : public CCKConnectionBase

	{

public:

	CCKConnection(TCaptureKeyTest *aTest, TInt aConnIndex);

	~CCKConnection();

	void ConstructL();

	void CheckKeyL(const SCapKeyTestParams &aKeyTest, const TKeyEvent &aKey);

	void SubStateChanged();

	void KeyTestL(TInt aBool);

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

	void CheckUpDownL(const SCapKeyTestParams &aKeyTest, const TKeyEvent &aKey);

	void CheckUpDownL(const TKeyEvent &aKey);

	inline TInt Index() {return iConnIndex;}

protected:

	TInt iConnIndex;

	CCKWindow *iWin;

	};

class CAbortHandler : public CTEventBase

	{

public:

	CAbortHandler(RWsSession *aWs, CCKAbortConnection *aConnection);

	~CAbortHandler();

	void Request();

protected:

	void DoCancel();

	void doRunL();

protected:

	CCKAbortConnection *iConnection;

	};

class CCKAbortConnection : public CCKConnectionBase

	{

public:

	CCKAbortConnection(TCaptureKeyTest *aTest);

	~CCKAbortConnection();

	void ConstructL();

	void ReceivedAbortEventL(TInt aHandle, TKeyEvent *aKey);

	void Foreground();

protected:

	CAbortHandler *iAbortHandler;

	TInt iAbortKeyIndex;

	};

class CCKWindow : public CTWin

	{

public:

	CCKWindow(TCaptureKeyTest *aTest, TInt aConnIndex);

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

	void Draw();

protected:

	TInt iConnIndex;

	TCaptureKeyTest *iTest;

	TRgb iBack;

	};

class CCKWindowGroup : public CTWindowGroup

	{

public:

	CCKWindowGroup(CTClient *aClient, TCaptureKeyTest *aTest);

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

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

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

	void CheckUpDown(const SCapKeyTestParams &aKeyTest, const TKeyEvent &aKey);

private:

	TCaptureKeyTest *iTest;

	};

class TCaptureKeyTest : public CTestBase

	{

public:

	TCaptureKeyTest();

	~TCaptureKeyTest();

	TestState DoTestL();

	void ConstructL();

	void EndCaptureKeyTest();

	TInt SubState() const;

	void IncSubState();

	void BadParamsL();

	void CapKeyPurgingL();

	void SetUpPriorityKeyTest();

	void TestComplete();

	void CaptureUpsAndDownsTest();

	TTestMode Mode();

	void SetMode(TTestMode aMode);

private:

	CCKConnection *iConn1;

	CCKConnection *iConn2;

	CCKConnection *iConn3;

	CCKAbortConnection *iAbortConn;

	TSize iWinSize;

	TInt iState;

	TInt iSubState;

	TTestMode iMode;

	};

GLDEF_C CTestBase *CreateMultiCaptureKeyTest()

	{

	return(new(ELeave) TCaptureKeyTest());

	}

//

// CAbortHandler

CAbortHandler::CAbortHandler(RWsSession *aWs, CCKAbortConnection *aConnection) : CTEventBase(aWs, 10), iConnection(aConnection)

	{

	}

CAbortHandler::~CAbortHandler()

	{

	Cancel();

	}

void CAbortHandler::Request()

	{

	iWs->PriorityKeyReady(&iStatus);

	SetActive();

	}

void CAbortHandler::DoCancel()

	{

	iWs->PriorityKeyReadyCancel();

	}

void CAbortHandler::doRunL()

	{

	TWsPriorityKeyEvent abortEvent;

	iWs->GetPriorityKey(abortEvent);

	iConnection->ReceivedAbortEventL(abortEvent.Handle(),abortEvent.Key());

	}

//

// CCKConnection

CCKConnectionBase::CCKConnectionBase(TCaptureKeyTest *aTest) : iTest(aTest)

	{

	}

void CCKConnectionBase::ConstructL()

	{

	CTClient::ConstructL();

	iGroup=new(ELeave) CCKWindowGroup(this, iTest);

	iGroup->ConstructL();

	}

CCKConnection::CCKConnection(TCaptureKeyTest *aTest, TInt aConnIndex) : CCKConnectionBase(aTest), iConnIndex(aConnIndex)

	{

	}

CCKConnection::~CCKConnection()

	{

	for(TInt index=0;index<numCapKeys;index++)

		if (capKeys[index].connIndex==iConnIndex)

			iGroup->GroupWin()->CancelCaptureKey(capKeyHandle[index]);

	for(TInt index2=0;index2<numUpDownKeys;index2++)

		if (capUpAndDownKeys[index2].connIndex==iConnIndex)

			iGroup->GroupWin()->CancelCaptureKeyUpAndDowns(capUpDownKeyHandle[index2]);

	CTWin::Delete(iWin);

	}

void CCKConnection::SubStateChanged()

	{

	iWin->Invalidate();

	iWs.Flush();

	}

void CCKConnection::ConstructL()

	{

	CCKConnectionBase::ConstructL();

	for(TInt index=0;index<numCapKeys;index++)

		if (capKeys[index].connIndex==iConnIndex)

			capKeyHandle[index]=User::LeaveIfError(iGroup->GroupWin()->CaptureKey(capKeys[index].keyCode,capKeys[index].modifier_mask,capKeys[index].modifiers));

	for(TInt index2=0;index2<numUpDownKeys;index2++)

		if (capUpAndDownKeys[index2].connIndex==iConnIndex)

			capUpDownKeyHandle[index2]=User::LeaveIfError(iGroup->GroupWin()->CaptureKeyUpAndDowns(capUpAndDownKeys[index2].keyCode,

								capUpAndDownKeys[index2].modifier_mask,capUpAndDownKeys[index2].modifiers));

	TSize screenSize=iGroup->Size();

	TInt winWidth=screenSize.iWidth/2;

	TInt winHeight=screenSize.iHeight-10;

	iGroup->GroupWin()->AutoForeground(EFalse);		// Don't allow clicking to cause foreground, might mess up test

	CCKWindow *win=new(ELeave) CCKWindow(iTest, iConnIndex);

	win->SetUpL(TPoint(5,5),TSize(winWidth,winHeight),iGroup,*iGc);

	iWin=win;

	}

void CCKConnection::KeyTestL(TInt aBool)

	{

	if (!aBool)

		{

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

		TInt ret=0;

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

		dialog->SetTitle(_L("Invalid key press"));

		dialog->SetLine1(_L("Try again?"));

		dialog->SetNumButtons(2);

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

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

		ret=dialog->Display();

		User::Leave(ret==1 ? ECapKeyRetry : ECapKeyFail);

		}

	}

void CCKConnection::CheckKeyL(const SCapKeyTestParams &aKeyTest, const TKeyEvent &aKey)

	{

	KeyTestL(aKeyTest.connIndex==iConnIndex);

	KeyTestL(aKeyTest.keyCode==aKey.iCode);

	KeyTestL(aKeyTest.modifiers==(aKey.iModifiers&aKeyTest.modifier_mask));

	}

void CCKConnection::CheckUpDownL(const SCapKeyTestParams &aKeyTest, const TKeyEvent &aKey)

	{

	KeyTestL(aKeyTest.connIndex==iConnIndex);

	KeyTestL(aKeyTest.keyCode==(TUint)aKey.iScanCode);

	KeyTestL(aKeyTest.modifiers==(aKey.iModifiers&aKeyTest.modifier_mask));

	}

void CCKConnection::KeyL(const TKeyEvent &aKey,const TTime &)

	{

	if (iTest->Mode()==EModeNormalCapture)

		{

		if (aKey.iCode==EKeyEscape)

			iTest->AbortL();

		TRAPD(ret,CheckKeyL(capKeyTests[iTest->SubState()],aKey));

		if (ret==ECapKeyOkay)

			iTest->IncSubState();

		else

			iTest->TestL(ret==ECapKeyRetry);

		}

	}

void CCKConnection::CheckUpDownL(const TKeyEvent &aKey)

	{

	CheckUpDownL(capKeyTests[iTest->SubState()],aKey);

	}

CCKAbortConnection::CCKAbortConnection(TCaptureKeyTest *aTest) : CCKConnectionBase(aTest)

	{

	}

CCKAbortConnection::~CCKAbortConnection()

	{

	iGroup->GroupWin()->RemovePriorityKey(3,EModifierCtrl,EModifierCtrl);

	delete iAbortHandler;

	}

void CCKAbortConnection::ConstructL()

	{

	CCKConnectionBase::ConstructL();

	User::LeaveIfError(iGroup->GroupWin()->AddPriorityKey(abortKeyTests[0].keyCode,abortKeyTests[0].modifier_mask,abortKeyTests[0].modifiers));

	User::LeaveIfError(iGroup->GroupWin()->AddPriorityKey(abortKeyTests[1].keyCode,abortKeyTests[1].modifier_mask,abortKeyTests[1].modifiers));

	User::LeaveIfError(iGroup->GroupWin()->AddPriorityKey(abortKeyTests[2].keyCode,abortKeyTests[2].modifier_mask,abortKeyTests[2].modifiers));

	iAbortHandler=new(ELeave) CAbortHandler(&iWs, this);

	iAbortHandler->Construct();

	iWs.Flush();

	}

void CCKAbortConnection::ReceivedAbortEventL(TInt aHandle, TKeyEvent *aKey)

	{

	iTest->TestL(aHandle==(TInt)iGroup);

	iTest->TestL(aKey->iCode==abortKeyTests[iAbortKeyIndex].keyCode);

	iTest->TestL((aKey->iModifiers&abortKeyTests[iAbortKeyIndex].modifier_mask)==abortKeyTests[iAbortKeyIndex].modifiers);

	iAbortKeyIndex++;

	iTest->IncSubState();

	}

void CCKAbortConnection::Foreground()

	{

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

	iWs.Flush();

	}

//

// CCKWindowGroup class //

//

CCKWindowGroup::CCKWindowGroup(CTClient *aClient, TCaptureKeyTest *aTest) : CTWindowGroup(aClient), iTest(aTest)

	{}

void CCKWindowGroup::KeyL(const TKeyEvent &aKey,const TTime &time)

	{

	/*TLogMessageText buf(_S("##Recieved Key: "));

	buf.Append(aKey.iScanCode);

	buf.Append('(');

	buf.AppendNum(aKey.iScanCode);

	buf.Append(')');

	if (!iCurWin)

		{

		buf.Append('(');

		buf.AppendNum(((CCKConnection *)iClient)->Index());

		buf.Append(')');

		}

	iClient->iWs.LogMessage(buf);*/

	if (iCurWin)

		iCurWin->WinKeyL(aKey,time);

	else

		((CCKConnection *)iClient)->KeyL(aKey,time);

	}

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

	{

	if (aKey.iScanCode!=EStdKeyLeftShift && aKey.iScanCode!=EStdKeyRightShift)

		{

		if (iTest->Mode()==EModeWaitingForFirstDown)

			iTest->SetMode(EModeKeyUpsAndDowns);

		if (iTest->Mode()==EModeKeyUpsAndDowns)

			((CCKConnection *)iClient)->CheckUpDownL(aKey);

		}

	}

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

	{

	if (aKey.iScanCode!=EStdKeyLeftShift && aKey.iScanCode!=EStdKeyRightShift)

		{

		if (iTest->Mode()==EModeKeyUpsAndDowns)

			{

			((CCKConnection *)iClient)->CheckUpDownL(aKey);

			iTest->IncSubState();

			}

		}

	}

//

// CCKWindow, class //

//

CCKWindow::CCKWindow(TCaptureKeyTest *aTest, TInt aConnIndex) : CTWin(), iConnIndex(aConnIndex), iTest(aTest)

	{

	iBack=TRgb::Gray256(230);

	}

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

	{

	ConstructExtLD(*parent,pos,size);

	iWin.SetBackgroundColor(iBack);

	Activate();

	AssignGC(aGc);

	}

void CCKWindow::Draw()

	{

	iGc->Clear();

	if (iConnIndex==0)

		iGc->DrawText(TPtrC(capKeyTests[iTest->SubState()].txt), TPoint(10,20));

	}

//

TCaptureKeyTest::TCaptureKeyTest() : CTestBase(_L("Capture Key"))

	{}

TCaptureKeyTest::~TCaptureKeyTest()

	{

	delete iConn1;

	delete iConn2;

	delete iConn3;

	delete iAbortConn;

	}

void TCaptureKeyTest::ConstructL()

	{

	iAbortConn=new(ELeave) CCKAbortConnection(this);

	iAbortConn->ConstructL();

	iConn3=new(ELeave) CCKConnection(this,2);

	iConn3->ConstructL();

	iConn2=new(ELeave) CCKConnection(this,1);

	iConn2->ConstructL();

	iConn1=new(ELeave) CCKConnection(this,0);

	iConn1->ConstructL();

	iMode=EModeNormalCapture;

	}

TInt TCaptureKeyTest::SubState() const

	{

	return(iSubState);

	}

void TCaptureKeyTest::IncSubState()

	{

	iSubState++;

	iConn1->SubStateChanged();

	iConn2->SubStateChanged();