// Copyright (c) 2001-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 Key Click Plug-In DLL

// 

//

#include <e32std.h>

#include "W32CLICK.H"

#include "CLICK.H"

#include <graphics/pointereventdata.h>

#if defined(__WINS__)

	#include <emulator.h>

	#include "LOGWIN.H"

#endif

#define bufSize 64

GLREF_D struct TSharedMemory GSharedMemory;

class MClickMaker

	{

public:

	virtual void KeyEvent(TEventCode aType,const TKeyEvent& aEvent)=0;

	virtual void PointerEvent(const TPointerEvent& aEvent)=0;

	virtual void OtherEvent(TInt aType,TAny* aParam)=0;

	};

struct TGpWinInfo

	{

	TBool iInUse;

	TInt iServerValue;

	TInt iNumGroups;

	};

struct TGpWinIdData

	{

	TInt iId;

	TInt iClient;

	};

NONSHARABLE_CLASS(TLogClicks) : public MClickMaker

	{

public:

	void StartLoggingL();

	inline TBool IsLogging() {return iLogging;}

	//Pure virtual functions from MClickMaker

	void KeyEvent(TEventCode aType,const TKeyEvent& aEvent);

	void PointerEvent(const TPointerEvent& aEvent);

    void OtherEvent(TInt aType,TAny* aParam=NULL);

private:

	TBool iLogging;

	};

NONSHARABLE_CLASS(CEventClicks) : public CBase, public MClickMaker

	{

	enum {

		EEventBufferSize=32,

		EMaxGroupWinClients=6,

		EMaxGroupWinIdData=12

		};

public:

	void ConstructL();

	TInt Add(TWsEvent* aEvent);

	inline TInt Failed() {return iFailed;}

	inline TInt Events() {return iEventsTested;}

	void Reset();

	void ExtendedPointerEvent(const TPointerEventData& aPointerEvent);

	void ExpectNewWindowGroup(TInt aClient);

	void NewWindowGroup(const TGroupWindowOpenData& aGpWinOpen);

	void CheckGpWinId(TInt aId);

	void ExpectCloseWindowGroup(TInt aId);

	void CloseWindowGroup(TInt aId);

	void ExpectCloseWindow(TWindowCloseData& aCloseWin);

	void CloseWindow(TWindowCloseData& aCloseWin);

	void PointerEventInfo(TPointerEventInfo& aPointerEventInfo);	

	//Pure virtual functions from MClickMaker

	void KeyEvent(TEventCode aType,const TKeyEvent& aEvent);

	void PointerEvent(const TPointerEvent& aEvent);

	void OtherEvent(TInt aType,TAny* aParam=NULL);

private:

	TBool GetEvent(TWsEvent& aEvent);

	void Fail();

	void AddGroupWindowId(TInt aClient,TInt aGpWinId);

	void RemoveGroupWindowId(TInt aGpWinId);

private:

	CCirBuf<TWsEvent> iEventBuffer;

	TInt iFailed;

	TInt iEventsTested;

	TInt iFailedAt;

	TGpWinInfo iGroupWins[EMaxGroupWinClients];

	TGpWinIdData iGroupWinIds[EMaxGroupWinIdData];

	TInt iExpectedEvent;

	TInt iExpectedEventData;

	TInt iExpectedHandle;

	TPointerEventInfo iExpectedPointerEventInfo;

	TInt iLastNewGpWinId;

	TAdvancedPointerEvent iLastPointerEvent;

	TBool iExpectingExtendedPointer;

	};

NONSHARABLE_CLASS(CMyClickMaker) : public CClickMaker

	{

public:

	~CMyClickMaker();

	void ConstructL();

	//Virtual function from CClickMaker

	void KeyEvent(TEventCode aType,const TKeyEvent& aEvent);

	void PointerEvent(const TPointerEvent& aEvent);

	void OtherEvent(TInt aType,TAny* aParam);

	TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

private:

	void LogToWindowL();

private:

	TClickOutputModes iMode;

	MClickMaker* iCurrentClick;

	TLogClicks iLogClicks;

	CEventClicks* iEventClicks;

	};

/*TLogClicks*/

void TLogClicks::StartLoggingL()

	{

#if defined(__WINS__)

	if (!IsLogging())

		{

		CreateLogWinThreadL();

		iLogging=ETrue;

		}

#else

	User::Leave(KErrNotSupported);

#endif

	}

void TLogClicks::KeyEvent(TEventCode aType,const TKeyEvent& aEvent)

	{

	_LIT(KKeyDown,		"KEY DOWN   ");

	_LIT(KKeyUp,		"KEY UP     ");

	_LIT(KKeyEvent,		"KEY EVENT  ");

	_LIT(KKeyRepeat,	"KEY REPEAT ");

	_LIT(KKeyUnknown,	"KEY Unknown");

	_LIT(KKeyDataFormatChar,"'%c',");

	_LIT(KKeyDataFormatCode," Code=%u,");

	_LIT(KKeyDataFormatScan," Scan=%d,");

	_LIT(KKeyDataFormatModRep," Mod=0x%x, Rep=%d");

	TBuf<bufSize> bufPlusZero;

	switch (aType)

		{

	case EEventKey:

		bufPlusZero.Copy(KKeyEvent);

		break;

	case EEventKeyUp:

		bufPlusZero.Copy(KKeyUp);

		break;

	case EEventKeyDown:

		bufPlusZero.Copy(KKeyDown);

		break;

	case EEventKeyRepeat:

		bufPlusZero.Copy(KKeyRepeat);

		break;

	default:

		bufPlusZero.Copy(KKeyUnknown);

		break;

		}

	bufPlusZero.AppendFormat(KKeyDataFormatCode,aEvent.iCode);

	if (aEvent.iCode!=0)

		bufPlusZero.AppendFormat(KKeyDataFormatChar,aEvent.iCode);

	bufPlusZero.AppendFormat(KKeyDataFormatScan,aEvent.iScanCode);

	if (aEvent.iScanCode!=0)

		bufPlusZero.AppendFormat(KKeyDataFormatChar,aEvent.iScanCode);

	bufPlusZero.AppendFormat(KKeyDataFormatModRep,aEvent.iModifiers,aEvent.iRepeats);

	bufPlusZero.ZeroTerminate();

#if defined(__WINS__)

	Emulator::Escape();

	SendMessage(GSharedMemory.iHwnd, WM_USER+EAppendText, (bufPlusZero.Length()+1)*sizeof(TText), (TInt32)(bufPlusZero.Ptr()));

	Emulator::Reenter();

#endif

	}

void TLogClicks::PointerEvent(const TPointerEvent& aEvent)

	{

	_LIT(KButtonDown,	"POINTER DOWN ");

	_LIT(KButtonUp,		"POINTER UP   ");

	_LIT(KButton2Down,	"BUTTON 2 DOWN");

	_LIT(KButton2Up,	"BUTTON 2 UP  ");

	_LIT(KButton3Down,	"BUTTON 3 DOWN");

	_LIT(KButton3Up,	"BUTTON 3 UP  ");

	_LIT(KButtonDrag,	"POINTER DRAG ");

	_LIT(KButtonMove,	"POINTER MOVE ");

	_LIT(KButtonRepeat,	"BUTTON REPEAT");

	_LIT(KSwitchOn,		"POINTER ON   ");

	_LIT(KUnknown,		"PTR Unknown  ");

	//_LIT(KPtrDataFormat," Pos=(%d,%d), ScrPos=(%d,%d), Modifiers=%x");

	_LIT(KPtrDataFormat," Pos=(%d,%d), ScrPos=(%d,%d), Mod=%x");

	TBuf<bufSize> bufPlusZero;

	switch (aEvent.iType)

		{

	case TPointerEvent::EButton1Down:

		bufPlusZero.Copy(KButtonDown);

		break;

	case TPointerEvent::EButton1Up:

		bufPlusZero.Copy(KButtonUp);

		break;

	case TPointerEvent::EButton2Down:

		bufPlusZero.Copy(KButton2Down);

		break;

	case TPointerEvent::EButton2Up:

		bufPlusZero.Copy(KButton2Up);

		break;

	case TPointerEvent::EButton3Down:

		bufPlusZero.Copy(KButton3Down);

		break;

	case TPointerEvent::EButton3Up:

		bufPlusZero.Copy(KButton3Up);

		break;

	case TPointerEvent::EDrag:

		bufPlusZero.Copy(KButtonDrag);

		break;

	case TPointerEvent::EMove:

		bufPlusZero.Copy(KButtonMove);

		break;

	case TPointerEvent::EButtonRepeat:

		bufPlusZero.Copy(KButtonRepeat);

		break;

	case TPointerEvent::ESwitchOn:

		bufPlusZero.Copy(KSwitchOn);

		break;

	default:

		bufPlusZero.Copy(KUnknown);

		break;

		}

	bufPlusZero.AppendFormat(KPtrDataFormat,aEvent.iPosition.iX,aEvent.iPosition.iY

																,aEvent.iParentPosition.iX,aEvent.iParentPosition.iY,aEvent.iModifiers);

	bufPlusZero.ZeroTerminate();

#if defined(__WINS__)

	Emulator::Escape();

	SendMessage(GSharedMemory.iHwnd, WM_USER+EAppendText, (bufPlusZero.Length()+1)*sizeof(TText), (TInt32)(bufPlusZero.Ptr()));

	Emulator::Reenter();

#endif

	}

void TLogClicks::OtherEvent(TInt aType,TAny* aParam)

	{

	_LIT(KPointer,"POINTER EVENT Ver=%d, ScrPos=(%d,%d), WinClientHandle=0x%x, WinOrigin=%d, WinGpId=%d");

	_LIT(KScreenDeviceChanged,"SCREEN DEVICE CHANGED EVENT, Mode=%d");

	_LIT(KGroupWindowOpen,"GROUP WINDOW OPEN EVENT WinGpId=%d, Client=%d, NumWinGps=%d");

	_LIT(KGroupWindowClose,"GROUP WINDOW CLOSE EVENT WinGpId=%d");

	_LIT(KWindowClose,"WINDOW CLOSE EVENT Client=%d, WinGpId=%d");

	_LIT(KEventUnknown,	"EVENT Unknown");

	TBuf<bufSize> bufPlusZero;

	switch (aType)

		{

	case EEventPointer:

		{

		TPointerEventData& data=*static_cast<TPointerEventData*>(aParam);

		bufPlusZero.Format(KPointer,data.iVersion,data.iCurrentPos.iX,data.iCurrentPos.iY,data.iClientHandle

										,data.iWindowOrigin.iX,data.iWindowOrigin.iY,data.iWindowGroupId);

		}

		break;

	case EEventScreenDeviceChanged:

		{

		TClickMakerData& data=*static_cast<TClickMakerData*>(aParam);

		bufPlusZero.Format(KScreenDeviceChanged,data.screenDeviceMode);

		}

		break;

	case EEventGroupWindowOpen:

		{

		TGroupWindowOpenData& data=*static_cast<TGroupWindowOpenData*>(aParam);

		bufPlusZero.Format(KGroupWindowOpen,data.iIdentifier,data.iClient,data.iNumClientWindowGroups);

		}

		break;

	case EEventGroupWindowClose:

		bufPlusZero.Format(KGroupWindowClose,reinterpret_cast<TInt&>(aParam));

		break;

	case EEventWindowClose:

		{

		TWindowCloseData& data=*static_cast<TWindowCloseData*>(aParam);

		bufPlusZero.Format(KWindowClose,data.iClientHandle,data.iWindowGroupId);

		}

		break;

	default:

		bufPlusZero.Copy(KEventUnknown);

		break;

		}

	bufPlusZero.ZeroTerminate();

#if defined(__WINS__)

	Emulator::Escape();

	SendMessage(GSharedMemory.iHwnd, WM_USER+EAppendText, (bufPlusZero.Length()+1)*sizeof(TText), (TInt32)(bufPlusZero.Ptr()));

	Emulator::Reenter();

#endif

	}

/*CEventClicks*/

void CEventClicks::ConstructL()

	{

	iEventBuffer.SetLengthL(EEventBufferSize);

	}

TInt CEventClicks::Add(TWsEvent* aEvent)

	{

	return (iEventBuffer.Add(aEvent) ? KErrNone:KErrOverflow);

	}

void CEventClicks::Reset()

	{

	iFailed=EFalse;

	iEventsTested=0;

	iExpectedEvent=0;

	iLastNewGpWinId=0;

	}

void CEventClicks::ExtendedPointerEvent(const TPointerEventData& aPointerEvent)

	{

	if (!iExpectingExtendedPointer)

		{

		Fail();

		return;

		}

	iExpectingExtendedPointer=EFalse;

	TBool match=ETrue;

	if (0!=aPointerEvent.iVersion)

		match=EFalse;

	if (iLastPointerEvent.iType!=aPointerEvent.iPointerEvent.iType)

		match=EFalse;

	if (iLastPointerEvent.iModifiers!=aPointerEvent.iPointerEvent.iModifiers)

		match=EFalse;

	if (iLastPointerEvent.iPosition!=aPointerEvent.iPointerEvent.iPosition)

		match=EFalse;

	if (iLastPointerEvent.iParentPosition!=aPointerEvent.iCurrentPos)

		match=EFalse;

	if (TPointerEventData::EUnspecified!=aPointerEvent.iSource)

		match=EFalse;

	if (iExpectedPointerEventInfo.iClientHandle && iExpectedPointerEventInfo.iWinGpId>0)

		{

		if (iLastPointerEvent.iParentPosition-iExpectedPointerEventInfo.iParentOrigin

										!=aPointerEvent.iPointerEvent.iParentPosition)

			match=EFalse;

		if (iExpectedPointerEventInfo.iParentOrigin+iExpectedPointerEventInfo.iWinOrigin

															!=aPointerEvent.iWindowOrigin)

			match=EFalse;

		if (iExpectedPointerEventInfo.iClientHandle!=aPointerEvent.iClientHandle)

			match=EFalse;

		if (iExpectedPointerEventInfo.iWinGpId!=aPointerEvent.iWindowGroupId)

			match=EFalse;

		}

	if (!match)

		Fail();

	}

void CEventClicks::ExpectNewWindowGroup(TInt aClient)

	{

	if (iExpectedEvent>0)

		Fail();

	iExpectedEvent=EEventGroupWindowOpen;

	iExpectedEventData=aClient;

	}

void CEventClicks::NewWindowGroup(const TGroupWindowOpenData& aGpWinOpen)

	{

	iLastNewGpWinId=aGpWinOpen.iIdentifier;

	if (iExpectedEvent!=EEventGroupWindowOpen)

		{

		Fail();

		return;

		}

	iExpectedEvent=0;

	if (iExpectedEventData>=EMaxGroupWinClients)

		return;

	AddGroupWindowId(iExpectedEventData,iLastNewGpWinId);

	TGpWinInfo& gpWinInfo=iGroupWins[iExpectedEventData];

	if (gpWinInfo.iInUse)

		{

		if (aGpWinOpen.iClient!=gpWinInfo.iServerValue)

			Fail();

		else 

			{

			if (aGpWinOpen.iNumClientWindowGroups!=gpWinInfo.iNumGroups)

				Fail();

			++gpWinInfo.iNumGroups;

			}

		}

	else

		{

		gpWinInfo.iInUse=ETrue;

		gpWinInfo.iServerValue=aGpWinOpen.iClient;

		gpWinInfo.iNumGroups=aGpWinOpen.iNumClientWindowGroups+1;

		}

	}

void CEventClicks::CheckGpWinId(TInt aId)

	{

	if (iLastNewGpWinId!=aId)

		Fail();

	}

void CEventClicks::ExpectCloseWindowGroup(TInt aId)

	{

	if (iExpectedEvent>0)

		Fail();

	iExpectedEvent=EEventGroupWindowClose;

	iExpectedEventData=aId;

	}

void CEventClicks::CloseWindowGroup(TInt aId)

	{

	if (iExpectedEvent!=EEventGroupWindowClose || iExpectedEventData!=aId)

		Fail();

	if (iExpectedEvent==EEventGroupWindowClose)

		iExpectedEvent=0;

	RemoveGroupWindowId(aId);

	}

void CEventClicks::ExpectCloseWindow(TWindowCloseData& aCloseWin)

	{

	if (iExpectedEvent>0)

		Fail();

	iExpectedEvent=EEventWindowClose;

	iExpectedEventData=aCloseWin.iWindowGroupId;

	iExpectedHandle=aCloseWin.iClientHandle;

	}

void CEventClicks::CloseWindow(TWindowCloseData& aCloseWin)

	{

	if (iExpectedEvent!=EEventWindowClose || iExpectedEventData!=aCloseWin.iWindowGroupId || iExpectedHandle!=aCloseWin.iClientHandle)

		Fail();

	if (iExpectedEvent==EEventWindowClose)

		iExpectedEvent=0;

	}

void CEventClicks::PointerEventInfo(TPointerEventInfo& aPointerEventInfo)

	{

	iExpectedPointerEventInfo=aPointerEventInfo;

	}

TBool CEventClicks::GetEvent(TWsEvent& aEvent)

	{

	++iEventsTested;

	if (iEventBuffer.Remove(&aEvent)<1)

		{

		Fail();

		return ETrue;

		}

	return EFalse;

	}

void CEventClicks::Fail()

	{

	if (!iFailed)

		{

		iFailed=iEventsTested;

		}

	}

void CEventClicks::AddGroupWindowId(TInt aClient,TInt aGpWinId)

	{

	TInt ii=0;

	while (ii<EMaxGroupWinIdData && iGroupWinIds[ii].iId>0)

		++ii;

	if (ii<EMaxGroupWinIdData)

		{

		iGroupWinIds[ii].iId=aGpWinId;

		iGroupWinIds[ii].iClient=aClient;

		}

	}

void CEventClicks::RemoveGroupWindowId(TInt aGpWinId)

	{

	TInt ii=0;

	while (ii<EMaxGroupWinIdData && iGroupWinIds[ii].iId!=aGpWinId)

		++ii;

	if (ii<EMaxGroupWinIdData)

		{

		--iGroupWins[iGroupWinIds[ii].iClient].iNumGroups;

		iGroupWinIds[ii].iId=0;

		}

	}

#define MODIFIER_FLAGS_TO_IGNOR EModifierNumLock

#pragma warning(disable : 4245)		//'initializing' : conversion from 'int' to 'unsigned int', signed/unsigned mismatch

void CEventClicks::KeyEvent(TEventCode aType,const TKeyEvent& aEvent)

	{

	TBool pass;

	TEventCode eType=aType;

	switch (aType)

		{

	case EEventKey:

		pass=(aEvent.iRepeats==0);

		break;

	case EEventKeyUp:

	case EEventKeyDown:

		pass=(aEvent.iCode==0) && (aEvent.iRepeats==0);

		break;

	case EEventKeyRepeat:

		pass=(aEvent.iRepeats>0);

		eType=EEventKey;

		break;

	default:

		pass=EFalse;

		}

	if (!pass)

		{

		Fail();

		return;

		}

	TWsEvent eEvent;

	if (GetEvent(eEvent))

		return;

	if (eEvent.Type()!=eType)

		{

		Fail();

		return;

		}

	TKeyEvent keyEvent=*eEvent.Key();

	TUint mask=~(EModifierAutorepeatable|MODIFIER_FLAGS_TO_IGNOR);

	if (keyEvent.iCode!=aEvent.iCode || (keyEvent.iModifiers&mask)!=(aEvent.iModifiers&mask) || keyEvent.iScanCode!=aEvent.iScanCode

																						|| (keyEvent.iRepeats==0)!=(aEvent.iRepeats==0))

		{

		Fail();

		return;

		}

	}

void CEventClicks::PointerEvent(const TPointerEvent& aEvent)

	{

	// Click events are now all advanced events so in order to test the modifier bits

	// appropriately we need to copy them as TAdvancedPointerEvent not TPointerEvent

	if(!aEvent.IsAdvancedPointerEvent())

		{

		Fail();

		return;

		}

	iLastPointerEvent=*aEvent.AdvancedPointerEvent();

	if (iExpectingExtendedPointer)

		Fail();

	else

		iExpectingExtendedPointer=ETrue;

	TWsEvent eEvent;

	if (GetEvent(eEvent))

		return;

	TAdvancedPointerEvent pEvent=*eEvent.Pointer();

	TUint mask=~(MODIFIER_FLAGS_TO_IGNOR);

	if (pEvent.iType!=aEvent.iType || (pEvent.iModifiers&mask)!=(aEvent.iModifiers&mask)

												|| pEvent.iPosition!=aEvent.iPosition || pEvent.iParentPosition!=aEvent.iParentPosition)

		{

		Fail();

		return;

		}

	}

void CEventClicks::OtherEvent(TInt aType,TAny* aParam)

	{

	TBool pass=ETrue;

	if (aType!=EEventPointer)

		++iEventsTested;

	switch (aType)

		{

	case EEventPointer:

		ExtendedPointerEvent(*static_cast<TPointerEventData*>(aParam));

		break;

	case EEventScreenDeviceChanged:

		break;

	case EEventGroupWindowOpen:

		NewWindowGroup(*static_cast<TGroupWindowOpenData*>(aParam));

		break;

	case EEventGroupWindowClose:

		CloseWindowGroup(reinterpret_cast<TInt>(aParam));

		break;

	case EEventWindowClose:

		CloseWindow(*static_cast<TWindowCloseData*>(aParam));

		break;

	default:

		pass=EFalse;

		}

	if (!pass)

		Fail();

	//GetEvent() is not call here because CWsGroupWindow::EnableScreenChangeEvents() could not be 

	//been called.This mean that no EEventScreenDeviceChanged will be put in the client queue.

	//Instead this event will be always passed to the click plugin if this is present.

	}

#pragma warning(default : 4245)

/*CMyClickMaker*/

CMyClickMaker::~CMyClickMaker()

	{

	delete iEventClicks;

	}

void CMyClickMaker::ConstructL()

	{

	iMode=EClickNone;

	iEventClicks=new(ELeave) CEventClicks();

	iEventClicks->ConstructL();

	}

void CMyClickMaker::KeyEvent(TEventCode aType,const TKeyEvent& aEvent)

	{

	if (iCurrentClick)

		iCurrentClick->KeyEvent(aType,aEvent);

	}

void CMyClickMaker::PointerEvent(const TPointerEvent& aEvent)

	{

	if (iCurrentClick)

		iCurrentClick->PointerEvent(aEvent);

	}

void CMyClickMaker::OtherEvent(TInt aType,TAny* aParam)

	{

	if (iCurrentClick)

		iCurrentClick->OtherEvent(aType,aParam);

	}

TInt CMyClickMaker::CommandReplyL(TInt aOpcode,TAny* aArgs)

	{

	switch (aOpcode)

		{

	case EClickCommandToggleOutput:

		switch (iMode)

			{

		case EClickNone:

			LogToWindowL();

			break;

		case EClickCheck:

		case EClickToWindow:

			iMode=EClickNone;

			iCurrentClick=NULL;

			break;

			}

		break;

	case EClickCommandSetOutput:

		iMode=*STATIC_CAST(TClickOutputModes*,aArgs);

		switch (iMode)

			{

		case EClickNone:

			iCurrentClick=NULL;

			break;

		case EClickCheck:

			iCurrentClick=iEventClicks;

			iEventClicks->Reset();

			break;

		case EClickToWindow:

			LogToWindowL();

			break;

			}

		break;

	case EClickEventAdd:

		return iEventClicks->Add(STATIC_CAST(TWsEvent*,aArgs));

	case EClickFailed:

		return iEventClicks->Failed();

	case EClickEvents:

		return iEventClicks->Events();

	case EClickReset:

		iEventClicks->Reset();

		break;

	case EClickCreateGroupWin:

		iEventClicks->ExpectNewWindowGroup(*static_cast<TInt*>(aArgs));

		break;

	case EClickCheckGpWinId:

		iEventClicks->CheckGpWinId(*static_cast<TInt*>(aArgs));

		break;

	case EClickCloseGroupWin:

		iEventClicks->ExpectCloseWindowGroup(*static_cast<TInt*>(aArgs));

		break;

	case EClickCloseWin:

		iEventClicks->ExpectCloseWindow(*static_cast<TWindowCloseData*>(aArgs));

		break;

	case EClickPointerEvent:

		iEventClicks->PointerEventInfo(*static_cast<TPointerEventInfo*>(aArgs));

		break;

	default:;

		}

	return KErrNone;

	}

void CMyClickMaker::LogToWindowL()

	{

	iMode=EClickNone;

	iCurrentClick=NULL;

	iLogClicks.StartLoggingL();

	iMode=EClickToWindow;

	iCurrentClick=&iLogClicks;

	}

EXPORT_C CClickMaker* CreateClickMakerL()

	{

	CMyClickMaker* plugIn=new(ELeave) CMyClickMaker;

	CleanupStack::PushL(plugIn);

	plugIn->ConstructL();

	CleanupStack::Pop(plugIn);

	return plugIn;

	}