core: rename disposition to Disposition

17 files changed, 106 insertions, 63 deletions

diff --git a/core/include/turns/core/disposition.hpp b/core/include/turns/core/disposition.hpp
index 92a7d03..89a2cb0 100644
--- a/core/include/turns/core/disposition.hpp
+++ b/core/include/turns/core/disposition.hpp
@@ -2,13 +2,15 @@
 #define TURNS_CORE_DISPOSITION_HPP
 
 #include <glibmm/ustring.h>
+#include <glibmm/value.h>
+
+#include <glib-object.h>
 
 #include <cstdint>
 
 namespace turns::core
 {
-
-  enum struct disposition : std::uint8_t
+  enum struct Disposition : std::uint8_t
   {
     neutral,
     friendly,
@@ -19,8 +21,19 @@ namespace turns::core
     END
   };
 
-  auto presentation_name_for(disposition value) -> Glib::ustring;
-
+  auto presentation_name_for(Disposition value) -> Glib::ustring;
 }  // namespace turns::core
 
+namespace Glib
+{
+  template<>
+  class Value<turns::core::Disposition> : public Glib::Value_Enum<turns::core::Disposition>
+  {
+    GType static constinit inline gtype_{};
+
+  public:
+    auto static value_type() -> GType;
+  };
+}  // namespace Glib
+
 #endif
\ No newline at end of file
diff --git a/core/include/turns/core/fwd.hpp b/core/include/turns/core/fwd.hpp
index 612e8c8..48380e3 100644
--- a/core/include/turns/core/fwd.hpp
+++ b/core/include/turns/core/fwd.hpp
@@ -5,7 +5,7 @@
 
 namespace turns::core
 {
-  enum struct disposition : std::uint8_t;
+  enum struct Disposition : std::uint8_t;
 
   struct Participant;
   struct turn_order;
diff --git a/core/include/turns/core/participant.hpp b/core/include/turns/core/participant.hpp
index d2f2035..0edc421 100644
--- a/core/include/turns/core/participant.hpp
+++ b/core/include/turns/core/participant.hpp
@@ -16,21 +16,21 @@ namespace turns::core
 {
   struct Participant : Glib::Object
   {
-    auto static create(Glib::ustring name, float priority, disposition disposition) -> Glib::RefPtr<Participant>;
+    auto static create(Glib::ustring name, float priority, Disposition disposition) -> Glib::RefPtr<Participant>;
     auto static create(nlohmann::json const & serialized) -> Glib::RefPtr<Participant>;
 
     Participant();
-    Participant(Glib::ustring name, float priority, disposition disposition);
+    Participant(Glib::ustring name, float priority, Disposition disposition);
 
     auto operator<=>(Participant const & other) const noexcept -> std::partial_ordering;
 
-    [[nodiscard]] auto get_disposition() const -> disposition;
+    [[nodiscard]] auto get_disposition() const -> Disposition;
     [[nodiscard]] auto get_is_active() const -> bool;
     [[nodiscard]] auto get_is_defeated() const -> bool;
     [[nodiscard]] auto get_name() const -> Glib::ustring;
     [[nodiscard]] auto get_priority() const -> float;
 
-    auto set_disposition(disposition value) -> void;
+    auto set_disposition(Disposition value) -> void;
     auto set_is_active(bool value) -> void;
     auto set_is_defeated(bool value) -> void;
     auto set_name(Glib::ustring const & value) -> void;
@@ -45,7 +45,7 @@ namespace turns::core
     auto serialize() -> nlohmann::json;
 
   private:
-    Glib::Property<core::disposition> m_disposition{*this, "disposition", core::disposition::neutral};
+    Glib::Property<core::Disposition> m_disposition{*this, "disposition", core::Disposition::neutral};
     Glib::Property<bool> m_is_active{*this, "is-active", false};
     Glib::Property<bool> m_is_defeated{*this, "is-defeated", false};
     Glib::Property<Glib::ustring> m_name{*this, "name", ""};
diff --git a/core/include/turns/core/turn_order.hpp b/core/include/turns/core/turn_order.hpp
index 6a0ee43..030f4c9 100644
--- a/core/include/turns/core/turn_order.hpp
+++ b/core/include/turns/core/turn_order.hpp
@@ -57,7 +57,7 @@ namespace turns::core
     auto skip_defeated() -> Glib::PropertyProxy<skip_defeated_type>;
 
     /** Element Modifications */
-    auto add(Glib::ustring const & name, float priority, disposition disposition) -> void;
+    auto add(Glib::ustring const & name, float priority, Disposition disposition) -> void;
     auto clear() -> void;
     auto remove(unsigned index) -> void;
 
diff --git a/core/src/disposition.cpp b/core/src/disposition.cpp
index 81fb410..4a1a496 100644
--- a/core/src/disposition.cpp
+++ b/core/src/disposition.cpp
@@ -3,24 +3,49 @@
 #include <glibmm/i18n.h>
 #include <glibmm/ustring.h>
 
+#include <glib-object.h>
+
+#include <array>
+#include <atomic>
+
 namespace turns::core
 {
 
-  auto presentation_name_for(disposition value) -> Glib::ustring
+  auto presentation_name_for(Disposition value) -> Glib::ustring
   {
     switch (value)
     {
-    case disposition::neutral:
+    case Disposition::neutral:
       return _("Neutral");
-    case disposition::friendly:
+    case Disposition::friendly:
       return _("Friendly");
-    case disposition::hostile:
+    case Disposition::hostile:
       return _("Hostile");
-    case disposition::secret:
+    case Disposition::secret:
       return _("Secret");
     default:
       return _("Unknown disposition value");
     }
   }
 
-}  // namespace turns::core
\ No newline at end of file
+}  // namespace turns::core
+
+namespace Glib
+{
+  auto Value<turns::core::Disposition>::value_type() -> GType
+  {
+    auto static is_initialized = std::atomic_flag{false};
+    auto static const values = std::array{
+        GEnumValue{static_cast<int>(turns::core::Disposition::neutral),  "TURNS_DISPOSITION_NEUTRAL",  "neutral" },
+        GEnumValue{static_cast<int>(turns::core::Disposition::friendly), "TURNS_DISPOSITION_FRIENDLY", "friendly"},
+        GEnumValue{static_cast<int>(turns::core::Disposition::hostile),  "TURNS_DISPOSITION_HOSTILE",  "hostile" },
+        GEnumValue{static_cast<int>(turns::core::Disposition::secret),   "TURNS_DISPOSITION_SECRET",   "secret"  },
+        GEnumValue{0,                                                    nullptr,                      nullptr   },
+    };
+    if (!is_initialized.test_and_set())
+    {
+      gtype_ = g_enum_register_static("TurnsDisposition", values.data());
+    }
+    return gtype_;
+  }
+}  // namespace Glib
\ No newline at end of file
diff --git a/core/src/init.cpp b/core/src/init.cpp
index 3991248..3434f91 100644
--- a/core/src/init.cpp
+++ b/core/src/init.cpp
@@ -1,8 +1,11 @@
 #include "turns/core/init.hpp"
 
+#include "turns/core/disposition.hpp"
 #include "turns/core/participant.hpp"
 #include "turns/core/turn_order.hpp"
 
+#include <glib-object.h>
+
 namespace turns::core
 {
 
@@ -10,6 +13,8 @@ namespace turns::core
   {
     static_cast<void>(Participant{});
     static_cast<void>(turn_order{});
+
+    g_type_ensure(Glib::Value<Disposition>::value_type());
   }
 
 }  // namespace turns::core
\ No newline at end of file
diff --git a/core/src/participant.cpp b/core/src/participant.cpp
index 343d461..242b1b2 100644
--- a/core/src/participant.cpp
+++ b/core/src/participant.cpp
@@ -15,14 +15,14 @@
 
 namespace turns::core
 {
-  auto Participant::create(Glib::ustring name, float priority, core::disposition disposition) -> Glib::RefPtr<Participant>
+  auto Participant::create(Glib::ustring name, float priority, core::Disposition disposition) -> Glib::RefPtr<Participant>
   {
     return Glib::make_refptr_for_instance(new Participant{name, priority, disposition});
   }
 
   auto Participant::create(nlohmann::json const & serialized) -> Glib::RefPtr<Participant>
   {
-    auto disposition = serialized.value("disposition", disposition::neutral);
+    auto disposition = serialized.value("disposition", Disposition::neutral);
     auto priority = serialized.value("priority", 0.0f);
     auto name = serialized.value("name", std::string{});
 
@@ -40,7 +40,7 @@ namespace turns::core
   {
   }
 
-  Participant::Participant(Glib::ustring name, float priority, core::disposition disposition)
+  Participant::Participant(Glib::ustring name, float priority, core::Disposition disposition)
       : Participant()
   {
     m_name = name;
@@ -53,7 +53,7 @@ namespace turns::core
     return m_priority <=> other.m_priority;
   }
 
-  auto Participant::get_disposition() const -> disposition
+  auto Participant::get_disposition() const -> Disposition
   {
     return m_disposition.get_value();
   }
@@ -78,7 +78,7 @@ namespace turns::core
     return m_priority.get_value();
   }
 
-  auto Participant::set_disposition(disposition value) -> void
+  auto Participant::set_disposition(Disposition value) -> void
   {
     return m_disposition.set_value(value);
   }
diff --git a/core/src/turn_order.cpp b/core/src/turn_order.cpp
index ef7bde6..669f746 100644
--- a/core/src/turn_order.cpp
+++ b/core/src/turn_order.cpp
@@ -100,7 +100,7 @@ namespace turns::core
 
   /** Modifiers */
 
-  auto turn_order::add(Glib::ustring const & name, float priority, disposition disposition) -> void
+  auto turn_order::add(Glib::ustring const & name, float priority, Disposition disposition) -> void
   {
     auto entry = Participant::create(name, priority, disposition);
     entry->property_priority().signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &turn_order::handle_priority_changed), entry));
diff --git a/core/tests/disposition.cpp b/core/tests/disposition.cpp
index fda605c..dfab1f7 100644
--- a/core/tests/disposition.cpp
+++ b/core/tests/disposition.cpp
@@ -16,14 +16,14 @@ namespace turns::core::tests
 
   TEST_CASE("to_presentation_name returns the correct string for the current language", "[disposition]")
   {
-    auto [value, name] = GENERATE(std::pair{disposition::neutral, Glib::ustring{_("Neutral")}},
-                                  std::pair{disposition::friendly, Glib::ustring{_("Friendly")}},
-                                  std::pair{disposition::hostile, Glib::ustring{_("Hostile")}},
-                                  std::pair{disposition::secret, Glib::ustring{_("Secret")}},
-                                  std::pair{static_cast<disposition>(std::numeric_limits<std::underlying_type_t<disposition>>::max()),
+    auto [value, name] = GENERATE(std::pair{Disposition::neutral, Glib::ustring{_("Neutral")}},
+                                  std::pair{Disposition::friendly, Glib::ustring{_("Friendly")}},
+                                  std::pair{Disposition::hostile, Glib::ustring{_("Hostile")}},
+                                  std::pair{Disposition::secret, Glib::ustring{_("Secret")}},
+                                  std::pair{static_cast<Disposition>(std::numeric_limits<std::underlying_type_t<Disposition>>::max()),
                                             Glib::ustring{_("Unknown disposition value")}});
 
-    SECTION(std::format("the presentation name for '{}' is '{}'", static_cast<std::underlying_type_t<disposition>>(value), name.c_str()))
+    SECTION(std::format("the presentation name for '{}' is '{}'", static_cast<std::underlying_type_t<Disposition>>(value), name.c_str()))
     {
       REQUIRE(presentation_name_for(value) == name);
     }
diff --git a/core/tests/participant.cpp b/core/tests/participant.cpp
index 8c7c230..b3ae5e9 100644
--- a/core/tests/participant.cpp
+++ b/core/tests/participant.cpp
@@ -16,7 +16,7 @@ namespace turns::core::tests
   {
     auto constexpr name = "Participant #1";
     auto constexpr priority = 17;
-    auto constexpr disposition = disposition::friendly;
+    auto constexpr disposition = Disposition::friendly;
 
     auto json = nlohmann::json::parse(R"(
     {
@@ -33,7 +33,7 @@ namespace turns::core::tests
       auto instance = Participant{};
       REQUIRE(instance.property_name() == "");
       REQUIRE(instance.property_priority() == 0);
-      REQUIRE(instance.property_disposition() == disposition::neutral);
+      REQUIRE(instance.property_disposition() == Disposition::neutral);
       REQUIRE(!instance.property_is_active());
       REQUIRE(!instance.property_is_defeated());
     }
@@ -73,21 +73,21 @@ namespace turns::core::tests
   {
     auto constexpr name = "Participant #2";
     auto constexpr priority = 10;
-    auto constexpr disposition = disposition::hostile;
+    auto constexpr disposition = Disposition::hostile;
 
     auto instance = Participant{name, priority, disposition};
 
     SECTION("Setting '::disposition' via proxy changes the 'disposition' value")
     {
       auto old = instance.property_disposition().get_value();
-      instance.property_disposition() = static_cast<core::disposition>(static_cast<int>(disposition) - 1);
+      instance.property_disposition() = static_cast<core::Disposition>(static_cast<int>(disposition) - 1);
       REQUIRE(instance.property_disposition() != old);
     }
 
     SECTION("Setting '::disposition' via glib changes the 'disposition' value")
     {
       auto old = instance.property_disposition().get_value();
-      instance.set_property("disposition", static_cast<core::disposition>(static_cast<int>(disposition) - 1));
+      instance.set_property("disposition", static_cast<core::Disposition>(static_cast<int>(disposition) - 1));
       REQUIRE(instance.property_disposition() != old);
     }
 
@@ -152,7 +152,7 @@ namespace turns::core::tests
   {
     auto constexpr constructed_name = "Vana Thistletop";
     auto constexpr constructed_priority = 17;
-    auto constexpr constructed_disposition = disposition::friendly;
+    auto constexpr constructed_disposition = Disposition::friendly;
     auto instance = Participant{constructed_name, constructed_priority, constructed_disposition};
 
     SECTION("can be created")
@@ -175,8 +175,8 @@ namespace turns::core::tests
 
       SECTION("allowing to set it")
       {
-        instance.property_disposition() = disposition::hostile;
-        REQUIRE(instance.property_disposition() == disposition::hostile);
+        instance.property_disposition() = Disposition::hostile;
+        REQUIRE(instance.property_disposition() == Disposition::hostile);
       }
     }
 
@@ -250,7 +250,7 @@ namespace turns::core::tests
 
   TEST_CASE("Serializing a participant")
   {
-    auto instance = Participant::create("Participant #0", 17.2, disposition::friendly);
+    auto instance = Participant::create("Participant #0", 17.2, Disposition::friendly);
     auto serialized = instance->serialize();
 
     SECTION("the active state is serialized correctly")
@@ -260,7 +260,7 @@ namespace turns::core::tests
 
     SECTION("the disposition is serialized correctly")
     {
-      REQUIRE(serialized.at("disposition") == disposition::friendly);
+      REQUIRE(serialized.at("disposition") == Disposition::friendly);
     }
 
     SECTION("the name is serialized correctly")
@@ -293,7 +293,7 @@ namespace turns::core::tests
 
     SECTION("the disposition is de-serialized correctly")
     {
-      REQUIRE(instance->property_disposition() == disposition::hostile);
+      REQUIRE(instance->property_disposition() == Disposition::hostile);
     }
 
     SECTION("the name is de-serialized correctly")
diff --git a/core/tests/turn_order.cpp b/core/tests/turn_order.cpp
index a7a0be0..a7af8d0 100644
--- a/core/tests/turn_order.cpp
+++ b/core/tests/turn_order.cpp
@@ -61,7 +61,7 @@ namespace turns::core::tests
 
     GIVEN("a participant has been added to a turn_order")
     {
-      instance->add("Participant #0", 0, disposition::neutral);
+      instance->add("Participant #0", 0, Disposition::neutral);
 
       THEN("get_n_items() returns 1")
       {
diff --git a/core/tests/turn_order_bugs.cpp b/core/tests/turn_order_bugs.cpp
index d5502bc..2e8937c 100644
--- a/core/tests/turn_order_bugs.cpp
+++ b/core/tests/turn_order_bugs.cpp
@@ -19,7 +19,7 @@ namespace turns::core::tests
     {
       auto instance = turn_order::create();
 
-      instance->add("A", 0, disposition::neutral);
+      instance->add("A", 0, Disposition::neutral);
 
       WHEN("it is started and then stepped forward, backward, forward")
       {
diff --git a/ui/include/turns/ui/participant_editor.hpp b/ui/include/turns/ui/participant_editor.hpp
index 4e6bdf4..0fbc504 100644
--- a/ui/include/turns/ui/participant_editor.hpp
+++ b/ui/include/turns/ui/participant_editor.hpp
@@ -32,7 +32,7 @@ namespace turns::ui
 
   struct ParticipantEditor : template_widget<ParticipantEditor, Adwaita::Dialog>
   {
-    using SignalFinishedType = sigc::signal<void(Glib::ustring, float, core::disposition)>;
+    using SignalFinishedType = sigc::signal<void(Glib::ustring, float, core::Disposition)>;
 
     auto constexpr inline static children = std::array{
         "disposition",
@@ -43,12 +43,12 @@ namespace turns::ui
 
     explicit ParticipantEditor(Glib::RefPtr<core::Participant> participant);
 
-    [[nodiscard]] auto get_disposition() const -> core::disposition;
+    [[nodiscard]] auto get_disposition() const -> core::Disposition;
     [[nodiscard]] auto get_name() const -> Glib::ustring;
     [[nodiscard]] auto get_participant() const -> Glib::RefPtr<core::Participant>;
     [[nodiscard]] auto get_priority() const -> double;
 
-    auto set_disposition(core::disposition value) -> void;
+    auto set_disposition(core::Disposition value) -> void;
     auto set_name(Glib::ustring const & value) -> void;
     auto set_participant(Glib::RefPtr<core::Participant> const & value) -> void;
     auto set_priority(double value) -> void;
diff --git a/ui/src/participant_editor.cpp b/ui/src/participant_editor.cpp
index 09feb7e..8c83559 100644
--- a/ui/src/participant_editor.cpp
+++ b/ui/src/participant_editor.cpp
@@ -51,9 +51,9 @@ namespace turns::ui
   {
     m_finish->signal_clicked().connect(sigc::mem_fun(*this, &ParticipantEditor::handle_finish_clicked));
 
-    for (auto n : std::views::iota(std::uint8_t{}, static_cast<std::uint8_t>(core::disposition::END)))
+    for (auto n : std::views::iota(std::uint8_t{}, static_cast<std::uint8_t>(core::Disposition::END)))
     {
-      m_disposition_model->append(presentation_name_for(core::disposition{n}));
+      m_disposition_model->append(presentation_name_for(core::Disposition{n}));
     }
 
     m_disposition_factory->signal_bind().connect(sigc::mem_fun(*this, &ParticipantEditor::handle_item_bind));
@@ -67,9 +67,9 @@ namespace turns::ui
     set_participant(participant);
   }
 
-  auto ParticipantEditor::get_disposition() const -> core::disposition
+  auto ParticipantEditor::get_disposition() const -> core::Disposition
   {
-    return static_cast<core::disposition>(m_disposition->get_selected());
+    return static_cast<core::Disposition>(m_disposition->get_selected());
   }
 
   auto ParticipantEditor::get_name() const -> Glib::ustring
@@ -87,7 +87,7 @@ namespace turns::ui
     return m_priority->get_value();
   }
 
-  auto ParticipantEditor::set_disposition(core::disposition value) -> void
+  auto ParticipantEditor::set_disposition(core::Disposition value) -> void
   {
     m_disposition->set_selected(static_cast<unsigned>(value));
   }
@@ -124,7 +124,7 @@ namespace turns::ui
 
   auto ParticipantEditor::handle_finish_clicked() -> void
   {
-    m_signal_finished.emit(m_name->get_text(), m_priority->get_value(), static_cast<core::disposition>(m_disposition->get_selected()));
+    m_signal_finished.emit(m_name->get_text(), m_priority->get_value(), static_cast<core::Disposition>(m_disposition->get_selected()));
     close();
   }
 
@@ -155,7 +155,7 @@ namespace turns::ui
                                    m_disposition->property_selected(),
                                    Glib::Binding::Flags::BIDIRECTIONAL | Glib::Binding::Flags::SYNC_CREATE,
                                    [](auto value) { return static_cast<unsigned>(value); },
-                                   [](auto value) { return static_cast<core::disposition>(value); });
+                                   [](auto value) { return static_cast<core::Disposition>(value); });
     }
   }
 
diff --git a/ui/src/participant_row.cpp b/ui/src/participant_row.cpp
index 782182d..3fc5739 100644
--- a/ui/src/participant_row.cpp
+++ b/ui/src/participant_row.cpp
@@ -31,15 +31,15 @@ namespace turns::ui
     auto constexpr static TYPE_NAME = "ParticipantRow";
     auto constexpr static TEMPLATE = "/ch/arknet/Turns/participant_row.ui";
 
-    auto css_class_for(core::disposition value) -> Glib::ustring
+    auto css_class_for(core::Disposition value) -> Glib::ustring
     {
       switch (value)
       {
-      case core::disposition::friendly:
+      case core::Disposition::friendly:
         return "disposition-friendly";
-      case core::disposition::hostile:
+      case core::Disposition::hostile:
         return "disposition-hostile";
-      case core::disposition::secret:
+      case core::Disposition::secret:
         return "disposition-secret";
       default:
         return "";
diff --git a/ui/tests/participant_editor.cpp b/ui/tests/participant_editor.cpp
index b2398de..a9ceb44 100644
--- a/ui/tests/participant_editor.cpp
+++ b/ui/tests/participant_editor.cpp
@@ -31,7 +31,7 @@ namespace turns::ui::tests
     auto locale = GENERATE("en_US.UTF-8", "de_CH.UTF-8");
     setlocale(LC_ALL, locale);
 
-    auto participant = core::Participant::create("Frederick Thumblewackle", 7.2, core::disposition::friendly);
+    auto participant = core::Participant::create("Frederick Thumblewackle", 7.2, core::Disposition::friendly);
     auto instance = std::make_shared<ParticipantEditor>(nullptr);
     auto window = Gtk::Window{};
 
@@ -62,7 +62,7 @@ namespace turns::ui::tests
 
     SECTION("has neutral disposition")
     {
-      REQUIRE(instance->get_disposition() == core::disposition::neutral);
+      REQUIRE(instance->get_disposition() == core::Disposition::neutral);
     }
 
     SECTION("has a null participant")
@@ -95,9 +95,9 @@ namespace turns::ui::tests
 
       THEN("changes to the disposition propagate to the participant")
       {
-        CHECK(participant->get_disposition() != core::disposition::secret);
-        instance->set_disposition(core::disposition::secret);
-        REQUIRE(participant->get_disposition() == core::disposition::secret);
+        CHECK(participant->get_disposition() != core::Disposition::secret);
+        instance->set_disposition(core::Disposition::secret);
+        REQUIRE(participant->get_disposition() == core::Disposition::secret);
       }
     }
 
@@ -112,7 +112,7 @@ namespace turns::ui::tests
     auto locale = GENERATE("en_US.UTF-8", "de_CH.UTF-8");
     setlocale(LC_ALL, locale);
 
-    auto participant = core::Participant::create("Qibi Babblebranch", 12, core::disposition::neutral);
+    auto participant = core::Participant::create("Qibi Babblebranch", 12, core::Disposition::neutral);
     auto instance = std::make_shared<ParticipantEditor>(participant);
     auto window = Gtk::Window{};
 
diff --git a/ui/tests/participant_row.cpp b/ui/tests/participant_row.cpp
index 6e5319f..c02b3f0 100644
--- a/ui/tests/participant_row.cpp
+++ b/ui/tests/participant_row.cpp
@@ -23,7 +23,7 @@ namespace turns::ui::tests
 
     SECTION("can be created with a participant")
     {
-      REQUIRE(std::make_shared<ParticipantRow>(core::Participant::create("Tazmyla Fireforge", 13, core::disposition::secret)));
+      REQUIRE(std::make_shared<ParticipantRow>(core::Participant::create("Tazmyla Fireforge", 13, core::Disposition::secret)));
     }
   }