dali/internal/event/events/pan-gesture-processor.cpp

   1 //
   2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an AS IS BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 // CLASS HEADER
  18 #include <dali/internal/event/events/pan-gesture-processor.h>
  19
  20 // EXTERNAL INCLUDES
  21 #include <algorithm>
  22
  23 // INTERNAL INCLUDES
  24 #include <dali/public-api/actors/actor.h>
  25 #include <dali/public-api/common/dali-common.h>
  26 #include <dali/public-api/events/pan-gesture.h>
  27 #include <dali/public-api/math/vector2.h>
  28 #include <dali/integration-api/events/pan-gesture-event.h>
  29 #include <dali/integration-api/gesture-manager.h>
  30 #include <dali/integration-api/debug.h>
  31 #include <dali/internal/event/common/stage-impl.h>
  32 #include <dali/internal/event/render-tasks/render-task-impl.h>
  33 #include <dali/internal/update/gestures/scene-graph-pan-gesture.h>
  34
  35 namespace Dali
  36 {
  37
  38 namespace Internal
  39 {
  40
  41 namespace // unnamed namespace
  42 {
  43
  44 const unsigned long MAXIMUM_TIME_WITH_VALID_LAST_VELOCITY( 50u );
  45
  46 /**
  47  * Functor which checks whether the specified actor is attached to the gesture detector.
  48  * If the actor is attached, it also checks whether the number of touches of the current pan event
  49  * are within the range of that expected by the detector.
  50  * It returns true if it is no longer attached or the touches are out of range.
  51  * This can be used in remove_if functions.
  52  */
  53 struct IsNotAttachedAndOutsideTouchesRangeFunctor
  54 {
  55   /**
  56    * Constructor
  57    * @param[in]  actor                 The actor to check whether it is attached.
  58    * @param[in]  touches               The number of touches in the current pan event.
  59    * @param[in]  outsideRangeEmitters  Reference to container where emitters outside of the touches range should be added.
  60    */
  61   IsNotAttachedAndOutsideTouchesRangeFunctor(Actor* actor, unsigned int touches, PanGestureDetectorContainer& outsideRangeEmitters)
  62   : actorToCheck(actor),
  63     numberOfTouches(touches),
  64     outsideTouchesRangeEmitters(outsideRangeEmitters)
  65   {
  66   }
  67
  68   /**
  69    * Returns true if not attached, false if it is still attached.
  70    * Additionally, checks if the number of touches has changed and stops sending the pan to a particular
  71    * detector if it exceeds the range of that detector.
  72    * @param[in]  detector  The detector to check.
  73    * @return true, if not attached, false otherwise.
  74    */
  75   bool operator()(PanGestureDetector* detector) const
  76   {
  77     bool remove(!detector->IsAttached(*actorToCheck));
  78
  79     if (!remove)
  80     {
  81       // Ensure number of touch points is within the range of our emitter. If it isn't then remove
  82       // this emitter and add it to the outsideTouchesRangeEmitters container
  83       if ( (numberOfTouches < detector->GetMinimumTouchesRequired()) ||
  84            (numberOfTouches > detector->GetMaximumTouchesRequired()) )
  85       {
  86         remove = true;
  87         outsideTouchesRangeEmitters.push_back(detector);
  88       }
  89     }
  90
  91     return remove;
  92   }
  93
  94   Actor* actorToCheck; ///< The actor to check whether it is attached or not.
  95   unsigned int numberOfTouches; ///< The number of touches in the pan event.
  96   PanGestureDetectorContainer& outsideTouchesRangeEmitters; ///< Emitters that are outside of the range of current pan.
  97 };
  98
  99 } // unnamed namespace
 100
 101 struct PanGestureProcessor::PanEventFunctor : public GestureProcessor::Functor
 102 {
 103   /**
 104    * Constructor
 105    * @param[in]  panEvent   The current gesture event.
 106    * @param[in]  processor  Reference to the processor.
 107    */
 108   PanEventFunctor( const Integration::PanGestureEvent& panEvent, PanGestureProcessor& processor )
 109   : panEvent( panEvent ),
 110     processor( processor )
 111   {
 112   }
 113
 114   /**
 115    * Check if the detector meets the current gesture event parameters.
 116    */
 117   virtual bool operator() ( GestureDetector* detector, Actor* actor )
 118   {
 119     bool retVal( false );
 120
 121     PanGestureDetector* panDetector( static_cast< PanGestureDetector* >( detector ) );
 122
 123     if ( ( panEvent.numberOfTouches >= panDetector->GetMinimumTouchesRequired() ) &&
 124          ( panEvent.numberOfTouches <= panDetector->GetMaximumTouchesRequired() ) )
 125     {
 126       // Check if the detector requires directional panning.
 127       if ( panDetector->RequiresDirectionalPan() && processor.mCurrentRenderTask )
 128       {
 129         // It does, calculate the angle of the pan in local actor coordinates and ensures it fits
 130         // the detector's criteria.
 131         RenderTask& renderTaskImpl( GetImplementation( processor.mCurrentRenderTask ) );
 132
 133         Vector2 startPosition, currentPosition;
 134         actor->ScreenToLocal( renderTaskImpl, startPosition.x,   startPosition.y,   processor.mPossiblePanPosition.x, processor.mPossiblePanPosition.y );
 135         actor->ScreenToLocal( renderTaskImpl, currentPosition.x, currentPosition.y, panEvent.currentPosition.x,       panEvent.currentPosition.y );
 136         Vector2 displacement( currentPosition - startPosition );
 137
 138         Radian angle( atan( displacement.y / displacement.x ) );
 139
 140         /////////////////////////////
 141         //            |            //
 142         //            |            //
 143         //   Q3 (-,-) | Q4 (+,-)   //
 144         //            |            //
 145         //    ----------------- +x //
 146         //            |            //
 147         //   Q2 (-,+) | Q1 (+,+)   //
 148         //            |            //
 149         //            |            //
 150         //           +y            //
 151         /////////////////////////////
 152         // Quadrant 1: As is
 153         // Quadrant 2: 180 degrees + angle
 154         // Quadrant 3: angle - 180 degrees
 155         // Quadrant 4: As is
 156         /////////////////////////////
 157
 158         if ( displacement.x < 0.0f )
 159         {
 160           if ( displacement.y >= 0.0f )
 161           {
 162             // Quadrant 2
 163             angle += Math::PI;
 164           }
 165           else
 166           {
 167             // Quadrant 3
 168             angle -= Math::PI;
 169           }
 170         }
 171
 172         if ( panDetector->CheckAngleAllowed( angle ) )
 173         {
 174           retVal = true;
 175         }
 176       }
 177       else
 178       {
 179         // Directional panning not required so we can use this actor and gesture detector.
 180         retVal = true;
 181       }
 182     }
 183
 184     return retVal;
 185   }
 186
 187   /**
 188    * Gestured actor and gesture detectors that meet the gesture's parameters found, emit and save required information.
 189    */
 190   virtual void operator() ( Dali::Actor actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates )
 191   {
 192     PanGestureDetectorContainer derivedContainer;
 193     DownCastContainer<PanGestureDetector>( gestureDetectors, derivedContainer );
 194
 195     processor.mCurrentPanEmitters.clear();
 196     processor.ResetActor();
 197
 198     Actor* actorImpl( &GetImplementation( actor ) );
 199     actorImpl->ScreenToLocal( GetImplementation(processor.mCurrentRenderTask), actorCoordinates.x, actorCoordinates.y, panEvent.currentPosition.x, panEvent.currentPosition.y );
 200
 201     processor.EmitPanSignal( actor, derivedContainer, panEvent, actorCoordinates, panEvent.state, processor.mCurrentRenderTask );
 202
 203     if ( actorImpl->OnStage() )
 204     {
 205       processor.mCurrentPanEmitters = derivedContainer;
 206       processor.SetActor( actor );
 207     }
 208   }
 209
 210   const Integration::PanGestureEvent& panEvent;
 211   PanGestureProcessor& processor;
 212 };
 213
 214 PanGestureProcessor::PanGestureProcessor( Stage& stage, Integration::GestureManager& gestureManager )
 215 : GestureProcessor( Gesture::Pan ),
 216   mStage( stage ),
 217   mGestureManager( gestureManager ),
 218   mGestureDetectors(),
 219   mCurrentPanEmitters(),
 220   mCurrentRenderTask(),
 221   mPossiblePanPosition(),
 222   mMinTouchesRequired( 1 ),
 223   mMaxTouchesRequired( 1 ),
 224   mSceneObject( SceneGraph::PanGesture::New() ) // Create scene object to store pan information.
 225 {
 226   // Pass ownership to scene-graph
 227   AddGestureMessage( mStage.GetUpdateManager(), mSceneObject );
 228 }
 229
 230 PanGestureProcessor::~PanGestureProcessor()
 231 {
 232   if( Stage::IsInstalled() && ( mSceneObject != NULL ) )
 233   {
 234     RemoveGestureMessage( mStage.GetUpdateManager(), mSceneObject );
 235     mSceneObject = NULL; // mSceneObject is about to be destroyed
 236   }
 237 }
 238
 239 void PanGestureProcessor::Process( const Integration::PanGestureEvent& panEvent )
 240 {
 241   switch( panEvent.state )
 242   {
 243     case Gesture::Possible:
 244     {
 245       mCurrentPanEmitters.clear();
 246       ResetActor();
 247
 248       HitTestAlgorithm::Results hitTestResults;
 249       if( HitTest( mStage, panEvent.currentPosition, hitTestResults ) )
 250       {
 251         SetActor( hitTestResults.actor );
 252         mPossiblePanPosition = panEvent.currentPosition;
 253       }
 254
 255       break;
 256     }
 257
 258     case Gesture::Started:
 259     {
 260       if ( GetCurrentGesturedActor() )
 261       {
 262         // The pan gesture should only be sent to the gesture detector which first received it so that
 263         // it can be told when the gesture ends as well.
 264
 265         HitTestAlgorithm::Results hitTestResults;
 266         HitTest( mStage, mPossiblePanPosition, hitTestResults ); // Hit test original possible position...
 267
 268         if ( hitTestResults.actor && ( GetCurrentGesturedActor() == &GetImplementation( hitTestResults.actor ) ) )
 269         {
 270           // Record the current render-task for Screen->Actor coordinate conversions
 271           mCurrentRenderTask = hitTestResults.renderTask;
 272
 273           PanEventFunctor functor( panEvent, *this );
 274           GestureDetectorContainer gestureDetectors;
 275           UpCastContainer<PanGestureDetector>( mGestureDetectors, gestureDetectors );
 276           ProcessAndEmit( hitTestResults, gestureDetectors, functor );
 277         }
 278         else
 279         {
 280           ResetActor();
 281           mCurrentPanEmitters.clear();
 282         }
 283       }
 284       break;
 285     }
 286
 287     case Gesture::Continuing:
 288     case Gesture::Finished:
 289     case Gesture::Cancelled:
 290     {
 291       // Only send subsequent pan gesture signals if we processed the pan gesture when it started.
 292       // Check if actor is still touchable.
 293
 294       Actor* currentGesturedActor = GetCurrentGesturedActor();
 295       if ( currentGesturedActor )
 296       {
 297         if ( currentGesturedActor->IsHittable() && !mCurrentPanEmitters.empty() && mCurrentRenderTask )
 298         {
 299           PanGestureDetectorContainer outsideTouchesRangeEmitters;
 300
 301           // Removes emitters that no longer have the actor attached
 302           // Also remove emitters whose touches are outside the range of the current pan event and add them to outsideTouchesRangeEmitters
 303           PanGestureDetectorContainer::iterator endIter = std::remove_if( mCurrentPanEmitters.begin(), mCurrentPanEmitters.end(),
 304                                                                           IsNotAttachedAndOutsideTouchesRangeFunctor(currentGesturedActor, panEvent.numberOfTouches, outsideTouchesRangeEmitters) );
 305           mCurrentPanEmitters.erase( endIter, mCurrentPanEmitters.end() );
 306
 307           Vector2 actorCoords;
 308
 309           if ( !outsideTouchesRangeEmitters.empty() || !mCurrentPanEmitters.empty() )
 310           {
 311             currentGesturedActor->ScreenToLocal( GetImplementation( mCurrentRenderTask ), actorCoords.x, actorCoords.y, panEvent.currentPosition.x, panEvent.currentPosition.y );
 312
 313             // EmitPanSignal checks whether we have a valid actor and whether the container we are passing in has emitters before it emits the pan.
 314             EmitPanSignal(Dali::Actor(currentGesturedActor), outsideTouchesRangeEmitters, panEvent, actorCoords, Gesture::Finished, mCurrentRenderTask);
 315             EmitPanSignal(Dali::Actor(currentGesturedActor), mCurrentPanEmitters, panEvent, actorCoords, panEvent.state, mCurrentRenderTask);
 316           }
 317
 318           if ( mCurrentPanEmitters.empty() )
 319           {
 320             // If we have no emitters attached then clear pan actor as well.
 321             ResetActor();
 322           }
 323
 324           // Clear current gesture detectors if pan gesture has ended or been cancelled.
 325           if ( ( panEvent.state == Gesture::Finished ) || ( panEvent.state == Gesture::Cancelled ) )
 326           {
 327             mCurrentPanEmitters.clear();
 328             ResetActor();
 329           }
 330         }
 331         else
 332         {
 333           mCurrentPanEmitters.clear();
 334           ResetActor();
 335         }
 336       }
 337       break;
 338     }
 339
 340     case Gesture::Clear:
 341       DALI_ASSERT_ALWAYS( false && "Incorrect state received from Integration layer: Clear\n" );
 342       break;
 343   }
 344 }
 345
 346 void PanGestureProcessor::AddGestureDetector( PanGestureDetector* gestureDetector )
 347 {
 348   bool firstRegistration(mGestureDetectors.empty());
 349
 350   mGestureDetectors.push_back(gestureDetector);
 351
 352   // Set the pan scene object on the gesture detector
 353   gestureDetector->SetSceneObject( mSceneObject );
 354
 355   if (firstRegistration)
 356   {
 357     mMinTouchesRequired = gestureDetector->GetMinimumTouchesRequired();
 358     mMaxTouchesRequired = gestureDetector->GetMaximumTouchesRequired();
 359
 360     Integration::PanGestureRequest request;
 361     request.minTouches = mMinTouchesRequired;
 362     request.maxTouches = mMaxTouchesRequired;
 363     mGestureManager.Register(request);
 364   }
 365   else
 366   {
 367     UpdateDetection();
 368   }
 369 }
 370
 371 void PanGestureProcessor::RemoveGestureDetector( PanGestureDetector* gestureDetector )
 372 {
 373   if (!mCurrentPanEmitters.empty())
 374   {
 375     // Check if the removed detector was one that is currently being panned and remove it from emitters.
 376     PanGestureDetectorContainer::iterator endIter = std::remove( mCurrentPanEmitters.begin(), mCurrentPanEmitters.end(), gestureDetector );
 377     mCurrentPanEmitters.erase( endIter, mCurrentPanEmitters.end() );
 378
 379     // If we no longer have any emitters, then we should clear mCurrentGesturedActor as well
 380     if ( mCurrentPanEmitters.empty() )
 381     {
 382       ResetActor();
 383     }
 384   }
 385
 386   // Find the detector...
 387   PanGestureDetectorContainer::iterator endIter = std::remove( mGestureDetectors.begin(), mGestureDetectors.end(), gestureDetector );
 388   DALI_ASSERT_DEBUG( endIter != mGestureDetectors.end() );
 389
 390   // ...and remove it
 391   mGestureDetectors.erase(endIter, mGestureDetectors.end());
 392
 393   if (mGestureDetectors.empty())
 394   {
 395     Integration::GestureRequest request(Gesture::Pan);
 396     mGestureManager.Unregister(request);
 397   }
 398   else
 399   {
 400     UpdateDetection();
 401   }
 402 }
 403
 404 void PanGestureProcessor::GestureDetectorUpdated( PanGestureDetector* gestureDetector )
 405 {
 406   DALI_ASSERT_DEBUG(find(mGestureDetectors.begin(), mGestureDetectors.end(), gestureDetector) != mGestureDetectors.end());
 407
 408   UpdateDetection();
 409 }
 410
 411 void PanGestureProcessor::SetPanGestureProperties( const PanGesture& pan )
 412 {
 413   // If we are currently processing a pan gesture then just ignore
 414   if ( mCurrentPanEmitters.empty() && mSceneObject )
 415   {
 416     // We update the scene object directly rather than sending a message.
 417     // Sending a message could cause unnecessary delays, the scene object ensure thread safe behaviour.
 418     mSceneObject->AddGesture( pan );
 419   }
 420 }
 421
 422 void PanGestureProcessor::EnableProfiling()
 423 {
 424   mSceneObject->EnableProfiling();
 425 }
 426
 427 void PanGestureProcessor::SetPredictionMode(int mode)
 428 {
 429   if( (mode < 0)
 430       || (mode >= SceneGraph::PanGesture::NUM_PREDICTION_MODES) )
 431   {
 432     mode = SceneGraph::PanGesture::DEFAULT_PREDICTION_MODE;
 433   }
 434   SceneGraph::PanGesture::PredictionMode modeEnum = static_cast<SceneGraph::PanGesture::PredictionMode>(mode);
 435   mSceneObject->SetPredictionMode(modeEnum);
 436 }
 437
 438 void PanGestureProcessor::SetPredictionAmount(float amount)
 439 {
 440   mSceneObject->SetPredictionAmount(amount);
 441 }
 442
 443 void PanGestureProcessor::UpdateDetection()
 444 {
 445   DALI_ASSERT_DEBUG(!mGestureDetectors.empty());
 446
 447   unsigned int minimumRequired = UINT_MAX;
 448   unsigned int maximumRequired = 0;
 449
 450   for ( PanGestureDetectorContainer::iterator iter = mGestureDetectors.begin(), endIter = mGestureDetectors.end(); iter != endIter; ++iter )
 451   {
 452     PanGestureDetector* detector(*iter);
 453
 454     unsigned int minimum = detector->GetMinimumTouchesRequired();
 455     if (minimum < minimumRequired)
 456     {
 457       minimumRequired = minimum;
 458     }
 459
 460     unsigned int maximum = detector->GetMaximumTouchesRequired();
 461     if (maximum > maximumRequired)
 462     {
 463       maximumRequired = maximum;
 464     }
 465   }
 466
 467   if ( (minimumRequired != mMinTouchesRequired)||(maximumRequired != mMaxTouchesRequired) )
 468   {
 469     mMinTouchesRequired = minimumRequired;
 470     mMaxTouchesRequired = maximumRequired;
 471
 472     Integration::PanGestureRequest request;
 473     request.minTouches = mMinTouchesRequired;
 474     request.maxTouches = mMaxTouchesRequired;
 475     mGestureManager.Update(request);
 476   }
 477 }
 478
 479 void PanGestureProcessor::EmitPanSignal( Dali::Actor actorHandle,
 480                                          PanGestureDetectorContainer& gestureDetectors,
 481                                          const Integration::PanGestureEvent& panEvent,
 482                                          Vector2 localCurrent,
 483                                          Gesture::State state,
 484                                          Dali::RenderTask renderTask )
 485 {
 486   if ( actorHandle && !gestureDetectors.empty() )
 487   {
 488     Actor& actor = GetImplementation(actorHandle);
 489
 490     PanGesture pan(state);
 491     pan.time = panEvent.time;
 492
 493     pan.numberOfTouches = panEvent.numberOfTouches;
 494     pan.screenPosition = panEvent.currentPosition;
 495     pan.position = localCurrent;
 496
 497     RenderTask& renderTaskImpl( GetImplementation( renderTask ) );
 498
 499     Vector2 localPrevious;
 500     actor.ScreenToLocal( renderTaskImpl, localPrevious.x, localPrevious.y, panEvent.previousPosition.x, panEvent.previousPosition.y );
 501
 502     pan.displacement = localCurrent - localPrevious;
 503     Vector2 previousPos( panEvent.previousPosition );
 504     if ( state == Gesture::Started )
 505     {
 506       previousPos = mPossiblePanPosition;
 507     }
 508
 509     pan.screenDisplacement = panEvent.currentPosition - previousPos;
 510
 511     pan.velocity.x = pan.displacement.x / panEvent.timeDelta;
 512     pan.velocity.y = pan.displacement.y / panEvent.timeDelta;
 513
 514     pan.screenVelocity.x = pan.screenDisplacement.x / panEvent.timeDelta;
 515     pan.screenVelocity.y = pan.screenDisplacement.y / panEvent.timeDelta;
 516
 517     // When the gesture ends, we may incorrectly get a ZERO velocity (as we have lifted our finger without any movement)
 518     // so we should use the last recorded velocity instead in this scenario.
 519     if ( ( state == Gesture::Finished ) && ( pan.screenVelocity == Vector2::ZERO ) &&
 520          ( panEvent.timeDelta < MAXIMUM_TIME_WITH_VALID_LAST_VELOCITY ) )
 521     {
 522       pan.velocity = mLastVelocity;
 523       pan.screenVelocity = mLastScreenVelocity;
 524     }
 525     else
 526     {
 527       // Store the current velocity for future iterations.
 528       mLastVelocity = pan.velocity;
 529       mLastScreenVelocity = pan.screenVelocity;
 530     }
 531
 532     if ( mSceneObject )
 533     {
 534       // We update the scene object directly rather than sending a message.
 535       // Sending a message could cause unnecessary delays, the scene object ensure thread safe behaviour.
 536       mSceneObject->AddGesture( pan );
 537     }
 538
 539     for ( PanGestureDetectorContainer::iterator iter = gestureDetectors.begin(), endIter = gestureDetectors.end(); iter != endIter; ++iter )
 540     {
 541       (*iter)->EmitPanGestureSignal(actorHandle, pan);
 542     }
 543   }
 544 }
 545
 546 void PanGestureProcessor::OnGesturedActorStageDisconnection()
 547 {
 548   mCurrentPanEmitters.clear();
 549 }
 550
 551 } // namespace Internal
 552
 553 } // namespace Dali