/*
- * Copyright (c) 2015 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 <cmath>
#include <algorithm>
#include <cfloat>
-#include <cstring> // for strcmp
// 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/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/common/property-helper.h>
#include <dali/internal/event/common/stage-impl.h>
#include <dali/internal/event/common/type-info-impl.h>
-#include <dali/internal/event/actor-attachments/actor-attachment-impl.h>
-#include <dali/internal/event/actor-attachments/renderer-attachment-impl.h>
#include <dali/internal/event/animation/constraint-impl.h>
#include <dali/internal/event/common/projection.h>
#include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
#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
{
-namespace ResizePolicy
-{
-namespace
+namespace Internal
{
-DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )DALI_ENUM_TO_STRING( FIXED )
-DALI_ENUM_TO_STRING( USE_NATURAL_SIZE )
-DALI_ENUM_TO_STRING( FILL_TO_PARENT )
-DALI_ENUM_TO_STRING( SIZE_RELATIVE_TO_PARENT )
-DALI_ENUM_TO_STRING( SIZE_FIXED_OFFSET_FROM_PARENT )
-DALI_ENUM_TO_STRING( FIT_TO_CHILDREN )
-DALI_ENUM_TO_STRING( DIMENSION_DEPENDENCY )
-DALI_ENUM_TO_STRING( USE_ASSIGNED_SIZE )
-DALI_ENUM_TO_STRING_TABLE_END( Type )
-} // unnamed namespace
-} // ResizePolicy
+unsigned int Actor::mActorCounter = 0;
-namespace SizeScalePolicy
-{
namespace
{
-// Enumeration to / from string conversion tables
-DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )DALI_ENUM_TO_STRING( USE_SIZE_SET )
-DALI_ENUM_TO_STRING( FIT_WITH_ASPECT_RATIO )
-DALI_ENUM_TO_STRING( FILL_WITH_ASPECT_RATIO )
-DALI_ENUM_TO_STRING_TABLE_END( Type )
-} // unnamed namespace
-} // SizeScalePolicy
+/// Using a function because of library initialisation order. Vector3::ONE may not have been initialised yet.
+inline const Vector3& GetDefaultSizeModeFactor()
+{
+ return Vector3::ONE;
+}
-namespace Internal
+/// Using a function because of library initialisation order. Vector2::ZERO may not have been initialised yet.
+inline const Vector2& GetDefaultPreferredSize()
{
+ return Vector2::ZERO;
+}
-unsigned int Actor::mActorCounter = 0;
+/// 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( SizeScalePolicy::USE_SIZE_SET ), 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::DIMENSION_COUNT; ++i )
{
- resizePolicies[ i ] = ResizePolicy::FIXED;
+ resizePolicies[ i ] = ResizePolicy::DEFAULT;
+ useAssignedSize[ i ] = false;
negotiatedDimensions[ i ] = 0.0f;
dimensionNegotiated[ i ] = false;
dimensionDirty[ i ] = false;
dimensionDependencies[ i ] = Dimension::ALL_DIMENSIONS;
- dimensionPadding[ i ] = Vector2( 0.0f, 0.0f );
+ dimensionPadding[ i ] = GetDefaultDimensionPadding();
minimumSize[ i ] = 0.0f;
maximumSize[ i ] = FLT_MAX;
}
}
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::Type dimensionDependencies[ Dimension::DIMENSION_COUNT ]; ///< A list of dimension dependencies
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-factor", VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR )
-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( "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
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
*
{
return values.width;
}
-
case Dimension::HEIGHT:
{
return values.height;
}
-
default:
{
break;
}
}
-
return 0.0f;
}
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() )
{
}
}
-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() );
+ 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 )
{
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 );
}
}
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 );
}
}
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 );
}
}
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 );
}
}
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 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 )
{
Vector3 normalizedAxis( axis.x, axis.y, axis.z );
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 );
}
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 ) );
}
void Actor::SetSizeInternal( const Vector2& size )
{
- SetSizeInternal( Vector3( size.width, size.height, CalculateSizeZ( size ) ) );
-}
-
-float Actor::CalculateSizeZ( const Vector2& size ) const
-{
- return std::min( size.width, size.height );
+ SetSizeInternal( Vector3( size.width, size.height, 0.f ) );
}
void Actor::SetSize( const Vector3& size )
{
if( IsRelayoutEnabled() && !mRelayoutData->insideRelayout )
{
+ // TODO we cannot just ignore the given Z but that means rewrite the size negotiation!!
SetPreferredSize( size.GetVectorXY() );
}
else
void Actor::SetSizeInternal( const Vector3& size )
{
- if( NULL != mNode )
+ // 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
{
EnsureRelayoutData();
+ 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;
+ }
}
}
// If calling SetResizePolicy, assume we want relayout enabled
SetRelayoutEnabled( true );
+ // 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( 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
ResizePolicy::Type Actor::GetResizePolicy( 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::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->resizePolicies[ i ];
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ if( mRelayoutData->useAssignedSize[ i ] )
+ {
+ return ResizePolicy::USE_ASSIGNED_SIZE;
+ }
+ else
+ {
+ return mRelayoutData->resizePolicies[ i ];
+ }
+ }
}
}
- return ResizePolicy::FIXED; // Default
+ return ResizePolicy::DEFAULT;
}
void Actor::SetSizeScalePolicy( SizeScalePolicy::Type policy )
SizeScalePolicy::Type Actor::GetSizeScalePolicy() const
{
- EnsureRelayoutData();
+ if ( mRelayoutData )
+ {
+ return mRelayoutData->sizeSetPolicy;
+ }
- return mRelayoutData->sizeSetPolicy;
+ return DEFAULT_SIZE_SCALE_POLICY;
}
void Actor::SetDimensionDependency( Dimension::Type dimension, Dimension::Type dependency )
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::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 ];
+ }
}
}
{
EnsureRelayoutData();
+ DALI_ASSERT_DEBUG( mRelayoutData && "mRelayoutData not created" );
+
mRelayoutData->relayoutEnabled = relayoutEnabled;
}
}
bool Actor::IsLayoutDirty( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- for( unsigned int i = 0; i < Dimension::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;
+ }
}
}
bool Actor::RelayoutPossible( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- return mRelayoutData->relayoutEnabled && !IsLayoutDirty( dimension );
+ return mRelayoutData && mRelayoutData->relayoutEnabled && !IsLayoutDirty( dimension );
}
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" );
-
- return attachment->GetRenderer();
-}
-
-void Actor::RemoveRenderer( Renderer& renderer )
-{
- //TODO: MESH_REWORK : Add support for multiple renderers
- mAttachment = NULL;
-}
-
-void Actor::RemoveRenderer( unsigned int index )
-{
- //TODO: MESH_REWORK : Add support for multiple renderers
- mAttachment = NULL;
-}
-
-
-#ifdef DYNAMICS_SUPPORT
-
-//--------------- Dynamics ---------------
-
-void Actor::DisableDynamics()
-{
- if( NULL != mDynamicsData )
- {
- 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() )
- {
- DynamicsJointPtr joint( *(mDynamicsData->referencedJoints.begin()) );
- ActorPtr jointOwner( joint->GetActor( true ) );
- if( jointOwner )
- {
- jointOwner->RemoveDynamicsJoint( joint );
- }
- else
- {
- mDynamicsData->referencedJoints.erase( mDynamicsData->referencedJoints.begin() );
- }
- }
- // delete the DynamicsBody object
- mDynamicsData->body.Reset();
-
- // Discard Dynamics data structure
- delete mDynamicsData;
- mDynamicsData = NULL;
- }
-}
-
-DynamicsBodyPtr Actor::GetDynamicsBody() const
-{
- DynamicsBodyPtr body;
-
- if( NULL != mDynamicsData )
- {
- body = mDynamicsData->body;
- }
-
- return body;
-}
-
-DynamicsBodyPtr Actor::EnableDynamics(DynamicsBodyConfigPtr bodyConfig)
-{
- DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s- (\"%s\")\n", __PRETTY_FUNCTION__, mName.c_str());
-
- if( NULL == mDynamicsData )
- {
- mDynamicsData = new DynamicsData( this );
- }
-
- if( !mDynamicsData->body )
- {
- 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() );
- }
- }
- }
- }
-
- return mDynamicsData->body;
-}
-
-DynamicsJointPtr Actor::AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offset )
-{
- DALI_ASSERT_ALWAYS( attachedActor && "'attachedActor' must be initialized!" );
- return AddDynamicsJoint( attachedActor, offset, ( GetCurrentPosition() + offset ) - attachedActor->GetCurrentPosition() );
-}
-
-DynamicsJointPtr Actor::AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offsetA, const Vector3& offsetB )
-{
- 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 )
- {
- if( NULL != mDynamicsData )
- {
- DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
-
- if( mDynamicsData->joints.end() != it )
- {
- // use existing joint
- joint = it->second;
- }
-
- if( !joint )
- {
- 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 );
- }
- }
- }
- return joint;
-}
-
-const int Actor::GetNumberOfJoints() const
-{
- return static_cast<int>( NULL != mDynamicsData ? mDynamicsData->joints.size() : 0 );
-}
-
-DynamicsJointPtr Actor::GetDynamicsJointByIndex( const int index ) const
-{
- DynamicsJointPtr joint;
-
- if( NULL != mDynamicsData )
+ unsigned int rendererCount(0);
+ if( mRenderers )
{
- if( index >= 0 && index < static_cast<int>(mDynamicsData->joints.size()) )
- {
- DynamicsData::JointContainer::const_iterator it( mDynamicsData->joints.begin() );
-
- for( int i = 0; i < index; ++i )
- {
- ++it;
- }
-
- joint = it->second;
- }
+ rendererCount = mRenderers->size();
}
- return joint;
+ return rendererCount;
}
-DynamicsJointPtr Actor::GetDynamicsJoint( ActorPtr attachedActor ) const
+RendererPtr Actor::GetRendererAt( unsigned int index )
{
- DynamicsJointPtr joint;
-
- if( NULL != mDynamicsData )
+ RendererPtr renderer;
+ if( index < GetRendererCount() )
{
- DynamicsData::JointContainer::const_iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
-
- if( mDynamicsData->joints.end() != it )
- {
- // use existing joint
- joint = it->second;
- }
+ renderer = ( *mRenderers )[ index ];
}
- return joint;
+ return renderer;
}
-void Actor::RemoveDynamicsJoint( DynamicsJointPtr joint )
+void Actor::RemoveRenderer( Renderer& renderer )
{
- if( NULL != mDynamicsData )
+ if( mRenderers )
{
- DynamicsData::JointContainer::iterator it( mDynamicsData->joints.begin() );
- DynamicsData::JointContainer::iterator endIt( mDynamicsData->joints.end() );
-
- for(; it != endIt; ++it )
+ RendererIter end = mRenderers->end();
+ for( RendererIter iter = mRenderers->begin(); iter != end; ++iter )
{
- if( it->second == joint.Get() )
+ if( (*iter).Get() == &renderer )
{
- ActorPtr attachedActor( it->first );
-
- if( OnStage() && attachedActor && attachedActor->OnStage() )
- {
- joint->Disconnect( GetEventThreadServices() );
- }
-
- if( attachedActor )
- {
- attachedActor->ReleaseJoint( joint );
- attachedActor->OnStageSignal().Disconnect( mDynamicsData->slotDelegate, &Actor::AttachedActorOnStage );
- attachedActor->OffStageSignal().Disconnect( mDynamicsData->slotDelegate, &Actor::AttachedActorOffStage );
- }
-
- mDynamicsData->joints.erase(it);
+ mRenderers->erase( iter );
+ RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
break;
}
}
}
}
-void Actor::ReferenceJoint( DynamicsJointPtr joint )
-{
- DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" );
-
- if( NULL != mDynamicsData )
- {
- mDynamicsData->referencedJoints.push_back(joint);
- }
-}
-
-void Actor::ReleaseJoint( DynamicsJointPtr joint )
-{
- DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" );
-
- if( NULL != mDynamicsData )
- {
- DynamicsData::ReferencedJointContainer::iterator it( std::find( mDynamicsData->referencedJoints.begin(), mDynamicsData->referencedJoints.end(), joint ) );
-
- if( it != mDynamicsData->referencedJoints.end() )
- {
- mDynamicsData->referencedJoints.erase( it );
- }
- }
-}
-
-void Actor::SetDynamicsRoot(bool flag)
-{
- if( mIsDynamicsRoot != flag )
- {
- mIsDynamicsRoot = flag;
-
- if( OnStage() && mChildren )
- {
- // 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();
- }
- }
- }
- }
- }
-}
-
-bool Actor::IsDynamicsRoot() const
-{
- return mIsDynamicsRoot;
-}
-
-void Actor::AttachedActorOnStage( Dali::Actor actor )
-{
- DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s\n", __PRETTY_FUNCTION__);
-
- if( OnStage() )
- {
- ActorPtr attachedActor( &GetImplementation(actor) );
-
- 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() );
- }
- }
- }
-}
-
-void Actor::AttachedActorOffStage( Dali::Actor actor )
-{
- DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s\n", __PRETTY_FUNCTION__);
-
- if( OnStage() )
- {
- ActorPtr attachedActor( &GetImplementation(actor) );
-
- 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() );
- }
- }
- }
-}
-
-void Actor::ConnectDynamics()
-{
- if( NULL != mDynamicsData && mDynamicsData->body )
- {
- if( OnStage() && mParent && mParent->IsDynamicsRoot() )
- {
- mDynamicsData->body->Connect( GetEventThreadServices() );
-
- // 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 )
+void Actor::RemoveRenderer( unsigned int index )
{
- // Setting STENCIL will override OVERLAY
- if( DrawMode::STENCIL != mDrawMode )
+ if( index < GetRendererCount() )
{
- SetDrawMode( enable ? DrawMode::OVERLAY : DrawMode::NORMAL );
+ RendererPtr renderer = ( *mRenderers )[ index ];
+ RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.Get()->GetRendererSceneObject() );
+ mRenderers->erase( mRenderers->begin()+index );
}
}
bool Actor::IsOverlay() const
{
- return ( DrawMode::OVERLAY == mDrawMode );
+ return ( DrawMode::OVERLAY_2D == mDrawMode );
}
void Actor::SetDrawMode( DrawMode::Type drawMode )
{
// this flag is not animatable so keep the value
mDrawMode = drawMode;
- if( NULL != mNode )
+ if( ( NULL != mNode ) && ( drawMode != DrawMode::STENCIL ) )
{
// mNode is being used in a separate thread; queue a message to set the value
SetDrawModeMessage( GetEventThreadServices(), *mNode, drawMode );
bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const
{
// only valid when on-stage
- if( OnStage() )
+ StagePtr stage = Stage::GetCurrent();
+ if( stage && OnStage() )
{
- const RenderTaskList& taskList = Stage::GetCurrent()->GetRenderTaskList();
+ const RenderTaskList& taskList = stage->GetRenderTaskList();
Vector2 converted( screenX, screenY );
return false;
}
-bool Actor::ScreenToLocal( RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const
+bool Actor::ScreenToLocal( const RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const
{
bool retval = false;
// only valid when on-stage
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 );
+ // Get the ModelView matrix
+ Matrix modelView;
+ Matrix::Multiply( modelView, mNode->GetWorldMatrix(0), viewMatrix );
// Calculate the inverted ModelViewProjection matrix; this will be used for 2 unprojects
Matrix invertedMvp( false/*don't init*/);
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
+ 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
connected = false;
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();
- }
-
-#ifdef DYNAMICS_SUPPORT
- // Notify dynamics
- if( NULL != mDynamicsData )
- {
- ConnectDynamics();
+ ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode );
}
-#endif
// Request relayout on all actors that are added to the scenegraph
RelayoutRequest();
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_POSITION:
+ {
+ SetInheritPosition( property.Get< bool >() );
+ break;
+ }
+
case Dali::Actor::Property::INHERIT_ORIENTATION:
{
SetInheritOrientation( property.Get< bool >() );
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 >() ) );
+ DrawMode::Type mode = mDrawMode;
+ if( Scripting::GetEnumerationProperty< DrawMode::Type >( property, DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT, mode ) )
+ {
+ SetDrawMode( mode );
+ }
break;
}
case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
{
- SetResizePolicy( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount ), Dimension::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::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount ), Dimension::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::Type >( property.Get< std::string >().c_str(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount ) );
+ 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;
}
break;
}
+ case Dali::DevelActor::Property::SIBLING_ORDER:
+ {
+ 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;
+ }
+
default:
{
// this can happen in the case of a non-animatable default property so just do nothing
// TODO: This method needs to be removed
void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value )
{
- switch( entry.type )
+ switch( entry.GetType() )
{
case Property::BOOLEAN:
{
break;
}
- case Property::UNSIGNED_INTEGER:
- {
- const AnimatableProperty< unsigned int >* property = dynamic_cast< const AnimatableProperty< unsigned 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<unsigned int>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<unsigned int>::Bake, value.Get<unsigned int>() );
-
- break;
- }
-
case Property::FLOAT:
{
const AnimatableProperty< float >* property = dynamic_cast< const AnimatableProperty< float >* >( entry.GetSceneGraphProperty() );
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;
- }
+ // 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_X:
- {
- value = GetCurrentParentOrigin().x;
- break;
- }
+ return value;
+}
- case Dali::Actor::Property::PARENT_ORIGIN_Y:
- {
- value = GetCurrentParentOrigin().y;
- break;
- }
+Property::Value Actor::GetDefaultPropertyCurrentValue( Property::Index index ) const
+{
+ Property::Value value;
- case Dali::Actor::Property::PARENT_ORIGIN_Z:
- {
- value = GetCurrentParentOrigin().z;
- 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:
- {
- value = GetCurrentAnchorPoint();
- break;
- }
+ return value;
+}
- case Dali::Actor::Property::ANCHOR_POINT_X:
+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().x;
- 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_Y:
- {
- value = GetCurrentAnchorPoint().y;
- break;
- }
+ case Dali::Actor::Property::SIZE_WIDTH:
+ {
+ if( value.Get( mTargetSize.width ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
- case Dali::Actor::Property::ANCHOR_POINT_Z:
- {
- value = GetCurrentAnchorPoint().z;
- break;
- }
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ {
+ if( value.Get( mTargetSize.height ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
- case Dali::Actor::Property::SIZE:
- {
- value = GetCurrentSize();
- break;
- }
+ case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ if( value.Get( mTargetSize.depth ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
- case Dali::Actor::Property::SIZE_WIDTH:
- {
- value = GetCurrentSize().width;
- break;
- }
+ case Dali::Actor::Property::POSITION:
+ {
+ value.Get( mTargetPosition );
+ break;
+ }
- case Dali::Actor::Property::SIZE_HEIGHT:
- {
- value = GetCurrentSize().height;
- break;
- }
+ case Dali::Actor::Property::POSITION_X:
+ {
+ value.Get( mTargetPosition.x );
+ break;
+ }
- case Dali::Actor::Property::SIZE_DEPTH:
- {
- value = GetCurrentSize().depth;
- break;
- }
+ case Dali::Actor::Property::POSITION_Y:
+ {
+ value.Get( mTargetPosition.y );
+ break;
+ }
- case Dali::Actor::Property::POSITION:
- {
- value = GetCurrentPosition();
- break;
- }
+ case Dali::Actor::Property::POSITION_Z:
+ {
+ value.Get( mTargetPosition.z );
+ break;
+ }
- case Dali::Actor::Property::POSITION_X:
- {
- value = GetCurrentPosition().x;
- break;
- }
+ case Dali::Actor::Property::ORIENTATION:
+ {
+ value.Get( mTargetOrientation );
+ break;
+ }
- case Dali::Actor::Property::POSITION_Y:
- {
- value = GetCurrentPosition().y;
- break;
- }
+ case Dali::Actor::Property::SCALE:
+ {
+ value.Get( mTargetScale );
+ break;
+ }
- case Dali::Actor::Property::POSITION_Z:
- {
- value = GetCurrentPosition().z;
- break;
- }
+ case Dali::Actor::Property::SCALE_X:
+ {
+ value.Get( mTargetScale.x );
+ break;
+ }
- case Dali::Actor::Property::WORLD_POSITION:
+ case Dali::Actor::Property::SCALE_Y:
+ {
+ value.Get( mTargetScale.y );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ value.Get( mTargetScale.z );
+ break;
+ }
+
+ case Dali::Actor::Property::VISIBLE:
+ {
+ SetVisibleInternal( value.Get< bool >(), SendMessage::FALSE );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR:
+ {
+ value.Get( mTargetColor );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ value.Get( mTargetColor.r );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ value.Get( mTargetColor.g );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ value.Get( mTargetColor.b );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
+ {
+ value.Get( mTargetColor.a );
+ break;
+ }
+
+ default:
+ {
+ // Not an animatable property. Do nothing.
+ break;
+ }
+ }
+ break;
+ }
+
+ case Animation::BY:
{
- value = GetCurrentWorldPosition();
+ switch( index )
+ {
+ case Dali::Actor::Property::SIZE:
+ {
+ if( AdjustValue< Vector3 >( mTargetSize, value ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_WIDTH:
+ {
+ if( AdjustValue< float >( mTargetSize.width, value ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ {
+ if( AdjustValue< float >( mTargetSize.height, value ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ if( AdjustValue< float >( mTargetSize.depth, value ) )
+ {
+ // Notify deriving classes
+ OnSizeAnimation( animation, mTargetSize );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION:
+ {
+ AdjustValue< Vector3 >( mTargetPosition, value );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_X:
+ {
+ AdjustValue< float >( mTargetPosition.x, value );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Y:
+ {
+ AdjustValue< float >( mTargetPosition.y, value );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Z:
+ {
+ AdjustValue< float >( mTargetPosition.z, value );
+ break;
+ }
+
+ case Dali::Actor::Property::ORIENTATION:
+ {
+ Quaternion relativeValue;
+ if( value.Get( relativeValue ) )
+ {
+ mTargetOrientation *= relativeValue;
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE:
+ {
+ AdjustValue< Vector3 >( mTargetScale, value );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_X:
+ {
+ AdjustValue< float >( mTargetScale.x, value );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Y:
+ {
+ AdjustValue< float >( mTargetScale.y, value );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ AdjustValue< float >( mTargetScale.z, value );
+ 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:
+ {
+ AdjustValue< Vector4 >( mTargetColor, value );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ AdjustValue< float >( mTargetColor.r, value );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ AdjustValue< float >( mTargetColor.g, value );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ AdjustValue< float >( mTargetColor.b, value );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
+ {
+ AdjustValue< float >( mTargetColor.a, value );
+ break;
+ }
+
+ default:
+ {
+ // Not an animatable property. Do nothing.
+ break;
+ }
+ }
break;
}
+ }
+}
+
+const SceneGraph::PropertyOwner* Actor::GetPropertyOwner() const
+{
+ return mNode;
+}
+
+const SceneGraph::PropertyOwner* Actor::GetSceneObject() const
+{
+ // This method should only return an object connected to the scene-graph
+ return OnStage() ? mNode : NULL;
+}
+
+const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index index ) const
+{
+ DALI_ASSERT_ALWAYS( IsPropertyAnimatable( index ) && "Property is not animatable" );
+
+ const PropertyBase* property( NULL );
+
+ // This method should only return a property of an object connected to the scene-graph
+ if( !OnStage() )
+ {
+ return property;
+ }
+
+ 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" );
+
+ 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::SIZE:
+ property = &mNode->mSize;
+ break;
+
+ case Dali::Actor::Property::SIZE_WIDTH:
+ property = &mNode->mSize;
+ 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 property;
+}
+
+const PropertyInputImpl* Actor::GetSceneObjectInputProperty( Property::Index index ) const
+{
+ const PropertyInputImpl* property( NULL );
+
+ // This method should only return a property of an object connected to the scene-graph
+ if( !OnStage() )
+ {
+ return property;
+ }
+
+ 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" );
+
+ 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::WORLD_POSITION_X:
- {
- value = GetCurrentWorldPosition().x;
- break;
- }
+ case Dali::Actor::Property::PARENT_ORIGIN_Y:
+ property = &mNode->mParentOrigin;
+ break;
- case Dali::Actor::Property::WORLD_POSITION_Y:
- {
- value = GetCurrentWorldPosition().y;
- 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;
+
+ case Dali::Actor::Property::ANCHOR_POINT_Y:
+ property = &mNode->mAnchorPoint;
+ break;
+
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
+ property = &mNode->mAnchorPoint;
+ break;
+
+ case Dali::Actor::Property::SIZE:
+ property = &mNode->mSize;
+ break;
+
+ case Dali::Actor::Property::SIZE_WIDTH:
+ property = &mNode->mSize;
+ 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::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;
+
+ 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::WORLD_SCALE:
+ property = &mNode->mWorldScale;
+ 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;
+ }
+
+ case Dali::Actor::Property::WORLD_COLOR:
+ property = &mNode->mWorldColor;
+ break;
+
+ case Dali::Actor::Property::WORLD_MATRIX:
+ property = &mNode->mWorldMatrix;
+ break;
+
+ default:
+ break;
}
+ }
- case Dali::Actor::Property::WORLD_POSITION_Z:
+ 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 )
{
- value = GetCurrentWorldPosition().z;
- break;
+ componentIndex = animatableProperty->componentIndex;
}
-
- case Dali::Actor::Property::ORIENTATION:
+ }
+ else
+ {
+ switch( index )
{
- value = GetCurrentOrientation();
- break;
+ 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;
+ }
}
+ }
- case Dali::Actor::Property::WORLD_ORIENTATION:
+ 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() )
{
- value = GetCurrentWorldOrientation();
- break;
+ // Instruct each actor to create a corresponding node in the scene graph
+ ConnectToStage( parent->GetHierarchyDepth() );
}
- case Dali::Actor::Property::SCALE:
+ // 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() )
{
- value = GetCurrentScale();
- break;
+ 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();
}
+ }
+}
- case Dali::Actor::Property::SCALE_X:
- {
- value = GetCurrentScale().x;
- break;
- }
+SceneGraph::Node* Actor::CreateNode() const
+{
+ return Node::New();
+}
- case Dali::Actor::Property::SCALE_Y:
- {
- value = GetCurrentScale().y;
- break;
- }
+bool Actor::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& /* attributes */ )
+{
+ bool done = false;
+ Actor* actor = dynamic_cast< Actor* >( object );
- case Dali::Actor::Property::SCALE_Z:
+ if( actor )
+ {
+ if( 0 == actionName.compare( ACTION_SHOW ) )
{
- value = GetCurrentScale().z;
- break;
+ actor->SetVisible( true );
+ done = true;
}
-
- case Dali::Actor::Property::WORLD_SCALE:
+ else if( 0 == actionName.compare( ACTION_HIDE ) )
{
- value = GetCurrentWorldScale();
- break;
+ actor->SetVisible( false );
+ done = true;
}
+ }
- case Dali::Actor::Property::VISIBLE:
- {
- value = IsVisible();
- break;
- }
+ return done;
+}
- case Dali::Actor::Property::COLOR:
- {
- value = GetCurrentColor();
- break;
- }
+bool Actor::GetCachedPropertyValue( Property::Index index, Property::Value& value ) const
+{
+ bool valueSet = true;
- case Dali::Actor::Property::COLOR_RED:
+ switch( index )
+ {
+ case Dali::Actor::Property::PARENT_ORIGIN:
{
- value = GetCurrentColor().r;
+ value = GetCurrentParentOrigin();
break;
}
- case Dali::Actor::Property::COLOR_GREEN:
+ case Dali::Actor::Property::PARENT_ORIGIN_X:
{
- value = GetCurrentColor().g;
+ value = GetCurrentParentOrigin().x;
break;
}
- case Dali::Actor::Property::COLOR_BLUE:
+ case Dali::Actor::Property::PARENT_ORIGIN_Y:
{
- value = GetCurrentColor().b;
+ value = GetCurrentParentOrigin().y;
break;
}
- case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
{
- value = GetCurrentColor().a;
+ value = GetCurrentParentOrigin().z;
break;
}
- case Dali::Actor::Property::WORLD_COLOR:
+ case Dali::Actor::Property::ANCHOR_POINT:
{
- value = GetCurrentWorldColor();
+ value = GetCurrentAnchorPoint();
break;
}
- case Dali::Actor::Property::WORLD_MATRIX:
+ case Dali::Actor::Property::ANCHOR_POINT_X:
{
- value = GetCurrentWorldMatrix();
+ value = GetCurrentAnchorPoint().x;
break;
}
- case Dali::Actor::Property::NAME:
+ case Dali::Actor::Property::ANCHOR_POINT_Y:
{
- value = GetName();
+ value = GetCurrentAnchorPoint().y;
break;
}
- case Dali::Actor::Property::SENSITIVE:
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
{
- value = IsSensitive();
+ value = GetCurrentAnchorPoint().z;
break;
}
- case Dali::Actor::Property::LEAVE_REQUIRED:
+ case Dali::Actor::Property::SIZE:
{
- value = GetLeaveRequired();
+ value = GetTargetSize();
break;
}
- case Dali::Actor::Property::INHERIT_ORIENTATION:
+ case Dali::Actor::Property::SIZE_WIDTH:
{
- value = IsOrientationInherited();
+ value = GetTargetSize().width;
break;
}
- case Dali::Actor::Property::INHERIT_SCALE:
+ case Dali::Actor::Property::SIZE_HEIGHT:
{
- value = IsScaleInherited();
+ value = GetTargetSize().height;
break;
}
- case Dali::Actor::Property::COLOR_MODE:
+ case Dali::Actor::Property::SIZE_DEPTH:
{
- value = Scripting::GetColorMode( GetColorMode() );
+ value = GetTargetSize().depth;
break;
}
- case Dali::Actor::Property::POSITION_INHERITANCE:
+ case Dali::Actor::Property::POSITION:
{
- value = Scripting::GetPositionInheritanceMode( GetPositionInheritanceMode() );
+ value = GetTargetPosition();
break;
}
- case Dali::Actor::Property::DRAW_MODE:
+ case Dali::Actor::Property::POSITION_X:
{
- value = Scripting::GetDrawMode( GetDrawMode() );
+ value = GetTargetPosition().x;
break;
}
- case Dali::Actor::Property::SIZE_MODE_FACTOR:
+ case Dali::Actor::Property::POSITION_Y:
{
- value = GetSizeModeFactor();
+ value = GetTargetPosition().y;
break;
}
- case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
+ case Dali::Actor::Property::POSITION_Z:
{
- value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::WIDTH ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount );
+ value = GetTargetPosition().z;
break;
}
- case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
+ case Dali::Actor::Property::ORIENTATION:
{
- value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::HEIGHT ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount );
+ value = mTargetOrientation;
break;
}
- case Dali::Actor::Property::SIZE_SCALE_POLICY:
+ case Dali::Actor::Property::SCALE:
{
- value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount );
+ value = mTargetScale;
break;
}
- case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
+ case Dali::Actor::Property::SCALE_X:
{
- value = ( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::WIDTH ) == Dimension::HEIGHT );
+ value = mTargetScale.x;
break;
}
- case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
+ case Dali::Actor::Property::SCALE_Y:
{
- value = ( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::HEIGHT ) == Dimension::WIDTH );
+ value = mTargetScale.y;
break;
}
- case Dali::Actor::Property::PADDING:
+ case Dali::Actor::Property::SCALE_Z:
{
- Vector2 widthPadding = GetPadding( Dimension::WIDTH );
- Vector2 heightPadding = GetPadding( Dimension::HEIGHT );
- value = Vector4( widthPadding.x, widthPadding.y, heightPadding.x, heightPadding.y );
+ value = mTargetScale.z;
break;
}
- case Dali::Actor::Property::MINIMUM_SIZE:
+ case Dali::Actor::Property::VISIBLE:
{
- value = Vector2( GetMinimumSize( Dimension::WIDTH ), GetMinimumSize( Dimension::HEIGHT ) );
+ value = mVisible;
break;
}
- case Dali::Actor::Property::MAXIMUM_SIZE:
+ case Dali::Actor::Property::COLOR:
{
- value = Vector2( GetMaximumSize( Dimension::WIDTH ), GetMaximumSize( Dimension::HEIGHT ) );
+ value = mTargetColor;
break;
}
- default:
+ case Dali::Actor::Property::COLOR_RED:
{
- DALI_ASSERT_ALWAYS( false && "Actor Property index invalid" ); // should not come here
+ value = mTargetColor.r;
break;
}
- }
-
- return value;
-}
-
-const SceneGraph::PropertyOwner* Actor::GetPropertyOwner() const
-{
- return mNode;
-}
-
-const SceneGraph::PropertyOwner* Actor::GetSceneObject() const
-{
- // This method should only return an object connected to the scene-graph
- return OnStage() ? mNode : NULL;
-}
-
-const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index index ) const
-{
- DALI_ASSERT_ALWAYS( IsPropertyAnimatable( index ) && "Property is not animatable" );
-
- const PropertyBase* property( NULL );
-
- // This method should only return a property of an object connected to the scene-graph
- if( !OnStage() )
- {
- return property;
- }
-
- 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" );
-
- 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::SIZE:
- property = &mNode->mSize;
- break;
-
- case Dali::Actor::Property::SIZE_WIDTH:
- property = &mNode->mSize;
- 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:
- property = &mNode->mColor;
- break;
-
- default:
- break;
- }
- }
-
- return property;
-}
-
-const PropertyInputImpl* Actor::GetSceneObjectInputProperty( Property::Index index ) const
-{
- const PropertyInputImpl* property( NULL );
- // This method should only return a property of an object connected to the scene-graph
- if( !OnStage() )
- {
- return property;
- }
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ value = mTargetColor.g;
+ 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::COLOR_BLUE:
+ {
+ value = mTargetColor.b;
+ break;
+ }
- 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::COLOR_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
{
- case Dali::Actor::Property::PARENT_ORIGIN:
- property = &mNode->mParentOrigin;
- break;
+ value = mTargetColor.a;
+ break;
+ }
- case Dali::Actor::Property::PARENT_ORIGIN_X:
- property = &mNode->mParentOrigin;
- break;
+ case Dali::Actor::Property::NAME:
+ {
+ value = GetName();
+ break;
+ }
- case Dali::Actor::Property::PARENT_ORIGIN_Y:
- property = &mNode->mParentOrigin;
- break;
+ case Dali::Actor::Property::SENSITIVE:
+ {
+ value = IsSensitive();
+ break;
+ }
- case Dali::Actor::Property::PARENT_ORIGIN_Z:
- property = &mNode->mParentOrigin;
- break;
+ case Dali::Actor::Property::LEAVE_REQUIRED:
+ {
+ value = GetLeaveRequired();
+ break;
+ }
- case Dali::Actor::Property::ANCHOR_POINT:
- property = &mNode->mAnchorPoint;
- break;
+ case Dali::Actor::Property::INHERIT_POSITION:
+ {
+ value = IsPositionInherited();
+ break;
+ }
- case Dali::Actor::Property::ANCHOR_POINT_X:
- property = &mNode->mAnchorPoint;
- break;
+ case Dali::Actor::Property::INHERIT_ORIENTATION:
+ {
+ value = IsOrientationInherited();
+ break;
+ }
- case Dali::Actor::Property::ANCHOR_POINT_Y:
- property = &mNode->mAnchorPoint;
- break;
+ case Dali::Actor::Property::INHERIT_SCALE:
+ {
+ value = IsScaleInherited();
+ break;
+ }
- case Dali::Actor::Property::ANCHOR_POINT_Z:
- property = &mNode->mAnchorPoint;
- break;
+ case Dali::Actor::Property::COLOR_MODE:
+ {
+ value = Scripting::GetLinearEnumerationName< ColorMode >( GetColorMode(), COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT );
+ break;
+ }
- case Dali::Actor::Property::SIZE:
- property = &mNode->mSize;
- 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::SIZE_WIDTH:
- property = &mNode->mSize;
- 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::SIZE_HEIGHT:
- property = &mNode->mSize;
- break;
+ case Dali::Actor::Property::SIZE_MODE_FACTOR:
+ {
+ value = GetSizeModeFactor();
+ break;
+ }
- case Dali::Actor::Property::SIZE_DEPTH:
- property = &mNode->mSize;
- 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::POSITION:
- property = &mNode->mPosition;
- 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::POSITION_X:
- property = &mNode->mPosition;
- 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::POSITION_Y:
- property = &mNode->mPosition;
- 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::POSITION_Z:
- property = &mNode->mPosition;
- 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::WORLD_POSITION:
- property = &mNode->mWorldPosition;
- 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::WORLD_POSITION_X:
- property = &mNode->mWorldPosition;
- break;
+ case Dali::Actor::Property::MINIMUM_SIZE:
+ {
+ value = Vector2( GetMinimumSize( Dimension::WIDTH ), GetMinimumSize( Dimension::HEIGHT ) );
+ break;
+ }
- case Dali::Actor::Property::WORLD_POSITION_Y:
- property = &mNode->mWorldPosition;
- break;
+ case Dali::Actor::Property::MAXIMUM_SIZE:
+ {
+ value = Vector2( GetMaximumSize( Dimension::WIDTH ), GetMaximumSize( Dimension::HEIGHT ) );
+ break;
+ }
- case Dali::Actor::Property::WORLD_POSITION_Z:
- property = &mNode->mWorldPosition;
- break;
+ case Dali::Actor::Property::CLIPPING_MODE:
+ {
+ value = mClippingMode;
+ break;
+ }
- case Dali::Actor::Property::ORIENTATION:
- property = &mNode->mOrientation;
- break;
+ case Dali::DevelActor::Property::SIBLING_ORDER:
+ {
+ value = static_cast<int>( GetSiblingOrder() );
+ break;
+ }
- case Dali::Actor::Property::WORLD_ORIENTATION:
- property = &mNode->mWorldOrientation;
- break;
+ case Dali::DevelActor::Property::SCREEN_POSITION:
+ {
+ value = GetCurrentScreenPosition();
+ break;
+ }
- case Dali::Actor::Property::SCALE:
- property = &mNode->mScale;
- break;
+ case Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT:
+ {
+ value = mPositionUsesAnchorPoint;
+ break;
+ }
- case Dali::Actor::Property::SCALE_X:
- property = &mNode->mScale;
- break;
+ case Dali::Actor::Property::LAYOUT_DIRECTION:
+ {
+ value = mLayoutDirection;
+ break;
+ }
- case Dali::Actor::Property::SCALE_Y:
- property = &mNode->mScale;
- break;
+ case Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION:
+ {
+ value = IsLayoutDirectionInherited();
+ break;
+ }
- case Dali::Actor::Property::SCALE_Z:
- property = &mNode->mScale;
- break;
+ default:
+ {
+ // Must be a scene-graph only property
+ valueSet = false;
+ break;
+ }
+ }
- case Dali::Actor::Property::WORLD_SCALE:
- property = &mNode->mWorldScale;
- break;
+ return valueSet;
+}
- case Dali::Actor::Property::VISIBLE:
- property = &mNode->mVisible;
- break;
+bool Actor::GetCurrentPropertyValue( Property::Index index, Property::Value& value ) const
+{
+ bool valueSet = true;
- case Dali::Actor::Property::COLOR:
- property = &mNode->mColor;
- break;
+ switch( index )
+ {
+ case Dali::Actor::Property::SIZE:
+ {
+ value = GetCurrentSize();
+ break;
+ }
- case Dali::Actor::Property::COLOR_RED:
- property = &mNode->mColor;
- break;
+ case Dali::Actor::Property::SIZE_WIDTH:
+ {
+ value = GetCurrentSize().width;
+ break;
+ }
- case Dali::Actor::Property::COLOR_GREEN:
- property = &mNode->mColor;
- break;
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ {
+ value = GetCurrentSize().height;
+ break;
+ }
- case Dali::Actor::Property::COLOR_BLUE:
- property = &mNode->mColor;
- break;
+ case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ value = GetCurrentSize().depth;
+ break;
+ }
- case Dali::Actor::Property::COLOR_ALPHA:
- property = &mNode->mColor;
- break;
+ case Dali::Actor::Property::POSITION:
+ {
+ value = GetCurrentPosition();
+ break;
+ }
- case Dali::Actor::Property::WORLD_COLOR:
- property = &mNode->mWorldColor;
- break;
+ case Dali::Actor::Property::POSITION_X:
+ {
+ value = GetCurrentPosition().x;
+ break;
+ }
- case Dali::Actor::Property::WORLD_MATRIX:
- property = &mNode->mWorldMatrix;
- break;
+ case Dali::Actor::Property::POSITION_Y:
+ {
+ value = GetCurrentPosition().y;
+ break;
+ }
- default:
- break;
+ case Dali::Actor::Property::POSITION_Z:
+ {
+ value = GetCurrentPosition().z;
+ break;
}
- }
- return property;
-}
+ case Dali::Actor::Property::WORLD_POSITION:
+ {
+ value = GetCurrentWorldPosition();
+ break;
+ }
-int Actor::GetPropertyComponentIndex( Property::Index index ) const
-{
- int componentIndex( Property::INVALID_COMPONENT_INDEX );
+ case Dali::Actor::Property::WORLD_POSITION_X:
+ {
+ value = GetCurrentWorldPosition().x;
+ break;
+ }
- 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 )
+ case Dali::Actor::Property::WORLD_POSITION_Y:
{
- componentIndex = animatableProperty->componentIndex;
+ value = GetCurrentWorldPosition().y;
+ break;
}
- }
- else
- {
- switch( index )
+
+ case Dali::Actor::Property::WORLD_POSITION_Z:
{
- 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;
- }
+ value = GetCurrentWorldPosition().z;
+ 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::ORIENTATION:
+ {
+ value = GetCurrentOrientation();
+ 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::WORLD_ORIENTATION:
+ {
+ value = GetCurrentWorldOrientation();
+ break;
+ }
- case Dali::Actor::Property::COLOR_ALPHA:
- {
- componentIndex = 3;
- break;
- }
+ case Dali::Actor::Property::SCALE:
+ {
+ value = GetCurrentScale();
+ break;
+ }
- default:
- {
- // Do nothing
- break;
- }
+ case Dali::Actor::Property::SCALE_X:
+ {
+ value = GetCurrentScale().x;
+ break;
}
- }
- return componentIndex;
-}
+ case Dali::Actor::Property::SCALE_Y:
+ {
+ value = GetCurrentScale().y;
+ break;
+ }
-void Actor::SetParent( Actor* parent, int index )
-{
- if( parent )
- {
- DALI_ASSERT_ALWAYS( !mParent && "Actor cannot have 2 parents" );
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ value = GetCurrentScale().z;
+ break;
+ }
- mParent = parent;
+ case Dali::Actor::Property::WORLD_SCALE:
+ {
+ value = GetCurrentWorldScale();
+ break;
+ }
- if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
- parent->OnStage() )
+ case Dali::Actor::Property::COLOR:
{
- // Instruct each actor to create a corresponding node in the scene graph
- ConnectToStage( index );
+ value = GetCurrentColor();
+ break;
}
- }
- else // parent being set to NULL
- {
- DALI_ASSERT_ALWAYS( mParent != NULL && "Actor should have a parent" );
- mParent = NULL;
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ value = GetCurrentColor().r;
+ break;
+ }
- if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
- OnStage() )
+ case Dali::Actor::Property::COLOR_GREEN:
{
- DALI_ASSERT_ALWAYS( mNode != NULL );
+ value = GetCurrentColor().g;
+ break;
+ }
- if( NULL != mNode )
- {
- // Disconnect the Node & its children from the scene-graph.
- DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *mNode );
- }
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ value = GetCurrentColor().b;
+ break;
+ }
- // Instruct each actor to discard pointers to the scene-graph
- DisconnectFromStage();
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::DevelActor::Property::OPACITY:
+ {
+ value = GetCurrentColor().a;
+ break;
}
- }
-}
-SceneGraph::Node* Actor::CreateNode() const
-{
- return Node::New();
-}
+ case Dali::Actor::Property::WORLD_COLOR:
+ {
+ value = GetCurrentWorldColor();
+ 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::WORLD_MATRIX:
+ {
+ value = GetCurrentWorldMatrix();
+ break;
+ }
- if( actor )
- {
- if( 0 == strcmp( actionName.c_str(), ACTION_SHOW ) ) // dont want to convert char* to string
+ case Dali::Actor::Property::VISIBLE:
{
- actor->SetVisible( true );
- done = true;
+ value = IsVisible();
+ break;
}
- else if( 0 == strcmp( actionName.c_str(), ACTION_HIDE ) )
+
+ default:
{
- actor->SetVisible( false );
- done = true;
+ // 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 )
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::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::Type dimension )
{
+ EnsureRelayoutData();
+
for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
{
if( dimension & ( 1 << i ) )
}
}
-bool Actor::IsLayoutNegotiated( Dimension::Type 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 )
+{
+ float height = 0.0f;
+
+ const Vector3 naturalSize = GetNaturalSize();
+ if( naturalSize.width > 0.0f )
+ {
+ height = naturalSize.height * width / naturalSize.width;
+ }
+ else // we treat 0 as 1:1 aspect ratio
+ {
+ height = width;
+ }
+
+ return height;
+}
+
+float Actor::GetWidthForHeightBase( float height )
{
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ float width = 0.0f;
+
+ const Vector3 naturalSize = GetNaturalSize();
+ if( naturalSize.height > 0.0f )
{
- if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionNegotiated[ i ] )
- {
- return true;
- }
+ width = naturalSize.width * height / naturalSize.height;
+ }
+ else // we treat 0 as 1:1 aspect ratio
+ {
+ width = height;
}
- return false;
-}
-
-float Actor::CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
-{
- // Could be overridden in derived classes.
- return CalculateChildSizeBase( child, dimension );
+ return width;
}
float Actor::CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type 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::Type dimension ) const
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.GetTargetPosition(), dimension );
- float dimensionSize = childImpl.GetRelayoutSize( dimension );
+ float childPosition = GetDimensionValue( child->GetTargetPosition(), dimension );
+ float dimensionSize = child->GetRelayoutSize( dimension );
maxDimensionPoint = std::max( maxDimensionPoint, childPosition + dimensionSize );
}
}
float Actor::GetSize( Dimension::Type dimension ) const
{
- return GetDimensionValue( GetTargetSize(), dimension );
+ return GetDimensionValue( mTargetSize, dimension );
}
float Actor::GetNaturalSize( Dimension::Type dimension ) const
{
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 );
}
}
}
}
}
-Vector2 Actor::ApplySizeSetPolicy( const Vector2 size )
+Vector2 Actor::ApplySizeSetPolicy( const Vector2& size )
{
switch( mRelayoutData->sizeSetPolicy )
{
return size;
}
}
+ break;
}
default:
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::Type 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;
+ }
+ }
+ }
+}
+
+bool Actor::GetUseAssignedSize( 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 )
+ {
+ 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 );
}
}
Vector2 Actor::GetPreferredSize() const
{
- EnsureRelayoutData();
+ if ( mRelayoutData )
+ {
+ return Vector2( mRelayoutData->preferredSize );
+ }
- return mRelayoutData->preferredSize;
+ return GetDefaultPreferredSize();
}
void Actor::SetMinimumSize( float size, Dimension::Type dimension )
float Actor::GetMinimumSize( Dimension::Type dimension ) const
{
- EnsureRelayoutData();
-
- for( unsigned int i = 0; i < Dimension::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 ];
+ }
}
}
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 ];
+ }
+ }
+ }
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ return FLT_MAX; // Default
+}
+
+Object* Actor::GetParentObject() const
+{
+ return mParent;
+}
+
+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