mirrors/maomaowm
1
0
Fork 0
mirror of https://github.com/DreamMaoMao/maomaowm.git synced 2026-03-23 05:35:53 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge e3309c7e1b into 028cf6e49e

Browse source
This commit is contained in:
Sqooky 2026-03-16 11:48:22 +00:00 • committed by GitHub
commit acb4e77c93
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
10 changed files with 6360 additions and 16 deletions
Download patch file Download diff file Expand all files Collapse all files

299
001-tablet.patch Normal file
View file

@ -0,0 +1,299 @@
From a649365d12b236af9a096d37484cfc82168d28b2 Mon Sep 17 00:00:00 2001
From: Yappaholic <sav.boyar@gmail.com>
Date: Tue, 26 Aug 2025 10:03:12 +0300
Subject: [PATCH] nothing
---
src/ext-protocol/all.h | 3 +-
src/ext-protocol/tablet.h | 220 ++++++++++++++++++++++++++++++++++++++
src/mango.c | 15 +++
3 files changed, 237 insertions(+), 1 deletion(-)
create mode 100644 src/ext-protocol/tablet.h
diff --git a/src/ext-protocol/all.h b/src/ext-protocol/all.h
index c657e0d..6b54c33 100644
--- a/src/ext-protocol/all.h
+++ b/src/ext-protocol/all.h
@@ -1,3 +1,4 @@
#include "dwl-ipc.h"
#include "foreign-toplevel.h"
-#include "text-input.h"
\ No newline at end of file
+#include "tablet.h"
+#include "text-input.h"
diff --git a/src/ext-protocol/tablet.h b/src/ext-protocol/tablet.h
new file mode 100644
index 0000000..bd67973
--- /dev/null
+++ b/src/ext-protocol/tablet.h
@@ -0,0 +1,220 @@
+#include <wlr/types/wlr_tablet_pad.h>
+#include <wlr/types/wlr_tablet_tool.h>
+#include <wlr/types/wlr_tablet_v2.h>
+
+static const int tabletmaptosurface =
+ 0; /* map tablet input to surface(1) or monitor(0) */
+
+static void createtablet(struct wlr_input_device *device);
+static void destroytablet(struct wl_listener *listener, void *data);
+static void destroytabletsurfacenotify(struct wl_listener *listener,
+ void *data);
+static void destroytablettool(struct wl_listener *listener, void *data);
+
+static void tablettoolmotion(struct wlr_tablet_v2_tablet_tool *tool,
+ bool change_x, bool change_y, double x, double y,
+ double dx, double dy);
+static void tablettoolproximity(struct wl_listener *listener, void *data);
+static void tablettoolaxis(struct wl_listener *listener, void *data);
+static void tablettoolbutton(struct wl_listener *listener, void *data);
+static void tablettooltip(struct wl_listener *listener, void *data);
+static struct wlr_tablet_manager_v2 *tablet_mgr;
+static struct wlr_tablet_v2_tablet *tablet = NULL;
+static struct wlr_tablet_v2_tablet_tool *tablet_tool = NULL;
+static struct wlr_tablet_v2_tablet_pad *tablet_pad = NULL;
+static struct wlr_surface *tablet_curr_surface = NULL;
+static struct wl_listener destroy_tablet_surface_listener = {
+ .notify = destroytabletsurfacenotify};
+static struct wl_listener tablet_device_destroy = {.notify = destroytablet};
+static struct wl_listener tablet_tool_axis = {.notify = tablettoolaxis};
+static struct wl_listener tablet_tool_button = {.notify = tablettoolbutton};
+static struct wl_listener tablet_tool_destroy = {.notify = destroytablettool};
+static struct wl_listener tablet_tool_proximity = {.notify =
+ tablettoolproximity};
+static struct wl_listener tablet_tool_tip = {.notify = tablettooltip};
+
+void createtablet(struct wlr_input_device *device) {
+ if (!tablet) {
+ struct libinput_device *device_handle = NULL;
+ if (!wlr_input_device_is_libinput(device) ||
+ !(device_handle = wlr_libinput_get_device_handle(device)))
+ return;
+
+ tablet = wlr_tablet_create(tablet_mgr, seat, device);
+ wl_signal_add(&tablet->wlr_device->events.destroy,
+ &tablet_device_destroy);
+ if (libinput_device_config_send_events_get_modes(device_handle)) {
+ libinput_device_config_send_events_set_mode(device_handle,
+ send_events_mode);
+ wlr_cursor_attach_input_device(cursor, device);
+ }
+ } else if (device == tablet->wlr_device) {
+ wlr_log(WLR_ERROR, "createtablet: duplicate device");
+ } else {
+ wlr_log(WLR_ERROR, "createtablet: already have one tablet");
+ }
+}
+
+void destroytablet(struct wl_listener *listener, void *data) { tablet = NULL; }
+
+void destroytabletsurfacenotify(struct wl_listener *listener, void *data) {
+ if (tablet_curr_surface)
+ wl_list_remove(&destroy_tablet_surface_listener.link);
+ tablet_curr_surface = NULL;
+}
+
+void destroytablettool(struct wl_listener *listener, void *data) {
+ destroytabletsurfacenotify(NULL, NULL);
+ tablet_tool = NULL;
+}
+
+void tabletapplymap(double x, double y, struct wlr_input_device *dev) {
+ Client *p;
+ struct wlr_box geom = {0};
+ if (tabletmaptosurface && tablet_curr_surface) {
+ toplevel_from_wlr_surface(tablet_curr_surface, &p, NULL);
+ if (p) {
+ for (; client_get_parent(p); p = client_get_parent(p))
+ ;
+ geom.x = p->geom.x + p->bw;
+ geom.y = p->geom.y + p->bw;
+ geom.width = p->geom.width - 2 * p->bw;
+ geom.height = p->geom.height - 2 * p->bw;
+ }
+ }
+ wlr_cursor_map_input_to_region(cursor, dev, &geom);
+ wlr_cursor_map_input_to_output(cursor, dev, selmon->wlr_output);
+}
+
+void tablettoolmotion(struct wlr_tablet_v2_tablet_tool *tool, bool change_x,
+ bool change_y, double x, double y, double dx, double dy) {
+ struct wlr_surface *surface = NULL;
+ double sx, sy;
+
+ if (!change_x && !change_y)
+ return;
+
+ tabletapplymap(x, y, tablet->wlr_device);
+
+ // TODO: apply constraints
+ switch (tablet_tool->wlr_tool->type) {
+ case WLR_TABLET_TOOL_TYPE_LENS:
+ case WLR_TABLET_TOOL_TYPE_MOUSE:
+ wlr_cursor_move(cursor, tablet->wlr_device, dx, dy);
+ break;
+ default:
+ wlr_cursor_warp_absolute(cursor, tablet->wlr_device, change_x ? x : NAN,
+ change_y ? y : NAN);
+ break;
+ }
+
+ motionnotify(0, NULL, 0, 0, 0, 0);
+
+ xytonode(cursor->x, cursor->y, &surface, NULL, NULL, &sx, &sy);
+ if (surface && !wlr_surface_accepts_tablet_v2(surface, tablet))
+ surface = NULL;
+
+ if (surface != tablet_curr_surface) {
+ if (tablet_curr_surface) {
+ // TODO: wait until all buttons released before leaving
+ if (tablet_tool)
+ wlr_tablet_v2_tablet_tool_notify_proximity_out(tablet_tool);
+ if (tablet_pad)
+ wlr_tablet_v2_tablet_pad_notify_leave(tablet_pad,
+ tablet_curr_surface);
+ wl_list_remove(&destroy_tablet_surface_listener.link);
+ }
+ if (surface) {
+ if (tablet_pad)
+ wlr_tablet_v2_tablet_pad_notify_enter(tablet_pad, tablet,
+ surface);
+ if (tablet_tool)
+ wlr_tablet_v2_tablet_tool_notify_proximity_in(tablet_tool,
+ tablet, surface);
+ wl_signal_add(&surface->events.destroy,
+ &destroy_tablet_surface_listener);
+ }
+ tablet_curr_surface = surface;
+ }
+
+ if (surface)
+ wlr_tablet_v2_tablet_tool_notify_motion(tablet_tool, sx, sy);
+}
+
+void tablettoolproximity(struct wl_listener *listener, void *data) {
+ struct wlr_tablet_tool_proximity_event *event = data;
+ struct wlr_tablet_tool *tool = event->tool;
+
+ if (!tablet_tool) {
+ tablet_tool = wlr_tablet_tool_create(tablet_mgr, seat, tool);
+ wl_signal_add(&tablet_tool->wlr_tool->events.destroy,
+ &tablet_tool_destroy);
+ wl_signal_add(&tablet_tool->events.set_cursor, &request_cursor);
+ }
+
+ switch (event->state) {
+ case WLR_TABLET_TOOL_PROXIMITY_OUT:
+ wlr_tablet_v2_tablet_tool_notify_proximity_out(tablet_tool);
+ destroytabletsurfacenotify(NULL, NULL);
+ break;
+ case WLR_TABLET_TOOL_PROXIMITY_IN:
+ tablettoolmotion(tablet_tool, true, true, event->x, event->y, 0, 0);
+ break;
+ }
+}
+
+void tablettoolaxis(struct wl_listener *listener, void *data) {
+ struct wlr_tablet_tool_axis_event *event = data;
+
+ tablettoolmotion(tablet_tool, event->updated_axes & WLR_TABLET_TOOL_AXIS_X,
+ event->updated_axes & WLR_TABLET_TOOL_AXIS_Y, event->x,
+ event->y, event->dx, event->dy);
+
+ if (event->updated_axes & WLR_TABLET_TOOL_AXIS_PRESSURE)
+ wlr_tablet_v2_tablet_tool_notify_pressure(tablet_tool, event->pressure);
+ if (event->updated_axes & WLR_TABLET_TOOL_AXIS_DISTANCE)
+ wlr_tablet_v2_tablet_tool_notify_distance(tablet_tool, event->distance);
+ if (event->updated_axes &
+ (WLR_TABLET_TOOL_AXIS_TILT_X | WLR_TABLET_TOOL_AXIS_TILT_Y)) {
+ printf("DEBUGGING: In axis event handling\n");
+ wlr_tablet_v2_tablet_tool_notify_tilt(tablet_tool, event->tilt_x,
+ event->tilt_y);
+ }
+ if (event->updated_axes & WLR_TABLET_TOOL_AXIS_ROTATION)
+ wlr_tablet_v2_tablet_tool_notify_rotation(tablet_tool, event->rotation);
+ if (event->updated_axes & WLR_TABLET_TOOL_AXIS_SLIDER)
+ wlr_tablet_v2_tablet_tool_notify_slider(tablet_tool, event->slider);
+ if (event->updated_axes & WLR_TABLET_TOOL_AXIS_WHEEL)
+ wlr_tablet_v2_tablet_tool_notify_wheel(tablet_tool, event->wheel_delta,
+ 0);
+}
+
+void tablettoolbutton(struct wl_listener *listener, void *data) {
+ struct wlr_tablet_tool_button_event *event = data;
+ wlr_tablet_v2_tablet_tool_notify_button(
+ tablet_tool, event->button,
+ (enum zwp_tablet_pad_v2_button_state)event->state);
+}
+
+void tablettooltip(struct wl_listener *listener, void *data) {
+ struct wlr_tablet_tool_tip_event *event = data;
+
+ if (!tablet_curr_surface) {
+ struct wlr_pointer_button_event fakeptrbtnevent = {
+ .button = BTN_LEFT,
+ .state = event->state == WLR_TABLET_TOOL_TIP_UP
+ ? WL_POINTER_BUTTON_STATE_RELEASED
+ : WL_POINTER_BUTTON_STATE_PRESSED,
+ .time_msec = event->time_msec,
+ };
+ buttonpress(NULL, (void *)&fakeptrbtnevent);
+ }
+
+ if (event->state == WLR_TABLET_TOOL_TIP_UP) {
+ wlr_tablet_v2_tablet_tool_notify_up(tablet_tool);
+ return;
+ }
+
+ wlr_tablet_v2_tablet_tool_notify_down(tablet_tool);
+ wlr_tablet_tool_v2_start_implicit_grab(tablet_tool);
+}
diff --git a/src/mango.c b/src/mango.c
index 3700441..7e2e818 100644
--- a/src/mango.c
+++ b/src/mango.c
@@ -67,6 +67,9 @@
#include <wlr/types/wlr_session_lock_v1.h>
#include <wlr/types/wlr_single_pixel_buffer_v1.h>
#include <wlr/types/wlr_subcompositor.h>
+#include <wlr/types/wlr_tablet_pad.h>
+#include <wlr/types/wlr_tablet_tool.h>
+#include <wlr/types/wlr_tablet_v2.h>
#include <wlr/types/wlr_viewporter.h>
#include <wlr/types/wlr_virtual_keyboard_v1.h>
#include <wlr/types/wlr_virtual_pointer_v1.h>
@@ -3017,6 +3020,12 @@ void inputdevice(struct wl_listener *listener, void *data) {
case WLR_INPUT_DEVICE_KEYBOARD:
createkeyboard(wlr_keyboard_from_input_device(device));
break;
+ case WLR_INPUT_DEVICE_TABLET:
+ createtablet(device);
+ break;
+ case WLR_INPUT_DEVICE_TABLET_PAD:
+ tablet_pad = wlr_tablet_pad_create(tablet_mgr, seat, device);
+ break;
case WLR_INPUT_DEVICE_POINTER:
createpointer(wlr_pointer_from_input_device(device));
break;
@@ -4422,6 +4431,7 @@ void setup(void) {
dpy = wl_display_create();
event_loop = wl_display_get_event_loop(dpy);
pointer_manager = wlr_relative_pointer_manager_v1_create(dpy);
+ tablet_mgr = wlr_tablet_v2_create(dpy);
/* The backend is a wlroots feature which abstracts the underlying input and
* output hardware. The autocreate option will choose the most suitable
* backend based on the current environment, such as opening an X11 window
@@ -4594,6 +4604,11 @@ void setup(void) {
wl_signal_add(&cursor->events.button, &cursor_button);
wl_signal_add(&cursor->events.axis, &cursor_axis);
wl_signal_add(&cursor->events.frame, &cursor_frame);
+ wl_signal_add(&cursor->events.tablet_tool_proximity,
+ &tablet_tool_proximity);
+ wl_signal_add(&cursor->events.tablet_tool_axis, &tablet_tool_axis);
+ wl_signal_add(&cursor->events.tablet_tool_button, &tablet_tool_button);
+ wl_signal_add(&cursor->events.tablet_tool_tip, &tablet_tool_tip);
// 这两句代码会造成obs窗口里的鼠标光标消失,不知道注释有什么影响
cursor_shape_mgr = wlr_cursor_shape_manager_v1_create(dpy, 1);
--
2.49.1

12
README.md
View file

@ -1,9 +1,13 @@
# Mango Wayland Compositor
<div>
<img src="https://github.com/mangowm/mango/blob/main/assets/mango-transparency-256.png" alt="MangoWM Logo" width="120"/>
</div>
This project's development is based on [dwl](https://codeberg.org/dwl/dwl/).
This is a fork of MangoWM which adds in support for tablelts
git clone https://github.com/Sqooky/Fork-of-Mamaowm-With-Tablet-Support
cd Fork-of-Mamaowm-With-Tablet-Support
meson build -Dprefix=/usr
sudo ninja -C build install
1. **Lightweight & Fast Build**

2
nix/default.nix
View file

@ -68,7 +68,7 @@ stdenv.mkDerivation {
meta = {
mainProgram = "mango";
description = "A streamlined but feature-rich Wayland compositor";
homepage = "https://github.com/DreamMaoMao/mango";
homepage = "https://github.com/Sqooky/maomaowm";
license = lib.licenses.gpl3Plus;
maintainers = [];
platforms = lib.platforms.unix;

4
src/ext-protocol/all.h
View file

@ -1,5 +1,7 @@
#include "dwl-ipc.h"
#include "ext-workspace.h"
#include "foreign-toplevel.h"
#include "tablet.h"
#include "text-input.h"
#include "tearing.h"
#include "text-input.h"

4
src/ext-protocol/all.h.orig Normal file
View file

@ -0,0 +1,4 @@
#include "dwl-ipc.h"
#include "ext-workspace.h"
#include "foreign-toplevel.h"
#include "text-input.h"

266
src/ext-protocol/tablet.h Normal file
View file

@ -0,0 +1,266 @@
#include <wlr/types/wlr_tablet_pad.h>
#include <wlr/types/wlr_tablet_tool.h>
#include <wlr/types/wlr_tablet_v2.h>
static const int tabletmaptosurface =
0; /* map tablet input to surface(1) or monitor(0) */
static void createtablet(struct wlr_input_device *device);
static void destroytablet(struct wl_listener *listener, void *data);
static void destroytabletsurfacenotify(struct wl_listener *listener,
void *data);
static void destroytablettool(struct wl_listener *listener, void *data);
static void tablettoolmotion(struct wlr_tablet_v2_tablet_tool *tool,
bool change_x, bool change_y, double x, double y,
double dx, double dy);
static void tablettoolproximity(struct wl_listener *listener, void *data);
static void tablettoolaxis(struct wl_listener *listener, void *data);
static void tablettoolbutton(struct wl_listener *listener, void *data);
static void tablettooltip(struct wl_listener *listener, void *data);
static struct wlr_tablet_manager_v2 *tablet_mgr;
static struct wlr_tablet_v2_tablet *tablet = NULL;
static struct wlr_tablet_v2_tablet_tool *tablet_tool = NULL;
static struct wlr_tablet_v2_tablet_pad *tablet_pad = NULL;
static struct wlr_surface *tablet_curr_surface = NULL;
static struct wl_listener destroy_tablet_surface_listener = {
.notify = destroytabletsurfacenotify};
static struct wl_listener tablet_device_destroy = {.notify = destroytablet};
static struct wl_listener tablet_tool_axis = {.notify = tablettoolaxis};
static struct wl_listener tablet_tool_button = {.notify = tablettoolbutton};
static struct wl_listener tablet_tool_destroy = {.notify = destroytablettool};
static struct wl_listener tablet_tool_proximity = {.notify =
tablettoolproximity};
static struct wl_listener tablet_tool_tip = {.notify = tablettooltip};
void createtablet(struct wlr_input_device *device) {
if (!tablet) {
struct libinput_device *device_handle = NULL;
if (!wlr_input_device_is_libinput(device) ||
!(device_handle = wlr_libinput_get_device_handle(device)))
return;
tablet = wlr_tablet_create(tablet_mgr, seat, device);
wl_signal_add(&tablet->wlr_device->events.destroy,
&tablet_device_destroy);
if (libinput_device_config_send_events_get_modes(device_handle)) {
libinput_device_config_send_events_set_mode(device_handle,
send_events_mode);
wlr_cursor_attach_input_device(cursor, device);
}
} else if (device == tablet->wlr_device) {
wlr_log(WLR_ERROR, "createtablet: duplicate device");
} else {
wlr_log(WLR_ERROR, "createtablet: already have one tablet");
}
}
void destroytablet(struct wl_listener *listener, void *data) {
wl_list_remove(&listener->link);
tablet = NULL;
}
void destroytabletsurfacenotify(struct wl_listener *listener, void *data) {
if (tablet_curr_surface)
wl_list_remove(&destroy_tablet_surface_listener.link);
tablet_curr_surface = NULL;
}
void destroytablettool(struct wl_listener *listener, void *data) {
destroytabletsurfacenotify(NULL, NULL);
tablet_tool = NULL;
}
void tabletapplymap(double tablet_width, double tablet_height,
struct wlr_fbox box, double *x, double *y)
{
if ((!box.x && !box.y && !box.width && !box.height) || !tablet_width ||
!tablet_height) {
return;
}
if (!box.width) {
box.width = tablet_width - box.x;
}
if (!box.height) {
box.height = tablet_height - box.y;
}
if (box.x + box.width <= tablet_width) {
const double max_x = 1;
double width_offset = max_x * box.x / tablet_width;
*x = (*x - width_offset) * tablet_width / box.width;
}
if (box.y + box.height <= tablet_height) {
const double max_y = 1;
double height_offset = max_y * box.y / tablet_height;
*y = (*y - height_offset) * tablet_height / box.height;
}
}
void tablettoolmotion(struct wlr_tablet_v2_tablet_tool *tool, bool change_x,
bool change_y, double x, double y, double dx, double dy) {
struct wlr_surface *surface = NULL;
Client *c = NULL, *w = NULL;
LayerSurface *l = NULL;
double sx, sy;
if (!change_x && !change_y)
return;
tabletapplymap(tablet->wlr_tablet->width_mm, tablet->wlr_tablet->height_mm,
(struct wlr_fbox){0}, &x, &y);
// TODO: apply constraints
switch (tablet_tool->wlr_tool->type) {
case WLR_TABLET_TOOL_TYPE_LENS:
case WLR_TABLET_TOOL_TYPE_MOUSE:
wlr_cursor_move(cursor, tablet->wlr_device, dx, dy);
break;
default:
wlr_cursor_warp_absolute(cursor, tablet->wlr_device, change_x ? x : NAN,
change_y ? y : NAN);
break;
}
motionnotify(0, NULL, 0, 0, 0, 0);
xytonode(cursor->x, cursor->y, &surface, &c, NULL, &sx, &sy);
if (cursor_mode == CurPressed && !seat->drag &&
surface != seat->pointer_state.focused_surface &&
toplevel_from_wlr_surface(seat->pointer_state.focused_surface, &w,
&l) >= 0) {
c = w;
surface = seat->pointer_state.focused_surface;
sx = cursor->x - (l ? l->scene->node.x : w->geom.x);
sy = cursor->y - (l ? l->scene->node.y : w->geom.y);
}
if (sloppyfocus && c && c->scene->node.enabled &&
(surface != seat->pointer_state.focused_surface ||
(selmon && selmon->sel && c != selmon->sel)) &&
!client_is_unmanaged(c))
focusclient(c, 0);
if (surface && !wlr_surface_accepts_tablet_v2(surface, tablet))
surface = NULL;
if (surface != tablet_curr_surface) {
if (tablet_curr_surface) {
// TODO: wait until all buttons released before leaving
if (tablet_tool)
wlr_tablet_v2_tablet_tool_notify_proximity_out(tablet_tool);
if (tablet_pad)
wlr_tablet_v2_tablet_pad_notify_leave(tablet_pad,
tablet_curr_surface);
wl_list_remove(&destroy_tablet_surface_listener.link);
}
if (surface) {
if (tablet_pad)
wlr_tablet_v2_tablet_pad_notify_enter(tablet_pad, tablet,
surface);
if (tablet_tool)
wlr_tablet_v2_tablet_tool_notify_proximity_in(tablet_tool,
tablet, surface);
wl_signal_add(&surface->events.destroy,
&destroy_tablet_surface_listener);
}
tablet_curr_surface = surface;
}
if (surface)
wlr_tablet_v2_tablet_tool_notify_motion(tablet_tool, sx, sy);
wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
handlecursoractivity();
}
void tablettoolproximity(struct wl_listener *listener, void *data) {
struct wlr_tablet_tool_proximity_event *event = data;
struct wlr_tablet_tool *tool = event->tool;
if (!tablet_tool) {
tablet_tool = wlr_tablet_tool_create(tablet_mgr, seat, tool);
wl_signal_add(&tablet_tool->wlr_tool->events.destroy,
&tablet_tool_destroy);
wl_signal_add(&tablet_tool->events.set_cursor, &request_cursor);
}
switch (event->state) {
case WLR_TABLET_TOOL_PROXIMITY_OUT:
wlr_tablet_v2_tablet_tool_notify_proximity_out(tablet_tool);
destroytabletsurfacenotify(NULL, NULL);
break;
case WLR_TABLET_TOOL_PROXIMITY_IN:
tablettoolmotion(tablet_tool, true, true, event->x, event->y, 0, 0);
break;
}
}
void tablettoolaxis(struct wl_listener *listener, void *data) {
struct wlr_tablet_tool_axis_event *event = data;
tablettoolmotion(tablet_tool, event->updated_axes & WLR_TABLET_TOOL_AXIS_X,
event->updated_axes & WLR_TABLET_TOOL_AXIS_Y, event->x,
event->y, event->dx, event->dy);
if (event->updated_axes & WLR_TABLET_TOOL_AXIS_PRESSURE)
wlr_tablet_v2_tablet_tool_notify_pressure(tablet_tool, event->pressure);
if (event->updated_axes & WLR_TABLET_TOOL_AXIS_DISTANCE)
wlr_tablet_v2_tablet_tool_notify_distance(tablet_tool, event->distance);
if (event->updated_axes &
(WLR_TABLET_TOOL_AXIS_TILT_X | WLR_TABLET_TOOL_AXIS_TILT_Y)) {
printf("DEBUGGING: In axis event handling\n");
wlr_tablet_v2_tablet_tool_notify_tilt(tablet_tool, event->tilt_x,
event->tilt_y);
}
if (event->updated_axes & WLR_TABLET_TOOL_AXIS_ROTATION)
wlr_tablet_v2_tablet_tool_notify_rotation(tablet_tool, event->rotation);
if (event->updated_axes & WLR_TABLET_TOOL_AXIS_SLIDER)
wlr_tablet_v2_tablet_tool_notify_slider(tablet_tool, event->slider);
if (event->updated_axes & WLR_TABLET_TOOL_AXIS_WHEEL)
wlr_tablet_v2_tablet_tool_notify_wheel(tablet_tool, event->wheel_delta,
0);
}
void tablettoolbutton(struct wl_listener *listener, void *data) {
struct wlr_tablet_tool_button_event *event = data;
wlr_tablet_v2_tablet_tool_notify_button(
tablet_tool, event->button,
(enum zwp_tablet_pad_v2_button_state)event->state);
}
void tablettooltip(struct wl_listener *listener, void *data) {
struct wlr_tablet_tool_tip_event *event = data;
struct wlr_pointer_button_event fakeptrbtnevent = {
.button = BTN_LEFT,
.state = event->state == WLR_TABLET_TOOL_TIP_UP
? WL_POINTER_BUTTON_STATE_RELEASED
: WL_POINTER_BUTTON_STATE_PRESSED,
.time_msec = event->time_msec,
};
if (handle_buttonpress(&fakeptrbtnevent))
return;
if (!tablet_curr_surface) {
wlr_seat_pointer_notify_button(seat, fakeptrbtnevent.time_msec,
fakeptrbtnevent.button,
fakeptrbtnevent.state);
return;
}
if (event->state == WLR_TABLET_TOOL_TIP_UP) {
wlr_tablet_v2_tablet_tool_notify_up(tablet_tool);
return;
}
wlr_tablet_v2_tablet_tool_notify_down(tablet_tool);
wlr_tablet_tool_v2_start_implicit_grab(tablet_tool);
}

50
src/mango.c
View file

@ -71,6 +71,9 @@
#include <wlr/types/wlr_session_lock_v1.h>
#include <wlr/types/wlr_single_pixel_buffer_v1.h>
#include <wlr/types/wlr_subcompositor.h>
#include <wlr/types/wlr_tablet_pad.h>
#include <wlr/types/wlr_tablet_tool.h>
#include <wlr/types/wlr_tablet_v2.h>
#include <wlr/types/wlr_switch.h>
#include <wlr/types/wlr_viewporter.h>
#include <wlr/types/wlr_virtual_keyboard_v1.h>
@ -570,6 +573,7 @@ static void axisnotify(struct wl_listener *listener,
void *data); // 滚轮事件处理
static void buttonpress(struct wl_listener *listener,
void *data); // 鼠标按键事件处理
static bool handle_buttonpress(struct wlr_pointer_button_event *event);
static int32_t ongesture(struct wlr_pointer_swipe_end_event *event);
static void swipe_begin(struct wl_listener *listener, void *data);
static void swipe_update(struct wl_listener *listener, void *data);
@ -2021,6 +2025,13 @@ bool check_trackpad_disabled(struct wlr_pointer *pointer) {
void // 鼠标按键事件
buttonpress(struct wl_listener *listener, void *data) {
struct wlr_pointer_button_event *event = data;
if (!handle_buttonpress(event))
wlr_seat_pointer_notify_button(seat, event->time_msec, event->button,
event->state);
}
bool handle_buttonpress(struct wlr_pointer_button_event *event) {
struct wlr_keyboard *hard_keyboard, *keyboard;
uint32_t hard_mods, mods;
Client *c = NULL;
@ -2035,8 +2046,8 @@ buttonpress(struct wl_listener *listener, void *data) {
handlecursoractivity();
wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
if (check_trackpad_disabled(event->pointer)) {
return;
if (event->pointer && check_trackpad_disabled(event->pointer)) {
return true;
}
switch (event->state) {
@ -2083,12 +2094,12 @@ buttonpress(struct wl_listener *listener, void *data) {
if (selmon->isoverview && event->button == BTN_LEFT && c) {
toggleoverview(&(Arg){.i = 1});
return;
return true;
}
if (selmon->isoverview && event->button == BTN_RIGHT && c) {
pending_kill_client(c);
return;
return true;
}
if (CLEANMASK(mods) == CLEANMASK(m->mod) &&
@ -2096,7 +2107,7 @@ buttonpress(struct wl_listener *listener, void *data) {
(CLEANMASK(m->mod) != 0 ||
(event->button != BTN_LEFT && event->button != BTN_RIGHT))) {
m->func(&m->arg);
return;
return true;
}
}
break;
@ -2128,16 +2139,14 @@ buttonpress(struct wl_listener *listener, void *data) {
apply_window_snap(tmpc);
}
tmpc->drag_to_tile = false;
return;
return true;
} else {
cursor_mode = CurNormal;
}
break;
}
/* If the event wasn't handled by the compositor, notify the client with
* pointer focus that a button press has occurred */
wlr_seat_pointer_notify_button(seat, event->time_msec, event->button,
event->state);
/* If the event wasn't handled by the compositor, return false */
return false;
}
void checkidleinhibitor(struct wlr_surface *exclude) {
@ -3643,6 +3652,12 @@ void inputdevice(struct wl_listener *listener, void *data) {
case WLR_INPUT_DEVICE_KEYBOARD:
createkeyboard(wlr_keyboard_from_input_device(device));
break;
case WLR_INPUT_DEVICE_TABLET:
createtablet(device);
break;
case WLR_INPUT_DEVICE_TABLET_PAD:
tablet_pad = wlr_tablet_pad_create(tablet_mgr, seat, device);
break;
case WLR_INPUT_DEVICE_POINTER:
createpointer(wlr_pointer_from_input_device(device));
break;
@ -5490,6 +5505,16 @@ void setup(void) {
* clients from the Unix socket, manging Wayland globals, and so on. */
dpy = wl_display_create();
event_loop = wl_display_get_event_loop(dpy);
relative_pointer_mgr = wlr_relative_pointer_manager_v1_create(dpy);
tablet_mgr = wlr_tablet_v2_create(dpy);
/* The backend is a wlroots feature which abstracts the underlying input and
* output hardware. The autocreate option will choose the most suitable
* backend based on the current environment, such as opening an X11 window
* if an X11 server is running. The NULL argument here optionally allows you
* to pass in a custom renderer if wlr_renderer doesn't meet your needs. The
* backend uses the renderer, for example, to fall back to software cursors
* if the backend does not support hardware cursors (some older GPUs
* don't). */
/* The backend is a wlroots feature which abstracts the underlying input
* and output hardware. The autocreate option will choose the most
* suitable backend based on the current environment, such as opening an
@ -5677,6 +5702,11 @@ void setup(void) {
wl_signal_add(&cursor->events.button, &cursor_button);
wl_signal_add(&cursor->events.axis, &cursor_axis);
wl_signal_add(&cursor->events.frame, &cursor_frame);
wl_signal_add(&cursor->events.tablet_tool_proximity,
&tablet_tool_proximity);
wl_signal_add(&cursor->events.tablet_tool_axis, &tablet_tool_axis);
wl_signal_add(&cursor->events.tablet_tool_button, &tablet_tool_button);
wl_signal_add(&cursor->events.tablet_tool_tip, &tablet_tool_tip);
// 这两句代码会造成obs窗口里的鼠标光标消失,不知道注释有什么影响
cursor_shape_mgr = wlr_cursor_shape_manager_v1_create(dpy, 1);

5424
src/mango.c.orig Normal file
View file

File diff suppressed because it is too large Load diff

7
src/mango.c.rej Normal file
View file

@ -0,0 +1,7 @@
--- src/ext-protocol/all.h
+++ src/ext-protocol/all.h
@@ -1,3 +1,4 @@
#include "dwl-ipc.h"
#include "foreign-toplevel.h"
-#include "text-input.h"+#include "tablet.h"
+#include "text-input.h"

308
tablet.patch Normal file
View file

@ -0,0 +1,308 @@
From a649365d12b236af9a096d37484cfc82168d28b2 Mon Sep 17 00:00:00 2001
From: Yappaholic <sav.boyar@gmail.com>
Date: Tue, 26 Aug 2025 10:03:12 +0300
Subject: [PATCH] nothing
---
src/ext-protocol/all.h | 3 +-
src/ext-protocol/tablet.h | 220 ++++++++++++++++++++++++++++++++++++++
src/mango.c | 15 +++
3 files changed, 237 insertions(+), 1 deletion(-)
create mode 100644 src/ext-protocol/tablet.h
diff --git a/src/ext-protocol/all.h b/src/ext-protocol/all.h
index c657e0d..6b54c33 100644
--- a/src/ext-protocol/all.h
+++ b/src/ext-protocol/all.h
@@ -1,3 +1,4 @@
#include "dwl-ipc.h"
#include "foreign-toplevel.h"
-#include "text-input.h"
\ No newline at end of file
+#include "tablet.h"
+#include "text-input.h"
diff --git a/src/ext-protocol/tablet.h b/src/ext-protocol/tablet.h
new file mode 100644
index 0000000..bd67973
--- /dev/null
+++ b/src/ext-protocol/tablet.h
@@ -0,0 +1,220 @@
+#include <wlr/types/wlr_tablet_pad.h>
+#include <wlr/types/wlr_tablet_tool.h>
+#include <wlr/types/wlr_tablet_v2.h>
+
+static const int tabletmaptosurface =
+ 0; /* map tablet input to surface(1) or monitor(0) */
+
+static void createtablet(struct wlr_input_device *device);
+static void destroytablet(struct wl_listener *listener, void *data);
+static void destroytabletsurfacenotify(struct wl_listener *listener,
+ void *data);
+static void destroytablettool(struct wl_listener *listener, void *data);
+
+static void tablettoolmotion(struct wlr_tablet_v2_tablet_tool *tool,
+ bool change_x, bool change_y, double x, double y,
+ double dx, double dy);
+static void tablettoolproximity(struct wl_listener *listener, void *data);
+static void tablettoolaxis(struct wl_listener *listener, void *data);
+static void tablettoolbutton(struct wl_listener *listener, void *data);
+static void tablettooltip(struct wl_listener *listener, void *data);
+static struct wlr_tablet_manager_v2 *tablet_mgr;
+static struct wlr_tablet_v2_tablet *tablet = NULL;
+static struct wlr_tablet_v2_tablet_tool *tablet_tool = NULL;
+static struct wlr_tablet_v2_tablet_pad *tablet_pad = NULL;
+static struct wlr_surface *tablet_curr_surface = NULL;
+static struct wl_listener destroy_tablet_surface_listener = {
+ .notify = destroytabletsurfacenotify};
+static struct wl_listener tablet_device_destroy = {.notify = destroytablet};
+static struct wl_listener tablet_tool_axis = {.notify = tablettoolaxis};
+static struct wl_listener tablet_tool_button = {.notify = tablettoolbutton};
+static struct wl_listener tablet_tool_destroy = {.notify = destroytablettool};
+static struct wl_listener tablet_tool_proximity = {.notify =
+ tablettoolproximity};
+static struct wl_listener tablet_tool_tip = {.notify = tablettooltip};
+
+void createtablet(struct wlr_input_device *device) {
+ if (!tablet) {
+ struct libinput_device *device_handle = NULL;
+ if (!wlr_input_device_is_libinput(device) ||
+ !(device_handle = wlr_libinput_get_device_handle(device)))
+ return;
+
+ tablet = wlr_tablet_create(tablet_mgr, seat, device);
+ wl_signal_add(&tablet->wlr_device->events.destroy,
+ &tablet_device_destroy);
+ if (libinput_device_config_send_events_get_modes(device_handle)) {
+ libinput_device_config_send_events_set_mode(device_handle,
+ send_events_mode);
+ wlr_cursor_attach_input_device(cursor, device);
+ }
+ } else if (device == tablet->wlr_device) {
+ wlr_log(WLR_ERROR, "createtablet: duplicate device");
+ } else {
+ wlr_log(WLR_ERROR, "createtablet: already have one tablet");
+ }
+}
+
+void destroytablet(struct wl_listener *listener, void *data) { tablet = NULL; }
+
+void destroytabletsurfacenotify(struct wl_listener *listener, void *data) {
+ if (tablet_curr_surface)
+ wl_list_remove(&destroy_tablet_surface_listener.link);
+ tablet_curr_surface = NULL;
+}
+
+void destroytablettool(struct wl_listener *listener, void *data) {
+ destroytabletsurfacenotify(NULL, NULL);
+ tablet_tool = NULL;
+}
+
+void tabletapplymap(double tablet_width, double tablet_height,
+ struct wlr_fbox box, double *x, double *y)
+{
+ if ((!box.x && !box.y && !box.width && !box.height)
+ || !tablet_width || !tablet_height) {
+ return;
+ }
+
+ if (!box.width) {
+ box.width = tablet_width - box.x;
+ }
+ if (!box.height) {
+ box.height = tablet_height - box.y;
+ }
+
+ if (box.x + box.width <= tablet_width) {
+ const double max_x = 1;
+ double width_offset = max_x * box.x / tablet_width;
+ *x = (*x - width_offset) * tablet_width / box.width;
+ }
+ if (box.y + box.height <= tablet_height) {
+ const double max_y = 1;
+ double height_offset = max_y * box.y / tablet_height;
+ *y = (*y - height_offset) * tablet_height / box.height;
+ }
+}
+
+void tablettoolmotion(struct wlr_tablet_v2_tablet_tool *tool, bool change_x,
+ bool change_y, double x, double y, double dx, double dy) {
+ struct wlr_surface *surface = NULL;
+ double sx, sy;
+
+ if (!change_x && !change_y)
+ return;
+
+ tabletapplymap(tablet->wlr_tablet->width_mm, tablet->wlr_tablet->height_mm,
+ (struct wlr_fbox){0}, &x, &y);
+ // TODO: apply constraints
+ switch (tablet_tool->wlr_tool->type) {
+ case WLR_TABLET_TOOL_TYPE_LENS:
+ case WLR_TABLET_TOOL_TYPE_MOUSE:
+ wlr_cursor_move(cursor, tablet->wlr_device, dx, dy);
+ break;
+ default:
+ wlr_cursor_warp_absolute(cursor, tablet->wlr_device, change_x ? x : NAN,
+ change_y ? y : NAN);
+ break;
+ }
+
+ motionnotify(0, NULL, 0, 0, 0, 0);
+
+ xytonode(cursor->x, cursor->y, &surface, NULL, NULL, &sx, &sy);
+ if (surface && !wlr_surface_accepts_tablet_v2(surface, tablet))
+ surface = NULL;
+
+ if (surface != tablet_curr_surface) {
+ if (tablet_curr_surface) {
+ // TODO: wait until all buttons released before leaving
+ if (tablet_tool)
+ wlr_tablet_v2_tablet_tool_notify_proximity_out(tablet_tool);
+ if (tablet_pad)
+ wlr_tablet_v2_tablet_pad_notify_leave(tablet_pad,
+ tablet_curr_surface);
+ wl_list_remove(&destroy_tablet_surface_listener.link);
+ }
+ if (surface) {
+ if (tablet_pad)
+ wlr_tablet_v2_tablet_pad_notify_enter(tablet_pad, tablet,
+ surface);
+ if (tablet_tool)
+ wlr_tablet_v2_tablet_tool_notify_proximity_in(tablet_tool,
+ tablet, surface);
+ wl_signal_add(&surface->events.destroy,
+ &destroy_tablet_surface_listener);
+ }
+ tablet_curr_surface = surface;
+ }
+
+ if (surface)
+ wlr_tablet_v2_tablet_tool_notify_motion(tablet_tool, sx, sy);
+}
+
+void tablettoolproximity(struct wl_listener *listener, void *data) {
+ struct wlr_tablet_tool_proximity_event *event = data;
+ struct wlr_tablet_tool *tool = event->tool;
+
+ if (!tablet_tool) {
+ tablet_tool = wlr_tablet_tool_create(tablet_mgr, seat, tool);
+ wl_signal_add(&tablet_tool->wlr_tool->events.destroy,
+ &tablet_tool_destroy);
+ wl_signal_add(&tablet_tool->events.set_cursor, &request_cursor);
+ }
+
+ switch (event->state) {
+ case WLR_TABLET_TOOL_PROXIMITY_OUT:
+ wlr_tablet_v2_tablet_tool_notify_proximity_out(tablet_tool);
+ destroytabletsurfacenotify(NULL, NULL);
+ break;
+ case WLR_TABLET_TOOL_PROXIMITY_IN:
+ tablettoolmotion(tablet_tool, true, true, event->x, event->y, 0, 0);
+ break;
+ }
+}
+
+void tablettoolaxis(struct wl_listener *listener, void *data) {
+ struct wlr_tablet_tool_axis_event *event = data;
+
+ tablettoolmotion(tablet_tool, event->updated_axes & WLR_TABLET_TOOL_AXIS_X,
+ event->updated_axes & WLR_TABLET_TOOL_AXIS_Y, event->x,
+ event->y, event->dx, event->dy);
+
+ if (event->updated_axes & WLR_TABLET_TOOL_AXIS_PRESSURE)
+ wlr_tablet_v2_tablet_tool_notify_pressure(tablet_tool, event->pressure);
+ if (event->updated_axes & WLR_TABLET_TOOL_AXIS_DISTANCE)
+ wlr_tablet_v2_tablet_tool_notify_distance(tablet_tool, event->distance);
+ if (event->updated_axes &
+ (WLR_TABLET_TOOL_AXIS_TILT_X | WLR_TABLET_TOOL_AXIS_TILT_Y)) {
+ printf("DEBUGGING: In axis event handling\n");
+ wlr_tablet_v2_tablet_tool_notify_tilt(tablet_tool, event->tilt_x,
+ event->tilt_y);
+ }
+ if (event->updated_axes & WLR_TABLET_TOOL_AXIS_ROTATION)
+ wlr_tablet_v2_tablet_tool_notify_rotation(tablet_tool, event->rotation);
+ if (event->updated_axes & WLR_TABLET_TOOL_AXIS_SLIDER)
+ wlr_tablet_v2_tablet_tool_notify_slider(tablet_tool, event->slider);
+ if (event->updated_axes & WLR_TABLET_TOOL_AXIS_WHEEL)
+ wlr_tablet_v2_tablet_tool_notify_wheel(tablet_tool, event->wheel_delta,
+ 0);
+}
+
+void tablettoolbutton(struct wl_listener *listener, void *data) {
+ struct wlr_tablet_tool_button_event *event = data;
+ wlr_tablet_v2_tablet_tool_notify_button(
+ tablet_tool, event->button,
+ (enum zwp_tablet_pad_v2_button_state)event->state);
+}
+
+void tablettooltip(struct wl_listener *listener, void *data) {
+ struct wlr_tablet_tool_tip_event *event = data;
+
+ if (!tablet_curr_surface) {
+ struct wlr_pointer_button_event fakeptrbtnevent = {
+ .button = BTN_LEFT,
+ .state = event->state == WLR_TABLET_TOOL_TIP_UP
+ ? WL_POINTER_BUTTON_STATE_RELEASED
+ : WL_POINTER_BUTTON_STATE_PRESSED,
+ .time_msec = event->time_msec,
+ };
+ buttonpress(NULL, (void *)&fakeptrbtnevent);
+ }
+
+ if (event->state == WLR_TABLET_TOOL_TIP_UP) {
+ wlr_tablet_v2_tablet_tool_notify_up(tablet_tool);
+ return;
+ }
+
+ wlr_tablet_v2_tablet_tool_notify_down(tablet_tool);
+ wlr_tablet_tool_v2_start_implicit_grab(tablet_tool);
+}
diff --git a/src/mango.c b/src/mango.c
index 3700441..7e2e818 100644
--- a/src/mango.c
+++ b/src/mango.c
@@ -67,6 +67,9 @@
#include <wlr/types/wlr_session_lock_v1.h>
#include <wlr/types/wlr_single_pixel_buffer_v1.h>
#include <wlr/types/wlr_subcompositor.h>
+#include <wlr/types/wlr_tablet_pad.h>
+#include <wlr/types/wlr_tablet_tool.h>
+#include <wlr/types/wlr_tablet_v2.h>
#include <wlr/types/wlr_viewporter.h>
#include <wlr/types/wlr_virtual_keyboard_v1.h>
#include <wlr/types/wlr_virtual_pointer_v1.h>
@@ -3017,6 +3020,12 @@ void inputdevice(struct wl_listener *listener, void *data) {
case WLR_INPUT_DEVICE_KEYBOARD:
createkeyboard(wlr_keyboard_from_input_device(device));
break;
+ case WLR_INPUT_DEVICE_TABLET:
+ createtablet(device);
+ break;
+ case WLR_INPUT_DEVICE_TABLET_PAD:
+ tablet_pad = wlr_tablet_pad_create(tablet_mgr, seat, device);
+ break;
case WLR_INPUT_DEVICE_POINTER:
createpointer(wlr_pointer_from_input_device(device));
break;
@@ -4422,6 +4431,7 @@ void setup(void) {
dpy = wl_display_create();
event_loop = wl_display_get_event_loop(dpy);
pointer_manager = wlr_relative_pointer_manager_v1_create(dpy);
+ tablet_mgr = wlr_tablet_v2_create(dpy);
/* The backend is a wlroots feature which abstracts the underlying input and
* output hardware. The autocreate option will choose the most suitable
* backend based on the current environment, such as opening an X11 window
@@ -4594,6 +4604,11 @@ void setup(void) {
wl_signal_add(&cursor->events.button, &cursor_button);
wl_signal_add(&cursor->events.axis, &cursor_axis);
wl_signal_add(&cursor->events.frame, &cursor_frame);
+ wl_signal_add(&cursor->events.tablet_tool_proximity,
+ &tablet_tool_proximity);
+ wl_signal_add(&cursor->events.tablet_tool_axis, &tablet_tool_axis);
+ wl_signal_add(&cursor->events.tablet_tool_button, &tablet_tool_button);
+ wl_signal_add(&cursor->events.tablet_tool_tip, &tablet_tool_tip);
// 这两句代码会造成obs窗口里的鼠标光标消失,不知道注释有什么影响
cursor_shape_mgr = wlr_cursor_shape_manager_v1_create(dpy, 1);
--
2.49.1