st

/* See LICENSE for license details. */
#ifndef _GNU_SOURCE
#define _GNU_SOURCE		/* memfd_create, pipe2 */
#endif

#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <locale.h>
#include <math.h>
#include <poll.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <time.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/timerfd.h>

#include <linux/input-event-codes.h>
#include <fontconfig/fontconfig.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include <xkbcommon/xkbcommon.h>
#include <xkbcommon/xkbcommon-compose.h>

#include <wayland-client.h>
#include "xdg-shell-client-protocol.h"
#include "fractional-scale-client-protocol.h"
#include "viewporter-client-protocol.h"
#include "cursor-shape-client-protocol.h"
#include "system-bell-client-protocol.h"
#include "primary-selection-client-protocol.h"
#include "text-input-client-protocol.h"

#include "st.h"
#include "win.h"
#include "hb.h"

char *argv0;
#include "arg.h"

/* Types used by config.h. */
typedef struct {
	uint mod;
	KeySym keysym;
	void (*func)(const Arg *);
	const Arg arg;
} Shortcut;

typedef struct {
	uint mod;
	uint button;
	void (*func)(const Arg *);
	const Arg arg;
	uint release;
} MouseShortcut;

typedef struct {
	KeySym k;
	uint mask;
	char *s;
	/* three-valued logic variables: 0 indifferent, 1 on, -1 off */
	signed char appkey;    /* application keypad */
	signed char appcursor; /* application cursor */
} Key;

static void clippaste(const Arg *);
static void numlock(const Arg *);
static void selpaste(const Arg *);
static void zoom(const Arg *);
static void zoomabs(const Arg *);
static void zoomreset(const Arg *);
static void ttysend(const Arg *) __attribute__((unused));

#include "config.h"

#define IS_SET(flag)		((win.mode & (flag)) != 0)
/* How long a printable key waits for an input method to claim it (ms). */
#define IMEWAIT 20
#define TRUERED(x)		(((x) & 0xff0000) >> 16)
#define TRUEGREEN(x)		(((x) & 0xff00) >> 8)
#define TRUEBLUE(x)		((x) & 0xff)

/* All geometry in this backend is in device (buffer) pixels, except for the
 * logical window size we get from xdg-shell. */
typedef struct {
	int tw, th;	/* terminal area in buffer pixels */
	int w, h;	/* buffer size */
	int lw, lh;	/* logical window size */
	int hborderpx, vborderpx;
	int ch;		/* cell height */
	int cw;		/* cell width */
	int mode;	/* window state/mode flags */
	int cursor;	/* cursor style */
} TermWindow;

typedef struct {
	char *primary;
	struct timespec tclick1;
	struct timespec tclick2;
} Selection;

typedef struct {
	FT_Face face;
	FcPattern *pattern;
	int height, width;
	int ascent, descent;
	int badslant, badweight;
	double pxsize;		/* device pixels */
	double logicalpx;	/* logical pixels */
} Font;

typedef struct {
	uint32_t *col;
	size_t collen;
	Font font, bfont, ifont, ibfont;
} DC;

typedef struct {
	FT_Face face;
	int flags;
	Rune unicodep;
} Fontcache;

typedef struct {
	int type;		/* 0 motion, 1 press, 2 release */
	int x, y;		/* buffer pixels */
	uint button;
	uint state;
	uint32_t serial;
	uint32_t time;
} MouseEvent;

typedef struct {
	struct wl_data_offer *data;
	struct zwp_primary_selection_offer_v1 *primary;
	char **mimes;
	int nmimes;
} Offer;

typedef struct {
	struct wl_data_source *data;
	struct zwp_primary_selection_source_v1 *primary;
	char *text;
} Source;

typedef struct Transfer {
	struct Transfer *next;
	int fd;
	int writing;
	char *buf;
	size_t len, off, cap;
} Transfer;

/* Two buffers, alternating.  KWin keeps the current buffer alive as the
 * window content and only releases it once another one is committed, so a
 * single buffer would stall after the first frame. */
static struct {
	struct wl_buffer *buffer[2];
	uint32_t *data[2];
	uint32_t *target;	/* buffer currently being drawn into */
	int stride;		/* bytes */
	size_t size;
	int busy[2];
	int cur;		/* index of the buffer we draw into next */
	int drawn;
} fb;

/* Globals */
static DC dc;
static TermWindow win;
static Selection xsel;
static GlyphSpec *specbuf = NULL;

static FT_Library ftlib;
static Fontcache *frc = NULL;
static int frclen = 0;
static int frccap = 0;
static char *usedfont = NULL;
static double usedfontsize = 0;
static double defaultfontsize = 0;
static int fontsloaded = 0;

static struct wl_display *display = NULL;
static struct wl_registry *registry = NULL;
static struct wl_compositor *compositor = NULL;
static struct wl_shm *shm = NULL;
static struct xdg_wm_base *wm_base = NULL;
static struct wl_seat *seat = NULL;
static struct wl_data_device_manager *data_manager = NULL;
static struct zwp_primary_selection_device_manager_v1 *primary_manager = NULL;
static struct zwp_text_input_manager_v3 *text_input_manager = NULL;
static struct wp_cursor_shape_manager_v1 *cursor_shape_manager = NULL;
static struct wp_fractional_scale_manager_v1 *fractional_manager = NULL;
static struct wp_viewporter *viewporter = NULL;
static struct xdg_system_bell_v1 *systembell = NULL;

static struct wl_surface *surface = NULL;
static struct xdg_surface *xdg_surface = NULL;
static struct xdg_toplevel *xdg_toplevel = NULL;
static struct wp_fractional_scale_v1 *fractional = NULL;
static struct wp_viewport *viewport = NULL;

static struct wl_keyboard *keyboard = NULL;
static struct wl_pointer *pointer = NULL;
static struct wp_cursor_shape_device_v1 *cursor_shape = NULL;
static struct wl_data_device *data_device = NULL;
static struct zwp_primary_selection_device_v1 *primary_device = NULL;
static struct zwp_text_input_v3 *text_input = NULL;

static Offer *clipboard_offer = NULL;
static Offer *primary_offer = NULL;
static Offer *pending_offer = NULL;
static Offer *pending_primary_offer = NULL;
static Source *clipboard_source = NULL;
static Source *primary_source = NULL;
static Transfer *transfers = NULL;

static struct xkb_context *xkbcontext = NULL;
static struct xkb_keymap *xkbkeymap = NULL;
static struct xkb_state *xkbstate = NULL;
static struct xkb_compose_table *composetable = NULL;
static struct xkb_compose_state *composestate = NULL;
static int shift_idx = -1, lock_idx = -1, ctrl_idx = -1;
static int mod1_idx = -1, mod2_idx = -1, mod3_idx = -1;
static int mod4_idx = -1, mod5_idx = -1;

static int repeatfd = -1;
static xkb_keycode_t repeatkey = 0;
static int repeatrate = 25, repeatdelay = 600;

static int ime_enabled = 0;
static int ime_active = 0;
/* Printable key text is held back briefly so an input method can claim it. */
static char *pendingtext = NULL;
static size_t pendinglen = 0, pendingcap = 0;
static struct timespec pendinguntil;
static int ime_x = 0, ime_y = 0;

static uint32_t last_serial = 0;
static uint32_t pointer_serial = 0;
static int pointer_hidden = 0;
static int pointer_x = 0, pointer_y = 0;

static double scale = 1.0;
static int iscale = 1;
static int use_viewport = 0;
static int have_frac_scale = 0;
static uint32_t frac_scale = 120;
static int surface_scale = 0;
static int started = 0;
static int configured = 0;
static int draw_pending = 0;
static int pending_event = 0;
static int conf_w = 0, conf_h = 0;
static int shm_argb = 0;

static int clipx1, clipy1, clipx2, clipy2;

static uint buttonstate = 0;
static int axis_dy = 0, axis_dx = 0;
static double axis_y = 0, axis_x = 0;
static int oldbutton = 3; /* button event on startup: 3 = release */

static char *opt_alpha = NULL;
static char *opt_class = NULL;
static char **opt_cmd = NULL;
static char *opt_font = NULL;
static char *opt_io = NULL;
static char *opt_line = NULL;
static char *opt_title = NULL;
static int opt_fixed = 0;

/* Rendering */
static uint32_t premul(uint32_t);
static uint32_t invert(uint32_t);
static int parsecolor(const char *, uint32_t *);
static int loadcolor(int, const char *, uint32_t *);
static int sixd_to_16bit(int);
static void setclip(int, int, int, int);
static void resetclip(void);
static void drawglyphbitmap(FT_Face, uint32_t, int, int, uint32_t);
static FT_Face loadfallbackface(Font *, Rune, FT_UInt *);
static int makeglyphspecs(GlyphSpec *, const Glyph *, int, int, int);
static void drawglyphspecs(const GlyphSpec *, Glyph, int, int, int);
static void drawglyph(Glyph, int, int);

/* Fonts */
static int loadfont(Font *, FcPattern *, double);
static void loadfonts(char *, double);
static void unloadfont(Font *);
static void unloadfonts(void);

/* Window */
static int borderpxdev(void);
static double surfacescale(void);
static int topx(double);
static int tological(int);
static void updatesize(void);
static void destroybuffer(void);
static int createbuffer(void);
static void wlresize(void);
static void cresize(int, int);
static void setscale(double);
static void flushdisplay(void);
static uint32_t cursorshapeid(void);
static void setcursorshape(uint32_t);
static void hidepointer(uint32_t);
static void showpointer(uint32_t);

/* Input */
static uint modmask(void);
static void updatemods(void);
static void keypress(xkb_keycode_t);
static int keytext(xkb_keycode_t, char *, int);
static char *kmap(KeySym, uint);
static int match(uint, uint);
static void startrepeat(xkb_keycode_t);
static void stoprepeat(void);
static void repeattick(void);
static uint buttonmask(uint);
static int evcol(MouseEvent *);
static int evrow(MouseEvent *);
static void bpress(MouseEvent *);
static void brelease(MouseEvent *);
static void bmotion(MouseEvent *);
static void mousesel(MouseEvent *, int);
static void mousereport(MouseEvent *);
static int mouseaction(MouseEvent *, uint);

/* Clipboard */
static void offerdestroy(Offer *);
static void offeraddmime(Offer *, const char *);
static const char *offerpicked(Offer *);
static void offerreceive(Offer *, int);
static void pasteselection(Offer *);
static void sourcedestroy(Source *);
static void newsource(int, const char *);
static void transferdone(Transfer *);
static void transferadd(int, int, const char *, size_t);
static void transferready(Transfer *);
static void transferspoll(struct pollfd *);

/* IME */
static void pendingflush(void);
static void pendingdiscard(void);
static void textqueue(const char *, size_t);
static int hascontrol(const char *, int);
static void imeenable(void);
static void imedisable(void);
static void imespotsend(void);

/* Setup and main loop */
static void wlinit(int, int);
static void run(void);
static void usage(void);

static const struct wl_buffer_listener buffer_listener;
static const struct wl_data_offer_listener data_offer_listener;
static const struct zwp_primary_selection_offer_v1_listener
	primary_offer_listener;
static const struct wl_data_source_listener data_source_listener;
static const struct zwp_primary_selection_source_v1_listener
	primary_source_listener;
static const struct wl_keyboard_listener keyboard_listener;
static const struct wl_pointer_listener pointer_listener;
static const struct wl_shm_listener shm_listener;
static const struct wl_registry_listener registry_listener;

/* Listener callbacks */
static void registryglobal(void *, struct wl_registry *, uint32_t,
                           const char *, uint32_t);
static void registryglobalremove(void *, struct wl_registry *, uint32_t);
static void shmformat(void *, struct wl_shm *, uint32_t);
static void bufferrelease(void *, struct wl_buffer *);
static void wmbaseping(void *, struct xdg_wm_base *, uint32_t);
static void xdgsurfaceconfigure(void *, struct xdg_surface *, uint32_t);
static void toplevelconfigure(void *, struct xdg_toplevel *, int32_t,
                             int32_t, struct wl_array *);
static void toplevelclose(void *, struct xdg_toplevel *);
static void toplevelbounds(void *, struct xdg_toplevel *, int32_t, int32_t);
static void toplevelcaps(void *, struct xdg_toplevel *, struct wl_array *);
static void surfaceenter(void *, struct wl_surface *, struct wl_output *);
static void surfaceleave(void *, struct wl_surface *, struct wl_output *);
static void surfaceprefscale(void *, struct wl_surface *, int32_t);
static void surfacepreftransform(void *, struct wl_surface *, uint32_t);
static void fractionalprefscale(void *, struct wp_fractional_scale_v1 *,
                                uint32_t);
static void seatcapabilities(void *, struct wl_seat *, uint32_t);
static void seatname(void *, struct wl_seat *, const char *);
static void keyboardkeymap(void *, struct wl_keyboard *, uint32_t, int32_t,
                           uint32_t);
static void keyboardenter(void *, struct wl_keyboard *, uint32_t,
                          struct wl_surface *, struct wl_array *);
static void keyboardleave(void *, struct wl_keyboard *, uint32_t,
                          struct wl_surface *);
static void keyboardkey(void *, struct wl_keyboard *, uint32_t, uint32_t,
                        uint32_t, uint32_t);
static void keyboardmodifiers(void *, struct wl_keyboard *, uint32_t,
                              uint32_t, uint32_t, uint32_t, uint32_t);
static void keyboardrepeat(void *, struct wl_keyboard *, int32_t, int32_t);
static void pointerenter(void *, struct wl_pointer *, uint32_t,
                         struct wl_surface *, wl_fixed_t, wl_fixed_t);
static void pointerleave(void *, struct wl_pointer *, uint32_t,
                         struct wl_surface *);
static void pointermotion(void *, struct wl_pointer *, uint32_t, wl_fixed_t,
                          wl_fixed_t);
static void pointerbutton(void *, struct wl_pointer *, uint32_t, uint32_t,
                          uint32_t, uint32_t);
static void pointeraxis(void *, struct wl_pointer *, uint32_t, uint32_t,
                        wl_fixed_t);
static void pointerframe(void *, struct wl_pointer *);
static void pointeraxissource(void *, struct wl_pointer *, uint32_t);
static void pointeraxisstop(void *, struct wl_pointer *, uint32_t, uint32_t);
static void pointeraxisdisc(void *, struct wl_pointer *, uint32_t, int32_t);
static void dataoffer(void *, struct wl_data_device *,
                      struct wl_data_offer *);
static void dataenter(void *, struct wl_data_device *, uint32_t,
                      struct wl_surface *, wl_fixed_t, wl_fixed_t,
                      struct wl_data_offer *);
static void dataleave(void *, struct wl_data_device *);
static void datamotion(void *, struct wl_data_device *, uint32_t,
                       wl_fixed_t, wl_fixed_t);
static void datadrop(void *, struct wl_data_device *);
static void dataselection(void *, struct wl_data_device *,
                          struct wl_data_offer *);
static void primaryoffer(void *, struct zwp_primary_selection_device_v1 *,
                         struct zwp_primary_selection_offer_v1 *);
static void primaryselection(void *, struct zwp_primary_selection_device_v1 *,
                             struct zwp_primary_selection_offer_v1 *);
static void offeroffer(void *, struct wl_data_offer *, const char *);
static void primaryofferoffer(void *,
                              struct zwp_primary_selection_offer_v1 *,
                              const char *);
static void datasourcesend(void *, struct wl_data_source *, const char *,
                           int32_t);
static void datasourcecancelled(void *, struct wl_data_source *);
static void primarysourcesend(void *,
                              struct zwp_primary_selection_source_v1 *,
                              const char *, int32_t);
static void primarysourcecancelled(void *,
                                   struct zwp_primary_selection_source_v1 *);
static void textinputenter(void *, struct zwp_text_input_v3 *,
                           struct wl_surface *);
static void textinputleave(void *, struct zwp_text_input_v3 *,
                           struct wl_surface *);
static void textinputpreedit(void *, struct zwp_text_input_v3 *, const char *,
                             int32_t, int32_t);
static void textinputcommit(void *, struct zwp_text_input_v3 *, const char *);
static void textinputdelete(void *, struct zwp_text_input_v3 *, uint32_t,
                            uint32_t);
static void textinputdone(void *, struct zwp_text_input_v3 *, uint32_t);
static void textinputaction(void *, struct zwp_text_input_v3 *, uint32_t,
                            uint32_t);
static void textinputlanguage(void *, struct zwp_text_input_v3 *, const char *);
static void textinputpreedithint(void *, struct zwp_text_input_v3 *, uint32_t,
                                 uint32_t, uint32_t);

/* ---- colors ---- */

static int
sixd_to_16bit(int x)
{
	return x == 0 ? 0 : 0x3737 + 0x2828 * x;
}

static uint32_t
premul(uint32_t c)
{
	uint32_t a = c >> 24;
	uint32_t r = (c >> 16) & 0xff;
	uint32_t g = (c >> 8) & 0xff;
	uint32_t b = c & 0xff;

	if (a == 0xff)
		return c;
	if (a == 0)
		return 0;
	return (a << 24) | (((r * a + 127) / 255) << 16) |
	       (((g * a + 127) / 255) << 8) | ((b * a + 127) / 255);
}

static uint32_t
invert(uint32_t c)
{
	return (c & 0xff000000) | (~c & 0x00ffffff);
}

static int
hexval(int c)
{
	if (c >= '0' && c <= '9')
		return c - '0';
	c |= 0x20;
	if (c >= 'a' && c <= 'f')
		return c - 'a' + 10;
	return -1;
}

static int
parsehex(const char **pp, int *digits)
{
	int v = 0, n = 0, c;

	while (n < 4 && (c = hexval((unsigned char)**pp)) >= 0) {
		v = v * 16 + c;
		(*pp)++;
		n++;
	}
	*digits = n;
	return v;
}

static int
parsenamed(const char *name, uint32_t *out)
{
	static const struct {
		const char *name;
		uint32_t rgb;
	} colors[] = {
		{ "black", 0x000000 }, { "white", 0xffffff },
		{ "red", 0xff0000 }, { "green", 0x00ff00 },
		{ "blue", 0x0000ff }, { "yellow", 0xffff00 },
		{ "magenta", 0xff00ff }, { "cyan", 0x00ffff },
		{ "gray", 0xbebebe }, { "grey", 0xbebebe },
		{ "darkgray", 0xa9a9a9 }, { "darkgrey", 0xa9a9a9 },
		{ "lightgray", 0xd3d3d3 }, { "lightgrey", 0xd3d3d3 },
		{ "orange", 0xffa500 }, { "purple", 0xa020f0 },
		{ "pink", 0xffc0cb }, { "brown", 0xa52a2a },
		{ "navy", 0x000080 }, { "teal", 0x008080 },
		{ "olive", 0x808000 }, { "maroon", 0x800000 },
		{ "silver", 0xc0c0c0 }, { "lime", 0x00ff00 },
		{ "aqua", 0x00ffff }, { "fuchsia", 0xff00ff },
	};
	size_t i;

	for (i = 0; i < LEN(colors); i++)
		if (!strcasecmp(name, colors[i].name)) {
			*out = 0xff000000 | colors[i].rgb;
			return 0;
		}
	return 1;
}

/* Accepts #rgb, #rrggbb, #rrggbbaa, rgb:r/g/b (1-4 hex digits each) and a
 * small set of names, so config.h can use whatever people are used to. */
static int
parsecolor(const char *name, uint32_t *out)
{
	const char *p;
	unsigned int r = 0, g = 0, b = 0, a = 0xff;
	int n, digits, i;

	if (name[0] == '#') {
		p = name + 1;
		n = strlen(p);
		if (n != 3 && n != 6 && n != 8)
			return 1;
		if (n == 3) {
			int hv;

			if ((hv = hexval(p[0])) < 0 ||
			    (r = hv * 0x11, (hv = hexval(p[1])) < 0) ||
			    (g = hv * 0x11, (hv = hexval(p[2])) < 0))
				return 1;
			b = hv * 0x11;
			*out = 0xff000000 | r << 16 | g << 8 | b;
			return 0;
		}
		for (i = 0; i < n; i += 2) {
			int hi = hexval(p[i]), lo = hexval(p[i + 1]);

			if (hi < 0 || lo < 0)
				return 1;
			if (i == 0)
				r = hi * 16 + lo;
			else if (i == 2)
				g = hi * 16 + lo;
			else if (i == 4)
				b = hi * 16 + lo;
			else
				a = hi * 16 + lo;
		}
		*out = a << 24 | r << 16 | g << 8 | b;
		return 0;
	}

	if (!strncmp(name, "rgb:", 4)) {
		unsigned int v[3];

		p = name + 4;
		for (i = 0; i < 3; i++) {
			if (i > 0 && *p++ != '/')
				return 1;
			v[i] = parsehex(&p, &digits);
			if (digits < 1)
				return 1;
			if (digits == 1)
				v[i] = v[i] * 0x11;
			else if (digits == 3)
				v[i] = (v[i] * 255 + 0x7ff) / 0xfff;
			else if (digits == 4)
				v[i] = v[i] >> 8;
		}
		*out = 0xff000000 | v[0] << 16 | v[1] << 8 | v[2];
		return 0;
	}

	return parsenamed(name, out);
}

static int
loadcolor(int i, const char *name, uint32_t *out)
{
	unsigned int r, g, b;

	if (!name) {
		if (BETWEEN(i, 16, 255)) {
			if (i < 6 * 6 * 6 + 16) {
				r = sixd_to_16bit(((i - 16) / 36) % 6) >> 8;
				g = sixd_to_16bit(((i - 16) / 6) % 6) >> 8;
				b = sixd_to_16bit(((i - 16) / 1) % 6) >> 8;
			} else {
				r = g = b = 0x08 + 0x0a * (i - (6 * 6 * 6 + 16));
			}
			*out = 0xff000000 | r << 16 | g << 8 | b;
			return 0;
		}
		if (i < 0 || i >= (int)LEN(colorname) || !colorname[i])
			return 1;
		name = colorname[i];
	}
	return parsecolor(name, out);
}

void
loadcols(void)
{
	int i;
	uint32_t c, a;

	if (!dc.col) {
		dc.collen = MAX(LEN(colorname), 256);
		dc.col = xmalloc(dc.collen * sizeof(uint32_t));
	}

	for (i = 0; i < (int)dc.collen; i++) {
		if (loadcolor(i, NULL, &c)) {
			if (i < (int)LEN(colorname) && colorname[i])
				die("could not load color '%s'\n", colorname[i]);
			die("could not load color %d\n", i);
		}
		dc.col[i] = c;
	}

	/* set alpha value of bg color */
	if (opt_alpha)
		alpha = strtof(opt_alpha, NULL);
	a = (uint32_t)(0xff * alpha + 0.5);
	dc.col[defaultbg] = (dc.col[defaultbg] & 0x00ffffff) | a << 24;

	for (i = 0; i < (int)dc.collen; i++)
		dc.col[i] = premul(dc.col[i]);
}

int
setcolorname(int x, const char *name)
{
	uint32_t c;

	if (x < 0 || x >= (int)dc.collen)
		return 1;

	if (loadcolor(x, name, &c))
		return 1;

	if (x == (int)defaultbg)
		c = (c & 0x00ffffff) | (uint32_t)(0xff * alpha + 0.5) << 24;
	dc.col[x] = premul(c);

	return 0;
}

/* ---- fonts ---- */

static int
loadfont(Font *f, FcPattern *pattern, double px)
{
	FcPattern *configured, *match;
	FcResult result;
	FT_Face face;
	FcChar8 *file;
	FcBool outline;
	int index, wantattr, haveattr;
	double size;
	unsigned int i, n = 0;
	long adv = 0;

	configured = FcPatternDuplicate(pattern);
	if (!configured)
		return 1;

	if (px > 0) {
		FcPatternDel(configured, FC_PIXEL_SIZE);
		FcPatternDel(configured, FC_SIZE);
		FcPatternAddDouble(configured, FC_PIXEL_SIZE, px);
	}

	FcConfigSubstitute(NULL, configured, FcMatchPattern);
	FcDefaultSubstitute(configured);

	match = FcFontMatch(NULL, configured, &result);
	if (!match) {
		FcPatternDestroy(configured);
		return 1;
	}

	if (px > 0) {
		f->pxsize = px;
		f->logicalpx = px / scale;
	} else {
		if (FcPatternGetDouble(match, FC_PIXEL_SIZE, 0, &size) !=
		    FcResultMatch)
			size = 12;
		f->logicalpx = size;
		f->pxsize = size * scale;
	}

	/* Only scalable outlines; bitmap emoji still come through fontconfig
	 * as scalable color fonts, but a stale bitmap family would be blurry. */
	if (FcPatternGetBool(match, FC_OUTLINE, 0, &outline) == FcResultMatch &&
	    !outline) {
		FcPatternDestroy(match);
		FcPatternDestroy(configured);
		return 1;
	}

	if (FcPatternGetString(match, FC_FILE, 0, &file) != FcResultMatch ||
	    FcPatternGetInteger(match, FC_INDEX, 0, &index) != FcResultMatch) {
		FcPatternDestroy(match);
		FcPatternDestroy(configured);
		return 1;
	}

	if (FT_New_Face(ftlib, (const char *)file, index, &face)) {
		FcPatternDestroy(match);
		FcPatternDestroy(configured);
		return 1;
	}

	FT_Select_Charmap(face, FT_ENCODING_UNICODE);
	FT_Set_Char_Size(face, 0, (FT_F26Dot6)(f->pxsize * 64 + 0.5), 72, 72);

	if (FcPatternGetInteger(pattern, FC_SLANT, 0, &wantattr) ==
	    FcResultMatch) {
		if (FcPatternGetInteger(match, FC_SLANT, 0, &haveattr) !=
		    FcResultMatch || haveattr < wantattr) {
			f->badslant = 1;
			fputs("font slant does not match\n", stderr);
		}
	}
	if (FcPatternGetInteger(pattern, FC_WEIGHT, 0, &wantattr) ==
	    FcResultMatch) {
		if (FcPatternGetInteger(match, FC_WEIGHT, 0, &haveattr) !=
		    FcResultMatch || haveattr != wantattr) {
			f->badweight = 1;
			fputs("font weight does not match\n", stderr);
		}
	}

	f->ascent = (face->size->metrics.ascender + 63) >> 6;
	f->descent = (-face->size->metrics.descender + 63) >> 6;
	f->height = f->ascent + f->descent;

	for (i = 0; ascii_printable[i]; i++) {
		if (FT_Load_Char(face, (unsigned char)ascii_printable[i],
		                 FT_LOAD_DEFAULT))
			continue;
		adv += face->glyph->advance.x;
		n++;
	}
	f->width = n ? (int)ceil((double)adv / (64.0 * n)) : 1;
	f->width = MAX(1, f->width);

	f->face = face;
	f->pattern = configured;

	FcPatternDestroy(match);
	return 0;
}

static void
loadfonts(char *fontstr, double fontsize)
{
	FcPattern *pattern;
	double px, fontval;

	pattern = FcNameParse((const FcChar8 *)fontstr);
	if (!pattern)
		die("can't open font %s\n", fontstr);

	if (fontsize > 1) {
		FcPatternDel(pattern, FC_PIXEL_SIZE);
		FcPatternDel(pattern, FC_SIZE);
		FcPatternAddDouble(pattern, FC_PIXEL_SIZE, fontsize);
		usedfontsize = fontsize;
		px = fontsize * scale;
	} else {
		px = 0;
		if (FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval) ==
		    FcResultMatch) {
			usedfontsize = fontval;
		} else if (FcPatternGetDouble(pattern, FC_SIZE, 0, &fontval) ==
		           FcResultMatch) {
			usedfontsize = -1;
		} else {
			FcPatternAddDouble(pattern, FC_PIXEL_SIZE, 12);
			usedfontsize = 12;
		}
		defaultfontsize = usedfontsize;
	}

	if (loadfont(&dc.font, pattern, px))
		die("can't open font %s\n", fontstr);

	if (usedfontsize < 0) {
		usedfontsize = dc.font.logicalpx;
		if (fontsize == 0)
			defaultfontsize = usedfontsize;
	}

	win.cw = MAX(1, (int)ceil(dc.font.width * cwscale));
	win.ch = MAX(1, (int)ceil(dc.font.height * chscale));

	FcPatternDel(pattern, FC_SLANT);
	FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC);
	if (loadfont(&dc.ifont, pattern, dc.font.pxsize))
		die("can't open font %s\n", fontstr);

	FcPatternDel(pattern, FC_WEIGHT);
	FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);
	if (loadfont(&dc.ibfont, pattern, dc.font.pxsize))
		die("can't open font %s\n", fontstr);

	FcPatternDel(pattern, FC_SLANT);
	FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN);
	if (loadfont(&dc.bfont, pattern, dc.font.pxsize))
		die("can't open font %s\n", fontstr);

	fontsloaded = 1;
	FcPatternDestroy(pattern);
}

static void
unloadfont(Font *f)
{
	if (f->face)
		FT_Done_Face(f->face);
	if (f->pattern)
		FcPatternDestroy(f->pattern);
	memset(f, 0, sizeof(*f));
}

static void
unloadfonts(void)
{
	int i;

	/* HarfBuzz keeps pointers to the FT_Face objects. */
	hbunloadfonts();

	for (i = 0; i < frclen; i++)
		FT_Done_Face(frc[i].face);
	free(frc);
	frc = NULL;
	frclen = frccap = 0;

	unloadfont(&dc.font);
	unloadfont(&dc.bfont);
	unloadfont(&dc.ifont);
	unloadfont(&dc.ibfont);

	fontsloaded = 0;
}

/* ---- rendering ---- */

static void
setclip(int x, int y, int w, int h)
{
	clipx1 = MAX(0, x);
	clipy1 = MAX(0, y);
	clipx2 = MIN(win.w, x + w);
	clipy2 = MIN(win.h, y + h);
}

static void
resetclip(void)
{
	clipx1 = 0;
	clipy1 = 0;
	clipx2 = win.w;
	clipy2 = win.h;
}

void
clearrect(int x, int y, int w, int h, uint32_t col)
{
	uint32_t *p;
	int x1, y1, x2, y2, i, j;

	if (!fb.target)
		return;

	x1 = MAX(x, clipx1);
	y1 = MAX(y, clipy1);
	x2 = MIN(x + w, clipx2);
	y2 = MIN(y + h, clipy2);
	if (x1 >= x2 || y1 >= y2)
		return;

	fb.drawn = 1;
	for (j = y1; j < y2; j++) {
		p = fb.target + (size_t)j * win.w;
		for (i = x1; i < x2; i++)
			p[i] = col;
	}
}

void
blendrect(int x, int y, int w, int h, uint32_t col)
{
	uint32_t *p, d, sr, sg, sb, sa, ia;
	int x1, y1, x2, y2, i, j;

	sa = col >> 24;
	if (!fb.target || sa == 0)
		return;

	x1 = MAX(x, clipx1);
	y1 = MAX(y, clipy1);
	x2 = MIN(x + w, clipx2);
	y2 = MIN(y + h, clipy2);
	if (x1 >= x2 || y1 >= y2)
		return;

	sr = (col >> 16) & 0xff;
	sg = (col >> 8) & 0xff;
	sb = col & 0xff;
	ia = 255 - sa;

	fb.drawn = 1;
	for (j = y1; j < y2; j++) {
		p = fb.target + (size_t)j * win.w;
		for (i = x1; i < x2; i++) {
			d = p[i];
			p[i] = ((sa + (((d >> 24) * ia + 127) / 255)) << 24) |
			       ((sr + ((((d >> 16) & 0xff) * ia + 127) / 255)) << 16) |
			       ((sg + ((((d >> 8) & 0xff) * ia + 127) / 255)) << 8) |
			       (sb + (((d & 0xff) * ia + 127) / 255));
		}
	}
}

/* Rasterize one FreeType glyph at pen position (x, y). */
static void
drawglyphbitmap(FT_Face face, uint32_t glyph, int x, int y, uint32_t fg)
{
	FT_GlyphSlot slot;
	unsigned char *src, *row;
	uint32_t *p, d, cov, sa, ia, fr, fg_, fb_, sr, sg, sb;
	int i, j, w, h, stride, px, py, mode;

	if (!fb.target || !glyph)
		return;
	if (FT_Load_Glyph(face, glyph, FT_LOAD_RENDER | FT_LOAD_COLOR))
		return;
	slot = face->glyph;
	if (slot->format != FT_GLYPH_FORMAT_BITMAP) {
		if (FT_Render_Glyph(slot, FT_RENDER_MODE_NORMAL))
			return;
	}
	if (!slot->bitmap.width || !slot->bitmap.rows ||
	    !slot->bitmap.buffer)
		return;

	w = slot->bitmap.width;
	h = slot->bitmap.rows;
	stride = slot->bitmap.pitch;
	mode = slot->bitmap.pixel_mode;
	src = slot->bitmap.buffer;
	px = x + slot->bitmap_left;
	py = y - slot->bitmap_top;

	fr = (fg >> 16) & 0xff;
	fg_ = (fg >> 8) & 0xff;
	fb_ = fg & 0xff;
	ia = 0;

	for (j = 0; j < h; j++) {
		int yy = py + j;

		if (yy < clipy1 || yy >= clipy2)
			continue;
		row = stride >= 0 ? src + j * stride : src + (h - 1 - j) * -stride;
		p = fb.target + (size_t)yy * win.w;

		for (i = 0; i < w; i++) {
			int xx = px + i;

			if (xx < clipx1 || xx >= clipx2)
				continue;

			if (mode == FT_PIXEL_MODE_BGRA)
				cov = row[i * 4 + 3];
			else if (mode == FT_PIXEL_MODE_MONO)
				cov = (row[i >> 3] & (0x80 >> (i & 7))) ? 255 : 0;
			else
				cov = row[i];
			if (!cov)
				continue;

			sa = (fg >> 24) * cov / 255;
			if (!sa)
				continue;
			ia = 255 - sa;
			d = p[xx];

			if (mode == FT_PIXEL_MODE_BGRA) {
				/* FreeType color bitmaps are premultiplied BGRA */
				sr = row[i * 4 + 2] * (fg >> 24) / 255;
				sg = row[i * 4 + 1] * (fg >> 24) / 255;
				sb = row[i * 4 + 0] * (fg >> 24) / 255;
			} else {
				sr = fr * cov / 255;
				sg = fg_ * cov / 255;
				sb = fb_ * cov / 255;
			}

			p[xx] = ((sa + (((d >> 24) * ia + 127) / 255)) << 24) |
			        ((sr + ((((d >> 16) & 0xff) * ia + 127) / 255)) << 16) |
			        ((sg + ((((d >> 8) & 0xff) * ia + 127) / 255)) << 8) |
			        (sb + (((d & 0xff) * ia + 127) / 255));
			fb.drawn = 1;
		}
	}
}

/* Font Ring Cache */
enum {
	FRC_NORMAL,
	FRC_ITALIC,
	FRC_BOLD,
	FRC_ITALICBOLD
};

/* Face for a rune the configured font does not carry, or NULL when nothing on
 * the system does.  *glyphidx is its index for that face (0 when not found).
 *
 * fontconfig's cached charsets over-report: the best match it offers may have
 * no cmap entry at all for the rune, which is how CJK came out blank.  Only
 * FreeType knows what a loaded face really contains, so walk the sorted
 * candidates and ask it.  Capped because the set is the whole font cache and a
 * rune nobody covers must not turn a redraw into a file scan. */
static FT_Face
loadfallbackface(Font *f, Rune rune, FT_UInt *glyphidx)
{
	FcPattern *pattern;
	FcCharSet *charset;
	FcFontSet *set;
	FcResult result;
	FcChar8 *file;
	FT_Face face = NULL;
	int i, index;

	charset = FcCharSetCreate();
	pattern = FcPatternDuplicate(f->pattern);
	if (!charset || !pattern)
		die("out of memory looking up a fallback font\n");

	FcCharSetAddChar(charset, rune);
	FcPatternAddCharSet(pattern, FC_CHARSET, charset);
	FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
	FcConfigSubstitute(NULL, pattern, FcMatchPattern);
	FcDefaultSubstitute(pattern);

	*glyphidx = 0;
	set = FcFontSort(NULL, pattern, FcTrue, NULL, &result);
	for (i = 0; set && i < set->nfont && i < 32; i++) {
		if (FcPatternGetString(set->fonts[i], FC_FILE, 0, &file) !=
		    FcResultMatch ||
		    FcPatternGetInteger(set->fonts[i], FC_INDEX, 0, &index) !=
		    FcResultMatch)
			continue;
		if (FT_New_Face(ftlib, (const char *)file, index, &face))
			continue;

		FT_Select_Charmap(face, FT_ENCODING_UNICODE);
		FT_Set_Char_Size(face, 0, (FT_F26Dot6)(f->pxsize * 64 + 0.5),
		                 72, 72);
		*glyphidx = FT_Get_Char_Index(face, rune);
		if (*glyphidx)
			break;
		FT_Done_Face(face);
	}

	if (set)
		FcFontSetDestroy(set);
	FcPatternDestroy(pattern);
	FcCharSetDestroy(charset);

	if (!*glyphidx)
		return NULL;
	return face;
}

/* Turn a run of glyphs into font specs.  Exactly one spec is appended per
 * non-dummy glyph so that hbtransform() can stay index-aligned. */
static int
makeglyphspecs(GlyphSpec *specs, const Glyph *glyphs, int len, int x, int y)
{
	double winx = win.hborderpx + x * win.cw,
	       winy = win.vborderpx + y * win.ch, xp, yp;
	ushort mode, prevmode = USHRT_MAX;
	Font *font = &dc.font;
	int frcflags = FRC_NORMAL;
	double runewidth = win.cw;
	Rune rune;
	FT_UInt glyphidx;
	FT_Face face;
	int f, numspecs = 0, i;

	for (i = 0, xp = winx, yp = winy + font->ascent; i < len; ++i) {
		rune = glyphs[i].u;
		mode = glyphs[i].mode;

		/* Skip dummy wide-character spacing. */
		if (mode & ATTR_WDUMMY)
			continue;

		/* Determine font for glyph if different from previous glyph. */
		if (prevmode != mode) {
			prevmode = mode;
			font = &dc.font;
			frcflags = FRC_NORMAL;
			runewidth = win.cw * ((mode & ATTR_WIDE) ? 2.0 : 1.0);
			if ((mode & ATTR_ITALIC) && (mode & ATTR_BOLD)) {
				font = &dc.ibfont;
				frcflags = FRC_ITALICBOLD;
			} else if (mode & ATTR_ITALIC) {
				font = &dc.ifont;
				frcflags = FRC_ITALIC;
			} else if (mode & ATTR_BOLD) {
				font = &dc.bfont;
				frcflags = FRC_BOLD;
			}
			yp = winy + font->ascent;
		}

		if (mode & ATTR_BOXDRAW) {
			/* minor shoehorning: boxdraw uses only this ushort */
			glyphidx = boxdrawindex(&glyphs[i]);
		} else {
			glyphidx = FT_Get_Char_Index(font->face, rune);
		}
		if (glyphidx) {
			specs[numspecs].font = font->face;
			specs[numspecs].glyph = glyphidx;
			specs[numspecs].x = (short)xp;
			specs[numspecs].y = (short)yp;
			xp += runewidth;
			numspecs++;
			continue;
		}

		/* Fallback on font cache, search the font cache for match.  A NULL
		 * face is a rune nothing on the system covers, see below. */
		for (f = 0; f < frclen; f++) {
			glyphidx = frc[f].face ?
			           FT_Get_Char_Index(frc[f].face, rune) : 0;
			/* Everything correct. */
			if (glyphidx && frc[f].flags == frcflags)
				break;
			/* We got a default font for a not found glyph. */
			if (!glyphidx && frc[f].flags == frcflags &&
			    frc[f].unicodep == rune)
				break;
		}

		/* Nothing was found.  Ask fontconfig for a face carrying the rune
		 * and cache the answer either way, so a rune is looked up once and
		 * an uncovered one does not rescan the fonts on every redraw. */
		if (f >= frclen) {
			face = loadfallbackface(font, rune, &glyphidx);

			if (frclen >= frccap) {
				frccap += 16;
				frc = xrealloc(frc, frccap * sizeof(Fontcache));
			}
			frc[frclen].face = face;
			frc[frclen].flags = frcflags;
			frc[frclen].unicodep = rune;
			f = frclen++;
		}

		specs[numspecs].font = frc[f].face ? frc[f].face : font->face;
		specs[numspecs].glyph = glyphidx;
		specs[numspecs].x = (short)xp;
		specs[numspecs].y = (short)yp;
		xp += runewidth;
		numspecs++;
	}

	/* Harfbuzz transformation for ligatures. */
	hbtransform(specs, glyphs, len, x, y);

	return numspecs;
}

static void
drawglyph(Glyph g, int x, int y)
{
	int numspecs;
	GlyphSpec spec;

	numspecs = makeglyphspecs(&spec, &g, 1, x, y);
	drawglyphspecs(&spec, g, numspecs, x, y);
}

static void
drawglyphspecs(const GlyphSpec *specs, Glyph base, int len, int x, int y)
{
	int charlen = len * ((base.mode & ATTR_WIDE) ? 2 : 1);
	int winx = win.hborderpx + x * win.cw;
	int winy = win.vborderpx + y * win.ch;
	int width = charlen * win.cw;
	uint32_t fg, bg, temp;
	int i;

	/* Fallback on color display for attributes not supported by the font */
	if (base.mode & ATTR_ITALIC && base.mode & ATTR_BOLD) {
		if (dc.ibfont.badslant || dc.ibfont.badweight)
			base.fg = defaultattr;
	} else if ((base.mode & ATTR_ITALIC && dc.ifont.badslant) ||
	           (base.mode & ATTR_BOLD && dc.bfont.badweight)) {
		base.fg = defaultattr;
	}

	fg = IS_TRUECOL(base.fg) ? 0xff000000 | (base.fg & 0xffffff)
	                         : dc.col[base.fg];
	bg = IS_TRUECOL(base.bg) ? 0xff000000 | (base.bg & 0xffffff)
	                         : dc.col[base.bg];

	/* Change basic system colors [0-7] to bright system colors [8-15] */
	if ((base.mode & ATTR_BOLD_FAINT) == ATTR_BOLD && BETWEEN(base.fg, 0, 7))
		fg = dc.col[base.fg + 8];

	if (IS_SET(MODE_REVERSE)) {
		if (!IS_TRUECOL(base.fg) && base.fg == defaultfg)
			fg = dc.col[defaultbg];
		else
			fg = invert(fg);

		if (!IS_TRUECOL(base.bg) && base.bg == defaultbg)
			bg = dc.col[defaultfg];
		else
			bg = invert(bg);
	}

	if ((base.mode & ATTR_BOLD_FAINT) == ATTR_FAINT)
		fg = (fg & 0xff000000) | ((fg >> 1) & 0x7f7f7f);

	if (base.mode & ATTR_REVERSE) {
		temp = fg;
		fg = bg;
		bg = temp;
	}

	if (base.mode & ATTR_BLINK && win.mode & MODE_BLINK)
		fg = bg;

	if (base.mode & ATTR_INVISIBLE)
		fg = bg;

	/* Intelligent cleaning up of the borders, horizontally only: the top and
	 * the bottom padding always belong to the default background, see
	 * startdraw(), so that a coloured block on the first or the last row does
	 * not bleed out of its own row. */
	if (x == 0)
		clearrect(0, winy, win.hborderpx, win.ch, bg);
	if (winx + width >= win.hborderpx + win.tw)
		clearrect(winx + width, winy, win.w - (winx + width),
		          win.ch, bg);

	/* Clean up the region we want to draw to. */
	clearrect(winx, winy, width, win.ch, bg);

	/* Set the clip region because our primitives are dumb. */
	setclip(winx, winy, width, win.ch);

	if (base.mode & ATTR_BOXDRAW) {
		drawboxes(winx, winy, width / len, win.ch, fg, bg, specs, len);
	} else {
		for (i = 0; i < len; i++)
			drawglyphbitmap((FT_Face)specs[i].font, specs[i].glyph,
			                specs[i].x, specs[i].y, fg);
	}

	/* Render underline and strikethrough. */
	if (base.mode & ATTR_UNDERLINE)
		blendrect(winx, winy + dc.font.ascent + 1, width, 1, fg);

	if (base.mode & ATTR_STRUCK)
		blendrect(winx, winy + 2 * dc.font.ascent / 3, width, 1, fg);

	resetclip();
}

void
drawline(Line line, int x1, int y1, int x2)
{
	int i, x, ox, numspecs;
	Glyph base, new;
	GlyphSpec *specs = specbuf;

	if (!specs || !fb.target)
		return;

	numspecs = makeglyphspecs(specs, &line[x1], x2 - x1, x1, y1);
	i = ox = 0;
	for (x = x1; x < x2 && i < numspecs; x++) {
		new = line[x];
		if (new.mode == ATTR_WDUMMY)
			continue;
		if (selected(x, y1))
			new.mode ^= ATTR_REVERSE;
		if (i > 0 && ATTRCMP(base, new)) {
			drawglyphspecs(specs, base, i, ox, y1);
			specs += i;
			numspecs -= i;
			i = 0;
		}
		if (i == 0) {
			ox = x;
			base = new;
		}
		i++;
	}
	if (i > 0)
		drawglyphspecs(specs, base, i, ox, y1);
}

void
drawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og, Line line,
           int len)
{
	uint32_t drawcol;
	int ct;

	/* remove the old cursor */
	if (selected(ox, oy))
		og.mode ^= ATTR_REVERSE;

	/* Redraw the line where cursor was previously.
	 * It will restore the ligatures broken by the cursor. */
	drawline(line, 0, oy, len);

	if (IS_SET(MODE_HIDE))
		return;

	/*
	 * Select the right color for the right mode.
	 */
	g.mode &= ATTR_BOLD|ATTR_ITALIC|ATTR_UNDERLINE|ATTR_STRUCK|ATTR_WIDE|
	          ATTR_BOXDRAW;

	if (IS_SET(MODE_REVERSE)) {
		g.mode |= ATTR_REVERSE;
		g.bg = defaultfg;
		if (selected(cx, cy)) {
			drawcol = dc.col[defaultcs];
			g.fg = defaultrcs;
		} else {
			drawcol = dc.col[defaultrcs];
			g.fg = defaultcs;
		}
	} else {
		if (selected(cx, cy)) {
			g.fg = defaultfg;
			g.bg = defaultrcs;
		} else if (!(og.mode & ATTR_REVERSE)) {
			uint32_t col = g.bg;

			g.bg = g.fg;
			g.fg = col;
		}

		if (IS_TRUECOL(g.bg))
			drawcol = 0xff000000 | (g.bg & 0xffffff);
		else
			drawcol = dc.col[g.bg];
	}

	ct = MAX(1, (int)(cursorthickness * scale + 0.5));

	/* draw the new one */
	if (IS_SET(MODE_FOCUSED)) {
		switch (win.cursor) {
		case 7: /* st extension */
			g.u = 0x2603; /* snowman (U+2603) */
			/* FALLTHROUGH */
		case 0: /* Blinking Block */
		case 1: /* Blinking Block (Default) */
		case 2: /* Steady Block */
			drawglyph(g, cx, cy);
			break;
		case 3: /* Blinking Underline */
		case 4: /* Steady Underline */
			blendrect(win.hborderpx + cx * win.cw,
			          win.vborderpx + (cy + 1) * win.ch - ct,
			          win.cw, ct, drawcol);
			break;
		case 5: /* Blinking bar */
		case 6: /* Steady bar */
			blendrect(win.hborderpx + cx * win.cw,
			          win.vborderpx + cy * win.ch, ct, win.ch,
			          drawcol);
			break;
		}
	} else {
		blendrect(win.hborderpx + cx * win.cw,
		          win.vborderpx + cy * win.ch, win.cw - 1, 1, drawcol);
		blendrect(win.hborderpx + cx * win.cw,
		          win.vborderpx + cy * win.ch, 1, win.ch - 1, drawcol);
		blendrect(win.hborderpx + (cx + 1) * win.cw - 1,
		          win.vborderpx + cy * win.ch, 1, win.ch - 1, drawcol);
		blendrect(win.hborderpx + cx * win.cw,
		          win.vborderpx + (cy + 1) * win.ch - 1, win.cw, 1,
		          drawcol);
	}
}

/* ---- shm buffer / drawing ---- */

int
startdraw(void)
{
	uint32_t padcol;

	if (!fb.data[0] || !IS_SET(MODE_VISIBLE))
		return 0;

	if (fb.busy[fb.cur]) {
		draw_pending = 1;
		return 0;
	}

	/* We commit whole buffers, so every frame repaints the whole screen.
	 * This also keeps the two rotating buffers identical. */
	fb.target = fb.data[fb.cur];
	fb.drawn = 0;
	draw_pending = 0;
	resetclip();

	/* The padding the character grid does not fill keeps the default
	 * background, even under reverse video.  Rows must not paint into it,
	 * a coloured first or last row would otherwise look too tall. */
	padcol = dc.col[IS_SET(MODE_REVERSE) ? defaultfg : defaultbg];
	clearrect(0, 0, win.w, win.vborderpx, padcol);
	clearrect(0, win.vborderpx + win.th, win.w,
	          win.h - (win.vborderpx + win.th), padcol);
	tfulldirt();
	return 1;
}

void
finishdraw(void)
{
	if (!fb.target || !fb.drawn) {
		fb.drawn = 0;
		return;
	}

	wl_surface_attach(surface, fb.buffer[fb.cur], 0, 0);
	if (wl_surface_get_version(surface) >=
	    WL_SURFACE_DAMAGE_BUFFER_SINCE_VERSION)
		wl_surface_damage_buffer(surface, 0, 0, win.w, win.h);
	else
		wl_surface_damage(surface, 0, 0, win.lw, win.lh);
	wl_surface_commit(surface);

	fb.busy[fb.cur] = 1;
	fb.cur ^= 1;
	fb.drawn = 0;
}

static void
bufferrelease(void *data, struct wl_buffer *buffer)
{
	int i = (int)(intptr_t)data;

	fb.busy[i] = 0;
	if (draw_pending) {
		draw_pending = 0;
		pending_event = 1;
	}
}

static int
createshm(size_t size)
{
	int fd;
	char name[32];

	fd = memfd_create("st", MFD_CLOEXEC);
	if (fd < 0) {
		snprintf(name, sizeof(name), "/st-%ld", (long)getpid());
		fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
		if (fd >= 0)
			shm_unlink(name);
	}
	if (fd < 0)
		return -1;
	if (ftruncate(fd, size) < 0) {
		close(fd);
		return -1;
	}
	return fd;
}

static void
destroybuffer(void)
{
	int i;

	for (i = 0; i < 2; i++) {
		if (fb.buffer[i])
			wl_buffer_destroy(fb.buffer[i]);
		if (fb.data[i])
			munmap(fb.data[i], fb.size);
		fb.buffer[i] = NULL;
		fb.data[i] = NULL;
		fb.busy[i] = 0;
	}
	fb.target = NULL;
	fb.size = 0;
	fb.stride = 0;
	fb.cur = 0;
	fb.drawn = 0;
	draw_pending = 0;
}

static int
createbuffer(void)
{
	struct wl_shm_pool *pool;
	int fd, stride, i;

	if (win.w < 1 || win.h < 1)
		return 1;

	stride = win.w * 4;
	fb.size = (size_t)stride * win.h;

	for (i = 0; i < 2; i++) {
		fd = createshm(fb.size);
		if (fd < 0)
			goto fail;

		fb.data[i] = mmap(NULL, fb.size, PROT_READ | PROT_WRITE,
		                  MAP_SHARED, fd, 0);
		if (fb.data[i] == MAP_FAILED) {
			fb.data[i] = NULL;
			close(fd);
			goto fail;
		}

		pool = wl_shm_create_pool(shm, fd, fb.size);
		fb.buffer[i] = wl_shm_pool_create_buffer(pool, 0, win.w, win.h,
		                                         stride,
		                                         WL_SHM_FORMAT_ARGB8888);
		wl_shm_pool_destroy(pool);
		close(fd);

		if (!fb.buffer[i])
			goto fail;
		fb.busy[i] = 0;
	}

	fb.stride = stride;
	fb.cur = 0;
	fb.target = fb.data[0];
	fb.drawn = 0;
	for (i = 0; i < 2; i++)
		wl_buffer_add_listener(fb.buffer[i], &buffer_listener,
		                       (void *)(intptr_t)i);
	return 0;

fail:
	destroybuffer();
	return 1;
}

static void
wlresize(void)
{
	if (createbuffer())
		die("failed to create wl_shm buffer\n");
}

/* ---- window geometry and scaling ---- */

static int
borderpxdev(void)
{
	return borderpx ? MAX(1, (int)ceil(borderpx * scale)) : 0;
}

static double
surfacescale(void)
{
	return use_viewport ? scale : iscale;
}

static int
topx(double v)
{
	return (int)(v * surfacescale() + 0.5);
}

static int
tological(int v)
{
	return (int)(v / surfacescale() + 0.5);
}

static void
updatesize(void)
{
	if (use_viewport) {
		win.w = (int)ceil(win.lw * scale);
		win.h = (int)ceil(win.lh * scale);
		if (surface)
			wl_surface_set_buffer_scale(surface, 1);
		if (viewport && win.lw > 0 && win.lh > 0)
			wp_viewport_set_destination(viewport, win.lw, win.lh);
	} else {
		iscale = MAX(1, (int)ceil(scale));
		win.w = win.lw * iscale;
		win.h = win.lh * iscale;
		if (surface)
			wl_surface_set_buffer_scale(surface, iscale);
	}
	win.w = MAX(1, win.w);
	win.h = MAX(1, win.h);
}

static void
setscale(double s)
{
	int oldviewport = use_viewport;
	int changed;

	if (s <= 0)
		return;

	changed = fabs(s - scale) > 1e-6;
	scale = s;
	use_viewport = have_frac_scale && viewporter != NULL;
	changed = changed || use_viewport != oldviewport;
	updatesize();

	if (!changed || !fontsloaded)
		return;

	unloadfonts();
	loadfonts(usedfont, usedfontsize);
	if (started)
		cresize(win.lw, win.lh);
}

static void
cresize(int lw, int lh)
{
	int col, row, bw;

	if (lw > 0)
		win.lw = lw;
	if (lh > 0)
		win.lh = lh;

	updatesize();
	bw = borderpxdev();

	col = (win.w - 2 * bw) / win.cw;
	row = (win.h - 2 * bw) / win.ch;
	col = MAX(1, col);
	row = MAX(1, row);

	win.hborderpx = (win.w - col * win.cw) / 2;
	win.vborderpx = (win.h - row * win.ch) / 2;
	win.tw = col * win.cw;
	win.th = row * win.ch;

	/* Make sure anything drawn from tresize() (keyboard_select) cannot
	 * touch a buffer the compositor is still reading. */
	specbuf = xrealloc(specbuf, col * sizeof(GlyphSpec));
	destroybuffer();
	tresize(col, row);
	wlresize();
	win.mode |= MODE_VISIBLE;

	if (started)
		ttyresize(win.tw, win.th);
	if (opt_fixed) {
		xdg_toplevel_set_min_size(xdg_toplevel, win.lw, win.lh);
		xdg_toplevel_set_max_size(xdg_toplevel, win.lw, win.lh);
	}
}

/* ---- xdg-shell / surface callbacks ---- */

static void
wmbaseping(void *data, struct xdg_wm_base *base, uint32_t serial)
{
	xdg_wm_base_pong(base, serial);
}

static void
xdgsurfaceconfigure(void *data, struct xdg_surface *s, uint32_t serial)
{
	xdg_surface_ack_configure(s, serial);

	if (conf_w > 0 && conf_h > 0 &&
	    (conf_w != win.lw || conf_h != win.lh)) {
		win.lw = conf_w;
		win.lh = conf_h;
		if (started)
			cresize(win.lw, win.lh);
	}
	configured = 1;
}

static void
toplevelconfigure(void *data, struct xdg_toplevel *t, int32_t w, int32_t h,
                  struct wl_array *states)
{
	conf_w = w;
	conf_h = h;
}

static void
toplevelclose(void *data, struct xdg_toplevel *t)
{
	ttyhangup();
	exit(0);
}

static void
toplevelbounds(void *data, struct xdg_toplevel *t, int32_t w, int32_t h)
{
	/* no size hints on Wayland; the grid is centered instead */
}

static void
toplevelcaps(void *data, struct xdg_toplevel *t, struct wl_array *caps)
{
}

static void
surfaceenter(void *data, struct wl_surface *s, struct wl_output *o)
{
}

static void
surfaceleave(void *data, struct wl_surface *s, struct wl_output *o)
{
}

static void
surfaceprefscale(void *data, struct wl_surface *s, int32_t factor)
{
	/* The integer fallback is only used without fractional-scale. */
	if (fractional_manager)
		return;
	surface_scale = factor;
	setscale(factor);
}

static void
surfacepreftransform(void *data, struct wl_surface *s, uint32_t transform)
{
}

static void
fractionalprefscale(void *data, struct wp_fractional_scale_v1 *fs,
                    uint32_t s)
{
	if (s == 0)
		return;
	frac_scale = s;
	have_frac_scale = 1;
	setscale(s / 120.0);
}

static const struct wl_buffer_listener buffer_listener = {
	.release = bufferrelease,
};

static const struct xdg_wm_base_listener wm_base_listener = {
	.ping = wmbaseping,
};

static const struct xdg_surface_listener xdg_surface_listener = {
	.configure = xdgsurfaceconfigure,
};

static const struct xdg_toplevel_listener xdg_toplevel_listener = {
	.configure = toplevelconfigure,
	.close = toplevelclose,
	.configure_bounds = toplevelbounds,
	.wm_capabilities = toplevelcaps,
};

static const struct wl_surface_listener surface_listener = {
	.enter = surfaceenter,
	.leave = surfaceleave,
	.preferred_buffer_scale = surfaceprefscale,
	.preferred_buffer_transform = surfacepreftransform,
};

static const struct wp_fractional_scale_v1_listener fractional_listener = {
	.preferred_scale = fractionalprefscale,
};

/* ---- clipboard and primary selection ---- */

static const char *mimetypes[] = {
	"text/plain;charset=utf-8",
	"UTF8_STRING",
	"text/plain",
	"STRING",
	"TEXT",
};

static void
offeraddmime(Offer *o, const char *mime)
{
	o->mimes = xrealloc(o->mimes, (o->nmimes + 1) * sizeof(char *));
	o->mimes[o->nmimes++] = xstrdup((char *)mime);
}

static void
offerdestroy(Offer *o)
{
	int i;

	if (!o)
		return;
	if (o->data)
		wl_data_offer_destroy(o->data);
	if (o->primary)
		zwp_primary_selection_offer_v1_destroy(o->primary);
	for (i = 0; i < o->nmimes; i++)
		free(o->mimes[i]);
	free(o->mimes);
	free(o);
}

static const char *
offerpicked(Offer *o)
{
	size_t i;
	int j;

	if (!o)
		return NULL;

	for (i = 0; i < LEN(mimetypes); i++)
		for (j = 0; j < o->nmimes; j++)
			if (!strcmp(o->mimes[j], mimetypes[i]))
				return mimetypes[i];
	return NULL;
}

static void
offerreceive(Offer *o, int fd)
{
	const char *mime = offerpicked(o);

	if (!mime) {
		fprintf(stderr, "no usable selection mime type\n");
		close(fd);
		return;
	}
	if (o->data)
		wl_data_offer_receive(o->data, mime, fd);
	else
		zwp_primary_selection_offer_v1_receive(o->primary, mime, fd);
	close(fd);
}

static void
transferdone(Transfer *t)
{
	Transfer **pp;

	for (pp = &transfers; *pp; pp = &(*pp)->next)
		if (*pp == t) {
			*pp = t->next;
			break;
		}
	close(t->fd);
	free(t->buf);
	free(t);
}

static void
transferready(Transfer *t)
{
	char buf[8192];
	char *p;
	ssize_t n;

	if (t->writing) {
		while (t->off < t->len) {
			n = write(t->fd, t->buf + t->off, t->len - t->off);
			if (n < 0) {
				if (errno == EINTR)
					continue;
				if (errno == EAGAIN)
					return;
				transferdone(t);
				return;
			}
			t->off += n;
		}
		transferdone(t);
		return;
	}

	for (;;) {
		n = read(t->fd, buf, sizeof(buf));
		if (n < 0) {
			if (errno == EINTR)
				continue;
			if (errno == EAGAIN)
				return;
			transferdone(t);
			return;
		}
		if (n == 0) {
			if (t->len) {
				t->buf = xrealloc(t->buf, t->len + 1);
				t->buf[t->len] = '\0';
				for (p = t->buf; *p; p++)
					if (*p == '\n')
						*p = '\r';
				if (IS_SET(MODE_BRCKTPASTE))
					ttywrite("\033[200~", 6, 0);
				ttywrite(t->buf, t->len, 1);
				if (IS_SET(MODE_BRCKTPASTE))
					ttywrite("\033[201~", 6, 0);
			}
			transferdone(t);
			return;
		}
		if (t->len + n > t->cap) {
			t->cap = MAX(8192, t->len + n);
			t->buf = xrealloc(t->buf, t->cap);
		}
		memcpy(t->buf + t->len, buf, n);
		t->len += n;
	}
}

static void
transferadd(int fd, int writing, const char *buf, size_t len)
{
	Transfer *t;

	t = xmalloc(sizeof(*t));
	memset(t, 0, sizeof(*t));
	t->fd = fd;
	t->writing = writing;
	if (writing) {
		t->buf = xstrdup((char *)buf);
		t->len = len;
	}
	t->next = transfers;
	transfers = t;

	if (writing)
		transferready(t);
}

static void
transferspoll(struct pollfd *pfd)
{
	Transfer *t, *next;
	int i = 0;

	for (t = transfers; t; t = next, i++) {
		next = t->next;
		if (pfd[i].revents)
			transferready(t);
	}
}

static void
pasteselection(Offer *o)
{
	int fds[2];

	if (!o)
		return;

	if (pipe2(fds, O_CLOEXEC) < 0) {
		fprintf(stderr, "pipe2: %s\n", strerror(errno));
		return;
	}
	fcntl(fds[0], F_SETFL, O_NONBLOCK);
	offerreceive(o, fds[1]);
	transferadd(fds[0], 0, NULL, 0);
}

static void
sourcedestroy(Source *s)
{
	if (!s)
		return;
	if (s->data) {
		if (clipboard_source == s)
			clipboard_source = NULL;
		wl_data_source_destroy(s->data);
	}
	if (s->primary) {
		if (primary_source == s)
			primary_source = NULL;
		zwp_primary_selection_source_v1_destroy(s->primary);
	}
	free(s->text);
	free(s);
}

static void
newsource(int primary, const char *text)
{
	Source *s;
	size_t i;

	s = xmalloc(sizeof(*s));
	memset(s, 0, sizeof(*s));
	s->text = xstrdup((char *)text);

	if (primary && primary_manager && primary_device) {
		s->primary =
			zwp_primary_selection_device_manager_v1_create_source(
				primary_manager);
		zwp_primary_selection_source_v1_add_listener(
			s->primary, &primary_source_listener, s);
		for (i = 0; i < LEN(mimetypes); i++)
			zwp_primary_selection_source_v1_offer(s->primary,
			                                      mimetypes[i]);
		primary_source = s;
		zwp_primary_selection_device_v1_set_selection(
			primary_device, s->primary, last_serial);
	} else if (!primary && data_manager && data_device) {
		s->data = wl_data_device_manager_create_data_source(data_manager);
		wl_data_source_add_listener(s->data, &data_source_listener, s);
		for (i = 0; i < LEN(mimetypes); i++)
			wl_data_source_offer(s->data, mimetypes[i]);
		clipboard_source = s;
		wl_data_device_set_selection(data_device, s->data, last_serial);
	} else {
		free(s->text);
		free(s);
	}
}

void
setsel(char *str)
{
	if (!str)
		return;

	free(xsel.primary);
	xsel.primary = str;

	newsource(1, xsel.primary);
	newsource(0, xsel.primary);
}

void
clipcopy(const Arg *dummy)
{
	(void)dummy;

	if (xsel.primary)
		newsource(0, xsel.primary);
}

static void
clippaste(const Arg *dummy)
{
	(void)dummy;

	pasteselection(clipboard_offer);
}

static void
selpaste(const Arg *dummy)
{
	(void)dummy;

	if (primary_offer)
		pasteselection(primary_offer);
	else
		pasteselection(clipboard_offer);
}

/* ---- selection listeners ---- */

static void
offeroffer(void *data, struct wl_data_offer *offer, const char *mime)
{
	offeraddmime(data, mime);
}

static void
primaryofferoffer(void *data, struct zwp_primary_selection_offer_v1 *offer,
                  const char *mime)
{
	offeraddmime(data, mime);
}

static void
dataoffer(void *data, struct wl_data_device *dev, struct wl_data_offer *id)
{
	Offer *o;

	offerdestroy(pending_offer);
	o = xmalloc(sizeof(*o));
	memset(o, 0, sizeof(*o));
	o->data = id;
	wl_data_offer_add_listener(id, &data_offer_listener, o);
	pending_offer = o;
}

static void
dataenter(void *data, struct wl_data_device *dev, uint32_t serial,
          struct wl_surface *s, wl_fixed_t x, wl_fixed_t y,
          struct wl_data_offer *id)
{
	/* Drag and drop is not implemented; drop the offer. */
	if (pending_offer && pending_offer->data == id) {
		offerdestroy(pending_offer);
		pending_offer = NULL;
	}
}

static void
dataleave(void *data, struct wl_data_device *dev)
{
}

static void
datamotion(void *data, struct wl_data_device *dev, uint32_t time,
           wl_fixed_t x, wl_fixed_t y)
{
}

static void
datadrop(void *data, struct wl_data_device *dev)
{
}

static void
dataselection(void *data, struct wl_data_device *dev,
              struct wl_data_offer *id)
{
	if (!id) {
		offerdestroy(clipboard_offer);
		clipboard_offer = NULL;
		return;
	}
	if (pending_offer && pending_offer->data == id) {
		offerdestroy(clipboard_offer);
		clipboard_offer = pending_offer;
		pending_offer = NULL;
	}
}

static void
primaryoffer(void *data, struct zwp_primary_selection_device_v1 *dev,
             struct zwp_primary_selection_offer_v1 *id)
{
	Offer *o;

	offerdestroy(pending_primary_offer);
	o = xmalloc(sizeof(*o));
	memset(o, 0, sizeof(*o));
	o->primary = id;
	zwp_primary_selection_offer_v1_add_listener(id,
	                                            &primary_offer_listener, o);
	pending_primary_offer = o;
}

static void
primaryselection(void *data, struct zwp_primary_selection_device_v1 *dev,
                 struct zwp_primary_selection_offer_v1 *id)
{
	if (!id) {
		offerdestroy(primary_offer);
		primary_offer = NULL;
		return;
	}
	if (pending_primary_offer && pending_primary_offer->primary == id) {
		offerdestroy(primary_offer);
		primary_offer = pending_primary_offer;
		pending_primary_offer = NULL;
	}
}

static void
datasourcesend(void *data, struct wl_data_source *src, const char *mime,
               int32_t fd)
{
	Source *s = data;

	fcntl(fd, F_SETFL, O_NONBLOCK);
	transferadd(fd, 1, s->text, strlen(s->text));
}

static void
datasourcecancelled(void *data, struct wl_data_source *src)
{
	sourcedestroy(data);
}

static void
primarysourcesend(void *data,
                  struct zwp_primary_selection_source_v1 *src,
                  const char *mime, int32_t fd)
{
	Source *s = data;

	fcntl(fd, F_SETFL, O_NONBLOCK);
	transferadd(fd, 1, s->text, strlen(s->text));
}

static void
primarysourcecancelled(void *data,
                       struct zwp_primary_selection_source_v1 *src)
{
	sourcedestroy(data);
}

static const struct wl_data_offer_listener data_offer_listener = {
	.offer = offeroffer,
};

static const struct zwp_primary_selection_offer_v1_listener
primary_offer_listener = {
	.offer = primaryofferoffer,
};

static const struct wl_data_source_listener data_source_listener = {
	.target = NULL,
	.send = datasourcesend,
	.cancelled = datasourcecancelled,
};

static const struct zwp_primary_selection_source_v1_listener
primary_source_listener = {
	.send = primarysourcesend,
	.cancelled = primarysourcecancelled,
};

static const struct wl_data_device_listener data_device_listener = {
	.data_offer = dataoffer,
	.enter = dataenter,
	.leave = dataleave,
	.motion = datamotion,
	.drop = datadrop,
	.selection = dataselection,
};

static const struct zwp_primary_selection_device_v1_listener
primary_device_listener = {
	.data_offer = primaryoffer,
	.selection = primaryselection,
};

/* ---- input method ---- */

static void
imespotsend(void)
{
	int x, y;

	if (!text_input || !ime_enabled)
		return;

	x = win.hborderpx + ime_x * win.cw;
	y = win.vborderpx + ime_y * win.ch;
	zwp_text_input_v3_set_cursor_rectangle(text_input, tological(x),
	                                       tological(y), tological(win.cw),
	                                       tological(win.ch));
	zwp_text_input_v3_commit(text_input);
}

static void
imeenable(void)
{
	if (!text_input || ime_enabled)
		return;

	zwp_text_input_v3_enable(text_input);
	zwp_text_input_v3_set_content_type(text_input,
	                                   ZWP_TEXT_INPUT_V3_CONTENT_HINT_NONE,
	                                   ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_TERMINAL);
	ime_enabled = 1;
	imespotsend();
}

static void
imedisable(void)
{
	if (!text_input || !ime_enabled)
		return;

	zwp_text_input_v3_disable(text_input);
	zwp_text_input_v3_commit(text_input);
	ime_enabled = 0;
	ime_active = 0;
}

void
imespot(int x, int y)
{
	ime_x = x;
	ime_y = y;
	imespotsend();
}

static void
textinputenter(void *data, struct zwp_text_input_v3 *ti,
               struct wl_surface *s)
{
}

static void
textinputleave(void *data, struct zwp_text_input_v3 *ti,
               struct wl_surface *s)
{
	ime_active = 0;
}

static void
textinputpreedit(void *data, struct zwp_text_input_v3 *ti, const char *text,
                 int32_t begin, int32_t end)
{
	/* The preedit is not rendered here; it only gates key handling. */
	pendingdiscard();
	ime_active = text != NULL && *text != '\0';
}

static void
textinputcommit(void *data, struct zwp_text_input_v3 *ti, const char *text)
{
	pendingdiscard();
	if (!text || !*text)
		return;

	ttywrite(text, strlen(text), 1);
	ime_active = 0;
}

static void
textinputdelete(void *data, struct zwp_text_input_v3 *ti, uint32_t before,
                uint32_t after)
{
}

static void
textinputdone(void *data, struct zwp_text_input_v3 *ti, uint32_t serial)
{
}

static void
textinputaction(void *data, struct zwp_text_input_v3 *ti, uint32_t action,
                uint32_t serial)
{
}

static void
textinputlanguage(void *data, struct zwp_text_input_v3 *ti, const char *lang)
{
}

static void
textinputpreedithint(void *data, struct zwp_text_input_v3 *ti,
                     uint32_t start, uint32_t end, uint32_t hint)
{
}

static const struct zwp_text_input_v3_listener text_input_listener = {
	.enter = textinputenter,
	.leave = textinputleave,
	.preedit_string = textinputpreedit,
	.commit_string = textinputcommit,
	.delete_surrounding_text = textinputdelete,
	.done = textinputdone,
	.action = textinputaction,
	.language = textinputlanguage,
	.preedit_hint = textinputpreedithint,
};

/* ---- keyboard ---- */

static uint
modmask(void)
{
	uint mask = 0;

	if (!xkbstate)
		return 0;

	if (shift_idx >= 0 && xkb_state_mod_index_is_active(
	        xkbstate, shift_idx, XKB_STATE_MODS_EFFECTIVE))
		mask |= ShiftMask;
	if (lock_idx >= 0 && xkb_state_mod_index_is_active(
	        xkbstate, lock_idx, XKB_STATE_MODS_EFFECTIVE))
		mask |= LockMask;
	if (ctrl_idx >= 0 && xkb_state_mod_index_is_active(
	        xkbstate, ctrl_idx, XKB_STATE_MODS_EFFECTIVE))
		mask |= ControlMask;
	if (mod1_idx >= 0 && xkb_state_mod_index_is_active(
	        xkbstate, mod1_idx, XKB_STATE_MODS_EFFECTIVE))
		mask |= Mod1Mask;
	if (mod2_idx >= 0 && xkb_state_mod_index_is_active(
	        xkbstate, mod2_idx, XKB_STATE_MODS_EFFECTIVE))
		mask |= Mod2Mask;
	if (mod3_idx >= 0 && xkb_state_mod_index_is_active(
	        xkbstate, mod3_idx, XKB_STATE_MODS_EFFECTIVE))
		mask |= Mod3Mask;
	if (mod4_idx >= 0 && xkb_state_mod_index_is_active(
	        xkbstate, mod4_idx, XKB_STATE_MODS_EFFECTIVE))
		mask |= Mod4Mask;
	if (mod5_idx >= 0 && xkb_state_mod_index_is_active(
	        xkbstate, mod5_idx, XKB_STATE_MODS_EFFECTIVE))
		mask |= Mod5Mask;

	return mask;
}

static void
updatemods(void)
{
	uint mask;

	if (!xkbstate)
		return;
	mask = modmask();
	MODBIT(win.mode, (mask & Mod2Mask) != 0, MODE_NUMLOCK);
}

static int
match(uint mask, uint state)
{
	return mask == MOD_ANY || mask == (state & ~ignoremod);
}

static char *
kmap(KeySym k, uint state)
{
	Key *kp;
	int i;

	/* Check for mapped keys out of X11 function keys. */
	for (i = 0; i < LEN(mappedkeys); i++) {
		if (mappedkeys[i] == k)
			break;
	}
	if (i == LEN(mappedkeys)) {
		if ((k & 0xFFFF) < 0xFD00)
			return NULL;
	}

	for (kp = key; kp < key + LEN(key); kp++) {
		if (kp->k != k)
			continue;

		if (!match(kp->mask, state))
			continue;

		if (IS_SET(MODE_APPKEYPAD) ? kp->appkey < 0 : kp->appkey > 0)
			continue;
		if (IS_SET(MODE_NUMLOCK) && kp->appkey == 2)
			continue;

		if (IS_SET(MODE_APPCURSOR) ? kp->appcursor < 0 : kp->appcursor > 0)
			continue;

		return kp->s;
	}

	return NULL;
}

/* xkbcommon returns the level text; apply the classic Ctrl mapping. */
static int
ctrlfilter(char *buf, int len)
{
	uchar c;

	if (len != 1 || !(modmask() & ControlMask))
		return len;

	c = buf[0];
	if (c >= '@' && c <= '_')
		buf[0] = c & 0x1f;
	else if (c >= 'a' && c <= 'z')
		buf[0] = c & 0x1f;
	else if (c == '?')
		buf[0] = 0x7f;
	else if (c == ' ')
		buf[0] = 0;

	return len;
}

static int
keytext(xkb_keycode_t keycode, char *buf, int len)
{
	enum xkb_compose_status status;
	KeySym sym;
	int n;

	sym = xkb_state_key_get_one_sym(xkbstate, keycode);

	if (composestate) {
		xkb_compose_state_feed(composestate, sym);
		status = xkb_compose_state_get_status(composestate);
		if (status == XKB_COMPOSE_COMPOSING)
			return 0;
		if (status == XKB_COMPOSE_COMPOSED) {
			n = xkb_compose_state_get_utf8(composestate, buf, len);
			xkb_compose_state_reset(composestate);
			return n > 0 ? ctrlfilter(buf, n) : 0;
		}
		if (status == XKB_COMPOSE_CANCELLED) {
			xkb_compose_state_reset(composestate);
			return 0;
		}
	}

	n = xkb_state_key_get_utf8(xkbstate, keycode, buf, len);
	if (n <= 0)
		return 0;

	return ctrlfilter(buf, n);
}

/* Input methods see the same key events we do and react a few milliseconds
 * later.  Hold printable text back for IMEWAIT ms: if the IME produces a
 * preedit or commit in the meantime, the key belonged to it and is dropped. */
static void
pendingflush(void)
{
	if (!pendinglen)
		return;

	ttywrite(pendingtext, pendinglen, 1);
	pendinglen = 0;
}

static void
pendingdiscard(void)
{
	pendinglen = 0;
}

static void
textqueue(const char *buf, size_t len)
{
	struct timespec now;

	if (pendinglen + len > pendingcap) {
		pendingcap = MAX(64, pendinglen + len);
		pendingtext = xrealloc(pendingtext, pendingcap);
	}

	if (!pendinglen) {
		clock_gettime(CLOCK_MONOTONIC, &now);
		pendinguntil = now;
		pendinguntil.tv_nsec += IMEWAIT * 1000000L;
		if (pendinguntil.tv_nsec >= 1000000000L) {
			pendinguntil.tv_sec++;
			pendinguntil.tv_nsec -= 1000000000L;
		}
	}

	memcpy(pendingtext + pendinglen, buf, len);
	pendinglen += len;
}

static int
hascontrol(const char *buf, int len)
{
	int i;

	for (i = 0; i < len; i++)
		if ((uchar)buf[i] < 0x20 || buf[i] == 0x7f)
			return 1;
	return 0;
}

static void
keypress(xkb_keycode_t keycode)
{
	KeySym sym;
	uint state;
	char buf[64];
	int len;
	Shortcut *bp;
	char *customkey;

	if (pointer && !pointer_hidden)
		hidepointer(pointer_serial ? pointer_serial : last_serial);

	if (IS_SET(MODE_KBDLOCK))
		return;

	if (ime_active)
		return;

	sym = xkb_state_key_get_one_sym(xkbstate, keycode);
	state = modmask();
	if (IS_SET(MODE_KBDSELECT)) {
		pendingflush();
		len = keytext(keycode, buf, sizeof(buf));
		if (match(MOD_NONE, state) || (state & ShiftMask))
			win.mode ^= trt_kbdselect(sym, buf, len);
		return;
	}

	/* 1. shortcuts */
	for (bp = shortcuts; bp < shortcuts + LEN(shortcuts); bp++) {
		if (sym == bp->keysym && match(bp->mod, state)) {
			pendingflush();
			bp->func(&(bp->arg));
			return;
		}
	}

	/* 2. custom keys from config.h */
	if ((customkey = kmap(sym, state))) {
		pendingflush();
		ttywrite(customkey, strlen(customkey), 1);
		return;
	}

	/* 3. composed string from input method */
	len = keytext(keycode, buf, sizeof(buf));
	if (len == 0)
		return;

	if (len == 1 && state & Mod1Mask) {
		pendingflush();
		if (IS_SET(MODE_8BIT)) {
			if (*buf < 0177) {
				Rune c = *buf | 0x80;

				len = utf8encode(c, buf);
			}
		} else {
			buf[1] = buf[0];
			buf[0] = '\033';
			len = 2;
		}
	}

	if (!text_input || hascontrol(buf, len)) {
		pendingflush();
		ttywrite(buf, len, 1);
	} else {
		textqueue(buf, len);
	}
}

static void
startrepeat(xkb_keycode_t keycode)
{
	struct itimerspec ts;

	if (!xkbkeymap || !repeatrate ||
	    !xkb_keymap_key_repeats(xkbkeymap, keycode)) {
		stoprepeat();
		return;
	}

	if (repeatfd < 0) {
		repeatfd = timerfd_create(CLOCK_MONOTONIC,
		                          TFD_NONBLOCK | TFD_CLOEXEC);
		if (repeatfd < 0)
			return;
	}

	repeatkey = keycode;
	memset(&ts, 0, sizeof(ts));
	ts.it_value.tv_sec = repeatdelay / 1000;
	ts.it_value.tv_nsec = (repeatdelay % 1000) * 1000000L;
	ts.it_interval.tv_nsec = 1000000000L / repeatrate;
	timerfd_settime(repeatfd, 0, &ts, NULL);
}

static void
stoprepeat(void)
{
	struct itimerspec ts;

	repeatkey = 0;
	if (repeatfd < 0)
		return;

	memset(&ts, 0, sizeof(ts));
	timerfd_settime(repeatfd, 0, &ts, NULL);
}

static void
repeattick(void)
{
	uint64_t exp;

	if (repeatfd < 0 || !repeatkey)
		return;
	if (read(repeatfd, &exp, sizeof(exp)) != sizeof(exp))
		return;
	keypress(repeatkey);
}

static void
numlock(const Arg *dummy)
{
	(void)dummy;
	win.mode ^= MODE_NUMLOCK;
}

/* ---- cursor shape ---- */

static uint32_t
cursorshapeid(void)
{
	const char *s = mouseshape;

	if (!strcmp(s, "text"))
		return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_TEXT;
	if (!strcmp(s, "pointer") || !strcmp(s, "hand1") ||
	    !strcmp(s, "hand2"))
		return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_POINTER;
	if (!strcmp(s, "crosshair"))
		return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_CROSSHAIR;
	if (!strcmp(s, "wait"))
		return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_WAIT;
	if (!strcmp(s, "progress"))
		return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_PROGRESS;
	if (!strcmp(s, "move") || !strcmp(s, "fleur"))
		return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_MOVE;
	if (!strcmp(s, "ew-resize") || !strcmp(s, "sb_h_double_arrow"))
		return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_EW_RESIZE;
	if (!strcmp(s, "ns-resize") || !strcmp(s, "sb_v_double_arrow"))
		return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NS_RESIZE;
	if (!strcmp(s, "nw-resize"))
		return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NW_RESIZE;
	if (!strcmp(s, "ne-resize"))
		return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NE_RESIZE;
	if (!strcmp(s, "sw-resize"))
		return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_SW_RESIZE;
	if (!strcmp(s, "se-resize"))
		return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_SE_RESIZE;
	return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT;
}

static void
setcursorshape(uint32_t serial)
{
	if (!cursor_shape)
		return;
	wp_cursor_shape_device_v1_set_shape(cursor_shape, serial,
	                                    cursorshapeid());
}

static void
hidepointer(uint32_t serial)
{
	if (!pointer || !cursor_shape || pointer_hidden)
		return;
	wl_pointer_set_cursor(pointer, serial, NULL, 0, 0);
	pointer_hidden = 1;
}

static void
showpointer(uint32_t serial)
{
	if (!pointer)
		return;
	if (cursor_shape)
		setcursorshape(serial);
	pointer_hidden = 0;
}

/* ---- seat and keyboard ---- */

static void
seatcapabilities(void *data, struct wl_seat *s, uint32_t caps)
{
	if ((caps & WL_SEAT_CAPABILITY_POINTER) && !pointer) {
		pointer = wl_seat_get_pointer(s);
		wl_pointer_add_listener(pointer, &pointer_listener, NULL);
		if (cursor_shape_manager)
			cursor_shape = wp_cursor_shape_manager_v1_get_pointer(
				cursor_shape_manager, pointer);
	} else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && pointer) {
		if (cursor_shape) {
			wp_cursor_shape_device_v1_destroy(cursor_shape);
			cursor_shape = NULL;
		}
		wl_pointer_destroy(pointer);
		pointer = NULL;
	}

	if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !keyboard) {
		keyboard = wl_seat_get_keyboard(s);
		wl_keyboard_add_listener(keyboard, &keyboard_listener, NULL);
	} else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && keyboard) {
		wl_keyboard_destroy(keyboard);
		keyboard = NULL;
	}
}

static void
seatname(void *data, struct wl_seat *s, const char *name)
{
}

static void
keyboardkeymap(void *data, struct wl_keyboard *kb, uint32_t format,
               int32_t fd, uint32_t size)
{
	struct xkb_keymap *keymap;
	char *map;

	if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
		close(fd);
		return;
	}

	map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
	if (map == MAP_FAILED) {
		close(fd);
		return;
	}

	keymap = xkb_keymap_new_from_string(xkbcontext, map,
	                                    XKB_KEYMAP_FORMAT_TEXT_V1,
	                                    XKB_KEYMAP_COMPILE_NO_FLAGS);
	munmap(map, size);
	close(fd);

	if (!keymap)
		return;

	if (xkbstate)
		xkb_state_unref(xkbstate);
	if (xkbkeymap)
		xkb_keymap_unref(xkbkeymap);
	xkbkeymap = keymap;
	xkbstate = xkb_state_new(xkbkeymap);
	if (!xkbstate)
		die("failed to create xkb state\n");

	shift_idx = xkb_keymap_mod_get_index(xkbkeymap, XKB_MOD_NAME_SHIFT);
	lock_idx = xkb_keymap_mod_get_index(xkbkeymap, XKB_MOD_NAME_CAPS);
	ctrl_idx = xkb_keymap_mod_get_index(xkbkeymap, XKB_MOD_NAME_CTRL);
	mod1_idx = xkb_keymap_mod_get_index(xkbkeymap, XKB_MOD_NAME_ALT);
	mod2_idx = xkb_keymap_mod_get_index(xkbkeymap, XKB_MOD_NAME_NUM);
	mod3_idx = xkb_keymap_mod_get_index(xkbkeymap, "Mod3");
	mod4_idx = xkb_keymap_mod_get_index(xkbkeymap, XKB_MOD_NAME_LOGO);
	mod5_idx = xkb_keymap_mod_get_index(xkbkeymap, "Mod5");
}

static void
keyboardenter(void *data, struct wl_keyboard *kb, uint32_t serial,
              struct wl_surface *s, struct wl_array *keys)
{
	last_serial = serial;
	win.mode |= MODE_FOCUSED;
	if (IS_SET(MODE_FOCUS))
		ttywrite("\033[I", 3, 0);
	imeenable();
}

static void
keyboardleave(void *data, struct wl_keyboard *kb, uint32_t serial,
              struct wl_surface *s)
{
	last_serial = serial;
	pendingflush();
	win.mode &= ~MODE_FOCUSED;
	if (IS_SET(MODE_FOCUS))
		ttywrite("\033[O", 3, 0);
	stoprepeat();
	imedisable();
}

static void
keyboardkey(void *data, struct wl_keyboard *kb, uint32_t serial,
            uint32_t time, uint32_t key, uint32_t state)
{
	xkb_keycode_t keycode = key + 8;

	last_serial = serial;

	if (!xkbstate)
		return;

	if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
		xkb_state_update_key(xkbstate, keycode, XKB_KEY_DOWN);
		updatemods();
		keypress(keycode);
		startrepeat(keycode);
	} else {
		xkb_state_update_key(xkbstate, keycode, XKB_KEY_UP);
		updatemods();
		if (keycode == repeatkey)
			stoprepeat();
	}
}

static void
keyboardmodifiers(void *data, struct wl_keyboard *kb, uint32_t serial,
                  uint32_t depressed, uint32_t latched, uint32_t locked,
                  uint32_t group)
{
	last_serial = serial;
	if (!xkbstate)
		return;

	xkb_state_update_mask(xkbstate, depressed, latched, locked, 0, 0, group);
	updatemods();
}

static void
keyboardrepeat(void *data, struct wl_keyboard *kb, int32_t rate,
               int32_t delay)
{
	if (rate <= 0 || delay <= 0) {
		repeatrate = 0;
		stoprepeat();
		return;
	}
	repeatrate = rate;
	repeatdelay = delay;
	if (repeatkey)
		startrepeat(repeatkey);
}

static const struct wl_seat_listener seat_listener = {
	.capabilities = seatcapabilities,
	.name = seatname,
};

static const struct wl_keyboard_listener keyboard_listener = {
	.keymap = keyboardkeymap,
	.enter = keyboardenter,
	.leave = keyboardleave,
	.key = keyboardkey,
	.modifiers = keyboardmodifiers,
	.repeat_info = keyboardrepeat,
};

/* ---- pointer ---- */

static void
pointerenter(void *data, struct wl_pointer *p, uint32_t serial,
             struct wl_surface *s, wl_fixed_t sx, wl_fixed_t sy)
{
	pointer_serial = serial;
	last_serial = serial;
	pointer_x = topx(wl_fixed_to_double(sx));
	pointer_y = topx(wl_fixed_to_double(sy));
	showpointer(serial);
}

static void
pointerleave(void *data, struct wl_pointer *p, uint32_t serial,
             struct wl_surface *s)
{
	pointer_serial = 0;
}

static void
pointermotion(void *data, struct wl_pointer *p, uint32_t time,
              wl_fixed_t sx, wl_fixed_t sy)
{
	MouseEvent ev;

	memset(&ev, 0, sizeof(ev));
	ev.type = 0;
	ev.x = pointer_x = topx(wl_fixed_to_double(sx));
	ev.y = pointer_y = topx(wl_fixed_to_double(sy));
	ev.state = buttonstate | modmask();
	ev.time = time;
	bmotion(&ev);
}

static void
pointerbutton(void *data, struct wl_pointer *p, uint32_t serial,
              uint32_t time, uint32_t button, uint32_t state)
{
	MouseEvent ev;
	uint b;

	switch (button) {
	case BTN_LEFT:
		b = Button1;
		break;
	case BTN_MIDDLE:
		b = Button2;
		break;
	case BTN_RIGHT:
		b = Button3;
		break;
	case BTN_SIDE:
		b = 8;
		break;
	case BTN_EXTRA:
		b = 9;
		break;
	default:
		return;
	}

	pointer_serial = serial;
	last_serial = serial;

	memset(&ev, 0, sizeof(ev));
	ev.x = pointer_x;
	ev.y = pointer_y;
	ev.button = b;
	ev.serial = serial;
	ev.time = time;
	ev.state = buttonstate | modmask();

	if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
		ev.type = 1;
		bpress(&ev);
		buttonstate |= buttonmask(b);
	} else {
		ev.type = 2;
		brelease(&ev);
		buttonstate &= ~buttonmask(b);
	}
}

static void
pointeraxis(void *data, struct wl_pointer *p, uint32_t time, uint32_t axis,
            wl_fixed_t value)
{
	if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL)
		axis_y += wl_fixed_to_double(value);
	else
		axis_x += wl_fixed_to_double(value);
}

static void
pointeraxisdisc(void *data, struct wl_pointer *p, uint32_t axis,
                int32_t value)
{
	if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL)
		axis_dy += value;
	else
		axis_dx += value;
}

static void
pointeraxissource(void *data, struct wl_pointer *p, uint32_t source)
{
}

static void
pointeraxisstop(void *data, struct wl_pointer *p, uint32_t time,
                uint32_t axis)
{
	if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL) {
		axis_dy = 0;
		axis_y = 0;
	} else {
		axis_dx = 0;
		axis_x = 0;
	}
}

static void
wheel(uint button)
{
	MouseEvent ev;

	memset(&ev, 0, sizeof(ev));
	ev.x = pointer_x;
	ev.y = pointer_y;
	ev.button = button;
	ev.state = buttonstate | modmask();
	ev.type = 1;
	bpress(&ev);
	ev.type = 2;
	brelease(&ev);
}

static void
pointerframe(void *data, struct wl_pointer *p)
{
	int n, i;

	if (axis_dy) {
		n = MIN(axis_dy < 0 ? -axis_dy : axis_dy, 8);
		for (i = 0; i < n; i++)
			wheel(axis_dy < 0 ? Button4 : Button5);
	} else if (axis_y <= -10.0 || axis_y >= 10.0) {
		wheel(axis_y < 0 ? Button4 : Button5);
	}

	if (axis_dx) {
		n = MIN(axis_dx < 0 ? -axis_dx : axis_dx, 8);
		for (i = 0; i < n; i++)
			wheel(axis_dx < 0 ? Button6 : Button7);
	} else if (axis_x <= -10.0 || axis_x >= 10.0) {
		wheel(axis_x < 0 ? Button6 : Button7);
	}

	axis_dy = 0;
	axis_dx = 0;
	axis_y = 0;
	axis_x = 0;
}

static const struct wl_pointer_listener pointer_listener = {
	.enter = pointerenter,
	.leave = pointerleave,
	.motion = pointermotion,
	.button = pointerbutton,
	.axis = pointeraxis,
	.frame = pointerframe,
	.axis_source = pointeraxissource,
	.axis_stop = pointeraxisstop,
	.axis_discrete = pointeraxisdisc,
};

void
setpointermotion(int set)
{
	/* The compositor always sends motion events. */
	(void)set;
}

/* ---- mouse selection and reporting ---- */

static uint
buttonmask(uint button)
{
	return button == Button1 ? Button1Mask
	     : button == Button2 ? Button2Mask
	     : button == Button3 ? Button3Mask
	     : button == Button4 ? Button4Mask
	     : button == Button5 ? Button5Mask
	     : 0;
}

static int
evcol(MouseEvent *e)
{
	int x = e->x - win.hborderpx;

	LIMIT(x, 0, win.tw - 1);
	return x / win.cw;
}

static int
evrow(MouseEvent *e)
{
	int y = e->y - win.vborderpx;

	LIMIT(y, 0, win.th - 1);
	return y / win.ch;
}

static void
mousesel(MouseEvent *e, int done)
{
	int type, seltype = SEL_REGULAR;
	uint state = e->state & ~(Button1Mask | forcemousemod);

	for (type = 1; type < LEN(selmasks); ++type) {
		if (match(selmasks[type], state)) {
			seltype = type;
			break;
		}
	}
	selextend(evcol(e), evrow(e), seltype, done);
	if (done)
		setsel(getsel());
}

static void
mousereport(MouseEvent *e)
{
	int len, x = evcol(e), y = evrow(e),
	    button = e->button, state = e->state;
	char buf[40];
	static int ox, oy;

	/* from urxvt */
	if (e->type == 0) {
		if (x == ox && y == oy)
			return;
		if (!IS_SET(MODE_MOUSEMOTION) && !IS_SET(MODE_MOUSEMANY))
			return;
		/* MOUSE_MOTION: no reporting if no button is pressed */
		if (IS_SET(MODE_MOUSEMOTION) && oldbutton == 3)
			return;

		button = oldbutton + 32;
		ox = x;
		oy = y;
	} else {
		if (!IS_SET(MODE_MOUSESGR) && e->type == 2) {
			button = 3;
		} else {
			button -= Button1;
			if (button >= 3)
				button += 64 - 3;
		}
		if (e->type == 1) {
			oldbutton = button;
			ox = x;
			oy = y;
		} else if (e->type == 2) {
			oldbutton = 3;
			/* MODE_MOUSEX10: no button release reporting */
			if (IS_SET(MODE_MOUSEX10))
				return;
			if (button == 64 || button == 65)
				return;
		}
	}

	if (!IS_SET(MODE_MOUSEX10)) {
		button += ((state & ShiftMask) ? 4 : 0)
		        + ((state & Mod4Mask) ? 8 : 0)
		        + ((state & ControlMask) ? 16 : 0);
	}

	if (IS_SET(MODE_MOUSESGR)) {
		len = snprintf(buf, sizeof(buf), "\033[<%d;%d;%d%c",
		               button, x + 1, y + 1,
		               e->type == 2 ? 'm' : 'M');
	} else if (x < 223 && y < 223) {
		len = snprintf(buf, sizeof(buf), "\033[M%c%c%c",
		               32 + button, 32 + x + 1, 32 + y + 1);
	} else {
		return;
	}

	ttywrite(buf, len, 0);
}

static int
mouseaction(MouseEvent *e, uint release)
{
	MouseShortcut *ms;

	/* ignore Button<N>mask for Button<N> - it's set on release */
	uint state = e->state & ~buttonmask(e->button);

	for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) {
		if (ms->release == release &&
		    ms->button == e->button &&
		    (match(ms->mod, state) ||  /* exact or forced */
		     match(ms->mod, state & ~forcemousemod))) {
			ms->func(&(ms->arg));
			return 1;
		}
	}

	return 0;
}

static void
bpress(MouseEvent *e)
{
	struct timespec now;
	int snap;

	if (IS_SET(MODE_MOUSE) && !(e->state & forcemousemod)) {
		mousereport(e);
		return;
	}

	if (mouseaction(e, 0))
		return;

	if (e->button == Button1) {
		/*
		 * If the user clicks below predefined timeouts specific
		 * snapping behaviour is exposed.
		 */
		clock_gettime(CLOCK_MONOTONIC, &now);
		if (TIMEDIFF(now, xsel.tclick2) <= tripleclicktimeout)
			snap = SNAP_LINE;
		else if (TIMEDIFF(now, xsel.tclick1) <= doubleclicktimeout)
			snap = SNAP_WORD;
		else
			snap = 0;
		xsel.tclick2 = xsel.tclick1;
		xsel.tclick1 = now;

		selstart(evcol(e), evrow(e), snap);
	}
}

static void
brelease(MouseEvent *e)
{
	if (IS_SET(MODE_MOUSE) && !(e->state & forcemousemod)) {
		mousereport(e);
		return;
	}

	if (mouseaction(e, 1))
		return;
	if (e->button == Button1)
		mousesel(e, 1);
}

static void
bmotion(MouseEvent *e)
{
	if (pointer_hidden)
		showpointer(pointer_serial ? pointer_serial : last_serial);

	if (IS_SET(MODE_MOUSE) && !(e->state & forcemousemod)) {
		mousereport(e);
		return;
	}

	mousesel(e, 0);
}

/* ---- st.c facing helpers ---- */

static void
zoom(const Arg *arg)
{
	Arg larg;

	larg.f = usedfontsize + arg->f;
	zoomabs(&larg);
}

static void
zoomabs(const Arg *arg)
{
	unloadfonts();
	loadfonts(usedfont, arg->f);
	if (started)
		cresize(win.lw, win.lh);
	redraw();
}

static void
zoomreset(const Arg *arg)
{
	Arg larg;

	(void)arg;
	if (defaultfontsize > 0) {
		larg.f = defaultfontsize;
		zoomabs(&larg);
	}
}

static void
ttysend(const Arg *arg)
{
	ttywrite(arg->s, strlen(arg->s), 1);
}

void
bell(void)
{
	if (bellvolume && systembell)
		xdg_system_bell_v1_ring(systembell, surface);
}

void
setmode(int set, unsigned int flags)
{
	int mode = win.mode;

	MODBIT(win.mode, set, flags);
	if ((win.mode & MODE_REVERSE) != (mode & MODE_REVERSE))
		redraw();
}

int
setcursor(int cursor)
{
	if (!BETWEEN(cursor, 0, 7)) /* 7: st extension */
		return 1;
	win.cursor = cursor;
	return 0;
}

void
settitle(char *p)
{
	DEFAULT(p, opt_title);
	if (!p)
		p = "st";
	xdg_toplevel_set_title(xdg_toplevel, p);
}

void
toggle_winmode(int flag)
{
	win.mode ^= flag;
}

void
keyboard_select(const Arg *dummy)
{
	(void)dummy;
	win.mode ^= trt_kbdselect(-1, NULL, 0);
}

/* ---- registry / setup ---- */

static void
registryglobal(void *data, struct wl_registry *reg, uint32_t name,
               const char *interface, uint32_t version)
{
	if (!strcmp(interface, wl_compositor_interface.name)) {
		compositor = wl_registry_bind(reg, name, &wl_compositor_interface,
		                              MIN(version, 6));
	} else if (!strcmp(interface, wl_shm_interface.name)) {
		shm = wl_registry_bind(reg, name, &wl_shm_interface, 1);
		wl_shm_add_listener(shm, &shm_listener, NULL);
	} else if (!strcmp(interface, xdg_wm_base_interface.name)) {
		wm_base = wl_registry_bind(reg, name, &xdg_wm_base_interface,
		                           MIN(version, 6));
		xdg_wm_base_add_listener(wm_base, &wm_base_listener, NULL);
	} else if (!strcmp(interface, wl_seat_interface.name)) {
		seat = wl_registry_bind(reg, name, &wl_seat_interface,
		                        MIN(version, 7));
	} else if (!strcmp(interface, wl_data_device_manager_interface.name)) {
		data_manager = wl_registry_bind(reg, name,
		                                &wl_data_device_manager_interface, 1);
	} else if (!strcmp(interface,
	                   zwp_primary_selection_device_manager_v1_interface.name)) {
		primary_manager = wl_registry_bind(reg, name,
			&zwp_primary_selection_device_manager_v1_interface, 1);
	} else if (!strcmp(interface, zwp_text_input_manager_v3_interface.name)) {
		text_input_manager = wl_registry_bind(reg, name,
			&zwp_text_input_manager_v3_interface, 1);
	} else if (!strcmp(interface, wp_cursor_shape_manager_v1_interface.name)) {
		cursor_shape_manager = wl_registry_bind(reg, name,
			&wp_cursor_shape_manager_v1_interface, 1);
	} else if (!strcmp(interface,
	                   wp_fractional_scale_manager_v1_interface.name)) {
		fractional_manager = wl_registry_bind(reg, name,
			&wp_fractional_scale_manager_v1_interface, 1);
	} else if (!strcmp(interface, wp_viewporter_interface.name)) {
		viewporter = wl_registry_bind(reg, name, &wp_viewporter_interface, 1);
	} else if (!strcmp(interface, xdg_system_bell_v1_interface.name)) {
		systembell = wl_registry_bind(reg, name,
		                              &xdg_system_bell_v1_interface, 1);
	}
}

static void
registryglobalremove(void *data, struct wl_registry *reg, uint32_t name)
{
}

static void
shmformat(void *data, struct wl_shm *s, uint32_t format)
{
	if (format == WL_SHM_FORMAT_ARGB8888)
		shm_argb = 1;
}

static const struct wl_registry_listener registry_listener = {
	.global = registryglobal,
	.global_remove = registryglobalremove,
};

static const struct wl_shm_listener shm_listener = {
	.format = shmformat,
};

static void
flushdisplay(void)
{
	struct pollfd pfd;

	pfd.fd = wl_display_get_fd(display);
	pfd.events = POLLOUT;

	while (wl_display_flush(display) < 0) {
		if (errno != EAGAIN)
			die("wl_display_flush: %s\n", strerror(errno));
		if (poll(&pfd, 1, -1) < 0 && errno != EINTR)
			die("poll: %s\n", strerror(errno));
	}
}

static void
wlinit(int ncols, int nrows)
{
	int bw;

	signal(SIGPIPE, SIG_IGN);

	display = wl_display_connect(NULL);
	if (!display)
		die("can't connect to Wayland display\n");

	registry = wl_display_get_registry(display);
	wl_registry_add_listener(registry, &registry_listener, NULL);
	wl_display_roundtrip(display);

	if (!compositor)
		die("compositor does not support wl_compositor\n");
	if (!wm_base)
		die("compositor does not support xdg_wm_base\n");
	if (!shm)
		die("compositor does not support wl_shm\n");

	xkbcontext = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
	if (!xkbcontext)
		die("failed to create xkb context\n");
	composetable = xkb_compose_table_new_from_locale(xkbcontext,
	                   setlocale(LC_CTYPE, NULL),
	                   XKB_COMPOSE_COMPILE_NO_FLAGS);
	if (composetable)
		composestate = xkb_compose_state_new(composetable,
	                                         XKB_COMPOSE_STATE_NO_FLAGS);

	if (seat) {
		wl_seat_add_listener(seat, &seat_listener, NULL);
		if (data_manager) {
			data_device = wl_data_device_manager_get_data_device(
				data_manager, seat);
			wl_data_device_add_listener(data_device,
			                            &data_device_listener, NULL);
		}
		if (primary_manager) {
			primary_device =
				zwp_primary_selection_device_manager_v1_get_device(
					primary_manager, seat);
			zwp_primary_selection_device_v1_add_listener(
				primary_device, &primary_device_listener, NULL);
		}
		if (text_input_manager) {
			text_input = zwp_text_input_manager_v3_get_text_input(
				text_input_manager, seat);
			zwp_text_input_v3_add_listener(text_input,
			                               &text_input_listener, NULL);
		}
	}

	/* seat capabilities and wl_shm formats */
	wl_display_roundtrip(display);

	if (!shm_argb)
		die("compositor does not support WL_SHM_FORMAT_ARGB8888\n");

	if (!FcInit())
		die("could not init fontconfig.\n");
	if (FT_Init_FreeType(&ftlib))
		die("could not init freetype.\n");

	surface = wl_compositor_create_surface(compositor);
	wl_surface_add_listener(surface, &surface_listener, NULL);
	xdg_surface = xdg_wm_base_get_xdg_surface(wm_base, surface);
	xdg_surface_add_listener(xdg_surface, &xdg_surface_listener, NULL);
	xdg_toplevel = xdg_surface_get_toplevel(xdg_surface);
	xdg_toplevel_add_listener(xdg_toplevel, &xdg_toplevel_listener, NULL);
	xdg_toplevel_set_app_id(xdg_toplevel, opt_class ? opt_class : termname);
	settitle(NULL);

	if (fractional_manager) {
		fractional = wp_fractional_scale_manager_v1_get_fractional_scale(
			fractional_manager, surface);
		wp_fractional_scale_v1_add_listener(fractional,
		                                    &fractional_listener, NULL);
	}
	if (viewporter && fractional_manager)
		viewport = wp_viewporter_get_viewport(viewporter, surface);

	/* An empty commit is required for the initial configure. */
	wl_surface_commit(surface);
	while (!configured && wl_display_dispatch(display) != -1)
		;
	if (!configured)
		die("compositor did not send xdg_surface.configure\n");

	/* Pick up fractional-scale / preferred_buffer_scale. */
	wl_display_roundtrip(display);

	if (have_frac_scale)
		scale = frac_scale / 120.0;
	else if (surface_scale > 0)
		scale = surface_scale;
	else
		scale = 1.0;
	use_viewport = have_frac_scale && viewporter != NULL;

	loadcols();
	usedfont = opt_font ? opt_font : font;
	loadfonts(usedfont, 0);

	if (win.lw <= 0 || win.lh <= 0) {
		bw = borderpxdev();
		win.lw = (int)ceil((2.0 * bw + ncols * win.cw) / scale);
		win.lh = (int)ceil((2.0 * bw + nrows * win.ch) / scale);
	}
	updatesize();

	wl_display_flush(display);
}

/* ---- main loop ---- */

static void
run(void)
{
	int ttyfd, drawing, npfd, xev, i;
	struct timespec now, lastblink, trigger;
	struct pollfd *pfds = NULL;
	Transfer *t;
	double timeout;

	ttyfd = ttynew(opt_line, shell, opt_io, opt_cmd);

	started = 1;
	cresize(win.lw, win.lh);
	draw();
	flushdisplay();

	clock_gettime(CLOCK_MONOTONIC, &lastblink);

	for (timeout = -1, drawing = 0;;) {
		npfd = 3;
		for (t = transfers; t; t = t->next)
			npfd++;

		pfds = xrealloc(pfds, npfd * sizeof(*pfds));
		memset(pfds, 0, npfd * sizeof(*pfds));
		pfds[0].fd = wl_display_get_fd(display);
		pfds[0].events = POLLIN;
		pfds[1].fd = ttyfd;
		pfds[1].events = POLLIN;
		pfds[2].fd = repeatfd;
		pfds[2].events = POLLIN;
		i = 3;
		for (t = transfers; t; t = t->next, i++) {
			pfds[i].fd = t->fd;
			pfds[i].events = t->writing ? POLLOUT : POLLIN;
		}

		if (wl_display_dispatch_pending(display) > 0)
			timeout = 0;  /* existing events might not set the fd */

		flushdisplay();

		if (pendinglen) {
			struct timespec pnow;
			double left;

			clock_gettime(CLOCK_MONOTONIC, &pnow);
			left = TIMEDIFF(pendinguntil, pnow);
			if (left <= 0)
				pendingflush();
			else if (timeout < 0 || left < timeout)
				timeout = left;
		}

		if (poll(pfds, npfd, timeout < 0 ? -1 : (int)timeout) < 0) {
			if (errno == EINTR)
				continue;
			die("poll failed: %s\n", strerror(errno));
		}
		clock_gettime(CLOCK_MONOTONIC, &now);

		xev = 0;

		if (pfds[1].revents)
			ttyread();
		if (pfds[2].revents)
			repeattick();
		if (npfd > 3)
			transferspoll(pfds + 3);
		if (pfds[0].revents) {
			if (wl_display_dispatch(display) < 0)
				die("wayland connection lost\n");
			xev = 1;
		}
		if (pending_event) {
			pending_event = 0;
			xev = 1;
		}

		/*
		 * To reduce flicker and tearing, when new content or event
		 * triggers drawing, we first wait a bit to ensure we got
		 * everything, and if nothing new arrives - we draw.
		 * We start with trying to wait minlatency ms. If more content
		 * arrives sooner, we retry with shorter and shorter periods,
		 * and eventually draw even without idle after maxlatency ms.
		 */
		if (pfds[1].revents || xev) {
			if (!drawing) {
				trigger = now;
				drawing = 1;
			}
			timeout = (maxlatency - TIMEDIFF(now, trigger)) /
			          maxlatency * minlatency;
			if (timeout > 0)
				continue;  /* we have time, try to find idle */
		}

		/* idle detected or maxlatency exhausted -> draw */
		timeout = -1;
		if (blinktimeout && tattrset(ATTR_BLINK)) {
			timeout = blinktimeout - TIMEDIFF(now, lastblink);
			if (timeout <= 0) {
				if (-timeout > blinktimeout) /* start visible */
					win.mode |= MODE_BLINK;
				win.mode ^= MODE_BLINK;
				tsetdirtattr(ATTR_BLINK);
				lastblink = now;
				timeout = blinktimeout;
			}
		}

		draw();
		flushdisplay();
		drawing = 0;
	}
}

static void
usage(void)
{
	die("usage: %s [-aiv] [-A alpha] [-c class] [-f font] [-g geometry]"
	    " [-o file]\n"
	    "          [-T title] [-t title]"
	    " [[-e] command [args ...]]\n"
	    "       %s [-aiv] [-A alpha] [-c class] [-f font] [-g geometry]"
	    " [-o file]\n"
	    "          [-T title] [-t title] -l line"
	    " [stty_args ...]\n", argv0, argv0);
}

static void
parsegeometry(char *s)
{
	char *p;
	long w, h;

	w = strtol(s, &p, 10);
	h = 0;
	if (*p == 'x' || *p == 'X')
		h = strtol(p + 1, &p, 10);

	if (w > 0)
		cols = w;
	if (h > 0)
		rows = h;

	if (*p == '+' || *p == '-')
		fprintf(stderr, "%s: ignoring window position in -g\n",
		        argv0);
}

int
main(int argc, char *argv[])
{
	win.mode = MODE_NUMLOCK;
	setcursor(cursorshape);

	ARGBEGIN {
	case 'a':
		allowaltscreen = 0;
		break;
	case 'A':
		opt_alpha = EARGF(usage());
		break;
	case 'c':
		opt_class = EARGF(usage());
		break;
	case 'e':
		if (argc > 0)
			--argc, ++argv;
		goto run;
	case 'f':
		opt_font = EARGF(usage());
		break;
	case 'g':
		parsegeometry(EARGF(usage()));
		break;
	case 'i':
		opt_fixed = 1;
		break;
	case 'l':
		opt_line = EARGF(usage());
		break;
	case 'o':
		opt_io = EARGF(usage());
		break;
	case 't':
	case 'T':
		opt_title = EARGF(usage());
		break;
	case 'v':
		die("%s " VERSION "\n", argv0);
		break;
	default:
		usage();
	} ARGEND;

run:
	if (argc > 0) /* eat all remaining arguments */
		opt_cmd = argv;

	if (!opt_title)
		opt_title = (opt_line || !opt_cmd) ? "st" : opt_cmd[0];

	setlocale(LC_CTYPE, "");
	cols = MAX(cols, 1);
	rows = MAX(rows, 1);
	tnew(cols, rows);
	wlinit(cols, rows);
	selinit();
	run();

	return 0;
}