Merge "Gesture event refactor" into devel/master
[platform/core/uifw/dali-core.git] / dali / internal / event / events / gesture-processor.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/gesture-processor.h>
20
21 // INTERNAL INCLUDES
22 #include <dali/integration-api/debug.h>
23 #include <dali/internal/event/actors/actor-impl.h>
24 #include <dali/internal/event/actors/layer-impl.h>
25 #include <dali/internal/event/common/scene-impl.h>
26 #include <dali/internal/event/events/hit-test-algorithm-impl.h>
27 #include <dali/internal/event/events/actor-gesture-data.h>
28 #include <dali/internal/event/render-tasks/render-task-impl.h>
29
30 namespace Dali
31 {
32
33 namespace Internal
34 {
35
36 namespace
37 {
38
39 /**
40  * Functor to check whether an actor requires a particular gesture or not
41  */
42 struct GestureHitTestCheck : public HitTestAlgorithm::HitTestInterface
43 {
44   GestureHitTestCheck( Gesture::Type type )
45   : mType( type )
46   {
47   }
48
49   virtual bool IsActorHittable( Actor* actor )
50   {
51     return actor->IsGestureRequred( mType ) && // Does the Application or derived actor type require the gesture?
52            actor->IsHittable();                // Is actor sensitive, visible and on the scene?
53   }
54
55   virtual bool DescendActorHierarchy( Actor* actor )
56   {
57     return actor->IsVisible() && // Actor is visible, if not visible then none of its children are visible.
58            actor->IsSensitive(); // Actor is sensitive, if insensitive none of its children should be hittable either.
59   }
60
61   virtual bool DoesLayerConsumeHit( Layer* layer )
62   {
63     return layer->IsTouchConsumed();
64   }
65
66   Gesture::Type mType;
67 };
68
69 } // unnamed namespace
70
71
72 GestureProcessor::GestureProcessor( Gesture::Type type )
73 : mGestureRecognizer(),
74   mNeedsUpdate( false ),
75   mType( type ),
76   mCurrentGesturedActor( nullptr ),
77   mGesturedActorDisconnected( false )
78 {
79 }
80
81 GestureProcessor::~GestureProcessor()
82 {
83   ResetActor();
84 }
85
86 void GestureProcessor::ProcessTouch( Scene& scene, const Integration::TouchEvent& event )
87 {
88   mGestureRecognizer->SendEvent(scene, event);
89 }
90
91 void GestureProcessor::GetGesturedActor( Actor*& actor, GestureDetectorContainer& gestureDetectors )
92 {
93   while ( actor )
94   {
95     // We may be checking a parent so ensure the parent requires this gesture (and do not unintentionally create the gesture data for the parent)
96     if ( actor->IsGestureRequred( mType ) )
97     {
98       // Retrieve the actor's detectors and check if they satisfy current gesture
99       const GestureDetectorContainer& connectedDetectors( actor->GetGestureData().GetGestureDetectorContainer( mType ) );
100       const GestureDetectorContainer::const_iterator endIter( connectedDetectors.end() );
101       for ( GestureDetectorContainer::const_iterator iter = connectedDetectors.begin(); iter != endIter; ++iter )
102       {
103         GestureDetector* current(*iter);
104
105         // Check deriving class for whether the current gesture satisfies the gesture detector's parameters.
106         if ( CheckGestureDetector( current, actor ) )
107         {
108           gestureDetectors.push_back(current);
109         }
110       }
111
112       // The hit actor or one of the parents is a gestured actor, break out.
113       if ( !gestureDetectors.empty() )
114       {
115         break;
116       }
117     }
118
119     // No match, we should now check the hit actor's parent.
120     actor = actor->GetParent();
121   }
122 }
123
124 void GestureProcessor::ProcessAndEmit( HitTestAlgorithm::Results& hitTestResults )
125 {
126   if ( hitTestResults.actor )
127   {
128     Actor* hitTestActor( &GetImplementation( hitTestResults.actor ) );
129     Actor* actor( hitTestActor );
130
131     while ( actor )
132     {
133       GestureDetectorContainer gestureDetectors;
134       GetGesturedActor( actor, gestureDetectors );
135
136       if ( actor && !gestureDetectors.empty() )
137       {
138         // We have a match but check if the hit point is within the gestured actor's bounds.
139         // If it is not then continue up the actor hierarchy.
140
141         if ( actor == hitTestActor )
142         {
143           // Our gesture detector's attached actor WAS the hit actor so we can can emit the signal.
144           EmitGestureSignal( actor, gestureDetectors, hitTestResults.actorCoordinates );
145           break; // We have found AND emitted a signal on the gestured actor, break out.
146         }
147         else
148         {
149           if ( actor->IsHittable() )
150           {
151             const Vector3 size( actor->GetCurrentSize() );
152
153             if ( ( size.x > 0.0f ) && ( size.y > 0.0f ) )
154             {
155               // Ensure tap is within the actor's area
156               if ( actor->RaySphereTest( hitTestResults.rayOrigin, hitTestResults.rayDirection ) ) // Quick check
157               {
158                 Vector2 hitPointLocal;
159                 float distance( 0.0f );
160                 if( actor->RayActorTest( hitTestResults.rayOrigin, hitTestResults.rayDirection, hitPointLocal, distance ) )
161                 {
162                   // One of the parents was the gestured actor so we can emit the signal for that actor.
163                   EmitGestureSignal( actor, gestureDetectors, hitPointLocal );
164                   break; // We have found AND emitted a signal on the gestured actor, break out.
165                 }
166               }
167             }
168           }
169         }
170       }
171
172       // Continue up hierarchy to see if any of the parents require this gesture.
173       if ( actor )
174       {
175         actor = actor->GetParent();
176       }
177     }
178   }
179 }
180
181 bool GestureProcessor::HitTest( Scene& scene, Vector2 screenCoordinates, HitTestAlgorithm::Results& hitTestResults )
182 {
183   GestureHitTestCheck hitCheck( mType );
184   HitTestAlgorithm::HitTest( scene.GetSize(), scene.GetRenderTaskList(), scene.GetLayerList(), screenCoordinates, hitTestResults, hitCheck );
185   return hitTestResults.renderTask && hitTestResults.actor;
186 }
187
188 void GestureProcessor::SetActor( Actor* actor )
189 {
190   if ( actor && actor != mCurrentGesturedActor )
191   {
192     ResetActor();
193
194     mCurrentGesturedActor = actor;
195     mCurrentGesturedActor->AddObserver( *this );
196   }
197   mGesturedActorDisconnected = false;
198 }
199
200 void GestureProcessor::ResetActor()
201 {
202   if ( mCurrentGesturedActor )
203   {
204     mCurrentGesturedActor->RemoveObserver( *this );
205     mCurrentGesturedActor = nullptr;
206     mGesturedActorDisconnected = false;
207   }
208 }
209
210 Actor* GestureProcessor::GetCurrentGesturedActor()
211 {
212   return mGesturedActorDisconnected ? nullptr : mCurrentGesturedActor;
213 }
214
215 void GestureProcessor::SceneObjectRemoved(Object& object)
216 {
217   if ( mCurrentGesturedActor == &object &&
218       !mGesturedActorDisconnected )
219   {
220     // Inform deriving classes.
221     OnGesturedActorStageDisconnection();
222
223     // do not call object.RemoveObserver here, object is currently iterating through observers... you wouldnt want to upset object now would you?
224     mGesturedActorDisconnected = true;
225   }
226 }
227
228 void GestureProcessor::ObjectDestroyed(Object& object)
229 {
230   if ( mCurrentGesturedActor == &object )
231   {
232     // Inform deriving classes.
233     OnGesturedActorStageDisconnection();
234
235     mCurrentGesturedActor = nullptr;
236   }
237 }
238
239 } // namespace Internal
240
241 } // namespace Dali