/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/public-api/math/radian.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/devel-api/actors/actor-devel.h>
-#include <dali/devel-api/object/weak-handle.h>
#include <dali/devel-api/scripting/scripting.h>
#include <dali/internal/common/internal-constants.h>
#include <dali/internal/event/common/event-thread-services.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/common/scene-impl.h>
+#include <dali/internal/event/common/thread-local-storage.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>
namespace Internal
{
-unsigned int Actor::mActorCounter = 0;
-
namespace
{
/// Using a function because of library initialisation order. Vector3::ONE may not have been initialised yet.
const SizeScalePolicy::Type DEFAULT_SIZE_SCALE_POLICY = SizeScalePolicy::USE_SIZE_SET;
-int GetSiblingOrder( ActorPtr actor )
-{
- Property::Value value = actor->GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
- int order;
- value.Get( order );
- return order;
-}
-
-bool ValidateActors( const Internal::Actor& actor, const Internal::Actor& target )
-{
- bool validTarget = true;
-
- if( &actor == &target )
- {
- DALI_LOG_WARNING( "Source actor and target actor can not be the same, Sibling order not changed.\n" );
- validTarget = false;
- }
- else if( actor.GetParent() != target.GetParent() )
- {
- DALI_LOG_WARNING( "Source actor and target actor need to have common parent, Sibling order not changed.\n" );
- validTarget = false;
- }
-
- return validTarget;
-}
-
} // unnamed namespace
/**
: sizeModeFactor( GetDefaultSizeModeFactor() ), preferredSize( GetDefaultPreferredSize() ), sizeSetPolicy( DEFAULT_SIZE_SCALE_POLICY ), relayoutEnabled( false ), insideRelayout( false )
{
// Set size negotiation defaults
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
resizePolicies[ i ] = ResizePolicy::DEFAULT;
useAssignedSize[ i ] = false;
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( "reservedProperty01", STRING, true, false, false, Dali::Actor::Property::RESERVED_PROPERTY_01 ) // This property was removed, but to keep binary compatibility and TypeRegister test app, remain it here.
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( "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( "layoutDirection", STRING, true, false, false, Dali::Actor::Property::LAYOUT_DIRECTION )
+DALI_PROPERTY( "inheritLayoutDirection", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION )
DALI_PROPERTY( "siblingOrder", INTEGER, true, false, false, Dali::DevelActor::Property::SIBLING_ORDER )
DALI_PROPERTY( "opacity", FLOAT, true, true, true, Dali::DevelActor::Property::OPACITY )
DALI_PROPERTY( "screenPosition", VECTOR2, false, false, false, Dali::DevelActor::Property::SCREEN_POSITION )
DALI_PROPERTY( "positionUsesAnchorPoint", BOOLEAN, true, false, false, Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT )
-DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
+DALI_PROPERTY( "culled", BOOLEAN, false, false, true, Dali::DevelActor::Property::CULLED )
+DALI_PROPERTY( "updateSizeHint", VECTOR2, true, true, true, Dali::DevelActor::Property::UPDATE_SIZE_HINT )
+DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX, ActorDefaultProperties )
// Signals
const char* const SIGNAL_OFF_STAGE = "offStage";
const char* const SIGNAL_ON_RELAYOUT = "onRelayout";
const char* const SIGNAL_TOUCH = "touch";
+const char* const SIGNAL_VISIBILITY_CHANGED = "visibilityChanged";
+const char* const SIGNAL_LAYOUT_DIRECTION_CHANGED = "layoutDirectionChanged";
+const char* const SIGNAL_CHILD_ADDED = "childAdded";
+const char* const SIGNAL_CHILD_REMOVED = "childRemoved";
// Actions
return Dali::Actor::New();
}
-TypeRegistration mType( typeid(Dali::Actor), typeid(Dali::Handle), CreateActor );
+TypeRegistration mType( typeid(Dali::Actor), typeid(Dali::Handle), CreateActor, ActorDefaultProperties );
SignalConnectorType signalConnector1( mType, SIGNAL_TOUCHED, &Actor::DoConnectSignal );
SignalConnectorType signalConnector2( mType, SIGNAL_HOVERED, &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 );
+SignalConnectorType signalConnector8( mType, SIGNAL_VISIBILITY_CHANGED, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector9( mType, SIGNAL_LAYOUT_DIRECTION_CHANGED, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector10( mType, SIGNAL_CHILD_ADDED, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector11( mType, SIGNAL_CHILD_REMOVED, &Actor::DoConnectSignal );
TypeAction a1( mType, ACTION_SHOW, &Actor::DoAction );
TypeAction a2( mType, ACTION_HIDE, &Actor::DoAction );
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( ClippingMode, CLIP_CHILDREN )
DALI_ENUM_TO_STRING_TABLE_END( CLIPPING_MODE )
+DALI_ENUM_TO_STRING_TABLE_BEGIN( LAYOUT_DIRECTION )
+DALI_ENUM_TO_STRING_WITH_SCOPE( LayoutDirection, LEFT_TO_RIGHT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( LayoutDirection, RIGHT_TO_LEFT )
+DALI_ENUM_TO_STRING_TABLE_END( LAYOUT_DIRECTION )
bool GetAnchorPointConstant( const std::string& value, Vector3& anchor )
{
- for( unsigned int i = 0; i < ANCHOR_CONSTANT_TABLE_COUNT; ++i )
+ for( uint32_t i = 0; i < ANCHOR_CONSTANT_TABLE_COUNT; ++i )
{
- size_t sizeIgnored = 0;
+ uint32_t sizeIgnored = 0;
if( CompareTokens( value.c_str(), ANCHOR_CONSTANT_TABLE[ i ].name, sizeIgnored ) )
{
anchor = ANCHOR_CONSTANT_TABLE[ i ].value;
ActorPtr Actor::New()
{
- ActorPtr actor( new Actor( BASIC ) );
+ // pass a reference to actor, actor does not own its node
+ ActorPtr actor( new Actor( BASIC, *CreateNode() ) );
// Second-phase construction
actor->Initialize();
return actor;
}
+const SceneGraph::Node* Actor::CreateNode()
+{
+ // create node. Nodes are owned by the update manager
+ SceneGraph::Node* node = SceneGraph::Node::New();
+ OwnerPointer< SceneGraph::Node > transferOwnership( node );
+ Internal::ThreadLocalStorage* tls = Internal::ThreadLocalStorage::GetInternal();
+ AddNodeMessage( tls->GetUpdateManager(), transferOwnership );
+
+ return node;
+}
+
const std::string& Actor::GetName() const
{
return mName;
{
mName = name;
- if( NULL != mNode )
- {
- // ATTENTION: string for debug purposes is not thread safe.
- DALI_LOG_SET_OBJECT_STRING( const_cast< SceneGraph::Node* >( mNode ), name );
- }
+ // ATTENTION: string for debug purposes is not thread safe.
+ DALI_LOG_SET_OBJECT_STRING( const_cast< SceneGraph::Node* >( &GetNode() ), name );
}
-unsigned int Actor::GetId() const
+uint32_t Actor::GetId() const
{
- return mId;
+ return GetNode().GetId();
}
bool Actor::OnStage() const
// if we already have parent, unparent us first
if( oldParent )
{
- oldParent->Remove( child ); // This causes OnChildRemove callback
+ oldParent->Remove( child ); // This causes OnChildRemove callback & ChildRemoved signal
// Old parent may need to readjust to missing child
if( oldParent->RelayoutDependentOnChildren() )
// Notification for derived classes
OnChildAdd( child );
+ EmitChildAddedSignal( child );
+
+ InheritLayoutDirectionRecursively( ActorPtr( &child ), mLayoutDirection );
// Only put in a relayout request if there is a suitable dependency
if( RelayoutDependentOnChildren() )
// Notification for derived classes
OnChildRemove( child );
+ EmitChildRemovedSignal( child );
}
void Actor::Unparent()
}
}
-unsigned int Actor::GetChildCount() const
+uint32_t Actor::GetChildCount() const
{
- return ( NULL != mChildren ) ? mChildren->size() : 0;
+ return ( NULL != mChildren ) ? static_cast<uint32_t>( mChildren->size() ) : 0; // only 4,294,967,295 children per actor
}
-ActorPtr Actor::GetChildAt( unsigned int index ) const
+ActorPtr Actor::GetChildAt( uint32_t index ) const
{
DALI_ASSERT_ALWAYS( index < GetChildCount() );
return child;
}
-ActorPtr Actor::FindChildById( const unsigned int id )
+ActorPtr Actor::FindChildById( const uint32_t id )
{
ActorPtr child = 0;
- if( id == mId )
+ if( id == GetId() )
{
child = this;
}
void Actor::SetParentOrigin( const Vector3& origin )
{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SetParentOriginMessage( GetEventThreadServices(), *mNode, origin );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SetParentOriginMessage( GetEventThreadServices(), GetNode(), origin );
// Cache for event-thread access
if( !mParentOrigin )
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( GetEventThreadServices(), *mNode, anchor );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SetAnchorPointMessage( GetEventThreadServices(), GetNode(), anchor );
// Cache for event-thread access
if( !mAnchorPoint )
{
mTargetPosition = position;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, position );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, position );
}
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::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );
}
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::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );
}
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::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );
}
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::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelative, distance );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelative, distance );
}
const Vector3& Actor::GetCurrentPosition() const
{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetPosition(GetEventThreadServices().GetEventBufferIndex());
- }
-
- return Vector3::ZERO;
+ // node is being used in a separate thread; copy the value from the previous update
+ return GetNode().GetPosition(GetEventThreadServices().GetEventBufferIndex());
}
const Vector3& Actor::GetTargetPosition() const
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( GetEventThreadServices().GetEventBufferIndex() );
- }
-
- return Vector3::ZERO;
+ // node is being used in a separate thread; copy the value from the previous update
+ return GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
}
const Vector2 Actor::GetCurrentScreenPosition() const
{
- if( OnStage() && NULL != mNode )
+ if( mScene && OnStage() )
{
- StagePtr stage = Stage::GetCurrent();
- Vector3 worldPosition = mNode->GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
- Vector3 actorSize = GetCurrentSize() * GetCurrentScale();
- Vector2 halfStageSize( stage->GetSize() * 0.5f ); // World position origin is center of stage
+ Vector3 worldPosition = GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
+ Vector3 cameraPosition = mScene->GetDefaultCameraActor().GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
+ worldPosition -= cameraPosition;
+
+ Vector3 actorSize = GetCurrentSize() * GetCurrentWorldScale();
+ Vector2 halfSceneSize( mScene->GetSize() * 0.5f ); // World position origin is center of scene
Vector3 halfActorSize( actorSize * 0.5f );
Vector3 anchorPointOffSet = halfActorSize - actorSize * ( mPositionUsesAnchorPoint ? GetCurrentAnchorPoint() : AnchorPoint::TOP_LEFT );
- return Vector2( halfStageSize.width + worldPosition.x - anchorPointOffSet.x,
- halfStageSize.height + worldPosition.y - anchorPointOffSet.y );
+ return Vector2( halfSceneSize.width + worldPosition.x - anchorPointOffSet.x,
+ halfSceneSize.height + worldPosition.y - anchorPointOffSet.y );
}
return Vector2::ZERO;
}
-void Actor::SetPositionInheritanceMode( PositionInheritanceMode mode )
-{
- // this flag is not animatable so keep the value
- mPositionInheritanceMode = mode;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value
- SetInheritPositionMessage( GetEventThreadServices(), *mNode, mode == INHERIT_PARENT_POSITION );
- }
-}
-
-PositionInheritanceMode Actor::GetPositionInheritanceMode() const
-{
- // Cached for event-thread access
- return mPositionInheritanceMode;
-}
-
void Actor::SetInheritPosition( bool inherit )
{
- if( mInheritPosition != inherit && NULL != mNode )
+ if( mInheritPosition != inherit )
{
- // non animateable so keep local copy
+ // non animatable so keep local copy
mInheritPosition = inherit;
- SetInheritPositionMessage( GetEventThreadServices(), *mNode, inherit );
+ SetInheritPositionMessage( GetEventThreadServices(), GetNode(), inherit );
}
}
{
mTargetOrientation = orientation;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::Bake, orientation );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::Bake, orientation );
}
void Actor::RotateBy( const Radian& angle, const Vector3& axis )
{
mTargetOrientation *= Quaternion( relativeRotation );
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::BakeRelative, relativeRotation );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::BakeRelative, relativeRotation );
}
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->GetOrientation(GetEventThreadServices().GetEventBufferIndex());
- }
-
- return Quaternion::IDENTITY;
+ // node is being used in a separate thread; copy the value from the previous update
+ return GetNode().GetOrientation(GetEventThreadServices().GetEventBufferIndex());
}
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->GetWorldOrientation( GetEventThreadServices().GetEventBufferIndex() );
- }
-
- return Quaternion::IDENTITY;
+ // node is being used in a separate thread; copy the value from the previous update
+ return GetNode().GetWorldOrientation( GetEventThreadServices().GetEventBufferIndex() );
}
void Actor::SetScale( float scale )
{
mTargetScale = scale;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, scale );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, scale );
}
void Actor::SetScaleX( float x )
{
mTargetScale.x = x;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );
}
void Actor::SetScaleY( float y )
{
mTargetScale.y = y;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );
}
void Actor::SetScaleZ( float z )
{
mTargetScale.z = z;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );
}
void Actor::ScaleBy(const Vector3& relativeScale)
{
mTargetScale *= relativeScale;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelativeMultiply, relativeScale );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelativeMultiply, relativeScale );
}
const Vector3& Actor::GetCurrentScale() const
{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetScale(GetEventThreadServices().GetEventBufferIndex());
- }
-
- return Vector3::ONE;
+ // node is being used in a separate thread; copy the value from the previous update
+ return GetNode().GetScale(GetEventThreadServices().GetEventBufferIndex());
}
const Vector3& Actor::GetCurrentWorldScale() const
{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetWorldScale( GetEventThreadServices().GetEventBufferIndex() );
- }
-
- return Vector3::ONE;
+ // node is being used in a separate thread; copy the value from the previous update
+ return GetNode().GetWorldScale( GetEventThreadServices().GetEventBufferIndex() );
}
void Actor::SetInheritScale( bool inherit )
{
-
- if( mInheritScale != inherit && NULL != mNode )
+ if( mInheritScale != inherit )
{
- // non animateable so keep local copy
+ // non animatable 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 );
+ // node is being used in a separate thread; queue a message to set the value
+ SetInheritScaleMessage( GetEventThreadServices(), GetNode(), inherit );
}
}
Matrix Actor::GetCurrentWorldMatrix() const
{
- if( NULL != mNode )
- {
- return mNode->GetWorldMatrix(0);
- }
-
- return Matrix::IDENTITY;
+ return GetNode().GetWorldMatrix(0);
}
void Actor::SetVisible( bool visible )
bool Actor::IsVisible() const
{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; copy the value from the previous update
- return mNode->IsVisible( GetEventThreadServices().GetEventBufferIndex() );
- }
-
- return true;
+ // node is being used in a separate thread; copy the value from the previous update
+ return GetNode().IsVisible( GetEventThreadServices().GetEventBufferIndex() );
}
void Actor::SetOpacity( float opacity )
{
mTargetColor.a = 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( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeW, opacity );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mColor, &AnimatableProperty<Vector4>::BakeW, opacity );
}
float Actor::GetCurrentOpacity() const
{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetOpacity(GetEventThreadServices().GetEventBufferIndex());
- }
-
- return 1.0f;
+ // node is being used in a separate thread; copy the value from the previous update
+ return GetNode().GetOpacity(GetEventThreadServices().GetEventBufferIndex());
}
ClippingMode::Type Actor::GetClippingMode() const
return mClippingMode;
}
-unsigned int Actor::GetSortingDepth()
+uint32_t Actor::GetSortingDepth()
{
return mSortedDepth;
}
const Vector4& Actor::GetCurrentWorldColor() const
{
- if( NULL != mNode )
- {
- return mNode->GetWorldColor( GetEventThreadServices().GetEventBufferIndex() );
- }
-
- return Color::WHITE;
+ return GetNode().GetWorldColor( GetEventThreadServices().GetEventBufferIndex() );
}
void Actor::SetColor( const Vector4& color )
{
mTargetColor = 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( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::Bake, color );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mColor, &AnimatableProperty<Vector4>::Bake, color );
}
void Actor::SetColorRed( float red )
{
mTargetColor.r = 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( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeX, red );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mColor, &AnimatableProperty<Vector4>::BakeX, red );
}
void Actor::SetColorGreen( float green )
{
mTargetColor.g = 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( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeY, green );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mColor, &AnimatableProperty<Vector4>::BakeY, green );
}
void Actor::SetColorBlue( float blue )
{
mTargetColor.b = blue;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeZ, blue );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mColor, &AnimatableProperty<Vector4>::BakeZ, blue );
}
const Vector4& Actor::GetCurrentColor() const
{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetColor(GetEventThreadServices().GetEventBufferIndex());
- }
-
- return Color::WHITE;
+ // node is being used in a separate thread; copy the value from the previous update
+ return GetNode().GetColor(GetEventThreadServices().GetEventBufferIndex());
}
void Actor::SetInheritOrientation( bool inherit )
{
- if( mInheritOrientation != inherit && NULL != mNode)
+ if( mInheritOrientation != inherit )
{
- // non animateable so keep local copy
+ // non animatable 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 );
+ // node is being used in a separate thread; queue a message to set the value
+ SetInheritOrientationMessage( GetEventThreadServices(), GetNode(), inherit );
}
}
void Actor::SetColorMode( ColorMode colorMode )
{
- // non animateable so keep local copy
+ // non animatable 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( GetEventThreadServices(), *mNode, colorMode );
- }
+ // node is being used in a separate thread; queue a message to set the value
+ SetColorModeMessage( GetEventThreadServices(), GetNode(), colorMode );
}
ColorMode Actor::GetColorMode() const
// dont allow recursive loop
DALI_ASSERT_ALWAYS( !mInsideOnSizeSet && "Cannot call SetSize from OnSizeSet" );
// check that we have a node AND the new size width, height or depth is at least a little bit different from the old one
- if( ( NULL != mNode )&&
- ( ( fabsf( mTargetSize.width - size.width ) > Math::MACHINE_EPSILON_1 )||
- ( fabsf( mTargetSize.height- size.height ) > Math::MACHINE_EPSILON_1 )||
- ( fabsf( mTargetSize.depth - size.depth ) > Math::MACHINE_EPSILON_1 ) ) )
+ if( ( fabsf( mTargetSize.width - size.width ) > Math::MACHINE_EPSILON_1 )||
+ ( fabsf( mTargetSize.height- size.height ) > Math::MACHINE_EPSILON_1 )||
+ ( fabsf( mTargetSize.depth - size.depth ) > Math::MACHINE_EPSILON_1 ) )
{
mTargetSize = size;
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, mTargetSize );
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, mTargetSize );
// Notification for derived classes
mInsideOnSizeSet = true;
{
mTargetSize.width = width;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, width );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, width );
}
RelayoutRequest();
{
mTargetSize.height = height;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, height );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, height );
}
RelayoutRequest();
{
mTargetSize.depth = depth;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, depth );
- }
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, depth );
}
Vector3 Actor::GetTargetSize() const
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( GetEventThreadServices().GetEventBufferIndex() );
- }
-
- return Vector3::ZERO;
+ // node is being used in a separate thread; copy the value from the previous update
+ return GetNode().GetSize( GetEventThreadServices().GetEventBufferIndex() );
}
Vector3 Actor::GetNaturalSize() const
ResizePolicy::Type originalWidthPolicy = GetResizePolicy(Dimension::WIDTH);
ResizePolicy::Type originalHeightPolicy = GetResizePolicy(Dimension::HEIGHT);
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
if ( mRelayoutData )
{
// If more than one dimension is requested, just return the first one found
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) )
{
EnsureRelayoutData();
mRelayoutData->sizeSetPolicy = policy;
+
+ // Trigger relayout on this control
+ RelayoutRequest();
}
SizeScalePolicy::Type Actor::GetSizeScalePolicy() const
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
if ( mRelayoutData )
{
// If more than one dimension is requested, just return the first one found
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) )
{
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
{
if ( mRelayoutData )
{
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionDirty[ i ] )
{
return mRelayoutData && mRelayoutData->relayoutEnabled && IsLayoutDirty( dimension );
}
-unsigned int Actor::AddRenderer( Renderer& renderer )
+uint32_t Actor::AddRenderer( Renderer& renderer )
{
if( !mRenderers )
{
mRenderers = new RendererContainer;
}
- unsigned int index = mRenderers->size();
+ uint32_t index = static_cast<uint32_t>( mRenderers->size() ); // 4,294,967,295 renderers per actor
RendererPtr rendererPtr = RendererPtr( &renderer );
mRenderers->push_back( rendererPtr );
- AddRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
+ AttachRendererMessage( GetEventThreadServices(), GetNode(), renderer.GetRendererSceneObject() );
return index;
}
-unsigned int Actor::GetRendererCount() const
+uint32_t Actor::GetRendererCount() const
{
- unsigned int rendererCount(0);
+ uint32_t rendererCount(0);
if( mRenderers )
{
- rendererCount = mRenderers->size();
+ rendererCount = static_cast<uint32_t>( mRenderers->size() ); // 4,294,967,295 renderers per actor
}
return rendererCount;
}
-RendererPtr Actor::GetRendererAt( unsigned int index )
+RendererPtr Actor::GetRendererAt( uint32_t index )
{
RendererPtr renderer;
if( index < GetRendererCount() )
if( (*iter).Get() == &renderer )
{
mRenderers->erase( iter );
- RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
+ DetachRendererMessage( GetEventThreadServices(), GetNode(), renderer.GetRendererSceneObject() );
break;
}
}
}
}
-void Actor::RemoveRenderer( unsigned int index )
+void Actor::RemoveRenderer( uint32_t index )
{
if( index < GetRendererCount() )
{
RendererPtr renderer = ( *mRenderers )[ index ];
- RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.Get()->GetRendererSceneObject() );
+ DetachRendererMessage( GetEventThreadServices(), GetNode(), renderer.Get()->GetRendererSceneObject() );
mRenderers->erase( mRenderers->begin()+index );
}
}
{
// this flag is not animatable so keep the value
mDrawMode = drawMode;
- 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 );
- }
+
+ // node is being used in a separate thread; queue a message to set the value
+ SetDrawModeMessage( GetEventThreadServices(), GetNode(), drawMode );
}
DrawMode::Type Actor::GetDrawMode() const
bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const
{
// only valid when on-stage
- StagePtr stage = Stage::GetCurrent();
- if( stage && OnStage() )
+ if( mScene && OnStage() )
{
- const RenderTaskList& taskList = stage->GetRenderTaskList();
+ const RenderTaskList& taskList = mScene->GetRenderTaskList();
Vector2 converted( screenX, screenY );
// do a reverse traversal of all lists (as the default onscreen one is typically the last one)
- const int taskCount = taskList.GetTaskCount();
- for( int i = taskCount - 1; i >= 0; --i )
+ uint32_t taskCount = taskList.GetTaskCount();
+ for( uint32_t i = taskCount; i > 0; --i )
{
- Dali::RenderTask task = taskList.GetTask( i );
- if( ScreenToLocal( Dali::GetImplementation( task ), localX, localY, screenX, screenY ) )
+ RenderTaskPtr task = taskList.GetTask( i - 1 );
+ if( ScreenToLocal( *task, localX, localY, screenX, screenY ) )
{
// found a task where this conversion was ok so return
return true;
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
+ // Early-out if not on stage
if( !OnStage() )
{
return false;
// Get the ModelView matrix
Matrix modelView;
- Matrix::Multiply( modelView, mNode->GetWorldMatrix(0), viewMatrix );
+ Matrix::Multiply( modelView, GetNode().GetWorldMatrix(0), viewMatrix );
// Calculate the inverted ModelViewProjection matrix; this will be used for 2 unprojects
Matrix invertedMvp( false/*don't init*/);
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 - static_cast<float>( viewport.x ), static_cast<float>( viewport.height ) - screenY - static_cast<float>( viewport.y ), 0.f, 1.f );
Vector4 nearPos;
if( success )
{
- success = Unproject( screenPos, invertedMvp, viewport.width, viewport.height, nearPos );
+ success = Unproject( screenPos, invertedMvp, static_cast<float>( viewport.width ), static_cast<float>( viewport.height ), nearPos );
}
Vector4 farPos;
if( success )
{
screenPos.z = 1.0f;
- success = Unproject( screenPos, invertedMvp, viewport.width, viewport.height, farPos );
+ success = Unproject( screenPos, invertedMvp, static_cast<float>( viewport.width ), static_cast<float>( viewport.height ), farPos );
}
if( success )
C = o dot o - r^2
*/
- // Early out if mNode is NULL
- if( !mNode )
+ // Early-out if not on stage
+ if( !OnStage() )
{
return false;
}
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 ) );
+ const Vector3& translation( GetNode().GetWorldPosition( bufferIndex ) );
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 ) );
+ const Vector3& size( GetNode().GetSize( bufferIndex ) );
// Scale the sphere.
- const Vector3& scale( mNode->GetWorldScale( bufferIndex ) );
+ const Vector3& scale( GetNode().GetWorldScale( bufferIndex ) );
const float width = size.width * scale.width;
const float height = size.height * scale.height;
{
bool hit = false;
- if( OnStage() && NULL != mNode )
+ if( OnStage() )
{
// Transforms the ray to the local reference system.
// Calculate the inverse of Model matrix
Matrix invModelMatrix( false/*don't init*/);
BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
- invModelMatrix = mNode->GetWorldMatrix(0);
+ invModelMatrix = GetNode().GetWorldMatrix(0);
invModelMatrix.Invert();
Vector4 rayOriginLocal( invModelMatrix * rayOrigin );
// Ray travels distance * rayDirLocal to intersect with plane.
distance = a / b;
- const Vector3& size = mNode->GetSize( bufferIndex );
+ const Vector3& size = GetNode().GetSize( bufferIndex );
hitPointLocal.x = rayOriginLocal.x + rayDirLocal.x * distance + size.x * 0.5f;
hitPointLocal.y = rayOriginLocal.y + rayDirLocal.y * distance + size.y * 0.5f;
}
}
+void Actor::EmitLayoutDirectionChangedSignal( LayoutDirection::Type type )
+{
+ if( ! mLayoutDirectionChangedSignal.Empty() )
+ {
+ Dali::Actor handle( this );
+ mLayoutDirectionChangedSignal.Emit( handle, type );
+ }
+}
+
+void Actor::EmitChildAddedSignal( Actor& child )
+{
+ if( ! mChildAddedSignal.Empty() )
+ {
+ Dali::Actor handle( &child );
+ mChildAddedSignal.Emit( handle );
+ }
+}
+
+void Actor::EmitChildRemovedSignal( Actor& child )
+{
+ if( ! mChildRemovedSignal.Empty() )
+ {
+ Dali::Actor handle( &child );
+ mChildRemovedSignal.Emit( handle );
+ }
+}
+
Dali::Actor::TouchSignalType& Actor::TouchedSignal()
{
return mTouchedSignal;
return mVisibilityChangedSignal;
}
+Dali::Actor::LayoutDirectionChangedSignalType& Actor::LayoutDirectionChangedSignal()
+{
+ return mLayoutDirectionChangedSignal;
+}
+
+DevelActor::ChildChangedSignalType& Actor::ChildAddedSignal()
+{
+ return mChildAddedSignal;
+}
+
+DevelActor::ChildChangedSignalType& Actor::ChildRemovedSignal()
+{
+ return mChildRemovedSignal;
+}
+
+DevelActor::ChildOrderChangedSignalType& Actor::ChildOrderChangedSignal()
+{
+ return mChildOrderChangedSignal;
+}
+
bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
{
bool connected( true );
{
actor->TouchSignal().Connect( tracker, functor );
}
+ else if( 0 == signalName.compare( SIGNAL_VISIBILITY_CHANGED ) )
+ {
+ actor->VisibilityChangedSignal().Connect( tracker, functor );
+ }
+ else if( 0 == signalName.compare( SIGNAL_LAYOUT_DIRECTION_CHANGED ) )
+ {
+ actor->LayoutDirectionChangedSignal().Connect( tracker, functor );
+ }
+ else if( 0 == signalName.compare( SIGNAL_CHILD_ADDED ) )
+ {
+ actor->ChildAddedSignal().Connect( tracker, functor );
+ }
+ else if( 0 == signalName.compare( SIGNAL_CHILD_REMOVED ) )
+ {
+ actor->ChildRemovedSignal().Connect( tracker, functor );
+ }
else
{
// signalName does not match any signal
return connected;
}
-Actor::Actor( DerivedType derivedType )
-: mParent( NULL ),
+Actor::Actor( DerivedType derivedType, const SceneGraph::Node& node )
+: Object( &node ),
+ mScene( nullptr ),
+ mParent( NULL ),
mChildren( NULL ),
mRenderers( NULL ),
- mNode( NULL ),
mParentOrigin( NULL ),
mAnchorPoint( NULL ),
mRelayoutData( NULL ),
mGestureData( NULL ),
+ mTouchedSignal(),
+ mTouchSignal(),
+ mHoveredSignal(),
+ mWheelEventSignal(),
+ mOnStageSignal(),
+ mOffStageSignal(),
+ mOnRelayoutSignal(),
+ mVisibilityChangedSignal(),
+ mLayoutDirectionChangedSignal(),
+ mChildAddedSignal(),
+ mChildRemovedSignal(),
+ mChildOrderChangedSignal(),
mTargetOrientation( Quaternion::IDENTITY ),
mTargetColor( Color::WHITE ),
mTargetSize( Vector3::ZERO ),
mTargetPosition( Vector3::ZERO ),
mTargetScale( Vector3::ONE ),
mName(),
- mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
mSortedDepth( 0u ),
mDepth( 0u ),
- mSiblingOrder(0u),
mIsRoot( ROOT_LAYER == derivedType ),
mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ),
mIsOnStage( false ),
mInheritScale( true ),
mPositionUsesAnchorPoint( true ),
mVisible( true ),
+ mInheritLayoutDirection( true ),
+ mLayoutDirection( LayoutDirection::LEFT_TO_RIGHT ),
mDrawMode( DrawMode::NORMAL ),
- mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ),
mColorMode( Node::DEFAULT_COLOR_MODE ),
mClippingMode( ClippingMode::DISABLED )
{
void Actor::Initialize()
{
- // Node creation
- SceneGraph::Node* node = CreateNode();
-
- AddNodeMessage( GetEventThreadServices().GetUpdateManager(), *node ); // Pass ownership to scene-graph
- mNode = node; // Keep raw-pointer to Node
-
OnInitialize();
GetEventThreadServices().RegisterObject( this );
// Guard to allow handle destruction after Core has been destroyed
if( EventThreadServices::IsCoreRunning() )
{
- if( NULL != mNode )
+ // Root layer will destroy its node in its own destructor
+ if ( !mIsRoot )
{
- DestroyNodeMessage( GetEventThreadServices().GetUpdateManager(), *mNode );
- mNode = NULL; // Node is about to be destroyed
- }
+ DestroyNodeMessage( GetEventThreadServices().GetUpdateManager(), GetNode() );
- GetEventThreadServices().UnregisterObject( this );
+ GetEventThreadServices().UnregisterObject( this );
+ }
}
// Cleanup optional gesture data
delete mAnchorPoint;
// Delete optional relayout data
- if( mRelayoutData )
- {
- delete mRelayoutData;
- }
+ delete mRelayoutData;
}
-void Actor::ConnectToStage( unsigned int parentDepth )
+void Actor::ConnectToStage( uint32_t parentDepth )
{
// This container is used instead of walking the Actor hierarchy.
// It protects us when the Actor hierarchy is modified during OnStageConnectionExternal callbacks.
ActorContainer connectionList;
- StagePtr stage = Stage::GetCurrent();
- if( stage )
+ if( mScene )
{
- stage->RequestRebuildDepthTree();
+ mScene->RequestRebuildDepthTree();
}
// This stage is atomic i.e. not interrupted by user callbacks.
RelayoutRequest();
}
-void Actor::RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth )
+void Actor::RecursiveConnectToStage( ActorContainer& connectionList, uint32_t depth )
{
DALI_ASSERT_ALWAYS( !OnStage() );
mIsOnStage = true;
- mDepth = depth;
+ mDepth = static_cast< uint16_t >( depth ); // overflow ignored, not expected in practice
ConnectToSceneGraph();
ActorConstIter endIter = mChildren->end();
for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
{
- (*iter)->RecursiveConnectToStage( connectionList, depth+1 );
+ (*iter)->SetScene( *mScene );
+ (*iter)->RecursiveConnectToStage( connectionList, depth + 1 );
}
}
}
*/
void Actor::ConnectToSceneGraph()
{
- DALI_ASSERT_DEBUG( mNode != NULL); DALI_ASSERT_DEBUG( mParent != NULL); DALI_ASSERT_DEBUG( mParent->mNode != NULL );
+ DALI_ASSERT_DEBUG( mParent != NULL);
- if( NULL != mNode )
- {
- // Reparent Node in next Update
- ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode );
- }
+ // Reparent Node in next Update
+ ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), mParent->GetNode(), GetNode() );
// Request relayout on all actors that are added to the scenegraph
RelayoutRequest();
// It protects us when the Actor hierachy is modified during OnStageDisconnectionExternal callbacks.
ActorContainer disconnectionList;
- StagePtr stage = Stage::GetCurrent();
- if( stage )
+ if( mScene )
{
- stage->RequestRebuildDepthTree();
+ mScene->RequestRebuildDepthTree();
}
// This stage is atomic i.e. not interrupted by user callbacks
void Actor::RecursiveDisconnectFromStage( ActorContainer& disconnectionList )
{
- DALI_ASSERT_ALWAYS( OnStage() );
+ // need to change state first so that internals relying on IsOnStage() inside OnStageDisconnectionInternal() get the correct value
+ mIsOnStage = false;
// Recursively disconnect children
if( mChildren )
OnStageDisconnectionInternal();
DisconnectFromSceneGraph();
-
- mIsOnStage = false;
}
/**
{
bool connected( false );
- if( OnStage() && ( NULL != mNode ) )
+ if( OnStage() )
{
- if( IsRoot() || mNode->GetParent() )
+ if( IsRoot() || GetNode().GetParent() )
{
connected = true;
}
return connected;
}
-// This method generates the depth tree using the recursive function below,
-// then walks the tree and sets a depth index based on traversal order. It
-// sends a single message to update manager to update all the actor's nodes in this
-// tree with the depth index. The sceneGraphNodeDepths vector's elements are ordered
-// by depth, and could be used to reduce sorting in the update thread.
+// This method initiates traversal of the actor tree using depth-first
+// traversal to set a depth index based on traversal order. It sends a
+// single message to update manager to update all the actor's nodes in
+// this tree with the depth index. The sceneGraphNodeDepths vector's
+// elements are ordered by depth, and could be used to reduce sorting
+// in the update thread.
void Actor::RebuildDepthTree()
{
DALI_LOG_TIMER_START(depthTimer);
- DepthNodeMemoryPool nodeMemoryPool;
- ActorDepthTreeNode* rootNode = new (nodeMemoryPool.AllocateRaw()) ActorDepthTreeNode( this, mSiblingOrder );
-
- int actorCount = BuildDepthTree( nodeMemoryPool, rootNode );
-
// Vector of scene-graph nodes and their depths to send to UpdateManager
// in a single message
- SceneGraph::NodeDepths* sceneGraphNodeDepths = new SceneGraph::NodeDepths(actorCount);
-
- // Traverse depth tree and set mSortedDepth on each actor and scenegraph node
- uint32_t sortOrder = 1u; // Don't start at zero, as visual depth can be negative
- ActorDepthTreeNode* currentNode = rootNode;
- bool firstVisit = true;
- while( currentNode != rootNode || firstVisit)
- {
- firstVisit = false;
-
- // Visit node, performing action
- for( std::vector<Actor*>::iterator iter = currentNode->mActors.begin(); iter != currentNode->mActors.end(); ++iter )
- {
- (*iter)->mSortedDepth = sortOrder * DevelLayer::SIBLING_ORDER_MULTIPLIER;
- sceneGraphNodeDepths->Add( const_cast<SceneGraph::Node*>((*iter)->mNode), (*iter)->mSortedDepth );
- }
- ++sortOrder;
-
- // Descend tree
- if( currentNode->mFirstChildNode )
- {
- currentNode = currentNode->mFirstChildNode;
- }
- else // leaf node, goto next sibling, or return up tree.
- {
- bool breakout=false;
- while( ! currentNode->mNextSiblingNode )
- {
- if( currentNode == rootNode ) // If we get to root of tree, stop
- {
- breakout = true;
- break;
- }
- currentNode = currentNode->mParentNode;
- }
+ OwnerPointer<SceneGraph::NodeDepths> sceneGraphNodeDepths( new SceneGraph::NodeDepths() );
- if( breakout )
- {
- break;
- }
- currentNode = currentNode->mNextSiblingNode;
- }
- }
+ int32_t depthIndex = 1;
+ DepthTraverseActorTree( sceneGraphNodeDepths, depthIndex );
SetDepthIndicesMessage( GetEventThreadServices().GetUpdateManager(), sceneGraphNodeDepths );
- DALI_LOG_TIMER_END(depthTimer, gLogFilter, Debug::Concise, "Depth tree create time: ");
- rootNode->~ActorDepthTreeNode();
+ DALI_LOG_TIMER_END(depthTimer, gLogFilter, Debug::Concise, "Depth tree traversal time: ");
}
-/**
- * Structure to store the actor's associated node in the depth tree for child
- * traversal
- */
-struct ActorNodePair
-{
- Actor* actor;
- ActorDepthTreeNode* node;
- ActorNodePair( Actor* actor, ActorDepthTreeNode* node )
- : actor(actor),
- node(node)
- {
- }
-};
-
-/*
- * Descend actor tree, building a depth tree based on actor's sibling order.
- * Actors with the same sibling order share the same depth tree. Siblings
- * in the depth tree are ordered by actor's sibling order.
- *
- * An actor tree like this:
- *
- * Root (SO:0)
- * _/ | \_
- * _/ | \_
- * _/ | \_
- * / | \
- * A(SO:1) B(SO:2) C(SO:1)
- * _/\_ | _/ \_
- * / \ | / \
- * D(SO:0) E(SO:0) F(SO:0) G(SO:1) H(SO:0)
- *
- * will end up as a depth tree like this:
- *
- * RootNode [ Root ] -> NULL
- * |(mFC)
- * V (mNS)
- * Node [ A, C ] ------------------------> Node [ B ] -> NULL
- * | |
- * V V
- * Node [ D, E, H ] -> Node [ G ] -> NULL Node [ F ] -> NULL
- * | | |
- * V V V
- * NULL NULL NULL
- *
- * (All nodes also point to their parents to enable storage free traversal)
- */
-int Actor::BuildDepthTree( DepthNodeMemoryPool& nodeMemoryPool, ActorDepthTreeNode* node )
+void Actor::DepthTraverseActorTree( OwnerPointer<SceneGraph::NodeDepths>& sceneGraphNodeDepths, int32_t& depthIndex )
{
- int treeCount=1; // Count self and children
+ mSortedDepth = depthIndex * DevelLayer::SIBLING_ORDER_MULTIPLIER;
+ sceneGraphNodeDepths->Add( const_cast<SceneGraph::Node*>( &GetNode() ), mSortedDepth );
// Create/add to children of this node
if( mChildren )
{
- std::vector<ActorNodePair> storedChildren;
- storedChildren.reserve( mChildren->size() );
-
for( ActorContainer::iterator it = mChildren->begin(); it != mChildren->end(); ++it )
{
Actor* childActor = (*it).Get();
- if( childActor->IsLayer() )
- {
- Layer* layer = static_cast<Layer*>(childActor);
- if( layer->GetBehavior() == Dali::Layer::LAYER_3D )
- {
- // Ignore this actor and children.
- continue;
- }
- }
+ ++depthIndex;
+ childActor->DepthTraverseActorTree( sceneGraphNodeDepths, depthIndex );
+ }
+ }
+}
- // If no existing depth node children
- if( node->mFirstChildNode == NULL )
+void Actor::SetDefaultProperty( Property::Index index, const Property::Value& property )
+{
+ switch( index )
+ {
+ case Dali::Actor::Property::PARENT_ORIGIN:
+ {
+ Property::Type type = property.GetType();
+ if( type == Property::VECTOR3 )
{
- node->mFirstChildNode = new (nodeMemoryPool.AllocateRaw()) ActorDepthTreeNode( childActor, childActor->mSiblingOrder );
- node->mFirstChildNode->mParentNode = node;
- storedChildren.push_back(ActorNodePair( childActor, node->mFirstChildNode ));
+ SetParentOrigin( property.Get< Vector3 >() );
}
- else // find child node with matching sibling order (insertion sort)
+ else if ( type == Property::STRING )
{
- bool addedChildActor = false;
-
- // depth tree child nodes ordered by sibling order
- ActorDepthTreeNode* lastNode = NULL;
- for( ActorDepthTreeNode* childNode = node->mFirstChildNode; childNode != NULL; childNode = childNode->mNextSiblingNode )
- {
- uint16_t actorSiblingOrder = childActor->mSiblingOrder;
- uint16_t currentSiblingOrder = childNode->GetSiblingOrder();
-
- if( actorSiblingOrder == currentSiblingOrder )
- {
- // Don't need a new depth node, add to existing node
- childNode->AddActor( childActor );
- storedChildren.push_back(ActorNodePair( childActor, childNode ));
- addedChildActor = true;
- break;
- }
- else if( actorSiblingOrder < currentSiblingOrder )
- {
- break;
- }
- lastNode = childNode;
- }
-
- // No matching sibling order - create new node and insert into sibling list
- if( !addedChildActor )
+ std::string parentOriginString;
+ property.Get( parentOriginString );
+ Vector3 parentOrigin;
+ if( GetParentOriginConstant( parentOriginString, parentOrigin ) )
{
- ActorDepthTreeNode* newNode = new (nodeMemoryPool.AllocateRaw()) ActorDepthTreeNode( childActor, childActor->mSiblingOrder );
-
- newNode->mParentNode = node;
- storedChildren.push_back(ActorNodePair( childActor, newNode ));
-
- if( lastNode == NULL ) // Insert at start of siblings
- {
- ActorDepthTreeNode* nextNode = node->mFirstChildNode;
- node->mFirstChildNode = newNode;
- newNode->mNextSiblingNode = nextNode;
- }
- else // insert into siblings after last node
- {
- newNode->mNextSiblingNode = lastNode->mNextSiblingNode;
- lastNode->mNextSiblingNode = newNode;
- }
+ SetParentOrigin( parentOrigin );
}
}
+ break;
}
- // Order of descent doesn't matter; we're using insertion to sort.
- for( std::vector<ActorNodePair>::iterator iter = storedChildren.begin(); iter != storedChildren.end(); ++iter )
+ case Dali::Actor::Property::PARENT_ORIGIN_X:
{
- treeCount += iter->actor->BuildDepthTree( nodeMemoryPool, iter->node );
- }
- }
- return treeCount;
-}
-
-unsigned int Actor::GetDefaultPropertyCount() const
-{
- return DEFAULT_PROPERTY_COUNT;
-}
-
-void Actor::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
-{
- indices.Reserve( DEFAULT_PROPERTY_COUNT );
-
- for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
- {
- indices.PushBack( i );
- }
-}
-
-const char* Actor::GetDefaultPropertyName( Property::Index index ) const
-{
- if( index < DEFAULT_PROPERTY_COUNT )
- {
- return DEFAULT_PROPERTY_DETAILS[ index ].name;
- }
-
- return NULL;
-}
-
-Property::Index Actor::GetDefaultPropertyIndex( const std::string& name ) const
-{
- Property::Index index = Property::INVALID_INDEX;
-
- // Look for name in default properties
- for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
- {
- const Internal::PropertyDetails* property = &DEFAULT_PROPERTY_DETAILS[ i ];
- if( 0 == name.compare( property->name ) )
- {
- index = i;
- break;
- }
- }
-
- return index;
-}
-
-bool Actor::IsDefaultPropertyWritable( Property::Index index ) const
-{
- if( index < DEFAULT_PROPERTY_COUNT )
- {
- return DEFAULT_PROPERTY_DETAILS[ index ].writable;
- }
-
- return false;
-}
-
-bool Actor::IsDefaultPropertyAnimatable( Property::Index index ) const
-{
- if( index < DEFAULT_PROPERTY_COUNT )
- {
- 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;
- }
-
- return false;
-}
-
-Property::Type Actor::GetDefaultPropertyType( Property::Index index ) const
-{
- if( index < DEFAULT_PROPERTY_COUNT )
- {
- 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 )
- {
- case Dali::Actor::Property::PARENT_ORIGIN:
- {
- 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;
- }
-
- case Dali::Actor::Property::PARENT_ORIGIN_X:
- {
- SetParentOriginX( property.Get< float >() );
- break;
+ SetParentOriginX( property.Get< float >() );
+ break;
}
case Dali::Actor::Property::PARENT_ORIGIN_Y:
break;
}
- case Dali::Actor::Property::POSITION_INHERITANCE:
- {
- PositionInheritanceMode mode = mPositionInheritanceMode;
- if( Scripting::GetEnumerationProperty< PositionInheritanceMode >( property, POSITION_INHERITANCE_MODE_TABLE, POSITION_INHERITANCE_MODE_TABLE_COUNT, mode ) )
- {
- SetPositionInheritanceMode( mode );
- }
- break;
- }
-
case Dali::Actor::Property::DRAW_MODE:
{
DrawMode::Type mode = mDrawMode;
case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
{
- ResizePolicy::Type type = static_cast< ResizePolicy::Type >( -1 ); // Set to invalid number so it definitely gets set.
+ ResizePolicy::Type type = GetResizePolicy( Dimension::WIDTH );
if( Scripting::GetEnumerationProperty< ResizePolicy::Type >( property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )
{
SetResizePolicy( type, Dimension::WIDTH );
case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
{
- ResizePolicy::Type type = static_cast< ResizePolicy::Type >( -1 ); // Set to invalid number so it definitely gets set.
+ ResizePolicy::Type type = GetResizePolicy( Dimension::HEIGHT );
if( Scripting::GetEnumerationProperty< ResizePolicy::Type >( property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )
{
SetResizePolicy( type, Dimension::HEIGHT );
case Dali::Actor::Property::SIZE_SCALE_POLICY:
{
- SizeScalePolicy::Type type;
+ SizeScalePolicy::Type type = GetSizeScalePolicy();
if( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT, type ) )
{
SetSizeScalePolicy( type );
if( property.Get( value ) )
{
- if( static_cast<unsigned int>(value) != mSiblingOrder )
- {
- SetSiblingOrder( value );
- }
+ SetSiblingOrder( value );
}
break;
}
if( Scripting::GetEnumerationProperty< ClippingMode::Type >( property, CLIPPING_MODE_TABLE, CLIPPING_MODE_TABLE_COUNT, convertedValue ) )
{
mClippingMode = convertedValue;
- if( NULL != mNode )
- {
- SetClippingModeMessage( GetEventThreadServices(), *mNode, mClippingMode );
- }
+ SetClippingModeMessage( GetEventThreadServices(), GetNode(), mClippingMode );
}
break;
}
if( property.Get( value ) && value != mPositionUsesAnchorPoint )
{
mPositionUsesAnchorPoint = value;
- if( NULL != mNode )
- {
- SetPositionUsesAnchorPointMessage( GetEventThreadServices(), *mNode, mPositionUsesAnchorPoint );
- }
+ SetPositionUsesAnchorPointMessage( GetEventThreadServices(), GetNode(), mPositionUsesAnchorPoint );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::LAYOUT_DIRECTION:
+ {
+ Dali::LayoutDirection::Type direction = mLayoutDirection;
+ mInheritLayoutDirection = false;
+
+ if( Scripting::GetEnumerationProperty< LayoutDirection::Type >( property, LAYOUT_DIRECTION_TABLE, LAYOUT_DIRECTION_TABLE_COUNT, direction ) )
+ {
+ InheritLayoutDirectionRecursively( this, direction, true );
}
break;
}
+ case Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION:
+ {
+ bool value = false;
+ if( property.Get( value ) )
+ {
+ SetInheritLayoutDirection( value );
+ }
+ break;
+ }
+
+ case Dali::DevelActor::Property::UPDATE_SIZE_HINT:
+ {
+ SetUpdateSizeHint( property.Get< Vector2 >() );
+ break;
+ }
+
default:
{
// this can happen in the case of a non-animatable default property so just do nothing
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<bool>::Bake, value.Get<bool>() );
+ SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<bool>::Bake, value.Get<bool>() );
break;
}
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<int>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<int>::Bake, value.Get<int>() );
+ SceneGraph::NodePropertyMessage<int>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<int>::Bake, value.Get<int>() );
break;
}
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<float>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<float>::Bake, value.Get<float>() );
+ SceneGraph::NodePropertyMessage<float>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<float>::Bake, value.Get<float>() );
break;
}
// property is being used in a separate thread; queue a message to set the property
if(entry.componentIndex == 0)
{
- SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::BakeX, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector2>::BakeX, value.Get<float>() );
}
else if(entry.componentIndex == 1)
{
- SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::BakeY, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector2>::BakeY, value.Get<float>() );
}
else
{
- SceneGraph::NodePropertyMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
+ SceneGraph::NodePropertyMessage<Vector2>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
}
break;
// property is being used in a separate thread; queue a message to set the property
if(entry.componentIndex == 0)
{
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::BakeX, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector3>::BakeX, value.Get<float>() );
}
else if(entry.componentIndex == 1)
{
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::BakeY, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector3>::BakeY, value.Get<float>() );
}
else if(entry.componentIndex == 2)
{
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::BakeZ, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector3>::BakeZ, value.Get<float>() );
}
else
{
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
+ SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
}
break;
// property is being used in a separate thread; queue a message to set the property
if(entry.componentIndex == 0)
{
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::BakeX, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::BakeX, value.Get<float>() );
}
else if(entry.componentIndex == 1)
{
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::BakeY, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::BakeY, value.Get<float>() );
}
else if(entry.componentIndex == 2)
{
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::BakeZ, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::BakeZ, value.Get<float>() );
}
else if(entry.componentIndex == 3)
{
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::BakeW, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::BakeW, value.Get<float>() );
}
else
{
- SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
+ SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
}
break;
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, property,&AnimatableProperty<Quaternion>::Bake, value.Get<Quaternion>() );
+ SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), &GetNode(), property,&AnimatableProperty<Quaternion>::Bake, value.Get<Quaternion>() );
break;
}
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Matrix>::Send( GetEventThreadServices(), mNode, property,&AnimatableProperty<Matrix>::Bake, value.Get<Matrix>() );
+ SceneGraph::NodePropertyMessage<Matrix>::Send( GetEventThreadServices(), &GetNode(), property,&AnimatableProperty<Matrix>::Bake, value.Get<Matrix>() );
break;
}
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Matrix3>::Send( GetEventThreadServices(), mNode, property,&AnimatableProperty<Matrix3>::Bake, value.Get<Matrix3>() );
+ SceneGraph::NodePropertyMessage<Matrix3>::Send( GetEventThreadServices(), &GetNode(), property,&AnimatableProperty<Matrix3>::Bake, value.Get<Matrix3>() );
break;
}
}
}
-const SceneGraph::PropertyOwner* Actor::GetPropertyOwner() const
-{
- return mNode;
-}
-
-const SceneGraph::PropertyOwner* Actor::GetSceneObject() const
-{
- // This method should only return an object connected to the scene-graph
- return OnStage() ? mNode : NULL;
-}
-
const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index index ) const
{
- 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() )
- {
- return property;
- }
-
- if ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX && index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )
- {
- AnimatablePropertyMetadata* animatable = RegisterAnimatableProperty( index );
- DALI_ASSERT_ALWAYS( animatable && "Property index is invalid" );
-
- property = animatable->GetSceneGraphProperty();
- }
- 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" );
-
- property = custom->GetSceneGraphProperty();
- }
- else if( NULL != mNode )
+ switch( index )
{
- switch( index )
+ case Dali::Actor::Property::SIZE: // FALLTHROUGH
+ case Dali::Actor::Property::SIZE_WIDTH: // FALLTHROUGH
+ case Dali::Actor::Property::SIZE_HEIGHT: // FALLTHROUGH
+ case Dali::Actor::Property::SIZE_DEPTH:
{
- case Dali::Actor::Property::SIZE:
- property = &mNode->mSize;
- break;
-
- case Dali::Actor::Property::SIZE_WIDTH:
- property = &mNode->mSize;
- break;
-
- case Dali::Actor::Property::SIZE_HEIGHT:
- property = &mNode->mSize;
- break;
-
- case Dali::Actor::Property::SIZE_DEPTH:
- property = &mNode->mSize;
- break;
-
- case Dali::Actor::Property::POSITION:
- property = &mNode->mPosition;
- break;
-
- case Dali::Actor::Property::POSITION_X:
- property = &mNode->mPosition;
- break;
-
- case Dali::Actor::Property::POSITION_Y:
- property = &mNode->mPosition;
- break;
-
- case Dali::Actor::Property::POSITION_Z:
- property = &mNode->mPosition;
- break;
-
- case Dali::Actor::Property::ORIENTATION:
- property = &mNode->mOrientation;
- break;
-
- case Dali::Actor::Property::SCALE:
- property = &mNode->mScale;
- break;
-
- case Dali::Actor::Property::SCALE_X:
- property = &mNode->mScale;
- break;
-
- case Dali::Actor::Property::SCALE_Y:
- property = &mNode->mScale;
- break;
-
- case Dali::Actor::Property::SCALE_Z:
- property = &mNode->mScale;
- break;
-
- case Dali::Actor::Property::VISIBLE:
- property = &mNode->mVisible;
- break;
-
- case Dali::Actor::Property::COLOR:
- property = &mNode->mColor;
- break;
-
- case Dali::Actor::Property::COLOR_RED:
- property = &mNode->mColor;
- break;
-
- case Dali::Actor::Property::COLOR_GREEN:
- property = &mNode->mColor;
- break;
-
- case Dali::Actor::Property::COLOR_BLUE:
- property = &mNode->mColor;
- break;
-
- case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::DevelActor::Property::OPACITY:
- property = &mNode->mColor;
- break;
-
- default:
- break;
+ property = &GetNode().mSize;
+ break;
+ }
+ case Dali::Actor::Property::POSITION: // FALLTHROUGH
+ case Dali::Actor::Property::POSITION_X: // FALLTHROUGH
+ case Dali::Actor::Property::POSITION_Y: // FALLTHROUGH
+ case Dali::Actor::Property::POSITION_Z:
+ {
+ property = &GetNode().mPosition;
+ break;
+ }
+ case Dali::Actor::Property::ORIENTATION:
+ {
+ property = &GetNode().mOrientation;
+ break;
+ }
+ case Dali::Actor::Property::SCALE: // FALLTHROUGH
+ case Dali::Actor::Property::SCALE_X: // FALLTHROUGH
+ case Dali::Actor::Property::SCALE_Y: // FALLTHROUGH
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ property = &GetNode().mScale;
+ break;
+ }
+ case Dali::Actor::Property::VISIBLE:
+ {
+ property = &GetNode().mVisible;
+ break;
+ }
+ case Dali::Actor::Property::COLOR: // FALLTHROUGH
+ case Dali::Actor::Property::COLOR_RED: // FALLTHROUGH
+ case Dali::Actor::Property::COLOR_GREEN: // FALLTHROUGH
+ case Dali::Actor::Property::COLOR_BLUE: // FALLTHROUGH
+ case Dali::Actor::Property::COLOR_ALPHA: // FALLTHROUGH
+ case Dali::DevelActor::Property::OPACITY:
+ {
+ property = &GetNode().mColor;
+ break;
+ }
+ default:
+ {
+ break;
}
}
+ if( !property )
+ {
+ // not our property, ask base
+ property = Object::GetSceneObjectAnimatableProperty( index );
+ }
return property;
}
{
const PropertyInputImpl* property( NULL );
- // This method should only return a property of an object connected to the scene-graph
- if( !OnStage() )
- {
- return property;
- }
-
- if ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX && index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )
- {
- AnimatablePropertyMetadata* animatable = RegisterAnimatableProperty( index );
- DALI_ASSERT_ALWAYS( animatable && "Property index is invalid" );
-
- property = animatable->GetSceneGraphProperty();
- }
- 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" );
- property = custom->GetSceneGraphProperty();
- }
- else if( NULL != mNode )
+ switch( index )
{
- switch( index )
+ case Dali::Actor::Property::PARENT_ORIGIN: // FALLTHROUGH
+ case Dali::Actor::Property::PARENT_ORIGIN_X: // FALLTHROUGH
+ case Dali::Actor::Property::PARENT_ORIGIN_Y: // FALLTHROUGH
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
{
- case Dali::Actor::Property::PARENT_ORIGIN:
- property = &mNode->mParentOrigin;
- break;
-
- case Dali::Actor::Property::PARENT_ORIGIN_X:
- property = &mNode->mParentOrigin;
- break;
-
- case Dali::Actor::Property::PARENT_ORIGIN_Y:
- property = &mNode->mParentOrigin;
- break;
-
- case Dali::Actor::Property::PARENT_ORIGIN_Z:
- property = &mNode->mParentOrigin;
- break;
-
- case Dali::Actor::Property::ANCHOR_POINT:
- property = &mNode->mAnchorPoint;
- break;
-
- case Dali::Actor::Property::ANCHOR_POINT_X:
- property = &mNode->mAnchorPoint;
- break;
-
- case Dali::Actor::Property::ANCHOR_POINT_Y:
- property = &mNode->mAnchorPoint;
- break;
-
- case Dali::Actor::Property::ANCHOR_POINT_Z:
- property = &mNode->mAnchorPoint;
- break;
-
- case Dali::Actor::Property::SIZE:
- property = &mNode->mSize;
- break;
-
- case Dali::Actor::Property::SIZE_WIDTH:
- property = &mNode->mSize;
- break;
-
- case Dali::Actor::Property::SIZE_HEIGHT:
- property = &mNode->mSize;
- break;
-
- case Dali::Actor::Property::SIZE_DEPTH:
- property = &mNode->mSize;
- break;
-
- case Dali::Actor::Property::POSITION:
- property = &mNode->mPosition;
- break;
-
- case Dali::Actor::Property::POSITION_X:
- property = &mNode->mPosition;
- break;
-
- case Dali::Actor::Property::POSITION_Y:
- property = &mNode->mPosition;
- break;
-
- case Dali::Actor::Property::POSITION_Z:
- property = &mNode->mPosition;
- break;
-
- case Dali::Actor::Property::WORLD_POSITION:
- property = &mNode->mWorldPosition;
- break;
-
- case Dali::Actor::Property::WORLD_POSITION_X:
- property = &mNode->mWorldPosition;
- break;
-
- case Dali::Actor::Property::WORLD_POSITION_Y:
- property = &mNode->mWorldPosition;
- break;
-
- case Dali::Actor::Property::WORLD_POSITION_Z:
- property = &mNode->mWorldPosition;
- break;
-
- case Dali::Actor::Property::ORIENTATION:
- property = &mNode->mOrientation;
- break;
-
- case Dali::Actor::Property::WORLD_ORIENTATION:
- property = &mNode->mWorldOrientation;
- break;
-
- case Dali::Actor::Property::SCALE:
- property = &mNode->mScale;
- break;
-
- case Dali::Actor::Property::SCALE_X:
- property = &mNode->mScale;
- break;
-
- case Dali::Actor::Property::SCALE_Y:
- property = &mNode->mScale;
- break;
-
- case Dali::Actor::Property::SCALE_Z:
- property = &mNode->mScale;
- break;
-
- case Dali::Actor::Property::WORLD_SCALE:
- property = &mNode->mWorldScale;
- break;
-
- case Dali::Actor::Property::VISIBLE:
- property = &mNode->mVisible;
- break;
-
- case Dali::Actor::Property::COLOR:
- property = &mNode->mColor;
- break;
-
- case Dali::Actor::Property::COLOR_RED:
- property = &mNode->mColor;
- break;
-
- case Dali::Actor::Property::COLOR_GREEN:
- property = &mNode->mColor;
- break;
-
- case Dali::Actor::Property::COLOR_BLUE:
- property = &mNode->mColor;
- break;
-
- case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::DevelActor::Property::OPACITY:
- {
- property = &mNode->mColor;
- break;
- }
-
- case Dali::Actor::Property::WORLD_COLOR:
- property = &mNode->mWorldColor;
- break;
-
- case Dali::Actor::Property::WORLD_MATRIX:
- property = &mNode->mWorldMatrix;
- break;
-
- default:
- break;
+ property = &GetNode().mParentOrigin;
+ break;
+ }
+ case Dali::Actor::Property::ANCHOR_POINT: // FALLTHROUGH
+ case Dali::Actor::Property::ANCHOR_POINT_X: // FALLTHROUGH
+ case Dali::Actor::Property::ANCHOR_POINT_Y: // FALLTHROUGH
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
+ {
+ property = &GetNode().mAnchorPoint;
+ break;
+ }
+ case Dali::Actor::Property::WORLD_POSITION: // FALLTHROUGH
+ case Dali::Actor::Property::WORLD_POSITION_X: // FALLTHROUGH
+ case Dali::Actor::Property::WORLD_POSITION_Y: // FALLTHROUGH
+ case Dali::Actor::Property::WORLD_POSITION_Z:
+ {
+ property = &GetNode().mWorldPosition;
+ break;
+ }
+ case Dali::Actor::Property::WORLD_ORIENTATION:
+ {
+ property = &GetNode().mWorldOrientation;
+ break;
+ }
+ case Dali::Actor::Property::WORLD_SCALE:
+ {
+ property = &GetNode().mWorldScale;
+ break;
+ }
+ case Dali::Actor::Property::WORLD_COLOR:
+ {
+ property = &GetNode().mWorldColor;
+ break;
}
+ case Dali::Actor::Property::WORLD_MATRIX:
+ {
+ property = &GetNode().mWorldMatrix;
+ break;
+ }
+ case Dali::DevelActor::Property::CULLED:
+ {
+ property = &GetNode().mCulled;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ if( !property )
+ {
+ // reuse animatable property getter as animatable properties are inputs as well
+ // animatable property chains back to Object::GetSceneObjectInputProperty() so all properties get covered
+ property = GetSceneObjectAnimatableProperty( index );
}
return property;
}
-int Actor::GetPropertyComponentIndex( Property::Index index ) const
+int32_t Actor::GetPropertyComponentIndex( Property::Index index ) const
{
- int componentIndex( Property::INVALID_COMPONENT_INDEX );
+ int32_t componentIndex = Property::INVALID_COMPONENT_INDEX;
- if ( ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX ) )
+ switch( index )
{
- // check whether the animatable property is registered already, if not then register one.
- AnimatablePropertyMetadata* animatableProperty = RegisterAnimatableProperty(index);
- if( animatableProperty )
+ 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 = animatableProperty->componentIndex;
+ componentIndex = 0;
+ break;
}
- }
- else
- {
- switch( index )
- {
- 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::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::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::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::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::Property::COLOR_ALPHA:
- case Dali::DevelActor::Property::OPACITY:
- {
- componentIndex = 3;
- break;
- }
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
+ {
+ componentIndex = 3;
+ break;
+ }
- default:
- {
- // Do nothing
- break;
- }
+ default:
+ {
+ // Do nothing
+ break;
}
}
+ if( Property::INVALID_COMPONENT_INDEX == componentIndex )
+ {
+ // ask base
+ componentIndex = Object::GetPropertyComponentIndex( index );
+ }
return componentIndex;
}
mParent = parent;
+ mScene = parent->mScene;
+
if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
parent->OnStage() )
{
if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
OnStage() )
{
- DALI_ASSERT_ALWAYS( mNode != NULL );
-
- if( NULL != mNode )
- {
- // Disconnect the Node & its children from the scene-graph.
- DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *mNode );
- }
+ // Disconnect the Node & its children from the scene-graph.
+ DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), GetNode() );
// Instruct each actor to discard pointers to the scene-graph
DisconnectFromStage();
}
- }
-}
-SceneGraph::Node* Actor::CreateNode() const
-{
- return Node::New();
+ mScene = nullptr;
+ }
}
bool Actor::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& /* attributes */ )
break;
}
- case Dali::Actor::Property::POSITION_INHERITANCE:
- {
- value = Scripting::GetLinearEnumerationName< PositionInheritanceMode >( GetPositionInheritanceMode(), POSITION_INHERITANCE_MODE_TABLE, POSITION_INHERITANCE_MODE_TABLE_COUNT );
- break;
- }
-
case Dali::Actor::Property::DRAW_MODE:
{
value = Scripting::GetEnumerationName< DrawMode::Type >( GetDrawMode(), DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT );
case Dali::DevelActor::Property::SIBLING_ORDER:
{
- value = static_cast<int>(mSiblingOrder);
+ value = static_cast<int>( GetSiblingOrder() );
break;
}
break;
}
+ case Dali::Actor::Property::LAYOUT_DIRECTION:
+ {
+ value = mLayoutDirection;
+ break;
+ }
+
+ case Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION:
+ {
+ value = IsLayoutDirectionInherited();
+ break;
+ }
+
default:
{
// Must be a scene-graph only property
break;
}
+ case DevelActor::Property::CULLED:
+ {
+ value = GetNode().IsCulled( GetEventThreadServices().GetEventBufferIndex() );
+ break;
+ }
+
+ case Dali::DevelActor::Property::UPDATE_SIZE_HINT:
+ {
+ value = GetUpdateSizeHint();
+ break;
+ }
+
default:
{
// Must be an event-side only property
bool Actor::RelayoutDependentOnParent( Dimension::Type dimension )
{
// Check if actor is dependent on parent
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) )
{
bool Actor::RelayoutDependentOnChildren( Dimension::Type dimension )
{
// Check if actor is dependent on children
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) )
{
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 )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
void Actor::SetNegotiatedDimension( float negotiatedDimension, Dimension::Type dimension )
{
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
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 )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) )
{
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
if ( mRelayoutData )
{
// If more than one dimension is requested, just return the first one found
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) )
{
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
{
if ( mRelayoutData )
{
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionNegotiated[ i ] )
{
{
float maxDimensionPoint = 0.0f;
- for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
+ for( uint32_t i = 0, count = GetChildCount(); i < count; ++i )
{
ActorPtr child = GetChildAt( i );
recursionStack.push_back( ActorDimensionPair( this, dimension ) );
// Dimension dependency check
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
Dimension::Type dimensionToCheck = static_cast< Dimension::Type >( 1 << i );
// Children dependency check
if( RelayoutDependentOnChildren( dimension ) )
{
- for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
+ for( uint32_t i = 0, count = GetChildCount(); i < count; ++i )
{
ActorPtr child = GetChildAt( i );
// Negotiate all dimensions that require it
ActorDimensionStack recursionStack;
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
const Dimension::Type dimension = static_cast< Dimension::Type >( 1 << i );
}
}
-Vector2 Actor::ApplySizeSetPolicy( const Vector2 size )
+Vector2 Actor::ApplySizeSetPolicy( const Vector2& size )
{
switch( mRelayoutData->sizeSetPolicy )
{
SetNegotiatedSize( container );
// Negotiate down to children
- const Vector2 newBounds = mTargetSize.GetVectorXY();
-
- for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
+ for( uint32_t i = 0, count = GetChildCount(); i < count; ++i )
{
ActorPtr child = GetChildAt( i );
// Only relayout if required
if( child->RelayoutRequired() )
{
- container.Add( Dali::Actor( child.Get() ), newBounds );
+ container.Add( Dali::Actor( child.Get() ), mTargetSize.GetVectorXY() );
}
}
DALI_LOG_TIMER_END( NegSizeTimer1, gLogRelayoutFilter, Debug::Concise, "NegotiateSize() took: ");
{
if( mRelayoutData )
{
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
if ( mRelayoutData )
{
// If more than one dimension is requested, just return the first one found
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
{
if ( mRelayoutData )
{
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
{
if ( mRelayoutData )
{
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
return FLT_MAX; // Default
}
+void Actor::SetUpdateSizeHint( const Vector2& updateSizeHint )
+{
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mUpdateSizeHint, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, Vector3(updateSizeHint.width, updateSizeHint.height, 0.f ) );
+}
+
+const Vector2 Actor::GetUpdateSizeHint() const
+{
+ // node is being used in a separate thread; copy the value from the previous update
+ Vector3 updateSizeHint = GetNode().GetUpdateSizeHint( GetEventThreadServices().GetEventBufferIndex() );
+ return Vector2( updateSizeHint.width, updateSizeHint.height );
+}
+
Object* Actor::GetParentObject() const
{
return mParent;
{
if( mVisible != visible )
{
- if( sendMessage == SendMessage::TRUE && NULL != mNode )
+ if( sendMessage == SendMessage::TRUE )
{
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), mNode, &mNode->mVisible, &AnimatableProperty<bool>::Bake, visible );
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mVisible, &AnimatableProperty<bool>::Bake, visible );
}
mVisible = visible;
}
}
-void Actor::SetSiblingOrder( unsigned int order )
-{
- mSiblingOrder = std::min( order, static_cast<unsigned int>( DevelLayer::SIBLING_ORDER_MULTIPLIER ) );
-
- if( mIsOnStage )
- {
- StagePtr stage = Stage::GetCurrent();
- if( stage )
- {
- stage->RequestRebuildDepthTree();
- }
- }
-}
-
-void Actor::DefragmentSiblingIndexes( ActorContainer& siblings )
+void Actor::SetSiblingOrder( uint32_t order )
{
- // Sibling index may not be in consecutive order as the sibling range is limited ( DevelLayer::SIBLING_ORDER_MULTIPLIER )
- // we need to remove the gaps and ensure the number start from 0 and consecutive hence have a full range.
-
- // Start at index 0, while index <= highest order
- // Find next index higher than 0
- // if nextHigher > index+1
- // set all nextHigher orders to index+1
-
- // Limitation: May reach the ceiling of DevelLayer::SIBLING_ORDER_MULTIPLIER with highest sibling.
-
- ActorIter end = siblings.end();
- int highestOrder = 0;
- for( ActorIter iter = siblings.begin(); iter != end; ++iter )
- {
- ActorPtr sibling = (*iter);
- int siblingOrder = sibling->mSiblingOrder;
- highestOrder = std::max( highestOrder, siblingOrder );
- }
-
- for ( int index = 0; index <= highestOrder; index++ )
+ if ( mParent )
{
- int nextHighest = -1;
+ ActorContainer& siblings = *(mParent->mChildren);
+ uint32_t currentOrder = GetSiblingOrder();
- // Find Next highest
- for( ActorIter iter = siblings.begin(); iter != end; ++iter )
+ if( order != currentOrder )
{
- ActorPtr sibling = (*iter);
- int siblingOrder = sibling->mSiblingOrder;
-
- if ( siblingOrder > index )
+ if( order == 0 )
+ {
+ LowerToBottom();
+ }
+ else if( order < siblings.size() -1 )
{
- if ( nextHighest == -1 )
+ if( order > currentOrder )
+ {
+ RaiseAbove( *siblings[order] );
+ }
+ else
{
- nextHighest = siblingOrder;
+ LowerBelow( *siblings[order] );
}
- nextHighest = std::min( nextHighest, siblingOrder );
+ }
+ else
+ {
+ RaiseToTop();
}
}
+ }
+}
+
+uint32_t Actor::GetSiblingOrder() const
+{
+ uint32_t order = 0;
- // Check if a gap exists between indexes, if so set next index to consecutive number
- if ( ( nextHighest - index ) > 1 )
+ if ( mParent )
+ {
+ ActorContainer& siblings = *(mParent->mChildren);
+ for( std::size_t i = 0; i < siblings.size(); ++i )
{
- for( ActorIter iter = siblings.begin(); iter != end; ++iter )
+ if( siblings[i] == this )
{
- ActorPtr sibling = (*iter);
- int siblingOrder = sibling->mSiblingOrder;
- if ( siblingOrder == nextHighest )
- {
- sibling->mSiblingOrder = index + 1;
- if ( sibling->mSiblingOrder >= Dali::DevelLayer::SIBLING_ORDER_MULTIPLIER )
- {
- DALI_LOG_WARNING( "Reached max sibling order level for raising / lowering actors\n" );
- sibling->mSiblingOrder = Dali::DevelLayer::SIBLING_ORDER_MULTIPLIER;
- }
- sibling->SetSiblingOrder( sibling->mSiblingOrder );
- }
+ order = static_cast<uint32_t>( i );
+ break;
}
}
}
+
+ return order;
}
-bool Actor::ShiftSiblingsLevels( ActorContainer& siblings, int targetLevelToShiftFrom )
+void Actor::RequestRebuildDepthTree()
{
- // Allows exclusive levels for an actor by shifting all sibling levels at the target and above by 1
- bool defragmentationRequired( false );
- ActorIter end = siblings.end();
- for( ActorIter iter = siblings.begin(); ( iter != end ) ; ++iter )
+ if( mIsOnStage )
{
- // Move actors at nearest order and above up by 1
- ActorPtr sibling = (*iter);
- if ( sibling != this )
+ if( mScene )
{
- // Iterate through container of actors, any actor with a sibling order of the target or greater should
- // be incremented by 1.
- if ( sibling->mSiblingOrder >= targetLevelToShiftFrom )
- {
- sibling->mSiblingOrder++;
- if ( sibling->mSiblingOrder + 1 >= DevelLayer::SIBLING_ORDER_MULTIPLIER )
- {
- // If a sibling order raises so that it is only 1 from the maximum allowed then set flag so
- // can re-order all sibling orders.
- defragmentationRequired = true;
- }
- sibling->SetSiblingOrder( sibling->mSiblingOrder );
- }
+ mScene->RequestRebuildDepthTree();
}
}
- return defragmentationRequired;
}
void Actor::Raise()
{
- /*
- 1) Check if already at top and nothing to be done.
- This Actor can have highest sibling order but if not exclusive then another actor at same sibling
- order can be positioned above it due to insertion order of actors.
- 2) Find nearest sibling level above, these are the siblings this actor needs to be above
- 3) a) There may be other levels above this target level
- b) Increment all sibling levels at the level above nearest(target)
- c) Now have a vacant sibling level
- 4) Set this actor's sibling level to nearest +1 as now vacated.
-
- Note May not just be sibling level + 1 as could be empty levels in-between
-
- Example:
-
- 1 ) Initial order
- ActorC ( sibling level 4 )
- ActorB ( sibling level 3 )
- ActorA ( sibling level 1 )
-
- 2 ) ACTION: Raise A above B
- a) Find nearest level above A = Level 3
- b) Increment levels above Level 3
-
- ActorC ( sibling level 5 )
- ActorB ( sibling level 3 ) NEAREST
- ActorA ( sibling level 1 )
-
- 3 ) Set Actor A sibling level to nearest +1 as vacant
-
- ActorC ( sibling level 5 )
- ActorA ( sibling level 4 )
- ActorB ( sibling level 3 )
-
- 4 ) Sibling order levels have a maximum defined in DevelLayer::SIBLING_ORDER_MULTIPLIER
- If shifting causes this ceiling to be reached. then a defragmentation can be performed to
- remove any empty sibling order gaps and start from sibling level 0 again.
- If the number of actors reaches this maximum and all using exclusive sibling order values then
- defragmention will stop and new sibling orders will be set to same max value.
- */
if ( mParent )
{
- int nearestLevel = mSiblingOrder;
- int shortestDistanceToNextLevel = DevelLayer::SIBLING_ORDER_MULTIPLIER;
- bool defragmentationRequired( false );
-
- ActorContainer* siblings = mParent->mChildren;
-
- // Find Nearest sibling level above this actor
- ActorIter end = siblings->end();
- for( ActorIter iter = siblings->begin(); iter != end; ++iter )
+ ActorContainer& siblings = *(mParent->mChildren);
+ if( siblings.back() != this ) // If not already at end
{
- ActorPtr sibling = (*iter);
- if ( sibling != this )
+ for( std::size_t i=0; i<siblings.size(); ++i )
{
- int order = GetSiblingOrder( sibling );
-
- if ( ( order >= mSiblingOrder ) )
+ if( siblings[i] == this )
{
- int distanceToNextLevel = order - mSiblingOrder;
- if ( distanceToNextLevel < shortestDistanceToNextLevel )
- {
- nearestLevel = order;
- shortestDistanceToNextLevel = distanceToNextLevel;
- }
+ // Swap with next
+ ActorPtr next = siblings[i+1];
+ siblings[i+1] = this;
+ siblings[i] = next;
+ break;
}
}
}
- if ( nearestLevel < DevelLayer::SIBLING_ORDER_MULTIPLIER ) // Actor is not already exclusively at top
- {
- mSiblingOrder = nearestLevel + 1; // Set sibling level to that above the nearest level
- defragmentationRequired = ShiftSiblingsLevels( *siblings, mSiblingOrder );
- // Move current actor to newly vacated order level
- SetSiblingOrder( mSiblingOrder );
- if ( defragmentationRequired )
- {
- DefragmentSiblingIndexes( *siblings );
- }
- }
- SetSiblingOrder( mSiblingOrder );
+ Dali::Actor handle( this );
+ mParent->mChildOrderChangedSignal.Emit( handle );
+
+ RequestRebuildDepthTree();
}
else
{
void Actor::Lower()
{
- /**
- 1) Check if actor already at bottom and if nothing needs to be done
- This Actor can have lowest sibling order but if not exclusive then another actor at same sibling
- order can be positioned above it due to insertion order of actors so need to move this actor below it.
- 2) Find nearest sibling level below, this Actor needs to be below it
- 3) a) Need to vacate a sibling level below nearest for this actor to occupy
- b) Shift up all sibling order values of actor at the nearest level and levels above it to vacate a level.
- c) Set this actor's sibling level to this newly vacated level.
- 4 ) Sibling order levels have a maximum defined in DevelLayer::SIBLING_ORDER_MULTIPLIER
- If shifting causes this ceiling to be reached. then a defragmentation can be performed to
- remove any empty sibling order gaps and start from sibling level 0 again.
- If the number of actors reaches this maximum and all using exclusive sibling order values then
- defragmention will stop and new sibling orders will be set to same max value.
- */
-
if ( mParent )
{
- // 1) Find nearest level below
- int nearestLevel = mSiblingOrder;
- int shortestDistanceToNextLevel = DevelLayer::SIBLING_ORDER_MULTIPLIER;
-
- ActorContainer* siblings = mParent->mChildren;
-
- ActorIter end = siblings->end();
- for( ActorIter iter = siblings->begin(); iter != end; ++iter )
+ ActorContainer& siblings = *(mParent->mChildren);
+ if( siblings.front() != this ) // If not already at beginning
{
- ActorPtr sibling = (*iter);
- if ( sibling != this )
+ for( std::size_t i=1; i<siblings.size(); ++i )
{
- int order = GetSiblingOrder( sibling );
-
- if ( order <= mSiblingOrder )
+ if( siblings[i] == this )
{
- int distanceToNextLevel = mSiblingOrder - order;
- if ( distanceToNextLevel < shortestDistanceToNextLevel )
- {
- nearestLevel = order;
- shortestDistanceToNextLevel = distanceToNextLevel;
- }
+ // Swap with previous
+ ActorPtr previous = siblings[i-1];
+ siblings[i-1] = this;
+ siblings[i] = previous;
+ break;
}
}
}
- bool defragmentationRequired ( false );
+ Dali::Actor handle( this );
+ mParent->mChildOrderChangedSignal.Emit( handle );
- // 2) If actor already not at bottom, raise all actors at required level and above
- if ( shortestDistanceToNextLevel < DevelLayer::SIBLING_ORDER_MULTIPLIER ) // Actor is not already exclusively at bottom
- {
- mSiblingOrder = nearestLevel;
- defragmentationRequired = ShiftSiblingsLevels( *siblings, mSiblingOrder );
- // Move current actor to newly vacated order
- SetSiblingOrder( mSiblingOrder );
- if ( defragmentationRequired )
- {
- DefragmentSiblingIndexes( *siblings );
- }
- }
+ RequestRebuildDepthTree();
}
else
{
void Actor::RaiseToTop()
{
- /**
- 1 ) Find highest sibling order actor
- 2 ) If highest sibling level not itself then set sibling order to that + 1
- 3 ) highest sibling order can be same as itself so need to increment over that
- 4 ) Sibling order levels have a maximum defined in DevelLayer::SIBLING_ORDER_MULTIPLIER
- If shifting causes this ceiling to be reached. then a defragmentation can be performed to
- remove any empty sibling order gaps and start from sibling level 0 again.
- If the number of actors reaches this maximum and all using exclusive sibling order values then
- defragmention will stop and new sibling orders will be set to same max value.
- */
-
if ( mParent )
{
- int maxOrder = 0;
-
- ActorContainer* siblings = mParent->mChildren;
-
- ActorIter end = siblings->end();
- for( ActorIter iter = siblings->begin(); iter != end; ++iter )
- {
- ActorPtr sibling = (*iter);
- if ( sibling != this )
- {
- maxOrder = std::max( GetSiblingOrder( sibling ), maxOrder );
- }
- }
-
- bool defragmentationRequired( false );
-
- if ( maxOrder >= mSiblingOrder )
+ ActorContainer& siblings = *(mParent->mChildren);
+ if( siblings.back() != this ) // If not already at end
{
- mSiblingOrder = maxOrder + 1;
- if ( mSiblingOrder + 1 >= DevelLayer::SIBLING_ORDER_MULTIPLIER )
+ ActorContainer::iterator iter = std::find( siblings.begin(), siblings.end(), this );
+ if( iter != siblings.end() )
{
- defragmentationRequired = true;
+ siblings.erase(iter);
+ siblings.push_back(ActorPtr(this));
}
}
- SetSiblingOrder( mSiblingOrder );
+ Dali::Actor handle( this );
+ mParent->mChildOrderChangedSignal.Emit( handle );
- if ( defragmentationRequired )
- {
- DefragmentSiblingIndexes( *siblings );
- }
+ RequestRebuildDepthTree();
}
else
{
void Actor::LowerToBottom()
{
- /**
- See Actor::LowerToBottom()
-
- 1 ) Check if this actor already at exclusively at the bottom, if so then no more to be done.
- 2 ) a ) Check if the bottom position 0 is vacant.
- b ) If 0 position is not vacant then shift up all sibling order values from 0 and above
- c ) 0 sibling position is vacant.
- 3 ) Set this actor to vacant sibling order 0;
- 4 ) Sibling order levels have a maximum defined in DevelLayer::SIBLING_ORDER_MULTIPLIER
- If shifting causes this ceiling to be reached. then a defragmentation can be performed to
- remove any empty sibling order gaps and start from sibling level 0 again.
- If the number of actors reaches this maximum and all using exclusive sibling order values then
- defragmention will stop and new sibling orders will be set to same max value.
- */
-
if ( mParent )
{
- bool defragmentationRequired( false );
- bool orderZeroFree ( true );
-
- ActorContainer* siblings = mParent->mChildren;
-
- bool actorAtLowestOrder = true;
- ActorIter end = siblings->end();
- for( ActorIter iter = siblings->begin(); ( iter != end ) ; ++iter )
+ ActorContainer& siblings = *(mParent->mChildren);
+ if( siblings.front() != this ) // If not already at bottom,
{
- ActorPtr sibling = (*iter);
- if ( sibling != this )
- {
- int siblingOrder = GetSiblingOrder( sibling );
- if ( siblingOrder <= mSiblingOrder )
- {
- actorAtLowestOrder = false;
- }
+ ActorPtr thisPtr(this); // ensure this actor remains referenced.
- if ( siblingOrder == 0 )
- {
- orderZeroFree = false;
- }
+ ActorContainer::iterator iter = std::find( siblings.begin(), siblings.end(), this );
+ if( iter != siblings.end() )
+ {
+ siblings.erase(iter);
+ siblings.insert(siblings.begin(), thisPtr);
}
}
- if ( ! actorAtLowestOrder )
- {
- if ( ! orderZeroFree )
- {
- defragmentationRequired = ShiftSiblingsLevels( *siblings, 0 );
- }
- mSiblingOrder = 0;
- SetSiblingOrder( mSiblingOrder );
+ Dali::Actor handle( this );
+ mParent->mChildOrderChangedSignal.Emit( handle );
- if ( defragmentationRequired )
- {
- DefragmentSiblingIndexes( *siblings );
- }
- }
+ RequestRebuildDepthTree();
}
else
{
void Actor::RaiseAbove( Internal::Actor& target )
{
- /**
- 1 ) a) Find target actor's sibling order
- b) If sibling order of target is the same as this actor then need to this Actor's sibling order
- needs to be above it or the insertion order will determine which is drawn on top.
- 2 ) Shift up by 1 all sibling order greater than target sibling order
- 3 ) Set this actor to the sibling order to target +1 as will be a newly vacated gap above
- 4 ) Sibling order levels have a maximum defined in DevelLayer::SIBLING_ORDER_MULTIPLIER
- If shifting causes this ceiling to be reached. then a defragmentation can be performed to
- remove any empty sibling order gaps and start from sibling level 0 again.
- If the number of actors reaches this maximum and all using exclusive sibling order values then
- defragmention will stop and new sibling orders will be set to same max value.
- */
-
if ( mParent )
{
- if ( ValidateActors( *this, target ) )
+ ActorContainer& siblings = *(mParent->mChildren);
+ if( siblings.back() != this && target.mParent == mParent ) // If not already at top
{
- // Find target's sibling order
- // Set actor sibling order to this number +1
- int targetSiblingOrder = GetSiblingOrder( &target );
- ActorContainer* siblings = mParent->mChildren;
- mSiblingOrder = targetSiblingOrder + 1;
- bool defragmentationRequired = ShiftSiblingsLevels( *siblings, mSiblingOrder );
+ ActorPtr thisPtr(this); // ensure this actor remains referenced.
- SetSiblingOrder( mSiblingOrder );
-
- if ( defragmentationRequired )
+ ActorContainer::iterator targetIter = std::find( siblings.begin(), siblings.end(), &target );
+ ActorContainer::iterator thisIter = std::find( siblings.begin(), siblings.end(), this );
+ if( thisIter < targetIter )
{
- DefragmentSiblingIndexes( *(mParent->mChildren) );
+ siblings.erase(thisIter);
+ // Erasing early invalidates the targetIter. (Conversely, inserting first may also
+ // invalidate thisIter)
+ targetIter = std::find( siblings.begin(), siblings.end(), &target );
+ ++targetIter;
+ siblings.insert(targetIter, thisPtr);
}
+
+ Dali::Actor handle( this );
+ mParent->mChildOrderChangedSignal.Emit( handle );
+
+ RequestRebuildDepthTree();
}
}
else
void Actor::LowerBelow( Internal::Actor& target )
{
- /**
- 1 ) a) Find target actor's sibling order
- b) If sibling order of target is the same as this actor then need to this Actor's sibling order
- needs to be below it or the insertion order will determine which is drawn on top.
- 2 ) Shift the target sibling order and all sibling orders at that level or above by 1
- 3 ) Set this actor to the sibling order of the target before it changed.
- 4 ) Sibling order levels have a maximum defined in DevelLayer::SIBLING_ORDER_MULTIPLIER
- If shifting causes this ceiling to be reached. then a defragmentation can be performed to
- remove any empty sibling order gaps and start from sibling level 0 again.
- If the number of actors reaches this maximum and all using exclusive sibling order values then
- defragmention will stop and new sibling orders will be set to same max value.
- */
-
if ( mParent )
{
- if ( ValidateActors( *this, target ) )
+ ActorContainer& siblings = *(mParent->mChildren);
+ if( siblings.front() != this && target.mParent == mParent ) // If not already at bottom
{
- bool defragmentationRequired ( false );
- // Find target's sibling order
- // Set actor sibling order to target sibling order - 1
- int targetSiblingOrder = GetSiblingOrder( &target);
- ActorContainer* siblings = mParent->mChildren;
- if ( targetSiblingOrder == 0 )
- {
- //lower to botton
- ActorIter end = siblings->end();
- for( ActorIter iter = siblings->begin(); ( iter != end ) ; ++iter )
- {
- ActorPtr sibling = (*iter);
- if ( sibling != this )
- {
- sibling->mSiblingOrder++;
- if ( sibling->mSiblingOrder + 1 >= DevelLayer::SIBLING_ORDER_MULTIPLIER )
- {
- defragmentationRequired = true;
- }
- sibling->SetSiblingOrder( sibling->mSiblingOrder );
- }
- }
- mSiblingOrder = 0;
- }
- else
- {
- defragmentationRequired = ShiftSiblingsLevels( *siblings, targetSiblingOrder );
+ ActorPtr thisPtr(this); // ensure this actor remains referenced.
- mSiblingOrder = targetSiblingOrder;
- }
- SetSiblingOrder( mSiblingOrder );
+ ActorContainer::iterator targetIter = std::find( siblings.begin(), siblings.end(), &target );
+ ActorContainer::iterator thisIter = std::find( siblings.begin(), siblings.end(), this );
- if ( defragmentationRequired )
+ if( thisIter > targetIter )
{
- DefragmentSiblingIndexes( *(mParent->mChildren) );
+ siblings.erase(thisIter); // this only invalidates iterators at or after this point.
+ siblings.insert(targetIter, thisPtr);
}
+
+ Dali::Actor handle( this );
+ mParent->mChildOrderChangedSignal.Emit( handle );
+
+ RequestRebuildDepthTree();
}
}
else
}
}
+void Actor::SetScene( Scene& scene )
+{
+ mScene = &scene;
+}
+
+Scene& Actor::GetScene() const
+{
+ return *mScene;
+}
+
+void Actor::SetInheritLayoutDirection( bool inherit )
+{
+ if( mInheritLayoutDirection != inherit )
+ {
+ mInheritLayoutDirection = inherit;
+
+ if( inherit && mParent )
+ {
+ InheritLayoutDirectionRecursively( this, mParent->mLayoutDirection );
+ }
+ }
+}
+
+bool Actor::IsLayoutDirectionInherited() const
+{
+ return mInheritLayoutDirection;
+}
+
+void Actor::InheritLayoutDirectionRecursively( ActorPtr actor, Dali::LayoutDirection::Type direction, bool set )
+{
+ if( actor && ( actor->mInheritLayoutDirection || set ) )
+ {
+ if( actor->mLayoutDirection != direction )
+ {
+ actor->mLayoutDirection = direction;
+ actor->EmitLayoutDirectionChangedSignal( direction );
+ actor->RelayoutRequest();
+ }
+
+ if( actor->GetChildCount() > 0 )
+ {
+ ActorContainer& children = actor->GetChildrenInternal();
+ for( ActorIter iter = children.begin(), endIter = children.end(); iter != endIter; ++iter )
+ {
+ InheritLayoutDirectionRecursively( *iter, direction );
+ }
+ }
+ }
+}
+
} // namespace Internal
} // namespace Dali
projects / platform / core / uifw / dali-core.git / blobdiff