X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Factors%2Factor-impl.h;h=9ca88450b71a24022cec87e1e8123fdfdb244eb3;hb=462cbee2270984cdca45488f3733d664dcf49187;hp=bb92041257e9dc00a1820bedf55a2e044670fe59;hpb=2ac8028e3ed170002c2f5ee84d2809cf4224c036;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 bb92041..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,29 +22,28 @@ #include // INTERNAL INCLUDES -#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 { @@ -53,12 +52,17 @@ class Actor; class ActorGestureData; class Animation; class RenderTask; -struct DynamicsData; +class Renderer; -typedef IntrusivePtr ActorPtr; -typedef Dali::ActorContainer ActorContainer; // Store handles to return via public-api -typedef ActorContainer::iterator ActorIter; -typedef ActorContainer::const_iterator ActorConstIter; +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. @@ -66,15 +70,51 @@ typedef ActorContainer::const_iterator ActorConstIter; * 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 ProxyObject +class Actor : public Object { public: /** + * @brief Struct to hold an actor and a dimension + */ + struct ActorDimensionPair + { + /** + * @brief Constructor + * + * @param[in] newActor The actor to assign + * @param[in] newDimension The dimension to assign + */ + ActorDimensionPair( Actor* newActor, Dimension::Type newDimension ) + : actor( newActor ), + dimension( newDimension ) + { + } + + /** + * @brief Equality operator + * + * @param[in] lhs The left hand side argument + * @param[in] rhs The right hand side argument + */ + bool operator== ( const ActorDimensionPair& rhs ) + { + return ( actor == rhs.actor ) && ( dimension == rhs.dimension ); + } + + Actor* actor; ///< The actor to hold + Dimension::Type dimension; ///< The dimension to hold + }; + + typedef std::vector< ActorDimensionPair > ActorDimensionStack; + +public: + + /** * Create a new actor. * @return A smart-pointer to the newly allocated Actor. */ @@ -90,28 +130,13 @@ public: * Set the name of the actor. * @param[in] name The new name. */ - void SetName(const std::string& name); + void SetName( const std::string& name ); /** * @copydoc Dali::Actor::GetId */ 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 /** @@ -129,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(); } /** @@ -161,24 +186,14 @@ public: * @param [in] child The child. * @post The child will be referenced by its parent. */ - 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); + void Add( Actor& child ); /** * Removes a child Actor from this Actor. * @param [in] child The child. * @post The child will be unreferenced. */ - void Remove(Actor& child); + void Remove( Actor& child ); /** * @copydoc Dali::Actor::Unparent @@ -194,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() { @@ -221,17 +225,12 @@ public: /** * @copydoc Dali::Actor::FindChildByName */ - ActorPtr FindChildByName(const std::string& actorName); - - /** - * @copydoc Dali::Actor::FindChildByAlias - */ - Dali::Actor FindChildByAlias(const std::string& actorAlias); + ActorPtr FindChildByName( const std::string& actorName ); /** * @copydoc Dali::Actor::FindChildById */ - ActorPtr FindChildById(const unsigned int id); + ActorPtr FindChildById( const unsigned int id ); /** * Retrieve the parent of an Actor. @@ -244,38 +243,48 @@ 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. */ - void SetSize(float width, float height); + void SetSize( float width, float height ); /** * 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. * @param [in] depth The size of the actor along the z-axis. */ - void SetSize(float width, float height, float depth); + void SetSize( float width, float height, float depth ); /** * 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); + 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); + 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. @@ -300,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& GetSize() const; + Vector3 GetTargetSize() const; /** * Retrieve the Actor's size from update side. @@ -324,7 +333,7 @@ public: * An actor position is the distance between this origin, and the actors anchor-point. * @param [in] origin The new parent-origin. */ - void SetParentOrigin(const Vector3& origin); + void SetParentOrigin( const Vector3& origin ); /** * Set the x component of the parent-origin @@ -358,7 +367,7 @@ public: * An actor's rotation is centered around its anchor-point. * @param [in] anchorPoint The new anchor-point. */ - void SetAnchorPoint(const Vector3& anchorPoint); + void SetAnchorPoint( const Vector3& anchorPoint ); /** * Set the x component of the anchor-point. @@ -391,7 +400,7 @@ public: * @param [in] x The new x position * @param [in] y The new y position */ - void SetPosition(float x, float y); + void SetPosition( float x, float y ); /** * Sets the position of the Actor. @@ -400,38 +409,38 @@ public: * @param [in] y The new y position * @param [in] z The new z position */ - void SetPosition(float x, float y, float z); + void SetPosition( float x, float y, float z ); /** * Sets the position of the Actor. * The coordinates are relative to the Actor's parent. * @param [in] position The new position. */ - void SetPosition(const Vector3& position); + void SetPosition( const Vector3& position ); /** * Set the position of an actor along the X-axis. * @param [in] x The new x position */ - void SetX(float x); + void SetX( float x ); /** * Set the position of an actor along the Y-axis. * @param [in] y The new y position. */ - void SetY(float y); + void SetY( float y ); /** * Set the position of an actor along the Z-axis. * @param [in] z The new z position */ - void SetZ(float z); + void SetZ( float z ); /** - * Move an actor relative to its existing position. + * Translate an actor relative to its existing position. * @param[in] distance The actor will move by this distance. */ - void MoveBy(const Vector3& distance); + void TranslateBy( const Vector3& distance ); /** * Retrieve the position of the Actor. @@ -441,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; @@ -456,60 +472,84 @@ public: PositionInheritanceMode GetPositionInheritanceMode() const; /** - * Sets the rotation of the Actor. - * @param [in] angleRadians The new rotation angle in radians. - * @param [in] axis The new axis of rotation. + * @copydoc Dali::Actor::SetInheritPosition() + */ + void SetInheritPosition( bool inherit ); + + /** + * @copydoc Dali::Actor::IsPositionInherited() */ - void SetRotation(const Radian& angleRadians, const Vector3& axis); + bool IsPositionInherited() const; /** - * Sets the rotation of the Actor. - * @param [in] rotation The new rotation. + * Sets the orientation of the Actor. + * @param [in] angleRadians The new orientation angle in radians. + * @param [in] axis The new axis of orientation. */ - void SetRotation(const Quaternion& rotation); + void SetOrientation( const Radian& angleRadians, const Vector3& axis ); + + /** + * Sets the orientation of the Actor. + * @param [in] orientation The new orientation. + */ + void SetOrientation( const Quaternion& orientation ); /** * Rotate an actor around its existing rotation axis. * @param[in] angleRadians The angle to the rotation to combine with the existing rotation. * @param[in] axis The axis of the rotation to combine with the existing rotation. */ - void RotateBy(const Radian& angleRadians, const Vector3& axis); + void RotateBy( const Radian& angleRadians, const Vector3& axis ); /** * Apply a relative rotation to an actor. * @param[in] relativeRotation The rotation to combine with the actors existing rotation. */ - void RotateBy(const Quaternion& relativeRotation); + void RotateBy( const Quaternion& relativeRotation ); /** - * Retreive the Actor's rotation. - * @return the rotation. + * Retreive the Actor's orientation. + * @return the orientation. */ - const Quaternion& GetCurrentRotation() const; + const Quaternion& GetCurrentOrientation() const; /** * Set whether a child actor inherits it's parent's orientation. Default is to inherit. - * Switching this off means that using SetRotation() sets the actor's world orientation. + * Switching this off means that using SetOrientation() sets the actor's world orientation. * @param[in] inherit - true if the actor should inherit orientation, false otherwise. */ - void SetInheritRotation(bool inherit); + void SetInheritOrientation( bool inherit ); /** * Returns whether the actor inherit's it's parent's orientation. * @return true if the actor inherit's it's parent orientation, false if it uses world orientation. */ - bool IsRotationInherited() const; + bool IsOrientationInherited() const; + + /** + * Sets the factor of the parents size used for the child actor. + * 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 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; /** - * @copydoc Dali::Actor::GetCurrentWorldRotation() + * @copydoc Dali::Actor::GetCurrentWorldOrientation() */ - const Quaternion& GetCurrentWorldRotation() const; + const Quaternion& GetCurrentWorldOrientation() const; /** * Sets a scale factor applied to an actor. * @param [in] scale The scale factor applied on all axes. */ - void SetScale(float scale); + void SetScale( float scale ); /** * Sets a scale factor applied to an actor. @@ -517,13 +557,13 @@ public: * @param [in] scaleY The scale factor applied along the y-axis. * @param [in] scaleZ The scale factor applied along the z-axis. */ - void SetScale(float scaleX, float scaleY, float scaleZ); + void SetScale( float scaleX, float scaleY, float scaleZ ); /** * Sets a scale factor applied to an actor. * @param [in] scale A vector representing the scale factor for each axis. */ - void SetScale(const Vector3& scale); + void SetScale( const Vector3& scale ); /** * Set the x component of the scale factor. @@ -547,7 +587,7 @@ public: * Apply a relative scale to an actor. * @param[in] relativeScale The scale to combine with the actors existing scale. */ - void ScaleBy(const Vector3& relativeScale); + void ScaleBy( const Vector3& relativeScale ); /** * Retrieve the scale factor applied to an actor. @@ -579,9 +619,9 @@ 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); + void SetVisible( bool visible ); /** * Retrieve the visibility flag of an actor. @@ -593,13 +633,7 @@ public: * Sets the opacity of an actor. * @param [in] opacity The new opacity. */ - void SetOpacity(float opacity); - - /** - * Apply a relative opacity change to an actor. - * @param[in] relativeOpacity The opacity to combine with the actors existing opacity. - */ - void OpacityBy(float relativeOpacity); + void SetOpacity( float opacity ); /** * Retrieve the actor's opacity. @@ -608,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 @@ -627,7 +667,7 @@ public: * @note If an actor's sensitivity is set to false, then it's children will not emit a touch or hover event signal either. * @param[in] sensitive true to enable emission of the touch or hover event signals, false otherwise. */ - void SetSensitive(bool sensitive) + void SetSensitive( bool sensitive ) { mSensitive = sensitive; } @@ -653,43 +693,16 @@ public: DrawMode::Type GetDrawMode() const; /** - * @copydoc Dali::Actor::SetOverlay - */ - void SetOverlay(bool enable); - - /** * @copydoc Dali::Actor::IsOverlay */ bool IsOverlay() const; /** - * Sets whether an actor transmits geometry scaling to it's children. - * The default value is for it not to transmit scaling. - * @param[in] transmitGeometryScaling True to transmit scaling. - */ - void SetTransmitGeometryScaling(bool transmitGeometryScaling); - - /** - * Get the TransmitGeometryScaling property for this actor. - * @return True if geometry scaling is applied to the inherited scale. - */ - bool GetTransmitGeometryScaling() const; - - /** - * Sets the initial volume of the actor. Used for scaling the - * actor appropriately as the actor is sized when transmitGeometryScaling - * is set to true. - * - * @param[in] volume the volume of the model and it's children - */ - void SetInitialVolume(const Vector3& volume); - - /** * Sets the actor's color. The final color of actor depends on its color mode. * This final color is applied to the drawable elements of an actor. * @param [in] color The new color. */ - void SetColor(const Vector4& color); + void SetColor( const Vector4& color ); /** * Set the red component of the color. @@ -710,12 +723,6 @@ public: void SetColorBlue( float blue ); /** - * Apply a relative color change to an actor. - * @param[in] relativeColor The color to combine with the actors existing color. - */ - void ColorBy(const Vector4& relativeColor); - - /** * Retrieve the actor's color. * @return The color. */ @@ -726,7 +733,7 @@ public: * Color mode specifies whether Actor uses its own color or inherits its parent color * @param [in] colorMode to use. */ - void SetColorMode(ColorMode colorMode); + void SetColorMode( ColorMode colorMode ); /** * Returns the actor's color mode. @@ -739,93 +746,509 @@ public: */ const Vector4& GetCurrentWorldColor() const; -#ifdef DYNAMICS_SUPPORT + /** + * @copydoc Dali::Actor::GetHierarchyDepth() + */ + inline int GetHierarchyDepth() const + { + if( mIsOnStage ) + { + return static_cast(mDepth); + } - // Dynamics + return -1; + } - /// @copydoc Dali::Actor::DisableDynamics - void DisableDynamics(); + /** + * Get the actor's sorting depth + * + * @return The depth used for hit-testing and renderer sorting + */ + unsigned int GetSortingDepth(); - /// @copydoc Dali::Actor::EnableDynamics(Dali::DynamicsBodyConfig) - DynamicsBodyPtr EnableDynamics(DynamicsBodyConfigPtr bodyConfig); +public: - /// @copydoc Dali::Actor::GetDynamicsBody - DynamicsBodyPtr GetDynamicsBody() const; + // Size negotiation virtual functions - /// @copydoc Dali::Actor::AddDynamicsJoint(Dali::Actor,const Vector3&) - DynamicsJointPtr AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offset ); + /** + * @brief Called after the size negotiation has been finished for this control. + * + * The control is expected to assign this given size to itself/its children. + * + * Should be overridden by derived classes if they need to layout + * actors differently after certain operations like add or remove + * actors, resize or after changing specific properties. + * + * Note! As this function is called from inside the size negotiation algorithm, you cannot + * call RequestRelayout (the call would just be ignored) + * + * @param[in] size The allocated size. + * @param[in,out] container The control should add actors to this container that it is not able + * to allocate a size for. + */ + virtual void OnRelayout( const Vector2& size, RelayoutContainer& container ) + { + } - /// @copydoc Dali::Actor::AddDynamicsJoint(Dali::Actor,const Vector3&,const Vector3&) - DynamicsJointPtr AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offsetA, const Vector3& offsetB ); + /** + * @brief Notification for deriving classes when the resize policy is set + * + * @param[in] policy The policy being set + * @param[in] dimension The dimension the policy is being set for + */ + virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension ) {} - /// @copydoc Dali::Actor::GetNumberOfJoints - const int GetNumberOfJoints() const; + /** + * @brief Virtual method to notify deriving classes that relayout dependencies have been + * met and the size for this object is about to be calculated for the given dimension + * + * @param dimension The dimension that is about to be calculated + */ + virtual void OnCalculateRelayoutSize( Dimension::Type dimension ); - /// @copydoc Dali::Actor::GetDynamicsJointByIndex - DynamicsJointPtr GetDynamicsJointByIndex( const int index ) const; + /** + * @brief Virtual method to notify deriving classes that the size for a dimension + * has just been negotiated + * + * @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::Type dimension ); - /// @copydoc Dali::Actor::GetDynamicsJoint - DynamicsJointPtr GetDynamicsJoint( ActorPtr attachedActor ) const; + /** + * @brief Determine if this actor is dependent on it's children for relayout + * + * @param dimension The dimension(s) to check for + * @return Return if the actor is dependent on it's children + */ + virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); - /// @copydoc Dali::Actor::RemoveDynamicsJoint - void RemoveDynamicsJoint( DynamicsJointPtr joint ); + /** + * @brief Determine if this actor is dependent on it's children for relayout. + * + * Called from deriving classes + * + * @param dimension The dimension(s) to check for + * @return Return if the actor is dependent on it's children + */ + virtual bool RelayoutDependentOnChildrenBase( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** - * Hold a reference to a DynamicsJoint - * @param[in] joint The joint + * @brief Calculate the size for a child + * + * @param[in] child The child actor to calculate the size for + * @param[in] dimension The dimension to calculate the size for. E.g. width or height. + * @return Return the calculated size for the given dimension */ - void ReferenceJoint( DynamicsJointPtr joint ); + virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension ); /** - * Release a reference to a DynamicsJoint - * @param[in] joint The joint + * @brief This method is called during size negotiation when a height is required for a given width. + * + * Derived classes should override this if they wish to customize the height returned. + * + * @param width to use. + * @return the height based on the width. */ - void ReleaseJoint( DynamicsJointPtr joint ); + virtual float GetHeightForWidth( float width ); /** - * 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. + * @brief This method is called during size negotiation when a width is required for a given height. + * + * Derived classes should override this if they wish to customize the width returned. + * + * @param height to use. + * @return the width based on the width. */ - void SetDynamicsRoot(bool flag); + virtual float GetWidthForHeight( float height ); + +public: + + // Size negotiation + + /** + * @brief Called by the RelayoutController to negotiate the size of an actor. + * + * The size allocated by the the algorithm is passed in which the + * actor must adhere to. A container is passed in as well which + * the actor should populate with actors it has not / or does not + * need to handle in its size negotiation. + * + * @param[in] size The allocated size. + * @param[in,out] container The container that holds actors that are fed back into the + * RelayoutController algorithm. + */ + 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 ); + + /** + * @copydoc Dali::Actor::GetResizePolicy() + */ + ResizePolicy::Type GetResizePolicy( Dimension::Type dimension ) const; + + /** + * @copydoc Dali::Actor::SetSizeScalePolicy() + */ + void SetSizeScalePolicy( SizeScalePolicy::Type policy ); + + /** + * @copydoc Dali::Actor::GetSizeScalePolicy() + */ + SizeScalePolicy::Type GetSizeScalePolicy() const; + + /** + * @copydoc Dali::Actor::SetDimensionDependency() + */ + void SetDimensionDependency( Dimension::Type dimension, Dimension::Type dependency ); + + /** + * @copydoc Dali::Actor::GetDimensionDependency() + */ + Dimension::Type GetDimensionDependency( Dimension::Type dimension ) const; + + /** + * @brief Set the size negotiation relayout enabled on this actor + * + * @param[in] relayoutEnabled Boolean to enable or disable relayout + */ + void SetRelayoutEnabled( bool relayoutEnabled ); + + /** + * @brief Return if relayout is enabled + * + * @return Return if relayout is enabled or not for this actor + */ + bool IsRelayoutEnabled() const; + + /** + * @brief Mark an actor as having it's layout dirty + * + * @param dirty Whether to mark actor as dirty or not + * @param dimension The dimension(s) to mark as dirty + */ + void SetLayoutDirty( bool dirty, Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); + + /** + * @brief Return if any of an actor's dimensions are marked as dirty + * + * @param dimension The dimension(s) to check + * @return Return if any of the requested dimensions are dirty + */ + bool IsLayoutDirty( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) const; -private: /** - * Check if this actor is the root actor in the dynamics simulation - * @return true if this is the dynamics root actor. + * @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::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 IsDynamicsRoot() const; + bool RelayoutRequired( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) const; /** - * Add actor to the dynamics simulation - * Invoked when the actor is staged, or it's parent becomes the simulation root + * @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(), + * OnChildRemove(), SetSizePolicy(), SetMinimumSize() and SetMaximumSize(). + * + * This method can also be called from a derived class every time it needs a different size. + * At the end of event processing, the relayout process starts and + * all controls which requested Relayout will have their sizes (re)negotiated. + * + * @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 ConnectDynamics(); + void RelayoutRequest( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** - * Remove actor from the dynamics simulation - * Invoked when the actor is unstaged, or it's parent stops being the the simulation root + * @brief Determine if this actor is dependent on it's parent for relayout + * + * @param dimension The dimension(s) to check for + * @return Return if the actor is dependent on it's parent */ - void DisconnectDynamics(); + bool RelayoutDependentOnParent( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** - * An actor in a DynamicsJoint relationship has been staged - * @param[in] actor The actor passed into AddDynamicsJoint() + * @brief Determine if this actor has another dimension depedent on the specified one + * + * @param dimension The dimension to check for + * @param dependentDimension The dimension to check for dependency with + * @return Return if the actor is dependent on this dimension */ - void AttachedActorOnStage( Dali::Actor actor ); + bool RelayoutDependentOnDimension( Dimension::Type dimension, Dimension::Type dependentDimension ); /** - * An actor in a DynamicsJoint relationship has been unstaged - * @param[in] actor The actor passed into AddDynamicsJoint() + * Negotiate sizes for a control in all dimensions + * + * @param[in] allocatedSize The size constraint that the control must respect */ - void AttachedActorOffStage( Dali::Actor actor ); + void NegotiateDimensions( const Vector2& allocatedSize ); -#endif // DYNAMICS_SUPPORT + /** + * Negotiate size for a specific dimension + * + * The algorithm adopts a recursive dependency checking approach. Meaning, that wherever dependencies + * are found, e.g. an actor dependent on its parent, the dependency will be calculated first with NegotiatedDimension and + * LayoutDimensionNegotiated flags being filled in on the actor. + * + * @post All actors that exist in the dependency chain connected to the given actor will have had their NegotiatedDimensions + * calculated and set as well as the LayoutDimensionNegotiated flags. + * + * @param[in] dimension The dimension to negotiate on + * @param[in] allocatedSize The size constraint that the actor must respect + */ + void NegotiateDimension( Dimension::Type dimension, const Vector2& allocatedSize, ActorDimensionStack& recursionStack ); + + /** + * @brief Calculate the size of a dimension + * + * @param[in] dimension The dimension to calculate the size for + * @param[in] maximumSize The upper bounds on the size + * @return Return the calculated size for the dimension + */ + float CalculateSize( Dimension::Type dimension, const Vector2& maximumSize ); + + /** + * @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 clamped size + */ + float ClampDimension( float size, Dimension::Type dimension ); + + /** + * Negotiate a dimension based on the size of the parent + * + * @param[in] dimension The dimension to negotiate on + * @return Return the negotiated size + */ + float NegotiateFromParent( Dimension::Type dimension ); + + /** + * Negotiate a dimension based on the size of the parent. Fitting inside. + * + * @param[in] dimension The dimension to negotiate on + * @return Return the negotiated size + */ + float NegotiateFromParentFit( Dimension::Type dimension ); + + /** + * Negotiate a dimension based on the size of the parent. Flooding the whole space. + * + * @param[in] dimension The dimension to negotiate on + * @return Return the negotiated size + */ + float NegotiateFromParentFlood( Dimension::Type dimension ); + + /** + * @brief Negotiate a dimension based on the size of the children + * + * @param[in] dimension The dimension to negotiate on + * @return Return the negotiated size + */ + float NegotiateFromChildren( Dimension::Type dimension ); + + /** + * Set the negotiated dimension value for the given dimension(s) + * + * @param negotiatedDimension The value to set + * @param dimension The dimension(s) to set the value for + */ + void SetNegotiatedDimension( float negotiatedDimension, Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); + + /** + * Return the value of negotiated dimension for the given dimension + * + * @param dimension The dimension to retrieve + * @return Return the value of the negotiated dimension + */ + float GetNegotiatedDimension( Dimension::Type dimension ) const; + + /** + * @brief Set the padding for a dimension + * + * @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::Type dimension ); + + /** + * Return the value of padding for the given dimension + * + * @param dimension The dimension to retrieve + * @return Return the value of padding for the dimension + */ + Vector2 GetPadding( Dimension::Type dimension ) const; + + /** + * Return the actor size for a given dimension + * + * @param[in] dimension The dimension to retrieve the size for + * @return Return the size for the given dimension + */ + float GetSize( Dimension::Type dimension ) const; + + /** + * Return the natural size of the actor for a given dimension + * + * @param[in] dimension The dimension to retrieve the size for + * @return Return the natural size for the given dimension + */ + float GetNaturalSize( Dimension::Type dimension ) const; + + /** + * @brief Return the amount of size allocated for relayout + * + * May include padding + * + * @param[in] dimension The dimension to retrieve + * @return Return the size + */ + float GetRelayoutSize( Dimension::Type dimension ) const; + + /** + * @brief If the size has been negotiated return that else return normal size + * + * @param[in] dimension The dimension to retrieve + * @return Return the size + */ + float GetLatestSize( Dimension::Type dimension ) const; + + /** + * Apply the negotiated size to the actor + * + * @param[in] container The container to fill with actors that require further relayout + */ + void SetNegotiatedSize( RelayoutContainer& container ); + + /** + * @brief Flag the actor as having it's layout dimension negotiated. + * + * @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::Type dimension = Dimension::ALL_DIMENSIONS ); + + /** + * @brief Test whether the layout dimension for this actor has been negotiated or not. + * + * @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::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 + * + * @param[in] child The child actor to calculate the size for + * @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::Type dimension ); + + /** + * @brief Set the preferred size for size negotiation + * + * @param[in] size The preferred size to set + */ + void SetPreferredSize( const Vector2& size ); + + /** + * @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::Type dimension = Dimension::ALL_DIMENSIONS ); + + /** + * @copydoc Dali::Actor::GetMinimumSize + */ + float GetMinimumSize( Dimension::Type dimension ) const; + + /** + * @copydoc Dali::Actor::SetMaximumSize + */ + void SetMaximumSize( float size, Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); + + /** + * @copydoc Dali::Actor::GetMaximumSize + */ + float GetMaximumSize( Dimension::Type dimension ) const; + + /** + * @copydoc Dali::Actor::AddRenderer() + */ + unsigned int AddRenderer( Renderer& renderer ); + + /** + * @copydoc Dali::Actor::GetRendererCount() + */ + unsigned int GetRendererCount() const; + + /** + * @copydoc Dali::Actor::GetRendererAt() + */ + RendererPtr GetRendererAt( unsigned int index ); + + /** + * @copydoc Dali::Actor::RemoveRenderer() + */ + void RemoveRenderer( Renderer& renderer ); + + /** + * @copydoc Dali::Actor::RemoveRenderer() + */ + void RemoveRenderer( unsigned int index ); 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) @@ -835,7 +1258,7 @@ public: * @param[in] screenY The screen Y-coordinate. * @return True if the conversion succeeded. */ - bool ScreenToLocal(float& localX, float& localY, float screenX, float screenY) const; + bool ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const; /** * Converts screen coordinates into the actor's coordinate system. @@ -847,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. @@ -887,7 +1310,10 @@ public: * @param[out] distance The distance from the hit point to the camera. * @return True if the ray intersects the actor's geometry. */ - bool RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vector4& hitPointLocal, float& distance ) const; + bool RayActorTest( const Vector4& rayOrigin, + const Vector4& rayDir, + Vector2& hitPointLocal, + float& distance ) const; /** * Sets whether the actor should receive a notification when touch or hover motion events leave @@ -898,7 +1324,7 @@ public: * * @param[in] required Should be set to true if a Leave event is required */ - void SetLeaveRequired(bool required); + void SetLeaveRequired( bool required ); /** * This returns whether the actor requires touch or hover events whenever touch or hover motion events leave @@ -930,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 @@ -964,54 +1390,72 @@ 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. * @param[in] event The hover event. * @return True if the event was consumed. */ - bool EmitHoverEventSignal(const HoverEvent& event); + 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() */ - Dali::Actor::TouchSignalV2& TouchedSignal(); + Dali::Actor::TouchSignalType& TouchedSignal(); /** - * @copydoc Dali::Actor::HoveredSignal() + * @copydoc Dali::Actor::TouchEventSignal() */ - Dali::Actor::HoverSignalV2& HoveredSignal(); + Dali::Actor::TouchDataSignalType& TouchSignal(); /** - * @copydoc Dali::Actor::MouseWheelEventSignal() + * @copydoc Dali::Actor::HoveredSignal() */ - Dali::Actor::MouseWheelEventSignalV2& MouseWheelEventSignal(); + Dali::Actor::HoverSignalType& HoveredSignal(); /** - * @copydoc Dali::Actor::SetSizeSignal() + * @copydoc Dali::Actor::WheelEventSignal() */ - Dali::Actor::SetSizeSignalV2& SetSizeSignal(); + Dali::Actor::WheelEventSignalType& WheelEventSignal(); /** * @copydoc Dali::Actor::OnStageSignal() */ - Dali::Actor::OnStageSignalV2& OnStageSignal(); + Dali::Actor::OnStageSignalType& OnStageSignal(); /** * @copydoc Dali::Actor::OffStageSignal() */ - Dali::Actor::OffStageSignalV2& OffStageSignal(); + Dali::Actor::OffStageSignalType& OffStageSignal(); + + /** + * @copydoc Dali::Actor::OnRelayoutSignal() + */ + Dali::Actor::OnRelayoutSignalType& OnRelayoutSignal(); + + /** + * @copydoc DevelActor::VisibilityChangedSignal + */ + DevelActor::VisibilityChangedSignalType& VisibilityChangedSignal(); /** * Connects a callback function with the object's signals. @@ -1022,7 +1466,10 @@ public: * @return True if the signal was connected. * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor. */ - static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor ); + static bool DoConnectSignal( BaseObject* object, + ConnectionTrackerInterface* tracker, + const std::string& signalName, + FunctorDelegate* functor ); /** * Performs actions as requested using the action name. @@ -1031,32 +1478,26 @@ public: * @param[in] attributes The attributes with which to perfrom this action. * @return true if the action was done. */ - static bool DoAction(BaseObject* object, const std::string& actionName, const std::vector& attributes); + static bool DoAction( BaseObject* object, + const std::string& actionName, + 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); +public: + // For Animation /** * For use in derived classes. * This should only be called by Animation, when the actor is resized using Animation::Resize(). */ - virtual void OnSizeAnimation( Animation& animation, const Vector3& targetSize) {} + virtual void OnSizeAnimation( Animation& animation, const Vector3& targetSize ) + { + } protected: enum DerivedType { - BASIC, - RENDERABLE, - LAYER, - ROOT_LAYER + BASIC, LAYER, ROOT_LAYER }; /** @@ -1069,7 +1510,7 @@ protected: /** * Second-phase constructor. Must be called immediately after creating a new Actor; */ - void Initialize(void); + void Initialize( void ); /** * A reference counted object may only be deleted by calling Unreference() @@ -1078,25 +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(Stage& stage, 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] stage The stage. - * @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( Stage& stage, 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. @@ -1131,119 +1569,175 @@ 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(); -public: // Default property extensions from ProxyObject +protected: /** - * @copydoc Dali::Internal::ProxyObject::IsSceneObjectRemovable() + * 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 */ - virtual bool IsSceneObjectRemovable() const; + int BuildDepthTree( DepthNodeMemoryPool& nodeMemoryPool, ActorDepthTreeNode* depthTreeNode ); + +public: + + // Default property extensions from Object /** - * @copydoc Dali::Internal::ProxyObject::GetDefaultPropertyCount() + * @copydoc Dali::Internal::Object::GetDefaultPropertyCount() */ virtual unsigned int GetDefaultPropertyCount() const; /** - * @copydoc Dali::Internal::ProxyObject::GetDefaultPropertyIndices() + * @copydoc Dali::Internal::Object::GetDefaultPropertyIndices() */ virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const; /** - * @copydoc Dali::Internal::ProxyObject::GetDefaultPropertyName() + * @copydoc Dali::Internal::Object::GetDefaultPropertyName() */ - virtual const char* GetDefaultPropertyName(Property::Index index) const; + virtual const char* GetDefaultPropertyName( Property::Index index ) const; /** - * @copydoc Dali::Internal::ProxyObject::GetDefaultPropertyIndex() + * @copydoc Dali::Internal::Object::GetDefaultPropertyIndex() */ - virtual Property::Index GetDefaultPropertyIndex(const std::string& name) const; + virtual Property::Index GetDefaultPropertyIndex( const std::string& name ) const; /** - * @copydoc Dali::Internal::ProxyObject::IsDefaultPropertyWritable() + * @copydoc Dali::Internal::Object::IsDefaultPropertyWritable() */ - virtual bool IsDefaultPropertyWritable(Property::Index index) const; + virtual bool IsDefaultPropertyWritable( Property::Index index ) const; /** - * @copydoc Dali::Internal::ProxyObject::IsDefaultPropertyAnimatable() + * @copydoc Dali::Internal::Object::IsDefaultPropertyAnimatable() */ - virtual bool IsDefaultPropertyAnimatable(Property::Index index) const; + virtual bool IsDefaultPropertyAnimatable( Property::Index index ) const; /** - * @copydoc Dali::Internal::ProxyObject::IsDefaultPropertyAConstraintInput() + * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput() */ virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const; /** - * @copydoc Dali::Internal::ProxyObject::GetDefaultPropertyType() + * @copydoc Dali::Internal::Object::GetDefaultPropertyType() */ - virtual Property::Type GetDefaultPropertyType(Property::Index index) const; + virtual Property::Type GetDefaultPropertyType( Property::Index index ) const; /** - * @copydoc Dali::Internal::ProxyObject::SetDefaultProperty() + * @copydoc Dali::Internal::Object::SetDefaultProperty() */ - virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue); + virtual void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ); /** - * @copydoc Dali::Internal::ProxyObject::SetCustomProperty() + * @copydoc Dali::Internal::Object::SetSceneGraphProperty() */ - virtual void SetCustomProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value ); + virtual void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value ); /** - * @copydoc Dali::Internal::ProxyObject::GetDefaultProperty() + * @copydoc Dali::Internal::Object::GetDefaultProperty() */ virtual Property::Value GetDefaultProperty( Property::Index index ) const; /** - * @copydoc Dali::Internal::ProxyObject::InstallSceneObjectProperty() + * @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 void InstallSceneObjectProperty( SceneGraph::PropertyBase& newProperty, const std::string& name, unsigned int index ); + virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const; /** - * @copydoc Dali::Internal::ProxyObject::GetSceneObject() + * @copydoc Dali::Internal::Object::GetSceneObject() */ virtual const SceneGraph::PropertyOwner* GetSceneObject() const; /** - * @copydoc Dali::Internal::ProxyObject::GetSceneObjectAnimatableProperty() + * @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty() */ virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const; /** - * @copydoc Dali::Internal::ProxyObject::GetSceneObjectInputProperty() + * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty() */ virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const; /** - * @copydoc Dali::Internal::ProxyObject::GetPropertyComponentIndex() + * @copydoc Dali::Internal::Object::GetPropertyComponentIndex() */ 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(); // Undefined - Actor(const Actor&); + Actor( const Actor& ); // Undefined - Actor& operator=(const Actor& rhs); + Actor& operator=( const Actor& rhs ); /** * 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. @@ -1255,59 +1749,67 @@ private: /** * For use in derived classes, called after Initialize() */ - virtual void OnInitialize() {} + 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. * The derived class must not modify the actor hierachy (Add/Remove children) during this callback. */ - virtual void OnStageConnectionInternal() {} + virtual void OnStageConnectionInternal() + { + } /** * For use in internal derived classes. * 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 OnStageDisconnectionInternal() + { + } /** * 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 ) + { + } /** * For use in external (CustomActor) derived classes. * This is called after the atomic DisconnectFromStage() traversal has been completed. */ - virtual void OnStageDisconnectionExternal() {} + virtual void OnStageDisconnectionExternal() + { + } /** * For use in derived classes; this is called after Add() has added a child. * @param[in] child The child that was added. */ - virtual void OnChildAdd( Actor& child ) {} + virtual void OnChildAdd( Actor& child ) + { + } /** - * 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 ) {} + virtual void OnChildRemove( Actor& child ) + { + } /** * For use in derived classes. * This is called after SizeSet() has been called. */ - virtual void OnSizeSet(const Vector3& targetSize) {} - - /** - * For use in derived classes. - * This is called after a non animatable custom property is set. - * @param [in] index The index of the property. - * @param [in] propertyValue The value of the property. - */ - virtual void OnPropertySet( Property::Index index, Property::Value propertyValue ) {} + virtual void OnSizeSet( const Vector3& targetSize ) + { + } /** * For use in derived classes. @@ -1315,7 +1817,10 @@ private: * @param[in] event The touch event. * @return True if the event should be consumed. */ - virtual bool OnTouchEvent(const TouchEvent& event) { return false; } + virtual bool OnTouchEvent( const TouchEvent& event ) + { + return false; + } /** * For use in derived classes. @@ -1323,111 +1828,242 @@ private: * @param[in] event The hover event. * @return True if the event should be consumed. */ - virtual bool OnHoverEvent(const HoverEvent& event) { return false; } + virtual bool OnHoverEvent( const HoverEvent& event ) + { + return false; + } /** * 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) { return false; } + 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(); + + /** + * @brief Apply the size set policy to the input size + * + * @param[in] size The size to apply the policy to + * @return Return the adjusted size + */ + 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 ); /** - * For use in derived class - * If an alias for a child exists, return the child otherwise return an empty handle. - * For example 'previous' could return the last selected child. - * @pre The Actor has been initialized. - * @param[in] actorAlias the name of the actor to find - * @return A handle to the actor if found, or an empty handle if not. + * @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 */ - virtual Dali::Actor GetChildByAlias(const std::string& actorAlias) { return Dali::Actor(); } + bool ShiftSiblingsLevels( ActorContainer& siblings, int targetLevelToShiftFrom ); /** - * Support function for FindChildByAlias - * @pre The Actor has been initialized. - * @param[in] actorAlias the name of the aliased actor to find - * @return A handle to the actor if found, or an empty handle if not. + * @brief Get the current position of the actor in screen coordinates. + * + * @return Returns the screen position of actor */ - Dali::Actor DoGetChildByAlias(const std::string& actorAlias); + 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 - 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 + Actor* mParent; ///< Each actor (except the root) can have one parent + ActorContainer* mChildren; ///< Container of referenced actors, lazily initialized + RendererContainer* mRenderers; ///< Renderer container -#ifdef DYNAMICS_SUPPORT - DynamicsData* mDynamicsData; ///< optional physics data -#endif + 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 + struct RelayoutData; + RelayoutData* mRelayoutData; ///< Struct to hold optional collection of relayout variables - ActorAttachmentPtr mAttachment; ///< Optional referenced attachment + ActorGestureData* mGestureData; ///< Optional Gesture data. Only created when actor requires gestures // Signals - Dali::Actor::TouchSignalV2 mTouchedSignalV2; - Dali::Actor::HoverSignalV2 mHoveredSignalV2; - Dali::Actor::MouseWheelEventSignalV2 mMouseWheelEventSignalV2; - Dali::Actor::SetSizeSignalV2 mSetSizeSignalV2; - Dali::Actor::OnStageSignalV2 mOnStageSignalV2; - Dali::Actor::OffStageSignalV2 mOffStageSignalV2; - - Vector3 mSize; ///< Event-side storage for size (not a pointer as most actors will have a size) + Dali::Actor::TouchSignalType mTouchedSignal; + Dali::Actor::TouchDataSignalType mTouchSignal; + Dali::Actor::HoverSignalType mHoveredSignal; + Dali::Actor::WheelEventSignalType mWheelEventSignal; + Dali::Actor::OnStageSignalType mOnStageSignal; + Dali::Actor::OffStageSignalType mOffStageSignal; + Dali::Actor::OnRelayoutSignalType mOnRelayoutSignal; + DevelActor::VisibilityChangedSignalType mVisibilityChangedSignal; + + 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 mInheritRotation : 1; ///< Cached: Whether the parent's rotation should be inherited. + 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 + 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 -inline Internal::Actor& GetImplementation(Dali::Actor& actor) +inline Internal::Actor& GetImplementation( Dali::Actor& actor ) { - DALI_ASSERT_ALWAYS(actor && "Actor handle is empty"); + DALI_ASSERT_ALWAYS( actor && "Actor handle is empty" ); BaseObject& handle = actor.GetBaseObject(); - return static_cast(handle); + return static_cast< Internal::Actor& >( handle ); } -inline const Internal::Actor& GetImplementation(const Dali::Actor& actor) +inline const Internal::Actor& GetImplementation( const Dali::Actor& actor ) { - DALI_ASSERT_ALWAYS(actor && "Actor handle is empty"); + DALI_ASSERT_ALWAYS( actor && "Actor handle is empty" ); const BaseObject& handle = actor.GetBaseObject(); - return static_cast(handle); + return static_cast< const Internal::Actor& >( handle ); } } // namespace Dali -#endif // __DALI_INTERNAL_ACTOR_H__ +#endif // DALI_INTERNAL_ACTOR_H