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.
18 #include <dali-test-suite-utils.h>
19 #include <dali/devel-api/actors/actor-devel.h>
20 #include <dali/integration-api/events/touch-event-integ.h>
21 #include <dali/integration-api/events/touch-integ.h>
22 #include <dali/integration-api/render-task-list-integ.h>
23 #include <dali/public-api/dali-core.h>
30 void utc_dali_touch_processing_startup(void)
32 test_return_value = TET_UNDEF;
35 void utc_dali_touch_processing_cleanup(void)
37 test_return_value = TET_PASS;
40 ///////////////////////////////////////////////////////////////////////////////
47 PointState::Type state{PointState::FINISHED};
52 Vector2 ellipseRadius;
55 Device::Class::Type deviceClass{Device::Class::NONE};
56 Device::Subclass::Type deviceSubclass{Device::Subclass::NONE};
58 TestPoint() = default;
59 static const TestPoint ZERO;
62 const TestPoint TestPoint::ZERO;
64 // Stores data that is populated in the callback and will be read by the TET cases
68 : functorCalled(false),
77 std::vector<TestPoint> points;
79 const TestPoint& GetPoint(size_t i)
85 return TestPoint::ZERO;
87 size_t GetPointCount()
95 functorCalled = false;
97 receivedTouch.time = 0u;
98 receivedTouch.points.clear();
100 touchedActor.Reset();
104 TestTouchEvent receivedTouch;
108 // Functor that sets the data when called
109 struct TouchEventFunctor
113 * @param[in] data Reference to the data to store callback information.
114 * @param[in] returnValue What the functor should return.
116 TouchEventFunctor(SignalData& data, bool returnValue = true)
118 returnValue(returnValue)
122 bool operator()(Actor actor, const TouchEvent& touch)
124 signalData.functorCalled = true;
125 signalData.touchedActor = actor;
127 signalData.receivedTouch.time = touch.GetTime();
128 signalData.receivedTouch.points.clear();
130 for(size_t i = 0; i < touch.GetPointCount(); ++i)
133 p.deviceId = touch.GetDeviceId(i);
134 p.state = touch.GetState(i);
135 p.hitActor = touch.GetHitActor(i);
136 p.local = touch.GetLocalPosition(i);
137 p.screen = touch.GetScreenPosition(i);
138 p.radius = touch.GetRadius(i);
139 p.ellipseRadius = touch.GetEllipseRadius(i);
140 p.pressure = touch.GetPressure(i);
141 p.angle = touch.GetAngle(i);
142 p.deviceClass = touch.GetDeviceClass(i);
143 p.deviceSubclass = touch.GetDeviceSubclass(i);
144 signalData.receivedTouch.points.push_back(p);
150 SignalData& signalData;
157 TouchEvent receivedTouchHandle;
160 : signalReceived(false)
165 struct TouchEventHandleFunctor
169 * @param[in] data Reference to the data to store callback information.
170 * @param[in] returnValue What the functor should return.
172 TouchEventHandleFunctor(HandleData& handleData, bool returnValue = true)
173 : handleData(handleData),
174 returnValue(returnValue)
178 bool operator()(Actor actor, const TouchEvent& someTouchEvent)
180 handleData.signalReceived = true;
181 handleData.receivedTouchHandle = someTouchEvent;
185 HandleData& handleData;
189 // Functor that removes the actor when called.
190 struct RemoveActorFunctor : public TouchEventFunctor
194 * @param[in] data Reference to the data to store callback information.
195 * @param[in] returnValue What the functor should return.
197 RemoveActorFunctor(SignalData& data, bool returnValue = true)
198 : TouchEventFunctor(data, returnValue)
202 bool operator()(Actor actor, const TouchEvent& touch)
204 Actor parent(actor.GetParent());
207 parent.Remove(actor);
210 return TouchEventFunctor::operator()(actor, touch);
214 struct OutOfBoundsData
220 : functorCalled(false)
225 // Functor that reads out of bounds data when called
226 struct OutOfBoundsFunctor
230 * @param[in] data Reference to the data to store callback information.
231 * @param[in] returnValue What the functor should return.
233 OutOfBoundsFunctor(OutOfBoundsData& data, bool returnValue = true)
234 : outOfBoundsData(data),
235 returnValue(returnValue)
239 bool operator()(Actor actor, const TouchEvent& touch)
241 outOfBoundsData.functorCalled = true;
242 size_t count = touch.GetPointCount();
244 // Read out of bounds data
245 outOfBoundsData.point.deviceId = touch.GetDeviceId(count + 1);
246 outOfBoundsData.point.state = touch.GetState(count + 1);
247 outOfBoundsData.point.hitActor = touch.GetHitActor(count + 1);
248 outOfBoundsData.point.local = touch.GetLocalPosition(count + 1);
249 outOfBoundsData.point.screen = touch.GetScreenPosition(count + 1);
254 OutOfBoundsData& outOfBoundsData;
258 Integration::TouchEvent GenerateSingleTouch(PointState::Type state, const Vector2& screenPosition)
260 Integration::TouchEvent touchEvent;
261 Integration::Point point;
262 point.SetState(state);
263 point.SetScreenPosition(screenPosition);
264 point.SetDeviceClass(Device::Class::TOUCH);
265 point.SetDeviceSubclass(Device::Subclass::NONE);
266 touchEvent.points.push_back(point);
272 ///////////////////////////////////////////////////////////////////////////////
274 int UtcDaliTouchEventNormalProcessing01(void)
276 TestApplication application;
278 Actor actor = Actor::New();
279 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
280 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
281 application.GetScene().Add(actor);
284 application.SendNotification();
285 application.Render();
287 // Connect to actor's touch signal
289 TouchEventFunctor functor(data);
290 actor.TouchedSignal().Connect(&application, functor);
292 Vector2 screenCoordinates(10.0f, 10.0f);
293 Vector2 localCoordinates;
294 actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
296 // Emit a down signal
297 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
298 const TestPoint* point1 = &data.receivedTouch.GetPoint(0);
299 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
300 DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION);
301 DALI_TEST_EQUALS(PointState::DOWN, point1->state, TEST_LOCATION);
302 DALI_TEST_EQUALS(screenCoordinates, point1->screen, TEST_LOCATION);
303 DALI_TEST_EQUALS(localCoordinates, point1->local, 0.1f, TEST_LOCATION);
306 // Emit a motion signal
307 screenCoordinates.x = screenCoordinates.y = 11.0f;
308 actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
309 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, screenCoordinates));
310 const TestPoint* point2 = &data.receivedTouch.GetPoint(0);
311 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
312 DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION);
313 DALI_TEST_EQUALS(PointState::MOTION, point2->state, TEST_LOCATION);
314 DALI_TEST_EQUALS(screenCoordinates, point2->screen, TEST_LOCATION);
315 DALI_TEST_EQUALS(localCoordinates, point2->local, 0.1f, TEST_LOCATION);
319 screenCoordinates.x = screenCoordinates.y = 12.0f;
320 actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
321 application.ProcessEvent(GenerateSingleTouch(PointState::UP, screenCoordinates));
322 const TestPoint* point3 = &data.receivedTouch.GetPoint(0);
323 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
324 DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION);
325 DALI_TEST_EQUALS(PointState::UP, point3->state, TEST_LOCATION);
326 DALI_TEST_EQUALS(screenCoordinates, point3->screen, TEST_LOCATION);
327 DALI_TEST_EQUALS(localCoordinates, point3->local, 0.1f, TEST_LOCATION);
330 // Emit a down signal where the actor is not present
331 screenCoordinates.x = screenCoordinates.y = 200.0f;
332 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
333 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
337 int UtcDaliTouchEventNormalProcessing02(void)
339 TestApplication application;
341 Actor actor = Actor::New();
342 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
343 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
344 application.GetScene().Add(actor);
347 application.SendNotification();
348 application.Render();
350 // Connect to actor's touched signal
351 HandleData handleData;
352 TouchEventHandleFunctor functor(handleData);
353 actor.TouchedSignal().Connect(&application, functor);
355 Vector2 screenCoordinates(10.0f, 10.0f);
356 Vector2 localCoordinates;
357 actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
359 // Emit a down signal
360 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
361 DALI_TEST_EQUALS(true, handleData.signalReceived, TEST_LOCATION);
362 DALI_TEST_EQUALS(1u, handleData.receivedTouchHandle.GetPointCount(), TEST_LOCATION);
363 DALI_TEST_EQUALS(PointState::DOWN, handleData.receivedTouchHandle.GetState(0), TEST_LOCATION);
364 DALI_TEST_EQUALS(screenCoordinates, handleData.receivedTouchHandle.GetScreenPosition(0), TEST_LOCATION);
365 DALI_TEST_EQUALS(localCoordinates, handleData.receivedTouchHandle.GetLocalPosition(0), 0.1f, TEST_LOCATION);
370 int UtcDaliTouchEventAPINegative(void)
372 TestApplication application;
374 Actor actor = Actor::New();
375 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
376 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
377 application.GetScene().Add(actor);
380 application.SendNotification();
381 application.Render();
383 // Connect to actor's touched signal
384 OutOfBoundsData data;
385 OutOfBoundsFunctor functor(data, true);
386 actor.TouchedSignal().Connect(&application, functor);
388 Vector2 screenCoordinates(10.0f, 10.0f);
389 Vector2 localCoordinates;
390 actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
392 // Emit a down signal
393 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
395 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
396 DALI_TEST_EQUALS(-1, data.point.deviceId, TEST_LOCATION);
397 DALI_TEST_EQUALS(PointState::FINISHED, data.point.state, TEST_LOCATION);
398 DALI_TEST_EQUALS(Vector2::ZERO, data.point.screen, TEST_LOCATION);
399 DALI_TEST_EQUALS(Vector2::ZERO, data.point.local, 0.1f, TEST_LOCATION);
400 DALI_TEST_CHECK(!data.point.hitActor);
405 int UtcDaliTouchEventOutsideCameraNearFarPlanes(void)
407 TestApplication application;
409 Integration::Scene scene = application.GetScene();
410 Vector2 sceneSize = scene.GetSize();
412 Actor actor = Actor::New();
413 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
414 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
415 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
419 application.SendNotification();
420 application.Render();
422 // Get the camera's near and far planes
423 RenderTaskList taskList = scene.GetRenderTaskList();
424 Dali::RenderTask task = taskList.GetTask(0);
425 CameraActor camera = task.GetCameraActor();
426 float nearPlane = camera.GetNearClippingPlane();
427 float farPlane = camera.GetFarClippingPlane();
429 // Calculate the current distance of the actor from the camera
430 float tanHalfFov = tanf(camera.GetFieldOfView() * 0.5f);
431 float distance = (sceneSize.y * 0.5f) / tanHalfFov;
433 // Connect to actor's touched signal
435 TouchEventFunctor functor(data);
436 actor.TouchedSignal().Connect(&application, functor);
438 Vector2 screenCoordinates(sceneSize.x * 0.5f, sceneSize.y * 0.5f);
440 // Emit a down signal
441 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
442 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
445 // Emit a down signal where actor is just at the camera's near plane
446 actor.SetProperty(Actor::Property::POSITION_Z, distance - nearPlane);
449 application.SendNotification();
450 application.Render();
452 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
453 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
456 // Emit a down signal where actor is closer than the camera's near plane
457 actor.SetProperty(Actor::Property::POSITION_Z, (distance - nearPlane) + 1.0f);
460 application.SendNotification();
461 application.Render();
463 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
464 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
467 // Emit a down signal where actor is just at the camera's far plane
468 actor.SetProperty(Actor::Property::POSITION_Z, distance - farPlane);
471 application.SendNotification();
472 application.Render();
474 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
475 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
478 // Emit a down signal where actor is further than the camera's far plane
479 actor.SetProperty(Actor::Property::POSITION_Z, (distance - farPlane) - 1.0f);
482 application.SendNotification();
483 application.Render();
485 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
486 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
491 int UtcDaliTouchEventEmitEmpty(void)
493 TestApplication application;
497 // Emit an empty TouchEvent
498 Integration::TouchEvent event;
499 application.ProcessEvent(event);
500 tet_result(TET_FAIL);
502 catch(Dali::DaliException& e)
504 DALI_TEST_ASSERT(e, "!event.points.empty()", TEST_LOCATION);
509 int UtcDaliTouchEventInterrupted(void)
511 TestApplication application;
513 Actor actor = Actor::New();
514 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
515 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
516 application.GetScene().Add(actor);
519 application.SendNotification();
520 application.Render();
522 // Connect to actor's touched signal
524 TouchEventFunctor functor(data);
525 actor.TouchedSignal().Connect(&application, functor);
527 // Emit a down signal
528 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
529 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
530 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
533 // Emit an interrupted signal, we should be signalled regardless of whether there is a hit or not.
534 application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f /* Outside actor */)));
535 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
536 DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
539 // Emit another interrupted signal, our signal handler should not be called.
540 application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f)));
541 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
545 int UtcDaliTouchEventParentConsumer(void)
547 TestApplication application;
548 Actor rootActor(application.GetScene().GetRootLayer());
550 Actor actor = Actor::New();
551 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
552 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
553 application.GetScene().Add(actor);
556 application.SendNotification();
557 application.Render();
559 // Connect to actor's touched signal
561 TouchEventFunctor functor(data, false);
562 actor.TouchedSignal().Connect(&application, functor);
564 // Connect to root actor's touched signal
566 TouchEventFunctor rootFunctor(rootData); // Consumes signal
567 rootActor.TouchedSignal().Connect(&application, rootFunctor);
569 Vector2 screenCoordinates(10.0f, 10.0f);
570 Vector2 actorCoordinates, rootCoordinates;
571 actor.ScreenToLocal(actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y);
572 rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y);
574 // Emit a down signal
575 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
576 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
577 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
578 DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION);
579 DALI_TEST_EQUALS(1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION);
580 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
581 DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
582 DALI_TEST_EQUALS(screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION);
583 DALI_TEST_EQUALS(screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION);
584 DALI_TEST_EQUALS(actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
585 DALI_TEST_EQUALS(rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
586 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
587 DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
591 // Emit a motion signal
592 screenCoordinates.x = screenCoordinates.y = 11.0f;
593 actor.ScreenToLocal(actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y);
594 rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y);
595 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, screenCoordinates));
596 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
597 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
598 DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION);
599 DALI_TEST_EQUALS(1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION);
600 DALI_TEST_EQUALS(PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION);
601 DALI_TEST_EQUALS(PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION);
602 DALI_TEST_EQUALS(screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION);
603 DALI_TEST_EQUALS(screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION);
604 DALI_TEST_EQUALS(actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
605 DALI_TEST_EQUALS(rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
606 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
607 DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
612 screenCoordinates.x = screenCoordinates.y = 12.0f;
613 actor.ScreenToLocal(actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y);
614 rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y);
615 application.ProcessEvent(GenerateSingleTouch(PointState::UP, screenCoordinates));
616 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
617 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
618 DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION);
619 DALI_TEST_EQUALS(1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION);
620 DALI_TEST_EQUALS(PointState::UP, data.receivedTouch.points[0].state, TEST_LOCATION);
621 DALI_TEST_EQUALS(PointState::UP, rootData.receivedTouch.points[0].state, TEST_LOCATION);
622 DALI_TEST_EQUALS(screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION);
623 DALI_TEST_EQUALS(screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION);
624 DALI_TEST_EQUALS(actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
625 DALI_TEST_EQUALS(rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
626 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
627 DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
631 // Emit a down signal where the actor is not present, will hit the root actor though
632 screenCoordinates.x = screenCoordinates.y = 200.0f;
633 rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y);
634 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
635 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
636 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
637 DALI_TEST_EQUALS(1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION);
638 DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
639 DALI_TEST_EQUALS(screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION);
640 DALI_TEST_EQUALS(rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
641 DALI_TEST_CHECK(rootActor == rootData.receivedTouch.points[0].hitActor);
645 int UtcDaliTouchEventInterruptedParentConsumer(void)
647 TestApplication application;
648 Actor rootActor(application.GetScene().GetRootLayer());
650 Actor actor = Actor::New();
651 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
652 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
653 application.GetScene().Add(actor);
656 application.SendNotification();
657 application.Render();
659 // Connect to actor's touched signal
661 TouchEventFunctor functor(data, false);
662 actor.TouchedSignal().Connect(&application, functor);
664 // Connect to root actor's touched signal
666 TouchEventFunctor rootFunctor(rootData); // Consumes signal
667 rootActor.TouchedSignal().Connect(&application, rootFunctor);
669 // Emit a down signal
670 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
671 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
672 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
673 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
674 DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
675 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
676 DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
680 // Emit an interrupted signal
681 application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f)));
682 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
683 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
684 DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
685 DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION);
686 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
687 DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
691 // Emit another down signal
692 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
693 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
694 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
695 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
696 DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
700 // Remove actor from scene
701 application.GetScene().Remove(actor);
706 application.SendNotification();
707 application.Render();
709 // Emit an interrupted signal, only root actor's signal should be called.
710 application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f /* Outside actor */)));
711 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
712 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
713 DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION);
714 DALI_TEST_CHECK(rootActor == rootData.receivedTouch.points[0].hitActor);
718 // Emit another interrupted state, none of the signal's should be called.
719 application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f)));
720 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
721 DALI_TEST_EQUALS(false, rootData.functorCalled, TEST_LOCATION);
725 int UtcDaliTouchEventLeave(void)
727 TestApplication application;
729 Actor actor = Actor::New();
730 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
731 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
732 application.GetScene().Add(actor);
735 application.SendNotification();
736 application.Render();
738 // Connect to actor's touched signal
740 TouchEventFunctor functor(data);
741 actor.TouchedSignal().Connect(&application, functor);
743 // Set actor to require leave events
744 actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
746 // Emit a down signal
747 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
748 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
749 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
752 // Emit a motion signal outside of actor, should be signalled with a Leave
753 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
754 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
755 DALI_TEST_EQUALS(PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION);
758 // Another motion outside of actor, no signalling
759 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(201.0f, 201.0f)));
760 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
763 // Another motion event inside actor, signalled with motion
764 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(10.0f, 10.0f)));
765 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
766 DALI_TEST_EQUALS(PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION);
769 // We do not want to listen to leave events anymore
770 actor.SetProperty(Actor::Property::LEAVE_REQUIRED, false);
772 // Another motion event outside of actor, no signalling
773 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
774 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
779 int UtcDaliTouchEventLeaveParentConsumer(void)
781 TestApplication application;
782 Actor rootActor(application.GetScene().GetRootLayer());
784 Actor actor = Actor::New();
785 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
786 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
787 application.GetScene().Add(actor);
790 application.SendNotification();
791 application.Render();
793 // Connect to actor's touched signal
795 TouchEventFunctor functor(data, false);
796 actor.TouchedSignal().Connect(&application, functor);
798 // Connect to root actor's touched signal
800 TouchEventFunctor rootFunctor(rootData); // Consumes signal
801 rootActor.TouchedSignal().Connect(&application, rootFunctor);
803 // Set actor to require leave events
804 actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
805 rootActor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
807 // Emit a down signal
808 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
809 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
810 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
811 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
812 DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
813 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
814 DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
818 // Emit a motion signal outside of actor, should be signalled with a Leave
819 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
820 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
821 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
822 DALI_TEST_EQUALS(PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION);
823 DALI_TEST_EQUALS(PointState::LEAVE, rootData.receivedTouch.points[0].state, TEST_LOCATION);
824 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
825 DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
829 // Another motion outside of actor, only rootActor signalled
830 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(201.0f, 201.0f)));
831 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
832 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
833 DALI_TEST_EQUALS(PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION);
834 DALI_TEST_CHECK(rootActor == rootData.receivedTouch.points[0].hitActor);
838 // Another motion event inside actor, signalled with motion
839 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(10.0f, 10.0f)));
840 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
841 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
842 DALI_TEST_EQUALS(PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION);
843 DALI_TEST_EQUALS(PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION);
844 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
845 DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
849 // We do not want to listen to leave events of actor anymore
850 actor.SetProperty(Actor::Property::LEAVE_REQUIRED, false);
852 // Another motion event outside of root actor, only root signalled
853 Vector2 sceneSize(application.GetScene().GetSize());
854 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(sceneSize.width + 10.0f, sceneSize.height + 10.0f)));
855 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
856 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
857 DALI_TEST_EQUALS(PointState::LEAVE, rootData.receivedTouch.points[0].state, TEST_LOCATION);
861 int UtcDaliTouchEventActorBecomesInsensitive(void)
863 TestApplication application;
865 Actor actor = Actor::New();
866 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
867 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
868 application.GetScene().Add(actor);
871 application.SendNotification();
872 application.Render();
874 // Connect to actor's touched signal
876 TouchEventFunctor functor(data);
877 actor.TouchedSignal().Connect(&application, functor);
879 // Emit a down signal
880 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
881 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
882 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
885 // Change actor to insensitive
886 actor.SetProperty(Actor::Property::SENSITIVE, false);
888 // Emit a motion signal, signalled with an interrupted
889 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
890 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
891 DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
896 int UtcDaliTouchEventActorBecomesInsensitiveParentConsumer(void)
898 TestApplication application;
899 Actor rootActor(application.GetScene().GetRootLayer());
901 Actor actor = Actor::New();
902 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
903 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
904 application.GetScene().Add(actor);
907 application.SendNotification();
908 application.Render();
910 // Connect to actor's touched signal
912 TouchEventFunctor functor(data, false);
913 actor.TouchedSignal().Connect(&application, functor);
915 // Connect to root actor's touched signal
917 TouchEventFunctor rootFunctor(rootData); // Consumes signal
918 rootActor.TouchedSignal().Connect(&application, rootFunctor);
920 // Emit a down signal
921 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
922 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
923 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
924 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
925 DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
926 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
927 DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
932 application.SendNotification();
933 application.Render();
935 // Make root actor insensitive
936 rootActor.SetProperty(Actor::Property::SENSITIVE, false);
938 // Emit a motion signal, signalled with an interrupted (should get interrupted even if within root actor)
939 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
940 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
941 DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
942 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
943 DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION);
947 int UtcDaliTouchEventActorBecomesUserInteractionDisabled(void)
949 TestApplication application;
951 Actor actor = Actor::New();
952 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
953 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
954 application.GetScene().Add(actor);
957 application.SendNotification();
958 application.Render();
960 // Connect to actor's touched signal
962 TouchEventFunctor functor(data);
963 actor.TouchedSignal().Connect(&application, functor);
965 // Emit a down signal
966 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
967 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
968 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
971 // Change actor to disable user interaction.
972 actor.SetProperty(DevelActor::Property::USER_INTERACTION_ENABLED, false);
974 // Emit a motion signal, signalled with an interrupted
975 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
976 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
977 DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
982 int UtcDaliTouchEventMultipleLayers(void)
984 TestApplication application;
985 Actor rootActor(application.GetScene().GetRootLayer());
987 // Connect to actor's touched signal
989 TouchEventFunctor functor(data);
991 Layer layer1(Layer::New());
992 layer1.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
993 layer1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
994 application.GetScene().Add(layer1);
996 Actor actor1(Actor::New());
997 actor1.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
998 actor1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
999 actor1.SetProperty(Actor::Property::POSITION_Z, 1.0f); // Should hit actor1 in this layer
1002 // Render and notify
1003 application.SendNotification();
1004 application.Render();
1006 // Connect to layer1 and actor1
1007 layer1.TouchedSignal().Connect(&application, functor);
1008 actor1.TouchedSignal().Connect(&application, functor);
1010 // Hit in hittable area, actor1 should be hit
1011 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1012 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1013 DALI_TEST_CHECK(data.touchedActor == actor1);
1016 // Make layer1 insensitive, nothing should be hit
1017 layer1.SetProperty(Actor::Property::SENSITIVE, false);
1018 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1019 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1022 // Make layer1 sensitive again, again actor1 will be hit
1023 layer1.SetProperty(Actor::Property::SENSITIVE, true);
1024 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1025 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1026 DALI_TEST_CHECK(data.touchedActor == actor1);
1029 // Make rootActor insensitive, nothing should be hit
1030 rootActor.SetProperty(Actor::Property::SENSITIVE, false);
1031 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1032 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1035 // Make rootActor sensitive
1036 rootActor.SetProperty(Actor::Property::SENSITIVE, true);
1038 // Add another layer
1039 Layer layer2(Layer::New());
1040 layer2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1041 layer2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1042 layer2.SetProperty(Actor::Property::POSITION_Z, 10.0f); // Should hit layer2 in this layer rather than actor2
1043 application.GetScene().Add(layer2);
1045 Actor actor2(Actor::New());
1046 actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1047 actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1050 // Render and notify
1051 application.SendNotification();
1052 application.Render();
1054 // Connect to layer2 and actor2
1055 layer2.TouchedSignal().Connect(&application, functor);
1056 actor2.TouchedSignal().Connect(&application, functor);
1058 // Emit an event, should hit layer2
1059 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1060 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1061 //DALI_TEST_CHECK( data.touchedActor == layer2 ); // TODO: Uncomment this after removing renderable hack!
1064 // Make layer2 insensitive, should hit actor1
1065 layer2.SetProperty(Actor::Property::SENSITIVE, false);
1066 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1067 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1068 DALI_TEST_CHECK(data.touchedActor == actor1);
1071 // Make layer2 sensitive again, should hit layer2
1072 layer2.SetProperty(Actor::Property::SENSITIVE, true);
1073 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1074 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1075 //DALI_TEST_CHECK( data.touchedActor == layer2 ); // TODO: Uncomment this after removing renderable hack!
1078 // Make layer2 invisible, render and notify
1079 layer2.SetProperty(Actor::Property::VISIBLE, false);
1080 application.SendNotification();
1081 application.Render();
1083 // Should hit actor1
1084 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1085 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1086 DALI_TEST_CHECK(data.touchedActor == actor1);
1089 // Make rootActor invisible, render and notify
1090 rootActor.SetProperty(Actor::Property::VISIBLE, false);
1091 application.SendNotification();
1092 application.Render();
1094 // Should not hit anything
1095 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1096 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1101 int UtcDaliTouchEventMultipleRenderTasks(void)
1103 TestApplication application;
1104 Integration::Scene scene(application.GetScene());
1105 Vector2 sceneSize(scene.GetSize());
1107 Actor actor = Actor::New();
1108 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1109 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1112 // Create render task
1113 Viewport viewport(sceneSize.width * 0.5f, sceneSize.height * 0.5f, sceneSize.width * 0.5f, sceneSize.height * 0.5f);
1114 RenderTask renderTask(application.GetScene().GetRenderTaskList().CreateTask());
1115 renderTask.SetViewport(viewport);
1116 renderTask.SetInputEnabled(true);
1118 // Render and notify
1119 application.SendNotification();
1120 application.Render();
1122 // Connect to actor's touched signal
1124 TouchEventFunctor functor(data);
1125 actor.TouchedSignal().Connect(&application, functor);
1127 // Emit a down signal
1128 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1129 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1132 // Ensure renderTask actor can be hit too.
1133 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(viewport.x + 5.0f, viewport.y + 5.0f)));
1134 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1137 // Disable input on renderTask, should not be hittable
1138 renderTask.SetInputEnabled(false);
1139 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(viewport.x + 5.0f, viewport.y + 5.0f)));
1140 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1145 int UtcDaliTouchEventMultipleRenderTasksWithChildLayer(void)
1147 TestApplication application;
1148 Integration::Scene scene(application.GetScene());
1149 Vector2 sceneSize(scene.GetSize());
1151 Actor actor = Actor::New();
1152 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1153 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1156 Layer layer = Layer::New();
1157 layer.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1158 layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1161 // Create render task
1162 Viewport viewport(sceneSize.width * 0.5f, sceneSize.height * 0.5f, sceneSize.width * 0.5f, sceneSize.height * 0.5f);
1163 RenderTask renderTask(application.GetScene().GetRenderTaskList().CreateTask());
1164 renderTask.SetViewport(viewport);
1165 renderTask.SetInputEnabled(true);
1166 renderTask.SetSourceActor(actor);
1168 // Render and notify
1169 application.SendNotification();
1170 application.Render();
1172 // Connect to layer's touched signal
1174 TouchEventFunctor functor(data);
1175 actor.TouchedSignal().Connect(&application, functor);
1176 layer.TouchedSignal().Connect(&application, functor);
1178 // Emit a down signal
1179 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1180 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1183 // Ensure renderTask actor can be hit too.
1184 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(viewport.x + 5.0f, viewport.y + 5.0f)));
1185 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1188 // Disable input on renderTask, should not be hittable
1189 renderTask.SetInputEnabled(false);
1190 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(viewport.x + 5.0f, viewport.y + 5.0f)));
1191 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1196 int UtcDaliTouchEventOffscreenRenderTasks(void)
1198 TestApplication application;
1199 Integration::Scene scene(application.GetScene());
1200 Vector2 sceneSize(scene.GetSize());
1202 // FrameBufferImage for offscreen RenderTask
1203 FrameBuffer frameBuffer = FrameBuffer::New(sceneSize.width, sceneSize.height);
1205 // Create a renderable actor to display the FrameBufferImage
1206 Actor renderableActor = CreateRenderableActor(frameBuffer.GetColorTexture());
1207 renderableActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1208 renderableActor.SetProperty(Actor::Property::SIZE, Vector2(sceneSize.x, sceneSize.y));
1209 renderableActor.ScaleBy(Vector3(1.0f, -1.0f, 1.0f)); // FIXME
1210 scene.Add(renderableActor);
1212 Actor actor = Actor::New();
1213 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1214 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1216 application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE); // Ensure framebuffer connects
1218 scene.GetRenderTaskList().GetTask(0u).SetScreenToFrameBufferFunction(RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION);
1220 // Create a RenderTask
1221 RenderTask renderTask = scene.GetRenderTaskList().CreateTask();
1222 renderTask.SetSourceActor(actor);
1223 renderTask.SetFrameBuffer(frameBuffer);
1224 renderTask.SetInputEnabled(true);
1226 // Create another RenderTask
1227 RenderTask renderTask2(scene.GetRenderTaskList().CreateTask());
1228 renderTask2.SetInputEnabled(true);
1230 // Render and notify
1231 application.SendNotification();
1232 application.Render();
1234 // Connect to actor's touched signal
1236 TouchEventFunctor functor(data);
1237 actor.TouchedSignal().Connect(&application, functor);
1239 // Emit a down signal
1240 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1241 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1246 int UtcDaliTouchEventMultipleRenderableActors(void)
1248 TestApplication application;
1249 Integration::Scene scene(application.GetScene());
1250 Vector2 sceneSize(scene.GetSize());
1252 Actor parent = CreateRenderableActor();
1253 parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1254 parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1257 Actor actor = CreateRenderableActor();
1258 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1259 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1262 // Render and notify
1263 application.SendNotification();
1264 application.Render();
1266 // Connect to layer's touched signal
1268 TouchEventFunctor functor(data);
1269 parent.TouchedSignal().Connect(&application, functor);
1270 actor.TouchedSignal().Connect(&application, functor);
1272 // Emit a down signal
1273 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1274 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1275 DALI_TEST_CHECK(actor == data.touchedActor);
1279 int UtcDaliTouchEventActorRemovedInSignal(void)
1281 TestApplication application;
1283 Actor actor = Actor::New();
1284 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1285 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1286 application.GetScene().Add(actor);
1288 // Render and notify
1289 application.SendNotification();
1290 application.Render();
1292 // Connect to actor's touched signal
1294 RemoveActorFunctor functor(data);
1295 actor.TouchedSignal().Connect(&application, functor);
1297 // Register for leave events
1298 actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
1300 // Emit a down signal
1301 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1302 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1305 // Re-add, render and notify
1306 application.GetScene().Add(actor);
1307 application.SendNotification();
1308 application.Render();
1310 // Emit another signal outside of actor's area, should not get anything as the scene has changed.
1311 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(210.0f, 210.0f)));
1312 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1315 // Emit a down signal
1316 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1317 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1320 // Render and notify
1321 application.SendNotification();
1322 application.Render();
1324 // Emit another signal outside of actor's area, should not get anything as the scene has changed.
1325 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(210.0f, 210.0f)));
1326 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1329 // Re-add actor back to scene, render and notify
1330 application.GetScene().Add(actor);
1331 application.SendNotification();
1332 application.Render();
1334 // Emit another down event
1335 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1336 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1339 // Completely delete the actor
1342 // Emit event, should not crash and should not receive an event.
1343 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(210.0f, 210.0f)));
1344 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1348 int UtcDaliTouchEventActorSignalNotConsumed(void)
1350 TestApplication application;
1352 Actor actor = Actor::New();
1353 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1354 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1355 application.GetScene().Add(actor);
1357 // Render and notify
1358 application.SendNotification();
1359 application.Render();
1361 // Connect to actor's touched signal
1363 TouchEventFunctor functor(data, false);
1364 actor.TouchedSignal().Connect(&application, functor);
1366 // Emit a down signal
1367 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1368 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1372 int UtcDaliTouchEventActorRemovedFromScene(void)
1374 TestApplication application;
1376 Actor actor = Actor::New();
1377 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1378 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1379 application.GetScene().Add(actor);
1381 // Render and notify
1382 application.SendNotification();
1383 application.Render();
1385 // Connect to actor's touched signal
1387 TouchEventFunctor functor(data);
1388 actor.TouchedSignal().Connect(&application, functor);
1390 // Emit a down signal
1391 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1392 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1395 // Remove actor from scene
1396 application.GetScene().Remove(actor);
1399 // Render and notify
1400 application.SendNotification();
1401 application.Render();
1403 // Emit a move at the same point, we should not be signalled.
1404 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(10.0f, 10.0f)));
1405 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1410 int UtcDaliTouchEventLayerConsumesTouch(void)
1412 TestApplication application;
1414 Actor actor = Actor::New();
1415 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1416 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1417 application.GetScene().Add(actor);
1419 // Render and notify
1420 application.SendNotification();
1421 application.Render();
1423 // Connect to actor's touched signal
1425 TouchEventFunctor functor(data);
1426 actor.TouchedSignal().Connect(&application, functor);
1428 // Add a layer to overlap the actor
1429 Layer layer = Layer::New();
1430 layer.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1431 layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1432 application.GetScene().Add(layer);
1435 // Render and notify
1436 application.SendNotification();
1437 application.Render();
1439 // Emit a few touch signals
1440 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1441 application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(10.0f, 10.0f)));
1442 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1445 // Set layer to consume all touch
1446 layer.SetProperty(Layer::Property::CONSUMES_TOUCH, true);
1448 // Render and notify
1449 application.SendNotification();
1450 application.Render();
1452 // Emit the same signals again, should not receive
1453 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1454 application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(10.0f, 10.0f)));
1455 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1461 int UtcDaliTouchEventLeaveActorReadded(void)
1463 TestApplication application;
1464 Integration::Scene scene = application.GetScene();
1466 Actor actor = Actor::New();
1467 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1468 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1471 // Set actor to receive touch-events
1472 actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
1474 // Render and notify
1475 application.SendNotification();
1476 application.Render();
1478 // Connect to actor's touched signal
1480 TouchEventFunctor functor(data);
1481 actor.TouchedSignal().Connect(&application, functor);
1483 // Emit a down and motion
1484 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1485 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(11.0f, 10.0f)));
1486 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1489 // Remove actor from scene and add again
1490 scene.Remove(actor);
1493 // Emit a motion within the actor's bounds
1494 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(12.0f, 10.0f)));
1495 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1498 // Emit a motion outside the actor's bounds
1499 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
1500 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1501 DALI_TEST_EQUALS(PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION);
1507 int UtcDaliTouchEventClippedActor(void)
1509 TestApplication application;
1510 Integration::Scene scene = application.GetScene();
1512 Actor actor = Actor::New();
1513 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1514 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1517 Actor clippingActor = Actor::New();
1518 clippingActor.SetProperty(Actor::Property::SIZE, Vector2(50.0f, 50.0f));
1519 clippingActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1520 clippingActor.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
1521 scene.Add(clippingActor);
1523 // Add a child to the clipped region.
1524 Actor clippingChild = Actor::New();
1525 clippingChild.SetProperty(Actor::Property::SIZE, Vector2(50.0f, 50.0f));
1526 clippingChild.SetProperty(Actor::Property::POSITION, Vector2(25.0f, 25.0f));
1527 clippingChild.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1528 clippingActor.Add(clippingChild);
1530 // Render and notify.
1531 application.SendNotification();
1532 application.Render();
1534 // Connect to actor's touch signal.
1536 TouchEventFunctor functor(data);
1537 actor.TouchedSignal().Connect(&application, functor);
1539 // Emit an event within clipped area - we should have a hit.
1540 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1541 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1544 // Emit an event within clipped child area - we should still have a hit.
1545 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(40.0f, 40.0f)));
1546 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1549 // Now connect to the clippingChild's touch signal
1550 SignalData clippingChildData;
1551 TouchEventFunctor clippingChildFunctor(clippingChildData);
1552 clippingChild.TouchedSignal().Connect(&application, clippingChildFunctor);
1554 // Emit an event within clipped child area - no hit on actor, but hit on clipped child.
1555 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(40.0f, 40.0f)));
1556 DALI_TEST_EQUALS(true, clippingChildData.functorCalled, TEST_LOCATION);
1557 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1559 clippingChildData.Reset();
1561 // Emit an event outside the clipped area but within the actor area, we should have a hit.
1562 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(60.0f, 60.0f)));
1563 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1565 clippingChildData.Reset();
1567 // Emit an event inside part of the child which is within the clipped area, we should have a hit on the clipped child but not the actor.
1568 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(30.0f, 30.0f)));
1569 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1570 DALI_TEST_EQUALS(true, clippingChildData.functorCalled, TEST_LOCATION);
1572 clippingChildData.Reset();
1577 int UtcDaliTouchEventActorUnparented(void)
1579 TestApplication application;
1581 Actor actor = Actor::New();
1582 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1583 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1584 application.GetScene().Add(actor);
1586 // Render and notify
1587 application.SendNotification();
1588 application.Render();
1590 // Connect to actor's touched signal
1592 TouchEventFunctor functor(data);
1593 actor.TouchedSignal().Connect(&application, functor);
1595 // Emit a down signal
1596 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1597 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1598 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
1599 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
1602 // Render and notify
1603 application.SendNotification();
1604 application.Render();
1606 // Unparent the actor
1609 // Should receive an interrupted event
1610 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1611 DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
1615 int UtcDaliTouchEventParentRemovedFromScene(void)
1617 TestApplication application;
1619 Actor parent = Actor::New();
1620 parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1621 parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1622 application.GetScene().Add(parent);
1624 Actor actor = Actor::New();
1625 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1626 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1629 // Render and notify
1630 application.SendNotification();
1631 application.Render();
1633 // Connect to actor's touched signal
1635 TouchEventFunctor functor(data);
1636 actor.TouchedSignal().Connect(&application, functor);
1638 // Emit a down signal
1639 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1640 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1641 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
1642 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
1645 // Render and notify
1646 application.SendNotification();
1647 application.Render();
1649 // Unparent the parent of the touchable actor
1652 // Should receive an interrupted event
1653 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1654 DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
1658 int UtcDaliTouchEventActorRemovedFromSceneDifferentConsumer(void)
1660 TestApplication application;
1662 Actor parent = Actor::New();
1663 parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1664 parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1665 application.GetScene().Add(parent);
1667 Actor actor = Actor::New();
1668 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1669 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1672 // Render and notify
1673 application.SendNotification();
1674 application.Render();
1676 // Connect to actor's touched signal
1678 TouchEventFunctor functor(data, false /* Do not consume */);
1679 actor.TouchedSignal().Connect(&application, functor);
1681 // Connect to parent's touched signal
1682 SignalData parentData;
1683 TouchEventFunctor parentFunctor(parentData);
1684 parent.TouchedSignal().Connect(&application, parentFunctor);
1686 // Emit a down signal
1687 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1688 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1689 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
1690 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
1691 DALI_TEST_CHECK(actor == data.touchedActor);
1692 DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
1693 DALI_TEST_EQUALS(PointState::DOWN, parentData.receivedTouch.points[0].state, TEST_LOCATION);
1694 DALI_TEST_CHECK(actor == parentData.receivedTouch.points[0].hitActor);
1695 DALI_TEST_CHECK(parent == parentData.touchedActor);
1699 // Render and notify
1700 application.SendNotification();
1701 application.Render();
1703 // Unparent the actor
1706 // Should receive an interrupted event for both actor & parent
1707 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1708 DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
1709 DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
1710 DALI_TEST_EQUALS(PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION);
1714 // Readd actor to parent
1717 // Render and notify
1718 application.SendNotification();
1719 application.Render();
1721 // Emit a motion signal
1722 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(10.0f, 10.0f)));
1723 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1724 DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
1728 // Parent is now consumer, connect again to the touched signal of the actor so that it becomes the consumer
1729 SignalData secondData;
1730 TouchEventFunctor secondFunctor(secondData /* Consume */);
1731 actor.TouchedSignal().Connect(&application, secondFunctor);
1733 // Unparent the actor
1736 // Should receive an interrupted event for both actor functors & the parent as well as it was last consumer
1737 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1738 DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
1739 DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
1740 DALI_TEST_EQUALS(PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION);
1741 DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
1742 DALI_TEST_EQUALS(PointState::INTERRUPTED, secondData.receivedTouch.points[0].state, TEST_LOCATION);
1750 int UtcDaliTouchEventInterruptedDifferentConsumer(void)
1752 TestApplication application;
1753 Actor rootActor(application.GetScene().GetRootLayer());
1755 Actor parent = Actor::New();
1756 parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1757 parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1758 application.GetScene().Add(parent);
1760 Actor actor = Actor::New();
1761 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1762 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1765 // Render and notify
1766 application.SendNotification();
1767 application.Render();
1769 // Connect to actor's touched signal
1771 TouchEventFunctor functor(data, false /* Do not consume */);
1772 actor.TouchedSignal().Connect(&application, functor);
1774 // Connect to parent's touched signal
1775 SignalData parentData;
1776 TouchEventFunctor parentFunctor(parentData, false /* Do not consume */);
1777 parent.TouchedSignal().Connect(&application, parentFunctor);
1779 // Connect to root's touched signal and consume
1780 SignalData rootData;
1781 TouchEventFunctor rootFunctor(rootData);
1782 rootActor.TouchedSignal().Connect(&application, rootFunctor);
1784 // Emit a down signal
1785 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1786 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1787 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
1788 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
1789 DALI_TEST_CHECK(actor == data.touchedActor);
1790 DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
1791 DALI_TEST_EQUALS(PointState::DOWN, parentData.receivedTouch.points[0].state, TEST_LOCATION);
1792 DALI_TEST_CHECK(actor == parentData.receivedTouch.points[0].hitActor);
1793 DALI_TEST_CHECK(parent == parentData.touchedActor);
1794 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
1795 DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
1796 DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
1797 DALI_TEST_CHECK(rootActor == rootData.touchedActor);
1802 // Root is now consumer, connect to the touched signal of the parent so that it becomes the consumer
1803 SignalData secondData;
1804 TouchEventFunctor secondFunctor(secondData /* Consume */);
1805 parent.TouchedSignal().Connect(&application, secondFunctor);
1807 // Emit an interrupted signal, all three should STILL be called
1808 application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(10.0f, 10.0f)));
1809 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1810 DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
1811 DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
1812 DALI_TEST_EQUALS(PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION);
1813 DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
1814 DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION);
1822 int UtcDaliTouchEventGetRadius(void)
1824 TestApplication application;
1826 Actor actor = Actor::New();
1827 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1828 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1829 application.GetScene().Add(actor);
1831 // Render and notify
1832 application.SendNotification();
1833 application.Render();
1835 // Connect to actor's touched signal
1837 TouchEventFunctor functor(data);
1838 actor.TouchedSignal().Connect(&application, functor);
1840 // Emit a down signal with an angle
1841 Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f));
1842 touchEvent.points[0].SetRadius(100.0f);
1843 application.ProcessEvent(touchEvent);
1844 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1845 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
1846 DALI_TEST_EQUALS(100.0f, data.receivedTouch.points[0].radius, TEST_LOCATION);
1847 DALI_TEST_EQUALS(100.0f, data.receivedTouch.points[0].ellipseRadius.x, TEST_LOCATION);
1848 DALI_TEST_EQUALS(100.0f, data.receivedTouch.points[0].ellipseRadius.y, TEST_LOCATION);
1853 int UtcDaliTouchEventGetEllipseRadius(void)
1855 TestApplication application;
1857 Actor actor = Actor::New();
1858 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1859 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1860 application.GetScene().Add(actor);
1862 // Render and notify
1863 application.SendNotification();
1864 application.Render();
1866 // Connect to actor's touched signal
1868 TouchEventFunctor functor(data);
1869 actor.TouchedSignal().Connect(&application, functor);
1871 // Emit a down signal with an angle
1872 Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f));
1873 touchEvent.points[0].SetRadius(100.0f, Vector2(20.0f, 10.0f));
1874 application.ProcessEvent(touchEvent);
1875 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1876 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
1877 DALI_TEST_EQUALS(100.0f, data.receivedTouch.points[0].radius, TEST_LOCATION);
1878 DALI_TEST_EQUALS(20.0f, data.receivedTouch.points[0].ellipseRadius.x, TEST_LOCATION);
1879 DALI_TEST_EQUALS(10.0f, data.receivedTouch.points[0].ellipseRadius.y, TEST_LOCATION);
1884 int UtcDaliTouchEventGetAngle(void)
1886 TestApplication application;
1888 Actor actor = Actor::New();
1889 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1890 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1891 application.GetScene().Add(actor);
1893 // Render and notify
1894 application.SendNotification();
1895 application.Render();
1897 // Connect to actor's touched signal
1899 TouchEventFunctor functor(data);
1900 actor.TouchedSignal().Connect(&application, functor);
1902 // Emit a down signal with an angle
1903 Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f));
1904 touchEvent.points[0].SetAngle(Degree(90.0f));
1905 application.ProcessEvent(touchEvent);
1906 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1907 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
1908 DALI_TEST_EQUALS(Degree(90.0f), data.receivedTouch.points[0].angle, TEST_LOCATION);
1913 int UtcDaliTouchEventGetPressure(void)
1915 TestApplication application;
1917 Actor actor = Actor::New();
1918 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1919 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1920 application.GetScene().Add(actor);
1922 // Render and notify
1923 application.SendNotification();
1924 application.Render();
1926 // Connect to actor's touched signal
1928 TouchEventFunctor functor(data);
1929 actor.TouchedSignal().Connect(&application, functor);
1931 // Emit a down signal with an angle
1932 Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f));
1933 touchEvent.points[0].SetPressure(10.0f);
1934 application.ProcessEvent(touchEvent);
1935 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1936 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
1937 DALI_TEST_EQUALS(10.0f, data.receivedTouch.points[0].pressure, TEST_LOCATION);
1942 int UtcDaliTouchEventUsage(void)
1944 TestApplication application;
1946 Actor actor = Actor::New();
1947 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1948 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1949 application.GetScene().Add(actor);
1951 // Render and notify
1952 application.SendNotification();
1953 application.Render();
1955 // Connect to actor's touched signal
1957 TouchEventFunctor functor(data);
1958 actor.TouchedSignal().Connect(&application, functor);
1960 // Emit a down signal with an angle
1961 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
1962 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1967 int UtcDaliTouchEventGetDeviceAPINegative(void)
1969 TestApplication application;
1971 Actor actor = Actor::New();
1972 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1973 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1974 application.GetScene().Add(actor);
1976 // Render and notify
1977 application.SendNotification();
1978 application.Render();
1980 // Connect to actor's touched signal
1981 HandleData handleData;
1982 TouchEventHandleFunctor functor(handleData);
1983 actor.TouchedSignal().Connect(&application, functor);
1985 Vector2 screenCoordinates(10.0f, 10.0f);
1986 Vector2 localCoordinates;
1987 actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
1989 // Emit a down signal
1990 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
1992 TouchEvent data = handleData.receivedTouchHandle;
1993 DALI_TEST_EQUALS(data.GetDeviceClass(-1), Device::Class::NONE, TEST_LOCATION);
1994 DALI_TEST_EQUALS(data.GetDeviceSubclass(-1), Device::Subclass::NONE, TEST_LOCATION);
1998 int UtcDaliTouchEventGetMouseButtonPositive(void)
2000 TestApplication application;
2002 Actor actor = Actor::New();
2003 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
2004 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2005 application.GetScene().Add(actor);
2007 // Render and notify
2008 application.SendNotification();
2009 application.Render();
2011 // Connect to actor's touched signal
2012 HandleData handleData;
2013 TouchEventHandleFunctor functor(handleData);
2014 actor.TouchedSignal().Connect(&application, functor);
2016 // Emit a down signal with MouseButton
2017 Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f));
2018 touchEvent.points[0].SetMouseButton(static_cast<MouseButton::Type>(3));
2019 application.ProcessEvent(touchEvent);
2021 TouchEvent data = handleData.receivedTouchHandle;
2022 DALI_TEST_EQUALS(data.GetMouseButton(0), MouseButton::SECONDARY, TEST_LOCATION);
2027 int UtcDaliTouchEventGetMouseButtonNagative(void)
2029 TestApplication application;
2031 Actor actor = Actor::New();
2032 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
2033 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2034 application.GetScene().Add(actor);
2036 // Render and notify
2037 application.SendNotification();
2038 application.Render();
2040 // Connect to actor's touched signal
2041 HandleData handleData;
2042 TouchEventHandleFunctor functor(handleData);
2043 actor.TouchedSignal().Connect(&application, functor);
2045 // Emit a down signal with MouseButton
2046 Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f));
2047 touchEvent.points[0].SetMouseButton(static_cast<MouseButton::Type>(2));
2048 application.ProcessEvent(touchEvent);
2050 TouchEvent data = handleData.receivedTouchHandle;
2051 DALI_TEST_EQUALS(data.GetMouseButton(0), MouseButton::TERTIARY, TEST_LOCATION);
2052 DALI_TEST_EQUALS(data.GetMouseButton(3), MouseButton::INVALID, TEST_LOCATION);
2057 int UtcDaliTouchEventCapturePropertySet(void)
2059 TestApplication application;
2061 Actor actor = Actor::New();
2062 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
2063 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2064 application.GetScene().Add(actor);
2066 // Render and notify
2067 application.SendNotification();
2068 application.Render();
2070 // Connect to actor's touched signal
2072 TouchEventFunctor functor(data);
2073 actor.TouchedSignal().Connect(&application, functor);
2075 // Emit a down signal
2076 application.ProcessEvent(GenerateSingleTouch(PointState::STARTED, Vector2(10.0f, 10.0f)));
2077 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2080 // Now motion outside of actor, we should not receive the event
2081 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(110.0f, 110.0f)));
2082 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2085 // Up event, should receive an interrupted
2086 application.ProcessEvent(GenerateSingleTouch(PointState::FINISHED, Vector2(110.0f, 110.0f)));
2087 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2088 DALI_TEST_EQUALS(data.receivedTouch.GetPoint(0).state, PointState::INTERRUPTED, TEST_LOCATION);
2090 // Now set the capture property
2091 actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, true);
2093 // Emit a down signal
2094 application.ProcessEvent(GenerateSingleTouch(PointState::STARTED, Vector2(10.0f, 10.0f)));
2095 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2098 // Now motion outside of actor, we now SHOULD receive the event
2099 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(110.0f, 110.0f)));
2100 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2103 // Up event, we should receive it again, but as ended rather than interrupted
2104 application.ProcessEvent(GenerateSingleTouch(PointState::FINISHED, Vector2(110.0f, 110.0f)));
2105 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2106 DALI_TEST_EQUALS(data.receivedTouch.GetPoint(0).state, PointState::FINISHED, TEST_LOCATION);
2111 int UtcDaliTouchEventIntegNewTouchEvent(void)
2113 uint32_t timestamp = 92858u;
2114 TouchPoint tp(1, PointState::STARTED, 34.4f, 123.89f, 5.0f, 7.0f);
2115 Dali::TouchEvent touchEvent = Integration::NewTouchEvent(timestamp, tp);
2117 DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
2118 DALI_TEST_EQUALS(touchEvent.GetState(0), PointState::STARTED, TEST_LOCATION);
2119 DALI_TEST_EQUALS(touchEvent.GetLocalPosition(0), Vector2(5.0f, 7.0f), TEST_LOCATION);
2120 DALI_TEST_EQUALS(touchEvent.GetScreenPosition(0), Vector2(34.4f, 123.89f), TEST_LOCATION);
2125 int UtcDaliTouchEventIntercept01(void)
2127 TestApplication application;
2129 Actor actor = Actor::New();
2130 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
2131 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2132 application.GetScene().Add(actor);
2134 // Render and notify
2135 application.SendNotification();
2136 application.Render();
2138 // Connect to actor's intercept touched signal
2140 TouchEventFunctor functor(data, false /* Do not consume */);
2141 Dali::DevelActor::InterceptTouchedSignal(actor).Connect(&application, functor);
2143 // Emit a down signal
2144 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
2146 // It should be able to receive touch events by registering only InterceptTouchEvent.
2147 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2148 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
2149 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
2150 DALI_TEST_CHECK(actor == data.touchedActor);
2156 int UtcDaliTouchEventIntercept02(void)
2158 TestApplication application;
2160 Actor parent = Actor::New();
2161 parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
2162 parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2163 application.GetScene().Add(parent);
2165 Actor actor = Actor::New();
2166 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
2167 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2170 // Render and notify
2171 application.SendNotification();
2172 application.Render();
2174 // Connect to actor's touched signal
2176 TouchEventFunctor functor(data, false /* Do not consume */);
2177 actor.TouchedSignal().Connect(&application, functor);
2179 // Connect to parent's touched signal
2180 SignalData parentData;
2181 TouchEventFunctor parentFunctor(parentData, false /* Do not consume */);
2182 parent.TouchedSignal().Connect(&application, parentFunctor);
2184 // Emit a down signal
2185 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
2186 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2187 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
2192 // Connect to parent's intercept touched signal
2193 SignalData interceptData;
2194 TouchEventFunctor interceptFunctor(interceptData, true /* Do intercept */);
2195 Dali::DevelActor::InterceptTouchedSignal(parent).Connect(&application, interceptFunctor);
2197 // Emit a down signal
2198 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
2200 // The actor gets interrupted. Because touch is intercepted by parent.
2201 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2202 DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
2203 DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION);
2204 DALI_TEST_EQUALS(PointState::DOWN, interceptData.receivedTouch.points[0].state, TEST_LOCATION);
2205 DALI_TEST_CHECK(actor == interceptData.receivedTouch.points[0].hitActor);
2206 DALI_TEST_CHECK(parent == interceptData.touchedActor);
2207 DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
2208 DALI_TEST_EQUALS(PointState::DOWN, parentData.receivedTouch.points[0].state, TEST_LOCATION);
2209 DALI_TEST_CHECK(actor == parentData.receivedTouch.points[0].hitActor);
2210 DALI_TEST_CHECK(parent == parentData.touchedActor);
2217 int UtcDaliTouchAreaOffset(void)
2219 TestApplication application;
2221 Actor actor = Actor::New();
2222 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
2223 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2225 application.GetScene().Add(actor);
2227 // Render and notify
2228 application.SendNotification();
2229 application.Render();
2231 // Connect to actor's touched signal
2233 TouchEventFunctor functor(data, false /* Do not consume */);
2234 actor.TouchedSignal().Connect(&application, functor);
2236 // Emit a down signal
2237 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(110.0f, 110.0f)));
2238 // The actor touched signal is not called because the touch area is outside actor.
2239 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2242 // set a bigger touch area
2243 actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Rect<int>(-70, 70, 70, -70)); // left, right, bottom, top
2245 // Render and notify
2246 application.SendNotification();
2247 application.Render();
2249 // Emit a down signal
2250 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(150.0f, 150.0f)));
2251 // The actor touched signal is called because the touch area is inside touchArea.
2252 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2253 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
2254 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
2257 // set a offset touch area
2258 actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Rect<int>(50, 100, -50, 0)); // left, right, bottom, top
2260 // Render and notify
2261 application.SendNotification();
2262 application.Render();
2264 // Emit a down signal
2265 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(190.0f, 25.0f)));
2266 // The actor touched signal is called because the touch area is inside touchArea.
2267 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2268 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
2269 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
2272 // set a smaller touch area
2273 actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Rect<int>(50, 0, 0, 50));
2275 // Render and notify
2276 application.SendNotification();
2277 application.Render();
2279 // Emit a down signal
2280 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(40.0f, 40.0f)));
2281 // The actor touched signal is not called because the touch area is outside touchArea.
2282 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2285 // Emit a down signal
2286 application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(90.0f, 90.0f)));
2287 // The actor touched signal is called because the touch area is inside touchArea.
2288 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2289 DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
2290 DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
2296 int UtcDaliTouchEventAllowOnlyOwnTouchPropertySet(void)
2298 TestApplication application;
2300 Actor actor = Actor::New();
2301 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
2302 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2303 application.GetScene().Add(actor);
2305 // Render and notify
2306 application.SendNotification();
2307 application.Render();
2309 // Connect to actor's touched signal
2311 TouchEventFunctor functor(data);
2312 actor.TouchedSignal().Connect(&application, functor);
2314 // Emit a down signal outside of actor, we should not receive the event
2315 application.ProcessEvent(GenerateSingleTouch(PointState::STARTED, Vector2(110.0f, 110.0f)));
2316 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2319 // Now motion inside of actor, we should receive the event
2320 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(80.0f, 80.0f)));
2321 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2324 // Up event, should not receive the event
2325 application.ProcessEvent(GenerateSingleTouch(PointState::FINISHED, Vector2(110.0f, 110.0f)));
2326 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2329 // Now set the only allow own touch property
2330 actor.SetProperty(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH, true);
2332 // Emit a down signal outside of actor, we should not receive the event
2333 application.ProcessEvent(GenerateSingleTouch(PointState::STARTED, Vector2(110.0f, 110.0f)));
2334 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2337 // Now motion inside of actor, we should NOT receive the event
2338 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(80.0f, 80.0f)));
2339 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2342 // Up event, should not receive the event
2343 application.ProcessEvent(GenerateSingleTouch(PointState::FINISHED, Vector2(110.0f, 110.0f)));
2344 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2347 // Emit a down signal inside of actor, we should receive the event
2348 application.ProcessEvent(GenerateSingleTouch(PointState::STARTED, Vector2(10.0f, 10.0f)));
2349 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2352 // Now motion inside of actor, we should receive the event
2353 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(80.0f, 80.0f)));
2354 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2357 // Now motion outsize of actor, we should receive the event
2358 application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(110.0f, 110.0f)));
2359 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2362 // Up event, should receive an interrupted
2363 application.ProcessEvent(GenerateSingleTouch(PointState::FINISHED, Vector2(110.0f, 110.0f)));
2364 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2365 DALI_TEST_EQUALS(data.receivedTouch.GetPoint(0).state, PointState::INTERRUPTED, TEST_LOCATION);