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

   1 /*
   2  * Copyright (c) 2020 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/tap-gesture/tap-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/common/dali-common.h>
  27 #include <dali/public-api/events/tap-gesture.h>
  28 #include <dali/public-api/math/vector2.h>
  29 #include <dali/integration-api/debug.h>
  30 #include <dali/internal/event/actors/actor-impl.h>
  31 #include <dali/internal/event/render-tasks/render-task-impl.h>
  32 #include <dali/internal/event/common/scene-impl.h>
  33 #include <dali/internal/event/events/tap-gesture/tap-gesture-recognizer.h>
  34 #include <dali/internal/event/events/tap-gesture/tap-gesture-impl.h>
  35 #include <dali/internal/event/events/gesture-requests.h>
  36 #include <dali/internal/event/events/tap-gesture/tap-gesture-event.h>
  37
  38 namespace Dali
  39 {
  40
  41 namespace Internal
  42 {
  43
  44 namespace
  45 {
  46
  47 /**
  48  * Creates a TapGesture and asks the specified detector to emit its detected signal.
  49  * @param[in]  actor             The actor on which a tap has occurred.
  50  * @param[in]  gestureDetectors  A reference to gesture detectors that should emit the signal.
  51  * @param[in]  tapEvent          The tapEvent received from the adaptor.
  52  * @param[in]  localPoint        Relative to the actor attached to the detector.
  53  */
  54 void EmitTapSignal(
  55   Actor* actor,
  56   const GestureDetectorContainer& gestureDetectors,
  57   const TapGestureEvent& tapEvent,
  58   Vector2 localPoint)
  59 {
  60   Internal::TapGesturePtr tap( new Internal::TapGesture(tapEvent.state) );
  61   tap->SetTime( tapEvent.time );
  62   tap->SetNumberOfTaps(tapEvent.numberOfTaps);
  63   tap->SetNumberOfTouches(tapEvent.numberOfTouches);
  64   tap->SetScreenPoint(tapEvent.point);
  65   tap->SetLocalPoint(localPoint);
  66
  67   Dali::Actor actorHandle( actor );
  68   const GestureDetectorContainer::const_iterator endIter = gestureDetectors.end();
  69   for ( GestureDetectorContainer::const_iterator iter = gestureDetectors.begin(); iter != endIter; ++iter )
  70   {
  71     static_cast< TapGestureDetector* >( *iter )->EmitTapGestureSignal( actorHandle, Dali::TapGesture( tap.Get() ) );
  72   }
  73 }
  74
  75 } // unnamed namespace
  76
  77 TapGestureProcessor::TapGestureProcessor()
  78 : GestureProcessor( GestureType::TAP ),
  79   mTapGestureDetectors(),
  80   mMinTapsRequired( 1 ),
  81   mMaxTapsRequired( 1 ),
  82   mMinTouchesRequired( 1 ),
  83   mMaxTouchesRequired( 1 ),
  84   mCurrentTapEvent( nullptr ),
  85   mPossibleProcessed( false )
  86 {
  87 }
  88
  89 TapGestureProcessor::~TapGestureProcessor() = default;
  90
  91 void TapGestureProcessor::Process( Scene& scene, const TapGestureEvent& tapEvent )
  92 {
  93   switch ( tapEvent.state )
  94   {
  95     case GestureState::POSSIBLE:
  96     {
  97       // Do a hit test and if an actor has been hit then save to see if tap event is still valid on a tap( same actor being hit )
  98       HitTestAlgorithm::Results hitTestResults;
  99       if ( HitTest( scene, tapEvent.point, hitTestResults ) )
 100       {
 101         SetActor( &GetImplementation( hitTestResults.actor ) );
 102         mCurrentTapActor.SetActor( GetCurrentGesturedActor() );
 103
 104         // Indicate that we've processed a touch down. Bool should be sufficient as a change in actor will result in a cancellation
 105         mPossibleProcessed = true;
 106       }
 107       else
 108       {
 109         ResetActor();
 110       }
 111       break;
 112     }
 113
 114     case GestureState::STARTED:
 115     {
 116       // Ensure that we're processing a hit on the current actor and that we've already processed a touch down
 117       HitTestAlgorithm::Results hitTestResults;
 118       if ( GetCurrentGesturedActor() && HitTest( scene, tapEvent.point, hitTestResults ) && mPossibleProcessed )
 119       {
 120         // Check that this actor is still the one that was used for the last touch down ?
 121         if ( mCurrentTapActor.GetActor() == &GetImplementation( hitTestResults.actor ) )
 122         {
 123           mCurrentTapEvent = &tapEvent;
 124           ProcessAndEmit( hitTestResults );
 125         }
 126         mCurrentTapEvent = nullptr;
 127         mPossibleProcessed = false;
 128       }
 129       break;
 130     }
 131
 132     case GestureState::CANCELLED:
 133     {
 134       mPossibleProcessed = false;
 135       ResetActor();
 136       break;
 137     }
 138
 139     case GestureState::CONTINUING:
 140     {
 141       DALI_ABORT( "Incorrect state received from Integration layer: CONTINUING\n" );
 142       break;
 143     }
 144     case GestureState::FINISHED:
 145     {
 146       DALI_ABORT( "Incorrect state received from Integration layer: FINISHED\n" );
 147       break;
 148     }
 149     case GestureState::CLEAR:
 150     {
 151       DALI_ABORT( "Incorrect state received from Integration layer: CLEAR\n" );
 152       break;
 153     }
 154   }
 155 }
 156
 157 void TapGestureProcessor::AddGestureDetector( TapGestureDetector* gestureDetector, Scene& scene )
 158 {
 159   bool firstRegistration(mTapGestureDetectors.empty());
 160
 161   mTapGestureDetectors.push_back(gestureDetector);
 162
 163   const unsigned int minTapsRequired = gestureDetector->GetMinimumTapsRequired();
 164   const unsigned int maxTapsRequired = gestureDetector->GetMaximumTapsRequired();
 165   const unsigned int touchesRequired = gestureDetector->GetTouchesRequired();
 166
 167   DALI_ASSERT_ALWAYS( minTapsRequired <= maxTapsRequired && "Minimum taps requested is greater than the maximum requested" );
 168
 169   if (firstRegistration)
 170   {
 171     // If this is the first tap gesture detector that has been added, then our minimum and maximum
 172     // requirements are the same as each other.
 173
 174     mMinTapsRequired = minTapsRequired;
 175     mMaxTapsRequired = maxTapsRequired;
 176     mMinTouchesRequired = mMaxTouchesRequired = touchesRequired;
 177
 178     TapGestureRequest request;
 179     request.minTaps = mMinTapsRequired;
 180     request.maxTaps = mMaxTapsRequired;
 181     request.minTouches = mMinTouchesRequired;
 182     request.maxTouches = mMaxTouchesRequired;
 183
 184     Size size = scene.GetSize();
 185     mGestureRecognizer = new TapGestureRecognizer(*this, Vector2(size.width, size.height), static_cast<const TapGestureRequest&>(request));
 186   }
 187   else
 188   {
 189     // If we have already registered for tap gesture detection before then we need to check our
 190     // minimum and maximums and see if our gesture detection requirements have changed, if they
 191     // have, then we should ask the adaptor to update its detection policy.
 192
 193     // This is quicker than calling UpdateDetection as there is no need to iterate through the container
 194
 195     unsigned int minTaps = mMinTapsRequired < minTapsRequired ? mMinTapsRequired : minTapsRequired;
 196     unsigned int maxTaps = mMaxTapsRequired > maxTapsRequired ? mMaxTapsRequired : maxTapsRequired;
 197     unsigned int minTouches = mMinTouchesRequired < touchesRequired ? mMinTouchesRequired : touchesRequired;
 198     unsigned int maxTouches = mMaxTouchesRequired > touchesRequired ? mMaxTouchesRequired : touchesRequired;
 199
 200     if ( (minTaps != mMinTapsRequired)||(maxTaps != mMaxTapsRequired) ||
 201          (minTouches != mMinTouchesRequired)||(maxTouches != mMaxTouchesRequired) )
 202     {
 203       TapGestureRequest request;
 204       request.minTaps = mMinTapsRequired = minTaps;
 205       request.maxTaps = mMaxTapsRequired = maxTaps;
 206       request.minTouches = mMinTouchesRequired = minTouches;
 207       request.maxTouches = mMaxTouchesRequired = maxTouches;
 208
 209       mGestureRecognizer->Update(request);
 210     }
 211   }
 212 }
 213
 214 void TapGestureProcessor::RemoveGestureDetector( TapGestureDetector* gestureDetector )
 215 {
 216   // Find detector ...
 217   TapGestureDetectorContainer::iterator endIter = std::remove( mTapGestureDetectors.begin(), mTapGestureDetectors.end(), gestureDetector );
 218   DALI_ASSERT_DEBUG( endIter != mTapGestureDetectors.end() );
 219
 220   // ... and remove it
 221   mTapGestureDetectors.erase( endIter, mTapGestureDetectors.end() );
 222
 223   if ( mTapGestureDetectors.empty() )
 224   {
 225     mGestureRecognizer = nullptr;
 226
 227     ResetActor();
 228   }
 229   else
 230   {
 231     UpdateDetection();
 232   }
 233 }
 234
 235 void TapGestureProcessor::GestureDetectorUpdated( TapGestureDetector* gestureDetector )
 236 {
 237   DALI_ASSERT_DEBUG(find(mTapGestureDetectors.begin(), mTapGestureDetectors.end(), gestureDetector) != mTapGestureDetectors.end());
 238
 239   const unsigned int minTapsRequired = gestureDetector->GetMinimumTapsRequired();
 240   const unsigned int maxTapsRequired = gestureDetector->GetMaximumTapsRequired();
 241
 242   DALI_ASSERT_ALWAYS( minTapsRequired <= maxTapsRequired && "Minimum taps requested is greater than the maximum requested" );
 243
 244   UpdateDetection();
 245 }
 246
 247 void TapGestureProcessor::UpdateDetection()
 248 {
 249   DALI_ASSERT_DEBUG(!mTapGestureDetectors.empty());
 250
 251   unsigned int minTaps = UINT_MAX;
 252   unsigned int maxTaps = 0;
 253   unsigned int minTouches = UINT_MAX;
 254   unsigned int maxTouches = 0;
 255
 256   for ( TapGestureDetectorContainer::iterator iter = mTapGestureDetectors.begin(), endIter = mTapGestureDetectors.end(); iter != endIter; ++iter )
 257   {
 258     TapGestureDetector* detector(*iter);
 259
 260     if( detector )
 261     {
 262       const unsigned int minTapsRequired = detector->GetMinimumTapsRequired();
 263       const unsigned int maxTapsRequired = detector->GetMaximumTapsRequired();
 264       const unsigned int touchesRequired = detector->GetTouchesRequired();
 265
 266       minTaps = minTapsRequired < minTaps ? minTapsRequired : minTaps;
 267       maxTaps = maxTapsRequired > maxTaps ? maxTapsRequired : maxTaps;
 268       minTouches = touchesRequired < minTouches ? touchesRequired : minTouches;
 269       maxTouches = touchesRequired > maxTouches ? touchesRequired : maxTouches;
 270     }
 271   }
 272
 273   if ( (minTaps != mMinTapsRequired)||(maxTaps != mMaxTapsRequired) ||
 274        (minTouches != mMinTouchesRequired)||(maxTouches != mMaxTouchesRequired) )
 275   {
 276     TapGestureRequest request;
 277     request.minTaps = mMinTapsRequired = minTaps;
 278     request.maxTaps = mMaxTapsRequired = maxTaps;
 279     request.minTouches = mMinTouchesRequired = minTouches;
 280     request.maxTouches = mMaxTouchesRequired = maxTouches;
 281
 282     mGestureRecognizer->Update(request);
 283   }
 284 }
 285
 286 bool TapGestureProcessor::CheckGestureDetector( GestureDetector* detector, Actor* actor )
 287 {
 288   DALI_ASSERT_DEBUG( mCurrentTapEvent );
 289
 290   TapGestureDetector* tapDetector ( static_cast< TapGestureDetector* >( detector ) );
 291
 292   return ( ( tapDetector->GetMinimumTapsRequired() <= mCurrentTapEvent->numberOfTaps ) && ( tapDetector->GetMaximumTapsRequired() >= mCurrentTapEvent->numberOfTaps ) ) &&
 293          ( tapDetector->GetTouchesRequired() == mCurrentTapEvent->numberOfTouches );
 294 }
 295
 296 void TapGestureProcessor::EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates )
 297 {
 298   DALI_ASSERT_DEBUG( mCurrentTapEvent );
 299
 300   EmitTapSignal( actor, gestureDetectors, *mCurrentTapEvent, actorCoordinates );
 301 }
 302
 303 } // namespace Internal
 304
 305 } // namespace Dali