X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=dali%2Finternal%2Fevent%2Fevents%2Fgesture-event-processor.cpp;h=04863ffa3b23f77688a02fbe79c80ad62ceffc20;hb=a4eb68faf1e75d213c951a7d4d1b67727247917a;hp=cfe7e586560fd87bbf535989427e95da261dc13f;hpb=ce20e9f082e811130930d13c9e9edc1da4ce1013;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/event/events/gesture-event-processor.cpp b/dali/internal/event/events/gesture-event-processor.cpp index cfe7e58..04863ff 100644 --- a/dali/internal/event/events/gesture-event-processor.cpp +++ b/dali/internal/event/events/gesture-event-processor.cpp @@ -1,49 +1,50 @@ -// -// 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) 2019 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. + * + */ // CLASS HEADER #include +#if defined(DEBUG_ENABLED) +#include +#endif + // INTERNAL INCLUDES -#include -#include -#include -#include -#include -#include #include #include -#include +#include +#include #include +#include + namespace Dali { namespace Internal { - -GestureEventProcessor::GestureEventProcessor(Stage& stage, Integration::GestureManager& gestureManager, Integration::RenderController& renderController) -: mStage(stage), - mGestureManager(gestureManager), - mLongPressGestureProcessor(stage, gestureManager), - mPanGestureProcessor(stage, gestureManager), - mPinchGestureProcessor(stage, gestureManager), - mTapGestureProcessor(stage, gestureManager), - mRenderController(renderController), - mUpdateRequired( false ) +GestureEventProcessor::GestureEventProcessor( SceneGraph::UpdateManager& updateManager, Integration::RenderController& renderController ) +: mLongPressGestureProcessor(), + mPanGestureProcessor( updateManager ), + mPinchGestureProcessor(), + mTapGestureProcessor(), + mRotationGestureProcessor(), + mRenderController( renderController ), + envOptionMinimumPanDistance(-1), + envOptionMinimumPanEvents(-1) { } @@ -51,72 +52,53 @@ GestureEventProcessor::~GestureEventProcessor() { } -void GestureEventProcessor::ProcessGestureEvent(const Integration::GestureEvent& event) +void GestureEventProcessor::ProcessTouchEvent( Scene& scene, const Integration::TouchEvent& event) { - if( Gesture::Started == event.state || Gesture::Continuing == event.state ) - { - SetUpdateRequired(); - } - - switch(event.gestureType) - { - case Gesture::LongPress: - mLongPressGestureProcessor.Process(static_cast(event)); - break; - - case Gesture::Pan: - mPanGestureProcessor.Process(static_cast(event)); - break; - - case Gesture::Pinch: - mPinchGestureProcessor.Process(static_cast(event)); - break; - - case Gesture::Tap: - mTapGestureProcessor.Process(static_cast(event)); - break; - - default: - DALI_ASSERT_ALWAYS( false && "Invalid gesture type sent from Integration\n" ); - break; - } + mLongPressGestureProcessor.ProcessTouch(scene, event); + mPanGestureProcessor.ProcessTouch(scene, event); + mPinchGestureProcessor.ProcessTouch(scene, event); + mTapGestureProcessor.ProcessTouch(scene, event); + mRotationGestureProcessor.ProcessTouch(scene, event); } -void GestureEventProcessor::AddGestureDetector(GestureDetector* gestureDetector) +void GestureEventProcessor::AddGestureDetector(GestureDetector* gestureDetector, Scene& scene) { switch (gestureDetector->GetType()) { - case Gesture::LongPress: + case DevelGesture::LongPress: { LongPressGestureDetector* longPress = static_cast(gestureDetector); - mLongPressGestureProcessor.AddGestureDetector(longPress); + mLongPressGestureProcessor.AddGestureDetector(longPress, scene); break; } - case Gesture::Pan: + case DevelGesture::Pan: { PanGestureDetector* pan = static_cast(gestureDetector); - mPanGestureProcessor.AddGestureDetector(pan); + mPanGestureProcessor.AddGestureDetector(pan, scene, envOptionMinimumPanDistance, envOptionMinimumPanEvents); break; } - case Gesture::Pinch: + case DevelGesture::Pinch: { PinchGestureDetector* pinch = static_cast(gestureDetector); - mPinchGestureProcessor.AddGestureDetector(pinch); + mPinchGestureProcessor.AddGestureDetector(pinch, scene); break; } - case Gesture::Tap: + case DevelGesture::Tap: { TapGestureDetector* tap = static_cast(gestureDetector); - mTapGestureProcessor.AddGestureDetector(tap); + mTapGestureProcessor.AddGestureDetector(tap, scene); break; } - default: - DALI_ASSERT_DEBUG( false && "Invalid gesture detector type created\n" ); + case DevelGesture::Rotation: + { + RotationGestureDetector* rotation = static_cast(gestureDetector); + mRotationGestureProcessor.AddGestureDetector(rotation, scene); break; + } } } @@ -124,37 +106,40 @@ void GestureEventProcessor::RemoveGestureDetector(GestureDetector* gestureDetect { switch (gestureDetector->GetType()) { - case Gesture::LongPress: + case DevelGesture::LongPress: { LongPressGestureDetector* longPress = static_cast(gestureDetector); mLongPressGestureProcessor.RemoveGestureDetector(longPress); break; } - case Gesture::Pan: + case DevelGesture::Pan: { PanGestureDetector* pan = static_cast(gestureDetector); mPanGestureProcessor.RemoveGestureDetector(pan); break; } - case Gesture::Pinch: + case DevelGesture::Pinch: { PinchGestureDetector* pinch = static_cast(gestureDetector); mPinchGestureProcessor.RemoveGestureDetector(pinch); break; } - case Gesture::Tap: + case DevelGesture::Tap: { TapGestureDetector* tap = static_cast(gestureDetector); mTapGestureProcessor.RemoveGestureDetector(tap); break; } - default: - DALI_ASSERT_DEBUG( false && "Invalid gesture detector type removal request\n" ); + case DevelGesture::Rotation: + { + RotationGestureDetector* rotation = static_cast(gestureDetector); + mRotationGestureProcessor.RemoveGestureDetector(rotation); break; + } } } @@ -162,83 +147,195 @@ void GestureEventProcessor::GestureDetectorUpdated(GestureDetector* gestureDetec { switch (gestureDetector->GetType()) { - case Gesture::LongPress: + case DevelGesture::LongPress: { LongPressGestureDetector* longPress = static_cast(gestureDetector); mLongPressGestureProcessor.GestureDetectorUpdated(longPress); break; } - case Gesture::Pan: + case DevelGesture::Pan: { PanGestureDetector* pan = static_cast(gestureDetector); mPanGestureProcessor.GestureDetectorUpdated(pan); break; } - case Gesture::Pinch: + case DevelGesture::Pinch: { PinchGestureDetector* pinch = static_cast(gestureDetector); mPinchGestureProcessor.GestureDetectorUpdated(pinch); break; } - case Gesture::Tap: + case DevelGesture::Tap: { TapGestureDetector* tap = static_cast(gestureDetector); mTapGestureProcessor.GestureDetectorUpdated(tap); break; } - default: - DALI_ASSERT_DEBUG( false && "Invalid gesture type update request\n" ); + case DevelGesture::Rotation: + { + // Nothing to do break; + } } } -void GestureEventProcessor::SetUpdateRequired() -{ - mUpdateRequired = true; -} - void GestureEventProcessor::SetGestureProperties( const Gesture& gesture ) { - if( Gesture::Started == gesture.state || Gesture::Continuing == gesture.state ) - { - SetUpdateRequired(); + bool requestUpdate = false; - // We may not be updating so we need to ask the render controller for an update. - mRenderController.RequestUpdate(); - } - - switch ( gesture.type ) + switch ( static_cast< DevelGesture::Type >( gesture.type ) ) { - case Gesture::Pan: + case DevelGesture::Pan: { const PanGesture& pan = static_cast< const PanGesture& >( gesture ); - mPanGestureProcessor.SetPanGestureProperties( pan ); + requestUpdate = mPanGestureProcessor.SetPanGestureProperties( pan ); break; } - case Gesture::LongPress: - case Gesture::Pinch: - case Gesture::Tap: + case DevelGesture::LongPress: + case DevelGesture::Pinch: + case DevelGesture::Tap: + case DevelGesture::Rotation: { DALI_ASSERT_DEBUG( false && "Gesture type does not have scene object\n" ); break; } } + + if( requestUpdate ) + { + // We may not be updating so we need to ask the render controller for an update. + mRenderController.RequestUpdate( false ); + } } bool GestureEventProcessor::NeedsUpdate() { - bool updateRequired( mUpdateRequired ); + bool updateRequired = false; - mUpdateRequired = false; + updateRequired |= mLongPressGestureProcessor.NeedsUpdate(); + updateRequired |= mPanGestureProcessor.NeedsUpdate(); + updateRequired |= mPinchGestureProcessor.NeedsUpdate(); + updateRequired |= mTapGestureProcessor.NeedsUpdate(); + updateRequired |= mRotationGestureProcessor.NeedsUpdate(); return updateRequired; } +void GestureEventProcessor::EnablePanGestureProfiling() +{ + mPanGestureProcessor.EnableProfiling(); +} + +void GestureEventProcessor::SetPanGesturePredictionMode(int mode) +{ + mPanGestureProcessor.SetPredictionMode(mode); +} + +void GestureEventProcessor::SetPanGesturePredictionAmount( uint32_t amount ) +{ + mPanGestureProcessor.SetPredictionAmount(amount); +} + +void GestureEventProcessor::SetPanGestureMaximumPredictionAmount( uint32_t amount ) +{ + mPanGestureProcessor.SetMaximumPredictionAmount(amount); +} + +void GestureEventProcessor::SetPanGestureMinimumPredictionAmount( uint32_t amount ) +{ + mPanGestureProcessor.SetMinimumPredictionAmount(amount); +} + +void GestureEventProcessor::SetPanGesturePredictionAmountAdjustment( uint32_t amount ) +{ + mPanGestureProcessor.SetPredictionAmountAdjustment(amount); +} + +void GestureEventProcessor::SetPanGestureSmoothingMode( int32_t mode ) +{ + mPanGestureProcessor.SetSmoothingMode(mode); +} + +void GestureEventProcessor::SetPanGestureSmoothingAmount( float amount ) +{ + mPanGestureProcessor.SetSmoothingAmount(amount); +} + +void GestureEventProcessor::SetPanGestureUseActualTimes( bool value ) +{ + mPanGestureProcessor.SetUseActualTimes( value ); +} + +void GestureEventProcessor::SetPanGestureInterpolationTimeRange( int32_t value ) +{ + mPanGestureProcessor.SetInterpolationTimeRange( value ); +} + +void GestureEventProcessor::SetPanGestureScalarOnlyPredictionEnabled( bool value ) +{ + mPanGestureProcessor.SetScalarOnlyPredictionEnabled( value ); +} + +void GestureEventProcessor::SetPanGestureTwoPointPredictionEnabled( bool value ) +{ + mPanGestureProcessor.SetTwoPointPredictionEnabled( value ); +} + +void GestureEventProcessor::SetPanGestureTwoPointInterpolatePastTime( int value ) +{ + mPanGestureProcessor.SetTwoPointInterpolatePastTime( value ); +} + +void GestureEventProcessor::SetPanGestureTwoPointVelocityBias( float value ) +{ + mPanGestureProcessor.SetTwoPointVelocityBias( value ); +} + +void GestureEventProcessor::SetPanGestureTwoPointAccelerationBias( float value ) +{ + mPanGestureProcessor.SetTwoPointAccelerationBias( value ); +} + +void GestureEventProcessor::SetPanGestureMultitapSmoothingRange( int32_t value ) +{ + mPanGestureProcessor.SetMultitapSmoothingRange( value ); +} + +void GestureEventProcessor::SetPanGestureMinimumDistance( int32_t value ) +{ + envOptionMinimumPanDistance = value; +} + +void GestureEventProcessor::SetPanGestureMinimumPanEvents( int32_t value ) +{ + envOptionMinimumPanEvents = value; +} + +void GestureEventProcessor::SetPinchGestureMinimumDistance( float value) +{ + mPinchGestureProcessor.SetMinimumPinchDistance( value ); +} + +void GestureEventProcessor::SetLongPressMinimumHoldingTime( uint32_t value ) +{ + mLongPressGestureProcessor.SetMinimumHoldingTime( value ); +} + +uint32_t GestureEventProcessor::GetLongPressMinimumHoldingTime() const +{ + return mLongPressGestureProcessor.GetMinimumHoldingTime(); +} + +const PanGestureProcessor& GestureEventProcessor::GetPanGestureProcessor() +{ + return mPanGestureProcessor; +} + } // namespace Internal } // namespace Dali