Code cleaning

Author: MorganCaron

README.md

@@ -40,7 +40,7 @@
 
 ### 🚀 Execution
 - [`Event`](modules/Execution/Event.mpp) - An event for thread synchronization
-- [`EventSystem`](modules/Execution/EventSystem.mpp) - Event system to subscribe functions and trigger actions by event name
+- [`EventDispatcher`](modules/Execution/EventDispatcher.mpp) - Event system to subscribe functions and trigger actions by event name
 
 ### 📁 File System
 - [`Watcher`](modules/FileSystem/Watcher.mpp) - File modification watcher

modules/Execution/EventSystem.mpp modules/Execution/EventDispatcher.mppmodules/Execution/EventSystem.mpp renamed to modules/Execution/EventDispatcher.mpp

@@ -1,22 +1,20 @@
-export module CppUtils.Execution.EventSystem;
+export module CppUtils.Execution.EventDispatcher;
 
 import std;
 import CppUtils.Type.Callable;
 import CppUtils.String.Hash;
 
 export namespace CppUtils::Execution
 {
-	class EventSystem final
+	class EventDispatcher final
 	{
 		using Key = std::pair<String::Hash, std::type_index>;
 
 	public:
-		template<String::Hasher eventName = String::Hash{}>
-		inline auto emit(const auto& event = nullptr) -> void
+		template<String::Hasher eventName = String::Hash{}, class Event = std::nullptr_t>
+		inline auto emit(const Event& event = nullptr) -> void
 		{
-			using Event = std::remove_cvref_t<decltype(event)>;
 			auto lockGuard = std::shared_lock{m_mutex};
-
 			auto key = std::make_pair(static_cast<String::Hash>(eventName), std::type_index{typeid(Event)});
 			if (auto subscriberIt = m_subscribers.find(key); subscriberIt == std::cend(m_subscribers))
 				return;
@@ -32,7 +30,7 @@ export namespace CppUtils::Execution
 			using FunctionInformations = Type::CallableTrait<FunctionType>;
 			using ArgumentsTypes = FunctionInformations::ArgumentsTypes;
 			constexpr auto nbArguments = std::tuple_size_v<ArgumentsTypes>;
-			static_assert(nbArguments == 1, "EventSystem: subscribed callable must take exactly one argument");
+			static_assert(nbArguments == 1, "EventDispatcher: subscribed callable must take exactly one argument");
 			using Event = std::remove_cvref_t<std::tuple_element_t<0, ArgumentsTypes>>;
 
 			auto lockGuard = std::unique_lock{m_mutex};

modules/Execution/Execution.mpp

@@ -1,4 +1,4 @@
 export module CppUtils.Execution;
 
 export import CppUtils.Execution.Event;
-export import CppUtils.Execution.EventSystem;
+export import CppUtils.Execution.EventDispatcher;

modules/Terminal/Area.mpp

@@ -2,15 +2,16 @@ export module CppUtils.Terminal.Area;
 
 import std;
 import CppUtils.Container.Size;
-export import :AreaBuffer;
 export import CppUtils.Terminal.CharAttributes;
-export import :Widget;
+export import :AreaBuffer;
 export import :Viewport;
+export import :Widget;
+export import :WidgetManager;
 export import :WritableAreaView;
 
 export namespace CppUtils::Terminal
 {
-	class Area: public AreaBuffer, public Widget
+	class Area: public Widget, public AreaBuffer
 	{
 	public:
 		inline Area(const Container::Size2& size, const Viewport& viewport = {{0, 0}, {0, 0}}):
@@ -20,6 +21,7 @@ export namespace CppUtils::Terminal
 
 		inline auto addWidget(std::unique_ptr<Widget> widget) -> void
 		{
+			widget->setWidgetManager(m_widgetManager);
 			m_widget = std::move(widget);
 		}
 
@@ -60,11 +62,13 @@ export namespace CppUtils::Terminal
 			// Draw scrollbars
 			// Apply to view (applique la portion délimitée par viewport du buffer sur view)
 			// view.applyArea(m_widget->getBuffer(), m_viewport);
+			drawFinished();
 		}
 
 	protected:
 		bool m_fullRenderRequested = true;
 		Viewport m_viewport;
 		std::unique_ptr<Widget> m_widget;
+		WidgetManager m_widgetManager;
 	};
 }

modules/Terminal/Canvas.mpp

@@ -13,9 +13,6 @@ import CppUtils.Terminal.Area;
 import CppUtils.Terminal.TextStyle;
 import CppUtils.Terminal.TextColor;
 import CppUtils.Terminal.BackgroundColor;
-import CppUtils.Execution.Event;
-import CppUtils.Thread.Scheduler;
-import CppUtils.Execution.EventSystem;
 
 export namespace CppUtils::Terminal
 {
@@ -107,6 +104,10 @@ export namespace CppUtils::Terminal
 				Area{size, optionalViewport.value_or(Viewport{size, {0, 0}})},
 				m_previousBuffer{size}
 			{
+				m_widgetManager.eventDispatcher.subscribe<"RequestUpdate">([this](std::nullptr_t) -> void {
+					print();
+				});
+				setWidgetManager(m_widgetManager);
 				setConsoleOutputUTF8();
 				enableAnsi();
 			}
@@ -175,37 +176,31 @@ export namespace CppUtils::Terminal
 					auto view = WritableAreaView{*this, m_viewport};
 					m_widget->draw(view);
 				}
-				if (m_forceReprint)
+				if (m_firstPrint)
 				{
 					std::print("{}", std::string(m_viewport.getSize().height(), '\n'));
-					m_forceReprint = false;
+					m_firstPrint = false;
 				}
 				applyDifferences();
 			}
 
-			inline auto reprint() noexcept -> void
-			{
-				m_forceReprint = true;
-				print();
-			}
-
 			inline auto wait() noexcept -> void
 			{
 				print();
-				m_stopEvent.wait();
+				m_stopEvent.wait(false);
 			}
 
 			inline auto close() noexcept -> void
 			{
-				m_stopEvent.notify();
+				m_stopEvent.store(true, std::memory_order_release);
+				m_stopEvent.notify_all();
 			}
 
 		private:
-			bool m_forceReprint = true;
+			bool m_firstPrint = true;
+			std::atomic_bool m_stopEvent = false;
 			AreaBuffer m_previousBuffer;
-			Execution::Event m_stopEvent;
-			Thread::Scheduler m_scheduler;
-			Execution::EventSystem m_eventSystem;
+			WidgetManager m_widgetManager;
 		};
 	}
 }

modules/Terminal/Layout.mpp

@@ -8,7 +8,7 @@ export namespace CppUtils::Terminal
 	class Layout: public Widget
 	{
 	public:
-		inline virtual ~Layout() = default;
+		virtual ~Layout() = default;
 
 		inline auto addWidget(std::unique_ptr<Widget> widget) -> void
 		{

modules/Terminal/Spinner.mpp

@@ -31,6 +31,8 @@ export namespace CppUtils::Terminal
 			view.applyArea(m_frames[m_frame]);
 			if (++m_frame == std::size(m_frames))
 				m_frame = 0;
+			drawFinished();
+			requestUpdate(m_duration);
 		}
 
 		[[nodiscard]] inline constexpr auto getSize() const noexcept -> const auto&

modules/Terminal/Widget.mpp

@@ -1,13 +1,44 @@
 export module CppUtils.Terminal.Area:Widget;
 
+import std;
+
+import :WidgetManager;
 import :WritableAreaView;
+import CppUtils.Chrono.Concept;
 
 export namespace CppUtils::Terminal
 {
 	class Widget
 	{
 	public:
-		inline virtual ~Widget() = default;
+		virtual ~Widget() = default;
 		virtual auto draw(WritableAreaView& view) noexcept -> void = 0;
+
+		inline auto drawFinished() noexcept -> void
+		{
+			m_needUpdate = false;
+		}
+
+		inline auto setWidgetManager(WidgetManager& widgetManager) noexcept -> void
+		{
+			m_widgetManagerRef = widgetManager;
+		}
+
+		[[nodiscard]] inline auto getWidgetManager() -> WidgetManager&
+		{
+			return m_widgetManagerRef.value().get();
+		}
+
+		inline auto requestUpdate(Chrono::Duration auto delay = std::chrono::milliseconds{10}) -> void
+		{
+			getWidgetManager().scheduler.schedule([this]() -> void {
+				m_needUpdate = true;
+				getWidgetManager().eventDispatcher.emit<"RequestUpdate">();
+			}, delay);
+		}
+
+	private:
+		std::atomic_bool m_needUpdate = true;
+		std::optional<std::reference_wrapper<WidgetManager>> m_widgetManagerRef = std::nullopt;
 	};
 }

modules/Terminal/WidgetManager.mpp

@@ -0,0 +1,15 @@
+export module CppUtils.Terminal.Area:WidgetManager;
+
+import std;
+
+import CppUtils.Thread.Scheduler;
+import CppUtils.Execution.EventDispatcher;
+
+export namespace CppUtils::Terminal
+{
+	struct WidgetManager final
+	{
+		Thread::Scheduler scheduler = {std::chrono::milliseconds{10}};
+		Execution::EventDispatcher eventDispatcher;
+	};
+}

modules/UnitTest/DummyObject.mpp

@@ -29,7 +29,7 @@ export namespace CppUtils::UnitTest
 			return m_moveCount;
 		}
 
-		inline virtual ~DummyObject()
+		virtual ~DummyObject()
 		{
 			Logger::print("{}~{}()\n", std::string(m_indentationLevel, '\t'), m_name);
 		}