adaptors/common/events/gesture-manager.cpp

   1 /*
   2  * Copyright (c) 2014 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 "gesture-manager.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <boost/bind.hpp>
  23
  24 #include <dali/integration-api/debug.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <events/gesture-detector.h>
  28 #include <events/long-press-gesture-detector.h>
  29 #include <events/pan-gesture-detector.h>
  30 #include <events/pinch-gesture-detector.h>
  31 #include <events/tap-gesture-detector.h>
  32 #include <base/core-event-interface.h>
  33
  34 namespace Dali
  35 {
  36
  37 namespace Internal
  38 {
  39
  40 namespace Adaptor
  41 {
  42
  43 namespace
  44 {
  45
  46 #if defined(DEBUG_ENABLED)
  47 Integration::Log::Filter* gLogFilter  = Integration::Log::Filter::New( Debug::NoLogging, false, "LOG_GESTURE_MANAGER" );
  48
  49 /**
  50  * Helper method to return the string representation of a gesture type.
  51  */
  52 const char * GetGestureTypeString( Gesture::Type type )
  53 {
  54   static const char * const pinch( "Pinch" );
  55   static const char * const pan( "Pan" );
  56   static const char * const tap( "tap" );
  57   static const char * const longPress( "LongPress" );
  58   static const char * const invalid( "Invalid" );
  59
  60   const char * retVal( NULL );
  61
  62   switch ( type )
  63   {
  64     case Gesture::LongPress:
  65     {
  66       retVal = longPress;
  67       break;
  68     }
  69
  70     case Gesture::Pan:
  71     {
  72       retVal = pan;
  73       break;
  74     }
  75
  76     case Gesture::Pinch:
  77     {
  78       retVal = pinch;
  79       break;
  80     }
  81
  82     case Gesture::Tap:
  83     {
  84       retVal = tap;
  85       break;
  86     }
  87
  88     default:
  89       retVal = invalid;
  90       break;
  91   }
  92
  93   return retVal;
  94 };
  95 #endif // DEBUG_ENABLED
  96
  97 const float MINIMUM_DISTANCE_DELTA_DIVISOR = 85.0f;
  98 } // unnamed namespace
  99
 100 GestureManager::GestureManager(CoreEventInterface& coreEventInterface, Vector2 screenSize,CallbackManager* callbackManager, EnvironmentOptions& environmentOptions)
 101 : mCoreEventInterface( coreEventInterface ),
 102   mScreenSize( screenSize ),
 103   mCallbackManager( callbackManager ),
 104   mEnvironmentOptions( environmentOptions ),
 105   mMinimumDistanceDelta(-1.0f),
 106   mRunning( true ) // This allows gestures to be created before Adaptor::Start() is called e.g. by Indicator
 107 {
 108   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Creating GestureManager\n" );
 109 }
 110
 111 GestureManager::~GestureManager()
 112 {
 113   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Destroying GestureManager\n" );
 114 }
 115
 116 void GestureManager::SendEvent(const Integration::TouchEvent& event)
 117 {
 118   if (mRunning)
 119   {
 120     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "SendEvent: START\n" );
 121
 122     // gestures can be added / deleted during SendEvent so we make a copy of the container.
 123     // the gestures are reference counted, so unused gesture detectors will be deleted when
 124     // the local variable detectors goes out of scope.
 125     GestureDetectorContainer detectors( mGestureDetectors );
 126
 127     // Send the event to all gesture detectors.
 128     for ( GestureDetectorContainer::iterator iter = detectors.begin(), endIter = detectors.end(); iter != endIter; ++iter )
 129     {
 130       (*iter)->SendEvent(event);
 131     }
 132     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "SendEvent: END\n" );
 133   }
 134 }
 135
 136 void GestureManager::Stop()
 137 {
 138   if (mRunning)
 139   {
 140     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Stop\n" );
 141
 142     mGestureDetectors.clear();
 143     mRunning = false;
 144   }
 145 }
 146
 147 void GestureManager::SetMinimumPinchDistance(float distance)
 148 {
 149   mMinimumDistanceDelta = distance;
 150   for( GestureDetectorContainer::iterator iter = mGestureDetectors.begin(), endIter = mGestureDetectors.end(); iter != endIter; ++iter )
 151   {
 152     if ( ( *iter )->GetType() == Gesture::Pinch )
 153     {
 154       DALI_LOG_INFO( gLogFilter, Debug::General, "Set Minimum Pinch Distance: %f\n", distance );
 155       PinchGestureDetector* gestureDetector = static_cast<PinchGestureDetector*>(iter->Get());
 156       gestureDetector->SetMinimumPinchDistance(distance);
 157       break;
 158     }
 159   }
 160 }
 161
 162 void GestureManager::Register(const Integration::GestureRequest& request)
 163 {
 164   if (mRunning)
 165   {
 166     DALI_LOG_INFO( gLogFilter, Debug::General, "Creating %s Detector\n", GetGestureTypeString( request.type ) );
 167
 168     switch (request.type)
 169     {
 170       case Gesture::LongPress:
 171       {
 172         GestureDetectorPtr gesture = new LongPressGestureDetector(mCoreEventInterface, mScreenSize, static_cast<const Integration::LongPressGestureRequest&>(request));
 173         mGestureDetectors.push_back(gesture);
 174         break;
 175       }
 176
 177       case Gesture::Pan:
 178       {
 179         GestureDetectorPtr gesture = new PanGestureDetector(mCoreEventInterface, mScreenSize, static_cast<const Integration::PanGestureRequest&>(request), mEnvironmentOptions);
 180         mGestureDetectors.push_back(gesture);
 181         break;
 182       }
 183
 184       case Gesture::Pinch:
 185       {
 186         float minPinchDistance = mMinimumDistanceDelta >= 0.0f ? mMinimumDistanceDelta : (mScreenSize.height / MINIMUM_DISTANCE_DELTA_DIVISOR);
 187         GestureDetectorPtr gesture = new PinchGestureDetector(mCoreEventInterface, mScreenSize, minPinchDistance);
 188         mGestureDetectors.push_back(gesture);
 189         break;
 190       }
 191
 192       case Gesture::Tap:
 193       {
 194         GestureDetectorPtr gesture = new TapGestureDetector(mCoreEventInterface, mScreenSize, static_cast<const Integration::TapGestureRequest&>(request));
 195         mGestureDetectors.push_back(gesture);
 196         break;
 197       }
 198
 199       default:
 200         DALI_ASSERT_DEBUG(false);
 201         break;
 202     }
 203   }
 204 }
 205
 206 void GestureManager::Unregister(const Integration::GestureRequest& request)
 207 {
 208   if ( mRunning )
 209   {
 210     DALI_LOG_INFO( gLogFilter, Debug::General, "Unregister: %s\n", GetGestureTypeString( request.type ) );
 211
 212     DeleteGestureDetector( request.type );
 213
 214   }
 215 }
 216
 217 void GestureManager::Update(const Integration::GestureRequest& request)
 218 {
 219   for( GestureDetectorContainer::iterator iter = mGestureDetectors.begin(), endIter = mGestureDetectors.end(); iter < endIter; ++iter )
 220   {
 221     if ( (*iter)->GetType() == request.type )
 222     {
 223       DALI_LOG_INFO( gLogFilter, Debug::General, "Update: %s\n", GetGestureTypeString( request.type ) );
 224       (*iter)->Update( request );
 225       break;
 226     }
 227   }
 228 }
 229
 230 void GestureManager::DeleteGestureDetector( Gesture::Type type )
 231 {
 232   for( GestureDetectorContainer::iterator iter = mGestureDetectors.begin(), endIter = mGestureDetectors.end(); iter != endIter; ++iter )
 233   {
 234     if ( ( *iter )->GetType() == type )
 235     {
 236       DALI_LOG_INFO( gLogFilter, Debug::General, "DeleteGestureDetector: %s\n", GetGestureTypeString( type ) );
 237       mGestureDetectors.erase( iter );
 238       break;
 239     }
 240   }
 241 }
 242
 243 } // namespace Adaptor
 244
 245 } // namespace Internal
 246
 247 } // namespace Dali