adopt a bit more dwm-like terseness
Devin J. Pohly
parent
66bf55930f
commit
a5a7445dee
135
dwl.c
135
dwl.c
|
|
@ -171,9 +171,9 @@ static Client *xytoclient(double x, double y,
|
|||
static Monitor *xytomon(double x, double y);
|
||||
|
||||
/* variables */
|
||||
static struct wl_display *wl_display;
|
||||
static struct wl_display *dpy;
|
||||
static struct wlr_backend *backend;
|
||||
static struct wlr_renderer *renderer;
|
||||
static struct wlr_renderer *drw;
|
||||
|
||||
static struct wlr_xdg_shell *xdg_shell;
|
||||
static struct wl_listener new_xdg_surface;
|
||||
|
|
@ -258,8 +258,8 @@ buttonpress(struct wl_listener *listener, void *data)
|
|||
void
|
||||
createkeyboard(struct wlr_input_device *device)
|
||||
{
|
||||
Keyboard *keyboard = calloc(1, sizeof(*keyboard));
|
||||
keyboard->device = device;
|
||||
Keyboard *kb = calloc(1, sizeof(*kb));
|
||||
kb->device = device;
|
||||
|
||||
/* Prepare an XKB keymap and assign it to the keyboard. */
|
||||
struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
|
||||
|
|
@ -272,15 +272,15 @@ createkeyboard(struct wlr_input_device *device)
|
|||
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);
|
||||
kb->modifiers.notify = keypressmod;
|
||||
wl_signal_add(&device->keyboard->events.modifiers, &kb->modifiers);
|
||||
kb->key.notify = keypress;
|
||||
wl_signal_add(&device->keyboard->events.key, &kb->key);
|
||||
|
||||
wlr_seat_set_keyboard(seat, device);
|
||||
|
||||
/* And add the keyboard to our list of keyboards */
|
||||
wl_list_insert(&keyboards, &keyboard->link);
|
||||
wl_list_insert(&keyboards, &kb->link);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -299,17 +299,16 @@ createmon(struct wl_listener *listener, void *data)
|
|||
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)) {
|
||||
if (!wlr_output_commit(wlr_output))
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/* Allocates and configures monitor state using configured rules */
|
||||
Monitor *m = calloc(1, sizeof(*m));
|
||||
m->wlr_output = wlr_output;
|
||||
m->tagset[0] = m->tagset[1] = 1;
|
||||
int i;
|
||||
for (i = 0; i < LENGTH(monrules); i++) {
|
||||
for (i = 0; i < LENGTH(monrules); i++)
|
||||
if (!monrules[i].name ||
|
||||
!strcmp(wlr_output->name, monrules[i].name)) {
|
||||
m->mfact = monrules[i].mfact;
|
||||
|
|
@ -319,7 +318,6 @@ createmon(struct wl_listener *listener, void *data)
|
|||
m->lt[0] = m->lt[1] = monrules[i].lt;
|
||||
break;
|
||||
}
|
||||
}
|
||||
/* Sets up a listener for the frame notify event. */
|
||||
m->frame.notify = rendermon;
|
||||
wl_signal_add(&wlr_output->events.frame, &m->frame);
|
||||
|
|
@ -343,9 +341,8 @@ createnotify(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 wlr_xdg_surface *xdg_surface = data;
|
||||
if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL) {
|
||||
if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL)
|
||||
return;
|
||||
}
|
||||
|
||||
/* Allocate a Client for this surface */
|
||||
Client *c = calloc(1, sizeof(*c));
|
||||
|
|
@ -423,10 +420,9 @@ focus(Client *c, struct wlr_surface *surface)
|
|||
/* XXX Need to understand xdg toplevel/popups to know if there's more
|
||||
* simplification that can be done in this function */
|
||||
struct wlr_surface *prev_surface = seat->keyboard_state.focused_surface;
|
||||
if (prev_surface == surface) {
|
||||
/* Don't re-focus an already focused surface. */
|
||||
if (prev_surface == surface)
|
||||
return;
|
||||
}
|
||||
if (prev_surface) {
|
||||
/*
|
||||
* Deactivate the previously focused surface. This lets the
|
||||
|
|
@ -523,9 +519,8 @@ inputdevice(struct wl_listener *listener, void *data)
|
|||
* 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(&keyboards)) {
|
||||
if (!wl_list_empty(&keyboards))
|
||||
caps |= WL_SEAT_CAPABILITY_KEYBOARD;
|
||||
}
|
||||
wlr_seat_set_capabilities(seat, caps);
|
||||
}
|
||||
|
||||
|
|
@ -538,14 +533,13 @@ keybinding(uint32_t mods, xkb_keysym_t sym)
|
|||
* processing.
|
||||
*/
|
||||
bool handled = false;
|
||||
for (int i = 0; i < LENGTH(keys); i++) {
|
||||
for (int i = 0; i < LENGTH(keys); i++)
|
||||
if (sym == keys[i].keysym &&
|
||||
CLEANMASK(mods) == CLEANMASK(keys[i].mod) &&
|
||||
keys[i].func) {
|
||||
keys[i].func(&keys[i].arg);
|
||||
handled = true;
|
||||
}
|
||||
}
|
||||
return handled;
|
||||
}
|
||||
|
||||
|
|
@ -553,8 +547,7 @@ void
|
|||
keypress(struct wl_listener *listener, void *data)
|
||||
{
|
||||
/* This event is raised when a key is pressed or released. */
|
||||
Keyboard *keyboard =
|
||||
wl_container_of(listener, keyboard, key);
|
||||
Keyboard *kb = wl_container_of(listener, kb, key);
|
||||
struct wlr_event_keyboard_key *event = data;
|
||||
|
||||
/* Translate libinput keycode -> xkbcommon */
|
||||
|
|
@ -562,20 +555,18 @@ keypress(struct wl_listener *listener, void *data)
|
|||
/* Get a list of keysyms based on the keymap for this keyboard */
|
||||
const xkb_keysym_t *syms;
|
||||
int nsyms = xkb_state_key_get_syms(
|
||||
keyboard->device->keyboard->xkb_state, keycode, &syms);
|
||||
kb->device->keyboard->xkb_state, keycode, &syms);
|
||||
|
||||
bool handled = false;
|
||||
uint32_t mods = wlr_keyboard_get_modifiers(keyboard->device->keyboard);
|
||||
if (event->state == WLR_KEY_PRESSED) {
|
||||
uint32_t mods = wlr_keyboard_get_modifiers(kb->device->keyboard);
|
||||
/* On _press_, attempt to process a compositor keybinding. */
|
||||
for (int i = 0; i < nsyms; i++) {
|
||||
if (event->state == WLR_KEY_PRESSED)
|
||||
for (int i = 0; i < nsyms; i++)
|
||||
handled = keybinding(mods, syms[i]) || handled;
|
||||
}
|
||||
}
|
||||
|
||||
if (!handled) {
|
||||
/* Otherwise, we pass it along to the client. */
|
||||
wlr_seat_set_keyboard(seat, keyboard->device);
|
||||
wlr_seat_set_keyboard(seat, kb->device);
|
||||
wlr_seat_keyboard_notify_key(seat, event->time_msec,
|
||||
event->keycode, event->state);
|
||||
}
|
||||
|
|
@ -586,17 +577,17 @@ keypressmod(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. */
|
||||
Keyboard *keyboard = wl_container_of(listener, keyboard, modifiers);
|
||||
Keyboard *kb = wl_container_of(listener, kb, 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(seat, keyboard->device);
|
||||
wlr_seat_set_keyboard(seat, kb->device);
|
||||
/* Send modifiers to the client. */
|
||||
wlr_seat_keyboard_notify_modifiers(seat,
|
||||
&keyboard->device->keyboard->modifiers);
|
||||
&kb->device->keyboard->modifiers);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -655,13 +646,12 @@ motionnotify(uint32_t time)
|
|||
double sx, sy;
|
||||
struct wlr_surface *surface = NULL;
|
||||
Client *c = xytoclient(cursor->x, cursor->y, &surface, &sx, &sy);
|
||||
if (!c) {
|
||||
/* If there's no client 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 clients. */
|
||||
if (!c)
|
||||
wlr_xcursor_manager_set_cursor_image(
|
||||
cursor_mgr, "left_ptr", cursor);
|
||||
}
|
||||
if (!surface) {
|
||||
/* Clear pointer focus so future button events and such are not sent to
|
||||
* the last client to have the cursor over it. */
|
||||
|
|
@ -712,11 +702,9 @@ movemouse(const Arg *arg)
|
|||
{
|
||||
double sx, sy;
|
||||
struct wlr_surface *surface;
|
||||
Client *c = xytoclient(cursor->x, cursor->y,
|
||||
&surface, &sx, &sy);
|
||||
if (!c) {
|
||||
Client *c = xytoclient(cursor->x, cursor->y, &surface, &sx, &sy);
|
||||
if (!c)
|
||||
return;
|
||||
}
|
||||
|
||||
/* Prepare for moving client in motionnotify */
|
||||
grabc = c;
|
||||
|
|
@ -731,7 +719,7 @@ movemouse(const Arg *arg)
|
|||
void
|
||||
quit(const Arg *arg)
|
||||
{
|
||||
wl_display_terminate(wl_display);
|
||||
wl_display_terminate(dpy);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -760,9 +748,8 @@ render(struct wlr_surface *surface, int sx, int sy, void *data)
|
|||
* could have sent a pixel buffer which we copied to the GPU, or a few other
|
||||
* means. You don't have to worry about this, wlroots takes care of it. */
|
||||
struct wlr_texture *texture = wlr_surface_get_texture(surface);
|
||||
if (texture == NULL) {
|
||||
if (!texture)
|
||||
return;
|
||||
}
|
||||
|
||||
/* The client has a position in layout coordinates. If you have two displays,
|
||||
* one next to the other, both 1080p, a client on the rightmost display might
|
||||
|
|
@ -801,7 +788,7 @@ render(struct wlr_surface *surface, int sx, int sy, void *data)
|
|||
|
||||
/* This takes our matrix, the texture, and an alpha, and performs the actual
|
||||
* rendering on the GPU. */
|
||||
wlr_render_texture_with_matrix(renderer, texture, matrix, 1);
|
||||
wlr_render_texture_with_matrix(drw, texture, matrix, 1);
|
||||
|
||||
/* This lets the client know that we've displayed that frame and it can
|
||||
* prepare another one now if it likes. */
|
||||
|
|
@ -819,9 +806,8 @@ rendermon(struct wl_listener *listener, void *data)
|
|||
clock_gettime(CLOCK_MONOTONIC, &now);
|
||||
|
||||
/* wlr_output_attach_render makes the OpenGL context current. */
|
||||
if (!wlr_output_attach_render(m->wlr_output, NULL)) {
|
||||
if (!wlr_output_attach_render(m->wlr_output, NULL))
|
||||
return;
|
||||
}
|
||||
/* Get effective monitor geometry and window area */
|
||||
m->geom = wlr_output_layout_get_box(output_layout, m->wlr_output);
|
||||
m->wx = m->geom->x;
|
||||
|
|
@ -832,8 +818,8 @@ rendermon(struct wl_listener *listener, void *data)
|
|||
arrange(m);
|
||||
|
||||
/* Begin the renderer (calls glViewport and some other GL sanity checks) */
|
||||
wlr_renderer_begin(renderer, m->wlr_output->width, m->wlr_output->height);
|
||||
wlr_renderer_clear(renderer, rootcolor);
|
||||
wlr_renderer_begin(drw, m->wlr_output->width, m->wlr_output->height);
|
||||
wlr_renderer_clear(drw, rootcolor);
|
||||
|
||||
/* Each subsequent window we render is rendered on top of the last. Because
|
||||
* our client list is ordered front-to-back, we iterate over it backwards. */
|
||||
|
|
@ -866,7 +852,7 @@ rendermon(struct wl_listener *listener, void *data)
|
|||
|
||||
/* Conclude rendering and swap the buffers, showing the final frame
|
||||
* on-screen. */
|
||||
wlr_renderer_end(renderer);
|
||||
wlr_renderer_end(drw);
|
||||
wlr_output_commit(m->wlr_output);
|
||||
}
|
||||
|
||||
|
|
@ -883,11 +869,10 @@ resizemouse(const Arg *arg)
|
|||
{
|
||||
double sx, sy;
|
||||
struct wlr_surface *surface;
|
||||
Client *c = xytoclient(cursor->x, cursor->y,
|
||||
&surface, &sx, &sy);
|
||||
if (!c) {
|
||||
Client *c = xytoclient(cursor->x, cursor->y, &surface, &sx, &sy);
|
||||
if (!c)
|
||||
return;
|
||||
}
|
||||
|
||||
struct wlr_box sbox;
|
||||
wlr_xdg_surface_get_geometry(c->xdg_surface, &sbox);
|
||||
/* Doesn't work for X11 output - the next absolute motion event
|
||||
|
|
@ -910,7 +895,7 @@ run(char *startup_cmd)
|
|||
pid_t startup_pid = -1;
|
||||
|
||||
/* Add a Unix socket to the Wayland display. */
|
||||
const char *socket = wl_display_add_socket_auto(wl_display);
|
||||
const char *socket = wl_display_add_socket_auto(dpy);
|
||||
if (!socket) {
|
||||
wlr_backend_destroy(backend);
|
||||
exit(1);
|
||||
|
|
@ -920,7 +905,7 @@ run(char *startup_cmd)
|
|||
* master, etc */
|
||||
if (!wlr_backend_start(backend)) {
|
||||
wlr_backend_destroy(backend);
|
||||
wl_display_destroy(wl_display);
|
||||
wl_display_destroy(dpy);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
|
@ -940,13 +925,13 @@ run(char *startup_cmd)
|
|||
startup_pid = fork();
|
||||
if (startup_pid < 0) {
|
||||
perror("startup: fork");
|
||||
wl_display_destroy(wl_display);
|
||||
wl_display_destroy(dpy);
|
||||
exit(1);
|
||||
}
|
||||
if (startup_pid == 0) {
|
||||
execl("/bin/sh", "/bin/sh", "-c", startup_cmd, (void *)NULL);
|
||||
perror("startup: execl");
|
||||
wl_display_destroy(wl_display);
|
||||
wl_display_destroy(dpy);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
|
@ -956,7 +941,7 @@ run(char *startup_cmd)
|
|||
* frame events at the refresh rate, and so on. */
|
||||
wlr_log(WLR_INFO, "Running Wayland compositor on WAYLAND_DISPLAY=%s",
|
||||
socket);
|
||||
wl_display_run(wl_display);
|
||||
wl_display_run(dpy);
|
||||
|
||||
if (startup_cmd) {
|
||||
kill(startup_pid, SIGTERM);
|
||||
|
|
@ -990,18 +975,14 @@ setcursor(struct wl_listener *listener, void *data)
|
|||
{
|
||||
/* This event is raised 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 =
|
||||
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. */
|
||||
* actually has pointer focus first. If so, 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. */
|
||||
if (event->seat_client == seat->pointer_state.focused_client)
|
||||
wlr_cursor_set_surface(cursor, event->surface,
|
||||
event->hotspot_x, event->hotspot_y);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -1039,20 +1020,20 @@ setup(void)
|
|||
* 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). */
|
||||
backend = wlr_backend_autocreate(wl_display, NULL);
|
||||
backend = wlr_backend_autocreate(dpy, NULL);
|
||||
|
||||
/* If we don't provide a renderer, autocreate makes a GLES2 renderer for us.
|
||||
* The renderer is responsible for defining the various pixel formats it
|
||||
* supports for shared memory, this configures that for clients. */
|
||||
renderer = wlr_backend_get_renderer(backend);
|
||||
wlr_renderer_init_wl_display(renderer, wl_display);
|
||||
drw = wlr_backend_get_renderer(backend);
|
||||
wlr_renderer_init_wl_display(drw, dpy);
|
||||
|
||||
/* This creates some hands-off wlroots interfaces. The compositor is
|
||||
* necessary for clients to allocate surfaces and the data device manager
|
||||
* handles the clipboard. Each of these wlroots interfaces has room for you
|
||||
* to dig your fingers in and play with their behavior if you want. */
|
||||
wlr_compositor_create(wl_display, renderer);
|
||||
wlr_data_device_manager_create(wl_display);
|
||||
wlr_compositor_create(dpy, drw);
|
||||
wlr_data_device_manager_create(dpy);
|
||||
|
||||
/* Creates an output layout, which a wlroots utility for working with an
|
||||
* arrangement of screens in a physical layout. */
|
||||
|
|
@ -1072,7 +1053,7 @@ setup(void)
|
|||
*/
|
||||
wl_list_init(&clients);
|
||||
wl_list_init(&fstack);
|
||||
xdg_shell = wlr_xdg_shell_create(wl_display);
|
||||
xdg_shell = wlr_xdg_shell_create(dpy);
|
||||
new_xdg_surface.notify = createnotify;
|
||||
wl_signal_add(&xdg_shell->events.new_surface,
|
||||
&new_xdg_surface);
|
||||
|
|
@ -1123,7 +1104,7 @@ setup(void)
|
|||
wl_list_init(&keyboards);
|
||||
new_input.notify = inputdevice;
|
||||
wl_signal_add(&backend->events.new_input, &new_input);
|
||||
seat = wlr_seat_create(wl_display, "seat0");
|
||||
seat = wlr_seat_create(dpy, "seat0");
|
||||
request_cursor.notify = setcursor;
|
||||
wl_signal_add(&seat->events.request_set_cursor,
|
||||
&request_cursor);
|
||||
|
|
@ -1279,7 +1260,7 @@ xytoclient(double x, double y,
|
|||
_surface = wlr_xdg_surface_surface_at(c->xdg_surface,
|
||||
x - c->x, y - c->y, &_sx, &_sy);
|
||||
|
||||
if (_surface != NULL) {
|
||||
if (_surface) {
|
||||
*sx = _sx;
|
||||
*sy = _sy;
|
||||
*surface = _surface;
|
||||
|
|
@ -1324,13 +1305,13 @@ main(int argc, char *argv[])
|
|||
|
||||
/* The Wayland display is managed by libwayland. It handles accepting
|
||||
* clients from the Unix socket, manging Wayland globals, and so on. */
|
||||
wl_display = wl_display_create();
|
||||
dpy = wl_display_create();
|
||||
|
||||
setup();
|
||||
run(startup_cmd);
|
||||
|
||||
/* Once wl_display_run returns, we shut down the server. */
|
||||
wl_display_destroy_clients(wl_display);
|
||||
wl_display_destroy(wl_display);
|
||||
wl_display_destroy_clients(dpy);
|
||||
wl_display_destroy(dpy);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue