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