turns: perform widespread code cleanup actions

15 files changed, 175 insertions, 128 deletions

diff --git a/app/include/turns/app/application.hpp b/app/include/turns/app/application.hpp
index c74f340..81fe333 100644
--- a/app/include/turns/app/application.hpp
+++ b/app/include/turns/app/application.hpp
@@ -1,13 +1,13 @@
 #ifndef TURNS_APP_APPLICATION_HPP
 #define TURNS_APP_APPLICATION_HPP
 
-#include <adwaita.h>
+#include "turns/app/windows/main.hpp"
+
+#include <memory>
 
+#include <adwaita.h>
 #include <glibmm/refptr.h>
 #include <gtkmm/application.h>
-#include <gtkmm/applicationwindow.h>
-
-#include <memory>
 
 namespace turns::app
 {
@@ -27,9 +27,9 @@ namespace turns::app
     auto on_shutdown() -> void;
     auto on_startup() -> void;
 
-    AdwApplication * m_self;
+    AdwApplication * m_adw;
     Glib::RefPtr<Gtk::Application> m_application;
-    AdwApplicationWindow * m_main_window;
+    windows::main * m_main;
   };
 
 }  // namespace turns::app
diff --git a/app/include/turns/app/widgets/participant_list_row.hpp b/app/include/turns/app/widgets/participant_list_row.hpp
index 2e3b176..6a9a6c2 100644
--- a/app/include/turns/app/widgets/participant_list_row.hpp
+++ b/app/include/turns/app/widgets/participant_list_row.hpp
@@ -2,9 +2,12 @@
 #define TURNS_APP_WIDGETS_PARTICIPANT_LIST_ROW_HPP
 
 #include "turns/app/widgets/template_widget.hpp"
+#include "turns/domain/participant.hpp"
 
 #include <array>
 
+#include <glibmm/binding.h>
+#include <glibmm/refptr.h>
 #include <glibmm/ustring.h>
 #include <gtkmm/button.h>
 #include <gtkmm/label.h>
@@ -23,20 +26,24 @@ namespace turns::app::widgets
         "toggle_defeated",
     };
 
-    participant_list_row();
+    participant_list_row(Glib::RefPtr<domain::participant> participant);
 
     auto set_subtitle(Glib::ustring const & value) -> void;
     auto set_title(Glib::ustring const & value) -> void;
 
   private:
     auto handle_delete() -> void;
-    auto handle_toggle_defeated() -> void;
+    auto handle_edit() -> void;
 
     Gtk::Button * m_delete;
     Gtk::Button * m_edit;
     Gtk::Label * m_subtitle;
     Gtk::Label * m_title;
     Gtk::ToggleButton * m_toggle_defeated;
+
+    Glib::RefPtr<Glib::Binding> m_subtitle_visibility{};
+    Glib::RefPtr<Glib::Binding> m_title_visibility{};
+    Glib::RefPtr<Glib::Binding> m_toggle_defeated_icon{};
   };
 }  // namespace turns::app::widgets
 
diff --git a/app/include/turns/app/windows/main.hpp b/app/include/turns/app/windows/main.hpp
index 22dab74..ca8237c 100644
--- a/app/include/turns/app/windows/main.hpp
+++ b/app/include/turns/app/windows/main.hpp
@@ -4,15 +4,14 @@
 #include "turns/domain/turn_order.hpp"
 
 #include <adwaita.h>
-#include <giomm/liststore.h>
+#include <glibmm/binding.h>
 #include <glibmm/object.h>
 #include <glibmm/refptr.h>
+#include <glibmm/ustring.h>
 #include <glibmm/variant.h>
 #include <gtkmm/applicationwindow.h>
 #include <gtkmm/builder.h>
-#include <gtkmm/button.h>
 #include <gtkmm/listbox.h>
-#include <gtkmm/menubutton.h>
 #include <gtkmm/scrolledwindow.h>
 #include <gtkmm/stack.h>
 #include <gtkmm/widget.h>
@@ -36,7 +35,12 @@ namespace turns::app::windows
     AdwWindowTitle * m_title;
     Gtk::ScrolledWindow * m_turn_order;
 
-    Glib::RefPtr<domain::turn_order> m_participants;
+    Glib::RefPtr<domain::turn_order> m_participant_list_data;
+
+    Glib::PropertyProxy<Glib::ustring> m_subtitle;
+
+    Glib::RefPtr<Glib::Binding> m_visible_child_widget{};
+    Glib::RefPtr<Glib::Binding> m_subtitle_text{};
   };
 
 }  // namespace turns::app::windows
diff --git a/app/include/turns/app/windows/participant_editor.hpp b/app/include/turns/app/windows/participant_editor.hpp
index 0d7b518..38b1887 100644
--- a/app/include/turns/app/windows/participant_editor.hpp
+++ b/app/include/turns/app/windows/participant_editor.hpp
@@ -30,14 +30,13 @@ namespace turns::app::windows
     auto handle_finish_clicked() -> void;
 
     AdwDialog * m_adw;
-    Gtk::Button * m_finish;
-
-    Glib::RefPtr<domain::participant> m_participant;
-
     AdwComboRow * m_disposition{};
+    Gtk::Button * m_finish;
     AdwEntryRow * m_name{};
     AdwSpinRow * m_priority{};
 
+    Glib::RefPtr<domain::participant> m_participant;
+
     signal_finished_type m_signal_finished{};
   };
 
diff --git a/app/src/application.cpp b/app/src/application.cpp
index 9408335..a5e8a3c 100644
--- a/app/src/application.cpp
+++ b/app/src/application.cpp
@@ -2,7 +2,7 @@
 
 #include "turns/app/windows/main.hpp"
 
-#include <glibmm.h>
+#include <glibmm/wrap.h>
 #include <gtkmm/builder.h>
 #include <gtkmm/init.h>
 #include <gtkmm/window.h>
@@ -15,23 +15,22 @@ namespace turns::app
   auto application::create() -> std::shared_ptr<application>
   {
     Gtk::init_gtkmm_internals();
+    adw_init();
     return std::shared_ptr<application>{new application{}};
   }
 
   auto application::run(int argc, char * argv[]) -> int
   {
-    return g_application_run(G_APPLICATION(m_self), argc, argv);
+    return g_application_run(G_APPLICATION(m_adw), argc, argv);
   }
 
   application::application()
   {
-    m_self = adw_application_new("ch.arknet.Turns", G_APPLICATION_DEFAULT_FLAGS);
-    m_application = Glib::wrap(GTK_APPLICATION(m_self));
+    m_adw = adw_application_new("ch.arknet.Turns", G_APPLICATION_DEFAULT_FLAGS);
+    m_application = Glib::wrap(GTK_APPLICATION(m_adw));
 
     auto builder = Gtk::Builder::create_from_resource("/ch/arknet/Turns/windows/main.ui");
-    auto main_window = Gtk::Builder::get_widget_derived<windows::main>(builder, "main");
-
-    m_main_window = ADW_APPLICATION_WINDOW(main_window->gobj());
+    m_main = Gtk::Builder::get_widget_derived<windows::main>(builder, "main");
 
     m_application->signal_activate().connect(sigc::mem_fun(*this, &application::on_activate));
     m_application->signal_shutdown().connect(sigc::mem_fun(*this, &application::on_shutdown));
@@ -40,19 +39,19 @@ namespace turns::app
 
   auto application::handle_action_quit() -> void
   {
-    gtk_window_close(GTK_WINDOW(m_main_window));
+    m_main->close();
   }
 
   auto application::on_activate() -> void
   {
-    gtk_application_add_window(m_application->gobj(), GTK_WINDOW(m_main_window));
-    gtk_window_present(GTK_WINDOW(m_main_window));
+    m_application->add_window(*m_main);
+    m_main->present();
   }
 
   auto application::on_shutdown() -> void
   {
-    gtk_window_close(GTK_WINDOW(m_main_window));
-    delete Glib::wrap(GTK_WINDOW(m_main_window));
+    m_main->close();
+    delete m_main;
   }
 
   auto application::on_startup() -> void
diff --git a/app/src/turns.cpp b/app/src/turns.cpp
index d7fadc7..d81f34f 100644
--- a/app/src/turns.cpp
+++ b/app/src/turns.cpp
@@ -10,8 +10,6 @@ auto main(int argc, char * argv[]) -> int
   bind_textdomain_codeset("turns", "UTF-8");
   textdomain("turns");
 
-  adw_init();
-
   auto app = turns::app::application::create();
   return app->run(argc, argv);
 }
\ No newline at end of file
diff --git a/app/src/widgets/participant_list_row.cpp b/app/src/widgets/participant_list_row.cpp
index e38b532..9be3c57 100644
--- a/app/src/widgets/participant_list_row.cpp
+++ b/app/src/widgets/participant_list_row.cpp
@@ -2,6 +2,7 @@
 
 #include "turns/lang/messages.hpp"
 
+#include <format>
 #include <print>
 
 #include <glibmm/i18n.h>
@@ -16,41 +17,60 @@ namespace turns::app::widgets
     auto constexpr static TEMPLATE = "/ch/arknet/Turns/widgets/participant_list_row.ui";
   }  // namespace
 
-  participant_list_row::participant_list_row()
+  participant_list_row::participant_list_row(Glib::RefPtr<domain::participant> participant)
       : Glib::ObjectBase(TYPE_NAME)
       , template_widget<participant_list_row, Gtk::ListBoxRow>{TEMPLATE}
+      , m_delete{get_widget<Gtk::Button>("delete")}
+      , m_edit{get_widget<Gtk::Button>("edit")}
+      , m_subtitle{get_widget<Gtk::Label>("subtitle")}
+      , m_title{get_widget<Gtk::Label>("title")}
+      , m_toggle_defeated{get_widget<Gtk::ToggleButton>("toggle_defeated")}
+      , m_subtitle_visibility{}
   {
-    m_delete = get_widget<Gtk::Button>("delete");
-    m_edit = get_widget<Gtk::Button>("edit");
-    m_subtitle = get_widget<Gtk::Label>("subtitle");
-    m_title = get_widget<Gtk::Label>("title");
-    m_toggle_defeated = get_widget<Gtk::ToggleButton>("toggle_defeated");
-
-    m_delete->signal_clicked().connect([this] { activate_action("win.delete", Glib::Variant<int>::create(get_index())); });
-    m_edit->signal_clicked().connect([this] { activate_action("win.edit", Glib::Variant<int>::create(get_index())); });
-    m_toggle_defeated->signal_toggled().connect(sigc::mem_fun(*this, &participant_list_row::handle_toggle_defeated));
+    m_delete->signal_clicked().connect(sigc::mem_fun(*this, &participant_list_row::handle_delete));
+    m_edit->signal_clicked().connect(sigc::mem_fun(*this, &participant_list_row::handle_edit));
+
+    m_subtitle_visibility = Glib::Binding::bind_property(m_subtitle->property_label(),
+                                                         m_subtitle->property_visible(),
+                                                         Glib::Binding::Flags::DEFAULT,
+                                                         sigc::mem_fun(&Glib::ustring::size));
+    m_title_visibility = Glib::Binding::bind_property(m_title->property_label(),
+                                                      m_title->property_visible(),
+                                                      Glib::Binding::Flags::INVERT_BOOLEAN,
+                                                      sigc::mem_fun(&Glib::ustring::size));
+    m_toggle_defeated_icon = Glib::Binding::bind_property(m_toggle_defeated->property_active(),
+                                                          m_toggle_defeated->property_icon_name(),
+                                                          Glib::Binding::Flags::SYNC_CREATE,
+                                                          [](auto active) { return active ? "face-sick-symbolic" : "face-smile-symbolic"; });
+
+    if (participant)
+    {
+      set_title(participant->get_name());
+      auto priority = participant->get_priority();
+      set_subtitle(std::vformat(_(lang::priority_number), std::make_format_args(priority)));
+    }
   }
 
   auto participant_list_row::set_subtitle(Glib::ustring const & value) -> void
   {
-    m_subtitle->set_text(value);
-    m_subtitle->set_visible(!value.empty());
+    m_subtitle->property_label() = value;
   }
 
   auto participant_list_row::set_title(Glib::ustring const & value) -> void
   {
-    m_title->set_text(value);
-    m_title->set_visible(!value.empty());
+    m_title->property_label() = value;
   }
 
-  auto participant_list_row::handle_toggle_defeated() -> void
+  auto participant_list_row::handle_delete() -> void
   {
-    if (m_toggle_defeated->get_active())
-    {
-      m_toggle_defeated->set_icon_name("face-sick-symbolic");
-      return;
-    }
-    m_toggle_defeated->set_icon_name("face-smile-symbolic");
+    auto index = Glib::Variant<int>::create(get_index());
+    activate_action("win.delete", index);
+  }
+
+  auto participant_list_row::handle_edit() -> void
+  {
+    auto index = Glib::Variant<int>::create(get_index());
+    activate_action("win.edit", index);
   }
 
 }  // namespace turns::app::widgets
\ No newline at end of file
diff --git a/app/src/windows/main.cpp b/app/src/windows/main.cpp
index 8c9ca5c..95ed221 100644
--- a/app/src/windows/main.cpp
+++ b/app/src/windows/main.cpp
@@ -14,6 +14,15 @@
 namespace turns::app::windows
 {
 
+  namespace
+  {
+    auto editor_for(Glib::RefPtr<domain::participant> participant)
+    {
+      auto builder = Gtk::Builder::create_from_resource("/ch/arknet/Turns/windows/participant_editor.ui");
+      return std::pair{builder, Gtk::Builder::get_widget_derived<windows::participant_editor>(builder, "participant_editor", participant)};
+    }
+  }  // namespace
+
   main::main(BaseObjectType * base, Glib::RefPtr<Gtk::Builder> const builder)
       : Gtk::ApplicationWindow{base}
       , m_adw{ADW_APPLICATION_WINDOW(gobj())}
@@ -22,71 +31,48 @@ namespace turns::app::windows
       , m_stack{builder->get_widget<Gtk::Stack>("stack")}
       , m_title(ADW_WINDOW_TITLE(builder->get_widget<Gtk::Widget>("title")->gobj()))
       , m_turn_order{builder->get_widget<Gtk::ScrolledWindow>("turn_order")}
-      , m_participants{domain::turn_order::create()}
+      , m_participant_list_data{domain::turn_order::create()}
+      , m_subtitle{Glib::wrap(GTK_WIDGET(m_title)), "subtitle"}
   {
-    m_stack->set_visible_child(*m_empty);
-    m_stack->property_visible_child().signal_changed().connect([this] {
-      if (m_stack->get_visible_child() == m_empty)
-      {
-        adw_window_title_set_subtitle(m_title, _(lang::no_active_turn_order));
-      }
-      else
-      {
-        adw_window_title_set_subtitle(m_title, "");
-      }
-    });
+    m_visible_child_widget = Glib::Binding::bind_property(m_participant_list_data->property_n_items(),
+                                                          m_stack->property_visible_child(),
+                                                          Glib::Binding::Flags::SYNC_CREATE,
+                                                          [this](auto count) { return count ? m_turn_order : m_empty; });
 
-    m_participants->property_n_items().signal_changed().connect([this] {
-      if (m_participants->get_n_items())
-      {
-        m_stack->set_visible_child(*m_turn_order);
-      }
-      else
-      {
-        m_stack->set_visible_child(*m_empty);
-      }
-    });
-    m_participant_list->bind_model(m_participants, sigc::mem_fun(*this, &main::handle_create_list_row));
+    m_subtitle_text = Glib::Binding::bind_property(m_participant_list_data->property_n_items(),
+                                                   m_subtitle,
+                                                   Glib::Binding::Flags::SYNC_CREATE,
+                                                   [](auto count) { return count ? "" : _(lang::no_active_turn_order); });
+
+    m_participant_list->bind_model(m_participant_list_data, sigc::mem_fun(*this, &main::handle_create_list_row));
 
     add_action("add_participant", sigc::mem_fun(*this, &main::handle_add_participant));
     add_action_with_parameter("delete", Glib::VARIANT_TYPE_INT32, [this](auto param) {
       auto index = Glib::VariantBase::cast_dynamic<Glib::Variant<int>>(param);
-      m_participants->remove(index.get());
+      m_participant_list_data->remove(index.get());
     });
     add_action_with_parameter("edit", Glib::VARIANT_TYPE_INT32, sigc::mem_fun(*this, &main::handle_edit_participant));
-
   }
 
   auto main::handle_create_list_row(Glib::RefPtr<Glib::Object> const item) -> Gtk::Widget *
   {
     auto participant = std::dynamic_pointer_cast<domain::participant>(item);
-    auto widget = Gtk::make_managed<widgets::participant_list_row>();
-    auto priority = participant->property_priority().get_value();
-    widget->set_title(participant->property_name());
-    widget->set_subtitle(std::vformat(_("Priority {}"), std::make_format_args(priority)));
-    return widget;
+    return Gtk::make_managed<widgets::participant_list_row>(participant);
   }
 
   auto main::handle_add_participant() -> void
   {
-    auto builder = Gtk::Builder::create_from_resource("/ch/arknet/Turns/windows/participant_editor.ui");
-    auto dialog = Gtk::Builder::get_widget_derived<windows::participant_editor>(builder, "participant_editor");
-    dialog->set_title(_(lang::add_participant));
+    auto [lifeline, dialog] = editor_for(nullptr);
     dialog->present(this);
-    dialog->signal_finished().connect([this](auto name, auto priority) { m_participants->append(name, priority); });
+    dialog->signal_finished().connect([this](auto name, auto priority) { m_participant_list_data->append(name, priority); });
   }
 
   auto main::handle_edit_participant(Glib::VariantBase param) -> void
   {
     auto index = Glib::VariantBase::cast_dynamic<Glib::Variant<int>>(param);
-    auto participant = m_participants->get_item(index.get());
-
-    auto builder = Gtk::Builder::create_from_resource("/ch/arknet/Turns/windows/participant_editor.ui");
-    auto dialog = Gtk::Builder::get_widget_derived<windows::participant_editor>(builder, "participant_editor", participant);
-
-    dialog->set_title(_(lang::edit_participant));
+    auto participant = m_participant_list_data->get_item(index.get());
+    auto [lifeline, dialog] = editor_for(participant);
     dialog->present(this);
-    dialog->signal_finished().connect([this](auto name, auto priority) { m_participants->append(name, priority); });
   }
 
 }  // namespace turns::app::windows
diff --git a/app/src/windows/participant_editor.cpp b/app/src/windows/participant_editor.cpp
index bab7731..49809c6 100644
--- a/app/src/windows/participant_editor.cpp
+++ b/app/src/windows/participant_editor.cpp
@@ -1,5 +1,7 @@
 #include "turns/app/windows/participant_editor.hpp"
 
+#include "turns/lang/messages.hpp"
+
 #include <print>
 
 #include <gtkmm/editable.h>
@@ -11,19 +13,20 @@ namespace turns::app::windows
   participant_editor::participant_editor(BaseObjectType * base, Glib::RefPtr<Gtk::Builder> const builder, Glib::RefPtr<domain::participant> obj)
       : Gtk::Widget{base}
       , m_adw{ADW_DIALOG(gobj())}
+      , m_disposition{ADW_COMBO_ROW(builder->get_widget<Gtk::ListBoxRow>("disposition")->gobj())}
       , m_finish{builder->get_widget<Gtk::Button>("finish")}
+      , m_name{ADW_ENTRY_ROW(builder->get_widget<Gtk::ListBoxRow>("name")->gobj())}
+      , m_priority{ADW_SPIN_ROW(builder->get_widget<Gtk::ListBoxRow>("priority")->gobj())}
       , m_participant{obj}
-  {
-    m_disposition = ADW_COMBO_ROW(builder->get_widget<Gtk::ListBoxRow>("disposition")->gobj());
-    m_name = ADW_ENTRY_ROW(builder->get_widget<Gtk::ListBoxRow>("name")->gobj());
-    m_priority = ADW_SPIN_ROW(builder->get_widget<Gtk::ListBoxRow>("priority")->gobj());
 
+  {
     if (obj)
     {
       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().get_value());
     }
 
+    adw_dialog_set_title(m_adw, obj ? lang::edit_participant : lang::add_participant);
     m_finish->signal_clicked().connect(sigc::mem_fun(*this, &participant_editor::handle_finish_clicked));
   }
 
@@ -46,15 +49,14 @@ namespace turns::app::windows
   {
     auto name = gtk_editable_get_text(GTK_EDITABLE(m_name));
     auto priority = adw_spin_row_get_value(m_priority);
+
     if (m_participant)
     {
-      m_participant->property_name().set_value(name);
-      m_participant->property_priority().set_value(priority);
-    }
-    else
-    {
-      m_signal_finished.emit(name, priority);
+      m_participant->set_name(name);
+      m_participant->set_priority(priority);
     }
+
+    m_signal_finished.emit(name, priority);
     adw_dialog_close(m_adw);
   }
 }  // namespace turns::app::windows
\ No newline at end of file
diff --git a/domain/include/turns/domain/participant.hpp b/domain/include/turns/domain/participant.hpp
index f417ec7..a097abd 100644
--- a/domain/include/turns/domain/participant.hpp
+++ b/domain/include/turns/domain/participant.hpp
@@ -22,8 +22,13 @@ namespace turns::domain
 
     auto property_name() -> Glib::PropertyProxy<Glib::ustring>;
     auto property_name() const -> Glib::PropertyProxy_ReadOnly<Glib::ustring>;
+    auto get_name() const -> Glib::ustring;
+    auto set_name(Glib::ustring value) -> void;
+
     auto property_priority() -> Glib::PropertyProxy<float>;
     auto property_priority() const -> Glib::PropertyProxy_ReadOnly<float>;
+    auto get_priority() const noexcept -> float;
+    auto set_priority(float value) -> void;
 
   private:
     Glib::Property<Glib::ustring> m_name;
diff --git a/domain/include/turns/domain/turn_order.hpp b/domain/include/turns/domain/turn_order.hpp
index f7eb773..cb51af6 100644
--- a/domain/include/turns/domain/turn_order.hpp
+++ b/domain/include/turns/domain/turn_order.hpp
@@ -4,8 +4,8 @@
 #include "turns/domain/participant.hpp"
 
 #include <giomm/liststore.h>
-#include <glibmm/ustring.h>
 #include <glibmm/refptr.h>
+#include <glibmm/ustring.h>
 
 namespace turns::domain
 {
@@ -15,8 +15,8 @@ namespace turns::domain
     using super = Gio::ListStore<participant>;
     using super::super;
 
-    using super::remove;
     using super::append;
+    using super::remove;
 
     auto static create() -> Glib::RefPtr<turn_order>;
 
diff --git a/domain/src/participant.cpp b/domain/src/participant.cpp
index 5c31e2a..7ff9ce1 100644
--- a/domain/src/participant.cpp
+++ b/domain/src/participant.cpp
@@ -1,7 +1,9 @@
 #include "turns/domain/participant.hpp"
 
-#include <utility>
 #include <typeinfo>
+#include <utility>
+
+#include <glibmm/refptr.h>
 
 namespace turns::domain
 {
@@ -23,6 +25,26 @@ namespace turns::domain
     return m_priority <=> other.m_priority;
   }
 
+  auto participant::get_name() const -> Glib::ustring
+  {
+    return m_name;
+  }
+
+  auto participant::set_name(Glib::ustring value) -> void
+  {
+    m_name = value;
+  }
+
+  auto participant::get_priority() const noexcept -> float
+  {
+    return m_priority;
+  }
+
+  auto participant::set_priority(float value) -> void
+  {
+    m_priority = value;
+  }
+
   auto participant::property_name() -> Glib::PropertyProxy<Glib::ustring>
   {
     return m_name.get_proxy();
diff --git a/domain/src/turn_order.cpp b/domain/src/turn_order.cpp
index 4c5c587..454e27a 100644
--- a/domain/src/turn_order.cpp
+++ b/domain/src/turn_order.cpp
@@ -1,23 +1,29 @@
 #include "turns/domain/turn_order.hpp"
 
+#include "turns/domain/participant.hpp"
+
+#include <compare>
+
+#include <glibmm/refptr.h>
+
 namespace turns::domain
 {
 
   namespace
   {
-    auto constexpr comparator = [](auto lhs, auto rhs){
+    auto constexpr comparator = [](auto lhs, auto rhs) {
       auto result = *lhs <=> *rhs;
-      if(result == std::partial_ordering::equivalent || result == std::partial_ordering::unordered)
+      if (result == std::partial_ordering::equivalent || result == std::partial_ordering::unordered)
       {
         return 0;
       }
-      else if(result == std::partial_ordering::less)
+      else if (result == std::partial_ordering::less)
       {
         return 1;
       }
       return -1;
     };
-  }
+  }  // namespace
 
   auto turn_order::create() -> Glib::RefPtr<turn_order>
   {
diff --git a/domain/tests/participant.cpp b/domain/tests/participant.cpp
index f6abef9..e9e7c46 100644
--- a/domain/tests/participant.cpp
+++ b/domain/tests/participant.cpp
@@ -2,10 +2,10 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-#include <glibmm/init.h>
-
 #include <compare>
 
+#include <glibmm/init.h>
+
 namespace turns::domain::tests
 {
 
diff --git a/lang/tests/messages.cpp b/lang/tests/messages.cpp
index 57a32f1..df991d6 100644
--- a/lang/tests/messages.cpp
+++ b/lang/tests/messages.cpp
@@ -13,23 +13,22 @@ namespace turns::lang::tests
 
   TEST_CASE("Translated messages")
   {
-    auto message = GENERATE(
-        add_participant,
-        clear,
-        disposition,
-        delete_participant,
-        edit_participant,
-        finish,
-        main_menu,
-        mark_as_defeated,
-        // name, a better solution is required to test this entry.
-        no_active_turn_order,
-        priority,
-        priority_number,
-        quit,
-        start_turn_order,
-        turns
-    );
+    auto message = GENERATE(add_participant,
+                            clear,
+                            disposition,
+                            delete_participant,
+                            edit_participant,
+                            finish,
+                            main_menu,
+                            mark_as_defeated,
+                            // a better solution is required to test the following entry:
+                            // name,
+                            no_active_turn_order,
+                            priority,
+                            priority_number,
+                            quit,
+                            start_turn_order,
+                            turns);
 
     auto locale = GENERATE("de_CH.UTF-8", "de_DE.UTF-8", "de_AT.UTF-8");