#define DALI_INTERNAL_ACTOR_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 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.
#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
{
/**
* 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 );
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 );
void EmitVisibilityChangedSignal( bool visible, DevelActor::VisibilityChange::Type type );
/**
+ * @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.
+ */
+ 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::TouchSignalType& TouchedSignal();
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
void RebuildDepthTree();
protected:
-
/**
* Traverse the actor tree, inserting actors into the depth tree in sibling order.
- * For all actors that share a sibling order, they also share a depth tree, for
- * optimal render performance.
- * @param[in] nodeMemoryPool The memory pool used to allocate depth nodes
- * @param[in,out] depthTreeNode The depth tree node to which to add this actor's children
- * @return The count of actors in this depth tree
+ * @param[in] sceneGraphNodeDepths A vector capturing the nodes and their depth index
+ * @param[in,out] depthIndex The current depth index (traversal index)
*/
- int BuildDepthTree( DepthNodeMemoryPool& nodeMemoryPool, ActorDepthTreeNode* depthTreeNode );
+ void DepthTraverseActorTree( OwnerPointer<SceneGraph::NodeDepths>& sceneGraphNodeDepths, int& depthIndex );
public:
virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
/**
+ * @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
+ */
+ virtual void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType );
+
+ /**
* @copydoc Dali::Internal::Object::GetPropertyOwner()
*/
virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const;
private:
- // Undefined
- Actor();
+ struct SendMessage
+ {
+ enum Type
+ {
+ FALSE = 0,
+ TRUE = 1,
+ };
+ };
- // Undefined
- Actor( const Actor& );
+ // Remove default constructor and copy constructor
+ Actor()=delete;
+ Actor( const Actor& )=delete;
// Undefined
Actor& operator=( const Actor& rhs );
* @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);
/**
- * @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 );
+ unsigned int 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 );
+
protected:
Actor* mParent; ///< Each actor (except the root) can have one parent
Dali::Actor::OffStageSignalType mOffStageSignal;
Dali::Actor::OnRelayoutSignalType mOnRelayoutSignal;
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
uint32_t mSortedDepth; ///< The sorted depth index. A combination of tree traversal and sibling order.
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
+
const bool mIsRoot : 1; ///< Flag to identify the root actor
const bool mIsLayer : 1; ///< Flag to identify that this is a layer
bool mInheritScale : 1; ///< Cached: Whether the parent's scale should be inherited.
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.
+ LayoutDirection::Type mLayoutDirection : 1; ///< Layout direction, Left to Right or Right to Left.
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
static unsigned int mActorCounter; ///< A counter to track the actor instance creation
};
-/**
- * Helper class to create sorted depth index
- */
-class ActorDepthTreeNode
-{
-public:
- ActorDepthTreeNode()
- : mParentNode(NULL),
- mNextSiblingNode(NULL),
- mFirstChildNode(NULL),
- mSiblingOrder( 0 )
- {
- }
-
- ActorDepthTreeNode( Actor* actor, uint16_t siblingOrder )
- : mParentNode(NULL),
- mNextSiblingNode(NULL),
- mFirstChildNode(NULL),
- mSiblingOrder( siblingOrder )
- {
- mActors.push_back( actor );
- }
-
- ~ActorDepthTreeNode()
- {
- if( mFirstChildNode )
- {
- delete mFirstChildNode;
- mFirstChildNode = NULL;
- }
- if( mNextSiblingNode )
- {
- delete mNextSiblingNode;
- mNextSiblingNode = NULL;
- }
- mParentNode = NULL;
- }
-
- uint16_t GetSiblingOrder()
- {
- return mSiblingOrder;
- }
-
- void AddActor( Actor* actor )
- {
- mActors.push_back( actor );
- }
-
-public:
- std::vector<Actor*> mActors; // Array of actors with the same sibling order and same ancestor sibling orders
- ActorDepthTreeNode* mParentNode;
- ActorDepthTreeNode* mNextSiblingNode;
- ActorDepthTreeNode* mFirstChildNode;
- uint16_t mSiblingOrder;
-
-private:
- ActorDepthTreeNode( ActorDepthTreeNode& );
- ActorDepthTreeNode& operator=(const ActorDepthTreeNode& );
-};
-
-
} // namespace Internal
// Helpers for public-api forwarding methods
projects / platform / core / uifw / dali-core.git / blobdiff