diff options
Diffstat (limited to 'dwl.c')
| -rw-r--r-- | dwl.c | 782 |
1 files changed, 670 insertions, 112 deletions
@@ -10,6 +10,7 @@ #include <sys/wait.h> #include <time.h> #include <unistd.h> +#include <libinput.h> #include <wayland-server-core.h> #include <wlr/backend.h> #include <wlr/render/wlr_renderer.h> @@ -17,7 +18,9 @@ #include <wlr/types/wlr_cursor.h> #include <wlr/types/wlr_data_device.h> #include <wlr/types/wlr_export_dmabuf_v1.h> +#include <wlr/types/wlr_gamma_control_v1.h> #include <wlr/types/wlr_input_device.h> +#include <wlr/types/wlr_layer_shell_v1.h> #include <wlr/types/wlr_keyboard.h> #include <wlr/types/wlr_matrix.h> #include <wlr/types/wlr_output.h> @@ -32,6 +35,7 @@ #include <wlr/types/wlr_xdg_decoration_v1.h> #include <wlr/types/wlr_xdg_output_v1.h> #include <wlr/types/wlr_xdg_shell.h> +#include <wlr/backend/libinput.h> #include <wlr/util/log.h> #include <xkbcommon/xkbcommon.h> #ifdef XWAYLAND @@ -40,6 +44,8 @@ #endif /* macros */ +#define BARF(fmt, ...) do { fprintf(stderr, fmt "\n", ##__VA_ARGS__); exit(EXIT_FAILURE); } while (0) +#define EBARF(fmt, ...) BARF(fmt ": %s", ##__VA_ARGS__, strerror(errno)) #define MAX(A, B) ((A) > (B) ? (A) : (B)) #define MIN(A, B) ((A) < (B) ? (A) : (B)) #define CLEANMASK(mask) (mask & ~WLR_MODIFIER_CAPS) @@ -47,6 +53,7 @@ #define LENGTH(X) (sizeof X / sizeof X[0]) #define END(A) ((A) + LENGTH(A)) #define TAGMASK ((1 << LENGTH(tags)) - 1) +#define ROUND(X) ((int)((X)+0.5)) #ifdef XWAYLAND #define WLR_SURFACE(C) ((C)->type != XDGShell ? (C)->surface.xwayland->surface : (C)->surface.xdg->surface) #else @@ -55,9 +62,9 @@ /* enums */ enum { CurNormal, CurMove, CurResize }; /* cursor */ +#ifdef XWAYLAND enum { NetWMWindowTypeDialog, NetWMWindowTypeSplash, NetWMWindowTypeToolbar, NetWMWindowTypeUtility, NetLast }; /* EWMH atoms */ -#ifdef XWAYLAND enum { XDGShell, X11Managed, X11Unmanaged }; /* client types */ #endif @@ -93,6 +100,7 @@ typedef struct { struct wl_listener map; struct wl_listener unmap; struct wl_listener destroy; + struct wl_listener fullscreen; struct wlr_box geom; /* layout-relative, includes border */ Monitor *mon; #ifdef XWAYLAND @@ -102,6 +110,11 @@ typedef struct { unsigned int tags; int isfloating; uint32_t resize; /* configure serial of a pending resize */ + int prevx; + int prevy; + int prevwidth; + int prevheight; + int isfullscreen; } Client; typedef struct { @@ -126,6 +139,19 @@ typedef struct { } Keyboard; typedef struct { + struct wlr_layer_surface_v1 *layer_surface; + struct wl_list link; + + struct wl_listener destroy; + struct wl_listener map; + struct wl_listener unmap; + struct wl_listener surface_commit; + + struct wlr_box geo; + enum zwlr_layer_shell_v1_layer layer; +} LayerSurface; + +typedef struct { const char *symbol; void (*arrange)(Monitor *); } Layout; @@ -137,12 +163,14 @@ struct Monitor { struct wl_listener destroy; struct wlr_box m; /* monitor area, layout-relative */ struct wlr_box w; /* window area, layout-relative */ + struct wl_list layers[4]; // LayerSurface::link const Layout *lt[2]; unsigned int seltags; unsigned int sellt; unsigned int tagset[2]; double mfact; int nmaster; + Client *fullscreenclient; }; typedef struct { @@ -172,25 +200,37 @@ struct render_data { /* function declarations */ static void applybounds(Client *c, struct wlr_box *bbox); +static void applyexclusive(struct wlr_box *usable_area, uint32_t anchor, + int32_t exclusive, int32_t margin_top, int32_t margin_right, + int32_t margin_bottom, int32_t margin_left); static void applyrules(Client *c); static void arrange(Monitor *m); +static void arrangelayer(Monitor *m, struct wl_list *list, + struct wlr_box *usable_area, bool exclusive); +static void arrangelayers(Monitor *m); static void axisnotify(struct wl_listener *listener, void *data); static void buttonpress(struct wl_listener *listener, void *data); static void chvt(const Arg *arg); +static void cleanup(void); static void cleanupkeyboard(struct wl_listener *listener, void *data); static void cleanupmon(struct wl_listener *listener, void *data); +static void commitlayersurfacenotify(struct wl_listener *listener, void *data); +static void commitnotify(struct wl_listener *listener, void *data); static void createkeyboard(struct wlr_input_device *device); static void createmon(struct wl_listener *listener, void *data); static void createnotify(struct wl_listener *listener, void *data); +static void createlayersurface(struct wl_listener *listener, void *data); static void createpointer(struct wlr_input_device *device); static void createxdeco(struct wl_listener *listener, void *data); static void cursorframe(struct wl_listener *listener, void *data); +static void destroylayersurfacenotify(struct wl_listener *listener, void *data); static void destroynotify(struct wl_listener *listener, void *data); static void destroyxdeco(struct wl_listener *listener, void *data); static Monitor *dirtomon(int dir); static void focusclient(Client *old, Client *c, int lift); static void focusmon(const Arg *arg); static void focusstack(const Arg *arg); +static void fullscreennotify(struct wl_listener *listener, void *data); static Client *focustop(Monitor *m); static void getxdecomode(struct wl_listener *listener, void *data); static void incnmaster(const Arg *arg); @@ -199,7 +239,9 @@ static int keybinding(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 killclient(const Arg *arg); +static void maplayersurfacenotify(struct wl_listener *listener, void *data); static void maprequest(struct wl_listener *listener, void *data); +static void maximizeclient(Client *c); static void monocle(Monitor *m); static void motionabsolute(struct wl_listener *listener, void *data); static void motionnotify(uint32_t time); @@ -210,6 +252,7 @@ static void pointerfocus(Client *c, struct wlr_surface *surface, static void quit(const Arg *arg); static void render(struct wlr_surface *surface, int sx, int sy, void *data); static void renderclients(Monitor *m, struct timespec *now); +static void renderlayer(struct wl_list *layer_surfaces, struct timespec *now); static void rendermon(struct wl_listener *listener, void *data); static void resize(Client *c, int x, int y, int w, int h, int interact); static void run(char *startup_cmd); @@ -219,20 +262,29 @@ static void setcursor(struct wl_listener *listener, void *data); static void setpsel(struct wl_listener *listener, void *data); static void setsel(struct wl_listener *listener, void *data); static void setfloating(Client *c, int floating); +static void setfullscreen(Client *c, int fullscreen); static void setlayout(const Arg *arg); static void setmfact(const Arg *arg); static void setmon(Client *c, Monitor *m, unsigned int newtags); static void setup(void); +static void sigchld(int unused); +static bool shouldfocusclients(); static void spawn(const Arg *arg); static void tag(const Arg *arg); static void tagmon(const Arg *arg); static void tile(Monitor *m); static void togglefloating(const Arg *arg); +static void togglefullscreen(const Arg *arg); static void toggletag(const Arg *arg); static void toggleview(const Arg *arg); +static void unmaplayersurface(LayerSurface *layersurface); +static void unmaplayersurfacenotify(struct wl_listener *listener, void *data); static void unmapnotify(struct wl_listener *listener, void *data); +static void updatemons(); static void view(const Arg *arg); static Client *xytoclient(double x, double y); +static struct wlr_surface *xytolayersurface(struct wl_list *layer_surfaces, + double x, double y, double *sx, double *sy); static Monitor *xytomon(double x, double y); static void zoom(const Arg *arg); @@ -248,6 +300,7 @@ static struct wl_list clients; /* tiling order */ static struct wl_list fstack; /* focus order */ static struct wl_list stack; /* stacking z-order */ static struct wl_list independents; +static struct wlr_layer_shell_v1 *layer_shell; static struct wlr_xdg_decoration_manager_v1 *xdeco_mgr; static struct wlr_cursor *cursor; @@ -278,6 +331,7 @@ static struct wl_listener new_input = {.notify = inputdevice}; static struct wl_listener new_output = {.notify = createmon}; static struct wl_listener new_xdeco = {.notify = createxdeco}; static struct wl_listener new_xdg_surface = {.notify = createnotify}; +static struct wl_listener new_layer_shell_surface = {.notify = createlayersurface}; static struct wl_listener request_cursor = {.notify = setcursor}; static struct wl_listener request_set_psel = {.notify = setpsel}; static struct wl_listener request_set_sel = {.notify = setsel}; @@ -289,6 +343,7 @@ static Atom getatom(xcb_connection_t *xc, const char *name); static void renderindependents(struct wlr_output *output, struct timespec *now); static void updatewindowtype(Client *c); static void xwaylandready(struct wl_listener *listener, void *data); +static Client *xytoindependent(double x, double y); static struct wl_listener new_xwayland_surface = {.notify = createnotifyx11}; static struct wl_listener xwayland_ready = {.notify = xwaylandready}; static struct wlr_xwayland *xwayland; @@ -320,6 +375,71 @@ applybounds(Client *c, struct wlr_box *bbox) } void +applyexclusive(struct wlr_box *usable_area, + uint32_t anchor, int32_t exclusive, + int32_t margin_top, int32_t margin_right, + int32_t margin_bottom, int32_t margin_left) { + struct { + uint32_t singular_anchor; + uint32_t anchor_triplet; + int *positive_axis; + int *negative_axis; + int margin; + } edges[4]; + + if (exclusive <= 0) + return; + + // Top + edges[0].singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP; + edges[0].anchor_triplet = + ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | + ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT | + ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP; + edges[0].positive_axis = &usable_area->y; + edges[0].negative_axis = &usable_area->height; + edges[0].margin = margin_top; + // Bottom + edges[1].singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; + edges[1].anchor_triplet = + ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | + ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT | + ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; + edges[1].positive_axis = NULL; + edges[1].negative_axis = &usable_area->height; + edges[1].margin = margin_bottom; + // Left + edges[2].singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT; + edges[2].anchor_triplet = + ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | + ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | + ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; + edges[2].positive_axis = &usable_area->x; + edges[2].negative_axis = &usable_area->width; + edges[2].margin = margin_left; + // Right + edges[3].singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT; + edges[3].anchor_triplet = + ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT | + ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | + ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; + edges[3].positive_axis = NULL; + edges[3].negative_axis = &usable_area->width; + edges[3].margin = margin_right; + + for (size_t i = 0; i < LENGTH(edges); ++i) { + if ((anchor == edges[i].singular_anchor || anchor == edges[i].anchor_triplet) + && exclusive + edges[i].margin > 0) { + if (edges[i].positive_axis) + *edges[i].positive_axis += exclusive + edges[i].margin; + if (edges[i].negative_axis) + *edges[i].negative_axis -= exclusive + edges[i].margin; + break; + } + } +} + +void applyrules(Client *c) { const char *appid, *title; @@ -330,8 +450,8 @@ applyrules(Client *c) /* rule matching */ c->isfloating = 0; #ifdef XWAYLAND - updatewindowtype(c); if (c->type != XDGShell) { + updatewindowtype(c); appid = c->surface.xwayland->class; title = c->surface.xwayland->title; } else @@ -362,15 +482,141 @@ applyrules(Client *c) void arrange(Monitor *m) { - /* Get effective monitor geometry to use for window area */ - m->m = *wlr_output_layout_get_box(output_layout, m->wlr_output); - m->w = m->m; if (m->lt[m->sellt]->arrange) m->lt[m->sellt]->arrange(m); + else if (m->fullscreenclient) + maximizeclient(m->fullscreenclient); /* XXX recheck pointer focus here... or in resize()? */ } void +arrangelayer(Monitor *m, struct wl_list *list, struct wlr_box *usable_area, bool exclusive) +{ + LayerSurface *layersurface; + struct wlr_box full_area = m->m; + + wl_list_for_each(layersurface, list, link) { + struct wlr_layer_surface_v1 *wlr_layer_surface = layersurface->layer_surface; + struct wlr_layer_surface_v1_state *state = &wlr_layer_surface->current; + struct wlr_box bounds; + struct wlr_box box = { + .width = state->desired_width, + .height = state->desired_height + }; + const uint32_t both_horiz = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT + | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT; + const uint32_t both_vert = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP + | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; + + if (exclusive != (state->exclusive_zone > 0)) + continue; + + bounds = state->exclusive_zone == -1 ? full_area : *usable_area; + + // Horizontal axis + if ((state->anchor & both_horiz) && box.width == 0) { + box.x = bounds.x; + box.width = bounds.width; + } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)) { + box.x = bounds.x; + } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT)) { + box.x = bounds.x + (bounds.width - box.width); + } else { + box.x = bounds.x + ((bounds.width / 2) - (box.width / 2)); + } + // Vertical axis + if ((state->anchor & both_vert) && box.height == 0) { + box.y = bounds.y; + box.height = bounds.height; + } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP)) { + box.y = bounds.y; + } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM)) { + box.y = bounds.y + (bounds.height - box.height); + } else { + box.y = bounds.y + ((bounds.height / 2) - (box.height / 2)); + } + // Margin + if ((state->anchor & both_horiz) == both_horiz) { + box.x += state->margin.left; + box.width -= state->margin.left + state->margin.right; + } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)) { + box.x += state->margin.left; + } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT)) { + box.x -= state->margin.right; + } + if ((state->anchor & both_vert) == both_vert) { + box.y += state->margin.top; + box.height -= state->margin.top + state->margin.bottom; + } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP)) { + box.y += state->margin.top; + } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM)) { + box.y -= state->margin.bottom; + } + if (box.width < 0 || box.height < 0) { + wlr_layer_surface_v1_close(wlr_layer_surface); + continue; + } + layersurface->geo = box; + + applyexclusive(usable_area, state->anchor, state->exclusive_zone, + state->margin.top, state->margin.right, + state->margin.bottom, state->margin.left); + wlr_layer_surface_v1_configure(wlr_layer_surface, box.width, box.height); + } +} + +void +arrangelayers(Monitor *m) +{ + struct wlr_box usable_area = m->m; + uint32_t layers_above_shell[] = { + ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY, + ZWLR_LAYER_SHELL_V1_LAYER_TOP, + }; + size_t nlayers = LENGTH(layers_above_shell); + LayerSurface *layersurface; + struct wlr_keyboard *kb = wlr_seat_get_keyboard(seat); + + // Arrange exclusive surfaces from top->bottom + arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], + &usable_area, true); + arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP], + &usable_area, true); + arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], + &usable_area, true); + arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], + &usable_area, true); + + if (memcmp(&usable_area, &m->w, sizeof(struct wlr_box))) { + m->w = usable_area; + arrange(m); + } + + // Arrange non-exlusive surfaces from top->bottom + arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], + &usable_area, false); + arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP], + &usable_area, false); + arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], + &usable_area, false); + arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], + &usable_area, false); + + // Find topmost keyboard interactive layer, if such a layer exists + for (size_t i = 0; i < nlayers; ++i) { + wl_list_for_each_reverse(layersurface, + &m->layers[layers_above_shell[i]], link) { + if (layersurface->layer_surface->current.keyboard_interactive && + layersurface->layer_surface->mapped) { + wlr_seat_keyboard_notify_enter(seat, layersurface->layer_surface->surface, + kb->keycodes, kb->num_keycodes, &kb->modifiers); + return; + } + } + } +} + +void axisnotify(struct wl_listener *listener, void *data) { /* This event is forwarded by the cursor when a pointer emits an axis event, @@ -430,10 +676,21 @@ buttonpress(struct wl_listener *listener, void *data) void chvt(const Arg *arg) { - struct wlr_session *s = wlr_backend_get_session(backend); - if (!s) - return; - wlr_session_change_vt(s, arg->ui); + wlr_session_change_vt(wlr_backend_get_session(backend), arg->ui); +} + +void +cleanup(void) +{ +#ifdef XWAYLAND + wlr_xwayland_destroy(xwayland); +#endif + wl_display_destroy_clients(dpy); + wl_display_destroy(dpy); + + wlr_xcursor_manager_destroy(cursor_mgr); + wlr_cursor_destroy(cursor); + wlr_output_layout_destroy(output_layout); } void @@ -454,6 +711,30 @@ cleanupmon(struct wl_listener *listener, void *data) wl_list_remove(&m->destroy.link); free(m); + + updatemons(); +} + +void +commitlayersurfacenotify(struct wl_listener *listener, void *data) +{ + LayerSurface *layersurface = wl_container_of(listener, layersurface, surface_commit); + struct wlr_layer_surface_v1 *wlr_layer_surface = layersurface->layer_surface; + struct wlr_output *wlr_output = wlr_layer_surface->output; + Monitor *m; + + if (!wlr_output) + return; + + m = wlr_output->data; + arrangelayers(m); + + if (layersurface->layer != wlr_layer_surface->current.layer) { + wl_list_remove(&layersurface->link); + wl_list_insert(&m->layers[wlr_layer_surface->current.layer], + &layersurface->link); + layersurface->layer = wlr_layer_surface->current.layer; + } } void @@ -508,6 +789,7 @@ createmon(struct wl_listener *listener, void *data) struct wlr_output *wlr_output = data; Monitor *m; const MonitorRule *r; + size_t nlayers = LENGTH(m->layers); /* The mode is a tuple of (width, height, refresh rate), and each * monitor supports only a specific set of modes. We just pick the @@ -553,6 +835,12 @@ createmon(struct wl_listener *listener, void *data) */ wlr_output_layout_add_auto(output_layout, wlr_output); sgeom = *wlr_output_layout_get_box(output_layout, NULL); + + for (size_t i = 0; i < nlayers; ++i) + wl_list_init(&m->layers[i]); + + /* When adding monitors, the geometries of all monitors must be updated */ + updatemons(); } void @@ -584,11 +872,66 @@ createnotify(struct wl_listener *listener, void *data) wl_signal_add(&xdg_surface->events.unmap, &c->unmap); c->destroy.notify = destroynotify; wl_signal_add(&xdg_surface->events.destroy, &c->destroy); + + c->fullscreen.notify = fullscreennotify; + wl_signal_add(&xdg_surface->toplevel->events.request_fullscreen, &c->fullscreen); + c->isfullscreen = 0; +} + +void +createlayersurface(struct wl_listener *listener, void *data) +{ + struct wlr_layer_surface_v1 *wlr_layer_surface = data; + LayerSurface *layersurface; + Monitor *m; + struct wlr_layer_surface_v1_state old_state; + + if (!wlr_layer_surface->output) { + wlr_layer_surface->output = selmon->wlr_output; + } + + layersurface = calloc(1, sizeof(LayerSurface)); + + layersurface->surface_commit.notify = commitlayersurfacenotify; + wl_signal_add(&wlr_layer_surface->surface->events.commit, + &layersurface->surface_commit); + layersurface->destroy.notify = destroylayersurfacenotify; + wl_signal_add(&wlr_layer_surface->events.destroy, &layersurface->destroy); + layersurface->map.notify = maplayersurfacenotify; + wl_signal_add(&wlr_layer_surface->events.map, &layersurface->map); + layersurface->unmap.notify = unmaplayersurfacenotify; + wl_signal_add(&wlr_layer_surface->events.unmap, &layersurface->unmap); + + layersurface->layer_surface = wlr_layer_surface; + wlr_layer_surface->data = layersurface; + + m = wlr_layer_surface->output->data; + + wl_list_insert(&m->layers[wlr_layer_surface->client_pending.layer], + &layersurface->link); + + // Temporarily set the layer's current state to client_pending + // so that we can easily arrange it + old_state = wlr_layer_surface->current; + wlr_layer_surface->current = wlr_layer_surface->client_pending; + arrangelayers(m); + wlr_layer_surface->current = old_state; } void createpointer(struct wlr_input_device *device) { + if (wlr_input_device_is_libinput(device)) { + struct libinput_device *libinput_device = (struct libinput_device*) + wlr_libinput_get_device_handle(device); + + if (tap_to_click && libinput_device_config_tap_get_finger_count(libinput_device)) + libinput_device_config_tap_set_enabled(libinput_device, LIBINPUT_CONFIG_TAP_ENABLED); + + if (libinput_device_config_scroll_has_natural_scroll(libinput_device)) + libinput_device_config_scroll_set_natural_scroll_enabled(libinput_device, natural_scrolling); + } + /* 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 @@ -610,7 +953,6 @@ createxdeco(struct wl_listener *listener, void *data) getxdecomode(&d->request_mode, wlr_deco); } - void cursorframe(struct wl_listener *listener, void *data) { @@ -623,6 +965,28 @@ cursorframe(struct wl_listener *listener, void *data) } void +destroylayersurfacenotify(struct wl_listener *listener, void *data) +{ + LayerSurface *layersurface = wl_container_of(listener, layersurface, destroy); + Monitor *m; + + if (layersurface->layer_surface->mapped) + unmaplayersurface(layersurface); + wl_list_remove(&layersurface->link); + wl_list_remove(&layersurface->destroy.link); + wl_list_remove(&layersurface->map.link); + wl_list_remove(&layersurface->unmap.link); + wl_list_remove(&layersurface->surface_commit.link); + if (layersurface->layer_surface->output) { + m = layersurface->layer_surface->output->data; + if (m) + arrangelayers(m); + layersurface->layer_surface->output = NULL; + } + free(layersurface); +} + +void destroynotify(struct wl_listener *listener, void *data) { /* Called when the surface is destroyed and should never be shown again. */ @@ -630,6 +994,7 @@ destroynotify(struct wl_listener *listener, void *data) wl_list_remove(&c->map.link); wl_list_remove(&c->unmap.link); wl_list_remove(&c->destroy.link); + wl_list_remove(&c->fullscreen.link); #ifdef XWAYLAND if (c->type == X11Managed) wl_list_remove(&c->activate.link); @@ -650,6 +1015,56 @@ destroyxdeco(struct wl_listener *listener, void *data) free(d); } +void +togglefullscreen(const Arg *arg) +{ + Client *sel = selclient(); + setfullscreen(sel, !sel->isfullscreen); +} + +void +maximizeclient(Client *c) +{ + resize(c, c->mon->m.x, c->mon->m.y, c->mon->m.width, c->mon->m.height, 0); + /* used for fullscreen clients */ +} + +void +setfullscreen(Client *c, int fullscreen) +{ + c->isfullscreen = fullscreen; + c->bw = (1 - fullscreen) * borderpx; + +#ifdef XWAYLAND + if (c->type == X11Managed) + wlr_xwayland_surface_set_fullscreen(c->surface.xwayland, fullscreen); + else +#endif + wlr_xdg_toplevel_set_fullscreen(c->surface.xdg, fullscreen); + + if (fullscreen) { + c->prevx = c->geom.x; + c->prevy = c->geom.y; + c->prevheight = c->geom.height; + c->prevwidth = c->geom.width; + c->mon->fullscreenclient = c; + maximizeclient(c); + } else { + /* restore previous size instead of arrange for floating windows since + * client positions are set by the user and cannot be recalculated */ + resize(c, c->prevx, c->prevy, c->prevwidth, c->prevheight, 0); + c->mon->fullscreenclient = NULL; + arrange(c->mon); + } +} + +void +fullscreennotify(struct wl_listener *listener, void *data) +{ + Client *c = wl_container_of(listener, c, fullscreen); + setfullscreen(c, !c->isfullscreen); +} + Monitor * dirtomon(int dir) { @@ -699,8 +1114,9 @@ focusclient(Client *old, Client *c, int lift) } /* Have a client, so focus its top-level wlr_surface */ - wlr_seat_keyboard_notify_enter(seat, WLR_SURFACE(c), - kb->keycodes, kb->num_keycodes, &kb->modifiers); + if (shouldfocusclients(c->mon)) + wlr_seat_keyboard_notify_enter(seat, WLR_SURFACE(c), + kb->keycodes, kb->num_keycodes, &kb->modifiers); /* Put the new client atop the focus stack and select its monitor */ wl_list_remove(&c->flink); @@ -842,7 +1258,7 @@ keypress(struct wl_listener *listener, void *data) int handled = 0; uint32_t mods = wlr_keyboard_get_modifiers(kb->device->keyboard); /* On _press_, attempt to process a compositor keybinding. */ - if (event->state == WLR_KEY_PRESSED) + if (event->state == WL_KEYBOARD_KEY_STATE_PRESSED) for (i = 0; i < nsyms; i++) handled = keybinding(mods, syms[i]) || handled; @@ -888,10 +1304,18 @@ killclient(const Arg *arg) } void +maplayersurfacenotify(struct wl_listener *listener, void *data) +{ + LayerSurface *layersurface = wl_container_of(listener, layersurface, map); + wlr_surface_send_enter(layersurface->layer_surface->surface, layersurface->layer_surface->output); + motionnotify(0); +} + +void maprequest(struct wl_listener *listener, void *data) { /* Called when the surface is mapped, or ready to display on-screen. */ - Client *c = wl_container_of(listener, c, map); + Client *c = wl_container_of(listener, c, map), *oldfocus = selclient(); #ifdef XWAYLAND if (c->type == X11Unmanaged) { @@ -922,6 +1346,14 @@ maprequest(struct wl_listener *listener, void *data) /* Set initial monitor, tags, floating status, and focus */ applyrules(c); + + if (c->mon->fullscreenclient && c->mon->fullscreenclient == oldfocus + && !c->isfloating && c->mon->lt[c->mon->sellt]->arrange) { + maximizeclient(c->mon->fullscreenclient); + focusclient(c, c->mon->fullscreenclient, 1); + /* give the focus back the fullscreen client on that monitor if exists, + * is focused and the new client isn't floating */ + } } void @@ -932,7 +1364,10 @@ monocle(Monitor *m) wl_list_for_each(c, &clients, link) { if (!VISIBLEON(c, m) || c->isfloating) continue; - resize(c, m->w.x, m->w.y, m->w.width, m->w.height, 0); + if (c->isfullscreen) + maximizeclient(c); + else + resize(c, m->w.x, m->w.y, m->w.width, m->w.height, 0); } } @@ -955,7 +1390,12 @@ motionnotify(uint32_t time) { double sx = 0, sy = 0; struct wlr_surface *surface = NULL; - Client *c; + Client *c = NULL; + struct timespec now; + if (!time) { + clock_gettime(CLOCK_MONOTONIC, &now); + time = now.tv_sec * 1000 + now.tv_nsec / 1000000; + } /* Update selmon (even while dragging a window) */ if (sloppyfocus) @@ -974,8 +1414,23 @@ motionnotify(uint32_t time) return; } + if ((surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], + cursor->x, cursor->y, &sx, &sy))) + ; + else if ((surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP], + cursor->x, cursor->y, &sx, &sy))) + ; +#ifdef XWAYLAND + /* Find an independent under the pointer and send the event along. */ + else if ((c = xytoindependent(cursor->x, cursor->y))) { + surface = wlr_surface_surface_at(c->surface.xwayland->surface, + cursor->x - c->surface.xwayland->x - c->bw, + cursor->y - c->surface.xwayland->y - c->bw, &sx, &sy); + /* Otherwise, find the client under the pointer and send the event along. */ - if ((c = xytoclient(cursor->x, cursor->y))) { + } +#endif + else if ((c = xytoclient(cursor->x, cursor->y))) { #ifdef XWAYLAND if (c->type != XDGShell) surface = wlr_surface_surface_at(c->surface.xwayland->surface, @@ -987,6 +1442,13 @@ motionnotify(uint32_t time) cursor->x - c->geom.x - c->bw, cursor->y - c->geom.y - c->bw, &sx, &sy); } + else if ((surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], + cursor->x, cursor->y, &sx, &sy))) + ; + else + surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], + cursor->x, cursor->y, &sx, &sy); + /* If there's no client surface under the cursor, set the cursor image to a * default. This is what makes the cursor image appear when you move it * off of a client or over its border. */ @@ -1063,6 +1525,15 @@ pointerfocus(Client *c, struct wlr_surface *surface, double sx, double sy, /* Otherwise, let the client know that the mouse cursor has entered one * of its surfaces, and make keyboard focus follow if desired. */ wlr_seat_pointer_notify_enter(seat, surface, sx, sy); + + if (!c) + return; + +#if XWAYLAND + if (c->type == X11Unmanaged) + return; +#endif + if (sloppyfocus) focusclient(selclient(), c, 0); } @@ -1153,21 +1624,24 @@ renderclients(Monitor *m, struct timespec *now) ox = c->geom.x, oy = c->geom.y; wlr_output_layout_output_coords(output_layout, m->wlr_output, &ox, &oy); - w = surface->current.width; - h = surface->current.height; - borders = (struct wlr_box[4]) { - {ox, oy, w + 2 * c->bw, c->bw}, /* top */ - {ox, oy + c->bw, c->bw, h}, /* left */ - {ox + c->bw + w, oy + c->bw, c->bw, h}, /* right */ - {ox, oy + c->bw + h, w + 2 * c->bw, c->bw}, /* bottom */ - }; - /* Draw window borders */ - color = (c == sel) ? focuscolor : bordercolor; - for (i = 0; i < 4; i++) { - scalebox(&borders[i], m->wlr_output->scale); - wlr_render_rect(drw, &borders[i], color, - m->wlr_output->transform_matrix); + if (c->bw) { + w = surface->current.width; + h = surface->current.height; + borders = (struct wlr_box[4]) { + {ox, oy, w + 2 * c->bw, c->bw}, /* top */ + {ox, oy + c->bw, c->bw, h}, /* left */ + {ox + c->bw + w, oy + c->bw, c->bw, h}, /* right */ + {ox, oy + c->bw + h, w + 2 * c->bw, c->bw}, /* bottom */ + }; + + /* Draw window borders */ + color = (c == sel) ? focuscolor : bordercolor; + for (i = 0; i < 4; i++) { + scalebox(&borders[i], m->wlr_output->scale); + wlr_render_rect(drw, &borders[i], color, + m->wlr_output->transform_matrix); + } } /* This calls our render function for each surface among the @@ -1186,6 +1660,22 @@ renderclients(Monitor *m, struct timespec *now) } void +renderlayer(struct wl_list *layer_surfaces, struct timespec *now) +{ + struct render_data rdata; + LayerSurface *layersurface; + wl_list_for_each(layersurface, layer_surfaces, link) { + rdata.output = layersurface->layer_surface->output; + rdata.when = now; + rdata.x = layersurface->geo.x; + rdata.y = layersurface->geo.y; + + wlr_surface_for_each_surface(layersurface->layer_surface->surface, + render, &rdata); + } +} + +void rendermon(struct wl_listener *listener, void *data) { Client *c; @@ -1215,10 +1705,14 @@ rendermon(struct wl_listener *listener, void *data) wlr_renderer_begin(drw, m->wlr_output->width, m->wlr_output->height); wlr_renderer_clear(drw, rootcolor); + renderlayer(&m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &now); + renderlayer(&m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &now); renderclients(m, &now); #ifdef XWAYLAND renderindependents(m->wlr_output, &now); #endif + renderlayer(&m->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP], &now); + renderlayer(&m->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &now); /* Hardware cursors are rendered by the GPU on a separate plane, and can be * moved around without re-rendering what's beneath them - which is more @@ -1269,20 +1763,13 @@ run(char *startup_cmd) /* Add a Unix socket to the Wayland display. */ const char *socket = wl_display_add_socket_auto(dpy); - if (!socket) { - perror("startup: display_add_socket_auto"); - wlr_backend_destroy(backend); - exit(EXIT_FAILURE); - } + if (!socket) + BARF("startup: display_add_socket_auto"); /* Start the backend. This will enumerate outputs and inputs, become the DRM * master, etc */ - if (!wlr_backend_start(backend)) { - perror("startup: backend_start"); - wlr_backend_destroy(backend); - wl_display_destroy(dpy); - exit(EXIT_FAILURE); - } + if (!wlr_backend_start(backend)) + BARF("startup: backend_start"); /* Now that outputs are initialized, choose initial selmon based on * cursor position, and set default cursor image */ @@ -1300,24 +1787,17 @@ run(char *startup_cmd) setenv("WAYLAND_DISPLAY", socket, 1); if (startup_cmd) { startup_pid = fork(); - if (startup_pid < 0) { - perror("startup: fork"); - wl_display_destroy(dpy); - exit(EXIT_FAILURE); - } + if (startup_pid < 0) + EBARF("startup: fork"); if (startup_pid == 0) { execl("/bin/sh", "/bin/sh", "-c", startup_cmd, (void *)NULL); - perror("startup: execl"); - wl_display_destroy(dpy); - exit(EXIT_FAILURE); + EBARF("startup: execl"); } } /* Run the Wayland event loop. This does not return until you exit the * compositor. Starting the backend rigged up all of the necessary event * loop configuration to listen to libinput events, DRM events, generate * frame events at the refresh rate, and so on. */ - wlr_log(WLR_INFO, "Running Wayland compositor on WAYLAND_DISPLAY=%s", - socket); wl_display_run(dpy); if (startup_cmd) { @@ -1329,10 +1809,10 @@ run(char *startup_cmd) void scalebox(struct wlr_box *box, float scale) { - box->x *= scale; - box->y *= scale; - box->width *= scale; - box->height *= scale; + box->width = ROUND((box->x + box->width) * scale) - ROUND(box->x * scale); + box->height = ROUND((box->y + box->height) * scale) - ROUND(box->y * scale); + box->x = ROUND(box->x * scale); + box->y = ROUND(box->y * scale); } Client * @@ -1366,8 +1846,6 @@ setcursor(struct wl_listener *listener, void *data) void setfloating(Client *c, int floating) { - if (c->isfloating == floating) - return; c->isfloating = floating; arrange(c->mon); } @@ -1448,6 +1926,13 @@ setsel(struct wl_listener *listener, void *data) void setup(void) { + /* The Wayland display is managed by libwayland. It handles accepting + * clients from the Unix socket, manging Wayland globals, and so on. */ + dpy = wl_display_create(); + + /* clean up child processes immediately */ + sigchld(0); + /* The backend is a wlroots feature which abstracts the underlying input and * output hardware. The autocreate option will choose the most suitable * backend based on the current environment, such as opening an X11 window @@ -1456,7 +1941,8 @@ 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(dpy, NULL); + if (!(backend = wlr_backend_autocreate(dpy, NULL))) + BARF("couldn't create backend"); /* 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 @@ -1474,6 +1960,7 @@ setup(void) wlr_export_dmabuf_manager_v1_create(dpy); wlr_screencopy_manager_v1_create(dpy); wlr_data_device_manager_create(dpy); + wlr_gamma_control_manager_v1_create(dpy); wlr_primary_selection_v1_device_manager_create(dpy); wlr_viewporter_create(dpy); @@ -1497,6 +1984,10 @@ setup(void) wl_list_init(&fstack); wl_list_init(&stack); wl_list_init(&independents); + + layer_shell = wlr_layer_shell_v1_create(dpy); + wl_signal_add(&layer_shell->events.new_surface, &new_layer_shell_surface); + xdg_shell = wlr_xdg_shell_create(dpy); wl_signal_add(&xdg_shell->events.new_surface, &new_xdg_surface); @@ -1584,14 +2075,37 @@ setup(void) } void +sigchld(int unused) +{ + if (signal(SIGCHLD, sigchld) == SIG_ERR) + EBARF("can't install SIGCHLD handler"); + while (0 < waitpid(-1, NULL, WNOHANG)) + ; +} + +bool +shouldfocusclients(Monitor *m) +{ + LayerSurface *layersurface; + uint32_t layers_above_shell[] = { + ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY, + ZWLR_LAYER_SHELL_V1_LAYER_TOP, + }; + for (size_t i = 0; i < LENGTH(layers_above_shell); ++i) + wl_list_for_each(layersurface, &m->layers[layers_above_shell[i]], link) + if (layersurface->layer_surface->current.keyboard_interactive && + layersurface->layer_surface->mapped) + return false; + return true; +} + +void spawn(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); + EBARF("dwl: execvp %s failed", ((char **)arg->v)[0]); } } @@ -1635,7 +2149,9 @@ tile(Monitor *m) wl_list_for_each(c, &clients, link) { if (!VISIBLEON(c, m) || c->isfloating) continue; - if (i < m->nmaster) { + if (c->isfullscreen) + maximizeclient(c); + else if (i < m->nmaster) { h = (m->w.height - my) / (MIN(n, m->nmaster) - i); resize(c, m->w.x, m->w.y + my, mw, h, 0); my += c->geom.height; @@ -1687,6 +2203,23 @@ toggleview(const Arg *arg) } void +unmaplayersurface(LayerSurface *layersurface) +{ + layersurface->layer_surface->mapped = false; + if (layersurface->layer_surface->surface == + seat->keyboard_state.focused_surface) + focusclient(NULL, selclient(), 1); + motionnotify(0); +} + +void +unmaplayersurfacenotify(struct wl_listener *listener, void *data) +{ + LayerSurface *layersurface = wl_container_of(listener, layersurface, unmap); + unmaplayersurface(layersurface); +} + +void unmapnotify(struct wl_listener *listener, void *data) { /* Called when the surface is unmapped, and should no longer be shown. */ @@ -1702,6 +2235,20 @@ unmapnotify(struct wl_listener *listener, void *data) } void +updatemons() +{ + Monitor *m; + wl_list_for_each(m, &mons, link) { + /* Get the effective monitor geometry to use for surfaces */ + m->m = m->w = *wlr_output_layout_get_box(output_layout, m->wlr_output); + /* Calculate the effective monitor geometry to use for clients */ + arrangelayers(m); + /* Don't move clients to the left output when plugging monitors */ + arrange(m); + } +} + +void view(const Arg *arg) { Client *sel = selclient(); @@ -1726,6 +2273,27 @@ xytoclient(double x, double y) return NULL; } +struct wlr_surface * +xytolayersurface(struct wl_list *layer_surfaces, double x, double y, + double *sx, double *sy) +{ + LayerSurface *layersurface; + wl_list_for_each_reverse(layersurface, layer_surfaces, link) { + struct wlr_surface *sub; + if (!layersurface->layer_surface->mapped) + continue; + sub = wlr_layer_surface_v1_surface_at( + layersurface->layer_surface, + x - layersurface->geo.x, + y - layersurface->geo.y, + sx, sy); + if (sub) + return sub; + + } + return NULL; +} + Monitor * xytomon(double x, double y) { @@ -1797,6 +2365,10 @@ createnotifyx11(struct wl_listener *listener, void *data) wl_signal_add(&xwayland_surface->events.request_activate, &c->activate); c->destroy.notify = destroynotify; wl_signal_add(&xwayland_surface->events.destroy, &c->destroy); + + c->fullscreen.notify = fullscreennotify; + wl_signal_add(&xwayland_surface->events.request_fullscreen, &c->fullscreen); + c->isfullscreen = 0; } Atom @@ -1844,14 +2416,12 @@ void updatewindowtype(Client *c) { size_t i; - - if (c->type != XDGShell) - for (i = 0; i < c->surface.xwayland->window_type_len; i++) - if (c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeDialog] || - c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeSplash] || - c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeToolbar] || - c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeUtility]) - c->isfloating = 1; + for (i = 0; i < c->surface.xwayland->window_type_len; i++) + if (c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeDialog] || + c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeSplash] || + c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeToolbar] || + c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeUtility]) + c->isfloating = 1; } void @@ -1876,65 +2446,53 @@ xwaylandready(struct wl_listener *listener, void *data) xcb_disconnect(xc); } + +Client * +xytoindependent(double x, double y) +{ + /* Find the topmost visible independent at point (x, y). + * For independents, the most recently created can be used as the "top". + * We rely on the X11 convention of unmapping unmanaged when the "owning" + * client loses focus, which ensures that unmanaged are only visible on + * the current tag. */ + Client *c; + struct wlr_box geom; + wl_list_for_each_reverse(c, &independents, link) { + geom.x = c->surface.xwayland->x; + geom.y = c->surface.xwayland->y; + geom.width = c->surface.xwayland->width; + geom.height = c->surface.xwayland->height; + if (wlr_box_contains_point(&geom, x, y)) + return c; + } + return NULL; +} #endif int main(int argc, char *argv[]) { char *startup_cmd = NULL; - enum wlr_log_importance loglevel = WLR_ERROR; - int c; - while ((c = getopt(argc, argv, "qvds:h")) != -1) { - switch (c) { - case 'q': - loglevel = WLR_SILENT; - break; - case 'v': - loglevel = WLR_INFO; - break; - case 'd': - loglevel = WLR_DEBUG; - break; - case 's': + + while ((c = getopt(argc, argv, "s:h")) != -1) { + if (c == 's') startup_cmd = optarg; - break; - default: + else goto usage; - } } if (optind < argc) goto usage; - wlr_log_init(loglevel, NULL); // Wayland requires XDG_RUNTIME_DIR for creating its communications // socket - if (!getenv("XDG_RUNTIME_DIR")) { - fprintf(stderr, "XDG_RUNTIME_DIR must be set\n"); - exit(EXIT_FAILURE); - } - - /* The Wayland display is managed by libwayland. It handles accepting - * clients from the Unix socket, manging Wayland globals, and so on. */ - dpy = wl_display_create(); - + if (!getenv("XDG_RUNTIME_DIR")) + BARF("XDG_RUNTIME_DIR must be set"); setup(); run(startup_cmd); - - /* Once wl_display_run returns, we shut down the server. */ -#ifdef XWAYLAND - wlr_xwayland_destroy(xwayland); -#endif - wl_display_destroy_clients(dpy); - wl_display_destroy(dpy); - - wlr_xcursor_manager_destroy(cursor_mgr); - wlr_cursor_destroy(cursor); - wlr_output_layout_destroy(output_layout); - + cleanup(); return EXIT_SUCCESS; usage: - printf("Usage: %s [-qvd] [-s startup command]\n", argv[0]); - return EXIT_FAILURE; + BARF("Usage: %s [-s startup command]", argv[0]); } |