cleanup

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

Author: pollend

include/nbl/ui/CClipboardManagerXCB.h

@@ -1,41 +1,36 @@
 #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/IClipboardManagerXCB.h"
 #include "nbl/ui/XCBConnection.h"
-
 namespace nbl::ui
 {
 
+class IWindowXCB;
+class XCBConnection;
+
 // details on XCB clipboard protocol: https://tronche.com/gui/x/icccm/sec-2.html#s-2
-class NBL_API2 CClipboardManagerXCB final : public IClipboardManager
+class NBL_API2 CClipboardManagerXCB final : public IClipboardManagerXCB
 {
-        using base_t = IClipboardManager;
     public:
         inline CClipboardManagerXCB(core::smart_refctd_ptr<XCBConnection>&& connect): 
-            m_xcbConnection(std::move(connect)) {}
+            IClipboardManagerXCB(),
+            m_connection(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);
+        void process(const IWindowXCB* window, xcb_generic_event_t* event) override;
     private:
-        core::smart_refctd_ptr<XCBConnection> m_xcbConnection;
-
-        struct {
-            std::string m_data;
-            std::vector<xcb_atom_t> m_formats;
-        } m_stagedClipboard;
-        
+        core::smart_refctd_ptr<XCBConnection> m_connection;
         std::mutex m_clipboardMutex;
         std::condition_variable m_clipboardResponseCV;
-        std::string m_clipboardResponse;
+        std::string m_clipboardResponse; // data sent to the clipboard by another application
+
+        std::string m_savedClipboard; // data saved to the clipboard for another application to read
 
         XCBConnection::XCBAtomToken<core::StringLiteral("CLIPBOARD")> m_CLIPBOARD;
         XCBConnection::XCBAtomToken<core::StringLiteral("TARGETS")> m_TARGETS;

include/nbl/ui/CCursorControlXCB.h

@@ -1,22 +1,20 @@
 #ifndef __NBL_SYSTEM_C_CURSOR_CONTROL_XCB_H_INCLUDED__
 #define __NBL_SYSTEM_C_CURSOR_CONTROL_XCB_H_INCLUDED__
 
+#ifdef _NBL_PLATFORM_LINUX_
 
 #include "nbl/ui/ICursorControl.h"
-#include "nbl/ui/XCBConnection.h"
-
-#ifdef _NBL_PLATFORM_LINUX_
 
 namespace nbl::ui
 {
+
+class XCBConnection;
 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)) {}
+        core::smart_refctd_ptr<XCBConnection>&& xcbConnection) : 
+            m_connection(std::move(xcbConnection)) {}
 
         void setVisible(bool visible) override;
         bool isVisible() const override;
@@ -26,6 +24,8 @@ class NBL_API2 CCursorControlXCB final : public ICursorControl
 
         SPosition getPosition() override;
         SRelativePosition getRelativePosition(IWindow* window) override;
+    private: 
+        core::smart_refctd_ptr<XCBConnection> m_connection;
 };
 }
 

include/nbl/ui/CWindowManagerXCB.h

@@ -84,7 +84,6 @@ class CWindowManagerXCB : public IWindowManager
     const XcbIcccm& getXcbIcccmFunctionTable() const { return m_xcbIcccm; }
 
 private:
-
 	Xcb m_xcb = Xcb("xcb"); // function tables
 	XcbIcccm m_xcbIcccm = XcbIcccm("xcb-icccm");
 };

include/nbl/ui/CWindowXCB.h

@@ -1,19 +1,20 @@
 #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/IClipboardManagerXCB.h"
 #include "nbl/ui/IWindowXCB.h"
 #include "nbl/ui/XCBConnection.h"
 
+#include <cstdlib>
+
 namespace nbl::ui
 {
 
-class CCursorControlXCB;
 class CWindowManagerXCB;
-class CClipboardManagerXCB;
+class XCBConnection;
+class CCursorControlXCB;
+class IClipboardManagerXCB;
 
 class NBL_API2 CWindowXCB final : public IWindowXCB
 {
@@ -25,7 +26,7 @@ class NBL_API2 CWindowXCB final : public IWindowXCB
 	// 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();
+		return m_connection->getRawConnection();
 	}
 
 	virtual IClipboardManager* getClipboardManager() override;
@@ -44,9 +45,9 @@ class NBL_API2 CWindowXCB final : public IWindowXCB
     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<XCBConnection> m_connection;
 	core::smart_refctd_ptr<CCursorControlXCB> m_cursorControl;
-	core::smart_refctd_ptr<CClipboardManagerXCB> m_clipboardManager;
+	core::smart_refctd_ptr<IClipboardManagerXCB> m_clipboardManager;
 
 	class CDispatchThread final : public system::IThreadHandler<CDispatchThread>
 	{

include/nbl/ui/IClipboardManagerXCB.h

@@ -0,0 +1,28 @@
+#ifndef _NBL_UI_I_CLIPBOARD_MANAGER_XCB_INCLUDED_
+#define _NBL_UI_I_CLIPBOARD_MANAGER_XCB_INCLUDED_
+
+#ifdef _NBL_PLATFORM_LINUX_
+
+#include "nbl/ui/IClipboardManager.h"
+
+namespace nbl::ui
+{
+class XCBConnection;
+
+// details on XCB clipboard protocol: https://tronche.com/gui/x/icccm/sec-2.html#s-2
+class NBL_API2 IClipboardManagerXCB : public IClipboardManager
+{
+    public:
+        IClipboardManagerXCB() : IClipboardManager() {}
+        virtual ~IClipboardManagerXCB() = default;
+
+        virtual std::string getClipboardText() = 0;
+        virtual bool setClipboardText(const std::string_view& data) = 0;
+        virtual void process(const IWindowXCB* window, xcb_generic_event_t* event) = 0;
+};
+
+}
+
+#endif
+
+#endif

include/nbl/ui/IWindowXCB.h

@@ -1,12 +1,14 @@
 #ifndef __NBL_I_WINDOW_XCB_H_INCLUDED__
 #define __NBL_I_WINDOW_XCB_H_INCLUDED__
 
+#ifdef _NBL_PLATFORM_LINUX_
+
 #include "nbl/core/util/bitflag.h"
+
 #include "nbl/ui/IWindow.h"
 #include "nbl/ui/XCBConnection.h"
-#include <xcb/xproto.h>
 
-#ifdef _NBL_PLATFORM_LINUX_
+#include <xcb/xproto.h>
 
 namespace nbl::ui
 {
@@ -22,7 +24,6 @@ class NBL_API2 IWindowXCB : public IWindow
 
         const void* getNativeHandle() const { return nullptr; }
         virtual xcb_window_t getXcbWindow() const = 0;
-        // virtual xcb_window_t getXcbRootWindow() const = 0;
         virtual xcb_connection_t* getXcbConnection() const = 0;
 
         virtual bool setWindowSize_impl(uint32_t width, uint32_t height) = 0;

include/nbl/ui/XCBConnection.h

@@ -29,7 +29,7 @@ class XCBConnection : public core::IReferenceCounted {
     virtual ~XCBConnection() override;
 
     template<core::StringLiteral Name> 
-    inline xcb_atom_t resolveXCBAtom(XCBAtomToken<Name>& token, bool only_if_exists = true, bool forced = false) const {
+    inline xcb_atom_t resolveAtom(XCBAtomToken<Name>& token, bool only_if_exists = true, bool forced = false) const {
         const auto& xcb = m_windowManager->getXcbFunctionTable();
         if(token.fetched && !forced) {
             return token.token;

src/nbl/ui/CClipboardManagerXCB.cpp

@@ -1,12 +1,12 @@
 
+#include "nbl/ui/CClipboardManagerXCB.h"
 #include "nbl/ui/XCBConnection.h"
+
 #include <mutex>
 #include <string>
 #include <vector>
-#include <xcb/xproto.h>
-#ifdef _NBL_PLATFORM_LINUX_
 
-#include "nbl/ui/CClipboardManagerXCB.h"
+#include <xcb/xproto.h>
 
 namespace nbl::ui
 {
@@ -24,23 +24,14 @@ namespace nbl::ui
 
     bool CClipboardManagerXCB::setClipboardText(const std::string_view& data) {
         std::lock_guard lk(m_clipboardMutex);
-        m_stagedClipboard.m_data = data;
-        m_stagedClipboard.m_formats = {
-            m_xcbConnection->resolveXCBAtom(m_formatUTF8_0),
-            m_xcbConnection->resolveXCBAtom(m_formatUTF8_1),
-            m_xcbConnection->resolveXCBAtom(m_formatUTF8_2),
-            m_xcbConnection->resolveXCBAtom(m_formatGTK),
-            m_xcbConnection->resolveXCBAtom(m_formatString),
-            m_xcbConnection->resolveXCBAtom(m_formatText),
-            m_xcbConnection->resolveXCBAtom(m_formatTextPlain)
-        };
+        m_savedClipboard = data;
         return true;
     }
 
     void CClipboardManagerXCB::process(const IWindowXCB* window, xcb_generic_event_t* event) {
-        const auto& xcb = m_xcbConnection->getXcbFunctionTable();
+        const auto& xcb = m_connection->getXcbFunctionTable();
 
-        auto TARGETS = m_xcbConnection->resolveXCBAtom(m_TARGETS);
+        auto TARGETS = m_connection->resolveAtom(m_TARGETS);
 
         switch(event->response_type & ~0x80) {
             // XCB_ATOM
@@ -52,13 +43,21 @@ namespace nbl::ui
                             std::vector<xcb_atom_t> targets;
                             {
                                 std::lock_guard lk(m_clipboardMutex);
-                                for(auto& format : m_stagedClipboard.m_formats) {
+                                for(auto& format : {
+                                    m_connection->resolveAtom(m_formatUTF8_0),
+                                    m_connection->resolveAtom(m_formatUTF8_1),
+                                    m_connection->resolveAtom(m_formatUTF8_2),
+                                    m_connection->resolveAtom(m_formatGTK),
+                                    m_connection->resolveAtom(m_formatString),
+                                    m_connection->resolveAtom(m_formatText),
+                                    m_connection->resolveAtom(m_formatTextPlain)
+                                }) {
                                     targets.push_back(format);
                                 }
                             }
-                            targets.push_back(m_xcbConnection->resolveXCBAtom(m_TARGETS));
+                            targets.push_back(m_connection->resolveAtom(m_TARGETS));
                             xcb.pxcb_change_property(
-                                m_xcbConnection->getRawConnection(),
+                                m_connection->getRawConnection(),
                                 XCB_PROP_MODE_REPLACE,
                                 sne->requestor,
                                 sne->property,
@@ -69,14 +68,14 @@ namespace nbl::ui
                     } else {
                         std::lock_guard lk(m_clipboardMutex);
                         xcb.pxcb_change_property(
-                            m_xcbConnection->getRawConnection(),
+                            m_connection->getRawConnection(),
                             XCB_PROP_MODE_REPLACE,
                             sne->requestor,
                             sne->property,
                             sne->target,
                             8,
-                            m_stagedClipboard.m_data.size(),
-                            m_stagedClipboard.m_data.data());
+                            m_savedClipboard.size(),
+                            m_savedClipboard.data());
                     }
                 }
 
@@ -91,22 +90,21 @@ namespace nbl::ui
                 notify.target        = sne->target;
                 notify.property      = sne->property;
 
-                xcb.pxcb_send_event(m_xcbConnection->getRawConnection(), false,
+                xcb.pxcb_send_event(m_connection->getRawConnection(), false,
                             sne->requestor,
                             XCB_EVENT_MASK_NO_EVENT, // SelectionNotify events go without mask
                             (const char*)&notify);
 
-                xcb.pxcb_flush(m_xcbConnection->getRawConnection());
+                xcb.pxcb_flush(m_connection->getRawConnection());
                 break;
             }
             // Someone else has new content in the clipboard, so is
             // notifying us that we should delete our data now.
             case XCB_SELECTION_CLEAR: {
                 auto* sne = reinterpret_cast<xcb_selection_clear_event_t*>(event);
-                if (sne->selection == m_xcbConnection->resolveXCBAtom(m_CLIPBOARD)) {
+                if (sne->selection == m_connection->resolveAtom(m_CLIPBOARD)) {
                     std::lock_guard<std::mutex> lock(m_clipboardMutex);
-                    m_stagedClipboard.m_formats = {};
-                    m_stagedClipboard.m_data = std::string();
+                    m_savedClipboard = std::string();
                 }
                 break;
             }
@@ -119,17 +117,17 @@ namespace nbl::ui
                     if(sne->target != TARGETS) {
                         fieldType = sne->target;
                     }
-                    xcb_get_property_cookie_t cookie = xcb.pxcb_get_property(m_xcbConnection->getRawConnection(), true, 
+                    xcb_get_property_cookie_t cookie = xcb.pxcb_get_property(m_connection->getRawConnection(), true, 
                         sne->requestor,
                         sne->property, 
                         fieldType, 0, 0x1fffffff); // 0x1fffffff = INT32_MAX / 4
                     if(xcb_get_property_reply_t* reply =
-                        xcb.pxcb_get_property_reply(m_xcbConnection->getRawConnection(), cookie, nullptr)) {
+                        xcb.pxcb_get_property_reply(m_connection->getRawConnection(), cookie, nullptr)) {
                         core::SRAIIBasedExiter exitReply([reply]() -> void { 
                             free(reply);
                         });
 
-                        if(reply->type == m_xcbConnection->resolveXCBAtom(m_INCR)) {
+                        if(reply->type == m_connection->resolveAtom(m_INCR)) {
                             assert(false); // TODO
                         } else {
                             const auto* src = reinterpret_cast<const char*>(xcb.pxcb_get_property_value(reply));
@@ -146,6 +144,4 @@ namespace nbl::ui
             }
         }
     }
-}
-
-#endif
+}