X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Ftext-effects-style.cpp;h=8d552d4b798644b99f844d6c8ac45124497e16ae;hp=7172f2329a131879d5bc11786115335fce92204e;hb=3a6adcbec75784b051cb9ebaf204d72b553ea355;hpb=dda9d7ca30d6f5c42759647df03a13e52c76228a

diff --git a/dali-toolkit/internal/text/text-effects-style.cpp b/dali-toolkit/internal/text/text-effects-style.cpp
index 7172f23..8d552d4 100644
--- a/dali-toolkit/internal/text/text-effects-style.cpp
+++ b/dali-toolkit/internal/text/text-effects-style.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
@@ -19,132 +19,520 @@
 #include <dali-toolkit/internal/text/text-effects-style.h>
 
 // INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/controls/text-controls/text-style-properties-devel.h>
 #include <dali-toolkit/internal/text/markup-processor-helper-functions.h>
 #include <dali-toolkit/internal/text/property-string-parser.h>
+#include <dali-toolkit/public-api/text/text-enumerations.h>
+#include <dali-toolkit/internal/text/text-enumerations-impl.h>
 
 namespace Dali
 {
-
 namespace Toolkit
 {
-
 namespace Text
 {
-
 namespace
 {
-const std::string COLOR_KEY( "color" );
-const std::string OFFSET_KEY( "offset" );
-const std::string THICKNESS_KEY( "thickness" );
+const std::string COLOR_KEY("color");
+const std::string OFFSET_KEY("offset");
+const std::string BLUR_RADIUS_KEY("blurRadius");
+const std::string WIDTH_KEY("width");
+const std::string HEIGHT_KEY("height");
+const std::string ENABLE_KEY("enable");
+const std::string TYPE_KEY("type");
+const std::string DASH_WIDTH_KEY("dashWidth");
+const std::string DASH_GAP_KEY("dashGap");
+const std::string TRUE_TOKEN("true");
+const std::string FALSE_TOKEN("false");
+} // namespace
+
+bool ParseShadowProperties(const Property::Map& shadowPropertiesMap,
+                           bool&                colorDefined,
+                           Vector4&             color,
+                           bool&                offsetDefined,
+                           Vector2&             offset,
+                           bool&                blurRadiusDefined,
+                           float&               blurRadius)
+{
+  const unsigned int numberOfItems = shadowPropertiesMap.Count();
+
+  // Parses and applies the style.
+  for(unsigned int index = 0u; index < numberOfItems; ++index)
+  {
+    const KeyValuePair& valueGet = shadowPropertiesMap.GetKeyValue(index);
+
+    if((DevelText::Shadow::Property::COLOR == valueGet.first.indexKey) || (COLOR_KEY == valueGet.first.stringKey))
+    {
+      /// Color key.
+      colorDefined = true;
+
+      if(valueGet.second.GetType() == Dali::Property::STRING)
+      {
+        const std::string colorStr = valueGet.second.Get<std::string>();
+        Text::ColorStringToVector4(colorStr.c_str(), colorStr.size(), color);
+      }
+      else
+      {
+        color = valueGet.second.Get<Vector4>();
+      }
+    }
+    else if((DevelText::Shadow::Property::OFFSET == valueGet.first.indexKey) || (OFFSET_KEY == valueGet.first.stringKey))
+    {
+      /// Offset key.
+      offsetDefined = true;
+
+      if(valueGet.second.GetType() == Dali::Property::STRING)
+      {
+        const std::string offsetStr = valueGet.second.Get<std::string>();
+        StringToVector2(offsetStr.c_str(), offsetStr.size(), offset);
+      }
+      else
+      {
+        offset = valueGet.second.Get<Vector2>();
+      }
+    }
+    else if((DevelText::Shadow::Property::BLUR_RADIUS == valueGet.first.indexKey) || (BLUR_RADIUS_KEY == valueGet.first.stringKey))
+    {
+      /// Blur radius key.
+      blurRadiusDefined = true;
+
+      if(valueGet.second.GetType() == Dali::Property::STRING)
+      {
+        const std::string blurRadiusStr = valueGet.second.Get<std::string>();
+        blurRadius                      = StringToFloat(blurRadiusStr.c_str());
+      }
+      else
+      {
+        blurRadius = valueGet.second.Get<float>();
+      }
+    }
+  }
+
+  return 0u == numberOfItems;
 }
 
-bool SetUnderlineProperties( ControllerPtr controller, const Property::Value& value, EffectStyle::Type type )
+bool ParseUnderlineProperties(const Property::Map&   underlinePropertiesMap,
+                              bool&                  enabled,
+                              bool&                  colorDefined,
+                              Vector4&               color,
+                              bool&                  heightDefined,
+                              float&                 height,
+                              bool&                  typeDefined,
+                              Text::Underline::Type& type,
+                              bool&                  dashWidthDefined,
+                              float&                 dashWidth,
+                              bool&                  dashGapDefined,
+                              float&                 dashGap)
 {
-  bool update = false;
+  const unsigned int numberOfItems = underlinePropertiesMap.Count();
 
-  if( controller )
+  // Parses and applies the style.
+  for(unsigned int index = 0u; index < numberOfItems; ++index)
   {
-    const std::string properties = value.Get< std::string >();
+    const KeyValuePair& valueGet = underlinePropertiesMap.GetKeyValue(index);
 
-    switch( type )
+    if((DevelText::Underline::Property::ENABLE == valueGet.first.indexKey) || (ENABLE_KEY == valueGet.first.stringKey))
     {
-      case EffectStyle::DEFAULT:
+      /// Enable key.
+      if(valueGet.second.GetType() == Dali::Property::STRING)
       {
-        // Stores the default underline's properties string to be recovered by the GetUnderlineProperties() function.
-        controller->SetDefaultUnderlineProperties( properties );
-        break;
+        const std::string enableStr = valueGet.second.Get<std::string>();
+        enabled                     = Text::TokenComparison(TRUE_TOKEN, enableStr.c_str(), enableStr.size());
       }
-      case EffectStyle::INPUT:
+      else
       {
-        // Stores the input underline's properties string to be recovered by the GetUnderlineProperties() function.
-        controller->SetInputUnderlineProperties( properties );
-        break;
+        enabled = valueGet.second.Get<bool>();
       }
     }
+    else if((DevelText::Underline::Property::COLOR == valueGet.first.indexKey) || (COLOR_KEY == valueGet.first.stringKey))
+    {
+      /// Color key.
+      colorDefined = true;
+
+      if(valueGet.second.GetType() == Dali::Property::STRING)
+      {
+        const std::string colorStr = valueGet.second.Get<std::string>();
+        Text::ColorStringToVector4(colorStr.c_str(), colorStr.size(), color);
+      }
+      else
+      {
+        color = valueGet.second.Get<Vector4>();
+      }
+    }
+    else if((DevelText::Underline::Property::HEIGHT == valueGet.first.indexKey) || (HEIGHT_KEY == valueGet.first.stringKey))
+    {
+      /// Height key.
+      heightDefined = true;
 
-    // Parses and applies the style.
-    Property::Map map;
-    ParsePropertyString( properties, map );
+      if(valueGet.second.GetType() == Dali::Property::STRING)
+      {
+        const std::string heightStr = valueGet.second.Get<std::string>();
+        height                      = StringToFloat(heightStr.c_str());
+      }
+      else
+      {
+        height = valueGet.second.Get<float>();
+      }
+    }
+    else if((DevelText::Underline::Property::TYPE == valueGet.first.indexKey) || (TYPE_KEY == valueGet.first.stringKey))
+    {
+      /// Underline Type key.
+      typeDefined = true;
 
-    if( !map.Empty() )
+      if(valueGet.second.GetType() == Dali::Property::STRING)
+      {
+        const std::string typeStr = valueGet.second.Get<std::string>();
+        Text::UnderlineTypeStringToTypeValue(typeStr.c_str(), typeStr.size(), type);
+      }
+      else
+      {
+        type = valueGet.second.Get<Text::Underline::Type>();
+      }
+    }
+    else if((DevelText::Underline::Property::DASH_WIDTH == valueGet.first.indexKey) || (DASH_WIDTH_KEY == valueGet.first.stringKey))
     {
-      /// Color key
-      Property::Value* colorValue = map.Find( COLOR_KEY );
+      /// Dashed Underline Width key.
+      dashWidthDefined = true;
 
-      Vector4 color;
-      const bool colorDefined = colorValue != NULL;
-      if( colorDefined )
+      if(valueGet.second.GetType() == Dali::Property::STRING)
+      {
+        const std::string dashWidthStr = valueGet.second.Get<std::string>();
+        dashWidth                      = StringToFloat(dashWidthStr.c_str());
+      }
+      else
       {
-        const std::string colorStr = colorValue->Get<std::string>();
+        dashWidth = valueGet.second.Get<float>();
+      }
+    }
+    else if((DevelText::Underline::Property::DASH_GAP == valueGet.first.indexKey) || (DASH_GAP_KEY == valueGet.first.stringKey))
+    {
+      /// Dashed Underline Gap key.
+      dashGapDefined = true;
 
-        ColorStringToVector4( colorStr.c_str(), colorStr.size(), color );
+      if(valueGet.second.GetType() == Dali::Property::STRING)
+      {
+        const std::string dashGapStr = valueGet.second.Get<std::string>();
+        dashGap                      = StringToFloat(dashGapStr.c_str());
+      }
+      else
+      {
+        dashGap = valueGet.second.Get<float>();
       }
+    }
+  }
+
+  return 0u == numberOfItems;
+}
+
+bool ParseOutlineProperties(const Property::Map& underlinePropertiesMap,
+                            bool&                colorDefined,
+                            Vector4&             color,
+                            bool&                widthDefined,
+                            uint16_t&            width)
+{
+  const unsigned int numberOfItems = underlinePropertiesMap.Count();
+
+  // Parses and applies the style.
+  for(unsigned int index = 0u; index < numberOfItems; ++index)
+  {
+    const KeyValuePair& valueGet = underlinePropertiesMap.GetKeyValue(index);
+
+    if((DevelText::Outline::Property::COLOR == valueGet.first.indexKey) || (COLOR_KEY == valueGet.first.stringKey))
+    {
+      /// Color key.
+      colorDefined = true;
+      color        = valueGet.second.Get<Vector4>();
+    }
+    else if((DevelText::Outline::Property::WIDTH == valueGet.first.indexKey) || (WIDTH_KEY == valueGet.first.stringKey))
+    {
+      /// Width key.
+      widthDefined = true;
+      width        = static_cast<uint16_t>(valueGet.second.Get<float>());
+    }
+  }
+
+  return 0u == numberOfItems;
+}
+
+bool ParseBackgroundProperties(const Property::Map& backgroundProperties,
+                               bool&                enabled,
+                               bool&                colorDefined,
+                               Vector4&             color)
+{
+  const unsigned int numberOfItems = backgroundProperties.Count();
+
+  // Parses and applies the style.
+  for(unsigned int index = 0u; index < numberOfItems; ++index)
+  {
+    const KeyValuePair& valueGet = backgroundProperties.GetKeyValue(index);
+
+    if((DevelText::Background::Property::ENABLE == valueGet.first.indexKey) || (ENABLE_KEY == valueGet.first.stringKey))
+    {
+      /// Enable key.
+      enabled = valueGet.second.Get<bool>();
+    }
+    else if((DevelText::Background::Property::COLOR == valueGet.first.indexKey) || (COLOR_KEY == valueGet.first.stringKey))
+    {
+      /// Color key.
+      colorDefined = true;
+      color        = valueGet.second.Get<Vector4>();
+    }
+  }
+
+  return 0u == numberOfItems;
+}
+
+bool ParseStrikethroughProperties(const Property::Map& strikethroughPropertiesMap,
+                                  bool&                enabled,
+                                  bool&                colorDefined,
+                                  Vector4&             color,
+                                  bool&                heightDefined,
+                                  float&               height)
+{
+  const unsigned int numberOfItems = strikethroughPropertiesMap.Count();
 
-      /// Thickness key
-      Property::Value* thicknessValue = map.Find( THICKNESS_KEY );
+  // Parses and applies the style.
+  for(unsigned int index = 0u; index < numberOfItems; ++index)
+  {
+    const KeyValuePair& valueGet = strikethroughPropertiesMap.GetKeyValue(index);
 
-      float thickness = 0.f;
-      const bool thicknessDefined = thicknessValue != NULL;
-      if( thicknessDefined )
+    if((DevelText::Strikethrough::Property::ENABLE == valueGet.first.indexKey) || (ENABLE_KEY == valueGet.first.stringKey))
+    {
+      /// Enable key.
+      if(valueGet.second.GetType() == Dali::Property::STRING)
       {
-        const std::string thicknessStr = thicknessValue->Get<std::string>();
+        const std::string enableStr = valueGet.second.Get<std::string>();
+        enabled                     = Text::TokenComparison(TRUE_TOKEN, enableStr.c_str(), enableStr.size());
+      }
+      else
+      {
+        enabled = valueGet.second.Get<bool>();
+      }
+    }
+    else if((DevelText::Strikethrough::Property::COLOR == valueGet.first.indexKey) || (COLOR_KEY == valueGet.first.stringKey))
+    {
+      /// Color key.
+      colorDefined = true;
+
+      if(valueGet.second.GetType() == Dali::Property::STRING)
+      {
+        const std::string colorStr = valueGet.second.Get<std::string>();
+        Text::ColorStringToVector4(colorStr.c_str(), colorStr.size(), color);
+      }
+      else
+      {
+        color = valueGet.second.Get<Vector4>();
+      }
+    }
+    else if((DevelText::Strikethrough::Property::HEIGHT == valueGet.first.indexKey) || (HEIGHT_KEY == valueGet.first.stringKey))
+    {
+      /// Height key.
+      heightDefined = true;
 
-        thickness = StringToFloat( thicknessStr.c_str() );
+      if(valueGet.second.GetType() == Dali::Property::STRING)
+      {
+        const std::string heightStr = valueGet.second.Get<std::string>();
+        height                      = StringToFloat(heightStr.c_str());
       }
+      else
+      {
+        height = valueGet.second.Get<float>();
+      }
+    }
+  }
+  return 0u == numberOfItems;
+}
+
+bool SetUnderlineProperties(ControllerPtr controller, const Property::Value& value, EffectStyle::Type type)
+{
+  bool update = false;
 
-      switch( type )
+  if(controller)
+  {
+    switch(type)
+    {
+      case EffectStyle::DEFAULT:
       {
-        case EffectStyle::DEFAULT:
+        const Property::Map& propertiesMap = value.Get<Property::Map>();
+
+        bool                  enabled       = false;
+        bool                  colorDefined  = false;
+        Vector4               color;
+        bool                  heightDefined = false;
+        float                 height        = 0.f;
+        bool                  typeDefined   = false;
+        Text::Underline::Type type;
+        bool                  dashWidthDefined = false;
+        float                 dashWidth        = 2.0f;
+        bool                  dashGapDefined   = false;
+        float                 dashGap          = 1.0f;
+
+        bool empty = true;
+
+        if(propertiesMap.Empty())
+        {
+          // Map empty so check if a string provided
+          const std::string propertyString = value.Get<std::string>();
+
+          if(!propertyString.empty())
+          {
+            Property::Map parsedStringMap;
+            Text::ParsePropertyString(propertyString, parsedStringMap);
+
+            empty = ParseUnderlineProperties(parsedStringMap,
+                                             enabled,
+                                             colorDefined,
+                                             color,
+                                             heightDefined,
+                                             height,
+                                             typeDefined,
+                                             type,
+                                             dashWidthDefined,
+                                             dashWidth,
+                                             dashGapDefined,
+                                             dashGap);
+
+            controller->UnderlineSetByString(!empty);
+          }
+        }
+        else
+        {
+          empty = ParseUnderlineProperties(propertiesMap,
+                                           enabled,
+                                           colorDefined,
+                                           color,
+                                           heightDefined,
+                                           height,
+                                           typeDefined,
+                                           type,
+                                           dashWidthDefined,
+                                           dashWidth,
+                                           dashGapDefined,
+                                           dashGap);
+
+          controller->UnderlineSetByString(false);
+        }
+
+        if(!empty)
         {
-          if( !controller->IsUnderlineEnabled() )
+          if(enabled != controller->IsUnderlineEnabled())
           {
-            controller->SetUnderlineEnabled( true );
+            controller->SetUnderlineEnabled(enabled);
             update = true;
           }
+
           // Sets the default underline values.
-          if( colorDefined && ( controller->GetUnderlineColor() != color ) )
+          if(colorDefined && (controller->GetUnderlineColor() != color))
+          {
+            controller->SetUnderlineColor(color);
+            update = true;
+          }
+
+          if(heightDefined && (fabsf(controller->GetUnderlineHeight() - height) > Math::MACHINE_EPSILON_1000))
           {
-            controller->SetUnderlineColor( color );
+            controller->SetUnderlineHeight(height);
             update = true;
           }
 
-          if( thicknessDefined &&  fabsf( controller->GetUnderlineHeight() - thickness ) > Math::MACHINE_EPSILON_1000 )
+          if(typeDefined && (controller->GetUnderlineType() != type))
           {
-            controller->SetUnderlineHeight( thickness );
+            controller->SetUnderlineType(type);
+            update = true;
+          }
+
+          if(dashWidthDefined && (fabsf(controller->GetDashedUnderlineWidth() - dashWidth) > Math::MACHINE_EPSILON_1000))
+          {
+            controller->SetDashedUnderlineWidth(dashWidth);
+            update = true;
+          }
+
+          if(dashGapDefined && (fabsf(controller->GetDashedUnderlineGap() - dashGap) > Math::MACHINE_EPSILON_1000))
+          {
+            controller->SetDashedUnderlineGap(dashGap);
             update = true;
           }
         }
-        case EffectStyle::INPUT:
+        else
         {
-          // Sets the input underline values.
-          // TODO: to be implemented.
-          break;
+          // Disable underline.
+          if(controller->IsUnderlineEnabled())
+          {
+            controller->SetUnderlineEnabled(false);
+            update = true;
+          }
         }
+        break;
       }
-    }
-    else
-    {
-      // Disable underline.
-      if( controller->IsUnderlineEnabled() )
+      case EffectStyle::INPUT:
       {
-        controller->SetUnderlineEnabled( false );
-        update = true;
+        const std::string& underlineProperties = value.Get<std::string>();
+
+        controller->SetInputUnderlineProperties(underlineProperties);
+        break;
       }
-    }
-  }
+    } // switch
+  }   // if( controller )
 
   return update;
 }
 
-void GetUnderlineProperties( ControllerPtr controller, Property::Value& value, EffectStyle::Type type )
+void GetUnderlineProperties(ControllerPtr controller, Property::Value& value, EffectStyle::Type type)
 {
-  if( controller )
+  if(controller)
   {
-    switch( type )
+    switch(type)
     {
       case EffectStyle::DEFAULT:
       {
-        value = controller->GetDefaultUnderlineProperties();
+        const bool                  enabled   = controller->IsUnderlineEnabled();
+        const Vector4&              color     = controller->GetUnderlineColor();
+        const float                 height    = controller->GetUnderlineHeight();
+        const Text::Underline::Type type      = controller->GetUnderlineType();
+        const float                 dashWidth = controller->GetDashedUnderlineWidth();
+        const float                 dashGap   = controller->GetDashedUnderlineGap();
+
+        if(controller->IsUnderlineSetByString())
+        {
+          std::string       underlineProperties = "{\"enable\":";
+          const std::string enabledStr          = enabled ? "true" : "false";
+          underlineProperties += "\"" + enabledStr + "\",";
+
+          std::string colorStr;
+          Vector4ToColorString(color, colorStr);
+          underlineProperties += "\"color\":\"" + colorStr + "\",";
+
+          std::string heightStr;
+          FloatToString(height, heightStr);
+          underlineProperties += "\"height\":\"" + heightStr + "\",";
+
+          std::string typeStr;
+          typeStr = GetUnderlineTypeToString(type);
+          underlineProperties += "\"type\":\"" + typeStr + "\",";
+
+          std::string dashWidthStr;
+          FloatToString(dashWidth, dashWidthStr);
+          underlineProperties += "\"dashWidth\":\"" + dashWidthStr + "\",";
+
+          std::string dashGapStr;
+          FloatToString(dashGap, dashGapStr);
+          underlineProperties += "\"dashGap\":\"" + dashGapStr + "\"}";
+
+          value = underlineProperties;
+        }
+        else
+        {
+          Property::Map map;
+
+          map.Insert(ENABLE_KEY, enabled);
+          map.Insert(COLOR_KEY, color);
+          map.Insert(HEIGHT_KEY, height);
+          map.Insert(TYPE_KEY, type);
+          map.Insert(DASH_WIDTH_KEY, dashWidth);
+          map.Insert(DASH_GAP_KEY, dashGap);
+
+          value = map;
+        }
+
         break;
       }
       case EffectStyle::INPUT:
@@ -156,99 +544,142 @@ void GetUnderlineProperties( ControllerPtr controller, Property::Value& value, E
   }
 }
 
-bool SetShadowProperties( ControllerPtr controller, const Property::Value& value, EffectStyle::Type type )
+bool SetShadowProperties(ControllerPtr controller, const Property::Value& value, EffectStyle::Type type)
 {
   bool update = false;
 
-  if( controller )
+  if(controller)
   {
-    const std::string properties = value.Get< std::string >();
-
-    switch( type )
+    switch(type)
     {
       case EffectStyle::DEFAULT:
       {
-        // Stores the default shadow's properties string to be recovered by the GetShadowProperties() function.
-        controller->SetDefaultShadowProperties( properties );
-        break;
-      }
-      case EffectStyle::INPUT:
-      {
-        // Stores the input shadow's properties string to be recovered by the GetShadowProperties() function.
-        controller->SetInputShadowProperties( properties );
-        break;
-      }
-    }
+        const Property::Map& propertiesMap = value.Get<Property::Map>();
 
-    // Parses and applies the style.
-    Property::Map map;
-    ParsePropertyString( properties, map );
+        bool    colorDefined = false;
+        Vector4 color;
+        bool    offsetDefined = false;
+        Vector2 offset;
+        bool    blurRadiusDefined = false;
+        float   blurRadius;
 
-    if( !map.Empty() )
-    {
-      /// Color key
-      Property::Value* colorValue = map.Find( COLOR_KEY );
+        bool empty = true;
 
-      Vector4 color;
-      const bool colorDefined = colorValue != NULL;
-      if( colorDefined )
-      {
-        const std::string colorStr = colorValue->Get<std::string>();
+        if(propertiesMap.Empty())
+        {
+          // Map empty so check if a string provided
+          const std::string propertyString = value.Get<std::string>();
 
-        ColorStringToVector4( colorStr.c_str(), colorStr.size(), color );
-      }
+          Property::Map parsedStringMap;
+          Text::ParsePropertyString(propertyString, parsedStringMap);
 
-      /// Offset key
-      Property::Value* offsetValue = map.Find( OFFSET_KEY );
+          empty = ParseShadowProperties(parsedStringMap,
+                                        colorDefined,
+                                        color,
+                                        offsetDefined,
+                                        offset,
+                                        blurRadiusDefined,
+                                        blurRadius);
 
-      Vector2 offset;
-      const bool offsetDefined = offsetValue != NULL;
-      if( offsetDefined )
-      {
-        const std::string offsetStr = offsetValue->Get<std::string>();
+          controller->ShadowSetByString(!empty);
+        }
+        else
+        {
+          empty = ParseShadowProperties(propertiesMap,
+                                        colorDefined,
+                                        color,
+                                        offsetDefined,
+                                        offset,
+                                        blurRadiusDefined,
+                                        blurRadius);
 
-        StringOffsetToVector2( offsetStr, offset );
-      }
+          controller->ShadowSetByString(false);
+        }
 
-      switch( type )
-      {
-        case EffectStyle::DEFAULT:
+        if(!empty)
         {
           // Sets the default shadow values.
-          if( colorDefined && ( controller->GetShadowColor() != color ) )
+          if(colorDefined && (controller->GetShadowColor() != color))
           {
-            controller->SetShadowColor( color );
+            controller->SetShadowColor(color);
             update = true;
           }
 
-          if( offsetDefined && ( controller->GetShadowOffset() != offset ) )
+          if(offsetDefined && (controller->GetShadowOffset() != offset))
           {
-            controller->SetShadowOffset( offset );
+            controller->SetShadowOffset(offset);
+            update = true;
+          }
+
+          if(blurRadiusDefined && (controller->GetShadowBlurRadius() != blurRadius))
+          {
+            controller->SetShadowBlurRadius(blurRadius);
             update = true;
           }
         }
-        case EffectStyle::INPUT:
+        else
         {
-          // Sets the input shadow values.
-          // TODO: to be implemented.
-          break;
+          // Disable shadow.
+          if(Vector2::ZERO != controller->GetShadowOffset())
+          {
+            controller->SetShadowOffset(Vector2::ZERO);
+          }
         }
+        break;
       }
-    }
-  }
+      case EffectStyle::INPUT:
+      {
+        const std::string& shadowString = value.Get<std::string>();
+
+        controller->SetInputShadowProperties(shadowString);
+        break;
+      }
+    } // switch
+  }   // if( controller )
 
   return update;
 }
 
-void GetShadowProperties( ControllerPtr controller, Property::Value& value, EffectStyle::Type type )
+void GetShadowProperties(ControllerPtr controller, Property::Value& value, EffectStyle::Type type)
 {
-  if( controller )
+  if(controller)
   {
-    switch( type )
+    switch(type)
     {
       case EffectStyle::DEFAULT:
       {
-        value = controller->GetDefaultShadowProperties();
+        const Vector4& color      = controller->GetShadowColor();
+        const Vector2& offset     = controller->GetShadowOffset();
+        const float&   blurRadius = controller->GetShadowBlurRadius();
+
+        if(controller->IsShadowSetByString())
+        {
+          std::string shadowProperties = "{";
+
+          std::string colorStr;
+          Vector4ToColorString(color, colorStr);
+          shadowProperties += "\"color\":\"" + colorStr + "\",";
+
+          std::string offsetStr;
+          Vector2ToString(offset, offsetStr);
+          shadowProperties += "\"offset\":\"" + offsetStr + "\",";
+
+          std::string blurRadiusStr;
+          FloatToString(blurRadius, blurRadiusStr);
+          shadowProperties += "\"blurRadius\":\"" + blurRadiusStr + "\"}";
+
+          value = shadowProperties;
+        }
+        else
+        {
+          Property::Map map;
+
+          map.Insert(COLOR_KEY, color);
+          map.Insert(OFFSET_KEY, offset);
+          map.Insert(BLUR_RADIUS_KEY, blurRadius);
+
+          value = map;
+        }
         break;
       }
       case EffectStyle::INPUT:
@@ -260,26 +691,26 @@ void GetShadowProperties( ControllerPtr controller, Property::Value& value, Effe
   }
 }
 
-bool SetEmbossProperties( ControllerPtr controller, const Property::Value& value, EffectStyle::Type type )
+bool SetEmbossProperties(ControllerPtr controller, const Property::Value& value, EffectStyle::Type type)
 {
   bool update = false;
 
-  if( controller )
+  if(controller)
   {
-    const std::string properties = value.Get< std::string >();
+    const std::string properties = value.Get<std::string>();
 
-    switch( type )
+    switch(type)
     {
       case EffectStyle::DEFAULT:
       {
         // Stores the default emboss's properties string to be recovered by the GetEmbossProperties() function.
-        controller->SetDefaultEmbossProperties( properties );
+        controller->SetDefaultEmbossProperties(properties);
         break;
       }
       case EffectStyle::INPUT:
       {
         // Stores the input emboss's properties string to be recovered by the GetEmbossProperties() function.
-        controller->SetInputEmbossProperties( properties );
+        controller->SetInputEmbossProperties(properties);
         break;
       }
     }
@@ -288,11 +719,11 @@ bool SetEmbossProperties( ControllerPtr controller, const Property::Value& value
   return update;
 }
 
-void GetEmbossProperties( ControllerPtr controller, Property::Value& value, EffectStyle::Type type )
+void GetEmbossProperties(ControllerPtr controller, Property::Value& value, EffectStyle::Type type)
 {
-  if( controller )
+  if(controller)
   {
-    switch( type )
+    switch(type)
     {
       case EffectStyle::DEFAULT:
       {
@@ -308,48 +739,353 @@ void GetEmbossProperties( ControllerPtr controller, Property::Value& value, Effe
   }
 }
 
-bool SetOutlineProperties( ControllerPtr controller, const Property::Value& value, EffectStyle::Type type )
+bool SetOutlineProperties(ControllerPtr controller, const Property::Value& value, EffectStyle::Type type)
 {
   bool update = false;
 
-  if( controller )
+  if(controller)
   {
-    const std::string properties = value.Get< std::string >();
+    switch(type)
+    {
+      case EffectStyle::DEFAULT:
+      {
+        const Property::Map& propertiesMap = value.Get<Property::Map>();
+
+        bool     colorDefined = false;
+        Vector4  color;
+        bool     widthDefined = false;
+        uint16_t width        = 0u;
+
+        bool empty = true;
+
+        if(propertiesMap.Empty())
+        {
+          // Map empty so check if a string provided
+          // This is purely to maintain backward compatibility, but we don't parse the string to be a property map.
+          const std::string propertyString = value.Get<std::string>();
+
+          // Stores the default outline's properties string to be recovered by the GetOutlineProperties() function.
+          controller->SetDefaultOutlineProperties(propertyString);
+
+          controller->OutlineSetByString(true);
+        }
+        else
+        {
+          empty = ParseOutlineProperties(propertiesMap,
+                                         colorDefined,
+                                         color,
+                                         widthDefined,
+                                         width);
+
+          controller->OutlineSetByString(false);
+        }
+
+        if(!empty)
+        {
+          // Sets the default outline values.
+          if(colorDefined && (controller->GetOutlineColor() != color))
+          {
+            controller->SetOutlineColor(color);
+            update = true;
+          }
+
+          if(widthDefined && (controller->GetOutlineWidth() != width))
+          {
+            controller->SetOutlineWidth(width);
+            update = true;
+          }
+        }
+        else
+        {
+          // Disable outline
+          if(0u != controller->GetOutlineWidth())
+          {
+            controller->SetOutlineWidth(0u);
+            update = true;
+          }
+        }
+        break;
+      }
+      case EffectStyle::INPUT:
+      {
+        const std::string& outlineProperties = value.Get<std::string>();
+
+        controller->SetInputOutlineProperties(outlineProperties);
+        break;
+      }
+    } // switch
+  }   // if( controller )
+
+  return update;
+}
+
+void GetOutlineProperties(ControllerPtr controller, Property::Value& value, EffectStyle::Type type)
+{
+  if(controller)
+  {
+    switch(type)
+    {
+      case EffectStyle::DEFAULT:
+      {
+        if(controller->IsOutlineSetByString())
+        {
+          value = controller->GetDefaultOutlineProperties();
+          break;
+        }
+        else
+        {
+          const Vector4& color = controller->GetOutlineColor();
+          const uint16_t width = controller->GetOutlineWidth();
+
+          Property::Map map;
+          map.Insert(COLOR_KEY, color);
+          map.Insert(WIDTH_KEY, static_cast<int>(width));
+
+          value = map;
+
+          break;
+        }
+      }
+      case EffectStyle::INPUT:
+      {
+        value = controller->GetInputOutlineProperties();
+        break;
+      }
+    }
+  }
+}
+
+bool SetBackgroundProperties(ControllerPtr controller, const Property::Value& value, EffectStyle::Type type)
+{
+  bool update = false;
+
+  if(controller)
+  {
+    switch(type)
+    {
+      case EffectStyle::DEFAULT:
+      {
+        const Property::Map& propertiesMap = value.Get<Property::Map>();
+
+        bool    enabled      = false;
+        bool    colorDefined = false;
+        Vector4 color;
+
+        bool empty = true;
+
+        if(!propertiesMap.Empty())
+        {
+          empty = ParseBackgroundProperties(propertiesMap,
+                                            enabled,
+                                            colorDefined,
+                                            color);
+        }
+
+        if(!empty)
+        {
+          if(enabled != controller->IsBackgroundEnabled())
+          {
+            controller->SetBackgroundEnabled(enabled);
+            update = true;
+          }
+
+          if(colorDefined && (controller->GetBackgroundColor() != color))
+          {
+            controller->SetBackgroundColor(color);
+            update = true;
+          }
+        }
+        else
+        {
+          // Disable background.
+          if(controller->IsBackgroundEnabled())
+          {
+            controller->SetBackgroundEnabled(false);
+            update = true;
+          }
+        }
+        break;
+      }
+      case EffectStyle::INPUT:
+      {
+        // Text background is not supported while inputting yet
+        break;
+      }
+    } // switch
+  }   // if( controller )
+
+  return update;
+}
 
-    switch( type )
+void GetBackgroundProperties(ControllerPtr controller, Property::Value& value, EffectStyle::Type type)
+{
+  if(controller)
+  {
+    switch(type)
     {
       case EffectStyle::DEFAULT:
       {
-        // Stores the default outline's properties string to be recovered by the GetOutlineProperties() function.
-        controller->SetDefaultOutlineProperties( properties );
+        const bool     enabled = controller->IsBackgroundEnabled();
+        const Vector4& color   = controller->GetBackgroundColor();
+
+        Property::Map map;
+        map.Insert(ENABLE_KEY, enabled);
+        map.Insert(COLOR_KEY, color);
+
+        value = map;
+
         break;
       }
       case EffectStyle::INPUT:
       {
-        // Stores the input outline's properties string to be recovered by the GetOutlineProperties() function.
-        controller->SetInputOutlineProperties( properties );
+        // Text background is not supported while inputting yet
         break;
       }
     }
   }
+}
+
+bool SetStrikethroughProperties(ControllerPtr controller, const Property::Value& value, EffectStyle::Type type)
+{
+  bool update = false;
+
+  if(controller)
+  {
+    switch(type)
+    {
+      case EffectStyle::DEFAULT:
+      {
+        const Property::Map& propertiesMap = value.Get<Property::Map>();
+
+        bool    enabled      = false;
+        bool    colorDefined = false;
+        Vector4 color;
+        bool    heightDefined = false;
+        float   height        = 0.f;
+
+        bool empty = true;
+
+        if(propertiesMap.Empty())
+        {
+          // Map empty so check if a string provided
+          const std::string propertyString = value.Get<std::string>();
+
+          if(!propertyString.empty())
+          {
+            Property::Map parsedStringMap;
+            Text::ParsePropertyString(propertyString, parsedStringMap);
+
+            empty = ParseStrikethroughProperties(parsedStringMap,
+                                             enabled,
+                                             colorDefined,
+                                             color,
+                                             heightDefined,
+                                             height);
+
+            controller->StrikethroughSetByString(!empty);
+          }
+        }
+        else
+        {
+          empty = ParseStrikethroughProperties(propertiesMap,
+                                               enabled,
+                                               colorDefined,
+                                               color,
+                                               heightDefined,
+                                               height);
+
+          controller->StrikethroughSetByString(false);
+        }
+
+        if(!empty)
+        {
+          if(enabled != controller->IsStrikethroughEnabled())
+          {
+            controller->SetStrikethroughEnabled(enabled);
+            update = true;
+          }
+
+          // Sets the default strikethrough values.
+          if(colorDefined && (controller->GetStrikethroughColor() != color))
+          {
+            controller->SetStrikethroughColor(color);
+            update = true;
+          }
+          if(heightDefined && (fabsf(controller->GetStrikethroughHeight() - height) > Math::MACHINE_EPSILON_1000))
+          {
+            controller->SetStrikethroughHeight(height);
+            update = true;
+          }
+        }
+        else
+        {
+          // Disable strikethrough.
+          if(controller->IsStrikethroughEnabled())
+          {
+            controller->SetStrikethroughEnabled(false);
+            update = true;
+          }
+        }
+        break;
+      }
+      case EffectStyle::INPUT:
+      {
+        const std::string& strikethroughProperties = value.Get<std::string>();
+
+        controller->SetInputStrikethroughProperties(strikethroughProperties);
+        update = true;
+        break;
+      }
+    } // switch
+  }   // if( controller )
 
   return update;
 }
 
-void GetOutlineProperties( ControllerPtr controller, Property::Value& value, EffectStyle::Type type )
+void GetStrikethroughProperties(ControllerPtr controller, Property::Value& value, EffectStyle::Type type)
 {
-  if( controller )
+  if(controller)
   {
-    switch( type )
+    switch(type)
     {
       case EffectStyle::DEFAULT:
       {
-        value = controller->GetDefaultOutlineProperties();
+        const bool     enabled = controller->IsStrikethroughEnabled();
+        const Vector4& color   = controller->GetStrikethroughColor();
+        const float    height  = controller->GetStrikethroughHeight();
+
+        if(controller->IsStrikethroughSetByString())
+        {
+          std::string       strikethroughProperties = "{\"enable\":";
+          const std::string enabledStr          = enabled ? "true" : "false";
+          strikethroughProperties += "\"" + enabledStr + "\",";
+
+          std::string colorStr;
+          Vector4ToColorString(color, colorStr);
+          strikethroughProperties += "\"color\":\"" + colorStr + "\",";
+
+          std::string heightStr;
+          FloatToString(height, heightStr);
+          strikethroughProperties += "\"height\":\"" + heightStr + "\"}";
+
+          value = strikethroughProperties;
+        }
+        else
+        {
+          Property::Map map;
+
+          map.Insert(ENABLE_KEY, enabled);
+          map.Insert(COLOR_KEY, color);
+          map.Insert(HEIGHT_KEY, height);
+
+          value = map;
+        }
+
         break;
       }
       case EffectStyle::INPUT:
       {
-        value = controller->GetInputOutlineProperties();
+        value = controller->GetInputStrikethroughProperties();
         break;
       }
     }