namespace
{
-
bool gTouchCallBackCalled=false;
bool gTouchCallBack2Called=false;
bool gHoverCallBackCalled=false;
}
catch(Dali::DaliException& e)
{
- tet_printf("Assertion %s test at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+ DALI_TEST_PRINT_ASSERT( e );
DALI_TEST_ASSERT(e, "this != &child", TEST_LOCATION);
DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
}
}
catch(Dali::DaliException& e)
{
- tet_printf("Assertion %s test at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+ DALI_TEST_PRINT_ASSERT( e );
DALI_TEST_ASSERT(e, "!child.IsRoot()", TEST_LOCATION);
DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
}
}
catch(Dali::DaliException& e)
{
- tet_printf("Assertion %s test at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+ DALI_TEST_PRINT_ASSERT( e );
DALI_TEST_ASSERT(e, "actor", TEST_LOCATION);
DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
}
}
catch(Dali::DaliException& e)
{
- tet_printf("Assertion %s test at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+ DALI_TEST_PRINT_ASSERT( e );
DALI_TEST_ASSERT(e, "this != &child", TEST_LOCATION);
DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
}
}
catch(Dali::DaliException& e)
{
- tet_printf("Assertion %s test at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+ DALI_TEST_PRINT_ASSERT( e );
DALI_TEST_ASSERT(e, "actor", TEST_LOCATION);
DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
}
Actor actor = Actor::New();
Vector3 vector(100.0f, 100.0f, 20.0f);
- DALI_TEST_CHECK(vector != actor.GetSize());
+ DALI_TEST_CHECK(vector != actor.GetTargetSize());
DALI_TEST_CHECK(vector != actor.GetCurrentSize());
actor.SetSize(vector);
- DALI_TEST_CHECK(vector == actor.GetSize());
+ DALI_TEST_CHECK(vector == actor.GetTargetSize());
DALI_TEST_CHECK(vector != actor.GetCurrentSize());
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetSize());
+ DALI_TEST_CHECK(vector == actor.GetTargetSize());
DALI_TEST_CHECK(vector == actor.GetCurrentSize());
// Animation
const float durationSeconds = 2.0f;
Animation animation = Animation::New( durationSeconds );
const Vector3 targetValue( 10.0f, 20.0f, 30.0f );
- animation.AnimateTo( Property( actor, Actor::SIZE ), targetValue );
+ animation.AnimateTo( Property( actor, Actor::Property::SIZE ), targetValue );
- DALI_TEST_CHECK( actor.GetSize() == targetValue );
+ DALI_TEST_CHECK( actor.GetTargetSize() == targetValue );
// Start the animation
animation.Play();
application.SendNotification();
application.Render( static_cast<unsigned int>( durationSeconds * 1000.0f ) );
- DALI_TEST_CHECK( actor.GetSize() == targetValue );
+ DALI_TEST_CHECK( actor.GetTargetSize() == targetValue );
END_TEST;
}
application.Render();
DALI_TEST_EQUALS( Vector3( 1.0f, 1.1f, 1.2f ), actor.GetCurrentPosition(), TEST_LOCATION );
- actor.MoveBy( Vector3( 0.1f, 0.1f, 0.1f ) );
+ actor.TranslateBy( Vector3( 0.1f, 0.1f, 0.1f ) );
// flush the queue and render once
application.SendNotification();
application.Render();
END_TEST;
}
-int UtcDaliActorMoveBy(void)
+int UtcDaliActorTranslateBy(void)
{
TestApplication application;
DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
- actor.MoveBy(vector);
+ actor.TranslateBy(vector);
// flush the queue and render once
application.SendNotification();
END_TEST;
}
-// SetRotation(float angleRadians, Vector3 axis)
-int UtcDaliActorSetRotation01(void)
+// SetOrientation(float angleRadians, Vector3 axis)
+int UtcDaliActorSetOrientation01(void)
{
TestApplication application;
Quaternion rotation(0.785f, Vector3(1.0f, 1.0f, 0.0f));
Actor actor = Actor::New();
- actor.SetRotation(rotation);
+ actor.SetOrientation(rotation);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(rotation, actor.GetCurrentRotation(), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
END_TEST;
}
-int UtcDaliActorSetRotation02(void)
+int UtcDaliActorSetOrientation02(void)
{
TestApplication application;
float angle = 0.785f;
Vector3 axis(1.0f, 1.0f, 0.0f);
- actor.SetRotation(Radian( angle ), axis);
+ actor.SetOrientation(Radian( angle ), axis);
Quaternion rotation( angle, axis );
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(rotation, actor.GetCurrentRotation(), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
Stage::GetCurrent().Add( actor );
actor.RotateBy( Degree( 360 ), axis);
- DALI_TEST_EQUALS(rotation, actor.GetCurrentRotation(), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
- actor.SetRotation( Degree( 0 ), Vector3( 1.0f, 0.0f, 0.0f ) );
+ actor.SetOrientation( Degree( 0 ), Vector3( 1.0f, 0.0f, 0.0f ) );
Quaternion result( 0, Vector3( 1.0f, 0.0f, 0.0f ) );
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( result, actor.GetCurrentRotation(), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS( result, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
- actor.SetRotation(Radian( angle ), axis);
+ actor.SetOrientation(Radian( angle ), axis);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(rotation, actor.GetCurrentRotation(), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
Stage::GetCurrent().Remove( actor );
END_TEST;
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(Quaternion(M_PI*0.25f, Vector3::ZAXIS), actor.GetCurrentRotation(), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(Quaternion(M_PI*0.25f, Vector3::ZAXIS), actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
Stage::GetCurrent().Add( actor );
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(Quaternion(M_PI*0.5f, Vector3::ZAXIS), actor.GetCurrentRotation(), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(Quaternion(M_PI*0.5f, Vector3::ZAXIS), actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
Stage::GetCurrent().Remove( actor );
END_TEST;
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(rotation, actor.GetCurrentRotation(), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
actor.RotateBy(rotation);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(Quaternion(M_PI*0.5f, Vector3::ZAXIS), actor.GetCurrentRotation(), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(Quaternion(M_PI*0.5f, Vector3::ZAXIS), actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
END_TEST;
}
-int UtcDaliActorGetCurrentRotation(void)
+int UtcDaliActorGetCurrentOrientation(void)
{
TestApplication application;
Actor actor = Actor::New();
Quaternion rotation(0.785f, Vector3(1.0f, 1.0f, 0.0f));
- actor.SetRotation(rotation);
+ actor.SetOrientation(rotation);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(rotation, actor.GetCurrentRotation(), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
END_TEST;
}
-int UtcDaliActorGetCurrentWorldRotation(void)
+int UtcDaliActorGetCurrentWorldOrientation(void)
{
tet_infoline("Testing Actor::GetCurrentWorldRotation");
TestApplication application;
Actor parent = Actor::New();
Radian rotationAngle( Degree(90.0f) );
Quaternion rotation( rotationAngle, Vector3::YAXIS );
- parent.SetRotation( rotation );
+ parent.SetOrientation( rotation );
Stage::GetCurrent().Add( parent );
Actor child = Actor::New();
- child.SetRotation( rotation );
+ child.SetOrientation( rotation );
parent.Add( child );
// The actors should not have a world rotation yet
- DALI_TEST_EQUALS( parent.GetCurrentWorldRotation(), Quaternion(0.0f, Vector3::YAXIS), 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentWorldRotation(), Quaternion(0.0f, Vector3::YAXIS), 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS( parent.GetCurrentWorldOrientation(), Quaternion(0.0f, Vector3::YAXIS), 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS( child.GetCurrentWorldOrientation(), Quaternion(0.0f, Vector3::YAXIS), 0.001, TEST_LOCATION );
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( parent.GetCurrentRotation(), rotation, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentRotation(), rotation, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS( parent.GetCurrentOrientation(), rotation, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS( child.GetCurrentOrientation(), rotation, 0.001, TEST_LOCATION );
// The actors should have a world rotation now
- DALI_TEST_EQUALS( parent.GetCurrentWorldRotation(), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentWorldRotation(), Quaternion( rotationAngle * 2.0f, Vector3::YAXIS ), 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS( parent.GetCurrentWorldOrientation(), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS( child.GetCurrentWorldOrientation(), Quaternion( rotationAngle * 2.0f, Vector3::YAXIS ), 0.001, TEST_LOCATION );
// turn off child rotation inheritance
- child.SetInheritRotation( false );
- DALI_TEST_EQUALS( child.IsRotationInherited(), false, TEST_LOCATION );
+ child.SetInheritOrientation( false );
+ DALI_TEST_EQUALS( child.IsOrientationInherited(), false, TEST_LOCATION );
application.SendNotification();
application.Render(0);
// The actors should have a world rotation now
- DALI_TEST_EQUALS( parent.GetCurrentWorldRotation(), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentWorldRotation(), rotation, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS( parent.GetCurrentWorldOrientation(), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS( child.GetCurrentWorldOrientation(), rotation, 0.001, TEST_LOCATION );
END_TEST;
}
DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.4f, TEST_LOCATION );
// change opacity, actor is on stage to change is not immediate
- actor.OpacityBy( 0.1f );
+ actor.SetOpacity( actor.GetCurrentOpacity() + 0.1f );
// flush the queue and render once
application.SendNotification();
application.Render();
DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.9f, TEST_LOCATION );
// change opacity, actor is on stage to change is not immediate
- actor.OpacityBy( -0.9f );
+ actor.SetOpacity( actor.GetCurrentOpacity() - 0.9f );
// flush the queue and render once
application.SendNotification();
application.Render();
application.Render();
DALI_TEST_CHECK(color == actor.GetCurrentColor());
- actor.ColorBy( Vector4( -0.4f, -0.5f, -0.6f, -0.4f ) );
+ actor.SetColor( actor.GetCurrentColor() + Vector4( -0.4f, -0.5f, -0.6f, -0.4f ) );
// flush the queue and render once
application.SendNotification();
application.Render();
application.Render();
DALI_TEST_EQUALS( color, actor.GetCurrentColor(), TEST_LOCATION );
- actor.ColorBy( Vector4( 1.1f, 1.1f, 1.1f, 1.1f ) );
+ actor.SetColor( actor.GetCurrentColor() + Vector4( 1.1f, 1.1f, 1.1f, 1.1f ) );
// flush the queue and render once
application.SendNotification();
application.Render();
Actor actor = Actor::New();
- Constraint constraint = Constraint::New<Vector4>( Actor::COLOR, TestConstraint() );
+ Constraint constraint = Constraint::New<Vector4>( Actor::Property::COLOR, TestConstraint() );
actor.ApplyConstraint(constraint);
DALI_TEST_CHECK( gTestConstraintCalled == false );
parent.SetSize( parentSize );
Stage::GetCurrent().Add( parent );
- Constraint constraint = Constraint::New<Vector3>( Actor::SIZE,
- Source( parent, Actor::SIZE ),
+ Constraint constraint = Constraint::New<Vector3>( Actor::Property::SIZE,
+ Source( parent, Actor::Property::SIZE ),
EqualToConstraint() );
// Create some child actors
activeConstraint3.AppliedSignal().Connect( TestConstraintCallback3 );
// Check event-side size
- DALI_TEST_EQUALS( child1.GetSize(), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( child2.GetSize(), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( child3.GetSize(), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS( child1.GetTargetSize(), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS( child2.GetTargetSize(), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS( child3.GetTargetSize(), Vector3::ZERO, TEST_LOCATION );
DALI_TEST_EQUALS( child1.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
DALI_TEST_EQUALS( child2.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
Actor actor = Actor::New();
- Constraint constraint = Constraint::New<Vector4>( Actor::COLOR, TestConstraint() );
+ Constraint constraint = Constraint::New<Vector4>( Actor::Property::COLOR, TestConstraint() );
actor.ApplyConstraint(constraint);
actor.RemoveConstraints();
// 1. Apply Constraint1 and Constraint2, and test...
unsigned int result1 = 0u;
unsigned int result2 = 0u;
- ActiveConstraint activeConstraint1 = actor.ApplyConstraint( Constraint::New<Vector4>( Actor::COLOR, TestConstraintRef<Vector4>(result1, 1) ) );
- ActiveConstraint activeConstraint2 = actor.ApplyConstraint( Constraint::New<Vector4>( Actor::COLOR, TestConstraintRef<Vector4>(result2, 2) ) );
+ ActiveConstraint activeConstraint1 = actor.ApplyConstraint( Constraint::New<Vector4>( Actor::Property::COLOR, TestConstraintRef<Vector4>(result1, 1) ) );
+ ActiveConstraint activeConstraint2 = actor.ApplyConstraint( Constraint::New<Vector4>( Actor::Property::COLOR, TestConstraintRef<Vector4>(result2, 2) ) );
Stage::GetCurrent().Add( actor );
// flush the queue and render once
// 3. Re-Apply Constraint1 and test...
result1 = 0;
result2 = 0;
- activeConstraint1 = actor.ApplyConstraint( Constraint::New<Vector4>( Actor::COLOR, TestConstraintRef<Vector4>(result1, 1) ) );
+ activeConstraint1 = actor.ApplyConstraint( Constraint::New<Vector4>( Actor::Property::COLOR, TestConstraintRef<Vector4>(result1, 1) ) );
// make color property dirty, which will trigger constraints to be reapplied.
actor.SetColor( Color::WHITE );
// flush the queue and render once
unsigned int result2 = 0u;
unsigned constraint1Tag = 1u;
- Constraint constraint1 = Constraint::New<Vector4>( Actor::COLOR, TestConstraintRef<Vector4>(result1, 1) );
+ Constraint constraint1 = Constraint::New<Vector4>( Actor::Property::COLOR, TestConstraintRef<Vector4>(result1, 1) );
constraint1.SetTag( constraint1Tag );
actor.ApplyConstraint( constraint1 );
unsigned constraint2Tag = 2u;
- Constraint constraint2 = Constraint::New<Vector4>( Actor::COLOR, TestConstraintRef<Vector4>(result2, 2) );
+ Constraint constraint2 = Constraint::New<Vector4>( Actor::Property::COLOR, TestConstraintRef<Vector4>(result2, 2) );
constraint2.SetTag( constraint2Tag );
actor.ApplyConstraint( constraint2 );
END_TEST;
}
-int UtcDaliActorSetSizeSignal(void)
-{
- TestApplication application;
-
- Actor actor = Actor::New();
- actor.SetSizeSignal().Connect( SetSizeCallback );
-
- gSetSize.x = gSetSize.y = gSetSize.z = 0.0f;
- gSetSizeCallBackCalled = false;
- Vector2 size2d( 1.0f, 2.0f );
- actor.SetSize( size2d );
- DALI_TEST_CHECK( gSetSizeCallBackCalled == true );
- // SetSize with Vector2 sets depth to be the minimum of width & height
- DALI_TEST_EQUALS( Vector3( 1.0f, 2.0f, 1.0f ), gSetSize, TEST_LOCATION );
-
- gSetSize.x = gSetSize.y = gSetSize.z = 0.0f;
- gSetSizeCallBackCalled = false;
- actor.SetSize( 22.0f, 11.0f );
- DALI_TEST_CHECK( gSetSizeCallBackCalled == true );
- // SetSize with Vector2 sets depth to be the minimum of width & height
- DALI_TEST_EQUALS( Vector3( 22.0f, 11.0f, 11.0f ), gSetSize, TEST_LOCATION );
-
- gSetSize.x = gSetSize.y = gSetSize.z = 0.0f;
- gSetSizeCallBackCalled = false;
- Vector3 size( 3.0f, 4.0f, 5.0f );
- actor.SetSize( size );
- DALI_TEST_CHECK( gSetSizeCallBackCalled == true );
- DALI_TEST_EQUALS( size, gSetSize, TEST_LOCATION );
-
- // add actor to stage to see that signal still works
- Stage::GetCurrent().Add( actor );
-
- gSetSize.x = gSetSize.y = gSetSize.z = 0.0f;
- gSetSizeCallBackCalled = false;
- actor.SetSize( -1.0f, -2.0f, -3.0f );
- DALI_TEST_CHECK( gSetSizeCallBackCalled == true );
- DALI_TEST_EQUALS( Vector3( -1.0f, -2.0f, -3.0f ), gSetSize, TEST_LOCATION );
- END_TEST;
-}
-
int UtcDaliActorOnOffStageSignal(void)
{
tet_infoline("Testing Dali::Actor::OnStageSignal() and OffStageSignal()");
END_TEST;
}
-int UtcDaliActorFindChildByAlias(void)
-{
- tet_infoline("Testing Dali::Actor::FindChildByAlias()");
- TestApplication application;
-
- Actor parent = Actor::New();
- parent.SetName( "parent" );
- Actor first = Actor::New();
- first .SetName( "first" );
- Actor second = Actor::New();
- second.SetName( "second" );
-
- parent.Add(first);
- first.Add(second);
-
- Actor found = parent.FindChildByAlias( "foo" );
- DALI_TEST_CHECK( !found );
-
- found = parent.FindChildByAlias( "parent" );
- DALI_TEST_CHECK( found == parent );
-
- found = parent.FindChildByAlias( "first" );
- DALI_TEST_CHECK( found == first );
-
- found = parent.FindChildByAlias( "second" );
- DALI_TEST_CHECK( found == second );
- END_TEST;
-}
-
int UtcDaliActorFindChildById(void)
{
tet_infoline("Testing Dali::Actor::UtcDaliActorFindChildById()");
ids.push_back( 10 ); // third rendered actor
app.GetGlAbstraction().SetNextTextureIds( ids );
- BitmapImage imageA = BitmapImage::New(16, 16);
- BitmapImage imageB = BitmapImage::New(16, 16);
- BitmapImage imageC = BitmapImage::New(16, 16);
+ 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 );
TestApplication app;
tet_infoline(" UtcDaliActorSetDrawModeOverlayHitTest");
- BitmapImage imageA = BitmapImage::New(16, 16);
- BitmapImage imageB = BitmapImage::New(16, 16);
+ BufferImage imageA = BufferImage::New(16, 16);
+ BufferImage imageB = BufferImage::New(16, 16);
ImageActor a = ImageActor::New( imageA );
ImageActor b = ImageActor::New( imageB );
Stage::GetCurrent().Add(a);
Stage::GetCurrent().Add(b);
- a.SetSize(Vector2(100.0f, 100.0f));
- b.SetSize(Vector2(100.0f, 100.0f));
+ a.SetSize( 100.0f, 100.0f );
+ b.SetSize( 100.0f, 100.0f );
// position b overlapping a. (regular non-overlays)
// hit test at point 'x'
Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
Vector3 parentScale( 1.0f, 2.0f, 3.0f );
parent.SetPosition( parentPosition );
- parent.SetRotation( parentRotation );
+ parent.SetOrientation( parentRotation );
parent.SetScale( parentScale );
Stage::GetCurrent().Add( parent );
Quaternion childRotation( childRotationAngle, Vector3::YAXIS );
Vector3 childScale( 2.0f, 2.0f, 2.0f );
child.SetPosition( childPosition );
- child.SetRotation( childRotation );
+ child.SetOrientation( childRotation );
child.SetScale( childScale );
parent.Add( child );
Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
Vector3 parentScale( 1.0f, 2.0f, 3.0f );
parent.SetPosition( parentPosition );
- parent.SetRotation( parentRotation );
+ parent.SetOrientation( parentRotation );
parent.SetScale( parentScale );
Stage::GetCurrent().Add( parent );
Actor child = Actor::New();
child.SetParentOrigin(ParentOrigin::CENTER);
- Constraint posConstraint = Constraint::New<Vector3>( Actor::POSITION, Source( parent, Actor::WORLD_MATRIX), PositionComponentConstraint() );
+ Constraint posConstraint = Constraint::New<Vector3>( Actor::Property::POSITION, Source( parent, Actor::Property::WORLD_MATRIX), PositionComponentConstraint() );
child.ApplyConstraint(posConstraint);
Stage::GetCurrent().Add( child );
const PropertyStringIndex PROPERTY_TABLE[] =
{
- { "parent-origin", Actor::PARENT_ORIGIN, Property::VECTOR3 },
- { "parent-origin-x", Actor::PARENT_ORIGIN_X, Property::FLOAT },
- { "parent-origin-y", Actor::PARENT_ORIGIN_Y, Property::FLOAT },
- { "parent-origin-z", Actor::PARENT_ORIGIN_Z, Property::FLOAT },
- { "anchor-point", Actor::ANCHOR_POINT, Property::VECTOR3 },
- { "anchor-point-x", Actor::ANCHOR_POINT_X, Property::FLOAT },
- { "anchor-point-y", Actor::ANCHOR_POINT_Y, Property::FLOAT },
- { "anchor-point-z", Actor::ANCHOR_POINT_Z, Property::FLOAT },
- { "size", Actor::SIZE, Property::VECTOR3 },
- { "size-width", Actor::SIZE_WIDTH, Property::FLOAT },
- { "size-height", Actor::SIZE_HEIGHT, Property::FLOAT },
- { "size-depth", Actor::SIZE_DEPTH, Property::FLOAT },
- { "position", Actor::POSITION, Property::VECTOR3 },
- { "position-x", Actor::POSITION_X, Property::FLOAT },
- { "position-y", Actor::POSITION_Y, Property::FLOAT },
- { "position-z", Actor::POSITION_Z, Property::FLOAT },
- { "world-position", Actor::WORLD_POSITION, Property::VECTOR3 },
- { "world-position-x", Actor::WORLD_POSITION_X, Property::FLOAT },
- { "world-position-y", Actor::WORLD_POSITION_Y, Property::FLOAT },
- { "world-position-z", Actor::WORLD_POSITION_Z, Property::FLOAT },
- { "rotation", Actor::ROTATION, Property::ROTATION },
- { "world-rotation", Actor::WORLD_ROTATION, Property::ROTATION },
- { "scale", Actor::SCALE, Property::VECTOR3 },
- { "scale-x", Actor::SCALE_X, Property::FLOAT },
- { "scale-y", Actor::SCALE_Y, Property::FLOAT },
- { "scale-z", Actor::SCALE_Z, Property::FLOAT },
- { "world-scale", Actor::WORLD_SCALE, Property::VECTOR3 },
- { "visible", Actor::VISIBLE, Property::BOOLEAN },
- { "color", Actor::COLOR, Property::VECTOR4 },
- { "color-red", Actor::COLOR_RED, Property::FLOAT },
- { "color-green", Actor::COLOR_GREEN, Property::FLOAT },
- { "color-blue", Actor::COLOR_BLUE, Property::FLOAT },
- { "color-alpha", Actor::COLOR_ALPHA, Property::FLOAT },
- { "world-color", Actor::WORLD_COLOR, Property::VECTOR4 },
- { "world-matrix", Actor::WORLD_MATRIX, Property::MATRIX },
- { "name", Actor::NAME, Property::STRING },
- { "sensitive", Actor::SENSITIVE, Property::BOOLEAN },
- { "leave-required", Actor::LEAVE_REQUIRED, Property::BOOLEAN },
- { "inherit-rotation", Actor::INHERIT_ROTATION, Property::BOOLEAN },
- { "inherit-scale", Actor::INHERIT_SCALE, Property::BOOLEAN },
- { "color-mode", Actor::COLOR_MODE, Property::STRING },
- { "position-inheritance", Actor::POSITION_INHERITANCE, Property::STRING },
- { "draw-mode", Actor::DRAW_MODE, Property::STRING },
+ { "parent-origin", Actor::Property::PARENT_ORIGIN, Property::VECTOR3 },
+ { "parent-origin-x", Actor::Property::PARENT_ORIGIN_X, Property::FLOAT },
+ { "parent-origin-y", Actor::Property::PARENT_ORIGIN_Y, Property::FLOAT },
+ { "parent-origin-z", Actor::Property::PARENT_ORIGIN_Z, Property::FLOAT },
+ { "anchor-point", Actor::Property::ANCHOR_POINT, Property::VECTOR3 },
+ { "anchor-point-x", Actor::Property::ANCHOR_POINT_X, Property::FLOAT },
+ { "anchor-point-y", Actor::Property::ANCHOR_POINT_Y, Property::FLOAT },
+ { "anchor-point-z", Actor::Property::ANCHOR_POINT_Z, Property::FLOAT },
+ { "size", Actor::Property::SIZE, Property::VECTOR3 },
+ { "size-width", Actor::Property::SIZE_WIDTH, Property::FLOAT },
+ { "size-height", Actor::Property::SIZE_HEIGHT, Property::FLOAT },
+ { "size-depth", Actor::Property::SIZE_DEPTH, Property::FLOAT },
+ { "position", Actor::Property::POSITION, Property::VECTOR3 },
+ { "position-x", Actor::Property::POSITION_X, Property::FLOAT },
+ { "position-y", Actor::Property::POSITION_Y, Property::FLOAT },
+ { "position-z", Actor::Property::POSITION_Z, Property::FLOAT },
+ { "world-position", Actor::Property::WORLD_POSITION, Property::VECTOR3 },
+ { "world-position-x", Actor::Property::WORLD_POSITION_X, Property::FLOAT },
+ { "world-position-y", Actor::Property::WORLD_POSITION_Y, Property::FLOAT },
+ { "world-position-z", Actor::Property::WORLD_POSITION_Z, Property::FLOAT },
+ { "orientation", Actor::Property::ORIENTATION, Property::ROTATION },
+ { "world-orientation", Actor::Property::WORLD_ORIENTATION, Property::ROTATION },
+ { "scale", Actor::Property::SCALE, Property::VECTOR3 },
+ { "scale-x", Actor::Property::SCALE_X, Property::FLOAT },
+ { "scale-y", Actor::Property::SCALE_Y, Property::FLOAT },
+ { "scale-z", Actor::Property::SCALE_Z, Property::FLOAT },
+ { "world-scale", Actor::Property::WORLD_SCALE, Property::VECTOR3 },
+ { "visible", Actor::Property::VISIBLE, Property::BOOLEAN },
+ { "color", Actor::Property::COLOR, Property::VECTOR4 },
+ { "color-red", Actor::Property::COLOR_RED, Property::FLOAT },
+ { "color-green", Actor::Property::COLOR_GREEN, Property::FLOAT },
+ { "color-blue", Actor::Property::COLOR_BLUE, Property::FLOAT },
+ { "color-alpha", Actor::Property::COLOR_ALPHA, Property::FLOAT },
+ { "world-color", Actor::Property::WORLD_COLOR, Property::VECTOR4 },
+ { "world-matrix", Actor::Property::WORLD_MATRIX, Property::MATRIX },
+ { "name", Actor::Property::NAME, Property::STRING },
+ { "sensitive", Actor::Property::SENSITIVE, Property::BOOLEAN },
+ { "leave-required", Actor::Property::LEAVE_REQUIRED, Property::BOOLEAN },
+ { "inherit-orientation", Actor::Property::INHERIT_ORIENTATION, Property::BOOLEAN },
+ { "inherit-scale", Actor::Property::INHERIT_SCALE, Property::BOOLEAN },
+ { "color-mode", Actor::Property::COLOR_MODE, Property::STRING },
+ { "position-inheritance", Actor::Property::POSITION_INHERITANCE, Property::STRING },
+ { "draw-mode", Actor::Property::DRAW_MODE, Property::STRING },
+ { "size-mode-factor", Actor::Property::SIZE_MODE_FACTOR, Property::VECTOR3 },
+ { "relayout-enabled", Actor::Property::RELAYOUT_ENABLED, Property::BOOLEAN },
+ { "width-resize-policy", Actor::Property::WIDTH_RESIZE_POLICY, Property::STRING },
+ { "height-resize-policy", Actor::Property::HEIGHT_RESIZE_POLICY, Property::STRING },
+ { "size-scale-policy", Actor::Property::SIZE_SCALE_POLICY, Property::STRING },
+ { "width-for-height", Actor::Property::WIDTH_FOR_HEIGHT, Property::BOOLEAN },
+ { "height-for-width", Actor::Property::HEIGHT_FOR_WIDTH, Property::BOOLEAN },
+ { "padding", Actor::Property::PADDING, Property::VECTOR4 },
+ { "minimum-size", Actor::Property::MINIMUM_SIZE, Property::VECTOR2 },
+ { "maximum-size", Actor::Property::MAXIMUM_SIZE, Property::VECTOR2 },
};
const unsigned int PROPERTY_TABLE_COUNT = sizeof( PROPERTY_TABLE ) / sizeof( PROPERTY_TABLE[0] );
} // unnamed namespace
}
END_TEST;
}
+
+int UtcDaliRelayoutProperties_RelayoutEnabled(void)
+{
+ TestApplication app;
+
+ Actor actor = Actor::New();
+
+ // Defaults
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::RELAYOUT_ENABLED ).Get< bool >(), false, TEST_LOCATION );
+
+ // Set relayout disabled
+ actor.SetProperty( Actor::Property::RELAYOUT_ENABLED, false );
+
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::RELAYOUT_ENABLED ).Get< bool >(), false, TEST_LOCATION );
+
+ // Set relayout enabled
+ actor.SetProperty( Actor::Property::RELAYOUT_ENABLED, true );
+
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::RELAYOUT_ENABLED ).Get< bool >(), true, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliRelayoutProperties_ResizePolicies(void)
+{
+ TestApplication app;
+
+ Actor actor = Actor::New();
+
+ // Defaults
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_RESIZE_POLICY ).Get< std::string >(), "FIXED", TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_RESIZE_POLICY ).Get< std::string >(), "FIXED", TEST_LOCATION );
+
+ // Set resize policy for all dimensions
+ actor.SetResizePolicy( USE_NATURAL_SIZE, ALL_DIMENSIONS );
+ for( unsigned int i = 0; i < DIMENSION_COUNT; ++i)
+ {
+ DALI_TEST_EQUALS( actor.GetResizePolicy( static_cast< Dimension >( 1 << i ) ), USE_NATURAL_SIZE, TEST_LOCATION );
+ }
+
+ // Set individual dimensions
+ const char* const widthPolicy = "FILL_TO_PARENT";
+ const char* const heightPolicy = "FIXED";
+
+ actor.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, widthPolicy );
+ actor.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, heightPolicy );
+
+ 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 );
+
+ END_TEST;
+}
+
+int UtcDaliRelayoutProperties_SizeScalePolicy(void)
+{
+ TestApplication app;
+
+ Actor actor = Actor::New();
+
+ // Defaults
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_SCALE_POLICY ).Get< std::string >(), "USE_SIZE_SET", TEST_LOCATION );
+
+ // Set
+ const char* const policy1 = "FIT_WITH_ASPECT_RATIO";
+ const char* const policy2 = "FILL_WITH_ASPECT_RATIO";
+
+ actor.SetProperty( Actor::Property::SIZE_SCALE_POLICY, policy1 );
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_SCALE_POLICY ).Get< std::string >(), policy1, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::SIZE_SCALE_POLICY, policy2 );
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_SCALE_POLICY ).Get< std::string >(), policy2, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliRelayoutProperties_DimensionDependency(void)
+{
+ TestApplication app;
+
+ Actor actor = Actor::New();
+
+ // Defaults
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_FOR_HEIGHT ).Get< bool >(), false, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_FOR_WIDTH ).Get< bool >(), false, TEST_LOCATION );
+
+ // Set
+ actor.SetProperty( Actor::Property::WIDTH_FOR_HEIGHT, true );
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_FOR_HEIGHT ).Get< bool >(), true, TEST_LOCATION );
+
+ actor.SetProperty( Actor::Property::HEIGHT_FOR_WIDTH, true );
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_FOR_WIDTH ).Get< bool >(), true, TEST_LOCATION );
+
+ // Test setting another resize policy
+ actor.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FIXED" );
+ DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_FOR_HEIGHT ).Get< bool >(), false, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliRelayoutProperties_Padding(void)
+{
+ TestApplication app;
+
+ Actor actor = Actor::New();
+
+ // Data
+ Vector4 padding( 1.0f, 2.0f, 3.0f, 4.0f );
+
+ // PADDING
+ actor.SetProperty( Actor::Property::PADDING, padding );
+ Vector4 paddingResult = actor.GetProperty( Actor::Property::PADDING ).Get< Vector4 >();
+
+ DALI_TEST_EQUALS( paddingResult, padding, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliRelayoutProperties_MinimumMaximumSize(void)
+{
+ TestApplication app;
+
+ Actor actor = Actor::New();
+
+ // Data
+ Vector2 minSize( 1.0f, 2.0f );
+
+ actor.SetProperty( Actor::Property::MINIMUM_SIZE, minSize );
+ Vector2 resultMin = actor.GetProperty( Actor::Property::MINIMUM_SIZE ).Get< Vector2 >();
+
+ DALI_TEST_EQUALS( resultMin, minSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ Vector2 maxSize( 3.0f, 4.0f );
+
+ actor.SetProperty( Actor::Property::MAXIMUM_SIZE, maxSize );
+ Vector2 resultMax = actor.GetProperty( Actor::Property::MAXIMUM_SIZE ).Get< Vector2 >();
+
+ DALI_TEST_EQUALS( resultMax, maxSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+ END_TEST;
+}
projects / platform / core / uifw / dali-core.git / blobdiff