Reduce Cyclomatic Complexity of some methods in text-typesetter, transtion-data ...

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / transition-data-impl.cpp

diff --git a/dali-toolkit/internal/visuals/transition-data-impl.cpp b/dali-toolkit/internal/visuals/transition-data-impl.cpp
index 30c0dee..bda70a4 100644 (file)
--- a/dali-toolkit/internal/visuals/transition-data-impl.cpp
+++ b/dali-toolkit/internal/visuals/transition-data-impl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -65,6 +65,114 @@ namespace Toolkit
 namespace Internal
 {
 
+namespace
+{
+
+/// Parses a Property::Array and sets up the animator appropriately
+void ParseArray(TransitionData::Animator* animator, const Property::Array* array)
+{
+  bool valid = true;
+  Vector4 controlPoints;
+  if( array && array->Count() >= 4 )
+  {
+    for( size_t vecIdx = 0; vecIdx < 4; ++vecIdx )
+    {
+      const Property::Value& v = array->GetElementAt(vecIdx);
+      if( v.GetType() == Property::FLOAT )
+      {
+        controlPoints[vecIdx] = v.Get<float>();
+      }
+      else
+      {
+        valid = false;
+        break;
+      }
+    }
+  }
+  else
+  {
+    valid = false;
+  }
+
+  if( valid )
+  {
+    Vector2 controlPoint1( controlPoints.x, controlPoints.y );
+    Vector2 controlPoint2( controlPoints.z, controlPoints.w );
+    animator->alphaFunction = AlphaFunction( controlPoint1, controlPoint2 );
+  }
+  else
+  {
+    animator->animate = false;
+  }
+}
+
+/// Parses a string value and sets up the animator appropriately
+void ParseString(TransitionData::Animator* animator, std::string alphaFunctionValue)
+{
+  if( alphaFunctionValue == "LINEAR" )
+  {
+    animator->alphaFunction = AlphaFunction(AlphaFunction::LINEAR);
+  }
+  else if( ! alphaFunctionValue.compare(0, 5, "EASE_" ) )
+  {
+    if( alphaFunctionValue == "EASE_IN" )
+    {
+      animator->alphaFunction = AlphaFunction(AlphaFunction::EASE_IN);
+    }
+    else if( alphaFunctionValue == "EASE_OUT" )
+    {
+      animator->alphaFunction = AlphaFunction(AlphaFunction::EASE_OUT);
+    }
+    else if( ! alphaFunctionValue.compare( 5, 3, "IN_" ) )
+    {
+      if( ! alphaFunctionValue.compare(8, -1, "SQUARE" ))
+      {
+        animator->alphaFunction = AlphaFunction(AlphaFunction::EASE_IN_SQUARE);
+      }
+      else if( ! alphaFunctionValue.compare(8, -1, "OUT" ))
+      {
+        animator->alphaFunction = AlphaFunction(AlphaFunction::EASE_IN_OUT);
+      }
+      else if( ! alphaFunctionValue.compare(8, -1, "OUT_SINE" ))
+      {
+        animator->alphaFunction = AlphaFunction(AlphaFunction::EASE_IN_OUT_SINE);
+      }
+      else if( ! alphaFunctionValue.compare(8, -1, "SINE" ))
+      {
+        animator->alphaFunction = AlphaFunction(AlphaFunction::EASE_IN_SINE);
+      }
+    }
+    else if( ! alphaFunctionValue.compare( 5, 4, "OUT_" ) )
+    {
+      if( ! alphaFunctionValue.compare(9, -1, "SQUARE" ) )
+      {
+        animator->alphaFunction = AlphaFunction(AlphaFunction::EASE_OUT_SQUARE);
+      }
+      else if( ! alphaFunctionValue.compare(9, -1, "SINE" ) )
+      {
+        animator->alphaFunction = AlphaFunction(AlphaFunction::EASE_OUT_SINE);
+      }
+      else if( ! alphaFunctionValue.compare(9, -1, "BACK" ) )
+      {
+        animator->alphaFunction = AlphaFunction(AlphaFunction::EASE_OUT_BACK);
+      }
+    }
+  }
+  else if( alphaFunctionValue == "REVERSE" )
+  {
+    animator->alphaFunction = AlphaFunction(AlphaFunction::REVERSE);
+  }
+  else if( alphaFunctionValue == "BOUNCE" )
+  {
+    animator->alphaFunction = AlphaFunction(AlphaFunction::BOUNCE);
+  }
+  else if( alphaFunctionValue == "SIN" )
+  {
+    animator->alphaFunction = AlphaFunction(AlphaFunction::SIN);
+  }
+}
+} // unnamed namespace
+
 TransitionData::TransitionData()
 {
 }
@@ -101,7 +209,7 @@ void TransitionData::Initialize( const Property::Array& array )
     const Property::Value& element = array.GetElementAt( arrayIdx );
     // Expect each child to be an object representing an animator:
 
-    Property::Map* map = element.GetMap();
+    const Property::Map* map = element.GetMap();
     if( map != NULL )
     {
       TransitionData::Animator* animator = ConvertMap( *map );
@@ -169,68 +277,24 @@ TransitionData::Animator* TransitionData::ConvertMap( const Property::Map& map)
 
         if( key == TOKEN_ALPHA_FUNCTION )
         {
-          std::string alphaFunctionValue = value.Get< std::string >();
-
-          if( alphaFunctionValue == "LINEAR" )
+          if( value.GetType() == Property::ARRAY )
           {
-            animator->alphaFunction = AlphaFunction::LINEAR;
+            ParseArray(animator, value.GetArray());
           }
-          else if( ! alphaFunctionValue.compare(0, 5, "EASE_" ) )
+          else if( value.GetType() == Property::VECTOR4 )
           {
-            if( alphaFunctionValue == "EASE_IN" )
-            {
-              animator->alphaFunction = AlphaFunction::EASE_IN;
-            }
-            else if( alphaFunctionValue == "EASE_OUT" )
-            {
-              animator->alphaFunction = AlphaFunction::EASE_OUT;
-            }
-            else if( ! alphaFunctionValue.compare( 5, 3, "IN_" ) )
-            {
-              if( ! alphaFunctionValue.compare(8, -1, "SQUARE" ))
-              {
-                animator->alphaFunction = AlphaFunction::EASE_IN_SQUARE;
-              }
-              else if( ! alphaFunctionValue.compare(8, -1, "OUT" ))
-              {
-                animator->alphaFunction = AlphaFunction::EASE_IN_OUT;
-              }
-              else if( ! alphaFunctionValue.compare(8, -1, "OUT_SINE" ))
-              {
-                animator->alphaFunction = AlphaFunction::EASE_IN_OUT_SINE;
-              }
-              else if( ! alphaFunctionValue.compare(8, -1, "SINE" ))
-              {
-                animator->alphaFunction = AlphaFunction::EASE_IN_SINE;
-              }
-            }
-            else if( ! alphaFunctionValue.compare( 5, 4, "OUT_" ) )
-            {
-              if( ! alphaFunctionValue.compare(9, -1, "SQUARE" ) )
-              {
-                animator->alphaFunction = AlphaFunction::EASE_OUT_SQUARE;
-              }
-              else if( ! alphaFunctionValue.compare(9, -1, "SINE" ) )
-              {
-                animator->alphaFunction = AlphaFunction::EASE_OUT_SINE;
-              }
-              else if( ! alphaFunctionValue.compare(9, -1, "BACK" ) )
-              {
-                animator->alphaFunction = AlphaFunction::EASE_OUT_BACK;
-              }
-            }
-          }
-          else if( alphaFunctionValue == "REVERSE" )
-          {
-            animator->alphaFunction = AlphaFunction::REVERSE;
+            Vector4 controlPoints = value.Get<Vector4>();
+            Vector2 controlPoint1( controlPoints.x, controlPoints.y );
+            Vector2 controlPoint2( controlPoints.z, controlPoints.w );
+            animator->alphaFunction = AlphaFunction( controlPoint1, controlPoint2 );
           }
-          else if( alphaFunctionValue == "BOUNCE" )
+          else if( value.GetType() == Property::STRING )
           {
-            animator->alphaFunction = AlphaFunction::BOUNCE;
+            ParseString(animator, value.Get< std::string >());
           }
-          else if( alphaFunctionValue == "SIN" )
+          else
           {
-            animator->alphaFunction = AlphaFunction::SIN;
+            animator->animate = false;
           }
         }
         else if( key == TOKEN_TIME_PERIOD )
@@ -306,13 +370,24 @@ Property::Map TransitionData::GetAnimatorAt( size_t index )
   }
   if( animator->animate )
   {
-    map[TOKEN_ANIMATOR] = Property::Map()
-      .Add(TOKEN_ALPHA_FUNCTION, GetEnumerationName( animator->alphaFunction,
-                                                     ALPHA_FUNCTION_BUILTIN_TABLE,
-                                                     ALPHA_FUNCTION_BUILTIN_TABLE_COUNT ))
-      .Add(TOKEN_TIME_PERIOD, Property::Map()
-           .Add( TOKEN_DELAY, animator->timePeriodDelay )
-           .Add( TOKEN_DURATION, animator->timePeriodDuration ));
+    Property::Map animateMap;
+
+    if( animator->alphaFunction.GetMode() == AlphaFunction::BUILTIN_FUNCTION )
+    {
+      animateMap.Add(TOKEN_ALPHA_FUNCTION, GetEnumerationName( animator->alphaFunction.GetBuiltinFunction(),
+                                                               ALPHA_FUNCTION_BUILTIN_TABLE,
+                                                               ALPHA_FUNCTION_BUILTIN_TABLE_COUNT ));
+    }
+    else if( animator->alphaFunction.GetMode() == AlphaFunction::BEZIER )
+    {
+      Vector4 controlPoints = animator->alphaFunction.GetBezierControlPoints();
+      animateMap.Add( TOKEN_ALPHA_FUNCTION, controlPoints );
+    }
+    animateMap.Add(TOKEN_TIME_PERIOD, Property::Map()
+                   .Add( TOKEN_DELAY, animator->timePeriodDelay )
+                   .Add( TOKEN_DURATION, animator->timePeriodDuration ));
+
+    map[TOKEN_ANIMATOR] = animateMap;
   }
 
   return map;