X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali%2Futc-Dali-Actor.cpp;h=12cbecd6ad9ec3c8c1880f198a09a11dbfd477af;hb=17f28cc04cbb2708a29a6ef7a353ce15fc434b2d;hp=bcc2aca73dac49c6a69c7c7e7970f2e13162109d;hpb=7f980d4fce89b03e0b5f3fe7947fa7b6e840127c;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/automated-tests/src/dali/utc-Dali-Actor.cpp b/automated-tests/src/dali/utc-Dali-Actor.cpp index bcc2aca..12cbecd 100644 --- a/automated-tests/src/dali/utc-Dali-Actor.cpp +++ b/automated-tests/src/dali/utc-Dali-Actor.cpp @@ -1,5 +1,5 @@ /* - * 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. @@ -51,6 +51,8 @@ bool gHoverCallBackCalled=false; static bool gTestConstraintCalled; +LayoutDirection::Type gLayoutDirectionType; + struct TestConstraint { void operator()( Vector4& color, const PropertyInputContainer& /* inputs */ ) @@ -177,6 +179,107 @@ void OnRelayoutCallback( Actor actor ) gActorNamesRelayout.push_back( actor.GetName() ); } +struct VisibilityChangedFunctorData +{ + VisibilityChangedFunctorData() + : actor(), + visible( false ), + type( DevelActor::VisibilityChange::SELF ), + called( false ) + { + } + + void Reset() + { + actor.Reset(); + visible = false; + type = DevelActor::VisibilityChange::SELF; + called = false; + } + + void Check( bool compareCalled, Actor compareActor, bool compareVisible, DevelActor::VisibilityChange::Type compareType, const char * location ) + { + DALI_TEST_EQUALS( called, compareCalled, TEST_INNER_LOCATION( location ) ); + DALI_TEST_EQUALS( actor, compareActor, TEST_INNER_LOCATION( location ) ); + DALI_TEST_EQUALS( visible, compareVisible, TEST_INNER_LOCATION( location ) ); + DALI_TEST_EQUALS( (int)type, (int)compareType, TEST_INNER_LOCATION( location ) ); + } + + void Check( bool compareCalled, const std::string& location ) + { + DALI_TEST_EQUALS( called, compareCalled, TEST_INNER_LOCATION( location ) ); + } + + Actor actor; + bool visible; + DevelActor::VisibilityChange::Type type; + bool called; +}; + +struct VisibilityChangedFunctor +{ + VisibilityChangedFunctor( VisibilityChangedFunctorData& dataVar ) : data( dataVar ) { } + + void operator()( Actor actor, bool visible, DevelActor::VisibilityChange::Type type ) + { + data.actor = actor; + data.visible = visible; + data.type = type; + data.called = true; + } + + 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 @@ -569,6 +672,75 @@ int UtcDaliActorGetParent02(void) 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(index) == startValue ); + + application.SendNotification(); + application.Render(0); + DALI_TEST_CHECK( actor.GetProperty(index) == startValue ); + + actor.SetProperty( index, 5.0f ); + + application.SendNotification(); + application.Render(0); + DALI_TEST_CHECK( actor.GetProperty(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(index) == startValue ); + + application.SendNotification(); + application.Render(0); + DALI_TEST_CHECK( actor.GetProperty(index) == startValue ); + + actor.SetProperty( index, int(1) ); + + application.SendNotification(); + application.Render(0); + DALI_TEST_CHECK( actor.GetProperty(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(index) == startValue ); + + application.SendNotification(); + application.Render(0); + DALI_TEST_CHECK( actor.GetProperty(index) == startValue ); + + actor.SetProperty( index, float(1.5) ); + + application.SendNotification(); + application.Render(0); + DALI_TEST_CHECK( actor.GetProperty(index) == 1 ); + END_TEST; +} + int UtcDaliActorSetParentOrigin(void) { TestApplication application; @@ -755,6 +927,9 @@ int UtcDaliActorSetSize01(void) // Immediately retrieve the size after setting Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >(); DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION ); // Flush the queue and render once application.SendNotification(); @@ -765,6 +940,16 @@ int UtcDaliActorSetSize01(void) currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >(); DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION ); + + // Check async behaviour + currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >(); + DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION ); // Change the resize policy and check whether the size stays the same actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS ); @@ -979,6 +1164,37 @@ int UtcDaliActorSetSizeIndividual(void) END_TEST; } +int UtcDaliActorSetSizeIndividual02(void) +{ + TestApplication application; + + Actor actor = Actor::New(); + actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS ); + Stage::GetCurrent().Add( actor ); + + Vector3 vector( 100.0f, 200.0f, 400.0f ); + DALI_TEST_CHECK( vector != actor.GetCurrentSize() ); + + actor.SetProperty( Actor::Property::SIZE_WIDTH, vector.width ); + DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >(), vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION ); + + actor.SetProperty( Actor::Property::SIZE_HEIGHT, vector.height ); + DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >(), vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION ); + + actor.SetProperty( Actor::Property::SIZE_DEPTH, vector.depth ); + DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >(), vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION ); + + // flush the queue and render once + application.SendNotification(); + application.Render(); + + // Check the width in the new frame + DALI_TEST_EQUALS( vector.width, actor.GetCurrentSize().width, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.height, actor.GetCurrentSize().height, TEST_LOCATION ); + + END_TEST; +} + int UtcDaliActorGetCurrentSize(void) { @@ -1040,7 +1256,7 @@ int UtcDaliActorGetCurrentSizeImmediate(void) const Vector3 targetValue( 10.0f, 20.0f, 30.0f ); animation.AnimateTo( Property( actor, Actor::Property::SIZE ), targetValue ); - DALI_TEST_CHECK( actor.GetTargetSize() == targetValue ); + DALI_TEST_CHECK( actor.GetTargetSize() == vector ); // Start the animation animation.Play(); @@ -1053,6 +1269,29 @@ int UtcDaliActorGetCurrentSizeImmediate(void) 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) { @@ -1216,28 +1455,46 @@ int UtcDaliActorSetPositionProperties(void) DALI_TEST_CHECK(vector != actor.GetCurrentPosition()); actor.SetProperty( Actor::Property::POSITION_X, vector.x ); + DALI_TEST_EQUALS( vector.x, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION ); // flush the queue and render once application.SendNotification(); application.Render(); DALI_TEST_EQUALS( vector.x, actor.GetCurrentPosition().x, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.x, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION ); actor.SetProperty( Actor::Property::POSITION_Y, vector.y ); + DALI_TEST_EQUALS( vector.y, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION ); // flush the queue and render once application.SendNotification(); application.Render(); DALI_TEST_EQUALS( vector.y, actor.GetCurrentPosition().y, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.y, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION ); actor.SetProperty( Actor::Property::POSITION_Z, vector.z ); + DALI_TEST_EQUALS( vector.z, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION ); // flush the queue and render once application.SendNotification(); application.Render(); DALI_TEST_EQUALS( vector.z, actor.GetCurrentPosition().z, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.z, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION ); END_TEST; } @@ -1319,55 +1576,6 @@ int UtcDaliActorGetCurrentWorldPosition(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"); @@ -1426,6 +1634,41 @@ int UtcDaliActorSetInheritPosition(void) 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(), 1.0f, 0.0001f, TEST_LOCATION ); + DALI_TEST_EQUALS( child.GetProperty( Actor::Property::COLOR_ALPHA ).Get(), 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(), 0.1f, 0.0001f, TEST_LOCATION ); + DALI_TEST_EQUALS( child.GetProperty( Actor::Property::COLOR_ALPHA ).Get(), 1.0f, 0.0001f, TEST_LOCATION ); + + application.SendNotification(); + application.Render(); + + DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::WORLD_COLOR ).Get(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION ); + DALI_TEST_EQUALS( parent.GetCurrentProperty( Actor::Property::COLOR_ALPHA ).Get(), 0.1f, 0.0001f, TEST_LOCATION ); + DALI_TEST_EQUALS( parent.GetCurrentProperty( Actor::Property::WORLD_COLOR ).Get(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION ); + DALI_TEST_EQUALS( child.GetProperty( Actor::Property::WORLD_COLOR ).Get(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION ); + DALI_TEST_EQUALS( child.GetCurrentProperty( Actor::Property::WORLD_COLOR ).Get(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION ); + DALI_TEST_EQUALS( child.GetCurrentProperty( Actor::Property::COLOR_ALPHA ).Get(), 1.f, 0.0001f, TEST_LOCATION ); + + END_TEST; +} + // SetOrientation(float angleRadians, Vector3 axis) int UtcDaliActorSetOrientation01(void) { @@ -1490,12 +1733,15 @@ int UtcDaliActorSetOrientationProperty(void) Actor actor = Actor::New(); actor.SetProperty( Actor::Property::ORIENTATION, rotation ); + DALI_TEST_EQUALS(rotation, actor.GetProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION); // flush the queue and render once application.SendNotification(); application.Render(); DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION); + DALI_TEST_EQUALS(rotation, actor.GetProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION); + DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION); END_TEST; } @@ -1691,28 +1937,40 @@ int UtcDaliActorSetScaleIndividual(void) DALI_TEST_CHECK(vector != actor.GetCurrentScale()); actor.SetProperty( Actor::Property::SCALE_X, vector.x ); + DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION ); // flush the queue and render once application.SendNotification(); application.Render(); DALI_TEST_EQUALS( vector.x, actor.GetCurrentScale().x, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION ); actor.SetProperty( Actor::Property::SCALE_Y, vector.y ); + DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION ); // flush the queue and render once application.SendNotification(); application.Render(); DALI_TEST_EQUALS( vector.y, actor.GetCurrentScale().y, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION ); actor.SetProperty( Actor::Property::SCALE_Z, vector.z ); + DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION ); // flush the queue and render once application.SendNotification(); application.Render(); DALI_TEST_EQUALS( vector.z, actor.GetCurrentScale().z, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION ); + + DALI_TEST_EQUALS( vector, actor.GetProperty< Vector3 >( Actor::Property::SCALE ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector, actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), TEST_LOCATION ); END_TEST; } @@ -1991,39 +2249,56 @@ int UtcDaliActorSetColorIndividual(void) DALI_TEST_CHECK(vector != actor.GetCurrentColor()); actor.SetProperty( Actor::Property::COLOR_RED, vector.r ); + DALI_TEST_EQUALS( vector.r, actor.GetProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION ); // flush the queue and render once application.SendNotification(); application.Render(); DALI_TEST_EQUALS( vector.r, actor.GetCurrentColor().r, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.r, actor.GetProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.r, actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION ); actor.SetProperty( Actor::Property::COLOR_GREEN, vector.g ); + DALI_TEST_EQUALS( vector.g, actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION ); // flush the queue and render once application.SendNotification(); application.Render(); DALI_TEST_EQUALS( vector.g, actor.GetCurrentColor().g, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.g, actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.g, actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION ); actor.SetProperty( Actor::Property::COLOR_BLUE, vector.b ); + DALI_TEST_EQUALS( vector.b, actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION ); // flush the queue and render once application.SendNotification(); application.Render(); DALI_TEST_EQUALS( vector.b, actor.GetCurrentColor().b, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.b, actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.b, actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION ); + actor.SetProperty( Actor::Property::COLOR_ALPHA, vector.a ); + DALI_TEST_EQUALS( vector.a, actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION ); // flush the queue and render once application.SendNotification(); application.Render(); DALI_TEST_EQUALS( vector.a, actor.GetCurrentColor().a, TEST_LOCATION ); + DALI_TEST_EQUALS( vector.a, actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector.a, actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION ); + + DALI_TEST_EQUALS( vector, actor.GetProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION ); + DALI_TEST_EQUALS( vector, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION ); actor.SetProperty( DevelActor::Property::OPACITY, 0.2f ); + // flush the queue and render once application.SendNotification(); application.Render(); @@ -2336,9 +2611,9 @@ int UtcDaliActorTouchedSignal(void) point.SetDeviceId( 1 ); point.SetState( PointState::DOWN ); point.SetScreenPosition( Vector2( touchPoint.x, touchPoint.y ) ); - Dali::Integration::TouchEvent event; - event.AddPoint( point ); - application.ProcessEvent( event ); + Dali::Integration::TouchEvent touchEvent; + touchEvent.AddPoint( point ); + application.ProcessEvent( touchEvent ); DALI_TEST_CHECK( gTouchCallBackCalled == true ); END_TEST; @@ -2366,9 +2641,9 @@ int UtcDaliActorHoveredSignal(void) point.SetDeviceId( 1 ); point.SetState( PointState::MOTION ); point.SetScreenPosition( Vector2( touchPoint.x, touchPoint.y ) ); - Dali::Integration::HoverEvent event; - event.AddPoint( point ); - application.ProcessEvent( event ); + Dali::Integration::HoverEvent hoverEvent; + hoverEvent.AddPoint( point ); + application.ProcessEvent( hoverEvent ); DALI_TEST_CHECK( gHoverCallBackCalled == true ); END_TEST; @@ -2996,7 +3271,6 @@ const PropertyStringIndex PROPERTY_TABLE[] = { "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 }, @@ -3515,31 +3789,6 @@ int UtcDaliActorColorModePropertyAsString(void) 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; @@ -3552,12 +3801,9 @@ int UtcDaliActorDrawModePropertyAsString(void) 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; } @@ -3583,27 +3829,6 @@ int UtcDaliActorColorModePropertyAsEnum(void) 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; @@ -3616,9 +3841,6 @@ int UtcDaliActorDrawModePropertyAsEnum(void) 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; } @@ -3712,17 +3934,33 @@ int UtcDaliActorRemoveRendererP1(void) DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION ); - Geometry geometry = CreateQuadGeometry(); - Shader shader = CreateShader(); - Renderer renderer = Renderer::New(geometry, shader); + { + Geometry geometry = CreateQuadGeometry(); + Shader shader = CreateShader(); + Renderer renderer = Renderer::New(geometry, shader); - actor.AddRenderer( renderer ); - DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION ); - DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION ); + actor.AddRenderer( renderer ); + DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION ); + DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION ); - actor.RemoveRenderer(renderer); - DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION ); + application.SendNotification(); + application.Render(); + } + + { + Renderer renderer = actor.GetRendererAt(0); + actor.RemoveRenderer(renderer); + DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION ); + application.SendNotification(); + application.Render(); + } + + // Call one final time to ensure that the renderer is actually removed after + // the handle goes out of scope, and excercises the deletion code path in + // scene graph and render. + application.SendNotification(); + application.Render(); END_TEST; } @@ -3741,13 +3979,19 @@ int UtcDaliActorRemoveRendererP2(void) Renderer renderer = Renderer::New(geometry, shader); actor.AddRenderer( renderer ); - DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION ); - DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION ); + application.SendNotification(); + application.Render(); + + DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION ); + DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION ); actor.RemoveRenderer(0); - DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION ); + application.SendNotification(); + application.Render(); + DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION ); + // Shut down whilst holding onto the renderer handle. END_TEST; } @@ -3777,20 +4021,25 @@ int UtcDaliActorRemoveRendererN(void) } // 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(); @@ -3818,7 +4067,7 @@ void CheckColorMask( TestGlAbstraction& glAbstraction, bool maskValue ) 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(); @@ -3835,7 +4084,7 @@ int UtcDaliActorPropertyClippingP(void) DALI_TEST_EQUALS( 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. @@ -3848,13 +4097,25 @@ int UtcDaliActorPropertyClippingP(void) DALI_TEST_EQUALS( 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( 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(); @@ -3889,7 +4150,7 @@ int UtcDaliActorPropertyClippingN(void) 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(); @@ -3898,7 +4159,7 @@ int UtcDaliActorPropertyClippingActor(void) 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 ); @@ -3925,7 +4186,7 @@ int UtcDaliActorPropertyClippingActor(void) 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(); @@ -3934,7 +4195,7 @@ int UtcDaliActorPropertyClippingActorEnableThenDisable(void) 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 ); @@ -3971,36 +4232,35 @@ int UtcDaliActorPropertyClippingActorEnableThenDisable(void) 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. @@ -4050,6 +4310,369 @@ int UtcDaliActorPropertyClippingNestedChildren(void) END_TEST; } +int UtcDaliActorPropertyClippingActorDrawOrder(void) +{ + // 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& enabledDisableTrace = glAbstraction.GetEnableDisableTrace(); + + /* We create a small tree of actors as follows: + + A + / \ + Clipping enabled -> B D + | | + C E + + 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 ); + + // Setup dimensions and position so actor is not skipped by culling. + actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS ); + actor.SetSize( 16.0f, 16.0f ); + + 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 ) ); + } + + actors[i] = actor; + } + + // Enable clipping on the actor at the top of the left branch. + actors[1].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN ); + + // Build the scene graph. + Stage::GetCurrent().Add( actors[0] ); + + // Left branch: + actors[0].Add( actors[1] ); + actors[1].Add( actors[2] ); + + // Right branch: + actors[0].Add( actors[3] ); + actors[3].Add( actors[4] ); + + // Gather the call trace. + enabledDisableTrace.Reset(); + enabledDisableTrace.Enable( true ); + application.SendNotification(); + application.Render(); + enabledDisableTrace.Enable( false ); + + /* Check stencil is enabled and disabled again (as right-hand branch of tree is drawn). + + 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 ) ); + + // 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 ); + + // Gather the call trace. + enabledDisableTrace.Reset(); + enabledDisableTrace.Enable( true ); + application.SendNotification(); + application.Render(); + enabledDisableTrace.Enable( false ); + + // 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 ) ); + + 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. @@ -4061,7 +4684,7 @@ int UtcDaliActorPropertyClippingActorWithRendererOverride(void) 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 ); @@ -4082,6 +4705,19 @@ int UtcDaliActorPropertyClippingActorWithRendererOverride(void) 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; } @@ -4146,14 +4782,20 @@ int UtcDaliActorRaiseLower(void) 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 ); point.SetScreenPosition( Vector2( 10.f, 10.f ) ); - Dali::Integration::TouchEvent event; - event.AddPoint( point ); + Dali::Integration::TouchEvent touchEvent; + touchEvent.AddPoint( point ); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION ); DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION ); @@ -4169,14 +4811,20 @@ int UtcDaliActorRaiseLower(void) 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( postActorOrder ); tet_printf( "Raised ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder ); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION ); DALI_TEST_EQUALS( gTouchCallBackCalled2, true , TEST_LOCATION ); @@ -4189,14 +4837,21 @@ int UtcDaliActorRaiseLower(void) 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 ); value.Get( postActorOrder ); tet_printf( "Lowered ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder ); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION ); DALI_TEST_EQUALS( gTouchCallBackCalled2, false , TEST_LOCATION ); @@ -4266,6 +4921,12 @@ int UtcDaliActorRaiseToTopLowerToBottom(void) 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); @@ -4302,10 +4963,10 @@ int UtcDaliActorRaiseToTopLowerToBottom(void) point.SetDeviceId( 1 ); point.SetState( PointState::DOWN ); point.SetScreenPosition( Vector2( 10.f, 10.f ) ); - Dali::Integration::TouchEvent event; - event.AddPoint( point ); + Dali::Integration::TouchEvent touchEvent; + touchEvent.AddPoint( point ); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION ); DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION ); @@ -4315,9 +4976,14 @@ int UtcDaliActorRaiseToTopLowerToBottom(void) 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( event ); + application.ProcessEvent( touchEvent ); glAbstraction.ResetSetUniformCallStack(); glSetUniformStack = glAbstraction.GetSetUniformTrace(); @@ -4345,9 +5011,16 @@ int UtcDaliActorRaiseToTopLowerToBottom(void) tet_printf( "RaiseToTop ActorB\n" ); - DevelActor::RaiseToTop( actorB ); + orderChangedSignal = false; - application.ProcessEvent( event ); + 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 ); glAbstraction.ResetSetUniformCallStack(); glSetUniformStack = glAbstraction.GetSetUniformTrace(); @@ -4375,15 +5048,27 @@ int UtcDaliActorRaiseToTopLowerToBottom(void) 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(); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); glAbstraction.ResetSetUniformCallStack(); glSetUniformStack = glAbstraction.GetSetUniformTrace(); @@ -4461,14 +5146,19 @@ int UtcDaliActorRaiseAbove(void) 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 ); point.SetScreenPosition( Vector2( 10.f, 10.f ) ); - Dali::Integration::TouchEvent event; - event.AddPoint( point ); + Dali::Integration::TouchEvent touchEvent; + touchEvent.AddPoint( point ); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION ); DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION ); @@ -4478,9 +5168,14 @@ int UtcDaliActorRaiseAbove(void) 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 ); - application.ProcessEvent( event ); + // Ensure sorting happens at end of Core::ProcessEvents() before next touch + application.SendNotification(); + application.ProcessEvent( touchEvent ); DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION ); DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION ); @@ -4490,9 +5185,17 @@ int UtcDaliActorRaiseAbove(void) tet_printf( "Raise actor A Above Actor B\n" ); - DevelActor::RaiseAbove( actorA, actorB ); + orderChangedSignal = false; - application.ProcessEvent( event ); + 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(); + + application.ProcessEvent( touchEvent ); // process a touch event on ordered actors. DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION ); DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION ); @@ -4556,12 +5259,23 @@ int UtcDaliActorLowerBelow(void) 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); @@ -4601,12 +5315,12 @@ int UtcDaliActorLowerBelow(void) point.SetDeviceId( 1 ); point.SetState( PointState::DOWN ); point.SetScreenPosition( Vector2( 10.f, 10.f ) ); - Dali::Integration::TouchEvent event; - event.AddPoint( point ); + Dali::Integration::TouchEvent touchEvent; + touchEvent.AddPoint( point ); tet_infoline( "UtcDaliActor Test Set up completed \n" ); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION ); DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION ); @@ -4616,12 +5330,16 @@ int UtcDaliActorLowerBelow(void) 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(); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); // touch event glAbstraction.ResetSetUniformCallStack(); glSetUniformStack = glAbstraction.GetSetUniformTrace(); @@ -4636,10 +5354,9 @@ int UtcDaliActorLowerBelow(void) 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 ); @@ -4647,14 +5364,20 @@ int UtcDaliActorLowerBelow(void) 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" ); - DevelActor::LowerBelow( actorB, actorC ); + 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 ); + + // Ensure sorting happens at end of Core::ProcessEvents() before next touch application.SendNotification(); application.Render(); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); glAbstraction.ResetSetUniformCallStack(); glSetUniformStack = glAbstraction.GetSetUniformTrace(); @@ -4667,24 +5390,29 @@ int UtcDaliActorLowerBelow(void) 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; - DevelActor::LowerBelow( actorA, actorC ); + DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION ); + actorB.LowerBelow( 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.Render(); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); glAbstraction.ResetSetUniformCallStack(); glSetUniformStack = glAbstraction.GetSetUniformTrace(); @@ -4697,70 +5425,14 @@ int UtcDaliActorLowerBelow(void) 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 ); - - 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" ); @@ -4814,6 +5486,12 @@ int UtcDaliActorRaiseAboveLowerBelowDifferentParentsN(void) ResetTouchCallbacks(); + // Connect ChildOrderChangedSignal + bool orderChangedSignal( false ); + Actor orderChangedActor; + ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor ); + DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ; + application.SendNotification(); application.Render(); @@ -4831,10 +5509,10 @@ int UtcDaliActorRaiseAboveLowerBelowDifferentParentsN(void) point.SetDeviceId( 1 ); point.SetState( PointState::DOWN ); point.SetScreenPosition( Vector2( 10.f, 10.f ) ); - Dali::Integration::TouchEvent event; - event.AddPoint( point ); + Dali::Integration::TouchEvent touchEvent; + touchEvent.AddPoint( point ); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION ); DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION ); @@ -4844,9 +5522,14 @@ int UtcDaliActorRaiseAboveLowerBelowDifferentParentsN(void) 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(); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); // touch event DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION ); DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION ); @@ -4889,6 +5572,12 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void) ResetTouchCallbacks(); + // Connect ChildOrderChangedSignal + bool orderChangedSignal( false ); + Actor orderChangedActor; + ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor ); + DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ; + application.SendNotification(); application.Render(); @@ -4906,14 +5595,19 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void) point.SetDeviceId( 1 ); point.SetState( PointState::DOWN ); point.SetScreenPosition( Vector2( 10.f, 10.f ) ); - Dali::Integration::TouchEvent event; - event.AddPoint( point ); + Dali::Integration::TouchEvent touchEvent; + touchEvent.AddPoint( point ); 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 ); - application.ProcessEvent( event ); + // Ensure sorting happens at end of Core::ProcessEvents() before next touch + application.SendNotification(); + + application.ProcessEvent( touchEvent ); tet_printf( "Not parented so RaiseAbove should show no effect\n" ); @@ -4923,14 +5617,20 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void) ResetTouchCallbacks(); + orderChangedSignal = false; + stage.Add ( actorB ); + tet_printf( "Lower actor A below Actor C when only A is not on stage \n" ); + 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(); application.Render(); - tet_printf( "Lower actor A below Actor C when only A is not on stage \n" ); - DevelActor::LowerBelow( actorA, actorC ); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); tet_printf( "Actor A not parented so LowerBelow should show no effect\n" ); DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION ); @@ -4939,6 +5639,8 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void) ResetTouchCallbacks(); + orderChangedSignal = false; + tet_printf( "Adding Actor A to stage, will be on top\n" ); stage.Add ( actorA ); @@ -4946,8 +5648,15 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void) application.Render(); tet_printf( "Raise actor B Above Actor C when only B has a parent\n" ); - DevelActor::RaiseAbove( actorB, actorC ); - application.ProcessEvent( event ); + + 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(); + + application.ProcessEvent( touchEvent ); tet_printf( "C not parented so RaiseAbove should show no effect\n" ); DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION ); @@ -4956,9 +5665,18 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void) ResetTouchCallbacks(); + orderChangedSignal = false; + tet_printf( "Lower actor A below Actor C when only A has a parent\n" ); - DevelActor::LowerBelow( actorA, actorC ); - application.ProcessEvent( event ); + + 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(); + + application.ProcessEvent( touchEvent ); tet_printf( "C not parented so LowerBelow should show no effect\n" ); DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION ); @@ -4967,13 +5685,20 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void) ResetTouchCallbacks(); + orderChangedSignal = false; + stage.Add ( 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(); - DevelActor::RaiseAbove( actorA, actorC ); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); tet_printf( "Raise actor A Above Actor C, now both have same parent \n" ); DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION ); @@ -5015,6 +5740,12 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void) 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 ); @@ -5025,19 +5756,20 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void) point.SetDeviceId( 1 ); point.SetState( PointState::DOWN ); point.SetScreenPosition( Vector2( 10.f, 10.f ) ); - Dali::Integration::TouchEvent event; - event.AddPoint( point ); + Dali::Integration::TouchEvent touchEvent; + touchEvent.AddPoint( point ); stage.Add ( actorA ); + tet_printf( "Raise actor B Above Actor C but B not parented\n" ); + + 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" ); - - DevelActor::Raise( actorB ); - - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); tet_printf( "Not parented so RaiseAbove should show no effect\n" ); @@ -5048,9 +5780,17 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void) tet_printf( "Raise actor B Above Actor C but B not parented\n" ); ResetTouchCallbacks(); - DevelActor::Lower( actorC ); + orderChangedSignal = false; - application.ProcessEvent( event ); + 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(); + + application.ProcessEvent( touchEvent ); tet_printf( "Not parented so RaiseAbove should show no effect\n" ); @@ -5059,11 +5799,19 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void) 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 ); - application.ProcessEvent( event ); + // Sort actor tree before next touch event + application.SendNotification(); + application.Render(); + + application.ProcessEvent( touchEvent ); tet_printf( "Not parented so Lower should show no effect\n" ); @@ -5072,11 +5820,19 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void) 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(); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); tet_printf( "Not parented so RaiseToTop should show no effect\n" ); @@ -5085,18 +5841,22 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void) 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 ); - application.SendNotification(); - application.Render(); - 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(); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); tet_printf( "Not parented so LowerToBottom should show no effect\n" ); @@ -5151,6 +5911,12 @@ int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void) ResetTouchCallbacks(); + // Connect ChildOrderChangedSignal + bool orderChangedSignal( false ); + Actor orderChangedActor; + ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor ); + DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ; + application.SendNotification(); application.Render(); @@ -5158,10 +5924,10 @@ int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void) point.SetDeviceId( 1 ); point.SetState( PointState::DOWN ); point.SetScreenPosition( Vector2( 10.f, 10.f ) ); - Dali::Integration::TouchEvent event; - event.AddPoint( point ); + Dali::Integration::TouchEvent touchEvent; + touchEvent.AddPoint( point ); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION ); DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION ); @@ -5171,9 +5937,15 @@ int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void) 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(); - application.ProcessEvent( event ); + application.ProcessEvent( touchEvent ); tet_infoline( "No target is source Actor so RaiseAbove should show no effect\n" ); @@ -5183,8 +5955,17 @@ int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void) ResetTouchCallbacks(); - DevelActor::RaiseAbove( actorA, actorC ); - application.ProcessEvent( event ); + 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(); + + application.ProcessEvent( touchEvent ); tet_infoline( "Raise actor A Above Actor C which will now be successful \n" ); DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION ); @@ -5290,6 +6071,26 @@ int UtcDaliActorGetScreenPosition(void) 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; } @@ -5488,7 +6289,7 @@ int UtcDaliActorGetScreenPositionWithChildActors02(void) parentActorA.SetSize( size2 ); parentActorA.SetPosition( 0.f, 0.f ); - tet_infoline( "Create Grand Parent Actor 1 TOP_RIGHT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" ); + tet_infoline( "Create Grand Parent Actor 1 BOTTOM_LEFT Anchor Point, ParentOrigin::BOTTOM_LEFT and 0,0 position \n" ); Actor grandParentActorA = Actor::New(); grandParentActorA.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT ); @@ -5521,6 +6322,70 @@ int UtcDaliActorGetScreenPositionWithChildActors02(void) END_TEST; } +int UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse(void) +{ + tet_infoline( "UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse Check screen position where the position does not use the anchor point" ); + + TestApplication application; + + Stage stage( Stage::GetCurrent() ); + + tet_infoline( "Create an actor with AnchorPoint::TOP_LEFT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" ); + + Actor actorA = Actor::New(); + actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT ); + actorA.SetParentOrigin( ParentOrigin::CENTER ); + actorA.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false ); + actorA.SetSize( 10.0f, 20.0f ); + stage.Add( actorA ); + + tet_infoline( "Create an Actor with AnchorPoint::BOTTOM_RIGHT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" ); + + Actor actorB = Actor::New(); + actorB.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT ); + actorB.SetParentOrigin( ParentOrigin::CENTER ); + actorB.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false ); + Vector2 actorBSize( 30.0f, 60.0f ); + actorB.SetSize( actorBSize ); + stage.Add( actorB ); + + tet_infoline( "Create an actor with AnchorPoint::CENTER, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" ); + + Actor actorC = Actor::New(); + actorC.SetAnchorPoint( AnchorPoint::CENTER ); + actorC.SetParentOrigin( ParentOrigin::CENTER ); + actorC.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false ); + Vector2 actorCSize( 60.0f, 120.0f ); + actorC.SetSize( actorCSize ); + stage.Add( actorC ); + + application.SendNotification(); + application.Render(); + + tet_infoline( "Despite differing sizes and anchor-points, the screen position for all actors is the same"); + + Vector2 center( stage.GetSize() * 0.5f ); + + DALI_TEST_EQUALS( actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION ); + DALI_TEST_EQUALS( actorB.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION ); + DALI_TEST_EQUALS( actorC.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION ); + + tet_infoline( "Add scale to all actors" ); + + actorA.SetScale( 2.0f ); + actorB.SetScale( 2.0f ); + actorC.SetScale( 2.0f ); + + application.SendNotification(); + application.Render(); + + DALI_TEST_EQUALS( actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center /* TOP_LEFT Anchor */, TEST_LOCATION ); + DALI_TEST_EQUALS( actorB.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center - actorBSize /* BOTTOM_RIGHT Anchor */, TEST_LOCATION ); + DALI_TEST_EQUALS( actorC.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center - actorCSize * 0.5f /* CENTER Anchor*/, TEST_LOCATION ); + + END_TEST; +} + int utcDaliActorPositionUsesAnchorPoint(void) { TestApplication application; @@ -5695,3 +6560,692 @@ int utcDaliActorPositionUsesAnchorPointOnlyInheritPosition(void) END_TEST; } +int utcDaliActorVisibilityChangeSignalSelf(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(); + + VisibilityChangedFunctorData data; + DevelActor::VisibilityChangedSignal( actor ).Connect( &application, VisibilityChangedFunctor( data ) ); + + actor.SetVisible( false ); + + data.Check( true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION ); + + tet_infoline( "Ensure functor is not called if we attempt to change the visibility to what it already is at" ); + data.Reset(); + + actor.SetVisible( false ); + data.Check( false /* not called */, TEST_LOCATION ); + + tet_infoline( "Change the visibility using properties, ensure called" ); + data.Reset(); + + actor.SetProperty( Actor::Property::VISIBLE, true ); + data.Check( true /* called */, actor, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION ); + + tet_infoline( "Set the visibility to current using properties, ensure not called" ); + data.Reset(); + + actor.SetProperty( Actor::Property::VISIBLE, true ); + data.Check( false /* not called */, TEST_LOCATION ); + + END_TEST; +} + +int utcDaliActorVisibilityChangeSignalChildren(void) +{ + TestApplication application; + tet_infoline( "Check that the visibility change signal is called for the children when the visibility changes for the parent" ); + + Actor parent = Actor::New(); + Actor child = Actor::New(); + parent.Add( child ); + + Actor grandChild = Actor::New(); + child.Add( grandChild ); + + VisibilityChangedFunctorData parentData; + VisibilityChangedFunctorData childData; + VisibilityChangedFunctorData grandChildData; + + tet_infoline( "Only connect the child and grandchild, ensure they are called and not the parent" ); + DevelActor::VisibilityChangedSignal( child ).Connect( &application, VisibilityChangedFunctor( childData ) ); + DevelActor::VisibilityChangedSignal( grandChild ).Connect( &application, VisibilityChangedFunctor( grandChildData ) ); + + parent.SetVisible( false ); + parentData.Check( false /* not called */, TEST_LOCATION ); + childData.Check( true /* called */, child, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION ); + grandChildData.Check( true /* called */, grandChild, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION ); + + tet_infoline( "Connect to the parent's signal as well and ensure all three are called" ); + parentData.Reset(); + childData.Reset(); + grandChildData.Reset(); + + DevelActor::VisibilityChangedSignal( parent ).Connect( &application, VisibilityChangedFunctor( parentData ) ); + + parent.SetVisible( true ); + parentData.Check( true /* called */, parent, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION ); + childData.Check( true /* called */, child, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION ); + grandChildData.Check( true /* called */, grandChild, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION ); + + tet_infoline( "Ensure none of the functors are called if we attempt to change the visibility to what it already is at" ); + parentData.Reset(); + childData.Reset(); + grandChildData.Reset(); + + parent.SetVisible( true ); + parentData.Check( false /* not called */, TEST_LOCATION ); + childData.Check( false /* not called */, TEST_LOCATION ); + grandChildData.Check( false /* not called */, TEST_LOCATION ); + + END_TEST; +} + +int utcDaliActorVisibilityChangeSignalAfterAnimation(void) +{ + TestApplication application; + tet_infoline( "Check that the visibility change signal is emitted when the visibility changes when an animation starts" ); + + Actor actor = Actor::New(); + Stage::GetCurrent().Add( actor ); + + application.SendNotification(); + application.Render(); + + VisibilityChangedFunctorData data; + DevelActor::VisibilityChangedSignal( actor ).Connect( &application, VisibilityChangedFunctor( data ) ); + + Animation animation = Animation::New( 1.0f ); + animation.AnimateTo( Property( actor, Actor::Property::VISIBLE ), false ); + + data.Check( false, TEST_LOCATION ); + DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION ); + DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION ); + + tet_infoline( "Play the animation and check the property value" ); + animation.Play(); + + data.Check( true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION ); + DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION ); + + tet_infoline( "Animation not currently finished, so the current visibility should still be true" ); + DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION ); + + application.SendNotification(); + application.Render( 1100 ); // After the animation + + DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION ); + + 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 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; +}