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

   1 /*
   2  * Copyright (c) 2014 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/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>
  35
  36 namespace Dali
  37 {
  38
  39 namespace Internal
  40 {
  41
  42 namespace
  43 {
  44
  45 bool IsActuallySensitive( Actor* actor );
  46
  47 #if defined(DEBUG_ENABLED)
  48 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_TOUCH_PROCESSOR" );
  49
  50 const char * TOUCH_POINT_STATE[TouchPoint::Last] =
  51 {
  52   "Down",
  53   "Up",
  54   "Motion",
  55   "Leave",
  56   "Stationary",
  57   "Interrupted",
  58 };
  59
  60 static const Debug::LogLevel HIERARCHY_DEBUG_LOG_LEVEL( Debug::Verbose );
  61
  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 );
  66
  67 /**
  68  * Prints out all the children of the given actor when debug is enabled.
  69  *
  70  * @param[in]  actor  The actor whose children to print.
  71  * @param[in]  level  The number of " | " to put in front of the children.
  72  */
  73 void PrintChildren( Dali::Actor actor, int level )
  74 {
  75   std::ostringstream output;
  76
  77   for ( int t = 0; t < level; ++t )
  78   {
  79     output << " | ";
  80   }
  81
  82   output << actor.GetName() << "(" << actor.GetTypeName() << ", " << actor.GetObjectPtr() << ")";
  83
  84   if ( HIERARCHY_GEOMETRY )
  85   {
  86     output << " Pos: " << actor.GetCurrentWorldPosition() << " Size: " << actor.GetCurrentSize() << " Scale: " << actor.GetCurrentWorldScale();
  87   }
  88
  89   if ( HIERARCHY_SENSITIVITY )
  90   {
  91     output << " Sensitivity: " << ( IsActuallySensitive( &GetImplementation( actor ) ) ? "True " : "False " );
  92   }
  93
  94   if ( HIERARCHY_TOUCH_REQUIRED )
  95   {
  96     output << " TouchRequired: " << ( GetImplementation(actor).GetTouchRequired() ? "True " : "False " );
  97   }
  98
  99   if ( HIERARCHY_HITTABLE )
 100   {
 101     output << " Hittable: " << ( GetImplementation(actor).IsHittable() ? "True " : "False " );
 102   }
 103
 104   output << std::endl;
 105
 106   DALI_LOG_INFO( gLogFilter, HIERARCHY_DEBUG_LOG_LEVEL, output.str().c_str() );
 107
 108   ++level;
 109   unsigned int numChildren=actor.GetChildCount();
 110   for ( unsigned int i=0; i<numChildren; ++i )
 111   {
 112     PrintChildren( actor.GetChildAt(i), level );
 113   }
 114   --level;
 115 }
 116
 117 /**
 118  * Prints the entire hierarchy of the scene.
 119  */
 120 void PrintHierarchy()
 121 {
 122   if ( gLogFilter->IsEnabledFor( HIERARCHY_DEBUG_LOG_LEVEL ) )
 123   {
 124     PrintChildren( Dali::Stage().GetCurrent().GetRootLayer(), 0 );
 125   }
 126 }
 127
 128 #define PRINT_HIERARCHY PrintHierarchy()
 129
 130 #else // defined(DEBUG_ENABLED)
 131
 132 #define PRINT_HIERARCHY
 133
 134 #endif // defined(DEBUG_ENABLED)
 135
 136 /**
 137  *  Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
 138  */
 139 Dali::Actor EmitTouchSignals( Dali::Actor actor, const TouchEvent& event )
 140 {
 141   Dali::Actor consumedActor;
 142
 143   if ( actor )
 144   {
 145     Dali::Actor oldParent( actor.GetParent() );
 146
 147     Actor& actorImpl( GetImplementation(actor) );
 148
 149     bool consumed( false );
 150
 151     // Only emit the signal if the actor's touch signal has connections (or derived actor implementation requires touch).
 152     if ( actorImpl.GetTouchRequired() )
 153     {
 154       consumed = actorImpl.EmitTouchEventSignal( event );
 155     }
 156
 157     if ( consumed )
 158     {
 159       // One of this actor's listeners has consumed the event so set this actor as the consumed actor.
 160       consumedActor = Dali::Actor( &actorImpl );
 161     }
 162     else
 163     {
 164       // The actor may have been removed/reparented during the signal callbacks.
 165       Dali::Actor parent = actor.GetParent();
 166
 167       if ( parent &&
 168            (parent == oldParent) )
 169       {
 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 );
 172       }
 173     }
 174   }
 175
 176   return consumedActor;
 177 }
 178
 179 /**
 180  * Changes the state of the primary point to leave and emits the touch signals
 181  */
 182 Dali::Actor EmitTouchSignals( Actor* actor, RenderTask& renderTask, const TouchEvent& originalEvent, TouchPoint::State state )
 183 {
 184   TouchEvent touchEvent( originalEvent );
 185
 186   DALI_ASSERT_DEBUG( NULL != actor && "NULL actor pointer" );
 187   if( actor )
 188   {
 189     TouchPoint& primaryPoint = touchEvent.points[0];
 190
 191     actor->ScreenToLocal( renderTask, primaryPoint.local.x, primaryPoint.local.y, primaryPoint.screen.x, primaryPoint.screen.y );
 192
 193     primaryPoint.hitActor = Dali::Actor(actor);
 194     primaryPoint.state = state;
 195   }
 196
 197   return EmitTouchSignals( Dali::Actor(actor), touchEvent );
 198 }
 199
 200 /**
 201  * In the hit test algorithm above we do not descend actor tree if it is insensitive, so here, we
 202  * should also check if any of the actor's parents has become insensitive since we last processed
 203  * it.
 204  */
 205 bool IsActuallySensitive( Actor* actor )
 206 {
 207   bool sensitive = true;
 208
 209   while ( actor && sensitive )
 210   {
 211     sensitive = actor->IsSensitive();
 212     actor = actor->GetParent();
 213   }
 214
 215   return sensitive;
 216 }
 217
 218 } // unnamed namespace
 219
 220 TouchEventProcessor::TouchEventProcessor( Stage& stage )
 221 : mStage( stage ),
 222   mLastPrimaryHitActor(),
 223   mLastConsumedActor(),
 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 void TouchEventProcessor::ProcessTouchEvent( const Integration::TouchEvent& event )
 236 {
 237   DALI_LOG_TRACE_METHOD( gLogFilter );
 238
 239   DALI_ASSERT_ALWAYS( !event.points.empty() && "Empty TouchEvent sent from Integration\n" );
 240
 241   Stage& stage = mStage;
 242
 243   PRINT_HIERARCHY;
 244
 245   // Copy so we can add the results of a hit-test.
 246   TouchEvent touchEvent( event.time );
 247
 248   // 1) Check if it is an interrupted event - we should inform our last primary hit actor about this
 249   //    and emit the stage signal as well.
 250
 251   if ( event.points[0].state == TouchPoint::Interrupted )
 252   {
 253     Dali::Actor consumingActor;
 254     touchEvent.points.push_back(event.points[0]);
 255
 256     Actor* lastPrimaryHitActor( mLastPrimaryHitActor.GetActor() );
 257     if ( lastPrimaryHitActor )
 258     {
 259       Dali::Actor lastPrimaryHitActorHandle( lastPrimaryHitActor );
 260       touchEvent.points[0].hitActor = lastPrimaryHitActorHandle;
 261       consumingActor = EmitTouchSignals( lastPrimaryHitActorHandle, touchEvent );
 262     }
 263
 264     // If the last consumed actor was different to the primary hit actor then inform it as well (if it has not already been informed).
 265     Actor* lastConsumedActor( mLastConsumedActor.GetActor() );
 266     if ( lastConsumedActor &&
 267          lastConsumedActor != lastPrimaryHitActor &&
 268          lastConsumedActor != consumingActor )
 269     {
 270       Dali::Actor lastConsumedActorHandle( lastConsumedActor );
 271       touchEvent.points[0].hitActor = lastConsumedActorHandle;
 272       EmitTouchSignals( lastConsumedActorHandle, touchEvent );
 273     }
 274
 275     // Tell the touch-down consuming actor as well, if required
 276     Actor* touchDownConsumedActor( mTouchDownConsumedActor.GetActor() );
 277     if ( touchDownConsumedActor &&
 278          touchDownConsumedActor != lastPrimaryHitActor &&
 279          touchDownConsumedActor != lastConsumedActor &&
 280          touchDownConsumedActor != consumingActor )
 281     {
 282       Dali::Actor touchDownConsumedActorHandle( touchDownConsumedActor );
 283       touchEvent.points[0].hitActor = touchDownConsumedActorHandle;
 284       EmitTouchSignals( touchDownConsumedActorHandle, touchEvent );
 285     }
 286
 287     mLastPrimaryHitActor.SetActor( NULL );
 288     mLastConsumedActor.SetActor( NULL );
 289     mTouchDownConsumedActor.SetActor( NULL );
 290     mLastRenderTask.Reset();
 291
 292     touchEvent.points[0].hitActor = NULL;
 293     mStage.EmitTouchedSignal( touchEvent );
 294
 295     return; // No need for hit testing
 296   }
 297
 298   // 2) Hit Testing.
 299
 300   DALI_LOG_INFO( gLogFilter, Debug::Concise, "\n" );
 301   DALI_LOG_INFO( gLogFilter, Debug::General, "Point(s): %d\n", event.GetPointCount() );
 302
 303   Dali::RenderTask currentRenderTask;
 304
 305   for ( TouchPointContainerConstIterator iter = event.points.begin(), beginIter = event.points.begin(), endIter = event.points.end(); iter != endIter; ++iter )
 306   {
 307     HitTestAlgorithm::Results hitTestResults;
 308     HitTestAlgorithm::HitTest( stage, iter->screen, hitTestResults );
 309
 310     TouchPoint newPoint( iter->deviceId, iter->state, iter->screen.x, iter->screen.y );
 311     newPoint.hitActor = hitTestResults.actor;
 312     newPoint.local = hitTestResults.actorCoordinates;
 313
 314     touchEvent.points.push_back( newPoint );
 315
 316     DALI_LOG_INFO( gLogFilter, Debug::General, "  State(%s), Screen(%.0f, %.0f), HitActor(%p, %s), Local(%.2f, %.2f)\n",
 317                    TOUCH_POINT_STATE[iter->state], iter->screen.x, iter->screen.y,
 318                    ( hitTestResults.actor ? (void*)&hitTestResults.actor.GetBaseObject() : NULL ),
 319                    ( hitTestResults.actor ? hitTestResults.actor.GetName().c_str() : "" ),
 320                    hitTestResults.actorCoordinates.x, hitTestResults.actorCoordinates.y );
 321
 322     // Only set the currentRenderTask for the primary hit actor.
 323     if ( iter == beginIter && hitTestResults.renderTask )
 324     {
 325       currentRenderTask = hitTestResults.renderTask;
 326     }
 327   }
 328
 329   // 3) Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
 330
 331   // Emit the touch signal
 332   Dali::Actor consumedActor;
 333   if ( currentRenderTask )
 334   {
 335     consumedActor = EmitTouchSignals( touchEvent.points[0].hitActor, touchEvent );
 336   }
 337
 338   TouchPoint& primaryPoint = touchEvent.points[0];
 339   Dali::Actor primaryHitActor = primaryPoint.hitActor;
 340   TouchPoint::State primaryPointState = primaryPoint.state;
 341
 342   DALI_LOG_INFO( gLogFilter, Debug::Concise, "PrimaryHitActor:     (%p) %s\n", primaryPoint.hitActor ? (void*)&primaryPoint.hitActor.GetBaseObject() : NULL, primaryPoint.hitActor ? primaryPoint.hitActor.GetName().c_str() : "" );
 343   DALI_LOG_INFO( gLogFilter, Debug::Concise, "ConsumedActor:       (%p) %s\n", consumedActor ? (void*)&consumedActor.GetBaseObject() : NULL, consumedActor ? consumedActor.GetName().c_str() : "" );
 344
 345   if ( ( primaryPointState == TouchPoint::Down ) &&
 346        ( touchEvent.GetPointCount() == 1 ) &&
 347        ( consumedActor && consumedActor.OnStage() ) )
 348   {
 349     mTouchDownConsumedActor.SetActor( &GetImplementation( consumedActor ) );
 350   }
 351
 352   // 4) Check if the last primary hit actor requires a leave event and if it was different to the current primary
 353   //    hit actor.  Also process the last consumed actor in the same manner.
 354
 355   Actor* lastPrimaryHitActor( mLastPrimaryHitActor.GetActor() );
 356   Actor* lastConsumedActor( mLastConsumedActor.GetActor() );
 357   if( (primaryPointState == TouchPoint::Motion) || (primaryPointState == TouchPoint::Up) || (primaryPointState == TouchPoint::Stationary) )
 358   {
 359     if ( mLastRenderTask )
 360     {
 361       Dali::Actor leaveEventConsumer;
 362       RenderTask& lastRenderTaskImpl( GetImplementation( mLastRenderTask ) );
 363
 364       if( lastPrimaryHitActor &&
 365           lastPrimaryHitActor != primaryHitActor &&
 366           lastPrimaryHitActor != consumedActor )
 367       {
 368         if( lastPrimaryHitActor->IsHittable() && IsActuallySensitive( lastPrimaryHitActor ) )
 369         {
 370           if ( lastPrimaryHitActor->GetLeaveRequired() )
 371           {
 372             DALI_LOG_INFO( gLogFilter, Debug::Concise, "LeaveActor(Hit):     (%p) %s\n", (void*)lastPrimaryHitActor, lastPrimaryHitActor->GetName().c_str() );
 373             leaveEventConsumer = EmitTouchSignals( mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEvent, TouchPoint::Leave );
 374           }
 375         }
 376         else
 377         {
 378           // At this point mLastPrimaryHitActor was touchable and sensitive in the previous touch event process but is not in the current one.
 379           // An interrupted event is send to allow some actors to go back to their original state (i.e. Button controls)
 380           DALI_LOG_INFO( gLogFilter, Debug::Concise, "InterruptedActor(Hit):     (%p) %s\n", (void*)lastPrimaryHitActor, lastPrimaryHitActor->GetName().c_str() );
 381           leaveEventConsumer = EmitTouchSignals( mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEvent, TouchPoint::Interrupted );
 382         }
 383       }
 384
 385       // Check if the motion event has been consumed by another actor's listener.  In this case, the previously
 386       // consumed actor's listeners may need to be informed (through a leave event).
 387       // Further checks here to ensure we do not signal the same actor twice for the same event.
 388       if ( lastConsumedActor &&
 389            lastConsumedActor != consumedActor &&
 390            lastConsumedActor != lastPrimaryHitActor &&
 391            lastConsumedActor != primaryHitActor &&
 392            lastConsumedActor != leaveEventConsumer )
 393       {
 394         if( lastConsumedActor->IsHittable() && IsActuallySensitive( lastConsumedActor ) )
 395         {
 396           if( lastConsumedActor->GetLeaveRequired() )
 397           {
 398             DALI_LOG_INFO( gLogFilter, Debug::Concise, "LeaveActor(Consume): (%p) %s\n", (void*)lastConsumedActor, lastConsumedActor->GetName().c_str() );
 399             EmitTouchSignals( lastConsumedActor, lastRenderTaskImpl, touchEvent, TouchPoint::Leave );
 400           }
 401         }
 402         else
 403         {
 404           // At this point mLastConsumedActor was touchable and sensitive in the previous touch event process but is not in the current one.
 405           // An interrupted event is send to allow some actors to go back to their original state (i.e. Button controls)
 406           DALI_LOG_INFO( gLogFilter, Debug::Concise, "InterruptedActor(Consume):     (%p) %s\n", (void*)lastConsumedActor, lastConsumedActor->GetName().c_str() );
 407           EmitTouchSignals( mLastConsumedActor.GetActor(), lastRenderTaskImpl, touchEvent, TouchPoint::Interrupted );
 408         }
 409       }
 410     }
 411   }
 412
 413   // 5) If our primary point is an Up event, then the primary point (in multi-touch) will change next
 414   //    time so set our last primary actor to NULL.  Do the same to the last consumed actor as well.
 415
 416   if ( primaryPointState == TouchPoint::Up )
 417   {
 418     mLastPrimaryHitActor.SetActor( NULL );
 419     mLastConsumedActor.SetActor( NULL );
 420     mLastRenderTask.Reset();
 421   }
 422   else
 423   {
 424     // The primaryHitActor may have been removed from the stage so ensure it is still on the stage before setting members.
 425     if ( primaryHitActor && primaryHitActor.OnStage() )
 426     {
 427       mLastPrimaryHitActor.SetActor( &GetImplementation( primaryHitActor ) );
 428
 429       // Only observe the consumed actor if we have a primaryHitActor (check if it is still on stage).
 430       if ( consumedActor && consumedActor.OnStage() )
 431       {
 432         mLastConsumedActor.SetActor( &GetImplementation( consumedActor ) );
 433       }
 434       else
 435       {
 436         mLastConsumedActor.SetActor( NULL );
 437       }
 438
 439       mLastRenderTask = currentRenderTask;
 440     }
 441     else
 442     {
 443       mLastPrimaryHitActor.SetActor( NULL );
 444       mLastConsumedActor.SetActor( NULL );
 445       mLastRenderTask.Reset();
 446     }
 447   }
 448
 449   // 6) Emit an interrupted event to the touch-down actor if it hasn't consumed the up and
 450   //    emit the stage touched event if required.
 451
 452   if ( touchEvent.GetPointCount() == 1 ) // Only want the first touch and the last release
 453   {
 454     switch ( primaryPointState )
 455     {
 456       case TouchPoint::Up:
 457       {
 458         Actor* touchDownConsumedActor( mTouchDownConsumedActor.GetActor() );
 459         if ( touchDownConsumedActor &&
 460              touchDownConsumedActor != consumedActor &&
 461              touchDownConsumedActor != lastPrimaryHitActor &&
 462              touchDownConsumedActor != lastConsumedActor )
 463         {
 464           Dali::Actor touchDownConsumedActorHandle( touchDownConsumedActor );
 465           touchEvent.points[0].hitActor = touchDownConsumedActorHandle;
 466           touchEvent.points[0].state = TouchPoint::Interrupted;
 467           EmitTouchSignals( touchDownConsumedActorHandle, touchEvent );
 468
 469           // Restore touch-event to original state
 470           touchEvent.points[0].hitActor = primaryHitActor;
 471           touchEvent.points[0].state = primaryPointState;
 472         }
 473
 474         mTouchDownConsumedActor.SetActor( NULL );
 475       }
 476       // No break, Fallthrough
 477
 478       case TouchPoint::Down:
 479       {
 480         mStage.EmitTouchedSignal( touchEvent );
 481         break;
 482       }
 483
 484       case TouchPoint::Motion:
 485       case TouchPoint::Leave:
 486       case TouchPoint::Stationary:
 487       case TouchPoint::Interrupted:
 488       case TouchPoint::Last:
 489       {
 490         // Ignore
 491         break;
 492       }
 493     }
 494   }
 495 }
 496
 497 TouchEventProcessor::ActorObserver::ActorObserver()
 498 : mActor ( NULL ),
 499   mActorDisconnected(false)
 500 {
 501   DALI_LOG_TRACE_METHOD( gLogFilter );
 502 }
 503
 504 TouchEventProcessor::ActorObserver::~ActorObserver()
 505 {
 506   DALI_LOG_TRACE_METHOD( gLogFilter );
 507   SetActor( NULL );
 508 }
 509
 510 Actor* TouchEventProcessor::ActorObserver::GetActor()
 511 {
 512   return mActorDisconnected ? NULL : mActor;
 513 }
 514
 515 void TouchEventProcessor::ActorObserver::SetActor( Actor* actor )
 516 {
 517   DALI_LOG_TRACE_METHOD( gLogFilter );
 518
 519   if ( mActor != actor )
 520   {
 521     ResetActor();
 522
 523     mActor = actor;
 524
 525     if ( mActor )
 526     {
 527       mActor->AddObserver( *this );
 528       DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Start Observing:            %p\n", mActor);
 529     }
 530   }
 531
 532   // Make sure this flag is unset (as we may have been disconnected if it's the same actor)
 533   mActorDisconnected = false;
 534 }
 535
 536 void TouchEventProcessor::ActorObserver::ResetActor()
 537 {
 538   if ( mActor )
 539   {
 540     DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Stop Observing:             %p\n", mActor);
 541     mActor->RemoveObserver( *this );
 542     mActor = NULL;
 543     mActorDisconnected = false;
 544   }
 545 }
 546
 547 void TouchEventProcessor::ActorObserver::SceneObjectRemoved( ProxyObject& proxy )
 548 {
 549   DALI_LOG_TRACE_METHOD( gLogFilter );
 550
 551   if ( mActor == &proxy )
 552   {
 553     // do not call proxy.RemoveObserver here, proxy is currently iterating through observers... you wouldnt want to upset proxy now would you?
 554     mActorDisconnected = true;
 555   }
 556 }
 557
 558 void TouchEventProcessor::ActorObserver::ProxyDestroyed(ProxyObject& proxy)
 559 {
 560   DALI_LOG_TRACE_METHOD( gLogFilter );
 561
 562   if ( mActor == &proxy )
 563   {
 564     DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Stop Observing:             %p\n", mActor);
 565     mActor = NULL;
 566   }
 567 }
 568
 569 } // namespace Internal
 570
 571 } // namespace Dali