/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/common/constants.h>
+#include <dali/public-api/events/touch-data.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/radian.h>
#include <dali/public-api/object/type-registry.h>
+
#include <dali/devel-api/scripting/scripting.h>
#include <dali/internal/common/internal-constants.h>
#include <dali/internal/event/common/property-helper.h>
#include <dali/internal/event/common/stage-impl.h>
#include <dali/internal/event/common/type-info-impl.h>
-#include <dali/internal/event/actor-attachments/actor-attachment-impl.h>
#include <dali/internal/event/animation/constraint-impl.h>
#include <dali/internal/event/common/projection.h>
#include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
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
{
const char* const SIGNAL_ON_STAGE = "onStage";
const char* const SIGNAL_OFF_STAGE = "offStage";
const char* const SIGNAL_ON_RELAYOUT = "onRelayout";
+const char* const SIGNAL_TOUCH = "touch";
// Actions
SignalConnectorType signalConnector4( mType, SIGNAL_ON_STAGE, &Actor::DoConnectSignal );
SignalConnectorType signalConnector5( mType, SIGNAL_OFF_STAGE, &Actor::DoConnectSignal );
SignalConnectorType signalConnector6( mType, SIGNAL_ON_RELAYOUT, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector7( mType, SIGNAL_TOUCH, &Actor::DoConnectSignal );
TypeAction a1( mType, ACTION_SHOW, &Actor::DoAction );
TypeAction a2( mType, ACTION_HIDE, &Actor::DoAction );
+struct AnchorValue
+{
+ 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( POSITION_INHERITANCE_MODE )
+DALI_ENUM_TO_STRING( INHERIT_PARENT_POSITION )
+DALI_ENUM_TO_STRING( USE_PARENT_POSITION )
+DALI_ENUM_TO_STRING( USE_PARENT_POSITION_PLUS_LOCAL_POSITION )
+DALI_ENUM_TO_STRING( DONT_INHERIT_POSITION )
+DALI_ENUM_TO_STRING_TABLE_END( POSITION_INHERITANCE_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_WITH_SCOPE( DrawMode, STENCIL )
+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 )
+
+bool GetAnchorPointConstant( const std::string& value, Vector3& anchor )
+{
+ for( unsigned int i = 0; i < ANCHOR_CONSTANT_TABLE_COUNT; ++i )
+ {
+ size_t sizeIgnored = 0;
+ if( CompareTokens( value.c_str(), ANCHOR_CONSTANT_TABLE[ i ].name, sizeIgnored ) )
+ {
+ anchor = ANCHOR_CONSTANT_TABLE[ i ].value;
+ return true;
+ }
+ }
+ return false;
+}
+
+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 );
+}
+
/**
* @brief Extract a given dimension from a Vector2
*
return mId;
}
-void Actor::Attach( ActorAttachment& attachment )
-{
- DALI_ASSERT_DEBUG( !mAttachment && "An Actor can only have one attachment" );
-
- if( OnStage() )
- {
- attachment.Connect();
- }
-
- mAttachment = ActorAttachmentPtr( &attachment );
-}
-
-ActorAttachmentPtr Actor::GetAttachment()
-{
- return mAttachment;
-}
-
bool Actor::OnStage() const
{
return mIsOnStage;
if( removed )
{
- // Notification for derived classes
- OnChildRemove( *(removed.Get()) );
-
// Only put in a relayout request if there is a suitable dependency
if( RelayoutDependentOnChildren() )
{
RelayoutRequest();
}
}
+
+ // Notification for derived classes
+ OnChildRemove( child );
}
void Actor::Unparent()
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value
- SetPositionInheritanceModeMessage( GetEventThreadServices(), *mNode, mode );
+ SetInheritPositionMessage( GetEventThreadServices(), *mNode, mode == INHERIT_PARENT_POSITION );
}
}
bool Actor::GetTouchRequired() const
{
- return !mTouchedSignal.Empty() || mDerivedRequiresTouch;
+ return !mTouchedSignal.Empty() || !mTouchSignal.Empty() || mDerivedRequiresTouch;
}
bool Actor::GetHoverRequired() const
return mGestureData && mGestureData->IsGestureRequred( type );
}
-bool Actor::EmitTouchEventSignal( const TouchEvent& event )
+bool Actor::EmitTouchEventSignal( const TouchEvent& event, const Dali::TouchData& touch )
{
bool consumed = false;
- if( !mTouchedSignal.Empty() )
+ if( !mTouchSignal.Empty() )
{
Dali::Actor handle( this );
- consumed = mTouchedSignal.Emit( handle, event );
+ consumed = mTouchSignal.Emit( handle, touch );
+ }
+
+ if( !mTouchedSignal.Empty() || !mTouchSignal.Empty() )
+ {
+ Dali::Actor handle( this );
+ consumed |= mTouchedSignal.Emit( handle, event );
}
if( !consumed )
{
// Notification for derived classes
- consumed = OnTouchEvent( event );
+ consumed = OnTouchEvent( event ); // TODO
}
return consumed;
Dali::Actor::TouchSignalType& Actor::TouchedSignal()
{
+ DALI_LOG_WARNING( "Deprecated: Use TouchSignal() instead\n" );
return mTouchedSignal;
}
+Dali::Actor::TouchDataSignalType& Actor::TouchSignal()
+{
+ return mTouchSignal;
+}
+
Dali::Actor::HoverSignalType& Actor::HoveredSignal()
{
return mHoveredSignal;
{
actor->OnRelayoutSignal().Connect( tracker, functor );
}
+ else if( 0 == signalName.compare( SIGNAL_TOUCH ) )
+ {
+ actor->TouchSignal().Connect( tracker, functor );
+ }
else
{
// signalName does not match any signal
mAnchorPoint( NULL ),
mRelayoutData( NULL ),
mGestureData( NULL ),
- mAttachment(),
mTargetSize( 0.0f, 0.0f, 0.0f ),
mName(),
mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode );
}
- // Notify attachment
- if( mAttachment )
- {
- mAttachment->Connect();
- }
-
unsigned int rendererCount( GetRendererCount() );
for( unsigned int i(0); i<rendererCount; ++i )
{
// Notification for Object::Observers
OnSceneObjectRemove();
- // Notify attachment
- if( mAttachment )
- {
- mAttachment->Disconnect();
- }
-
unsigned int rendererCount( GetRendererCount() );
for( unsigned int i(0); i<rendererCount; ++i )
{
{
case Dali::Actor::Property::PARENT_ORIGIN:
{
- SetParentOrigin( property.Get< Vector3 >() );
+ Property::Type type = property.GetType();
+ if( type == Property::VECTOR3 )
+ {
+ SetParentOrigin( property.Get< Vector3 >() );
+ }
+ else if ( type == Property::STRING )
+ {
+ std::string parentOriginString;
+ property.Get( parentOriginString );
+ Vector3 parentOrigin;
+ if( GetParentOriginConstant( parentOriginString, parentOrigin ) )
+ {
+ SetParentOrigin( parentOrigin );
+ }
+ }
break;
}
case Dali::Actor::Property::ANCHOR_POINT:
{
- SetAnchorPoint( property.Get< Vector3 >() );
+ Property::Type type = property.GetType();
+ if( type == Property::VECTOR3 )
+ {
+ SetAnchorPoint( property.Get< Vector3 >() );
+ }
+ else if ( type == Property::STRING )
+ {
+ std::string anchorPointString;
+ property.Get( anchorPointString );
+ Vector3 anchor;
+ if( GetAnchorPointConstant( anchorPointString, anchor ) )
+ {
+ SetAnchorPoint( anchor );
+ }
+ }
break;
}
case Dali::Actor::Property::COLOR_MODE:
{
- SetColorMode( Scripting::GetColorMode( property.Get< std::string >() ) );
+ ColorMode mode;
+ if ( Scripting::GetEnumeration< ColorMode >( property.Get< std::string >().c_str(), COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT, mode ) )
+ {
+ SetColorMode( mode );
+ }
break;
}
case Dali::Actor::Property::POSITION_INHERITANCE:
{
- SetPositionInheritanceMode( Scripting::GetPositionInheritanceMode( property.Get< std::string >() ) );
+ PositionInheritanceMode mode;
+ if( Scripting::GetEnumeration< PositionInheritanceMode >( property.Get< std::string >().c_str(), POSITION_INHERITANCE_MODE_TABLE, POSITION_INHERITANCE_MODE_TABLE_COUNT, mode ) )
+ {
+ SetPositionInheritanceMode( mode );
+ }
break;
}
case Dali::Actor::Property::DRAW_MODE:
{
- SetDrawMode( Scripting::GetDrawMode( property.Get< std::string >() ) );
+ DrawMode::Type mode;
+ if( Scripting::GetEnumeration< DrawMode::Type >( property.Get< std::string >().c_str(), DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT, mode ) )
+ {
+ SetDrawMode( mode );
+ }
break;
}
case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
{
ResizePolicy::Type type;
- if( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount, type ) )
+ if( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )
{
SetResizePolicy( type, Dimension::WIDTH );
}
case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
{
ResizePolicy::Type type;
- if( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount, type ) )
+ if( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )
{
SetResizePolicy( type, Dimension::HEIGHT );
}
case Dali::Actor::Property::SIZE_SCALE_POLICY:
{
SizeScalePolicy::Type type;
- if( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount, type ) )
+ if( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT, type ) )
{
SetSizeScalePolicy( type );
}
case Dali::Actor::Property::COLOR_MODE:
{
- value = Scripting::GetColorMode( GetColorMode() );
+ value = Scripting::GetLinearEnumerationName< ColorMode >( GetColorMode(), COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT );
break;
}
case Dali::Actor::Property::POSITION_INHERITANCE:
{
- value = Scripting::GetPositionInheritanceMode( GetPositionInheritanceMode() );
+ value = Scripting::GetLinearEnumerationName< PositionInheritanceMode >( GetPositionInheritanceMode(), POSITION_INHERITANCE_MODE_TABLE, POSITION_INHERITANCE_MODE_TABLE_COUNT );
break;
}
case Dali::Actor::Property::DRAW_MODE:
{
- value = Scripting::GetDrawMode( GetDrawMode() );
+ value = Scripting::GetEnumerationName< DrawMode::Type >( GetDrawMode(), DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT );
break;
}
case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
{
- value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::WIDTH ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount );
+ value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::WIDTH ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT );
break;
}
case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
{
- value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::HEIGHT ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount );
+ value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::HEIGHT ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT );
break;
}
case Dali::Actor::Property::SIZE_SCALE_POLICY:
{
- value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount );
+ value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT );
break;
}
// Instruct each actor to create a corresponding node in the scene graph
ConnectToStage( parent->GetHierarchyDepth() );
}
+
+ // Resolve the name and index for the child properties if any
+ ResolveChildProperties();
}
else // parent being set to NULL
{
void Actor::NegotiateSize( const Vector2& allocatedSize, RelayoutContainer& container )
{
+ // Force a size negotiation for actors that has assigned size during relayout
+ // This is required as otherwise the flags that force a relayout will not
+ // necessarilly be set. This will occur if the actor has already been laid out.
+ // The dirty flags are then cleared. Then if the actor is added back into the
+ // relayout container afterwards, the dirty flags would still be clear...
+ // causing a relayout to be skipped. Here we force any actors added to the
+ // container to be relayed out.
+ if(GetResizePolicy(Dimension::WIDTH) == ResizePolicy::USE_ASSIGNED_SIZE)
+ {
+ SetLayoutNegotiated(false, Dimension::WIDTH);
+ }
+ if(GetResizePolicy(Dimension::HEIGHT) == ResizePolicy::USE_ASSIGNED_SIZE)
+ {
+ SetLayoutNegotiated(false, Dimension::HEIGHT);
+ }
+
// Do the negotiation
NegotiateDimensions( allocatedSize );
{
ActorPtr child = GetChildAt( i );
+ // Forces children that have already been laid out to be relayed out
+ // if they have assigned size during relayout.
+ if(child->GetResizePolicy(Dimension::WIDTH) == ResizePolicy::USE_ASSIGNED_SIZE)
+ {
+ child->SetLayoutNegotiated(false, Dimension::WIDTH);
+ child->SetLayoutDirty(true, Dimension::WIDTH);
+ }
+ if(child->GetResizePolicy(Dimension::HEIGHT) == ResizePolicy::USE_ASSIGNED_SIZE)
+ {
+ child->SetLayoutNegotiated(false, Dimension::HEIGHT);
+ child->SetLayoutDirty(true, Dimension::HEIGHT);
+ }
+
// Only relayout if required
if( child->RelayoutRequired() )
{
return FLT_MAX; // Default
}
+Object* Actor::GetParentObject() const
+{
+ return mParent;
+}
+
} // namespace Internal
} // namespace Dali
projects / platform / core / uifw / dali-core.git / blobdiff