X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Factors%2Factor-impl.h;h=412d2a0b880b8bbdc87d01c72a2a9a5148f03a35;hb=b1ce4d4fcd7c85330c5fe99465c78bb8b9c42244;hp=75f5eac052aab3a5137cc26056249480b4dcb3c2;hpb=e45786f4a82498177727422a935f7b56b79f8f45;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 75f5eac..412d2a0 100644 --- a/dali/internal/event/actors/actor-impl.h +++ b/dali/internal/event/actors/actor-impl.h @@ -22,14 +22,14 @@ #include // INTERNAL INCLUDES -#include #include #include #include #include #include #include -#include +#include +#include #include #include #include @@ -44,22 +44,22 @@ namespace Dali struct KeyEvent; struct TouchEvent; -struct MouseWheelEvent; +struct HoverEvent; +struct WheelEvent; namespace Internal { class Actor; class ActorGestureData; +class Animation; class RenderTask; -class ShaderEffect; struct DynamicsData; -typedef IntrusivePtr ActorPtr; -typedef IntrusivePtr ShaderEffectPtr; -typedef Dali::ActorContainer ActorContainer; // Store handles to return via public-api -typedef ActorContainer::iterator ActorIter; -typedef ActorContainer::const_iterator ActorConstIter; +typedef IntrusivePtr< Actor > ActorPtr; +typedef std::vector< Dali::Actor > ActorContainer; // Store handles to return via public-api +typedef ActorContainer::iterator ActorIter; +typedef ActorContainer::const_iterator ActorConstIter; /** * Actor is the primary object which Dali applications interact with. @@ -71,11 +71,47 @@ typedef ActorContainer::const_iterator ActorConstIter; * The scene-graph can be updated in a separate thread, so the attachment 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. */ @@ -91,7 +127,7 @@ 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 @@ -105,7 +141,7 @@ public: * @pre The actor does not already have an attachment. * @param[in] attachment The object to attach. */ - void Attach(ActorAttachment& attachment); + void Attach( ActorAttachment& attachment ); /** * Retreive the object attached to an actor. @@ -162,14 +198,24 @@ public: * @param [in] child The child. * @post The child will be referenced by its parent. */ - void Add(Actor& child); + 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. */ - void Remove(Actor& child); + void Remove( Actor& child ); /** * @copydoc Dali::Actor::Unparent @@ -185,19 +231,7 @@ 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; + Dali::Actor GetChildAt( unsigned int index ) const; /** * Retrieve a reference to Actor's children. @@ -212,17 +246,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. @@ -240,7 +269,7 @@ public: * @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. @@ -250,7 +279,7 @@ public: * @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. @@ -258,7 +287,14 @@ public: * 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. @@ -266,7 +302,14 @@ public: * 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. @@ -287,12 +330,27 @@ public: void SetDepth( float depth ); /** - * Retrieve the Actor's size. + * Retrieve the Actor's size from event side. + * This size will be the size set or if animating then the target size. + * @return The Actor's size. + */ + const Vector3& GetTargetSize() const; + + /** + * Retrieve the Actor's size from update side. + * This size will be the size set or animating but will be a frame behind. * @return The Actor's size. */ const Vector3& GetCurrentSize() const; /** + * Return the natural size of the actor + * + * @return The actor's natural size + */ + virtual Vector3 GetNaturalSize() const; + + /** * Set the origin of an actor, within its parent's area. * This is expressed in 2D unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the parent, * and (1.0, 1.0, 0.5) is the bottom-right corner. @@ -300,7 +358,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 @@ -334,7 +392,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. @@ -367,7 +425,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. @@ -376,38 +434,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. @@ -417,6 +475,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; @@ -432,60 +497,74 @@ 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. + * 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 Radian& angleRadians, const Vector3& axis); + void SetOrientation( const Radian& angleRadians, const Vector3& axis ); /** - * Sets the rotation of the Actor. - * @param [in] rotation The new rotation. + * Sets the orientation of the Actor. + * @param [in] orientation The new orientation. */ - void SetRotation(const Quaternion& rotation); + 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; /** - * @copydoc Dali::Actor::GetCurrentWorldRotation() + * 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. */ - const Quaternion& GetCurrentWorldRotation() const; + 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::GetCurrentWorldOrientation() + */ + 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. @@ -493,13 +572,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. @@ -523,7 +602,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. @@ -557,7 +636,7 @@ public: * Sets the visibility flag of an actor. * @param [in] visible The new visibility flag. */ - void SetVisible(bool visible); + void SetVisible( bool visible ); /** * Retrieve the visibility flag of an actor. @@ -569,13 +648,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. @@ -584,33 +657,34 @@ public: float GetCurrentOpacity() const; /** - * Sets whether an actor should emit touch signals; see SignalTouch(). + * 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. + * the touch event signal will be emitted, and as soon as an application connects to the SignalHover(), the + * hover event signal will be emitted. * - * If the application wishes to temporarily disable the touch event signal emission, then they can do so by calling: + * If the application wishes to temporarily disable the touch or hover event signal emission, then they can do so by calling: * @code * actor.SetSensitive(false); * @endcode * - * Then, to re-enable the touch event signal emission, the application should call: + * Then, to re-enable the touch or hover event signal emission, the application should call: * @code * actor.SetSensitive(true); * @endcode * - * @see SignalTouch(). - * @note If an actor's sensitivity is set to false, then it's children will not emit a touch event signal either. - * @param[in] sensitive true to enable emission of the touch event signals, false otherwise. + * @see SignalTouch() and SignalHover(). + * @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; } /** - * Query whether an actor emits touch event signals. + * Query whether an actor emits touch or hover event signals. * @see SetSensitive(bool) - * @return true, if emission of touch event signals is enabled, false otherwise. + * @return true, if emission of touch or hover event signals is enabled, false otherwise. */ bool IsSensitive() const { @@ -618,38 +692,6 @@ public: } /** - * Set whether the actor inherits a shader effect from its parent. - * The inherited effect can be overridden using SetShaderEffect() - * @param [in] inherit True if the parent effect is inherited. - */ - void SetInheritShaderEffect(bool inherit); - - /** - * Query whether the actor inherits a shader effect from its parent. - * @return True if the parent effect is inherited. - */ - bool GetInheritShaderEffect() const; - - /** - * Sets the shader effect for the Actor. - * Shader effects provide special effects like rippling and bending. - * Setting a shader effect removes any shader effect previously set by SetShaderEffect. - * @param [in] effect The shader effect. - */ - void SetShaderEffect(ShaderEffect& effect); - - /** - * Retrieve the shader effect for the Actor. - * @return The shader effect - */ - ShaderEffectPtr GetShaderEffect() const; - - /** - * Removes the current shader effect. - */ - void RemoveShaderEffect(); - - /** * @copydoc Dali::Actor::SetDrawMode */ void SetDrawMode( DrawMode::Type drawMode ); @@ -662,7 +704,7 @@ public: /** * @copydoc Dali::Actor::SetOverlay */ - void SetOverlay(bool enable); + void SetOverlay( bool enable ); /** * @copydoc Dali::Actor::IsOverlay @@ -674,7 +716,7 @@ public: * The default value is for it not to transmit scaling. * @param[in] transmitGeometryScaling True to transmit scaling. */ - void SetTransmitGeometryScaling(bool transmitGeometryScaling); + void SetTransmitGeometryScaling( bool transmitGeometryScaling ); /** * Get the TransmitGeometryScaling property for this actor. @@ -689,14 +731,14 @@ public: * * @param[in] volume the volume of the model and it's children */ - void SetInitialVolume(const Vector3& volume); + 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. @@ -717,12 +759,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. */ @@ -733,7 +769,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. @@ -746,6 +782,444 @@ public: */ const Vector4& GetCurrentWorldColor() const; +public: + + // Size negotiation virtual functions + + /** + * @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 ) + { + } + + /** + * @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 ) {} + + /** + * @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 ); + + /** + * @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 ); + + /** + * @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 ); + + /** + * @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 ); + + /** + * @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 + */ + 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. + * + * Derived classes should override this if they wish to customize the height returned. + * + * @param width to use. + * @return the height based on the width. + */ + virtual float GetHeightForWidth( float width ); + + /** + * @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. + */ + 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 ); + + /** + * @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; + + /** + * @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 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) + * + * 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 RelayoutRequest( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); + + /** + * @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 + */ + bool RelayoutDependentOnParent( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); + + /** + * @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 + */ + bool RelayoutDependentOnDimension( Dimension::Type dimension, Dimension::Type dependentDimension ); + + /** + * Negotiate sizes for a control in all dimensions + * + * @param[in] allocatedSize The size constraint that the control must respect + */ + void NegotiateDimensions( const Vector2& allocatedSize ); + + /** + * 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; + #ifdef DYNAMICS_SUPPORT // Dynamics @@ -754,7 +1228,7 @@ public: void DisableDynamics(); /// @copydoc Dali::Actor::EnableDynamics(Dali::DynamicsBodyConfig) - DynamicsBodyPtr EnableDynamics(DynamicsBodyConfigPtr bodyConfig); + DynamicsBodyPtr EnableDynamics(DynamicsBodyConfigPtr bodyConfig); /// @copydoc Dali::Actor::GetDynamicsBody DynamicsBodyPtr GetDynamicsBody() const; @@ -842,7 +1316,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. @@ -854,7 +1328,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( RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const; /** * Converts from the actor's coordinate system to screen coordinates. @@ -894,21 +1368,24 @@ 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, + Vector4& hitPointLocal, + float& distance ) const; /** - * Sets whether the actor should receive a notification when touch motion events leave + * Sets whether the actor should receive a notification when touch or hover motion events leave * the boundary of the actor. * * @note By default, this is set to false as most actors do not require this. - * @note Need to connect to the SignalTouch to actually receive this event. + * @note Need to connect to the SignalTouch or SignalHover to actually receive this event. * * @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 events whenever touch motion events leave + * This returns whether the actor requires touch or hover events whenever touch or hover motion events leave * the boundary of the actor. * @return true if a Leave event is required, false otherwise. */ @@ -931,10 +1408,16 @@ public: bool GetTouchRequired() 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 hover events. + * @return True if hover events are required. */ - bool GetMouseWheelEventRequired() const; + bool GetHoverRequired() const; + + /** + * Query whether the application or derived actor type requires wheel events. + * @return True if wheel events are required. + */ + bool GetWheelEventRequired() const; /** * Query whether the actor is actually hittable. This method checks whether the actor is @@ -968,39 +1451,51 @@ public: * @param[in] event The touch event. * @return True if the event was consumed. */ - bool EmitTouchEventSignal(const TouchEvent& event); + bool EmitTouchEventSignal( const TouchEvent& event ); + + /** + * 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 ); /** - * 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 ); /** * @copydoc Dali::Actor::TouchedSignal() */ - Dali::Actor::TouchSignalV2& TouchedSignal(); + Dali::Actor::TouchSignalType& TouchedSignal(); /** - * @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(); /** * Connects a callback function with the object's signals. @@ -1011,7 +1506,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. @@ -1020,24 +1518,42 @@ 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 +public: + // For Animation + + /** + * This should only be called by Animation, when the actors SIZE property is animated. + * + * @param[in] animation The animation that resized the actor + * @param[in] targetSize The new target size of the actor + */ + void NotifySizeAnimation( Animation& animation, const Vector3& targetSize ); + + /** + * This should only be called by Animation, when the actors SIZE_WIDTH or SIZE_HEIGHT property is animated. + * + * @param[in] animation The animation that resized the actor + * @param[in] targetSize The new target size of the actor + */ + void NotifySizeAnimation( Animation& animation, float targetSize, Property::Index property ); /** * For use in derived classes. * This should only be called by Animation, when the actor is resized using Animation::Resize(). */ - 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, RENDERABLE, LAYER, ROOT_LAYER }; /** @@ -1050,7 +1566,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() @@ -1060,21 +1576,23 @@ 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. */ - void ConnectToStage(Stage& stage); + void ConnectToStage( int index = -1 ); /** * 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[out] connectionList On return, the list of connected actors which require notification. */ - void RecursiveConnectToStage( Stage& stage, ActorContainer& connectionList ); + void RecursiveConnectToStage( ActorContainer& connectionList, int index = -1 ); /** * 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(); + void ConnectToSceneGraph( int index = -1 ); /** * Helper for ConnectToStage, to notify a connected actor through the public API. @@ -1109,90 +1627,95 @@ protected: */ bool IsNodeConnected() const; -public: // Default property extensions from ProxyObject - /** - * @copydoc Dali::Internal::ProxyObject::IsSceneObjectRemovable() + * 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 */ - virtual bool IsSceneObjectRemovable() const; + float CalculateSizeZ( const Vector2& size ) const; + +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 std::string& 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::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; @@ -1202,16 +1725,17 @@ private: 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); + void SetParent( Actor* parent, int index = -1 ); /** * Helper to create a Node for this Actor. @@ -1223,118 +1747,144 @@ 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() + { + } /** * 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. * @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) {} + 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. + * This is only called if mDerivedRequiresTouch is true, and the touch-signal was not consumed. + * @param[in] event The touch event. + * @return True if the event should be consumed. */ - virtual void OnPropertySet( Property::Index index, Property::Value propertyValue ) {} + virtual bool OnTouchEvent( const TouchEvent& event ) + { + return false; + } /** * For use in derived classes. - * This is only called if mTouchRequired is true, and the touch-signal was not consumed. - * @param[in] event The touch event. + * This is only called if mDerivedRequiresHover is true, and the hover-signal was not consumed. + * @param[in] event The hover event. * @return True if the event should be consumed. */ - virtual bool OnTouchEvent(const TouchEvent& 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; + } /** - * 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 Ensure the relayout data is allocated */ - virtual Dali::Actor GetChildByAlias(const std::string& actorAlias) { return Dali::Actor(); } + void EnsureRelayoutData() const; /** - * 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 Apply the size set policy to the input size + * + * @param[in] size The size to apply the policy to + * @return Return the adjusted size */ - Dali::Actor DoGetChildByAlias(const std::string& actorAlias); + Vector2 ApplySizeSetPolicy( const Vector2 size ); 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 + 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 + + struct RelayoutData; + mutable RelayoutData* mRelayoutData; ///< Struct to hold optional collection of relayout variables #ifdef DYNAMICS_SUPPORT - DynamicsData* mDynamicsData; ///< optional physics data + DynamicsData* mDynamicsData; ///< optional physics data #endif - ActorGestureData* mGestureData; /// Optional Gesture data. Only created when actor requires gestures + ActorGestureData* mGestureData; ///< Optional Gesture data. Only created when actor requires gestures - ActorAttachmentPtr mAttachment; ///< Optional referenced attachment - ShaderEffectPtr mShaderEffect; ///< Optional referenced shader effect + ActorAttachmentPtr mAttachment; ///< Optional referenced attachment // Signals - Dali::Actor::TouchSignalV2 mTouchedSignalV2; - Dali::Actor::MouseWheelEventSignalV2 mMouseWheelEventSignalV2; - Dali::Actor::SetSizeSignalV2 mSetSizeSignalV2; - Dali::Actor::OnStageSignalV2 mOnStageSignalV2; - Dali::Actor::OffStageSignalV2 mOffStageSignalV2; + Dali::Actor::TouchSignalType mTouchedSignal; + Dali::Actor::HoverSignalType mHoveredSignal; + Dali::Actor::WheelEventSignalType mWheelEventSignal; + Dali::Actor::OnStageSignalType mOnStageSignal; + Dali::Actor::OffStageSignalType mOffStageSignal; + Dali::Actor::OnRelayoutSignalType mOnRelayoutSignal; + + Vector3 mTargetSize; ///< Event-side storage for size (not a pointer as most actors will have a size) + Vector3 mTargetPosition; ///< Event-side storage for position (not a pointer as most actors will have a position) std::string mName; ///< Name of the actor unsigned int mId; ///< A unique ID to identify the actor starting from 1, and 0 is reserved @@ -1348,59 +1898,43 @@ protected: 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 mDerivedRequiresMouseWheelEvent : 1; ///< Whether the derived actor type requires mouse wheel event signals + bool mDerivedRequiresHover : 1; ///< Whether the derived actor type requires hover event signals + bool mDerivedRequiresWheelEvent : 1; ///< Whether the derived actor type requires wheel event signals bool mOnStageSignalled : 1; ///< Set to true before OnStageConnection signal is emitted, and false before OnStageDisconnection - bool mInheritRotation : 1; ///< Cached: Whether the parent's rotation should be inherited. + bool mInsideOnSizeSet : 1; ///< Whether we are inside OnSizeSet + bool mInheritOrientation : 1; ///< Cached: Whether the parent's orientation should be inherited. bool mInheritScale : 1; ///< Cached: Whether the parent's scale should be inherited. DrawMode::Type mDrawMode : 2; ///< Cached: How the actor and its children should be drawn PositionInheritanceMode mPositionInheritanceMode : 2; ///< Cached: Determines how position is inherited ColorMode mColorMode : 2; ///< Cached: Determines whether mWorldColor is inherited - // Default properties - typedef std::map DefaultPropertyLookup; - 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 - - // Default properties - static DefaultPropertyLookup* mDefaultPropertyLookup; + 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 }; -/** - * @brief Structure for setting up default properties and their details. - */ -struct PropertyDetails -{ - std::string name; ///< The name of the property. - Property::Type type; ///< The property type. - bool writable:1; ///< Whether the property is writable - bool animatable:1; ///< Whether the property is animatable. - bool constraintInput:1; ///< Whether the property can be used as an input to a constraint. -}; - } // 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