added tablet v2 support (alpha alpha)

11 files changed, 291 insertions, 14 deletions

diff --git a/src/Compositor.hpp b/src/Compositor.hpp
index 2cf867db..e00ea0fd 100644
--- a/src/Compositor.hpp
+++ b/src/Compositor.hpp
@@ -10,7 +10,7 @@
 #include "config/ConfigManager.hpp"
 #include "managers/ThreadManager.hpp"
 #include "managers/XWaylandManager.hpp"
-#include "managers/InputManager.hpp"
+#include "managers/input/InputManager.hpp"
 #include "managers/LayoutManager.hpp"
 #include "managers/KeybindManager.hpp"
 #include "managers/AnimationManager.hpp"
diff --git a/src/events/Devices.cpp b/src/events/Devices.cpp
index 89443af2..7a47df77 100644
--- a/src/events/Devices.cpp
+++ b/src/events/Devices.cpp
@@ -2,7 +2,7 @@
 
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
-#include "../managers/InputManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
 
 // ---------------------------------------------------- //
@@ -78,14 +78,20 @@ void Events::listener_newInput(wl_listener* listener, void* data) {
             Debug::log(WARN, "!!!! Hyprland does not directly support touchscreens, bugs may occur !!!!");
             wlr_cursor_attach_input_device(g_pCompositor->m_sWLRCursor, DEVICE);
             break;
+        case WLR_INPUT_DEVICE_TABLET_TOOL:
+            Debug::log(LOG, "Attached a tablet tool with name %s", DEVICE->name);
+            g_pInputManager->newTabletTool(DEVICE);
+            break;
+        case WLR_INPUT_DEVICE_TABLET_PAD:
+            Debug::log(LOG, "Attached a tablet pad with name %s", DEVICE->name);
+            g_pInputManager->newTabletPad(DEVICE);
+            break;
         default:
             Debug::log(WARN, "Unrecognized input device plugged in: %s", DEVICE->name);
             break;
     }
 
-    uint32_t capabilities = WL_SEAT_CAPABILITY_POINTER | WL_SEAT_CAPABILITY_KEYBOARD;
-
-    wlr_seat_set_capabilities(g_pCompositor->m_sSeat.seat, capabilities);
+    g_pInputManager->updateCapabilities(DEVICE);
 }
 
 void Events::listener_newConstraint(wl_listener* listener, void* data) {
diff --git a/src/events/Layers.cpp b/src/events/Layers.cpp
index 1503f8cb..a1aa7764 100644
--- a/src/events/Layers.cpp
+++ b/src/events/Layers.cpp
@@ -1,6 +1,6 @@
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
-#include "../managers/InputManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
 #include "Events.hpp"
 
diff --git a/src/events/Misc.cpp b/src/events/Misc.cpp
index eec42f6d..c25b1c6a 100644
--- a/src/events/Misc.cpp
+++ b/src/events/Misc.cpp
@@ -2,7 +2,7 @@
 
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
-#include "../managers/InputManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
 
 // ------------------------------ //
diff --git a/src/events/Monitors.cpp b/src/events/Monitors.cpp
index 7756bfa2..accdd3d7 100644
--- a/src/events/Monitors.cpp
+++ b/src/events/Monitors.cpp
@@ -1,6 +1,6 @@
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
-#include "../managers/InputManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
 #include "Events.hpp"
 #include "../debug/HyprCtl.hpp"
diff --git a/src/events/Popups.cpp b/src/events/Popups.cpp
index 457a95fe..0b075295 100644
--- a/src/events/Popups.cpp
+++ b/src/events/Popups.cpp
@@ -2,7 +2,7 @@
 
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
-#include "../managers/InputManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
 
 // --------------------------------------------- //
diff --git a/src/events/Windows.cpp b/src/events/Windows.cpp
index ffe2ac96..b84b9d2d 100644
--- a/src/events/Windows.cpp
+++ b/src/events/Windows.cpp
@@ -2,7 +2,7 @@
 
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
-#include "../managers/InputManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
 
 // ------------------------------------------------------------ //
diff --git a/src/helpers/WLClasses.hpp b/src/helpers/WLClasses.hpp
index 461d02e0..723ffdff 100644
--- a/src/helpers/WLClasses.hpp
+++ b/src/helpers/WLClasses.hpp
@@ -153,4 +153,54 @@ struct SDrag {
     DYNLISTENER(mapIcon);
     DYNLISTENER(unmapIcon);
     DYNLISTENER(commitIcon);
+};
+
+struct STablet {
+    DYNLISTENER(Tip);
+    DYNLISTENER(Axis);
+    DYNLISTENER(Button);
+    DYNLISTENER(Proximity);
+    DYNLISTENER(Destroy);
+
+    wlr_tablet* wlrTablet = nullptr;
+    wlr_tablet_v2_tablet* wlrTabletV2 = nullptr;
+    wlr_input_device* wlrDevice = nullptr;
+
+    bool operator==(const STablet& b) {
+        return wlrDevice == b.wlrDevice;
+    }
+};
+
+struct STabletTool {
+    wlr_tablet_tool* wlrTabletTool = nullptr;
+    wlr_tablet_v2_tablet_tool* wlrTabletToolV2 = nullptr;
+
+    wlr_tablet_v2_tablet* wlrTabletOwnerV2 = nullptr;
+
+    double tiltX = 0;
+    double tiltY = 0;
+
+    bool active = true;
+
+    DYNLISTENER(TabletToolDestroy);
+    DYNLISTENER(TabletToolSetCursor);
+
+    bool operator==(const STabletTool& b) {
+        return wlrTabletTool == b.wlrTabletTool;
+    }
+};
+
+struct STabletPad {
+    wlr_tablet_v2_tablet_pad* wlrTabletPadV2 = nullptr;
+    STablet* pTabletParent = nullptr;
+
+    DYNLISTENER(Attach);
+    DYNLISTENER(Button);
+    DYNLISTENER(Strip);
+    DYNLISTENER(Ring);
+    DYNLISTENER(Destroy);
+
+    bool operator==(const STabletPad& b) {
+        return wlrTabletPadV2 == b.wlrTabletPadV2;
+    }
 };
\ No newline at end of file
diff --git a/src/managers/InputManager.cpp b/src/managers/input/InputManager.cpp
index be861532..26e20ffb 100644
--- a/src/managers/InputManager.cpp
+++ b/src/managers/input/InputManager.cpp
@@ -1,5 +1,5 @@
 #include "InputManager.hpp"
-#include "../Compositor.hpp"
+#include "../../Compositor.hpp"
 
 void CInputManager::onMouseMoved(wlr_pointer_motion_event* e) {
 
@@ -500,3 +500,23 @@ void CInputManager::constrainMouse(SMouse* pMouse, wlr_pointer_constraint_v1* co
 void Events::listener_commitConstraint(void* owner, void* data) {
     //g_pInputManager->recheckConstraint((SMouse*)owner);
 }
+
+void CInputManager::updateCapabilities(wlr_input_device* pDev) {
+    // TODO: this is dumb
+
+    switch (pDev->type) {
+        case WLR_INPUT_DEVICE_KEYBOARD:
+            m_uiCapabilities |= WL_SEAT_CAPABILITY_KEYBOARD;
+            break;
+        case WLR_INPUT_DEVICE_POINTER:
+            m_uiCapabilities |= WL_SEAT_CAPABILITY_POINTER;
+            break;
+        case WLR_INPUT_DEVICE_TOUCH:
+            m_uiCapabilities |= WL_SEAT_CAPABILITY_TOUCH;
+            break;
+        default:
+            break;
+    }
+
+    wlr_seat_set_capabilities(g_pCompositor->m_sSeat.seat, m_uiCapabilities);
+}
\ No newline at end of file
diff --git a/src/managers/InputManager.hpp b/src/managers/input/InputManager.hpp
index a6f436da..e83a1e34 100644
--- a/src/managers/InputManager.hpp
+++ b/src/managers/input/InputManager.hpp
@@ -1,9 +1,9 @@
 #pragma once
 
-#include "../defines.hpp"
+#include "../../defines.hpp"
 #include <list>
-#include "../helpers/WLClasses.hpp"
-#include "../Window.hpp"
+#include "../../helpers/WLClasses.hpp"
+#include "../../Window.hpp"
 
 class CInputManager {
 public:
@@ -28,6 +28,7 @@ public:
     void            setKeyboardLayout();
 
     void            updateDragIcon();
+    void            updateCapabilities(wlr_input_device*);
 
 
     // for dragging floating windows
@@ -40,11 +41,23 @@ public:
     std::list<SKeyboard>    m_lKeyboards;
     std::list<SMouse>       m_lMice;
 
+    // tablets
+    std::list<STablet>      m_lTablets;
+    std::list<STabletTool>  m_lTabletTools;
+    std::list<STabletPad>   m_lTabletPads;
+
+    void            newTabletTool(wlr_input_device*);
+    void            newTabletPad(wlr_input_device*);
+
     SKeyboard*      m_pActiveKeyboard = nullptr;
 
    private:
 
+    uint32_t        m_uiCapabilities = 0;
+
     void            mouseMoveUnified(uint32_t, bool refocus = false);
+
+    STabletTool*    ensureTabletToolPresent(STablet*, wlr_tablet_tool*);
 };
 
 inline std::unique_ptr<CInputManager> g_pInputManager;
\ No newline at end of file
diff --git a/src/managers/input/Tablets.cpp b/src/managers/input/Tablets.cpp
new file mode 100644
index 00000000..df0a7171
--- /dev/null
+++ b/src/managers/input/Tablets.cpp
@@ -0,0 +1,188 @@
+#include "InputManager.hpp"
+#include "../../Compositor.hpp"
+
+void CInputManager::newTabletTool(wlr_input_device* pDevice) {
+    const auto PNEWTABLET = &m_lTablets.emplace_back();
+
+    PNEWTABLET->wlrTablet = pDevice->tablet;
+    PNEWTABLET->wlrDevice = pDevice;
+    PNEWTABLET->wlrTabletV2 = wlr_tablet_create(g_pCompositor->m_sWLRTabletManager, g_pCompositor->m_sSeat.seat, pDevice);
+    PNEWTABLET->wlrTablet->data = PNEWTABLET;
+
+    wlr_cursor_attach_input_device(g_pCompositor->m_sWLRCursor, pDevice);
+
+    PNEWTABLET->hyprListener_Destroy.initCallback(&pDevice->events.destroy, [](void* owner, void* data) {
+        const auto PTAB = (STablet*)owner;
+
+        g_pInputManager->m_lTablets.remove(*PTAB);
+
+        Debug::log(LOG, "Removed a tablet");
+    }, PNEWTABLET, "Tablet");
+
+    PNEWTABLET->hyprListener_Axis.initCallback(&pDevice->tablet->events.axis, [](void* owner, void* data) {
+
+        const auto EVENT = (wlr_tablet_tool_axis_event*)data;
+        const auto PTAB = (STablet*)owner;
+
+        switch (EVENT->tool->type) {
+            case WLR_TABLET_TOOL_TYPE_MOUSE:
+                wlr_cursor_move(g_pCompositor->m_sWLRCursor, PTAB->wlrDevice, EVENT->dx, EVENT->dy);
+                g_pInputManager->refocus();
+                break;
+            default:
+                double x = (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_X) ? EVENT->x : NAN;
+                double y = (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_Y) ? EVENT->y : NAN;
+                wlr_cursor_warp_absolute(g_pCompositor->m_sWLRCursor, PTAB->wlrDevice, x, y);
+                g_pInputManager->refocus();
+                break;
+        }
+
+        const auto PTOOL = g_pInputManager->ensureTabletToolPresent(PTAB, EVENT->tool);
+
+        // TODO: this might be wrong
+        if (PTOOL->active)
+            g_pInputManager->refocus();
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_PRESSURE)
+            wlr_tablet_v2_tablet_tool_notify_pressure(PTOOL->wlrTabletToolV2, EVENT->pressure);
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_DISTANCE)
+            wlr_tablet_v2_tablet_tool_notify_distance(PTOOL->wlrTabletToolV2, EVENT->distance);
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_ROTATION)
+            wlr_tablet_v2_tablet_tool_notify_rotation(PTOOL->wlrTabletToolV2, EVENT->rotation);
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_SLIDER)
+            wlr_tablet_v2_tablet_tool_notify_slider(PTOOL->wlrTabletToolV2, EVENT->slider);
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_WHEEL)
+            wlr_tablet_v2_tablet_tool_notify_wheel(PTOOL->wlrTabletToolV2, EVENT->wheel_delta, 0);
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_TILT_X)
+            PTOOL->tiltX = EVENT->tilt_x;
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_TILT_Y)
+            PTOOL->tiltY = EVENT->tilt_y;
+
+        if (EVENT->updated_axes & (WLR_TABLET_TOOL_AXIS_TILT_X | WLR_TABLET_TOOL_AXIS_TILT_Y))
+            wlr_tablet_v2_tablet_tool_notify_tilt(PTOOL->wlrTabletToolV2, PTOOL->tiltX, PTOOL->tiltY);
+
+    }, PNEWTABLET, "Tablet");
+
+    PNEWTABLET->hyprListener_Tip.initCallback(&pDevice->tablet->events.tip, [](void* owner, void* data) {
+        const auto EVENT = (wlr_tablet_tool_tip_event*)data;
+        const auto PTAB = (STablet*)owner;
+
+        const auto PTOOL = g_pInputManager->ensureTabletToolPresent(PTAB, EVENT->tool);
+
+        // TODO: this might be wrong
+        if (EVENT->state == WLR_TABLET_TOOL_TIP_DOWN)
+            wlr_send_tablet_v2_tablet_tool_down(PTOOL->wlrTabletToolV2);
+        else
+            wlr_send_tablet_v2_tablet_tool_up(PTOOL->wlrTabletToolV2);
+            
+    }, PNEWTABLET, "Tablet");
+
+    PNEWTABLET->hyprListener_Button.initCallback(&pDevice->tablet->events.button, [](void* owner, void* data) {
+        const auto EVENT = (wlr_tablet_tool_button_event*)data;
+        const auto PTAB = (STablet*)owner;
+
+        const auto PTOOL = g_pInputManager->ensureTabletToolPresent(PTAB, EVENT->tool);
+
+        wlr_tablet_v2_tablet_tool_notify_button(PTOOL->wlrTabletToolV2, (zwp_tablet_pad_v2_button_state)EVENT->button, (zwp_tablet_pad_v2_button_state)EVENT->state);
+            
+    }, PNEWTABLET, "Tablet");
+
+    PNEWTABLET->hyprListener_Proximity.initCallback(&pDevice->tablet->events.proximity, [](void* owner, void* data) {
+        const auto EVENT = (wlr_tablet_tool_proximity_event*)data;
+        const auto PTAB = (STablet*)owner;
+
+        const auto PTOOL = g_pInputManager->ensureTabletToolPresent(PTAB, EVENT->tool);
+
+        if (EVENT->state == WLR_TABLET_TOOL_PROXIMITY_OUT) {
+            PTOOL->active = false;
+        } else {
+            PTOOL->active = true;
+            g_pInputManager->refocus();
+        }
+            
+    }, PNEWTABLET, "Tablet");
+}
+
+STabletTool* CInputManager::ensureTabletToolPresent(STablet* pTablet, wlr_tablet_tool* pTool) {
+    if (pTool->data == nullptr) {
+        const auto PTOOL = &m_lTabletTools.emplace_back();
+
+        PTOOL->wlrTabletTool = pTool;
+        pTool->data = PTOOL;
+
+        PTOOL->wlrTabletToolV2 = wlr_tablet_tool_create(g_pCompositor->m_sWLRTabletManager, g_pCompositor->m_sSeat.seat, pTool);
+
+        PTOOL->hyprListener_TabletToolDestroy.initCallback(&pTool->events.destroy, [](void* owner, void* data) {
+            const auto PTOOL = (STabletTool*)owner;
+
+            PTOOL->wlrTabletTool->data = nullptr;
+            g_pInputManager->m_lTabletTools.remove(*PTOOL);
+        }, PTOOL, "Tablet Tool V1");
+
+        //TODO: set cursor request
+    }
+
+    return (STabletTool*)pTool->data;
+}
+
+void CInputManager::newTabletPad(wlr_input_device* pDevice) {
+    const auto PNEWPAD = &m_lTabletPads.emplace_back();
+
+    PNEWPAD->wlrTabletPadV2 = wlr_tablet_pad_create(g_pCompositor->m_sWLRTabletManager, g_pCompositor->m_sSeat.seat, pDevice);
+
+    PNEWPAD->hyprListener_Button.initCallback(&pDevice->tablet_pad->events.button, [](void* owner, void* data) {
+
+        const auto EVENT = (wlr_tablet_pad_button_event*)data;
+        const auto PPAD = (STabletPad*)owner;
+
+        wlr_tablet_v2_tablet_pad_notify_mode(PPAD->wlrTabletPadV2, EVENT->group, EVENT->mode, EVENT->time_msec);
+        wlr_tablet_v2_tablet_pad_notify_button(PPAD->wlrTabletPadV2, EVENT->button, EVENT->time_msec, (zwp_tablet_pad_v2_button_state)EVENT->state);
+
+    }, PNEWPAD, "Tablet Pad");
+
+    PNEWPAD->hyprListener_Strip.initCallback(&pDevice->tablet_pad->events.strip, [](void* owner, void* data) {
+
+        const auto EVENT = (wlr_tablet_pad_strip_event*)data;
+        const auto PPAD = (STabletPad*)owner;
+
+        wlr_tablet_v2_tablet_pad_notify_strip(PPAD->wlrTabletPadV2, EVENT->strip, EVENT->position, EVENT->source == WLR_TABLET_PAD_STRIP_SOURCE_FINGER, EVENT->time_msec);
+
+    }, PNEWPAD, "Tablet Pad");
+
+    PNEWPAD->hyprListener_Ring.initCallback(&pDevice->tablet_pad->events.strip, [](void* owner, void* data) {
+
+        const auto EVENT = (wlr_tablet_pad_ring_event*)data;
+        const auto PPAD = (STabletPad*)owner;
+
+        wlr_tablet_v2_tablet_pad_notify_ring(PPAD->wlrTabletPadV2, EVENT->ring, EVENT->position, EVENT->source == WLR_TABLET_PAD_RING_SOURCE_FINGER, EVENT->time_msec);
+
+    }, PNEWPAD, "Tablet Pad");
+
+    PNEWPAD->hyprListener_Attach.initCallback(&pDevice->tablet_pad->events.strip, [](void* owner, void* data) {
+
+        const auto TABLET = (wlr_tablet_tool*)data;
+        const auto PPAD = (STabletPad*)owner;
+
+        PPAD->pTabletParent = (STablet*)TABLET->data;
+
+        if (!PPAD->pTabletParent)
+            Debug::log(ERR, "tabletpad got attached to a nullptr tablet!! this might be bad.");
+
+    }, PNEWPAD, "Tablet Pad");
+
+    PNEWPAD->hyprListener_Destroy.initCallback(&pDevice->events.destroy, [](void* owner, void* data) {
+
+        const auto PPAD = (STabletPad*)owner;
+
+        g_pInputManager->m_lTabletPads.remove(*PPAD);
+
+        Debug::log(LOG, "Removed a tablet pad");
+
+    }, PNEWPAD, "Tablet Pad");
+}
\ No newline at end of file