X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Ftext-effects-style.cpp;h=a367696d4eec5395d6db19b9ad1a12baa3eda17c;hb=d74d70d51ed70b00e29a2b6feac5419124fffc49;hp=31580a27882035d688c8fd632e757d92ce273a2c;hpb=af5c3407ed4e83fad2eea2059e98327080f590e3;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/text/text-effects-style.cpp b/dali-toolkit/internal/text/text-effects-style.cpp index 31580a2..a367696 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,133 +19,349 @@ #include // INTERNAL INCLUDES +#include #include #include 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" ); -} - -bool SetUnderlineProperties( ControllerPtr controller, const Property::Value& value, EffectStyle::Type type ) +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 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) { - bool update = false; + const unsigned int numberOfItems = shadowPropertiesMap.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 = shadowPropertiesMap.GetKeyValue(index); - switch( type ) + if((DevelText::Shadow::Property::COLOR == valueGet.first.indexKey) || (COLOR_KEY == valueGet.first.stringKey)) { - case EffectStyle::DEFAULT: + /// Color key. + colorDefined = true; + + 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 colorStr = valueGet.second.Get(); + Text::ColorStringToVector4(colorStr.c_str(), colorStr.size(), color); } - case EffectStyle::INPUT: + else { - // Stores the input underline's properties string to be recovered by the GetUnderlineProperties() function. - controller->SetInputUnderlineProperties( properties ); - break; + color = valueGet.second.Get(); } } - - // Parses and applies the style. - Property::Map map; - ParsePropertyString( properties, map ); - - if( !map.Empty() ) + else if((DevelText::Shadow::Property::OFFSET == valueGet.first.indexKey) || (OFFSET_KEY == valueGet.first.stringKey)) { - /// Color key - Property::Value* colorValue = map.Find( COLOR_KEY ); + /// Offset key. + offsetDefined = true; - Vector4 color; - const bool colorDefined = colorValue != NULL; - if( colorDefined ) + if(valueGet.second.GetType() == Dali::Property::STRING) + { + const std::string offsetStr = valueGet.second.Get(); + StringToVector2(offsetStr.c_str(), offsetStr.size(), offset); + } + else { - const std::string colorStr = colorValue->Get(); + offset = valueGet.second.Get(); + } + } + else if((DevelText::Shadow::Property::BLUR_RADIUS == valueGet.first.indexKey) || (BLUR_RADIUS_KEY == valueGet.first.stringKey)) + { + /// Blur radius key. + blurRadiusDefined = true; - ColorStringToVector4( colorStr.c_str(), colorStr.size(), color ); + if(valueGet.second.GetType() == Dali::Property::STRING) + { + const std::string blurRadiusStr = valueGet.second.Get(); + blurRadius = StringToFloat(blurRadiusStr.c_str()); + } + else + { + blurRadius = valueGet.second.Get(); } + } + } + + return 0u == numberOfItems; +} + +bool ParseUnderlineProperties(const Property::Map& underlinePropertiesMap, + bool& enabled, + bool& colorDefined, + Vector4& color, + bool& heightDefined, + float& height) +{ + const unsigned int numberOfItems = underlinePropertiesMap.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 = underlinePropertiesMap.GetKeyValue(index); - float thickness = 0.f; - const bool thicknessDefined = thicknessValue != NULL; - if( thicknessDefined ) + if((DevelText::Underline::Property::ENABLE == valueGet.first.indexKey) || (ENABLE_KEY == valueGet.first.stringKey)) + { + /// Enable key. + if(valueGet.second.GetType() == Dali::Property::STRING) + { + const std::string enableStr = valueGet.second.Get(); + enabled = Text::TokenComparison(TRUE_TOKEN, enableStr.c_str(), enableStr.size()); + } + else { - const std::string thicknessStr = thicknessValue->Get(); + enabled = valueGet.second.Get(); + } + } + 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(); + Text::ColorStringToVector4(colorStr.c_str(), colorStr.size(), color); + } + else + { + color = valueGet.second.Get(); + } + } + else if((DevelText::Underline::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(); + height = StringToFloat(heightStr.c_str()); + } + else + { + height = valueGet.second.Get(); } + } + } + + 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(); + } + else if((DevelText::Outline::Property::WIDTH == valueGet.first.indexKey) || (WIDTH_KEY == valueGet.first.stringKey)) + { + /// Width key. + widthDefined = true; + width = static_cast(valueGet.second.Get()); + } + } + + 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(); + } + else if((DevelText::Background::Property::COLOR == valueGet.first.indexKey) || (COLOR_KEY == valueGet.first.stringKey)) + { + /// Color key. + colorDefined = true; + color = valueGet.second.Get(); + } + } + + 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(); + + 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(); + + if(!propertyString.empty()) + { + Property::Map parsedStringMap; + Text::ParsePropertyString(propertyString, parsedStringMap); + + empty = ParseUnderlineProperties(parsedStringMap, + enabled, + colorDefined, + color, + heightDefined, + height); + + controller->UnderlineSetByString(!empty); + } + } + else + { + empty = ParseUnderlineProperties(propertiesMap, + enabled, + colorDefined, + color, + heightDefined, + height); + + 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 ); + controller->SetUnderlineColor(color); update = true; } - if( thicknessDefined && fabsf( controller->GetUnderlineHeight() - thickness ) > Math::MACHINE_EPSILON_1000 ) + if(heightDefined && (fabsf(controller->GetUnderlineHeight() - height) > Math::MACHINE_EPSILON_1000)) { - controller->SetUnderlineHeight( thickness ); + controller->SetUnderlineHeight(height); update = true; } - break; } - 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(); + + 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(); + + 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 + "\"}"; + + value = underlineProperties; + } + 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: @@ -157,100 +373,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; - } - } - - // Parses and applies the style. - Property::Map map; - ParsePropertyString( properties, map ); + const Property::Map& propertiesMap = value.Get(); - if( !map.Empty() ) - { - /// Color key - Property::Value* colorValue = map.Find( COLOR_KEY ); + bool colorDefined = false; + Vector4 color; + bool offsetDefined = false; + Vector2 offset; + bool blurRadiusDefined = false; + float blurRadius; - Vector4 color; - const bool colorDefined = colorValue != NULL; - if( colorDefined ) - { - const std::string colorStr = colorValue->Get(); + bool empty = true; - ColorStringToVector4( colorStr.c_str(), colorStr.size(), color ); - } + if(propertiesMap.Empty()) + { + // Map empty so check if a string provided + const std::string propertyString = value.Get(); - /// Offset key - Property::Value* offsetValue = map.Find( OFFSET_KEY ); + Property::Map parsedStringMap; + Text::ParsePropertyString(propertyString, parsedStringMap); - Vector2 offset; - const bool offsetDefined = offsetValue != NULL; - if( offsetDefined ) - { - const std::string offsetStr = offsetValue->Get(); + empty = ParseShadowProperties(parsedStringMap, + colorDefined, + color, + offsetDefined, + offset, + blurRadiusDefined, + blurRadius); - StringOffsetToVector2( offsetStr, offset ); - } + controller->ShadowSetByString(!empty); + } + else + { + empty = ParseShadowProperties(propertiesMap, + colorDefined, + color, + offsetDefined, + offset, + blurRadiusDefined, + blurRadius); + + 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; } - break; } - 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(); + + 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: @@ -262,26 +520,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(); - 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; } } @@ -290,11 +548,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: { @@ -310,48 +568,206 @@ 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 ) + switch(type) { case EffectStyle::DEFAULT: { - // Stores the default outline's properties string to be recovered by the GetOutlineProperties() function. - controller->SetDefaultOutlineProperties( properties ); + const Property::Map& propertiesMap = value.Get(); + + 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(); + + // 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(); + + 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(width)); + + value = map; + + break; + } + } case EffectStyle::INPUT: { - // Stores the input outline's properties string to be recovered by the GetOutlineProperties() function. - controller->SetInputOutlineProperties( properties ); + 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(); + + 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; } -void GetOutlineProperties( ControllerPtr controller, Property::Value& value, EffectStyle::Type type ) +void GetBackgroundProperties(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->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: { - value = controller->GetInputOutlineProperties(); + // Text background is not supported while inputting yet break; } }