dali/internal/event/events/pinch-gesture/pinch-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/pinch-gesture/pinch-gesture-processor.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <algorithm>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/integration-api/debug.h>
  26 #include <dali/integration-api/trace.h>
  27 #include <dali/internal/event/common/scene-impl.h>
  28 #include <dali/internal/event/events/gesture-requests.h>
  29 #include <dali/internal/event/events/pinch-gesture/pinch-gesture-event.h>
  30 #include <dali/internal/event/events/pinch-gesture/pinch-gesture-impl.h>
  31 #include <dali/internal/event/events/pinch-gesture/pinch-gesture-recognizer.h>
  32 #include <dali/internal/event/render-tasks/render-task-impl.h>
  33 #include <dali/public-api/actors/actor.h>
  34 #include <dali/public-api/events/pinch-gesture.h>
  35 #include <dali/public-api/math/vector2.h>
  36
  37 namespace Dali
  38 {
  39 namespace Internal
  40 {
  41 namespace
  42 {
  43 DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false);
  44 const uint32_t MINIMUM_TOUCH_EVENTS_REQUIRED             = 4u;
  45 const uint32_t MINIMUM_TOUCH_EVENTS_REQUIRED_AFTER_START = 4u;
  46
  47 /**
  48  * Creates a PinchGesture and asks the specified detector to emit its detected signal.
  49  * @param[in]  actor             The actor that has been pinched.
  50  * @param[in]  gestureDetectors  The gesture detector container that should emit the signal.
  51  * @param[in]  pinchEvent        The pinchEvent received from the adaptor.
  52  * @param[in]  localCenter       Relative to the actor attached to the detector.
  53  */
  54 void EmitPinchSignal(
  55   Actor*                          actor,
  56   const GestureDetectorContainer& gestureDetectors,
  57   const PinchGestureEvent&        pinchEvent,
  58   Vector2                         localCenter)
  59 {
  60   Internal::PinchGesturePtr pinch(new Internal::PinchGesture(pinchEvent.state));
  61   pinch->SetTime(pinchEvent.time);
  62
  63   pinch->SetScale(pinchEvent.scale);
  64   pinch->SetSpeed(pinchEvent.speed);
  65   pinch->SetScreenCenterPoint(pinchEvent.centerPoint);
  66
  67   pinch->SetLocalCenterPoint(localCenter);
  68   pinch->SetSourceType(pinchEvent.sourceType);
  69   pinch->SetSourceData(pinchEvent.sourceData);
  70
  71   DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_EMIT_PINCH_GESTURE_SIGNAL", [&](std::ostringstream& oss) {
  72     oss << "[" << gestureDetectors.size() << "]";
  73   });
  74
  75   Dali::Actor                                    actorHandle(actor);
  76   const GestureDetectorContainer::const_iterator endIter = gestureDetectors.end();
  77   for(GestureDetectorContainer::const_iterator iter = gestureDetectors.begin(); iter != endIter; ++iter)
  78   {
  79     static_cast<PinchGestureDetector*>(*iter)->EmitPinchGestureSignal(actorHandle, Dali::PinchGesture(pinch.Get()));
  80   }
  81
  82   DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_EMIT_PINCH_GESTURE_SIGNAL", [&](std::ostringstream& oss) {
  83     oss << "[" << gestureDetectors.size() << "]";
  84   });
  85 }
  86
  87 /**
  88  * Functor which checks whether the specified actor is attached to the gesture detector.
  89  * It returns true if it is no longer attached.  This can be used in remove_if functions.
  90  */
  91 struct IsNotAttachedFunctor
  92 {
  93   /**
  94    * Constructor
  95    * @param[in]  actor  The actor to check whether it is attached.
  96    */
  97   IsNotAttachedFunctor(Actor* actor)
  98   : actorToCheck(actor)
  99   {
 100   }
 101
 102   /**
 103    * Returns true if not attached, false if it is still attached.
 104    * @param[in]  detector  The detector to check.
 105    * @return true, if not attached, false otherwise.
 106    */
 107   bool operator()(const GestureDetector* detector) const
 108   {
 109     return !detector->IsAttached(*actorToCheck);
 110   }
 111
 112   Actor* actorToCheck; ///< The actor to check whether it is attached or not.
 113 };
 114
 115 } // unnamed namespace
 116
 117 PinchGestureProcessor::PinchGestureProcessor()
 118 : GestureProcessor(GestureType::PINCH),
 119   mPinchGestureDetectors(),
 120   mCurrentPinchEmitters(),
 121   mCurrentPinchEvent(nullptr),
 122   mMinimumPinchDistance(-1.0f),
 123   mMinimumTouchEvents(MINIMUM_TOUCH_EVENTS_REQUIRED),
 124   mMinimumTouchEventsAfterStart(MINIMUM_TOUCH_EVENTS_REQUIRED_AFTER_START)
 125 {
 126 }
 127
 128 PinchGestureProcessor::~PinchGestureProcessor() = default;
 129
 130 void PinchGestureProcessor::SetMinimumPinchDistance(float value)
 131 {
 132   mMinimumPinchDistance = value;
 133
 134   if(mGestureRecognizer)
 135   {
 136     PinchGestureRecognizer* pinchRecognizer = dynamic_cast<PinchGestureRecognizer*>(mGestureRecognizer.Get());
 137     if(pinchRecognizer)
 138     {
 139       pinchRecognizer->SetMinimumPinchDistance(value);
 140     }
 141   }
 142 }
 143
 144 void PinchGestureProcessor::SetMinimumTouchEvents(uint32_t value)
 145 {
 146   if(value > 1u && mMinimumTouchEvents != value)
 147   {
 148     mMinimumTouchEvents = value;
 149
 150     if(mGestureRecognizer)
 151     {
 152       PinchGestureRecognizer* pinchRecognizer = dynamic_cast<PinchGestureRecognizer*>(mGestureRecognizer.Get());
 153       if(pinchRecognizer)
 154       {
 155         pinchRecognizer->SetMinimumTouchEvents(value);
 156       }
 157     }
 158   }
 159 }
 160
 161 void PinchGestureProcessor::SetMinimumTouchEventsAfterStart(uint32_t value)
 162 {
 163   if(value > 1u && mMinimumTouchEventsAfterStart != value)
 164   {
 165     mMinimumTouchEventsAfterStart = value;
 166
 167     if(mGestureRecognizer)
 168     {
 169       PinchGestureRecognizer* pinchRecognizer = dynamic_cast<PinchGestureRecognizer*>(mGestureRecognizer.Get());
 170       if(pinchRecognizer)
 171       {
 172         pinchRecognizer->SetMinimumTouchEventsAfterStart(value);
 173       }
 174     }
 175   }
 176 }
 177
 178 void PinchGestureProcessor::Process(Scene& scene, const PinchGestureEvent& pinchEvent, Actor* actor)
 179 {
 180   DALI_TRACE_SCOPE(gTraceFilter, "DALI_PROCESS_PINCH_GESTURE");
 181   switch(pinchEvent.state)
 182   {
 183     case GestureState::STARTED:
 184     {
 185       // The pinch gesture should only be sent to the gesture detector which first received it so that
 186       // it can be told when the gesture ends as well.
 187
 188       mCurrentPinchEmitters.clear();
 189       ResetActor();
 190
 191       HitTestAlgorithm::Results hitTestResults;
 192       if(actor)
 193       {
 194         hitTestResults.actor = Dali::Actor(actor);
 195         hitTestResults.renderTask = pinchEvent.renderTask;
 196
 197         // Record the current render-task for Screen->Actor coordinate conversions
 198         mCurrentRenderTask = hitTestResults.renderTask;
 199
 200         Vector2     actorCoords;
 201         actor->ScreenToLocal(*mCurrentRenderTask.Get(), actorCoords.x, actorCoords.y, pinchEvent.centerPoint.x, pinchEvent.centerPoint.y);
 202         hitTestResults.actorCoordinates = actorCoords;
 203
 204         // Set mCurrentPinchEvent to use inside overridden methods called from ProcessAndEmit()
 205         mCurrentPinchEvent = &pinchEvent;
 206         ProcessAndEmitActor(hitTestResults);
 207         mCurrentPinchEvent = nullptr;
 208       }
 209       else if(HitTest(scene, pinchEvent.centerPoint, hitTestResults))
 210       {
 211         // Record the current render-task for Screen->Actor coordinate conversions
 212         mCurrentRenderTask = hitTestResults.renderTask;
 213
 214         // Set mCurrentPinchEvent to use inside overridden methods called from ProcessAndEmit()
 215         mCurrentPinchEvent = &pinchEvent;
 216         ProcessAndEmit(hitTestResults);
 217         mCurrentPinchEvent = nullptr;
 218       }
 219       break;
 220     }
 221
 222     case GestureState::CONTINUING:
 223     case GestureState::FINISHED:
 224     case GestureState::CANCELLED:
 225     {
 226       // Only send subsequent pinch gesture signals if we processed the pinch gesture when it started.
 227       // Check if actor is still touchable.
 228
 229       Actor* currentGesturedActor = GetCurrentGesturedActor();
 230       if(currentGesturedActor)
 231       {
 232         if(currentGesturedActor->IsHittable() && !mCurrentPinchEmitters.empty() && mCurrentRenderTask)
 233         {
 234           // Ensure actor is still attached to the emitters, if it is not then remove the emitter.
 235           GestureDetectorContainer::iterator endIter = std::remove_if(mCurrentPinchEmitters.begin(), mCurrentPinchEmitters.end(), IsNotAttachedFunctor(currentGesturedActor));
 236           mCurrentPinchEmitters.erase(endIter, mCurrentPinchEmitters.end());
 237
 238           if(!mCurrentPinchEmitters.empty())
 239           {
 240             Vector2     actorCoords;
 241             RenderTask& renderTaskImpl(*mCurrentRenderTask.Get());
 242             currentGesturedActor->ScreenToLocal(renderTaskImpl, actorCoords.x, actorCoords.y, pinchEvent.centerPoint.x, pinchEvent.centerPoint.y);
 243
 244             EmitPinchSignal(currentGesturedActor, mCurrentPinchEmitters, pinchEvent, actorCoords);
 245           }
 246           else
 247           {
 248             // If we have no current emitters then clear pinched actor as well.
 249             ResetActor();
 250           }
 251
 252           // Clear current emitters if pinch gesture has ended or been cancelled.
 253           if(pinchEvent.state == GestureState::FINISHED || pinchEvent.state == GestureState::CANCELLED)
 254           {
 255             mCurrentPinchEmitters.clear();
 256             ResetActor();
 257           }
 258         }
 259         else
 260         {
 261           mCurrentPinchEmitters.clear();
 262           ResetActor();
 263         }
 264       }
 265       break;
 266     }
 267
 268     case GestureState::CLEAR:
 269     {
 270       DALI_ABORT("Incorrect state received from Integration layer: CLEAR\n");
 271       break;
 272     }
 273     case GestureState::POSSIBLE:
 274     {
 275       DALI_ABORT("Incorrect state received from Integration layer: POSSIBLE\n");
 276       break;
 277     }
 278   }
 279 }
 280
 281 void PinchGestureProcessor::AddGestureDetector(PinchGestureDetector* gestureDetector, Scene& scene)
 282 {
 283   bool createRecognizer(mPinchGestureDetectors.empty());
 284
 285   mPinchGestureDetectors.push_back(gestureDetector);
 286
 287   if(createRecognizer)
 288   {
 289     Size size          = scene.GetSize();
 290     mGestureRecognizer = new PinchGestureRecognizer(*this, Vector2(size.width, size.height), scene.GetDpi(), mMinimumPinchDistance, mMinimumTouchEvents, mMinimumTouchEventsAfterStart);
 291   }
 292 }
 293
 294 void PinchGestureProcessor::RemoveGestureDetector(PinchGestureDetector* gestureDetector)
 295 {
 296   if(!mCurrentPinchEmitters.empty())
 297   {
 298     // Check if the removed detector was one that is currently being pinched and remove it from emitters.
 299     GestureDetectorContainer::iterator endIter = std::remove(mCurrentPinchEmitters.begin(), mCurrentPinchEmitters.end(), gestureDetector);
 300     mCurrentPinchEmitters.erase(endIter, mCurrentPinchEmitters.end());
 301
 302     // If we no longer have any emitters, then we should clear mCurrentGesturedActor as well
 303     if(mCurrentPinchEmitters.empty())
 304     {
 305       ResetActor();
 306     }
 307   }
 308
 309   // Find the detector...
 310   PinchGestureDetectorContainer::iterator endIter = std::remove(mPinchGestureDetectors.begin(), mPinchGestureDetectors.end(), gestureDetector);
 311   DALI_ASSERT_DEBUG(endIter != mPinchGestureDetectors.end());
 312
 313   // ...and remove it
 314   mPinchGestureDetectors.erase(endIter, mPinchGestureDetectors.end());
 315
 316   if(mPinchGestureDetectors.empty())
 317   {
 318     mGestureRecognizer = nullptr;
 319   }
 320 }
 321
 322 void PinchGestureProcessor::GestureDetectorUpdated(PinchGestureDetector* gestureDetector)
 323 {
 324   // Nothing to do as PinchGestureDetector does not have any specific parameters.
 325 }
 326
 327 void PinchGestureProcessor::OnGesturedActorStageDisconnection()
 328 {
 329   mCurrentPinchEmitters.clear();
 330 }
 331
 332 bool PinchGestureProcessor::CheckGestureDetector(GestureDetector* detector, Actor* actor)
 333 {
 334   // No special case required for pinch.
 335   return true;
 336 }
 337
 338 void PinchGestureProcessor::EmitGestureSignal(Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates)
 339 {
 340   DALI_ASSERT_DEBUG(mCurrentPinchEvent);
 341
 342   EmitPinchSignal(actor, gestureDetectors, *mCurrentPinchEvent, actorCoordinates);
 343
 344   if(actor->OnScene())
 345   {
 346     mCurrentPinchEmitters = gestureDetectors;
 347     SetActor(actor);
 348   }
 349 }
 350
 351 } // namespace Internal
 352
 353 } // namespace Dali