/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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/vector3.h>
#include <dali/public-api/math/radian.h>
#include <dali/public-api/object/type-registry.h>
-#include <dali/public-api/scripting/scripting.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/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/actor-attachments/renderer-attachment-impl.h>
#include <dali/internal/event/animation/constraint-impl.h>
#include <dali/internal/event/common/projection.h>
#include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
#include <dali/internal/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
{
+namespace ResizePolicy
+{
+
+namespace
+{
+DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )
+DALI_ENUM_TO_STRING( FIXED )
+DALI_ENUM_TO_STRING( USE_NATURAL_SIZE )
+DALI_ENUM_TO_STRING( FILL_TO_PARENT )
+DALI_ENUM_TO_STRING( SIZE_RELATIVE_TO_PARENT )
+DALI_ENUM_TO_STRING( SIZE_FIXED_OFFSET_FROM_PARENT )
+DALI_ENUM_TO_STRING( FIT_TO_CHILDREN )
+DALI_ENUM_TO_STRING( DIMENSION_DEPENDENCY )
+DALI_ENUM_TO_STRING( USE_ASSIGNED_SIZE )
+DALI_ENUM_TO_STRING_TABLE_END( Type )
+
+} // unnamed namespace
+} // ResizePolicy
+
+namespace SizeScalePolicy
+{
+namespace
+{
+// Enumeration to / from string conversion tables
+DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )
+DALI_ENUM_TO_STRING( USE_SIZE_SET )
+DALI_ENUM_TO_STRING( FIT_WITH_ASPECT_RATIO )
+DALI_ENUM_TO_STRING( FILL_WITH_ASPECT_RATIO )
+DALI_ENUM_TO_STRING_TABLE_END( Type )
+} // unnamed namespace
+} // SizeScalePolicy
namespace Internal
{
unsigned int Actor::mActorCounter = 0;
-ActorContainer Actor::mNullChildren;
+
+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( 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_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- resizePolicies[ i ] = FIXED;
+ resizePolicies[ i ] = ResizePolicy::DEFAULT;
negotiatedDimensions[ i ] = 0.0f;
dimensionNegotiated[ i ] = false;
dimensionDirty[ i ] = false;
- dimensionDependencies[ i ] = ALL_DIMENSIONS;
- dimensionPadding[ i ] = Vector2( 0.0f, 0.0f );
+ dimensionDependencies[ i ] = Dimension::ALL_DIMENSIONS;
+ dimensionPadding[ i ] = GetDefaultDimensionPadding();
minimumSize[ i ] = 0.0f;
maximumSize[ i ] = FLT_MAX;
}
}
- ResizePolicy resizePolicies[ DIMENSION_COUNT ]; ///< Resize policies
+ ResizePolicy::Type resizePolicies[ Dimension::DIMENSION_COUNT ]; ///< Resize policies
- Dimension dimensionDependencies[ DIMENSION_COUNT ]; ///< A list of dimension dependencies
+ Dimension::Type dimensionDependencies[ Dimension::DIMENSION_COUNT ]; ///< A list of dimension dependencies
- Vector2 dimensionPadding[ DIMENSION_COUNT ]; ///< Padding for each dimension. X = start (e.g. left, bottom), y = end (e.g. right, top)
+ Vector2 dimensionPadding[ Dimension::DIMENSION_COUNT ]; ///< Padding for each dimension. X = start (e.g. left, bottom), y = end (e.g. right, top)
- float negotiatedDimensions[ DIMENSION_COUNT ]; ///< Storage for when a dimension is negotiated but before set on actor
+ float negotiatedDimensions[ Dimension::DIMENSION_COUNT ]; ///< Storage for when a dimension is negotiated but before set on actor
- float minimumSize[ DIMENSION_COUNT ]; ///< The minimum size an actor can be
- float maximumSize[ DIMENSION_COUNT ]; ///< The maximum size an actor can be
+ float minimumSize[ Dimension::DIMENSION_COUNT ]; ///< The minimum size an actor can be
+ float maximumSize[ Dimension::DIMENSION_COUNT ]; ///< The maximum size an actor can be
- bool dimensionNegotiated[ DIMENSION_COUNT ]; ///< Has the dimension been negotiated
- bool dimensionDirty[ DIMENSION_COUNT ]; ///< Flags indicating whether the layout dimension is dirty or not
+ bool dimensionNegotiated[ Dimension::DIMENSION_COUNT ]; ///< Has the dimension been negotiated
+ bool dimensionDirty[ Dimension::DIMENSION_COUNT ]; ///< Flags indicating whether the layout dimension is dirty or not
Vector3 sizeModeFactor; ///< Factor of size used for certain SizeModes
Vector2 preferredSize; ///< The preferred size of the actor
- SizeScalePolicy sizeSetPolicy :3; ///< Policy to apply when setting size. Enough room for the enum
+ SizeScalePolicy::Type sizeSetPolicy :3; ///< Policy to apply when setting size. Enough room for the enum
bool relayoutEnabled :1; ///< Flag to specify if this actor should be included in size negotiation or not (defaults to true)
bool insideRelayout :1; ///< Locking flag to prevent recursive relayouts on size set
};
-#ifdef DYNAMICS_SUPPORT
+#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( "relayout-enabled", BOOLEAN, true, false, false, Dali::Actor::Property::RELAYOUT_ENABLED )
-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";
const char* const ACTION_SHOW = "show";
const char* const ACTION_HIDE = "hide";
-// Enumeration to / from string conversion tables
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( ResizePolicy )DALI_ENUM_TO_STRING( FIXED )
-DALI_ENUM_TO_STRING( USE_NATURAL_SIZE )
-DALI_ENUM_TO_STRING( FILL_TO_PARENT )
-DALI_ENUM_TO_STRING( SIZE_RELATIVE_TO_PARENT )
-DALI_ENUM_TO_STRING( SIZE_FIXED_OFFSET_FROM_PARENT )
-DALI_ENUM_TO_STRING( FIT_TO_CHILDREN )
-DALI_ENUM_TO_STRING( DIMENSION_DEPENDENCY )
-DALI_ENUM_TO_STRING( USE_ASSIGNED_SIZE )
-DALI_ENUM_TO_STRING_TABLE_END( ResizePolicy )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( SizeScalePolicy )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( SizeScalePolicy )
-
BaseHandle CreateActor()
{
return Dali::Actor::New();
* @param[in] dimension The dimension to extract
* @return Return the value for the dimension
*/
-float GetDimensionValue( const Vector2& values, Dimension dimension )
+float GetDimensionValue( const Vector2& values, Dimension::Type dimension )
{
switch( dimension )
{
- case WIDTH:
+ case Dimension::WIDTH:
{
return values.width;
}
-
- case HEIGHT:
+ case Dimension::HEIGHT:
{
return values.height;
}
-
default:
{
break;
}
}
-
return 0.0f;
}
* @param[in] dimension The dimension to extract
* @return Return the value for the dimension
*/
-float GetDimensionValue( const Vector3& values, Dimension dimension )
+float GetDimensionValue( const Vector3& values, Dimension::Type dimension )
{
return GetDimensionValue( values.GetVectorXY(), dimension );
}
+
} // unnamed namespace
ActorPtr Actor::New()
return ( ( mChildren ) ? ( *mChildren )[ index ] : Dali::Actor() );
}
-ActorContainer Actor::GetChildren()
-{
- if( NULL != mChildren )
- {
- return *mChildren;
- }
-
- // return copy of mNullChildren
- return mNullChildren;
-}
-
-const ActorContainer& Actor::GetChildren() const
-{
- if( NULL != mChildren )
- {
- return *mChildren;
- }
-
- // return const reference to mNullChildren
- return mNullChildren;
-}
-
ActorPtr Actor::FindChildByName( const std::string& actorName )
{
ActorPtr child = 0;
void Actor::SetPosition( const Vector3& position )
{
+ mTargetPosition = position;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
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
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
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
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
return Vector3::ZERO;
}
+const Vector3& Actor::GetTargetPosition() const
+{
+ return mTargetPosition;
+}
+
const Vector3& Actor::GetCurrentWorldPosition() const
{
if( NULL != mNode )
void Actor::SetOrientation( const Radian& angle, const Vector3& axis )
{
- Vector4 normalizedAxis( axis.x, axis.y, axis.z, 0.0f );
+ Vector3 normalizedAxis( axis.x, axis.y, axis.z );
normalizedAxis.Normalize();
- Quaternion orientation( Quaternion::FromAxisAngle( normalizedAxis, angle ) );
+ Quaternion orientation( angle, normalizedAxis );
SetOrientation( orientation );
}
}
}
-void Actor::SetInitialVolume( const Vector3& volume )
-{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value
- SetInitialVolumeMessage( GetEventThreadServices(), *mNode, volume );
- }
-}
-
-void Actor::SetTransmitGeometryScaling( bool transmitGeometryScaling )
-{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value
- SetTransmitGeometryScalingMessage( GetEventThreadServices(), *mNode, transmitGeometryScaling );
- }
-}
-
-bool Actor::GetTransmitGeometryScaling() const
-{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetTransmitGeometryScaling();
- }
-
- return false;
-}
-
-void Actor::ScaleBy( const Vector3& relativeScale )
+void Actor::ScaleBy(const Vector3& relativeScale)
{
if( NULL != mNode )
{
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 )
return Vector3( 0.0f, 0.0f, 0.0f );
}
-void Actor::SetResizePolicy( ResizePolicy policy, Dimension dimension )
+void Actor::SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
}
}
- if( policy == DIMENSION_DEPENDENCY )
+ if( policy == ResizePolicy::DIMENSION_DEPENDENCY )
{
- if( dimension & WIDTH )
+ if( dimension & Dimension::WIDTH )
{
- SetDimensionDependency( WIDTH, HEIGHT );
+ SetDimensionDependency( Dimension::WIDTH, Dimension::HEIGHT );
}
- if( dimension & HEIGHT )
+ if( dimension & Dimension::HEIGHT )
{
- SetDimensionDependency( HEIGHT, WIDTH );
+ SetDimensionDependency( Dimension::HEIGHT, Dimension::WIDTH );
}
}
+ // If calling SetResizePolicy, assume we want relayout enabled
+ SetRelayoutEnabled( true );
+
OnSetResizePolicy( policy, dimension );
// Trigger relayout on this control
RelayoutRequest();
}
-ResizePolicy Actor::GetResizePolicy( Dimension dimension ) const
+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_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 FIXED; // Default
+ return ResizePolicy::DEFAULT;
}
-void Actor::SetSizeScalePolicy( SizeScalePolicy policy )
+void Actor::SetSizeScalePolicy( SizeScalePolicy::Type policy )
{
EnsureRelayoutData();
mRelayoutData->sizeSetPolicy = policy;
}
-SizeScalePolicy Actor::GetSizeScalePolicy() const
+SizeScalePolicy::Type Actor::GetSizeScalePolicy() const
{
- EnsureRelayoutData();
+ if ( mRelayoutData )
+ {
+ return mRelayoutData->sizeSetPolicy;
+ }
- return mRelayoutData->sizeSetPolicy;
+ return DEFAULT_SIZE_SCALE_POLICY;
}
-void Actor::SetDimensionDependency( Dimension dimension, Dimension dependency )
+void Actor::SetDimensionDependency( Dimension::Type dimension, Dimension::Type dependency )
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
}
}
-Dimension Actor::GetDimensionDependency( Dimension dimension ) const
+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_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 ];
+ }
}
}
- return ALL_DIMENSIONS; // Default
+ return Dimension::ALL_DIMENSIONS; // Default
}
void Actor::SetRelayoutEnabled( bool relayoutEnabled )
return mRelayoutData && mRelayoutData->relayoutEnabled;
}
-void Actor::SetLayoutDirty( bool dirty, Dimension dimension )
+void Actor::SetLayoutDirty( bool dirty, Dimension::Type dimension )
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
}
}
-bool Actor::IsLayoutDirty( Dimension dimension ) const
+bool Actor::IsLayoutDirty( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- for( unsigned int i = 0; i < 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;
+ }
}
}
return false;
}
-bool Actor::RelayoutPossible( Dimension dimension ) const
+bool Actor::RelayoutPossible( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
+ return mRelayoutData && mRelayoutData->relayoutEnabled && !IsLayoutDirty( dimension );
+}
- return mRelayoutData->relayoutEnabled && !IsLayoutDirty( dimension );
+bool Actor::RelayoutRequired( Dimension::Type dimension ) const
+{
+ return mRelayoutData && mRelayoutData->relayoutEnabled && IsLayoutDirty( dimension );
}
-bool Actor::RelayoutRequired( Dimension dimension ) const
+unsigned int Actor::AddRenderer( Renderer& renderer )
{
- EnsureRelayoutData();
+ //TODO: MESH_REWORK : Add support for multiple renderers
+ if ( ! mAttachment )
+ {
+ mAttachment = RendererAttachment::New( GetEventThreadServices(), *mNode, renderer );
+ }
+
+ return 0;
+}
+
+unsigned int Actor::GetRendererCount() const
+{
+ //TODO: MESH_REWORK : Add support for multiple renderers
+ RendererAttachment* attachment = dynamic_cast<RendererAttachment*>(mAttachment.Get());
+ return attachment ? 1u : 0u;
+}
+
+Renderer& Actor::GetRendererAt( unsigned int index )
+{
+ //TODO: MESH_REWORK : Add support for multiple renderers
+ DALI_ASSERT_DEBUG( index == 0 && "Only one renderer is supported." );
+
+ //TODO: MESH_REWORK : Temporary code
+ RendererAttachment* attachment = dynamic_cast<RendererAttachment*>(mAttachment.Get());
+ DALI_ASSERT_ALWAYS( attachment && "Actor doesn't have a renderer" );
+
+ return attachment->GetRenderer();
+}
+
+void Actor::RemoveRenderer( Renderer& renderer )
+{
+ //TODO: MESH_REWORK : Add support for multiple renderers
+ mAttachment = NULL;
+}
- return mRelayoutData->relayoutEnabled && IsLayoutDirty( dimension );
+void Actor::RemoveRenderer( unsigned int index )
+{
+ //TODO: MESH_REWORK : Add support for multiple renderers
+ mAttachment = NULL;
}
-#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;
break;
}
- case Dali::Actor::Property::RELAYOUT_ENABLED:
- {
- SetRelayoutEnabled( property.Get< bool >() );
- break;
- }
-
case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
{
- SetResizePolicy( Scripting::GetEnumeration< ResizePolicy >( property.Get< std::string >().c_str(), ResizePolicyTable, ResizePolicyTableCount ), 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 >( property.Get< std::string >().c_str(), ResizePolicyTable, ResizePolicyTableCount ), 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 >( property.Get< std::string >().c_str(), SizeScalePolicyTable, SizeScalePolicyTableCount ) );
+ SizeScalePolicy::Type type;
+ if( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount, type ) )
+ {
+ SetSizeScalePolicy( type );
+ }
break;
}
{
if( property.Get< bool >() )
{
- SetResizePolicy( DIMENSION_DEPENDENCY, WIDTH );
+ SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::WIDTH );
}
break;
}
{
if( property.Get< bool >() )
{
- SetResizePolicy( DIMENSION_DEPENDENCY, HEIGHT );
+ SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::HEIGHT );
}
break;
}
case Dali::Actor::Property::PADDING:
{
Vector4 padding = property.Get< Vector4 >();
- SetPadding( Vector2( padding.x, padding.y ), WIDTH );
- SetPadding( Vector2( padding.z, padding.w ), HEIGHT );
+ SetPadding( Vector2( padding.x, padding.y ), Dimension::WIDTH );
+ SetPadding( Vector2( padding.z, padding.w ), Dimension::HEIGHT );
break;
}
case Dali::Actor::Property::MINIMUM_SIZE:
{
Vector2 size = property.Get< Vector2 >();
- SetMinimumSize( size.x, WIDTH );
- SetMinimumSize( size.y, HEIGHT );
+ SetMinimumSize( size.x, Dimension::WIDTH );
+ SetMinimumSize( size.y, Dimension::HEIGHT );
break;
}
case Dali::Actor::Property::MAXIMUM_SIZE:
{
Vector2 size = property.Get< Vector2 >();
- SetMaximumSize( size.x, WIDTH );
- SetMaximumSize( size.y, HEIGHT );
+ SetMaximumSize( size.x, Dimension::WIDTH );
+ SetMaximumSize( size.y, Dimension::HEIGHT );
break;
}
// TODO: This method needs to be removed
void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value )
{
- OnPropertySet( index, value );
-
switch( entry.type )
{
case Property::BOOLEAN:
break;
}
- case Property::FLOAT:
+ case Property::INTEGER:
{
- const AnimatableProperty< float >* property = dynamic_cast< const AnimatableProperty< float >* >( entry.GetSceneGraphProperty() );
+ const AnimatableProperty< int >* property = dynamic_cast< const AnimatableProperty< int >* >( entry.GetSceneGraphProperty() );
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<float>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<float>::Bake, value.Get<float>() );
+ SceneGraph::NodePropertyMessage<int>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<int>::Bake, value.Get<int>() );
break;
}
- case Property::INTEGER:
+ case Property::UNSIGNED_INTEGER:
{
- const AnimatableProperty< int >* property = dynamic_cast< const AnimatableProperty< int >* >( entry.GetSceneGraphProperty() );
+ const AnimatableProperty< unsigned int >* property = dynamic_cast< const AnimatableProperty< unsigned int >* >( entry.GetSceneGraphProperty() );
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<int>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<int>::Bake, value.Get<int>() );
+ SceneGraph::NodePropertyMessage<unsigned int>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<unsigned int>::Bake, value.Get<unsigned int>() );
+
+ break;
+ }
+
+ case Property::FLOAT:
+ {
+ const AnimatableProperty< float >* property = dynamic_cast< const AnimatableProperty< float >* >( entry.GetSceneGraphProperty() );
+ DALI_ASSERT_DEBUG( NULL != property );
+
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<float>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<float>::Bake, value.Get<float>() );
break;
}
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
+ if(entry.componentIndex == 0)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), mNode, 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>() );
+ }
+ else
+ {
+ SceneGraph::NodePropertyMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
+ }
break;
}
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
+ if(entry.componentIndex == 0)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, 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>() );
+ }
+ else if(entry.componentIndex == 2)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::BakeZ, value.Get<float>() );
+ }
+ else
+ {
+ SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
+ }
break;
}
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
+ if(entry.componentIndex == 0)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, 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>() );
+ }
+ else if(entry.componentIndex == 2)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, 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>() );
+ }
+ else
+ {
+ SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
+ }
break;
}
break;
}
- case Dali::Actor::Property::RELAYOUT_ENABLED:
- {
- value = IsRelayoutEnabled();
- break;
- }
-
case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
{
- value = Scripting::GetLinearEnumerationName< ResizePolicy >( GetResizePolicy( WIDTH ), ResizePolicyTable, ResizePolicyTableCount );
+ value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::WIDTH ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount );
break;
}
case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
{
- value = Scripting::GetLinearEnumerationName< ResizePolicy >( GetResizePolicy( HEIGHT ), ResizePolicyTable, ResizePolicyTableCount );
+ value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::HEIGHT ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount );
break;
}
case Dali::Actor::Property::SIZE_SCALE_POLICY:
{
- value = Scripting::GetLinearEnumerationName< SizeScalePolicy >( GetSizeScalePolicy(), SizeScalePolicyTable, SizeScalePolicyTableCount );
+ value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount );
break;
}
case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
{
- value = ( GetResizePolicy( WIDTH ) == DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( WIDTH ) == HEIGHT );
+ value = ( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::WIDTH ) == Dimension::HEIGHT );
break;
}
case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
{
- value = ( GetResizePolicy( HEIGHT ) == DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( HEIGHT ) == WIDTH );
+ value = ( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::HEIGHT ) == Dimension::WIDTH );
break;
}
case Dali::Actor::Property::PADDING:
{
- Vector2 widthPadding = GetPadding( WIDTH );
- Vector2 heightPadding = GetPadding( HEIGHT );
+ Vector2 widthPadding = GetPadding( Dimension::WIDTH );
+ Vector2 heightPadding = GetPadding( Dimension::HEIGHT );
value = Vector4( widthPadding.x, widthPadding.y, heightPadding.x, heightPadding.y );
break;
}
case Dali::Actor::Property::MINIMUM_SIZE:
{
- value = Vector2( GetMinimumSize( WIDTH ), GetMinimumSize( HEIGHT ) );
+ value = Vector2( GetMinimumSize( Dimension::WIDTH ), GetMinimumSize( Dimension::HEIGHT ) );
break;
}
case Dali::Actor::Property::MAXIMUM_SIZE:
{
- value = Vector2( GetMaximumSize( WIDTH ), GetMaximumSize( HEIGHT ) );
+ value = Vector2( GetMaximumSize( Dimension::WIDTH ), GetMaximumSize( Dimension::HEIGHT ) );
break;
}
if ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX && index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )
{
- AnimatablePropertyMetadata* animatable = FindAnimatableProperty( index );
- if( !animatable )
- {
- const TypeInfo* typeInfo( GetTypeInfo() );
- if ( typeInfo )
- {
- if( Property::INVALID_INDEX != RegisterSceneGraphProperty( typeInfo->GetPropertyName( index ), index, Property::Value( typeInfo->GetPropertyType( index ) ) ) )
- {
- animatable = FindAnimatableProperty( index );
- }
- }
- }
+ AnimatablePropertyMetadata* animatable = RegisterAnimatableProperty( index );
DALI_ASSERT_ALWAYS( animatable && "Property index is invalid" );
property = animatable->GetSceneGraphProperty();
if ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX && index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )
{
- AnimatablePropertyMetadata* animatable = FindAnimatableProperty( index );
- if( !animatable )
- {
- const TypeInfo* typeInfo( GetTypeInfo() );
- if ( typeInfo )
- {
- if( Property::INVALID_INDEX != RegisterSceneGraphProperty( typeInfo->GetPropertyName( index ), index, Property::Value( typeInfo->GetPropertyType( index ) ) ) )
- {
- animatable = FindAnimatableProperty( index );
- }
- }
- }
+ AnimatablePropertyMetadata* animatable = RegisterAnimatableProperty( index );
DALI_ASSERT_ALWAYS( animatable && "Property index is invalid" );
property = animatable->GetSceneGraphProperty();
{
int componentIndex( Property::INVALID_COMPONENT_INDEX );
- switch( index )
+ if ( ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_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:
+ // check whether the animatable property is registered already, if not then register one.
+ AnimatablePropertyMetadata* animatableProperty = RegisterAnimatableProperty(index);
+ if( animatableProperty )
{
- componentIndex = 0;
- break;
+ componentIndex = animatableProperty->componentIndex;
}
-
- 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:
+ }
+ else
+ {
+ switch( index )
{
- componentIndex = 1;
- break;
- }
+ 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_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_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::COLOR_ALPHA:
- {
- componentIndex = 3;
- 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;
+ }
- default:
- {
- // Do nothing
- break;
+ case Dali::Actor::Property::COLOR_ALPHA:
+ {
+ componentIndex = 3;
+ break;
+ }
+
+ default:
+ {
+ // Do nothing
+ 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 )
}
}
-bool Actor::RelayoutDependentOnParent( Dimension dimension )
+bool Actor::RelayoutDependentOnParent( Dimension::Type dimension )
{
// Check if actor is dependent on parent
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) )
{
- const ResizePolicy resizePolicy = GetResizePolicy( static_cast< Dimension >( 1 << i ) );
- if( resizePolicy == FILL_TO_PARENT || resizePolicy == SIZE_RELATIVE_TO_PARENT || resizePolicy == SIZE_FIXED_OFFSET_FROM_PARENT )
+ const ResizePolicy::Type resizePolicy = GetResizePolicy( static_cast< Dimension::Type >( 1 << i ) );
+ if( resizePolicy == ResizePolicy::FILL_TO_PARENT || resizePolicy == ResizePolicy::SIZE_RELATIVE_TO_PARENT || resizePolicy == ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT )
{
return true;
}
return false;
}
-bool Actor::RelayoutDependentOnChildren( Dimension dimension )
+bool Actor::RelayoutDependentOnChildren( Dimension::Type dimension )
{
// Check if actor is dependent on children
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) )
{
- const ResizePolicy resizePolicy = GetResizePolicy( static_cast< Dimension >( 1 << i ) );
+ const ResizePolicy::Type resizePolicy = GetResizePolicy( static_cast< Dimension::Type >( 1 << i ) );
switch( resizePolicy )
{
- case FIT_TO_CHILDREN:
- case USE_NATURAL_SIZE: // i.e. For things that calculate their size based on children
+ case ResizePolicy::FIT_TO_CHILDREN:
+ case ResizePolicy::USE_NATURAL_SIZE: // i.e. For things that calculate their size based on children
{
return true;
}
return false;
}
-bool Actor::RelayoutDependentOnChildrenBase( Dimension dimension )
+bool Actor::RelayoutDependentOnChildrenBase( Dimension::Type dimension )
{
return Actor::RelayoutDependentOnChildren( dimension );
}
-bool Actor::RelayoutDependentOnDimension( Dimension dimension, Dimension dependentDimension )
+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_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
- return mRelayoutData->resizePolicies[ i ] == DIMENSION_DEPENDENCY && mRelayoutData->dimensionDependencies[ i ] == dependentDimension;
+ return mRelayoutData->resizePolicies[ i ] == ResizePolicy::DIMENSION_DEPENDENCY && mRelayoutData->dimensionDependencies[ i ] == dependentDimension;
}
}
return false;
}
-void Actor::SetNegotiatedDimension( float negotiatedDimension, Dimension dimension )
+void Actor::SetNegotiatedDimension( float negotiatedDimension, Dimension::Type dimension )
{
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
}
}
-float Actor::GetNegotiatedDimension( Dimension dimension ) const
+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_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) )
{
return 0.0f; // Default
}
-void Actor::SetPadding( const Vector2& padding, Dimension dimension )
+void Actor::SetPadding( const Vector2& padding, Dimension::Type dimension )
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
}
}
-Vector2 Actor::GetPadding( Dimension dimension ) const
+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_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 dimension )
+void Actor::SetLayoutNegotiated( bool negotiated, Dimension::Type dimension )
{
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ EnsureRelayoutData();
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
}
}
-bool Actor::IsLayoutNegotiated( Dimension dimension ) const
+bool Actor::IsLayoutNegotiated( Dimension::Type dimension ) const
{
- for( unsigned int i = 0; i < 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 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 dimension )
+float Actor::CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension )
{
// Fill to parent, taking size mode factor into account
switch( child.GetResizePolicy( dimension ) )
{
- case FILL_TO_PARENT:
+ case ResizePolicy::FILL_TO_PARENT:
{
return GetLatestSize( dimension );
}
- case SIZE_RELATIVE_TO_PARENT:
+ case ResizePolicy::SIZE_RELATIVE_TO_PARENT:
{
return GetLatestSize( dimension ) * GetDimensionValue( child.GetSizeModeFactor(), dimension );
}
- case SIZE_FIXED_OFFSET_FROM_PARENT:
+ case ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT:
{
return GetLatestSize( dimension ) + GetDimensionValue( child.GetSizeModeFactor(), 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 dimension ) const
+float Actor::GetLatestSize( Dimension::Type dimension ) const
{
return IsLayoutNegotiated( dimension ) ? GetNegotiatedDimension( dimension ) : GetSize( dimension );
}
-float Actor::GetRelayoutSize( Dimension dimension ) const
+float Actor::GetRelayoutSize( Dimension::Type dimension ) const
{
Vector2 padding = GetPadding( dimension );
return GetLatestSize( dimension ) + padding.x + padding.y;
}
-float Actor::NegotiateFromParent( Dimension dimension )
+float Actor::NegotiateFromParent( Dimension::Type dimension )
{
Actor* parent = GetParent();
if( parent )
return 0.0f;
}
-float Actor::NegotiateFromChildren( Dimension dimension )
+float Actor::NegotiateFromChildren( Dimension::Type dimension )
{
- float minDimensionPoint = 0.0f;
float maxDimensionPoint = 0.0f;
for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
if( !childImpl.RelayoutDependentOnParent( dimension ) )
{
// Calculate the min and max points that the children range across
- float childPosition = GetDimensionValue( childImpl.GetCurrentPosition(), dimension );
+ float childPosition = GetDimensionValue( childImpl.GetTargetPosition(), dimension );
float dimensionSize = childImpl.GetRelayoutSize( dimension );
- minDimensionPoint = std::min( minDimensionPoint, childPosition - dimensionSize * 0.5f );
- maxDimensionPoint = std::max( maxDimensionPoint, childPosition + dimensionSize * 0.5f );
+ maxDimensionPoint = std::max( maxDimensionPoint, childPosition + dimensionSize );
}
}
- return maxDimensionPoint - minDimensionPoint;
+ return maxDimensionPoint;
}
-float Actor::GetSize( Dimension dimension ) const
+float Actor::GetSize( Dimension::Type dimension ) const
{
return GetDimensionValue( GetTargetSize(), dimension );
}
-float Actor::GetNaturalSize( Dimension dimension ) const
+float Actor::GetNaturalSize( Dimension::Type dimension ) const
{
return GetDimensionValue( GetNaturalSize(), dimension );
}
-float Actor::CalculateSize( Dimension dimension, const Vector2& maximumSize )
+float Actor::CalculateSize( Dimension::Type dimension, const Vector2& maximumSize )
{
switch( GetResizePolicy( dimension ) )
{
- case USE_NATURAL_SIZE:
+ case ResizePolicy::USE_NATURAL_SIZE:
{
return GetNaturalSize( dimension );
}
- case FIXED:
+ case ResizePolicy::FIXED:
{
return GetDimensionValue( GetPreferredSize(), dimension );
}
- case USE_ASSIGNED_SIZE:
+ case ResizePolicy::USE_ASSIGNED_SIZE:
{
return GetDimensionValue( maximumSize, dimension );
}
- case FILL_TO_PARENT:
- case SIZE_RELATIVE_TO_PARENT:
- case SIZE_FIXED_OFFSET_FROM_PARENT:
+ case ResizePolicy::FILL_TO_PARENT:
+ case ResizePolicy::SIZE_RELATIVE_TO_PARENT:
+ case ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT:
{
return NegotiateFromParent( dimension );
}
- case FIT_TO_CHILDREN:
+ case ResizePolicy::FIT_TO_CHILDREN:
{
return NegotiateFromChildren( dimension );
}
- case DIMENSION_DEPENDENCY:
+ case ResizePolicy::DIMENSION_DEPENDENCY:
{
- const Dimension dimensionDependency = GetDimensionDependency( dimension );
+ const Dimension::Type dimensionDependency = GetDimensionDependency( dimension );
// Custom rules
- if( dimension == WIDTH && dimensionDependency == HEIGHT )
+ if( dimension == Dimension::WIDTH && dimensionDependency == Dimension::HEIGHT )
{
- return GetWidthForHeight( GetNegotiatedDimension( HEIGHT ) );
+ return GetWidthForHeight( GetNegotiatedDimension( Dimension::HEIGHT ) );
}
- if( dimension == HEIGHT && dimensionDependency == WIDTH )
+ if( dimension == Dimension::HEIGHT && dimensionDependency == Dimension::WIDTH )
{
- return GetHeightForWidth( GetNegotiatedDimension( WIDTH ) );
+ return GetHeightForWidth( GetNegotiatedDimension( Dimension::WIDTH ) );
}
break;
return 0.0f; // Default
}
-float Actor::ConstrainDimension( float size, Dimension dimension )
+float Actor::ClampDimension( float size, Dimension::Type dimension )
{
const float minSize = GetMinimumSize( dimension );
const float maxSize = GetMaximumSize( dimension );
return std::max( minSize, std::min( size, maxSize ) );
}
-void Actor::NegotiateDimension( Dimension dimension, const Vector2& allocatedSize, ActorDimensionStack& recursionStack )
+void Actor::NegotiateDimension( Dimension::Type dimension, const Vector2& allocatedSize, ActorDimensionStack& recursionStack )
{
// Check if it needs to be negotiated
if( IsLayoutDirty( dimension ) && !IsLayoutNegotiated( dimension ) )
recursionStack.push_back( ActorDimensionPair( this, dimension ) );
// Dimension dependency check
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- Dimension dimensionToCheck = static_cast< Dimension >( 1 << i );
+ Dimension::Type dimensionToCheck = static_cast< Dimension::Type >( 1 << i );
if( RelayoutDependentOnDimension( dimension, dimensionToCheck ) )
{
OnCalculateRelayoutSize( dimension );
// All dependencies checked, calculate the size and set negotiated flag
- const float newSize = ConstrainDimension( CalculateSize( dimension, allocatedSize ), dimension );
+ const float newSize = ClampDimension( CalculateSize( dimension, allocatedSize ), dimension );
SetNegotiatedDimension( newSize, dimension );
SetLayoutNegotiated( true, dimension );
// Negotiate all dimensions that require it
ActorDimensionStack recursionStack;
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- const Dimension dimension = static_cast< Dimension >( 1 << i );
+ const Dimension::Type dimension = static_cast< Dimension::Type >( 1 << i );
// Negotiate
NegotiateDimension( dimension, allocatedSize, recursionStack );
{
switch( mRelayoutData->sizeSetPolicy )
{
- case USE_SIZE_SET:
+ case SizeScalePolicy::USE_SIZE_SET:
{
return size;
}
- case FIT_WITH_ASPECT_RATIO:
+ case SizeScalePolicy::FIT_WITH_ASPECT_RATIO:
{
// Scale size to fit within the original size bounds, keeping the natural size aspect ratio
const Vector3 naturalSize = GetNaturalSize();
break;
}
- case FILL_WITH_ASPECT_RATIO:
+ case SizeScalePolicy::FILL_WITH_ASPECT_RATIO:
{
// Scale size to fill the original size bounds, keeping the natural size aspect ratio. Potentially exceeding the original bounds.
const Vector3 naturalSize = GetNaturalSize();
void Actor::SetNegotiatedSize( RelayoutContainer& container )
{
// Do the set actor size
- Vector2 negotiatedSize( GetLatestSize( WIDTH ), GetLatestSize( HEIGHT ) );
+ Vector2 negotiatedSize( GetLatestSize( Dimension::WIDTH ), GetLatestSize( Dimension::HEIGHT ) );
// Adjust for size set policy
negotiatedSize = ApplySizeSetPolicy( negotiatedSize );
}
}
-void Actor::RelayoutRequest( Dimension dimension )
+void Actor::RelayoutRequest( Dimension::Type dimension )
{
Internal::RelayoutController* relayoutController = Internal::RelayoutController::Get();
if( relayoutController )
}
}
-void Actor::RelayoutRequestTree()
-{
- Internal::RelayoutController* relayoutController = Internal::RelayoutController::Get();
- if( relayoutController )
- {
- Dali::Actor self( this );
- relayoutController->RequestRelayoutTree( self );
- }
-}
-
-void Actor::PropagateRelayoutFlags()
-{
- Internal::RelayoutController* relayoutController = Internal::RelayoutController::Get();
- if( relayoutController )
- {
- Dali::Actor self( this );
- relayoutController->PropagateFlags( self );
- }
-}
-
-void Actor::OnCalculateRelayoutSize( Dimension dimension )
+void Actor::OnCalculateRelayoutSize( Dimension::Type dimension )
{
}
-void Actor::OnLayoutNegotiated( float size, Dimension dimension )
+void Actor::OnLayoutNegotiated( float size, Dimension::Type dimension )
{
}
if( size.width > 0.0f )
{
- SetResizePolicy( FIXED, WIDTH );
+ SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
}
if( size.height > 0.0f )
{
- SetResizePolicy( FIXED, HEIGHT );
+ SetResizePolicy( ResizePolicy::FIXED, Dimension::HEIGHT );
}
mRelayoutData->preferredSize = size;
Vector2 Actor::GetPreferredSize() const
{
- EnsureRelayoutData();
+ if ( mRelayoutData )
+ {
+ return mRelayoutData->preferredSize;
+ }
- return mRelayoutData->preferredSize;
+ return GetDefaultPreferredSize();
}
-void Actor::SetMinimumSize( float size, Dimension dimension )
+void Actor::SetMinimumSize( float size, Dimension::Type dimension )
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
RelayoutRequest();
}
-float Actor::GetMinimumSize( Dimension dimension ) const
+float Actor::GetMinimumSize( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- for( unsigned int i = 0; i < 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 ];
+ }
}
}
return 0.0f; // Default
}
-void Actor::SetMaximumSize( float size, Dimension dimension )
+void Actor::SetMaximumSize( float size, Dimension::Type dimension )
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
RelayoutRequest();
}
-float Actor::GetMaximumSize( Dimension dimension ) const
+float Actor::GetMaximumSize( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- for( unsigned int i = 0; i < 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
projects / platform / core / uifw / dali-core.git / blobdiff