@desklink/host 0.1.0

package/engine/vendor/inputtino/src/uinput/mouse.cpp

@@ -0,0 +1,199 @@
+#include "inputtino/input.hpp"
+#include <cmath>
+#include <inputtino/protected_types.hpp>
+#include <string.h>
+
+namespace inputtino {
+
+std::vector<std::string> Mouse::get_nodes() const {
+  std::vector<std::string> nodes;
+
+  if (auto mouse = _state->mouse_rel.get()) {
+    nodes.emplace_back(libevdev_uinput_get_devnode(mouse));
+  }
+
+  if (auto mouse = _state->mouse_abs.get()) {
+    nodes.emplace_back(libevdev_uinput_get_devnode(mouse));
+  }
+
+  return nodes;
+}
+
+constexpr int ABS_MAX_WIDTH = 19200;
+constexpr int ABS_MAX_HEIGHT = 12000;
+
+static Result<libevdev_uinput_ptr> create_mouse(const DeviceDefinition &device) {
+  libevdev *dev = libevdev_new();
+  libevdev_uinput *uidev;
+
+  libevdev_set_name(dev, device.name.c_str());
+  libevdev_set_id_vendor(dev, device.vendor_id);
+  libevdev_set_id_product(dev, device.product_id);
+  libevdev_set_id_version(dev, device.version);
+  libevdev_set_id_bustype(dev, BUS_USB);
+
+  libevdev_enable_event_type(dev, EV_KEY);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_LEFT, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_RIGHT, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_MIDDLE, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_SIDE, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_EXTRA, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_FORWARD, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_BACK, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TASK, nullptr);
+
+  libevdev_enable_event_type(dev, EV_REL);
+  libevdev_enable_event_code(dev, EV_REL, REL_X, nullptr);
+  libevdev_enable_event_code(dev, EV_REL, REL_Y, nullptr);
+
+  libevdev_enable_event_code(dev, EV_REL, REL_WHEEL, nullptr);
+  libevdev_enable_event_code(dev, EV_REL, REL_WHEEL_HI_RES, nullptr);
+  libevdev_enable_event_code(dev, EV_REL, REL_HWHEEL, nullptr);
+  libevdev_enable_event_code(dev, EV_REL, REL_HWHEEL_HI_RES, nullptr);
+
+  libevdev_enable_event_type(dev, EV_MSC);
+  libevdev_enable_event_code(dev, EV_MSC, MSC_SCAN, nullptr);
+
+  auto err = libevdev_uinput_create_from_device(dev, LIBEVDEV_UINPUT_OPEN_MANAGED, &uidev);
+  libevdev_free(dev);
+  if (err != 0) {
+    return Error(strerror(-err));
+  }
+
+  return libevdev_uinput_ptr{uidev, ::libevdev_uinput_destroy};
+}
+
+static Result<libevdev_uinput_ptr> create_mouse_abs(const DeviceDefinition &device) {
+  libevdev *dev = libevdev_new();
+  libevdev_uinput *uidev;
+
+  libevdev_set_name(dev, (device.name + " (absolute)").c_str());
+  libevdev_set_id_vendor(dev, device.vendor_id);
+  libevdev_set_id_product(dev, device.product_id);
+  libevdev_set_id_version(dev, device.version);
+  libevdev_set_id_bustype(dev, BUS_USB);
+
+  libevdev_enable_property(dev, INPUT_PROP_DIRECT);
+  libevdev_enable_event_type(dev, EV_KEY);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_LEFT, nullptr);
+
+  struct input_absinfo absinfo {
+    .value = 0, .minimum = 0, .maximum = 0, .fuzz = 1, .flat = 0, .resolution = 28
+  };
+  libevdev_enable_event_type(dev, EV_ABS);
+
+  absinfo.maximum = ABS_MAX_WIDTH;
+  libevdev_enable_event_code(dev, EV_ABS, ABS_X, &absinfo);
+  absinfo.maximum = ABS_MAX_HEIGHT;
+  libevdev_enable_event_code(dev, EV_ABS, ABS_Y, &absinfo);
+
+  auto err = libevdev_uinput_create_from_device(dev, LIBEVDEV_UINPUT_OPEN_MANAGED, &uidev);
+  libevdev_free(dev);
+  if (err != 0) {
+    return Error(strerror(-err));
+  }
+
+  return libevdev_uinput_ptr{uidev, ::libevdev_uinput_destroy};
+}
+
+Mouse::Mouse() : _state(std::make_shared<MouseState>()) {}
+
+Mouse::~Mouse() {
+  if (_state) {
+    _state.reset();
+  }
+}
+
+Result<Mouse> Mouse::create(const DeviceDefinition &device) {
+  auto mouse = Mouse();
+
+  auto mouse_rel_or_error = create_mouse(device);
+  if (mouse_rel_or_error) {
+    mouse._state->mouse_rel = std::move(*mouse_rel_or_error);
+  } else {
+    return Error(mouse_rel_or_error.getErrorMessage());
+  }
+
+  auto mouse_abs_or_error = create_mouse_abs(device);
+  if (mouse_abs_or_error) {
+    mouse._state->mouse_abs = std::move(*mouse_abs_or_error);
+  } else {
+    return Error(mouse_abs_or_error.getErrorMessage());
+  }
+
+  return std::move(mouse);
+}
+
+void Mouse::move(int delta_x, int delta_y) {
+  if (auto mouse = _state->mouse_rel.get()) {
+    libevdev_uinput_write_event(mouse, EV_REL, REL_X, delta_x);
+    libevdev_uinput_write_event(mouse, EV_REL, REL_Y, delta_y);
+    libevdev_uinput_write_event(mouse, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+void Mouse::move_abs(int x, int y, int screen_width, int screen_height) {
+  int scaled_x = (int)std::lround((ABS_MAX_WIDTH / (double)screen_width) * x);
+  int scaled_y = (int)std::lround((ABS_MAX_HEIGHT / (double)screen_height) * y);
+
+  if (auto mouse = _state->mouse_abs.get()) {
+    libevdev_uinput_write_event(mouse, EV_ABS, ABS_X, scaled_x);
+    libevdev_uinput_write_event(mouse, EV_ABS, ABS_Y, scaled_y);
+    libevdev_uinput_write_event(mouse, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+static std::pair<int, int> btn_to_uinput(Mouse::MOUSE_BUTTON button) {
+  switch (button) {
+  case Mouse::LEFT:
+    return {BTN_LEFT, 90001};
+  case Mouse::MIDDLE:
+    return {BTN_MIDDLE, 90003};
+  case Mouse::RIGHT:
+    return {BTN_RIGHT, 90002};
+  case Mouse::SIDE:
+    return {BTN_SIDE, 90004};
+  default:
+    return {BTN_EXTRA, 90005};
+  }
+}
+
+void Mouse::press(Mouse::MOUSE_BUTTON button) {
+  if (auto mouse = _state->mouse_rel.get()) {
+    auto [btn_type, scan_code] = btn_to_uinput(button);
+    libevdev_uinput_write_event(mouse, EV_MSC, MSC_SCAN, scan_code);
+    libevdev_uinput_write_event(mouse, EV_KEY, btn_type, 1);
+    libevdev_uinput_write_event(mouse, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+void Mouse::release(Mouse::MOUSE_BUTTON button) {
+  if (auto mouse = _state->mouse_rel.get()) {
+    auto [btn_type, scan_code] = btn_to_uinput(button);
+    libevdev_uinput_write_event(mouse, EV_MSC, MSC_SCAN, scan_code);
+    libevdev_uinput_write_event(mouse, EV_KEY, btn_type, 0);
+    libevdev_uinput_write_event(mouse, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+void Mouse::horizontal_scroll(int high_res_distance) {
+  int distance = high_res_distance / 120;
+
+  if (auto mouse = _state->mouse_rel.get()) {
+    libevdev_uinput_write_event(mouse, EV_REL, REL_HWHEEL, distance);
+    libevdev_uinput_write_event(mouse, EV_REL, REL_HWHEEL_HI_RES, high_res_distance);
+    libevdev_uinput_write_event(mouse, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+void Mouse::vertical_scroll(int high_res_distance) {
+  int distance = high_res_distance / 120;
+
+  if (auto mouse = _state->mouse_rel.get()) {
+    libevdev_uinput_write_event(mouse, EV_REL, REL_WHEEL, distance);
+    libevdev_uinput_write_event(mouse, EV_REL, REL_WHEEL_HI_RES, high_res_distance);
+    libevdev_uinput_write_event(mouse, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+} // namespace inputtino

package/engine/vendor/inputtino/src/uinput/pentablet.cpp

@@ -0,0 +1,162 @@
+#include "inputtino/input.hpp"
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <inputtino/protected_types.hpp>
+
+namespace inputtino {
+
+static const std::map<int, int> tool_to_linux = {
+    {PenTablet::PEN, BTN_TOOL_PEN},
+    {PenTablet::ERASER, BTN_TOOL_RUBBER},
+    {PenTablet::BRUSH, BTN_TOOL_BRUSH},
+    {PenTablet::PENCIL, BTN_TOOL_PENCIL},
+    {PenTablet::AIRBRUSH, BTN_TOOL_AIRBRUSH},
+    {PenTablet::TOUCH, BTN_TOUCH},
+};
+
+static const std::map<int, int> btn_to_linux = {
+    {PenTablet::PRIMARY, BTN_STYLUS},
+    {PenTablet::SECONDARY, BTN_STYLUS2},
+    {PenTablet::TERTIARY, BTN_STYLUS3},
+};
+
+static constexpr int MAX_X = 19200;
+static constexpr int MAX_Y = 10800;
+static constexpr int PRESSURE_MAX = 4096;
+static constexpr int DISTANCE_MAX = 1024;
+static constexpr int RESOLUTION = 28;
+
+Result<libevdev_uinput_ptr> create_tablet(const DeviceDefinition &device) {
+  libevdev *dev = libevdev_new();
+  libevdev_uinput *uidev;
+
+  libevdev_set_name(dev, device.name.c_str());
+  libevdev_set_id_vendor(dev, device.vendor_id);
+  libevdev_set_id_product(dev, device.product_id);
+  libevdev_set_id_version(dev, device.version);
+  libevdev_set_id_bustype(dev, BUS_USB);
+
+  libevdev_enable_event_type(dev, EV_KEY);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOUCH, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_STYLUS, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_STYLUS2, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_STYLUS3, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOOL_PEN, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOOL_RUBBER, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOOL_BRUSH, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOOL_PENCIL, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOOL_AIRBRUSH, nullptr);
+
+  libevdev_enable_event_type(dev, EV_ABS);
+  input_absinfo abs_x{0, 0, MAX_X, 1, 0, RESOLUTION};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_X, &abs_x);
+
+  input_absinfo abs_y{0, 0, MAX_Y, 1, 0, RESOLUTION};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_Y, &abs_y);
+
+  input_absinfo pressure{0, 0, PRESSURE_MAX, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_PRESSURE, &pressure);
+
+  input_absinfo distance{0, 0, DISTANCE_MAX, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_DISTANCE, &distance);
+  input_absinfo abs_tilt{0, -90, 90, 0, 0, RESOLUTION}; // If resolution is nonzero, it's in units/radian.
+  libevdev_enable_event_code(dev, EV_ABS, ABS_TILT_X, &abs_tilt);
+  libevdev_enable_event_code(dev, EV_ABS, ABS_TILT_Y, &abs_tilt);
+
+  // https://docs.kernel.org/input/event-codes.html#tablets
+  libevdev_enable_property(dev, INPUT_PROP_POINTER);
+  libevdev_enable_property(dev, INPUT_PROP_DIRECT);
+  auto err = libevdev_uinput_create_from_device(dev, LIBEVDEV_UINPUT_OPEN_MANAGED, &uidev);
+  libevdev_free(dev);
+  if (err != 0) {
+    return Error(strerror(-err));
+  }
+
+  return libevdev_uinput_ptr{uidev, ::libevdev_uinput_destroy};
+}
+
+PenTablet::PenTablet() : _state(std::make_shared<PenTabletState>()) {}
+
+PenTablet::~PenTablet() {
+  if (_state) {
+    _state.reset();
+  }
+}
+
+Result<PenTablet> PenTablet::create(const DeviceDefinition &device) {
+  auto tablet = create_tablet(device);
+  if (tablet) {
+    PenTablet pt;
+    pt._state->pen_tablet = std::move(*tablet);
+    return std::move(pt);
+  } else {
+    return Error(tablet.getErrorMessage());
+  }
+}
+
+std::vector<std::string> PenTablet::get_nodes() const {
+  std::vector<std::string> nodes;
+
+  if (auto kb = _state->pen_tablet.get()) {
+    nodes.emplace_back(libevdev_uinput_get_devnode(kb));
+  }
+
+  return nodes;
+}
+
+static inline float deg2rad(float degree) {
+  return M_PI * degree / 180.0;
+}
+
+void PenTablet::place_tool(
+    PenTablet::TOOL_TYPE tool_type, float x, float y, float pressure, float distance, float tilt_x, float tilt_y) {
+  if (auto tablet = _state->pen_tablet.get()) {
+    if (tool_type != PenTablet::SAME_AS_BEFORE && tool_type != _state->last_tool) {
+      libevdev_uinput_write_event(tablet, EV_KEY, tool_to_linux.at(tool_type), 1);
+
+      if (_state->last_tool != PenTablet::SAME_AS_BEFORE)
+        libevdev_uinput_write_event(tablet, EV_KEY, tool_to_linux.at(_state->last_tool), 0);
+
+      _state->last_tool = tool_type;
+    }
+
+    int scaled_x = (int)std::lround(MAX_X * x);
+    int scaled_y = (int)std::lround(MAX_Y * y);
+    libevdev_uinput_write_event(tablet, EV_ABS, ABS_X, scaled_x);
+    libevdev_uinput_write_event(tablet, EV_ABS, ABS_Y, scaled_y);
+
+    if (pressure >= 0) {
+      int scaled_pressure = (int)std::lround(pressure * PRESSURE_MAX);
+      libevdev_uinput_write_event(tablet, EV_ABS, ABS_PRESSURE, scaled_pressure);
+      // when there's pressure, the tool must be touching the tablet
+      libevdev_uinput_write_event(tablet, EV_ABS, ABS_DISTANCE, 0);
+    }
+
+    if (distance >= 0) {
+      int scaled_distance = (int)std::lround(distance * DISTANCE_MAX);
+      libevdev_uinput_write_event(tablet, EV_ABS, ABS_DISTANCE, scaled_distance);
+      // when there's distance, the tool can't be touching the tablet
+      libevdev_uinput_write_event(tablet, EV_ABS, ABS_PRESSURE, 0);
+    }
+
+    auto scaled_tilt_x = std::clamp(tilt_x, -90.0f, 90.0f);
+    scaled_tilt_x = deg2rad(scaled_tilt_x * RESOLUTION);
+    libevdev_uinput_write_event(tablet, EV_ABS, ABS_TILT_X, (int)std::lround(scaled_tilt_x));
+
+    auto scaled_tilt_y = std::clamp(tilt_y, -90.0f, 90.0f);
+    scaled_tilt_y = deg2rad(scaled_tilt_y * RESOLUTION);
+    libevdev_uinput_write_event(tablet, EV_ABS, ABS_TILT_Y, (int)std::lround(scaled_tilt_y));
+
+    libevdev_uinput_write_event(tablet, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+void PenTablet::set_btn(PenTablet::BTN_TYPE btn, bool pressed) {
+  if (auto tablet = _state->pen_tablet.get()) {
+    libevdev_uinput_write_event(tablet, EV_KEY, btn_to_linux.at(btn), pressed ? 1 : 0);
+    libevdev_uinput_write_event(tablet, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+} // namespace inputtino

package/engine/vendor/inputtino/src/uinput/touchscreen.cpp

@@ -0,0 +1,140 @@
+#include "inputtino/input.hpp"
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <inputtino/protected_types.hpp>
+
+namespace inputtino {
+
+std::vector<std::string> TouchScreen::get_nodes() const {
+  std::vector<std::string> nodes;
+
+  if (auto kb = _state->touch_screen.get()) {
+    nodes.emplace_back(libevdev_uinput_get_devnode(kb));
+  }
+
+  return nodes;
+}
+
+static constexpr int TOUCH_MAX_X = 19200;
+static constexpr int TOUCH_MAX_Y = 10800;
+static constexpr int NUM_FINGERS = 16;
+static constexpr int PRESSURE_MAX = 253;
+
+Result<libevdev_uinput_ptr> create_touch_screen(const DeviceDefinition &device) {
+  libevdev *dev = libevdev_new();
+  libevdev_uinput *uidev;
+
+  libevdev_set_name(dev, device.name.c_str());
+  libevdev_set_id_vendor(dev, device.vendor_id);
+  libevdev_set_id_product(dev, device.product_id);
+  libevdev_set_id_version(dev, device.version);
+  libevdev_set_id_bustype(dev, BUS_USB);
+
+  libevdev_enable_event_type(dev, EV_KEY);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOUCH, nullptr);
+
+  libevdev_enable_event_type(dev, EV_ABS);
+  input_absinfo mt_slot{0, 0, NUM_FINGERS - 1, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_SLOT, &mt_slot);
+
+  input_absinfo abs_x{0, 0, TOUCH_MAX_X, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_X, &abs_x);
+  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_POSITION_X, &abs_x);
+
+  input_absinfo abs_y{0, 0, TOUCH_MAX_Y, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_Y, &abs_y);
+  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_POSITION_Y, &abs_y);
+
+  input_absinfo tracking{0, 0, 65535, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_TRACKING_ID, &tracking);
+
+  input_absinfo abs_pressure{0, 0, PRESSURE_MAX, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_PRESSURE, &abs_pressure);
+  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_PRESSURE, &abs_pressure);
+  // TODO:
+  //  input_absinfo touch{0, 0, TOUCH_MAX, 4, 0, 0};
+  //  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_TOUCH_MAJOR, &touch);
+  //  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_TOUCH_MINOR, &touch);
+  input_absinfo orientation{0, -90, 90, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_ORIENTATION, &orientation);
+
+  // https://docs.kernel.org/input/event-codes.html#touchscreens
+  libevdev_enable_property(dev, INPUT_PROP_DIRECT);
+
+  auto err = libevdev_uinput_create_from_device(dev, LIBEVDEV_UINPUT_OPEN_MANAGED, &uidev);
+  libevdev_free(dev);
+  if (err != 0) {
+    return Error(strerror(-err));
+  }
+
+  return libevdev_uinput_ptr{uidev, ::libevdev_uinput_destroy};
+}
+
+TouchScreen::TouchScreen() : _state(std::make_shared<TouchScreenState>()) {}
+
+TouchScreen::~TouchScreen() {
+  if (_state) {
+    _state.reset();
+  }
+}
+
+Result<TouchScreen> TouchScreen::create(const DeviceDefinition &device) {
+  auto touch_screen = create_touch_screen(device);
+  if (touch_screen) {
+    TouchScreen ts;
+    ts._state->touch_screen = std::move(*touch_screen);
+    return ts;
+  } else {
+    return Error(touch_screen.getErrorMessage());
+  }
+}
+
+void TouchScreen::place_finger(int finger_nr, float x, float y, float pressure, int orientation) {
+  if (auto ts = this->_state->touch_screen.get()) {
+    int scaled_x = (int)std::lround(TOUCH_MAX_X * x);
+    int scaled_y = (int)std::lround(TOUCH_MAX_Y * y);
+    int scaled_orientation = std::clamp(orientation, -90, 90);
+
+    if (_state->fingers.find(finger_nr) == _state->fingers.end()) {
+      // Wow, a wild finger appeared!
+      auto finger_slot = _state->fingers.size() + 1;
+      _state->fingers[finger_nr] = finger_slot;
+      libevdev_uinput_write_event(ts, EV_ABS, ABS_MT_SLOT, finger_slot);
+      libevdev_uinput_write_event(ts, EV_ABS, ABS_MT_TRACKING_ID, finger_slot);
+    } else {
+      // I already know this finger, let's check the slot
+      auto finger_slot = _state->fingers[finger_nr];
+      if (_state->current_slot != finger_slot) {
+        libevdev_uinput_write_event(ts, EV_ABS, ABS_MT_SLOT, finger_slot);
+        _state->current_slot = finger_slot;
+      }
+    }
+
+    libevdev_uinput_write_event(ts, EV_ABS, ABS_X, scaled_x);
+    libevdev_uinput_write_event(ts, EV_ABS, ABS_MT_POSITION_X, scaled_x);
+    libevdev_uinput_write_event(ts, EV_ABS, ABS_Y, scaled_y);
+    libevdev_uinput_write_event(ts, EV_ABS, ABS_MT_POSITION_Y, scaled_y);
+    libevdev_uinput_write_event(ts, EV_ABS, ABS_PRESSURE, (int)std::lround(pressure * PRESSURE_MAX));
+    libevdev_uinput_write_event(ts, EV_ABS, ABS_MT_PRESSURE, (int)std::lround(pressure * PRESSURE_MAX));
+    libevdev_uinput_write_event(ts, EV_ABS, ABS_MT_ORIENTATION, scaled_orientation);
+
+    libevdev_uinput_write_event(ts, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+void TouchScreen::release_finger(int finger_nr) {
+  if (auto ts = this->_state->touch_screen.get()) {
+    auto finger_slot = _state->fingers[finger_nr];
+    if (_state->current_slot != finger_slot) {
+      libevdev_uinput_write_event(ts, EV_ABS, ABS_MT_SLOT, finger_slot);
+      _state->current_slot = -1;
+    }
+    _state->fingers.erase(finger_nr);
+    libevdev_uinput_write_event(ts, EV_ABS, ABS_MT_TRACKING_ID, -1);
+
+    libevdev_uinput_write_event(ts, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+} // namespace inputtino

package/engine/vendor/inputtino/src/uinput/trackpad.cpp

@@ -0,0 +1,192 @@
+#include "inputtino/input.hpp"
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <inputtino/protected_types.hpp>
+
+namespace inputtino {
+
+std::vector<std::string> Trackpad::get_nodes() const {
+  std::vector<std::string> nodes;
+
+  if (auto kb = _state->trackpad.get()) {
+    nodes.emplace_back(libevdev_uinput_get_devnode(kb));
+  }
+
+  return nodes;
+}
+
+static constexpr int TOUCH_MAX_X = 19200;
+static constexpr int TOUCH_MAX_Y = 10800;
+// static constexpr int TOUCH_MAX = 1020;
+static constexpr int NUM_FINGERS = 16; // Apple's touchpads support 16 touches
+static constexpr int PRESSURE_MAX = 253;
+
+Result<libevdev_uinput_ptr> create_trackpad(const DeviceDefinition &device) {
+  libevdev *dev = libevdev_new();
+  libevdev_uinput *uidev;
+
+  libevdev_set_name(dev, device.name.c_str());
+  libevdev_set_id_vendor(dev, device.vendor_id);
+  libevdev_set_id_product(dev, device.product_id);
+  libevdev_set_id_version(dev, device.version);
+  libevdev_set_id_bustype(dev, BUS_USB);
+
+  libevdev_enable_event_type(dev, EV_KEY);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_LEFT, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOUCH, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOOL_FINGER, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOOL_DOUBLETAP, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOOL_TRIPLETAP, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOOL_QUADTAP, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TOOL_QUINTTAP, nullptr);
+
+  libevdev_enable_event_type(dev, EV_ABS);
+  input_absinfo mt_slot{0, 0, NUM_FINGERS - 1, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_SLOT, &mt_slot);
+
+  input_absinfo abs_x{0, 0, TOUCH_MAX_X, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_X, &abs_x);
+  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_POSITION_X, &abs_x);
+
+  input_absinfo abs_y{0, 0, TOUCH_MAX_Y, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_Y, &abs_y);
+  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_POSITION_Y, &abs_y);
+
+  input_absinfo tracking{0, 0, 65535, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_TRACKING_ID, &tracking);
+
+  input_absinfo abs_pressure{0, 0, PRESSURE_MAX, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_PRESSURE, &abs_pressure);
+  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_PRESSURE, &abs_pressure);
+  // TODO:
+  //  input_absinfo touch{0, 0, TOUCH_MAX, 4, 0, 0};
+  //  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_TOUCH_MAJOR, &touch);
+  //  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_TOUCH_MINOR, &touch);
+  input_absinfo orientation{0, -90, 90, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_MT_ORIENTATION, &orientation);
+
+  // https://docs.kernel.org/input/event-codes.html#trackpads
+  libevdev_enable_property(dev, INPUT_PROP_POINTER);
+  libevdev_enable_property(dev, INPUT_PROP_BUTTONPAD);
+
+  auto err = libevdev_uinput_create_from_device(dev, LIBEVDEV_UINPUT_OPEN_MANAGED, &uidev);
+  libevdev_free(dev);
+  if (err != 0) {
+    return Error(strerror(-err));
+  }
+
+  return libevdev_uinput_ptr{uidev, ::libevdev_uinput_destroy};
+}
+
+Trackpad::Trackpad() : _state(std::make_shared<TrackpadState>()) {}
+Trackpad::~Trackpad() {
+  if (_state) {
+    _state.reset();
+  }
+}
+
+Result<Trackpad> Trackpad::create(const DeviceDefinition &device) {
+  auto trackpad_el = create_trackpad(device);
+  if (trackpad_el) {
+    Trackpad trackpad;
+    trackpad._state->trackpad = std::move(*trackpad_el);
+    return std::move(trackpad);
+  } else {
+    return Error(trackpad_el.getErrorMessage());
+  }
+}
+
+void Trackpad::place_finger(int finger_nr, float x, float y, float pressure, int orientation) {
+  if (auto touchpad = this->_state->trackpad.get()) {
+    int scaled_x = (int)std::lround(TOUCH_MAX_X * x);
+    int scaled_y = (int)std::lround(TOUCH_MAX_Y * y);
+    int scaled_orientation = std::clamp(orientation, -90, 90);
+
+    if (_state->fingers.find(finger_nr) == _state->fingers.end()) {
+      // Wow, a wild finger appeared!
+      auto finger_slot = _state->fingers.size() + 1;
+      _state->fingers[finger_nr] = finger_slot;
+      libevdev_uinput_write_event(touchpad, EV_ABS, ABS_MT_SLOT, finger_slot);
+      libevdev_uinput_write_event(touchpad, EV_ABS, ABS_MT_TRACKING_ID, finger_slot);
+      auto nr_fingers = _state->fingers.size();
+      { // Update number of fingers pressed
+        if (nr_fingers == 1) {
+          libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_FINGER, 1);
+          libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOUCH, 1);
+        } else if (nr_fingers == 2) {
+          libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_FINGER, 0);
+          libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
+        } else if (nr_fingers == 3) {
+          libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
+          libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
+        } else if (nr_fingers == 4) {
+          libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
+          libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_QUADTAP, 1);
+        } else if (nr_fingers == 5) {
+          libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_QUADTAP, 0);
+          libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_QUINTTAP, 1);
+        }
+      }
+    } else {
+      // I already know this finger, let's check the slot
+      auto finger_slot = _state->fingers[finger_nr];
+      if (_state->current_slot != finger_slot) {
+        libevdev_uinput_write_event(touchpad, EV_ABS, ABS_MT_SLOT, finger_slot);
+        _state->current_slot = finger_slot;
+      }
+    }
+
+    libevdev_uinput_write_event(touchpad, EV_ABS, ABS_X, scaled_x);
+    libevdev_uinput_write_event(touchpad, EV_ABS, ABS_MT_POSITION_X, scaled_x);
+    libevdev_uinput_write_event(touchpad, EV_ABS, ABS_Y, scaled_y);
+    libevdev_uinput_write_event(touchpad, EV_ABS, ABS_MT_POSITION_Y, scaled_y);
+    libevdev_uinput_write_event(touchpad, EV_ABS, ABS_PRESSURE, (int)std::lround(pressure * PRESSURE_MAX));
+    libevdev_uinput_write_event(touchpad, EV_ABS, ABS_MT_PRESSURE, (int)std::lround(pressure * PRESSURE_MAX));
+    libevdev_uinput_write_event(touchpad, EV_ABS, ABS_MT_ORIENTATION, scaled_orientation);
+
+    libevdev_uinput_write_event(touchpad, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+void Trackpad::release_finger(int finger_nr) {
+  if (auto touchpad = this->_state->trackpad.get()) {
+    auto finger_slot = _state->fingers[finger_nr];
+    if (_state->current_slot != finger_slot) {
+      libevdev_uinput_write_event(touchpad, EV_ABS, ABS_MT_SLOT, finger_slot);
+      _state->current_slot = -1;
+    }
+    _state->fingers.erase(finger_nr);
+    libevdev_uinput_write_event(touchpad, EV_ABS, ABS_MT_TRACKING_ID, -1);
+    auto nr_fingers = _state->fingers.size();
+    { // Update number of fingers pressed
+      if (nr_fingers == 0) {
+        libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_FINGER, 0);
+        libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOUCH, 0);
+      } else if (nr_fingers == 1) {
+        libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_FINGER, 1);
+        libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
+      } else if (nr_fingers == 2) {
+        libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
+        libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
+      } else if (nr_fingers == 3) {
+        libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
+        libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_QUADTAP, 0);
+      } else if (nr_fingers == 4) {
+        libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_QUADTAP, 1);
+        libevdev_uinput_write_event(touchpad, EV_KEY, BTN_TOOL_QUINTTAP, 0);
+      }
+    }
+
+    libevdev_uinput_write_event(touchpad, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+void Trackpad::set_left_btn(bool pressed) {
+  if (auto touchpad = this->_state->trackpad.get()) {
+    libevdev_uinput_write_event(touchpad, EV_KEY, BTN_LEFT, pressed ? 1 : 0);
+    libevdev_uinput_write_event(touchpad, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+} // namespace inputtino