#endif
// INTERNAL INCLUDES
-#include <dali/public-api/events/touch-data.h>
+#include <dali/public-api/events/touch-event.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/signals/callback.h>
#include <dali/integration-api/debug.h>
#include <dali/internal/event/common/scene-impl.h>
#include <dali/internal/event/events/hit-test-algorithm-impl.h>
#include <dali/internal/event/events/multi-point-event-util.h>
-#include <dali/internal/event/events/touch-data-impl.h>
+#include <dali/internal/event/events/touch-event-impl.h>
#include <dali/internal/event/render-tasks/render-task-impl.h>
namespace Dali
#endif // defined(DEBUG_ENABLED)
+Dali::Actor EmitInterceptTouchSignals( Dali::Actor actor, const Dali::TouchEvent& touchEvent )
+{
+ Dali::Actor interceptedActor;
+
+ if( actor )
+ {
+ Dali::Actor parent = actor.GetParent();
+ if( parent )
+ {
+ // Recursively deliver events to the actor and its parents for intercept touch event.
+ interceptedActor = EmitInterceptTouchSignals( parent, touchEvent );
+ }
+
+ if( !interceptedActor )
+ {
+ bool intercepted = false;
+ Actor& actorImpl( GetImplementation(actor) );
+ if( actorImpl.GetInterceptTouchRequired() )
+ {
+ intercepted = actorImpl.EmitInterceptTouchEventSignal( touchEvent );
+ if( intercepted )
+ {
+ interceptedActor = Dali::Actor( &actorImpl );
+ }
+ }
+ }
+ }
+
+ return interceptedActor;
+}
/**
* Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
*/
-Dali::Actor EmitTouchSignals( Dali::Actor actor, const TouchEvent& event, const Dali::TouchData& touchData )
+Dali::Actor EmitTouchSignals( Dali::Actor actor, const Dali::TouchEvent& touchEvent )
{
Dali::Actor consumedActor;
// Only emit the signal if the actor's touch signal has connections (or derived actor implementation requires touch).
if ( actorImpl.GetTouchRequired() )
{
- consumed = actorImpl.EmitTouchEventSignal( event, touchData );
+ consumed = actorImpl.EmitTouchEventSignal( touchEvent );
}
if ( consumed )
(parent == oldParent) )
{
// One of the actor's parents may consumed the event and they should be set as the consumed actor.
- consumedActor = EmitTouchSignals( parent, event, touchData );
+ consumedActor = EmitTouchSignals( parent, touchEvent );
}
}
}
Dali::Actor AllocAndEmitTouchSignals( unsigned long time, Dali::Actor actor, const Integration::Point& point )
{
- TouchEvent touchEvent( time );
- TouchDataPtr touchData( new TouchData( time ) );
- Dali::TouchData touchDataHandle( touchData.Get() );
+ TouchEventPtr touchEvent( new TouchEvent( time ) );
+ Dali::TouchEvent touchEventHandle( touchEvent.Get() );
- touchEvent.points.push_back( point.GetTouchPoint() );
- touchData->AddPoint( point );
+ touchEvent->AddPoint( point );
- return EmitTouchSignals( actor, touchEvent, touchDataHandle );
+ return EmitTouchSignals( actor, touchEventHandle );
}
/**
* Changes the state of the primary point to leave and emits the touch signals
*/
-Dali::Actor EmitTouchSignals( Actor* actor, RenderTask& renderTask, const TouchEvent& originalEvent, const TouchDataPtr& originalTouchData, PointState::Type state )
+Dali::Actor EmitTouchSignals( Actor* actor, RenderTask& renderTask, const TouchEventPtr& originalTouchEvent, PointState::Type state )
{
Dali::Actor consumingActor;
if( actor )
{
- TouchDataPtr touchData = TouchData::Clone( *originalTouchData.Get() );
+ TouchEventPtr touchEventImpl = TouchEvent::Clone( *originalTouchEvent.Get() );
- Integration::Point& primaryPoint = touchData->GetPoint( 0 );
+ Integration::Point& primaryPoint = touchEventImpl->GetPoint( 0 );
const Vector2& screenPosition = primaryPoint.GetScreenPosition();
Vector2 localPosition;
primaryPoint.SetHitActor( Dali::Actor( actor ) );
primaryPoint.SetState( state );
- TouchEvent touchEvent( originalEvent );
- touchEvent.points[0] = primaryPoint.GetTouchPoint();
-
- consumingActor = EmitTouchSignals( Dali::Actor(actor), touchEvent, Dali::TouchData( touchData.Get() ) );
+ consumingActor = EmitTouchSignals( Dali::Actor(actor), Dali::TouchEvent( touchEventImpl.Get() ) );
}
return consumingActor;
currentPoint.SetHitActor( Dali::Actor() );
- TouchEvent touchEvent( event.time );
- TouchDataPtr touchData( new TouchData( event.time ) );
- Dali::TouchData touchDataHandle( touchData.Get() );
+ TouchEventPtr touchEventImpl( new TouchEvent( event.time ) );
+ Dali::TouchEvent touchEventHandle( touchEventImpl.Get() );
- touchEvent.points.push_back( currentPoint.GetTouchPoint() );
- touchData->AddPoint( currentPoint );
+ touchEventImpl->AddPoint( currentPoint );
- mScene.EmitTouchedSignal( touchEvent, touchDataHandle );
+ mScene.EmitTouchedSignal( touchEventHandle );
return false; // No need for hit testing & already an interrupted event so just return false
}
// 2) Hit Testing.
- TouchEvent touchEvent( event.time );
- TouchDataPtr touchData( new TouchData( event.time ) );
- Dali::TouchData touchDataHandle( touchData.Get() );
+ TouchEventPtr touchEventImpl( new TouchEvent( event.time ) );
+ Dali::TouchEvent touchEventHandle( touchEventImpl.Get() );
DALI_LOG_INFO( gLogFilter, Debug::Concise, "\n" );
DALI_LOG_INFO( gLogFilter, Debug::General, "Point(s): %d\n", event.GetPointCount() );
newPoint.SetHitActor( hitTestResults.actor );
newPoint.SetLocalPosition( hitTestResults.actorCoordinates );
- touchEvent.points.push_back( newPoint.GetTouchPoint() );
- touchData->AddPoint( newPoint );
+ touchEventImpl->AddPoint( newPoint );
DALI_LOG_INFO( gLogFilter, Debug::General, " State(%s), Screen(%.0f, %.0f), HitActor(%p, %s), Local(%.2f, %.2f)\n",
TOUCH_POINT_STATE[currentPoint.GetState()], currentPoint.GetScreenPosition().x, currentPoint.GetScreenPosition().y,
Dali::Actor consumedActor;
if ( currentRenderTask )
{
- consumedActor = EmitTouchSignals( touchData->GetPoint( 0 ).GetHitActor(), touchEvent, touchDataHandle );
+ // Emit the intercept touch signal
+ Dali::Actor interceptedActor = EmitInterceptTouchSignals( touchEventImpl->GetPoint( 0 ).GetHitActor(), touchEventHandle );
+ if( interceptedActor )
+ {
+ consumedActor = EmitTouchSignals( interceptedActor, touchEventHandle );
+ }
+ else
+ {
+ consumedActor = EmitTouchSignals( touchEventImpl->GetPoint( 0 ).GetHitActor(), touchEventHandle );
+ }
consumed = consumedActor ? true : false;
}
- Integration::Point& primaryPoint = touchData->GetPoint( 0 );
+ Integration::Point& primaryPoint = touchEventImpl->GetPoint( 0 );
Dali::Actor primaryHitActor = primaryPoint.GetHitActor();
PointState::Type primaryPointState = primaryPoint.GetState();
DALI_LOG_INFO( gLogFilter, Debug::Concise, "ConsumedActor: (%p) %s\n", consumedActor ? reinterpret_cast< void* >( &consumedActor.GetBaseObject() ) : NULL, consumedActor ? consumedActor.GetProperty< std::string >( Dali::Actor::Property::NAME ).c_str() : "" );
if ( ( primaryPointState == PointState::DOWN ) &&
- ( touchEvent.GetPointCount() == 1 ) &&
+ ( touchEventImpl->GetPointCount() == 1 ) &&
( consumedActor && consumedActor.GetProperty< bool >( Dali::Actor::Property::CONNECTED_TO_SCENE ) ) )
{
mTouchDownConsumedActor.SetActor( &GetImplementation( consumedActor ) );
if ( lastPrimaryHitActor->GetLeaveRequired() )
{
DALI_LOG_INFO( gLogFilter, Debug::Concise, "LeaveActor(Hit): (%p) %s\n", reinterpret_cast< void* >( lastPrimaryHitActor ), lastPrimaryHitActor->GetName().c_str() );
- leaveEventConsumer = EmitTouchSignals( mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEvent, touchData, PointState::LEAVE );
+ leaveEventConsumer = EmitTouchSignals( mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEventImpl, PointState::LEAVE );
}
}
else
// At this point mLastPrimaryHitActor was touchable and sensitive in the previous touch event process but is not in the current one.
// An interrupted event is send to allow some actors to go back to their original state (i.e. Button controls)
DALI_LOG_INFO( gLogFilter, Debug::Concise, "InterruptedActor(Hit): (%p) %s\n", reinterpret_cast< void* >( lastPrimaryHitActor ), lastPrimaryHitActor->GetName().c_str() );
- leaveEventConsumer = EmitTouchSignals( mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEvent, touchData, PointState::INTERRUPTED );
+ leaveEventConsumer = EmitTouchSignals( mLastPrimaryHitActor.GetActor(), lastRenderTaskImpl, touchEventImpl, PointState::INTERRUPTED );
}
}
if( lastConsumedActor->GetLeaveRequired() )
{
DALI_LOG_INFO( gLogFilter, Debug::Concise, "LeaveActor(Consume): (%p) %s\n", reinterpret_cast< void* >( lastConsumedActor ), lastConsumedActor->GetName().c_str() );
- EmitTouchSignals( lastConsumedActor, lastRenderTaskImpl, touchEvent, touchData, PointState::LEAVE );
+ EmitTouchSignals( lastConsumedActor, lastRenderTaskImpl, touchEventImpl, PointState::LEAVE );
}
}
else
// At this point mLastConsumedActor was touchable and sensitive in the previous touch event process but is not in the current one.
// An interrupted event is send to allow some actors to go back to their original state (i.e. Button controls)
DALI_LOG_INFO( gLogFilter, Debug::Concise, "InterruptedActor(Consume): (%p) %s\n", reinterpret_cast< void* >( lastConsumedActor ), lastConsumedActor->GetName().c_str() );
- EmitTouchSignals( mLastConsumedActor.GetActor(), lastRenderTaskImpl, touchEvent, touchData, PointState::INTERRUPTED );
+ EmitTouchSignals( mLastConsumedActor.GetActor(), lastRenderTaskImpl, touchEventImpl, PointState::INTERRUPTED );
}
}
}
}
else
{
- // The primaryHitActor may have been removed from the stage so ensure it is still on the stage before setting members.
- if ( primaryHitActor && GetImplementation( primaryHitActor ).OnStage() )
+ // The primaryHitActor may have been removed from the scene so ensure it is still on the scene before setting members.
+ if ( primaryHitActor && GetImplementation( primaryHitActor ).OnScene() )
{
mLastPrimaryHitActor.SetActor( &GetImplementation( primaryHitActor ) );
- // Only observe the consumed actor if we have a primaryHitActor (check if it is still on stage).
- if ( consumedActor && GetImplementation( consumedActor ).OnStage() )
+ // Only observe the consumed actor if we have a primaryHitActor (check if it is still on the scene).
+ if ( consumedActor && GetImplementation( consumedActor ).OnScene() )
{
mLastConsumedActor.SetActor( &GetImplementation( consumedActor ) );
}
else
{
- mLastConsumedActor.SetActor( NULL );
+ mLastConsumedActor.SetActor( nullptr );
}
mLastRenderTask = currentRenderTask;
// 6) Emit an interrupted event to the touch-down actor if it hasn't consumed the up and
// emit the stage touched event if required.
- if ( touchEvent.GetPointCount() == 1 ) // Only want the first touch and the last release
+ if ( touchEventImpl->GetPointCount() == 1 ) // Only want the first touch and the last release
{
switch ( primaryPointState )
{
{
Dali::Actor touchDownConsumedActorHandle( touchDownConsumedActor );
- Integration::Point currentPoint = touchData->GetPoint( 0 );
+ Integration::Point currentPoint = touchEventImpl->GetPoint( 0 );
currentPoint.SetHitActor( touchDownConsumedActorHandle );
currentPoint.SetState( PointState::INTERRUPTED );
AllocAndEmitTouchSignals( event.time, touchDownConsumedActorHandle, currentPoint );
}
- mTouchDownConsumedActor.SetActor( NULL );
+ mTouchDownConsumedActor.SetActor( nullptr );
DALI_FALLTHROUGH;
}
case PointState::DOWN:
{
- mScene.EmitTouchedSignal( touchEvent, touchDataHandle );
+ mScene.EmitTouchedSignal( touchEventHandle );
break;
}
{
if ( actor == mLastPrimaryHitActor.GetActor() )
{
- Dali::Actor handle( actor );
+ Dali::Actor actorHandle( actor );
Integration::Point point;
point.SetState( PointState::INTERRUPTED );
- point.SetHitActor( handle );
+ point.SetHitActor( actorHandle );
- TouchDataPtr touchData( new TouchData );
- touchData->AddPoint( point );
- Dali::TouchData touchDataHandle( touchData.Get() );
+ TouchEventPtr touchEventImpl( new TouchEvent );
+ touchEventImpl->AddPoint( point );
+ Dali::TouchEvent touchEventHandle( touchEventImpl.Get() );
- TouchEvent touchEvent( 0 );
- touchEvent.points.push_back( point.GetTouchPoint() );
-
- Dali::Actor eventConsumer = EmitTouchSignals( handle, touchEvent, touchDataHandle );
+ Dali::Actor eventConsumer = EmitTouchSignals( actorHandle, touchEventHandle );
if ( mLastConsumedActor.GetActor() != eventConsumer )
{
- EmitTouchSignals( Dali::Actor( mLastConsumedActor.GetActor() ), touchEvent, touchDataHandle );
+ EmitTouchSignals( Dali::Actor( mLastConsumedActor.GetActor() ), touchEventHandle );
}
// Do not set mLastPrimaryHitActor to NULL we may be iterating through its observers
- mLastConsumedActor.SetActor( NULL );
+ mLastConsumedActor.SetActor( nullptr );
mLastRenderTask.Reset();
}
}
projects / platform / core / uifw / dali-core.git / blobdiff