X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Factors%2Factor-impl.cpp;h=ce9d371125d5ca9e098f7b60429e6e7b3637eda4;hb=8580a4d8cac9e232d55d8d332af0822c3449727f;hp=69710d9d3793855d1ad0808c10011dd5ea14eaba;hpb=df77c968587491afbd9f96816f37de560595bdff;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/event/actors/actor-impl.cpp b/dali/internal/event/actors/actor-impl.cpp index 69710d9..ce9d371 100644 --- a/dali/internal/event/actors/actor-impl.cpp +++ b/dali/internal/event/actors/actor-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 Samsung Electronics Co., Ltd. + * Copyright (c) 2016 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -24,15 +24,16 @@ #include // INTERNAL INCLUDES - +#include #include #include +#include #include #include #include #include +#include #include - #include #include #include @@ -41,7 +42,6 @@ #include #include #include -#include #include #include #include @@ -53,50 +53,12 @@ #include #include -#ifdef DALI_DYNAMICS_SUPPORT -#include -#include -#include -#include -#endif - using Dali::Internal::SceneGraph::Node; using Dali::Internal::SceneGraph::AnimatableProperty; using Dali::Internal::SceneGraph::PropertyBase; namespace Dali { -namespace ResizePolicy -{ - -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 ) - -} // unnamed namespace -} // ResizePolicy - -namespace SizeScalePolicy -{ -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 { @@ -173,28 +135,6 @@ struct Actor::RelayoutData bool insideRelayout :1; ///< Locking flag to prevent recursive relayouts on size set }; -#ifdef DALI_DYNAMICS_SUPPORT - -// Encapsulate actor related dynamics data -struct DynamicsData -{ - DynamicsData( Actor* slotOwner ) - : slotDelegate( slotOwner ) - { - } - - typedef std::map JointContainer; - typedef std::vector ReferencedJointContainer; - - DynamicsBodyPtr body; - JointContainer joints; - ReferencedJointContainer referencedJoints; - - SlotDelegate< Actor > slotDelegate; -}; - -#endif // DALI_DYNAMICS_SUPPORT - namespace // unnamed namespace { @@ -203,70 +143,75 @@ namespace // unnamed namespace /** * 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 + * 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( "parentOrigin", VECTOR3, true, false, true, Dali::Actor::Property::PARENT_ORIGIN ) +DALI_PROPERTY( "parentOriginX", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_X ) +DALI_PROPERTY( "parentOriginY", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Y ) +DALI_PROPERTY( "parentOriginZ", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Z ) +DALI_PROPERTY( "anchorPoint", VECTOR3, true, false, true, Dali::Actor::Property::ANCHOR_POINT ) +DALI_PROPERTY( "anchorPointX", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_X ) +DALI_PROPERTY( "anchorPointY", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Y ) +DALI_PROPERTY( "anchorPointZ", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Z ) +DALI_PROPERTY( "size", VECTOR3, true, true, true, Dali::Actor::Property::SIZE ) +DALI_PROPERTY( "sizeWidth", FLOAT, true, true, true, Dali::Actor::Property::SIZE_WIDTH ) +DALI_PROPERTY( "sizeHeight", FLOAT, true, true, true, Dali::Actor::Property::SIZE_HEIGHT ) +DALI_PROPERTY( "sizeDepth", FLOAT, true, true, true, Dali::Actor::Property::SIZE_DEPTH ) +DALI_PROPERTY( "position", VECTOR3, true, true, true, Dali::Actor::Property::POSITION ) +DALI_PROPERTY( "positionX", FLOAT, true, true, true, Dali::Actor::Property::POSITION_X ) +DALI_PROPERTY( "positionY", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Y ) +DALI_PROPERTY( "positionZ", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Z ) +DALI_PROPERTY( "worldPosition", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_POSITION ) +DALI_PROPERTY( "worldPositionX", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_X ) +DALI_PROPERTY( "worldPositionY", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Y ) +DALI_PROPERTY( "worldPositionZ", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Z ) +DALI_PROPERTY( "orientation", ROTATION, true, true, true, Dali::Actor::Property::ORIENTATION ) +DALI_PROPERTY( "worldOrientation", ROTATION, false, false, true, Dali::Actor::Property::WORLD_ORIENTATION ) +DALI_PROPERTY( "scale", VECTOR3, true, true, true, Dali::Actor::Property::SCALE ) +DALI_PROPERTY( "scaleX", FLOAT, true, true, true, Dali::Actor::Property::SCALE_X ) +DALI_PROPERTY( "scaleY", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Y ) +DALI_PROPERTY( "scaleZ", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Z ) +DALI_PROPERTY( "worldScale", 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( "colorRed", FLOAT, true, true, true, Dali::Actor::Property::COLOR_RED ) +DALI_PROPERTY( "colorGreen", FLOAT, true, true, true, Dali::Actor::Property::COLOR_GREEN ) +DALI_PROPERTY( "colorBlue", FLOAT, true, true, true, Dali::Actor::Property::COLOR_BLUE ) +DALI_PROPERTY( "colorAlpha", FLOAT, true, true, true, Dali::Actor::Property::COLOR_ALPHA ) +DALI_PROPERTY( "worldColor", VECTOR4, false, false, true, Dali::Actor::Property::WORLD_COLOR ) +DALI_PROPERTY( "worldMatrix", 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( "leaveRequired", BOOLEAN, true, false, false, Dali::Actor::Property::LEAVE_REQUIRED ) +DALI_PROPERTY( "inheritOrientation", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_ORIENTATION ) +DALI_PROPERTY( "inheritScale", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_SCALE ) +DALI_PROPERTY( "colorMode", STRING, true, false, false, Dali::Actor::Property::COLOR_MODE ) +DALI_PROPERTY( "positionInheritance", STRING, true, false, false, Dali::Actor::Property::POSITION_INHERITANCE ) +DALI_PROPERTY( "drawMode", STRING, true, false, false, Dali::Actor::Property::DRAW_MODE ) +DALI_PROPERTY( "sizeModeFactor", VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR ) +DALI_PROPERTY( "widthResizePolicy", STRING, true, false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY ) +DALI_PROPERTY( "heightResizePolicy", STRING, true, false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY ) +DALI_PROPERTY( "sizeScalePolicy", STRING, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY ) +DALI_PROPERTY( "widthForHeight", BOOLEAN, true, false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT ) +DALI_PROPERTY( "heightForWidth", BOOLEAN, true, false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH ) +DALI_PROPERTY( "padding", VECTOR4, true, false, false, Dali::Actor::Property::PADDING ) +DALI_PROPERTY( "minimumSize", VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE ) +DALI_PROPERTY( "maximumSize", VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE ) +DALI_PROPERTY( "inheritPosition", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_POSITION ) +DALI_PROPERTY( "clippingMode", STRING, true, false, false, Dali::Actor::Property::CLIPPING_MODE ) +DALI_PROPERTY( "batchParent", BOOLEAN, true, false, false, Dali::DevelActor::Property::BATCH_PARENT ) 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_WHEEL_EVENT = "wheel-event"; -const char* const SIGNAL_ON_STAGE = "on-stage"; -const char* const SIGNAL_OFF_STAGE = "off-stage"; +const char* const SIGNAL_WHEEL_EVENT = "wheelEvent"; +const char* const SIGNAL_ON_STAGE = "onStage"; +const char* const SIGNAL_OFF_STAGE = "offStage"; +const char* const SIGNAL_ON_RELAYOUT = "onRelayout"; +const char* const SIGNAL_TOUCH = "touch"; // Actions @@ -282,12 +227,96 @@ TypeRegistration mType( typeid(Dali::Actor), typeid(Dali::Handle), CreateActor ) 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 ); +SignalConnectorType signalConnector3( mType, SIGNAL_WHEEL_EVENT, &Actor::DoConnectSignal ); +SignalConnectorType signalConnector4( mType, SIGNAL_ON_STAGE, &Actor::DoConnectSignal ); +SignalConnectorType signalConnector5( mType, SIGNAL_OFF_STAGE, &Actor::DoConnectSignal ); +SignalConnectorType signalConnector6( mType, SIGNAL_ON_RELAYOUT, &Actor::DoConnectSignal ); +SignalConnectorType signalConnector7( mType, SIGNAL_TOUCH, &Actor::DoConnectSignal ); TypeAction a1( mType, ACTION_SHOW, &Actor::DoAction ); TypeAction a2( mType, ACTION_HIDE, &Actor::DoAction ); +struct AnchorValue +{ + const char* name; + const Vector3& value; +}; + +DALI_ENUM_TO_STRING_TABLE_BEGIN_WITH_TYPE( AnchorValue, ANCHOR_CONSTANT ) +DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_LEFT ) +DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_CENTER ) +DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_RIGHT ) +DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER_LEFT ) +DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER ) +DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER_RIGHT ) +DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_LEFT ) +DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_CENTER ) +DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_RIGHT ) +DALI_ENUM_TO_STRING_TABLE_END( ANCHOR_CONSTANT ) + +DALI_ENUM_TO_STRING_TABLE_BEGIN( COLOR_MODE ) +DALI_ENUM_TO_STRING( USE_OWN_COLOR ) +DALI_ENUM_TO_STRING( USE_PARENT_COLOR ) +DALI_ENUM_TO_STRING( USE_OWN_MULTIPLY_PARENT_COLOR ) +DALI_ENUM_TO_STRING( USE_OWN_MULTIPLY_PARENT_ALPHA ) +DALI_ENUM_TO_STRING_TABLE_END( COLOR_MODE ) + +DALI_ENUM_TO_STRING_TABLE_BEGIN( POSITION_INHERITANCE_MODE ) +DALI_ENUM_TO_STRING( INHERIT_PARENT_POSITION ) +DALI_ENUM_TO_STRING( USE_PARENT_POSITION ) +DALI_ENUM_TO_STRING( USE_PARENT_POSITION_PLUS_LOCAL_POSITION ) +DALI_ENUM_TO_STRING( DONT_INHERIT_POSITION ) +DALI_ENUM_TO_STRING_TABLE_END( POSITION_INHERITANCE_MODE ) + +DALI_ENUM_TO_STRING_TABLE_BEGIN( DRAW_MODE ) +DALI_ENUM_TO_STRING_WITH_SCOPE( DrawMode, NORMAL ) +DALI_ENUM_TO_STRING_WITH_SCOPE( DrawMode, OVERLAY_2D ) +DALI_ENUM_TO_STRING_WITH_SCOPE( DrawMode, STENCIL ) +DALI_ENUM_TO_STRING_TABLE_END( DRAW_MODE ) + +DALI_ENUM_TO_STRING_TABLE_BEGIN( RESIZE_POLICY ) +DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FIXED ) +DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, USE_NATURAL_SIZE ) +DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FILL_TO_PARENT ) +DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, SIZE_RELATIVE_TO_PARENT ) +DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, SIZE_FIXED_OFFSET_FROM_PARENT ) +DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FIT_TO_CHILDREN ) +DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, DIMENSION_DEPENDENCY ) +DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, USE_ASSIGNED_SIZE ) +DALI_ENUM_TO_STRING_TABLE_END( RESIZE_POLICY ) + +DALI_ENUM_TO_STRING_TABLE_BEGIN( SIZE_SCALE_POLICY ) +DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, USE_SIZE_SET ) +DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, FIT_WITH_ASPECT_RATIO ) +DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, FILL_WITH_ASPECT_RATIO ) +DALI_ENUM_TO_STRING_TABLE_END( SIZE_SCALE_POLICY ) + +DALI_ENUM_TO_STRING_TABLE_BEGIN( CLIPPING_MODE ) +DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, DISABLED ) +DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, CLIP_CHILDREN ) +DALI_ENUM_TO_STRING_TABLE_END( CLIPPING_MODE ) + + +bool GetAnchorPointConstant( const std::string& value, Vector3& anchor ) +{ + for( unsigned int i = 0; i < ANCHOR_CONSTANT_TABLE_COUNT; ++i ) + { + size_t sizeIgnored = 0; + if( CompareTokens( value.c_str(), ANCHOR_CONSTANT_TABLE[ i ].name, sizeIgnored ) ) + { + anchor = ANCHOR_CONSTANT_TABLE[ i ].value; + return true; + } + } + return false; +} + +inline bool GetParentOriginConstant( const std::string& value, Vector3& parentOrigin ) +{ + // Values are the same so just use the same table as anchor-point + return GetAnchorPointConstant( value, parentOrigin ); +} + /** * @brief Extract a given dimension from a Vector2 * @@ -327,6 +356,10 @@ float GetDimensionValue( const Vector3& values, Dimension::Type dimension ) return GetDimensionValue( values.GetVectorXY(), dimension ); } +unsigned int GetDepthIndex( uint16_t depth, uint16_t siblingOrder ) +{ + return depth * Dali::DevelLayer::TREE_DEPTH_MULTIPLIER + siblingOrder * Dali::DevelLayer::SIBLING_ORDER_MULTIPLIER; +} } // unnamed namespace @@ -361,23 +394,6 @@ unsigned int Actor::GetId() const return mId; } -void Actor::Attach( ActorAttachment& attachment ) -{ - DALI_ASSERT_DEBUG( !mAttachment && "An Actor can only have one attachment" ); - - if( OnStage() ) - { - attachment.Connect(); - } - - mAttachment = ActorAttachmentPtr( &attachment ); -} - -ActorAttachmentPtr Actor::GetAttachment() -{ - return mAttachment; -} - bool Actor::OnStage() const { return mIsOnStage; @@ -436,7 +452,7 @@ void Actor::Add( Actor& child ) 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( ActorPtr( &child ) ); // SetParent asserts that child can be added child.SetParent( this ); @@ -453,91 +469,32 @@ void Actor::Add( 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( !mChildren ) - { - mChildren = new ActorContainer; - } - - Actor* const oldParent( child.mParent ); - - // since an explicit position has been given, always insert, even if already a child - 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 ) - { - // Do this first, since user callbacks from within SetParent() may need to remove child - if( index < GetChildCount() ) - { - ActorIter it = mChildren->begin(); - std::advance( it, index ); - mChildren->insert( it, Dali::Actor( &child ) ); - } - else - { - mChildren->push_back( Dali::Actor( &child ) ); - } - // SetParent asserts that child can be added - child.SetParent( this, index ); - - // Notification for derived classes - 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 ) { - DALI_ASSERT_ALWAYS( this != &child && "Cannot remove actor from itself" ); - - Dali::Actor removed; - - if( !mChildren ) + if( (this == &child) || (!mChildren) ) { - // no children + // no children or removing itself return; } + ActorPtr removed; + // Find the child in mChildren, and unparent it ActorIter end = mChildren->end(); for( ActorIter iter = mChildren->begin(); iter != end; ++iter ) { - Actor& actor = GetImplementation( *iter ); + ActorPtr actor = (*iter); - if( &actor == &child ) + if( actor.Get() == &child ) { // Keep handle for OnChildRemove notification - removed = Dali::Actor( &actor ); + removed = actor; // Do this first, since user callbacks from within SetParent() may need to add the child mChildren->erase( iter ); - DALI_ASSERT_DEBUG( actor.GetParent() == this ); - actor.SetParent( NULL ); + DALI_ASSERT_DEBUG( actor->GetParent() == this ); + actor->SetParent( NULL ); break; } @@ -545,15 +502,15 @@ void Actor::Remove( Actor& child ) if( removed ) { - // Notification for derived classes - OnChildRemove( GetImplementation( removed ) ); - // Only put in a relayout request if there is a suitable dependency if( RelayoutDependentOnChildren() ) { RelayoutRequest(); } } + + // Notification for derived classes + OnChildRemove( child ); } void Actor::Unparent() @@ -572,11 +529,11 @@ unsigned int Actor::GetChildCount() const return ( NULL != mChildren ) ? mChildren->size() : 0; } -Dali::Actor Actor::GetChildAt( unsigned int index ) const +ActorPtr Actor::GetChildAt( unsigned int index ) const { DALI_ASSERT_ALWAYS( index < GetChildCount() ); - return ( ( mChildren ) ? ( *mChildren )[ index ] : Dali::Actor() ); + return ( ( mChildren ) ? ( *mChildren )[ index ] : ActorPtr() ); } ActorPtr Actor::FindChildByName( const std::string& actorName ) @@ -591,7 +548,7 @@ ActorPtr Actor::FindChildByName( const std::string& actorName ) ActorIter end = mChildren->end(); for( ActorIter iter = mChildren->begin(); iter != end; ++iter ) { - child = GetImplementation( *iter ).FindChildByName( actorName ); + child = (*iter)->FindChildByName( actorName ); if( child ) { @@ -614,7 +571,7 @@ ActorPtr Actor::FindChildById( const unsigned int id ) ActorIter end = mChildren->end(); for( ActorIter iter = mChildren->begin(); iter != end; ++iter ) { - child = GetImplementation( *iter ).FindChildById( id ); + child = (*iter)->FindChildById( id ); if( child ) { @@ -744,7 +701,7 @@ void Actor::SetPosition( const Vector3& position ) if( NULL != mNode ) { // mNode is being used in a separate thread; queue a message to set the value & base value - SceneGraph::NodePropertyMessage::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty::Bake, position ); + SceneGraph::NodeTransformPropertyMessage::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler::Bake, position ); } } @@ -755,7 +712,7 @@ void Actor::SetX( float x ) if( NULL != mNode ) { // mNode is being used in a separate thread; queue a message to set the value & base value - SceneGraph::NodePropertyComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty::BakeX, x ); + SceneGraph::NodeTransformComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler::BakeX, x ); } } @@ -766,7 +723,7 @@ void Actor::SetY( float y ) if( NULL != mNode ) { // mNode is being used in a separate thread; queue a message to set the value & base value - SceneGraph::NodePropertyComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty::BakeY, y ); + SceneGraph::NodeTransformComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler::BakeY, y ); } } @@ -777,7 +734,7 @@ void Actor::SetZ( float z ) if( NULL != mNode ) { // mNode is being used in a separate thread; queue a message to set the value & base value - SceneGraph::NodePropertyComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty::BakeZ, z ); + SceneGraph::NodeTransformComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler::BakeZ, z ); } } @@ -788,7 +745,7 @@ void Actor::TranslateBy( const Vector3& distance ) if( NULL != mNode ) { // mNode is being used in a separate thread; queue a message to set the value & base value - SceneGraph::NodePropertyMessage::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty::BakeRelative, distance ); + SceneGraph::NodeTransformPropertyMessage::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler::BakeRelative, distance ); } } @@ -826,7 +783,7 @@ void Actor::SetPositionInheritanceMode( PositionInheritanceMode mode ) if( NULL != mNode ) { // mNode is being used in a separate thread; queue a message to set the value - SetPositionInheritanceModeMessage( GetEventThreadServices(), *mNode, mode ); + SetInheritPositionMessage( GetEventThreadServices(), *mNode, mode == INHERIT_PARENT_POSITION ); } } @@ -836,6 +793,21 @@ PositionInheritanceMode Actor::GetPositionInheritanceMode() const return mPositionInheritanceMode; } +void Actor::SetInheritPosition( bool inherit ) +{ + if( mInheritPosition != inherit && NULL != mNode ) + { + // non animateable so keep local copy + mInheritPosition = inherit; + SetInheritPositionMessage( GetEventThreadServices(), *mNode, inherit ); + } +} + +bool Actor::IsPositionInherited() const +{ + return mInheritPosition; +} + void Actor::SetOrientation( const Radian& angle, const Vector3& axis ) { Vector3 normalizedAxis( axis.x, axis.y, axis.z ); @@ -851,7 +823,7 @@ 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::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty::Bake, orientation ); + SceneGraph::NodeTransformPropertyMessage::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler::Bake, orientation ); } } @@ -860,7 +832,7 @@ 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::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty::BakeRelative, Quaternion(angle, axis) ); + SceneGraph::NodeTransformPropertyMessage::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler::BakeRelative, Quaternion(angle, axis) ); } } @@ -869,7 +841,7 @@ 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::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty::BakeRelative, relativeRotation ); + SceneGraph::NodeTransformPropertyMessage::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler::BakeRelative, relativeRotation ); } } @@ -910,7 +882,7 @@ 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::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty::Bake, scale ); + SceneGraph::NodeTransformPropertyMessage::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler::Bake, scale ); } } @@ -919,7 +891,7 @@ void Actor::SetScaleX( float x ) if( NULL != mNode ) { // mNode is being used in a separate thread; queue a message to set the value & base value - SceneGraph::NodePropertyComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty::BakeX, x ); + SceneGraph::NodeTransformComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler::BakeX, x ); } } @@ -928,7 +900,7 @@ void Actor::SetScaleY( float y ) if( NULL != mNode ) { // mNode is being used in a separate thread; queue a message to set the value & base value - SceneGraph::NodePropertyComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty::BakeY, y ); + SceneGraph::NodeTransformComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler::BakeY, y ); } } @@ -937,45 +909,16 @@ void Actor::SetScaleZ( float z ) if( NULL != mNode ) { // mNode is being used in a separate thread; queue a message to set the value & base value - SceneGraph::NodePropertyComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty::BakeZ, z ); + SceneGraph::NodeTransformComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler::BakeZ, z ); } } -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( GetEventThreadServices(), *mNode, volume ); - } -} - -void Actor::SetTransmitGeometryScaling( bool transmitGeometryScaling ) -{ - if( NULL != mNode ) - { - // mNode is being used in a separate thread; queue a message to set the value - SetTransmitGeometryScalingMessage( GetEventThreadServices(), *mNode, transmitGeometryScaling ); - } -} - -bool Actor::GetTransmitGeometryScaling() const -{ - if( NULL != mNode ) - { - // mNode is being used in a separate thread; copy the value from the previous update - return mNode->GetTransmitGeometryScaling(); - } - - 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::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty::BakeRelativeMultiply, relativeScale ); + SceneGraph::NodeTransformPropertyMessage::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler::BakeRelativeMultiply, relativeScale ); } } @@ -1003,10 +946,11 @@ const Vector3& Actor::GetCurrentWorldScale() const void Actor::SetInheritScale( bool inherit ) { - // non animateable so keep local copy - mInheritScale = inherit; - if( NULL != mNode ) + + if( mInheritScale != inherit && NULL != mNode ) { + // non animateable so keep local copy + mInheritScale = inherit; // mNode is being used in a separate thread; queue a message to set the value SetInheritScaleMessage( GetEventThreadServices(), *mNode, inherit ); } @@ -1021,14 +965,7 @@ Matrix Actor::GetCurrentWorldMatrix() const { 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, orientation and scale: - BufferIndex updateBufferIndex = GetEventThreadServices().GetEventBufferIndex(); - Matrix worldMatrix(false); - worldMatrix.SetTransformComponents( mNode->GetWorldScale( updateBufferIndex ), - mNode->GetWorldOrientation( updateBufferIndex ), - mNode->GetWorldPosition( updateBufferIndex ) ); - return worldMatrix; + return mNode->GetWorldMatrix(0); } return Matrix::IDENTITY; @@ -1074,6 +1011,11 @@ float Actor::GetCurrentOpacity() const return 1.0f; } +ClippingMode::Type Actor::GetClippingMode() const +{ + return mClippingMode; +} + const Vector4& Actor::GetCurrentWorldColor() const { if( NULL != mNode ) @@ -1133,10 +1075,10 @@ const Vector4& Actor::GetCurrentColor() const void Actor::SetInheritOrientation( bool inherit ) { - // non animateable so keep local copy - mInheritOrientation = inherit; - if( NULL != mNode ) + if( mInheritOrientation != inherit && NULL != mNode) { + // non animateable so keep local copy + mInheritOrientation = inherit; // mNode is being used in a separate thread; queue a message to set the value SetInheritOrientationMessage( GetEventThreadServices(), *mNode, inherit ); } @@ -1193,23 +1135,19 @@ void Actor::SetSize( float width, float height, float depth ) void Actor::SetSize( const Vector2& size ) { - SetSize( Vector3( size.width, size.height, CalculateSizeZ( size ) ) ); + SetSize( Vector3( size.width, size.height, 0.f ) ); } 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 ); + SetSizeInternal( Vector3( size.width, size.height, 0.f ) ); } void Actor::SetSize( const Vector3& size ) { if( IsRelayoutEnabled() && !mRelayoutData->insideRelayout ) { + // TODO we cannot just ignore the given Z but that means rewrite the size negotiation!! SetPreferredSize( size.GetVectorXY() ); } else @@ -1231,7 +1169,7 @@ void Actor::SetSizeInternal( const Vector3& size ) mTargetSize = size; // mNode is being used in a separate thread; queue a message to set the value & base value - SceneGraph::NodePropertyMessage::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty::Bake, mTargetSize ); + SceneGraph::NodeTransformPropertyMessage::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler::Bake, mTargetSize ); // Notification for derived classes mInsideOnSizeSet = true; @@ -1264,34 +1202,65 @@ void Actor::NotifySizeAnimation( Animation& animation, float targetSize, Propert { mTargetSize.height = targetSize; } + else if ( Dali::Actor::Property::SIZE_DEPTH == property ) + { + mTargetSize.depth = targetSize; + } // Notify deriving classes OnSizeAnimation( animation, mTargetSize ); } +void Actor::NotifyPositionAnimation( Animation& animation, const Vector3& targetPosition ) +{ + mTargetPosition = targetPosition; +} + +void Actor::NotifyPositionAnimation( Animation& animation, float targetPosition, Property::Index property ) +{ + if ( Dali::Actor::Property::POSITION_X == property ) + { + mTargetPosition.x = targetPosition; + } + else if ( Dali::Actor::Property::POSITION_Y == property ) + { + mTargetPosition.y = targetPosition; + } + else if ( Dali::Actor::Property::POSITION_Z == property ) + { + mTargetPosition.z = targetPosition; + } +} + void Actor::SetWidth( float width ) { + mTargetSize.width = width; + if( NULL != mNode ) { // mNode is being used in a separate thread; queue a message to set the value & base value - SceneGraph::NodePropertyComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty::BakeX, width ); + SceneGraph::NodeTransformComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler::BakeX, width ); } } void Actor::SetHeight( float height ) { + mTargetSize.height = height; + if( NULL != mNode ) { // mNode is being used in a separate thread; queue a message to set the value & base value - SceneGraph::NodePropertyComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty::BakeY, height ); + SceneGraph::NodeTransformComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler::BakeY, height ); } } void Actor::SetDepth( float depth ) { + mTargetSize.depth = depth; + if( NULL != mNode ) { // mNode is being used in a separate thread; queue a message to set the value & base value - SceneGraph::NodePropertyComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty::BakeZ, depth ); + SceneGraph::NodeTransformComponentMessage::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler::BakeZ, depth ); } } @@ -1423,6 +1392,8 @@ void Actor::SetRelayoutEnabled( bool relayoutEnabled ) { EnsureRelayoutData(); + DALI_ASSERT_DEBUG( mRelayoutData && "mRelayoutData not created" ); + mRelayoutData->relayoutEnabled = relayoutEnabled; } } @@ -1473,403 +1444,85 @@ bool Actor::RelayoutRequired( Dimension::Type dimension ) const return mRelayoutData && mRelayoutData->relayoutEnabled && IsLayoutDirty( dimension ); } -#ifdef DALI_DYNAMICS_SUPPORT - -//--------------- Dynamics --------------- - -void Actor::DisableDynamics() +unsigned int Actor::AddRenderer( Renderer& renderer ) { - if( NULL != mDynamicsData ) + if( !mRenderers ) { - DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s- (\"%s\")\n", __PRETTY_FUNCTION__, mName.c_str()); - - // ensure dynamics object are disconnected from scene - DisconnectDynamics(); - - // delete joint owned by this actor - while( !mDynamicsData->joints.empty() ) - { - RemoveDynamicsJoint( mDynamicsData->joints.begin()->second ); - } - - // delete other joints referencing this actor - while( !mDynamicsData->referencedJoints.empty() ) - { - DynamicsJointPtr joint( *(mDynamicsData->referencedJoints.begin()) ); - ActorPtr jointOwner( joint->GetActor( true ) ); - if( jointOwner ) - { - jointOwner->RemoveDynamicsJoint( joint ); - } - else - { - mDynamicsData->referencedJoints.erase( mDynamicsData->referencedJoints.begin() ); - } - } - // delete the DynamicsBody object - mDynamicsData->body.Reset(); - - // Discard Dynamics data structure - delete mDynamicsData; - mDynamicsData = NULL; - } -} - -DynamicsBodyPtr Actor::GetDynamicsBody() const -{ - DynamicsBodyPtr body; - - if( NULL != mDynamicsData ) - { - body = mDynamicsData->body; + mRenderers = new RendererContainer; } - return body; -} - -DynamicsBodyPtr Actor::EnableDynamics(DynamicsBodyConfigPtr bodyConfig) -{ - DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s- (\"%s\")\n", __PRETTY_FUNCTION__, mName.c_str()); + unsigned int index = mRenderers->size(); + RendererPtr rendererPtr = RendererPtr( &renderer ); + mRenderers->push_back( rendererPtr ); + AddRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() ); - if( NULL == mDynamicsData ) + if( mIsOnStage) { - mDynamicsData = new DynamicsData( this ); + rendererPtr->Connect(); } - if( !mDynamicsData->body ) - { - mDynamicsData->body = new DynamicsBody(mName, bodyConfig, *this, *(const_cast(mNode)) ); - - if( OnStage() ) - { - DynamicsWorldPtr world( DynamicsWorld::Get() ); - if( world ) - { - if( mParent == world->GetRootActor().Get() ) - { - mDynamicsData->body->Connect( GetEventThreadServices() ); - } - } - } - } - - return mDynamicsData->body; -} - -DynamicsJointPtr Actor::AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offset ) -{ - DALI_ASSERT_ALWAYS( attachedActor && "'attachedActor' must be initialized!" ); - return AddDynamicsJoint( attachedActor, offset, ( GetCurrentPosition() + offset ) - attachedActor->GetCurrentPosition() ); -} - -DynamicsJointPtr Actor::AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offsetA, const Vector3& offsetB ) -{ - DALI_ASSERT_ALWAYS( attachedActor && "'attachedActor' must be initialized!" ); - DALI_ASSERT_ALWAYS( this != attachedActor.Get() && "Cannot create a joint to oneself!" ); - - DynamicsJointPtr joint; - - DynamicsWorldPtr world( DynamicsWorld::Get() ); - - if( world ) - { - if( NULL != mDynamicsData ) - { - DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) ); - - if( mDynamicsData->joints.end() != it ) - { - // use existing joint - joint = it->second; - } - - if( !joint ) - { - DynamicsBodyPtr bodyA( GetDynamicsBody() ); - DynamicsBodyPtr bodyB( attachedActor->GetDynamicsBody() ); - - if( !bodyA ) - { - bodyA = EnableDynamics( new DynamicsBodyConfig ); - } - - if( !bodyB ) - { - bodyB = attachedActor->EnableDynamics( new DynamicsBodyConfig ); - } - - joint = new DynamicsJoint(world, bodyA, bodyB, offsetA, offsetB); - mDynamicsData->joints[ attachedActor.Get() ] = joint; - - if( OnStage() && attachedActor->OnStage() ) - { - joint->Connect( GetEventThreadServices() ); - } - - attachedActor->ReferenceJoint( joint ); - - attachedActor->OnStageSignal().Connect( mDynamicsData->slotDelegate, &Actor::AttachedActorOnStage ); - attachedActor->OffStageSignal().Connect( mDynamicsData->slotDelegate, &Actor::AttachedActorOffStage ); - } - } - } - return joint; -} - -const int Actor::GetNumberOfJoints() const -{ - return static_cast( NULL != mDynamicsData ? mDynamicsData->joints.size() : 0 ); + return index; } -DynamicsJointPtr Actor::GetDynamicsJointByIndex( const int index ) const +unsigned int Actor::GetRendererCount() const { - DynamicsJointPtr joint; - - if( NULL != mDynamicsData ) + unsigned int rendererCount(0); + if( mRenderers ) { - if( index >= 0 && index < static_cast(mDynamicsData->joints.size()) ) - { - DynamicsData::JointContainer::const_iterator it( mDynamicsData->joints.begin() ); - - for( int i = 0; i < index; ++i ) - { - ++it; - } - - joint = it->second; - } + rendererCount = mRenderers->size(); } - return joint; + return rendererCount; } -DynamicsJointPtr Actor::GetDynamicsJoint( ActorPtr attachedActor ) const +RendererPtr Actor::GetRendererAt( unsigned int index ) { - DynamicsJointPtr joint; - - if( NULL != mDynamicsData ) + RendererPtr renderer; + if( index < GetRendererCount() ) { - DynamicsData::JointContainer::const_iterator it( mDynamicsData->joints.find( attachedActor.Get() ) ); - - if( mDynamicsData->joints.end() != it ) - { - // use existing joint - joint = it->second; - } + renderer = ( *mRenderers )[ index ]; } - return joint; + return renderer; } -void Actor::RemoveDynamicsJoint( DynamicsJointPtr joint ) +void Actor::RemoveRenderer( Renderer& renderer ) { - if( NULL != mDynamicsData ) + if( mRenderers ) { - DynamicsData::JointContainer::iterator it( mDynamicsData->joints.begin() ); - DynamicsData::JointContainer::iterator endIt( mDynamicsData->joints.end() ); - - for(; it != endIt; ++it ) + RendererIter end = mRenderers->end(); + for( RendererIter iter = mRenderers->begin(); iter != end; ++iter ) { - if( it->second == joint.Get() ) + if( (*iter).Get() == &renderer ) { - ActorPtr attachedActor( it->first ); - - if( OnStage() && attachedActor && attachedActor->OnStage() ) - { - joint->Disconnect( GetEventThreadServices() ); - } - - if( attachedActor ) - { - attachedActor->ReleaseJoint( joint ); - attachedActor->OnStageSignal().Disconnect( mDynamicsData->slotDelegate, &Actor::AttachedActorOnStage ); - attachedActor->OffStageSignal().Disconnect( mDynamicsData->slotDelegate, &Actor::AttachedActorOffStage ); - } - - mDynamicsData->joints.erase(it); + mRenderers->erase( iter ); + RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() ); break; } } } } -void Actor::ReferenceJoint( DynamicsJointPtr joint ) -{ - DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" ); - - if( NULL != mDynamicsData ) - { - mDynamicsData->referencedJoints.push_back(joint); - } -} - -void Actor::ReleaseJoint( DynamicsJointPtr joint ) -{ - DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" ); - - if( NULL != mDynamicsData ) - { - DynamicsData::ReferencedJointContainer::iterator it( std::find( mDynamicsData->referencedJoints.begin(), mDynamicsData->referencedJoints.end(), joint ) ); - - if( it != mDynamicsData->referencedJoints.end() ) - { - mDynamicsData->referencedJoints.erase( it ); - } - } -} - -void Actor::SetDynamicsRoot(bool flag) -{ - if( mIsDynamicsRoot != flag ) - { - mIsDynamicsRoot = flag; - - if( OnStage() && mChildren ) - { - // walk the children connecting or disconnecting any dynamics enabled child from the dynamics simulation - ActorIter end = mChildren->end(); - for( ActorIter iter = mChildren->begin(); iter != end; ++iter ) - { - Actor& child = GetImplementation(*iter); - - if( child.GetDynamicsBody() ) - { - if( mIsDynamicsRoot ) - { - child.ConnectDynamics(); - } - else - { - child.DisconnectDynamics(); - } - } - } - } - } -} - -bool Actor::IsDynamicsRoot() const -{ - return mIsDynamicsRoot; -} - -void Actor::AttachedActorOnStage( Dali::Actor actor ) -{ - DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s\n", __PRETTY_FUNCTION__); - - if( OnStage() ) - { - ActorPtr attachedActor( &GetImplementation(actor) ); - - DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" ); - if( NULL != mDynamicsData ) - { - DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) ); - if( mDynamicsData->joints.end() != it ) - { - DynamicsJointPtr joint( it->second ); - joint->Connect( GetEventThreadServices() ); - } - } - } -} - -void Actor::AttachedActorOffStage( Dali::Actor actor ) -{ - DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s\n", __PRETTY_FUNCTION__); - - if( OnStage() ) - { - ActorPtr attachedActor( &GetImplementation(actor) ); - - DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" ); - if( NULL != mDynamicsData ) - { - DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) ); - if( mDynamicsData->joints.end() != it ) - { - DynamicsJointPtr joint( it->second ); - joint->Disconnect( GetEventThreadServices() ); - } - } - } -} - -void Actor::ConnectDynamics() -{ - if( NULL != mDynamicsData && mDynamicsData->body ) - { - if( OnStage() && mParent && mParent->IsDynamicsRoot() ) - { - 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 ) - { - Actor* attachedActor( it->first ); - if( NULL != attachedActor && attachedActor->OnStage() ) - { - DynamicsJointPtr joint( it->second ); - - joint->Connect( GetEventThreadServices() ); - } - } - } - } - } -} - -void Actor::DisconnectDynamics() -{ - if( NULL != mDynamicsData && mDynamicsData->body ) - { - if( OnStage() ) - { - 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 ) - { - DynamicsJointPtr joint( it->second ); - - joint->Disconnect( GetEventThreadServices() ); - } - } - } - } -} - -#endif // DALI_DYNAMICS_SUPPORT - -void Actor::SetOverlay( bool enable ) +void Actor::RemoveRenderer( unsigned int index ) { - // Setting STENCIL will override OVERLAY - if( DrawMode::STENCIL != mDrawMode ) + if( index < GetRendererCount() ) { - SetDrawMode( enable ? DrawMode::OVERLAY : DrawMode::NORMAL ); + RendererPtr renderer = ( *mRenderers )[ index ]; + RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.Get()->GetRendererSceneObject() ); + mRenderers->erase( mRenderers->begin()+index ); } } bool Actor::IsOverlay() const { - return ( DrawMode::OVERLAY == mDrawMode ); + return ( DrawMode::OVERLAY_2D == mDrawMode ); } void Actor::SetDrawMode( DrawMode::Type drawMode ) { // this flag is not animatable so keep the value mDrawMode = drawMode; - if( NULL != mNode ) + if( ( NULL != mNode ) && ( drawMode != DrawMode::STENCIL ) ) { // mNode is being used in a separate thread; queue a message to set the value SetDrawModeMessage( GetEventThreadServices(), *mNode, drawMode ); @@ -1906,7 +1559,7 @@ bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float sc return false; } -bool Actor::ScreenToLocal( RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const +bool Actor::ScreenToLocal( const RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const { bool retval = false; // only valid when on-stage @@ -1937,13 +1590,9 @@ bool Actor::ScreenToLocal( const Matrix& viewMatrix, const Matrix& projectionMat return false; } - BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() ); - - // Calculate the ModelView matrix - 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->GetWorldOrientation( bufferIndex ), mNode->GetWorldPosition( bufferIndex ) ); - Matrix::Multiply( modelView, modelView, viewMatrix ); + // Get the ModelView matrix + Matrix modelView; + Matrix::Multiply( modelView, mNode->GetWorldMatrix(0), viewMatrix ); // Calculate the inverted ModelViewProjection matrix; this will be used for 2 unprojects Matrix invertedMvp( false/*don't init*/); @@ -2076,21 +1725,19 @@ bool Actor::RaySphereTest( const Vector4& rayOrigin, const Vector4& rayDir ) con return ( b2 * b2 - a * c ) >= 0.f; } -bool Actor::RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vector4& hitPointLocal, float& distance ) const +bool Actor::RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vector2& hitPointLocal, float& distance ) const { bool hit = false; - if( OnStage() && - NULL != mNode ) + if( OnStage() && NULL != mNode ) { - BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() ); - // Transforms the ray to the local reference system. - // Calculate the inverse of Model matrix 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->GetWorldOrientation( bufferIndex ), mNode->GetWorldPosition( bufferIndex ) ); + + BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() ); + invModelMatrix = mNode->GetWorldMatrix(0); + invModelMatrix.Invert(); Vector4 rayOriginLocal( invModelMatrix * rayOrigin ); Vector4 rayDirLocal( invModelMatrix * rayDir - invModelMatrix.GetTranslation() ); @@ -2140,7 +1787,7 @@ bool Actor::IsKeyboardFocusable() const bool Actor::GetTouchRequired() const { - return !mTouchedSignal.Empty() || mDerivedRequiresTouch; + return !mTouchedSignal.Empty() || !mTouchSignal.Empty() || mDerivedRequiresTouch; } bool Actor::GetHoverRequired() const @@ -2174,20 +1821,26 @@ bool Actor::IsGestureRequred( Gesture::Type type ) const return mGestureData && mGestureData->IsGestureRequred( type ); } -bool Actor::EmitTouchEventSignal( const TouchEvent& event ) +bool Actor::EmitTouchEventSignal( const TouchEvent& event, const Dali::TouchData& touch ) { bool consumed = false; + if( !mTouchSignal.Empty() ) + { + Dali::Actor handle( this ); + consumed = mTouchSignal.Emit( handle, touch ); + } + if( !mTouchedSignal.Empty() ) { Dali::Actor handle( this ); - consumed = mTouchedSignal.Emit( handle, event ); + consumed |= mTouchedSignal.Emit( handle, event ); } if( !consumed ) { // Notification for derived classes - consumed = OnTouchEvent( event ); + consumed = OnTouchEvent( event ); // TODO } return consumed; @@ -2233,9 +1886,15 @@ bool Actor::EmitWheelEventSignal( const WheelEvent& event ) Dali::Actor::TouchSignalType& Actor::TouchedSignal() { + DALI_LOG_WARNING( "Deprecated: Use TouchSignal() instead\n" ); return mTouchedSignal; } +Dali::Actor::TouchDataSignalType& Actor::TouchSignal() +{ + return mTouchSignal; +} + Dali::Actor::HoverSignalType& Actor::HoveredSignal() { return mHoveredSignal; @@ -2264,7 +1923,7 @@ Dali::Actor::OnRelayoutSignalType& Actor::OnRelayoutSignal() bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor ) { bool connected( true ); - Actor* actor = dynamic_cast< Actor* >( object ); + Actor* actor = static_cast< Actor* >( object ); // TypeRegistry guarantees that this is the correct type. if( 0 == signalName.compare( SIGNAL_TOUCHED ) ) { @@ -2286,6 +1945,14 @@ bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tra { actor->OffStageSignal().Connect( tracker, functor ); } + else if( 0 == signalName.compare( SIGNAL_ON_RELAYOUT ) ) + { + actor->OnRelayoutSignal().Connect( tracker, functor ); + } + else if( 0 == signalName.compare( SIGNAL_TOUCH ) ) + { + actor->TouchSignal().Connect( tracker, functor ); + } else { // signalName does not match any signal @@ -2296,26 +1963,22 @@ bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tra } Actor::Actor( DerivedType derivedType ) -: mStage( NULL ), - mParent( NULL ), +: mParent( NULL ), mChildren( NULL ), + mRenderers( NULL ), mNode( NULL ), mParentOrigin( NULL ), mAnchorPoint( NULL ), mRelayoutData( NULL ), -#ifdef DALI_DYNAMICS_SUPPORT - mDynamicsData( NULL ), -#endif 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 + mDepth( 0u ), + mSiblingOrder(0u), mIsRoot( ROOT_LAYER == derivedType ), - mIsRenderable( RENDERABLE == derivedType ), mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ), mIsOnStage( false ), - mIsDynamicsRoot( false ), mSensitive( true ), mLeaveRequired( false ), mKeyboardFocusable( false ), @@ -2324,11 +1987,14 @@ Actor::Actor( DerivedType derivedType ) mDerivedRequiresWheelEvent( false ), mOnStageSignalled( false ), mInsideOnSizeSet( false ), + mInheritPosition( true ), mInheritOrientation( true ), mInheritScale( true ), mDrawMode( DrawMode::NORMAL ), mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ), - mColorMode( Node::DEFAULT_COLOR_MODE ) + mColorMode( Node::DEFAULT_COLOR_MODE ), + mClippingMode( ClippingMode::DISABLED ), + mIsBatchParent( false ) { } @@ -2354,11 +2020,11 @@ Actor::~Actor() ActorConstIter endIter = mChildren->end(); for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter ) { - Actor& actor = GetImplementation( *iter ); - actor.SetParent( NULL ); + (*iter)->SetParent( NULL ); } } delete mChildren; + delete mRenderers; // Guard to allow handle destruction after Core has been destroyed if( EventThreadServices::IsCoreRunning() ) @@ -2372,11 +2038,6 @@ Actor::~Actor() GetEventThreadServices().UnregisterObject( this ); } -#ifdef DALI_DYNAMICS_SUPPORT - // Cleanup dynamics - delete mDynamicsData; -#endif - // Cleanup optional gesture data delete mGestureData; @@ -2391,39 +2052,40 @@ Actor::~Actor() } } -void Actor::ConnectToStage( int index ) +void Actor::ConnectToStage( unsigned int parentDepth ) { - // This container is used instead of walking the Actor hierachy. - // It protects us when the Actor hierachy is modified during OnStageConnectionExternal callbacks. + // This container is used instead of walking the Actor hierarchy. + // It protects us when the Actor hierarchy is modified during OnStageConnectionExternal callbacks. ActorContainer connectionList; - // This stage is atomic i.e. not interrupted by user callbacks - RecursiveConnectToStage( connectionList, index ); + // This stage is atomic i.e. not interrupted by user callbacks. + RecursiveConnectToStage( connectionList, parentDepth + 1 ); // Notify applications about the newly connected actors. const ActorIter endIter = connectionList.end(); for( ActorIter iter = connectionList.begin(); iter != endIter; ++iter ) { - Actor& actor = GetImplementation( *iter ); - actor.NotifyStageConnection(); + (*iter)->NotifyStageConnection(); } RelayoutRequest(); } -void Actor::RecursiveConnectToStage( ActorContainer& connectionList, int index ) +void Actor::RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth ) { DALI_ASSERT_ALWAYS( !OnStage() ); mIsOnStage = true; + mDepth = depth; + SetDepthIndexMessage( GetEventThreadServices(), *mNode, GetDepthIndex( mDepth, mSiblingOrder ) ); - ConnectToSceneGraph( index ); + ConnectToSceneGraph(); // 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( ActorPtr( this ) ); // Recursively connect children if( mChildren ) @@ -2431,8 +2093,7 @@ void Actor::RecursiveConnectToStage( ActorContainer& connectionList, int index ) ActorConstIter endIter = mChildren->end(); for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter ) { - Actor& actor = GetImplementation( *iter ); - actor.RecursiveConnectToStage( connectionList ); + (*iter)->RecursiveConnectToStage( connectionList, depth+1 ); } } } @@ -2441,32 +2102,24 @@ void Actor::RecursiveConnectToStage( ActorContainer& connectionList, int index ) * This method is called when the Actor is connected to the Stage. * The parent must have added its Node to the scene-graph. * The child must connect its Node to the parent's Node. - * This is resursive; the child calls ConnectToStage() for its children. + * This is recursive; the child calls ConnectToStage() for its children. */ -void Actor::ConnectToSceneGraph( int index ) +void Actor::ConnectToSceneGraph() { 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( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode, index ); + ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode ); } - // Notify attachment - if( mAttachment ) + unsigned int rendererCount( GetRendererCount() ); + for( unsigned int i(0); iConnect(); + GetRendererAt(i)->Connect(); } -#ifdef DALI_DYNAMICS_SUPPORT - // Notify dynamics - if( NULL != mDynamicsData ) - { - ConnectDynamics(); - } -#endif - // Request relayout on all actors that are added to the scenegraph RelayoutRequest(); @@ -2481,7 +2134,7 @@ void Actor::NotifyStageConnection() if( OnStage() && !mOnStageSignalled ) { // Notification for external (CustomActor) derived classes - OnStageConnectionExternal(); + OnStageConnectionExternal( mDepth ); if( !mOnStageSignal.Empty() ) { @@ -2510,8 +2163,7 @@ void Actor::DisconnectFromStage() const ActorIter endIter = disconnectionList.end(); for( ActorIter iter = disconnectionList.begin(); iter != endIter; ++iter ) { - Actor& actor = GetImplementation( *iter ); - actor.NotifyStageDisconnection(); + (*iter)->NotifyStageDisconnection(); } } @@ -2525,13 +2177,12 @@ void Actor::RecursiveDisconnectFromStage( ActorContainer& disconnectionList ) ActorConstIter endIter = mChildren->end(); for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter ) { - Actor& actor = GetImplementation( *iter ); - actor.RecursiveDisconnectFromStage( disconnectionList ); + (*iter)->RecursiveDisconnectFromStage( disconnectionList ); } } // This stage is atomic; avoid emitting callbacks until all Actors are disconnected - disconnectionList.push_back( Dali::Actor( this ) ); + disconnectionList.push_back( ActorPtr( this ) ); // Notification for internal derived classes OnStageDisconnectionInternal(); @@ -2550,19 +2201,11 @@ void Actor::DisconnectFromSceneGraph() // Notification for Object::Observers OnSceneObjectRemove(); - // Notify attachment - if( mAttachment ) + unsigned int rendererCount( GetRendererCount() ); + for( unsigned int i(0); iDisconnect(); + GetRendererAt(i)->Disconnect(); } - -#ifdef DALI_DYNAMICS_SUPPORT - // Notify dynamics - if( NULL != mDynamicsData ) - { - DisconnectDynamics(); - } -#endif } void Actor::NotifyStageDisconnection() @@ -2593,10 +2236,9 @@ bool Actor::IsNodeConnected() const { bool connected( false ); - if( OnStage() && - NULL != mNode ) + if( OnStage() && ( NULL != mNode ) ) { - if( mNode->IsRoot() || mNode->GetParent() ) + if( IsRoot() || mNode->GetParent() ) { connected = true; } @@ -2695,7 +2337,21 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr { case Dali::Actor::Property::PARENT_ORIGIN: { - SetParentOrigin( property.Get< Vector3 >() ); + Property::Type type = property.GetType(); + if( type == Property::VECTOR3 ) + { + SetParentOrigin( property.Get< Vector3 >() ); + } + else if ( type == Property::STRING ) + { + std::string parentOriginString; + property.Get( parentOriginString ); + Vector3 parentOrigin; + if( GetParentOriginConstant( parentOriginString, parentOrigin ) ) + { + SetParentOrigin( parentOrigin ); + } + } break; } @@ -2719,7 +2375,21 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr case Dali::Actor::Property::ANCHOR_POINT: { - SetAnchorPoint( property.Get< Vector3 >() ); + Property::Type type = property.GetType(); + if( type == Property::VECTOR3 ) + { + SetAnchorPoint( property.Get< Vector3 >() ); + } + else if ( type == Property::STRING ) + { + std::string anchorPointString; + property.Get( anchorPointString ); + Vector3 anchor; + if( GetAnchorPointConstant( anchorPointString, anchor ) ) + { + SetAnchorPoint( anchor ); + } + } break; } @@ -2873,6 +2543,12 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr break; } + case Dali::Actor::Property::INHERIT_POSITION: + { + SetInheritPosition( property.Get< bool >() ); + break; + } + case Dali::Actor::Property::INHERIT_ORIENTATION: { SetInheritOrientation( property.Get< bool >() ); @@ -2887,19 +2563,31 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr case Dali::Actor::Property::COLOR_MODE: { - SetColorMode( Scripting::GetColorMode( property.Get< std::string >() ) ); + ColorMode mode; + if ( Scripting::GetEnumeration< ColorMode >( property.Get< std::string >().c_str(), COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT, mode ) ) + { + SetColorMode( mode ); + } break; } case Dali::Actor::Property::POSITION_INHERITANCE: { - SetPositionInheritanceMode( Scripting::GetPositionInheritanceMode( property.Get< std::string >() ) ); + PositionInheritanceMode mode; + if( Scripting::GetEnumeration< PositionInheritanceMode >( property.Get< std::string >().c_str(), POSITION_INHERITANCE_MODE_TABLE, POSITION_INHERITANCE_MODE_TABLE_COUNT, mode ) ) + { + SetPositionInheritanceMode( mode ); + } break; } case Dali::Actor::Property::DRAW_MODE: { - SetDrawMode( Scripting::GetDrawMode( property.Get< std::string >() ) ); + DrawMode::Type mode; + if( Scripting::GetEnumeration< DrawMode::Type >( property.Get< std::string >().c_str(), DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT, mode ) ) + { + SetDrawMode( mode ); + } break; } @@ -2912,7 +2600,7 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr case Dali::Actor::Property::WIDTH_RESIZE_POLICY: { ResizePolicy::Type type; - if( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount, type ) ) + if( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) ) { SetResizePolicy( type, Dimension::WIDTH ); } @@ -2922,7 +2610,7 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr case Dali::Actor::Property::HEIGHT_RESIZE_POLICY: { ResizePolicy::Type type; - if( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount, type ) ) + if( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) ) { SetResizePolicy( type, Dimension::HEIGHT ); } @@ -2932,7 +2620,7 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr case Dali::Actor::Property::SIZE_SCALE_POLICY: { SizeScalePolicy::Type type; - if( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount, type ) ) + if( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT, type ) ) { SetSizeScalePolicy( type ); } @@ -2981,6 +2669,53 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr break; } + case Dali::DevelActor::Property::BATCH_PARENT: + { + bool value; + + if( property.Get( value ) ) + { + if( value != mIsBatchParent ) + { + mIsBatchParent = value; + SetIsBatchParentMessage( GetEventThreadServices(), *mNode, mIsBatchParent ); + } + } + break; + } + + case Dali::DevelActor::Property::SIBLING_ORDER: + { + int value; + + if( property.Get( value ) ) + { + if( static_cast(value) != mSiblingOrder ) + { + mSiblingOrder = value; + if( mIsOnStage ) + { + SetDepthIndexMessage( GetEventThreadServices(), *mNode, GetDepthIndex( mDepth, mSiblingOrder ) ); + } + } + } + break; + } + + case Dali::Actor::Property::CLIPPING_MODE: + { + ClippingMode::Type convertedValue = mClippingMode; + if( Scripting::GetEnumerationProperty< ClippingMode::Type >( property, CLIPPING_MODE_TABLE, CLIPPING_MODE_TABLE_COUNT, convertedValue ) ) + { + mClippingMode = convertedValue; + if( NULL != mNode ) + { + SetClippingModeMessage( GetEventThreadServices(), *mNode, mClippingMode ); + } + } + break; + } + default: { // this can happen in the case of a non-animatable default property so just do nothing @@ -2992,7 +2727,7 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr // TODO: This method needs to be removed void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value ) { - switch( entry.type ) + switch( entry.GetType() ) { case Property::BOOLEAN: { @@ -3016,17 +2751,6 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata break; } - 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::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty::Bake, value.Get() ); - - break; - } - case Property::FLOAT: { const AnimatableProperty< float >* property = dynamic_cast< const AnimatableProperty< float >* >( entry.GetSceneGraphProperty() ); @@ -3151,10 +2875,9 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata default: { - DALI_ASSERT_ALWAYS( false && "Property type enumeration out of bounds" ); // should not come here - break; + // nothing to do for other types } - } + } // entry.GetType } Property::Value Actor::GetDefaultProperty( Property::Index index ) const @@ -3213,49 +2936,49 @@ Property::Value Actor::GetDefaultProperty( Property::Index index ) const case Dali::Actor::Property::SIZE: { - value = GetCurrentSize(); + value = GetTargetSize(); break; } case Dali::Actor::Property::SIZE_WIDTH: { - value = GetCurrentSize().width; + value = GetTargetSize().width; break; } case Dali::Actor::Property::SIZE_HEIGHT: { - value = GetCurrentSize().height; + value = GetTargetSize().height; break; } case Dali::Actor::Property::SIZE_DEPTH: { - value = GetCurrentSize().depth; + value = GetTargetSize().depth; break; } case Dali::Actor::Property::POSITION: { - value = GetCurrentPosition(); + value = GetTargetPosition(); break; } case Dali::Actor::Property::POSITION_X: { - value = GetCurrentPosition().x; + value = GetTargetPosition().x; break; } case Dali::Actor::Property::POSITION_Y: { - value = GetCurrentPosition().y; + value = GetTargetPosition().y; break; } case Dali::Actor::Property::POSITION_Z: { - value = GetCurrentPosition().z; + value = GetTargetPosition().z; break; } @@ -3391,6 +3114,12 @@ Property::Value Actor::GetDefaultProperty( Property::Index index ) const break; } + case Dali::Actor::Property::INHERIT_POSITION: + { + value = IsPositionInherited(); + break; + } + case Dali::Actor::Property::INHERIT_ORIENTATION: { value = IsOrientationInherited(); @@ -3405,19 +3134,19 @@ Property::Value Actor::GetDefaultProperty( Property::Index index ) const case Dali::Actor::Property::COLOR_MODE: { - value = Scripting::GetColorMode( GetColorMode() ); + value = Scripting::GetLinearEnumerationName< ColorMode >( GetColorMode(), COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT ); break; } case Dali::Actor::Property::POSITION_INHERITANCE: { - value = Scripting::GetPositionInheritanceMode( GetPositionInheritanceMode() ); + value = Scripting::GetLinearEnumerationName< PositionInheritanceMode >( GetPositionInheritanceMode(), POSITION_INHERITANCE_MODE_TABLE, POSITION_INHERITANCE_MODE_TABLE_COUNT ); break; } case Dali::Actor::Property::DRAW_MODE: { - value = Scripting::GetDrawMode( GetDrawMode() ); + value = Scripting::GetEnumerationName< DrawMode::Type >( GetDrawMode(), DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT ); break; } @@ -3429,19 +3158,19 @@ Property::Value Actor::GetDefaultProperty( Property::Index index ) const case Dali::Actor::Property::WIDTH_RESIZE_POLICY: { - value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::WIDTH ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount ); + value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::WIDTH ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT ); break; } case Dali::Actor::Property::HEIGHT_RESIZE_POLICY: { - value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::HEIGHT ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount ); + value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::HEIGHT ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT ); break; } case Dali::Actor::Property::SIZE_SCALE_POLICY: { - value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount ); + value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT ); break; } @@ -3477,9 +3206,21 @@ Property::Value Actor::GetDefaultProperty( Property::Index index ) const break; } - default: + case Dali::DevelActor::Property::BATCH_PARENT: + { + value = mIsBatchParent; + break; + } + + case Dali::DevelActor::Property::SIBLING_ORDER: { - DALI_ASSERT_ALWAYS( false && "Actor Property index invalid" ); // should not come here + value = static_cast(mSiblingOrder); + break; + } + + case Dali::Actor::Property::CLIPPING_MODE: + { + value = mClippingMode; break; } } @@ -3517,7 +3258,8 @@ const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index ind property = animatable->GetSceneGraphProperty(); } - else if ( index >= DEFAULT_PROPERTY_MAX_COUNT ) + else if ( ( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && // Child properties are also stored as custom properties + ( index <= PROPERTY_CUSTOM_MAX_INDEX ) ) { CustomPropertyMetadata* custom = FindCustomProperty( index ); DALI_ASSERT_ALWAYS( custom && "Property index is invalid" ); @@ -3629,7 +3371,8 @@ const PropertyInputImpl* Actor::GetSceneObjectInputProperty( Property::Index ind property = animatable->GetSceneGraphProperty(); } - else if ( index >= DEFAULT_PROPERTY_MAX_COUNT ) + else if ( ( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && // Child properties are also stored as custom properties + ( index <= PROPERTY_CUSTOM_MAX_INDEX ) ) { CustomPropertyMetadata* custom = FindCustomProperty( index ); DALI_ASSERT_ALWAYS( custom && "Property index is invalid" ); @@ -3857,7 +3600,7 @@ int Actor::GetPropertyComponentIndex( Property::Index index ) const return componentIndex; } -void Actor::SetParent( Actor* parent, int index ) +void Actor::SetParent( Actor* parent ) { if( parent ) { @@ -3869,8 +3612,11 @@ void Actor::SetParent( Actor* parent, int index ) parent->OnStage() ) { // Instruct each actor to create a corresponding node in the scene graph - ConnectToStage( index ); + ConnectToStage( parent->GetHierarchyDepth() ); } + + // Resolve the name and index for the child properties if any + ResolveChildProperties(); } else // parent being set to NULL { @@ -4189,14 +3935,13 @@ float Actor::NegotiateFromChildren( Dimension::Type dimension ) for( unsigned int i = 0, count = GetChildCount(); i < count; ++i ) { - Dali::Actor child = GetChildAt( i ); - Actor& childImpl = GetImplementation( child ); + ActorPtr child = GetChildAt( i ); - if( !childImpl.RelayoutDependentOnParent( dimension ) ) + if( !child->RelayoutDependentOnParent( dimension ) ) { // Calculate the min and max points that the children range across - float childPosition = GetDimensionValue( childImpl.GetTargetPosition(), dimension ); - float dimensionSize = childImpl.GetRelayoutSize( dimension ); + float childPosition = GetDimensionValue( child->GetTargetPosition(), dimension ); + float dimensionSize = child->GetRelayoutSize( dimension ); maxDimensionPoint = std::max( maxDimensionPoint, childPosition + dimensionSize ); } } @@ -4325,13 +4070,12 @@ void Actor::NegotiateDimension( Dimension::Type dimension, const Vector2& alloca { for( unsigned int i = 0, count = GetChildCount(); i < count; ++i ) { - Dali::Actor child = GetChildAt( i ); - Actor& childImpl = GetImplementation( child ); + ActorPtr child = GetChildAt( i ); // Only relayout child first if it is not dependent on this actor - if( !childImpl.RelayoutDependentOnParent( dimension ) ) + if( !child->RelayoutDependentOnParent( dimension ) ) { - childImpl.NegotiateDimension( dimension, allocatedSize, recursionStack ); + child->NegotiateDimension( dimension, allocatedSize, recursionStack ); } } } @@ -4430,6 +4174,7 @@ Vector2 Actor::ApplySizeSetPolicy( const Vector2 size ) return size; } } + break; } default: @@ -4469,6 +4214,22 @@ void Actor::SetNegotiatedSize( RelayoutContainer& container ) void Actor::NegotiateSize( const Vector2& allocatedSize, RelayoutContainer& container ) { + // Force a size negotiation for actors that has assigned size during relayout + // This is required as otherwise the flags that force a relayout will not + // necessarilly be set. This will occur if the actor has already been laid out. + // The dirty flags are then cleared. Then if the actor is added back into the + // relayout container afterwards, the dirty flags would still be clear... + // causing a relayout to be skipped. Here we force any actors added to the + // container to be relayed out. + if(GetResizePolicy(Dimension::WIDTH) == ResizePolicy::USE_ASSIGNED_SIZE) + { + SetLayoutNegotiated(false, Dimension::WIDTH); + } + if(GetResizePolicy(Dimension::HEIGHT) == ResizePolicy::USE_ASSIGNED_SIZE) + { + SetLayoutNegotiated(false, Dimension::HEIGHT); + } + // Do the negotiation NegotiateDimensions( allocatedSize ); @@ -4480,12 +4241,25 @@ void Actor::NegotiateSize( const Vector2& allocatedSize, RelayoutContainer& cont for( unsigned int i = 0, count = GetChildCount(); i < count; ++i ) { - Dali::Actor child = GetChildAt( i ); + ActorPtr child = GetChildAt( i ); + + // Forces children that have already been laid out to be relayed out + // if they have assigned size during relayout. + if(child->GetResizePolicy(Dimension::WIDTH) == ResizePolicy::USE_ASSIGNED_SIZE) + { + child->SetLayoutNegotiated(false, Dimension::WIDTH); + child->SetLayoutDirty(true, Dimension::WIDTH); + } + if(child->GetResizePolicy(Dimension::HEIGHT) == ResizePolicy::USE_ASSIGNED_SIZE) + { + child->SetLayoutNegotiated(false, Dimension::HEIGHT); + child->SetLayoutDirty(true, Dimension::HEIGHT); + } // Only relayout if required - if( GetImplementation( child ).RelayoutRequired() ) + if( child->RelayoutRequired() ) { - container.Add( child, newBounds ); + container.Add( Dali::Actor( child.Get() ), newBounds ); } } } @@ -4531,7 +4305,7 @@ Vector2 Actor::GetPreferredSize() const { if ( mRelayoutData ) { - return mRelayoutData->preferredSize; + return Vector2( mRelayoutData->preferredSize ); } return GetDefaultPreferredSize(); @@ -4599,6 +4373,11 @@ float Actor::GetMaximumSize( Dimension::Type dimension ) const return FLT_MAX; // Default } +Object* Actor::GetParentObject() const +{ + return mParent; +} + } // namespace Internal } // namespace Dali