DALI_PROPERTY( "leaveRequired", BOOLEAN, true, false, false, Dali::Actor::Property::LEAVE_REQUIRED )
DALI_PROPERTY( "inheritOrientation", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_ORIENTATION )
DALI_PROPERTY( "inheritScale", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_SCALE )
-DALI_PROPERTY( "colorMode", STRING, true, false, false, Dali::Actor::Property::COLOR_MODE )
-DALI_PROPERTY( "reservedProperty01", STRING, true, false, false, Dali::Actor::Property::RESERVED_PROPERTY_01 ) // This property was removed, but to keep binary compatibility and TypeRegister test app, remain it here.
-DALI_PROPERTY( "drawMode", STRING, true, false, false, Dali::Actor::Property::DRAW_MODE )
+DALI_PROPERTY( "colorMode", INTEGER, true, false, false, Dali::Actor::Property::COLOR_MODE )
+DALI_PROPERTY( "drawMode", INTEGER, true, false, false, Dali::Actor::Property::DRAW_MODE )
DALI_PROPERTY( "sizeModeFactor", VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR )
DALI_PROPERTY( "widthResizePolicy", STRING, true, false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY )
DALI_PROPERTY( "heightResizePolicy", STRING, true, false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY )
-DALI_PROPERTY( "sizeScalePolicy", STRING, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY )
+DALI_PROPERTY( "sizeScalePolicy", INTEGER, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY )
DALI_PROPERTY( "widthForHeight", BOOLEAN, true, false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT )
DALI_PROPERTY( "heightForWidth", BOOLEAN, true, false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH )
DALI_PROPERTY( "padding", VECTOR4, true, false, false, Dali::Actor::Property::PADDING )
DALI_PROPERTY( "clippingMode", STRING, true, false, false, Dali::Actor::Property::CLIPPING_MODE )
DALI_PROPERTY( "layoutDirection", STRING, true, false, false, Dali::Actor::Property::LAYOUT_DIRECTION )
DALI_PROPERTY( "inheritLayoutDirection", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION )
+DALI_PROPERTY( "opacity", FLOAT, true, true, true, Dali::Actor::Property::OPACITY )
+DALI_PROPERTY( "screenPosition", VECTOR2, false, false, false, Dali::Actor::Property::SCREEN_POSITION )
+DALI_PROPERTY( "positionUsesAnchorPoint", BOOLEAN, true, false, false, Dali::Actor::Property::POSITION_USES_ANCHOR_POINT )
+DALI_PROPERTY( "culled", BOOLEAN, false, false, true, Dali::Actor::Property::CULLED )
+DALI_PROPERTY( "id", INTEGER, false, false, false, Dali::Actor::Property::ID )
+DALI_PROPERTY( "hierarchyDepth", INTEGER, false, false, false, Dali::Actor::Property::HIERARCHY_DEPTH )
+DALI_PROPERTY( "isRoot", BOOLEAN, false, false, false, Dali::Actor::Property::IS_ROOT )
+DALI_PROPERTY( "isLayer", BOOLEAN, false, false, false, Dali::Actor::Property::IS_LAYER )
+DALI_PROPERTY( "connectedToScene", BOOLEAN, false, false, false, Dali::Actor::Property::CONNECTED_TO_SCENE )
+DALI_PROPERTY( "keyboardFocusable", BOOLEAN, true, false, false, Dali::Actor::Property::KEYBOARD_FOCUSABLE )
DALI_PROPERTY( "siblingOrder", INTEGER, true, false, false, Dali::DevelActor::Property::SIBLING_ORDER )
-DALI_PROPERTY( "opacity", FLOAT, true, true, true, Dali::DevelActor::Property::OPACITY )
-DALI_PROPERTY( "screenPosition", VECTOR2, false, false, false, Dali::DevelActor::Property::SCREEN_POSITION )
-DALI_PROPERTY( "positionUsesAnchorPoint", BOOLEAN, true, false, false, Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT )
-DALI_PROPERTY( "culled", BOOLEAN, false, false, true, Dali::DevelActor::Property::CULLED )
+DALI_PROPERTY( "updateSizeHint", VECTOR2, true, false, false, Dali::DevelActor::Property::UPDATE_SIZE_HINT )
+DALI_PROPERTY( "captureAllTouchAfterStart", BOOLEAN, true, false, false, Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START )
DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX, ActorDefaultProperties )
// Signals
const char* const SIGNAL_TOUCHED = "touched";
const char* const SIGNAL_HOVERED = "hovered";
const char* const SIGNAL_WHEEL_EVENT = "wheelEvent";
-const char* const SIGNAL_ON_STAGE = "onStage";
-const char* const SIGNAL_OFF_STAGE = "offStage";
+const char* const SIGNAL_ON_SCENE = "onScene";
+const char* const SIGNAL_OFF_SCENE = "offScene";
const char* const SIGNAL_ON_RELAYOUT = "onRelayout";
const char* const SIGNAL_TOUCH = "touch";
const char* const SIGNAL_VISIBILITY_CHANGED = "visibilityChanged";
SignalConnectorType signalConnector1( mType, SIGNAL_TOUCHED, &Actor::DoConnectSignal );
SignalConnectorType signalConnector2( mType, SIGNAL_HOVERED, &Actor::DoConnectSignal );
SignalConnectorType signalConnector3( mType, SIGNAL_WHEEL_EVENT, &Actor::DoConnectSignal );
-SignalConnectorType signalConnector4( mType, SIGNAL_ON_STAGE, &Actor::DoConnectSignal );
-SignalConnectorType signalConnector5( mType, SIGNAL_OFF_STAGE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector4( mType, SIGNAL_ON_SCENE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector5( mType, SIGNAL_OFF_SCENE, &Actor::DoConnectSignal );
SignalConnectorType signalConnector6( mType, SIGNAL_ON_RELAYOUT, &Actor::DoConnectSignal );
SignalConnectorType signalConnector7( mType, SIGNAL_TOUCH, &Actor::DoConnectSignal );
SignalConnectorType signalConnector8( mType, SIGNAL_VISIBILITY_CHANGED, &Actor::DoConnectSignal );
SceneGraph::Node* node = SceneGraph::Node::New();
OwnerPointer< SceneGraph::Node > transferOwnership( node );
Internal::ThreadLocalStorage* tls = Internal::ThreadLocalStorage::GetInternal();
+
+ DALI_ASSERT_ALWAYS( tls && "ThreadLocalStorage is null" );
+
AddNodeMessage( tls->GetUpdateManager(), transferOwnership );
return node;
return GetNode().GetId();
}
-bool Actor::OnStage() const
+bool Actor::OnScene() const
{
- return mIsOnStage;
+ return mIsOnScene;
}
Dali::Layer Actor::GetLayer()
const Vector2 Actor::GetCurrentScreenPosition() const
{
- if( mScene && OnStage() )
+ if( mScene && OnScene() )
{
Vector3 worldPosition = GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
Vector3 cameraPosition = mScene->GetDefaultCameraActor().GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, width );
}
+ mUseAnimatedSize &= ~AnimatedSizeFlag::WIDTH;
+
RelayoutRequest();
}
SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, height );
}
+ mUseAnimatedSize &= ~AnimatedSizeFlag::HEIGHT;
+
RelayoutRequest();
}
{
mTargetSize.depth = depth;
+ mUseAnimatedSize &= ~AnimatedSizeFlag::DEPTH;
+
// node is being used in a separate thread; queue a message to set the value & base value
SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, depth );
}
{
Vector3 size = mTargetSize;
- // Should return preferred size if size is fixed as set by SetSize
- if( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::FIXED )
+ if( mUseAnimatedSize & AnimatedSizeFlag::WIDTH )
{
- size.width = GetPreferredSize().width;
+ // Should return animated size if size is animated
+ size.width = mAnimatedSize.width;
}
- if( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::FIXED )
+ else
{
- size.height = GetPreferredSize().height;
+ // Should return preferred size if size is fixed as set by SetSize
+ if( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::FIXED )
+ {
+ size.width = GetPreferredSize().width;
+ }
+ }
+
+ if( mUseAnimatedSize & AnimatedSizeFlag::HEIGHT )
+ {
+ size.height = mAnimatedSize.height;
+ }
+ else
+ {
+ if( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::FIXED )
+ {
+ size.height = GetPreferredSize().height;
+ }
+ }
+
+ if( mUseAnimatedSize & AnimatedSizeFlag::DEPTH )
+ {
+ size.depth = mAnimatedSize.depth;
}
return size;
bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const
{
// only valid when on-stage
- if( mScene && OnStage() )
+ if( mScene && OnScene() )
{
const RenderTaskList& taskList = mScene->GetRenderTaskList();
{
bool retval = false;
// only valid when on-stage
- if( OnStage() )
+ if( OnScene() )
{
CameraActor* camera = renderTask.GetCameraActor();
if( camera )
bool Actor::ScreenToLocal( const Matrix& viewMatrix, const Matrix& projectionMatrix, const Viewport& viewport, float& localX, float& localY, float screenX, float screenY ) const
{
// Early-out if not on stage
- if( !OnStage() )
+ if( !OnScene() )
{
return false;
}
*/
// Early-out if not on stage
- if( !OnStage() )
+ if( !OnScene() )
{
return false;
}
{
bool hit = false;
- if( OnStage() )
+ if( OnScene() )
{
// Transforms the ray to the local reference system.
// Calculate the inverse of Model matrix
return consumed;
}
-bool Actor::EmitHoverEventSignal( const HoverEvent& event )
+bool Actor::EmitHoverEventSignal( const Dali::HoverEvent& event )
{
bool consumed = false;
return mWheelEventSignal;
}
-Dali::Actor::OnStageSignalType& Actor::OnStageSignal()
+Dali::Actor::OnSceneSignalType& Actor::OnSceneSignal()
{
- return mOnStageSignal;
+ return mOnSceneSignal;
}
-Dali::Actor::OffStageSignalType& Actor::OffStageSignal()
+Dali::Actor::OffSceneSignalType& Actor::OffSceneSignal()
{
- return mOffStageSignal;
+ return mOffSceneSignal;
}
Dali::Actor::OnRelayoutSignalType& Actor::OnRelayoutSignal()
{
actor->WheelEventSignal().Connect( tracker, functor );
}
- else if( 0 == signalName.compare( SIGNAL_ON_STAGE ) )
+ else if( 0 == signalName.compare( SIGNAL_ON_SCENE ) )
{
- actor->OnStageSignal().Connect( tracker, functor );
+ actor->OnSceneSignal().Connect( tracker, functor );
}
- else if( 0 == signalName.compare( SIGNAL_OFF_STAGE ) )
+ else if( 0 == signalName.compare( SIGNAL_OFF_SCENE ) )
{
- actor->OffStageSignal().Connect( tracker, functor );
+ actor->OffSceneSignal().Connect( tracker, functor );
}
else if( 0 == signalName.compare( SIGNAL_ON_RELAYOUT ) )
{
mTouchSignal(),
mHoveredSignal(),
mWheelEventSignal(),
- mOnStageSignal(),
- mOffStageSignal(),
+ mOnSceneSignal(),
+ mOffSceneSignal(),
mOnRelayoutSignal(),
mVisibilityChangedSignal(),
mLayoutDirectionChangedSignal(),
mTargetSize( Vector3::ZERO ),
mTargetPosition( Vector3::ZERO ),
mTargetScale( Vector3::ONE ),
+ mAnimatedSize( Vector3::ZERO ),
mName(),
mSortedDepth( 0u ),
mDepth( 0u ),
+ mUseAnimatedSize( AnimatedSizeFlag::CLEAR ),
mIsRoot( ROOT_LAYER == derivedType ),
mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ),
- mIsOnStage( false ),
+ mIsOnScene( false ),
mSensitive( true ),
mLeaveRequired( false ),
mKeyboardFocusable( false ),
mDerivedRequiresTouch( false ),
mDerivedRequiresHover( false ),
mDerivedRequiresWheelEvent( false ),
- mOnStageSignalled( false ),
+ mOnSceneSignalled( false ),
mInsideOnSizeSet( false ),
mInheritPosition( true ),
mInheritOrientation( true ),
mPositionUsesAnchorPoint( true ),
mVisible( true ),
mInheritLayoutDirection( true ),
+ mCaptureAllTouchAfterStart( false ),
mLayoutDirection( LayoutDirection::LEFT_TO_RIGHT ),
mDrawMode( DrawMode::NORMAL ),
mColorMode( Node::DEFAULT_COLOR_MODE ),
delete mRelayoutData;
}
-void Actor::ConnectToStage( uint32_t parentDepth )
+void Actor::ConnectToScene( uint32_t parentDepth )
{
// This container is used instead of walking the Actor hierarchy.
- // It protects us when the Actor hierarchy is modified during OnStageConnectionExternal callbacks.
+ // It protects us when the Actor hierarchy is modified during OnSceneConnectionExternal callbacks.
ActorContainer connectionList;
if( mScene )
}
// This stage is atomic i.e. not interrupted by user callbacks.
- RecursiveConnectToStage( connectionList, parentDepth + 1 );
+ RecursiveConnectToScene( connectionList, parentDepth + 1 );
// Notify applications about the newly connected actors.
const ActorIter endIter = connectionList.end();
RelayoutRequest();
}
-void Actor::RecursiveConnectToStage( ActorContainer& connectionList, uint32_t depth )
+void Actor::RecursiveConnectToScene( ActorContainer& connectionList, uint32_t depth )
{
- DALI_ASSERT_ALWAYS( !OnStage() );
+ DALI_ASSERT_ALWAYS( !OnScene() );
- mIsOnStage = true;
+ mIsOnScene = true;
mDepth = static_cast< uint16_t >( depth ); // overflow ignored, not expected in practice
ConnectToSceneGraph();
// Notification for internal derived classes
- OnStageConnectionInternal();
+ OnSceneConnectionInternal();
// This stage is atomic; avoid emitting callbacks until all Actors are connected
connectionList.push_back( ActorPtr( this ) );
for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
{
(*iter)->SetScene( *mScene );
- (*iter)->RecursiveConnectToStage( connectionList, depth + 1 );
+ (*iter)->RecursiveConnectToScene( connectionList, depth + 1 );
}
}
}
* This method is called when the Actor is connected to the Stage.
* The parent must have added its Node to the scene-graph.
* The child must connect its Node to the parent's Node.
- * This is recursive; the child calls ConnectToStage() for its children.
+ * This is recursive; the child calls ConnectToScene() for its children.
*/
void Actor::ConnectToSceneGraph()
{
void Actor::NotifyStageConnection()
{
// Actors can be removed (in a callback), before the on-stage stage is reported.
- // The actor may also have been reparented, in which case mOnStageSignalled will be true.
- if( OnStage() && !mOnStageSignalled )
+ // The actor may also have been reparented, in which case mOnSceneSignalled will be true.
+ if( OnScene() && !mOnSceneSignalled )
{
// Notification for external (CustomActor) derived classes
- OnStageConnectionExternal( mDepth );
+ OnSceneConnectionExternal( mDepth );
- if( !mOnStageSignal.Empty() )
+ if( !mOnSceneSignal.Empty() )
{
Dali::Actor handle( this );
- mOnStageSignal.Emit( handle );
+ mOnSceneSignal.Emit( handle );
}
// Guard against Remove during callbacks
- if( OnStage() )
+ if( OnScene() )
{
- mOnStageSignalled = true; // signal required next time Actor is removed
+ mOnSceneSignalled = true; // signal required next time Actor is removed
}
}
}
void Actor::DisconnectFromStage()
{
// This container is used instead of walking the Actor hierachy.
- // It protects us when the Actor hierachy is modified during OnStageDisconnectionExternal callbacks.
+ // It protects us when the Actor hierachy is modified during OnSceneDisconnectionExternal callbacks.
ActorContainer disconnectionList;
if( mScene )
void Actor::RecursiveDisconnectFromStage( ActorContainer& disconnectionList )
{
- // need to change state first so that internals relying on IsOnStage() inside OnStageDisconnectionInternal() get the correct value
- mIsOnStage = false;
+ // need to change state first so that internals relying on IsOnScene() inside OnSceneDisconnectionInternal() get the correct value
+ mIsOnScene = false;
// Recursively disconnect children
if( mChildren )
disconnectionList.push_back( ActorPtr( this ) );
// Notification for internal derived classes
- OnStageDisconnectionInternal();
+ OnSceneDisconnectionInternal();
DisconnectFromSceneGraph();
}
void Actor::NotifyStageDisconnection()
{
// Actors can be added (in a callback), before the off-stage state is reported.
- // Also if the actor was added & removed before mOnStageSignalled was set, then we don't notify here.
+ // Also if the actor was added & removed before mOnSceneSignalled was set, then we don't notify here.
// only do this step if there is a stage, i.e. Core is not being shut down
- if ( EventThreadServices::IsCoreRunning() && !OnStage() && mOnStageSignalled )
+ if ( EventThreadServices::IsCoreRunning() && !OnScene() && mOnSceneSignalled )
{
// Notification for external (CustomeActor) derived classes
- OnStageDisconnectionExternal();
+ OnSceneDisconnectionExternal();
- if( !mOffStageSignal.Empty() )
+ if( !mOffSceneSignal.Empty() )
{
Dali::Actor handle( this );
- mOffStageSignal.Emit( handle );
+ mOffSceneSignal.Emit( handle );
}
// Guard against Add during callbacks
- if( !OnStage() )
+ if( !OnScene() )
{
- mOnStageSignalled = false; // signal required next time Actor is added
+ mOnSceneSignalled = false; // signal required next time Actor is added
}
}
}
{
bool connected( false );
- if( OnStage() )
+ if( OnScene() )
{
if( IsRoot() || GetNode().GetParent() )
{
case Dali::Actor::Property::SIZE:
{
- SetSize( property.Get< Vector3 >() );
+ Property::Type type = property.GetType();
+ if( type == Property::VECTOR2 )
+ {
+ SetSize( property.Get< Vector2 >() );
+ }
+ else if ( type == Property::VECTOR3 )
+ {
+ SetSize( property.Get< Vector3 >() );
+ }
break;
}
case Dali::Actor::Property::POSITION:
{
- SetPosition( property.Get< Vector3 >() );
+ Property::Type type = property.GetType();
+ if( type == Property::VECTOR2 )
+ {
+ Vector2 position = property.Get< Vector2 >();
+ SetPosition( Vector3( position.x, position.y, 0.0f ) );
+ }
+ else if ( type == Property::VECTOR3 )
+ {
+ SetPosition( property.Get< Vector3 >() );
+ }
break;
}
case Dali::Actor::Property::SCALE:
{
- SetScale( property.Get< Vector3 >() );
+ Property::Type type = property.GetType();
+ if( type == Property::FLOAT )
+ {
+ float scale = property.Get< float >();
+ SetScale( scale, scale, scale );
+ }
+ else if ( type == Property::VECTOR3 )
+ {
+ SetScale( property.Get< Vector3 >() );
+ }
break;
}
case Dali::Actor::Property::COLOR:
{
- SetColor( property.Get< Vector4 >() );
+ Property::Type type = property.GetType();
+ if( type == Property::VECTOR3 )
+ {
+ Vector3 color = property.Get< Vector3 >();
+ SetColor( Vector4( color.r, color.g, color.b, 1.0f ) );
+ }
+ else if( type == Property::VECTOR4 )
+ {
+ SetColor( property.Get< Vector4 >() );
+ }
break;
}
}
case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::DevelActor::Property::OPACITY:
+ case Dali::Actor::Property::OPACITY:
{
float value;
if( property.Get( value ) )
case Dali::Actor::Property::SIZE_SCALE_POLICY:
{
SizeScalePolicy::Type type = GetSizeScalePolicy();
- if( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT, type ) )
+ if( Scripting::GetEnumerationProperty< SizeScalePolicy::Type >( property, SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT, type ) )
{
SetSizeScalePolicy( type );
}
break;
}
- case Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT:
+ case Dali::Actor::Property::POSITION_USES_ANCHOR_POINT:
{
bool value = false;
if( property.Get( value ) && value != mPositionUsesAnchorPoint )
break;
}
+ case Dali::Actor::Property::KEYBOARD_FOCUSABLE:
+ {
+ bool value = false;
+ if( property.Get( value ) )
+ {
+ SetKeyboardFocusable( value );
+ }
+ break;
+ }
+
+ case Dali::DevelActor::Property::UPDATE_SIZE_HINT:
+ {
+ SetUpdateSizeHint( property.Get< Vector2 >() );
+ break;
+ }
+
+ case Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START:
+ {
+ bool boolValue = false;
+ if ( property.Get( boolValue ) )
+ {
+ mCaptureAllTouchAfterStart = boolValue;
+ }
+ break;
+ }
+
default:
{
// this can happen in the case of a non-animatable default property so just do nothing
{
if( value.Get( mTargetSize ) )
{
+ mAnimatedSize = mTargetSize;
+ mUseAnimatedSize = AnimatedSizeFlag::WIDTH | AnimatedSizeFlag::HEIGHT | AnimatedSizeFlag::DEPTH;
+
// Notify deriving classes
OnSizeAnimation( animation, mTargetSize );
}
{
if( value.Get( mTargetSize.width ) )
{
+ mAnimatedSize.width = mTargetSize.width;
+ mUseAnimatedSize |= AnimatedSizeFlag::WIDTH;
+
// Notify deriving classes
OnSizeAnimation( animation, mTargetSize );
}
{
if( value.Get( mTargetSize.height ) )
{
+ mAnimatedSize.height = mTargetSize.height;
+ mUseAnimatedSize |= AnimatedSizeFlag::HEIGHT;
+
// Notify deriving classes
OnSizeAnimation( animation, mTargetSize );
}
{
if( value.Get( mTargetSize.depth ) )
{
+ mAnimatedSize.depth = mTargetSize.depth;
+ mUseAnimatedSize |= AnimatedSizeFlag::DEPTH;
+
// Notify deriving classes
OnSizeAnimation( animation, mTargetSize );
}
}
case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::DevelActor::Property::OPACITY:
+ case Dali::Actor::Property::OPACITY:
{
value.Get( mTargetColor.a );
break;
{
if( AdjustValue< Vector3 >( mTargetSize, value ) )
{
+ mAnimatedSize = mTargetSize;
+ mUseAnimatedSize = AnimatedSizeFlag::WIDTH | AnimatedSizeFlag::HEIGHT | AnimatedSizeFlag::DEPTH;
+
// Notify deriving classes
OnSizeAnimation( animation, mTargetSize );
}
{
if( AdjustValue< float >( mTargetSize.width, value ) )
{
+ mAnimatedSize.width = mTargetSize.width;
+ mUseAnimatedSize |= AnimatedSizeFlag::WIDTH;
+
// Notify deriving classes
OnSizeAnimation( animation, mTargetSize );
}
{
if( AdjustValue< float >( mTargetSize.height, value ) )
{
+ mAnimatedSize.height = mTargetSize.height;
+ mUseAnimatedSize |= AnimatedSizeFlag::HEIGHT;
+
// Notify deriving classes
OnSizeAnimation( animation, mTargetSize );
}
{
if( AdjustValue< float >( mTargetSize.depth, value ) )
{
+ mAnimatedSize.depth = mTargetSize.depth;
+ mUseAnimatedSize |= AnimatedSizeFlag::DEPTH;
+
// Notify deriving classes
OnSizeAnimation( animation, mTargetSize );
}
}
case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::DevelActor::Property::OPACITY:
+ case Dali::Actor::Property::OPACITY:
{
AdjustValue< float >( mTargetColor.a, value );
break;
case Dali::Actor::Property::COLOR_GREEN: // FALLTHROUGH
case Dali::Actor::Property::COLOR_BLUE: // FALLTHROUGH
case Dali::Actor::Property::COLOR_ALPHA: // FALLTHROUGH
- case Dali::DevelActor::Property::OPACITY:
+ case Dali::Actor::Property::OPACITY:
{
property = &GetNode().mColor;
break;
property = &GetNode().mWorldMatrix;
break;
}
- case Dali::DevelActor::Property::CULLED:
+ case Dali::Actor::Property::CULLED:
{
property = &GetNode().mCulled;
break;
}
case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::DevelActor::Property::OPACITY:
+ case Dali::Actor::Property::OPACITY:
{
componentIndex = 3;
break;
mScene = parent->mScene;
if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
- parent->OnStage() )
+ parent->OnScene() )
{
// Instruct each actor to create a corresponding node in the scene graph
- ConnectToStage( parent->GetHierarchyDepth() );
+ ConnectToScene( parent->GetHierarchyDepth() );
}
// Resolve the name and index for the child properties if any
mParent = NULL;
if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
- OnStage() )
+ OnScene() )
{
// Disconnect the Node & its children from the scene-graph.
DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), GetNode() );
}
case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::DevelActor::Property::OPACITY:
+ case Dali::Actor::Property::OPACITY:
{
value = mTargetColor.a;
break;
case Dali::Actor::Property::COLOR_MODE:
{
- value = Scripting::GetLinearEnumerationName< ColorMode >( GetColorMode(), COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT );
+ value = GetColorMode();
break;
}
case Dali::Actor::Property::DRAW_MODE:
{
- value = Scripting::GetEnumerationName< DrawMode::Type >( GetDrawMode(), DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT );
+ value = GetDrawMode();
break;
}
case Dali::Actor::Property::SIZE_SCALE_POLICY:
{
- value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT );
+ value = GetSizeScalePolicy();
break;
}
break;
}
- case Dali::DevelActor::Property::SCREEN_POSITION:
+ case Dali::Actor::Property::SCREEN_POSITION:
{
value = GetCurrentScreenPosition();
break;
}
- case Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT:
+ case Dali::Actor::Property::POSITION_USES_ANCHOR_POINT:
{
value = mPositionUsesAnchorPoint;
break;
break;
}
+ case Dali::Actor::Property::ID:
+ {
+ value = static_cast<int>( GetId() );
+ break;
+ }
+
+ case Dali::Actor::Property::HIERARCHY_DEPTH:
+ {
+ value = GetHierarchyDepth();
+ break;
+ }
+
+ case Dali::Actor::Property::IS_ROOT:
+ {
+ value = IsRoot();
+ break;
+ }
+
+ case Dali::Actor::Property::IS_LAYER:
+ {
+ value = IsLayer();
+ break;
+ }
+
+ case Dali::Actor::Property::CONNECTED_TO_SCENE:
+ {
+ value = OnScene();
+ break;
+ }
+
+ case Dali::Actor::Property::KEYBOARD_FOCUSABLE:
+ {
+ value = IsKeyboardFocusable();
+ break;
+ }
+
+ case Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START:
+ {
+ value = mCaptureAllTouchAfterStart;
+ break;
+ }
+
default:
{
// Must be a scene-graph only property
}
case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::DevelActor::Property::OPACITY:
+ case Dali::Actor::Property::OPACITY:
{
value = GetCurrentColor().a;
break;
break;
}
- case DevelActor::Property::CULLED:
+ case Dali::Actor::Property::CULLED:
{
value = GetNode().IsCulled( GetEventThreadServices().GetEventBufferIndex() );
break;
}
+ case Dali::DevelActor::Property::UPDATE_SIZE_HINT:
+ {
+ value = GetUpdateSizeHint();
+ break;
+ }
+
default:
{
// Must be an event-side only property
case ResizePolicy::SIZE_RELATIVE_TO_PARENT:
{
- return GetLatestSize( dimension ) * GetDimensionValue( child.GetSizeModeFactor(), dimension );
+ return GetLatestSize( dimension ) * GetDimensionValue( child.GetProperty< Vector3 >( Dali::Actor::Property::SIZE_MODE_FACTOR ), dimension );
}
case ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT:
{
- return GetLatestSize( dimension ) + GetDimensionValue( child.GetSizeModeFactor(), dimension );
+ return GetLatestSize( dimension ) + GetDimensionValue( child.GetProperty< Vector3 >( Dali::Actor::Property::SIZE_MODE_FACTOR ), dimension );
}
default:
// A 0 width or height may also be required so if the resize policy has not been changed, i.e. is still set to DEFAULT,
// then change to FIXED as well
- if( size.width > 0.0f || GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::DEFAULT )
+ if( size.width > 0.0f )
{
SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
}
- if( size.height > 0.0f || GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::DEFAULT )
+ if( size.height > 0.0f )
{
SetResizePolicy( ResizePolicy::FIXED, Dimension::HEIGHT );
}
mRelayoutData->preferredSize = size;
+ mUseAnimatedSize = AnimatedSizeFlag::CLEAR;
+
RelayoutRequest();
}
void Actor::RequestRebuildDepthTree()
{
- if( mIsOnStage )
+ if( mIsOnScene )
{
if( mScene )
{
}
}
+void Actor::SetUpdateSizeHint( const Vector2& updateSizeHint )
+{
+ // node is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mUpdateSizeHint, &AnimatableProperty<Vector3>::Bake, Vector3(updateSizeHint.width, updateSizeHint.height, 0.f ) );
+}
+
+Vector2 Actor::GetUpdateSizeHint() const
+{
+ // node is being used in a separate thread, the value from the previous update is the same, set by user
+ Vector3 updateSizeHint = GetNode().GetUpdateSizeHint();
+ return Vector2( updateSizeHint.width, updateSizeHint.height );
+}
+
} // namespace Internal
} // namespace Dali
projects / platform / core / uifw / dali-core.git / blobdiff