X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Fevents%2Fgesture-event-processor.h;h=ebef0e28b7bb6cd96b15d4ef81a86afbb1675edf;hb=da4ad1b400618f4663547453326cffa8a6c789cc;hp=27c583764713ef1b9e92c79e2c4f463b8f65c8f8;hpb=98a2c4b3f41b29795b03a738e8f570ae36fb3906;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/event/events/gesture-event-processor.h b/dali/internal/event/events/gesture-event-processor.h index 27c5837..ebef0e2 100644 --- a/dali/internal/event/events/gesture-event-processor.h +++ b/dali/internal/event/events/gesture-event-processor.h @@ -1,46 +1,49 @@ -#ifndef __DALI_INTERNAL_GESTURE_EVENT_PROCESSOR_H__ -#define __DALI_INTERNAL_GESTURE_EVENT_PROCESSOR_H__ - -// -// Copyright (c) 2014 Samsung Electronics Co., Ltd. -// -// Licensed under the Flora License, Version 1.0 (the License); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://floralicense.org/license/ -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an AS IS BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// +#ifndef DALI_INTERNAL_GESTURE_EVENT_PROCESSOR_H +#define DALI_INTERNAL_GESTURE_EVENT_PROCESSOR_H + +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ // INTERNAL INCLUDES -#include #include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include namespace Dali { - -struct Gesture; - namespace Integration { -struct GestureEvent; -class GestureManager; class RenderController; } -namespace Internal +namespace SceneGraph { +class UpdateManager; +} +namespace Internal +{ class Stage; +class Scene; /** * Gesture Event Processing: @@ -51,14 +54,12 @@ class Stage; class GestureEventProcessor { public: - /** * Create a gesture event processor. - * @param[in] stage The stage. - * @param[in] gestureManager The gesture manager + * @param[in] updateManager The update manager * @param[in] renderController The render controller */ - GestureEventProcessor(Stage& stage, Integration::GestureManager& gestureManager, Integration::RenderController& renderController); + GestureEventProcessor(SceneGraph::UpdateManager& updateManager, Integration::RenderController& renderController); /** * Non-virtual destructor; GestureProcessor is not a base class @@ -66,20 +67,19 @@ public: ~GestureEventProcessor(); public: // To be called by EventProcessor - /** - * This function is called by Core whenever a gesture event occurs. - * @param[in] event The event that has occurred. + * This function is called by Core whenever a touch event occurs + * @param[in] scene The scene + * @param[in] event The event that has occurred */ - void ProcessGestureEvent(const Integration::GestureEvent& event); + void ProcessTouchEvent(Scene& scene, const Integration::TouchEvent& event); public: // To be called by gesture detectors - /** * This method adds the specified gesture detector to the relevant gesture processor. * @param[in] gestureDetector The gesture detector to add */ - void AddGestureDetector(GestureDetector* gestureDetector); + void AddGestureDetector(GestureDetector* gestureDetector, Scene& scene); /** * This method removes the specified gesture detector from the relevant gesture processor. @@ -94,20 +94,13 @@ public: // To be called by gesture detectors void GestureDetectorUpdated(GestureDetector* gestureDetector); /** - * This method is called by GestureDetectors on Started or Continue state events. - * Status is queried and reset by Core in ProcessEvents - */ - void SetUpdateRequired(); - - /** * Called by GestureDetectors to set the gesture properties in the update thread. * @param[in] gesture The gesture whose values will be used in the Update object. * @note If we are in the middle of processing the gesture being set, then this call is ignored. */ - void SetGestureProperties( const Gesture& gesture ); + void SetGestureProperties(const Dali::Gesture& gesture); public: // Called by Core - /** * Returns true if any GestureDetector requires a Core::Update. Clears * the state flag after reading. @@ -122,41 +115,200 @@ public: // Called by Core void EnablePanGestureProfiling(); /** - * @brief Called to set how pan gestures predict and smooth input + * @brief Called to set how pan gestures predict input * * @param[in] mode The prediction mode to use */ - void SetPanGesturePredictionMode( int mode ); + void SetPanGesturePredictionMode(int32_t mode); /** * @brief Sets the prediction amount of the pan gesture * - * @param[in] amount The prediction amount, 0.0f being next vsync and each 1.0f on top is another vsync ahead, can be divisions of (0.5f) + * @param[in] amount The prediction amount in milliseconds */ - void SetPanGesturePredictionAmount( float amount ); + void SetPanGesturePredictionAmount(uint32_t amount); -private: + /** + * @brief Sets the upper bound of the prediction amount for clamping + * + * @param[in] amount The prediction amount in milliseconds + */ + void SetPanGestureMaximumPredictionAmount(uint32_t amount); + + /** + * @brief Sets the lower bound of the prediction amount for clamping + * + * @param[in] amount The prediction amount in milliseconds + */ + void SetPanGestureMinimumPredictionAmount(uint32_t amount); + + /** + * @brief Sets the prediction amount to adjust when the pan velocity is changed. + * If the pan velocity is accelerating, the prediction amount will be increased + * by the specified amount until it reaches the upper bound. If the pan velocity + * is decelerating, the prediction amount will be decreased by the specified amount + * until it reaches the lower bound. + * + * @param[in] amount The prediction amount in milliseconds + */ + void SetPanGesturePredictionAmountAdjustment(uint32_t amount); + + /** + * @brief Called to set how pan gestures smooth input + * + * @param[in] mode The smoothing mode to use + */ + void SetPanGestureSmoothingMode(int32_t mode); + + /** + * @brief Sets the prediction amount of the pan gesture + * + * @param[in] amount The smoothing amount [0.0f,1.0f] - 0.0f would be no smoothing, 1.0f maximum smoothing + */ + void SetPanGestureSmoothingAmount(float amount); + + /* + * @brief Sets whether to use actual times of the real gesture and frames or not. + * + * @param[in] value True = use actual times, False = use perfect values + */ + void SetPanGestureUseActualTimes(bool value); + + /** + * @brief Sets the interpolation time range (ms) of past points to use (with weights) when interpolating. + * + * @param[in] value Time range in ms + */ + void SetPanGestureInterpolationTimeRange(int32_t value); + + /** + * @brief Sets whether to use scalar only prediction, which when enabled, ignores acceleration. + * + * @param[in] value True = use scalar prediction only + */ + void SetPanGestureScalarOnlyPredictionEnabled(bool value); + + /** + * @brief Sets whether to use two point prediction. This combines two interpolated points to get more steady acceleration and velocity values. + * + * @param[in] value True = use two point prediction + */ + void SetPanGestureTwoPointPredictionEnabled(bool value); + /** + * @brief Sets the time in the past to interpolate the second point when using two point interpolation. + * + * @param[in] value Time in past in ms + */ + void SetPanGestureTwoPointInterpolatePastTime(int32_t value); + + /** + * @brief Sets the two point velocity bias. This is the ratio of first and second points to use for velocity. + * + * @param[in] value 0.0f = 100% first point. 1.0f = 100% of second point. + */ + void SetPanGestureTwoPointVelocityBias(float value); + + /** + * @brief Sets the two point acceleration bias. This is the ratio of first and second points to use for acceleration. + * + * @param[in] value 0.0f = 100% first point. 1.0f = 100% of second point. + */ + void SetPanGestureTwoPointAccelerationBias(float value); + + /** + * @brief Sets the range of time (ms) of points in the history to perform multitap smoothing with (if enabled). + * + * @param[in] value Time in past in ms + */ + void SetPanGestureMultitapSmoothingRange(int32_t value); + + /** + * @brief Sets the minimum distance required to start a pan event + * + * @param[in] value Distance in pixels + */ + void SetPanGestureMinimumDistance(int32_t value); + + /** + * @brief Sets the minimum number of touch events required to start a pan + * + * @param[in] value Number of touch events + */ + void SetPanGestureMinimumPanEvents(int32_t value); + + /** + * @brief Sets the minimum distance required to start a pinch event + * + * @param[in] value Distance in pixels + */ + void SetPinchGestureMinimumDistance(float value); + + /** + * @brief Sets the minimum touch events required before a pinch can be started + * + * @param[in] value The number of touch events + */ + void SetPinchGestureMinimumTouchEvents(uint32_t value); + + /** + * @brief Sets the minimum touch events required after a pinch started + * + * @param[in] value The number of touch events + */ + void SetPinchGestureMinimumTouchEventsAfterStart(uint32_t value); + + /** + * @brief Sets the minimum touch events required before a rotation can be started + * + * @param[in] value The number of touch events + */ + void SetRotationGestureMinimumTouchEvents(uint32_t value); + + /** + * @brief Sets the minimum touch events required after a rotation started + * + * @param[in] value The number of touch events + */ + void SetRotationGestureMinimumTouchEventsAfterStart(uint32_t value); + + /** + * @brief Sets the minimum holding time required to be recognized as a long press gesture + * + * @param[in] value The time value in milliseconds + */ + void SetLongPressMinimumHoldingTime(uint32_t value); + + /** + * @return The minimum holding time required to be recognized as a long press gesture in milliseconds + */ + uint32_t GetLongPressMinimumHoldingTime() const; + +public: // needed for PanGesture + /** + * @return the pan gesture processor + */ + const PanGestureProcessor& GetPanGestureProcessor(); + +private: // Undefined GestureEventProcessor(const GestureEventProcessor&); GestureEventProcessor& operator=(const GestureEventProcessor& rhs); private: - - Stage& mStage; - Integration::GestureManager& mGestureManager; - - LongPressGestureProcessor mLongPressGestureProcessor; - PanGestureProcessor mPanGestureProcessor; - PinchGestureProcessor mPinchGestureProcessor; - TapGestureProcessor mTapGestureProcessor; + LongPressGestureProcessor mLongPressGestureProcessor; + PanGestureProcessor mPanGestureProcessor; + PinchGestureProcessor mPinchGestureProcessor; + TapGestureProcessor mTapGestureProcessor; + RotationGestureProcessor mRotationGestureProcessor; Integration::RenderController& mRenderController; - bool mUpdateRequired; ///< set to true by gesture detectors if they require a Core::Update + int32_t envOptionMinimumPanDistance; + int32_t envOptionMinimumPanEvents; }; } // namespace Internal } // namespace Dali -#endif // __DALI_INTERNAL_GESTURE_EVENT_PROCESSOR_H__ +#endif // DALI_INTERNAL_GESTURE_EVENT_PROCESSOR_H