#include <dali/devel-api/actors/layer-devel.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/common/constants.h>
-#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/math/vector3.h>
#include <dali/public-api/math/radian.h>
// Signals
-const char* const SIGNAL_TOUCHED = "touched";
const char* const SIGNAL_HOVERED = "hovered";
const char* const SIGNAL_WHEEL_EVENT = "wheelEvent";
-const char* const SIGNAL_ON_STAGE = "onStage";
-const char* const SIGNAL_OFF_STAGE = "offStage";
+const char* const SIGNAL_ON_SCENE = "onScene";
+const char* const SIGNAL_OFF_SCENE = "offScene";
const char* const SIGNAL_ON_RELAYOUT = "onRelayout";
-const char* const SIGNAL_TOUCH = "touch";
+const char* const SIGNAL_TOUCHED = "touched";
const char* const SIGNAL_VISIBILITY_CHANGED = "visibilityChanged";
const char* const SIGNAL_LAYOUT_DIRECTION_CHANGED = "layoutDirectionChanged";
const char* const SIGNAL_CHILD_ADDED = "childAdded";
TypeRegistration mType( typeid(Dali::Actor), typeid(Dali::Handle), CreateActor, ActorDefaultProperties );
-SignalConnectorType signalConnector1( mType, SIGNAL_TOUCHED, &Actor::DoConnectSignal );
SignalConnectorType signalConnector2( mType, SIGNAL_HOVERED, &Actor::DoConnectSignal );
SignalConnectorType signalConnector3( mType, SIGNAL_WHEEL_EVENT, &Actor::DoConnectSignal );
-SignalConnectorType signalConnector4( mType, SIGNAL_ON_STAGE, &Actor::DoConnectSignal );
-SignalConnectorType signalConnector5( mType, SIGNAL_OFF_STAGE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector4( mType, SIGNAL_ON_SCENE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector5( mType, SIGNAL_OFF_SCENE, &Actor::DoConnectSignal );
SignalConnectorType signalConnector6( mType, SIGNAL_ON_RELAYOUT, &Actor::DoConnectSignal );
-SignalConnectorType signalConnector7( mType, SIGNAL_TOUCH, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector7( mType, SIGNAL_TOUCHED, &Actor::DoConnectSignal );
SignalConnectorType signalConnector8( mType, SIGNAL_VISIBILITY_CHANGED, &Actor::DoConnectSignal );
SignalConnectorType signalConnector9( mType, SIGNAL_LAYOUT_DIRECTION_CHANGED, &Actor::DoConnectSignal );
SignalConnectorType signalConnector10( mType, SIGNAL_CHILD_ADDED, &Actor::DoConnectSignal );
return GetNode().GetId();
}
-bool Actor::OnStage() const
+bool Actor::OnScene() const
{
- return mIsOnStage;
+ return mIsOnScene;
}
Dali::Layer Actor::GetLayer()
const Vector2 Actor::GetCurrentScreenPosition() const
{
- if( mScene && OnStage() )
+ if( mScene && OnScene() )
{
Vector3 worldPosition = GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
Vector3 cameraPosition = mScene->GetDefaultCameraActor().GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const
{
// only valid when on-stage
- if( mScene && OnStage() )
+ if( mScene && OnScene() )
{
const RenderTaskList& taskList = mScene->GetRenderTaskList();
{
bool retval = false;
// only valid when on-stage
- if( OnStage() )
+ if( OnScene() )
{
CameraActor* camera = renderTask.GetCameraActor();
if( camera )
bool Actor::ScreenToLocal( const Matrix& viewMatrix, const Matrix& projectionMatrix, const Viewport& viewport, float& localX, float& localY, float screenX, float screenY ) const
{
// Early-out if not on stage
- if( !OnStage() )
+ if( !OnScene() )
{
return false;
}
*/
// Early-out if not on stage
- if( !OnStage() )
+ if( !OnScene() )
{
return false;
}
{
bool hit = false;
- if( OnStage() )
+ if( OnScene() )
{
// Transforms the ray to the local reference system.
// Calculate the inverse of Model matrix
bool Actor::GetTouchRequired() const
{
- return !mTouchedSignal.Empty() || !mTouchSignal.Empty() || mDerivedRequiresTouch;
+ return !mTouchedSignal.Empty() || mDerivedRequiresTouch;
}
bool Actor::GetHoverRequired() const
return *mGestureData;
}
-bool Actor::IsGestureRequred( DevelGesture::Type type ) const
+bool Actor::IsGestureRequired( GestureType::Value type ) const
{
- return mGestureData && mGestureData->IsGestureRequred( type );
+ return mGestureData && mGestureData->IsGestureRequired( type );
}
-bool Actor::EmitTouchEventSignal( const TouchEvent& event, const Dali::TouchData& touch )
+bool Actor::EmitTouchEventSignal( const Dali::TouchEvent& touch )
{
bool consumed = false;
- if( !mTouchSignal.Empty() )
- {
- Dali::Actor handle( this );
- consumed = mTouchSignal.Emit( handle, touch );
- }
-
if( !mTouchedSignal.Empty() )
{
Dali::Actor handle( this );
- consumed |= mTouchedSignal.Emit( handle, event );
- }
-
- if( !consumed )
- {
- // Notification for derived classes
- consumed = OnTouchEvent( event ); // TODO
+ consumed = mTouchedSignal.Emit( handle, touch );
}
return consumed;
}
-bool Actor::EmitHoverEventSignal( const HoverEvent& event )
+bool Actor::EmitHoverEventSignal( const Dali::HoverEvent& event )
{
bool consumed = false;
return consumed;
}
-bool Actor::EmitWheelEventSignal( const WheelEvent& event )
+bool Actor::EmitWheelEventSignal( const Dali::WheelEvent& event )
{
bool consumed = false;
}
}
-Dali::Actor::TouchSignalType& Actor::TouchedSignal()
+Dali::Actor::TouchEventSignalType& Actor::TouchedSignal()
{
return mTouchedSignal;
}
-Dali::Actor::TouchDataSignalType& Actor::TouchSignal()
-{
- return mTouchSignal;
-}
-
Dali::Actor::HoverSignalType& Actor::HoveredSignal()
{
return mHoveredSignal;
return mWheelEventSignal;
}
-Dali::Actor::OnStageSignalType& Actor::OnStageSignal()
+Dali::Actor::OnSceneSignalType& Actor::OnSceneSignal()
{
- return mOnStageSignal;
+ return mOnSceneSignal;
}
-Dali::Actor::OffStageSignalType& Actor::OffStageSignal()
+Dali::Actor::OffSceneSignalType& Actor::OffSceneSignal()
{
- return mOffStageSignal;
+ return mOffSceneSignal;
}
Dali::Actor::OnRelayoutSignalType& Actor::OnRelayoutSignal()
bool connected( true );
Actor* actor = static_cast< Actor* >( object ); // TypeRegistry guarantees that this is the correct type.
- if( 0 == signalName.compare( SIGNAL_TOUCHED ) )
- {
- actor->TouchedSignal().Connect( tracker, functor );
- }
- else if( 0 == signalName.compare( SIGNAL_HOVERED ) )
+ if( 0 == signalName.compare( SIGNAL_HOVERED ) )
{
actor->HoveredSignal().Connect( tracker, functor );
}
{
actor->WheelEventSignal().Connect( tracker, functor );
}
- else if( 0 == signalName.compare( SIGNAL_ON_STAGE ) )
+ else if( 0 == signalName.compare( SIGNAL_ON_SCENE ) )
{
- actor->OnStageSignal().Connect( tracker, functor );
+ actor->OnSceneSignal().Connect( tracker, functor );
}
- else if( 0 == signalName.compare( SIGNAL_OFF_STAGE ) )
+ else if( 0 == signalName.compare( SIGNAL_OFF_SCENE ) )
{
- actor->OffStageSignal().Connect( tracker, functor );
+ actor->OffSceneSignal().Connect( tracker, functor );
}
else if( 0 == signalName.compare( SIGNAL_ON_RELAYOUT ) )
{
actor->OnRelayoutSignal().Connect( tracker, functor );
}
- else if( 0 == signalName.compare( SIGNAL_TOUCH ) )
+ else if( 0 == signalName.compare( SIGNAL_TOUCHED ) )
{
- actor->TouchSignal().Connect( tracker, functor );
+ actor->TouchedSignal().Connect( tracker, functor );
}
else if( 0 == signalName.compare( SIGNAL_VISIBILITY_CHANGED ) )
{
mRelayoutData( NULL ),
mGestureData( NULL ),
mTouchedSignal(),
- mTouchSignal(),
mHoveredSignal(),
mWheelEventSignal(),
- mOnStageSignal(),
- mOffStageSignal(),
+ mOnSceneSignal(),
+ mOffSceneSignal(),
mOnRelayoutSignal(),
mVisibilityChangedSignal(),
mLayoutDirectionChangedSignal(),
mUseAnimatedSize( AnimatedSizeFlag::CLEAR ),
mIsRoot( ROOT_LAYER == derivedType ),
mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ),
- mIsOnStage( false ),
+ mIsOnScene( false ),
mSensitive( true ),
mLeaveRequired( false ),
mKeyboardFocusable( false ),
mDerivedRequiresTouch( false ),
mDerivedRequiresHover( false ),
mDerivedRequiresWheelEvent( false ),
- mOnStageSignalled( false ),
+ mOnSceneSignalled( false ),
mInsideOnSizeSet( false ),
mInheritPosition( true ),
mInheritOrientation( true ),
delete mRelayoutData;
}
-void Actor::ConnectToStage( uint32_t parentDepth )
+void Actor::ConnectToScene( uint32_t parentDepth )
{
// This container is used instead of walking the Actor hierarchy.
- // It protects us when the Actor hierarchy is modified during OnStageConnectionExternal callbacks.
+ // It protects us when the Actor hierarchy is modified during OnSceneConnectionExternal callbacks.
ActorContainer connectionList;
if( mScene )
}
// This stage is atomic i.e. not interrupted by user callbacks.
- RecursiveConnectToStage( connectionList, parentDepth + 1 );
+ RecursiveConnectToScene( connectionList, parentDepth + 1 );
// Notify applications about the newly connected actors.
const ActorIter endIter = connectionList.end();
RelayoutRequest();
}
-void Actor::RecursiveConnectToStage( ActorContainer& connectionList, uint32_t depth )
+void Actor::RecursiveConnectToScene( ActorContainer& connectionList, uint32_t depth )
{
- DALI_ASSERT_ALWAYS( !OnStage() );
+ DALI_ASSERT_ALWAYS( !OnScene() );
- mIsOnStage = true;
+ mIsOnScene = true;
mDepth = static_cast< uint16_t >( depth ); // overflow ignored, not expected in practice
ConnectToSceneGraph();
// Notification for internal derived classes
- OnStageConnectionInternal();
+ OnSceneConnectionInternal();
// This stage is atomic; avoid emitting callbacks until all Actors are connected
connectionList.push_back( ActorPtr( this ) );
for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
{
(*iter)->SetScene( *mScene );
- (*iter)->RecursiveConnectToStage( connectionList, depth + 1 );
+ (*iter)->RecursiveConnectToScene( connectionList, depth + 1 );
}
}
}
* This method is called when the Actor is connected to the Stage.
* The parent must have added its Node to the scene-graph.
* The child must connect its Node to the parent's Node.
- * This is recursive; the child calls ConnectToStage() for its children.
+ * This is recursive; the child calls ConnectToScene() for its children.
*/
void Actor::ConnectToSceneGraph()
{
void Actor::NotifyStageConnection()
{
// Actors can be removed (in a callback), before the on-stage stage is reported.
- // The actor may also have been reparented, in which case mOnStageSignalled will be true.
- if( OnStage() && !mOnStageSignalled )
+ // The actor may also have been reparented, in which case mOnSceneSignalled will be true.
+ if( OnScene() && !mOnSceneSignalled )
{
// Notification for external (CustomActor) derived classes
- OnStageConnectionExternal( mDepth );
+ OnSceneConnectionExternal( mDepth );
- if( !mOnStageSignal.Empty() )
+ if( !mOnSceneSignal.Empty() )
{
Dali::Actor handle( this );
- mOnStageSignal.Emit( handle );
+ mOnSceneSignal.Emit( handle );
}
// Guard against Remove during callbacks
- if( OnStage() )
+ if( OnScene() )
{
- mOnStageSignalled = true; // signal required next time Actor is removed
+ mOnSceneSignalled = true; // signal required next time Actor is removed
}
}
}
void Actor::DisconnectFromStage()
{
// This container is used instead of walking the Actor hierachy.
- // It protects us when the Actor hierachy is modified during OnStageDisconnectionExternal callbacks.
+ // It protects us when the Actor hierachy is modified during OnSceneDisconnectionExternal callbacks.
ActorContainer disconnectionList;
if( mScene )
void Actor::RecursiveDisconnectFromStage( ActorContainer& disconnectionList )
{
- // need to change state first so that internals relying on IsOnStage() inside OnStageDisconnectionInternal() get the correct value
- mIsOnStage = false;
+ // need to change state first so that internals relying on IsOnScene() inside OnSceneDisconnectionInternal() get the correct value
+ mIsOnScene = false;
// Recursively disconnect children
if( mChildren )
disconnectionList.push_back( ActorPtr( this ) );
// Notification for internal derived classes
- OnStageDisconnectionInternal();
+ OnSceneDisconnectionInternal();
DisconnectFromSceneGraph();
}
void Actor::NotifyStageDisconnection()
{
// Actors can be added (in a callback), before the off-stage state is reported.
- // Also if the actor was added & removed before mOnStageSignalled was set, then we don't notify here.
+ // Also if the actor was added & removed before mOnSceneSignalled was set, then we don't notify here.
// only do this step if there is a stage, i.e. Core is not being shut down
- if ( EventThreadServices::IsCoreRunning() && !OnStage() && mOnStageSignalled )
+ if ( EventThreadServices::IsCoreRunning() && !OnScene() && mOnSceneSignalled )
{
// Notification for external (CustomeActor) derived classes
- OnStageDisconnectionExternal();
+ OnSceneDisconnectionExternal();
- if( !mOffStageSignal.Empty() )
+ if( !mOffSceneSignal.Empty() )
{
Dali::Actor handle( this );
- mOffStageSignal.Emit( handle );
+ mOffSceneSignal.Emit( handle );
}
// Guard against Add during callbacks
- if( !OnStage() )
+ if( !OnScene() )
{
- mOnStageSignalled = false; // signal required next time Actor is added
+ mOnSceneSignalled = false; // signal required next time Actor is added
}
}
}
{
bool connected( false );
- if( OnStage() )
+ if( OnScene() )
{
if( IsRoot() || GetNode().GetParent() )
{
mScene = parent->mScene;
if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
- parent->OnStage() )
+ parent->OnScene() )
{
// Instruct each actor to create a corresponding node in the scene graph
- ConnectToStage( parent->GetHierarchyDepth() );
+ ConnectToScene( parent->GetHierarchyDepth() );
}
// Resolve the name and index for the child properties if any
mParent = NULL;
if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
- OnStage() )
+ OnScene() )
{
// Disconnect the Node & its children from the scene-graph.
DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), GetNode() );
case Dali::Actor::Property::CONNECTED_TO_SCENE:
{
- value = OnStage();
+ value = OnScene();
break;
}
void Actor::RequestRebuildDepthTree()
{
- if( mIsOnStage )
+ if( mIsOnScene )
{
if( mScene )
{