/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
static bool gTestConstraintCalled;
+LayoutDirection::Type gLayoutDirectionType;
+
struct TestConstraint
{
void operator()( Vector4& color, const PropertyInputContainer& /* inputs */ )
VisibilityChangedFunctorData& data;
};
+
+struct VisibilityChangedVoidFunctor
+{
+ VisibilityChangedVoidFunctor(bool& signalCalled)
+ : mSignalCalled( signalCalled )
+ { }
+
+ void operator()()
+ {
+ mSignalCalled = true;
+ }
+
+ bool& mSignalCalled;
+};
+
+struct ChildOrderChangedFunctor
+{
+ ChildOrderChangedFunctor(bool& signalCalled, Actor& actor)
+ : mSignalCalled( signalCalled ),
+ mActor( actor )
+ { }
+
+ void operator()( Actor actor )
+ {
+ mSignalCalled = true;
+ mActor = actor;
+ }
+
+ bool& mSignalCalled;
+ Actor& mActor;
+};
+
+struct CulledPropertyNotificationFunctor
+{
+ CulledPropertyNotificationFunctor( bool& signalCalled, PropertyNotification& propertyNotification )
+ : mSignalCalled( signalCalled ),
+ mPropertyNotification( propertyNotification )
+ { }
+
+ void operator()( PropertyNotification& source )
+ {
+ mSignalCalled = true;
+ mPropertyNotification = source;
+ }
+
+ bool& mSignalCalled;
+ PropertyNotification& mPropertyNotification;
+};
+
} // anonymous namespace
END_TEST;
}
+int UtcDaliActorCustomProperty(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ Stage::GetCurrent().Add( actor );
+
+ float startValue(1.0f);
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
+
+ application.SendNotification();
+ application.Render(0);
+ DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
+
+ actor.SetProperty( index, 5.0f );
+
+ application.SendNotification();
+ application.Render(0);
+ DALI_TEST_CHECK( actor.GetProperty<float>(index) == 5.0f );
+ END_TEST;
+}
+
+int UtcDaliActorCustomPropertyIntToFloat(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ Stage::GetCurrent().Add( actor );
+
+ float startValue(5.0f);
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
+
+ application.SendNotification();
+ application.Render(0);
+ DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
+
+ actor.SetProperty( index, int(1) );
+
+ application.SendNotification();
+ application.Render(0);
+ DALI_TEST_CHECK( actor.GetProperty<float>(index) == 1.0f );
+ END_TEST;
+}
+
+int UtcDaliActorCustomPropertyFloatToInt(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ Stage::GetCurrent().Add( actor );
+
+ int startValue(5);
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ DALI_TEST_CHECK( actor.GetProperty<int>(index) == startValue );
+
+ application.SendNotification();
+ application.Render(0);
+ DALI_TEST_CHECK( actor.GetProperty<int>(index) == startValue );
+
+ actor.SetProperty( index, float(1.5) );
+
+ application.SendNotification();
+ application.Render(0);
+ DALI_TEST_CHECK( actor.GetProperty<int>(index) == 1 );
+ END_TEST;
+}
+
int UtcDaliActorSetParentOrigin(void)
{
TestApplication application;
END_TEST;
}
+int UtcDaliActorCalculateScreenExtents(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ actor.SetPosition(Vector3(2.0f, 2.0f, 16.0f));
+ actor.SetSize(Vector3{ 1.0f, 1.0f, 1.0f });
+
+ application.SendNotification();
+ application.Render();
+
+ auto expectedExtent = Rect<>{ -0.5f, -0.5f, 1.0f, 1.0f };
+ auto actualExtent = DevelActor::CalculateScreenExtents( actor );
+ DALI_TEST_EQUALS( expectedExtent.x, actualExtent.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
+ DALI_TEST_EQUALS( expectedExtent.y, actualExtent.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
+ DALI_TEST_EQUALS( expectedExtent.width, actualExtent.width, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
+ DALI_TEST_EQUALS( expectedExtent.height, actualExtent.height, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
+
+ Stage::GetCurrent().Remove( actor );
+ END_TEST;
+}
+
// SetPosition(float x, float y)
int UtcDaliActorSetPosition01(void)
{
END_TEST;
}
-int UtcDaliActorInheritPosition(void)
-{
- tet_infoline("Testing Actor::SetPositionInheritanceMode");
- TestApplication application;
-
- Actor parent = Actor::New();
- Vector3 parentPosition( 1.0f, 2.0f, 3.0f );
- parent.SetPosition( parentPosition );
- parent.SetParentOrigin( ParentOrigin::CENTER );
- parent.SetAnchorPoint( AnchorPoint::CENTER );
- Stage::GetCurrent().Add( parent );
-
- Actor child = Actor::New();
- child.SetParentOrigin( ParentOrigin::CENTER );
- child.SetAnchorPoint( AnchorPoint::CENTER );
- Vector3 childPosition( 10.0f, 11.0f, 12.0f );
- child.SetPosition( childPosition );
- parent.Add( child );
-
- // The actors should not have a world position yet
- DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
-
- // first test default, which is to inherit position
- DALI_TEST_EQUALS( child.GetPositionInheritanceMode(), Dali::INHERIT_PARENT_POSITION, TEST_LOCATION );
- application.SendNotification();
- application.Render(0); // should only really call Update as Render is not required to update scene
- DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentPosition(), childPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), parentPosition + childPosition, TEST_LOCATION );
-
-
- //Change child position
- Vector3 childOffset( -1.0f, 1.0f, 0.0f );
- child.SetPosition( childOffset );
-
- // Change inheritance mode to not inherit
- child.SetPositionInheritanceMode( Dali::DONT_INHERIT_POSITION );
- DALI_TEST_EQUALS( child.GetPositionInheritanceMode(), Dali::DONT_INHERIT_POSITION, TEST_LOCATION );
- application.SendNotification();
- application.Render(0); // should only really call Update as Render is not required to update scene
- DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentPosition(), childOffset, TEST_LOCATION );
- DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), childOffset, TEST_LOCATION );
- END_TEST;
-}
-
int UtcDaliActorSetInheritPosition(void)
{
tet_infoline("Testing Actor::SetInheritPosition");
END_TEST;
}
+int UtcDaliActorInheritOpacity(void)
+{
+ tet_infoline("Testing Actor::Inherit Opacity");
+ TestApplication application;
+
+ Actor parent = Actor::New();
+ Actor child = Actor::New();
+ parent.Add( child );
+ Stage::GetCurrent().Add( parent );
+
+ DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( child.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ parent.SetOpacity( 0.1f );
+
+ DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( child.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( parent.GetCurrentProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( parent.GetCurrentProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( child.GetProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( child.GetCurrentProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( child.GetCurrentProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.f, 0.0001f, TEST_LOCATION );
+
+ END_TEST;
+}
+
// SetOrientation(float angleRadians, Vector3 axis)
int UtcDaliActorSetOrientation01(void)
{
{ "inheritOrientation", Actor::Property::INHERIT_ORIENTATION, Property::BOOLEAN },
{ "inheritScale", Actor::Property::INHERIT_SCALE, Property::BOOLEAN },
{ "colorMode", Actor::Property::COLOR_MODE, Property::STRING },
- { "positionInheritance", Actor::Property::POSITION_INHERITANCE, Property::STRING },
{ "drawMode", Actor::Property::DRAW_MODE, Property::STRING },
{ "sizeModeFactor", Actor::Property::SIZE_MODE_FACTOR, Property::VECTOR3 },
{ "widthResizePolicy", Actor::Property::WIDTH_RESIZE_POLICY, Property::STRING },
{ "inheritPosition", Actor::Property::INHERIT_POSITION, Property::BOOLEAN },
{ "clippingMode", Actor::Property::CLIPPING_MODE, Property::STRING },
{ "opacity", DevelActor::Property::OPACITY, Property::FLOAT },
+ { "updateSizeHint", DevelActor::Property::UPDATE_SIZE_HINT, Property::VECTOR2 },
};
const unsigned int PROPERTY_TABLE_COUNT = sizeof( PROPERTY_TABLE ) / sizeof( PROPERTY_TABLE[0] );
} // unnamed namespace
END_TEST;
}
-int UtcDaliActorPositionInheritancePropertyAsString(void)
-{
- TestApplication application;
-
- Actor actor = Actor::New();
-
- actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "INHERIT_PARENT_POSITION" );
- DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), INHERIT_PARENT_POSITION, TEST_LOCATION );
-
- actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "USE_PARENT_POSITION" );
- DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), USE_PARENT_POSITION, TEST_LOCATION );
-
- actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "USE_PARENT_POSITION_PLUS_LOCAL_POSITION" );
- DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), USE_PARENT_POSITION_PLUS_LOCAL_POSITION, TEST_LOCATION );
-
- actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "DONT_INHERIT_POSITION" );
- DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
-
- // Invalid should not change anything
- actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "INVALID_ARG" );
- DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
-
- END_TEST;
-}
-
int UtcDaliActorDrawModePropertyAsString(void)
{
TestApplication application;
actor.SetProperty( Actor::Property::DRAW_MODE, "OVERLAY_2D" );
DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::OVERLAY_2D, TEST_LOCATION );
- actor.SetProperty( Actor::Property::DRAW_MODE, "STENCIL" );
- DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::STENCIL, TEST_LOCATION );
-
// Invalid should not change anything
actor.SetProperty( Actor::Property::DRAW_MODE, "INVALID_ARG" );
- DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::STENCIL, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::OVERLAY_2D, TEST_LOCATION );
END_TEST;
}
END_TEST;
}
-int UtcDaliActorPositionInheritancePropertyAsEnum(void)
-{
- TestApplication application;
-
- Actor actor = Actor::New();
-
- actor.SetProperty( Actor::Property::POSITION_INHERITANCE, INHERIT_PARENT_POSITION );
- DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), INHERIT_PARENT_POSITION, TEST_LOCATION );
-
- actor.SetProperty( Actor::Property::POSITION_INHERITANCE, USE_PARENT_POSITION );
- DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), USE_PARENT_POSITION, TEST_LOCATION );
-
- actor.SetProperty( Actor::Property::POSITION_INHERITANCE, USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
- DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), USE_PARENT_POSITION_PLUS_LOCAL_POSITION, TEST_LOCATION );
-
- actor.SetProperty( Actor::Property::POSITION_INHERITANCE, DONT_INHERIT_POSITION );
- DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
-
- END_TEST;
-}
-
int UtcDaliActorDrawModePropertyAsEnum(void)
{
TestApplication application;
actor.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::OVERLAY_2D, TEST_LOCATION );
- actor.SetProperty( Actor::Property::DRAW_MODE, DrawMode::STENCIL );
- DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::STENCIL, TEST_LOCATION );
-
END_TEST;
}
}
// Clipping test helper functions:
-Actor CreateActorWithContent()
+Actor CreateActorWithContent( uint32_t width, uint32_t height)
{
- BufferImage image = BufferImage::New( 16u, 16u );
+ BufferImage image = BufferImage::New( width, height );
Actor actor = CreateRenderableActor( image );
// Setup dimensions and position so actor is not skipped by culling.
actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
- actor.SetSize( 16.0f, 16.0f );
+ actor.SetSize( width, height );
actor.SetParentOrigin( ParentOrigin::CENTER );
actor.SetAnchorPoint( AnchorPoint::CENTER );
return actor;
}
+Actor CreateActorWithContent16x16()
+{
+ return CreateActorWithContent( 16, 16 );
+}
+
void GenerateTrace( TestApplication& application, TraceCallStack& enabledDisableTrace, TraceCallStack& stencilTrace )
{
enabledDisableTrace.Reset();
int UtcDaliActorPropertyClippingP(void)
{
// This test checks the clippingMode property.
- tet_infoline( "Testing Actor::Property::CLIPPING_MODE P" );
+ tet_infoline( "Testing Actor::Property::ClippingMode: P" );
TestApplication application;
Actor actor = Actor::New();
DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
}
- // Check setting the property.
+ // Check setting the property to the stencil mode.
actor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
// Check the new value was set.
DALI_TEST_EQUALS<int>( value, ClippingMode::CLIP_CHILDREN, TEST_LOCATION );
}
+ // Check setting the property to the scissor mode.
+ actor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+ // Check the new value was set.
+ getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
+ getValueResult = getValue.Get( value );
+ DALI_TEST_CHECK( getValueResult );
+
+ if( getValueResult )
+ {
+ DALI_TEST_EQUALS<int>( value, ClippingMode::CLIP_TO_BOUNDING_BOX, TEST_LOCATION );
+ }
END_TEST;
}
int UtcDaliActorPropertyClippingN(void)
{
// Negative test case for Clipping.
- tet_infoline( "Testing Actor::Property::CLIPPING_MODE N" );
+ tet_infoline( "Testing Actor::Property::ClippingMode: N" );
TestApplication application;
Actor actor = Actor::New();
int UtcDaliActorPropertyClippingActor(void)
{
// This test checks that an actor is correctly setup for clipping.
- tet_infoline( "Testing Actor::Property::CLIPPING_MODE actor" );
+ tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor" );
TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
size_t startIndex = 0u;
// Create a clipping actor.
- Actor actorDepth1Clip = CreateActorWithContent();
+ Actor actorDepth1Clip = CreateActorWithContent16x16();
actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
Stage::GetCurrent().Add( actorDepth1Clip );
int UtcDaliActorPropertyClippingActorEnableThenDisable(void)
{
// This test checks that an actor is correctly setup for clipping and then correctly setup when clipping is disabled
- tet_infoline( "Testing Actor::Property::CLIPPING_MODE actor enable and then disable" );
+ tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor enable and then disable" );
TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
size_t startIndex = 0u;
// Create a clipping actor.
- Actor actorDepth1Clip = CreateActorWithContent();
+ Actor actorDepth1Clip = CreateActorWithContent16x16();
actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
Stage::GetCurrent().Add( actorDepth1Clip );
END_TEST;
}
-
int UtcDaliActorPropertyClippingNestedChildren(void)
{
// This test checks that a hierarchy of actors are clipped correctly by
// writing to and reading from the correct bit-planes of the stencil buffer.
- tet_infoline( "Testing Actor::Property::CLIPPING_MODE nested children" );
+ tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN nested children" );
TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
// Create a clipping actor.
- Actor actorDepth1Clip = CreateActorWithContent();
+ Actor actorDepth1Clip = CreateActorWithContent16x16();
actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
Stage::GetCurrent().Add( actorDepth1Clip );
// Create a child actor.
- Actor childDepth2 = CreateActorWithContent();
+ Actor childDepth2 = CreateActorWithContent16x16();
actorDepth1Clip.Add( childDepth2 );
// Create another clipping actor.
- Actor childDepth2Clip = CreateActorWithContent();
+ Actor childDepth2Clip = CreateActorWithContent16x16();
childDepth2Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
childDepth2.Add( childDepth2Clip );
// Create another 2 child actors. We do this so 2 nodes will have the same clipping ID.
// This tests the sort algorithm.
- Actor childDepth3 = CreateActorWithContent();
+ Actor childDepth3 = CreateActorWithContent16x16();
childDepth2Clip.Add( childDepth3 );
- Actor childDepth4 = CreateActorWithContent();
+ Actor childDepth4 = CreateActorWithContent16x16();
childDepth3.Add( childDepth4 );
// Gather the call trace.
END_TEST;
}
-int UtcDaliActorPropertyClippingActorWithRendererOverride(void)
+int UtcDaliActorPropertyClippingActorDrawOrder(void)
{
- // This test checks that an actor with clipping will be ignored if overridden by the Renderer properties.
- tet_infoline( "Testing Actor::Property::CLIPPING_MODE actor with renderer override" );
+ // This test checks that a hierarchy of actors are drawn in the correct order when clipping is enabled.
+ tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN draw order" );
TestApplication application;
-
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
- // Create a clipping actor.
- Actor actorDepth1Clip = CreateActorWithContent();
- actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
- Stage::GetCurrent().Add( actorDepth1Clip );
+ /* We create a small tree of actors as follows:
- // Turn the RenderMode to just "COLOR" at the Renderer level to ignore the clippingMode.
- actorDepth1Clip.GetRendererAt( 0 ).SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR );
+ A
+ / \
+ Clipping enabled -> B D
+ | |
+ C E
- // Gather the call trace.
- GenerateTrace( application, enabledDisableTrace, stencilTrace );
+ The correct draw order is "ABCDE" (the same as if clipping was not enabled).
+ */
+ Actor actors[5];
+ for( int i = 0; i < 5; ++i )
+ {
+ BufferImage image = BufferImage::New( 16u, 16u );
+ Actor actor = CreateRenderableActor( image );
- // Check we are writing to the color buffer.
- CheckColorMask( glAbstraction, true );
+ // Setup dimensions and position so actor is not skipped by culling.
+ actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
+ actor.SetSize( 16.0f, 16.0f );
- // Check the stencil buffer was not enabled.
- DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) ); // 2960 is GL_STENCIL_TEST
+ if( i == 0 )
+ {
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ }
+ else
+ {
+ float b = i > 2 ? 1.0f : -1.0f;
+ actor.SetParentOrigin( Vector3( 0.5 + ( 0.2f * b ), 0.8f, 0.8f ) );
+ }
- // Check stencil functions are not called.
- DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilFunc" ) );
- DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilMask" ) );
- DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilOp" ) );
+ actors[i] = actor;
+ }
- END_TEST;
-}
+ // Enable clipping on the actor at the top of the left branch.
+ actors[1].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
-int UtcDaliGetPropertyN(void)
-{
- tet_infoline( "Testing Actor::GetProperty returns a non valid value if property index is out of range" );
- TestApplication app;
+ // Build the scene graph.
+ Stage::GetCurrent().Add( actors[0] );
- Actor actor = Actor::New();
+ // Left branch:
+ actors[0].Add( actors[1] );
+ actors[1].Add( actors[2] );
- unsigned int propertyCount = actor.GetPropertyCount();
- DALI_TEST_EQUALS( actor.GetProperty( Property::Index(propertyCount)).GetType(), Property::NONE, TEST_LOCATION );
- END_TEST;
-}
+ // Right branch:
+ actors[0].Add( actors[3] );
+ actors[3].Add( actors[4] );
-int UtcDaliActorRaiseLower(void)
-{
- tet_infoline( "UtcDaliActor Raise and Lower test\n" );
+ // Gather the call trace.
+ enabledDisableTrace.Reset();
+ enabledDisableTrace.Enable( true );
+ application.SendNotification();
+ application.Render();
+ enabledDisableTrace.Enable( false );
- TestApplication application;
+ /* Check stencil is enabled and disabled again (as right-hand branch of tree is drawn).
- Stage stage( Stage::GetCurrent() );
+ Note: Correct enable call trace: StackTrace: Index:0, Function:Enable, ParamList:3042 StackTrace: Index:1, Function:Enable, ParamList:2960 StackTrace: Index:2, Function:Disable, ParamList:2960
+ Incorrect enable call trace: StackTrace: Index:0, Function:Enable, ParamList:3042 StackTrace: Index:1, Function:Enable, ParamList:2960
+ */
+ size_t startIndex = 0u;
+ DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Enable", "3042", startIndex ) );
+ DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Enable", "2960", startIndex ) ); // 2960 is GL_STENCIL_TEST
+ DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Disable", "2960", startIndex ) );
- Actor actorA = Actor::New();
- Actor actorB = Actor::New();
- Actor actorC = Actor::New();
+ // Swap the clipping actor from top of left branch to top of right branch.
+ actors[1].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED );
+ actors[3].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
- actorA.SetAnchorPoint( AnchorPoint::CENTER );
- actorA.SetParentOrigin( ParentOrigin::CENTER );
+ // Gather the call trace.
+ enabledDisableTrace.Reset();
+ enabledDisableTrace.Enable( true );
+ application.SendNotification();
+ application.Render();
+ enabledDisableTrace.Enable( false );
- actorB.SetAnchorPoint( AnchorPoint::CENTER );
- actorB.SetParentOrigin( ParentOrigin::CENTER );
+ // Check stencil is enabled but NOT disabled again (as right-hand branch of tree is drawn).
+ // This proves the draw order has remained the same.
+ startIndex = 0u;
+ DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Enable", "2960", startIndex ) );
+ DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Disable", "2960", startIndex ) );
- actorC.SetAnchorPoint( AnchorPoint::CENTER );
+ END_TEST;
+}
+
+int UtcDaliActorPropertyScissorClippingActor(void)
+{
+ // This test checks that an actor is correctly setup for clipping.
+ tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor" );
+ TestApplication application;
+
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+ const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
+ const Vector2 imageSize( 16.0f, 16.0f );
+
+ // Create a clipping actor.
+ Actor clippingActorA = CreateActorWithContent16x16();
+ // Note: Scissor coords are have flipped Y values compared with DALi's coordinate system.
+ // We choose BOTTOM_LEFT to give us x=0, y=0 starting coordinates for the first test.
+ clippingActorA.SetParentOrigin( ParentOrigin::BOTTOM_LEFT );
+ clippingActorA.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
+ clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+ Stage::GetCurrent().Add( clippingActorA );
+
+ // Gather the call trace.
+ GenerateTrace( application, enabledDisableTrace, scissorTrace );
+
+ // Check we are writing to the color buffer.
+ CheckColorMask( glAbstraction, true );
+
+ // Check scissor test was enabled.
+ DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST)
+
+ // Check the scissor was set, and the coordinates are correct.
+ std::stringstream compareParametersString;
+ compareParametersString << "0, 0, " << imageSize.x << ", " << imageSize.y;
+ DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) ); // Compare with 0, 0, 16, 16
+
+ clippingActorA.SetParentOrigin( ParentOrigin::TOP_RIGHT );
+ clippingActorA.SetAnchorPoint( AnchorPoint::TOP_RIGHT );
+
+ // Gather the call trace.
+ GenerateTrace( application, enabledDisableTrace, scissorTrace );
+
+ // Check the scissor was set, and the coordinates are correct.
+ compareParametersString.str( std::string() );
+ compareParametersString.clear();
+ compareParametersString << ( stageSize.x - imageSize.x ) << ", " << ( stageSize.y - imageSize.y ) << ", " << imageSize.x << ", " << imageSize.y;
+ DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) ); // Compare with 464, 784, 16, 16
+
+ END_TEST;
+}
+
+int UtcDaliActorPropertyScissorClippingActorSiblings(void)
+{
+ // This test checks that an actor is correctly setup for clipping.
+ tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actors which are siblings" );
+ TestApplication application;
+
+
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+ const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
+ const Vector2 sizeA{ stageSize.width, stageSize.height * 0.25f };
+ const Vector2 sizeB{ stageSize.width, stageSize.height * 0.05f };
+
+ // Create a clipping actors.
+ Actor clippingActorA = CreateActorWithContent( sizeA.width, sizeA.height );
+ Actor clippingActorB = CreateActorWithContent( sizeB.width, sizeB.height );
+
+ clippingActorA.SetParentOrigin( ParentOrigin::CENTER_LEFT );
+ clippingActorA.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
+ clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+ clippingActorB.SetParentOrigin( ParentOrigin::CENTER_LEFT );
+ clippingActorB.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
+ clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+ clippingActorA.SetPosition( 0.0f, -200.0f, 0.0f );
+ clippingActorB.SetPosition( 0.0f, 0.0f, 0.0f );
+
+ Stage::GetCurrent().Add( clippingActorA );
+ Stage::GetCurrent().Add( clippingActorB );
+
+ // Gather the call trace.
+ GenerateTrace( application, enabledDisableTrace, scissorTrace );
+
+ // Check we are writing to the color buffer.
+ CheckColorMask( glAbstraction, true );
+
+ // Check scissor test was enabled.
+ DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST)
+
+ // Check the scissor was set, and the coordinates are correct.
+ std::stringstream compareParametersString;
+
+ std::string clipA( "0, 500, 480, 200" );
+ std::string clipB( "0, 380, 480, 40" );
+
+ DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipA ) );
+ DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipB ) );
+
+ END_TEST;
+}
+
+int UtcDaliActorPropertyScissorClippingActorNested01(void)
+{
+ // This test checks that an actor is correctly setup for clipping.
+ tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested" );
+ TestApplication application;
+
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+ const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
+ const Vector2 imageSize( 16.0f, 16.0f );
+
+ /* Create a nest of 2 scissors to test nesting (intersecting clips).
+
+ A is drawn first - with scissor clipping on
+ B is drawn second - also with scissor clipping on
+ C is the generated clipping region, the intersection ( A ∩ B )
+
+ ┏━━━━━━━┓ ┌───────┐
+ ┃ B ┃ │ B │
+ ┌───╂┄┄┄┐ ┃ ┌┄┄┄╆━━━┓ │
+ │ ┃ ┊ ┃ ━━━━━> ┊ ┃ C ┃ │
+ │ ┗━━━┿━━━┛ ┊ ┗━━━╃───┘
+ │ A │ ┊ A ┊
+ └───────┘ └┄┄┄┄┄┄┄┘
+
+ We then reposition B around each corner of A to test the 4 overlap combinations (thus testing intersecting works correctly).
+ */
+
+ // Create a clipping actor.
+ Actor clippingActorA = CreateActorWithContent16x16();
+ // Note: Scissor coords are have flipped Y values compared with DALi's coordinate system.
+ // We choose BOTTOM_LEFT to give us x=0, y=0 starting coordinates for the first test.
+ clippingActorA.SetParentOrigin( ParentOrigin::CENTER );
+ clippingActorA.SetAnchorPoint( AnchorPoint::CENTER );
+ clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+ Stage::GetCurrent().Add( clippingActorA );
+
+ // Create a child clipping actor.
+ Actor clippingActorB = CreateActorWithContent16x16();
+ clippingActorB.SetParentOrigin( ParentOrigin::CENTER );
+ clippingActorB.SetAnchorPoint( AnchorPoint::CENTER );
+ clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+ clippingActorA.Add( clippingActorB );
+
+ // positionModifiers is an array of positions to position B around.
+ // expect is an array of expected scissor clip coordinate results.
+ const Vector2 positionModifiers[4] = { Vector2( 1.0f, 1.0f ), Vector2( -1.0f, 1.0f ), Vector2( -1.0f, -1.0f ), Vector2( 1.0f, -1.0f ) };
+ const Vector4 expect[4] = { Vector4( 240, 392, 8, 8 ), Vector4( 232, 392, 8, 8 ), Vector4( 232, 400, 8, 8 ), Vector4( 240, 400, 8, 8 ) };
+
+ // Loop through each overlap combination.
+ for( unsigned int test = 0u; test < 4u; ++test )
+ {
+ // Position the child clipping actor so it intersects with the 1st clipping actor. This changes each loop.
+ const Vector2 position = ( imageSize / 2.0f ) * positionModifiers[test];
+ clippingActorB.SetPosition( position.x, position.y );
+
+ // Gather the call trace.
+ GenerateTrace( application, enabledDisableTrace, scissorTrace );
+
+ // Check we are writing to the color buffer.
+ CheckColorMask( glAbstraction, true );
+
+ // Check scissor test was enabled.
+ DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST)
+
+ // Check the scissor was set, and the coordinates are correct.
+ const Vector4& expectResults( expect[test] );
+ std::stringstream compareParametersString;
+ compareParametersString << expectResults.x << ", " << expectResults.y << ", " << expectResults.z << ", " << expectResults.w;
+ DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) ); // Compare with the expected result
+ }
+
+ END_TEST;
+}
+
+int UtcDaliActorPropertyScissorClippingActorNested02(void)
+{
+ // This test checks that an actor is correctly setup for clipping.
+ tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested" );
+ TestApplication application;
+
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+ /* Create a nest of 2 scissors and siblings of the parent.
+
+ stage
+ |
+ ┌─────┐─────┐
+ A C D
+ | |
+ B E
+ */
+
+ const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
+ const Vector2 sizeA{ stageSize.width, stageSize.height * 0.25f };
+ const Vector2 sizeB{ stageSize.width, stageSize.height * 0.05f };
+ const Vector2 sizeC{ stageSize.width, stageSize.height * 0.25f };
+ const Vector2 sizeD{ stageSize.width, stageSize.height * 0.25f };
+ const Vector2 sizeE{ stageSize.width, stageSize.height * 0.05f };
+
+ // Create a clipping actors.
+ Actor clippingActorA = CreateActorWithContent( sizeA.width, sizeA.height );
+ Actor clippingActorB = CreateActorWithContent( sizeB.width, sizeB.height );
+ Actor clippingActorC = CreateActorWithContent( sizeC.width, sizeC.height );
+ Actor clippingActorD = CreateActorWithContent( sizeD.width, sizeD.height );
+ Actor clippingActorE = CreateActorWithContent( sizeE.width, sizeE.height );
+
+ clippingActorA.SetParentOrigin( ParentOrigin::CENTER_LEFT );
+ clippingActorA.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
+ clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+ clippingActorB.SetParentOrigin( ParentOrigin::CENTER_LEFT );
+ clippingActorB.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
+ clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+ clippingActorC.SetParentOrigin( ParentOrigin::CENTER_LEFT );
+ clippingActorC.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
+ clippingActorC.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+ clippingActorD.SetParentOrigin( ParentOrigin::CENTER_LEFT );
+ clippingActorD.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
+ clippingActorD.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+ clippingActorE.SetParentOrigin( ParentOrigin::CENTER_LEFT );
+ clippingActorE.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
+
+ clippingActorA.SetPosition( 0.0f, -200.0f, 0.0f );
+ clippingActorB.SetPosition( 0.0f, 0.0f, 0.0f );
+ clippingActorC.SetPosition( 0.0f, 100.0f, 0.0f );
+ clippingActorD.SetPosition( 0.0f, 0.0f, 0.0f );
+ clippingActorE.SetPosition( 0.0f, 0.0f, 0.0f );
+
+ Stage::GetCurrent().Add( clippingActorA );
+ clippingActorA.Add( clippingActorB );
+ Stage::GetCurrent().Add( clippingActorC );
+ Stage::GetCurrent().Add( clippingActorD );
+ clippingActorD.Add( clippingActorE );
+
+ // Gather the call trace.
+ GenerateTrace( application, enabledDisableTrace, scissorTrace );
+
+ // Check we are writing to the color buffer.
+ CheckColorMask( glAbstraction, true );
+
+ // Check scissor test was enabled.
+ DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST)
+
+ // Check the scissor was set, and the coordinates are correct.
+ std::string clipA( "0, 500, 480, 200" );
+ std::string clipB( "0, 580, 480, 40" );
+ std::string clipC( "0, 200, 480, 200" );
+ std::string clipD( "0, 300, 480, 200" );
+
+ DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipA ) );
+ DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipB ) );
+ DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipC ) );
+ DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipD ) );
+ DALI_TEST_CHECK( scissorTrace.CountMethod( "Scissor" ) == 4 ); // Scissor rect should not be changed in clippingActorE case. So count should be 4.
+
+ END_TEST;
+}
+
+int UtcDaliActorPropertyClippingActorWithRendererOverride(void)
+{
+ // This test checks that an actor with clipping will be ignored if overridden by the Renderer properties.
+ tet_infoline( "Testing Actor::Property::CLIPPING_MODE actor with renderer override" );
+ TestApplication application;
+
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+ // Create a clipping actor.
+ Actor actorDepth1Clip = CreateActorWithContent16x16();
+ actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
+ Stage::GetCurrent().Add( actorDepth1Clip );
+
+ // Turn the RenderMode to just "COLOR" at the Renderer level to ignore the clippingMode.
+ actorDepth1Clip.GetRendererAt( 0 ).SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR );
+
+ // Gather the call trace.
+ GenerateTrace( application, enabledDisableTrace, stencilTrace );
+
+ // Check we are writing to the color buffer.
+ CheckColorMask( glAbstraction, true );
+
+ // Check the stencil buffer was not enabled.
+ DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) ); // 2960 is GL_STENCIL_TEST
+
+ // Check stencil functions are not called.
+ DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilFunc" ) );
+ DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilMask" ) );
+ DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilOp" ) );
+
+ // Check that scissor clipping is overriden by the renderer properties.
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+
+ actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+ // Gather the call trace.
+ GenerateTrace( application, enabledDisableTrace, scissorTrace );
+
+ // Check the stencil buffer was not enabled.
+ DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST)
+
+ DALI_TEST_CHECK( !scissorTrace.FindMethod( "StencilFunc" ) );
+
+ END_TEST;
+}
+
+int UtcDaliGetPropertyN(void)
+{
+ tet_infoline( "Testing Actor::GetProperty returns a non valid value if property index is out of range" );
+ TestApplication app;
+
+ Actor actor = Actor::New();
+
+ unsigned int propertyCount = actor.GetPropertyCount();
+ DALI_TEST_EQUALS( actor.GetProperty( Property::Index(propertyCount)).GetType(), Property::NONE, TEST_LOCATION );
+ END_TEST;
+}
+
+int UtcDaliActorRaiseLower(void)
+{
+ tet_infoline( "UtcDaliActor Raise and Lower test\n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor actorA = Actor::New();
+ Actor actorB = Actor::New();
+ Actor actorC = Actor::New();
+
+ actorA.SetAnchorPoint( AnchorPoint::CENTER );
+ actorA.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorB.SetAnchorPoint( AnchorPoint::CENTER );
+ actorB.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorC.SetAnchorPoint( AnchorPoint::CENTER );
actorC.SetParentOrigin( ParentOrigin::CENTER );
actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
actorB.TouchSignal().Connect( TestTouchCallback2 );
actorC.TouchSignal().Connect( TestTouchCallback3 );
+ // Connect ChildOrderChangedSignal
+ bool orderChangedSignal( false );
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+ DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+
Dali::Integration::Point point;
point.SetDeviceId( 1 );
point.SetState( PointState::DOWN );
Property::Value value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
value.Get( preActorOrder );
- DevelActor::Raise( actorB );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorB.Raise();
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+
// Ensure sort order is calculated before next touch event
application.SendNotification();
value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
value.Get( preActorOrder );
- DevelActor::Lower( actorB );
+ orderChangedSignal = false;
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorB.Lower();
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+
application.SendNotification(); // ensure sort order calculated before next touch event
value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
ResetTouchCallbacks();
+ // Connect ChildOrderChangedSignal
+ bool orderChangedSignal( false );
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+ DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+
// Set up gl abstraction trace so can query the set uniform order
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableSetUniformCallTrace(true);
tet_printf( "RaiseToTop ActorA\n" );
- DevelActor::RaiseToTop( actorA );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorA.RaiseToTop();
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+
application.SendNotification(); // ensure sorting order is calculated before next touch event
application.ProcessEvent( touchEvent );
tet_printf( "RaiseToTop ActorB\n" );
- DevelActor::RaiseToTop( actorB );
+ orderChangedSignal = false;
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorB.RaiseToTop();
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+
application.SendNotification(); // Ensure sort order is calculated before next touch event
application.ProcessEvent( touchEvent );
tet_printf( "LowerToBottom ActorA then ActorB leaving Actor C at Top\n" );
- DevelActor::LowerToBottom( actorA );
+ orderChangedSignal = false;
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorA.LowerToBottom();
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+
application.SendNotification();
application.Render();
- DevelActor::LowerToBottom( actorB );
+ orderChangedSignal = false;
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorB.LowerToBottom();
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+
application.SendNotification();
application.Render();
actorB.TouchSignal().Connect( TestTouchCallback2 );
actorC.TouchSignal().Connect( TestTouchCallback3 );
+ bool orderChangedSignal( false );
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+ DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+
Dali::Integration::Point point;
point.SetDeviceId( 1 );
point.SetState( PointState::DOWN );
tet_printf( "Raise actor B Above Actor C\n" );
- DevelActor::RaiseAbove( actorB, actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorB.RaiseAbove( actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
-
application.ProcessEvent( touchEvent );
DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
tet_printf( "Raise actor A Above Actor B\n" );
- DevelActor::RaiseAbove( actorA, actorB );
+ orderChangedSignal = false;
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorA.RaiseAbove( actorB );
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
- stage.Add( actorA );
- stage.Add( actorB );
- stage.Add( actorC );
+ Actor container = Actor::New();
+ container.SetParentOrigin( ParentOrigin::CENTER );
+ container.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+ stage.Add( container );
+
+ container.Add( actorA );
+ container.Add( actorB );
+ container.Add( actorC );
ResetTouchCallbacks();
+ // Connect ChildOrderChangedSignal
+ bool orderChangedSignal( false );
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+ DevelActor::ChildOrderChangedSignal( container ).Connect( &application, f ) ;
+
// Set up gl abstraction trace so can query the set uniform order
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableSetUniformCallTrace(true);
tet_printf( "Lower actor C below Actor B ( actor B and A on same level due to insertion order) so C is below both \n" );
- DevelActor::LowerBelow( actorC, actorB );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorC.LowerBelow( actorB );
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorC, TEST_LOCATION );
+
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
application.Render();
indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
- tet_infoline( "Testing B above A and C at bottom\n" );
- bool BAC = ( indexB > indexA) && ( indexA > indexC ); // B at TOP, then A then C at bottom
-
- DALI_TEST_EQUALS( BAC, true, TEST_LOCATION );
+ tet_infoline( "Testing render order is A, C, B" );
+ DALI_TEST_EQUALS( indexC > indexA, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( indexB > indexC, true, TEST_LOCATION );
DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
ResetTouchCallbacks();
- tet_printf( "Lower actor B below Actor C leaving A on top\n" );
+ tet_printf( "Lower actor C below Actor A leaving B on top\n" );
+
+ orderChangedSignal = false;
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorC.LowerBelow( actorA );
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorC, TEST_LOCATION );
- DevelActor::LowerBelow( actorB, actorC );
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
application.Render();
indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
- bool ACB = ( indexA > indexC) && ( indexC > indexB ); // A on TOP, then C then B at bottom
-
- DALI_TEST_EQUALS( ACB, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( indexA > indexC, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( indexB > indexA, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
ResetTouchCallbacks();
- tet_printf( "Lower actor A below Actor C leaving C on top\n" );
+ tet_printf( "Lower actor B below Actor C leaving A on top\n" );
+
+ orderChangedSignal = false;
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorB.LowerBelow( actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
- DevelActor::LowerBelow( actorA, actorC );
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
application.Render();
indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
- bool CAB = ( indexC > indexA) && ( indexA > indexB );
-
- DALI_TEST_EQUALS( CAB, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( indexC > indexB, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( indexA > indexC, true, TEST_LOCATION );
END_TEST;
}
-int UtcDaliActorMaxSiblingOrder(void)
-{
- tet_infoline( "UtcDaliActor De-fragment of sibling order once max index reached\n" );
-
- TestApplication application;
-
- int testOrders[] = { 0,1,3,5,17,998, 999 };
- int resultingOrders[] = { 0,1,2,3,4,6,5 };
-
- const int TEST_ORDERS_COUNT = sizeof( testOrders ) / sizeof( testOrders[0] );
-
- Stage stage( Stage::GetCurrent() );
-
- Actor parent = Actor::New();
-
- for ( int index = 0; index < TEST_ORDERS_COUNT; index++ )
- {
- Actor newActor = Actor::New();
- newActor.SetProperty(Dali::DevelActor::Property::SIBLING_ORDER, testOrders[index] );
- parent.Add( newActor );
- }
- stage.Add( parent );
-
- tet_printf( "Sibling Order %d children :", parent.GetChildCount() );
- for ( unsigned int index = 0; index < parent.GetChildCount(); index ++)
- {
- Actor sibling = parent.GetChildAt( index );
- int siblingOrder = 0;
- Property::Value value = sibling.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
- value.Get( siblingOrder );
- tet_printf( "%d, ", siblingOrder );
- }
- tet_printf( "\n" );
-
- Actor sibling = parent.GetChildAt( 5 );
- DevelActor::RaiseToTop( sibling );
-
- // Ensure sorting happens at end of Core::ProcessEvents()
- application.SendNotification();
- application.Render();
-
- tet_printf( "Sibling Order %d children :", parent.GetChildCount() );
- for ( unsigned int index = 0; index < parent.GetChildCount(); index ++)
- {
- Actor sibling = parent.GetChildAt( index );
- int siblingOrder = 0;
- Property::Value value = sibling.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
- value.Get( siblingOrder );
- tet_printf( "%d, ", siblingOrder );
- DALI_TEST_EQUALS( siblingOrder, resultingOrders[ index] , TEST_LOCATION );
- }
-
- tet_printf( "\n" );
- END_TEST;
-}
-
-int UtcDaliActorRaiseAboveLowerBelowDifferentParentsN(void)
+int UtcDaliActorRaiseAboveDifferentParentsN(void)
{
tet_infoline( "UtcDaliActor RaiseToAbove test with actor and target actor having different parents \n" );
ResetTouchCallbacks();
+ // Connect ChildOrderChangedSignal
+ bool orderChangedSignal( false );
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+ DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+
application.SendNotification();
application.Render();
tet_printf( "Raise actor A Above Actor C which have different parents\n" );
- DevelActor::RaiseAbove( actorA, actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorA.RaiseAbove( actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
ResetTouchCallbacks();
+ // Connect ChildOrderChangedSignal
+ bool orderChangedSignal( false );
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+ DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+
application.SendNotification();
application.Render();
tet_printf( "Raise actor A Above Actor C which have no parents\n" );
- DevelActor::RaiseAbove( actorA, actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorA.RaiseAbove( actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
ResetTouchCallbacks();
+ orderChangedSignal = false;
+
stage.Add ( actorB );
tet_printf( "Lower actor A below Actor C when only A is not on stage \n" );
- DevelActor::LowerBelow( actorA, actorC );
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorA.LowerBelow( actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
ResetTouchCallbacks();
+ orderChangedSignal = false;
+
tet_printf( "Adding Actor A to stage, will be on top\n" );
stage.Add ( actorA );
application.Render();
tet_printf( "Raise actor B Above Actor C when only B has a parent\n" );
- DevelActor::RaiseAbove( actorB, actorC );
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorB.RaiseAbove( actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
ResetTouchCallbacks();
+ orderChangedSignal = false;
+
tet_printf( "Lower actor A below Actor C when only A has a parent\n" );
- DevelActor::LowerBelow( actorA, actorC );
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorA.LowerBelow( actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
ResetTouchCallbacks();
+ orderChangedSignal = false;
+
stage.Add ( actorC );
- DevelActor::RaiseAbove( actorA, actorC );
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorA.RaiseAbove( actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
application.Render();
ResetTouchCallbacks();
+ // Connect ChildOrderChangedSignal
+ bool orderChangedSignal( false );
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+ DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+
// connect to actor touch signals, will use touch callbacks to determine which actor is on top.
// Only top actor will get touched.
actorA.TouchSignal().Connect( TestTouchCallback );
stage.Add ( actorA );
tet_printf( "Raise actor B Above Actor C but B not parented\n" );
- DevelActor::Raise( actorB );
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorB.Raise();
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
application.SendNotification();
application.Render();
tet_printf( "Raise actor B Above Actor C but B not parented\n" );
ResetTouchCallbacks();
- DevelActor::Lower( actorC );
+ orderChangedSignal = false;
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorC.Lower();
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
// Sort actor tree before next touch event
application.SendNotification();
application.Render();
DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
ResetTouchCallbacks();
+ orderChangedSignal = false;
+
tet_printf( "Lower actor C below B but C not parented\n" );
- DevelActor::Lower( actorB );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorB.Lower();
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
// Sort actor tree before next touch event
application.SendNotification();
application.Render();
DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
ResetTouchCallbacks();
+ orderChangedSignal = false;
+
tet_printf( "Raise actor B to top\n" );
- DevelActor::RaiseToTop( actorB );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorB.RaiseToTop();
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
// Sort actor tree before next touch event
application.SendNotification();
application.Render();
DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
ResetTouchCallbacks();
+ orderChangedSignal = false;
+
tet_printf( "Add ActorB to stage so only Actor C not parented\n" );
stage.Add ( actorB );
tet_printf( "Lower actor C to Bottom, B stays at top\n" );
- DevelActor::LowerToBottom( actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorC.LowerToBottom();
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
application.SendNotification();
application.Render();
ResetTouchCallbacks();
+ // Connect ChildOrderChangedSignal
+ bool orderChangedSignal( false );
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+ DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+
application.SendNotification();
application.Render();
tet_infoline( "Raise actor A Above Actor A which is the same actor!!\n" );
- DevelActor::RaiseAbove( actorA, actorA );
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorA.RaiseAbove( actorA );
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+
application.SendNotification();
application.Render();
ResetTouchCallbacks();
- DevelActor::RaiseAbove( actorA, actorC );
+ orderChangedSignal = false;
+
+ DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ actorA.RaiseAbove( actorC );
+ DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+
application.SendNotification();
application.Render();
tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0\n", actorWorldPosition.x, actorWorldPosition.y );
tet_printf( "Actor Screen Position( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0 \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_infoline( "UtcDaliActorGetScreenPosition Scale parent and check child's screen position \n" );
+
+ actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+ actorA.SetPosition( 30.0, 30.0 );
+
+ Actor actorB = Actor::New();
+ actorB.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+ actorB.SetSize( size2 );
+ actorB.SetPosition( 10.f, 10.f );
+ actorA.Add( actorB );
+
+ actorA.SetScale( 2.0f );
+
+ application.SendNotification();
+ application.Render();
+
+ actorScreenPosition = actorB.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ DALI_TEST_EQUALS( actorScreenPosition.x, 50lu , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, 50lu , TEST_LOCATION );
END_TEST;
}
END_TEST;
}
+
+
+int utcDaliActorVisibilityChangeSignalByName(void)
+{
+ TestApplication application;
+ tet_infoline( "Check that the visibility change signal is called when the visibility changes for the actor itself" );
+
+ Actor actor = Actor::New();
+
+ bool signalCalled=false;
+ actor.ConnectSignal( &application, "visibilityChanged", VisibilityChangedVoidFunctor(signalCalled) );
+ DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+ actor.SetVisible( false );
+ DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
+
+ tet_infoline( "Ensure functor is not called if we attempt to change the visibility to what it already is at" );
+ signalCalled = false;
+ actor.SetVisible( false );
+ DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+
+ tet_infoline( "Change the visibility using properties, ensure called" );
+ actor.SetProperty( Actor::Property::VISIBLE, true );
+ DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
+
+ tet_infoline( "Set the visibility to current using properties, ensure not called" );
+ signalCalled = false;
+
+ actor.SetProperty( Actor::Property::VISIBLE, true );
+ DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+
+ END_TEST;
+}
+
+
+static void LayoutDirectionChanged( Actor actor, LayoutDirection::Type type )
+{
+ gLayoutDirectionType = type;
+}
+
+int UtcDaliActorLayoutDirectionProperty(void)
+{
+ TestApplication application;
+ tet_infoline( "Check layout direction property" );
+
+ Actor actor0 = Actor::New();
+ DALI_TEST_EQUALS( actor0.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ Stage::GetCurrent().Add( actor0 );
+
+ application.SendNotification();
+ application.Render();
+
+ Actor actor1 = Actor::New();
+ DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ Actor actor2 = Actor::New();
+ DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ Actor actor3 = Actor::New();
+ DALI_TEST_EQUALS( actor3.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ Actor actor4 = Actor::New();
+ DALI_TEST_EQUALS( actor4.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ Actor actor5 = Actor::New();
+ DALI_TEST_EQUALS( actor5.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ Actor actor6 = Actor::New();
+ DALI_TEST_EQUALS( actor6.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ Actor actor7 = Actor::New();
+ DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ Actor actor8 = Actor::New();
+ DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ Actor actor9 = Actor::New();
+ DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+
+ actor1.Add( actor2 );
+ gLayoutDirectionType = LayoutDirection::LEFT_TO_RIGHT;
+ actor2.LayoutDirectionChangedSignal().Connect( LayoutDirectionChanged );
+
+ DALI_TEST_EQUALS( actor1.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), true, TEST_LOCATION );
+ actor1.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
+ DALI_TEST_EQUALS( actor1.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), false, TEST_LOCATION );
+
+ DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( gLayoutDirectionType, LayoutDirection::RIGHT_TO_LEFT, TEST_LOCATION );
+
+ actor1.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, true );
+ actor0.Add( actor1 );
+ DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+
+ Stage::GetCurrent().Add( actor3 );
+ actor3.Add( actor4 );
+ actor4.Add( actor5 );
+ actor5.Add( actor6 );
+ actor5.Add( actor7 );
+ actor7.Add( actor8 );
+ actor8.Add( actor9 );
+ actor3.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
+ actor5.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
+
+ DALI_TEST_EQUALS( actor8.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), true, TEST_LOCATION );
+ actor8.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, false );
+ DALI_TEST_EQUALS( actor8.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), false, TEST_LOCATION );
+
+ actor7.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
+
+ DALI_TEST_EQUALS( actor3.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor4.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor5.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor6.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+
+ actor8.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
+ DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+
+ actor7.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
+ DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+
+ actor8.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, true );
+ DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+
+ END_TEST;
+}
+
+
+struct LayoutDirectionFunctor
+{
+ LayoutDirectionFunctor(bool& signalCalled)
+ : mSignalCalled( signalCalled )
+ {
+ }
+
+ LayoutDirectionFunctor(const LayoutDirectionFunctor& rhs)
+ : mSignalCalled( rhs.mSignalCalled )
+ {
+ }
+
+ void operator()()
+ {
+ mSignalCalled = true;
+ }
+
+ bool& mSignalCalled;
+};
+
+int UtcDaliActorLayoutDirectionSignal(void)
+{
+ TestApplication application;
+ tet_infoline( "Check changing layout direction property sends a signal" );
+
+ Actor actor = Actor::New();
+ DALI_TEST_EQUALS( actor.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ Stage::GetCurrent().Add( actor );
+ bool signalCalled = false;
+ LayoutDirectionFunctor layoutDirectionFunctor(signalCalled);
+
+ actor.ConnectSignal( &application, "layoutDirectionChanged", layoutDirectionFunctor );
+ DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+
+ // Test that writing the same value doesn't send a signal
+ actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
+ DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+
+ // Test that writing a different value sends the signal
+ signalCalled = false;
+ actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
+ DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
+
+ signalCalled = false;
+ actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
+ DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+
+ END_TEST;
+}
+
+struct ChildAddedSignalCheck
+{
+ ChildAddedSignalCheck( bool& signalReceived, Actor& childHandle )
+ : mSignalReceived( signalReceived ),
+ mChildHandle( childHandle )
+ {
+ }
+
+ void operator() ( Actor childHandle )
+ {
+ mSignalReceived = true;
+ mChildHandle = childHandle;
+ }
+ void operator() ()
+ {
+ mSignalReceived = true;
+ mChildHandle = Actor();
+ }
+
+ bool& mSignalReceived;
+ Actor& mChildHandle;
+};
+
+int UtcDaliChildAddedSignalP1(void)
+{
+ TestApplication application;
+ auto stage = Stage::GetCurrent();
+
+ bool signalReceived=false;
+ Actor childActor;
+
+ ChildAddedSignalCheck signal( signalReceived, childActor );
+ DevelActor::ChildAddedSignal( stage.GetRootLayer() ).Connect( &application, signal );
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+ auto actorA = Actor::New();
+ stage.Add( actorA );
+ DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
+ signalReceived = false;
+
+ auto actorB = Actor::New();
+ stage.Add( actorB );
+ DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( childActor, actorB, TEST_LOCATION );
+
+ END_TEST;
+}
+
+
+int UtcDaliChildAddedSignalP2(void)
+{
+ TestApplication application;
+ auto stage = Stage::GetCurrent();
+
+ bool signalReceived=false;
+ Actor childActor;
+
+ ChildAddedSignalCheck signal( signalReceived, childActor );
+ tet_infoline( "Connect to childAdded signal by name" );
+
+ stage.GetRootLayer().ConnectSignal( &application, "childAdded", signal );
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+ auto actorA = Actor::New();
+ stage.Add( actorA );
+ DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+
+ // Can't test which actor was added; signal signature is void() when connecting via name.
+ signalReceived = false;
+
+ auto actorB = Actor::New();
+ stage.Add( actorB );
+ DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliChildAddedSignalN(void)
+{
+ TestApplication application;
+ auto stage = Stage::GetCurrent();
+
+ bool signalReceived=false;
+ Actor childActor;
+
+ ChildAddedSignalCheck signal( signalReceived, childActor );
+ DevelActor::ChildAddedSignal( stage.GetRootLayer() ).Connect( &application, signal );
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+ auto actorA = Actor::New();
+ stage.Add( actorA );
+ DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
+ signalReceived = false;
+
+ auto actorB = Actor::New();
+ actorA.Add( actorB );
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ END_TEST;
+}
+
+
+struct ChildRemovedSignalCheck
+{
+ ChildRemovedSignalCheck( bool& signalReceived, Actor& childHandle )
+ : mSignalReceived( signalReceived ),
+ mChildHandle( childHandle )
+ {
+ }
+
+ void operator() ( Actor childHandle )
+ {
+ mSignalReceived = true;
+ mChildHandle = childHandle;
+ }
+
+ void operator() ()
+ {
+ mSignalReceived = true;
+ }
+
+ bool& mSignalReceived;
+ Actor& mChildHandle;
+};
+
+int UtcDaliChildRemovedSignalP1(void)
+{
+ TestApplication application;
+ auto stage = Stage::GetCurrent();
+
+ bool signalReceived=false;
+ Actor childActor;
+
+ ChildRemovedSignalCheck signal( signalReceived, childActor );
+ DevelActor::ChildRemovedSignal( stage.GetRootLayer() ).Connect( &application, signal );
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+ auto actorA = Actor::New();
+ stage.Add( actorA );
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ DALI_TEST_CHECK( !childActor );
+
+ stage.Remove( actorA );
+ DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
+ DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+
+ signalReceived = false;
+ auto actorB = Actor::New();
+ stage.Add( actorB );
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+ stage.Remove( actorB );
+ DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( childActor, actorB, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliChildRemovedSignalP2(void)
+{
+ TestApplication application;
+ auto stage = Stage::GetCurrent();
+
+ bool signalReceived=false;
+ Actor childActor;
+
+ ChildAddedSignalCheck signal( signalReceived, childActor );
+ tet_infoline( "Connect to childRemoved signal by name" );
+
+ stage.GetRootLayer().ConnectSignal( &application, "childRemoved", signal );
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+ auto actorA = Actor::New();
+ stage.Add( actorA );
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+ stage.Remove( actorA );
+ DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+
+ signalReceived = false;
+ auto actorB = Actor::New();
+ stage.Add( actorB );
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+ stage.Remove( actorB );
+ DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+
+ END_TEST;
+}
+
+
+int UtcDaliChildRemovedSignalN(void)
+{
+ TestApplication application;
+ auto stage = Stage::GetCurrent();
+
+ bool signalReceived=false;
+ Actor childActor;
+
+ ChildRemovedSignalCheck signal( signalReceived, childActor );
+ DevelActor::ChildRemovedSignal( stage.GetRootLayer() ).Connect( &application, signal );
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+ auto actorA = Actor::New();
+ stage.Add( actorA );
+
+ auto actorB = Actor::New();
+ actorA.Add( actorB );
+
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ DALI_TEST_CHECK( ! childActor );
+
+ actorA.Remove( actorB );
+ DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ END_TEST;
+}
+
+
+int UtcDaliChildMovedSignalP(void)
+{
+ TestApplication application;
+ auto stage = Stage::GetCurrent();
+
+ bool addedASignalReceived = false;
+ bool removedASignalReceived = false;
+ bool addedBSignalReceived = false;
+ bool removedBSignalReceived = false;
+ Actor childActor;
+
+ auto actorA = Actor::New();
+ auto actorB = Actor::New();
+ stage.Add( actorA );
+ stage.Add( actorB );
+
+ ChildAddedSignalCheck addedSignalA( addedASignalReceived, childActor );
+ ChildRemovedSignalCheck removedSignalA( removedASignalReceived, childActor );
+ ChildAddedSignalCheck addedSignalB( addedBSignalReceived, childActor );
+ ChildRemovedSignalCheck removedSignalB( removedBSignalReceived, childActor );
+
+ DevelActor::ChildAddedSignal( actorA ).Connect( &application, addedSignalA );
+ DevelActor::ChildRemovedSignal( actorA ).Connect( &application, removedSignalA );
+ DevelActor::ChildAddedSignal( actorB ).Connect( &application, addedSignalB );
+ DevelActor::ChildRemovedSignal( actorB ).Connect( &application, removedSignalB );
+
+ DALI_TEST_EQUALS( addedASignalReceived, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
+
+ // Create a child of A
+
+ auto child = Actor::New();
+ actorA.Add( child );
+
+ DALI_TEST_EQUALS( addedASignalReceived, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( childActor, child, TEST_LOCATION );
+
+ // Move child to B:
+ addedASignalReceived = false;
+ addedBSignalReceived = false;
+ removedASignalReceived = false;
+ removedBSignalReceived = false;
+
+ actorB.Add( child ); // Expect this child to be re-parented
+ DALI_TEST_EQUALS( addedASignalReceived, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( removedASignalReceived, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( addedBSignalReceived, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
+
+ // Move child back to A:
+ addedASignalReceived = false;
+ addedBSignalReceived = false;
+ removedASignalReceived = false;
+ removedBSignalReceived = false;
+
+ actorA.Add( child ); // Expect this child to be re-parented
+ DALI_TEST_EQUALS( addedASignalReceived, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( removedBSignalReceived, true, TEST_LOCATION );
+
+
+ END_TEST;
+}
+
+int utcDaliActorCulled(void)
+{
+ TestApplication application;
+ auto stage = Stage::GetCurrent();
+
+ tet_infoline( "Check that the actor is culled if the actor is out of the screen" );
+
+ Actor actor = Actor::New();
+ actor.SetSize( 10.0f, 10.0f );
+
+ Geometry geometry = CreateQuadGeometry();
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
+ actor.AddRenderer( renderer );
+
+ stage.Add( actor );
+
+ application.SendNotification();
+ application.Render( 0 );
+
+ DALI_TEST_EQUALS( actor.GetProperty< bool >( DevelActor::Property::CULLED ), false, TEST_LOCATION );
+
+ PropertyNotification notification = actor.AddPropertyNotification( DevelActor::Property::CULLED, LessThanCondition( 0.5f ) );
+ notification.SetNotifyMode( PropertyNotification::NotifyOnChanged );
+
+ // Connect NotifySignal
+ bool propertyNotificationSignal( false );
+ PropertyNotification source;
+ CulledPropertyNotificationFunctor f( propertyNotificationSignal, source );
+ notification.NotifySignal().Connect( &application, f ) ;
+
+ actor.SetPosition( 1000.0f, 1000.0f );
+
+ application.SendNotification();
+ application.Render();
+
+ application.SendNotification();
+
+ DALI_TEST_EQUALS( actor.GetProperty< bool >( DevelActor::Property::CULLED ), true, TEST_LOCATION );
+
+ DALI_TEST_EQUALS( propertyNotificationSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( source.GetTargetProperty(), static_cast< int >( DevelActor::Property::CULLED ), TEST_LOCATION );
+ DALI_TEST_EQUALS( source.GetTarget().GetProperty< bool >( source.GetTargetProperty() ), true, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliActorUpdateSizeHint(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ Vector3 vector(100.0f, 100.0f, 0.0f);
+
+ DALI_TEST_CHECK(vector != actor.GetCurrentSize());
+
+ actor.SetSize(vector.x, vector.y);
+
+
+ Vector2 updateSizeHint = Vector2(150.f, 150.f);
+ actor.SetProperty(Dali::DevelActor::Property::UPDATE_SIZE_HINT, updateSizeHint);
+
+ // Flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+
+ Vector2 currentSizeHint = actor.GetProperty( Dali::DevelActor::Property::UPDATE_SIZE_HINT ).Get< Vector2 >();
+ DALI_TEST_EQUALS( currentSizeHint, updateSizeHint, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ // Flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ END_TEST;
+}
+
+int utcDaliEnsureRenderWhenRemovingLastRenderableActor(void)
+{
+ TestApplication application;
+ auto stage = Stage::GetCurrent();
+
+ tet_infoline( "Ensure we clear the screen when the last actor is removed" );
+
+ Actor actor = CreateRenderableActor();
+ actor.SetSize( 100.0f, 100.0f );
+ stage.Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ auto& glAbstraction = application.GetGlAbstraction();
+ const auto clearCountBefore = glAbstraction.GetClearCountCalled();
+
+ actor.Unparent();
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int utcDaliEnsureRenderWhenMakingLastActorInvisible(void)
+{
+ TestApplication application;
+ auto stage = Stage::GetCurrent();
+
+ tet_infoline( "Ensure we clear the screen when the last actor is made invisible" );
+
+ Actor actor = CreateRenderableActor();
+ actor.SetSize( 100.0f, 100.0f );
+ stage.Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ auto& glAbstraction = application.GetGlAbstraction();
+ const auto clearCountBefore = glAbstraction.GetClearCountCalled();
+
+ actor.SetVisible( false );
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
+
+ END_TEST;
+}
projects / platform / core / uifw / dali-core.git / blobdiff