/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/public-api/dali-core.h>
#include <string>
#include <cfloat> // For FLT_MAX
+#include <dali/devel-api/actors/actor-devel.h>
+#include <dali/devel-api/object/handle-devel.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/events/hover-event-integ.h>
#include <dali-test-suite-utils.h>
+#include <mesh-builder.h>
//& set: DaliActor
namespace
{
bool gTouchCallBackCalled=false;
-bool gHoverCallBackCalled=false;
-
-/**
- * Simulates a Down Touch at 25.0, 25.0.
- * @param[in] app Test Application instance.
- */
-int SimulateTouchForSetOverlayHitTest(TestApplication& app)
-{
- app.SendNotification();
- app.Render(1);
- app.SendNotification();
- app.Render(1);
-
- gTouchCallBackCalled = false;
-
- // simulate a touch event
- Dali::TouchPoint point( 0, TouchPoint::Down, 25.0f, 25.0f );
- Dali::Integration::TouchEvent event;
- event.AddPoint( point );
- app.ProcessEvent( event );
-
- app.SendNotification();
- app.Render(1);
- app.SendNotification();
- app.Render(1);
- END_TEST;
-}
+bool gTouchCallBackCalled2=false;
+bool gTouchCallBackCalled3=false;
+bool gHoverCallBackCalled=false;
static bool gTestConstraintCalled;
END_TEST;
}
+static bool TestTouchCallback(Actor actor, const TouchData& touchData )
+{
+ gTouchCallBackCalled = true;
+ return true;
+ END_TEST;
+}
+
+static bool TestTouchCallback2(Actor actor, const TouchData& touchData )
+{
+ gTouchCallBackCalled2 = true;
+ return true;
+ END_TEST;
+}
+
+static bool TestTouchCallback3(Actor actor, const TouchData& touchData )
+{
+ gTouchCallBackCalled3 = true;
+ return true;
+ END_TEST;
+}
+
+static void ResetTouchCallbacks()
+{
+ gTouchCallBackCalled = false;
+ gTouchCallBackCalled2 = false;
+ gTouchCallBackCalled3 = false;
+}
+
static bool TestCallback3(Actor actor, const HoverEvent& event)
{
gHoverCallBackCalled = true;
END_TEST;
}
-static Vector3 gSetSize;
-static bool gSetSizeCallBackCalled;
-void SetSizeCallback( Actor actor, const Vector3& size )
-{
- gSetSizeCallBackCalled = true;
- gSetSize = size;
-}
// validation stuff for onstage & offstage signals
static std::vector< std::string > gActorNamesOnOffStage;
static int gOnStageCallBackCalled;
}
};
+struct OrientationComponentConstraint
+{
+ OrientationComponentConstraint(){}
+
+ void operator()( Quaternion& orientation, const PropertyInputContainer& inputs )
+ {
+ const Quaternion& parentOrientation = inputs[0]->GetQuaternion();
+ Vector3 pos, scale;
+ Quaternion rot;
+ orientation = parentOrientation;
+ }
+};
// OnRelayout
static bool gOnRelayoutCallBackCalled = false;
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;
+};
+
} // anonymous namespace
END_TEST;
}
+int UtcDaliActorSetParentOriginIndividual(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ Vector3 vector(0.7f, 0.8f, 0.9f);
+ DALI_TEST_CHECK(vector != actor.GetCurrentParentOrigin());
+
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN_X, vector.x );
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( vector.x, actor.GetCurrentParentOrigin().x, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN_Y, vector.y );
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( vector.y, actor.GetCurrentParentOrigin().y, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN_Z, vector.z );
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( vector.z, actor.GetCurrentParentOrigin().z, TEST_LOCATION );
+
+ END_TEST;
+}
+
int UtcDaliActorGetCurrentParentOrigin(void)
{
TestApplication application;
END_TEST;
}
+int UtcDaliActorSetAnchorPointIndividual(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ Vector3 vector(0.7f, 0.8f, 0.9f);
+ DALI_TEST_CHECK(vector != actor.GetCurrentAnchorPoint());
+
+ actor.SetProperty( Actor::Property::ANCHOR_POINT_X, vector.x );
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( vector.x, actor.GetCurrentAnchorPoint().x, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::ANCHOR_POINT_Y, vector.y );
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( vector.y, actor.GetCurrentAnchorPoint().y, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::ANCHOR_POINT_Z, vector.z );
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( vector.z, actor.GetCurrentAnchorPoint().z, TEST_LOCATION );
+
+ END_TEST;
+}
+
int UtcDaliActorGetCurrentAnchorPoint(void)
{
TestApplication application;
actor.SetSize(vector.x, vector.y);
- // flush the queue and render once
+ // 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();
application.Render();
+ // Check the size in the new frame
DALI_TEST_CHECK(vector == actor.GetCurrentSize());
+
+ 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 = DevelHandle::GetCurrentProperty( actor, Actor::Property::SIZE ).Get< Vector3 >();
+ DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ DALI_TEST_EQUALS( vector.width, DevelHandle::GetCurrentProperty< float >( actor, Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+ DALI_TEST_EQUALS( vector.height, DevelHandle::GetCurrentProperty< float >( actor, Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( vector.depth, DevelHandle::GetCurrentProperty< float >( actor, 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 );
+
+ currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+ DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ // Set a new size after resize policy is changed and check the new size
+ actor.SetSize( Vector3( 0.1f, 0.2f, 0.0f ) );
+
+ currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+ DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ // Change the resize policy again and check whether the new size stays the same
+ actor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
+
+ currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+ DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ // Set another new size after resize policy is changed and check the new size
+ actor.SetSize( Vector3( 50.0f, 60.0f, 0.0f ) );
+
+ currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+ DALI_TEST_EQUALS( currentSize, Vector3( 50.0f, 60.0f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
END_TEST;
}
actor.SetSize(vector.x, vector.y, vector.z);
+ // Immediately check the size after setting
+ Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+ DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
// flush the queue and render once
application.SendNotification();
application.Render();
+ // Check the size in the new frame
DALI_TEST_CHECK(vector == actor.GetCurrentSize());
+
+ currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+ DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
END_TEST;
}
actor.SetSize(Vector2(vector.x, vector.y));
+ // Immediately check the size after setting
+ Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+ DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
// flush the queue and render once
application.SendNotification();
application.Render();
+ // Check the size in the new frame
DALI_TEST_CHECK(vector == actor.GetCurrentSize());
+
+ currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+ DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
END_TEST;
}
actor.SetSize(vector);
+ // Immediately check the size after setting
+ Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+ DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
// flush the queue and render once
application.SendNotification();
application.Render();
+ // Check the size in the new frame
DALI_TEST_CHECK(vector == actor.GetCurrentSize());
Stage::GetCurrent().Add( actor );
actor.SetSize( Vector3( 0.1f, 0.2f, 0.3f ) );
+ // Immediately check the size after setting
+ currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+ DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.3f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
// flush the queue and render once
application.SendNotification();
application.Render();
+ // Check the size in the new frame
DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentSize(), TEST_LOCATION );
+
+ currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+ DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.3f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
Stage::GetCurrent().Remove( actor );
END_TEST;
}
+int UtcDaliActorSetSizeIndividual(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ Vector3 vector(0.7f, 0.8f, 0.9f);
+ DALI_TEST_CHECK(vector != actor.GetCurrentSize());
+
+ actor.SetProperty( Actor::Property::SIZE_WIDTH, vector.width );
+
+ // Immediately check the width after setting
+ float sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
+ DALI_TEST_EQUALS( sizeWidth, vector.width, 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 );
+
+ sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
+ DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::SIZE_HEIGHT, vector.height );
+
+ // Immediately check the height after setting
+ float sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
+ DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ // Check the height in the new frame
+ DALI_TEST_EQUALS( vector.height, actor.GetCurrentSize().height, TEST_LOCATION );
+
+ sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
+ DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::SIZE_DEPTH, vector.depth );
+
+ // Immediately check the depth after setting
+ float sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
+ DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ // Check the depth in the new frame
+ DALI_TEST_EQUALS( vector.depth, actor.GetCurrentSize().depth, TEST_LOCATION );
+
+ sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
+ DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ // Change the resize policy and check whether the size stays the same
+ actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
+
+ sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
+ DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
+ DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
+ DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ // Change the resize policy again and check whether the size stays the same
+ actor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
+
+ sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
+ DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
+ DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
+ DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ 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)
{
TestApplication application;
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();
END_TEST;
}
+int UtcDaliActorSetPositionProperties(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ Vector3 vector(0.7f, 0.8f, 0.9f);
+ 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, DevelHandle::GetCurrentProperty< Vector3 >( actor, Actor::Property::POSITION ).x, TEST_LOCATION );
+ DALI_TEST_EQUALS( vector.x, DevelHandle::GetCurrentProperty< float >( actor, 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, DevelHandle::GetCurrentProperty< Vector3 >( actor, Actor::Property::POSITION ).y, TEST_LOCATION );
+ DALI_TEST_EQUALS( vector.y, DevelHandle::GetCurrentProperty< float >( actor, 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, DevelHandle::GetCurrentProperty< Vector3 >( actor, Actor::Property::POSITION ).z, TEST_LOCATION );
+ DALI_TEST_EQUALS( vector.z, DevelHandle::GetCurrentProperty< float >( actor, Actor::Property::POSITION_Z ), TEST_LOCATION );
+
+ END_TEST;
+}
+
int UtcDaliActorTranslateBy(void)
{
TestApplication application;
DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
- // first test default, which is INHERIT_PARENT_POSITION
+ // 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.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), parentPosition + childPosition, TEST_LOCATION );
- // Change inheritance mode to use parent
- child.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION );
- DALI_TEST_EQUALS( child.GetPositionInheritanceMode(), Dali::USE_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, TEST_LOCATION );
- // Change inheritance mode to use parent + offset
- child.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
+ //Change child position
Vector3 childOffset( -1.0f, 1.0f, 0.0f );
child.SetPosition( childOffset );
- DALI_TEST_EQUALS( child.GetPositionInheritanceMode(), Dali::USE_PARENT_POSITION_PLUS_LOCAL_POSITION, TEST_LOCATION );
+
+ // 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(), parentPosition + childOffset, TEST_LOCATION );
+ DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), childOffset, TEST_LOCATION );
+ END_TEST;
+}
- // Change inheritance mode to not inherit
- child.SetPositionInheritanceMode( Dali::DONT_INHERIT_POSITION );
- DALI_TEST_EQUALS( child.GetPositionInheritanceMode(), Dali::DONT_INHERIT_POSITION, TEST_LOCATION );
+int UtcDaliActorSetInheritPosition(void)
+{
+ tet_infoline("Testing Actor::SetInheritPosition");
+ 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.IsPositionInherited(), true, 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 );
+
+ // Use local position as world postion
+ child.SetInheritPosition( false );
+ DALI_TEST_EQUALS( child.IsPositionInherited(), false, 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 );
+
+ //Change back to inherit position from parent
+ child.SetInheritPosition( true );
+ DALI_TEST_EQUALS( child.IsPositionInherited(), true, 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(), parentPosition + childOffset, TEST_LOCATION );
END_TEST;
}
END_TEST;
}
+// SetOrientation(float angleRadians, Vector3 axis)
+int UtcDaliActorSetOrientationProperty(void)
+{
+ TestApplication application;
+
+ Quaternion rotation( Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
+ 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, DevelHandle::GetCurrentProperty< Quaternion >( actor, Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ END_TEST;
+}
+
// RotateBy(float angleRadians, Vector3 axis)
int UtcDaliActorRotateBy01(void)
{
END_TEST;
}
+int UtcDaliActorSetScaleIndividual(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ Vector3 vector(0.7f, 0.8f, 0.9f);
+ 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, DevelHandle::GetCurrentProperty< float >( actor, 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, DevelHandle::GetCurrentProperty< float >( actor, 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, DevelHandle::GetCurrentProperty< float >( actor, Actor::Property::SCALE_Z ), TEST_LOCATION );
+
+ DALI_TEST_EQUALS( vector, actor.GetProperty< Vector3 >( Actor::Property::SCALE ), TEST_LOCATION );
+ DALI_TEST_EQUALS( vector, DevelHandle::GetCurrentProperty< Vector3 >( actor, Actor::Property::SCALE ), TEST_LOCATION );
+
+ END_TEST;
+}
+
int UtcDaliActorScaleBy(void)
{
TestApplication application;
END_TEST;
}
+int UtcDaliActorSetColorIndividual(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ Vector4 vector(0.7f, 0.8f, 0.9f, 0.6f);
+ 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, DevelHandle::GetCurrentProperty< float >( actor, 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, DevelHandle::GetCurrentProperty< float >( actor, 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, DevelHandle::GetCurrentProperty< float >( actor, 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, DevelHandle::GetCurrentProperty< float >( actor, Actor::Property::COLOR_ALPHA ), TEST_LOCATION );
+
+ DALI_TEST_EQUALS( vector, actor.GetProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
+ DALI_TEST_EQUALS( vector, DevelHandle::GetCurrentProperty< Vector4 >( actor, Actor::Property::COLOR ), TEST_LOCATION );
+
+ actor.SetProperty( DevelActor::Property::OPACITY, 0.2f );
+
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( 0.2f, actor.GetCurrentColor().a, TEST_LOCATION );
+
+ END_TEST;
+}
+
+
int UtcDaliActorGetCurrentColor(void)
{
TestApplication application;
float localX;
float localY;
+ application.SendNotification();
+ application.Render();
+
DALI_TEST_CHECK( actor.ScreenToLocal(localX, localY, 50.0f, 50.0f) );
DALI_TEST_EQUALS(localX, 40.0f, 0.01f, TEST_LOCATION);
{
TestApplication application;
- gTouchCallBackCalled = false;
+ ResetTouchCallbacks();
// get the root layer
Actor actor = Stage::GetCurrent().GetRootLayer();
// simulate a touch event in the middle of the screen
Vector2 touchPoint( Stage::GetCurrent().GetSize() * 0.5 );
- Dali::TouchPoint point( 1, TouchPoint::Down, touchPoint.x, touchPoint.y );
- Dali::Integration::TouchEvent event;
- event.AddPoint( point );
- application.ProcessEvent( event );
+ Dali::Integration::Point point;
+ point.SetDeviceId( 1 );
+ point.SetState( PointState::DOWN );
+ point.SetScreenPosition( Vector2( touchPoint.x, touchPoint.y ) );
+ Dali::Integration::TouchEvent touchEvent;
+ touchEvent.AddPoint( point );
+ application.ProcessEvent( touchEvent );
DALI_TEST_CHECK( gTouchCallBackCalled == true );
END_TEST;
// simulate a hover event in the middle of the screen
Vector2 touchPoint( Stage::GetCurrent().GetSize() * 0.5 );
- Dali::TouchPoint point( 1, TouchPoint::Motion, touchPoint.x, touchPoint.y );
- Dali::Integration::HoverEvent event;
- event.AddPoint( point );
- application.ProcessEvent( event );
+ Dali::Integration::Point point;
+ point.SetDeviceId( 1 );
+ point.SetState( PointState::MOTION );
+ point.SetScreenPosition( Vector2( touchPoint.x, touchPoint.y ) );
+ Dali::Integration::HoverEvent hoverEvent;
+ hoverEvent.AddPoint( point );
+ application.ProcessEvent( hoverEvent );
DALI_TEST_CHECK( gHoverCallBackCalled == true );
END_TEST;
Stage::GetCurrent().Add( actor );
- gTouchCallBackCalled = false;
+ ResetTouchCallbacks();
unsigned int index = 0;
while( NULL != hitTestData[index] )
// connect to its touch signal
actor.TouchedSignal().Connect(TestCallback);
- Dali::TouchPoint point( 0, TouchPoint::Down, hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y );
+ Dali::Integration::Point point;
+ point.SetState( PointState::DOWN );
+ point.SetScreenPosition( Vector2( hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y ) );
Dali::Integration::TouchEvent event;
event.AddPoint( point );
hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y,
hitTestData[index]->mResult );
- gTouchCallBackCalled = false;
+ ResetTouchCallbacks();
++index;
}
END_TEST;
DALI_TEST_CHECK( DrawMode::OVERLAY_2D == a.GetDrawMode() ); // Check Actor is overlay
- a.SetDrawMode( DrawMode::STENCIL );
- app.SendNotification();
- app.Render(1);
-
- DALI_TEST_CHECK( DrawMode::STENCIL == a.GetDrawMode() ); // Check Actor is stencil, not overlay
-
a.SetDrawMode( DrawMode::NORMAL );
app.SendNotification();
app.Render(1);
- DALI_TEST_CHECK( DrawMode::NORMAL == a.GetDrawMode() ); // Check Actor is not stencil
+ DALI_TEST_CHECK( DrawMode::NORMAL == a.GetDrawMode() ); // Check Actor is normal
END_TEST;
}
BufferImage imageA = BufferImage::New(16, 16);
BufferImage imageB = BufferImage::New(16, 16);
BufferImage imageC = BufferImage::New(16, 16);
- ImageActor a = ImageActor::New( imageA );
- ImageActor b = ImageActor::New( imageB );
- ImageActor c = ImageActor::New( imageC );
+ Actor a = CreateRenderableActor( imageA );
+ Actor b = CreateRenderableActor( imageB );
+ Actor c = CreateRenderableActor( imageC );
+
+ app.SendNotification();
+ app.Render(1);
+
+ //Textures are bound when first created. Clear bound textures vector
+ app.GetGlAbstraction().ClearBoundTextures();
// Render a,b,c as regular non-overlays. so order will be:
// a (8)
child.SetScale( childScale );
parent.Add( child );
- // The actors should not have a world matrix yet
- DALI_TEST_EQUALS( parent.GetCurrentWorldMatrix(), Matrix::IDENTITY, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentWorldMatrix(), Matrix::IDENTITY, 0.001, TEST_LOCATION );
-
app.SendNotification();
app.Render(0);
app.Render();
Matrix parentMatrix(false);
parentMatrix.SetTransformComponents(parentScale, parentRotation, parentPosition);
- Vector3 childWorldPosition = parentPosition + parentRotation * parentScale * childPosition;
- Quaternion childWorldRotation = parentRotation * childRotation;
- Vector3 childWorldScale = parentScale * childScale;
+ Matrix childMatrix(false);
+ childMatrix.SetTransformComponents( childScale, childRotation, childPosition );
+ //Child matrix should be the composition of child and parent
Matrix childWorldMatrix(false);
- childWorldMatrix.SetTransformComponents(childWorldScale, childWorldRotation, childWorldPosition);
+ Matrix::Multiply( childWorldMatrix, childMatrix, parentMatrix);
DALI_TEST_EQUALS( parent.GetCurrentWorldMatrix(), parentMatrix, 0.001, TEST_LOCATION );
DALI_TEST_EQUALS( child.GetCurrentWorldMatrix(), childWorldMatrix, 0.001, TEST_LOCATION );
Stage::GetCurrent().Add( child );
- // The actors should not have a world matrix yet
- DALI_TEST_EQUALS( parent.GetCurrentWorldMatrix(), Matrix::IDENTITY, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentWorldMatrix(), Matrix::IDENTITY, 0.001, TEST_LOCATION );
-
app.SendNotification();
app.Render(0);
app.Render();
END_TEST;
}
+int UtcDaliActorConstrainedToOrientation(void)
+{
+ TestApplication app;
+ tet_infoline(" UtcDaliActorConstrainedToOrientation");
+
+ Actor parent = Actor::New();
+ parent.SetParentOrigin(ParentOrigin::CENTER);
+ parent.SetAnchorPoint(AnchorPoint::CENTER);
+ Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
+ Radian rotationAngle(Degree(85.0f));
+ Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
+ Vector3 parentScale( 1.0f, 2.0f, 3.0f );
+ parent.SetPosition( parentPosition );
+ parent.SetOrientation( parentRotation );
+ parent.SetScale( parentScale );
+ Stage::GetCurrent().Add( parent );
+
+ Actor child = Actor::New();
+ child.SetParentOrigin(ParentOrigin::CENTER);
+ Constraint posConstraint = Constraint::New<Quaternion>( child, Actor::Property::ORIENTATION, OrientationComponentConstraint() );
+ posConstraint.AddSource( Source( parent, Actor::Property::ORIENTATION ) );
+ posConstraint.Apply();
+
+ Stage::GetCurrent().Add( child );
+
+ app.SendNotification();
+ app.Render(0);
+ app.Render();
+ app.SendNotification();
+
+ DALI_TEST_EQUALS( child.GetCurrentOrientation(), parent.GetCurrentOrientation(), 0.001, TEST_LOCATION );
+ END_TEST;
+}
+
+int UtcDaliActorConstrainedToOpacity(void)
+{
+ TestApplication app;
+ tet_infoline(" UtcDaliActorConstrainedToOpacity");
+
+ Actor parent = Actor::New();
+ parent.SetOpacity( 0.7f );
+ Stage::GetCurrent().Add( parent );
+
+ Actor child = Actor::New();
+ Constraint opacityConstraint = Constraint::New<float>( child, DevelActor::Property::OPACITY, EqualToConstraint() );
+ opacityConstraint.AddSource( Source( parent, DevelActor::Property::OPACITY ) );
+ opacityConstraint.Apply();
+
+ Stage::GetCurrent().Add( child );
+
+ app.SendNotification();
+ app.Render(0);
+ app.Render();
+ app.SendNotification();
+
+ DALI_TEST_EQUALS( child.GetCurrentOpacity(), parent.GetCurrentOpacity(), 0.001f, TEST_LOCATION );
+
+ parent.SetOpacity( 0.3f );
+
+ app.SendNotification();
+ app.Render(0);
+ app.Render();
+ app.SendNotification();
+
+ DALI_TEST_EQUALS( child.GetCurrentOpacity(), parent.GetCurrentOpacity(), 0.001f, TEST_LOCATION );
+
+ END_TEST;
+}
+
int UtcDaliActorUnparent(void)
{
TestApplication app;
{ "padding", Actor::Property::PADDING, Property::VECTOR4 },
{ "minimumSize", Actor::Property::MINIMUM_SIZE, Property::VECTOR2 },
{ "maximumSize", Actor::Property::MAXIMUM_SIZE, Property::VECTOR2 },
+ { "inheritPosition", Actor::Property::INHERIT_POSITION, Property::BOOLEAN },
+ { "clippingMode", Actor::Property::CLIPPING_MODE, Property::STRING },
+ { "opacity", DevelActor::Property::OPACITY, Property::FLOAT },
};
const unsigned int PROPERTY_TABLE_COUNT = sizeof( PROPERTY_TABLE ) / sizeof( PROPERTY_TABLE[0] );
} // unnamed namespace
DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_RESIZE_POLICY ).Get< std::string >(), widthPolicy, TEST_LOCATION );
DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_RESIZE_POLICY ).Get< std::string >(), heightPolicy, TEST_LOCATION );
+ // Set individual dimensions using enums
+ ResizePolicy::Type widthPolicyEnum = ResizePolicy::USE_ASSIGNED_SIZE;
+ ResizePolicy::Type heightPolicyEnum = ResizePolicy::SIZE_RELATIVE_TO_PARENT;
+
+ actor.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, widthPolicyEnum );
+ actor.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, heightPolicyEnum );
+
+ DALI_TEST_EQUALS( static_cast< int >( actor.GetResizePolicy( Dimension::WIDTH ) ), static_cast< int >( widthPolicyEnum ), TEST_LOCATION );
+ DALI_TEST_EQUALS( static_cast< int >( actor.GetResizePolicy( Dimension::HEIGHT ) ), static_cast< int >( heightPolicyEnum ), TEST_LOCATION );
+
END_TEST;
}
END_TEST;
}
+int UtcDaliActorAnchorPointPropertyAsString(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_LEFT" );
+ DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_CENTER" );
+ DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::TOP_CENTER, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_RIGHT" );
+ DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER_LEFT" );
+ DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::CENTER_LEFT, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER" );
+ DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::CENTER, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER_RIGHT" );
+ DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::CENTER_RIGHT, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_LEFT" );
+ DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_CENTER" );
+ DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_RIGHT" );
+ DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
+
+ // Invalid should not change anything
+ actor.SetProperty( Actor::Property::ANCHOR_POINT, "INVALID_ARG" );
+ DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliActorParentOriginPropertyAsString(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_LEFT" );
+ DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_CENTER" );
+ DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_CENTER, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_RIGHT" );
+ DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER_LEFT" );
+ DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::CENTER_LEFT, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER" );
+ DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::CENTER, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER_RIGHT" );
+ DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::CENTER_RIGHT, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_LEFT" );
+ DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_CENTER" );
+ DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_RIGHT" );
+ DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
+
+ // Invalid should not change anything
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN, "INVALID_ARG" );
+ DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliActorColorModePropertyAsString(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_COLOR" );
+ DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_COLOR, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::COLOR_MODE, "USE_PARENT_COLOR" );
+ DALI_TEST_EQUALS( actor.GetColorMode(), USE_PARENT_COLOR, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_COLOR" );
+ DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_ALPHA" );
+ DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
+
+ // Invalid should not change anything
+ actor.SetProperty( Actor::Property::COLOR_MODE, "INVALID_ARG" );
+ DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliActorPositionInheritancePropertyAsString(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "INHERIT_PARENT_POSITION" );
+ DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), INHERIT_PARENT_POSITION, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "USE_PARENT_POSITION" );
+ DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), USE_PARENT_POSITION, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "USE_PARENT_POSITION_PLUS_LOCAL_POSITION" );
+ DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), USE_PARENT_POSITION_PLUS_LOCAL_POSITION, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "DONT_INHERIT_POSITION" );
+ DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
+
+ // Invalid should not change anything
+ actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "INVALID_ARG" );
+ DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliActorDrawModePropertyAsString(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ actor.SetProperty( Actor::Property::DRAW_MODE, "NORMAL" );
+ DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::NORMAL, TEST_LOCATION );
+
+ 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 );
+
+ END_TEST;
+}
+
+int UtcDaliActorColorModePropertyAsEnum(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_COLOR );
+ DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_COLOR, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::COLOR_MODE, USE_PARENT_COLOR );
+ DALI_TEST_EQUALS( actor.GetColorMode(), USE_PARENT_COLOR, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_COLOR );
+ DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA );
+ DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliActorPositionInheritancePropertyAsEnum(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ actor.SetProperty( Actor::Property::POSITION_INHERITANCE, INHERIT_PARENT_POSITION );
+ DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), INHERIT_PARENT_POSITION, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::POSITION_INHERITANCE, USE_PARENT_POSITION );
+ DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), USE_PARENT_POSITION, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::POSITION_INHERITANCE, USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
+ DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), USE_PARENT_POSITION_PLUS_LOCAL_POSITION, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::POSITION_INHERITANCE, DONT_INHERIT_POSITION );
+ DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliActorDrawModePropertyAsEnum(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ actor.SetProperty( Actor::Property::DRAW_MODE, DrawMode::NORMAL );
+ DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::NORMAL, TEST_LOCATION );
+
+ 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;
+}
+
+int UtcDaliActorAddRendererP(void)
+{
+ tet_infoline("Testing Actor::AddRenderer");
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+
+ 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 );
+
+ END_TEST;
+}
+
+int UtcDaliActorAddRendererN(void)
+{
+ tet_infoline("Testing Actor::AddRenderer");
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ Renderer renderer;
+
+ // try illegal Add
+ try
+ {
+ actor.AddRenderer( renderer );
+ tet_printf("Assertion test failed - no Exception\n" );
+ tet_result(TET_FAIL);
+ }
+ catch(Dali::DaliException& e)
+ {
+ DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_ASSERT(e, "Renderer handle is empty", TEST_LOCATION);
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+ }
+ catch(...)
+ {
+ tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_result(TET_FAIL);
+ }
+
+ END_TEST;
+}
+
+int UtcDaliActorAddRendererOnStage(void)
+{
+ tet_infoline("Testing Actor::AddRenderer");
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ Stage::GetCurrent().Add(actor);
+
+ application.SendNotification();
+ application.Render(0);
+
+ Geometry geometry = CreateQuadGeometry();
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
+
+ application.SendNotification();
+ application.Render(0);
+
+ try
+ {
+ actor.AddRenderer( renderer );
+ tet_result(TET_PASS);
+ }
+ catch(...)
+ {
+ tet_result(TET_FAIL);
+ }
+
+ END_TEST;
+}
+
+int UtcDaliActorRemoveRendererP1(void)
+{
+ tet_infoline("Testing Actor::RemoveRenderer");
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+
+ {
+ 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 );
+
+ 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;
+}
+
+int UtcDaliActorRemoveRendererP2(void)
+{
+ tet_infoline("Testing Actor::RemoveRenderer");
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+
+ Geometry geometry = CreateQuadGeometry();
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
+
+ actor.AddRenderer( renderer );
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
+
+ actor.RemoveRenderer(0);
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+
+ // Shut down whilst holding onto the renderer handle.
+ END_TEST;
+}
+
+
+int UtcDaliActorRemoveRendererN(void)
+{
+ tet_infoline("Testing Actor::RemoveRenderer");
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+
+ 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.RemoveRenderer(10);
+ DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
+
+ END_TEST;
+}
+
+// Clipping test helper functions:
+Actor CreateActorWithContent()
+{
+ 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 );
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetAnchorPoint( AnchorPoint::CENTER );
+
+ return actor;
+}
+
+void GenerateTrace( TestApplication& application, TraceCallStack& enabledDisableTrace, TraceCallStack& stencilTrace )
+{
+ enabledDisableTrace.Reset();
+ stencilTrace.Reset();
+ enabledDisableTrace.Enable( true );
+ stencilTrace.Enable( true );
+
+ application.SendNotification();
+ application.Render();
+
+ enabledDisableTrace.Enable( false );
+ stencilTrace.Enable( false );
+}
+
+void CheckColorMask( TestGlAbstraction& glAbstraction, bool maskValue )
+{
+ const TestGlAbstraction::ColorMaskParams& colorMaskParams = glAbstraction.GetColorMaskParams();
+
+ DALI_TEST_EQUALS<bool>( colorMaskParams.red, maskValue, TEST_LOCATION );
+ DALI_TEST_EQUALS<bool>( colorMaskParams.green, maskValue, TEST_LOCATION );
+ DALI_TEST_EQUALS<bool>( colorMaskParams.blue, maskValue, TEST_LOCATION );
+ DALI_TEST_EQUALS<bool>( colorMaskParams.alpha, maskValue, TEST_LOCATION );
+}
+
+int UtcDaliActorPropertyClippingP(void)
+{
+ // This test checks the clippingMode property.
+ tet_infoline( "Testing Actor::Property::CLIPPING_MODE P" );
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ // Check default clippingEnabled value.
+ Property::Value getValue( actor.GetProperty( Actor::Property::CLIPPING_MODE ) );
+
+ int value = 0;
+ bool getValueResult = getValue.Get( value );
+ DALI_TEST_CHECK( getValueResult );
+
+ if( getValueResult )
+ {
+ DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
+ }
+
+ // Check setting the property.
+ actor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
+
+ // Check the new value was set.
+ getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
+ getValueResult = getValue.Get( value );
+ DALI_TEST_CHECK( getValueResult );
+
+ if( getValueResult )
+ {
+ DALI_TEST_EQUALS<int>( value, ClippingMode::CLIP_CHILDREN, TEST_LOCATION );
+ }
+
+ END_TEST;
+}
+
+int UtcDaliActorPropertyClippingN(void)
+{
+ // Negative test case for Clipping.
+ tet_infoline( "Testing Actor::Property::CLIPPING_MODE N" );
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ // Check default clippingEnabled value.
+ Property::Value getValue( actor.GetProperty( Actor::Property::CLIPPING_MODE ) );
+
+ int value = 0;
+ bool getValueResult = getValue.Get( value );
+ DALI_TEST_CHECK( getValueResult );
+
+ if( getValueResult )
+ {
+ DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
+ }
+
+ // Check setting an invalid property value won't change the current property value.
+ actor.SetProperty( Actor::Property::CLIPPING_MODE, "INVALID_PROPERTY" );
+
+ getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
+ getValueResult = getValue.Get( value );
+ DALI_TEST_CHECK( getValueResult );
+
+ if( getValueResult )
+ {
+ DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
+ }
+
+ END_TEST;
+}
+
+int UtcDaliActorPropertyClippingActor(void)
+{
+ // This test checks that an actor is correctly setup for clipping.
+ tet_infoline( "Testing Actor::Property::CLIPPING_MODE actor" );
+ TestApplication application;
+
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ size_t startIndex = 0u;
+
+ // Create a clipping actor.
+ Actor actorDepth1Clip = CreateActorWithContent();
+ actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
+ Stage::GetCurrent().Add( actorDepth1Clip );
+
+ // Gather the call trace.
+ GenerateTrace( application, enabledDisableTrace, stencilTrace );
+
+ // Check we are writing to the color buffer.
+ CheckColorMask( glAbstraction, true );
+
+ // Check the stencil buffer was enabled.
+ DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) ); // 2960 is GL_STENCIL_TEST
+
+ // Check the stencil buffer was cleared.
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "ClearStencil", "0", startIndex ) );
+
+ // Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc", "514, 1, 0", startIndex ) ); // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "1", startIndex ) );
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
+
+ END_TEST;
+}
+
+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" );
+ TestApplication application;
+
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ size_t startIndex = 0u;
+
+ // Create a clipping actor.
+ Actor actorDepth1Clip = CreateActorWithContent();
+ actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
+ Stage::GetCurrent().Add( actorDepth1Clip );
+
+ // Gather the call trace.
+ GenerateTrace( application, enabledDisableTrace, stencilTrace );
+
+ // Check we are writing to the color buffer.
+ CheckColorMask( glAbstraction, true );
+
+ // Check the stencil buffer was enabled.
+ DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) ); // 2960 is GL_STENCIL_TEST
+
+ // Check the stencil buffer was cleared.
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "ClearStencil", "0", startIndex ) );
+
+ // Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc", "514, 1, 0", startIndex ) ); // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "1", startIndex ) );
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
+
+ // Now disable the clipping
+ actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED );
+
+ // Gather the call trace.
+ GenerateTrace( application, enabledDisableTrace, stencilTrace );
+
+ // Check the stencil buffer was disabled.
+ DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Disable", "2960" ) ); // 2960 is GL_STENCIL_TEST
+
+ // Ensure all values in stencil-mask are set to 1.
+ startIndex = 0u;
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "255", startIndex ) );
+
+ 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" );
+ TestApplication application;
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+ // Create a clipping actor.
+ Actor actorDepth1Clip = CreateActorWithContent();
+ actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
+ Stage::GetCurrent().Add( actorDepth1Clip );
+
+ // Create a child actor.
+ Actor childDepth2 = CreateActorWithContent();
+ actorDepth1Clip.Add( childDepth2 );
+
+ // Create another clipping actor.
+ Actor childDepth2Clip = CreateActorWithContent();
+ 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();
+ childDepth2Clip.Add( childDepth3 );
+ Actor childDepth4 = CreateActorWithContent();
+ childDepth3.Add( childDepth4 );
+
+ // Gather the call trace.
+ GenerateTrace( application, enabledDisableTrace, stencilTrace );
+
+ // Check we are writing to the color buffer.
+ CheckColorMask( glAbstraction, true );
+
+ // Check the stencil buffer was enabled.
+ DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) ); // 2960 is GL_STENCIL_TEST
+
+ // Perform the test twice, once for 2D layer, and once for 3D.
+ for( unsigned int i = 0u ; i < 2u; ++i )
+ {
+ size_t startIndex = 0u;
+
+ // Check the stencil buffer was cleared.
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "ClearStencil", "0", startIndex ) );
+
+ // Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc", "514, 1, 0", startIndex ) ); // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "1", startIndex ) ); // Write to the first bit-plane
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
+
+ // Check the correct setup was done to test against first bit-plane (only) of the stencil buffer.
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc", "514, 1, 255", startIndex ) ); // 514 is GL_EQUAL
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7680, 7680", startIndex ) ); // GL_KEEP, GL_KEEP, GL_KEEP
+
+ // Check we are set up to write to the second bitplane of the stencil buffer (only).
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc", "514, 3, 1", startIndex ) ); // 514 is GL_EQUAL, Test both bit-planes 1 & 2
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "3", startIndex ) ); // Write to second (and previous) bit-planes
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
+
+ // Check we are set up to test against both the first and second bit-planes of the stencil buffer.
+ // (Both must be set to pass the check).
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc", "514, 3, 255", startIndex ) ); // 514 is GL_EQUAL, Test both bit-planes 1 & 2
+ DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7680, 7680", startIndex ) ); // GL_KEEP, GL_KEEP, GL_KEEP
+
+ // If we are on the first loop, set the layer to 3D and loop to perform the test again.
+ if( i == 0u )
+ {
+ Stage::GetCurrent().GetRootLayer().SetBehavior( Layer::LAYER_3D );
+ GenerateTrace( application, enabledDisableTrace, stencilTrace );
+ }
+ }
+
+ END_TEST;
+}
+
+int UtcDaliActorPropertyClippingActorWithRendererOverride(void)
+{
+ // This test checks that an actor with clipping will be ignored if overridden by the Renderer properties.
+ tet_infoline( "Testing Actor::Property::CLIPPING_MODE actor with renderer override" );
+ TestApplication application;
+
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+ // Create a clipping actor.
+ Actor actorDepth1Clip = CreateActorWithContent();
+ actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
+ Stage::GetCurrent().Add( actorDepth1Clip );
+
+ // Turn the RenderMode to just "COLOR" at the Renderer level to ignore the clippingMode.
+ actorDepth1Clip.GetRendererAt( 0 ).SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR );
+
+ // Gather the call trace.
+ GenerateTrace( application, enabledDisableTrace, stencilTrace );
+
+ // Check we are writing to the color buffer.
+ CheckColorMask( glAbstraction, true );
+
+ // Check the stencil buffer was not enabled.
+ DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) ); // 2960 is GL_STENCIL_TEST
+
+ // Check stencil functions are not called.
+ DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilFunc" ) );
+ DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilMask" ) );
+ DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilOp" ) );
+
+ END_TEST;
+}
+
+int UtcDaliGetPropertyN(void)
+{
+ tet_infoline( "Testing Actor::GetProperty returns a non valid value if property index is out of range" );
+ TestApplication app;
+
+ Actor actor = Actor::New();
+
+ unsigned int propertyCount = actor.GetPropertyCount();
+ DALI_TEST_EQUALS( actor.GetProperty( Property::Index(propertyCount)).GetType(), Property::NONE, TEST_LOCATION );
+ END_TEST;
+}
+
+int UtcDaliActorRaiseLower(void)
+{
+ tet_infoline( "UtcDaliActor Raise and Lower test\n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor actorA = Actor::New();
+ Actor actorB = Actor::New();
+ Actor actorC = Actor::New();
+
+ actorA.SetAnchorPoint( AnchorPoint::CENTER );
+ actorA.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorB.SetAnchorPoint( AnchorPoint::CENTER );
+ actorB.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorC.SetAnchorPoint( AnchorPoint::CENTER );
+ actorC.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ 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 );
+
+ ResetTouchCallbacks();
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+
+ // 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 );
+ actorB.TouchSignal().Connect( TestTouchCallback2 );
+ actorC.TouchSignal().Connect( TestTouchCallback3 );
+
+ Dali::Integration::Point point;
+ point.SetDeviceId( 1 );
+ point.SetState( PointState::DOWN );
+ point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ Dali::Integration::TouchEvent touchEvent;
+ touchEvent.AddPoint( point );
+
+ application.ProcessEvent( touchEvent );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ tet_printf( "Testing Raising of Actor\n" );
+
+ int preActorOrder( 0 );
+ int postActorOrder( 0 );
+
+ Property::Value value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
+ value.Get( preActorOrder );
+
+ DevelActor::Raise( actorB );
+ // 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( touchEvent );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, true , TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ tet_printf( "Testing Lowering of Actor\n" );
+
+ value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
+ value.Get( preActorOrder );
+
+ DevelActor::Lower( actorB );
+ 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( touchEvent );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false , TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, true, TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ END_TEST;
+}
+
+int UtcDaliActorRaiseToTopLowerToBottom(void)
+{
+ tet_infoline( "UtcDaliActorRaiseToTop and LowerToBottom test \n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor actorA = Actor::New();
+ Actor actorB = Actor::New();
+ Actor actorC = Actor::New();
+
+ // Set up renderers to add to Actors, float value 1, 2, 3 assigned to each
+ // enables checking of which actor the uniform is assigned too
+ Shader shaderA = CreateShader();
+ shaderA.RegisterProperty( "uRendererColor",1.f);
+
+ Shader shaderB = CreateShader();
+ shaderB.RegisterProperty( "uRendererColor", 2.f );
+
+ Shader shaderC = CreateShader();
+ shaderC.RegisterProperty( "uRendererColor", 3.f );
+
+ Geometry geometry = CreateQuadGeometry();
+
+ // Add renderers to Actors so ( uRendererColor, 1 ) is A, ( uRendererColor, 2 ) is B, and ( uRendererColor, 3 ) is C,
+ Renderer rendererA = Renderer::New(geometry, shaderA);
+ actorA.AddRenderer(rendererA);
+
+ Renderer rendererB = Renderer::New(geometry, shaderB);
+ actorB.AddRenderer(rendererB);
+
+ Renderer rendererC = Renderer::New(geometry, shaderC);
+ actorC.AddRenderer(rendererC);
+
+ actorA.SetAnchorPoint( AnchorPoint::CENTER );
+ actorA.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorB.SetAnchorPoint( AnchorPoint::CENTER );
+ actorB.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorC.SetAnchorPoint( AnchorPoint::CENTER );
+ actorC.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ 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 );
+
+ ResetTouchCallbacks();
+
+ // Set up gl abstraction trace so can query the set uniform order
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ glAbstraction.EnableSetUniformCallTrace(true);
+ glAbstraction.ResetSetUniformCallStack();
+
+ TraceCallStack& glSetUniformStack = glAbstraction.GetSetUniformTrace();
+
+ application.SendNotification();
+ application.Render();
+
+ tet_printf( "Trace Output:%s \n", glSetUniformStack.GetTraceString().c_str() );
+
+
+ // Test order of uniforms in stack
+ int indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
+ int indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
+ int indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+
+ bool CBA = ( indexC > indexB) && ( indexB > indexA );
+
+ DALI_TEST_EQUALS( CBA, true, TEST_LOCATION );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+
+ // 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 );
+ actorB.TouchSignal().Connect( TestTouchCallback2 );
+ actorC.TouchSignal().Connect( TestTouchCallback3 );
+
+ Dali::Integration::Point point;
+ point.SetDeviceId( 1 );
+ point.SetState( PointState::DOWN );
+ point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ Dali::Integration::TouchEvent touchEvent;
+ touchEvent.AddPoint( point );
+
+ application.ProcessEvent( touchEvent );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ tet_printf( "RaiseToTop ActorA\n" );
+
+ DevelActor::RaiseToTop( actorA );
+ application.SendNotification(); // ensure sorting order is calculated before next touch event
+
+ application.ProcessEvent( touchEvent );
+
+ glAbstraction.ResetSetUniformCallStack();
+ glSetUniformStack = glAbstraction.GetSetUniformTrace();
+
+ application.SendNotification();
+ application.Render();
+
+ tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+
+ // Test order of uniforms in stack
+ indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
+ indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
+ indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+
+ tet_infoline( "Testing A above C and B at bottom\n" );
+ bool ACB = ( indexA > indexC) && ( indexC > indexB );
+
+ DALI_TEST_EQUALS( ACB, true, TEST_LOCATION );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ tet_printf( "RaiseToTop ActorB\n" );
+
+ DevelActor::RaiseToTop( actorB );
+ application.SendNotification(); // Ensure sort order is calculated before next touch event
+
+ application.ProcessEvent( touchEvent );
+
+ glAbstraction.ResetSetUniformCallStack();
+ glSetUniformStack = glAbstraction.GetSetUniformTrace();
+
+ application.SendNotification();
+ application.Render();
+
+ tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+
+ // Test order of uniforms in stack
+ indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
+ 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 );
+
+ DALI_TEST_EQUALS( BAC, true, 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( "LowerToBottom ActorA then ActorB leaving Actor C at Top\n" );
+
+ DevelActor::LowerToBottom( actorA );
+ application.SendNotification();
+ application.Render();
+
+ DevelActor::LowerToBottom( actorB );
+ application.SendNotification();
+ application.Render();
+
+ application.ProcessEvent( touchEvent );
+
+ glAbstraction.ResetSetUniformCallStack();
+ glSetUniformStack = glAbstraction.GetSetUniformTrace();
+
+ application.SendNotification();
+ application.Render();
+
+ tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+
+ // Test order of uniforms in stack
+ indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
+ indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
+ indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+
+ tet_infoline( "Testing C above A and B at bottom\n" );
+ bool CAB = ( indexC > indexA ) && ( indexA > indexB );
+
+ DALI_TEST_EQUALS( CAB, true, TEST_LOCATION );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ END_TEST;
+}
+
+int UtcDaliActorRaiseAbove(void)
+{
+ tet_infoline( "UtcDaliActor RaiseToAbove test \n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor actorA = Actor::New();
+ Actor actorB = Actor::New();
+ Actor actorC = Actor::New();
+
+ actorA.SetAnchorPoint( AnchorPoint::CENTER );
+ actorA.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorB.SetAnchorPoint( AnchorPoint::CENTER );
+ actorB.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorC.SetAnchorPoint( AnchorPoint::CENTER );
+ actorC.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ 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 );
+
+ ResetTouchCallbacks();
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+
+ // 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 );
+ actorB.TouchSignal().Connect( TestTouchCallback2 );
+ actorC.TouchSignal().Connect( TestTouchCallback3 );
+
+ Dali::Integration::Point point;
+ point.SetDeviceId( 1 );
+ point.SetState( PointState::DOWN );
+ point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ Dali::Integration::TouchEvent touchEvent;
+ touchEvent.AddPoint( point );
+
+ application.ProcessEvent( touchEvent );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ tet_printf( "Raise actor B Above Actor C\n" );
+
+ DevelActor::RaiseAbove( actorB, actorC );
+ // 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 );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ tet_printf( "Raise actor A Above Actor B\n" );
+
+ DevelActor::RaiseAbove( actorA, actorB );
+
+ // 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 );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ END_TEST;
+}
+
+int UtcDaliActorLowerBelow(void)
+{
+ tet_infoline( "UtcDaliActor LowerBelow test \n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ // Set up renderers to add to Actors, float value 1, 2, 3 assigned to each
+ // enables checking of which actor the uniform is assigned too
+ Shader shaderA = CreateShader();
+ shaderA.RegisterProperty( "uRendererColor",1.f);
+
+ Shader shaderB = CreateShader();
+ shaderB.RegisterProperty( "uRendererColor", 2.f );
+
+ Shader shaderC = CreateShader();
+ shaderC.RegisterProperty( "uRendererColor", 3.f );
+
+ Actor actorA = Actor::New();
+ Actor actorB = Actor::New();
+ Actor actorC = Actor::New();
+
+ // Add renderers to Actors so ( uRendererColor, 1 ) is A, ( uRendererColor, 2 ) is B, and ( uRendererColor, 3 ) is C,
+ Geometry geometry = CreateQuadGeometry();
+
+ Renderer rendererA = Renderer::New(geometry, shaderA);
+ actorA.AddRenderer(rendererA);
+
+ Renderer rendererB = Renderer::New(geometry, shaderB);
+ actorB.AddRenderer(rendererB);
+
+ Renderer rendererC = Renderer::New(geometry, shaderC);
+ actorC.AddRenderer(rendererC);
+
+ actorA.SetAnchorPoint( AnchorPoint::CENTER );
+ actorA.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorB.SetAnchorPoint( AnchorPoint::CENTER );
+ actorB.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorC.SetAnchorPoint( AnchorPoint::CENTER );
+ actorC.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ 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 );
+
+ ResetTouchCallbacks();
+
+ // Set up gl abstraction trace so can query the set uniform order
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ glAbstraction.EnableSetUniformCallTrace(true);
+ glAbstraction.ResetSetUniformCallStack();
+ TraceCallStack& glSetUniformStack = glAbstraction.GetSetUniformTrace();
+
+ glAbstraction.ResetSetUniformCallStack();
+
+ application.SendNotification();
+ application.Render();
+
+ glSetUniformStack = glAbstraction.GetSetUniformTrace();
+
+ tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+
+ // Test order of uniforms in stack
+ int indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
+ int indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
+ int indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+
+ tet_infoline( "Testing C above B and A at bottom\n" );
+ bool CBA = ( indexC > indexB) && ( indexB > indexA );
+
+ DALI_TEST_EQUALS( CBA, true, TEST_LOCATION );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+
+ // 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 );
+ actorB.TouchSignal().Connect( TestTouchCallback2 );
+ actorC.TouchSignal().Connect( TestTouchCallback3 );
+
+ Dali::Integration::Point point;
+ point.SetDeviceId( 1 );
+ point.SetState( PointState::DOWN );
+ point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ Dali::Integration::TouchEvent touchEvent;
+ touchEvent.AddPoint( point );
+
+ tet_infoline( "UtcDaliActor Test Set up completed \n" );
+
+ application.ProcessEvent( touchEvent );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ 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 );
+ // Ensure sorting happens at end of Core::ProcessEvents() before next touch
+ application.SendNotification();
+ application.Render();
+
+ application.ProcessEvent( touchEvent ); // touch event
+
+ glAbstraction.ResetSetUniformCallStack();
+ glSetUniformStack = glAbstraction.GetSetUniformTrace();
+
+ application.SendNotification();
+ application.Render();
+
+ tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+
+ // Test order of uniforms in stack
+ indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
+ 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 );
+
+ 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 B below Actor C leaving A on top\n" );
+
+ DevelActor::LowerBelow( actorB, actorC );
+ // Ensure sorting happens at end of Core::ProcessEvents() before next touch
+ application.SendNotification();
+ application.Render();
+
+ application.ProcessEvent( touchEvent );
+
+ glAbstraction.ResetSetUniformCallStack();
+ glSetUniformStack = glAbstraction.GetSetUniformTrace();
+
+ application.Render();
+ tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+
+ // Test order of uniforms in stack
+ indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
+ 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( gTouchCallBackCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ tet_printf( "Lower actor A below Actor C leaving C on top\n" );
+
+ DevelActor::LowerBelow( actorA, actorC );
+ // Ensure sorting happens at end of Core::ProcessEvents() before next touch
+ application.SendNotification();
+ application.Render();
+
+ application.ProcessEvent( touchEvent );
+
+ glAbstraction.ResetSetUniformCallStack();
+ glSetUniformStack = glAbstraction.GetSetUniformTrace();
+
+ application.Render();
+ tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+
+ // Test order of uniforms in stack
+ indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
+ indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
+ indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+
+ bool CAB = ( indexC > indexA) && ( indexA > indexB );
+
+ DALI_TEST_EQUALS( CAB, true, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliActorMaxSiblingOrder(void)
+{
+ tet_infoline( "UtcDaliActor De-fragment of sibling order once max index reached\n" );
+
+ TestApplication application;
+
+ int testOrders[] = { 0,1,3,5,17,998, 999 };
+ int resultingOrders[] = { 0,1,2,3,4,6,5 };
+
+ const int TEST_ORDERS_COUNT = sizeof( testOrders ) / sizeof( testOrders[0] );
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor parent = Actor::New();
+
+ for ( int index = 0; index < TEST_ORDERS_COUNT; index++ )
+ {
+ Actor newActor = Actor::New();
+ newActor.SetProperty(Dali::DevelActor::Property::SIBLING_ORDER, testOrders[index] );
+ parent.Add( newActor );
+ }
+ stage.Add( parent );
+
+ tet_printf( "Sibling Order %d children :", parent.GetChildCount() );
+ for ( unsigned int index = 0; index < parent.GetChildCount(); index ++)
+ {
+ Actor sibling = parent.GetChildAt( index );
+ int siblingOrder = 0;
+ Property::Value value = sibling.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
+ value.Get( siblingOrder );
+ tet_printf( "%d, ", siblingOrder );
+ }
+ tet_printf( "\n" );
+
+ Actor sibling = parent.GetChildAt( 5 );
+ DevelActor::RaiseToTop( sibling );
+
+ // Ensure sorting happens at end of Core::ProcessEvents()
+ application.SendNotification();
+ application.Render();
+
+ tet_printf( "Sibling Order %d children :", parent.GetChildCount() );
+ for ( unsigned int index = 0; index < parent.GetChildCount(); index ++)
+ {
+ Actor sibling = parent.GetChildAt( index );
+ int siblingOrder = 0;
+ Property::Value value = sibling.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
+ value.Get( siblingOrder );
+ tet_printf( "%d, ", siblingOrder );
+ DALI_TEST_EQUALS( siblingOrder, resultingOrders[ index] , TEST_LOCATION );
+ }
+
+ tet_printf( "\n" );
+
+ END_TEST;
+}
+
+int UtcDaliActorRaiseAboveLowerBelowDifferentParentsN(void)
+{
+ tet_infoline( "UtcDaliActor RaiseToAbove test with actor and target actor having different parents \n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor parentA = Actor::New();
+ Actor parentB = Actor::New();
+ parentA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ parentA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ parentB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ parentB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ parentA.SetAnchorPoint( AnchorPoint::CENTER );
+ parentA.SetParentOrigin( ParentOrigin::CENTER );
+
+ parentB.SetAnchorPoint( AnchorPoint::CENTER );
+ parentB.SetParentOrigin( ParentOrigin::CENTER );
+
+ stage.Add( parentA );
+ stage.Add( parentB );
+
+ Actor actorA = Actor::New();
+ Actor actorB = Actor::New();
+ Actor actorC = Actor::New();
+
+ parentA.Add( actorA );
+ parentA.Add( actorB );
+
+ tet_printf( "Actor C added to different parent from A and B \n" );
+ parentB.Add( actorC );
+
+ actorA.SetAnchorPoint( AnchorPoint::CENTER );
+ actorA.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorB.SetAnchorPoint( AnchorPoint::CENTER );
+ actorB.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorC.SetAnchorPoint( AnchorPoint::CENTER );
+ actorC.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ ResetTouchCallbacks();
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+
+ // 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 );
+ actorB.TouchSignal().Connect( TestTouchCallback2 );
+ actorC.TouchSignal().Connect( TestTouchCallback3 );
+
+ Dali::Integration::Point point;
+ point.SetDeviceId( 1 );
+ point.SetState( PointState::DOWN );
+ point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ Dali::Integration::TouchEvent touchEvent;
+ touchEvent.AddPoint( point );
+
+ application.ProcessEvent( touchEvent );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ tet_printf( "Raise actor A Above Actor C which have different parents\n" );
+
+ DevelActor::RaiseAbove( actorA, actorC );
+ // Ensure sorting happens at end of Core::ProcessEvents() before next touch
+ application.SendNotification();
+
+ application.ProcessEvent( touchEvent ); // touch event
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ END_TEST;
+}
+
+int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
+{
+ tet_infoline( "UtcDaliActor Test raiseAbove and lowerBelow api when target Actor has no parent \n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor actorA = Actor::New();
+ Actor actorB = Actor::New();
+ Actor actorC = Actor::New();
+
+ actorA.SetAnchorPoint( AnchorPoint::CENTER );
+ actorA.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorB.SetAnchorPoint( AnchorPoint::CENTER );
+ actorB.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorC.SetAnchorPoint( AnchorPoint::CENTER );
+ actorC.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ ResetTouchCallbacks();
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+
+ // 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 );
+ actorB.TouchSignal().Connect( TestTouchCallback2 );
+ actorC.TouchSignal().Connect( TestTouchCallback3 );
+
+ Dali::Integration::Point point;
+ point.SetDeviceId( 1 );
+ point.SetState( PointState::DOWN );
+ point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ Dali::Integration::TouchEvent touchEvent;
+ touchEvent.AddPoint( point );
+
+ tet_printf( "Raise actor A Above Actor C which have no parents\n" );
+
+ DevelActor::RaiseAbove( actorA, actorC );
+ // 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" );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ stage.Add ( actorB );
+ tet_printf( "Lower actor A below Actor C when only A is not on stage \n" );
+ DevelActor::LowerBelow( actorA, actorC );
+
+ // Ensure sorting happens at end of Core::ProcessEvents() before next touch
+ application.SendNotification();
+ application.Render();
+
+ application.ProcessEvent( touchEvent );
+
+ tet_printf( "Actor A not parented so LowerBelow should show no effect\n" );
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ tet_printf( "Adding Actor A to stage, will be on top\n" );
+
+ stage.Add ( actorA );
+ application.SendNotification();
+ application.Render();
+
+ tet_printf( "Raise actor B Above Actor C when only B has a parent\n" );
+ DevelActor::RaiseAbove( actorB, actorC );
+ // 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 );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ tet_printf( "Lower actor A below Actor C when only A has a parent\n" );
+ DevelActor::LowerBelow( actorA, actorC );
+ // 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 );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ stage.Add ( actorC );
+ DevelActor::RaiseAbove( actorA, actorC );
+ // Ensure sorting happens at end of Core::ProcessEvents() before next touch
+ application.SendNotification();
+ application.Render();
+
+ application.ProcessEvent( touchEvent );
+
+ tet_printf( "Raise actor A Above Actor C, now both have same parent \n" );
+ DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliActorTestAllAPIwhenActorNotParented(void)
+{
+ tet_infoline( "UtcDaliActor Test all raise/lower api when actor has no parent \n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor actorA = Actor::New();
+ Actor actorB = Actor::New();
+ Actor actorC = Actor::New();
+
+ actorA.SetAnchorPoint( AnchorPoint::CENTER );
+ actorA.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorB.SetAnchorPoint( AnchorPoint::CENTER );
+ actorB.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorC.SetAnchorPoint( AnchorPoint::CENTER );
+ actorC.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ ResetTouchCallbacks();
+
+ // 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 );
+ actorB.TouchSignal().Connect( TestTouchCallback2 );
+ actorC.TouchSignal().Connect( TestTouchCallback3 );
+
+ Dali::Integration::Point point;
+ point.SetDeviceId( 1 );
+ point.SetState( PointState::DOWN );
+ point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ Dali::Integration::TouchEvent touchEvent;
+ touchEvent.AddPoint( point );
+
+ stage.Add ( actorA );
+ tet_printf( "Raise actor B Above Actor C but B not parented\n" );
+ DevelActor::Raise( actorB );
+
+ application.SendNotification();
+ application.Render();
+
+ application.ProcessEvent( touchEvent );
+
+ tet_printf( "Not parented so RaiseAbove should show no effect\n" );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+
+ tet_printf( "Raise actor B Above Actor C but B not parented\n" );
+ ResetTouchCallbacks();
+
+ DevelActor::Lower( actorC );
+ // 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" );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ ResetTouchCallbacks();
+
+ tet_printf( "Lower actor C below B but C not parented\n" );
+
+ DevelActor::Lower( actorB );
+ // 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" );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ ResetTouchCallbacks();
+
+ tet_printf( "Raise actor B to top\n" );
+
+ DevelActor::RaiseToTop( actorB );
+ // Sort actor tree before next touch event
+ application.SendNotification();
+ application.Render();
+
+ application.ProcessEvent( touchEvent );
+
+ tet_printf( "Not parented so RaiseToTop should show no effect\n" );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ ResetTouchCallbacks();
+
+ tet_printf( "Add ActorB to stage so only Actor C not parented\n" );
+
+ stage.Add ( actorB );
+
+ tet_printf( "Lower actor C to Bottom, B stays at top\n" );
+
+ DevelActor::LowerToBottom( actorC );
+ application.SendNotification();
+ application.Render();
+
+ application.ProcessEvent( touchEvent );
+
+ tet_printf( "Not parented so LowerToBottom should show no effect\n" );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ ResetTouchCallbacks();
+
+ END_TEST;
+}
+
+
+int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void)
+{
+ tet_infoline( "UtcDaliActor RaiseToAbove and test with actor provided as target resulting in a no operation \n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor actorA = Actor::New();
+ Actor actorB = Actor::New();
+ Actor actorC = Actor::New();
+
+ actorA.SetAnchorPoint( AnchorPoint::CENTER );
+ actorA.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorB.SetAnchorPoint( AnchorPoint::CENTER );
+ actorB.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorC.SetAnchorPoint( AnchorPoint::CENTER );
+ actorC.SetParentOrigin( ParentOrigin::CENTER );
+
+ actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+
+ 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 );
+
+ // 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 );
+ actorB.TouchSignal().Connect( TestTouchCallback2 );
+ actorC.TouchSignal().Connect( TestTouchCallback3 );
+
+ ResetTouchCallbacks();
+
+ application.SendNotification();
+ application.Render();
+
+ Dali::Integration::Point point;
+ point.SetDeviceId( 1 );
+ point.SetState( PointState::DOWN );
+ point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ Dali::Integration::TouchEvent touchEvent;
+ touchEvent.AddPoint( point );
+
+ application.ProcessEvent( touchEvent );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, true, TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ tet_infoline( "Raise actor A Above Actor A which is the same actor!!\n" );
+
+ DevelActor::RaiseAbove( actorA, actorA );
+ application.SendNotification();
+ application.Render();
+
+ application.ProcessEvent( touchEvent );
+
+ tet_infoline( "No target is source Actor so RaiseAbove should show no effect\n" );
+
+ DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+
+ ResetTouchCallbacks();
+
+ DevelActor::RaiseAbove( actorA, actorC );
+ 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 );
+ DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliActorGetScreenPosition(void)
+{
+ tet_infoline( "UtcDaliActorGetScreenPosition Get screen coordinates of Actor \n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor actorA = Actor::New();
+ actorA.SetAnchorPoint( AnchorPoint::CENTER );
+
+ Vector2 size2( 10.0f, 20.0f );
+ actorA.SetSize( size2 );
+
+ actorA.SetPosition( 0.f, 0.f );
+
+ tet_infoline( "UtcDaliActorGetScreenPosition Center Anchor Point and 0,0 position \n" );
+
+ stage.Add( actorA );
+
+ application.SendNotification();
+ application.Render();
+
+ Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
+ Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ tet_printf( "Actor World Position ( %f %f ) AnchorPoint::CENTER \n", actorWorldPosition.x, actorWorldPosition.y );
+ tet_printf( "Actor Screen Position %f %f \n", actorScreenPosition.x, actorScreenPosition.y );
+
+ DALI_TEST_EQUALS( actorScreenPosition.x, 0lu , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, 0lu , TEST_LOCATION );
+
+ tet_infoline( "UtcDaliActorGetScreenPosition Top Left Anchor Point and 0,0 position \n" );
+
+ actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+
+ application.SendNotification();
+ application.Render();
+
+ actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
+ actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT \n", actorWorldPosition.x, actorWorldPosition.y );
+ tet_printf( "Actor Screen Position ( %f %f ) AnchorPoint::TOP_LEFT \n", actorScreenPosition.x, actorScreenPosition.y );
+
+ DALI_TEST_EQUALS( actorScreenPosition.x, 0lu , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, 0lu , TEST_LOCATION );
+
+ tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 0,0 position \n" );
+
+ actorA.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+
+ application.SendNotification();
+ application.Render();
+
+ actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
+ actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n", actorWorldPosition.x, actorWorldPosition.y );
+ tet_printf( "Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n", actorScreenPosition.x, actorScreenPosition.y );
+
+ DALI_TEST_EQUALS( actorScreenPosition.x, 0lu , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, 0lu , TEST_LOCATION );
+
+ tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,0 position \n" );
+
+ actorA.SetPosition( 30.0, 0.0 );
+
+ application.SendNotification();
+ application.Render();
+
+ actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
+ actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0 \n", actorWorldPosition.x, actorWorldPosition.y );
+ tet_printf( "Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0 \n", actorScreenPosition.x, actorScreenPosition.y );
+
+ DALI_TEST_EQUALS( actorScreenPosition.x, 30lu , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, 0lu , TEST_LOCATION );
+
+ tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,420 position \n" );
+
+ actorA.SetPosition( 30.0, 420.0 );
+
+ application.SendNotification();
+ application.Render();
+
+ actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
+ actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ DALI_TEST_EQUALS( actorScreenPosition.x, 30lu , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, 420lu , TEST_LOCATION );
+
+ 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 );
+
+
+ END_TEST;
+}
+
+int UtcDaliActorGetScreenPositionAfterScaling(void)
+{
+ tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling Get screen coordinates of Actor \n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor actorA = Actor::New();
+ actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+
+ Vector2 size2( 10.0f, 20.0f );
+ actorA.SetSize( size2 );
+ actorA.SetScale( 1.5f );
+ actorA.SetPosition( 0.f, 0.f );
+
+ tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling TopRight Anchor Point, scale 1.5f and 0,0 position \n" );
+
+ stage.Add( actorA );
+
+ application.SendNotification();
+ application.Render();
+
+ Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
+ Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT \n", actorWorldPosition.x, actorWorldPosition.y );
+ tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+
+ DALI_TEST_EQUALS( actorScreenPosition.x, 0lu , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, 0lu , TEST_LOCATION );
+
+ tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling BOTTOM_RIGHT Anchor Point, scale 1.5f and 0,0 position \n" );
+
+ actorA.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+
+ application.SendNotification();
+ application.Render();
+
+ actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
+ actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n", actorWorldPosition.x, actorWorldPosition.y );
+ tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+
+ DALI_TEST_EQUALS( actorScreenPosition.x , 0.0f , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, 0.0f , TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliActorGetScreenPositionWithDifferentParentOrigin(void)
+{
+ tet_infoline( "UtcDaliActorGetScreenPositionWithDifferentParentOrigin Changes parent origin which should not effect result \n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor actorA = Actor::New();
+ actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+ actorA.SetParentOrigin( ParentOrigin::CENTER );
+ Vector2 size2( 10.0f, 20.0f );
+ actorA.SetSize( size2 );
+ actorA.SetPosition( 0.f, 0.f );
+
+ tet_infoline( " TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
+
+ stage.Add( actorA );
+
+ application.SendNotification();
+ application.Render();
+
+ Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
+ Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER \n", actorWorldPosition.x, actorWorldPosition.y );
+ tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+
+ DALI_TEST_EQUALS( actorScreenPosition.x, 240.0f , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, 400.0f , TEST_LOCATION );
+
+ tet_infoline( " BOTTOM_RIGHT Anchor Point, ParentOrigin::TOP_RIGHT and 0,0 position \n" );
+
+ actorA.SetParentOrigin( ParentOrigin::TOP_RIGHT );
+ actorA.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+
+ application.SendNotification();
+ application.Render();
+
+ actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
+ actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT ParentOrigin::TOP_RIGHT \n", actorWorldPosition.x, actorWorldPosition.y );
+ tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+
+ DALI_TEST_EQUALS( actorScreenPosition.x , 480.0f , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, 0.0f , TEST_LOCATION );
+
+ END_TEST;
+ END_TEST;
+}
+
+int UtcDaliActorGetScreenPositionWithChildActors(void)
+{
+ tet_infoline( "UtcDaliActorGetScreenPositionWithChildActors Check screen position with a tree of actors \n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ tet_infoline( "Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
+
+ Actor actorA = Actor::New();
+ actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+ actorA.SetParentOrigin( ParentOrigin::CENTER );
+ Vector2 size1( 10.0f, 20.0f );
+ actorA.SetSize( size1 );
+ actorA.SetPosition( 0.f, 0.f );
+
+ tet_infoline( "Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
+
+ Actor parentActorA = Actor::New();
+ parentActorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+ parentActorA.SetParentOrigin( ParentOrigin::CENTER );
+ Vector2 size2( 30.0f, 60.0f );
+ parentActorA.SetSize( size2 );
+ parentActorA.SetPosition( 0.f, 0.f );
+
+ tet_infoline( "Add child 1 to Parent 1 and check screen position \n" );
+
+ stage.Add( parentActorA );
+ parentActorA.Add ( actorA );
+
+ application.SendNotification();
+ application.Render();
+
+ Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
+ Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER \n", actorWorldPosition.x, actorWorldPosition.y );
+ tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+
+ DALI_TEST_EQUALS( actorScreenPosition.x, 255.0f , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, 430.0f , TEST_LOCATION );
+
+ tet_infoline( "Test 2\n");
+
+ tet_infoline( "change parent anchor point and parent origin then check screen position \n" );
+
+ parentActorA.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
+ parentActorA.SetParentOrigin( ParentOrigin::TOP_LEFT );
+
+ application.SendNotification();
+ application.Render();
+
+ actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
+ actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_LEFT ParentOrigin::TOP_LEFT \n", actorWorldPosition.x, actorWorldPosition.y );
+ tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+
+ DALI_TEST_EQUALS( actorScreenPosition.x, 15.0f , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, -30.0f , TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliActorGetScreenPositionWithChildActors02(void)
+{
+ tet_infoline( "UtcDaliActorGetScreenPositionWithChildActors02 Check screen position with a tree of actors \n" );
+
+ TestApplication application;
+
+ Stage stage( Stage::GetCurrent() );
+
+ tet_infoline( "Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
+
+ Actor actorA = Actor::New();
+ actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+ actorA.SetParentOrigin( ParentOrigin::CENTER );
+ Vector2 size1( 10.0f, 20.0f );
+ actorA.SetSize( size1 );
+ actorA.SetPosition( 0.f, 0.f );
+
+ tet_infoline( "Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
+
+ Actor parentActorA = Actor::New();
+ parentActorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+ parentActorA.SetParentOrigin( ParentOrigin::CENTER );
+ Vector2 size2( 30.0f, 60.0f );
+ parentActorA.SetSize( size2 );
+ parentActorA.SetPosition( 0.f, 0.f );
+
+ 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 );
+ grandParentActorA.SetParentOrigin( ParentOrigin::BOTTOM_LEFT );
+ Vector2 size3( 60.0f, 120.0f );
+ grandParentActorA.SetSize( size3 );
+ grandParentActorA.SetPosition( 0.f, 0.f );
+
+ tet_infoline( "Add Parent 1 to Grand Parent 1 \n" );
+
+ stage.Add( grandParentActorA );
+ grandParentActorA.Add ( parentActorA );
+
+ tet_infoline( "Add child 1 to Parent 1 and check screen position \n" );
+
+ parentActorA.Add ( actorA );
+
+ application.SendNotification();
+ application.Render();
+
+ Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
+ Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+ tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER \n", actorWorldPosition.x, actorWorldPosition.y );
+ tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+
+ DALI_TEST_EQUALS( actorScreenPosition.x, 45.0f , TEST_LOCATION );
+ DALI_TEST_EQUALS( actorScreenPosition.y, 770.0f , TEST_LOCATION );
+
+ 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;
+ tet_infoline( "Check default behaviour\n" );
+
+ Actor actor = Actor::New();
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetAnchorPoint( AnchorPoint::CENTER );
+ actor.SetSize( 100.0f, 100.0f );
+ Stage::GetCurrent().Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ tet_infoline( "Check that the world position is in the center\n" );
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+
+ tet_infoline( "Set the position uses anchor point property to false\n" );
+ actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
+
+ application.SendNotification();
+ application.Render();
+
+ tet_infoline( "Check that the world position has changed appropriately\n" );
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+
+ END_TEST;
+}
+
+int utcDaliActorPositionUsesAnchorPointCheckScale(void)
+{
+ TestApplication application;
+ tet_infoline( "Check that the scale is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
+
+ Actor actor = Actor::New();
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetAnchorPoint( AnchorPoint::CENTER );
+ actor.SetSize( 100.0f, 100.0f );
+ actor.SetScale( 2.0f );
+ actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
+ Stage::GetCurrent().Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ tet_infoline( "Check the world position is the same as it would be without a scale\n" );
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+
+ tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
+ actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 100.0f, 100.0f, 0.0f ), TEST_LOCATION );
+
+ tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
+ actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+
+ END_TEST;
+}
+
+int utcDaliActorPositionUsesAnchorPointCheckRotation(void)
+{
+ TestApplication application;
+ tet_infoline( "Check that the rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
+
+ Actor actor = Actor::New();
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetAnchorPoint( AnchorPoint::CENTER );
+ actor.SetSize( 100.0f, 100.0f );
+ actor.SetOrientation( Degree( 90.0f), Vector3::ZAXIS );
+ actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
+ Stage::GetCurrent().Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ tet_infoline( "Check the world position is the same as it would be without a rotation\n" );
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+
+ tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
+ actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( -50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+
+ tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
+ actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 150.0f, 50.0f, 0.0f ), TEST_LOCATION );
+
+ END_TEST;
+}
+
+int utcDaliActorPositionUsesAnchorPointCheckScaleAndRotation(void)
+{
+ TestApplication application;
+ tet_infoline( "Check that the scale and rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
+
+ Actor actor = Actor::New();
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetAnchorPoint( AnchorPoint::CENTER );
+ actor.SetSize( 100.0f, 100.0f );
+ actor.SetOrientation( Degree( 90.0f), Vector3::ZAXIS );
+ actor.SetScale( 2.0f );
+ actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
+ Stage::GetCurrent().Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ tet_infoline( "Check the world position is the same as it would be without a scale and rotation\n" );
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+
+ tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
+ actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( -100.0f, 100.0f, 0.0f ), TEST_LOCATION );
+
+ tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
+ actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 200.0f, 0.0f, 0.0f ), TEST_LOCATION );
+
+ END_TEST;
+}
+
+int utcDaliActorPositionUsesAnchorPointOnlyInheritPosition(void)
+{
+ TestApplication application;
+ tet_infoline( "Check that if not inheriting scale and position, then the position is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
+
+ Actor parent = Actor::New();
+
+ Stage::GetCurrent().Add( parent );
+ Vector2 stageSize( Stage::GetCurrent().GetSize() );
+
+ Actor actor = Actor::New();
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetAnchorPoint( AnchorPoint::CENTER );
+ actor.SetSize( 100.0f, 100.0f );
+ actor.SetInheritScale( false );
+ actor.SetInheritOrientation( false );
+ actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
+ parent.Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ const Vector3 expectedWorldPosition( -stageSize.width * 0.5f + 50.0f, -stageSize.height * 0.5f + 50.0f, 0.0f );
+
+ tet_infoline( "Check the world position is in the right place\n" );
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), expectedWorldPosition, TEST_LOCATION );
+
+ tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure world position hasn't changed" );
+ actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), expectedWorldPosition, TEST_LOCATION );
+
+ tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure world position hasn't changed" );
+ actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), expectedWorldPosition, TEST_LOCATION );
+
+ 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( DevelHandle::GetCurrentProperty< bool >( actor, 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( DevelHandle::GetCurrentProperty< bool >( actor, Actor::Property::VISIBLE ), true, TEST_LOCATION );
+
+ application.SendNotification();
+ application.Render( 1100 ); // After the animation
+
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< bool >( actor, Actor::Property::VISIBLE ), false, TEST_LOCATION );
+
+ END_TEST;
+}
projects / platform / core / uifw / dali-core.git / blobdiff