/*
- * 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/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/events/hover-event-integ.h>
#include <dali-test-suite-utils.h>
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::Integration::Point point;
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 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;
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 );
+
+ // 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 );
+
+ // 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;
}
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;
}
DALI_TEST_EQUALS( vector.a, actor.GetCurrentColor().a, 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;
}
{
TestApplication application;
- gTouchCallBackCalled = false;
+ ResetTouchCallbacks();
// get the root layer
Actor actor = Stage::GetCurrent().GetRootLayer();
Stage::GetCurrent().Add( actor );
- gTouchCallBackCalled = false;
+ ResetTouchCallbacks();
unsigned int index = 0;
while( NULL != hitTestData[index] )
hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y,
hitTestData[index]->mResult );
- gTouchCallBackCalled = false;
+ ResetTouchCallbacks();
++index;
}
END_TEST;
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)
// b (9)
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;
{ "minimumSize", Actor::Property::MINIMUM_SIZE, Property::VECTOR2 },
{ "maximumSize", Actor::Property::MAXIMUM_SIZE, Property::VECTOR2 },
{ "inheritPosition", Actor::Property::INHERIT_POSITION, Property::BOOLEAN },
- { "batchParent", Actor::Property::BATCH_PARENT, 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 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");
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
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 event;
+ event.AddPoint( point );
+
+ application.ProcessEvent( event );
+
+ 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 );
+
+ value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
+ value.Get( postActorOrder );
+
+ tet_printf( "Raised ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder );
+
+ application.ProcessEvent( event );
+
+ 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 );
+
+ value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
+ value.Get( postActorOrder );
+
+ tet_printf( "Lowered ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder );
+
+ application.ProcessEvent( event );
+
+ 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 event;
+ event.AddPoint( point );
+
+ application.ProcessEvent( event );
+
+ 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.ProcessEvent( 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 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.ProcessEvent( 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 );
+
+ 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( 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 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 UtcDaliActorRaiseAboveLowerBelow(void)
+{
+ tet_infoline( "UtcDaliActor RaiseToAbove and LowerBelow 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 event;
+ event.AddPoint( point );
+
+ application.ProcessEvent( event );
+
+ 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 );
+
+ application.ProcessEvent( event );
+
+ 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 );
+
+ application.ProcessEvent( event );
+
+ 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 event;
+ event.AddPoint( point );
+
+ tet_infoline( "UtcDaliActor Test Set up completed \n" );
+
+ application.ProcessEvent( event );
+
+ 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 );
+
+ application.SendNotification();
+ application.Render();
+
+ application.ProcessEvent( 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 );
+
+ 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 );
+
+ application.SendNotification();
+ application.Render();
+
+ application.ProcessEvent( event );
+
+ 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 );
+
+ 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();
+
+ END_TEST;
+}
+
+int UtcDaliActorMaxSiblingOrder(void)
+{
+ tet_infoline( "UtcDaliActor De-fragment of sibling order once max index reached\n" );
+
+ TestApplication application;
+
+ int testOrders[] = { 0,1,3,5,17,998, 999 };
+ int resultingOrders[] = { 0,1,2,3,4,6,5 };
+
+ const int TEST_ORDERS_COUNT = sizeof( testOrders ) / sizeof( testOrders[0] );
+
+ Stage stage( Stage::GetCurrent() );
+
+ Actor parent = Actor::New();
+
+ for ( int index = 0; index < TEST_ORDERS_COUNT; index++ )
+ {
+ Actor newActor = Actor::New();
+ newActor.SetProperty(Dali::DevelActor::Property::SIBLING_ORDER, testOrders[index] );
+ parent.Add( newActor );
+ }
+ stage.Add( parent );
+
+ tet_printf( "Sibling Order %d children :", parent.GetChildCount() );
+ for ( unsigned int index = 0; index < parent.GetChildCount(); index ++)
+ {
+ Actor sibling = parent.GetChildAt( index );
+ int siblingOrder = 0;
+ Property::Value value = sibling.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
+ value.Get( siblingOrder );
+ tet_printf( "%d, ", siblingOrder );
+ }
+ tet_printf( "\n" );
+
+ Actor sibling = parent.GetChildAt( 5 );
+ DevelActor::RaiseToTop( sibling );
+
+ application.SendNotification();
+ application.Render();
+
+ tet_printf( "Sibling Order %d children :", parent.GetChildCount() );
+ for ( unsigned int index = 0; index < parent.GetChildCount(); index ++)
+ {
+ Actor sibling = parent.GetChildAt( index );
+ int siblingOrder = 0;
+ Property::Value value = sibling.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
+ value.Get( siblingOrder );
+ tet_printf( "%d, ", siblingOrder );
+ DALI_TEST_EQUALS( siblingOrder, resultingOrders[ index] , TEST_LOCATION );
+ }
+
+ tet_printf( "\n" );
+
+ END_TEST;
+}
projects / platform / core / uifw / dali-core.git / blobdiff