Core: Move to aquamarine (#6608)

Moves Hyprland from wlroots to aquamarine for the backend.

---------

Signed-off-by: Vaxry <vaxry@vaxry.net>
Co-authored-by: Mihai Fufezan <mihai@fufexan.net>
Co-authored-by: Jan Beich <jbeich@FreeBSD.org>
Co-authored-by: vaxerski <vaxerski@users.noreply.github.com>
Co-authored-by: UjinT34 <41110182+UjinT34@users.noreply.github.com>
Co-authored-by: Tom Englund <tomenglund26@gmail.com>
Co-authored-by: Ikalco <73481042+ikalco@users.noreply.github.com>
Co-authored-by: diniamo <diniamo53@gmail.com>

1 files changed, 103 insertions, 153 deletions

diff --git a/src/devices/Tablet.cpp b/src/devices/Tablet.cpp
index b5ab16c1..71ca8991 100644
--- a/src/devices/Tablet.cpp
+++ b/src/devices/Tablet.cpp
@@ -2,8 +2,9 @@
 #include "../defines.hpp"
 #include "../protocols/Tablet.hpp"
 #include "../protocols/core/Compositor.hpp"
+#include <aquamarine/input/Input.hpp>
 
-SP<CTablet> CTablet::create(wlr_tablet* tablet) {
+SP<CTablet> CTablet::create(SP<Aquamarine::ITablet> tablet) {
     SP<CTablet> pTab = SP<CTablet>(new CTablet(tablet));
 
     pTab->self = pTab;
@@ -13,7 +14,7 @@ SP<CTablet> CTablet::create(wlr_tablet* tablet) {
     return pTab;
 }
 
-SP<CTabletTool> CTabletTool::create(wlr_tablet_tool* tablet) {
+SP<CTabletTool> CTabletTool::create(SP<Aquamarine::ITabletTool> tablet) {
     SP<CTabletTool> pTab = SP<CTabletTool>(new CTabletTool(tablet));
 
     pTab->self = pTab;
@@ -23,7 +24,7 @@ SP<CTabletTool> CTabletTool::create(wlr_tablet_tool* tablet) {
     return pTab;
 }
 
-SP<CTabletPad> CTabletPad::create(wlr_tablet_pad* tablet) {
+SP<CTabletPad> CTabletPad::create(SP<Aquamarine::ITabletPad> tablet) {
     SP<CTabletPad> pTab = SP<CTabletPad>(new CTabletPad(tablet));
 
     pTab->self = pTab;
@@ -33,33 +34,25 @@ SP<CTabletPad> CTabletPad::create(wlr_tablet_pad* tablet) {
     return pTab;
 }
 
-SP<CTabletTool> CTabletTool::fromWlr(wlr_tablet_tool* tool) {
-    return ((CTabletTool*)tool->data)->self.lock();
-}
-
-SP<CTablet> CTablet::fromWlr(wlr_tablet* tablet) {
-    return ((CTablet*)tablet->data)->self.lock();
-}
-
-static uint32_t wlrUpdateToHl(uint32_t wlr) {
+static uint32_t aqUpdateToHl(uint32_t aq) {
     uint32_t result = 0;
-    if (wlr & WLR_TABLET_TOOL_AXIS_X)
+    if (aq & Aquamarine::AQ_TABLET_TOOL_AXIS_X)
         result |= CTablet::eTabletToolAxes::HID_TABLET_TOOL_AXIS_X;
-    if (wlr & WLR_TABLET_TOOL_AXIS_Y)
+    if (aq & Aquamarine::AQ_TABLET_TOOL_AXIS_Y)
         result |= CTablet::eTabletToolAxes::HID_TABLET_TOOL_AXIS_Y;
-    if (wlr & WLR_TABLET_TOOL_AXIS_DISTANCE)
+    if (aq & Aquamarine::AQ_TABLET_TOOL_AXIS_DISTANCE)
         result |= CTablet::eTabletToolAxes::HID_TABLET_TOOL_AXIS_DISTANCE;
-    if (wlr & WLR_TABLET_TOOL_AXIS_PRESSURE)
+    if (aq & Aquamarine::AQ_TABLET_TOOL_AXIS_PRESSURE)
         result |= CTablet::eTabletToolAxes::HID_TABLET_TOOL_AXIS_PRESSURE;
-    if (wlr & WLR_TABLET_TOOL_AXIS_TILT_X)
+    if (aq & Aquamarine::AQ_TABLET_TOOL_AXIS_TILT_X)
         result |= CTablet::eTabletToolAxes::HID_TABLET_TOOL_AXIS_TILT_X;
-    if (wlr & WLR_TABLET_TOOL_AXIS_TILT_Y)
+    if (aq & Aquamarine::AQ_TABLET_TOOL_AXIS_TILT_Y)
         result |= CTablet::eTabletToolAxes::HID_TABLET_TOOL_AXIS_TILT_Y;
-    if (wlr & WLR_TABLET_TOOL_AXIS_ROTATION)
+    if (aq & Aquamarine::AQ_TABLET_TOOL_AXIS_ROTATION)
         result |= CTablet::eTabletToolAxes::HID_TABLET_TOOL_AXIS_ROTATION;
-    if (wlr & WLR_TABLET_TOOL_AXIS_SLIDER)
+    if (aq & Aquamarine::AQ_TABLET_TOOL_AXIS_SLIDER)
         result |= CTablet::eTabletToolAxes::HID_TABLET_TOOL_AXIS_SLIDER;
-    if (wlr & WLR_TABLET_TOOL_AXIS_WHEEL)
+    if (aq & Aquamarine::AQ_TABLET_TOOL_AXIS_WHEEL)
         result |= CTablet::eTabletToolAxes::HID_TABLET_TOOL_AXIS_WHEEL;
     return result;
 }
@@ -68,97 +61,81 @@ uint32_t CTablet::getCapabilities() {
     return HID_INPUT_CAPABILITY_POINTER | HID_INPUT_CAPABILITY_TABLET;
 }
 
-wlr_tablet* CTablet::wlr() {
-    return tablet;
+SP<Aquamarine::ITablet> CTablet::aq() {
+    return tablet.lock();
 }
 
-CTablet::CTablet(wlr_tablet* tablet_) : tablet(tablet_) {
+CTablet::CTablet(SP<Aquamarine::ITablet> tablet_) : tablet(tablet_) {
     if (!tablet)
         return;
 
-    tablet->data = this;
-
-    // clang-format off
-    hyprListener_destroy.initCallback(&tablet->base.events.destroy, [this] (void* owner, void* data) {
-        tablet = nullptr;
-        disconnectCallbacks();
+    listeners.destroy = tablet->events.destroy.registerListener([this](std::any d) {
+        tablet.reset();
         events.destroy.emit();
-    }, this, "CTablet");
+    });
 
-    hyprListener_axis.initCallback(&tablet->events.axis, [this] (void* owner, void* data) {
-        auto E = (wlr_tablet_tool_axis_event*)data;
+    listeners.axis = tablet->events.axis.registerListener([this](std::any d) {
+        auto E = std::any_cast<Aquamarine::ITablet::SAxisEvent>(d);
 
         tabletEvents.axis.emit(SAxisEvent{
-            .tool        = E->tool,
+            .tool        = E.tool,
             .tablet      = self.lock(),
-            .timeMs      = E->time_msec,
-            .updatedAxes = wlrUpdateToHl(E->updated_axes),
-            .axis        = {E->x, E->y},
-            .axisDelta   = {E->dx, E->dy},
-            .tilt        = {E->tilt_x, E->tilt_y},
-            .pressure    = E->pressure,
-            .distance    = E->distance,
-            .rotation    = E->rotation,
-            .slider      = E->slider,
-            .wheelDelta  = E->wheel_delta,
+            .timeMs      = E.timeMs,
+            .updatedAxes = aqUpdateToHl(E.updatedAxes),
+            .axis        = E.absolute,
+            .axisDelta   = E.delta,
+            .tilt        = E.tilt,
+            .pressure    = E.pressure,
+            .distance    = E.distance,
+            .rotation    = E.rotation,
+            .slider      = E.slider,
+            .wheelDelta  = E.wheelDelta,
         });
-    }, this, "CTablet");
+    });
 
-    hyprListener_proximity.initCallback(&tablet->events.proximity, [this] (void* owner, void* data) {
-        auto E = (wlr_tablet_tool_proximity_event*)data;
+    listeners.proximity = tablet->events.proximity.registerListener([this](std::any d) {
+        auto E = std::any_cast<Aquamarine::ITablet::SProximityEvent>(d);
 
         tabletEvents.proximity.emit(SProximityEvent{
-            .tool      = E->tool,
+            .tool      = E.tool,
             .tablet    = self.lock(),
-            .timeMs    = E->time_msec,
-            .proximity = {E->x, E->y},
-            .in        = E->state == WLR_TABLET_TOOL_PROXIMITY_IN,
+            .timeMs    = E.timeMs,
+            .proximity = E.absolute,
+            .in        = E.in,
         });
-    }, this, "CTablet");
+    });
 
-    hyprListener_tip.initCallback(&tablet->events.tip, [this] (void* owner, void* data) {
-        auto E = (wlr_tablet_tool_tip_event*)data;
+    listeners.tip = tablet->events.tip.registerListener([this](std::any d) {
+        auto E = std::any_cast<Aquamarine::ITablet::STipEvent>(d);
 
         tabletEvents.tip.emit(STipEvent{
-            .tool   = E->tool,
+            .tool   = E.tool,
             .tablet = self.lock(),
-            .timeMs = E->time_msec,
-            .tip    = {E->x, E->y},
-            .in     = E->state == WLR_TABLET_TOOL_TIP_DOWN,
+            .timeMs = E.timeMs,
+            .tip    = E.absolute,
+            .in     = E.down,
         });
-    }, this, "CTablet");
+    });
 
-    hyprListener_button.initCallback(&tablet->events.button, [this] (void* owner, void* data) {
-        auto E = (wlr_tablet_tool_button_event*)data;
+    listeners.button = tablet->events.button.registerListener([this](std::any d) {
+        auto E = std::any_cast<Aquamarine::ITablet::SButtonEvent>(d);
 
         tabletEvents.button.emit(SButtonEvent{
-            .tool   = E->tool,
+            .tool   = E.tool,
             .tablet = self.lock(),
-            .timeMs = E->time_msec,
-            .button = E->button,
-            .down   = E->state == WLR_BUTTON_PRESSED,
+            .timeMs = E.timeMs,
+            .button = E.button,
+            .down   = E.down,
         });
-    }, this, "CTablet");
-    // clang-format on
+    });
 
-    deviceName = tablet->base.name ? tablet->base.name : "UNKNOWN";
+    deviceName = tablet->getName();
 }
 
 CTablet::~CTablet() {
-    if (tablet)
-        tablet->data = nullptr;
-
     PROTO::tablet->recheckRegisteredDevices();
 }
 
-void CTablet::disconnectCallbacks() {
-    hyprListener_axis.removeCallback();
-    hyprListener_button.removeCallback();
-    hyprListener_destroy.removeCallback();
-    hyprListener_proximity.removeCallback();
-    hyprListener_tip.removeCallback();
-}
-
 eHIDType CTablet::getType() {
     return HID_TYPE_TABLET;
 }
@@ -167,138 +144,111 @@ uint32_t CTabletPad::getCapabilities() {
     return HID_INPUT_CAPABILITY_TABLET;
 }
 
-wlr_tablet_pad* CTabletPad::wlr() {
-    return pad;
+SP<Aquamarine::ITabletPad> CTabletPad::aq() {
+    return pad.lock();
 }
 
 eHIDType CTabletPad::getType() {
     return HID_TYPE_TABLET_PAD;
 }
 
-CTabletPad::CTabletPad(wlr_tablet_pad* pad_) : pad(pad_) {
+CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : pad(pad_) {
     if (!pad)
         return;
 
-    // clang-format off
-    hyprListener_destroy.initCallback(&pad->base.events.destroy, [this] (void* owner, void* data) {
-        pad = nullptr;
-        disconnectCallbacks();
+    listeners.destroy = pad->events.destroy.registerListener([this](std::any d) {
+        pad.reset();
         events.destroy.emit();
-    }, this, "CTabletPad");
+    });
 
-    hyprListener_button.initCallback(&pad->events.button, [this] (void* owner, void* data) {
-        auto E = (wlr_tablet_pad_button_event*)data;
+    listeners.button = pad->events.button.registerListener([this](std::any d) {
+        auto E = std::any_cast<Aquamarine::ITabletPad::SButtonEvent>(d);
 
         padEvents.button.emit(SButtonEvent{
-            .timeMs = E->time_msec,
-            .button = E->button,
-            .down   = E->state == WLR_BUTTON_PRESSED,
-            .mode   = E->mode,
-            .group  = E->group,
+            .timeMs = E.timeMs,
+            .button = E.button,
+            .down   = E.down,
+            .mode   = E.mode,
+            .group  = E.group,
         });
-    }, this, "CTabletPad");
+    });
 
-    hyprListener_ring.initCallback(&pad->events.ring, [this] (void* owner, void* data) {
-        auto E = (wlr_tablet_pad_ring_event*)data;
+    listeners.ring = pad->events.ring.registerListener([this](std::any d) {
+        auto E = std::any_cast<Aquamarine::ITabletPad::SRingEvent>(d);
 
         padEvents.ring.emit(SRingEvent{
-            .timeMs   = E->time_msec,
-            .finger   = E->source == WLR_TABLET_PAD_RING_SOURCE_FINGER,
-            .ring     = E->ring,
-            .position = E->position,
-            .mode     = E->mode,
+            .timeMs   = E.timeMs,
+            .finger   = E.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_RING_SOURCE_FINGER,
+            .ring     = E.ring,
+            .position = E.pos,
+            .mode     = E.mode,
         });
-    }, this, "CTabletPad");
+    });
 
-    hyprListener_strip.initCallback(&pad->events.strip, [this] (void* owner, void* data) {
-        auto E = (wlr_tablet_pad_strip_event*)data;
+    listeners.strip = pad->events.strip.registerListener([this](std::any d) {
+        auto E = std::any_cast<Aquamarine::ITabletPad::SStripEvent>(d);
 
         padEvents.strip.emit(SStripEvent{
-            .timeMs   = E->time_msec,
-            .finger   = E->source == WLR_TABLET_PAD_STRIP_SOURCE_FINGER,
-            .strip    = E->strip,
-            .position = E->position,
-            .mode     = E->mode,
+            .timeMs   = E.timeMs,
+            .finger   = E.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_STRIP_SOURCE_FINGER,
+            .strip    = E.strip,
+            .position = E.pos,
+            .mode     = E.mode,
         });
-    }, this, "CTabletPad");
+    });
 
-    hyprListener_attach.initCallback(&pad->events.attach_tablet, [this] (void* owner, void* data) {
-        if (!data)
-            return;
-            
-        padEvents.attach.emit(CTabletTool::fromWlr((wlr_tablet_tool*)data));
-    }, this, "CTabletPad");
-    // clang-format on
+    listeners.attach = pad->events.attach.registerListener([this](std::any d) {
+        ; // TODO: this doesn't do anything in aq atm
+    });
 
-    deviceName = pad->base.name ? pad->base.name : "UNKNOWN";
+    deviceName = pad->getName();
 }
 
 CTabletPad::~CTabletPad() {
     PROTO::tablet->recheckRegisteredDevices();
 }
 
-void CTabletPad::disconnectCallbacks() {
-    hyprListener_ring.removeCallback();
-    hyprListener_button.removeCallback();
-    hyprListener_destroy.removeCallback();
-    hyprListener_strip.removeCallback();
-    hyprListener_attach.removeCallback();
-}
-
 uint32_t CTabletTool::getCapabilities() {
     return HID_INPUT_CAPABILITY_POINTER | HID_INPUT_CAPABILITY_TABLET;
 }
 
-wlr_tablet_tool* CTabletTool::wlr() {
-    return tool;
+SP<Aquamarine::ITabletTool> CTabletTool::aq() {
+    return tool.lock();
 }
 
 eHIDType CTabletTool::getType() {
     return HID_TYPE_TABLET_TOOL;
 }
 
-CTabletTool::CTabletTool(wlr_tablet_tool* tool_) : tool(tool_) {
+CTabletTool::CTabletTool(SP<Aquamarine::ITabletTool> tool_) : tool(tool_) {
     if (!tool)
         return;
 
-    // clang-format off
-    hyprListener_destroy.initCallback(&tool->events.destroy, [this] (void* owner, void* data) {
-        tool = nullptr;
-        disconnectCallbacks();
+    listeners.destroyTool = tool->events.destroy.registerListener([this](std::any d) {
+        tool.reset();
         events.destroy.emit();
-    }, this, "CTabletTool");
-    // clang-format on
+    });
 
-    if (tool->tilt)
+    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_TILT)
         toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_TILT;
-    if (tool->pressure)
+    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_PRESSURE)
         toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_PRESSURE;
-    if (tool->distance)
+    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_DISTANCE)
         toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_DISTANCE;
-    if (tool->rotation)
+    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_ROTATION)
         toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_ROTATION;
-    if (tool->slider)
+    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_SLIDER)
         toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_SLIDER;
-    if (tool->wheel)
+    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_WHEEL)
         toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_WHEEL;
 
-    tool->data = this;
-
-    deviceName = std::to_string(tool->hardware_serial) + std::to_string(tool->hardware_wacom);
+    deviceName = std::format("{:x}-{:x}", tool->serial, tool->id);
 }
 
 CTabletTool::~CTabletTool() {
-    if (tool)
-        tool->data = nullptr;
-
     PROTO::tablet->recheckRegisteredDevices();
 }
 
-void CTabletTool::disconnectCallbacks() {
-    hyprListener_destroy.removeCallback();
-    listeners.destroySurface.reset();
-}
-
 SP<CWLSurfaceResource> CTabletTool::getSurface() {
     return pSurface.lock();
 }