diff -r 000000000000 -r 2f259fa3e83a lafagnosticuifoundation/cone/tef/tconemultiptrstep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lafagnosticuifoundation/cone/tef/tconemultiptrstep.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,1246 @@ +// Copyright (c) 2008-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: +// + +#include "TConeMultiPtrStep.h" +#include "tconemultiptrtestappui.h" +#include "tconemultiptrconst.h" +#include + +// Global function for panic +void ConeTestPanic(TConeTestPanic aPanic) + { + User::Panic(_L("MultiPointerConeTest Panic"),aPanic); + } + + + +/** + CTestStep derived class which implements RunTestStepL. It creates CoEnv & AppUi objects. + Logic involved, RunTestStepL will call RunTestsL() which will create new control/s for each + test case and calls NextSetOfEventsL() which does testing of all different use cases + i,e by simulating the events and adding the events to a buffer. + Then RunTestStepL() starts the active scheduler, which will result in a call to + control's HandlePointerEventL, which will test expected event in buffer with actual event. +*/ +CConeMultiPtrTestAppUi::CConeMultiPtrTestAppUi(CTmsTestStep* aStep) +: CTestCoeAppUi(aStep) + { + } + + +void CConeMultiPtrTestAppUi::ConstructL() + { + RDebug::Print( _L(">CConeMultiPtrTestAppUi::ConstructL") ); + + CTestCoeAppUi::ConstructL(); + iNormalPointerCursorArea = iCoeEnv->WsSession().PointerCursorArea(); + User::LeaveIfError( HAL::Get(HALData::EPointerMaxPointers, iMaxPointers) ); + User::LeaveIfError( HAL::Get(HALData::EPointerNumberOfPointers, iNumberOfPointers) ); + User::LeaveIfError( HAL::Get(HALData::EPointer3DMaxPressure, iMaxPressure) ); + User::LeaveIfError( HAL::Get(HALData::EPointer3DPressureStep, iPressureStep) ); + User::LeaveIfError( HAL::Get(HALData::EPointer3DMaxProximity, iMaxProximity) ); + User::LeaveIfError( HAL::Get(HALData::EPointer3DProximityStep, iProximityStep) ); + + RDebug::Print( _L("CConeMultiPtrTestAppUi::ConstructL 1") ); + + iPressureNominal = iPressureStep * (iMaxPressure / (iPressureStep * 2) ); // Somewhere in the middle + iProximityNominal = iProximityStep * (iMaxProximity / (iProximityStep * 2) ); // Somewhere in the middle + + // Certain tests (MultiPointerGrab) can induce anomalous double-click key-modifiers. + // Therefore, disable by setting the double-click max interval to zero. + // This is restored in doTestStepPostambleL(). + RWsSession wsSession; + TTimeIntervalMicroSeconds32 interval; + TInt distance; + + User::LeaveIfError( wsSession.Connect() ); + wsSession.GetDoubleClickSettings( interval, distance); + wsSession.SetDoubleClick( 0, distance); + wsSession.Close(); + + + AutoTestManager().StartAutoTest(); + + RDebug::Print( _L("CConeMultiPtrTestAppUi::ConstructL>") ); + } + + +CConeMultiPtrTestAppUi::~CConeMultiPtrTestAppUi() + { + delete iControl; + } + + +// Function called for each new test case from CTestManager active object. +void CConeMultiPtrTestAppUi::RunTestStepL(TInt /*aStepNum*/) + { + if (!ConfigurationSupportsPointerEventTesting()) + { + INFO_PRINTF1(_L("Test skipped because config does not support pointer event testing")); + AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass); + return; + } + + switch(iTestCase) + { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + RunTestsL(); + break; + + default: + AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass); + break; + } + + if (iFailed) + { + TEST(EFalse); + iFailed=EFalse; + } + ++iTestCase; + } + + +/** + Function called for each new test case from RunTestStepL. + This creates control/s calls NextSetOfEventsL and starts activescheduler + */ +void CConeMultiPtrTestAppUi::RunTestsL() + { + iEventSet = 0; + iCoeEnv->WsSession().SetAutoFlush(ETrue); + + iControl = CMultiPtrTestControl::NewL( KMultiPtrTestControlParentPosition, TSize(300,200) ); + AddToStackL(iControl); + + iEventCount = 0; + TRAPD(err, NextSetOfEventsL()); + if (err != KErrNone) + { + INFO_PRINTF1( _L("ERROR INFO LOGGED IN epocwind.out") ); + + iFailed = ETrue; + return; + } + + // Start nested activescheduler + CActiveScheduler::Start(); + + TInt eventsLeft = iControl->EventsLeft(); + if (eventsLeft > 0) + { + INFO_PRINTF1( _L("ERROR INFO LOGGED IN epocwind.out") ); + + iFailed=ETrue; + } + + RemoveFromStack(iControl); + delete iControl; + iControl = NULL; + } + +/** + * Determine if the configuration supports pointer event testing. + * + * There are certain circumstances where we want to skip pointer event + * testing because we are simulating pointer events, and don't want to + * simulate a pointer event from an impossible co-ordinate. We'd rather + * just identify that there is no point in doing the test and skip over + * to the next test case. + * + * In particular, when a ROM configured with a digitiser is deployed on a + * Naviengine, with hardware configuration DIP switches which say that there + * is an external screen connected, then no touch pad is active. + * The base port under these conditions returns a digitiser area (0,0,0,0) + * + * @return ETrue if the configuration supports pointer event testing, otherwise + * return EFalse. + */ +TBool CConeMultiPtrTestAppUi::ConfigurationSupportsPointerEventTesting() const + { + if (iNormalPointerCursorArea.IsEmpty()) + { + return EFalse; + } + return ETrue; + } + + +/** + Simulates pointer event, by making use of UserSvr::AddEvent. Also takes a Z parameter. +*/ +void CConeMultiPtrTestAppUi::SimulatePointer(TRawEvent::TType aType, TInt aX, TInt aY, TInt aZ, TUint8 aPointerNumber) + { + __ASSERT_DEBUG(ConfigurationSupportsPointerEventTesting(), ConeTestPanic(EConePanicNoDigitiser)); + + TRawEvent rawEvent; + + rawEvent.Set(aType, aX, aY, aZ, aPointerNumber); + UserSvr::AddEvent(rawEvent); + } + +void CConeMultiPtrTestAppUi::SimulatePointerDownUp(TInt aX, TInt aY, TInt aZ, TUint8 aPointerNumber) + { + SimulatePointer(TRawEvent::EButton1Down, aX, aY, aZ, aPointerNumber); + SimulatePointer(TRawEvent::EButton1Up, aX, aY, aZ, aPointerNumber); + } + + +void CConeMultiPtrTestAppUi::AddExpectedPointer( TAdvancedPointerEvent::TType aType, TPoint aPos, TInt aZ, TUint8 aPointerNumber, TInt /*Handle*/ ) + { + TWsEvent event; + TPoint3D point3D; + + point3D.iX = aPos.iX; + point3D.iY = aPos.iY; + point3D.iZ = aZ; + + // Note: this setter does not initialise the parent-position parameter. + // Note: The modifier value is or'd in, as it is a bit-field. The TAdvancedPointerEvent Init()function + // should initialise it to EModifierAdvancedPointerEvent. + event.InitAdvancedPointerEvent( aType, 0, point3D, aPointerNumber ); + event.Pointer()->iParentPosition.SetXY( KMultiPtrTestControlParentPosition.iX, KMultiPtrTestControlParentPosition.iY ); + + iControl->AddExpectedEvent( *event.Pointer() ); + } + + +void CConeMultiPtrTestAppUi::AddExpectedPointerDownUp(TPoint aPos, TInt aZ, TUint8 aPointerNumber) + { + // Pointer position is with respect to the window's Top Left position + // Here we may want to write a function which will set sent position with respect to control/window + // on which we are simulating the events. + aPos -= iControl->Position(); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, aPos, aZ, aPointerNumber ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, aPos, aZ, aPointerNumber ); + } + + +/** + once all the events for a given sub test are tested. So that next subtest case can proceed with it. + */ +void CConeMultiPtrTestAppUi::NextSetOfEventsL() + { + + switch(iTestCase) + { + + case 0: + SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0002")); + MultiPointerEventsL(); + RecordTestResultL(); + break; + + case 1: + SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0006")); + PressureAndProximityL(); + RecordTestResultL(); + break; + + case 2: + SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0008")); + MoveAndDragL(); + RecordTestResultL(); + break; + + case 3: + SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0016")); + MoveAndOutOfRangeL(); + RecordTestResultL(); + break; + + case 4: + SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0018")); + PointerNumberOutOfRangeL(); + RecordTestResultL(); + break; + + case 5: + SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0020")); + MultiPointerCaptureL(); + RecordTestResultL(); + break; + + case 6: + SetTestStepID(_L("UIF-WSERV-ADVANCEDPOINTER-0022")); + MultiPointerGrabL(); + RecordTestResultL(); + CloseTMSGraphicsStep(); + break; + + default: + ConeTestPanic(EConeTestPanicWrongTest); + break; + } + + } + + +/** +@SYMTestCaseID UIF-WSERV-ADVANCEDPOINTER-0002 +@SYMPREQ PREQ1226 +@SYMTestType UT +@SYMTestPriority Critical +@SYMTestStatus Implemented +@SYMTestCaseDesc Multi-touch pointer events in Cone. +@SYMTestActions +@SYMTestExpectedResults The received events should match the simulated raw events. +*/ +void CConeMultiPtrTestAppUi::MultiPointerEventsL() + { + INFO_PRINTF1( _L(">MultiPointerEventsL") ); + RDebug::Print( _L(">MultiPointerEventsL") ); + + if( iNumberOfPointers <= 1 ) + { + User::Leave( KErrNotSupported ); + } + + switch( iEventSet++ ) + { + case 0: + { + INFO_PRINTF1( _L("MultiPointerEventsL case 0") ); + + TPoint ptrPos( 60, 60 ); + TInt z = iPressureNominal; + TInt i = 0; + + for(; i < iNumberOfPointers; i++ ) + { + ptrPos.iX += KMultiPtrTestCoOrdinateIncrement; + ptrPos.iY += KMultiPtrTestCoOrdinateIncrement; + + SimulatePointerDownUp( ptrPos.iX, ptrPos.iY, z, i ); + AddExpectedPointerDownUp( ptrPos, z, i ); + } + + } + break; + + default: + { + CActiveScheduler::Stop(); + iEventSet = 0; + INFO_PRINTF1( _L("MultiPointerEventsL STOP\n") ); + RDebug::Print( _L("MultiPointerEventsL STOP") ); + RDebug::Print( _L("") ); + } + break; + } + + } + + +/** +@SYMTestCaseID UIF-WSERV-ADVANCEDPOINTER-0006 +@SYMPREQ PREQ1226 +@SYMTestType UT +@SYMTestPriority Critical +@SYMTestStatus Implemented +@SYMTestCaseDesc To check events received by the control (from different pointers) + have pressure and proximity and move events in them. +@SYMTestActions +@SYMTestExpectedResults Simulated events are correctly conveyed. +*/ +void CConeMultiPtrTestAppUi::PressureAndProximityL() + { + INFO_PRINTF1( _L(">PressureAndProximityL") ); + RDebug::Print( _L(">PressureAndProximityL") ); + + if( iNumberOfPointers <= 1 ) + { + User::Leave( KErrNotSupported ); + } + + const TInt KPressureProximityInitialX = 60; + const TInt KPressureProximityInitialY = 60; + TPoint ptrPos( KPressureProximityInitialX, KPressureProximityInitialY ); + TPoint incPoint( KMultiPtrTestCoOrdinateIncrement, KMultiPtrTestCoOrdinateIncrement ); + + iControl->SetDrags(); + + switch( iEventSet++ ) + { + case 0: + { + INFO_PRINTF1( _L("PressureAndProximityL case 0") ); + RDebug::Print( _L("PressureAndProximityL case 0") ); + // Two pointers. Some pressure. Position is wrt the screen + SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, iPressureNominal, KMultiPtrTestPointerNumberLowest ); + SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, (iPressureNominal + iPressureStep), KMultiPtrTestPointerNumberLowest + 1 ); + // Reported position is wrt the control. + ptrPos -= iControl->Position(); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, ptrPos, iPressureNominal, KMultiPtrTestPointerNumberLowest ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, ptrPos, (iPressureNominal + iPressureStep), KMultiPtrTestPointerNumberLowest + 1 ); + } + break; + + case 1: + { + INFO_PRINTF1( _L("PressureAndProximityL case 1") ); + RDebug::Print( _L("PressureAndProximityL case 1") ); + // Two pointers. Max pressure. Position is wrt the screen + ptrPos += incPoint; + SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, iMaxPressure, KMultiPtrTestPointerNumberLowest ); + SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, iMaxPressure, KMultiPtrTestPointerNumberLowest + 1 ); + // Reported position is wrt the control. + ptrPos -= iControl->Position(); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, ptrPos, iMaxPressure, KMultiPtrTestPointerNumberLowest ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, ptrPos, iMaxPressure, KMultiPtrTestPointerNumberLowest + 1 ); + } + break; + + case 2: + { + INFO_PRINTF1( _L("PressureAndProximityL case 2") ); + RDebug::Print( _L("PressureAndProximityL case 2") ); + // Two pointers. Some proximity plus pointer-move events. + //Differentiate ptr no's so WServe does not translate to EDrag because of the above button-down events. + ptrPos += incPoint; + SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, iProximityNominal, KMultiPtrTestPointerNumberLowest + 2 ); + SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest + 3 ); + + ptrPos -= iControl->Position(); + AddExpectedPointer( TAdvancedPointerEvent::EMove, ptrPos, iProximityNominal, KMultiPtrTestPointerNumberLowest + 2 ); + AddExpectedPointer( TAdvancedPointerEvent::EMove, ptrPos, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest + 3 ); + } + break; + + case 3: + { + INFO_PRINTF1( _L("PressureAndProximityL case 3") ); + RDebug::Print( _L("PressureAndProximityL case 3") ); + // Two pointers. Max proximity plus pointer-move events. + ptrPos += incPoint; + SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, iMaxProximity, KMultiPtrTestPointerNumberLowest + 2 ); + SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, iMaxProximity, KMultiPtrTestPointerNumberLowest + 3 ); + + ptrPos -= iControl->Position(); + AddExpectedPointer( TAdvancedPointerEvent::EMove, ptrPos, iMaxProximity, KMultiPtrTestPointerNumberLowest + 2 ); + AddExpectedPointer( TAdvancedPointerEvent::EMove, ptrPos, iMaxProximity, KMultiPtrTestPointerNumberLowest + 3 ); + } + break; + + default: + { + INFO_PRINTF1( _L("PressureAndProximityL STOP\n") ); + RDebug::Print( _L("PressureAndProximityL STOP") ); + RDebug::Print( _L("") ); + + CActiveScheduler::Stop(); + iEventSet = 0; + } + break; + } + + } + + +/** +@SYMTestCaseID UIF-WSERV-ADVANCEDPOINTER-0008 +@SYMPREQ PREQ1226 +@SYMTestType UT +@SYMTestPriority Critical +@SYMTestStatus Implemented +@SYMTestCaseDesc To check the Control receives move and drags from different pointers + and that moves are delivered as moves, or translated to drags + dependent upon whether the pointer is up or down. +@SYMTestActions +@SYMTestExpectedResults The received events must match the simulated raw events. Moves being + translated to drags in the button-down state. +*/ +void CConeMultiPtrTestAppUi::MoveAndDragL() + { + INFO_PRINTF1( _L(">MoveAndDragL") ); + RDebug::Print( _L(">MoveAndDragL") ); + + if( iNumberOfPointers <= 1 ) + { + User::Leave( KErrNotSupported ); + } + + const TInt KMoveAndDragInitialX = 100; + const TInt KMoveAndDragInitialY = 100; + TPoint ptrPos( KMoveAndDragInitialX, KMoveAndDragInitialY ); + TPoint incPoint( KMultiPtrTestCoOrdinateIncrement, KMultiPtrTestCoOrdinateIncrement ); + TPoint exPos( ptrPos - iControl->Position() ); // The initial expected position adjusted for the control's offset + + iControl->SetDrags(); + + switch( iEventSet++ ) + { + case 0: + { + INFO_PRINTF1( _L("MoveAndDragL case 0") ); + RDebug::Print( _L("MoveAndDragL case 0") ); + + // Anomalous: Send button-up so that EPointerMove -> EMove + SimulatePointer( TRawEvent::EButton1Up, ptrPos.iX, ptrPos.iY, iProximityNominal, KMultiPtrTestPointerNumberLowest ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, exPos, iProximityNominal, KMultiPtrTestPointerNumberLowest ); + + ptrPos += incPoint; + exPos +=incPoint; + SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest ); + AddExpectedPointer( TAdvancedPointerEvent::EMove, exPos, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest ); + // Send button-down so that EPointerMove -> EDrag + SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, exPos, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest ); + + ptrPos += incPoint; + exPos +=incPoint; + SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, (iProximityNominal + (2 * iProximityStep)), KMultiPtrTestPointerNumberLowest ); + AddExpectedPointer( TAdvancedPointerEvent::EDrag, exPos, (iProximityNominal + (2 * iProximityStep)), KMultiPtrTestPointerNumberLowest ); + // Anomalous: Send button-up so that EPointerMove -> EMove + SimulatePointer( TRawEvent::EButton1Up, ptrPos.iX, ptrPos.iY, iProximityNominal, KMultiPtrTestPointerNumberLowest ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, exPos, iProximityNominal, KMultiPtrTestPointerNumberLowest ); + + ptrPos += incPoint; + exPos +=incPoint; + SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest ); + AddExpectedPointer( TAdvancedPointerEvent::EMove, exPos, (iProximityNominal + iProximityStep), KMultiPtrTestPointerNumberLowest ); + } + break; + case 1: + { + INFO_PRINTF1( _L("MoveAndDragL case 1") ); + RDebug::Print( _L("MoveAndDragL case 1") ); + // Replicate case 0 for another pointer number. + const TInt pointerNumber = KMultiPtrTestPointerNumberLowest + 1; + + // Anomalous: Send button-up so that EPointerMove -> EMove + SimulatePointer( TRawEvent::EButton1Up, ptrPos.iX, ptrPos.iY, iProximityNominal, pointerNumber ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, exPos, iProximityNominal, pointerNumber ); + + ptrPos += incPoint; + exPos +=incPoint; + SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, (iProximityNominal + iProximityStep), pointerNumber ); + AddExpectedPointer( TAdvancedPointerEvent::EMove, exPos, (iProximityNominal + iProximityStep), pointerNumber ); + // Send button-down so that EPointerMove -> EDrag + SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, (iProximityNominal + iProximityStep), pointerNumber ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, exPos, (iProximityNominal + iProximityStep), pointerNumber ); + + ptrPos += incPoint; + exPos +=incPoint; + SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, (iProximityNominal + (2 * iProximityStep)), pointerNumber ); + AddExpectedPointer( TAdvancedPointerEvent::EDrag, exPos, (iProximityNominal + (2 * iProximityStep)), pointerNumber ); + // Anomalous: Send button-up so that EPointerMove -> EMove + SimulatePointer( TRawEvent::EButton1Up, ptrPos.iX, ptrPos.iY, iProximityNominal, pointerNumber ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, exPos, iProximityNominal, pointerNumber ); + + ptrPos += incPoint; + exPos +=incPoint; + SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, (iProximityNominal + iProximityStep), pointerNumber ); + AddExpectedPointer( TAdvancedPointerEvent::EMove, exPos, (iProximityNominal + iProximityStep), pointerNumber ); + } + break; + + case 2: + { + INFO_PRINTF1( _L("MoveAndDragL case 2") ); + RDebug::Print( _L("MoveAndDragL case 2") ); + // Discriminate the pointers' attributes by position and prox/press. + TPoint ptr0Pos( ptrPos ); + TPoint ptr0ExpectedPos( ptrPos - iControl->Position() ); + TPoint ptr1Pos( ptrPos += incPoint ); + TPoint ptr1ExpectedPos( ptr1Pos - iControl->Position() ); + TInt pointer0Proximity = iProximityNominal; + TInt pointer1Proximity = iProximityNominal + iProximityStep; + TInt pointer0Pressure = iPressureNominal; + TInt pointer1Pressure = iPressureNominal + iPressureStep; + + const TInt pointerZero = KMultiPtrTestPointerNumberLowest; + const TInt pointerOne = KMultiPtrTestPointerNumberLowest + 1; + + // Anomalous: Send button-up so that EPointerMove -> EMove + SimulatePointer( TRawEvent::EButton1Up, ptr0Pos.iX, ptr0Pos.iY, pointer0Proximity, pointerZero ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, ptr0ExpectedPos, pointer0Proximity, pointerZero ); + + SimulatePointer( TRawEvent::EButton1Up, ptr1Pos.iX, ptr1Pos.iY, pointer1Proximity, pointerOne ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, ptr1ExpectedPos, pointer1Proximity, pointerOne ); + + + ptr0Pos += incPoint; + ptr1Pos +=incPoint; + ptr0ExpectedPos +=incPoint; + ptr1ExpectedPos +=incPoint; + pointer0Proximity += iProximityStep; + pointer1Proximity += iProximityStep; + + SimulatePointer( TRawEvent::EPointerMove, ptr0Pos.iX, ptr0Pos.iY, pointer0Proximity, pointerZero ); + AddExpectedPointer( TAdvancedPointerEvent::EMove, ptr0ExpectedPos, pointer0Proximity, pointerZero ); + + SimulatePointer( TRawEvent::EPointerMove, ptr1Pos.iX, ptr1Pos.iY, pointer1Proximity, pointerOne ); + AddExpectedPointer( TAdvancedPointerEvent::EMove, ptr1ExpectedPos, pointer1Proximity, pointerOne ); + + RDebug::Print( _L("Button down") ); + // Send button-down so that EPointerMove -> EDrag + SimulatePointer( TRawEvent::EButton1Down, ptr1Pos.iX, ptr1Pos.iY, pointer0Pressure, pointerZero ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, ptr1ExpectedPos, pointer0Pressure, pointerZero ); + + SimulatePointer( TRawEvent::EButton1Down, ptr1Pos.iX, ptr1Pos.iY, pointer1Pressure, pointerOne ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, ptr1ExpectedPos, pointer1Pressure, pointerOne ); + + + ptr0Pos += incPoint; + ptr1Pos +=incPoint; + ptr0ExpectedPos +=incPoint; + ptr1ExpectedPos +=incPoint; + pointer0Pressure += iPressureStep; + pointer1Pressure += iPressureStep; + + // Perform moves in anticipation of drags. + SimulatePointer( TRawEvent::EPointerMove, ptr0Pos.iX, ptr0Pos.iY, pointer0Pressure, pointerZero ); + AddExpectedPointer( TAdvancedPointerEvent::EDrag, ptr0ExpectedPos, pointer0Pressure, pointerZero ); + + SimulatePointer( TRawEvent::EPointerMove, ptr1Pos.iX, ptr1Pos.iY, pointer1Pressure, pointerOne ); + AddExpectedPointer( TAdvancedPointerEvent::EDrag, ptr1ExpectedPos, pointer1Pressure, pointerOne ); + + + ptr0Pos += incPoint; + ptr1Pos +=incPoint; + ptr0ExpectedPos +=incPoint; + ptr1ExpectedPos +=incPoint; + pointer0Proximity += iProximityStep; + pointer1Proximity += iProximityStep; + + // Send button-up so that EPointerMove -> EMove + SimulatePointer( TRawEvent::EButton1Up, ptr0Pos.iX, ptr0Pos.iY, pointer0Proximity, pointerZero ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, ptr0ExpectedPos, pointer0Proximity, pointerZero ); + + SimulatePointer( TRawEvent::EButton1Up, ptr1Pos.iX, ptr1Pos.iY, pointer1Proximity, pointerOne ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, ptr1ExpectedPos, pointer1Proximity, pointerOne ); + + + ptr0Pos += incPoint; + ptr1Pos +=incPoint; + ptr0ExpectedPos +=incPoint; + ptr1ExpectedPos +=incPoint; + + SimulatePointer( TRawEvent::EPointerMove, ptr0Pos.iX, ptr0Pos.iY, pointer0Proximity, pointerZero ); + AddExpectedPointer( TAdvancedPointerEvent::EMove, ptr0ExpectedPos, pointer0Proximity, pointerZero ); + + SimulatePointer( TRawEvent::EPointerMove, ptr1Pos.iX, ptr1Pos.iY, pointer1Proximity, pointerOne ); + AddExpectedPointer( TAdvancedPointerEvent::EMove, ptr1ExpectedPos, pointer1Proximity, pointerOne ); + } + break; + default: + { + INFO_PRINTF1( _L("MoveAndDragL STOP\n") ); + RDebug::Print( _L("MoveAndDragL STOP") ); + RDebug::Print( _L("") ); + + CActiveScheduler::Stop(); + iEventSet = 0; + } + break; + } + + } + + +/** +@SYMTestCaseID UIF-WSERV-ADVANCEDPOINTER-0016 +@SYMPREQ PREQ1226 +@SYMTestType UT +@SYMTestPriority Critical +@SYMTestStatus Implemented +@SYMTestCaseDesc Out of range and move events in Cone. +@SYMTestActions Simulate TRawEvent::EMove from 2 pointers. + Simulate TRawEvent::EPointer3DOutOfRange from 2 pointers. + cf GRAPHICS-WSERV-ADVANCEDPOINTER-0042 +@SYMTestExpectedResults The received events must match the events added to buffer. +*/ +void CConeMultiPtrTestAppUi::MoveAndOutOfRangeL() + { + INFO_PRINTF1( _L(">MoveAndOutOfRangeL") ); + RDebug::Print( _L(">MoveAndOutOfRangeL") ); + + if( iNumberOfPointers <= 1 ) + { + User::Leave( KErrNotSupported ); + } + + iControl->SetDrags(); + + switch( iEventSet++ ) + { + case 0: + { + INFO_PRINTF1( _L("MoveAndOutOfRangeL case 0") ); + RDebug::Print( _L("MoveAndOutOfRangeL STOP\n") ); + const TInt KPressureProximityInitialX = 60; + const TInt KPressureProximityInitialY = 60; + TPoint ptrPos( KPressureProximityInitialX, KPressureProximityInitialY ); + TPoint incPoint( KMultiPtrTestCoOrdinateIncrement, KMultiPtrTestCoOrdinateIncrement ); + + // Two pointers. Move events + SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, iProximityNominal, KMultiPtrTestPointerNumberLowest ); + SimulatePointer( TRawEvent::EPointerMove, ptrPos.iX, ptrPos.iY, iProximityNominal, KMultiPtrTestPointerNumberLowest + 1 ); + ptrPos -= iControl->Position(); + AddExpectedPointer( TAdvancedPointerEvent::EMove, TPoint(ptrPos.iX, ptrPos.iY), iProximityNominal, KMultiPtrTestPointerNumberLowest ); + AddExpectedPointer( TAdvancedPointerEvent::EMove, TPoint(ptrPos.iX, ptrPos.iY), iProximityNominal, KMultiPtrTestPointerNumberLowest + 1 ); + + // Reset the position. + ptrPos.SetXY( KPressureProximityInitialX, KPressureProximityInitialY ); + SimulatePointer( TRawEvent::EPointer3DOutOfRange, ptrPos.iX, ptrPos.iY, iProximityNominal, KMultiPtrTestPointerNumberLowest ); + SimulatePointer( TRawEvent::EPointer3DOutOfRange, ptrPos.iX, ptrPos.iY, iProximityNominal, KMultiPtrTestPointerNumberLowest + 1 ); + ptrPos -= iControl->Position(); + AddExpectedPointer( TAdvancedPointerEvent::EOutOfRange, TPoint(ptrPos.iX, ptrPos.iY), iProximityNominal, KMultiPtrTestPointerNumberLowest ); + AddExpectedPointer( TAdvancedPointerEvent::EOutOfRange, TPoint(ptrPos.iX, ptrPos.iY), iProximityNominal, KMultiPtrTestPointerNumberLowest + 1 ); + + } + break; + + default: + { + INFO_PRINTF1( _L("MoveAndOutOfRangeL STOP\n") ); + RDebug::Print( _L("MoveAndOutOfRangeL STOP\n") ); + RDebug::Print( _L("") ); + + CActiveScheduler::Stop(); + iEventSet = 0; + } + break; + } + + } + + +/** +@SYMTestCaseID UIF-WSERV-ADVANCEDPOINTER-0018 +@SYMPREQ PREQ1226 +@SYMTestType UT +@SYMTestPriority Critical +@SYMTestStatus Implemented +@SYMTestCaseDesc Check cone ignores pointer numbers greater than EPointerNumberOfPointers but less than EPointerMaxPointers. +@SYMTestActions +@SYMTestExpectedResults The first reported event should be the first legal one. The illegally-numbered-pointer event should be ignored. +*/ +void CConeMultiPtrTestAppUi::PointerNumberOutOfRangeL() + { + INFO_PRINTF1( _L(">PointerNumberOutOfRange") ); + RDebug::Print( _L(">PointerNumberOutOfRange") ); + + // Compose an illegitimately numbered pointer. (Pointers are numbered from 0) + const TInt illegitimatePointerNumber = iNumberOfPointers; // One more than the maximally-numbered pointer + const TInt nominalPressureOne = iPressureNominal; + const TInt nominalPressureTwo = iPressureNominal + iPressureStep; + + if( (iNumberOfPointers <= 1) + || (illegitimatePointerNumber >= iMaxPointers) ) + { + User::Leave( KErrNotSupported ); + } + + switch( iEventSet++ ) + { + case 0: + { + INFO_PRINTF1( _L("PointerNumberOutOfRange case 0") ); + RDebug::Print( _L("PointerNumberOutOfRange case 0") ); + + const TInt KPointerNumberOutOfRangeInitialX = 60; + const TInt KPointerNumberOutOfRangeInitialY = 60; + TPoint ptrPos( KPointerNumberOutOfRangeInitialX, KPointerNumberOutOfRangeInitialY ); + TPoint incPoint( KMultiPtrTestCoOrdinateIncrement, KMultiPtrTestCoOrdinateIncrement ); + // Generate a button-down event from an illegally numbered pointer + SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, nominalPressureOne, illegitimatePointerNumber ); + // Generate a legal event. Differentiate the event in terms of position and pressure also. + ptrPos += incPoint; + SimulatePointer( TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, nominalPressureTwo, (iNumberOfPointers - 1) ); + ptrPos -= iControl->Position(); // Compensate for co-ordinate-within-control. + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, TPoint(ptrPos.iX, ptrPos.iY), nominalPressureTwo, (iNumberOfPointers - 1) ); + } + break; + + default: + { + INFO_PRINTF1( _L("PointerNumberOutOfRange STOP\n") ); + RDebug::Print( _L("PointerNumberOutOfRange STOP") ); + RDebug::Print( _L("") ); + + CActiveScheduler::Stop(); + iEventSet = 0; + } + break; + } + + } + + +/** +@SYMTestCaseID UIF-WSERV-ADVANCEDPOINTER-0020 +@SYMPREQ PREQ1226 +@SYMTestType UT +@SYMTestPriority Critical +@SYMTestStatus Implemented +@SYMTestCaseDesc Check that Cone supports 'capture' in the case of multi-pointer events. +@SYMTestActions Set the test-control to be capturing. Simulate EButton1Down from 2 pointers outside the control area. + Then simulate EButton1Down from a third pointer inside the control. + cf GRAPHICS-WSERV-ADVANCEDPOINTER-0040 +@SYMTestExpectedResults Pointer events inside and outside the control are delivered to the control. +*/ +void CConeMultiPtrTestAppUi::MultiPointerCaptureL() + { + INFO_PRINTF1( _L(">MultiPointerCaptureL") ); + RDebug::Print( _L(">MultiPointerCaptureL") ); + + if( iNumberOfPointers <= 1 ) + { + User::Leave( KErrNotSupported ); + } + + switch( iEventSet++ ) + { + case 0: + { + INFO_PRINTF1( _L("MultiPointerCaptureL case 0") ); + RDebug::Print( _L("MultiPointerCaptureL case 0") ); + + TPoint decPoint( KMultiPtrTestCoOrdinateDecrementSmall, KMultiPtrTestCoOrdinateDecrementSmall ); + TPoint incPoint( KMultiPtrTestCoOrdinateIncrementSmall, KMultiPtrTestCoOrdinateIncrementSmall ); + + TPoint outsidePoint_1( iControl->Position() ); + outsidePoint_1 -= decPoint; + // The negative co-ordinates supplied to the control + TPoint outsideResult_1( outsidePoint_1 - iControl->Position() ); + + TPoint outsidePoint_2( outsidePoint_1 ); + outsidePoint_2 -= decPoint; + // The negative co-ordinates supplied to the control + TPoint outsideResult_2( outsidePoint_2 - iControl->Position() ); + + TPoint insidePoint_1( iControl->Position() ); + insidePoint_1 += incPoint; + TPoint insideResult_1( insidePoint_1 - iControl->Position() ); + + const TInt nominalPressureOne = iPressureNominal; + const TInt nominalPressureTwo = iPressureNominal + iPressureStep; + + iControl->SetGloballyCapturing( ETrue ); + iControl->SetPointerCapture( ETrue ); + + TInt i = 2; + TInt first = 0; + TInt second = 0; + TInt third = 0; + + for(; i < iNumberOfPointers; i++ ) + { + first = i - 2; + second = i - 1; + third = i; + + // First pointer. Outside the control. + SimulatePointer( TRawEvent::EButton1Down, outsidePoint_1.iX, outsidePoint_1.iY, nominalPressureOne, first ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, outsideResult_1, nominalPressureOne, first ); + // Next pointer. Outside the control. + SimulatePointer( TRawEvent::EButton1Down, outsidePoint_2.iX, outsidePoint_2.iY, nominalPressureOne, second ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, outsideResult_2, nominalPressureOne, second ); + // Next pointer. Inside the control. + SimulatePointer( TRawEvent::EButton1Down, insidePoint_1.iX, insidePoint_1.iY, nominalPressureTwo, third ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, insideResult_1, nominalPressureTwo, third ); + + // Discriminate the next suite of events by co-ordinate + outsidePoint_1 -= decPoint; + outsideResult_1 -= decPoint; + + outsidePoint_2 -= decPoint; + outsideResult_2 -= decPoint; + + insidePoint_1 += incPoint; + insideResult_1 += incPoint; + } + + } + break; + + default: + { + INFO_PRINTF1( _L("MultiPointerCaptureL STOP\n") ); + RDebug::Print( _L("MultiPointerCaptureL STOP") ); + RDebug::Print( _L("") ); + + CActiveScheduler::Stop(); + iEventSet = 0; + } + break; + } + + } + + + + +/** +@SYMTestCaseID UIF-WSERV-ADVANCEDPOINTER-0022 +@SYMPREQ PREQ1226 +@SYMTestType UT +@SYMTestPriority Critical +@SYMTestStatus Implemented +@SYMTestCaseDesc Check that Cone supports 'grabbing' in the case of multi-pointer events. + Ensure that events outside the control are not grabbed if grabbing has not been enabled. +@SYMTestActions +@SYMTestExpectedResults Events outside the control are supplied to the control only when grabbing has been enabled. +*/ +void CConeMultiPtrTestAppUi::MultiPointerGrabL() + { + INFO_PRINTF1( _L(">MultiPointerGrabL") ); + RDebug::Print( _L(">MultiPointerGrabL") ); + + if( iNumberOfPointers <= 1 ) + { + User::Leave( KErrNotSupported ); + } + + + switch( iEventSet++ ) + { + case 0: + { + // Events outside the control are not reported when grabbing has not been enabled + INFO_PRINTF1( _L("MultiPointerGrabL case 0") ); + RDebug::Print( _L("MultiPointerGrabL case 0") ); + + TPoint decPoint( KMultiPtrTestCoOrdinateDecrement, KMultiPtrTestCoOrdinateDecrement ); + TPoint incPoint( KMultiPtrTestCoOrdinateIncrement, KMultiPtrTestCoOrdinateIncrement ); + + TPoint outsidePoint_1( iControl->Position() ); + outsidePoint_1 -= decPoint; + TPoint reportedOutsidePoint_1( outsidePoint_1 ); + reportedOutsidePoint_1 -= iControl->Position(); // Compensate for the reported position within the control. + + TPoint outsidePoint_2( outsidePoint_1 ); + outsidePoint_2 -= decPoint; + TPoint reportedOutsidePoint_2( outsidePoint_2 ); + reportedOutsidePoint_2 -= iControl->Position(); // Compensate for the reported position within the control. + + TPoint insidePoint_1( iControl->Position() ); + insidePoint_1 += incPoint; // Place the co-ordinates within the control. + TPoint reportedInsidePoint_1( insidePoint_1 ); + reportedInsidePoint_1 -= iControl->Position(); // Compensate for the reported position within the control. + + TPoint insidePoint_2( insidePoint_1 ); + insidePoint_2 += incPoint; // differentiate from insidePoint_1. + TPoint reportedInsidePoint_2( insidePoint_2 ); + reportedInsidePoint_2 -= iControl->Position(); // Compensate for the reported position within the control. + + const TInt nominalPressureOne = iPressureNominal; + const TInt nominalPressureTwo = iPressureNominal + iPressureStep; + const TInt nominalProximityOne = iProximityNominal; + const TInt nominalProximityTwo = iProximityNominal + iProximityStep; + + // ****** Grabbing not enabled + iControl->SetDrags(); + TInt i = 1; + + for(; i < iNumberOfPointers; i++ ) + { + // Only events within the control should be reported. + + // First pointer down. + SimulatePointer( TRawEvent::EButton1Down, insidePoint_1.iX, insidePoint_1.iY, nominalPressureOne, i - 1 ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, reportedInsidePoint_1, nominalPressureOne, i - 1 ); + // First button move outside. + SimulatePointer( TRawEvent::EPointerMove, outsidePoint_1.iX, outsidePoint_1.iY, nominalPressureOne, i - 1 ); + // First button up + SimulatePointer( TRawEvent::EButton1Up, outsidePoint_1.iX, outsidePoint_1.iY, nominalProximityOne, i - 1 ); + + // Second pointer down. + SimulatePointer( TRawEvent::EButton1Down, insidePoint_2.iX, insidePoint_2.iY, nominalPressureTwo, i ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, reportedInsidePoint_2, nominalPressureTwo, i ); + // Second button move outside. + SimulatePointer( TRawEvent::EPointerMove, outsidePoint_2.iX, outsidePoint_2.iY, nominalPressureTwo, i ); + // Second button up + SimulatePointer( TRawEvent::EButton1Up, outsidePoint_2.iX, outsidePoint_2.iY, nominalProximityTwo, i ); + } + + } + break; + + case 1: + { + // Events outside the control should be reported to the control. + + // Pointer down, drag outside control, pointer up. Next pointer down... + INFO_PRINTF1( _L("MultiPointerGrabL case 1") ); + RDebug::Print( _L("MultiPointerGrabL case 1") ); + + TPoint decPoint( KMultiPtrTestCoOrdinateDecrement, KMultiPtrTestCoOrdinateDecrement ); + TPoint incPoint( KMultiPtrTestCoOrdinateIncrement, KMultiPtrTestCoOrdinateIncrement ); + + TPoint outsidePoint_1( iControl->Position() ); + outsidePoint_1 -= decPoint; + TPoint reportedOutsidePoint_1( outsidePoint_1 ); + reportedOutsidePoint_1 -= iControl->Position(); // Compensate for the reported position within the control. + + TPoint outsidePoint_2( outsidePoint_1 ); + outsidePoint_2 -= decPoint; + TPoint reportedOutsidePoint_2( outsidePoint_2 ); + reportedOutsidePoint_2 -= iControl->Position(); // Compensate for the reported position within the control. + + TPoint insidePoint_1( iControl->Position() ); + insidePoint_1 += incPoint; // Place the co-ordinates within the control. + TPoint reportedInsidePoint_1( insidePoint_1 ); + reportedInsidePoint_1 -= iControl->Position(); // Compensate for the reported position within the control. + + TPoint insidePoint_2( insidePoint_1 ); + insidePoint_2 += incPoint; // differentiate from insidePoint_1. + TPoint reportedInsidePoint_2( insidePoint_2 ); + reportedInsidePoint_2 -= iControl->Position(); // Compensate for the reported position within the control. + + const TInt nominalPressureOne = iPressureNominal; + const TInt nominalPressureTwo = iPressureNominal + iPressureStep; + const TInt nominalProximityOne = iProximityNominal; + const TInt nominalProximityTwo = iProximityNominal + iProximityStep; + + iControl->SetGrabs(); + iControl->SetDrags(); + TInt i = 1; + + for(; i < iNumberOfPointers; i++ ) + { + // First pointer down. + SimulatePointer( TRawEvent::EButton1Down, insidePoint_1.iX, insidePoint_1.iY, nominalPressureOne, i - 1 ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, reportedInsidePoint_1, nominalPressureOne, i - 1 ); + // First button move outside. + SimulatePointer( TRawEvent::EPointerMove, outsidePoint_1.iX, outsidePoint_1.iY, nominalPressureOne, i - 1 ); + AddExpectedPointer( TAdvancedPointerEvent::EDrag, reportedOutsidePoint_1, nominalPressureOne, i - 1 ); + // First button up + SimulatePointer( TRawEvent::EButton1Up, outsidePoint_1.iX, outsidePoint_1.iY, nominalProximityOne, i - 1 ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, reportedOutsidePoint_1, nominalProximityOne, i - 1 ); + + // Second pointer down. + SimulatePointer( TRawEvent::EButton1Down, insidePoint_2.iX, insidePoint_2.iY, nominalPressureTwo, i ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, reportedInsidePoint_2, nominalPressureTwo, i ); + // Second button move outside. + SimulatePointer( TRawEvent::EPointerMove, outsidePoint_2.iX, outsidePoint_2.iY, nominalPressureTwo, i ); + AddExpectedPointer( TAdvancedPointerEvent::EDrag, reportedOutsidePoint_2, nominalPressureTwo, i ); + // Second button up + SimulatePointer( TRawEvent::EButton1Up, outsidePoint_2.iX, outsidePoint_2.iY, nominalProximityTwo, i ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, reportedOutsidePoint_2, nominalProximityTwo, i ); + } + + } + break; + + case 2: + { + // Events outside the control should be reported to the control. Interdigitate the events to ensure + // that the pointer numbers are discriminated correctly + + // Ptr dn, next ptr dn, 1st ptr drag outside , next ptr drag outside, 1st ptr up, next ptr up + INFO_PRINTF1( _L("MultiPointerGrabL case 2") ); + RDebug::Print( _L("MultiPointerGrabL case 2") ); + + TPoint decPoint( KMultiPtrTestCoOrdinateDecrement, KMultiPtrTestCoOrdinateDecrement ); + TPoint incPoint( KMultiPtrTestCoOrdinateIncrement, KMultiPtrTestCoOrdinateIncrement ); + + TPoint outsidePoint_1( iControl->Position() ); + outsidePoint_1 -= decPoint; + TPoint reportedOutsidePoint_1( outsidePoint_1 ); + reportedOutsidePoint_1 -= iControl->Position(); // Compensate for the reported position within the control. + + TPoint outsidePoint_2( outsidePoint_1 ); + outsidePoint_2 -= decPoint; + TPoint reportedOutsidePoint_2( outsidePoint_2 ); + reportedOutsidePoint_2 -= iControl->Position(); // Compensate for the reported position within the control. + + TPoint insidePoint_1( iControl->Position() ); + insidePoint_1 += incPoint; // Place the co-ordinates within the control. + TPoint reportedInsidePoint_1( insidePoint_1 ); + reportedInsidePoint_1 -= iControl->Position(); // Compensate for the reported position within the control. + + TPoint insidePoint_2( insidePoint_1 ); + insidePoint_2 += incPoint; // differentiate from insidePoint_1. + TPoint reportedInsidePoint_2( insidePoint_2 ); + reportedInsidePoint_2 -= iControl->Position(); // Compensate for the reported position within the control. + + const TInt nominalPressureOne = iPressureNominal; + const TInt nominalPressureTwo = iPressureNominal + iPressureStep; + const TInt nominalProximityOne = iProximityNominal; + const TInt nominalProximityTwo = iProximityNominal + iProximityStep; + + iControl->SetGrabs(); + iControl->SetDrags(); + TInt i = 1; + + for(; i < iNumberOfPointers; i++ ) + { + // First pointer down. + SimulatePointer( TRawEvent::EButton1Down, insidePoint_1.iX, insidePoint_1.iY, nominalPressureOne, i - 1 ); + // Second pointer down. + SimulatePointer( TRawEvent::EButton1Down, insidePoint_2.iX, insidePoint_2.iY, nominalPressureTwo, i ); + // First button move outside. + SimulatePointer( TRawEvent::EPointerMove, outsidePoint_1.iX, outsidePoint_1.iY, nominalPressureOne, i - 1 ); + // Second button move outside. + SimulatePointer( TRawEvent::EPointerMove, outsidePoint_2.iX, outsidePoint_2.iY, nominalPressureTwo, i ); + // First button up + SimulatePointer( TRawEvent::EButton1Up, outsidePoint_1.iX, outsidePoint_1.iY, nominalProximityOne, i - 1 ); + // Second button up + SimulatePointer( TRawEvent::EButton1Up, outsidePoint_2.iX, outsidePoint_2.iY, nominalProximityTwo, i ); + + // The corresponding anticipated events. + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, reportedInsidePoint_1, nominalPressureOne, i - 1 ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Down, reportedInsidePoint_2, nominalPressureTwo, i ); + + AddExpectedPointer( TAdvancedPointerEvent::EDrag, reportedOutsidePoint_1, nominalPressureOne, i - 1 ); + AddExpectedPointer( TAdvancedPointerEvent::EDrag, reportedOutsidePoint_2, nominalPressureTwo, i ); + + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, reportedOutsidePoint_1, nominalProximityOne, i - 1 ); + AddExpectedPointer( TAdvancedPointerEvent::EButton1Up, reportedOutsidePoint_2, nominalProximityTwo, i ); + } + + } + break; + default: + { + INFO_PRINTF1( _L("MultiPointerGrabL STOP\n") ); + RDebug::Print( _L("MultiPointerGrabL STOP") ); + RDebug::Print( _L("") ); + + CActiveScheduler::Stop(); + iEventSet = 0; + } + break; + + } + + } + + +// Stops the active scheduler and sets the flag to ETrue +void CConeMultiPtrTestAppUi::Failed() + { + CActiveScheduler::Stop(); + iFailed=ETrue; + } + + +/** + CTestStep derived class. It creates the control environment and App Ui class objects +*/ + void CTConeMultiPtrStep::ConstructConeMultiPtrAppL(CCoeEnv* aCoe) + { // runs inside a TRAP harness + aCoe->ConstructL(); + CConeMultiPtrTestAppUi* appUi=new(ELeave) CConeMultiPtrTestAppUi(this); + aCoe->SetAppUi(appUi); + aCoe->WsSession().SetDoubleClick(1000000,4); + appUi->ConstructL(); + } + + + CTConeMultiPtrStep::CTConeMultiPtrStep() + { + SetTestStepName(KTConeMultiPtrStep); + } + + + CTConeMultiPtrStep::~CTConeMultiPtrStep() + { + + } + + +/** +Testexecute loads testserver and creates CTConeMultiPtrStep object and calls +this function for each step in script file. +*/ +TVerdict CTConeMultiPtrStep::doTestStepL() + { + INFO_PRINTF1(_L("Test Started")); + + // Need to check if wserv is NGA or Non-NGA + // If NGA continue or else just return + RWsSession wsSession; + User::LeaveIfError(wsSession.Connect()); + if (wsSession.PreferredSurfaceConfigurationSize() == KErrNotSupported) + { + wsSession.Close(); + INFO_PRINTF1(_L("Tests should run only on NGA configuration. \n")); + SetTestStepResult(EPass); + return TestStepResult(); + } + wsSession.Close(); + + // Here check if the HAL configuration are correct if not then finish the test case + TInt maxPtr=-1; + TInt ret = HAL::Get(HALData::EPointerMaxPointers, maxPtr); + if (ret != KErrNone || maxPtr < 2 || maxPtr > 8) + { + INFO_PRINTF2(_L("Incorrect HAL configuration (MaxPointers=%d). \n"),maxPtr); + SetTestStepResult(EFail); + return TestStepResult(); + } + + PreallocateHALBuffer(); + + __UHEAP_MARK; + + CCoeEnv* coe = new(ELeave) CCoeEnv; + TRAPD(err, ConstructConeMultiPtrAppL(coe)); + + if (!err) + { + coe->ExecuteD(); + } + else + { + INFO_PRINTF1(_L("Failed to contruct ControlEnvironment")); + SetTestStepResult(EFail); + if (coe) + coe->DestroyEnvironment(); + } + REComSession::FinalClose(); + + __UHEAP_MARKEND; + + INFO_PRINTF1(_L("Test Finished")); + return TestStepResult(); + } + + +TVerdict CTConeMultiPtrStep::doTestStepPreambleL() + { + // Remember the double-click settings. + // Tests (may) adjust these values. + RWsSession wsSession; + User::LeaveIfError( wsSession.Connect() ); + + wsSession.GetDoubleClickSettings( iDoubleClickMaxInterval, iDoubleClickMaxDistance ); + wsSession.Close(); + + return CTestStep::doTestStepPreambleL(); + } + + +TVerdict CTConeMultiPtrStep::doTestStepPostambleL() + { + // Restore the original system-wide double-click settings. + RWsSession wsSession; + User::LeaveIfError( wsSession.Connect() ); + + wsSession.SetDoubleClick( iDoubleClickMaxInterval, iDoubleClickMaxDistance); + wsSession.Close(); + + return CTestStep::doTestStepPostambleL(); + }