308fc46cccd631a0725d9d950231ff070f227058
[platform/core/uifw/dali-core.git] / dali / internal / event / events / rotation-gesture / rotation-gesture-recognizer.cpp
1 /*
2  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 // CLASS HEADER
19 #include <dali/internal/event/events/rotation-gesture/rotation-gesture-recognizer.h>
20
21 // EXTERNAL INCLUDES
22 #include <cmath>
23
24 // INTERNAL INCLUDES
25 #include <dali/public-api/events/touch-point.h>
26 #include <dali/public-api/math/vector2.h>
27 #include <dali/devel-api/events/gesture-devel.h>
28 #include <dali/integration-api/events/touch-event-integ.h>
29 #include <dali/internal/event/events/rotation-gesture/rotation-gesture-event.h>
30 #include <dali/internal/event/common/scene-impl.h>
31
32 // INTERNAL INCLUDES
33
34
35 namespace Dali
36 {
37
38 namespace Internal
39 {
40
41 namespace
42 {
43 const unsigned int MINIMUM_TOUCH_EVENTS_REQUIRED = 4;
44 const unsigned int MINIMUM_TOUCH_EVENTS_REQUIRED_AFTER_START = 4;
45
46 inline float GetAngle( const Integration::Point& point1, const Integration::Point& point2 )
47 {
48   const Vector2& point1ScreenPosition = point1.GetScreenPosition();
49   const Vector2& point2ScreenPosition = point2.GetScreenPosition();
50   return atan2( point2ScreenPosition.y - point1ScreenPosition.y, point2ScreenPosition.x - point1ScreenPosition.x );
51 }
52
53 inline Vector2 GetCenterPoint( const Integration::Point& point1, const Integration::Point& point2 )
54 {
55   return Vector2( point1.GetScreenPosition() + point2.GetScreenPosition() ) * 0.5f;
56 }
57
58 } // unnamed namespace
59
60 RotationGestureRecognizer::RotationGestureRecognizer( Observer& observer )
61 : GestureRecognizer( DevelGesture::Rotation ),
62   mObserver( observer ),
63   mState( Clear ),
64   mTouchEvents(),
65   mStartingAngle( 0.0f )
66 {
67 }
68
69 void RotationGestureRecognizer::SendEvent( const Integration::TouchEvent& event )
70 {
71   int pointCount = event.GetPointCount();
72
73   switch( mState )
74   {
75     case Clear:
76     {
77       if( pointCount == 2 )
78       {
79         // Change state to possible as we have two touch points.
80         mState = Possible;
81         mTouchEvents.push_back( event );
82       }
83       break;
84     }
85
86     case Possible:
87     {
88       if ( pointCount != 2 )
89       {
90         // We no longer have two touch points so change state back to Clear.
91         mState = Clear;
92         mTouchEvents.clear();
93       }
94       else
95       {
96         const Integration::Point& currentPoint1 = event.points[0];
97         const Integration::Point& currentPoint2 = event.points[1];
98
99         if( currentPoint1.GetState() == PointState::UP || currentPoint2.GetState() == PointState::UP )
100         {
101           // One of our touch points has an Up event so change our state back to Clear.
102           mState = Clear;
103           mTouchEvents.clear();
104         }
105         else
106         {
107           mTouchEvents.push_back( event );
108
109           // We can only determine a rotation after a certain number of touch points have been collected.
110           if( mTouchEvents.size() >= MINIMUM_TOUCH_EVENTS_REQUIRED )
111           {
112             // Remove the first few events from the vector otherwise values are exaggerated
113             mTouchEvents.erase( mTouchEvents.begin(), mTouchEvents.end() - MINIMUM_TOUCH_EVENTS_REQUIRED_AFTER_START );
114
115             if( !mTouchEvents.empty() )
116             {
117               mStartingAngle = GetAngle( mTouchEvents.begin()->points[0], mTouchEvents.begin()->points[1] );
118
119               // Send rotation started
120               SendRotation( Gesture::Started, event );
121
122               mState = Started;
123             }
124
125             mTouchEvents.clear();
126
127             if( mState == Possible )
128             {
129               // No rotation, so restart detection
130               mState = Clear;
131               mTouchEvents.clear();
132             }
133           }
134         }
135       }
136       break;
137     }
138
139     case Started:
140     {
141       if( pointCount != 2 )
142       {
143         // Send rotation finished event
144         SendRotation( Gesture::Finished, event );
145
146         mState = Clear;
147         mTouchEvents.clear();
148       }
149       else
150       {
151         const Integration::Point& currentPoint1 = event.points[0];
152         const Integration::Point& currentPoint2 = event.points[1];
153
154         if( ( currentPoint1.GetState() == PointState::UP ) ||
155             ( currentPoint2.GetState() == PointState::UP ) )
156         {
157           mTouchEvents.push_back( event );
158           // Send rotation finished event
159           SendRotation( Gesture::Finished, event );
160
161           mState = Clear;
162           mTouchEvents.clear();
163         }
164         else
165         {
166           mTouchEvents.push_back( event );
167
168           if( mTouchEvents.size() >= MINIMUM_TOUCH_EVENTS_REQUIRED_AFTER_START )
169           {
170             // Send rotation continuing
171             SendRotation( Gesture::Continuing, event );
172
173             mTouchEvents.clear();
174           }
175         }
176       }
177       break;
178     }
179   }
180 }
181
182 void RotationGestureRecognizer::SendRotation( Gesture::State state, const Integration::TouchEvent& currentEvent )
183 {
184   RotationGestureEvent gesture( state );
185
186   if( !mTouchEvents.empty() )
187   {
188     // Assert if we have been holding TouchEvents that do not have 2 points
189     DALI_ASSERT_DEBUG( mTouchEvents[0].GetPointCount() == 2 );
190
191     // We should use the current event in our calculations unless it does not have two points.
192     // If it does not have two points, then we should use the last point in mTouchEvents.
193     Integration::TouchEvent event( currentEvent );
194     if( event.GetPointCount() != 2 )
195     {
196       event = *mTouchEvents.rbegin();
197     }
198
199     const Integration::Point& currentPoint1( event.points[0] );
200     const Integration::Point& currentPoint2( event.points[1] );
201
202     gesture.rotation = GetAngle( currentPoint1, currentPoint2 ) - mStartingAngle;
203     gesture.centerPoint = GetCenterPoint( currentPoint1, currentPoint2 );
204   }
205   else
206   {
207     // Something has gone wrong, just cancel the gesture.
208     gesture.state = Gesture::Cancelled;
209   }
210
211   gesture.time = currentEvent.time;
212
213   if( mScene )
214   {
215     // Create another handle so the recognizer cannot be destroyed during process function
216     GestureRecognizerPtr recognizerHandle = this;
217
218     mObserver.Process( *mScene, gesture );
219   }
220 }
221
222 } // namespace Internal
223
224 } // namespace Dali