void PathConstrainer::SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) { if( index == Dali::PathConstrainer::Property::FORWARD ) { propertyValue.Get(mForward); } else if( index == Dali::PathConstrainer::Property::POINTS ) { const Property::Array* array = propertyValue.GetArray(); mPath->ClearPoints(); if( array ) { for( Property::Array::SizeType i = 0, count = array->Count(); i < count; ++i ) { Vector3 point; array->GetElementAt( i ).Get( point ); mPath->AddPoint( point ); } } } else if( index == Dali::PathConstrainer::Property::CONTROL_POINTS ) { const Property::Array* array = propertyValue.GetArray(); mPath->ClearControlPoints(); if( array ) { for( Property::Array::SizeType i = 0, count = array->Count(); i < count; ++i ) { Vector3 point; array->GetElementAt( i ).Get( point ); mPath->AddControlPoint( point ); } } } }
void ImageView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value ) { Toolkit::ImageView imageView = Toolkit::ImageView::DownCast( Dali::BaseHandle( object ) ); if ( imageView ) { switch ( index ) { case Toolkit::ImageView::Property::IMAGE: { std::string imageUrl; if( value.Get( imageUrl ) ) { ImageView& impl = GetImpl( imageView ); impl.SetImage( imageUrl ); } // if its not a string then get a Property::Map from the property if possible. Property::Map map; if( value.Get( map ) ) { ImageView& impl = GetImpl( imageView ); impl.SetImage( map ); } break; } } } }
int UtcDaliVideoViewProperty4(void) { ToolkitTestApplication application; tet_infoline(" UtcDaliVideoViewProperty4"); Toolkit::VideoView view = Toolkit::VideoView::New(); DALI_TEST_CHECK( view ); float left, right; left = right = 0.f; Property::Map map; map.Insert( VOLUME_LEFT, 1.0f ); map.Insert( VOLUME_RIGHT, 0.5f ); Property::Map map2; view.SetProperty( VideoView::Property::VOLUME, map ); Property::Value val4 = view.GetProperty( VideoView::Property::VOLUME ); DALI_TEST_CHECK( val4.Get( map2 ) ); Property::Value* volumeLeft = map.Find( VOLUME_LEFT ); Property::Value* volumeRight = map.Find( VOLUME_RIGHT ); DALI_TEST_CHECK( volumeLeft && volumeLeft->Get( left ) ); DALI_TEST_CHECK( volumeRight && volumeRight->Get( right ) ); DALI_TEST_CHECK( left == 1.0f ); DALI_TEST_CHECK( right == 0.5f ); END_TEST; }
// Positive test case for a method int UtcDaliVideoViewProperty1(void) { ToolkitTestApplication application; tet_infoline(" UtcDaliVideoViewProperty1"); Toolkit::VideoView view = Toolkit::VideoView::New(); DALI_TEST_CHECK( view ); std::string file; view.SetProperty( VideoView::Property::VIDEO, TEST_FILE ); Property::Value val = view.GetProperty( VideoView::Property::VIDEO ); DALI_TEST_CHECK( val.Get( file ) ); DALI_TEST_CHECK( file == TEST_FILE ); END_TEST; }
int UtcDaliImageActorImageProperty(void) { TestApplication application; Image image = Image::New( "MY_PATH" ); ImageActor imageActor = ImageActor::New( image ); Stage::GetCurrent().Add( imageActor ); application.SendNotification(); application.Render(); Property::Value imageMap = imageActor.GetProperty( ImageActor::IMAGE ); DALI_TEST_CHECK( imageMap.HasKey( "filename" ) ); DALI_TEST_EQUALS( imageMap.GetValue( "filename" ).Get< std::string >(), "MY_PATH", TEST_LOCATION ); END_TEST; }
void LinearConstrainer::SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) { const Property::Array* array = propertyValue.GetArray(); if( array ) { size_t propertyArrayCount = array->Count(); if( index == Dali::LinearConstrainer::Property::VALUE ) { mValue.Clear(); // remove old values mValue.Resize( propertyArrayCount ); for( size_t i(0); i != propertyArrayCount; ++i ) { array->GetElementAt( i ).Get( mValue[ i ] ); } } else if( index == Dali::LinearConstrainer::Property::PROGRESS ) { mProgress.Clear(); // remove old values mProgress.Resize( propertyArrayCount ); for( size_t i(0); i != propertyArrayCount; ++i ) { array->GetElementAt( i ).Get( mProgress[ i ] ); } } } }
bool SetPropertyMapRetrieved( TextField& field, const Property::Index property, const std::string mapKey, const std::string mapValue ) { bool result = false; Property::Map imageMap; imageMap[mapKey] =mapValue; field.SetProperty( property , imageMap ); Property::Value propValue = field.GetProperty( property ); Property::Map* resultMap = propValue.GetMap(); if ( resultMap->Find( mapKey )->Get< std::string>() == mapValue ) { result = true; } return result; }
void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Property::Map& propertyMap ) { if( renderer ) { Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME ); std::string typeValue ; if( type && type->Get( typeValue )) { //If there's been a renderer type change then we have to return a new shader if( typeValue == COLOR_RENDERER && typeid( renderer ) != typeid( ColorRenderer ) ) { renderer = GetControlRenderer( propertyMap ); return; } else if( typeValue == GRADIENT_RENDERER && typeid( renderer ) != typeid( GradientRenderer ) ) { renderer = GetControlRenderer( propertyMap ); return; } else if( typeValue == IMAGE_RENDERER && typeid( renderer ) != typeid( ImageRenderer ) ) { renderer = GetControlRenderer( propertyMap ); return; } else if( typeValue == N_PATCH_RENDERER && typeid( renderer ) != typeid( NPatchRenderer ) ) { renderer = GetControlRenderer( propertyMap ); return; } else if( typeValue == BORDER_RENDERER && typeid( renderer ) != typeid( BorderRenderer ) ) { renderer = GetControlRenderer( propertyMap ); return; } } GetImplementation( renderer ).Initialize( actor, propertyMap ); } else { renderer = GetControlRenderer( propertyMap ); } }
int UtcDaliVideoViewProperty3(void) { ToolkitTestApplication application; tet_infoline(" UtcDaliVideoViewProperty3"); Toolkit::VideoView view = Toolkit::VideoView::New(); DALI_TEST_CHECK( view ); bool muted; Property::Value val = view.GetProperty( VideoView::Property::MUTED ); DALI_TEST_CHECK( val.Get( muted ) ); DALI_TEST_CHECK( !muted ); view.SetProperty( VideoView::Property::MUTED, true ); val = view.GetProperty( VideoView::Property::MUTED ); DALI_TEST_CHECK( val.Get( muted ) ); DALI_TEST_CHECK( muted ); END_TEST; }
int UtcDaliVideoViewProperty2(void) { ToolkitTestApplication application; tet_infoline(" UtcDaliVideoViewProperty2"); Toolkit::VideoView view = Toolkit::VideoView::New(); DALI_TEST_CHECK( view ); bool looping; Property::Value val = view.GetProperty( VideoView::Property::LOOPING ); DALI_TEST_CHECK( val.Get( looping ) ); DALI_TEST_CHECK( !looping ); view.SetProperty( VideoView::Property::LOOPING, true ); val = view.GetProperty( VideoView::Property::LOOPING ); DALI_TEST_CHECK( val.Get( looping ) ); DALI_TEST_CHECK( looping ); END_TEST; }
void ControlRenderer::Initialize( Actor& actor, const Property::Map& propertyMap ) { if( mImpl->mCustomShader ) { mImpl->mCustomShader->SetPropertyMap( propertyMap ); } else { Property::Value* customShaderValue = propertyMap.Find( CUSTOM_SHADER ); if( customShaderValue ) { Property::Map customShader; if( customShaderValue->Get( customShader ) ) { mImpl->mCustomShader = new Impl::CustomShader( propertyMap ); } } } DoInitialize( actor, propertyMap ); }
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; }
Image NewImage( const Property::Value& property ) { Image ret; std::string filename; Internal::ImageAttributes attributes = Internal::ImageAttributes::New(); const Property::Map* map = property.GetMap(); ImageType imageType = RESOURCE_IMAGE; // default to resource image if( map ) { // first check the type as it determines, which other parameters are needed const Property::Value* value = map->Find( "type" ); if( value ) { std::string type; value->Get( type ); for( unsigned int i = 0; i < imageTypeCount; ++i ) { if( 0 == type.compare( ImageTypeName[ i ] ) ) { imageType = static_cast<ImageType>( i ); break; } } } // filename is only needed for resource images if( RESOURCE_IMAGE == imageType ) { const Property::Value* value = map->Find( "filename" ); if( value ) { value->Get( filename ); } // if empty file, no need to go further if( filename.size() == 0 ) { DALI_LOG_ERROR( "No filename\n" ); return Image(); } } // Width and height can be set individually. Dali derives the unspecified // dimension from the aspect ratio of the raw image. int width = 0, height = 0; value = map->Find( "width" ); if( value ) { // handle floats and integer the same for json script if( value->GetType() == Property::FLOAT ) { width = static_cast<unsigned int>( value->Get<float>() ); } else { value->Get( width ); } } value = map->Find( "height" ); if( value ) { if( value->GetType() == Property::FLOAT ) { height = static_cast<int>( value->Get<float>() ); } else { value->Get( height ); } } attributes.SetSize( width, height ); Pixel::Format pixelFormat = Pixel::RGBA8888; value = map->Find( "pixelFormat" ); if( value ) { std::string format; value->Get( format ); GetEnumeration< Pixel::Format >( format.c_str(), PIXEL_FORMAT_TABLE, PIXEL_FORMAT_TABLE_COUNT, pixelFormat ); } value = map->Find( "fittingMode" ); if( value ) { std::string fitting; value->Get( fitting ); FittingMode::Type mode; if( GetEnumeration< FittingMode::Type >( fitting.c_str(), IMAGE_FITTING_MODE_TABLE, IMAGE_FITTING_MODE_TABLE_COUNT, mode ) ) { attributes.SetScalingMode( mode ); } } value = map->Find( "samplingMode" ); if( value ) { std::string sampling; value->Get( sampling ); SamplingMode::Type mode; if( GetEnumeration< SamplingMode::Type >( sampling.c_str(), IMAGE_SAMPLING_MODE_TABLE, IMAGE_SAMPLING_MODE_TABLE_COUNT, mode ) ) { attributes.SetFilterMode( mode ); } } value = map->Find( "orientation" ); if( value ) { bool b = value->Get<bool>(); attributes.SetOrientationCorrection( b ); } switch( imageType ) { case RESOURCE_IMAGE : { ret = ResourceImage::New( filename, ImageDimensions( attributes.GetSize().x, attributes.GetSize().y ), attributes.GetScalingMode(), attributes.GetFilterMode(), attributes.GetOrientationCorrection() ); break; } case BUFFER_IMAGE : { ret = BufferImage::New( attributes.GetWidth(), attributes.GetHeight(), pixelFormat ); break; } case FRAME_BUFFER_IMAGE : { ret = FrameBufferImage::New( attributes.GetWidth(), attributes.GetHeight(), pixelFormat ); break; } } } return ret; } // Image NewImage( Property::Value map )
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 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; }
void KeyFrames::Add(float time, Property::Value value, AlphaFunction alpha) { if(mType == Property::NONE) { CreateKeyFramesSpec(value.GetType()); } // Once we have created a type, can only add values of the same type DALI_ASSERT_ALWAYS( mType == value.GetType() && "Can only add values of the same type to a KeyFrame" ); DALI_ASSERT_DEBUG(mKeyFrames); switch(mType) { case Property::BOOLEAN: { Internal::KeyFrameBoolean* kf = static_cast<Internal::KeyFrameBoolean*>(mKeyFrames.Get()); kf->AddKeyFrame(time, value.Get<bool>(), alpha); break; } case Property::INTEGER: { Internal::KeyFrameInteger* kf = static_cast<Internal::KeyFrameInteger*>(mKeyFrames.Get()); kf->AddKeyFrame(time, value.Get<int>(), alpha); break; } case Property::FLOAT: { Internal::KeyFrameNumber* kf = static_cast<Internal::KeyFrameNumber*>(mKeyFrames.Get()); kf->AddKeyFrame(time, value.Get<float>(), alpha); break; } case Property::VECTOR2: { Internal::KeyFrameVector2* kf = static_cast<Internal::KeyFrameVector2*>(mKeyFrames.Get()); kf->AddKeyFrame(time, value.Get<Vector2>(), alpha); break; } case Property::VECTOR3: { Internal::KeyFrameVector3* kf = static_cast<Internal::KeyFrameVector3*>(mKeyFrames.Get()); kf->AddKeyFrame(time, value.Get<Vector3>(), alpha); break; } case Property::VECTOR4: { Internal::KeyFrameVector4* kf = static_cast<Internal::KeyFrameVector4*>(mKeyFrames.Get()); kf->AddKeyFrame(time, value.Get<Vector4>(), alpha); break; } case Property::ROTATION: { Internal::KeyFrameQuaternion* kf = static_cast<Internal::KeyFrameQuaternion*>(mKeyFrames.Get()); kf->AddKeyFrame(time, value.Get<Quaternion>(), alpha); break; } default: DALI_ASSERT_DEBUG(!"Type not supported"); break; } }