/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
// INTERNAL INCLUDES
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector3.h>
+
#include <dali/devel-api/actors/actor-devel.h>
+
#include <dali/internal/event/actors/actor-impl.h>
+#include <dali/internal/event/actors/actor-relayouter.h>
+#include <dali/internal/event/actors/actor-sizer.h>
#include <dali/internal/event/common/property-helper.h>
-#include <dali/internal/update/nodes/node-messages.h>
#include <dali/internal/update/nodes/node-declarations.h>
+#include <dali/internal/update/nodes/node-messages.h>
-using Dali::Internal::SceneGraph::Node;
using Dali::Internal::SceneGraph::AnimatableProperty;
+using Dali::Internal::SceneGraph::Node;
using Dali::Internal::SceneGraph::PropertyBase;
namespace Dali
{
-
namespace Internal
{
-
namespace // unnamed namespace
{
-
struct AnchorValue
{
- const char* name;
+ const char* name;
const Vector3& value;
};
-DALI_ENUM_TO_STRING_TABLE_BEGIN_WITH_TYPE( AnchorValue, ANCHOR_CONSTANT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_LEFT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_CENTER )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_RIGHT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER_LEFT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER_RIGHT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_LEFT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_CENTER )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_RIGHT )
-DALI_ENUM_TO_STRING_TABLE_END( ANCHOR_CONSTANT )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( COLOR_MODE )
-DALI_ENUM_TO_STRING( USE_OWN_COLOR )
-DALI_ENUM_TO_STRING( USE_PARENT_COLOR )
-DALI_ENUM_TO_STRING( USE_OWN_MULTIPLY_PARENT_COLOR )
-DALI_ENUM_TO_STRING( USE_OWN_MULTIPLY_PARENT_ALPHA )
-DALI_ENUM_TO_STRING_TABLE_END( COLOR_MODE )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( DRAW_MODE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DrawMode, NORMAL )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DrawMode, OVERLAY_2D )
-DALI_ENUM_TO_STRING_TABLE_END( DRAW_MODE )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( RESIZE_POLICY )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FIXED )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, USE_NATURAL_SIZE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FILL_TO_PARENT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, SIZE_RELATIVE_TO_PARENT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, SIZE_FIXED_OFFSET_FROM_PARENT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FIT_TO_CHILDREN )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, DIMENSION_DEPENDENCY )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, USE_ASSIGNED_SIZE )
-DALI_ENUM_TO_STRING_TABLE_END( RESIZE_POLICY )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( SIZE_SCALE_POLICY )
-DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, USE_SIZE_SET )
-DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, FIT_WITH_ASPECT_RATIO )
-DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, FILL_WITH_ASPECT_RATIO )
-DALI_ENUM_TO_STRING_TABLE_END( SIZE_SCALE_POLICY )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( CLIPPING_MODE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, DISABLED )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, CLIP_CHILDREN )
-DALI_ENUM_TO_STRING_TABLE_END( CLIPPING_MODE )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( LAYOUT_DIRECTION )
-DALI_ENUM_TO_STRING_WITH_SCOPE( LayoutDirection, LEFT_TO_RIGHT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( LayoutDirection, RIGHT_TO_LEFT )
-DALI_ENUM_TO_STRING_TABLE_END( LAYOUT_DIRECTION )
-
-bool GetAnchorPointConstant( const std::string& value, Vector3& anchor )
+DALI_ENUM_TO_STRING_TABLE_BEGIN_WITH_TYPE(AnchorValue, ANCHOR_CONSTANT)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(AnchorPoint, TOP_LEFT)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(AnchorPoint, TOP_CENTER)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(AnchorPoint, TOP_RIGHT)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(AnchorPoint, CENTER_LEFT)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(AnchorPoint, CENTER)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(AnchorPoint, CENTER_RIGHT)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(AnchorPoint, BOTTOM_LEFT)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(AnchorPoint, BOTTOM_CENTER)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(AnchorPoint, BOTTOM_RIGHT)
+DALI_ENUM_TO_STRING_TABLE_END(ANCHOR_CONSTANT)
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN(COLOR_MODE)
+ DALI_ENUM_TO_STRING(USE_OWN_COLOR)
+ DALI_ENUM_TO_STRING(USE_PARENT_COLOR)
+ DALI_ENUM_TO_STRING(USE_OWN_MULTIPLY_PARENT_COLOR)
+ DALI_ENUM_TO_STRING(USE_OWN_MULTIPLY_PARENT_ALPHA)
+DALI_ENUM_TO_STRING_TABLE_END(COLOR_MODE)
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN(DRAW_MODE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(DrawMode, NORMAL)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(DrawMode, OVERLAY_2D)
+DALI_ENUM_TO_STRING_TABLE_END(DRAW_MODE)
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN(RESIZE_POLICY)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(ResizePolicy, FIXED)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(ResizePolicy, USE_NATURAL_SIZE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(ResizePolicy, FILL_TO_PARENT)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(ResizePolicy, SIZE_RELATIVE_TO_PARENT)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(ResizePolicy, SIZE_FIXED_OFFSET_FROM_PARENT)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(ResizePolicy, FIT_TO_CHILDREN)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(ResizePolicy, DIMENSION_DEPENDENCY)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(ResizePolicy, USE_ASSIGNED_SIZE)
+DALI_ENUM_TO_STRING_TABLE_END(RESIZE_POLICY)
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN(SIZE_SCALE_POLICY)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(SizeScalePolicy, USE_SIZE_SET)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(SizeScalePolicy, FIT_WITH_ASPECT_RATIO)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(SizeScalePolicy, FILL_WITH_ASPECT_RATIO)
+DALI_ENUM_TO_STRING_TABLE_END(SIZE_SCALE_POLICY)
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN(CLIPPING_MODE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(ClippingMode, DISABLED)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(ClippingMode, CLIP_CHILDREN)
+DALI_ENUM_TO_STRING_TABLE_END(CLIPPING_MODE)
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN(LAYOUT_DIRECTION)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(LayoutDirection, LEFT_TO_RIGHT)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(LayoutDirection, RIGHT_TO_LEFT)
+DALI_ENUM_TO_STRING_TABLE_END(LAYOUT_DIRECTION)
+
+bool GetAnchorPointConstant(const std::string& value, Vector3& anchor)
{
- for( uint32_t i = 0; i < ANCHOR_CONSTANT_TABLE_COUNT; ++i )
+ for(uint32_t i = 0; i < ANCHOR_CONSTANT_TABLE_COUNT; ++i)
{
uint32_t sizeIgnored = 0;
- if( CompareTokens( value.c_str(), ANCHOR_CONSTANT_TABLE[ i ].name, sizeIgnored ) )
+ if(CompareTokens(value.c_str(), ANCHOR_CONSTANT_TABLE[i].name, sizeIgnored))
{
- anchor = ANCHOR_CONSTANT_TABLE[ i ].value;
+ anchor = ANCHOR_CONSTANT_TABLE[i].value;
return true;
}
}
return false;
}
-inline bool GetParentOriginConstant( const std::string& value, Vector3& parentOrigin )
+inline bool GetParentOriginConstant(const std::string& value, Vector3& parentOrigin)
{
// Values are the same so just use the same table as anchor-point
- return GetAnchorPointConstant( value, parentOrigin );
+ return GetAnchorPointConstant(value, parentOrigin);
}
} // unnamed namespace
-void Actor::PropertyHandler::SetDefaultProperty( Internal::Actor& actor, Property::Index index, const Property::Value& property )
+void Actor::PropertyHandler::SetDefaultProperty(Internal::Actor& actor, Property::Index index, const Property::Value& property)
{
- switch( index )
+ switch(index)
{
case Dali::Actor::Property::PARENT_ORIGIN:
{
Property::Type type = property.GetType();
- if( type == Property::VECTOR3 )
+ if(type == Property::VECTOR3)
{
- actor.SetParentOrigin( property.Get< Vector3 >() );
+ actor.SetParentOrigin(property.Get<Vector3>());
}
- else if ( type == Property::STRING )
+ else if(type == Property::STRING)
{
std::string parentOriginString;
- property.Get( parentOriginString );
+ property.Get(parentOriginString);
Vector3 parentOrigin;
- if( GetParentOriginConstant( parentOriginString, parentOrigin ) )
+ if(GetParentOriginConstant(parentOriginString, parentOrigin))
{
- actor.SetParentOrigin( parentOrigin );
+ actor.SetParentOrigin(parentOrigin);
}
}
break;
case Dali::Actor::Property::PARENT_ORIGIN_X:
{
const Vector3& current = actor.GetCurrentParentOrigin();
- actor.SetParentOrigin( Vector3( property.Get< float >(), current.y, current.z ) );
+ actor.SetParentOrigin(Vector3(property.Get<float>(), current.y, current.z));
break;
}
case Dali::Actor::Property::PARENT_ORIGIN_Y:
{
const Vector3& current = actor.GetCurrentParentOrigin();
- actor.SetParentOrigin( Vector3( current.x, property.Get< float >(), current.z ) );
+ actor.SetParentOrigin(Vector3(current.x, property.Get<float>(), current.z));
break;
}
case Dali::Actor::Property::PARENT_ORIGIN_Z:
{
const Vector3& current = actor.GetCurrentParentOrigin();
- actor.SetParentOrigin( Vector3( current.x, current.y, property.Get< float >() ) );
+ actor.SetParentOrigin(Vector3(current.x, current.y, property.Get<float>()));
break;
}
case Dali::Actor::Property::ANCHOR_POINT:
{
Property::Type type = property.GetType();
- if( type == Property::VECTOR3 )
+ if(type == Property::VECTOR3)
{
- actor.SetAnchorPoint( property.Get< Vector3 >() );
+ actor.SetAnchorPoint(property.Get<Vector3>());
}
- else if ( type == Property::STRING )
+ else if(type == Property::STRING)
{
std::string anchorPointString;
- property.Get( anchorPointString );
+ property.Get(anchorPointString);
Vector3 anchor;
- if( GetAnchorPointConstant( anchorPointString, anchor ) )
+ if(GetAnchorPointConstant(anchorPointString, anchor))
{
- actor.SetAnchorPoint( anchor );
+ actor.SetAnchorPoint(anchor);
}
}
break;
case Dali::Actor::Property::ANCHOR_POINT_X:
{
const Vector3& current = actor.GetCurrentAnchorPoint();
- actor.SetAnchorPoint( Vector3( property.Get< float >(), current.y, current.z ) );
+ actor.SetAnchorPoint(Vector3(property.Get<float>(), current.y, current.z));
break;
}
case Dali::Actor::Property::ANCHOR_POINT_Y:
{
const Vector3& current = actor.GetCurrentAnchorPoint();
- actor.SetAnchorPoint( Vector3( current.x, property.Get< float >(), current.z ) );
+ actor.SetAnchorPoint(Vector3(current.x, property.Get<float>(), current.z));
break;
}
case Dali::Actor::Property::ANCHOR_POINT_Z:
{
const Vector3& current = actor.GetCurrentAnchorPoint();
- actor.SetAnchorPoint( Vector3( current.x, current.y, property.Get< float >() ) );
+ actor.SetAnchorPoint(Vector3(current.x, current.y, property.Get<float>()));
break;
}
case Dali::Actor::Property::SIZE:
{
Property::Type type = property.GetType();
- if( type == Property::VECTOR2 )
+ if(type == Property::VECTOR2)
{
- actor.SetSize( property.Get< Vector2 >() );
+ actor.SetSize(property.Get<Vector2>());
}
- else if ( type == Property::VECTOR3 )
+ else if(type == Property::VECTOR3)
{
- actor.SetSize( property.Get< Vector3 >() );
+ actor.SetSize(property.Get<Vector3>());
}
break;
}
case Dali::Actor::Property::SIZE_WIDTH:
{
- actor.SetWidth( property.Get< float >() );
+ actor.SetWidth(property.Get<float>());
break;
}
case Dali::Actor::Property::SIZE_HEIGHT:
{
- actor.SetHeight( property.Get< float >() );
+ actor.SetHeight(property.Get<float>());
break;
}
case Dali::Actor::Property::SIZE_DEPTH:
{
- actor.SetDepth( property.Get< float >() );
+ actor.SetDepth(property.Get<float>());
break;
}
case Dali::Actor::Property::POSITION:
{
Property::Type type = property.GetType();
- if( type == Property::VECTOR2 )
+ if(type == Property::VECTOR2)
{
- Vector2 position = property.Get< Vector2 >();
- actor.SetPosition( Vector3( position.x, position.y, 0.0f ) );
+ Vector2 position = property.Get<Vector2>();
+ actor.SetPosition(Vector3(position.x, position.y, 0.0f));
}
- else if ( type == Property::VECTOR3 )
+ else if(type == Property::VECTOR3)
{
- actor.SetPosition( property.Get< Vector3 >() );
+ actor.SetPosition(property.Get<Vector3>());
}
break;
}
case Dali::Actor::Property::POSITION_X:
{
- actor.SetX( property.Get< float >() );
+ actor.SetX(property.Get<float>());
break;
}
case Dali::Actor::Property::POSITION_Y:
{
- actor.SetY( property.Get< float >() );
+ actor.SetY(property.Get<float>());
break;
}
case Dali::Actor::Property::POSITION_Z:
{
- actor.SetZ( property.Get< float >() );
+ actor.SetZ(property.Get<float>());
break;
}
case Dali::Actor::Property::ORIENTATION:
{
- actor.SetOrientation( property.Get< Quaternion >() );
+ actor.SetOrientation(property.Get<Quaternion>());
break;
}
case Dali::Actor::Property::SCALE:
{
Property::Type type = property.GetType();
- if( type == Property::FLOAT )
+ if(type == Property::FLOAT)
{
- float scale = property.Get< float >();
- actor.SetScale( scale, scale, scale );
+ float scale = property.Get<float>();
+ actor.SetScale(scale, scale, scale);
}
- else if ( type == Property::VECTOR3 )
+ else if(type == Property::VECTOR3)
{
- actor.SetScale( property.Get< Vector3 >() );
+ actor.SetScale(property.Get<Vector3>());
}
break;
}
case Dali::Actor::Property::SCALE_X:
{
- actor.SetScaleX( property.Get< float >() );
+ actor.SetScaleX(property.Get<float>());
break;
}
case Dali::Actor::Property::SCALE_Y:
{
- actor.SetScaleY( property.Get< float >() );
+ actor.SetScaleY(property.Get<float>());
break;
}
case Dali::Actor::Property::SCALE_Z:
{
- actor.SetScaleZ( property.Get< float >() );
+ actor.SetScaleZ(property.Get<float>());
break;
}
case Dali::Actor::Property::VISIBLE:
{
- actor.SetVisible( property.Get< bool >() );
+ actor.SetVisible(property.Get<bool>());
break;
}
case Dali::Actor::Property::COLOR:
{
Property::Type type = property.GetType();
- if( type == Property::VECTOR3 )
+ if(type == Property::VECTOR3)
{
- Vector3 color = property.Get< Vector3 >();
- actor.SetColor( Vector4( color.r, color.g, color.b, 1.0f ) );
+ Vector3 color = property.Get<Vector3>();
+ actor.SetColor(Vector4(color.r, color.g, color.b, 1.0f));
}
- else if( type == Property::VECTOR4 )
+ else if(type == Property::VECTOR4)
{
- actor.SetColor( property.Get< Vector4 >() );
+ actor.SetColor(property.Get<Vector4>());
}
break;
}
case Dali::Actor::Property::COLOR_RED:
{
- actor.SetColorRed( property.Get< float >() );
+ actor.SetColorRed(property.Get<float>());
break;
}
case Dali::Actor::Property::COLOR_GREEN:
{
- actor.SetColorGreen( property.Get< float >() );
+ actor.SetColorGreen(property.Get<float>());
break;
}
case Dali::Actor::Property::COLOR_BLUE:
{
- actor.SetColorBlue( property.Get< float >() );
+ actor.SetColorBlue(property.Get<float>());
break;
}
case Dali::Actor::Property::OPACITY:
{
float value;
- if( property.Get( value ) )
+ if(property.Get(value))
{
- actor.SetOpacity( value );
+ actor.SetOpacity(value);
}
break;
}
case Dali::Actor::Property::NAME:
{
- actor.SetName( property.Get< std::string >() );
+ actor.SetName(property.Get<std::string>());
break;
}
case Dali::Actor::Property::SENSITIVE:
{
- actor.SetSensitive( property.Get< bool >() );
+ actor.SetSensitive(property.Get<bool>());
break;
}
case Dali::Actor::Property::LEAVE_REQUIRED:
{
- actor.SetLeaveRequired( property.Get< bool >() );
+ actor.SetLeaveRequired(property.Get<bool>());
break;
}
case Dali::Actor::Property::INHERIT_POSITION:
{
- actor.SetInheritPosition( property.Get< bool >() );
+ actor.SetInheritPosition(property.Get<bool>());
break;
}
case Dali::Actor::Property::INHERIT_ORIENTATION:
{
- actor.SetInheritOrientation( property.Get< bool >() );
+ actor.SetInheritOrientation(property.Get<bool>());
break;
}
case Dali::Actor::Property::INHERIT_SCALE:
{
- actor.SetInheritScale( property.Get< bool >() );
+ actor.SetInheritScale(property.Get<bool>());
break;
}
case Dali::Actor::Property::COLOR_MODE:
{
ColorMode mode = actor.mColorMode;
- if ( Scripting::GetEnumerationProperty< ColorMode >( property, COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT, mode ) )
+ if(Scripting::GetEnumerationProperty<ColorMode>(property, COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT, mode))
{
- actor.SetColorMode( mode );
+ actor.SetColorMode(mode);
}
break;
}
case Dali::Actor::Property::DRAW_MODE:
{
DrawMode::Type mode = actor.mDrawMode;
- if( Scripting::GetEnumerationProperty< DrawMode::Type >( property, DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT, mode ) )
+ if(Scripting::GetEnumerationProperty<DrawMode::Type>(property, DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT, mode))
{
- actor.SetDrawMode( mode );
+ actor.SetDrawMode(mode);
}
break;
}
case Dali::Actor::Property::SIZE_MODE_FACTOR:
{
- actor.SetSizeModeFactor( property.Get< Vector3 >() );
+ actor.SetSizeModeFactor(property.Get<Vector3>());
break;
}
case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
{
- ResizePolicy::Type type = actor.GetResizePolicy( Dimension::WIDTH );
- if( Scripting::GetEnumerationProperty< ResizePolicy::Type >( property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )
+ ResizePolicy::Type type = actor.mSizer.GetResizePolicy(Dimension::WIDTH);
+ if(Scripting::GetEnumerationProperty<ResizePolicy::Type>(property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type))
{
- actor.SetResizePolicy( type, Dimension::WIDTH );
+ actor.mSizer.SetResizePolicy(type, Dimension::WIDTH);
}
break;
}
case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
{
- ResizePolicy::Type type = actor.GetResizePolicy( Dimension::HEIGHT );
- if( Scripting::GetEnumerationProperty< ResizePolicy::Type >( property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )
+ ResizePolicy::Type type = actor.mSizer.GetResizePolicy(Dimension::HEIGHT);
+ if(Scripting::GetEnumerationProperty<ResizePolicy::Type>(property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type))
{
- actor.SetResizePolicy( type, Dimension::HEIGHT );
+ actor.mSizer.SetResizePolicy(type, Dimension::HEIGHT);
}
break;
}
case Dali::Actor::Property::SIZE_SCALE_POLICY:
{
- SizeScalePolicy::Type type = actor.GetSizeScalePolicy();
- if( Scripting::GetEnumerationProperty< SizeScalePolicy::Type >( property, SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT, type ) )
+ SizeScalePolicy::Type type = actor.mSizer.GetSizeScalePolicy();
+ if(Scripting::GetEnumerationProperty<SizeScalePolicy::Type>(property, SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT, type))
{
- actor.SetSizeScalePolicy( type );
+ actor.mSizer.SetSizeScalePolicy(type);
}
break;
}
case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
{
- if( property.Get< bool >() )
+ if(property.Get<bool>())
{
- actor.SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::WIDTH );
+ actor.mSizer.SetResizePolicy(ResizePolicy::DIMENSION_DEPENDENCY, Dimension::WIDTH);
}
break;
}
case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
{
- if( property.Get< bool >() )
+ if(property.Get<bool>())
{
- actor.SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::HEIGHT );
+ actor.mSizer.SetResizePolicy(ResizePolicy::DIMENSION_DEPENDENCY, Dimension::HEIGHT);
}
break;
}
case Dali::Actor::Property::PADDING:
{
- Vector4 padding = property.Get< Vector4 >();
- actor.SetPadding( Vector2( padding.x, padding.y ), Dimension::WIDTH );
- actor.SetPadding( Vector2( padding.z, padding.w ), Dimension::HEIGHT );
+ Vector4 padding = property.Get<Vector4>();
+ actor.SetPadding(Vector2(padding.x, padding.y), Dimension::WIDTH);
+ actor.SetPadding(Vector2(padding.z, padding.w), Dimension::HEIGHT);
break;
}
case Dali::Actor::Property::MINIMUM_SIZE:
{
- Vector2 size = property.Get< Vector2 >();
- actor.SetMinimumSize( size.x, Dimension::WIDTH );
- actor.SetMinimumSize( size.y, Dimension::HEIGHT );
+ Vector2 size = property.Get<Vector2>();
+ actor.SetMinimumSize(size.x, Dimension::WIDTH);
+ actor.SetMinimumSize(size.y, Dimension::HEIGHT);
break;
}
case Dali::Actor::Property::MAXIMUM_SIZE:
{
- Vector2 size = property.Get< Vector2 >();
- actor.SetMaximumSize( size.x, Dimension::WIDTH );
- actor.SetMaximumSize( size.y, Dimension::HEIGHT );
+ Vector2 size = property.Get<Vector2>();
+ actor.SetMaximumSize(size.x, Dimension::WIDTH);
+ actor.SetMaximumSize(size.y, Dimension::HEIGHT);
break;
}
{
int value;
- if( property.Get( value ) )
+ if(property.Get(value))
{
- actor.SetSiblingOrder( value );
+ Actor* parent = actor.GetParent();
+ if(parent)
+ {
+ parent->SetSiblingOrderOfChild(actor, value);
+ }
}
break;
}
case Dali::Actor::Property::CLIPPING_MODE:
{
ClippingMode::Type convertedValue = actor.mClippingMode;
- if( Scripting::GetEnumerationProperty< ClippingMode::Type >( property, CLIPPING_MODE_TABLE, CLIPPING_MODE_TABLE_COUNT, convertedValue ) )
+ if(Scripting::GetEnumerationProperty<ClippingMode::Type>(property, CLIPPING_MODE_TABLE, CLIPPING_MODE_TABLE_COUNT, convertedValue))
{
actor.mClippingMode = convertedValue;
- SetClippingModeMessage( actor.GetEventThreadServices(), actor.GetNode(), actor.mClippingMode );
+ SetClippingModeMessage(actor.GetEventThreadServices(), actor.GetNode(), actor.mClippingMode);
}
break;
}
case Dali::Actor::Property::POSITION_USES_ANCHOR_POINT:
{
bool value = false;
- if( property.Get( value ) && value != actor.mPositionUsesAnchorPoint )
+ if(property.Get(value) && value != actor.mPositionUsesAnchorPoint)
{
actor.mPositionUsesAnchorPoint = value;
- SetPositionUsesAnchorPointMessage( actor.GetEventThreadServices(), actor.GetNode(), actor.mPositionUsesAnchorPoint );
+ SetPositionUsesAnchorPointMessage(actor.GetEventThreadServices(), actor.GetNode(), actor.mPositionUsesAnchorPoint);
}
break;
}
case Dali::Actor::Property::LAYOUT_DIRECTION:
{
Dali::LayoutDirection::Type direction = actor.mLayoutDirection;
- actor.mInheritLayoutDirection = false;
+ actor.mInheritLayoutDirection = false;
- if( Scripting::GetEnumerationProperty< LayoutDirection::Type >( property, LAYOUT_DIRECTION_TABLE, LAYOUT_DIRECTION_TABLE_COUNT, direction ) )
+ if(Scripting::GetEnumerationProperty<LayoutDirection::Type>(property, LAYOUT_DIRECTION_TABLE, LAYOUT_DIRECTION_TABLE_COUNT, direction))
{
- actor.InheritLayoutDirectionRecursively( &actor, direction, true );
+ actor.mParentImpl.InheritLayoutDirectionRecursively(direction, true);
}
break;
}
case Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION:
{
bool value = false;
- if( property.Get( value ) )
+ if(property.Get(value))
{
- actor.SetInheritLayoutDirection( value );
+ actor.SetInheritLayoutDirection(value);
}
break;
}
case Dali::Actor::Property::KEYBOARD_FOCUSABLE:
{
bool value = false;
- if( property.Get( value ) )
+ if(property.Get(value))
{
- actor.SetKeyboardFocusable( value );
+ actor.SetKeyboardFocusable(value);
}
break;
}
case Dali::DevelActor::Property::UPDATE_SIZE_HINT:
{
- actor.SetUpdateSizeHint( property.Get< Vector2 >() );
+ actor.SetUpdateSizeHint(property.Get<Vector2>());
break;
}
case Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START:
{
bool boolValue = false;
- if ( property.Get( boolValue ) )
+ if(property.Get(boolValue))
{
actor.mCaptureAllTouchAfterStart = boolValue;
}
break;
}
+ case Dali::DevelActor::Property::TOUCH_AREA_OFFSET:
+ {
+ Rect<int> rectValue;
+ if(property.Get(rectValue))
+ {
+ actor.SetTouchAreaOffset(rectValue);
+ }
+ break;
+ }
+
+ case Dali::DevelActor::Property::BLEND_EQUATION:
+ {
+ int value;
+ if(property.Get(value))
+ {
+ actor.SetBlendEquation(static_cast<DevelBlendEquation::Type>(value));
+ }
+ break;
+ }
+
+ case Dali::DevelActor::Property::TOUCH_FOCUSABLE:
+ {
+ bool value = false;
+ if(property.Get(value))
+ {
+ actor.SetTouchFocusable(value);
+ }
+ break;
+ }
+
+ case Dali::DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN:
+ {
+ bool value = false;
+ if(property.Get(value))
+ {
+ actor.SetKeyboardFocusableChildren(value);
+ }
+ break;
+ }
+
default:
{
// this can happen in the case of a non-animatable default property so just do nothing
}
void Actor::PropertyHandler::SetSceneGraphProperty(
- Property::Index index,
- const PropertyMetadata& entry,
- const Property::Value& value,
- EventThreadServices& eventThreadServices,
- const SceneGraph::Node& node)
+ Property::Index index,
+ const PropertyMetadata& entry,
+ const Property::Value& value,
+ EventThreadServices& eventThreadServices,
+ const SceneGraph::Node& node)
{
- switch( entry.GetType() )
+ switch(entry.GetType())
{
case Property::BOOLEAN:
{
- const AnimatableProperty< bool >* property = dynamic_cast< const AnimatableProperty< bool >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ const AnimatableProperty<bool>* property = dynamic_cast<const AnimatableProperty<bool>*>(entry.GetSceneGraphProperty());
+ DALI_ASSERT_DEBUG(NULL != property);
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<bool>::Send( eventThreadServices, &node, property, &AnimatableProperty<bool>::Bake, value.Get<bool>() );
+ SceneGraph::NodePropertyMessage<bool>::Send(eventThreadServices, &node, property, &AnimatableProperty<bool>::Bake, value.Get<bool>());
break;
}
case Property::INTEGER:
{
- const AnimatableProperty< int >* property = dynamic_cast< const AnimatableProperty< int >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ 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<int>::Send( eventThreadServices, &node, property, &AnimatableProperty<int>::Bake, value.Get<int>() );
+ SceneGraph::NodePropertyMessage<int>::Send(eventThreadServices, &node, property, &AnimatableProperty<int>::Bake, value.Get<int>());
break;
}
case Property::FLOAT:
{
- const AnimatableProperty< float >* property = dynamic_cast< const AnimatableProperty< float >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ 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( eventThreadServices, &node, property, &AnimatableProperty<float>::Bake, value.Get<float>() );
+ SceneGraph::NodePropertyMessage<float>::Send(eventThreadServices, &node, property, &AnimatableProperty<float>::Bake, value.Get<float>());
break;
}
case Property::VECTOR2:
{
- const AnimatableProperty< Vector2 >* property = dynamic_cast< const AnimatableProperty< Vector2 >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ const AnimatableProperty<Vector2>* property = dynamic_cast<const AnimatableProperty<Vector2>*>(entry.GetSceneGraphProperty());
+ DALI_ASSERT_DEBUG(NULL != property);
// property is being used in a separate thread; queue a message to set the property
if(entry.componentIndex == 0)
{
- SceneGraph::NodePropertyComponentMessage<Vector2>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector2>::BakeX, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector2>::Send(eventThreadServices, &node, property, &AnimatableProperty<Vector2>::BakeX, value.Get<float>());
}
else if(entry.componentIndex == 1)
{
- SceneGraph::NodePropertyComponentMessage<Vector2>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector2>::BakeY, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector2>::Send(eventThreadServices, &node, property, &AnimatableProperty<Vector2>::BakeY, value.Get<float>());
}
else
{
- SceneGraph::NodePropertyMessage<Vector2>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
+ SceneGraph::NodePropertyMessage<Vector2>::Send(eventThreadServices, &node, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>());
}
break;
case Property::VECTOR3:
{
- const AnimatableProperty< Vector3 >* property = dynamic_cast< const AnimatableProperty< Vector3 >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ const AnimatableProperty<Vector3>* property = dynamic_cast<const AnimatableProperty<Vector3>*>(entry.GetSceneGraphProperty());
+ DALI_ASSERT_DEBUG(NULL != property);
// property is being used in a separate thread; queue a message to set the property
if(entry.componentIndex == 0)
{
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector3>::BakeX, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send(eventThreadServices, &node, property, &AnimatableProperty<Vector3>::BakeX, value.Get<float>());
}
else if(entry.componentIndex == 1)
{
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector3>::BakeY, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send(eventThreadServices, &node, property, &AnimatableProperty<Vector3>::BakeY, value.Get<float>());
}
else if(entry.componentIndex == 2)
{
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector3>::BakeZ, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send(eventThreadServices, &node, property, &AnimatableProperty<Vector3>::BakeZ, value.Get<float>());
}
else
{
- SceneGraph::NodePropertyMessage<Vector3>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
+ SceneGraph::NodePropertyMessage<Vector3>::Send(eventThreadServices, &node, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>());
}
break;
case Property::VECTOR4:
{
- const AnimatableProperty< Vector4 >* property = dynamic_cast< const AnimatableProperty< Vector4 >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ const AnimatableProperty<Vector4>* property = dynamic_cast<const AnimatableProperty<Vector4>*>(entry.GetSceneGraphProperty());
+ DALI_ASSERT_DEBUG(NULL != property);
// property is being used in a separate thread; queue a message to set the property
if(entry.componentIndex == 0)
{
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector4>::BakeX, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send(eventThreadServices, &node, property, &AnimatableProperty<Vector4>::BakeX, value.Get<float>());
}
else if(entry.componentIndex == 1)
{
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector4>::BakeY, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send(eventThreadServices, &node, property, &AnimatableProperty<Vector4>::BakeY, value.Get<float>());
}
else if(entry.componentIndex == 2)
{
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector4>::BakeZ, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send(eventThreadServices, &node, property, &AnimatableProperty<Vector4>::BakeZ, value.Get<float>());
}
else if(entry.componentIndex == 3)
{
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector4>::BakeW, value.Get<float>() );
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send(eventThreadServices, &node, property, &AnimatableProperty<Vector4>::BakeW, value.Get<float>());
}
else
{
- SceneGraph::NodePropertyMessage<Vector4>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
+ SceneGraph::NodePropertyMessage<Vector4>::Send(eventThreadServices, &node, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>());
}
break;
case Property::ROTATION:
{
- const AnimatableProperty< Quaternion >* property = dynamic_cast< const AnimatableProperty< Quaternion >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ const AnimatableProperty<Quaternion>* property = dynamic_cast<const AnimatableProperty<Quaternion>*>(entry.GetSceneGraphProperty());
+ DALI_ASSERT_DEBUG(NULL != property);
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Quaternion>::Send( eventThreadServices, &node, property,&AnimatableProperty<Quaternion>::Bake, value.Get<Quaternion>() );
+ SceneGraph::NodePropertyMessage<Quaternion>::Send(eventThreadServices, &node, property, &AnimatableProperty<Quaternion>::Bake, value.Get<Quaternion>());
break;
}
case Property::MATRIX:
{
- const AnimatableProperty< Matrix >* property = dynamic_cast< const AnimatableProperty< Matrix >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ const AnimatableProperty<Matrix>* property = dynamic_cast<const AnimatableProperty<Matrix>*>(entry.GetSceneGraphProperty());
+ DALI_ASSERT_DEBUG(NULL != property);
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Matrix>::Send( eventThreadServices, &node, property,&AnimatableProperty<Matrix>::Bake, value.Get<Matrix>() );
+ SceneGraph::NodePropertyMessage<Matrix>::Send(eventThreadServices, &node, property, &AnimatableProperty<Matrix>::Bake, value.Get<Matrix>());
break;
}
case Property::MATRIX3:
{
- const AnimatableProperty< Matrix3 >* property = dynamic_cast< const AnimatableProperty< Matrix3 >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ const AnimatableProperty<Matrix3>* property = dynamic_cast<const AnimatableProperty<Matrix3>*>(entry.GetSceneGraphProperty());
+ DALI_ASSERT_DEBUG(NULL != property);
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Matrix3>::Send( eventThreadServices, &node, property,&AnimatableProperty<Matrix3>::Bake, value.Get<Matrix3>() );
+ SceneGraph::NodePropertyMessage<Matrix3>::Send(eventThreadServices, &node, property, &AnimatableProperty<Matrix3>::Bake, value.Get<Matrix3>());
break;
}
void Actor::PropertyHandler::OnNotifyDefaultPropertyAnimation(Internal::Actor& actor, Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType)
{
- switch( animationType )
+ switch(animationType)
{
case Animation::TO:
case Animation::BETWEEN:
{
- switch( index )
+ switch(index)
{
case Dali::Actor::Property::SIZE:
{
- if( value.Get( actor.mTargetSize ) )
+ Vector3 targetSize;
+ if(value.Get(targetSize))
{
- actor.mAnimatedSize = actor.mTargetSize;
- actor.mUseAnimatedSize = AnimatedSizeFlag::WIDTH | AnimatedSizeFlag::HEIGHT | AnimatedSizeFlag::DEPTH;
-
- // Notify deriving classes
- actor.OnSizeAnimation( animation, actor.mTargetSize );
+ actor.mSizer.OnAnimateSize(animation, targetSize, false);
}
break;
}
case Dali::Actor::Property::SIZE_WIDTH:
{
- if( value.Get( actor.mTargetSize.width ) )
+ float width;
+ if(value.Get(width))
{
- actor.mAnimatedSize.width = actor.mTargetSize.width;
- actor.mUseAnimatedSize |= AnimatedSizeFlag::WIDTH;
-
- // Notify deriving classes
- actor.OnSizeAnimation( animation, actor.mTargetSize );
+ actor.mSizer.OnAnimateWidth(animation, width, false);
}
break;
}
case Dali::Actor::Property::SIZE_HEIGHT:
{
- if( value.Get( actor.mTargetSize.height ) )
+ float height;
+ if(value.Get(height))
{
- actor.mAnimatedSize.height = actor.mTargetSize.height;
- actor.mUseAnimatedSize |= AnimatedSizeFlag::HEIGHT;
-
- // Notify deriving classes
- actor.OnSizeAnimation( animation, actor.mTargetSize );
+ actor.mSizer.OnAnimateHeight(animation, height, false);
}
break;
}
case Dali::Actor::Property::SIZE_DEPTH:
{
- if( value.Get( actor.mTargetSize.depth ) )
+ float depth;
+ if(value.Get(depth))
{
- actor.mAnimatedSize.depth = actor.mTargetSize.depth;
- actor.mUseAnimatedSize |= AnimatedSizeFlag::DEPTH;
-
- // Notify deriving classes
- actor.OnSizeAnimation( animation, actor.mTargetSize );
+ actor.mSizer.OnAnimateDepth(animation, depth, false);
}
break;
}
case Dali::Actor::Property::POSITION:
{
- value.Get( actor.mTargetPosition );
+ value.Get(actor.mTargetPosition);
break;
}
case Dali::Actor::Property::POSITION_X:
{
- value.Get( actor.mTargetPosition.x );
+ value.Get(actor.mTargetPosition.x);
break;
}
case Dali::Actor::Property::POSITION_Y:
{
- value.Get( actor.mTargetPosition.y );
+ value.Get(actor.mTargetPosition.y);
break;
}
case Dali::Actor::Property::POSITION_Z:
{
- value.Get( actor.mTargetPosition.z );
+ value.Get(actor.mTargetPosition.z);
break;
}
case Dali::Actor::Property::ORIENTATION:
{
- value.Get( actor.mTargetOrientation );
+ value.Get(actor.mTargetOrientation);
break;
}
case Dali::Actor::Property::SCALE:
{
- value.Get( actor.mTargetScale );
+ value.Get(actor.mTargetScale);
break;
}
case Dali::Actor::Property::SCALE_X:
{
- value.Get( actor.mTargetScale.x );
+ value.Get(actor.mTargetScale.x);
break;
}
case Dali::Actor::Property::SCALE_Y:
{
- value.Get( actor.mTargetScale.y );
+ value.Get(actor.mTargetScale.y);
break;
}
case Dali::Actor::Property::SCALE_Z:
{
- value.Get( actor.mTargetScale.z );
+ value.Get(actor.mTargetScale.z);
break;
}
case Dali::Actor::Property::VISIBLE:
{
- actor.SetVisibleInternal( value.Get< bool >(), SendMessage::FALSE );
+ actor.SetVisibleInternal(value.Get<bool>(), SendMessage::FALSE);
break;
}
case Dali::Actor::Property::COLOR:
{
- value.Get( actor.mTargetColor );
+ value.Get(actor.mTargetColor);
break;
}
case Dali::Actor::Property::COLOR_RED:
{
- value.Get( actor.mTargetColor.r );
+ value.Get(actor.mTargetColor.r);
break;
}
case Dali::Actor::Property::COLOR_GREEN:
{
- value.Get( actor.mTargetColor.g );
+ value.Get(actor.mTargetColor.g);
break;
}
case Dali::Actor::Property::COLOR_BLUE:
{
- value.Get( actor.mTargetColor.b );
+ value.Get(actor.mTargetColor.b);
break;
}
case Dali::Actor::Property::COLOR_ALPHA:
case Dali::Actor::Property::OPACITY:
{
- value.Get( actor.mTargetColor.a );
+ value.Get(actor.mTargetColor.a);
break;
}
case Animation::BY:
{
- switch( index )
+ switch(index)
{
case Dali::Actor::Property::SIZE:
{
- if( AdjustValue< Vector3 >( actor.mTargetSize, value ) )
+ Vector3 targetSize;
+ if(value.Get(targetSize))
{
- actor.mAnimatedSize = actor.mTargetSize;
- actor.mUseAnimatedSize = AnimatedSizeFlag::WIDTH | AnimatedSizeFlag::HEIGHT | AnimatedSizeFlag::DEPTH;
-
- // Notify deriving classes
- actor.OnSizeAnimation( animation, actor.mTargetSize );
+ actor.mSizer.OnAnimateSize(animation, targetSize, true);
}
break;
}
case Dali::Actor::Property::SIZE_WIDTH:
{
- if( AdjustValue< float >( actor.mTargetSize.width, value ) )
+ float width;
+ if(value.Get(width))
{
- actor.mAnimatedSize.width = actor.mTargetSize.width;
- actor.mUseAnimatedSize |= AnimatedSizeFlag::WIDTH;
-
- // Notify deriving classes
- actor.OnSizeAnimation( animation, actor.mTargetSize );
+ actor.mSizer.OnAnimateWidth(animation, width, true);
}
break;
}
case Dali::Actor::Property::SIZE_HEIGHT:
{
- if( AdjustValue< float >( actor.mTargetSize.height, value ) )
+ float height;
+ if(value.Get(height))
{
- actor.mAnimatedSize.height = actor.mTargetSize.height;
- actor.mUseAnimatedSize |= AnimatedSizeFlag::HEIGHT;
-
- // Notify deriving classes
- actor.OnSizeAnimation( animation, actor.mTargetSize );
+ actor.mSizer.OnAnimateHeight(animation, height, true);
}
break;
}
case Dali::Actor::Property::SIZE_DEPTH:
{
- if( AdjustValue< float >( actor.mTargetSize.depth, value ) )
+ float depth;
+ if(value.Get(depth))
{
- actor.mAnimatedSize.depth = actor.mTargetSize.depth;
- actor.mUseAnimatedSize |= AnimatedSizeFlag::DEPTH;
-
- // Notify deriving classes
- actor.OnSizeAnimation( animation, actor.mTargetSize );
+ actor.mSizer.OnAnimateDepth(animation, depth, true);
}
break;
}
case Dali::Actor::Property::POSITION:
{
- AdjustValue< Vector3 >( actor.mTargetPosition, value );
+ AdjustValue<Vector3>(actor.mTargetPosition, value);
break;
}
case Dali::Actor::Property::POSITION_X:
{
- AdjustValue< float >( actor.mTargetPosition.x, value );
+ AdjustValue<float>(actor.mTargetPosition.x, value);
break;
}
case Dali::Actor::Property::POSITION_Y:
{
- AdjustValue< float >( actor.mTargetPosition.y, value );
+ AdjustValue<float>(actor.mTargetPosition.y, value);
break;
}
case Dali::Actor::Property::POSITION_Z:
{
- AdjustValue< float >( actor.mTargetPosition.z, value );
+ AdjustValue<float>(actor.mTargetPosition.z, value);
break;
}
case Dali::Actor::Property::ORIENTATION:
{
Quaternion relativeValue;
- if( value.Get( relativeValue ) )
+ if(value.Get(relativeValue))
{
actor.mTargetOrientation *= relativeValue;
}
case Dali::Actor::Property::SCALE:
{
- AdjustValue< Vector3 >( actor.mTargetScale, value );
+ AdjustValue<Vector3>(actor.mTargetScale, value);
break;
}
case Dali::Actor::Property::SCALE_X:
{
- AdjustValue< float >( actor.mTargetScale.x, value );
+ AdjustValue<float>(actor.mTargetScale.x, value);
break;
}
case Dali::Actor::Property::SCALE_Y:
{
- AdjustValue< float >( actor.mTargetScale.y, value );
+ AdjustValue<float>(actor.mTargetScale.y, value);
break;
}
case Dali::Actor::Property::SCALE_Z:
{
- AdjustValue< float >( actor.mTargetScale.z, value );
+ AdjustValue<float>(actor.mTargetScale.z, value);
break;
}
case Dali::Actor::Property::VISIBLE:
{
bool relativeValue = false;
- if( value.Get( relativeValue ) )
+ if(value.Get(relativeValue))
{
bool visible = actor.mVisible || relativeValue;
- actor.SetVisibleInternal( visible, SendMessage::FALSE );
+ actor.SetVisibleInternal(visible, SendMessage::FALSE);
}
break;
}
case Dali::Actor::Property::COLOR:
{
- AdjustValue< Vector4 >( actor.mTargetColor, value );
+ AdjustValue<Vector4>(actor.mTargetColor, value);
break;
}
case Dali::Actor::Property::COLOR_RED:
{
- AdjustValue< float >( actor.mTargetColor.r, value );
+ AdjustValue<float>(actor.mTargetColor.r, value);
break;
}
case Dali::Actor::Property::COLOR_GREEN:
{
- AdjustValue< float >( actor.mTargetColor.g, value );
+ AdjustValue<float>(actor.mTargetColor.g, value);
break;
}
case Dali::Actor::Property::COLOR_BLUE:
{
- AdjustValue< float >( actor.mTargetColor.b, value );
+ AdjustValue<float>(actor.mTargetColor.b, value);
break;
}
case Dali::Actor::Property::COLOR_ALPHA:
case Dali::Actor::Property::OPACITY:
{
- AdjustValue< float >( actor.mTargetColor.a, value );
+ AdjustValue<float>(actor.mTargetColor.a, value);
break;
}
const PropertyBase* Actor::PropertyHandler::GetSceneObjectAnimatableProperty(Property::Index index, const SceneGraph::Node& node)
{
- const PropertyBase* property( nullptr );
+ const PropertyBase* property(nullptr);
- switch( index )
+ switch(index)
{
case Dali::Actor::Property::SIZE: // FALLTHROUGH
case Dali::Actor::Property::SIZE_WIDTH: // FALLTHROUGH
const PropertyInputImpl* Actor::PropertyHandler::GetSceneObjectInputProperty(Property::Index index, const SceneGraph::Node& node)
{
- const PropertyInputImpl* property( nullptr );
+ const PropertyInputImpl* property(nullptr);
- switch( index )
+ switch(index)
{
case Dali::Actor::Property::PARENT_ORIGIN: // FALLTHROUGH
case Dali::Actor::Property::PARENT_ORIGIN_X: // FALLTHROUGH
{
int32_t componentIndex = Property::INVALID_COMPONENT_INDEX;
- switch( index )
+ switch(index)
{
case Dali::Actor::Property::PARENT_ORIGIN_X:
case Dali::Actor::Property::ANCHOR_POINT_X:
{
bool valueSet = true;
- switch( index )
+ switch(index)
{
case Dali::Actor::Property::PARENT_ORIGIN:
{
case Dali::Actor::Property::NAME:
{
- value = actor.GetName();
+ value = std::string(actor.GetName());
break;
}
case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
{
- value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( actor.GetResizePolicy( Dimension::WIDTH ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT );
+ value = Scripting::GetLinearEnumerationName<ResizePolicy::Type>(actor.mSizer.GetResizePolicy(Dimension::WIDTH), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT);
break;
}
case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
{
- value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( actor.GetResizePolicy( Dimension::HEIGHT ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT );
+ value = Scripting::GetLinearEnumerationName<ResizePolicy::Type>(actor.mSizer.GetResizePolicy(Dimension::HEIGHT), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT);
break;
}
case Dali::Actor::Property::SIZE_SCALE_POLICY:
{
- value = actor.GetSizeScalePolicy();
+ value = actor.mSizer.GetSizeScalePolicy();
break;
}
case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
{
- value = ( actor.GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( actor.GetDimensionDependency( Dimension::WIDTH ) == Dimension::HEIGHT );
+ value = (actor.mSizer.GetResizePolicy(Dimension::WIDTH) == ResizePolicy::DIMENSION_DEPENDENCY) && (actor.mSizer.GetDimensionDependency(Dimension::WIDTH) == Dimension::HEIGHT);
break;
}
case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
{
- value = ( actor.GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( actor.GetDimensionDependency( Dimension::HEIGHT ) == Dimension::WIDTH );
+ value = (actor.mSizer.GetResizePolicy(Dimension::HEIGHT) == ResizePolicy::DIMENSION_DEPENDENCY) && (actor.mSizer.GetDimensionDependency(Dimension::HEIGHT) == Dimension::WIDTH);
break;
}
case Dali::Actor::Property::PADDING:
{
- Vector2 widthPadding = actor.GetPadding( Dimension::WIDTH );
- Vector2 heightPadding = actor.GetPadding( Dimension::HEIGHT );
- value = Vector4( widthPadding.x, widthPadding.y, heightPadding.x, heightPadding.y );
+ Vector2 widthPadding = actor.GetPadding(Dimension::WIDTH);
+ Vector2 heightPadding = actor.GetPadding(Dimension::HEIGHT);
+ value = Vector4(widthPadding.x, widthPadding.y, heightPadding.x, heightPadding.y);
break;
}
case Dali::Actor::Property::MINIMUM_SIZE:
{
- value = Vector2( actor.GetMinimumSize( Dimension::WIDTH ), actor.GetMinimumSize( Dimension::HEIGHT ) );
+ value = Vector2(actor.GetMinimumSize(Dimension::WIDTH), actor.GetMinimumSize(Dimension::HEIGHT));
break;
}
case Dali::Actor::Property::MAXIMUM_SIZE:
{
- value = Vector2( actor.GetMaximumSize( Dimension::WIDTH ), actor.GetMaximumSize( Dimension::HEIGHT ) );
+ value = Vector2(actor.GetMaximumSize(Dimension::WIDTH), actor.GetMaximumSize(Dimension::HEIGHT));
break;
}
case Dali::DevelActor::Property::SIBLING_ORDER:
{
- value = static_cast<int>( actor.GetSiblingOrder() );
+ Actor* parent = actor.GetParent();
+ if(parent)
+ {
+ value = static_cast<int>(parent->GetSiblingOrderOfChild(actor));
+ }
+ else
+ {
+ value = 0;
+ }
break;
}
case Dali::Actor::Property::ID:
{
- value = static_cast<int>( actor.GetId() );
+ value = static_cast<int>(actor.GetId());
break;
}
break;
}
+ case Dali::DevelActor::Property::TOUCH_AREA_OFFSET:
+ {
+ value = actor.GetTouchAreaOffset();
+ break;
+ }
+
+ case Dali::DevelActor::Property::BLEND_EQUATION:
+ {
+ value = actor.GetBlendEquation();
+ break;
+ }
+
+ case Dali::DevelActor::Property::TOUCH_FOCUSABLE:
+ {
+ value = actor.IsTouchFocusable();
+ break;
+ }
+
+ case Dali::DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN:
+ {
+ value = actor.AreChildrenKeyBoardFocusable();
+ break;
+ }
+
default:
{
// Must be a scene-graph only property
{
bool valueSet = true;
- switch( index )
+ switch(index)
{
case Dali::Actor::Property::SIZE:
{
case Dali::Actor::Property::CULLED:
{
- value = actor.GetNode().IsCulled( actor.GetEventThreadServices().GetEventBufferIndex() );
+ value = actor.GetNode().IsCulled(actor.GetEventThreadServices().GetEventBufferIndex());
break;
}
case Dali::DevelActor::Property::UPDATE_SIZE_HINT:
{
// node is being used in a separate thread, the value from the previous update is the same, set by user
- value = Vector2( actor.GetNode().GetUpdateSizeHint() );
+ value = Vector2(actor.GetNode().GetUpdateSizeHint());
break;
}
projects / platform / core / uifw / dali-core.git / blobdiff