dali/internal/event/events/gesture-event-processor.h

   1 #ifndef DALI_INTERNAL_GESTURE_EVENT_PROCESSOR_H
   2 #define DALI_INTERNAL_GESTURE_EVENT_PROCESSOR_H
   3
   4 /*
   5  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/actors/actor.h>
  23 #include <dali/public-api/events/gesture.h>
  24 #include <dali/internal/event/events/gesture-detector-impl.h>
  25 #include <dali/internal/event/events/long-press-gesture/long-press-gesture-processor.h>
  26 #include <dali/internal/event/events/pan-gesture/pan-gesture-processor.h>
  27 #include <dali/internal/event/events/pinch-gesture/pinch-gesture-processor.h>
  28 #include <dali/internal/event/events/rotation-gesture/rotation-gesture-processor.h>
  29 #include <dali/internal/event/events/tap-gesture/tap-gesture-processor.h>
  30
  31 namespace Dali
  32 {
  33
  34 namespace Integration
  35 {
  36
  37 class RenderController;
  38 }
  39
  40 namespace SceneGraph
  41 {
  42 class UpdateManager;
  43 }
  44
  45 namespace Internal
  46 {
  47
  48 class Stage;
  49 class Scene;
  50
  51 /**
  52  * Gesture Event Processing:
  53  *
  54  * The GestureEventProcessor determines what type of gesture event we have received and sends it to
  55  * the appropriate gesture processor for processing.
  56  */
  57 class GestureEventProcessor
  58 {
  59 public:
  60
  61   /**
  62    * Create a gesture event processor.
  63    * @param[in] updateManager The update manager
  64    * @param[in] renderController The render controller
  65    */
  66   GestureEventProcessor( SceneGraph::UpdateManager& updateManager, Integration::RenderController& renderController );
  67
  68   /**
  69    * Non-virtual destructor; GestureProcessor is not a base class
  70    */
  71   ~GestureEventProcessor();
  72
  73 public: // To be called by EventProcessor
  74
  75   /**
  76    * This function is called by Core whenever a touch event occurs
  77    * @param[in] scene The scene
  78    * @param[in] event The event that has occurred
  79    */
  80   void ProcessTouchEvent( Scene& scene, const Integration::TouchEvent& event);
  81
  82 public: // To be called by gesture detectors
  83
  84   /**
  85    * This method adds the specified gesture detector to the relevant gesture processor.
  86    * @param[in]  gestureDetector  The gesture detector to add
  87    */
  88   void AddGestureDetector(GestureDetector* gestureDetector, Scene& scene);
  89
  90   /**
  91    * This method removes the specified gesture detector from the relevant gesture processor.
  92    * @param[in]  gestureDetector  The gesture detector to remove.
  93    */
  94   void RemoveGestureDetector(GestureDetector* gestureDetector);
  95
  96   /**
  97    * This method informs the appropriate processor that the gesture detector has been updated.
  98    * @param[in]  gestureDetector  The gesture detector that has been updated.
  99    */
 100   void GestureDetectorUpdated(GestureDetector* gestureDetector);
 101
 102   /**
 103    * Called by GestureDetectors to set the gesture properties in the update thread.
 104    * @param[in]  gesture  The gesture whose values will be used in the Update object.
 105    * @note If we are in the middle of processing the gesture being set, then this call is ignored.
 106    */
 107   void SetGestureProperties( const Dali::Gesture& gesture );
 108
 109 public: // Called by Core
 110
 111   /**
 112    * Returns true if any GestureDetector requires a Core::Update. Clears
 113    * the state flag after reading.
 114    *
 115    * @return true if any GestureDetector requires a Core::Update
 116    */
 117   bool NeedsUpdate();
 118
 119   /**
 120    * Called to provide pan-gesture profiling information.
 121    */
 122   void EnablePanGestureProfiling();
 123
 124   /**
 125    * @brief Called to set how pan gestures predict input
 126    *
 127    * @param[in] mode The prediction mode to use
 128    */
 129   void SetPanGesturePredictionMode( int32_t mode );
 130
 131   /**
 132    * @brief Sets the prediction amount of the pan gesture
 133    *
 134    * @param[in] amount The prediction amount in milliseconds
 135    */
 136   void SetPanGesturePredictionAmount( uint32_t amount );
 137
 138   /**
 139    * @brief Sets the upper bound of the prediction amount for clamping
 140    *
 141    * @param[in] amount The prediction amount in milliseconds
 142    */
 143   void SetPanGestureMaximumPredictionAmount( uint32_t amount );
 144
 145   /**
 146    * @brief Sets the lower bound of the prediction amount for clamping
 147    *
 148    * @param[in] amount The prediction amount in milliseconds
 149    */
 150   void SetPanGestureMinimumPredictionAmount( uint32_t amount );
 151
 152   /**
 153    * @brief Sets the prediction amount to adjust when the pan velocity is changed.
 154    * If the pan velocity is accelerating, the prediction amount will be increased
 155    * by the specified amount until it reaches the upper bound. If the pan velocity
 156    * is decelerating, the prediction amount will be decreased by the specified amount
 157    * until it reaches the lower bound.
 158    *
 159    * @param[in] amount The prediction amount in milliseconds
 160    */
 161   void SetPanGesturePredictionAmountAdjustment( uint32_t amount );
 162
 163   /**
 164    * @brief Called to set how pan gestures smooth input
 165    *
 166    * @param[in] mode The smoothing mode to use
 167    */
 168   void SetPanGestureSmoothingMode( int32_t mode );
 169
 170   /**
 171    * @brief Sets the prediction amount of the pan gesture
 172    *
 173    * @param[in] amount The smoothing amount [0.0f,1.0f] - 0.0f would be no smoothing, 1.0f maximum smoothing
 174    */
 175   void SetPanGestureSmoothingAmount( float amount );
 176
 177   /*
 178    * @brief Sets whether to use actual times of the real gesture and frames or not.
 179    *
 180    * @param[in] value True = use actual times, False = use perfect values
 181    */
 182   void SetPanGestureUseActualTimes( bool value );
 183
 184   /**
 185    * @brief Sets the interpolation time range (ms) of past points to use (with weights) when interpolating.
 186    *
 187    * @param[in] value Time range in ms
 188    */
 189   void SetPanGestureInterpolationTimeRange( int32_t value );
 190
 191   /**
 192    * @brief Sets whether to use scalar only prediction, which when enabled, ignores acceleration.
 193    *
 194    * @param[in] value True = use scalar prediction only
 195    */
 196   void SetPanGestureScalarOnlyPredictionEnabled( bool value );
 197
 198   /**
 199    * @brief Sets whether to use two point prediction. This combines two interpolated points to get more steady acceleration and velocity values.
 200    *
 201    * @param[in] value True = use two point prediction
 202    */
 203   void SetPanGestureTwoPointPredictionEnabled( bool value );
 204
 205   /**
 206    * @brief Sets the time in the past to interpolate the second point when using two point interpolation.
 207    *
 208    * @param[in] value Time in past in ms
 209    */
 210   void SetPanGestureTwoPointInterpolatePastTime( int32_t value );
 211
 212   /**
 213    * @brief Sets the two point velocity bias. This is the ratio of first and second points to use for velocity.
 214    *
 215    * @param[in] value 0.0f = 100% first point. 1.0f = 100% of second point.
 216    */
 217   void SetPanGestureTwoPointVelocityBias( float value );
 218
 219   /**
 220    * @brief Sets the two point acceleration bias. This is the ratio of first and second points to use for acceleration.
 221    *
 222    * @param[in] value 0.0f = 100% first point. 1.0f = 100% of second point.
 223    */
 224   void SetPanGestureTwoPointAccelerationBias( float value );
 225
 226   /**
 227    * @brief Sets the range of time (ms) of points in the history to perform multitap smoothing with (if enabled).
 228    *
 229    * @param[in] value Time in past in ms
 230    */
 231   void SetPanGestureMultitapSmoothingRange( int32_t value );
 232
 233   /**
 234    * @brief Sets the minimum distance required to start a pan event
 235    *
 236    * @param[in] value Distance in pixels
 237    */
 238   void SetPanGestureMinimumDistance( int32_t value );
 239
 240   /**
 241    * @brief Sets the minimum number of touch events required to start a pan
 242    *
 243    * @param[in] value Number of touch events
 244    */
 245   void SetPanGestureMinimumPanEvents( int32_t value );
 246
 247   /**
 248    * @brief Sets the minimum distance required to start a pinch event
 249    *
 250    * @param[in] value Distance in pixels
 251    */
 252   void SetPinchGestureMinimumDistance( float value);
 253
 254   /**
 255    * @brief Sets the minimum touch events required before a pinch can be started
 256    *
 257    * @param[in] value The number of touch events
 258    */
 259   void SetPinchGestureMinimumTouchEvents( uint32_t value );
 260
 261   /**
 262    * @brief Sets the minimum touch events required after a pinch started
 263    *
 264    * @param[in] value The number of touch events
 265    */
 266   void SetPinchGestureMinimumTouchEventsAfterStart( uint32_t value );
 267
 268   /**
 269    * @brief Sets the minimum touch events required before a rotation can be started
 270    *
 271    * @param[in] value The number of touch events
 272    */
 273   void SetRotationGestureMinimumTouchEvents( uint32_t value );
 274
 275   /**
 276    * @brief Sets the minimum touch events required after a rotation started
 277    *
 278    * @param[in] value The number of touch events
 279    */
 280   void SetRotationGestureMinimumTouchEventsAfterStart( uint32_t value );
 281
 282   /**
 283    * @brief Sets the minimum holding time required to be recognized as a long press gesture
 284    *
 285    * @param[in] value The time value in milliseconds
 286    */
 287   void SetLongPressMinimumHoldingTime( uint32_t value );
 288
 289   /**
 290    * @return The minimum holding time required to be recognized as a long press gesture in milliseconds
 291    */
 292   uint32_t GetLongPressMinimumHoldingTime() const;
 293
 294 public: // needed for PanGesture
 295
 296   /**
 297    * @return the pan gesture processor
 298    */
 299   const PanGestureProcessor& GetPanGestureProcessor();
 300
 301 private:
 302
 303   // Undefined
 304   GestureEventProcessor(const GestureEventProcessor&);
 305   GestureEventProcessor& operator=(const GestureEventProcessor& rhs);
 306
 307 private:
 308
 309   LongPressGestureProcessor mLongPressGestureProcessor;
 310   PanGestureProcessor mPanGestureProcessor;
 311   PinchGestureProcessor mPinchGestureProcessor;
 312   TapGestureProcessor mTapGestureProcessor;
 313   RotationGestureProcessor mRotationGestureProcessor;
 314   Integration::RenderController& mRenderController;
 315
 316   int32_t envOptionMinimumPanDistance;
 317   int32_t envOptionMinimumPanEvents;
 318 };
 319
 320 } // namespace Internal
 321
 322 } // namespace Dali
 323
 324 #endif // DALI_INTERNAL_GESTURE_EVENT_PROCESSOR_H