-#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 <string>
// INTERNAL INCLUDES
-#include <dali/public-api/common/map-wrapper.h>
-#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/devel-api/actors/actor-devel.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/proxy-object.h>
-#include <dali/internal/event/common/stage-def.h>
+#include <dali/public-api/object/ref-object.h>
+#include <dali/public-api/size-negotiation/relayout-container.h>
+#include <dali/internal/common/memory-pool-object-allocator.h>
#include <dali/internal/event/actors/actor-declarations.h>
-#include <dali/internal/event/actor-attachments/actor-attachment-declarations.h>
-#include <dali/internal/event/dynamics/dynamics-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>
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<Actor> ActorPtr;
-typedef IntrusivePtr<ShaderEffect> 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.
* 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.
*/
* 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
/**
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();
}
/**
* @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
/**
* @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()
{
/**
* @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.
/**
* 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.
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.
* 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
* 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.
* @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.
* @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.
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;
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.
* @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.
* 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.
/**
* 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.
* 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.
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
{
}
/**
- * 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<int>(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)
* @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.
* @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.
* @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.
*/
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
*/
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.
* @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.
* @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<Property::Value>& 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
};
/**
/**
* 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()
/**
* 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.
*/
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.
/**
* 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<std::string, Property::Index> 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<Actor*> 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<Internal::Actor&>(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<const Internal::Actor&>(handle);
+ return static_cast< const Internal::Actor& >( handle );
}
} // namespace Dali
-#endif // __DALI_INTERNAL_ACTOR_H__
+#endif // DALI_INTERNAL_ACTOR_H
projects / platform / core / uifw / dali-core.git / blobdiff