X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Fevents%2Fpan-gesture-processor.h;h=bc0bdb39ad89ec3dfbf9e0c2d9855f056364dbf8;hb=891f95adefdd739d38f14aaaee17cd66eacad972;hp=2479e0687914fdf348f87e2090d292695738aa22;hpb=ce20e9f082e811130930d13c9e9edc1da4ce1013;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/event/events/pan-gesture-processor.h b/dali/internal/event/events/pan-gesture-processor.h index 2479e06..bc0bdb3 100644 --- a/dali/internal/event/events/pan-gesture-processor.h +++ b/dali/internal/event/events/pan-gesture-processor.h @@ -1,26 +1,27 @@ #ifndef __DALI_INTERNAL_PAN_GESTURE_EVENT_PROCESSOR_H__ #define __DALI_INTERNAL_PAN_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. -// +/* + * Copyright (c) 2018 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 namespace Dali { @@ -36,20 +37,20 @@ namespace Internal { class Stage; +class Scene; namespace SceneGraph { class PanGesture; +class UpdateManager; } /** * Pan Gesture Event Processing: * - * When we receive a pinch gesture event, we do the following: - * - Determine the hot actor underneath the current position of the pan gesture event. - * - Determine whether this actor is, or is a child of, the actor(s) attached to any of the - * detectors. - * - Emit the gesture when all the above conditions are met. + * When we receive a pan gesture event, we do the following: + * - Find the actor that requires a pan where the pan started from (i.e. the down position). + * - Emit the gesture if the event satisfies the detector conditions. * * The above is only checked when our gesture starts. We continue sending the pan gesture to the * same actor and detector until the pan ends or is cancelled. @@ -60,23 +61,24 @@ public: /** * Create a pan gesture processor. - * @param[in] stage The stage. * @param[in] gestureManager The gesture manager + * @param[in] updateManager The Update Manager */ - PanGestureProcessor( Stage& stage, Integration::GestureManager& gestureManager ); + PanGestureProcessor( Integration::GestureManager& gestureManager, SceneGraph::UpdateManager& updateManager ); /** - * Non-virtual destructor; PanGestureProcessor is not a base class + * Destructor */ - ~PanGestureProcessor(); + virtual ~PanGestureProcessor(); public: // To be called by GestureEventProcessor /** - * This method is called whenever a pinch gesture event occurs. + * This method is called whenever a pan gesture event occurs. + * @param[in] scene The scene the pan gesture event occurs in. * @param[in] panEvent The event that has occurred. */ - void Process( const Integration::PanGestureEvent& panEvent ); + void Process( Scene& scene, const Integration::PanGestureEvent& panEvent ); /** * Adds a gesture detector to this gesture processor. @@ -107,6 +109,131 @@ public: // To be called by GestureEventProcessor */ void SetPanGestureProperties( const PanGesture& pan ); + /** + * Called to provide pan-gesture profiling information. + */ + void EnableProfiling(); + + /** + * Called to set the prediction mode for pan gestures + * + * @param[in] mode The prediction mode + * + * Valid modes: + * 0 - No prediction + * 1 - Prediction using average acceleration + */ + void SetPredictionMode(int mode); + + /** + * @brief Sets the prediction amount of the pan gesture + * + * @param[in] amount The prediction amount in milliseconds + */ + void SetPredictionAmount(unsigned int amount); + + /** + * @brief Sets the upper bound of the prediction amount for clamping + * + * @param[in] amount The prediction amount in milliseconds + */ + void SetMaximumPredictionAmount(unsigned int amount); + + /** + * @brief Sets the lower bound of the prediction amount for clamping + * + * @param[in] amount The prediction amount in milliseconds + */ + void SetMinimumPredictionAmount(unsigned int amount); + + /** + * @brief Sets the amount of prediction interpolation to adjust when the pan velocity is changed + * + * @param[in] amount The prediction amount in milliseconds + */ + void SetPredictionAmountAdjustment(unsigned int amount); + + /** + * Called to set the prediction mode for pan gestures + * + * @param[in] mode The prediction mode + * + * Valid modes: + * 0 - No smoothing + * 1 - average between last 2 values + */ + void SetSmoothingMode(int mode); + + /** + * @brief Sets the smoothing amount of the pan gesture + * + * @param[in] amount The smotthing amount from 0.0f (none) to 1.0f (full) + */ + void SetSmoothingAmount(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 SetUseActualTimes( 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 SetInterpolationTimeRange( int value ); + + /** + * @brief Sets whether to use scalar only prediction, which when enabled, ignores acceleration. + * + * @param[in] value True = use scalar prediction only + */ + void SetScalarOnlyPredictionEnabled( 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 SetTwoPointPredictionEnabled( 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 SetTwoPointInterpolatePastTime( int 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 SetTwoPointVelocityBias( 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 SetTwoPointAccelerationBias( 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 SetMultitapSmoothingRange( int value ); + +public: // for PanGestureDetector + + /** + * @return the pan gesture scene object + */ + const SceneGraph::PanGesture& GetSceneObject() const; + private: // Undefined @@ -128,12 +255,12 @@ private: * @param[in] state The state of the gesture. * @param[in] renderTask The renderTask to use. */ - void EmitPanSignal( Dali::Actor actor, - PanGestureDetectorContainer& gestureDetectors, + void EmitPanSignal( Actor* actor, + const GestureDetectorContainer& gestureDetectors, const Integration::PanGestureEvent& panEvent, Vector2 localCurrent, Gesture::State state, - Dali::RenderTask renderTask ); + RenderTaskPtr renderTask ); // GestureProcessor overrides @@ -142,23 +269,31 @@ private: */ void OnGesturedActorStageDisconnection(); + /** + * @copydoc GestureProcessor::CheckGestureDetector() + */ + bool CheckGestureDetector( GestureDetector* detector, Actor* actor ); + + /** + * @copydoc GestureProcessor::EmitGestureSignal() + */ + void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ); + private: - Stage& mStage; Integration::GestureManager& mGestureManager; PanGestureDetectorContainer mGestureDetectors; - PanGestureDetectorContainer mCurrentPanEmitters; - Dali::RenderTask mCurrentRenderTask; + GestureDetectorContainer mCurrentPanEmitters; + RenderTaskPtr mCurrentRenderTask; Vector2 mPossiblePanPosition; - unsigned int mMinTouchesRequired; - unsigned int mMaxTouchesRequired; + uint32_t mMinTouchesRequired; + uint32_t mMaxTouchesRequired; Vector2 mLastVelocity; ///< The last recorded velocity in local actor coordinates. Vector2 mLastScreenVelocity; ///< The last recorded velocity in screen coordinates. - struct PanEventFunctor; - + const Integration::PanGestureEvent* mCurrentPanEvent; ///< Pointer to current PanEvent, used when calling ProcessAndEmit() SceneGraph::PanGesture* mSceneObject; ///< Not owned, but we write to it directly };