2 * Copyright (c) 2022 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/integration-api/debug.h>
27 #include <dali/integration-api/events/touch-event-integ.h>
28 #include <dali/internal/event/actors/actor-impl.h>
29 #include <dali/internal/event/actors/layer-impl.h>
30 #include <dali/internal/event/common/scene-impl.h>
31 #include <dali/internal/event/events/hit-test-algorithm-impl.h>
32 #include <dali/internal/event/events/multi-point-event-util.h>
33 #include <dali/internal/event/events/touch-event-impl.h>
34 #include <dali/internal/event/render-tasks/render-task-impl.h>
35 #include <dali/public-api/events/touch-event.h>
36 #include <dali/public-api/math/vector2.h>
37 #include <dali/public-api/signals/callback.h>
45 #if defined(DEBUG_ENABLED)
46 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_TOUCH_PROCESSOR");
48 const char* TOUCH_POINT_STATE[6] =
58 #endif // defined(DEBUG_ENABLED)
60 Dali::Actor EmitInterceptTouchSignals(Dali::Actor actor, const Dali::TouchEvent& touchEvent)
62 Dali::Actor interceptedActor;
66 Dali::Actor parent = actor.GetParent();
69 // Recursively deliver events to the actor and its parents for intercept touch event.
70 interceptedActor = EmitInterceptTouchSignals(parent, touchEvent);
75 bool intercepted = false;
76 Actor& actorImpl(GetImplementation(actor));
77 if(actorImpl.GetInterceptTouchRequired())
79 intercepted = actorImpl.EmitInterceptTouchEventSignal(touchEvent);
82 interceptedActor = Dali::Actor(&actorImpl);
88 return interceptedActor;
92 * Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
94 Dali::Actor EmitTouchSignals(Dali::Actor actor, const Dali::TouchEvent& touchEvent)
96 Dali::Actor consumedActor;
100 Dali::Actor oldParent(actor.GetParent());
102 Actor& actorImpl(GetImplementation(actor));
104 bool consumed(false);
106 // Only emit the signal if the actor's touch signal has connections (or derived actor implementation requires touch).
107 if(actorImpl.GetTouchRequired())
109 consumed = actorImpl.EmitTouchEventSignal(touchEvent);
114 // One of this actor's listeners has consumed the event so set this actor as the consumed actor.
115 consumedActor = Dali::Actor(&actorImpl);
119 // The actor may have been removed/reparented during the signal callbacks.
120 Dali::Actor parent = actor.GetParent();
123 (parent == oldParent))
125 // One of the actor's parents may consumed the event and they should be set as the consumed actor.
126 consumedActor = EmitTouchSignals(parent, touchEvent);
131 return consumedActor;
134 Dali::Actor AllocAndEmitTouchSignals(unsigned long time, Dali::Actor actor, const Integration::Point& point)
136 TouchEventPtr touchEvent(new TouchEvent(time));
137 Dali::TouchEvent touchEventHandle(touchEvent.Get());
139 touchEvent->AddPoint(point);
141 return EmitTouchSignals(actor, touchEventHandle);
145 * Changes the state of the primary point to leave and emits the touch signals
147 Dali::Actor EmitTouchSignals(Actor* actor, RenderTask& renderTask, const TouchEventPtr& originalTouchEvent, PointState::Type state)
149 Dali::Actor consumingActor;
153 TouchEventPtr touchEventImpl = TouchEvent::Clone(*originalTouchEvent.Get());
155 Integration::Point& primaryPoint = touchEventImpl->GetPoint(0);
157 const Vector2& screenPosition = primaryPoint.GetScreenPosition();
158 Vector2 localPosition;
159 actor->ScreenToLocal(renderTask, localPosition.x, localPosition.y, screenPosition.x, screenPosition.y);
161 primaryPoint.SetLocalPosition(localPosition);
162 primaryPoint.SetHitActor(Dali::Actor(actor));
163 primaryPoint.SetState(state);
165 consumingActor = EmitTouchSignals(Dali::Actor(actor), Dali::TouchEvent(touchEventImpl.Get()));
168 return consumingActor;
172 * @brief Parses the primary touch point by performing a hit-test if necessary
174 * @param[out] hitTestResults The hit test results are put into this variable
175 * @param[in/out] capturingTouchActorObserver The observer for the capturing touch actor member
176 * @param[in] lastRenderTask The last render task member
177 * @param[in] currentPoint The current point information
178 * @param[in] scene The scene that this touch is related to
180 void ParsePrimaryTouchPoint(
181 HitTestAlgorithm::Results& hitTestResults,
182 ActorObserver& capturingTouchActorObserver,
183 ActorObserver& ownTouchActorObserver,
184 const RenderTaskPtr& lastRenderTask,
185 const Integration::Point& currentPoint,
186 const Internal::Scene& scene)
188 Actor* capturingTouchActor = capturingTouchActorObserver.GetActor();
190 // We only set the capturing touch actor when the first touch-started actor captures all touch so if it's set, just use it
191 if(capturingTouchActor && lastRenderTask)
193 hitTestResults.actor = Dali::Actor(capturingTouchActor);
194 hitTestResults.renderTask = lastRenderTask;
195 const Vector2& screenPosition = currentPoint.GetScreenPosition();
196 capturingTouchActor->ScreenToLocal(*lastRenderTask, hitTestResults.actorCoordinates.x, hitTestResults.actorCoordinates.y, screenPosition.x, screenPosition.y);
200 Actor* ownTouchActor = ownTouchActorObserver.GetActor();
201 HitTestAlgorithm::HitTest(scene.GetSize(), scene.GetRenderTaskList(), scene.GetLayerList(), currentPoint.GetScreenPosition(), hitTestResults, ownTouchActor);
203 if(currentPoint.GetState() == PointState::STARTED && hitTestResults.actor)
205 // If we've just started touch, then check whether the actor has requested to capture all touch events
206 Actor* hitActor = &GetImplementation(hitTestResults.actor);
207 if(hitActor->CapturesAllTouchAfterStart())
209 capturingTouchActorObserver.SetActor(hitActor);
211 if(hitActor->IsAllowedOnlyOwnTouch())
213 ownTouchActorObserver.SetActor(hitActor);
219 } // unnamed namespace
221 TouchEventProcessor::TouchEventProcessor(Scene& scene)
223 mLastPrimaryHitActor(MakeCallback(this, &TouchEventProcessor::OnObservedActorDisconnected)),
224 mLastConsumedActor(),
225 mCapturingTouchActor(),
227 mTouchDownConsumedActor(),
229 mLastPrimaryPointState(PointState::FINISHED)
231 DALI_LOG_TRACE_METHOD(gLogFilter);
234 TouchEventProcessor::~TouchEventProcessor()
236 DALI_LOG_TRACE_METHOD(gLogFilter);
239 void TouchEventProcessor::Clear()
241 mLastPrimaryHitActor.SetActor(nullptr);
242 mLastConsumedActor.SetActor(nullptr);
243 mCapturingTouchActor.SetActor(nullptr);
244 mOwnTouchActor.SetActor(nullptr);
245 mLastRenderTask.Reset();
246 mLastPrimaryPointState = PointState::FINISHED;
249 bool TouchEventProcessor::ProcessTouchEvent(const Integration::TouchEvent& event)
251 DALI_LOG_TRACE_METHOD(gLogFilter);
252 DALI_ASSERT_ALWAYS(!event.points.empty() && "Empty TouchEvent sent from Integration\n");
254 PRINT_HIERARCHY(gLogFilter);
256 // 1) Check if it is an interrupted event - we should inform our last primary hit actor about this
257 // and emit the stage signal as well.
259 if(event.points[0].GetState() == PointState::INTERRUPTED)
261 Dali::Actor consumingActor;
262 Integration::Point currentPoint(event.points[0]);
264 Actor* lastPrimaryHitActor(mLastPrimaryHitActor.GetActor());
265 if(lastPrimaryHitActor)
267 Dali::Actor lastPrimaryHitActorHandle(lastPrimaryHitActor);
268 currentPoint.SetHitActor(lastPrimaryHitActorHandle);
270 consumingActor = AllocAndEmitTouchSignals(event.time, lastPrimaryHitActorHandle, currentPoint);
273 // If the last consumed actor was different to the primary hit actor then inform it as well (if it has not already been informed).
274 Actor* lastConsumedActor(mLastConsumedActor.GetActor());
275 if(lastConsumedActor &&
276 lastConsumedActor != lastPrimaryHitActor &&
277 lastConsumedActor != consumingActor)
279 Dali::Actor lastConsumedActorHandle(lastConsumedActor);
280 currentPoint.SetHitActor(lastConsumedActorHandle);
281 AllocAndEmitTouchSignals(event.time, lastConsumedActorHandle, currentPoint);
284 // Tell the touch-down consuming actor as well, if required
285 Actor* touchDownConsumedActor(mTouchDownConsumedActor.GetActor());
286 if(touchDownConsumedActor &&
287 touchDownConsumedActor != lastPrimaryHitActor &&
288 touchDownConsumedActor != lastConsumedActor &&
289 touchDownConsumedActor != consumingActor)
291 Dali::Actor touchDownConsumedActorHandle(touchDownConsumedActor);
293 currentPoint.SetHitActor(touchDownConsumedActorHandle);
294 AllocAndEmitTouchSignals(event.time, touchDownConsumedActorHandle, currentPoint);
298 mTouchDownConsumedActor.SetActor(nullptr);
300 currentPoint.SetHitActor(Dali::Actor());
302 TouchEventPtr touchEventImpl(new TouchEvent(event.time));
303 Dali::TouchEvent touchEventHandle(touchEventImpl.Get());
305 touchEventImpl->AddPoint(currentPoint);
307 mScene.EmitTouchedSignal(touchEventHandle);
308 return false; // No need for hit testing & already an interrupted event so just return false
312 TouchEventPtr touchEventImpl(new TouchEvent(event.time));
313 Dali::TouchEvent touchEventHandle(touchEventImpl.Get());
315 DALI_LOG_INFO(gLogFilter, Debug::Concise, "\n");
316 DALI_LOG_INFO(gLogFilter, Debug::General, "Point(s): %d\n", event.GetPointCount());
318 RenderTaskPtr currentRenderTask;
319 bool firstPointParsed = false;
321 for(auto&& currentPoint : event.points)
323 HitTestAlgorithm::Results hitTestResults;
324 hitTestResults.point = currentPoint;
325 hitTestResults.eventTime = event.time;
326 if(!firstPointParsed)
328 firstPointParsed = true;
329 ParsePrimaryTouchPoint(hitTestResults, mCapturingTouchActor, mOwnTouchActor, mLastRenderTask, currentPoint, mScene);
331 // Only set the currentRenderTask for the primary hit actor.
332 currentRenderTask = hitTestResults.renderTask;
336 HitTestAlgorithm::HitTest(mScene.GetSize(), mScene.GetRenderTaskList(), mScene.GetLayerList(), currentPoint.GetScreenPosition(), hitTestResults);
339 Integration::Point newPoint(currentPoint);
340 newPoint.SetHitActor(hitTestResults.actor);
341 newPoint.SetLocalPosition(hitTestResults.actorCoordinates);
343 touchEventImpl->AddPoint(newPoint);
345 DALI_LOG_INFO(gLogFilter, Debug::General, " State(%s), Screen(%.0f, %.0f), HitActor(%p, %s), Local(%.2f, %.2f)\n", TOUCH_POINT_STATE[currentPoint.GetState()], currentPoint.GetScreenPosition().x, currentPoint.GetScreenPosition().y, (hitTestResults.actor ? reinterpret_cast<void*>(&hitTestResults.actor.GetBaseObject()) : NULL), (hitTestResults.actor ? hitTestResults.actor.GetProperty<std::string>(Dali::Actor::Property::NAME).c_str() : ""), hitTestResults.actorCoordinates.x, hitTestResults.actorCoordinates.y);
348 // 3) Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
350 bool consumed = false;
352 // Emit the touch signal
353 Dali::Actor consumedActor;
355 Integration::Point& primaryPoint = touchEventImpl->GetPoint(0);
356 Dali::Actor primaryHitActor = primaryPoint.GetHitActor();
357 PointState::Type primaryPointState = primaryPoint.GetState();
359 if(currentRenderTask)
361 // Emit the intercept touch signal
362 Dali::Actor interceptedActor = EmitInterceptTouchSignals(primaryHitActor, touchEventHandle);
365 // If the child is being touched, INTERRUPTED is sent.
366 if(mLastPrimaryHitActor.GetActor() &&
367 mLastPrimaryHitActor.GetActor() != interceptedActor &&
369 mLastPrimaryPointState != PointState::FINISHED)
371 EmitTouchSignals(mLastPrimaryHitActor.GetActor(), *mLastRenderTask.Get(), touchEventImpl, PointState::INTERRUPTED);
374 consumedActor = EmitTouchSignals(interceptedActor, touchEventHandle);
378 consumedActor = EmitTouchSignals(primaryHitActor, touchEventHandle);
380 consumed = consumedActor ? true : false;
383 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() : "");
384 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() : "");
386 if((primaryPointState == PointState::DOWN) &&
387 (touchEventImpl->GetPointCount() == 1) &&
388 (consumedActor && consumedActor.GetProperty<bool>(Dali::Actor::Property::CONNECTED_TO_SCENE)))
390 mTouchDownConsumedActor.SetActor(&GetImplementation(consumedActor));
393 // 4) Check if the last primary hit actor requires a leave event and if it was different to the current primary
394 // hit actor. Also process the last consumed actor in the same manner.
396 Actor* lastPrimaryHitActor(mLastPrimaryHitActor.GetActor());
397 Actor* lastConsumedActor(mLastConsumedActor.GetActor());
398 if((primaryPointState == PointState::MOTION) || (primaryPointState == PointState::UP) || (primaryPointState == PointState::STATIONARY))
402 Dali::Actor leaveEventConsumer;
403 RenderTask& lastRenderTaskImpl = *mLastRenderTask.Get();
405 if(lastPrimaryHitActor &&
406 lastPrimaryHitActor != primaryHitActor &&
407 lastPrimaryHitActor != consumedActor)
409 if(lastPrimaryHitActor->IsHittable() && IsActuallySensitive(lastPrimaryHitActor))
411 if(lastPrimaryHitActor->GetLeaveRequired())
413 DALI_LOG_INFO(gLogFilter, Debug::Concise, "LeaveActor(Hit): (%p) %s\n", reinterpret_cast<void*>(lastPrimaryHitActor), lastPrimaryHitActor->GetName().data());
414 leaveEventConsumer = EmitTouchSignals(mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEventImpl, PointState::LEAVE);
419 // At this point mLastPrimaryHitActor was touchable and sensitive in the previous touch event process but is not in the current one.
420 // An interrupted event is send to allow some actors to go back to their original state (i.e. Button controls)
421 DALI_LOG_INFO(gLogFilter, Debug::Concise, "InterruptedActor(Hit): (%p) %s\n", reinterpret_cast<void*>(lastPrimaryHitActor), lastPrimaryHitActor->GetName().data());
422 leaveEventConsumer = EmitTouchSignals(mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEventImpl, PointState::INTERRUPTED);
426 consumed |= leaveEventConsumer ? true : false;
428 // Check if the motion event has been consumed by another actor's listener. In this case, the previously
429 // consumed actor's listeners may need to be informed (through a leave event).
430 // Further checks here to ensure we do not signal the same actor twice for the same event.
431 if(lastConsumedActor &&
432 lastConsumedActor != consumedActor &&
433 lastConsumedActor != lastPrimaryHitActor &&
434 lastConsumedActor != primaryHitActor &&
435 lastConsumedActor != leaveEventConsumer)
437 if(lastConsumedActor->IsHittable() && IsActuallySensitive(lastConsumedActor))
439 if(lastConsumedActor->GetLeaveRequired())
441 DALI_LOG_INFO(gLogFilter, Debug::Concise, "LeaveActor(Consume): (%p) %s\n", reinterpret_cast<void*>(lastConsumedActor), lastConsumedActor->GetName().data());
442 EmitTouchSignals(lastConsumedActor, lastRenderTaskImpl, touchEventImpl, PointState::LEAVE);
447 // At this point mLastConsumedActor was touchable and sensitive in the previous touch event process but is not in the current one.
448 // An interrupted event is send to allow some actors to go back to their original state (i.e. Button controls)
449 DALI_LOG_INFO(gLogFilter, Debug::Concise, "InterruptedActor(Consume): (%p) %s\n", reinterpret_cast<void*>(lastConsumedActor), lastConsumedActor->GetName().data());
450 EmitTouchSignals(mLastConsumedActor.GetActor(), lastRenderTaskImpl, touchEventImpl, PointState::INTERRUPTED);
456 // 5) If our primary point is an Up event, then the primary point (in multi-touch) will change next
457 // time so set our last primary actor to NULL. Do the same to the last consumed actor as well.
458 if(primaryPointState == PointState::UP)
464 // The primaryHitActor may have been removed from the scene so ensure it is still on the scene before setting members.
465 if(primaryHitActor && GetImplementation(primaryHitActor).OnScene())
467 mLastPrimaryHitActor.SetActor(&GetImplementation(primaryHitActor));
469 // Only observe the consumed actor if we have a primaryHitActor (check if it is still on the scene).
470 if(consumedActor && GetImplementation(consumedActor).OnScene())
472 mLastConsumedActor.SetActor(&GetImplementation(consumedActor));
476 mLastConsumedActor.SetActor(nullptr);
479 mLastRenderTask = currentRenderTask;
480 mLastPrimaryPointState = primaryPointState;
488 // 6) Emit an interrupted event to the touch-down actor if it hasn't consumed the up and
489 // emit the stage touched event if required.
491 if(touchEventImpl->GetPointCount() == 1) // Only want the first touch and the last release
493 switch(primaryPointState)
497 Actor* touchDownConsumedActor(mTouchDownConsumedActor.GetActor());
498 if(touchDownConsumedActor &&
499 touchDownConsumedActor != consumedActor &&
500 touchDownConsumedActor != lastPrimaryHitActor &&
501 touchDownConsumedActor != lastConsumedActor)
503 Dali::Actor touchDownConsumedActorHandle(touchDownConsumedActor);
505 Integration::Point currentPoint = touchEventImpl->GetPoint(0);
506 currentPoint.SetHitActor(touchDownConsumedActorHandle);
507 currentPoint.SetState(PointState::INTERRUPTED);
509 AllocAndEmitTouchSignals(event.time, touchDownConsumedActorHandle, currentPoint);
512 mTouchDownConsumedActor.SetActor(nullptr);
517 case PointState::DOWN:
519 mScene.EmitTouchedSignal(touchEventHandle);
523 case PointState::MOTION:
524 case PointState::LEAVE:
525 case PointState::STATIONARY:
526 case PointState::INTERRUPTED:
537 void TouchEventProcessor::OnObservedActorDisconnected(Actor* actor)
539 if(actor == mLastPrimaryHitActor.GetActor())
541 Dali::Actor actorHandle(actor);
543 Integration::Point point;
544 point.SetState(PointState::INTERRUPTED);
545 point.SetHitActor(actorHandle);
547 TouchEventPtr touchEventImpl(new TouchEvent);
548 touchEventImpl->AddPoint(point);
549 Dali::TouchEvent touchEventHandle(touchEventImpl.Get());
551 Dali::Actor eventConsumer = EmitTouchSignals(actorHandle, touchEventHandle);
553 if(mLastConsumedActor.GetActor() != eventConsumer)
555 EmitTouchSignals(Dali::Actor(mLastConsumedActor.GetActor()), touchEventHandle);
558 // Do not set mLastPrimaryHitActor to NULL we may be iterating through its observers
560 mLastConsumedActor.SetActor(nullptr);
561 mLastRenderTask.Reset();
562 mLastPrimaryPointState = PointState::FINISHED;
566 } // namespace Internal