#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/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
{
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.
* 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.
/**
* 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 );
}
/**
- * 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
*/
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
bool IsNodeConnected() const;
public:
+ /**
+ * 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.
+ */
+ void RebuildDepthTree();
+
+protected:
+ /**
+ * 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)
+ */
+ void DepthTraverseActorTree( OwnerPointer<SceneGraph::NodeDepths>& sceneGraphNodeDepths, int& depthIndex );
+
+public:
// Default property extensions from Object
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
std::string mName; ///< Name of the actor
unsigned int mId; ///< A unique ID to identify the actor starting from 1, and 0 is reserved
+ 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.
- 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 mInheritLayoutDirection : 1; ///< Whether the actor inherits the layout direction from parent.
+ 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
+ PositionInheritanceMode mPositionInheritanceMode : 3; ///< Cached: Determines how position is inherited
+ ColorMode mColorMode : 3; ///< Cached: Determines whether mWorldColor is inherited
+ ClippingMode::Type mClippingMode : 3; ///< Cached: Determines which clipping mode (if any) to use.
private:
projects / platform / core / uifw / dali-core.git / blobdiff