#define DALI_INTERNAL_ACTOR_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// INTERNAL INCLUDES
#include <dali/public-api/actors/actor.h>
+#include <dali/devel-api/actors/actor-devel.h>
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/events/gesture.h>
#include <dali/public-api/math/viewport.h>
#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/size-negotiation/relayout-container.h>
+#include <dali/internal/common/memory-pool-object-allocator.h>
#include <dali/internal/event/actors/actor-declarations.h>
#include <dali/internal/event/common/object-impl.h>
#include <dali/internal/event/common/stage-def.h>
#include <dali/internal/event/rendering/renderer-impl.h>
#include <dali/internal/update/nodes/node-declarations.h>
+#include <dali/internal/update/manager/update-manager.h>
namespace Dali
{
-struct KeyEvent;
+class KeyEvent;
class TouchData;
-struct HoverEvent;
-struct WheelEvent;
+class TouchEvent;
+class WheelEvent;
namespace Internal
{
class Animation;
class RenderTask;
class Renderer;
+class Scene;
typedef std::vector< ActorPtr > ActorContainer;
typedef ActorContainer::iterator ActorIter;
typedef std::vector< RendererPtr > RendererContainer;
typedef RendererContainer::iterator RendererIter;
+class ActorDepthTreeNode;
+typedef Dali::Internal::MemoryPoolObjectAllocator< ActorDepthTreeNode > DepthNodeMemoryPool;
+
/**
* Actor is the primary object which Dali applications interact with.
* UI controls can be built by combining multiple actors.
static ActorPtr New();
/**
+ * Helper to create node for derived classes who don't have their own node type
+ * @return pointer to newly created unique node
+ */
+ static const SceneGraph::Node* CreateNode();
+
+ /**
* Retrieve the name of the actor.
* @return The name.
*/
/**
* @copydoc Dali::Actor::GetId
*/
- unsigned int GetId() const;
+ uint32_t GetId() const;
// Containment
}
/**
- * Query whether the actor is connected to the Stage.
+ * Query whether the actor is connected to the Scene.
*/
- bool OnStage() const;
+ bool OnScene() const;
/**
* Query whether the actor has any renderers.
* Retrieve the number of children held by the actor.
* @return The number of children
*/
- unsigned int GetChildCount() const;
+ uint32_t GetChildCount() const;
/**
* @copydoc Dali::Actor::GetChildAt
*/
- ActorPtr GetChildAt( unsigned int index ) const;
+ ActorPtr GetChildAt( uint32_t index ) const;
/**
* Retrieve a reference to Actor's children.
* @note Not for public use.
* @return A reference to the container of children.
+ * @note The internal container is lazily initialized so ensure you check the child count before using the value returned by this method.
*/
ActorContainer& GetChildrenInternal()
{
/**
* @copydoc Dali::Actor::FindChildById
*/
- ActorPtr FindChildById( const unsigned int id );
+ ActorPtr FindChildById( const uint32_t id );
/**
* Retrieve the parent of an Actor.
}
/**
+ * Calculates screen position and size.
+ *
+ * @return pair of two values, position of top-left corner on screen and size respectively.
+ */
+ Rect<> CalculateScreenExtents( ) const;
+
+ /**
* Sets the size of an actor.
* This does not interfere with the actors scale factor.
* @param [in] width The new width.
* This size will be the size set or if animating then the target size.
* @return The Actor's size.
*/
- const Vector3& GetTargetSize() const;
+ Vector3 GetTargetSize() const;
/**
* Retrieve the Actor's size from update side.
const Vector3& GetCurrentWorldPosition() const;
/**
- * @copydoc Dali::Actor::SetPositionInheritanceMode()
- */
- void SetPositionInheritanceMode( PositionInheritanceMode mode );
-
- /**
- * @copydoc Dali::Actor::GetPositionInheritanceMode()
- */
- PositionInheritanceMode GetPositionInheritanceMode() const;
-
- /**
* @copydoc Dali::Actor::SetInheritPosition()
*/
void SetInheritPosition( bool inherit );
/**
* Sets the visibility flag of an actor.
- * @param [in] visible The new visibility flag.
+ * @param[in] visible The new visibility flag.
*/
void SetVisible( bool visible );
/**
* @copydoc Dali::Actor::GetHierarchyDepth()
*/
- inline int GetHierarchyDepth() const
+ inline int32_t GetHierarchyDepth() const
{
- if( mIsOnStage )
+ if( mIsOnScene )
{
- return static_cast<int>(mDepth);
+ return mDepth;
}
return -1;
}
/**
- * Get the actor's sorting depth (The hierarchy depth combined with
- * the sibling order)
+ * Get the actor's sorting depth
*
* @return The depth used for hit-testing and renderer sorting
*/
- unsigned int GetSortingDepth();
+ uint32_t GetSortingDepth();
public:
void NegotiateSize( const Vector2& size, RelayoutContainer& container );
/**
+ * @brief Set whether size negotiation should use the assigned size of the actor
+ * during relayout for the given dimension(s)
+ *
+ * @param[in] use Whether the assigned size of the actor should be used
+ * @param[in] dimension The dimension(s) to set. Can be a bitfield of multiple dimensions
+ */
+ void SetUseAssignedSize( bool use, Dimension::Type dimension = Dimension::ALL_DIMENSIONS );
+
+ /**
+ * @brief Returns whether size negotiation should use the assigned size of the actor
+ * during relayout for a single dimension
+ *
+ * @param[in] dimension The dimension to get
+ * @return Return whether the assigned size of the actor should be used. If more than one dimension is requested, just return the first one found
+ */
+ bool GetUseAssignedSize( Dimension::Type dimension ) const;
+
+ /**
* @copydoc Dali::Actor::SetResizePolicy()
*/
void SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension = Dimension::ALL_DIMENSIONS );
/**
* @brief Request a relayout, which means performing a size negotiation on this actor, its parent and children (and potentially whole scene)
*
- * This method is automatically called from OnStageConnection(), OnChildAdd(),
+ * This method is automatically called from OnSceneConnection(), OnChildAdd(),
* OnChildRemove(), SetSizePolicy(), SetMinimumSize() and SetMaximumSize().
*
* This method can also be called from a derived class every time it needs a different size.
/**
* @copydoc Dali::Actor::AddRenderer()
*/
- unsigned int AddRenderer( Renderer& renderer );
+ uint32_t AddRenderer( Renderer& renderer );
/**
* @copydoc Dali::Actor::GetRendererCount()
*/
- unsigned int GetRendererCount() const;
+ uint32_t GetRendererCount() const;
/**
* @copydoc Dali::Actor::GetRendererAt()
*/
- RendererPtr GetRendererAt( unsigned int index );
+ RendererPtr GetRendererAt( uint32_t index );
/**
* @copydoc Dali::Actor::RemoveRenderer()
/**
* @copydoc Dali::Actor::RemoveRenderer()
*/
- void RemoveRenderer( unsigned int index );
+ void RemoveRenderer( uint32_t index );
public:
*/
bool IsHittable() const;
+ /**
+ * Query whether the actor captures all touch after it starts even if touch leaves its boundary.
+ * @return true, if it captures all touch after start
+ */
+ bool CapturesAllTouchAfterStart() const
+ {
+ return mCaptureAllTouchAfterStart;
+ }
+
// Gestures
/**
/**
* Queries whether the actor requires the gesture type.
* @param[in] type The gesture type.
+ * @return True if the gesture is required, false otherwise.
*/
- bool IsGestureRequred( Gesture::Type type ) const;
+ bool IsGestureRequired( GestureType::Value type ) const;
// Signals
/**
* Used by the EventProcessor to emit touch event signals.
- * @param[in] event The touch event (Old API).
* @param[in] touch The touch data.
* @return True if the event was consumed.
*/
- bool EmitTouchEventSignal( const TouchEvent& event, const Dali::TouchData& touch );
+ bool EmitTouchEventSignal( const Dali::TouchEvent& touch );
/**
* Used by the EventProcessor to emit hover event signals.
* @param[in] event The hover event.
* @return True if the event was consumed.
*/
- bool EmitHoverEventSignal( const HoverEvent& event );
+ bool EmitHoverEventSignal( const Dali::HoverEvent& event );
/**
* Used by the EventProcessor to emit wheel event signals.
* @param[in] event The wheel event.
* @return True if the event was consumed.
*/
- bool EmitWheelEventSignal( const WheelEvent& event );
+ bool EmitWheelEventSignal( const Dali::WheelEvent& event );
/**
- * @copydoc Dali::Actor::TouchedSignal()
+ * @brief Emits the visibility change signal for this actor and all its children.
+ * @param[in] visible Whether the actor has become visible or not.
+ * @param[in] type Whether the actor's visible property has changed or a parent's.
*/
- Dali::Actor::TouchSignalType& TouchedSignal();
+ void EmitVisibilityChangedSignal( bool visible, DevelActor::VisibilityChange::Type type );
/**
- * @copydoc Dali::Actor::TouchEventSignal()
+ * @brief Emits the layout direction change signal for this actor and all its children.
+ * @param[in] type Whether the actor's layout direction property has changed or a parent's.
*/
- Dali::Actor::TouchDataSignalType& TouchSignal();
+ void EmitLayoutDirectionChangedSignal( LayoutDirection::Type type );
+
+ /**
+ * @brief Emits the ChildAdded signal for this actor
+ * @param[in] child The child actor that has been added
+ */
+ void EmitChildAddedSignal( Actor& child );
+
+ /**
+ * @brief Emits the ChildRemoved signal for this actor
+ * @param[in] child The child actor that has been removed
+ */
+ void EmitChildRemovedSignal( Actor& child );
+
+ /**
+ * @copydoc Dali::Actor::TouchedSignal()
+ */
+ Dali::Actor::TouchEventSignalType& TouchedSignal();
/**
* @copydoc Dali::Actor::HoveredSignal()
Dali::Actor::WheelEventSignalType& WheelEventSignal();
/**
- * @copydoc Dali::Actor::OnStageSignal()
+ * @copydoc Dali::Actor::OnSceneSignal()
*/
- Dali::Actor::OnStageSignalType& OnStageSignal();
+ Dali::Actor::OnSceneSignalType& OnSceneSignal();
/**
- * @copydoc Dali::Actor::OffStageSignal()
+ * @copydoc Dali::Actor::OffSceneSignal()
*/
- Dali::Actor::OffStageSignalType& OffStageSignal();
+ Dali::Actor::OffSceneSignalType& OffSceneSignal();
/**
* @copydoc Dali::Actor::OnRelayoutSignal()
Dali::Actor::OnRelayoutSignalType& OnRelayoutSignal();
/**
+ * @copydoc DevelActor::VisibilityChangedSignal
+ */
+ DevelActor::VisibilityChangedSignalType& VisibilityChangedSignal();
+
+ /**
+ * @copydoc LayoutDirectionChangedSignal
+ */
+ Dali::Actor::LayoutDirectionChangedSignalType& LayoutDirectionChangedSignal();
+
+ /**
+ * @copydoc DevelActor::ChildAddedSignal
+ */
+ DevelActor::ChildChangedSignalType& ChildAddedSignal();
+
+ /**
+ * @copydoc DevelActor::ChildRemovedSignal
+ */
+ DevelActor::ChildChangedSignalType& ChildRemovedSignal();
+
+ /**
+ * @copydoc DevelActor::ChildOrderChangedSignal
+ */
+ DevelActor::ChildOrderChangedSignalType& ChildOrderChangedSignal();
+
+ /**
* Connects a callback function with the object's signals.
* @param[in] object The object providing the signal.
* @param[in] tracker Used to disconnect the signal.
// For Animation
/**
- * This should only be called by Animation, when the actors SIZE property is animated.
- *
- * @param[in] animation The animation that resized the actor
- * @param[in] targetSize The new target size of the actor
- */
- void NotifySizeAnimation( Animation& animation, const Vector3& targetSize );
-
- /**
- * This should only be called by Animation, when the actors SIZE_WIDTH or SIZE_HEIGHT or SIZE_DEPTH property is animated.
- *
- * @param[in] animation The animation that resized the actor
- * @param[in] targetSize The new target size of the actor
- * @param[in] property The index of the property being animated
- */
- void NotifySizeAnimation( Animation& animation, float targetSize, Property::Index property );
-
- /**
* For use in derived classes.
* This should only be called by Animation, when the actor is resized using Animation::Resize().
*/
{
}
- /**
- * This should only be called by Animation, when the actors POSITION property is animated.
- *
- * @param[in] animation The animation that repositioned the actor
- * @param[in] targetPosition The new target position of the actor
- */
- void NotifyPositionAnimation( Animation& animation, const Vector3& targetPosition );
-
- /**
- * This should only be called by Animation, when the actors POSITION_X or POSITION_Y or POSITION_Z property is animated.
- *
- * @param[in] animation The animation that repositioned the actor
- * @param[in] targetPosition The new target position of the actor
- * @param[in] property The index of the property being animated
- */
- void NotifyPositionAnimation( Animation& animation, float targetPosition, Property::Index property );
-
protected:
enum DerivedType
* Protected Constructor. See Actor::New().
* The second-phase construction Initialize() member should be called immediately after this.
* @param[in] derivedType The derived type of actor (if any).
+ * @param[in] reference to the node
*/
- Actor( DerivedType derivedType );
+ Actor( DerivedType derivedType, const SceneGraph::Node& node );
/**
* Second-phase constructor. Must be called immediately after creating a new Actor;
virtual ~Actor();
/**
- * Called on a child during Add() when the parent actor is connected to the Stage.
+ * Called on a child during Add() when the parent actor is connected to the Scene.
* @param[in] parentDepth The depth of the parent in the hierarchy.
*/
- void ConnectToStage( unsigned int parentDepth );
+ void ConnectToScene( uint32_t parentDepth );
/**
- * Helper for ConnectToStage, to recursively connect a tree of actors.
+ * Helper for ConnectToScene, to recursively connect a tree of actors.
* This is atomic i.e. not interrupted by user callbacks.
* @param[in] depth The depth in the hierarchy of the actor
* @param[out] connectionList On return, the list of connected actors which require notification.
*/
- void RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth );
+ void RecursiveConnectToScene( ActorContainer& connectionList, uint32_t depth );
/**
* Connect the Node associated with this Actor to the scene-graph.
void ConnectToSceneGraph();
/**
- * Helper for ConnectToStage, to notify a connected actor through the public API.
+ * Helper for ConnectToScene, to notify a connected actor through the public API.
*/
void NotifyStageConnection();
void NotifyStageDisconnection();
/**
- * When the Actor is OnStage, checks whether the corresponding Node is connected to the scene graph.
- * @return True if the Actor is OnStage & has a Node connected to the scene graph.
+ * When the Actor is OnScene, checks whether the corresponding Node is connected to the scene graph.
+ * @return True if the Actor is OnScene & has a Node connected to the scene graph.
*/
bool IsNodeConnected() const;
public:
-
- // Default property extensions from Object
-
/**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyCount()
+ * Trigger a rebuild of the actor depth tree from this root
+ * If a Layer3D is encountered, then this doesn't descend any further.
+ * The mSortedDepth of each actor is set appropriately.
*/
- virtual unsigned int GetDefaultPropertyCount() const;
+ void RebuildDepthTree();
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyIndices()
- */
- virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyName()
- */
- virtual const char* GetDefaultPropertyName( Property::Index index ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyIndex()
- */
- virtual Property::Index GetDefaultPropertyIndex( const std::string& name ) const;
-
- /**
- * @copydoc Dali::Internal::Object::IsDefaultPropertyWritable()
- */
- virtual bool IsDefaultPropertyWritable( Property::Index index ) const;
+protected:
/**
- * @copydoc Dali::Internal::Object::IsDefaultPropertyAnimatable()
+ * Traverse the actor tree, inserting actors into the depth tree in sibling order.
+ * @param[in] sceneGraphNodeDepths A vector capturing the nodes and their depth index
+ * @param[in,out] depthIndex The current depth index (traversal index)
*/
- virtual bool IsDefaultPropertyAnimatable( Property::Index index ) const;
+ void DepthTraverseActorTree( OwnerPointer<SceneGraph::NodeDepths>& sceneGraphNodeDepths, int32_t& depthIndex );
- /**
- * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput()
- */
- virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const;
+public:
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyType()
- */
- virtual Property::Type GetDefaultPropertyType( Property::Index index ) const;
+ // Default property extensions from Object
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
virtual Property::Value GetDefaultProperty( Property::Index index ) const;
/**
- * @copydoc Dali::Internal::Object::GetPropertyOwner()
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const;
+ virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
/**
- * @copydoc Dali::Internal::Object::GetSceneObject()
+ * @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
*/
- virtual const SceneGraph::PropertyOwner* GetSceneObject() const;
+ virtual void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType );
/**
* @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
/**
* @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
*/
- virtual int GetPropertyComponentIndex( Property::Index index ) const;
+ virtual int32_t GetPropertyComponentIndex( Property::Index index ) const;
+
+ /**
+ * Retrieve the actor's node.
+ * @return The node used by this actor
+ */
+ const SceneGraph::Node& GetNode() const
+ {
+ return *static_cast<const SceneGraph::Node*>( mUpdateObject );
+ }
/**
* @copydoc Dali::DevelActor::Raise()
*/
void LowerBelow( Internal::Actor& target );
+public:
+
+ /**
+ * Sets the scene which this actor is added to.
+ * @param[in] scene The scene
+ */
+ void SetScene( Scene& scene );
+
+ /**
+ * Gets the scene which this actor is added to.
+ * @return The scene
+ */
+ Scene& GetScene() const;
+
private:
- // Undefined
- Actor();
+ struct SendMessage
+ {
+ enum Type
+ {
+ FALSE = 0,
+ TRUE = 1,
+ };
+ };
- // Undefined
- Actor( const Actor& );
+ struct AnimatedSizeFlag
+ {
+ enum Type
+ {
+ CLEAR = 0,
+ WIDTH = 1,
+ HEIGHT = 2,
+ DEPTH = 4
+ };
+ };
- // Undefined
- Actor& operator=( const Actor& rhs );
+ // Remove default constructor and copy constructor
+ Actor() = delete;
+ Actor( const Actor& ) = delete;
+ Actor& operator=( const Actor& rhs ) = delete;
/**
* Set the actors parent.
void SetParent( Actor* parent );
/**
- * Helper to create a Node for this Actor.
- * To be overriden in derived classes.
- * @return A newly allocated node.
- */
- virtual SceneGraph::Node* CreateNode() const;
-
- /**
* For use in derived classes, called after Initialize()
*/
virtual void OnInitialize()
/**
* For use in internal derived classes.
- * This is called during ConnectToStage(), after the actor has finished adding its node to the scene-graph.
+ * This is called during ConnectToScene(), after the actor has finished adding its node to the scene-graph.
* The derived class must not modify the actor hierachy (Add/Remove children) during this callback.
*/
- virtual void OnStageConnectionInternal()
+ virtual void OnSceneConnectionInternal()
{
}
* This is called during DisconnectFromStage(), before the actor removes its node from the scene-graph.
* The derived class must not modify the actor hierachy (Add/Remove children) during this callback.
*/
- virtual void OnStageDisconnectionInternal()
+ virtual void OnSceneDisconnectionInternal()
{
}
/**
* For use in external (CustomActor) derived classes.
- * This is called after the atomic ConnectToStage() traversal has been completed.
+ * This is called after the atomic ConnectToScene() traversal has been completed.
*/
- virtual void OnStageConnectionExternal( int depth )
+ virtual void OnSceneConnectionExternal( int depth )
{
}
* For use in external (CustomActor) derived classes.
* This is called after the atomic DisconnectFromStage() traversal has been completed.
*/
- virtual void OnStageDisconnectionExternal()
+ virtual void OnSceneDisconnectionExternal()
{
}
/**
* For use in derived classes.
- * This is only called if mDerivedRequiresTouch is true, and the touch-signal was not consumed.
- * @param[in] event The touch event.
- * @return True if the event should be consumed.
- */
- virtual bool OnTouchEvent( const TouchEvent& event )
- {
- return false;
- }
-
- /**
- * For use in derived classes.
* This is only called if mDerivedRequiresHover is true, and the hover-signal was not consumed.
* @param[in] event The hover event.
* @return True if the event should be consumed.
}
/**
+ * @brief Retrieves the cached event side value of a default property.
+ * @param[in] index The index of the property
+ * @param[out] value Is set with the cached value of the property if found.
+ * @return True if value set, false otherwise.
+ */
+ bool GetCachedPropertyValue( Property::Index index, Property::Value& value ) const;
+
+ /**
+ * @brief Retrieves the current value of a default property from the scene-graph.
+ * @param[in] index The index of the property
+ * @param[out] value Is set with the current scene-graph value of the property
+ * @return True if value set, false otherwise.
+ */
+ bool GetCurrentPropertyValue( Property::Index index, Property::Value& value ) const;
+
+ /**
* @brief Ensure the relayout data is allocated
*/
void EnsureRelayoutData();
* @param[in] size The size to apply the policy to
* @return Return the adjusted size
*/
- Vector2 ApplySizeSetPolicy( const Vector2 size );
+ Vector2 ApplySizeSetPolicy( const Vector2& size );
/**
* Retrieve the parent object of an Actor.
/**
* Set Sibling order
- * @param[in] order The sibling order this Actor should be
+ * @param[in] order The sibling order this Actor should be. It will place
+ * the actor at this index in it's parent's child array.
*/
- void SetSiblingOrder( unsigned int order);
+ void SetSiblingOrder( uint32_t order);
/**
- * @brief Re-orders the sibling order when any actor raised to the max level
- * @param[in] siblings the container of sibling actors
+ * Get Sibling order
+ * @return the order of this actor amongst it's siblings
*/
- void DefragmentSiblingIndexes( ActorContainer& siblings );
+ uint32_t GetSiblingOrder() const;
/**
- * @brief Shifts all siblings levels from the target level up by 1 to make space for a newly insert sibling
- * at an exclusive level.
- *
- * @note Used with Raise and Lower API
- *
- * @param[in] siblings the actor container of the siblings
- * @param[in] targetLevelToShiftFrom the sibling level to start shifting from
+ * Request that the stage rebuilds the actor depth indices.
*/
- bool ShiftSiblingsLevels( ActorContainer& siblings, int targetLevelToShiftFrom );
-
+ void RequestRebuildDepthTree();
/**
* @brief Get the current position of the actor in screen coordinates.
*/
const Vector2 GetCurrentScreenPosition() const;
+ /**
+ * Sets the visibility flag of an actor.
+ * @param[in] visible The new visibility flag.
+ * @param[in] sendMessage Whether to send a message to the update thread or not.
+ */
+ void SetVisibleInternal( bool visible, SendMessage::Type sendMessage );
+
+ /**
+ * Set whether a child actor inherits it's parent's layout direction. Default is to inherit.
+ * @param[in] inherit - true if the actor should inherit layout direction, false otherwise.
+ */
+ void SetInheritLayoutDirection( bool inherit );
+
+ /**
+ * Returns whether the actor inherits it's parent's layout direction.
+ * @return true if the actor inherits it's parent's layout direction, false otherwise.
+ */
+ bool IsLayoutDirectionInherited() const;
+
+ /**
+ * @brief Propagates layout direction recursively.
+ * @param[in] actor The actor for seting layout direction.
+ * @param[in] direction New layout direction.
+ */
+ void InheritLayoutDirectionRecursively( ActorPtr actor, Dali::LayoutDirection::Type direction, bool set = false );
+
+ /**
+ * @brief Sets the update size hint of an actor.
+ * @param [in] updateSizeHint The update size hint.
+ */
+ void SetUpdateSizeHint( const Vector2& updateSizeHint );
+
+ /**
+ * @brief Return the update size hint of actor
+ * @return Return the update size hint
+ */
+ Vector2 GetUpdateSizeHint() const;
+
protected:
+ Scene* mScene; ///< The scene the actor is added to
+
Actor* mParent; ///< Each actor (except the root) can have one parent
- ActorContainer* mChildren; ///< Container of referenced actors
+ ActorContainer* mChildren; ///< Container of referenced actors, lazily initialized
RendererContainer* mRenderers; ///< Renderer container
- const SceneGraph::Node* mNode; ///< Not owned
Vector3* mParentOrigin; ///< NULL means ParentOrigin::DEFAULT. ParentOrigin is non-animatable
Vector3* mAnchorPoint; ///< NULL means AnchorPoint::DEFAULT. AnchorPoint is non-animatable
ActorGestureData* mGestureData; ///< Optional Gesture data. Only created when actor requires gestures
// Signals
- Dali::Actor::TouchSignalType mTouchedSignal;
- Dali::Actor::TouchDataSignalType mTouchSignal;
+ Dali::Actor::TouchEventSignalType mTouchedSignal;
Dali::Actor::HoverSignalType mHoveredSignal;
Dali::Actor::WheelEventSignalType mWheelEventSignal;
- Dali::Actor::OnStageSignalType mOnStageSignal;
- Dali::Actor::OffStageSignalType mOffStageSignal;
+ Dali::Actor::OnSceneSignalType mOnSceneSignal;
+ Dali::Actor::OffSceneSignalType mOffSceneSignal;
Dali::Actor::OnRelayoutSignalType mOnRelayoutSignal;
-
- Vector3 mTargetSize; ///< Event-side storage for size (not a pointer as most actors will have a size)
- Vector3 mTargetPosition; ///< Event-side storage for position (not a pointer as most actors will have a position)
-
- std::string mName; ///< Name of the actor
- unsigned int mId; ///< A unique ID to identify the actor starting from 1, and 0 is reserved
-
- uint16_t mDepth; ///< The depth in the hierarchy of the actor. Only 4096 levels of depth are supported
- uint16_t mSiblingOrder; ///< The sibling order of the actor
+ DevelActor::VisibilityChangedSignalType mVisibilityChangedSignal;
+ Dali::Actor::LayoutDirectionChangedSignalType mLayoutDirectionChangedSignal;
+ DevelActor::ChildChangedSignalType mChildAddedSignal;
+ DevelActor::ChildChangedSignalType mChildRemovedSignal;
+ DevelActor::ChildOrderChangedSignalType mChildOrderChangedSignal;
+
+ Quaternion mTargetOrientation; ///< Event-side storage for orientation
+ Vector4 mTargetColor; ///< Event-side storage for color
+ Vector3 mTargetSize; ///< Event-side storage for size (not a pointer as most actors will have a size)
+ Vector3 mTargetPosition; ///< Event-side storage for position (not a pointer as most actors will have a position)
+ Vector3 mTargetScale; ///< Event-side storage for scale
+ Vector3 mAnimatedSize; ///< Event-side storage for size animation
+
+ std::string mName; ///< Name of the actor
+ uint32_t mSortedDepth; ///< The sorted depth index. A combination of tree traversal and sibling order.
+ int16_t mDepth; ///< The depth in the hierarchy of the actor. Only 32,767 levels of depth are supported
+ uint16_t mUseAnimatedSize; ///< Whether the size is animated.
const bool mIsRoot : 1; ///< Flag to identify the root actor
const bool mIsLayer : 1; ///< Flag to identify that this is a layer
- bool mIsOnStage : 1; ///< Flag to identify whether the actor is on-stage
+ bool mIsOnScene : 1; ///< Flag to identify whether the actor is on-scene
bool mSensitive : 1; ///< Whether the actor emits touch event signals
bool mLeaveRequired : 1; ///< Whether a touch event signal is emitted when the a touch leaves the actor's bounds
bool mKeyboardFocusable : 1; ///< Whether the actor should be focusable by keyboard navigation
bool mDerivedRequiresTouch : 1; ///< Whether the derived actor type requires touch event signals
bool mDerivedRequiresHover : 1; ///< Whether the derived actor type requires hover event signals
bool mDerivedRequiresWheelEvent : 1; ///< Whether the derived actor type requires wheel event signals
- bool mOnStageSignalled : 1; ///< Set to true before OnStageConnection signal is emitted, and false before OnStageDisconnection
+ bool mOnSceneSignalled : 1; ///< Set to true before OnSceneConnection signal is emitted, and false before OnSceneDisconnection
bool mInsideOnSizeSet : 1; ///< Whether we are inside OnSizeSet
bool mInheritPosition : 1; ///< Cached: Whether the parent's position should be inherited.
bool mInheritOrientation : 1; ///< Cached: Whether the parent's orientation should be inherited.
bool mInheritScale : 1; ///< Cached: Whether the parent's scale should be inherited.
- DrawMode::Type mDrawMode : 2; ///< Cached: How the actor and its children should be drawn
- PositionInheritanceMode mPositionInheritanceMode : 2; ///< Cached: Determines how position is inherited
- ColorMode mColorMode : 2; ///< Cached: Determines whether mWorldColor is inherited
- ClippingMode::Type mClippingMode : 2; ///< Cached: Determines which clipping mode (if any) to use.
+ bool mPositionUsesAnchorPoint : 1; ///< Cached: Whether the position uses the anchor point or not.
+ bool mVisible : 1; ///< Cached: Whether the actor is visible or not.
+ bool mInheritLayoutDirection : 1; ///< Whether the actor inherits the layout direction from parent.
+ bool mCaptureAllTouchAfterStart : 1; ///< Whether the actor should capture all touch after touch starts even if the motion moves outside of the actor area.
+ LayoutDirection::Type mLayoutDirection : 2; ///< Layout direction, Left to Right or Right to Left.
+ DrawMode::Type mDrawMode : 3; ///< Cached: How the actor and its children should be drawn
+ ColorMode mColorMode : 3; ///< Cached: Determines whether mWorldColor is inherited
+ ClippingMode::Type mClippingMode : 3; ///< Cached: Determines which clipping mode (if any) to use.
private:
static ActorContainer mNullChildren; ///< Empty container (shared by all actors, returned by GetChildren() const)
- static unsigned int mActorCounter; ///< A counter to track the actor instance creation
+
};
} // namespace Internal