X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Factors%2Factor-impl.h;h=9ca88450b71a24022cec87e1e8123fdfdb244eb3;hb=462cbee2270984cdca45488f3733d664dcf49187;hp=5f5d900e8d19923ad93b7a08c145702959a4c4e2;hpb=b2b474f488d2bcb9f688a5106f578d141bbb8ddd;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/event/actors/actor-impl.h b/dali/internal/event/actors/actor-impl.h index 5f5d900..59e23d0 100644 --- a/dali/internal/event/actors/actor-impl.h +++ b/dali/internal/event/actors/actor-impl.h @@ -1,8 +1,8 @@ -#ifndef __DALI_INTERNAL_ACTOR_H__ -#define __DALI_INTERNAL_ACTOR_H__ +#ifndef DALI_INTERNAL_ACTOR_H +#define DALI_INTERNAL_ACTOR_H /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2017 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. @@ -22,31 +22,28 @@ #include // INTERNAL INCLUDES -#include -#include #include +#include +#include #include #include #include -#include +#include #include -#include +#include #include -#include -#include +#include +#include +#include #include -#ifdef DYNAMICS_SUPPORT -#include -#endif - namespace Dali { struct KeyEvent; -struct TouchEvent; +class TouchData; struct HoverEvent; -struct MouseWheelEvent; +struct WheelEvent; namespace Internal { @@ -56,21 +53,25 @@ class ActorGestureData; class Animation; class RenderTask; class Renderer; -struct DynamicsData; -typedef IntrusivePtr< Actor > ActorPtr; -typedef Dali::ActorContainer ActorContainer; // Store handles to return via public-api +typedef std::vector< ActorPtr > ActorContainer; typedef ActorContainer::iterator ActorIter; typedef ActorContainer::const_iterator ActorConstIter; +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. * Multi-Touch events are received through signals emitted by the actor tree. * * An Actor is a proxy for a Node in the scene graph. - * When an Actor is added to the Stage, it creates a node and attaches it to the scene graph. - * The scene-graph can be updated in a separate thread, so the attachment is done using an asynchronous message. + * When an Actor is added to the Stage, it creates a node and connects it to the scene graph. + * The scene-graph can be updated in a separate thread, so the connection is done using an asynchronous message. * When a tree of Actors is detached from the Stage, a message is sent to destroy the associated nodes. */ class Actor : public Object @@ -88,7 +89,7 @@ public: * @param[in] newActor The actor to assign * @param[in] newDimension The dimension to assign */ - ActorDimensionPair( Actor* newActor, Dimension newDimension ) + ActorDimensionPair( Actor* newActor, Dimension::Type newDimension ) : actor( newActor ), dimension( newDimension ) { @@ -106,7 +107,7 @@ public: } Actor* actor; ///< The actor to hold - Dimension dimension; ///< The dimension to hold + Dimension::Type dimension; ///< The dimension to hold }; typedef std::vector< ActorDimensionPair > ActorDimensionStack; @@ -136,21 +137,6 @@ public: */ unsigned int GetId() const; - // Attachments - - /** - * Attach an object to an actor. - * @pre The actor does not already have an attachment. - * @param[in] attachment The object to attach. - */ - void Attach( ActorAttachment& attachment ); - - /** - * Retreive the object attached to an actor. - * @return The attachment. - */ - ActorAttachmentPtr GetAttachment(); - // Containment /** @@ -168,13 +154,13 @@ public: bool OnStage() const; /** - * Query whether the actor is a RenderableActor derived type. + * Query whether the actor has any renderers. * @return True if the actor is renderable. */ bool IsRenderable() const { // inlined as this is called a lot in hit testing - return mIsRenderable; + return mRenderers && !mRenderers->empty(); } /** @@ -203,16 +189,6 @@ public: void Add( Actor& child ); /** - * Inserts a child Actor to this Actor's child list - * @pre The child actor is not the same as the parent actor. - * @pre The child actor does not already have a parent. - * @param [in] index in childlist to insert child at - * @param [in] child The child. - * @post The child will be referenced by its parent. - */ - void Insert( unsigned int index, Actor& child ); - - /** * Removes a child Actor from this Actor. * @param [in] child The child. * @post The child will be unreferenced. @@ -233,24 +209,13 @@ public: /** * @copydoc Dali::Actor::GetChildAt */ - Dali::Actor GetChildAt( unsigned int index ) const; - - /** - * Retrieve the Actor's children. - * @return A copy of the container of children. - */ - ActorContainer GetChildren(); - - /** - * Retrieve the Actor's children. - * @return A const reference to the container of children. - */ - const ActorContainer& GetChildren() const; + ActorPtr GetChildAt( unsigned int 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() { @@ -278,7 +243,6 @@ public: /** * Sets the size of an actor. - * ActorAttachments attached to the actor, can be scaled to fit within this area. * This does not interfere with the actors scale factor. * @param [in] width The new width. * @param [in] height The new height. @@ -287,7 +251,6 @@ public: /** * Sets the size of an actor. - * ActorAttachments attached to the actor, can be scaled to fit within this area. * This does not interfere with the actors scale factor. * @param [in] width The size of the actor along the x-axis. * @param [in] height The size of the actor along the y-axis. @@ -297,21 +260,33 @@ public: /** * Sets the size of an actor. - * ActorAttachments attached to the actor, can be scaled to fit within this area. * This does not interfere with the actors scale factor. * @param [in] size The new size. */ void SetSize( const Vector2& size ); /** + * Sets the update size for an actor. + * + * @param[in] size The size to set. + */ + void SetSizeInternal( const Vector2& size ); + + /** * Sets the size of an actor. - * ActorAttachments attached to the actor, can be scaled to fit within this area. * This does not interfere with the actors scale factor. * @param [in] size The new size. */ void SetSize( const Vector3& size ); /** + * Sets the update size for an actor. + * + * @param[in] size The size to set. + */ + void SetSizeInternal( const Vector3& size ); + + /** * Set the width component of the Actor's size. * @param [in] width The new width component. */ @@ -334,7 +309,7 @@ public: * 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. @@ -475,6 +450,13 @@ public: const Vector3& GetCurrentPosition() const; /** + * Retrieve the target position of the Actor. + * The coordinates are relative to the Actor's parent. + * @return the Actor's position. + */ + const Vector3& GetTargetPosition() const; + + /** * @copydoc Dali::Actor::GetCurrentWorldPosition() */ const Vector3& GetCurrentWorldPosition() const; @@ -490,6 +472,16 @@ public: PositionInheritanceMode GetPositionInheritanceMode() const; /** + * @copydoc Dali::Actor::SetInheritPosition() + */ + void SetInheritPosition( bool inherit ); + + /** + * @copydoc Dali::Actor::IsPositionInherited() + */ + bool IsPositionInherited() const; + + /** * Sets the orientation of the Actor. * @param [in] angleRadians The new orientation angle in radians. * @param [in] axis The new axis of orientation. @@ -535,27 +527,15 @@ public: bool IsOrientationInherited() const; /** - * @brief Defines how a child actors size is affected by its parents size. - * @param[in] mode The size relative to parent mode to use. - */ - void SetSizeMode( SizeMode mode ); - - /** - * Query how the child actors size is affected by its parents size. - * @return The size relative to parent mode in use. - */ - SizeMode GetSizeMode() const; - - /** * Sets the factor of the parents size used for the child actor. - * Note: Only used if SizeMode is SIZE_RELATIVE_TO_PARENT or SIZE_FIXED_OFFSET_FROM_PARENT. + * Note: Only used if ResizePolicy is ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT. * @param[in] factor The vector to multiply the parents size by to get the childs size. */ void SetSizeModeFactor( const Vector3& factor ); /** * Gets the factor of the parents size used for the child actor. - * Note: Only used if SizeMode is SIZE_RELATIVE_TO_PARENT or SIZE_FIXED_OFFSET_FROM_PARENT. + * Note: Only used if ResizePolicy is ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT. * @return The vector being used to multiply the parents size by to get the childs size. */ const Vector3& GetSizeModeFactor() const; @@ -639,7 +619,7 @@ public: /** * 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 ); @@ -662,6 +642,12 @@ public: float GetCurrentOpacity() const; /** + * Retrieve the actor's clipping mode. + * @return The actor's clipping mode (cached) + */ + ClippingMode::Type GetClippingMode() const; + + /** * Sets whether an actor should emit touch or hover signals; see SignalTouch() and SignalHover(). * An actor is sensitive by default, which means that as soon as an application connects to the SignalTouch(), * the touch event signal will be emitted, and as soon as an application connects to the SignalHover(), the @@ -707,11 +693,6 @@ public: DrawMode::Type GetDrawMode() const; /** - * @copydoc Dali::Actor::SetOverlay - */ - void SetOverlay( bool enable ); - - /** * @copydoc Dali::Actor::IsOverlay */ bool IsOverlay() const; @@ -765,6 +746,26 @@ public: */ const Vector4& GetCurrentWorldColor() const; + /** + * @copydoc Dali::Actor::GetHierarchyDepth() + */ + inline int GetHierarchyDepth() const + { + if( mIsOnStage ) + { + return static_cast(mDepth); + } + + return -1; + } + + /** + * Get the actor's sorting depth + * + * @return The depth used for hit-testing and renderer sorting + */ + unsigned int GetSortingDepth(); + public: // Size negotiation virtual functions @@ -795,7 +796,7 @@ public: * @param[in] policy The policy being set * @param[in] dimension The dimension the policy is being set for */ - virtual void OnSetResizePolicy( ResizePolicy policy, Dimension dimension ) {} + virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension ) {} /** * @brief Virtual method to notify deriving classes that relayout dependencies have been @@ -803,7 +804,7 @@ public: * * @param dimension The dimension that is about to be calculated */ - virtual void OnCalculateRelayoutSize( Dimension dimension ); + virtual void OnCalculateRelayoutSize( Dimension::Type dimension ); /** * @brief Virtual method to notify deriving classes that the size for a dimension @@ -812,7 +813,7 @@ public: * @param[in] size The new size for the given dimension * @param[in] dimension The dimension that was just negotiated */ - virtual void OnLayoutNegotiated( float size, Dimension dimension ); + virtual void OnLayoutNegotiated( float size, Dimension::Type dimension ); /** * @brief Determine if this actor is dependent on it's children for relayout @@ -820,7 +821,7 @@ public: * @param dimension The dimension(s) to check for * @return Return if the actor is dependent on it's children */ - virtual bool RelayoutDependentOnChildren( Dimension dimension = ALL_DIMENSIONS ); + virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** * @brief Determine if this actor is dependent on it's children for relayout. @@ -830,7 +831,7 @@ public: * @param dimension The dimension(s) to check for * @return Return if the actor is dependent on it's children */ - virtual bool RelayoutDependentOnChildrenBase( Dimension dimension = ALL_DIMENSIONS ); + virtual bool RelayoutDependentOnChildrenBase( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** * @brief Calculate the size for a child @@ -839,7 +840,7 @@ public: * @param[in] dimension The dimension to calculate the size for. E.g. width or height. * @return Return the calculated size for the given dimension */ - virtual float CalculateChildSize( const Dali::Actor& child, Dimension dimension ); + virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension ); /** * @brief This method is called during size negotiation when a height is required for a given width. @@ -880,42 +881,64 @@ 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 policy, Dimension dimension = ALL_DIMENSIONS ); + void SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** * @copydoc Dali::Actor::GetResizePolicy() */ - ResizePolicy GetResizePolicy( Dimension dimension ) const; + ResizePolicy::Type GetResizePolicy( Dimension::Type dimension ) const; /** * @copydoc Dali::Actor::SetSizeScalePolicy() */ - void SetSizeScalePolicy( SizeScalePolicy policy ); + void SetSizeScalePolicy( SizeScalePolicy::Type policy ); /** * @copydoc Dali::Actor::GetSizeScalePolicy() */ - SizeScalePolicy GetSizeScalePolicy() const; + SizeScalePolicy::Type GetSizeScalePolicy() const; /** * @copydoc Dali::Actor::SetDimensionDependency() */ - void SetDimensionDependency( Dimension dimension, Dimension dependency ); + void SetDimensionDependency( Dimension::Type dimension, Dimension::Type dependency ); /** * @copydoc Dali::Actor::GetDimensionDependency() */ - Dimension GetDimensionDependency( Dimension dimension ) const; + Dimension::Type GetDimensionDependency( Dimension::Type dimension ) const; /** - * @copydoc Dali::Actor::SetRelayoutEnabled() + * @brief Set the size negotiation relayout enabled on this actor + * + * @param[in] relayoutEnabled Boolean to enable or disable relayout */ void SetRelayoutEnabled( bool relayoutEnabled ); /** - * @copydoc Dali::Actor::IsRelayoutEnabled() + * @brief Return if relayout is enabled + * + * @return Return if relayout is enabled or not for this actor */ bool IsRelayoutEnabled() const; @@ -925,7 +948,7 @@ public: * @param dirty Whether to mark actor as dirty or not * @param dimension The dimension(s) to mark as dirty */ - void SetLayoutDirty( bool dirty, Dimension dimension = ALL_DIMENSIONS ); + void SetLayoutDirty( bool dirty, Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** * @brief Return if any of an actor's dimensions are marked as dirty @@ -933,21 +956,21 @@ public: * @param dimension The dimension(s) to check * @return Return if any of the requested dimensions are dirty */ - bool IsLayoutDirty( Dimension dimension = ALL_DIMENSIONS ) const; + bool IsLayoutDirty( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) const; /** * @brief Returns if relayout is enabled and the actor is not dirty * * @return Return if it is possible to relayout the actor */ - bool RelayoutPossible( Dimension dimension = ALL_DIMENSIONS ) const; + bool RelayoutPossible( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) const; /** * @brief Returns if relayout is enabled and the actor is dirty * * @return Return if it is required to relayout the actor */ - bool RelayoutRequired( Dimension dimension = ALL_DIMENSIONS ) const; + bool RelayoutRequired( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) const; /** * @brief Request a relayout, which means performing a size negotiation on this actor, its parent and children (and potentially whole scene) @@ -962,21 +985,7 @@ public: * @note RelayoutRequest() can be called multiple times; the size negotiation is still * only performed once, i.e. there is no need to keep track of this in the calling side. */ - void RelayoutRequest( Dimension dimension = ALL_DIMENSIONS ); - - /** - * @brief Request to relayout of all actors in the sub-tree below the given actor. - * - * This flags the actor and all actors below it for relayout. The actual - * relayout is performed at the end of the frame. This means that multiple calls to relayout - * will not cause multiple relayouts to occur. - */ - void RelayoutRequestTree(); - - /* - * @copydoc Dali::Actor::PropagateRelayoutFlags - */ - void PropagateRelayoutFlags(); + void RelayoutRequest( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** * @brief Determine if this actor is dependent on it's parent for relayout @@ -984,7 +993,7 @@ public: * @param dimension The dimension(s) to check for * @return Return if the actor is dependent on it's parent */ - bool RelayoutDependentOnParent( Dimension dimension = ALL_DIMENSIONS ); + bool RelayoutDependentOnParent( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** * @brief Determine if this actor has another dimension depedent on the specified one @@ -993,7 +1002,7 @@ public: * @param dependentDimension The dimension to check for dependency with * @return Return if the actor is dependent on this dimension */ - bool RelayoutDependentOnDimension( Dimension dimension, Dimension dependentDimension ); + bool RelayoutDependentOnDimension( Dimension::Type dimension, Dimension::Type dependentDimension ); /** * Negotiate sizes for a control in all dimensions @@ -1015,7 +1024,7 @@ public: * @param[in] dimension The dimension to negotiate on * @param[in] allocatedSize The size constraint that the actor must respect */ - void NegotiateDimension( Dimension dimension, const Vector2& allocatedSize, ActorDimensionStack& recursionStack ); + void NegotiateDimension( Dimension::Type dimension, const Vector2& allocatedSize, ActorDimensionStack& recursionStack ); /** * @brief Calculate the size of a dimension @@ -1024,16 +1033,16 @@ public: * @param[in] maximumSize The upper bounds on the size * @return Return the calculated size for the dimension */ - float CalculateSize( Dimension dimension, const Vector2& maximumSize ); + float CalculateSize( Dimension::Type dimension, const Vector2& maximumSize ); /** - * @brief Constain a dimension given the relayout constraints on this actor + * @brief Clamp a dimension given the relayout constraints on this actor * * @param[in] size The size to constrain * @param[in] dimension The dimension the size exists in - * @return Return the constrained size + * @return Return the clamped size */ - float ConstrainDimension( float size, Dimension dimension ); + float ClampDimension( float size, Dimension::Type dimension ); /** * Negotiate a dimension based on the size of the parent @@ -1041,7 +1050,7 @@ public: * @param[in] dimension The dimension to negotiate on * @return Return the negotiated size */ - float NegotiateFromParent( Dimension dimension ); + float NegotiateFromParent( Dimension::Type dimension ); /** * Negotiate a dimension based on the size of the parent. Fitting inside. @@ -1049,7 +1058,7 @@ public: * @param[in] dimension The dimension to negotiate on * @return Return the negotiated size */ - float NegotiateFromParentFit( Dimension dimension ); + float NegotiateFromParentFit( Dimension::Type dimension ); /** * Negotiate a dimension based on the size of the parent. Flooding the whole space. @@ -1057,7 +1066,7 @@ public: * @param[in] dimension The dimension to negotiate on * @return Return the negotiated size */ - float NegotiateFromParentFlood( Dimension dimension ); + float NegotiateFromParentFlood( Dimension::Type dimension ); /** * @brief Negotiate a dimension based on the size of the children @@ -1065,7 +1074,7 @@ public: * @param[in] dimension The dimension to negotiate on * @return Return the negotiated size */ - float NegotiateFromChildren( Dimension dimension ); + float NegotiateFromChildren( Dimension::Type dimension ); /** * Set the negotiated dimension value for the given dimension(s) @@ -1073,7 +1082,7 @@ public: * @param negotiatedDimension The value to set * @param dimension The dimension(s) to set the value for */ - void SetNegotiatedDimension( float negotiatedDimension, Dimension dimension = ALL_DIMENSIONS ); + void SetNegotiatedDimension( float negotiatedDimension, Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** * Return the value of negotiated dimension for the given dimension @@ -1081,7 +1090,7 @@ public: * @param dimension The dimension to retrieve * @return Return the value of the negotiated dimension */ - float GetNegotiatedDimension( Dimension dimension ) const; + float GetNegotiatedDimension( Dimension::Type dimension ) const; /** * @brief Set the padding for a dimension @@ -1089,7 +1098,7 @@ public: * @param[in] padding Padding for the dimension. X = start (e.g. left, bottom), y = end (e.g. right, top) * @param[in] dimension The dimension to set */ - void SetPadding( const Vector2& padding, Dimension dimension ); + void SetPadding( const Vector2& padding, Dimension::Type dimension ); /** * Return the value of padding for the given dimension @@ -1097,7 +1106,7 @@ public: * @param dimension The dimension to retrieve * @return Return the value of padding for the dimension */ - Vector2 GetPadding( Dimension dimension ) const; + Vector2 GetPadding( Dimension::Type dimension ) const; /** * Return the actor size for a given dimension @@ -1105,7 +1114,7 @@ public: * @param[in] dimension The dimension to retrieve the size for * @return Return the size for the given dimension */ - float GetSize( Dimension dimension ) const; + float GetSize( Dimension::Type dimension ) const; /** * Return the natural size of the actor for a given dimension @@ -1113,7 +1122,7 @@ public: * @param[in] dimension The dimension to retrieve the size for * @return Return the natural size for the given dimension */ - float GetNaturalSize( Dimension dimension ) const; + float GetNaturalSize( Dimension::Type dimension ) const; /** * @brief Return the amount of size allocated for relayout @@ -1123,7 +1132,7 @@ public: * @param[in] dimension The dimension to retrieve * @return Return the size */ - float GetRelayoutSize( Dimension dimension ) const; + float GetRelayoutSize( Dimension::Type dimension ) const; /** * @brief If the size has been negotiated return that else return normal size @@ -1131,7 +1140,7 @@ public: * @param[in] dimension The dimension to retrieve * @return Return the size */ - float GetLatestSize( Dimension dimension ) const; + float GetLatestSize( Dimension::Type dimension ) const; /** * Apply the negotiated size to the actor @@ -1146,7 +1155,7 @@ public: * @param[in] negotiated The status of the flag to set. * @param[in] dimension The dimension to set the flag for */ - void SetLayoutNegotiated( bool negotiated, Dimension dimension = ALL_DIMENSIONS ); + void SetLayoutNegotiated( bool negotiated, Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** * @brief Test whether the layout dimension for this actor has been negotiated or not. @@ -1154,7 +1163,21 @@ public: * @param[in] dimension The dimension to determine the value of the flag for * @return Return if the layout dimension is negotiated or not. */ - bool IsLayoutNegotiated( Dimension dimension = ALL_DIMENSIONS ) const; + bool IsLayoutNegotiated( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) const; + + /** + * @brief provides the Actor implementation of GetHeightForWidth + * @param width to use. + * @return the height based on the width. + */ + float GetHeightForWidthBase( float width ); + + /** + * @brief provides the Actor implementation of GetWidthForHeight + * @param height to use. + * @return the width based on the height. + */ + float GetWidthForHeightBase( float height ); /** * @brief Calculate the size for a child @@ -1163,37 +1186,42 @@ public: * @param[in] dimension The dimension to calculate the size for. E.g. width or height. * @return Return the calculated size for the given dimension */ - float CalculateChildSizeBase( const Dali::Actor& child, Dimension dimension ); + float CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension ); /** - * @copydoc Dali::Actor::SetPreferredSize + * @brief Set the preferred size for size negotiation + * + * @param[in] size The preferred size to set */ void SetPreferredSize( const Vector2& size ); /** - * @copydoc Dali::Actor::GetPreferredSize + * @brief Return the preferred size used for size negotiation + * + * @return Return the preferred size */ Vector2 GetPreferredSize() const; /** * @copydoc Dali::Actor::SetMinimumSize */ - void SetMinimumSize( float size, Dimension dimension = ALL_DIMENSIONS ); + void SetMinimumSize( float size, Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** * @copydoc Dali::Actor::GetMinimumSize */ - float GetMinimumSize( Dimension dimension ) const; + float GetMinimumSize( Dimension::Type dimension ) const; /** * @copydoc Dali::Actor::SetMaximumSize */ - void SetMaximumSize( float size, Dimension dimension = ALL_DIMENSIONS ); + void SetMaximumSize( float size, Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** * @copydoc Dali::Actor::GetMaximumSize */ - float GetMaximumSize( Dimension dimension ) const; + float GetMaximumSize( Dimension::Type dimension ) const; + /** * @copydoc Dali::Actor::AddRenderer() */ @@ -1207,7 +1235,7 @@ public: /** * @copydoc Dali::Actor::GetRendererAt() */ - Renderer& GetRendererAt( unsigned int index ); + RendererPtr GetRendererAt( unsigned int index ); /** * @copydoc Dali::Actor::RemoveRenderer() @@ -1219,93 +1247,8 @@ public: */ void RemoveRenderer( unsigned int index ); -#ifdef DYNAMICS_SUPPORT - - // Dynamics - - /// @copydoc Dali::Actor::DisableDynamics - void DisableDynamics(); - - /// @copydoc Dali::Actor::EnableDynamics(Dali::DynamicsBodyConfig) - DynamicsBodyPtr EnableDynamics(DynamicsBodyConfigPtr bodyConfig); - - /// @copydoc Dali::Actor::GetDynamicsBody - DynamicsBodyPtr GetDynamicsBody() const; - - /// @copydoc Dali::Actor::AddDynamicsJoint(Dali::Actor,const Vector3&) - DynamicsJointPtr AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offset ); - - /// @copydoc Dali::Actor::AddDynamicsJoint(Dali::Actor,const Vector3&,const Vector3&) - DynamicsJointPtr AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offsetA, const Vector3& offsetB ); - - /// @copydoc Dali::Actor::GetNumberOfJoints - const int GetNumberOfJoints() const; - - /// @copydoc Dali::Actor::GetDynamicsJointByIndex - DynamicsJointPtr GetDynamicsJointByIndex( const int index ) const; - - /// @copydoc Dali::Actor::GetDynamicsJoint - DynamicsJointPtr GetDynamicsJoint( ActorPtr attachedActor ) const; - - /// @copydoc Dali::Actor::RemoveDynamicsJoint - void RemoveDynamicsJoint( DynamicsJointPtr joint ); - - /** - * Hold a reference to a DynamicsJoint - * @param[in] joint The joint - */ - void ReferenceJoint( DynamicsJointPtr joint ); - - /** - * Release a reference to a DynamicsJoint - * @param[in] joint The joint - */ - void ReleaseJoint( DynamicsJointPtr joint ); - - /** - * Set this actor to be the root actor in the dynamics simulation - * All children of the actor are added/removed from the simulation. - * @param[in] flag When true sets this actor to be the simulation world root actor and - * if OnStage() all dynamics enabled child actors are added to the simulation, - * when false stops this actor being the simulation root and if OnStage() all - * dynamics enabled child actors are removed from the simulation. - */ - void SetDynamicsRoot(bool flag); - -private: - /** - * Check if this actor is the root actor in the dynamics simulation - * @return true if this is the dynamics root actor. - */ - bool IsDynamicsRoot() const; - - /** - * Add actor to the dynamics simulation - * Invoked when the actor is staged, or it's parent becomes the simulation root - */ - void ConnectDynamics(); - - /** - * Remove actor from the dynamics simulation - * Invoked when the actor is unstaged, or it's parent stops being the the simulation root - */ - void DisconnectDynamics(); - - /** - * An actor in a DynamicsJoint relationship has been staged - * @param[in] actor The actor passed into AddDynamicsJoint() - */ - void AttachedActorOnStage( Dali::Actor actor ); - - /** - * An actor in a DynamicsJoint relationship has been unstaged - * @param[in] actor The actor passed into AddDynamicsJoint() - */ - void AttachedActorOffStage( Dali::Actor actor ); - -#endif // DYNAMICS_SUPPORT - public: + /** * Converts screen coordinates into the actor's coordinate system. * @note The actor coordinates are relative to the top-left (0.0, 0.0, 0.5) @@ -1327,7 +1270,7 @@ public: * @param[in] screenY The screen Y-coordinate. * @return True if the conversion succeeded. */ - bool ScreenToLocal( RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const; + bool ScreenToLocal( const RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const; /** * Converts from the actor's coordinate system to screen coordinates. @@ -1369,7 +1312,7 @@ public: */ bool RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, - Vector4& hitPointLocal, + Vector2& hitPointLocal, float& distance ) const; /** @@ -1413,10 +1356,10 @@ public: bool GetHoverRequired() const; /** - * Query whether the application or derived actor type requires mouse wheel events. - * @return True if mouse wheel events are required. + * Query whether the application or derived actor type requires wheel events. + * @return True if wheel events are required. */ - bool GetMouseWheelEventRequired() const; + bool GetWheelEventRequired() const; /** * Query whether the actor is actually hittable. This method checks whether the actor is @@ -1447,10 +1390,11 @@ public: /** * Used by the EventProcessor to emit touch event signals. - * @param[in] event The touch event. + * @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 ); + bool EmitTouchEventSignal( const TouchEvent& event, const Dali::TouchData& touch ); /** * Used by the EventProcessor to emit hover event signals. @@ -1460,11 +1404,18 @@ public: bool EmitHoverEventSignal( const HoverEvent& event ); /** - * Used by the EventProcessor to emit mouse wheel event signals. - * @param[in] event The mouse wheel event. + * Used by the EventProcessor to emit wheel event signals. + * @param[in] event The wheel event. * @return True if the event was consumed. */ - bool EmitMouseWheelEventSignal( const MouseWheelEvent& event ); + bool EmitWheelEventSignal( const WheelEvent& event ); + + /** + * @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. + */ + void EmitVisibilityChangedSignal( bool visible, DevelActor::VisibilityChange::Type type ); /** * @copydoc Dali::Actor::TouchedSignal() @@ -1472,14 +1423,19 @@ public: Dali::Actor::TouchSignalType& TouchedSignal(); /** + * @copydoc Dali::Actor::TouchEventSignal() + */ + Dali::Actor::TouchDataSignalType& TouchSignal(); + + /** * @copydoc Dali::Actor::HoveredSignal() */ Dali::Actor::HoverSignalType& HoveredSignal(); /** - * @copydoc Dali::Actor::MouseWheelEventSignal() + * @copydoc Dali::Actor::WheelEventSignal() */ - Dali::Actor::MouseWheelEventSignalType& MouseWheelEventSignal(); + Dali::Actor::WheelEventSignalType& WheelEventSignal(); /** * @copydoc Dali::Actor::OnStageSignal() @@ -1497,6 +1453,11 @@ public: Dali::Actor::OnRelayoutSignalType& OnRelayoutSignal(); /** + * @copydoc DevelActor::VisibilityChangedSignal + */ + DevelActor::VisibilityChangedSignalType& VisibilityChangedSignal(); + + /** * 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. @@ -1519,20 +1480,12 @@ public: */ static bool DoAction( BaseObject* object, const std::string& actionName, - const std::vector< Property::Value >& attributes ); + const Property::Map& attributes ); public: // For Animation /** - * This should only be called by Animation, when the actor is resized using Animation::Resize(). - * - * @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 ); - - /** * For use in derived classes. * This should only be called by Animation, when the actor is resized using Animation::Resize(). */ @@ -1544,7 +1497,7 @@ protected: enum DerivedType { - BASIC, RENDERABLE, LAYER, ROOT_LAYER + BASIC, LAYER, ROOT_LAYER }; /** @@ -1566,24 +1519,22 @@ protected: /** * Called on a child during Add() when the parent actor is connected to the Stage. - * @param[in] stage The stage. - * @param[in] index If set, it is only used for positioning the actor within the parent's child list. + * @param[in] parentDepth The depth of the parent in the hierarchy. */ - void ConnectToStage( int index = -1 ); + void ConnectToStage( unsigned int parentDepth ); /** * Helper for ConnectToStage, to recursively connect a tree of actors. * This is atomic i.e. not interrupted by user callbacks. - * @param[in] index If set, it is only used for positioning the actor within the parent's child list. + * @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, int index = -1 ); + void RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth ); /** * Connect the Node associated with this Actor to the scene-graph. - * @param[in] index If set, it is only used for positioning the actor within the parent's child list. */ - void ConnectToSceneGraph( int index = -1 ); + void ConnectToSceneGraph(); /** * Helper for ConnectToStage, to notify a connected actor through the public API. @@ -1618,16 +1569,28 @@ protected: */ bool IsNodeConnected() const; +public: /** - * Calculate the size of the z dimension for a 2D size - * - * @param[in] size The 2D size (X, Y) to calculate Z from - * - * @return Return the Z dimension for this size + * 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. */ - float CalculateSizeZ( const Vector2& size ) const; + 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 + */ + int BuildDepthTree( DepthNodeMemoryPool& nodeMemoryPool, ActorDepthTreeNode* depthTreeNode ); public: + // Default property extensions from Object /** @@ -1686,6 +1649,16 @@ public: virtual Property::Value GetDefaultProperty( Property::Index index ) const; /** + * @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue() + */ + 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 ); + + /** * @copydoc Dali::Internal::Object::GetPropertyOwner() */ virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const; @@ -1710,8 +1683,47 @@ public: */ virtual int GetPropertyComponentIndex( Property::Index index ) const; + /** + * @copydoc Dali::DevelActor::Raise() + */ + void Raise(); + + /** + * @copydoc Dali::DevelActor::Lower() + */ + void Lower(); + + /** + * @copydoc Dali::DevelActor::RaiseToTop() + */ + void RaiseToTop(); + + /** + * @copydoc Dali::DevelActor::LowerToBottom() + */ + void LowerToBottom(); + + /** + * @copydoc Dali::DevelActor::RaiseAbove() + */ + void RaiseAbove( Internal::Actor& target ); + + /** + * @copydoc Dali::DevelActor::LowerBelow() + */ + void LowerBelow( Internal::Actor& target ); + private: + struct SendMessage + { + enum Type + { + FALSE = 0, + TRUE = 1, + }; + }; + // Undefined Actor(); @@ -1724,9 +1736,8 @@ private: /** * Set the actors parent. * @param[in] parent The new parent. - * @param[in] index If set, it is only used for positioning the actor within the parent's child list. */ - void SetParent( Actor* parent, int index = -1 ); + void SetParent( Actor* parent ); /** * Helper to create a Node for this Actor. @@ -1764,7 +1775,7 @@ private: * For use in external (CustomActor) derived classes. * This is called after the atomic ConnectToStage() traversal has been completed. */ - virtual void OnStageConnectionExternal() + virtual void OnStageConnectionExternal( int depth ) { } @@ -1785,7 +1796,7 @@ private: } /** - * For use in derived classes; this is called after Remove() has removed a child. + * For use in derived classes; this is called after Remove() has attempted to remove a child( regardless of whether it succeeded or not ). * @param[in] child The child that was removed. */ virtual void OnChildRemove( Actor& child ) @@ -1824,19 +1835,35 @@ private: /** * For use in derived classes. - * This is only called if the mouse wheel signal was not consumed. - * @param[in] event The mouse event. + * This is only called if the wheel signal was not consumed. + * @param[in] event The wheel event. * @return True if the event should be consumed. */ - virtual bool OnMouseWheelEvent( const MouseWheelEvent& event ) + virtual bool OnWheelEvent( const WheelEvent& event ) { return false; } /** + * @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() const; + void EnsureRelayoutData(); /** * @brief Apply the size set policy to the input size @@ -1846,64 +1873,175 @@ private: */ Vector2 ApplySizeSetPolicy( const Vector2 size ); + /** + * Retrieve the parent object of an Actor. + * @return The parent object, or NULL if the Actor does not have a parent. + */ + virtual Object* GetParentObject() const; + + /** + * Set Sibling order + * @param[in] order The sibling order this Actor should be + */ + 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 + */ + void DefragmentSiblingIndexes( ActorContainer& siblings ); + + /** + * @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 + */ + bool ShiftSiblingsLevels( ActorContainer& siblings, int targetLevelToShiftFrom ); + + /** + * @brief Get the current position of the actor in screen coordinates. + * + * @return Returns the screen position of actor + */ + 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 ); + protected: - StagePtr mStage; ///< Used to send messages to Node; valid until Core destruction 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 struct RelayoutData; - mutable RelayoutData* mRelayoutData; ///< Struct to hold optional collection of relayout variables - -#ifdef DYNAMICS_SUPPORT - DynamicsData* mDynamicsData; ///< optional physics data -#endif + RelayoutData* mRelayoutData; ///< Struct to hold optional collection of relayout variables ActorGestureData* mGestureData; ///< Optional Gesture data. Only created when actor requires gestures - ActorAttachmentPtr mAttachment; ///< Optional referenced attachment - // Signals Dali::Actor::TouchSignalType mTouchedSignal; + Dali::Actor::TouchDataSignalType mTouchSignal; Dali::Actor::HoverSignalType mHoveredSignal; - Dali::Actor::MouseWheelEventSignalType mMouseWheelEventSignal; + Dali::Actor::WheelEventSignalType mWheelEventSignal; Dali::Actor::OnStageSignalType mOnStageSignal; Dali::Actor::OffStageSignalType mOffStageSignal; Dali::Actor::OnRelayoutSignalType mOnRelayoutSignal; + DevelActor::VisibilityChangedSignalType mVisibilityChangedSignal; - Vector3 mTargetSize; ///< Event-side storage for size (not a pointer as most actors will have a size) + 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 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 mIsRenderable : 1; ///< Flag to identify that this is a renderable 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 mIsDynamicsRoot : 1; ///< Flag to identify if this is the dynamics world root 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 mDerivedRequiresMouseWheelEvent : 1; ///< Whether the derived actor type requires mouse wheel 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 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. + 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. 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 +}; + +/** + * 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 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 @@ -1928,4 +2066,4 @@ inline const Internal::Actor& GetImplementation( const Dali::Actor& actor ) } // namespace Dali -#endif // __DALI_INTERNAL_ACTOR_H__ +#endif // DALI_INTERNAL_ACTOR_H