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

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