void PinchGestureProcessor::Process( const Integration::PinchGestureEvent& pinchEvent ) { switch ( pinchEvent.state ) { case Gesture::Started: { // The pinch gesture should only be sent to the gesture detector which first received it so that // it can be told when the gesture ends as well. mCurrentPinchEmitters.clear(); ResetActor(); HitTestAlgorithm::Results hitTestResults; if( HitTest( mStage, pinchEvent.centerPoint, hitTestResults ) ) { // Record the current render-task for Screen->Actor coordinate conversions mCurrentRenderTask = hitTestResults.renderTask; PinchEventFunctor functor( pinchEvent, *this ); // Sets mCurrentGesturedActor GestureDetectorContainer gestureDetectors; UpCastContainer<PinchGestureDetector>( mGestureDetectors, gestureDetectors ); ProcessAndEmit( hitTestResults, gestureDetectors, functor ); } break; } case Gesture::Continuing: case Gesture::Finished: case Gesture::Cancelled: { // Only send subsequent pinch gesture signals if we processed the pinch gesture when it started. // Check if actor is still touchable. if ( mCurrentGesturedActor ) { if ( mCurrentGesturedActor->IsHittable() && !mCurrentPinchEmitters.empty() && mCurrentRenderTask ) { // Ensure actor is still attached to the emitters, if it is not then remove the emitter. PinchGestureDetectorContainer::iterator endIter = std::remove_if( mCurrentPinchEmitters.begin(), mCurrentPinchEmitters.end(), IsNotAttachedFunctor(mCurrentGesturedActor) ); mCurrentPinchEmitters.erase( endIter, mCurrentPinchEmitters.end() ); if ( !mCurrentPinchEmitters.empty() ) { Vector2 actorCoords; RenderTask& renderTaskImpl( GetImplementation(mCurrentRenderTask) ); mCurrentGesturedActor->ScreenToLocal( renderTaskImpl, actorCoords.x, actorCoords.y, pinchEvent.centerPoint.x, pinchEvent.centerPoint.y ); EmitPinchSignal( Dali::Actor(mCurrentGesturedActor), mCurrentPinchEmitters, pinchEvent, actorCoords ); } else { // If we have no current emitters then clear pinched actor as well. ResetActor(); } // Clear current emitters if pinch gesture has ended or been cancelled. if ( pinchEvent.state == Gesture::Finished || pinchEvent.state == Gesture::Cancelled ) { mCurrentPinchEmitters.clear(); ResetActor(); } } else { mCurrentPinchEmitters.clear(); ResetActor(); } } break; } case Gesture::Clear: DALI_ASSERT_ALWAYS( false && "Incorrect state received from Integration layer: Clear\n" ); break; case Gesture::Possible: DALI_ASSERT_ALWAYS( false && "Incorrect state received from Integration layer: Possible\n" ); break; } }
void PanGestureProcessor::Process( const Integration::PanGestureEvent& panEvent ) { switch( panEvent.state ) { case Gesture::Possible: { mCurrentPanEmitters.clear(); ResetActor(); HitTestAlgorithm::Results hitTestResults; if( HitTest( mStage, panEvent.currentPosition, hitTestResults ) ) { SetActor( &GetImplementation( hitTestResults.actor ) ); mPossiblePanPosition = panEvent.currentPosition; } break; } case Gesture::Started: { if ( GetCurrentGesturedActor() ) { // The pan gesture should only be sent to the gesture detector which first received it so that // it can be told when the gesture ends as well. HitTestAlgorithm::Results hitTestResults; HitTest( mStage, mPossiblePanPosition, hitTestResults ); // Hit test original possible position... if ( hitTestResults.actor && ( GetCurrentGesturedActor() == &GetImplementation( hitTestResults.actor ) ) ) { // Record the current render-task for Screen->Actor coordinate conversions mCurrentRenderTask = hitTestResults.renderTask; // Set mCurrentPanEvent to use inside overridden methods called in ProcessAndEmit() mCurrentPanEvent = &panEvent; ProcessAndEmit( hitTestResults ); mCurrentPanEvent = NULL; } else { ResetActor(); mCurrentPanEmitters.clear(); } } break; } case Gesture::Continuing: case Gesture::Finished: case Gesture::Cancelled: { // Only send subsequent pan gesture signals if we processed the pan gesture when it started. // Check if actor is still touchable. Actor* currentGesturedActor = GetCurrentGesturedActor(); if ( currentGesturedActor ) { if ( currentGesturedActor->IsHittable() && !mCurrentPanEmitters.empty() && mCurrentRenderTask ) { GestureDetectorContainer outsideTouchesRangeEmitters; // Removes emitters that no longer have the actor attached // Also remove emitters whose touches are outside the range of the current pan event and add them to outsideTouchesRangeEmitters GestureDetectorContainer::iterator endIter = std::remove_if( mCurrentPanEmitters.begin(), mCurrentPanEmitters.end(), IsNotAttachedAndOutsideTouchesRangeFunctor(currentGesturedActor, panEvent.numberOfTouches, outsideTouchesRangeEmitters) ); mCurrentPanEmitters.erase( endIter, mCurrentPanEmitters.end() ); Vector2 actorCoords; if ( !outsideTouchesRangeEmitters.empty() || !mCurrentPanEmitters.empty() ) { currentGesturedActor->ScreenToLocal( GetImplementation( mCurrentRenderTask ), actorCoords.x, actorCoords.y, panEvent.currentPosition.x, panEvent.currentPosition.y ); // EmitPanSignal checks whether we have a valid actor and whether the container we are passing in has emitters before it emits the pan. EmitPanSignal( currentGesturedActor, outsideTouchesRangeEmitters, panEvent, actorCoords, Gesture::Finished, mCurrentRenderTask); EmitPanSignal( currentGesturedActor, mCurrentPanEmitters, panEvent, actorCoords, panEvent.state, mCurrentRenderTask); } if ( mCurrentPanEmitters.empty() ) { // If we have no emitters attached then clear pan actor as well. ResetActor(); } // Clear current gesture detectors if pan gesture has ended or been cancelled. if ( ( panEvent.state == Gesture::Finished ) || ( panEvent.state == Gesture::Cancelled ) ) { mCurrentPanEmitters.clear(); ResetActor(); } } else { mCurrentPanEmitters.clear(); ResetActor(); } } break; } case Gesture::Clear: DALI_ASSERT_ALWAYS( false && "Incorrect state received from Integration layer: Clear\n" ); break; } }