X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali%2Futc-Dali-TouchProcessing.cpp;h=275aa2a0511667ade741635fda4090753fd12af3;hb=5f30f2007509e8b9306599542c30a82d60564f96;hp=cb66ac499889dcba3babf5fbd14cbae9154743b9;hpb=9709e1327f6ca9391863eb6dacf562334a5d6a23;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/automated-tests/src/dali/utc-Dali-TouchProcessing.cpp b/automated-tests/src/dali/utc-Dali-TouchProcessing.cpp old mode 100644 new mode 100755 index cb66ac4..275aa2a --- a/automated-tests/src/dali/utc-Dali-TouchProcessing.cpp +++ b/automated-tests/src/dali/utc-Dali-TouchProcessing.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2020 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,13 +15,15 @@ * */ -#include - -#include -#include -#include -#include #include +#include +#include +#include +#include +#include +#include + +#include using namespace Dali; @@ -39,30 +41,68 @@ void utc_dali_touch_processing_cleanup(void) namespace { +struct TestPoint +{ + int32_t deviceId{-1}; + PointState::Type state{PointState::FINISHED}; + Actor hitActor; + Vector2 local; + Vector2 screen; + float radius{0}; + Vector2 ellipseRadius; + float pressure{0}; + Degree angle; + Device::Class::Type deviceClass{Device::Class::NONE}; + Device::Subclass::Type deviceSubclass{Device::Subclass::NONE}; + + TestPoint() = default; + static const TestPoint ZERO; +}; + +const TestPoint TestPoint::ZERO; // Stores data that is populated in the callback and will be read by the TET cases struct SignalData { SignalData() - : functorCalled( false ), - touchEvent(), + : functorCalled(false), + receivedTouch(), touchedActor() { } + struct TestTouchEvent + { + unsigned long time; + std::vector points; + + const TestPoint& GetPoint(size_t i) + { + if(i < points.size()) + { + return points[i]; + } + return TestPoint::ZERO; + } + size_t GetPointCount() + { + return points.size(); + } + }; + void Reset() { functorCalled = false; - touchEvent.time = 0u; - touchEvent.points.clear(); + receivedTouch.time = 0u; + receivedTouch.points.clear(); touchedActor.Reset(); } - bool functorCalled; - TouchEvent touchEvent; - Actor touchedActor; + bool functorCalled; + TestTouchEvent receivedTouch; + Actor touchedActor; }; // Functor that sets the data when called @@ -73,23 +113,77 @@ struct TouchEventFunctor * @param[in] data Reference to the data to store callback information. * @param[in] returnValue What the functor should return. */ - TouchEventFunctor( SignalData& data, bool returnValue = true ) - : signalData( data ), - returnValue( returnValue ) + TouchEventFunctor(SignalData& data, bool returnValue = true) + : signalData(data), + returnValue(returnValue) { } - bool operator()( Actor actor, const TouchEvent& touchEvent ) + bool operator()(Actor actor, const TouchEvent& touch) { signalData.functorCalled = true; - signalData.touchedActor = actor; - signalData.touchEvent = touchEvent; + signalData.touchedActor = actor; + + signalData.receivedTouch.time = touch.GetTime(); + signalData.receivedTouch.points.clear(); + + for(size_t i = 0; i < touch.GetPointCount(); ++i) + { + TestPoint p; + p.deviceId = touch.GetDeviceId(i); + p.state = touch.GetState(i); + p.hitActor = touch.GetHitActor(i); + p.local = touch.GetLocalPosition(i); + p.screen = touch.GetScreenPosition(i); + p.radius = touch.GetRadius(i); + p.ellipseRadius = touch.GetEllipseRadius(i); + p.pressure = touch.GetPressure(i); + p.angle = touch.GetAngle(i); + p.deviceClass = touch.GetDeviceClass(i); + p.deviceSubclass = touch.GetDeviceSubclass(i); + signalData.receivedTouch.points.push_back(p); + } return returnValue; } SignalData& signalData; - bool returnValue; + bool returnValue; +}; + +struct HandleData +{ + bool signalReceived; + TouchEvent receivedTouchHandle; + + HandleData() + : signalReceived(false) + { + } +}; + +struct TouchEventHandleFunctor +{ + /** + * Constructor. + * @param[in] data Reference to the data to store callback information. + * @param[in] returnValue What the functor should return. + */ + TouchEventHandleFunctor(HandleData& handleData, bool returnValue = true) + : handleData(handleData), + returnValue(returnValue) + { + } + + bool operator()(Actor actor, const TouchEvent& someTouchEvent) + { + handleData.signalReceived = true; + handleData.receivedTouchHandle = someTouchEvent; + return returnValue; + } + + HandleData& handleData; + bool returnValue; }; // Functor that removes the actor when called. @@ -100,181 +194,301 @@ struct RemoveActorFunctor : public TouchEventFunctor * @param[in] data Reference to the data to store callback information. * @param[in] returnValue What the functor should return. */ - RemoveActorFunctor( SignalData& data, bool returnValue = true ) - : TouchEventFunctor( data, returnValue ) + RemoveActorFunctor(SignalData& data, bool returnValue = true) + : TouchEventFunctor(data, returnValue) { } - bool operator()( Actor actor, const TouchEvent& touchEvent ) + bool operator()(Actor actor, const TouchEvent& touch) { - Actor parent( actor.GetParent() ); - if ( parent ) + Actor parent(actor.GetParent()); + if(parent) { - parent.Remove( actor ); + parent.Remove(actor); } - return TouchEventFunctor::operator()( actor, touchEvent ); + return TouchEventFunctor::operator()(actor, touch); + } +}; + +struct OutOfBoundsData +{ + TestPoint point; + bool functorCalled; + + OutOfBoundsData() + : functorCalled(false) + { } }; -Integration::TouchEvent GenerateSingleTouch( TouchPoint::State state, Vector2 screenPosition ) +// Functor that reads out of bounds data when called +struct OutOfBoundsFunctor +{ + /** + * Constructor. + * @param[in] data Reference to the data to store callback information. + * @param[in] returnValue What the functor should return. + */ + OutOfBoundsFunctor(OutOfBoundsData& data, bool returnValue = true) + : outOfBoundsData(data), + returnValue(returnValue) + { + } + + bool operator()(Actor actor, const TouchEvent& touch) + { + outOfBoundsData.functorCalled = true; + size_t count = touch.GetPointCount(); + + // Read out of bounds data + outOfBoundsData.point.deviceId = touch.GetDeviceId(count + 1); + outOfBoundsData.point.state = touch.GetState(count + 1); + outOfBoundsData.point.hitActor = touch.GetHitActor(count + 1); + outOfBoundsData.point.local = touch.GetLocalPosition(count + 1); + outOfBoundsData.point.screen = touch.GetScreenPosition(count + 1); + + return returnValue; + } + + OutOfBoundsData& outOfBoundsData; + bool returnValue; +}; + +Integration::TouchEvent GenerateSingleTouch(PointState::Type state, const Vector2& screenPosition) { Integration::TouchEvent touchEvent; - touchEvent.points.push_back( TouchPoint ( 0, state, screenPosition.x, screenPosition.y ) ); + Integration::Point point; + point.SetState(state); + point.SetScreenPosition(screenPosition); + point.SetDeviceClass(Device::Class::TOUCH); + point.SetDeviceSubclass(Device::Subclass::NONE); + touchEvent.points.push_back(point); return touchEvent; } -} // anon namespace +} // namespace /////////////////////////////////////////////////////////////////////////////// -int UtcDaliTouchNormalProcessing(void) +int UtcDaliTouchEventNormalProcessing01(void) { TestApplication application; Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); - // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + // Connect to actor's touch signal + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); - Vector2 screenCoordinates( 10.0f, 10.0f ); + Vector2 screenCoordinates(10.0f, 10.0f); Vector2 localCoordinates; - actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y ); + actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION ); - DALI_TEST_EQUALS( localCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates)); + const TestPoint* point1 = &data.receivedTouch.GetPoint(0); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, point1->state, TEST_LOCATION); + DALI_TEST_EQUALS(screenCoordinates, point1->screen, TEST_LOCATION); + DALI_TEST_EQUALS(localCoordinates, point1->local, 0.1f, TEST_LOCATION); data.Reset(); // Emit a motion signal screenCoordinates.x = screenCoordinates.y = 11.0f; - actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, screenCoordinates ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Motion, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION ); - DALI_TEST_EQUALS( localCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION ); + actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, screenCoordinates)); + const TestPoint* point2 = &data.receivedTouch.GetPoint(0); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION); + DALI_TEST_EQUALS(PointState::MOTION, point2->state, TEST_LOCATION); + DALI_TEST_EQUALS(screenCoordinates, point2->screen, TEST_LOCATION); + DALI_TEST_EQUALS(localCoordinates, point2->local, 0.1f, TEST_LOCATION); data.Reset(); // Emit an up signal screenCoordinates.x = screenCoordinates.y = 12.0f; - actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Up, screenCoordinates ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Up, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION ); - DALI_TEST_EQUALS( localCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION ); + actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y); + application.ProcessEvent(GenerateSingleTouch(PointState::UP, screenCoordinates)); + const TestPoint* point3 = &data.receivedTouch.GetPoint(0); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION); + DALI_TEST_EQUALS(PointState::UP, point3->state, TEST_LOCATION); + DALI_TEST_EQUALS(screenCoordinates, point3->screen, TEST_LOCATION); + DALI_TEST_EQUALS(localCoordinates, point3->local, 0.1f, TEST_LOCATION); data.Reset(); // Emit a down signal where the actor is not present screenCoordinates.x = screenCoordinates.y = 200.0f; - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates)); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + END_TEST; +} + +int UtcDaliTouchEventNormalProcessing02(void) +{ + TestApplication application; + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); + + // Render and notify + application.SendNotification(); + application.Render(); + + // Connect to actor's touched signal + HandleData handleData; + TouchEventHandleFunctor functor(handleData); + actor.TouchedSignal().Connect(&application, functor); + + Vector2 screenCoordinates(10.0f, 10.0f); + Vector2 localCoordinates; + actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y); + + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates)); + DALI_TEST_EQUALS(true, handleData.signalReceived, TEST_LOCATION); + DALI_TEST_EQUALS(1u, handleData.receivedTouchHandle.GetPointCount(), TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, handleData.receivedTouchHandle.GetState(0), TEST_LOCATION); + DALI_TEST_EQUALS(screenCoordinates, handleData.receivedTouchHandle.GetScreenPosition(0), TEST_LOCATION); + DALI_TEST_EQUALS(localCoordinates, handleData.receivedTouchHandle.GetLocalPosition(0), 0.1f, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliTouchEventAPINegative(void) +{ + TestApplication application; + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); + + // Render and notify + application.SendNotification(); + application.Render(); + + // Connect to actor's touched signal + OutOfBoundsData data; + OutOfBoundsFunctor functor(data, true); + actor.TouchedSignal().Connect(&application, functor); + + Vector2 screenCoordinates(10.0f, 10.0f); + Vector2 localCoordinates; + actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y); + + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates)); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(-1, data.point.deviceId, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::FINISHED, data.point.state, TEST_LOCATION); + DALI_TEST_EQUALS(Vector2::ZERO, data.point.screen, TEST_LOCATION); + DALI_TEST_EQUALS(Vector2::ZERO, data.point.local, 0.1f, TEST_LOCATION); + DALI_TEST_CHECK(!data.point.hitActor); + END_TEST; } -int UtcDaliTouchOutsideCameraNearFarPlanes(void) +int UtcDaliTouchEventOutsideCameraNearFarPlanes(void) { TestApplication application; - Stage stage = Stage::GetCurrent(); - Vector2 stageSize = stage.GetSize(); + Integration::Scene scene = application.GetScene(); + Vector2 sceneSize = scene.GetSize(); Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::CENTER); - actor.SetParentOrigin(ParentOrigin::CENTER); - stage.Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); + actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); + scene.Add(actor); // Render and notify application.SendNotification(); application.Render(); // Get the camera's near and far planes - RenderTaskList taskList = stage.GetRenderTaskList(); - Dali::RenderTask task = taskList.GetTask(0); - CameraActor camera = task.GetCameraActor(); - float nearPlane = camera.GetNearClippingPlane(); - float farPlane = camera.GetFarClippingPlane(); + RenderTaskList taskList = scene.GetRenderTaskList(); + Dali::RenderTask task = taskList.GetTask(0); + CameraActor camera = task.GetCameraActor(); + float nearPlane = camera.GetNearClippingPlane(); + float farPlane = camera.GetFarClippingPlane(); // Calculate the current distance of the actor from the camera float tanHalfFov = tanf(camera.GetFieldOfView() * 0.5f); - float distance = (stageSize.y * 0.5f) / tanHalfFov; + float distance = (sceneSize.y * 0.5f) / tanHalfFov; // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); - Vector2 screenCoordinates( stageSize.x * 0.5f, stageSize.y * 0.5f ); + Vector2 screenCoordinates(sceneSize.x * 0.5f, sceneSize.y * 0.5f); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates)); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); // Emit a down signal where actor is just at the camera's near plane - actor.SetZ(distance - nearPlane); + actor.SetProperty(Actor::Property::POSITION_Z, distance - nearPlane); // Render and notify application.SendNotification(); application.Render(); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates)); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); // Emit a down signal where actor is closer than the camera's near plane - actor.SetZ((distance - nearPlane) + 1.0f); + actor.SetProperty(Actor::Property::POSITION_Z, (distance - nearPlane) + 1.0f); // Render and notify application.SendNotification(); application.Render(); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates)); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); // Emit a down signal where actor is just at the camera's far plane - actor.SetZ(distance - farPlane); + actor.SetProperty(Actor::Property::POSITION_Z, distance - farPlane); // Render and notify application.SendNotification(); application.Render(); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates)); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); // Emit a down signal where actor is further than the camera's far plane - actor.SetZ((distance - farPlane) - 1.0f); + actor.SetProperty(Actor::Property::POSITION_Z, (distance - farPlane) - 1.0f); // Render and notify application.SendNotification(); application.Render(); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates)); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); END_TEST; } -int UtcDaliTouchEmitEmpty(void) +int UtcDaliTouchEventEmitEmpty(void) { TestApplication application; @@ -282,209 +496,209 @@ int UtcDaliTouchEmitEmpty(void) { // Emit an empty TouchEvent Integration::TouchEvent event; - application.ProcessEvent( event ); - tet_result( TET_FAIL ); + application.ProcessEvent(event); + tet_result(TET_FAIL); } - catch ( Dali::DaliException& e ) + catch(Dali::DaliException& e) { - DALI_TEST_ASSERT( e, "!event.points.empty()", TEST_LOCATION ); + DALI_TEST_ASSERT(e, "!event.points.empty()", TEST_LOCATION); } END_TEST; } -int UtcDaliTouchInterrupted(void) +int UtcDaliTouchEventInterrupted(void) { TestApplication application; Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); data.Reset(); // Emit an interrupted signal, we should be signalled regardless of whether there is a hit or not. - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f /* Outside actor */))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION); data.Reset(); // Emit another interrupted signal, our signal handler should not be called. - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); END_TEST; } -int UtcDaliTouchParentConsumer(void) +int UtcDaliTouchEventParentConsumer(void) { TestApplication application; - Actor rootActor( Stage::GetCurrent().GetRootLayer() ); + Actor rootActor(application.GetScene().GetRootLayer()); Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data, false ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data, false); + actor.TouchedSignal().Connect(&application, functor); // Connect to root actor's touched signal - SignalData rootData; - TouchEventFunctor rootFunctor( rootData ); // Consumes signal - rootActor.TouchedSignal().Connect( &application, rootFunctor ); + SignalData rootData; + TouchEventFunctor rootFunctor(rootData); // Consumes signal + rootActor.TouchedSignal().Connect(&application, rootFunctor); - Vector2 screenCoordinates( 10.0f, 10.0f ); + Vector2 screenCoordinates(10.0f, 10.0f); Vector2 actorCoordinates, rootCoordinates; - actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y ); - rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y ); + actor.ScreenToLocal(actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y); + rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION ); - DALI_TEST_EQUALS( 1u, rootData.touchEvent.GetPointCount(), TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION ); - DALI_TEST_EQUALS( screenCoordinates, rootData.touchEvent.points[0].screen, TEST_LOCATION ); - DALI_TEST_EQUALS( actorCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION ); - DALI_TEST_EQUALS( rootCoordinates, rootData.touchEvent.points[0].local, 0.1f, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates)); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION); + DALI_TEST_EQUALS(1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION); + DALI_TEST_EQUALS(screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION); + DALI_TEST_EQUALS(actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION); + DALI_TEST_EQUALS(rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor); data.Reset(); rootData.Reset(); // Emit a motion signal screenCoordinates.x = screenCoordinates.y = 11.0f; - actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y ); - rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, screenCoordinates ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION ); - DALI_TEST_EQUALS( 1u, rootData.touchEvent.GetPointCount(), TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Motion, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Motion, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION ); - DALI_TEST_EQUALS( screenCoordinates, rootData.touchEvent.points[0].screen, TEST_LOCATION ); - DALI_TEST_EQUALS( actorCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION ); - DALI_TEST_EQUALS( rootCoordinates, rootData.touchEvent.points[0].local, 0.1f, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor ); + actor.ScreenToLocal(actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y); + rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, screenCoordinates)); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION); + DALI_TEST_EQUALS(1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION); + DALI_TEST_EQUALS(PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION); + DALI_TEST_EQUALS(screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION); + DALI_TEST_EQUALS(actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION); + DALI_TEST_EQUALS(rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor); data.Reset(); rootData.Reset(); // Emit an up signal screenCoordinates.x = screenCoordinates.y = 12.0f; - actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y ); - rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Up, screenCoordinates ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION ); - DALI_TEST_EQUALS( 1u, rootData.touchEvent.GetPointCount(), TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Up, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Up, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION ); - DALI_TEST_EQUALS( screenCoordinates, rootData.touchEvent.points[0].screen, TEST_LOCATION ); - DALI_TEST_EQUALS( actorCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION ); - DALI_TEST_EQUALS( rootCoordinates, rootData.touchEvent.points[0].local, 0.1f, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor ); + actor.ScreenToLocal(actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y); + rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y); + application.ProcessEvent(GenerateSingleTouch(PointState::UP, screenCoordinates)); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION); + DALI_TEST_EQUALS(1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION); + DALI_TEST_EQUALS(PointState::UP, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::UP, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION); + DALI_TEST_EQUALS(screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION); + DALI_TEST_EQUALS(actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION); + DALI_TEST_EQUALS(rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor); data.Reset(); rootData.Reset(); // Emit a down signal where the actor is not present, will hit the root actor though screenCoordinates.x = screenCoordinates.y = 200.0f; - rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( 1u, rootData.touchEvent.GetPointCount(), TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( screenCoordinates, rootData.touchEvent.points[0].screen, TEST_LOCATION ); - DALI_TEST_EQUALS( rootCoordinates, rootData.touchEvent.points[0].local, 0.1f, TEST_LOCATION ); - DALI_TEST_CHECK( rootActor == rootData.touchEvent.points[0].hitActor ); + rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates)); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION); + DALI_TEST_EQUALS(rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION); + DALI_TEST_CHECK(rootActor == rootData.receivedTouch.points[0].hitActor); END_TEST; } -int UtcDaliTouchInterruptedParentConsumer(void) +int UtcDaliTouchEventInterruptedParentConsumer(void) { TestApplication application; - Actor rootActor( Stage::GetCurrent().GetRootLayer() ); + Actor rootActor(application.GetScene().GetRootLayer()); Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data, false ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data, false); + actor.TouchedSignal().Connect(&application, functor); // Connect to root actor's touched signal - SignalData rootData; - TouchEventFunctor rootFunctor( rootData ); // Consumes signal - rootActor.TouchedSignal().Connect( &application, rootFunctor ); + SignalData rootData; + TouchEventFunctor rootFunctor(rootData); // Consumes signal + rootActor.TouchedSignal().Connect(&application, rootFunctor); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor); data.Reset(); rootData.Reset(); // Emit an interrupted signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor ); + application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor); data.Reset(); rootData.Reset(); // Emit another down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION); data.Reset(); rootData.Reset(); - // Remove actor from Stage - Stage::GetCurrent().Remove( actor ); + // Remove actor from scene + application.GetScene().Remove(actor); data.Reset(); rootData.Reset(); @@ -493,224 +707,224 @@ int UtcDaliTouchInterruptedParentConsumer(void) application.Render(); // Emit an interrupted signal, only root actor's signal should be called. - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( rootActor == rootData.touchEvent.points[0].hitActor ); + application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f /* Outside actor */))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(rootActor == rootData.receivedTouch.points[0].hitActor); data.Reset(); rootData.Reset(); // Emit another interrupted state, none of the signal's should be called. - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( false, rootData.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(false, rootData.functorCalled, TEST_LOCATION); END_TEST; } -int UtcDaliTouchLeave(void) +int UtcDaliTouchEventLeave(void) { TestApplication application; Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); // Set actor to require leave events - actor.SetLeaveRequired( true ); + actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); data.Reset(); // Emit a motion signal outside of actor, should be signalled with a Leave - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Leave, data.touchEvent.points[0].state, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION); data.Reset(); // Another motion outside of actor, no signalling - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 201.0f, 201.0f )) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(201.0f, 201.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); // Another motion event inside actor, signalled with motion - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 10.0f, 10.0f )) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Motion, data.touchEvent.points[0].state, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION); data.Reset(); // We do not want to listen to leave events anymore - actor.SetLeaveRequired( false ); + actor.SetProperty(Actor::Property::LEAVE_REQUIRED, false); // Another motion event outside of actor, no signalling - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); END_TEST; } -int UtcDaliTouchLeaveParentConsumer(void) +int UtcDaliTouchEventLeaveParentConsumer(void) { TestApplication application; - Actor rootActor( Stage::GetCurrent().GetRootLayer() ); + Actor rootActor(application.GetScene().GetRootLayer()); Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data, false ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data, false); + actor.TouchedSignal().Connect(&application, functor); // Connect to root actor's touched signal - SignalData rootData; - TouchEventFunctor rootFunctor( rootData ); // Consumes signal - rootActor.TouchedSignal().Connect( &application, rootFunctor ); + SignalData rootData; + TouchEventFunctor rootFunctor(rootData); // Consumes signal + rootActor.TouchedSignal().Connect(&application, rootFunctor); // Set actor to require leave events - actor.SetLeaveRequired( true ); - rootActor.SetLeaveRequired( true ); + actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true); + rootActor.SetProperty(Actor::Property::LEAVE_REQUIRED, true); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor); data.Reset(); rootData.Reset(); // Emit a motion signal outside of actor, should be signalled with a Leave - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Leave, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Leave, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::LEAVE, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor); data.Reset(); rootData.Reset(); // Another motion outside of actor, only rootActor signalled - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 201.0f, 201.0f )) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Motion, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( rootActor == rootData.touchEvent.points[0].hitActor ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(201.0f, 201.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(rootActor == rootData.receivedTouch.points[0].hitActor); data.Reset(); rootData.Reset(); // Another motion event inside actor, signalled with motion - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 10.0f, 10.0f )) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Motion, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Motion, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor); data.Reset(); rootData.Reset(); // We do not want to listen to leave events of actor anymore - actor.SetLeaveRequired( false ); + actor.SetProperty(Actor::Property::LEAVE_REQUIRED, false); // Another motion event outside of root actor, only root signalled - Vector2 stageSize( Stage::GetCurrent().GetSize() ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( stageSize.width + 10.0f, stageSize.height + 10.0f )) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Leave, rootData.touchEvent.points[0].state, TEST_LOCATION ); + Vector2 sceneSize(application.GetScene().GetSize()); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(sceneSize.width + 10.0f, sceneSize.height + 10.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::LEAVE, rootData.receivedTouch.points[0].state, TEST_LOCATION); END_TEST; } -int UtcDaliTouchActorBecomesInsensitive(void) +int UtcDaliTouchEventActorBecomesInsensitive(void) { TestApplication application; Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); data.Reset(); // Change actor to insensitive - actor.SetSensitive( false ); + actor.SetProperty(Actor::Property::SENSITIVE, false); // Emit a motion signal, signalled with an interrupted - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION); data.Reset(); END_TEST; } -int UtcDaliTouchActorBecomesInsensitiveParentConsumer(void) +int UtcDaliTouchEventActorBecomesInsensitiveParentConsumer(void) { TestApplication application; - Actor rootActor( Stage::GetCurrent().GetRootLayer() ); + Actor rootActor(application.GetScene().GetRootLayer()); Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data, false ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data, false); + actor.TouchedSignal().Connect(&application, functor); // Connect to root actor's touched signal - SignalData rootData; - TouchEventFunctor rootFunctor( rootData ); // Consumes signal - rootActor.TouchedSignal().Connect( &application, rootFunctor ); + SignalData rootData; + TouchEventFunctor rootFunctor(rootData); // Consumes signal + rootActor.TouchedSignal().Connect(&application, rootFunctor); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor); data.Reset(); rootData.Reset(); @@ -719,295 +933,295 @@ int UtcDaliTouchActorBecomesInsensitiveParentConsumer(void) application.Render(); // Make root actor insensitive - rootActor.SetSensitive( false ); + rootActor.SetProperty(Actor::Property::SENSITIVE, false); // Emit a motion signal, signalled with an interrupted (should get interrupted even if within root actor) - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, rootData.touchEvent.points[0].state, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION); END_TEST; } -int UtcDaliTouchMultipleLayers(void) +int UtcDaliTouchEventMultipleLayers(void) { TestApplication application; - Actor rootActor( Stage::GetCurrent().GetRootLayer() ); + Actor rootActor(application.GetScene().GetRootLayer()); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); + SignalData data; + TouchEventFunctor functor(data); - Layer layer1 ( Layer::New() ); - layer1.SetSize(100.0f, 100.0f); - layer1.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add( layer1 ); + Layer layer1(Layer::New()); + layer1.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + layer1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(layer1); - Actor actor1 ( Actor::New() ); - actor1.SetSize( 100.0f, 100.0f ); - actor1.SetAnchorPoint(AnchorPoint::TOP_LEFT); - actor1.SetZ( 1.0f ); // Should hit actor1 in this layer - layer1.Add( actor1 ); + Actor actor1(Actor::New()); + actor1.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor1.SetProperty(Actor::Property::POSITION_Z, 1.0f); // Should hit actor1 in this layer + layer1.Add(actor1); // Render and notify application.SendNotification(); application.Render(); // Connect to layer1 and actor1 - layer1.TouchedSignal().Connect( &application, functor ); - actor1.TouchedSignal().Connect( &application, functor ); + layer1.TouchedSignal().Connect(&application, functor); + actor1.TouchedSignal().Connect(&application, functor); // Hit in hittable area, actor1 should be hit - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_CHECK( data.touchedActor == actor1 ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(data.touchedActor == actor1); data.Reset(); // Make layer1 insensitive, nothing should be hit - layer1.SetSensitive( false ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + layer1.SetProperty(Actor::Property::SENSITIVE, false); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); // Make layer1 sensitive again, again actor1 will be hit - layer1.SetSensitive( true ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_CHECK( data.touchedActor == actor1 ); + layer1.SetProperty(Actor::Property::SENSITIVE, true); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(data.touchedActor == actor1); data.Reset(); // Make rootActor insensitive, nothing should be hit - rootActor.SetSensitive( false ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + rootActor.SetProperty(Actor::Property::SENSITIVE, false); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); // Make rootActor sensitive - rootActor.SetSensitive( true ); + rootActor.SetProperty(Actor::Property::SENSITIVE, true); // Add another layer - Layer layer2 ( Layer::New() ); - layer2.SetSize(100.0f, 100.0f ); - layer2.SetAnchorPoint(AnchorPoint::TOP_LEFT); - layer2.SetZ( 10.0f ); // Should hit layer2 in this layer rather than actor2 - Stage::GetCurrent().Add( layer2 ); + Layer layer2(Layer::New()); + layer2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + layer2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + layer2.SetProperty(Actor::Property::POSITION_Z, 10.0f); // Should hit layer2 in this layer rather than actor2 + application.GetScene().Add(layer2); - Actor actor2 ( Actor::New() ); - actor2.SetSize(100.0f, 100.0f); - actor2.SetAnchorPoint(AnchorPoint::TOP_LEFT); - layer2.Add( actor2 ); + Actor actor2(Actor::New()); + actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + layer2.Add(actor2); // Render and notify application.SendNotification(); application.Render(); // Connect to layer2 and actor2 - layer2.TouchedSignal().Connect( &application, functor ); - actor2.TouchedSignal().Connect( &application, functor ); + layer2.TouchedSignal().Connect(&application, functor); + actor2.TouchedSignal().Connect(&application, functor); // Emit an event, should hit layer2 - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); //DALI_TEST_CHECK( data.touchedActor == layer2 ); // TODO: Uncomment this after removing renderable hack! data.Reset(); // Make layer2 insensitive, should hit actor1 - layer2.SetSensitive( false ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_CHECK( data.touchedActor == actor1 ); + layer2.SetProperty(Actor::Property::SENSITIVE, false); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(data.touchedActor == actor1); data.Reset(); // Make layer2 sensitive again, should hit layer2 - layer2.SetSensitive( true ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + layer2.SetProperty(Actor::Property::SENSITIVE, true); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); //DALI_TEST_CHECK( data.touchedActor == layer2 ); // TODO: Uncomment this after removing renderable hack! data.Reset(); // Make layer2 invisible, render and notify - layer2.SetVisible( false ); + layer2.SetProperty(Actor::Property::VISIBLE, false); application.SendNotification(); application.Render(); // Should hit actor1 - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_CHECK( data.touchedActor == actor1 ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(data.touchedActor == actor1); data.Reset(); // Make rootActor invisible, render and notify - rootActor.SetVisible( false ); + rootActor.SetProperty(Actor::Property::VISIBLE, false); application.SendNotification(); application.Render(); // Should not hit anything - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); END_TEST; } -int UtcDaliTouchMultipleRenderTasks(void) +int UtcDaliTouchEventMultipleRenderTasks(void) { - TestApplication application; - Stage stage ( Stage::GetCurrent() ); - Vector2 stageSize ( stage.GetSize() ); + TestApplication application; + Integration::Scene scene(application.GetScene()); + Vector2 sceneSize(scene.GetSize()); Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stage.Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + scene.Add(actor); // Create render task - Viewport viewport( stageSize.width * 0.5f, stageSize.height * 0.5f, stageSize.width * 0.5f, stageSize.height * 0.5f ); - RenderTask renderTask ( Stage::GetCurrent().GetRenderTaskList().CreateTask() ); - renderTask.SetViewport( viewport ); - renderTask.SetInputEnabled( true ); + Viewport viewport(sceneSize.width * 0.5f, sceneSize.height * 0.5f, sceneSize.width * 0.5f, sceneSize.height * 0.5f); + RenderTask renderTask(application.GetScene().GetRenderTaskList().CreateTask()); + renderTask.SetViewport(viewport); + renderTask.SetInputEnabled(true); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); // Ensure renderTask actor can be hit too. - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(viewport.x + 5.0f, viewport.y + 5.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); // Disable input on renderTask, should not be hittable - renderTask.SetInputEnabled( false ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + renderTask.SetInputEnabled(false); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(viewport.x + 5.0f, viewport.y + 5.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); END_TEST; } -int UtcDaliTouchMultipleRenderTasksWithChildLayer(void) +int UtcDaliTouchEventMultipleRenderTasksWithChildLayer(void) { - TestApplication application; - Stage stage ( Stage::GetCurrent() ); - Vector2 stageSize ( stage.GetSize() ); + TestApplication application; + Integration::Scene scene(application.GetScene()); + Vector2 sceneSize(scene.GetSize()); Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stage.Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + scene.Add(actor); Layer layer = Layer::New(); - layer.SetSize(100.0f, 100.0f); - layer.SetAnchorPoint(AnchorPoint::TOP_LEFT); + layer.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); actor.Add(layer); // Create render task - Viewport viewport( stageSize.width * 0.5f, stageSize.height * 0.5f, stageSize.width * 0.5f, stageSize.height * 0.5f ); - RenderTask renderTask ( Stage::GetCurrent().GetRenderTaskList().CreateTask() ); - renderTask.SetViewport( viewport ); - renderTask.SetInputEnabled( true ); - renderTask.SetSourceActor( actor ); + Viewport viewport(sceneSize.width * 0.5f, sceneSize.height * 0.5f, sceneSize.width * 0.5f, sceneSize.height * 0.5f); + RenderTask renderTask(application.GetScene().GetRenderTaskList().CreateTask()); + renderTask.SetViewport(viewport); + renderTask.SetInputEnabled(true); + renderTask.SetSourceActor(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to layer's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); - layer.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); + layer.TouchedSignal().Connect(&application, functor); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); // Ensure renderTask actor can be hit too. - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(viewport.x + 5.0f, viewport.y + 5.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); // Disable input on renderTask, should not be hittable - renderTask.SetInputEnabled( false ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + renderTask.SetInputEnabled(false); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(viewport.x + 5.0f, viewport.y + 5.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); END_TEST; } -int UtcDaliTouchOffscreenRenderTasks(void) +int UtcDaliTouchEventOffscreenRenderTasks(void) { - TestApplication application; - Stage stage ( Stage::GetCurrent() ); - Vector2 stageSize ( stage.GetSize() ); + TestApplication application; + Integration::Scene scene(application.GetScene()); + Vector2 sceneSize(scene.GetSize()); // FrameBufferImage for offscreen RenderTask - FrameBufferImage frameBufferImage( FrameBufferImage::New( stageSize.width, stageSize.height, Pixel::RGBA8888 ) ); + FrameBuffer frameBuffer = FrameBuffer::New(sceneSize.width, sceneSize.height); - // Create an image actor to display the FrameBufferImage - ImageActor imageActor ( ImageActor::New( frameBufferImage ) ); - imageActor.SetParentOrigin(ParentOrigin::CENTER); - imageActor.SetSize( stageSize.x, stageSize.y ); - imageActor.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME - stage.Add( imageActor ); + // Create a renderable actor to display the FrameBufferImage + Actor renderableActor = CreateRenderableActor(frameBuffer.GetColorTexture()); + renderableActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); + renderableActor.SetProperty(Actor::Property::SIZE, Vector2(sceneSize.x, sceneSize.y)); + renderableActor.ScaleBy(Vector3(1.0f, -1.0f, 1.0f)); // FIXME + scene.Add(renderableActor); Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stage.Add( actor ); - application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE ); // Ensure framebuffer connects + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + scene.Add(actor); + application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE); // Ensure framebuffer connects - stage.GetRenderTaskList().GetTask( 0u ).SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION ); + scene.GetRenderTaskList().GetTask(0u).SetScreenToFrameBufferFunction(RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION); // Create a RenderTask - RenderTask renderTask = stage.GetRenderTaskList().CreateTask(); - renderTask.SetSourceActor( actor ); - renderTask.SetTargetFrameBuffer( frameBufferImage ); - renderTask.SetInputEnabled( true ); + RenderTask renderTask = scene.GetRenderTaskList().CreateTask(); + renderTask.SetSourceActor(actor); + renderTask.SetFrameBuffer(frameBuffer); + renderTask.SetInputEnabled(true); // Create another RenderTask - RenderTask renderTask2( stage.GetRenderTaskList().CreateTask() ); - renderTask2.SetInputEnabled( true ); + RenderTask renderTask2(scene.GetRenderTaskList().CreateTask()); + renderTask2.SetInputEnabled(true); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); END_TEST; } -int UtcDaliTouchMultipleRenderableActors(void) +int UtcDaliTouchEventMultipleRenderableActors(void) { - TestApplication application; - Stage stage ( Stage::GetCurrent() ); - Vector2 stageSize ( stage.GetSize() ); - - Actor parent = ImageActor::New(); - parent.SetSize(100.0f, 100.0f); - parent.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stage.Add(parent); - - Actor actor = ImageActor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); + TestApplication application; + Integration::Scene scene(application.GetScene()); + Vector2 sceneSize(scene.GetSize()); + + Actor parent = CreateRenderableActor(); + parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + scene.Add(parent); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); parent.Add(actor); // Render and notify @@ -1015,57 +1229,57 @@ int UtcDaliTouchMultipleRenderableActors(void) application.Render(); // Connect to layer's touched signal - SignalData data; - TouchEventFunctor functor( data ); - parent.TouchedSignal().Connect( &application, functor ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + parent.TouchedSignal().Connect(&application, functor); + actor.TouchedSignal().Connect(&application, functor); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchedActor ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.touchedActor); END_TEST; } -int UtcDaliTouchActorRemovedInSignal(void) +int UtcDaliTouchEventActorRemovedInSignal(void) { TestApplication application; Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - RemoveActorFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + RemoveActorFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); // Register for leave events - actor.SetLeaveRequired( true ); + actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); // Re-add, render and notify - Stage::GetCurrent().Add(actor); + application.GetScene().Add(actor); application.SendNotification(); application.Render(); // Emit another signal outside of actor's area, should not get anything as the scene has changed. - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 210.0f, 210.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(210.0f, 210.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); // Render and notify @@ -1073,78 +1287,78 @@ int UtcDaliTouchActorRemovedInSignal(void) application.Render(); // Emit another signal outside of actor's area, should not get anything as the scene has changed. - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 210.0f, 210.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(210.0f, 210.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); - // Re-add actor back to stage, render and notify - Stage::GetCurrent().Add(actor); + // Re-add actor back to scene, render and notify + application.GetScene().Add(actor); application.SendNotification(); application.Render(); // Emit another down event - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); // Completely delete the actor actor.Reset(); // Emit event, should not crash and should not receive an event. - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 210.0f, 210.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(210.0f, 210.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); END_TEST; } -int UtcDaliTouchActorSignalNotConsumed(void) +int UtcDaliTouchEventActorSignalNotConsumed(void) { TestApplication application; Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data, false ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data, false); + actor.TouchedSignal().Connect(&application, functor); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); END_TEST; } -int UtcDaliTouchActorUnStaged(void) +int UtcDaliTouchEventActorRemovedFromScene(void) { TestApplication application; Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); - // Remove actor from stage - Stage::GetCurrent().Remove( actor ); + // Remove actor from scene + application.GetScene().Remove(actor); data.Reset(); // Render and notify @@ -1152,71 +1366,35 @@ int UtcDaliTouchActorUnStaged(void) application.Render(); // Emit a move at the same point, we should not be signalled. - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); END_TEST; } -int UtcDaliTouchSystemOverlayActor(void) +int UtcDaliTouchEventLayerConsumesTouch(void) { TestApplication application; - Dali::Integration::Core& core( application.GetCore() ); - Dali::Integration::SystemOverlay& systemOverlay( core.GetSystemOverlay() ); - systemOverlay.GetOverlayRenderTasks().CreateTask(); - // Create an actor and add it to the system overlay. - Actor systemActor = Actor::New(); - systemActor.SetSize(100.0f, 100.0f); - systemActor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - systemOverlay.Add( systemActor ); - - // Create an actor and add it to the stage as per normal, same position and size as systemActor Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); - - // Connect to the touch signals. - SignalData data; - TouchEventFunctor functor( data ); - systemActor.TouchedSignal().Connect( &application, functor ); - actor.TouchedSignal().Connect( &application, functor ); - - // Render and notify - application.SendNotification(); - application.Render(); - - // Emit a down signal, the system overlay is drawn last so is at the top, should hit the systemActor. - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_CHECK( systemActor == data.touchedActor ); - END_TEST; -} - -int UtcDaliTouchLayerConsumesTouch(void) -{ - TestApplication application; - - Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); // Add a layer to overlap the actor Layer layer = Layer::New(); - layer.SetSize(100.0f, 100.0f); - layer.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add( layer ); + layer.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(layer); layer.RaiseToTop(); // Render and notify @@ -1224,471 +1402,686 @@ int UtcDaliTouchLayerConsumesTouch(void) application.Render(); // Emit a few touch signals - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Up, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); // Set layer to consume all touch - layer.SetTouchConsumed( true ); + layer.SetProperty(Layer::Property::CONSUMES_TOUCH, true); // Render and notify application.SendNotification(); application.Render(); // Emit the same signals again, should not receive - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Up, Vector2( 10.0f, 10.0f ) ) ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(10.0f, 10.0f))); DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); data.Reset(); END_TEST; } -int UtcDaliTouchLeaveActorReadded(void) +int UtcDaliTouchEventLeaveActorReadded(void) { - TestApplication application; - Stage stage = Stage::GetCurrent(); + TestApplication application; + Integration::Scene scene = application.GetScene(); Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stage.Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + scene.Add(actor); // Set actor to receive touch-events - actor.SetLeaveRequired( true ); + actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); // Emit a down and motion - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 11.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(11.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); - // Remove actor from stage and add again - stage.Remove( actor ); - stage.Add( actor ); + // Remove actor from scene and add again + scene.Remove(actor); + scene.Add(actor); // Emit a motion within the actor's bounds - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 12.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(12.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); // Emit a motion outside the actor's bounds - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 200.0f, 200.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Leave, data.touchEvent.points[0].state, TEST_LOCATION ); + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION); data.Reset(); END_TEST; } -int UtcDaliTouchStencil(void) +int UtcDaliTouchEventClippedActor(void) { - TestApplication application; - Stage stage = Stage::GetCurrent(); + TestApplication application; + Integration::Scene scene = application.GetScene(); + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + scene.Add(actor); + + Actor clippingActor = Actor::New(); + clippingActor.SetProperty(Actor::Property::SIZE, Vector2(50.0f, 50.0f)); + clippingActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + clippingActor.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN); + scene.Add(clippingActor); + + // Add a child to the clipped region. + Actor clippingChild = Actor::New(); + clippingChild.SetProperty(Actor::Property::SIZE, Vector2(50.0f, 50.0f)); + clippingChild.SetProperty(Actor::Property::POSITION, Vector2(25.0f, 25.0f)); + clippingChild.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + clippingActor.Add(clippingChild); + + // Render and notify. + application.SendNotification(); + application.Render(); - ImageActor actor = ImageActor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stage.Add(actor); + // Connect to actor's touch signal. + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); + + // Emit an event within clipped area - no hit. + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + data.Reset(); + + // Emit an event outside the clipped area but within the actor area, we should have a hit. + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(60.0f, 60.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + data.Reset(); - Actor stencil = Actor::New(); - stencil.SetSize(50.0f, 50.0f); - stencil.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stencil.SetDrawMode( DrawMode::STENCIL ); - stage.Add(stencil); + clippingChild.TouchedSignal().Connect(&application, functor); + + // Emit an event inside part of the child which is within the clipped area, we should have a hit. + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(30.0f, 30.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + data.Reset(); + + END_TEST; +} + +int UtcDaliTouchEventActorUnparented(void) +{ + TestApplication application; + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); - // Emit an event within stencil area - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); data.Reset(); - // Emit an event outside the stencil area but within the actor area - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 60.0f, 60.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); - data.Reset(); + // Render and notify + application.SendNotification(); + application.Render(); + + // Unparent the actor + actor.Unparent(); + // Should receive an interrupted event + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION); END_TEST; } -int UtcDaliTouchStencilInActorHierarchy(void) +int UtcDaliTouchEventParentRemovedFromScene(void) { TestApplication application; - Stage stage = Stage::GetCurrent(); - ImageActor parent = ImageActor::New(); - parent.SetSize(100.0f, 100.0f); - parent.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stage.Add(parent); + Actor parent = Actor::New(); + parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(parent); - ImageActor child = ImageActor::New(); - child.SetSize(25.0f, 25.0f); - child.SetAnchorPoint(AnchorPoint::TOP_LEFT); - parent.Add(child); + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + parent.Add(actor); - Actor stencil = Actor::New(); - stencil.SetSize(50.0f, 50.0f); - stencil.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stencil.SetDrawMode( DrawMode::STENCIL ); - stage.Add(stencil); + // Render and notify + application.SendNotification(); + application.Render(); + + // Connect to actor's touched signal + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); + + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + data.Reset(); // Render and notify application.SendNotification(); application.Render(); - // Connect to touch signals - SignalData parentData; - parent.TouchedSignal().Connect( &application, TouchEventFunctor(parentData) ); - SignalData childData; - child.TouchedSignal().Connect( &application, TouchEventFunctor(childData) ); + // Unparent the parent of the touchable actor + parent.Unparent(); - // Emit an event within stencil area - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, childData.functorCalled, TEST_LOCATION ); - parentData.Reset(); - childData.Reset(); + // Should receive an interrupted event + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION); + END_TEST; +} - // Emit an event outside child area and within stencil area - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 40.0f, 40.0f ) ) ); - DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION ); - parentData.Reset(); - childData.Reset(); +int UtcDaliTouchEventActorRemovedFromSceneDifferentConsumer(void) +{ + TestApplication application; - // Emit an event outside stencil are but within parent area - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 60.0f, 60.0f ) ) ); - DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION ); - parentData.Reset(); - childData.Reset(); + Actor parent = Actor::New(); + parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(parent); + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + parent.Add(actor); - // Readd actor (so that stencil is the first child) - stage.Remove(parent); + // Render and notify application.SendNotification(); application.Render(); - stage.Add(parent); + + // Connect to actor's touched signal + SignalData data; + TouchEventFunctor functor(data, false /* Do not consume */); + actor.TouchedSignal().Connect(&application, functor); + + // Connect to parent's touched signal + SignalData parentData; + TouchEventFunctor parentFunctor(parentData); + parent.TouchedSignal().Connect(&application, parentFunctor); + + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(actor == data.touchedActor); + DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, parentData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == parentData.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(parent == parentData.touchedActor); + data.Reset(); + parentData.Reset(); + + // Render and notify application.SendNotification(); application.Render(); - // Redo hit in same area... + // Unparent the actor + actor.Unparent(); - // Emit an event within stencil area - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, childData.functorCalled, TEST_LOCATION ); + // Should receive an interrupted event for both actor & parent + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION); + data.Reset(); parentData.Reset(); - childData.Reset(); - // Emit an event outside child area and within stencil area - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 40.0f, 40.0f ) ) ); - DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION ); + // Readd actor to parent + parent.Add(actor); + + // Render and notify + application.SendNotification(); + application.Render(); + + // Emit a motion signal + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION); + data.Reset(); parentData.Reset(); - childData.Reset(); - // Emit an event outside stencil are but within parent area - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 60.0f, 60.0f ) ) ); - DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION ); + // Parent is now consumer, connect again to the touched signal of the actor so that it becomes the consumer + SignalData secondData; + TouchEventFunctor secondFunctor(secondData /* Consume */); + actor.TouchedSignal().Connect(&application, secondFunctor); + + // Unparent the actor + actor.Unparent(); + + // Should receive an interrupted event for both actor functors & the parent as well as it was last consumer + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, secondData.receivedTouch.points[0].state, TEST_LOCATION); + data.Reset(); parentData.Reset(); - childData.Reset(); + secondData.Reset(); END_TEST; } -int UtcDaliTouchMultipleStencils(void) +int UtcDaliTouchEventInterruptedDifferentConsumer(void) { TestApplication application; - Stage stage = Stage::GetCurrent(); - - ImageActor actor = ImageActor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stage.Add(actor); - - Actor stencil = Actor::New(); - stencil.SetSize(50.0f, 50.0f); - stencil.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stencil.SetDrawMode( DrawMode::STENCIL ); - stage.Add(stencil); - - Actor stencil2 = Actor::New(); - stencil2.SetSize(50.0f, 50.0f); - stencil2.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stencil2.SetDrawMode( DrawMode::STENCIL ); - stencil2.SetPosition(50.0f, 50.0f); - stage.Add(stencil2); + Actor rootActor(application.GetScene().GetRootLayer()); + + Actor parent = Actor::New(); + parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(parent); + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + parent.Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data, false /* Do not consume */); + actor.TouchedSignal().Connect(&application, functor); - // Emit an event within stencil area - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - data.Reset(); + // Connect to parent's touched signal + SignalData parentData; + TouchEventFunctor parentFunctor(parentData, false /* Do not consume */); + parent.TouchedSignal().Connect(&application, parentFunctor); + + // Connect to root's touched signal and consume + SignalData rootData; + TouchEventFunctor rootFunctor(rootData); + rootActor.TouchedSignal().Connect(&application, rootFunctor); - // Emit an event inside the second stencil area - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 60.0f, 60.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(actor == data.touchedActor); + DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, parentData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == parentData.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(parent == parentData.touchedActor); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(rootActor == rootData.touchedActor); data.Reset(); + parentData.Reset(); + rootData.Reset(); + + // Root is now consumer, connect to the touched signal of the parent so that it becomes the consumer + SignalData secondData; + TouchEventFunctor secondFunctor(secondData /* Consume */); + parent.TouchedSignal().Connect(&application, secondFunctor); - // Emit an event outside both stencil areas but within the actor area - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 60.0f ) ) ); - DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + // Emit an interrupted signal, all three should STILL be called + application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION); data.Reset(); + parentData.Reset(); + rootData.Reset(); END_TEST; } -int UtcDaliTouchStencilNonRenderableActor(void) +int UtcDaliTouchEventGetRadius(void) { TestApplication application; - Stage stage = Stage::GetCurrent(); Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stage.Add(actor); - - Actor stencil = Actor::New(); - stencil.SetSize(50.0f, 50.0f); - stencil.SetAnchorPoint(AnchorPoint::TOP_LEFT); - stencil.SetDrawMode( DrawMode::STENCIL ); - stage.Add(stencil); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); + + // Emit a down signal with an angle + Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)); + touchEvent.points[0].SetRadius(100.0f); + application.ProcessEvent(touchEvent); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(100.0f, data.receivedTouch.points[0].radius, TEST_LOCATION); + DALI_TEST_EQUALS(100.0f, data.receivedTouch.points[0].ellipseRadius.x, TEST_LOCATION); + DALI_TEST_EQUALS(100.0f, data.receivedTouch.points[0].ellipseRadius.y, TEST_LOCATION); - // Emit an event within stencil area - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - data.Reset(); + END_TEST; +} - // Emit an event outside the stencil area but within the actor area, we should have a hit! - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 60.0f, 60.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - data.Reset(); +int UtcDaliTouchEventGetEllipseRadius(void) +{ + TestApplication application; + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); + + // Render and notify + application.SendNotification(); + application.Render(); + + // Connect to actor's touched signal + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); + + // Emit a down signal with an angle + Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)); + touchEvent.points[0].SetRadius(100.0f, Vector2(20.0f, 10.0f)); + application.ProcessEvent(touchEvent); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(100.0f, data.receivedTouch.points[0].radius, TEST_LOCATION); + DALI_TEST_EQUALS(20.0f, data.receivedTouch.points[0].ellipseRadius.x, TEST_LOCATION); + DALI_TEST_EQUALS(10.0f, data.receivedTouch.points[0].ellipseRadius.y, TEST_LOCATION); END_TEST; } -int UtcDaliTouchActorUnstaged(void) +int UtcDaliTouchEventGetAngle(void) { TestApplication application; Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); + + // Emit a down signal with an angle + Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)); + touchEvent.points[0].SetAngle(Degree(90.0f)); + application.ProcessEvent(touchEvent); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(Degree(90.0f), data.receivedTouch.points[0].angle, TEST_LOCATION); - // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - data.Reset(); + END_TEST; +} + +int UtcDaliTouchEventGetPressure(void) +{ + TestApplication application; + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); - // Unparent the actor - actor.Unparent(); + // Connect to actor's touched signal + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); + + // Emit a down signal with an angle + Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)); + touchEvent.points[0].SetPressure(10.0f); + application.ProcessEvent(touchEvent); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_EQUALS(10.0f, data.receivedTouch.points[0].pressure, TEST_LOCATION); - // Should receive an interrupted event - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION ); END_TEST; } -int UtcDaliTouchParentUnstaged(void) +int UtcDaliTouchEventUsage(void) { TestApplication application; - Actor parent = Actor::New(); - parent.SetSize(100.0f, 100.0f); - parent.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(parent); - Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - parent.Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); - // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - data.Reset(); + // Emit a down signal with an angle + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliTouchEventGetDeviceAPINegative(void) +{ + TestApplication application; + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); - // Unparent the parent of the touchable actor - parent.Unparent(); + // Connect to actor's touched signal + HandleData handleData; + TouchEventHandleFunctor functor(handleData); + actor.TouchedSignal().Connect(&application, functor); - // Should receive an interrupted event - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION ); + Vector2 screenCoordinates(10.0f, 10.0f); + Vector2 localCoordinates; + actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y); + + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates)); + + TouchEvent data = handleData.receivedTouchHandle; + DALI_TEST_EQUALS(data.GetDeviceClass(-1), Device::Class::NONE, TEST_LOCATION); + DALI_TEST_EQUALS(data.GetDeviceSubclass(-1), Device::Subclass::NONE, TEST_LOCATION); END_TEST; } -int UtcDaliTouchActorUnstagedDifferentConsumer(void) +int UtcDaliTouchEventGetMouseButtonPositive(void) { TestApplication application; - Actor parent = Actor::New(); - parent.SetSize(100.0f, 100.0f); - parent.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(parent); - Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); - parent.Add(actor); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data, false /* Do not consume */ ); - actor.TouchedSignal().Connect( &application, functor ); + HandleData handleData; + TouchEventHandleFunctor functor(handleData); + actor.TouchedSignal().Connect(&application, functor); - // Connect to parent's touched signal - SignalData parentData; - TouchEventFunctor parentFunctor( parentData ); - parent.TouchedSignal().Connect( &application, parentFunctor ); + // Emit a down signal with MouseButton + Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)); + touchEvent.points[0].SetMouseButton(static_cast(3)); + application.ProcessEvent(touchEvent); - // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( actor == data.touchedActor ); - DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, parentData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == parentData.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( parent == parentData.touchedActor ); - data.Reset(); - parentData.Reset(); + TouchEvent data = handleData.receivedTouchHandle; + DALI_TEST_EQUALS(data.GetMouseButton(0), MouseButton::SECONDARY, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliTouchEventGetMouseButtonNagative(void) +{ + TestApplication application; + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); - // Unparent the actor - actor.Unparent(); + // Connect to actor's touched signal + HandleData handleData; + TouchEventHandleFunctor functor(handleData); + actor.TouchedSignal().Connect(&application, functor); - // Should receive an interrupted event for both actor & parent - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, parentData.touchEvent.points[0].state, TEST_LOCATION ); - data.Reset(); - parentData.Reset(); + // Emit a down signal with MouseButton + Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)); + touchEvent.points[0].SetMouseButton(static_cast(2)); + application.ProcessEvent(touchEvent); - // Readd actor to parent - parent.Add(actor); + TouchEvent data = handleData.receivedTouchHandle; + DALI_TEST_EQUALS(data.GetMouseButton(0), MouseButton::TERTIARY, TEST_LOCATION); + DALI_TEST_EQUALS(data.GetMouseButton(3), MouseButton::INVALID, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliTouchEventCapturePropertySet(void) +{ + TestApplication application; + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(actor); // Render and notify application.SendNotification(); application.Render(); - // Emit a motion signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION ); + // Connect to actor's touched signal + SignalData data; + TouchEventFunctor functor(data); + actor.TouchedSignal().Connect(&application, functor); + + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::STARTED, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); - parentData.Reset(); - // Parent is now consumer, connect again to the touched signal of the actor so that it becomes the consumer - SignalData secondData; - TouchEventFunctor secondFunctor( secondData /* Consume */ ); - actor.TouchedSignal().Connect( &application, secondFunctor ); + // Now motion outside of actor, we should not receive the event + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(110.0f, 110.0f))); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + data.Reset(); - // Unparent the actor - actor.Unparent(); + // Up event, should receive an interrupted + application.ProcessEvent(GenerateSingleTouch(PointState::FINISHED, Vector2(110.0f, 110.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(data.receivedTouch.GetPoint(0).state, PointState::INTERRUPTED, TEST_LOCATION); - // Should receive an interrupted event for both actor functors & the parent as well as it was last consumer - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, parentData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( true, secondData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, secondData.touchEvent.points[0].state, TEST_LOCATION ); + // Now set the capture property + actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, true); + + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::STARTED, Vector2(10.0f, 10.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); data.Reset(); - parentData.Reset(); - secondData.Reset(); + + // Now motion outside of actor, we now SHOULD receive the event + application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(110.0f, 110.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + data.Reset(); + + // Up event, we should receive it again, but as ended rather than interrupted + application.ProcessEvent(GenerateSingleTouch(PointState::FINISHED, Vector2(110.0f, 110.0f))); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(data.receivedTouch.GetPoint(0).state, PointState::FINISHED, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliTouchEventIntegNewTouchEvent(void) +{ + uint32_t timestamp = 92858u; + TouchPoint tp(1, PointState::STARTED, 34.4f, 123.89f, 5.0f, 7.0f); + Dali::TouchEvent touchEvent = Integration::NewTouchEvent(timestamp, tp); + + DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION); + DALI_TEST_EQUALS(touchEvent.GetState(0), PointState::STARTED, TEST_LOCATION); + DALI_TEST_EQUALS(touchEvent.GetLocalPosition(0), Vector2(5.0f, 7.0f), TEST_LOCATION); + DALI_TEST_EQUALS(touchEvent.GetScreenPosition(0), Vector2(34.4f, 123.89f), TEST_LOCATION); END_TEST; } -int UtcDaliTouchInterruptedDifferentConsumer(void) + +int UtcDaliTouchEventIntercept(void) { TestApplication application; - Actor rootActor( Stage::GetCurrent().GetRootLayer() ); Actor parent = Actor::New(); - parent.SetSize(100.0f, 100.0f); - parent.SetAnchorPoint(AnchorPoint::TOP_LEFT); - Stage::GetCurrent().Add(parent); + parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + application.GetScene().Add(parent); Actor actor = Actor::New(); - actor.SetSize(100.0f, 100.0f); - actor.SetAnchorPoint(AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); parent.Add(actor); // Render and notify @@ -1696,54 +2089,98 @@ int UtcDaliTouchInterruptedDifferentConsumer(void) application.Render(); // Connect to actor's touched signal - SignalData data; - TouchEventFunctor functor( data, false /* Do not consume */ ); - actor.TouchedSignal().Connect( &application, functor ); + SignalData data; + TouchEventFunctor functor(data, false /* Do not consume */); + actor.TouchedSignal().Connect(&application, functor); - // Connect to parent's touched signal - SignalData parentData; - TouchEventFunctor parentFunctor( parentData, false /* Do not consume */ ); - parent.TouchedSignal().Connect( &application, parentFunctor ); - // Connect to root's touched signal and consume - SignalData rootData; - TouchEventFunctor rootFunctor( rootData ); - rootActor.TouchedSignal().Connect( &application, rootFunctor ); + // Connect to parent's touched signal + SignalData parentData; + TouchEventFunctor parentFunctor(parentData, false /* Do not consume */); + parent.TouchedSignal().Connect(&application, parentFunctor); + // Connect to parent's intercept touched signal + SignalData interceptData; + TouchEventFunctor interceptFunctor(interceptData, true /* Do intercept */); + Dali::DevelActor::InterceptTouchedSignal(parent).Connect(&application, interceptFunctor); // Emit a down signal - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( actor == data.touchedActor ); - DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, parentData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == parentData.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( parent == parentData.touchedActor ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor ); - DALI_TEST_CHECK( rootActor == rootData.touchedActor ); + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f))); + // The actor touched signal is not called because the touch is intercepted in the parent. + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, interceptData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == interceptData.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(parent == interceptData.touchedActor); + DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, parentData.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == parentData.receivedTouch.points[0].hitActor); + DALI_TEST_CHECK(parent == parentData.touchedActor); data.Reset(); parentData.Reset(); - rootData.Reset(); - // Root is now consumer, connect to the touched signal of the parent so that it becomes the consumer - SignalData secondData; - TouchEventFunctor secondFunctor( secondData /* Consume */ ); - parent.TouchedSignal().Connect( &application, secondFunctor ); + END_TEST; +} - // Emit an interrupted signal, all three should STILL be called - application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 10.0f, 10.0f ) ) ); - DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, parentData.touchEvent.points[0].state, TEST_LOCATION ); - DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION ); - DALI_TEST_EQUALS( TouchPoint::Interrupted, rootData.touchEvent.points[0].state, TEST_LOCATION ); +int UtcDaliTouchArea(void) +{ + TestApplication application; + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f)); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + + application.GetScene().Add(actor); + + // Render and notify + application.SendNotification(); + application.Render(); + + // Connect to actor's touched signal + SignalData data; + TouchEventFunctor functor(data, false /* Do not consume */); + actor.TouchedSignal().Connect(&application, functor); + + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(110.0f, 110.0f))); + // The actor touched signal is not called because the touch area is outside actor. + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + data.Reset(); + + // set a bigger touch area + actor.SetProperty(DevelActor::Property::TOUCH_AREA, Vector2(200.0f, 200.0f)); + + // Render and notify + application.SendNotification(); + application.Render(); + + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(110.0f, 110.0f))); + // The actor touched signal is called because the touch area is inside touchArea. + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); + data.Reset(); + + // set a smaller touch area + actor.SetProperty(DevelActor::Property::TOUCH_AREA, Vector2(50.0f, 50.0f)); + + // Render and notify + application.SendNotification(); + application.Render(); + + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(80.0f, 80.0f))); + // The actor touched signal is not called because the touch area is outside touchArea. + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + data.Reset(); + + // Emit a down signal + application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(30.0f, 30.0f))); + // The actor touched signal is called because the touch area is inside touchArea. + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION); + DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor); data.Reset(); - parentData.Reset(); - rootData.Reset(); END_TEST; }