feature: implement xcb for windowing

Signed-off-by: Michael Pollind <mpollind@gmail.com>

Author: pollend

3rdparty/CMakeLists.txt

@@ -36,6 +36,8 @@ set(VOLK_PULL_IN_VULKAN OFF CACHE INTERNAL "" FORCE) # Needed to make sure vulka
 
 if (WIN32)
 	set(VOLK_STATIC_DEFINES VK_USE_PLATFORM_WIN32_KHR)
+elseif(UNIX AND NOT ANDROID AND NOT APPLE)
+	set(VOLK_STATIC_DEFINES VK_USE_PLATFORM_XCB_KHR)
 endif()
 add_subdirectory(volk volk EXCLUDE_FROM_ALL)
 

include/nbl/core/string/StringLiteral.h

@@ -4,6 +4,9 @@
 #ifndef _NBL_CORE_STRING_LITERAL_H_INCLUDED_
 #define _NBL_CORE_STRING_LITERAL_H_INCLUDED_
 
+#include <algorithm>
+#include <cstddef>
+
 namespace nbl::core
 {
 
@@ -15,6 +18,11 @@ struct StringLiteral
         std::copy_n(str, N, value);
     }
 
+    // the size includes the null terminator
+    constexpr size_t size() const {
+        return N;
+    }
+
     char value[N];
 };
 

include/nbl/ui/CClipboardManagerXcb.h

@@ -0,0 +1,63 @@
+#ifndef _NBL_UI_C_CLIPBOARD_MANAGER_XCB_INCLUDED_
+#define _NBL_UI_C_CLIPBOARD_MANAGER_XCB_INCLUDED_
+
+#include <string>
+#include <vector>
+#include <xcb/xproto.h>
+#ifdef _NBL_PLATFORM_LINUX_
+
+#include "nbl/core/decl/Types.h"
+#include "nbl/ui/IClipboardManager.h"
+#include "nbl/ui/XcbConnection.h"
+
+namespace nbl::ui
+{
+
+// details on XCB clipboard protocol: https://tronche.com/gui/x/icccm/sec-2.html#s-2
+class NBL_API2 CClipboardManagerXcb final : public IClipboardManager
+{
+		using base_t = IClipboardManager;
+	public:
+		inline CClipboardManagerXcb(core::smart_refctd_ptr<XcbConnection>&& connect): 
+			m_xcbConnection(std::move(connect)) {}
+
+		virtual std::string getClipboardText() override;
+		virtual bool setClipboardText(const std::string_view& data) override;
+
+		void process(const IWindowXcb* window, xcb_generic_event_t* event);
+	private:
+		core::smart_refctd_ptr<XcbConnection> m_xcbConnection;
+
+		xcb_window_t getClipboardWindow();
+
+		struct {
+			std::string m_data;
+			std::vector<xcb_atom_t> m_formats;
+		} m_stagedClipboard;
+		
+		std::mutex m_clipboardMutex;
+		std::condition_variable m_clipboardResponseCV;
+		std::string m_clipboardResponse;
+		// bool ready = false;
+
+		XcbConnection::XCBAtomToken<core::StringLiteral("CLIPBOARD")> m_CLIPBOARD;
+		XcbConnection::XCBAtomToken<core::StringLiteral("TARGETS")> m_TARGETS;
+		XcbConnection::XCBAtomToken<core::StringLiteral("INCR")> m_INCR;
+		
+
+		XcbConnection::XCBAtomToken<core::StringLiteral("UTF8_STRING")> m_formatUTF8_0;
+		XcbConnection::XCBAtomToken<core::StringLiteral("text/plain;charset=utf-8")> m_formatUTF8_1;
+		XcbConnection::XCBAtomToken<core::StringLiteral("text/plain;charset=UTF-8")> m_formatUTF8_2;
+		XcbConnection::XCBAtomToken<core::StringLiteral("GTK_TEXT_BUFFER_CONTENTS")> m_formatGTK;
+		XcbConnection::XCBAtomToken<core::StringLiteral("STRING")> m_formatString;
+		XcbConnection::XCBAtomToken<core::StringLiteral("TEXT")> m_formatText;
+		XcbConnection::XCBAtomToken<core::StringLiteral("text/plain")> m_formatTextPlain;
+		
+
+};
+
+}
+
+#endif
+
+#endif

include/nbl/ui/CCursorControlXcb.h

@@ -0,0 +1,34 @@
+#ifndef __NBL_SYSTEM_C_CURSOR_CONTROL_XCB_H_INCLUDED__
+#define __NBL_SYSTEM_C_CURSOR_CONTROL_XCB_H_INCLUDED__
+
+
+#include "nbl/ui/ICursorControl.h"
+#include "nbl/ui/XcbConnection.h"
+
+#ifdef _NBL_PLATFORM_LINUX_
+
+namespace nbl::ui
+{
+class NBL_API2 CCursorControlXcb final : public ICursorControl
+{
+        core::smart_refctd_ptr<XcbConnection> m_xcbConnection;
+
+    public:
+        inline CCursorControlXcb(
+            core::smart_refctd_ptr<XcbConnection>&& xcbConnection) : 
+            m_xcbConnection(std::move(xcbConnection)) {}
+
+        void setVisible(bool visible) override;
+        bool isVisible() const override;
+
+        void setPosition(SPosition pos) override;
+        void setRelativePosition(IWindow* window, SRelativePosition pos) override;
+
+        SPosition getPosition() override;
+        SRelativePosition getRelativePosition(IWindow* window) override;
+};
+}
+
+#endif
+
+#endif

include/nbl/ui/CWindowManagerXcb.h

@@ -0,0 +1,95 @@
+#ifndef C_WINDOW_MANAGER_XCB
+#define C_WINDOW_MANAGER_XCB
+
+#ifdef _NBL_PLATFORM_LINUX_
+#include "nbl/core/decl/Types.h"
+
+#include "nbl/system/DefaultFuncPtrLoader.h"
+
+#include "nbl/ui/IWindow.h"
+#include "nbl/ui/IWindowManager.h"
+
+#include <functional>
+#include <memory>
+#include <string>
+
+#include <xcb/xcb.h>
+#include <xcb/xcb_icccm.h>
+#include <xcb/xproto.h>
+
+namespace nbl::ui
+{
+
+NBL_SYSTEM_DECLARE_DYNAMIC_FUNCTION_CALLER_CLASS(Xcb, system::DefaultFuncPtrLoader,
+    xcb_destroy_window,
+    xcb_generate_id,
+    xcb_create_window,
+    xcb_connect,
+    xcb_disconnect,
+    xcb_map_window,
+    xcb_get_setup,
+    xcb_setup_roots_iterator,
+    xcb_flush,
+    xcb_intern_atom,
+    xcb_intern_atom_reply,
+    xcb_unmap_window,
+    xcb_get_property,
+    xcb_get_property_reply,
+    xcb_get_property_value_length,
+    xcb_change_property,
+    xcb_configure_window_checked,
+    xcb_get_property_value,
+    xcb_wait_for_event,
+    xcb_send_event,
+    xcb_request_check,
+    xcb_delete_property,
+    xcb_change_window_attributes,
+    xcb_warp_pointer,
+    xcb_query_pointer,
+    xcb_query_pointer_reply,
+    xcb_get_selection_owner_reply,
+    xcb_get_selection_owner
+);
+
+NBL_SYSTEM_DECLARE_DYNAMIC_FUNCTION_CALLER_CLASS(XcbIcccm, system::DefaultFuncPtrLoader,
+    xcb_icccm_set_wm_hints,
+    xcb_icccm_size_hints_set_size,
+    xcb_icccm_size_hints_set_min_size,
+    xcb_icccm_size_hints_set_max_size,
+    xcb_icccm_set_wm_normal_hints
+);
+
+class CWindowManagerXcb : public IWindowManager
+{
+public:
+
+	virtual bool setWindowSize_impl(IWindow* window, uint32_t width, uint32_t height) override;
+	virtual bool setWindowPosition_impl(IWindow* window, int32_t x, int32_t y) override;
+	virtual bool setWindowRotation_impl(IWindow* window, bool landscape) override;
+	virtual bool setWindowVisible_impl(IWindow* window, bool visible) override;
+	virtual bool setWindowMaximized_impl(IWindow* window, bool maximized) override;
+
+	inline SDisplayInfo getPrimaryDisplayInfo() const override final {
+		return SDisplayInfo();
+	}
+
+    CWindowManagerXcb();
+    ~CWindowManagerXcb() override = default;
+
+	virtual core::smart_refctd_ptr<IWindow> createWindow(IWindow::SCreationParams&& creationParams) override;
+
+	virtual void destroyWindow(IWindow* wnd) override final {}
+
+    const Xcb& getXcbFunctionTable() const { return m_xcb; }
+    const XcbIcccm& getXcbIcccmFunctionTable() const { return m_xcbIcccm; }
+
+private:
+
+	Xcb m_xcb = Xcb("xcb"); // function tables
+	XcbIcccm m_xcbIcccm = XcbIcccm("xcb-icccm");
+};
+
+
+}
+#endif
+#endif

include/nbl/ui/CWindowXcb.h

@@ -0,0 +1,85 @@
+#ifndef __C_WINDOW_XCB_H_INCLUDED__
+#define __C_WINDOW_XCB_H_INCLUDED__
+
+#include <cstdlib>
+
+#include "nbl/core/decl/smart_refctd_ptr.h"
+#include "nbl/ui/CClipboardManagerXcb.h"
+#include "nbl/ui/IWindowXcb.h"
+#include "nbl/ui/XcbConnection.h"
+
+namespace nbl::ui
+{
+
+class CCursorControlXcb;
+class CWindowManagerXcb;
+class CClipboardManagerXcb;
+
+class NBL_API2 CWindowXcb final : public IWindowXcb
+{
+	
+public:
+	CWindowXcb(core::smart_refctd_ptr<CWindowManagerXcb>&& winManager, SCreationParams&& params);
+	~CWindowXcb();
+
+	// Display* getDisplay() const override { return m_dpy; }
+	xcb_window_t getXcbWindow() const override { return m_xcbWindow; }
+	xcb_connection_t* getXcbConnection() const override {
+		return m_xcbConnection->getRawConnection();
+	}
+
+	virtual IClipboardManager* getClipboardManager() override;
+	virtual ICursorControl* getCursorControl() override;
+	virtual IWindowManager* getManager() override;
+
+	virtual bool setWindowSize_impl(uint32_t width, uint32_t height) override;
+	virtual bool setWindowPosition_impl(int32_t x, int32_t y) override;
+	virtual bool setWindowRotation_impl(bool landscape) override;
+	virtual bool setWindowVisible_impl(bool visible) override;
+	virtual bool setWindowMaximized_impl(bool maximized) override;
+
+	virtual void setCaption(const std::string_view& caption) override;
+	
+private:
+    CWindowXcb(core::smart_refctd_ptr<system::ISystem>&& sys, uint32_t _w, uint32_t _h, E_CREATE_FLAGS _flags);
+	
+	core::smart_refctd_ptr<CWindowManagerXcb> m_windowManager;
+	core::smart_refctd_ptr<XcbConnection> m_xcbConnection;
+	core::smart_refctd_ptr<CCursorControlXcb> m_cursorControl;
+	core::smart_refctd_ptr<CClipboardManagerXcb> m_clipboardManager;
+
+	class CDispatchThread final : public system::IThreadHandler<CDispatchThread>
+	{
+	public:
+
+		inline CDispatchThread(CWindowXcb& window);
+		inline ~CDispatchThread() {
+		}
+
+		void init();
+		void exit();
+		void work(lock_t& lock);
+
+		inline bool wakeupPredicate() const { return true; }
+		inline bool continuePredicate() const { return true; }
+	private:
+		CWindowXcb& m_window;
+		// xcb_connection_t* m_connection = nullptr;
+		friend class CWindowXcb;
+	} m_dispatcher;
+
+	xcb_window_t m_xcbWindow = 0;
+
+	XcbConnection::XCBAtomToken<core::StringLiteral("WM_DELETE_WINDOW")> m_WM_DELETE_WINDOW;
+	XcbConnection::XCBAtomToken<core::StringLiteral("WM_PROTOCOLS")> m_WM_PROTOCOLS;
+	XcbConnection::XCBAtomToken<core::StringLiteral("_NET_WM_PING")> m_NET_WM_PING;
+	
+	XcbConnection::XCBAtomToken<core::StringLiteral("_NET_WM_STATE_MAXIMIZED_VERT")> m_NET_WM_STATE_MAXIMIZED_VERT;
+	XcbConnection::XCBAtomToken<core::StringLiteral("_NET_WM_STATE_MAXIMIZED_HORZ")> m_NET_WM_STATE_MAXIMIZED_HORZ;
+	XcbConnection::XCBAtomToken<core::StringLiteral("_NET_WM_STATE_FULLSCREEN")> m_NET_WM_STATE_FULLSCREEN;
+
+};
+
+}
+
+#endif