Actor NewActor( const Property::Map& map ) { BaseHandle handle; // First find type and create Actor Property::Value* typeValue = map.Find( "type" ); if ( typeValue ) { TypeInfo type = TypeRegistry::Get().GetTypeInfo( typeValue->Get< std::string >() ); if ( type ) { handle = type.CreateInstance(); } } if ( !handle ) { DALI_LOG_ERROR( "Actor type not provided\n" ); return Actor(); } Actor actor( Actor::DownCast( handle ) ); if ( actor ) { // Now set the properties, or create children for ( unsigned int i = 0, mapCount = map.Count(); i < mapCount; ++i ) { const StringValuePair& pair( map.GetPair( i ) ); const std::string& key( pair.first ); if ( key == "type" ) { continue; } const Property::Value& value( pair.second ); if ( key == "actors" ) { // Create children Property::Array actorArray = value.Get< Property::Array >(); for ( Property::Array::SizeType i = 0; i < actorArray.Size(); ++i) { actor.Add( NewActor( actorArray[i].Get< Property::Map >() ) ); } } else { Property::Index index( actor.GetPropertyIndex( key ) ); if ( index != Property::INVALID_INDEX ) { actor.SetProperty( index, value ); } } } } return actor; }
int UtcDaliPropertyMapInsertP(void) { Property::Map map; DALI_TEST_EQUALS( 0, map.Count(), TEST_LOCATION ); map.Insert( "foo", "bar"); DALI_TEST_EQUALS( 1, map.Count(), TEST_LOCATION ); Property::Value* value = map.Find( "foo" ); DALI_TEST_CHECK( value ); DALI_TEST_EQUALS( "bar", value->Get<std::string>(), TEST_LOCATION ); map.Insert( std::string("foo2"), "testing" ); DALI_TEST_EQUALS( 2, map.Count(), TEST_LOCATION ); value = map.Find( "foo2" ); DALI_TEST_CHECK( value ); DALI_TEST_EQUALS( "testing", value->Get<std::string>(), TEST_LOCATION ); END_TEST; }
int UtcDaliPropertyMapCopyAndAssignment(void) { Property::Map map; map[ "hello" ] = 1; map[ "world" ] = 2; Property::Map assignedMap; assignedMap[ "foo" ] = 3; DALI_TEST_CHECK( assignedMap.Count() == 1 ); assignedMap = map; DALI_TEST_CHECK( assignedMap.Count() == 2 ); Property::Map copiedMap( map ); DALI_TEST_CHECK( copiedMap.Count() == 2 ); // Self assignment DALI_TEST_CHECK( map.Count() == 2 ); map = map; DALI_TEST_CHECK( map.Count() == 2 ); END_TEST; }
int UtcDaliPropertyMapPopulate(void) { Property::Map map; DALI_TEST_CHECK( map.Empty() ); map[ "hello" ] = 1; map[ "world" ] = "world"; map[ "world" ] = 3; // same item as line above DALI_TEST_CHECK( !map.Empty() ); // Should no longer be empty DALI_TEST_CHECK( map.Count() == 2 ); // Should only have two items, not three!! DALI_TEST_CHECK( map["hello"].Get<int>() == 1 ); DALI_TEST_CHECK( map["world"].Get<int>() == 3 ); map.Clear(); DALI_TEST_CHECK( map.Empty() ); END_TEST; }
int UtcDaliPropertyMapConstOperator(void) { Property::Map map; map[ "hello" ] = 1; map[ "world" ] = 2; DALI_TEST_CHECK( map.Count() == 2 ); const Property::Map& constMap( map ); DALI_TEST_CHECK( constMap[ "world" ].Get<int>() == 2 ); DALI_TEST_CHECK( constMap.Count() == 2 ); // Ensure count hasn't gone up // Invalid Key try { constMap[ "invalid-key" ]; tet_result( TET_FAIL ); } catch ( DaliException& e ) { DALI_TEST_ASSERT( e, "! \"Invalid Key\"", TEST_LOCATION ); } END_TEST; }
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; }
void NewAnimation( const Property::Map& map, Dali::AnimationData& outputAnimationData ) { // Note: Builder cannot currently pass generic Property::Maps "{" that are nested, so currently we can only have one AnimateTo per animation. Dali::AnimationData::AnimationDataElement* element = new Dali::AnimationData::AnimationDataElement(); element->alphaFunction = AlphaFunction::LINEAR; element->timePeriodDelay = 0.0f; element->timePeriodDuration = 1.0f; // Now set the properties, or create children for( unsigned int i = 0, animationMapCount = map.Count(); i < animationMapCount; ++i ) { const StringValuePair& pair( map.GetPair( i ) ); const std::string& key( pair.first ); const Property::Value& value( pair.second ); if( key == "actor" ) { element->actor = value.Get< std::string >(); } else if( key == "property" ) { element->property = value.Get< std::string >(); } else if( key == "value" ) { element->value = value; } else if( key == "alphaFunction" ) { std::string alphaFunctionValue = value.Get< std::string >(); if( alphaFunctionValue == "LINEAR" ) { element->alphaFunction = AlphaFunction::LINEAR; } else if( alphaFunctionValue == "REVERSE" ) { element->alphaFunction = AlphaFunction::REVERSE; } else if( alphaFunctionValue == "EASE_IN_SQUARE" ) { element->alphaFunction = AlphaFunction::EASE_IN_SQUARE; } else if( alphaFunctionValue == "EASE_OUT_SQUARE" ) { element->alphaFunction = AlphaFunction::EASE_OUT_SQUARE; } else if( alphaFunctionValue == "EASE_IN" ) { element->alphaFunction = AlphaFunction::EASE_IN; } else if( alphaFunctionValue == "EASE_OUT" ) { element->alphaFunction = AlphaFunction::EASE_OUT; } else if( alphaFunctionValue == "EASE_IN_OUT" ) { element->alphaFunction = AlphaFunction::EASE_IN_OUT; } else if( alphaFunctionValue == "EASE_IN_SINE" ) { element->alphaFunction = AlphaFunction::EASE_IN_SINE; } else if( alphaFunctionValue == "EASE_OUT_SINE" ) { element->alphaFunction = AlphaFunction::EASE_OUT_SINE; } else if( alphaFunctionValue == "EASE_IN_OUT_SINE" ) { element->alphaFunction = AlphaFunction::EASE_IN_OUT_SINE; } else if( alphaFunctionValue == "BOUNCE" ) { element->alphaFunction = AlphaFunction::BOUNCE; } else if( alphaFunctionValue == "SIN" ) { element->alphaFunction = AlphaFunction::SIN; } else if( alphaFunctionValue == "EASE_OUT_BACK" ) { element->alphaFunction = AlphaFunction::EASE_OUT_BACK; } } else if( key == "timePeriod" ) { Property::Map timeMap = value.Get< Property::Map >(); for( unsigned int i = 0; i < timeMap.Count(); ++i ) { const StringValuePair& pair( timeMap.GetPair( i ) ); if( pair.first == "delay" ) { element->timePeriodDelay = pair.second.Get< float >(); } else if( pair.first == "duration" ) { element->timePeriodDuration = pair.second.Get< float >(); } } } } outputAnimationData.Add( element ); }
int UtcDaliPropertyMapMerge(void) { Property::Map map; map[ "hello" ] = 1; map[ "world" ] = 2; DALI_TEST_CHECK( map.Count() == 2 ); // Create another map with the same keys but different values Property::Map map2; map[ "hello" ] = 3; map[ "world" ] = 4; // Merge map2 into map1, count should still be 2, map values should be from map2 map.Merge( map2 ); DALI_TEST_CHECK( map.Count() == 2 ); DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 ); DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 ); // Create another map with different keys Property::Map map3; map3[ "foo" ] = 5; map3[ "bar" ] = 6; // Merge map3 into map1, count should increase, existing values should match previous and new values should match map3 map.Merge( map3 ); DALI_TEST_CHECK( map.Count() == 4 ); DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 ); DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 ); DALI_TEST_CHECK( map[ "foo"].Get< int >() == 5 ); DALI_TEST_CHECK( map[ "bar"].Get< int >() == 6 ); // Create an empty map and attempt to merge, should be successful, nothing should change Property::Map map4; DALI_TEST_CHECK( map4.Empty() ); map.Merge( map4 ); DALI_TEST_CHECK( map4.Empty() ); DALI_TEST_CHECK( map.Count() == 4 ); DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 ); DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 ); DALI_TEST_CHECK( map[ "foo"].Get< int >() == 5 ); DALI_TEST_CHECK( map[ "bar"].Get< int >() == 6 ); // Merge map into map4, map4 should be the same as map now. map4.Merge( map ); DALI_TEST_CHECK( map4.Count() == 4 ); DALI_TEST_CHECK( map4[ "hello" ].Get< int >() == 3 ); DALI_TEST_CHECK( map4[ "world"].Get< int >() == 4 ); DALI_TEST_CHECK( map4[ "foo"].Get< int >() == 5 ); DALI_TEST_CHECK( map4[ "bar"].Get< int >() == 6 ); // Attempt to merge into itself, should be successful, nothing should change map.Merge( map ); DALI_TEST_CHECK( map.Count() == 4 ); DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 ); DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 ); DALI_TEST_CHECK( map[ "foo"].Get< int >() == 5 ); DALI_TEST_CHECK( map[ "bar"].Get< int >() == 6 ); END_TEST; }