From 4e0b7d82cd64ef8016dcb49247a8a5e4de8a0b3d Mon Sep 17 00:00:00 2001
From: Yuqian Yang <crupest@crupest.life>
Date: Sun, 16 Nov 2025 10:37:36 +0800
Subject: Rename ClonePtr, update theme.

---
 include/cru/base/ClonablePtr.h                     | 216 ---------------------
 include/cru/base/ClonePtr.h                        | 119 ++++++++++++
 include/cru/ui/mapper/Mapper.h                     |   4 +-
 include/cru/ui/mapper/MapperRegistry.h             |   4 +-
 include/cru/ui/mapper/style/AndConditionMapper.h   |   6 +-
 include/cru/ui/mapper/style/BorderStylerMapper.h   |   8 +-
 .../cru/ui/mapper/style/CheckedConditionMapper.h   |   6 +-
 .../ui/mapper/style/ClickStateConditionMapper.h    |   6 +-
 .../cru/ui/mapper/style/ContentBrushStylerMapper.h |   6 +-
 include/cru/ui/mapper/style/CursorStylerMapper.h   |   6 +-
 include/cru/ui/mapper/style/FocusConditionMapper.h |   6 +-
 include/cru/ui/mapper/style/FontStylerMapper.h     |   6 +-
 include/cru/ui/mapper/style/HoverConditionMapper.h |   6 +-
 include/cru/ui/mapper/style/IConditionMapper.h     |   4 +-
 include/cru/ui/mapper/style/IStylerMapper.h        |   4 +-
 include/cru/ui/mapper/style/MarginStylerMapper.h   |   6 +-
 include/cru/ui/mapper/style/NoConditionMapper.h    |   8 +-
 include/cru/ui/mapper/style/OrConditionMapper.h    |   6 +-
 include/cru/ui/mapper/style/PaddingStylerMapper.h  |   6 +-
 .../ui/mapper/style/PreferredSizeStylerMapper.h    |   6 +-
 include/cru/ui/mapper/style/StyleRuleMapper.h      |   6 +-
 include/cru/ui/style/Condition.h                   |  40 ++--
 include/cru/ui/style/StyleRule.h                   |  18 +-
 include/cru/ui/style/Styler.h                      |  56 +++---
 24 files changed, 231 insertions(+), 328 deletions(-)
 delete mode 100644 include/cru/base/ClonablePtr.h
 create mode 100644 include/cru/base/ClonePtr.h

(limited to 'include')

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)
-- 
cgit v1.2.3