#define __DALI_INTERNAL_ACTOR_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <string>
// INTERNAL INCLUDES
-#include <dali/public-api/common/vector-wrapper.h>
-#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/events/gesture.h>
#include <dali/public-api/math/viewport.h>
-#include <dali/internal/event/common/object-impl.h>
+#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/size-negotiation/relayout-container.h>
-#include <dali/internal/event/common/stage-def.h>
#include <dali/internal/event/actors/actor-declarations.h>
-#include <dali/internal/event/actor-attachments/actor-attachment-declarations.h>
+#include <dali/internal/event/common/object-impl.h>
+#include <dali/internal/event/common/stage-def.h>
+#include <dali/internal/event/rendering/renderer-impl.h>
#include <dali/internal/update/nodes/node-declarations.h>
-#ifdef DYNAMICS_SUPPORT
-#include <dali/internal/event/dynamics/dynamics-declarations.h>
-#endif
-
namespace Dali
{
struct KeyEvent;
struct TouchEvent;
struct HoverEvent;
-struct MouseWheelEvent;
+struct WheelEvent;
namespace Internal
{
class ActorGestureData;
class Animation;
class RenderTask;
-struct DynamicsData;
+class Renderer;
-typedef IntrusivePtr< Actor > ActorPtr;
-typedef Dali::ActorContainer ActorContainer; // Store handles to return via public-api
+typedef std::vector< ActorPtr > ActorContainer;
typedef ActorContainer::iterator ActorIter;
typedef ActorContainer::const_iterator ActorConstIter;
+typedef std::vector< RendererPtr > RendererContainer;
+typedef RendererContainer::iterator RendererIter;
+
/**
* Actor is the primary object which Dali applications interact with.
* UI controls can be built by combining multiple actors.
* Multi-Touch events are received through signals emitted by the actor tree.
*
* An Actor is a proxy for a Node in the scene graph.
- * When an Actor is added to the Stage, it creates a node and attaches it to the scene graph.
- * The scene-graph can be updated in a separate thread, so the attachment is done using an asynchronous message.
+ * When an Actor is added to the Stage, it creates a node and connects it to the scene graph.
+ * The scene-graph can be updated in a separate thread, so the connection is done using an asynchronous message.
* When a tree of Actors is detached from the Stage, a message is sent to destroy the associated nodes.
*/
class Actor : public Object
*/
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
/**
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();
}
/**
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.
/**
* @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.
/**
* 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.
/**
* 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.
/**
* 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.
*/
/**
* 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.
*/
PositionInheritanceMode GetPositionInheritanceMode() const;
/**
+ * @copydoc Dali::Actor::SetInheritPosition()
+ */
+ void SetInheritPosition( bool inherit );
+
+ /**
+ * @copydoc Dali::Actor::IsPositionInherited()
+ */
+ bool IsPositionInherited() const;
+
+ /**
* Sets the orientation of the Actor.
* @param [in] angleRadians The new orientation angle in radians.
* @param [in] axis The new axis of orientation.
bool IsOverlay() const;
/**
- * Sets whether an actor transmits geometry scaling to it's children.
- * The default value is for it not to transmit scaling.
- * @param[in] transmitGeometryScaling True to transmit scaling.
- */
- void SetTransmitGeometryScaling( bool transmitGeometryScaling );
-
- /**
- * Get the TransmitGeometryScaling property for this actor.
- * @return True if geometry scaling is applied to the inherited scale.
- */
- bool GetTransmitGeometryScaling() const;
-
- /**
- * Sets the initial volume of the actor. Used for scaling the
- * actor appropriately as the actor is sized when transmitGeometryScaling
- * is set to true.
- *
- * @param[in] volume the volume of the model and it's children
- */
- void SetInitialVolume( const Vector3& volume );
-
- /**
* Sets the actor's color. The final color of actor depends on its color mode.
* This final color is applied to the drawable elements of an actor.
* @param [in] color The new color.
*/
const Vector4& GetCurrentWorldColor() const;
+ /**
+ * @copydoc Dali::Actor::GetHierarchyDepth()
+ */
+ int GetHierarchyDepth() const
+ {
+ if( mIsOnStage )
+ {
+ return static_cast<int>(mDepth);
+ }
+
+ return -1;
+ }
+
public:
// Size negotiation virtual functions
Dimension::Type GetDimensionDependency( Dimension::Type dimension ) const;
/**
- * @copydoc Dali::Actor::SetRelayoutEnabled()
+ * @brief Set the size negotiation relayout enabled on this actor
+ *
+ * @param[in] relayoutEnabled Boolean to enable or disable relayout
*/
void SetRelayoutEnabled( bool relayoutEnabled );
/**
- * @copydoc Dali::Actor::IsRelayoutEnabled()
+ * @brief Return if relayout is enabled
+ *
+ * @return Return if relayout is enabled or not for this actor
*/
bool IsRelayoutEnabled() const;
void RelayoutRequest( Dimension::Type dimension = Dimension::ALL_DIMENSIONS );
/**
- * @brief Request to relayout of all actors in the sub-tree below the given actor.
- *
- * This flags the actor and all actors below it for relayout. The actual
- * relayout is performed at the end of the frame. This means that multiple calls to relayout
- * will not cause multiple relayouts to occur.
- */
- void RelayoutRequestTree();
-
- /*
- * @copydoc Dali::Actor::PropagateRelayoutFlags
- */
- void PropagateRelayoutFlags();
-
- /**
* @brief Determine if this actor is dependent on it's parent for relayout
*
* @param dimension The dimension(s) to check for
float CalculateSize( Dimension::Type dimension, const Vector2& maximumSize );
/**
- * @brief Constain a dimension given the relayout constraints on this actor
+ * @brief Clamp a dimension given the relayout constraints on this actor
*
* @param[in] size The size to constrain
* @param[in] dimension The dimension the size exists in
- * @return Return the constrained size
+ * @return Return the clamped size
*/
- float ConstrainDimension( float size, Dimension::Type dimension );
+ float ClampDimension( float size, Dimension::Type dimension );
/**
* Negotiate a dimension based on the size of the parent
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
*/
float GetMaximumSize( Dimension::Type dimension ) const;
-#ifdef DYNAMICS_SUPPORT
-
- // Dynamics
-
- /// @copydoc Dali::Actor::DisableDynamics
- void DisableDynamics();
-
- /// @copydoc Dali::Actor::EnableDynamics(Dali::DynamicsBodyConfig)
- DynamicsBodyPtr EnableDynamics(DynamicsBodyConfigPtr bodyConfig);
-
- /// @copydoc Dali::Actor::GetDynamicsBody
- DynamicsBodyPtr GetDynamicsBody() const;
-
- /// @copydoc Dali::Actor::AddDynamicsJoint(Dali::Actor,const Vector3&)
- DynamicsJointPtr AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offset );
-
- /// @copydoc Dali::Actor::AddDynamicsJoint(Dali::Actor,const Vector3&,const Vector3&)
- DynamicsJointPtr AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offsetA, const Vector3& offsetB );
-
- /// @copydoc Dali::Actor::GetNumberOfJoints
- const int GetNumberOfJoints() const;
-
- /// @copydoc Dali::Actor::GetDynamicsJointByIndex
- DynamicsJointPtr GetDynamicsJointByIndex( const int index ) const;
-
- /// @copydoc Dali::Actor::GetDynamicsJoint
- DynamicsJointPtr GetDynamicsJoint( ActorPtr attachedActor ) const;
-
- /// @copydoc Dali::Actor::RemoveDynamicsJoint
- void RemoveDynamicsJoint( DynamicsJointPtr joint );
-
- /**
- * Hold a reference to a DynamicsJoint
- * @param[in] joint The joint
- */
- void ReferenceJoint( DynamicsJointPtr joint );
-
- /**
- * Release a reference to a DynamicsJoint
- * @param[in] joint The joint
- */
- void ReleaseJoint( DynamicsJointPtr joint );
-
- /**
- * Set this actor to be the root actor in the dynamics simulation
- * All children of the actor are added/removed from the simulation.
- * @param[in] flag When true sets this actor to be the simulation world root actor and
- * if OnStage() all dynamics enabled child actors are added to the simulation,
- * when false stops this actor being the simulation root and if OnStage() all
- * dynamics enabled child actors are removed from the simulation.
- */
- void SetDynamicsRoot(bool flag);
-
-private:
/**
- * Check if this actor is the root actor in the dynamics simulation
- * @return true if this is the dynamics root actor.
+ * @copydoc Dali::Actor::AddRenderer()
*/
- bool IsDynamicsRoot() const;
+ unsigned int AddRenderer( Renderer& renderer );
/**
- * Add actor to the dynamics simulation
- * Invoked when the actor is staged, or it's parent becomes the simulation root
+ * @copydoc Dali::Actor::GetRendererCount()
*/
- void ConnectDynamics();
+ unsigned int GetRendererCount() const;
/**
- * Remove actor from the dynamics simulation
- * Invoked when the actor is unstaged, or it's parent stops being the the simulation root
+ * @copydoc Dali::Actor::GetRendererAt()
*/
- void DisconnectDynamics();
+ RendererPtr GetRendererAt( unsigned int index );
/**
- * An actor in a DynamicsJoint relationship has been staged
- * @param[in] actor The actor passed into AddDynamicsJoint()
+ * @copydoc Dali::Actor::RemoveRenderer()
*/
- void AttachedActorOnStage( Dali::Actor actor );
+ void RemoveRenderer( Renderer& renderer );
/**
- * An actor in a DynamicsJoint relationship has been unstaged
- * @param[in] actor The actor passed into AddDynamicsJoint()
+ * @copydoc Dali::Actor::RemoveRenderer()
*/
- void AttachedActorOffStage( Dali::Actor actor );
-
-#endif // DYNAMICS_SUPPORT
+ 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)
* @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.
bool GetHoverRequired() const;
/**
- * Query whether the application or derived actor type requires mouse wheel events.
- * @return True if mouse wheel events are required.
+ * Query whether the application or derived actor type requires wheel events.
+ * @return True if wheel events are required.
*/
- bool GetMouseWheelEventRequired() const;
+ bool GetWheelEventRequired() const;
/**
* Query whether the actor is actually hittable. This method checks whether the actor is
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::HoverSignalType& HoveredSignal();
/**
- * @copydoc Dali::Actor::MouseWheelEventSignal()
+ * @copydoc Dali::Actor::WheelEventSignal()
*/
- Dali::Actor::MouseWheelEventSignalType& MouseWheelEventSignal();
+ Dali::Actor::WheelEventSignalType& WheelEventSignal();
/**
* @copydoc Dali::Actor::OnStageSignal()
*/
static bool DoAction( BaseObject* object,
const std::string& actionName,
- const std::vector< Property::Value >& attributes );
+ const Property::Map& attributes );
public:
// For Animation
/**
- * This should only be called by Animation, when the actor is resized using Animation::Resize().
+ * This should only be called by Animation, when the actors SIZE property is animated.
*
* @param[in] animation The animation that resized the actor
* @param[in] targetSize The new target size of the actor
void NotifySizeAnimation( Animation& animation, const Vector3& targetSize );
/**
+ * This should only be called by Animation, when the actors SIZE_WIDTH or SIZE_HEIGHT or SIZE_DEPTH property is animated.
+ *
+ * @param[in] animation The animation that resized the actor
+ * @param[in] targetSize The new target size of the actor
+ * @param[in] property The index of the property being animated
+ */
+ void NotifySizeAnimation( Animation& animation, float targetSize, Property::Index property );
+
+ /**
* For use in derived classes.
* This should only be called by Animation, when the actor is resized using Animation::Resize().
*/
{
}
+ /**
+ * This should only be called by Animation, when the actors POSITION property is animated.
+ *
+ * @param[in] animation The animation that repositioned the actor
+ * @param[in] targetPosition The new target position of the actor
+ */
+ void NotifyPositionAnimation( Animation& animation, const Vector3& targetPosition );
+
+ /**
+ * This should only be called by Animation, when the actors POSITION_X or POSITION_Y or POSITION_Z property is animated.
+ *
+ * @param[in] animation The animation that repositioned the actor
+ * @param[in] targetPosition The new target position of the actor
+ * @param[in] property The index of the property being animated
+ */
+ void NotifyPositionAnimation( Animation& animation, float targetPosition, Property::Index property );
+
protected:
enum DerivedType
{
- BASIC, RENDERABLE, LAYER, ROOT_LAYER
+ BASIC, LAYER, ROOT_LAYER
};
/**
/**
* Called on a child during Add() when the parent actor is connected to the Stage.
- * @param[in] stage The stage.
- * @param[in] index If set, it is only used for positioning the actor within the parent's child list.
+ * @param[in] parentDepth The depth of the parent in the hierarchy.
*/
- void ConnectToStage( int index = -1 );
+ void ConnectToStage( unsigned int parentDepth );
/**
* Helper for ConnectToStage, to recursively connect a tree of actors.
* This is atomic i.e. not interrupted by user callbacks.
- * @param[in] index If set, it is only used for positioning the actor within the parent's child list.
+ * @param[in] depth The depth in the hierarchy of the actor
* @param[out] connectionList On return, the list of connected actors which require notification.
*/
- void RecursiveConnectToStage( ActorContainer& connectionList, int index = -1 );
+ void RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth );
/**
* Connect the Node associated with this Actor to the scene-graph.
- * @param[in] index If set, it is only used for positioning the actor within the parent's child list.
*/
- void ConnectToSceneGraph( int index = -1 );
+ void ConnectToSceneGraph();
/**
* Helper for ConnectToStage, to notify a connected actor through the public API.
*/
bool IsNodeConnected() const;
- /**
- * 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
- */
- float CalculateSizeZ( const Vector2& size ) const;
-
public:
+
// Default property extensions from Object
/**
/**
* Set the actors parent.
* @param[in] parent The new parent.
- * @param[in] index If set, it is only used for positioning the actor within the parent's child list.
*/
- void SetParent( Actor* parent, int index = -1 );
+ void SetParent( Actor* parent );
/**
* Helper to create a Node for this Actor.
* 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 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 )
/**
* For use in derived classes.
- * This is only called if the mouse wheel signal was not consumed.
- * @param[in] event The mouse event.
+ * This is only called if the wheel signal was not consumed.
+ * @param[in] event The wheel event.
* @return True if the event should be consumed.
*/
- virtual bool OnMouseWheelEvent( const MouseWheelEvent& event )
+ virtual bool OnWheelEvent( const WheelEvent& event )
{
return false;
}
/**
* @brief Ensure the relayout data is allocated
*/
- void EnsureRelayoutData() const;
+ void EnsureRelayoutData();
/**
* @brief Apply the size set policy to the input size
*/
Vector2 ApplySizeSetPolicy( const Vector2 size );
+ /**
+ * Retrieve the parent object of an Actor.
+ * @return The parent object, or NULL if the Actor does not have a parent.
+ */
+ virtual Object* GetParentObject() const;
+
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
+ RendererContainer* mRenderers; ///< Renderer container
+
const SceneGraph::Node* mNode; ///< Not owned
Vector3* mParentOrigin; ///< NULL means ParentOrigin::DEFAULT. ParentOrigin is non-animatable
Vector3* mAnchorPoint; ///< NULL means AnchorPoint::DEFAULT. AnchorPoint is non-animatable
struct RelayoutData;
- mutable RelayoutData* mRelayoutData; ///< Struct to hold optional collection of relayout variables
-
-#ifdef DYNAMICS_SUPPORT
- DynamicsData* mDynamicsData; ///< optional physics data
-#endif
+ RelayoutData* mRelayoutData; ///< Struct to hold optional collection of relayout variables
ActorGestureData* mGestureData; ///< Optional Gesture data. Only created when actor requires gestures
- ActorAttachmentPtr mAttachment; ///< Optional referenced attachment
-
// Signals
Dali::Actor::TouchSignalType mTouchedSignal;
Dali::Actor::HoverSignalType mHoveredSignal;
- Dali::Actor::MouseWheelEventSignalType mMouseWheelEventSignal;
+ Dali::Actor::WheelEventSignalType mWheelEventSignal;
Dali::Actor::OnStageSignalType mOnStageSignal;
Dali::Actor::OffStageSignalType mOffStageSignal;
Dali::Actor::OnRelayoutSignalType mOnRelayoutSignal;
std::string mName; ///< Name of the actor
unsigned int mId; ///< A unique ID to identify the actor starting from 1, and 0 is reserved
+ unsigned short mDepth :12; ///< Cached: The depth in the hierarchy of the actor. Only 4096 levels of depth are supported
const bool mIsRoot : 1; ///< Flag to identify the root actor
- const bool mIsRenderable : 1; ///< Flag to identify that this is a renderable actor
const bool mIsLayer : 1; ///< Flag to identify that this is a layer
bool mIsOnStage : 1; ///< Flag to identify whether the actor is on-stage
- bool mIsDynamicsRoot : 1; ///< Flag to identify if this is the dynamics world root
bool mSensitive : 1; ///< Whether the actor emits touch event signals
bool mLeaveRequired : 1; ///< Whether a touch event signal is emitted when the a touch leaves the actor's bounds
bool mKeyboardFocusable : 1; ///< Whether the actor should be focusable by keyboard navigation
bool mDerivedRequiresTouch : 1; ///< Whether the derived actor type requires touch event signals
bool mDerivedRequiresHover : 1; ///< Whether the derived actor type requires hover event signals
- bool mDerivedRequiresMouseWheelEvent : 1; ///< Whether the derived actor type requires mouse wheel event signals
+ bool mDerivedRequiresWheelEvent : 1; ///< Whether the derived actor type requires wheel event signals
bool mOnStageSignalled : 1; ///< Set to true before OnStageConnection signal is emitted, and false before OnStageDisconnection
+ bool mInsideOnSizeSet : 1; ///< Whether we are inside OnSizeSet
+ bool mInheritPosition : 1; ///< Cached: Whether the parent's position should be inherited.
bool mInheritOrientation : 1; ///< Cached: Whether the parent's orientation should be inherited.
bool mInheritScale : 1; ///< Cached: Whether the parent's scale should be inherited.
DrawMode::Type mDrawMode : 2; ///< Cached: How the actor and its children should be drawn