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