diff -r 000000000000 -r 5d03bc08d59c windowing/windowserver/tauto/TEvent.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/tauto/TEvent.CPP Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,7027 @@ +// Copyright (c) 1996-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 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 +#include + +#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"); + +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,iEventCount,eKeyCode,eKeyCode,wsKeyCode,wsKeyCode); + iTest->LOG_MESSAGE(buf); + } + wsKeyRepeat=wsEvent.Key()->iRepeats,eKeyRepeat=expectedEvent.Key()->iRepeats; + if ((wsKeyRepeat>0)!=(eKeyRepeat>0) || wsKeyRepeatLOG_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: + #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); + } + #endif + TestL(wsEvent.Key()->iScanCode==expectedEvent.Key()->iScanCode); + 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)LOG_MESSAGE(buf); + } + #endif + TestL(Abs(offset)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(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(aAnimDll))->Destroy(); + } + +/** + Destroys an REventAnimBase derived anim + @param aAnim REventAnimBase derived client-side handle to anim + */ +LOCAL_C void DestroyAnim(TAny* aAnim) + { + (static_cast(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 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 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 *rotations=new(ELeave) CArrayFixFlat(1); + iNumScrModes=TheClient->iScreen->NumScreenModes(); + TInt modes=Min(2,iNumScrModes); + TInt mode; + TInt rot; + CleanupStack::PushL(rotations); + for (mode=0;modeiScreen->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 + } + +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/*=0*/) + { + TPckgBuf 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) + iClick.CommandReply(EClickEventAdd,evtPkg); + } + +void CTEventTest::AddExpectedKeyDownUp(TInt aScanCode, TInt aCode/*=0*/, TInt aRepeats/*=0*/, TUint aModifiers/*=0*/) + { + __ASSERT_DEBUG(aScanCode<'a' || aScanCode>'z',AutoPanic(EAutoPanicScanCapital)); + AddExpectedKey(EEventKeyDown,aScanCode,0,aRepeats,aModifiers); + AddExpectedKey(EEventKey,aScanCode,aCode,aRepeats,aModifiers); + AddExpectedKey(EEventKeyUp,aScanCode,0,aRepeats,aModifiers); + } + +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(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 evtPkg; + CalculatePointerCaptureEvent(evtPkg(),aType,aPos,aHandle); + iQueueClient->AddExpectedEvent(evtPkg()); + } + +void CTEventTest::AddExpectedPointer(TPointerEvent::TType aType, TPoint aPos) + { + TPckgBuf 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) + { + TPckgBuf evtPkg; + CalculatePointerEvent(evtPkg(),aType,aPos); + evtPkg().Pointer()->iParentPosition+=TPoint(EWinPositionX,EWinPositionY); + iClick.CommandReply(EClickEventAdd,evtPkg); + } + +void CTEventTest::AddExpectedPointerDownUp(TPoint aPos) + { + AddExpectedPointer(TPointerEvent::EButton1Down,aPos); + AddExpectedPointer(TPointerEvent::EButton1Up,aPos); + } + +void CTEventTest::AddExpectedPointerScr(TPointerEvent::TType aType, TPoint aPos) + { + AddExpectedPointer(aType,TPoint(aPos.iX-EWinPositionX,aPos.iY-EWinPositionY)); + } + +void CTEventTest::AddExpectedPointerDownUpScr(TPoint aPos) + { + AddExpectedPointerDownUp(TPoint(aPos.iX-EWinPositionX,aPos.iY-EWinPositionY)); + } + +void CTEventTest::AddExpectedModifiersChanged(TInt aChangedModifiers, TInt aModifiers) + { + TWsQTEvent event; + event.iType=EEventModifiersChanged; + event.iHandle=(TInt)iQueueClient->iGroup; + event.ModifiersChanged()->iChangedModifiers=aChangedModifiers; + event.ModifiersChanged()->iModifiers=aModifiers; + iQueueClient->AddExpectedEvent(event); + } + +void CTEventTest::AddExpectedEnterExit(TInt aEventCode, TPoint aPos) + { + AddExpectedEvent(aEventCode,iQueueClient->GetHandle(aPos)); + } + +void CTEventTest::AddExpectedKeyAnim(TRawEvent::TType aEventCode, TInt aScanCode, TBool aEat) + { + TAnimRawEvent event; + event.iRawEvent.Set(aEventCode,aScanCode); + event.iEat=aEat; + TInt retVal = iAnim->AddEvent(event); + TEST(retVal==KErrNone); + if (retVal!=KErrNone) + INFO_PRINTF3(_L("iAnim->AddEvent(event) return value - Expected: %d, Actual: %d"), KErrNone, retVal); + + if (!aEat) + AddExpectedKey((aEventCode==TRawEvent::EKeyDown ? EEventKeyDown:EEventKeyUp),aScanCode); + } + +void CTEventTest::AddExpectedPointerAnim(TRawEvent::TType aEventCode, TPoint aPoint, TBool aEat/*=ETrue*/) + { + TAnimRawEvent event; + event.iRawEvent.Set(aEventCode,aPoint.iX,aPoint.iY); + event.iEat=aEat; + + TInt retVal = iAnim->AddEvent(event); + TEST(retVal==KErrNone); + if (retVal!=KErrNone) + INFO_PRINTF3(_L("iAnim->AddEvent(event) return value - Expected: %d, Actual: %d"), KErrNone, retVal); + + if (!aEat) + AddExpectedPointer((aEventCode==TRawEvent::EButton1Down ? TPointerEvent::EButton1Down:TPointerEvent::EButton1Up) + ,aPoint-TPoint(EWinPositionX,EWinPositionY)); + } + +void CTEventTest::AddExpectedVisibilityChange(TUint aFlags) + { + TWsQTEvent event; + event.iType=EEventWindowVisibilityChanged; + event.iHandle=(TInt)iVisWins1; + event.VisibilityChanged()->iFlags=aFlags; + iQueueClient->AddExpectedEvent(event); + } + +void CTEventTest::AddExpectedVisibilityChange(TUint aFlags, CTBlankWindow* aWindow) + { + TWsQTEvent event; + event.iType=EEventWindowVisibilityChanged; + event.iHandle=(TInt)aWindow; + event.VisibilityChanged()->iFlags=aFlags; + iQueueClient->AddExpectedEvent(event); + } + +void CTEventTest::SimulatePointerWin(TRawEvent::TType aType, TInt aX, TInt aY) + { + SimulatePointer(aType,EWinPositionX+aX,EWinPositionY+aY+iYOffset); + } + +void CTEventTest::SimulatePointerDownUpWin(TInt aX, TInt aY) + { + iTest->SimulatePointerDownUp(EWinPositionX+aX,EWinPositionY+aY+iYOffset); + } + +void CTEventTest::SimulatePointer(TRawEvent::TType aType, TInt aX, TInt aY) + { + iTest->SimulatePointer(aType,aX,aY+iYOffset); + } + +#if !defined(TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA) +void CTEventTest::SimulateButton1DownWithSimulatedMove(TInt aX, TInt aY) + { + if(iIs3DPointer) + { + // With advanced pointer events we can have an XYInputType of Pointer coupled with 3DPointer + // which now makes MovesAvailable return ETrue rahter than EFalse, which in turn stops the simulated + // Emove from being generated. + // So... + // If MovesAvailable() returns ETrue, then this move will be used, and the WServ simulated move wont be generated + // If MovesAvailable() returns EFalse, then this move will be filtered out, and the WServ simulated move will be generated + SimulatePointer(TRawEvent::EPointerMove,aX,aY); + } + // then the original button down event + SimulatePointer(TRawEvent::EButton1Down,aX,aY); + } +#endif + +void CTEventTest::NextSetOfEventsL() + { + iQueueClient->ResetCount(iEventSet); + switch (iTest->iState) + { + case 1: + QueuePurge_NextSetOfEventsL(); + break; + case 2: + SendEventTest_NextSetOfEvents(); + break; + case 4: + InvisibleWindow_NextSetOfEvents(); + break; + case 5: + JavaAdditions_NextSetOfEvents(); + break; + case 6: + WinCap_NextSetOfEvents(); + break; + case 7: + XyInputType_NextSetOfEvents(); + break; + case 8: + MovingPointerCursor_NextSetOfEventsL(); + break; + case 9: + RotatedMode_NextSetOfEventsL(); + break; + case 10: + AnimEvent_NextSetOfEventsL(); + break; + case 11: + FocusChanged_NextSetOfEventsL(); + break; + case 12: + StopEvents_NextSetOfEventsL(); + break; + case 13: + VirtualKeyboard_NextSetOfEventsL(); + break; + case 14: + KeyClicks_NextSetOfEvents(); + break; + case 15: + CaptureLong_NextSetOfEventsL(); + break; + case 16: + Password_NextSetOfEvents(); + break; + case 17: + GroupListChanged_NextSetOfEventsL(); + break; + case 18: + RepeatableKeysL(); + break; + case 19: + ScreenScaling_NextSetOfEventsL(); + break; + case 20: + VisibilityChanged_NextSetOfEventsL(); + break; + case 21: + CheckTimeStamp_NextSetOfEventsL(); + break; + case 22: + PointerCapture_NextSetOfEventsL(); + break; + case 23: + EventHandlerRemoval_NextSetOfEventsL(); + break; + // Note that case 24 (which is KTest24) does not use NextSetOfEventsL() + case 25: + MismatchedCapture_NextSetOfEventsL(); + break; + case 26: + PointerBufferPurge_NextSetOfEventsL(); + break; + case 27: + RawEventRepeatTest_NextSetOfEventsL(); + break; + +#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS +#ifndef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA + case 28: + SurfaceVisibilityChanged1_NextSetOfEventsL(); + break; + case 29: + SurfaceVisibilityChanged2_NextSetOfEventsL(); + break; + case 30: + SurfaceVisibilityChanged3_NextSetOfEventsL(); + break; +#endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA +#endif // SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS + + default: + AutoPanic(EAutoPanicWrongTest); + } + } + +void CTEventTest::TriggerOomMessage(TTimeIntervalMinutes aPeriod) + { + TTime time; + if (aPeriod.Int()!=0) // adjust time to affect Oom message triggering + { + time.HomeTime(); + User::SetHomeTime(time+aPeriod); + } + RBlankWindow win(TheClient->iWs); + win.Construct(*(TheClient->iGroup->WinTreeNode()),1); + win.SetColor(TRgb::Gray4(1)); + win.SetExtent(TPoint(10,10),TheClient->iGroup->Size()-TSize(20,20)); + TheClient->iWs.HeapSetFail(RHeap::EDeterministic,1); + win.Activate(); + TheClient->iWs.Flush(); + TheClient->iWs.HeapSetFail(RHeap::ENone,0); + if (aPeriod.Int()!=0) + { + time.HomeTime(); + User::SetHomeTime(time-aPeriod); + } + win.Close(); + } + +TBool CTEventTest::SetClickType(TClickOutputModes aType) + { + TPckgBuf intPkg; + intPkg()=aType; + TInt err=iClick.CommandReply(EClickCommandSetOutput,intPkg); + if (err!=KErrNone) + Failed(); + return err; + } + +void CTEventTest::CreateEventTestGroup() + { + iEventTestGroup=RWindowGroup(TheClient->iWs); + iEventTestGroup.Construct(123, EFalse); + iEventTestGroup.SetName(_L("Fred")); + } + +void CTQueueClient::CreateEventTestGroupOnSecondScreenL() + { + const TInt KSndScreenNo=1; + iSndScreen=new(ELeave) CWsScreenDevice(iWs); + User::LeaveIfError(iSndScreen->Construct(KSndScreenNo)); + iWinGp1 = new(ELeave) RWindowGroup(iWs); + User::LeaveIfError(iWinGp1->Construct((TUint32)iWinGp1,ETrue,iSndScreen)); + iWinGp2 = new (ELeave) RWindowGroup(iWs); + User::LeaveIfError(iWinGp2->Construct((TUint32)iWinGp2,ETrue,iSndScreen)); + } + +void CTQueueClient::CloseEventTestGroupOnSecondScreen() + { + if(iWinGp1) + { + iWinGp1->Close(); + delete iWinGp1; + iWinGp1=NULL; + } + if(iWinGp2) + { + iWinGp2->Close(); + delete iWinGp2; + iWinGp2=NULL; + } + if(iSndScreen) + { + delete iSndScreen; + iSndScreen = NULL; + } + } + +void CTEventTest::CloseEventTestGroup() + { + iEventTestGroup.Close(); + } + +void CTEventTest::CreateAndCloseEventTestGroup() +// +// Create and close a window group to test sending of group changed messages +// + { + CreateEventTestGroup(); + CloseEventTestGroup(); + } + +void CTEventTest::QueuePurge_NextSetOfEventsL() + { +#if defined(LOGGING) + TLogMessageText logMessageText; + _LIT(KSet,"QueuePurge SetOfEvents: %d of 11"); + logMessageText.Format(KSet,iEventSet); + TheClient->LogMessage(logMessageText); +#endif + iTheClientFlush=TheClient->iWs.SetAutoFlush(ETrue); + iQuequeClientFlush=iQueueClient->iWs.SetAutoFlush(ETrue); + switch(iEventSet++) + { + case 0: + iTest->SimulateKey(TRawEvent::EKeyDown,32); + iTest->SimulateKey(TRawEvent::EKeyUp,32); + CreateAndCloseEventTestGroup(); + SimulatePointer(TRawEvent::EButton1Down,10,20); + SimulatePointer(TRawEvent::EButton1Up,20,30); + iTest->SimulateEvent(TRawEvent::ESwitchOn); + CreateAndCloseEventTestGroup(); + // + AddExpectedEvent(EEventFocusGained); + AddExpectedKey(EEventKeyDown,32); + AddExpectedKey(EEventKeyUp,32); + AddExpectedEvent(EEventWindowGroupsChanged); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(10-EWinPositionX,20-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(20-EWinPositionX,30-EWinPositionY)); + AddExpectedEvent(EEventSwitchOn); + break; + case 1: + { + for(TInt count=0;count<100;count++) + { + iTest->SimulateKey(TRawEvent::EKeyDown,'A'+(count%26)); + iTest->SimulateKey(TRawEvent::EKeyUp,'A'+(count%26)); + } + for(TInt count2=0;count2iGroup->GroupWin()->EnableModifierChangedEvents(0xFFFFFFFF, EEventControlOnlyWhenVisible)); + for(TInt count=0;count<20;count++) + { + iTest->SimulateEvent(TRawEvent::ESwitchOn); + iTest->SimulateEvent(TRawEvent::ESwitchOn); + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeyLeftShift); + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeyRightShift); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeyRightShift); + iTest->SimulateEvent(TRawEvent::ESwitchOn); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeyLeftShift); + } + for(TInt count2=0;count2<60;count2++) + iTest->SimulateKey(TRawEvent::EKeyDown,'A'); + AddExpectedEvent(EEventSwitchOn); + AddExpectedModifiersChanged(EModifierLeftShift|EModifierRightShift|EModifierShift,0); + for(TInt count3=0;count3iGroup->GroupWin()->DisableModifierChangedEvents(); + } + break; + case 3: + { + SimulatePointer(TRawEvent::EButton1Up,10,20); + SimulatePointer(TRawEvent::EButton2Up,11,22); + SimulatePointer(TRawEvent::EButton1Down,12,23); + SimulatePointer(TRawEvent::EPointerMove,13,24); + SimulatePointer(TRawEvent::EButton3Down,15,25); + SimulatePointer(TRawEvent::EButton1Up,14,24); + for(TInt count2=0;count2<60;count2++) + iTest->SimulateKey(TRawEvent::EKeyDown,'A'); + SimulatePointer(TRawEvent::EButton3Up,15,25); // Should get stripped by unmatched purged down handling code + iTest->SimulateKey(TRawEvent::EKeyUp,'A'); // To stop repeats + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(10-EWinPositionX,20-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton2Up, TPoint(11-EWinPositionX,22-EWinPositionY)); + for(TInt count3=0;count3SimulateKey(TRawEvent::EKeyDown,'B'); + SimulatePointer(TRawEvent::EButton1Down,12,23); + SimulatePointer(TRawEvent::EPointerMove,13,24); + iTest->SimulateKey(TRawEvent::EKeyUp,'B'); + SimulatePointer(TRawEvent::EButton3Down,15,25); + SimulatePointer(TRawEvent::EButton1Up,14,24); + iQueueClient->iWs.PurgePointerEvents(); + iTest->SimulateEvent(TRawEvent::ESwitchOn); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(10-EWinPositionX,20-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton2Up, TPoint(11-EWinPositionX,22-EWinPositionY)); + AddExpectedKey(EEventKeyDown,'B'); + AddExpectedKey(EEventKey,'B','b'); + AddExpectedKey(EEventKeyUp,'B'); +// AddExpectedPointer(TPointerEvent::EButton3Down, TPoint(15-EWinPositionX,25-EWinPositionY)); + AddExpectedEvent(EEventSwitchOn); // To check pointer events purged okay + } + break; + case 5: + CreateEventTestGroup(); + AddExpectedEvent(EEventWindowGroupsChanged); + break; + case 6: + CloseEventTestGroup(); + AddExpectedEvent(EEventWindowGroupsChanged); + break; + case 7: + iQueueClient->iGroup->GroupWin()->DisableGroupChangeEvents(); + CreateAndCloseEventTestGroup(); + iTest->SimulateEvent(TRawEvent::ESwitchOn); + AddExpectedEvent(EEventSwitchOn); + break; + case 8: + SimulatePointer(TRawEvent::EButton1Down,12,23); + iQueueClient->iWs.PurgePointerEvents(); + SimulatePointer(TRawEvent::EButton1Up,13,24); + SimulatePointer(TRawEvent::EButton2Down,12,23); + iQueueClient->iWs.PurgePointerEvents(); + SimulatePointer(TRawEvent::EButton2Up,13,24); + SimulatePointer(TRawEvent::EButton3Down,12,23); + iQueueClient->iWs.PurgePointerEvents(); + SimulatePointer(TRawEvent::EButton3Up,13,24); +// + SendEvent(EEventUser); + AddExpectedEvent(EEventUser); + break; + case 9: + { + for(TInt count5=0;count5<500;count5++) + { + RWindowGroup group(TheClient->iWs); + group.Construct(ENullWsHandle); + group.EnableReceiptOfFocus(EFalse); + group.Close(); + SimulatePointer(TRawEvent::EButton1Up,10,20); + } + for(TInt count4=0;count4iGroup->GroupWin(); + User::LeaveIfError(group->EnableOnEvents(EEventControlOnlyWithKeyboardFocus)); + iTest->SimulateEvent(TRawEvent::ESwitchOn); + SimulatePointer(TRawEvent::EButton3Down,EWinPositionX,EWinPositionY); + AddExpectedEvent(EEventSwitchOn); + AddExpectedPointer(TPointerEvent::EButton3Down, TPoint(0,0)); +// + group->SetOrdinalPosition(-1); + TheClient->iWs.Finish(); + iTest->SimulateEvent(TRawEvent::ESwitchOn); // Shouldn't get it as in background this time + AddExpectedEvent(EEventFocusLost); + group->SetOrdinalPosition(0); + TheClient->iWs.Finish(); + AddExpectedEvent(EEventFocusGained); +// + User::LeaveIfError(group->EnableOnEvents(EEventControlOnlyWhenVisible)); + User::LeaveIfError(group->EnableModifierChangedEvents(EModifierShift, EEventControlOnlyWhenVisible)); + iTest->SimulateEvent(TRawEvent::ESwitchOn); // Should get this as window still visible + AddExpectedEvent(EEventSwitchOn); + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeyLeftShift); // Should get modifier changed event as window still visible + AddExpectedModifiersChanged(EModifierShift,EModifierShift); + AddExpectedKey(EEventKeyDown,EStdKeyLeftShift); + SimulatePointer(TRawEvent::EButton1Down,EWinPositionX,EWinPositionY); + SimulatePointer(TRawEvent::EButton1Up,EWinPositionX,EWinPositionY); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(0,0)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(0,0)); + iQueueClient->iWin->SetPos(TPoint(-EWinWidth,-EWinHeight)); + TheClient->iWs.Finish(); +// The following two events shouldn't cause an on or mod changed event as the window is now hidden + iTest->SimulateEvent(TRawEvent::ESwitchOn); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeyLeftShift); + AddExpectedKey(EEventKeyUp,EStdKeyLeftShift); +// + iQueueClient->iWin->SetPos(TPoint(EWinPositionX,EWinPositionY)); + TheClient->iWs.Finish(); + } + break; + case 11: + { + RWindowGroup *group=iQueueClient->iGroup->GroupWin(); + SendEvent(EEventUser); + AddExpectedEvent(EEventUser); + + if(iTest->IsFullRomL()) + break; +// +// Test focus only messages when with and without focus +// + User::LeaveIfError(group->EnableErrorMessages(EEventControlOnlyWithKeyboardFocus)); + TriggerOomMessage(TTimeIntervalMinutes(3)); + AddExpectedErrorMessage(TWsErrorMessage::EDrawingRegion,KErrNoMemory); + SendEvent(EEventUser); + AddExpectedEvent(EEventUser); + group->SetOrdinalPosition(1); + TriggerOomMessage(TTimeIntervalMinutes(3)); + AddExpectedEvent(EEventFocusLost); + group->SetOrdinalPosition(0); + AddExpectedEvent(EEventFocusGained); + SendEvent(EEventUser+1); + AddExpectedEvent(EEventUser+1); +// +// Test focus only messages when with visible and invisible +// + User::LeaveIfError(group->EnableErrorMessages(EEventControlOnlyWhenVisible)); + TriggerOomMessage(TTimeIntervalMinutes(3)); + AddExpectedErrorMessage(TWsErrorMessage::EDrawingRegion,KErrNoMemory); + iQueueClient->iWin->SetPos(TPoint(-EWinWidth,-EWinHeight)); + TriggerOomMessage(TTimeIntervalMinutes(3)); + SendEvent(EEventUser+2); + AddExpectedEvent(EEventUser+2); + iQueueClient->iWin->SetPos(TPoint(EWinPositionX,EWinPositionY)); +// +// Check always mode sends an event +// + User::LeaveIfError(group->EnableErrorMessages(EEventControlAlways)); + TriggerOomMessage(TTimeIntervalMinutes(3)); + AddExpectedErrorMessage(TWsErrorMessage::EDrawingRegion,KErrNoMemory); +// + iQueueClient->iWin->SetPos(TPoint(-EWinWidth,-EWinHeight)); + TriggerOomMessage(TTimeIntervalMinutes(3)); + AddExpectedErrorMessage(TWsErrorMessage::EDrawingRegion,KErrNoMemory); + iQueueClient->iWin->SetPos(TPoint(EWinPositionX,EWinPositionY)); +// + group->SetOrdinalPosition(1); + AddExpectedEvent(EEventFocusLost); + TriggerOomMessage(TTimeIntervalMinutes(3)); + AddExpectedErrorMessage(TWsErrorMessage::EDrawingRegion,KErrNoMemory); + group->SetOrdinalPosition(0); + AddExpectedEvent(EEventFocusGained); +// +// Check timing of OOM messages +// + TriggerOomMessage(TTimeIntervalMinutes(3)); + AddExpectedErrorMessage(TWsErrorMessage::EDrawingRegion,KErrNoMemory); + TriggerOomMessage(TTimeIntervalMinutes(0)); + User::After(TTimeIntervalMicroSeconds32(1100000)); // 1.1 second + TriggerOomMessage(TTimeIntervalMinutes(0)); + SendEvent(EEventUser+3); + AddExpectedEvent(EEventUser+3); + TriggerOomMessage(TTimeIntervalMinutes(3)); // Forward by a 2 minutes plus the 1.1 from previous test should trigger an OOM event + AddExpectedErrorMessage(TWsErrorMessage::EDrawingRegion,KErrNoMemory); + SendEvent(EEventUser+4); + AddExpectedEvent(EEventUser+4); + TriggerOomMessage(TTimeIntervalMinutes(-1)); // Clock going backwards should trigger an event + AddExpectedErrorMessage(TWsErrorMessage::EDrawingRegion,KErrNoMemory); + User::After(TTimeIntervalMicroSeconds32(800000)); // 8/10ths of a second + TriggerOomMessage(TTimeIntervalMinutes(0)); // Shouldn't trigger an event + SendEvent(EEventUser+5); + AddExpectedEvent(EEventUser+5); + } + break; + default: + TheClient->iWs.DebugInfo(EWsDebugSetEventQueueTest,ETrue); + TRAPD(err, EventQueueExpansionTestL()); + if (err!=KErrNone) + { + iFailed=ETrue; + } + TheClient->iWs.DebugInfo(EWsDebugSetEventQueueTest,EFalse); + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.SetAutoFlush(iTheClientFlush); + iQueueClient->iWs.SetAutoFlush(iQuequeClientFlush); + } + +// Used for testing PDEF112243. +// Create RWsSession/RWindowGroup/RBlankWindow in a loop. In case of odd loop, +// close the session which causes the previous window to gain focus. Also go +// on adding events to the previous session. Along with some change in product +// code and this test code we get some space/memory before globaleventqueue, +// which is the problem faced by licensee for this defect. +void CTEventTest::EventQueueExpansionTestL() + { + const TInt numClients = 5; + TInt cliHanGrpWin = 777; + TInt cliHanBlkWin = 888; + TInt pushed=0; + RWsSession wsSession[numClients]; + RWindowGroup groupWin[numClients]; + RBlankWindow blankWin[numClients]; + + for (TInt i = 0; i < numClients; i++) + { + User::LeaveIfError(wsSession[i].Connect()); + CleanupClosePushL(wsSession[i]); + + groupWin[i] = RWindowGroup(wsSession[i]); + User::LeaveIfError(groupWin[i].Construct(cliHanGrpWin++)); + CleanupClosePushL(groupWin[i]); + groupWin[i].DefaultOwningWindow(); + + blankWin[i] = RBlankWindow(wsSession[i]); + User::LeaveIfError(blankWin[i].Construct(groupWin[i], cliHanBlkWin++)); + if (i%2 == 0) + { + CleanupClosePushL(blankWin[i]); + pushed++; + } + blankWin[i].Activate(); + + if (i%2 == 1) + { + CleanupStack::Pop(2, &wsSession[i]); + wsSession[i].Close(); + + TRawEvent rawEvent; + for (TInt count=0; count < 40; count++) + { + rawEvent.Set(TRawEvent::EKeyDown,'A'+(i%26)); + wsSession[i-1].SimulateRawEvent(rawEvent); + + rawEvent.Set(TRawEvent::EKeyUp,'A'+(i%26)); + wsSession[i-1].SimulateRawEvent(rawEvent); + } + } + } + CleanupStack::PopAndDestroy(pushed*3, &wsSession[0]); + } + +void CTEventTest::doSendEvent(TWsEvent &aEvent) + { + iQueueClient->iWs.SendEventToWindowGroup(iQueueClient->WindowGroupIdentifier(),aEvent); + } + +void CTEventTest::SendKey(TInt aEventCode, TInt aScanCode, TInt aCode/*=0*/, TInt iRepeats/*=0*/) + { + TWsEvent event; + if (aEventCode==EEventKey && aCode==0) + aCode=aScanCode; + event.SetType(aEventCode); + event.Key()->iCode=aCode; + event.Key()->iScanCode=aScanCode; + event.Key()->iModifiers=0; + event.Key()->iRepeats=iRepeats; + doSendEvent(event); + } + +void CTEventTest::SendEvent(TInt aEventCode) + { + TWsQTEvent event; + event.SetType(aEventCode); + doSendEvent(event); + } + +void CTEventTest::SimulateAndCheck(TPoint aOrigin,TSize aScale,TInt aXOffset,TInt aYOffset,TPointerEvent::TType aEventType,TRect aPointerCursorArea) + { + TPoint ptCheck=PhysicalToLogical(TPoint(aOrigin.iX+aXOffset,aOrigin.iY+aYOffset)-aOrigin,aScale); + if (ptCheck.iX < aPointerCursorArea.iTl.iX) + { + ptCheck.iX=aPointerCursorArea.iTl.iX; + } + else if (ptCheck.iX > aPointerCursorArea.iBr.iX) + { + ptCheck.iX=aPointerCursorArea.iBr.iX; + } + if (ptCheck.iY < aPointerCursorArea.iTl.iY) + { + ptCheck.iY=aPointerCursorArea.iTl.iY; + } + else if (ptCheck.iY > aPointerCursorArea.iBr.iY) + { + ptCheck.iY=aPointerCursorArea.iBr.iY; + } + AddExpectedPointer(aEventType,TPoint(ptCheck.iX-EWinPositionX,ptCheck.iY-EWinPositionY)); + } + +void CTEventTest::CheckPointerCursorInDifferentScreenMode(TSizeMode aMode,TPoint aOrigin) + { + aMode.iOrigin=aOrigin; + iQueueClient->iScreen->SetCurrentScreenModeAttributes(aMode); + iQueueClient->iScreen->SetAppScreenMode(iCurrentMode); //This makes the App pick up the new mode parameters + TheClient->iScreen->SetAppScreenMode(iCurrentMode); //Ditto + iQueueClient->iScreen->SetScreenMode(iCurrentMode); //This causes all the windows to be updated + + //.. Tests the general pointer cursor area setting and getting + RWsSession& ws=iQueueClient->iWs; + TRect rect=ws.PointerCursorArea(iCurrentMode); //ws.PointerCursorArea() by default gets first screen mode's pointer cursor area so use other overloaded function + TPoint origin=iQueueClient->iScreen->GetScreenModeOrigin(iCurrentMode); + TSize scale=iQueueClient->iScreen->GetScreenModeScale(iCurrentMode); + TSize fullScreenModeSize=iQueueClient->iScreen->SizeInPixels(); + TRect rect1(PhysicalToLogical(TPoint(),scale),PhysicalToLogical(fullScreenModeSize.AsPoint()-origin,scale)); + TRect rect2=rect1; + rect2.Shrink(20,20); + ws.SetPointerCursorArea(iCurrentMode,rect1); + TEST(ws.PointerCursorArea(iCurrentMode)==rect1); + ws.SetPointerCursorArea(iCurrentMode,rect2); + TEST(ws.PointerCursorArea(iCurrentMode)==rect2); + ws.SetPointerCursorArea(iCurrentMode,rect); + TEST(ws.PointerCursorArea(iCurrentMode)==rect); + + //.. Test events are restricted to correct pointer cursor area + TRect rectPointerCursorArea(10,10,51,51); + iQueueClient->iWs.SetPointerCursorArea(iCurrentMode,rectPointerCursorArea); + TPoint screenModeOrigin=iQueueClient->iScreen->GetDefaultScreenModeOrigin(); + + SimulatePointer(TRawEvent::EButton1Down,screenModeOrigin.iX+5,screenModeOrigin.iY+5); + SimulatePointer(TRawEvent::EButton1Up,screenModeOrigin.iX+25,screenModeOrigin.iY+25); + SimulatePointer(TRawEvent::EButton1Down,screenModeOrigin.iX+50,screenModeOrigin.iY+50); + SimulatePointer(TRawEvent::EButton1Up,screenModeOrigin.iX+75,screenModeOrigin.iY+75); + + SimulatePointer(TRawEvent::EButton1Down,screenModeOrigin.iX+10,screenModeOrigin.iY+15); + SimulatePointer(TRawEvent::EButton1Up,screenModeOrigin.iX+20,screenModeOrigin.iY+5); + SimulatePointer(TRawEvent::EButton1Down,screenModeOrigin.iX+35,screenModeOrigin.iY+40); + SimulatePointer(TRawEvent::EButton1Up,screenModeOrigin.iX+45,screenModeOrigin.iY+70); + + SimulateAndCheck(screenModeOrigin,aMode.iScreenScale,5,5,TPointerEvent::EButton1Down,rectPointerCursorArea); + SimulateAndCheck(screenModeOrigin,aMode.iScreenScale,25,25,TPointerEvent::EButton1Up,rectPointerCursorArea); + SimulateAndCheck(screenModeOrigin,aMode.iScreenScale,50,50,TPointerEvent::EButton1Down,rectPointerCursorArea); + SimulateAndCheck(screenModeOrigin,aMode.iScreenScale,75,75,TPointerEvent::EButton1Up,rectPointerCursorArea); + + SimulateAndCheck(screenModeOrigin,aMode.iScreenScale,10,15,TPointerEvent::EButton1Down,rectPointerCursorArea); + SimulateAndCheck(screenModeOrigin,aMode.iScreenScale,20,5,TPointerEvent::EButton1Up,rectPointerCursorArea); + SimulateAndCheck(screenModeOrigin,aMode.iScreenScale,35,40,TPointerEvent::EButton1Down,rectPointerCursorArea); + SimulateAndCheck(screenModeOrigin,aMode.iScreenScale,45,70,TPointerEvent::EButton1Up,rectPointerCursorArea); + } + +void CTEventTest::SendEventTest_NextSetOfEvents() + { + TTimeIntervalMicroSeconds32 initialTime,time; + TheClient->iWs.GetKeyboardRepeatRate(initialTime,time); + switch(iEventSet++) + { + case 0: + SendKey(EEventKeyDown,1); + SendKey(EEventKeyDown,2); + SendEvent(EEventUser); + SendKey(EEventKeyUp,1); + SendKey(EEventKeyUp,2); + SendEvent(EEventUser+1); + SendEvent(EEventUser+2); +// + AddExpectedEvent(EEventFocusGained); + AddExpectedKey(EEventKeyDown,1); + AddExpectedKey(EEventKeyDown,2); + AddExpectedEvent(EEventUser); + AddExpectedKey(EEventKeyUp,1); + AddExpectedKey(EEventKeyUp,2); + AddExpectedEvent(EEventUser+1); + AddExpectedEvent(EEventUser+2); + break; + case 1: + #if defined(SCREEN_MODE_TESTING) + if (iNumScrModes>1) + { + iQueueClient->iGroup->GroupWin()->EnableScreenChangeEvents(); + + if (SetClickType(EClickCheck)) + return; + iAddToClick=ETrue; + + iQueueClient->iScreen->SetScreenMode(1); + + iAddToClick=EFalse; + SetClickType(EClickNone); + + AddExpectedEvent(EEventScreenDeviceChanged); + SendEvent(EEventUser); + AddExpectedEvent(EEventUser); + iQueueClient->iGroup->GroupWin()->DisableScreenChangeEvents(); + if (iQueueClient->iScreen->ScreenModeEnforcement()==ESizeEnforcementPixelsAndRotation) + AddExpectedEvent(EEventFocusLost); + } + #endif + SendEvent(EEventUser+1); + AddExpectedEvent(EEventUser+1); + break; + case 2: + #if defined(SCREEN_MODE_TESTING) + if (iNumScrModes>1) + { + iQueueClient->iGroup->GroupWin()->EnableScreenChangeEvents(); + + if (SetClickType(EClickCheck)) + return; + iAddToClick=ETrue; + + iQueueClient->iScreen->SetScreenMode(0); + iQueueClient->iScreen->SetScreenMode(1); + iQueueClient->iScreen->SetScreenMode(0); + + iAddToClick=EFalse; + SetClickType(EClickNone); + + AddExpectedEvent(EEventScreenDeviceChanged); // Only one event should get queued + if (iQueueClient->iScreen->ScreenModeEnforcement()==ESizeEnforcementPixelsAndRotation) + AddExpectedEvent(EEventFocusGained); + SendEvent(EEventUser+2); + AddExpectedEvent(EEventUser+2); + iQueueClient->iGroup->GroupWin()->DisableScreenChangeEvents(); + } + #endif + SendEvent(EEventUser+3); + AddExpectedEvent(EEventUser+3); + break; + case 3: + #if defined(SCREEN_MODE_TESTING) + if (iNumScrModes>1) + { + iQueueClient->iGroup->GroupWin()->EnableScreenChangeEvents(); + iQueueClient->iGroup->GroupWin()->DisableScreenChangeEvents(); + + if (SetClickType(EClickCheck)) + return; + iAddToClick=ETrue; + + iQueueClient->iScreen->SetScreenMode(0); + + iAddToClick=EFalse; + SetClickType(EClickNone); + + SendEvent(EEventUser+1); + AddExpectedEvent(EEventUser+1); + } + #endif + SendEvent(EEventUser+4); + AddExpectedEvent(EEventUser+4); + break; + case 4: + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeySpace); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+time.Int()/3); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKey,EStdKeySpace,' '); + AddExpectedKey(EEventKey,EStdKeySpace,' ',1); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + break; + case 5: //To test sending a key event with iRepeats!=0 + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeySpace); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+time.Int()/3); + SendKey(EEventKey,EStdKeyHome,EKeyHome,0); + User::After(initialTime.Int()+time.Int()/3); + SendKey(EEventKey,EStdKeyEnd,EKeyEnd,12345); + User::After(initialTime.Int()+time.Int()/3); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKey,EStdKeySpace,' '); + AddExpectedKey(EEventKey,EStdKeySpace,' ',1); + AddExpectedKey(EEventKey,EStdKeyHome,EKeyHome); + AddExpectedKey(EEventKey,EStdKeySpace,' ',1); + AddExpectedKey(EEventKey,EStdKeyEnd,EKeyEnd,1); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + break; + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +void CTEventTest::InvisibleWindow_NextSetOfEvents() + { + switch(iEventSet++) + { + case 0: + SimulatePointer(TRawEvent::EButton1Down,45,30); + SimulatePointer(TRawEvent::EButton1Up,45,30); + SimulatePointer(TRawEvent::EButton1Down,20,10); + SimulatePointer(TRawEvent::EButton1Up,20,10); + TheClient->iWs.Flush(); + iQueueClient->iChildWin->BaseWin()->SetVisible(EFalse); + iQueueClient->iChildWin->BaseWin()->SetVisible(ETrue); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,46,31); + SimulatePointer(TRawEvent::EButton1Up,46,31); + AddExpectedEvent(EEventFocusGained); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(20-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(20-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(46-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(46-EWinPositionX,31-EWinPositionY)); + break; + case 1: + SimulatePointer(TRawEvent::EButton1Down,21,11); + SimulatePointer(TRawEvent::EButton1Up,21,11); + SimulatePointer(TRawEvent::EButton1Down,44,30); + SimulatePointer(TRawEvent::EButton1Up,44,30); + TheClient->iWs.Flush(); + iQueueClient->iWin->BaseWin()->SetVisible(EFalse); + iQueueClient->iWin->BaseWin()->SetVisible(ETrue); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,19,12); + SimulatePointer(TRawEvent::EButton1Up,19,12); + SimulatePointer(TRawEvent::EButton1Down,47,32); + SimulatePointer(TRawEvent::EButton1Up,47,32); + /*AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(44-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(44-EWinPositionX,30-EWinPositionY));*/ + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(19-EWinPositionX,12-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(19-EWinPositionX,12-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(47-EWinPositionX,32-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(47-EWinPositionX,32-EWinPositionY)); + break; + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +#define TOP16A 0xAAAA0000 +#define TOP16B 0x55550000 +void CTEventTest::JavaAdditions_NextSetOfEvents() + { + switch(iEventSet++) + { + case 0: + SimulatePointer(TRawEvent::EButton1Down,45,30); + SimulatePointer(TRawEvent::EButton1Up,45,30); + TheClient->iWs.Flush(); + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerMoveEvents,EPointerGenerateSimulatedMove); + iQueueClient->iWs.Flush(); +#if !defined(TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA) + SimulateButton1DownWithSimulatedMove(46,31); +#else + SimulatePointer(TRawEvent::EButton1Down,46,31); +#endif + SimulatePointer(TRawEvent::EButton1Up,46,31); + TheClient->iWs.Flush(); + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerMoveEvents,0); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,20,10); + SimulatePointer(TRawEvent::EButton1Up,20,10); + TheClient->iWs.Flush(); + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerMoveEvents,EPointerGenerateSimulatedMove); + iQueueClient->iWs.Flush(); +#if !defined(TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA) + SimulateButton1DownWithSimulatedMove(21,11); +#else + SimulatePointer(TRawEvent::EButton1Down,21,11); +#endif + SimulatePointer(TRawEvent::EButton1Up,21,11); + TheClient->iWs.Flush(); + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerMoveEvents,EPointerMoveEvents); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,22,12); + SimulatePointer(TRawEvent::EButton1Up,22,12); + TheClient->iWs.Flush(); + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerMoveEvents,EPointerGenerateSimulatedMove); + iQueueClient->iWs.Flush(); +#if !defined(TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA) + SimulateButton1DownWithSimulatedMove(23,13); +#else + SimulatePointer(TRawEvent::EButton1Down,23,13); +#endif + SimulatePointer(TRawEvent::EButton1Up,23,13); + TheClient->iWs.Flush(); + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerMoveEvents,EPointerFilterMove); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,24,14); + SimulatePointer(TRawEvent::EButton1Up,24,14); + AddExpectedEvent(EEventFocusGained); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(45-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(45-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(46-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(46-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(46-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(20-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(20-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(21-EWinPositionX,11-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(21-EWinPositionX,11-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(21-EWinPositionX,11-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(22-EWinPositionX,12-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(22-EWinPositionX,12-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(23-EWinPositionX,13-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(23-EWinPositionX,13-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(23-EWinPositionX,13-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(24-EWinPositionX,14-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(24-EWinPositionX,14-EWinPositionY)); + break; + #if defined(__WINS__) + case 1: + { + RWindowGroup *group=iQueueClient->iGroup->GroupWin(); + group->SetOrdinalPosition(0); + iTest->SimulateKey(TRawEvent::EKeyDown,'2'|TOP16A); + iTest->SimulateKey(TRawEvent::EKeyUp,'2'); + TheClient->iWs.Flush(); + iQueueClient->iWs.SetRemoveKeyCode(EFalse); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,'3'|TOP16B); + iTest->SimulateKey(TRawEvent::EKeyUp,'3'); + TheClient->iWs.Flush(); + iQueueClient->iWs.SetRemoveKeyCode(ETrue); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,'4'|TOP16B); + iTest->SimulateKey(TRawEvent::EKeyUp,'4'); + AddExpectedKey(EEventKeyDown,'2'); + AddExpectedKey(EEventKey,'2',TOP16A>>16); + AddExpectedKey(EEventKeyUp,'2'); + AddExpectedKey(EEventKeyDown,'3'|TOP16B); + AddExpectedKey(EEventKey,'3',TOP16B>>16); + AddExpectedKey(EEventKeyUp,'3'); + AddExpectedKey(EEventKeyDown,'4'); + AddExpectedKey(EEventKey,'4',TOP16B>>16); + AddExpectedKey(EEventKeyUp,'4'); + break; + } + #endif + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +void CTEventTest::WinCap_NextSetOfEvents() + { + switch(iEventSet++) + { + case 0: + //iQueueClient->SetChildCapture(RWindowBase::TCaptureEnabled); + SimulatePointer(TRawEvent::EButton1Down,35,27); + SimulatePointer(TRawEvent::EButton1Up,25,12); + + + AddExpectedEvent(EEventFocusGained); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(35-EWinPositionX,27-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(25-EWinPositionX,12-EWinPositionY)); + break; + + + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +void CTEventTest::XyInputType_NextSetOfEvents() + { + switch(iEventSet++) + { + case 0: + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerMoveEvents|EPointerFilterDrag,EPointerGenerateSimulatedMove); + iQueueClient->iWs.Flush(); +#if !defined(TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA) + SimulateButton1DownWithSimulatedMove(46,31); +#else + SimulatePointer(TRawEvent::EButton1Down,46,31); +#endif + SimulatePointer(TRawEvent::EButton1Up,46,31); + AddExpectedEvent(EEventFocusGained); + AddExpectedPointer(TPointerEvent::EMove, TPoint(46-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(46-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(46-EWinPositionX,31-EWinPositionY)); + break; //Must do something + case 1: + { + // check if RWindowGroup::SimulatePointerEvent is working (DEF131563) + RWindowGroup& group = *iQueueClient->iGroup->GroupWin(); + TRawEvent event; + event.Set(TRawEvent::EButton1Down, 10, 10); + group.SimulatePointerEvent(event); + event.Set(TRawEvent::EButton1Up, 10, 10); + group.SimulatePointerEvent(event); + if(!iIs3DPointer) + { + // simulated move will be generated + AddExpectedPointer(TPointerEvent::EMove, TPoint(10 - EWinPositionX, 10 - EWinPositionY)); + } + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(10 - EWinPositionX, 10 - EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(10 - EWinPositionX, 10 - EWinPositionY)); + } + break; + #if defined(__WINS__) + case 2: +#if !defined(TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA) + SimulateButton1DownWithSimulatedMove(45,32); +#else + SimulatePointer(TRawEvent::EButton1Down,45,32); +#endif + SimulatePointer(TRawEvent::EButton1Up,45,32); + TheClient->iWs.SimulateXyInputType(EXYInputNone); + SimulatePointer(TRawEvent::EButton1Down,44,32); + SimulatePointer(TRawEvent::EPointerMove,43,32); + SimulatePointer(TRawEvent::EButton1Up,43,31); + SimulatePointer(TRawEvent::EButton2Down,44,33); + SimulatePointer(TRawEvent::EButton2Up,44,33); + SimulatePointer(TRawEvent::EButton3Down,43,32); + SimulatePointer(TRawEvent::EButton3Up,43,32); + SimulatePointer(TRawEvent::EPointerSwitchOn,48,32); + TheClient->iWs.SimulateXyInputType(EXYInputPointer); +#if !defined(TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA) + SimulateButton1DownWithSimulatedMove(47,32); +#else + SimulatePointer(TRawEvent::EButton1Down,47,32); +#endif + SimulatePointer(TRawEvent::EButton1Up,47,32); + AddExpectedPointer(TPointerEvent::EMove, TPoint(45-EWinPositionX,32-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(45-EWinPositionX,32-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(45-EWinPositionX,32-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(47-EWinPositionX,32-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(47-EWinPositionX,32-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(47-EWinPositionX,32-EWinPositionY)); + break; + case 3: + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerGenerateSimulatedMove,0); + iQueueClient->iWs.Flush(); + TheClient->iWs.SimulateXyInputType(EXYInputPointer); + SimulatePointer(TRawEvent::EButton1Down,49,32); + SimulatePointer(TRawEvent::EPointerMove,50,30); + SimulatePointer(TRawEvent::EButton1Up,50,30); + SimulatePointer(TRawEvent::EButton1Down,51,32); + SimulatePointer(TRawEvent::EPointerMove,52,30); + SimulatePointer(TRawEvent::EButton1Up,52,30); + TheClient->iWs.SimulateXyInputType(EXYInputPointer); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(49-EWinPositionX,32-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EDrag, TPoint(50-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(50-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(51-EWinPositionX,32-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EDrag, TPoint(52-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(52-EWinPositionX,30-EWinPositionY)); + break; + case 4: + SimulatePointer(TRawEvent::EButton1Down,49,31); + SimulatePointer(TRawEvent::EButton1Up,49,31); + TheClient->iWs.SimulateXyInputType(EXYInputMouse); + SimulatePointer(TRawEvent::EPointerMove,50,31); + SimulatePointer(TRawEvent::EButton1Down,50,31); + SimulatePointer(TRawEvent::EPointerMove,50,30); + SimulatePointer(TRawEvent::EButton1Up,50,30); + SimulatePointer(TRawEvent::EPointerMove,51,31); + SimulatePointer(TRawEvent::EButton1Down,51,31); + SimulatePointer(TRawEvent::EPointerMove,51,30); + SimulatePointer(TRawEvent::EButton1Up,51,30); + TheClient->iWs.SimulateXyInputType(EXYInputPointer); + SimulatePointer(TRawEvent::EButton1Down,52,31); + SimulatePointer(TRawEvent::EButton1Up,52,31); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(49-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(49-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(50-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(50-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EDrag, TPoint(50-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(50-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(51-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(51-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EDrag, TPoint(51-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(51-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(52-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(52-EWinPositionX,31-EWinPositionY)); + break; + case 5: + SimulatePointer(TRawEvent::EButton1Down,69,31); + SimulatePointer(TRawEvent::EButton1Up,69,31); + TheClient->iWs.SimulateXyInputType(EXYInputDeltaMouse); + SimulatePointer(TRawEvent::EPointerMove,-5,-5); + SimulatePointer(TRawEvent::EButton1Down,7,8); + SimulatePointer(TRawEvent::EPointerMove,10,-3); + SimulatePointer(TRawEvent::EButton1Up,-7,-8); + SimulatePointer(TRawEvent::EPointerMove,-4,9); + SimulatePointer(TRawEvent::EButton1Down,123,456); + SimulatePointer(TRawEvent::EPointerMove,15,13); + SimulatePointer(TRawEvent::EButton1Up,-2345,-6789); + TheClient->iWs.SimulateXyInputType(EXYInputPointer); + SimulatePointer(TRawEvent::EButton1Down,62,31); + SimulatePointer(TRawEvent::EButton1Up,62,31); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(69-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(69-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(64-EWinPositionX,26-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(64-EWinPositionX,26-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EDrag, TPoint(74-EWinPositionX,23-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(74-EWinPositionX,23-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(70-EWinPositionX,32-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(70-EWinPositionX,32-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EDrag, TPoint(85-EWinPositionX,45-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(85-EWinPositionX,45-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(62-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(62-EWinPositionX,31-EWinPositionY)); + break; + #endif + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +void CTEventTest::MovingPointerCursor_NextSetOfEventsL() + { + switch(iEventSet++) + { + case 0: + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerFilterMove|EPointerFilterDrag,0); + iQueueClient->iWin->BaseWin()->SetPointerGrab(EFalse); + iQueueClient->iChildWin->BaseWin()->PointerFilter(EPointerFilterMove|EPointerFilterDrag,0); + iQueueClient->iChildWin->BaseWin()->SetPointerGrab(EFalse); + iQueueClient->iWs.Flush(); + //AddExpectedEvent(EEventFocusGained); + break; + #if defined(__WINS__) + case 1: + TheClient->iWs.SimulateXyInputType(EXYInputMouse); + iQueueClient->iChildWin->BaseWin()->PointerFilter(EPointerFilterMove|EPointerFilterDrag,0); + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerFilterMove|EPointerFilterDrag,0); + iQueueClient->iWin->BaseWin()->SetPointerGrab(EFalse); + iQueueClient->iChildWin->BaseWin()->SetPointerGrab(EFalse); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EPointerMove,46,31); + SimulatePointer(TRawEvent::EButton1Down,46,31); + SimulatePointer(TRawEvent::EPointerMove,47,32); + SimulatePointer(TRawEvent::EButton1Up,47,32); + AddExpectedPointer(TPointerEvent::EMove, TPoint(46-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(46-EWinPositionX,31-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EDrag, TPoint(47-EWinPositionX,32-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(47-EWinPositionX,32-EWinPositionY)); + break; + case 2: + TheClient->iWs.SimulateXyInputType(EXYInputDeltaMouse); + TheClient->iWs.SetPointerCursorPosition(TPoint(62,24)); + SimulatePointer(TRawEvent::EPointerMove,-5,-5); + TheClient->iWs.SetPointerCursorPosition(TPoint(60,20)); + SimulatePointer(TRawEvent::EPointerMove,6,7); + SimulatePointer(TRawEvent::EButton1Down,27,38); + SimulatePointer(TRawEvent::EPointerMove,0,0); + TheClient->iWs.SetPointerCursorPosition(TPoint(55,25)); + SimulatePointer(TRawEvent::EPointerMove,4,-13); + TheClient->iWs.SetPointerCursorPosition(TPoint(58,20)); + SimulatePointer(TRawEvent::EButton1Up,45,-678); + TheClient->iWs.Flush(); + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerFilterEnterExit,0); + iQueueClient->iChildWin->BaseWin()->PointerFilter(EPointerFilterEnterExit,0); + iQueueClient->iWs.Flush(); + TheClient->iWs.SetPointerCursorPosition(TPoint(80,45)); + TheClient->iWs.SimulateXyInputType(EXYInputPointer); + AddExpectedPointer(TPointerEvent::EMove, TPoint(57-EWinPositionX,19-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(66-EWinPositionX,27-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(66-EWinPositionX,27-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EDrag, TPoint(66-EWinPositionX,27-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EDrag, TPoint(59-EWinPositionX,12-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(58-EWinPositionX,20-EWinPositionY)); + AddExpectedEnterExit(EEventPointerEnter, TPoint(58-EWinPositionX,20-EWinPositionY)); + AddExpectedEnterExit(EEventPointerExit, TPoint(58-EWinPositionX,20-EWinPositionY)); + AddExpectedEnterExit(EEventPointerEnter, TPoint(80-EWinPositionX,45-EWinPositionY)); + break; + case 3: + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerFilterEnterExit,EPointerFilterEnterExit); + iQueueClient->iChildWin->BaseWin()->PointerFilter(EPointerFilterEnterExit,EPointerFilterEnterExit); + iQueueClient->iWs.Flush(); + TheClient->iWs.SetPointerCursorArea(TRect(0,0,70,240)); + TheClient->iWs.SimulateXyInputType(EXYInputDeltaMouse); + TheClient->iWs.SetPointerCursorPosition(TPoint(65,30)); + SimulatePointer(TRawEvent::EPointerMove,20,0); + TheClient->iWs.SetPointerCursorPosition(TPoint(75,32)); + SimulatePointer(TRawEvent::EPointerMove,-1,20); + SimulatePointer(TRawEvent::EButton1Down,29,37); + SimulatePointer(TRawEvent::EPointerMove,25,-13); + SimulatePointer(TRawEvent::EButton1Up,47,-648); + TheClient->iWs.SimulateXyInputType(EXYInputPointer); + AddExpectedPointer(TPointerEvent::EMove, TPoint(69-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(68-EWinPositionX,52-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(68-EWinPositionX,52-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EDrag, TPoint(69-EWinPositionX,39-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(69-EWinPositionX,39-EWinPositionY)); + break; + case 4: + TheClient->iWs.SetPointerCursorArea(TRect(EWinPositionX+2,EWinPositionY+2,EWinPositionX+99,EWinPositionY+49)); + TheClient->iWs.SimulateXyInputType(EXYInputDeltaMouse); + TheClient->iWs.SetPointerCursorPosition(TPoint(56,30)); + SimulatePointer(TRawEvent::EPointerMove,0,-34); + TheClient->iWs.SetPointerCursorPosition(TPoint(56,30)); + SimulatePointer(TRawEvent::EPointerMove,0,0); + SimulatePointer(TRawEvent::EPointerMove,-77,-35); + TheClient->iWs.SetPointerCursorPosition(TPoint(56,30)); + SimulatePointer(TRawEvent::EPointerMove,0,0); + SimulatePointer(TRawEvent::EPointerMove,-78,0); + TheClient->iWs.SetPointerCursorPosition(TPoint(56,30)); + SimulatePointer(TRawEvent::EPointerMove,0,0); + SimulatePointer(TRawEvent::EPointerMove,-79,36); + TheClient->iWs.SetPointerCursorPosition(TPoint(56,30)); + SimulatePointer(TRawEvent::EPointerMove,0,0); + SimulatePointer(TRawEvent::EPointerMove,0,37); + TheClient->iWs.SetPointerCursorPosition(TPoint(56,30)); + SimulatePointer(TRawEvent::EPointerMove,0,0); + SimulatePointer(TRawEvent::EPointerMove,80,38); + TheClient->iWs.SetPointerCursorPosition(TPoint(56,30)); + SimulatePointer(TRawEvent::EPointerMove,0,0); + SimulatePointer(TRawEvent::EPointerMove,81,0); + TheClient->iWs.SetPointerCursorPosition(TPoint(56,30)); + SimulatePointer(TRawEvent::EPointerMove,0,0); + SimulatePointer(TRawEvent::EPointerMove,82,-39); + TheClient->iWs.SetPointerCursorPosition(TPoint(2,2)); + SimulatePointer(TRawEvent::EPointerMove,30,30); + TheClient->iWs.SetPointerCursorPosition(TPoint(1,30)); + SimulatePointer(TRawEvent::EPointerMove,1,0); + TheClient->iWs.SetPointerCursorPosition(TPoint(2,88)); + SimulatePointer(TRawEvent::EPointerMove,30,-30); + TheClient->iWs.SetPointerCursorPosition(TPoint(56,88)); + SimulatePointer(TRawEvent::EPointerMove,0,-1); + TheClient->iWs.SetPointerCursorPosition(TPoint(123,88)); + SimulatePointer(TRawEvent::EPointerMove,-30,-30); + TheClient->iWs.SetPointerCursorPosition(TPoint(123,30)); + SimulatePointer(TRawEvent::EPointerMove,-1,0); + TheClient->iWs.SetPointerCursorPosition(TPoint(123,2)); + SimulatePointer(TRawEvent::EPointerMove,-30,30); + TheClient->iWs.SetPointerCursorPosition(TPoint(56,1)); + SimulatePointer(TRawEvent::EPointerMove,0,1); + TheClient->iWs.SimulateXyInputType(EXYInputPointer); + AddExpectedPointer(TPointerEvent::EMove, TPoint(56-EWinPositionX,2)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(56-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(2,2)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(56-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(2,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(56-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(2,48)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(56-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(56-EWinPositionX,48)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(56-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(98,48)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(56-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(98,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(56-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(98,2)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(32,32)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(3,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(32,18)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(56-EWinPositionX,47)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(68,18)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(97,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(68,32)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(56-EWinPositionX,3)); + break; + case 5: + TheClient->iWs.SetPointerCursorArea(TRect(0,0,EWinPositionX+100,EWinPositionY+50)); + TheClient->iWs.SimulateXyInputType(EXYInputDeltaMouse); + TheClient->iWs.SetPointerCursorPosition(TPoint(57,31)); + TheClient->iWs.SetPointerCursorArea(TRect(0,35,EWinPositionX+100,EWinPositionY+50)); + SimulatePointer(TRawEvent::EPointerMove,1,0); + TheClient->iWs.SetPointerCursorPosition(TPoint(10,55)); + TheClient->iWs.SetPointerCursorArea(TRect(15,0,EWinPositionX+100,50)); + SimulatePointer(TRawEvent::EPointerMove,1,1); + TheClient->iWs.SetPointerCursorPosition(TPoint(57,31)); + TheClient->iWs.SetPointerCursorArea(TRect(0,0,50,EWinPositionY+50)); + SimulatePointer(TRawEvent::EPointerMove,0,1); + TheClient->iWs.SetPointerCursorPosition(TPoint(10,10)); + TheClient->iWs.SetPointerCursorArea(TRect(15,15,EWinPositionX+100,EWinPositionY+50)); + SimulatePointer(TRawEvent::EPointerMove,1,-1); + TheClient->iWs.SetPointerCursorPosition(TPoint(57,31)); + TheClient->iWs.SetPointerCursorArea(TRect(0,0,EWinPositionX+100,30)); + SimulatePointer(TRawEvent::EPointerMove,-1,0); + TheClient->iWs.SetPointerCursorPosition(TPoint(100,10)); + TheClient->iWs.SetPointerCursorArea(TRect(0,15,95,EWinPositionY+50)); + SimulatePointer(TRawEvent::EPointerMove,-1,-1); + TheClient->iWs.SetPointerCursorPosition(TPoint(57,31)); + TheClient->iWs.SetPointerCursorArea(TRect(60,0,EWinPositionX+100,EWinPositionY+50)); + SimulatePointer(TRawEvent::EPointerMove,0,-1); + TheClient->iWs.SetPointerCursorPosition(TPoint(100,55)); + TheClient->iWs.SetPointerCursorArea(TRect(0,0,95,50)); + SimulatePointer(TRawEvent::EPointerMove,1,-1); + TheClient->iWs.SimulateXyInputType(EXYInputPointer); + AddExpectedPointer(TPointerEvent::EMove, TPoint(58-EWinPositionX,35-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(16-EWinPositionX,49-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(49-EWinPositionX,32-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(16-EWinPositionX,15-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(56-EWinPositionX,29-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(93-EWinPositionX,15-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(60-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EMove, TPoint(94-EWinPositionX,48-EWinPositionY)); + break; + #endif + default: + TheClient->iWs.SetPointerCursorArea(TRect(0,0,95,50)); + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +void CTEventTest::RotatedMode_NextSetOfEventsL() + { +#if defined(LOGGING) + TLogMessageText logMessageText; + _LIT(KSet,"RotatedMode SetOfEvents: %d Max=4"); + logMessageText.Format(KSet,iEventSet); + INFO_PRINTF1(logMessageText); +#endif + switch(iEventSet++) + { + case 0: + { + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerFilterMove|EPointerFilterDrag,0); + iQueueClient->iWin->BaseWin()->SetPointerGrab(EFalse); + iQueueClient->iWs.Flush(); + TheClient->iWs.SetPointerCursorArea(TRect(10,10,51,51)); + SimulatePointer(TRawEvent::EButton1Down,5,5); + SimulatePointer(TRawEvent::EButton1Up,25,5); + SimulatePointer(TRawEvent::EButton1Down,55,5); + SimulatePointer(TRawEvent::EButton1Up,55,35); + SimulatePointer(TRawEvent::EButton1Down,55,55); + SimulatePointer(TRawEvent::EButton1Up,25,55); + SimulatePointer(TRawEvent::EButton1Down,5,55); + SimulatePointer(TRawEvent::EButton1Up,5,35); + AddExpectedEvent(EEventFocusGained); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(10-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(25-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(50-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(50-EWinPositionX,35-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(50-EWinPositionX,50-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(25-EWinPositionX,50-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(10-EWinPositionX,50-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(10-EWinPositionX,35-EWinPositionY)); + } + break; + case 1: + { + TInt enforc=TheClient->iScreen->ScreenModeEnforcement(); + iBlankWin->SetVisible(ETrue); + #if defined(LOGGING) + _LIT(KSet1,"AUTO Rotating Events :1st "); + INFO_PRINTF1(KSet1); + #endif + INFO_PRINTF1(_L(" Set of Events")); + if (iScreenModeTests&EDoRot90) + { + TheClient->iScreen->SetScreenMode(1); + TheClient->iWs.Flush(); + iTest->DelayIfFullRomL(); + INFO_PRINTF1(_L(" Screen mode 1.")); + TPoint screenModeOrigin=TheClient->iScreen->GetDefaultScreenModeOrigin(); + #if defined(__WINS__) + iTest->SimulatePointer(TRawEvent::EButton1Down,20+screenModeOrigin.iX,20+screenModeOrigin.iY); + iTest->SimulatePointer(TRawEvent::EButton1Up,20+screenModeOrigin.iX,20+screenModeOrigin.iY); + #else + // simulate pointer at (20,20) on rotated screen by providing physical coordinates + iTest->SimulatePointer(TRawEvent::EButton1Down,iPhysicalScreenSize.iWidth-1-20+screenModeOrigin.iX,20+screenModeOrigin.iY); + iTest->SimulatePointer(TRawEvent::EButton1Up,iPhysicalScreenSize.iWidth-1-20+screenModeOrigin.iX,20+screenModeOrigin.iY); + #endif + INFO_PRINTF1(_L(" Sent Up and Down 90")); + } + if (iScreenModeTests&EDoRot180) + { + TheClient->iScreen->SetCurrentRotations(0,CFbsBitGc::EGraphicsOrientationRotated180); + TheClient->iScreen->SetScreenMode(0); + INFO_PRINTF1(_L(" Screen mode 0")); + TheClient->iWs.Flush(); + iTest->DelayIfFullRomL(); + INFO_PRINTF1(_L(" Upside Down")); + #if defined(__WINS__) + iTest->SimulatePointer(TRawEvent::EButton1Down,22,22); + iTest->SimulatePointer(TRawEvent::EButton1Up,22,22); + #else + // simulate pointer at (22,22) on rotated screen by providing physical coordinates + iTest->SimulatePointer(TRawEvent::EButton1Down,iPhysicalScreenSize.iWidth-1-22,iPhysicalScreenSize.iHeight-1-22); + iTest->SimulatePointer(TRawEvent::EButton1Up,iPhysicalScreenSize.iWidth-1-22,iPhysicalScreenSize.iHeight-1-22); + #endif + INFO_PRINTF1(_L(" Sent Up and Down 180")); + } + TheClient->iScreen->SetCurrentRotations(0,CFbsBitGc::EGraphicsOrientationNormal); + TheClient->iScreen->SetScreenMode(0); + TheClient->iWs.Flush(); + iTest->DelayIfFullRomL(); + INFO_PRINTF1(_L(" Normal Screen mode")); + if (iScreenModeTests&EDoRot0) + { + SimulatePointer(TRawEvent::EButton1Down,24,24); + SimulatePointer(TRawEvent::EButton1Up,24,24); + } + if (iScreenModeTests&EDoRot90) + { + if (enforc>ESizeEnforcementNone) + { + AddExpectedEvent(EEventFocusLost); + AddExpectedEvent(EEventFocusGained); + } + else + { + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(20-EWinPositionX,20-EWinPositionY-iYOffset)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(20-EWinPositionX,20-EWinPositionY-iYOffset)); + } + } + if (iScreenModeTests&EDoRot180) + { + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(22-EWinPositionX,22-EWinPositionY-iYOffset)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(22-EWinPositionX,22-EWinPositionY-iYOffset)); + } + if (iScreenModeTests&EDoRot0) + { + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(24-EWinPositionX,24-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(24-EWinPositionX,24-EWinPositionY)); + } + INFO_PRINTF1(_L(" Added Expected")); + User::After(EPointerCursorUpdateGap); + iBlankWin->SetVisible(EFalse); + } + break; + #if defined(__WINS__) + case 2: + { + TInt enforc=TheClient->iScreen->ScreenModeEnforcement(); + //INFO_PRINTF1("AUTO Rotating Events "); + //INFO_PRINTF1(" :2nd Set of Events"); + TheClient->iWs.SimulateXyInputType(EXYInputDeltaMouse); + TheClient->iWs.SetPointerCursorPosition(TPoint(24+EWinPositionX,24+EWinPositionY)); + if (iScreenModeTests&EDoRot90) + { + TheClient->iScreen->SetScreenMode(1); + TheClient->iWs.Flush(); + iTest->DelayIfFullRomL(); + SimulatePointer(TRawEvent::EPointerMove,1,2); + SimulatePointer(TRawEvent::EButton1Down,56,89); + SimulatePointer(TRawEvent::EPointerMove,2,-1); + SimulatePointer(TRawEvent::EButton1Up,234,456); + } + else + TheClient->iWs.SetPointerCursorPosition(TPoint(27+EWinPositionX,25+EWinPositionY)); + if (iScreenModeTests&EDoRot180) + { + TheClient->iScreen->SetCurrentRotations(0,CFbsBitGc::EGraphicsOrientationRotated180); + TheClient->iScreen->SetScreenMode(0); + TheClient->iWs.Flush(); + iTest->DelayIfFullRomL(); + SimulatePointer(TRawEvent::EPointerMove,-3,4); + SimulatePointer(TRawEvent::EButton1Down,156,289); + SimulatePointer(TRawEvent::EPointerMove,-4,-3); + SimulatePointer(TRawEvent::EButton1Up,2234,3456); + } + else + TheClient->iWs.SetPointerCursorPosition(TPoint(20+EWinPositionX,26+EWinPositionY)); + TheClient->iScreen->SetCurrentRotations(0,CFbsBitGc::EGraphicsOrientationNormal); + TheClient->iScreen->SetScreenMode(0); + TheClient->iWs.Flush(); + iTest->DelayIfFullRomL(); + if (iScreenModeTests&EDoRot0) + { + SimulatePointer(TRawEvent::EButton1Down,24,24); + SimulatePointer(TRawEvent::EButton1Up,24,24); + } + TheClient->iWs.SimulateXyInputType(EXYInputPointer); + TheClient->iWs.Flush(); + if (iScreenModeTests&EDoRot90) + { + if (enforc>ESizeEnforcementNone) + { + AddExpectedEvent(EEventFocusLost); + AddExpectedEvent(EEventFocusGained); + } + else + { + AddExpectedPointer(TPointerEvent::EMove, TPoint(25,26)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(25,26)); + AddExpectedPointer(TPointerEvent::EDrag, TPoint(27,25)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(27,25)); + } + } + if (iScreenModeTests&EDoRot180) + { + AddExpectedPointer(TPointerEvent::EMove, TPoint(24,29)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(24,29)); + AddExpectedPointer(TPointerEvent::EDrag, TPoint(20,26)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(20,26)); + } + if (iScreenModeTests&EDoRot0) + { + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(20,26)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(20,26)); + } + } + break; + case 3: + { + #if defined(LOGGING) + _LIT(KSet2,"AUTO Rotating Events "); + INFO_PRINTF1(KSet2); + #endif + INFO_PRINTF1(_L(" :3rd Set of Events")); + if (iScreenModeTests&EDoScale) + { + INFO_PRINTF1(_L(" :Screen Scalling Supported")); + iBlankWin->SetVisible(ETrue); + iCurrentMode=iNumScrModes; + --iCurrentMode; + iTheClientFlush=TheClient->iWs.SetAutoFlush(ETrue); + iQuequeClientFlush=iQueueClient->iWs.SetAutoFlush(ETrue); + iQueueClient->iScreen->SetScreenMode(iCurrentMode); + TheClient->iScreen->SetAppScreenMode(iCurrentMode); + iQueueClient->iScreen->SetAppScreenMode(iCurrentMode); + iSizeMode=iQueueClient->iScreen->GetCurrentScreenModeAttributes(); + TSizeMode testMode=iSizeMode; + for (TInt xScale=2;xScale<4;xScale++) + { + INFO_PRINTF1(_L(" :New X-Scale Value")); + for (TInt yScale=2;yScale<4;yScale++) + { + INFO_PRINTF1(_L(" :New Y-Scale Value")); + testMode.iScreenScale.SetSize(xScale,yScale); + CheckPointerCursorInDifferentScreenMode(testMode,TPoint(20,30)); + } + } + User::After(EPointerCursorUpdateGap); + iBlankWin->SetVisible(EFalse); + break; + } + } + case 4: + { + if (iScreenModeTests&EDoScale) + { + TSizeMode testMode=iSizeMode; + iBlankWin->SetVisible(ETrue); + for (TInt xScale=2;xScale<4;xScale++) + { + for (TInt yScale=2;yScale<4;yScale++) + { + testMode.iScreenScale.SetSize(xScale,yScale); + CheckPointerCursorInDifferentScreenMode(testMode,TPoint(30,20)); + } + } + User::After(EPointerCursorUpdateGap); + iBlankWin->SetVisible(EFalse); + break; + } + } + #endif + default: + #if defined(__WINS__) + if (iScreenModeTests&EDoScale) + { + iQueueClient->iScreen->SetScreenMode(iCurrentMode); + iQueueClient->iScreen->SetCurrentScreenModeAttributes(iSizeMode); + iQueueClient->iScreen->SetAppScreenMode(0); + TheClient->iScreen->SetAppScreenMode(0); + iQueueClient->iScreen->SetScreenMode(0); + iBlankWin->SetVisible(EFalse); + TheClient->iWs.SetAutoFlush(iTheClientFlush); + iQueueClient->iWs.SetAutoFlush(iQuequeClientFlush); + } + #endif + User::After(500000); //0.5secs, to allow other screen devices to respond to the flip events + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + + +void CTEventTest::ScreenScaling_NextSetOfEventsL() + { +#if defined(LOGGING) + TLogMessageText logMessageText; + _LIT(KSet,"ScreenScaling SetOfEvents: %d (Last=3)"); + logMessageText.Format(KSet,iEventSet); + INFO_PRINTF1(logMessageText); +#endif + if(! (iScreenModeTests & EDoScale)) + { + User::After(500000); + CActiveScheduler::Stop(); + return; + } + switch(iEventSet++) + { + case 0: + { + iTheClientFlush=TheClient->iWs.SetAutoFlush(ETrue); + iQuequeClientFlush=iQueueClient->iWs.SetAutoFlush(ETrue); + iBlankWin->SetVisible(ETrue); + + TInt mode = TheClient->iScreen->CurrentScreenMode(); + + iSizeMode = iQueueClient->iScreen->GetCurrentScreenModeAttributes(); + + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerFilterMove|EPointerFilterDrag,0); + iQueueClient->iWin->BaseWin()->SetPointerGrab(EFalse); + + TSizeMode szMode2 = iSizeMode; + + szMode2.iScreenScale.SetSize(2,2); + + iQueueClient->iScreen->SetCurrentScreenModeAttributes(szMode2); + TheClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetScreenMode(mode); + + TPoint theScreenOrigin(iQueueClient->iScreen->GetScreenModeOrigin(mode)); + + SimulatePointer(TRawEvent::EButton1Down, + 20+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 20+theScreenOrigin.iX, 20+theScreenOrigin.iY); + iQueueClient->iScreen->SetCurrentScreenModeAttributes(iSizeMode); + TheClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetScreenMode(mode); + + AddExpectedEvent(EEventFocusGained); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(10-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(10-EWinPositionX,10-EWinPositionY)); + + break; + } + case 1: + { + TSizeMode szMode2 = iSizeMode; + TInt mode = TheClient->iScreen->CurrentScreenMode(); + + szMode2.iScreenScale.SetSize(2,2); + szMode2.iOrigin.SetXY(20,20); + + iQueueClient->iScreen->SetCurrentScreenModeAttributes(szMode2); + TheClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetScreenMode(mode); + + TPoint theScreenOrigin(iQueueClient->iScreen->GetDefaultScreenModeOrigin()); + + SimulatePointer(TRawEvent::EButton1Down, + 30+theScreenOrigin.iX, 30+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Down, + 40+theScreenOrigin.iX, 60+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX, 20+theScreenOrigin.iY); + + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(15-EWinPositionX,15-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(13-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(20-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(13-EWinPositionX,10-EWinPositionY)); + + iQueueClient->iScreen->SetCurrentScreenModeAttributes(iSizeMode); + TheClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetScreenMode(mode); + + theScreenOrigin = TPoint(iQueueClient->iScreen->GetDefaultScreenModeOrigin()); + + SimulatePointer(TRawEvent::EButton1Down, + 30+theScreenOrigin.iX, 30+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Down, + 40+theScreenOrigin.iX, 50+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX, 20+theScreenOrigin.iY); + + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(30-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(26-EWinPositionX,20-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(40-EWinPositionX,50-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(26-EWinPositionX,20-EWinPositionY)); + break; + } + case 2: + { + TInt mode = TheClient->iScreen->CurrentScreenMode(); + TRect theRect = TheClient->iWs.PointerCursorArea(); + + TSizeMode szMode2 = iSizeMode; + + //----------- scaling 2X2 + szMode2.iScreenScale.SetSize(2,2); + + iQueueClient->iScreen->SetCurrentScreenModeAttributes(szMode2); + iQueueClient->iWs.SetPointerCursorArea(mode, TRect(24,10,52,52)); + TheClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetScreenMode(mode); + + + TPoint theScreenOrigin(iQueueClient->iScreen->GetDefaultScreenModeOrigin()); + + SimulatePointer(TRawEvent::EButton1Down, + 20+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Down, + 50+theScreenOrigin.iX, 30+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX, 20+theScreenOrigin.iY); + + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(24-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(24-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(25-EWinPositionX,15-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(24-EWinPositionX,10-EWinPositionY)); + //------------------------ scaling 1X2 + szMode2.iScreenScale.SetSize(1,2); + + iQueueClient->iScreen->SetCurrentScreenModeAttributes(szMode2); + iQueueClient->iWs.SetPointerCursorArea(mode, TRect(24,10,52,52)); + TheClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetScreenMode(mode); + + theScreenOrigin = TPoint(iQueueClient->iScreen->GetDefaultScreenModeOrigin()); + + SimulatePointer(TRawEvent::EButton1Down, + 20+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Down, + 50+theScreenOrigin.iX, 30+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX, 20+theScreenOrigin.iY); + + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(24-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(26-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(50-EWinPositionX,15-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(26-EWinPositionX,10-EWinPositionY)); + //------------------------ scaling 2X1 + szMode2.iScreenScale.SetSize(2,1); + + iQueueClient->iScreen->SetCurrentScreenModeAttributes(szMode2); + iQueueClient->iWs.SetPointerCursorArea(mode, TRect(24,10,52,52)); + TheClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetScreenMode(mode); + + theScreenOrigin = TPoint(iQueueClient->iScreen->GetDefaultScreenModeOrigin()); + + SimulatePointer(TRawEvent::EButton1Down, + 20+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Down, + 50+theScreenOrigin.iX, 30+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX, 20+theScreenOrigin.iY); + + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(24-EWinPositionX,20-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(24-EWinPositionX,20-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(25-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(24-EWinPositionX,20-EWinPositionY)); + //------------------------ scaling 3X1 + + szMode2.iScreenScale.SetSize(3,1); + + iQueueClient->iScreen->SetCurrentScreenModeAttributes(szMode2); + iQueueClient->iWs.SetPointerCursorArea(mode, TRect(24,10,52,52)); + TheClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetScreenMode(mode); + + theScreenOrigin = TPoint(iQueueClient->iScreen->GetDefaultScreenModeOrigin()); + + SimulatePointer(TRawEvent::EButton1Down, + 21+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 30+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Down, + 75+theScreenOrigin.iX, 30+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 30+theScreenOrigin.iX, 20+theScreenOrigin.iY); + + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(24-EWinPositionX,20-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(24-EWinPositionX,20-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(25-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(24-EWinPositionX,20-EWinPositionY)); + //------------------------ scaling 3X2 + + szMode2.iScreenScale.SetSize(3,2); + + iQueueClient->iScreen->SetCurrentScreenModeAttributes(szMode2); + iQueueClient->iWs.SetPointerCursorArea(mode, TRect(24,10,52,52)); + TheClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetScreenMode(mode); + + theScreenOrigin = TPoint(iQueueClient->iScreen->GetDefaultScreenModeOrigin()); + + SimulatePointer(TRawEvent::EButton1Down, + 21+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 30+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Down, + 75+theScreenOrigin.iX, 30+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 30+theScreenOrigin.iX, 20+theScreenOrigin.iY); + + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(24-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(24-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(25-EWinPositionX,15-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(24-EWinPositionX,10-EWinPositionY)); + //------------------------ scaling 3X3 + szMode2.iScreenScale.SetSize(3,3); + + iQueueClient->iScreen->SetCurrentScreenModeAttributes(szMode2); + iQueueClient->iWs.SetPointerCursorArea(mode, TRect(24,10,52,52)); + TheClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetScreenMode(mode); + + theScreenOrigin = TPoint(iQueueClient->iScreen->GetDefaultScreenModeOrigin()); + + SimulatePointer(TRawEvent::EButton1Down, + 21+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 30+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Down, + 75+theScreenOrigin.iX, 33+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 30+theScreenOrigin.iX, 20+theScreenOrigin.iY); + + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(24-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(24-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(25-EWinPositionX,11-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(24-EWinPositionX,10-EWinPositionY)); + //------------------------ + iQueueClient->iWs.SetPointerCursorArea(mode, theRect); + iQueueClient->iScreen->SetCurrentScreenModeAttributes(iSizeMode); + TheClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetAppScreenMode(mode); + iQueueClient->iScreen->SetScreenMode(mode); + break; + } + case 3: + { + iQueueClient->iWs.SetAutoFlush(ETrue); + TInt theCurMode = iQueueClient->iScreen->CurrentScreenMode(); + TPoint theScreenOrigin; + if (iNumScrModes>2) + { + TheClient->iScreen->SetAppScreenMode(2); + iQueueClient->iScreen->SetAppScreenMode(2); + TheClient->iScreen->SetScreenMode(2); + + theScreenOrigin=iQueueClient->iScreen->GetDefaultScreenModeOrigin(); + SimulatePointer(TRawEvent::EButton1Down, + 30+theScreenOrigin.iX,30+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX,20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Down, + 40+theScreenOrigin.iX,60+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX,20+theScreenOrigin.iY); + + AddExpectedPointer(TPointerEvent::EButton1Down, + TPoint(15-EWinPositionX,15-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, + TPoint(13-EWinPositionX,10-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, + TPoint(20-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, + TPoint(13-EWinPositionX,10-EWinPositionY)); + } + + TheClient->iScreen->SetAppScreenMode(0); + iQueueClient->iScreen->SetAppScreenMode(0); + iQueueClient->iScreen->SetScreenMode(0); + iTest->DelayIfFullRomL(); + + theScreenOrigin = TPoint(iQueueClient->iScreen->GetDefaultScreenModeOrigin()); + + SimulatePointer(TRawEvent::EButton1Down, + 30+theScreenOrigin.iX, 30+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX, 20+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Down, + 40+theScreenOrigin.iX, 50+theScreenOrigin.iY); + SimulatePointer(TRawEvent::EButton1Up, + 26+theScreenOrigin.iX, 20+theScreenOrigin.iY); + + #if defined(__WINS__) + iQueueClient->iWs.SimulateXyInputType(EXYInputDeltaMouse); + iQueueClient->iWs.SetPointerCursorPosition(TPoint(24+theScreenOrigin.iX,24+theScreenOrigin.iY)); + SimulatePointer(TRawEvent::EPointerMove,1,2); + iQueueClient->iWs.SimulateXyInputType(EXYInputPointer); + #endif + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(30-EWinPositionX,30-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(26-EWinPositionX,20-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(40-EWinPositionX,50-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(26-EWinPositionX,20-EWinPositionY)); + + #if defined(__WINS__) + AddExpectedPointer(TPointerEvent::EMove, TPoint(25-EWinPositionX,26-EWinPositionY)); + #endif + + iQueueClient->iScreen->SetAppScreenMode(theCurMode); + TheClient->iScreen->SetScreenMode(theCurMode); + break; + } + default: + User::After(EPointerCursorUpdateGap); + iBlankWin->SetVisible(EFalse); + TheClient->iWs.SetAutoFlush(iTheClientFlush); + iQueueClient->iWs.SetAutoFlush(iQuequeClientFlush); + iQueueClient->iScreen->SetCurrentScreenModeAttributes(iSizeMode); + User::After(500000); //0.5secs, to allow other screen devices to respond to the flip events + CActiveScheduler::Stop(); + break; + } + } + +void CTEventTest::AnimEvent_NextSetOfEventsL() + { +#if defined(LOGGING) + TLogMessageText logMessageText; + _LIT(KSet,"AnimEvent SetOfEvents: %d (Max=4)"); + logMessageText.Format(KSet,iEventSet); + INFO_PRINTF1(logMessageText); +#endif + switch(iEventSet++) + { + case 0: + iAnim=REventAnim::NewL(iQueueClient->iWin->BaseWin(), iAnimDll); + AddExpectedEvent(EEventFocusGained); + AddExpectedKeyAnim(TRawEvent::EKeyDown,32,ETrue); + AddExpectedKeyAnim(TRawEvent::EKeyUp,32,ETrue); + AddExpectedKeyAnim(TRawEvent::EKeyDown,33,EFalse); + AddExpectedKeyAnim(TRawEvent::EKeyUp,33,EFalse); + iTest->SimulateKey(TRawEvent::EKeyDown,32); + iTest->SimulateKey(TRawEvent::EKeyUp,32); + iTest->SimulateKey(TRawEvent::EKeyDown,33); + iTest->SimulateKey(TRawEvent::EKeyUp,33); + TheClient->iWs.Flush(); + if (iAnim->TestFail(4)) + Failed(); + break; + case 1: + iQueueClient->iWin->BaseWin()->PointerFilter(EPointerFilterMove|EPointerFilterDrag,0); + iQueueClient->iWin->BaseWin()->SetPointerGrab(EFalse); + iQueueClient->iWs.Flush(); + TheClient->iWs.SetPointerCursorArea(TRect(10,10,51,51)); + AddExpectedPointerAnim(TRawEvent::EButton1Down, TPoint(10,10)); + AddExpectedPointerAnim(TRawEvent::EButton1Up, TPoint(25,10)); + AddExpectedPointerAnim(TRawEvent::EButton1Down, TPoint(50,10)); + AddExpectedPointerAnim(TRawEvent::EButton1Up, TPoint(50,35)); + AddExpectedPointerAnim(TRawEvent::EButton1Down, TPoint(50,50)); + AddExpectedPointerAnim(TRawEvent::EButton1Up, TPoint(25,50)); + AddExpectedPointerAnim(TRawEvent::EButton1Down, TPoint(10,50)); + AddExpectedPointerAnim(TRawEvent::EButton1Up, TPoint(10,35)); + AddExpectedPointerAnim(TRawEvent::EButton1Down, TPoint(30,30),EFalse); + AddExpectedPointerAnim(TRawEvent::EButton1Up, TPoint(30,30),EFalse); + SimulatePointer(TRawEvent::EButton1Down,5,5); + SimulatePointer(TRawEvent::EButton1Up,25,5); + SimulatePointer(TRawEvent::EButton1Down,55,5); + SimulatePointer(TRawEvent::EButton1Up,55,35); + SimulatePointer(TRawEvent::EButton1Down,55,55); + SimulatePointer(TRawEvent::EButton1Up,25,55); + SimulatePointer(TRawEvent::EButton1Down,5,55); + SimulatePointer(TRawEvent::EButton1Up,5,35); + SimulatePointer(TRawEvent::EButton1Down,30,30); + SimulatePointer(TRawEvent::EButton1Up,30,30); + TheClient->iWs.Flush(); + if (iAnim->TestFail(10)) + Failed(); + break; + case 2: + { + #if defined(LOGGING) + _LIT(KLog," :2nd Set of Events Modes=0x%x"); + logMessageText.Format(KLog,iScreenModeTests); + INFO_PRINTF1(logMessageText); + #endif + TInt enforc=TheClient->iScreen->ScreenModeEnforcement(); + iBlankWin->SetVisible(ETrue); + TInt expectedEvents=0; + if (iScreenModeTests&EDoRot90 && enforc==ESizeEnforcementNone) + { + INFO_PRINTF1(_L(" :Rotation 90")); + TheClient->iScreen->SetScreenMode(1); + TheClient->iWs.Flush(); + iTest->DelayIfFullRomL(); + AddExpectedPointerAnim(TRawEvent::EButton1Down, TPoint(20,20-iYOffset)); + AddExpectedPointerAnim(TRawEvent::EButton1Up, TPoint(20,20-iYOffset)); + expectedEvents+=2; + TPoint screenModeOrigin=TheClient->iScreen->GetDefaultScreenModeOrigin(); + #if defined(__WINS__) + iTest->SimulatePointer(TRawEvent::EButton1Down,20+screenModeOrigin.iX,20+screenModeOrigin.iY); + iTest->SimulatePointer(TRawEvent::EButton1Up,20+screenModeOrigin.iX,20+screenModeOrigin.iY); + #else + // simulate pointer at (20,20) on rotated screen by providing physical coordinates + iTest->SimulatePointer(TRawEvent::EButton1Down,iPhysicalScreenSize.iWidth-1-20+screenModeOrigin.iX,20+screenModeOrigin.iY); + iTest->SimulatePointer(TRawEvent::EButton1Up,iPhysicalScreenSize.iWidth-1-20+screenModeOrigin.iX,20+screenModeOrigin.iY); + #endif + } + if (iScreenModeTests&EDoRot180) + { + INFO_PRINTF1(_L(" :Rotation 180")); + TheClient->iScreen->SetCurrentRotations(0,CFbsBitGc::EGraphicsOrientationRotated180); + TheClient->iScreen->SetScreenMode(0); + TheClient->iWs.Flush(); + iTest->DelayIfFullRomL(); + AddExpectedPointerAnim(TRawEvent::EButton1Down, TPoint(22,22-iYOffset)); + AddExpectedPointerAnim(TRawEvent::EButton1Up, TPoint(22,22-iYOffset)); + + expectedEvents+=2; + #if defined(__WINS__) + iTest->SimulatePointer(TRawEvent::EButton1Down,22,22); + iTest->SimulatePointer(TRawEvent::EButton1Up,22,22); + #else + // simulate pointer at (22,22) on rotated screen by providing physical coordinates + iTest->SimulatePointer(TRawEvent::EButton1Down,iPhysicalScreenSize.iWidth-1-22,iPhysicalScreenSize.iHeight-1-22); + iTest->SimulatePointer(TRawEvent::EButton1Up,iPhysicalScreenSize.iWidth-1-22,iPhysicalScreenSize.iHeight-1-22); + #endif + } + TheClient->iScreen->SetCurrentRotations(0,CFbsBitGc::EGraphicsOrientationNormal); + TheClient->iScreen->SetScreenMode(0); + TheClient->iWs.Flush(); + iTest->DelayIfFullRomL(); + if (iScreenModeTests&EDoRot0) + { + INFO_PRINTF1(_L(" :Rotation 0")); + AddExpectedPointerAnim(TRawEvent::EButton1Down, TPoint(24,24),EFalse); + AddExpectedPointerAnim(TRawEvent::EButton1Up, TPoint(24,24),EFalse); + expectedEvents+=2; + SimulatePointer(TRawEvent::EButton1Down,24,24); + SimulatePointer(TRawEvent::EButton1Up,24,24); + } + #if defined(LOGGING) + _LIT(KNumEvents," :Expected Number of Events=%d Actual=%d"); + logMessageText.Format(KNumEvents,expectedEvents,iAnim->GetNumEvents()); + INFO_PRINTF1(logMessageText); + _LIT(KError," :Error Value %d ('0'=OK)"); + logMessageText.Format(KError,iAnim->GetError()); + INFO_PRINTF1(logMessageText); + #endif + if (iAnim->TestFail(expectedEvents)) + Failed(); + User::After(EPointerCursorUpdateGap); + iBlankWin->SetVisible(EFalse); + INFO_PRINTF1(_L(" :Finished 2nd Set")); + } + break; + case 3: + iAnim->Destroy(); iAnim=NULL; + // Create an EventPostingAnim, key down & key up events are simulated. + // The event posting anim sees the key events in turn, and creates duplicates. + // Test checks that each simulated event is received twice. + TRAPD(err, iAnim=REventAnim::NewL(iQueueClient->iWin->BaseWin(), iAnimDll, REventAnimBase::EEventPostingAnim)); + if (err!=KErrNone) + { + Failed(); + return; + } + AddExpectedKeyAnim(TRawEvent::EKeyDown,32,ETrue); + AddExpectedKeyAnim(TRawEvent::EKeyDown,32,EFalse); + AddExpectedKeyAnim(TRawEvent::EKeyUp,32,ETrue); + AddExpectedKeyAnim(TRawEvent::EKeyUp,32,EFalse); + + iTest->SimulateKey(TRawEvent::EKeyDown,32); + iTest->SimulateKey(TRawEvent::EKeyUp,32); + break; + case 4: + // Simulate a key down event, which calls anim's offer raw event + // which inturn calls post key event with old and new API + // Test checks the repeat count for old and new API are as expected. + AddExpectedKeyAnim(TRawEvent::EKeyDown,45,ETrue); + + TKeyEvent event; + event.iCode='J'; + event.iScanCode=0; + event.iModifiers=0; + event.iRepeats=0; + AddExpectedKey(1, event.iScanCode, event.iCode, event.iRepeats, event.iModifiers); + event.iRepeats=2; + AddExpectedKey(1, event.iScanCode, event.iCode, event.iRepeats, event.iModifiers); + + iTest->SimulateKey(TRawEvent::EKeyDown,45); + break; + default: + iAnim->Destroy(); + iAnim=NULL; + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +void CTEventTest::FocusChanged_NextSetOfEventsL() + { +#if defined(LOGGING) + TLogMessageText logMessageText; + _LIT(KSet,"FocusChanged SetOfEvents: %d "); + logMessageText.Format(KSet,iEventSet); + INFO_PRINTF1(logMessageText); +#endif + switch(iEventSet++) + { + case 0: + { + _LIT(AutoFocusTest,"FocusEvents"); + iQueueClient->EnableFocusChangeEvents(); + iEventTestGroup2=new(ELeave) CTWindowGroup(TheClient); + iEventTestGroup2->ConstructL(); + iEventTestGroup2->GroupWin()->SetName(AutoFocusTest); + AddExpectedEvent(EEventFocusGained); + AddExpectedEvent(EEventFocusLost); + AddExpectedEvent(EEventFocusGroupChanged); + AddExpectedEvent(EEventWindowGroupsChanged); + } + break; + case 1: + iEventTestGroup2->GroupWin()->EnableReceiptOfFocus(EFalse); + AddExpectedEvent(EEventFocusGained); + AddExpectedEvent(EEventFocusGroupChanged); + break; + case 2: + iEventTestGroup2->GroupWin()->EnableReceiptOfFocus(ETrue); + AddExpectedEvent(EEventFocusLost); + AddExpectedEvent(EEventFocusGroupChanged); + break; + case 3: + iEventTestGroup2->GroupWin()->SetOrdinalPosition(999); + AddExpectedEvent(EEventFocusGained); + AddExpectedEvent(EEventFocusGroupChanged); + break; + case 4: + iEventTestGroup2->GroupWin()->SetOrdinalPosition(0); + AddExpectedEvent(EEventFocusLost); + AddExpectedEvent(EEventFocusGroupChanged); + break; + case 5: + delete iEventTestGroup2; + iEventTestGroup2=NULL; + AddExpectedEvent(EEventWindowGroupsChanged); + AddExpectedEvent(EEventFocusGroupChanged); + break; + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + + +void CTEventTest::StopEvents_NextSetOfEventsL() + { + // we are not running tests 0,1,2 as they currently fail + if(iEventSet==0) + { + iEventSet=3; + AddExpectedEvent(EEventFocusGained); + } + TInt retVal = KErrNone; + + switch(iEventSet++) + { + case 0: // doesn't work if shell gets the off events - will fail on User::LeaveIfError(.... + iQueueClient->iWs.Flush(); + User::LeaveIfError(iQueueClient->iWs.RequestOffEvents(ETrue,iQueueClient->iGroup->WinTreeNode())); + iTest->SimulateEvent(TRawEvent::ESwitchOff); + TheClient->iWs.Flush(); + retVal = iQueueClient->iWs.RequestOffEvents(ETrue,iQueueClient->iWin->WinTreeNode()); + TEST(retVal==KErrAlreadyExists); + if (retVal!=KErrAlreadyExists) + INFO_PRINTF3(_L("iQueueClient->iWs.RequestOffEvents(ETrue,iQueueClient->iWin->WinTreeNode()) return value - Expected: %d, Actual: %d"), KErrAlreadyExists, retVal); + User::LeaveIfError(iQueueClient->iWs.RequestOffEvents(EFalse,iQueueClient->iGroup->WinTreeNode())); + User::LeaveIfError(iQueueClient->iWs.RequestOffEvents(ETrue,iQueueClient->iGroup->WinTreeNode())); + iTest->SimulateEvent(TRawEvent::ESwitchOff); + TheClient->iWs.Flush(); + retVal = iQueueClient->iWs.RequestOffEvents(ETrue,iQueueClient->iGroup->WinTreeNode()); + TEST(retVal==KErrAlreadyExists); + if (retVal!=KErrAlreadyExists) + INFO_PRINTF3(_L("iQueueClient->iWs.RequestOffEvents(ETrue,iQueueClient->iGroup->WinTreeNode()) return value - Expected: %d, Actual: %d"), KErrAlreadyExists, retVal); + User::LeaveIfError(iQueueClient->iWs.RequestOffEvents(EFalse)); + AddExpectedEvent(EEventFocusGained); + AddExpectedEvent(EEventSwitchOff); + AddExpectedEvent(EEventSwitchOff); + break; + + case 1: // doesn't work if shell gets the off events - will fail on User::LeaveIfError(.... + { + TKeyEvent event; + iQueueClient->iWs.Flush(); + User::LeaveIfError(iQueueClient->iWs.RequestOffEvents(ETrue,iQueueClient->iGroup->WinTreeNode())); + event.iCode=EKeyOff; + event.iScanCode=EKeyOff; + event.iModifiers=0; + event.iRepeats=0; + TheClient->iWs.SimulateKeyEvent(event); + TheClient->iWs.Flush(); + User::LeaveIfError(iQueueClient->iWs.RequestOffEvents(EFalse)); + AddExpectedEvent(EEventKeySwitchOff); + } + break; + + case 2: // doesn't work if shell gets the off events - will fail on User::LeaveIfError(.... + { + TKeyEvent event; + event.iCode=EKeyOff; + event.iScanCode=EKeyOff; + event.iModifiers=0; + event.iRepeats=0; + iQueueClient->iWs.Flush(); + User::LeaveIfError(iQueueClient->iWs.RequestOffEvents(ETrue,iQueueClient->iGroup->WinTreeNode())); + iTest->SimulateEvent(TRawEvent::ESwitchOff); + TheClient->iWs.SimulateKeyEvent(event); + iTest->SimulateEvent(TRawEvent::ECaseClose); + TheClient->iWs.Flush(); + retVal = iQueueClient->iWs.RequestOffEvents(ETrue,iQueueClient->iWin->WinTreeNode()); + TEST(retVal==KErrAlreadyExists); + if (retVal!=KErrAlreadyExists) + INFO_PRINTF3(_L("iQueueClient->iWs.RequestOffEvents(ETrue,iQueueClient->iWin->WinTreeNode()) return value - Expected: %d, Actual: %d"), KErrAlreadyExists, retVal); + iTest->SimulateEvent(TRawEvent::ESwitchOff); + iTest->SimulateEvent(TRawEvent::ECaseClose); + TheClient->iWs.SimulateKeyEvent(event); + TheClient->iWs.Flush(); + User::LeaveIfError(iQueueClient->iWs.RequestOffEvents(EFalse,iQueueClient->iGroup->WinTreeNode())); + User::LeaveIfError(iQueueClient->iWs.RequestOffEvents(ETrue,iQueueClient->iWin->WinTreeNode())); + iTest->SimulateEvent(TRawEvent::ECaseClose); + iTest->SimulateEvent(TRawEvent::ESwitchOff); + TheClient->iWs.SimulateKeyEvent(event); + TheClient->iWs.Flush(); + User::LeaveIfError(iQueueClient->iWs.RequestOffEvents(EFalse)); + User::LeaveIfError(iQueueClient->iWs.RequestOffEvents(ETrue,iQueueClient->iChildWin->WinTreeNode())); + iTest->SimulateEvent(TRawEvent::ESwitchOff); + TheClient->iWs.SimulateKeyEvent(event); + iTest->SimulateEvent(TRawEvent::ECaseClose); + TheClient->iWs.Flush(); + User::LeaveIfError(iQueueClient->iWs.RequestOffEvents(EFalse)); + AddExpectedEvent(EEventSwitchOff); + AddExpectedEvent(EEventKeySwitchOff); + AddExpectedEvent(EEventCaseClosed); + AddExpectedEvent(EEventSwitchOff); + AddExpectedEvent(EEventCaseClosed); + AddExpectedEvent(EEventKeySwitchOff); + AddExpectedEvent(EEventCaseClosed,iQueueClient->iWin); + AddExpectedEvent(EEventSwitchOff,iQueueClient->iWin); + AddExpectedEvent(EEventKeySwitchOff,iQueueClient->iWin); + AddExpectedEvent(EEventSwitchOff,iQueueClient->iChildWin); + AddExpectedEvent(EEventKeySwitchOff,iQueueClient->iChildWin); + AddExpectedEvent(EEventCaseClosed,iQueueClient->iChildWin); + } + break; + + case 3: + iQueueClient->iWs.Flush(); + //User::LeaveIfError(iQueueClient->iGroup->WinTreeNode()->EnableOnEvents(EEventControlAlways)); + iTest->SimulateEvent(TRawEvent::ESwitchOn); + iTest->SimulateEvent(TRawEvent::ECaseOpen); + TheClient->iWs.Flush(); + User::LeaveIfError(iQueueClient->iWin->WinTreeNode()->EnableOnEvents(EEventControlAlways)); + iTest->SimulateEvent(TRawEvent::ECaseOpen); + iTest->SimulateEvent(TRawEvent::ESwitchOn); + TheClient->iWs.Flush(); + iQueueClient->iWin->WinTreeNode()->DisableOnEvents(); + AddExpectedEvent(EEventSwitchOn); + //AddExpectedEvent(EEventSwitchOn); + AddExpectedEvent(EEventCaseOpened); + AddExpectedEvent(EEventCaseOpened,iQueueClient->iWin); + AddExpectedEvent(EEventCaseOpened); + AddExpectedEvent(EEventSwitchOn,iQueueClient->iWin); + AddExpectedEvent(EEventSwitchOn); + break; + + case 4: + iQueueClient->iWs.Flush(); + // switch off the device + iTest->SimulateEvent(TRawEvent::ESwitchOff); + // switch it back on. + iTest->SimulateEvent(TRawEvent::ESwitchOn); + TheClient->iWs.Flush(); + // TRawEvent::ESwitchOff never actually comes back. The tests will hang if we look for one + AddExpectedEvent(EEventSwitchOn); + break; + + case 5: + { + TKeyEvent event; + iQueueClient->iWs.Flush(); + event.iCode=EKeyOff; + event.iScanCode=EKeyOff; + event.iModifiers=0; + event.iRepeats=0; + // switch off the device - this one seems to send it to standby rather than off + TheClient->iWs.SimulateKeyEvent(event); + // switch it back on or no further tests will complete + iTest->SimulateEvent(TRawEvent::ESwitchOn); + TheClient->iWs.Flush(); + // again we would expect EEventKeySwitchOff but it doesn't come back. The tests will hang if we look for one + AddExpectedEvent(EEventSwitchOn); + } + break; + + case 6: + iQueueClient->iWs.Flush(); + iTest->SimulateEvent(TRawEvent::ESwitchOn); + iTest->SimulateEvent(TRawEvent::ECaseOpen); + TheClient->iWs.Flush(); + User::LeaveIfError(iQueueClient->iWin->WinTreeNode()->EnableOnEvents(EEventControlAlways)); + iTest->SimulateEvent(TRawEvent::ECaseOpen); + iTest->SimulateEvent(TRawEvent::ESwitchOn); + TheClient->iWs.Flush(); + iQueueClient->iWin->WinTreeNode()->DisableOnEvents(); + AddExpectedEvent(EEventSwitchOn); + AddExpectedEvent(EEventCaseOpened); + AddExpectedEvent(EEventCaseOpened,iQueueClient->iWin); + AddExpectedEvent(EEventCaseOpened); + AddExpectedEvent(EEventSwitchOn,iQueueClient->iWin); + AddExpectedEvent(EEventSwitchOn); + break; + + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +void CTEventTest::VirtualKeyboard_NextSetOfEventsL() + { + const TInt noVirtualKeys=10; + const TInt keyWidth=2*EWinWidth/noVirtualKeys/3; + const TInt keyHeight=EWinHeight/2; + const TInt keySpacing=EWinWidth/noVirtualKeys; + const TInt baseChar='1'; + TInt startX=1; + TInt ii; + switch(iEventSet++) + { + case 0: + iQueueClient->iWin->BaseWin()->SetPointerGrab(EFalse); + for (ii=0;iiiWin->BaseWin()->AddKeyRect(TRect(startX,1,startX+keyWidth,keyHeight),baseChar+ii,EFalse); + startX+=keySpacing; + } + iQueueClient->iWs.Flush(); + iTest->SimulatePointerDownUp(EWinPositionX+1,EWinPositionY+1+iYOffset); + //TheClient->iWs.Flush(); + AddExpectedEvent(EEventFocusGained); + AddExpectedKeyDownUp(baseChar); + break; + case 1: + startX=3; + for (ii=0;iiSimulatePointerDownUp(startX+EWinPositionX+1,EWinPositionY+keyHeight-1+iYOffset); + AddExpectedKeyDownUp(baseChar+ii); + startX+=keySpacing; + } + break; + case 2: + SimulatePointerDownUpWin(keySpacing+1,1); + //SimulatePointerDownUp(EWinPositionX+keySpacing+1,EWinPositionY+1); + iTest->SimulatePointerDownUp(EWinPositionX+keyWidth,EWinPositionY+1+iYOffset); + iTest->SimulatePointerDownUp(EWinPositionX+1,EWinPositionY+keyHeight-1+iYOffset); + iTest->SimulatePointerDownUp(EWinPositionX+keyWidth,EWinPositionY+keyHeight-1+iYOffset); + AddExpectedKeyDownUp(baseChar+1); + AddExpectedKeyDownUp(baseChar); + AddExpectedKeyDownUp(baseChar); + AddExpectedKeyDownUp(baseChar); + break; + case 3: + SimulatePointerDownUpWin(keySpacing+3,4); + SimulatePointerDownUpWin(0,0); //No Pointer event get through even if there are gaps + SimulatePointerDownUpWin(1,0); + SimulatePointerDownUpWin(0,1); + SimulatePointerDownUpWin(keyWidth+1,0); + SimulatePointerDownUpWin(keyWidth,0); + SimulatePointerDownUpWin(keyWidth+1,1); + SimulatePointerDownUpWin(0,keyHeight); + SimulatePointerDownUpWin(1,keyHeight); + SimulatePointerDownUpWin(0,keyHeight-1); + SimulatePointerDownUpWin(keyWidth+1,keyHeight); + SimulatePointerDownUpWin(keyWidth,keyHeight); + SimulatePointerDownUpWin(keyWidth+1,keyHeight-1); + SimulatePointerDownUpWin(2*keySpacing+3,4); + AddExpectedKeyDownUp(baseChar+1); + AddExpectedPointerDownUpScr(TPoint(EWinPositionX+0,EWinPositionY+0)); //No Pointer event get through even if there are gaps + AddExpectedPointerDownUpScr(TPoint(EWinPositionX+1,EWinPositionY+0)); + AddExpectedPointerDownUpScr(TPoint(EWinPositionX+0,EWinPositionY+1)); + AddExpectedPointerDownUpScr(TPoint(EWinPositionX+keyWidth+1,EWinPositionY+0)); + AddExpectedPointerDownUpScr(TPoint(EWinPositionX+keyWidth,EWinPositionY+0)); + AddExpectedPointerDownUpScr(TPoint(EWinPositionX+keyWidth+1,EWinPositionY+1)); + AddExpectedPointerDownUpScr(TPoint(EWinPositionX+0,EWinPositionY+keyHeight)); + AddExpectedPointerDownUpScr(TPoint(EWinPositionX+1,EWinPositionY+keyHeight)); + AddExpectedPointerDownUpScr(TPoint(EWinPositionX+0,EWinPositionY+keyHeight-1)); + AddExpectedPointerDownUpScr(TPoint(EWinPositionX+keyWidth+1,EWinPositionY+keyHeight)); + AddExpectedPointerDownUpScr(TPoint(EWinPositionX+keyWidth,EWinPositionY+keyHeight)); + AddExpectedPointerDownUpScr(TPoint(EWinPositionX+keyWidth+1,EWinPositionY+keyHeight-1)); + AddExpectedKeyDownUp(baseChar+2); + break; + case 4: + SimulatePointerWin(TRawEvent::EButton1Down,keySpacing+2,6); + SimulatePointerWin(TRawEvent::EButton1Up,2*keySpacing+1,5); + SimulatePointerWin(TRawEvent::EButton1Down,2*keySpacing+2,7); + SimulatePointer(TRawEvent::EButton1Up,0,0); + AddExpectedKeyDownUp(baseChar+1); + AddExpectedKeyDownUp(baseChar+2); + break; + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +TInt CTEventTest::ClickCommandReply(TInt aCommand,TInt aData) + { + TPckgBuf intPkg; + intPkg()=aData; + return iClick.CommandReply(aCommand,intPkg); + } + +TInt CTEventTest::CreateGroupWindow(RWindowGroup& aWinGp,TClients aClient,TInt& aWinGpId) + { + ClickCommandReply(EClickCreateGroupWin,aClient); + TInt err=aWinGp.Construct(ENullWsHandle,EFalse); + if (!err) + { + aWinGpId=aWinGp.Identifier(); + ClickCommandReply(EClickCheckGpWinId,aWinGpId); + } + return err; + } + +void CTEventTest::CloseGroupWindow(RWindowGroup& aWinGp,TInt aWinGpId) + { + ClickCommandReply(EClickCloseGroupWin,aWinGpId); + aWinGp.Close(); + } + +void CTEventTest::CloseWindow(RWindowBase& aWin,TInt aHandle,TInt aWinGpId) + { + TPckgBuf winClose; + winClose().iClientHandle=aHandle; + winClose().iWindowGroupId=aWinGpId; + iClick.CommandReply(EClickCloseWin,winClose); + aWin.Close(); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0447 + +@SYMCR CR1164 + +@SYMTestCaseDesc Tests that Key Click Plug-in gets new event Information + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Do things that cause the new events to be sent into plug-in. +Creating destroying windows, pointer events. Provide test plug-in with information it needs to check events. + +@SYMTestExpectedResults When Test Plug-in is querried to see if events match what was expected it says that they were. +*/ +void CTEventTest::KeyClicks_NextSetOfEvents() + { +#if defined(LOGGING) + TLogMessageText logMessageText; + _LIT(KSet,"KeyClicks SetOfEvents: %d (last=13)"); + logMessageText.Format(KSet,iEventSet); + INFO_PRINTF1(logMessageText); +#endif + TInt events=-1; + switch(iEventSet++) + { + case 0: + if (SetClickType(EClickCheck)) + return; + iAddToClick=ETrue; + iQueueClient->iWin->BaseWin()->SetPointerGrab(EFalse); + iQueueClient->iChildWin->BaseWin()->SetPointerGrab(EFalse); + AddExpectedEvent(EEventFocusGained); + AddExpectedKeyDownUp(EStdKeySpace,EKeySpace); + iQueueClient->iWs.Flush(); + iTest->SimulateKeyDownUp(EStdKeySpace); //3 events + events=3; + break; + case 1: + AddExpectedKeyDownUp(EStdKeyEnter,EKeyEnter); + AddExpectedKeyDownUp('0'); + AddExpectedKeyDownUp('A','a'); + AddExpectedKeyDownUp('X','x'); + AddExpectedKey(EEventKeyDown,EStdKeyLeftShift,0,0,EModifierLeftShift|EModifierShift); + AddExpectedKey(EEventKeyUp,EStdKeyLeftShift); + iQueueClient->iWs.Flush(); + iTest->SimulateKeyDownUp(EStdKeyEnter); //3 events + iTest->SimulateKeyDownUp('0'); //3 events + iTest->SimulateKeyDownUp('A'); //3 events + iTest->SimulateKeyDownUp('X'); //3 events + iTest->SimulateKeyDownUp(EStdKeyLeftShift); //2 events + events=14; + break; + case 2: + AddExpectedKey(EEventKeyDown,EStdKeyRightShift,0,0,EModifierRightShift|EModifierShift); + AddExpectedKeyDownUp('B','B',0,EModifierRightShift|EModifierShift); + AddExpectedKeyDownUp('W','W',0,EModifierRightShift|EModifierShift); + AddExpectedKey(EEventKeyUp,EStdKeyRightShift); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeyRightShift); //1 event + iTest->SimulateKeyDownUp('B'); //3 events + iTest->SimulateKeyDownUp('W'); //3 events + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeyRightShift); //1 event + events=8; + break; + case 3: + AddExpectedKey(EEventKeyDown,'C'); + AddExpectedKey(EEventKey,'C','c'); + AddExpectedKey(EEventKeyDown,'V'); + AddExpectedKey(EEventKey,'V','v'); + AddExpectedKey(EEventKeyUp,'C'); + AddExpectedKey(EEventKeyUp,'V'); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,'C'); //2 events + iTest->SimulateKey(TRawEvent::EKeyDown,'V'); //2 events + iTest->SimulateKey(TRawEvent::EKeyUp,'C'); //1 event + iTest->SimulateKey(TRawEvent::EKeyUp,'V'); //1 event + events=6; + break; + case 4: + { + AddExpectedKey(EEventKeyDown,'D'); + AddExpectedKey(EEventKey,'D','d'); + AddExpectedKey(EEventKey,'D','d',1); + AddExpectedKey(EEventKeyUp,'D'); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,'D'); //2 events + TTimeIntervalMicroSeconds32 initialTime,time; + TheClient->iWs.GetKeyboardRepeatRate(initialTime,time); + User::After(initialTime.Int()+time.Int()/4); //1 event + iTest->SimulateKey(TRawEvent::EKeyUp,'D'); //1 event + events=4; + } + break; + case 5: + AddExpectedPointerDownUpScr(TPoint(40,25)); + AddExpectedPointerDownUpScr(TPoint(95,30)); + AddExpectedPointer(TPointerEvent::EButton1Down,TPoint(20-EWinPositionX,50-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EDrag,TPoint(45-EWinPositionX,42-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up,TPoint(45-EWinPositionX,42-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down,TPoint(98-EWinPositionX,15-EWinPositionY)); + AddExpectedPointerClick(TPointerEvent::EDrag,TPoint(68-EWinPositionX,39-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EDrag,TPoint(41-EWinPositionX,42-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up,TPoint(50-EWinPositionX,58-EWinPositionY)); + iQueueClient->iWs.Flush(); + iTest->SimulatePointerDownUp(40,25+iYOffset); //2 events + iTest->SimulatePointerDownUp(95,30+iYOffset); //2 events + SimulatePointer(TRawEvent::EButton1Down,20,50); //1 event + SimulatePointer(TRawEvent::EPointerMove,45,42); //1 event + SimulatePointer(TRawEvent::EButton1Up,45,42); //1 event + SimulatePointer(TRawEvent::EButton1Down,98,15); //1 event + SimulatePointer(TRawEvent::EPointerMove,68,39); //1 event + SimulatePointer(TRawEvent::EPointerMove,41,42); //1 event + SimulatePointer(TRawEvent::EButton1Up,50,58); //1 event + events=11; + break; + case 6: + AddExpectedKey(EEventKeyDown,'E'); + AddExpectedKey(EEventKey,'E','e'); + AddExpectedPointerDownUpScr(TPoint(41,24)); + AddExpectedKey(EEventKeyUp,'E'); + AddExpectedPointer(TPointerEvent::EButton1Down,TPoint(23-EWinPositionX,52-EWinPositionY)); + AddExpectedKeyDownUp('1'); + AddExpectedPointer(TPointerEvent::EButton1Up,TPoint(44-EWinPositionX,45-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Down,TPoint(33-EWinPositionX,53-EWinPositionY)); + AddExpectedKey(EEventKeyDown,'F'); + AddExpectedKey(EEventKey,'F','f'); + AddExpectedPointer(TPointerEvent::EButton1Up,TPoint(34-EWinPositionX,47-EWinPositionY)); + AddExpectedKey(EEventKeyUp,'F'); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,'E'); //2 events + iTest->SimulatePointerDownUp(41,24+iYOffset); //2 events + iTest->SimulateKey(TRawEvent::EKeyUp,'E'); //1 event + SimulatePointer(TRawEvent::EButton1Down,23,52); //1 event + iTest->SimulateKeyDownUp('1'); //3 events + SimulatePointer(TRawEvent::EButton1Up,44,45); //1 event + SimulatePointer(TRawEvent::EButton1Down,33,53); //1 event + iTest->SimulateKey(TRawEvent::EKeyDown,'F'); //2 events + SimulatePointer(TRawEvent::EButton1Up,34,47); //1 event + iTest->SimulateKey(TRawEvent::EKeyUp,'F'); //1 event + events=15; + break; + case 7: + AddExpectedKeyDownUp('2'); + iAddToClick=EFalse; + AddExpectedKeyDownUp('G','g'); + iAddToClick=ETrue; + AddExpectedPointerDownUpScr(TPoint(42,26)); + AddExpectedKeyDownUp('U','u'); + iQueueClient->iWs.Flush(); + iTest->SimulateKeyDownUp('2'); //3 events + TheClient->iWs.Flush(); + iQueueClient->iGroup->GroupWin()->DisableKeyClick(ETrue); + iQueueClient->iWs.Flush(); + iTest->SimulateKeyDownUp('G'); + iTest->SimulatePointerDownUp(42,26+iYOffset); //2 events + TheClient->iWs.Flush(); + iQueueClient->iGroup->GroupWin()->DisableKeyClick(EFalse); + iQueueClient->iWs.Flush(); + iTest->SimulateKeyDownUp('U'); //3 events + events=8; + break; + case 8: + { + TPckgBuf pointerEventInfo; + pointerEventInfo().iClientHandle=reinterpret_cast(iQueueClient->iChildWin); + pointerEventInfo().iWinGpId=iQueueClient->iGroup->GroupWin()->Identifier(); + pointerEventInfo().iWinOrigin=iQueueClient->ChildTopLeft(); + pointerEventInfo().iParentOrigin.SetXY(EWinPositionX,EWinPositionY); + iClick.CommandReply(EClickPointerEvent,pointerEventInfo); + AddExpectedKeyDownUp('3'); + AddExpectedPointerDownUpScr(TPoint(43,26)); + AddExpectedKeyDownUp('H','h'); + iAddToClick=EFalse; + AddExpectedPointerDownUpScr(TPoint(43,27)); + AddExpectedKeyDownUp('4'); + AddExpectedPointerDownUpScr(TPoint(42,27)); + AddExpectedKeyDownUp('I','i'); + iAddToClick=ETrue; + AddExpectedPointerDownUpScr(TPoint(44,27)); + AddExpectedKeyDownUp('5'); + AddExpectedPointerDownUpScr(TPoint(44,26)); + iQueueClient->iWs.Flush(); + iTest->SimulateKeyDownUp('3'); //3 events + iTest->SimulatePointerDownUp(43,26+iYOffset); //2 events + iClick.SetPenClick(EFalse); + iTest->SimulateKeyDownUp('H'); //3 events + iTest->SimulatePointerDownUp(43,27+iYOffset); + iClick.SetKeyClick(EFalse); + iTest->SimulateKeyDownUp('4'); + iTest->SimulatePointerDownUp(42,27+iYOffset); + iClick.SetPenClick(ETrue); + iTest->SimulateKeyDownUp('I'); + iTest->SimulatePointerDownUp(44,27+iYOffset); //2 events + iClick.SetKeyClick(ETrue); + iTest->SimulateKeyDownUp('5'); //3 events + iTest->SimulatePointerDownUp(44,26+iYOffset); //2 events + pointerEventInfo().iClientHandle=0; + pointerEventInfo().iWinGpId=0; + iClick.CommandReply(EClickPointerEvent,pointerEventInfo); + events=15; + } + break; + case 9: + { + RWindowGroup winGp(iQueueClient->iWs); + TInt winGpId; + TInt ii; + AddExpectedEvent(EEventWindowGroupsChanged); + for (ii=0;ii<2;++ii) //events x2 + { + if (CreateGroupWindow(winGp,EQueueClient,winGpId)) //1 event + Failed(); + CloseGroupWindow(winGp,winGpId); //1 event + iQueueClient->iWs.Flush(); + } + events=4; + } + break; + case 10: + { + RWindowGroup winGp(TheClient->iWs); + RWindowGroup winGp1(iQueueClient->iWs); + RWindowGroup winGp2(iQueueClient->iWs); + TInt winGpId; + TInt winGpId1; + TInt winGpId2; + AddExpectedEvent(EEventWindowGroupsChanged); + if (CreateGroupWindow(winGp,ETheClient,winGpId)) //1 event + Failed(); + CloseGroupWindow(winGp,winGpId); //1 event + TheClient->iWs.Flush(); + if (CreateGroupWindow(winGp1,EQueueClient,winGpId1)) //1 event + Failed(); + if (CreateGroupWindow(winGp2,EQueueClient,winGpId2)) //1 event + Failed(); + if (CreateGroupWindow(winGp,ETheClient,winGpId)) //1 event + Failed(); + CloseGroupWindow(winGp2,winGpId2); //1 event + iQueueClient->iWs.Flush(); + CloseGroupWindow(winGp,winGpId); //1 event + TheClient->iWs.Flush(); + CloseGroupWindow(winGp1,winGpId1); //1 event + iQueueClient->iWs.Flush(); + events=8; + } + break; + case 11: + { + RWindowGroup winGp(iQueueClient->iWs); + TInt winGpId; + AddExpectedEvent(EEventWindowGroupsChanged); + if (CreateGroupWindow(winGp,EQueueClient,winGpId)) //1 event + Failed(); + RWindow win(iQueueClient->iWs); + const TInt handle=79; + if (win.Construct(winGp,handle)) + Failed(); + win.Activate(); + CloseWindow(win,handle,winGpId); //1 event + iQueueClient->iWs.Flush(); + CloseGroupWindow(winGp,winGpId); //1 event + iQueueClient->iWs.Flush(); + events=3; + } + break; + case 12: + { + RWindowGroup winGp1(iQueueClient->iWs); + RWindowGroup winGp2(TheClient->iWs); + TInt winGpId1; + TInt winGpId2; + AddExpectedEvent(EEventWindowGroupsChanged); + if (CreateGroupWindow(winGp2,ETheClient,winGpId2)) //1 event + Failed(); + if (CreateGroupWindow(winGp1,EQueueClient,winGpId1)) //1 event + Failed(); + RWindow win1(iQueueClient->iWs); + RWindow win2(iQueueClient->iWs); + RWindow win(TheClient->iWs); + const TInt handle1a=80; + const TInt handle1b=81; + const TInt handle2a=82; + const TInt handle2b=83; + const TInt handle=84; + if (win1.Construct(winGp1,handle1a)) + Failed(); + win1.Activate(); + if (win2.Construct(win1,handle2a)) + Failed(); + win2.Activate(); + if (win.Construct(winGp2,handle)) + Failed(); + win.Activate(); + CloseWindow(win2,handle2a,winGpId1); //1 event + iQueueClient->iWs.Flush(); + if (win2.Construct(winGp1,handle2b)) + Failed(); + win2.Activate(); + CloseWindow(win1,handle1a,winGpId1); //1 event + iQueueClient->iWs.Flush(); + CloseWindow(win,handle,winGpId2); //1 event + TheClient->iWs.Flush(); + if (win1.Construct(win2,handle1b)) + Failed(); + win1.Activate(); + CloseWindow(win1,handle1b,winGpId1); //1 event + iQueueClient->iWs.Flush(); + CloseGroupWindow(winGp2,winGpId2); //1 event + TheClient->iWs.Flush(); + CloseWindow(win2,handle2b,winGpId1); //1 event + iQueueClient->iWs.Flush(); + CloseGroupWindow(winGp1,winGpId1); //1 event + iQueueClient->iWs.Flush(); + events=9; + } + break; + case 13: + { + TPckgBuf pointerEventInfo; + pointerEventInfo().iClientHandle=reinterpret_cast(iQueueClient->iWin); + pointerEventInfo().iWinGpId=iQueueClient->iGroup->GroupWin()->Identifier(); + pointerEventInfo().iWinOrigin.SetXY(EWinPositionX,EWinPositionY); + pointerEventInfo().iParentOrigin.SetXY(0,0); + iClick.CommandReply(EClickPointerEvent,pointerEventInfo); + AddExpectedPointerDownUpScr(TPoint(43,18)); + AddExpectedPointerDownUpScr(TPoint(43,17)); + AddExpectedPointerDownUpScr(TPoint(42,52)); + AddExpectedPointerDownUpScr(TPoint(24,27)); + AddExpectedPointerDownUpScr(TPoint(94,26)); + iQueueClient->iWs.Flush(); + iTest->SimulatePointerDownUp(43,18+iYOffset); //2 events + iTest->SimulatePointerDownUp(43,17+iYOffset); //2 events + iTest->SimulatePointerDownUp(42,52+iYOffset); //2 events + iTest->SimulatePointerDownUp(24,27+iYOffset); //2 events + iTest->SimulatePointerDownUp(94,26+iYOffset); //2 events + pointerEventInfo().iClientHandle=0; + pointerEventInfo().iWinGpId=0; + iClick.CommandReply(EClickPointerEvent,pointerEventInfo); + events=10; + } + break; + default: + iAddToClick=EFalse; + if (!SetClickType(EClickNone)) + CActiveScheduler::Stop(); + return; + } + TInt failedAt=iClick.CommandReply(EClickFailed,TPtrC8(NULL,0)); + TInt eventsDone=iClick.CommandReply(EClickEvents,TPtrC8(NULL,0)); + if (failedAt!=0 || eventsDone!=events) //iEventSet (already incremented) + { + #if defined(LOGGING) + _LIT(KeyClickFailed,"KeyClick Failed EventSet=%d FailedAt=%d TotalEvents=%d EventsDone=%d"); + logMessageText.Format(KeyClickFailed,iEventSet-1,failedAt,events,eventsDone); + INFO_PRINTF1(logMessageText); + #endif + Failed(); + } + iClick.CommandReply(EClickReset,TPtrC8(NULL,0)); + } + +void CTEventTest::CaptureLong_NextSetOfEventsL() + { + TTimeIntervalMicroSeconds32 initialTime,time; + TheClient->iWs.GetKeyboardRepeatRate(initialTime,time); + #if defined(LOGGING) + TLogMessageText logMessageText; + _LIT(KSet,"CaptureLong SetOfEvents: %d of 14"); + logMessageText.Format(KSet,iEventSet); + INFO_PRINTF1(logMessageText); + #endif + + switch(iEventSet++) + { + case 0: + iQueueClient->iWs.Flush(); + iTest->SimulateKeyDownUp('A'); + AddExpectedEvent(EEventFocusGained); + AddExpectedKeyDownUp('A','a'); + break; + case 1: + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureLongKey(' ','a',0,0,2,ELongCaptureNormal); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeySpace); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+time.Int()/3); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKey,EStdKeySpace,' '); + AddExpectedKey(EEventKey,EStdKeySpace,'a',1); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + iQueueClient->iGroup->GroupWin()->CancelCaptureLongKey(iCaptureKey); + break; + case 2: + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureLongKey(' ','a',0,0,2,ELongCaptureWaitShort); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeySpace); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+time.Int()/3); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace); + iTest->SimulateKeyDownUp(EStdKeySpace); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKey,EStdKeySpace,'a',1); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + AddExpectedKeyDownUp(EStdKeySpace,' '); + iQueueClient->iGroup->GroupWin()->CancelCaptureLongKey(iCaptureKey); + break; + case 3: + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureLongKey(' ','a',0,0,2,ELongCaptureNormal|ELongCaptureRepeatEvents); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeySpace); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+5*time.Int()); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKey,EStdKeySpace,' '); + AddExpectedKey(EEventKey,EStdKeySpace,'a',2); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + iQueueClient->iGroup->GroupWin()->CancelCaptureLongKey(iCaptureKey); + break; + case 4: + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,'Z'); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+3*time.Int()); + iTest->SimulateKey(TRawEvent::EKeyDown,'Y'); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+2*time.Int()); + iTest->SimulateKey(TRawEvent::EKeyUp,'Z'); + iTest->SimulateKey(TRawEvent::EKeyUp,'Y'); + AddExpectedKey(EEventKeyDown,'Z'); + AddExpectedKey(EEventKey,'Z','z'); + AddExpectedKey(EEventKey,'Z','z',1); + AddExpectedKey(EEventKeyDown,'Y'); + AddExpectedKey(EEventKey,'Y','y'); + AddExpectedKey(EEventKey,'Y','y',1); + AddExpectedKey(EEventKeyUp,'Z'); + AddExpectedKey(EEventKeyUp,'Y'); + break; + case 5: + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,'Z'); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+3*time.Int()); + iTest->SimulateKey(TRawEvent::EKeyDown,'Y'); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+5*time.Int()/2); + iTest->SimulateKey(TRawEvent::EKeyUp,'Y'); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+2*time.Int()); + iTest->SimulateKey(TRawEvent::EKeyUp,'Z'); + AddExpectedKey(EEventKeyDown,'Z'); + AddExpectedKey(EEventKey,'Z','z'); + AddExpectedKey(EEventKey,'Z','z',1); + AddExpectedKey(EEventKeyDown,'Y'); + AddExpectedKey(EEventKey,'Y','y'); + AddExpectedKey(EEventKey,'Y','y',1); + AddExpectedKey(EEventKeyUp,'Y'); + AddExpectedKey(EEventKey,'Z','z',1); + AddExpectedKey(EEventKeyUp,'Z'); + break; + case 6: + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureLongKey(' ','b',0,0,2,ELongCaptureNormal); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,'X'); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+3*time.Int()); + iTest->SimulateKeyDownUp(EStdKeySpace); + TheClient->iWs.Flush(); + if(!iTest->IsFullRomL()) + { + User::After(initialTime.Int()+2*time.Int()); + } + iTest->SimulateKey(TRawEvent::EKeyUp,'X'); + AddExpectedKey(EEventKeyDown,'X'); + AddExpectedKey(EEventKey,'X','x'); + AddExpectedKey(EEventKey,'X','x',1); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKey,EStdKeySpace,' '); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + if(!iTest->IsFullRomL()) + { + AddExpectedKey(EEventKey,'X','x',1); + } + AddExpectedKey(EEventKeyUp,'X'); + iQueueClient->iGroup->GroupWin()->CancelCaptureLongKey(iCaptureKey); + break; + case 7: + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureLongKey(' ','b',0,0,2,ELongCaptureNormal|ELongCaptureRepeatEvents); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,'X'); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+5*time.Int()); + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeySpace); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+time.Int()/3); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace); + TheClient->iWs.Flush(); + User::ResetInactivityTime(); + User::After(initialTime.Int()+4*time.Int()); + iTest->SimulateKey(TRawEvent::EKeyUp,'X'); + AddExpectedKey(EEventKeyDown,'X'); + AddExpectedKey(EEventKey,'X','x'); + AddExpectedKey(EEventKey,'X','x',1); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKey,EStdKeySpace,' '); + AddExpectedKey(EEventKey,EStdKeySpace,'b',1); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + AddExpectedKey(EEventKey,'X','x',1); + AddExpectedKey(EEventKeyUp,'X'); + iQueueClient->iGroup->GroupWin()->CancelCaptureLongKey(iCaptureKey); + break; + case 8: + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureLongKey(' ','c',0,0,2,ELongCaptureRepeatEvents); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeySpace); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+5*time.Int()); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKey,EStdKeySpace,'c',1); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + iQueueClient->iGroup->GroupWin()->CancelCaptureLongKey(iCaptureKey); + break; + case 9: + { + TInt captureKey=iQueueClient->iGroup->GroupWin()->CaptureLongKey(EKeyEscape,'e',0,0,2,ELongCaptureNormal|ELongCaptureRepeatEvents); + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureLongKey(' ','d',0,0,2,ELongCaptureNormal|ELongCaptureRepeatEvents); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeySpace); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+5*time.Int()/2); + iTest->SimulateKeyDownUp(EStdKeyEscape); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+3*time.Int()); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKey,EStdKeySpace,' '); + AddExpectedKey(EEventKey,EStdKeySpace,'d',1); + AddExpectedKey(EEventKeyDown,EStdKeyEscape); + AddExpectedKey(EEventKey,EStdKeyEscape,EKeyEscape); + AddExpectedKey(EEventKeyUp,EStdKeyEscape); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + iQueueClient->iGroup->GroupWin()->CancelCaptureLongKey(iCaptureKey); + iQueueClient->iGroup->GroupWin()->CancelCaptureLongKey(captureKey); + } + break; + case 10: + //Cancel a long capture key event whilst a repeat is underway + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureLongKey(' ','a',0,0,2,ELongCaptureNormal|ELongCaptureRepeatEvents); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeySpace); + TheClient->iWs.Flush(); + iQueueClient->iGroup->GroupWin()->CancelCaptureLongKey(iCaptureKey); + User::After(initialTime.Int()+5*time.Int()); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKey,EStdKeySpace,' '); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + break; + case 11: + //Cancel a capture key up and down event whilst a repeat is underway + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureKeyUpAndDowns(EStdKeySpace,0,0); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,'X'); + TheClient->iWs.Flush(); + iQueueClient->iGroup->GroupWin()->CancelCaptureKeyUpAndDowns(iCaptureKey); + User::After(initialTime.Int()+5*time.Int()); + iTest->SimulateKey(TRawEvent::EKeyUp,'X'); + AddExpectedKey(EEventKeyDown,'X'); + AddExpectedKey(EEventKey,'X','x'); + AddExpectedKey(EEventKeyUp,'X'); + break; + case 12: + //Cancel a capture key event whilst a repeat is underway + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureKey(EStdKeySpace,0,0); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,'Y'); + TheClient->iWs.Flush(); + iQueueClient->iGroup->GroupWin()->CancelCaptureKey(iCaptureKey); + User::After(initialTime.Int()+5*time.Int()); + iTest->SimulateKey(TRawEvent::EKeyUp,'Y'); + AddExpectedKey(EEventKeyDown,'Y'); + AddExpectedKey(EEventKey,'Y','y'); + AddExpectedKey(EEventKeyUp,'Y'); + break; + case 13: + //Variation on case 12 i.e. change in the timing of the CancelCaptureKey call + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureKey(EStdKeySpace,0,0); + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,'Z'); + TheClient->iWs.Flush(); + User::After(initialTime.Int()+5*time.Int()/2); + iQueueClient->iGroup->GroupWin()->CancelCaptureKey(iCaptureKey); + User::After(initialTime.Int()+5*time.Int()/2); + iTest->SimulateKey(TRawEvent::EKeyUp,'Z'); + AddExpectedKey(EEventKeyDown,'Z'); + AddExpectedKey(EEventKey,'Z','z'); + AddExpectedKey(EEventKey,'Z','z',2); + AddExpectedKey(EEventKeyUp,'Z'); + break; + case 14: + { + // Cancel long capture key event when normal capture key is scheduled for different + // window group. + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureLongKey(' ','a',0,0,2,ELongCaptureNormal); + TInt shortCaptKey = TheClient->iGroup->GroupWin()->CaptureKey(' ',0,0); + + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeySpace); + TheClient->iWs.Flush(); + iQueueClient->iGroup->GroupWin()->CancelCaptureLongKey(iCaptureKey); + User::After(initialTime.Int()+time.Int()/3); + + TheClient->iGroup->GroupWin()->CancelCaptureKey(shortCaptKey); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + } + break; + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +#define PASSWORD_START_OF_DAY 4 +void CTEventTest::Password_NextSetOfEvents() + { + switch(iEventSet++) + { + case 0: + iQueueClient->iWin->BaseWin()->PasswordWindow(EPasswordAlwaysTriggerNow); + iQueueClient->iWs.PasswordEntered(); + iTest->SimulateKeyDownUp('2'); + iQueueClient->iWs.Flush(); + AddExpectedEvent(EEventFocusGained); + AddExpectedEvent(EEventPassword); + AddExpectedKeyDownUp('2'); + break; + case 1: + iQueueClient->iWin->BaseWin()->PasswordWindow(EPasswordOnceADayTriggerNow); + iQueueClient->iWs.PasswordEntered(); + iTest->SimulateKeyDownUp('3'); + iQueueClient->iWs.Flush(); + AddExpectedEvent(EEventPassword); + AddExpectedKeyDownUp('3'); + break; + case 2: + { + TTime time; + time.HomeTime(); + TInt day=time.DayNoInMonth(); + if (day==0) + day=5; + time-=TTimeIntervalDays(day); + time+=TTimeIntervalHours(PASSWORD_START_OF_DAY); + User::SetHomeTime(time); + iQueueClient->iWin->BaseWin()->PasswordWindow(EPasswordOnceADayTriggerNow); + iQueueClient->iWs.PasswordEntered(); + iTest->SimulateKeyDownUp('3'); + iQueueClient->iWs.Flush(); + AddExpectedEvent(EEventPassword); + AddExpectedKeyDownUp('3'); + time+=TTimeIntervalDays(day); + time-=TTimeIntervalHours(PASSWORD_START_OF_DAY); + User::SetHomeTime(time); + } + break; + case 3: + { + TTime time; + time.HomeTime(); + TInt day=time.DayNoInMonth(); + time-=TTimeIntervalDays(day); + time+=TTimeIntervalHours(PASSWORD_START_OF_DAY); + User::SetHomeTime(time); + iQueueClient->iWin->BaseWin()->PasswordWindow(EPasswordOnceADay); + iQueueClient->iWs.PasswordEntered(); + iTest->SimulateEvent(TRawEvent::ESwitchOn); + iTest->SimulateKeyDownUp('3'); + iQueueClient->iWs.Flush(); + AddExpectedEvent(EEventPassword); + AddExpectedEvent(EEventSwitchOn); + AddExpectedKeyDownUp('3'); + time+=TTimeIntervalDays(day); + time-=TTimeIntervalHours(PASSWORD_START_OF_DAY); + User::SetHomeTime(time); + } + break; + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +void CTEventTest::GroupListChanged_NextSetOfEventsL() + { + _LIT(WindowGroup1,"WindowGroupName1"); + _LIT(WindowGroup2,"WindowGroupName2"); + switch(iEventSet++) + { + case 0: + { + _LIT(TestGroup3,"GroupListEvents3"); + iQueueClient->EnableGroupListChangeEvents(); + iEventTestGroup3=new(ELeave) CTWindowGroup(TheClient); + iEventTestGroup3->ConstructL(); + iEventTestGroup3->GroupWin()->SetName(TestGroup3); + AddExpectedEvent(EEventFocusGained); + AddExpectedEvent(EEventFocusLost); + AddExpectedEvent(EEventWindowGroupListChanged); + AddExpectedEvent(EEventWindowGroupsChanged); + } + break; + case 1: + { + _LIT(TestGroup4,"GroupListEvents4"); + iEventTestGroup4=new(ELeave) CTWindowGroup(TheClient); + iEventTestGroup4->ConstructL(); + iEventTestGroup4->GroupWin()->SetName(TestGroup4); + AddExpectedEvent(EEventWindowGroupListChanged); + AddExpectedEvent(EEventWindowGroupsChanged); + } + break; + case 2: + iEventTestGroup3->GroupWin()->SetOrdinalPosition(0); + AddExpectedEvent(EEventWindowGroupListChanged); + break; + case 3: + iEventTestGroup3->GroupWin()->SetOrdinalPosition(999); + AddExpectedEvent(EEventWindowGroupListChanged); + break; + case 4: + iEventTestGroup4->GroupWin()->SetOrdinalPosition(999); + AddExpectedEvent(EEventFocusGained); + AddExpectedEvent(EEventWindowGroupListChanged); + // Testcase for defect INC135635 + // Since iWin has OrdinalPosition Zero (the front) clicking on it won't generate an + // EEventWindowGroupListChanged event as there is no change in the order of the windows + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(20-EWinPositionX,11-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(20-EWinPositionX,11-EWinPositionY)); + SimulatePointer(TRawEvent::EButton1Down,20,11); + SimulatePointer(TRawEvent::EButton1Up,20,11); + break; + case 5: + iEventTestGroup3->GroupWin()->SetOrdinalPosition(999); + AddExpectedEvent(EEventWindowGroupListChanged); + break; + case 6: + iEventTestGroup3->GroupWin()->SetOrdinalPosition(99); + SimulatePointer(TRawEvent::EButton1Down,20,11); + iEventTestGroup3->GroupWin()->SetName(WindowGroup1); + AddExpectedPointer(TPointerEvent::EButton1Down, TPoint(20-EWinPositionX,11-EWinPositionY)); + AddExpectedEvent(EEventWindowGroupsChanged); + break; + case 7: + iEventTestGroup3->GroupWin()->SetName(WindowGroup2); + SimulatePointer(TRawEvent::EButton1Up,10,20); + AddExpectedEvent(EEventWindowGroupsChanged); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(10-EWinPositionX,20-EWinPositionY)); + break; + case 8: + iEventTestGroup3->GroupWin()->SetName(WindowGroup1); + SimulatePointer(TRawEvent::EButton2Down,20,30); + AddExpectedEvent(EEventWindowGroupsChanged); + AddExpectedPointer(TPointerEvent::EButton2Down, TPoint(20-EWinPositionX,30-EWinPositionY)); + break; + case 9: + SimulatePointer(TRawEvent::EButton1Up,15,15); + iEventTestGroup3->GroupWin()->SetName(WindowGroup2); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(15-EWinPositionX,15-EWinPositionY)); + AddExpectedEvent(EEventWindowGroupsChanged); + break; + case 10: + SimulatePointer(TRawEvent::EButton2Down,25,20); + iEventTestGroup3->GroupWin()->SetName(WindowGroup2); + SimulatePointer(TRawEvent::EButton1Up,15,20); + iEventTestGroup3->GroupWin()->SetName(WindowGroup1); + AddExpectedPointer(TPointerEvent::EButton2Down, TPoint(25-EWinPositionX,20-EWinPositionY)); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(15-EWinPositionX,20-EWinPositionY)); + AddExpectedEvent(EEventWindowGroupsChanged); + break; + case 11: + iEventTestGroup3->GroupWin()->SetName(WindowGroup1); + SimulatePointer(TRawEvent::EButton2Down,12,12); + iEventTestGroup3->GroupWin()->SetName(WindowGroup2); + SimulatePointer(TRawEvent::EButton1Up,12,12); + AddExpectedPointer(TPointerEvent::EButton2Down, TPoint(12-EWinPositionX,12-EWinPositionY)); + AddExpectedEvent(EEventWindowGroupsChanged); + AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(12-EWinPositionX,12-EWinPositionY)); + break; + case 12: + delete iEventTestGroup3; + iEventTestGroup3=NULL; + AddExpectedEvent(EEventWindowGroupsChanged); + AddExpectedEvent(EEventWindowGroupListChanged); + break; + case 13: + delete iEventTestGroup4; + iEventTestGroup4=NULL; + AddExpectedEvent(EEventWindowGroupsChanged); + AddExpectedEvent(EEventWindowGroupListChanged); + break; + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +TInt CTEventTest::KeyRepeatTime() const + { + TTimeIntervalMicroSeconds32 initialTime; + TTimeIntervalMicroSeconds32 time; + TheClient->iWs.GetKeyboardRepeatRate(initialTime,time); + return(initialTime.Int()); + } + +void CTEventTest::RepeatableKeysL() + { + // repeatable key event + TKeyEvent repKeyEvent; + repKeyEvent.iCode='J'; + repKeyEvent.iScanCode=0; + repKeyEvent.iModifiers=EModifierAutorepeatable; + repKeyEvent.iRepeats=0; + + // non-repeatable key event + TKeyEvent keyEvent; + keyEvent.iCode='J'; + keyEvent.iScanCode=0; + keyEvent.iModifiers=0; + keyEvent.iRepeats=0; + + switch(iEventSet++) + { + case 0: + { + TheClient->iWs.SimulateKeyEvent(repKeyEvent); // Create a repeatable key event + TheClient->iWs.SimulateKeyEvent(repKeyEvent); // Create a repeatable key event + TheClient->iWs.SimulateKeyEvent(keyEvent); // Create a non-repeatable key event + TheClient->iWs.Flush(); // Send events + AddExpectedEvent(EEventFocusGained); // Always get a focus gain at start + AddExpectedKey(1, repKeyEvent.iScanCode, repKeyEvent.iCode, repKeyEvent.iRepeats, repKeyEvent.iModifiers);// Expect the event that was created above + AddExpectedKey(1, repKeyEvent.iScanCode, repKeyEvent.iCode, repKeyEvent.iRepeats, repKeyEvent.iModifiers);// Expect the event that was created above + AddExpectedKey(1, keyEvent.iScanCode, keyEvent.iCode, keyEvent.iRepeats, keyEvent.iModifiers);// Expect the event that was created above + break; + } + case 1: + { + TheClient->iWs.SimulateKeyEvent(repKeyEvent); // Create a repeatable key event + TheClient->iWs.SimulateKeyEvent(keyEvent); // Create a non-repeatable key event + TheClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown, 'A'); // Create a raw event + TheClient->iWs.Flush(); + User::After(KeyRepeatTime()*3/2); + iTest->SimulateKey(TRawEvent::EKeyUp, 'A'); // Create a raw event + TheClient->iWs.Flush(); + AddExpectedKey(1, repKeyEvent.iScanCode, repKeyEvent.iCode, repKeyEvent.iRepeats, repKeyEvent.iModifiers);// Expect the event that was created above + AddExpectedKey(1, keyEvent.iScanCode, keyEvent.iCode, keyEvent.iRepeats, keyEvent.iModifiers);// Expect the event that was created above + AddExpectedKey(EEventKeyDown, 'A'); + AddExpectedKey(EEventKey,'A','a'); + AddExpectedKey(EEventKey,'A','a',1); + AddExpectedKey(EEventKeyUp, 'A'); + break; + } + case 2: + { + iTest->SimulateKey(TRawEvent::EKeyDown, 'A'); // Create a raw event + TheClient->iWs.Flush(); + User::After(KeyRepeatTime()*3/2); + TheClient->iWs.SimulateKeyEvent(repKeyEvent); // Create a repeatable key event + TheClient->iWs.SimulateKeyEvent(keyEvent); // Create a non-repeatable key event + TheClient->iWs.Flush(); // Send event + iTest->SimulateKey(TRawEvent::EKeyUp, 'A'); // Create a raw event + TheClient->iWs.Flush(); + AddExpectedKey(EEventKeyDown, 'A'); + AddExpectedKey(EEventKey,'A','a'); + AddExpectedKey(EEventKey,'A','a',1); + AddExpectedKey(1, repKeyEvent.iScanCode, repKeyEvent.iCode, repKeyEvent.iRepeats, repKeyEvent.iModifiers);// Expect the event that was created above + AddExpectedKey(1, keyEvent.iScanCode, keyEvent.iCode, keyEvent.iRepeats, keyEvent.iModifiers);// Expect the event that was created above + AddExpectedKey(EEventKeyUp, 'A'); + break; + } + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +CTBlankWindow* CTEventTest::NewBlueForgroundWindowL() + { + CTBlankWindow* window; + window=new (ELeave) CTBlankWindow; + CleanupStack::PushL(window); + window->ConstructL(*iQueueClient->iGroup); + User::LeaveIfError(window->BaseWin()->SetRequiredDisplayMode(EColor256)); + CleanupStack::Pop(window); + + window->SetColor(KRgbBlue); + window->SetExt(TPoint(40, 40), TSize(40,40)); + window->BaseWin()->SetOrdinalPosition(0); + return window; + } + +CTBlankWindow* CTEventTest::NewBlueForgroundWindow() + { + CTBlankWindow* window = NULL; + TRAPD(err, window=NewBlueForgroundWindowL()); + if (err != KErrNone) + Failed(); + return window; + } + +#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS +#ifndef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA +static void CreateSurfaceAttributes(RSurfaceManager::TSurfaceCreationAttributesBuf& aBuffer , const TSize& aSize) + { + RSurfaceManager::TSurfaceCreationAttributes& b = aBuffer(); + + b.iSize.iWidth = aSize.iWidth; + b.iSize.iHeight = aSize.iHeight; + b.iBuffers = 1; // number of buffers in the surface + b.iPixelFormat = EUidPixelFormatARGB_8888; + b.iStride = aSize.iWidth * 4; // Number of bytes between start of one line and start of next + b.iOffsetToFirstBuffer = 0; // way of reserving space before the surface pixel data + b.iAlignment = 4; // alignment, 1,2,4,8 byte aligned + b.iContiguous = EFalse; + b.iMappable = ETrue; + } + +static const TInt KFullyVisible = TWsVisibilityChangedEvent::EPartiallyVisible | TWsVisibilityChangedEvent::EFullyVisible; + +void CTEventTest::SurfaceVisibilityChanged1_NextSetOfEventsL() + { + switch(iEventSet++) + { + case 0: + { + //Setup + LOG_MESSAGE(_L("case 0")); + TInt err = iSurfaceManager.Open(); + if (err != KErrNone) + { + RDebug::Printf("RSurfaceManager::Open() failed", err); + User::Leave(err); + } + + iVisWins1=NewBlueForgroundWindowL(); + iVisWins1->Activate(); + iVisWins1->BaseWin()->EnableVisibilityChangeEvents(); + + AddExpectedEvent(EEventFocusGained); + AddExpectedVisibilityChange(KFullyVisible, iVisWins1); + break; + } + case 1: + { + LOG_MESSAGE(_L("case 1")); + iVisWins2=NewBlueForgroundWindowL(); // will cover iVisWins1 + iVisWins2->BlankWin()->SetColor(); //remove colour to ensure window does not draw to UI layer + iVisWins2->Activate(); + + AddExpectedVisibilityChange(TWsVisibilityChangedEvent::ENotVisible, iVisWins1); + break; + } + case 2: + { + // This case contains the actual test GRAPHICS-WSERV-2669-0015 + LOG_MESSAGE(_L("case 2")); + RSurfaceManager::TSurfaceCreationAttributesBuf surfaceBuf; + CreateSurfaceAttributes(surfaceBuf, iVisWins2->BaseWin()->Size()); + + iSurfaceId = TSurfaceId::CreateNullId(); + TInt err = iSurfaceManager.CreateSurface(surfaceBuf, iSurfaceId); + if (err != KErrNone) + { + RDebug::Printf("RSurfaceManager::CreateSurface() error: %d", err); + TEST(EFalse); + } + + err = iVisWins2->BaseWin()->SetBackgroundSurface(iSurfaceId); + if (err != KErrNone) + { + RDebug::Printf("RWindow::SetBackgroundSurface() error: %d", err); + TEST(EFalse); + } + + iVisWins2->BaseWin()->SetSurfaceTransparency(ETrue); //iVisWins1 will become visible + + AddExpectedVisibilityChange(KFullyVisible, iVisWins1); + break; + } + default: + LOG_MESSAGE(_L("default")); + if (!iSurfaceId.IsNull()) + { + iSurfaceManager.CloseSurface(iSurfaceId); + iSurfaceId = TSurfaceId::CreateNullId(); + } + iSurfaceManager.Close(); + delete iVisWins1; + iVisWins1 = NULL; + delete iVisWins2; + iVisWins2 = NULL; + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +void CTEventTest::SurfaceVisibilityChanged2_NextSetOfEventsL() + { + switch (iEventSet++) + { + case 0: + { + //Win1 - bottom window + //Win2 - middle window with semi-transparent background surface, which totally obscures win1 + LOG_MESSAGE(_L("case 0")); + TInt err = iSurfaceManager.Open(); + if (err != KErrNone) + { + RDebug::Printf("RSurfaceManager::Open() failed", err); + User::Leave(err); + } + + iVisWins1 = NewBlueForgroundWindowL(); + iVisWins1->BaseWin()->EnableVisibilityChangeEvents(); + + iVisWins2 = NewBlueForgroundWindowL(); + iVisWins2->BlankWin()->SetColor(); //remove colour to ensure window does not draw to UI layer + iVisWins2->BaseWin()->EnableVisibilityChangeEvents(); + + iVisWins1->Activate(); //obscured + iVisWins2->Activate(); //visible + + // Create surface for background window + RSurfaceManager::TSurfaceCreationAttributesBuf surfaceBuf; + CreateSurfaceAttributes(surfaceBuf, iVisWins2->BaseWin()->Size()); + + iSurfaceId = TSurfaceId::CreateNullId(); + err = iSurfaceManager.CreateSurface(surfaceBuf, iSurfaceId); + if (err != KErrNone) + { + RDebug::Printf("RSurfaceManager::CreateSurface() error: %d", err); + TEST(EFalse); + } + + err = iVisWins2->BaseWin()->SetBackgroundSurface(iSurfaceId); + if (err != KErrNone) + { + RDebug::Printf("RWindow::SetBackgroundSurface() error: %d", err); + TEST(EFalse); + } + + iVisWins2->BaseWin()->SetSurfaceTransparency(ETrue); //win1 and win2 both visible + + AddExpectedEvent(EEventFocusGained); + AddExpectedVisibilityChange(KFullyVisible, iVisWins2); + AddExpectedVisibilityChange(KFullyVisible, iVisWins1); + break; + } + case 1: + { + //Win3 - opaque top window which obscures win2 and win1 + LOG_MESSAGE(_L("case 1")); + iVisWins3 = NewBlueForgroundWindowL(); + iVisWins3->SetColor(KRgbRed); + iVisWins3->Activate(); + + AddExpectedVisibilityChange(TWsVisibilityChangedEvent::ENotVisible, iVisWins2); + AddExpectedVisibilityChange(TWsVisibilityChangedEvent::ENotVisible, iVisWins1); + break; + } + case 2: + { + //This case contains the actual test GRAPHICS-WSERV-2669-0016 + LOG_MESSAGE(_L("case 2")); + delete iVisWins3; + iVisWins3 = NULL; + + AddExpectedVisibilityChange(KFullyVisible, iVisWins2); + AddExpectedVisibilityChange(KFullyVisible, iVisWins1); + break; + } + default: + LOG_MESSAGE(_L("default")); + if (!iSurfaceId.IsNull()) + { + iSurfaceManager.CloseSurface(iSurfaceId); + iSurfaceId = TSurfaceId::CreateNullId(); + } + iSurfaceManager.Close(); + delete iVisWins1; + iVisWins1 = NULL; + delete iVisWins2; + iVisWins2 = NULL; + delete iVisWins3; + iVisWins3 = NULL; + CActiveScheduler::Stop(); + return; + } + TheClient->iWs.Flush(); + } + +TInt CTEventTest::GenerateAnEvent(TAny* aEventTest) + { + CTEventTest* self = static_cast(aEventTest); + self->LogMessage(((TText8*)__FILE__), __LINE__,_L("Negative test passed OK - no event was generated.")); + //Now we must generate an event to get CTQueueTestEvent out of its wait loop + self->SimulateRepeatEvent(32); + self->AddExpectedKey(EEventKey, 32); + return KErrNone; + } + +void CTEventTest::SurfaceVisibilityChanged3_NextSetOfEventsL() + { + switch (iEventSet++) + { + case 0: + { + //Win1 - Bottom window + //Win2 - Top window with semi-transparent background surface. Does not overlap win1. + LOG_MESSAGE(_L("case 0")); + TInt err = iSurfaceManager.Open(); + if (err != KErrNone) + { + RDebug::Printf("RSurfaceManager::Open() failed", err); + User::Leave(err); + } + iTimeOutCallback = CPeriodic::NewL(CActive::EPriorityIdle); + + iVisWins1 = NewBlueForgroundWindowL(); + iVisWins1->BaseWin()->EnableVisibilityChangeEvents(); + + iVisWins2 = NewBlueForgroundWindowL(); + iVisWins2->BlankWin()->SetColor(); //remove colour to ensure window does not draw to UI layer + TPoint newPos(iVisWins1->Position() + iVisWins1->Size()); + iVisWins2->SetPos(newPos); //to not overlap win1 + + iVisWins1->Activate(); //upper left + iVisWins2->Activate(); //lower right + + // Create surface for background window + RSurfaceManager::TSurfaceCreationAttributesBuf surfaceBuf; + CreateSurfaceAttributes(surfaceBuf, iVisWins2->BaseWin()->Size()); + + iSurfaceId = TSurfaceId::CreateNullId(); + err = iSurfaceManager.CreateSurface(surfaceBuf, iSurfaceId); + if (err != KErrNone) + { + RDebug::Printf("RSurfaceManager::CreateSurface() error: %d", err); + TEST(EFalse); + } + + err = iVisWins2->BaseWin()->SetBackgroundSurface(iSurfaceId); + if (err != KErrNone) + { + RDebug::Printf("RWindow::SetBackgroundSurface() error: %d", err); + TEST(EFalse); + } + + iVisWins2->BaseWin()->SetSurfaceTransparency(ETrue); + + AddExpectedEvent(EEventFocusGained); + AddExpectedVisibilityChange(KFullyVisible, iVisWins1); + break; + } + case 1: + { + //This case contains the actual test GRAPHICS-WSERV-2669-0017 + LOG_MESSAGE(_L("case 1")); + iVisWins2->SetPos(iVisWins1->Position()); //Win2 now overlaps Win1, but because Win2 has + //a transparent surface Win1 is still fully visible + + //Because we don't expect any events we need to generate one to avoid waiting forever. + TCallBack timeout(GenerateAnEvent, this); + iTimeOutCallback->Start(1000000, 10000000, timeout); + break; + } + default: + LOG_MESSAGE(_L("default")); + iTimeOutCallback->Cancel(); + delete iTimeOutCallback; + iTimeOutCallback = NULL; + if (!iSurfaceId.IsNull()) + { + iSurfaceManager.CloseSurface(iSurfaceId); + iSurfaceId = TSurfaceId::CreateNullId(); + } + iSurfaceManager.Close(); + delete iVisWins1; + iVisWins1 = NULL; + delete iVisWins2; + iVisWins2 = NULL; + CActiveScheduler::Stop(); + return; + } + TheClient->iWs.Flush(); + } +#endif //TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA +#endif //SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS + +void CTEventTest::VisibilityChanged_NextSetOfEventsL() + { + const TInt fullyVisible = TWsVisibilityChangedEvent::EPartiallyVisible | TWsVisibilityChangedEvent::EFullyVisible; + + switch(iEventSet++) + { + case 0: //only this case can leave + { + iQueueClient->iWin->BackedUpWin()->MaintainBackup(); + iVisWins1=NewBlueForgroundWindowL(); + iVisWins2=NewBlueForgroundWindowL(); + + iVisWins1->BaseWin()->EnableVisibilityChangeEvents(); + iVisWins1->Activate(); + iVisWins2->SetColor(KRgbGreen); + iVisWins2->SetExt(TPoint(80, 80), TSize(120,120)); + iVisWins2->Activate(); + + AddExpectedEvent(EEventFocusGained); + AddExpectedVisibilityChange(fullyVisible); + } + break; + case 1: + iVisWins1->BaseWin()->SetVisible(EFalse); + AddExpectedVisibilityChange(TWsVisibilityChangedEvent::ENotVisible); + break; + case 2: + iVisWins1->BaseWin()->SetVisible(ETrue); + AddExpectedVisibilityChange(fullyVisible); + break; + case 3: + iVisWins2->SetExt(TPoint(0,0), TSize(120,120)); + AddExpectedVisibilityChange(TWsVisibilityChangedEvent::ENotVisible); + break; + case 4: + iVisWins2->BaseWin()->SetVisible(EFalse); + AddExpectedVisibilityChange(fullyVisible); + break; + case 5: + iVisWins2->BaseWin()->SetVisible(ETrue); + AddExpectedVisibilityChange(TWsVisibilityChangedEvent::ENotVisible); + break; + case 6: + iVisWins2->SetExt(TPoint(60,60), TSize(120,120)); + AddExpectedVisibilityChange(TWsVisibilityChangedEvent::EPartiallyVisible); + break; + case 7: + iVisWins1->SetExt(TPoint(80,80), TSize(40,40)); + AddExpectedVisibilityChange(TWsVisibilityChangedEvent::ENotVisible); + break; + case 8: + iVisWins1->BaseWin()->SetOrdinalPosition(0); + AddExpectedVisibilityChange(fullyVisible); + + if(TransparencySupportedL() != KErrNone) + { + iEventSet += 2; //we shall skip set 9,10 as they work with transparency + } + break; + case 9: + { + TDisplayMode mode = EColor256; + iTransWin=CTransWindow::NewL(iQueueClient->iGroup, TRgb(255, 0, 0, 128), TRect(0,0,200,200), &mode); + iTransWin->CTWin::DrawNow(); + // it gets put at ordinal position 0 + iVisWins2->BaseWin()->SetOrdinalPosition(1); + AddExpectedVisibilityChange(TWsVisibilityChangedEvent::ENotVisible); + } + break; + case 10: + iVisWins1->BaseWin()->SetOrdinalPosition(1); + AddExpectedVisibilityChange(fullyVisible); + break; + case 11: + { + delete iVisWins1; + iVisWins1=NULL; + iVisWins1=NewBlueForgroundWindow(); + + iVisWins1->Activate(); + iVisWins1->BaseWin()->EnableVisibilityChangeEvents(); + + AddExpectedVisibilityChange(fullyVisible); + } + break; + case 12: + { + delete iVisWins1; + iVisWins1=NULL; + iVisWins1=NewBlueForgroundWindow(); + + iVisWins1->Activate(); + iVisWins1->BaseWin()->EnableVisibilityChangeEvents(); + iVisWins1->BaseWin()->SetVisible(EFalse); + + AddExpectedVisibilityChange(TWsVisibilityChangedEvent::ENotVisible); + } + break; + case 13: + { + delete iVisWins1; + iVisWins1=NULL; + iVisWins1=NewBlueForgroundWindow(); + + iVisWins1->BaseWin()->EnableVisibilityChangeEvents(); + iVisWins1->Activate(); + + AddExpectedVisibilityChange(fullyVisible); + } + break; + case 14: + { + delete iVisWins1; + iVisWins1=NULL; + iVisWins1=NewBlueForgroundWindow(); + + iVisWins1->Activate(); + iVisWins1->BaseWin()->SetVisible(EFalse); + iVisWins1->BaseWin()->EnableVisibilityChangeEvents(); + + AddExpectedVisibilityChange(TWsVisibilityChangedEvent::ENotVisible); + } + break; + default: + delete iVisWins1; + delete iVisWins2; + iVisWins1 = NULL; + iVisWins2 = NULL; + delete iTransWin; + iTransWin = NULL; + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +void CTEventTest::CheckTimeStamp_NextSetOfEventsL() + { + iQueueClient->EventQueue()->SetCheckTimeStamp(ETrue); + switch(iEventSet++) + { + case 0: + iTest->SimulateKey(TRawEvent::EKeyDown, 'A'); // Create a raw event + iTest->SimulateKey(TRawEvent::EKeyUp, 'A'); // Create a raw event + AddExpectedEvent(EEventFocusGained); + AddExpectedKey(EEventKeyDown,'A'); + AddExpectedKey(EEventKey,'A','a'); + AddExpectedKey(EEventKeyUp,'A','a'); + break; + case 1: + { + _LIT8(KMsgParam,"CheckTimeStamp"); + TBuf8<0x20> params(KMsgParam); + TInt err = TheClient->iWs.SendMessageToWindowGroup(iQueueClient->WindowGroupIdentifier(),TUid::Uid(123),params); + AddExpectedEvent(EEventMessageReady); + } + break; + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +/** + * @SYMTestCaseID GRAPHICS-WSERV-0001 + * + * @SYMPREQ PREQ525 + * + * @SYMTestCaseDesc Test Capture priority of different top most windows in a Group. + * + * @SYMTestPriority Critical + * + * @SYMTestStatus Implemented + * + * @SYMTestActions Create two different top client windows under one parent window + * in a same window group. Add pointer event by clicking various position on the + * window and Simulate the pointer event. Change the pointer capture flag, capture + * priority and simulate the pointer event. + * + * @SYMTestExpectedResults In general the expected event and the window server event should + * match same event handle, type and pointer position for following cases. + * When pointer capture is disabled and capture priorities are 0, the pointer position on window1 + * window2 or parent window are same as expected. + * When pointer capture is enabled and capture priorities are 0, the pointer position on window2(which is top most now) + * is same as expected. + * When pointer capture is enabled and capture priorities of win1 is greater than win2 + * the pointer position on win1 and win2 are same as expected. + * The combination of above cases should match the general expexted result. + * + */ +void CTEventTest::PointerCapture_NextSetOfEventsL() + { +#if defined(LOGGING) + TLogMessageText logMessageText; + _LIT(KSet,"Pointer Capture SetOfEvents: %d (last=9)"); + logMessageText.Format(KSet,iEventSet); + INFO_PRINTF1(logMessageText); +#endif + switch(iEventSet++) + { + case 0: //Create two top client windows of same group + iVisWins1=new (ELeave) CTBlankWindow; + iVisWins2=new (ELeave) CTBlankWindow; + iVisWins1->ConstructL(*iQueueClient->iGroup); + iVisWins2->ConstructL(*iQueueClient->iGroup); + iVisWins1->SetColor(KRgbBlue); + iVisWins1->SetExt(iQueueClient->ChildTopLeft(),iQueueClient->ChildSize()); + iVisWins1->Activate(); + iVisWins2->SetColor(KRgbGreen); + iVisWins2->SetExt(iQueueClient->ChildTopLeft()+TPoint(15,15),iQueueClient->ChildSize()); + iVisWins2->Activate(); + iQueueClient->iWs.Flush(); + AddExpectedEvent(EEventFocusGained); + break; + case 1: //Pointer capture are disabled and priorities are 0 + iVisWins1->BaseWin()->SetPointerCapture(RWindowBase::TCaptureDisabled); + iVisWins1->BaseWin()->SetPointerCapturePriority(0); + iVisWins2->BaseWin()->SetPointerCapture(RWindowBase::TCaptureDisabled); + iVisWins2->BaseWin()->SetPointerCapturePriority(0); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(35,25)); //Pointer on the first window + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(35,25)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(50,30)); //Pointer on the second window(overlaping on first window) + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(60,50)); //Pointer on the second window + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(75,25)); //Pointer on the parent window + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(75,25)); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,35,25); + SimulatePointer(TRawEvent::EButton1Up,35,25); + SimulatePointer(TRawEvent::EButton1Down,50,30); + SimulatePointer(TRawEvent::EButton1Up,50,30); + SimulatePointer(TRawEvent::EButton1Down,60,50); + SimulatePointer(TRawEvent::EButton1Up,60,50); + SimulatePointer(TRawEvent::EButton1Down,75,25); + SimulatePointer(TRawEvent::EButton1Up,75,25); + break; + case 2: //Pointer capture are enabled and priorities are 0 + iVisWins1->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iVisWins2->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iVisWins1->BaseWin()->SetPointerCapturePriority(0); + iVisWins2->BaseWin()->SetPointerCapturePriority(0); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(35,25),(TInt)iVisWins2); //Pointer on the first window + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(35,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(50,30)); //Pointer on the second window(overlaping on first window) + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(60,50)); //Pointer on the second window + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(75,25),(TInt)iVisWins2); //Pointer on the parent window + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(75,25),(TInt)iVisWins2); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,35,25); + SimulatePointer(TRawEvent::EButton1Up,35,25); + SimulatePointer(TRawEvent::EButton1Down,50,30); + SimulatePointer(TRawEvent::EButton1Up,50,30); + SimulatePointer(TRawEvent::EButton1Down,60,50); + SimulatePointer(TRawEvent::EButton1Up,60,50); + SimulatePointer(TRawEvent::EButton1Down,75,25); + SimulatePointer(TRawEvent::EButton1Up,75,25); + break; + case 3: //Pointer capture are enabled and priorities of win1 is higher than win2 + iVisWins1->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iVisWins2->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iVisWins1->BaseWin()->SetPointerCapturePriority(1); + iVisWins2->BaseWin()->SetPointerCapturePriority(0); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(35,25)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(35,25)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(75,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(75,25),(TInt)iVisWins2); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,35,25); + SimulatePointer(TRawEvent::EButton1Up,35,25); + SimulatePointer(TRawEvent::EButton1Down,50,30); + SimulatePointer(TRawEvent::EButton1Up,50,30); + SimulatePointer(TRawEvent::EButton1Down,60,50); + SimulatePointer(TRawEvent::EButton1Up,60,50); + SimulatePointer(TRawEvent::EButton1Down,75,25); + SimulatePointer(TRawEvent::EButton1Up,75,25); + break; + case 4: //Pointer capture are enabled and priorities of win1 is equal to win2 + iVisWins1->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iVisWins2->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iVisWins1->BaseWin()->SetPointerCapturePriority(1); + iVisWins2->BaseWin()->SetPointerCapturePriority(1); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(35,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(35,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(75,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(75,25),(TInt)iVisWins2); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,35,25); + SimulatePointer(TRawEvent::EButton1Up,35,25); + SimulatePointer(TRawEvent::EButton1Down,50,30); + SimulatePointer(TRawEvent::EButton1Up,50,30); + SimulatePointer(TRawEvent::EButton1Down,60,50); + SimulatePointer(TRawEvent::EButton1Up,60,50); + SimulatePointer(TRawEvent::EButton1Down,75,25); + SimulatePointer(TRawEvent::EButton1Up,75,25); + break; + case 5: //Pointer capture are enabled and priorities of win2 is higher than win1 + iVisWins1->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iVisWins2->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iVisWins1->BaseWin()->SetPointerCapturePriority(0); + iVisWins2->BaseWin()->SetPointerCapturePriority(1); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(35,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(35,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(75,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(75,25),(TInt)iVisWins2); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,35,25); + SimulatePointer(TRawEvent::EButton1Up,35,25); + SimulatePointer(TRawEvent::EButton1Down,50,30); + SimulatePointer(TRawEvent::EButton1Up,50,30); + SimulatePointer(TRawEvent::EButton1Down,60,50); + SimulatePointer(TRawEvent::EButton1Up,60,50); + SimulatePointer(TRawEvent::EButton1Down,75,25); + SimulatePointer(TRawEvent::EButton1Up,75,25); + break; + case 6: //Pointer capture are enabled for all groups and priorities of win1 is higher than win2 + iVisWins1->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled|RWindowBase::TCaptureFlagAllGroups); + iVisWins2->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled|RWindowBase::TCaptureFlagAllGroups); + iVisWins1->BaseWin()->SetPointerCapturePriority(1); + iVisWins2->BaseWin()->SetPointerCapturePriority(0); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(35,25)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(35,25)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(75,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(75,25),(TInt)iVisWins2); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,35,25); + SimulatePointer(TRawEvent::EButton1Up,35,25); + SimulatePointer(TRawEvent::EButton1Down,50,30); + SimulatePointer(TRawEvent::EButton1Up,50,30); + SimulatePointer(TRawEvent::EButton1Down,60,50); + SimulatePointer(TRawEvent::EButton1Up,60,50); + SimulatePointer(TRawEvent::EButton1Down,75,25); + SimulatePointer(TRawEvent::EButton1Up,75,25); + break; + case 7: //Pointer capture are enabled and priorities of iWin is higher than the other windows + iVisWins1->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iVisWins2->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iVisWins1->BaseWin()->SetPointerCapturePriority(0); + iVisWins2->BaseWin()->SetPointerCapturePriority(0); + iQueueClient->iWin->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iQueueClient->iWin->BaseWin()->SetPointerCapturePriority(1); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(80,20)); //Pointer on the parent window + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(80,20)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(35,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(35,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(75,25)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(75,25)); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,80,20); + SimulatePointer(TRawEvent::EButton1Up,80,20); + SimulatePointer(TRawEvent::EButton1Down,35,25); + SimulatePointer(TRawEvent::EButton1Up,35,25); + SimulatePointer(TRawEvent::EButton1Down,60,50); + SimulatePointer(TRawEvent::EButton1Up,60,50); + SimulatePointer(TRawEvent::EButton1Down,50,30); + SimulatePointer(TRawEvent::EButton1Up,50,30); + SimulatePointer(TRawEvent::EButton1Down,75,25); + SimulatePointer(TRawEvent::EButton1Up,75,25); + break; + case 8: //Pointer capture are enabled and priorities of iWin is 0 + iVisWins1->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iVisWins2->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iVisWins1->BaseWin()->SetPointerCapturePriority(1); + iVisWins2->BaseWin()->SetPointerCapturePriority(0); + iQueueClient->iWin->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled); + iQueueClient->iWin->BaseWin()->SetPointerCapturePriority(0); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(80,20),(TInt)iVisWins2); //Pointer on the parent window + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(80,20),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(35,25)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(35,25)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(75,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(75,25),(TInt)iVisWins2); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,80,20); + SimulatePointer(TRawEvent::EButton1Up,80,20); + SimulatePointer(TRawEvent::EButton1Down,35,25); + SimulatePointer(TRawEvent::EButton1Up,35,25); + SimulatePointer(TRawEvent::EButton1Down,60,50); + SimulatePointer(TRawEvent::EButton1Up,60,50); + SimulatePointer(TRawEvent::EButton1Down,50,30); + SimulatePointer(TRawEvent::EButton1Up,50,30); + SimulatePointer(TRawEvent::EButton1Down,75,25); + SimulatePointer(TRawEvent::EButton1Up,75,25); + break; + case 9: //Pointer capture are enabled and with different groups + iVisWins1->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled|RWindowBase::TCaptureFlagAllGroups); + iVisWins2->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled|RWindowBase::TCaptureFlagAllGroups); + iVisWins1->BaseWin()->SetPointerCapturePriority(0); + iVisWins2->BaseWin()->SetPointerCapturePriority(0); + iQueueClient->iWin->BaseWin()->SetPointerCapture(RWindowBase::TCaptureEnabled|RWindowBase::TCaptureFlagAllGroups); + iQueueClient->iWin->BaseWin()->SetPointerCapturePriority(1); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(25,150),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(25,150),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(150,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(150,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(80,20)); //Pointer on the parent window + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(80,20)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(35,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(35,25),(TInt)iVisWins2); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(60,50)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(50,30)); + AddExpectedPointerCapture(TPointerEvent::EButton1Down,TPoint(75,25)); + AddExpectedPointerCapture(TPointerEvent::EButton1Up,TPoint(75,25)); + iQueueClient->iWs.Flush(); + SimulatePointer(TRawEvent::EButton1Down,25,150); + SimulatePointer(TRawEvent::EButton1Up,25,150); + SimulatePointer(TRawEvent::EButton1Down,150,25); + SimulatePointer(TRawEvent::EButton1Up,150,25); + SimulatePointer(TRawEvent::EButton1Down,80,20); + SimulatePointer(TRawEvent::EButton1Up,80,20); + SimulatePointer(TRawEvent::EButton1Down,35,25); + SimulatePointer(TRawEvent::EButton1Up,35,25); + SimulatePointer(TRawEvent::EButton1Down,60,50); + SimulatePointer(TRawEvent::EButton1Up,60,50); + SimulatePointer(TRawEvent::EButton1Down,50,30); + SimulatePointer(TRawEvent::EButton1Up,50,30); + SimulatePointer(TRawEvent::EButton1Down,75,25); + SimulatePointer(TRawEvent::EButton1Up,75,25); + break; + default: + delete iVisWins1; + delete iVisWins2; + iVisWins1=NULL; + iVisWins2=NULL; + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +/** +PDEF110849 +Allocate a pointer buffer, send it some events and then disconnect. +Now fill the event queue, causing a purge. +The purge will call void CWsPointerBuffer::DiscardPointerMoveBuffer(TUint aHandle) +in which an access violation occurred because iCurrentBuffer had not been set to NULL. +*/ +void CTEventTest::PointerBufferPurge_NextSetOfEventsL() + { +#if defined(LOGGING) + TLogMessageText logMessageText; + _LIT(KSet,"PointerBufferPurge SetOfEvents: %d of 1"); + logMessageText.Format(KSet,iEventSet); + TheClient->LogMessage(logMessageText); +#endif + iTheClientFlush=TheClient->iWs.SetAutoFlush(ETrue); + iQuequeClientFlush=iQueueClient->iWs.SetAutoFlush(ETrue); + switch(iEventSet++) + { + case 0: + { + RWindowBase& win = *iQueueClient->iWin->BaseWin(); + + // Cause a connect to happen + RDebug::Print(_L("PointerBufferPurge - AllocPointerMoveBuffer()")); + win.AllocPointerMoveBuffer(10, 0); + + // Allow pen events to be received + RDebug::Print(_L("PointerBufferPurge - EnablePointerMoveBuffer()")); + win.EnablePointerMoveBuffer(); + + // Simulate some pen events + RDebug::Print(_L("PointerBufferPurge - Events")); + SimulatePointer(TRawEvent::EPointerMove,10,20); + SimulatePointer(TRawEvent::EButton1Down,10,20); + SimulatePointer(TRawEvent::EPointerMove,11,21); + SimulatePointer(TRawEvent::EButton1Up,11,21); + + // Disconnect + RDebug::Print(_L("PointerBufferPurge - FreePointerMoveBuffer()")); + win.FreePointerMoveBuffer(); + + // Send sufficient events to cause a purge to happen + for (TInt i=0; iiWs.SetAutoFlush(iTheClientFlush); + iQueueClient->iWs.SetAutoFlush(iQuequeClientFlush); + } + +/** + * @SYMTestCaseID GRAPHICS-WSERV-0025 + * + * @SYMDEF DEF085009 + * + * @SYMTestCaseDesc Test removal of event handlers mid-way through processing an event. + * + * @SYMTestPriority Critical + * + * @SYMTestStatus Implemented + * + * @SYMTestActions The following tests use RRemovable anim to replicate the removal of + * event handlers mid-way through processing an event (where an event is offered to each of the + * listed event handlers). + * + * RRemovableAnim is an anim which removes itself from the event handler list + * after receiving n events, where n is the 'lifetime' of the anim measured in events received. + * By setting the lifetimes of a number of these anims, we replicate the removal of event handlers + * mid-way through processing an event. + * + * Event set 0: + * Sends 2 events e1,e2 and expects them be received by wserv event processing. + * + * Event set 1: (Simple scenario) + * Adds 3 removable anims to event handler list + * Sets lifetimes as {1000,2,5} + * Sends 6 events + * Expected events to be received by anims: {6,2,5} + * + * Event set 2: (Manual removal and reset state) + * Manually remove all anims from event handler list + * Sends 2 events + * No events expected to be received by anims + * Resets all anims ready for next test + * + * Event set 3: (Removal of multiple anims on receipt of same event) + * Adds 10 removable anims in event handler list + * Set lifetimes: {1,5,9,3,8,8,8,10,5,2} + * Sends 12 events: + * Expected number of received events for anims: {1,5,9,3,8,8,8,10,5,2} + * + * Event set 4: (Manual removal and reset state) + * Manually remove all anims from event handler list + * Sends 2 events + * No events expected to be received by anims + * Resets all anims ready for next test + * + * Event set 5: (Addition of anims to non-empty event handler list, part 1) + * Adds 6 removable anims in the event handler list + * Set lifetimes: {1,1,1,5,5,5} + * Sends 2 events: + * Expected number of received events for anims: {1,1,1,2,2,2} + * + * Event set 6: (Addition of anims to non-empty event handler list, part 2) + * Readds first 3 anims to event handler list + * Sets lifetimes of these three anims {13,24,6} + * Sends 5 events: + * Expected number of received events for anims: {5,5,5,3,3,3} + * + * Event set 7: (Addition of anims to non-empty event handler list, part 3) + * Sends 16 events: + * Expected number of received events for anims: {8,16,1,0,0,0} + * + * Event set 8: (Manual Removal and reset state) + * Manually remove all anims from event handler list + * Sends 2 events + * No events expected to be received by anims + * Resets all anims ready for next test + * + * Event set 9: (Creating anims which again generate events.) + * Create 3 anims. One anims generates events in its OfferrawEvent function. + * Check the funtionality of ProcessRawEvent in Wserv when it is called + * recursively. Also check the fix for defect INC095892. + * + * @SYMTestExpectedResults + * All events should be received by wserv event processing + * Each anim should only receive events when (number of events received by anim) <= (lifetime of anim) + */ +void CTEventTest::EventHandlerRemoval_NextSetOfEventsL() + { +#if defined(LOGGING) + INFO_PRINTF1(_L("EventHandlerRemoval SetOfEvents: (Max=8)")); +#endif + switch(iEventSet++) + { + case 0: + #if defined(LOGGING) + INFO_PRINTF1(_L("AUTO Event Handler Removal Anim Events")); + #endif + #if defined(DETAILED) + INFO_PRINTF1(_L("No anims in event handler list")); + INFO_PRINTF1(_L(" Send 2 events")); + INFO_PRINTF1(_L(" - Expected to be received by wserv event processing")); + #endif + // Always get a focus gain at start + AddExpectedEvent(EEventFocusGained); + // All expected to be received by wserv event processing + AddExpectedKey(EEventKeyDown,32,ETrue); + AddExpectedKey(EEventKeyUp,32,ETrue); + // Send 2 events - none expected to be received by anims, + iTest->SimulateKey(TRawEvent::EKeyDown,32); + iTest->SimulateKey(TRawEvent::EKeyUp,32); + // Flush events to wserv + TheClient->iWs.Flush(); + // Create all anims for all tests in first event set because + // first event set is only place where leaving functions can be called + EventHandlerRemoval_CreateAnimsL(10); + break; + case 1: + { + #if defined(DETAILED) + INFO_PRINTF1(_L(" Add 3 removable anims to event handler list")); + INFO_PRINTF1(_L(" Set lifetimes for anims: {1000,2,5}")); + INFO_PRINTF1(_L(" Send 6 events")); + INFO_PRINTF1(_L(" - Expected number of received events for anims: {6,2,5}")); + INFO_PRINTF1(_L(" All events expected to be received by wserv event processing")); + #endif + const TInt KLifetimes [] = {1000,2,5}; + EventHandlerRemoval_PrepareAnims(KLifetimes, 3); + EventHandlerRemoval_CreateExpectedEvents(6,3); + // Flush events to wserv + TheClient->iWs.Flush(); + // Check each anim has received the expected events + EventHandlerRemoval_CheckExpectedEventsReceivedByAnims(); + } + break; + case 2: + { + // Remove all anims, check removal was successful + // and reset all anims ready for next test + EventHandlerRemoval_RemoveAndResetAllAnims(); + } + break; + case 3: + { + #if defined(DETAILED) + INFO_PRINTF1(_L(" Add 10 removable anims in event handler list")); + INFO_PRINTF1(_L(" Set lifetimes: {1,5,9,3,8,8,8,10,5,2}")); + INFO_PRINTF1(_L(" Send 12 events")); + INFO_PRINTF1(_L(" - Expected number of received events for anims:{1,5,9,3,8,8,8,10,5,2}")); + INFO_PRINTF1(_L(" All expected to be received by wserv event processing")); + #endif + const TInt KLifetimes [] = {1,5,9,3,8,8,8,10,5,2}; + + // Create anims, set lifetimes, add to event handlers and add to iRemovableAnims array + EventHandlerRemoval_PrepareAnims(KLifetimes, 10); + EventHandlerRemoval_CreateExpectedEvents(12,10); + // Flush events to wserv + TheClient->iWs.Flush(); + // Check each anim has received the expected events + EventHandlerRemoval_CheckExpectedEventsReceivedByAnims(); + } + break; + case 4: + { + // Remove all anims, check removal was successful + // and reset all anims ready for next test + EventHandlerRemoval_RemoveAndResetAllAnims(); + } + break; + case 5: + { + #if defined(DETAILED) + INFO_PRINTF1(_L(" Add 6 removable anims in event handler list")); + INFO_PRINTF1(_L(" Set lifetimes: {1,1,1,5,5,5}")); + INFO_PRINTF1(_L(" Send 2 events")); + INFO_PRINTF1(_L(" - Expected number of received events for anims:{1,1,1,2,2,2}")); + INFO_PRINTF1(_L(" All expected to be received by wserv event processing")); + #endif + const TInt KLifetimes [] = {1,1,1,5,5,5}; + + // Create anims, set lifetimes, add to event handlers and add to iRemovableAnims array + EventHandlerRemoval_PrepareAnims(KLifetimes, 6); + EventHandlerRemoval_CreateExpectedEvents(2, 6); + // Flush events to wserv + TheClient->iWs.Flush(); + // Check each anim has received the expected events + EventHandlerRemoval_CheckExpectedEventsReceivedByAnims(); + } + break; + case 6: + { + #if defined(DETAILED) + INFO_PRINTF1(_L(" Readds first 3 removable anims to event handler list")); + INFO_PRINTF1(_L(" Set lifetimes of these three anims {13,24,6}")); + INFO_PRINTF1(_L(" Send 5 events")); + INFO_PRINTF1(_L(" - Expected number of received events for anims: {5,5,5,3,3,3}")); + INFO_PRINTF1(_L(" All expected to be received by wserv event processing")); + #endif + const TInt KLifetimes [] = {13,24,6}; + + // Create anims, set lifetimes, add to event handlers and add to iRemovableAnims array + EventHandlerRemoval_PrepareAnims(KLifetimes, 3); + EventHandlerRemoval_CreateExpectedEvents(5, 6); + // Flush events to wserv + TheClient->iWs.Flush(); + // Check each anim has received the expected events + EventHandlerRemoval_CheckExpectedEventsReceivedByAnims(); + } + break; + case 7: + { + #if defined(DETAILED) + INFO_PRINTF1(_L(" Send 16 events")); + INFO_PRINTF1(_L(" - Expected number of received events for anims:{8,16,1,0,0,0}")); + INFO_PRINTF1(_L(" All expected to be received by wserv event processing")); + #endif + EventHandlerRemoval_CreateExpectedEvents(16, 3); + // Flush events to wserv + TheClient->iWs.Flush(); + // Check each anim has received the expected events + EventHandlerRemoval_CheckExpectedEventsReceivedByAnims(); + } + break; + case 8: + { + // Remove all anims, check removal was successful + // and reset all anims ready for next test + EventHandlerRemoval_RemoveAndResetAllAnims(); + } + break; + case 9: + EventHandlerRemoval_CheckRecursionOfProcessRawEvent(); + break; + case 10: + EventHandlerRemoval_AddEventHandlerMultipleTimes(); + break; + default: + #if defined(DETAILED) + INFO_PRINTF1(_L(" Test postamble")); + INFO_PRINTF1(_L(" Destroy anims")); + #endif + // Destroy anims + EventHandlerRemoval_DestroyAllAnims(); + iRemovableAnims->Close(); + delete iRemovableAnims; + iRemovableAnims = NULL; + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +/** + * Creates an array of aAnimCount anims on heap + * Assigns array to iRemovableAnims for use in rest of tests + */ +void CTEventTest::EventHandlerRemoval_CreateAnimsL(TInt aAnimCount) + { + RPointerArray* removableAnims = new (ELeave) RPointerArray(); + CleanupStack::PushL(removableAnims); + for (TInt animIndex = 0; animIndex < aAnimCount; animIndex++) + { + RRemovableAnim* anim = RRemovableAnim::NewLC(iQueueClient->iWin->BaseWin(), iAnimDll); + removableAnims->AppendL(anim); + } + CleanupStack::Pop(aAnimCount, (*removableAnims)[0]); + CleanupStack::Pop(removableAnims); + iRemovableAnims = removableAnims; + } + +/** + * Sets lifetimes of anims as specified in aLifeTimes + * Adds anims to event handler list + */ +void CTEventTest::EventHandlerRemoval_PrepareAnims(const TInt* aLifetimes, TInt aAnimCount) + { + for (TInt animIndex = 0; animIndex < aAnimCount; animIndex++) + { + RRemovableAnim* anim = (*iRemovableAnims)[animIndex]; + anim->SetEventHandlerLifetime(aLifetimes[animIndex]); + anim->AddToEventHandlers(); + } + } + +/** + * Creates aEventCount key events to be used in test + * Adds the expected event aEvent to the first aLiveAnimCount anims + * Adds expected events observed by the rest of wserv + * Simulates events on wserv + */ +void CTEventTest::EventHandlerRemoval_CreateExpectedEvents(TInt aEventCount, TInt aLiveAnimCount) + { + RArray events; + + // Add expected events to anims + for (TInt eventCount = 0; eventCount < aEventCount; eventCount++) + { + TRawEvent rawEvent; + TInt scanCode = 33 + eventCount; + // Alternate key down, key up events. + if (eventCount%2 == 0) + { + rawEvent.Set(TRawEvent::EKeyDown, scanCode); + } + else + { + rawEvent.Set(TRawEvent::EKeyUp, scanCode); + } + EventHandlerRemoval_AddExpectedEvent(rawEvent, aLiveAnimCount); + events.Append(rawEvent); + } + + // Simulates expected events + for (TInt eventCount = 0; eventCount < aEventCount; eventCount++) + { + TRawEvent event = events[eventCount]; + iTest->SimulateKey(event.Type(), event.ScanCode()); + } + + events.Close(); + } + +/** + * Adds the expected event aEvent to the first aLiveAnimCount anims + * Adds expected event observed by the rest of wserv + */ +void CTEventTest::EventHandlerRemoval_AddExpectedEvent(TRawEvent aEvent, TInt aLiveAnimCount) + { + // Add event to each of the anims + for (TInt animIndex = 0; animIndex < aLiveAnimCount; animIndex++) + { + TInt err = (*iRemovableAnims)[animIndex]->AddExpectedEvent(aEvent); + } + TInt eventType = (aEvent.Type() == TRawEvent::EKeyDown ? EEventKeyDown : EEventKeyUp); + AddExpectedKey(eventType, aEvent.ScanCode(), ETrue); + } + +/** + * Checks each anim has received the expected events + */ +void CTEventTest::EventHandlerRemoval_CheckExpectedEventsReceivedByAnims() + { + for (TInt animIndex = iRemovableAnims->Count() - 1; animIndex >= 0; animIndex--) + { + if (!(*iRemovableAnims)[animIndex]->TestPassed()) + { + Failed(); + break; + } + } + } + + +/** + * Create three anims. In the first anim's Offer raw event generate two more events + * which will call recursively the process raw event at the server side. + * The second and third anims are just removable anims. To simulate the scenario + * for the defect INC095892. If teh fix for this is defect is not supplied then + * wserv would panic for this test case. + */ +void CTEventTest::EventHandlerRemoval_CheckRecursionOfProcessRawEvent() + { + iTheClientFlush=TheClient->iWs.SetAutoFlush(ETrue); + iQuequeClientFlush=iQueueClient->iWs.SetAutoFlush(ETrue); + + // Create 3 anims + RRemovableAnim* eventRecurAnim = RRemovableAnim::NewLC(iQueueClient->iWin->BaseWin(), iAnimDll); + RRemovableAnim* removableAnim = RRemovableAnim::NewLC(iQueueClient->iWin->BaseWin(), iAnimDll); + RRemovableAnim* eventAnim = RRemovableAnim::NewLC(iQueueClient->iWin->BaseWin(), iAnimDll); + + // Add these anim as event handlers and set thier respective life time + eventRecurAnim->AddToEventHandlers(); + eventRecurAnim->SetEventHandlerLifetime(4); + + removableAnim->AddToEventHandlers(); + removableAnim->SetEventHandlerLifetime(1); + + eventAnim->AddToEventHandlers(); + eventAnim->SetEventHandlerLifetime(2); + + TRawEvent rawEvent1; + TRawEvent rawEvent2; + TRawEvent rawEvent3; + rawEvent1.Set(TRawEvent::EKeyDown, 60); + rawEvent2.Set(TRawEvent::EKeyUp, 34); + rawEvent3.Set(TRawEvent::EKeyUp, 35); + + eventRecurAnim->AddExpectedEvent(rawEvent2); + eventRecurAnim->AddExpectedEvent(rawEvent3); + + removableAnim->AddExpectedEvent(rawEvent2); + + eventAnim->AddExpectedEvent(rawEvent2); + eventAnim->AddExpectedEvent(rawEvent3); + + // Add these events to iQueueClient for testing + AddExpectedKey(EEventKeyUp, 34, ETrue); + AddExpectedKey(EEventKeyUp, 35, ETrue); + + iTest->SimulateKey(rawEvent1.Type(), rawEvent1.ScanCode()); + + CleanupStack::PopAndDestroy(3, eventRecurAnim); + + TheClient->iWs.SetAutoFlush(iTheClientFlush); + iQueueClient->iWs.SetAutoFlush(iQuequeClientFlush); + } + +/** + * Manually removes all anims from event handlers array + */ +void CTEventTest::EventHandlerRemoval_ManuallyRemoveAllAnims() + { + // Manually remove all anims from event handler list + for (TInt animIndex = iRemovableAnims->Count() - 1; animIndex >= 0; animIndex--) + { + (*iRemovableAnims)[animIndex]->RemoveFromEventHandlers(); + } + } + +/** + * Manually removes all anims from event handlers array + */ +void CTEventTest::EventHandlerRemoval_ResetAllAnims() + { + // Manually remove all anims from event handler list + for (TInt animIndex = iRemovableAnims->Count() - 1; animIndex >= 0; animIndex--) + { + (*iRemovableAnims)[animIndex]->Reset(); + (*iRemovableAnims)[animIndex]->SetEventHandlerLifetime(0); + } + } + +/** + * Manually removes all anims from event handler list + * Sends 2 events + * Checks that no events have been received by anims + * Resets all anims ready for next test + */ +void CTEventTest::EventHandlerRemoval_RemoveAndResetAllAnims() + { +#if defined(DETAILED) + INFO_PRINTF1(_L(" Manually remove all anims from event handler list")); + INFO_PRINTF1(_L(" Send 2 events: none expected to be received by anims")); + INFO_PRINTF1(_L(" All expected to be received by wserv event processing")); +#endif + // Manually remove all anims from event handler list + EventHandlerRemoval_ManuallyRemoveAllAnims(); + // All expected to be received by wserv event processing + AddExpectedKey(EEventKeyDown,32,ETrue); + AddExpectedKey(EEventKeyUp,32,ETrue); + // Send 2 events - none expected to be received by anims, + iTest->SimulateKey(TRawEvent::EKeyDown,32); + iTest->SimulateKey(TRawEvent::EKeyUp,32); + // Flush events to wserv + TheClient->iWs.Flush(); + // Check the anims have not received any events + EventHandlerRemoval_CheckExpectedEventsReceivedByAnims(); +#if defined(DETAILED) + INFO_PRINTF1(_L(" Cleanup before next step")); +#endif + // Reset anims + EventHandlerRemoval_ResetAllAnims(); + } + +/** + * Destroys all anims in iRemovableAnims + * Resets iRemovableAnims + */ +void CTEventTest::EventHandlerRemoval_DestroyAllAnims() + { + if (iRemovableAnims) + { + // Destroy anims + for (TInt animIndex = iRemovableAnims->Count() - 1; animIndex >= 0; animIndex--) + { + RRemovableAnim* anim = (*iRemovableAnims)[animIndex]; + if (anim) + { + anim->Destroy(); + } + } + iRemovableAnims->Reset(); + } + } + +/** +SYMTestCaseID GRAPHICS-WSERV-0496 + +@SYMDEF DEF133776 + +@SYMTestCaseDesc Cancels key captures using all combinations of + RWindowGroup::Capture...() and RWindowGroup::Cancel...() APIs. + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Call each of the RWindowGroup::Capture***() APIs followed by + each of the RWindowGroup::CancelCapture***() APIs. + RWindowGroup::Capture***() APIs: + CaptureKey(TUint, TUint, TUint) + CaptureKey(TUint, TUint, TUint, TInt) + CaptureKeyUpAndDowns(TUint, TUint, TUint) + CaptureKeyUpAndDowns(TUint, TUint, TUint, TInt) + CaptureLongKey(TUint, TUint, TUint, TUint, TInt, TUint) + CaptureLongKey(TTimeIntervalMicroSeconds32, TUint, TUint, TUint, TUint, TInt, TUint) + RWindowGroup::CancelCapture***() APIs: + CancelCaptureKey() + CancelCaptureKeyUpAndDowns() + CancelCaptureLongKey() + +@SYMTestExpectedResults WServ should handle matched and mismatched Cancel + and Capture calls without panicking. + */ +void CTEventTest::MismatchedCapture_NextSetOfEventsL() + { + if (iEventSet == 0) + AddExpectedEvent(EEventFocusGained); + + if (iEventSet < (EMaxCaptureKeyApis*EMaxCancelCaptureKeyApis)) + { + TestCaptureAndCancelCapturePair(static_cast(iEventSet%EMaxCaptureKeyApis), static_cast(iEventSet/EMaxCaptureKeyApis)); + iEventSet++; + } + else + { + CActiveScheduler::Stop(); + } + } + +/** Helper function that applies a key capture and then cancels it using the +passed capture and cancel RWindowGroup APIs. + +@param aCaptureApi Enum value specifying the capture API to use +@param aCancelCaptureApi Enum value specifying the cancel capture API to use + */ +void CTEventTest::TestCaptureAndCancelCapturePair(TCaptureKeyApis aCaptureApi, TCancelCaptureKeyApis aCancelCaptureApi) + { +#if defined(LOGGING) + _LIT(KCaptureKey, "CaptureKey"); + _LIT(KCaptureKeyKeyUpAndDowns, "CaptureKeyKeyUpAndDowns"); + _LIT(KCaptureLongKey, "CaptureLongKey"); + _LIT(KCancelCaptureKey, "CancelCaptureKey"); + _LIT(KCancelCaptureKeyKeyUpAndDowns, "CancelCaptureKeyKeyUpAndDowns"); + _LIT(KCancelCaptureLongKey, "CancelCaptureLongKey"); + _LIT(KLog,"TestCaptureAndCancelCapturePair: %S, %S"); + TPtrC captures[EMaxCaptureKeyApis] = {KCaptureKey(), KCaptureKey(), KCaptureKeyKeyUpAndDowns(), KCaptureKeyKeyUpAndDowns(), KCaptureLongKey(), KCaptureLongKey()}; + TPtrC cancelCaptures[EMaxCancelCaptureKeyApis] = {KCancelCaptureKey(), KCancelCaptureKeyKeyUpAndDowns(), KCancelCaptureLongKey()}; + TLogMessageText logMessageText; + logMessageText.Format(KLog, &captures[aCaptureApi], &cancelCaptures[aCancelCaptureApi]); + INFO_PRINTF1(logMessageText); +#endif // LOGGING + + // Start a key capture using one of the six RWindowGroup Capture***() APIs + switch (aCaptureApi) + { + case ECaptureKey1: + case ECaptureKey2: + // Test RWindowGroup::CaptureKey() + if (aCaptureApi == ECaptureKey1) + iCaptureKey = iQueueClient->iGroup->GroupWin()->CaptureKey('A',0,0); + else + iCaptureKey = iQueueClient->iGroup->GroupWin()->CaptureKey('A',0,0,1); // priority 1 (default priority is 0) + iTest->SimulateKey(TRawEvent::EKeyDown, 'A'); + TheClient->iWs.Flush(); + User::After(KeyRepeatTime()*3/2); + iTest->SimulateKey(TRawEvent::EKeyUp, 'A'); + TheClient->iWs.Flush(); + AddExpectedKey(EEventKeyDown, 'A'); + AddExpectedKey(EEventKey,'A','a'); + AddExpectedKey(EEventKey,'A','a',1); + AddExpectedKey(EEventKeyUp, 'A'); + break; + + case ECaptureKeyUpAndDowns1: + case ECaptureKeyUpAndDowns2: + // Test RWindowGroup::CaptureKeyUpAndDowns() + if (aCaptureApi == ECaptureKeyUpAndDowns1) + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureKeyUpAndDowns(EStdKeySpace,0,0); + else + iCaptureKey=iQueueClient->iGroup->GroupWin()->CaptureKeyUpAndDowns(EStdKeySpace,0,0,1); // priority 1 (default priority is 0) + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeySpace); + TheClient->iWs.Flush(); + User::After(KeyRepeatTime()*3/2); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace); + TheClient->iWs.Flush(); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKey,EStdKeySpace,' '); + AddExpectedKey(EEventKey,EStdKeySpace,' ',1); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + break; + + case ECaptureLongKey1: + case ECaptureLongKey2: + { + // Test RWindowGroup::CaptureLongKey() + TTimeIntervalMicroSeconds32 repeat = KeyRepeatTime(); + if (aCaptureApi == ECaptureLongKey1) + { + iCaptureKey = iQueueClient->iGroup->GroupWin()->CaptureLongKey(' ', 'a', 0, 0, 2, ELongCaptureNormal); + } + else + { + repeat = KeyRepeatTime()/2; + iCaptureKey = iQueueClient->iGroup->GroupWin()->CaptureLongKey(repeat, ' ', 'a', 0, 0, 2, ELongCaptureNormal); + } + iQueueClient->iWs.Flush(); + iTest->SimulateKey(TRawEvent::EKeyDown,EStdKeySpace); + TheClient->iWs.Flush(); + User::After(KeyRepeatTime()*3/2); + iTest->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace); + TheClient->iWs.Flush(); + AddExpectedKey(EEventKeyDown,EStdKeySpace); + AddExpectedKey(EEventKey,EStdKeySpace,' '); + AddExpectedKey(EEventKey,EStdKeySpace,'a',1); + AddExpectedKey(EEventKeyUp,EStdKeySpace); + } + break; + + default: + INFO_PRINTF1(_L("Unexpected TCaptureKeyApis value passed to CTEventTest::TestCaptureAndCancelCapturePair()")); + TEST(EFalse); + break; + } + + if (iCaptureKey) + { + // End a capture using one of the three RWindowGroup CancelCapture***() APIs, + // for each Capture***() API each one of these will be called, therefore there will + // be one correct CancelCapture***() APIs called and two incorrect CancelCapture***() + // APIs called for each Capture***() API. + switch (aCancelCaptureApi) + { + case ECancelCaptureKey: + iQueueClient->iGroup->GroupWin()->CancelCaptureKey(iCaptureKey); + break; + case ECancelCaptureKeyUpAndDowns: + iQueueClient->iGroup->GroupWin()->CancelCaptureKeyUpAndDowns(iCaptureKey); + break; + case ECancelCaptureLongKey: + iQueueClient->iGroup->GroupWin()->CancelCaptureLongKey(iCaptureKey); + break; + default: + INFO_PRINTF1(_L("Unexpected TCancelCaptureKeyApis value passed to CTEventTest::TestCaptureAndCancelCapturePair()")); + TEST(EFalse); + break; + } + + // If an mistmatched CancelCapture***() API was called, call the correct one now + // to make sure the Capture/CancelCapture state is clean before the next test starts + if ((aCaptureApi/2) != aCancelCaptureApi) + { + switch (aCaptureApi) + { + case ECaptureKey1: + case ECaptureKey2: + iQueueClient->iGroup->GroupWin()->CancelCaptureKey(iCaptureKey); + break; + case ECaptureKeyUpAndDowns1: + case ECaptureKeyUpAndDowns2: + iQueueClient->iGroup->GroupWin()->CancelCaptureKeyUpAndDowns(iCaptureKey); + break; + case ECaptureLongKey1: + case ECaptureLongKey2: + iQueueClient->iGroup->GroupWin()->CancelCaptureLongKey(iCaptureKey); + break; + } + } + } + + TheClient->iWs.Flush(); + } + +/*void CTEventTest::_NextSetOfEvents() //Template for these functions + { + switch(iEventSet++) + { + case 0: + iQueueClient->iWin->WinTreeNode()->; //Set up window + iQueueClient->iWin->BaseWin()->; + iQueueClient->iGroup->GroupWin()->; + iQueueClient->iWs.Flush(); //Make take effect + SimulateEvent(TRawEvent::); //Create an event + TheClient->iWs.Flush(); //Send event + AddExpectedEvent(EEventFocusGained); //Always get a focus gain at start + AddExpectedEvent(); //Expect the event that was created above + break; + case 1: + iQueueClient->iWs.Flush(); + SimulateEvent(TRawEvent::); + TheClient->iWs.Flush(); + AddExpectedEvent(); + break; + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + }*/ + +/** + @SYMTestCaseID GRAPHICS-WSERV-CODEBASE-WSERV-0051 + + @SYMPREQ PGM027 + + @SYMTestCaseDesc Tests SetKeyboardRepeatRate API. + + @SYMTestPriority 1 + + @SYMTestStatus Implemented + + @SYMTestActions This test tryes to call SetKeyboardRepeatRate with invalid time values\n + + @SYMTestExpectedResults KeyRepeatRateNegTest should tests the API SetKeyboardRepeatRate return value\n + The test should pass and API should return KErrArgument. + + */ +void CTEventTest::KeyRepeatRateNegTest(TInt aInitialRepeat, TInt aRepeat) + { + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-CODEBASE-WSERV-0051")); + TInt ret=TheClient->iWs.SetKeyboardRepeatRate(TTimeIntervalMicroSeconds32(aInitialRepeat), TTimeIntervalMicroSeconds32(aRepeat)); + TEST(ret==KErrArgument); + TRAPD(err,((CTEventTestStep*)iStep)->RecordTestResultL()); + if (err!=KErrNone) + INFO_PRINTF1(_L("Failed to record test result")); + } + +void CTEventTest::RunTestsL(TBool aNeedChildWindows/*=EFalse*/) + { + iQueueClient=new(ELeave) CTQueueClient(this); + iQueueClient->SetScreenNumber(iTest->iScreenNumber); + iQueueClient->ConstructL(aNeedChildWindows); + iEventSet=0; + TRAPD(err,NextSetOfEventsL()); + if (err!=KErrNone) + { + iFailed=ETrue; + return; + } +// + CActiveScheduler::Start(); +// + TInt eventsLeft=iQueueClient->EventQueue()->EventsLeft(); + if (eventsLeft>0) + iFailed=ETrue; + delete iVisWins1; + iVisWins1 = NULL; + delete iVisWins2; + iVisWins2 = NULL; + delete iQueueClient; + iQueueClient=NULL; + } + +void CTEventTest::RunTestsRestoreAreaL(TBool aNeedChildWindows) + { + TRect area(TheClient->iWs.PointerCursorArea()); + RunTestsL(aNeedChildWindows); + TheClient->iWs.SetPointerCursorArea(area); + } + +/*void CTEventTest::QueuePurgingL() + { + RunTestsL(EFalse); + } + +void CTEventTest::SendEventL() + { + RunTestsL(EFalse); + } + +void CTEventTest::InvisibleWindowL() + { + RunTestsL(ETrue); + } + +void CTEventTest::JavaAdditionsL() + { + RunTestsL(EFalse); + }*/ + +void CTEventTest::WindowCapBugL() + { + RunTestsL(ETrue); + } + +/*void CTEventTest::XyInputTypeL() + { + RunTestsL(EFalse); + } + +void CTEventTest::MovingPointerCursorL() + { + RunTestsRestoreAreaL(ETrue); + } + +void CTEventTest::RotatedModeL() + { + RunTestsRestoreAreaL(EFalse); + }*/ + +/** +* This test creates one anim and calls AddToEventHandlers() twenty times. +* it shouldn't add the same anim to event handler if anim is already in handler. +*/ +void CTEventTest::EventHandlerRemoval_AddEventHandlerMultipleTimes() + { + iTheClientFlush=TheClient->iWs.SetAutoFlush(ETrue); + iQuequeClientFlush=iQueueClient->iWs.SetAutoFlush(ETrue); + + RRemovableAnim* eventTestAnim = RRemovableAnim::NewLC(iQueueClient->iWin->BaseWin(), iAnimDll); + + // Call AddToEventHandlers() on same anim 20 times, it should add this anim in event handler only once + for (TInt count = 0; count < 20; count++) + eventTestAnim->AddToEventHandlers(); + eventTestAnim->SetEventHandlerLifetime(1); + + TRawEvent rawEvent1; + rawEvent1.Set(TRawEvent::EKeyUp, 34); + + eventTestAnim->AddExpectedEvent(rawEvent1); + + // Add these events to iQueueClient for testing + AddExpectedKey(EEventKeyUp, 34, ETrue); + + iTest->SimulateKey(TRawEvent::EKeyUp, 34); + + CleanupStack::PopAndDestroy(eventTestAnim); + TheClient->iWs.SetAutoFlush(iTheClientFlush); + iQueueClient->iWs.SetAutoFlush(iQuequeClientFlush); + } + +void CTEventTest::EventQueuePtrCrashTest() +// Code designed to hit the defect reported in INC109199 & INC105430, needs a very specific sequence of +// events and client disconnections to hit the exact problem state. + { + const TInt KNumTestEvents=6; + const TInt KMaxNumTestEvents=16; + // Number of iterations needs to be as high as the queue granularity to make sure at least + // once around we actually hit the code to change the queue size + const TInt KNumEvTestIterations=4; + const TInt KNumBaseTestSessions=KNumEvTestIterations+1; + const TInt KNumMainTestSessions=13; + const TInt KMaxNumSessions=KNumBaseTestSessions+KNumMainTestSessions+KNumEvTestIterations; + RWsSession wsSessions[KMaxNumSessions]; + RWindowGroup wGroups[KMaxNumSessions]; + for(TInt iterationLoop=0;iterationLoop=KNumBaseTestSessions) + { + TWsEvent event; + for(TInt evLoop=0;evLoopiWs.SendEventToWindowGroup(groupWin[0].Identifier(),event); + TheClient->iWs.SendEventToWindowGroup(groupWin[1].Identifier(),event); + } + + //To create a new client, although the queue is full, wserv will guarantee to initialize + //the queue size of the new queue to at least EMinQueueSize. So that it can response to + //the event. + RWsSession testWsSession; + RWindowGroup testGroupWin; + TRequestStatus testStatus; + if (aEventReadyCancel) + { + //Simulate the heap allocation failure to test expanding spaces by purge + //events from inactive clients when initialize queue size. + TInt failAt = 1; + TInt err; + do { + TheClient->iWs.HeapSetFail(RHeap::EFailNext, failAt++); + TheClient->iWs.Flush(); + err = testWsSession.Connect(); + TheClient->iWs.HeapSetFail(RHeap::ENone, 1); + } while (err == KErrNoMemory); + User::LeaveIfError(err); + } + else + { + User::LeaveIfError(testWsSession.Connect()); + } + CleanupClosePushL(testWsSession); + testGroupWin = RWindowGroup(testWsSession); + User::LeaveIfError(testGroupWin.Construct(cliHanGrpWin++)); + CleanupClosePushL(testGroupWin); + + //Send events to the newly created client. + // The Debug version of WServ puts a EEventFocusGained into the event + // before this test's custom event, so leave one slot in the queue + // for it. +#if (defined _DEBUG) + TInt testEventCount = EMinQueueSize - 1; +#else + TInt testEventCount = EMinQueueSize; +#endif + for(TInt evLoop = 0; evLoop < testEventCount; evLoop++) + { + event.SetType(3001 + evLoop); + TheClient->iWs.SendEventToWindowGroup(testGroupWin.Identifier(),event); + } + + //Check the event queue. + //Having a timer here to avoid infinitely wait for event. + TInt expectedEvent = 3001; + for(TInt evLoop = 0; evLoop < EMinQueueSize; evLoop++) + { + testWsSession.EventReady(&testStatus); + TRequestStatus timerStatus; + timer.After(timerStatus, oneSecond); + User::WaitForRequest(testStatus, timerStatus); + TEST(testStatus == 0); + if (testStatus == 0) + { + // Tests the event + testWsSession.GetEvent(event); + // WServ sometimes puts a EEventFocusGained event into the queue + // before the test's custom event, so ignore it. + if (event.Type() != EEventFocusGained) + { + TEST(event.Type() == expectedEvent); + expectedEvent++; + } + // testStatus has been completed. Cancel the timer. + timer.Cancel(); + User::WaitForRequest(timerStatus); + } + else + { + // Times out, cancel the event notification + testWsSession.EventReadyCancel(); + User::WaitForRequest(testStatus); + } + } + CleanupStack::PopAndDestroy(2*numClients + 2, &wsSession[0]); + } + CleanupStack::PopAndDestroy(&timer); + } + +void CTEventTest::SimulateRepeatEvent(TInt aScanCode, TInt aRepeats/*=0*/) + { + TRawEvent rawEvent; + if (aRepeats) + rawEvent.Set(TRawEvent::EKeyRepeat, aScanCode, aRepeats); + else + rawEvent.Set(TRawEvent::EKeyRepeat, aScanCode); + UserSvr::AddEvent(rawEvent); + } + +void CTEventTest::RawEventRepeatTest_NextSetOfEventsL() + { + switch(iEventSet++) + { + case 0: + // Tests EKeyRepeat without repeat value set. + SimulateRepeatEvent(32); + + // Tests EKeyRepeat with repeat value set to 2. + SimulateRepeatEvent(33,2); + + AddExpectedEvent(EEventFocusGained); + AddExpectedKey(EEventKey, 32); + AddExpectedKey(EEventKey, 33, 0, 2); + break; + default: + CActiveScheduler::Stop(); + break; + } + TheClient->iWs.Flush(); + } + +void CTEventTest::RunTestCaseL(TInt /*aCurTestCase*/) + { + _LIT(KTest0,"General 1"); + _LIT(KTest1,"Event queue purging"); + _LIT(KTest2,"SendEvent"); + _LIT(KTest3,"SendEventToAll"); + _LIT(KTest4,"InvisibleWindow"); + _LIT(KTest5,"JavaAdditions"); + _LIT(KTest6,"WindowCaptureBug"); + _LIT(KTest7,"XYInput Types"); + _LIT(KTest8,"MovingPointerCursor"); + _LIT(KTest9,"Rotated Modes"); + _LIT(KTest10,"Anim Event"); + _LIT(KTest11,"Focus Changed"); + _LIT(KTest12,"On/Off Events"); + _LIT(KTest13,"Virtual Keyboard"); + _LIT(KTest14,"Key Clicks"); + _LIT(KTest15,"Capture Long"); + _LIT(KTest16,"Password Window"); + _LIT(KTest17,"Group List Changed"); + _LIT(KTest18,"Repeatable Key Events"); + _LIT(KTest19,"Screen Scaling"); + _LIT(KTest20,"Visibility Changed Events"); + _LIT(KTest21,"Check Time Stamp Of Events"); + _LIT(KTest22,"Pointer Capture Priority Events"); + _LIT(KTest23,"Event Handler Removal"); + _LIT(KTest24,"Event Queue ptr crash test"); + _LIT(KTest25,"Mismatched Pointer Events"); + _LIT(KTest26,"Pointer Buffer Purge"); + _LIT(KTest27,"TRawEvent test for Repeats"); +#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS +#ifndef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA + _LIT(KTest28,"Transparent Surface Visibility Changed Events 1"); + _LIT(KTest29,"Transparent Surface Visibility Changed Events 2"); + _LIT(KTest30,"Transparent Surface Visibility Changed Events 3"); +#endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA +#endif // SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS + _LIT(KTest31A,"Initialize Queue Size without inactive queue"); + _LIT(KTest31B,"Initialize Queue Size with inactive queue"); + + if (!TestBase()->ConfigurationSupportsPointerEventTesting()) + { + INFO_PRINTF1(_L("Test skipped because config does not support pointer event testing")); + TestComplete(); + return; + } + + //if (iTest->iState==1) iTest->iState=14; //Use this line to skip to a particular test + ((CTEventTestStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch(iTest->iState) + { +/** +@SYMTestCaseID GRAPHICS-WSERV-0053 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Carry out general event tests on WServ + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions General events are sent via WServ + +@SYMTestExpectedResults The events are sent without error +*/ + case 0: + iTest->LogSubTest(KTest0); + General(); + ((CTEventTestStep*)iStep)->SetOverallTestStepID(_L("GRAPHICS-WSERV-0053")); + //iState=8; + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0054 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Carry out event queue purging + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Purge the event queue + +@SYMTestExpectedResults The events queue is purged without error +*/ + case 1: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0054")); + iTest->LogSubTest(KTest1); + RunTestsL(); //QueuePurgingL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0055 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test that events can be sent + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send events in WServ + +@SYMTestExpectedResults The events are sent without error +*/ + case 2: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0055")); + iTest->LogSubTest(KTest2); + RunTestsL(); //SendEventL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0056 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send an event to all window groups + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send an event to all window groups + +@SYMTestExpectedResults The events are sent to all window groups + without error +*/ + case 3: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0056")); + iTest->LogSubTest(KTest3); + General2(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0057 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send events to an invisible window + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send events to an invisible window + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 4: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0057")); + iTest->LogSubTest(KTest4); + RunTestsL(ETrue); //InvisibleWindowL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0058 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send events for java additions + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send events for java additions + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 5: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0058")); + iTest->LogSubTest(KTest5); + RunTestsL(); //JavaAdditionsL(); + break; + + case 6: + ((CTEventTestStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + iTest->LogSubTest(KTest6); + //WindowCapBugL(); //Not finished + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0059 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send events for x and y inputs + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send events for x and y inputs + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 7: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0059")); + iTest->LogSubTest(KTest7); + RunTestsL(); //XyInputTypeL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0060 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send events for moving pointer cursor + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send events for moving pointer cursor + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 8: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0060")); + iTest->LogSubTest(KTest8); + RunTestsRestoreAreaL(ETrue); //MovingPointerCursorL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0061 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send events for rotate mode + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send events for rotate mode + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 9: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0061")); + iTest->LogSubTest(KTest9); + RunTestsRestoreAreaL(EFalse); //RotatedModeL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0062 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send events for an anim event + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send events for an anim event + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 10: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0062")); + iTest->LogSubTest(KTest10); + RunTestsRestoreAreaL(EFalse); //AnimEvent(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0063 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send events for focus changed + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send events for focus changed + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 11: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0063")); + iTest->LogSubTest(KTest11); + RunTestsL(); //FocusChanged(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0064 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send stop events + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send stop events + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 12: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0064")); + iTest->LogSubTest(KTest12); + RunTestsL(ETrue); //StopEvents(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0065 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send events for the virtual keyboard + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send events for the virtual keyboard + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 13: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0065")); + iTest->LogSubTest(KTest13); + RunTestsL(); //VirtualKeyboard(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0066 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send events for key clicks + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send stop events + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 14: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0066")); + iTest->LogSubTest(KTest14); + { + TBool changeable; + if (iClick.IsLoaded(changeable) && !iTest->IsFullRomL()) + RunTestsL(ETrue); //KeyClicks(); + } + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0067 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send events for capturing large areas of text + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send events for capturing large areas of text + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 15: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0067")); + iTest->LogSubTest(KTest15); + RunTestsL(ETrue); //CaptureLong(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0068 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send events for activating password + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send events for activating password + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 16: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0068")); + iTest->LogSubTest(KTest16); + if (!iTest->IsFullRomL()) + RunTestsL(); //Password(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0069 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send events for activating password + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send events for activating password + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 17: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0069")); + iTest->LogSubTest(KTest17); + RunTestsL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0070 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send repeatable key events + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send repeatable key events + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 18: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0070")); + iTest->LogSubTest(KTest18); + RunTestsL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0071 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send Screen Scaling events + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send Screen Scaling events + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 19: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0071")); + iTest->LogSubTest(KTest19); + if (iScreenModeTests&EDoScale) + { + RunTestsL(); + } + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0072 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send Visibility Changed events + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send Visibility Changed events + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 20: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0072")); + iTest->LogSubTest(KTest20); + RunTestsL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0073 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Check Time Stamp Of Sent Events + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Check Time Stamp Of Sent Events + +@SYMTestExpectedResults The time stamps for the events are correct +*/ + case 21: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0073")); + iTest->LogSubTest(KTest21); + RunTestsL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0074 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send Pointer Capture Priority Events + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send Pointer Capture Priority Events + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 22: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0074")); + iTest->LogSubTest(KTest22); + RunTestsL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0343 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Send Event Handler Removal Events + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Send Event Handler Removal Events + +@SYMTestExpectedResults The events are sent to the window without + error +*/ + case 23: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0343")); + iTest->LogSubTest(KTest23); + RunTestsL(); //EventHandlerRemoval(); + break; + case 24: +/** +@SYMTestCaseID GRAPHICS-WSERV-0565 +*/ + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0565")); + iTest->LogSubTest(KTest24); + EventQueuePtrCrashTest(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0496 + +@SYMDEF DEF133776 + +@SYMTestCaseDesc Cancels key captures using all combinations of + RWindowGroup::Capture...() and RWindowGroup::Cancel...() APIs. + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Call each of the RWindowGroup::Capture***() APIs followed by + each of the RWindowGroup::CancelCapture***() APIs. + RWindowGroup::Capture***() APIs: + CaptureKey(TUint, TUint, TUint) + CaptureKey(TUint, TUint, TUint, TInt) + CaptureKeyUpAndDowns(TUint, TUint, TUint) + CaptureKeyUpAndDowns(TUint, TUint, TUint, TInt) + CaptureLongKey(TUint, TUint, TUint, TUint, TInt, TUint) + CaptureLongKey(TTimeIntervalMicroSeconds32, TUint, TUint, TUint, TUint, TInt, TUint) + RWindowGroup::CancelCapture***() APIs: + CancelCaptureKey() + CancelCaptureKeyUpAndDowns() + CancelCaptureLongKey() + +@SYMTestExpectedResults WServ should handle matched and mismatched Cancel + and Capture calls without panicking. +*/ + case 25: +// Skip this test in debug on the emulator, run it always on hardware as debug ROMs include +// a release version of the production code that doesn't panic + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0496")); +#if defined(_DEBUG) && !defined (__MARM__) + INFO_PRINTF1(_L("Skipping this test in _DEBUG on emulator to avoid debug only panics, see GRAPHICS-WSERV-0497 for the matching panic test")); +#else + iTest->LogSubTest(KTest25); + RunTestsL(); +#endif + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0444 + +@SYMDEF PDEF110849 + +@SYMTestCaseDesc Pointer Buffer Exception After Event Queue Purge + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Connect to pointer buffer, send it some pointer events and disconnect. + Now send enough events to cause an event queue purge. The purge will + attempt to empty the pointer buffer, but will fail because we have disconnected. + +@SYMTestExpectedResults The purge will realise it does not need to empty the pointer buffer and + so there will not be an access violation - exception. + +*/ + case 26: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0444")); + iTest->LogSubTest(KTest26); + RunTestsL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0484 +@SYMDEF PDEF120721 +@SYMTestCaseDesc Window server guarantees to initialize the queue size of the new queue to + at least EMinQueueSize. +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions Create multiple clients to connect to window server. + Send enough events to make the event queue full. + Create a new client to connect to window server. + Send events to the new client and test that the new client + can get the events. +@SYMTestExpectedResults Window server guarantees to initialize the size of the new event + queue to EMinQueueSize, so that window server will not lock up + due to the full of global event queue. + +*/ + case 27: + iTest->LogSubTest(KTest27); + RunTestsL(); + break; + +#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS +#ifndef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA +/** +@SYMTestCaseID GRAPHICS-WSERV-2669-0015 +@SYMREQ REQ13202: Possibility for external layers to appear above UI layer +@SYMTestCaseDesc Window obscured by transparent surface window receives + (EPartiallyVisible | EFullyVisible) when surface is made semi-transparent. +@SYMTestPriority 2 +@SYMPrerequisites Win1 – bottom window + Win2 – middle window with background surface, which totally obscures win1 +@SYMTestActions Call SetSurfaceTransparency(ETrue) on win2 +@SYMTestExpectedResults Win1 receives visibility event +*/ + case 28: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-2669-0015")); + iTest->LogSubTest(KTest28); + RunTestsL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-2669-0016 +@SYMREQ REQ13202: Possibility for external layers to appear above UI layer +@SYMTestCaseDesc Window obscured by semi-transparent surface window receives + (EPartiallyVisible | EFullyVisible) when obscuring window is deleted +@SYMTestPriority 2 +@SYMPrerequisites Win1 – bottom window + Win2 – middle window with semi-transparent background surface, which totally obscures win1 + Win3 – top window which totally obscures win2, and is opaque +@SYMTestActions Delete win3 +@SYMTestExpectedResults Both win1 and win2 receive visibility events +*/ + case 29: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-2669-0016")); + iTest->LogSubTest(KTest29); + RunTestsL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-2669-0017 +@SYMREQ REQ13202: Possibility for external layers to appear above UI layer +@SYMTestCaseDesc Window does not receive any visibiliy event when a semi-transparent + surface is moved onto/above it. +@SYMTestPriority 2 +@SYMPrerequisites Win1 – bottom window + Win2 – top window which does not overlap win1 +@SYMTestActions Move win2 to overlap win1 +@SYMTestExpectedResults No visibility event is received (win1 is still fully visible) +*/ + case 30: + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-2669-0017")); + iTest->LogSubTest(KTest30); + RunTestsL(); + break; +#endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA +#endif // SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS + +/** +@SYMTestCaseID GRAPHICS-WSERV-0559 +@SYMDEF INC140850 +@SYMTestCaseDesc To check Wserv passes correct repeat value for TRawEvent of type EKeyRepeat. +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions Simulate TRawEvent of type EKeyRepeat without Repeat value set. + Simulate the above with repeat value set to 2. +@SYMTestExpectedResults Simulated events should match expected events added to the array. +*/ + +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA + case 28: +#else +#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS + case 31: +#else + case 28: +#endif +#endif + // This test was moved to be the last test in the test suite, because it sometimes leaves events in the event queue, + //it can affect the results of other tests. This test case should be the last test in the test suite. + ((CTEventTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0484")); + iTest->LogSubTest(KTest31A); + InitializeQueueSizeTestL(EFalse); + iTest->LogSubTest(KTest31B); + InitializeQueueSizeTestL(ETrue); + break; + + default: + ((CTEventTestStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTEventTestStep*)iStep)->CloseTMSGraphicsStep(); + TestComplete(); + break; + } + ((CTEventTestStep*)iStep)->RecordTestResultL(); + if (iFailed) + { + TEST(EFalse); + iFailed=EFalse; + } + ++iTest->iState; + } + +__WS_CONSTRUCT_STEP__(EventTest) +