7 files changed, 92 insertions, 92 deletions

diff --git a/core/include/turns/core/participant.hpp b/core/include/turns/core/participant.hpp
index c21aa8b..a7eb98d 100644
--- a/core/include/turns/core/participant.hpp
+++ b/core/include/turns/core/participant.hpp
@@ -24,11 +24,11 @@ namespace turns::core
 
     auto operator<=>(participant const & other) const noexcept -> std::partial_ordering;
 
-    auto disposition(this auto && self);
-    auto is_active(this auto && self);
-    auto is_defeated(this auto && self);
-    auto name(this auto && self);
-    auto priority(this auto && self);
+    auto property_disposition(this auto && self);
+    auto property_is_active(this auto && self);
+    auto property_is_defeated(this auto && self);
+    auto property_name(this auto && self);
+    auto property_priority(this auto && self);
 
     auto serialize() -> nlohmann::json;
 
@@ -40,27 +40,27 @@ namespace turns::core
     Glib::Property<float> m_priority{*this, "priority", 0.0f};
   };
 
-  auto participant::disposition(this auto && self)
+  auto participant::property_disposition(this auto && self)
   {
     return self.m_disposition.get_proxy();
   }
 
-  auto participant::is_active(this auto && self)
+  auto participant::property_is_active(this auto && self)
   {
     return self.m_is_active.get_proxy();
   }
 
-  auto participant::is_defeated(this auto && self)
+  auto participant::property_is_defeated(this auto && self)
   {
     return self.m_is_defeated.get_proxy();
   }
 
-  auto participant::name(this auto && self)
+  auto participant::property_name(this auto && self)
   {
     return self.m_name.get_proxy();
   }
 
-  auto participant::priority(this auto && self)
+  auto participant::property_priority(this auto && self)
   {
     return self.m_priority.get_proxy();
   }
diff --git a/core/src/participant.cpp b/core/src/participant.cpp
index b607794..d560789 100644
--- a/core/src/participant.cpp
+++ b/core/src/participant.cpp
@@ -28,8 +28,8 @@ namespace turns::core
     auto name = serialized.value("name", std::string{});
 
     auto instance = create(name, priority, disposition);
-    instance->is_active() = serialized.value("is-active", false);
-    instance->is_defeated() = serialized.value("is-defeated", false);;
+    instance->property_is_active() = serialized.value("is-active", false);
+    instance->property_is_defeated() = serialized.value("is-defeated", false);;
 
     return instance;
   }
diff --git a/core/src/turn_order.cpp b/core/src/turn_order.cpp
index a2c4ce5..d43ac7f 100644
--- a/core/src/turn_order.cpp
+++ b/core/src/turn_order.cpp
@@ -103,7 +103,7 @@ namespace turns::core
   auto turn_order::add(Glib::ustring const & name, float priority, disposition disposition) -> void
   {
     auto entry = participant::create(name, priority, disposition);
-    entry->priority().signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &turn_order::handle_priority_changed), entry));
+    entry->property_priority().signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &turn_order::handle_priority_changed), entry));
     auto position = std::distance(m_data.cbegin(), insert(entry));
     items_changed(position, 0, 1);
 
@@ -135,8 +135,8 @@ namespace turns::core
     m_active = m_active.transform([this](auto index) { return (index + 1) % get_n_items(); });
 
     m_has_previous = true;
-    m_data[old_active]->is_active() = false;
-    m_data[*m_active]->is_active() = true;
+    m_data[old_active]->property_is_active() = false;
+    m_data[*m_active]->property_is_active() = true;
 
     m_progress = (static_cast<float>(*m_active) + 1) / get_n_items();
 
@@ -157,8 +157,8 @@ namespace turns::core
     m_active = m_active.transform([this](auto index) { return index ? index - 1 : get_n_items() - 1; });
 
     m_has_previous = m_round_number > 0 || m_active > 0;
-    m_data[old_active]->is_active() = false;
-    m_data[*m_active]->is_active() = true;
+    m_data[old_active]->property_is_active() = false;
+    m_data[*m_active]->property_is_active() = true;
 
     m_progress = (static_cast<float>(*m_active) + 1) / get_n_items();
 
@@ -191,7 +191,7 @@ namespace turns::core
     if (!m_active)
     {
       m_active = 0;
-      m_data[*m_active]->is_active() = true;
+      m_data[*m_active]->property_is_active() = true;
     }
     if (m_round_number == invalid_round_number)
     {
@@ -225,7 +225,7 @@ namespace turns::core
     auto inserter = std::bind(&turn_order::insert, this, _1);
     std::ranges::for_each(participants | std::views::transform(factory), inserter);
 
-    auto active = std::ranges::find_if(m_data, [](auto participant) { return participant->is_active(); });
+    auto active = std::ranges::find_if(m_data, [](auto participant) { return participant->property_is_active(); });
     if (active != std::ranges::end(m_data))
     {
       m_active = std::ranges::distance(std::ranges::begin(m_data), active);
diff --git a/core/tests/participant.cpp b/core/tests/participant.cpp
index a526582..ed7b435 100644
--- a/core/tests/participant.cpp
+++ b/core/tests/participant.cpp
@@ -31,41 +31,41 @@ namespace turns::core::tests
     SECTION("Can be constructed using default ctor")
     {
       auto instance = participant{};
-      REQUIRE(instance.name() == "");
-      REQUIRE(instance.priority() == 0);
-      REQUIRE(instance.disposition() == disposition::neutral);
-      REQUIRE(!instance.is_active());
-      REQUIRE(!instance.is_defeated());
+      REQUIRE(instance.property_name() == "");
+      REQUIRE(instance.property_priority() == 0);
+      REQUIRE(instance.property_disposition() == disposition::neutral);
+      REQUIRE(!instance.property_is_active());
+      REQUIRE(!instance.property_is_defeated());
     }
 
     SECTION("Can be constructed using ctor")
     {
       auto instance = participant{name, priority, disposition};
-      REQUIRE(instance.name() == name);
-      REQUIRE(instance.priority() == priority);
-      REQUIRE(instance.disposition() == disposition);
-      REQUIRE(!instance.is_active());
-      REQUIRE(!instance.is_defeated());
+      REQUIRE(instance.property_name() == name);
+      REQUIRE(instance.property_priority() == priority);
+      REQUIRE(instance.property_disposition() == disposition);
+      REQUIRE(!instance.property_is_active());
+      REQUIRE(!instance.property_is_defeated());
     }
 
     SECTION("Can be constructed using factory")
     {
       auto instance = participant::create(name, priority, disposition);
-      REQUIRE(instance->name() == name);
-      REQUIRE(instance->priority() == priority);
-      REQUIRE(instance->disposition() == disposition);
-      REQUIRE(!instance->is_active());
-      REQUIRE(!instance->is_defeated());
+      REQUIRE(instance->property_name() == name);
+      REQUIRE(instance->property_priority() == priority);
+      REQUIRE(instance->property_disposition() == disposition);
+      REQUIRE(!instance->property_is_active());
+      REQUIRE(!instance->property_is_defeated());
     }
 
     SECTION("Can be constructed using JSON factory", "[json]")
     {
       auto instance = participant::create(json);
-      REQUIRE(instance->name() == name);
-      REQUIRE(instance->priority() == priority);
-      REQUIRE(instance->disposition() == disposition);
-      REQUIRE(!instance->is_active());
-      REQUIRE(!instance->is_defeated());
+      REQUIRE(instance->property_name() == name);
+      REQUIRE(instance->property_priority() == priority);
+      REQUIRE(instance->property_disposition() == disposition);
+      REQUIRE(!instance->property_is_active());
+      REQUIRE(!instance->property_is_defeated());
     }
   }
 
@@ -79,72 +79,72 @@ namespace turns::core::tests
 
     SECTION("Setting '::disposition' via proxy changes the 'disposition' value")
     {
-      auto old = instance.disposition().get_value();
-      instance.disposition() = static_cast<core::disposition>(static_cast<int>(disposition) - 1);
-      REQUIRE(instance.disposition() != old);
+      auto old = instance.property_disposition().get_value();
+      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.disposition().get_value();
+      auto old = instance.property_disposition().get_value();
       instance.set_property("disposition", static_cast<core::disposition>(static_cast<int>(disposition) - 1));
-      REQUIRE(instance.disposition() != old);
+      REQUIRE(instance.property_disposition() != old);
     }
 
     SECTION("Setting '::is-active' via proxy changes the 'is_active' value")
     {
-      auto old = instance.is_active().get_value();
-      instance.is_active() = !old;
-      REQUIRE(instance.is_active() != old);
+      auto old = instance.property_is_active().get_value();
+      instance.property_is_active() = !old;
+      REQUIRE(instance.property_is_active() != old);
     }
 
     SECTION("Setting '::is-active' via glib changes the 'is_active' value")
     {
-      auto old = instance.is_active().get_value();
+      auto old = instance.property_is_active().get_value();
       instance.set_property("is-active", !old);
-      REQUIRE(instance.is_active() != old);
+      REQUIRE(instance.property_is_active() != old);
     }
 
     SECTION("Setting '::is-defeated' via proxy changes the 'is_defeated' value")
     {
-      auto old = instance.is_defeated().get_value();
-      instance.is_defeated() = !old;
-      REQUIRE(instance.is_defeated() != old);
+      auto old = instance.property_is_defeated().get_value();
+      instance.property_is_defeated() = !old;
+      REQUIRE(instance.property_is_defeated() != old);
     }
 
     SECTION("Setting '::is-defeated' via glib changes the 'is_defeated' value")
     {
-      auto old = instance.is_defeated().get_value();
+      auto old = instance.property_is_defeated().get_value();
       instance.set_property("is-defeated", !old);
-      REQUIRE(instance.is_defeated() != old);
+      REQUIRE(instance.property_is_defeated() != old);
     }
 
     SECTION("Setting '::name' via proxy changes the 'name' value")
     {
-      auto old = instance.name().get_value();
-      instance.name() = old + " Changed";
-      REQUIRE(instance.name().get_value() != old);
+      auto old = instance.property_name().get_value();
+      instance.property_name() = old + " Changed";
+      REQUIRE(instance.property_name().get_value() != old);
     }
 
     SECTION("Setting '::name' via glib changes the 'name' value")
     {
-      auto old = instance.name().get_value();
+      auto old = instance.property_name().get_value();
       instance.set_property("name", old + " Changed");
-      REQUIRE(instance.name().get_value() != old);
+      REQUIRE(instance.property_name().get_value() != old);
     }
 
     SECTION("Setting '::priority' via proxy changes the 'priority' value")
     {
-      auto old = instance.priority().get_value();
-      instance.priority() = old + 1;
-      REQUIRE(instance.priority() != old);
+      auto old = instance.property_priority().get_value();
+      instance.property_priority() = old + 1;
+      REQUIRE(instance.property_priority() != old);
     }
 
     SECTION("Setting '::priority' via glib changes the 'priority' value")
     {
-      auto old = instance.priority().get_value();
+      auto old = instance.property_priority().get_value();
       instance.set_property("priority", old + 1);
-      REQUIRE(instance.priority() != old);
+      REQUIRE(instance.property_priority() != old);
     }
   }
 
@@ -164,19 +164,19 @@ namespace turns::core::tests
     {
       SECTION("allowing to get it")
       {
-        REQUIRE(instance.disposition() == constructed_disposition);
+        REQUIRE(instance.property_disposition() == constructed_disposition);
       }
 
       SECTION("allowing to get it via a constant object")
       {
         auto const & cref = instance;
-        REQUIRE(cref.disposition() == constructed_disposition);
+        REQUIRE(cref.property_disposition() == constructed_disposition);
       }
 
       SECTION("allowing to set it")
       {
-        instance.disposition() = disposition::hostile;
-        REQUIRE(instance.disposition() == disposition::hostile);
+        instance.property_disposition() = disposition::hostile;
+        REQUIRE(instance.property_disposition() == disposition::hostile);
       }
     }
 
@@ -184,19 +184,19 @@ namespace turns::core::tests
     {
       SECTION("allowing to get it")
       {
-        REQUIRE(instance.name() == constructed_name);
+        REQUIRE(instance.property_name() == constructed_name);
       }
 
       SECTION("allowing to get it via a constant object")
       {
         auto const & cref = instance;
-        REQUIRE(cref.name() == constructed_name);
+        REQUIRE(cref.property_name() == constructed_name);
       }
 
       SECTION("allowing to set it")
       {
-        instance.name() = "replaced";
-        REQUIRE(instance.name() == "replaced");
+        instance.property_name() = "replaced";
+        REQUIRE(instance.property_name() == "replaced");
       }
     }
 
@@ -204,19 +204,19 @@ namespace turns::core::tests
     {
       SECTION("allowing to get it")
       {
-        REQUIRE(instance.priority() == constructed_priority);
+        REQUIRE(instance.property_priority() == constructed_priority);
       }
 
       SECTION("allowing to get it via a constant object")
       {
         auto const & cref = instance;
-        REQUIRE(cref.priority() == constructed_priority);
+        REQUIRE(cref.property_priority() == constructed_priority);
       }
 
       SECTION("allowing to set it")
       {
-        instance.priority() = 4;
-        REQUIRE(instance.priority() == 4);
+        instance.property_priority() = 4;
+        REQUIRE(instance.property_priority() == 4);
       }
     }
 
@@ -288,22 +288,22 @@ namespace turns::core::tests
 
     SECTION("the active state is de-serialized correctly")
     {
-      REQUIRE(instance->is_active());
+      REQUIRE(instance->property_is_active());
     }
 
     SECTION("the disposition is de-serialized correctly")
     {
-      REQUIRE(instance->disposition() == disposition::hostile);
+      REQUIRE(instance->property_disposition() == disposition::hostile);
     }
 
     SECTION("the name is de-serialized correctly")
     {
-      REQUIRE(instance->name() == "Participant #1");
+      REQUIRE(instance->property_name() == "Participant #1");
     }
 
     SECTION("the priority is de-serialized correctly")
     {
-      REQUIRE(instance->priority() == Catch::Approx{-2.3});
+      REQUIRE(instance->property_priority() == Catch::Approx{-2.3});
     }
   }
 
diff --git a/ui/src/widgets/participant_row.cpp b/ui/src/widgets/participant_row.cpp
index 305336e..0a2a3b6 100644
--- a/ui/src/widgets/participant_row.cpp
+++ b/ui/src/widgets/participant_row.cpp
@@ -86,13 +86,13 @@ namespace turns::ui::widgets
 
     if (participant)
     {
-      Glib::Binding::bind_property(participant->name(), m_title->property_label(), Glib::Binding::Flags::SYNC_CREATE);
+      Glib::Binding::bind_property(participant->property_name(), m_title->property_label(), Glib::Binding::Flags::SYNC_CREATE);
 
-      Glib::Binding::bind_property(participant->priority(), m_subtitle->property_label(), Glib::Binding::Flags::SYNC_CREATE, [](auto n) {
+      Glib::Binding::bind_property(participant->property_priority(), m_subtitle->property_label(), Glib::Binding::Flags::SYNC_CREATE, [](auto n) {
         return std::vformat(_(lang::priority_number), std::make_format_args(n));
       });
 
-      Glib::Binding::bind_property(participant->disposition(),
+      Glib::Binding::bind_property(participant->property_disposition(),
                                    m_toggle_defeated->property_css_classes(),
                                    Glib::Binding::Flags::SYNC_CREATE,
                                    [this](auto value) {
@@ -105,7 +105,7 @@ namespace turns::ui::widgets
         return classes;
       });
 
-      Glib::Binding::bind_property(participant->is_active(), property_css_classes(), Glib::Binding::Flags::SYNC_CREATE, [this](auto value) {
+      Glib::Binding::bind_property(participant->property_is_active(), property_css_classes(), Glib::Binding::Flags::SYNC_CREATE, [this](auto value) {
         auto classes = get_css_classes();
         if (!value)
         {
diff --git a/ui/src/windows/participant_editor.cpp b/ui/src/windows/participant_editor.cpp
index 1577554..a14593b 100644
--- a/ui/src/windows/participant_editor.cpp
+++ b/ui/src/windows/participant_editor.cpp
@@ -61,9 +61,9 @@ namespace turns::ui::windows
 
     if (m_participant)
     {
-      gtk_editable_set_text(GTK_EDITABLE(m_name), m_participant->name().get_value().c_str());
-      adw_spin_row_set_value(m_priority, m_participant->priority());
-      adw_combo_row_set_selected(m_disposition, static_cast<unsigned>(m_participant->disposition().get_value()));
+      gtk_editable_set_text(GTK_EDITABLE(m_name), m_participant->property_name().get_value().c_str());
+      adw_spin_row_set_value(m_priority, m_participant->property_priority());
+      adw_combo_row_set_selected(m_disposition, static_cast<unsigned>(m_participant->property_disposition().get_value()));
     }
   }
 
@@ -85,9 +85,9 @@ namespace turns::ui::windows
 
     if (m_participant)
     {
-      m_participant->name() = name;
-      m_participant->priority() = priority;
-      m_participant->disposition() = disposition;
+      m_participant->property_name() = name;
+      m_participant->property_priority() = priority;
+      m_participant->property_disposition() = disposition;
     }
 
     m_signal_finished.emit(name, priority, disposition);
diff --git a/ui/tests/windows/participant_editor.cpp b/ui/tests/windows/participant_editor.cpp
index b721018..46c9b58 100644
--- a/ui/tests/windows/participant_editor.cpp
+++ b/ui/tests/windows/participant_editor.cpp
@@ -97,13 +97,13 @@ namespace turns::ui::windows::tests
     SECTION("has its name field set according to its participant")
     {
       auto widget = GTK_EDITABLE(Glib::unwrap(builder->get_widget<Gtk::ListBoxRow>("name")));
-      REQUIRE(gtk_editable_get_text(widget) == participant->name().get_value());
+      REQUIRE(gtk_editable_get_text(widget) == participant->property_name().get_value());
     }
 
     SECTION("has its priority field set according to its participant")
     {
       auto widget = ADW_SPIN_ROW(Glib::unwrap(builder->get_widget<Gtk::ListBoxRow>("priority")));
-      REQUIRE(adw_spin_row_get_value(widget) == participant->priority());
+      REQUIRE(adw_spin_row_get_value(widget) == participant->property_priority());
     }
 
     SECTION("allows binding to the finished signal")