/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/common/constants.h>
+#include <dali/public-api/events/touch-data.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/radian.h>
#include <dali/internal/event/common/property-helper.h>
#include <dali/internal/event/common/stage-impl.h>
#include <dali/internal/event/common/type-info-impl.h>
-#include <dali/internal/event/actor-attachments/actor-attachment-impl.h>
#include <dali/internal/event/animation/constraint-impl.h>
#include <dali/internal/event/common/projection.h>
#include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
DALI_PROPERTY( "padding", VECTOR4, true, false, false, Dali::Actor::Property::PADDING )
DALI_PROPERTY( "minimumSize", VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE )
DALI_PROPERTY( "maximumSize", VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE )
+DALI_PROPERTY( "inheritPosition", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_POSITION )
DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
// Signals
const char* const SIGNAL_WHEEL_EVENT = "wheelEvent";
const char* const SIGNAL_ON_STAGE = "onStage";
const char* const SIGNAL_OFF_STAGE = "offStage";
+const char* const SIGNAL_ON_RELAYOUT = "onRelayout";
// Actions
SignalConnectorType signalConnector1( mType, SIGNAL_TOUCHED, &Actor::DoConnectSignal );
SignalConnectorType signalConnector2( mType, SIGNAL_HOVERED, &Actor::DoConnectSignal );
-SignalConnectorType signalConnector3( mType, SIGNAL_ON_STAGE, &Actor::DoConnectSignal );
-SignalConnectorType signalConnector4( mType, SIGNAL_OFF_STAGE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector3( mType, SIGNAL_WHEEL_EVENT, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector4( mType, SIGNAL_ON_STAGE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector5( mType, SIGNAL_OFF_STAGE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector6( mType, SIGNAL_ON_RELAYOUT, &Actor::DoConnectSignal );
TypeAction a1( mType, ACTION_SHOW, &Actor::DoAction );
TypeAction a2( mType, ACTION_HIDE, &Actor::DoAction );
return mId;
}
-void Actor::Attach( ActorAttachment& attachment )
-{
- DALI_ASSERT_DEBUG( !mAttachment && "An Actor can only have one attachment" );
-
- if( OnStage() )
- {
- attachment.Connect();
- }
-
- mAttachment = ActorAttachmentPtr( &attachment );
-}
-
-ActorAttachmentPtr Actor::GetAttachment()
-{
- return mAttachment;
-}
-
bool Actor::OnStage() const
{
return mIsOnStage;
if( removed )
{
- // Notification for derived classes
- OnChildRemove( *(removed.Get()) );
-
// Only put in a relayout request if there is a suitable dependency
if( RelayoutDependentOnChildren() )
{
RelayoutRequest();
}
}
+
+ // Notification for derived classes
+ OnChildRemove( child );
}
void Actor::Unparent()
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::Bake, position );
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, position );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeX, x );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeY, y );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeZ, z );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeRelative, distance );
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelative, distance );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value
- SetPositionInheritanceModeMessage( GetEventThreadServices(), *mNode, mode );
+ SetInheritPositionMessage( GetEventThreadServices(), *mNode, mode == INHERIT_PARENT_POSITION );
}
}
return mPositionInheritanceMode;
}
+void Actor::SetInheritPosition( bool inherit )
+{
+ if( mInheritPosition != inherit && NULL != mNode )
+ {
+ // non animateable so keep local copy
+ mInheritPosition = inherit;
+ SetInheritPositionMessage( GetEventThreadServices(), *mNode, inherit );
+ }
+}
+
+bool Actor::IsPositionInherited() const
+{
+ return mInheritPosition;
+}
+
void Actor::SetOrientation( const Radian& angle, const Vector3& axis )
{
Vector3 normalizedAxis( axis.x, axis.y, axis.z );
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty<Quaternion>::Bake, orientation );
+ SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::Bake, orientation );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty<Quaternion>::BakeRelative, Quaternion(angle, axis) );
+ SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::BakeRelative, Quaternion(angle, axis) );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty<Quaternion>::BakeRelative, relativeRotation );
+ SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::BakeRelative, relativeRotation );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::Bake, scale );
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, scale );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeX, x );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeY, y );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeZ, z );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );
}
}
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeRelativeMultiply, relativeScale );
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelativeMultiply, relativeScale );
}
}
void Actor::SetInheritScale( bool inherit )
{
- // non animateable so keep local copy
- mInheritScale = inherit;
- if( NULL != mNode )
+
+ if( mInheritScale != inherit && NULL != mNode )
{
+ // non animateable so keep local copy
+ mInheritScale = inherit;
// mNode is being used in a separate thread; queue a message to set the value
SetInheritScaleMessage( GetEventThreadServices(), *mNode, inherit );
}
{
if( NULL != mNode )
{
- // World matrix is no longer updated unless there is something observing the node.
- // Need to calculate it from node's world position, orientation and scale:
- BufferIndex updateBufferIndex = GetEventThreadServices().GetEventBufferIndex();
- Matrix worldMatrix(false);
- worldMatrix.SetTransformComponents( mNode->GetWorldScale( updateBufferIndex ),
- mNode->GetWorldOrientation( updateBufferIndex ),
- mNode->GetWorldPosition( updateBufferIndex ) );
- return worldMatrix;
+ return mNode->GetWorldMatrix(0);
}
return Matrix::IDENTITY;
void Actor::SetInheritOrientation( bool inherit )
{
- // non animateable so keep local copy
- mInheritOrientation = inherit;
- if( NULL != mNode )
+ if( mInheritOrientation != inherit && NULL != mNode)
{
+ // non animateable so keep local copy
+ mInheritOrientation = inherit;
// mNode is being used in a separate thread; queue a message to set the value
SetInheritOrientationMessage( GetEventThreadServices(), *mNode, inherit );
}
mTargetSize = size;
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::Bake, mTargetSize );
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, mTargetSize );
// Notification for derived classes
mInsideOnSizeSet = true;
{
mTargetSize.height = targetSize;
}
+ else if ( Dali::Actor::Property::SIZE_DEPTH == property )
+ {
+ mTargetSize.depth = targetSize;
+ }
// Notify deriving classes
OnSizeAnimation( animation, mTargetSize );
}
+void Actor::NotifyPositionAnimation( Animation& animation, const Vector3& targetPosition )
+{
+ mTargetPosition = targetPosition;
+}
+
+void Actor::NotifyPositionAnimation( Animation& animation, float targetPosition, Property::Index property )
+{
+ if ( Dali::Actor::Property::POSITION_X == property )
+ {
+ mTargetPosition.x = targetPosition;
+ }
+ else if ( Dali::Actor::Property::POSITION_Y == property )
+ {
+ mTargetPosition.y = targetPosition;
+ }
+ else if ( Dali::Actor::Property::POSITION_Z == property )
+ {
+ mTargetPosition.z = targetPosition;
+ }
+}
+
void Actor::SetWidth( float width )
{
+ mTargetSize.width = width;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeX, width );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, width );
}
}
void Actor::SetHeight( float height )
{
+ mTargetSize.height = height;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeY, height );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, height );
}
}
void Actor::SetDepth( float depth )
{
+ mTargetSize.depth = depth;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeZ, depth );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, depth );
}
}
return false;
}
-bool Actor::ScreenToLocal( RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const
+bool Actor::ScreenToLocal( const RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const
{
bool retval = false;
// only valid when on-stage
return false;
}
- BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
-
- // Calculate the ModelView matrix
- Matrix modelView( false/*don't init*/);
- // need to use the components as world matrix is only updated for actors that need it
- modelView.SetTransformComponents( mNode->GetWorldScale( bufferIndex ), mNode->GetWorldOrientation( bufferIndex ), mNode->GetWorldPosition( bufferIndex ) );
- Matrix::Multiply( modelView, modelView, viewMatrix );
+ // Get the ModelView matrix
+ Matrix modelView;
+ Matrix::Multiply( modelView, mNode->GetWorldMatrix(0), viewMatrix );
// Calculate the inverted ModelViewProjection matrix; this will be used for 2 unprojects
Matrix invertedMvp( false/*don't init*/);
Matrix invModelMatrix( false/*don't init*/);
BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
- // need to use the components as world matrix is only updated for actors that need it
- invModelMatrix.SetInverseTransformComponents( mNode->GetWorldScale( bufferIndex ), mNode->GetWorldOrientation( bufferIndex ), mNode->GetWorldPosition( bufferIndex ) );
+ invModelMatrix = mNode->GetWorldMatrix(0);
+ invModelMatrix.Invert();
Vector4 rayOriginLocal( invModelMatrix * rayOrigin );
Vector4 rayDirLocal( invModelMatrix * rayDir - invModelMatrix.GetTranslation() );
bool Actor::GetTouchRequired() const
{
- return !mTouchedSignal.Empty() || mDerivedRequiresTouch;
+ return !mTouchedSignal.Empty() || !mTouchSignal.Empty() || mDerivedRequiresTouch;
}
bool Actor::GetHoverRequired() const
return mGestureData && mGestureData->IsGestureRequred( type );
}
-bool Actor::EmitTouchEventSignal( const TouchEvent& event )
+bool Actor::EmitTouchEventSignal( const TouchEvent& event, const Dali::TouchData& touch )
{
bool consumed = false;
- if( !mTouchedSignal.Empty() )
+ if( !mTouchSignal.Empty() )
{
Dali::Actor handle( this );
- consumed = mTouchedSignal.Emit( handle, event );
+ consumed = mTouchSignal.Emit( handle, touch );
+ }
+
+ if( !mTouchedSignal.Empty() || !mTouchSignal.Empty() )
+ {
+ Dali::Actor handle( this );
+ consumed |= mTouchedSignal.Emit( handle, event );
}
if( !consumed )
{
// Notification for derived classes
- consumed = OnTouchEvent( event );
+ consumed = OnTouchEvent( event ); // TODO
}
return consumed;
Dali::Actor::TouchSignalType& Actor::TouchedSignal()
{
+ DALI_LOG_WARNING( "Deprecated: Use TouchSignal() instead\n" );
return mTouchedSignal;
}
+Dali::Actor::TouchDataSignalType& Actor::TouchSignal()
+{
+ return mTouchSignal;
+}
+
Dali::Actor::HoverSignalType& Actor::HoveredSignal()
{
return mHoveredSignal;
{
actor->OffStageSignal().Connect( tracker, functor );
}
+ else if( 0 == signalName.compare( SIGNAL_ON_RELAYOUT ) )
+ {
+ actor->OnRelayoutSignal().Connect( tracker, functor );
+ }
else
{
// signalName does not match any signal
mAnchorPoint( NULL ),
mRelayoutData( NULL ),
mGestureData( NULL ),
- mAttachment(),
mTargetSize( 0.0f, 0.0f, 0.0f ),
mName(),
mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
mDerivedRequiresWheelEvent( false ),
mOnStageSignalled( false ),
mInsideOnSizeSet( false ),
+ mInheritPosition( true ),
mInheritOrientation( true ),
mInheritScale( true ),
mDrawMode( DrawMode::NORMAL ),
ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode );
}
- // Notify attachment
- if( mAttachment )
- {
- mAttachment->Connect();
- }
-
unsigned int rendererCount( GetRendererCount() );
for( unsigned int i(0); i<rendererCount; ++i )
{
// Notification for Object::Observers
OnSceneObjectRemove();
- // Notify attachment
- if( mAttachment )
- {
- mAttachment->Disconnect();
- }
-
unsigned int rendererCount( GetRendererCount() );
for( unsigned int i(0); i<rendererCount; ++i )
{
break;
}
+ case Dali::Actor::Property::INHERIT_POSITION:
+ {
+ SetInheritPosition( property.Get< bool >() );
+ break;
+ }
+
case Dali::Actor::Property::INHERIT_ORIENTATION:
{
SetInheritOrientation( property.Get< bool >() );
DALI_ASSERT_ALWAYS( false && "Property type enumeration out of bounds" ); // should not come here
break;
}
- }
+ } // entry.GetType
}
Property::Value Actor::GetDefaultProperty( Property::Index index ) const
case Dali::Actor::Property::SIZE:
{
- value = GetCurrentSize();
+ value = GetTargetSize();
break;
}
case Dali::Actor::Property::SIZE_WIDTH:
{
- value = GetCurrentSize().width;
+ value = GetTargetSize().width;
break;
}
case Dali::Actor::Property::SIZE_HEIGHT:
{
- value = GetCurrentSize().height;
+ value = GetTargetSize().height;
break;
}
case Dali::Actor::Property::SIZE_DEPTH:
{
- value = GetCurrentSize().depth;
+ value = GetTargetSize().depth;
break;
}
case Dali::Actor::Property::POSITION:
{
- value = GetCurrentPosition();
+ value = GetTargetPosition();
break;
}
case Dali::Actor::Property::POSITION_X:
{
- value = GetCurrentPosition().x;
+ value = GetTargetPosition().x;
break;
}
case Dali::Actor::Property::POSITION_Y:
{
- value = GetCurrentPosition().y;
+ value = GetTargetPosition().y;
break;
}
case Dali::Actor::Property::POSITION_Z:
{
- value = GetCurrentPosition().z;
+ value = GetTargetPosition().z;
break;
}
break;
}
+ case Dali::Actor::Property::INHERIT_POSITION:
+ {
+ value = IsPositionInherited();
+ break;
+ }
+
case Dali::Actor::Property::INHERIT_ORIENTATION:
{
value = IsOrientationInherited();
// Instruct each actor to create a corresponding node in the scene graph
ConnectToStage( parent->GetHierarchyDepth() );
}
+
+ // Resolve the name and index for the child properties if any
+ ResolveChildProperties();
}
else // parent being set to NULL
{
return size;
}
}
+ break;
}
default:
void Actor::NegotiateSize( const Vector2& allocatedSize, RelayoutContainer& container )
{
+ // Force a size negotiation for actors that has assigned size during relayout
+ // This is required as otherwise the flags that force a relayout will not
+ // necessarilly be set. This will occur if the actor has already been laid out.
+ // The dirty flags are then cleared. Then if the actor is added back into the
+ // relayout container afterwards, the dirty flags would still be clear...
+ // causing a relayout to be skipped. Here we force any actors added to the
+ // container to be relayed out.
+ if(GetResizePolicy(Dimension::WIDTH) == ResizePolicy::USE_ASSIGNED_SIZE)
+ {
+ SetLayoutNegotiated(false, Dimension::WIDTH);
+ }
+ if(GetResizePolicy(Dimension::HEIGHT) == ResizePolicy::USE_ASSIGNED_SIZE)
+ {
+ SetLayoutNegotiated(false, Dimension::HEIGHT);
+ }
+
// Do the negotiation
NegotiateDimensions( allocatedSize );
{
ActorPtr child = GetChildAt( i );
+ // Forces children that have already been laid out to be relayed out
+ // if they have assigned size during relayout.
+ if(child->GetResizePolicy(Dimension::WIDTH) == ResizePolicy::USE_ASSIGNED_SIZE)
+ {
+ child->SetLayoutNegotiated(false, Dimension::WIDTH);
+ child->SetLayoutDirty(true, Dimension::WIDTH);
+ }
+ if(child->GetResizePolicy(Dimension::HEIGHT) == ResizePolicy::USE_ASSIGNED_SIZE)
+ {
+ child->SetLayoutNegotiated(false, Dimension::HEIGHT);
+ child->SetLayoutDirty(true, Dimension::HEIGHT);
+ }
+
// Only relayout if required
if( child->RelayoutRequired() )
{
return FLT_MAX; // Default
}
+Object* Actor::GetParentObject() const
+{
+ return mParent;
+}
+
} // namespace Internal
} // namespace Dali