xwayland: move to hyprland impl (#6086)

8 files changed, 89 insertions, 116 deletions

diff --git a/src/managers/CursorManager.cpp b/src/managers/CursorManager.cpp
index ea36b9b2..c9783844 100644
--- a/src/managers/CursorManager.cpp
+++ b/src/managers/CursorManager.cpp
@@ -2,6 +2,7 @@
 #include "Compositor.hpp"
 #include "../config/ConfigValue.hpp"
 #include "PointerManager.hpp"
+#include "../xwayland/XWayland.hpp"
 
 extern "C" {
 #include <wlr/interfaces/wlr_buffer.h>
@@ -246,14 +247,14 @@ SCursorImageData CCursorManager::dataFor(const std::string& name) {
     return IMAGES.images[0];
 }
 
-void CCursorManager::setXWaylandCursor(wlr_xwayland* xwayland) {
+void CCursorManager::setXWaylandCursor() {
     const auto CURSOR = dataFor("left_ptr");
     if (CURSOR.surface) {
-        wlr_xwayland_set_cursor(xwayland, cairo_image_surface_get_data(CURSOR.surface), cairo_image_surface_get_stride(CURSOR.surface), CURSOR.size, CURSOR.size, CURSOR.hotspotX,
-                                CURSOR.hotspotY);
+        g_pXWayland->setCursor(cairo_image_surface_get_data(CURSOR.surface), cairo_image_surface_get_stride(CURSOR.surface), {CURSOR.size, CURSOR.size},
+                               {CURSOR.hotspotX, CURSOR.hotspotY});
     } else if (const auto XCURSOR = wlr_xcursor_manager_get_xcursor(m_pWLRXCursorMgr, "left_ptr", 1); XCURSOR) {
-        wlr_xwayland_set_cursor(xwayland, XCURSOR->images[0]->buffer, XCURSOR->images[0]->width * 4, XCURSOR->images[0]->width, XCURSOR->images[0]->height,
-                                XCURSOR->images[0]->hotspot_x, XCURSOR->images[0]->hotspot_y);
+        g_pXWayland->setCursor(XCURSOR->images[0]->buffer, XCURSOR->images[0]->width * 4, {XCURSOR->images[0]->width, XCURSOR->images[0]->height},
+                               {XCURSOR->images[0]->hotspot_x, XCURSOR->images[0]->hotspot_y});
     } else
         Debug::log(ERR, "CursorManager: no valid cursor for xwayland");
 }
diff --git a/src/managers/CursorManager.hpp b/src/managers/CursorManager.hpp
index b4c5232a..4ff9adeb 100644
--- a/src/managers/CursorManager.hpp
+++ b/src/managers/CursorManager.hpp
@@ -8,7 +8,6 @@
 
 struct wlr_buffer;
 struct wlr_xcursor_manager;
-struct wlr_xwayland;
 class CWLSurface;
 
 class CCursorManager {
@@ -25,7 +24,7 @@ class CCursorManager {
     void             changeTheme(const std::string& name, const int size);
     void             updateTheme();
     SCursorImageData dataFor(const std::string& name); // for xwayland
-    void             setXWaylandCursor(wlr_xwayland* xwayland);
+    void             setXWaylandCursor();
 
     void             tickAnimatedCursor();
 
diff --git a/src/managers/ProtocolManager.cpp b/src/managers/ProtocolManager.cpp
index c43e4c56..feff69e0 100644
--- a/src/managers/ProtocolManager.cpp
+++ b/src/managers/ProtocolManager.cpp
@@ -31,6 +31,7 @@
 #include "../protocols/XDGShell.hpp"
 #include "../protocols/DataDeviceWlr.hpp"
 #include "../protocols/PrimarySelection.hpp"
+#include "../protocols/XWaylandShell.hpp"
 
 #include "../protocols/core/Seat.hpp"
 #include "../protocols/core/DataDevice.hpp"
@@ -73,6 +74,7 @@ CProtocolManager::CProtocolManager() {
     PROTO::xdgShell            = std::make_unique<CXDGShellProtocol>(&xdg_wm_base_interface, 6, "XDGShell");
     PROTO::dataWlr             = std::make_unique<CDataDeviceWLRProtocol>(&zwlr_data_control_manager_v1_interface, 2, "DataDeviceWlr");
     PROTO::primarySelection    = std::make_unique<CPrimarySelectionProtocol>(&zwp_primary_selection_device_manager_v1_interface, 1, "PrimarySelection");
+    PROTO::xwaylandShell       = std::make_unique<CXWaylandShellProtocol>(&xwayland_shell_v1_interface, 1, "XWaylandShell");
 
     // Old protocol implementations.
     // TODO: rewrite them to use hyprwayland-scanner.
diff --git a/src/managers/SeatManager.cpp b/src/managers/SeatManager.cpp
index bbbe01d4..ce40650d 100644
--- a/src/managers/SeatManager.cpp
+++ b/src/managers/SeatManager.cpp
@@ -498,6 +498,8 @@ void CSeatManager::setCurrentSelection(SP<IDataSource> source) {
         PROTO::data->setSelection(source);
         PROTO::dataWlr->setSelection(source, false);
     }
+
+    events.setSelection.emit();
 }
 
 void CSeatManager::setCurrentPrimarySelection(SP<IDataSource> source) {
@@ -521,6 +523,8 @@ void CSeatManager::setCurrentPrimarySelection(SP<IDataSource> source) {
         PROTO::primarySelection->setSelection(source);
         PROTO::dataWlr->setSelection(source, true);
     }
+
+    events.setPrimarySelection.emit();
 }
 
 void CSeatManager::setGrab(SP<CSeatGrab> grab) {
diff --git a/src/managers/SeatManager.hpp b/src/managers/SeatManager.hpp
index fee3efa9..b88058a8 100644
--- a/src/managers/SeatManager.hpp
+++ b/src/managers/SeatManager.hpp
@@ -106,6 +106,8 @@ class CSeatManager {
         CSignal pointerFocusChange;
         CSignal touchFocusChange;
         CSignal setCursor; // SSetCursorEvent
+        CSignal setSelection;
+        CSignal setPrimarySelection;
     } events;
 
     struct {
diff --git a/src/managers/XWaylandManager.cpp b/src/managers/XWaylandManager.cpp
index 390c6ece..4aebefcb 100644
--- a/src/managers/XWaylandManager.cpp
+++ b/src/managers/XWaylandManager.cpp
@@ -3,29 +3,14 @@
 #include "../events/Events.hpp"
 #include "../config/ConfigValue.hpp"
 #include "../protocols/XDGShell.hpp"
+#include "../xwayland/XWayland.hpp"
 
 #define OUTPUT_MANAGER_VERSION                   3
 #define OUTPUT_DONE_DEPRECATED_SINCE_VERSION     3
 #define OUTPUT_DESCRIPTION_MUTABLE_SINCE_VERSION 3
 
 CHyprXWaylandManager::CHyprXWaylandManager() {
-#ifndef NO_XWAYLAND
-    m_sWLRXWayland = wlr_xwayland_create(g_pCompositor->m_sWLDisplay, g_pCompositor->m_sWLRCompositor, 1);
-
-    if (!m_sWLRXWayland) {
-        Debug::log(ERR, "Couldn't start up the XWaylandManager because wlr_xwayland_create returned a nullptr!");
-        return;
-    }
-
-    addWLSignal(&m_sWLRXWayland->events.ready, &Events::listen_readyXWayland, m_sWLRXWayland, "XWayland Manager");
-    addWLSignal(&m_sWLRXWayland->events.new_surface, &Events::listen_surfaceXWayland, m_sWLRXWayland, "XWayland Manager");
-
-    setenv("DISPLAY", m_sWLRXWayland->display_name, 1);
-
-    Debug::log(LOG, "CHyprXWaylandManager started on display {}", m_sWLRXWayland->display_name);
-#else
-    unsetenv("DISPLAY"); // unset DISPLAY so that X11 apps do not try to start on a different/invalid DISPLAY
-#endif
+    ;
 }
 
 CHyprXWaylandManager::~CHyprXWaylandManager() {
@@ -42,24 +27,23 @@ void CHyprXWaylandManager::activateSurface(wlr_surface* pSurface, bool activate)
     if (!pSurface)
         return;
 
-    if (wlr_xwayland_surface_try_from_wlr_surface(pSurface)) {
-        const auto XSURF = wlr_xwayland_surface_try_from_wlr_surface(pSurface);
-        wlr_xwayland_surface_activate(XSURF, activate);
-
-        if (activate && !XSURF->override_redirect)
-            wlr_xwayland_surface_restack(XSURF, nullptr, XCB_STACK_MODE_ABOVE);
-    }
-
     // TODO:
     // this cannot be nicely done until we rewrite wlr_surface
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (w->m_bIsX11 || !w->m_bIsMapped)
+        if (!w->m_bIsMapped)
             continue;
 
         if (w->m_pWLSurface.wlr() != pSurface)
             continue;
 
-        w->m_pXDGSurface->toplevel->setActive(activate);
+        if (w->m_bIsX11) {
+            if (activate) {
+                w->m_pXWaylandSurface->setMinimized(false);
+                w->m_pXWaylandSurface->restackToTop();
+            }
+            w->m_pXWaylandSurface->activate(activate);
+        } else
+            w->m_pXDGSurface->toplevel->setActive(activate);
     }
 }
 
@@ -68,12 +52,12 @@ void CHyprXWaylandManager::activateWindow(PHLWINDOW pWindow, bool activate) {
         setWindowSize(pWindow, pWindow->m_vRealSize.value()); // update xwayland output pos
 
         if (activate) {
-            wlr_xwayland_surface_set_minimized(pWindow->m_uSurface.xwayland, false);
-            if (!pWindow->m_uSurface.xwayland->override_redirect)
-                wlr_xwayland_surface_restack(pWindow->m_uSurface.xwayland, nullptr, XCB_STACK_MODE_ABOVE);
+            pWindow->m_pXWaylandSurface->setMinimized(false);
+            if (pWindow->m_iX11Type != 2)
+                pWindow->m_pXWaylandSurface->restackToTop();
         }
 
-        wlr_xwayland_surface_activate(pWindow->m_uSurface.xwayland, activate);
+        pWindow->m_pXWaylandSurface->activate(activate);
     } else if (pWindow->m_pXDGSurface && pWindow->m_pXDGSurface->toplevel)
         pWindow->m_pXDGSurface->toplevel->setActive(activate);
 
@@ -88,7 +72,7 @@ void CHyprXWaylandManager::activateWindow(PHLWINDOW pWindow, bool activate) {
 
 void CHyprXWaylandManager::getGeometryForWindow(PHLWINDOW pWindow, CBox* pbox) {
     if (pWindow->m_bIsX11) {
-        const auto SIZEHINTS = pWindow->m_uSurface.xwayland->size_hints;
+        const auto SIZEHINTS = pWindow->m_pXWaylandSurface->sizeHints.get();
 
         if (SIZEHINTS && pWindow->m_iX11Type != 2) {
             pbox->x      = SIZEHINTS->x;
@@ -96,10 +80,7 @@ void CHyprXWaylandManager::getGeometryForWindow(PHLWINDOW pWindow, CBox* pbox) {
             pbox->width  = SIZEHINTS->width;
             pbox->height = SIZEHINTS->height;
         } else {
-            pbox->x      = pWindow->m_uSurface.xwayland->x;
-            pbox->y      = pWindow->m_uSurface.xwayland->y;
-            pbox->width  = pWindow->m_uSurface.xwayland->width;
-            pbox->height = pWindow->m_uSurface.xwayland->height;
+            *pbox = pWindow->m_pXWaylandSurface->geometry;
         }
     } else if (pWindow->m_pXDGSurface)
         *pbox = pWindow->m_pXDGSurface->current.geometry;
@@ -107,7 +88,7 @@ void CHyprXWaylandManager::getGeometryForWindow(PHLWINDOW pWindow, CBox* pbox) {
 
 void CHyprXWaylandManager::sendCloseWindow(PHLWINDOW pWindow) {
     if (pWindow->m_bIsX11)
-        wlr_xwayland_surface_close(pWindow->m_uSurface.xwayland);
+        pWindow->m_pXWaylandSurface->close();
     else if (pWindow->m_pXDGSurface && pWindow->m_pXDGSurface->toplevel)
         pWindow->m_pXDGSurface->toplevel->close();
 }
@@ -145,7 +126,7 @@ void CHyprXWaylandManager::setWindowSize(PHLWINDOW pWindow, Vector2D size, bool
     }
 
     if (pWindow->m_bIsX11)
-        wlr_xwayland_surface_configure(pWindow->m_uSurface.xwayland, windowPos.x, windowPos.y, size.x, size.y);
+        pWindow->m_pXWaylandSurface->configure({windowPos, size});
     else if (pWindow->m_pXDGSurface->toplevel)
         pWindow->m_vPendingSizeAcks.push_back(std::make_pair<>(pWindow->m_pXDGSurface->toplevel->setSize(size), size.floor()));
 }
@@ -156,45 +137,36 @@ wlr_surface* CHyprXWaylandManager::surfaceAt(PHLWINDOW pWindow, const Vector2D&
 
 bool CHyprXWaylandManager::shouldBeFloated(PHLWINDOW pWindow, bool pending) {
     if (pWindow->m_bIsX11) {
-        for (size_t i = 0; i < pWindow->m_uSurface.xwayland->window_type_len; i++)
-            if (pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DIALOG"] ||
-                pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_SPLASH"] ||
-                pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_TOOLBAR"] ||
-                pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_UTILITY"] ||
-                pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_TOOLTIP"] ||
-                pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_POPUP_MENU"] ||
-                pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DOCK"] ||
-                pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"] ||
-                pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_MENU"] ||
-                pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_KDE_NET_WM_WINDOW_TYPE_OVERRIDE"]) {
-
-                if (pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"] ||
-                    pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_MENU"])
+        for (auto& a : pWindow->m_pXWaylandSurface->atoms)
+            if (a == HYPRATOMS["_NET_WM_WINDOW_TYPE_DIALOG"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_SPLASH"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_TOOLBAR"] ||
+                a == HYPRATOMS["_NET_WM_WINDOW_TYPE_UTILITY"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_TOOLTIP"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_POPUP_MENU"] ||
+                a == HYPRATOMS["_NET_WM_WINDOW_TYPE_DOCK"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_MENU"] ||
+                a == HYPRATOMS["_KDE_NET_WM_WINDOW_TYPE_OVERRIDE"]) {
+
+                if (a == HYPRATOMS["_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_MENU"])
                     pWindow->m_bX11ShouldntFocus = true;
 
                 pWindow->m_bNoInitialFocus = true;
                 return true;
             }
 
-        if (pWindow->m_uSurface.xwayland->role) {
-            try {
-                std::string winrole = std::string(pWindow->m_uSurface.xwayland->role);
-                if (winrole.contains("pop-up") || winrole.contains("task_dialog")) {
-                    return true;
-                }
-            } catch (std::exception& e) { Debug::log(ERR, "Error in shouldBeFloated, winrole threw {}", e.what()); }
-        }
-
-        if (pWindow->m_uSurface.xwayland->modal) {
+        if (pWindow->m_pXWaylandSurface->modal) {
             pWindow->m_bIsModal = true;
             return true;
         }
 
-        if (pWindow->m_iX11Type == 2)
-            return true; // override_redirect
+        if (pWindow->m_pXWaylandSurface->transient)
+            return true;
+
+        if (pWindow->m_pXWaylandSurface->role.contains("task_dialog") || pWindow->m_pXWaylandSurface->role.contains("pop-up"))
+            return true;
 
-        const auto SIZEHINTS = pWindow->m_uSurface.xwayland->size_hints;
-        if (SIZEHINTS && (pWindow->m_uSurface.xwayland->parent || ((SIZEHINTS->min_width == SIZEHINTS->max_width) && (SIZEHINTS->min_height == SIZEHINTS->max_height))))
+        if (pWindow->m_pXWaylandSurface->overrideRedirect)
+            return true;
+
+        const auto SIZEHINTS = pWindow->m_pXWaylandSurface->sizeHints.get();
+        if (pWindow->m_pXWaylandSurface->transient || pWindow->m_pXWaylandSurface->parent ||
+            (SIZEHINTS && (SIZEHINTS->min_width == SIZEHINTS->max_width) && (SIZEHINTS->min_height == SIZEHINTS->max_height)))
             return true;
     } else {
         const auto PSTATE = pending ? &pWindow->m_pXDGSurface->toplevel->pending : &pWindow->m_pXDGSurface->toplevel->current;
@@ -207,28 +179,14 @@ bool CHyprXWaylandManager::shouldBeFloated(PHLWINDOW pWindow, bool pending) {
     return false;
 }
 
-void CHyprXWaylandManager::moveXWaylandWindow(PHLWINDOW pWindow, const Vector2D& pos) {
-    if (!validMapped(pWindow))
-        return;
-
-    if (!pWindow->m_bIsX11)
-        return;
-
-    wlr_xwayland_surface_configure(pWindow->m_uSurface.xwayland, pos.x, pos.y, pWindow->m_vRealSize.value().x, pWindow->m_vRealSize.value().y);
-}
-
 void CHyprXWaylandManager::checkBorders(PHLWINDOW pWindow) {
     if (!pWindow->m_bIsX11)
         return;
 
-    for (size_t i = 0; i < pWindow->m_uSurface.xwayland->window_type_len; i++) {
-        if (pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_POPUP_MENU"] ||
-            pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_NOTIFICATION"] ||
-            pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"] ||
-            pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_COMBO"] ||
-            pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_MENU"] ||
-            pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_SPLASH"] ||
-            pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_TOOLTIP"]) {
+    for (auto& a : pWindow->m_pXWaylandSurface->atoms) {
+        if (a == HYPRATOMS["_NET_WM_WINDOW_TYPE_POPUP_MENU"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_NOTIFICATION"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"] ||
+            a == HYPRATOMS["_NET_WM_WINDOW_TYPE_COMBO"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_MENU"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_SPLASH"] ||
+            a == HYPRATOMS["_NET_WM_WINDOW_TYPE_TOOLTIP"]) {
 
             pWindow->m_bX11DoesntWantBorders = true;
             return;
@@ -242,7 +200,7 @@ void CHyprXWaylandManager::checkBorders(PHLWINDOW pWindow) {
 
 void CHyprXWaylandManager::setWindowFullscreen(PHLWINDOW pWindow, bool fullscreen) {
     if (pWindow->m_bIsX11)
-        wlr_xwayland_surface_set_fullscreen(pWindow->m_uSurface.xwayland, fullscreen);
+        pWindow->m_pXWaylandSurface->setFullscreen(fullscreen);
     else if (pWindow->m_pXDGSurface && pWindow->m_pXDGSurface->toplevel)
         pWindow->m_pXDGSurface->toplevel->setFullscreen(fullscreen);
 }
@@ -251,10 +209,10 @@ Vector2D CHyprXWaylandManager::getMaxSizeForWindow(PHLWINDOW pWindow) {
     if (!validMapped(pWindow))
         return Vector2D(99999, 99999);
 
-    if ((pWindow->m_bIsX11 && !pWindow->m_uSurface.xwayland->size_hints) || (!pWindow->m_bIsX11 && !pWindow->m_pXDGSurface->toplevel) || pWindow->m_sAdditionalConfigData.noMaxSize)
+    if ((pWindow->m_bIsX11 && !pWindow->m_pXWaylandSurface->sizeHints) || (!pWindow->m_bIsX11 && !pWindow->m_pXDGSurface->toplevel) || pWindow->m_sAdditionalConfigData.noMaxSize)
         return Vector2D(99999, 99999);
 
-    auto MAXSIZE = pWindow->m_bIsX11 ? Vector2D(pWindow->m_uSurface.xwayland->size_hints->max_width, pWindow->m_uSurface.xwayland->size_hints->max_height) :
+    auto MAXSIZE = pWindow->m_bIsX11 ? Vector2D(pWindow->m_pXWaylandSurface->sizeHints->max_width, pWindow->m_pXWaylandSurface->sizeHints->max_height) :
                                        pWindow->m_pXDGSurface->toplevel->current.maxSize;
 
     if (MAXSIZE.x < 5)
@@ -269,10 +227,10 @@ Vector2D CHyprXWaylandManager::getMinSizeForWindow(PHLWINDOW pWindow) {
     if (!validMapped(pWindow))
         return Vector2D(0, 0);
 
-    if ((pWindow->m_bIsX11 && !pWindow->m_uSurface.xwayland->size_hints) || (!pWindow->m_bIsX11 && !pWindow->m_pXDGSurface->toplevel))
+    if ((pWindow->m_bIsX11 && !pWindow->m_pXWaylandSurface->sizeHints) || (!pWindow->m_bIsX11 && !pWindow->m_pXDGSurface->toplevel))
         return Vector2D(0, 0);
 
-    auto MINSIZE = pWindow->m_bIsX11 ? Vector2D(pWindow->m_uSurface.xwayland->size_hints->min_width, pWindow->m_uSurface.xwayland->size_hints->min_height) :
+    auto MINSIZE = pWindow->m_bIsX11 ? Vector2D(pWindow->m_pXWaylandSurface->sizeHints->min_width, pWindow->m_pXWaylandSurface->sizeHints->min_height) :
                                        pWindow->m_pXDGSurface->toplevel->current.minSize;
 
     MINSIZE = MINSIZE.clamp({1, 1});
diff --git a/src/managers/XWaylandManager.hpp b/src/managers/XWaylandManager.hpp
index 8889eb61..5bbab802 100644
--- a/src/managers/XWaylandManager.hpp
+++ b/src/managers/XWaylandManager.hpp
@@ -11,22 +11,19 @@ class CHyprXWaylandManager {
     CHyprXWaylandManager();
     ~CHyprXWaylandManager();
 
-    wlr_xwayland* m_sWLRXWayland = nullptr;
-
-    wlr_surface*  getWindowSurface(PHLWINDOW);
-    void          activateSurface(wlr_surface*, bool);
-    void          activateWindow(PHLWINDOW, bool);
-    void          getGeometryForWindow(PHLWINDOW, CBox*);
-    void          sendCloseWindow(PHLWINDOW);
-    void          setWindowSize(PHLWINDOW, Vector2D, bool force = false);
-    void          setWindowFullscreen(PHLWINDOW, bool);
-    wlr_surface*  surfaceAt(PHLWINDOW, const Vector2D&, Vector2D&);
-    bool          shouldBeFloated(PHLWINDOW, bool pending = false);
-    void          moveXWaylandWindow(PHLWINDOW, const Vector2D&);
-    void          checkBorders(PHLWINDOW);
-    Vector2D      getMaxSizeForWindow(PHLWINDOW);
-    Vector2D      getMinSizeForWindow(PHLWINDOW);
-    Vector2D      xwaylandToWaylandCoords(const Vector2D&);
+    wlr_surface* getWindowSurface(PHLWINDOW);
+    void         activateSurface(wlr_surface*, bool);
+    void         activateWindow(PHLWINDOW, bool);
+    void         getGeometryForWindow(PHLWINDOW, CBox*);
+    void         sendCloseWindow(PHLWINDOW);
+    void         setWindowSize(PHLWINDOW, Vector2D, bool force = false);
+    void         setWindowFullscreen(PHLWINDOW, bool);
+    wlr_surface* surfaceAt(PHLWINDOW, const Vector2D&, Vector2D&);
+    bool         shouldBeFloated(PHLWINDOW, bool pending = false);
+    void         checkBorders(PHLWINDOW);
+    Vector2D     getMaxSizeForWindow(PHLWINDOW);
+    Vector2D     getMinSizeForWindow(PHLWINDOW);
+    Vector2D     xwaylandToWaylandCoords(const Vector2D&);
 };
 
 inline std::unique_ptr<CHyprXWaylandManager> g_pXWaylandManager;
\ No newline at end of file
diff --git a/src/managers/input/InputManager.cpp b/src/managers/input/InputManager.cpp
index 52927d95..5a7688cd 100644
--- a/src/managers/input/InputManager.cpp
+++ b/src/managers/input/InputManager.cpp
@@ -661,7 +661,7 @@ void CInputManager::processMouseDownNormal(const IPointer::SButtonEvent& e) {
 
     // clicking on border triggers resize
     // TODO detect click on LS properly
-    if (*PRESIZEONBORDER && !m_bLastFocusOnLS && e.state == WL_POINTER_BUTTON_STATE_PRESSED) {
+    if (*PRESIZEONBORDER && !m_bLastFocusOnLS && e.state == WL_POINTER_BUTTON_STATE_PRESSED && (!w || w->m_iX11Type != 2)) {
         if (w && !w->m_bIsFullscreen) {
             const CBox real = {w->m_vRealPosition.value().x, w->m_vRealPosition.value().y, w->m_vRealSize.value().x, w->m_vRealSize.value().y};
             const CBox grab = {real.x - BORDER_GRAB_AREA, real.y - BORDER_GRAB_AREA, real.width + 2 * BORDER_GRAB_AREA, real.height + 2 * BORDER_GRAB_AREA};
@@ -674,7 +674,7 @@ void CInputManager::processMouseDownNormal(const IPointer::SButtonEvent& e) {
     }
 
     switch (e.state) {
-        case WL_POINTER_BUTTON_STATE_PRESSED:
+        case WL_POINTER_BUTTON_STATE_PRESSED: {
             if (*PFOLLOWMOUSE == 3) // don't refocus on full loose
                 break;
 
@@ -692,10 +692,16 @@ void CInputManager::processMouseDownNormal(const IPointer::SButtonEvent& e) {
             }
 
             // if clicked on a floating window make it top
-            if (g_pCompositor->m_pLastWindow.lock() && g_pCompositor->m_pLastWindow->m_bIsFloating)
-                g_pCompositor->changeWindowZOrder(g_pCompositor->m_pLastWindow.lock(), true);
+            if (!g_pSeatManager->state.pointerFocus)
+                break;
+
+            auto HLSurf = CWLSurface::surfaceFromWlr(g_pSeatManager->state.pointerFocus);
+
+            if (HLSurf && HLSurf->getWindow())
+                g_pCompositor->changeWindowZOrder(HLSurf->getWindow(), true);
 
             break;
+        }
         case WL_POINTER_BUTTON_STATE_RELEASED: break;
     }
 
@@ -1677,6 +1683,10 @@ void CInputManager::setCursorIconOnBorder(PHLWINDOW w) {
         return;
     }
 
+    // ignore X11 OR windows, they shouldn't be touched
+    if (w->m_bIsX11 && w->m_iX11Type == 2)
+        return;
+
     static auto PEXTENDBORDERGRAB = CConfigValue<Hyprlang::INT>("general:extend_border_grab_area");
     const int   BORDERSIZE        = w->getRealBorderSize();
     const int   ROUNDING          = w->rounding();