2 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <dali/internal/event/events/touch-event-processor.h>
21 #if defined(DEBUG_ENABLED)
26 #include <dali/public-api/actors/renderable-actor.h>
27 #include <dali/public-api/math/vector2.h>
28 #include <dali/integration-api/debug.h>
29 #include <dali/integration-api/events/touch-event-integ.h>
30 #include <dali/internal/event/actors/actor-impl.h>
31 #include <dali/internal/event/actors/layer-impl.h>
32 #include <dali/internal/event/common/stage-impl.h>
33 #include <dali/internal/event/events/hit-test-algorithm-impl.h>
34 #include <dali/internal/event/render-tasks/render-task-impl.h>
45 bool IsActuallySensitive( Actor* actor );
47 #if defined(DEBUG_ENABLED)
48 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_TOUCH_PROCESSOR" );
50 const char * TOUCH_POINT_STATE[TouchPoint::Last] =
60 static const Debug::LogLevel HIERARCHY_DEBUG_LOG_LEVEL( Debug::Verbose );
62 static bool HIERARCHY_GEOMETRY( false );
63 static bool HIERARCHY_SENSITIVITY( false );
64 static bool HIERARCHY_TOUCH_REQUIRED( false );
65 static bool HIERARCHY_HITTABLE( false );
68 * Prints out all the children of the given actor when debug is enabled.
70 * @param[in] actor The actor whose children to print.
71 * @param[in] level The number of " | " to put in front of the children.
73 void PrintChildren( Dali::Actor actor, int level )
75 std::ostringstream output;
77 for ( int t = 0; t < level; ++t )
82 output << actor.GetName() << "(" << actor.GetTypeName() << ", " << actor.GetObjectPtr() << ")";
84 if ( HIERARCHY_GEOMETRY )
86 output << " Pos: " << actor.GetCurrentWorldPosition() << " Size: " << actor.GetCurrentSize() << " Scale: " << actor.GetCurrentWorldScale();
89 if ( HIERARCHY_SENSITIVITY )
91 output << " Sensitivity: " << ( IsActuallySensitive( &GetImplementation( actor ) ) ? "True " : "False " );
94 if ( HIERARCHY_TOUCH_REQUIRED )
96 output << " TouchRequired: " << ( GetImplementation(actor).GetTouchRequired() ? "True " : "False " );
99 if ( HIERARCHY_HITTABLE )
101 output << " Hittable: " << ( GetImplementation(actor).IsHittable() ? "True " : "False " );
106 DALI_LOG_INFO( gLogFilter, HIERARCHY_DEBUG_LOG_LEVEL, output.str().c_str() );
109 unsigned int numChildren=actor.GetChildCount();
110 for ( unsigned int i=0; i<numChildren; ++i )
112 PrintChildren( actor.GetChildAt(i), level );
118 * Prints the entire hierarchy of the scene.
120 void PrintHierarchy()
122 if ( gLogFilter->IsEnabledFor( HIERARCHY_DEBUG_LOG_LEVEL ) )
124 PrintChildren( Dali::Stage().GetCurrent().GetRootLayer(), 0 );
128 #define PRINT_HIERARCHY PrintHierarchy()
130 #else // defined(DEBUG_ENABLED)
132 #define PRINT_HIERARCHY
134 #endif // defined(DEBUG_ENABLED)
137 * Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
139 Dali::Actor EmitTouchSignals( Dali::Actor actor, const TouchEvent& event )
141 Dali::Actor consumedActor;
145 Dali::Actor oldParent( actor.GetParent() );
147 Actor& actorImpl( GetImplementation(actor) );
149 bool consumed( false );
151 // Only emit the signal if the actor's touch signal has connections (or derived actor implementation requires touch).
152 if ( actorImpl.GetTouchRequired() )
154 consumed = actorImpl.EmitTouchEventSignal( event );
159 // One of this actor's listeners has consumed the event so set this actor as the consumed actor.
160 consumedActor = Dali::Actor( &actorImpl );
164 // The actor may have been removed/reparented during the signal callbacks.
165 Dali::Actor parent = actor.GetParent();
168 (parent == oldParent) )
170 // One of the actor's parents may consumed the event and they should be set as the consumed actor.
171 consumedActor = EmitTouchSignals( parent, event );
176 return consumedActor;
180 * Changes the state of the primary point to leave and emits the touch signals
182 Dali::Actor EmitTouchSignals( Actor* actor, RenderTask& renderTask, const TouchEvent& originalEvent, TouchPoint::State state )
184 TouchEvent touchEvent( originalEvent );
185 TouchPoint& primaryPoint = touchEvent.points[0];
187 actor->ScreenToLocal( renderTask, primaryPoint.local.x, primaryPoint.local.y, primaryPoint.screen.x, primaryPoint.screen.y );
189 primaryPoint.hitActor = actor;
190 primaryPoint.state = state;
192 return EmitTouchSignals( Dali::Actor(actor), touchEvent );
196 * In the hit test algorithm above we do not descend actor tree if it is insensitive, so here, we
197 * should also check if any of the actor's parents has become insensitive since we last processed
200 bool IsActuallySensitive( Actor* actor )
202 bool sensitive = true;
204 while ( actor && sensitive )
206 sensitive = actor->IsSensitive();
207 actor = actor->GetParent();
213 } // unnamed namespace
215 TouchEventProcessor::TouchEventProcessor( Stage& stage )
217 mLastPrimaryHitActor(),
218 mLastConsumedActor(),
219 mTouchDownConsumedActor(),
222 DALI_LOG_TRACE_METHOD( gLogFilter );
225 TouchEventProcessor::~TouchEventProcessor()
227 DALI_LOG_TRACE_METHOD( gLogFilter );
230 void TouchEventProcessor::ProcessTouchEvent( const Integration::TouchEvent& event )
232 DALI_LOG_TRACE_METHOD( gLogFilter );
234 DALI_ASSERT_ALWAYS( !event.points.empty() && "Empty TouchEvent sent from Integration\n" );
236 Stage& stage = mStage;
240 // Copy so we can add the results of a hit-test.
241 TouchEvent touchEvent( event.time );
243 // 1) Check if it is an interrupted event - we should inform our last primary hit actor about this
244 // and emit the stage signal as well.
246 if ( event.points[0].state == TouchPoint::Interrupted )
248 Dali::Actor consumingActor;
249 touchEvent.points.push_back(event.points[0]);
251 Actor* lastPrimaryHitActor( mLastPrimaryHitActor.GetActor() );
252 if ( lastPrimaryHitActor )
254 Dali::Actor lastPrimaryHitActorHandle( lastPrimaryHitActor );
255 touchEvent.points[0].hitActor = lastPrimaryHitActorHandle;
256 consumingActor = EmitTouchSignals( lastPrimaryHitActorHandle, touchEvent );
259 // If the last consumed actor was different to the primary hit actor then inform it as well (if it has not already been informed).
260 Actor* lastConsumedActor( mLastConsumedActor.GetActor() );
261 if ( lastConsumedActor &&
262 lastConsumedActor != lastPrimaryHitActor &&
263 lastConsumedActor != consumingActor )
265 Dali::Actor lastConsumedActorHandle( lastConsumedActor );
266 touchEvent.points[0].hitActor = lastConsumedActorHandle;
267 EmitTouchSignals( lastConsumedActorHandle, touchEvent );
270 // Tell the touch-down consuming actor as well, if required
271 Actor* touchDownConsumedActor( mTouchDownConsumedActor.GetActor() );
272 if ( touchDownConsumedActor &&
273 touchDownConsumedActor != lastPrimaryHitActor &&
274 touchDownConsumedActor != lastConsumedActor &&
275 touchDownConsumedActor != consumingActor )
277 Dali::Actor touchDownConsumedActorHandle( touchDownConsumedActor );
278 touchEvent.points[0].hitActor = touchDownConsumedActorHandle;
279 EmitTouchSignals( touchDownConsumedActorHandle, touchEvent );
282 mLastPrimaryHitActor.SetActor( NULL );
283 mLastConsumedActor.SetActor( NULL );
284 mTouchDownConsumedActor.SetActor( NULL );
285 mLastRenderTask.Reset();
287 touchEvent.points[0].hitActor = NULL;
288 mStage.EmitTouchedSignal( touchEvent );
290 return; // No need for hit testing
295 DALI_LOG_INFO( gLogFilter, Debug::Concise, "\n" );
296 DALI_LOG_INFO( gLogFilter, Debug::General, "Point(s): %d\n", event.GetPointCount() );
298 Dali::RenderTask currentRenderTask;
300 for ( TouchPointContainerConstIterator iter = event.points.begin(), beginIter = event.points.begin(), endIter = event.points.end(); iter != endIter; ++iter )
302 HitTestAlgorithm::Results hitTestResults;
303 HitTestAlgorithm::HitTest( stage, iter->screen, hitTestResults );
305 TouchPoint newPoint( iter->deviceId, iter->state, iter->screen.x, iter->screen.y );
306 newPoint.hitActor = hitTestResults.actor;
307 newPoint.local = hitTestResults.actorCoordinates;
309 touchEvent.points.push_back( newPoint );
311 DALI_LOG_INFO( gLogFilter, Debug::General, " State(%s), Screen(%.0f, %.0f), HitActor(%p, %s), Local(%.2f, %.2f)\n",
312 TOUCH_POINT_STATE[iter->state], iter->screen.x, iter->screen.y,
313 ( hitTestResults.actor ? (void*)&hitTestResults.actor.GetBaseObject() : NULL ),
314 ( hitTestResults.actor ? hitTestResults.actor.GetName().c_str() : "" ),
315 hitTestResults.actorCoordinates.x, hitTestResults.actorCoordinates.y );
317 // Only set the currentRenderTask for the primary hit actor.
318 if ( iter == beginIter && hitTestResults.renderTask )
320 currentRenderTask = hitTestResults.renderTask;
324 // 3) Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
326 // Emit the touch signal
327 Dali::Actor consumedActor;
328 if ( currentRenderTask )
330 consumedActor = EmitTouchSignals( touchEvent.points[0].hitActor, touchEvent );
333 TouchPoint& primaryPoint = touchEvent.points[0];
334 Dali::Actor primaryHitActor = primaryPoint.hitActor;
335 TouchPoint::State primaryPointState = primaryPoint.state;
337 DALI_LOG_INFO( gLogFilter, Debug::Concise, "PrimaryHitActor: (%p) %s\n", primaryPoint.hitActor ? (void*)&primaryPoint.hitActor.GetBaseObject() : NULL, primaryPoint.hitActor ? primaryPoint.hitActor.GetName().c_str() : "" );
338 DALI_LOG_INFO( gLogFilter, Debug::Concise, "ConsumedActor: (%p) %s\n", consumedActor ? (void*)&consumedActor.GetBaseObject() : NULL, consumedActor ? consumedActor.GetName().c_str() : "" );
340 if ( ( primaryPointState == TouchPoint::Down ) &&
341 ( touchEvent.GetPointCount() == 1 ) &&
342 ( consumedActor && consumedActor.OnStage() ) )
344 mTouchDownConsumedActor.SetActor( &GetImplementation( consumedActor ) );
347 // 4) Check if the last primary hit actor requires a leave event and if it was different to the current primary
348 // hit actor. Also process the last consumed actor in the same manner.
350 Actor* lastPrimaryHitActor( mLastPrimaryHitActor.GetActor() );
351 Actor* lastConsumedActor( mLastConsumedActor.GetActor() );
352 if( (primaryPointState == TouchPoint::Motion) || (primaryPointState == TouchPoint::Up) || (primaryPointState == TouchPoint::Stationary) )
354 if ( mLastRenderTask )
356 Dali::Actor leaveEventConsumer;
357 RenderTask& lastRenderTaskImpl( GetImplementation( mLastRenderTask ) );
359 if( lastPrimaryHitActor &&
360 lastPrimaryHitActor != primaryHitActor &&
361 lastPrimaryHitActor != consumedActor )
363 if( lastPrimaryHitActor->IsHittable() && IsActuallySensitive( lastPrimaryHitActor ) )
365 if ( lastPrimaryHitActor->GetLeaveRequired() )
367 DALI_LOG_INFO( gLogFilter, Debug::Concise, "LeaveActor(Hit): (%p) %s\n", (void*)lastPrimaryHitActor, lastPrimaryHitActor->GetName().c_str() );
368 leaveEventConsumer = EmitTouchSignals( mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEvent, TouchPoint::Leave );
373 // At this point mLastPrimaryHitActor was touchable and sensitive in the previous touch event process but is not in the current one.
374 // An interrupted event is send to allow some actors to go back to their original state (i.e. Button controls)
375 DALI_LOG_INFO( gLogFilter, Debug::Concise, "InterruptedActor(Hit): (%p) %s\n", (void*)lastPrimaryHitActor, lastPrimaryHitActor->GetName().c_str() );
376 leaveEventConsumer = EmitTouchSignals( mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEvent, TouchPoint::Interrupted );
380 // Check if the motion event has been consumed by another actor's listener. In this case, the previously
381 // consumed actor's listeners may need to be informed (through a leave event).
382 // Further checks here to ensure we do not signal the same actor twice for the same event.
383 if ( lastConsumedActor &&
384 lastConsumedActor != consumedActor &&
385 lastConsumedActor != lastPrimaryHitActor &&
386 lastConsumedActor != primaryHitActor &&
387 lastConsumedActor != leaveEventConsumer )
389 if( lastConsumedActor->IsHittable() && IsActuallySensitive( lastConsumedActor ) )
391 if( lastConsumedActor->GetLeaveRequired() )
393 DALI_LOG_INFO( gLogFilter, Debug::Concise, "LeaveActor(Consume): (%p) %s\n", (void*)lastConsumedActor, lastConsumedActor->GetName().c_str() );
394 EmitTouchSignals( lastConsumedActor, lastRenderTaskImpl, touchEvent, TouchPoint::Leave );
399 // At this point mLastConsumedActor was touchable and sensitive in the previous touch event process but is not in the current one.
400 // An interrupted event is send to allow some actors to go back to their original state (i.e. Button controls)
401 DALI_LOG_INFO( gLogFilter, Debug::Concise, "InterruptedActor(Consume): (%p) %s\n", (void*)lastConsumedActor, lastConsumedActor->GetName().c_str() );
402 EmitTouchSignals( mLastConsumedActor.GetActor(), lastRenderTaskImpl, touchEvent, TouchPoint::Interrupted );
408 // 5) If our primary point is an Up event, then the primary point (in multi-touch) will change next
409 // time so set our last primary actor to NULL. Do the same to the last consumed actor as well.
411 if ( primaryPointState == TouchPoint::Up )
413 mLastPrimaryHitActor.SetActor( NULL );
414 mLastConsumedActor.SetActor( NULL );
415 mLastRenderTask.Reset();
419 // The primaryHitActor may have been removed from the stage so ensure it is still on the stage before setting members.
420 if ( primaryHitActor && primaryHitActor.OnStage() )
422 mLastPrimaryHitActor.SetActor( &GetImplementation( primaryHitActor ) );
424 // Only observe the consumed actor if we have a primaryHitActor (check if it is still on stage).
425 if ( consumedActor && consumedActor.OnStage() )
427 mLastConsumedActor.SetActor( &GetImplementation( consumedActor ) );
431 mLastConsumedActor.SetActor( NULL );
434 mLastRenderTask = currentRenderTask;
438 mLastPrimaryHitActor.SetActor( NULL );
439 mLastConsumedActor.SetActor( NULL );
440 mLastRenderTask.Reset();
444 // 6) Emit an interrupted event to the touch-down actor if it hasn't consumed the up and
445 // emit the stage touched event if required.
447 if ( touchEvent.GetPointCount() == 1 ) // Only want the first touch and the last release
449 switch ( primaryPointState )
453 Actor* touchDownConsumedActor( mTouchDownConsumedActor.GetActor() );
454 if ( touchDownConsumedActor &&
455 touchDownConsumedActor != consumedActor &&
456 touchDownConsumedActor != lastPrimaryHitActor &&
457 touchDownConsumedActor != lastConsumedActor )
459 Dali::Actor touchDownConsumedActorHandle( touchDownConsumedActor );
460 touchEvent.points[0].hitActor = touchDownConsumedActorHandle;
461 touchEvent.points[0].state = TouchPoint::Interrupted;
462 EmitTouchSignals( touchDownConsumedActorHandle, touchEvent );
465 mTouchDownConsumedActor.SetActor( NULL );
467 // No break, Fallthrough
469 case TouchPoint::Down:
471 mStage.EmitTouchedSignal( touchEvent );
475 case TouchPoint::Motion:
476 case TouchPoint::Leave:
477 case TouchPoint::Stationary:
478 case TouchPoint::Interrupted:
479 case TouchPoint::Last:
488 TouchEventProcessor::ActorObserver::ActorObserver()
490 mActorDisconnected(false)
492 DALI_LOG_TRACE_METHOD( gLogFilter );
495 TouchEventProcessor::ActorObserver::~ActorObserver()
497 DALI_LOG_TRACE_METHOD( gLogFilter );
501 Actor* TouchEventProcessor::ActorObserver::GetActor()
503 return mActorDisconnected ? NULL : mActor;
506 void TouchEventProcessor::ActorObserver::SetActor( Actor* actor )
508 DALI_LOG_TRACE_METHOD( gLogFilter );
510 if ( mActor != actor )
518 mActor->AddObserver( *this );
519 DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Start Observing: %p\n", mActor);
524 void TouchEventProcessor::ActorObserver::ResetActor()
528 DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Stop Observing: %p\n", mActor);
529 mActor->RemoveObserver( *this );
531 mActorDisconnected = false;
535 void TouchEventProcessor::ActorObserver::SceneObjectRemoved( ProxyObject& proxy )
537 DALI_LOG_TRACE_METHOD( gLogFilter );
539 if ( mActor == &proxy )
541 // do not call proxy.RemoveObserver here, proxy is currently iterating through observers... you wouldnt want to upset proxy now would you?
542 mActorDisconnected = true;
546 void TouchEventProcessor::ActorObserver::ProxyDestroyed(ProxyObject& proxy)
548 DALI_LOG_TRACE_METHOD( gLogFilter );
550 if ( mActor == &proxy )
552 DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Stop Observing: %p\n", mActor);
557 } // namespace Internal