Merge 4797f8d979 into 74d24c3cd9

src/ext-protocol/all.h

@@ -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"
+

src/ext-protocol/tablet.h

@@ -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,
+														config.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 (config.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);
+}

src/mango.c

@@ -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);
@@ -2047,6 +2051,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;
@@ -2061,8 +2072,8 @@ buttonpress(struct wl_listener *listener, void *data) {
 	handlecursoractivity();
 	wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
 
-	if (check_trackpad_disabled(event->pointer)) {
+	if (event->pointer && check_trackpad_disabled(event->pointer)) {
-		return;
+		return true;
 	}
 
 	switch (event->state) {
@@ -2109,12 +2120,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) &&
@@ -2122,7 +2133,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;
@@ -2154,16 +2165,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
+	/* If the event wasn't handled by the compositor, return false */
-	 * pointer focus that a button press has occurred */
+	return false;
-	wlr_seat_pointer_notify_button(seat, event->time_msec, event->button,
-								   event->state);
 }
 
 void checkidleinhibitor(struct wlr_surface *exclude) {
@@ -3669,6 +3678,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;
@@ -5519,6 +5534,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
@@ -5669,7 +5694,6 @@ void setup(void) {
 	wl_signal_add(&pointer_constraints->events.new_constraint,
 				  &new_pointer_constraint);
 
-	relative_pointer_mgr = wlr_relative_pointer_manager_v1_create(dpy);
 
 	/*
 	 * Creates a cursor, which is a wlroots utility for tracking the cursor
@@ -5706,6 +5730,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);