{
functorCalled = false;
- receivedTouchData.Reset();
+ receivedTouchEvent.Reset();
}
bool functorCalled;
- TouchData receivedTouchData;
+ TouchEvent receivedTouchEvent;
};
// Functor that sets the data when touched signal is received
{
TouchFunctor( TouchSignalData& data ) : signalData( data ) { }
- void operator()( const TouchData& touch )
+ void operator()( const TouchEvent& touch )
{
signalData.functorCalled = true;
- TouchData handle(touch);
- signalData.receivedTouchData = handle;
+ TouchEvent handle(touch);
+ signalData.receivedTouchEvent = handle;
}
void operator()()
WheelEventSignalData& signalData;
};
-bool DummyTouchCallback( Actor actor, const TouchData& touch )
+bool DummyTouchCallback( Actor actor, const TouchEvent& touch )
{
return true;
}
GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
data.Reset();
GenerateTouch( application, PointState::UP, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
data.Reset();
}
GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( data.receivedTouchData.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetHitActor(0) );
data.Reset();
GenerateTouch( application, PointState::MOTION, Vector2( 150.0f, 10.0f ) ); // Some motion
GenerateTouch( application, PointState::UP, Vector2( 150.0f, 10.0f ) ); // Some motion
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
data.Reset();
}
touchEvent.points.push_back( point );
application.ProcessEvent( touchEvent );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( data.receivedTouchData.GetPointCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
data.Reset();
// 2nd point
touchEvent.points.push_back( point );
application.ProcessEvent( touchEvent );
DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( (bool)data.receivedTouchData, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( (bool)data.receivedTouchEvent, false, TEST_LOCATION );
data.Reset();
// Primary point is up
touchEvent.points[1].SetState( PointState::STATIONARY );
application.ProcessEvent( touchEvent );
DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( (bool)data.receivedTouchData, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( (bool)data.receivedTouchEvent, false, TEST_LOCATION );
data.Reset();
// Remove 1st point now, 2nd point is now in motion
touchEvent.points[0].SetScreenPosition( Vector2( 150.0f, 50.0f ) );
application.ProcessEvent( touchEvent );
DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( (bool)data.receivedTouchData, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( (bool)data.receivedTouchEvent, false, TEST_LOCATION );
data.Reset();
// Final point Up
touchEvent.points[0].SetState( PointState::UP );
application.ProcessEvent( touchEvent );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( data.receivedTouchData.GetPointCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
data.Reset();
}
END_TEST;
GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
data.Reset();
// Confirm there is no signal when the touchpoint is only moved.
GenerateTouch( application, PointState::UP, Vector2( 1200.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
data.Reset();
}
GenerateTouch( application, PointState::INTERRUPTED, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
- DALI_TEST_CHECK( data.receivedTouchData.GetState(0) == PointState::INTERRUPTED );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED );
data.Reset();
GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( data.receivedTouchData.GetHitActor(0) == actor );
- DALI_TEST_CHECK( data.receivedTouchData.GetState(0) == PointState::DOWN );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetHitActor(0) == actor );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetState(0) == PointState::DOWN );
data.Reset();
GenerateTouch( application, PointState::INTERRUPTED, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
- DALI_TEST_CHECK( data.receivedTouchData.GetState(0) == PointState::INTERRUPTED );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED );
- DALI_TEST_EQUALS( data.receivedTouchData.GetPointCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
// Check that getting info about a non-existent point causes an assert.
- DALI_TEST_EQUALS( data.receivedTouchData.GetState( 1 ), PointState::FINISHED, TEST_LOCATION );
+ DALI_TEST_EQUALS( data.receivedTouchEvent.GetState( 1 ), PointState::FINISHED, TEST_LOCATION );
data.Reset();
}
GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
data.Reset();
GenerateTouch( application, PointState::UP, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
data.Reset();
}
GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( data.receivedTouchData.GetHitActor(0) == actor );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetHitActor(0) == actor );
data.Reset();
GenerateTouch( application, PointState::MOTION, Vector2( 150.0f, 10.0f ) ); // Some motion
GenerateTouch( application, PointState::UP, Vector2( 150.0f, 10.0f ) ); // Some motion
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
data.Reset();
}
touchEvent.points.push_back( point );
application.ProcessEvent( touchEvent );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( data.receivedTouchData.GetPointCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
data.Reset();
// 2nd point
touchEvent.points[0].SetState( PointState::UP );
application.ProcessEvent( touchEvent );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( data.receivedTouchData.GetPointCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
data.Reset();
}
END_TEST;
GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0));
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0));
DALI_TEST_EQUALS( true, data2.functorCalled, TEST_LOCATION );
GenerateTouch( application, PointState::UP, Vector2( 1200.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0));
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0));
data.Reset();
}
GenerateTouch( application, PointState::INTERRUPTED, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
- DALI_TEST_CHECK( data.receivedTouchData.GetState(0) == PointState::INTERRUPTED );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED );
data.Reset();
GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( data.receivedTouchData.GetHitActor(0) == actor );
- DALI_TEST_CHECK( data.receivedTouchData.GetState(0) == PointState::DOWN );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetHitActor(0) == actor );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetState(0) == PointState::DOWN );
data.Reset();
GenerateTouch( application, PointState::INTERRUPTED, Vector2( 10.0f, 10.0f ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
- DALI_TEST_CHECK( data.receivedTouchData.GetState(0) == PointState::INTERRUPTED );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
+ DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_CHECK( data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED );
- DALI_TEST_EQUALS( data.receivedTouchData.GetPointCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
// Check that getting info about a non-existent point returns an empty handle
- Actor actor = data.receivedTouchData.GetHitActor( 1 );
+ Actor actor = data.receivedTouchEvent.GetHitActor( 1 );
DALI_TEST_CHECK( !actor );
data.Reset();
#include <stdlib.h>
#include <dali/public-api/dali-core.h>
+#include <dali/integration-api/events/touch-integ.h>
#include <dali/integration-api/events/touch-event-integ.h>
-#include <dali/integration-api/events/touch-data-integ.h>
#include <dali/integration-api/render-task-list-integ.h>
#include <dali-test-suite-utils.h>
#include <dali/devel-api/actors/actor-devel.h>
using namespace Dali;
-void utc_dali_touch_data_processing_startup(void)
+void utc_dali_touch_processing_startup(void)
{
test_return_value = TET_UNDEF;
}
-void utc_dali_touch_data_processing_cleanup(void)
+void utc_dali_touch_processing_cleanup(void)
{
test_return_value = TET_PASS;
}
{
struct TestPoint
{
- int32_t deviceId;
- PointState::Type state;
+ int32_t deviceId{-1};
+ PointState::Type state{PointState::FINISHED};
Actor hitActor;
Vector2 local;
Vector2 screen;
- float radius;
+ float radius{0};
Vector2 ellipseRadius;
- float pressure;
+ float pressure{0};
Degree angle;
- Device::Class::Type deviceClass;
- Device::Subclass::Type deviceSubclass;
+ Device::Class::Type deviceClass{Device::Class::NONE};
+ Device::Subclass::Type deviceSubclass{Device::Subclass::NONE};
- TestPoint()
- : deviceId(-1), state(PointState::FINISHED), radius(0), pressure(0)
- {
- }
+ TestPoint() = default;
static const TestPoint ZERO;
};
{
SignalData()
: functorCalled( false ),
- touchData(),
+ receivedTouch(),
touchedActor()
{
}
- struct TestTouchData
+ struct TestTouchEvent
{
unsigned long time;
std::vector<TestPoint> points;
{
functorCalled = false;
- touchData.time = 0u;
- touchData.points.clear();
+ receivedTouch.time = 0u;
+ receivedTouch.points.clear();
touchedActor.Reset();
}
bool functorCalled;
- TestTouchData touchData;
+ TestTouchEvent receivedTouch;
Actor touchedActor;
};
// Functor that sets the data when called
-struct TouchDataFunctor
+struct TouchEventFunctor
{
/**
* Constructor.
* @param[in] data Reference to the data to store callback information.
* @param[in] returnValue What the functor should return.
*/
- TouchDataFunctor( SignalData& data, bool returnValue = true )
+ TouchEventFunctor( SignalData& data, bool returnValue = true )
: signalData( data ),
returnValue( returnValue )
{
}
- bool operator()( Actor actor, const TouchData& touchData )
+ bool operator()( Actor actor, const TouchEvent& touch )
{
signalData.functorCalled = true;
signalData.touchedActor = actor;
- signalData.touchData.time = touchData.GetTime();
- signalData.touchData.points.clear();
+ signalData.receivedTouch.time = touch.GetTime();
+ signalData.receivedTouch.points.clear();
- for( size_t i=0; i<touchData.GetPointCount(); ++i )
+ for( size_t i=0; i<touch.GetPointCount(); ++i )
{
TestPoint p;
- p.deviceId = touchData.GetDeviceId(i);
- p.state = touchData.GetState(i);
- p.hitActor = touchData.GetHitActor(i);
- p.local = touchData.GetLocalPosition(i);
- p.screen = touchData.GetScreenPosition(i);
- p.radius = touchData.GetRadius(i);
- p.ellipseRadius = touchData.GetEllipseRadius(i);
- p.pressure = touchData.GetPressure(i);
- p.angle = touchData.GetAngle(i);
- p.deviceClass = touchData.GetDeviceClass(i);
- p.deviceSubclass = touchData.GetDeviceSubclass(i);
- signalData.touchData.points.push_back(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;
struct HandleData
{
bool signalReceived;
- TouchData touchData;
+ TouchEvent receivedTouchHandle;
HandleData()
: signalReceived(false)
}
};
-struct TouchDataHandleFunctor
+struct TouchEventHandleFunctor
{
/**
* Constructor.
* @param[in] data Reference to the data to store callback information.
* @param[in] returnValue What the functor should return.
*/
- TouchDataHandleFunctor( HandleData& handleData, bool returnValue = true )
+ TouchEventHandleFunctor( HandleData& handleData, bool returnValue = true )
: handleData(handleData),
returnValue( returnValue )
{
}
- bool operator()( Actor actor, const TouchData& someTouchData )
+ bool operator()( Actor actor, const TouchEvent& someTouchEvent )
{
handleData.signalReceived = true;
- TouchData handle(someTouchData);
- handleData.touchData = handle;
+ handleData.receivedTouchHandle = someTouchEvent;
return returnValue;
}
// Functor that removes the actor when called.
-struct RemoveActorFunctor : public TouchDataFunctor
+struct RemoveActorFunctor : public TouchEventFunctor
{
/**
* Constructor.
* @param[in] returnValue What the functor should return.
*/
RemoveActorFunctor( SignalData& data, bool returnValue = true )
- : TouchDataFunctor( data, returnValue )
+ : TouchEventFunctor( data, returnValue )
{
}
- bool operator()( Actor actor, const TouchData& touchData )
+ bool operator()( Actor actor, const TouchEvent& touch )
{
Actor parent( actor.GetParent() );
if ( parent )
parent.Remove( actor );
}
- return TouchDataFunctor::operator()( actor, touchData );
+ return TouchEventFunctor::operator()( actor, touch );
}
};
{
}
- bool operator()( Actor actor, const TouchData& touchData )
+ bool operator()( Actor actor, const TouchEvent& touch )
{
outOfBoundsData.functorCalled = true;
- size_t count = touchData.GetPointCount();
+ size_t count = touch.GetPointCount();
// Read out of bounds data
- outOfBoundsData.point.deviceId = touchData.GetDeviceId(count+1);
- outOfBoundsData.point.state = touchData.GetState(count+1);
- outOfBoundsData.point.hitActor = touchData.GetHitActor(count+1);
- outOfBoundsData.point.local = touchData.GetLocalPosition(count+1);
- outOfBoundsData.point.screen = touchData.GetScreenPosition(count+1);
+ 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;
}
///////////////////////////////////////////////////////////////////////////////
-int UtcDaliTouchDataNormalProcessing01(void)
+int UtcDaliTouchEventNormalProcessing01(void)
{
TestApplication application;
// Connect to actor's touch signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
Vector2 screenCoordinates( 10.0f, 10.0f );
// Emit a down signal
application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
- const TestPoint *point1 = &data.touchData.GetPoint(0);
+ const TestPoint *point1 = &data.receivedTouch.GetPoint(0);
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.touchData.GetPointCount(), 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 );
screenCoordinates.x = screenCoordinates.y = 11.0f;
actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, screenCoordinates ) );
- const TestPoint *point2 = &data.touchData.GetPoint(0);
+ const TestPoint *point2 = &data.receivedTouch.GetPoint(0);
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.touchData.GetPointCount(), 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 );
screenCoordinates.x = screenCoordinates.y = 12.0f;
actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
application.ProcessEvent( GenerateSingleTouch( PointState::UP, screenCoordinates ) );
- const TestPoint *point3 = &data.touchData.GetPoint(0);
+ const TestPoint *point3 = &data.receivedTouch.GetPoint(0);
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.touchData.GetPointCount(), 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 );
}
-int UtcDaliTouchDataNormalProcessing02(void)
+int UtcDaliTouchEventNormalProcessing02(void)
{
TestApplication application;
// Connect to actor's touched signal
HandleData handleData;
- TouchDataHandleFunctor functor( handleData );
+ TouchEventHandleFunctor functor( handleData );
actor.TouchSignal().Connect( &application, functor );
Vector2 screenCoordinates( 10.0f, 10.0f );
// Emit a down signal
application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
DALI_TEST_EQUALS( true, handleData.signalReceived, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, handleData.touchData.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, handleData.touchData.GetState(0), TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, handleData.touchData.GetScreenPosition(0), TEST_LOCATION );
- DALI_TEST_EQUALS( localCoordinates, handleData.touchData.GetLocalPosition(0), 0.1f, 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 UtcDaliTouchDataAPINegative(void)
+int UtcDaliTouchEventAPINegative(void)
{
TestApplication application;
}
-int UtcDaliTouchDataOutsideCameraNearFarPlanes(void)
+int UtcDaliTouchEventOutsideCameraNearFarPlanes(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
Vector2 screenCoordinates( sceneSize.x * 0.5f, sceneSize.y * 0.5f );
END_TEST;
}
-int UtcDaliTouchDataEmitEmpty(void)
+int UtcDaliTouchEventEmitEmpty(void)
{
TestApplication application;
END_TEST;
}
-int UtcDaliTouchDataInterrupted(void)
+int UtcDaliTouchEventInterrupted(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().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.touchData.points[0].state, 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( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.touchData.points[0].state, 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.
END_TEST;
}
-int UtcDaliTouchDataParentConsumer(void)
+int UtcDaliTouchEventParentConsumer(void)
{
TestApplication application;
Actor rootActor( application.GetScene().GetRootLayer() );
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data, false );
+ TouchEventFunctor functor( data, false );
actor.TouchSignal().Connect( &application, functor );
// Connect to root actor's touched signal
SignalData rootData;
- TouchDataFunctor rootFunctor( rootData ); // Consumes signal
+ TouchEventFunctor rootFunctor( rootData ); // Consumes signal
rootActor.TouchSignal().Connect( &application, rootFunctor );
Vector2 screenCoordinates( 10.0f, 10.0f );
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.touchData.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, rootData.touchData.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, data.touchData.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, rootData.touchData.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( actorCoordinates, data.touchData.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( rootCoordinates, rootData.touchData.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.touchData.points[0].hitActor );
+ 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();
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.touchData.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, rootData.touchData.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, data.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, rootData.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, data.touchData.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, rootData.touchData.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( actorCoordinates, data.touchData.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( rootCoordinates, rootData.touchData.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.touchData.points[0].hitActor );
+ 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();
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.touchData.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, rootData.touchData.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::UP, data.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::UP, rootData.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, data.touchData.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, rootData.touchData.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( actorCoordinates, data.touchData.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( rootCoordinates, rootData.touchData.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.touchData.points[0].hitActor );
+ 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();
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.touchData.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, rootData.touchData.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( rootCoordinates, rootData.touchData.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( rootActor == rootData.touchData.points[0].hitActor );
+ 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 UtcDaliTouchDataInterruptedParentConsumer(void)
+int UtcDaliTouchEventInterruptedParentConsumer(void)
{
TestApplication application;
Actor rootActor( application.GetScene().GetRootLayer() );
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data, false );
+ TouchEventFunctor functor( data, false );
actor.TouchSignal().Connect( &application, functor );
// Connect to root actor's touched signal
SignalData rootData;
- TouchDataFunctor rootFunctor( rootData ); // Consumes signal
+ TouchEventFunctor rootFunctor( rootData ); // Consumes signal
rootActor.TouchSignal().Connect( &application, rootFunctor );
// 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( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.touchData.points[0].hitActor );
+ 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();
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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.touchData.points[0].hitActor );
+ 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();
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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.touchData.points[0].state, 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();
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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( rootActor == rootData.touchData.points[0].hitActor );
+ 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();
END_TEST;
}
-int UtcDaliTouchDataLeave(void)
+int UtcDaliTouchEventLeave(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
// Set actor to require leave events
// 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.touchData.points[0].state, 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( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, data.touchData.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS( PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION );
data.Reset();
// Another motion outside of actor, no signalling
// Another motion event inside actor, signalled with motion
application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 10.0f, 10.0f )) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, data.touchData.points[0].state, 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
END_TEST;
}
-int UtcDaliTouchDataLeaveParentConsumer(void)
+int UtcDaliTouchEventLeaveParentConsumer(void)
{
TestApplication application;
Actor rootActor( application.GetScene().GetRootLayer() );
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data, false );
+ TouchEventFunctor functor( data, false );
actor.TouchSignal().Connect( &application, functor );
// Connect to root actor's touched signal
SignalData rootData;
- TouchDataFunctor rootFunctor( rootData ); // Consumes signal
+ TouchEventFunctor rootFunctor( rootData ); // Consumes signal
rootActor.TouchSignal().Connect( &application, rootFunctor );
// Set actor to require leave events
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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.touchData.points[0].hitActor );
+ 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();
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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, rootData.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.touchData.points[0].hitActor );
+ 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();
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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( rootActor == rootData.touchData.points[0].hitActor );
+ 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();
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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, rootData.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.touchData.points[0].hitActor );
+ 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();
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.touchData.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS( PointState::LEAVE, rootData.receivedTouch.points[0].state, TEST_LOCATION );
END_TEST;
}
-int UtcDaliTouchDataActorBecomesInsensitive(void)
+int UtcDaliTouchEventActorBecomesInsensitive(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().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.touchData.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
data.Reset();
// Change actor to insensitive
// Emit a motion signal, signalled with an interrupted
application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.touchData.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
data.Reset();
END_TEST;
}
-int UtcDaliTouchDataActorBecomesInsensitiveParentConsumer(void)
+int UtcDaliTouchEventActorBecomesInsensitiveParentConsumer(void)
{
TestApplication application;
Actor rootActor( application.GetScene().GetRootLayer() );
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data, false );
+ TouchEventFunctor functor( data, false );
actor.TouchSignal().Connect( &application, functor );
// Connect to root actor's touched signal
SignalData rootData;
- TouchDataFunctor rootFunctor( rootData ); // Consumes signal
+ TouchEventFunctor rootFunctor( rootData ); // Consumes signal
rootActor.TouchSignal().Connect( &application, rootFunctor );
// 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( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.touchData.points[0].hitActor );
+ 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, signalled with an interrupted (should get interrupted even if within root actor)
application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.touchData.points[0].state, 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.touchData.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION );
END_TEST;
}
-int UtcDaliTouchDataMultipleLayers(void)
+int UtcDaliTouchEventMultipleLayers(void)
{
TestApplication application;
Actor rootActor( application.GetScene().GetRootLayer() );
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
Layer layer1 ( Layer::New() );
layer1.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
END_TEST;
}
-int UtcDaliTouchDataMultipleRenderTasks(void)
+int UtcDaliTouchEventMultipleRenderTasks(void)
{
TestApplication application;
Integration::Scene scene ( application.GetScene() );
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
// Emit a down signal
END_TEST;
}
-int UtcDaliTouchDataMultipleRenderTasksWithChildLayer(void)
+int UtcDaliTouchEventMultipleRenderTasksWithChildLayer(void)
{
TestApplication application;
Integration::Scene scene ( application.GetScene() );
// Connect to layer's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
layer.TouchSignal().Connect( &application, functor );
END_TEST;
}
-int UtcDaliTouchDataOffscreenRenderTasks(void)
+int UtcDaliTouchEventOffscreenRenderTasks(void)
{
TestApplication application;
Integration::Scene scene ( application.GetScene() );
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
// Emit a down signal
END_TEST;
}
-int UtcDaliTouchDataMultipleRenderableActors(void)
+int UtcDaliTouchEventMultipleRenderableActors(void)
{
TestApplication application;
Integration::Scene scene ( application.GetScene() );
// Connect to layer's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
parent.TouchSignal().Connect( &application, functor );
actor.TouchSignal().Connect( &application, functor );
END_TEST;
}
-int UtcDaliTouchDataActorRemovedInSignal(void)
+int UtcDaliTouchEventActorRemovedInSignal(void)
{
TestApplication application;
END_TEST;
}
-int UtcDaliTouchDataActorSignalNotConsumed(void)
+int UtcDaliTouchEventActorSignalNotConsumed(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data, false );
+ TouchEventFunctor functor( data, false );
actor.TouchSignal().Connect( &application, functor );
// Emit a down signal
END_TEST;
}
-int UtcDaliTouchDataActorRemovedFromScene(void)
+int UtcDaliTouchEventActorRemovedFromScene(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
// Emit a down signal
END_TEST;
}
-int UtcDaliTouchDataLayerConsumesTouch(void)
+int UtcDaliTouchEventLayerConsumesTouch(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
// Add a layer to overlap the actor
END_TEST;
}
-int UtcDaliTouchDataLeaveActorReadded(void)
+int UtcDaliTouchEventLeaveActorReadded(void)
{
TestApplication application;
Integration::Scene scene = application.GetScene();
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
// Emit a down and motion
// Emit a motion outside the actor's bounds
application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 200.0f, 200.0f ) ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, data.touchData.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS( PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION );
data.Reset();
END_TEST;
}
-int UtcDaliTouchDataClippedActor(void)
+int UtcDaliTouchEventClippedActor(void)
{
TestApplication application;
Integration::Scene scene = application.GetScene();
// Connect to actor's touch signal.
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
// Emit an event within clipped area - no hit.
END_TEST;
}
-int UtcDaliTouchDataActorUnparented(void)
+int UtcDaliTouchEventActorUnparented(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
+ 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
// Should receive an interrupted event
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.touchData.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
END_TEST;
}
-int UtcDaliTouchDataParentRemovedFromScene(void)
+int UtcDaliTouchEventParentRemovedFromScene(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
+ 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
// Should receive an interrupted event
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.touchData.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
END_TEST;
}
-int UtcDaliTouchDataActorRemovedFromSceneDifferentConsumer(void)
+int UtcDaliTouchEventActorRemovedFromSceneDifferentConsumer(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data, false /* Do not consume */ );
+ TouchEventFunctor functor( data, false /* Do not consume */ );
actor.TouchSignal().Connect( &application, functor );
// Connect to parent's touched signal
SignalData parentData;
- TouchDataFunctor parentFunctor( parentData );
+ TouchEventFunctor parentFunctor( parentData );
parent.TouchSignal().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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
+ 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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == parentData.touchData.points[0].hitActor );
+ 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();
// Should receive an interrupted event for both actor & parent
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.touchData.points[0].state, 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.touchData.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS( PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, 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;
- TouchDataFunctor secondFunctor( secondData /* Consume */ );
+ TouchEventFunctor secondFunctor( secondData /* Consume */ );
actor.TouchSignal().Connect( &application, secondFunctor );
// Unparent the actor
// 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.touchData.points[0].state, 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.touchData.points[0].state, 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.touchData.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS( PointState::INTERRUPTED, secondData.receivedTouch.points[0].state, TEST_LOCATION );
data.Reset();
parentData.Reset();
secondData.Reset();
END_TEST;
}
-int UtcDaliTouchDataInterruptedDifferentConsumer(void)
+int UtcDaliTouchEventInterruptedDifferentConsumer(void)
{
TestApplication application;
Actor rootActor( application.GetScene().GetRootLayer() );
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data, false /* Do not consume */ );
+ TouchEventFunctor functor( data, false /* Do not consume */ );
actor.TouchSignal().Connect( &application, functor );
// Connect to parent's touched signal
SignalData parentData;
- TouchDataFunctor parentFunctor( parentData, false /* Do not consume */ );
+ TouchEventFunctor parentFunctor( parentData, false /* Do not consume */ );
parent.TouchSignal().Connect( &application, parentFunctor );
// Connect to root's touched signal and consume
SignalData rootData;
- TouchDataFunctor rootFunctor( rootData );
+ TouchEventFunctor rootFunctor( rootData );
rootActor.TouchSignal().Connect( &application, rootFunctor );
// 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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchData.points[0].hitActor );
+ 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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == parentData.touchData.points[0].hitActor );
+ 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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == rootData.touchData.points[0].hitActor );
+ 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();
// Root is now consumer, connect to the touched signal of the parent so that it becomes the consumer
SignalData secondData;
- TouchDataFunctor secondFunctor( secondData /* Consume */ );
+ TouchEventFunctor secondFunctor( secondData /* Consume */ );
parent.TouchSignal().Connect( &application, secondFunctor );
// 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.touchData.points[0].state, 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.touchData.points[0].state, 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.touchData.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION );
data.Reset();
parentData.Reset();
rootData.Reset();
END_TEST;
}
-int UtcDaliTouchDataGetRadius(void)
+int UtcDaliTouchEventGetRadius(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
// Emit a down signal with an angle
touchEvent.points[ 0 ].SetRadius( 100.0f );
application.ProcessEvent( touchEvent );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( 100.0f, data.touchData.points[0].radius, TEST_LOCATION );
- DALI_TEST_EQUALS( 100.0f, data.touchData.points[0].ellipseRadius.x, TEST_LOCATION );
- DALI_TEST_EQUALS( 100.0f, data.touchData.points[0].ellipseRadius.y, 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 );
END_TEST;
}
-int UtcDaliTouchDataGetEllipseRadius(void)
+int UtcDaliTouchEventGetEllipseRadius(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
// Emit a down signal with an angle
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.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( 100.0f, data.touchData.points[0].radius, TEST_LOCATION );
- DALI_TEST_EQUALS( 20.0f, data.touchData.points[0].ellipseRadius.x, TEST_LOCATION );
- DALI_TEST_EQUALS( 10.0f, data.touchData.points[0].ellipseRadius.y, 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 UtcDaliTouchDataGetAngle(void)
+int UtcDaliTouchEventGetAngle(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
// Emit a down signal with an angle
touchEvent.points[ 0 ].SetAngle( Degree( 90.0f ) );
application.ProcessEvent( touchEvent );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( Degree( 90.0f ), data.touchData.points[0].angle, 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 );
END_TEST;
}
-int UtcDaliTouchDataGetPressure(void)
+int UtcDaliTouchEventGetPressure(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
// Emit a down signal with an angle
touchEvent.points[ 0 ].SetPressure( 10.0f );
application.ProcessEvent( touchEvent );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.touchData.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( 10.0f, data.touchData.points[0].pressure, 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 );
END_TEST;
}
-int UtcDaliTouchDataUsage(void)
+int UtcDaliTouchEventUsage(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
END_TEST;
}
-int UtcDaliTouchDataGetDeviceAPINegative(void)
+int UtcDaliTouchEventGetDeviceAPINegative(void)
{
TestApplication application;
// Connect to actor's touched signal
HandleData handleData;
- TouchDataHandleFunctor functor( handleData );
+ TouchEventHandleFunctor functor( handleData );
actor.TouchSignal().Connect( &application, functor );
Vector2 screenCoordinates( 10.0f, 10.0f );
// Emit a down signal
application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
- TouchData data = handleData.touchData;
+ 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 UtcDaliTouchDataGetMouseButtonPositive(void)
+int UtcDaliTouchEventGetMouseButtonPositive(void)
{
TestApplication application;
// Connect to actor's touched signal
HandleData handleData;
- TouchDataHandleFunctor functor( handleData );
+ TouchEventHandleFunctor functor( handleData );
actor.TouchSignal().Connect( &application, functor );
// Emit a down signal with MouseButton
touchEvent.points[ 0 ].SetMouseButton( static_cast< MouseButton::Type >( 3 ) );
application.ProcessEvent( touchEvent );
- TouchData data = handleData.touchData;
+ TouchEvent data = handleData.receivedTouchHandle;
DALI_TEST_EQUALS( data.GetMouseButton( 0 ), MouseButton::SECONDARY, TEST_LOCATION );
END_TEST;
}
-int UtcDaliTouchDataGetMouseButtonNagative(void)
+int UtcDaliTouchEventGetMouseButtonNagative(void)
{
TestApplication application;
// Connect to actor's touched signal
HandleData handleData;
- TouchDataHandleFunctor functor( handleData );
+ TouchEventHandleFunctor functor( handleData );
actor.TouchSignal().Connect( &application, functor );
// Emit a down signal with MouseButton
touchEvent.points[ 0 ].SetMouseButton( static_cast< MouseButton::Type >( 2 ) );
application.ProcessEvent( touchEvent );
- TouchData data = handleData.touchData;
+ 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 UtcDaliTouchDataCapturePropertySet(void)
+int UtcDaliTouchEventCapturePropertySet(void)
{
TestApplication application;
// Connect to actor's touched signal
SignalData data;
- TouchDataFunctor functor( data );
+ TouchEventFunctor functor( data );
actor.TouchSignal().Connect( &application, functor );
// Emit a down signal
// 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.touchData.GetPoint(0).state, PointState::INTERRUPTED, TEST_LOCATION );
+ DALI_TEST_EQUALS( data.receivedTouch.GetPoint(0).state, PointState::INTERRUPTED, TEST_LOCATION );
// Now set the capture property
actor.SetProperty( DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, true);
// 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.touchData.GetPoint(0).state, PointState::FINISHED, TEST_LOCATION );
+ DALI_TEST_EQUALS( data.receivedTouch.GetPoint(0).state, PointState::FINISHED, TEST_LOCATION );
END_TEST;
}
-int UtcDaliTouchDataIntegNewTouchData(void)
+int UtcDaliTouchEventIntegNewTouchEvent(void)
{
uint32_t timestamp = 92858u;
TouchPoint tp(1, TouchPoint::State::Started, 34.4f, 123.89f, 5.0f, 7.0f);
- Dali::TouchData touchData = Integration::NewTouchData(timestamp, tp);
+ Dali::TouchEvent touchEvent = Integration::NewTouchEvent(timestamp, tp);
- DALI_TEST_EQUALS(touchData.GetPointCount(), 1u, TEST_LOCATION);
- DALI_TEST_EQUALS(touchData.GetState(0), PointState::Type::STARTED, TEST_LOCATION );
- DALI_TEST_EQUALS(touchData.GetLocalPosition(0), Vector2(5.0f, 7.0f), TEST_LOCATION );
- DALI_TEST_EQUALS(touchData.GetScreenPosition(0), Vector2(34.4f, 123.89f), TEST_LOCATION );
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetState(0), PointState::Type::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;