hyprwm
/
aquamarine
mirror of https://github.com/hyprwm/aquamarine.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

session: Tablet support 

woo
This commit is contained in:
Vaxry 2024-07-03 19:12:17 +02:00
parent a0cfad9ec0
commit f48653cf0e
9 changed files with 564 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/aquamarine/backend/Backend.hpp
View File

@ -11,13 +11,13 @@
#include "Session.hpp"
namespace Aquamarine {
enum eBackendType {
enum eBackendType : uint32_t {
AQ_BACKEND_WAYLAND = 0,
AQ_BACKEND_DRM,
AQ_BACKEND_HEADLESS,
};
enum eBackendRequestMode {
enum eBackendRequestMode : uint32_t {
/*
Require the provided backend, will error out if it's not available.
*/
@ -32,7 +32,7 @@ namespace Aquamarine {
AQ_BACKEND_REQUEST_FALLBACK,
};
enum eBackendLogLevel {
enum eBackendLogLevel : uint32_t {
AQ_LOG_TRACE = 0,
AQ_LOG_DEBUG,
AQ_LOG_WARNING,

81
include/aquamarine/backend/Session.hpp
View File

@ -13,6 +13,7 @@ struct libseat;
struct libinput;
struct libinput_event;
struct libinput_device;
struct libinput_tablet_tool;
namespace Aquamarine {
class CBackend;
@ -34,7 +35,7 @@ namespace Aquamarine {
dev_t dev;
std::string path;
enum eChangeEventType {
enum eChangeEventType : uint32_t {
AQ_SESSION_EVENT_CHANGE_HOTPLUG = 0,
AQ_SESSION_EVENT_CHANGE_LEASE,
};
@ -69,6 +70,8 @@ namespace Aquamarine {
private:
Hyprutils::Memory::CWeakPointer<CLibinputDevice> device;
friend class CLibinputDevice;
};
class CLibinputMouse : public IPointer {
@ -83,6 +86,8 @@ namespace Aquamarine {
private:
Hyprutils::Memory::CWeakPointer<CLibinputDevice> device;
friend class CLibinputDevice;
};
class CLibinputTouch : public ITouch {
@ -97,6 +102,8 @@ namespace Aquamarine {
private:
Hyprutils::Memory::CWeakPointer<CLibinputDevice> device;
friend class CLibinputDevice;
};
class CLibinputSwitch : public ISwitch {
@ -114,6 +121,55 @@ namespace Aquamarine {
private:
Hyprutils::Memory::CWeakPointer<CLibinputDevice> device;
friend class CLibinputDevice;
};
class CLibinputTablet : public ITablet {
public:
CLibinputTablet(Hyprutils::Memory::CSharedPointer<CLibinputDevice> dev);
virtual ~CLibinputTablet() {
;
}
virtual libinput_device* getLibinputHandle();
virtual const std::string& getName();
private:
Hyprutils::Memory::CWeakPointer<CLibinputDevice> device;
friend class CLibinputDevice;
};
class CLibinputTabletTool : public ITabletTool {
public:
CLibinputTabletTool(Hyprutils::Memory::CSharedPointer<CLibinputDevice> dev, libinput_tablet_tool* tool);
virtual ~CLibinputTabletTool();
virtual libinput_device* getLibinputHandle();
virtual const std::string& getName();
private:
Hyprutils::Memory::CWeakPointer<CLibinputDevice> device;
libinput_tablet_tool* libinputTool = nullptr;
friend class CLibinputDevice;
};
class CLibinputTabletPad : public ITabletPad {
public:
CLibinputTabletPad(Hyprutils::Memory::CSharedPointer<CLibinputDevice> dev);
virtual ~CLibinputTabletPad();
virtual libinput_device* getLibinputHandle();
virtual const std::string& getName();
private:
Hyprutils::Memory::CWeakPointer<CLibinputDevice> device;
Hyprutils::Memory::CSharedPointer<ITabletPad::STabletPadGroup> createGroupFromID(int id);
friend class CLibinputDevice;
};
class CLibinputDevice {
@ -121,17 +177,22 @@ namespace Aquamarine {
CLibinputDevice(libinput_device* device, Hyprutils::Memory::CWeakPointer<CSession> session_);
~CLibinputDevice();
void init();
void init();
libinput_device* device;
Hyprutils::Memory::CWeakPointer<CLibinputDevice> self;
Hyprutils::Memory::CWeakPointer<CSession> session;
std::string name;
libinput_device* device;
Hyprutils::Memory::CWeakPointer<CLibinputDevice> self;
Hyprutils::Memory::CWeakPointer<CSession> session;
std::string name;
Hyprutils::Memory::CSharedPointer<CLibinputKeyboard> keyboard;
Hyprutils::Memory::CSharedPointer<CLibinputMouse> mouse;
Hyprutils::Memory::CSharedPointer<CLibinputTouch> touch;
Hyprutils::Memory::CSharedPointer<CLibinputSwitch> switchy; // :)
Hyprutils::Memory::CSharedPointer<CLibinputKeyboard> keyboard;
Hyprutils::Memory::CSharedPointer<CLibinputMouse> mouse;
Hyprutils::Memory::CSharedPointer<CLibinputTouch> touch;
Hyprutils::Memory::CSharedPointer<CLibinputSwitch> switchy; // :)
Hyprutils::Memory::CSharedPointer<CLibinputTablet> tablet;
Hyprutils::Memory::CSharedPointer<CLibinputTabletPad> tabletPad;
std::vector<Hyprutils::Memory::CSharedPointer<CLibinputTabletTool>> tabletTools;
Hyprutils::Memory::CSharedPointer<CLibinputTabletTool> toolFrom(libinput_tablet_tool* tool);
};
class CSession {

4
include/aquamarine/buffer/Buffer.hpp
View File

@ -7,11 +7,11 @@
#include "../misc/Attachment.hpp"
namespace Aquamarine {
enum eBufferCapability {
enum eBufferCapability : uint32_t {
BUFFER_CAPABILITY_DATAPTR = (1 << 0),
};
enum eBufferType {
enum eBufferType : uint32_t {
BUFFER_TYPE_DMABUF = 0,
BUFFER_TYPE_SHM,
BUFFER_TYPE_MISC,

158
include/aquamarine/input/Input.hpp
View File

@ -6,6 +6,8 @@
struct libinput_device;
namespace Aquamarine {
class ITabletTool;
class IKeyboard {
public:
virtual ~IKeyboard() {
@ -41,19 +43,19 @@ namespace Aquamarine {
virtual libinput_device* getLibinputHandle();
virtual const std::string& getName() = 0;
enum ePointerAxis {
enum ePointerAxis : uint32_t {
AQ_POINTER_AXIS_VERTICAL = 0,
AQ_POINTER_AXIS_HORIZONTAL,
};
enum ePointerAxisSource {
enum ePointerAxisSource : uint32_t {
AQ_POINTER_AXIS_SOURCE_WHEEL = 0,
AQ_POINTER_AXIS_SOURCE_FINGER,
AQ_POINTER_AXIS_SOURCE_CONTINUOUS,
AQ_POINTER_AXIS_SOURCE_TILT,
};
enum ePointerAxisRelativeDirection {
enum ePointerAxisRelativeDirection : uint32_t {
AQ_POINTER_AXIS_RELATIVE_IDENTICAL = 0,
AQ_POINTER_AXIS_RELATIVE_INVERTED,
};
@ -198,7 +200,7 @@ namespace Aquamarine {
virtual libinput_device* getLibinputHandle();
virtual const std::string& getName() = 0;
enum eSwitchType {
enum eSwitchType : uint32_t {
AQ_SWITCH_TYPE_UNKNOWN = 0,
AQ_SWITCH_TYPE_LID,
AQ_SWITCH_TYPE_TABLET_MODE,
@ -216,18 +218,107 @@ namespace Aquamarine {
} events;
};
enum eTabletToolAxes : uint32_t {
AQ_TABLET_TOOL_AXIS_X = (1 << 0),
AQ_TABLET_TOOL_AXIS_Y = (1 << 1),
AQ_TABLET_TOOL_AXIS_DISTANCE = (1 << 2),
AQ_TABLET_TOOL_AXIS_PRESSURE = (1 << 3),
AQ_TABLET_TOOL_AXIS_TILT_X = (1 << 4),
AQ_TABLET_TOOL_AXIS_TILT_Y = (1 << 5),
AQ_TABLET_TOOL_AXIS_ROTATION = (1 << 6),
AQ_TABLET_TOOL_AXIS_SLIDER = (1 << 7),
AQ_TABLET_TOOL_AXIS_WHEEL = (1 << 8),
};
class ITablet {
public:
// FIXME:
virtual ~ITablet() {
events.destroy.emit();
}
virtual libinput_device* getLibinputHandle();
virtual const std::string& getName() = 0;
uint16_t usbVendorID = 0, usbProductID = 0;
Hyprutils::Math::Vector2D physicalSize; // mm
std::vector<std::string> paths;
struct SAxisEvent {
Hyprutils::Memory::CSharedPointer<ITabletTool> tool;
uint32_t timeMs = 0, updatedAxes = 0;
Hyprutils::Math::Vector2D absolute;
Hyprutils::Math::Vector2D delta;
Hyprutils::Math::Vector2D tilt;
double pressure = 0.0, distance = 0.0, rotation = 0.0, slider = 0.0, wheelDelta = 0.0;
};
struct SProximityEvent {
Hyprutils::Memory::CSharedPointer<ITabletTool> tool;
uint32_t timeMs = 0;
Hyprutils::Math::Vector2D absolute;
bool in = false;
};
struct STipEvent {
Hyprutils::Memory::CSharedPointer<ITabletTool> tool;
uint32_t timeMs = 0;
Hyprutils::Math::Vector2D absolute;
bool down = false;
};
struct SButtonEvent {
Hyprutils::Memory::CSharedPointer<ITabletTool> tool;
uint32_t timeMs = 0, button = 0;
bool down = false;
};
struct {
Hyprutils::Signal::CSignal axis;
Hyprutils::Signal::CSignal proximity;
Hyprutils::Signal::CSignal tip;
Hyprutils::Signal::CSignal button;
Hyprutils::Signal::CSignal destroy;
} events;
};
class ITabletTool {
public:
// FIXME:
virtual ~ITabletTool() {
events.destroy.emit();
}
virtual libinput_device* getLibinputHandle();
virtual const std::string& getName() = 0;
enum eTabletToolType : uint32_t {
AQ_TABLET_TOOL_TYPE_INVALID = 0,
AQ_TABLET_TOOL_TYPE_PEN,
AQ_TABLET_TOOL_TYPE_ERASER,
AQ_TABLET_TOOL_TYPE_BRUSH,
AQ_TABLET_TOOL_TYPE_PENCIL,
AQ_TABLET_TOOL_TYPE_AIRBRUSH,
AQ_TABLET_TOOL_TYPE_MOUSE,
AQ_TABLET_TOOL_TYPE_LENS,
AQ_TABLET_TOOL_TYPE_TOTEM,
};
eTabletToolType type = AQ_TABLET_TOOL_TYPE_INVALID;
uint64_t serial = 0, id = 0;
enum eTabletToolCapabilities : uint32_t {
AQ_TABLET_TOOL_CAPABILITY_TILT = (1 << 0),
AQ_TABLET_TOOL_CAPABILITY_PRESSURE = (1 << 1),
AQ_TABLET_TOOL_CAPABILITY_DISTANCE = (1 << 2),
AQ_TABLET_TOOL_CAPABILITY_ROTATION = (1 << 3),
AQ_TABLET_TOOL_CAPABILITY_SLIDER = (1 << 4),
AQ_TABLET_TOOL_CAPABILITY_WHEEL = (1 << 5),
};
uint32_t capabilities = 0; // enum eTabletToolCapabilities
struct {
Hyprutils::Signal::CSignal destroy;
@ -236,10 +327,63 @@ namespace Aquamarine {
class ITabletPad {
public:
// FIXME:
virtual ~ITabletPad() {
events.destroy.emit();
}
struct STabletPadGroup {
std::vector<uint32_t> buttons, strips, rings;
uint16_t modes = 0;
};
virtual libinput_device* getLibinputHandle();
virtual const std::string& getName() = 0;
uint16_t buttons = 0, rings = 0, strips = 0;
std::vector<std::string> paths;
std::vector<Hyprutils::Memory::CSharedPointer<STabletPadGroup>> groups;
//
struct SButtonEvent {
uint32_t timeMs = 0, button = 0;
bool down = false;
uint16_t mode = 0, group = 0;
};
enum eTabletPadRingSource : uint16_t {
AQ_TABLET_PAD_RING_SOURCE_UNKNOWN = 0,
AQ_TABLET_PAD_RING_SOURCE_FINGER,
};
enum eTabletPadStripSource : uint16_t {
AQ_TABLET_PAD_STRIP_SOURCE_UNKNOWN = 0,
AQ_TABLET_PAD_STRIP_SOURCE_FINGER,
};
struct SRingEvent {
uint32_t timeMs = 0;
eTabletPadRingSource source = AQ_TABLET_PAD_RING_SOURCE_UNKNOWN;
uint16_t ring = 0;
double pos = 0.0;
uint16_t mode = 0;
};
struct SStripEvent {
uint32_t timeMs = 0;
eTabletPadStripSource source = AQ_TABLET_PAD_STRIP_SOURCE_UNKNOWN;
uint16_t strip = 0;
double pos = 0.0;
uint16_t mode = 0;
};
struct {
Hyprutils::Signal::CSignal destroy;
Hyprutils::Signal::CSignal button;
Hyprutils::Signal::CSignal ring;
Hyprutils::Signal::CSignal strip;
Hyprutils::Signal::CSignal attach;
} events;
};
}

2
include/aquamarine/misc/Attachment.hpp
View File

@ -4,7 +4,7 @@
#include <hyprutils/memory/SharedPtr.hpp>
namespace Aquamarine {
enum eAttachmentType {
enum eAttachmentType : uint32_t {
AQ_ATTACHMENT_DRM_BUFFER = 0,
AQ_ATTACHMENT_DRM_KMS_UNIMPORTABLE,
};

4
include/aquamarine/output/Output.hpp
View File

@ -21,12 +21,12 @@ namespace Aquamarine {
std::optional<drmModeModeInfo> modeInfo; // if this is a drm mode, this will be populated.
};
enum eOutputPresentationMode {
enum eOutputPresentationMode : uint32_t {
AQ_OUTPUT_PRESENTATION_VSYNC = 0,
AQ_OUTPUT_PRESENTATION_IMMEDIATE, // likely tearing
};
enum eSubpixelMode {
enum eSubpixelMode : uint32_t {
AQ_SUBPIXEL_UNKNOWN = 0,
AQ_SUBPIXEL_NONE,
AQ_SUBPIXEL_HORIZONTAL_RGB,

323
src/backend/Session.cpp
View File

@ -8,6 +8,7 @@ extern "C" {
#include <xf86drm.h>
#include <sys/stat.h>
#include <xf86drmMode.h>
#include <linux/input.h>
}
using namespace Aquamarine;
@ -270,8 +271,14 @@ void Aquamarine::CSession::onReady() {
backend->events.newTouch.emit(SP<ITouch>(d->touch));
if (d->switchy)
backend->events.newSwitch.emit(SP<ITouch>(d->touch));
if (d->tablet)
backend->events.newTablet.emit(SP<ITablet>(d->tablet));
if (d->tabletPad)
backend->events.newTabletPad.emit(SP<ITabletPad>(d->tabletPad));
// FIXME: other devices.
for (auto& t : d->tabletTools) {
backend->events.newTabletTool.emit(SP<ITabletTool>(t));
}
}
}
@ -400,7 +407,8 @@ void Aquamarine::CSession::handleLibinputEvent(libinput_event* e) {
return;
}
auto hlDevice = ((CLibinputDevice*)data)->self.lock();
auto hlDevice = ((CLibinputDevice*)data)->self.lock();
bool destroyTool = false;
switch (eventType) {
case LIBINPUT_EVENT_DEVICE_ADDED:
@ -640,7 +648,145 @@ void Aquamarine::CSession::handleLibinputEvent(libinput_event* e) {
// --------- tbalet
// FIXME: other events
case LIBINPUT_EVENT_TABLET_PAD_BUTTON: {
auto tpe = libinput_event_get_tablet_pad_event(e);
hlDevice->tabletPad->events.button.emit(ITabletPad::SButtonEvent{
.timeMs = (uint32_t)(libinput_event_tablet_pad_get_time_usec(tpe) / 1000),
.button = libinput_event_tablet_pad_get_button_number(tpe),
.down = libinput_event_tablet_pad_get_button_state(tpe) == LIBINPUT_BUTTON_STATE_PRESSED,
.mode = (uint16_t)libinput_event_tablet_pad_get_mode(tpe),
.group = (uint16_t)libinput_tablet_pad_mode_group_get_index(libinput_event_tablet_pad_get_mode_group(tpe)),
});
break;
}
case LIBINPUT_EVENT_TABLET_PAD_RING: {
auto tpe = libinput_event_get_tablet_pad_event(e);
hlDevice->tabletPad->events.ring.emit(ITabletPad::SRingEvent{
.timeMs = (uint32_t)(libinput_event_tablet_pad_get_time_usec(tpe) / 1000),
.source = libinput_event_tablet_pad_get_ring_source(tpe) == LIBINPUT_TABLET_PAD_RING_SOURCE_UNKNOWN ? ITabletPad::AQ_TABLET_PAD_RING_SOURCE_UNKNOWN :
ITabletPad::AQ_TABLET_PAD_RING_SOURCE_FINGER,
.ring = (uint16_t)libinput_event_tablet_pad_get_ring_number(tpe),
.pos = libinput_event_tablet_pad_get_ring_position(tpe),
.mode = (uint16_t)libinput_event_tablet_pad_get_mode(tpe),
});
break;
}
case LIBINPUT_EVENT_TABLET_PAD_STRIP: {
auto tpe = libinput_event_get_tablet_pad_event(e);
hlDevice->tabletPad->events.strip.emit(ITabletPad::SStripEvent{
.timeMs = (uint32_t)(libinput_event_tablet_pad_get_time_usec(tpe) / 1000),
.source = libinput_event_tablet_pad_get_strip_source(tpe) == LIBINPUT_TABLET_PAD_STRIP_SOURCE_UNKNOWN ? ITabletPad::AQ_TABLET_PAD_STRIP_SOURCE_UNKNOWN :
ITabletPad::AQ_TABLET_PAD_STRIP_SOURCE_FINGER,
.strip = (uint16_t)libinput_event_tablet_pad_get_strip_number(tpe),
.pos = libinput_event_tablet_pad_get_strip_position(tpe),
.mode = (uint16_t)libinput_event_tablet_pad_get_mode(tpe),
});
break;
}
case LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY: {
auto tte = libinput_event_get_tablet_tool_event(e);
auto tool = hlDevice->toolFrom(libinput_event_tablet_tool_get_tool(tte));
hlDevice->tablet->events.proximity.emit(ITablet::SProximityEvent{
.tool = tool,
.timeMs = (uint32_t)(libinput_event_tablet_tool_get_time_usec(tte) / 1000),
.absolute = {libinput_event_tablet_tool_get_x_transformed(tte, 1), libinput_event_tablet_tool_get_y_transformed(tte, 1)},
.in = libinput_event_tablet_tool_get_proximity_state(tte) == LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN,
});
destroyTool = !libinput_tablet_tool_is_unique(libinput_event_tablet_tool_get_tool(tte)) &&
libinput_event_tablet_tool_get_proximity_state(tte) == LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT;
if (libinput_event_tablet_tool_get_proximity_state(tte) == LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT) {
std::erase(hlDevice->tabletTools, tool);
break;
}
// fallthrough. If this is proximity in, also process axis.
}
case LIBINPUT_EVENT_TABLET_TOOL_AXIS: {
auto tte = libinput_event_get_tablet_tool_event(e);
auto tool = hlDevice->toolFrom(libinput_event_tablet_tool_get_tool(tte));
ITablet::SAxisEvent event = {
.tool = tool,
.timeMs = (uint32_t)(libinput_event_tablet_tool_get_time_usec(tte) / 1000),
};
if (libinput_event_tablet_tool_x_has_changed(tte)) {
event.updatedAxes |= AQ_TABLET_TOOL_AXIS_X;
event.absolute.x = libinput_event_tablet_tool_get_x_transformed(tte, 1);
event.delta.x = libinput_event_tablet_tool_get_dx(tte);
}
if (libinput_event_tablet_tool_y_has_changed(tte)) {
event.updatedAxes |= AQ_TABLET_TOOL_AXIS_Y;
event.absolute.y = libinput_event_tablet_tool_get_y_transformed(tte, 1);
event.delta.y = libinput_event_tablet_tool_get_dy(tte);
}
if (libinput_event_tablet_tool_pressure_has_changed(tte)) {
event.updatedAxes |= AQ_TABLET_TOOL_AXIS_PRESSURE;
event.pressure = libinput_event_tablet_tool_get_pressure(tte);
}
if (libinput_event_tablet_tool_distance_has_changed(tte)) {
event.updatedAxes |= AQ_TABLET_TOOL_AXIS_DISTANCE;
event.distance = libinput_event_tablet_tool_get_distance(tte);
}
if (libinput_event_tablet_tool_tilt_x_has_changed(tte)) {
event.updatedAxes |= AQ_TABLET_TOOL_AXIS_TILT_X;
event.tilt.x = libinput_event_tablet_tool_get_tilt_x(tte);
}
if (libinput_event_tablet_tool_tilt_y_has_changed(tte)) {
event.updatedAxes |= AQ_TABLET_TOOL_AXIS_TILT_Y;
event.tilt.y = libinput_event_tablet_tool_get_tilt_y(tte);
}
if (libinput_event_tablet_tool_rotation_has_changed(tte)) {
event.updatedAxes |= AQ_TABLET_TOOL_AXIS_ROTATION;
event.rotation = libinput_event_tablet_tool_get_rotation(tte);
}
if (libinput_event_tablet_tool_slider_has_changed(tte)) {
event.updatedAxes |= AQ_TABLET_TOOL_AXIS_SLIDER;
event.slider = libinput_event_tablet_tool_get_slider_position(tte);
}
if (libinput_event_tablet_tool_wheel_has_changed(tte)) {
event.updatedAxes |= AQ_TABLET_TOOL_AXIS_WHEEL;
event.wheelDelta = libinput_event_tablet_tool_get_wheel_delta(tte);
}
hlDevice->tablet->events.axis.emit(event);
if (destroyTool)
std::erase(hlDevice->tabletTools, tool);
break;
}
case LIBINPUT_EVENT_TABLET_TOOL_TIP: {
auto tte = libinput_event_get_tablet_tool_event(e);
auto tool = hlDevice->toolFrom(libinput_event_tablet_tool_get_tool(tte));
hlDevice->tablet->events.tip.emit(ITablet::STipEvent{
.tool = tool,
.timeMs = (uint32_t)(libinput_event_tablet_tool_get_time_usec(tte) / 1000),
.absolute = {libinput_event_tablet_tool_get_x_transformed(tte, 1), libinput_event_tablet_tool_get_y_transformed(tte, 1)},
.down = libinput_event_tablet_tool_get_tip_state(tte) == LIBINPUT_TABLET_TOOL_TIP_DOWN,
});
break;
}
case LIBINPUT_EVENT_TABLET_TOOL_BUTTON: {
auto tte = libinput_event_get_tablet_tool_event(e);
auto tool = hlDevice->toolFrom(libinput_event_tablet_tool_get_tool(tte));
hlDevice->tablet->events.button.emit(ITablet::SButtonEvent{
.tool = tool,
.timeMs = (uint32_t)(libinput_event_tablet_tool_get_time_usec(tte) / 1000),
.button = libinput_event_tablet_tool_get_button(tte),
.down = libinput_event_tablet_tool_get_button_state(tte) == LIBINPUT_BUTTON_STATE_PRESSED,
});
break;
}
default: break;
}
@ -686,13 +832,50 @@ void Aquamarine::CLibinputDevice::init() {
session->backend->events.newSwitch.emit(SP<ISwitch>(switchy));
}
// FIXME: other devices
if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_TABLET_TOOL)) {
tablet = makeShared<CLibinputTablet>(self.lock());
if (session->backend->ready)
session->backend->events.newTablet.emit(SP<ITablet>(tablet));
}
if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_TABLET_PAD)) {
tabletPad = makeShared<CLibinputTabletPad>(self.lock());
if (session->backend->ready)
session->backend->events.newTabletPad.emit(SP<ITabletPad>(tabletPad));
}
}
Aquamarine::CLibinputDevice::~CLibinputDevice() {
libinput_device_unref(device);
}
SP<CLibinputTabletTool> Aquamarine::CLibinputDevice::toolFrom(libinput_tablet_tool* tool) {
for (auto& t : tabletTools) {
if (t->libinputTool == tool)
return t;
}
auto newt = makeShared<CLibinputTabletTool>(self.lock(), tool);
tabletTools.emplace_back(newt);
if (session->backend->ready)
session->backend->events.newTabletTool.emit(SP<ITabletTool>(newt));
return newt;
}
static ITabletTool::eTabletToolType aqTypeFromLibinput(libinput_tablet_tool_type value) {
switch (value) {
case LIBINPUT_TABLET_TOOL_TYPE_PEN: return ITabletTool::AQ_TABLET_TOOL_TYPE_PEN;
case LIBINPUT_TABLET_TOOL_TYPE_ERASER: return ITabletTool::AQ_TABLET_TOOL_TYPE_ERASER;
case LIBINPUT_TABLET_TOOL_TYPE_BRUSH: return ITabletTool::AQ_TABLET_TOOL_TYPE_BRUSH;
case LIBINPUT_TABLET_TOOL_TYPE_PENCIL: return ITabletTool::AQ_TABLET_TOOL_TYPE_PENCIL;
case LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH: return ITabletTool::AQ_TABLET_TOOL_TYPE_AIRBRUSH;
case LIBINPUT_TABLET_TOOL_TYPE_MOUSE: return ITabletTool::AQ_TABLET_TOOL_TYPE_MOUSE;
case LIBINPUT_TABLET_TOOL_TYPE_LENS: return ITabletTool::AQ_TABLET_TOOL_TYPE_LENS;
case LIBINPUT_TABLET_TOOL_TYPE_TOTEM: return ITabletTool::AQ_TABLET_TOOL_TYPE_TOTEM;
}
return ITabletTool::AQ_TABLET_TOOL_TYPE_INVALID;
}
Aquamarine::CLibinputKeyboard::CLibinputKeyboard(SP<CLibinputDevice> dev) : device(dev) {}
libinput_device* Aquamarine::CLibinputKeyboard::getLibinputHandle() {
@ -760,3 +943,135 @@ const std::string& Aquamarine::CLibinputSwitch::getName() {
return AQ_UNKNOWN_DEVICE_NAME;
return device->name;
}
Aquamarine::CLibinputTablet::CLibinputTablet(Hyprutils::Memory::CSharedPointer<CLibinputDevice> dev) : device(dev) {
if (libinput_device_get_id_bustype(device->device) == BUS_USB) {
usbVendorID = libinput_device_get_id_vendor(device->device);
usbProductID = libinput_device_get_id_product(device->device);
}
double w = 0, h = 0;
libinput_device_get_size(dev->device, &w, &h);
physicalSize = {w, h};
auto udevice = libinput_device_get_udev_device(device->device);
paths.emplace_back(udev_device_get_syspath(udevice));
}
libinput_device* Aquamarine::CLibinputTablet::getLibinputHandle() {
if (!device)
return nullptr;
return device->device;
}
const std::string& Aquamarine::CLibinputTablet::getName() {
if (!device)
return AQ_UNKNOWN_DEVICE_NAME;
return device->name;
}
Aquamarine::CLibinputTabletTool::CLibinputTabletTool(Hyprutils::Memory::CSharedPointer<CLibinputDevice> dev, libinput_tablet_tool* tool) : device(dev), libinputTool(tool) {
type = aqTypeFromLibinput(libinput_tablet_tool_get_type(libinputTool));
serial = libinput_tablet_tool_get_serial(libinputTool);
id = libinput_tablet_tool_get_tool_id(libinputTool);
libinput_tablet_tool_ref(tool);
capabilities = 0;
if (libinput_tablet_tool_has_distance(tool))
capabilities |= AQ_TABLET_TOOL_CAPABILITY_DISTANCE;
if (libinput_tablet_tool_has_pressure(tool))
capabilities |= AQ_TABLET_TOOL_CAPABILITY_PRESSURE;
if (libinput_tablet_tool_has_tilt(tool))
capabilities |= AQ_TABLET_TOOL_CAPABILITY_TILT;
if (libinput_tablet_tool_has_rotation(tool))
capabilities |= AQ_TABLET_TOOL_CAPABILITY_ROTATION;
if (libinput_tablet_tool_has_slider(tool))
capabilities |= AQ_TABLET_TOOL_CAPABILITY_SLIDER;
if (libinput_tablet_tool_has_wheel(tool))
capabilities |= AQ_TABLET_TOOL_CAPABILITY_WHEEL;
libinput_tablet_tool_set_user_data(tool, this);
}
Aquamarine::CLibinputTabletTool::~CLibinputTabletTool() {
libinput_tablet_tool_unref(libinputTool);
}
libinput_device* Aquamarine::CLibinputTabletTool::getLibinputHandle() {
if (!device)
return nullptr;
return device->device;
}
const std::string& Aquamarine::CLibinputTabletTool::getName() {
if (!device)
return AQ_UNKNOWN_DEVICE_NAME;
return device->name;
}
Aquamarine::CLibinputTabletPad::CLibinputTabletPad(Hyprutils::Memory::CSharedPointer<CLibinputDevice> dev) : device(dev) {
buttons = libinput_device_tablet_pad_get_num_buttons(device->device);
rings = libinput_device_tablet_pad_get_num_rings(device->device);
strips = libinput_device_tablet_pad_get_num_strips(device->device);
auto udevice = libinput_device_get_udev_device(device->device);
paths.emplace_back(udev_device_get_syspath(udevice));
int groupsno = libinput_device_tablet_pad_get_num_mode_groups(device->device);
for (size_t i = 0; i < groupsno; ++i) {
auto g = createGroupFromID(i);
if (g)
groups.emplace_back(g);
}
}
Aquamarine::CLibinputTabletPad::~CLibinputTabletPad() {
int groups = libinput_device_tablet_pad_get_num_mode_groups(device->device);
for (int i = 0; i < groups; ++i) {
auto g = libinput_device_tablet_pad_get_mode_group(device->device, i);
libinput_tablet_pad_mode_group_unref(g);
}
}
libinput_device* Aquamarine::CLibinputTabletPad::getLibinputHandle() {
if (!device)
return nullptr;
return device->device;
}
const std::string& Aquamarine::CLibinputTabletPad::getName() {
if (!device)
return AQ_UNKNOWN_DEVICE_NAME;
return device->name;
}
SP<ITabletPad::STabletPadGroup> Aquamarine::CLibinputTabletPad::createGroupFromID(int id) {
auto libinputGroup = libinput_device_tablet_pad_get_mode_group(device->device, id);
auto group = makeShared<STabletPadGroup>();
for (size_t i = 0; i < rings; ++i) {
if (!libinput_tablet_pad_mode_group_has_ring(libinputGroup, i))
continue;
group->rings.push_back(i);
}
for (size_t i = 0; i < strips; ++i) {
if (!libinput_tablet_pad_mode_group_has_strip(libinputGroup, i))
continue;
group->strips.push_back(i);
}
for (size_t i = 0; i < buttons; ++i) {
if (!libinput_tablet_pad_mode_group_has_button(libinputGroup, i))
continue;
group->buttons.push_back(i);
}
group->modes = libinput_tablet_pad_mode_group_get_num_modes(libinputGroup);
return group;
}

12
src/input/Input.cpp
View File

@ -16,6 +16,18 @@ libinput_device* Aquamarine::ISwitch::getLibinputHandle() {
return nullptr;
}
libinput_device* Aquamarine::ITabletTool::getLibinputHandle() {
return nullptr;
}
libinput_device* Aquamarine::ITablet::getLibinputHandle() {
return nullptr;
}
libinput_device* Aquamarine::ITabletPad::getLibinputHandle() {
return nullptr;
}
void Aquamarine::IKeyboard::updateLEDs(uint32_t leds) {
;
}

6
src/utils/Shared.cpp
View File

@ -6,10 +6,8 @@ bool Aquamarine::envEnabled(const std::string& env) {
return e && e == std::string{"1"};
}
static bool trace = []() -> bool {
return Aquamarine::envEnabled("AQ_TRACE");
}();
static bool trace = []() -> bool { return Aquamarine::envEnabled("AQ_TRACE"); }();
bool Aquamarine::isTrace() {
bool Aquamarine::isTrace() {
return trace;
}