// 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 <w32debug.h>
#include <hal.h>
#define FAIL_LOGGING on
//#define DETAILED
#define LOGGING 1 //Uncomment this when there is a fail so that you get more logging
_LIT(KKeyClickPluginDll, "click.dll");
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) || wsKeyRepeat<eKeyRepeat)
{
_LIT(KKeysRepDiff,"Count=%d Key Repeat Exp=%d Act=%d");
buf.Copy(KStartString);
buf.AppendFormat(KKeysRepDiff,iEventCount,eKeyRepeat,wsKeyRepeat);
iTest->LOG_MESSAGE(buf);
}
#endif
TestL(wsEvent.Key()->iCode==expectedEvent.Key()->iCode && wsEvent.Key()->iRepeats>=expectedEvent.Key()->iRepeats
&& (wsEvent.Key()->iRepeats>0)==(expectedEvent.Key()->iRepeats>0)); //Fall Through
case EEventKeyDown:
case EEventKeyUp:
#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)<KOffset)
{
_LIT(KTimeStampDiff,"Count=%d Offset=%d, ExpectedTime=%d, WServEventTime=%d");
buf.Copy(KStartString);
buf.AppendFormat(KTimeStampDiff,iEventCount,offset,expectedEvent.Time().Int64(),wsEvent.Time().Int64());
iTest->LOG_MESSAGE(buf);
}
#endif
TestL(Abs(offset)<KOffset);
}
End:
if (iEventBuffer.Count()==0)
{
TRAPD(err, iTest->NextSetOfEventsL()); //Not allowed to leave
if(err != KErrNone)
{
buf.Copy(KStartString);
buf.AppendFormat(_L("Subtest does not follow rules set by TEvent test framework, leave code: %d"), err);
iTest->TEST(EFalse);
iTest->LOG_MESSAGE(buf);
User::Leave(err);
}
}
}
void CTQueueTestEvent::AddExpectedEvent(TWsEvent &aEvent)
{
if(iCheckTimeStamp)
{
static_cast<TWsQTEvent&>(aEvent).Time().UniversalTime();
}
iEventBuffer.Add(&aEvent);
}
TInt CTQueueTestEvent::EventsLeft()
{
return iEventBuffer.Count();
}
//
CTQueueWindowGroup::CTQueueWindowGroup(CTClient *aClient) : CTWindowGroup(aClient)
{}
void CTQueueWindowGroup::ConstructL()
{
CTWindowGroup::ConstructL();
User::LeaveIfError(iGroupWin.EnableOnEvents(EEventControlAlways));
User::LeaveIfError(iGroupWin.EnableGroupChangeEvents());
}
//
/**
Closes and deletes anim DLL.
@param aAnimDll Pointer to the anim Dll to be closed and deleted
*/
LOCAL_C void DestroyAnimDll(TAny* aAnimDll)
{
(static_cast<RAnimDll*>(aAnimDll))->Destroy();
}
/**
Destroys an REventAnimBase derived anim
@param aAnim REventAnimBase derived client-side handle to anim
*/
LOCAL_C void DestroyAnim(TAny* aAnim)
{
(static_cast<REventAnimBase*>(aAnim))->Destroy();
}
/**
Loads the DLL containing the test anims and pushes it onto the cleanup stack.
This function leaves if the operation was unsuccessful.
@return A pointer to the DLL containing test anims
*/
RAnimDll* REventAnimBase::LoadL()
{
RAnimDll* animDll=new(ELeave) RAnimDll(TheClient->iWs);
CleanupStack::PushL(TCleanupItem(DestroyAnimDll,animDll));
User::LeaveIfError(animDll->Load(KAnimDLLName));
CleanupStack::Pop(animDll);
return animDll;
}
/**
Closes the client-side handle to the anim, destroys the DLL and deletes itself.
*/
void REventAnimBase::Destroy()
{
Close();
delete this;
}
/**
Resets server-side state of anim
*/
void REventAnimBase::Reset()
{
CommandReply(EADllReset);
}
/**
@return Under non-error conditions, returns 0.
Under error conditions, returns the number of events received
since the first unexpected event was sent.
*/
TInt REventAnimBase::ErrorCode()
{
return CommandReply(EADllErrorCode);
}
/**
@return The number of events received by the anim since it was last reset.
*/
TInt REventAnimBase::NumberOfEventsReceived()
{
return CommandReply(EADllNumberOfEventsReceived);
}
/**
Adds an expected event to the list of events expected by the anim.
@param aEat Indicates if event is expected to be eaten (ETrue 'indicates expected to be eaten')
@param aEvent The expected event
@return KErrNone if succcessful, othewise error code.
*/
TInt REventAnimBase::AddExpectedEvent(TBool aEat, const TRawEvent& aEvent)
{
TAnimRawEvent event;
event.iRawEvent=aEvent;
event.iEat=aEat;
return AddExpectedEvent(event);
}
/**
Adds an expected event to the list of events expected by the anim.
@param aEvent The expected event
@return KErrNone if succcessful, othewise error code.
*/
TInt REventAnimBase::AddExpectedEvent(const TAnimRawEvent& aEvent)
{
TPckgBuf<TAnimRawEvent> param;
param()=aEvent;
return CommandReply(EADllAddExpectedEvent,param);
}
//
/**
Loads the DLL containing the event test anim and creates an anim for event tests
@param aWin the base window to which the anim is associated (this anim is a Window anim)
@return A pointer to the new REventAnim
*/
REventAnim* REventAnim::NewL(RWindowBase* aWin, RAnimDll* aDll, REventAnimBase::EAnimationType aType/*=EEventAnim*/)
{
REventAnim* self=new(ELeave) REventAnim(aDll);
CleanupStack::PushL(TCleanupItem(DestroyAnim,self));
User::LeaveIfError(self->Construct(*aWin,(aType == EEventAnim ? EAnimTypeEventTest : EAnimTypeEventPostingTest), TPtrC8()));
CleanupStack::Pop(self);
return self;
}
/**
Checks if the anim has received the correct events, and resets the sever-side state of the anim
@return positive value if events did not match expected showing the first event that didn't match.
negative value if there were the wrong number of events showing the number of events there were
0 if correct number of events and they all match
*/
TInt REventAnim::TestFail(TInt aNoEvents)
{
TInt events=CommandReply(EADllErrorCode);
if (events>0)
return events;
events=CommandReply(EADllNoEventsAndReset);
if (events==aNoEvents)
return 0;
return -events;
}
//
/**
Loads the DLL containing the event test anim and creates an anim for event handler removal tests
@param aWin the base window to which the anim is associated (this anim is a Window anim)
@return A pointer to the new REventAnim
*/
RRemovableAnim* RRemovableAnim::NewLC(RWindowBase* aWin, RAnimDll* aDll)
{
RRemovableAnim* self=new(ELeave) RRemovableAnim(aDll);
CleanupStack::PushL(TCleanupItem(DestroyAnim,self));
User::LeaveIfError(self->Construct(*aWin,EAnimTypeRemovableAnim,TPtrC8()));
return self;
}
/**
Sets the lifetime of the anim. This anim will remove itself from the
event handler list after receiving this number of events.
@return The lifetime of the anim
*/
TInt RRemovableAnim::SetEventHandlerLifetime(TInt aEventCount)
{
TPckgBuf<TInt> param;
param()=aEventCount;
return CommandReply(EADllSetEventHandlerLifetime, param);
}
/**
Retrieves the lifetime of the anim. This anim will remove itself from the
event handler list after receiving this number of events.
@return The lifetime of the anim
*/
TInt RRemovableAnim::EventHandlerLifetime()
{
return CommandReply(EADllEventHandlerLifetime);
}
/**
Adds the anim to the list of event handlers.
This anim should receive any subsequent events.
@return KErrNone on successful addition.
*/
TInt RRemovableAnim::AddToEventHandlers()
{
return CommandReply(EADllAddToEventHandlers);
}
/**
Removes the anim from the list of event handlers.
This anim should not receive any subsequent events.
@return KErrNone on successful removal.
*/
TInt RRemovableAnim::RemoveFromEventHandlers()
{
return CommandReply(EADllRemoveFromEventHandlers);
}
/**
Tests if the anim has received the correct number of events, and that
the events received are all the correct events.
@param aNoEvents The total expected number of events since it was last reset/constructed.
@return ETrue if the anim has received the expected events.
*/
TBool RRemovableAnim::TestPassed()
{
return CommandReply(EADllTestPassed);
}
//
CTEventTest::CTEventTest(CTestStep* aStep) : CTWsGraphicsBase(aStep)
{
INFO_PRINTF1(_L("Testing Event functions"));
}
CTEventTest::~CTEventTest()
{
delete iBlankWin;
iBackingWindow.Close();
delete iVisWins1;
delete iVisWins2;
delete iVisWins3;
delete iTransWin;
delete iQueueClient;
if (iAnim)
iAnim->Destroy();
delete iEventTestGroup2; //Just in case it doesn't get deleted normally
delete iEventTestGroup3; //Just in case it doesn't get deleted normally
delete iEventTestGroup4; //Just in case it doesn't get deleted normally
if (iPtrPluginLoaded)
{
iClick.Unload();
}
iClick.Close();
if (iTurnBackOnCapsLock)
{
TheClient->iWs.SetModifierState(EModifierCapsLock,ETurnOnModifier);
}
if (iRemovableAnims)
{
EventHandlerRemoval_DestroyAllAnims();
iRemovableAnims->Close();
delete iRemovableAnims;
}
if (iAnimDll)
{
iAnimDll->Destroy();
}
#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
#ifndef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
if (!iSurfaceId.IsNull())
{
iSurfaceManager.CloseSurface(iSurfaceId);
}
iSurfaceManager.Close();
if(iTimeOutCallback)
{
iTimeOutCallback->Cancel();
delete iTimeOutCallback;
}
#endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
#endif // SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
}
void CTEventTest::ConstructL()
{
_LIT(KWsIniFile, "z:\\system\\data\\wsini.ini");
CIniData* iniData = CIniData::NewL(KWsIniFile, ' ');
_LIT( KWsiniYShifting, "YSHIFTING");
iniData->FindVar(KWsiniYShifting, iYOffset);
delete iniData;
TheClient->iScreen->SetAppScreenMode(0);
TheClient->iScreen->SetScreenMode(0); // in mode 0 TheClient->iScreen->SizeInPixels()
iPhysicalScreenSize = TheClient->iScreen->SizeInPixels(); // is equal to physical screen size
BaseWin->Invalidate();
BaseWin->Win()->BeginRedraw();
TheGc->Activate(*BaseWin->Win());
TheGc->SetBrushColor(TRgb::Gray16(12));
TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
TheGc->SetPenStyle(CGraphicsContext::ENullPen);
TheGc->DrawRect(TRect(BaseWin->Win()->Size()));
TheGc->Deactivate();
BaseWin->Win()->EndRedraw();
TheGc->Activate(*TestWin->Win());
TheGc->SetBrushColor(TRgb::Gray16(4));
TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
TheGc->SetPenStyle(CGraphicsContext::ENullPen);
TheGc->DrawRect(TRect(TestWin->Win()->Size()));
TheGc->Deactivate();
iBackingWindow=RBlankWindow(TheClient->iWs);
iBackingWindow.Construct(*TheClient->iGroup->WinTreeNode(),ENullWsHandle);
iBackingWindow.SetColor(TRgb(0,0xDD,0xDD));
iBackingWindow.SetOrdinalPosition(-1,-25);
iBackingWindow.Activate();
iBlankWin=new(ELeave) CTBlankWindow();
iBlankWin->ConstructL(*TheClient->iGroup);
User::LeaveIfError(iBlankWin->BaseWin()->SetRequiredDisplayMode(EColor256));
iBlankWin->SetExt(TPoint(),iPhysicalScreenSize);
iBlankWin->SetVisible(EFalse);
iBlankWin->Activate();
CArrayFixFlat<TInt> *rotations=new(ELeave) CArrayFixFlat<TInt>(1);
iNumScrModes=TheClient->iScreen->NumScreenModes();
TInt modes=Min(2,iNumScrModes);
TInt mode;
TInt rot;
CleanupStack::PushL(rotations);
for (mode=0;mode<modes;++mode)
{
User::LeaveIfError(TheClient->iScreen->GetRotationsList(mode,rotations));
for (rot=rotations->Count()-1;rot>=0;--rot)
{
iScreenModeTests|=(1<<(*rotations)[rot]);
}
}
if (CheckScalingSupportedOrNot())
iScreenModeTests|=EDoScale;
iClick=RSoundPlugIn(TheClient->iWs);
User::LeaveIfError(iClick.Construct(TUid::Uid(CLICK_THIRD_UID)));
TBool ptrPluginLoadable = EFalse;
iClick.IsLoaded(ptrPluginLoadable);
if (ptrPluginLoadable)
{
User::LeaveIfError(iClick.Load(KKeyClickPluginDll));
iPtrPluginLoaded = ETrue;
}
CleanupStack::PopAndDestroy();
if (TheClient->iWs.GetModifierState()&EModifierCapsLock)
{
iTurnBackOnCapsLock=ETrue;
TheClient->iWs.SetModifierState(EModifierCapsLock,ETurnOffModifier);
}
iAnimDll = REventAnimBase::LoadL();
TInt mods=TheClient->iWs.GetModifierState();
if (mods&EModifierCapsLock)
iTest->SimulateKeyDownUp(EStdKeyCapsLock);
if (mods&EModifierNumLock)
iTest->SimulateKeyDownUp(EStdKeyNumLock);
//Make sure all the keys we test are in the up state
iTest->SimulateKeyDownUp(EStdKeyLeftShift);
iTest->SimulateKeyDownUp(EStdKeyRightShift);
iTest->SimulateKeyDownUp(EStdKeyLeftFunc);
iTest->SimulateKeyDownUp(EStdKeyLeftCtrl);
iTest->SimulateKeyDownUp(EStdKeyRightCtrl);
mods=TheClient->iWs.GetModifierState();
_LIT(KLog,"Initial Modifiers state 0x%x (ideally should be zero)");
LOG_MESSAGE2(KLog,mods);
iTest->DelayIfFullRomL();
#if !defined(TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA)
// 2d or 3d pointer?
if(HAL::Get(HALData::EPointer3D,iIs3DPointer)!=KErrNone)
{
iIs3DPointer=EFalse;
}
#endif
}
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<TWsEvent> evtPkg;
TWsEvent& event=evtPkg();
if (aEventCode==EEventKey && aCode==0)
aCode=aScanCode;
event.SetType(aEventCode);
event.SetHandle((TInt)iQueueClient->iGroup);
event.Key()->iCode=aCode;
event.Key()->iScanCode=aScanCode;
event.Key()->iModifiers=aModifiers;
event.Key()->iRepeats=aRepeats;
iQueueClient->AddExpectedEvent(event);
if (iAddToClick)
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<TInt>(iQueueClient->GetHandle(aPos)));
const TPoint3D point3D(aPos.iX, aPos.iY, 0);
const TInt pointerEventModifiers=0;
const TUint8 pointerNumber=0;
aEvent.InitAdvancedPointerEvent(aType,pointerEventModifiers,point3D,pointerNumber);
#else
TPointerEvent& ptrEvent=*aEvent.Pointer();
aEvent.SetType(EEventPointer);
ptrEvent.iParentPosition=aPos; //Must be done before next line
aEvent.SetHandle(REINTERPRET_CAST(TInt,iQueueClient->GetHandle(aPos)));
ptrEvent.iType=aType;
ptrEvent.iModifiers=0;
ptrEvent.iPosition=aPos;
#endif
}
void CTEventTest::CalculatePointerCaptureEvent(TWsEvent& aEvent, TPointerEvent::TType aType, TPoint aPos, TInt aHandle)
{
TPointerEvent& ptrEvent=*aEvent.Pointer();
aEvent.SetType(EEventPointer);
ptrEvent.iParentPosition=aPos; //Must be done before next line
if(iVisWins1 && iVisWins2)
{
if (TRect(iQueueClient->ChildTopLeft(),iQueueClient->ChildSize()).Contains(aPos) &&
!TRect(iQueueClient->ChildTopLeft()+TPoint(15,15),iQueueClient->ChildSize()).Contains(aPos))
{
aPos-=iQueueClient->ChildTopLeft(); //Pointer is on the first window
aEvent.SetHandle((TInt)iVisWins1);
}
else if (TRect(iQueueClient->ChildTopLeft()+TPoint(15,15),iQueueClient->ChildSize()).Contains(aPos))
{
aPos-=(iQueueClient->ChildTopLeft()+TPoint(15,15)); //Pointer is on the second window
aEvent.SetHandle((TInt)iVisWins2);
}
else if (TRect(TPoint(EWinPositionX,EWinPositionY),TSize(EWinWidth,EWinHeight)).Contains(aPos))
{
aPos-=TPoint(EWinPositionX,EWinPositionY); //Pointer is on the parent window
aEvent.SetHandle((TInt)iQueueClient->iWin);
}
else
{
aEvent.SetHandle((TInt)0); //Pointer is not in the same window group
}
}
ptrEvent.iType=aType;
ptrEvent.iModifiers=0;
if(aHandle!=0 && aHandle!=aEvent.Handle())
{
aEvent.SetHandle(aHandle);
ptrEvent.iPosition=ptrEvent.iParentPosition-(iQueueClient->ChildTopLeft()+TPoint(15,15));
}
else
{
ptrEvent.iPosition=aPos;
}
}
void CTEventTest::AddExpectedPointerCapture(TPointerEvent::TType aType, TPoint aPos, TInt aHandle)
{
TPckgBuf<TWsQTEvent> evtPkg;
CalculatePointerCaptureEvent(evtPkg(),aType,aPos,aHandle);
iQueueClient->AddExpectedEvent(evtPkg());
}
void CTEventTest::AddExpectedPointer(TPointerEvent::TType aType, TPoint aPos)
{
TPckgBuf<TWsQTEvent> evtPkg;
CalculatePointerEvent(evtPkg(),aType,aPos);
iQueueClient->AddExpectedEvent(evtPkg());
if (iAddToClick)
{
evtPkg().Pointer()->iParentPosition+=TPoint(EWinPositionX,EWinPositionY);
iClick.CommandReply(EClickEventAdd,evtPkg);
}
}
void CTEventTest::AddExpectedPointerClick(TPointerEvent::TType aType, TPoint aPos)
{
TPckgBuf<TWsQTEvent> 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<TInt> 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;count2<EMaxEventQueueSize/3;count2++)
{
AddExpectedKey(EEventKeyDown,'A'+(count2%26));
AddExpectedKey(EEventKey,'A'+(count2%26),'a'+(count2%26));
AddExpectedKey(EEventKeyUp,'A'+(count2%26));
}
AddExpectedKey(EEventKeyDown,'A'+(99%26));
AddExpectedKey(EEventKeyUp,'A'+(99%26));
}
break;
case 2:
{
User::LeaveIfError(iQueueClient->iGroup->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;count3<EMaxEventQueueSize-2;count3++)
AddExpectedKey(EEventKeyDown,'A');
iQueueClient->iGroup->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;count3<EMaxEventQueueSize-2;count3++)
AddExpectedKey(EEventKeyDown,'A');
}
break;
case 4:
{
SimulatePointer(TRawEvent::EButton1Up,10,20);
SimulatePointer(TRawEvent::EButton2Up,11,22);
iTest->SimulateKey(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;count4<EMaxEventQueueSize;count4++)
AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(10-EWinPositionX,20-EWinPositionY));
}
break;
case 10:
{
RWindowGroup *group=iQueueClient->iGroup->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;ii<noVirtualKeys;++ii)
{
iQueueClient->iWin->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;ii<noVirtualKeys-2;++ii) //Can't do all 10 as this will overflow the event buffer
{
iTest->SimulatePointerDownUp(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<TInt> 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<TWindowCloseData> 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<TPointerEventInfo> pointerEventInfo;
pointerEventInfo().iClientHandle=reinterpret_cast<TInt>(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<TPointerEventInfo> pointerEventInfo;
pointerEventInfo().iClientHandle=reinterpret_cast<TInt>(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<CTEventTest*>(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; i<EMaxEventQueueSize; i++)
{
RDebug::Print(_L("PointerBufferPurge - Purge Loop %d"), i);
SimulatePointer(TRawEvent::EButton1Up,15,25);
}
// Expected events
// - We only expect the focus and button up events because the other events have been purged
// - button up events which are not paired with button down take precedence
// - but even some of our button up events will have been purged - hence the lower count
AddExpectedEvent(EEventFocusGained);
for (TInt i=0; i<EMaxEventQueueSize-1; i++)
{
AddExpectedPointer(TPointerEvent::EButton1Up, TPoint(15-EWinPositionX,25-EWinPositionY));
}
break;
}
default:
CActiveScheduler::Stop();
break;
}
TheClient->iWs.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<RRemovableAnim>* removableAnims = new (ELeave) RPointerArray<RRemovableAnim>();
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<TRawEvent> 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<TCaptureKeyApis>(iEventSet%EMaxCaptureKeyApis), static_cast<TCancelCaptureKeyApis>(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<KNumEvTestIterations;iterationLoop++)
{
const TInt numTestSessions=KNumBaseTestSessions+KNumMainTestSessions+iterationLoop;
#if defined(LOGGING)
_LIT(KLog1,"EventQueuePtrCrashTest: Test Creating %d Clients");
LOG_MESSAGE2(KLog1,numTestSessions);
#endif
for(TInt testSessionIndex=0;testSessionIndex<numTestSessions;testSessionIndex++)
{
RWsSession& ws=wsSessions[testSessionIndex];
User::LeaveIfError(ws.Connect());
wGroups[testSessionIndex]=RWindowGroup(ws);
RWindowGroup& group=wGroups[testSessionIndex];
User::LeaveIfError(group.Construct(testSessionIndex+1,EFalse));
if (testSessionIndex>=KNumBaseTestSessions)
{
TWsEvent event;
for(TInt evLoop=0;evLoop<KNumTestEvents;evLoop++)
{
event.SetType(1001+evLoop);
ws.SendEventToWindowGroup(group.Identifier(),event);
}
if (testSessionIndex==(numTestSessions-1))
{
for(TInt eventIndex=0;eventIndex<KMaxNumTestEvents;eventIndex++)
{
event.SetType(1001+eventIndex);
ws.SendEventToAllWindowGroups(event);
}
}
}
}
#if defined(LOGGING)
_LIT(KLog2,"EventQueuePtrCrashTest: Closing Clients");
LOG_MESSAGE(KLog2);
#endif
TInt closeLoop=0;
while(closeLoop<KNumBaseTestSessions)
{
wsSessions[closeLoop++].Close();
}
RWsSession extraSession1;
User::LeaveIfError(extraSession1.Connect());
extraSession1.Close();
while(closeLoop<numTestSessions)
{
wsSessions[closeLoop++].Close();
}
}
}
/**
Test queue size of the new queue can be initialized to be at least EMinQueueSize.
@param aEventReadyCancel whether there is inactive client. This parameter can be specified
to test different code path for expanding spaces for new queue. If the value is false,
the space for the new queue is gained from current global queue or by growing global queue size.
Otherwise, there are inactive clients which cancel their listening to event, in addition,
memory allocation is simulated to be failed when growing global queue size,
so that space is gained by purging events from inactive clients.
*/
void CTEventTest::InitializeQueueSizeTestL(TBool aEventReadyCancel)
{
const TInt numEvents = 50;
const TInt maxClients = 3;
const TInt oneSecond = 1000000;
RWsSession wsSession[maxClients];
RWindowGroup groupWin[maxClients];
TRequestStatus status;
TInt cliHanGrpWin = 10000;
RTimer timer;
timer.CreateLocal();
CleanupClosePushL(timer);
// To have the test creating different number of clients is to make sure
// there is at least one of the tests meets the below requirement:
// the number of the connections when the new queue created for test is not multiple
// of queue granularity, so that the queue size initialization is not done by growing
// global queue size due to the increase of the connections.
for (TInt numClients = maxClients - 1; numClients <= maxClients; numClients++)
{
TInt clientIndex;
//Create test clients
for (clientIndex = 0; clientIndex < numClients; clientIndex++)
{
User::LeaveIfError(wsSession[clientIndex].Connect());
CleanupClosePushL(wsSession[clientIndex]);
groupWin[clientIndex] = RWindowGroup(wsSession[clientIndex]);
User::LeaveIfError(groupWin[clientIndex].Construct(cliHanGrpWin++));
CleanupClosePushL(groupWin[clientIndex]);
}
// Cancel listening to event for the first client.
// This is for testing PurgeInactiveEvents.
if (aEventReadyCancel)
{
wsSession[0].EventReady(&status);
wsSession[0].EventReadyCancel();
User::WaitForRequest(status);
}
//send events to window group to make the queue full.
TWsEvent event;
TInt evLoop;
for(evLoop = 0; evLoop < numEvents; evLoop++)
{
event.SetType(2001 + evLoop);
TheClient->iWs.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)