int UtcDaliPropertyArrayIndexOperatorP(void) { Property::Array array; array.Reserve(3); array.PushBack( 1 ); array.PushBack( "world" ); array.PushBack( 3 ); DALI_TEST_CHECK( array[0].Get<int>() == 1 ); DALI_TEST_CHECK( array[1].Get<std::string>() == "world" ); DALI_TEST_CHECK( array[2].Get<int>() == 3 ); END_TEST; }
int UtcDaliPropertyArrayReserveP(void) { Property::Array array; DALI_TEST_CHECK( array.Empty() ); array.Reserve(3); DALI_TEST_CHECK( 3 == array.Capacity() ); DALI_TEST_CHECK( 0 == array.Size() ); array.PushBack( 1 ); array.PushBack( "world" ); array.PushBack( 3 ); END_TEST; }
void CreatePropertyMap( Actor actor, Property::Map& map ) { map.Clear(); if ( actor ) { map[ "type" ] = actor.GetTypeName(); // Default properties Property::IndexContainer indices; actor.GetPropertyIndices( indices ); const Property::IndexContainer::ConstIterator endIter = indices.End(); for ( Property::IndexContainer::Iterator iter = indices.Begin(); iter != endIter; ++iter ) { map[ actor.GetPropertyName( *iter ) ] = actor.GetProperty( *iter ); } // Children unsigned int childCount( actor.GetChildCount() ); if ( childCount ) { Property::Array childArray; for ( unsigned int child = 0; child < childCount; ++child ) { Property::Map childMap; CreatePropertyMap( actor.GetChildAt( child ), childMap ); childArray.PushBack( childMap ); } map[ "actors" ] = childArray; } } }
int UtcDaliPropertyArrayEmptyP(void) { Property::Array array; DALI_TEST_CHECK( array.Empty() ); array.Reserve(3); DALI_TEST_CHECK( array.Empty() ); array.PushBack( 1 ); array.PushBack( "world" ); array.PushBack( 3 ); DALI_TEST_CHECK( !array.Empty() ); END_TEST; }
Property::Value PathConstrainer::GetDefaultProperty( Property::Index index ) const { if( index == Dali::PathConstrainer::Property::FORWARD ) { return Property::Value( mForward ); } else { if( index == Dali::PathConstrainer::Property::POINTS ) { Property::Value value( Property::ARRAY ); Property::Array* array = value.GetArray(); const Dali::Vector<Vector3>& point = mPath->GetPoints(); Property::Array::SizeType pointCount = point.Size(); if( array ) { array->Reserve( pointCount ); for( Property::Array::SizeType i = 0; i < pointCount; ++i ) { array->PushBack( point[i] ); } } return value; } else if( index == Dali::PathConstrainer::Property::CONTROL_POINTS ) { Property::Value value( Property::ARRAY ); Property::Array* array = value.GetArray(); const Dali::Vector<Vector3>& point = mPath->GetControlPoints(); Property::Array::SizeType pointCount = point.Size(); if( array ) { array->Reserve( pointCount ); for( Property::Array::SizeType i = 0; i < pointCount; ++i ) { array->PushBack( point[i] ); } } return value; } } return Property::Value(); }
int UtcDaliPropertyArrayPushBackP(void) { Property::Array array; DALI_TEST_CHECK( 0 == array.Size() ); array.PushBack( 1 ); DALI_TEST_CHECK( 1 == array.Size() ); DALI_TEST_CHECK( array[0].Get<int>() == 1 ); END_TEST; }
Property::Value LinearConstrainer::GetDefaultProperty( Property::Index index ) const { if( index == Dali::LinearConstrainer::Property::VALUE ) { Property::Value value( Property::ARRAY ); Property::Array* array = value.GetArray(); size_t count( mValue.Size() ); if( array ) { array->Reserve( count ); for( size_t i( 0 ); i != count; ++i ) { array->PushBack( mValue[i] ); } } return value; } else if( index == Dali::LinearConstrainer::Property::PROGRESS ) { Property::Value value( Property::ARRAY ); Property::Array* array = value.GetArray(); size_t count( mValue.Size() ); if( array ) { array->Reserve( count ); for( size_t i( 0 ); i != count; ++i ) { array->PushBack( mProgress[i] ); } } return value; } return Property::Value(); }
int UtcDaliScriptingNewActorChildren(void) { TestApplication application; Property::Map map; map[ "type" ] = "Actor"; map[ "position" ] = Vector3::XAXIS; Property::Map child1Map; child1Map[ "type" ] = "ImageActor"; child1Map[ "position" ] = Vector3::YAXIS; Property::Array childArray; childArray.PushBack( child1Map ); map[ "actors" ] = childArray; // Create Actor handle = NewActor( map ); DALI_TEST_CHECK( handle ); Stage::GetCurrent().Add( handle ); application.SendNotification(); application.Render(); DALI_TEST_EQUALS( handle.GetCurrentPosition(), Vector3::XAXIS, TEST_LOCATION ); DALI_TEST_EQUALS( handle.GetChildCount(), 1u, TEST_LOCATION ); Actor child1 = handle.GetChildAt(0); DALI_TEST_CHECK( child1 ); DALI_TEST_CHECK( ImageActor::DownCast( child1 ) ); DALI_TEST_EQUALS( child1.GetCurrentPosition(), Vector3::YAXIS, TEST_LOCATION ); DALI_TEST_EQUALS( child1.GetChildCount(), 0u, TEST_LOCATION ); Stage::GetCurrent().Remove( handle ); END_TEST; }
int UtcDaliControlRendererGetPropertyMap4(void) { ToolkitTestApplication application; tet_infoline( "UtcDaliControlRendererGetPropertyMap4: radial GradientRenderer" ); RendererFactory factory = RendererFactory::Get(); DALI_TEST_CHECK( factory ); Property::Map propertyMap; propertyMap.Insert("renderer-type", "gradient-renderer"); Vector2 center(100.f, 100.f); float radius = 100.f; propertyMap.Insert("gradient-units", "user-space"); propertyMap.Insert("gradient-center", center); propertyMap.Insert("gradient-radius", radius); propertyMap.Insert("gradient-stop-offset", Vector3(0.1f, 0.3f, 1.1f)); Property::Array stopColors; stopColors.PushBack( Color::RED ); stopColors.PushBack( Color::BLACK ); stopColors.PushBack( Color::GREEN ); propertyMap.Insert("gradient-stop-color", stopColors); ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap); DALI_TEST_CHECK( gradientRenderer ); Property::Map resultMap; gradientRenderer.CreatePropertyMap( resultMap ); // check the property values from the returned map from control renderer Property::Value* value = resultMap.Find( "renderer-type", Property::STRING ); DALI_TEST_CHECK( value ); DALI_TEST_CHECK( value->Get<std::string>() == "gradient-renderer" ); value = resultMap.Find( "gradient-units", Property::STRING ); DALI_TEST_CHECK( value ); DALI_TEST_CHECK( value->Get<std::string>() == "user-space" ); value = resultMap.Find( "gradient-spread-method", Property::STRING ); DALI_TEST_CHECK( value ); DALI_TEST_CHECK( value->Get<std::string>() == "pad" ); value = resultMap.Find( "gradient-center", Property::VECTOR2 ); DALI_TEST_CHECK( value ); DALI_TEST_EQUALS( value->Get<Vector2>(), center , Math::MACHINE_EPSILON_100, TEST_LOCATION ); value = resultMap.Find( "gradient-radius", Property::FLOAT ); DALI_TEST_CHECK( value ); DALI_TEST_EQUALS( value->Get<float>(), radius , Math::MACHINE_EPSILON_100, TEST_LOCATION ); value = resultMap.Find( "gradient-stop-offset", Property::ARRAY ); DALI_TEST_CHECK( value ); Property::Array* offsetArray = value->GetArray(); DALI_TEST_CHECK( offsetArray->Count() == 3 ); DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.1f , Math::MACHINE_EPSILON_100, TEST_LOCATION ); DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.3f , Math::MACHINE_EPSILON_100, TEST_LOCATION ); // any stop value will be clamped to [0.0, 1.0]; DALI_TEST_EQUALS( offsetArray->GetElementAt(2).Get<float>(), 1.0f , Math::MACHINE_EPSILON_100, TEST_LOCATION ); value = resultMap.Find( "gradient-stop-color", Property::ARRAY ); DALI_TEST_CHECK( value ); Property::Array* colorArray = value->GetArray(); DALI_TEST_CHECK( colorArray->Count() == 3 ); DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION ); DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK , Math::MACHINE_EPSILON_100, TEST_LOCATION ); DALI_TEST_EQUALS( colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION ); END_TEST; }
int UtcDaliControlRendererGetPropertyMap3(void) { ToolkitTestApplication application; tet_infoline( "UtcDaliControlRendererGetPropertyMap3: linear GradientRenderer" ); RendererFactory factory = RendererFactory::Get(); DALI_TEST_CHECK( factory ); Property::Map propertyMap; propertyMap.Insert("renderer-type", "gradient-renderer"); Vector2 start(-1.f, -1.f); Vector2 end(1.f, 1.f); propertyMap.Insert("gradient-start-position", start); propertyMap.Insert("gradient-end-position", end); propertyMap.Insert("gradient-spread-method", "repeat"); propertyMap.Insert("gradient-stop-offset", Vector2(0.2f, 0.8f)); Property::Array stopColors; stopColors.PushBack( Color::RED ); stopColors.PushBack( Color::GREEN ); propertyMap.Insert("gradient-stop-color", stopColors); ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap); Property::Map resultMap; gradientRenderer.CreatePropertyMap( resultMap ); // check the property values from the returned map from control renderer Property::Value* value = resultMap.Find( "renderer-type", Property::STRING ); DALI_TEST_CHECK( value ); DALI_TEST_CHECK( value->Get<std::string>() == "gradient-renderer" ); value = resultMap.Find( "gradient-units", Property::STRING ); DALI_TEST_CHECK( value ); DALI_TEST_CHECK( value->Get<std::string>() == "object-bounding-box" ); value = resultMap.Find( "gradient-spread-method", Property::STRING ); DALI_TEST_CHECK( value ); DALI_TEST_CHECK( value->Get<std::string>() == "repeat" ); value = resultMap.Find( "gradient-start-position", Property::VECTOR2 ); DALI_TEST_CHECK( value ); DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION ); value = resultMap.Find( "gradient-end-position", Property::VECTOR2 ); DALI_TEST_CHECK( value ); DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION ); value = resultMap.Find( "gradient-stop-offset", Property::ARRAY ); DALI_TEST_CHECK( value ); Property::Array* offsetArray = value->GetArray(); DALI_TEST_CHECK( offsetArray->Count() == 2 ); DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.2f , Math::MACHINE_EPSILON_100, TEST_LOCATION ); DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.8f , Math::MACHINE_EPSILON_100, TEST_LOCATION ); value = resultMap.Find( "gradient-stop-color", Property::ARRAY ); DALI_TEST_CHECK( value ); Property::Array* colorArray = value->GetArray(); DALI_TEST_CHECK( colorArray->Count() == 2 ); DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION ); DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION ); END_TEST; }
int UtcDaliControlRendererSize(void) { ToolkitTestApplication application; tet_infoline( "UtcDaliControlRendererGetNaturalSize" ); RendererFactory factory = RendererFactory::Get(); Vector2 rendererSize( 20.f, 30.f ); Vector2 naturalSize; // color renderer ControlRenderer colorRenderer = factory.GetControlRenderer( Color::MAGENTA ); colorRenderer.SetSize( rendererSize ); DALI_TEST_EQUALS( colorRenderer.GetSize(), rendererSize, TEST_LOCATION ); colorRenderer.GetNaturalSize(naturalSize); DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION ); // image renderer Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200)); ControlRenderer imageRenderer = factory.GetControlRenderer( image ); imageRenderer.SetSize( rendererSize ); DALI_TEST_EQUALS( imageRenderer.GetSize(), rendererSize, TEST_LOCATION ); imageRenderer.GetNaturalSize(naturalSize); DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 200.f), TEST_LOCATION ); // n patch renderer TestPlatformAbstraction& platform = application.GetPlatform(); Vector2 testSize(80.f, 160.f); platform.SetClosestImageSize(testSize); image = ResourceImage::New(TEST_NPATCH_FILE_NAME); ControlRenderer nPatchRenderer = factory.GetControlRenderer( image ); nPatchRenderer.SetSize( rendererSize ); DALI_TEST_EQUALS( nPatchRenderer.GetSize(), rendererSize, TEST_LOCATION ); nPatchRenderer.GetNaturalSize(naturalSize); DALI_TEST_EQUALS( naturalSize, testSize, TEST_LOCATION ); // border renderer float borderSize = 5.f; ControlRenderer borderRenderer = factory.GetControlRenderer( borderSize, Color::RED ); borderRenderer.SetSize( rendererSize ); DALI_TEST_EQUALS( borderRenderer.GetSize(), rendererSize, TEST_LOCATION ); borderRenderer.GetNaturalSize(naturalSize); DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION ); // gradient renderer Property::Map propertyMap; propertyMap.Insert("renderer-type", "gradient-renderer"); Vector2 start(-1.f, -1.f); Vector2 end(1.f, 1.f); propertyMap.Insert("gradient-start-position", start); propertyMap.Insert("gradient-end-position", end); propertyMap.Insert("gradient-stop-offset", Vector2(0.f, 1.f)); Property::Array stopColors; stopColors.PushBack( Color::RED ); stopColors.PushBack( Color::GREEN ); propertyMap.Insert("gradient-stop-color", stopColors); ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap); gradientRenderer.SetSize( rendererSize ); DALI_TEST_EQUALS( gradientRenderer.GetSize(), rendererSize, TEST_LOCATION ); gradientRenderer.GetNaturalSize(naturalSize); DALI_TEST_EQUALS( naturalSize, Vector2::ZERO,TEST_LOCATION ); END_TEST; }
bool SetPropertyFromNode( const TreeNode& node, Property::Value& value, const Replacement& replacer ) { bool done = false; // some values are ambiguous as we have no Property::Type but can be disambiguated in the json // Currently Rotations and Rectangle must always be disambiguated when a type isnt available if( Disambiguated( node, value, replacer ) ) { done = true; } else { if( node.Size() ) { // our current heuristic for deciding an array is actually a vector and not say a map // is to check if the values are all floats bool allNumbers = true; for(TreeConstIter iter = node.CBegin(); iter != node.CEnd(); ++iter) { OptionalFloat f = IsFloat((*iter).second); if(!f) { allNumbers = false; break; } } if( allNumbers ) { // prefer finding vectors over presuming composite Property::Array... if( OptionalMatrix v = IsMatrix(node) ) { value = *v; done = true; } else if( OptionalMatrix3 v = IsMatrix3(node) ) { value = *v; done = true; } else if( OptionalVector4 v = IsVector4(node) ) { value = *v; done = true; } else if( OptionalVector3 v = IsVector3(node) ) { value = *v; done = true; } else if( OptionalVector2 v = IsVector2(node) ) { value = *v; done = true; } else if( 4 == node.Size() ) { if( OptionalVector4 v = IsVector4(node) ) { value = *v; done = true; } } else { value = Property::Value(Property::ARRAY); Property::Array* array = value.GetArray(); if( array ) { for(TreeConstIter iter = node.CBegin(); iter != node.CEnd(); ++iter) { Property::Value childValue; if( SetPropertyFromNode( (*iter).second, childValue, replacer ) ) { array->PushBack( childValue ); done = true; } } } } } if(!done) { // presume an array or map // container of size 1 TreeNode::ConstIterator iter = node.CBegin(); // its seems legal with current json parser for a map to have an empty key // but here we take that to mean the structure is a list if( ((*iter).first) == 0 ) { value = Property::Value(Property::ARRAY); Property::Array* array = value.GetArray(); if( array ) { for(unsigned int i = 0; i < node.Size(); ++i, ++iter) { Property::Value childValue; if( SetPropertyFromNode( (*iter).second, childValue, replacer ) ) { array->PushBack( childValue ); done = true; } } } } else { value = Property::Value(Property::MAP); Property::Map* map = value.GetMap(); if( map ) { for(unsigned int i = 0; i < node.Size(); ++i, ++iter) { Property::Value childValue; if( SetPropertyFromNode( (*iter).second, childValue, replacer ) ) { map->Insert( (*iter).first, childValue ); done = true; } } } } } // if!done } // if node.size() else // if( 0 == node.size() ) { // no children so either one of bool, float, integer, string OptionalBoolean aBool = replacer.IsBoolean(node); OptionalInteger anInt = replacer.IsInteger(node); OptionalFloat aFloat = replacer.IsFloat(node); OptionalString aString = replacer.IsString(node); if(aBool) { // a bool is also an int but here we presume int if(anInt) { value = *anInt; done = true; } else { value = *aBool; done = true; } } else { // Note: These are both floats and strings // {"value":"123"} // {"value":123} // This means we can't have a string with purely numeric content without disambiguation. if(aFloat) { value = *aFloat; done = true; } else if(anInt) { value = *anInt; done = true; } else { // string always succeeds with the current json parser so its last value = *aString; done = true; } } // if aBool } // if( node.size() ) } // if Disambiguated() return done; } // bool SetPropertyFromNode( const TreeNode& node, Property::Value& value )
bool SetPropertyFromNode( const TreeNode& node, Property::Type type, Property::Value& value, const Replacement& replacer ) { bool done = false; switch(type) { case Property::BOOLEAN: { if( OptionalBoolean v = replacer.IsBoolean(node) ) { value = *v; done = true; } break; } case Property::FLOAT: { if( OptionalFloat v = replacer.IsFloat(node) ) { value = *v; done = true; } break; } case Property::INTEGER: { if( OptionalInteger v = replacer.IsInteger(node) ) { value = *v; done = true; } break; } case Property::VECTOR2: { if( OptionalVector2 v = replacer.IsVector2(node) ) { value = *v; done = true; } break; } case Property::VECTOR3: { if( OptionalVector3 v = replacer.IsVector3(node) ) { value = *v; done = true; } break; } case Property::VECTOR4: { if( OptionalVector4 v = replacer.IsVector4(node) ) { value = *v; done = true; } else if( OptionalString s = replacer.IsString(node) ) { if( (*s)[0] == '#' && 7 == (*s).size() ) { value = HexStringToVector4( &(*s)[1] ); done = true; } else if( Dali::ColorController::Get() ) { Vector4 color; done = Dali::ColorController::Get().RetrieveColor( *s, color ); value = color; } } else if( TreeNode::OBJECT == node.GetType() ) { // check for "r", "g" and "b" child color component nodes OptionalInteger r = replacer.IsInteger( IsChild(node, "r") ); OptionalInteger g = replacer.IsInteger( IsChild(node, "g") ); OptionalInteger b = replacer.IsInteger( IsChild(node, "b") ); if( r && g && b ) { float red( (*r) * (1.0f/255.0f) ); float green( (*g) * (1.0f/255.0f) ); float blue( (*b) * (1.0f/255.0f) ); // check for optional "a" (alpha) node, default to fully opaque if it is not found. float alpha( 1.0f ); OptionalInteger a = replacer.IsInteger( IsChild(node, "a") ); if( a ) { alpha = (*a) * (1.0f/255.0f); } value = Vector4( red, green, blue, alpha ); done = true; } } break; } case Property::MATRIX3: { if( OptionalMatrix3 v = replacer.IsMatrix3(node) ) { value = *v; done = true; } break; } case Property::MATRIX: { if( OptionalMatrix v = replacer.IsMatrix(node) ) { value = *v; done = true; } break; } case Property::RECTANGLE: { if( OptionalRect v = replacer.IsRect(node) ) { value = *v; done = true; } break; } case Property::ROTATION: { if(4 == node.Size()) { if( OptionalVector4 ov = replacer.IsVector4(node) ) { const Vector4& v = *ov; // angle, axis as per spec value = Quaternion(Radian(Degree(v[3])), Vector3(v[0],v[1],v[2])); done = true; } } else { // degrees Euler as per spec if( OptionalVector3 v = replacer.IsVector3(node) ) { value = Quaternion(Radian(Degree((*v).x)), Radian(Degree((*v).y)), Radian(Degree((*v).z))); done = true; } } break; } case Property::STRING: { if( OptionalString v = replacer.IsString(node) ) { value = *v; done = true; } break; } case Property::ARRAY: { if( replacer.IsArray( node, value ) ) { done = true; } else if(node.Size()) { value = Property::Value(Property::ARRAY); Property::Array* array = value.GetArray(); unsigned int i = 0; TreeNode::ConstIterator iter(node.CBegin()); if( array ) { for( ; i < node.Size(); ++i, ++iter) { Property::Value childValue; if( SetPropertyFromNode( (*iter).second, childValue, replacer ) ) { array->PushBack( childValue ); } } if( array->Count() == node.Size() ) { done = true; } else { done = false; } } } break; } case Property::MAP: { if( replacer.IsMap( node, value ) ) { done = true; } else if(node.Size()) { value = Property::Value(Property::MAP); Property::Map* map = value.GetMap(); unsigned int i = 0; TreeNode::ConstIterator iter(node.CBegin()); if( map ) { for( ; i < node.Size(); ++i, ++iter) { Property::Value childValue; if( SetPropertyFromNode( (*iter).second, childValue, replacer ) ) { map->Insert( (*iter).first, childValue ); } } if( map->Count() == node.Size() ) { done = true; } else { done = false; } } } break; } case Property::NONE: { break; } } // switch type return done; }