Remove blend mode change when mixColor is changed
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / visual-base-impl.cpp
1 /*
2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 // CLASS HEADER
19 #include "visual-base-impl.h"
20
21 // EXTERNAL HEADER
22 #include <dali-toolkit/public-api/dali-toolkit-common.h>
23 #include <dali/devel-api/scripting/enum-helper.h>
24 #include <dali/devel-api/rendering/renderer-devel.h>
25 #include <dali/integration-api/debug.h>
26
27 //INTERNAL HEARDER
28 #include <dali-toolkit/public-api/visuals/color-visual-properties.h>
29 #include <dali-toolkit/public-api/visuals/primitive-visual-properties.h>
30 #include <dali-toolkit/public-api/visuals/visual-properties.h>
31 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
32 #include <dali-toolkit/internal/helpers/property-helper.h>
33 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
34 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
35
36 namespace
37 {
38 #if defined(DEBUG_ENABLED)
39 Debug::Filter* gVisualBaseLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_VISUAL_BASE" );
40 #endif
41
42 const char * const PRE_MULTIPLIED_ALPHA_PROPERTY( "preMultipliedAlpha" );
43
44 } // namespace
45
46 namespace Dali
47 {
48
49 namespace Toolkit
50 {
51
52 namespace Internal
53 {
54
55 namespace
56 {
57
58 DALI_ENUM_TO_STRING_TABLE_BEGIN( VISUAL_FITTING_MODE )
59 DALI_ENUM_TO_STRING_WITH_SCOPE( Visual::FittingMode, FIT_KEEP_ASPECT_RATIO  )
60 DALI_ENUM_TO_STRING_WITH_SCOPE( Visual::FittingMode, FILL  )
61 DALI_ENUM_TO_STRING_WITH_SCOPE( Visual::FittingMode, OVER_FIT_KEEP_ASPECT_RATIO )
62 DALI_ENUM_TO_STRING_WITH_SCOPE( Visual::FittingMode, CENTER )
63 DALI_ENUM_TO_STRING_WITH_SCOPE( Visual::FittingMode, FIT_WIDTH )
64 DALI_ENUM_TO_STRING_WITH_SCOPE( Visual::FittingMode, FIT_HEIGHT )
65 DALI_ENUM_TO_STRING_TABLE_END( VISUAL_FITTING_MODE )
66
67 } // namespace
68
69 Visual::Base::Base( VisualFactoryCache& factoryCache, FittingMode fittingMode, Toolkit::Visual::Type type )
70 : mImpl( new Impl( fittingMode, type ) ),
71   mFactoryCache( factoryCache )
72 {
73 }
74
75 Visual::Base::~Base()
76 {
77   delete mImpl;
78 }
79
80 void Visual::Base::SetCustomShader( const Property::Map& shaderMap )
81 {
82   if( mImpl->mCustomShader )
83   {
84     mImpl->mCustomShader->SetPropertyMap( shaderMap );
85   }
86   else
87   {
88     mImpl->mCustomShader = new Impl::CustomShader( shaderMap );
89   }
90 }
91
92 void Visual::Base::SetProperties( const Property::Map& propertyMap )
93 {
94   for( size_t i = 0; i < propertyMap.Count(); ++i )
95   {
96     const KeyValuePair& pair = propertyMap.GetKeyValue( i );
97     const Property::Key& key = pair.first;
98     const Property::Value& value = pair.second;
99
100     Property::Key matchKey = key;
101     if( matchKey.type == Property::Key::STRING )
102     {
103       if( matchKey == CUSTOM_SHADER )
104       {
105         matchKey = Property::Key( Toolkit::Visual::Property::SHADER );
106       }
107       else if( matchKey == TRANSFORM )
108       {
109         matchKey = Property::Key( Toolkit::Visual::Property::TRANSFORM );
110       }
111       else if( matchKey == PREMULTIPLIED_ALPHA )
112       {
113         matchKey = Property::Key( Toolkit::Visual::Property::PREMULTIPLIED_ALPHA );
114       }
115       else if( matchKey == MIX_COLOR )
116       {
117         matchKey = Property::Key( Toolkit::Visual::Property::MIX_COLOR );
118       }
119       else if( matchKey == OPACITY )
120       {
121         matchKey = Property::Key( Toolkit::Visual::Property::OPACITY );
122       }
123       else if( matchKey == VISUAL_FITTING_MODE )
124       {
125         matchKey = Property::Key( Toolkit::DevelVisual::Property::VISUAL_FITTING_MODE );
126       }
127       else if( matchKey == CORNER_RADIUS )
128       {
129         matchKey = Property::Key( Toolkit::DevelVisual::Property::CORNER_RADIUS );
130       }
131       else if( matchKey == CORNER_RADIUS_POLICY )
132       {
133         matchKey = Property::Key( Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY );
134       }
135     }
136
137     switch( matchKey.indexKey )
138     {
139       case Toolkit::Visual::Property::SHADER:
140       {
141         Property::Map shaderMap;
142         if( value.Get( shaderMap ) )
143         {
144           SetCustomShader( shaderMap );
145         }
146         break;
147       }
148
149       case Toolkit::Visual::Property::TRANSFORM:
150       {
151         Property::Map map;
152         if( value.Get( map ) )
153         {
154           mImpl->mTransform.SetPropertyMap( map );
155         }
156         break;
157       }
158
159       case Toolkit::Visual::Property::PREMULTIPLIED_ALPHA:
160       {
161         bool premultipliedAlpha = false;
162         if( value.Get( premultipliedAlpha ) )
163         {
164           EnablePreMultipliedAlpha( premultipliedAlpha );
165         }
166         break;
167       }
168
169       case Toolkit::Visual::Property::MIX_COLOR:
170       {
171         Vector4 mixColor;
172         if( value.Get( mixColor ) )
173         {
174           if( value.GetType() == Property::VECTOR4 )
175           {
176             SetMixColor( mixColor );
177           }
178           else
179           {
180             Vector3 mixColor3(mixColor);
181             SetMixColor( mixColor3 );
182           }
183         }
184         break;
185       }
186       case Toolkit::Visual::Property::OPACITY:
187       {
188         float opacity;
189         if( value.Get( opacity ) )
190         {
191           mImpl->mMixColor.a = opacity;
192           SetMixColor( mImpl->mMixColor );
193         }
194         break;
195       }
196       case Toolkit::DevelVisual::Property::VISUAL_FITTING_MODE:
197       {
198         Scripting::GetEnumerationProperty< Visual::FittingMode >(
199           value, VISUAL_FITTING_MODE_TABLE, VISUAL_FITTING_MODE_TABLE_COUNT, mImpl->mFittingMode );
200         break;
201       }
202       case Toolkit::DevelVisual::Property::CORNER_RADIUS:
203       {
204         float radius;
205         if( value.Get( radius ) )
206         {
207           mImpl->mCornerRadius = radius;
208         }
209         break;
210       }
211       case Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY:
212       {
213         int policy;
214         if( value.Get( policy ) )
215         {
216           switch( policy )
217           {
218             case Toolkit::Visual::Transform::Policy::RELATIVE:
219             case Toolkit::Visual::Transform::Policy::ABSOLUTE:
220             {
221               mImpl->mCornerRadiusPolicy = policy;
222               break;
223             }
224             default:
225             {
226               DALI_LOG_ERROR( "Unsupported policy: %d\n", policy );
227               break;
228             }
229           }
230         }
231         break;
232       }
233     }
234   }
235
236   DoSetProperties( propertyMap );
237 }
238
239 void Visual::Base::SetTransformAndSize( const Property::Map& transform, Size controlSize )
240 {
241   mImpl->mControlSize = controlSize;
242   mImpl->mTransform.UpdatePropertyMap( transform );
243
244 #if defined(DEBUG_ENABLED)
245   std::ostringstream oss;
246   oss << transform;
247   DALI_LOG_INFO( gVisualBaseLogFilter, Debug::General, "Visual::Base::SetTransformAndSize(%s) - [\e[1;32mtransform: %s  controlSize: (%3.1f, %3.1f)]\e[0m\n",
248                  GetName().c_str(), oss.str().c_str(), controlSize.x, controlSize.y );
249 #endif
250
251   OnSetTransform();
252 }
253
254 void Visual::Base::SetName( const std::string& name )
255 {
256   mImpl->mName = name;
257 }
258
259 const std::string& Visual::Base::GetName() const
260 {
261   return mImpl->mName;
262 }
263
264 float Visual::Base::GetHeightForWidth( float width )
265 {
266   float aspectCorrectedHeight = 0.f;
267   Vector2 naturalSize;
268   GetNaturalSize( naturalSize );
269   if( naturalSize.width )
270   {
271     aspectCorrectedHeight = naturalSize.height * width / naturalSize.width;
272   }
273   return aspectCorrectedHeight;
274 }
275
276 float Visual::Base::GetWidthForHeight( float height )
277 {
278   float aspectCorrectedWidth = 0.f;
279   Vector2 naturalSize;
280   GetNaturalSize( naturalSize );
281   if( naturalSize.height > 0.0f )
282   {
283     aspectCorrectedWidth = naturalSize.width * height / naturalSize.height;
284   }
285   return aspectCorrectedWidth;
286 }
287
288 void Visual::Base::GetNaturalSize( Vector2& naturalSize )
289 {
290   naturalSize = Vector2::ZERO;
291 }
292
293 void Visual::Base::DoAction( const Property::Index actionId, const Property::Value attributes )
294 {
295   OnDoAction( actionId, attributes );
296 }
297
298 void Visual::Base::SetDepthIndex( int index )
299 {
300   mImpl->mDepthIndex = index;
301   if( mImpl->mRenderer )
302   {
303     mImpl->mRenderer.SetProperty( Renderer::Property::DEPTH_INDEX, mImpl->mDepthIndex );
304   }
305 }
306
307 int Visual::Base::GetDepthIndex() const
308 {
309   return mImpl->mDepthIndex;
310 }
311
312 void Visual::Base::SetOnScene( Actor& actor )
313 {
314   if( !IsOnScene() )
315   {
316     // To display the actor correctly, renderer should not be added to actor until all required resources are ready.
317     // Thus the calling of actor.AddRenderer() should happen inside derived class as base class does not know the exact timing.
318     DoSetOnScene( actor );
319
320     if( mImpl->mRenderer )
321     {
322       RegisterMixColor();
323
324       if( IsRoundedCornerRequired() )
325       {
326         mImpl->mCornerRadiusIndex = mImpl->mRenderer.RegisterProperty( CORNER_RADIUS, mImpl->mCornerRadius );
327         mImpl->mRenderer.RegisterProperty( CORNER_RADIUS_POLICY, mImpl->mCornerRadiusPolicy );
328
329         mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
330       }
331
332       mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, IsPreMultipliedAlphaEnabled());
333       mImpl->mRenderer.SetProperty( Renderer::Property::DEPTH_INDEX, mImpl->mDepthIndex );
334       mImpl->mFlags |= Impl::IS_ON_SCENE; // Only sets the flag if renderer exists
335     }
336   }
337 }
338
339 void Visual::Base::SetOffScene( Actor& actor )
340 {
341   if( IsOnScene() )
342   {
343     DoSetOffScene( actor );
344     mImpl->mMixColorIndex = Property::INVALID_INDEX;
345     mImpl->mCornerRadiusIndex = Property::INVALID_INDEX;
346     mImpl->mFlags &= ~Impl::IS_ON_SCENE;
347   }
348 }
349
350 void Visual::Base::CreatePropertyMap( Property::Map& map ) const
351 {
352   DoCreatePropertyMap( map );
353
354   if( mImpl->mCustomShader )
355   {
356     mImpl->mCustomShader->CreatePropertyMap( map );
357   }
358
359   Property::Map transform;
360   mImpl->mTransform.GetPropertyMap( transform );
361   map.Insert( Toolkit::Visual::Property::TRANSFORM, transform );
362
363   bool premultipliedAlpha( IsPreMultipliedAlphaEnabled() );
364   map.Insert( Toolkit::Visual::Property::PREMULTIPLIED_ALPHA, premultipliedAlpha );
365
366   // Note, Color and Primitive will also insert their own mix color into the map
367   // which is ok, because they have a different key value range.
368   map.Insert( Toolkit::Visual::Property::MIX_COLOR, mImpl->mMixColor ); // vec4
369   map.Insert( Toolkit::Visual::Property::OPACITY, mImpl->mMixColor.a );
370
371   auto fittingModeString = Scripting::GetLinearEnumerationName< FittingMode >(
372     mImpl->mFittingMode, VISUAL_FITTING_MODE_TABLE, VISUAL_FITTING_MODE_TABLE_COUNT );
373   map.Insert( Toolkit::DevelVisual::Property::VISUAL_FITTING_MODE, fittingModeString );
374
375   map.Insert( Toolkit::DevelVisual::Property::CORNER_RADIUS, mImpl->mCornerRadius );
376   map.Insert( Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, static_cast< int >( mImpl->mCornerRadiusPolicy ) );
377 }
378
379 void Visual::Base::CreateInstancePropertyMap( Property::Map& map ) const
380 {
381   DoCreateInstancePropertyMap( map );
382
383   if( mImpl->mCustomShader )
384   {
385     mImpl->mCustomShader->CreatePropertyMap( map );
386   }
387
388   //map.Insert( Toolkit::Visual::Property::DEPTH_INDEX, mImpl->mDepthIndex );
389   //map.Insert( Toolkit::Visual::Property::ENABLED, (bool) mImpl->mRenderer );
390 }
391
392
393 void Visual::Base::EnablePreMultipliedAlpha( bool preMultiplied )
394 {
395   if( preMultiplied )
396   {
397     mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA;
398   }
399   else
400   {
401     mImpl->mFlags &= ~Impl::IS_PREMULTIPLIED_ALPHA;
402   }
403
404   if( mImpl->mRenderer )
405   {
406     mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, preMultiplied);
407     mImpl->mRenderer.RegisterProperty( PRE_MULTIPLIED_ALPHA_PROPERTY, static_cast<float>( preMultiplied ) );
408   }
409 }
410
411 bool Visual::Base::IsPreMultipliedAlphaEnabled() const
412 {
413   return mImpl->mFlags & Impl::IS_PREMULTIPLIED_ALPHA;
414 }
415
416 bool Visual::Base::IsAdvancedBlendEquationApplied() const
417 {
418   return IsPreMultipliedAlphaEnabled() && DevelRenderer::IsAdvancedBlendEquationApplied( mImpl->mRenderer );
419 }
420
421 void Visual::Base::DoSetOffScene( Actor& actor )
422 {
423   actor.RemoveRenderer( mImpl->mRenderer );
424   mImpl->mRenderer.Reset();
425 }
426
427 bool Visual::Base::IsOnScene() const
428 {
429   return mImpl->mFlags & Impl::IS_ON_SCENE;
430 }
431
432 bool Visual::Base::IsRoundedCornerRequired() const
433 {
434   return !EqualsZero( mImpl->mCornerRadius );
435 }
436
437 void Visual::Base::OnDoAction( const Property::Index actionId, const Property::Value& attributes )
438 {
439   // May be overriden by derived class
440 }
441
442 void Visual::Base::RegisterMixColor()
443 {
444   // Only register if not already registered.
445   // (Color and Primitive visuals will register their own and save to this index)
446   if( mImpl->mMixColorIndex == Property::INVALID_INDEX )
447   {
448     mImpl->mMixColorIndex = mImpl->mRenderer.RegisterProperty(
449       Toolkit::Visual::Property::MIX_COLOR,
450       MIX_COLOR,
451       Vector3(mImpl->mMixColor) );
452   }
453
454   mImpl->mRenderer.SetProperty( DevelRenderer::Property::OPACITY, mImpl->mMixColor.a );
455
456   float preMultipliedAlpha = 0.0f;
457   if( IsPreMultipliedAlphaEnabled() )
458   {
459     preMultipliedAlpha = 1.0f;
460   }
461   mImpl->mRenderer.RegisterProperty( PRE_MULTIPLIED_ALPHA_PROPERTY, preMultipliedAlpha );
462 }
463
464 void Visual::Base::SetMixColor( const Vector4& color )
465 {
466   mImpl->mMixColor = color;
467
468   if( mImpl->mRenderer )
469   {
470     mImpl->mRenderer.SetProperty( mImpl->mMixColorIndex, Vector3(color) );
471     mImpl->mRenderer.SetProperty( DevelRenderer::Property::OPACITY, color.a );
472   }
473 }
474
475 void Visual::Base::SetMixColor( const Vector3& color )
476 {
477   mImpl->mMixColor.r = color.r;
478   mImpl->mMixColor.g = color.g;
479   mImpl->mMixColor.b = color.b;
480
481   if( mImpl->mRenderer )
482   {
483     mImpl->mRenderer.SetProperty( mImpl->mMixColorIndex, color );
484   }
485 }
486
487 const Vector4& Visual::Base::GetMixColor() const
488 {
489   return mImpl->mMixColor;
490 }
491
492 void Visual::Base::AddEventObserver( Visual::EventObserver& observer)
493 {
494   mImpl->mEventObserver = &observer;
495 }
496
497 void Visual::Base::RemoveEventObserver( Visual::EventObserver& observer )
498 {
499   mImpl->mEventObserver = NULL;
500 }
501
502 void Visual::Base::ResourceReady(Toolkit::Visual::ResourceStatus resourceStatus)
503 {
504   if( mImpl->mResourceStatus != resourceStatus )
505   {
506     mImpl->mResourceStatus = resourceStatus;
507
508     if( mImpl->mEventObserver )
509     {
510       // observer is currently a control impl
511       mImpl->mEventObserver->ResourceReady( *this );
512     }
513   }
514 }
515
516 bool Visual::Base::IsResourceReady() const
517 {
518   return ( mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::READY );
519 }
520
521 bool Visual::Base::IsSynchronousLoadingRequired() const
522 {
523   return ( mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING );
524 }
525
526 Toolkit::Visual::Type Visual::Base::GetType() const
527 {
528   return mImpl->mType;
529 }
530
531 Toolkit::Visual::ResourceStatus Visual::Base::GetResourceStatus() const
532 {
533   return mImpl->mResourceStatus;
534 }
535
536 Visual::FittingMode Visual::Base::GetFittingMode() const
537 {
538   return mImpl->mFittingMode;
539 }
540
541 Visual::Base& Visual::Base::GetVisualObject()
542 {
543   return *this;
544 }
545
546 Renderer Visual::Base::GetRenderer()
547 {
548   return mImpl->mRenderer;
549 }
550
551 Property::Index Visual::Base::GetPropertyIndex( Property::Key key )
552 {
553   Property::Index index = mImpl->mRenderer.GetPropertyIndex( key );
554
555   if( index == Property::INVALID_INDEX )
556   {
557     // Is it a shader property?
558     Shader shader = mImpl->mRenderer.GetShader();
559     index = shader.GetPropertyIndex( key );
560     if( index != Property::INVALID_INDEX )
561     {
562       // Yes - we should register it in the Renderer so it can be set / animated
563       // independently, as shaders are shared across multiple renderers.
564       std::string keyName;
565       Property::Index keyIndex( Property::INVALID_KEY );
566       if( key.type == Property::Key::INDEX )
567       {
568         keyName = shader.GetPropertyName( index );
569         keyIndex = key.indexKey;
570       }
571       else
572       {
573         keyName = key.stringKey;
574         // Leave keyIndex as INVALID_KEY - it can still be registered against the string key.
575       }
576       Property::Value value = shader.GetProperty( index );
577       index = mImpl->mRenderer.RegisterProperty( keyIndex, keyName, value );
578     }
579   }
580   return index;
581 }
582
583 void Visual::Base::SetupTransition(
584   Dali::Animation& transition,
585   Internal::TransitionData::Animator& animator,
586   Property::Index index,
587   Property::Value& initialValue,
588   Property::Value& targetValue )
589 {
590   if( index != Property::INVALID_INDEX )
591   {
592     if( mImpl->mRenderer )
593     {
594       if( animator.animate == false )
595       {
596         mImpl->mRenderer.SetProperty( index, targetValue );
597       }
598       else
599       {
600         if( animator.initialValue.GetType() != Property::NONE )
601         {
602           mImpl->mRenderer.SetProperty( index, initialValue );
603         }
604
605         if( ! transition )
606         {
607           transition = Dali::Animation::New( 0.1f );
608         }
609
610         transition.AnimateTo( Property( mImpl->mRenderer, index ),
611                               targetValue,
612                               animator.alphaFunction,
613                               TimePeriod( animator.timePeriodDelay,
614                                           animator.timePeriodDuration ) );
615       }
616     }
617   }
618 }
619
620 void Visual::Base::AnimateProperty(
621   Dali::Animation& transition,
622   Internal::TransitionData::Animator& animator )
623 {
624 #if defined(DEBUG_ENABLED)
625   {
626     std::ostringstream oss;
627     oss << "Visual::Base::AnimateProperty(Visual:" << mImpl->mName << " Property:" << animator.propertyKey << " Target: " << animator.targetValue << std::endl;
628     DALI_LOG_INFO( gVisualBaseLogFilter, Debug::General, oss.str().c_str() );
629   }
630 #endif
631
632   Property::Map map;
633   DoCreatePropertyMap( map );
634   Property::Value* valuePtr = map.Find( Toolkit::Visual::Property::TYPE );
635   int visualType = -1;
636   if( valuePtr )
637   {
638     valuePtr->Get( visualType );
639   }
640
641   if( animator.propertyKey == Toolkit::Visual::Property::MIX_COLOR ||
642       animator.propertyKey == MIX_COLOR ||
643       ( visualType == Toolkit::Visual::COLOR &&
644         animator.propertyKey == ColorVisual::Property::MIX_COLOR ) ||
645       ( visualType == Toolkit::Visual::PRIMITIVE &&
646         animator.propertyKey == PrimitiveVisual::Property::MIX_COLOR ) )
647   {
648     AnimateMixColorProperty( transition, animator );
649   }
650   else if(animator.propertyKey == Toolkit::Visual::Property::OPACITY ||
651           animator.propertyKey == OPACITY )
652   {
653     AnimateOpacityProperty( transition, animator );
654   }
655   else if( mImpl->mRenderer )
656   {
657     AnimateRendererProperty( transition, animator );
658   }
659 }
660
661 void Visual::Base::AnimateOpacityProperty(
662   Dali::Animation& transition,
663   Internal::TransitionData::Animator& animator )
664 {
665   float targetOpacity;
666   if( animator.targetValue.Get( targetOpacity ) )
667   {
668     mImpl->mMixColor.a = targetOpacity;
669   }
670
671   SetupTransition( transition, animator, DevelRenderer::Property::OPACITY, animator.initialValue, animator.targetValue );
672 }
673
674 void Visual::Base::AnimateRendererProperty(
675   Dali::Animation& transition,
676   Internal::TransitionData::Animator& animator )
677 {
678   Property::Index index = GetPropertyIndex( animator.propertyKey );
679   if( index != Property::INVALID_INDEX )
680   {
681     if( animator.targetValue.GetType() != Property::NONE )
682     {
683       // Try writing target value into transform property map
684       // if it's not a valid key, then it won't alter mTransform
685       Property::Map map;
686       if( animator.propertyKey.type == Property::Key::INDEX )
687       {
688         map.Add( animator.propertyKey.indexKey, animator.targetValue );
689       }
690       else
691       {
692         map.Add( animator.propertyKey.stringKey, animator.targetValue );
693       }
694
695       mImpl->mTransform.UpdatePropertyMap( map );
696     }
697
698     SetupTransition( transition, animator, index, animator.initialValue, animator.targetValue );
699   }
700 }
701
702 void Visual::Base::AnimateMixColorProperty(
703   Dali::Animation& transition,
704   Internal::TransitionData::Animator& animator )
705 {
706   Property::Index index = mImpl->mMixColorIndex;
707   bool animateOpacity = false;
708
709   Property::Value initialOpacity;
710   Property::Value targetOpacity;
711   Property::Value initialMixColor;
712   Property::Value targetMixColor;
713
714   if( index != Property::INVALID_INDEX )
715   {
716     Vector4 initialColor;
717     if( animator.initialValue.Get(initialColor) )
718     {
719       if( animator.initialValue.GetType() == Property::VECTOR4 )
720       {
721         // if there is an initial color specifying alpha, test it
722         initialOpacity = initialColor.a;
723       }
724       initialMixColor = Vector3( initialColor );
725     }
726
727     // Set target value into data store
728     if( animator.targetValue.GetType() != Property::NONE )
729     {
730       Vector4 mixColor;
731       animator.targetValue.Get(mixColor);
732       if( animator.targetValue.GetType() == Property::VECTOR4 )
733       {
734         mImpl->mMixColor.a = mixColor.a;
735         targetOpacity = mixColor.a;
736         animateOpacity = true;
737       }
738
739       mImpl->mMixColor.r = mixColor.r;
740       mImpl->mMixColor.g = mixColor.g;
741       mImpl->mMixColor.b = mixColor.b;
742       targetMixColor = Vector3(mixColor);
743     }
744
745     SetupTransition( transition, animator, index, initialMixColor, targetMixColor );
746     if( animateOpacity )
747     {
748       SetupTransition( transition, animator, DevelRenderer::Property::OPACITY, initialOpacity, targetOpacity );
749     }
750   }
751 }
752
753 } // namespace Internal
754
755 } // namespace Toolkit
756
757 } // namespace Dali