#define DALI_INTERNAL_ACTOR_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <dali/public-api/math/viewport.h>
#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/size-negotiation/relayout-container.h>
+#include <dali/internal/common/internal-constants.h>
#include <dali/internal/common/memory-pool-object-allocator.h>
#include <dali/internal/event/actors/actor-declarations.h>
#include <dali/internal/event/common/object-impl.h>
namespace Dali
{
-struct KeyEvent;
+class KeyEvent;
class TouchData;
-struct HoverEvent;
-struct WheelEvent;
+class TouchEvent;
+class WheelEvent;
namespace Internal
{
class Animation;
class RenderTask;
class Renderer;
+class Scene;
-typedef std::vector< ActorPtr > ActorContainer;
-typedef ActorContainer::iterator ActorIter;
-typedef ActorContainer::const_iterator ActorConstIter;
+using ActorContainer = std::vector<ActorPtr>;
+using ActorIter = ActorContainer::iterator;
+using ActorConstIter = ActorContainer::const_iterator;
-typedef std::vector< RendererPtr > RendererContainer;
-typedef RendererContainer::iterator RendererIter;
+using RendererContainer = std::vector<RendererPtr>;
+using RendererIter = RendererContainer::iterator;
class ActorDepthTreeNode;
-typedef Dali::Internal::MemoryPoolObjectAllocator< ActorDepthTreeNode > DepthNodeMemoryPool;
+using DepthNodeMemoryPool = Dali::Internal::MemoryPoolObjectAllocator<ActorDepthTreeNode>;
/**
* Actor is the primary object which Dali applications interact with.
Dimension::Type dimension; ///< The dimension to hold
};
- typedef std::vector< ActorDimensionPair > ActorDimensionStack;
+ using ActorDimensionStack = std::vector<ActorDimensionPair>;
public:
* Retrieve the name of the actor.
* @return The name.
*/
- const std::string& GetName() const;
+ const std::string& GetName() const
+ {
+ return mName;
+ }
/**
* Set the name of the actor.
}
/**
- * Query whether the actor is connected to the Stage.
+ * Query whether the actor is connected to the Scene.
*/
- bool OnStage() const;
+ bool OnScene() const
+ {
+ return mIsOnScene;
+ }
/**
* Query whether the actor has any renderers.
}
/**
+ * Calculates screen position and size.
+ *
+ * @return pair of two values, position of top-left corner on screen and size respectively.
+ */
+ Rect<> CalculateScreenExtents( ) const;
+
+ /**
* Sets the size of an actor.
* This does not interfere with the actors scale factor.
* @param [in] width The new width.
void SetParentOrigin( const Vector3& origin );
/**
- * Set the x component of the parent-origin
- * @param [in] x The new x value.
- */
- void SetParentOriginX( float x );
-
- /**
- * Set the y component of the parent-origin
- * @param [in] y The new y value.
- */
- void SetParentOriginY( float y );
-
- /**
- * Set the z component of the parent-origin
- * @param [in] z The new z value.
- */
- void SetParentOriginZ( float z );
-
- /**
* Retrieve the parent-origin of an actor.
* @return The parent-origin.
*/
void SetAnchorPoint( const Vector3& anchorPoint );
/**
- * Set the x component of the anchor-point.
- * @param [in] x The new x value.
- */
- void SetAnchorPointX( float x );
-
- /**
- * Set the y component of the anchor-point.
- * @param [in] y The new y value.
- */
- void SetAnchorPointY( float y );
-
- /**
- * Set the z component of the anchor-point.
- * @param [in] z The new z value.
- */
- void SetAnchorPointZ( float z );
-
- /**
* Retrieve the anchor-point of an actor.
* @return The anchor-point.
*/
* The coordinates are relative to the Actor's parent.
* @return the Actor's position.
*/
- const Vector3& GetTargetPosition() const;
+ const Vector3& GetTargetPosition() const
+ {
+ return mTargetPosition;
+ }
/**
* @copydoc Dali::Actor::GetCurrentWorldPosition()
/**
* @copydoc Dali::Actor::IsPositionInherited()
*/
- bool IsPositionInherited() const;
+ bool IsPositionInherited() const
+ {
+ return mInheritPosition;
+ }
/**
* Sets the orientation of the Actor.
* 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 IsOrientationInherited() const;
+ bool IsOrientationInherited() const
+ {
+ return mInheritOrientation;
+ }
/**
* Sets the factor of the parents size used for the child actor.
/**
* @copydoc Dali::Actor::IsScaleInherited()
*/
- bool IsScaleInherited() const;
+ bool IsScaleInherited() const
+ {
+ return mInheritScale;
+ }
/**
* @copydoc Dali::Actor::GetCurrentWorldMatrix()
* Retrieve the actor's clipping mode.
* @return The actor's clipping mode (cached)
*/
- ClippingMode::Type GetClippingMode() const;
+ ClippingMode::Type GetClippingMode() const
+ {
+ return mClippingMode;
+ }
/**
* Sets whether an actor should emit touch or hover signals; see SignalTouch() and SignalHover().
/**
* @copydoc Dali::Actor::GetDrawMode
*/
- DrawMode::Type GetDrawMode() const;
+ DrawMode::Type GetDrawMode() const
+ {
+ return mDrawMode;
+ }
/**
* @copydoc Dali::Actor::IsOverlay
*/
- bool IsOverlay() const;
+ bool IsOverlay() const
+ {
+ return ( DrawMode::OVERLAY_2D == mDrawMode );
+ }
/**
* Sets the actor's color. The final color of actor depends on its color mode.
* Returns the actor's color mode.
* @return currently used colorMode.
*/
- ColorMode GetColorMode() const;
+ ColorMode GetColorMode() const
+ {
+ return mColorMode;
+ }
/**
* @copydoc Dali::Actor::GetCurrentWorldColor()
*/
inline int32_t GetHierarchyDepth() const
{
- if( mIsOnStage )
+ if( mIsOnScene )
{
return mDepth;
}
*
* @return The depth used for hit-testing and renderer sorting
*/
- uint32_t GetSortingDepth();
+ uint32_t GetSortingDepth()
+ {
+ return mSortedDepth;
+ }
public:
*
* @param dimension The dimension that is about to be calculated
*/
- virtual void OnCalculateRelayoutSize( Dimension::Type dimension );
+ virtual void OnCalculateRelayoutSize( Dimension::Type dimension ) {}
/**
* @brief Virtual method to notify deriving classes that the size for a dimension
* @param[in] size The new size for the given dimension
* @param[in] dimension The dimension that was just negotiated
*/
- virtual void OnLayoutNegotiated( float size, Dimension::Type dimension );
+ virtual void OnLayoutNegotiated( float size, Dimension::Type dimension ) {}
/**
* @brief Determine if this actor is dependent on it's children for relayout
/**
* @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(),
+ * This method is automatically called from OnSceneConnection(), OnChildAdd(),
* OnChildRemove(), SetSizePolicy(), SetMinimumSize() and SetMaximumSize().
*
* This method can also be called from a derived class every time it needs a different size.
float CalculateSize( Dimension::Type dimension, const Vector2& maximumSize );
/**
- * @brief Clamp a dimension given the relayout constraints on this actor
- *
- * @param[in] size The size to constrain
- * @param[in] dimension The dimension the size exists in
- * @return Return the clamped size
- */
- float ClampDimension( float size, Dimension::Type dimension );
-
- /**
* Negotiate a dimension based on the size of the parent
*
* @param[in] dimension The dimension to negotiate on
float screenY ) const;
/**
- * Performs a ray-sphere test with the given pick-ray and the actor's bounding sphere.
- * @note The actor coordinates are relative to the top-left (0.0, 0.0, 0.5)
- * @param[in] rayOrigin The ray origin in the world's reference system.
- * @param[in] rayDir The ray director vector in the world's reference system.
- * @return True if the ray intersects the actor's bounding sphere.
- */
- bool RaySphereTest( const Vector4& rayOrigin, const Vector4& rayDir ) const;
-
- /**
- * Performs a ray-actor test with the given pick-ray and the actor's geometry.
- * @note The actor coordinates are relative to the top-left (0.0, 0.0, 0.5)
- * @param[in] rayOrigin The ray origin in the world's reference system.
- * @param[in] rayDir The ray director vector in the world's reference system.
- * @param[out] hitPointLocal The hit point in the Actor's local reference system.
- * @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,
- Vector2& hitPointLocal,
- float& distance ) const;
-
- /**
* Sets whether the actor should receive a notification when touch or hover motion events leave
* the boundary of the actor.
*
*
* @param[in] required Should be set to true if a Leave event is required
*/
- void SetLeaveRequired( bool required );
+ void SetLeaveRequired( bool required )
+ {
+ mLeaveRequired = required;
+ }
/**
* 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.
*/
- bool GetLeaveRequired() const;
+ bool GetLeaveRequired() const
+ {
+ return mLeaveRequired;
+ }
/**
* @copydoc Dali::Actor::SetKeyboardFocusable()
*/
- void SetKeyboardFocusable( bool focusable );
+ void SetKeyboardFocusable( bool focusable )
+ {
+ mKeyboardFocusable = focusable;
+ }
/**
* @copydoc Dali::Actor::IsKeyboardFocusable()
*/
- bool IsKeyboardFocusable() const;
+ bool IsKeyboardFocusable() const
+ {
+ return mKeyboardFocusable;
+ }
+
+
+ /**
+ * Query whether the application or derived actor type requires intercept touch events.
+ * @return True if intercept touch events are required.
+ */
+ bool GetInterceptTouchRequired() const
+ {
+ return !mInterceptTouchedSignal.Empty();
+ }
/**
* Query whether the application or derived actor type requires touch events.
* @return True if touch events are required.
*/
- bool GetTouchRequired() const;
+ bool GetTouchRequired() const
+ {
+ return !mTouchedSignal.Empty();
+ }
/**
* Query whether the application or derived actor type requires hover events.
* @return True if hover events are required.
*/
- bool GetHoverRequired() const;
+ bool GetHoverRequired() const
+ {
+ return !mHoveredSignal.Empty();
+ }
/**
* Query whether the application or derived actor type requires wheel events.
* @return True if wheel events are required.
*/
- bool GetWheelEventRequired() const;
+ bool GetWheelEventRequired() const
+ {
+ return !mWheelEventSignal.Empty();
+ }
/**
* Query whether the actor is actually hittable. This method checks whether the actor is
* sensitive, has the visibility flag set to true and is not fully transparent.
* @return true, if it can be hit, false otherwise.
*/
- bool IsHittable() const;
+ bool IsHittable() const
+ {
+ return IsSensitive() && IsVisible() && ( GetCurrentWorldColor().a > FULLY_TRANSPARENT ) && IsNodeConnected();
+ }
+
+ /**
+ * Query whether the actor captures all touch after it starts even if touch leaves its boundary.
+ * @return true, if it captures all touch after start
+ */
+ bool CapturesAllTouchAfterStart() const
+ {
+ return mCaptureAllTouchAfterStart;
+ }
+
+ /**
+ * Sets the touch delegate area of an actor.
+ * @param [in] area The new area.
+ */
+ void SetTouchDelegateArea(Vector2 area)
+ {
+ mTouchDelegateArea = area;
+ }
+
+ /**
+ * Retrieve the Actor's touch delegate area.
+ * @return The Actor's touch delegate area.
+ */
+ const Vector2& GetTouchDelegateArea() const
+ {
+ return mTouchDelegateArea;
+ }
+
// Gestures
/**
* Queries whether the actor requires the gesture type.
* @param[in] type The gesture type.
+ * @return True if the gesture is required, false otherwise.
*/
- bool IsGestureRequred( Gesture::Type type ) const;
+ bool IsGestureRequired( GestureType::Value type ) const;
// Signals
/**
+ * Used by the EventProcessor to emit intercept touch event signals.
+ * @param[in] touch The touch data.
+ * @return True if the event was intercepted.
+ */
+ bool EmitInterceptTouchEventSignal( const Dali::TouchEvent& touch );
+
+ /**
* Used by the EventProcessor to emit touch event signals.
- * @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, const Dali::TouchData& touch );
+ bool EmitTouchEventSignal( const Dali::TouchEvent& touch );
/**
* Used by the EventProcessor to emit hover event signals.
* @param[in] event The hover event.
* @return True if the event was consumed.
*/
- bool EmitHoverEventSignal( const HoverEvent& event );
+ bool EmitHoverEventSignal( const Dali::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 );
+ bool EmitWheelEventSignal( const Dali::WheelEvent& event );
/**
* @brief Emits the visibility change signal for this actor and all its children.
void EmitChildRemovedSignal( Actor& child );
/**
- * @copydoc Dali::Actor::TouchedSignal()
+ * @copydoc DevelActor::InterceptTouchedSignal()
*/
- Dali::Actor::TouchSignalType& TouchedSignal();
+ Dali::Actor::TouchEventSignalType& InterceptTouchedSignal()
+ {
+ return mInterceptTouchedSignal;
+ }
/**
- * @copydoc Dali::Actor::TouchEventSignal()
+ * @copydoc Dali::Actor::TouchedSignal()
*/
- Dali::Actor::TouchDataSignalType& TouchSignal();
+ Dali::Actor::TouchEventSignalType& TouchedSignal()
+ {
+ return mTouchedSignal;
+ }
/**
* @copydoc Dali::Actor::HoveredSignal()
*/
- Dali::Actor::HoverSignalType& HoveredSignal();
+ Dali::Actor::HoverSignalType& HoveredSignal()
+ {
+ return mHoveredSignal;
+ }
/**
* @copydoc Dali::Actor::WheelEventSignal()
*/
- Dali::Actor::WheelEventSignalType& WheelEventSignal();
+ Dali::Actor::WheelEventSignalType& WheelEventSignal()
+ {
+ return mWheelEventSignal;
+ }
/**
- * @copydoc Dali::Actor::OnStageSignal()
+ * @copydoc Dali::Actor::OnSceneSignal()
*/
- Dali::Actor::OnStageSignalType& OnStageSignal();
+ Dali::Actor::OnSceneSignalType& OnSceneSignal()
+ {
+ return mOnSceneSignal;
+ }
/**
- * @copydoc Dali::Actor::OffStageSignal()
+ * @copydoc Dali::Actor::OffSceneSignal()
*/
- Dali::Actor::OffStageSignalType& OffStageSignal();
+ Dali::Actor::OffSceneSignalType& OffSceneSignal()
+ {
+ return mOffSceneSignal;
+ }
/**
* @copydoc Dali::Actor::OnRelayoutSignal()
*/
- Dali::Actor::OnRelayoutSignalType& OnRelayoutSignal();
+ Dali::Actor::OnRelayoutSignalType& OnRelayoutSignal()
+ {
+ return mOnRelayoutSignal;
+ }
/**
* @copydoc DevelActor::VisibilityChangedSignal
*/
- DevelActor::VisibilityChangedSignalType& VisibilityChangedSignal();
+ DevelActor::VisibilityChangedSignalType& VisibilityChangedSignal()
+ {
+ return mVisibilityChangedSignal;
+ }
/**
* @copydoc LayoutDirectionChangedSignal
*/
- Dali::Actor::LayoutDirectionChangedSignalType& LayoutDirectionChangedSignal();
+ Dali::Actor::LayoutDirectionChangedSignalType& LayoutDirectionChangedSignal()
+ {
+ return mLayoutDirectionChangedSignal;
+ }
/**
* @copydoc DevelActor::ChildAddedSignal
*/
- DevelActor::ChildChangedSignalType& ChildAddedSignal();
+ DevelActor::ChildChangedSignalType& ChildAddedSignal()
+ {
+ return mChildAddedSignal;
+ }
/**
* @copydoc DevelActor::ChildRemovedSignal
*/
- DevelActor::ChildChangedSignalType& ChildRemovedSignal();
+ DevelActor::ChildChangedSignalType& ChildRemovedSignal()
+ {
+ return mChildRemovedSignal;
+ }
/**
* @copydoc DevelActor::ChildOrderChangedSignal
*/
- DevelActor::ChildOrderChangedSignalType& ChildOrderChangedSignal();
+ DevelActor::ChildOrderChangedSignalType& ChildOrderChangedSignal()
+ {
+ return mChildOrderChangedSignal;
+ }
/**
* Connects a callback function with the object's signals.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Actor();
+ ~Actor() override;
/**
- * Called on a child during Add() when the parent actor is connected to the Stage.
+ * Called on a child during Add() when the parent actor is connected to the Scene.
* @param[in] parentDepth The depth of the parent in the hierarchy.
*/
- void ConnectToStage( uint32_t parentDepth );
+ void ConnectToScene( uint32_t parentDepth );
/**
- * Helper for ConnectToStage, to recursively connect a tree of actors.
+ * Helper for ConnectToScene, to recursively connect a tree of actors.
* This is atomic i.e. not interrupted by user callbacks.
* @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, uint32_t depth );
+ void RecursiveConnectToScene( ActorContainer& connectionList, uint32_t depth );
/**
* Connect the Node associated with this Actor to the scene-graph.
void ConnectToSceneGraph();
/**
- * Helper for ConnectToStage, to notify a connected actor through the public API.
+ * Helper for ConnectToScene, to notify a connected actor through the public API.
*/
void NotifyStageConnection();
void NotifyStageDisconnection();
/**
- * When the Actor is OnStage, checks whether the corresponding Node is connected to the scene graph.
- * @return True if the Actor is OnStage & has a Node connected to the scene graph.
+ * When the Actor is OnScene, checks whether the corresponding Node is connected to the scene graph.
+ * @return True if the Actor is OnScene & has a Node connected to the scene graph.
*/
bool IsNodeConnected() const;
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue );
+ void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) override;
/**
* @copydoc Dali::Internal::Object::SetSceneGraphProperty()
*/
- virtual void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value );
+ void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value ) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
*/
- virtual void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType );
+ void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType ) override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
*/
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+ const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
*/
- virtual int32_t GetPropertyComponentIndex( Property::Index index ) const;
+ int32_t GetPropertyComponentIndex( Property::Index index ) const override;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsAnimationPossible()
+ */
+ bool IsAnimationPossible() const override
+ {
+ return OnScene();
+ }
/**
* Retrieve the actor's node.
*/
void LowerBelow( Internal::Actor& target );
+public:
+
+ /**
+ * Sets the scene which this actor is added to.
+ * @param[in] scene The scene
+ */
+ void SetScene( Scene& scene )
+ {
+ mScene = &scene;
+ }
+
+ /**
+ * Gets the scene which this actor is added to.
+ * @return The scene
+ */
+ Scene& GetScene() const
+ {
+ return *mScene;
+ }
+
private:
struct SendMessage
};
};
+ struct AnimatedSizeFlag
+ {
+ enum Type
+ {
+ CLEAR = 0,
+ WIDTH = 1,
+ HEIGHT = 2,
+ DEPTH = 4
+ };
+ };
+
+ struct Relayouter;
+
// Remove default constructor and copy constructor
Actor() = delete;
Actor( const Actor& ) = delete;
/**
* For use in internal derived classes.
- * This is called during ConnectToStage(), after the actor has finished adding its node to the scene-graph.
+ * This is called during ConnectToScene(), 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 OnSceneConnectionInternal()
{
}
* 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 OnSceneDisconnectionInternal()
{
}
/**
* For use in external (CustomActor) derived classes.
- * This is called after the atomic ConnectToStage() traversal has been completed.
+ * This is called after the atomic ConnectToScene() traversal has been completed.
*/
- virtual void OnStageConnectionExternal( int depth )
+ virtual void OnSceneConnectionExternal( 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 OnSceneDisconnectionExternal()
{
}
}
/**
- * For use in derived classes.
- * 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 bool OnTouchEvent( const TouchEvent& event )
- {
- return false;
- }
-
- /**
- * For use in derived classes.
- * 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 OnHoverEvent( const HoverEvent& event )
- {
- return false;
- }
-
- /**
- * For use in derived classes.
- * 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 OnWheelEvent( const WheelEvent& event )
- {
- return false;
- }
-
- /**
* @brief Retrieves the cached event side value of a default property.
* @param[in] index The index of the property
* @param[out] value Is set with the cached value of the property if found.
bool GetCurrentPropertyValue( Property::Index index, Property::Value& value ) const;
/**
- * @brief Ensure the relayout data is allocated
+ * @brief Ensure the relayouter is allocated
*/
- void EnsureRelayoutData();
+ Relayouter& EnsureRelayouter();
/**
* @brief Apply the size set policy to the input 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;
+ Object* GetParentObject() const override
+ {
+ return mParent;
+ }
/**
* Set Sibling order
* Returns whether the actor inherits it's parent's layout direction.
* @return true if the actor inherits it's parent's layout direction, false otherwise.
*/
- bool IsLayoutDirectionInherited() const;
+ bool IsLayoutDirectionInherited() const
+ {
+ return mInheritLayoutDirection;
+ }
/**
* @brief Propagates layout direction recursively.
*/
void InheritLayoutDirectionRecursively( ActorPtr actor, Dali::LayoutDirection::Type direction, bool set = false );
+ /**
+ * @brief Sets the update size hint of an actor.
+ * @param [in] updateSizeHint The update size hint.
+ */
+ void SetUpdateSizeHint( const Vector2& updateSizeHint );
+
protected:
+ Scene* mScene; ///< The scene the actor is added to
+
Actor* mParent; ///< Each actor (except the root) can have one parent
ActorContainer* mChildren; ///< Container of referenced actors, lazily initialized
RendererContainer* mRenderers; ///< Renderer container
Vector3* mParentOrigin; ///< NULL means ParentOrigin::DEFAULT. ParentOrigin is non-animatable
Vector3* mAnchorPoint; ///< NULL means AnchorPoint::DEFAULT. AnchorPoint is non-animatable
- struct RelayoutData;
- RelayoutData* mRelayoutData; ///< Struct to hold optional collection of relayout variables
+ Relayouter* mRelayoutData; ///< Struct to hold optional collection of relayout variables
ActorGestureData* mGestureData; ///< Optional Gesture data. Only created when actor requires gestures
// Signals
- Dali::Actor::TouchSignalType mTouchedSignal;
- Dali::Actor::TouchDataSignalType mTouchSignal;
+ Dali::Actor::TouchEventSignalType mInterceptTouchedSignal;
+ Dali::Actor::TouchEventSignalType mTouchedSignal;
Dali::Actor::HoverSignalType mHoveredSignal;
Dali::Actor::WheelEventSignalType mWheelEventSignal;
- Dali::Actor::OnStageSignalType mOnStageSignal;
- Dali::Actor::OffStageSignalType mOffStageSignal;
+ Dali::Actor::OnSceneSignalType mOnSceneSignal;
+ Dali::Actor::OffSceneSignalType mOffSceneSignal;
Dali::Actor::OnRelayoutSignalType mOnRelayoutSignal;
DevelActor::VisibilityChangedSignalType mVisibilityChangedSignal;
Dali::Actor::LayoutDirectionChangedSignalType mLayoutDirectionChangedSignal;
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
+ Vector3 mAnimatedSize; ///< Event-side storage for size animation
+ Vector2 mTouchDelegateArea; ///< touch delegate area
std::string mName; ///< Name of the actor
uint32_t mSortedDepth; ///< The sorted depth index. A combination of tree traversal and sibling order.
int16_t mDepth; ///< The depth in the hierarchy of the actor. Only 32,767 levels of depth are supported
+ uint16_t mUseAnimatedSize; ///< Whether the size is animated.
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 mIsOnScene : 1; ///< Flag to identify whether the actor is on-scene
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 mOnSceneSignalled : 1; ///< Set to true before OnSceneConnection signal is emitted, and false before OnSceneDisconnection
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 mPositionUsesAnchorPoint : 1; ///< Cached: Whether the position uses the anchor point or not.
bool mVisible : 1; ///< Cached: Whether the actor is visible or not.
bool mInheritLayoutDirection : 1; ///< Whether the actor inherits the layout direction from parent.
+ bool mCaptureAllTouchAfterStart : 1; ///< Whether the actor should capture all touch after touch starts even if the motion moves outside of the actor area.
LayoutDirection::Type mLayoutDirection : 2; ///< Layout direction, Left to Right or Right to Left.
DrawMode::Type mDrawMode : 3; ///< Cached: How the actor and its children should be drawn
ColorMode mColorMode : 3; ///< Cached: Determines whether mWorldColor is inherited
static ActorContainer mNullChildren; ///< Empty container (shared by all actors, returned by GetChildren() const)
+ struct PropertyHandler;
};
} // namespace Internal
projects / platform / core / uifw / dali-core.git / blobdiff