...

8 files changed, 44 insertions, 46 deletions

diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt
index b086cce1..4353a541 100644
--- a/src/ui/CMakeLists.txt
+++ b/src/ui/CMakeLists.txt
@@ -26,14 +26,15 @@ add_library(cru_ui SHARED
 	helper/ShortcutHub.cpp
 	host/LayoutPaintCycler.cpp
 	host/WindowHost.cpp
+	mapper/BorderStyleMapper.cpp
 	mapper/ColorMapper.cpp
 	mapper/CornerRadiusMapper.cpp
+	mapper/CursorMapper.cpp
 	mapper/Mapper.cpp
 	mapper/MapperRegistry.cpp
 	mapper/PointMapper.cpp
 	mapper/SizeMapper.cpp
 	mapper/ThicknessMapper.cpp
-	mapper/style/BorderStyleMapper.cpp
 	render/BorderRenderObject.cpp
 	render/CanvasRenderObject.cpp
 	render/FlexLayoutRenderObject.cpp
diff --git a/src/ui/mapper/style/BorderStyleMapper.cpp b/src/ui/mapper/BorderStyleMapper.cpp
index 0dc8a05f..65dbfe3b 100644
--- a/src/ui/mapper/style/BorderStyleMapper.cpp
+++ b/src/ui/mapper/BorderStyleMapper.cpp
@@ -1,12 +1,12 @@
-#include "cru/ui/mapper/style/BorderStyleMapper.hpp"
-#include "../../Helper.hpp"
+#include "cru/ui/mapper/BorderStyleMapper.hpp"
+#include "../Helper.hpp"
 #include "cru/common/Logger.hpp"
 #include "cru/platform/graphics/Factory.hpp"
 #include "cru/ui/mapper/MapperRegistry.hpp"
 #include "cru/ui/style/ApplyBorderStyleInfo.hpp"
 #include "cru/xml/XmlNode.hpp"
 
-namespace cru::ui::mapper::style {
+namespace cru::ui::mapper {
 using namespace xml;
 using ui::style::ApplyBorderStyleInfo;
 
@@ -14,9 +14,9 @@ bool BorderStyleMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
   return node->GetTag() == u"BorderStyle";
 }
 
-std::unique_ptr<ApplyBorderStyleInfo> BorderStyleMapper::DoMapFromXml(
+ApplyBorderStyleInfo BorderStyleMapper::DoMapFromXml(
     xml::XmlElementNode* node) {
-  auto result = std::make_unique<ApplyBorderStyleInfo>();
+  ApplyBorderStyleInfo result;
 
   for (auto child : node->GetChildren()) {
     if (child->GetType() == XmlNode::Type::Text) {
@@ -29,23 +29,23 @@ std::unique_ptr<ApplyBorderStyleInfo> BorderStyleMapper::DoMapFromXml(
           MapperRegistry::GetInstance()->GetMapper<CornerRadius>();
       auto color_mapper = MapperRegistry::GetInstance()->GetMapper<Color>();
       if (thickness_mapper->XmlElementIsOfThisType(c)) {
-        result->border_thickness = *thickness_mapper->MapFromXml(c);
+        result.border_thickness = thickness_mapper->MapFromXml(c);
       } else if (corner_radius_mapper->XmlElementIsOfThisType(c)) {
-        result->border_radius = *corner_radius_mapper->MapFromXml(c);
+        result.border_radius = corner_radius_mapper->MapFromXml(c);
       } else if (color_mapper->XmlElementIsOfThisType(c)) {
         auto brush = GetGraphicsFactory()->CreateSolidColorBrush(
-            *color_mapper->MapFromXml(c));
+            color_mapper->MapFromXml(c));
         auto name = c->GetOptionalAttribute(u"name");
         if (name) {
           if (name == u"foreground") {
-            result->foreground_brush = std::move(brush);
+            result.foreground_brush = std::move(brush);
           } else if (name == u"background") {
-            result->background_brush = std::move(brush);
+            result.background_brush = std::move(brush);
           } else {
             log::Debug(u"Unknown brush name: {}", *name);
           }
         } else {
-          result->border_brush = std::move(brush);
+          result.border_brush = std::move(brush);
         }
       }
     }
@@ -53,4 +53,4 @@ std::unique_ptr<ApplyBorderStyleInfo> BorderStyleMapper::DoMapFromXml(
 
   return result;
 }
-}  // namespace cru::ui::mapper::style
+}  // namespace cru::ui::mapper
diff --git a/src/ui/mapper/ColorMapper.cpp b/src/ui/mapper/ColorMapper.cpp
index e17352e1..a5d2c5e3 100644
--- a/src/ui/mapper/ColorMapper.cpp
+++ b/src/ui/mapper/ColorMapper.cpp
@@ -5,18 +5,18 @@ bool ColorMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
   return node->GetTag() == u"Color";
 }
 
-std::unique_ptr<Color> ColorMapper::DoMapFromString(String str) {
+Color ColorMapper::DoMapFromString(String str) {
   auto c = Color::Parse(str);
   if (!c) {
     throw Exception(u"Invalid color value.");
   }
-  return std::make_unique<Color>(*c);
+  return *c;
 }
 
-std::unique_ptr<Color> ColorMapper::DoMapFromXml(xml::XmlElementNode* node) {
+Color ColorMapper::DoMapFromXml(xml::XmlElementNode* node) {
   auto value_attr = node->GetOptionalAttribute(u"value");
   if (!value_attr) {
-    return std::make_unique<Color>(colors::transparent);
+    return colors::transparent;
   }
   return DoMapFromString(*value_attr);
 }
diff --git a/src/ui/mapper/CornerRadiusMapper.cpp b/src/ui/mapper/CornerRadiusMapper.cpp
index ef63e26f..0c13db7c 100644
--- a/src/ui/mapper/CornerRadiusMapper.cpp
+++ b/src/ui/mapper/CornerRadiusMapper.cpp
@@ -10,35 +10,33 @@ bool CornerRadiusMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
   return false;
 }
 
-std::unique_ptr<CornerRadius> CornerRadiusMapper::DoMapFromXml(
-    xml::XmlElementNode* node) {
+CornerRadius CornerRadiusMapper::DoMapFromXml(xml::XmlElementNode* node) {
   auto point_mapper = MapperRegistry::GetInstance()->GetMapper<Point>();
-
-  auto result = std::make_unique<CornerRadius>();
+  CornerRadius result;
 
   auto all = node->GetOptionalAttribute(u"all");
   if (all) {
-    result->SetAll(*point_mapper->MapFromString(*all));
+    result.SetAll(point_mapper->MapFromString(*all));
   }
 
   auto lefttop = node->GetOptionalAttribute(u"lefttop");
   if (lefttop) {
-    result->left_top = *point_mapper->MapFromString(*lefttop);
+    result.left_top = point_mapper->MapFromString(*lefttop);
   }
 
   auto righttop = node->GetOptionalAttribute(u"righttop");
   if (righttop) {
-    result->right_top = *point_mapper->MapFromString(*righttop);
+    result.right_top = point_mapper->MapFromString(*righttop);
   }
 
   auto rightbottom = node->GetOptionalAttribute(u"rightbottom");
   if (rightbottom) {
-    result->right_bottom = *point_mapper->MapFromString(*rightbottom);
+    result.right_bottom = point_mapper->MapFromString(*rightbottom);
   }
 
   auto leftbottom = node->GetOptionalAttribute(u"leftbottom");
   if (leftbottom) {
-    result->left_bottom = *point_mapper->MapFromString(*leftbottom);
+    result.left_bottom = point_mapper->MapFromString(*leftbottom);
   }
 
   return result;
diff --git a/src/ui/mapper/CursorMapper.cpp b/src/ui/mapper/CursorMapper.cpp
new file mode 100644
index 00000000..2dd08219
--- /dev/null
+++ b/src/ui/mapper/CursorMapper.cpp
@@ -0,0 +1,3 @@
+#include "cru/ui/mapper/CursorMapper.hpp"
+
+namespace cru::ui::mapper {}
diff --git a/src/ui/mapper/PointMapper.cpp b/src/ui/mapper/PointMapper.cpp
index 2be0ba01..bcf209fb 100644
--- a/src/ui/mapper/PointMapper.cpp
+++ b/src/ui/mapper/PointMapper.cpp
@@ -8,20 +8,20 @@ bool PointMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
   return false;
 }
 
-std::unique_ptr<Point> PointMapper::DoMapFromString(String str) {
+Point PointMapper::DoMapFromString(String str) {
   std::vector<float> values = str.ParseToFloatList();
   if (values.size() == 2) {
-    return std::make_unique<Point>(values[0], values[1]);
+    return {values[0], values[1]};
   } else if (values.size() == 1) {
-    return std::make_unique<Point>(values[0], values[0]);
+    return {values[0], values[0]};
   } else {
     throw Exception(u"Invalid Point string.");
   }
 }
 
-std::unique_ptr<Point> PointMapper::DoMapFromXml(xml::XmlElementNode* node) {
+Point PointMapper::DoMapFromXml(xml::XmlElementNode* node) {
   auto value_attr = node->GetOptionalAttribute(u"value");
-  if (!value_attr) return std::make_unique<Point>();
+  if (!value_attr) return {};
   return DoMapFromString(*value_attr);
 }
 }  // namespace cru::ui::mapper
diff --git a/src/ui/mapper/SizeMapper.cpp b/src/ui/mapper/SizeMapper.cpp
index 4f9dc208..3e3355cd 100644
--- a/src/ui/mapper/SizeMapper.cpp
+++ b/src/ui/mapper/SizeMapper.cpp
@@ -8,20 +8,20 @@ bool SizeMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
   return false;
 }
 
-std::unique_ptr<Size> SizeMapper::DoMapFromString(String str) {
+Size SizeMapper::DoMapFromString(String str) {
   std::vector<float> values = str.ParseToFloatList();
   if (values.size() == 2) {
-    return std::make_unique<Size>(values[0], values[1]);
+    return {values[0], values[1]};
   } else if (values.size() == 1) {
-    return std::make_unique<Size>(values[0], values[0]);
+    return {values[0], values[0]};
   } else {
     throw Exception(u"Invalid Point string.");
   }
 }
 
-std::unique_ptr<Size> SizeMapper::DoMapFromXml(xml::XmlElementNode* node) {
+Size SizeMapper::DoMapFromXml(xml::XmlElementNode* node) {
   auto value_attr = node->GetOptionalAttribute(u"value");
-  if (!value_attr) return std::make_unique<Size>();
+  if (!value_attr) return {};
   return DoMapFromString(*value_attr);
 }
 }  // namespace cru::ui::mapper
diff --git a/src/ui/mapper/ThicknessMapper.cpp b/src/ui/mapper/ThicknessMapper.cpp
index 11f0be0d..1829d64b 100644
--- a/src/ui/mapper/ThicknessMapper.cpp
+++ b/src/ui/mapper/ThicknessMapper.cpp
@@ -9,26 +9,22 @@ bool ThicknessMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
   return false;
 }
 
-std::unique_ptr<Thickness> ThicknessMapper::DoMapFromString(String str) {
+Thickness ThicknessMapper::DoMapFromString(String str) {
   std::vector<float> values = str.ParseToFloatList();
   if (values.size() == 4) {
-    return std::make_unique<Thickness>(values[0], values[1], values[2],
-                                       values[3]);
+    return Thickness(values[0], values[1], values[2], values[3]);
   } else if (values.size() == 2) {
-    return std::make_unique<Thickness>(values[0], values[1], values[0],
-                                       values[1]);
+    return Thickness(values[0], values[1], values[0], values[1]);
   } else if (values.size() == 1) {
-    return std::make_unique<Thickness>(values[0], values[0], values[0],
-                                       values[0]);
+    return Thickness(values[0], values[0], values[0], values[0]);
   } else {
     throw Exception(u"Invalid Thickness string.");
   }
 }
 
-std::unique_ptr<Thickness> ThicknessMapper::DoMapFromXml(
-    xml::XmlElementNode* node) {
+Thickness ThicknessMapper::DoMapFromXml(xml::XmlElementNode* node) {
   auto value_attr = node->GetOptionalAttribute(u"value");
-  if (!value_attr) return std::make_unique<Thickness>();
+  if (!value_attr) return {};
   return DoMapFromString(*value_attr);
 }
 }  // namespace cru::ui::mapper