#include <cmath>
#include <algorithm>
#include <cfloat>
-#include <cstring> // for strcmp
// INTERNAL INCLUDES
#include <dali/internal/common/message.h>
#include <dali/integration-api/debug.h>
-#ifdef DYNAMICS_SUPPORT
+#ifdef DALI_DYNAMICS_SUPPORT
#include <dali/internal/event/dynamics/dynamics-body-config-impl.h>
#include <dali/internal/event/dynamics/dynamics-body-impl.h>
#include <dali/internal/event/dynamics/dynamics-joint-impl.h>
namespace
{
-DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )DALI_ENUM_TO_STRING( FIXED )
+DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )
+DALI_ENUM_TO_STRING( FIXED )
DALI_ENUM_TO_STRING( USE_NATURAL_SIZE )
DALI_ENUM_TO_STRING( FILL_TO_PARENT )
DALI_ENUM_TO_STRING( SIZE_RELATIVE_TO_PARENT )
namespace
{
// Enumeration to / from string conversion tables
-DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )DALI_ENUM_TO_STRING( USE_SIZE_SET )
+DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )
+DALI_ENUM_TO_STRING( USE_SIZE_SET )
DALI_ENUM_TO_STRING( FIT_WITH_ASPECT_RATIO )
DALI_ENUM_TO_STRING( FILL_WITH_ASPECT_RATIO )
DALI_ENUM_TO_STRING_TABLE_END( Type )
unsigned int Actor::mActorCounter = 0;
+namespace
+{
+/// Using a function because of library initialisation order. Vector3::ONE may not have been initialised yet.
+inline const Vector3& GetDefaultSizeModeFactor()
+{
+ return Vector3::ONE;
+}
+
+/// Using a function because of library initialisation order. Vector2::ZERO may not have been initialised yet.
+inline const Vector2& GetDefaultPreferredSize()
+{
+ return Vector2::ZERO;
+}
+
+/// Using a function because of library initialisation order. Vector2::ZERO may not have been initialised yet.
+inline const Vector2& GetDefaultDimensionPadding()
+{
+ return Vector2::ZERO;
+}
+
+const SizeScalePolicy::Type DEFAULT_SIZE_SCALE_POLICY = SizeScalePolicy::USE_SIZE_SET;
+
+} // unnamed namespace
+
/**
* Struct to collect relayout variables
*/
struct Actor::RelayoutData
{
RelayoutData()
- : sizeModeFactor( Vector3::ONE ), preferredSize( Vector2::ZERO ), sizeSetPolicy( SizeScalePolicy::USE_SIZE_SET ), relayoutEnabled( false ), insideRelayout( false )
+ : 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 )
{
- resizePolicies[ i ] = ResizePolicy::FIXED;
+ resizePolicies[ i ] = ResizePolicy::DEFAULT;
negotiatedDimensions[ i ] = 0.0f;
dimensionNegotiated[ i ] = false;
dimensionDirty[ i ] = false;
dimensionDependencies[ i ] = Dimension::ALL_DIMENSIONS;
- dimensionPadding[ i ] = Vector2( 0.0f, 0.0f );
+ dimensionPadding[ i ] = GetDefaultDimensionPadding();
minimumSize[ i ] = 0.0f;
maximumSize[ i ] = FLT_MAX;
}
bool insideRelayout :1; ///< Locking flag to prevent recursive relayouts on size set
};
-#ifdef DYNAMICS_SUPPORT
+#ifdef DALI_DYNAMICS_SUPPORT
// Encapsulate actor related dynamics data
struct DynamicsData
SlotDelegate< Actor > slotDelegate;
};
-#endif // DYNAMICS_SUPPORT
+#endif // DALI_DYNAMICS_SUPPORT
namespace // unnamed namespace
{
/**
* We want to discourage the use of property strings (minimize string comparisons),
* particularly for the default properties.
- * Name Type writable animatable constraint-input enum for index-checking
+ * Name Type writable animatable constraint-input enum for index-checking
*/
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "parent-origin", VECTOR3, true, false, true, Dali::Actor::Property::PARENT_ORIGIN )
-DALI_PROPERTY( "parent-origin-x", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_X )
-DALI_PROPERTY( "parent-origin-y", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Y )
-DALI_PROPERTY( "parent-origin-z", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Z )
-DALI_PROPERTY( "anchor-point", VECTOR3, true, false, true, Dali::Actor::Property::ANCHOR_POINT )
-DALI_PROPERTY( "anchor-point-x", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_X )
-DALI_PROPERTY( "anchor-point-y", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Y )
-DALI_PROPERTY( "anchor-point-z", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Z )
-DALI_PROPERTY( "size", VECTOR3, true, true, true, Dali::Actor::Property::SIZE )
-DALI_PROPERTY( "size-width", FLOAT, true, true, true, Dali::Actor::Property::SIZE_WIDTH )
-DALI_PROPERTY( "size-height", FLOAT, true, true, true, Dali::Actor::Property::SIZE_HEIGHT )
-DALI_PROPERTY( "size-depth", FLOAT, true, true, true, Dali::Actor::Property::SIZE_DEPTH )
-DALI_PROPERTY( "position", VECTOR3, true, true, true, Dali::Actor::Property::POSITION )
-DALI_PROPERTY( "position-x", FLOAT, true, true, true, Dali::Actor::Property::POSITION_X )
-DALI_PROPERTY( "position-y", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Y )
-DALI_PROPERTY( "position-z", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Z )
-DALI_PROPERTY( "world-position", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_POSITION )
-DALI_PROPERTY( "world-position-x", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_X )
-DALI_PROPERTY( "world-position-y", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Y )
-DALI_PROPERTY( "world-position-z", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Z )
-DALI_PROPERTY( "orientation", ROTATION, true, true, true, Dali::Actor::Property::ORIENTATION )
-DALI_PROPERTY( "world-orientation", ROTATION, false, false, true, Dali::Actor::Property::WORLD_ORIENTATION )
-DALI_PROPERTY( "scale", VECTOR3, true, true, true, Dali::Actor::Property::SCALE )
-DALI_PROPERTY( "scale-x", FLOAT, true, true, true, Dali::Actor::Property::SCALE_X )
-DALI_PROPERTY( "scale-y", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Y )
-DALI_PROPERTY( "scale-z", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Z )
-DALI_PROPERTY( "world-scale", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_SCALE )
-DALI_PROPERTY( "visible", BOOLEAN, true, true, true, Dali::Actor::Property::VISIBLE )
-DALI_PROPERTY( "color", VECTOR4, true, true, true, Dali::Actor::Property::COLOR )
-DALI_PROPERTY( "color-red", FLOAT, true, true, true, Dali::Actor::Property::COLOR_RED )
-DALI_PROPERTY( "color-green", FLOAT, true, true, true, Dali::Actor::Property::COLOR_GREEN )
-DALI_PROPERTY( "color-blue", FLOAT, true, true, true, Dali::Actor::Property::COLOR_BLUE )
-DALI_PROPERTY( "color-alpha", FLOAT, true, true, true, Dali::Actor::Property::COLOR_ALPHA )
-DALI_PROPERTY( "world-color", VECTOR4, false, false, true, Dali::Actor::Property::WORLD_COLOR )
-DALI_PROPERTY( "world-matrix", MATRIX, false, false, true, Dali::Actor::Property::WORLD_MATRIX )
-DALI_PROPERTY( "name", STRING, true, false, false, Dali::Actor::Property::NAME )
-DALI_PROPERTY( "sensitive", BOOLEAN, true, false, false, Dali::Actor::Property::SENSITIVE )
-DALI_PROPERTY( "leave-required", BOOLEAN, true, false, false, Dali::Actor::Property::LEAVE_REQUIRED )
-DALI_PROPERTY( "inherit-orientation", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_ORIENTATION )
-DALI_PROPERTY( "inherit-scale", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_SCALE )
-DALI_PROPERTY( "color-mode", STRING, true, false, false, Dali::Actor::Property::COLOR_MODE )
-DALI_PROPERTY( "position-inheritance", STRING, true, false, false, Dali::Actor::Property::POSITION_INHERITANCE )
-DALI_PROPERTY( "draw-mode", STRING, true, false, false, Dali::Actor::Property::DRAW_MODE )
-DALI_PROPERTY( "size-mode-factor", VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR )
-DALI_PROPERTY( "width-resize-policy", STRING, true, false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY )
-DALI_PROPERTY( "height-resize-policy", STRING, true, false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY )
-DALI_PROPERTY( "size-scale-policy", STRING, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY )
-DALI_PROPERTY( "width-for-height", BOOLEAN, true, false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT )
-DALI_PROPERTY( "height-for-width", BOOLEAN, true, false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH )
-DALI_PROPERTY( "padding", VECTOR4, true, false, false, Dali::Actor::Property::PADDING )
-DALI_PROPERTY( "minimum-size", VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE )
-DALI_PROPERTY( "maximum-size", VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE )
+DALI_PROPERTY( "parent-origin", VECTOR3, true, false, true, Dali::Actor::Property::PARENT_ORIGIN )
+DALI_PROPERTY( "parent-origin-x", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_X )
+DALI_PROPERTY( "parent-origin-y", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Y )
+DALI_PROPERTY( "parent-origin-z", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Z )
+DALI_PROPERTY( "anchor-point", VECTOR3, true, false, true, Dali::Actor::Property::ANCHOR_POINT )
+DALI_PROPERTY( "anchor-point-x", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_X )
+DALI_PROPERTY( "anchor-point-y", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Y )
+DALI_PROPERTY( "anchor-point-z", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Z )
+DALI_PROPERTY( "size", VECTOR3, true, true, true, Dali::Actor::Property::SIZE )
+DALI_PROPERTY( "size-width", FLOAT, true, true, true, Dali::Actor::Property::SIZE_WIDTH )
+DALI_PROPERTY( "size-height", FLOAT, true, true, true, Dali::Actor::Property::SIZE_HEIGHT )
+DALI_PROPERTY( "size-depth", FLOAT, true, true, true, Dali::Actor::Property::SIZE_DEPTH )
+DALI_PROPERTY( "position", VECTOR3, true, true, true, Dali::Actor::Property::POSITION )
+DALI_PROPERTY( "position-x", FLOAT, true, true, true, Dali::Actor::Property::POSITION_X )
+DALI_PROPERTY( "position-y", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Y )
+DALI_PROPERTY( "position-z", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Z )
+DALI_PROPERTY( "world-position", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_POSITION )
+DALI_PROPERTY( "world-position-x", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_X )
+DALI_PROPERTY( "world-position-y", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Y )
+DALI_PROPERTY( "world-position-z", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Z )
+DALI_PROPERTY( "orientation", ROTATION, true, true, true, Dali::Actor::Property::ORIENTATION )
+DALI_PROPERTY( "world-orientation", ROTATION, false, false, true, Dali::Actor::Property::WORLD_ORIENTATION )
+DALI_PROPERTY( "scale", VECTOR3, true, true, true, Dali::Actor::Property::SCALE )
+DALI_PROPERTY( "scale-x", FLOAT, true, true, true, Dali::Actor::Property::SCALE_X )
+DALI_PROPERTY( "scale-y", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Y )
+DALI_PROPERTY( "scale-z", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Z )
+DALI_PROPERTY( "world-scale", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_SCALE )
+DALI_PROPERTY( "visible", BOOLEAN, true, true, true, Dali::Actor::Property::VISIBLE )
+DALI_PROPERTY( "color", VECTOR4, true, true, true, Dali::Actor::Property::COLOR )
+DALI_PROPERTY( "color-red", FLOAT, true, true, true, Dali::Actor::Property::COLOR_RED )
+DALI_PROPERTY( "color-green", FLOAT, true, true, true, Dali::Actor::Property::COLOR_GREEN )
+DALI_PROPERTY( "color-blue", FLOAT, true, true, true, Dali::Actor::Property::COLOR_BLUE )
+DALI_PROPERTY( "color-alpha", FLOAT, true, true, true, Dali::Actor::Property::COLOR_ALPHA )
+DALI_PROPERTY( "world-color", VECTOR4, false, false, true, Dali::Actor::Property::WORLD_COLOR )
+DALI_PROPERTY( "world-matrix", MATRIX, false, false, true, Dali::Actor::Property::WORLD_MATRIX )
+DALI_PROPERTY( "name", STRING, true, false, false, Dali::Actor::Property::NAME )
+DALI_PROPERTY( "sensitive", BOOLEAN, true, false, false, Dali::Actor::Property::SENSITIVE )
+DALI_PROPERTY( "leave-required", BOOLEAN, true, false, false, Dali::Actor::Property::LEAVE_REQUIRED )
+DALI_PROPERTY( "inherit-orientation",BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_ORIENTATION )
+DALI_PROPERTY( "inherit-scale", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_SCALE )
+DALI_PROPERTY( "color-mode", STRING, true, false, false, Dali::Actor::Property::COLOR_MODE )
+DALI_PROPERTY( "position-inheritance",STRING, true, false, false, Dali::Actor::Property::POSITION_INHERITANCE )
+DALI_PROPERTY( "draw-mode", STRING, true, false, false, Dali::Actor::Property::DRAW_MODE )
+DALI_PROPERTY( "size-mode-factor", VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR )
+DALI_PROPERTY( "width-resize-policy",STRING, true, false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY )
+DALI_PROPERTY( "height-resize-policy",STRING, true, false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY )
+DALI_PROPERTY( "size-scale-policy", STRING, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY )
+DALI_PROPERTY( "width-for-height", BOOLEAN, true, false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT )
+DALI_PROPERTY( "height-for-width", BOOLEAN, true, false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH )
+DALI_PROPERTY( "padding", VECTOR4, true, false, false, Dali::Actor::Property::PADDING )
+DALI_PROPERTY( "minimum-size", VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE )
+DALI_PROPERTY( "maximum-size", VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE )
DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
// Signals
const char* const SIGNAL_TOUCHED = "touched";
const char* const SIGNAL_HOVERED = "hovered";
-const char* const SIGNAL_MOUSE_WHEEL_EVENT = "mouse-wheel-event";
+const char* const SIGNAL_WHEEL_EVENT = "wheel-event";
const char* const SIGNAL_ON_STAGE = "on-stage";
const char* const SIGNAL_OFF_STAGE = "off-stage";
{
return values.width;
}
-
case Dimension::HEIGHT:
{
return values.height;
}
-
default:
{
break;
}
}
-
return 0.0f;
}
return GetDimensionValue( values.GetVectorXY(), dimension );
}
+
} // unnamed namespace
ActorPtr Actor::New()
const Vector3& Actor::GetSizeModeFactor() const
{
- EnsureRelayoutData();
+ if ( mRelayoutData )
+ {
+ return mRelayoutData->sizeModeFactor;
+ }
- return mRelayoutData->sizeModeFactor;
+ return GetDefaultSizeModeFactor();
}
void Actor::SetColorMode( ColorMode colorMode )
void Actor::SetSizeInternal( const Vector3& size )
{
- if( NULL != mNode )
+ // 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 ) ) )
{
mTargetSize = size;
SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::Bake, mTargetSize );
// Notification for derived classes
+ mInsideOnSizeSet = true;
OnSizeSet( mTargetSize );
+ mInsideOnSizeSet = false;
// Raise a relayout request if the flag is not locked
if( mRelayoutData && !mRelayoutData->insideRelayout )
mTargetSize = targetSize;
// Notify deriving classes
- OnSizeAnimation( animation, targetSize );
+ OnSizeAnimation( animation, mTargetSize );
+}
+
+void Actor::NotifySizeAnimation( Animation& animation, float targetSize, Property::Index property )
+{
+ if ( Dali::Actor::Property::SIZE_WIDTH == property )
+ {
+ mTargetSize.width = targetSize;
+ }
+ else if ( Dali::Actor::Property::SIZE_HEIGHT == property )
+ {
+ mTargetSize.height = targetSize;
+ }
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
}
void Actor::SetWidth( float width )
ResizePolicy::Type Actor::GetResizePolicy( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- // If more than one dimension is requested, just return the first one found
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ if ( mRelayoutData )
{
- if( ( dimension & ( 1 << i ) ) )
+ // If more than one dimension is requested, just return the first one found
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- return mRelayoutData->resizePolicies[ i ];
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ return mRelayoutData->resizePolicies[ i ];
+ }
}
}
- return ResizePolicy::FIXED; // Default
+ return ResizePolicy::DEFAULT;
}
void Actor::SetSizeScalePolicy( SizeScalePolicy::Type policy )
SizeScalePolicy::Type Actor::GetSizeScalePolicy() const
{
- EnsureRelayoutData();
+ if ( mRelayoutData )
+ {
+ return mRelayoutData->sizeSetPolicy;
+ }
- return mRelayoutData->sizeSetPolicy;
+ return DEFAULT_SIZE_SCALE_POLICY;
}
void Actor::SetDimensionDependency( Dimension::Type dimension, Dimension::Type dependency )
Dimension::Type Actor::GetDimensionDependency( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- // If more than one dimension is requested, just return the first one found
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ if ( mRelayoutData )
{
- if( ( dimension & ( 1 << i ) ) )
+ // If more than one dimension is requested, just return the first one found
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- return mRelayoutData->dimensionDependencies[ i ];
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ return mRelayoutData->dimensionDependencies[ i ];
+ }
}
}
bool Actor::IsLayoutDirty( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ if ( mRelayoutData )
{
- if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionDirty[ i ] )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- return true;
+ if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionDirty[ i ] )
+ {
+ return true;
+ }
}
}
bool Actor::RelayoutPossible( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- return mRelayoutData->relayoutEnabled && !IsLayoutDirty( dimension );
+ return mRelayoutData && mRelayoutData->relayoutEnabled && !IsLayoutDirty( dimension );
}
bool Actor::RelayoutRequired( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- return mRelayoutData->relayoutEnabled && IsLayoutDirty( dimension );
+ return mRelayoutData && mRelayoutData->relayoutEnabled && IsLayoutDirty( dimension );
}
unsigned int Actor::AddRenderer( Renderer& renderer )
}
-#ifdef DYNAMICS_SUPPORT
+#ifdef DALI_DYNAMICS_SUPPORT
//--------------- Dynamics ---------------
}
}
-#endif // DYNAMICS_SUPPORT
+#endif // DALI_DYNAMICS_SUPPORT
void Actor::SetOverlay( bool enable )
{
bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const
{
// only valid when on-stage
- if( OnStage() )
+ StagePtr stage = Stage::GetCurrent();
+ if( stage && OnStage() )
{
- const RenderTaskList& taskList = Stage::GetCurrent()->GetRenderTaskList();
+ const RenderTaskList& taskList = stage->GetRenderTaskList();
Vector2 converted( screenX, screenY );
return !mHoveredSignal.Empty() || mDerivedRequiresHover;
}
-bool Actor::GetMouseWheelEventRequired() const
+bool Actor::GetWheelEventRequired() const
{
- return !mMouseWheelEventSignal.Empty() || mDerivedRequiresMouseWheelEvent;
+ return !mWheelEventSignal.Empty() || mDerivedRequiresWheelEvent;
}
bool Actor::IsHittable() const
return consumed;
}
-bool Actor::EmitMouseWheelEventSignal( const MouseWheelEvent& event )
+bool Actor::EmitWheelEventSignal( const WheelEvent& event )
{
bool consumed = false;
- if( !mMouseWheelEventSignal.Empty() )
+ if( !mWheelEventSignal.Empty() )
{
Dali::Actor handle( this );
- consumed = mMouseWheelEventSignal.Emit( handle, event );
+ consumed = mWheelEventSignal.Emit( handle, event );
}
if( !consumed )
{
// Notification for derived classes
- consumed = OnMouseWheelEvent( event );
+ consumed = OnWheelEvent( event );
}
return consumed;
return mHoveredSignal;
}
-Dali::Actor::MouseWheelEventSignalType& Actor::MouseWheelEventSignal()
+Dali::Actor::WheelEventSignalType& Actor::WheelEventSignal()
{
- return mMouseWheelEventSignal;
+ return mWheelEventSignal;
}
Dali::Actor::OnStageSignalType& Actor::OnStageSignal()
bool connected( true );
Actor* actor = dynamic_cast< Actor* >( object );
- if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCHED ) ) // don't want to convert char* to string
+ if( 0 == signalName.compare( SIGNAL_TOUCHED ) )
{
actor->TouchedSignal().Connect( tracker, functor );
}
- else if( 0 == strcmp( signalName.c_str(), SIGNAL_HOVERED ) )
+ else if( 0 == signalName.compare( SIGNAL_HOVERED ) )
{
actor->HoveredSignal().Connect( tracker, functor );
}
- else if( 0 == strcmp( signalName.c_str(), SIGNAL_MOUSE_WHEEL_EVENT ) )
+ else if( 0 == signalName.compare( SIGNAL_WHEEL_EVENT ) )
{
- actor->MouseWheelEventSignal().Connect( tracker, functor );
+ actor->WheelEventSignal().Connect( tracker, functor );
}
- else if( 0 == strcmp( signalName.c_str(), SIGNAL_ON_STAGE ) )
+ else if( 0 == signalName.compare( SIGNAL_ON_STAGE ) )
{
actor->OnStageSignal().Connect( tracker, functor );
}
- else if( 0 == strcmp( signalName.c_str(), SIGNAL_OFF_STAGE ) )
+ else if( 0 == signalName.compare( SIGNAL_OFF_STAGE ) )
{
actor->OffStageSignal().Connect( tracker, functor );
}
mParentOrigin( NULL ),
mAnchorPoint( NULL ),
mRelayoutData( NULL ),
-#ifdef DYNAMICS_SUPPORT
- mDynamicsData( NULL ),
+#ifdef DALI_DYNAMICS_SUPPORT
+ mDynamicsData( NULL ),
#endif
- mGestureData( NULL ), mAttachment(), mTargetSize( 0.0f, 0.0f, 0.0f ), mName(), mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
- mIsRoot( ROOT_LAYER == derivedType ), mIsRenderable( RENDERABLE == derivedType ), mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ), mIsOnStage( false ), mIsDynamicsRoot( false ), mSensitive( true ), mLeaveRequired( false ), mKeyboardFocusable( false ), mDerivedRequiresTouch( false ), mDerivedRequiresHover( false ), mDerivedRequiresMouseWheelEvent( false ), mOnStageSignalled( false ), mInheritOrientation( true ), mInheritScale( true ), mDrawMode( DrawMode::NORMAL ), mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ), mColorMode( Node::DEFAULT_COLOR_MODE )
+ mGestureData( NULL ),
+ mAttachment(),
+ mTargetSize( 0.0f, 0.0f, 0.0f ),
+ mName(),
+ mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
+ mDepth( 0 ),
+ mIsRoot( ROOT_LAYER == derivedType ),
+ mIsRenderable( RENDERABLE == derivedType ),
+ mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ),
+ mIsOnStage( false ),
+ mIsDynamicsRoot( false ),
+ mSensitive( true ),
+ mLeaveRequired( false ),
+ mKeyboardFocusable( false ),
+ mDerivedRequiresTouch( false ),
+ mDerivedRequiresHover( false ),
+ mDerivedRequiresWheelEvent( false ),
+ mOnStageSignalled( false ),
+ mInsideOnSizeSet( false ),
+ mInheritOrientation( true ),
+ mInheritScale( true ),
+ mDrawMode( DrawMode::NORMAL ),
+ mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ),
+ mColorMode( Node::DEFAULT_COLOR_MODE )
{
}
GetEventThreadServices().UnregisterObject( this );
}
-#ifdef DYNAMICS_SUPPORT
+#ifdef DALI_DYNAMICS_SUPPORT
// Cleanup dynamics
delete mDynamicsData;
#endif
}
}
-void Actor::ConnectToStage( int index )
+void Actor::ConnectToStage( unsigned int parentDepth, int index )
{
// This container is used instead of walking the Actor hierachy.
// It protects us when the Actor hierachy is modified during OnStageConnectionExternal callbacks.
ActorContainer connectionList;
+
// This stage is atomic i.e. not interrupted by user callbacks
- RecursiveConnectToStage( connectionList, index );
+ RecursiveConnectToStage( connectionList, parentDepth+1, index );
// Notify applications about the newly connected actors.
const ActorIter endIter = connectionList.end();
RelayoutRequest();
}
-void Actor::RecursiveConnectToStage( ActorContainer& connectionList, int index )
+void Actor::RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth, int index )
{
DALI_ASSERT_ALWAYS( !OnStage() );
mIsOnStage = true;
+ mDepth = depth;
ConnectToSceneGraph( index );
for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
{
Actor& actor = GetImplementation( *iter );
- actor.RecursiveConnectToStage( connectionList );
+ actor.RecursiveConnectToStage( connectionList, depth+1 );
}
}
}
mAttachment->Connect();
}
-#ifdef DYNAMICS_SUPPORT
+#ifdef DALI_DYNAMICS_SUPPORT
// Notify dynamics
if( NULL != mDynamicsData )
{
if( OnStage() && !mOnStageSignalled )
{
// Notification for external (CustomActor) derived classes
- OnStageConnectionExternal();
+ OnStageConnectionExternal( mDepth );
if( !mOnStageSignal.Empty() )
{
mAttachment->Disconnect();
}
-#ifdef DYNAMICS_SUPPORT
+#ifdef DALI_DYNAMICS_SUPPORT
// Notify dynamics
if( NULL != mDynamicsData )
{
void Actor::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
{
- indices.reserve( DEFAULT_PROPERTY_COUNT );
+ indices.Reserve( DEFAULT_PROPERTY_COUNT );
for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
{
- indices.push_back( i );
+ indices.PushBack( i );
}
}
for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
{
const Internal::PropertyDetails* property = &DEFAULT_PROPERTY_DETAILS[ i ];
- if( 0 == strcmp( name.c_str(), property->name ) ) // dont want to convert rhs to string
+ if( 0 == name.compare( property->name ) )
{
index = i;
break;
case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
{
- SetResizePolicy( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount ), Dimension::WIDTH );
+ ResizePolicy::Type type;
+ if( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount, type ) )
+ {
+ SetResizePolicy( type, Dimension::WIDTH );
+ }
break;
}
case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
{
- SetResizePolicy( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount ), Dimension::HEIGHT );
+ ResizePolicy::Type type;
+ if( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount, type ) )
+ {
+ SetResizePolicy( type, Dimension::HEIGHT );
+ }
break;
}
case Dali::Actor::Property::SIZE_SCALE_POLICY:
{
- SetSizeScalePolicy( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount ) );
+ SizeScalePolicy::Type type;
+ if( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount, type ) )
+ {
+ SetSizeScalePolicy( type );
+ }
break;
}
parent->OnStage() )
{
// Instruct each actor to create a corresponding node in the scene graph
- ConnectToStage( index );
+ ConnectToStage( parent->GetDepth(), index );
}
}
else // parent being set to NULL
return Node::New();
}
-bool Actor::DoAction( BaseObject* object, const std::string& actionName, const std::vector< Property::Value >& attributes )
+bool Actor::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& /* attributes */ )
{
bool done = false;
Actor* actor = dynamic_cast< Actor* >( object );
if( actor )
{
- if( 0 == strcmp( actionName.c_str(), ACTION_SHOW ) ) // dont want to convert char* to string
+ if( 0 == actionName.compare( ACTION_SHOW ) )
{
actor->SetVisible( true );
done = true;
}
- else if( 0 == strcmp( actionName.c_str(), ACTION_HIDE ) )
+ else if( 0 == actionName.compare( ACTION_HIDE ) )
{
actor->SetVisible( false );
done = true;
return done;
}
-void Actor::EnsureRelayoutData() const
+void Actor::EnsureRelayoutData()
{
// Assign relayout data.
if( !mRelayoutData )
Vector2 Actor::GetPadding( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- // If more than one dimension is requested, just return the first one found
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ if ( mRelayoutData )
{
- if( ( dimension & ( 1 << i ) ) )
+ // If more than one dimension is requested, just return the first one found
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- return mRelayoutData->dimensionPadding[ i ];
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ return mRelayoutData->dimensionPadding[ i ];
+ }
}
}
- return Vector2( 0.0f, 0.0f ); // Default
+ return GetDefaultDimensionPadding();
}
void Actor::SetLayoutNegotiated( bool negotiated, Dimension::Type dimension )
{
+ EnsureRelayoutData();
+
for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
bool Actor::IsLayoutNegotiated( Dimension::Type dimension ) const
{
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ if ( mRelayoutData )
{
- if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionNegotiated[ i ] )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- return true;
+ if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionNegotiated[ i ] )
+ {
+ return true;
+ }
}
}
return false;
}
-float Actor::CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
+float Actor::GetHeightForWidthBase( float width )
{
- // Could be overridden in derived classes.
- return CalculateChildSizeBase( child, dimension );
+ float height = 0.0f;
+
+ const Vector3 naturalSize = GetNaturalSize();
+ if( naturalSize.width > 0.0f )
+ {
+ height = naturalSize.height * width / naturalSize.width;
+ }
+ else // we treat 0 as 1:1 aspect ratio
+ {
+ height = width;
+ }
+
+ return height;
+}
+
+float Actor::GetWidthForHeightBase( float height )
+{
+ float width = 0.0f;
+
+ const Vector3 naturalSize = GetNaturalSize();
+ if( naturalSize.height > 0.0f )
+ {
+ width = naturalSize.width * height / naturalSize.height;
+ }
+ else // we treat 0 as 1:1 aspect ratio
+ {
+ width = height;
+ }
+
+ return width;
}
float Actor::CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension )
}
}
-float Actor::GetHeightForWidth( float width )
+float Actor::CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
{
- // Could be overridden in derived classes.
- float height = 0.0f;
-
- const Vector3 naturalSize = GetNaturalSize();
- if( naturalSize.width > 0.0f )
- {
- height = naturalSize.height * width / naturalSize.width;
- }
+ // Can be overridden in derived class
+ return CalculateChildSizeBase( child, dimension );
+}
- return height;
+float Actor::GetHeightForWidth( float width )
+{
+ // Can be overridden in derived class
+ return GetHeightForWidthBase( width );
}
float Actor::GetWidthForHeight( float height )
{
- // Could be overridden in derived classes.
- float width = 0.0f;
-
- const Vector3 naturalSize = GetNaturalSize();
- if( naturalSize.height > 0.0f )
- {
- width = naturalSize.width * height / naturalSize.height;
- }
-
- return width;
+ // Can be overridden in derived class
+ return GetWidthForHeightBase( height );
}
float Actor::GetLatestSize( Dimension::Type dimension ) const
}
}
-void Actor::PropagateRelayoutFlags()
-{
- Internal::RelayoutController* relayoutController = Internal::RelayoutController::Get();
- if( relayoutController )
- {
- Dali::Actor self( this );
- relayoutController->PropagateFlags( self );
- }
-}
-
void Actor::OnCalculateRelayoutSize( Dimension::Type dimension )
{
}
Vector2 Actor::GetPreferredSize() const
{
- EnsureRelayoutData();
+ if ( mRelayoutData )
+ {
+ return mRelayoutData->preferredSize;
+ }
- return mRelayoutData->preferredSize;
+ return GetDefaultPreferredSize();
}
void Actor::SetMinimumSize( float size, Dimension::Type dimension )
float Actor::GetMinimumSize( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ if ( mRelayoutData )
{
- if( dimension & ( 1 << i ) )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- return mRelayoutData->minimumSize[ i ];
+ if( dimension & ( 1 << i ) )
+ {
+ return mRelayoutData->minimumSize[ i ];
+ }
}
}
float Actor::GetMaximumSize( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ if ( mRelayoutData )
{
- if( dimension & ( 1 << i ) )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- return mRelayoutData->maximumSize[ i ];
+ if( dimension & ( 1 << i ) )
+ {
+ return mRelayoutData->maximumSize[ i ];
+ }
}
}
- return 0.0f; // Default
+ return FLT_MAX; // Default
}
} // namespace Internal