output: add wlr_output_set_hardware_cursors_enabled

And use it in screencopy.

include/wlr/types/wlr_output.h

@@ -107,6 +107,7 @@ struct wlr_output {
 
 	struct wl_list cursors; // wlr_output_cursor::link
 	struct wlr_output_cursor *hardware_cursor;
+	int software_cursor_locks; // number of locks forcing software cursors
 
 	// the output position in layout space reported to clients
 	int32_t lx, ly;
@@ -196,6 +197,14 @@ bool wlr_output_export_dmabuf(struct wlr_output *output,
 void wlr_output_set_fullscreen_surface(struct wlr_output *output,
 	struct wlr_surface *surface);
 struct wlr_output *wlr_output_from_resource(struct wl_resource *resource);
+/**
+ * Locks the output to only use software cursors instead of hardware cursors.
+ * This is useful if hardware cursors need to be temporarily disabled (e.g.
+ * during screen capture). There must be as many unlocks as there have been
+ * locks to restore the original state. There should never be an unlock before
+ * a lock.
+ */
+void wlr_output_lock_software_cursors(struct wlr_output *output, bool lock);
 
 
 struct wlr_output_cursor *wlr_output_cursor_create(struct wlr_output *output);

include/wlr/types/wlr_screencopy_v1.h

@@ -9,6 +9,7 @@
 #ifndef WLR_TYPES_WLR_SCREENCOPY_V1_H
 #define WLR_TYPES_WLR_SCREENCOPY_V1_H
 
+#include <stdbool.h>
 #include <wayland-server.h>
 #include <wlr/types/wlr_box.h>
 
@@ -35,6 +36,8 @@ struct wlr_screencopy_frame_v1 {
 	struct wlr_box box;
 	int stride;
 
+	bool overlay_cursor, cursor_locked;
+
 	struct wl_shm_buffer *buffer;
 	struct wl_listener buffer_destroy;
 

types/wlr_output.c

@@ -273,6 +273,13 @@ void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend,
 	wl_signal_init(&output->events.destroy);
 	pixman_region32_init(&output->damage);
 
+	const char *no_hardware_cursors = getenv("WLR_NO_HARDWARE_CURSORS");
+	if (no_hardware_cursors != NULL && strcmp(no_hardware_cursors, "1") == 0) {
+		wlr_log(WLR_DEBUG,
+			"WLR_NO_HARDWARE_CURSORS set, forcing software cursors");
+		output->software_cursor_locks = 1;
+	}
+
 	output->display_destroy.notify = handle_display_destroy;
 	wl_display_add_destroy_listener(display, &output->display_destroy);
 
@@ -469,13 +476,6 @@ bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when,
 		output->idle_frame = NULL;
 	}
 
-	struct wlr_output_event_swap_buffers event = {
-		.output = output,
-		.when = when,
-		.damage = damage,
-	};
-	wlr_signal_emit_safe(&output->events.swap_buffers, &event);
-
 	int width, height;
 	wlr_output_transformed_resolution(output, &width, &height);
 
@@ -510,6 +510,13 @@ bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when,
 		}
 	}
 
+	struct wlr_output_event_swap_buffers event = {
+		.output = output,
+		.when = when,
+		.damage = damage,
+	};
+	wlr_signal_emit_safe(&output->events.swap_buffers, &event);
+
 	// Transform damage into renderer coordinates, ie. upside down
 	enum wl_output_transform transform = wlr_output_transform_compose(
 		wlr_output_transform_invert(output->transform),
@@ -666,6 +673,32 @@ struct wlr_output *wlr_output_from_resource(struct wl_resource *resource) {
 	return wl_resource_get_user_data(resource);
 }
 
+static void output_cursor_damage_whole(struct wlr_output_cursor *cursor);
+
+void wlr_output_lock_software_cursors(struct wlr_output *output, bool lock) {
+	if (lock) {
+		++output->software_cursor_locks;
+	} else {
+		assert(output->software_cursor_locks > 0);
+		--output->software_cursor_locks;
+	}
+	wlr_log(WLR_DEBUG, "%s hardware cursors on output '%s' (locks: %d)",
+		lock ? "Disabling" : "Enabling", output->name,
+		output->software_cursor_locks);
+
+	if (output->software_cursor_locks > 0 && output->hardware_cursor != NULL) {
+		assert(output->impl->set_cursor);
+		output->impl->set_cursor(output, NULL, 1,
+			WL_OUTPUT_TRANSFORM_NORMAL, 0, 0, true);
+		output_cursor_damage_whole(output->hardware_cursor);
+		output->hardware_cursor = NULL;
+	}
+
+	// If it's possible to use hardware cursors again, don't switch immediately
+	// since a recorder is likely to lock software cursors for the next frame
+	// again.
+}
+
 
 static void output_cursor_damage_whole(struct wlr_output_cursor *cursor) {
 	struct wlr_box box;
@@ -721,10 +754,7 @@ static bool output_cursor_attempt_hardware(struct wlr_output_cursor *cursor) {
 		transform = cursor->surface->current.transform;
 	}
 
-	const char *no_hardware_cursors = getenv("WLR_NO_HARDWARE_CURSORS");
+	if (cursor->output->software_cursor_locks > 0) {
-	if (no_hardware_cursors != NULL && strcmp(no_hardware_cursors, "1") == 0) {
-		wlr_log(WLR_DEBUG,
-			"WLR_NO_HARDWARE_CURSORS set, forcing software cursors");
 		return false;
 	}
 

types/wlr_screencopy_v1.c

@@ -22,6 +22,9 @@ static void frame_destroy(struct wlr_screencopy_frame_v1 *frame) {
 	if (frame == NULL) {
 		return;
 	}
+	if (frame->cursor_locked) {
+		wlr_output_lock_software_cursors(frame->output, false);
+	}
 	wl_list_remove(&frame->link);
 	wl_list_remove(&frame->output_swap_buffers.link);
 	wl_list_remove(&frame->buffer_destroy.link);
@@ -133,6 +136,11 @@ static void frame_handle_copy(struct wl_client *client,
 	// Schedule a buffer swap
 	output->needs_swap = true;
 	wlr_output_schedule_frame(output);
+
+	if (frame->overlay_cursor) {
+		wlr_output_lock_software_cursors(output, true);
+		frame->cursor_locked = true;
+	}
 }
 
 static void frame_handle_destroy(struct wl_client *client,
@@ -189,6 +197,7 @@ static void capture_output(struct wl_client *client,
 	}
 	frame->manager = manager;
 	frame->output = output;
+	frame->overlay_cursor = !!overlay_cursor;
 
 	frame->resource = wl_resource_create(client,
 		&zwlr_screencopy_frame_v1_interface, version, id);