+ if( index != Property::INVALID_INDEX )
+ {
+ if( mImpl->mRenderer )
+ {
+ if( animator.animate == false )
+ {
+ mImpl->mRenderer.SetProperty( index, targetValue );
+ }
+ else
+ {
+ if( animator.initialValue.GetType() != Property::NONE )
+ {
+ mImpl->mRenderer.SetProperty( index, initialValue );
+ }
+
+ if( ! transition )
+ {
+ transition = Dali::Animation::New( 0.1f );
+ }
+
+ transition.AnimateTo( Property( mImpl->mRenderer, index ),
+ targetValue,
+ animator.alphaFunction,
+ TimePeriod( animator.timePeriodDelay,
+ animator.timePeriodDuration ) );
+ }
+ }
+ }
+}
+
+void Visual::Base::AnimateProperty(
+ Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator )
+{
+#if defined(DEBUG_ENABLED)
+ {
+ std::ostringstream oss;
+ oss << "Visual::Base::AnimateProperty(Visual:" << mImpl->mName << " Property:" << animator.propertyKey << " Target: " << animator.targetValue << std::endl;
+ DALI_LOG_INFO( gVisualBaseLogFilter, Debug::General, oss.str().c_str() );
+ }
+#endif
+
+ Property::Map map;
+ DoCreatePropertyMap( map );
+ Property::Value* valuePtr = map.Find( Toolkit::DevelVisual::Property::TYPE );
+ int visualType;
+ valuePtr->Get(visualType);
+
+ if( animator.propertyKey == Toolkit::DevelVisual::Property::MIX_COLOR ||
+ animator.propertyKey == MIX_COLOR ||
+ ( visualType == Toolkit::Visual::COLOR &&
+ animator.propertyKey == ColorVisual::Property::MIX_COLOR ) ||
+ ( visualType == Toolkit::Visual::PRIMITIVE &&
+ animator.propertyKey == PrimitiveVisual::Property::MIX_COLOR ) )
+ {
+ AnimateMixColorProperty( transition, animator );
+ }
+ else if(animator.propertyKey == Toolkit::DevelVisual::Property::OPACITY ||
+ animator.propertyKey == OPACITY )
+ {
+ AnimateOpacityProperty( transition, animator );
+ }
+ else if( mImpl->mRenderer )
+ {
+ AnimateRendererProperty(transition, animator);
+ }
+}
+
+void Visual::Base::AnimateOpacityProperty(
+ Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator )
+{
+ Property::Index index = mImpl->mOpacityIndex;
+
+ bool isOpaque = mImpl->mMixColor.a >= 1.0f;
+
+ if( index != Property::INVALID_INDEX )
+ {
+ float initialOpacity;
+ if( animator.initialValue.Get( initialOpacity ) )
+ {
+ isOpaque = (initialOpacity >= 1.0f);
+ }
+
+ float targetOpacity;
+ if( animator.targetValue.Get( targetOpacity ) )
+ {
+ mImpl->mMixColor.a = targetOpacity;
+ }
+
+ SetupTransition( transition, animator, index, animator.initialValue, animator.targetValue );
+ SetupBlendMode( transition, isOpaque, animator.animate );
+ }
+}
+
+void Visual::Base::AnimateRendererProperty(
+ Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator )
+{
+ Property::Index index = GetPropertyIndex( animator.propertyKey );
+ if( index != Property::INVALID_INDEX )
+ {
+ if( animator.targetValue.GetType() != Property::NONE )
+ {
+ // Try writing target value into transform property map
+ // if it's not a valid key, then it won't alter mTransform
+ Property::Map map;
+ if( animator.propertyKey.type == Property::Key::INDEX )
+ {
+ map.Add( animator.propertyKey.indexKey, animator.targetValue );
+ }
+ else
+ {
+ map.Add( animator.propertyKey.stringKey, animator.targetValue );
+ }
+
+ mImpl->mTransform.UpdatePropertyMap( map );
+ }
+
+ SetupTransition( transition, animator, index, animator.initialValue, animator.targetValue );
+ }
+}
+
+void Visual::Base::AnimateMixColorProperty(
+ Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator )
+{
+ Property::Index index = mImpl->mMixColorIndex;
+ bool animateOpacity = false;
+ bool isOpaque = true;
+
+ Property::Value initialOpacity;
+ Property::Value targetOpacity;
+ Property::Value initialMixColor;
+ Property::Value targetMixColor;
+
+ if( index != Property::INVALID_INDEX )
+ {
+ Vector4 initialColor;
+ if( animator.initialValue.Get(initialColor) )
+ {
+ if( animator.initialValue.GetType() == Property::VECTOR4 )
+ {
+ // if there is an initial color specifying alpha, test it
+ isOpaque = initialColor.a >= 1.0f;
+ initialOpacity = initialColor.a;
+ }
+ initialMixColor = Vector3( initialColor );
+ }
+
+ // Set target value into data store
+ if( animator.targetValue.GetType() != Property::NONE )
+ {
+ Vector4 mixColor;
+ animator.targetValue.Get(mixColor);
+ if( animator.targetValue.GetType() == Property::VECTOR4 )
+ {
+ mImpl->mMixColor.a = mixColor.a;
+ targetOpacity = mixColor.a;
+ animateOpacity = true;
+ }
+
+ mImpl->mMixColor.r = mixColor.r;
+ mImpl->mMixColor.g = mixColor.g;
+ mImpl->mMixColor.b = mixColor.b;
+ targetMixColor = Vector3(mixColor);
+ }
+
+ SetupTransition( transition, animator, index, initialMixColor, targetMixColor );
+ if( animateOpacity )
+ {
+ SetupTransition( transition, animator, mImpl->mOpacityIndex, initialOpacity, targetOpacity );
+ SetupBlendMode( transition, isOpaque, animator.animate );
+ }
+ }
+}
+
+void Visual::Base::SetupBlendMode( Animation& transition, bool isInitialOpaque, bool animating )
+{
+ // Ensure the blend mode is turned on if we are animating opacity, and
+ // turned off after the animation ends if the final value is opaque
+ if( ! isInitialOpaque || mImpl->mMixColor.a < 1.0f )
+ {
+ mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
+
+ if( animating == true && mImpl->mMixColor.a >= 1.0f )
+ {
+ // When it becomes opaque, set the blend mode back to automatically
+ if( ! mImpl->mBlendSlotDelegate )
+ {
+ mImpl->mBlendSlotDelegate = new SlotDelegate<Visual::Base>(this);
+ }
+ transition.FinishedSignal().Connect( *(mImpl->mBlendSlotDelegate),
+ &Visual::Base::OnMixColorFinished );
+ }
+ }
+}
+
+void Visual::Base::OnMixColorFinished( Animation& animation )
+{
+ if( mImpl->mRenderer )
+ {
+ DALI_LOG_INFO( gVisualBaseLogFilter, Debug::General, "Visual::Base::OnMixColorFinished()\n");
+ mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE,
+ ( mImpl->mMixColor.a < 1.0 ) ? BlendMode::ON : BlendMode::AUTO );
+ }
+ delete mImpl->mBlendSlotDelegate;
+ mImpl->mBlendSlotDelegate = NULL;