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/ui/style/Condition.h | 40 ++++++++++++++--------------
 include/cru/ui/style/StyleRule.h | 18 ++++++-------
 include/cru/ui/style/Styler.h    | 56 ++++++++++++++++++++--------------------
 3 files changed, 57 insertions(+), 57 deletions(-)

(limited to 'include/cru/ui/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