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

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
   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
  18 // CLASS HEADER
  19 #include <dali/internal/event/events/pan-gesture/pan-gesture-processor.h>
  20
  21 #if defined(DEBUG_ENABLED)
  22 #include <sstream>
  23 #endif
  24
  25 // EXTERNAL INCLUDES
  26 #include <algorithm>
  27
  28 // INTERNAL INCLUDES
  29 #include <dali/integration-api/debug.h>
  30 #include <dali/integration-api/trace.h>
  31 #include <dali/internal/event/common/scene-impl.h>
  32 #include <dali/internal/event/events/gesture-requests.h>
  33 #include <dali/internal/event/events/multi-point-event-util.h>
  34 #include <dali/internal/event/events/pan-gesture/pan-gesture-event.h>
  35 #include <dali/internal/event/events/pan-gesture/pan-gesture-impl.h>
  36 #include <dali/internal/event/events/pan-gesture/pan-gesture-recognizer.h>
  37 #include <dali/internal/event/render-tasks/render-task-impl.h>
  38 #include <dali/internal/update/gestures/scene-graph-pan-gesture.h>
  39 #include <dali/internal/update/manager/update-manager.h>
  40 #include <dali/public-api/actors/actor.h>
  41 #include <dali/public-api/common/dali-common.h>
  42 #include <dali/public-api/events/pan-gesture.h>
  43 #include <dali/public-api/math/vector2.h>
  44
  45 namespace Dali
  46 {
  47 namespace Internal
  48 {
  49 namespace // unnamed namespace
  50 {
  51 DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false);
  52 #if defined(DEBUG_ENABLED)
  53 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_PAN_PROCESSOR");
  54
  55 const char* GESTURE_STATES[6] =
  56   {
  57     "CLEAR",
  58     "STARTED",
  59     "CONTINUING",
  60     "FINISHED",
  61     "CANCELLED",
  62     "POSSIBLE"};
  63
  64 #endif // defined(DEBUG_ENABLED)
  65
  66 const unsigned long MAXIMUM_TIME_WITH_VALID_LAST_VELOCITY(50u);
  67
  68 /**
  69  * Functor which checks whether the specified actor is attached to the gesture detector.
  70  * If the actor is attached, it also checks whether the number of touches of the current pan event
  71  * are within the range of that expected by the detector.
  72  * It returns true if it is no longer attached or the touches are out of range.
  73  * This can be used in remove_if functions.
  74  */
  75 struct IsNotAttachedAndOutsideTouchesRangeFunctor
  76 {
  77   /**
  78    * Constructor
  79    * @param[in]  actor                 The actor to check whether it is attached.
  80    * @param[in]  touches               The number of touches in the current pan event.
  81    * @param[in]  outsideRangeEmitters  Reference to container where emitters outside of the touches range should be added.
  82    */
  83   IsNotAttachedAndOutsideTouchesRangeFunctor(Actor* actor, unsigned int touches, GestureDetectorContainer& outsideRangeEmitters)
  84   : actorToCheck(actor),
  85     numberOfTouches(touches),
  86     outsideTouchesRangeEmitters(outsideRangeEmitters)
  87   {
  88   }
  89
  90   /**
  91    * Returns true if not attached, false if it is still attached.
  92    * Additionally, checks if the number of touches has changed and stops sending the pan to a particular
  93    * detector if it exceeds the range of that detector.
  94    * @param[in]  detector  The detector to check.
  95    * @return true, if not attached, false otherwise.
  96    */
  97   bool operator()(GestureDetector* detector) const
  98   {
  99     bool remove(!detector->IsAttached(*actorToCheck));
 100
 101     if(!remove)
 102     {
 103       PanGestureDetector* panDetector(static_cast<PanGestureDetector*>(detector));
 104
 105       // Ensure number of touch points is within the range of our emitter. If it isn't then remove
 106       // this emitter and add it to the outsideTouchesRangeEmitters container
 107       if((numberOfTouches < panDetector->GetMinimumTouchesRequired()) ||
 108          (numberOfTouches > panDetector->GetMaximumTouchesRequired()))
 109       {
 110         remove = true;
 111         outsideTouchesRangeEmitters.push_back(detector);
 112       }
 113     }
 114
 115     return remove;
 116   }
 117
 118   Actor*                    actorToCheck;                ///< The actor to check whether it is attached or not.
 119   unsigned int              numberOfTouches;             ///< The number of touches in the pan event.
 120   GestureDetectorContainer& outsideTouchesRangeEmitters; ///< Emitters that are outside of the range of current pan.
 121 };
 122
 123 } // unnamed namespace
 124
 125 PanGestureProcessor::PanGestureProcessor(SceneGraph::UpdateManager& updateManager)
 126 : GestureProcessor(GestureType::PAN),
 127   mPanGestureDetectors(),
 128   mCurrentPanEmitters(),
 129   mCurrentRenderTask(),
 130   mPossiblePanPosition(),
 131   mMinTouchesRequired(1),
 132   mMaxTouchesRequired(1),
 133   mMaxMotionEventAge(std::numeric_limits<uint32_t>::max()),
 134   mCurrentPanEvent(nullptr),
 135   mSceneObject(SceneGraph::PanGesture::New()) // Create scene object to store pan information.
 136 {
 137   // Pass ownership to scene-graph; scene object lives for the lifecycle of UpdateManager
 138   updateManager.SetPanGestureProcessor(mSceneObject);
 139 }
 140
 141 PanGestureProcessor::~PanGestureProcessor()
 142 {
 143   mSceneObject = nullptr; // mSceneObject is owned and destroyed by update manager (there is only one of these for now)
 144 }
 145
 146 void PanGestureProcessor::Process(Scene& scene, const PanGestureEvent& panEvent, Actor* actor)
 147 {
 148 #if defined(DEBUG_ENABLED)
 149   DALI_LOG_TRACE_METHOD(gLogFilter);
 150
 151   DALI_LOG_INFO(gLogFilter, Debug::General, "    Pan Event\n");
 152   DALI_LOG_INFO(gLogFilter, Debug::General, "      State: %s  Touches: %d  Time: %d  TimeDelta: %d\n", GESTURE_STATES[static_cast<uint8_t>(panEvent.state)], panEvent.numberOfTouches, panEvent.time, panEvent.timeDelta);
 153   DALI_LOG_INFO(gLogFilter, Debug::General, "      Positions: Current: (%.0f, %.0f), Previous: (%.0f, %.0f)\n", panEvent.currentPosition.x, panEvent.currentPosition.y, panEvent.previousPosition.x, panEvent.previousPosition.y);
 154 #endif
 155
 156   DALI_TRACE_SCOPE(gTraceFilter, "DALI_PROCESS_PAN_GESTURE");
 157
 158   switch(panEvent.state)
 159   {
 160     case GestureState::POSSIBLE:
 161     {
 162       mCurrentPanEmitters.clear();
 163       ResetActor();
 164
 165       HitTestAlgorithm::Results hitTestResults;
 166       if(actor)
 167       {
 168         SetActor(actor);
 169         mPossiblePanPosition = panEvent.currentPosition;
 170       }
 171       else if(HitTest(scene, panEvent.currentPosition, hitTestResults))
 172       {
 173         SetActor(&GetImplementation(hitTestResults.actor));
 174         mPossiblePanPosition = panEvent.currentPosition;
 175       }
 176       break;
 177     }
 178
 179     case GestureState::STARTED:
 180     {
 181       // Requires a core update
 182       mNeedsUpdate = true;
 183
 184       // The pan gesture should only be sent to the gesture detector which first received it so that
 185       // it can be told when the gesture ends as well.
 186
 187       HitTestAlgorithm::Results hitTestResults;
 188       if(actor)
 189       {
 190         hitTestResults.actor = Dali::Actor(actor);
 191         hitTestResults.renderTask = panEvent.renderTask;
 192
 193         Vector2 actorCoords;
 194         actor->ScreenToLocal(*hitTestResults.renderTask.Get(), actorCoords.x, actorCoords.y, panEvent.currentPosition.x, panEvent.currentPosition.y);
 195         hitTestResults.actorCoordinates = actorCoords;
 196       }
 197       else
 198       {
 199         HitTest(scene, panEvent.previousPosition, hitTestResults); // Hit Test previous position
 200       }
 201
 202       if(hitTestResults.actor)
 203       {
 204         // If the current hit actor is different from the one we touched down on then set accordingly & update initial pan position
 205         if(&GetImplementation(hitTestResults.actor) != GetCurrentGesturedActor())
 206         {
 207           mPossiblePanPosition = panEvent.previousPosition;
 208           SetActor(&GetImplementation(hitTestResults.actor));
 209         }
 210
 211         // Record the current render-task for Screen->Actor coordinate conversions
 212         mCurrentRenderTask = hitTestResults.renderTask;
 213
 214         // Set mCurrentPanEvent to use inside overridden methods called in ProcessAndEmit()
 215         mCurrentPanEvent = &panEvent;
 216         if(actor)
 217         {
 218           ProcessAndEmitActor(hitTestResults);
 219         }
 220         else
 221         {
 222           ProcessAndEmit(hitTestResults);
 223         }
 224         mCurrentPanEvent = nullptr;
 225       }
 226       else
 227       {
 228         ResetActor();
 229         mCurrentPanEmitters.clear();
 230       }
 231       break;
 232     }
 233
 234     case GestureState::CONTINUING:
 235     {
 236       // Requires a core update
 237       mNeedsUpdate = true;
 238
 239       DALI_FALLTHROUGH;
 240     }
 241
 242     case GestureState::FINISHED:
 243     case GestureState::CANCELLED:
 244     {
 245       // Only send subsequent pan gesture signals if we processed the pan gesture when it started.
 246       // Check if actor is still touchable.
 247
 248       Actor* currentGesturedActor = GetCurrentGesturedActor();
 249       if(currentGesturedActor)
 250       {
 251         if(currentGesturedActor->IsHittable() && !mCurrentPanEmitters.empty() && mCurrentRenderTask)
 252         {
 253           GestureDetectorContainer outsideTouchesRangeEmitters;
 254
 255           // Removes emitters that no longer have the actor attached
 256           // Also remove emitters whose touches are outside the range of the current pan event and add them to outsideTouchesRangeEmitters
 257           GestureDetectorContainer::iterator endIter = std::remove_if(mCurrentPanEmitters.begin(), mCurrentPanEmitters.end(), IsNotAttachedAndOutsideTouchesRangeFunctor(currentGesturedActor, panEvent.numberOfTouches, outsideTouchesRangeEmitters));
 258           mCurrentPanEmitters.erase(endIter, mCurrentPanEmitters.end());
 259
 260           Vector2 actorCoords;
 261
 262           if(!outsideTouchesRangeEmitters.empty() || !mCurrentPanEmitters.empty())
 263           {
 264             currentGesturedActor->ScreenToLocal(*mCurrentRenderTask.Get(), actorCoords.x, actorCoords.y, panEvent.currentPosition.x, panEvent.currentPosition.y);
 265
 266             // EmitPanSignal checks whether we have a valid actor and whether the container we are passing in has emitters before it emits the pan.
 267             EmitPanSignal(currentGesturedActor, outsideTouchesRangeEmitters, panEvent, actorCoords, GestureState::FINISHED, mCurrentRenderTask);
 268             EmitPanSignal(currentGesturedActor, mCurrentPanEmitters, panEvent, actorCoords, panEvent.state, mCurrentRenderTask);
 269           }
 270
 271           if(mCurrentPanEmitters.empty())
 272           {
 273             // If we have no emitters attached then clear pan actor as well.
 274             ResetActor();
 275           }
 276
 277           // Clear current gesture detectors if pan gesture has ended or been cancelled.
 278           if((panEvent.state == GestureState::FINISHED) || (panEvent.state == GestureState::CANCELLED))
 279           {
 280             mCurrentPanEmitters.clear();
 281             ResetActor();
 282           }
 283         }
 284         else
 285         {
 286           mCurrentPanEmitters.clear();
 287           ResetActor();
 288         }
 289       }
 290       break;
 291     }
 292
 293     case GestureState::CLEAR:
 294     {
 295       DALI_ABORT("Incorrect state received from Integration layer: CLEAR\n");
 296       break;
 297     }
 298   }
 299 }
 300
 301 void PanGestureProcessor::AddGestureDetector(PanGestureDetector* gestureDetector, Scene& scene, int32_t minDistance, int32_t minPanEvents)
 302 {
 303   bool firstRegistration(mPanGestureDetectors.empty());
 304
 305   mPanGestureDetectors.push_back(gestureDetector);
 306
 307   if(firstRegistration)
 308   {
 309     mMinTouchesRequired = gestureDetector->GetMinimumTouchesRequired();
 310     mMaxTouchesRequired = gestureDetector->GetMaximumTouchesRequired();
 311     mMaxMotionEventAge  = gestureDetector->GetMaximumMotionEventAge();
 312
 313     PanGestureRequest request;
 314     request.minTouches        = mMinTouchesRequired;
 315     request.maxTouches        = mMaxTouchesRequired;
 316     request.maxMotionEventAge = mMaxMotionEventAge;
 317
 318     Size size          = scene.GetSize();
 319     mGestureRecognizer = new PanGestureRecognizer(*this, Vector2(size.width, size.height), static_cast<const PanGestureRequest&>(request), minDistance, minPanEvents);
 320   }
 321   else
 322   {
 323     UpdateDetection();
 324   }
 325 }
 326
 327 void PanGestureProcessor::RemoveGestureDetector(PanGestureDetector* gestureDetector)
 328 {
 329   if(!mCurrentPanEmitters.empty())
 330   {
 331     // Check if the removed detector was one that is currently being panned and remove it from emitters.
 332     GestureDetectorContainer::iterator endIter = std::remove(mCurrentPanEmitters.begin(), mCurrentPanEmitters.end(), gestureDetector);
 333     mCurrentPanEmitters.erase(endIter, mCurrentPanEmitters.end());
 334
 335     // If we no longer have any emitters, then we should clear mCurrentGesturedActor as well
 336     if(mCurrentPanEmitters.empty())
 337     {
 338       ResetActor();
 339     }
 340   }
 341
 342   // Find the detector...
 343   PanGestureDetectorContainer::iterator endIter = std::remove(mPanGestureDetectors.begin(), mPanGestureDetectors.end(), gestureDetector);
 344   DALI_ASSERT_DEBUG(endIter != mPanGestureDetectors.end());
 345
 346   // ...and remove it
 347   mPanGestureDetectors.erase(endIter, mPanGestureDetectors.end());
 348
 349   if(mPanGestureDetectors.empty())
 350   {
 351     mGestureRecognizer = nullptr;
 352   }
 353   else
 354   {
 355     UpdateDetection();
 356   }
 357 }
 358
 359 void PanGestureProcessor::GestureDetectorUpdated(PanGestureDetector* gestureDetector)
 360 {
 361   DALI_ASSERT_DEBUG(find(mPanGestureDetectors.begin(), mPanGestureDetectors.end(), gestureDetector) != mPanGestureDetectors.end());
 362
 363   UpdateDetection();
 364 }
 365
 366 bool PanGestureProcessor::SetPanGestureProperties(const Dali::PanGesture& pan)
 367 {
 368   // If we are currently processing a pan gesture then just ignore
 369   if(mCurrentPanEmitters.empty() && mSceneObject)
 370   {
 371     const PanGesture& panImpl(GetImplementation(pan));
 372
 373     // We update the scene object directly rather than sending a message.
 374     // Sending a message could cause unnecessary delays, the scene object ensure thread safe behaviour.
 375     mSceneObject->AddGesture(panImpl);
 376
 377     if(GestureState::STARTED == panImpl.GetState() || GestureState::CONTINUING == panImpl.GetState())
 378     {
 379       mNeedsUpdate = true;
 380     }
 381   }
 382
 383   return mNeedsUpdate;
 384 }
 385
 386 void PanGestureProcessor::EnableProfiling()
 387 {
 388   mSceneObject->EnableProfiling();
 389 }
 390
 391 void PanGestureProcessor::SetPredictionMode(int mode)
 392 {
 393   if((mode < 0) || (mode >= SceneGraph::PanGesture::NUM_PREDICTION_MODES))
 394   {
 395     mode = SceneGraph::PanGesture::DEFAULT_PREDICTION_MODE;
 396   }
 397   SceneGraph::PanGesture::PredictionMode modeEnum = static_cast<SceneGraph::PanGesture::PredictionMode>(mode);
 398   mSceneObject->SetPredictionMode(modeEnum);
 399 }
 400
 401 void PanGestureProcessor::SetPredictionAmount(unsigned int amount)
 402 {
 403   mSceneObject->SetPredictionAmount(amount);
 404 }
 405
 406 void PanGestureProcessor::SetMaximumPredictionAmount(unsigned int amount)
 407 {
 408   mSceneObject->SetMaximumPredictionAmount(amount);
 409 }
 410
 411 void PanGestureProcessor::SetMinimumPredictionAmount(unsigned int amount)
 412 {
 413   mSceneObject->SetMinimumPredictionAmount(amount);
 414 }
 415
 416 void PanGestureProcessor::SetPredictionAmountAdjustment(unsigned int amount)
 417 {
 418   mSceneObject->SetPredictionAmountAdjustment(amount);
 419 }
 420
 421 void PanGestureProcessor::SetSmoothingMode(int mode)
 422 {
 423   if((mode < 0) || (mode >= SceneGraph::PanGesture::NUM_SMOOTHING_MODES))
 424   {
 425     mode = SceneGraph::PanGesture::DEFAULT_SMOOTHING_MODE;
 426   }
 427   SceneGraph::PanGesture::SmoothingMode modeEnum = static_cast<SceneGraph::PanGesture::SmoothingMode>(mode);
 428   mSceneObject->SetSmoothingMode(modeEnum);
 429 }
 430
 431 void PanGestureProcessor::SetSmoothingAmount(float amount)
 432 {
 433   mSceneObject->SetSmoothingAmount(amount);
 434 }
 435
 436 void PanGestureProcessor::SetUseActualTimes(bool value)
 437 {
 438   mSceneObject->SetUseActualTimes(value);
 439 }
 440
 441 void PanGestureProcessor::SetInterpolationTimeRange(int value)
 442 {
 443   mSceneObject->SetInterpolationTimeRange(value);
 444 }
 445
 446 void PanGestureProcessor::SetScalarOnlyPredictionEnabled(bool value)
 447 {
 448   mSceneObject->SetScalarOnlyPredictionEnabled(value);
 449 }
 450
 451 void PanGestureProcessor::SetTwoPointPredictionEnabled(bool value)
 452 {
 453   mSceneObject->SetTwoPointPredictionEnabled(value);
 454 }
 455
 456 void PanGestureProcessor::SetTwoPointInterpolatePastTime(int value)
 457 {
 458   mSceneObject->SetTwoPointInterpolatePastTime(value);
 459 }
 460
 461 void PanGestureProcessor::SetTwoPointVelocityBias(float value)
 462 {
 463   mSceneObject->SetTwoPointVelocityBias(value);
 464 }
 465
 466 void PanGestureProcessor::SetTwoPointAccelerationBias(float value)
 467 {
 468   mSceneObject->SetTwoPointAccelerationBias(value);
 469 }
 470
 471 void PanGestureProcessor::SetMultitapSmoothingRange(int value)
 472 {
 473   mSceneObject->SetMultitapSmoothingRange(value);
 474 }
 475
 476 const SceneGraph::PanGesture& PanGestureProcessor::GetSceneObject() const
 477 {
 478   return *mSceneObject;
 479 }
 480
 481 void PanGestureProcessor::UpdateDetection()
 482 {
 483   DALI_ASSERT_DEBUG(!mPanGestureDetectors.empty());
 484
 485   uint32_t minimumRequired       = std::numeric_limits<uint32_t>::max();
 486   uint32_t maximumRequired       = 0;
 487   uint32_t maximumMotionEventAge = std::numeric_limits<uint32_t>::max();
 488
 489   for(PanGestureDetectorContainer::iterator iter = mPanGestureDetectors.begin(), endIter = mPanGestureDetectors.end(); iter != endIter; ++iter)
 490   {
 491     PanGestureDetector* detector(*iter);
 492
 493     if(detector)
 494     {
 495       uint32_t minimum = detector->GetMinimumTouchesRequired();
 496       if(minimum < minimumRequired)
 497       {
 498         minimumRequired = minimum;
 499       }
 500
 501       uint32_t maximum = detector->GetMaximumTouchesRequired();
 502       if(maximum > maximumRequired)
 503       {
 504         maximumRequired = maximum;
 505       }
 506
 507       uint32_t maximumAge = detector->GetMaximumMotionEventAge();
 508       if(maximumAge < maximumMotionEventAge)
 509       {
 510         maximumMotionEventAge = maximumAge;
 511       }
 512     }
 513   }
 514
 515   if((minimumRequired != mMinTouchesRequired) || (maximumRequired != mMaxTouchesRequired) || (maximumMotionEventAge != mMaxMotionEventAge))
 516   {
 517     mMinTouchesRequired = minimumRequired;
 518     mMaxTouchesRequired = maximumRequired;
 519     mMaxMotionEventAge  = maximumMotionEventAge;
 520
 521     PanGestureRequest request;
 522     request.minTouches        = mMinTouchesRequired;
 523     request.maxTouches        = mMaxTouchesRequired;
 524     request.maxMotionEventAge = mMaxMotionEventAge;
 525     mGestureRecognizer->Update(request);
 526   }
 527 }
 528
 529 void PanGestureProcessor::EmitPanSignal(Actor*                          actor,
 530                                         const GestureDetectorContainer& gestureDetectors,
 531                                         const PanGestureEvent&          panEvent,
 532                                         Vector2                         localCurrent,
 533                                         GestureState                    state,
 534                                         RenderTaskPtr                   renderTask)
 535 {
 536   if(actor && !gestureDetectors.empty())
 537   {
 538     Internal::PanGesturePtr pan(new Internal::PanGesture(state));
 539
 540     pan->SetTime(panEvent.time);
 541
 542     pan->SetNumberOfTouches(panEvent.numberOfTouches);
 543     pan->SetScreenPosition(panEvent.currentPosition);
 544     pan->SetPosition(localCurrent);
 545     pan->SetSourceType(panEvent.sourceType);
 546     pan->SetSourceData(panEvent.sourceData);
 547
 548     RenderTask& renderTaskImpl(*renderTask.Get());
 549
 550     Vector2 localPrevious;
 551     actor->ScreenToLocal(renderTaskImpl, localPrevious.x, localPrevious.y, panEvent.previousPosition.x, panEvent.previousPosition.y);
 552
 553     pan->SetDisplacement(localCurrent - localPrevious);
 554     Vector2 previousPos(panEvent.previousPosition);
 555     if(state == GestureState::STARTED)
 556     {
 557       previousPos = mPossiblePanPosition;
 558     }
 559
 560     pan->SetScreenDisplacement(panEvent.currentPosition - previousPos);
 561
 562     // Avoid dividing by 0
 563     if(panEvent.timeDelta > 0)
 564     {
 565       Vector2 velocity;
 566       velocity.x = pan->GetDisplacement().x / static_cast<float>(panEvent.timeDelta);
 567       velocity.y = pan->GetDisplacement().y / static_cast<float>(panEvent.timeDelta);
 568       pan->SetVelocity(velocity);
 569
 570       Vector2 screenVelocity;
 571       screenVelocity.x = pan->GetScreenDisplacement().x / static_cast<float>(panEvent.timeDelta);
 572       screenVelocity.y = pan->GetScreenDisplacement().y / static_cast<float>(panEvent.timeDelta);
 573       pan->SetScreenVelocity(screenVelocity);
 574     }
 575
 576     // When the gesture ends, we may incorrectly get a ZERO velocity (as we have lifted our finger without any movement)
 577     // so we should use the last recorded velocity instead in this scenario.
 578     if((state == GestureState::FINISHED) && (pan->GetScreenVelocity() == Vector2::ZERO) &&
 579        (panEvent.timeDelta < MAXIMUM_TIME_WITH_VALID_LAST_VELOCITY))
 580     {
 581       pan->SetVelocity(mLastVelocity);
 582       pan->SetScreenVelocity(mLastScreenVelocity);
 583     }
 584     else
 585     {
 586       // Store the current velocity for future iterations.
 587       mLastVelocity       = pan->GetVelocity();
 588       mLastScreenVelocity = pan->GetScreenVelocity();
 589     }
 590
 591     if(mSceneObject)
 592     {
 593       // We update the scene object directly rather than sending a message.
 594       // Sending a message could cause unnecessary delays, the scene object ensure thread safe behaviour.
 595       mSceneObject->AddGesture(*pan.Get());
 596     }
 597
 598     DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_EMIT_PAN_GESTURE_SIGNAL", [&](std::ostringstream& oss) {
 599       oss << "[" << gestureDetectors.size() << "]";
 600     });
 601
 602     Dali::Actor actorHandle(actor);
 603
 604     const GestureDetectorContainer::const_iterator endIter = gestureDetectors.end();
 605     for(GestureDetectorContainer::const_iterator iter = gestureDetectors.begin(); iter != endIter; ++iter)
 606     {
 607       static_cast<PanGestureDetector*>(*iter)->EmitPanGestureSignal(actorHandle, Dali::PanGesture(pan.Get()));
 608     }
 609
 610     DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_EMIT_PAN_GESTURE_SIGNAL", [&](std::ostringstream& oss) {
 611       oss << "[" << gestureDetectors.size() << "]";
 612     });
 613   }
 614 }
 615
 616 void PanGestureProcessor::OnGesturedActorStageDisconnection()
 617 {
 618   mCurrentPanEmitters.clear();
 619 }
 620
 621 bool PanGestureProcessor::CheckGestureDetector(GestureDetector* detector, Actor* actor)
 622 {
 623   DALI_ASSERT_DEBUG(mCurrentPanEvent);
 624
 625   bool                retVal(false);
 626   PanGestureDetector* panDetector(static_cast<PanGestureDetector*>(detector));
 627
 628   if((mCurrentPanEvent->numberOfTouches >= panDetector->GetMinimumTouchesRequired()) &&
 629      (mCurrentPanEvent->numberOfTouches <= panDetector->GetMaximumTouchesRequired()))
 630   {
 631     // Check if the detector requires directional panning.
 632     if(panDetector->RequiresDirectionalPan() && mCurrentRenderTask)
 633     {
 634       // It does, calculate the angle of the pan in local actor coordinates and ensures it fits
 635       // the detector's criteria.
 636       RenderTask& renderTaskImpl = *mCurrentRenderTask.Get();
 637
 638       Vector2 startPosition, currentPosition;
 639       actor->ScreenToLocal(renderTaskImpl, startPosition.x, startPosition.y, mPossiblePanPosition.x, mPossiblePanPosition.y);
 640       actor->ScreenToLocal(renderTaskImpl, currentPosition.x, currentPosition.y, mCurrentPanEvent->currentPosition.x, mCurrentPanEvent->currentPosition.y);
 641       Vector2 displacement(currentPosition - startPosition);
 642
 643       Radian angle(atanf(displacement.y / displacement.x));
 644
 645       /////////////////////////////
 646       //            |            //
 647       //            |            //
 648       //   Q3 (-,-) | Q4 (+,-)   //
 649       //            |            //
 650       //    ----------------- +x //
 651       //            |            //
 652       //   Q2 (-,+) | Q1 (+,+)   //
 653       //            |            //
 654       //            |            //
 655       //           +y            //
 656       /////////////////////////////
 657       // Quadrant 1: As is
 658       // Quadrant 2: 180 degrees + angle
 659       // Quadrant 3: angle - 180 degrees
 660       // Quadrant 4: As is
 661       /////////////////////////////
 662
 663       if(displacement.x < 0.0f)
 664       {
 665         if(displacement.y >= 0.0f)
 666         {
 667           // Quadrant 2
 668           angle.radian += Math::PI;
 669         }
 670         else
 671         {
 672           // Quadrant 3
 673           angle.radian -= Math::PI;
 674         }
 675       }
 676
 677       if(panDetector->CheckAngleAllowed(angle))
 678       {
 679         retVal = true;
 680       }
 681     }
 682     else
 683     {
 684       // Directional panning not required so we can use this actor and gesture detector.
 685       retVal = true;
 686     }
 687   }
 688   return retVal;
 689 }
 690
 691 void PanGestureProcessor::EmitGestureSignal(Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates)
 692 {
 693   DALI_ASSERT_DEBUG(mCurrentPanEvent);
 694
 695   mCurrentPanEmitters.clear();
 696   ResetActor();
 697
 698   actor->ScreenToLocal(*mCurrentRenderTask.Get(), actorCoordinates.x, actorCoordinates.y, mCurrentPanEvent->currentPosition.x, mCurrentPanEvent->currentPosition.y);
 699
 700   EmitPanSignal(actor, gestureDetectors, *mCurrentPanEvent, actorCoordinates, mCurrentPanEvent->state, mCurrentRenderTask);
 701
 702   if(actor->OnScene())
 703   {
 704     mCurrentPanEmitters = gestureDetectors;
 705     SetActor(actor);
 706   }
 707 }
 708
 709 } // namespace Internal
 710
 711 } // namespace Dali