asolkar/dwl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

functions: dwm style and more dwm-like names

Browse Source
This commit is contained in:
Devin J. Pohly 2020-04-21 13:18:38 -05:00
parent bc9049a11b
commit 2c0bf57fcf
1 changed files with 142 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

227
dwl.c
View File

@ -129,7 +129,9 @@ static void spawn(struct dwl_server *, const Arg *);
#include "config.h" #include "config.h"
static void focus_view(struct dwl_view *view, struct wlr_surface *surface) { static void
focus(struct dwl_view *view, struct wlr_surface *surface)
{
/* Note: this function only deals with keyboard focus. */ /* Note: this function only deals with keyboard focus. */
if (view == NULL) { if (view == NULL) {
return; return;
@ -166,8 +168,9 @@ static void focus_view(struct dwl_view *view, struct wlr_surface *surface) {
keyboard->keycodes, keyboard->num_keycodes, &keyboard->modifiers); keyboard->keycodes, keyboard->num_keycodes, &keyboard->modifiers);
} }
static void keyboard_handle_modifiers( static void
struct wl_listener *listener, void *data) { keypressmod(struct wl_listener *listener, void *data)
{
/* This event is raised when a modifier key, such as shift or alt, is /* This event is raised when a modifier key, such as shift or alt, is
* pressed. We simply communicate this to the client. */ * pressed. We simply communicate this to the client. */
struct dwl_keyboard *keyboard = struct dwl_keyboard *keyboard =
@ -184,11 +187,15 @@ static void keyboard_handle_modifiers(
&keyboard->device->keyboard->modifiers); &keyboard->device->keyboard->modifiers);
} }
static void quit(struct dwl_server *server, const Arg *unused) { static void
quit(struct dwl_server *server, const Arg *arg)
{
wl_display_terminate(server->wl_display); wl_display_terminate(server->wl_display);
} }
static void spawn(struct dwl_server *server, const Arg *arg) { static void
spawn(struct dwl_server *server, const Arg *arg)
{
if (fork() == 0) { if (fork() == 0) {
setsid(); setsid();
execvp(((char **)arg->v)[0], (char **)arg->v); execvp(((char **)arg->v)[0], (char **)arg->v);
@ -198,7 +205,9 @@ static void spawn(struct dwl_server *server, const Arg *arg) {
} }
} }
static void focusnext(struct dwl_server *server, const Arg *unused) { static void
focusnext(struct dwl_server *server, const Arg *arg)
{
/* Cycle to the next view */ /* Cycle to the next view */
if (wl_list_length(&server->views) < 2) { if (wl_list_length(&server->views) < 2) {
return; return;
@ -207,13 +216,15 @@ static void focusnext(struct dwl_server *server, const Arg *unused) {
server->views.next, current_view, link); server->views.next, current_view, link);
struct dwl_view *next_view = wl_container_of( struct dwl_view *next_view = wl_container_of(
current_view->link.next, next_view, link); current_view->link.next, next_view, link);
focus_view(next_view, next_view->xdg_surface->surface); focus(next_view, next_view->xdg_surface->surface);
/* Move the previous view to the end of the list */ /* Move the previous view to the end of the list */
wl_list_remove(&current_view->link); wl_list_remove(&current_view->link);
wl_list_insert(server->views.prev, &current_view->link); wl_list_insert(server->views.prev, &current_view->link);
} }
static bool handle_keybinding(struct dwl_server *server, uint32_t mods, xkb_keysym_t sym) { static bool
keybinding(struct dwl_server *server, uint32_t mods, xkb_keysym_t sym)
{
/* /*
* Here we handle compositor keybindings. This is when the compositor is * Here we handle compositor keybindings. This is when the compositor is
* processing keys, rather than passing them on to the client for its own * processing keys, rather than passing them on to the client for its own
@ -231,8 +242,9 @@ static bool handle_keybinding(struct dwl_server *server, uint32_t mods, xkb_keys
return handled; return handled;
} }
static void keyboard_handle_key( static void
struct wl_listener *listener, void *data) { keypress(struct wl_listener *listener, void *data)
{
/* This event is raised when a key is pressed or released. */ /* This event is raised when a key is pressed or released. */
struct dwl_keyboard *keyboard = struct dwl_keyboard *keyboard =
wl_container_of(listener, keyboard, key); wl_container_of(listener, keyboard, key);
@ -252,7 +264,7 @@ static void keyboard_handle_key(
if (event->state == WLR_KEY_PRESSED) { if (event->state == WLR_KEY_PRESSED) {
/* On _press_, attempt to process a compositor keybinding. */ /* On _press_, attempt to process a compositor keybinding. */
for (int i = 0; i < nsyms; i++) { for (int i = 0; i < nsyms; i++) {
handled = handle_keybinding(server, mods, syms[i]) || handled; handled = keybinding(server, mods, syms[i]) || handled;
} }
} }
@ -264,8 +276,9 @@ static void keyboard_handle_key(
} }
} }
static void server_new_keyboard(struct dwl_server *server, static void
struct wlr_input_device *device) { createkeyboard(struct dwl_server *server, struct wlr_input_device *device)
{
struct dwl_keyboard *keyboard = struct dwl_keyboard *keyboard =
calloc(1, sizeof(struct dwl_keyboard)); calloc(1, sizeof(struct dwl_keyboard));
keyboard->server = server; keyboard->server = server;
@ -283,9 +296,9 @@ static void server_new_keyboard(struct dwl_server *server,
wlr_keyboard_set_repeat_info(device->keyboard, 25, 600); wlr_keyboard_set_repeat_info(device->keyboard, 25, 600);
/* Here we set up listeners for keyboard events. */ /* Here we set up listeners for keyboard events. */
keyboard->modifiers.notify = keyboard_handle_modifiers; keyboard->modifiers.notify = keypressmod;
wl_signal_add(&device->keyboard->events.modifiers, &keyboard->modifiers); wl_signal_add(&device->keyboard->events.modifiers, &keyboard->modifiers);
keyboard->key.notify = keyboard_handle_key; keyboard->key.notify = keypress;
wl_signal_add(&device->keyboard->events.key, &keyboard->key); wl_signal_add(&device->keyboard->events.key, &keyboard->key);
wlr_seat_set_keyboard(server->seat, device); wlr_seat_set_keyboard(server->seat, device);
@ -294,8 +307,9 @@ static void server_new_keyboard(struct dwl_server *server,
wl_list_insert(&server->keyboards, &keyboard->link); wl_list_insert(&server->keyboards, &keyboard->link);
} }
static void server_new_pointer(struct dwl_server *server, static void
struct wlr_input_device *device) { createpointer(struct dwl_server *server, struct wlr_input_device *device)
{
/* We don't do anything special with pointers. All of our pointer handling /* We don't do anything special with pointers. All of our pointer handling
* is proxied through wlr_cursor. On another compositor, you might take this * is proxied through wlr_cursor. On another compositor, you might take this
* opportunity to do libinput configuration on the device to set * opportunity to do libinput configuration on the device to set
@ -303,7 +317,9 @@ static void server_new_pointer(struct dwl_server *server,
wlr_cursor_attach_input_device(server->cursor, device); wlr_cursor_attach_input_device(server->cursor, device);
} }
static void server_new_input(struct wl_listener *listener, void *data) { static void
inputdevice(struct wl_listener *listener, void *data)
{
/* This event is raised by the backend when a new input device becomes /* This event is raised by the backend when a new input device becomes
* available. */ * available. */
struct dwl_server *server = struct dwl_server *server =
@ -311,10 +327,10 @@ static void server_new_input(struct wl_listener *listener, void *data) {
struct wlr_input_device *device = data; struct wlr_input_device *device = data;
switch (device->type) { switch (device->type) {
case WLR_INPUT_DEVICE_KEYBOARD: case WLR_INPUT_DEVICE_KEYBOARD:
server_new_keyboard(server, device); createkeyboard(server, device);
break; break;
case WLR_INPUT_DEVICE_POINTER: case WLR_INPUT_DEVICE_POINTER:
server_new_pointer(server, device); createpointer(server, device);
break; break;
default: default:
break; break;
@ -329,7 +345,9 @@ static void server_new_input(struct wl_listener *listener, void *data) {
wlr_seat_set_capabilities(server->seat, caps); wlr_seat_set_capabilities(server->seat, caps);
} }
static void seat_request_cursor(struct wl_listener *listener, void *data) { static void
setcursor(struct wl_listener *listener, void *data)
{
struct dwl_server *server = wl_container_of( struct dwl_server *server = wl_container_of(
listener, server, request_cursor); listener, server, request_cursor);
/* This event is rasied by the seat when a client provides a cursor image */ /* This event is rasied by the seat when a client provides a cursor image */
@ -348,9 +366,10 @@ static void seat_request_cursor(struct wl_listener *listener, void *data) {
} }
} }
static bool view_at(struct dwl_view *view, static bool
double lx, double ly, struct wlr_surface **surface, xytosurface(struct dwl_view *view, double lx, double ly,
double *sx, double *sy) { struct wlr_surface **surface, double *sx, double *sy)
{
/* /*
* XDG toplevels may have nested surfaces, such as popup windows for context * XDG toplevels may have nested surfaces, such as popup windows for context
* menus or tooltips. This function tests if any of those are underneath the * menus or tooltips. This function tests if any of those are underneath the
@ -378,27 +397,32 @@ static bool view_at(struct dwl_view *view,
return false; return false;
} }
static struct dwl_view *desktop_view_at( static struct dwl_view *
struct dwl_server *server, double lx, double ly, xytoview(struct dwl_server *server, double lx, double ly,
struct wlr_surface **surface, double *sx, double *sy) { struct wlr_surface **surface, double *sx, double *sy)
{
/* This iterates over all of our surfaces and attempts to find one under the /* This iterates over all of our surfaces and attempts to find one under the
* cursor. This relies on server->views being ordered from top-to-bottom. */ * cursor. This relies on server->views being ordered from top-to-bottom. */
struct dwl_view *view; struct dwl_view *view;
wl_list_for_each(view, &server->views, link) { wl_list_for_each(view, &server->views, link) {
if (view_at(view, lx, ly, surface, sx, sy)) { if (xytosurface(view, lx, ly, surface, sx, sy)) {
return view; return view;
} }
} }
return NULL; return NULL;
} }
static void process_cursor_move(struct dwl_server *server, uint32_t time) { static void
handlemove(struct dwl_server *server, uint32_t time)
{
/* Move the grabbed view to the new position. */ /* Move the grabbed view to the new position. */
server->grabbed_view->x = server->cursor->x - server->grab_x; server->grabbed_view->x = server->cursor->x - server->grab_x;
server->grabbed_view->y = server->cursor->y - server->grab_y; server->grabbed_view->y = server->cursor->y - server->grab_y;
} }
static void process_cursor_resize(struct dwl_server *server, uint32_t time) { static void
handleresize(struct dwl_server *server, uint32_t time)
{
/* /*
* Resizing the grabbed view can be a little bit complicated, because we * 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 * could be resizing from any corner or edge. This not only resizes the view
@ -439,13 +463,14 @@ static void process_cursor_resize(struct dwl_server *server, uint32_t time) {
wlr_xdg_toplevel_set_size(view->xdg_surface, width, height); wlr_xdg_toplevel_set_size(view->xdg_surface, width, height);
} }
static void process_cursor_motion(struct dwl_server *server, uint32_t time) { static void motionnotify(struct dwl_server *server, uint32_t time)
{
/* If the mode is non-passthrough, delegate to those functions. */ /* If the mode is non-passthrough, delegate to those functions. */
if (server->cursor_mode == DWL_CURSOR_MOVE) { if (server->cursor_mode == DWL_CURSOR_MOVE) {
process_cursor_move(server, time); handlemove(server, time);
return; return;
} else if (server->cursor_mode == DWL_CURSOR_RESIZE) { } else if (server->cursor_mode == DWL_CURSOR_RESIZE) {
process_cursor_resize(server, time); handleresize(server, time);
return; return;
} }
@ -453,7 +478,7 @@ static void process_cursor_motion(struct dwl_server *server, uint32_t time) {
double sx, sy; double sx, sy;
struct wlr_seat *seat = server->seat; struct wlr_seat *seat = server->seat;
struct wlr_surface *surface = NULL; struct wlr_surface *surface = NULL;
struct dwl_view *view = desktop_view_at(server, struct dwl_view *view = xytoview(server,
server->cursor->x, server->cursor->y, &surface, &sx, &sy); server->cursor->x, server->cursor->y, &surface, &sx, &sy);
if (!view) { if (!view) {
/* If there's no view under the cursor, set the cursor image to a /* If there's no view under the cursor, set the cursor image to a
@ -485,7 +510,9 @@ static void process_cursor_motion(struct dwl_server *server, uint32_t time) {
} }
} }
static void server_cursor_motion(struct wl_listener *listener, void *data) { static void
motionrelative(struct wl_listener *listener, void *data)
{
/* This event is forwarded by the cursor when a pointer emits a _relative_ /* This event is forwarded by the cursor when a pointer emits a _relative_
* pointer motion event (i.e. a delta) */ * pointer motion event (i.e. a delta) */
struct dwl_server *server = struct dwl_server *server =
@ -498,11 +525,12 @@ static void server_cursor_motion(struct wl_listener *listener, void *data) {
* the cursor around without any input. */ * the cursor around without any input. */
wlr_cursor_move(server->cursor, event->device, wlr_cursor_move(server->cursor, event->device,
event->delta_x, event->delta_y); event->delta_x, event->delta_y);
process_cursor_motion(server, event->time_msec); motionnotify(server, event->time_msec);
} }
static void server_cursor_motion_absolute( static void
struct wl_listener *listener, void *data) { motionabsolute(struct wl_listener *listener, void *data)
{
/* This event is forwarded by the cursor when a pointer emits an _absolute_ /* 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 * 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 * wlroots is running under a Wayland window rather than KMS+DRM, and you
@ -513,10 +541,12 @@ static void server_cursor_motion_absolute(
wl_container_of(listener, server, cursor_motion_absolute); wl_container_of(listener, server, cursor_motion_absolute);
struct wlr_event_pointer_motion_absolute *event = data; struct wlr_event_pointer_motion_absolute *event = data;
wlr_cursor_warp_absolute(server->cursor, event->device, event->x, event->y); wlr_cursor_warp_absolute(server->cursor, event->device, event->x, event->y);
process_cursor_motion(server, event->time_msec); motionnotify(server, event->time_msec);
} }
static void server_cursor_button(struct wl_listener *listener, void *data) { static void
buttonpress(struct wl_listener *listener, void *data)
{
/* This event is forwarded by the cursor when a pointer emits a button /* This event is forwarded by the cursor when a pointer emits a button
* event. */ * event. */
struct dwl_server *server = struct dwl_server *server =
@ -528,14 +558,14 @@ static void server_cursor_button(struct wl_listener *listener, void *data) {
double sx, sy; double sx, sy;
struct wlr_seat *seat = server->seat; struct wlr_seat *seat = server->seat;
struct wlr_surface *surface; struct wlr_surface *surface;
struct dwl_view *view = desktop_view_at(server, struct dwl_view *view = xytoview(server,
server->cursor->x, server->cursor->y, &surface, &sx, &sy); server->cursor->x, server->cursor->y, &surface, &sx, &sy);
if (event->state == WLR_BUTTON_RELEASED) { if (event->state == WLR_BUTTON_RELEASED) {
/* If you released any buttons, we exit interactive move/resize mode. */ /* If you released any buttons, we exit interactive move/resize mode. */
server->cursor_mode = DWL_CURSOR_PASSTHROUGH; server->cursor_mode = DWL_CURSOR_PASSTHROUGH;
} else { } else {
/* Focus that client if the button was _pressed_ */ /* Focus that client if the button was _pressed_ */
focus_view(view, surface); focus(view, surface);
struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat); struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat);
uint32_t mods = wlr_keyboard_get_modifiers(keyboard); uint32_t mods = wlr_keyboard_get_modifiers(keyboard);
@ -549,7 +579,9 @@ static void server_cursor_button(struct wl_listener *listener, void *data) {
} }
} }
static void server_cursor_axis(struct wl_listener *listener, void *data) { static void
axisnotify(struct wl_listener *listener, void *data)
{
/* This event is forwarded by the cursor when a pointer emits an axis event, /* This event is forwarded by the cursor when a pointer emits an axis event,
* for example when you move the scroll wheel. */ * for example when you move the scroll wheel. */
struct dwl_server *server = struct dwl_server *server =
@ -561,7 +593,9 @@ static void server_cursor_axis(struct wl_listener *listener, void *data) {
event->delta_discrete, event->source); event->delta_discrete, event->source);
} }
static void server_cursor_frame(struct wl_listener *listener, void *data) { static void
cursorframe(struct wl_listener *listener, void *data)
{
/* This event is forwarded by the cursor when a pointer emits an frame /* This event is forwarded by the cursor when a pointer emits an frame
* event. Frame events are sent after regular pointer events to group * event. Frame events are sent after regular pointer events to group
* multiple events together. For instance, two axis events may happen at the * multiple events together. For instance, two axis events may happen at the
@ -581,8 +615,9 @@ struct render_data {
struct timespec *when; struct timespec *when;
}; };
static void render_surface(struct wlr_surface *surface, static void
int sx, int sy, void *data) { render(struct wlr_surface *surface, int sx, int sy, void *data)
{
/* This function is called for every surface that needs to be rendered. */ /* This function is called for every surface that needs to be rendered. */
struct render_data *rdata = data; struct render_data *rdata = data;
struct dwl_view *view = rdata->view; struct dwl_view *view = rdata->view;
@ -642,7 +677,9 @@ static void render_surface(struct wlr_surface *surface,
wlr_surface_send_frame_done(surface, rdata->when); wlr_surface_send_frame_done(surface, rdata->when);
} }
static void output_frame(struct wl_listener *listener, void *data) { static void
renderoutput(struct wl_listener *listener, void *data)
{
/* This function is called every time an output is ready to display a frame, /* This function is called every time an output is ready to display a frame,
* generally at the output's refresh rate (e.g. 60Hz). */ * generally at the output's refresh rate (e.g. 60Hz). */
struct dwl_output *output = struct dwl_output *output =
@ -679,10 +716,10 @@ static void output_frame(struct wl_listener *listener, void *data) {
.renderer = renderer, .renderer = renderer,
.when = &now, .when = &now,
}; };
/* This calls our render_surface function for each surface among the /* This calls our render function for each surface among the
* xdg_surface's toplevel and popups. */ * xdg_surface's toplevel and popups. */
wlr_xdg_surface_for_each_surface(view->xdg_surface, wlr_xdg_surface_for_each_surface(view->xdg_surface,
render_surface, &rdata); render, &rdata);
} }
/* Hardware cursors are rendered by the GPU on a separate plane, and can be /* Hardware cursors are rendered by the GPU on a separate plane, and can be
@ -699,7 +736,9 @@ static void output_frame(struct wl_listener *listener, void *data) {
wlr_output_commit(output->wlr_output); wlr_output_commit(output->wlr_output);
} }
static void server_new_output(struct wl_listener *listener, void *data) { static void
createoutput(struct wl_listener *listener, void *data)
{
/* This event is rasied by the backend when a new output (aka a display or /* This event is rasied by the backend when a new output (aka a display or
* monitor) becomes available. */ * monitor) becomes available. */
struct dwl_server *server = struct dwl_server *server =
@ -726,7 +765,7 @@ static void server_new_output(struct wl_listener *listener, void *data) {
output->wlr_output = wlr_output; output->wlr_output = wlr_output;
output->server = server; output->server = server;
/* Sets up a listener for the frame notify event. */ /* Sets up a listener for the frame notify event. */
output->frame.notify = output_frame; output->frame.notify = renderoutput;
wl_signal_add(&wlr_output->events.frame, &output->frame); wl_signal_add(&wlr_output->events.frame, &output->frame);
wl_list_insert(&server->outputs, &output->link); wl_list_insert(&server->outputs, &output->link);
@ -742,28 +781,36 @@ static void server_new_output(struct wl_listener *listener, void *data) {
wlr_output_create_global(wlr_output); wlr_output_create_global(wlr_output);
} }
static void xdg_surface_map(struct wl_listener *listener, void *data) { static void
maprequest(struct wl_listener *listener, void *data)
{
/* Called when the surface is mapped, or ready to display on-screen. */ /* Called when the surface is mapped, or ready to display on-screen. */
struct dwl_view *view = wl_container_of(listener, view, map); struct dwl_view *view = wl_container_of(listener, view, map);
view->mapped = true; view->mapped = true;
focus_view(view, view->xdg_surface->surface); focus(view, view->xdg_surface->surface);
} }
static void xdg_surface_unmap(struct wl_listener *listener, void *data) { static void
unmapnotify(struct wl_listener *listener, void *data)
{
/* Called when the surface is unmapped, and should no longer be shown. */ /* Called when the surface is unmapped, and should no longer be shown. */
struct dwl_view *view = wl_container_of(listener, view, unmap); struct dwl_view *view = wl_container_of(listener, view, unmap);
view->mapped = false; view->mapped = false;
} }
static void xdg_surface_destroy(struct wl_listener *listener, void *data) { static void
destroynotify(struct wl_listener *listener, void *data)
{
/* Called when the surface is destroyed and should never be shown again. */ /* Called when the surface is destroyed and should never be shown again. */
struct dwl_view *view = wl_container_of(listener, view, destroy); struct dwl_view *view = wl_container_of(listener, view, destroy);
wl_list_remove(&view->link); wl_list_remove(&view->link);
free(view); free(view);
} }
static void begin_interactive(struct dwl_view *view, static void
enum dwl_cursor_mode mode, uint32_t edges) { moveresize(struct dwl_view *view,
enum dwl_cursor_mode mode, uint32_t edges)
{
/* This function sets up an interactive move or resize operation, where the /* This function sets up an interactive move or resize operation, where the
* compositor stops propagating pointer events to clients and instead * compositor stops propagating pointer events to clients and instead
* consumes them itself, to move or resize windows. */ * consumes them itself, to move or resize windows. */
@ -790,21 +837,25 @@ static void begin_interactive(struct dwl_view *view,
server->resize_edges = edges; server->resize_edges = edges;
} }
static void movemouse(struct dwl_server *server, const Arg *unused) { static void
movemouse(struct dwl_server *server, const Arg *arg)
{
double sx, sy; double sx, sy;
struct wlr_surface *surface; struct wlr_surface *surface;
struct dwl_view *view = desktop_view_at(server, struct dwl_view *view = xytoview(server,
server->cursor->x, server->cursor->y, &surface, &sx, &sy); server->cursor->x, server->cursor->y, &surface, &sx, &sy);
if (!view) { if (!view) {
return; return;
} }
begin_interactive(view, DWL_CURSOR_MOVE, 0); moveresize(view, DWL_CURSOR_MOVE, 0);
} }
static void resizemouse(struct dwl_server *server, const Arg *unused) { static void
resizemouse(struct dwl_server *server, const Arg *arg)
{
double sx, sy; double sx, sy;
struct wlr_surface *surface; struct wlr_surface *surface;
struct dwl_view *view = desktop_view_at(server, struct dwl_view *view = xytoview(server,
server->cursor->x, server->cursor->y, &surface, &sx, &sy); server->cursor->x, server->cursor->y, &surface, &sx, &sy);
if (!view) { if (!view) {
return; return;
@ -814,22 +865,24 @@ static void resizemouse(struct dwl_server *server, const Arg *unused) {
wlr_cursor_warp_closest(server->cursor, NULL, wlr_cursor_warp_closest(server->cursor, NULL,
view->x + geo_box.x + geo_box.width, view->x + geo_box.x + geo_box.width,
view->y + geo_box.y + geo_box.height); view->y + geo_box.y + geo_box.height);
begin_interactive(view, DWL_CURSOR_RESIZE, WLR_EDGE_BOTTOM|WLR_EDGE_RIGHT); moveresize(view, DWL_CURSOR_RESIZE, WLR_EDGE_BOTTOM|WLR_EDGE_RIGHT);
} }
static void xdg_toplevel_request_move( static void
struct wl_listener *listener, void *data) { moverequest(struct wl_listener *listener, void *data)
{
/* This event is raised when a client would like to begin an interactive /* This event is raised when a client would like to begin an interactive
* move, typically because the user clicked on their client-side * move, typically because the user clicked on their client-side
* decorations. Note that a more sophisticated compositor should check the * decorations. Note that a more sophisticated compositor should check the
* provied serial against a list of button press serials sent to this * provied serial against a list of button press serials sent to this
* client, to prevent the client from requesting this whenever they want. */ * client, to prevent the client from requesting this whenever they want. */
struct dwl_view *view = wl_container_of(listener, view, request_move); struct dwl_view *view = wl_container_of(listener, view, request_move);
begin_interactive(view, DWL_CURSOR_MOVE, 0); moveresize(view, DWL_CURSOR_MOVE, 0);
} }
static void xdg_toplevel_request_resize( static void
struct wl_listener *listener, void *data) { resizerequest(struct wl_listener *listener, void *data)
{
/* This event is raised when a client would like to begin an interactive /* This event is raised when a client would like to begin an interactive
* resize, typically because the user clicked on their client-side * resize, typically because the user clicked on their client-side
* decorations. Note that a more sophisticated compositor should check the * decorations. Note that a more sophisticated compositor should check the
@ -837,10 +890,12 @@ static void xdg_toplevel_request_resize(
* client, to prevent the client from requesting this whenever they want. */ * client, to prevent the client from requesting this whenever they want. */
struct wlr_xdg_toplevel_resize_event *event = data; struct wlr_xdg_toplevel_resize_event *event = data;
struct dwl_view *view = wl_container_of(listener, view, request_resize); struct dwl_view *view = wl_container_of(listener, view, request_resize);
begin_interactive(view, DWL_CURSOR_RESIZE, event->edges); moveresize(view, DWL_CURSOR_RESIZE, event->edges);
} }
static void server_new_xdg_surface(struct wl_listener *listener, void *data) { static void
createnotify(struct wl_listener *listener, void *data)
{
/* This event is raised when wlr_xdg_shell receives a new xdg surface from a /* This event is raised when wlr_xdg_shell receives a new xdg surface from a
* client, either a toplevel (application window) or popup. */ * client, either a toplevel (application window) or popup. */
struct dwl_server *server = struct dwl_server *server =
@ -857,25 +912,27 @@ static void server_new_xdg_surface(struct wl_listener *listener, void *data) {
view->xdg_surface = xdg_surface; view->xdg_surface = xdg_surface;
/* Listen to the various events it can emit */ /* Listen to the various events it can emit */
view->map.notify = xdg_surface_map; view->map.notify = maprequest;
wl_signal_add(&xdg_surface->events.map, &view->map); wl_signal_add(&xdg_surface->events.map, &view->map);
view->unmap.notify = xdg_surface_unmap; view->unmap.notify = unmapnotify;
wl_signal_add(&xdg_surface->events.unmap, &view->unmap); wl_signal_add(&xdg_surface->events.unmap, &view->unmap);
view->destroy.notify = xdg_surface_destroy; view->destroy.notify = destroynotify;
wl_signal_add(&xdg_surface->events.destroy, &view->destroy); wl_signal_add(&xdg_surface->events.destroy, &view->destroy);
/* cotd */ /* cotd */
struct wlr_xdg_toplevel *toplevel = xdg_surface->toplevel; struct wlr_xdg_toplevel *toplevel = xdg_surface->toplevel;
view->request_move.notify = xdg_toplevel_request_move; view->request_move.notify = moverequest;
wl_signal_add(&toplevel->events.request_move, &view->request_move); wl_signal_add(&toplevel->events.request_move, &view->request_move);
view->request_resize.notify = xdg_toplevel_request_resize; view->request_resize.notify = resizerequest;
wl_signal_add(&toplevel->events.request_resize, &view->request_resize); wl_signal_add(&toplevel->events.request_resize, &view->request_resize);
/* Add it to the list of views. */ /* Add it to the list of views. */
wl_list_insert(&server->views, &view->link); wl_list_insert(&server->views, &view->link);
} }
int main(int argc, char *argv[]) { int
main(int argc, char *argv[])
{
wlr_log_init(WLR_DEBUG, NULL); wlr_log_init(WLR_DEBUG, NULL);
char *startup_cmd = NULL; char *startup_cmd = NULL;
pid_t startup_pid = -1; pid_t startup_pid = -1;
@ -930,7 +987,7 @@ int main(int argc, char *argv[]) {
/* Configure a listener to be notified when new outputs are available on the /* Configure a listener to be notified when new outputs are available on the
* backend. */ * backend. */
wl_list_init(&server.outputs); wl_list_init(&server.outputs);
server.new_output.notify = server_new_output; server.new_output.notify = createoutput;
wl_signal_add(&server.backend->events.new_output, &server.new_output); wl_signal_add(&server.backend->events.new_output, &server.new_output);
/* Set up our list of views and the xdg-shell. The xdg-shell is a Wayland /* Set up our list of views and the xdg-shell. The xdg-shell is a Wayland
@ -941,7 +998,7 @@ int main(int argc, char *argv[]) {
*/ */
wl_list_init(&server.views); wl_list_init(&server.views);
server.xdg_shell = wlr_xdg_shell_create(server.wl_display); server.xdg_shell = wlr_xdg_shell_create(server.wl_display);
server.new_xdg_surface.notify = server_new_xdg_surface; server.new_xdg_surface.notify = createnotify;
wl_signal_add(&server.xdg_shell->events.new_surface, wl_signal_add(&server.xdg_shell->events.new_surface,
&server.new_xdg_surface); &server.new_xdg_surface);
@ -971,16 +1028,16 @@ int main(int argc, char *argv[]) {
* *
* And more comments are sprinkled throughout the notify functions above. * And more comments are sprinkled throughout the notify functions above.
*/ */
server.cursor_motion.notify = server_cursor_motion; server.cursor_motion.notify = motionrelative;
wl_signal_add(&server.cursor->events.motion, &server.cursor_motion); wl_signal_add(&server.cursor->events.motion, &server.cursor_motion);
server.cursor_motion_absolute.notify = server_cursor_motion_absolute; server.cursor_motion_absolute.notify = motionabsolute;
wl_signal_add(&server.cursor->events.motion_absolute, wl_signal_add(&server.cursor->events.motion_absolute,
&server.cursor_motion_absolute); &server.cursor_motion_absolute);
server.cursor_button.notify = server_cursor_button; server.cursor_button.notify = buttonpress;
wl_signal_add(&server.cursor->events.button, &server.cursor_button); wl_signal_add(&server.cursor->events.button, &server.cursor_button);
server.cursor_axis.notify = server_cursor_axis; server.cursor_axis.notify = axisnotify;
wl_signal_add(&server.cursor->events.axis, &server.cursor_axis); wl_signal_add(&server.cursor->events.axis, &server.cursor_axis);
server.cursor_frame.notify = server_cursor_frame; server.cursor_frame.notify = cursorframe;
wl_signal_add(&server.cursor->events.frame, &server.cursor_frame); wl_signal_add(&server.cursor->events.frame, &server.cursor_frame);
/* /*
@ -990,10 +1047,10 @@ int main(int argc, char *argv[]) {
* let us know when new input devices are available on the backend. * let us know when new input devices are available on the backend.
*/ */
wl_list_init(&server.keyboards); wl_list_init(&server.keyboards);
server.new_input.notify = server_new_input; server.new_input.notify = inputdevice;
wl_signal_add(&server.backend->events.new_input, &server.new_input); wl_signal_add(&server.backend->events.new_input, &server.new_input);
server.seat = wlr_seat_create(server.wl_display, "seat0"); server.seat = wlr_seat_create(server.wl_display, "seat0");
server.request_cursor.notify = seat_request_cursor; server.request_cursor.notify = setcursor;
wl_signal_add(&server.seat->events.request_set_cursor, wl_signal_add(&server.seat->events.request_set_cursor,
&server.request_cursor); &server.request_cursor);