339 lines
14 KiB
Zig
339 lines
14 KiB
Zig
|
const std = @import("std");
|
||
|
const c = @import("c.zig").c;
|
||
|
|
||
|
const CursorMode = enum {
|
||
|
Passthrough,
|
||
|
Move,
|
||
|
Resize,
|
||
|
};
|
||
|
|
||
|
pub const Cursor = struct {
|
||
|
seat: *Seat,
|
||
|
|
||
|
wlr_cursor: *c.wlr_cursor,
|
||
|
wlr_xcursor_manager: *c.wlr_xcursor_manager,
|
||
|
|
||
|
listen_motion: c.wl_listener,
|
||
|
listen_motion_absolute: c.wl_listener,
|
||
|
listen_button: c.wl_listener,
|
||
|
listen_axis: c.wl_listener,
|
||
|
listen_frame: c.wl_listener,
|
||
|
|
||
|
listen_request_cursor: c.wl_listener,
|
||
|
|
||
|
cursor_mode: CursorMode,
|
||
|
grabbed_view: ?*View,
|
||
|
grab_x: f64,
|
||
|
grab_y: f64,
|
||
|
grab_width: c_int,
|
||
|
grab_height: c_int,
|
||
|
resize_edges: u32,
|
||
|
|
||
|
pub fn init(seat: *Seat) !@This() {
|
||
|
var cursor = @This(){
|
||
|
.server = seat.server,
|
||
|
.seat = seat,
|
||
|
|
||
|
// Creates a wlroots utility for tracking the cursor image shown on screen.
|
||
|
.wlr_cursor = c.wlr_cursor_create() orelse
|
||
|
return error.CantCreateWlrCursor,
|
||
|
|
||
|
// Creates an xcursor manager, another wlroots utility which loads up
|
||
|
// Xcursor themes to source cursor images from and makes sure that cursor
|
||
|
// images are available at all scale factors on the screen (necessary for
|
||
|
// HiDPI support). We add a cursor theme at scale factor 1 to begin with.
|
||
|
.wlr_xcursor_manager = c.wlr_xcursor_manager_create(null, 24) orelse
|
||
|
return error.CantCreateWlrXCursorManager,
|
||
|
|
||
|
.listen_motion = c.wl_listener{
|
||
|
.link = undefined,
|
||
|
.notify = @This().handle_motion,
|
||
|
},
|
||
|
.listen_motion_absolute = c.wl_listener{
|
||
|
.link = undefined,
|
||
|
.notify = @This().handle_motion_absolute,
|
||
|
},
|
||
|
.listen_button = c.wl_listener{
|
||
|
.link = undefined,
|
||
|
.notify = @This().handle_button,
|
||
|
},
|
||
|
.listen_axis = c.wl_listener{
|
||
|
.link = undefined,
|
||
|
.notify = @This().handle_axis,
|
||
|
},
|
||
|
.listen_frame = c.wl_listener{
|
||
|
.link = undefined,
|
||
|
.notify = @This().handle_frame,
|
||
|
},
|
||
|
|
||
|
.listen_request_set_cursor = c.wl_listener{
|
||
|
.link = undefined,
|
||
|
.notify = @This().handle_request_set_cursor,
|
||
|
},
|
||
|
|
||
|
.mode = CursorMode.Passthrough,
|
||
|
|
||
|
.grabbed_view = null,
|
||
|
.grab_x = 0.0,
|
||
|
.grab_y = 0.0,
|
||
|
.grab_width = 0,
|
||
|
.grab_height = 0,
|
||
|
.resize_edges = 0,
|
||
|
};
|
||
|
|
||
|
c.wlr_cursor_attach_output_layout(cursor.wlr_cursor, seat.*.server.*.output_layout);
|
||
|
_ = c.wlr_xcursor_manager_load(server.cursor_mgr, 1);
|
||
|
|
||
|
// wlr_cursor *only* displays an image on screen. It does not move around
|
||
|
// when the pointer moves. However, we can attach input devices to it, and
|
||
|
// it will generate aggregate events for all of them. In these events, we
|
||
|
// can choose how we want to process them, forwarding them to clients and
|
||
|
// moving the cursor around. See following post for more detail:
|
||
|
// https://drewdevault.com/2018/07/17/Input-handling-in-wlroots.html
|
||
|
c.wl_signal_add(&cursor.wlr_cursor.*.events.motion, &cursor.listen_motion);
|
||
|
c.wl_signal_add(&cursor.wlr_cursor.*.events.motion_absolute, &cursor.listen_motion_absolute);
|
||
|
c.wl_signal_add(&cursor.wlr_cursor.*.events.button, &cursor.listen_button);
|
||
|
c.wl_signal_add(&cursor.wlr_cursor.*.events.axis, &cursor.listen_axis);
|
||
|
c.wl_signal_add(&cursor.wlr_cursor.*.events.frame, &cursor.listen_frame);
|
||
|
|
||
|
// This listens for clients requesting a specific cursor image
|
||
|
c.wl_signal_add(&server.seat.*.events.request_set_cursor, &cursor.listen_request_set_cursor);
|
||
|
|
||
|
return cursor;
|
||
|
}
|
||
|
|
||
|
fn process_cursor_move(server: *Server, time: u32) void {
|
||
|
// Move the grabbed view to the new position.
|
||
|
server.*.grabbed_view.?.*.x = @floatToInt(c_int, server.*.cursor.*.x - server.*.grab_x);
|
||
|
server.*.grabbed_view.?.*.y = @floatToInt(c_int, server.*.cursor.*.y - server.*.grab_y);
|
||
|
}
|
||
|
|
||
|
fn process_cursor_resize(server: *Server, time: u32) void {
|
||
|
// Resizing the grabbed view can be a little bit complicated, because we
|
||
|
// could be resizing from any corner or edge. This not only resizes the view
|
||
|
// on one or two axes, but can also move the view if you resize from the top
|
||
|
// or left edges (or top-left corner).
|
||
|
//
|
||
|
// Note that I took some shortcuts here. In a more fleshed-out compositor,
|
||
|
// you'd wait for the client to prepare a buffer at the new size, then
|
||
|
// commit any movement that was prepared.
|
||
|
var view = server.*.grabbed_view;
|
||
|
|
||
|
var dx: f64 = (server.*.cursor.*.x - server.*.grab_x);
|
||
|
var dy: f64 = (server.*.cursor.*.y - server.*.grab_y);
|
||
|
var x: f64 = @intToFloat(f64, view.?.*.x);
|
||
|
var y: f64 = @intToFloat(f64, view.?.*.y);
|
||
|
|
||
|
var width = @intToFloat(f64, server.*.grab_width);
|
||
|
var height = @intToFloat(f64, server.*.grab_height);
|
||
|
if (server.*.resize_edges & @intCast(u32, c.WLR_EDGE_TOP) != 0) {
|
||
|
y = server.*.grab_y + dy;
|
||
|
height -= dy;
|
||
|
if (height < 1) {
|
||
|
y += height;
|
||
|
}
|
||
|
} else if (server.*.resize_edges & @intCast(u32, c.WLR_EDGE_BOTTOM) != 0) {
|
||
|
height += dy;
|
||
|
}
|
||
|
if (server.*.resize_edges & @intCast(u32, c.WLR_EDGE_LEFT) != 0) {
|
||
|
x = server.*.grab_x + dx;
|
||
|
width -= dx;
|
||
|
if (width < 1) {
|
||
|
x += width;
|
||
|
}
|
||
|
} else if (server.*.resize_edges & @intCast(u32, c.WLR_EDGE_RIGHT) != 0) {
|
||
|
width += dx;
|
||
|
}
|
||
|
view.?.*.x = @floatToInt(c_int, x);
|
||
|
view.?.*.y = @floatToInt(c_int, y);
|
||
|
_ = c.wlr_xdg_toplevel_set_size(
|
||
|
view.?.*.xdg_surface,
|
||
|
@floatToInt(u32, width),
|
||
|
@floatToInt(u32, height),
|
||
|
);
|
||
|
}
|
||
|
|
||
|
fn process_cursor_motion(server: *Server, time: u32) void {
|
||
|
// If the mode is non-passthrough, delegate to those functions.
|
||
|
if (server.*.cursor_mode == CursorMode.Move) {
|
||
|
process_cursor_move(server, time);
|
||
|
return;
|
||
|
} else if (server.*.cursor_mode == CursorMode.Resize) {
|
||
|
process_cursor_resize(server, time);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// Otherwise, find the view under the pointer and send the event along.
|
||
|
var sx: f64 = undefined;
|
||
|
var sy: f64 = undefined;
|
||
|
var seat = server.*.seat;
|
||
|
var opt_surface: ?*c.wlr_surface = null;
|
||
|
var view = desktop_view_at(
|
||
|
server,
|
||
|
server.*.cursor.*.x,
|
||
|
server.*.cursor.*.y,
|
||
|
&opt_surface,
|
||
|
&sx,
|
||
|
&sy,
|
||
|
);
|
||
|
|
||
|
if (view == null) {
|
||
|
// If there's no view under the cursor, set the cursor image to a
|
||
|
// default. This is what makes the cursor image appear when you move it
|
||
|
// around the screen, not over any views.
|
||
|
c.wlr_xcursor_manager_set_cursor_image(
|
||
|
server.*.cursor_mgr,
|
||
|
"left_ptr",
|
||
|
server.*.cursor,
|
||
|
);
|
||
|
}
|
||
|
|
||
|
if (opt_surface) |surface| {
|
||
|
const focus_changed = seat.*.pointer_state.focused_surface != surface;
|
||
|
// "Enter" the surface if necessary. This lets the client know that the
|
||
|
// cursor has entered one of its surfaces.
|
||
|
//
|
||
|
// Note that this gives the surface "pointer focus", which is distinct
|
||
|
// from keyboard focus. You get pointer focus by moving the pointer over
|
||
|
// a window.
|
||
|
c.wlr_seat_pointer_notify_enter(seat, surface, sx, sy);
|
||
|
if (!focus_changed) {
|
||
|
// The enter event contains coordinates, so we only need to notify
|
||
|
// on motion if the focus did not change.
|
||
|
c.wlr_seat_pointer_notify_motion(seat, time, sx, sy);
|
||
|
}
|
||
|
} else {
|
||
|
// Clear pointer focus so future button events and such are not sent to
|
||
|
// the last client to have the cursor over it.
|
||
|
c.wlr_seat_pointer_clear_focus(seat);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fn handle_motion(listener: [*c]c.wl_listener, data: ?*c_void) callconv(.C) void {
|
||
|
// This event is forwarded by the cursor when a pointer emits a _relative_
|
||
|
// pointer motion event (i.e. a delta)
|
||
|
var server = @fieldParentPtr(Server, "cursor_motion", listener);
|
||
|
var event = @ptrCast(
|
||
|
*c.wlr_event_pointer_motion,
|
||
|
@alignCast(@alignOf(*c.wlr_event_pointer_motion), data),
|
||
|
);
|
||
|
// The cursor doesn't move unless we tell it to. The cursor automatically
|
||
|
// handles constraining the motion to the output layout, as well as any
|
||
|
// special configuration applied for the specific input device which
|
||
|
// generated the event. You can pass NULL for the device if you want to move
|
||
|
// the cursor around without any input.
|
||
|
c.wlr_cursor_move(server.*.cursor, event.*.device, event.*.delta_x, event.*.delta_y);
|
||
|
process_cursor_motion(server, event.*.time_msec);
|
||
|
}
|
||
|
|
||
|
fn handle_motion_absolute(listener: [*c]c.wl_listener, data: ?*c_void) callconv(.C) void {
|
||
|
// This event is forwarded by the cursor when a pointer emits an _absolute_
|
||
|
// motion event, from 0..1 on each axis. This happens, for example, when
|
||
|
// wlroots is running under a Wayland window rather than KMS+DRM, and you
|
||
|
// move the mouse over the window. You could enter the window from any edge,
|
||
|
// so we have to warp the mouse there. There is also some hardware which
|
||
|
// emits these events.
|
||
|
var server = @fieldParentPtr(Server, "cursor_motion_absolute", listener);
|
||
|
var event = @ptrCast(
|
||
|
*c.wlr_event_pointer_motion_absolute,
|
||
|
@alignCast(@alignOf(*c.wlr_event_pointer_motion_absolute), data),
|
||
|
);
|
||
|
c.wlr_cursor_warp_absolute(server.*.cursor, event.*.device, event.*.x, event.*.y);
|
||
|
process_cursor_motion(server, event.*.time_msec);
|
||
|
}
|
||
|
|
||
|
fn handle_button(listener: [*c]c.wl_listener, data: ?*c_void) callconv(.C) void {
|
||
|
// This event is forwarded by the cursor when a pointer emits a button
|
||
|
// event.
|
||
|
var server = @fieldParentPtr(Server, "cursor_button", listener);
|
||
|
var event = @ptrCast(
|
||
|
*c.wlr_event_pointer_button,
|
||
|
@alignCast(@alignOf(*c.wlr_event_pointer_button), data),
|
||
|
);
|
||
|
// Notify the client with pointer focus that a button press has occurred
|
||
|
_ = c.wlr_seat_pointer_notify_button(
|
||
|
server.*.seat,
|
||
|
event.*.time_msec,
|
||
|
event.*.button,
|
||
|
event.*.state,
|
||
|
);
|
||
|
|
||
|
var sx: f64 = undefined;
|
||
|
var sy: f64 = undefined;
|
||
|
|
||
|
var surface: ?*c.wlr_surface = null;
|
||
|
var view = desktop_view_at(
|
||
|
server,
|
||
|
server.*.cursor.*.x,
|
||
|
server.*.cursor.*.y,
|
||
|
&surface,
|
||
|
&sx,
|
||
|
&sy,
|
||
|
);
|
||
|
|
||
|
if (event.*.state == c.enum_wlr_button_state.WLR_BUTTON_RELEASED) {
|
||
|
// If you released any buttons, we exit interactive move/resize mode.
|
||
|
server.*.cursor_mode = CursorMode.Passthrough;
|
||
|
} else {
|
||
|
// Focus that client if the button was _pressed_
|
||
|
if (view) |v| {
|
||
|
focus_view(v, surface.?);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fn handle_axis(listener: [*c]c.wl_listener, data: ?*c_void) callconv(.C) void {
|
||
|
// This event is forwarded by the cursor when a pointer emits an axis event,
|
||
|
// for example when you move the scroll wheel.
|
||
|
var server = @fieldParentPtr(Server, "cursor_axis", listener);
|
||
|
var event = @ptrCast(
|
||
|
*c.wlr_event_pointer_axis,
|
||
|
@alignCast(@alignOf(*c.wlr_event_pointer_axis), data),
|
||
|
);
|
||
|
// Notify the client with pointer focus of the axis event.
|
||
|
c.wlr_seat_pointer_notify_axis(
|
||
|
server.*.seat,
|
||
|
event.*.time_msec,
|
||
|
event.*.orientation,
|
||
|
event.*.delta,
|
||
|
event.*.delta_discrete,
|
||
|
event.*.source,
|
||
|
);
|
||
|
}
|
||
|
|
||
|
fn handle_frame(listener: [*c]c.wl_listener, data: ?*c_void) callconv(.C) void {
|
||
|
// This event is forwarded by the cursor when a pointer emits an frame
|
||
|
// event. Frame events are sent after regular pointer events to group
|
||
|
// multiple events together. For instance, two axis events may happen at the
|
||
|
// same time, in which case a frame event won't be sent in between.
|
||
|
var server = @fieldParentPtr(Server, "cursor_frame", listener);
|
||
|
// Notify the client with pointer focus of the frame event.
|
||
|
c.wlr_seat_pointer_notify_frame(server.*.seat);
|
||
|
}
|
||
|
|
||
|
fn handle_request_set_cursor(listener: [*c]c.wl_listener, data: ?*c_void) callconv(.C) void {
|
||
|
// This event is rasied by the seat when a client provides a cursor image
|
||
|
var server = @fieldParentPtr(Server, "request_cursor", listener);
|
||
|
var event = @ptrCast(
|
||
|
*c.wlr_seat_pointer_request_set_cursor_event,
|
||
|
@alignCast(@alignOf(*c.wlr_seat_pointer_request_set_cursor_event), data),
|
||
|
);
|
||
|
var focused_client = server.*.seat.*.pointer_state.focused_client;
|
||
|
|
||
|
// This can be sent by any client, so we check to make sure this one is
|
||
|
// actually has pointer focus first.
|
||
|
if (focused_client == event.*.seat_client) {
|
||
|
// Once we've vetted the client, we can tell the cursor to use the
|
||
|
// provided surface as the cursor image. It will set the hardware cursor
|
||
|
// on the output that it's currently on and continue to do so as the
|
||
|
// cursor moves between outputs.
|
||
|
c.wlr_cursor_set_surface(
|
||
|
server.*.cursor,
|
||
|
event.*.surface,
|
||
|
event.*.hotspot_x,
|
||
|
event.*.hotspot_y,
|
||
|
);
|
||
|
}
|
||
|
}
|
||
|
};
|