cursor: move to a hyprland impl

This moves wlr_cursor to a completely new impl mostly under
CPointerManager

Also adds beginSimple to OpenGL for simple render passes (e.g. cursor)

src/Compositor.cpp

@@ -3,6 +3,7 @@
 #include "config/ConfigValue.hpp"
 #include "managers/CursorManager.hpp"
 #include "managers/TokenManager.hpp"
+#include "managers/PointerManager.hpp"
 #include "managers/eventLoop/EventLoopManager.hpp"
 #include <random>
 #include <unordered_set>
@@ -227,13 +228,8 @@ void CCompositor::initServer() {
     wlr_primary_selection_v1_device_manager_create(m_sWLDisplay);
     wlr_viewporter_create(m_sWLDisplay);
 
-    m_sWLROutputLayout = wlr_output_layout_create(m_sWLDisplay);
-
     m_sWLRXDGShell = wlr_xdg_shell_create(m_sWLDisplay, 6);
 
-    m_sWLRCursor = wlr_cursor_create();
-    wlr_cursor_attach_output_layout(m_sWLRCursor, m_sWLROutputLayout);
-
     m_sSeat.seat = wlr_seat_create(m_sWLDisplay, "seat0");
 
     m_sWLRPresentation = wlr_presentation_create(m_sWLDisplay, m_sWLRBackend);
@@ -246,7 +242,7 @@ void CCompositor::initServer() {
         Debug::log(INFO, "VR will not be available");
     }
 
-    m_sWLRTabletManager = wlr_tablet_v2_create(m_sWLDisplay);
+    // m_sWLRTabletManager = wlr_tablet_v2_create(m_sWLDisplay);
 
     m_sWLRForeignRegistry = wlr_xdg_foreign_registry_create(m_sWLDisplay);
 
@@ -270,23 +266,6 @@ void CCompositor::initServer() {
 void CCompositor::initAllSignals() {
     addWLSignal(&m_sWLRBackend->events.new_output, &Events::listen_newOutput, m_sWLRBackend, "Backend");
     addWLSignal(&m_sWLRXDGShell->events.new_toplevel, &Events::listen_newXDGToplevel, m_sWLRXDGShell, "XDG Shell");
-    addWLSignal(&m_sWLRCursor->events.motion, &Events::listen_mouseMove, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.motion_absolute, &Events::listen_mouseMoveAbsolute, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.button, &Events::listen_mouseButton, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.axis, &Events::listen_mouseAxis, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.frame, &Events::listen_mouseFrame, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.swipe_begin, &Events::listen_swipeBegin, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.swipe_update, &Events::listen_swipeUpdate, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.swipe_end, &Events::listen_swipeEnd, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.pinch_begin, &Events::listen_pinchBegin, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.pinch_update, &Events::listen_pinchUpdate, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.pinch_end, &Events::listen_pinchEnd, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.touch_down, &Events::listen_touchBegin, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.touch_up, &Events::listen_touchEnd, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.touch_motion, &Events::listen_touchUpdate, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.touch_frame, &Events::listen_touchFrame, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.hold_begin, &Events::listen_holdBegin, m_sWLRCursor, "WLRCursor");
-    addWLSignal(&m_sWLRCursor->events.hold_end, &Events::listen_holdEnd, m_sWLRCursor, "WLRCursor");
     addWLSignal(&m_sWLRBackend->events.new_input, &Events::listen_newInput, m_sWLRBackend, "Backend");
     addWLSignal(&m_sSeat.seat->events.request_set_cursor, &Events::listen_requestMouse, &m_sSeat, "Seat");
     addWLSignal(&m_sSeat.seat->events.request_set_selection, &Events::listen_requestSetSel, &m_sSeat, "Seat");
@@ -307,23 +286,6 @@ void CCompositor::initAllSignals() {
 void CCompositor::removeAllSignals() {
     removeWLSignal(&Events::listen_newOutput);
     removeWLSignal(&Events::listen_newXDGToplevel);
-    removeWLSignal(&Events::listen_mouseMove);
-    removeWLSignal(&Events::listen_mouseMoveAbsolute);
-    removeWLSignal(&Events::listen_mouseButton);
-    removeWLSignal(&Events::listen_mouseAxis);
-    removeWLSignal(&Events::listen_mouseFrame);
-    removeWLSignal(&Events::listen_swipeBegin);
-    removeWLSignal(&Events::listen_swipeUpdate);
-    removeWLSignal(&Events::listen_swipeEnd);
-    removeWLSignal(&Events::listen_pinchBegin);
-    removeWLSignal(&Events::listen_pinchUpdate);
-    removeWLSignal(&Events::listen_pinchEnd);
-    removeWLSignal(&Events::listen_touchBegin);
-    removeWLSignal(&Events::listen_touchEnd);
-    removeWLSignal(&Events::listen_touchUpdate);
-    removeWLSignal(&Events::listen_touchFrame);
-    removeWLSignal(&Events::listen_holdBegin);
-    removeWLSignal(&Events::listen_holdEnd);
     removeWLSignal(&Events::listen_newInput);
     removeWLSignal(&Events::listen_requestMouse);
     removeWLSignal(&Events::listen_requestSetSel);
@@ -434,9 +396,6 @@ void CCompositor::cleanup() {
     g_pWatchdog.reset();
     g_pXWaylandManager.reset();
 
-    if (m_sWLRCursor)
-        wlr_cursor_destroy(m_sWLRCursor);
-
     if (m_sSeat.seat)
         wlr_seat_destroy(m_sSeat.seat);
 
@@ -485,6 +444,9 @@ void CCompositor::initManagers(eManagersInitStage stage) {
 
             g_pConfigManager->init();
             g_pWatchdog = std::make_unique<CWatchdog>(); // requires config
+
+            Debug::log(LOG, "Creating the PointerManager!");
+            g_pPointerManager = std::make_unique<CPointerManager>();
         } break;
         case STAGE_LATE: {
             Debug::log(LOG, "Creating the ThreadManager!");
@@ -668,24 +630,28 @@ CMonitor* CCompositor::getMonitorFromDesc(const std::string& desc) {
 }
 
 CMonitor* CCompositor::getMonitorFromCursor() {
-    const auto COORDS = Vector2D(m_sWLRCursor->x, m_sWLRCursor->y);
-
-    return getMonitorFromVector(COORDS);
+    return getMonitorFromVector(g_pPointerManager->position());
 }
 
 CMonitor* CCompositor::getMonitorFromVector(const Vector2D& point) {
-    const auto OUTPUT = wlr_output_layout_output_at(m_sWLROutputLayout, point.x, point.y);
+    SP<CMonitor> mon;
+    for (auto& m : m_vMonitors) {
+        if (CBox{m->vecPosition, m->vecSize}.containsPoint(point)) {
+            mon = m;
+            break;
+        }
+    }
 
-    if (!OUTPUT) {
-        float     bestDistance = 0.f;
-        CMonitor* pBestMon     = nullptr;
+    if (!mon) {
+        float        bestDistance = 0.f;
+        SP<CMonitor> pBestMon;
 
         for (auto& m : m_vMonitors) {
             float dist = vecToRectDistanceSquared(point, m->vecPosition, m->vecPosition + m->vecSize);
 
             if (dist < bestDistance || !pBestMon) {
                 bestDistance = dist;
-                pBestMon     = m.get();
+                pBestMon     = m;
             }
         }
 
@@ -694,10 +660,10 @@ CMonitor* CCompositor::getMonitorFromVector(const Vector2D& point) {
             return m_vMonitors.front().get();
         }
 
-        return pBestMon;
+        return pBestMon.get();
     }
 
-    return getMonitorFromOutput(OUTPUT);
+    return mon.get();
 }
 
 void CCompositor::removeWindowFromVectorSafe(PHLWINDOW pWindow) {
@@ -732,7 +698,7 @@ PHLWINDOW CCompositor::vectorToWindowUnified(const Vector2D& pos, uint8_t proper
             const auto BB  = w->getWindowBoxUnified(properties);
             CBox       box = {BB.x - BORDER_GRAB_AREA, BB.y - BORDER_GRAB_AREA, BB.width + 2 * BORDER_GRAB_AREA, BB.height + 2 * BORDER_GRAB_AREA};
             if (w->m_bIsFloating && w->m_bIsMapped && !w->isHidden() && !w->m_bX11ShouldntFocus && w->m_bPinned && !w->m_sAdditionalConfigData.noFocus && w != pIgnoreWindow) {
-                if (box.containsPoint({m_sWLRCursor->x, m_sWLRCursor->y}))
+                if (box.containsPoint(g_pPointerManager->position()))
                     return w;
 
                 if (!w->m_bIsX11) {
@@ -766,7 +732,7 @@ PHLWINDOW CCompositor::vectorToWindowUnified(const Vector2D& pos, uint8_t proper
                     if (w->m_bX11ShouldntFocus && w->m_iX11Type != 2)
                         continue;
 
-                    if (box.containsPoint({m_sWLRCursor->x, m_sWLRCursor->y})) {
+                    if (box.containsPoint(g_pPointerManager->position())) {
 
                         if (w->m_bIsX11 && w->m_iX11Type == 2 && !wlr_xwayland_or_surface_wants_focus(w->m_uSurface.xwayland)) {
                             // Override Redirect
@@ -1719,7 +1685,7 @@ void checkFocusSurfaceIter(wlr_surface* pSurface, int x, int y, void* data) {
 }
 
 CMonitor* CCompositor::getMonitorInDirection(const char& dir) {
-    return this->getMonitorInDirection(m_pLastMonitor, dir);
+    return this->getMonitorInDirection(m_pLastMonitor.get(), dir);
 }
 
 CMonitor* CCompositor::getMonitorInDirection(CMonitor* pSourceMonitor, const char& dir) {
@@ -1733,7 +1699,7 @@ CMonitor* CCompositor::getMonitorInDirection(CMonitor* pSourceMonitor, const cha
     CMonitor*  longestIntersectMonitor = nullptr;
 
     for (auto& m : m_vMonitors) {
-        if (m.get() == m_pLastMonitor)
+        if (m == m_pLastMonitor)
             continue;
 
         const auto POSB  = m->vecPosition;
@@ -2011,7 +1977,7 @@ void CCompositor::swapActiveWorkspaces(CMonitor* pMonitorA, CMonitor* pMonitorB)
 
 CMonitor* CCompositor::getMonitorFromString(const std::string& name) {
     if (name == "current")
-        return g_pCompositor->m_pLastMonitor;
+        return g_pCompositor->m_pLastMonitor.get();
     else if (isDirection(name))
         return getMonitorInDirection(name[0]);
     else if (name[0] == '+' || name[0] == '-') {
@@ -2032,7 +1998,7 @@ CMonitor* CCompositor::getMonitorFromString(const std::string& name) {
 
         int currentPlace = 0;
         for (int i = 0; i < (int)m_vMonitors.size(); i++) {
-            if (m_vMonitors[i].get() == m_pLastMonitor) {
+            if (m_vMonitors[i] == m_pLastMonitor) {
                 currentPlace = i;
                 break;
             }
@@ -2158,7 +2124,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, CMonitor* pMon
         }
     }
 
-    if (SWITCHINGISACTIVE && POLDMON == g_pCompositor->m_pLastMonitor) { // if it was active, preserve its' status. If it wasn't, don't.
+    if (SWITCHINGISACTIVE && POLDMON == g_pCompositor->m_pLastMonitor.get()) { // if it was active, preserve its' status. If it wasn't, don't.
         Debug::log(LOG, "moveWorkspaceToMonitor: SWITCHINGISACTIVE, active {} -> {}", pMonitor->activeWorkspaceID(), pWorkspace->m_iID);
 
         if (valid(pMonitor->activeWorkspace)) {
@@ -2174,7 +2140,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, CMonitor* pMon
         pWorkspace->m_bVisible = true;
 
         if (!noWarpCursor)
-            wlr_cursor_warp(m_sWLRCursor, nullptr, pMonitor->vecPosition.x + pMonitor->vecTransformedSize.x / 2, pMonitor->vecPosition.y + pMonitor->vecTransformedSize.y / 2);
+            g_pPointerManager->warpTo(pMonitor->vecPosition + pMonitor->vecTransformedSize / 2.F);
 
         g_pInputManager->sendMotionEventsToFocused();
     }
@@ -2439,10 +2405,10 @@ void CCompositor::warpCursorTo(const Vector2D& pos, bool force) {
     if (*PNOWARPS && !force)
         return;
 
-    wlr_cursor_warp(m_sWLRCursor, nullptr, pos.x, pos.y);
+    g_pPointerManager->warpTo(pos);
 
     const auto PMONITORNEW = getMonitorFromVector(pos);
-    if (PMONITORNEW != m_pLastMonitor)
+    if (PMONITORNEW != m_pLastMonitor.get())
         setActiveMonitor(PMONITORNEW);
 }
 
@@ -2587,19 +2553,19 @@ void CCompositor::renameWorkspace(const int& id, const std::string& name) {
 }
 
 void CCompositor::setActiveMonitor(CMonitor* pMonitor) {
-    if (m_pLastMonitor == pMonitor)
+    if (m_pLastMonitor.get() == pMonitor)
         return;
 
     if (!pMonitor) {
-        m_pLastMonitor = nullptr;
+        m_pLastMonitor.reset();
         return;
     }
 
     const auto PWORKSPACE = pMonitor->activeWorkspace;
 
     g_pEventManager->postEvent(SHyprIPCEvent{"focusedmon", pMonitor->szName + "," + (PWORKSPACE ? PWORKSPACE->m_szName : "?")});
     EMIT_HOOK_EVENT("focusedMon", pMonitor);
-    m_pLastMonitor = pMonitor;
+    m_pLastMonitor = pMonitor->self;
 }
 
 bool CCompositor::isWorkspaceSpecial(const int& id) {

src/Compositor.hpp

@@ -51,10 +51,8 @@ class CCompositor {
     wlr_data_device_manager*  m_sWLRDataDevMgr;
     wlr_drm*                  m_sWRLDRM;
     wlr_drm_lease_v1_manager* m_sWRLDRMLeaseMgr;
-    wlr_output_layout*        m_sWLROutputLayout;
     wlr_layer_shell_v1*       m_sWLRLayerShell;
     wlr_xdg_shell*            m_sWLRXDGShell;
-    wlr_cursor*               m_sWLRCursor;
     wlr_presentation*         m_sWLRPresentation;
     wlr_egl*                  m_sWLREGL;
     int                       m_iDRMFD;
@@ -88,7 +86,7 @@ class CCompositor {
 
     wlr_surface*                              m_pLastFocus = nullptr;
     PHLWINDOWREF                              m_pLastWindow;
-    CMonitor*                                 m_pLastMonitor = nullptr;
+    WP<CMonitor>                              m_pLastMonitor;
 
     std::vector<PHLWINDOWREF>                 m_vWindowFocusHistory; // first element is the most recently focused.
 

src/config/ConfigManager.cpp

@@ -516,6 +516,9 @@ CConfigManager::CConfigManager() {
     m_pConfig->addConfigValue("opengl:nvidia_anti_flicker", Hyprlang::INT{1});
     m_pConfig->addConfigValue("opengl:force_introspection", Hyprlang::INT{2});
 
+    m_pConfig->addConfigValue("cursor:no_hardware_cursors", Hyprlang::INT{0});
+    m_pConfig->addConfigValue("cursor:hotspot_padding", Hyprlang::INT{1});
+
     m_pConfig->addConfigValue("autogenerated", Hyprlang::INT{0});
 
     m_pConfig->addConfigValue("general:col.active_border", Hyprlang::CConfigCustomValueType{&configHandleGradientSet, configHandleGradientDestroy, "0xffffffff"});

src/debug/HyprCtl.cpp

@@ -115,7 +115,7 @@ std::string monitorsRequest(eHyprCtlOutputFormat format, std::string request) {
                 (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y, m->activeWorkspaceID(),
                 (!m->activeWorkspace ? "" : escapeJSONStrings(m->activeWorkspace->m_szName)), m->activeSpecialWorkspaceID(),
                 escapeJSONStrings(m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_szName : ""), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y,
-                (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m.get() == g_pCompositor->m_pLastMonitor ? "true" : "false"),
+                (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m == g_pCompositor->m_pLastMonitor ? "true" : "false"),
                 (m->dpmsStatus ? "true" : "false"), (m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED ? "true" : "false"),
                 (m->tearingState.activelyTearing ? "true" : "false"), (m->m_bEnabled ? "false" : "true"), formatToString(m->drmFormat), availableModesForOutput(m.get(), format));
         }
@@ -137,7 +137,7 @@ std::string monitorsRequest(eHyprCtlOutputFormat format, std::string request) {
                 (m->output->make ? m->output->make : ""), (m->output->model ? m->output->model : ""), (m->output->serial ? m->output->serial : ""), m->activeWorkspaceID(),
                 (!m->activeWorkspace ? "" : m->activeWorkspace->m_szName), m->activeSpecialWorkspaceID(), (m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_szName : ""),
                 (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform,
-                (m.get() == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus, (int)(m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED),
+                (m == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus, (int)(m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED),
                 m->tearingState.activelyTearing, !m->m_bEnabled, formatToString(m->drmFormat), availableModesForOutput(m.get(), format));
         }
     }

src/debug/HyprDebugOverlay.cpp

@@ -33,7 +33,7 @@ void CHyprMonitorDebugOverlay::frameData(CMonitor* pMonitor) {
         m_pMonitor = pMonitor;
 
     // anim data too
-    const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor : g_pCompositor->m_pLastMonitor;
+    const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor : g_pCompositor->m_pLastMonitor.get();
     if (PMONITORFORTICKS) {
         if (m_dLastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->refreshRate)
             m_dLastAnimationTicks.pop_front();

src/desktop/WLSurface.cpp

@@ -122,7 +122,7 @@ void CWLSurface::destroy() {
         g_pCompositor->m_pLastFocus = nullptr;
     if (g_pInputManager && g_pInputManager->m_pLastMouseSurface == m_pWLRSurface)
         g_pInputManager->m_pLastMouseSurface = nullptr;
-    if (g_pHyprRenderer && g_pHyprRenderer->m_sLastCursorData.surf == m_pWLRSurface)
+    if (g_pHyprRenderer && g_pHyprRenderer->m_sLastCursorData.surf == this)
         g_pHyprRenderer->m_sLastCursorData.surf.reset();
 
     m_pWLRSurface = nullptr;

src/desktop/Window.cpp

@@ -1169,7 +1169,7 @@ void CWindow::setSuspended(bool suspend) {
 bool CWindow::visibleOnMonitor(CMonitor* pMonitor) {
     CBox wbox = {m_vRealPosition.value(), m_vRealSize.value()};
 
-    return wlr_output_layout_intersects(g_pCompositor->m_sWLROutputLayout, pMonitor->output, wbox.pWlr());
+    return !wbox.intersection({pMonitor->vecPosition, pMonitor->vecSize}).empty();
 }
 
 void CWindow::setAnimationsToMove() {

src/devices/IHID.cpp

@@ -0,0 +1,5 @@
+#include "IHID.hpp"
+
+eHIDType IHID::getType() {
+    return HID_TYPE_UNKNOWN;
+}

src/devices/IHID.hpp

@@ -10,13 +10,24 @@ enum eHIDCapabilityType : uint32_t {
     HID_INPUT_CAPABILITY_TOUCH    = (1 << 2),
 };
 
+enum eHIDType {
+    HID_TYPE_UNKNOWN = 0,
+    HID_TYPE_POINTER,
+    HID_TYPE_KEYBOARD,
+    HID_TYPE_TOUCH,
+    HID_TYPE_TABLET,
+};
+
 /*
     Base class for a HID device.
     This could be a keyboard, a mouse, or a touchscreen.
 */
 class IHID {
   public:
+    virtual ~IHID() {}
+
     virtual uint32_t getCapabilities() = 0;
+    virtual eHIDType getType();
 
     struct {
         CSignal destroy;

src/devices/IKeyboard.cpp

@@ -7,6 +7,10 @@ uint32_t IKeyboard::getCapabilities() {
     return HID_INPUT_CAPABILITY_KEYBOARD;
 }
 
+eHIDType IKeyboard::getType() {
+    return HID_TYPE_KEYBOARD;
+}
+
 IKeyboard::~IKeyboard() {
     events.destroy.emit();
 

src/devices/IKeyboard.hpp

@@ -13,6 +13,7 @@ class IKeyboard : public IHID {
   public:
     virtual ~IKeyboard();
     virtual uint32_t      getCapabilities();
+    virtual eHIDType      getType();
     virtual bool          isVirtual() = 0;
     virtual wlr_keyboard* wlr()       = 0;
 

src/devices/IPointer.cpp

@@ -3,3 +3,7 @@
 uint32_t IPointer::getCapabilities() {
     return HID_INPUT_CAPABILITY_POINTER;
 }
+
+eHIDType IPointer::getType() {
+    return HID_TYPE_POINTER;
+}