Rename ClonePtr, update theme.

72 files changed, 350 insertions, 442 deletions

diff --git a/assets/cru/ui/DefaultResources.xml b/assets/cru/ui/DefaultResources.xml
index f7c1366d..5512dce6 100644
--- a/assets/cru/ui/DefaultResources.xml
+++ b/assets/cru/ui/DefaultResources.xml
@@ -79,6 +79,7 @@
         <StyleRuleSet>
             <StyleRule>
                 <NoCondition />
+                <PaddingStyler value="8 2"/>
                 <BorderStyler>
                     <BorderStyle>
                         <Thickness value="1" />
@@ -91,6 +92,7 @@
                 <BorderStyler>
                     <BorderStyle>
                         <Color value="#d2d2d2" />
+                        <Color name="background" value="#fdfdfd" />
                     </BorderStyle>
                 </BorderStyler>
                 <CursorStyler>
@@ -102,6 +104,7 @@
                 <BorderStyler>
                     <BorderStyle>
                         <Color value="#0078d4" />
+                        <Color name="background" value="#e0eef9" />
                     </BorderStyle>
                 </BorderStyler>
                 <CursorStyler>
@@ -113,6 +116,7 @@
                 <BorderStyler>
                     <BorderStyle>
                         <Color value="#06579b" />
+                        <Color name="background" value="#cce4f7" />
                     </BorderStyle>
                 </BorderStyler>
                 <CursorStyler>
@@ -124,6 +128,7 @@
                 <BorderStyler>
                     <BorderStyle>
                         <Color value="#06579b" />
+                        <Color name="background" value="#cce4f7" />
                     </BorderStyle>
                 </BorderStyler>
                 <CursorStyler>
diff --git a/include/cru/base/ClonablePtr.h b/include/cru/base/ClonablePtr.h
deleted file mode 100644
index 1198315f..00000000
--- a/include/cru/base/ClonablePtr.h
+++ /dev/null
@@ -1,216 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <functional>
-#include <memory>
-#include <type_traits>
-
-namespace cru {
-template <typename TClonable>
-class ClonablePtr {
-  template <typename T>
-  friend class ClonablePtr;
-
- public:
-  using element_type = typename std::unique_ptr<TClonable>::element_type;
-  using pointer = typename std::unique_ptr<TClonable>::pointer;
-
-  ClonablePtr() = default;
-  ClonablePtr(std::nullptr_t) noexcept : ptr_(nullptr) {}
-  explicit ClonablePtr(pointer p) noexcept : ptr_(p) {}
-  ClonablePtr(std::unique_ptr<element_type>&& p) noexcept
-      : ptr_(std::move(p)) {}
-  template <typename O,
-            std::enable_if_t<std::is_convertible_v<
-                                 typename ClonablePtr<O>::pointer, pointer>,
-                             int> = 0>
-  ClonablePtr(std::unique_ptr<O>&& p) : ptr_(std::move(p)) {}
-  ClonablePtr(const ClonablePtr& other) : ptr_(other.ptr_->Clone()) {}
-  ClonablePtr(ClonablePtr&& other) = default;
-  template <typename O,
-            std::enable_if_t<std::is_convertible_v<
-                                 typename ClonablePtr<O>::pointer, pointer>,
-                             int> = 0>
-  ClonablePtr(const ClonablePtr<O>& other) : ptr_(other.ptr_->Clone()) {}
-  template <typename O,
-            std::enable_if_t<std::is_convertible_v<
-                                 typename ClonablePtr<O>::pointer, pointer>,
-                             int> = 0>
-  ClonablePtr(ClonablePtr<O>&& other) noexcept : ptr_(std::move(other.ptr_)) {}
-  ClonablePtr& operator=(std::nullptr_t) noexcept {
-    ptr_ = nullptr;
-    return *this;
-  }
-  ClonablePtr& operator=(std::unique_ptr<element_type>&& other) noexcept {
-    ptr_ = std::move(other);
-    return *this;
-  }
-  template <typename O,
-            std::enable_if_t<std::is_convertible_v<
-                                 typename ClonablePtr<O>::pointer, pointer>,
-                             int> = 0>
-  ClonablePtr& operator=(std::unique_ptr<O>&& p) noexcept {
-    ptr_ = std::move(p);
-    return *this;
-  }
-  ClonablePtr& operator=(const ClonablePtr& other) {
-    if (this != &other) {
-      ptr_ = std::unique_ptr<element_type>(other.ptr_->Clone());
-    }
-    return *this;
-  }
-  ClonablePtr& operator=(ClonablePtr&& other) = default;
-  template <typename O,
-            std::enable_if_t<std::is_convertible_v<
-                                 typename ClonablePtr<O>::pointer, pointer>,
-                             int> = 0>
-  ClonablePtr& operator=(const ClonablePtr<O>& other) noexcept {
-    if (this != &other) {
-      ptr_ = std::unique_ptr<element_type>(other.ptr_->Clone());
-    }
-    return *this;
-  }
-  template <typename O,
-            std::enable_if_t<std::is_convertible_v<
-                                 typename ClonablePtr<O>::pointer, pointer>,
-                             int> = 0>
-  ClonablePtr& operator=(ClonablePtr<O>&& other) noexcept {
-    ptr_ = std::move(other.ptr_);
-  }
-
-  ~ClonablePtr() = default;
-
- public:
-  pointer release() noexcept { return ptr_.release(); }
-  void reset(pointer p = pointer()) noexcept { ptr_.reset(p); }
-  void swap(ClonablePtr& other) noexcept { ptr_.swap(other.ptr_); }
-
- public:
-  pointer get() const noexcept { return ptr_.get(); }
-
-  operator bool() const noexcept { return ptr_ != nullptr; }
-
-  element_type& operator*() const noexcept { return *ptr_; }
-  pointer operator->() const noexcept { return ptr_.get(); }
-
-  int Compare(const ClonablePtr& other) const noexcept {
-    if (ptr_ == other.ptr_) {
-      return 0;
-    } else if (ptr_ < other.ptr_) {
-      return -1;
-    } else {
-      return 1;
-    }
-  }
-
-  int Compare(std::nullptr_t) const noexcept { return ptr_ ? 1 : 0; }
-
- private:
-  std::unique_ptr<element_type> ptr_;
-};
-
-template <typename T>
-void swap(ClonablePtr<T>& left, ClonablePtr<T>& right) noexcept {
-  left.swap(right);
-}
-
-template <typename T>
-bool operator==(const ClonablePtr<T>& left, const ClonablePtr<T>& right) {
-  return left.Compare(right) == 0;
-}
-
-template <typename T>
-bool operator!=(const ClonablePtr<T>& left, const ClonablePtr<T>& right) {
-  return left.Compare(right) != 0;
-}
-
-template <typename T>
-bool operator<(const ClonablePtr<T>& left, const ClonablePtr<T>& right) {
-  return left.Compare(right) < 0;
-}
-
-template <typename T>
-bool operator<=(const ClonablePtr<T>& left, const ClonablePtr<T>& right) {
-  return left.Compare(right) <= 0;
-}
-
-template <typename T>
-bool operator>(const ClonablePtr<T>& left, const ClonablePtr<T>& right) {
-  return left.Compare(right) > 0;
-}
-
-template <typename T>
-bool operator>=(const ClonablePtr<T>& left, const ClonablePtr<T>& right) {
-  return left.Compare(right) >= 0;
-}
-
-template <typename T>
-bool operator==(const ClonablePtr<T>& left, std::nullptr_t) {
-  return left.Compare(nullptr) == 0;
-}
-
-template <typename T>
-bool operator!=(const ClonablePtr<T>& left, std::nullptr_t) {
-  return left.Compare(nullptr) != 0;
-}
-
-template <typename T>
-bool operator<(const ClonablePtr<T>& left, std::nullptr_t) {
-  return left.Compare(nullptr) < 0;
-}
-
-template <typename T>
-bool operator<=(const ClonablePtr<T>& left, std::nullptr_t) {
-  return left.Compare(nullptr) <= 0;
-}
-
-template <typename T>
-bool operator>(const ClonablePtr<T>& left, std::nullptr_t) {
-  return left.Compare(nullptr) > 0;
-}
-
-template <typename T>
-bool operator>=(const ClonablePtr<T>& left, std::nullptr_t) {
-  return left.Compare(nullptr) >= 0;
-}
-
-template <typename T>
-bool operator==(std::nullptr_t, const ClonablePtr<T>& right) {
-  return right.Compare(nullptr) == 0;
-}
-
-template <typename T>
-bool operator!=(std::nullptr_t, const ClonablePtr<T>& right) {
-  return right.Compare(nullptr) != 0;
-}
-
-template <typename T>
-bool operator<(std::nullptr_t, const ClonablePtr<T>& right) {
-  return right.Compare(nullptr) > 0;
-}
-
-template <typename T>
-bool operator<=(std::nullptr_t, const ClonablePtr<T>& right) {
-  return right.Compare(nullptr) >= 0;
-}
-
-template <typename T>
-bool operator>(std::nullptr_t, const ClonablePtr<T>& right) {
-  return right.Compare(nullptr) < 0;
-}
-
-template <typename T>
-bool operator>=(std::nullptr_t, const ClonablePtr<T>& right) {
-  return right.Compare(nullptr) <= 0;
-}
-
-}  // namespace cru
-
-namespace std {
-template <typename T>
-struct hash<cru::ClonablePtr<T>> {
-  std::size_t operator()(const cru::ClonablePtr<T>& p) const {
-    return std::hash<typename cru::ClonablePtr<T>::pointer>(p.get());
-  }
-};
-}  // namespace std
diff --git a/include/cru/base/ClonePtr.h b/include/cru/base/ClonePtr.h
new file mode 100644
index 00000000..452c2cdd
--- /dev/null
+++ b/include/cru/base/ClonePtr.h
@@ -0,0 +1,119 @@
+#pragma once
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <type_traits>
+
+namespace cru {
+template <typename T>
+class ClonePtr {
+  template <typename O>
+  friend class ClonePtr;
+
+ public:
+  using element_type = typename std::unique_ptr<T>::element_type;
+  using pointer = typename std::unique_ptr<T>::pointer;
+
+  ClonePtr() = default;
+  ClonePtr(std::nullptr_t) noexcept : ptr_(nullptr) {}
+  explicit ClonePtr(pointer p) noexcept : ptr_(p) {}
+  ClonePtr(std::unique_ptr<element_type>&& p) noexcept : ptr_(std::move(p)) {}
+  template <typename O,
+            std::enable_if_t<
+                std::is_convertible_v<typename ClonePtr<O>::pointer, pointer>,
+                int> = 0>
+  ClonePtr(std::unique_ptr<O>&& p) : ptr_(std::move(p)) {}
+  ClonePtr(const ClonePtr& other) : ptr_(other.ptr_->Clone()) {}
+  ClonePtr(ClonePtr&& other) = default;
+  template <typename O,
+            std::enable_if_t<
+                std::is_convertible_v<typename ClonePtr<O>::pointer, pointer>,
+                int> = 0>
+  ClonePtr(const ClonePtr<O>& other) : ptr_(other.ptr_->Clone()) {}
+  template <typename O,
+            std::enable_if_t<
+                std::is_convertible_v<typename ClonePtr<O>::pointer, pointer>,
+                int> = 0>
+  ClonePtr(ClonePtr<O>&& other) noexcept : ptr_(std::move(other.ptr_)) {}
+  ClonePtr& operator=(std::nullptr_t) noexcept {
+    ptr_ = nullptr;
+    return *this;
+  }
+  ClonePtr& operator=(std::unique_ptr<element_type>&& other) noexcept {
+    ptr_ = std::move(other);
+    return *this;
+  }
+  template <typename O,
+            std::enable_if_t<
+                std::is_convertible_v<typename ClonePtr<O>::pointer, pointer>,
+                int> = 0>
+  ClonePtr& operator=(std::unique_ptr<O>&& p) noexcept {
+    ptr_ = std::move(p);
+    return *this;
+  }
+  ClonePtr& operator=(const ClonePtr& other) {
+    if (this != &other) {
+      ptr_ = std::unique_ptr<element_type>(other.ptr_->Clone());
+    }
+    return *this;
+  }
+  ClonePtr& operator=(ClonePtr&& other) = default;
+  template <typename O,
+            std::enable_if_t<
+                std::is_convertible_v<typename ClonePtr<O>::pointer, pointer>,
+                int> = 0>
+  ClonePtr& operator=(const ClonePtr<O>& other) noexcept {
+    if (this != &other) {
+      ptr_ = std::unique_ptr<element_type>(other.ptr_->Clone());
+    }
+    return *this;
+  }
+  template <typename O,
+            std::enable_if_t<
+                std::is_convertible_v<typename ClonePtr<O>::pointer, pointer>,
+                int> = 0>
+  ClonePtr& operator=(ClonePtr<O>&& other) noexcept {
+    ptr_ = std::move(other.ptr_);
+  }
+
+  ~ClonePtr() = default;
+
+ public:
+  pointer release() noexcept { return ptr_.release(); }
+  void reset(pointer p = pointer()) noexcept { ptr_.reset(p); }
+  void swap(ClonePtr& other) noexcept { ptr_.swap(other.ptr_); }
+
+ public:
+  pointer get() const noexcept { return ptr_.get(); }
+
+  operator bool() const noexcept { return ptr_ != nullptr; }
+
+  element_type& operator*() const noexcept { return *ptr_; }
+  pointer operator->() const noexcept { return ptr_.get(); }
+
+  auto operator<=>(std::nullptr_t) const { return ptr_.operator<=>(nullptr); }
+
+  auto operator<=>(const ClonePtr& other) const {
+    return ptr_.operator<=>(other.ptr_);
+  }
+
+ private:
+  std::unique_ptr<element_type> ptr_;
+};
+
+template <typename T>
+void swap(ClonePtr<T>& left, ClonePtr<T>& right) noexcept {
+  left.swap(right);
+}
+
+}  // namespace cru
+
+namespace std {
+template <typename T>
+struct hash<cru::ClonePtr<T>> {
+  std::size_t operator()(const cru::ClonePtr<T>& p) const {
+    return std::hash<typename cru::ClonePtr<T>::pointer>(p.get());
+  }
+};
+}  // namespace std
diff --git a/include/cru/ui/mapper/Mapper.h b/include/cru/ui/mapper/Mapper.h
index 88081816..164329d3 100644
--- a/include/cru/ui/mapper/Mapper.h
+++ b/include/cru/ui/mapper/Mapper.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "../Base.h"
 
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/base/xml/XmlNode.h"
 
 #include <memory>
@@ -88,5 +88,5 @@ template <typename T>
 using BasicSharedPtrMapper = BasicMapper<std::shared_ptr<T>>;
 
 template <typename T>
-using BasicClonablePtrMapper = BasicMapper<ClonablePtr<T>>;
+using BasicClonePtrMapper = BasicMapper<ClonePtr<T>>;
 }  // namespace cru::ui::mapper
diff --git a/include/cru/ui/mapper/MapperRegistry.h b/include/cru/ui/mapper/MapperRegistry.h
index ca1170b5..fae90b40 100644
--- a/include/cru/ui/mapper/MapperRegistry.h
+++ b/include/cru/ui/mapper/MapperRegistry.h
@@ -35,8 +35,8 @@ class CRU_UI_API MapperRegistry {
   }
 
   template <typename T>
-  BasicClonablePtrMapper<T>* GetClonablePtrMapper() const {
-    return GetMapper<ClonablePtr<T>>();
+  BasicClonePtrMapper<T>* GetClonePtrMapper() const {
+    return GetMapper<ClonePtr<T>>();
   }
 
   template <typename T>
diff --git a/include/cru/ui/mapper/style/AndConditionMapper.h b/include/cru/ui/mapper/style/AndConditionMapper.h
index 65d0337c..5569e0fc 100644
--- a/include/cru/ui/mapper/style/AndConditionMapper.h
+++ b/include/cru/ui/mapper/style/AndConditionMapper.h
@@ -4,7 +4,7 @@
 
 namespace cru::ui::mapper::style {
 class CRU_UI_API AndConditionMapper
-    : public BasicClonablePtrMapper<ui::style::AndCondition>,
+    : public BasicClonePtrMapper<ui::style::AndCondition>,
       public virtual IConditionMapper {
  public:
   CRU_DEFAULT_CONSTRUCTOR_DESTRUCTOR(AndConditionMapper)
@@ -13,13 +13,13 @@ class CRU_UI_API AndConditionMapper
   bool SupportMapFromXml() override { return true; }
   bool XmlElementIsOfThisType(xml::XmlElementNode* node) override;
 
-  ClonablePtr<ui::style::Condition> MapConditionFromXml(
+  ClonePtr<ui::style::Condition> MapConditionFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::AndCondition> DoMapFromXml(
+  ClonePtr<ui::style::AndCondition> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/BorderStylerMapper.h b/include/cru/ui/mapper/style/BorderStylerMapper.h
index 8cb4d392..c1554255 100644
--- a/include/cru/ui/mapper/style/BorderStylerMapper.h
+++ b/include/cru/ui/mapper/style/BorderStylerMapper.h
@@ -1,13 +1,13 @@
 #pragma once
 #include "../Mapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/mapper/style/IStylerMapper.h"
 #include "cru/ui/style/Styler.h"
 #include "cru/base/xml/XmlNode.h"
 
 namespace cru::ui::mapper::style {
 class CRU_UI_API BorderStylerMapper
-    : public BasicClonablePtrMapper<ui::style::BorderStyler>,
+    : public BasicClonePtrMapper<ui::style::BorderStyler>,
       public virtual IStylerMapper {
  public:
   CRU_DEFAULT_CONSTRUCTOR_DESTRUCTOR(BorderStylerMapper)
@@ -16,13 +16,13 @@ class CRU_UI_API BorderStylerMapper
   bool SupportMapFromXml() override { return true; }
   bool XmlElementIsOfThisType(xml::XmlElementNode* node) override;
 
-  ClonablePtr<ui::style::Styler> MapStylerFromXml(
+  ClonePtr<ui::style::Styler> MapStylerFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::BorderStyler> DoMapFromXml(
+  ClonePtr<ui::style::BorderStyler> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/CheckedConditionMapper.h b/include/cru/ui/mapper/style/CheckedConditionMapper.h
index 1bed9597..87d892a7 100644
--- a/include/cru/ui/mapper/style/CheckedConditionMapper.h
+++ b/include/cru/ui/mapper/style/CheckedConditionMapper.h
@@ -5,7 +5,7 @@
 
 namespace cru::ui::mapper::style {
 class CRU_UI_API CheckedConditionMapper
-    : public BasicClonablePtrMapper<ui::style::CheckedCondition>,
+    : public BasicClonePtrMapper<ui::style::CheckedCondition>,
       public virtual IConditionMapper {
  public:
   CRU_DEFAULT_CONSTRUCTOR_DESTRUCTOR(CheckedConditionMapper)
@@ -14,13 +14,13 @@ class CRU_UI_API CheckedConditionMapper
   bool SupportMapFromXml() override { return true; }
   bool XmlElementIsOfThisType(xml::XmlElementNode* node) override;
 
-  ClonablePtr<ui::style::Condition> MapConditionFromXml(
+  ClonePtr<ui::style::Condition> MapConditionFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::CheckedCondition> DoMapFromXml(
+  ClonePtr<ui::style::CheckedCondition> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/ClickStateConditionMapper.h b/include/cru/ui/mapper/style/ClickStateConditionMapper.h
index a54a3ad4..13c72a36 100644
--- a/include/cru/ui/mapper/style/ClickStateConditionMapper.h
+++ b/include/cru/ui/mapper/style/ClickStateConditionMapper.h
@@ -5,7 +5,7 @@
 
 namespace cru::ui::mapper::style {
 class CRU_UI_API ClickStateConditionMapper
-    : public BasicClonablePtrMapper<ui::style::ClickStateCondition>,
+    : public BasicClonePtrMapper<ui::style::ClickStateCondition>,
       public virtual IConditionMapper {
  public:
   CRU_DEFAULT_CONSTRUCTOR_DESTRUCTOR(ClickStateConditionMapper)
@@ -14,13 +14,13 @@ class CRU_UI_API ClickStateConditionMapper
   bool SupportMapFromXml() override { return true; }
   bool XmlElementIsOfThisType(xml::XmlElementNode* node) override;
 
-  ClonablePtr<ui::style::Condition> MapConditionFromXml(
+  ClonePtr<ui::style::Condition> MapConditionFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  public:
-  ClonablePtr<ui::style::ClickStateCondition> DoMapFromXml(
+  ClonePtr<ui::style::ClickStateCondition> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/ContentBrushStylerMapper.h b/include/cru/ui/mapper/style/ContentBrushStylerMapper.h
index 04b19bf8..d15eb28a 100644
--- a/include/cru/ui/mapper/style/ContentBrushStylerMapper.h
+++ b/include/cru/ui/mapper/style/ContentBrushStylerMapper.h
@@ -4,7 +4,7 @@
 
 namespace cru::ui::mapper::style {
 class ContentBrushStylerMapper
-    : public BasicClonablePtrMapper<ui::style::ContentBrushStyler>,
+    : public BasicClonePtrMapper<ui::style::ContentBrushStyler>,
       public virtual IStylerMapper {
  public:
   ContentBrushStylerMapper();
@@ -13,13 +13,13 @@ class ContentBrushStylerMapper
  public:
   bool SupportMapFromXml() override { return true; }
 
-  ClonablePtr<ui::style::Styler> MapStylerFromXml(
+  ClonePtr<ui::style::Styler> MapStylerFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::ContentBrushStyler> DoMapFromXml(
+  ClonePtr<ui::style::ContentBrushStyler> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/CursorStylerMapper.h b/include/cru/ui/mapper/style/CursorStylerMapper.h
index c88a5170..54ade7f0 100644
--- a/include/cru/ui/mapper/style/CursorStylerMapper.h
+++ b/include/cru/ui/mapper/style/CursorStylerMapper.h
@@ -5,7 +5,7 @@
 
 namespace cru::ui::mapper::style {
 class CRU_UI_API CursorStylerMapper
-    : public BasicClonablePtrMapper<ui::style::CursorStyler>,
+    : public BasicClonePtrMapper<ui::style::CursorStyler>,
       public virtual IStylerMapper {
  public:
   CRU_DEFAULT_CONSTRUCTOR_DESTRUCTOR(CursorStylerMapper)
@@ -14,13 +14,13 @@ class CRU_UI_API CursorStylerMapper
   bool SupportMapFromXml() override { return true; }
   bool XmlElementIsOfThisType(xml::XmlElementNode* node) override;
 
-  ClonablePtr<ui::style::Styler> MapStylerFromXml(
+  ClonePtr<ui::style::Styler> MapStylerFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::CursorStyler> DoMapFromXml(
+  ClonePtr<ui::style::CursorStyler> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/FocusConditionMapper.h b/include/cru/ui/mapper/style/FocusConditionMapper.h
index 6a7c56a2..e18150cf 100644
--- a/include/cru/ui/mapper/style/FocusConditionMapper.h
+++ b/include/cru/ui/mapper/style/FocusConditionMapper.h
@@ -5,7 +5,7 @@
 
 namespace cru::ui::mapper::style {
 class CRU_UI_API FocusConditionMapper
-    : public BasicClonablePtrMapper<ui::style::FocusCondition>,
+    : public BasicClonePtrMapper<ui::style::FocusCondition>,
       public virtual IConditionMapper {
  public:
   CRU_DEFAULT_CONSTRUCTOR_DESTRUCTOR(FocusConditionMapper)
@@ -14,13 +14,13 @@ class CRU_UI_API FocusConditionMapper
   bool SupportMapFromXml() override { return true; }
   bool XmlElementIsOfThisType(xml::XmlElementNode* node) override;
 
-  ClonablePtr<ui::style::Condition> MapConditionFromXml(
+  ClonePtr<ui::style::Condition> MapConditionFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::FocusCondition> DoMapFromXml(
+  ClonePtr<ui::style::FocusCondition> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/FontStylerMapper.h b/include/cru/ui/mapper/style/FontStylerMapper.h
index 34c94b73..6a79eb99 100644
--- a/include/cru/ui/mapper/style/FontStylerMapper.h
+++ b/include/cru/ui/mapper/style/FontStylerMapper.h
@@ -3,7 +3,7 @@
 #include "IStylerMapper.h"
 
 namespace cru::ui::mapper::style {
-class FontStylerMapper : public BasicClonablePtrMapper<ui::style::FontStyler>,
+class FontStylerMapper : public BasicClonePtrMapper<ui::style::FontStyler>,
                          public virtual IStylerMapper {
  public:
   FontStylerMapper();
@@ -12,13 +12,13 @@ class FontStylerMapper : public BasicClonablePtrMapper<ui::style::FontStyler>,
  public:
   bool SupportMapFromXml() override { return true; }
 
-  ClonablePtr<ui::style::Styler> MapStylerFromXml(
+  ClonePtr<ui::style::Styler> MapStylerFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::FontStyler> DoMapFromXml(
+  ClonePtr<ui::style::FontStyler> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/HoverConditionMapper.h b/include/cru/ui/mapper/style/HoverConditionMapper.h
index d3aa0b60..faa889e7 100644
--- a/include/cru/ui/mapper/style/HoverConditionMapper.h
+++ b/include/cru/ui/mapper/style/HoverConditionMapper.h
@@ -5,7 +5,7 @@
 
 namespace cru::ui::mapper::style {
 class CRU_UI_API HoverConditionMapper
-    : public BasicClonablePtrMapper<ui::style::HoverCondition>,
+    : public BasicClonePtrMapper<ui::style::HoverCondition>,
       public virtual IConditionMapper {
  public:
   CRU_DEFAULT_CONSTRUCTOR_DESTRUCTOR(HoverConditionMapper)
@@ -14,13 +14,13 @@ class CRU_UI_API HoverConditionMapper
   bool SupportMapFromXml() override { return true; }
   bool XmlElementIsOfThisType(xml::XmlElementNode* node) override;
 
-  ClonablePtr<ui::style::Condition> MapConditionFromXml(
+  ClonePtr<ui::style::Condition> MapConditionFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::HoverCondition> DoMapFromXml(
+  ClonePtr<ui::style::HoverCondition> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/IConditionMapper.h b/include/cru/ui/mapper/style/IConditionMapper.h
index 7bfd1427..27c09e82 100644
--- a/include/cru/ui/mapper/style/IConditionMapper.h
+++ b/include/cru/ui/mapper/style/IConditionMapper.h
@@ -1,6 +1,6 @@
 #pragma once
 #include "../../Base.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/mapper/Mapper.h"
 #include "cru/ui/style/Condition.h"
 #include "cru/base/xml/XmlNode.h"
@@ -11,7 +11,7 @@ struct CRU_UI_API IConditionMapper : virtual Interface {
     return dynamic_cast<MapperBase*>(this)->XmlElementIsOfThisType(node);
   }
 
-  virtual ClonablePtr<ui::style::Condition> MapConditionFromXml(
+  virtual ClonePtr<ui::style::Condition> MapConditionFromXml(
       xml::XmlElementNode* node) = 0;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/IStylerMapper.h b/include/cru/ui/mapper/style/IStylerMapper.h
index 4aa43665..ce9c4243 100644
--- a/include/cru/ui/mapper/style/IStylerMapper.h
+++ b/include/cru/ui/mapper/style/IStylerMapper.h
@@ -1,6 +1,6 @@
 #pragma once
 #include "../../Base.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/mapper/Mapper.h"
 #include "cru/ui/style/Styler.h"
 #include "cru/base/xml/XmlNode.h"
@@ -11,7 +11,7 @@ struct CRU_UI_API IStylerMapper : virtual Interface {
     return dynamic_cast<MapperBase*>(this)->XmlElementIsOfThisType(node);
   }
 
-  virtual ClonablePtr<ui::style::Styler> MapStylerFromXml(
+  virtual ClonePtr<ui::style::Styler> MapStylerFromXml(
       xml::XmlElementNode* node) = 0;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/MarginStylerMapper.h b/include/cru/ui/mapper/style/MarginStylerMapper.h
index 39d55fb6..b20452a9 100644
--- a/include/cru/ui/mapper/style/MarginStylerMapper.h
+++ b/include/cru/ui/mapper/style/MarginStylerMapper.h
@@ -5,7 +5,7 @@
 
 namespace cru::ui::mapper::style {
 class CRU_UI_API MarginStylerMapper
-    : public BasicClonablePtrMapper<ui::style::MarginStyler>,
+    : public BasicClonePtrMapper<ui::style::MarginStyler>,
       public virtual IStylerMapper {
  public:
   MarginStylerMapper();
@@ -14,13 +14,13 @@ class CRU_UI_API MarginStylerMapper
  public:
   bool SupportMapFromXml() override { return true; }
 
-  ClonablePtr<ui::style::Styler> MapStylerFromXml(
+  ClonePtr<ui::style::Styler> MapStylerFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::MarginStyler> DoMapFromXml(
+  ClonePtr<ui::style::MarginStyler> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/NoConditionMapper.h b/include/cru/ui/mapper/style/NoConditionMapper.h
index bd2adf14..8acb79e0 100644
--- a/include/cru/ui/mapper/style/NoConditionMapper.h
+++ b/include/cru/ui/mapper/style/NoConditionMapper.h
@@ -2,13 +2,13 @@
 #include "../Mapper.h"
 #include "IConditionMapper.h"
 #include "cru/base/Base.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/style/Condition.h"
 #include "cru/base/xml/XmlNode.h"
 
 namespace cru::ui::mapper::style {
 class CRU_UI_API NoConditionMapper
-    : public BasicClonablePtrMapper<ui::style::NoCondition>,
+    : public BasicClonePtrMapper<ui::style::NoCondition>,
       public virtual IConditionMapper {
  public:
   CRU_DEFAULT_CONSTRUCTOR_DESTRUCTOR(NoConditionMapper)
@@ -17,13 +17,13 @@ class CRU_UI_API NoConditionMapper
   bool SupportMapFromXml() override { return true; }
   bool XmlElementIsOfThisType(xml::XmlElementNode* node) override;
 
-  ClonablePtr<ui::style::Condition> MapConditionFromXml(
+  ClonePtr<ui::style::Condition> MapConditionFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::NoCondition> DoMapFromXml(
+  ClonePtr<ui::style::NoCondition> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/OrConditionMapper.h b/include/cru/ui/mapper/style/OrConditionMapper.h
index de8e0695..0aa5b241 100644
--- a/include/cru/ui/mapper/style/OrConditionMapper.h
+++ b/include/cru/ui/mapper/style/OrConditionMapper.h
@@ -4,7 +4,7 @@
 
 namespace cru::ui::mapper::style {
 class CRU_UI_API OrConditionMapper
-    : public BasicClonablePtrMapper<ui::style::OrCondition>,
+    : public BasicClonePtrMapper<ui::style::OrCondition>,
       public virtual IConditionMapper {
  public:
   CRU_DEFAULT_CONSTRUCTOR_DESTRUCTOR(OrConditionMapper)
@@ -13,13 +13,13 @@ class CRU_UI_API OrConditionMapper
   bool SupportMapFromXml() override { return true; }
   bool XmlElementIsOfThisType(xml::XmlElementNode* node) override;
 
-  ClonablePtr<ui::style::Condition> MapConditionFromXml(
+  ClonePtr<ui::style::Condition> MapConditionFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::OrCondition> DoMapFromXml(
+  ClonePtr<ui::style::OrCondition> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/PaddingStylerMapper.h b/include/cru/ui/mapper/style/PaddingStylerMapper.h
index e7515ec1..bf0c5650 100644
--- a/include/cru/ui/mapper/style/PaddingStylerMapper.h
+++ b/include/cru/ui/mapper/style/PaddingStylerMapper.h
@@ -5,7 +5,7 @@
 
 namespace cru::ui::mapper::style {
 class CRU_UI_API PaddingStylerMapper
-    : public BasicClonablePtrMapper<ui::style::PaddingStyler>,
+    : public BasicClonePtrMapper<ui::style::PaddingStyler>,
       public virtual IStylerMapper {
  public:
   PaddingStylerMapper();
@@ -14,13 +14,13 @@ class CRU_UI_API PaddingStylerMapper
  public:
   bool SupportMapFromXml() override { return true; }
 
-  ClonablePtr<ui::style::Styler> MapStylerFromXml(
+  ClonePtr<ui::style::Styler> MapStylerFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::PaddingStyler> DoMapFromXml(
+  ClonePtr<ui::style::PaddingStyler> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/PreferredSizeStylerMapper.h b/include/cru/ui/mapper/style/PreferredSizeStylerMapper.h
index f46b70d5..ee4f5705 100644
--- a/include/cru/ui/mapper/style/PreferredSizeStylerMapper.h
+++ b/include/cru/ui/mapper/style/PreferredSizeStylerMapper.h
@@ -5,7 +5,7 @@
 
 namespace cru::ui::mapper::style {
 class CRU_UI_API PreferredSizeStylerMapper
-    : public BasicClonablePtrMapper<ui::style::PreferredSizeStyler>,
+    : public BasicClonePtrMapper<ui::style::PreferredSizeStyler>,
       public virtual IStylerMapper {
  public:
   CRU_DEFAULT_CONSTRUCTOR_DESTRUCTOR(PreferredSizeStylerMapper)
@@ -14,13 +14,13 @@ class CRU_UI_API PreferredSizeStylerMapper
   bool SupportMapFromXml() override { return true; }
   bool XmlElementIsOfThisType(xml::XmlElementNode* node) override;
 
-  ClonablePtr<ui::style::Styler> MapStylerFromXml(
+  ClonePtr<ui::style::Styler> MapStylerFromXml(
       xml::XmlElementNode* node) override {
     return MapFromXml(node);
   }
 
  protected:
-  ClonablePtr<ui::style::PreferredSizeStyler> DoMapFromXml(
+  ClonePtr<ui::style::PreferredSizeStyler> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/mapper/style/StyleRuleMapper.h b/include/cru/ui/mapper/style/StyleRuleMapper.h
index b4cb95e7..5622d0f4 100644
--- a/include/cru/ui/mapper/style/StyleRuleMapper.h
+++ b/include/cru/ui/mapper/style/StyleRuleMapper.h
@@ -1,12 +1,12 @@
 #pragma once
 #include "../Mapper.h"
 #include "cru/base/Base.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/style/StyleRule.h"
 #include "cru/base/xml/XmlNode.h"
 
 namespace cru::ui::mapper::style {
-class CRU_UI_API StyleRuleMapper : public BasicClonablePtrMapper<ui::style::StyleRule> {
+class CRU_UI_API StyleRuleMapper : public BasicClonePtrMapper<ui::style::StyleRule> {
   CRU_DEFINE_CLASS_LOG_TAG("StyleRuleMapper")
  public:
   CRU_DEFAULT_CONSTRUCTOR_DESTRUCTOR(StyleRuleMapper)
@@ -16,7 +16,7 @@ class CRU_UI_API StyleRuleMapper : public BasicClonablePtrMapper<ui::style::Styl
   bool XmlElementIsOfThisType(xml::XmlElementNode* node) override;
 
  protected:
-  ClonablePtr<ui::style::StyleRule> DoMapFromXml(
+  ClonePtr<ui::style::StyleRule> DoMapFromXml(
       xml::XmlElementNode* node) override;
 };
 }  // namespace cru::ui::mapper::style
diff --git a/include/cru/ui/style/Condition.h b/include/cru/ui/style/Condition.h
index 2d2dceac..e9b0e9d5 100644
--- a/include/cru/ui/style/Condition.h
+++ b/include/cru/ui/style/Condition.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "../Base.h"
 #include "cru/base/Base.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/base/Event.h"
 #include "cru/ui/controls/IClickableControl.h"
 #include "cru/ui/helper/ClickDetector.h"
@@ -23,8 +23,8 @@ class CRU_UI_API Condition : public Object {
 
 class CRU_UI_API NoCondition : public Condition {
  public:
-  static ClonablePtr<NoCondition> Create() {
-    return ClonablePtr<NoCondition>(new NoCondition);
+  static ClonePtr<NoCondition> Create() {
+    return ClonePtr<NoCondition>(new NoCondition);
   };
 
   std::vector<IBaseEvent*> ChangeOn(controls::Control*) const override {
@@ -38,23 +38,23 @@ class CRU_UI_API NoCondition : public Condition {
 
 class CRU_UI_API CompoundCondition : public Condition {
  public:
-  explicit CompoundCondition(std::vector<ClonablePtr<Condition>> conditions);
+  explicit CompoundCondition(std::vector<ClonePtr<Condition>> conditions);
 
   std::vector<IBaseEvent*> ChangeOn(controls::Control* control) const override;
 
-  std::vector<ClonablePtr<Condition>> GetChildren() const {
+  std::vector<ClonePtr<Condition>> GetChildren() const {
     return conditions_;
   }
 
  protected:
-  std::vector<ClonablePtr<Condition>> conditions_;
+  std::vector<ClonePtr<Condition>> conditions_;
 };
 
 class CRU_UI_API AndCondition : public CompoundCondition {
  public:
-  static ClonablePtr<AndCondition> Create(
-      std::vector<ClonablePtr<Condition>> conditions) {
-    return ClonablePtr<AndCondition>(new AndCondition(std::move(conditions)));
+  static ClonePtr<AndCondition> Create(
+      std::vector<ClonePtr<Condition>> conditions) {
+    return ClonePtr<AndCondition>(new AndCondition(std::move(conditions)));
   }
 
   using CompoundCondition::CompoundCondition;
@@ -66,9 +66,9 @@ class CRU_UI_API AndCondition : public CompoundCondition {
 
 class CRU_UI_API OrCondition : public CompoundCondition {
  public:
-  static ClonablePtr<OrCondition> Create(
-      std::vector<ClonablePtr<Condition>> conditions) {
-    return ClonablePtr<OrCondition>(new OrCondition(std::move(conditions)));
+  static ClonePtr<OrCondition> Create(
+      std::vector<ClonePtr<Condition>> conditions) {
+    return ClonePtr<OrCondition>(new OrCondition(std::move(conditions)));
   }
 
   using CompoundCondition::CompoundCondition;
@@ -80,8 +80,8 @@ class CRU_UI_API OrCondition : public CompoundCondition {
 
 class CRU_UI_API FocusCondition : public Condition {
  public:
-  static ClonablePtr<FocusCondition> Create(bool has_focus) {
-    return ClonablePtr<FocusCondition>(new FocusCondition(has_focus));
+  static ClonePtr<FocusCondition> Create(bool has_focus) {
+    return ClonePtr<FocusCondition>(new FocusCondition(has_focus));
   }
 
   explicit FocusCondition(bool has_focus);
@@ -101,8 +101,8 @@ class CRU_UI_API FocusCondition : public Condition {
 
 class CRU_UI_API HoverCondition : public Condition {
  public:
-  static ClonablePtr<HoverCondition> Create(bool hover) {
-    return ClonablePtr<HoverCondition>(new HoverCondition(hover));
+  static ClonePtr<HoverCondition> Create(bool hover) {
+    return ClonePtr<HoverCondition>(new HoverCondition(hover));
   }
 
   explicit HoverCondition(bool hover) : hover_(hover) {}
@@ -118,9 +118,9 @@ class CRU_UI_API HoverCondition : public Condition {
 
 class CRU_UI_API ClickStateCondition : public Condition {
  public:
-  static ClonablePtr<ClickStateCondition> Create(
+  static ClonePtr<ClickStateCondition> Create(
       helper::ClickState click_state) {
-    return ClonablePtr<ClickStateCondition>(
+    return ClonePtr<ClickStateCondition>(
         new ClickStateCondition(click_state));
   }
 
@@ -141,8 +141,8 @@ class CRU_UI_API ClickStateCondition : public Condition {
 
 class CRU_UI_API CheckedCondition : public Condition {
  public:
-  static ClonablePtr<CheckedCondition> Create(bool checked) {
-    return ClonablePtr<CheckedCondition>(new CheckedCondition(checked));
+  static ClonePtr<CheckedCondition> Create(bool checked) {
+    return ClonePtr<CheckedCondition>(new CheckedCondition(checked));
   }
 
   explicit CheckedCondition(bool checked);
diff --git a/include/cru/ui/style/StyleRule.h b/include/cru/ui/style/StyleRule.h
index 382cd664..dd0d8780 100644
--- a/include/cru/ui/style/StyleRule.h
+++ b/include/cru/ui/style/StyleRule.h
@@ -2,7 +2,7 @@
 #include "../Base.h"
 #include "Condition.h"
 #include "Styler.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 
 namespace cru::ui::style {
 /**
@@ -11,14 +11,14 @@ namespace cru::ui::style {
  */
 class CRU_UI_API StyleRule {
  public:
-  static ClonablePtr<StyleRule> Create(ClonablePtr<Condition> condition,
-                                       ClonablePtr<Styler> styler,
+  static ClonePtr<StyleRule> Create(ClonePtr<Condition> condition,
+                                       ClonePtr<Styler> styler,
                                        std::string name = {}) {
-    return ClonablePtr<StyleRule>(new StyleRule(
+    return ClonePtr<StyleRule>(new StyleRule(
         std::move(condition), std::move(styler), std::move(name)));
   }
 
-  StyleRule(ClonablePtr<Condition> condition, ClonablePtr<Styler> styler,
+  StyleRule(ClonePtr<Condition> condition, ClonePtr<Styler> styler,
             std::string name = {});
 
  public:
@@ -26,12 +26,12 @@ class CRU_UI_API StyleRule {
   Condition* GetCondition() const { return condition_.get(); }
   Styler* GetStyler() const { return styler_.get(); }
 
-  StyleRule WithNewCondition(ClonablePtr<Condition> condition,
+  StyleRule WithNewCondition(ClonePtr<Condition> condition,
                              std::string name = {}) const {
     return StyleRule{std::move(condition), styler_, std::move(name)};
   }
 
-  StyleRule WithNewStyler(ClonablePtr<Styler> styler,
+  StyleRule WithNewStyler(ClonePtr<Styler> styler,
                           std::string name = {}) const {
     return StyleRule{condition_, std::move(styler), std::move(name)};
   }
@@ -39,8 +39,8 @@ class CRU_UI_API StyleRule {
   bool CheckAndApply(controls::Control* control) const;
 
  private:
-  ClonablePtr<Condition> condition_;
-  ClonablePtr<Styler> styler_;
+  ClonePtr<Condition> condition_;
+  ClonePtr<Styler> styler_;
   std::string name_;
 };
 }  // namespace cru::ui::style
diff --git a/include/cru/ui/style/Styler.h b/include/cru/ui/style/Styler.h
index 3ed85e1e..0e21945d 100644
--- a/include/cru/ui/style/Styler.h
+++ b/include/cru/ui/style/Styler.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "../Base.h"
 #include "ApplyBorderStyleInfo.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/platform/graphics/Brush.h"
 #include "cru/platform/gui/Cursor.h"
 #include "cru/ui/render/MeasureRequirement.h"
@@ -12,7 +12,7 @@
 namespace cru::ui::style {
 /**
  * \brief The base class for all styler implementations.
- * \remarks Styler should be immutable. And we use cru::ClonablePtr to wrap it
+ * \remarks Styler should be immutable. And we use cru::ClonePtr to wrap it
  * in order to get both polymorphic and value semantics.
  */
 class CRU_UI_API Styler : public Object {
@@ -25,17 +25,17 @@ class CRU_UI_API Styler : public Object {
 class CRU_UI_API CompoundStyler : public Styler {
  public:
   template <typename... S>
-  static ClonablePtr<CompoundStyler> Create(ClonablePtr<S>... s) {
-    return ClonablePtr<CompoundStyler>(
-        new CompoundStyler(std::vector<ClonablePtr<Styler>>{std::move(s)...}));
+  static ClonePtr<CompoundStyler> Create(ClonePtr<S>... s) {
+    return ClonePtr<CompoundStyler>(
+        new CompoundStyler(std::vector<ClonePtr<Styler>>{std::move(s)...}));
   }
 
-  static ClonablePtr<CompoundStyler> Create(
-      std::vector<ClonablePtr<Styler>> stylers) {
-    return ClonablePtr<CompoundStyler>(new CompoundStyler(std::move(stylers)));
+  static ClonePtr<CompoundStyler> Create(
+      std::vector<ClonePtr<Styler>> stylers) {
+    return ClonePtr<CompoundStyler>(new CompoundStyler(std::move(stylers)));
   }
 
-  explicit CompoundStyler(std::vector<ClonablePtr<Styler>> stylers)
+  explicit CompoundStyler(std::vector<ClonePtr<Styler>> stylers)
       : stylers_(std::move(stylers)) {}
 
   void Apply(controls::Control* control) const override {
@@ -44,24 +44,24 @@ class CRU_UI_API CompoundStyler : public Styler {
     }
   }
 
-  std::vector<ClonablePtr<Styler>> GetChildren() const { return stylers_; }
+  std::vector<ClonePtr<Styler>> GetChildren() const { return stylers_; }
 
   virtual CompoundStyler* Clone() const override {
     return new CompoundStyler(stylers_);
   }
 
  private:
-  std::vector<ClonablePtr<Styler>> stylers_;
+  std::vector<ClonePtr<Styler>> stylers_;
 };
 
 class CRU_UI_API BorderStyler : public Styler {
  public:
-  static ClonablePtr<BorderStyler> Create() {
-    return ClonablePtr<BorderStyler>(new BorderStyler());
+  static ClonePtr<BorderStyler> Create() {
+    return ClonePtr<BorderStyler>(new BorderStyler());
   }
 
-  static ClonablePtr<BorderStyler> Create(ApplyBorderStyleInfo style) {
-    return ClonablePtr<BorderStyler>(new BorderStyler(std::move(style)));
+  static ClonePtr<BorderStyler> Create(ApplyBorderStyleInfo style) {
+    return ClonePtr<BorderStyler>(new BorderStyler(std::move(style)));
   }
 
   BorderStyler() = default;
@@ -79,12 +79,12 @@ class CRU_UI_API BorderStyler : public Styler {
 
 class CRU_UI_API CursorStyler : public Styler {
  public:
-  static ClonablePtr<CursorStyler> Create(
+  static ClonePtr<CursorStyler> Create(
       std::shared_ptr<platform::gui::ICursor> cursor) {
-    return ClonablePtr<CursorStyler>(new CursorStyler(std::move(cursor)));
+    return ClonePtr<CursorStyler>(new CursorStyler(std::move(cursor)));
   }
 
-  static ClonablePtr<CursorStyler> Create(platform::gui::SystemCursorType type);
+  static ClonePtr<CursorStyler> Create(platform::gui::SystemCursorType type);
 
   explicit CursorStyler(std::shared_ptr<platform::gui::ICursor> cursor)
       : cursor_(std::move(cursor)) {}
@@ -101,8 +101,8 @@ class CRU_UI_API CursorStyler : public Styler {
 
 class CRU_UI_API PreferredSizeStyler : public Styler {
  public:
-  static ClonablePtr<PreferredSizeStyler> Create(render::MeasureSize size) {
-    return ClonablePtr<PreferredSizeStyler>(new PreferredSizeStyler(size));
+  static ClonePtr<PreferredSizeStyler> Create(render::MeasureSize size) {
+    return ClonePtr<PreferredSizeStyler>(new PreferredSizeStyler(size));
   }
 
   explicit PreferredSizeStyler(render::MeasureSize size) : size_(size) {}
@@ -121,8 +121,8 @@ class CRU_UI_API PreferredSizeStyler : public Styler {
 
 class CRU_UI_API MarginStyler : public Styler {
  public:
-  static ClonablePtr<MarginStyler> Create(const Thickness& margin) {
-    return ClonablePtr<MarginStyler>(new MarginStyler(margin));
+  static ClonePtr<MarginStyler> Create(const Thickness& margin) {
+    return ClonePtr<MarginStyler>(new MarginStyler(margin));
   }
 
   explicit MarginStyler(const Thickness& margin) : margin_(margin) {}
@@ -139,8 +139,8 @@ class CRU_UI_API MarginStyler : public Styler {
 
 class CRU_UI_API PaddingStyler : public Styler {
  public:
-  static ClonablePtr<PaddingStyler> Create(const Thickness& padding) {
-    return ClonablePtr<PaddingStyler>(new PaddingStyler(padding));
+  static ClonePtr<PaddingStyler> Create(const Thickness& padding) {
+    return ClonePtr<PaddingStyler>(new PaddingStyler(padding));
   }
 
   explicit PaddingStyler(const Thickness& padding) : padding_(padding) {}
@@ -157,9 +157,9 @@ class CRU_UI_API PaddingStyler : public Styler {
 
 class CRU_UI_API ContentBrushStyler : public Styler {
  public:
-  static ClonablePtr<ContentBrushStyler> Create(
+  static ClonePtr<ContentBrushStyler> Create(
       std::shared_ptr<platform::graphics::IBrush> brush) {
-    return ClonablePtr<ContentBrushStyler>(
+    return ClonePtr<ContentBrushStyler>(
         new ContentBrushStyler(std::move(brush)));
   }
 
@@ -182,9 +182,9 @@ class CRU_UI_API ContentBrushStyler : public Styler {
 
 class CRU_UI_API FontStyler : public Styler {
  public:
-  static ClonablePtr<FontStyler> Create(
+  static ClonePtr<FontStyler> Create(
       std::shared_ptr<platform::graphics::IFont> font) {
-    return ClonablePtr<FontStyler>(new FontStyler(std::move(font)));
+    return ClonePtr<FontStyler>(new FontStyler(std::move(font)));
   }
 
   explicit FontStyler(std::shared_ptr<platform::graphics::IFont> font)
diff --git a/src/ThemeBuilder/components/conditions/CheckedConditionEditor.cpp b/src/ThemeBuilder/components/conditions/CheckedConditionEditor.cpp
index 04f2ed29..e207c761 100644
--- a/src/ThemeBuilder/components/conditions/CheckedConditionEditor.cpp
+++ b/src/ThemeBuilder/components/conditions/CheckedConditionEditor.cpp
@@ -1,5 +1,5 @@
 #include "CheckedConditionEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/style/Condition.h"
 
 namespace cru::theme_builder::components::conditions {
@@ -14,7 +14,7 @@ CheckedConditionEditor::CheckedConditionEditor() {
 
 CheckedConditionEditor::~CheckedConditionEditor() {}
 
-ClonablePtr<ui::style::CheckedCondition> CheckedConditionEditor::GetValue()
+ClonePtr<ui::style::CheckedCondition> CheckedConditionEditor::GetValue()
     const {
   return ui::style::CheckedCondition::Create(checked_check_box_.GetValue());
 }
diff --git a/src/ThemeBuilder/components/conditions/CheckedConditionEditor.h b/src/ThemeBuilder/components/conditions/CheckedConditionEditor.h
index b6e740f1..c83a1cff 100644
--- a/src/ThemeBuilder/components/conditions/CheckedConditionEditor.h
+++ b/src/ThemeBuilder/components/conditions/CheckedConditionEditor.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "../properties/CheckBoxPropertyEditor.h"
 #include "ConditionEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/style/Condition.h"
 
 namespace cru::theme_builder::components::conditions {
@@ -11,14 +11,14 @@ class CheckedConditionEditor : public ConditionEditor {
   ~CheckedConditionEditor() override;
 
  public:
-  ClonablePtr<ui::style::CheckedCondition> GetValue() const;
+  ClonePtr<ui::style::CheckedCondition> GetValue() const;
   void SetValue(ui::style::CheckedCondition* value, bool trigger_change = true);
-  void SetValue(const ClonablePtr<ui::style::CheckedCondition>& value,
+  void SetValue(const ClonePtr<ui::style::CheckedCondition>& value,
                 bool trigger_change = true) {
     SetValue(value.get(), trigger_change);
   }
 
-  ClonablePtr<ui::style::Condition> GetCondition() override {
+  ClonePtr<ui::style::Condition> GetCondition() override {
     return GetValue();
   }
 
diff --git a/src/ThemeBuilder/components/conditions/ClickStateConditionEditor.cpp b/src/ThemeBuilder/components/conditions/ClickStateConditionEditor.cpp
index 57652ef6..24e83a0e 100644
--- a/src/ThemeBuilder/components/conditions/ClickStateConditionEditor.cpp
+++ b/src/ThemeBuilder/components/conditions/ClickStateConditionEditor.cpp
@@ -1,5 +1,5 @@
 #include "ClickStateConditionEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/helper/ClickDetector.h"
 #include "cru/ui/style/Condition.h"
 
@@ -55,7 +55,7 @@ ClickStateConditionEditor::ClickStateConditionEditor() {
 
 ClickStateConditionEditor::~ClickStateConditionEditor() {}
 
-ClonablePtr<ui::style::ClickStateCondition>
+ClonePtr<ui::style::ClickStateCondition>
 ClickStateConditionEditor::GetValue() const {
   return ui::style::ClickStateCondition::Create(
       ConvertIndexToClickState(click_state_select_.GetSelectedIndex()));
diff --git a/src/ThemeBuilder/components/conditions/ClickStateConditionEditor.h b/src/ThemeBuilder/components/conditions/ClickStateConditionEditor.h
index 2ea4fcf4..24d60f7b 100644
--- a/src/ThemeBuilder/components/conditions/ClickStateConditionEditor.h
+++ b/src/ThemeBuilder/components/conditions/ClickStateConditionEditor.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "../properties/SelectPropertyEditor.h"
 #include "ConditionEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/base/Event.h"
 #include "cru/ui/style/Condition.h"
 
@@ -12,15 +12,15 @@ class ClickStateConditionEditor : public ConditionEditor {
   ~ClickStateConditionEditor();
 
  public:
-  ClonablePtr<ui::style::ClickStateCondition> GetValue() const;
+  ClonePtr<ui::style::ClickStateCondition> GetValue() const;
   void SetValue(ui::style::ClickStateCondition* value,
                 bool trigger_change = true);
-  void SetValue(const ClonablePtr<ui::style::ClickStateCondition>& value,
+  void SetValue(const ClonePtr<ui::style::ClickStateCondition>& value,
                 bool trigger_change = true) {
     SetValue(value.get(), trigger_change);
   }
 
-  ClonablePtr<ui::style::Condition> GetCondition() override {
+  ClonePtr<ui::style::Condition> GetCondition() override {
     return GetValue();
   }
 
diff --git a/src/ThemeBuilder/components/conditions/CompoundConditionEditor.cpp b/src/ThemeBuilder/components/conditions/CompoundConditionEditor.cpp
index a641c2df..d01ceca0 100644
--- a/src/ThemeBuilder/components/conditions/CompoundConditionEditor.cpp
+++ b/src/ThemeBuilder/components/conditions/CompoundConditionEditor.cpp
@@ -4,7 +4,7 @@
 #include "ConditionEditor.h"
 #include "FocusConditionEditor.h"
 #include "NoConditionEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/platform/Color.h"
 #include "cru/ui/Base.h"
 #include "cru/ui/ThemeManager.h"
@@ -76,9 +76,9 @@ CompoundConditionEditor::CompoundConditionEditor() {
 
 CompoundConditionEditor::~CompoundConditionEditor() {}
 
-std::vector<ClonablePtr<ui::style::Condition>>
+std::vector<ClonePtr<ui::style::Condition>>
 CompoundConditionEditor::GetChildren() {
-  std::vector<ClonablePtr<ui::style::Condition>> children;
+  std::vector<ClonePtr<ui::style::Condition>> children;
   for (auto& child : children_) {
     children.push_back(child->GetCondition());
   }
@@ -86,7 +86,7 @@ CompoundConditionEditor::GetChildren() {
 }
 
 void CompoundConditionEditor::SetChildren(
-    std::vector<ClonablePtr<ui::style::Condition>> children,
+    std::vector<ClonePtr<ui::style::Condition>> children,
     bool trigger_change) {
   children_container_.ClearChildren();
   children_.clear();
diff --git a/src/ThemeBuilder/components/conditions/CompoundConditionEditor.h b/src/ThemeBuilder/components/conditions/CompoundConditionEditor.h
index 2948df36..af632758 100644
--- a/src/ThemeBuilder/components/conditions/CompoundConditionEditor.h
+++ b/src/ThemeBuilder/components/conditions/CompoundConditionEditor.h
@@ -1,6 +1,6 @@
 #pragma once
 #include "ConditionEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/base/Event.h"
 #include "cru/ui/components/Component.h"
 #include "cru/ui/components/PopupButton.h"
@@ -16,8 +16,8 @@ class CompoundConditionEditor : public ConditionEditor {
   ~CompoundConditionEditor();
 
  protected:
-  std::vector<ClonablePtr<ui::style::Condition>> GetChildren();
-  void SetChildren(std::vector<ClonablePtr<ui::style::Condition>> children,
+  std::vector<ClonePtr<ui::style::Condition>> GetChildren();
+  void SetChildren(std::vector<ClonePtr<ui::style::Condition>> children,
                    bool trigger_change = true);
 
  private:
@@ -32,18 +32,18 @@ class AndConditionEditor : public CompoundConditionEditor {
   ~AndConditionEditor() override = default;
 
  public:
-  ClonablePtr<ui::style::AndCondition> GetValue() {
+  ClonePtr<ui::style::AndCondition> GetValue() {
     return ui::style::AndCondition::Create(GetChildren());
   }
   void SetValue(ui::style::AndCondition* value, bool trigger_change = true) {
     SetChildren(value->GetChildren(), trigger_change);
   }
-  void SetValue(const ClonablePtr<ui::style::AndCondition>& value,
+  void SetValue(const ClonePtr<ui::style::AndCondition>& value,
                 bool trigger_change = true) {
     SetValue(value.get(), trigger_change);
   }
 
-  ClonablePtr<ui::style::Condition> GetCondition() override {
+  ClonePtr<ui::style::Condition> GetCondition() override {
     return GetValue();
   }
 };
@@ -54,18 +54,18 @@ class OrConditionEditor : public CompoundConditionEditor {
   ~OrConditionEditor() override = default;
 
  public:
-  ClonablePtr<ui::style::OrCondition> GetValue() {
+  ClonePtr<ui::style::OrCondition> GetValue() {
     return ui::style::OrCondition::Create(GetChildren());
   }
   void SetValue(ui::style::OrCondition* value, bool trigger_change = true) {
     SetChildren(value->GetChildren(), trigger_change);
   }
-  void SetValue(const ClonablePtr<ui::style::OrCondition>& value,
+  void SetValue(const ClonePtr<ui::style::OrCondition>& value,
                 bool trigger_change = true) {
     SetValue(value.get(), trigger_change);
   }
 
-  ClonablePtr<ui::style::Condition> GetCondition() override {
+  ClonePtr<ui::style::Condition> GetCondition() override {
     return GetValue();
   }
 };
diff --git a/src/ThemeBuilder/components/conditions/ConditionEditor.h b/src/ThemeBuilder/components/conditions/ConditionEditor.h
index f20132f6..ca632cc0 100644
--- a/src/ThemeBuilder/components/conditions/ConditionEditor.h
+++ b/src/ThemeBuilder/components/conditions/ConditionEditor.h
@@ -9,7 +9,7 @@ class ConditionEditor : public HeadBodyEditor {
   ~ConditionEditor() override;
 
  public:
-  virtual ClonablePtr<ui::style::Condition> GetCondition() = 0;
+  virtual ClonePtr<ui::style::Condition> GetCondition() = 0;
 };
 
 std::unique_ptr<ConditionEditor> CreateConditionEditor(
diff --git a/src/ThemeBuilder/components/conditions/FocusConditionEditor.cpp b/src/ThemeBuilder/components/conditions/FocusConditionEditor.cpp
index 0ac3e224..67a660d1 100644
--- a/src/ThemeBuilder/components/conditions/FocusConditionEditor.cpp
+++ b/src/ThemeBuilder/components/conditions/FocusConditionEditor.cpp
@@ -1,5 +1,5 @@
 #include "FocusConditionEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/style/Condition.h"
 
 namespace cru::theme_builder::components::conditions {
@@ -14,7 +14,7 @@ FocusConditionEditor::FocusConditionEditor() {
 
 FocusConditionEditor::~FocusConditionEditor() {}
 
-ClonablePtr<ui::style::FocusCondition> FocusConditionEditor::GetValue() const {
+ClonePtr<ui::style::FocusCondition> FocusConditionEditor::GetValue() const {
   return ui::style::FocusCondition::Create(focus_check_box_.GetValue());
 }
 
diff --git a/src/ThemeBuilder/components/conditions/FocusConditionEditor.h b/src/ThemeBuilder/components/conditions/FocusConditionEditor.h
index d5478653..c9c8018e 100644
--- a/src/ThemeBuilder/components/conditions/FocusConditionEditor.h
+++ b/src/ThemeBuilder/components/conditions/FocusConditionEditor.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "../properties/CheckBoxPropertyEditor.h"
 #include "ConditionEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/style/Condition.h"
 
 namespace cru::theme_builder::components::conditions {
@@ -11,14 +11,14 @@ class FocusConditionEditor : public ConditionEditor {
   ~FocusConditionEditor() override;
 
  public:
-  ClonablePtr<ui::style::FocusCondition> GetValue() const;
+  ClonePtr<ui::style::FocusCondition> GetValue() const;
   void SetValue(ui::style::FocusCondition* value, bool trigger_change = true);
-  void SetValue(const ClonablePtr<ui::style::FocusCondition>& value,
+  void SetValue(const ClonePtr<ui::style::FocusCondition>& value,
                 bool trigger_change = true) {
     SetValue(value.get(), trigger_change);
   }
 
-  ClonablePtr<ui::style::Condition> GetCondition() override {
+  ClonePtr<ui::style::Condition> GetCondition() override {
     return GetValue();
   }
 
diff --git a/src/ThemeBuilder/components/conditions/NoConditionEditor.h b/src/ThemeBuilder/components/conditions/NoConditionEditor.h
index b38806b5..1cb50947 100644
--- a/src/ThemeBuilder/components/conditions/NoConditionEditor.h
+++ b/src/ThemeBuilder/components/conditions/NoConditionEditor.h
@@ -1,6 +1,6 @@
 #pragma once
 #include "ConditionEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/style/Condition.h"
 
 namespace cru::theme_builder::components::conditions {
@@ -10,7 +10,7 @@ class NoConditionEditor : public ConditionEditor {
   ~NoConditionEditor() override;
 
  public:
-  ClonablePtr<ui::style::Condition> GetCondition() override {
+  ClonePtr<ui::style::Condition> GetCondition() override {
     return ui::style::NoCondition::Create();
   }
 };
diff --git a/src/ThemeBuilder/components/stylers/BorderStylerEditor.cpp b/src/ThemeBuilder/components/stylers/BorderStylerEditor.cpp
index c44b4723..74ce83ec 100644
--- a/src/ThemeBuilder/components/stylers/BorderStylerEditor.cpp
+++ b/src/ThemeBuilder/components/stylers/BorderStylerEditor.cpp
@@ -1,5 +1,5 @@
 #include "BorderStylerEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/platform/graphics/Brush.h"
 #include "cru/platform/graphics/Factory.h"
 #include "cru/platform/gui/UiApplication.h"
@@ -29,7 +29,7 @@ BorderStylerEditor::BorderStylerEditor() {
 
 BorderStylerEditor::~BorderStylerEditor() {}
 
-ClonablePtr<ui::style::BorderStyler> BorderStylerEditor::GetValue() {
+ClonePtr<ui::style::BorderStyler> BorderStylerEditor::GetValue() {
   auto graphics_factory =
       platform::gui::IUiApplication::GetInstance()->GetGraphicsFactory();
 
diff --git a/src/ThemeBuilder/components/stylers/BorderStylerEditor.h b/src/ThemeBuilder/components/stylers/BorderStylerEditor.h
index c9435ee9..ea92a8d4 100644
--- a/src/ThemeBuilder/components/stylers/BorderStylerEditor.h
+++ b/src/ThemeBuilder/components/stylers/BorderStylerEditor.h
@@ -4,7 +4,7 @@
 #include "../properties/OptionalPropertyEditor.h"
 #include "../properties/ThicknessPropertyEditor.h"
 #include "StylerEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 
 namespace cru::theme_builder::components::stylers {
 class BorderStylerEditor : public StylerEditor {
@@ -12,14 +12,14 @@ class BorderStylerEditor : public StylerEditor {
   BorderStylerEditor();
   ~BorderStylerEditor() override;
 
-  ClonablePtr<ui::style::BorderStyler> GetValue();
+  ClonePtr<ui::style::BorderStyler> GetValue();
   void SetValue(ui::style::BorderStyler* styler, bool trigger_change = true);
-  void SetValue(const ClonablePtr<ui::style::BorderStyler>& styler,
+  void SetValue(const ClonePtr<ui::style::BorderStyler>& styler,
                 bool trigger_change = true) {
     SetValue(styler.get(), trigger_change);
   }
 
-  ClonablePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
+  ClonePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
 
  private:
   properties::OptionalPropertyEditor<properties::CornerRadiusPropertyEditor>
diff --git a/src/ThemeBuilder/components/stylers/CompoundStylerEditor.cpp b/src/ThemeBuilder/components/stylers/CompoundStylerEditor.cpp
index af22217b..15f4e912 100644
--- a/src/ThemeBuilder/components/stylers/CompoundStylerEditor.cpp
+++ b/src/ThemeBuilder/components/stylers/CompoundStylerEditor.cpp
@@ -6,7 +6,7 @@
 #include "MarginStylerEditor.h"
 #include "PaddingStylerEditor.h"
 #include "PreferredSizeStylerEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/ThemeManager.h"
 #include "cru/ui/style/Styler.h"
 
@@ -78,8 +78,8 @@ CompoundStylerEditor::CompoundStylerEditor() {
 
 CompoundStylerEditor::~CompoundStylerEditor() {}
 
-ClonablePtr<ui::style::CompoundStyler> CompoundStylerEditor::GetValue() {
-  std::vector<ClonablePtr<ui::style::Styler>> children_styler;
+ClonePtr<ui::style::CompoundStyler> CompoundStylerEditor::GetValue() {
+  std::vector<ClonePtr<ui::style::Styler>> children_styler;
   for (auto& child : children_) {
     children_styler.push_back(child->GetStyler());
   }
diff --git a/src/ThemeBuilder/components/stylers/CompoundStylerEditor.h b/src/ThemeBuilder/components/stylers/CompoundStylerEditor.h
index 91d2bff5..f9265fbf 100644
--- a/src/ThemeBuilder/components/stylers/CompoundStylerEditor.h
+++ b/src/ThemeBuilder/components/stylers/CompoundStylerEditor.h
@@ -1,6 +1,6 @@
 #pragma once
 #include "StylerEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/DeleteLater.h"
 #include "cru/ui/components/PopupButton.h"
 #include "cru/ui/controls/FlexLayout.h"
@@ -13,14 +13,14 @@ class CompoundStylerEditor : public StylerEditor {
   ~CompoundStylerEditor() override;
 
  public:
-  ClonablePtr<ui::style::CompoundStyler> GetValue();
+  ClonePtr<ui::style::CompoundStyler> GetValue();
   void SetValue(ui::style::CompoundStyler* styler, bool trigger_change = true);
-  void SetValue(const ClonablePtr<ui::style::CompoundStyler>& styler,
+  void SetValue(const ClonePtr<ui::style::CompoundStyler>& styler,
                 bool trigger_change = true) {
     SetValue(styler.get(), trigger_change);
   }
 
-  ClonablePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
+  ClonePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
 
  private:
   ui::controls::FlexLayout children_container_;
diff --git a/src/ThemeBuilder/components/stylers/ContentBrushStylerEditor.cpp b/src/ThemeBuilder/components/stylers/ContentBrushStylerEditor.cpp
index bd649c67..00b40d10 100644
--- a/src/ThemeBuilder/components/stylers/ContentBrushStylerEditor.cpp
+++ b/src/ThemeBuilder/components/stylers/ContentBrushStylerEditor.cpp
@@ -12,7 +12,7 @@ ContentBrushStylerEditor::ContentBrushStylerEditor() {
 
 ContentBrushStylerEditor::~ContentBrushStylerEditor() {}
 
-ClonablePtr<ui::style::ContentBrushStyler> ContentBrushStylerEditor::GetValue()
+ClonePtr<ui::style::ContentBrushStyler> ContentBrushStylerEditor::GetValue()
     const {
   return ui::style::ContentBrushStyler::Create(
       platform::gui::IUiApplication::GetInstance()
diff --git a/src/ThemeBuilder/components/stylers/ContentBrushStylerEditor.h b/src/ThemeBuilder/components/stylers/ContentBrushStylerEditor.h
index ec51c041..91e8adc2 100644
--- a/src/ThemeBuilder/components/stylers/ContentBrushStylerEditor.h
+++ b/src/ThemeBuilder/components/stylers/ContentBrushStylerEditor.h
@@ -2,7 +2,7 @@
 #include "../Editor.h"
 #include "../properties/ColorPropertyEditor.h"
 #include "StylerEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/style/Styler.h"
 
 namespace cru::theme_builder::components::stylers {
@@ -12,11 +12,11 @@ class ContentBrushStylerEditor : public StylerEditor {
   ~ContentBrushStylerEditor();
 
  public:
-  ClonablePtr<ui::style::ContentBrushStyler> GetValue() const;
+  ClonePtr<ui::style::ContentBrushStyler> GetValue() const;
   void SetValue(ui::style::ContentBrushStyler* value,
                 bool trigger_change = true);
 
-  ClonablePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
+  ClonePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
 
  private:
   properties::ColorPropertyEditor color_editor_;
diff --git a/src/ThemeBuilder/components/stylers/CursorStylerEditor.cpp b/src/ThemeBuilder/components/stylers/CursorStylerEditor.cpp
index 71de739a..589efc2b 100644
--- a/src/ThemeBuilder/components/stylers/CursorStylerEditor.cpp
+++ b/src/ThemeBuilder/components/stylers/CursorStylerEditor.cpp
@@ -16,7 +16,7 @@ CursorStylerEditor::CursorStylerEditor() {
 
 CursorStylerEditor::~CursorStylerEditor() {}
 
-ClonablePtr<ui::style::CursorStyler> CursorStylerEditor::GetValue() {
+ClonePtr<ui::style::CursorStyler> CursorStylerEditor::GetValue() {
   auto cursor_manager =
       platform::gui::IUiApplication::GetInstance()->GetCursorManager();
 
diff --git a/src/ThemeBuilder/components/stylers/CursorStylerEditor.h b/src/ThemeBuilder/components/stylers/CursorStylerEditor.h
index 552619a0..a40c8aa9 100644
--- a/src/ThemeBuilder/components/stylers/CursorStylerEditor.h
+++ b/src/ThemeBuilder/components/stylers/CursorStylerEditor.h
@@ -9,14 +9,14 @@ class CursorStylerEditor : public StylerEditor {
   ~CursorStylerEditor() override;
 
  public:
-  ClonablePtr<ui::style::CursorStyler> GetValue();
+  ClonePtr<ui::style::CursorStyler> GetValue();
   void SetValue(ui::style::CursorStyler* styler, bool trigger_change = true);
-  void SetValue(const ClonablePtr<ui::style::CursorStyler>& styler,
+  void SetValue(const ClonePtr<ui::style::CursorStyler>& styler,
                 bool trigger_change = true) {
     SetValue(styler.get(), trigger_change);
   }
 
-  ClonablePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
+  ClonePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
 
  private:
   properties::SelectPropertyEditor cursor_select_;
diff --git a/src/ThemeBuilder/components/stylers/FontStylerEditor.cpp b/src/ThemeBuilder/components/stylers/FontStylerEditor.cpp
index 9787a4fd..c8687e6d 100644
--- a/src/ThemeBuilder/components/stylers/FontStylerEditor.cpp
+++ b/src/ThemeBuilder/components/stylers/FontStylerEditor.cpp
@@ -12,7 +12,7 @@ FontStylerEditor::FontStylerEditor() {
 
 FontStylerEditor::~FontStylerEditor() {}
 
-ClonablePtr<ui::style::FontStyler> FontStylerEditor::GetValue() const {
+ClonePtr<ui::style::FontStyler> FontStylerEditor::GetValue() const {
   return ui::style::FontStyler::Create(font_editor_.GetValue());
 }
 
diff --git a/src/ThemeBuilder/components/stylers/FontStylerEditor.h b/src/ThemeBuilder/components/stylers/FontStylerEditor.h
index 847b0e2a..a5145e31 100644
--- a/src/ThemeBuilder/components/stylers/FontStylerEditor.h
+++ b/src/ThemeBuilder/components/stylers/FontStylerEditor.h
@@ -2,7 +2,7 @@
 #include "../Editor.h"
 #include "../properties/FontPropertyEditor.h"
 #include "StylerEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/style/Styler.h"
 
 namespace cru::theme_builder::components::stylers {
@@ -12,10 +12,10 @@ class FontStylerEditor : public StylerEditor {
   ~FontStylerEditor();
 
  public:
-  ClonablePtr<ui::style::FontStyler> GetValue() const;
+  ClonePtr<ui::style::FontStyler> GetValue() const;
   void SetValue(ui::style::FontStyler* value, bool trigger_change = true);
 
-  ClonablePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
+  ClonePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
 
  private:
   properties::FontPropertyEditor font_editor_;
diff --git a/src/ThemeBuilder/components/stylers/MarginStylerEditor.cpp b/src/ThemeBuilder/components/stylers/MarginStylerEditor.cpp
index c750e9b6..bfd15903 100644
--- a/src/ThemeBuilder/components/stylers/MarginStylerEditor.cpp
+++ b/src/ThemeBuilder/components/stylers/MarginStylerEditor.cpp
@@ -13,7 +13,7 @@ MarginStylerEditor::MarginStylerEditor() {
 
 MarginStylerEditor::~MarginStylerEditor() {}
 
-ClonablePtr<ui::style::MarginStyler> MarginStylerEditor::GetValue() {
+ClonePtr<ui::style::MarginStyler> MarginStylerEditor::GetValue() {
   return ui::style::MarginStyler::Create(thickness_editor_.GetValue());
 }
 
diff --git a/src/ThemeBuilder/components/stylers/MarginStylerEditor.h b/src/ThemeBuilder/components/stylers/MarginStylerEditor.h
index 9a1ca750..e27bf61e 100644
--- a/src/ThemeBuilder/components/stylers/MarginStylerEditor.h
+++ b/src/ThemeBuilder/components/stylers/MarginStylerEditor.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "../properties/ThicknessPropertyEditor.h"
 #include "StylerEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/style/Styler.h"
 
 namespace cru::theme_builder::components::stylers {
@@ -10,14 +10,14 @@ class MarginStylerEditor : public StylerEditor {
   MarginStylerEditor();
   ~MarginStylerEditor() override;
 
-  ClonablePtr<ui::style::MarginStyler> GetValue();
+  ClonePtr<ui::style::MarginStyler> GetValue();
   void SetValue(ui::style::MarginStyler* styler, bool trigger_change = true);
-  void SetValue(const ClonablePtr<ui::style::MarginStyler>& styler,
+  void SetValue(const ClonePtr<ui::style::MarginStyler>& styler,
                 bool trigger_change = true) {
     SetValue(styler.get(), trigger_change);
   }
 
-  ClonablePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
+  ClonePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
 
  private:
   properties::ThicknessPropertyEditor thickness_editor_;
diff --git a/src/ThemeBuilder/components/stylers/PaddingStylerEditor.cpp b/src/ThemeBuilder/components/stylers/PaddingStylerEditor.cpp
index 5cf9d3d8..1ad6cf35 100644
--- a/src/ThemeBuilder/components/stylers/PaddingStylerEditor.cpp
+++ b/src/ThemeBuilder/components/stylers/PaddingStylerEditor.cpp
@@ -13,7 +13,7 @@ PaddingStylerEditor::PaddingStylerEditor() {
 
 PaddingStylerEditor::~PaddingStylerEditor() {}
 
-ClonablePtr<ui::style::PaddingStyler> PaddingStylerEditor::GetValue() {
+ClonePtr<ui::style::PaddingStyler> PaddingStylerEditor::GetValue() {
   return ui::style::PaddingStyler::Create(thickness_editor_.GetValue());
 }
 
diff --git a/src/ThemeBuilder/components/stylers/PaddingStylerEditor.h b/src/ThemeBuilder/components/stylers/PaddingStylerEditor.h
index 69565cad..e11918f8 100644
--- a/src/ThemeBuilder/components/stylers/PaddingStylerEditor.h
+++ b/src/ThemeBuilder/components/stylers/PaddingStylerEditor.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "../properties/ThicknessPropertyEditor.h"
 #include "StylerEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/style/Styler.h"
 
 namespace cru::theme_builder::components::stylers {
@@ -10,14 +10,14 @@ class PaddingStylerEditor : public StylerEditor {
   PaddingStylerEditor();
   ~PaddingStylerEditor() override;
 
-  ClonablePtr<ui::style::PaddingStyler> GetValue();
+  ClonePtr<ui::style::PaddingStyler> GetValue();
   void SetValue(ui::style::PaddingStyler* styler, bool trigger_change = true);
-  void SetValue(const ClonablePtr<ui::style::PaddingStyler>& styler,
+  void SetValue(const ClonePtr<ui::style::PaddingStyler>& styler,
                 bool trigger_change = true) {
     SetValue(styler.get(), trigger_change);
   }
 
-  ClonablePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
+  ClonePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
 
  private:
   properties::ThicknessPropertyEditor thickness_editor_;
diff --git a/src/ThemeBuilder/components/stylers/PreferredSizeStylerEditor.cpp b/src/ThemeBuilder/components/stylers/PreferredSizeStylerEditor.cpp
index f0e700a1..8c7c751f 100644
--- a/src/ThemeBuilder/components/stylers/PreferredSizeStylerEditor.cpp
+++ b/src/ThemeBuilder/components/stylers/PreferredSizeStylerEditor.cpp
@@ -16,7 +16,7 @@ PreferredSizeStylerEditor::PreferredSizeStylerEditor() {
 
 PreferredSizeStylerEditor::~PreferredSizeStylerEditor() {}
 
-ClonablePtr<ui::style::PreferredSizeStyler>
+ClonePtr<ui::style::PreferredSizeStyler>
 PreferredSizeStylerEditor::GetValue() {
   return ui::style::PreferredSizeStyler::Create(ui::render::MeasureSize{
       width_editor_.GetValue(), height_editor_.GetValue()});
diff --git a/src/ThemeBuilder/components/stylers/PreferredSizeStylerEditor.h b/src/ThemeBuilder/components/stylers/PreferredSizeStylerEditor.h
index 36fdc3d6..2c83b533 100644
--- a/src/ThemeBuilder/components/stylers/PreferredSizeStylerEditor.h
+++ b/src/ThemeBuilder/components/stylers/PreferredSizeStylerEditor.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "../properties/MeasureLengthPropertyEditor.h"
 #include "StylerEditor.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/style/Styler.h"
 
 namespace cru::theme_builder::components::stylers {
@@ -10,15 +10,15 @@ class PreferredSizeStylerEditor : public StylerEditor {
   PreferredSizeStylerEditor();
   ~PreferredSizeStylerEditor() override;
 
-  ClonablePtr<ui::style::PreferredSizeStyler> GetValue();
+  ClonePtr<ui::style::PreferredSizeStyler> GetValue();
   void SetValue(ui::style::PreferredSizeStyler* styler,
                 bool trigger_change = true);
-  void SetValue(const ClonablePtr<ui::style::PreferredSizeStyler>& styler,
+  void SetValue(const ClonePtr<ui::style::PreferredSizeStyler>& styler,
                 bool trigger_change = true) {
     SetValue(styler.get(), trigger_change);
   }
 
-  ClonablePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
+  ClonePtr<ui::style::Styler> GetStyler() override { return GetValue(); }
 
  private:
   properties::MeasureLengthPropertyEditor width_editor_;
diff --git a/src/ThemeBuilder/components/stylers/StylerEditor.h b/src/ThemeBuilder/components/stylers/StylerEditor.h
index 8aa52bda..8bd6af48 100644
--- a/src/ThemeBuilder/components/stylers/StylerEditor.h
+++ b/src/ThemeBuilder/components/stylers/StylerEditor.h
@@ -9,7 +9,7 @@ class StylerEditor : public HeadBodyEditor {
   ~StylerEditor() override;
 
  public:
-  virtual ClonablePtr<ui::style::Styler> GetStyler() = 0;
+  virtual ClonePtr<ui::style::Styler> GetStyler() = 0;
 };
 
 std::unique_ptr<StylerEditor> CreateStylerEditor(ui::style::Styler* styler);
diff --git a/src/ui/mapper/FontMapper.cpp b/src/ui/mapper/FontMapper.cpp
index ebf7c27c..6ba37964 100644
--- a/src/ui/mapper/FontMapper.cpp
+++ b/src/ui/mapper/FontMapper.cpp
@@ -16,7 +16,7 @@ std::shared_ptr<platform::graphics::IFont> FontMapper::DoMapFromXml(
   auto font_family = font_family_attr.value_or("");
   auto font_size =
       font_size_attr ? cru::string::ParseToNumber<float>(*font_size_attr).value
-                     : 24.0f;
+                     : 16.0f;
 
   return GetGraphicsFactory()->CreateFont(font_family, font_size);
 }
diff --git a/src/ui/mapper/style/AndConditionMapper.cpp b/src/ui/mapper/style/AndConditionMapper.cpp
index 0b1fc008..ad996a4e 100644
--- a/src/ui/mapper/style/AndConditionMapper.cpp
+++ b/src/ui/mapper/style/AndConditionMapper.cpp
@@ -1,5 +1,5 @@
 #include "cru/ui/mapper/style/AndConditionMapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/mapper/MapperRegistry.h"
 #include "cru/ui/mapper/style/IConditionMapper.h"
 #include "cru/ui/style/Condition.h"
@@ -10,9 +10,9 @@ bool AndConditionMapper::XmlElementIsOfThisType(xml::XmlElementNode *node) {
   return cru::string::CaseInsensitiveCompare(node->GetTag(), "AndCondition") == 0;
 }
 
-ClonablePtr<ui::style::AndCondition> AndConditionMapper::DoMapFromXml(
+ClonePtr<ui::style::AndCondition> AndConditionMapper::DoMapFromXml(
     xml::XmlElementNode *node) {
-  std::vector<ClonablePtr<ui::style::Condition>> conditions;
+  std::vector<ClonePtr<ui::style::Condition>> conditions;
   auto condition_mappers =
       MapperRegistry::GetInstance()->GetMappersByInterface<IConditionMapper>();
   for (auto child : node->GetChildren()) {
diff --git a/src/ui/mapper/style/BorderStylerMapper.cpp b/src/ui/mapper/style/BorderStylerMapper.cpp
index 3deeed43..33358b28 100644
--- a/src/ui/mapper/style/BorderStylerMapper.cpp
+++ b/src/ui/mapper/style/BorderStylerMapper.cpp
@@ -1,5 +1,5 @@
 #include "cru/ui/mapper/style/BorderStylerMapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/mapper/MapperRegistry.h"
 #include "cru/ui/style/ApplyBorderStyleInfo.h"
 #include "cru/ui/style/Styler.h"
@@ -13,7 +13,7 @@ bool BorderStylerMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
   return cru::string::CaseInsensitiveCompare(node->GetTag(), "BorderStyler") == 0;
 }
 
-ClonablePtr<BorderStyler> BorderStylerMapper::DoMapFromXml(
+ClonePtr<BorderStyler> BorderStylerMapper::DoMapFromXml(
     xml::XmlElementNode* node) {
   auto border_style_mapper =
       MapperRegistry::GetInstance()->GetMapper<ApplyBorderStyleInfo>();
diff --git a/src/ui/mapper/style/CheckedConditionMapper.cpp b/src/ui/mapper/style/CheckedConditionMapper.cpp
index 2d01b4bf..9e93cbea 100644
--- a/src/ui/mapper/style/CheckedConditionMapper.cpp
+++ b/src/ui/mapper/style/CheckedConditionMapper.cpp
@@ -1,5 +1,5 @@
 #include "cru/ui/mapper/style/CheckedConditionMapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/base/StringUtil.h"
 #include "cru/ui/style/Condition.h"
 #include "cru/base/xml/XmlNode.h"
@@ -10,7 +10,7 @@ bool CheckedConditionMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
                                              "CheckedCondition") == 0;
 }
 
-ClonablePtr<ui::style::CheckedCondition> CheckedConditionMapper::DoMapFromXml(
+ClonePtr<ui::style::CheckedCondition> CheckedConditionMapper::DoMapFromXml(
     xml::XmlElementNode* node) {
   auto value = node->GetAttributeValueCaseInsensitive("value");
   if (cru::string::CaseInsensitiveCompare(value, "true") == 0) {
diff --git a/src/ui/mapper/style/ClickStateConditionMapper.cpp b/src/ui/mapper/style/ClickStateConditionMapper.cpp
index 16ef1209..accfdf0a 100644
--- a/src/ui/mapper/style/ClickStateConditionMapper.cpp
+++ b/src/ui/mapper/style/ClickStateConditionMapper.cpp
@@ -1,5 +1,5 @@
 #include "cru/ui/mapper/style/ClickStateConditionMapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/base/StringUtil.h"
 #include "cru/ui/helper/ClickDetector.h"
 #include "cru/ui/style/Condition.h"
@@ -11,7 +11,7 @@ bool ClickStateConditionMapper::XmlElementIsOfThisType(
                                              "ClickStateCondition") == 0;
 }
 
-ClonablePtr<ui::style::ClickStateCondition>
+ClonePtr<ui::style::ClickStateCondition>
 ClickStateConditionMapper::DoMapFromXml(xml::XmlElementNode *node) {
   auto state = helper::ClickState::None;
   auto value_attr = node->GetOptionalAttributeValueCaseInsensitive("value");
diff --git a/src/ui/mapper/style/ContentBrushStylerMapper.cpp b/src/ui/mapper/style/ContentBrushStylerMapper.cpp
index c5caab02..1ab91be0 100644
--- a/src/ui/mapper/style/ContentBrushStylerMapper.cpp
+++ b/src/ui/mapper/style/ContentBrushStylerMapper.cpp
@@ -1,5 +1,5 @@
 #include "cru/ui/mapper/style/ContentBrushStylerMapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/platform/graphics/Brush.h"
 #include "cru/ui/mapper/MapperRegistry.h"
 #include "cru/ui/style/Styler.h"
@@ -12,7 +12,7 @@ ContentBrushStylerMapper::ContentBrushStylerMapper() {
 
 ContentBrushStylerMapper::~ContentBrushStylerMapper() {}
 
-ClonablePtr<ui::style::ContentBrushStyler>
+ClonePtr<ui::style::ContentBrushStyler>
 ContentBrushStylerMapper::DoMapFromXml(xml::XmlElementNode* node) {
   auto brush_mapper = MapperRegistry::GetInstance()
                           ->GetSharedPtrMapper<platform::graphics::IBrush>();
diff --git a/src/ui/mapper/style/CursorStylerMapper.cpp b/src/ui/mapper/style/CursorStylerMapper.cpp
index c9a75329..e5051ce0 100644
--- a/src/ui/mapper/style/CursorStylerMapper.cpp
+++ b/src/ui/mapper/style/CursorStylerMapper.cpp
@@ -1,5 +1,5 @@
 #include "cru/ui/mapper/style/CursorStylerMapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/platform/gui/Cursor.h"
 #include "cru/ui/mapper/MapperRegistry.h"
 #include "cru/ui/style/Styler.h"
@@ -9,7 +9,7 @@ bool CursorStylerMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
   return cru::string::CaseInsensitiveCompare(node->GetTag(), "CursorStyler") == 0;
 }
 
-ClonablePtr<ui::style::CursorStyler> CursorStylerMapper::DoMapFromXml(
+ClonePtr<ui::style::CursorStyler> CursorStylerMapper::DoMapFromXml(
     xml::XmlElementNode* node) {
   auto cursor_mapper =
       MapperRegistry::GetInstance()->GetSharedPtrMapper<platform::gui::ICursor>();
diff --git a/src/ui/mapper/style/FocusConditionMapper.cpp b/src/ui/mapper/style/FocusConditionMapper.cpp
index 26a5780d..08d0c992 100644
--- a/src/ui/mapper/style/FocusConditionMapper.cpp
+++ b/src/ui/mapper/style/FocusConditionMapper.cpp
@@ -1,5 +1,5 @@
 #include "cru/ui/mapper/style/FocusConditionMapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/base/StringUtil.h"
 #include "cru/ui/style/Condition.h"
 #include "cru/base/xml/XmlNode.h"
@@ -10,7 +10,7 @@ bool FocusConditionMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
                                              "FocusCondition") == 0;
 }
 
-ClonablePtr<ui::style::FocusCondition> FocusConditionMapper::DoMapFromXml(
+ClonePtr<ui::style::FocusCondition> FocusConditionMapper::DoMapFromXml(
     xml::XmlElementNode* node) {
   auto value = node->GetAttributeValueCaseInsensitive("value");
   if (cru::string::CaseInsensitiveCompare(value, "true") == 0) {
diff --git a/src/ui/mapper/style/FontStylerMapper.cpp b/src/ui/mapper/style/FontStylerMapper.cpp
index 1555c071..ac8051a3 100644
--- a/src/ui/mapper/style/FontStylerMapper.cpp
+++ b/src/ui/mapper/style/FontStylerMapper.cpp
@@ -1,5 +1,5 @@
 #include "cru/ui/mapper/style/FontStylerMapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/mapper/MapperRegistry.h"
 
 namespace cru::ui::mapper::style {
@@ -7,7 +7,7 @@ FontStylerMapper::FontStylerMapper() { SetAllowedTags({"FontStyler"}); }
 
 FontStylerMapper::~FontStylerMapper() {}
 
-ClonablePtr<ui::style::FontStyler> FontStylerMapper::DoMapFromXml(
+ClonePtr<ui::style::FontStyler> FontStylerMapper::DoMapFromXml(
     xml::XmlElementNode* node) {
   auto font_mapper = MapperRegistry::GetInstance()
                          ->GetSharedPtrMapper<platform::graphics::IFont>();
diff --git a/src/ui/mapper/style/HoverConditionMapper.cpp b/src/ui/mapper/style/HoverConditionMapper.cpp
index 1a7ffd95..7797ad7c 100644
--- a/src/ui/mapper/style/HoverConditionMapper.cpp
+++ b/src/ui/mapper/style/HoverConditionMapper.cpp
@@ -1,5 +1,5 @@
 #include "cru/ui/mapper/style/HoverConditionMapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/base/StringUtil.h"
 #include "cru/ui/style/Condition.h"
 
@@ -11,7 +11,7 @@ bool HoverConditionMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
                                              "HoverCondition") == 0;
 }
 
-ClonablePtr<HoverCondition> HoverConditionMapper::DoMapFromXml(
+ClonePtr<HoverCondition> HoverConditionMapper::DoMapFromXml(
     xml::XmlElementNode* node) {
   auto value = node->GetAttributeValueCaseInsensitive("value");
   if (cru::string::CaseInsensitiveCompare(value, "true") == 0) {
diff --git a/src/ui/mapper/style/MarginStylerMapper.cpp b/src/ui/mapper/style/MarginStylerMapper.cpp
index ffbdcd75..2343dd3e 100644
--- a/src/ui/mapper/style/MarginStylerMapper.cpp
+++ b/src/ui/mapper/style/MarginStylerMapper.cpp
@@ -8,7 +8,7 @@ MarginStylerMapper::MarginStylerMapper() { SetAllowedTags({"MarginStyler"}); }
 
 MarginStylerMapper::~MarginStylerMapper() {}
 
-ClonablePtr<ui::style::MarginStyler> MarginStylerMapper::DoMapFromXml(
+ClonePtr<ui::style::MarginStyler> MarginStylerMapper::DoMapFromXml(
     xml::XmlElementNode* node) {
   Thickness thickness;
 
diff --git a/src/ui/mapper/style/NoConditionMapper.cpp b/src/ui/mapper/style/NoConditionMapper.cpp
index 84cbf598..3ee9981e 100644
--- a/src/ui/mapper/style/NoConditionMapper.cpp
+++ b/src/ui/mapper/style/NoConditionMapper.cpp
@@ -1,5 +1,5 @@
 #include "cru/ui/mapper/style/NoConditionMapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/base/xml/XmlNode.h"
 
 namespace cru::ui::mapper::style {
@@ -7,7 +7,7 @@ bool NoConditionMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
   return cru::string::CaseInsensitiveCompare(node->GetTag(), "NoCondition") == 0;
 }
 
-ClonablePtr<ui::style::NoCondition> NoConditionMapper::DoMapFromXml(
+ClonePtr<ui::style::NoCondition> NoConditionMapper::DoMapFromXml(
     xml::XmlElementNode* node) {
   return ui::style::NoCondition::Create();
 }
diff --git a/src/ui/mapper/style/OrConditionMapper.cpp b/src/ui/mapper/style/OrConditionMapper.cpp
index 98b4078d..5591bab0 100644
--- a/src/ui/mapper/style/OrConditionMapper.cpp
+++ b/src/ui/mapper/style/OrConditionMapper.cpp
@@ -1,5 +1,5 @@
 #include "cru/ui/mapper/style/OrConditionMapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/mapper/MapperRegistry.h"
 #include "cru/ui/mapper/style/IConditionMapper.h"
 #include "cru/ui/style/Condition.h"
@@ -10,9 +10,9 @@ bool OrConditionMapper::XmlElementIsOfThisType(xml::XmlElementNode *node) {
   return cru::string::CaseInsensitiveCompare(node->GetTag(), "OrCondition") == 0;
 }
 
-ClonablePtr<ui::style::OrCondition> OrConditionMapper::DoMapFromXml(
+ClonePtr<ui::style::OrCondition> OrConditionMapper::DoMapFromXml(
     xml::XmlElementNode *node) {
-  std::vector<ClonablePtr<ui::style::Condition>> conditions;
+  std::vector<ClonePtr<ui::style::Condition>> conditions;
   auto condition_mappers =
       MapperRegistry::GetInstance()->GetMappersByInterface<IConditionMapper>();
   for (auto child : node->GetChildren()) {
diff --git a/src/ui/mapper/style/PaddingStylerMapper.cpp b/src/ui/mapper/style/PaddingStylerMapper.cpp
index faa86082..60c40c3d 100644
--- a/src/ui/mapper/style/PaddingStylerMapper.cpp
+++ b/src/ui/mapper/style/PaddingStylerMapper.cpp
@@ -10,7 +10,7 @@ PaddingStylerMapper::PaddingStylerMapper() {
 
 PaddingStylerMapper::~PaddingStylerMapper() {}
 
-ClonablePtr<ui::style::PaddingStyler> PaddingStylerMapper::DoMapFromXml(
+ClonePtr<ui::style::PaddingStyler> PaddingStylerMapper::DoMapFromXml(
     xml::XmlElementNode* node) {
   Thickness thickness;
 
diff --git a/src/ui/mapper/style/PreferredSizeStylerMapper.cpp b/src/ui/mapper/style/PreferredSizeStylerMapper.cpp
index 2fe71025..0603f5c4 100644
--- a/src/ui/mapper/style/PreferredSizeStylerMapper.cpp
+++ b/src/ui/mapper/style/PreferredSizeStylerMapper.cpp
@@ -9,7 +9,7 @@ bool PreferredSizeStylerMapper::XmlElementIsOfThisType(
   return cru::string::CaseInsensitiveCompare(node->GetTag(), "PreferredSizeStyler") == 0;
 }
 
-ClonablePtr<ui::style::PreferredSizeStyler>
+ClonePtr<ui::style::PreferredSizeStyler>
 PreferredSizeStylerMapper::DoMapFromXml(xml::XmlElementNode* node) {
   render::MeasureSize size;
 
diff --git a/src/ui/mapper/style/StyleRuleMapper.cpp b/src/ui/mapper/style/StyleRuleMapper.cpp
index f14d11da..30fedb16 100644
--- a/src/ui/mapper/style/StyleRuleMapper.cpp
+++ b/src/ui/mapper/style/StyleRuleMapper.cpp
@@ -1,5 +1,5 @@
 #include "cru/ui/mapper/style/StyleRuleMapper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/ui/mapper/MapperRegistry.h"
 #include "cru/ui/mapper/style/IConditionMapper.h"
 #include "cru/ui/mapper/style/IStylerMapper.h"
@@ -13,15 +13,15 @@ bool StyleRuleMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
   return cru::string::CaseInsensitiveCompare(node->GetTag(), "StyleRule") == 0;
 }
 
-ClonablePtr<ui::style::StyleRule> StyleRuleMapper::DoMapFromXml(
+ClonePtr<ui::style::StyleRule> StyleRuleMapper::DoMapFromXml(
     xml::XmlElementNode* node) {
   std::vector<IConditionMapper*> condition_mappers =
       MapperRegistry::GetInstance()->GetMappersByInterface<IConditionMapper>();
   std::vector<IStylerMapper*> styler_mappers =
       MapperRegistry::GetInstance()->GetMappersByInterface<IStylerMapper>();
 
-  std::vector<ClonablePtr<Condition>> conditions;
-  std::vector<ClonablePtr<Styler>> stylers;
+  std::vector<ClonePtr<Condition>> conditions;
+  std::vector<ClonePtr<Styler>> stylers;
 
   for (auto child : node->GetChildren()) {
     if (child->GetType() == xml::XmlNode::Type::Element) {
diff --git a/src/ui/mapper/style/StyleRuleSetMapper.cpp b/src/ui/mapper/style/StyleRuleSetMapper.cpp
index d4bc7c37..19a628ad 100644
--- a/src/ui/mapper/style/StyleRuleSetMapper.cpp
+++ b/src/ui/mapper/style/StyleRuleSetMapper.cpp
@@ -14,7 +14,7 @@ bool StyleRuleSetMapper::XmlElementIsOfThisType(xml::XmlElementNode* node) {
 std::shared_ptr<ui::style::StyleRuleSet> StyleRuleSetMapper::DoMapFromXml(
     xml::XmlElementNode* node) {
   auto style_rule_mapper =
-      MapperRegistry::GetInstance()->GetClonablePtrMapper<StyleRule>();
+      MapperRegistry::GetInstance()->GetClonePtrMapper<StyleRule>();
 
   auto result = std::make_shared<StyleRuleSet>();
 
diff --git a/src/ui/style/Condition.cpp b/src/ui/style/Condition.cpp
index a0de03dc..abe52edb 100644
--- a/src/ui/style/Condition.cpp
+++ b/src/ui/style/Condition.cpp
@@ -1,7 +1,7 @@
 #include "cru/ui/style/Condition.h"
 #include <memory>
 
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/base/Event.h"
 #include "cru/ui/controls/Control.h"
 #include "cru/ui/controls/ICheckableControl.h"
@@ -10,7 +10,7 @@
 
 namespace cru::ui::style {
 CompoundCondition::CompoundCondition(
-    std::vector<ClonablePtr<Condition>> conditions)
+    std::vector<ClonePtr<Condition>> conditions)
     : conditions_(std::move(conditions)) {}
 
 std::vector<IBaseEvent*> CompoundCondition::ChangeOn(
diff --git a/src/ui/style/StyleRule.cpp b/src/ui/style/StyleRule.cpp
index 8b9b0a56..bdd0acf2 100644
--- a/src/ui/style/StyleRule.cpp
+++ b/src/ui/style/StyleRule.cpp
@@ -1,8 +1,8 @@
 #include "cru/ui/style/StyleRule.h"
 
 namespace cru::ui::style {
-StyleRule::StyleRule(ClonablePtr<Condition> condition,
-                     ClonablePtr<Styler> styler, std::string name)
+StyleRule::StyleRule(ClonePtr<Condition> condition,
+                     ClonePtr<Styler> styler, std::string name)
     : condition_(std::move(condition)),
       styler_(std::move(styler)),
       name_(std::move(name)) {}
diff --git a/src/ui/style/Styler.cpp b/src/ui/style/Styler.cpp
index a4e3ac25..8b4405cd 100644
--- a/src/ui/style/Styler.cpp
+++ b/src/ui/style/Styler.cpp
@@ -1,7 +1,7 @@
 #include "cru/ui/style/Styler.h"
 
 #include "../Helper.h"
-#include "cru/base/ClonablePtr.h"
+#include "cru/base/ClonePtr.h"
 #include "cru/platform/gui/Cursor.h"
 #include "cru/platform/gui/UiApplication.h"
 #include "cru/ui/controls/Control.h"
@@ -20,7 +20,7 @@ void BorderStyler::Apply(controls::Control *control) const {
   }
 }
 
-ClonablePtr<CursorStyler> CursorStyler::Create(
+ClonePtr<CursorStyler> CursorStyler::Create(
     platform::gui::SystemCursorType type) {
   return Create(GetUiApplication()->GetCursorManager()->GetSystemCursor(type));
 }