dwl/dwl.c

1727 lines
51 KiB
C
Raw Normal View History

/*
* See LICENSE file for copyright and license details.
*/
#define _POSIX_C_SOURCE 200809L
#include <getopt.h>
2020-05-02 13:24:18 -07:00
#include <linux/input-event-codes.h>
#include <signal.h>
#include <stdio.h>
2020-05-02 13:24:18 -07:00
#include <stdlib.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <wayland-server-core.h>
#include <wlr/backend.h>
#include <wlr/render/wlr_renderer.h>
#include <wlr/types/wlr_compositor.h>
2020-05-02 13:24:18 -07:00
#include <wlr/types/wlr_cursor.h>
#include <wlr/types/wlr_data_device.h>
#include <wlr/types/wlr_input_device.h>
#include <wlr/types/wlr_keyboard.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_pointer.h>
2020-05-09 20:45:22 -07:00
#include <wlr/types/wlr_primary_selection.h>
#include <wlr/types/wlr_primary_selection_v1.h>
#include <wlr/types/wlr_screencopy_v1.h>
#include <wlr/types/wlr_seat.h>
#include <wlr/types/wlr_xcursor_manager.h>
#include <wlr/types/wlr_xdg_decoration_v1.h>
2020-05-09 21:01:30 -07:00
#include <wlr/types/wlr_xdg_output_v1.h>
#include <wlr/types/wlr_xdg_shell.h>
#include <wlr/util/log.h>
#include <wlr/xwayland.h>
#include <xkbcommon/xkbcommon.h>
/* macros */
2020-04-23 18:14:11 -07:00
#define MAX(A, B) ((A) > (B) ? (A) : (B))
#define MIN(A, B) ((A) < (B) ? (A) : (B))
2020-04-11 17:46:51 -07:00
#define CLEANMASK(mask) (mask & ~WLR_MODIFIER_CAPS)
2020-04-23 17:53:49 -07:00
#define VISIBLEON(C, M) ((C)->mon == (M) && ((C)->tags & (M)->tagset[(M)->seltags]))
#define LENGTH(X) (sizeof X / sizeof X[0])
2020-05-02 22:41:37 -07:00
#define END(A) ((A) + LENGTH(A))
2020-04-23 17:53:49 -07:00
#define TAGMASK ((1 << LENGTH(tags)) - 1)
2020-07-23 16:32:10 -07:00
#define WLR_SURFACE(C) ((C)->isx11 ? (C)->xwayland_surface->surface : (C)->xdg_surface->surface)
2020-04-21 12:00:18 -07:00
/* enums */
enum { CurNormal, CurMove, CurResize }; /* cursor */
typedef union {
int i;
unsigned int ui;
float f;
const void *v;
} Arg;
typedef struct {
unsigned int mod;
unsigned int button;
void (*func)(const Arg *);
const Arg arg;
} Button;
typedef struct Monitor Monitor;
typedef struct {
struct wl_list link;
struct wl_list flink;
struct wl_list slink;
union {
struct wlr_xdg_surface *xdg_surface;
struct wlr_xwayland_surface *xwayland_surface;
};
struct wl_listener map;
struct wl_listener unmap;
struct wl_listener destroy;
2020-04-26 20:12:08 -07:00
struct wlr_box geom; /* layout-relative, includes border */
int isx11;
Monitor *mon;
2020-04-23 20:56:27 -07:00
int bw;
2020-04-23 17:53:49 -07:00
unsigned int tags;
2020-04-23 17:23:57 -07:00
int isfloating;
} Client;
typedef struct {
struct wl_listener request_mode;
struct wl_listener destroy;
} Decoration;
typedef struct {
uint32_t mod;
xkb_keysym_t keysym;
void (*func)(const Arg *);
const Arg arg;
} Key;
typedef struct {
struct wl_list link;
struct wlr_input_device *device;
struct wl_listener modifiers;
struct wl_listener key;
2020-07-23 15:13:42 -07:00
struct wl_listener destroy;
} Keyboard;
typedef struct {
const char *symbol;
void (*arrange)(Monitor *);
} Layout;
struct Monitor {
struct wl_list link;
struct wlr_output *wlr_output;
struct wl_listener frame;
2020-07-23 15:03:13 -07:00
struct wl_listener destroy;
2020-04-26 10:41:33 -07:00
struct wlr_box m; /* monitor area, layout-relative */
struct wlr_box w; /* window area, layout-relative */
const Layout *lt[2];
2020-04-23 17:53:49 -07:00
unsigned int seltags;
unsigned int sellt;
2020-04-23 17:53:49 -07:00
unsigned int tagset[2];
double mfact;
int nmaster;
};
typedef struct {
const char *name;
float mfact;
int nmaster;
float scale;
const Layout *lt;
2020-04-23 21:44:24 -07:00
enum wl_output_transform rr;
} MonitorRule;
2020-05-02 22:48:12 -07:00
typedef struct {
const char *id;
const char *title;
unsigned int tags;
int isfloating;
int monitor;
} Rule;
/* 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 timespec *when;
int x, y; /* layout-relative */
};
2020-04-21 11:48:27 -07:00
/* function declarations */
static void applybounds(Client *c, struct wlr_box *bbox);
2020-05-02 22:48:12 -07:00
static void applyrules(Client *c);
static void arrange(Monitor *m);
2020-04-21 11:48:27 -07:00
static void axisnotify(struct wl_listener *listener, void *data);
static void buttonpress(struct wl_listener *listener, void *data);
static void chvt(const Arg *arg);
2020-07-23 15:13:42 -07:00
static void cleanupkeyboard(struct wl_listener *listener, void *data);
2020-07-23 15:03:13 -07:00
static void cleanupmon(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 createnotifyx11(struct wl_listener *listener, void *data);
static void createpointer(struct wlr_input_device *device);
static void createxdeco(struct wl_listener *listener, void *data);
2020-04-21 11:48:27 -07:00
static void cursorframe(struct wl_listener *listener, void *data);
static void destroynotify(struct wl_listener *listener, void *data);
static void destroyxdeco(struct wl_listener *listener, void *data);
2020-04-23 18:40:02 -07:00
static Monitor *dirtomon(int dir);
static void focusclient(Client *c, struct wlr_surface *surface, int lift);
2020-04-23 18:40:02 -07:00
static void focusmon(const Arg *arg);
2020-04-22 22:47:15 -07:00
static void focusstack(const Arg *arg);
static void getxdecomode(struct wl_listener *listener, void *data);
2020-04-23 18:14:11 -07:00
static void incnmaster(const Arg *arg);
2020-04-21 11:48:27 -07:00
static void inputdevice(struct wl_listener *listener, void *data);
2020-05-02 12:32:23 -07:00
static int keybinding(uint32_t mods, xkb_keysym_t sym);
2020-04-21 11:48:27 -07:00
static void keypress(struct wl_listener *listener, void *data);
static void keypressmod(struct wl_listener *listener, void *data);
2020-07-23 11:30:25 -07:00
static void killclient(const Arg *arg);
2020-05-03 09:23:39 -07:00
static Client *lastfocused(void);
2020-04-21 11:48:27 -07:00
static void maprequest(struct wl_listener *listener, void *data);
static void motionabsolute(struct wl_listener *listener, void *data);
static void motionnotify(uint32_t time);
2020-04-21 11:48:27 -07:00
static void motionrelative(struct wl_listener *listener, void *data);
2020-04-30 08:25:37 -07:00
static void moveresize(const Arg *arg);
2020-04-23 22:12:11 -07:00
static void pointerfocus(Client *c, struct wlr_surface *surface,
2020-04-26 12:47:23 -07:00
double sx, double sy, uint32_t time);
static void quit(const Arg *arg);
2020-04-21 11:48:27 -07:00
static void render(struct wlr_surface *surface, int sx, int sy, void *data);
static void renderclients(Monitor *m, 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);
2020-04-21 16:57:04 -07:00
static void run(char *startup_cmd);
static void scalebox(struct wlr_box *box, float scale);
static Client *selclient(void);
2020-04-21 11:48:27 -07:00
static void setcursor(struct wl_listener *listener, void *data);
2020-05-09 20:45:22 -07:00
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);
2020-04-22 09:20:08 -07:00
static void setlayout(const Arg *arg);
2020-04-23 18:14:11 -07:00
static void setmfact(const Arg *arg);
2020-05-02 22:44:16 -07:00
static void setmon(Client *c, Monitor *m, unsigned int newtags);
2020-04-21 16:57:04 -07:00
static void setup(void);
static void spawn(const Arg *arg);
2020-04-23 17:53:49 -07:00
static void tag(const Arg *arg);
2020-04-23 18:40:02 -07:00
static void tagmon(const Arg *arg);
static void tile(Monitor *m);
2020-04-23 17:23:57 -07:00
static void togglefloating(const Arg *arg);
2020-04-23 18:02:17 -07:00
static void toggletag(const Arg *arg);
static void toggleview(const Arg *arg);
2020-04-21 11:48:27 -07:00
static void unmapnotify(struct wl_listener *listener, void *data);
2020-04-23 17:53:49 -07:00
static void view(const Arg *arg);
2020-05-03 09:31:55 -07:00
static Client *xytoclient(double x, double y);
static Monitor *xytomon(double x, double y);
2020-07-24 08:12:41 -07:00
static void zoom(const Arg *arg);
/* variables */
2020-05-02 22:48:12 -07:00
static const char broken[] = "broken";
2020-04-23 19:16:01 -07:00
static struct wl_display *dpy;
static struct wlr_backend *backend;
2020-04-23 19:16:01 -07:00
static struct wlr_renderer *drw;
static struct wlr_compositor *compositor;
static struct wlr_xwayland *xwayland;
static struct wlr_xdg_shell *xdg_shell;
static struct wl_list clients; /* tiling order */
static struct wl_list fstack; /* focus order */
static struct wl_list stack; /* stacking z-order */
static struct wlr_xdg_decoration_manager_v1 *xdeco_mgr;
static struct wlr_cursor *cursor;
static struct wlr_xcursor_manager *cursor_mgr;
static struct wlr_seat *seat;
static struct wl_list keyboards;
static unsigned int cursor_mode;
2020-04-22 20:37:11 -07:00
static Client *grabc;
2020-04-30 09:33:32 -07:00
static int grabcx, grabcy; /* client-relative */
static struct wlr_output_layout *output_layout;
static struct wlr_box sgeom;
static struct wl_list mons;
static Monitor *selmon;
2020-05-09 08:05:34 -07:00
/* global event handlers */
static struct wl_listener cursor_axis = {.notify = axisnotify};
static struct wl_listener cursor_button = {.notify = buttonpress};
static struct wl_listener cursor_frame = {.notify = cursorframe};
static struct wl_listener cursor_motion = {.notify = motionrelative};
static struct wl_listener cursor_motion_absolute = {.notify = motionabsolute};
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_xwayland_surface = {.notify = createnotifyx11};
2020-05-09 08:05:34 -07:00
static struct wl_listener request_cursor = {.notify = setcursor};
2020-05-09 20:45:22 -07:00
static struct wl_listener request_set_psel = {.notify = setpsel};
static struct wl_listener request_set_sel = {.notify = setsel};
2020-05-09 08:05:34 -07:00
2020-04-23 20:20:44 -07:00
/* configuration, allows nested code to access above variables */
#include "config.h"
2020-05-02 22:48:12 -07:00
/* function implementations */
void
applybounds(Client *c, struct wlr_box *bbox)
{
/* set minimum possible */
2020-04-26 20:12:08 -07:00
c->geom.width = MAX(1, c->geom.width);
c->geom.height = MAX(1, c->geom.height);
if (c->geom.x >= bbox->x + bbox->width)
c->geom.x = bbox->x + bbox->width - c->geom.width;
if (c->geom.y >= bbox->y + bbox->height)
c->geom.y = bbox->y + bbox->height - c->geom.height;
if (c->geom.x + c->geom.width + 2 * c->bw <= bbox->x)
c->geom.x = bbox->x;
if (c->geom.y + c->geom.height + 2 * c->bw <= bbox->y)
c->geom.y = bbox->y;
}
2020-05-02 22:48:12 -07:00
void
applyrules(Client *c)
{
const char *appid, *title;
unsigned int i, newtags = 0;
const Rule *r;
Monitor *mon = selmon, *m;
/* rule matching */
c->isfloating = 0;
appid = c->isx11 ? c->xwayland_surface->class :
c->xdg_surface->toplevel->app_id;
title = c->isx11 ? c->xwayland_surface->title :
c->xdg_surface->toplevel->title;
2020-07-21 15:47:30 -07:00
if (!appid)
appid = broken;
if (!title)
title = broken;
2020-05-02 22:48:12 -07:00
for (r = rules; r < END(rules); r++) {
if ((!r->title || strstr(title, r->title))
&& (!r->id || strstr(appid, r->id)))
{
c->isfloating = r->isfloating;
newtags |= r->tags;
i = 0;
wl_list_for_each(m, &mons, link)
if (r->monitor == i++)
mon = m;
}
}
setmon(c, mon, newtags);
}
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);
2020-04-23 18:29:26 -07:00
/* XXX recheck pointer focus here... or in resize()? */
}
2020-04-21 11:48:27 -07:00
void
axisnotify(struct wl_listener *listener, void *data)
{
2020-04-21 11:48:27 -07:00
/* This event is forwarded by the cursor when a pointer emits an axis event,
* for example when you move the scroll wheel. */
struct wlr_event_pointer_axis *event = data;
/* Notify the client with pointer focus of the axis event. */
wlr_seat_pointer_notify_axis(seat,
2020-04-21 11:48:27 -07:00
event->time_msec, event->orientation, event->delta,
event->delta_discrete, event->source);
}
2020-04-21 11:48:27 -07:00
void
buttonpress(struct wl_listener *listener, void *data)
{
2020-04-21 11:48:27 -07:00
struct wlr_event_pointer_button *event = data;
struct wlr_surface *surface;
struct wlr_keyboard *keyboard;
uint32_t mods;
Client *c;
2020-05-02 22:41:37 -07:00
const Button *b;
switch (event->state) {
case WLR_BUTTON_PRESSED:;
/* Change focus if the button was _pressed_ over a client */
2020-05-03 09:37:44 -07:00
if ((c = xytoclient(cursor->x, cursor->y))) {
if (c->isx11)
surface = wlr_surface_surface_at(c->xwayland_surface->surface,
cursor->x - c->geom.x - c->bw,
cursor->y - c->geom.y - c->bw, NULL, NULL);
else
surface = wlr_xdg_surface_surface_at(c->xdg_surface,
cursor->x - c->geom.x - c->bw,
cursor->y - c->geom.y - c->bw, NULL, NULL);
focusclient(c, surface, 1);
2020-05-03 09:37:44 -07:00
}
keyboard = wlr_seat_get_keyboard(seat);
mods = wlr_keyboard_get_modifiers(keyboard);
2020-05-02 22:41:37 -07:00
for (b = buttons; b < END(buttons); b++) {
if (CLEANMASK(mods) == CLEANMASK(b->mod) &&
event->button == b->button && b->func) {
b->func(&b->arg);
return;
}
}
break;
case WLR_BUTTON_RELEASED:
2020-04-21 11:48:27 -07:00
/* If you released any buttons, we exit interactive move/resize mode. */
2020-04-23 20:38:06 -07:00
/* XXX should reset to the pointer focus's current setcursor */
if (cursor_mode != CurNormal) {
2020-04-23 20:38:06 -07:00
wlr_xcursor_manager_set_cursor_image(cursor_mgr,
"left_ptr", cursor);
cursor_mode = CurNormal;
2020-04-26 19:35:21 -07:00
/* Drop the window off on its new monitor */
selmon = xytomon(cursor->x, cursor->y);
2020-05-02 22:44:16 -07:00
setmon(grabc, selmon, 0);
return;
}
break;
}
/* If the event wasn't handled by the compositor, notify the client with
* pointer focus that a button press has occurred */
wlr_seat_pointer_notify_button(seat,
event->time_msec, event->button, event->state);
}
2020-05-03 11:18:53 -07:00
void
chvt(const Arg *arg)
{
struct wlr_session *s = wlr_backend_get_session(backend);
if (!s)
return;
wlr_session_change_vt(s, arg->ui);
}
2020-07-23 15:13:42 -07:00
void
cleanupkeyboard(struct wl_listener *listener, void *data)
{
struct wlr_input_device *device = data;
Keyboard *kb = device->data;
wl_list_remove(&kb->destroy.link);
free(kb);
}
2020-07-23 15:03:13 -07:00
void
cleanupmon(struct wl_listener *listener, void *data)
{
struct wlr_output *wlr_output = data;
Monitor *m = wlr_output->data;
wl_list_remove(&m->destroy.link);
free(m);
}
2020-04-21 11:48:27 -07:00
void
createkeyboard(struct wlr_input_device *device)
{
struct xkb_context *context;
struct xkb_keymap *keymap;
Keyboard *kb;
kb = device->data = calloc(1, sizeof(*kb));
2020-04-23 19:16:01 -07:00
kb->device = device;
2020-04-21 17:09:36 -07:00
/* Prepare an XKB keymap and assign it to the keyboard. */
context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
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, repeat_rate, repeat_delay);
/* Here we set up listeners for keyboard events. */
2020-04-23 19:16:01 -07:00
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);
2020-07-23 15:13:42 -07:00
kb->destroy.notify = cleanupkeyboard;
wl_signal_add(&device->events.destroy, &kb->destroy);
wlr_seat_set_keyboard(seat, device);
/* And add the keyboard to our list of keyboards */
2020-04-23 19:16:01 -07:00
wl_list_insert(&keyboards, &kb->link);
}
2020-04-21 11:48:27 -07:00
void
createmon(struct wl_listener *listener, void *data)
2020-04-21 11:48:27 -07:00
{
2020-04-21 17:09:36 -07:00
/* This event is raised by the backend when a new output (aka a display or
2020-04-21 11:48:27 -07:00
* monitor) becomes available. */
struct wlr_output *wlr_output = data;
Monitor *m;
2020-05-02 22:41:37 -07:00
const MonitorRule *r;
2020-04-21 11:48:27 -07:00
/* 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. */
wlr_output_set_mode(wlr_output, wlr_output_preferred_mode(wlr_output));
2020-04-21 11:48:27 -07:00
/* Allocates and configures monitor state using configured rules */
m = wlr_output->data = calloc(1, sizeof(*m));
m->wlr_output = wlr_output;
2020-04-23 17:53:49 -07:00
m->tagset[0] = m->tagset[1] = 1;
2020-05-02 22:41:37 -07:00
for (r = monrules; r < END(monrules); r++) {
2020-05-03 09:39:48 -07:00
if (!r->name || strstr(wlr_output->name, r->name)) {
2020-05-02 22:41:37 -07:00
m->mfact = r->mfact;
m->nmaster = r->nmaster;
wlr_output_set_scale(wlr_output, r->scale);
wlr_xcursor_manager_load(cursor_mgr, r->scale);
m->lt[0] = m->lt[1] = r->lt;
wlr_output_set_transform(wlr_output, r->rr);
break;
}
}
2020-07-23 15:03:13 -07:00
/* Set up event listeners */
m->frame.notify = rendermon;
wl_signal_add(&wlr_output->events.frame, &m->frame);
2020-07-23 15:03:13 -07:00
m->destroy.notify = cleanupmon;
wl_signal_add(&wlr_output->events.destroy, &m->destroy);
2020-07-23 15:03:13 -07:00
wl_list_insert(&mons, &m->link);
wlr_output_enable(wlr_output, 1);
if (!wlr_output_commit(wlr_output))
return;
2020-04-21 11:48:27 -07:00
/* 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
2020-04-21 15:26:52 -07:00
* layout.
*
* The output layout utility automatically 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_layout_add_auto(output_layout, wlr_output);
sgeom = *wlr_output_layout_get_box(output_layout, NULL);
2020-04-21 11:48:27 -07:00
}
2020-04-21 12:53:35 -07:00
void
createnotify(struct wl_listener *listener, void *data)
2020-04-21 12:53:35 -07:00
{
/* 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;
Client *c;
2020-04-23 19:16:01 -07:00
if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL)
2020-04-21 12:53:35 -07:00
return;
/* Allocate a Client for this surface */
c = xdg_surface->data = calloc(1, sizeof(*c));
2020-04-21 12:53:35 -07:00
c->xdg_surface = xdg_surface;
2020-04-23 20:56:27 -07:00
c->bw = borderpx;
2020-04-21 12:53:35 -07:00
/* Tell the client not to try anything fancy */
wlr_xdg_toplevel_set_tiled(c->xdg_surface, WLR_EDGE_TOP |
WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT);
2020-04-21 12:53:35 -07:00
/* Listen to the various events it can emit */
c->map.notify = maprequest;
wl_signal_add(&xdg_surface->events.map, &c->map);
c->unmap.notify = unmapnotify;
wl_signal_add(&xdg_surface->events.unmap, &c->unmap);
c->destroy.notify = destroynotify;
wl_signal_add(&xdg_surface->events.destroy, &c->destroy);
}
void
createnotifyx11(struct wl_listener *listener, void *data)
{
struct wlr_xwayland_surface *xwayland_surface = data;
Client *c;
/* Allocate a Client for this surface */
c = xwayland_surface->data = calloc(1, sizeof(*c));
c->xwayland_surface = xwayland_surface;
c->isx11 = 1;
c->bw = borderpx;
/* Listen to the various events it can emit */
c->map.notify = maprequest;
wl_signal_add(&xwayland_surface->events.map, &c->map);
c->unmap.notify = unmapnotify;
wl_signal_add(&xwayland_surface->events.unmap, &c->unmap);
c->destroy.notify = destroynotify;
wl_signal_add(&xwayland_surface->events.destroy, &c->destroy);
}
2020-04-21 11:48:27 -07:00
void
createpointer(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(cursor, device);
}
void
createxdeco(struct wl_listener *listener, void *data)
{
struct wlr_xdg_toplevel_decoration_v1 *wlr_deco = data;
Decoration *d = wlr_deco->data = calloc(1, sizeof(*d));
wl_signal_add(&wlr_deco->events.request_mode, &d->request_mode);
d->request_mode.notify = getxdecomode;
wl_signal_add(&wlr_deco->events.destroy, &d->destroy);
d->destroy.notify = destroyxdeco;
getxdecomode(&d->request_mode, wlr_deco);
}
2020-04-21 11:48:27 -07:00
void
cursorframe(struct wl_listener *listener, void *data)
{
2020-04-21 11:48:27 -07:00
/* 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. */
/* Notify the client with pointer focus of the frame event. */
wlr_seat_pointer_notify_frame(seat);
}
2020-04-21 11:48:27 -07:00
void
destroynotify(struct wl_listener *listener, void *data)
{
2020-04-21 11:48:27 -07:00
/* Called when the surface is destroyed and should never be shown again. */
Client *c = wl_container_of(listener, c, destroy);
wl_list_remove(&c->map.link);
wl_list_remove(&c->unmap.link);
wl_list_remove(&c->destroy.link);
free(c);
}
void
destroyxdeco(struct wl_listener *listener, void *data)
{
struct wlr_xdg_toplevel_decoration_v1 *wlr_deco = data;
Decoration *d = wlr_deco->data;
wl_list_remove(&d->destroy.link);
wl_list_remove(&d->request_mode.link);
free(d);
}
2020-04-23 18:40:02 -07:00
Monitor *
dirtomon(int dir)
{
Monitor *m;
if (dir > 0) {
if (selmon->link.next == &mons)
return wl_container_of(mons.next, m, link);
return wl_container_of(selmon->link.next, m, link);
} else {
if (selmon->link.prev == &mons)
return wl_container_of(mons.prev, m, link);
return wl_container_of(selmon->link.prev, m, link);
}
}
void
focusclient(Client *c, struct wlr_surface *surface, int lift)
{
Client *sel = selclient();
struct wlr_keyboard *kb;
/* Previous and new xdg toplevel surfaces */
Client *ptl = sel;
Client *tl = c;
/* Previously focused surface */
struct wlr_surface *psurface = seat->keyboard_state.focused_surface;
if (c) {
/* assert(VISIBLEON(c, c->mon)); ? */
/* Use top-level wlr_surface if nothing more specific given */
if (!surface)
surface = WLR_SURFACE(c);
/* Focus the correct monitor (must come after selclient!) */
selmon = c->mon;
/* Move the client to the front of the focus stack */
wl_list_remove(&c->flink);
wl_list_insert(&fstack, &c->flink);
/* Also raise client in stacking order if requested */
if (lift) {
wl_list_remove(&c->slink);
wl_list_insert(&stack, &c->slink);
}
}
/*
* If the focused surface has changed, tell the seat to have the
* keyboard enter the new surface. wlroots will keep track of this and
* automatically send key events to the appropriate clients. If surface
* is NULL, we clear the focus instead.
*/
if (!surface) {
2020-06-15 07:22:25 -07:00
wlr_seat_keyboard_notify_clear_focus(seat);
} else if (surface != psurface) {
kb = wlr_seat_get_keyboard(seat);
wlr_seat_keyboard_notify_enter(seat, surface,
kb->keycodes, kb->num_keycodes, &kb->modifiers);
}
/*
* If the focused toplevel has changed, deactivate the old one and
* activate the new one. This lets the clients know to repaint
* accordingly, e.g. show/hide a caret.
*/
if (tl != ptl && ptl) {
if (ptl->isx11)
wlr_xwayland_surface_activate(ptl->xwayland_surface, 0);
else
wlr_xdg_toplevel_set_activated(ptl->xdg_surface, 0);
}
if (tl != ptl && tl) {
if (tl->isx11)
wlr_xwayland_surface_activate(tl->xwayland_surface, 1);
else
wlr_xdg_toplevel_set_activated(tl->xdg_surface, 1);
}
}
2020-04-23 18:40:02 -07:00
void
focusmon(const Arg *arg)
{
Monitor *m = dirtomon(arg->i);
if (m == selmon)
return;
selmon = m;
2020-05-03 09:23:39 -07:00
focusclient(lastfocused(), NULL, 1);
2020-04-23 18:40:02 -07:00
}
2020-04-21 11:48:27 -07:00
void
2020-04-22 22:47:15 -07:00
focusstack(const Arg *arg)
{
2020-04-22 22:47:15 -07:00
/* Focus the next or previous client (in tiling order) on selmon */
Client *c, *sel = selclient();
if (!sel)
2020-04-21 11:48:27 -07:00
return;
2020-04-22 22:47:15 -07:00
if (arg->i > 0) {
wl_list_for_each(c, &sel->link, link) {
if (&c->link == &clients)
continue; /* wrap past the sentinel node */
if (VISIBLEON(c, selmon))
break; /* found it */
}
} else {
wl_list_for_each_reverse(c, &sel->link, link) {
if (&c->link == &clients)
continue; /* wrap past the sentinel node */
if (VISIBLEON(c, selmon))
break; /* found it */
}
2020-04-22 22:38:09 -07:00
}
2020-04-22 22:47:15 -07:00
/* If only one client is visible on selmon, then c == sel */
focusclient(c, NULL, 1);
}
void
getxdecomode(struct wl_listener *listener, void *data)
{
struct wlr_xdg_toplevel_decoration_v1 *wlr_deco = data;
wlr_xdg_toplevel_decoration_v1_set_mode(wlr_deco,
WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
}
2020-04-23 18:14:11 -07:00
void
incnmaster(const Arg *arg)
{
selmon->nmaster = MAX(selmon->nmaster + arg->i, 0);
arrange(selmon);
2020-04-23 18:14:11 -07:00
}
2020-04-21 11:48:27 -07:00
void
inputdevice(struct wl_listener *listener, void *data)
{
/* This event is raised by the backend when a new input device becomes
* available. */
struct wlr_input_device *device = data;
uint32_t caps;
2020-04-21 11:48:27 -07:00
switch (device->type) {
case WLR_INPUT_DEVICE_KEYBOARD:
createkeyboard(device);
2020-04-21 11:48:27 -07:00
break;
case WLR_INPUT_DEVICE_POINTER:
createpointer(device);
2020-04-21 11:48:27 -07:00
break;
default:
2020-04-23 20:56:27 -07:00
/* XXX handle other input device types */
2020-04-21 11:48:27 -07:00
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. */
2020-04-23 20:20:44 -07:00
/* XXX do we actually require a cursor? */
caps = WL_SEAT_CAPABILITY_POINTER;
2020-04-23 19:16:01 -07:00
if (!wl_list_empty(&keyboards))
2020-04-21 11:48:27 -07:00
caps |= WL_SEAT_CAPABILITY_KEYBOARD;
wlr_seat_set_capabilities(seat, caps);
2020-04-21 11:48:27 -07:00
}
2020-05-02 12:32:23 -07:00
int
keybinding(uint32_t mods, xkb_keysym_t sym)
2020-04-21 11:48:27 -07:00
{
/*
* 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.
*/
2020-05-02 12:32:23 -07:00
int handled = 0;
2020-05-02 22:41:37 -07:00
const Key *k;
for (k = keys; k < END(keys); k++) {
if (CLEANMASK(mods) == CLEANMASK(k->mod) &&
sym == k->keysym && k->func) {
k->func(&k->arg);
2020-05-02 12:32:23 -07:00
handled = 1;
2020-04-21 11:48:27 -07:00
}
}
2020-04-21 11:48:27 -07:00
return handled;
}
void
keypress(struct wl_listener *listener, void *data)
{
/* This event is raised when a key is pressed or released. */
2020-04-23 19:16:01 -07:00
Keyboard *kb = wl_container_of(listener, kb, key);
2020-04-21 11:48:27 -07:00
struct wlr_event_keyboard_key *event = data;
int i;
2020-04-21 11:48:27 -07:00
/* Translate libinput keycode -> xkbcommon */
uint32_t keycode = event->keycode + 8;
/* Get a list of keysyms based on the keymap for this keyboard */
const xkb_keysym_t *syms;
int nsyms = xkb_state_key_get_syms(
2020-04-23 19:16:01 -07:00
kb->device->keyboard->xkb_state, keycode, &syms);
2020-04-21 11:48:27 -07:00
2020-05-02 12:32:23 -07:00
int handled = 0;
2020-04-23 19:16:01 -07:00
uint32_t mods = wlr_keyboard_get_modifiers(kb->device->keyboard);
/* On _press_, attempt to process a compositor keybinding. */
if (event->state == WLR_KEY_PRESSED)
for (i = 0; i < nsyms; i++)
handled = keybinding(mods, syms[i]) || handled;
2020-04-21 11:48:27 -07:00
if (!handled) {
2020-04-23 20:20:44 -07:00
/* Pass unhandled keycodes along to the client. */
2020-04-23 19:16:01 -07:00
wlr_seat_set_keyboard(seat, kb->device);
2020-04-21 11:48:27 -07:00
wlr_seat_keyboard_notify_key(seat, event->time_msec,
event->keycode, event->state);
}
}
void
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. */
2020-04-23 19:16:01 -07:00
Keyboard *kb = wl_container_of(listener, kb, modifiers);
2020-04-21 11:48:27 -07:00
/*
* 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.
*/
2020-04-23 19:16:01 -07:00
wlr_seat_set_keyboard(seat, kb->device);
2020-04-21 11:48:27 -07:00
/* Send modifiers to the client. */
wlr_seat_keyboard_notify_modifiers(seat,
2020-04-23 19:16:01 -07:00
&kb->device->keyboard->modifiers);
2020-04-21 11:48:27 -07:00
}
2020-07-23 11:30:25 -07:00
void
killclient(const Arg *arg)
{
Client *sel = selclient();
if (!sel)
return;
if (sel->isx11)
wlr_xwayland_surface_close(sel->xwayland_surface);
else
wlr_xdg_toplevel_send_close(sel->xdg_surface);
}
2020-05-03 09:23:39 -07:00
Client *
lastfocused(void)
{
Client *c;
wl_list_for_each(c, &fstack, flink)
if (VISIBLEON(c, selmon))
return c;
return NULL;
}
2020-04-21 11:48:27 -07:00
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);
2020-05-02 22:48:12 -07:00
/* Insert this client into client lists. */
wl_list_insert(&clients, &c->link);
wl_list_insert(&fstack, &c->flink);
wl_list_insert(&stack, &c->slink);
if (c->isx11) {
c->geom.x = c->xwayland_surface->x;
c->geom.y = c->xwayland_surface->y;
c->geom.width = c->xwayland_surface->width + 2 * c->bw;
c->geom.height = c->xwayland_surface->height + 2 * c->bw;
} else {
wlr_xdg_surface_get_geometry(c->xdg_surface, &c->geom);
c->geom.width += 2 * c->bw;
c->geom.height += 2 * c->bw;
}
2020-05-02 22:48:12 -07:00
/* Set initial monitor, tags, floating status, and focus */
applyrules(c);
2020-04-21 11:48:27 -07:00
}
void
motionabsolute(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 wlr_event_pointer_motion_absolute *event = data;
wlr_cursor_warp_absolute(cursor, event->device, event->x, event->y);
motionnotify(event->time_msec);
2020-04-21 11:48:27 -07:00
}
void
motionnotify(uint32_t time)
{
double sx = 0, sy = 0;
struct wlr_surface *surface = NULL;
Client *c;
/* Update selmon (even while dragging a window) */
2020-04-23 18:29:26 -07:00
if (sloppyfocus)
selmon = xytomon(cursor->x, cursor->y);
2020-04-21 17:09:36 -07:00
/* If we are currently grabbing the mouse, handle and return */
if (cursor_mode == CurMove) {
2020-04-21 12:59:32 -07:00
/* Move the grabbed client to the new position. */
2020-04-30 09:33:32 -07:00
resize(grabc, cursor->x - grabcx, cursor->y - grabcy,
2020-04-26 20:12:08 -07:00
grabc->geom.width, grabc->geom.height, 1);
return;
} else if (cursor_mode == CurResize) {
2020-04-26 20:12:08 -07:00
resize(grabc, grabc->geom.x, grabc->geom.y,
2020-04-26 20:19:48 -07:00
cursor->x - grabc->geom.x,
cursor->y - grabc->geom.y, 1);
return;
}
/* Otherwise, find the client under the pointer and send the event along. */
if ((c = xytoclient(cursor->x, cursor->y))) {
if (c->isx11)
surface = wlr_surface_surface_at(c->xwayland_surface->surface,
cursor->x - c->geom.x - c->bw,
cursor->y - c->geom.y - c->bw, &sx, &sy);
else
surface = wlr_xdg_surface_surface_at(c->xdg_surface,
cursor->x - c->geom.x - c->bw,
cursor->y - c->geom.y - c->bw, &sx, &sy);
}
2020-05-02 13:22:07 -07:00
/* If there's no client surface under the cursor, set the cursor image to a
2020-04-23 19:16:01 -07:00
* default. This is what makes the cursor image appear when you move it
2020-05-02 13:22:07 -07:00
* off of a client or over its border. */
if (!surface)
2020-04-23 20:38:06 -07:00
wlr_xcursor_manager_set_cursor_image(cursor_mgr,
"left_ptr", cursor);
2020-04-23 18:29:26 -07:00
2020-04-26 12:47:23 -07:00
pointerfocus(c, surface, sx, sy, time);
}
2020-04-21 11:48:27 -07:00
void
motionrelative(struct wl_listener *listener, void *data)
{
/* This event is forwarded by the cursor when a pointer emits a _relative_
* pointer motion event (i.e. a delta) */
struct wlr_event_pointer_motion *event = data;
/* The cursor doesn't move unless we tell it to. The cursor automatically
* handles constraining the motion to the output layout, as well as any
* special configuration applied for the specific input device which
* generated the event. You can pass NULL for the device if you want to move
* the cursor around without any input. */
wlr_cursor_move(cursor, event->device,
event->delta_x, event->delta_y);
motionnotify(event->time_msec);
}
2020-04-21 11:48:27 -07:00
void
2020-04-30 08:25:37 -07:00
moveresize(const Arg *arg)
{
2020-05-03 09:31:55 -07:00
grabc = xytoclient(cursor->x, cursor->y);
2020-04-23 20:26:43 -07:00
if (!grabc)
2020-04-21 11:48:27 -07:00
return;
2020-04-23 20:26:43 -07:00
/* Float the window and tell motionnotify to grab it */
setfloating(grabc, 1);
2020-04-30 08:25:37 -07:00
switch (cursor_mode = arg->ui) {
case CurMove:
2020-04-30 09:33:32 -07:00
grabcx = cursor->x - grabc->geom.x;
grabcy = cursor->y - grabc->geom.y;
2020-04-30 08:25:37 -07:00
wlr_xcursor_manager_set_cursor_image(cursor_mgr, "fleur", cursor);
break;
case CurResize:
/* Doesn't work for X11 output - the next absolute motion event
* returns the cursor to where it started */
wlr_cursor_warp_closest(cursor, NULL,
grabc->geom.x + grabc->geom.width,
grabc->geom.y + grabc->geom.height);
wlr_xcursor_manager_set_cursor_image(cursor_mgr,
"bottom_right_corner", cursor);
break;
}
}
2020-04-23 22:12:11 -07:00
void
2020-04-26 12:47:23 -07:00
pointerfocus(Client *c, struct wlr_surface *surface, double sx, double sy,
uint32_t time)
2020-04-23 22:12:11 -07:00
{
/* Use top level surface if nothing more specific given */
if (c && !surface)
surface = WLR_SURFACE(c);
2020-04-26 12:47:23 -07:00
/* If surface is already focused, only notify of motion */
if (surface && surface == seat->pointer_state.focused_surface) {
wlr_seat_pointer_notify_motion(seat, time, sx, sy);
return;
}
2020-04-23 22:12:11 -07:00
/* If surface is NULL, clear pointer focus, otherwise let the client
* know that the mouse cursor has entered one of its surfaces. */
if (!surface) {
wlr_seat_pointer_notify_clear_focus(seat);
return;
}
2020-04-26 12:47:23 -07:00
wlr_seat_pointer_notify_enter(seat, surface, sx, sy);
2020-04-23 22:12:11 -07:00
/* If keyboard focus follows mouse, enforce that */
if (sloppyfocus)
focusclient(c, surface, 0);
2020-04-23 22:12:11 -07:00
}
2020-04-21 11:48:27 -07:00
void
quit(const Arg *arg)
{
2020-04-23 19:16:01 -07:00
wl_display_terminate(dpy);
}
2020-04-21 11:48:27 -07:00
void
render(struct wlr_surface *surface, int sx, int sy, void *data)
{
/* This function is called for every surface that needs to be rendered. */
struct render_data *rdata = data;
struct wlr_output *output = rdata->output;
double ox = 0, oy = 0;
struct wlr_box obox;
float matrix[9];
enum wl_output_transform transform;
/* We first obtain a wlr_texture, which is a GPU resource. wlroots
* automatically handles negotiating these with the client. The underlying
* resource could be an opaque handle passed from the client, or the client
* 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);
2020-04-23 19:16:01 -07:00
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
* have layout coordinates of 2000,100. We need to translate that to
* output-local coordinates, or (2000 - 1920). */
2020-05-03 10:41:15 -07:00
wlr_output_layout_output_coords(output_layout, output, &ox, &oy);
/* We also have to apply the scale factor for HiDPI outputs. This is only
* part of the puzzle, dwl does not fully support HiDPI. */
obox.x = ox + rdata->x + sx;
obox.y = oy + rdata->y + sy;
obox.width = surface->current.width;
obox.height = surface->current.height;
scalebox(&obox, output->scale);
/*
2020-04-21 17:09:36 -07:00
* Those familiar with OpenGL are also familiar with the role of matrices
* in graphics programming. We need to prepare a matrix to render the
* client with. wlr_matrix_project_box is a helper which takes a box with
* a desired x, y coordinates, width and height, and an output geometry,
* then prepares an orthographic projection and multiplies the necessary
* transforms to produce a model-view-projection matrix.
*
* Naturally you can do this any way you like, for example to make a 3D
* compositor.
*/
transform = wlr_output_transform_invert(surface->current.transform);
wlr_matrix_project_box(matrix, &obox, transform, 0,
output->transform_matrix);
/* This takes our matrix, the texture, and an alpha, and performs the actual
* rendering on the GPU. */
2020-04-23 19:16:01 -07:00
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. */
wlr_surface_send_frame_done(surface, rdata->when);
}
void
renderclients(Monitor *m, struct timespec *now)
{
Client *c;
double ox, oy;
int i, w, h;
struct render_data rdata;
struct wlr_box *borders;
struct wlr_surface *surface;
/* Each subsequent window we render is rendered on top of the last. Because
* our stacking list is ordered front-to-back, we iterate over it backwards. */
wl_list_for_each_reverse(c, &stack, slink) {
2020-04-26 18:00:06 -07:00
/* Only render visible clients which show on this monitor */
if (!VISIBLEON(c, c->mon) || !wlr_output_layout_intersects(
2020-04-26 20:12:08 -07:00
output_layout, m->wlr_output, &c->geom))
continue;
surface = WLR_SURFACE(c);
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 */
};
for (i = 0; i < 4; i++) {
scalebox(&borders[i], m->wlr_output->scale);
wlr_render_rect(drw, &borders[i], bordercolor,
m->wlr_output->transform_matrix);
}
/* This calls our render function for each surface among the
* xdg_surface's toplevel and popups. */
rdata.output = m->wlr_output,
rdata.when = now,
rdata.x = c->geom.x + c->bw,
rdata.y = c->geom.y + c->bw;
if (c->isx11)
wlr_surface_for_each_surface(c->xwayland_surface->surface, render, &rdata);
else
wlr_xdg_surface_for_each_surface(c->xdg_surface, render, &rdata);
}
}
2020-04-21 11:48:27 -07:00
void
rendermon(struct wl_listener *listener, void *data)
{
/* This function is called every time an output is ready to display a frame,
* generally at the output's refresh rate (e.g. 60Hz). */
Monitor *m = wl_container_of(listener, m, frame);
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
/* wlr_output_attach_render makes the OpenGL context current. */
2020-04-23 19:16:01 -07:00
if (!wlr_output_attach_render(m->wlr_output, NULL))
return;
/* Begin the renderer (calls glViewport and some other GL sanity checks) */
2020-04-23 19:16:01 -07:00
wlr_renderer_begin(drw, m->wlr_output->width, m->wlr_output->height);
wlr_renderer_clear(drw, rootcolor);
renderclients(m, &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
* efficient. However, not all hardware supports hardware cursors. For this
* reason, wlroots provides a software fallback, which we ask it to render
* here. wlr_cursor handles configuring hardware vs software cursors for you,
* and this function is a no-op when hardware cursors are in use. */
wlr_output_render_software_cursors(m->wlr_output, NULL);
/* Conclude rendering and swap the buffers, showing the final frame
* on-screen. */
2020-04-23 19:16:01 -07:00
wlr_renderer_end(drw);
wlr_output_commit(m->wlr_output);
}
void
resize(Client *c, int x, int y, int w, int h, int interact)
{
2020-04-26 19:42:45 -07:00
/*
* 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 wlr_box *bbox = interact ? &sgeom : &c->mon->w;
2020-04-26 20:12:08 -07:00
c->geom.x = x;
c->geom.y = y;
c->geom.width = w;
c->geom.height = h;
applybounds(c, bbox);
2020-04-26 11:18:20 -07:00
/* wlroots makes this a no-op if size hasn't changed */
if (c->isx11)
wlr_xwayland_surface_configure(c->xwayland_surface,
c->geom.x, c->geom.y,
c->geom.width - 2 * c->bw, c->geom.height - 2 * c->bw);
else
wlr_xdg_toplevel_set_size(c->xdg_surface,
c->geom.width - 2 * c->bw, c->geom.height - 2 * c->bw);
}
2020-04-21 16:57:04 -07:00
void
run(char *startup_cmd)
{
pid_t startup_pid = -1;
/* Add a Unix socket to the Wayland display. */
2020-04-23 19:16:01 -07:00
const char *socket = wl_display_add_socket_auto(dpy);
2020-04-21 16:57:04 -07:00
if (!socket) {
perror("startup: display_add_socket_auto");
2020-04-21 16:57:04 -07:00
wlr_backend_destroy(backend);
2020-04-23 20:20:54 -07:00
exit(EXIT_FAILURE);
2020-04-21 16:57:04 -07:00
}
/* Start the backend. This will enumerate outputs and inputs, become the DRM
* master, etc */
if (!wlr_backend_start(backend)) {
perror("startup: backend_start");
2020-04-21 16:57:04 -07:00
wlr_backend_destroy(backend);
2020-04-23 19:16:01 -07:00
wl_display_destroy(dpy);
2020-04-23 20:20:54 -07:00
exit(EXIT_FAILURE);
2020-04-21 16:57:04 -07:00
}
/* Now that outputs are initialized, choose initial selmon based on
* cursor position, and set default cursor image */
selmon = xytomon(cursor->x, cursor->y);
/* XXX hack to get cursor to display in its initial location (100, 100)
2020-04-23 21:47:52 -07:00
* instead of (0, 0) and then jumping. still may not be fully
* initialized, as the image/coordinates are not transformed for the
* monitor when displayed here */
wlr_cursor_warp_closest(cursor, NULL, cursor->x, cursor->y);
wlr_xcursor_manager_set_cursor_image(cursor_mgr, "left_ptr", cursor);
2020-04-21 16:57:04 -07:00
/* Set the WAYLAND_DISPLAY environment variable to our socket and run the
* startup command if requested. */
2020-05-02 12:32:23 -07:00
setenv("WAYLAND_DISPLAY", socket, 1);
2020-04-21 16:57:04 -07:00
if (startup_cmd) {
startup_pid = fork();
if (startup_pid < 0) {
perror("startup: fork");
2020-04-23 19:16:01 -07:00
wl_display_destroy(dpy);
2020-04-23 20:20:54 -07:00
exit(EXIT_FAILURE);
2020-04-21 16:57:04 -07:00
}
if (startup_pid == 0) {
execl("/bin/sh", "/bin/sh", "-c", startup_cmd, (void *)NULL);
perror("startup: execl");
2020-04-23 19:16:01 -07:00
wl_display_destroy(dpy);
2020-04-23 20:20:54 -07:00
exit(EXIT_FAILURE);
2020-04-21 16:57:04 -07:00
}
}
/* 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);
2020-04-23 19:16:01 -07:00
wl_display_run(dpy);
2020-04-21 16:57:04 -07:00
if (startup_cmd) {
kill(startup_pid, SIGTERM);
waitpid(startup_pid, NULL, 0);
}
}
void
scalebox(struct wlr_box *box, float scale)
{
box->x *= scale;
box->y *= scale;
box->width *= scale;
box->height *= scale;
}
Client *
selclient(void)
{
Client *c = wl_container_of(fstack.next, c, flink);
if (wl_list_empty(&fstack) || !VISIBLEON(c, selmon))
return NULL;
return c;
}
2020-04-21 11:48:27 -07:00
void
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;
2020-04-23 20:38:06 -07:00
/* If we're "grabbing" the cursor, don't use the client's image */
/* XXX still need to save the provided surface to restore later */
if (cursor_mode != CurNormal)
return;
2020-04-21 11:48:27 -07:00
/* This can be sent by any client, so we check to make sure this one is
2020-04-23 19:16:01 -07:00
* 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,
2020-04-21 11:48:27 -07:00
event->hotspot_x, event->hotspot_y);
}
void
setfloating(Client *c, int floating)
{
if (c->isfloating == floating)
return;
c->isfloating = floating;
arrange(c->mon);
}
2020-04-22 09:20:08 -07:00
void
setlayout(const Arg *arg)
{
if (!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])
selmon->sellt ^= 1;
if (arg && arg->v)
selmon->lt[selmon->sellt] = (Layout *)arg->v;
/* XXX change layout symbol? */
arrange(selmon);
2020-04-22 09:20:08 -07:00
}
2020-04-23 18:14:11 -07:00
/* arg > 1.0 will set mfact absolutely */
void
setmfact(const Arg *arg)
{
float f;
if (!arg || !selmon->lt[selmon->sellt]->arrange)
return;
f = arg->f < 1.0 ? arg->f + selmon->mfact : arg->f - 1.0;
if (f < 0.1 || f > 0.9)
return;
selmon->mfact = f;
arrange(selmon);
2020-04-23 18:14:11 -07:00
}
2020-04-26 17:48:28 -07:00
void
2020-05-02 22:44:16 -07:00
setmon(Client *c, Monitor *m, unsigned int newtags)
2020-04-26 17:48:28 -07:00
{
int hadfocus;
Monitor *oldmon = c->mon;
struct wlr_surface *surface = WLR_SURFACE(c);
if (oldmon == m)
return;
hadfocus = (c == selclient());
2020-04-26 17:48:28 -07:00
c->mon = m;
/* XXX leave/enter is not optimal but works */
if (oldmon) {
wlr_surface_send_leave(surface, oldmon->wlr_output);
arrange(oldmon);
}
2020-04-26 17:48:28 -07:00
if (m) {
/* Make sure window actually overlaps with the monitor */
applybounds(c, &m->m);
wlr_surface_send_enter(surface, m->wlr_output);
2020-05-02 22:44:16 -07:00
c->tags = newtags ? newtags : m->tagset[m->seltags]; /* assign tags of target monitor */
arrange(m);
2020-04-26 17:48:28 -07:00
}
/* Focus can change if c is the top of selmon before or after */
if (hadfocus || c == selclient())
2020-05-03 09:23:39 -07:00
focusclient(lastfocused(), NULL, 1);
2020-04-26 17:48:28 -07:00
}
2020-05-09 20:45:22 -07:00
void
setpsel(struct wl_listener *listener, void *data)
{
/* This event is raised by the seat when a client wants to set the selection,
* usually when the user copies something. wlroots allows compositors to
* ignore such requests if they so choose, but in dwl we always honor
*/
struct wlr_seat_request_set_primary_selection_event *event = data;
wlr_seat_set_primary_selection(seat, event->source, event->serial);
}
void
setsel(struct wl_listener *listener, void *data)
{
/* This event is raised by the seat when a client wants to set the selection,
* usually when the user copies something. wlroots allows compositors to
* ignore such requests if they so choose, but in dwl we always honor
*/
struct wlr_seat_request_set_selection_event *event = data;
wlr_seat_set_selection(seat, event->source, event->serial);
}
2020-04-21 11:48:27 -07:00
void
2020-04-21 16:57:04 -07:00
setup(void)
{
/* 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
* if an X11 server is running. The NULL argument here optionally allows you
* to pass in a custom renderer if wlr_renderer doesn't meet your needs. The
* 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). */
2020-04-23 19:16:01 -07:00
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. */
2020-04-23 19:16:01 -07:00
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. Note that
* the clients cannot set the selection directly without compositor approval,
* see the setsel() function. */
compositor = wlr_compositor_create(dpy, drw);
wlr_screencopy_manager_v1_create(dpy);
2020-04-23 19:16:01 -07:00
wlr_data_device_manager_create(dpy);
2020-05-09 20:45:22 -07:00
wlr_primary_selection_v1_device_manager_create(dpy);
/* Creates an output layout, which a wlroots utility for working with an
* arrangement of screens in a physical layout. */
output_layout = wlr_output_layout_create();
2020-05-09 21:01:30 -07:00
wlr_xdg_output_manager_v1_create(dpy, output_layout);
/* Configure a listener to be notified when new outputs are available on the
* backend. */
wl_list_init(&mons);
wl_signal_add(&backend->events.new_output, &new_output);
/* Set up our client lists and the xdg-shell. The xdg-shell is a
* Wayland protocol which is used for application windows. For more
* detail on shells, refer to the article:
*
* https://drewdevault.com/2018/07/29/Wayland-shells.html
*/
wl_list_init(&clients);
wl_list_init(&fstack);
wl_list_init(&stack);
2020-04-23 19:16:01 -07:00
xdg_shell = wlr_xdg_shell_create(dpy);
2020-05-09 08:05:34 -07:00
wl_signal_add(&xdg_shell->events.new_surface, &new_xdg_surface);
/* Use xdg_decoration protocol to negotiate server-side decorations */
xdeco_mgr = wlr_xdg_decoration_manager_v1_create(dpy);
wl_signal_add(&xdeco_mgr->events.new_toplevel_decoration, &new_xdeco);
/*
* Creates a cursor, which is a wlroots utility for tracking the cursor
* image shown on screen.
*/
cursor = wlr_cursor_create();
wlr_cursor_attach_output_layout(cursor, output_layout);
/* Creates an xcursor manager, another wlroots utility which loads up
* Xcursor themes to source cursor images from and makes sure that cursor
* images are available at all scale factors on the screen (necessary for
* HiDPI support). Scaled cursors will be loaded with each output. */
cursor_mgr = wlr_xcursor_manager_create(NULL, 24);
/*
* wlr_cursor *only* displays an image on screen. It does not move around
* when the pointer moves. However, we can attach input devices to it, and
* it will generate aggregate events for all of them. In these events, we
* can choose how we want to process them, forwarding them to clients and
* moving the cursor around. More detail on this process is described in my
* input handling blog post:
*
* https://drewdevault.com/2018/07/17/Input-handling-in-wlroots.html
*
* And more comments are sprinkled throughout the notify functions above.
*/
wl_signal_add(&cursor->events.motion, &cursor_motion);
wl_signal_add(&cursor->events.motion_absolute,
&cursor_motion_absolute);
wl_signal_add(&cursor->events.button, &cursor_button);
wl_signal_add(&cursor->events.axis, &cursor_axis);
wl_signal_add(&cursor->events.frame, &cursor_frame);
/*
* Configures a seat, which is a single "seat" at which a user sits and
* operates the computer. This conceptually includes up to one keyboard,
* pointer, touch, and drawing tablet device. We also rig up a listener to
* let us know when new input devices are available on the backend.
*/
wl_list_init(&keyboards);
wl_signal_add(&backend->events.new_input, &new_input);
2020-04-23 19:16:01 -07:00
seat = wlr_seat_create(dpy, "seat0");
wl_signal_add(&seat->events.request_set_cursor,
&request_cursor);
wl_signal_add(&seat->events.request_set_selection,
&request_set_sel);
2020-05-09 20:45:22 -07:00
wl_signal_add(&seat->events.request_set_primary_selection,
&request_set_psel);
/*
* Initialise the XWayland X server.
* It will be started when the first X client is started.
*/
xwayland = wlr_xwayland_create(dpy, compositor, true);
if (xwayland) {
wl_signal_add(&xwayland->events.new_surface, &new_xwayland_surface);
setenv("DISPLAY", xwayland->display_name, true);
} else {
fprintf(stderr, "failed to setup XWayland X server, continuing without it\n");
}
2020-04-21 16:57:04 -07:00
}
2020-04-21 16:57:04 -07:00
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);
}
2020-04-21 16:57:04 -07:00
}
2020-04-23 17:53:49 -07:00
void
tag(const Arg *arg)
{
Client *sel = selclient();
if (sel && arg->ui & TAGMASK) {
sel->tags = arg->ui & TAGMASK;
2020-05-03 09:23:39 -07:00
focusclient(lastfocused(), NULL, 1);
arrange(selmon);
2020-04-23 17:53:49 -07:00
}
}
2020-04-23 18:40:02 -07:00
void
tagmon(const Arg *arg)
{
Client *sel = selclient();
if (!sel)
return;
2020-05-02 22:44:16 -07:00
setmon(sel, dirtomon(arg->i), 0);
2020-04-23 18:40:02 -07:00
}
void
tile(Monitor *m)
{
unsigned int i, n = 0, h, mw, my, ty;
Client *c;
2020-05-03 09:23:51 -07:00
wl_list_for_each(c, &clients, link)
2020-04-23 17:23:57 -07:00
if (VISIBLEON(c, m) && !c->isfloating)
n++;
if (n == 0)
return;
if (n > m->nmaster)
2020-04-26 10:41:33 -07:00
mw = m->nmaster ? m->w.width * m->mfact : 0;
else
2020-04-26 10:41:33 -07:00
mw = m->w.width;
i = my = ty = 0;
wl_list_for_each(c, &clients, link) {
2020-04-23 17:23:57 -07:00
if (!VISIBLEON(c, m) || c->isfloating)
continue;
if (i < m->nmaster) {
2020-04-26 10:41:33 -07:00
h = (m->w.height - my) / (MIN(n, m->nmaster) - i);
2020-04-26 11:18:20 -07:00
resize(c, m->w.x, m->w.y + my, mw, h, 0);
2020-04-26 20:12:08 -07:00
my += c->geom.height;
} else {
2020-04-26 10:41:33 -07:00
h = (m->w.height - ty) / (n - i);
2020-04-26 11:18:20 -07:00
resize(c, m->w.x + mw, m->w.y + ty, m->w.width - mw, h, 0);
2020-04-26 20:12:08 -07:00
ty += c->geom.height;
}
i++;
}
}
2020-04-23 17:23:57 -07:00
void
togglefloating(const Arg *arg)
{
Client *sel = selclient();
if (!sel)
return;
/* return if fullscreen */
setfloating(sel, !sel->isfloating /* || sel->isfixed */);
2020-04-23 17:23:57 -07:00
}
2020-04-23 18:02:17 -07:00
void
toggletag(const Arg *arg)
{
unsigned int newtags;
Client *sel = selclient();
if (!sel)
return;
newtags = sel->tags ^ (arg->ui & TAGMASK);
if (newtags) {
sel->tags = newtags;
2020-05-03 09:23:39 -07:00
focusclient(lastfocused(), NULL, 1);
arrange(selmon);
2020-04-23 18:02:17 -07:00
}
}
void
toggleview(const Arg *arg)
{
unsigned int newtagset = selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK);
if (newtagset) {
selmon->tagset[selmon->seltags] = newtagset;
2020-05-03 09:23:39 -07:00
focusclient(lastfocused(), NULL, 1);
arrange(selmon);
2020-04-23 18:02:17 -07:00
}
}
2020-04-21 16:57:04 -07:00
void
unmapnotify(struct wl_listener *listener, void *data)
{
/* Called when the surface is unmapped, and should no longer be shown. */
Client *c = wl_container_of(listener, c, unmap);
2020-05-02 22:44:16 -07:00
setmon(c, NULL, 0);
wl_list_remove(&c->link);
wl_list_remove(&c->flink);
wl_list_remove(&c->slink);
2020-04-21 16:57:04 -07:00
}
2020-04-23 17:53:49 -07:00
void
view(const Arg *arg)
{
if ((arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
return;
selmon->seltags ^= 1; /* toggle sel tagset */
if (arg->ui & TAGMASK)
selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
2020-05-03 09:23:39 -07:00
focusclient(lastfocused(), NULL, 1);
arrange(selmon);
2020-04-23 17:53:49 -07:00
}
2020-04-21 16:57:04 -07:00
Client *
2020-05-03 09:31:55 -07:00
xytoclient(double x, double y)
2020-04-21 16:57:04 -07:00
{
2020-05-03 09:31:55 -07:00
/* Find the topmost visible client (if any) at point (x, y), including
* borders. This relies on stack being ordered from top to bottom. */
2020-04-21 16:57:04 -07:00
Client *c;
2020-05-03 09:31:55 -07:00
wl_list_for_each(c, &stack, slink)
if (VISIBLEON(c, c->mon) && wlr_box_contains_point(&c->geom, x, y))
2020-04-21 16:57:04 -07:00
return c;
return NULL;
}
Monitor *
xytomon(double x, double y)
{
struct wlr_output *o = wlr_output_layout_output_at(output_layout, x, y);
return o ? o->data : NULL;
}
2020-07-24 08:12:41 -07:00
void
zoom(const Arg *arg)
{
unsigned int n = 0;
Client *c, *sel = selclient();
if (!sel || !selmon->lt[selmon->sellt]->arrange || sel->isfloating)
return;
wl_list_for_each(c, &clients, link)
if (VISIBLEON(c, selmon) && !c->isfloating) {
if (++n == 1 && c == sel)
sel = NULL;
else if (n == 2) {
if (!sel)
sel = c;
break;
}
}
if (n == 1)
return;
wl_list_remove(&sel->link);
wl_list_insert(&clients, &sel->link);
focusclient(sel, NULL, 1);
arrange(selmon);
}
2020-04-21 16:57:04 -07:00
int
main(int argc, char *argv[])
{
char *startup_cmd = NULL;
2020-04-26 19:32:44 -07:00
enum wlr_log_importance loglevel = WLR_ERROR;
2020-04-21 16:57:04 -07:00
int c;
2020-04-26 19:32:44 -07:00
while ((c = getopt(argc, argv, "qvds:h")) != -1) {
2020-04-21 16:57:04 -07:00
switch (c) {
2020-04-26 19:32:44 -07:00
case 'q':
loglevel = WLR_SILENT;
break;
case 'v':
loglevel = WLR_INFO;
break;
case 'd':
loglevel = WLR_DEBUG;
break;
2020-04-21 16:57:04 -07:00
case 's':
startup_cmd = optarg;
break;
default:
2020-06-03 13:05:12 -07:00
goto usage;
2020-04-21 16:57:04 -07:00
}
}
2020-06-03 13:05:12 -07:00
if (optind < argc)
goto usage;
2020-04-26 19:32:44 -07:00
wlr_log_init(loglevel, NULL);
2020-04-21 16:57:04 -07:00
// 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);
}
2020-04-21 16:57:04 -07:00
/* The Wayland display is managed by libwayland. It handles accepting
* clients from the Unix socket, manging Wayland globals, and so on. */
2020-04-23 19:16:01 -07:00
dpy = wl_display_create();
2020-04-21 16:57:04 -07:00
setup();
run(startup_cmd);
/* Once wl_display_run returns, we shut down the server. */
wlr_xwayland_destroy(xwayland);
2020-04-23 19:16:01 -07:00
wl_display_destroy_clients(dpy);
wl_display_destroy(dpy);
2020-07-23 14:36:20 -07:00
wlr_xcursor_manager_destroy(cursor_mgr);
2020-07-23 14:34:50 -07:00
wlr_cursor_destroy(cursor);
wlr_output_layout_destroy(output_layout);
2020-07-23 14:36:20 -07:00
2020-04-23 20:20:54 -07:00
return EXIT_SUCCESS;
2020-06-03 13:05:12 -07:00
usage:
printf("Usage: %s [-qvd] [-s startup command]\n", argv[0]);
return EXIT_FAILURE;
}