namespace
{
+// Enumeration properties to test:
+const Scripting::StringEnum< int > SIZE_MODE_VALUES[] =
+{
+ { "USE_OWN_SIZE", USE_OWN_SIZE },
+ { "SIZE_EQUAL_TO_PARENT", SIZE_EQUAL_TO_PARENT },
+ { "SIZE_RELATIVE_TO_PARENT", SIZE_RELATIVE_TO_PARENT },
+ { "SIZE_FIXED_OFFSET_FROM_PARENT", SIZE_FIXED_OFFSET_FROM_PARENT },
+};
+const unsigned int SIZE_MODE_VALUES_COUNT = sizeof( SIZE_MODE_VALUES ) / sizeof( SIZE_MODE_VALUES[0] );
bool gTouchCallBackCalled=false;
bool gTouchCallBack2Called=false;
END_TEST;
}
+int UtcDaliActorSizeMode(void)
+{
+ tet_infoline("Testing Actor::SetSizeMode");
+ TestApplication application;
+
+ // Create a parent and a child.
+ Actor parent = Actor::New();
+ parent.SetParentOrigin( ParentOrigin::CENTER );
+ parent.SetAnchorPoint( AnchorPoint::CENTER );
+ Vector3 parentPosition( 0.0f, 0.0f, 0.0f );
+ parent.SetPosition( parentPosition );
+ parent.SetSize( 10.0f, 20.0f, 40.0f );
+ parent.SetSizeMode( USE_OWN_SIZE );
+ Stage::GetCurrent().Add( parent );
+
+ Actor child = Actor::New();
+ child.SetParentOrigin( ParentOrigin::CENTER );
+ child.SetAnchorPoint( AnchorPoint::CENTER );
+ Vector3 childPosition( 0.0f, 0.0f, 0.0f );
+ child.SetPosition( childPosition );
+ child.SetSize( 1.0f, 2.0f, 4.0f );
+ child.SetSizeMode( USE_OWN_SIZE );
+ parent.Add( child );
+
+ // Flush the queue and render once.
+ application.SendNotification();
+ application.Render();
+
+ // Test USE_OWN_SIZE uses the user-set size value.
+ DALI_TEST_EQUALS( child.GetCurrentSize(), Vector3( 1.0f, 2.0f, 4.0f ), TEST_LOCATION );
+ // Render and check again to ensure double-buffering does not cause old value to reappear.
+ application.Render();
+ DALI_TEST_EQUALS( child.GetCurrentSize(), Vector3( 1.0f, 2.0f, 4.0f ), TEST_LOCATION );
+
+ // Test SIZE_EQUAL_TO_PARENT overrides size with the parents size.
+ child.SetSizeMode( SIZE_EQUAL_TO_PARENT );
+
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( child.GetCurrentSize(), Vector3( 10.0f, 20.0f, 40.0f ), TEST_LOCATION );
+ // Render and check again to ensure double-buffering does not cause old value to reappear.
+ application.Render();
+ DALI_TEST_EQUALS( child.GetCurrentSize(), Vector3( 10.0f, 20.0f, 40.0f ), TEST_LOCATION );
+
+ // Test SIZE_RELATIVE_TO_PARENT overrides size with parents size * SizeModeFactor.
+ child.SetSizeMode( SIZE_RELATIVE_TO_PARENT );
+
+ application.SendNotification();
+ application.Render();
+ // First check without setting a relative factor, to confirm that the default factor (of 1.0f) is used.
+ DALI_TEST_EQUALS( child.GetCurrentSize(), Vector3( 10.0f, 20.0f, 40.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ // Render and check again to ensure double-buffering does not cause old value to reappear.
+ application.Render();
+ DALI_TEST_EQUALS( child.GetCurrentSize(), Vector3( 10.0f, 20.0f, 40.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+
+ // Set an arbitary relative factor to check against.
+ child.SetSizeModeFactor( Vector3( 2.0f, 3.0f, 4.0f ) );
+
+ application.SendNotification();
+ application.Render();
+ // Check with a valid relative factor.
+ DALI_TEST_EQUALS( child.GetCurrentSize(), Vector3( 20.0f, 60.0f, 160.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ // Render and check again to ensure double-buffering does not cause old value to reappear.
+ application.Render();
+ DALI_TEST_EQUALS( child.GetCurrentSize(), Vector3( 20.0f, 60.0f, 160.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+
+ // Test SIZE_FIXED_OFFSET_FROM_PARENT overrides size with parents size + SizeModeFactor.
+ child.SetSizeMode( SIZE_FIXED_OFFSET_FROM_PARENT );
+
+ application.SendNotification();
+ application.Render();
+ // Check with a valid relative factor.
+ DALI_TEST_EQUALS( child.GetCurrentSize(), Vector3( 12.0f, 23.0f, 44.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ // Render and check again to ensure double-buffering does not cause old value to reappear.
+ application.Render();
+ DALI_TEST_EQUALS( child.GetCurrentSize(), Vector3( 12.0f, 23.0f, 44.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+
+ application.SendNotification();
+
+ // Test the calculation order in update by having a parent with a size-relative
+ // factor and a rotation rotate a child anchored to one of the parents corners.
+ // .---. c
+ // .-----. | .-----. The new child is parented from the top-left of its parent.
+ // | '-|-' -----> | | We rotate the parent to confirm that the relative size calculation is
+ // | p | Rotate | .-|-. done before rotation. If it wasn't, the childs resultant
+ // '-----' parent '-----' | world-position would be incorrect.
+ // 90° '---'
+ //
+ // Create a new parent and child, and a root parent which the parent can grab relative size from.
+ Actor rootParent = Actor::New();
+ rootParent.SetParentOrigin( ParentOrigin::CENTER );
+ rootParent.SetAnchorPoint( AnchorPoint::CENTER );
+ rootParent.SetPosition( Vector3( 0.0f, 0.0f, 0.0f ) );
+ rootParent.SetSize( 10.0f, 10.0f, 10.0f );
+ rootParent.SetSizeMode( USE_OWN_SIZE );
+ Stage::GetCurrent().Add( rootParent );
+
+ Actor newParent = Actor::New();
+ newParent.SetParentOrigin( ParentOrigin::CENTER );
+ newParent.SetAnchorPoint( AnchorPoint::CENTER );
+ newParent.SetPosition( Vector3( 0.0f, 0.0f, 0.0f ) );
+ newParent.SetSize( 10.0f, 10.0f, 10.0f );
+ newParent.SetSizeMode( SIZE_RELATIVE_TO_PARENT );
+ newParent.SetSizeModeFactor( Vector3( 0.5f, 0.5f, 0.5f ) );
+ rootParent.Add( newParent );
+
+ Actor newChild = Actor::New();
+ newChild.SetParentOrigin( ParentOrigin::TOP_RIGHT );
+ newChild.SetAnchorPoint( AnchorPoint::CENTER );
+ newChild.SetPosition( Vector3( 0.0f, 0.0f, 0.0f ) );
+ newChild.SetSize( 1.0f, 1.0f, 1.0f );
+ newChild.SetSizeMode( USE_OWN_SIZE );
+ newParent.Add( newChild );
+
+ // Set up the rotation by 90 degrees on Z.
+ newParent.RotateBy( Radian( M_PI * 0.5f ), Vector3::ZAXIS );
+
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( newParent.GetCurrentSize(), Vector3( 5.0f, 5.0f, 5.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ DALI_TEST_EQUALS( newParent.GetCurrentWorldPosition(), Vector3( 0.0f, 0.0f, 0.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ DALI_TEST_EQUALS( newChild.GetCurrentWorldPosition(), Vector3( 2.5f, 2.5f, 0.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+
+ // Test changing the parents size to check the child's size is updated.
+ Actor newParent2 = Actor::New();
+ newParent2.SetParentOrigin( ParentOrigin::CENTER );
+ newParent2.SetAnchorPoint( AnchorPoint::CENTER );
+ newParent2.SetPosition( Vector3( 0.0f, 0.0f, 0.0f ) );
+ newParent2.SetSize( 10.0f, 10.0f, 10.0f );
+ newParent2.SetSizeMode( USE_OWN_SIZE );
+ rootParent.Add( newParent2 );
+
+ Actor newChild2 = Actor::New();
+ newChild2.SetParentOrigin( ParentOrigin::TOP_RIGHT );
+ newChild2.SetAnchorPoint( AnchorPoint::CENTER );
+ newChild2.SetPosition( Vector3( 0.0f, 0.0f, 0.0f ) );
+ newChild2.SetSize( Vector3::ONE );
+ newChild2.SetSizeMode( SIZE_RELATIVE_TO_PARENT );
+ newChild2.SetSizeModeFactor( Vector3( 0.5f, 0.5f, 0.5f ) );
+ newParent2.Add( newChild2 );
+
+ // Check the child has no size yet.
+ DALI_TEST_EQUALS( newChild2.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
+
+ // Check the child now has a relative size to the parent.
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( newChild2.GetCurrentSize(), Vector3( 5.0f, 5.0f, 5.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+
+ // Change the parent's size and check the child's size changes also.
+ newParent2.SetSize( 100.0f, 100.0f, 100.0f );
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( newChild2.GetCurrentSize(), Vector3( 50.0f, 50.0f, 50.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ // Confirm the child's size is still correct on the next frame.
+ application.Render();
+ DALI_TEST_EQUALS( newChild2.GetCurrentSize(), Vector3( 50.0f, 50.0f, 50.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+
+ // Text that reparenting a child causes its size to update relative to its new parent.
+ Actor newParent3 = Actor::New();
+ newParent3.SetParentOrigin( ParentOrigin::CENTER );
+ newParent3.SetAnchorPoint( AnchorPoint::CENTER );
+ newParent3.SetPosition( Vector3( 0.0f, 0.0f, 0.0f ) );
+ newParent3.SetSize( 400.0f, 400.0f, 400.0f );
+ newParent3.SetSizeMode( USE_OWN_SIZE );
+ rootParent.Add( newParent3 );
+
+ // Reparent the child but don't update yet. Check it still has its old size.
+ newParent3.Add( newChild2 );
+ DALI_TEST_EQUALS( newChild2.GetCurrentSize(), Vector3( 50.0f, 50.0f, 50.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+
+ // Check the child's size has updated based on the new parent.
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( newChild2.GetCurrentSize(), Vector3( 200.0f, 200.0f, 200.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ // Confirm the child's size is still correct on the next frame.
+ application.Render();
+ DALI_TEST_EQUALS( newChild2.GetCurrentSize(), Vector3( 200.0f, 200.0f, 200.0f ), Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+
+ // Properties:
+ // Test setting and getting the SizeMode property (by string).
+ Actor propertyActor = Actor::New();
+ propertyActor.SetParentOrigin( ParentOrigin::CENTER );
+ propertyActor.SetAnchorPoint( AnchorPoint::CENTER );
+ propertyActor.SetPosition( Vector3::ZERO );
+ propertyActor.SetSize( Vector3::ONE );
+ propertyActor.SetSizeMode( USE_OWN_SIZE );
+
+ // Loop through each SizeMode enumeration.
+ for( unsigned int propertyIndex = 0; propertyIndex < SIZE_MODE_VALUES_COUNT; ++propertyIndex )
+ {
+ Property::Value inValue = SIZE_MODE_VALUES[ propertyIndex ].string;
+ propertyActor.SetProperty( Actor::SIZE_MODE, inValue );
+ std::string outString = propertyActor.GetProperty( Actor::SIZE_MODE ).Get< std::string >();
+ DALI_TEST_EQUALS( inValue.Get< std::string >(), outString, TEST_LOCATION );
+ }
+
+ // Test setting and getting the SizeModeFactor property.
+ Vector3 testPropertySizeModeFactor( 1.0f, 2.0f, 3.0f );
+ Property::Value inValueFactor = testPropertySizeModeFactor;
+ propertyActor.SetProperty( Actor::SIZE_MODE_FACTOR, inValueFactor );
+ Vector3 outValueFactor = propertyActor.GetProperty( Actor::SIZE_MODE_FACTOR ).Get< Vector3 >();
+ DALI_TEST_EQUALS( testPropertySizeModeFactor, outValueFactor, TEST_LOCATION );
+
+ END_TEST;
+}
+
// SetRotation(float angleRadians, Vector3 axis)
int UtcDaliActorSetRotation01(void)
{
{ "color-mode", Actor::COLOR_MODE, Property::STRING },
{ "position-inheritance", Actor::POSITION_INHERITANCE, Property::STRING },
{ "draw-mode", Actor::DRAW_MODE, Property::STRING },
+ { "size-mode", Actor::SIZE_MODE, Property::STRING },
+ { "size-mode-factor", Actor::SIZE_MODE_FACTOR, Property::VECTOR3 },
};
const unsigned int PROPERTY_TABLE_COUNT = sizeof( PROPERTY_TABLE ) / sizeof( PROPERTY_TABLE[0] );
} // unnamed namespace
DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::COLOR_MODE ) );
DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::POSITION_INHERITANCE ) );
DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::DRAW_MODE ) );
+ DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::SIZE_MODE ) );
+ DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::SIZE_MODE_FACTOR ) );
END_TEST;
}
valueMap.SetValue("key", 5.f);
valueMap.SetValue("2key", "a string");
- DALI_TEST_EQUALS( true, valueMap.HasKey("key"), TEST_LOCATION);
+ DALI_TEST_EQUALS( true, valueMap.HasKey("key"), TEST_LOCATION);
DALI_TEST_EQUALS( "key", valueMap.GetKey(0), TEST_LOCATION);
DALI_TEST_EQUALS( true, valueMap.HasKey("2key"), TEST_LOCATION);
valueMap.SetItem(0, Property::Value("a string"));
valueMap.SetItem(1, Property::Value(5.f));
- DALI_TEST_EQUALS( 5.f, valueMap.GetValue("2key").Get<float>(), TEST_LOCATION);
- DALI_TEST_EQUALS( "a string", valueMap.GetValue("key").Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_EQUALS( 5.f, valueMap.GetValue("2key").Get<float>(), TEST_LOCATION);
+ DALI_TEST_EQUALS( "a string", valueMap.GetValue("key").Get<std::string>(), TEST_LOCATION);
// ordered map
valueMap = Property::Value(Property::MAP);
const unsigned int DRAW_MODE_VALUES_COUNT = sizeof( DRAW_MODE_VALUES ) / sizeof( DRAW_MODE_VALUES[0] );
-
//////////////////////////////////////////////////////////////////////////////
// Helpers for string to enum comparisons for Image and ImageAttributes
//////////////////////////////////////////////////////////////////////////////
actor.SetLeaveRequired( true );
actor.SetInheritRotation( false );
actor.SetInheritScale( false );
+ actor.SetSizeMode( USE_OWN_SIZE );
+ actor.SetSizeModeFactor( Vector3::ONE );
Stage::GetCurrent().Add( actor );
application.SendNotification();
DALI_TEST_EQUALS( value.GetValue( "inherit-rotation" ).Get< bool >(), false, TEST_LOCATION );
DALI_TEST_CHECK( value.HasKey( "inherit-scale" ) );
DALI_TEST_EQUALS( value.GetValue( "inherit-scale" ).Get< bool >(), false, TEST_LOCATION );
+ DALI_TEST_CHECK( value.HasKey( "size-mode-factor" ) );
+ DALI_TEST_EQUALS( value.GetValue( "size-mode-factor" ).Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
Stage::GetCurrent().Remove( actor );
}
const Property::Index Actor::COLOR_MODE = 40;
const Property::Index Actor::POSITION_INHERITANCE = 41;
const Property::Index Actor::DRAW_MODE = 42;
+const Property::Index Actor::SIZE_MODE = 43;
+const Property::Index Actor::SIZE_MODE_FACTOR = 44;
namespace // unnamed namespace
{
{ "color-mode", Property::STRING, true, false, false }, // COLOR_MODE
{ "position-inheritance", Property::STRING, true, false, false }, // POSITION_INHERITANCE
{ "draw-mode", Property::STRING, true, false, false }, // DRAW_MODE
+ { "size-mode", Property::STRING, true, false, false }, // SIZE_MODE
+ { "size-mode-factor", Property::VECTOR3, true, false, false }, // SIZE_MODE_FACTOR
};
const int DEFAULT_PROPERTY_COUNT = sizeof( DEFAULT_PROPERTY_DETAILS ) / sizeof( Internal::PropertyDetails );
+// Enumeration to/from text conversion tables:
+const Scripting::StringEnum< SizeMode > SIZE_MODE_TABLE[] =
+{
+ { "USE_OWN_SIZE", USE_OWN_SIZE },
+ { "SIZE_EQUAL_TO_PARENT", SIZE_EQUAL_TO_PARENT },
+ { "SIZE_RELATIVE_TO_PARENT", SIZE_RELATIVE_TO_PARENT },
+ { "SIZE_FIXED_OFFSET_FROM_PARENT", SIZE_FIXED_OFFSET_FROM_PARENT },
+};
+const unsigned int SIZE_MODE_TABLE_COUNT = sizeof( SIZE_MODE_TABLE ) / sizeof( SIZE_MODE_TABLE[0] );
+
} // unnamed namespace
namespace Internal
return mInheritRotation;
}
+void Actor::SetSizeMode(SizeMode mode)
+{
+ // non animateable so keep local copy
+ mSizeMode = mode;
+ if( NULL != mNode )
+ {
+ // mNode is being used in a separate thread; queue a message to set the value
+ SetSizeModeMessage( mStage->GetUpdateInterface(), *mNode, mode );
+ }
+}
+
+void Actor::SetSizeModeFactor(const Vector3& factor)
+{
+ // non animateable so keep local copy
+ mSizeModeFactor = factor;
+ if( NULL != mNode )
+ {
+ // mNode is being used in a separate thread; queue a message to set the value
+ SetSizeModeFactorMessage( mStage->GetUpdateInterface(), *mNode, factor );
+ }
+}
+
+SizeMode Actor::GetSizeMode() const
+{
+ return mSizeMode;
+}
+
+const Vector3& Actor::GetSizeModeFactor() const
+{
+ return mSizeModeFactor;
+}
+
void Actor::SetColorMode(ColorMode colorMode)
{
// non animateable so keep local copy
mGestureData( NULL ),
mAttachment(),
mSize( 0.0f, 0.0f, 0.0f ),
+ mSizeModeFactor( Vector3::ONE ),
mName(),
mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
mIsRoot( ROOT_LAYER == derivedType ),
mInheritScale( true ),
mDrawMode( DrawMode::NORMAL ),
mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ),
- mColorMode( Node::DEFAULT_COLOR_MODE )
+ mColorMode( Node::DEFAULT_COLOR_MODE ),
+ mSizeMode( Node::DEFAULT_SIZE_MODE )
{
}
break;
}
+ case Dali::Actor::SIZE_MODE:
+ {
+ SetSizeMode( Scripting::GetEnumeration< SizeMode >( property.Get<std::string>(), SIZE_MODE_TABLE, SIZE_MODE_TABLE_COUNT ) );
+ break;
+ }
+
+ case Dali::Actor::SIZE_MODE_FACTOR:
+ {
+ SetSizeModeFactor( property.Get<Vector3>() );
+ break;
+ }
+
case Dali::Actor::INHERIT_SCALE:
{
SetInheritScale( property.Get<bool>() );
break;
}
+ case Dali::Actor::SIZE_MODE:
+ {
+ value = Scripting::GetEnumerationName< SizeMode >( GetSizeMode(), SIZE_MODE_TABLE, SIZE_MODE_TABLE_COUNT );
+ break;
+ }
+
+ case Dali::Actor::SIZE_MODE_FACTOR:
+ {
+ value = GetSizeModeFactor();
+ break;
+ }
+
case Dali::Actor::INHERIT_SCALE:
{
value = IsScaleInherited();
bool IsRotationInherited() const;
/**
+ * @brief Defines how a child actors size is affected by its parents size.
+ * @param[in] mode The size relative to parent mode to use.
+ */
+ void SetSizeMode(SizeMode mode);
+
+ /**
+ * Query how the child actors size is affected by its parents size.
+ * @return The size relative to parent mode in use.
+ */
+ SizeMode GetSizeMode() const;
+
+ /**
+ * Sets the factor of the parents size used for the child actor.
+ * Note: Only used if SizeMode is SIZE_RELATIVE_TO_PARENT or SIZE_FIXED_OFFSET_FROM_PARENT.
+ * @param[in] factor The vector to multiply the parents size by to get the childs size.
+ */
+ void SetSizeModeFactor(const Vector3& factor);
+
+ /**
+ * Gets the factor of the parents size used for the child actor.
+ * Note: Only used if SizeMode is SIZE_RELATIVE_TO_PARENT or SIZE_FIXED_OFFSET_FROM_PARENT.
+ * @return The vector being used to multiply the parents size by to get the childs size.
+ */
+ const Vector3& GetSizeModeFactor() const;
+
+ /**
* @copydoc Dali::Actor::GetCurrentWorldRotation()
*/
const Quaternion& GetCurrentWorldRotation() const;
Actor* mParent; ///< Each actor (except the root) can have one parent
ActorContainer* mChildren; ///< Container of referenced actors
const SceneGraph::Node* mNode; ///< Not owned
- Vector3* mParentOrigin; // NULL means ParentOrigin::DEFAULT. ParentOrigin is non-animatable
- Vector3* mAnchorPoint; // NULL means AnchorPoint::DEFAULT. AnchorPoint is non-animatable
+ Vector3* mParentOrigin; ///< NULL means ParentOrigin::DEFAULT. ParentOrigin is non-animatable
+ Vector3* mAnchorPoint; ///< NULL means AnchorPoint::DEFAULT. AnchorPoint is non-animatable
#ifdef DYNAMICS_SUPPORT
DynamicsData* mDynamicsData; ///< optional physics data
#endif
- ActorGestureData* mGestureData; /// Optional Gesture data. Only created when actor requires gestures
+ ActorGestureData* mGestureData; ///< Optional Gesture data. Only created when actor requires gestures
ActorAttachmentPtr mAttachment; ///< Optional referenced attachment
Dali::Actor::OffStageSignalType mOffStageSignal;
Vector3 mSize; ///< Event-side storage for size (not a pointer as most actors will have a size)
+ Vector3 mSizeModeFactor; ///< Factor of parent size used for certain SizeModes.
std::string mName; ///< Name of the actor
unsigned int mId; ///< A unique ID to identify the actor starting from 1, and 0 is reserved
DrawMode::Type mDrawMode : 2; ///< Cached: How the actor and its children should be drawn
PositionInheritanceMode mPositionInheritanceMode : 2; ///< Cached: Determines how position is inherited
ColorMode mColorMode : 2; ///< Cached: Determines whether mWorldColor is inherited
+ SizeMode mSizeMode : 2; ///< Cached: Determines how the actors parent affects the actors size.
private:
inline void UpdateNodeTransformValues( Node& node, int nodeDirtyFlags, BufferIndex updateBufferIndex )
{
// If the transform values need to be reinherited
- if ( nodeDirtyFlags & TransformFlag )
+ if( nodeDirtyFlags & TransformFlag )
{
+ // Handle size relative to parent modes.
+ // This must be delt with before rotation/translation as otherwise anything
+ // anchored to a corner of this child would appear at the wrong position.
+ // Note: Switch is in order of use-case commonality.
+ switch( node.GetSizeMode() )
+ {
+ case USE_OWN_SIZE:
+ {
+ // Completely ignore the parents size.
+ break;
+ }
+
+ case SIZE_EQUAL_TO_PARENT:
+ {
+ // Set the nodes size to that of the parent.
+ node.SetSize( updateBufferIndex, node.GetParent()->GetSize( updateBufferIndex ) );
+ break;
+ }
+
+ case SIZE_RELATIVE_TO_PARENT:
+ {
+ // Set the nodes size to the parents multiplied by a user defined value.
+ node.SetSize( updateBufferIndex, node.GetSizeModeFactor() * node.GetParent()->GetSize( updateBufferIndex ) );
+ break;
+ }
+
+ case SIZE_FIXED_OFFSET_FROM_PARENT:
+ {
+ // Set the nodes size to the parents plus a user defined value.
+ node.SetSize( updateBufferIndex, node.GetSizeModeFactor() + node.GetParent()->GetSize( updateBufferIndex ) );
+ break;
+ }
+ }
+
// With a non-central anchor-point, the world rotation and scale affects the world position.
// Therefore the world rotation & scale must be updated before the world position.
-
if( node.IsRotationInherited() )
{
node.InheritWorldRotation( updateBufferIndex );
node.CopyPreviousWorldRotation( updateBufferIndex );
node.CopyPreviousWorldScale( updateBufferIndex );
node.CopyPreviousWorldPosition( updateBufferIndex );
+ node.CopyPreviousSize( updateBufferIndex );
}
}
const PositionInheritanceMode Node::DEFAULT_POSITION_INHERITANCE_MODE( INHERIT_PARENT_POSITION );
const ColorMode Node::DEFAULT_COLOR_MODE( USE_OWN_MULTIPLY_PARENT_ALPHA );
+const SizeMode Node::DEFAULT_SIZE_MODE( USE_OWN_SIZE );
Node* Node::New()
{
mChildren(),
mGeometryScale( Vector3::ONE ),
mInitialVolume( Vector3::ONE ),
+ mSizeModeFactor( Vector3::ONE ),
mDirtyFlags(AllFlags),
mIsRoot( false ),
mInheritRotation( true ),
mIsActive( true ),
mDrawMode( DrawMode::NORMAL ),
mPositionInheritanceMode( DEFAULT_POSITION_INHERITANCE_MODE ),
- mColorMode( DEFAULT_COLOR_MODE )
+ mColorMode( DEFAULT_COLOR_MODE ),
+ mSizeMode( DEFAULT_SIZE_MODE )
{
}
// value types used by messages
template <> struct ParameterType< ColorMode > : public BasicType< ColorMode > {};
template <> struct ParameterType< PositionInheritanceMode > : public BasicType< PositionInheritanceMode > {};
+template <> struct ParameterType< SizeMode > : public BasicType< SizeMode > {};
namespace SceneGraph
{
// Defaults
static const PositionInheritanceMode DEFAULT_POSITION_INHERITANCE_MODE;
static const ColorMode DEFAULT_COLOR_MODE;
+ static const SizeMode DEFAULT_SIZE_MODE;
// Creation methods
}
/**
+ * @brief Defines how a child actor's size is affected by its parent's size.
+ * @param[in] mode The size relative to parent mode to use.
+ */
+ void SetSizeMode( SizeMode mode )
+ {
+ if ( mode != mSizeMode )
+ {
+ mSizeMode = mode;
+
+ SetDirtyFlag( TransformFlag );
+ }
+ }
+
+ /**
+ * Query how the child actor's size is affected by its parent's size.
+ * @return The size relative to parent mode in use.
+ */
+ SizeMode GetSizeMode() const
+ {
+ return mSizeMode;
+ }
+
+ /**
+ * Sets the factor of the parents size used for the child actor.
+ * Note: Only used for certain SizeModes.
+ * @param[in] factor The vector to multiply the parents size by to get the childs size.
+ */
+ void SetSizeModeFactor( const Vector3& factor )
+ {
+ mSizeModeFactor = factor;
+
+ SetDirtyFlag( TransformFlag );
+ }
+
+ /**
+ * Gets the factor of the parents size used for the child actor.
+ * Note: Only used for certain SizeModes.
+ * @return The vector being used to multiply the parents size by to get the childs size.
+ */
+ const Vector3& GetSizeModeFactor() const
+ {
+ return mSizeModeFactor;
+ }
+
+ /**
* Set the initial volume of the node. Used for calculating geometry scaling
* as the node size is changed when transmitGeometryScaling is set to true.
*
*
* @param[in] volume The initial volume of this nodes meshes & children
*/
- void SetInitialVolume( const Vector3& volume)
+ void SetInitialVolume( const Vector3& volume )
{
mInitialVolume = volume;
SetDirtyFlag(SizeFlag);
}
/**
+ * Copies the previously used size, if this changed in the previous frame.
+ * @param[in] updateBufferIndex The current update buffer index.
+ */
+ void CopyPreviousSize( BufferIndex updateBufferIndex )
+ {
+ SetSize( updateBufferIndex, GetSize( 1u - updateBufferIndex ) );
+ }
+
+ /**
* Retrieve the visibility of the node.
* @param[in] bufferIndex The buffer to read from.
* @return True if the node is visible.
}
/**
+ * Sets the size of the node.
+ * @param[in] bufferIndex The buffer to write to.
+ * @param[in] size The size to write.
+ */
+ void SetSize( BufferIndex bufferIndex, const Vector3& size )
+ {
+ mSize[bufferIndex] = size;
+ }
+
+ /**
* Retrieve the size of the node.
* @param[in] bufferIndex The buffer to read from.
* @return The size.
NodeContainer mChildren; ///< Container of children; not owned
Vector3 mGeometryScale; ///< Applied before calculating world transform.
- Vector3 mInitialVolume; ///< Initial volume... TODO - need a better name
+ Vector3 mInitialVolume; ///< Initial volume... TODO - need a better name.
+ Vector3 mSizeModeFactor; ///< Factor of parent size. Used for certain SizeModes.
// flags, compressed to bitfield
int mDirtyFlags:10; ///< A composite set of flags for each of the Node properties
DrawMode::Type mDrawMode:2; ///< How the Node and its children should be drawn
PositionInheritanceMode mPositionInheritanceMode:2;///< Determines how position is inherited, 2 bits is enough
ColorMode mColorMode:2; ///< Determines whether mWorldColor is inherited, 2 bits is enough
+ SizeMode mSizeMode:2; ///< Determines how the actors parent affects the actors size.
// Changes scope, should be at end of class
DALI_LOG_OBJECT_STRING_DECLARATION;
new (slot) LocalType( &node, &Node::SetInheritRotation, inherit );
}
+inline void SetSizeModeMessage( EventToUpdate& eventToUpdate, const Node& node, SizeMode mode )
+{
+ typedef MessageValue1< Node, SizeMode > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &node, &Node::SetSizeMode, mode );
+}
+
+inline void SetSizeModeFactorMessage( EventToUpdate& eventToUpdate, const Node& node, const Vector3& factor )
+{
+ typedef MessageValue1< Node, Vector3 > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &node, &Node::SetSizeModeFactor, factor );
+}
+
inline void SetInitialVolumeMessage( EventToUpdate& eventToUpdate, const Node& node, const Vector3& initialVolume )
{
typedef MessageValue1< Node, Vector3 > LocalType;
DONT_INHERIT_POSITION ///< Actor will not inherit position. Local position is treated as world position. This is useful if a constraint is used to override local position or if an actor is positioned globally. This option ignores parent origin, anchor point and local position.
};
+/**
+ * @brief Actor size relative to parent mode.
+ */
+enum SizeMode
+{
+ USE_OWN_SIZE, ///< The mode is bypassed. The size Vector3 will be used as normal.
+ SIZE_EQUAL_TO_PARENT, ///< The actor will have the exact same size as the parent.
+ SIZE_RELATIVE_TO_PARENT, ///< The actors size will be ( ParentSize * SizeRelativeToParentFactor ).
+ SIZE_FIXED_OFFSET_FROM_PARENT ///< The actors size will be ( ParentSize + SizeRelativeToParentFactor ).
+};
} // namespace Dali
return GetImplementation(*this).IsScaleInherited();
}
+void Actor::SetSizeMode(SizeMode mode)
+{
+ GetImplementation(*this).SetSizeMode(mode);
+}
+
+SizeMode Actor::GetSizeMode() const
+{
+ return GetImplementation(*this).GetSizeMode();
+}
+
+void Actor::SetSizeModeFactor(const Vector3& factor)
+{
+ GetImplementation(*this).SetSizeModeFactor(factor);
+}
+
+Vector3 Actor::GetSizeModeFactor() const
+{
+ return GetImplementation(*this).GetSizeModeFactor();
+}
+
Matrix Actor::GetCurrentWorldMatrix() const
{
return GetImplementation(*this).GetCurrentWorldMatrix();
static const Property::Index COLOR_MODE; ///< name "color-mode", type STRING
static const Property::Index POSITION_INHERITANCE; ///< name "position-inheritance", type STRING
static const Property::Index DRAW_MODE; ///< name "draw-mode", type STRING
+ static const Property::Index SIZE_MODE; ///< name "size-mode", type STRING
+ static const Property::Index SIZE_MODE_FACTOR; ///< name "size-mode-factor", type VECTOR3
/** @} */
/// @name Signals
bool IsScaleInherited() const;
/**
+ * @brief Defines how a child actor's size is affected by its parent's size.
+ *
+ * The default is to ignore the parent's size and use the size property of this actor.
+ *
+ * If USE_OWN_SIZE is used, this option is bypassed and the actor's size
+ * property is used.
+ *
+ * If SIZE_EQUAL_TO_PARENT is used, this actor's size will be equal to that
+ * of its parent. The actor's size property is ignored.
+ *
+ * If SIZE_RELATIVE_TO_PARENT is used, this actor's size will be based on
+ * its parent's size by multiplying the parent size by
+ * SizeModeFactor.
+ *
+ * If SIZE_FIXED_OFFSET_FROM_PARENT is used, this actor's size will be based on
+ * its parent's size plus SizeModeFactor.
+ *
+ * @pre The Actor has been initialized.
+ * @param[in] mode The size relative to parent mode to use.
+ */
+ void SetSizeMode(const SizeMode mode);
+
+ /**
+ * @brief Returns the actor's mode for modifying its size relative to its parent.
+ *
+ * @pre The Actor has been initialized.
+ * @return The mode used.
+ */
+ SizeMode GetSizeMode() const;
+
+ /**
+ * @brief Sets the relative to parent size factor of the actor.
+ *
+ * This factor is only used when SizeMode is set to either:
+ * SIZE_RELATIVE_TO_PARENT or SIZE_FIXED_OFFSET_FROM_PARENT.
+ * This actor's size is set to the actor's parent size multipled by or added to this factor,
+ * depending on SideMode (See SetSizeMode).
+ *
+ * @pre The Actor has been initialized.
+ * @param [in] factor A Vector3 representing the relative factor to be applied to each axis.
+ */
+ void SetSizeModeFactor(const Vector3& factor);
+
+ /**
+ * @brief Retrieve the relative to parent size factor of the actor.
+ *
+ * @pre The Actor has been initialized.
+ * @return The Actor's current relative size factor.
+ */
+ Vector3 GetSizeModeFactor() const;
+
+ /**
* @brief Retrieves the world-matrix of the actor.
*
* @note The actor will not have a world-matrix, unless it has previously been added to the stage.
projects / platform / core / uifw / dali-core.git / commitdiff