// Copyright (c) 1996-2010 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 window server events

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#ifndef __INIPARSER_H__

#define __INIPARSER_H__

#endif // __INIPARSER_H__

#include "PARSEINIDATA.H"

#include "TEVENT.H"

#include "W32CLICK.H"

#include <w32debug.h>

#include <hal.h>

#define FAIL_LOGGING on

//#define DETAILED

#define LOGGING 1	//Uncomment this when there is a fail so that you get more logging

_LIT(KKeyClickPluginDll, "click.dll");

const TInt KLongKeyCaptureLowPriority = 1;

const TInt KLongKeyCaptureHighPriority = 2;

CTQueueClient::CTQueueClient(CTEventTest *aTest) : iTest(aTest)

	{

	}

CTQueueClient::~CTQueueClient()

	{

	CloseEventTestGroupOnSecondScreen();

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

	delete iChildWin;

	delete iWin;

	}

void CTQueueClient::ConstructL(TBool aCreateChild)

	{

	CTClient::ConstructL();

	iGroup=new(ELeave) CTQueueWindowGroup(this);

	iGroup->ConstructL();

	iWin=new(ELeave) CTBackedUpWin(EGray4);

	iWin->ConstructExtLD(*iGroup,TPoint(EWinPositionX,EWinPositionY),TSize(EWinWidth,EWinHeight));

	iWin->Activate();

	if (aCreateChild)

		{

		iChildWin=new(ELeave) CTBackedUpWin(EGray4);

		iChildWin->ConstructExtLD(*iWin,ChildTopLeft(),ChildSize());

		iChildWin->Activate();

		}

	iWs.Flush();

	}

void CTQueueClient::ConstructEventHandlerL()

	{

	iEventHandler=new(ELeave) CTQueueTestEvent(&iWs, iTest);

	((CTQueueTestEvent *)iEventHandler)->ConstructL();

	}

TInt CTQueueClient::WindowGroupIdentifier()

	{

	return(iGroup->GroupWin()->Identifier());

	}

CTWinBase* CTQueueClient::GetHandle(TPoint& aPos)

	{

	if (iCapturing)

		return iChildWin;

	if (iChildWin && TRect(ChildTopLeft(),ChildSize()).Contains(aPos))

	//if (iChildWin && TRect(TPoint(),ChildSize()).Contains(aPos))

		{

		aPos-=ChildTopLeft();

		if (iChildCapturing)

			iCapturing=ETrue;

		return iChildWin;

		}

	return iWin;

	}

void CTQueueClient::AddExpectedEvent(TWsEvent &aEvent)

	{

#if defined(DETAILED)

	_LIT(KLog,"   Adding Event Type=%d");

	TLogMessageText buf;

	buf.Format(KLog,aEvent.Type());

	LogMessage(buf);

#endif

	((CTQueueTestEvent *)iEventHandler)->AddExpectedEvent(aEvent);

	}

void CTQueueClient::SetChildCapture(TInt aCaptureFlags)

	{

	if (!iChildWin)

		return;

	iChildWin->BaseWin()->SetPointerCapture(aCaptureFlags);

	if (aCaptureFlags|RWindowBase::TCaptureFlagEnabled)

		iChildCapturing=ETrue;

	}

//

CTQueueTestEvent::CTQueueTestEvent(RWsSession *aWs, CTEventTest *aTest) : CTEvent(aWs)

	{

	iTest = aTest;

	iCheckTimeStamp = EFalse;

	iLastEventError = EFalse;

	}

void CTQueueTestEvent::ConstructL()

	{

	CTEventBase::Construct();

	iEventBuffer.SetLengthL(EEventBufferSize);

	iRedrawType=iTest->TestBase()->RedrawStoreTypeL();

	}

void CTQueueTestEvent::TestL(TInt aTest)

	{

	if (!aTest)

		{

		iTest->Failed();

		User::Leave(ETestFailed);

		}

	}

//#define FAIL_LOGGING yes

void CTQueueTestEvent::doRunL()

	{

	TWsEvent wsEvent;

	iWs->GetEvent(wsEvent);

	TWsEvent expectedEvent;

#if defined(FAIL_LOGGING)

	TInt eType,wsHan,eHan,wsKeyCode,eKeyCode,wsKeyRepeat,eKeyRepeat,wsKeyScan,eKeyScan;

	TLogMessageText buf;

	_LIT(KStartString,"AUTO  EventTestFail ");

#endif

	TInt wsType=wsEvent.Type();

	if (wsEvent.Type()==EEventNull)

		TestL(wsEvent.Handle()==0);

	else

		{

		TInt count=iEventBuffer.Count();

		if (count==0 && wsType==EEventFocusGained)

			goto End;

		if (iLastEventError

			&& (iRedrawType==EPartialRedraw_FullRedrawSupport || iRedrawType==EPartialRedraw_PreserveStoredCmds)

			&& wsEvent.Type()==EEventErrorMessage /*&& expectedEvent.Type()!=EEventErrorMessage*/)		//Should really check if the next expected event is an error but there is no way to do this without removing it from the buffer

			{

		#if defined(DETAILED)

			_LIT(KLog,"Skip Duplicate Error Message");

			iTest->LOG_MESSAGE(KLog);

		#endif

			return;		//Ignore repeated error events

			}

		do	{

			TestL(iEventBuffer.Remove(&expectedEvent));	//Loop needed for REL Build with DEB WSERV and W32

		#if defined(DETAILED)

			_LIT(KLog,"Skip event while waiting for error message");

			if (expectedEvent.Type()==EEventErrorMessage && wsEvent.Type()!=expectedEvent.Type())

				iTest->LOG_MESSAGE(KLog);

		#endif

			} while (expectedEvent.Type()==EEventErrorMessage && wsEvent.Type()!=expectedEvent.Type());

		++iEventCount;		//iEventSet

	#if defined(FAIL_LOGGING)

		wsType=wsEvent.Type(),eType=expectedEvent.Type(),wsHan=wsEvent.Handle(),eHan=expectedEvent.Handle();

		if (wsType!=eType)

			{

			_LIT(KEventDiff,"Count=%d  Events Differ Exp=%d  Act=%d");

			buf.Copy(KStartString);

			buf.AppendFormat(KEventDiff,iEventCount,eType,wsType);

			iTest->LOG_MESSAGE(buf);

			}

		else

			{

		#if defined(DETAILED)

			_LIT(KLog," Count=%d  Event Type=%d");

			iTest->LOG_MESSAGE3(KLog,iEventCount,wsType);

		#endif

			}

		if (wsHan!=eHan)

			{

			_LIT(KHandlesDiff,"Count=%d  Handles Differ");

			buf.Copy(KStartString);

			buf.AppendFormat(KHandlesDiff,iEventCount);

			iTest->LOG_MESSAGE(buf);

			}

	#endif

		TestL(wsEvent.Type()==expectedEvent.Type() && wsEvent.Handle()==expectedEvent.Handle());

		}		

	iLastEventError=(wsEvent.Type()==EEventErrorMessage);

	switch(wsEvent.Type())

		{

		case EEventKey:

		#if defined(FAIL_LOGGING)

			wsKeyCode=wsEvent.Key()->iCode,eKeyCode=expectedEvent.Key()->iCode;

			if (wsKeyCode!=eKeyCode)

				{

				_LIT(KKeysDiff,"Count=%d  Key Code Exp=%d (%c)  Act=%d (%c)");

				buf.Copy(KStartString);

				buf.AppendFormat(KKeysDiff,iEventCount,eKeyCode,eKeyCode,wsKeyCode,wsKeyCode);

				iTest->LOG_MESSAGE(buf);

				}

			wsKeyRepeat=wsEvent.Key()->iRepeats,eKeyRepeat=expectedEvent.Key()->iRepeats;

			if ((wsKeyRepeat>0)!=(eKeyRepeat>0) || wsKeyRepeat<eKeyRepeat)

				{

				_LIT(KKeysRepDiff,"Count=%d  Key Repeat Exp=%d  Act=%d");

				buf.Copy(KStartString);

				buf.AppendFormat(KKeysRepDiff,iEventCount,eKeyRepeat,wsKeyRepeat);

				iTest->LOG_MESSAGE(buf);

				}

		#endif

			TestL(wsEvent.Key()->iCode==expectedEvent.Key()->iCode &&

				wsEvent.Key()->iRepeats>=expectedEvent.Key()->iRepeats &&

				(wsEvent.Key()->iRepeats>0)==(expectedEvent.Key()->iRepeats>0));

			// Fall Through

		case EEventKeyDown:

		case EEventKeyUp:

			{

			TUint wsModifiers = wsEvent.Key()->iModifiers;

			TUint eModifiers = expectedEvent.Key()->iModifiers;

		#if defined(FAIL_LOGGING)

			wsKeyScan=wsEvent.Key()->iScanCode,eKeyScan=expectedEvent.Key()->iScanCode;

			if (wsKeyScan!=eKeyScan)

				{

				_LIT(KScanDiff,"Count=%d  Scan Code Exp=%d (%c)  Act=%d (%c)");

				buf.Copy(KStartString);

				buf.AppendFormat(KScanDiff,iEventCount,eKeyScan,eKeyScan,wsKeyScan,wsKeyScan);

				iTest->LOG_MESSAGE(buf);

				}

			if (eModifiers != KModifiersIgnore && wsModifiers != eModifiers)

				{

				_LIT(KModDiff,"Count=%d  Modifiers Exp=0x%x  Act=0x%x");

				buf.Copy(KStartString);

				buf.AppendFormat(KModDiff, iEventCount, eModifiers, wsModifiers);

				iTest->LOG_MESSAGE(buf);

				}

		#endif

			TestL(wsEvent.Key()->iScanCode == expectedEvent.Key()->iScanCode &&

				(eModifiers == KModifiersIgnore || wsModifiers == eModifiers));

			}

			break;

		case EEventModifiersChanged:

			{

			TBool changeModifiersOK=(wsEvent.ModifiersChanged()->iChangedModifiers

																==expectedEvent.ModifiersChanged()->iChangedModifiers);

			TBool modifiersOK=((wsEvent.ModifiersChanged()->iModifiers&wsEvent.ModifiersChanged()->iChangedModifiers)==

						(expectedEvent.ModifiersChanged()->iModifiers&wsEvent.ModifiersChanged()->iChangedModifiers));

		#if defined(FAIL_LOGGING)

			if (!changeModifiersOK || !modifiersOK)

				{

				_LIT(KModDiff,"Count=%d  Modifiers");

				buf.Copy(KStartString);

				buf.AppendFormat(KModDiff,iEventCount);

				iTest->LOG_MESSAGE(buf);

				}

		#endif

			TestL(changeModifiersOK);

			TestL(modifiersOK);

			}

			break;

		case EEventPointer:

		case EEventDragDrop:

			{

		#if defined(FAIL_LOGGING)

			TInt expectedType=expectedEvent.Pointer()->iType, actualType=wsEvent.Pointer()->iType;

			TPoint expectedPos=expectedEvent.Pointer()->iPosition, actualPos=wsEvent.Pointer()->iPosition;

			if (actualType!=expectedType)

				{

				_LIT(KPointerDiff,"Count=%d  Pointer Type Exp=%d  Act=%d");

				buf.Copy(KStartString);

				buf.AppendFormat(KPointerDiff,iEventCount,expectedType,actualType);

				iTest->LOG_MESSAGE(buf);

				}

			if (actualPos!=expectedPos)

				{

				_LIT(KPointerPosDiff,"Count=%d  Pointer Pos E=(%d,%d)  A=(%d,%d)");

				buf.Copy(KStartString);

				buf.AppendFormat(KPointerPosDiff,iEventCount,expectedPos.iX,expectedPos.iY

																,actualPos.iX,actualPos.iY);

				iTest->LOG_MESSAGE(buf);

				}

		#endif

			TestL(wsEvent.Pointer()->iType==expectedEvent.Pointer()->iType);

			TestL(wsEvent.Pointer()->iPosition==expectedEvent.Pointer()->iPosition);

			TInt count=iEventBuffer.Count();count++;			//Dummy line to help in debugging.

			}

			break;

		case EEventWindowVisibilityChanged:

			{

		#if defined(FAIL_LOGGING)

			TUint expectedFlags=expectedEvent.VisibilityChanged()->iFlags;

			TUint actualFlags=wsEvent.VisibilityChanged()->iFlags;

			if (actualFlags!=expectedFlags)

				{

				_LIT(KVisibilityDiff,"Count=%d  Visibility Flags Exp=%d  Act=%d");

				buf.Copy(KStartString);

				buf.AppendFormat(KVisibilityDiff,iEventCount,expectedFlags,actualFlags);

				iTest->LOG_MESSAGE(buf);

				}

		#endif

			TestL(wsEvent.VisibilityChanged()->iFlags==expectedEvent.VisibilityChanged()->iFlags);

			TInt count=iEventBuffer.Count();count++;			//Dummy line to help in debugging.

			}

			break;

		case EEventMessageReady:

			{

			const SEventMessageReady message = *(SEventMessageReady*)wsEvent.EventData();

			TestL(message.iMessageUid== TUid::Uid(123));

			}

			break;

		default:;

		}

	if(iCheckTimeStamp)

		{

		const TInt KOffset=100000; //0.1secs

		TInt64 offset = expectedEvent.Time().Int64() - wsEvent.Time().Int64();

		#if defined(FAIL_LOGGING)

			if(Abs(offset)<KOffset)

				{

				_LIT(KTimeStampDiff,"Count=%d  Offset=%d, ExpectedTime=%d, WServEventTime=%d");

				buf.Copy(KStartString);

				buf.AppendFormat(KTimeStampDiff,iEventCount,offset,expectedEvent.Time().Int64(),wsEvent.Time().Int64());

				iTest->LOG_MESSAGE(buf);

				}

		#endif

		TestL(Abs(offset)<KOffset);

		}

	End:

	if (iEventBuffer.Count()==0)

	    {

		TRAPD(err, iTest->NextSetOfEventsL());		//Not allowed to leave

		if(err != KErrNone)

		    {

            buf.Copy(KStartString);

            buf.AppendFormat(_L("Subtest does not follow rules set by TEvent test framework, leave code: %d"), err);

            iTest->TEST(EFalse);

            iTest->LOG_MESSAGE(buf);

            User::Leave(err);

		    }

	    }

	}

void CTQueueTestEvent::AddExpectedEvent(TWsEvent &aEvent)

	{

	if(iCheckTimeStamp)

		{

		static_cast<TWsQTEvent&>(aEvent).Time().UniversalTime();

		}

	iEventBuffer.Add(&aEvent);

	}

TInt CTQueueTestEvent::EventsLeft()

	{

	return iEventBuffer.Count();

	}

//

CTQueueWindowGroup::CTQueueWindowGroup(CTClient *aClient) : CTWindowGroup(aClient)

	{}

void CTQueueWindowGroup::ConstructL()

	{

	CTWindowGroup::ConstructL();

	User::LeaveIfError(iGroupWin.EnableOnEvents(EEventControlAlways));

	User::LeaveIfError(iGroupWin.EnableGroupChangeEvents());

	}

//

/**

 Closes and deletes anim DLL.

 @param aAnimDll Pointer to the anim Dll to be closed and deleted

 */

LOCAL_C void DestroyAnimDll(TAny* aAnimDll)

	{

	(static_cast<RAnimDll*>(aAnimDll))->Destroy();

	}

/**

 Destroys an REventAnimBase derived anim

 @param aAnim REventAnimBase derived client-side handle to anim

 */

LOCAL_C void DestroyAnim(TAny* aAnim)

	{

	(static_cast<REventAnimBase*>(aAnim))->Destroy();

	}

/**

 Loads the DLL containing the test anims and pushes it onto the cleanup stack.

 This function leaves if the operation was unsuccessful.

 @return A pointer to the DLL containing test anims

 */

RAnimDll* REventAnimBase::LoadL()

	{

	RAnimDll* animDll=new(ELeave) RAnimDll(TheClient->iWs);

	CleanupStack::PushL(TCleanupItem(DestroyAnimDll,animDll));

	User::LeaveIfError(animDll->Load(KAnimDLLName));

	CleanupStack::Pop(animDll);

	return animDll;

	}

/**

 Closes the client-side handle to the anim, destroys the DLL and deletes itself.

 */

void REventAnimBase::Destroy()

	{

	Close();

	delete this;

	}

/**

 Resets server-side state of anim

 */

void REventAnimBase::Reset()

	{

	CommandReply(EADllReset);

	}

/**

 @return Under non-error conditions, returns 0.

 Under error conditions, returns the number of events received

 since the first unexpected event was sent.

 */

TInt REventAnimBase::ErrorCode()

	{

	return CommandReply(EADllErrorCode);

	}

/**

 @return The number of events received by the anim since it was last reset.

 */

TInt REventAnimBase::NumberOfEventsReceived()

	{

	return CommandReply(EADllNumberOfEventsReceived);

	}

/**

 Adds an expected event to the list of events expected by the anim.

 @param aEat Indicates if event is expected to be eaten (ETrue 'indicates expected to be eaten')

 @param aEvent The expected event

 @return KErrNone if succcessful, othewise error code.

 */

TInt REventAnimBase::AddExpectedEvent(TBool aEat, const TRawEvent& aEvent)

	{

	TAnimRawEvent event;

	event.iRawEvent=aEvent;

	event.iEat=aEat;

	return AddExpectedEvent(event);

	}

/**

 Adds an expected event to the list of events expected by the anim.

 @param aEvent The expected event

 @return KErrNone if succcessful, othewise error code.

 */

TInt REventAnimBase::AddExpectedEvent(const TAnimRawEvent& aEvent)

	{

	TPckgBuf<TAnimRawEvent> param;

	param()=aEvent;

	return CommandReply(EADllAddExpectedEvent,param);

	}

//

/**

 Loads the DLL containing the event test anim and creates an anim for event tests

 @param aWin the base window to which the anim is associated (this anim is a Window anim)

 @return A pointer to the new REventAnim

 */

REventAnim* REventAnim::NewL(RWindowBase* aWin, RAnimDll* aDll, REventAnimBase::EAnimationType aType/*=EEventAnim*/)

	{

	REventAnim* self=new(ELeave) REventAnim(aDll);

	CleanupStack::PushL(TCleanupItem(DestroyAnim,self));

	User::LeaveIfError(self->Construct(*aWin,(aType == EEventAnim ? EAnimTypeEventTest : EAnimTypeEventPostingTest), TPtrC8()));

	CleanupStack::Pop(self);

	return self;

	}

/**

 Checks if the anim has received the correct events, and resets the sever-side state of the anim

 @return positive value if events did not match expected showing the first event that didn't match.

         negative value if there were the wrong number of events showing the number of events there were

         0 if correct number of events and they all match

 */

TInt REventAnim::TestFail(TInt aNoEvents)

	{

	TInt events=CommandReply(EADllErrorCode);

	if (events>0)

		return events;

	events=CommandReply(EADllNoEventsAndReset);

	if (events==aNoEvents)

		return 0;

	return -events;

	}

//

/**

 Loads the DLL containing the event test anim and creates an anim for event handler removal tests

 @param aWin the base window to which the anim is associated (this anim is a Window anim)

 @return A pointer to the new REventAnim

 */

RRemovableAnim* RRemovableAnim::NewLC(RWindowBase* aWin, RAnimDll* aDll)

	{

	RRemovableAnim* self=new(ELeave) RRemovableAnim(aDll);

	CleanupStack::PushL(TCleanupItem(DestroyAnim,self));

	User::LeaveIfError(self->Construct(*aWin,EAnimTypeRemovableAnim,TPtrC8()));

	return self;

	}

/**

 Sets the lifetime of the anim. This anim will remove itself from the

 event handler list after receiving this number of events.

 @return The lifetime of the anim

 */

TInt RRemovableAnim::SetEventHandlerLifetime(TInt aEventCount)

	{

	TPckgBuf<TInt> param;

	param()=aEventCount;

	return CommandReply(EADllSetEventHandlerLifetime, param);

	}

/**

 Retrieves the lifetime of the anim. This anim will remove itself from the

 event handler list after receiving this number of events.

 @return The lifetime of the anim

 */

TInt RRemovableAnim::EventHandlerLifetime()

	{

	return CommandReply(EADllEventHandlerLifetime);

	}

/**

 Adds the anim to the list of event handlers.

 This anim should receive any subsequent events.

 @return KErrNone on successful addition.

 */

TInt RRemovableAnim::AddToEventHandlers()

	{

	return CommandReply(EADllAddToEventHandlers);

	}

/**

 Removes the anim from the list of event handlers.

 This anim should not receive any subsequent events.

 @return KErrNone on successful removal.

 */

TInt RRemovableAnim::RemoveFromEventHandlers()

	{

	return CommandReply(EADllRemoveFromEventHandlers);

	}

/**

 Tests if the anim has received the correct number of events, and that

 the events received are all the correct events.

 @param aNoEvents The total expected number of events since it was last reset/constructed.

 @return ETrue if the anim has received the expected events.

 */

TBool RRemovableAnim::TestPassed()

	{

	return CommandReply(EADllTestPassed);

	}

//

CTEventTest::CTEventTest(CTestStep* aStep) : CTWsGraphicsBase(aStep)

	{

	INFO_PRINTF1(_L("Testing Event functions"));

	}

CTEventTest::~CTEventTest()

	{

	delete iBlankWin;

	iBackingWindow.Close();

	delete iVisWins1;

	delete iVisWins2;

	delete iVisWins3;

	delete iTransWin;

	delete iQueueClient;

	if (iAnim)

		iAnim->Destroy();

	delete iEventTestGroup2;		//Just in case it doesn't get deleted normally

	delete iEventTestGroup3;		//Just in case it doesn't get deleted normally

	delete iEventTestGroup4;        //Just in case it doesn't get deleted normally

	if (iPtrPluginLoaded)

	    {

	    iClick.Unload();

	    }

	iClick.Close();

	if (iTurnBackOnCapsLock)

		{

		TheClient->iWs.SetModifierState(EModifierCapsLock,ETurnOnModifier);

		}

	if (iRemovableAnims)

		{

		EventHandlerRemoval_DestroyAllAnims();

		iRemovableAnims->Close();

		delete iRemovableAnims;

		}

	if (iAnimDll)

		{

		iAnimDll->Destroy();

		}

#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS	

#ifndef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA  	

	if (!iSurfaceId.IsNull())

	    {

	    iSurfaceManager.CloseSurface(iSurfaceId);

	    }

	iSurfaceManager.Close();

	if(iTimeOutCallback)

	    {

	    iTimeOutCallback->Cancel();

	    delete iTimeOutCallback;

	    }

#endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

#endif // SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS

	}

void CTEventTest::ConstructL()

	{

    _LIT(KWsIniFile, "z:\\system\\data\\wsini.ini");

    CIniData* iniData = CIniData::NewL(KWsIniFile, ' ');

    _LIT( KWsiniYShifting, "YSHIFTING");

    iniData->FindVar(KWsiniYShifting, iYOffset);

    delete iniData;

	TheClient->iScreen->SetAppScreenMode(0);

	TheClient->iScreen->SetScreenMode(0);						// in mode 0 TheClient->iScreen->SizeInPixels() 

	iPhysicalScreenSize = TheClient->iScreen->SizeInPixels();	// is equal to physical screen size

	BaseWin->Invalidate();

	BaseWin->Win()->BeginRedraw();

	TheGc->Activate(*BaseWin->Win());

	TheGc->SetBrushColor(TRgb::Gray16(12));

	TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	TheGc->SetPenStyle(CGraphicsContext::ENullPen);

	TheGc->DrawRect(TRect(BaseWin->Win()->Size()));

	TheGc->Deactivate();

	BaseWin->Win()->EndRedraw();

	TheGc->Activate(*TestWin->Win());

	TheGc->SetBrushColor(TRgb::Gray16(4));

	TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	TheGc->SetPenStyle(CGraphicsContext::ENullPen);

	TheGc->DrawRect(TRect(TestWin->Win()->Size()));

	TheGc->Deactivate();

	iBackingWindow=RBlankWindow(TheClient->iWs);

	iBackingWindow.Construct(*TheClient->iGroup->WinTreeNode(),ENullWsHandle);

	iBackingWindow.SetColor(TRgb(0,0xDD,0xDD));

	iBackingWindow.SetOrdinalPosition(-1,-25);

	iBackingWindow.Activate();

	iBlankWin=new(ELeave) CTBlankWindow();

	iBlankWin->ConstructL(*TheClient->iGroup);

	User::LeaveIfError(iBlankWin->BaseWin()->SetRequiredDisplayMode(EColor256));

	iBlankWin->SetExt(TPoint(),iPhysicalScreenSize);

	iBlankWin->SetVisible(EFalse);

	iBlankWin->Activate();

	CArrayFixFlat<TInt> *rotations=new(ELeave) CArrayFixFlat<TInt>(1);

	iNumScrModes=TheClient->iScreen->NumScreenModes();

	TInt modes=Min(2,iNumScrModes);

	TInt mode;

	TInt rot;

	CleanupStack::PushL(rotations);

	for (mode=0;mode<modes;++mode)

		{

		User::LeaveIfError(TheClient->iScreen->GetRotationsList(mode,rotations));

		for (rot=rotations->Count()-1;rot>=0;--rot)

			{

			iScreenModeTests|=(1<<(*rotations)[rot]);

			}

		}

	if (CheckScalingSupportedOrNot())

		iScreenModeTests|=EDoScale;

	iClick=RSoundPlugIn(TheClient->iWs);

	User::LeaveIfError(iClick.Construct(TUid::Uid(CLICK_THIRD_UID)));

    TBool ptrPluginLoadable = EFalse;

    iClick.IsLoaded(ptrPluginLoadable);

    if (ptrPluginLoadable)

        {

        User::LeaveIfError(iClick.Load(KKeyClickPluginDll));

        iPtrPluginLoaded = ETrue;

        }

	CleanupStack::PopAndDestroy();

	if (TheClient->iWs.GetModifierState()&EModifierCapsLock)

		{

		iTurnBackOnCapsLock=ETrue;

		TheClient->iWs.SetModifierState(EModifierCapsLock,ETurnOffModifier);

		}

	iAnimDll = REventAnimBase::LoadL();

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

	if (mods&EModifierCapsLock)

		iTest->SimulateKeyDownUp(EStdKeyCapsLock);

	if (mods&EModifierNumLock)

		iTest->SimulateKeyDownUp(EStdKeyNumLock);

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

	iTest->DelayIfFullRomL();

#if !defined(TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA)

	// 2d or 3d pointer?

	if(HAL::Get(HALData::EPointer3D,iIs3DPointer)!=KErrNone)

		{

		iIs3DPointer=EFalse;

		}

#endif

	TheClient->iWs.GetKeyboardRepeatRate(iKeyBoardRepeatInitialDelay, iKeyBoardRepeatNextDelay);

	}

void CTEventTest::Failed()

	{

#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS	

#ifndef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA  	

   if(iTimeOutCallback)

        {

        iTimeOutCallback->Cancel();

        iTimeOutCallback->Deque();

        delete iTimeOutCallback;

        iTimeOutCallback = NULL;

        }

    TEST(EFalse);

#endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

#endif // SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS

	CActiveScheduler::Stop();

	iFailed=ETrue;

	}

void CTEventTest::CheckTimeInterval(const TTimeIntervalMicroSeconds32 &aTime,TInt aCheckTime)

	{

	TEST(aTime.Int()==aCheckTime);

	if (aTime.Int()!=aCheckTime)

		INFO_PRINTF3(_L("aTime.Int()==aCheckTime - Expected: %d, Actual: %d"), aCheckTime, aTime.Int());

	}

void CTEventTest::KeyRepeatRate(TInt aInitialRepeat, TInt aRepeat)

	{

	TheClient->iWs.SetKeyboardRepeatRate(TTimeIntervalMicroSeconds32(aInitialRepeat), TTimeIntervalMicroSeconds32(aRepeat));

	TTimeIntervalMicroSeconds32 initialTime;

	TTimeIntervalMicroSeconds32 time;

	TheClient->iWs.GetKeyboardRepeatRate(initialTime,time);

	CheckTimeInterval(initialTime,aInitialRepeat);

	CheckTimeInterval(time,aRepeat);

	}

void CTEventTest::DoubleClickSettings(TInt aInterval, TInt aDistance)

	{

	TheClient->iWs.SetDoubleClick(TTimeIntervalMicroSeconds32(aInterval), aDistance);

	TTimeIntervalMicroSeconds32 interval;

	TInt distance;

	TheClient->iWs.GetDoubleClickSettings(interval, distance);

	CheckTimeInterval(interval,aInterval);

	TEST(aDistance==distance);

	if (aDistance!=distance)

		INFO_PRINTF3(_L("aDistance==distance - Expected: %d, Actual: %d"), distance, aDistance);

	}

TInt EventCancelFunc(TAny* aClient)

	{

	TWsQTEvent event;

	event.SetType(EEventModifiersChanged);

	((TModifiersChangedEvent *)event.EventData())->iChangedModifiers=0;

	((TModifiersChangedEvent *)event.EventData())->iModifiers=0;

	TheClient->iWs.SendEventToWindowGroup(TheClient->iGroup->GroupWin()->Identifier(),event);

//

	TRequestStatus status;

	((CTClient *)aClient)->iWs.EventReady(&status);

	((CTClient *)aClient)->iWs.EventReadyCancel();

	User::WaitForRequest(status);

	return(KErrNone);

	}

void CTEventTest::General()

	{

	TWsQTEvent event;

	event.SetType(EEventModifiersChanged);

	((TModifiersChangedEvent *)event.EventData())->iChangedModifiers=0;

	((TModifiersChangedEvent *)event.EventData())->iModifiers=0;

	TheClient->iWs.SendEventToWindowGroup(TheClient->iGroup->GroupWin()->Identifier(),event);

	TCallBack callBack(EventCancelFunc,TheClient);

	TheClient->SetCancelFunction(callBack);

//

	TTimeIntervalMicroSeconds32 oldInitialTime;

	TTimeIntervalMicroSeconds32 oldTime;

	TheClient->iWs.GetKeyboardRepeatRate(oldInitialTime,oldTime);

//

	KeyRepeatRate(EKeyboardInitialRepeat1, EKeyboardRepeat1);

	KeyRepeatRate(EKeyboardInitialRepeat2, EKeyboardRepeat2);

	KeyRepeatRate(EKeyboardInitialRepeat3+200, EKeyboardRepeat3); // Max initial repeat with normal keyboard repeat value

	KeyRepeatRate(EKeyboardInitialRepeat3, EKeyboardRepeat7+200); // Max key and initial repeat

	KeyRepeatRateNegTest(EKeyboardInitialRepeat4, EKeyboardRepeat4); // -ve initial repeat

	KeyRepeatRateNegTest(EKeyboardInitialRepeat2, EKeyboardRepeat6); // -ve keyboard repeat

	#if defined __WINS__ || defined __WINSCW__

	KeyRepeatRateNegTest(EKeyboardInitialRepeat3+400, EKeyboardRepeat5); // More than max initial repeat

	#endif//defined __WINS__ || defined __WINSCW__

	DoubleClickSettings(EDoubleClickTime1,EDoubleClickGap1);

	DoubleClickSettings(EDoubleClickTime2,EDoubleClickGap2);

	TheClient->iWs.SetKeyboardRepeatRate(oldInitialTime,oldTime);

//

	}

#define UNIQUE_PRIORITY 123

void CTEventTest::General2()

	{

	RWindowGroup& group=*TheClient->iGroup->GroupWin();

	TInt priority=group.OrdinalPriority();

	TInt position=group.OrdinalPosition();

	TInt priorityGain=TheClient->iWs.GetWindowGroupOrdinalPriority(group.Identifier())-priority;

	group.SetOrdinalPosition(0,UNIQUE_PRIORITY);

	TWsQTEvent event;

	event.SetType(EEventModifiersChanged);

	((TModifiersChangedEvent *)event.EventData())->iChangedModifiers=0;

	((TModifiersChangedEvent *)event.EventData())->iModifiers=0;

	TheClient->iWs.SendEventToAllWindowGroups(UNIQUE_PRIORITY+priorityGain,event);

	TCallBack callBack(EventCancelFunc,TheClient);

	TheClient->SetCancelFunction(callBack);

	group.SetOrdinalPosition(position,priority);

	}

void CTEventTest::AddExpectedKey(TInt aEventCode, TInt aScanCode, TInt aCode/*=0*/, TInt aRepeats/*=0*/, TUint aModifiers/*=KModifiersIgnore*/)

	{

	TPckgBuf<TWsEvent> evtPkg;

	TWsEvent& event=evtPkg();

	if (aEventCode==EEventKey && aCode==0)

		aCode=aScanCode;

	event.SetType(aEventCode);

	event.SetHandle((TInt)iQueueClient->iGroup);

	event.Key()->iCode=aCode;

	event.Key()->iScanCode=aScanCode;

	event.Key()->iModifiers=aModifiers;

	event.Key()->iRepeats=aRepeats;

	iQueueClient->AddExpectedEvent(event);

	if (iAddToClick)

		{

		if (aModifiers == KModifiersIgnore)

			{

			// Key click tests assume zero modifiers in click event by default

			event.Key()->iModifiers = 0;

			}

		iClick.CommandReply(EClickEventAdd,evtPkg);

		}

	}

void CTEventTest::AddExpectedKeyDownUp(TInt aScanCode, TInt aCode/*=0*/, TInt aRepeats/*=0*/, TUint aModifiers/*=KModifiersIgnore*/)

	{

	__ASSERT_DEBUG(aScanCode<'a' || aScanCode>'z',AutoPanic(EAutoPanicScanCapital));

	// EModiferAutorepeatable can be present in EEventKey but is never valid

	// in EEventKeyDown and EEventKeyUp. 

	TUint modifiersDownUp = (aModifiers == KModifiersIgnore) ?

		aModifiers : aModifiers & ~EModifierAutorepeatable;

	AddExpectedKey(EEventKeyDown,aScanCode,0,aRepeats,modifiersDownUp);

	AddExpectedKey(EEventKey,aScanCode,aCode,aRepeats,aModifiers);

	AddExpectedKey(EEventKeyUp,aScanCode,0,aRepeats,modifiersDownUp);

	}

void CTEventTest::AddExpectedEvent(TInt aEventCode, CTWinBase* aWin)

	{

	TWsQTEvent event;

	event.iType=aEventCode;

	event.iHandle=REINTERPRET_CAST(TInt,aWin);

	iQueueClient->AddExpectedEvent(event);

	}

void CTEventTest::AddExpectedEvent(TInt aEventCode, RWindowGroup* aWindow)

	{

	TWsQTEvent event;

	event.iType=aEventCode;

	event.iHandle=(TUint32)aWindow;

	iQueueClient->AddExpectedEvent(event);

	}

void CTEventTest::AddExpectedEvent(TInt aEventCode)

	{

	AddExpectedEvent(aEventCode,iQueueClient->iGroup);

	}

void CTEventTest::AddExpectedErrorMessage(TWsErrorMessage::TErrorCategory aCategory, TInt aError)

	{

	TWsQTEvent event;

	event.iType=EEventErrorMessage;

	event.iHandle=(TInt)iQueueClient->iGroup;

	event.ErrorMessage()->iErrorCategory=aCategory;

	event.ErrorMessage()->iError=aError;

	iQueueClient->AddExpectedEvent(event);

	}

void CTEventTest::CalculatePointerEvent(TWsEvent& aEvent,TPointerEvent::TType aType, TPoint aPos)

	{

#if !defined(TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA)

	TAdvancedPointerEvent& ptrEvent=*aEvent.Pointer();

	aEvent.SetType(EEventPointer);

	ptrEvent.iParentPosition=aPos;

	// SetHandle must be done after iParentPosition is set, but before iPosition is set.

	aEvent.SetHandle(reinterpret_cast<TInt>(iQueueClient->GetHandle(aPos)));	

	const TPoint3D point3D(aPos.iX, aPos.iY, 0);

	const TInt pointerEventModifiers=0;

	const TUint8 pointerNumber=0;

	aEvent.InitAdvancedPointerEvent(aType,pointerEventModifiers,point3D,pointerNumber);

#else	

	TPointerEvent& ptrEvent=*aEvent.Pointer();

	aEvent.SetType(EEventPointer);

	ptrEvent.iParentPosition=aPos;		//Must be done before next line

	aEvent.SetHandle(REINTERPRET_CAST(TInt,iQueueClient->GetHandle(aPos)));

	ptrEvent.iType=aType;

	ptrEvent.iModifiers=0;

	ptrEvent.iPosition=aPos;

#endif

	}

void CTEventTest::CalculatePointerCaptureEvent(TWsEvent& aEvent, TPointerEvent::TType aType, TPoint aPos, TInt aHandle)

	{

	TPointerEvent& ptrEvent=*aEvent.Pointer();

	aEvent.SetType(EEventPointer);

	ptrEvent.iParentPosition=aPos;		//Must be done before next line

	if(iVisWins1 && iVisWins2)

		{

		if (TRect(iQueueClient->ChildTopLeft(),iQueueClient->ChildSize()).Contains(aPos) &&

			!TRect(iQueueClient->ChildTopLeft()+TPoint(15,15),iQueueClient->ChildSize()).Contains(aPos))

			{

			aPos-=iQueueClient->ChildTopLeft();	//Pointer is on the first window

			aEvent.SetHandle((TInt)iVisWins1);

			}

		else if (TRect(iQueueClient->ChildTopLeft()+TPoint(15,15),iQueueClient->ChildSize()).Contains(aPos))

			{

			aPos-=(iQueueClient->ChildTopLeft()+TPoint(15,15));	//Pointer is on the second window

			aEvent.SetHandle((TInt)iVisWins2);

			}

		else if (TRect(TPoint(EWinPositionX,EWinPositionY),TSize(EWinWidth,EWinHeight)).Contains(aPos))

			{

			aPos-=TPoint(EWinPositionX,EWinPositionY);	//Pointer is on the parent window

			aEvent.SetHandle((TInt)iQueueClient->iWin);

			}

		else

			{

			aEvent.SetHandle((TInt)0);		//Pointer is not in the same window group

			}

		}

	ptrEvent.iType=aType;

	ptrEvent.iModifiers=0;

	if(aHandle!=0 && aHandle!=aEvent.Handle())

		{

		aEvent.SetHandle(aHandle);

		ptrEvent.iPosition=ptrEvent.iParentPosition-(iQueueClient->ChildTopLeft()+TPoint(15,15));

		}

	else

		{

		ptrEvent.iPosition=aPos;

		}

	}

void CTEventTest::AddExpectedPointerCapture(TPointerEvent::TType aType, TPoint aPos, TInt aHandle)

	{

	TPckgBuf<TWsQTEvent> evtPkg;

	CalculatePointerCaptureEvent(evtPkg(),aType,aPos,aHandle);

	iQueueClient->AddExpectedEvent(evtPkg());

	}

void CTEventTest::AddExpectedPointer(TPointerEvent::TType aType, TPoint aPos)

	{

	TPckgBuf<TWsQTEvent> evtPkg;

	CalculatePointerEvent(evtPkg(),aType,aPos);

	iQueueClient->AddExpectedEvent(evtPkg());

	if (iAddToClick)

		{

		evtPkg().Pointer()->iParentPosition+=TPoint(EWinPositionX,EWinPositionY);

		iClick.CommandReply(EClickEventAdd,evtPkg);

		}

	}

void CTEventTest::AddExpectedPointerClick(TPointerEvent::TType aType, TPoint aPos)