// 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 "W32STD.H"

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

#include "TMAN.H"

enum THotKeyRetValues

	{

	EHotKeyOkay,

	EHotKeyRetry,

	EHotKeyFail,

	};

struct SHotKeyParams

	{

	THotKey hotKey;

	TUint keyCode;

	TUint mod_mask;

	TUint modifiers;

	};

struct SHotKeyTestParams

	{

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

	};

LOCAL_D SHotKeyParams HotKeys[]={

	{EHotKeyEnableLogging,'e',EModifierFunc|EModifierCtrl|EModifierShift,0},

	{EHotKeyDisableLogging,'d',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},

	{EHotKeyOfDeath,'q',0},

	{EHotKeyOfDeath,'w',0},

	};

LOCAL_D SHotKeyTestParams HotKeyTests[]={

	{(TText *)_S("Use \"e\" to enable logging")},

	{(TText *)_S("Use \"<Alt>d\" to disable logging")},

	{(TText *)_S("Use \"q\" to kill the foreground app")},

	{(TText *)_S("Use \"w\" to kill the foreground app")},

	{(TText *)_S("Use \"<Cntrl><Alt><Shift>K\" to kill the foreground app")},

	};

LOCAL_D TBool HotKeyTestIsDeathTest[]={EFalse, EFalse, ETrue, ETrue, ETrue};

struct SErrorHotKey

	{

	THotKey hotKey;

	TUint keyCode;

	TUint mod_mask;

	TUint modifiers;

	};

LOCAL_D SErrorHotKey errorKeys[]={

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

	{EHotKeyDisableLogging,'1',0,EModifierFunc},

	{EHotKeyEnableLogging,3,EModifierCtrl,EModifierCtrl|EModifierShift},

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

	{(THotKey)100,'1',0,EModifierFunc},

	{(THotKey)200, 3,EModifierCtrl,EModifierCtrl|EModifierShift},

	};

const TInt numHotKeys=sizeof(HotKeys)/sizeof(HotKeys[0]);

const TInt numHotKeyTests=sizeof(HotKeyTests)/sizeof(HotKeyTests[0]);

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

class SHKWindow;

class THotKeyTest;

class SHKConnection;

class SHKDeath : public CActive

	{

public:

	SHKDeath(TInt aPriority);

	void SetConnection(SHKConnection *aConn);

	virtual void DoCancel();

	virtual void RunL();

	void Request();

private:

	SHKConnection *iConn;

	};

class SHKWindowGroup : public CTWindowGroup

	{

public:

	SHKWindowGroup(CTClient *aClient);

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

	};

class SHKConnection : public CTClient

	{

public:

	SHKConnection(THotKeyTest *aTest, TInt aMode);

	~SHKConnection();

	void ConstructL();

	void KeyL(const TKeyEvent &aKey);

	void SubStateChangedL();

	void CompleteL();

protected:

	TInt iMode;

	SHKDeath iDeath;

	THotKeyTest *iTest;

	CTWin *iWin;

	static TInt iMainWinId;

	};

class SHKWindow : public CTWin

	{

public:

	SHKWindow(THotKeyTest *aTest);

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

	void Draw();

protected:

	THotKeyTest *iTest;

	TRgb iBack;

	};

class SHKWindow2 : public CTWin

	{

public:

	SHKWindow2();

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

	void Draw();

	};

class THotKeyTest : public CTestBase

	{

public:

	THotKeyTest();

	~THotKeyTest();

	TestState DoTestL();

	void ConstructL();

	void EndCaptureKeyTest();

	TInt SubState() const;

	void IncSubStateL();

	void BadParamsL();

private:

	SHKConnection *iConn1;

	TSize iWinSize;

	TInt iState;

	TInt iSubState;

	TBool iIsInActiveScheduler;

	};

TInt SHKConnection::iMainWinId;

TInt SubThread(TAny *);

GLDEF_C CTestBase *CreateHotKeyTest()

	{

	return(new(ELeave) THotKeyTest());

	}

THotKeyTest::THotKeyTest() : CTestBase(_L("Hot Key"))

	{}

THotKeyTest::~THotKeyTest()

	{

	User::SetJustInTime(ETrue);

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

		{

		Client()->iWs.ClearHotKeys(HotKeys[index].hotKey);

		Client()->iWs.RestoreDefaultHotKey(HotKeys[index].hotKey);

		}

	delete iConn1;

	if (iIsInActiveScheduler)

		CActiveScheduler::Stop();

	}

void THotKeyTest::EndCaptureKeyTest()

	{

	Request();

	}

void THotKeyTest::ConstructL()

	{

	iConn1=new(ELeave) SHKConnection(this, EFalse);

	iConn1->ConstructL();

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

		User::LeaveIfError(Client()->iWs.SetHotKey(HotKeys[index].hotKey, HotKeys[index].keyCode,HotKeys[index].mod_mask,HotKeys[index].modifiers));

	User::SetJustInTime(EFalse);

	}

//

// SHKDeath //

//

SHKDeath::SHKDeath(TInt aPriority) : CActive(aPriority)

	{

	CActiveScheduler::Add(this);

	}

void SHKDeath::SetConnection(SHKConnection *aConn)

	{

	iConn=aConn;

	}

void SHKDeath::DoCancel()

	{

	}

void SHKDeath::RunL()

	{

	iConn->CompleteL();

	}

void SHKDeath::Request()

	{

	SetActive();

	}

//

SHKWindowGroup::SHKWindowGroup(CTClient *aClient) : CTWindowGroup(aClient)

	{}

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

	{

	((SHKConnection *)iClient)->KeyL(aKey);

	}

//

// SHKConnection

SHKConnection::SHKConnection(THotKeyTest *aTest, TInt aMode) : iMode(aMode), iDeath(100), iTest(aTest)

	{

	iDeath.SetConnection(this);

	}

SHKConnection::~SHKConnection()

	{

	iGroup->GroupWin()->EnableReceiptOfFocus(EFalse);

	CTWin::Delete(iWin);

	}

void SHKConnection::KeyL(const TKeyEvent &aKey)

	{

	if (iTest)

		{

		if (aKey.iCode==EKeyEnter && !HotKeyTestIsDeathTest[iTest->SubState()])

			iTest->IncSubStateL();

		else if (aKey.iCode==EKeyEscape)

			iTest->AbortL();

		}

	}

void SHKConnection::CompleteL()

	{

	iTest->IncSubStateL();

	}

void SHKConnection::SubStateChangedL()

	{

	if (HotKeyTestIsDeathTest[iTest->SubState()])

		{

		RThread thread;

		iMainWinId=iGroup->GroupWin()->Identifier();

		TInt subState=iTest->SubState();

		User::After(100000);

		User::LeaveIfError(thread.Create(_L("SubThread"),SubThread,KDefaultStackSize,0x2000,0x2000,&subState,EOwnerThread));

		thread.Logon(iDeath.iStatus);

		iDeath.Request();

		thread.Resume();

		thread.Close();

		}

	iWin->Invalidate();

	iWs.Flush();

	}

void SHKConnection::ConstructL()

	{

	CTClient::ConstructL();

	iGroup=new(ELeave) SHKWindowGroup(this);

	iGroup->ConstructL();

	TSize screenSize=iGroup->Size();

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

	TInt winWidth;

	TInt winHeight;

	if (iMode==0)

		{

		winWidth=screenSize.iWidth/2;

		winHeight=screenSize.iHeight-10;

		SHKWindow *win=new(ELeave) SHKWindow(iTest);

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

		iWin=win;

		}

	else

		{

		winWidth=150;

		winHeight=50;

		iGroup->GroupWin()->SetOwningWindowGroup(iMainWinId);

		SHKWindow2 *win=new(ELeave) SHKWindow2();

		win->SetUpL(TPoint((screenSize.iWidth-winWidth)/2,(screenSize.iHeight-winHeight)/2),TSize(winWidth,winHeight),iGroup,*iGc);

		iWin=win;

		}

	iWs.Flush();

	}

//

// SHKWindow, class //

//

SHKWindow::SHKWindow(THotKeyTest *aTest) : CTWin(), iTest(aTest)

	{

	iBack=TRgb::Gray256(230);

	}

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

	{

	ConstructExtLD(*parent,pos,size);

	iWin.SetBackgroundColor(iBack);

	Activate();

	AssignGC(aGc);

	}

void SHKWindow::Draw()

	{

	iGc->Clear();

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

	iGc->DrawText(TPtrC(_L("Press <Enter> when tested okay")), TPoint(10,35));

	iGc->DrawText(TPtrC(_L("or escape to abort tests")), TPoint(10,50));

	}

//

// SHKWindow2, class //

//

SHKWindow2::SHKWindow2() : CTWin()

	{

	}

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

	{

	ConstructExtLD(*parent,pos,size);

	iWin.SetBackgroundColor(TRgb(0,0,0));

	Activate();

	AssignGC(aGc);

	}

void SHKWindow2::Draw()

	{

	iGc->SetBrushColor(TRgb::Gray4(1));

	iGc->Clear();

	iGc->SetPenColor(TRgb::Gray4(3));

	iGc->DrawText(TPtrC(_L("Kill me!!!")), TPoint(10,15));

	}

//

TInt THotKeyTest::SubState() const

	{

	return(iSubState);

	}

void THotKeyTest::IncSubStateL()

	{

	if (iSubState==(numHotKeyTests-1))

		EndCaptureKeyTest();

	else

		{

		iSubState++;

		iConn1->SubStateChangedL();

		}

	}

void THotKeyTest::BadParamsL()

	{

	TInt resCount=Client()->iWs.ResourceCount();

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

		TestL(Client()->iWs.SetHotKey(errorKeys[index].hotKey, errorKeys[index].keyCode,errorKeys[index].mod_mask,errorKeys[index].modifiers)==KErrArgument);

	TestL(Client()->iWs.ResourceCount()==resCount);

	}

TestState THotKeyTest::DoTestL()

	{

	switch(iState)

		{

		case 0:

			LogSubTest(_L("Errors"),1);

			BadParamsL();

			LogSubTest(_L("CaptureKey"),2);

			iState++;

			return(EContinue);

		default:

			return(EFinished);

		}

 	}

//======================================================//

// Sub thread to do tests and get shot by window server //

//======================================================//

void SubThreadMain()

	{

	CActiveScheduler *TheActiveScheduler=new(ELeave) CActiveScheduler;

	CActiveScheduler::Install(TheActiveScheduler);

	SHKConnection *conn=new(ELeave) SHKConnection(NULL, ETrue);

	conn->ConstructL();

	CActiveScheduler::Start();

	delete TheActiveScheduler;

	}

TInt SubThread(TAny *)

	{

	CTrapCleanup* CleanUpStack=CTrapCleanup::New();

	TRAPD(err,SubThreadMain());

	delete CleanUpStack;

	return(err);

	}