dali/internal/event/events/touch-event-processor.cpp

   1 /*
   2  * Copyright (c) 2020 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-event.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-event-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 Dali::Actor EmitInterceptTouchSignals( Dali::Actor actor, const Dali::TouchEvent& touchEvent )
  64 {
  65   Dali::Actor interceptedActor;
  66
  67   if( actor )
  68   {
  69      Dali::Actor parent = actor.GetParent();
  70      if( parent )
  71      {
  72        // Recursively deliver events to the actor and its parents for intercept touch event.
  73        interceptedActor = EmitInterceptTouchSignals( parent, touchEvent );
  74      }
  75
  76      if( !interceptedActor )
  77      {
  78        bool intercepted = false;
  79        Actor& actorImpl( GetImplementation(actor) );
  80        if( actorImpl.GetInterceptTouchRequired() )
  81        {
  82           intercepted = actorImpl.EmitInterceptTouchEventSignal( touchEvent );
  83           if( intercepted )
  84           {
  85             interceptedActor = Dali::Actor( &actorImpl );
  86           }
  87        }
  88      }
  89   }
  90
  91   return interceptedActor;
  92 }
  93
  94 /**
  95  *  Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
  96  */
  97 Dali::Actor EmitTouchSignals( Dali::Actor actor, const Dali::TouchEvent& touchEvent )
  98 {
  99   Dali::Actor consumedActor;
 100
 101   if ( actor )
 102   {
 103     Dali::Actor oldParent( actor.GetParent() );
 104
 105     Actor& actorImpl( GetImplementation(actor) );
 106
 107     bool consumed( false );
 108
 109     // Only emit the signal if the actor's touch signal has connections (or derived actor implementation requires touch).
 110     if ( actorImpl.GetTouchRequired() )
 111     {
 112       consumed = actorImpl.EmitTouchEventSignal( touchEvent );
 113     }
 114
 115     if ( consumed )
 116     {
 117       // One of this actor's listeners has consumed the event so set this actor as the consumed actor.
 118       consumedActor = Dali::Actor( &actorImpl );
 119     }
 120     else
 121     {
 122       // The actor may have been removed/reparented during the signal callbacks.
 123       Dali::Actor parent = actor.GetParent();
 124
 125       if ( parent &&
 126            (parent == oldParent) )
 127       {
 128         // One of the actor's parents may consumed the event and they should be set as the consumed actor.
 129         consumedActor = EmitTouchSignals( parent, touchEvent );
 130       }
 131     }
 132   }
 133
 134   return consumedActor;
 135 }
 136
 137 Dali::Actor AllocAndEmitTouchSignals( unsigned long time,  Dali::Actor actor, const Integration::Point& point )
 138 {
 139   TouchEventPtr touchEvent( new TouchEvent( time ) );
 140   Dali::TouchEvent touchEventHandle( touchEvent.Get() );
 141
 142   touchEvent->AddPoint( point );
 143
 144   return EmitTouchSignals( actor, touchEventHandle );
 145 }
 146
 147
 148 /**
 149  * Changes the state of the primary point to leave and emits the touch signals
 150  */
 151 Dali::Actor EmitTouchSignals( Actor* actor, RenderTask& renderTask, const TouchEventPtr& originalTouchEvent, PointState::Type state )
 152 {
 153   Dali::Actor consumingActor;
 154
 155   if( actor )
 156   {
 157     TouchEventPtr touchEventImpl = TouchEvent::Clone( *originalTouchEvent.Get() );
 158
 159     Integration::Point& primaryPoint = touchEventImpl->GetPoint( 0 );
 160
 161     const Vector2& screenPosition = primaryPoint.GetScreenPosition();
 162     Vector2 localPosition;
 163     actor->ScreenToLocal( renderTask, localPosition.x, localPosition.y, screenPosition.x, screenPosition.y );
 164
 165     primaryPoint.SetLocalPosition( localPosition );
 166     primaryPoint.SetHitActor( Dali::Actor( actor ) );
 167     primaryPoint.SetState( state );
 168
 169     consumingActor = EmitTouchSignals( Dali::Actor(actor), Dali::TouchEvent( touchEventImpl.Get() ) );
 170   }
 171
 172   return consumingActor;
 173 }
 174
 175 /**
 176  * @brief Parses the primary touch point by performing a hit-test if necessary
 177  *
 178  * @param[out] hitTestResults The hit test results are put into this variable
 179  * @param[in/out] capturingTouchActorObserver The observer for the capturing touch actor member
 180  * @param[in] lastRenderTask The last render task member
 181  * @param[in] currentPoint The current point information
 182  * @param[in] scene The scene that this touch is related to
 183  */
 184 void ParsePrimaryTouchPoint(
 185     HitTestAlgorithm::Results& hitTestResults,
 186     ActorObserver& capturingTouchActorObserver,
 187     const RenderTaskPtr& lastRenderTask,
 188     const Integration::Point& currentPoint,
 189     const Internal::Scene& scene )
 190 {
 191   Actor* capturingTouchActor = capturingTouchActorObserver.GetActor();
 192
 193   // We only set the capturing touch actor when the first touch-started actor captures all touch so if it's set, just use it
 194   if( capturingTouchActor && lastRenderTask )
 195   {
 196     hitTestResults.actor = Dali::Actor( capturingTouchActor );
 197     hitTestResults.renderTask = lastRenderTask;
 198     const Vector2& screenPosition = currentPoint.GetScreenPosition();
 199     capturingTouchActor->ScreenToLocal( *lastRenderTask, hitTestResults.actorCoordinates.x, hitTestResults.actorCoordinates.y, screenPosition.x, screenPosition.y );
 200   }
 201   else
 202   {
 203     HitTestAlgorithm::HitTest( scene.GetSize(), scene.GetRenderTaskList(), scene.GetLayerList(), currentPoint.GetScreenPosition(), hitTestResults );
 204
 205     if( currentPoint.GetState() == PointState::STARTED && hitTestResults.actor )
 206     {
 207       // If we've just started touch, then check whether the actor has requested to capture all touch events
 208       Actor* hitActor = &GetImplementation( hitTestResults.actor );
 209       if( hitActor->CapturesAllTouchAfterStart() )
 210       {
 211         capturingTouchActorObserver.SetActor( hitActor );
 212       }
 213     }
 214   }
 215 }
 216
 217 } // unnamed namespace
 218
 219 TouchEventProcessor::TouchEventProcessor( Scene& scene )
 220 : mScene( scene ),
 221   mLastPrimaryHitActor( MakeCallback( this, &TouchEventProcessor::OnObservedActorDisconnected ) ),
 222   mLastConsumedActor(),
 223   mCapturingTouchActor(),
 224   mTouchDownConsumedActor(),
 225   mLastRenderTask()
 226 {
 227   DALI_LOG_TRACE_METHOD( gLogFilter );
 228 }
 229
 230 TouchEventProcessor::~TouchEventProcessor()
 231 {
 232   DALI_LOG_TRACE_METHOD( gLogFilter );
 233 }
 234
 235 bool TouchEventProcessor::ProcessTouchEvent( const Integration::TouchEvent& event )
 236 {
 237   DALI_LOG_TRACE_METHOD( gLogFilter );
 238   DALI_ASSERT_ALWAYS( !event.points.empty() && "Empty TouchEvent sent from Integration\n" );
 239
 240   PRINT_HIERARCHY(gLogFilter);
 241
 242   // 1) Check if it is an interrupted event - we should inform our last primary hit actor about this
 243   //    and emit the stage signal as well.
 244
 245   if ( event.points[0].GetState() == PointState::INTERRUPTED )
 246   {
 247     Dali::Actor consumingActor;
 248     Integration::Point currentPoint( event.points[0] );
 249
 250     Actor* lastPrimaryHitActor( mLastPrimaryHitActor.GetActor() );
 251     if ( lastPrimaryHitActor )
 252     {
 253       Dali::Actor lastPrimaryHitActorHandle( lastPrimaryHitActor );
 254       currentPoint.SetHitActor( lastPrimaryHitActorHandle );
 255
 256       consumingActor = AllocAndEmitTouchSignals( event.time, lastPrimaryHitActorHandle, currentPoint );
 257     }
 258
 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 )
 264     {
 265       Dali::Actor lastConsumedActorHandle( lastConsumedActor );
 266       currentPoint.SetHitActor( lastConsumedActorHandle );
 267       AllocAndEmitTouchSignals( event.time, lastConsumedActorHandle, currentPoint );
 268     }
 269
 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 )
 276     {
 277       Dali::Actor touchDownConsumedActorHandle( touchDownConsumedActor );
 278
 279       currentPoint.SetHitActor( touchDownConsumedActorHandle );
 280       AllocAndEmitTouchSignals( event.time, touchDownConsumedActorHandle, currentPoint );
 281     }
 282
 283     mLastPrimaryHitActor.SetActor( nullptr );
 284     mLastConsumedActor.SetActor( nullptr );
 285     mCapturingTouchActor.SetActor( nullptr );
 286     mTouchDownConsumedActor.SetActor( nullptr );
 287     mLastRenderTask.Reset();
 288
 289     currentPoint.SetHitActor( Dali::Actor() );
 290
 291     TouchEventPtr touchEventImpl( new TouchEvent( event.time ) );
 292     Dali::TouchEvent touchEventHandle( touchEventImpl.Get() );
 293
 294     touchEventImpl->AddPoint( currentPoint );
 295
 296     mScene.EmitTouchedSignal( touchEventHandle );
 297     return false; // No need for hit testing & already an interrupted event so just return false
 298   }
 299
 300   // 2) Hit Testing.
 301   TouchEventPtr touchEventImpl( new TouchEvent( event.time ) );
 302   Dali::TouchEvent touchEventHandle( touchEventImpl.Get() );
 303
 304   DALI_LOG_INFO( gLogFilter, Debug::Concise, "\n" );
 305   DALI_LOG_INFO( gLogFilter, Debug::General, "Point(s): %d\n", event.GetPointCount() );
 306
 307   RenderTaskPtr currentRenderTask;
 308   bool firstPointParsed = false;
 309
 310   for ( auto&& currentPoint : event.points )
 311   {
 312     HitTestAlgorithm::Results hitTestResults;
 313     if( !firstPointParsed )
 314     {
 315       firstPointParsed = true;
 316       ParsePrimaryTouchPoint( hitTestResults, mCapturingTouchActor, mLastRenderTask, currentPoint, mScene );
 317
 318       // Only set the currentRenderTask for the primary hit actor.
 319       currentRenderTask = hitTestResults.renderTask;
 320     }
 321     else
 322     {
 323       HitTestAlgorithm::HitTest( mScene.GetSize(), mScene.GetRenderTaskList(), mScene.GetLayerList(), currentPoint.GetScreenPosition(), hitTestResults );
 324     }
 325
 326     Integration::Point newPoint( currentPoint );
 327     newPoint.SetHitActor( hitTestResults.actor );
 328     newPoint.SetLocalPosition( hitTestResults.actorCoordinates );
 329
 330     touchEventImpl->AddPoint( newPoint );
 331
 332     DALI_LOG_INFO( gLogFilter, Debug::General, "  State(%s), Screen(%.0f, %.0f), HitActor(%p, %s), Local(%.2f, %.2f)\n",
 333                    TOUCH_POINT_STATE[currentPoint.GetState()], currentPoint.GetScreenPosition().x, currentPoint.GetScreenPosition().y,
 334                    ( hitTestResults.actor ? reinterpret_cast< void* >( &hitTestResults.actor.GetBaseObject() ) : NULL ),
 335                    ( hitTestResults.actor ? hitTestResults.actor.GetProperty< std::string >( Dali::Actor::Property::NAME ).c_str() : "" ),
 336                    hitTestResults.actorCoordinates.x, hitTestResults.actorCoordinates.y );
 337
 338   }
 339
 340   // 3) Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
 341
 342   bool consumed = false;
 343
 344   // Emit the touch signal
 345   Dali::Actor consumedActor;
 346   if ( currentRenderTask )
 347   {
 348     // Emit the intercept touch signal
 349     Dali::Actor interceptedActor = EmitInterceptTouchSignals( touchEventImpl->GetPoint( 0 ).GetHitActor(), touchEventHandle );
 350     if( interceptedActor )
 351     {
 352       consumedActor = EmitTouchSignals( interceptedActor, touchEventHandle );
 353     }
 354     else
 355     {
 356       consumedActor = EmitTouchSignals( touchEventImpl->GetPoint( 0 ).GetHitActor(), touchEventHandle );
 357     }
 358     consumed = consumedActor ? true : false;
 359   }
 360
 361   Integration::Point& primaryPoint = touchEventImpl->GetPoint( 0 );
 362   Dali::Actor primaryHitActor = primaryPoint.GetHitActor();
 363   PointState::Type primaryPointState = primaryPoint.GetState();
 364
 365   DALI_LOG_INFO( gLogFilter, Debug::Concise, "PrimaryHitActor:     (%p) %s\n", primaryHitActor ? reinterpret_cast< void* >( &primaryHitActor.GetBaseObject() ) : NULL, primaryHitActor ? primaryHitActor.GetProperty< std::string >( Dali::Actor::Property::NAME ).c_str() : "" );
 366   DALI_LOG_INFO( gLogFilter, Debug::Concise, "ConsumedActor:       (%p) %s\n", consumedActor ? reinterpret_cast< void* >( &consumedActor.GetBaseObject() ) : NULL, consumedActor ? consumedActor.GetProperty< std::string >( Dali::Actor::Property::NAME ).c_str() : "" );
 367
 368   if ( ( primaryPointState == PointState::DOWN ) &&
 369        ( touchEventImpl->GetPointCount() == 1 ) &&
 370        ( consumedActor && consumedActor.GetProperty< bool >( Dali::Actor::Property::CONNECTED_TO_SCENE ) ) )
 371   {
 372     mTouchDownConsumedActor.SetActor( &GetImplementation( consumedActor ) );
 373   }
 374
 375   // 4) Check if the last primary hit actor requires a leave event and if it was different to the current primary
 376   //    hit actor.  Also process the last consumed actor in the same manner.
 377
 378   Actor* lastPrimaryHitActor( mLastPrimaryHitActor.GetActor() );
 379   Actor* lastConsumedActor( mLastConsumedActor.GetActor() );
 380   if( ( primaryPointState == PointState::MOTION ) || ( primaryPointState == PointState::UP ) || ( primaryPointState == PointState::STATIONARY ) )
 381   {
 382     if( mLastRenderTask )
 383     {
 384       Dali::Actor leaveEventConsumer;
 385       RenderTask& lastRenderTaskImpl = *mLastRenderTask.Get();
 386
 387       if( lastPrimaryHitActor &&
 388           lastPrimaryHitActor != primaryHitActor &&
 389           lastPrimaryHitActor != consumedActor )
 390       {
 391         if( lastPrimaryHitActor->IsHittable() && IsActuallySensitive( lastPrimaryHitActor ) )
 392         {
 393           if ( lastPrimaryHitActor->GetLeaveRequired() )
 394           {
 395             DALI_LOG_INFO( gLogFilter, Debug::Concise, "LeaveActor(Hit):     (%p) %s\n", reinterpret_cast< void* >( lastPrimaryHitActor ), lastPrimaryHitActor->GetName().c_str() );
 396             leaveEventConsumer = EmitTouchSignals( mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEventImpl, PointState::LEAVE );
 397           }
 398         }
 399         else
 400         {
 401           // At this point mLastPrimaryHitActor was touchable and sensitive in the previous touch event process but is not in the current one.
 402           // An interrupted event is send to allow some actors to go back to their original state (i.e. Button controls)
 403           DALI_LOG_INFO( gLogFilter, Debug::Concise, "InterruptedActor(Hit):     (%p) %s\n", reinterpret_cast< void* >( lastPrimaryHitActor ), lastPrimaryHitActor->GetName().c_str() );
 404           leaveEventConsumer = EmitTouchSignals( mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEventImpl, PointState::INTERRUPTED );
 405         }
 406       }
 407
 408       consumed |= leaveEventConsumer ? true : false;
 409
 410       // Check if the motion event has been consumed by another actor's listener.  In this case, the previously
 411       // consumed actor's listeners may need to be informed (through a leave event).
 412       // Further checks here to ensure we do not signal the same actor twice for the same event.
 413       if ( lastConsumedActor &&
 414            lastConsumedActor != consumedActor &&
 415            lastConsumedActor != lastPrimaryHitActor &&
 416            lastConsumedActor != primaryHitActor &&
 417            lastConsumedActor != leaveEventConsumer )
 418       {
 419         if( lastConsumedActor->IsHittable() && IsActuallySensitive( lastConsumedActor ) )
 420         {
 421           if( lastConsumedActor->GetLeaveRequired() )
 422           {
 423             DALI_LOG_INFO( gLogFilter, Debug::Concise, "LeaveActor(Consume): (%p) %s\n", reinterpret_cast< void* >( lastConsumedActor ), lastConsumedActor->GetName().c_str() );
 424             EmitTouchSignals( lastConsumedActor, lastRenderTaskImpl, touchEventImpl, PointState::LEAVE );
 425           }
 426         }
 427         else
 428         {
 429           // At this point mLastConsumedActor was touchable and sensitive in the previous touch event process but is not in the current one.
 430           // An interrupted event is send to allow some actors to go back to their original state (i.e. Button controls)
 431           DALI_LOG_INFO( gLogFilter, Debug::Concise, "InterruptedActor(Consume):     (%p) %s\n", reinterpret_cast< void* >( lastConsumedActor ), lastConsumedActor->GetName().c_str() );
 432           EmitTouchSignals( mLastConsumedActor.GetActor(), lastRenderTaskImpl, touchEventImpl, PointState::INTERRUPTED );
 433         }
 434       }
 435     }
 436   }
 437
 438   // 5) If our primary point is an Up event, then the primary point (in multi-touch) will change next
 439   //    time so set our last primary actor to NULL.  Do the same to the last consumed actor as well.
 440
 441   if ( primaryPointState == PointState::UP )
 442   {
 443     mLastPrimaryHitActor.SetActor( nullptr );
 444     mLastConsumedActor.SetActor( nullptr );
 445     mCapturingTouchActor.SetActor( nullptr );
 446     mLastRenderTask.Reset();
 447   }
 448   else
 449   {
 450     // The primaryHitActor may have been removed from the scene so ensure it is still on the scene before setting members.
 451     if ( primaryHitActor && GetImplementation( primaryHitActor ).OnScene() )
 452     {
 453       mLastPrimaryHitActor.SetActor( &GetImplementation( primaryHitActor ) );
 454
 455       // Only observe the consumed actor if we have a primaryHitActor (check if it is still on the scene).
 456       if ( consumedActor && GetImplementation( consumedActor ).OnScene() )
 457       {
 458         mLastConsumedActor.SetActor( &GetImplementation( consumedActor ) );
 459       }
 460       else
 461       {
 462         mLastConsumedActor.SetActor( nullptr );
 463       }
 464
 465       mLastRenderTask = currentRenderTask;
 466     }
 467     else
 468     {
 469       mLastPrimaryHitActor.SetActor( nullptr );
 470       mLastConsumedActor.SetActor( nullptr );
 471       mCapturingTouchActor.SetActor( nullptr );
 472       mLastRenderTask.Reset();
 473     }
 474   }
 475
 476   // 6) Emit an interrupted event to the touch-down actor if it hasn't consumed the up and
 477   //    emit the stage touched event if required.
 478
 479   if ( touchEventImpl->GetPointCount() == 1 ) // Only want the first touch and the last release
 480   {
 481     switch ( primaryPointState )
 482     {
 483       case PointState::UP:
 484       {
 485         Actor* touchDownConsumedActor( mTouchDownConsumedActor.GetActor() );
 486         if ( touchDownConsumedActor &&
 487              touchDownConsumedActor != consumedActor &&
 488              touchDownConsumedActor != lastPrimaryHitActor &&
 489              touchDownConsumedActor != lastConsumedActor )
 490         {
 491           Dali::Actor touchDownConsumedActorHandle( touchDownConsumedActor );
 492
 493           Integration::Point currentPoint = touchEventImpl->GetPoint( 0 );
 494           currentPoint.SetHitActor( touchDownConsumedActorHandle );
 495           currentPoint.SetState( PointState::INTERRUPTED );
 496
 497           AllocAndEmitTouchSignals( event.time, touchDownConsumedActorHandle, currentPoint );
 498         }
 499
 500         mTouchDownConsumedActor.SetActor( nullptr );
 501
 502         DALI_FALLTHROUGH;
 503       }
 504
 505       case PointState::DOWN:
 506       {
 507         mScene.EmitTouchedSignal( touchEventHandle );
 508         break;
 509       }
 510
 511       case PointState::MOTION:
 512       case PointState::LEAVE:
 513       case PointState::STATIONARY:
 514       case PointState::INTERRUPTED:
 515       {
 516         // Ignore
 517         break;
 518       }
 519     }
 520   }
 521
 522   return consumed;
 523 }
 524
 525 void TouchEventProcessor::OnObservedActorDisconnected( Actor* actor )
 526 {
 527   if ( actor == mLastPrimaryHitActor.GetActor() )
 528   {
 529     Dali::Actor actorHandle( actor );
 530
 531     Integration::Point point;
 532     point.SetState( PointState::INTERRUPTED );
 533     point.SetHitActor( actorHandle );
 534
 535     TouchEventPtr touchEventImpl( new TouchEvent );
 536     touchEventImpl->AddPoint( point );
 537     Dali::TouchEvent touchEventHandle( touchEventImpl.Get() );
 538
 539     Dali::Actor eventConsumer = EmitTouchSignals( actorHandle, touchEventHandle );
 540
 541     if ( mLastConsumedActor.GetActor() != eventConsumer )
 542     {
 543       EmitTouchSignals( Dali::Actor( mLastConsumedActor.GetActor() ), touchEventHandle );
 544     }
 545
 546     // Do not set mLastPrimaryHitActor to NULL we may be iterating through its observers
 547
 548     mLastConsumedActor.SetActor( nullptr );
 549     mLastRenderTask.Reset();
 550   }
 551 }
 552
 553 } // namespace Internal
 554
 555 } // namespace Dali