Ensure DALI_*_API is stripped out from the doxygen documentation
[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(DevelVisual::Property::CORNER_RADIUS, 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     if(mImpl->mRenderer)
344     {
345       // Update values from Renderer
346       mImpl->mMixColor   = mImpl->mRenderer.GetProperty<Vector3>(mImpl->mMixColorIndex);
347       mImpl->mMixColor.a = mImpl->mRenderer.GetProperty<float>(DevelRenderer::Property::OPACITY);
348       if(mImpl->mCornerRadiusIndex != Property::INVALID_INDEX)
349       {
350         mImpl->mCornerRadius = mImpl->mRenderer.GetProperty<float>(mImpl->mCornerRadiusIndex);
351       }
352     }
353
354     DoSetOffScene( actor );
355     mImpl->mMixColorIndex = Property::INVALID_INDEX;
356     mImpl->mCornerRadiusIndex = Property::INVALID_INDEX;
357     mImpl->mFlags &= ~Impl::IS_ON_SCENE;
358   }
359 }
360
361 void Visual::Base::CreatePropertyMap( Property::Map& map ) const
362 {
363   if(mImpl->mRenderer)
364   {
365     // Update values from Renderer
366     mImpl->mMixColor   = mImpl->mRenderer.GetProperty<Vector3>(mImpl->mMixColorIndex);
367     mImpl->mMixColor.a = mImpl->mRenderer.GetProperty<float>(DevelRenderer::Property::OPACITY);
368     if(mImpl->mCornerRadiusIndex != Property::INVALID_INDEX)
369     {
370       mImpl->mCornerRadius = mImpl->mRenderer.GetProperty<float>(mImpl->mCornerRadiusIndex);
371     }
372   }
373
374   DoCreatePropertyMap(map);
375
376   if(mImpl->mCustomShader)
377   {
378     mImpl->mCustomShader->CreatePropertyMap(map);
379   }
380
381   Property::Map transform;
382   mImpl->mTransform.GetPropertyMap( transform );
383   map.Insert( Toolkit::Visual::Property::TRANSFORM, transform );
384
385   bool premultipliedAlpha( IsPreMultipliedAlphaEnabled() );
386   map.Insert( Toolkit::Visual::Property::PREMULTIPLIED_ALPHA, premultipliedAlpha );
387
388   // Note, Color and Primitive will also insert their own mix color into the map
389   // which is ok, because they have a different key value range.
390   map.Insert( Toolkit::Visual::Property::MIX_COLOR, mImpl->mMixColor ); // vec4
391   map.Insert( Toolkit::Visual::Property::OPACITY, mImpl->mMixColor.a );
392
393   auto fittingModeString = Scripting::GetLinearEnumerationName< FittingMode >(
394     mImpl->mFittingMode, VISUAL_FITTING_MODE_TABLE, VISUAL_FITTING_MODE_TABLE_COUNT );
395   map.Insert( Toolkit::DevelVisual::Property::VISUAL_FITTING_MODE, fittingModeString );
396
397   map.Insert( Toolkit::DevelVisual::Property::CORNER_RADIUS, mImpl->mCornerRadius );
398   map.Insert( Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, static_cast< int >( mImpl->mCornerRadiusPolicy ) );
399 }
400
401 void Visual::Base::CreateInstancePropertyMap( Property::Map& map ) const
402 {
403   DoCreateInstancePropertyMap( map );
404
405   if( mImpl->mCustomShader )
406   {
407     mImpl->mCustomShader->CreatePropertyMap( map );
408   }
409
410   //map.Insert( Toolkit::Visual::Property::DEPTH_INDEX, mImpl->mDepthIndex );
411   //map.Insert( Toolkit::Visual::Property::ENABLED, (bool) mImpl->mRenderer );
412 }
413
414
415 void Visual::Base::EnablePreMultipliedAlpha( bool preMultiplied )
416 {
417   if( preMultiplied )
418   {
419     mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA;
420   }
421   else
422   {
423     mImpl->mFlags &= ~Impl::IS_PREMULTIPLIED_ALPHA;
424   }
425
426   if( mImpl->mRenderer )
427   {
428     mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, preMultiplied);
429     mImpl->mRenderer.RegisterProperty( PRE_MULTIPLIED_ALPHA_PROPERTY, static_cast<float>( preMultiplied ) );
430   }
431 }
432
433 bool Visual::Base::IsPreMultipliedAlphaEnabled() const
434 {
435   return mImpl->mFlags & Impl::IS_PREMULTIPLIED_ALPHA;
436 }
437
438 void Visual::Base::DoSetOffScene( Actor& actor )
439 {
440   actor.RemoveRenderer( mImpl->mRenderer );
441   mImpl->mRenderer.Reset();
442 }
443
444 bool Visual::Base::IsOnScene() const
445 {
446   return mImpl->mFlags & Impl::IS_ON_SCENE;
447 }
448
449 bool Visual::Base::IsRoundedCornerRequired() const
450 {
451   if(mImpl->mRenderer && mImpl->mCornerRadiusIndex != Property::INVALID_INDEX)
452   {
453     // Update values from Renderer
454     mImpl->mCornerRadius = mImpl->mRenderer.GetProperty<float>(mImpl->mCornerRadiusIndex);
455   }
456   return !EqualsZero(mImpl->mCornerRadius) || mImpl->mNeedCornerRadius;
457 }
458
459 void Visual::Base::OnDoAction( const Property::Index actionId, const Property::Value& attributes )
460 {
461   // May be overriden by derived class
462 }
463
464 void Visual::Base::RegisterMixColor()
465 {
466   // Only register if not already registered.
467   // (Color and Primitive visuals will register their own and save to this index)
468   if( mImpl->mMixColorIndex == Property::INVALID_INDEX )
469   {
470     mImpl->mMixColorIndex = mImpl->mRenderer.RegisterProperty(
471       Toolkit::Visual::Property::MIX_COLOR,
472       MIX_COLOR,
473       Vector3(mImpl->mMixColor) );
474   }
475
476   mImpl->mRenderer.SetProperty( DevelRenderer::Property::OPACITY, mImpl->mMixColor.a );
477
478   float preMultipliedAlpha = 0.0f;
479   if( IsPreMultipliedAlphaEnabled() )
480   {
481     preMultipliedAlpha = 1.0f;
482   }
483   mImpl->mRenderer.RegisterProperty( PRE_MULTIPLIED_ALPHA_PROPERTY, preMultipliedAlpha );
484 }
485
486 void Visual::Base::SetMixColor( const Vector4& color )
487 {
488   mImpl->mMixColor = color;
489
490   if( mImpl->mRenderer )
491   {
492     mImpl->mRenderer.SetProperty( mImpl->mMixColorIndex, Vector3(color) );
493     mImpl->mRenderer.SetProperty( DevelRenderer::Property::OPACITY, color.a );
494   }
495 }
496
497 void Visual::Base::SetMixColor( const Vector3& color )
498 {
499   mImpl->mMixColor.r = color.r;
500   mImpl->mMixColor.g = color.g;
501   mImpl->mMixColor.b = color.b;
502
503   if( mImpl->mRenderer )
504   {
505     mImpl->mRenderer.SetProperty( mImpl->mMixColorIndex, color );
506   }
507 }
508
509 void Visual::Base::AddEventObserver( Visual::EventObserver& observer)
510 {
511   mImpl->mEventObserver = &observer;
512 }
513
514 void Visual::Base::RemoveEventObserver( Visual::EventObserver& observer )
515 {
516   mImpl->mEventObserver = NULL;
517 }
518
519 void Visual::Base::ResourceReady(Toolkit::Visual::ResourceStatus resourceStatus)
520 {
521   if( mImpl->mResourceStatus != resourceStatus )
522   {
523     mImpl->mResourceStatus = resourceStatus;
524
525     if( mImpl->mEventObserver )
526     {
527       // observer is currently a control impl
528       mImpl->mEventObserver->ResourceReady( *this );
529     }
530   }
531 }
532
533 bool Visual::Base::IsResourceReady() const
534 {
535   return ( mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::READY );
536 }
537
538 bool Visual::Base::IsSynchronousLoadingRequired() const
539 {
540   return ( mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING );
541 }
542
543 Toolkit::Visual::Type Visual::Base::GetType() const
544 {
545   return mImpl->mType;
546 }
547
548 Toolkit::Visual::ResourceStatus Visual::Base::GetResourceStatus() const
549 {
550   return mImpl->mResourceStatus;
551 }
552
553 Visual::FittingMode Visual::Base::GetFittingMode() const
554 {
555   return mImpl->mFittingMode;
556 }
557
558 Visual::Base& Visual::Base::GetVisualObject()
559 {
560   return *this;
561 }
562
563 Renderer Visual::Base::GetRenderer()
564 {
565   return mImpl->mRenderer;
566 }
567
568 Property::Index Visual::Base::GetPropertyIndex( Property::Key key )
569 {
570   Property::Index index = mImpl->mRenderer.GetPropertyIndex( key );
571
572   if( index == Property::INVALID_INDEX )
573   {
574     // Is it a shader property?
575     Shader shader = mImpl->mRenderer.GetShader();
576     index = shader.GetPropertyIndex( key );
577     if( index != Property::INVALID_INDEX )
578     {
579       // Yes - we should register it in the Renderer so it can be set / animated
580       // independently, as shaders are shared across multiple renderers.
581       std::string keyName;
582       Property::Index keyIndex( Property::INVALID_KEY );
583       if( key.type == Property::Key::INDEX )
584       {
585         keyName = shader.GetPropertyName( index );
586         keyIndex = key.indexKey;
587       }
588       else
589       {
590         keyName = key.stringKey;
591         // Leave keyIndex as INVALID_KEY - it can still be registered against the string key.
592       }
593       Property::Value value = shader.GetProperty( index );
594       index = mImpl->mRenderer.RegisterProperty( keyIndex, keyName, value );
595     }
596   }
597   return index;
598 }
599
600 void Visual::Base::SetupTransition(
601   Dali::Animation& transition,
602   Internal::TransitionData::Animator& animator,
603   Property::Index index,
604   Property::Value& initialValue,
605   Property::Value& targetValue )
606 {
607   if( index != Property::INVALID_INDEX )
608   {
609     if( mImpl->mRenderer )
610     {
611       if( animator.animate == false )
612       {
613         mImpl->mRenderer.SetProperty( index, targetValue );
614       }
615       else
616       {
617         if( animator.initialValue.GetType() != Property::NONE )
618         {
619           mImpl->mRenderer.SetProperty( index, initialValue );
620         }
621
622         if( ! transition )
623         {
624           transition = Dali::Animation::New( 0.1f );
625         }
626
627         transition.AnimateTo( Property( mImpl->mRenderer, index ),
628                               targetValue,
629                               animator.alphaFunction,
630                               TimePeriod( animator.timePeriodDelay,
631                                           animator.timePeriodDuration ) );
632       }
633     }
634   }
635 }
636
637 void Visual::Base::AnimateProperty(
638   Dali::Animation& transition,
639   Internal::TransitionData::Animator& animator )
640 {
641 #if defined(DEBUG_ENABLED)
642   {
643     std::ostringstream oss;
644     oss << "Visual::Base::AnimateProperty(Visual:" << mImpl->mName << " Property:" << animator.propertyKey << " Target: " << animator.targetValue << std::endl;
645     DALI_LOG_INFO( gVisualBaseLogFilter, Debug::General, oss.str().c_str() );
646   }
647 #endif
648
649   if(animator.propertyKey == Toolkit::Visual::Property::MIX_COLOR ||
650      animator.propertyKey == MIX_COLOR ||
651      (mImpl->mType == Toolkit::Visual::COLOR &&
652       animator.propertyKey == ColorVisual::Property::MIX_COLOR) ||
653      (mImpl->mType == Toolkit::Visual::PRIMITIVE &&
654       animator.propertyKey == PrimitiveVisual::Property::MIX_COLOR))
655   {
656     AnimateMixColorProperty( transition, animator );
657   }
658   else if(animator.propertyKey == Toolkit::Visual::Property::OPACITY ||
659           animator.propertyKey == OPACITY )
660   {
661     AnimateOpacityProperty( transition, animator );
662   }
663   else if( mImpl->mRenderer )
664   {
665     AnimateRendererProperty( transition, animator );
666   }
667 }
668
669 void Visual::Base::AnimateOpacityProperty(
670   Dali::Animation& transition,
671   Internal::TransitionData::Animator& animator )
672 {
673   float targetOpacity;
674   if( animator.targetValue.Get( targetOpacity ) )
675   {
676     mImpl->mMixColor.a = targetOpacity;
677   }
678
679   SetupTransition( transition, animator, DevelRenderer::Property::OPACITY, animator.initialValue, animator.targetValue );
680 }
681
682 void Visual::Base::AnimateRendererProperty(
683   Dali::Animation& transition,
684   Internal::TransitionData::Animator& animator )
685 {
686   Property::Index index = GetPropertyIndex( animator.propertyKey );
687   if( index != Property::INVALID_INDEX )
688   {
689     if( animator.targetValue.GetType() != Property::NONE )
690     {
691       // Try writing target value into transform property map
692       // if it's not a valid key, then it won't alter mTransform
693       Property::Map map;
694       if( animator.propertyKey.type == Property::Key::INDEX )
695       {
696         map.Add( animator.propertyKey.indexKey, animator.targetValue );
697       }
698       else
699       {
700         map.Add( animator.propertyKey.stringKey, animator.targetValue );
701       }
702
703       mImpl->mTransform.UpdatePropertyMap( map );
704     }
705
706     SetupTransition( transition, animator, index, animator.initialValue, animator.targetValue );
707   }
708 }
709
710 void Visual::Base::AnimateMixColorProperty(
711   Dali::Animation& transition,
712   Internal::TransitionData::Animator& animator )
713 {
714   Property::Index index = mImpl->mMixColorIndex;
715   bool animateOpacity = false;
716
717   Property::Value initialOpacity;
718   Property::Value targetOpacity;
719   Property::Value initialMixColor;
720   Property::Value targetMixColor;
721
722   if( index != Property::INVALID_INDEX )
723   {
724     Vector4 initialColor;
725     if( animator.initialValue.Get(initialColor) )
726     {
727       if( animator.initialValue.GetType() == Property::VECTOR4 )
728       {
729         // if there is an initial color specifying alpha, test it
730         initialOpacity = initialColor.a;
731       }
732       initialMixColor = Vector3( initialColor );
733     }
734
735     // Set target value into data store
736     if( animator.targetValue.GetType() != Property::NONE )
737     {
738       Vector4 mixColor;
739       animator.targetValue.Get(mixColor);
740       if( animator.targetValue.GetType() == Property::VECTOR4 )
741       {
742         mImpl->mMixColor.a = mixColor.a;
743         targetOpacity = mixColor.a;
744         animateOpacity = true;
745       }
746
747       mImpl->mMixColor.r = mixColor.r;
748       mImpl->mMixColor.g = mixColor.g;
749       mImpl->mMixColor.b = mixColor.b;
750       targetMixColor = Vector3(mixColor);
751     }
752
753     SetupTransition( transition, animator, index, initialMixColor, targetMixColor );
754     if( animateOpacity )
755     {
756       SetupTransition( transition, animator, DevelRenderer::Property::OPACITY, initialOpacity, targetOpacity );
757     }
758   }
759 }
760
761 Dali::Property Visual::Base::GetPropertyObject(Dali::Property::Key key)
762 {
763   if(!mImpl->mRenderer)
764   {
765     Handle handle;
766     return Dali::Property(handle, Property::INVALID_INDEX);
767   }
768
769   // Mix color or opacity cases
770   if(key.type == Property::Key::INDEX)
771   {
772     if(key.indexKey == Toolkit::Visual::Property::MIX_COLOR || (mImpl->mType == Toolkit::Visual::COLOR && key.indexKey == ColorVisual::Property::MIX_COLOR) || (mImpl->mType == Toolkit::Visual::PRIMITIVE && key.indexKey == PrimitiveVisual::Property::MIX_COLOR))
773     {
774       return Dali::Property(mImpl->mRenderer, mImpl->mMixColorIndex);
775     }
776     else if(key.indexKey == Toolkit::Visual::Property::OPACITY)
777     {
778       return Dali::Property(mImpl->mRenderer, DevelRenderer::Property::OPACITY);
779     }
780   }
781   else
782   {
783     if(key.stringKey == MIX_COLOR)
784     {
785       return Dali::Property(mImpl->mRenderer, mImpl->mMixColorIndex);
786     }
787     else if(key.stringKey == OPACITY)
788     {
789       return Dali::Property(mImpl->mRenderer, DevelRenderer::Property::OPACITY);
790     }
791   }
792
793   // Other cases
794   Property::Index index = GetPropertyIndex(key);
795   if(index == Property::INVALID_INDEX)
796   {
797     if((key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::CORNER_RADIUS) || (key.type == Property::Key::STRING && key.stringKey == CORNER_RADIUS))
798     {
799       // Register CORNER_RADIUS property
800       mImpl->mCornerRadiusIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::CORNER_RADIUS, CORNER_RADIUS, mImpl->mCornerRadius);
801       mImpl->mRenderer.RegisterProperty(CORNER_RADIUS_POLICY, mImpl->mCornerRadiusPolicy);
802       index = mImpl->mCornerRadiusIndex;
803
804       mImpl->mNeedCornerRadius = true;
805
806       // Change shader
807       UpdateShader();
808     }
809     else
810     {
811       // We can't find the property in the base class.
812       // Request to child class
813       return OnGetPropertyObject(key);
814     }
815   }
816
817   return Dali::Property(mImpl->mRenderer, index);
818 }
819
820 } // namespace Internal
821
822 } // namespace Toolkit
823
824 } // namespace Dali