Window/Wayland: Fix Window

Author: MorganCaron

modules/System/System.mpp

@@ -73,14 +73,49 @@ export namespace CppUtils::System
 		return fileDescriptor;
 	}
 
-	[[nodiscard]] inline auto mapSharedMemory(FileDescriptor& fileDescriptor, std::size_t size) -> std::expected<std::uint8_t*, std::string_view>
+	struct MappedSharedMemory final
 	{
-		using namespace std::literals;
-		auto* data = static_cast<std::uint8_t*>(mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fileDescriptor.get(), 0));
-		if (data == MAP_FAILED)
-			return std::unexpected{"Failed to mmap"sv};
-		return data;
-	}
+		inline MappedSharedMemory() = default;
+
+		inline MappedSharedMemory(FileDescriptor& fileDescriptor, std::size_t size):
+			m_sharedMemory{static_cast<std::byte*>(mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fileDescriptor.get(), 0)), size}
+		{
+			if (std::data(m_sharedMemory) == MAP_FAILED)
+				throw std::runtime_error{"Failed to mmap"};
+		}
+
+		inline MappedSharedMemory(std::byte* data, std::size_t size):
+			m_sharedMemory{data, size}
+		{}
+
+		inline MappedSharedMemory(const MappedSharedMemory&) = delete;
+		inline MappedSharedMemory(MappedSharedMemory&& other) noexcept:
+			m_sharedMemory{std::exchange(other.m_sharedMemory, {})}
+		{}
+
+		inline MappedSharedMemory& operator=(const MappedSharedMemory&) = delete;
+		inline MappedSharedMemory& operator=(MappedSharedMemory&& other) noexcept
+		{
+			m_sharedMemory = std::exchange(other.m_sharedMemory, {});
+			return *this;
+		}
+
+		inline ~MappedSharedMemory()
+		{
+			munmap(std::data(m_sharedMemory), std::size(m_sharedMemory));
+		}
+
+		[[nodiscard]] inline auto get() const noexcept -> auto*
+		{
+			return std::data(m_sharedMemory);
+		}
+
+		[[nodiscard]] inline auto size() const noexcept -> auto
+		{
+			return std::size(m_sharedMemory);
+		}
 
+		std::span<std::byte> m_sharedMemory;
+	};
 #endif
 }

modules/Window/Wayland.mpp

@@ -0,0 +1,76 @@
+module;
+
+#include <CppUtils/System/OS.hpp>
+
+#if defined(OS_LINUX)
+#	include <unistd.h>
+#	include <sys/types.h>
+#	include <sys/mman.h>
+
+#	include <wayland-client-core.h>
+#	include <wayland-client-protocol.h>
+#	include <xdg-shell.h>
+// #	include <wayland-cursor.h>
+#endif
+
+export module CppUtils.Window.Wayland;
+
+import std;
+
+import CppUtils.Container.Size2d;
+import CppUtils.Logger;
+import CppUtils.Memory;
+import CppUtils.String;
+import CppUtils.System;
+
+#if defined(OS_LINUX)
+export namespace CppUtils::Window::Wayland
+{
+	using Display = Memory::UniquePtrWithDestructor<wl_display>;
+	using Registry = Memory::UniquePtrWithDestructor<wl_registry>;
+	using Compositor = Memory::UniquePtrWithDestructor<wl_compositor>;
+	using SharedMemory = Memory::UniquePtrWithDestructor<wl_shm>;
+	using SharedMemoryPool = Memory::UniquePtrWithDestructor<wl_shm_pool>;
+	using Surface = Memory::UniquePtrWithDestructor<wl_surface>;
+	using ShellSurface = Memory::UniquePtrWithDestructor<xdg_surface>;
+	using TopLevel = Memory::UniquePtrWithDestructor<xdg_toplevel>;
+	using Buffer = Memory::UniquePtrWithDestructor<wl_buffer>;
+	using WindowManagerBase = Memory::UniquePtrWithDestructor<xdg_wm_base>;
+
+	struct Globals final
+	{
+		Display display = {nullptr, wl_display_disconnect};
+		Registry registry = {nullptr, wl_registry_destroy};
+		Compositor compositor = {nullptr, wl_compositor_destroy};
+		SharedMemory sharedMemory = {nullptr, wl_shm_destroy};
+		WindowManagerBase windowManagerBase = {nullptr, xdg_wm_base_destroy};
+	};
+	inline auto globals = Globals{};
+
+	using RegisterHandler = std::function<void(wl_registry*, std::uint32_t, std::uint32_t)>;
+
+	template<class T>
+	inline auto makeHandlerPair(
+		const wl_interface& interface,
+		Memory::UniquePtrWithDestructor<T>& registerContainer,
+		std::uint32_t minVersion,
+		std::uint32_t maxVersion,
+		std::function<void()>&& callback = {}) -> std::pair<std::string_view, RegisterHandler>
+	{
+		return {
+			std::string_view{interface.name},
+			[&registerContainer,
+				&interface,
+				minVersion,
+				maxVersion,
+				callback = std::forward<decltype(callback)>(callback)](auto* registry, auto id, auto serverVersion) -> void {
+			using namespace std::literals;
+			if (serverVersion < minVersion)
+				throw std::runtime_error{interface.name + " trop ancien"s};
+			registerContainer.reset(static_cast<T*>(wl_registry_bind(registry, id, &interface, std::min(serverVersion, maxVersion))));
+			if (callback)
+				callback();
+		}};
+	}
+}
+#endif