EHS/src/io/Window_Way.cpp

#include "ehs/io/Window_Way.h"

namespace ehs
{
	void Window::SurfaceConfigure(void* data, xdg_surface* xdg_surface, UInt_32 serial)
	{
		xdg_surface_ack_configure(xdg_surface, serial);
	}

	void Window::ShellPing(void* data, xdg_wm_base* shell, UInt_32 serial)
	{
		xdg_wm_base_pong(shell, serial);
	}

	void Window::RegistryHandler(void* data, wl_registry* registry, UInt_32 id, const char* interface, UInt_32 version)
	{
		Serializer<UInt_64>* ser = (Serializer<UInt_64>*)data;

		if (Str_8::Cmp(interface, "wl_compositor"))
		{
			ser->SetOffset(0);
			wl_compositor** comp = ser->Read<wl_compositor**>();
			*comp = (wl_compositor*)wl_registry_bind(registry, id, &wl_compositor_interface, 1);
		}

		if (Str_8::Cmp(interface, "xdg_wm_base"))
		{
			ser->SetOffset(sizeof(void*));
			xdg_wm_base** base = ser->Read<xdg_wm_base**>();
			*base = (xdg_wm_base*)wl_registry_bind(registry, id, &xdg_wm_base_interface, 1);
		}
	}

	void Window::RegistryRemoved(void* data, wl_registry* registry, UInt_32 id)
	{
	}

	Window::~Window()
	{
		xdg_toplevel_destroy(xdgToplevel);
		xdg_surface_destroy(xdgSurface);
		xdg_wm_base_destroy(xdgShell);
		wl_surface_destroy(surface);
		wl_compositor_destroy(compositor);
		wl_registry_destroy(registry);
		wl_display_disconnect(display);
	}

	Window::Window()
		: display(nullptr), registry(nullptr), compositor(nullptr) , surface(nullptr)
	{
	}

	void Window::Create_32(const Str_32& title, const Vec2_s32& pos, const Vec2_u32 scale)
	{
		Create_8(UTF::To_8(title), pos, scale);
	}

	void Window::Create_16(const Str_16& title, const Vec2_s32& pos, const Vec2_u32 scale)
	{
		Create_8(UTF::To_8(title), pos, scale);
	}

	void Window::Create_8(const Str_8& title, const Vec2_s32& pos, const Vec2_u32 scale)
	{
		display = wl_display_connect(nullptr);
		if (!display)
		{
			EHS_LOG_INT(LogType::ERR, 0, "Failed to connect to display server.");
			return;
		}

		Serializer<UInt_64> data(Endianness::LE);
		data.Write(&compositor);
		data.Write(&xdgShell);

		static constexpr wl_registry_listener registry_listener = {
			RegistryHandler,
			RegistryRemoved
		};

		registry = wl_display_get_registry(display);
		wl_registry_add_listener(registry, &registry_listener, &data);

		wl_display_dispatch(display);
		wl_display_roundtrip(display);

		if (!compositor || !xdgShell)
		{
			EHS_LOG_INT(LogType::ERR, 1, "Can't find required interfaces.");
			return;
		}

		static constexpr xdg_wm_base_listener xdg_shell_listener = {ShellPing};

		xdg_wm_base_add_listener(xdgShell, &xdg_shell_listener, nullptr);

		surface = wl_compositor_create_surface(compositor);
		if (!surface)
		{
			EHS_LOG_INT(LogType::ERR, 2, "Can't create surface.");
			return;
		}

		xdgSurface = xdg_wm_base_get_xdg_surface(xdgShell, surface);
		xdgToplevel = xdg_surface_get_toplevel(xdgSurface);

		static constexpr xdg_surface_listener surfaceListener = {SurfaceConfigure};

		xdg_surface_add_listener(xdgSurface, &surfaceListener, nullptr);

		xdg_toplevel_set_title(xdgToplevel, title);
		wl_surface_commit(surface);
	}

	void Window::OnCreated()
	{
	}

	void Window::Close()
	{
		xdg_toplevel_destroy(xdgToplevel);
		xdgToplevel = nullptr;

		xdg_surface_destroy(xdgSurface);
		xdgSurface = nullptr;

		xdg_wm_base_destroy(xdgShell);
		xdgShell = nullptr;

		wl_surface_destroy(surface);
		surface = nullptr;

		wl_compositor_destroy(compositor);
		compositor = nullptr;

		wl_registry_destroy(registry);
		registry = nullptr;

		wl_display_disconnect(display);
		display = nullptr;
	}

	void Window::Show()
	{
	}

	void Window::Hide()
	{
	}

	bool Window::Poll()
	{
		wl_display_dispatch(display);

		return true;
	}

	void Window::ShowCursor(bool toggle)
	{
	}

	void Window::ConstrainCursor(const bool constrain)
	{
	}

	void Window::SetTitle_32(const Str_32& newTitle)
	{
	}

	Str_32 Window::GetTitle_32() const
	{
		return {};
	}

	void Window::SetTitle_16(const Str_16& newTitle)
	{
	}

	Str_16 Window::GetTitle_16() const
	{
		return {};
	}

	void Window::SetTitle_8(const Str_8& newTitle)
	{
	}

	Str_8 Window::GetTitle_8() const
	{
		return {};
	}

	void Window::SetPos(const Vec2_s32& newPos)
	{
	}

	Vec2_s32 Window::GetPos() const
	{
		return {};
	}

	void Window::SetScale(const Vec2_u32& newScale)
	{
	}

	Vec2_u32 Window::GetScale() const
	{
		return {};
	}

	Serializer<UInt_64> Window::GetClipboard()
	{
		return {};
	}

	void Window::SetClipboard(Serializer<UInt_64> data)
	{
	}

	void Window::SetCursorImg(const CursorImg img)
	{
	}
}