/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 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 <cfloat>
// INTERNAL INCLUDES
-
+#include <dali/devel-api/actors/layer-devel.h>
#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/public-api/scripting/scripting.h>
-
+#include <dali/devel-api/actors/actor-devel.h>
+#include <dali/devel-api/scripting/scripting.h>
#include <dali/internal/common/internal-constants.h>
#include <dali/internal/event/common/event-thread-services.h>
#include <dali/internal/event/render-tasks/render-task-impl.h>
#include <dali/internal/event/render-tasks/render-task-list-impl.h>
#include <dali/internal/event/common/property-helper.h>
#include <dali/internal/event/common/stage-impl.h>
-#include <dali/internal/event/actor-attachments/actor-attachment-impl.h>
-#include <dali/internal/event/actor-attachments/renderer-attachment-impl.h>
+#include <dali/internal/event/common/type-info-impl.h>
#include <dali/internal/event/animation/constraint-impl.h>
#include <dali/internal/event/common/projection.h>
#include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
#include <dali/internal/common/message.h>
#include <dali/integration-api/debug.h>
-#ifdef DYNAMICS_SUPPORT
-#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;
+#if defined(DEBUG_ENABLED)
+Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_DEPTH_TIMER" );
+Debug::Filter* gLogRelayoutFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_RELAYOUT_TIMER" );
+#endif
+
namespace Dali
{
{
unsigned int Actor::mActorCounter = 0;
-ActorContainer Actor::mNullChildren;
+
+namespace
+{
+/// Using a function because of library initialisation order. Vector3::ONE may not have been initialised yet.
+inline const Vector3& GetDefaultSizeModeFactor()
+{
+ return Vector3::ONE;
+}
+
+/// Using a function because of library initialisation order. Vector2::ZERO may not have been initialised yet.
+inline const Vector2& GetDefaultPreferredSize()
+{
+ return Vector2::ZERO;
+}
+
+/// Using a function because of library initialisation order. Vector2::ZERO may not have been initialised yet.
+inline const Vector2& GetDefaultDimensionPadding()
+{
+ return Vector2::ZERO;
+}
+
+const SizeScalePolicy::Type DEFAULT_SIZE_SCALE_POLICY = SizeScalePolicy::USE_SIZE_SET;
+
+} // unnamed namespace
/**
* Struct to collect relayout variables
struct Actor::RelayoutData
{
RelayoutData()
- : sizeModeFactor( Vector3::ONE ), preferredSize( Vector2::ZERO ), sizeSetPolicy( USE_SIZE_SET ), sizeMode( USE_OWN_SIZE ), relayoutEnabled( false ), insideRelayout( false )
+ : sizeModeFactor( GetDefaultSizeModeFactor() ), preferredSize( GetDefaultPreferredSize() ), sizeSetPolicy( DEFAULT_SIZE_SCALE_POLICY ), relayoutEnabled( false ), insideRelayout( false )
{
// Set size negotiation defaults
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- resizePolicies[ i ] = FIXED;
+ resizePolicies[ i ] = ResizePolicy::DEFAULT;
+ useAssignedSize[ i ] = false;
negotiatedDimensions[ i ] = 0.0f;
dimensionNegotiated[ i ] = false;
dimensionDirty[ i ] = false;
- dimensionDependencies[ i ] = ALL_DIMENSIONS;
- dimensionPadding[ i ] = Vector2( 0.0f, 0.0f );
+ dimensionDependencies[ i ] = Dimension::ALL_DIMENSIONS;
+ dimensionPadding[ i ] = GetDefaultDimensionPadding();
minimumSize[ i ] = 0.0f;
maximumSize[ i ] = FLT_MAX;
}
}
- ResizePolicy resizePolicies[ DIMENSION_COUNT ]; ///< Resize policies
+ ResizePolicy::Type resizePolicies[ Dimension::DIMENSION_COUNT ]; ///< Resize policies
+ bool useAssignedSize[ Dimension::DIMENSION_COUNT ]; ///< The flag to specify whether the size should be assigned to the actor
- Dimension dimensionDependencies[ DIMENSION_COUNT ]; ///< A list of dimension dependencies
+ Dimension::Type dimensionDependencies[ Dimension::DIMENSION_COUNT ]; ///< A list of dimension dependencies
- Vector2 dimensionPadding[ DIMENSION_COUNT ]; ///< Padding for each dimension. X = start (e.g. left, bottom), y = end (e.g. right, top)
+ Vector2 dimensionPadding[ Dimension::DIMENSION_COUNT ]; ///< Padding for each dimension. X = start (e.g. left, bottom), y = end (e.g. right, top)
- float negotiatedDimensions[ DIMENSION_COUNT ]; ///< Storage for when a dimension is negotiated but before set on actor
+ float negotiatedDimensions[ Dimension::DIMENSION_COUNT ]; ///< Storage for when a dimension is negotiated but before set on actor
- float minimumSize[ DIMENSION_COUNT ]; ///< The minimum size an actor can be
- float maximumSize[ DIMENSION_COUNT ]; ///< The maximum size an actor can be
+ float minimumSize[ Dimension::DIMENSION_COUNT ]; ///< The minimum size an actor can be
+ float maximumSize[ Dimension::DIMENSION_COUNT ]; ///< The maximum size an actor can be
- bool dimensionNegotiated[ DIMENSION_COUNT ]; ///< Has the dimension been negotiated
- bool dimensionDirty[ DIMENSION_COUNT ]; ///< Flags indicating whether the layout dimension is dirty or not
+ bool dimensionNegotiated[ Dimension::DIMENSION_COUNT ]; ///< Has the dimension been negotiated
+ bool dimensionDirty[ Dimension::DIMENSION_COUNT ]; ///< Flags indicating whether the layout dimension is dirty or not
Vector3 sizeModeFactor; ///< Factor of size used for certain SizeModes
Vector2 preferredSize; ///< The preferred size of the actor
- SizeScalePolicy sizeSetPolicy :3; ///< Policy to apply when setting size. Enough room for the enum
- SizeMode sizeMode :2; ///< Determines how the actors parent affects the actors size
+ SizeScalePolicy::Type sizeSetPolicy :3; ///< Policy to apply when setting size. Enough room for the enum
bool relayoutEnabled :1; ///< Flag to specify if this actor should be included in size negotiation or not (defaults to true)
bool insideRelayout :1; ///< Locking flag to prevent recursive relayouts on size set
};
-#ifdef DYNAMICS_SUPPORT
-
-// Encapsulate actor related dynamics data
-struct DynamicsData
-{
- DynamicsData( Actor* slotOwner )
- : slotDelegate( slotOwner )
- {
- }
-
- typedef std::map<Actor*, DynamicsJointPtr> JointContainer;
- typedef std::vector<DynamicsJointPtr> ReferencedJointContainer;
-
- DynamicsBodyPtr body;
- JointContainer joints;
- ReferencedJointContainer referencedJoints;
-
- SlotDelegate< Actor > slotDelegate;
-};
-
-#endif // DYNAMICS_SUPPORT
-
namespace // unnamed namespace
{
/**
* We want to discourage the use of property strings (minimize string comparisons),
* particularly for the default properties.
- * Name Type writable animatable constraint-input enum for index-checking
+ * Name Type writable animatable constraint-input enum for index-checking
*/
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "parent-origin", VECTOR3, true, false, true, Dali::Actor::Property::PARENT_ORIGIN )
-DALI_PROPERTY( "parent-origin-x", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_X )
-DALI_PROPERTY( "parent-origin-y", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Y )
-DALI_PROPERTY( "parent-origin-z", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Z )
-DALI_PROPERTY( "anchor-point", VECTOR3, true, false, true, Dali::Actor::Property::ANCHOR_POINT )
-DALI_PROPERTY( "anchor-point-x", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_X )
-DALI_PROPERTY( "anchor-point-y", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Y )
-DALI_PROPERTY( "anchor-point-z", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Z )
-DALI_PROPERTY( "size", VECTOR3, true, true, true, Dali::Actor::Property::SIZE )
-DALI_PROPERTY( "size-width", FLOAT, true, true, true, Dali::Actor::Property::SIZE_WIDTH )
-DALI_PROPERTY( "size-height", FLOAT, true, true, true, Dali::Actor::Property::SIZE_HEIGHT )
-DALI_PROPERTY( "size-depth", FLOAT, true, true, true, Dali::Actor::Property::SIZE_DEPTH )
-DALI_PROPERTY( "position", VECTOR3, true, true, true, Dali::Actor::Property::POSITION )
-DALI_PROPERTY( "position-x", FLOAT, true, true, true, Dali::Actor::Property::POSITION_X )
-DALI_PROPERTY( "position-y", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Y )
-DALI_PROPERTY( "position-z", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Z )
-DALI_PROPERTY( "world-position", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_POSITION )
-DALI_PROPERTY( "world-position-x", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_X )
-DALI_PROPERTY( "world-position-y", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Y )
-DALI_PROPERTY( "world-position-z", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Z )
-DALI_PROPERTY( "orientation", ROTATION, true, true, true, Dali::Actor::Property::ORIENTATION )
-DALI_PROPERTY( "world-orientation", ROTATION, false, false, true, Dali::Actor::Property::WORLD_ORIENTATION )
-DALI_PROPERTY( "scale", VECTOR3, true, true, true, Dali::Actor::Property::SCALE )
-DALI_PROPERTY( "scale-x", FLOAT, true, true, true, Dali::Actor::Property::SCALE_X )
-DALI_PROPERTY( "scale-y", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Y )
-DALI_PROPERTY( "scale-z", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Z )
-DALI_PROPERTY( "world-scale", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_SCALE )
-DALI_PROPERTY( "visible", BOOLEAN, true, true, true, Dali::Actor::Property::VISIBLE )
-DALI_PROPERTY( "color", VECTOR4, true, true, true, Dali::Actor::Property::COLOR )
-DALI_PROPERTY( "color-red", FLOAT, true, true, true, Dali::Actor::Property::COLOR_RED )
-DALI_PROPERTY( "color-green", FLOAT, true, true, true, Dali::Actor::Property::COLOR_GREEN )
-DALI_PROPERTY( "color-blue", FLOAT, true, true, true, Dali::Actor::Property::COLOR_BLUE )
-DALI_PROPERTY( "color-alpha", FLOAT, true, true, true, Dali::Actor::Property::COLOR_ALPHA )
-DALI_PROPERTY( "world-color", VECTOR4, false, false, true, Dali::Actor::Property::WORLD_COLOR )
-DALI_PROPERTY( "world-matrix", MATRIX, false, false, true, Dali::Actor::Property::WORLD_MATRIX )
-DALI_PROPERTY( "name", STRING, true, false, false, Dali::Actor::Property::NAME )
-DALI_PROPERTY( "sensitive", BOOLEAN, true, false, false, Dali::Actor::Property::SENSITIVE )
-DALI_PROPERTY( "leave-required", BOOLEAN, true, false, false, Dali::Actor::Property::LEAVE_REQUIRED )
-DALI_PROPERTY( "inherit-orientation", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_ORIENTATION )
-DALI_PROPERTY( "inherit-scale", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_SCALE )
-DALI_PROPERTY( "color-mode", STRING, true, false, false, Dali::Actor::Property::COLOR_MODE )
-DALI_PROPERTY( "position-inheritance", STRING, true, false, false, Dali::Actor::Property::POSITION_INHERITANCE )
-DALI_PROPERTY( "draw-mode", STRING, true, false, false, Dali::Actor::Property::DRAW_MODE )
-DALI_PROPERTY( "size-mode", STRING, true, false, false, Dali::Actor::Property::SIZE_MODE )
-DALI_PROPERTY( "size-mode-factor", VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR )
-DALI_PROPERTY( "relayout-enabled", BOOLEAN, true, false, false, Dali::Actor::Property::RELAYOUT_ENABLED )
-DALI_PROPERTY( "width-resize-policy", STRING, true, false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY )
-DALI_PROPERTY( "height-resize-policy", STRING, true, false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY )
-DALI_PROPERTY( "size-scale-policy", STRING, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY )
-DALI_PROPERTY( "width-for-height", BOOLEAN, true, false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT )
-DALI_PROPERTY( "height-for-width", BOOLEAN, true, false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH )
-DALI_PROPERTY( "padding", VECTOR4, true, false, false, Dali::Actor::Property::PADDING )
-DALI_PROPERTY( "minimum-size", VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE )
-DALI_PROPERTY( "maximum-size", VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE )
-DALI_PROPERTY( "preferred-size", VECTOR2, true, false, false, Dali::Actor::Property::PREFERRED_SIZE )
+DALI_PROPERTY( "parentOrigin", VECTOR3, true, false, true, Dali::Actor::Property::PARENT_ORIGIN )
+DALI_PROPERTY( "parentOriginX", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_X )
+DALI_PROPERTY( "parentOriginY", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Y )
+DALI_PROPERTY( "parentOriginZ", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Z )
+DALI_PROPERTY( "anchorPoint", VECTOR3, true, false, true, Dali::Actor::Property::ANCHOR_POINT )
+DALI_PROPERTY( "anchorPointX", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_X )
+DALI_PROPERTY( "anchorPointY", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Y )
+DALI_PROPERTY( "anchorPointZ", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Z )
+DALI_PROPERTY( "size", VECTOR3, true, true, true, Dali::Actor::Property::SIZE )
+DALI_PROPERTY( "sizeWidth", FLOAT, true, true, true, Dali::Actor::Property::SIZE_WIDTH )
+DALI_PROPERTY( "sizeHeight", FLOAT, true, true, true, Dali::Actor::Property::SIZE_HEIGHT )
+DALI_PROPERTY( "sizeDepth", FLOAT, true, true, true, Dali::Actor::Property::SIZE_DEPTH )
+DALI_PROPERTY( "position", VECTOR3, true, true, true, Dali::Actor::Property::POSITION )
+DALI_PROPERTY( "positionX", FLOAT, true, true, true, Dali::Actor::Property::POSITION_X )
+DALI_PROPERTY( "positionY", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Y )
+DALI_PROPERTY( "positionZ", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Z )
+DALI_PROPERTY( "worldPosition", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_POSITION )
+DALI_PROPERTY( "worldPositionX", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_X )
+DALI_PROPERTY( "worldPositionY", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Y )
+DALI_PROPERTY( "worldPositionZ", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Z )
+DALI_PROPERTY( "orientation", ROTATION, true, true, true, Dali::Actor::Property::ORIENTATION )
+DALI_PROPERTY( "worldOrientation", ROTATION, false, false, true, Dali::Actor::Property::WORLD_ORIENTATION )
+DALI_PROPERTY( "scale", VECTOR3, true, true, true, Dali::Actor::Property::SCALE )
+DALI_PROPERTY( "scaleX", FLOAT, true, true, true, Dali::Actor::Property::SCALE_X )
+DALI_PROPERTY( "scaleY", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Y )
+DALI_PROPERTY( "scaleZ", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Z )
+DALI_PROPERTY( "worldScale", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_SCALE )
+DALI_PROPERTY( "visible", BOOLEAN, true, true, true, Dali::Actor::Property::VISIBLE )
+DALI_PROPERTY( "color", VECTOR4, true, true, true, Dali::Actor::Property::COLOR )
+DALI_PROPERTY( "colorRed", FLOAT, true, true, true, Dali::Actor::Property::COLOR_RED )
+DALI_PROPERTY( "colorGreen", FLOAT, true, true, true, Dali::Actor::Property::COLOR_GREEN )
+DALI_PROPERTY( "colorBlue", FLOAT, true, true, true, Dali::Actor::Property::COLOR_BLUE )
+DALI_PROPERTY( "colorAlpha", FLOAT, true, true, true, Dali::Actor::Property::COLOR_ALPHA )
+DALI_PROPERTY( "worldColor", VECTOR4, false, false, true, Dali::Actor::Property::WORLD_COLOR )
+DALI_PROPERTY( "worldMatrix", MATRIX, false, false, true, Dali::Actor::Property::WORLD_MATRIX )
+DALI_PROPERTY( "name", STRING, true, false, false, Dali::Actor::Property::NAME )
+DALI_PROPERTY( "sensitive", BOOLEAN, true, false, false, Dali::Actor::Property::SENSITIVE )
+DALI_PROPERTY( "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( "positionInheritance", STRING, true, false, false, Dali::Actor::Property::POSITION_INHERITANCE )
+DALI_PROPERTY( "drawMode", STRING, 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( "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( "minimumSize", VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE )
+DALI_PROPERTY( "maximumSize", VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE )
+DALI_PROPERTY( "inheritPosition", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_POSITION )
+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( "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_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
// Signals
const char* const SIGNAL_TOUCHED = "touched";
const char* const SIGNAL_HOVERED = "hovered";
-const char* const SIGNAL_MOUSE_WHEEL_EVENT = "mouse-wheel-event";
-const char* const SIGNAL_ON_STAGE = "on-stage";
-const char* const SIGNAL_OFF_STAGE = "off-stage";
+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_RELAYOUT = "onRelayout";
+const char* const SIGNAL_TOUCH = "touch";
// Actions
const char* const ACTION_SHOW = "show";
const char* const ACTION_HIDE = "hide";
-// Enumeration to / from string conversion tables
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( SizeMode )DALI_ENUM_TO_STRING( USE_OWN_SIZE )
-DALI_ENUM_TO_STRING( SIZE_RELATIVE_TO_PARENT )
-DALI_ENUM_TO_STRING( SIZE_FIXED_OFFSET_FROM_PARENT )
-DALI_ENUM_TO_STRING_TABLE_END( SizeMode )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( ResizePolicy )DALI_ENUM_TO_STRING( FIXED )
-DALI_ENUM_TO_STRING( USE_NATURAL_SIZE )
-DALI_ENUM_TO_STRING( USE_ASSIGNED_SIZE )
-DALI_ENUM_TO_STRING( FILL_TO_PARENT )
-DALI_ENUM_TO_STRING( FIT_TO_CHILDREN )
-DALI_ENUM_TO_STRING( DIMENSION_DEPENDENCY )
-DALI_ENUM_TO_STRING_TABLE_END( ResizePolicy )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( SizeScalePolicy )DALI_ENUM_TO_STRING( USE_SIZE_SET )
-DALI_ENUM_TO_STRING( FIT_WITH_ASPECT_RATIO )
-DALI_ENUM_TO_STRING( FILL_WITH_ASPECT_RATIO )
-DALI_ENUM_TO_STRING_TABLE_END( SizeScalePolicy )
-
BaseHandle CreateActor()
{
return Dali::Actor::New();
SignalConnectorType signalConnector1( mType, SIGNAL_TOUCHED, &Actor::DoConnectSignal );
SignalConnectorType signalConnector2( mType, SIGNAL_HOVERED, &Actor::DoConnectSignal );
-SignalConnectorType signalConnector3( mType, SIGNAL_ON_STAGE, &Actor::DoConnectSignal );
-SignalConnectorType signalConnector4( mType, SIGNAL_OFF_STAGE, &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 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 )
+
+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( 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
*
* @param[in] dimension The dimension to extract
* @return Return the value for the dimension
*/
-float GetDimensionValue( const Vector2& values, Dimension dimension )
+float GetDimensionValue( const Vector2& values, Dimension::Type dimension )
{
switch( dimension )
{
- case WIDTH:
+ case Dimension::WIDTH:
{
return values.width;
}
-
- case HEIGHT:
+ case Dimension::HEIGHT:
{
return values.height;
}
-
default:
{
break;
}
}
-
return 0.0f;
}
* @param[in] dimension The dimension to extract
* @return Return the value for the dimension
*/
-float GetDimensionValue( const Vector3& values, Dimension dimension )
+float GetDimensionValue( const Vector3& values, Dimension::Type dimension )
{
return GetDimensionValue( values.GetVectorXY(), dimension );
}
+/**
+ * @brief Recursively emits the visibility-changed-signal on the actor tree.
+ * @param[in] actor The actor to emit the signal on
+ * @param[in] visible The new visibility of the actor
+ * @param[in] type Whether the actor's visible property has changed or a parent's
+ */
+void EmitVisibilityChangedSignalRecursively( ActorPtr actor, bool visible, DevelActor::VisibilityChange::Type type )
+{
+ if( actor )
+ {
+ actor->EmitVisibilityChangedSignal( visible, type );
+
+ if( actor->GetChildCount() > 0 )
+ {
+ ActorContainer& children = actor->GetChildrenInternal();
+ for( ActorIter iter = children.begin(), endIter = children.end(); iter != endIter; ++iter )
+ {
+ EmitVisibilityChangedSignalRecursively( *iter, visible, DevelActor::VisibilityChange::PARENT );
+ }
+ }
+ }
+}
+
} // unnamed namespace
ActorPtr Actor::New()
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( !child.mParent )
{
// Do this first, since user callbacks from within SetParent() may need to remove child
- mChildren->push_back( Dali::Actor( &child ) );
+ mChildren->push_back( ActorPtr( &child ) );
// SetParent asserts that child can be added
child.SetParent( this );
// Notification for derived classes
OnChildAdd( child );
+ InheritLayoutDirectionRecursively( ActorPtr( &child ), mLayoutDirection );
+
// Only put in a relayout request if there is a suitable dependency
if( RelayoutDependentOnChildren() )
{
RelayoutRequest();
}
-
- if( child.RelayoutDependentOnParent() )
- {
- child.RelayoutRequest();
- }
- }
- }
-}
-
-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
-
- // Old parent may need to readjust to missing child
- if( oldParent->RelayoutDependentOnChildren() )
- {
- oldParent->RelayoutRequest();
- }
- }
-
- // 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 );
-
- // Only put in a relayout request if there is a suitable dependency
- if( RelayoutDependentOnChildren() )
- {
- RelayoutRequest();
- }
-
- if( child.RelayoutDependentOnParent() )
- {
- child.RelayoutRequest();
}
}
}
void Actor::Remove( Actor& child )
{
- DALI_ASSERT_ALWAYS( this != &child && "Cannot remove actor from itself" );
-
- Dali::Actor removed;
-
- if( !mChildren )
+ if( (this == &child) || (!mChildren) )
{
- // no children
+ // no children or removing itself
return;
}
+ ActorPtr removed;
+
// Find the child in mChildren, and unparent it
ActorIter end = mChildren->end();
for( ActorIter iter = mChildren->begin(); iter != end; ++iter )
{
- Actor& actor = GetImplementation( *iter );
+ ActorPtr actor = (*iter);
- if( &actor == &child )
+ if( actor.Get() == &child )
{
// Keep handle for OnChildRemove notification
- removed = Dali::Actor( &actor );
+ removed = actor;
// Do this first, since user callbacks from within SetParent() may need to add the child
mChildren->erase( iter );
- DALI_ASSERT_DEBUG( actor.GetParent() == this );
- actor.SetParent( NULL );
+ DALI_ASSERT_DEBUG( actor->GetParent() == this );
+ actor->SetParent( NULL );
break;
}
if( removed )
{
- // Notification for derived classes
- OnChildRemove( GetImplementation( removed ) );
-
// Only put in a relayout request if there is a suitable dependency
if( RelayoutDependentOnChildren() )
{
RelayoutRequest();
}
}
+
+ // Notification for derived classes
+ OnChildRemove( child );
}
void Actor::Unparent()
return ( NULL != mChildren ) ? mChildren->size() : 0;
}
-Dali::Actor Actor::GetChildAt( unsigned int index ) const
+ActorPtr Actor::GetChildAt( unsigned int index ) const
{
DALI_ASSERT_ALWAYS( index < GetChildCount() );
- return ( ( mChildren ) ? ( *mChildren )[ index ] : Dali::Actor() );
-}
-
-ActorContainer Actor::GetChildren()
-{
- if( NULL != mChildren )
- {
- return *mChildren;
- }
-
- // return copy of mNullChildren
- return mNullChildren;
-}
-
-const ActorContainer& Actor::GetChildren() const
-{
- if( NULL != mChildren )
- {
- return *mChildren;
- }
-
- // return const reference to mNullChildren
- return mNullChildren;
+ return ( ( mChildren ) ? ( *mChildren )[ index ] : ActorPtr() );
}
ActorPtr Actor::FindChildByName( const std::string& actorName )
ActorIter end = mChildren->end();
for( ActorIter iter = mChildren->begin(); iter != end; ++iter )
{
- child = GetImplementation( *iter ).FindChildByName( actorName );
+ child = (*iter)->FindChildByName( actorName );
if( child )
{
ActorIter end = mChildren->end();
for( ActorIter iter = mChildren->begin(); iter != end; ++iter )
{
- child = GetImplementation( *iter ).FindChildById( id );
+ child = (*iter)->FindChildById( id );
if( child )
{
void Actor::SetPosition( const Vector3& position )
{
+ mTargetPosition = position;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::Bake, position );
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, position );
}
}
void Actor::SetX( float x )
{
+ mTargetPosition.x = x;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeX, x );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );
}
}
void Actor::SetY( float y )
{
+ mTargetPosition.y = y;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeY, y );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );
}
}
void Actor::SetZ( float z )
{
+ mTargetPosition.z = z;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeZ, z );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );
}
}
void Actor::TranslateBy( const Vector3& distance )
{
+ mTargetPosition += distance;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeRelative, distance );
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelative, distance );
}
}
return Vector3::ZERO;
}
+const Vector3& Actor::GetTargetPosition() const
+{
+ return mTargetPosition;
+}
+
const Vector3& Actor::GetCurrentWorldPosition() const
{
if( NULL != mNode )
return Vector3::ZERO;
}
+const Vector2 Actor::GetCurrentScreenPosition() const
+{
+ if( OnStage() && NULL != mNode )
+ {
+ StagePtr stage = Stage::GetCurrent();
+ Vector3 worldPosition = mNode->GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
+ Vector3 actorSize = GetCurrentSize() * GetCurrentWorldScale();
+ Vector2 halfStageSize( stage->GetSize() * 0.5f ); // World position origin is center of stage
+ Vector3 halfActorSize( actorSize * 0.5f );
+ Vector3 anchorPointOffSet = halfActorSize - actorSize * ( mPositionUsesAnchorPoint ? GetCurrentAnchorPoint() : AnchorPoint::TOP_LEFT );
+
+ return Vector2( halfStageSize.width + worldPosition.x - anchorPointOffSet.x,
+ halfStageSize.height + worldPosition.y - anchorPointOffSet.y );
+ }
+
+ return Vector2::ZERO;
+}
+
void Actor::SetPositionInheritanceMode( PositionInheritanceMode mode )
{
// this flag is not animatable so keep the value
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 );
}
}
return mPositionInheritanceMode;
}
+void Actor::SetInheritPosition( bool inherit )
+{
+ if( mInheritPosition != inherit && NULL != mNode )
+ {
+ // non animateable so keep local copy
+ mInheritPosition = inherit;
+ SetInheritPositionMessage( GetEventThreadServices(), *mNode, inherit );
+ }
+}
+
+bool Actor::IsPositionInherited() const
+{
+ return mInheritPosition;
+}
+
void Actor::SetOrientation( const Radian& angle, const Vector3& axis )
{
- Vector4 normalizedAxis( axis.x, axis.y, axis.z, 0.0f );
+ Vector3 normalizedAxis( axis.x, axis.y, axis.z );
normalizedAxis.Normalize();
- Quaternion orientation( Quaternion::FromAxisAngle( normalizedAxis, angle ) );
+ Quaternion orientation( angle, normalizedAxis );
SetOrientation( orientation );
}
void Actor::SetOrientation( const Quaternion& orientation )
{
+ mTargetOrientation = orientation;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty<Quaternion>::Bake, orientation );
+ SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::Bake, orientation );
}
}
void Actor::RotateBy( const Radian& angle, const Vector3& axis )
{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty<Quaternion>::BakeRelative, Quaternion(angle, axis) );
- }
+ RotateBy( Quaternion(angle, axis) );
}
void Actor::RotateBy( const Quaternion& relativeRotation )
{
+ mTargetOrientation *= Quaternion( relativeRotation );
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty<Quaternion>::BakeRelative, relativeRotation );
+ SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::BakeRelative, relativeRotation );
}
}
void Actor::SetScale( const Vector3& scale )
{
+ mTargetScale = scale;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::Bake, scale );
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, scale );
}
}
void Actor::SetScaleX( float x )
{
+ mTargetScale.x = x;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeX, x );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );
}
}
void Actor::SetScaleY( float y )
{
+ mTargetScale.y = y;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeY, y );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );
}
}
void Actor::SetScaleZ( float z )
{
+ mTargetScale.z = z;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeZ, z );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );
}
}
void Actor::ScaleBy(const Vector3& relativeScale)
{
+ mTargetScale *= relativeScale;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeRelativeMultiply, relativeScale );
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelativeMultiply, relativeScale );
}
}
void Actor::SetInheritScale( bool inherit )
{
- // non animateable so keep local copy
- mInheritScale = inherit;
- if( NULL != mNode )
+
+ if( mInheritScale != inherit && NULL != mNode )
{
+ // non animateable so keep local copy
+ mInheritScale = inherit;
// mNode is being used in a separate thread; queue a message to set the value
SetInheritScaleMessage( GetEventThreadServices(), *mNode, inherit );
}
{
if( NULL != mNode )
{
- // World matrix is no longer updated unless there is something observing the node.
- // Need to calculate it from node's world position, orientation and scale:
- BufferIndex updateBufferIndex = GetEventThreadServices().GetEventBufferIndex();
- Matrix worldMatrix(false);
- worldMatrix.SetTransformComponents( mNode->GetWorldScale( updateBufferIndex ),
- mNode->GetWorldOrientation( updateBufferIndex ),
- mNode->GetWorldPosition( updateBufferIndex ) );
- return worldMatrix;
+ return mNode->GetWorldMatrix(0);
}
return Matrix::IDENTITY;
void Actor::SetVisible( bool visible )
{
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), mNode, &mNode->mVisible, &AnimatableProperty<bool>::Bake, visible );
- }
+ SetVisibleInternal( visible, SendMessage::TRUE );
}
bool Actor::IsVisible() const
void Actor::SetOpacity( float opacity )
{
+ mTargetColor.a = opacity;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
return 1.0f;
}
+ClippingMode::Type Actor::GetClippingMode() const
+{
+ return mClippingMode;
+}
+
+unsigned int Actor::GetSortingDepth()
+{
+ return mSortedDepth;
+}
+
const Vector4& Actor::GetCurrentWorldColor() const
{
if( NULL != mNode )
void Actor::SetColor( const Vector4& color )
{
+ mTargetColor = color;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
void Actor::SetColorRed( float red )
{
+ mTargetColor.r = red;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
void Actor::SetColorGreen( float green )
{
+ mTargetColor.g = green;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
void Actor::SetColorBlue( float blue )
{
+ mTargetColor.b = blue;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
void Actor::SetInheritOrientation( bool inherit )
{
- // non animateable so keep local copy
- mInheritOrientation = inherit;
- if( NULL != mNode )
+ if( mInheritOrientation != inherit && NULL != mNode)
{
+ // non animateable so keep local copy
+ mInheritOrientation = inherit;
// mNode is being used in a separate thread; queue a message to set the value
SetInheritOrientationMessage( GetEventThreadServices(), *mNode, inherit );
}
return mInheritOrientation;
}
-void Actor::SetSizeMode( SizeMode mode )
-{
- EnsureRelayoutData();
-
- mRelayoutData->sizeMode = mode;
-}
-
void Actor::SetSizeModeFactor( const Vector3& factor )
{
EnsureRelayoutData();
mRelayoutData->sizeModeFactor = factor;
}
-SizeMode Actor::GetSizeMode() const
-{
- EnsureRelayoutData();
-
- return mRelayoutData->sizeMode;
-}
-
const Vector3& Actor::GetSizeModeFactor() const
{
- EnsureRelayoutData();
+ if ( mRelayoutData )
+ {
+ return mRelayoutData->sizeModeFactor;
+ }
- return mRelayoutData->sizeModeFactor;
+ return GetDefaultSizeModeFactor();
}
void Actor::SetColorMode( ColorMode colorMode )
void Actor::SetSize( const Vector2& size )
{
- SetSize( Vector3( size.width, size.height, CalculateSizeZ( size ) ) );
+ SetSize( Vector3( size.width, size.height, 0.f ) );
}
-float Actor::CalculateSizeZ( const Vector2& size ) const
+void Actor::SetSizeInternal( const Vector2& size )
{
- return std::min( size.width, size.height );
+ SetSizeInternal( Vector3( size.width, size.height, 0.f ) );
}
void Actor::SetSize( const Vector3& size )
{
- if( NULL != mNode )
+ if( IsRelayoutEnabled() && !mRelayoutData->insideRelayout )
+ {
+ // TODO we cannot just ignore the given Z but that means rewrite the size negotiation!!
+ SetPreferredSize( size.GetVectorXY() );
+ }
+ else
+ {
+ SetSizeInternal( size );
+ }
+}
+
+void Actor::SetSizeInternal( const Vector3& size )
+{
+ // dont allow recursive loop
+ DALI_ASSERT_ALWAYS( !mInsideOnSizeSet && "Cannot call SetSize from OnSizeSet" );
+ // check that we have a node AND the new size width, height or depth is at least a little bit different from the old one
+ if( ( NULL != mNode )&&
+ ( ( fabsf( mTargetSize.width - size.width ) > Math::MACHINE_EPSILON_1 )||
+ ( fabsf( mTargetSize.height- size.height ) > Math::MACHINE_EPSILON_1 )||
+ ( fabsf( mTargetSize.depth - size.depth ) > Math::MACHINE_EPSILON_1 ) ) )
{
mTargetSize = size;
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::Bake, mTargetSize );
+ SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, mTargetSize );
// Notification for derived classes
+ mInsideOnSizeSet = true;
OnSizeSet( mTargetSize );
+ mInsideOnSizeSet = false;
// Raise a relayout request if the flag is not locked
if( mRelayoutData && !mRelayoutData->insideRelayout )
}
}
-void Actor::NotifySizeAnimation( Animation& animation, const Vector3& targetSize )
-{
- mTargetSize = targetSize;
-
- // Notify deriving classes
- OnSizeAnimation( animation, targetSize );
-}
-
void Actor::SetWidth( float width )
{
- if( NULL != mNode )
+ if( IsRelayoutEnabled() && !mRelayoutData->insideRelayout )
{
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeX, width );
+ SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
+ mRelayoutData->preferredSize.width = width;
+ }
+ else
+ {
+ mTargetSize.width = width;
+
+ if( NULL != mNode )
+ {
+ // mNode is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, width );
+ }
}
+
+ RelayoutRequest();
}
void Actor::SetHeight( float height )
{
- if( NULL != mNode )
+ if( IsRelayoutEnabled() && !mRelayoutData->insideRelayout )
{
- // mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeY, height );
+ SetResizePolicy( ResizePolicy::FIXED, Dimension::HEIGHT );
+ mRelayoutData->preferredSize.height = height;
+ }
+ else
+ {
+ mTargetSize.height = height;
+
+ if( NULL != mNode )
+ {
+ // mNode is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, height );
+ }
}
+
+ RelayoutRequest();
}
void Actor::SetDepth( float depth )
{
+ mTargetSize.depth = depth;
+
if( NULL != mNode )
{
// mNode is being used in a separate thread; queue a message to set the value & base value
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeZ, depth );
+ SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, depth );
}
}
-const Vector3& Actor::GetTargetSize() const
+Vector3 Actor::GetTargetSize() const
{
- return mTargetSize;
+ Vector3 size = mTargetSize;
+
+ // Should return preferred size if size is fixed as set by SetSize
+ if( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::FIXED )
+ {
+ size.width = GetPreferredSize().width;
+ }
+ if( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::FIXED )
+ {
+ size.height = GetPreferredSize().height;
+ }
+
+ return size;
}
const Vector3& Actor::GetCurrentSize() const
return Vector3( 0.0f, 0.0f, 0.0f );
}
-void Actor::SetResizePolicy( ResizePolicy policy, Dimension dimension )
+void Actor::SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ ResizePolicy::Type originalWidthPolicy = GetResizePolicy(Dimension::WIDTH);
+ ResizePolicy::Type originalHeightPolicy = GetResizePolicy(Dimension::HEIGHT);
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
- mRelayoutData->resizePolicies[ i ] = policy;
+ if ( policy == ResizePolicy::USE_ASSIGNED_SIZE )
+ {
+ mRelayoutData->useAssignedSize[ i ] = true;
+ }
+ else
+ {
+ mRelayoutData->resizePolicies[ i ] = policy;
+ mRelayoutData->useAssignedSize[ i ] = false;
+ }
}
}
- OnSetResizePolicy( policy, dimension );
+ if( policy == ResizePolicy::DIMENSION_DEPENDENCY )
+ {
+ if( dimension & Dimension::WIDTH )
+ {
+ SetDimensionDependency( Dimension::WIDTH, Dimension::HEIGHT );
+ }
- // Trigger relayout on this control
- RelayoutRequest();
-}
+ if( dimension & Dimension::HEIGHT )
+ {
+ SetDimensionDependency( Dimension::HEIGHT, Dimension::WIDTH );
+ }
+ }
-ResizePolicy Actor::GetResizePolicy( Dimension dimension ) const
-{
- EnsureRelayoutData();
+ // If calling SetResizePolicy, assume we want relayout enabled
+ SetRelayoutEnabled( true );
- // If more than one dimension is requested, just return the first one found
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ // If the resize policy is set to be FIXED, the preferred size
+ // should be overrided by the target size. Otherwise the target
+ // size should be overrided by the preferred size.
+
+ if( dimension & Dimension::WIDTH )
{
- if( ( dimension & ( 1 << i ) ) )
+ if( originalWidthPolicy != ResizePolicy::FIXED && policy == ResizePolicy::FIXED )
+ {
+ mRelayoutData->preferredSize.width = mTargetSize.width;
+ }
+ else if( originalWidthPolicy == ResizePolicy::FIXED && policy != ResizePolicy::FIXED )
+ {
+ mTargetSize.width = mRelayoutData->preferredSize.width;
+ }
+ }
+
+ if( dimension & Dimension::HEIGHT )
+ {
+ if( originalHeightPolicy != ResizePolicy::FIXED && policy == ResizePolicy::FIXED )
+ {
+ mRelayoutData->preferredSize.height = mTargetSize.height;
+ }
+ else if( originalHeightPolicy == ResizePolicy::FIXED && policy != ResizePolicy::FIXED )
+ {
+ mTargetSize.height = mRelayoutData->preferredSize.height;
+ }
+ }
+
+ OnSetResizePolicy( policy, dimension );
+
+ // Trigger relayout on this control
+ RelayoutRequest();
+}
+
+ResizePolicy::Type Actor::GetResizePolicy( Dimension::Type dimension ) const
+{
+ if ( mRelayoutData )
+ {
+ // If more than one dimension is requested, just return the first one found
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- return mRelayoutData->resizePolicies[ i ];
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ if( mRelayoutData->useAssignedSize[ i ] )
+ {
+ return ResizePolicy::USE_ASSIGNED_SIZE;
+ }
+ else
+ {
+ return mRelayoutData->resizePolicies[ i ];
+ }
+ }
}
}
- return FIXED; // Default
+ return ResizePolicy::DEFAULT;
}
-void Actor::SetSizeScalePolicy( SizeScalePolicy policy )
+void Actor::SetSizeScalePolicy( SizeScalePolicy::Type policy )
{
EnsureRelayoutData();
mRelayoutData->sizeSetPolicy = policy;
}
-SizeScalePolicy Actor::GetSizeScalePolicy() const
+SizeScalePolicy::Type Actor::GetSizeScalePolicy() const
{
- EnsureRelayoutData();
+ if ( mRelayoutData )
+ {
+ return mRelayoutData->sizeSetPolicy;
+ }
- return mRelayoutData->sizeSetPolicy;
+ return DEFAULT_SIZE_SCALE_POLICY;
}
-void Actor::SetDimensionDependency( Dimension dimension, Dimension dependency )
+void Actor::SetDimensionDependency( Dimension::Type dimension, Dimension::Type dependency )
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
mRelayoutData->dimensionDependencies[ i ] = dependency;
- mRelayoutData->resizePolicies[ i ] = DIMENSION_DEPENDENCY;
}
}
}
-Dimension Actor::GetDimensionDependency( Dimension dimension ) const
+Dimension::Type Actor::GetDimensionDependency( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- // If more than one dimension is requested, just return the first one found
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ if ( mRelayoutData )
{
- if( ( dimension & ( 1 << i ) ) )
+ // If more than one dimension is requested, just return the first one found
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- return mRelayoutData->dimensionDependencies[ i ];
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ return mRelayoutData->dimensionDependencies[ i ];
+ }
}
}
- return ALL_DIMENSIONS; // Default
+ return Dimension::ALL_DIMENSIONS; // Default
}
void Actor::SetRelayoutEnabled( bool relayoutEnabled )
{
EnsureRelayoutData();
+ DALI_ASSERT_DEBUG( mRelayoutData && "mRelayoutData not created" );
+
mRelayoutData->relayoutEnabled = relayoutEnabled;
}
}
return mRelayoutData && mRelayoutData->relayoutEnabled;
}
-void Actor::SetLayoutDirty( bool dirty, Dimension dimension )
+void Actor::SetLayoutDirty( bool dirty, Dimension::Type dimension )
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
}
}
-bool Actor::IsLayoutDirty( Dimension dimension ) const
+bool Actor::IsLayoutDirty( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ if ( mRelayoutData )
{
- if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionDirty[ i ] )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- return true;
+ if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionDirty[ i ] )
+ {
+ return true;
+ }
}
}
return false;
}
-bool Actor::RelayoutPossible( Dimension dimension ) const
+bool Actor::RelayoutPossible( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- return mRelayoutData->relayoutEnabled && !IsLayoutDirty( dimension );
+ return mRelayoutData && mRelayoutData->relayoutEnabled && !IsLayoutDirty( dimension );
}
-bool Actor::RelayoutRequired( Dimension dimension ) const
+bool Actor::RelayoutRequired( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- return mRelayoutData->relayoutEnabled && IsLayoutDirty( dimension );
+ return mRelayoutData && mRelayoutData->relayoutEnabled && IsLayoutDirty( dimension );
}
unsigned int Actor::AddRenderer( Renderer& renderer )
{
- //TODO: MESH_REWORK : Add support for multiple renderers
- if ( ! mAttachment )
+ if( !mRenderers )
{
- mAttachment = RendererAttachment::New( GetEventThreadServices(), *mNode, renderer );
+ mRenderers = new RendererContainer;
}
- return 0;
+ unsigned int index = mRenderers->size();
+ RendererPtr rendererPtr = RendererPtr( &renderer );
+ mRenderers->push_back( rendererPtr );
+ AddRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
+ return index;
}
unsigned int Actor::GetRendererCount() const
{
- //TODO: MESH_REWORK : Add support for multiple renderers
- RendererAttachment* attachment = dynamic_cast<RendererAttachment*>(mAttachment.Get());
- return attachment ? 1u : 0u;
-}
-
-Renderer& Actor::GetRendererAt( unsigned int index )
-{
- //TODO: MESH_REWORK : Add support for multiple renderers
- DALI_ASSERT_DEBUG( index == 0 && "Only one renderer is supported." );
-
- //TODO: MESH_REWORK : Temporary code
- RendererAttachment* attachment = dynamic_cast<RendererAttachment*>(mAttachment.Get());
- DALI_ASSERT_ALWAYS( attachment && "Actor doesn't have a renderer" );
+ unsigned int rendererCount(0);
+ if( mRenderers )
+ {
+ rendererCount = mRenderers->size();
+ }
- return attachment->GetRenderer();
+ return rendererCount;
}
-void Actor::RemoveRenderer( Renderer& renderer )
+RendererPtr Actor::GetRendererAt( unsigned int index )
{
- //TODO: MESH_REWORK : Add support for multiple renderers
- mAttachment = NULL;
-}
+ RendererPtr renderer;
+ if( index < GetRendererCount() )
+ {
+ renderer = ( *mRenderers )[ index ];
+ }
-void Actor::RemoveRenderer( unsigned int index )
-{
- //TODO: MESH_REWORK : Add support for multiple renderers
- mAttachment = NULL;
+ return renderer;
}
-
-#ifdef DYNAMICS_SUPPORT
-
-//--------------- Dynamics ---------------
-
-void Actor::DisableDynamics()
+void Actor::RemoveRenderer( Renderer& renderer )
{
- if( NULL != mDynamicsData )
+ if( mRenderers )
{
- DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s- (\"%s\")\n", __PRETTY_FUNCTION__, mName.c_str());
-
- // ensure dynamics object are disconnected from scene
- DisconnectDynamics();
-
- // delete joint owned by this actor
- while( !mDynamicsData->joints.empty() )
- {
- RemoveDynamicsJoint( mDynamicsData->joints.begin()->second );
- }
-
- // delete other joints referencing this actor
- while( !mDynamicsData->referencedJoints.empty() )
+ RendererIter end = mRenderers->end();
+ for( RendererIter iter = mRenderers->begin(); iter != end; ++iter )
{
- DynamicsJointPtr joint( *(mDynamicsData->referencedJoints.begin()) );
- ActorPtr jointOwner( joint->GetActor( true ) );
- if( jointOwner )
- {
- jointOwner->RemoveDynamicsJoint( joint );
- }
- else
+ if( (*iter).Get() == &renderer )
{
- mDynamicsData->referencedJoints.erase( mDynamicsData->referencedJoints.begin() );
+ mRenderers->erase( iter );
+ RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
+ break;
}
}
- // delete the DynamicsBody object
- mDynamicsData->body.Reset();
-
- // Discard Dynamics data structure
- delete mDynamicsData;
- mDynamicsData = NULL;
}
}
-DynamicsBodyPtr Actor::GetDynamicsBody() const
+void Actor::RemoveRenderer( unsigned int index )
{
- DynamicsBodyPtr body;
-
- if( NULL != mDynamicsData )
+ if( index < GetRendererCount() )
{
- body = mDynamicsData->body;
+ RendererPtr renderer = ( *mRenderers )[ index ];
+ RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.Get()->GetRendererSceneObject() );
+ mRenderers->erase( mRenderers->begin()+index );
}
-
- return body;
}
-DynamicsBodyPtr Actor::EnableDynamics(DynamicsBodyConfigPtr bodyConfig)
+bool Actor::IsOverlay() const
{
- DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s- (\"%s\")\n", __PRETTY_FUNCTION__, mName.c_str());
-
- if( NULL == mDynamicsData )
- {
- mDynamicsData = new DynamicsData( this );
- }
+ return ( DrawMode::OVERLAY_2D == mDrawMode );
+}
- if( !mDynamicsData->body )
+void Actor::SetDrawMode( DrawMode::Type drawMode )
+{
+ // this flag is not animatable so keep the value
+ mDrawMode = drawMode;
+ if( ( NULL != mNode ) && ( drawMode != DrawMode::STENCIL ) )
{
- mDynamicsData->body = new DynamicsBody(mName, bodyConfig, *this, *(const_cast<SceneGraph::Node*>(mNode)) );
-
- if( OnStage() )
- {
- DynamicsWorldPtr world( DynamicsWorld::Get() );
- if( world )
- {
- if( mParent == world->GetRootActor().Get() )
- {
- mDynamicsData->body->Connect( GetEventThreadServices() );
- }
- }
- }
+ // mNode is being used in a separate thread; queue a message to set the value
+ SetDrawModeMessage( GetEventThreadServices(), *mNode, drawMode );
}
-
- return mDynamicsData->body;
}
-DynamicsJointPtr Actor::AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offset )
+DrawMode::Type Actor::GetDrawMode() const
{
- DALI_ASSERT_ALWAYS( attachedActor && "'attachedActor' must be initialized!" );
- return AddDynamicsJoint( attachedActor, offset, ( GetCurrentPosition() + offset ) - attachedActor->GetCurrentPosition() );
+ return mDrawMode;
}
-DynamicsJointPtr Actor::AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offsetA, const Vector3& offsetB )
+bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const
{
- DALI_ASSERT_ALWAYS( attachedActor && "'attachedActor' must be initialized!" );
- DALI_ASSERT_ALWAYS( this != attachedActor.Get() && "Cannot create a joint to oneself!" );
-
- DynamicsJointPtr joint;
-
- DynamicsWorldPtr world( DynamicsWorld::Get() );
-
- if( world )
+ // only valid when on-stage
+ StagePtr stage = Stage::GetCurrent();
+ if( stage && OnStage() )
{
- if( NULL != mDynamicsData )
- {
- DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
+ const RenderTaskList& taskList = stage->GetRenderTaskList();
- if( mDynamicsData->joints.end() != it )
- {
- // use existing joint
- joint = it->second;
- }
+ Vector2 converted( screenX, screenY );
- if( !joint )
+ // do a reverse traversal of all lists (as the default onscreen one is typically the last one)
+ const int taskCount = taskList.GetTaskCount();
+ for( int i = taskCount - 1; i >= 0; --i )
+ {
+ Dali::RenderTask task = taskList.GetTask( i );
+ if( ScreenToLocal( Dali::GetImplementation( task ), localX, localY, screenX, screenY ) )
{
- DynamicsBodyPtr bodyA( GetDynamicsBody() );
- DynamicsBodyPtr bodyB( attachedActor->GetDynamicsBody() );
-
- if( !bodyA )
- {
- bodyA = EnableDynamics( new DynamicsBodyConfig );
- }
-
- if( !bodyB )
- {
- bodyB = attachedActor->EnableDynamics( new DynamicsBodyConfig );
- }
-
- joint = new DynamicsJoint(world, bodyA, bodyB, offsetA, offsetB);
- mDynamicsData->joints[ attachedActor.Get() ] = joint;
-
- if( OnStage() && attachedActor->OnStage() )
- {
- joint->Connect( GetEventThreadServices() );
- }
-
- attachedActor->ReferenceJoint( joint );
-
- attachedActor->OnStageSignal().Connect( mDynamicsData->slotDelegate, &Actor::AttachedActorOnStage );
- attachedActor->OffStageSignal().Connect( mDynamicsData->slotDelegate, &Actor::AttachedActorOffStage );
+ // found a task where this conversion was ok so return
+ return true;
}
}
}
- return joint;
-}
-
-const int Actor::GetNumberOfJoints() const
-{
- return static_cast<int>( NULL != mDynamicsData ? mDynamicsData->joints.size() : 0 );
+ return false;
}
-DynamicsJointPtr Actor::GetDynamicsJointByIndex( const int index ) const
+bool Actor::ScreenToLocal( const RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const
{
- DynamicsJointPtr joint;
-
- if( NULL != mDynamicsData )
+ bool retval = false;
+ // only valid when on-stage
+ if( OnStage() )
{
- if( index >= 0 && index < static_cast<int>(mDynamicsData->joints.size()) )
+ CameraActor* camera = renderTask.GetCameraActor();
+ if( camera )
{
- DynamicsData::JointContainer::const_iterator it( mDynamicsData->joints.begin() );
+ Viewport viewport;
+ renderTask.GetViewport( viewport );
- for( int i = 0; i < index; ++i )
+ // need to translate coordinates to render tasks coordinate space
+ Vector2 converted( screenX, screenY );
+ if( renderTask.TranslateCoordinates( converted ) )
{
- ++it;
+ retval = ScreenToLocal( camera->GetViewMatrix(), camera->GetProjectionMatrix(), viewport, localX, localY, converted.x, converted.y );
}
-
- joint = it->second;
}
}
-
- return joint;
+ return retval;
}
-DynamicsJointPtr Actor::GetDynamicsJoint( ActorPtr attachedActor ) const
+bool Actor::ScreenToLocal( const Matrix& viewMatrix, const Matrix& projectionMatrix, const Viewport& viewport, float& localX, float& localY, float screenX, float screenY ) const
{
- DynamicsJointPtr joint;
-
- if( NULL != mDynamicsData )
+ // Early-out if mNode is NULL
+ if( !OnStage() )
{
- DynamicsData::JointContainer::const_iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
-
- if( mDynamicsData->joints.end() != it )
- {
- // use existing joint
- joint = it->second;
- }
+ return false;
}
- return joint;
-}
-
-void Actor::RemoveDynamicsJoint( DynamicsJointPtr joint )
-{
- if( NULL != mDynamicsData )
- {
- DynamicsData::JointContainer::iterator it( mDynamicsData->joints.begin() );
- DynamicsData::JointContainer::iterator endIt( mDynamicsData->joints.end() );
-
- for(; it != endIt; ++it )
- {
- if( it->second == joint.Get() )
- {
- ActorPtr attachedActor( it->first );
+ // Get the ModelView matrix
+ Matrix modelView;
+ Matrix::Multiply( modelView, mNode->GetWorldMatrix(0), viewMatrix );
- if( OnStage() && attachedActor && attachedActor->OnStage() )
- {
- joint->Disconnect( GetEventThreadServices() );
- }
+ // Calculate the inverted ModelViewProjection matrix; this will be used for 2 unprojects
+ Matrix invertedMvp( false/*don't init*/);
+ Matrix::Multiply( invertedMvp, modelView, projectionMatrix );
+ bool success = invertedMvp.Invert();
- if( attachedActor )
- {
- attachedActor->ReleaseJoint( joint );
- attachedActor->OnStageSignal().Disconnect( mDynamicsData->slotDelegate, &Actor::AttachedActorOnStage );
- attachedActor->OffStageSignal().Disconnect( mDynamicsData->slotDelegate, &Actor::AttachedActorOffStage );
- }
+ // Convert to GL coordinates
+ Vector4 screenPos( screenX - viewport.x, viewport.height - ( screenY - viewport.y ), 0.f, 1.f );
- mDynamicsData->joints.erase(it);
- break;
- }
- }
+ Vector4 nearPos;
+ if( success )
+ {
+ success = Unproject( screenPos, invertedMvp, viewport.width, viewport.height, nearPos );
}
-}
-
-void Actor::ReferenceJoint( DynamicsJointPtr joint )
-{
- DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" );
- if( NULL != mDynamicsData )
+ Vector4 farPos;
+ if( success )
{
- mDynamicsData->referencedJoints.push_back(joint);
+ screenPos.z = 1.0f;
+ success = Unproject( screenPos, invertedMvp, viewport.width, viewport.height, farPos );
}
-}
-void Actor::ReleaseJoint( DynamicsJointPtr joint )
-{
- DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" );
-
- if( NULL != mDynamicsData )
+ if( success )
{
- DynamicsData::ReferencedJointContainer::iterator it( std::find( mDynamicsData->referencedJoints.begin(), mDynamicsData->referencedJoints.end(), joint ) );
-
- if( it != mDynamicsData->referencedJoints.end() )
+ Vector4 local;
+ if( XyPlaneIntersect( nearPos, farPos, local ) )
{
- mDynamicsData->referencedJoints.erase( it );
+ Vector3 size = GetCurrentSize();
+ localX = local.x + size.x * 0.5f;
+ localY = local.y + size.y * 0.5f;
}
- }
-}
-
-void Actor::SetDynamicsRoot(bool flag)
-{
- if( mIsDynamicsRoot != flag )
- {
- mIsDynamicsRoot = flag;
-
- if( OnStage() && mChildren )
+ else
{
- // walk the children connecting or disconnecting any dynamics enabled child from the dynamics simulation
- ActorIter end = mChildren->end();
- for( ActorIter iter = mChildren->begin(); iter != end; ++iter )
- {
- Actor& child = GetImplementation(*iter);
-
- if( child.GetDynamicsBody() )
- {
- if( mIsDynamicsRoot )
- {
- child.ConnectDynamics();
- }
- else
- {
- child.DisconnectDynamics();
- }
- }
- }
+ success = false;
}
}
-}
-bool Actor::IsDynamicsRoot() const
-{
- return mIsDynamicsRoot;
+ return success;
}
-void Actor::AttachedActorOnStage( Dali::Actor actor )
+bool Actor::RaySphereTest( const Vector4& rayOrigin, const Vector4& rayDir ) const
{
- DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s\n", __PRETTY_FUNCTION__);
+ /*
+ http://wiki.cgsociety.org/index.php/Ray_Sphere_Intersection
- if( OnStage() )
- {
- ActorPtr attachedActor( &GetImplementation(actor) );
+ Mathematical Formulation
- DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" );
- if( NULL != mDynamicsData )
- {
- DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
- if( mDynamicsData->joints.end() != it )
- {
- DynamicsJointPtr joint( it->second );
- joint->Connect( GetEventThreadServices() );
- }
- }
- }
-}
+ Given the above mentioned sphere, a point 'p' lies on the surface of the sphere if
-void Actor::AttachedActorOffStage( Dali::Actor actor )
-{
- DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s\n", __PRETTY_FUNCTION__);
+ ( p - c ) dot ( p - c ) = r^2
- if( OnStage() )
- {
- ActorPtr attachedActor( &GetImplementation(actor) );
+ Given a ray with a point of origin 'o', and a direction vector 'd':
- DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" );
- if( NULL != mDynamicsData )
- {
- DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
- if( mDynamicsData->joints.end() != it )
- {
- DynamicsJointPtr joint( it->second );
- joint->Disconnect( GetEventThreadServices() );
- }
- }
- }
-}
+ ray(t) = o + td, t >= 0
-void Actor::ConnectDynamics()
-{
- if( NULL != mDynamicsData && mDynamicsData->body )
- {
- if( OnStage() && mParent && mParent->IsDynamicsRoot() )
- {
- mDynamicsData->body->Connect( GetEventThreadServices() );
+ we can find the t at which the ray intersects the sphere by setting ray(t) equal to 'p'
- // Connect all joints where attachedActor is also on stage
- if( !mDynamicsData->joints.empty() )
- {
- DynamicsData::JointContainer::iterator it( mDynamicsData->joints.begin() );
- DynamicsData::JointContainer::iterator endIt( mDynamicsData->joints.end() );
-
- for(; it != endIt; ++it )
- {
- Actor* attachedActor( it->first );
- if( NULL != attachedActor && attachedActor->OnStage() )
- {
- DynamicsJointPtr joint( it->second );
-
- joint->Connect( GetEventThreadServices() );
- }
- }
- }
- }
- }
-}
-
-void Actor::DisconnectDynamics()
-{
- if( NULL != mDynamicsData && mDynamicsData->body )
- {
- if( OnStage() )
- {
- mDynamicsData->body->Disconnect( GetEventThreadServices() );
-
- // Disconnect all joints
- if( !mDynamicsData->joints.empty() )
- {
- DynamicsData::JointContainer::iterator it( mDynamicsData->joints.begin() );
- DynamicsData::JointContainer::iterator endIt( mDynamicsData->joints.end() );
-
- for(; it != endIt; ++it )
- {
- DynamicsJointPtr joint( it->second );
-
- joint->Disconnect( GetEventThreadServices() );
- }
- }
- }
- }
-}
-
-#endif // DYNAMICS_SUPPORT
-
-void Actor::SetOverlay( bool enable )
-{
- // Setting STENCIL will override OVERLAY
- if( DrawMode::STENCIL != mDrawMode )
- {
- SetDrawMode( enable ? DrawMode::OVERLAY : DrawMode::NORMAL );
- }
-}
-
-bool Actor::IsOverlay() const
-{
- return ( DrawMode::OVERLAY == mDrawMode );
-}
-
-void Actor::SetDrawMode( DrawMode::Type drawMode )
-{
- // this flag is not animatable so keep the value
- mDrawMode = drawMode;
- if( NULL != mNode )
- {
- // mNode is being used in a separate thread; queue a message to set the value
- SetDrawModeMessage( GetEventThreadServices(), *mNode, drawMode );
- }
-}
-
-DrawMode::Type Actor::GetDrawMode() const
-{
- return mDrawMode;
-}
-
-bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const
-{
- // only valid when on-stage
- if( OnStage() )
- {
- const RenderTaskList& taskList = Stage::GetCurrent()->GetRenderTaskList();
-
- Vector2 converted( screenX, screenY );
-
- // do a reverse traversal of all lists (as the default onscreen one is typically the last one)
- const int taskCount = taskList.GetTaskCount();
- for( int i = taskCount - 1; i >= 0; --i )
- {
- Dali::RenderTask task = taskList.GetTask( i );
- if( ScreenToLocal( Dali::GetImplementation( task ), localX, localY, screenX, screenY ) )
- {
- // found a task where this conversion was ok so return
- return true;
- }
- }
- }
- return false;
-}
-
-bool Actor::ScreenToLocal( RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const
-{
- bool retval = false;
- // only valid when on-stage
- if( OnStage() )
- {
- CameraActor* camera = renderTask.GetCameraActor();
- if( camera )
- {
- Viewport viewport;
- renderTask.GetViewport( viewport );
-
- // need to translate coordinates to render tasks coordinate space
- Vector2 converted( screenX, screenY );
- if( renderTask.TranslateCoordinates( converted ) )
- {
- retval = ScreenToLocal( camera->GetViewMatrix(), camera->GetProjectionMatrix(), viewport, localX, localY, converted.x, converted.y );
- }
- }
- }
- return retval;
-}
-
-bool Actor::ScreenToLocal( const Matrix& viewMatrix, const Matrix& projectionMatrix, const Viewport& viewport, float& localX, float& localY, float screenX, float screenY ) const
-{
- // Early-out if mNode is NULL
- if( !OnStage() )
- {
- return false;
- }
-
- BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
-
- // Calculate the ModelView matrix
- Matrix modelView( false/*don't init*/);
- // need to use the components as world matrix is only updated for actors that need it
- modelView.SetTransformComponents( mNode->GetWorldScale( bufferIndex ), mNode->GetWorldOrientation( bufferIndex ), mNode->GetWorldPosition( bufferIndex ) );
- Matrix::Multiply( modelView, modelView, viewMatrix );
-
- // Calculate the inverted ModelViewProjection matrix; this will be used for 2 unprojects
- Matrix invertedMvp( false/*don't init*/);
- Matrix::Multiply( invertedMvp, modelView, projectionMatrix );
- bool success = invertedMvp.Invert();
-
- // Convert to GL coordinates
- Vector4 screenPos( screenX - viewport.x, viewport.height - ( screenY - viewport.y ), 0.f, 1.f );
-
- Vector4 nearPos;
- if( success )
- {
- success = Unproject( screenPos, invertedMvp, viewport.width, viewport.height, nearPos );
- }
-
- Vector4 farPos;
- if( success )
- {
- screenPos.z = 1.0f;
- success = Unproject( screenPos, invertedMvp, viewport.width, viewport.height, farPos );
- }
-
- if( success )
- {
- Vector4 local;
- if( XyPlaneIntersect( nearPos, farPos, local ) )
- {
- Vector3 size = GetCurrentSize();
- localX = local.x + size.x * 0.5f;
- localY = local.y + size.y * 0.5f;
- }
- else
- {
- success = false;
- }
- }
-
- return success;
-}
-
-bool Actor::RaySphereTest( const Vector4& rayOrigin, const Vector4& rayDir ) const
-{
- /*
- http://wiki.cgsociety.org/index.php/Ray_Sphere_Intersection
-
- Mathematical Formulation
-
- Given the above mentioned sphere, a point 'p' lies on the surface of the sphere if
-
- ( p - c ) dot ( p - c ) = r^2
-
- Given a ray with a point of origin 'o', and a direction vector 'd':
-
- ray(t) = o + td, t >= 0
-
- we can find the t at which the ray intersects the sphere by setting ray(t) equal to 'p'
-
- (o + td - c ) dot ( o + td - c ) = r^2
+ (o + td - c ) dot ( o + td - c ) = r^2
To solve for t we first expand the above into a more recognisable quadratic equation form
return ( b2 * b2 - a * c ) >= 0.f;
}
-bool Actor::RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vector4& hitPointLocal, float& distance ) const
+bool Actor::RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vector2& hitPointLocal, float& distance ) const
{
bool hit = false;
- if( OnStage() &&
- NULL != mNode )
+ if( OnStage() && NULL != mNode )
{
- BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
-
// Transforms the ray to the local reference system.
-
// Calculate the inverse of Model matrix
Matrix invModelMatrix( false/*don't init*/);
- // need to use the components as world matrix is only updated for actors that need it
- invModelMatrix.SetInverseTransformComponents( mNode->GetWorldScale( bufferIndex ), mNode->GetWorldOrientation( bufferIndex ), mNode->GetWorldPosition( bufferIndex ) );
+
+ BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
+ invModelMatrix = mNode->GetWorldMatrix(0);
+ invModelMatrix.Invert();
Vector4 rayOriginLocal( invModelMatrix * rayOrigin );
Vector4 rayDirLocal( invModelMatrix * rayDir - invModelMatrix.GetTranslation() );
bool Actor::GetTouchRequired() const
{
- return !mTouchedSignal.Empty() || mDerivedRequiresTouch;
+ return !mTouchedSignal.Empty() || !mTouchSignal.Empty() || mDerivedRequiresTouch;
}
bool Actor::GetHoverRequired() const
return !mHoveredSignal.Empty() || mDerivedRequiresHover;
}
-bool Actor::GetMouseWheelEventRequired() const
+bool Actor::GetWheelEventRequired() const
{
- return !mMouseWheelEventSignal.Empty() || mDerivedRequiresMouseWheelEvent;
+ return !mWheelEventSignal.Empty() || mDerivedRequiresWheelEvent;
}
bool Actor::IsHittable() const
return mGestureData && mGestureData->IsGestureRequred( type );
}
-bool Actor::EmitTouchEventSignal( const TouchEvent& event )
+bool Actor::EmitTouchEventSignal( const TouchEvent& event, const Dali::TouchData& touch )
{
bool consumed = false;
+ if( !mTouchSignal.Empty() )
+ {
+ Dali::Actor handle( this );
+ consumed = mTouchSignal.Emit( handle, touch );
+ }
+
if( !mTouchedSignal.Empty() )
{
Dali::Actor handle( this );
- consumed = mTouchedSignal.Emit( handle, event );
+ consumed |= mTouchedSignal.Emit( handle, event );
}
if( !consumed )
{
// Notification for derived classes
- consumed = OnTouchEvent( event );
+ consumed = OnTouchEvent( event ); // TODO
}
return consumed;
return consumed;
}
-bool Actor::EmitMouseWheelEventSignal( const MouseWheelEvent& event )
+bool Actor::EmitWheelEventSignal( const WheelEvent& event )
{
bool consumed = false;
- if( !mMouseWheelEventSignal.Empty() )
+ if( !mWheelEventSignal.Empty() )
{
Dali::Actor handle( this );
- consumed = mMouseWheelEventSignal.Emit( handle, event );
+ consumed = mWheelEventSignal.Emit( handle, event );
}
if( !consumed )
{
// Notification for derived classes
- consumed = OnMouseWheelEvent( event );
+ consumed = OnWheelEvent( event );
}
return consumed;
}
+void Actor::EmitVisibilityChangedSignal( bool visible, DevelActor::VisibilityChange::Type type )
+{
+ if( ! mVisibilityChangedSignal.Empty() )
+ {
+ Dali::Actor handle( this );
+ mVisibilityChangedSignal.Emit( handle, visible, type );
+ }
+}
+
+void Actor::EmitLayoutDirectionChangedSignal( LayoutDirection::Type type )
+{
+ if( ! mLayoutDirectionChangedSignal.Empty() )
+ {
+ Dali::Actor handle( this );
+ mLayoutDirectionChangedSignal.Emit( handle, type );
+ }
+}
+
Dali::Actor::TouchSignalType& Actor::TouchedSignal()
{
return mTouchedSignal;
}
+Dali::Actor::TouchDataSignalType& Actor::TouchSignal()
+{
+ return mTouchSignal;
+}
+
Dali::Actor::HoverSignalType& Actor::HoveredSignal()
{
return mHoveredSignal;
}
-Dali::Actor::MouseWheelEventSignalType& Actor::MouseWheelEventSignal()
+Dali::Actor::WheelEventSignalType& Actor::WheelEventSignal()
{
- return mMouseWheelEventSignal;
+ return mWheelEventSignal;
}
Dali::Actor::OnStageSignalType& Actor::OnStageSignal()
return mOnRelayoutSignal;
}
+DevelActor::VisibilityChangedSignalType& Actor::VisibilityChangedSignal()
+{
+ return mVisibilityChangedSignal;
+}
+
+Dali::Actor::LayoutDirectionChangedSignalType& Actor::LayoutDirectionChangedSignal()
+{
+ return mLayoutDirectionChangedSignal;
+}
+
bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
{
bool connected( true );
- Actor* actor = dynamic_cast< Actor* >( object );
+ Actor* actor = static_cast< Actor* >( object ); // TypeRegistry guarantees that this is the correct type.
- if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCHED ) ) // don't want to convert char* to string
+ if( 0 == signalName.compare( SIGNAL_TOUCHED ) )
{
actor->TouchedSignal().Connect( tracker, functor );
}
- else if( 0 == strcmp( signalName.c_str(), SIGNAL_HOVERED ) )
+ else if( 0 == signalName.compare( SIGNAL_HOVERED ) )
{
actor->HoveredSignal().Connect( tracker, functor );
}
- else if( 0 == strcmp( signalName.c_str(), SIGNAL_MOUSE_WHEEL_EVENT ) )
+ else if( 0 == signalName.compare( SIGNAL_WHEEL_EVENT ) )
{
- actor->MouseWheelEventSignal().Connect( tracker, functor );
+ actor->WheelEventSignal().Connect( tracker, functor );
}
- else if( 0 == strcmp( signalName.c_str(), SIGNAL_ON_STAGE ) )
+ else if( 0 == signalName.compare( SIGNAL_ON_STAGE ) )
{
actor->OnStageSignal().Connect( tracker, functor );
}
- else if( 0 == strcmp( signalName.c_str(), SIGNAL_OFF_STAGE ) )
+ else if( 0 == signalName.compare( SIGNAL_OFF_STAGE ) )
{
actor->OffStageSignal().Connect( tracker, functor );
}
+ else if( 0 == signalName.compare( SIGNAL_ON_RELAYOUT ) )
+ {
+ actor->OnRelayoutSignal().Connect( tracker, functor );
+ }
+ else if( 0 == signalName.compare( SIGNAL_TOUCH ) )
+ {
+ actor->TouchSignal().Connect( tracker, functor );
+ }
else
{
// signalName does not match any signal
Actor::Actor( DerivedType derivedType )
: mParent( NULL ),
mChildren( NULL ),
+ mRenderers( NULL ),
mNode( NULL ),
mParentOrigin( NULL ),
mAnchorPoint( NULL ),
mRelayoutData( NULL ),
-#ifdef DYNAMICS_SUPPORT
- mDynamicsData( NULL ),
-#endif
- mGestureData( NULL ), mAttachment(), mTargetSize( 0.0f, 0.0f, 0.0f ), mName(), mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
- mIsRoot( ROOT_LAYER == derivedType ), mIsRenderable( RENDERABLE == derivedType ), mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ), mIsOnStage( false ), mIsDynamicsRoot( false ), mSensitive( true ), mLeaveRequired( false ), mKeyboardFocusable( false ), mDerivedRequiresTouch( false ), mDerivedRequiresHover( false ), mDerivedRequiresMouseWheelEvent( false ), mOnStageSignalled( false ), mInheritOrientation( true ), mInheritScale( true ), mDrawMode( DrawMode::NORMAL ), mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ), mColorMode( Node::DEFAULT_COLOR_MODE )
+ mGestureData( NULL ),
+ mTargetOrientation( Quaternion::IDENTITY ),
+ mTargetColor( Color::WHITE ),
+ mTargetSize( Vector3::ZERO ),
+ mTargetPosition( Vector3::ZERO ),
+ mTargetScale( Vector3::ONE ),
+ mName(),
+ mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
+ mSortedDepth( 0u ),
+ mDepth( 0u ),
+ mIsRoot( ROOT_LAYER == derivedType ),
+ mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ),
+ mIsOnStage( false ),
+ mSensitive( true ),
+ mLeaveRequired( false ),
+ mKeyboardFocusable( false ),
+ mDerivedRequiresTouch( false ),
+ mDerivedRequiresHover( false ),
+ mDerivedRequiresWheelEvent( false ),
+ mOnStageSignalled( false ),
+ mInsideOnSizeSet( false ),
+ mInheritPosition( true ),
+ mInheritOrientation( true ),
+ mInheritScale( true ),
+ mPositionUsesAnchorPoint( true ),
+ mVisible( true ),
+ mInheritLayoutDirection( true ),
+ mLayoutDirection( LayoutDirection::LEFT_TO_RIGHT ),
+ mDrawMode( DrawMode::NORMAL ),
+ mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ),
+ mColorMode( Node::DEFAULT_COLOR_MODE ),
+ mClippingMode( ClippingMode::DISABLED )
{
}
void Actor::Initialize()
{
- // Node creation
- SceneGraph::Node* node = CreateNode();
-
- AddNodeMessage( GetEventThreadServices().GetUpdateManager(), *node ); // Pass ownership to scene-graph
- mNode = node; // Keep raw-pointer to Node
+ // Node creation, keep raw-pointer to Node for messaging
+ mNode = CreateNode();
+ OwnerPointer< SceneGraph::Node > transferOwnership( const_cast< SceneGraph::Node* >( mNode ) );
+ AddNodeMessage( GetEventThreadServices().GetUpdateManager(), transferOwnership );
OnInitialize();
ActorConstIter endIter = mChildren->end();
for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
{
- Actor& actor = GetImplementation( *iter );
- actor.SetParent( NULL );
+ (*iter)->SetParent( NULL );
}
}
delete mChildren;
+ delete mRenderers;
// Guard to allow handle destruction after Core has been destroyed
if( EventThreadServices::IsCoreRunning() )
GetEventThreadServices().UnregisterObject( this );
}
-#ifdef DYNAMICS_SUPPORT
- // Cleanup dynamics
- delete mDynamicsData;
-#endif
-
// Cleanup optional gesture data
delete mGestureData;
}
}
-void Actor::ConnectToStage( int index )
+void Actor::ConnectToStage( unsigned int parentDepth )
{
- // This container is used instead of walking the Actor hierachy.
- // It protects us when the Actor hierachy is modified during OnStageConnectionExternal callbacks.
+ // This container is used instead of walking the Actor hierarchy.
+ // It protects us when the Actor hierarchy is modified during OnStageConnectionExternal callbacks.
ActorContainer connectionList;
- // This stage is atomic i.e. not interrupted by user callbacks
- RecursiveConnectToStage( connectionList, index );
+ StagePtr stage = Stage::GetCurrent();
+ if( stage )
+ {
+ stage->RequestRebuildDepthTree();
+ }
+
+ // This stage is atomic i.e. not interrupted by user callbacks.
+ RecursiveConnectToStage( connectionList, parentDepth + 1 );
// Notify applications about the newly connected actors.
const ActorIter endIter = connectionList.end();
for( ActorIter iter = connectionList.begin(); iter != endIter; ++iter )
{
- Actor& actor = GetImplementation( *iter );
- actor.NotifyStageConnection();
+ (*iter)->NotifyStageConnection();
}
RelayoutRequest();
}
-void Actor::RecursiveConnectToStage( ActorContainer& connectionList, int index )
+void Actor::RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth )
{
DALI_ASSERT_ALWAYS( !OnStage() );
mIsOnStage = true;
+ mDepth = depth;
- ConnectToSceneGraph( index );
+ ConnectToSceneGraph();
// Notification for internal derived classes
OnStageConnectionInternal();
// This stage is atomic; avoid emitting callbacks until all Actors are connected
- connectionList.push_back( Dali::Actor( this ) );
+ connectionList.push_back( ActorPtr( this ) );
// Recursively connect children
if( mChildren )
ActorConstIter endIter = mChildren->end();
for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
{
- Actor& actor = GetImplementation( *iter );
- actor.RecursiveConnectToStage( connectionList );
+ (*iter)->RecursiveConnectToStage( 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 resursive; the child calls ConnectToStage() for its children.
+ * This is recursive; the child calls ConnectToStage() for its children.
*/
-void Actor::ConnectToSceneGraph( int index )
+void Actor::ConnectToSceneGraph()
{
DALI_ASSERT_DEBUG( mNode != NULL); DALI_ASSERT_DEBUG( mParent != NULL); DALI_ASSERT_DEBUG( mParent->mNode != NULL );
if( NULL != mNode )
{
// Reparent Node in next Update
- ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode, index );
- }
-
- // Notify attachment
- if( mAttachment )
- {
- mAttachment->Connect();
+ ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode );
}
-#ifdef DYNAMICS_SUPPORT
- // Notify dynamics
- if( NULL != mDynamicsData )
- {
- ConnectDynamics();
- }
-#endif
+ // Request relayout on all actors that are added to the scenegraph
+ RelayoutRequest();
// Notification for Object::Observers
OnSceneObjectAdd();
if( OnStage() && !mOnStageSignalled )
{
// Notification for external (CustomActor) derived classes
- OnStageConnectionExternal();
+ OnStageConnectionExternal( mDepth );
if( !mOnStageSignal.Empty() )
{
// It protects us when the Actor hierachy is modified during OnStageDisconnectionExternal callbacks.
ActorContainer disconnectionList;
+ StagePtr stage = Stage::GetCurrent();
+ if( stage )
+ {
+ stage->RequestRebuildDepthTree();
+ }
+
// This stage is atomic i.e. not interrupted by user callbacks
RecursiveDisconnectFromStage( disconnectionList );
const ActorIter endIter = disconnectionList.end();
for( ActorIter iter = disconnectionList.begin(); iter != endIter; ++iter )
{
- Actor& actor = GetImplementation( *iter );
- actor.NotifyStageDisconnection();
+ (*iter)->NotifyStageDisconnection();
}
}
ActorConstIter endIter = mChildren->end();
for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
{
- Actor& actor = GetImplementation( *iter );
- actor.RecursiveDisconnectFromStage( disconnectionList );
+ (*iter)->RecursiveDisconnectFromStage( disconnectionList );
}
}
// This stage is atomic; avoid emitting callbacks until all Actors are disconnected
- disconnectionList.push_back( Dali::Actor( this ) );
+ disconnectionList.push_back( ActorPtr( this ) );
// Notification for internal derived classes
OnStageDisconnectionInternal();
{
// Notification for Object::Observers
OnSceneObjectRemove();
-
- // Notify attachment
- if( mAttachment )
- {
- mAttachment->Disconnect();
- }
-
-#ifdef DYNAMICS_SUPPORT
- // Notify dynamics
- if( NULL != mDynamicsData )
- {
- DisconnectDynamics();
- }
-#endif
}
void Actor::NotifyStageDisconnection()
{
bool connected( false );
- if( OnStage() &&
- NULL != mNode )
+ if( OnStage() && ( NULL != mNode ) )
{
- if( mNode->IsRoot() || mNode->GetParent() )
+ if( IsRoot() || mNode->GetParent() )
{
connected = true;
}
return connected;
}
+// This method initiates traversal of the actor tree using depth-first
+// traversal to set a depth index based on traversal order. It sends a
+// single message to update manager to update all the actor's nodes in
+// this tree with the depth index. The sceneGraphNodeDepths vector's
+// elements are ordered by depth, and could be used to reduce sorting
+// in the update thread.
+void Actor::RebuildDepthTree()
+{
+ DALI_LOG_TIMER_START(depthTimer);
+
+ // Vector of scene-graph nodes and their depths to send to UpdateManager
+ // in a single message
+ OwnerPointer<SceneGraph::NodeDepths> sceneGraphNodeDepths( new SceneGraph::NodeDepths() );
+
+ int depthIndex = 1;
+ DepthTraverseActorTree( sceneGraphNodeDepths, depthIndex );
+
+ SetDepthIndicesMessage( GetEventThreadServices().GetUpdateManager(), sceneGraphNodeDepths );
+ DALI_LOG_TIMER_END(depthTimer, gLogFilter, Debug::Concise, "Depth tree traversal time: ");
+}
+
+void Actor::DepthTraverseActorTree( OwnerPointer<SceneGraph::NodeDepths>& sceneGraphNodeDepths, int& depthIndex )
+{
+ mSortedDepth = depthIndex * DevelLayer::SIBLING_ORDER_MULTIPLIER;
+ sceneGraphNodeDepths->Add( const_cast<SceneGraph::Node*>( mNode ), mSortedDepth );
+
+ // Create/add to children of this node
+ if( mChildren )
+ {
+ for( ActorContainer::iterator it = mChildren->begin(); it != mChildren->end(); ++it )
+ {
+ Actor* childActor = (*it).Get();
+ ++depthIndex;
+ childActor->DepthTraverseActorTree( sceneGraphNodeDepths, depthIndex );
+ }
+ }
+}
+
unsigned int Actor::GetDefaultPropertyCount() const
{
return DEFAULT_PROPERTY_COUNT;
void Actor::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
{
- indices.reserve( DEFAULT_PROPERTY_COUNT );
+ indices.Reserve( DEFAULT_PROPERTY_COUNT );
for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
{
- indices.push_back( i );
+ indices.PushBack( i );
}
}
for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
{
const Internal::PropertyDetails* property = &DEFAULT_PROPERTY_DETAILS[ i ];
- if( 0 == strcmp( name.c_str(), property->name ) ) // dont want to convert rhs to string
+ if( 0 == name.compare( property->name ) )
{
index = i;
break;
{
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_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
{
- SetOpacity( property.Get< float >() );
+ float value;
+ if( property.Get( value ) )
+ {
+ SetOpacity( value );
+ }
break;
}
break;
}
- case Dali::Actor::Property::INHERIT_ORIENTATION:
+ case Dali::Actor::Property::INHERIT_POSITION:
+ {
+ SetInheritPosition( property.Get< bool >() );
+ break;
+ }
+
+ case Dali::Actor::Property::INHERIT_ORIENTATION:
{
SetInheritOrientation( property.Get< bool >() );
break;
case Dali::Actor::Property::COLOR_MODE:
{
- SetColorMode( Scripting::GetColorMode( property.Get< std::string >() ) );
+ ColorMode mode = mColorMode;
+ if ( Scripting::GetEnumerationProperty< ColorMode >( property, 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 = mPositionInheritanceMode;
+ if( Scripting::GetEnumerationProperty< PositionInheritanceMode >( property, 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 >() ) );
- break;
- }
-
- case Dali::Actor::Property::SIZE_MODE:
- {
- SetSizeMode( Scripting::GetEnumeration< SizeMode >( property.Get< std::string >().c_str(), SizeModeTable, SizeModeTableCount ) );
+ DrawMode::Type mode = mDrawMode;
+ if( Scripting::GetEnumerationProperty< DrawMode::Type >( property, DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT, mode ) )
+ {
+ SetDrawMode( mode );
+ }
break;
}
break;
}
- case Dali::Actor::Property::RELAYOUT_ENABLED:
- {
- SetRelayoutEnabled( property.Get< bool >() );
- break;
- }
-
case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
{
- SetResizePolicy( Scripting::GetEnumeration< ResizePolicy >( property.Get< std::string >().c_str(), ResizePolicyTable, ResizePolicyTableCount ), WIDTH );
+ ResizePolicy::Type type = static_cast< ResizePolicy::Type >( -1 ); // Set to invalid number so it definitely gets set.
+ if( Scripting::GetEnumerationProperty< ResizePolicy::Type >( property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )
+ {
+ SetResizePolicy( type, Dimension::WIDTH );
+ }
break;
}
case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
{
- SetResizePolicy( Scripting::GetEnumeration< ResizePolicy >( property.Get< std::string >().c_str(), ResizePolicyTable, ResizePolicyTableCount ), HEIGHT );
+ ResizePolicy::Type type = static_cast< ResizePolicy::Type >( -1 ); // Set to invalid number so it definitely gets set.
+ if( Scripting::GetEnumerationProperty< ResizePolicy::Type >( property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )
+ {
+ SetResizePolicy( type, Dimension::HEIGHT );
+ }
break;
}
case Dali::Actor::Property::SIZE_SCALE_POLICY:
{
- SetSizeScalePolicy( Scripting::GetEnumeration< SizeScalePolicy >( property.Get< std::string >().c_str(), SizeScalePolicyTable, SizeScalePolicyTableCount ) );
+ SizeScalePolicy::Type type;
+ if( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT, type ) )
+ {
+ SetSizeScalePolicy( type );
+ }
break;
}
{
if( property.Get< bool >() )
{
- SetDimensionDependency( WIDTH, HEIGHT );
+ SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::WIDTH );
}
break;
}
{
if( property.Get< bool >() )
{
- SetDimensionDependency( HEIGHT, WIDTH );
+ SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::HEIGHT );
}
break;
}
case Dali::Actor::Property::PADDING:
{
Vector4 padding = property.Get< Vector4 >();
- SetPadding( Vector2( padding.x, padding.y ), WIDTH );
- SetPadding( Vector2( padding.z, padding.w ), HEIGHT );
+ SetPadding( Vector2( padding.x, padding.y ), Dimension::WIDTH );
+ SetPadding( Vector2( padding.z, padding.w ), Dimension::HEIGHT );
break;
}
case Dali::Actor::Property::MINIMUM_SIZE:
{
Vector2 size = property.Get< Vector2 >();
- SetMinimumSize( size.x, WIDTH );
- SetMinimumSize( size.y, HEIGHT );
+ SetMinimumSize( size.x, Dimension::WIDTH );
+ SetMinimumSize( size.y, Dimension::HEIGHT );
break;
}
case Dali::Actor::Property::MAXIMUM_SIZE:
{
Vector2 size = property.Get< Vector2 >();
- SetMaximumSize( size.x, WIDTH );
- SetMaximumSize( size.y, HEIGHT );
+ SetMaximumSize( size.x, Dimension::WIDTH );
+ SetMaximumSize( size.y, Dimension::HEIGHT );
break;
}
- case Dali::Actor::Property::PREFERRED_SIZE:
+ case Dali::DevelActor::Property::SIBLING_ORDER:
{
- Vector2 size = property.Get< Vector2 >();
- SetPreferredSize( size );
+ int value;
+
+ if( property.Get( value ) )
+ {
+ SetSiblingOrder( value );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::CLIPPING_MODE:
+ {
+ ClippingMode::Type convertedValue = mClippingMode;
+ if( Scripting::GetEnumerationProperty< ClippingMode::Type >( property, CLIPPING_MODE_TABLE, CLIPPING_MODE_TABLE_COUNT, convertedValue ) )
+ {
+ mClippingMode = convertedValue;
+ if( NULL != mNode )
+ {
+ SetClippingModeMessage( GetEventThreadServices(), *mNode, mClippingMode );
+ }
+ }
+ break;
+ }
+
+ case Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT:
+ {
+ bool value = false;
+ if( property.Get( value ) && value != mPositionUsesAnchorPoint )
+ {
+ mPositionUsesAnchorPoint = value;
+ if( NULL != mNode )
+ {
+ SetPositionUsesAnchorPointMessage( GetEventThreadServices(), *mNode, mPositionUsesAnchorPoint );
+ }
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::LAYOUT_DIRECTION:
+ {
+ Dali::LayoutDirection::Type direction = mLayoutDirection;
+ mInheritLayoutDirection = false;
+
+ if( Scripting::GetEnumerationProperty< LayoutDirection::Type >( property, LAYOUT_DIRECTION_TABLE, LAYOUT_DIRECTION_TABLE_COUNT, direction ) )
+ {
+ InheritLayoutDirectionRecursively( this, direction, true );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION:
+ {
+ bool value = false;
+ if( property.Get( value ) )
+ {
+ SetInheritLayoutDirection( value );
+ }
break;
}
// TODO: This method needs to be removed
void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value )
{
- OnPropertySet( index, value );
-
- switch( entry.type )
+ switch( entry.GetType() )
{
case Property::BOOLEAN:
{
break;
}
- case Property::FLOAT:
+ case Property::INTEGER:
{
- const AnimatableProperty< float >* property = dynamic_cast< const AnimatableProperty< float >* >( entry.GetSceneGraphProperty() );
+ const AnimatableProperty< int >* property = dynamic_cast< const AnimatableProperty< int >* >( entry.GetSceneGraphProperty() );
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<float>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<float>::Bake, value.Get<float>() );
+ SceneGraph::NodePropertyMessage<int>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<int>::Bake, value.Get<int>() );
break;
}
- case Property::INTEGER:
+ case Property::FLOAT:
{
- const AnimatableProperty< int >* property = dynamic_cast< const AnimatableProperty< int >* >( entry.GetSceneGraphProperty() );
+ 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<int>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<int>::Bake, value.Get<int>() );
+ SceneGraph::NodePropertyMessage<float>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<float>::Bake, value.Get<float>() );
break;
}
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
+ if(entry.componentIndex == 0)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::BakeX, value.Get<float>() );
+ }
+ else if(entry.componentIndex == 1)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::BakeY, value.Get<float>() );
+ }
+ else
+ {
+ SceneGraph::NodePropertyMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
+ }
break;
}
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
+ if(entry.componentIndex == 0)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::BakeX, value.Get<float>() );
+ }
+ else if(entry.componentIndex == 1)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::BakeY, value.Get<float>() );
+ }
+ else if(entry.componentIndex == 2)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::BakeZ, value.Get<float>() );
+ }
+ else
+ {
+ SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
+ }
break;
}
DALI_ASSERT_DEBUG( NULL != property );
// property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
+ if(entry.componentIndex == 0)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::BakeX, value.Get<float>() );
+ }
+ else if(entry.componentIndex == 1)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::BakeY, value.Get<float>() );
+ }
+ else if(entry.componentIndex == 2)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::BakeZ, value.Get<float>() );
+ }
+ else if(entry.componentIndex == 3)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::BakeW, value.Get<float>() );
+ }
+ else
+ {
+ SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
+ }
break;
}
default:
{
- DALI_ASSERT_ALWAYS( false && "Property type enumeration out of bounds" ); // should not come here
- break;
+ // nothing to do for other types
}
- }
+ } // entry.GetType
}
Property::Value Actor::GetDefaultProperty( Property::Index index ) const
{
Property::Value value;
- switch( index )
+ if( ! GetCachedPropertyValue( index, value ) )
{
- case Dali::Actor::Property::PARENT_ORIGIN:
- {
- value = GetCurrentParentOrigin();
- break;
- }
-
- case Dali::Actor::Property::PARENT_ORIGIN_X:
- {
- value = GetCurrentParentOrigin().x;
- break;
- }
+ // If property value is not stored in the event-side, then it must be a scene-graph only property
+ GetCurrentPropertyValue( index, value );
+ }
- case Dali::Actor::Property::PARENT_ORIGIN_Y:
- {
- value = GetCurrentParentOrigin().y;
- break;
- }
+ return value;
+}
- case Dali::Actor::Property::PARENT_ORIGIN_Z:
- {
- value = GetCurrentParentOrigin().z;
- break;
- }
+Property::Value Actor::GetDefaultPropertyCurrentValue( Property::Index index ) const
+{
+ Property::Value value;
- case Dali::Actor::Property::ANCHOR_POINT:
- {
- value = GetCurrentAnchorPoint();
- break;
- }
+ if( ! GetCurrentPropertyValue( index, value ) )
+ {
+ // If unable to retrieve scene-graph property value, then it must be an event-side only property
+ GetCachedPropertyValue( index, value );
+ }
- case Dali::Actor::Property::ANCHOR_POINT_X:
- {
- value = GetCurrentAnchorPoint().x;
- break;
- }
+ return value;
+}
- case Dali::Actor::Property::ANCHOR_POINT_Y:
+void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType )
+{
+ switch( animationType )
+ {
+ case Animation::TO:
+ case Animation::BETWEEN:
{
- value = GetCurrentAnchorPoint().y;
- break;
- }
+ switch( index )
+ {
+ case Dali::Actor::Property::SIZE:
+ {
+ if( value.Get( mTargetSize ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
- case Dali::Actor::Property::ANCHOR_POINT_Z:
- {
- value = GetCurrentAnchorPoint().z;
- break;
- }
+ case Dali::Actor::Property::SIZE_WIDTH:
+ {
+ if( value.Get( mTargetSize.width ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
- case Dali::Actor::Property::SIZE:
- {
- value = GetCurrentSize();
- break;
- }
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ {
+ if( value.Get( mTargetSize.height ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
- case Dali::Actor::Property::SIZE_WIDTH:
- {
- value = GetCurrentSize().width;
- break;
- }
+ case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ if( value.Get( mTargetSize.depth ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
- case Dali::Actor::Property::SIZE_HEIGHT:
- {
- value = GetCurrentSize().height;
- break;
- }
+ case Dali::Actor::Property::POSITION:
+ {
+ value.Get( mTargetPosition );
+ break;
+ }
- case Dali::Actor::Property::SIZE_DEPTH:
- {
- value = GetCurrentSize().depth;
- break;
- }
+ case Dali::Actor::Property::POSITION_X:
+ {
+ value.Get( mTargetPosition.x );
+ break;
+ }
- case Dali::Actor::Property::POSITION:
- {
- value = GetCurrentPosition();
- break;
- }
+ case Dali::Actor::Property::POSITION_Y:
+ {
+ value.Get( mTargetPosition.y );
+ break;
+ }
- case Dali::Actor::Property::POSITION_X:
- {
- value = GetCurrentPosition().x;
- break;
- }
+ case Dali::Actor::Property::POSITION_Z:
+ {
+ value.Get( mTargetPosition.z );
+ break;
+ }
- case Dali::Actor::Property::POSITION_Y:
- {
- value = GetCurrentPosition().y;
- break;
- }
+ case Dali::Actor::Property::ORIENTATION:
+ {
+ value.Get( mTargetOrientation );
+ break;
+ }
- case Dali::Actor::Property::POSITION_Z:
- {
- value = GetCurrentPosition().z;
- break;
- }
+ case Dali::Actor::Property::SCALE:
+ {
+ value.Get( mTargetScale );
+ break;
+ }
- case Dali::Actor::Property::WORLD_POSITION:
- {
- value = GetCurrentWorldPosition();
- break;
- }
+ case Dali::Actor::Property::SCALE_X:
+ {
+ value.Get( mTargetScale.x );
+ break;
+ }
- case Dali::Actor::Property::WORLD_POSITION_X:
- {
- value = GetCurrentWorldPosition().x;
- break;
- }
+ case Dali::Actor::Property::SCALE_Y:
+ {
+ value.Get( mTargetScale.y );
+ break;
+ }
- case Dali::Actor::Property::WORLD_POSITION_Y:
- {
- value = GetCurrentWorldPosition().y;
- break;
- }
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ value.Get( mTargetScale.z );
+ break;
+ }
- case Dali::Actor::Property::WORLD_POSITION_Z:
- {
- value = GetCurrentWorldPosition().z;
- break;
- }
+ case Dali::Actor::Property::VISIBLE:
+ {
+ SetVisibleInternal( value.Get< bool >(), SendMessage::FALSE );
+ break;
+ }
- case Dali::Actor::Property::ORIENTATION:
- {
- value = GetCurrentOrientation();
- break;
- }
+ case Dali::Actor::Property::COLOR:
+ {
+ value.Get( mTargetColor );
+ break;
+ }
- case Dali::Actor::Property::WORLD_ORIENTATION:
- {
- value = GetCurrentWorldOrientation();
- break;
- }
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ value.Get( mTargetColor.r );
+ break;
+ }
- case Dali::Actor::Property::SCALE:
- {
- value = GetCurrentScale();
- break;
- }
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ value.Get( mTargetColor.g );
+ break;
+ }
- case Dali::Actor::Property::SCALE_X:
- {
- value = GetCurrentScale().x;
- break;
- }
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ value.Get( mTargetColor.b );
+ break;
+ }
- case Dali::Actor::Property::SCALE_Y:
- {
- value = GetCurrentScale().y;
- break;
- }
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
+ {
+ value.Get( mTargetColor.a );
+ break;
+ }
- case Dali::Actor::Property::SCALE_Z:
- {
- value = GetCurrentScale().z;
+ default:
+ {
+ // Not an animatable property. Do nothing.
+ break;
+ }
+ }
break;
}
- case Dali::Actor::Property::WORLD_SCALE:
+ case Animation::BY:
{
- value = GetCurrentWorldScale();
- break;
- }
+ switch( index )
+ {
+ case Dali::Actor::Property::SIZE:
+ {
+ if( AdjustValue< Vector3 >( mTargetSize, value ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
- case Dali::Actor::Property::VISIBLE:
- {
- value = IsVisible();
- break;
- }
+ case Dali::Actor::Property::SIZE_WIDTH:
+ {
+ if( AdjustValue< float >( mTargetSize.width, value ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
- case Dali::Actor::Property::COLOR:
- {
- value = GetCurrentColor();
- break;
- }
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ {
+ if( AdjustValue< float >( mTargetSize.height, value ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
- case Dali::Actor::Property::COLOR_RED:
- {
- value = GetCurrentColor().r;
- break;
- }
+ case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ if( AdjustValue< float >( mTargetSize.depth, value ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
- case Dali::Actor::Property::COLOR_GREEN:
- {
- value = GetCurrentColor().g;
- break;
- }
+ case Dali::Actor::Property::POSITION:
+ {
+ AdjustValue< Vector3 >( mTargetPosition, value );
+ break;
+ }
- case Dali::Actor::Property::COLOR_BLUE:
- {
- value = GetCurrentColor().b;
- break;
- }
+ case Dali::Actor::Property::POSITION_X:
+ {
+ AdjustValue< float >( mTargetPosition.x, value );
+ break;
+ }
- case Dali::Actor::Property::COLOR_ALPHA:
- {
- value = GetCurrentColor().a;
- break;
- }
+ case Dali::Actor::Property::POSITION_Y:
+ {
+ AdjustValue< float >( mTargetPosition.y, value );
+ break;
+ }
- case Dali::Actor::Property::WORLD_COLOR:
- {
- value = GetCurrentWorldColor();
- break;
- }
+ case Dali::Actor::Property::POSITION_Z:
+ {
+ AdjustValue< float >( mTargetPosition.z, value );
+ break;
+ }
- case Dali::Actor::Property::WORLD_MATRIX:
- {
- value = GetCurrentWorldMatrix();
- break;
- }
+ case Dali::Actor::Property::ORIENTATION:
+ {
+ Quaternion relativeValue;
+ if( value.Get( relativeValue ) )
+ {
+ mTargetOrientation *= relativeValue;
+ }
+ break;
+ }
- case Dali::Actor::Property::NAME:
- {
- value = GetName();
- break;
- }
+ case Dali::Actor::Property::SCALE:
+ {
+ AdjustValue< Vector3 >( mTargetScale, value );
+ break;
+ }
- case Dali::Actor::Property::SENSITIVE:
- {
- value = IsSensitive();
- break;
- }
+ case Dali::Actor::Property::SCALE_X:
+ {
+ AdjustValue< float >( mTargetScale.x, value );
+ break;
+ }
- case Dali::Actor::Property::LEAVE_REQUIRED:
- {
- value = GetLeaveRequired();
- break;
- }
+ case Dali::Actor::Property::SCALE_Y:
+ {
+ AdjustValue< float >( mTargetScale.y, value );
+ break;
+ }
- case Dali::Actor::Property::INHERIT_ORIENTATION:
- {
- value = IsOrientationInherited();
- break;
- }
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ AdjustValue< float >( mTargetScale.z, value );
+ break;
+ }
- case Dali::Actor::Property::INHERIT_SCALE:
- {
- value = IsScaleInherited();
- break;
- }
+ case Dali::Actor::Property::VISIBLE:
+ {
+ bool relativeValue = false;
+ if( value.Get( relativeValue ) )
+ {
+ bool visible = mVisible || relativeValue;
+ SetVisibleInternal( visible, SendMessage::FALSE );
+ }
+ break;
+ }
- case Dali::Actor::Property::COLOR_MODE:
- {
- value = Scripting::GetColorMode( GetColorMode() );
- break;
- }
+ case Dali::Actor::Property::COLOR:
+ {
+ AdjustValue< Vector4 >( mTargetColor, value );
+ break;
+ }
- case Dali::Actor::Property::POSITION_INHERITANCE:
- {
- value = Scripting::GetPositionInheritanceMode( GetPositionInheritanceMode() );
- break;
- }
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ AdjustValue< float >( mTargetColor.r, value );
+ break;
+ }
- case Dali::Actor::Property::DRAW_MODE:
- {
- value = Scripting::GetDrawMode( GetDrawMode() );
- break;
- }
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ AdjustValue< float >( mTargetColor.g, value );
+ break;
+ }
- case Dali::Actor::Property::SIZE_MODE:
- {
- value = Scripting::GetLinearEnumerationName< SizeMode >( GetSizeMode(), SizeModeTable, SizeModeTableCount );
- break;
- }
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ AdjustValue< float >( mTargetColor.b, value );
+ break;
+ }
- case Dali::Actor::Property::SIZE_MODE_FACTOR:
- {
- value = GetSizeModeFactor();
- break;
- }
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
+ {
+ AdjustValue< float >( mTargetColor.a, value );
+ break;
+ }
- case Dali::Actor::Property::RELAYOUT_ENABLED:
- {
- value = IsRelayoutEnabled();
+ default:
+ {
+ // Not an animatable property. Do nothing.
+ break;
+ }
+ }
break;
}
+ }
+}
- case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
- {
- value = Scripting::GetLinearEnumerationName< ResizePolicy >( GetResizePolicy( WIDTH ), ResizePolicyTable, ResizePolicyTableCount );
- break;
- }
+const SceneGraph::PropertyOwner* Actor::GetPropertyOwner() const
+{
+ return mNode;
+}
- case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
- {
- value = Scripting::GetLinearEnumerationName< ResizePolicy >( GetResizePolicy( HEIGHT ), ResizePolicyTable, ResizePolicyTableCount );
- break;
- }
+const SceneGraph::PropertyOwner* Actor::GetSceneObject() const
+{
+ // This method should only return an object connected to the scene-graph
+ return OnStage() ? mNode : NULL;
+}
- case Dali::Actor::Property::SIZE_SCALE_POLICY:
- {
- value = Scripting::GetLinearEnumerationName< SizeScalePolicy >( GetSizeScalePolicy(), SizeScalePolicyTable, SizeScalePolicyTableCount );
- break;
- }
+const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index index ) const
+{
+ DALI_ASSERT_ALWAYS( IsPropertyAnimatable( index ) && "Property is not animatable" );
- case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
- {
- value = ( GetResizePolicy( WIDTH ) == DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( WIDTH ) == HEIGHT );
- break;
- }
+ const PropertyBase* property( NULL );
- case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
- {
- value = ( GetResizePolicy( HEIGHT ) == DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( HEIGHT ) == WIDTH );
- break;
- }
+ // This method should only return a property of an object connected to the scene-graph
+ if( !OnStage() )
+ {
+ return property;
+ }
- case Dali::Actor::Property::PADDING:
- {
- Vector2 widthPadding = GetPadding( WIDTH );
- Vector2 heightPadding = GetPadding( HEIGHT );
- value = Vector4( widthPadding.x, widthPadding.y, heightPadding.x, heightPadding.y );
- break;
- }
+ if ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX && index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )
+ {
+ AnimatablePropertyMetadata* animatable = RegisterAnimatableProperty( index );
+ DALI_ASSERT_ALWAYS( animatable && "Property index is invalid" );
- case Dali::Actor::Property::MINIMUM_SIZE:
- {
- value = Vector2( GetMinimumSize( WIDTH ), GetMinimumSize( HEIGHT ) );
- break;
- }
+ property = animatable->GetSceneGraphProperty();
+ }
+ else if ( ( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && // Child properties are also stored as custom properties
+ ( index <= PROPERTY_CUSTOM_MAX_INDEX ) )
+ {
+ CustomPropertyMetadata* custom = FindCustomProperty( index );
+ DALI_ASSERT_ALWAYS( custom && "Property index is invalid" );
- case Dali::Actor::Property::MAXIMUM_SIZE:
+ property = custom->GetSceneGraphProperty();
+ }
+ else if( NULL != mNode )
+ {
+ switch( index )
{
- value = Vector2( GetMaximumSize( WIDTH ), GetMaximumSize( HEIGHT ) );
- break;
- }
+ case Dali::Actor::Property::SIZE:
+ property = &mNode->mSize;
+ break;
- case Dali::Actor::Property::PREFERRED_SIZE:
- {
- value = GetPreferredSize();
- break;
- }
+ case Dali::Actor::Property::SIZE_WIDTH:
+ property = &mNode->mSize;
+ break;
- default:
- {
- DALI_ASSERT_ALWAYS( false && "Actor Property index invalid" ); // should not come here
- break;
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ property = &mNode->mSize;
+ break;
+
+ case Dali::Actor::Property::SIZE_DEPTH:
+ property = &mNode->mSize;
+ break;
+
+ case Dali::Actor::Property::POSITION:
+ property = &mNode->mPosition;
+ break;
+
+ case Dali::Actor::Property::POSITION_X:
+ property = &mNode->mPosition;
+ break;
+
+ case Dali::Actor::Property::POSITION_Y:
+ property = &mNode->mPosition;
+ break;
+
+ case Dali::Actor::Property::POSITION_Z:
+ property = &mNode->mPosition;
+ break;
+
+ case Dali::Actor::Property::ORIENTATION:
+ property = &mNode->mOrientation;
+ break;
+
+ case Dali::Actor::Property::SCALE:
+ property = &mNode->mScale;
+ break;
+
+ case Dali::Actor::Property::SCALE_X:
+ property = &mNode->mScale;
+ break;
+
+ case Dali::Actor::Property::SCALE_Y:
+ property = &mNode->mScale;
+ break;
+
+ case Dali::Actor::Property::SCALE_Z:
+ property = &mNode->mScale;
+ break;
+
+ case Dali::Actor::Property::VISIBLE:
+ property = &mNode->mVisible;
+ break;
+
+ case Dali::Actor::Property::COLOR:
+ property = &mNode->mColor;
+ break;
+
+ case Dali::Actor::Property::COLOR_RED:
+ property = &mNode->mColor;
+ break;
+
+ case Dali::Actor::Property::COLOR_GREEN:
+ property = &mNode->mColor;
+ break;
+
+ case Dali::Actor::Property::COLOR_BLUE:
+ property = &mNode->mColor;
+ break;
+
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
+ property = &mNode->mColor;
+ break;
+
+ default:
+ break;
}
}
- return value;
+ return property;
}
-const SceneGraph::PropertyOwner* Actor::GetPropertyOwner() const
+const PropertyInputImpl* Actor::GetSceneObjectInputProperty( Property::Index index ) const
{
- return mNode;
-}
+ const PropertyInputImpl* property( NULL );
-const SceneGraph::PropertyOwner* Actor::GetSceneObject() const
-{
- // This method should only return an object connected to the scene-graph
- return OnStage() ? mNode : NULL;
-}
+ // This method should only return a property of an object connected to the scene-graph
+ if( !OnStage() )
+ {
+ return property;
+ }
-const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index index ) const
-{
- DALI_ASSERT_ALWAYS( IsPropertyAnimatable( index ) && "Property is not animatable" );
+ if ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX && index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )
+ {
+ AnimatablePropertyMetadata* animatable = RegisterAnimatableProperty( index );
+ DALI_ASSERT_ALWAYS( animatable && "Property index is invalid" );
- const PropertyBase* property( NULL );
+ property = animatable->GetSceneGraphProperty();
+ }
+ else if ( ( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && // Child properties are also stored as custom properties
+ ( index <= PROPERTY_CUSTOM_MAX_INDEX ) )
+ {
+ CustomPropertyMetadata* custom = FindCustomProperty( index );
+ DALI_ASSERT_ALWAYS( custom && "Property index is invalid" );
+ property = custom->GetSceneGraphProperty();
+ }
+ else if( NULL != mNode )
+ {
+ switch( index )
+ {
+ case Dali::Actor::Property::PARENT_ORIGIN:
+ property = &mNode->mParentOrigin;
+ break;
+
+ case Dali::Actor::Property::PARENT_ORIGIN_X:
+ property = &mNode->mParentOrigin;
+ break;
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Y:
+ property = &mNode->mParentOrigin;
+ break;
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
+ property = &mNode->mParentOrigin;
+ break;
+
+ case Dali::Actor::Property::ANCHOR_POINT:
+ property = &mNode->mAnchorPoint;
+ break;
+
+ case Dali::Actor::Property::ANCHOR_POINT_X:
+ property = &mNode->mAnchorPoint;
+ break;
- // This method should only return a property of an object connected to the scene-graph
- if( !OnStage() )
- {
- return property;
- }
+ case Dali::Actor::Property::ANCHOR_POINT_Y:
+ property = &mNode->mAnchorPoint;
+ break;
- if ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX && index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )
- {
- AnimatablePropertyMetadata* animatable = FindAnimatableProperty( index );
- DALI_ASSERT_ALWAYS( animatable && "Property index is invalid" );
- property = animatable->GetSceneGraphProperty();
- }
- else if ( index >= DEFAULT_PROPERTY_MAX_COUNT )
- {
- CustomPropertyMetadata* custom = FindCustomProperty( index );
- DALI_ASSERT_ALWAYS( custom && "Property index is invalid" );
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
+ property = &mNode->mAnchorPoint;
+ break;
- property = custom->GetSceneGraphProperty();
- }
- else if( NULL != mNode )
- {
- switch( index )
- {
case Dali::Actor::Property::SIZE:
property = &mNode->mSize;
break;
property = &mNode->mPosition;
break;
+ case Dali::Actor::Property::WORLD_POSITION:
+ property = &mNode->mWorldPosition;
+ break;
+
+ case Dali::Actor::Property::WORLD_POSITION_X:
+ property = &mNode->mWorldPosition;
+ break;
+
+ case Dali::Actor::Property::WORLD_POSITION_Y:
+ property = &mNode->mWorldPosition;
+ break;
+
+ case Dali::Actor::Property::WORLD_POSITION_Z:
+ property = &mNode->mWorldPosition;
+ break;
+
case Dali::Actor::Property::ORIENTATION:
property = &mNode->mOrientation;
break;
+ case Dali::Actor::Property::WORLD_ORIENTATION:
+ property = &mNode->mWorldOrientation;
+ break;
+
case Dali::Actor::Property::SCALE:
property = &mNode->mScale;
break;
property = &mNode->mScale;
break;
+ case Dali::Actor::Property::WORLD_SCALE:
+ property = &mNode->mWorldScale;
+ break;
+
case Dali::Actor::Property::VISIBLE:
property = &mNode->mVisible;
break;
property = &mNode->mColor;
break;
- case Dali::Actor::Property::COLOR_BLUE:
- property = &mNode->mColor;
- break;
+ case Dali::Actor::Property::COLOR_BLUE:
+ property = &mNode->mColor;
+ break;
+
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
+ {
+ property = &mNode->mColor;
+ break;
+ }
+
+ case Dali::Actor::Property::WORLD_COLOR:
+ property = &mNode->mWorldColor;
+ break;
+
+ case Dali::Actor::Property::WORLD_MATRIX:
+ property = &mNode->mWorldMatrix;
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ return property;
+}
+
+int Actor::GetPropertyComponentIndex( Property::Index index ) const
+{
+ int componentIndex( Property::INVALID_COMPONENT_INDEX );
+
+ if ( ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX ) )
+ {
+ // check whether the animatable property is registered already, if not then register one.
+ AnimatablePropertyMetadata* animatableProperty = RegisterAnimatableProperty(index);
+ if( animatableProperty )
+ {
+ componentIndex = animatableProperty->componentIndex;
+ }
+ }
+ else
+ {
+ switch( index )
+ {
+ case Dali::Actor::Property::PARENT_ORIGIN_X:
+ case Dali::Actor::Property::ANCHOR_POINT_X:
+ case Dali::Actor::Property::SIZE_WIDTH:
+ case Dali::Actor::Property::POSITION_X:
+ case Dali::Actor::Property::WORLD_POSITION_X:
+ case Dali::Actor::Property::SCALE_X:
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ componentIndex = 0;
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Y:
+ case Dali::Actor::Property::ANCHOR_POINT_Y:
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ case Dali::Actor::Property::POSITION_Y:
+ case Dali::Actor::Property::WORLD_POSITION_Y:
+ case Dali::Actor::Property::SCALE_Y:
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ componentIndex = 1;
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
+ case Dali::Actor::Property::SIZE_DEPTH:
+ case Dali::Actor::Property::POSITION_Z:
+ case Dali::Actor::Property::WORLD_POSITION_Z:
+ case Dali::Actor::Property::SCALE_Z:
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ componentIndex = 2;
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
+ {
+ componentIndex = 3;
+ break;
+ }
+
+ default:
+ {
+ // Do nothing
+ break;
+ }
+ }
+ }
+
+ return componentIndex;
+}
+
+void Actor::SetParent( Actor* parent )
+{
+ if( parent )
+ {
+ DALI_ASSERT_ALWAYS( !mParent && "Actor cannot have 2 parents" );
+
+ mParent = parent;
+
+ if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
+ parent->OnStage() )
+ {
+ // 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
+ {
+ DALI_ASSERT_ALWAYS( mParent != NULL && "Actor should have a parent" );
+
+ mParent = NULL;
+
+ if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
+ OnStage() )
+ {
+ DALI_ASSERT_ALWAYS( mNode != NULL );
+
+ if( NULL != mNode )
+ {
+ // Disconnect the Node & its children from the scene-graph.
+ DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *mNode );
+ }
+
+ // Instruct each actor to discard pointers to the scene-graph
+ DisconnectFromStage();
+ }
+ }
+}
+
+SceneGraph::Node* Actor::CreateNode() const
+{
+ return Node::New();
+}
+
+bool Actor::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& /* attributes */ )
+{
+ bool done = false;
+ Actor* actor = dynamic_cast< Actor* >( object );
+
+ if( actor )
+ {
+ if( 0 == actionName.compare( ACTION_SHOW ) )
+ {
+ actor->SetVisible( true );
+ done = true;
+ }
+ else if( 0 == actionName.compare( ACTION_HIDE ) )
+ {
+ actor->SetVisible( false );
+ done = true;
+ }
+ }
+
+ return done;
+}
+
+bool Actor::GetCachedPropertyValue( Property::Index index, Property::Value& value ) const
+{
+ bool valueSet = true;
+
+ switch( index )
+ {
+ case Dali::Actor::Property::PARENT_ORIGIN:
+ {
+ value = GetCurrentParentOrigin();
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_X:
+ {
+ value = GetCurrentParentOrigin().x;
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Y:
+ {
+ value = GetCurrentParentOrigin().y;
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
+ {
+ value = GetCurrentParentOrigin().z;
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT:
+ {
+ value = GetCurrentAnchorPoint();
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT_X:
+ {
+ value = GetCurrentAnchorPoint().x;
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT_Y:
+ {
+ value = GetCurrentAnchorPoint().y;
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
+ {
+ value = GetCurrentAnchorPoint().z;
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE:
+ {
+ value = GetTargetSize();
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_WIDTH:
+ {
+ value = GetTargetSize().width;
+ break;
+ }
- case Dali::Actor::Property::COLOR_ALPHA:
- property = &mNode->mColor;
- break;
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ {
+ value = GetTargetSize().height;
+ break;
+ }
- default:
- break;
+ case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ value = GetTargetSize().depth;
+ break;
}
- }
- return property;
-}
+ case Dali::Actor::Property::POSITION:
+ {
+ value = GetTargetPosition();
+ break;
+ }
-const PropertyInputImpl* Actor::GetSceneObjectInputProperty( Property::Index index ) const
-{
- const PropertyInputImpl* property( NULL );
+ case Dali::Actor::Property::POSITION_X:
+ {
+ value = GetTargetPosition().x;
+ break;
+ }
- // This method should only return a property of an object connected to the scene-graph
- if( !OnStage() )
- {
- return property;
- }
+ case Dali::Actor::Property::POSITION_Y:
+ {
+ value = GetTargetPosition().y;
+ break;
+ }
- if ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX && index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )
- {
- AnimatablePropertyMetadata* animatable = FindAnimatableProperty( index );
- DALI_ASSERT_ALWAYS( animatable && "Property index is invalid" );
- property = animatable->GetSceneGraphProperty();
- }
- else if ( index >= DEFAULT_PROPERTY_MAX_COUNT )
- {
- CustomPropertyMetadata* custom = FindCustomProperty( index );
- DALI_ASSERT_ALWAYS( custom && "Property index is invalid" );
- property = custom->GetSceneGraphProperty();
- }
- else if( NULL != mNode )
- {
- switch( index )
+ case Dali::Actor::Property::POSITION_Z:
{
- case Dali::Actor::Property::PARENT_ORIGIN:
- property = &mNode->mParentOrigin;
- break;
+ value = GetTargetPosition().z;
+ break;
+ }
- case Dali::Actor::Property::PARENT_ORIGIN_X:
- property = &mNode->mParentOrigin;
- break;
+ case Dali::Actor::Property::ORIENTATION:
+ {
+ value = mTargetOrientation;
+ break;
+ }
- case Dali::Actor::Property::PARENT_ORIGIN_Y:
- property = &mNode->mParentOrigin;
- break;
+ case Dali::Actor::Property::SCALE:
+ {
+ value = mTargetScale;
+ break;
+ }
- case Dali::Actor::Property::PARENT_ORIGIN_Z:
- property = &mNode->mParentOrigin;
- break;
+ case Dali::Actor::Property::SCALE_X:
+ {
+ value = mTargetScale.x;
+ break;
+ }
- case Dali::Actor::Property::ANCHOR_POINT:
- property = &mNode->mAnchorPoint;
- break;
+ case Dali::Actor::Property::SCALE_Y:
+ {
+ value = mTargetScale.y;
+ break;
+ }
- case Dali::Actor::Property::ANCHOR_POINT_X:
- property = &mNode->mAnchorPoint;
- break;
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ value = mTargetScale.z;
+ break;
+ }
- case Dali::Actor::Property::ANCHOR_POINT_Y:
- property = &mNode->mAnchorPoint;
- break;
+ case Dali::Actor::Property::VISIBLE:
+ {
+ value = mVisible;
+ break;
+ }
- case Dali::Actor::Property::ANCHOR_POINT_Z:
- property = &mNode->mAnchorPoint;
- break;
+ case Dali::Actor::Property::COLOR:
+ {
+ value = mTargetColor;
+ break;
+ }
- case Dali::Actor::Property::SIZE:
- property = &mNode->mSize;
- break;
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ value = mTargetColor.r;
+ break;
+ }
- case Dali::Actor::Property::SIZE_WIDTH:
- property = &mNode->mSize;
- break;
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ value = mTargetColor.g;
+ break;
+ }
- case Dali::Actor::Property::SIZE_HEIGHT:
- property = &mNode->mSize;
- break;
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ value = mTargetColor.b;
+ break;
+ }
- case Dali::Actor::Property::SIZE_DEPTH:
- property = &mNode->mSize;
- break;
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
+ {
+ value = mTargetColor.a;
+ break;
+ }
- case Dali::Actor::Property::POSITION:
- property = &mNode->mPosition;
- break;
+ case Dali::Actor::Property::NAME:
+ {
+ value = GetName();
+ break;
+ }
- case Dali::Actor::Property::POSITION_X:
- property = &mNode->mPosition;
- break;
+ case Dali::Actor::Property::SENSITIVE:
+ {
+ value = IsSensitive();
+ break;
+ }
- case Dali::Actor::Property::POSITION_Y:
- property = &mNode->mPosition;
- break;
+ case Dali::Actor::Property::LEAVE_REQUIRED:
+ {
+ value = GetLeaveRequired();
+ break;
+ }
- case Dali::Actor::Property::POSITION_Z:
- property = &mNode->mPosition;
- break;
+ case Dali::Actor::Property::INHERIT_POSITION:
+ {
+ value = IsPositionInherited();
+ break;
+ }
- case Dali::Actor::Property::WORLD_POSITION:
- property = &mNode->mWorldPosition;
- break;
+ case Dali::Actor::Property::INHERIT_ORIENTATION:
+ {
+ value = IsOrientationInherited();
+ break;
+ }
- case Dali::Actor::Property::WORLD_POSITION_X:
- property = &mNode->mWorldPosition;
- break;
+ case Dali::Actor::Property::INHERIT_SCALE:
+ {
+ value = IsScaleInherited();
+ break;
+ }
- case Dali::Actor::Property::WORLD_POSITION_Y:
- property = &mNode->mWorldPosition;
- break;
+ case Dali::Actor::Property::COLOR_MODE:
+ {
+ value = Scripting::GetLinearEnumerationName< ColorMode >( GetColorMode(), COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT );
+ break;
+ }
- case Dali::Actor::Property::WORLD_POSITION_Z:
- property = &mNode->mWorldPosition;
- break;
+ case Dali::Actor::Property::POSITION_INHERITANCE:
+ {
+ value = Scripting::GetLinearEnumerationName< PositionInheritanceMode >( GetPositionInheritanceMode(), POSITION_INHERITANCE_MODE_TABLE, POSITION_INHERITANCE_MODE_TABLE_COUNT );
+ break;
+ }
- case Dali::Actor::Property::ORIENTATION:
- property = &mNode->mOrientation;
- break;
+ case Dali::Actor::Property::DRAW_MODE:
+ {
+ value = Scripting::GetEnumerationName< DrawMode::Type >( GetDrawMode(), DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT );
+ break;
+ }
- case Dali::Actor::Property::WORLD_ORIENTATION:
- property = &mNode->mWorldOrientation;
- break;
+ case Dali::Actor::Property::SIZE_MODE_FACTOR:
+ {
+ value = GetSizeModeFactor();
+ break;
+ }
- case Dali::Actor::Property::SCALE:
- property = &mNode->mScale;
- break;
+ case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
+ {
+ value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::WIDTH ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT );
+ break;
+ }
- case Dali::Actor::Property::SCALE_X:
- property = &mNode->mScale;
- break;
+ case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
+ {
+ value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::HEIGHT ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT );
+ break;
+ }
- case Dali::Actor::Property::SCALE_Y:
- property = &mNode->mScale;
- break;
+ case Dali::Actor::Property::SIZE_SCALE_POLICY:
+ {
+ value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT );
+ break;
+ }
- case Dali::Actor::Property::SCALE_Z:
- property = &mNode->mScale;
- break;
+ case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
+ {
+ value = ( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::WIDTH ) == Dimension::HEIGHT );
+ break;
+ }
- case Dali::Actor::Property::WORLD_SCALE:
- property = &mNode->mWorldScale;
- break;
+ case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
+ {
+ value = ( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::HEIGHT ) == Dimension::WIDTH );
+ break;
+ }
- case Dali::Actor::Property::VISIBLE:
- property = &mNode->mVisible;
- break;
+ case Dali::Actor::Property::PADDING:
+ {
+ Vector2 widthPadding = GetPadding( Dimension::WIDTH );
+ Vector2 heightPadding = GetPadding( Dimension::HEIGHT );
+ value = Vector4( widthPadding.x, widthPadding.y, heightPadding.x, heightPadding.y );
+ break;
+ }
- case Dali::Actor::Property::COLOR:
- property = &mNode->mColor;
- break;
+ case Dali::Actor::Property::MINIMUM_SIZE:
+ {
+ value = Vector2( GetMinimumSize( Dimension::WIDTH ), GetMinimumSize( Dimension::HEIGHT ) );
+ break;
+ }
- case Dali::Actor::Property::COLOR_RED:
- property = &mNode->mColor;
- break;
+ case Dali::Actor::Property::MAXIMUM_SIZE:
+ {
+ value = Vector2( GetMaximumSize( Dimension::WIDTH ), GetMaximumSize( Dimension::HEIGHT ) );
+ break;
+ }
- case Dali::Actor::Property::COLOR_GREEN:
- property = &mNode->mColor;
- break;
+ case Dali::Actor::Property::CLIPPING_MODE:
+ {
+ value = mClippingMode;
+ break;
+ }
- case Dali::Actor::Property::COLOR_BLUE:
- property = &mNode->mColor;
- break;
+ case Dali::DevelActor::Property::SIBLING_ORDER:
+ {
+ value = static_cast<int>( GetSiblingOrder() );
+ break;
+ }
- case Dali::Actor::Property::COLOR_ALPHA:
- property = &mNode->mColor;
- break;
+ case Dali::DevelActor::Property::SCREEN_POSITION:
+ {
+ value = GetCurrentScreenPosition();
+ break;
+ }
- case Dali::Actor::Property::WORLD_COLOR:
- property = &mNode->mWorldColor;
- break;
+ case Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT:
+ {
+ value = mPositionUsesAnchorPoint;
+ break;
+ }
- case Dali::Actor::Property::WORLD_MATRIX:
- property = &mNode->mWorldMatrix;
- break;
+ case Dali::Actor::Property::LAYOUT_DIRECTION:
+ {
+ value = mLayoutDirection;
+ break;
+ }
- default:
- break;
+ case Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION:
+ {
+ value = IsLayoutDirectionInherited();
+ break;
+ }
+
+ default:
+ {
+ // Must be a scene-graph only property
+ valueSet = false;
+ break;
}
}
- return property;
+ return valueSet;
}
-int Actor::GetPropertyComponentIndex( Property::Index index ) const
+bool Actor::GetCurrentPropertyValue( Property::Index index, Property::Value& value ) const
{
- int componentIndex( Property::INVALID_COMPONENT_INDEX );
+ bool valueSet = true;
switch( index )
{
- case Dali::Actor::Property::PARENT_ORIGIN_X:
- case Dali::Actor::Property::ANCHOR_POINT_X:
+ case Dali::Actor::Property::SIZE:
+ {
+ value = GetCurrentSize();
+ break;
+ }
+
case Dali::Actor::Property::SIZE_WIDTH:
- case Dali::Actor::Property::POSITION_X:
- case Dali::Actor::Property::WORLD_POSITION_X:
- case Dali::Actor::Property::SCALE_X:
- case Dali::Actor::Property::COLOR_RED:
{
- componentIndex = 0;
+ value = GetCurrentSize().width;
break;
}
- case Dali::Actor::Property::PARENT_ORIGIN_Y:
- case Dali::Actor::Property::ANCHOR_POINT_Y:
case Dali::Actor::Property::SIZE_HEIGHT:
- case Dali::Actor::Property::POSITION_Y:
- case Dali::Actor::Property::WORLD_POSITION_Y:
- case Dali::Actor::Property::SCALE_Y:
- case Dali::Actor::Property::COLOR_GREEN:
{
- componentIndex = 1;
+ value = GetCurrentSize().height;
break;
}
- case Dali::Actor::Property::PARENT_ORIGIN_Z:
- case Dali::Actor::Property::ANCHOR_POINT_Z:
case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ value = GetCurrentSize().depth;
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION:
+ {
+ value = GetCurrentPosition();
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_X:
+ {
+ value = GetCurrentPosition().x;
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Y:
+ {
+ value = GetCurrentPosition().y;
+ break;
+ }
+
case Dali::Actor::Property::POSITION_Z:
+ {
+ value = GetCurrentPosition().z;
+ break;
+ }
+
+ case Dali::Actor::Property::WORLD_POSITION:
+ {
+ value = GetCurrentWorldPosition();
+ break;
+ }
+
+ case Dali::Actor::Property::WORLD_POSITION_X:
+ {
+ value = GetCurrentWorldPosition().x;
+ break;
+ }
+
+ case Dali::Actor::Property::WORLD_POSITION_Y:
+ {
+ value = GetCurrentWorldPosition().y;
+ break;
+ }
+
case Dali::Actor::Property::WORLD_POSITION_Z:
- case Dali::Actor::Property::SCALE_Z:
- case Dali::Actor::Property::COLOR_BLUE:
{
- componentIndex = 2;
+ value = GetCurrentWorldPosition().z;
break;
}
- case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::Actor::Property::ORIENTATION:
{
- componentIndex = 3;
+ value = GetCurrentOrientation();
break;
}
- default:
+ case Dali::Actor::Property::WORLD_ORIENTATION:
{
- // Do nothing
+ value = GetCurrentWorldOrientation();
break;
}
- }
- return componentIndex;
-}
+ case Dali::Actor::Property::SCALE:
+ {
+ value = GetCurrentScale();
+ break;
+ }
-void Actor::SetParent( Actor* parent, int index )
-{
- if( parent )
- {
- DALI_ASSERT_ALWAYS( !mParent && "Actor cannot have 2 parents" );
+ case Dali::Actor::Property::SCALE_X:
+ {
+ value = GetCurrentScale().x;
+ break;
+ }
- mParent = parent;
+ case Dali::Actor::Property::SCALE_Y:
+ {
+ value = GetCurrentScale().y;
+ break;
+ }
- if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
- parent->OnStage() )
+ case Dali::Actor::Property::SCALE_Z:
{
- // Instruct each actor to create a corresponding node in the scene graph
- ConnectToStage( index );
+ value = GetCurrentScale().z;
+ break;
}
- }
- else // parent being set to NULL
- {
- DALI_ASSERT_ALWAYS( mParent != NULL && "Actor should have a parent" );
- mParent = NULL;
+ case Dali::Actor::Property::WORLD_SCALE:
+ {
+ value = GetCurrentWorldScale();
+ break;
+ }
- if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
- OnStage() )
+ case Dali::Actor::Property::COLOR:
{
- DALI_ASSERT_ALWAYS( mNode != NULL );
+ value = GetCurrentColor();
+ break;
+ }
- if( NULL != mNode )
- {
- // Disconnect the Node & its children from the scene-graph.
- DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *mNode );
- }
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ value = GetCurrentColor().r;
+ break;
+ }
- // Instruct each actor to discard pointers to the scene-graph
- DisconnectFromStage();
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ value = GetCurrentColor().g;
+ break;
}
- }
-}
-SceneGraph::Node* Actor::CreateNode() const
-{
- return Node::New();
-}
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ value = GetCurrentColor().b;
+ break;
+ }
-bool Actor::DoAction( BaseObject* object, const std::string& actionName, const std::vector< Property::Value >& attributes )
-{
- bool done = false;
- Actor* actor = dynamic_cast< Actor* >( object );
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
+ {
+ value = GetCurrentColor().a;
+ break;
+ }
- if( actor )
- {
- if( 0 == strcmp( actionName.c_str(), ACTION_SHOW ) ) // dont want to convert char* to string
+ case Dali::Actor::Property::WORLD_COLOR:
{
- actor->SetVisible( true );
- done = true;
+ value = GetCurrentWorldColor();
+ break;
}
- else if( 0 == strcmp( actionName.c_str(), ACTION_HIDE ) )
+
+ case Dali::Actor::Property::WORLD_MATRIX:
{
- actor->SetVisible( false );
- done = true;
+ value = GetCurrentWorldMatrix();
+ break;
+ }
+
+ case Dali::Actor::Property::VISIBLE:
+ {
+ value = IsVisible();
+ break;
+ }
+
+ default:
+ {
+ // Must be an event-side only property
+ valueSet = false;
+ break;
}
}
- return done;
+ return valueSet;
}
-void Actor::EnsureRelayoutData() const
+void Actor::EnsureRelayoutData()
{
// Assign relayout data.
if( !mRelayoutData )
}
}
-bool Actor::RelayoutDependentOnParent( Dimension dimension )
+bool Actor::RelayoutDependentOnParent( Dimension::Type dimension )
{
// Check if actor is dependent on parent
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) )
{
- const ResizePolicy resizePolicy = GetResizePolicy( static_cast< Dimension >( 1 << i ) );
- if( resizePolicy == FILL_TO_PARENT )
+ const ResizePolicy::Type resizePolicy = GetResizePolicy( static_cast< Dimension::Type >( 1 << i ) );
+ if( resizePolicy == ResizePolicy::FILL_TO_PARENT || resizePolicy == ResizePolicy::SIZE_RELATIVE_TO_PARENT || resizePolicy == ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT )
{
return true;
}
return false;
}
-bool Actor::RelayoutDependentOnChildren( Dimension dimension )
+bool Actor::RelayoutDependentOnChildren( Dimension::Type dimension )
{
// Check if actor is dependent on children
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) )
{
- const ResizePolicy resizePolicy = GetResizePolicy( static_cast< Dimension >( 1 << i ) );
+ const ResizePolicy::Type resizePolicy = GetResizePolicy( static_cast< Dimension::Type >( 1 << i ) );
switch( resizePolicy )
{
- case FIT_TO_CHILDREN:
- case USE_NATURAL_SIZE: // i.e. For things that calculate their size based on children
+ case ResizePolicy::FIT_TO_CHILDREN:
+ case ResizePolicy::USE_NATURAL_SIZE: // i.e. For things that calculate their size based on children
{
return true;
}
return false;
}
-bool Actor::RelayoutDependentOnChildrenBase( Dimension dimension )
+bool Actor::RelayoutDependentOnChildrenBase( Dimension::Type dimension )
{
return Actor::RelayoutDependentOnChildren( dimension );
}
-bool Actor::RelayoutDependentOnDimension( Dimension dimension, Dimension dependentDimension )
+bool Actor::RelayoutDependentOnDimension( Dimension::Type dimension, Dimension::Type dependentDimension )
{
// Check each possible dimension and see if it is dependent on the input one
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
- return mRelayoutData->resizePolicies[ i ] == DIMENSION_DEPENDENCY && mRelayoutData->dimensionDependencies[ i ] == dependentDimension;
+ return mRelayoutData->resizePolicies[ i ] == ResizePolicy::DIMENSION_DEPENDENCY && mRelayoutData->dimensionDependencies[ i ] == dependentDimension;
}
}
return false;
}
-void Actor::SetNegotiatedDimension( float negotiatedDimension, Dimension dimension )
+void Actor::SetNegotiatedDimension( float negotiatedDimension, Dimension::Type dimension )
{
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
}
}
-float Actor::GetNegotiatedDimension( Dimension dimension ) const
+float Actor::GetNegotiatedDimension( Dimension::Type dimension ) const
{
// If more than one dimension is requested, just return the first one found
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( ( dimension & ( 1 << i ) ) )
{
return 0.0f; // Default
}
-void Actor::SetPadding( const Vector2& padding, Dimension dimension )
+void Actor::SetPadding( const Vector2& padding, Dimension::Type dimension )
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
}
}
-Vector2 Actor::GetPadding( Dimension dimension ) const
+Vector2 Actor::GetPadding( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- // If more than one dimension is requested, just return the first one found
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ if ( mRelayoutData )
{
- if( ( dimension & ( 1 << i ) ) )
+ // If more than one dimension is requested, just return the first one found
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- return mRelayoutData->dimensionPadding[ i ];
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ return mRelayoutData->dimensionPadding[ i ];
+ }
}
}
- return Vector2( 0.0f, 0.0f ); // Default
+ return GetDefaultDimensionPadding();
}
-void Actor::SetLayoutNegotiated( bool negotiated, Dimension dimension )
+void Actor::SetLayoutNegotiated( bool negotiated, Dimension::Type dimension )
{
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ EnsureRelayoutData();
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
}
}
-bool Actor::IsLayoutNegotiated( Dimension dimension ) const
+bool Actor::IsLayoutNegotiated( Dimension::Type dimension ) const
+{
+ if ( mRelayoutData )
+ {
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionNegotiated[ i ] )
+ {
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+float Actor::GetHeightForWidthBase( float width )
{
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ float height = 0.0f;
+
+ const Vector3 naturalSize = GetNaturalSize();
+ if( naturalSize.width > 0.0f )
{
- if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionNegotiated[ i ] )
- {
- return true;
- }
+ height = naturalSize.height * width / naturalSize.width;
+ }
+ else // we treat 0 as 1:1 aspect ratio
+ {
+ height = width;
}
- return false;
+ return height;
}
-float Actor::CalculateChildSize( const Dali::Actor& child, Dimension dimension )
+float Actor::GetWidthForHeightBase( float height )
{
- // Could be overridden in derived classes.
- return CalculateChildSizeBase( child, dimension );
+ float width = 0.0f;
+
+ const Vector3 naturalSize = GetNaturalSize();
+ if( naturalSize.height > 0.0f )
+ {
+ width = naturalSize.width * height / naturalSize.height;
+ }
+ else // we treat 0 as 1:1 aspect ratio
+ {
+ width = height;
+ }
+
+ return width;
}
-float Actor::CalculateChildSizeBase( const Dali::Actor& child, Dimension dimension )
+float Actor::CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension )
{
// Fill to parent, taking size mode factor into account
- switch( child.GetSizeMode() )
+ switch( child.GetResizePolicy( dimension ) )
{
- case USE_OWN_SIZE:
+ case ResizePolicy::FILL_TO_PARENT:
{
return GetLatestSize( dimension );
}
- case SIZE_RELATIVE_TO_PARENT:
+ case ResizePolicy::SIZE_RELATIVE_TO_PARENT:
{
return GetLatestSize( dimension ) * GetDimensionValue( child.GetSizeModeFactor(), dimension );
}
- case SIZE_FIXED_OFFSET_FROM_PARENT:
+ case ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT:
{
return GetLatestSize( dimension ) + GetDimensionValue( child.GetSizeModeFactor(), dimension );
}
}
}
-float Actor::GetHeightForWidth( float width )
+float Actor::CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
{
- // Could be overridden in derived classes.
- float height = 0.0f;
-
- const Vector3 naturalSize = GetNaturalSize();
- if( naturalSize.width > 0.0f )
- {
- height = naturalSize.height * width / naturalSize.width;
- }
+ // Can be overridden in derived class
+ return CalculateChildSizeBase( child, dimension );
+}
- return height;
+float Actor::GetHeightForWidth( float width )
+{
+ // Can be overridden in derived class
+ return GetHeightForWidthBase( width );
}
float Actor::GetWidthForHeight( float height )
{
- // Could be overridden in derived classes.
- float width = 0.0f;
-
- const Vector3 naturalSize = GetNaturalSize();
- if( naturalSize.height > 0.0f )
- {
- width = naturalSize.width * height / naturalSize.height;
- }
-
- return width;
+ // Can be overridden in derived class
+ return GetWidthForHeightBase( height );
}
-float Actor::GetLatestSize( Dimension dimension ) const
+float Actor::GetLatestSize( Dimension::Type dimension ) const
{
return IsLayoutNegotiated( dimension ) ? GetNegotiatedDimension( dimension ) : GetSize( dimension );
}
-float Actor::GetRelayoutSize( Dimension dimension ) const
+float Actor::GetRelayoutSize( Dimension::Type dimension ) const
{
Vector2 padding = GetPadding( dimension );
return GetLatestSize( dimension ) + padding.x + padding.y;
}
-float Actor::NegotiateFromParent( Dimension dimension )
+float Actor::NegotiateFromParent( Dimension::Type dimension )
{
Actor* parent = GetParent();
if( parent )
return 0.0f;
}
-float Actor::NegotiateFromChildren( Dimension dimension )
+float Actor::NegotiateFromChildren( Dimension::Type dimension )
{
- float minDimensionPoint = 0.0f;
float maxDimensionPoint = 0.0f;
for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
{
- Dali::Actor child = GetChildAt( i );
- Actor& childImpl = GetImplementation( child );
+ ActorPtr child = GetChildAt( i );
- if( !childImpl.RelayoutDependentOnParent( dimension ) )
+ if( !child->RelayoutDependentOnParent( dimension ) )
{
// Calculate the min and max points that the children range across
- float childPosition = GetDimensionValue( childImpl.GetCurrentPosition(), dimension );
- float dimensionSize = childImpl.GetRelayoutSize( dimension );
- minDimensionPoint = std::min( minDimensionPoint, childPosition - dimensionSize * 0.5f );
- maxDimensionPoint = std::max( maxDimensionPoint, childPosition + dimensionSize * 0.5f );
+ float childPosition = GetDimensionValue( child->GetTargetPosition(), dimension );
+ float dimensionSize = child->GetRelayoutSize( dimension );
+ maxDimensionPoint = std::max( maxDimensionPoint, childPosition + dimensionSize );
}
}
- return maxDimensionPoint - minDimensionPoint;
+ return maxDimensionPoint;
}
-float Actor::GetSize( Dimension dimension ) const
+float Actor::GetSize( Dimension::Type dimension ) const
{
- return GetDimensionValue( GetTargetSize(), dimension );
+ return GetDimensionValue( mTargetSize, dimension );
}
-float Actor::GetNaturalSize( Dimension dimension ) const
+float Actor::GetNaturalSize( Dimension::Type dimension ) const
{
return GetDimensionValue( GetNaturalSize(), dimension );
}
-float Actor::CalculateSize( Dimension dimension, const Vector2& maximumSize )
+float Actor::CalculateSize( Dimension::Type dimension, const Vector2& maximumSize )
{
switch( GetResizePolicy( dimension ) )
{
- case USE_NATURAL_SIZE:
+ case ResizePolicy::USE_NATURAL_SIZE:
{
return GetNaturalSize( dimension );
}
- case FIXED:
+ case ResizePolicy::FIXED:
{
return GetDimensionValue( GetPreferredSize(), dimension );
}
- case USE_ASSIGNED_SIZE:
+ case ResizePolicy::USE_ASSIGNED_SIZE:
{
return GetDimensionValue( maximumSize, dimension );
}
- case FILL_TO_PARENT:
+ case ResizePolicy::FILL_TO_PARENT:
+ case ResizePolicy::SIZE_RELATIVE_TO_PARENT:
+ case ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT:
{
return NegotiateFromParent( dimension );
}
- case FIT_TO_CHILDREN:
+ case ResizePolicy::FIT_TO_CHILDREN:
{
return NegotiateFromChildren( dimension );
}
- case DIMENSION_DEPENDENCY:
+ case ResizePolicy::DIMENSION_DEPENDENCY:
{
- const Dimension dimensionDependency = GetDimensionDependency( dimension );
+ const Dimension::Type dimensionDependency = GetDimensionDependency( dimension );
// Custom rules
- if( dimension == WIDTH && dimensionDependency == HEIGHT )
+ if( dimension == Dimension::WIDTH && dimensionDependency == Dimension::HEIGHT )
{
- return GetWidthForHeight( GetNegotiatedDimension( HEIGHT ) );
+ return GetWidthForHeight( GetNegotiatedDimension( Dimension::HEIGHT ) );
}
- if( dimension == HEIGHT && dimensionDependency == WIDTH )
+ if( dimension == Dimension::HEIGHT && dimensionDependency == Dimension::WIDTH )
{
- return GetHeightForWidth( GetNegotiatedDimension( WIDTH ) );
+ return GetHeightForWidth( GetNegotiatedDimension( Dimension::WIDTH ) );
}
break;
return 0.0f; // Default
}
-float Actor::ConstrainDimension( float size, Dimension dimension )
+float Actor::ClampDimension( float size, Dimension::Type dimension )
{
const float minSize = GetMinimumSize( dimension );
const float maxSize = GetMaximumSize( dimension );
return std::max( minSize, std::min( size, maxSize ) );
}
-void Actor::NegotiateDimension( Dimension dimension, const Vector2& allocatedSize, ActorDimensionStack& recursionStack )
+void Actor::NegotiateDimension( Dimension::Type dimension, const Vector2& allocatedSize, ActorDimensionStack& recursionStack )
{
// Check if it needs to be negotiated
if( IsLayoutDirty( dimension ) && !IsLayoutNegotiated( dimension ) )
recursionStack.push_back( ActorDimensionPair( this, dimension ) );
// Dimension dependency check
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- Dimension dimensionToCheck = static_cast< Dimension >( 1 << i );
+ Dimension::Type dimensionToCheck = static_cast< Dimension::Type >( 1 << i );
if( RelayoutDependentOnDimension( dimension, dimensionToCheck ) )
{
{
for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
{
- Dali::Actor child = GetChildAt( i );
- Actor& childImpl = GetImplementation( child );
+ ActorPtr child = GetChildAt( i );
// Only relayout child first if it is not dependent on this actor
- if( !childImpl.RelayoutDependentOnParent( dimension ) )
+ if( !child->RelayoutDependentOnParent( dimension ) )
{
- childImpl.NegotiateDimension( dimension, allocatedSize, recursionStack );
+ child->NegotiateDimension( dimension, allocatedSize, recursionStack );
}
}
}
OnCalculateRelayoutSize( dimension );
// All dependencies checked, calculate the size and set negotiated flag
- const float newSize = ConstrainDimension( CalculateSize( dimension, allocatedSize ), dimension );
+ const float newSize = ClampDimension( CalculateSize( dimension, allocatedSize ), dimension );
SetNegotiatedDimension( newSize, dimension );
SetLayoutNegotiated( true, dimension );
// Negotiate all dimensions that require it
ActorDimensionStack recursionStack;
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- const Dimension dimension = static_cast< Dimension >( 1 << i );
+ const Dimension::Type dimension = static_cast< Dimension::Type >( 1 << i );
// Negotiate
NegotiateDimension( dimension, allocatedSize, recursionStack );
}
}
-Vector2 Actor::ApplySizeSetPolicy( const Vector2 size )
+Vector2 Actor::ApplySizeSetPolicy( const Vector2& size )
{
switch( mRelayoutData->sizeSetPolicy )
{
- case USE_SIZE_SET:
+ case SizeScalePolicy::USE_SIZE_SET:
{
return size;
}
- case FIT_WITH_ASPECT_RATIO:
+ case SizeScalePolicy::FIT_WITH_ASPECT_RATIO:
{
// Scale size to fit within the original size bounds, keeping the natural size aspect ratio
const Vector3 naturalSize = GetNaturalSize();
break;
}
- case FILL_WITH_ASPECT_RATIO:
+ case SizeScalePolicy::FILL_WITH_ASPECT_RATIO:
{
// Scale size to fill the original size bounds, keeping the natural size aspect ratio. Potentially exceeding the original bounds.
const Vector3 naturalSize = GetNaturalSize();
return size;
}
}
+ break;
}
default:
void Actor::SetNegotiatedSize( RelayoutContainer& container )
{
// Do the set actor size
- Vector2 negotiatedSize( GetLatestSize( WIDTH ), GetLatestSize( HEIGHT ) );
+ Vector2 negotiatedSize( GetLatestSize( Dimension::WIDTH ), GetLatestSize( Dimension::HEIGHT ) );
// Adjust for size set policy
negotiatedSize = ApplySizeSetPolicy( negotiatedSize );
void Actor::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.
+ DALI_LOG_TIMER_START( NegSizeTimer1 );
+
+ if( GetUseAssignedSize(Dimension::WIDTH ) )
+ {
+ SetLayoutNegotiated( false, Dimension::WIDTH );
+ }
+ if( GetUseAssignedSize( Dimension::HEIGHT ) )
+ {
+ SetLayoutNegotiated( false, Dimension::HEIGHT );
+ }
+
// Do the negotiation
NegotiateDimensions( allocatedSize );
SetNegotiatedSize( container );
// Negotiate down to children
- const Vector2 newBounds = GetTargetSize().GetVectorXY();
-
for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
{
- Dali::Actor child = GetChildAt( i );
+ 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->GetUseAssignedSize(Dimension::WIDTH) )
+ {
+ child->SetLayoutNegotiated(false, Dimension::WIDTH);
+ child->SetLayoutDirty(true, Dimension::WIDTH);
+ }
+
+ if( child->GetUseAssignedSize(Dimension::HEIGHT) )
+ {
+ child->SetLayoutNegotiated(false, Dimension::HEIGHT);
+ child->SetLayoutDirty(true, Dimension::HEIGHT);
+ }
// Only relayout if required
- if( GetImplementation( child ).RelayoutRequired() )
+ if( child->RelayoutRequired() )
{
- container.Add( child, newBounds );
+ container.Add( Dali::Actor( child.Get() ), mTargetSize.GetVectorXY() );
}
}
+ DALI_LOG_TIMER_END( NegSizeTimer1, gLogRelayoutFilter, Debug::Concise, "NegotiateSize() took: ");
}
-void Actor::RelayoutRequest( Dimension dimension )
+void Actor::SetUseAssignedSize( bool use, Dimension::Type dimension )
{
- Internal::RelayoutController* relayoutController = Internal::RelayoutController::Get();
- if( relayoutController )
+ if( mRelayoutData )
{
- Dali::Actor self( this );
- relayoutController->RequestRelayout( self, dimension );
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ mRelayoutData->useAssignedSize[ i ] = use;
+ }
+ }
}
}
-void Actor::RelayoutRequestTree()
+bool Actor::GetUseAssignedSize( Dimension::Type dimension ) const
{
- Internal::RelayoutController* relayoutController = Internal::RelayoutController::Get();
- if( relayoutController )
+ if ( mRelayoutData )
{
- Dali::Actor self( this );
- relayoutController->RequestRelayoutTree( self );
+ // If more than one dimension is requested, just return the first one found
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ return mRelayoutData->useAssignedSize[ i ];
+ }
+ }
}
+
+ return false;
}
-void Actor::PropagateRelayoutFlags()
+void Actor::RelayoutRequest( Dimension::Type dimension )
{
Internal::RelayoutController* relayoutController = Internal::RelayoutController::Get();
if( relayoutController )
{
Dali::Actor self( this );
- relayoutController->PropagateFlags( self );
+ relayoutController->RequestRelayout( self, dimension );
}
}
-void Actor::OnCalculateRelayoutSize( Dimension dimension )
+void Actor::OnCalculateRelayoutSize( Dimension::Type dimension )
{
}
-void Actor::OnLayoutNegotiated( float size, Dimension dimension )
+void Actor::OnLayoutNegotiated( float size, Dimension::Type dimension )
{
}
{
EnsureRelayoutData();
+ if( size.width > 0.0f )
+ {
+ SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
+ }
+
+ if( size.height > 0.0f )
+ {
+ SetResizePolicy( ResizePolicy::FIXED, Dimension::HEIGHT );
+ }
+
mRelayoutData->preferredSize = size;
RelayoutRequest();
Vector2 Actor::GetPreferredSize() const
{
- EnsureRelayoutData();
+ if ( mRelayoutData )
+ {
+ return Vector2( mRelayoutData->preferredSize );
+ }
- return mRelayoutData->preferredSize;
+ return GetDefaultPreferredSize();
}
-void Actor::SetMinimumSize( float size, Dimension dimension )
+void Actor::SetMinimumSize( float size, Dimension::Type dimension )
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
RelayoutRequest();
}
-float Actor::GetMinimumSize( Dimension dimension ) const
+float Actor::GetMinimumSize( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ if ( mRelayoutData )
{
- if( dimension & ( 1 << i ) )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
- return mRelayoutData->minimumSize[ i ];
+ if( dimension & ( 1 << i ) )
+ {
+ return mRelayoutData->minimumSize[ i ];
+ }
}
}
return 0.0f; // Default
}
-void Actor::SetMaximumSize( float size, Dimension dimension )
+void Actor::SetMaximumSize( float size, Dimension::Type dimension )
{
EnsureRelayoutData();
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
{
RelayoutRequest();
}
-float Actor::GetMaximumSize( Dimension dimension ) const
+float Actor::GetMaximumSize( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
+ if ( mRelayoutData )
+ {
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ return mRelayoutData->maximumSize[ i ];
+ }
+ }
+ }
+
+ return FLT_MAX; // Default
+}
+
+Object* Actor::GetParentObject() const
+{
+ return mParent;
+}
- for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+void Actor::SetVisibleInternal( bool visible, SendMessage::Type sendMessage )
+{
+ if( mVisible != visible )
{
- if( dimension & ( 1 << i ) )
+ if( sendMessage == SendMessage::TRUE && NULL != mNode )
{
- return mRelayoutData->maximumSize[ i ];
+ // mNode is being used in a separate thread; queue a message to set the value & base value
+ SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), mNode, &mNode->mVisible, &AnimatableProperty<bool>::Bake, visible );
}
+
+ mVisible = visible;
+
+ // Emit the signal on this actor and all its children
+ EmitVisibilityChangedSignalRecursively( this, visible, DevelActor::VisibilityChange::SELF );
}
+}
- return 0.0f; // Default
+void Actor::SetSiblingOrder( unsigned int order )
+{
+ if ( mParent )
+ {
+ ActorContainer& siblings = *(mParent->mChildren);
+ unsigned int currentOrder = GetSiblingOrder();
+
+ if( order != currentOrder )
+ {
+ if( order == 0 )
+ {
+ LowerToBottom();
+ }
+ else if( order < siblings.size() -1 )
+ {
+ if( order > currentOrder )
+ {
+ RaiseAbove( *siblings[order] );
+ }
+ else
+ {
+ LowerBelow( *siblings[order] );
+ }
+ }
+ else
+ {
+ RaiseToTop();
+ }
+ }
+ }
+}
+
+unsigned int Actor::GetSiblingOrder() const
+{
+ unsigned int order = 0;
+
+ if ( mParent )
+ {
+ ActorContainer& siblings = *(mParent->mChildren);
+ for( size_t i=0; i<siblings.size(); ++i )
+ {
+ if( siblings[i] == this )
+ {
+ order = i;
+ break;
+ }
+ }
+ }
+
+ return order;
+}
+
+void Actor::RequestRebuildDepthTree()
+{
+ if( mIsOnStage )
+ {
+ StagePtr stage = Stage::GetCurrent();
+ if( stage )
+ {
+ stage->RequestRebuildDepthTree();
+ }
+ }
+}
+
+void Actor::Raise()
+{
+ if ( mParent )
+ {
+ ActorContainer& siblings = *(mParent->mChildren);
+ if( siblings.back() != this ) // If not already at end
+ {
+ for( size_t i=0; i<siblings.size(); ++i )
+ {
+ if( siblings[i] == this )
+ {
+ // Swap with next
+ ActorPtr next = siblings[i+1];
+ siblings[i+1] = this;
+ siblings[i] = next;
+ break;
+ }
+ }
+ }
+ RequestRebuildDepthTree();
+ }
+ else
+ {
+ DALI_LOG_WARNING( "Actor must have a parent, Sibling order not changed.\n" );
+ }
+}
+
+void Actor::Lower()
+{
+ if ( mParent )
+ {
+ ActorContainer& siblings = *(mParent->mChildren);
+ if( siblings.front() != this ) // If not already at beginning
+ {
+ for( size_t i=1; i<siblings.size(); ++i )
+ {
+ if( siblings[i] == this )
+ {
+ // Swap with previous
+ ActorPtr previous = siblings[i-1];
+ siblings[i-1] = this;
+ siblings[i] = previous;
+ break;
+ }
+ }
+ }
+ RequestRebuildDepthTree();
+ }
+ else
+ {
+ DALI_LOG_WARNING( "Actor must have a parent, Sibling order not changed.\n" );
+ }
+}
+
+void Actor::RaiseToTop()
+{
+ if ( mParent )
+ {
+ ActorContainer& siblings = *(mParent->mChildren);
+ if( siblings.back() != this ) // If not already at end
+ {
+ ActorContainer::iterator iter = std::find( siblings.begin(), siblings.end(), this );
+ if( iter != siblings.end() )
+ {
+ siblings.erase(iter);
+ siblings.push_back(ActorPtr(this));
+ }
+ }
+ RequestRebuildDepthTree();
+ }
+ else
+ {
+ DALI_LOG_WARNING( "Actor must have a parent, Sibling order not changed.\n" );
+ }
+}
+
+void Actor::LowerToBottom()
+{
+ if ( mParent )
+ {
+ ActorContainer& siblings = *(mParent->mChildren);
+ if( siblings.front() != this ) // If not already at bottom,
+ {
+ ActorPtr thisPtr(this); // ensure this actor remains referenced.
+
+ ActorContainer::iterator iter = std::find( siblings.begin(), siblings.end(), this );
+ if( iter != siblings.end() )
+ {
+ siblings.erase(iter);
+ siblings.insert(siblings.begin(), thisPtr);
+ }
+ }
+ RequestRebuildDepthTree();
+ }
+ else
+ {
+ DALI_LOG_WARNING( "Actor must have a parent, Sibling order not changed.\n" );
+ }
+}
+
+void Actor::RaiseAbove( Internal::Actor& target )
+{
+ if ( mParent )
+ {
+ ActorContainer& siblings = *(mParent->mChildren);
+ if( siblings.back() != this && target.mParent == mParent ) // If not already at top
+ {
+ ActorPtr thisPtr(this); // ensure this actor remains referenced.
+
+ ActorContainer::iterator targetIter = std::find( siblings.begin(), siblings.end(), &target );
+ ActorContainer::iterator thisIter = std::find( siblings.begin(), siblings.end(), this );
+ if( thisIter < targetIter )
+ {
+ siblings.erase(thisIter);
+ // Erasing early invalidates the targetIter. (Conversely, inserting first may also
+ // invalidate thisIter)
+ targetIter = std::find( siblings.begin(), siblings.end(), &target );
+ ++targetIter;
+ siblings.insert(targetIter, thisPtr);
+ }
+ RequestRebuildDepthTree();
+ }
+ }
+ else
+ {
+ DALI_LOG_WARNING( "Actor must have a parent, Sibling order not changed.\n" );
+ }
+}
+
+void Actor::LowerBelow( Internal::Actor& target )
+{
+ if ( mParent )
+ {
+ ActorContainer& siblings = *(mParent->mChildren);
+ if( siblings.front() != this && target.mParent == mParent ) // If not already at bottom
+ {
+ ActorPtr thisPtr(this); // ensure this actor remains referenced.
+
+ ActorContainer::iterator targetIter = std::find( siblings.begin(), siblings.end(), &target );
+ ActorContainer::iterator thisIter = std::find( siblings.begin(), siblings.end(), this );
+
+ if( thisIter > targetIter )
+ {
+ siblings.erase(thisIter); // this only invalidates iterators at or after this point.
+ siblings.insert(targetIter, thisPtr);
+ }
+ RequestRebuildDepthTree();
+ }
+ }
+ else
+ {
+ DALI_LOG_WARNING( "Actor must have a parent, Sibling order not changed.\n" );
+ }
+}
+
+void Actor::SetInheritLayoutDirection( bool inherit )
+{
+ if( mInheritLayoutDirection != inherit )
+ {
+ mInheritLayoutDirection = inherit;
+
+ if( inherit && mParent )
+ {
+ InheritLayoutDirectionRecursively( this, mParent->mLayoutDirection );
+ }
+ }
+}
+
+bool Actor::IsLayoutDirectionInherited() const
+{
+ return mInheritLayoutDirection;
+}
+
+void Actor::InheritLayoutDirectionRecursively( ActorPtr actor, Dali::LayoutDirection::Type direction, bool set )
+{
+ if( actor && ( actor->mInheritLayoutDirection || set ) )
+ {
+ if( actor->mLayoutDirection != direction)
+ {
+ actor->mLayoutDirection = direction;
+ actor->EmitLayoutDirectionChangedSignal( direction );
+ actor->RelayoutRequest();
+ }
+
+ if( actor->GetChildCount() > 0 )
+ {
+ ActorContainer& children = actor->GetChildrenInternal();
+ for( ActorIter iter = children.begin(), endIter = children.end(); iter != endIter; ++iter )
+ {
+ InheritLayoutDirectionRecursively( *iter, direction );
+ }
+ }
+ }
}
} // namespace Internal
projects / platform / core / uifw / dali-core.git / blobdiff