D425ND7AT3F7QJ3CCSESMVDOC3J5C5P32M5SJDBHECZJXLHNQ2FAC MXCDSKZEMOIO7Q3MC4TD5FZFNMR2QWGPLT4D2X2Z66IZVZGPN5AAC O5JVMDEEKP334BAYMJ6HHXROW4X4WC24JHCYZTKJRQE5UGYXV7YQC 2ZRKX4A24W4WNSLJNPKP3FWB3Y3UCYLWWESTC65P45BQFSJKS4PQC 7B74AT3BXYB7PVW4F6SGQNPMHOU5TEV5TZ54CG6VSQI46XSEKWXQC 7XCGFU3GX4TQXZBOU7GFAQ62EEOTVRNWFYQGI3XULFPSUKDZ2EYAC UPT2JR7QWWO32CYRPGYKT6AAH745ILELEWTY2CHYJB5DBRR7VTZQC static void focusnext(struct dwl_server *, const Arg *);static void movemouse(struct dwl_server *, const Arg *);static void quit(struct dwl_server *, const Arg *);static void resizemouse(struct dwl_server *, const Arg *);static void spawn(struct dwl_server *, const Arg *);
/* function declarations */static void axisnotify(struct wl_listener *listener, void *data);static void buttonpress(struct wl_listener *listener, void *data);static void createkeyboard(struct dwl_server *server,struct wlr_input_device *device);static void createnotify(struct wl_listener *listener, void *data);static void createoutput(struct wl_listener *listener, void *data);static void createpointer(struct dwl_server *server,struct wlr_input_device *device);static void cursorframe(struct wl_listener *listener, void *data);static void destroynotify(struct wl_listener *listener, void *data);static void focus(struct dwl_view *view, struct wlr_surface *surface);static void focusnext(struct dwl_server *server, const Arg *arg);static void handlemove(struct dwl_server *server, uint32_t time);static void handleresize(struct dwl_server *server, uint32_t time);static void inputdevice(struct wl_listener *listener, void *data);static bool keybinding(struct dwl_server *server, uint32_t mods, xkb_keysym_t sym);static void keypress(struct wl_listener *listener, void *data);static void keypressmod(struct wl_listener *listener, void *data);static void maprequest(struct wl_listener *listener, void *data);static void motionabsolute(struct wl_listener *listener, void *data);static void motionnotify(struct dwl_server *server, uint32_t time);static void motionrelative(struct wl_listener *listener, void *data);static void movemouse(struct dwl_server *server, const Arg *arg);static void moverequest(struct wl_listener *listener, void *data);static void moveresize(struct dwl_view *view, enum dwl_cursor_mode mode,uint32_t edges);static void quit(struct dwl_server *server, const Arg *arg);static void render(struct wlr_surface *surface, int sx, int sy, void *data);static void renderoutput(struct wl_listener *listener, void *data);static void resizemouse(struct dwl_server *server, const Arg *arg);static void resizerequest(struct wl_listener *listener, void *data);static void setcursor(struct wl_listener *listener, void *data);static void spawn(struct dwl_server *server, const Arg *arg);static void unmapnotify(struct wl_listener *listener, void *data);static bool xytosurface(struct dwl_view *view, double lx, double ly,struct wlr_surface **surface, double *sx, double *sy);static struct dwl_view * xytoview(struct dwl_server *server, double lx, double ly,struct wlr_surface **surface, double *sx, double *sy);
/* Used to move all of the data necessary to render a surface from the top-level* frame handler to the per-surface render function. */struct render_data {struct wlr_output *output;struct wlr_renderer *renderer;struct dwl_view *view;struct timespec *when;};voidaxisnotify(struct wl_listener *listener, void *data){/* This event is forwarded by the cursor when a pointer emits an axis event,* for example when you move the scroll wheel. */struct dwl_server *server =wl_container_of(listener, server, cursor_axis);struct wlr_event_pointer_axis *event = data;/* Notify the client with pointer focus of the axis event. */wlr_seat_pointer_notify_axis(server->seat,event->time_msec, event->orientation, event->delta,event->delta_discrete, event->source);}voidbuttonpress(struct wl_listener *listener, void *data){/* This event is forwarded by the cursor when a pointer emits a button* event. */struct dwl_server *server =wl_container_of(listener, server, cursor_button);struct wlr_event_pointer_button *event = data;/* Notify the client with pointer focus that a button press has occurred */wlr_seat_pointer_notify_button(server->seat,event->time_msec, event->button, event->state);double sx, sy;struct wlr_seat *seat = server->seat;struct wlr_surface *surface;struct dwl_view *view = xytoview(server,server->cursor->x, server->cursor->y, &surface, &sx, &sy);if (event->state == WLR_BUTTON_RELEASED) {/* If you released any buttons, we exit interactive move/resize mode. */server->cursor_mode = DWL_CURSOR_PASSTHROUGH;} else {/* Focus that client if the button was _pressed_ */focus(view, surface);struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat);uint32_t mods = wlr_keyboard_get_modifiers(keyboard);for (int i = 0; i < LENGTH(buttons); i++) {if (event->button == buttons[i].button &&CLEANMASK(mods) == CLEANMASK(buttons[i].mod) &&buttons[i].func) {buttons[i].func(server, &buttons[i].arg);}}}}voidcreatekeyboard(struct dwl_server *server, struct wlr_input_device *device){struct dwl_keyboard *keyboard =calloc(1, sizeof(struct dwl_keyboard));keyboard->server = server;keyboard->device = device;/* We need to prepare an XKB keymap and assign it to the keyboard. This* assumes the defaults (e.g. layout = "us"). */struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);struct xkb_keymap *keymap = xkb_map_new_from_names(context, &xkb_rules,XKB_KEYMAP_COMPILE_NO_FLAGS);wlr_keyboard_set_keymap(device->keyboard, keymap);xkb_keymap_unref(keymap);xkb_context_unref(context);wlr_keyboard_set_repeat_info(device->keyboard, 25, 600);/* Here we set up listeners for keyboard events. */keyboard->modifiers.notify = keypressmod;wl_signal_add(&device->keyboard->events.modifiers, &keyboard->modifiers);keyboard->key.notify = keypress;wl_signal_add(&device->keyboard->events.key, &keyboard->key);wlr_seat_set_keyboard(server->seat, device);/* And add the keyboard to our list of keyboards */wl_list_insert(&server->keyboards, &keyboard->link);}voidcreatenotify(struct wl_listener *listener, void *data){/* This event is raised when wlr_xdg_shell receives a new xdg surface from a* client, either a toplevel (application window) or popup. */struct dwl_server *server =wl_container_of(listener, server, new_xdg_surface);struct wlr_xdg_surface *xdg_surface = data;if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL) {return;}/* Allocate a dwl_view for this surface */struct dwl_view *view =calloc(1, sizeof(struct dwl_view));view->server = server;view->xdg_surface = xdg_surface;/* Listen to the various events it can emit */view->map.notify = maprequest;wl_signal_add(&xdg_surface->events.map, &view->map);view->unmap.notify = unmapnotify;wl_signal_add(&xdg_surface->events.unmap, &view->unmap);view->destroy.notify = destroynotify;wl_signal_add(&xdg_surface->events.destroy, &view->destroy);/* cotd */struct wlr_xdg_toplevel *toplevel = xdg_surface->toplevel;view->request_move.notify = moverequest;wl_signal_add(&toplevel->events.request_move, &view->request_move);view->request_resize.notify = resizerequest;wl_signal_add(&toplevel->events.request_resize, &view->request_resize);/* Add it to the list of views. */wl_list_insert(&server->views, &view->link);}voidcreateoutput(struct wl_listener *listener, void *data){/* This event is rasied by the backend when a new output (aka a display or* monitor) becomes available. */struct dwl_server *server =wl_container_of(listener, server, new_output);struct wlr_output *wlr_output = data;/* Some backends don't have modes. DRM+KMS does, and we need to set a mode* before we can use the output. The mode is a tuple of (width, height,* refresh rate), and each monitor supports only a specific set of modes. We* just pick the monitor's preferred mode, a more sophisticated compositor* would let the user configure it. */if (!wl_list_empty(&wlr_output->modes)) {struct wlr_output_mode *mode = wlr_output_preferred_mode(wlr_output);wlr_output_set_mode(wlr_output, mode);wlr_output_enable(wlr_output, true);if (!wlr_output_commit(wlr_output)) {return;}}
static void
/* Allocates and configures our state for this output */struct dwl_output *output =calloc(1, sizeof(struct dwl_output));output->wlr_output = wlr_output;output->server = server;/* Sets up a listener for the frame notify event. */output->frame.notify = renderoutput;wl_signal_add(&wlr_output->events.frame, &output->frame);wl_list_insert(&server->outputs, &output->link);/* Adds this to the output layout. The add_auto function arranges outputs* from left-to-right in the order they appear. A more sophisticated* compositor would let the user configure the arrangement of outputs in the* layout. */wlr_output_layout_add_auto(server->output_layout, wlr_output);/* Creating the global adds a wl_output global to the display, which Wayland* clients can see to find out information about the output (such as* DPI, scale factor, manufacturer, etc). */wlr_output_create_global(wlr_output);}voidcreatepointer(struct dwl_server *server, struct wlr_input_device *device){/* 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* opportunity to do libinput configuration on the device to set* acceleration, etc. */wlr_cursor_attach_input_device(server->cursor, device);}voidcursorframe(struct wl_listener *listener, void *data){/* 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. */struct dwl_server *server =wl_container_of(listener, server, cursor_frame);/* Notify the client with pointer focus of the frame event. */wlr_seat_pointer_notify_frame(server->seat);}voiddestroynotify(struct wl_listener *listener, void *data){/* Called when the surface is destroyed and should never be shown again. */struct dwl_view *view = wl_container_of(listener, view, destroy);wl_list_remove(&view->link);free(view);}void
static voidkeypressmod(struct wl_listener *listener, void *data){/* This event is raised when a modifier key, such as shift or alt, is* pressed. We simply communicate this to the client. */struct dwl_keyboard *keyboard =wl_container_of(listener, keyboard, modifiers);/** A seat can only have one keyboard, but this is a limitation of the* Wayland protocol - not wlroots. We assign all connected keyboards to the* same seat. You can swap out the underlying wlr_keyboard like this and* wlr_seat handles this transparently.*/wlr_seat_set_keyboard(keyboard->server->seat, keyboard->device);/* Send modifiers to the client. */wlr_seat_keyboard_notify_modifiers(keyboard->server->seat,&keyboard->device->keyboard->modifiers);}static voidquit(struct dwl_server *server, const Arg *arg){wl_display_terminate(server->wl_display);}static voidspawn(struct dwl_server *server, const Arg *arg){if (fork() == 0) {setsid();execvp(((char **)arg->v)[0], (char **)arg->v);fprintf(stderr, "dwl: execvp %s", ((char **)arg->v)[0]);perror(" failed");exit(EXIT_FAILURE);}}static void
void
static bool
voidhandleresize(struct dwl_server *server, uint32_t time){/** 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.*/struct dwl_view *view = server->grabbed_view;double dx = server->cursor->x - server->grab_x;double dy = server->cursor->y - server->grab_y;double x = view->x;double y = view->y;int width = server->grab_width;int height = server->grab_height;if (server->resize_edges & WLR_EDGE_TOP) {y = server->grab_y + dy;height -= dy;if (height < 1) {y += height;}} else if (server->resize_edges & WLR_EDGE_BOTTOM) {height += dy;}if (server->resize_edges & WLR_EDGE_LEFT) {x = server->grab_x + dx;width -= dx;if (width < 1) {x += width;}} else if (server->resize_edges & WLR_EDGE_RIGHT) {width += dx;}view->x = x;view->y = y;wlr_xdg_toplevel_set_size(view->xdg_surface, width, height);}voidinputdevice(struct wl_listener *listener, void *data){/* This event is raised by the backend when a new input device becomes* available. */struct dwl_server *server =wl_container_of(listener, server, new_input);struct wlr_input_device *device = data;switch (device->type) {case WLR_INPUT_DEVICE_KEYBOARD:createkeyboard(server, device);break;case WLR_INPUT_DEVICE_POINTER:createpointer(server, device);break;default:break;}/* We need to let the wlr_seat know what our capabilities are, which is* communiciated to the client. In dwl we always have a cursor, even if* there are no pointer devices, so we always include that capability. */uint32_t caps = WL_SEAT_CAPABILITY_POINTER;if (!wl_list_empty(&server->keyboards)) {caps |= WL_SEAT_CAPABILITY_KEYBOARD;}wlr_seat_set_capabilities(server->seat, caps);}bool
calloc(1, sizeof(struct dwl_keyboard));keyboard->server = server;keyboard->device = device;/* We need to prepare an XKB keymap and assign it to the keyboard. This* assumes the defaults (e.g. layout = "us"). */struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);struct xkb_keymap *keymap = xkb_map_new_from_names(context, &xkb_rules,XKB_KEYMAP_COMPILE_NO_FLAGS);wlr_keyboard_set_keymap(device->keyboard, keymap);xkb_keymap_unref(keymap);xkb_context_unref(context);wlr_keyboard_set_repeat_info(device->keyboard, 25, 600);/* Here we set up listeners for keyboard events. */keyboard->modifiers.notify = keypressmod;wl_signal_add(&device->keyboard->events.modifiers, &keyboard->modifiers);keyboard->key.notify = keypress;wl_signal_add(&device->keyboard->events.key, &keyboard->key);wlr_seat_set_keyboard(server->seat, device);/* And add the keyboard to our list of keyboards */wl_list_insert(&server->keyboards, &keyboard->link);}static voidcreatepointer(struct dwl_server *server, struct wlr_input_device *device){/* 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* opportunity to do libinput configuration on the device to set* acceleration, etc. */wlr_cursor_attach_input_device(server->cursor, device);}static voidinputdevice(struct wl_listener *listener, void *data){/* This event is raised by the backend when a new input device becomes* available. */struct dwl_server *server =wl_container_of(listener, server, new_input);struct wlr_input_device *device = data;switch (device->type) {case WLR_INPUT_DEVICE_KEYBOARD:createkeyboard(server, device);break;case WLR_INPUT_DEVICE_POINTER:createpointer(server, device);break;default:break;}/* We need to let the wlr_seat know what our capabilities are, which is* communiciated to the client. In dwl we always have a cursor, even if* there are no pointer devices, so we always include that capability. */uint32_t caps = WL_SEAT_CAPABILITY_POINTER;if (!wl_list_empty(&server->keyboards)) {caps |= WL_SEAT_CAPABILITY_KEYBOARD;}wlr_seat_set_capabilities(server->seat, caps);}static voidsetcursor(struct wl_listener *listener, void *data){struct dwl_server *server = wl_container_of(listener, server, request_cursor);/* This event is rasied by the seat when a client provides a cursor image */struct wlr_seat_pointer_request_set_cursor_event *event = data;struct wlr_seat_client *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. */wlr_cursor_set_surface(server->cursor, event->surface,event->hotspot_x, event->hotspot_y);}}static boolxytosurface(struct dwl_view *view, double lx, double ly,struct wlr_surface **surface, double *sx, double *sy){
wl_container_of(listener, keyboard, modifiers);
* 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* coordinates lx and ly (in output Layout Coordinates). If so, it sets the* surface pointer to that wlr_surface and the sx and sy coordinates to the* coordinates relative to that surface's top-left corner.
* A seat can only have one keyboard, but this is a limitation of the* Wayland protocol - not wlroots. We assign all connected keyboards to the* same seat. You can swap out the underlying wlr_keyboard like this and* wlr_seat handles this transparently.
double view_sx = lx - view->x;double view_sy = ly - view->y;struct wlr_surface_state *state = &view->xdg_surface->surface->current;double _sx, _sy;struct wlr_surface *_surface = NULL;_surface = wlr_xdg_surface_surface_at(view->xdg_surface, view_sx, view_sy, &_sx, &_sy);if (_surface != NULL) {*sx = _sx;*sy = _sy;*surface = _surface;return true;}return false;
wlr_seat_set_keyboard(keyboard->server->seat, keyboard->device);/* Send modifiers to the client. */wlr_seat_keyboard_notify_modifiers(keyboard->server->seat,&keyboard->device->keyboard->modifiers);
/* 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. */struct dwl_view *view;wl_list_for_each(view, &server->views, link) {if (xytosurface(view, lx, ly, surface, sx, sy)) {return view;}}return NULL;}static voidhandlemove(struct dwl_server *server, uint32_t time){/* Move the grabbed view to the new position. */server->grabbed_view->x = server->cursor->x - server->grab_x;server->grabbed_view->y = server->cursor->y - server->grab_y;
/* Called when the surface is mapped, or ready to display on-screen. */struct dwl_view *view = wl_container_of(listener, view, map);view->mapped = true;focus(view, view->xdg_surface->surface);
/** 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.*/struct dwl_view *view = server->grabbed_view;double dx = server->cursor->x - server->grab_x;double dy = server->cursor->y - server->grab_y;double x = view->x;double y = view->y;int width = server->grab_width;int height = server->grab_height;if (server->resize_edges & WLR_EDGE_TOP) {y = server->grab_y + dy;height -= dy;if (height < 1) {y += height;}} else if (server->resize_edges & WLR_EDGE_BOTTOM) {height += dy;}if (server->resize_edges & WLR_EDGE_LEFT) {x = server->grab_x + dx;width -= dx;if (width < 1) {x += width;}} else if (server->resize_edges & WLR_EDGE_RIGHT) {width += dx;}view->x = x;view->y = y;wlr_xdg_toplevel_set_size(view->xdg_surface, width, height);
/* 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. */struct dwl_server *server =wl_container_of(listener, server, cursor_motion_absolute);struct wlr_event_pointer_motion_absolute *event = data;wlr_cursor_warp_absolute(server->cursor, event->device, event->x, event->y);motionnotify(server, event->time_msec);
motionnotify(server, event->time_msec);}static voidmotionabsolute(struct wl_listener *listener, void *data){/* 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. */struct dwl_server *server =wl_container_of(listener, server, cursor_motion_absolute);struct wlr_event_pointer_motion_absolute *event = data;wlr_cursor_warp_absolute(server->cursor, event->device, event->x, event->y);
/* This event is forwarded by the cursor when a pointer emits a button* event. */struct dwl_server *server =wl_container_of(listener, server, cursor_button);struct wlr_event_pointer_button *event = data;/* Notify the client with pointer focus that a button press has occurred */wlr_seat_pointer_notify_button(server->seat,event->time_msec, event->button, event->state);
if (event->state == WLR_BUTTON_RELEASED) {/* If you released any buttons, we exit interactive move/resize mode. */server->cursor_mode = DWL_CURSOR_PASSTHROUGH;} else {/* Focus that client if the button was _pressed_ */focus(view, surface);struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat);uint32_t mods = wlr_keyboard_get_modifiers(keyboard);for (int i = 0; i < LENGTH(buttons); i++) {if (event->button == buttons[i].button &&CLEANMASK(mods) == CLEANMASK(buttons[i].mod) &&buttons[i].func) {buttons[i].func(server, &buttons[i].arg);}}
if (!view) {return;
/* This event is forwarded by the cursor when a pointer emits an axis event,* for example when you move the scroll wheel. */struct dwl_server *server =wl_container_of(listener, server, cursor_axis);struct wlr_event_pointer_axis *event = data;/* Notify the client with pointer focus of the axis event. */wlr_seat_pointer_notify_axis(server->seat,event->time_msec, event->orientation, event->delta,event->delta_discrete, event->source);
/* This event is raised when a client would like to begin an interactive* move, typically because the user clicked on their client-side* decorations. Note that a more sophisticated compositor should check the* provied serial against a list of button press serials sent to this* client, to prevent the client from requesting this whenever they want. */struct dwl_view *view = wl_container_of(listener, view, request_move);moveresize(view, DWL_CURSOR_MOVE, 0);
/* 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. */struct dwl_server *server =wl_container_of(listener, server, cursor_frame);/* Notify the client with pointer focus of the frame event. */wlr_seat_pointer_notify_frame(server->seat);
/* This function sets up an interactive move or resize operation, where the* compositor stops propagating pointer events to clients and instead* consumes them itself, to move or resize windows. */struct dwl_server *server = view->server;struct wlr_surface *focused_surface =server->seat->pointer_state.focused_surface;if (view->xdg_surface->surface != focused_surface) {/* Deny move/resize requests from unfocused clients. */return;}server->grabbed_view = view;server->cursor_mode = mode;struct wlr_box geo_box;wlr_xdg_surface_get_geometry(view->xdg_surface, &geo_box);if (mode == DWL_CURSOR_MOVE) {server->grab_x = server->cursor->x - view->x;server->grab_y = server->cursor->y - view->y;} else {server->grab_x = server->cursor->x + geo_box.x;server->grab_y = server->cursor->y + geo_box.y;}server->grab_width = geo_box.width;server->grab_height = geo_box.height;server->resize_edges = edges;
/* Used to move all of the data necessary to render a surface from the top-level* frame handler to the per-surface render function. */struct render_data {struct wlr_output *output;struct wlr_renderer *renderer;struct dwl_view *view;struct timespec *when;};
voidquit(struct dwl_server *server, const Arg *arg){wl_display_terminate(server->wl_display);}
static voidcreateoutput(struct wl_listener *listener, void *data){/* This event is rasied by the backend when a new output (aka a display or* monitor) becomes available. */struct dwl_server *server =wl_container_of(listener, server, new_output);struct wlr_output *wlr_output = data;/* Some backends don't have modes. DRM+KMS does, and we need to set a mode* before we can use the output. The mode is a tuple of (width, height,* refresh rate), and each monitor supports only a specific set of modes. We* just pick the monitor's preferred mode, a more sophisticated compositor* would let the user configure it. */if (!wl_list_empty(&wlr_output->modes)) {struct wlr_output_mode *mode = wlr_output_preferred_mode(wlr_output);wlr_output_set_mode(wlr_output, mode);wlr_output_enable(wlr_output, true);if (!wlr_output_commit(wlr_output)) {return;}}/* Allocates and configures our state for this output */struct dwl_output *output =calloc(1, sizeof(struct dwl_output));output->wlr_output = wlr_output;output->server = server;/* Sets up a listener for the frame notify event. */output->frame.notify = renderoutput;wl_signal_add(&wlr_output->events.frame, &output->frame);wl_list_insert(&server->outputs, &output->link);/* Adds this to the output layout. The add_auto function arranges outputs* from left-to-right in the order they appear. A more sophisticated* compositor would let the user configure the arrangement of outputs in the* layout. */wlr_output_layout_add_auto(server->output_layout, wlr_output);/* Creating the global adds a wl_output global to the display, which Wayland* clients can see to find out information about the output (such as* DPI, scale factor, manufacturer, etc). */wlr_output_create_global(wlr_output);}static voidmaprequest(struct wl_listener *listener, void *data){/* Called when the surface is mapped, or ready to display on-screen. */struct dwl_view *view = wl_container_of(listener, view, map);view->mapped = true;focus(view, view->xdg_surface->surface);}static voidunmapnotify(struct wl_listener *listener, void *data){/* Called when the surface is unmapped, and should no longer be shown. */struct dwl_view *view = wl_container_of(listener, view, unmap);view->mapped = false;}static voiddestroynotify(struct wl_listener *listener, void *data){/* Called when the surface is destroyed and should never be shown again. */struct dwl_view *view = wl_container_of(listener, view, destroy);wl_list_remove(&view->link);free(view);}static voidmoveresize(struct dwl_view *view,enum dwl_cursor_mode mode, uint32_t edges){/* This function sets up an interactive move or resize operation, where the* compositor stops propagating pointer events to clients and instead* consumes them itself, to move or resize windows. */struct dwl_server *server = view->server;struct wlr_surface *focused_surface =server->seat->pointer_state.focused_surface;if (view->xdg_surface->surface != focused_surface) {/* Deny move/resize requests from unfocused clients. */return;}server->grabbed_view = view;server->cursor_mode = mode;struct wlr_box geo_box;wlr_xdg_surface_get_geometry(view->xdg_surface, &geo_box);if (mode == DWL_CURSOR_MOVE) {server->grab_x = server->cursor->x - view->x;server->grab_y = server->cursor->y - view->y;} else {server->grab_x = server->cursor->x + geo_box.x;server->grab_y = server->cursor->y + geo_box.y;}server->grab_width = geo_box.width;server->grab_height = geo_box.height;server->resize_edges = edges;}static voidmovemouse(struct dwl_server *server, const Arg *arg){double sx, sy;struct wlr_surface *surface;struct dwl_view *view = xytoview(server,server->cursor->x, server->cursor->y, &surface, &sx, &sy);if (!view) {return;}moveresize(view, DWL_CURSOR_MOVE, 0);}static void
void
static voidmoverequest(struct wl_listener *listener, void *data){/* This event is raised when a client would like to begin an interactive* move, typically because the user clicked on their client-side* decorations. Note that a more sophisticated compositor should check the* provied serial against a list of button press serials sent to this* client, to prevent the client from requesting this whenever they want. */struct dwl_view *view = wl_container_of(listener, view, request_move);moveresize(view, DWL_CURSOR_MOVE, 0);}static void
void
}voidsetcursor(struct wl_listener *listener, void *data){struct dwl_server *server = wl_container_of(listener, server, request_cursor);/* This event is rasied by the seat when a client provides a cursor image */struct wlr_seat_pointer_request_set_cursor_event *event = data;struct wlr_seat_client *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. */wlr_cursor_set_surface(server->cursor, event->surface,event->hotspot_x, event->hotspot_y);}
/* This event is raised when wlr_xdg_shell receives a new xdg surface from a* client, either a toplevel (application window) or popup. */struct dwl_server *server =wl_container_of(listener, server, new_xdg_surface);struct wlr_xdg_surface *xdg_surface = data;if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL) {return;
if (fork() == 0) {setsid();execvp(((char **)arg->v)[0], (char **)arg->v);fprintf(stderr, "dwl: execvp %s", ((char **)arg->v)[0]);perror(" failed");exit(EXIT_FAILURE);
/* Allocate a dwl_view for this surface */struct dwl_view *view =calloc(1, sizeof(struct dwl_view));view->server = server;view->xdg_surface = xdg_surface;
boolxytosurface(struct dwl_view *view, double lx, double ly,struct wlr_surface **surface, double *sx, double *sy){/** 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* coordinates lx and ly (in output Layout Coordinates). If so, it sets the* surface pointer to that wlr_surface and the sx and sy coordinates to the* coordinates relative to that surface's top-left corner.*/double view_sx = lx - view->x;double view_sy = ly - view->y;
/* Listen to the various events it can emit */view->map.notify = maprequest;wl_signal_add(&xdg_surface->events.map, &view->map);view->unmap.notify = unmapnotify;wl_signal_add(&xdg_surface->events.unmap, &view->unmap);view->destroy.notify = destroynotify;wl_signal_add(&xdg_surface->events.destroy, &view->destroy);
struct wlr_surface_state *state = &view->xdg_surface->surface->current;
/* cotd */struct wlr_xdg_toplevel *toplevel = xdg_surface->toplevel;view->request_move.notify = moverequest;wl_signal_add(&toplevel->events.request_move, &view->request_move);view->request_resize.notify = resizerequest;wl_signal_add(&toplevel->events.request_resize, &view->request_resize);
double _sx, _sy;struct wlr_surface *_surface = NULL;_surface = wlr_xdg_surface_surface_at(view->xdg_surface, view_sx, view_sy, &_sx, &_sy);
/* Add it to the list of views. */wl_list_insert(&server->views, &view->link);
if (_surface != NULL) {*sx = _sx;*sy = _sy;*surface = _surface;return true;}return false;}struct dwl_view *xytoview(struct dwl_server *server, double lx, double ly,struct wlr_surface **surface, double *sx, double *sy){/* 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. */struct dwl_view *view;wl_list_for_each(view, &server->views, link) {if (xytosurface(view, lx, ly, surface, sx, sy)) {return view;}}return NULL;