-//
-// Copyright (c) 2014 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Flora License, Version 1.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://floralicense.org/license/
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an AS IS BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
// CLASS HEADER
#include <dali/internal/event/actors/actor-impl.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/public-api/scripting/scripting.h>
#include <dali/internal/common/internal-constants.h>
#include <dali/internal/event/render-tasks/render-task-impl.h>
#include <dali/internal/event/common/property-index-ranges.h>
#include <dali/internal/event/common/stage-impl.h>
#include <dali/internal/event/actor-attachments/actor-attachment-impl.h>
-#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>
-#include <dali/internal/event/dynamics/dynamics-world-impl.h>
#include <dali/internal/event/animation/constraint-impl.h>
#include <dali/internal/event/common/projection.h>
#include <dali/internal/update/common/animatable-property.h>
-#include <dali/internal/update/common/property-owner-messages.h>
#include <dali/internal/update/nodes/node-messages.h>
+#include <dali/internal/update/nodes/node-declarations.h>
#include <dali/internal/update/animation/scene-graph-constraint.h>
-#include <dali/internal/event/effects/shader-effect-impl.h>
+#include <dali/internal/event/events/actor-gesture-data.h>
#include <dali/internal/common/message.h>
#include <dali/integration-api/debug.h>
-// DECLARATION FILES
-#include <dali/internal/update/nodes/node-declarations.h>
+#ifdef 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>
+#include <dali/internal/event/dynamics/dynamics-world-impl.h>
+#endif
using Dali::Internal::SceneGraph::Node;
using Dali::Internal::SceneGraph::AnimatableProperty;
using Dali::Internal::SceneGraph::PropertyBase;
-using Dali::Internal::SceneGraph::Shader;
-
-using namespace std;
namespace Dali
{
-const Property::Index Actor::PARENT_ORIGIN = 0;
-const Property::Index Actor::PARENT_ORIGIN_X = 1;
-const Property::Index Actor::PARENT_ORIGIN_Y = 2;
-const Property::Index Actor::PARENT_ORIGIN_Z = 3;
-const Property::Index Actor::ANCHOR_POINT = 4;
-const Property::Index Actor::ANCHOR_POINT_X = 5;
-const Property::Index Actor::ANCHOR_POINT_Y = 6;
-const Property::Index Actor::ANCHOR_POINT_Z = 7;
-const Property::Index Actor::SIZE = 8;
-const Property::Index Actor::SIZE_WIDTH = 9;
-const Property::Index Actor::SIZE_HEIGHT = 10;
-const Property::Index Actor::SIZE_DEPTH = 11;
-const Property::Index Actor::POSITION = 12;
-const Property::Index Actor::POSITION_X = 13;
-const Property::Index Actor::POSITION_Y = 14;
-const Property::Index Actor::POSITION_Z = 15;
-const Property::Index Actor::WORLD_POSITION = 16;
-const Property::Index Actor::WORLD_POSITION_X = 17;
-const Property::Index Actor::WORLD_POSITION_Y = 18;
-const Property::Index Actor::WORLD_POSITION_Z = 19;
-const Property::Index Actor::ROTATION = 20;
-const Property::Index Actor::WORLD_ROTATION = 21;
-const Property::Index Actor::SCALE = 22;
-const Property::Index Actor::SCALE_X = 23;
-const Property::Index Actor::SCALE_Y = 24;
-const Property::Index Actor::SCALE_Z = 25;
-const Property::Index Actor::WORLD_SCALE = 26;
-const Property::Index Actor::VISIBLE = 27;
-const Property::Index Actor::COLOR = 28;
-const Property::Index Actor::COLOR_RED = 29;
-const Property::Index Actor::COLOR_GREEN = 30;
-const Property::Index Actor::COLOR_BLUE = 31;
-const Property::Index Actor::COLOR_ALPHA = 32;
-const Property::Index Actor::WORLD_COLOR = 33;
-const Property::Index Actor::WORLD_MATRIX = 34;
-const Property::Index Actor::NAME = 35;
+const Property::Index Actor::PARENT_ORIGIN = 0;
+const Property::Index Actor::PARENT_ORIGIN_X = 1;
+const Property::Index Actor::PARENT_ORIGIN_Y = 2;
+const Property::Index Actor::PARENT_ORIGIN_Z = 3;
+const Property::Index Actor::ANCHOR_POINT = 4;
+const Property::Index Actor::ANCHOR_POINT_X = 5;
+const Property::Index Actor::ANCHOR_POINT_Y = 6;
+const Property::Index Actor::ANCHOR_POINT_Z = 7;
+const Property::Index Actor::SIZE = 8;
+const Property::Index Actor::SIZE_WIDTH = 9;
+const Property::Index Actor::SIZE_HEIGHT = 10;
+const Property::Index Actor::SIZE_DEPTH = 11;
+const Property::Index Actor::POSITION = 12;
+const Property::Index Actor::POSITION_X = 13;
+const Property::Index Actor::POSITION_Y = 14;
+const Property::Index Actor::POSITION_Z = 15;
+const Property::Index Actor::WORLD_POSITION = 16;
+const Property::Index Actor::WORLD_POSITION_X = 17;
+const Property::Index Actor::WORLD_POSITION_Y = 18;
+const Property::Index Actor::WORLD_POSITION_Z = 19;
+const Property::Index Actor::ROTATION = 20;
+const Property::Index Actor::WORLD_ROTATION = 21;
+const Property::Index Actor::SCALE = 22;
+const Property::Index Actor::SCALE_X = 23;
+const Property::Index Actor::SCALE_Y = 24;
+const Property::Index Actor::SCALE_Z = 25;
+const Property::Index Actor::WORLD_SCALE = 26;
+const Property::Index Actor::VISIBLE = 27;
+const Property::Index Actor::COLOR = 28;
+const Property::Index Actor::COLOR_RED = 29;
+const Property::Index Actor::COLOR_GREEN = 30;
+const Property::Index Actor::COLOR_BLUE = 31;
+const Property::Index Actor::COLOR_ALPHA = 32;
+const Property::Index Actor::WORLD_COLOR = 33;
+const Property::Index Actor::WORLD_MATRIX = 34;
+const Property::Index Actor::NAME = 35;
+const Property::Index Actor::SENSITIVE = 36;
+const Property::Index Actor::LEAVE_REQUIRED = 37;
+const Property::Index Actor::INHERIT_ROTATION = 38;
+const Property::Index Actor::INHERIT_SCALE = 39;
+const Property::Index Actor::COLOR_MODE = 40;
+const Property::Index Actor::POSITION_INHERITANCE = 41;
+const Property::Index Actor::DRAW_MODE = 42;
namespace // unnamed namespace
{
-/// An empty string returned for invalid property name lookups
-const std::string INVALID_PROPERTY_NAME;
-
/**
* We want to discourage the use of property strings (minimize string comparisons),
* particularly for the default properties.
*/
-const std::string DEFAULT_PROPERTY_NAMES[] =
-{
- "parent-origin",
- "parent-origin-x",
- "parent-origin-y",
- "parent-origin-z",
- "anchor-point",
- "anchor-point-x",
- "anchor-point-y",
- "anchor-point-z",
- "size",
- "size-width",
- "size-height",
- "size-depth",
- "position",
- "position-x",
- "position-y",
- "position-z",
- "world-position",
- "world-position-x",
- "world-position-y",
- "world-position-z",
- "rotation",
- "world-rotation",
- "scale",
- "world-scale",
- "scale-x",
- "scale-y",
- "scale-z",
- "visible",
- "color",
- "color-red",
- "color-green",
- "color-blue",
- "color-alpha",
- "world-color",
- "world-matrix",
- "name"
-};
-const int DEFAULT_PROPERTY_COUNT = sizeof( DEFAULT_PROPERTY_NAMES ) / sizeof( std::string );
-
-const Property::Type DEFAULT_PROPERTY_TYPES[DEFAULT_PROPERTY_COUNT] =
-{
- Property::VECTOR3, // PARENT_ORIGIN
- Property::FLOAT, // PARENT_ORIGIN_X
- Property::FLOAT, // PARENT_ORIGIN_Y
- Property::FLOAT, // PARENT_ORIGIN_Z
- Property::VECTOR3, // ANCHOR_POINT
- Property::FLOAT, // ANCHOR_POINT_X
- Property::FLOAT, // ANCHOR_POINT_Y
- Property::FLOAT, // ANCHOR_POINT_Z
- Property::VECTOR3, // SIZE
- Property::FLOAT, // SIZE_WIDTH
- Property::FLOAT, // SIZE_HEIGHT
- Property::FLOAT, // SIZE_DEPTH
- Property::VECTOR3, // POSITION
- Property::FLOAT, // POSITION_X
- Property::FLOAT, // POSITION_Y
- Property::FLOAT, // POSITION_Z
- Property::VECTOR3, // WORLD_POSITION
- Property::FLOAT, // WORLD_POSITION_X
- Property::FLOAT, // WORLD_POSITION_Y
- Property::FLOAT, // WORLD_POSITION_Z
- Property::ROTATION, // ROTATION
- Property::ROTATION, // WORLD_ROTATION
- Property::VECTOR3, // SCALE
- Property::FLOAT, // SCALE_X
- Property::FLOAT, // SCALE_Y
- Property::FLOAT, // SCALE_Z
- Property::VECTOR3, // WORLD_SCALE
- Property::BOOLEAN, // VISIBLE
- Property::VECTOR4, // COLOR
- Property::FLOAT, // COLOR_RED
- Property::FLOAT, // COLOR_GREEN
- Property::FLOAT, // COLOR_BLUE
- Property::FLOAT, // COLOR_ALPHA
- Property::VECTOR4, // WORLD_COLOR
- Property::MATRIX, // WORLD_MATRIX
- Property::STRING, // NAME
+const Internal::PropertyDetails DEFAULT_PROPERTY_DETAILS[] =
+{
+ // Name Type writable animatable constraint-input
+ { "parent-origin", Property::VECTOR3, true, false, true }, // PARENT_ORIGIN
+ { "parent-origin-x", Property::FLOAT, true, false, true }, // PARENT_ORIGIN_X
+ { "parent-origin-y", Property::FLOAT, true, false, true }, // PARENT_ORIGIN_Y
+ { "parent-origin-z", Property::FLOAT, true, false, true }, // PARENT_ORIGIN_Z
+ { "anchor-point", Property::VECTOR3, true, false, true }, // ANCHOR_POINT
+ { "anchor-point-x", Property::FLOAT, true, false, true }, // ANCHOR_POINT_X
+ { "anchor-point-y", Property::FLOAT, true, false, true }, // ANCHOR_POINT_Y
+ { "anchor-point-z", Property::FLOAT, true, false, true }, // ANCHOR_POINT_Z
+ { "size", Property::VECTOR3, true, true, true }, // SIZE
+ { "size-width", Property::FLOAT, true, true, true }, // SIZE_WIDTH
+ { "size-height", Property::FLOAT, true, true, true }, // SIZE_HEIGHT
+ { "size-depth", Property::FLOAT, true, true, true }, // SIZE_DEPTH
+ { "position", Property::VECTOR3, true, true, true }, // POSITION
+ { "position-x", Property::FLOAT, true, true, true }, // POSITION_X
+ { "position-y", Property::FLOAT, true, true, true }, // POSITION_Y
+ { "position-z", Property::FLOAT, true, true, true }, // POSITION_Z
+ { "world-position", Property::VECTOR3, false, false, true }, // WORLD_POSITION
+ { "world-position-x", Property::FLOAT, false, false, true }, // WORLD_POSITION_X
+ { "world-position-y", Property::FLOAT, false, false, true }, // WORLD_POSITION_Y
+ { "world-position-z", Property::FLOAT, false, false, true }, // WORLD_POSITION_Z
+ { "rotation", Property::ROTATION, true, true, true }, // ROTATION
+ { "world-rotation", Property::ROTATION, false, false, true }, // WORLD_ROTATION
+ { "scale", Property::VECTOR3, true, true, true }, // SCALE
+ { "scale-x", Property::FLOAT, true, true, true }, // SCALE_X
+ { "scale-y", Property::FLOAT, true, true, true }, // SCALE_Y
+ { "scale-z", Property::FLOAT, true, true, true }, // SCALE_Z
+ { "world-scale", Property::VECTOR3, false, false, true }, // WORLD_SCALE
+ { "visible", Property::BOOLEAN, true, true, true }, // VISIBLE
+ { "color", Property::VECTOR4, true, true, true }, // COLOR
+ { "color-red", Property::FLOAT, true, true, true }, // COLOR_RED
+ { "color-green", Property::FLOAT, true, true, true }, // COLOR_GREEN
+ { "color-blue", Property::FLOAT, true, true, true }, // COLOR_BLUE
+ { "color-alpha", Property::FLOAT, true, true, true }, // COLOR_ALPHA
+ { "world-color", Property::VECTOR4, false, false, true }, // WORLD_COLOR
+ { "world-matrix", Property::MATRIX, false, false, true }, // WORLD_MATRIX
+ { "name", Property::STRING, true, false, false }, // NAME
+ { "sensitive", Property::BOOLEAN, true, false, false }, // SENSITIVE
+ { "leave-required", Property::BOOLEAN, true, false, false }, // LEAVE_REQUIRED
+ { "inherit-rotation", Property::BOOLEAN, true, false, false }, // INHERIT_ROTATION
+ { "inherit-scale", Property::BOOLEAN, true, false, false }, // INHERIT_SCALE
+ { "color-mode", Property::STRING, true, false, false }, // COLOR_MODE
+ { "position-inheritance", Property::STRING, true, false, false }, // POSITION_INHERITANCE
+ { "draw-mode", Property::STRING, true, false, false }, // DRAW_MODE
};
+const int DEFAULT_PROPERTY_COUNT = sizeof( DEFAULT_PROPERTY_DETAILS ) / sizeof( Internal::PropertyDetails );
} // unnamed namespace
unsigned int Actor::mActorCounter = 0;
ActorContainer Actor::mNullChildren;
+#ifdef DYNAMICS_SUPPORT
+
// Encapsulate actor related dynamics data
struct DynamicsData
{
SlotDelegate< Actor > slotDelegate;
};
+#endif // DYNAMICS_SUPPORT
+
namespace
{
TypeRegistration mType( typeid(Dali::Actor), typeid(Dali::Handle), CreateActor );
SignalConnectorType signalConnector1(mType, Dali::Actor::SIGNAL_TOUCHED, &Actor::DoConnectSignal);
-SignalConnectorType signalConnector2(mType, Dali::Actor::SIGNAL_SET_SIZE, &Actor::DoConnectSignal);
-SignalConnectorType signalConnector3(mType, Dali::Actor::SIGNAL_ON_STAGE, &Actor::DoConnectSignal);
-SignalConnectorType signalConnector4(mType, Dali::Actor::SIGNAL_OFF_STAGE, &Actor::DoConnectSignal);
+SignalConnectorType signalConnector2(mType, Dali::Actor::SIGNAL_HOVERED, &Actor::DoConnectSignal);
+SignalConnectorType signalConnector3(mType, Dali::Actor::SIGNAL_SET_SIZE, &Actor::DoConnectSignal);
+SignalConnectorType signalConnector4(mType, Dali::Actor::SIGNAL_ON_STAGE, &Actor::DoConnectSignal);
+SignalConnectorType signalConnector5(mType, Dali::Actor::SIGNAL_OFF_STAGE, &Actor::DoConnectSignal);
TypeAction a1(mType, Dali::Actor::ACTION_SHOW, &Actor::DoAction);
TypeAction a2(mType, Dali::Actor::ACTION_HIDE, &Actor::DoAction);
}
-Actor::DefaultPropertyLookup* Actor::mDefaultPropertyLookup = NULL;
-
ActorPtr Actor::New()
{
ActorPtr actor( new Actor( BASIC ) );
}
}
+void Actor::Insert(unsigned int index, Actor& child)
+{
+ DALI_ASSERT_ALWAYS( this != &child && "Cannot add actor to itself" );
+ DALI_ASSERT_ALWAYS( !child.IsRoot() && "Cannot add root actor" );
+
+ if( !mChildren )
+ {
+ mChildren = new ActorContainer;
+ }
+
+ Actor* const oldParent( child.mParent );
+
+ // since an explicit position has been given, always insert, even if already a child
+ if( oldParent )
+ {
+ oldParent->Remove( child ); // This causes OnChildRemove callback
+ }
+
+ // Guard against Add() during previous OnChildRemove callback
+ if ( !child.mParent )
+ {
+ // Do this first, since user callbacks from within SetParent() may need to remove child
+ if (index < GetChildCount())
+ {
+ ActorIter it = mChildren->begin();
+ std::advance(it, index);
+ mChildren->insert(it, Dali::Actor(&child));
+ }
+ else
+ {
+ mChildren->push_back(Dali::Actor(&child));
+ }
+ // SetParent asserts that child can be added
+ child.SetParent(this, index);
+
+ // Notification for derived classes
+ OnChildAdd(child);
+ }
+}
+
void Actor::Remove(Actor& child)
{
DALI_ASSERT_ALWAYS( this != &child && "Cannot remove actor from itself" );
void Actor::SetSize(const Vector2& size)
{
- Vector3 volume( size );
- volume.z = std::min( size.width, size.height );
- SetSize( volume );
+ SetSize( Vector3( size.width, size.height, CalculateSizeZ( size ) ) );
+}
+
+float Actor::CalculateSizeZ( const Vector2& size ) const
+{
+ return std::min( size.width, size.height );
}
void Actor::SetSize(const Vector3& size)
{
if( NULL != mNode )
{
+ mSize = size;
+
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::Bake, size );
+ SceneGraph::NodePropertyMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::Bake, mSize );
// Notification for derived classes
- OnSizeSet(size);
+ OnSizeSet( mSize );
// Emit signal for application developer
if( !mSetSizeSignalV2.Empty() )
{
Dali::Actor handle( this );
- mSetSizeSignalV2.Emit( handle, size );
+ mSetSizeSignalV2.Emit( handle, mSize );
}
}
}
+void Actor::NotifySizeAnimation(Animation& animation, const Vector3& targetSize)
+{
+ mSize = targetSize;
+
+ // Notify deriving classes
+ OnSizeAnimation( animation, targetSize );
+}
+
void Actor::SetWidth( float width )
{
if( NULL != mNode )
}
}
-const Vector3& Actor::GetCurrentSize() const
+const Vector3& Actor::GetSize() const
{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetSize( mStage->GetEventBufferIndex() );
- }
-
- return Vector3::ZERO;
+ return mSize;
}
-void Actor::SetInheritShaderEffect(bool inherit)
-{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value
- SetInheritShaderMessage( mStage->GetUpdateInterface(), *mNode, inherit );
- }
-}
-
-bool Actor::GetInheritShaderEffect() const
+const Vector3& Actor::GetCurrentSize() const
{
if( NULL != mNode )
{
// mNode is being used in a separate thread; copy the value from the previous update
- return mNode->GetInheritShader();
+ return mNode->GetSize( mStage->GetEventBufferIndex() );
}
- return true;
-}
-
-void Actor::SetShaderEffect(ShaderEffect& effect)
-{
- if ( OnStage() )
- {
- if (mShaderEffect)
- {
- mShaderEffect->Disconnect();
- }
-
- mShaderEffect = ShaderEffectPtr(&effect);
-
- const Shader& shader = dynamic_cast<const Shader&>( *mShaderEffect->GetSceneObject() );
-
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to apply shader
- ApplyShaderMessage( mStage->GetUpdateInterface(), *mNode, shader );
- }
-
- mShaderEffect->Connect();
- }
- else
- {
- mShaderEffect = ShaderEffectPtr(&effect);
- }
- // Effects can only be applied when the Node is connected to scene-graph
+ return Vector3::ZERO;
}
-ShaderEffectPtr Actor::GetShaderEffect() const
+Vector3 Actor::GetNaturalSize() const
{
- return mShaderEffect;
+ // It is up to deriving classes to return the appropriate natural size
+ return Vector3( 0.0f, 0.0f, 0.0f );
}
-void Actor::RemoveShaderEffect()
-{
- if ( OnStage() )
- {
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to remove shader
- RemoveShaderMessage( mStage->GetUpdateInterface(), *mNode );
- }
-
- // Notify shader effect
- if (mShaderEffect)
- {
- mShaderEffect->Disconnect();
- }
- }
- mShaderEffect.Reset();
-}
+#ifdef DYNAMICS_SUPPORT
//--------------- Dynamics ---------------
}
}
+#endif // DYNAMICS_SUPPORT
+
void Actor::SetOverlay(bool enable)
{
// Setting STENCIL will override OVERLAY
return !mTouchedSignalV2.Empty() || mDerivedRequiresTouch;
}
+bool Actor::GetHoverRequired() const
+{
+ return !mHoveredSignalV2.Empty() || mDerivedRequiresHover;
+}
+
bool Actor::GetMouseWheelEventRequired() const
{
return !mMouseWheelEventSignalV2.Empty() || mDerivedRequiresMouseWheelEvent;
IsNodeConnected();
}
+ActorGestureData& Actor::GetGestureData()
+{
+ // Likely scenario is that once gesture-data is created for this actor, the actor will require
+ // that gesture for its entire life-time so no need to destroy it until the actor is destroyed
+ if ( NULL == mGestureData )
+ {
+ mGestureData = new ActorGestureData;
+ }
+ return *mGestureData;
+}
+
+bool Actor::IsGestureRequred( Gesture::Type type ) const
+{
+ return mGestureData && mGestureData->IsGestureRequred( type );
+}
+
bool Actor::EmitTouchEventSignal(const TouchEvent& event)
{
bool consumed = false;
return consumed;
}
+bool Actor::EmitHoverEventSignal(const HoverEvent& event)
+{
+ bool consumed = false;
+
+ if ( !mHoveredSignalV2.Empty() )
+ {
+ Dali::Actor handle( this );
+ consumed = mHoveredSignalV2.Emit( handle, event );
+ }
+
+ if (!consumed)
+ {
+ // Notification for derived classes
+ consumed = OnHoverEvent( event );
+ }
+
+ return consumed;
+}
+
bool Actor::EmitMouseWheelEventSignal(const MouseWheelEvent& event)
{
bool consumed = false;
return mTouchedSignalV2;
}
+Dali::Actor::HoverSignalV2& Actor::HoveredSignal()
+{
+ return mHoveredSignalV2;
+}
+
Dali::Actor::MouseWheelEventSignalV2& Actor::MouseWheelEventSignal()
{
return mMouseWheelEventSignalV2;
{
actor->TouchedSignal().Connect( tracker, functor );
}
+ else if(Dali::Actor::SIGNAL_HOVERED == signalName)
+ {
+ actor->HoveredSignal().Connect( tracker, functor );
+ }
else if(Dali::Actor::SIGNAL_MOUSE_WHEEL_EVENT == signalName)
{
actor->MouseWheelEventSignal().Connect( tracker, functor );
}
Actor::Actor( DerivedType derivedType )
-: mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
- mStage( NULL ),
+: mStage( NULL ),
+ mParent( NULL ),
+ mChildren( NULL ),
+ mNode( NULL ),
+ mParentOrigin( NULL ),
+ mAnchorPoint( NULL ),
+#ifdef DYNAMICS_SUPPORT
+ mDynamicsData( NULL ),
+#endif
+ mGestureData( NULL ),
+ mAttachment(),
+ mSize( 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 ),
mLeaveRequired( false ),
mKeyboardFocusable( false ),
mDerivedRequiresTouch( false ),
+ mDerivedRequiresHover( false ),
mDerivedRequiresMouseWheelEvent( false ),
mOnStageSignalled( false ),
mInheritRotation( true ),
mInheritScale( true ),
mDrawMode( DrawMode::NORMAL ),
mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ),
- mColorMode( Node::DEFAULT_COLOR_MODE ),
- mParent( NULL ),
- mChildren( NULL ),
- mNode( NULL ),
- mParentOrigin( NULL ),
- mAnchorPoint( NULL ),
- mDynamicsData( NULL )
+ mColorMode( Node::DEFAULT_COLOR_MODE )
{
}
AddNodeMessage( mStage->GetUpdateManager(), *node ); // Pass ownership to scene-graph
mNode = node; // Keep raw-pointer to Node
- if(!mDefaultPropertyLookup)
- {
- mDefaultPropertyLookup = new DefaultPropertyLookup();
-
- for (int i=0; i<DEFAULT_PROPERTY_COUNT; ++i)
- {
- (*mDefaultPropertyLookup)[DEFAULT_PROPERTY_NAMES[i]] = i;
- }
- }
-
OnInitialize();
RegisterObject();
UnregisterObject();
}
+#ifdef DYNAMICS_SUPPORT
// Cleanup dynamics
delete mDynamicsData;
+#endif
+
+ // Cleanup optional gesture data
+ delete mGestureData;
+
// Cleanup optional parent origin and anchor
delete mParentOrigin;
delete mAnchorPoint;
}
-void Actor::ConnectToStage( Stage& stage )
+void Actor::ConnectToStage( Stage& stage, 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( stage, connectionList );
+ RecursiveConnectToStage( stage, connectionList, index );
// Notify applications about the newly connected actors.
const ActorIter endIter = connectionList.end();
}
}
-void Actor::RecursiveConnectToStage( Stage& stage, ActorContainer& connectionList )
+void Actor::RecursiveConnectToStage( Stage& stage, ActorContainer& connectionList, int index )
{
DALI_ASSERT_ALWAYS( !OnStage() );
mIsOnStage = true;
- ConnectToSceneGraph();
+ ConnectToSceneGraph(index);
// Notification for internal derived classes
OnStageConnectionInternal();
* The child must connect its Node to the parent's Node.
* This is resursive; the child calls ConnectToStage() for its children.
*/
-void Actor::ConnectToSceneGraph()
+void Actor::ConnectToSceneGraph(int index)
{
DALI_ASSERT_DEBUG( mNode != NULL);
DALI_ASSERT_DEBUG( mParent != NULL);
if( NULL != mNode )
{
// Reparent Node in next Update
- ConnectNodeMessage( mStage->GetUpdateManager(), *(mParent->mNode), *mNode );
- }
-
- if (mShaderEffect)
- {
- const Shader& shader = dynamic_cast<const Shader&>( *mShaderEffect->GetSceneObject() );
-
- if( NULL != mNode )
- {
- // Effects can only be applied when the node is on-stage
- ApplyShaderMessage( mStage->GetUpdateInterface(), *mNode, shader );
- }
-
- // Notify shader effect
- mShaderEffect->Connect();
+ ConnectNodeMessage( mStage->GetUpdateManager(), *(mParent->mNode), *mNode, index );
}
// Notify attachment
mAttachment->Connect();
}
+#ifdef DYNAMICS_SUPPORT
// Notify dynamics
if( NULL != mDynamicsData )
{
ConnectDynamics();
}
+#endif
// Notification for ProxyObject::Observers
OnSceneObjectAdd();
// Notification for ProxyObject::Observers
OnSceneObjectRemove();
- // Notify shader effect
- if (mShaderEffect)
- {
- mShaderEffect->Disconnect();
- }
-
// Notify attachment
if (mAttachment)
{
mAttachment->Disconnect();
}
+#ifdef DYNAMICS_SUPPORT
// Notify dynamics
if( NULL != mDynamicsData )
{
DisconnectDynamics();
}
+#endif
}
void Actor::NotifyStageDisconnection()
return connected;
}
-bool Actor::IsSceneObjectRemovable() const
+unsigned int Actor::GetDefaultPropertyCount() const
{
- return false;
+ return DEFAULT_PROPERTY_COUNT;
}
-unsigned int Actor::GetDefaultPropertyCount() const
+void Actor::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
{
- return DEFAULT_PROPERTY_COUNT;
+ indices.reserve( DEFAULT_PROPERTY_COUNT );
+
+ for ( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
+ {
+ indices.push_back( i );
+ }
}
-const std::string& Actor::GetDefaultPropertyName( Property::Index index ) const
+const char* Actor::GetDefaultPropertyName( Property::Index index ) const
{
- if( static_cast< unsigned int >( index ) < GetDefaultPropertyCount() )
+ if( index < DEFAULT_PROPERTY_COUNT )
{
- return DEFAULT_PROPERTY_NAMES[index];
+ return DEFAULT_PROPERTY_DETAILS[index].name;
}
else
{
- // index out of range..return empty string
- return INVALID_PROPERTY_NAME;
+ return NULL;
}
}
{
Property::Index index = Property::INVALID_INDEX;
- DALI_ASSERT_DEBUG( NULL != mDefaultPropertyLookup );
-
// Look for name in default properties
- DefaultPropertyLookup::const_iterator result = mDefaultPropertyLookup->find( name );
- if ( mDefaultPropertyLookup->end() != result )
+ for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
{
- index = result->second;
+ const Internal::PropertyDetails* property = &DEFAULT_PROPERTY_DETAILS[ i ];
+ if( 0 == strcmp( name.c_str(), property->name ) ) // dont want to convert rhs to string
+ {
+ index = i;
+ break;
+ }
}
return index;
bool Actor::IsDefaultPropertyWritable(Property::Index index) const
{
- // World-properties are not writable
- return ( Dali::Actor::WORLD_POSITION != index &&
- Dali::Actor::WORLD_POSITION_X != index &&
- Dali::Actor::WORLD_POSITION_Y != index &&
- Dali::Actor::WORLD_POSITION_Z != index &&
- Dali::Actor::WORLD_ROTATION != index &&
- Dali::Actor::WORLD_SCALE != index &&
- Dali::Actor::WORLD_COLOR != index &&
- Dali::Actor::WORLD_MATRIX != index);
+ if( index < DEFAULT_PROPERTY_COUNT )
+ {
+ return DEFAULT_PROPERTY_DETAILS[index].writable;
+ }
+ else
+ {
+ return false;
+ }
}
bool Actor::IsDefaultPropertyAnimatable(Property::Index index) const
{
- // ParentOrigin, AnchorPoint & World-properties are not animatable
- return ( Dali::Actor::PARENT_ORIGIN != index &&
- Dali::Actor::PARENT_ORIGIN_X != index &&
- Dali::Actor::PARENT_ORIGIN_Y != index &&
- Dali::Actor::PARENT_ORIGIN_Z != index &&
- Dali::Actor::ANCHOR_POINT != index &&
- Dali::Actor::ANCHOR_POINT_X != index &&
- Dali::Actor::ANCHOR_POINT_Y != index &&
- Dali::Actor::ANCHOR_POINT_Z != index &&
- Dali::Actor::WORLD_POSITION != index &&
- Dali::Actor::WORLD_POSITION_X != index &&
- Dali::Actor::WORLD_POSITION_Y != index &&
- Dali::Actor::WORLD_POSITION_Z != index &&
- Dali::Actor::WORLD_ROTATION != index &&
- Dali::Actor::WORLD_SCALE != index &&
- Dali::Actor::WORLD_COLOR != index &&
- Dali::Actor::WORLD_MATRIX != index);
+ if( index < DEFAULT_PROPERTY_COUNT )
+ {
+ return DEFAULT_PROPERTY_DETAILS[index].animatable;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+bool Actor::IsDefaultPropertyAConstraintInput( Property::Index index ) const
+{
+ if( index < DEFAULT_PROPERTY_COUNT )
+ {
+ return DEFAULT_PROPERTY_DETAILS[index].constraintInput;
+ }
+ else
+ {
+ return false;
+ }
}
Property::Type Actor::GetDefaultPropertyType(Property::Index index) const
{
- if( static_cast< unsigned int >( index ) < GetDefaultPropertyCount() )
+ if( index < DEFAULT_PROPERTY_COUNT )
{
- return DEFAULT_PROPERTY_TYPES[index];
+ return DEFAULT_PROPERTY_DETAILS[index].type;
}
else
{
void Actor::SetDefaultProperty( Property::Index index, const Property::Value& property )
{
- // ProxyObject guarantees the property is writable and index is in range
switch ( index )
{
case Dali::Actor::PARENT_ORIGIN:
break;
}
+ case Dali::Actor::SENSITIVE:
+ {
+ SetSensitive( property.Get<bool>() );
+ break;
+ }
+
+ case Dali::Actor::LEAVE_REQUIRED:
+ {
+ SetLeaveRequired( property.Get<bool>() );
+ break;
+ }
+
+ case Dali::Actor::INHERIT_ROTATION:
+ {
+ SetInheritRotation( property.Get<bool>() );
+ break;
+ }
+
+ case Dali::Actor::INHERIT_SCALE:
+ {
+ SetInheritScale( property.Get<bool>() );
+ break;
+ }
+
+ case Dali::Actor::COLOR_MODE:
+ {
+ SetColorMode( Scripting::GetColorMode( property.Get<std::string>() ) );
+ break;
+ }
+
+ case Dali::Actor::POSITION_INHERITANCE:
+ {
+ SetPositionInheritanceMode( Scripting::GetPositionInheritanceMode( property.Get<std::string>() ) );
+ break;
+ }
+
+ case Dali::Actor::DRAW_MODE:
+ {
+ SetDrawMode( Scripting::GetDrawMode( property.Get<std::string>() ) );
+ break;
+ }
+
default:
{
- DALI_ASSERT_ALWAYS(false && "Actor::Property is out of bounds"); // should not come here
+ // this can happen in the case of a non-animatable default property so just do nothing
break;
}
}
}
-void Actor::SetCustomProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value )
+// TODO: This method needs to be removed
+void Actor::SetSceneGraphProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value )
{
- // ProxyObject guarantees the index is in range
-
OnPropertySet(index, value);
- if(entry.IsAnimatable())
+ switch ( entry.type )
{
- // TODO: ADD MATRIX & MATRIX3 types
+ case Property::BOOLEAN:
+ {
+ const AnimatableProperty<bool>* property = dynamic_cast< const AnimatableProperty<bool>* >( entry.GetSceneGraphProperty() );
+ DALI_ASSERT_DEBUG( NULL != property );
- switch ( entry.type )
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<bool>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<bool>::Bake, value.Get<bool>() );
+
+ break;
+ }
+
+ case Property::FLOAT:
{
- case Property::BOOLEAN:
- {
- AnimatableProperty<bool>* property = dynamic_cast< AnimatableProperty<bool>* >( 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<bool>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<bool>::Bake, value.Get<bool>() );
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<float>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<float>::Bake, value.Get<float>() );
- break;
- }
+ break;
+ }
- case Property::FLOAT:
- {
- AnimatableProperty<float>* property = dynamic_cast< AnimatableProperty<float>* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ case Property::INTEGER:
+ {
+ 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( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<float>::Bake, value.Get<float>() );
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<int>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<int>::Bake, value.Get<int>() );
- break;
- }
+ break;
+ }
- case Property::VECTOR2:
- {
- AnimatableProperty<Vector2>* property = dynamic_cast< AnimatableProperty<Vector2>* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ case Property::VECTOR2:
+ {
+ 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
- SceneGraph::NodePropertyMessage<Vector2>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<Vector2>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
- break;
- }
+ break;
+ }
- case Property::VECTOR3:
- {
- AnimatableProperty<Vector3>* property = dynamic_cast< AnimatableProperty<Vector3>* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ case Property::VECTOR3:
+ {
+ 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
- SceneGraph::NodePropertyMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
- break;
- }
+ break;
+ }
- case Property::VECTOR4:
- {
- AnimatableProperty<Vector4>* property = dynamic_cast< AnimatableProperty<Vector4>* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ case Property::VECTOR4:
+ {
+ 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
- SceneGraph::NodePropertyMessage<Vector4>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<Vector4>::Send( mStage->GetUpdateManager(), mNode, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
- break;
- }
+ break;
+ }
- case Property::ROTATION:
- {
- AnimatableProperty<Quaternion>* property = dynamic_cast< AnimatableProperty<Quaternion>* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
+ case Property::ROTATION:
+ {
+ 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( mStage->GetUpdateManager(), mNode, property,&AnimatableProperty<Quaternion>::Bake, value.Get<Quaternion>() );
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<Quaternion>::Send( mStage->GetUpdateManager(), mNode, property,&AnimatableProperty<Quaternion>::Bake, value.Get<Quaternion>() );
- break;
- }
+ break;
+ }
- default:
- {
- DALI_ASSERT_ALWAYS( false && "Property type enumeration out of bounds" ); // should not come here
- break;
- }
+ case Property::MATRIX:
+ {
+ 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( mStage->GetUpdateManager(), mNode, 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 );
+
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<Matrix3>::Send( mStage->GetUpdateManager(), mNode, property,&AnimatableProperty<Matrix3>::Bake, value.Get<Matrix3>() );
+
+ break;
+ }
+
+ default:
+ {
+ DALI_ASSERT_ALWAYS( false && "Property type enumeration out of bounds" ); // should not come here
+ break;
}
}
}
{
Property::Value value;
- // ProxyObject guarantees that index is within range
switch ( index )
{
case Dali::Actor::PARENT_ORIGIN:
break;
}
+ case Dali::Actor::SENSITIVE:
+ {
+ value = IsSensitive();
+ break;
+ }
+
+ case Dali::Actor::LEAVE_REQUIRED:
+ {
+ value = GetLeaveRequired();
+ break;
+ }
+
+ case Dali::Actor::INHERIT_ROTATION:
+ {
+ value = IsRotationInherited();
+ break;
+ }
+
+ case Dali::Actor::INHERIT_SCALE:
+ {
+ value = IsScaleInherited();
+ break;
+ }
+
+ case Dali::Actor::COLOR_MODE:
+ {
+ value = Scripting::GetColorMode( GetColorMode() );
+ break;
+ }
+
+ case Dali::Actor::POSITION_INHERITANCE:
+ {
+ value = Scripting::GetPositionInheritanceMode( GetPositionInheritanceMode() );
+ break;
+ }
+
+ case Dali::Actor::DRAW_MODE:
+ {
+ value = Scripting::GetDrawMode( GetDrawMode() );
+ break;
+ }
+
default:
{
DALI_ASSERT_ALWAYS(false && "Actor Property index invalid" ); // should not come here
return value;
}
-void Actor::InstallSceneObjectProperty( PropertyBase& newProperty, const std::string& name, unsigned int index )
+const SceneGraph::PropertyOwner* Actor::GetPropertyOwner() const
{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to add the property
- InstallCustomPropertyMessage( mStage->GetUpdateInterface(), *mNode, newProperty ); // Message takes ownership
- }
+ return mNode;
}
const SceneGraph::PropertyOwner* Actor::GetSceneObject() const
if ( static_cast<unsigned int>(index) >= DEFAULT_PROPERTY_MAX_COUNT )
{
- CustomPropertyLookup::const_iterator entry = GetCustomPropertyLookup().find( index );
+ CustomProperty* custom = FindCustomProperty( index );
+ DALI_ASSERT_ALWAYS( custom && "Property index is invalid" );
- DALI_ASSERT_ALWAYS( GetCustomPropertyLookup().end() != entry && "index is invalid" );
-
- property = dynamic_cast<const PropertyBase*>( entry->second.GetSceneGraphProperty() );
+ property = custom->GetSceneGraphProperty();
}
else if( NULL != mNode )
{
return property;
}
- if ( static_cast<unsigned int>(index) >= DEFAULT_PROPERTY_MAX_COUNT )
+ if ( index >= DEFAULT_PROPERTY_MAX_COUNT )
{
- CustomPropertyLookup::const_iterator entry = GetCustomPropertyLookup().find( index );
-
- DALI_ASSERT_ALWAYS( GetCustomPropertyLookup().end() != entry && "property index is invalid" );
-
- property = entry->second.GetSceneGraphProperty();
+ CustomProperty* custom = FindCustomProperty( index );
+ DALI_ASSERT_ALWAYS( custom && "Property index is invalid" );
+ property = custom->GetSceneGraphProperty();
}
else if( NULL != mNode )
{
int Actor::GetPropertyComponentIndex( Property::Index index ) const
{
- int componentIndex( INVALID_PROPERTY_COMPONENT_INDEX );
+ int componentIndex( Property::INVALID_COMPONENT_INDEX );
switch ( index )
{
return componentIndex;
}
-void Actor::SetParent(Actor* parent)
+void Actor::SetParent(Actor* parent, int index)
{
if( parent )
{
StagePtr stage = parent->mStage;
// Instruct each actor to create a corresponding node in the scene graph
- ConnectToStage(*stage);
+ ConnectToStage(*stage, index);
}
}
else // parent being set to NULL
projects / platform / core / uifw / dali-core.git / blobdiff