// EXTERNAL INCLUDES
#include <cmath>
#include <algorithm>
+#include <cfloat>
+#include <cstring> // for strcmp
// INTERNAL INCLUDES
#include <dali/public-api/scripting/scripting.h>
#include <dali/internal/common/internal-constants.h>
+#include <dali/internal/event/common/event-thread-services.h>
#include <dali/internal/event/render-tasks/render-task-impl.h>
#include <dali/internal/event/actors/camera-actor-impl.h>
#include <dali/internal/event/render-tasks/render-task-list-impl.h>
-#include <dali/internal/event/common/property-index-ranges.h>
+#include <dali/internal/event/common/property-helper.h>
#include <dali/internal/event/common/stage-impl.h>
+#include <dali/internal/event/common/type-info-impl.h>
#include <dali/internal/event/actor-attachments/actor-attachment-impl.h>
#include <dali/internal/event/animation/constraint-impl.h>
#include <dali/internal/event/common/projection.h>
+#include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
#include <dali/internal/update/common/animatable-property.h>
#include <dali/internal/update/nodes/node-messages.h>
#include <dali/internal/update/nodes/node-declarations.h>
namespace Dali
{
+namespace ResizePolicy
+{
-const Property::Index Actor::PARENT_ORIGIN = 0;
-const Property::Index Actor::PARENT_ORIGIN_X = 1;
-const Property::Index Actor::PARENT_ORIGIN_Y = 2;
-const Property::Index Actor::PARENT_ORIGIN_Z = 3;
-const Property::Index Actor::ANCHOR_POINT = 4;
-const Property::Index Actor::ANCHOR_POINT_X = 5;
-const Property::Index Actor::ANCHOR_POINT_Y = 6;
-const Property::Index Actor::ANCHOR_POINT_Z = 7;
-const Property::Index Actor::SIZE = 8;
-const Property::Index Actor::SIZE_WIDTH = 9;
-const Property::Index Actor::SIZE_HEIGHT = 10;
-const Property::Index Actor::SIZE_DEPTH = 11;
-const Property::Index Actor::POSITION = 12;
-const Property::Index Actor::POSITION_X = 13;
-const Property::Index Actor::POSITION_Y = 14;
-const Property::Index Actor::POSITION_Z = 15;
-const Property::Index Actor::WORLD_POSITION = 16;
-const Property::Index Actor::WORLD_POSITION_X = 17;
-const Property::Index Actor::WORLD_POSITION_Y = 18;
-const Property::Index Actor::WORLD_POSITION_Z = 19;
-const Property::Index Actor::ROTATION = 20;
-const Property::Index Actor::WORLD_ROTATION = 21;
-const Property::Index Actor::SCALE = 22;
-const Property::Index Actor::SCALE_X = 23;
-const Property::Index Actor::SCALE_Y = 24;
-const Property::Index Actor::SCALE_Z = 25;
-const Property::Index Actor::WORLD_SCALE = 26;
-const Property::Index Actor::VISIBLE = 27;
-const Property::Index Actor::COLOR = 28;
-const Property::Index Actor::COLOR_RED = 29;
-const Property::Index Actor::COLOR_GREEN = 30;
-const Property::Index Actor::COLOR_BLUE = 31;
-const Property::Index Actor::COLOR_ALPHA = 32;
-const Property::Index Actor::WORLD_COLOR = 33;
-const Property::Index Actor::WORLD_MATRIX = 34;
-const Property::Index Actor::NAME = 35;
-const Property::Index Actor::SENSITIVE = 36;
-const Property::Index Actor::LEAVE_REQUIRED = 37;
-const Property::Index Actor::INHERIT_ROTATION = 38;
-const Property::Index Actor::INHERIT_SCALE = 39;
-const Property::Index Actor::COLOR_MODE = 40;
-const Property::Index Actor::POSITION_INHERITANCE = 41;
-const Property::Index Actor::DRAW_MODE = 42;
-const Property::Index Actor::SIZE_MODE = 43;
-const Property::Index Actor::SIZE_MODE_FACTOR = 44;
-
-namespace // unnamed namespace
+namespace
{
+DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )DALI_ENUM_TO_STRING( FIXED )
+DALI_ENUM_TO_STRING( USE_NATURAL_SIZE )
+DALI_ENUM_TO_STRING( FILL_TO_PARENT )
+DALI_ENUM_TO_STRING( SIZE_RELATIVE_TO_PARENT )
+DALI_ENUM_TO_STRING( SIZE_FIXED_OFFSET_FROM_PARENT )
+DALI_ENUM_TO_STRING( FIT_TO_CHILDREN )
+DALI_ENUM_TO_STRING( DIMENSION_DEPENDENCY )
+DALI_ENUM_TO_STRING( USE_ASSIGNED_SIZE )
+DALI_ENUM_TO_STRING_TABLE_END( Type )
-/**
- * We want to discourage the use of property strings (minimize string comparisons),
- * particularly for the default properties.
- */
-const Internal::PropertyDetails DEFAULT_PROPERTY_DETAILS[] =
-{
- // Name Type writable animatable constraint-input
- { "parent-origin", Property::VECTOR3, true, false, true }, // PARENT_ORIGIN
- { "parent-origin-x", Property::FLOAT, true, false, true }, // PARENT_ORIGIN_X
- { "parent-origin-y", Property::FLOAT, true, false, true }, // PARENT_ORIGIN_Y
- { "parent-origin-z", Property::FLOAT, true, false, true }, // PARENT_ORIGIN_Z
- { "anchor-point", Property::VECTOR3, true, false, true }, // ANCHOR_POINT
- { "anchor-point-x", Property::FLOAT, true, false, true }, // ANCHOR_POINT_X
- { "anchor-point-y", Property::FLOAT, true, false, true }, // ANCHOR_POINT_Y
- { "anchor-point-z", Property::FLOAT, true, false, true }, // ANCHOR_POINT_Z
- { "size", Property::VECTOR3, true, true, true }, // SIZE
- { "size-width", Property::FLOAT, true, true, true }, // SIZE_WIDTH
- { "size-height", Property::FLOAT, true, true, true }, // SIZE_HEIGHT
- { "size-depth", Property::FLOAT, true, true, true }, // SIZE_DEPTH
- { "position", Property::VECTOR3, true, true, true }, // POSITION
- { "position-x", Property::FLOAT, true, true, true }, // POSITION_X
- { "position-y", Property::FLOAT, true, true, true }, // POSITION_Y
- { "position-z", Property::FLOAT, true, true, true }, // POSITION_Z
- { "world-position", Property::VECTOR3, false, false, true }, // WORLD_POSITION
- { "world-position-x", Property::FLOAT, false, false, true }, // WORLD_POSITION_X
- { "world-position-y", Property::FLOAT, false, false, true }, // WORLD_POSITION_Y
- { "world-position-z", Property::FLOAT, false, false, true }, // WORLD_POSITION_Z
- { "rotation", Property::ROTATION, true, true, true }, // ROTATION
- { "world-rotation", Property::ROTATION, false, false, true }, // WORLD_ROTATION
- { "scale", Property::VECTOR3, true, true, true }, // SCALE
- { "scale-x", Property::FLOAT, true, true, true }, // SCALE_X
- { "scale-y", Property::FLOAT, true, true, true }, // SCALE_Y
- { "scale-z", Property::FLOAT, true, true, true }, // SCALE_Z
- { "world-scale", Property::VECTOR3, false, false, true }, // WORLD_SCALE
- { "visible", Property::BOOLEAN, true, true, true }, // VISIBLE
- { "color", Property::VECTOR4, true, true, true }, // COLOR
- { "color-red", Property::FLOAT, true, true, true }, // COLOR_RED
- { "color-green", Property::FLOAT, true, true, true }, // COLOR_GREEN
- { "color-blue", Property::FLOAT, true, true, true }, // COLOR_BLUE
- { "color-alpha", Property::FLOAT, true, true, true }, // COLOR_ALPHA
- { "world-color", Property::VECTOR4, false, false, true }, // WORLD_COLOR
- { "world-matrix", Property::MATRIX, false, false, true }, // WORLD_MATRIX
- { "name", Property::STRING, true, false, false }, // NAME
- { "sensitive", Property::BOOLEAN, true, false, false }, // SENSITIVE
- { "leave-required", Property::BOOLEAN, true, false, false }, // LEAVE_REQUIRED
- { "inherit-rotation", Property::BOOLEAN, true, false, false }, // INHERIT_ROTATION
- { "inherit-scale", Property::BOOLEAN, true, false, false }, // INHERIT_SCALE
- { "color-mode", Property::STRING, true, false, false }, // COLOR_MODE
- { "position-inheritance", Property::STRING, true, false, false }, // POSITION_INHERITANCE
- { "draw-mode", Property::STRING, true, false, false }, // DRAW_MODE
- { "size-mode", Property::STRING, true, false, false }, // SIZE_MODE
- { "size-mode-factor", Property::VECTOR3, true, false, false }, // SIZE_MODE_FACTOR
-};
-const int DEFAULT_PROPERTY_COUNT = sizeof( DEFAULT_PROPERTY_DETAILS ) / sizeof( Internal::PropertyDetails );
+} // unnamed namespace
+} // ResizePolicy
-// Enumeration to/from text conversion tables:
-const Scripting::StringEnum< SizeMode > SIZE_MODE_TABLE[] =
+namespace SizeScalePolicy
{
- { "USE_OWN_SIZE", USE_OWN_SIZE },
- { "SIZE_EQUAL_TO_PARENT", SIZE_EQUAL_TO_PARENT },
- { "SIZE_RELATIVE_TO_PARENT", SIZE_RELATIVE_TO_PARENT },
- { "SIZE_FIXED_OFFSET_FROM_PARENT", SIZE_FIXED_OFFSET_FROM_PARENT },
-};
-const unsigned int SIZE_MODE_TABLE_COUNT = sizeof( SIZE_MODE_TABLE ) / sizeof( SIZE_MODE_TABLE[0] );
-
+namespace
+{
+// Enumeration to / from string conversion tables
+DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )DALI_ENUM_TO_STRING( USE_SIZE_SET )
+DALI_ENUM_TO_STRING( FIT_WITH_ASPECT_RATIO )
+DALI_ENUM_TO_STRING( FILL_WITH_ASPECT_RATIO )
+DALI_ENUM_TO_STRING_TABLE_END( Type )
} // unnamed namespace
+} // SizeScalePolicy
namespace Internal
{
unsigned int Actor::mActorCounter = 0;
ActorContainer Actor::mNullChildren;
+/**
+ * Struct to collect relayout variables
+ */
+struct Actor::RelayoutData
+{
+ RelayoutData()
+ : sizeModeFactor( Vector3::ONE ), preferredSize( Vector2::ZERO ), sizeSetPolicy( SizeScalePolicy::USE_SIZE_SET ), relayoutEnabled( false ), insideRelayout( false )
+ {
+ // Set size negotiation defaults
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ resizePolicies[ i ] = ResizePolicy::FIXED;
+ negotiatedDimensions[ i ] = 0.0f;
+ dimensionNegotiated[ i ] = false;
+ dimensionDirty[ i ] = false;
+ dimensionDependencies[ i ] = Dimension::ALL_DIMENSIONS;
+ dimensionPadding[ i ] = Vector2( 0.0f, 0.0f );
+ minimumSize[ i ] = 0.0f;
+ maximumSize[ i ] = FLT_MAX;
+ }
+ }
+
+ ResizePolicy::Type resizePolicies[ Dimension::DIMENSION_COUNT ]; ///< Resize policies
+
+ Dimension::Type dimensionDependencies[ Dimension::DIMENSION_COUNT ]; ///< A list of dimension dependencies
+
+ Vector2 dimensionPadding[ Dimension::DIMENSION_COUNT ]; ///< Padding for each dimension. X = start (e.g. left, bottom), y = end (e.g. right, top)
+
+ float negotiatedDimensions[ Dimension::DIMENSION_COUNT ]; ///< Storage for when a dimension is negotiated but before set on actor
+
+ float minimumSize[ Dimension::DIMENSION_COUNT ]; ///< The minimum size an actor can be
+ float maximumSize[ Dimension::DIMENSION_COUNT ]; ///< The maximum size an actor can be
+
+ bool dimensionNegotiated[ Dimension::DIMENSION_COUNT ]; ///< Has the dimension been negotiated
+ bool dimensionDirty[ Dimension::DIMENSION_COUNT ]; ///< Flags indicating whether the layout dimension is dirty or not
+
+ Vector3 sizeModeFactor; ///< Factor of size used for certain SizeModes
+
+ Vector2 preferredSize; ///< The preferred size of the actor
+
+ SizeScalePolicy::Type sizeSetPolicy :3; ///< Policy to apply when setting size. Enough room for the enum
+
+ bool relayoutEnabled :1; ///< Flag to specify if this actor should be included in size negotiation or not (defaults to true)
+ bool insideRelayout :1; ///< Locking flag to prevent recursive relayouts on size set
+};
+
#ifdef DYNAMICS_SUPPORT
// Encapsulate actor related dynamics data
}
typedef std::map<Actor*, DynamicsJointPtr> JointContainer;
- typedef std::vector<DynamicsJointPtr> ReferencedJointContainer;
+ typedef std::vector<DynamicsJointPtr> ReferencedJointContainer;
- DynamicsBodyPtr body;
- JointContainer joints;
+ DynamicsBodyPtr body;
+ JointContainer joints;
ReferencedJointContainer referencedJoints;
SlotDelegate< Actor > slotDelegate;
#endif // DYNAMICS_SUPPORT
-namespace
+namespace // unnamed namespace
{
-using namespace Dali;
+// Properties
+
+/**
+ * We want to discourage the use of property strings (minimize string comparisons),
+ * particularly for the default properties.
+ * Name Type writable animatable constraint-input enum for index-checking
+ */
+DALI_PROPERTY_TABLE_BEGIN
+DALI_PROPERTY( "parent-origin", VECTOR3, true, false, true, Dali::Actor::Property::PARENT_ORIGIN )
+DALI_PROPERTY( "parent-origin-x", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_X )
+DALI_PROPERTY( "parent-origin-y", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Y )
+DALI_PROPERTY( "parent-origin-z", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Z )
+DALI_PROPERTY( "anchor-point", VECTOR3, true, false, true, Dali::Actor::Property::ANCHOR_POINT )
+DALI_PROPERTY( "anchor-point-x", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_X )
+DALI_PROPERTY( "anchor-point-y", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Y )
+DALI_PROPERTY( "anchor-point-z", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Z )
+DALI_PROPERTY( "size", VECTOR3, true, true, true, Dali::Actor::Property::SIZE )
+DALI_PROPERTY( "size-width", FLOAT, true, true, true, Dali::Actor::Property::SIZE_WIDTH )
+DALI_PROPERTY( "size-height", FLOAT, true, true, true, Dali::Actor::Property::SIZE_HEIGHT )
+DALI_PROPERTY( "size-depth", FLOAT, true, true, true, Dali::Actor::Property::SIZE_DEPTH )
+DALI_PROPERTY( "position", VECTOR3, true, true, true, Dali::Actor::Property::POSITION )
+DALI_PROPERTY( "position-x", FLOAT, true, true, true, Dali::Actor::Property::POSITION_X )
+DALI_PROPERTY( "position-y", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Y )
+DALI_PROPERTY( "position-z", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Z )
+DALI_PROPERTY( "world-position", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_POSITION )
+DALI_PROPERTY( "world-position-x", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_X )
+DALI_PROPERTY( "world-position-y", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Y )
+DALI_PROPERTY( "world-position-z", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Z )
+DALI_PROPERTY( "orientation", ROTATION, true, true, true, Dali::Actor::Property::ORIENTATION )
+DALI_PROPERTY( "world-orientation", ROTATION, false, false, true, Dali::Actor::Property::WORLD_ORIENTATION )
+DALI_PROPERTY( "scale", VECTOR3, true, true, true, Dali::Actor::Property::SCALE )
+DALI_PROPERTY( "scale-x", FLOAT, true, true, true, Dali::Actor::Property::SCALE_X )
+DALI_PROPERTY( "scale-y", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Y )
+DALI_PROPERTY( "scale-z", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Z )
+DALI_PROPERTY( "world-scale", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_SCALE )
+DALI_PROPERTY( "visible", BOOLEAN, true, true, true, Dali::Actor::Property::VISIBLE )
+DALI_PROPERTY( "color", VECTOR4, true, true, true, Dali::Actor::Property::COLOR )
+DALI_PROPERTY( "color-red", FLOAT, true, true, true, Dali::Actor::Property::COLOR_RED )
+DALI_PROPERTY( "color-green", FLOAT, true, true, true, Dali::Actor::Property::COLOR_GREEN )
+DALI_PROPERTY( "color-blue", FLOAT, true, true, true, Dali::Actor::Property::COLOR_BLUE )
+DALI_PROPERTY( "color-alpha", FLOAT, true, true, true, Dali::Actor::Property::COLOR_ALPHA )
+DALI_PROPERTY( "world-color", VECTOR4, false, false, true, Dali::Actor::Property::WORLD_COLOR )
+DALI_PROPERTY( "world-matrix", MATRIX, false, false, true, Dali::Actor::Property::WORLD_MATRIX )
+DALI_PROPERTY( "name", STRING, true, false, false, Dali::Actor::Property::NAME )
+DALI_PROPERTY( "sensitive", BOOLEAN, true, false, false, Dali::Actor::Property::SENSITIVE )
+DALI_PROPERTY( "leave-required", BOOLEAN, true, false, false, Dali::Actor::Property::LEAVE_REQUIRED )
+DALI_PROPERTY( "inherit-orientation", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_ORIENTATION )
+DALI_PROPERTY( "inherit-scale", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_SCALE )
+DALI_PROPERTY( "color-mode", STRING, true, false, false, Dali::Actor::Property::COLOR_MODE )
+DALI_PROPERTY( "position-inheritance", STRING, true, false, false, Dali::Actor::Property::POSITION_INHERITANCE )
+DALI_PROPERTY( "draw-mode", STRING, true, false, false, Dali::Actor::Property::DRAW_MODE )
+DALI_PROPERTY( "size-mode-factor", VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR )
+DALI_PROPERTY( "width-resize-policy", STRING, true, false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY )
+DALI_PROPERTY( "height-resize-policy", STRING, true, false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY )
+DALI_PROPERTY( "size-scale-policy", STRING, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY )
+DALI_PROPERTY( "width-for-height", BOOLEAN, true, false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT )
+DALI_PROPERTY( "height-for-width", BOOLEAN, true, false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH )
+DALI_PROPERTY( "padding", VECTOR4, true, false, false, Dali::Actor::Property::PADDING )
+DALI_PROPERTY( "minimum-size", VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE )
+DALI_PROPERTY( "maximum-size", VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE )
+DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
+
+// Signals
+
+const char* const SIGNAL_TOUCHED = "touched";
+const char* const SIGNAL_HOVERED = "hovered";
+const char* const SIGNAL_MOUSE_WHEEL_EVENT = "mouse-wheel-event";
+const char* const SIGNAL_ON_STAGE = "on-stage";
+const char* const SIGNAL_OFF_STAGE = "off-stage";
+
+// Actions
+
+const char* const ACTION_SHOW = "show";
+const char* const ACTION_HIDE = "hide";
BaseHandle CreateActor()
{
TypeRegistration mType( typeid(Dali::Actor), typeid(Dali::Handle), CreateActor );
-SignalConnectorType signalConnector1(mType, Dali::Actor::SIGNAL_TOUCHED, &Actor::DoConnectSignal);
-SignalConnectorType signalConnector2(mType, Dali::Actor::SIGNAL_HOVERED, &Actor::DoConnectSignal);
-SignalConnectorType signalConnector3(mType, Dali::Actor::SIGNAL_SET_SIZE, &Actor::DoConnectSignal);
-SignalConnectorType signalConnector4(mType, Dali::Actor::SIGNAL_ON_STAGE, &Actor::DoConnectSignal);
-SignalConnectorType signalConnector5(mType, Dali::Actor::SIGNAL_OFF_STAGE, &Actor::DoConnectSignal);
+SignalConnectorType signalConnector1( mType, SIGNAL_TOUCHED, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector2( mType, SIGNAL_HOVERED, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector3( mType, SIGNAL_ON_STAGE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector4( mType, SIGNAL_OFF_STAGE, &Actor::DoConnectSignal );
+
+TypeAction a1( mType, ACTION_SHOW, &Actor::DoAction );
+TypeAction a2( mType, ACTION_HIDE, &Actor::DoAction );
+
+/**
+ * @brief Extract a given dimension from a Vector2
+ *
+ * @param[in] values The values to extract from
+ * @param[in] dimension The dimension to extract
+ * @return Return the value for the dimension
+ */
+float GetDimensionValue( const Vector2& values, Dimension::Type dimension )
+{
+ switch( dimension )
+ {
+ case Dimension::WIDTH:
+ {
+ return values.width;
+ }
+
+ case Dimension::HEIGHT:
+ {
+ return values.height;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
-TypeAction a1(mType, Dali::Actor::ACTION_SHOW, &Actor::DoAction);
-TypeAction a2(mType, Dali::Actor::ACTION_HIDE, &Actor::DoAction);
+ return 0.0f;
+}
+/**
+ * @brief Extract a given dimension from a Vector3
+ *
+ * @param[in] values The values to extract from
+ * @param[in] dimension The dimension to extract
+ * @return Return the value for the dimension
+ */
+float GetDimensionValue( const Vector3& values, Dimension::Type dimension )
+{
+ return GetDimensionValue( values.GetVectorXY(), dimension );
}
+} // unnamed namespace
+
ActorPtr Actor::New()
{
ActorPtr actor( new Actor( BASIC ) );
return mName;
}
-void Actor::SetName(const std::string& name)
+void Actor::SetName( const std::string& name )
{
mName = name;
attachment.Connect();
}
- mAttachment = ActorAttachmentPtr(&attachment);
+ mAttachment = ActorAttachmentPtr( &attachment );
}
ActorAttachmentPtr Actor::GetAttachment()
}
// Find the immediate Layer parent
- for (Actor* parent = mParent; !layer && parent != NULL; parent = parent->GetParent())
+ for( Actor* parent = mParent; !layer && parent != NULL; parent = parent->GetParent() )
{
if( parent->IsLayer() )
{
return layer;
}
-void Actor::Add(Actor& child)
+void Actor::Add( Actor& child )
{
DALI_ASSERT_ALWAYS( this != &child && "Cannot add actor to itself" );
DALI_ASSERT_ALWAYS( !child.IsRoot() && "Cannot add root actor" );
if( oldParent )
{
oldParent->Remove( child ); // This causes OnChildRemove callback
+
+ // Old parent may need to readjust to missing child
+ if( oldParent->RelayoutDependentOnChildren() )
+ {
+ oldParent->RelayoutRequest();
+ }
}
// Guard against Add() during previous OnChildRemove callback
- if ( !child.mParent )
+ if( !child.mParent )
{
// Do this first, since user callbacks from within SetParent() may need to remove child
- mChildren->push_back(Dali::Actor(&child));
+ mChildren->push_back( Dali::Actor( &child ) );
// SetParent asserts that child can be added
- child.SetParent(this);
+ child.SetParent( this );
// Notification for derived classes
- OnChildAdd(child);
+ OnChildAdd( child );
+
+ // Only put in a relayout request if there is a suitable dependency
+ if( RelayoutDependentOnChildren() )
+ {
+ RelayoutRequest();
+ }
}
}
}
-void Actor::Insert(unsigned int index, Actor& child)
+void Actor::Insert( unsigned int index, Actor& child )
{
DALI_ASSERT_ALWAYS( this != &child && "Cannot add actor to itself" );
DALI_ASSERT_ALWAYS( !child.IsRoot() && "Cannot add root actor" );
if( oldParent )
{
oldParent->Remove( child ); // This causes OnChildRemove callback
+
+ // Old parent may need to readjust to missing child
+ if( oldParent->RelayoutDependentOnChildren() )
+ {
+ oldParent->RelayoutRequest();
+ }
}
// Guard against Add() during previous OnChildRemove callback
- if ( !child.mParent )
+ if( !child.mParent )
{
// Do this first, since user callbacks from within SetParent() may need to remove child
- if (index < GetChildCount())
+ if( index < GetChildCount() )
{
ActorIter it = mChildren->begin();
- std::advance(it, index);
- mChildren->insert(it, Dali::Actor(&child));
+ std::advance( it, index );
+ mChildren->insert( it, Dali::Actor( &child ) );
}
else
{
- mChildren->push_back(Dali::Actor(&child));
+ mChildren->push_back( Dali::Actor( &child ) );
}
// SetParent asserts that child can be added
- child.SetParent(this, index);
+ child.SetParent( this, index );
// Notification for derived classes
- OnChildAdd(child);
+ OnChildAdd( child );
+
+ // Only put in a relayout request if there is a suitable dependency
+ if( RelayoutDependentOnChildren() )
+ {
+ RelayoutRequest();
+ }
+
+ if( child.RelayoutDependentOnParent() )
+ {
+ child.RelayoutRequest();
+ }
}
}
-void Actor::Remove(Actor& child)
+void Actor::Remove( Actor& child )
{
DALI_ASSERT_ALWAYS( this != &child && "Cannot remove actor from itself" );
ActorIter end = mChildren->end();
for( ActorIter iter = mChildren->begin(); iter != end; ++iter )
{
- Actor& actor = GetImplementation(*iter);
+ Actor& actor = GetImplementation( *iter );
if( &actor == &child )
{
removed = Dali::Actor( &actor );
// Do this first, since user callbacks from within SetParent() may need to add the child
- mChildren->erase(iter);
+ mChildren->erase( iter );
DALI_ASSERT_DEBUG( actor.GetParent() == this );
actor.SetParent( NULL );
}
}
- if ( removed )
+ if( removed )
{
// Notification for derived classes
- OnChildRemove( GetImplementation(removed) );
+ OnChildRemove( GetImplementation( removed ) );
+
+ // Only put in a relayout request if there is a suitable dependency
+ if( RelayoutDependentOnChildren() )
+ {
+ RelayoutRequest();
+ }
}
}
{
if( mParent )
{
+ // Remove this actor from the parent. The remove will put a relayout request in for
+ // the parent if required
mParent->Remove( *this );
+ // mParent is now NULL!
}
}
return ( NULL != mChildren ) ? mChildren->size() : 0;
}
-Dali::Actor Actor::GetChildAt(unsigned int index) const
+Dali::Actor Actor::GetChildAt( unsigned int index ) const
{
DALI_ASSERT_ALWAYS( index < GetChildCount() );
- return ( ( mChildren ) ? (*mChildren)[index] : Dali::Actor() );
+ return ( ( mChildren ) ? ( *mChildren )[ index ] : Dali::Actor() );
}
ActorContainer Actor::GetChildren()
return mNullChildren;
}
-ActorPtr Actor::FindChildByName(const std::string& actorName)
+ActorPtr Actor::FindChildByName( const std::string& actorName )
{
- ActorPtr child=0;
- if (actorName == mName)
+ ActorPtr child = 0;
+ if( actorName == mName )
{
child = this;
}
ActorIter end = mChildren->end();
for( ActorIter iter = mChildren->begin(); iter != end; ++iter )
{
- child = GetImplementation(*iter).FindChildByName(actorName);
-
- if (child)
- {
- break;
- }
- }
- }
- return child;
-}
-
-Dali::Actor Actor::FindChildByAlias(const std::string& actorAlias)
-{
- Dali::Actor child = DoGetChildByAlias(actorAlias);
-
- // If not found then search by name.
- if (!child)
- {
- Internal::ActorPtr child_ptr = FindChildByName(actorAlias);
- if (child_ptr)
- {
- child = Dali::Actor(child_ptr.Get());
- }
- }
-
- return child;
-}
-
-Dali::Actor Actor::DoGetChildByAlias(const std::string& actorAlias)
-{
- Dali::Actor child = GetChildByAlias(actorAlias);
-
- if (!child && mChildren )
- {
- ActorIter end = mChildren->end();
- for( ActorIter iter = mChildren->begin(); iter != end; ++iter )
- {
- child = GetImplementation(*iter).DoGetChildByAlias(actorAlias);
+ child = GetImplementation( *iter ).FindChildByName( actorName );
- if (child)
+ if( child )
{
break;
}
}
}
-
return child;
}
-ActorPtr Actor::FindChildById(const unsigned int id)
+ActorPtr Actor::FindChildById( const unsigned int id )
{
ActorPtr child = 0;
- if (id == mId)
+ if( id == mId )
{
child = this;
}
ActorIter end = mChildren->end();
for( ActorIter iter = mChildren->begin(); iter != end; ++iter )
{
- child = GetImplementation(*iter).FindChildById(id);
+ child = GetImplementation( *iter ).FindChildById( id );
- if (child)
+ if( child )
{
break;
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SetParentOriginMessage( mStage->GetUpdateInterface(), *mNode, origin );
+ SetParentOriginMessage( GetEventThreadServices(), *mNode, origin );
}
// Cache for event-thread access
return ( mParentOrigin ) ? *mParentOrigin : ParentOrigin::DEFAULT;
}
-void Actor::SetAnchorPoint(const Vector3& anchor)
+void Actor::SetAnchorPoint( const Vector3& anchor )
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SetAnchorPointMessage( mStage->GetUpdateInterface(), *mNode, anchor );
+ SetAnchorPointMessage( GetEventThreadServices(), *mNode, anchor );
}
// Cache for event-thread access
return ( mAnchorPoint ) ? *mAnchorPoint : AnchorPoint::DEFAULT;
}
-void Actor::SetPosition(float x, float y)
+void Actor::SetPosition( float x, float y )
{
- SetPosition(Vector3(x, y, 0.0f));
+ SetPosition( Vector3( x, y, 0.0f ) );
}
-void Actor::SetPosition(float x, float y, float z)
+void Actor::SetPosition( float x, float y, float z )
{
- SetPosition(Vector3(x, y, z));
+ SetPosition( Vector3( x, y, z ) );
}
-void Actor::SetPosition(const Vector3& position)
+void Actor::SetPosition( const Vector3& position )
{
+ mTargetPosition = position;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::Bake, position );
+ SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::Bake, position );
}
}
-void Actor::SetX(float x)
+void Actor::SetX( float x )
{
+ mTargetPosition.x = x;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeX, x );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeX, x );
}
}
-void Actor::SetY(float y)
+void Actor::SetY( float y )
{
+ mTargetPosition.y = y;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeY, y );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeY, y );
}
}
-void Actor::SetZ(float z)
+void Actor::SetZ( float z )
{
+ mTargetPosition.z = z;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeZ, z );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeZ, z );
}
}
-void Actor::MoveBy(const Vector3& distance)
+void Actor::TranslateBy( const Vector3& distance )
{
+ mTargetPosition += distance;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeRelative, distance );
+ SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeRelative, distance );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetPosition(mStage->GetEventBufferIndex());
+ return mNode->GetPosition(GetEventThreadServices().GetEventBufferIndex());
}
return Vector3::ZERO;
}
+const Vector3& Actor::GetTargetPosition() const
+{
+ return mTargetPosition;
+}
+
const Vector3& Actor::GetCurrentWorldPosition() const
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetWorldPosition( mStage->GetEventBufferIndex() );
+ return mNode->GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
}
return Vector3::ZERO;
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value
- SetPositionInheritanceModeMessage( mStage->GetUpdateInterface(), *mNode, mode );
+ SetPositionInheritanceModeMessage( GetEventThreadServices(), *mNode, mode );
}
}
return mPositionInheritanceMode;
}
-void Actor::SetRotation(const Radian& angle, const Vector3& axis)
+void Actor::SetOrientation( const Radian& angle, const Vector3& axis )
{
- Vector4 normalizedAxis(axis.x, axis.y, axis.z, 0.0f);
+ Vector3 normalizedAxis( axis.x, axis.y, axis.z );
normalizedAxis.Normalize();
- Quaternion rotation(Quaternion::FromAxisAngle(normalizedAxis, angle));
+ Quaternion orientation( angle, normalizedAxis );
- SetRotation(rotation);
+ SetOrientation( orientation );
}
-void Actor::SetRotation(const Quaternion& rotation)
+void Actor::SetOrientation( const Quaternion& orientation )
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Quaternion>::Send( mStage->GetUpdateManager(), mNode, &mNode->mRotation, &AnimatableProperty<Quaternion>::Bake, rotation );
+ SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty<Quaternion>::Bake, orientation );
}
}
-void Actor::RotateBy(const Radian& angle, const Vector3& axis)
+void Actor::RotateBy( const Radian& angle, const Vector3& axis )
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Quaternion>::Send( mStage->GetUpdateManager(), mNode, &mNode->mRotation, &AnimatableProperty<Quaternion>::BakeRelative, Quaternion(angle, axis) );
+ SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty<Quaternion>::BakeRelative, Quaternion(angle, axis) );
}
}
-void Actor::RotateBy(const Quaternion& relativeRotation)
+void Actor::RotateBy( const Quaternion& relativeRotation )
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Quaternion>::Send( mStage->GetUpdateManager(), mNode, &mNode->mRotation, &AnimatableProperty<Quaternion>::BakeRelative, relativeRotation );
+ SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty<Quaternion>::BakeRelative, relativeRotation );
}
}
-const Quaternion& Actor::GetCurrentRotation() const
+const Quaternion& Actor::GetCurrentOrientation() const
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetRotation(mStage->GetEventBufferIndex());
+ return mNode->GetOrientation(GetEventThreadServices().GetEventBufferIndex());
}
return Quaternion::IDENTITY;
}
-const Quaternion& Actor::GetCurrentWorldRotation() const
+const Quaternion& Actor::GetCurrentWorldOrientation() const
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetWorldRotation( mStage->GetEventBufferIndex() );
+ return mNode->GetWorldOrientation( GetEventThreadServices().GetEventBufferIndex() );
}
return Quaternion::IDENTITY;
}
-void Actor::SetScale(float scale)
+void Actor::SetScale( float scale )
{
- SetScale(Vector3(scale, scale, scale));
+ SetScale( Vector3( scale, scale, scale ) );
}
-void Actor::SetScale(float x, float y, float z)
+void Actor::SetScale( float x, float y, float z )
{
- SetScale(Vector3(x, y, z));
+ SetScale( Vector3( x, y, z ) );
}
-void Actor::SetScale(const Vector3& scale)
+void Actor::SetScale( const Vector3& scale )
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::Bake, scale );
+ SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::Bake, scale );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeX, x );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeX, x );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeY, y );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeY, y );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeZ, z );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeZ, z );
}
}
-void Actor::SetInitialVolume(const Vector3& volume)
+void Actor::SetInitialVolume( const Vector3& volume )
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value
- SetInitialVolumeMessage( mStage->GetUpdateInterface(), *mNode, volume );
+ SetInitialVolumeMessage( GetEventThreadServices(), *mNode, volume );
}
}
-void Actor::SetTransmitGeometryScaling(bool transmitGeometryScaling)
+void Actor::SetTransmitGeometryScaling( bool transmitGeometryScaling )
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value
- SetTransmitGeometryScalingMessage( mStage->GetUpdateInterface(), *mNode, transmitGeometryScaling );
+ SetTransmitGeometryScalingMessage( GetEventThreadServices(), *mNode, transmitGeometryScaling );
}
}
return false;
}
-void Actor::ScaleBy(const Vector3& relativeScale)
+void Actor::ScaleBy( const Vector3& relativeScale )
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeRelativeMultiply, relativeScale );
+ SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeRelativeMultiply, relativeScale );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetScale(mStage->GetEventBufferIndex());
+ return mNode->GetScale(GetEventThreadServices().GetEventBufferIndex());
}
return Vector3::ONE;
if( NULL != mNode )
{
// mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetWorldScale( mStage->GetEventBufferIndex() );
+ return mNode->GetWorldScale( GetEventThreadServices().GetEventBufferIndex() );
}
return Vector3::ONE;
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value
- SetInheritScaleMessage( mStage->GetUpdateInterface(), *mNode, inherit );
+ SetInheritScaleMessage( GetEventThreadServices(), *mNode, inherit );
}
}
if( NULL != mNode )
{
// World matrix is no longer updated unless there is something observing the node.
- // Need to calculate it from node's world position, rotation and scale:
- BufferIndex updateBufferIndex = mStage->GetEventBufferIndex();
+ // Need to calculate it from node's world position, orientation and scale:
+ BufferIndex updateBufferIndex = GetEventThreadServices().GetEventBufferIndex();
Matrix worldMatrix(false);
worldMatrix.SetTransformComponents( mNode->GetWorldScale( updateBufferIndex ),
- mNode->GetWorldRotation( updateBufferIndex ),
+ mNode->GetWorldOrientation( updateBufferIndex ),
mNode->GetWorldPosition( updateBufferIndex ) );
return worldMatrix;
}
return Matrix::IDENTITY;
}
-void Actor::SetVisible(bool visible)
+void Actor::SetVisible( bool visible )
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<bool>::Send( mStage->GetUpdateManager(), mNode, &mNode->mVisible, &AnimatableProperty<bool>::Bake, visible );
+ SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), mNode, &mNode->mVisible, &AnimatableProperty<bool>::Bake, visible );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; copy the value from the previous update
- return mNode->IsVisible( mStage->GetEventBufferIndex() );
+ return mNode->IsVisible( GetEventThreadServices().GetEventBufferIndex() );
}
return true;
}
-void Actor::SetOpacity(float opacity)
-{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( mStage->GetUpdateManager(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeW, opacity );
- }
-}
-
-void Actor::OpacityBy(float relativeOpacity)
+void Actor::SetOpacity( float opacity )
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( mStage->GetUpdateManager(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeWRelative, relativeOpacity );
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeW, opacity );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetOpacity(mStage->GetEventBufferIndex());
+ return mNode->GetOpacity(GetEventThreadServices().GetEventBufferIndex());
}
return 1.0f;
{
if( NULL != mNode )
{
- return mNode->GetWorldColor( mStage->GetEventBufferIndex() );
+ return mNode->GetWorldColor( GetEventThreadServices().GetEventBufferIndex() );
}
return Color::WHITE;
}
-void Actor::SetColor(const Vector4& color)
+void Actor::SetColor( const Vector4& color )
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector4>::Send( mStage->GetUpdateManager(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::Bake, color );
+ SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::Bake, color );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( mStage->GetUpdateManager(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeX, red );
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeX, red );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( mStage->GetUpdateManager(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeY, green );
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeY, green );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( mStage->GetUpdateManager(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeZ, blue );
- }
-}
-
-void Actor::ColorBy(const Vector4& relativeColor)
-{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector4>::Send( mStage->GetUpdateManager(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeRelative, relativeColor );
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeZ, blue );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetColor(mStage->GetEventBufferIndex());
+ return mNode->GetColor(GetEventThreadServices().GetEventBufferIndex());
}
return Color::WHITE;
}
-void Actor::SetInheritRotation(bool inherit)
+void Actor::SetInheritOrientation( bool inherit )
{
// non animateable so keep local copy
- mInheritRotation = inherit;
+ mInheritOrientation = inherit;
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value
- SetInheritRotationMessage( mStage->GetUpdateInterface(), *mNode, inherit );
+ SetInheritOrientationMessage( GetEventThreadServices(), *mNode, inherit );
}
}
-bool Actor::IsRotationInherited() const
-{
- return mInheritRotation;
-}
-
-void Actor::SetSizeMode(SizeMode mode)
+bool Actor::IsOrientationInherited() const
{
- // non animateable so keep local copy
- mSizeMode = mode;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value
- SetSizeModeMessage( mStage->GetUpdateInterface(), *mNode, mode );
- }
+ return mInheritOrientation;
}
-void Actor::SetSizeModeFactor(const Vector3& factor)
+void Actor::SetSizeModeFactor( const Vector3& factor )
{
- // non animateable so keep local copy
- mSizeModeFactor = factor;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value
- SetSizeModeFactorMessage( mStage->GetUpdateInterface(), *mNode, factor );
- }
-}
+ EnsureRelayoutData();
-SizeMode Actor::GetSizeMode() const
-{
- return mSizeMode;
+ mRelayoutData->sizeModeFactor = factor;
}
const Vector3& Actor::GetSizeModeFactor() const
{
- return mSizeModeFactor;
+ EnsureRelayoutData();
+
+ return mRelayoutData->sizeModeFactor;
}
-void Actor::SetColorMode(ColorMode colorMode)
+void Actor::SetColorMode( ColorMode colorMode )
{
// non animateable so keep local copy
mColorMode = colorMode;
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value
- SetColorModeMessage( mStage->GetUpdateInterface(), *mNode, colorMode );
+ SetColorModeMessage( GetEventThreadServices(), *mNode, colorMode );
}
}
return mColorMode;
}
-void Actor::SetSize(float width, float height)
+void Actor::SetSize( float width, float height )
{
SetSize( Vector2( width, height ) );
}
-void Actor::SetSize(float width, float height, float depth)
+void Actor::SetSize( float width, float height, float depth )
{
SetSize( Vector3( width, height, depth ) );
}
-void Actor::SetSize(const Vector2& size)
+void Actor::SetSize( const Vector2& size )
{
SetSize( Vector3( size.width, size.height, CalculateSizeZ( size ) ) );
}
+void Actor::SetSizeInternal( const Vector2& size )
+{
+ SetSizeInternal( Vector3( size.width, size.height, CalculateSizeZ( size ) ) );
+}
+
float Actor::CalculateSizeZ( const Vector2& size ) const
{
return std::min( size.width, size.height );
}
-void Actor::SetSize(const Vector3& size)
+void Actor::SetSize( const Vector3& size )
+{
+ if( IsRelayoutEnabled() && !mRelayoutData->insideRelayout )
+ {
+ SetPreferredSize( size.GetVectorXY() );
+ }
+ else
+ {
+ SetSizeInternal( size );
+ }
+}
+
+void Actor::SetSizeInternal( const Vector3& size )
{
if( NULL != mNode )
{
- mSize = size;
+ mTargetSize = size;
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::Bake, mSize );
+ SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::Bake, mTargetSize );
// Notification for derived classes
- OnSizeSet( mSize );
+ OnSizeSet( mTargetSize );
- // Emit signal for application developer
-
- if( !mSetSizeSignal.Empty() )
+ // Raise a relayout request if the flag is not locked
+ if( mRelayoutData && !mRelayoutData->insideRelayout )
{
- Dali::Actor handle( this );
- mSetSizeSignal.Emit( handle, mSize );
+ RelayoutRequest();
}
}
}
-void Actor::NotifySizeAnimation(Animation& animation, const Vector3& targetSize)
+void Actor::NotifySizeAnimation( Animation& animation, const Vector3& targetSize )
{
- mSize = targetSize;
+ mTargetSize = targetSize;
// Notify deriving classes
OnSizeAnimation( animation, targetSize );
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeX, width );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeX, width );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeY, height );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeY, height );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeZ, depth );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeZ, depth );
}
}
-const Vector3& Actor::GetSize() const
+const Vector3& Actor::GetTargetSize() const
{
- return mSize;
+ return mTargetSize;
}
const Vector3& Actor::GetCurrentSize() const
if( NULL != mNode )
{
// mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetSize( mStage->GetEventBufferIndex() );
+ return mNode->GetSize( GetEventThreadServices().GetEventBufferIndex() );
}
return Vector3::ZERO;
return Vector3( 0.0f, 0.0f, 0.0f );
}
+void Actor::SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
+{
+ EnsureRelayoutData();
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ mRelayoutData->resizePolicies[ i ] = policy;
+ }
+ }
+
+ if( policy == ResizePolicy::DIMENSION_DEPENDENCY )
+ {
+ if( dimension & Dimension::WIDTH )
+ {
+ SetDimensionDependency( Dimension::WIDTH, Dimension::HEIGHT );
+ }
+
+ if( dimension & Dimension::HEIGHT )
+ {
+ SetDimensionDependency( Dimension::HEIGHT, Dimension::WIDTH );
+ }
+ }
+
+ // If calling SetResizePolicy, assume we want relayout enabled
+ SetRelayoutEnabled( true );
+
+ OnSetResizePolicy( policy, dimension );
+
+ // Trigger relayout on this control
+ RelayoutRequest();
+}
+
+ResizePolicy::Type Actor::GetResizePolicy( Dimension::Type dimension ) const
+{
+ EnsureRelayoutData();
+
+ // If more than one dimension is requested, just return the first one found
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ return mRelayoutData->resizePolicies[ i ];
+ }
+ }
+
+ return ResizePolicy::FIXED; // Default
+}
+
+void Actor::SetSizeScalePolicy( SizeScalePolicy::Type policy )
+{
+ EnsureRelayoutData();
+
+ mRelayoutData->sizeSetPolicy = policy;
+}
+
+SizeScalePolicy::Type Actor::GetSizeScalePolicy() const
+{
+ EnsureRelayoutData();
+
+ return mRelayoutData->sizeSetPolicy;
+}
+
+void Actor::SetDimensionDependency( Dimension::Type dimension, Dimension::Type dependency )
+{
+ EnsureRelayoutData();
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ mRelayoutData->dimensionDependencies[ i ] = dependency;
+ }
+ }
+}
+
+Dimension::Type Actor::GetDimensionDependency( Dimension::Type dimension ) const
+{
+ EnsureRelayoutData();
+
+ // If more than one dimension is requested, just return the first one found
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ return mRelayoutData->dimensionDependencies[ i ];
+ }
+ }
+
+ return Dimension::ALL_DIMENSIONS; // Default
+}
+
+void Actor::SetRelayoutEnabled( bool relayoutEnabled )
+{
+ // If relayout data has not been allocated yet and the client is requesting
+ // to disable it, do nothing
+ if( mRelayoutData || relayoutEnabled )
+ {
+ EnsureRelayoutData();
+
+ mRelayoutData->relayoutEnabled = relayoutEnabled;
+ }
+}
+
+bool Actor::IsRelayoutEnabled() const
+{
+ // Assume that if relayout data has not been allocated yet then
+ // relayout is disabled
+ return mRelayoutData && mRelayoutData->relayoutEnabled;
+}
+
+void Actor::SetLayoutDirty( bool dirty, Dimension::Type dimension )
+{
+ EnsureRelayoutData();
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ mRelayoutData->dimensionDirty[ i ] = dirty;
+ }
+ }
+}
+
+bool Actor::IsLayoutDirty( Dimension::Type dimension ) const
+{
+ EnsureRelayoutData();
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionDirty[ i ] )
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool Actor::RelayoutPossible( Dimension::Type dimension ) const
+{
+ EnsureRelayoutData();
+
+ return mRelayoutData->relayoutEnabled && !IsLayoutDirty( dimension );
+}
+
+bool Actor::RelayoutRequired( Dimension::Type dimension ) const
+{
+ EnsureRelayoutData();
+
+ return mRelayoutData->relayoutEnabled && IsLayoutDirty( dimension );
+}
#ifdef DYNAMICS_SUPPORT
if( OnStage() )
{
- DynamicsWorldPtr world( mStage->GetDynamicsWorld() );
+ DynamicsWorldPtr world( DynamicsWorld::Get() );
if( world )
{
if( mParent == world->GetRootActor().Get() )
{
- mDynamicsData->body->Connect(*mStage);
+ mDynamicsData->body->Connect( GetEventThreadServices() );
}
}
}
DynamicsJointPtr joint;
- DynamicsWorldPtr world( mStage->GetDynamicsWorld() );
+ DynamicsWorldPtr world( DynamicsWorld::Get() );
if( world )
{
if( OnStage() && attachedActor->OnStage() )
{
- joint->Connect(*mStage);
+ joint->Connect( GetEventThreadServices() );
}
attachedActor->ReferenceJoint( joint );
{
DynamicsData::JointContainer::const_iterator it( mDynamicsData->joints.begin() );
- for( int i = 0; i < index; ++i )
+ for( int i = 0; i < index; ++i )
{
++it;
}
DynamicsData::JointContainer::iterator it( mDynamicsData->joints.begin() );
DynamicsData::JointContainer::iterator endIt( mDynamicsData->joints.end() );
- for( ; it != endIt; ++it )
+ for(; it != endIt; ++it )
{
if( it->second == joint.Get() )
{
if( OnStage() && attachedActor && attachedActor->OnStage() )
{
- joint->Disconnect(*mStage);
+ joint->Disconnect( GetEventThreadServices() );
}
if( attachedActor )
DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" );
if( NULL != mDynamicsData )
{
- DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
+ DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
if( mDynamicsData->joints.end() != it )
{
DynamicsJointPtr joint( it->second );
- joint->Connect(*mStage);
+ joint->Connect( GetEventThreadServices() );
}
}
}
DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" );
if( NULL != mDynamicsData )
{
- DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
+ DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
if( mDynamicsData->joints.end() != it )
{
DynamicsJointPtr joint( it->second );
- joint->Disconnect(*mStage);
+ joint->Disconnect( GetEventThreadServices() );
}
}
}
{
if( OnStage() && mParent && mParent->IsDynamicsRoot() )
{
- mDynamicsData->body->Connect(*mStage);
+ mDynamicsData->body->Connect( GetEventThreadServices() );
// Connect all joints where attachedActor is also on stage
if( !mDynamicsData->joints.empty() )
DynamicsData::JointContainer::iterator it( mDynamicsData->joints.begin() );
DynamicsData::JointContainer::iterator endIt( mDynamicsData->joints.end() );
- for( ; it != endIt; ++it )
+ for(; it != endIt; ++it )
{
Actor* attachedActor( it->first );
if( NULL != attachedActor && attachedActor->OnStage() )
{
DynamicsJointPtr joint( it->second );
- joint->Connect(*mStage);
+ joint->Connect( GetEventThreadServices() );
}
}
}
{
if( OnStage() )
{
- mDynamicsData->body->Disconnect(*mStage);
+ mDynamicsData->body->Disconnect( GetEventThreadServices() );
// Disconnect all joints
if( !mDynamicsData->joints.empty() )
DynamicsData::JointContainer::iterator it( mDynamicsData->joints.begin() );
DynamicsData::JointContainer::iterator endIt( mDynamicsData->joints.end() );
- for( ; it != endIt; ++it )
+ for(; it != endIt; ++it )
{
DynamicsJointPtr joint( it->second );
- joint->Disconnect(*mStage);
+ joint->Disconnect( GetEventThreadServices() );
}
}
}
#endif // DYNAMICS_SUPPORT
-void Actor::SetOverlay(bool enable)
+void Actor::SetOverlay( bool enable )
{
// Setting STENCIL will override OVERLAY
if( DrawMode::STENCIL != mDrawMode )
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value
- SetDrawModeMessage( mStage->GetUpdateInterface(), *mNode, drawMode );
+ SetDrawModeMessage( GetEventThreadServices(), *mNode, drawMode );
}
}
return mDrawMode;
}
-bool Actor::ScreenToLocal( float& localX,
- float& localY,
- float screenX,
- float screenY ) const
+bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const
{
// only valid when on-stage
- if ( OnStage() )
+ if( OnStage() )
{
- const RenderTaskList& taskList = mStage->GetRenderTaskList();
+ const RenderTaskList& taskList = Stage::GetCurrent()->GetRenderTaskList();
Vector2 converted( screenX, screenY );
return false;
}
-bool Actor::ScreenToLocal( RenderTask& renderTask,
- float& localX,
- float& localY,
- float screenX,
- float screenY ) const
+bool Actor::ScreenToLocal( RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const
{
bool retval = false;
// only valid when on-stage
- if ( OnStage() )
+ if( OnStage() )
{
CameraActor* camera = renderTask.GetCameraActor();
if( camera )
return retval;
}
-bool Actor::ScreenToLocal( const Matrix& viewMatrix,
- const Matrix& projectionMatrix,
- const Viewport& viewport,
- float& localX,
- float& localY,
- float screenX,
- float screenY ) const
+bool Actor::ScreenToLocal( const Matrix& viewMatrix, const Matrix& projectionMatrix, const Viewport& viewport, float& localX, float& localY, float screenX, float screenY ) const
{
// Early-out if mNode is NULL
if( !OnStage() )
return false;
}
- BufferIndex bufferIndex( mStage->GetEventBufferIndex() );
+ BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
// Calculate the ModelView matrix
- Matrix modelView(false/*don't init*/);
+ Matrix modelView( false/*don't init*/);
// need to use the components as world matrix is only updated for actors that need it
- modelView.SetTransformComponents( mNode->GetWorldScale(bufferIndex), mNode->GetWorldRotation(bufferIndex), mNode->GetWorldPosition(bufferIndex) );
- Matrix::Multiply(modelView, modelView, viewMatrix);
+ modelView.SetTransformComponents( mNode->GetWorldScale( bufferIndex ), mNode->GetWorldOrientation( bufferIndex ), mNode->GetWorldPosition( bufferIndex ) );
+ Matrix::Multiply( modelView, modelView, viewMatrix );
// Calculate the inverted ModelViewProjection matrix; this will be used for 2 unprojects
- Matrix invertedMvp(false/*don't init*/);
- Matrix::Multiply(invertedMvp, modelView, projectionMatrix);
+ Matrix invertedMvp( false/*don't init*/);
+ Matrix::Multiply( invertedMvp, modelView, projectionMatrix );
bool success = invertedMvp.Invert();
// Convert to GL coordinates
- Vector4 screenPos( screenX - viewport.x, viewport.height - (screenY - viewport.y), 0.f, 1.f );
+ Vector4 screenPos( screenX - viewport.x, viewport.height - ( screenY - viewport.y ), 0.f, 1.f );
Vector4 nearPos;
- if (success)
+ if( success )
{
- success = Unproject(screenPos, invertedMvp, viewport.width, viewport.height, nearPos);
+ success = Unproject( screenPos, invertedMvp, viewport.width, viewport.height, nearPos );
}
Vector4 farPos;
- if (success)
+ if( success )
{
screenPos.z = 1.0f;
- success = Unproject(screenPos, invertedMvp, viewport.width, viewport.height, farPos);
+ success = Unproject( screenPos, invertedMvp, viewport.width, viewport.height, farPos );
}
- if (success)
+ if( success )
{
Vector4 local;
- if (XyPlaneIntersect(nearPos, farPos, local))
+ if( XyPlaneIntersect( nearPos, farPos, local ) )
{
Vector3 size = GetCurrentSize();
localX = local.x + size.x * 0.5f;
bool Actor::RaySphereTest( const Vector4& rayOrigin, const Vector4& rayDir ) const
{
/*
- http://wiki.cgsociety.org/index.php/Ray_Sphere_Intersection
+ http://wiki.cgsociety.org/index.php/Ray_Sphere_Intersection
- Mathematical Formulation
+ Mathematical Formulation
- Given the above mentioned sphere, a point 'p' lies on the surface of the sphere if
+ Given the above mentioned sphere, a point 'p' lies on the surface of the sphere if
- ( p - c ) dot ( p - c ) = r^2
+ ( p - c ) dot ( p - c ) = r^2
- Given a ray with a point of origin 'o', and a direction vector 'd':
+ Given a ray with a point of origin 'o', and a direction vector 'd':
- ray(t) = o + td, t >= 0
+ ray(t) = o + td, t >= 0
- we can find the t at which the ray intersects the sphere by setting ray(t) equal to 'p'
+ we can find the t at which the ray intersects the sphere by setting ray(t) equal to 'p'
- (o + td - c ) dot ( o + td - c ) = r^2
+ (o + td - c ) dot ( o + td - c ) = r^2
- To solve for t we first expand the above into a more recognisable quadratic equation form
+ To solve for t we first expand the above into a more recognisable quadratic equation form
- ( d dot d )t^2 + 2( o - c ) dot dt + ( o - c ) dot ( o - c ) - r^2 = 0
+ ( d dot d )t^2 + 2( o - c ) dot dt + ( o - c ) dot ( o - c ) - r^2 = 0
- or
+ or
- At2 + Bt + C = 0
+ At2 + Bt + C = 0
- where
+ where
- A = d dot d
- B = 2( o - c ) dot d
- C = ( o - c ) dot ( o - c ) - r^2
+ A = d dot d
+ B = 2( o - c ) dot d
+ C = ( o - c ) dot ( o - c ) - r^2
- which can be solved using a standard quadratic formula.
+ which can be solved using a standard quadratic formula.
- Note that in the absence of positive, real, roots, the ray does not intersect the sphere.
+ Note that in the absence of positive, real, roots, the ray does not intersect the sphere.
- Practical Simplification
+ Practical Simplification
- In a renderer, we often differentiate between world space and object space. In the object space
- of a sphere it is centred at origin, meaning that if we first transform the ray from world space
- into object space, the mathematical solution presented above can be simplified significantly.
+ In a renderer, we often differentiate between world space and object space. In the object space
+ of a sphere it is centred at origin, meaning that if we first transform the ray from world space
+ into object space, the mathematical solution presented above can be simplified significantly.
- If a sphere is centred at origin, a point 'p' lies on a sphere of radius r2 if
+ If a sphere is centred at origin, a point 'p' lies on a sphere of radius r2 if
- p dot p = r^2
+ p dot p = r^2
- and we can find the t at which the (transformed) ray intersects the sphere by
+ and we can find the t at which the (transformed) ray intersects the sphere by
- ( o + td ) dot ( o + td ) = r^2
+ ( o + td ) dot ( o + td ) = r^2
- According to the reasoning above, we expand the above quadratic equation into the general form
+ According to the reasoning above, we expand the above quadratic equation into the general form
- At2 + Bt + C = 0
+ At2 + Bt + C = 0
- which now has coefficients:
+ which now has coefficients:
- A = d dot d
- B = 2( d dot o )
- C = o dot o - r^2
+ A = d dot d
+ B = 2( d dot o )
+ C = o dot o - r^2
*/
// Early out if mNode is NULL
return false;
}
- BufferIndex bufferIndex( mStage->GetEventBufferIndex() );
+ BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
// Transforms the ray to the local reference system. As the test is against a sphere, only the translation and scale are needed.
const Vector3& translation( mNode->GetWorldPosition( bufferIndex ) );
- Vector3 rayOriginLocal(rayOrigin.x - translation.x,
- rayOrigin.y - translation.y,
- rayOrigin.z - translation.z);
+ Vector3 rayOriginLocal( rayOrigin.x - translation.x, rayOrigin.y - translation.y, rayOrigin.z - translation.z );
// Compute the radius is not needed, square radius it's enough.
const Vector3& size( mNode->GetSize( bufferIndex ) );
float b2 = rayDir.Dot( rayOriginLocal ); // b/2
float c = rayOriginLocal.Dot( rayOriginLocal ) - squareSphereRadius; // c
- return ( b2*b2 - a*c ) >= 0.f;
+ return ( b2 * b2 - a * c ) >= 0.f;
}
bool Actor::RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vector4& hitPointLocal, float& distance ) const
bool hit = false;
if( OnStage() &&
- NULL != mNode )
+ NULL != mNode )
{
- BufferIndex bufferIndex( mStage->GetEventBufferIndex() );
+ BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
// Transforms the ray to the local reference system.
// Calculate the inverse of Model matrix
- Matrix invModelMatrix(false/*don't init*/);
+ Matrix invModelMatrix( false/*don't init*/);
// need to use the components as world matrix is only updated for actors that need it
- invModelMatrix.SetInverseTransformComponents( mNode->GetWorldScale(bufferIndex), mNode->GetWorldRotation(bufferIndex), mNode->GetWorldPosition(bufferIndex) );
+ invModelMatrix.SetInverseTransformComponents( mNode->GetWorldScale( bufferIndex ), mNode->GetWorldOrientation( bufferIndex ), mNode->GetWorldPosition( bufferIndex ) );
- Vector4 rayOriginLocal(invModelMatrix * rayOrigin);
- Vector4 rayDirLocal(invModelMatrix * rayDir - invModelMatrix.GetTranslation());
+ Vector4 rayOriginLocal( invModelMatrix * rayOrigin );
+ Vector4 rayDirLocal( invModelMatrix * rayDir - invModelMatrix.GetTranslation() );
// Test with the actor's XY plane (Normal = 0 0 1 1).
return hit;
}
-void Actor::SetLeaveRequired(bool required)
+void Actor::SetLeaveRequired( bool required )
{
mLeaveRequired = required;
}
bool Actor::IsHittable() const
{
- return IsSensitive() &&
- IsVisible() &&
- ( GetCurrentWorldColor().a > FULLY_TRANSPARENT ) &&
- IsNodeConnected();
+ return IsSensitive() && IsVisible() && ( GetCurrentWorldColor().a > FULLY_TRANSPARENT ) && IsNodeConnected();
}
ActorGestureData& Actor::GetGestureData()
{
// Likely scenario is that once gesture-data is created for this actor, the actor will require
// that gesture for its entire life-time so no need to destroy it until the actor is destroyed
- if ( NULL == mGestureData )
+ if( NULL == mGestureData )
{
mGestureData = new ActorGestureData;
}
return mGestureData && mGestureData->IsGestureRequred( type );
}
-bool Actor::EmitTouchEventSignal(const TouchEvent& event)
+bool Actor::EmitTouchEventSignal( const TouchEvent& event )
{
bool consumed = false;
- if ( !mTouchedSignal.Empty() )
+ if( !mTouchedSignal.Empty() )
{
Dali::Actor handle( this );
consumed = mTouchedSignal.Emit( handle, event );
}
- if (!consumed)
+ if( !consumed )
{
// Notification for derived classes
consumed = OnTouchEvent( event );
return consumed;
}
-bool Actor::EmitHoverEventSignal(const HoverEvent& event)
+bool Actor::EmitHoverEventSignal( const HoverEvent& event )
{
bool consumed = false;
- if ( !mHoveredSignal.Empty() )
+ if( !mHoveredSignal.Empty() )
{
Dali::Actor handle( this );
consumed = mHoveredSignal.Emit( handle, event );
}
- if (!consumed)
+ if( !consumed )
{
// Notification for derived classes
consumed = OnHoverEvent( event );
return consumed;
}
-bool Actor::EmitMouseWheelEventSignal(const MouseWheelEvent& event)
+bool Actor::EmitMouseWheelEventSignal( const MouseWheelEvent& event )
{
bool consumed = false;
- if ( !mMouseWheelEventSignal.Empty() )
+ if( !mMouseWheelEventSignal.Empty() )
{
Dali::Actor handle( this );
consumed = mMouseWheelEventSignal.Emit( handle, event );
}
- if (!consumed)
+ if( !consumed )
{
// Notification for derived classes
- consumed = OnMouseWheelEvent(event);
+ consumed = OnMouseWheelEvent( event );
}
return consumed;
return mMouseWheelEventSignal;
}
-Dali::Actor::SetSizeSignalType& Actor::SetSizeSignal()
-{
- return mSetSizeSignal;
-}
-
Dali::Actor::OnStageSignalType& Actor::OnStageSignal()
{
return mOnStageSignal;
return mOffStageSignal;
}
+Dali::Actor::OnRelayoutSignalType& Actor::OnRelayoutSignal()
+{
+ return mOnRelayoutSignal;
+}
+
bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
{
bool connected( true );
- Actor* actor = dynamic_cast<Actor*>(object);
+ Actor* actor = dynamic_cast< Actor* >( object );
- if(Dali::Actor::SIGNAL_TOUCHED == signalName)
+ if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCHED ) ) // don't want to convert char* to string
{
actor->TouchedSignal().Connect( tracker, functor );
}
- else if(Dali::Actor::SIGNAL_HOVERED == signalName)
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_HOVERED ) )
{
actor->HoveredSignal().Connect( tracker, functor );
}
- else if(Dali::Actor::SIGNAL_MOUSE_WHEEL_EVENT == signalName)
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_MOUSE_WHEEL_EVENT ) )
{
actor->MouseWheelEventSignal().Connect( tracker, functor );
}
- else if(Dali::Actor::SIGNAL_SET_SIZE == signalName)
- {
- actor->SetSizeSignal().Connect( tracker, functor );
- }
- else if(Dali::Actor::SIGNAL_ON_STAGE == signalName)
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_ON_STAGE ) )
{
actor->OnStageSignal().Connect( tracker, functor );
}
- else if(Dali::Actor::SIGNAL_OFF_STAGE == signalName)
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_OFF_STAGE ) )
{
actor->OffStageSignal().Connect( tracker, functor );
}
}
Actor::Actor( DerivedType derivedType )
-: mStage( NULL ),
- mParent( NULL ),
+: mParent( NULL ),
mChildren( NULL ),
mNode( NULL ),
mParentOrigin( NULL ),
mAnchorPoint( NULL ),
+ mRelayoutData( NULL ),
#ifdef DYNAMICS_SUPPORT
- mDynamicsData( NULL ),
+ mDynamicsData( NULL ),
#endif
- mGestureData( NULL ),
- mAttachment(),
- mSize( 0.0f, 0.0f, 0.0f ),
- mSizeModeFactor( Vector3::ONE ),
- mName(),
- mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
- mIsRoot( ROOT_LAYER == derivedType ),
- mIsRenderable( RENDERABLE == derivedType ),
- mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ),
- mIsOnStage( false ),
- mIsDynamicsRoot(false),
- mSensitive( true ),
- mLeaveRequired( false ),
- mKeyboardFocusable( false ),
- mDerivedRequiresTouch( false ),
- mDerivedRequiresHover( false ),
- mDerivedRequiresMouseWheelEvent( false ),
- mOnStageSignalled( false ),
- mInheritRotation( true ),
- mInheritScale( true ),
- mDrawMode( DrawMode::NORMAL ),
- mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ),
- mColorMode( Node::DEFAULT_COLOR_MODE ),
- mSizeMode( Node::DEFAULT_SIZE_MODE )
+ mGestureData( NULL ), mAttachment(), mTargetSize( 0.0f, 0.0f, 0.0f ), mName(), mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
+ mIsRoot( ROOT_LAYER == derivedType ), mIsRenderable( RENDERABLE == derivedType ), mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ), mIsOnStage( false ), mIsDynamicsRoot( false ), mSensitive( true ), mLeaveRequired( false ), mKeyboardFocusable( false ), mDerivedRequiresTouch( false ), mDerivedRequiresHover( false ), mDerivedRequiresMouseWheelEvent( false ), mOnStageSignalled( false ), mInheritOrientation( true ), mInheritScale( true ), mDrawMode( DrawMode::NORMAL ), mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ), mColorMode( Node::DEFAULT_COLOR_MODE )
{
}
void Actor::Initialize()
{
- mStage = Stage::GetCurrent();
-
// Node creation
SceneGraph::Node* node = CreateNode();
- AddNodeMessage( mStage->GetUpdateManager(), *node ); // Pass ownership to scene-graph
+ AddNodeMessage( GetEventThreadServices().GetUpdateManager(), *node ); // Pass ownership to scene-graph
mNode = node; // Keep raw-pointer to Node
OnInitialize();
- RegisterObject();
+ GetEventThreadServices().RegisterObject( this );
}
Actor::~Actor()
delete mChildren;
// Guard to allow handle destruction after Core has been destroyed
- if( Stage::IsInstalled() )
+ if( EventThreadServices::IsCoreRunning() )
{
if( NULL != mNode )
{
- DestroyNodeMessage( mStage->GetUpdateManager(), *mNode );
+ DestroyNodeMessage( GetEventThreadServices().GetUpdateManager(), *mNode );
mNode = NULL; // Node is about to be destroyed
}
- UnregisterObject();
+ GetEventThreadServices().UnregisterObject( this );
}
#ifdef DYNAMICS_SUPPORT
// Cleanup optional parent origin and anchor
delete mParentOrigin;
delete mAnchorPoint;
+
+ // Delete optional relayout data
+ if( mRelayoutData )
+ {
+ delete mRelayoutData;
+ }
}
void Actor::ConnectToStage( int index )
const ActorIter endIter = connectionList.end();
for( ActorIter iter = connectionList.begin(); iter != endIter; ++iter )
{
- Actor& actor = GetImplementation(*iter);
+ Actor& actor = GetImplementation( *iter );
actor.NotifyStageConnection();
}
+
+ RelayoutRequest();
}
void Actor::RecursiveConnectToStage( ActorContainer& connectionList, int index )
mIsOnStage = true;
- ConnectToSceneGraph(index);
+ ConnectToSceneGraph( index );
// Notification for internal derived classes
OnStageConnectionInternal();
// This stage is atomic; avoid emitting callbacks until all Actors are connected
- connectionList.push_back( Dali::Actor(this) );
+ connectionList.push_back( Dali::Actor( this ) );
// Recursively connect children
if( mChildren )
* The child must connect its Node to the parent's Node.
* This is resursive; the child calls ConnectToStage() for its children.
*/
-void Actor::ConnectToSceneGraph(int index)
+void Actor::ConnectToSceneGraph( int index )
{
- DALI_ASSERT_DEBUG( mNode != NULL);
- DALI_ASSERT_DEBUG( mParent != NULL);
- DALI_ASSERT_DEBUG( mParent->mNode != NULL );
+ DALI_ASSERT_DEBUG( mNode != NULL); DALI_ASSERT_DEBUG( mParent != NULL); DALI_ASSERT_DEBUG( mParent->mNode != NULL );
if( NULL != mNode )
{
// Reparent Node in next Update
- ConnectNodeMessage( mStage->GetUpdateManager(), *(mParent->mNode), *mNode, index );
+ ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode, index );
}
// Notify attachment
- if (mAttachment)
+ if( mAttachment )
{
mAttachment->Connect();
}
}
#endif
- // Notification for ProxyObject::Observers
+ // Request relayout on all actors that are added to the scenegraph
+ RelayoutRequest();
+
+ // Notification for Object::Observers
OnSceneObjectAdd();
}
{
// Actors can be removed (in a callback), before the on-stage stage is reported.
// The actor may also have been reparented, in which case mOnStageSignalled will be true.
- if ( OnStage() && !mOnStageSignalled )
+ if( OnStage() && !mOnStageSignalled )
{
// Notification for external (CustomActor) derived classes
OnStageConnectionExternal();
- if ( !mOnStageSignal.Empty() )
+ if( !mOnStageSignal.Empty() )
{
Dali::Actor handle( this );
mOnStageSignal.Emit( handle );
}
// Guard against Remove during callbacks
- if ( OnStage() )
+ if( OnStage() )
{
mOnStageSignalled = true; // signal required next time Actor is removed
}
const ActorIter endIter = disconnectionList.end();
for( ActorIter iter = disconnectionList.begin(); iter != endIter; ++iter )
{
- Actor& actor = GetImplementation(*iter);
+ Actor& actor = GetImplementation( *iter );
actor.NotifyStageDisconnection();
}
}
}
// This stage is atomic; avoid emitting callbacks until all Actors are disconnected
- disconnectionList.push_back( Dali::Actor(this) );
+ disconnectionList.push_back( Dali::Actor( this ) );
// Notification for internal derived classes
OnStageDisconnectionInternal();
*/
void Actor::DisconnectFromSceneGraph()
{
- // Notification for ProxyObject::Observers
+ // Notification for Object::Observers
OnSceneObjectRemove();
// Notify attachment
- if (mAttachment)
+ if( mAttachment )
{
mAttachment->Disconnect();
}
// Actors can be added (in a callback), before the off-stage state is reported.
// Also if the actor was added & removed before mOnStageSignalled was set, then we don't notify here.
// only do this step if there is a stage, i.e. Core is not being shut down
- if ( Stage::IsInstalled() && !OnStage() && mOnStageSignalled )
+ if ( EventThreadServices::IsCoreRunning() && !OnStage() && mOnStageSignalled )
{
// Notification for external (CustomeActor) derived classes
OnStageDisconnectionExternal();
}
// Guard against Add during callbacks
- if ( !OnStage() )
+ if( !OnStage() )
{
mOnStageSignalled = false; // signal required next time Actor is added
}
bool connected( false );
if( OnStage() &&
- NULL != mNode )
+ NULL != mNode )
{
if( mNode->IsRoot() || mNode->GetParent() )
{
{
indices.reserve( DEFAULT_PROPERTY_COUNT );
- for ( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
+ for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
{
indices.push_back( i );
}
{
if( index < DEFAULT_PROPERTY_COUNT )
{
- return DEFAULT_PROPERTY_DETAILS[index].name;
- }
- else
- {
- return NULL;
+ return DEFAULT_PROPERTY_DETAILS[ index ].name;
}
+
+ return NULL;
}
-Property::Index Actor::GetDefaultPropertyIndex(const std::string& name) const
+Property::Index Actor::GetDefaultPropertyIndex( const std::string& name ) const
{
Property::Index index = Property::INVALID_INDEX;
return index;
}
-bool Actor::IsDefaultPropertyWritable(Property::Index index) const
+bool Actor::IsDefaultPropertyWritable( Property::Index index ) const
{
if( index < DEFAULT_PROPERTY_COUNT )
{
- return DEFAULT_PROPERTY_DETAILS[index].writable;
- }
- else
- {
- return false;
+ return DEFAULT_PROPERTY_DETAILS[ index ].writable;
}
+
+ return false;
}
-bool Actor::IsDefaultPropertyAnimatable(Property::Index index) const
+bool Actor::IsDefaultPropertyAnimatable( Property::Index index ) const
{
if( index < DEFAULT_PROPERTY_COUNT )
{
- return DEFAULT_PROPERTY_DETAILS[index].animatable;
- }
- else
- {
- return false;
+ return DEFAULT_PROPERTY_DETAILS[ index ].animatable;
}
+
+ return false;
}
bool Actor::IsDefaultPropertyAConstraintInput( Property::Index index ) const
{
if( index < DEFAULT_PROPERTY_COUNT )
{
- return DEFAULT_PROPERTY_DETAILS[index].constraintInput;
- }
- else
- {
- return false;
+ return DEFAULT_PROPERTY_DETAILS[ index ].constraintInput;
}
+
+ return false;
}
-Property::Type Actor::GetDefaultPropertyType(Property::Index index) const
+Property::Type Actor::GetDefaultPropertyType( Property::Index index ) const
{
if( index < DEFAULT_PROPERTY_COUNT )
{
- return DEFAULT_PROPERTY_DETAILS[index].type;
- }
- else
- {
- // index out of range...return Property::NONE
- return Property::NONE;
+ return DEFAULT_PROPERTY_DETAILS[ index ].type;
}
+
+ // index out of range...return Property::NONE
+ return Property::NONE;
}
void Actor::SetDefaultProperty( Property::Index index, const Property::Value& property )
{
- switch ( index )
+ switch( index )
{
- case Dali::Actor::PARENT_ORIGIN:
+ case Dali::Actor::Property::PARENT_ORIGIN:
+ {
+ SetParentOrigin( property.Get< Vector3 >() );
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_X:
+ {
+ SetParentOriginX( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Y:
+ {
+ SetParentOriginY( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
+ {
+ SetParentOriginZ( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT:
+ {
+ SetAnchorPoint( property.Get< Vector3 >() );
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT_X:
+ {
+ SetAnchorPointX( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT_Y:
+ {
+ SetAnchorPointY( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
{
- SetParentOrigin( property.Get<Vector3>() );
+ SetAnchorPointZ( property.Get< float >() );
break;
}
- case Dali::Actor::PARENT_ORIGIN_X:
+ case Dali::Actor::Property::SIZE:
{
- SetParentOriginX( property.Get<float>() );
+ SetSize( property.Get< Vector3 >() );
break;
}
- case Dali::Actor::PARENT_ORIGIN_Y:
+ case Dali::Actor::Property::SIZE_WIDTH:
{
- SetParentOriginY( property.Get<float>() );
+ SetWidth( property.Get< float >() );
break;
}
- case Dali::Actor::PARENT_ORIGIN_Z:
+ case Dali::Actor::Property::SIZE_HEIGHT:
{
- SetParentOriginZ( property.Get<float>() );
+ SetHeight( property.Get< float >() );
break;
}
- case Dali::Actor::ANCHOR_POINT:
+ case Dali::Actor::Property::SIZE_DEPTH:
{
- SetAnchorPoint( property.Get<Vector3>() );
+ SetDepth( property.Get< float >() );
break;
}
- case Dali::Actor::ANCHOR_POINT_X:
+ case Dali::Actor::Property::POSITION:
{
- SetAnchorPointX( property.Get<float>() );
+ SetPosition( property.Get< Vector3 >() );
break;
}
- case Dali::Actor::ANCHOR_POINT_Y:
+ case Dali::Actor::Property::POSITION_X:
{
- SetAnchorPointY( property.Get<float>() );
+ SetX( property.Get< float >() );
break;
}
- case Dali::Actor::ANCHOR_POINT_Z:
+ case Dali::Actor::Property::POSITION_Y:
{
- SetAnchorPointZ( property.Get<float>() );
+ SetY( property.Get< float >() );
break;
}
- case Dali::Actor::SIZE:
+ case Dali::Actor::Property::POSITION_Z:
{
- SetSize( property.Get<Vector3>() );
+ SetZ( property.Get< float >() );
break;
}
- case Dali::Actor::SIZE_WIDTH:
+ case Dali::Actor::Property::ORIENTATION:
{
- SetWidth( property.Get<float>() );
+ SetOrientation( property.Get< Quaternion >() );
break;
}
- case Dali::Actor::SIZE_HEIGHT:
+ case Dali::Actor::Property::SCALE:
{
- SetHeight( property.Get<float>() );
+ SetScale( property.Get< Vector3 >() );
break;
}
- case Dali::Actor::SIZE_DEPTH:
+ case Dali::Actor::Property::SCALE_X:
{
- SetDepth( property.Get<float>() );
+ SetScaleX( property.Get< float >() );
break;
}
- case Dali::Actor::POSITION:
+ case Dali::Actor::Property::SCALE_Y:
{
- SetPosition( property.Get<Vector3>() );
+ SetScaleY( property.Get< float >() );
break;
}
- case Dali::Actor::POSITION_X:
+ case Dali::Actor::Property::SCALE_Z:
{
- SetX( property.Get<float>() );
+ SetScaleZ( property.Get< float >() );
break;
}
- case Dali::Actor::POSITION_Y:
+ case Dali::Actor::Property::VISIBLE:
{
- SetY( property.Get<float>() );
+ SetVisible( property.Get< bool >() );
break;
}
- case Dali::Actor::POSITION_Z:
+ case Dali::Actor::Property::COLOR:
{
- SetZ( property.Get<float>() );
+ SetColor( property.Get< Vector4 >() );
break;
}
- case Dali::Actor::ROTATION:
+ case Dali::Actor::Property::COLOR_RED:
{
- SetRotation( property.Get<Quaternion>() );
+ SetColorRed( property.Get< float >() );
break;
}
- case Dali::Actor::SCALE:
+ case Dali::Actor::Property::COLOR_GREEN:
{
- SetScale( property.Get<Vector3>() );
+ SetColorGreen( property.Get< float >() );
break;
}
- case Dali::Actor::SCALE_X:
+ case Dali::Actor::Property::COLOR_BLUE:
{
- SetScaleX( property.Get<float>() );
+ SetColorBlue( property.Get< float >() );
break;
}
- case Dali::Actor::SCALE_Y:
+ case Dali::Actor::Property::COLOR_ALPHA:
{
- SetScaleY( property.Get<float>() );
+ SetOpacity( property.Get< float >() );
break;
}
- case Dali::Actor::SCALE_Z:
+ case Dali::Actor::Property::NAME:
{
- SetScaleZ( property.Get<float>() );
+ SetName( property.Get< std::string >() );
break;
}
- case Dali::Actor::VISIBLE:
+ case Dali::Actor::Property::SENSITIVE:
{
- SetVisible( property.Get<bool>() );
+ SetSensitive( property.Get< bool >() );
break;
}
- case Dali::Actor::COLOR:
+ case Dali::Actor::Property::LEAVE_REQUIRED:
{
- SetColor( property.Get<Vector4>() );
+ SetLeaveRequired( property.Get< bool >() );
break;
}
- case Dali::Actor::COLOR_RED:
+ case Dali::Actor::Property::INHERIT_ORIENTATION:
{
- SetColorRed( property.Get<float>() );
+ SetInheritOrientation( property.Get< bool >() );
break;
}
- case Dali::Actor::COLOR_GREEN:
+ case Dali::Actor::Property::INHERIT_SCALE:
{
- SetColorGreen( property.Get<float>() );
+ SetInheritScale( property.Get< bool >() );
break;
}
- case Dali::Actor::COLOR_BLUE:
+ case Dali::Actor::Property::COLOR_MODE:
{
- SetColorBlue( property.Get<float>() );
+ SetColorMode( Scripting::GetColorMode( property.Get< std::string >() ) );
break;
}
- case Dali::Actor::COLOR_ALPHA:
+ case Dali::Actor::Property::POSITION_INHERITANCE:
{
- SetOpacity( property.Get<float>() );
+ SetPositionInheritanceMode( Scripting::GetPositionInheritanceMode( property.Get< std::string >() ) );
break;
}
- case Dali::Actor::NAME:
+ case Dali::Actor::Property::DRAW_MODE:
{
- SetName( property.Get<std::string>() );
+ SetDrawMode( Scripting::GetDrawMode( property.Get< std::string >() ) );
break;
}
- case Dali::Actor::SENSITIVE:
+ case Dali::Actor::Property::SIZE_MODE_FACTOR:
{
- SetSensitive( property.Get<bool>() );
+ SetSizeModeFactor( property.Get< Vector3 >() );
break;
}
- case Dali::Actor::LEAVE_REQUIRED:
+ case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
{
- SetLeaveRequired( property.Get<bool>() );
+ SetResizePolicy( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount ), Dimension::WIDTH );
break;
}
- case Dali::Actor::INHERIT_ROTATION:
+ case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
{
- SetInheritRotation( property.Get<bool>() );
+ SetResizePolicy( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount ), Dimension::HEIGHT );
break;
}
- case Dali::Actor::SIZE_MODE:
+ case Dali::Actor::Property::SIZE_SCALE_POLICY:
{
- SetSizeMode( Scripting::GetEnumeration< SizeMode >( property.Get<std::string>(), SIZE_MODE_TABLE, SIZE_MODE_TABLE_COUNT ) );
+ SetSizeScalePolicy( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount ) );
break;
}
- case Dali::Actor::SIZE_MODE_FACTOR:
+ case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
{
- SetSizeModeFactor( property.Get<Vector3>() );
+ if( property.Get< bool >() )
+ {
+ SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::WIDTH );
+ }
break;
}
- case Dali::Actor::INHERIT_SCALE:
+ case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
{
- SetInheritScale( property.Get<bool>() );
+ if( property.Get< bool >() )
+ {
+ SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::HEIGHT );
+ }
break;
}
- case Dali::Actor::COLOR_MODE:
+ case Dali::Actor::Property::PADDING:
{
- SetColorMode( Scripting::GetColorMode( property.Get<std::string>() ) );
+ Vector4 padding = property.Get< Vector4 >();
+ SetPadding( Vector2( padding.x, padding.y ), Dimension::WIDTH );
+ SetPadding( Vector2( padding.z, padding.w ), Dimension::HEIGHT );
break;
}
- case Dali::Actor::POSITION_INHERITANCE:
+ case Dali::Actor::Property::MINIMUM_SIZE:
{
- SetPositionInheritanceMode( Scripting::GetPositionInheritanceMode( property.Get<std::string>() ) );
+ Vector2 size = property.Get< Vector2 >();
+ SetMinimumSize( size.x, Dimension::WIDTH );
+ SetMinimumSize( size.y, Dimension::HEIGHT );
break;
}
- case Dali::Actor::DRAW_MODE:
+ case Dali::Actor::Property::MAXIMUM_SIZE:
{
- SetDrawMode( Scripting::GetDrawMode( property.Get<std::string>() ) );
+ Vector2 size = property.Get< Vector2 >();
+ SetMaximumSize( size.x, Dimension::WIDTH );
+ SetMaximumSize( size.y, Dimension::HEIGHT );
break;
}
}
// TODO: This method needs to be removed
-void Actor::SetSceneGraphProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value )
+void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value )
{
- OnPropertySet(index, value);
-
- switch ( entry.type )
+ switch( entry.type )
{
case Property::BOOLEAN:
{
- const AnimatableProperty<bool>* property = dynamic_cast< const AnimatableProperty<bool>* >( entry.GetSceneGraphProperty() );
+ const AnimatableProperty< bool >* property = dynamic_cast< const AnimatableProperty< bool >* >( entry.GetSceneGraphProperty() );
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<bool>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<bool>::Bake, value.Get<bool>() );
+ SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<bool>::Bake, value.Get<bool>() );
break;
}
- case Property::FLOAT:
+ case Property::INTEGER:
{
- const AnimatableProperty<float>* property = dynamic_cast< const AnimatableProperty<float>* >( entry.GetSceneGraphProperty() );
+ const AnimatableProperty< int >* property = dynamic_cast< const AnimatableProperty< int >* >( entry.GetSceneGraphProperty() );
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<float>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<float>::Bake, value.Get<float>() );
+ SceneGraph::NodePropertyMessage<int>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<int>::Bake, value.Get<int>() );
break;
}
- case Property::INTEGER:
+ case Property::UNSIGNED_INTEGER:
+ {
+ const AnimatableProperty< unsigned int >* property = dynamic_cast< const AnimatableProperty< unsigned int >* >( entry.GetSceneGraphProperty() );
+ DALI_ASSERT_DEBUG( NULL != property );
+
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<unsigned int>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<unsigned int>::Bake, value.Get<unsigned int>() );
+
+ break;
+ }
+
+ case Property::FLOAT:
{
- const AnimatableProperty<int>* property = dynamic_cast< const AnimatableProperty<int>* >( entry.GetSceneGraphProperty() );
+ const AnimatableProperty< float >* property = dynamic_cast< const AnimatableProperty< float >* >( entry.GetSceneGraphProperty() );
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<int>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<int>::Bake, value.Get<int>() );
+ SceneGraph::NodePropertyMessage<float>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<float>::Bake, value.Get<float>() );
break;
}
case Property::VECTOR2:
{
- const AnimatableProperty<Vector2>* property = dynamic_cast< const AnimatableProperty<Vector2>* >( entry.GetSceneGraphProperty() );
+ const AnimatableProperty< Vector2 >* property = dynamic_cast< const AnimatableProperty< Vector2 >* >( entry.GetSceneGraphProperty() );
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Vector2>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
+ SceneGraph::NodePropertyMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
break;
}
case Property::VECTOR3:
{
- const AnimatableProperty<Vector3>* property = dynamic_cast< const AnimatableProperty<Vector3>* >( entry.GetSceneGraphProperty() );
+ const AnimatableProperty< Vector3 >* property = dynamic_cast< const AnimatableProperty< Vector3 >* >( entry.GetSceneGraphProperty() );
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
+ SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
break;
}
case Property::VECTOR4:
{
- const AnimatableProperty<Vector4>* property = dynamic_cast< const AnimatableProperty<Vector4>* >( entry.GetSceneGraphProperty() );
+ const AnimatableProperty< Vector4 >* property = dynamic_cast< const AnimatableProperty< Vector4 >* >( entry.GetSceneGraphProperty() );
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Vector4>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
+ SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
break;
}
case Property::ROTATION:
{
- const AnimatableProperty<Quaternion>* property = dynamic_cast< const AnimatableProperty<Quaternion>* >( entry.GetSceneGraphProperty() );
+ const AnimatableProperty< Quaternion >* property = dynamic_cast< const AnimatableProperty< Quaternion >* >( entry.GetSceneGraphProperty() );
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Quaternion>::Send( mStage->GetUpdateManager(), mNode, property,&AnimatableProperty<Quaternion>::Bake, value.Get<Quaternion>() );
+ SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, property,&AnimatableProperty<Quaternion>::Bake, value.Get<Quaternion>() );
break;
}
case Property::MATRIX:
{
- const AnimatableProperty<Matrix>* property = dynamic_cast< const AnimatableProperty<Matrix>* >( entry.GetSceneGraphProperty() );
+ const AnimatableProperty< Matrix >* property = dynamic_cast< const AnimatableProperty< Matrix >* >( entry.GetSceneGraphProperty() );
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Matrix>::Send( mStage->GetUpdateManager(), mNode, property,&AnimatableProperty<Matrix>::Bake, value.Get<Matrix>() );
+ SceneGraph::NodePropertyMessage<Matrix>::Send( GetEventThreadServices(), mNode, property,&AnimatableProperty<Matrix>::Bake, value.Get<Matrix>() );
break;
}
case Property::MATRIX3:
{
- const AnimatableProperty<Matrix3>* property = dynamic_cast< const AnimatableProperty<Matrix3>* >( entry.GetSceneGraphProperty() );
+ const AnimatableProperty< Matrix3 >* property = dynamic_cast< const AnimatableProperty< Matrix3 >* >( entry.GetSceneGraphProperty() );
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Matrix3>::Send( mStage->GetUpdateManager(), mNode, property,&AnimatableProperty<Matrix3>::Bake, value.Get<Matrix3>() );
+ SceneGraph::NodePropertyMessage<Matrix3>::Send( GetEventThreadServices(), mNode, property,&AnimatableProperty<Matrix3>::Bake, value.Get<Matrix3>() );
break;
}
}
}
-Property::Value Actor::GetDefaultProperty(Property::Index index) const
+Property::Value Actor::GetDefaultProperty( Property::Index index ) const
{
Property::Value value;
- switch ( index )
+ switch( index )
{
- case Dali::Actor::PARENT_ORIGIN:
+ case Dali::Actor::Property::PARENT_ORIGIN:
{
value = GetCurrentParentOrigin();
break;
}
- case Dali::Actor::PARENT_ORIGIN_X:
+ case Dali::Actor::Property::PARENT_ORIGIN_X:
{
value = GetCurrentParentOrigin().x;
break;
}
- case Dali::Actor::PARENT_ORIGIN_Y:
+ case Dali::Actor::Property::PARENT_ORIGIN_Y:
{
value = GetCurrentParentOrigin().y;
break;
}
- case Dali::Actor::PARENT_ORIGIN_Z:
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
{
value = GetCurrentParentOrigin().z;
break;
}
- case Dali::Actor::ANCHOR_POINT:
+ case Dali::Actor::Property::ANCHOR_POINT:
{
value = GetCurrentAnchorPoint();
break;
}
- case Dali::Actor::ANCHOR_POINT_X:
+ case Dali::Actor::Property::ANCHOR_POINT_X:
{
value = GetCurrentAnchorPoint().x;
break;
}
- case Dali::Actor::ANCHOR_POINT_Y:
+ case Dali::Actor::Property::ANCHOR_POINT_Y:
{
value = GetCurrentAnchorPoint().y;
break;
}
- case Dali::Actor::ANCHOR_POINT_Z:
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
{
value = GetCurrentAnchorPoint().z;
break;
}
- case Dali::Actor::SIZE:
+ case Dali::Actor::Property::SIZE:
{
value = GetCurrentSize();
break;
}
- case Dali::Actor::SIZE_WIDTH:
+ case Dali::Actor::Property::SIZE_WIDTH:
{
value = GetCurrentSize().width;
break;
}
- case Dali::Actor::SIZE_HEIGHT:
+ case Dali::Actor::Property::SIZE_HEIGHT:
{
value = GetCurrentSize().height;
break;
}
- case Dali::Actor::SIZE_DEPTH:
+ case Dali::Actor::Property::SIZE_DEPTH:
{
value = GetCurrentSize().depth;
break;
}
- case Dali::Actor::POSITION:
+ case Dali::Actor::Property::POSITION:
{
value = GetCurrentPosition();
break;
}
- case Dali::Actor::POSITION_X:
+ case Dali::Actor::Property::POSITION_X:
{
value = GetCurrentPosition().x;
break;
}
- case Dali::Actor::POSITION_Y:
+ case Dali::Actor::Property::POSITION_Y:
{
value = GetCurrentPosition().y;
break;
}
- case Dali::Actor::POSITION_Z:
+ case Dali::Actor::Property::POSITION_Z:
{
value = GetCurrentPosition().z;
break;
}
- case Dali::Actor::WORLD_POSITION:
+ case Dali::Actor::Property::WORLD_POSITION:
{
value = GetCurrentWorldPosition();
break;
}
- case Dali::Actor::WORLD_POSITION_X:
+ case Dali::Actor::Property::WORLD_POSITION_X:
{
value = GetCurrentWorldPosition().x;
break;
}
- case Dali::Actor::WORLD_POSITION_Y:
+ case Dali::Actor::Property::WORLD_POSITION_Y:
{
value = GetCurrentWorldPosition().y;
break;
}
- case Dali::Actor::WORLD_POSITION_Z:
+ case Dali::Actor::Property::WORLD_POSITION_Z:
{
value = GetCurrentWorldPosition().z;
break;
}
- case Dali::Actor::ROTATION:
+ case Dali::Actor::Property::ORIENTATION:
{
- value = GetCurrentRotation();
+ value = GetCurrentOrientation();
break;
}
- case Dali::Actor::WORLD_ROTATION:
+ case Dali::Actor::Property::WORLD_ORIENTATION:
{
- value = GetCurrentWorldRotation();
+ value = GetCurrentWorldOrientation();
break;
}
- case Dali::Actor::SCALE:
+ case Dali::Actor::Property::SCALE:
{
value = GetCurrentScale();
break;
}
- case Dali::Actor::SCALE_X:
+ case Dali::Actor::Property::SCALE_X:
{
value = GetCurrentScale().x;
break;
}
- case Dali::Actor::SCALE_Y:
+ case Dali::Actor::Property::SCALE_Y:
{
value = GetCurrentScale().y;
break;
}
- case Dali::Actor::SCALE_Z:
+ case Dali::Actor::Property::SCALE_Z:
{
value = GetCurrentScale().z;
break;
}
- case Dali::Actor::WORLD_SCALE:
+ case Dali::Actor::Property::WORLD_SCALE:
{
value = GetCurrentWorldScale();
break;
}
- case Dali::Actor::VISIBLE:
+ case Dali::Actor::Property::VISIBLE:
{
value = IsVisible();
break;
}
- case Dali::Actor::COLOR:
+ case Dali::Actor::Property::COLOR:
{
value = GetCurrentColor();
break;
}
- case Dali::Actor::COLOR_RED:
+ case Dali::Actor::Property::COLOR_RED:
{
value = GetCurrentColor().r;
break;
}
- case Dali::Actor::COLOR_GREEN:
+ case Dali::Actor::Property::COLOR_GREEN:
{
value = GetCurrentColor().g;
break;
}
- case Dali::Actor::COLOR_BLUE:
+ case Dali::Actor::Property::COLOR_BLUE:
{
value = GetCurrentColor().b;
break;
}
- case Dali::Actor::COLOR_ALPHA:
+ case Dali::Actor::Property::COLOR_ALPHA:
{
value = GetCurrentColor().a;
break;
}
- case Dali::Actor::WORLD_COLOR:
+ case Dali::Actor::Property::WORLD_COLOR:
{
value = GetCurrentWorldColor();
break;
}
- case Dali::Actor::WORLD_MATRIX:
+ case Dali::Actor::Property::WORLD_MATRIX:
{
value = GetCurrentWorldMatrix();
break;
}
- case Dali::Actor::NAME:
+ case Dali::Actor::Property::NAME:
{
value = GetName();
break;
}
- case Dali::Actor::SENSITIVE:
+ case Dali::Actor::Property::SENSITIVE:
{
value = IsSensitive();
break;
}
- case Dali::Actor::LEAVE_REQUIRED:
+ case Dali::Actor::Property::LEAVE_REQUIRED:
{
value = GetLeaveRequired();
break;
}
- case Dali::Actor::INHERIT_ROTATION:
+ case Dali::Actor::Property::INHERIT_ORIENTATION:
+ {
+ value = IsOrientationInherited();
+ break;
+ }
+
+ case Dali::Actor::Property::INHERIT_SCALE:
+ {
+ value = IsScaleInherited();
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_MODE:
+ {
+ value = Scripting::GetColorMode( GetColorMode() );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_INHERITANCE:
{
- value = IsRotationInherited();
+ value = Scripting::GetPositionInheritanceMode( GetPositionInheritanceMode() );
break;
}
- case Dali::Actor::SIZE_MODE:
+ case Dali::Actor::Property::DRAW_MODE:
{
- value = Scripting::GetEnumerationName< SizeMode >( GetSizeMode(), SIZE_MODE_TABLE, SIZE_MODE_TABLE_COUNT );
+ value = Scripting::GetDrawMode( GetDrawMode() );
break;
}
- case Dali::Actor::SIZE_MODE_FACTOR:
+ case Dali::Actor::Property::SIZE_MODE_FACTOR:
{
value = GetSizeModeFactor();
break;
}
- case Dali::Actor::INHERIT_SCALE:
+ case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
{
- value = IsScaleInherited();
+ value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::WIDTH ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount );
break;
}
- case Dali::Actor::COLOR_MODE:
+ case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
{
- value = Scripting::GetColorMode( GetColorMode() );
+ value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::HEIGHT ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount );
break;
}
- case Dali::Actor::POSITION_INHERITANCE:
+ case Dali::Actor::Property::SIZE_SCALE_POLICY:
{
- value = Scripting::GetPositionInheritanceMode( GetPositionInheritanceMode() );
+ value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount );
break;
}
- case Dali::Actor::DRAW_MODE:
+ case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
{
- value = Scripting::GetDrawMode( GetDrawMode() );
+ value = ( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::WIDTH ) == Dimension::HEIGHT );
+ break;
+ }
+
+ case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
+ {
+ value = ( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::HEIGHT ) == Dimension::WIDTH );
+ break;
+ }
+
+ case Dali::Actor::Property::PADDING:
+ {
+ Vector2 widthPadding = GetPadding( Dimension::WIDTH );
+ Vector2 heightPadding = GetPadding( Dimension::HEIGHT );
+ value = Vector4( widthPadding.x, widthPadding.y, heightPadding.x, heightPadding.y );
+ break;
+ }
+
+ case Dali::Actor::Property::MINIMUM_SIZE:
+ {
+ value = Vector2( GetMinimumSize( Dimension::WIDTH ), GetMinimumSize( Dimension::HEIGHT ) );
+ break;
+ }
+
+ case Dali::Actor::Property::MAXIMUM_SIZE:
+ {
+ value = Vector2( GetMaximumSize( Dimension::WIDTH ), GetMaximumSize( Dimension::HEIGHT ) );
break;
}
default:
{
- DALI_ASSERT_ALWAYS(false && "Actor Property index invalid" ); // should not come here
+ DALI_ASSERT_ALWAYS( false && "Actor Property index invalid" ); // should not come here
break;
}
}
const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index index ) const
{
- DALI_ASSERT_ALWAYS( IsPropertyAnimatable(index) && "Property is not animatable" );
+ DALI_ASSERT_ALWAYS( IsPropertyAnimatable( index ) && "Property is not animatable" );
const PropertyBase* property( NULL );
// This method should only return a property of an object connected to the scene-graph
- if ( !OnStage() )
+ if( !OnStage() )
{
return property;
}
- if ( static_cast<unsigned int>(index) >= DEFAULT_PROPERTY_MAX_COUNT )
+ if ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX && index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )
{
- CustomProperty* custom = FindCustomProperty( index );
+ AnimatablePropertyMetadata* animatable = FindAnimatableProperty( index );
+ if( !animatable )
+ {
+ const TypeInfo* typeInfo( GetTypeInfo() );
+ if ( typeInfo )
+ {
+ if( Property::INVALID_INDEX != RegisterSceneGraphProperty( typeInfo->GetPropertyName( index ), index, Property::Value( typeInfo->GetPropertyType( index ) ) ) )
+ {
+ animatable = FindAnimatableProperty( index );
+ }
+ }
+ }
+ DALI_ASSERT_ALWAYS( animatable && "Property index is invalid" );
+
+ property = animatable->GetSceneGraphProperty();
+ }
+ else if ( index >= DEFAULT_PROPERTY_MAX_COUNT )
+ {
+ CustomPropertyMetadata* custom = FindCustomProperty( index );
DALI_ASSERT_ALWAYS( custom && "Property index is invalid" );
property = custom->GetSceneGraphProperty();
}
else if( NULL != mNode )
{
- switch ( index )
+ switch( index )
{
- case Dali::Actor::SIZE:
+ case Dali::Actor::Property::SIZE:
property = &mNode->mSize;
break;
- case Dali::Actor::SIZE_WIDTH:
+ case Dali::Actor::Property::SIZE_WIDTH:
property = &mNode->mSize;
break;
- case Dali::Actor::SIZE_HEIGHT:
+ case Dali::Actor::Property::SIZE_HEIGHT:
property = &mNode->mSize;
break;
- case Dali::Actor::SIZE_DEPTH:
+ case Dali::Actor::Property::SIZE_DEPTH:
property = &mNode->mSize;
break;
- case Dali::Actor::POSITION:
+ case Dali::Actor::Property::POSITION:
property = &mNode->mPosition;
break;
- case Dali::Actor::POSITION_X:
+ case Dali::Actor::Property::POSITION_X:
property = &mNode->mPosition;
break;
- case Dali::Actor::POSITION_Y:
+ case Dali::Actor::Property::POSITION_Y:
property = &mNode->mPosition;
break;
- case Dali::Actor::POSITION_Z:
+ case Dali::Actor::Property::POSITION_Z:
property = &mNode->mPosition;
break;
- case Dali::Actor::ROTATION:
- property = &mNode->mRotation;
+ case Dali::Actor::Property::ORIENTATION:
+ property = &mNode->mOrientation;
break;
- case Dali::Actor::SCALE:
+ case Dali::Actor::Property::SCALE:
property = &mNode->mScale;
break;
- case Dali::Actor::SCALE_X:
+ case Dali::Actor::Property::SCALE_X:
property = &mNode->mScale;
break;
- case Dali::Actor::SCALE_Y:
+ case Dali::Actor::Property::SCALE_Y:
property = &mNode->mScale;
break;
- case Dali::Actor::SCALE_Z:
+ case Dali::Actor::Property::SCALE_Z:
property = &mNode->mScale;
break;
- case Dali::Actor::VISIBLE:
+ case Dali::Actor::Property::VISIBLE:
property = &mNode->mVisible;
break;
- case Dali::Actor::COLOR:
+ case Dali::Actor::Property::COLOR:
property = &mNode->mColor;
break;
- case Dali::Actor::COLOR_RED:
+ case Dali::Actor::Property::COLOR_RED:
property = &mNode->mColor;
break;
- case Dali::Actor::COLOR_GREEN:
+ case Dali::Actor::Property::COLOR_GREEN:
property = &mNode->mColor;
break;
- case Dali::Actor::COLOR_BLUE:
+ case Dali::Actor::Property::COLOR_BLUE:
property = &mNode->mColor;
break;
- case Dali::Actor::COLOR_ALPHA:
+ case Dali::Actor::Property::COLOR_ALPHA:
property = &mNode->mColor;
break;
const PropertyInputImpl* property( NULL );
// This method should only return a property of an object connected to the scene-graph
- if ( !OnStage() )
+ if( !OnStage() )
{
return property;
}
- if ( index >= DEFAULT_PROPERTY_MAX_COUNT )
+ if ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX && index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )
+ {
+ AnimatablePropertyMetadata* animatable = FindAnimatableProperty( index );
+ if( !animatable )
+ {
+ const TypeInfo* typeInfo( GetTypeInfo() );
+ if ( typeInfo )
+ {
+ if( Property::INVALID_INDEX != RegisterSceneGraphProperty( typeInfo->GetPropertyName( index ), index, Property::Value( typeInfo->GetPropertyType( index ) ) ) )
+ {
+ animatable = FindAnimatableProperty( index );
+ }
+ }
+ }
+ DALI_ASSERT_ALWAYS( animatable && "Property index is invalid" );
+
+ property = animatable->GetSceneGraphProperty();
+ }
+ else if ( index >= DEFAULT_PROPERTY_MAX_COUNT )
{
- CustomProperty* custom = FindCustomProperty( index );
+ CustomPropertyMetadata* custom = FindCustomProperty( index );
DALI_ASSERT_ALWAYS( custom && "Property index is invalid" );
property = custom->GetSceneGraphProperty();
}
else if( NULL != mNode )
{
- switch ( index )
+ switch( index )
{
- case Dali::Actor::PARENT_ORIGIN:
+ case Dali::Actor::Property::PARENT_ORIGIN:
property = &mNode->mParentOrigin;
break;
- case Dali::Actor::PARENT_ORIGIN_X:
+ case Dali::Actor::Property::PARENT_ORIGIN_X:
property = &mNode->mParentOrigin;
break;
- case Dali::Actor::PARENT_ORIGIN_Y:
+ case Dali::Actor::Property::PARENT_ORIGIN_Y:
property = &mNode->mParentOrigin;
break;
- case Dali::Actor::PARENT_ORIGIN_Z:
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
property = &mNode->mParentOrigin;
break;
- case Dali::Actor::ANCHOR_POINT:
+ case Dali::Actor::Property::ANCHOR_POINT:
property = &mNode->mAnchorPoint;
break;
- case Dali::Actor::ANCHOR_POINT_X:
+ case Dali::Actor::Property::ANCHOR_POINT_X:
property = &mNode->mAnchorPoint;
break;
- case Dali::Actor::ANCHOR_POINT_Y:
+ case Dali::Actor::Property::ANCHOR_POINT_Y:
property = &mNode->mAnchorPoint;
break;
- case Dali::Actor::ANCHOR_POINT_Z:
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
property = &mNode->mAnchorPoint;
break;
- case Dali::Actor::SIZE:
+ case Dali::Actor::Property::SIZE:
property = &mNode->mSize;
break;
- case Dali::Actor::SIZE_WIDTH:
+ case Dali::Actor::Property::SIZE_WIDTH:
property = &mNode->mSize;
break;
- case Dali::Actor::SIZE_HEIGHT:
+ case Dali::Actor::Property::SIZE_HEIGHT:
property = &mNode->mSize;
break;
- case Dali::Actor::SIZE_DEPTH:
+ case Dali::Actor::Property::SIZE_DEPTH:
property = &mNode->mSize;
break;
- case Dali::Actor::POSITION:
+ case Dali::Actor::Property::POSITION:
property = &mNode->mPosition;
break;
- case Dali::Actor::POSITION_X:
+ case Dali::Actor::Property::POSITION_X:
property = &mNode->mPosition;
break;
- case Dali::Actor::POSITION_Y:
+ case Dali::Actor::Property::POSITION_Y:
property = &mNode->mPosition;
break;
- case Dali::Actor::POSITION_Z:
+ case Dali::Actor::Property::POSITION_Z:
property = &mNode->mPosition;
break;
- case Dali::Actor::WORLD_POSITION:
+ case Dali::Actor::Property::WORLD_POSITION:
property = &mNode->mWorldPosition;
break;
- case Dali::Actor::WORLD_POSITION_X:
+ case Dali::Actor::Property::WORLD_POSITION_X:
property = &mNode->mWorldPosition;
break;
- case Dali::Actor::WORLD_POSITION_Y:
+ case Dali::Actor::Property::WORLD_POSITION_Y:
property = &mNode->mWorldPosition;
break;
- case Dali::Actor::WORLD_POSITION_Z:
+ case Dali::Actor::Property::WORLD_POSITION_Z:
property = &mNode->mWorldPosition;
break;
- case Dali::Actor::ROTATION:
- property = &mNode->mRotation;
+ case Dali::Actor::Property::ORIENTATION:
+ property = &mNode->mOrientation;
break;
- case Dali::Actor::WORLD_ROTATION:
- property = &mNode->mWorldRotation;
+ case Dali::Actor::Property::WORLD_ORIENTATION:
+ property = &mNode->mWorldOrientation;
break;
- case Dali::Actor::SCALE:
+ case Dali::Actor::Property::SCALE:
property = &mNode->mScale;
break;
- case Dali::Actor::SCALE_X:
+ case Dali::Actor::Property::SCALE_X:
property = &mNode->mScale;
break;
- case Dali::Actor::SCALE_Y:
+ case Dali::Actor::Property::SCALE_Y:
property = &mNode->mScale;
break;
- case Dali::Actor::SCALE_Z:
+ case Dali::Actor::Property::SCALE_Z:
property = &mNode->mScale;
break;
- case Dali::Actor::WORLD_SCALE:
+ case Dali::Actor::Property::WORLD_SCALE:
property = &mNode->mWorldScale;
break;
- case Dali::Actor::VISIBLE:
+ case Dali::Actor::Property::VISIBLE:
property = &mNode->mVisible;
break;
- case Dali::Actor::COLOR:
+ case Dali::Actor::Property::COLOR:
property = &mNode->mColor;
break;
- case Dali::Actor::COLOR_RED:
+ case Dali::Actor::Property::COLOR_RED:
property = &mNode->mColor;
break;
- case Dali::Actor::COLOR_GREEN:
+ case Dali::Actor::Property::COLOR_GREEN:
property = &mNode->mColor;
break;
- case Dali::Actor::COLOR_BLUE:
+ case Dali::Actor::Property::COLOR_BLUE:
property = &mNode->mColor;
break;
- case Dali::Actor::COLOR_ALPHA:
+ case Dali::Actor::Property::COLOR_ALPHA:
property = &mNode->mColor;
break;
- case Dali::Actor::WORLD_COLOR:
+ case Dali::Actor::Property::WORLD_COLOR:
property = &mNode->mWorldColor;
break;
- case Dali::Actor::WORLD_MATRIX:
+ case Dali::Actor::Property::WORLD_MATRIX:
property = &mNode->mWorldMatrix;
break;
{
int componentIndex( Property::INVALID_COMPONENT_INDEX );
- switch ( index )
+ switch( index )
{
- case Dali::Actor::PARENT_ORIGIN_X:
- case Dali::Actor::ANCHOR_POINT_X:
- case Dali::Actor::SIZE_WIDTH:
- case Dali::Actor::POSITION_X:
- case Dali::Actor::SCALE_X:
- case Dali::Actor::COLOR_RED:
- case Dali::Actor::WORLD_POSITION_X:
+ case Dali::Actor::Property::PARENT_ORIGIN_X:
+ case Dali::Actor::Property::ANCHOR_POINT_X:
+ case Dali::Actor::Property::SIZE_WIDTH:
+ case Dali::Actor::Property::POSITION_X:
+ case Dali::Actor::Property::WORLD_POSITION_X:
+ case Dali::Actor::Property::SCALE_X:
+ case Dali::Actor::Property::COLOR_RED:
{
componentIndex = 0;
break;
}
- case Dali::Actor::PARENT_ORIGIN_Y:
- case Dali::Actor::ANCHOR_POINT_Y:
- case Dali::Actor::SIZE_HEIGHT:
- case Dali::Actor::POSITION_Y:
- case Dali::Actor::SCALE_Y:
- case Dali::Actor::COLOR_GREEN:
- case Dali::Actor::WORLD_POSITION_Y:
+ case Dali::Actor::Property::PARENT_ORIGIN_Y:
+ case Dali::Actor::Property::ANCHOR_POINT_Y:
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ case Dali::Actor::Property::POSITION_Y:
+ case Dali::Actor::Property::WORLD_POSITION_Y:
+ case Dali::Actor::Property::SCALE_Y:
+ case Dali::Actor::Property::COLOR_GREEN:
{
componentIndex = 1;
break;
}
- case Dali::Actor::PARENT_ORIGIN_Z:
- case Dali::Actor::ANCHOR_POINT_Z:
- case Dali::Actor::SIZE_DEPTH:
- case Dali::Actor::POSITION_Z:
- case Dali::Actor::SCALE_Z:
- case Dali::Actor::COLOR_BLUE:
- case Dali::Actor::WORLD_POSITION_Z:
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
+ case Dali::Actor::Property::SIZE_DEPTH:
+ case Dali::Actor::Property::POSITION_Z:
+ case Dali::Actor::Property::WORLD_POSITION_Z:
+ case Dali::Actor::Property::SCALE_Z:
+ case Dali::Actor::Property::COLOR_BLUE:
{
componentIndex = 2;
break;
}
- case Dali::Actor::COLOR_ALPHA:
+ case Dali::Actor::Property::COLOR_ALPHA:
{
componentIndex = 3;
break;
return componentIndex;
}
-void Actor::SetParent(Actor* parent, int index)
+void Actor::SetParent( Actor* parent, int index )
{
if( parent )
{
mParent = parent;
- if ( Stage::IsInstalled() && // Don't emit signals or send messages during Core destruction
+ if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
parent->OnStage() )
{
// Instruct each actor to create a corresponding node in the scene graph
mParent = NULL;
- if ( Stage::IsInstalled() && // Don't emit signals or send messages during Core destruction
+ if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
OnStage() )
{
- DALI_ASSERT_ALWAYS(mNode != NULL);
+ DALI_ASSERT_ALWAYS( mNode != NULL );
if( NULL != mNode )
{
// Disconnect the Node & its children from the scene-graph.
- DisconnectNodeMessage( mStage->GetUpdateManager(), *mNode );
+ DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *mNode );
}
// Instruct each actor to discard pointers to the scene-graph
return Node::New();
}
-bool Actor::DoAction(BaseObject* object, const std::string& actionName, const std::vector<Property::Value>& attributes)
+bool Actor::DoAction( BaseObject* object, const std::string& actionName, const std::vector< Property::Value >& attributes )
{
bool done = false;
- Actor* actor = dynamic_cast<Actor*>(object);
+ Actor* actor = dynamic_cast< Actor* >( object );
if( actor )
{
- if(Dali::Actor::ACTION_SHOW == actionName)
+ if( 0 == strcmp( actionName.c_str(), ACTION_SHOW ) ) // dont want to convert char* to string
{
- actor->SetVisible(true);
+ actor->SetVisible( true );
done = true;
}
- else if(Dali::Actor::ACTION_HIDE == actionName)
+ else if( 0 == strcmp( actionName.c_str(), ACTION_HIDE ) )
{
- actor->SetVisible(false);
+ actor->SetVisible( false );
done = true;
}
}
return done;
}
+void Actor::EnsureRelayoutData() const
+{
+ // Assign relayout data.
+ if( !mRelayoutData )
+ {
+ mRelayoutData = new RelayoutData();
+ }
+}
+
+bool Actor::RelayoutDependentOnParent( Dimension::Type dimension )
+{
+ // Check if actor is dependent on parent
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ const ResizePolicy::Type resizePolicy = GetResizePolicy( static_cast< Dimension::Type >( 1 << i ) );
+ if( resizePolicy == ResizePolicy::FILL_TO_PARENT || resizePolicy == ResizePolicy::SIZE_RELATIVE_TO_PARENT || resizePolicy == ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT )
+ {
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+bool Actor::RelayoutDependentOnChildren( Dimension::Type dimension )
+{
+ // Check if actor is dependent on children
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ const ResizePolicy::Type resizePolicy = GetResizePolicy( static_cast< Dimension::Type >( 1 << i ) );
+ switch( resizePolicy )
+ {
+ case ResizePolicy::FIT_TO_CHILDREN:
+ case ResizePolicy::USE_NATURAL_SIZE: // i.e. For things that calculate their size based on children
+ {
+ return true;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
+bool Actor::RelayoutDependentOnChildrenBase( Dimension::Type dimension )
+{
+ return Actor::RelayoutDependentOnChildren( dimension );
+}
+
+bool Actor::RelayoutDependentOnDimension( Dimension::Type dimension, Dimension::Type dependentDimension )
+{
+ // Check each possible dimension and see if it is dependent on the input one
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ return mRelayoutData->resizePolicies[ i ] == ResizePolicy::DIMENSION_DEPENDENCY && mRelayoutData->dimensionDependencies[ i ] == dependentDimension;
+ }
+ }
+
+ return false;
+}
+
+void Actor::SetNegotiatedDimension( float negotiatedDimension, Dimension::Type dimension )
+{
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ mRelayoutData->negotiatedDimensions[ i ] = negotiatedDimension;
+ }
+ }
+}
+
+float Actor::GetNegotiatedDimension( Dimension::Type dimension ) const
+{
+ // If more than one dimension is requested, just return the first one found
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ return mRelayoutData->negotiatedDimensions[ i ];
+ }
+ }
+
+ return 0.0f; // Default
+}
+
+void Actor::SetPadding( const Vector2& padding, Dimension::Type dimension )
+{
+ EnsureRelayoutData();
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ mRelayoutData->dimensionPadding[ i ] = padding;
+ }
+ }
+}
+
+Vector2 Actor::GetPadding( Dimension::Type dimension ) const
+{
+ EnsureRelayoutData();
+
+ // If more than one dimension is requested, just return the first one found
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ return mRelayoutData->dimensionPadding[ i ];
+ }
+ }
+
+ return Vector2( 0.0f, 0.0f ); // Default
+}
+
+void Actor::SetLayoutNegotiated( bool negotiated, Dimension::Type dimension )
+{
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ mRelayoutData->dimensionNegotiated[ i ] = negotiated;
+ }
+ }
+}
+
+bool Actor::IsLayoutNegotiated( Dimension::Type dimension ) const
+{
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionNegotiated[ i ] )
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+float Actor::CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
+{
+ // Could be overridden in derived classes.
+ return CalculateChildSizeBase( child, dimension );
+}
+
+float Actor::CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension )
+{
+ // Fill to parent, taking size mode factor into account
+ switch( child.GetResizePolicy( dimension ) )
+ {
+ case ResizePolicy::FILL_TO_PARENT:
+ {
+ return GetLatestSize( dimension );
+ }
+
+ case ResizePolicy::SIZE_RELATIVE_TO_PARENT:
+ {
+ return GetLatestSize( dimension ) * GetDimensionValue( child.GetSizeModeFactor(), dimension );
+ }
+
+ case ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT:
+ {
+ return GetLatestSize( dimension ) + GetDimensionValue( child.GetSizeModeFactor(), dimension );
+ }
+
+ default:
+ {
+ return GetLatestSize( dimension );
+ }
+ }
+}
+
+float Actor::GetHeightForWidth( float width )
+{
+ // Could be overridden in derived classes.
+ float height = 0.0f;
+
+ const Vector3 naturalSize = GetNaturalSize();
+ if( naturalSize.width > 0.0f )
+ {
+ height = naturalSize.height * width / naturalSize.width;
+ }
+
+ return height;
+}
+
+float Actor::GetWidthForHeight( float height )
+{
+ // Could be overridden in derived classes.
+ float width = 0.0f;
+
+ const Vector3 naturalSize = GetNaturalSize();
+ if( naturalSize.height > 0.0f )
+ {
+ width = naturalSize.width * height / naturalSize.height;
+ }
+
+ return width;
+}
+
+float Actor::GetLatestSize( Dimension::Type dimension ) const
+{
+ return IsLayoutNegotiated( dimension ) ? GetNegotiatedDimension( dimension ) : GetSize( dimension );
+}
+
+float Actor::GetRelayoutSize( Dimension::Type dimension ) const
+{
+ Vector2 padding = GetPadding( dimension );
+
+ return GetLatestSize( dimension ) + padding.x + padding.y;
+}
+
+float Actor::NegotiateFromParent( Dimension::Type dimension )
+{
+ Actor* parent = GetParent();
+ if( parent )
+ {
+ Vector2 padding( GetPadding( dimension ) );
+ Vector2 parentPadding( parent->GetPadding( dimension ) );
+ return parent->CalculateChildSize( Dali::Actor( this ), dimension ) - parentPadding.x - parentPadding.y - padding.x - padding.y;
+ }
+
+ return 0.0f;
+}
+
+float Actor::NegotiateFromChildren( Dimension::Type dimension )
+{
+ float maxDimensionPoint = 0.0f;
+
+ for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
+ {
+ Dali::Actor child = GetChildAt( i );
+ Actor& childImpl = GetImplementation( child );
+
+ if( !childImpl.RelayoutDependentOnParent( dimension ) )
+ {
+ // Calculate the min and max points that the children range across
+ float childPosition = GetDimensionValue( childImpl.GetTargetPosition(), dimension );
+ float dimensionSize = childImpl.GetRelayoutSize( dimension );
+ maxDimensionPoint = std::max( maxDimensionPoint, childPosition + dimensionSize );
+ }
+ }
+
+ return maxDimensionPoint;
+}
+
+float Actor::GetSize( Dimension::Type dimension ) const
+{
+ return GetDimensionValue( GetTargetSize(), dimension );
+}
+
+float Actor::GetNaturalSize( Dimension::Type dimension ) const
+{
+ return GetDimensionValue( GetNaturalSize(), dimension );
+}
+
+float Actor::CalculateSize( Dimension::Type dimension, const Vector2& maximumSize )
+{
+ switch( GetResizePolicy( dimension ) )
+ {
+ case ResizePolicy::USE_NATURAL_SIZE:
+ {
+ return GetNaturalSize( dimension );
+ }
+
+ case ResizePolicy::FIXED:
+ {
+ return GetDimensionValue( GetPreferredSize(), dimension );
+ }
+
+ case ResizePolicy::USE_ASSIGNED_SIZE:
+ {
+ return GetDimensionValue( maximumSize, dimension );
+ }
+
+ case ResizePolicy::FILL_TO_PARENT:
+ case ResizePolicy::SIZE_RELATIVE_TO_PARENT:
+ case ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT:
+ {
+ return NegotiateFromParent( dimension );
+ }
+
+ case ResizePolicy::FIT_TO_CHILDREN:
+ {
+ return NegotiateFromChildren( dimension );
+ }
+
+ case ResizePolicy::DIMENSION_DEPENDENCY:
+ {
+ const Dimension::Type dimensionDependency = GetDimensionDependency( dimension );
+
+ // Custom rules
+ if( dimension == Dimension::WIDTH && dimensionDependency == Dimension::HEIGHT )
+ {
+ return GetWidthForHeight( GetNegotiatedDimension( Dimension::HEIGHT ) );
+ }
+
+ if( dimension == Dimension::HEIGHT && dimensionDependency == Dimension::WIDTH )
+ {
+ return GetHeightForWidth( GetNegotiatedDimension( Dimension::WIDTH ) );
+ }
+
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+
+ return 0.0f; // Default
+}
+
+float Actor::ClampDimension( float size, Dimension::Type dimension )
+{
+ const float minSize = GetMinimumSize( dimension );
+ const float maxSize = GetMaximumSize( dimension );
+
+ return std::max( minSize, std::min( size, maxSize ) );
+}
+
+void Actor::NegotiateDimension( Dimension::Type dimension, const Vector2& allocatedSize, ActorDimensionStack& recursionStack )
+{
+ // Check if it needs to be negotiated
+ if( IsLayoutDirty( dimension ) && !IsLayoutNegotiated( dimension ) )
+ {
+ // Check that we havn't gotten into an infinite loop
+ ActorDimensionPair searchActor = ActorDimensionPair( this, dimension );
+ bool recursionFound = false;
+ for( ActorDimensionStack::iterator it = recursionStack.begin(), itEnd = recursionStack.end(); it != itEnd; ++it )
+ {
+ if( *it == searchActor )
+ {
+ recursionFound = true;
+ break;
+ }
+ }
+
+ if( !recursionFound )
+ {
+ // Record the path that we have taken
+ recursionStack.push_back( ActorDimensionPair( this, dimension ) );
+
+ // Dimension dependency check
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ Dimension::Type dimensionToCheck = static_cast< Dimension::Type >( 1 << i );
+
+ if( RelayoutDependentOnDimension( dimension, dimensionToCheck ) )
+ {
+ NegotiateDimension( dimensionToCheck, allocatedSize, recursionStack );
+ }
+ }
+
+ // Parent dependency check
+ Actor* parent = GetParent();
+ if( parent && RelayoutDependentOnParent( dimension ) )
+ {
+ parent->NegotiateDimension( dimension, allocatedSize, recursionStack );
+ }
+
+ // Children dependency check
+ if( RelayoutDependentOnChildren( dimension ) )
+ {
+ for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
+ {
+ Dali::Actor child = GetChildAt( i );
+ Actor& childImpl = GetImplementation( child );
+
+ // Only relayout child first if it is not dependent on this actor
+ if( !childImpl.RelayoutDependentOnParent( dimension ) )
+ {
+ childImpl.NegotiateDimension( dimension, allocatedSize, recursionStack );
+ }
+ }
+ }
+
+ // For deriving classes
+ OnCalculateRelayoutSize( dimension );
+
+ // All dependencies checked, calculate the size and set negotiated flag
+ const float newSize = ClampDimension( CalculateSize( dimension, allocatedSize ), dimension );
+
+ SetNegotiatedDimension( newSize, dimension );
+ SetLayoutNegotiated( true, dimension );
+
+ // For deriving classes
+ OnLayoutNegotiated( newSize, dimension );
+
+ // This actor has been successfully processed, pop it off the recursion stack
+ recursionStack.pop_back();
+ }
+ else
+ {
+ // TODO: Break infinite loop
+ SetLayoutNegotiated( true, dimension );
+ }
+ }
+}
+
+void Actor::NegotiateDimensions( const Vector2& allocatedSize )
+{
+ // Negotiate all dimensions that require it
+ ActorDimensionStack recursionStack;
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ const Dimension::Type dimension = static_cast< Dimension::Type >( 1 << i );
+
+ // Negotiate
+ NegotiateDimension( dimension, allocatedSize, recursionStack );
+ }
+}
+
+Vector2 Actor::ApplySizeSetPolicy( const Vector2 size )
+{
+ switch( mRelayoutData->sizeSetPolicy )
+ {
+ case SizeScalePolicy::USE_SIZE_SET:
+ {
+ return size;
+ }
+
+ case SizeScalePolicy::FIT_WITH_ASPECT_RATIO:
+ {
+ // Scale size to fit within the original size bounds, keeping the natural size aspect ratio
+ const Vector3 naturalSize = GetNaturalSize();
+ if( naturalSize.width > 0.0f && naturalSize.height > 0.0f && size.width > 0.0f && size.height > 0.0f )
+ {
+ const float sizeRatio = size.width / size.height;
+ const float naturalSizeRatio = naturalSize.width / naturalSize.height;
+
+ if( naturalSizeRatio < sizeRatio )
+ {
+ return Vector2( naturalSizeRatio * size.height, size.height );
+ }
+ else if( naturalSizeRatio > sizeRatio )
+ {
+ return Vector2( size.width, size.width / naturalSizeRatio );
+ }
+ else
+ {
+ return size;
+ }
+ }
+
+ break;
+ }
+
+ case SizeScalePolicy::FILL_WITH_ASPECT_RATIO:
+ {
+ // Scale size to fill the original size bounds, keeping the natural size aspect ratio. Potentially exceeding the original bounds.
+ const Vector3 naturalSize = GetNaturalSize();
+ if( naturalSize.width > 0.0f && naturalSize.height > 0.0f && size.width > 0.0f && size.height > 0.0f )
+ {
+ const float sizeRatio = size.width / size.height;
+ const float naturalSizeRatio = naturalSize.width / naturalSize.height;
+
+ if( naturalSizeRatio < sizeRatio )
+ {
+ return Vector2( size.width, size.width / naturalSizeRatio );
+ }
+ else if( naturalSizeRatio > sizeRatio )
+ {
+ return Vector2( naturalSizeRatio * size.height, size.height );
+ }
+ else
+ {
+ return size;
+ }
+ }
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+
+ return size;
+}
+
+void Actor::SetNegotiatedSize( RelayoutContainer& container )
+{
+ // Do the set actor size
+ Vector2 negotiatedSize( GetLatestSize( Dimension::WIDTH ), GetLatestSize( Dimension::HEIGHT ) );
+
+ // Adjust for size set policy
+ negotiatedSize = ApplySizeSetPolicy( negotiatedSize );
+
+ // Lock the flag to stop recursive relayouts on set size
+ mRelayoutData->insideRelayout = true;
+ SetSize( negotiatedSize );
+ mRelayoutData->insideRelayout = false;
+
+ // Clear flags for all dimensions
+ SetLayoutDirty( false );
+
+ // Give deriving classes a chance to respond
+ OnRelayout( negotiatedSize, container );
+
+ if( !mOnRelayoutSignal.Empty() )
+ {
+ Dali::Actor handle( this );
+ mOnRelayoutSignal.Emit( handle );
+ }
+}
+
+void Actor::NegotiateSize( const Vector2& allocatedSize, RelayoutContainer& container )
+{
+ // Do the negotiation
+ NegotiateDimensions( allocatedSize );
+
+ // Set the actor size
+ SetNegotiatedSize( container );
+
+ // Negotiate down to children
+ const Vector2 newBounds = GetTargetSize().GetVectorXY();
+
+ for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
+ {
+ Dali::Actor child = GetChildAt( i );
+
+ // Only relayout if required
+ if( GetImplementation( child ).RelayoutRequired() )
+ {
+ container.Add( child, newBounds );
+ }
+ }
+}
+
+void Actor::RelayoutRequest( Dimension::Type dimension )
+{
+ Internal::RelayoutController* relayoutController = Internal::RelayoutController::Get();
+ if( relayoutController )
+ {
+ Dali::Actor self( this );
+ relayoutController->RequestRelayout( self, dimension );
+ }
+}
+
+void Actor::PropagateRelayoutFlags()
+{
+ Internal::RelayoutController* relayoutController = Internal::RelayoutController::Get();
+ if( relayoutController )
+ {
+ Dali::Actor self( this );
+ relayoutController->PropagateFlags( self );
+ }
+}
+
+void Actor::OnCalculateRelayoutSize( Dimension::Type dimension )
+{
+}
+
+void Actor::OnLayoutNegotiated( float size, Dimension::Type dimension )
+{
+}
+
+void Actor::SetPreferredSize( const Vector2& size )
+{
+ EnsureRelayoutData();
+
+ if( size.width > 0.0f )
+ {
+ SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
+ }
+
+ if( size.height > 0.0f )
+ {
+ SetResizePolicy( ResizePolicy::FIXED, Dimension::HEIGHT );
+ }
+
+ mRelayoutData->preferredSize = size;
+
+ RelayoutRequest();
+}
+
+Vector2 Actor::GetPreferredSize() const
+{
+ EnsureRelayoutData();
+
+ return mRelayoutData->preferredSize;
+}
+
+void Actor::SetMinimumSize( float size, Dimension::Type dimension )
+{
+ EnsureRelayoutData();
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ mRelayoutData->minimumSize[ i ] = size;
+ }
+ }
+
+ RelayoutRequest();
+}
+
+float Actor::GetMinimumSize( Dimension::Type dimension ) const
+{
+ EnsureRelayoutData();
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ return mRelayoutData->minimumSize[ i ];
+ }
+ }
+
+ return 0.0f; // Default
+}
+
+void Actor::SetMaximumSize( float size, Dimension::Type dimension )
+{
+ EnsureRelayoutData();
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ mRelayoutData->maximumSize[ i ] = size;
+ }
+ }
+
+ RelayoutRequest();
+}
+
+float Actor::GetMaximumSize( Dimension::Type dimension ) const
+{
+ EnsureRelayoutData();
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ return mRelayoutData->maximumSize[ i ];
+ }
+ }
+
+ return 0.0f; // Default
+}
+
} // namespace Internal
} // namespace Dali
projects / platform / core / uifw / dali-core.git / blobdiff