void PinchGestureProcessor::RemoveGestureDetector( PinchGestureDetector* gestureDetector )
{
if ( !mCurrentPinchEmitters.empty() )
{
// Check if the removed detector was one that is currently being pinched and remove it from emitters.
PinchGestureDetectorContainer::iterator endIter = std::remove( mCurrentPinchEmitters.begin(), mCurrentPinchEmitters.end(), gestureDetector );
mCurrentPinchEmitters.erase( endIter, mCurrentPinchEmitters.end() );
// If we no longer have any emitters, then we should clear mCurrentGesturedActor as well
if ( mCurrentPinchEmitters.empty() )
{
ResetActor();
}
}
// Find the detector...
PinchGestureDetectorContainer::iterator endIter = std::remove( mGestureDetectors.begin(), mGestureDetectors.end(), gestureDetector );
DALI_ASSERT_DEBUG( endIter != mGestureDetectors.end() );
// ...and remove it
mGestureDetectors.erase(endIter, mGestureDetectors.end());
if (mGestureDetectors.empty())
{
Integration::GestureRequest request(Gesture::Pinch);
mGestureManager.Unregister(request);
}
}
void PanGestureProcessor::EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates )
{
DALI_ASSERT_DEBUG ( mCurrentPanEvent );
mCurrentPanEmitters.clear();
ResetActor();
actor->ScreenToLocal( GetImplementation(mCurrentRenderTask), actorCoordinates.x, actorCoordinates.y, mCurrentPanEvent->currentPosition.x, mCurrentPanEvent->currentPosition.y );
EmitPanSignal( actor, gestureDetectors, *mCurrentPanEvent, actorCoordinates, mCurrentPanEvent->state, mCurrentRenderTask );
if ( actor->OnStage() )
{
mCurrentPanEmitters = gestureDetectors;
SetActor( actor );
}
}
/***********************************************************
respawn
***********************************************************/
void NPCHandler::Respawn()
{
if(!_agentState->IsDead())
return;
if(!ChangeState(1))
return;
// reset life
_lifeinfo.CurrentLife = _lifeinfo.MaxLife;
_lifeinfo.CurrentMana = _lifeinfo.MaxMana;
// reset position - reset and start script
ResetActor();
// unhide
ShowHideInternal(true);
}
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;
}
}
