Add conversion to string for decorators and font-effects

Include/RmlUi/Core/ComputedValues.h

@@ -204,8 +204,8 @@ struct ComputedValues
 	TransitionList transition;
 	AnimationList animation;
 
-	DecoratorListPtr decorator;
-	FontEffectListPtr font_effect; // Sorted by layer first (back then front), then by declaration order.
+	DecoratorsPtr decorator;
+	FontEffectsPtr font_effect; // Sorted by layer first (back then front), then by declaration order.
 };
 }
 

Include/RmlUi/Core/Property.h

@@ -86,8 +86,8 @@ public:
 		TRANSFORM = 1 << 17,			// transform; fetch as < TransformPtr >, may be empty
 		TRANSITION = 1 << 18,           // transition; fetch as < TransitionList >
 		ANIMATION = 1 << 19,            // animation; fetch as < AnimationList >
-		DECORATOR = 1 << 20,            // decorator; fetch as < DecoratorListPtr >
-		FONTEFFECT = 1 << 21,           // font-effect; fetch as < FontEffectListPtr >
+		DECORATOR = 1 << 20,            // decorator; fetch as < DecoratorsPtr >
+		FONTEFFECT = 1 << 21,           // font-effect; fetch as < FontEffectsPtr >
 
 		LENGTH = PX | DP | PPI_UNIT | EM | REM,
 		LENGTH_PERCENT = LENGTH | PERCENT,

Include/RmlUi/Core/StyleSheet.h

@@ -95,10 +95,10 @@ public:
 	SharedPtr<Decorator> GetDecorator(const String& name) const;
 
 	/// Parses the decorator property from a string and returns a list of instanced decorators.
-	DecoratorListPtr InstanceDecoratorsFromString(const String& decorator_string_value, const SharedPtr<const PropertySource>& source) const;
+	DecoratorsPtr InstanceDecoratorsFromString(const String& decorator_string_value, const SharedPtr<const PropertySource>& source) const;
 
 	/// Parses the font-effect property from a string and returns a list of instanced font-effects.
-	FontEffectListPtr InstanceFontEffectsFromString(const String& font_effect_string_value, const SharedPtr<const PropertySource>& source) const;
+	FontEffectsPtr InstanceFontEffectsFromString(const String& font_effect_string_value, const SharedPtr<const PropertySource>& source) const;
 
 	/// Get sprite located in any spritesheet within this stylesheet.
 	const Sprite* GetSprite(const String& name) const;

Include/RmlUi/Core/TypeConverter.h

@@ -87,22 +87,22 @@ public:
 	RMLUICORE_API static bool Convert(const AnimationList& src, String& dest);
 };
 
-template<> class TypeConverter< DecoratorListPtr, DecoratorListPtr > {
+template<> class TypeConverter< DecoratorsPtr, DecoratorsPtr > {
 public:
-	RMLUICORE_API static bool Convert(const DecoratorListPtr& src, DecoratorListPtr& dest);
+	RMLUICORE_API static bool Convert(const DecoratorsPtr& src, DecoratorsPtr& dest);
 };
-template<> class TypeConverter< DecoratorListPtr, String > {
+template<> class TypeConverter< DecoratorsPtr, String > {
 public:
-	RMLUICORE_API static bool Convert(const DecoratorListPtr& src, String& dest);
+	RMLUICORE_API static bool Convert(const DecoratorsPtr& src, String& dest);
 };
 
-template<> class TypeConverter< FontEffectListPtr, FontEffectListPtr> {
+template<> class TypeConverter< FontEffectsPtr, FontEffectsPtr> {
 public:
-	RMLUICORE_API static bool Convert(const FontEffectListPtr& src, FontEffectListPtr& dest);
+	RMLUICORE_API static bool Convert(const FontEffectsPtr& src, FontEffectsPtr& dest);
 };
-template<> class TypeConverter< FontEffectListPtr, String > {
+template<> class TypeConverter< FontEffectsPtr, String > {
 public:
-	RMLUICORE_API static bool Convert(const FontEffectListPtr& src, String& dest);
+	RMLUICORE_API static bool Convert(const FontEffectsPtr& src, String& dest);
 };
 
 

Include/RmlUi/Core/Types.h

@@ -102,9 +102,9 @@ class Event;
 class Property;
 class Variant;
 class Transform;
+class PropertyIdSet;
 class Decorator;
 class FontEffect;
-class PropertyIdSet;
 struct Animation;
 struct Transition;
 struct TransitionList;
@@ -168,14 +168,23 @@ using PropertyMap = UnorderedMap< PropertyId, Property >;
 using Dictionary = SmallUnorderedMap< String, Variant >;
 using ElementAttributes = Dictionary;
 
+using AnimationList = std::vector<Animation>;
 using DecoratorList = std::vector<SharedPtr<const Decorator>>;
 using FontEffectList = std::vector<SharedPtr<const FontEffect>>;
-using AnimationList = std::vector<Animation>;
+
+struct Decorators {
+	DecoratorList list;
+	String value;
+};
+struct FontEffects {
+	FontEffectList list;
+	String value;
+};
 
 // Additional smart pointers
 using TransformPtr = SharedPtr< Transform >;
-using FontEffectListPtr = SharedPtr<const FontEffectList>;
-using DecoratorListPtr = SharedPtr<const DecoratorList>;
+using DecoratorsPtr = SharedPtr<const Decorators>;
+using FontEffectsPtr = SharedPtr<const FontEffects>;
 
 }
 }

Include/RmlUi/Core/Variant.h

@@ -143,10 +143,10 @@ private:
 	void Set(TransitionList&& value);
 	void Set(const AnimationList& value);
 	void Set(AnimationList&& value);
-	void Set(const DecoratorListPtr& value);
-	void Set(DecoratorListPtr&& value);
-	void Set(const FontEffectListPtr& value);
-	void Set(FontEffectListPtr&& value);
+	void Set(const DecoratorsPtr& value);
+	void Set(DecoratorsPtr&& value);
+	void Set(const FontEffectsPtr& value);
+	void Set(FontEffectsPtr&& value);
 	
 	static constexpr size_t LOCAL_DATA_SIZE = sizeof(TransitionList);
 

Include/RmlUi/Core/Variant.inl

@@ -119,11 +119,11 @@ bool Variant::GetInto(T& value) const
 		break;
 
 	case DECORATORLIST:
-		return TypeConverter< DecoratorListPtr, T >::Convert(*(DecoratorListPtr*)data, value);
+		return TypeConverter< DecoratorsPtr, T >::Convert(*(DecoratorsPtr*)data, value);
 		break;
 
 	case FONTEFFECTLISTPTR:
-		return TypeConverter< FontEffectListPtr, T >::Convert(*(FontEffectListPtr*)data, value);
+		return TypeConverter< FontEffectsPtr, T >::Convert(*(FontEffectsPtr*)data, value);
 		break;
 	case NONE:
 		break;

Samples/basic/animation/src/main.cpp

@@ -88,7 +88,7 @@ public:
 			// Transform tests
 			{
 				auto el = document->GetElementById("generic");
-				auto p = Transform::MakeProperty({ Transforms::TranslateY{50, Property::PX}, Transforms::RotateZ{-90, Property::DEG}, Transforms::ScaleY{0.8} });
+				auto p = Transform::MakeProperty({ Transforms::TranslateY{50, Property::PX}, Transforms::RotateZ{-90, Property::DEG}, Transforms::ScaleY{0.8f} });
 				el->Animate("transform", p, 1.5f, Tween{Tween::Sine, Tween::InOut}, -1, true);
 			}
 			{

Source/Core/ElementDecoration.cpp

@@ -52,11 +52,11 @@ bool ElementDecoration::ReloadDecorators()
 	RMLUI_ZoneScopedC(0xB22222);
 	ReleaseDecorators();
 
-	auto& decorator_list_ptr = element->GetComputedValues().decorator;
-	if (!decorator_list_ptr)
+	auto& decorators_ptr = element->GetComputedValues().decorator;
+	if (!decorators_ptr)
 		return true;
 
-	for (const auto& decorator : *decorator_list_ptr)
+	for (const auto& decorator : decorators_ptr->list)
 	{
 		if (decorator)
 		{

Source/Core/ElementStyle.cpp

@@ -830,7 +830,7 @@ PropertyIdSet ElementStyle::ComputeValues(Style::ComputedValues& values, const S
 		case PropertyId::Decorator:
 			if (p->unit == Property::DECORATOR)
 			{
-				values.decorator = p->Get<DecoratorListPtr>();
+				values.decorator = p->Get<DecoratorsPtr>();
 			}
 			else if (p->unit == Property::STRING)
 			{
@@ -850,7 +850,7 @@ PropertyIdSet ElementStyle::ComputeValues(Style::ComputedValues& values, const S
 		case PropertyId::FontEffect:
 			if (p->unit == Property::FONTEFFECT)
 			{
-				values.font_effect = p->Get<FontEffectListPtr>();
+				values.font_effect = p->Get<FontEffectsPtr>();
 			}
 			else if (p->unit == Property::STRING)
 			{

Source/Core/ElementTextDefault.cpp

@@ -387,9 +387,9 @@ bool ElementTextDefault::UpdateFontConfiguration()
 	static const FontEffectList empty_font_effects;
 
 	// Fetch the font-effect for this text element
-	const FontEffectList* font_effects = GetComputedValues().font_effect.get();
-	if (!font_effects)
-		font_effects = &empty_font_effects;
+	const FontEffectList* font_effects = &empty_font_effects;
+	if (const FontEffects* effects = GetComputedValues().font_effect.get())
+		font_effects = &effects->list;
 
 	// Request a font layer configuration to match this set of effects. If this is different from
 	// our old configuration, then return true to indicate we'll need to regenerate geometry.

Source/Core/StyleSheet.cpp

@@ -135,7 +135,7 @@ const Sprite* StyleSheet::GetSprite(const String& name) const
 	return spritesheet_list.GetSprite(name);
 }
 
-DecoratorListPtr StyleSheet::InstanceDecoratorsFromString(const String& decorator_string_value, const SharedPtr<const PropertySource>& source) const
+DecoratorsPtr StyleSheet::InstanceDecoratorsFromString(const String& decorator_string_value, const SharedPtr<const PropertySource>& source) const
 {
 	// Decorators are declared as
 	//   decorator: <decorator-value>[, <decorator-value> ...];
@@ -144,7 +144,7 @@ DecoratorListPtr StyleSheet::InstanceDecoratorsFromString(const String& decorato
 	// or is an anonymous decorator with inline properties
 	//   decorator: tiled-box( <shorthand properties> ), ...;
 	
-	DecoratorList decorator_list;
+	Decorators decorators;
 	if (decorator_string_value.empty() || decorator_string_value == NONE)
 		return nullptr;
 
@@ -155,7 +155,8 @@ DecoratorListPtr StyleSheet::InstanceDecoratorsFromString(const String& decorato
 	StringList decorator_string_list;
 	StringUtilities::ExpandString(decorator_string_list, decorator_string_value, ',', '(', ')');
 
-	decorator_list.reserve(decorator_string_list.size());
+	decorators.value = decorator_string_value;
+	decorators.list.reserve(decorator_string_list.size());
 
 	// Get or instance each decorator in the comma-separated string list
 	for (const String& decorator_string : decorator_string_list)
@@ -169,7 +170,7 @@ DecoratorListPtr StyleSheet::InstanceDecoratorsFromString(const String& decorato
 			// We found no parenthesis, that means the value must be a name of a @decorator rule, look it up
 			SharedPtr<Decorator> decorator = GetDecorator(decorator_string);
 			if (decorator)
-				decorator_list.emplace_back(std::move(decorator));
+				decorators.list.emplace_back(std::move(decorator));
 			else
 				Log::Message(Log::LT_WARNING, "Decorator name '%s' could not be found in any @decorator rule, declared at %s:%d", decorator_string.c_str(), source_path, source_line_number);
 		}
@@ -205,7 +206,7 @@ DecoratorListPtr StyleSheet::InstanceDecoratorsFromString(const String& decorato
 			SharedPtr<Decorator> decorator = instancer->InstanceDecorator(type, properties, DecoratorInstancerInterface(*this));
 
 			if (decorator)
-				decorator_list.emplace_back(std::move(decorator));
+				decorators.list.emplace_back(std::move(decorator));
 			else
 			{
 				Log::Message(Log::LT_WARNING, "Decorator '%s' could not be instanced, declared at %s:%d", decorator_string.c_str(), source_path, source_line_number);
@@ -214,10 +215,10 @@ DecoratorListPtr StyleSheet::InstanceDecoratorsFromString(const String& decorato
 		}
 	}
 
-	return std::make_shared<DecoratorList>(std::move(decorator_list));
+	return std::make_shared<Decorators>(std::move(decorators));
 }
 
-FontEffectListPtr StyleSheet::InstanceFontEffectsFromString(const String& font_effect_string_value, const SharedPtr<const PropertySource>& source) const
+FontEffectsPtr StyleSheet::InstanceFontEffectsFromString(const String& font_effect_string_value, const SharedPtr<const PropertySource>& source) const
 {	
 	// Font-effects are declared as
 	//   font-effect: <font-effect-value>[, <font-effect-value> ...];
@@ -230,13 +231,14 @@ FontEffectListPtr StyleSheet::InstanceFontEffectsFromString(const String& font_e
 	const char* source_path = (source ? source->path.c_str() : "");
 	const int source_line_number = (source ? source->line_number : 0);
 
-	FontEffectList font_effect_list;
+	FontEffects font_effects;
 
 	// Make sure we don't split inside the parenthesis since they may appear in decorator shorthands.
 	StringList font_effect_string_list;
 	StringUtilities::ExpandString(font_effect_string_list, font_effect_string_value, ',', '(', ')');
 
-	font_effect_list.reserve(font_effect_string_list.size());
+	font_effects.value = font_effect_string_value;
+	font_effects.list.reserve(font_effect_string_list.size());
 
 	// Get or instance each decorator in the comma-separated string list
 	for (const String& font_effect_string : font_effect_string_list)
@@ -289,7 +291,7 @@ FontEffectListPtr StyleSheet::InstanceFontEffectsFromString(const String& font_e
 
 				font_effect->SetFingerprint(fingerprint);
 
-				font_effect_list.emplace_back(std::move(font_effect));
+				font_effects.list.emplace_back(std::move(font_effect));
 			}
 			else
 			{
@@ -300,11 +302,11 @@ FontEffectListPtr StyleSheet::InstanceFontEffectsFromString(const String& font_e
 	}
 
 	// Partition the list such that the back layer effects appear before the front layer effects
-	std::stable_partition(font_effect_list.begin(), font_effect_list.end(), 
+	std::stable_partition(font_effects.list.begin(), font_effects.list.end(), 
 		[](const SharedPtr<const FontEffect>& effect) { return effect->GetLayer() == FontEffect::Layer::Back; }
 	);
 
-	return std::make_shared<FontEffectList>(std::move(font_effect_list));
+	return std::make_shared<FontEffects>(std::move(font_effects));
 }
 
 size_t StyleSheet::NodeHash(const String& tag, const String& id)

Source/Core/StyleSheetNode.cpp

@@ -136,10 +136,10 @@ void StyleSheetNode::BuildIndexAndOptimizeProperties(StyleSheet::NodeIndex& styl
 			{
 				const String string_value = property->Get<String>();
 				
-				if(DecoratorListPtr decorator_list = style_sheet.InstanceDecoratorsFromString(string_value, property->source))
+				if(DecoratorsPtr decorators = style_sheet.InstanceDecoratorsFromString(string_value, property->source))
 				{
 					Property new_property = *property;
-					new_property.value = std::move(decorator_list);
+					new_property.value = std::move(decorators);
 					new_property.unit = Property::DECORATOR;
 					properties.SetProperty(PropertyId::Decorator, new_property);
 				}
@@ -152,7 +152,7 @@ void StyleSheetNode::BuildIndexAndOptimizeProperties(StyleSheet::NodeIndex& styl
 			if (property->unit == Property::STRING)
 			{
 				const String string_value = property->Get<String>();
-				FontEffectListPtr font_effects = style_sheet.InstanceFontEffectsFromString(string_value, property->source);
+				FontEffectsPtr font_effects = style_sheet.InstanceFontEffectsFromString(string_value, property->source);
 
 				Property new_property = *property;
 				new_property.value = std::move(font_effects);

Source/Core/TypeConverter.cpp

@@ -113,42 +113,36 @@ bool TypeConverter<AnimationList, String>::Convert(const AnimationList& src, Str
 	return true;
 }
 
-bool TypeConverter<DecoratorListPtr, DecoratorListPtr>::Convert(const DecoratorListPtr& src, DecoratorListPtr& dest)
+bool TypeConverter<DecoratorsPtr, DecoratorsPtr>::Convert(const DecoratorsPtr& src, DecoratorsPtr& dest)
 {
 	dest = src;
 	return true;
 }
 
 
-bool TypeConverter<DecoratorListPtr, String>::Convert(const DecoratorListPtr& src, String& dest)
+bool TypeConverter<DecoratorsPtr, String>::Convert(const DecoratorsPtr& src, String& dest)
 {
-	// Todo. For now, we just count the number of decorators
-	if (!src || src->empty())
+	if (!src || src->list.empty())
 		dest = "none";
-	else if (TypeConverter<int, String>::Convert((int)src->size(), dest))
-		dest += " decorator(s)";
 	else
-		return false;
+		dest += src->value;
 	return true;
 }
 
 
-bool TypeConverter<FontEffectListPtr, FontEffectListPtr>::Convert(const FontEffectListPtr& src, FontEffectListPtr& dest)
+bool TypeConverter<FontEffectsPtr, FontEffectsPtr>::Convert(const FontEffectsPtr& src, FontEffectsPtr& dest)
 {
 	dest = src;
 	return true;
 }
 
 
-bool TypeConverter<FontEffectListPtr, String>::Convert(const FontEffectListPtr& src, String& dest)
+bool TypeConverter<FontEffectsPtr, String>::Convert(const FontEffectsPtr& src, String& dest)
 {
-	// Todo. For now, we just count the number of font-effects
-	if (!src || src->empty())
+	if (!src || src->list.empty())
 		dest = "none";
-	else if (TypeConverter<int, String>::Convert((int)src->size(), dest))
-		dest += " font-effect(s)";
-	else	
-		return false;
+	else
+		dest += src->value;
 	return true;
 }
 

Source/Core/Variant.cpp

@@ -42,8 +42,8 @@ Variant::Variant() : type(NONE)
 	static_assert(sizeof(TransformPtr) <= LOCAL_DATA_SIZE, "Local data too small for TransformPtr");
 	static_assert(sizeof(TransitionList) <= LOCAL_DATA_SIZE, "Local data too small for TransitionList");
 	static_assert(sizeof(AnimationList) <= LOCAL_DATA_SIZE, "Local data too small for AnimationList");
-	static_assert(sizeof(DecoratorListPtr) <= LOCAL_DATA_SIZE, "Local data too small for DecoratorListPtr");
-	static_assert(sizeof(FontEffectListPtr) <= LOCAL_DATA_SIZE, "Local data too small for FontEffectListPtr");
+	static_assert(sizeof(DecoratorsPtr) <= LOCAL_DATA_SIZE, "Local data too small for DecoratorsPtr");
+	static_assert(sizeof(FontEffectsPtr) <= LOCAL_DATA_SIZE, "Local data too small for FontEffectsPtr");
 }
 
 Variant::Variant(const Variant& copy) : type(NONE)
@@ -96,13 +96,13 @@ void Variant::Clear()
 		break;
 		case DECORATORLIST:
 		{
-			DecoratorListPtr* decorator_list = (DecoratorListPtr*)data;
-			decorator_list->~DecoratorListPtr();
+			DecoratorsPtr* decorators = (DecoratorsPtr*)data;
+			decorators->~DecoratorsPtr();
 		}
 		break;
 		case FONTEFFECTLISTPTR:
 		{
-			FontEffectListPtr* font_effects = (FontEffectListPtr*)data;
+			FontEffectsPtr* font_effects = (FontEffectsPtr*)data;
 			font_effects->~shared_ptr();
 		}
 		break;
@@ -141,11 +141,11 @@ void Variant::Set(const Variant& copy)
 		break;
 
 	case DECORATORLIST:
-		Set(*(DecoratorListPtr*)copy.data);
+		Set(*(DecoratorsPtr*)copy.data);
 		break;
 
 	case FONTEFFECTLISTPTR:
-		Set(*(FontEffectListPtr*)copy.data);
+		Set(*(FontEffectsPtr*)copy.data);
 		break;
 
 	default:
@@ -177,11 +177,11 @@ void Variant::Set(Variant&& other)
 		break;
 
 	case DECORATORLIST:
-		Set(std::move(*(DecoratorListPtr*)other.data));
+		Set(std::move(*(DecoratorsPtr*)other.data));
 		break;
 
 	case FONTEFFECTLISTPTR:
-		Set(std::move(*(FontEffectListPtr*)other.data));
+		Set(std::move(*(FontEffectsPtr*)other.data));
 		break;
 
 
@@ -371,52 +371,52 @@ void Variant::Set(AnimationList&& value)
 	}
 }
 
-void Variant::Set(const DecoratorListPtr& value)
+void Variant::Set(const DecoratorsPtr& value)
 {
 	if (type == DECORATORLIST)
 	{
-		*(DecoratorListPtr*)data = value;
+		*(DecoratorsPtr*)data = value;
 	}
 	else
 	{
 		type = DECORATORLIST;
-		new(data) DecoratorListPtr(value);
+		new(data) DecoratorsPtr(value);
 	}
 }
-void Variant::Set(DecoratorListPtr&& value)
+void Variant::Set(DecoratorsPtr&& value)
 {
 	if (type == DECORATORLIST)
 	{
-		(*(DecoratorListPtr*)data) = std::move(value);
+		(*(DecoratorsPtr*)data) = std::move(value);
 	}
 	else
 	{
 		type = DECORATORLIST;
-		new(data) DecoratorListPtr(std::move(value));
+		new(data) DecoratorsPtr(std::move(value));
 	}
 }
-void Variant::Set(const FontEffectListPtr& value)
+void Variant::Set(const FontEffectsPtr& value)
 {
 	if (type == FONTEFFECTLISTPTR)
 	{
-		*(FontEffectListPtr*)data = value;
+		*(FontEffectsPtr*)data = value;
 	}
 	else
 	{
 		type = FONTEFFECTLISTPTR;
-		new(data) FontEffectListPtr(value);
+		new(data) FontEffectsPtr(value);
 	}
 }
-void Variant::Set(FontEffectListPtr&& value)
+void Variant::Set(FontEffectsPtr&& value)
 {
 	if (type == FONTEFFECTLISTPTR)
 	{
-		(*(FontEffectListPtr*)data) = std::move(value);
+		(*(FontEffectsPtr*)data) = std::move(value);
 	}
 	else
 	{
 		type = FONTEFFECTLISTPTR;
-		new(data) FontEffectListPtr(std::move(value));
+		new(data) FontEffectsPtr(std::move(value));
 	}
 }
 
@@ -478,9 +478,9 @@ bool Variant::operator==(const Variant & other) const
 	case ANIMATIONLIST:
 		return DEFAULT_VARIANT_COMPARE(AnimationList);
 	case DECORATORLIST:
-		return DEFAULT_VARIANT_COMPARE(DecoratorListPtr);
+		return DEFAULT_VARIANT_COMPARE(DecoratorsPtr);
 	case FONTEFFECTLISTPTR:
-		return DEFAULT_VARIANT_COMPARE(FontEffectListPtr);
+		return DEFAULT_VARIANT_COMPARE(FontEffectsPtr);
 	case NONE:
 		return true;
 		break;