--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/tauto/TEVENT.H Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,423 @@
+// 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:
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+
+#ifndef __TEVENT_H__
+#define __TEVENT_H__
+
+#include <e32std.h>
+#include <e32cmn.h>
+#include <w32std.h>
+#include "../tlib/testbase.h"
+#include "AUTO.H"
+#include "AUTODLL.H"
+#include "../TClick/CLICK.H"
+#include "TGraphicsHarness.h"
+#ifndef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+#include <graphics/surfacemanager.h>
+#include <graphics/surfaceupdateclient.h>
+#endif //TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+
+const TInt EMaxEventQueueSize=32;
+const TInt EMinQueueSize = 2;
+
+
+class CTEventTest;
+class CTQueueClient;
+
+class TWsQTEvent : public TWsEvent
+ {
+ friend class CTEventTest;
+public:
+ inline TTime& Time() {return iTime;}
+ };
+
+class CTQueueTestEvent : public CTEvent
+ {
+ enum {EEventBufferSize=40};
+public:
+ CTQueueTestEvent(RWsSession *aWs, CTEventTest *aTest);
+ void ConstructL();
+ void AddExpectedEvent(TWsEvent &aEvent);
+ inline void ResetCount(TInt aSet) {iEventCount=0;iEventSet=aSet;iLastEventError=EFalse;}
+ TInt EventsLeft();
+ inline void SetCheckTimeStamp(TBool aCheck) {iCheckTimeStamp = aCheck;}
+protected:
+ void doRunL();
+private:
+ void TestL(TInt aTest);
+private:
+ CCirBuf<TWsEvent> iEventBuffer;
+ CTEventTest *iTest;
+ TInt iEventCount;
+ TInt iEventSet;
+ TBool iCheckTimeStamp;
+ TPartialRedrawType iRedrawType;
+ TBool iLastEventError;
+ };
+
+const TInt EWinPositionX=6;
+const TInt EWinPositionY=9;
+const TInt EWinWidth=100;
+const TInt EWinHeight=50;
+// (6,9)
+// +----------------------+
+// | (31,21) |
+// | +--------------+ |
+// | | | |
+// | | | |
+// | +--------------+ |
+// | (81,46) |
+// +----------------------+ (106,59)
+
+class CTQueueClient : public CTClient
+ {
+private:
+ enum {EMaxKeysDown=50};
+public:
+ CTQueueClient(CTEventTest *aTest);
+ ~CTQueueClient();
+ void ConstructL(TBool aCreateChild);
+ void ConstructEventHandlerL();
+ void AddExpectedEvent(TWsEvent &aEvent);
+ TInt WindowGroupIdentifier();
+ CTWinBase* GetHandle(TPoint& aPos);
+ void SetChildCapture(TInt aCaptureFlags);
+ inline void ResetCount(TInt aSet) {EventQueue()->ResetCount(aSet);}
+ inline void EnableFocusChangeEvents() {iGroup->GroupWin()->EnableFocusChangeEvents();}
+ inline void DisableFocusChangeEvents() {iGroup->GroupWin()->DisableFocusChangeEvents();}
+ inline void EnableGroupListChangeEvents() {iGroup->GroupWin()->EnableGroupListChangeEvents();}
+ inline void DisableGroupListChangeEvents() {iGroup->GroupWin()->DisableGroupListChangeEvents();}
+ inline CTQueueTestEvent* EventQueue() {return STATIC_CAST(CTQueueTestEvent*,iEventHandler);}
+ inline TPoint ChildTopLeft() {return TPoint(EWinWidth/4,EWinHeight/4);}
+ inline TSize ChildSize() {return TSize(EWinWidth/2,EWinHeight/2);}
+ void CreateEventTestGroupOnSecondScreenL();
+ void CloseEventTestGroupOnSecondScreen();
+private:
+ inline TPoint ParentTopLeft() {return TPoint(EWinPositionX,EWinPositionY);}
+ inline TPoint ChildAbsTopLeft() {return ParentTopLeft()+ChildTopLeft();}
+private:
+ TInt iKeysDown[EMaxKeysDown];
+ TInt iNumKeysDown;
+ CTEventTest *iTest;
+public:
+ CTBackedUpWin *iChildWin;
+ CTBackedUpWin *iWin;
+ TBool iChildCapturing;
+ TBool iCapturing;
+ CWsScreenDevice* iSndScreen;
+ RWindowGroup* iWinGp1;
+ RWindowGroup* iWinGp2;
+ };
+
+class REventAnimBase : public RTestAnim
+ {
+public:
+ enum EAnimationType
+ {
+ EEventAnim,
+ EEventPostingAnim
+ };
+ REventAnimBase(RAnimDll* aDll) :RTestAnim(*aDll) {}
+ virtual void Destroy();
+ void Reset();
+ TInt ErrorCode();
+ TInt NumberOfEventsReceived();
+ TInt AddExpectedEvent(TBool aEat, const TRawEvent& aEvent);
+ TInt AddExpectedEvent(const TAnimRawEvent& aEvent);
+ static RAnimDll* LoadL();
+ };
+
+/**
+ Client side handle to server-side anim class used for Anim Event tests
+ @internalComponent
+ @test
+ */
+class REventAnim : public REventAnimBase
+ {
+public:
+ static REventAnim* NewL(RWindowBase* aWin, RAnimDll* aDll, REventAnimBase::EAnimationType aType=EEventAnim);
+ inline REventAnim(RAnimDll* aDll) : REventAnimBase(aDll) {}
+ inline TInt AddEvent(const TAnimRawEvent& aEvent) {return REventAnimBase::AddExpectedEvent(aEvent);};
+ inline TInt GetError() {return REventAnimBase::ErrorCode();};
+ inline TInt GetNumEvents() {return REventAnimBase::NumberOfEventsReceived();};
+ TInt TestFail(TInt aNoEvents);
+ };
+
+/**
+ Client side handle to server-side anim class used for Event Handler Removal tests
+
+ 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.
+
+ @internalComponent
+ @test
+ */
+class RRemovableAnim : public REventAnimBase
+ {
+public:
+ static RRemovableAnim* NewLC(RWindowBase* aWin, RAnimDll* aDll);
+ inline RRemovableAnim(RAnimDll* aDll) : REventAnimBase(aDll) {}
+ inline TInt AddExpectedEvent(const TRawEvent& aEvent) {return REventAnimBase::AddExpectedEvent(EFalse, aEvent);};
+ TInt SetEventHandlerLifetime(TInt aEventCount);
+ TInt EventHandlerLifetime();
+ TInt AddToEventHandlers();
+ TInt RemoveFromEventHandlers();
+ TBool TestPassed();
+ };
+
+class CTEventTest : public CTWsGraphicsBase
+ {
+ enum {
+ EKeyboardInitialRepeat1=1234567,
+ EKeyboardRepeat1=555666,
+ EKeyboardInitialRepeat2=2121212,
+ EKeyboardRepeat2=20000,
+ EDoubleClickTime1=900000,
+ EDoubleClickGap1=10,
+ EDoubleClickTime2=4000000,
+ EDoubleClickGap2=5,
+ ENumVisWins=2,
+ EPointerCursorUpdateGap=50000, //0.05secs Same as WsPointer::EPointerUpdateGapInMicroSeconds
+ EKeyboardInitialRepeat3=2147483447, // Max value
+ EKeyboardRepeat3=8000, // for repeat 3
+ EKeyboardInitialRepeat4=-2, // Min value
+ EKeyboardRepeat4=6000, // for repeat 4
+ EKeyboardRepeat5=7000, // for repeat 4z
+ EKeyboardRepeat6=-30000, // for repeat 4
+ EKeyboardRepeat7=2147483447, // for repeat 4
+ };
+public:
+ CTEventTest(CTestStep* aStep);
+ ~CTEventTest();
+ //TestState DoTestL();
+ void ConstructL();
+ void General();
+ void General2();
+ void Failed();
+ //void QueuePurgingL();
+ //void SendEventL();
+ //void InvisibleWindowL();
+ //void JavaAdditionsL();
+ void WindowCapBugL();
+ //void XyInputTypeL();
+ //void MovingPointerCursorL();
+ //void RotatedModeL();
+ //void AnimEvent();
+ void CheckTimeInterval(const TTimeIntervalMicroSeconds32 &aTime,TInt EKeyboardRepeat1);
+ void KeyRepeatRate(TInt aInitialRepeat, TInt aRepeat);
+ void KeyRepeatRateNegTest(TInt aInitialRepeat, TInt aRepeat);
+ void DoubleClickSettings(TInt aInterval, TInt aDistance);
+ void NextSetOfEventsL();
+ inline void ResetCount(TInt aSet) {iQueueClient->ResetCount(aSet);}
+protected:
+//from CTGraphicsStep
+ virtual void RunTestCaseL(TInt aCurTestCase);
+private:
+ enum
+ {
+ EDoRot0 =0x01,
+ EDoRot90 =0x02,
+ EDoRot180=0x04,
+ EDoScale=0x80,
+ };
+ enum TClients
+ {
+ ETheClient,
+ EQueueClient,
+ };
+ enum TCaptureKeyApis
+ {
+ ECaptureKey1,
+ ECaptureKey2,
+ ECaptureKeyUpAndDowns1,
+ ECaptureKeyUpAndDowns2,
+ ECaptureLongKey1,
+ ECaptureLongKey2,
+ // Add additional enum values before this line
+ EMaxCaptureKeyApis
+ };
+ enum TCancelCaptureKeyApis
+ {
+ ECancelCaptureKey,
+ ECancelCaptureKeyUpAndDowns,
+ ECancelCaptureLongKey,
+ // Add additional enum values before this line
+ EMaxCancelCaptureKeyApis
+ };
+private:
+ void RunTestsL(TBool aNeedChildWindows=EFalse);
+ void RunTestsRestoreAreaL(TBool aNeedChildWindows);
+ void QueuePurge_NextSetOfEventsL();
+ void InitializeQueueSizeTestL(TBool aEventReadyCancel);
+ void SendEventTest_NextSetOfEvents();
+ void InvisibleWindow_NextSetOfEvents();
+ void JavaAdditions_NextSetOfEvents();
+ void XyInputType_NextSetOfEvents();
+ void MovingPointerCursor_NextSetOfEventsL();
+ void WinCap_NextSetOfEvents();
+ void RotatedMode_NextSetOfEventsL();
+ void ScreenScaling_NextSetOfEventsL();
+ void AnimEvent_NextSetOfEventsL();
+ void FocusChanged_NextSetOfEventsL();
+ void StopEvents_NextSetOfEventsL();
+ void VirtualKeyboard_NextSetOfEventsL();
+ void KeyClicks_NextSetOfEvents();
+ void CaptureLong_NextSetOfEventsL();
+ void Password_NextSetOfEvents();
+ void GroupListChanged_NextSetOfEventsL();
+ void VisibilityChanged_NextSetOfEventsL();
+#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+#ifndef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ void SurfaceVisibilityChanged1_NextSetOfEventsL();
+ void SurfaceVisibilityChanged2_NextSetOfEventsL();
+ void SurfaceVisibilityChanged3_NextSetOfEventsL();
+#endif //TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+#endif //SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+ void CheckTimeStamp_NextSetOfEventsL();
+ void RepeatableKeysL();
+ void PointerCapture_NextSetOfEventsL();
+ void PointerBufferPurge_NextSetOfEventsL();
+ void MismatchedCapture_NextSetOfEventsL();
+ void EventHandlerRemoval_NextSetOfEventsL();
+ void EventHandlerRemoval_CreateAnimsL(TInt aAnimCount);
+ void EventHandlerRemoval_PrepareAnims(const TInt* aLifeTimes, TInt aAnimCount);
+ void EventHandlerRemoval_CreateExpectedEvents(TInt aEventCount, TInt aLiveAnimCount);
+ void EventHandlerRemoval_AddExpectedEvent(TRawEvent aEvent, TInt aLiveAnimCount);
+ void EventHandlerRemoval_CheckExpectedEventsReceivedByAnims();
+ void EventHandlerRemoval_CheckRecursionOfProcessRawEvent();
+ void EventHandlerRemoval_ManuallyRemoveAllAnims();
+ void EventHandlerRemoval_ResetAllAnims();
+ void EventHandlerRemoval_RemoveAndResetAllAnims();
+ void EventHandlerRemoval_DestroyAllAnims();
+ void EventHandlerRemoval_AddEventHandlerMultipleTimes();
+ void CheckPointerCursorInDifferentScreenMode(TSizeMode aMode,TPoint aOrigin);
+ void SimulateAndCheck(TPoint aOrigin,TSize aScale,TInt aXOffset,TInt aYOffset,TPointerEvent::TType aEventType,TRect aPointerCursorArea);
+ void AddExpectedKey(TInt aEventCode, TInt aScanCode, TInt aCode=0, TInt aRepeats=0, TUint aModifiers=0);
+ void AddExpectedKeyDownUp(TInt aScanCode, TInt aCode=0, TInt aRepeats=0, TUint aModifiers=0);
+ void AddExpectedEvent(TInt aEventCode, CTWinBase* aWin);
+ void AddExpectedEvent(TInt aEventCode);
+ void AddExpectedEvent(TInt aEventCode,RWindowGroup* aWindow);
+ void AddExpectedErrorMessage(TWsErrorMessage::TErrorCategory aCategory, TInt aError);
+ void CalculatePointerEvent(TWsEvent& aEvent,TPointerEvent::TType aType, TPoint aPos);
+ void CalculatePointerCaptureEvent(TWsEvent& aEvent,TPointerEvent::TType aType, TPoint aPos, TInt aHandle=0);
+ void AddExpectedPointer(TPointerEvent::TType aType, TPoint aPos);
+ void AddExpectedPointerCapture(TPointerEvent::TType aType, TPoint aPos, TInt aHandle=0);
+ void AddExpectedPointerClick(TPointerEvent::TType aType, TPoint aPos);
+ void AddExpectedPointerDownUp(TPoint aPos);
+ inline void AddExpectedPointerScr(TPointerEvent::TType aType, TPoint aPos);
+ inline void AddExpectedPointerDownUpScr(TPoint aPos);
+ void AddExpectedModifiersChanged(TInt aChangedModifiers, TInt aModifiers);
+ void AddExpectedEnterExit(TInt aEventCode, TPoint aPos);
+ void AddExpectedKeyAnim(TRawEvent::TType aEventCode, TInt aScanCode,TBool aEat);
+ void AddExpectedPointerAnim(TRawEvent::TType aEventCode, TPoint aPoint, TBool aEat=ETrue);
+ void AddExpectedVisibilityChange(TUint aFlags);
+ void AddExpectedVisibilityChange(TUint aFlags, CTBlankWindow* aWindow);
+ inline void SimulatePointerWin(TRawEvent::TType aType, TInt aX, TInt aY);
+ inline void SimulatePointerDownUpWin(TInt aX, TInt aY);
+ inline void SimulatePointer(TRawEvent::TType aType, TInt aX, TInt aY);
+ void doSendEvent(TWsEvent &aEvent);
+ void SendKey(TInt aEventCode, TInt aScanCode, TInt aCode=0, TInt iRepeats=0);
+ void SendEvent(TInt aEventCode);
+ void CreateEventTestGroup();
+ void CloseEventTestGroup();
+ void CreateAndCloseEventTestGroup();
+ void TriggerOomMessage(TTimeIntervalMinutes aPeriod);
+ TBool SetClickType(TClickOutputModes aType);
+ CTBlankWindow* NewBlueForgroundWindowL();
+ CTBlankWindow* NewBlueForgroundWindow();
+ TInt KeyRepeatTime() const;
+ void EventQueuePtrCrashTest();
+ TInt ClickCommandReply(TInt aCommand,TInt aData);
+ TInt CreateGroupWindow(RWindowGroup& aWinGp,TClients aClient,TInt& aWinGpId);
+ void CloseGroupWindow(RWindowGroup& aWinGp,TInt aWinGpId);
+ void CloseWindow(RWindowBase& aWin,TInt aHandle,TInt aWinGpId);
+ void EventQueueExpansionTestL();
+ void RawEventRepeatTest_NextSetOfEventsL();
+ void SimulateRepeatEvent(TInt aScanCode, TInt aRepeats=0);
+#if !defined(TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA)
+ void SimulateButton1DownWithSimulatedMove(TInt aX, TInt aY);
+#endif
+ void TestCaptureAndCancelCapturePair(TCaptureKeyApis aCaptureApi, TCancelCaptureKeyApis aCancelCaptureApi);
+ static TInt GenerateAnEvent(TAny* aEventTest);
+private:
+ CTBlankWindow* iBlankWin;
+ RBlankWindow iBackingWindow;
+ TSize iPhysicalScreenSize;
+ TSize iWinSize;
+ RWindowGroup iEventTestGroup;
+ CTWindowGroup *iEventTestGroup2;
+ CTWindowGroup *iEventTestGroup3;
+ CTWindowGroup *iEventTestGroup4;
+ TInt iEventSet;
+ CTQueueClient *iQueueClient;
+ TBool iFailed;
+ REventAnim* iAnim;
+ TUint iScreenModeTests; //currently contains supported rotation and if screen scaling is possible
+ TInt iNumScrModes;
+ RSoundPlugIn iClick;
+ TBool iAddToClick;
+ TInt iCaptureKey;
+ TBool iTurnBackOnCapsLock;
+ TInt iCurrentMode;
+ TSizeMode iSizeMode;
+ TBool iTheClientFlush;
+ TBool iQuequeClientFlush;
+ CTBlankWindow* iVisWins1;
+ CTBlankWindow* iVisWins2;
+ CTBlankWindow* iVisWins3;
+ CTransWindow* iTransWin;
+ RAnimDll* iAnimDll;
+ RPointerArray<RRemovableAnim>* iRemovableAnims;
+ TBool iIs3DPointer;
+ TBool iPtrPluginLoaded;
+ TInt iYOffset;
+#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+#ifndef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ TSurfaceId iSurfaceId;
+ RSurfaceManager iSurfaceManager;
+ CPeriodic* iTimeOutCallback;
+#endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+#endif // SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+ };
+
+class CTQueueWindowGroup : public CTWindowGroup
+ {
+public:
+ CTQueueWindowGroup(CTClient *aClient);
+ void ConstructL();
+private:
+ TInt iNumOnEvents;
+ };
+
+class CTEventTestStep : public CTGraphicsStep
+ {
+public:
+ CTEventTestStep();
+protected:
+ //from CTGraphicsStep
+ virtual CTGraphicsBase* CreateTestL();
+ };
+
+_LIT(KTEventTestStep,"TEventTest");
+
+
+#endif