X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Factors%2Factor-impl.h;h=9ca88450b71a24022cec87e1e8123fdfdb244eb3;hb=462cbee2270984cdca45488f3733d664dcf49187;hp=e5033038f67c4d2f3bc0fba479a0e6e39c155e96;hpb=24a826711c9b42968089e6ad54faead44a5df376;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 e503303..59e23d0 100644 --- a/dali/internal/event/actors/actor-impl.h +++ b/dali/internal/event/actors/actor-impl.h @@ -1,59 +1,68 @@ -#ifndef __DALI_INTERNAL_ACTOR_H__ -#define __DALI_INTERNAL_ACTOR_H__ - -// -// Copyright (c) 2014 Samsung Electronics Co., Ltd. -// -// Licensed under the Flora License, Version 1.0 (the License); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://floralicense.org/license/ -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an AS IS BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// +#ifndef DALI_INTERNAL_ACTOR_H +#define DALI_INTERNAL_ACTOR_H + +/* + * 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ // EXTERNAL INCLUDES #include // INTERNAL INCLUDES -#include -#include -#include #include +#include +#include #include +#include #include -#include -#include +#include +#include +#include #include -#include -#include +#include +#include +#include #include namespace Dali { struct KeyEvent; -struct TouchEvent; -struct MouseWheelEvent; +class TouchData; +struct HoverEvent; +struct WheelEvent; namespace Internal { class Actor; +class ActorGestureData; +class Animation; class RenderTask; -class ShaderEffect; -struct DynamicsData; +class Renderer; -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 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. @@ -61,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. */ @@ -85,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 /** @@ -124,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(); } /** @@ -156,14 +186,14 @@ public: * @param [in] child The child. * @post The child will be referenced by its parent. */ - void Add(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 @@ -179,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() { @@ -206,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. @@ -229,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. @@ -281,12 +305,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. + */ + 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. @@ -294,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 @@ -328,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. @@ -361,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. @@ -370,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. @@ -411,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; @@ -426,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 SetRotation(const Radian& angleRadians, const Vector3& axis); + void SetInheritPosition( bool inherit ); /** - * Sets the rotation of the Actor. - * @param [in] rotation The new rotation. + * @copydoc Dali::Actor::IsPositionInherited() */ - void SetRotation(const Quaternion& rotation); + bool IsPositionInherited() const; + + /** + * Sets the orientation of the Actor. + * @param [in] angleRadians The new orientation angle in radians. + * @param [in] axis The new axis of orientation. + */ + 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; /** - * @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. @@ -487,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. @@ -517,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. @@ -549,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. @@ -563,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. @@ -578,33 +642,40 @@ public: float GetCurrentOpacity() const; /** - * Sets whether an actor should emit touch signals; see SignalTouch(). + * 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. + * 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 { @@ -612,216 +683,572 @@ 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. + * @copydoc Dali::Actor::SetDrawMode */ - void SetInheritShaderEffect(bool inherit); + void SetDrawMode( DrawMode::Type drawMode ); /** - * Query whether the actor inherits a shader effect from its parent. - * @return True if the parent effect is inherited. + * @copydoc Dali::Actor::GetDrawMode */ - bool GetInheritShaderEffect() const; + DrawMode::Type GetDrawMode() 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. + * @copydoc Dali::Actor::IsOverlay */ - void SetShaderEffect(ShaderEffect& effect); + bool IsOverlay() const; /** - * Retrieve the shader effect for the Actor. - * @return The shader effect + * 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. */ - ShaderEffectPtr GetShaderEffect() const; + void SetColor( const Vector4& color ); /** - * Removes the current shader effect. + * Set the red component of the color. + * @param [in] red The new red component. */ - void RemoveShaderEffect(); + void SetColorRed( float red ); /** - * @copydoc Dali::Actor::SetDrawMode + * Set the green component of the color. + * @param [in] green The new green component. */ - void SetDrawMode( DrawMode::Type drawMode ); + void SetColorGreen( float green ); /** - * @copydoc Dali::Actor::GetDrawMode + * Set the blue component of the scale factor. + * @param [in] blue The new blue value. */ - DrawMode::Type GetDrawMode() const; + void SetColorBlue( float blue ); /** - * @copydoc Dali::Actor::SetOverlay + * Retrieve the actor's color. + * @return The color. */ - void SetOverlay(bool enable); + const Vector4& GetCurrentColor() const; /** - * @copydoc Dali::Actor::IsOverlay + * Sets the actor's color mode. + * Color mode specifies whether Actor uses its own color or inherits its parent color + * @param [in] colorMode to use. */ - bool IsOverlay() const; + void SetColorMode( ColorMode colorMode ); /** - * 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. + * Returns the actor's color mode. + * @return currently used colorMode. */ - void SetTransmitGeometryScaling(bool transmitGeometryScaling); + ColorMode GetColorMode() const; /** - * Get the TransmitGeometryScaling property for this actor. - * @return True if geometry scaling is applied to the inherited scale. + * @copydoc Dali::Actor::GetCurrentWorldColor() */ - bool GetTransmitGeometryScaling() const; + const Vector4& GetCurrentWorldColor() 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. + * @copydoc Dali::Actor::GetHierarchyDepth() + */ + inline int GetHierarchyDepth() const + { + if( mIsOnStage ) + { + return static_cast(mDepth); + } + + return -1; + } + + /** + * Get the actor's sorting depth * - * @param[in] volume the volume of the model and it's children + * @return The depth used for hit-testing and renderer sorting */ - void SetInitialVolume(const Vector3& volume); + unsigned int GetSortingDepth(); + +public: + + // Size negotiation virtual functions /** - * 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. + * @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. */ - void SetColor(const Vector4& color); + virtual void OnRelayout( const Vector2& size, RelayoutContainer& container ) + { + } /** - * Set the red component of the color. - * @param [in] red The new red component. + * @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 */ - void SetColorRed( float red ); + virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension ) {} /** - * Set the green component of the color. - * @param [in] green The new green component. + * @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 */ - void SetColorGreen( float green ); + virtual void OnCalculateRelayoutSize( Dimension::Type dimension ); /** - * Set the blue component of the scale factor. - * @param [in] blue The new blue value. + * @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 */ - void SetColorBlue( float blue ); + virtual void OnLayoutNegotiated( float size, Dimension::Type dimension ); /** - * Apply a relative color change to an actor. - * @param[in] relativeColor The color to combine with the actors existing color. + * @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 */ - void ColorBy(const Vector4& relativeColor); + virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** - * Retrieve the actor's color. - * @return The color. + * @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 */ - const Vector4& GetCurrentColor() const; + virtual bool RelayoutDependentOnChildrenBase( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** - * Sets the actor's color mode. - * Color mode specifies whether Actor uses its own color or inherits its parent color - * @param [in] colorMode to use. + * @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 SetColorMode(ColorMode colorMode); + virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension ); /** - * Returns the actor's color mode. - * @return currently used colorMode. + * @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. */ - ColorMode GetColorMode() const; + virtual float GetHeightForWidth( float width ); /** - * @copydoc Dali::Actor::GetCurrentWorldColor() + * @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. */ - const Vector4& GetCurrentWorldColor() const; + 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 ); - // Dynamics + /** + * @copydoc Dali::Actor::GetResizePolicy() + */ + ResizePolicy::Type GetResizePolicy( Dimension::Type dimension ) const; - /// @copydoc Dali::Actor::DisableDynamics - void DisableDynamics(); + /** + * @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::EnableDynamics(Dali::DynamicsBodyConfig) - DynamicsBodyPtr EnableDynamics(DynamicsBodyConfigPtr bodyConfig); + /** + * @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 ); - /// @copydoc Dali::Actor::GetDynamicsBody - DynamicsBodyPtr GetDynamicsBody() const; + /** + * @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; - /// @copydoc Dali::Actor::AddDynamicsJoint(Dali::Actor,const Vector3&) - DynamicsJointPtr AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offset ); + /** + * @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; - /// @copydoc Dali::Actor::AddDynamicsJoint(Dali::Actor,const Vector3&,const Vector3&) - DynamicsJointPtr AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offsetA, const Vector3& offsetB ); + /** + * @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; - /// @copydoc Dali::Actor::GetNumberOfJoints - const int GetNumberOfJoints() 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 ); - /// @copydoc Dali::Actor::GetDynamicsJointByIndex - DynamicsJointPtr GetDynamicsJointByIndex( const int index ) const; + /** + * @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 ); - /// @copydoc Dali::Actor::GetDynamicsJoint - DynamicsJointPtr GetDynamicsJoint( ActorPtr attachedActor ) const; + /** + * @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 ); - /// @copydoc Dali::Actor::RemoveDynamicsJoint - void RemoveDynamicsJoint( DynamicsJointPtr joint ); + /** + * Negotiate sizes for a control in all dimensions + * + * @param[in] allocatedSize The size constraint that the control must respect + */ + void NegotiateDimensions( const Vector2& allocatedSize ); /** - * Hold a reference to a DynamicsJoint - * @param[in] joint The joint + * 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 ReferenceJoint( DynamicsJointPtr joint ); + void NegotiateDimension( Dimension::Type dimension, const Vector2& allocatedSize, ActorDimensionStack& recursionStack ); /** - * Release a reference to a DynamicsJoint - * @param[in] joint The joint + * @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 */ - void ReleaseJoint( DynamicsJointPtr joint ); + float CalculateSize( Dimension::Type dimension, const Vector2& maximumSize ); /** - * 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 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 */ - void SetDynamicsRoot(bool flag); + float ClampDimension( float size, Dimension::Type dimension ); -private: /** - * Check if this actor is the root actor in the dynamics simulation - * @return true if this is the dynamics root actor. + * 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 */ - bool IsDynamicsRoot() const; + void SetNegotiatedDimension( float negotiatedDimension, Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); /** - * Add actor to the dynamics simulation - * Invoked when the actor is staged, or it's parent becomes the simulation root + * Return the value of negotiated dimension for the given dimension + * + * @param dimension The dimension to retrieve + * @return Return the value of the negotiated dimension */ - void ConnectDynamics(); + float GetNegotiatedDimension( Dimension::Type dimension ) const; /** - * Remove actor from the dynamics simulation - * Invoked when the actor is unstaged, or it's parent stops being the the simulation root + * @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 DisconnectDynamics(); + void SetPadding( const Vector2& padding, Dimension::Type dimension ); /** - * An actor in a DynamicsJoint relationship has been staged - * @param[in] actor The actor passed into AddDynamicsJoint() + * Return the value of padding for the given dimension + * + * @param dimension The dimension to retrieve + * @return Return the value of padding for the dimension */ - void AttachedActorOnStage( Dali::Actor actor ); + Vector2 GetPadding( Dimension::Type dimension ) const; /** - * An actor in a DynamicsJoint relationship has been unstaged - * @param[in] actor The actor passed into AddDynamicsJoint() + * 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 */ - void AttachedActorOffStage( Dali::Actor actor ); + 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) @@ -831,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. @@ -843,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. @@ -883,21 +1310,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, + Vector2& 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. */ @@ -920,10 +1350,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 GetHoverRequired() const; + + /** + * 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 @@ -932,47 +1368,94 @@ public: */ bool IsHittable() const; + // Gestures + + /** + * Retrieve the gesture data associated with this actor. The first call to this method will + * allocate space for the ActorGestureData so this should only be called if an actor really does + * require gestures. + * @return Reference to the ActorGestureData for this actor. + * @note Once the gesture-data is created for an actor it is likely that gestures are required + * throughout the actor's lifetime so it will only be deleted when the actor is destroyed. + */ + ActorGestureData& GetGestureData(); + + /** + * Queries whether the actor requires the gesture type. + * @param[in] type The gesture type. + */ + bool IsGestureRequred( Gesture::Type type ) const; // Signals /** * 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 mouse wheel event signals. - * @param[in] event The mouse wheel event. + * Used by the EventProcessor to emit hover event signals. + * @param[in] event The hover event. * @return True if the event was consumed. */ - bool EmitMouseWheelEventSignal(const MouseWheelEvent& event); + bool EmitHoverEventSignal( const HoverEvent& event ); + + /** + * Used by the EventProcessor to emit wheel event signals. + * @param[in] event The wheel event. + * @return True if the event was consumed. + */ + 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::MouseWheelEventSignal() + * @copydoc Dali::Actor::TouchEventSignal() */ - Dali::Actor::MouseWheelEventSignalV2& MouseWheelEventSignal(); + Dali::Actor::TouchDataSignalType& TouchSignal(); /** - * @copydoc Dali::Actor::SetSizeSignal() + * @copydoc Dali::Actor::HoveredSignal() */ - Dali::Actor::SetSizeSignalV2& SetSizeSignal(); + Dali::Actor::HoverSignalType& HoveredSignal(); + + /** + * @copydoc Dali::Actor::WheelEventSignal() + */ + 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. @@ -983,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. @@ -992,24 +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 +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 }; /** @@ -1022,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() @@ -1031,17 +1519,17 @@ protected: /** * Called on a child during Add() when the parent actor is connected to the Stage. - * @param[in] stage The stage. + * @param[in] parentDepth The depth of the parent in the hierarchy. */ - void ConnectToStage(Stage& stage); + 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] 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 ); + void RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth ); /** * Connect the Node associated with this Actor to the scene-graph. @@ -1081,104 +1569,175 @@ protected: */ bool IsNodeConnected() const; -public: // Default property extensions from ProxyObject +public: + /** + * Trigger a rebuild of the actor depth tree from this root + * If a Layer3D is encountered, then this doesn't descend any further. + * The mSortedDepth of each actor is set appropriately. + */ + void RebuildDepthTree(); + +protected: /** - * @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 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::GetDefaultPropertyType() + * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput() */ - virtual Property::Type GetDefaultPropertyType(Property::Index index) const; + virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const; /** - * @copydoc Dali::Internal::ProxyObject::SetDefaultProperty() + * @copydoc Dali::Internal::Object::GetDefaultPropertyType() */ - virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue); + virtual Property::Type GetDefaultPropertyType( Property::Index index ) const; /** - * @copydoc Dali::Internal::ProxyObject::SetCustomProperty() + * @copydoc Dali::Internal::Object::SetDefaultProperty() */ - virtual void SetCustomProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value ); + virtual void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ); /** - * @copydoc Dali::Internal::ProxyObject::GetDefaultProperty() + * @copydoc Dali::Internal::Object::SetSceneGraphProperty() + */ + virtual void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value ); + + /** + * @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. */ - void SetParent(Actor* parent); + void SetParent( Actor* parent ); /** * Helper to create a Node for this Actor. @@ -1190,178 +1749,321 @@ 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) {} + 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 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. */ - virtual Dali::Actor GetChildByAlias(const std::string& actorAlias) { return Dali::Actor(); } + bool GetCachedPropertyValue( Property::Index index, Property::Value& value ) 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 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. */ - Dali::Actor DoGetChildByAlias(const std::string& actorAlias); + bool GetCurrentPropertyValue( Property::Index index, Property::Value& value ) const; -protected: + /** + * @brief Ensure the relayout data is allocated + */ + void EnsureRelayoutData(); - std::string mName; + /** + * @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 ); - static unsigned int mActorCounter; ///< A counter to track the actor instance creation - unsigned int mId; ///< A unique ID to identify the actor starting from 1, and 0 is reserved + /** + * 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; - StagePtr mStage; ///< Used to send messages to Node; valid until Core destruction + /** + * 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 ); - 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 mDerivedRequiresMouseWheelEvent : 1; ///< Whether the derived actor type requires mouse wheel event signals - bool mOnStageSignalled : 1; ///< Set to true before OnStageConnection signal is emitted, and false before OnStageDisconnection + /** + * @brief Shifts all siblings levels from the target level up by 1 to make space for a newly insert sibling + * at an exclusive level. + * + * @note Used with Raise and Lower API + * + * @param[in] siblings the actor container of the siblings + * @param[in] targetLevelToShiftFrom the sibling level to start shifting from + */ + bool ShiftSiblingsLevels( ActorContainer& siblings, int targetLevelToShiftFrom ); - bool mInheritRotation:1; ///< Cached: Whether the parent's rotation 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 + /** + * @brief Get the current position of the actor in screen coordinates. + * + * @return Returns the screen position of actor + */ + const Vector2 GetCurrentScreenPosition() const; - Actor* mParent; ///< Each actor (except the root) can have one parent + /** + * 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 ); - ActorContainer* mChildren; ///< Container of referenced actors - static ActorContainer mNullChildren; ///< Empty container (shared by all actors, returned by GetChildren() const) - ActorAttachmentPtr mAttachment; ///< Optional referenced attachment +protected: - const SceneGraph::Node* mNode; ///< Not owned + Actor* mParent; ///< Each actor (except the root) can have one parent + ActorContainer* mChildren; ///< Container of referenced actors, lazily initialized + RendererContainer* mRenderers; ///< Renderer container - // ParentOrigin & AnchorPoint are non-animatable - Vector3* mParentOrigin; // NULL means ParentOrigin::DEFAULT - Vector3* mAnchorPoint; // NULL means AnchorPoint::DEFAULT + 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 - ShaderEffectPtr mShaderEffect; ///< Optional referenced shader effect + struct RelayoutData; + RelayoutData* mRelayoutData; ///< Struct to hold optional collection of relayout variables - // Dynamics - DynamicsData* mDynamicsData; + ActorGestureData* mGestureData; ///< Optional Gesture data. Only created when actor requires gestures // 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::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 mIsLayer : 1; ///< Flag to identify that this is a layer + bool mIsOnStage : 1; ///< Flag to identify whether the actor is on-stage + 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 mDerivedRequiresWheelEvent : 1; ///< Whether the derived actor type requires wheel event signals + bool mOnStageSignalled : 1; ///< Set to true before OnStageConnection signal is emitted, and false before OnStageDisconnection + bool mInsideOnSizeSet : 1; ///< Whether we are inside OnSizeSet + bool mInheritPosition : 1; ///< Cached: Whether the parent's position should be inherited. + bool mInheritOrientation : 1; ///< Cached: Whether the parent's orientation should be inherited. + bool mInheritScale : 1; ///< Cached: Whether the parent's scale should be inherited. + bool mPositionUsesAnchorPoint : 1; ///< Cached: Whether the position uses the anchor point or not. + bool mVisible : 1; ///< Cached: Whether the actor is visible or not. + DrawMode::Type mDrawMode : 2; ///< Cached: How the actor and its children should be drawn + PositionInheritanceMode mPositionInheritanceMode : 2; ///< Cached: Determines how position is inherited + ColorMode mColorMode : 2; ///< Cached: Determines whether mWorldColor is inherited + ClippingMode::Type mClippingMode : 2; ///< Cached: Determines which clipping mode (if any) to use. - // Default properties +private: - typedef std::map DefaultPropertyLookup; + 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 +}; -private: +/** + * Helper class to create sorted depth index + */ +class ActorDepthTreeNode +{ +public: + ActorDepthTreeNode() + : mParentNode(NULL), + mNextSiblingNode(NULL), + mFirstChildNode(NULL), + mSiblingOrder( 0 ) + { + } - // Default properties + 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; + } - static DefaultPropertyLookup* mDefaultPropertyLookup; + 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