Revert "[Tizen] GCC 9.2 Support"
[platform/core/uifw/dali-core.git] / dali / internal / event / events / touch-event-processor.cpp
1 /*
2  * Copyright (c) 2018 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/touch-event-processor.h>
20
21 #if defined(DEBUG_ENABLED)
22 #include <sstream>
23 #endif
24
25 // INTERNAL INCLUDES
26 #include <dali/public-api/events/touch-data.h>
27 #include <dali/public-api/math/vector2.h>
28 #include <dali/public-api/signals/callback.h>
29 #include <dali/integration-api/debug.h>
30 #include <dali/integration-api/events/touch-event-integ.h>
31 #include <dali/internal/event/actors/actor-impl.h>
32 #include <dali/internal/event/actors/layer-impl.h>
33 #include <dali/internal/event/common/scene-impl.h>
34 #include <dali/internal/event/events/hit-test-algorithm-impl.h>
35 #include <dali/internal/event/events/multi-point-event-util.h>
36 #include <dali/internal/event/events/touch-data-impl.h>
37 #include <dali/internal/event/render-tasks/render-task-impl.h>
38
39 namespace Dali
40 {
41
42 namespace Internal
43 {
44
45 namespace
46 {
47
48 #if defined(DEBUG_ENABLED)
49 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_TOUCH_PROCESSOR" );
50
51 const char * TOUCH_POINT_STATE[ 6 ] =
52 {
53   "DOWN",
54   "UP",
55   "MOTION",
56   "LEAVE",
57   "STATIONARY",
58   "INTERRUPTED",
59 };
60
61 #endif // defined(DEBUG_ENABLED)
62
63
64 /**
65  *  Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
66  */
67 Dali::Actor EmitTouchSignals( Dali::Actor actor, const TouchEvent& event, const Dali::TouchData& touchData )
68 {
69   Dali::Actor consumedActor;
70
71   if ( actor )
72   {
73     Dali::Actor oldParent( actor.GetParent() );
74
75     Actor& actorImpl( GetImplementation(actor) );
76
77     bool consumed( false );
78
79     // Only emit the signal if the actor's touch signal has connections (or derived actor implementation requires touch).
80     if ( actorImpl.GetTouchRequired() )
81     {
82       consumed = actorImpl.EmitTouchEventSignal( event, touchData );
83     }
84
85     if ( consumed )
86     {
87       // One of this actor's listeners has consumed the event so set this actor as the consumed actor.
88       consumedActor = Dali::Actor( &actorImpl );
89     }
90     else
91     {
92       // The actor may have been removed/reparented during the signal callbacks.
93       Dali::Actor parent = actor.GetParent();
94
95       if ( parent &&
96            (parent == oldParent) )
97       {
98         // One of the actor's parents may consumed the event and they should be set as the consumed actor.
99         consumedActor = EmitTouchSignals( parent, event, touchData );
100       }
101     }
102   }
103
104   return consumedActor;
105 }
106
107 Dali::Actor AllocAndEmitTouchSignals( unsigned long time,  Dali::Actor actor, const Integration::Point& point )
108 {
109   TouchEvent touchEvent( time );
110   TouchDataPtr touchData( new TouchData( time ) );
111   Dali::TouchData touchDataHandle( touchData.Get() );
112
113   touchEvent.points.push_back( point.GetTouchPoint() );
114   touchData->AddPoint( point );
115
116   return EmitTouchSignals( actor, touchEvent, touchDataHandle );
117 }
118
119
120 /**
121  * Changes the state of the primary point to leave and emits the touch signals
122  */
123 Dali::Actor EmitTouchSignals( Actor* actor, RenderTask& renderTask, const TouchEvent& originalEvent, const TouchDataPtr& originalTouchData, PointState::Type state )
124 {
125   Dali::Actor consumingActor;
126
127   if( actor )
128   {
129     TouchDataPtr touchData = TouchData::Clone( *originalTouchData.Get() );
130
131     Integration::Point& primaryPoint = touchData->GetPoint( 0 );
132
133     const Vector2& screenPosition = primaryPoint.GetScreenPosition();
134     Vector2 localPosition;
135     actor->ScreenToLocal( renderTask, localPosition.x, localPosition.y, screenPosition.x, screenPosition.y );
136
137     primaryPoint.SetLocalPosition( localPosition );
138     primaryPoint.SetHitActor( Dali::Actor( actor ) );
139     primaryPoint.SetState( state );
140
141     TouchEvent touchEvent( originalEvent );
142     touchEvent.points[0] = primaryPoint.GetTouchPoint();
143
144     consumingActor = EmitTouchSignals( Dali::Actor(actor), touchEvent, Dali::TouchData( touchData.Get() ) );
145   }
146
147   return consumingActor;
148 }
149
150 } // unnamed namespace
151
152 TouchEventProcessor::TouchEventProcessor( Scene& scene )
153 : mScene( scene ),
154   mLastPrimaryHitActor( MakeCallback( this, &TouchEventProcessor::OnObservedActorDisconnected ) ),
155   mLastConsumedActor(),
156   mTouchDownConsumedActor(),
157   mLastRenderTask()
158 {
159   DALI_LOG_TRACE_METHOD( gLogFilter );
160 }
161
162 TouchEventProcessor::~TouchEventProcessor()
163 {
164   DALI_LOG_TRACE_METHOD( gLogFilter );
165 }
166
167 void TouchEventProcessor::ProcessTouchEvent( const Integration::TouchEvent& event )
168 {
169   DALI_LOG_TRACE_METHOD( gLogFilter );
170   DALI_ASSERT_ALWAYS( !event.points.empty() && "Empty TouchEvent sent from Integration\n" );
171
172   PRINT_HIERARCHY(gLogFilter);
173
174   // 1) Check if it is an interrupted event - we should inform our last primary hit actor about this
175   //    and emit the stage signal as well.
176
177   if ( event.points[0].GetState() == PointState::INTERRUPTED )
178   {
179     Dali::Actor consumingActor;
180     Integration::Point currentPoint( event.points[0] );
181
182     Actor* lastPrimaryHitActor( mLastPrimaryHitActor.GetActor() );
183     if ( lastPrimaryHitActor )
184     {
185       Dali::Actor lastPrimaryHitActorHandle( lastPrimaryHitActor );
186       currentPoint.SetHitActor( lastPrimaryHitActorHandle );
187
188       consumingActor = AllocAndEmitTouchSignals( event.time, lastPrimaryHitActorHandle, currentPoint );
189     }
190
191     // If the last consumed actor was different to the primary hit actor then inform it as well (if it has not already been informed).
192     Actor* lastConsumedActor( mLastConsumedActor.GetActor() );
193     if ( lastConsumedActor &&
194          lastConsumedActor != lastPrimaryHitActor &&
195          lastConsumedActor != consumingActor )
196     {
197       Dali::Actor lastConsumedActorHandle( lastConsumedActor );
198       currentPoint.SetHitActor( lastConsumedActorHandle );
199       AllocAndEmitTouchSignals( event.time, lastConsumedActorHandle, currentPoint );
200     }
201
202     // Tell the touch-down consuming actor as well, if required
203     Actor* touchDownConsumedActor( mTouchDownConsumedActor.GetActor() );
204     if ( touchDownConsumedActor &&
205          touchDownConsumedActor != lastPrimaryHitActor &&
206          touchDownConsumedActor != lastConsumedActor &&
207          touchDownConsumedActor != consumingActor )
208     {
209       Dali::Actor touchDownConsumedActorHandle( touchDownConsumedActor );
210
211       currentPoint.SetHitActor( touchDownConsumedActorHandle );
212       AllocAndEmitTouchSignals( event.time, touchDownConsumedActorHandle, currentPoint );
213     }
214
215     mLastPrimaryHitActor.SetActor( NULL );
216     mLastConsumedActor.SetActor( NULL );
217     mTouchDownConsumedActor.SetActor( NULL );
218     mLastRenderTask.Reset();
219
220     currentPoint.SetHitActor( Dali::Actor() );
221
222     TouchEvent touchEvent( event.time );
223     TouchDataPtr touchData( new TouchData( event.time ) );
224     Dali::TouchData touchDataHandle( touchData.Get() );
225
226     touchEvent.points.push_back( currentPoint.GetTouchPoint() );
227     touchData->AddPoint( currentPoint );
228
229     mScene.EmitTouchedSignal( touchEvent, touchDataHandle );
230     return; // No need for hit testing
231   }
232
233   // 2) Hit Testing.
234   TouchEvent touchEvent( event.time );
235   TouchDataPtr touchData( new TouchData( event.time ) );
236   Dali::TouchData touchDataHandle( touchData.Get() );
237
238   DALI_LOG_INFO( gLogFilter, Debug::Concise, "\n" );
239   DALI_LOG_INFO( gLogFilter, Debug::General, "Point(s): %d\n", event.GetPointCount() );
240
241   RenderTaskPtr currentRenderTask;
242
243   for ( Integration::PointContainerConstIterator iter = event.points.begin(), beginIter = event.points.begin(), endIter = event.points.end(); iter != endIter; ++iter )
244   {
245     HitTestAlgorithm::Results hitTestResults;
246     HitTestAlgorithm::HitTest( mScene.GetSize(), mScene.GetRenderTaskList(), mScene.GetLayerList(), iter->GetScreenPosition(), hitTestResults );
247
248     Integration::Point newPoint( *iter );
249     newPoint.SetHitActor( hitTestResults.actor );
250     newPoint.SetLocalPosition( hitTestResults.actorCoordinates );
251
252     touchEvent.points.push_back( newPoint.GetTouchPoint() );
253     touchData->AddPoint( newPoint );
254
255     DALI_LOG_INFO( gLogFilter, Debug::General, "  State(%s), Screen(%.0f, %.0f), HitActor(%p, %s), Local(%.2f, %.2f)\n",
256                    TOUCH_POINT_STATE[iter->GetState()], iter->GetScreenPosition().x, iter->GetScreenPosition().y,
257                    ( hitTestResults.actor ? reinterpret_cast< void* >( &hitTestResults.actor.GetBaseObject() ) : NULL ),
258                    ( hitTestResults.actor ? hitTestResults.actor.GetName().c_str() : "" ),
259                    hitTestResults.actorCoordinates.x, hitTestResults.actorCoordinates.y );
260
261     // Only set the currentRenderTask for the primary hit actor.
262     if ( iter == beginIter && hitTestResults.renderTask )
263     {
264       currentRenderTask = hitTestResults.renderTask;
265     }
266   }
267
268   // 3) Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
269
270   // Emit the touch signal
271   Dali::Actor consumedActor;
272   if ( currentRenderTask )
273   {
274     consumedActor = EmitTouchSignals( touchData->GetPoint( 0 ).GetHitActor(), touchEvent, touchDataHandle );
275   }
276
277   Integration::Point& primaryPoint = touchData->GetPoint( 0 );
278   Dali::Actor primaryHitActor = primaryPoint.GetHitActor();
279   PointState::Type primaryPointState = primaryPoint.GetState();
280
281   DALI_LOG_INFO( gLogFilter, Debug::Concise, "PrimaryHitActor:     (%p) %s\n", primaryHitActor ? reinterpret_cast< void* >( &primaryHitActor.GetBaseObject() ) : NULL, primaryHitActor ? primaryHitActor.GetName().c_str() : "" );
282   DALI_LOG_INFO( gLogFilter, Debug::Concise, "ConsumedActor:       (%p) %s\n", consumedActor ? reinterpret_cast< void* >( &consumedActor.GetBaseObject() ) : NULL, consumedActor ? consumedActor.GetName().c_str() : "" );
283
284   if ( ( primaryPointState == PointState::DOWN ) &&
285        ( touchEvent.GetPointCount() == 1 ) &&
286        ( consumedActor && consumedActor.OnStage() ) )
287   {
288     mTouchDownConsumedActor.SetActor( &GetImplementation( consumedActor ) );
289   }
290
291   // 4) Check if the last primary hit actor requires a leave event and if it was different to the current primary
292   //    hit actor.  Also process the last consumed actor in the same manner.
293
294   Actor* lastPrimaryHitActor( mLastPrimaryHitActor.GetActor() );
295   Actor* lastConsumedActor( mLastConsumedActor.GetActor() );
296   if( ( primaryPointState == PointState::MOTION ) || ( primaryPointState == PointState::UP ) || ( primaryPointState == PointState::STATIONARY ) )
297   {
298     if( mLastRenderTask )
299     {
300       Dali::Actor leaveEventConsumer;
301       RenderTask& lastRenderTaskImpl = *mLastRenderTask.Get();
302
303       if( lastPrimaryHitActor &&
304           lastPrimaryHitActor != primaryHitActor &&
305           lastPrimaryHitActor != consumedActor )
306       {
307         if( lastPrimaryHitActor->IsHittable() && IsActuallySensitive( lastPrimaryHitActor ) )
308         {
309           if ( lastPrimaryHitActor->GetLeaveRequired() )
310           {
311             DALI_LOG_INFO( gLogFilter, Debug::Concise, "LeaveActor(Hit):     (%p) %s\n", reinterpret_cast< void* >( lastPrimaryHitActor ), lastPrimaryHitActor->GetName().c_str() );
312             leaveEventConsumer = EmitTouchSignals( mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEvent, touchData, PointState::LEAVE );
313           }
314         }
315         else
316         {
317           // At this point mLastPrimaryHitActor was touchable and sensitive in the previous touch event process but is not in the current one.
318           // An interrupted event is send to allow some actors to go back to their original state (i.e. Button controls)
319           DALI_LOG_INFO( gLogFilter, Debug::Concise, "InterruptedActor(Hit):     (%p) %s\n", reinterpret_cast< void* >( lastPrimaryHitActor ), lastPrimaryHitActor->GetName().c_str() );
320           leaveEventConsumer = EmitTouchSignals( mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEvent, touchData, PointState::INTERRUPTED );
321         }
322       }
323
324       // Check if the motion event has been consumed by another actor's listener.  In this case, the previously
325       // consumed actor's listeners may need to be informed (through a leave event).
326       // Further checks here to ensure we do not signal the same actor twice for the same event.
327       if ( lastConsumedActor &&
328            lastConsumedActor != consumedActor &&
329            lastConsumedActor != lastPrimaryHitActor &&
330            lastConsumedActor != primaryHitActor &&
331            lastConsumedActor != leaveEventConsumer )
332       {
333         if( lastConsumedActor->IsHittable() && IsActuallySensitive( lastConsumedActor ) )
334         {
335           if( lastConsumedActor->GetLeaveRequired() )
336           {
337             DALI_LOG_INFO( gLogFilter, Debug::Concise, "LeaveActor(Consume): (%p) %s\n", reinterpret_cast< void* >( lastConsumedActor ), lastConsumedActor->GetName().c_str() );
338             EmitTouchSignals( lastConsumedActor, lastRenderTaskImpl, touchEvent, touchData, PointState::LEAVE );
339           }
340         }
341         else
342         {
343           // At this point mLastConsumedActor was touchable and sensitive in the previous touch event process but is not in the current one.
344           // An interrupted event is send to allow some actors to go back to their original state (i.e. Button controls)
345           DALI_LOG_INFO( gLogFilter, Debug::Concise, "InterruptedActor(Consume):     (%p) %s\n", reinterpret_cast< void* >( lastConsumedActor ), lastConsumedActor->GetName().c_str() );
346           EmitTouchSignals( mLastConsumedActor.GetActor(), lastRenderTaskImpl, touchEvent, touchData, PointState::INTERRUPTED );
347         }
348       }
349     }
350   }
351
352   // 5) If our primary point is an Up event, then the primary point (in multi-touch) will change next
353   //    time so set our last primary actor to NULL.  Do the same to the last consumed actor as well.
354
355   if ( primaryPointState == PointState::UP )
356   {
357     mLastPrimaryHitActor.SetActor( NULL );
358     mLastConsumedActor.SetActor( NULL );
359     mLastRenderTask.Reset();
360   }
361   else
362   {
363     // The primaryHitActor may have been removed from the stage so ensure it is still on the stage before setting members.
364     if ( primaryHitActor && primaryHitActor.OnStage() )
365     {
366       mLastPrimaryHitActor.SetActor( &GetImplementation( primaryHitActor ) );
367
368       // Only observe the consumed actor if we have a primaryHitActor (check if it is still on stage).
369       if ( consumedActor && consumedActor.OnStage() )
370       {
371         mLastConsumedActor.SetActor( &GetImplementation( consumedActor ) );
372       }
373       else
374       {
375         mLastConsumedActor.SetActor( NULL );
376       }
377
378       mLastRenderTask = currentRenderTask;
379     }
380     else
381     {
382       mLastPrimaryHitActor.SetActor( NULL );
383       mLastConsumedActor.SetActor( NULL );
384       mLastRenderTask.Reset();
385     }
386   }
387
388   // 6) Emit an interrupted event to the touch-down actor if it hasn't consumed the up and
389   //    emit the stage touched event if required.
390
391   if ( touchEvent.GetPointCount() == 1 ) // Only want the first touch and the last release
392   {
393     switch ( primaryPointState )
394     {
395       case PointState::UP:
396       {
397         Actor* touchDownConsumedActor( mTouchDownConsumedActor.GetActor() );
398         if ( touchDownConsumedActor &&
399              touchDownConsumedActor != consumedActor &&
400              touchDownConsumedActor != lastPrimaryHitActor &&
401              touchDownConsumedActor != lastConsumedActor )
402         {
403           Dali::Actor touchDownConsumedActorHandle( touchDownConsumedActor );
404
405           Integration::Point currentPoint = touchData->GetPoint( 0 );
406           currentPoint.SetHitActor( touchDownConsumedActorHandle );
407           currentPoint.SetState( PointState::INTERRUPTED );
408
409           AllocAndEmitTouchSignals( event.time, touchDownConsumedActorHandle, currentPoint );
410         }
411
412         mTouchDownConsumedActor.SetActor( NULL );
413       }
414       // No break, Fallthrough
415
416       case PointState::DOWN:
417       {
418         mScene.EmitTouchedSignal( touchEvent, touchDataHandle );
419         break;
420       }
421
422       case PointState::MOTION:
423       case PointState::LEAVE:
424       case PointState::STATIONARY:
425       case PointState::INTERRUPTED:
426       {
427         // Ignore
428         break;
429       }
430     }
431   }
432 }
433
434 void TouchEventProcessor::OnObservedActorDisconnected( Actor* actor )
435 {
436   if ( actor == mLastPrimaryHitActor.GetActor() )
437   {
438     Dali::Actor handle( actor );
439
440     Integration::Point point;
441     point.SetState( PointState::INTERRUPTED );
442     point.SetHitActor( handle );
443
444     TouchDataPtr touchData( new TouchData );
445     touchData->AddPoint( point );
446     Dali::TouchData touchDataHandle( touchData.Get() );
447
448     TouchEvent touchEvent( 0 );
449     touchEvent.points.push_back( point.GetTouchPoint() );
450
451     Dali::Actor eventConsumer = EmitTouchSignals( handle, touchEvent, touchDataHandle );
452
453     if ( mLastConsumedActor.GetActor() != eventConsumer )
454     {
455       EmitTouchSignals( Dali::Actor( mLastConsumedActor.GetActor() ), touchEvent, touchDataHandle );
456     }
457
458     // Do not set mLastPrimaryHitActor to NULL we may be iterating through its observers
459
460     mLastConsumedActor.SetActor( NULL );
461     mLastRenderTask.Reset();
462   }
463 }
464
465 } // namespace Internal
466
467 } // namespace Dali