X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Factors%2Factor-impl.h;h=1d37366cea379deb9ecfba1621226118c5f8d04d;hb=4d75040ab200bd306ec5a48f2a617480062eef4c;hp=1ff3035b9438510e97969e168783f6929f827d08;hpb=deb43a837c49c7f514816ea189ba661eae251a76;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 old mode 100644 new mode 100755 index 1ff3035..d09585e --- a/dali/internal/event/actors/actor-impl.h +++ b/dali/internal/event/actors/actor-impl.h @@ -1,8 +1,8 @@ -#ifndef __DALI_INTERNAL_ACTOR_H__ -#define __DALI_INTERNAL_ACTOR_H__ +#ifndef DALI_INTERNAL_ACTOR_H +#define DALI_INTERNAL_ACTOR_H /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2018 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. @@ -23,24 +23,26 @@ // INTERNAL INCLUDES #include +#include #include #include #include #include #include #include +#include #include -#include #include #include #include #include +#include namespace Dali { struct KeyEvent; -struct TouchEvent; +class TouchData; struct HoverEvent; struct WheelEvent; @@ -60,14 +62,17 @@ 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. * 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 @@ -133,21 +138,6 @@ public: */ 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 /** @@ -226,6 +216,7 @@ public: * 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() { @@ -253,7 +244,6 @@ 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. @@ -262,7 +252,6 @@ 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 size of the actor along the x-axis. * @param [in] height The size of the actor along the y-axis. @@ -272,7 +261,6 @@ 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] size The new size. */ @@ -287,7 +275,6 @@ 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] size The new size. */ @@ -323,7 +310,7 @@ public: * This size will be the size set or if animating then the target size. * @return The Actor's size. */ - const Vector3& GetTargetSize() const; + Vector3 GetTargetSize() const; /** * Retrieve the Actor's size from update side. @@ -633,7 +620,7 @@ 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 ); @@ -656,6 +643,12 @@ public: float GetCurrentOpacity() const; /** + * Retrieve the actor's clipping mode. + * @return The actor's clipping mode (cached) + */ + ClippingMode::Type GetClippingMode() const; + + /** * Sets whether an actor should emit touch or hover signals; see SignalTouch() and SignalHover(). * An actor is sensitive by default, which means that as soon as an application connects to the SignalTouch(), * the touch event signal will be emitted, and as soon as an application connects to the SignalHover(), the @@ -701,11 +694,6 @@ public: DrawMode::Type GetDrawMode() const; /** - * @copydoc Dali::Actor::SetOverlay - */ - void SetOverlay( bool enable ); - - /** * @copydoc Dali::Actor::IsOverlay */ bool IsOverlay() const; @@ -762,7 +750,7 @@ public: /** * @copydoc Dali::Actor::GetHierarchyDepth() */ - int GetHierarchyDepth() const + inline int GetHierarchyDepth() const { if( mIsOnStage ) { @@ -772,6 +760,13 @@ public: return -1; } + /** + * Get the actor's sorting depth + * + * @return The depth used for hit-testing and renderer sorting + */ + unsigned int GetSortingDepth(); + public: // Size negotiation virtual functions @@ -887,6 +882,24 @@ public: 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 ); @@ -1300,7 +1313,7 @@ public: */ bool RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, - Vector4& hitPointLocal, + Vector2& hitPointLocal, float& distance ) const; /** @@ -1378,10 +1391,11 @@ public: /** * Used by the EventProcessor to emit touch event signals. - * @param[in] event The touch event. + * @param[in] event The touch event (Old API). + * @param[in] touch The touch data. * @return True if the event was consumed. */ - bool EmitTouchEventSignal( const TouchEvent& event ); + bool EmitTouchEventSignal( const TouchEvent& event, const Dali::TouchData& touch ); /** * Used by the EventProcessor to emit hover event signals. @@ -1398,11 +1412,41 @@ public: 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 ); + + /** + * @brief Emits the layout direction change signal for this actor and all its children. + * @param[in] type Whether the actor's layout direction property has changed or a parent's. + */ + void EmitLayoutDirectionChangedSignal( LayoutDirection::Type type ); + + /** + * @brief Emits the ChildAdded signal for this actor + * @param[in] child The child actor that has been added + */ + void EmitChildAddedSignal( Actor& child ); + + /** + * @brief Emits the ChildRemoved signal for this actor + * @param[in] child The child actor that has been removed + */ + void EmitChildRemovedSignal( Actor& child ); + + /** * @copydoc Dali::Actor::TouchedSignal() */ Dali::Actor::TouchSignalType& TouchedSignal(); /** + * @copydoc Dali::Actor::TouchEventSignal() + */ + Dali::Actor::TouchDataSignalType& TouchSignal(); + + /** * @copydoc Dali::Actor::HoveredSignal() */ Dali::Actor::HoverSignalType& HoveredSignal(); @@ -1428,6 +1472,31 @@ public: Dali::Actor::OnRelayoutSignalType& OnRelayoutSignal(); /** + * @copydoc DevelActor::VisibilityChangedSignal + */ + DevelActor::VisibilityChangedSignalType& VisibilityChangedSignal(); + + /** + * @copydoc LayoutDirectionChangedSignal + */ + Dali::Actor::LayoutDirectionChangedSignalType& LayoutDirectionChangedSignal(); + + /** + * @copydoc DevelActor::ChildAddedSignal + */ + DevelActor::ChildChangedSignalType& ChildAddedSignal(); + + /** + * @copydoc DevelActor::ChildRemovedSignal + */ + DevelActor::ChildChangedSignalType& ChildRemovedSignal(); + + /** + * @copydoc DevelActor::ChildOrderChangedSignal + */ + DevelActor::ChildOrderChangedSignalType& ChildOrderChangedSignal(); + + /** * Connects a callback function with the object's signals. * @param[in] object The object providing the signal. * @param[in] tracker Used to disconnect the signal. @@ -1456,23 +1525,6 @@ public: // For Animation /** - * This should only be called by Animation, when the actors SIZE property is animated. - * - * @param[in] animation The animation that resized the actor - * @param[in] targetSize The new target size of the actor - */ - void NotifySizeAnimation( Animation& animation, const Vector3& targetSize ); - - /** - * This should only be called by Animation, when the actors SIZE_WIDTH or SIZE_HEIGHT 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(). */ @@ -1480,23 +1532,6 @@ public: { } - /** - * 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 @@ -1574,6 +1609,22 @@ protected: bool IsNodeConnected() const; 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: + /** + * Traverse the actor tree, inserting actors into the depth tree in sibling order. + * @param[in] sceneGraphNodeDepths A vector capturing the nodes and their depth index + * @param[in,out] depthIndex The current depth index (traversal index) + */ + void DepthTraverseActorTree( OwnerPointer& sceneGraphNodeDepths, int& depthIndex ); + +public: // Default property extensions from Object @@ -1633,6 +1684,16 @@ public: virtual Property::Value GetDefaultProperty( Property::Index index ) const; /** + * @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, Animation::Type animationType ); + + /** * @copydoc Dali::Internal::Object::GetPropertyOwner() */ virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const; @@ -1657,13 +1718,50 @@ public: */ 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: - // Undefined - Actor(); + struct SendMessage + { + enum Type + { + FALSE = 0, + TRUE = 1, + }; + }; - // Undefined - Actor( const Actor& ); + // Remove default constructor and copy constructor + Actor()=delete; + Actor( const Actor& )=delete; // Undefined Actor& operator=( const Actor& rhs ); @@ -1731,7 +1829,7 @@ private: } /** - * 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 ) @@ -1780,6 +1878,22 @@ private: } /** + * @brief Retrieves the cached event side value of a default property. + * @param[in] index The index of the property + * @param[out] value Is set with the cached value of the property if found. + * @return True if value set, false otherwise. + */ + bool GetCachedPropertyValue( Property::Index index, Property::Value& value ) const; + + /** + * @brief Retrieves the current value of a default property from the scene-graph. + * @param[in] index The index of the property + * @param[out] value Is set with the current scene-graph value of the property + * @return True if value set, false otherwise. + */ + bool GetCurrentPropertyValue( Property::Index index, Property::Value& value ) const; + + /** * @brief Ensure the relayout data is allocated */ void EnsureRelayoutData(); @@ -1790,12 +1904,69 @@ private: * @param[in] size The size to apply the policy to * @return Return the adjusted size */ - Vector2 ApplySizeSetPolicy( const Vector2 size ); + Vector2 ApplySizeSetPolicy( const Vector2& size ); + + /** + * Retrieve the parent object of an Actor. + * @return The parent object, or NULL if the Actor does not have a parent. + */ + virtual Object* GetParentObject() const; + + /** + * Set Sibling order + * @param[in] order The sibling order this Actor should be. It will place + * the actor at this index in it's parent's child array. + */ + void SetSiblingOrder( unsigned int order); + + /** + * Get Sibling order + * @return the order of this actor amongst it's siblings + */ + unsigned int GetSiblingOrder() const; + + /** + * Request that the stage rebuilds the actor depth indices. + */ + void RequestRebuildDepthTree(); + + /** + * @brief Get the current position of the actor in screen coordinates. + * + * @return Returns the screen position of actor + */ + const Vector2 GetCurrentScreenPosition() const; + + /** + * Sets the visibility flag of an actor. + * @param[in] visible The new visibility flag. + * @param[in] sendMessage Whether to send a message to the update thread or not. + */ + void SetVisibleInternal( bool visible, SendMessage::Type sendMessage ); + + /** + * Set whether a child actor inherits it's parent's layout direction. Default is to inherit. + * @param[in] inherit - true if the actor should inherit layout direction, false otherwise. + */ + void SetInheritLayoutDirection( bool inherit ); + + /** + * 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; + + /** + * @brief Propagates layout direction recursively. + * @param[in] actor The actor for seting layout direction. + * @param[in] direction New layout direction. + */ + void InheritLayoutDirectionRecursively( ActorPtr actor, Dali::LayoutDirection::Type direction, bool set = false ); protected: Actor* mParent; ///< Each actor (except the root) can have one parent - ActorContainer* mChildren; ///< Container of referenced actors + ActorContainer* mChildren; ///< Container of referenced actors, lazily initialized RendererContainer* mRenderers; ///< Renderer container const SceneGraph::Node* mNode; ///< Not owned @@ -1807,23 +1978,33 @@ protected: ActorGestureData* mGestureData; ///< Optional Gesture data. Only created when actor requires gestures - ActorAttachmentPtr mAttachment; ///< Optional referenced attachment - // Signals 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; - - 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) + DevelActor::VisibilityChangedSignalType mVisibilityChangedSignal; + Dali::Actor::LayoutDirectionChangedSignalType mLayoutDirectionChangedSignal; + DevelActor::ChildChangedSignalType mChildAddedSignal; + DevelActor::ChildChangedSignalType mChildRemovedSignal; + DevelActor::ChildOrderChangedSignalType mChildOrderChangedSignal; + + 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 - unsigned short mDepth :12; ///< Cached: The depth in the hierarchy of the actor. Only 4096 levels of depth are supported + 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 + + 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 @@ -1838,15 +2019,19 @@ protected: 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 - PositionInheritanceMode mPositionInheritanceMode : 2; ///< Cached: Determines how position is inherited - ColorMode mColorMode : 2; ///< Cached: Determines whether mWorldColor is 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. + 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 + PositionInheritanceMode mPositionInheritanceMode : 3; ///< Cached: Determines how position is inherited + ColorMode mColorMode : 3; ///< Cached: Determines whether mWorldColor is inherited + ClippingMode::Type mClippingMode : 3; ///< Cached: Determines which clipping mode (if any) to use. private: static ActorContainer mNullChildren; ///< Empty container (shared by all actors, returned by GetChildren() const) static unsigned int mActorCounter; ///< A counter to track the actor instance creation - }; } // namespace Internal @@ -1873,4 +2058,4 @@ inline const Internal::Actor& GetImplementation( const Dali::Actor& actor ) } // namespace Dali -#endif // __DALI_INTERNAL_ACTOR_H__ +#endif // DALI_INTERNAL_ACTOR_H