nixos-dotfiles

/* See LICENSE for license details. */

#include <errno.h>

#include <math.h>

#include <limits.h>

#include <locale.h>

#include <signal.h>

#include <sys/select.h>

#include <time.h>

#include <unistd.h>

#include <libgen.h>

#include <X11/Xatom.h>

#include <X11/Xlib.h>

#include <X11/cursorfont.h>

#include <X11/keysym.h>

#include <X11/Xft/Xft.h>

#include <X11/XKBlib.h>

char *argv0;

#include "arg.h"

#include "st.h"

#include "win.h"

/* types used in 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;

/* X modifiers */

#define XK_ANY_MOD    UINT_MAX

#define XK_NO_MOD     0

#define XK_SWITCH_MOD (1<<13|1<<14)

/* function definitions used in config.h */

static void clipcopy(const Arg *);

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 *);

/* config.h for applying patches and the configuration. */

#include "config.h"

/* XEMBED messages */

#define XEMBED_FOCUS_IN  4

#define XEMBED_FOCUS_OUT 5

/* macros */

#define IS_SET(flag)		((win.mode & (flag)) != 0)

#define TRUERED(x)		(((x) & 0xff0000) >> 8)

#define TRUEGREEN(x)		(((x) & 0xff00))

#define TRUEBLUE(x)		(((x) & 0xff) << 8)

typedef XftDraw *Draw;

typedef XftColor Color;

typedef XftGlyphFontSpec GlyphFontSpec;

/* Purely graphic info */

typedef struct {

	int tw, th; /* tty width and height */

	int w, h; /* window width and height */

	int ch; /* char height */

	int cw; /* char width  */

	int mode; /* window state/mode flags */

	int cursor; /* cursor style */

} TermWindow;

typedef struct {

	Display *dpy;

	Colormap cmap;

	Window win;

	Drawable buf;

	GlyphFontSpec *specbuf; /* font spec buffer used for rendering */

	Atom xembed, wmdeletewin, netwmname, netwmiconname, netwmpid;

	struct {

		XIM xim;

		XIC xic;

		XPoint spot;

		XVaNestedList spotlist;

	} ime;

	Draw draw;

	Visual *vis;

	XSetWindowAttributes attrs;

	int scr;

	int isfixed; /* is fixed geometry? */

	int depth; /* bit depth */

	int l, t; /* left and top offset */

	int gm; /* geometry mask */

} XWindow;

typedef struct {

	Atom xtarget;

	char *primary, *clipboard;

	struct timespec tclick1;

	struct timespec tclick2;

} XSelection;

/* Font structure */

#define Font Font_

typedef struct {

	int height;

	int width;

	int ascent;

	int descent;

	int badslant;

	int badweight;

	short lbearing;

	short rbearing;

	XftFont *match;

	FcFontSet *set;

	FcPattern *pattern;

} Font;

/* Drawing Context */

typedef struct {

	Color *col;

	size_t collen;

	Font font, bfont, ifont, ibfont;

	GC gc;

} DC;

static inline ushort sixd_to_16bit(int);

static int xmakeglyphfontspecs(XftGlyphFontSpec *, const Glyph *, int, int, int);

static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int);

static void xdrawglyph(Glyph, int, int);

static void xclear(int, int, int, int);

static int xgeommasktogravity(int);

static int ximopen(Display *);

static void ximinstantiate(Display *, XPointer, XPointer);

static void ximdestroy(XIM, XPointer, XPointer);

static int xicdestroy(XIC, XPointer, XPointer);

static void xinit(int, int);

static void cresize(int, int);

static void xresize(int, int);

static void xhints(void);

static int xloadcolor(int, const char *, Color *);

static int xloadfont(Font *, FcPattern *);

static void xloadfonts(const char *, double);

static void xunloadfont(Font *);

static void xunloadfonts(void);

static void xsetenv(void);

static void xseturgency(int);

static int evcol(XEvent *);

static int evrow(XEvent *);

static void expose(XEvent *);

static void visibility(XEvent *);

static void unmap(XEvent *);

static void kpress(XEvent *);

static void cmessage(XEvent *);

static void resize(XEvent *);

static void focus(XEvent *);

static uint buttonmask(uint);

static int mouseaction(XEvent *, uint);

static void brelease(XEvent *);

static void bpress(XEvent *);

static void bmotion(XEvent *);

static void propnotify(XEvent *);

static void selnotify(XEvent *);

static void selclear_(XEvent *);

static void selrequest(XEvent *);

static void setsel(char *, Time);

static void mousesel(XEvent *, int);

static void mousereport(XEvent *);

static char *kmap(KeySym, uint);

static int match(uint, uint);

static void run(void);

static void usage(void);

static void (*handler[LASTEvent])(XEvent *) = {

	[KeyPress] = kpress,

	[ClientMessage] = cmessage,

	[ConfigureNotify] = resize,

	[VisibilityNotify] = visibility,

	[UnmapNotify] = unmap,

	[Expose] = expose,

	[FocusIn] = focus,

	[FocusOut] = focus,

	[MotionNotify] = bmotion,

	[ButtonPress] = bpress,

	[ButtonRelease] = brelease,

/*

 * Uncomment if you want the selection to disappear when you select something

 * different in another window.

 */

/*	[SelectionClear] = selclear_, */

	[SelectionNotify] = selnotify,

/*

 * PropertyNotify is only turned on when there is some INCR transfer happening

 * for the selection retrieval.

 */

	[PropertyNotify] = propnotify,

	[SelectionRequest] = selrequest,

};

/* Globals */

static DC dc;

static XWindow xw;

static XSelection xsel;

static TermWindow win;

/* Font Ring Cache */

enum {

	FRC_NORMAL,

	FRC_ITALIC,

	FRC_BOLD,

	FRC_ITALICBOLD

};

typedef struct {

	XftFont *font;

	int flags;

	Rune unicodep;

} Fontcache;

/* Fontcache is an array now. A new font will be appended to the array. */

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 char *opt_class = NULL;

static char **opt_cmd  = NULL;

static char *opt_embed = NULL;

static char *opt_font  = NULL;

static char *opt_io    = NULL;

static char *opt_line  = NULL;

static char *opt_name  = NULL;

static char *opt_title = NULL;

static uint buttons; /* bit field of pressed buttons */

void

clipcopy(const Arg *dummy)

{

	Atom clipboard;

	free(xsel.clipboard);

	xsel.clipboard = NULL;

	if (xsel.primary != NULL) {

		xsel.clipboard = xstrdup(xsel.primary);

		clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);

		XSetSelectionOwner(xw.dpy, clipboard, xw.win, CurrentTime);

	}

}

void

clippaste(const Arg *dummy)

{

	Atom clipboard;

	clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);

	XConvertSelection(xw.dpy, clipboard, xsel.xtarget, clipboard,

			xw.win, CurrentTime);

}

void

selpaste(const Arg *dummy)

{

	XConvertSelection(xw.dpy, XA_PRIMARY, xsel.xtarget, XA_PRIMARY,

			xw.win, CurrentTime);

}

void

numlock(const Arg *dummy)

{

	win.mode ^= MODE_NUMLOCK;

}

void

zoom(const Arg *arg)

{

	Arg larg;

	larg.f = usedfontsize + arg->f;

	zoomabs(&larg);

}

void

zoomabs(const Arg *arg)

{

	xunloadfonts();

	xloadfonts(usedfont, arg->f);

	cresize(0, 0);

	redraw();

	xhints();

}

void

zoomreset(const Arg *arg)

{

	Arg larg;

	if (defaultfontsize > 0) {

		larg.f = defaultfontsize;

		zoomabs(&larg);

	}

}

void

ttysend(const Arg *arg)

{

	ttywrite(arg->s, strlen(arg->s), 1);

}

int

evcol(XEvent *e)

{

	int x = e->xbutton.x - borderpx;

	LIMIT(x, 0, win.tw - 1);

	return x / win.cw;

}

int

evrow(XEvent *e)

{

	int y = e->xbutton.y - borderpx;

	LIMIT(y, 0, win.th - 1);

	return y / win.ch;

}

void

mousesel(XEvent *e, int done)

{

	int type, seltype = SEL_REGULAR;

	uint state = e->xbutton.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(), e->xbutton.time);

}

void

mousereport(XEvent *e)

{

	int len, btn, code;

	int x = evcol(e), y = evrow(e);

	int state = e->xbutton.state;

	char buf[40];

	static int ox, oy;

	if (e->type == MotionNotify) {

		if (x == ox && y == oy)

			return;

		if (!IS_SET(MODE_MOUSEMOTION) && !IS_SET(MODE_MOUSEMANY))

			return;

		/* MODE_MOUSEMOTION: no reporting if no button is pressed */

		if (IS_SET(MODE_MOUSEMOTION) && buttons == 0)

			return;

		/* Set btn to lowest-numbered pressed button, or 12 if no

		 * buttons are pressed. */

		for (btn = 1; btn <= 11 && !(buttons & (1<<(btn-1))); btn++)

			;

		code = 32;

	} else {

		btn = e->xbutton.button;

		/* Only buttons 1 through 11 can be encoded */

		if (btn < 1 || btn > 11)

			return;

		if (e->type == ButtonRelease) {

			/* MODE_MOUSEX10: no button release reporting */

			if (IS_SET(MODE_MOUSEX10))

				return;

			/* Don't send release events for the scroll wheel */

			if (btn == 4 || btn == 5)

				return;

		}

		code = 0;

	}

	ox = x;

	oy = y;

	/* Encode btn into code. If no button is pressed for a motion event in

	 * MODE_MOUSEMANY, then encode it as a release. */

	if ((!IS_SET(MODE_MOUSESGR) && e->type == ButtonRelease) || btn == 12)

		code += 3;

	else if (btn >= 8)

		code += 128 + btn - 8;

	else if (btn >= 4)

		code += 64 + btn - 4;

	else

		code += btn - 1;

	if (!IS_SET(MODE_MOUSEX10)) {

		code += ((state & ShiftMask  ) ?  4 : 0)

		      + ((state & Mod1Mask   ) ?  8 : 0) /* meta key: alt */

		      + ((state & ControlMask) ? 16 : 0);

	}

	if (IS_SET(MODE_MOUSESGR)) {

		len = snprintf(buf, sizeof(buf), "\033[<%d;%d;%d%c",

				code, x+1, y+1,

				e->type == ButtonRelease ? 'm' : 'M');

	} else if (x < 223 && y < 223) {

		len = snprintf(buf, sizeof(buf), "\033[M%c%c%c",

				32+code, 32+x+1, 32+y+1);

	} else {

		return;

	}

	ttywrite(buf, len, 0);

}

uint

buttonmask(uint button)

{

	return button == Button1 ? Button1Mask

	     : button == Button2 ? Button2Mask

	     : button == Button3 ? Button3Mask

	     : button == Button4 ? Button4Mask

	     : button == Button5 ? Button5Mask

	     : 0;

}

int

mouseaction(XEvent *e, uint release)

{

	MouseShortcut *ms;

	/* ignore Button<N>mask for Button<N> - it's set on release */

	uint state = e->xbutton.state & ~buttonmask(e->xbutton.button);

	for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) {

		if (ms->release == release &&

		    ms->button == e->xbutton.button &&

		    (match(ms->mod, state) ||  /* exact or forced */

		     match(ms->mod, state & ~forcemousemod))) {

			ms->func(&(ms->arg));

			return 1;

		}

	}

	return 0;

}

void

bpress(XEvent *e)

{

	int btn = e->xbutton.button;

	struct timespec now;

	int snap;

	if (1 <= btn && btn <= 11)

		buttons |= 1 << (btn-1);

	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {

		mousereport(e);

		return;

	}

	if (mouseaction(e, 0))

		return;

	if (btn == 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);

	}

}

void

propnotify(XEvent *e)

{

	XPropertyEvent *xpev;

	Atom clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);

	xpev = &e->xproperty;

	if (xpev->state == PropertyNewValue &&

			(xpev->atom == XA_PRIMARY ||

			 xpev->atom == clipboard)) {

		selnotify(e);

	}

}

void

selnotify(XEvent *e)

{

	ulong nitems, ofs, rem;

	int format;

	uchar *data, *last, *repl;

	Atom type, incratom, property = None;

	incratom = XInternAtom(xw.dpy, "INCR", 0);

	ofs = 0;

	if (e->type == SelectionNotify)

		property = e->xselection.property;

	else if (e->type == PropertyNotify)

		property = e->xproperty.atom;

	if (property == None)

		return;

	do {

		if (XGetWindowProperty(xw.dpy, xw.win, property, ofs,

					BUFSIZ/4, False, AnyPropertyType,

					&type, &format, &nitems, &rem,

					&data)) {

			fprintf(stderr, "Clipboard allocation failed\n");

			return;

		}

		if (e->type == PropertyNotify && nitems == 0 && rem == 0) {

			/*

			 * If there is some PropertyNotify with no data, then

			 * this is the signal of the selection owner that all

			 * data has been transferred. We won't need to receive

			 * PropertyNotify events anymore.

			 */

			MODBIT(xw.attrs.event_mask, 0, PropertyChangeMask);

			XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask,

					&xw.attrs);

		}

		if (type == incratom) {

			/*

			 * Activate the PropertyNotify events so we receive

			 * when the selection owner does send us the next

			 * chunk of data.

			 */

			MODBIT(xw.attrs.event_mask, 1, PropertyChangeMask);

			XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask,

					&xw.attrs);

			/*

			 * Deleting the property is the transfer start signal.

			 */

			XDeleteProperty(xw.dpy, xw.win, (int)property);

			continue;

		}

		/*

		 * As seen in getsel:

		 * Line endings are inconsistent in the terminal and GUI world

		 * copy and pasting. When receiving some selection data,

		 * replace all '\n' with '\r'.

		 * FIXME: Fix the computer world.

		 */

		repl = data;

		last = data + nitems * format / 8;

		while ((repl = memchr(repl, '\n', last - repl))) {

			*repl++ = '\r';

		}

		if (IS_SET(MODE_BRCKTPASTE) && ofs == 0)

			ttywrite("\033[200~", 6, 0);

		ttywrite((char *)data, nitems * format / 8, 1);

		if (IS_SET(MODE_BRCKTPASTE) && rem == 0)

			ttywrite("\033[201~", 6, 0);

		XFree(data);

		/* number of 32-bit chunks returned */

		ofs += nitems * format / 32;

	} while (rem > 0);

	/*

	 * Deleting the property again tells the selection owner to send the

	 * next data chunk in the property.

	 */

	XDeleteProperty(xw.dpy, xw.win, (int)property);

}

void

xclipcopy(void)

{

	clipcopy(NULL);

}

void

selclear_(XEvent *e)

{

	selclear();

}

void

selrequest(XEvent *e)

{

	XSelectionRequestEvent *xsre;

	XSelectionEvent xev;

	Atom xa_targets, string, clipboard;

	char *seltext;

	xsre = (XSelectionRequestEvent *) e;

	xev.type = SelectionNotify;

	xev.requestor = xsre->requestor;

	xev.selection = xsre->selection;

	xev.target = xsre->target;

	xev.time = xsre->time;

	if (xsre->property == None)

		xsre->property = xsre->target;

	/* reject */

	xev.property = None;

	xa_targets = XInternAtom(xw.dpy, "TARGETS", 0);

	if (xsre->target == xa_targets) {

		/* respond with the supported type */

		string = xsel.xtarget;

		XChangeProperty(xsre->display, xsre->requestor, xsre->property,

				XA_ATOM, 32, PropModeReplace,

				(uchar *) &string, 1);

		xev.property = xsre->property;

	} else if (xsre->target == xsel.xtarget || xsre->target == XA_STRING) {

		/*

		 * xith XA_STRING non ascii characters may be incorrect in the

		 * requestor. It is not our problem, use utf8.

		 */

		clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);

		if (xsre->selection == XA_PRIMARY) {

			seltext = xsel.primary;

		} else if (xsre->selection == clipboard) {

			seltext = xsel.clipboard;

		} else {

			fprintf(stderr,

				"Unhandled clipboard selection 0x%lx\n",

				xsre->selection);

			return;

		}

		if (seltext != NULL) {

			XChangeProperty(xsre->display, xsre->requestor,

					xsre->property, xsre->target,

					8, PropModeReplace,

					(uchar *)seltext, strlen(seltext));

			xev.property = xsre->property;

		}

	}

	/* all done, send a notification to the listener */

	if (!XSendEvent(xsre->display, xsre->requestor, 1, 0, (XEvent *) &xev))

		fprintf(stderr, "Error sending SelectionNotify event\n");

}

void

setsel(char *str, Time t)

{

	if (!str)

		return;

	free(xsel.primary);

	xsel.primary = str;

	XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, t);

	if (XGetSelectionOwner(xw.dpy, XA_PRIMARY) != xw.win)

		selclear();

}

void

xsetsel(char *str)

{

	setsel(str, CurrentTime);

}

void

brelease(XEvent *e)

{

	int btn = e->xbutton.button;

	if (1 <= btn && btn <= 11)

		buttons &= ~(1 << (btn-1));

	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {

		mousereport(e);

		return;

	}

	if (mouseaction(e, 1))

		return;

	if (btn == Button1)

		mousesel(e, 1);

}

void

bmotion(XEvent *e)

{

	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {

		mousereport(e);

		return;

	}

	mousesel(e, 0);

}

void

cresize(int width, int height)

{

	int col, row;

	if (width != 0)

		win.w = width;

	if (height != 0)

		win.h = height;

	col = (win.w - 2 * borderpx) / win.cw;

	row = (win.h - 2 * borderpx) / win.ch;

	col = MAX(1, col);

	row = MAX(1, row);

	tresize(col, row);

	xresize(col, row);

	ttyresize(win.tw, win.th);

}

void

xresize(int col, int row)

{

	win.tw = col * win.cw;

	win.th = row * win.ch;

	XFreePixmap(xw.dpy, xw.buf);

	xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h,

			xw.depth);

	XftDrawChange(xw.draw, xw.buf);

	xclear(0, 0, win.w, win.h);

	/* resize to new width */

	xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec));

}

ushort

sixd_to_16bit(int x)

{

	return x == 0 ? 0 : 0x3737 + 0x2828 * x;

}

int

xloadcolor(int i, const char *name, Color *ncolor)

{

	XRenderColor color = { .alpha = 0xffff };

	if (!name) {

		if (BETWEEN(i, 16, 255)) { /* 256 color */

			if (i < 6*6*6+16) { /* same colors as xterm */

				color.red   = sixd_to_16bit( ((i-16)/36)%6 );

				color.green = sixd_to_16bit( ((i-16)/6) %6 );

				color.blue  = sixd_to_16bit( ((i-16)/1) %6 );

			} else { /* greyscale */

				color.red = 0x0808 + 0x0a0a * (i - (6*6*6+16));

				color.green = color.blue = color.red;

			}

			return XftColorAllocValue(xw.dpy, xw.vis,

			                          xw.cmap, &color, ncolor);

		} else

			name = colorname[i];

	}

	return XftColorAllocName(xw.dpy, xw.vis, xw.cmap, name, ncolor);

}

void

xloadcols(void)

{

	int i;

	static int loaded;

	Color *cp;

	if (loaded) {

		for (cp = dc.col; cp < &dc.col[dc.collen]; ++cp)

			XftColorFree(xw.dpy, xw.vis, xw.cmap, cp);

	} else {

		dc.collen = MAX(LEN(colorname), 256);

		dc.col = xmalloc(dc.collen * sizeof(Color));

	}

	for (i = 0; i < dc.collen; i++)

		if (!xloadcolor(i, NULL, &dc.col[i])) {

			if (colorname[i])

				die("could not allocate color '%s'\n", colorname[i]);

			else

				die("could not allocate color %d\n", i);

		}

	dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha);

	dc.col[defaultbg].pixel &= 0x00FFFFFF;

	dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24;

	loaded = 1;

}

int

xgetcolor(int x, unsigned char *r, unsigned char *g, unsigned char *b)

{

	if (!BETWEEN(x, 0, dc.collen - 1))

		return 1;

	*r = dc.col[x].color.red >> 8;

	*g = dc.col[x].color.green >> 8;

	*b = dc.col[x].color.blue >> 8;

	return 0;

}

int

xsetcolorname(int x, const char *name)

{

	Color ncolor;

	if (!BETWEEN(x, 0, dc.collen - 1))

		return 1;

	if (!xloadcolor(x, name, &ncolor))

		return 1;

	XftColorFree(xw.dpy, xw.vis, xw.cmap, &dc.col[x]);

	dc.col[x] = ncolor;

	if (x == defaultbg) {

		dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha);

		dc.col[defaultbg].pixel &= 0x00FFFFFF;

		dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24;

	}

	return 0;

}

/*

 * Absolute coordinates.

 */

void

xclear(int x1, int y1, int x2, int y2)

{

	XftDrawRect(xw.draw,

			&dc.col[IS_SET(MODE_REVERSE)? defaultfg : defaultbg],

			x1, y1, x2-x1, y2-y1);

}

void

xhints(void)

{

	XClassHint class = {opt_name ? opt_name : termname,

	                    opt_class ? opt_class : termname};

	XWMHints wm = {.flags = InputHint, .input = 1};

	XSizeHints *sizeh;

	sizeh = XAllocSizeHints();

	sizeh->flags = PSize | PResizeInc | PBaseSize | PMinSize;

	sizeh->height = win.h;

	sizeh->width = win.w;

	sizeh->height_inc = win.ch;

	sizeh->width_inc = win.cw;

	sizeh->base_height = 2 * borderpx;

	sizeh->base_width = 2 * borderpx;

	sizeh->min_height = win.ch + 2 * borderpx;

	sizeh->min_width = win.cw + 2 * borderpx;

	if (xw.isfixed) {

		sizeh->flags |= PMaxSize;

		sizeh->min_width = sizeh->max_width = win.w;

		sizeh->min_height = sizeh->max_height = win.h;

	}

	if (xw.gm & (XValue|YValue)) {

		sizeh->flags |= USPosition | PWinGravity;

		sizeh->x = xw.l;

		sizeh->y = xw.t;

		sizeh->win_gravity = xgeommasktogravity(xw.gm);

	}

	XSetWMProperties(xw.dpy, xw.win, NULL, NULL, NULL, 0, sizeh, &wm,

			&class);

	XFree(sizeh);

}

int

xgeommasktogravity(int mask)

{

	switch (mask & (XNegative|YNegative)) {

	case 0:

		return NorthWestGravity;

	case XNegative:

		return NorthEastGravity;

	case YNegative:

		return SouthWestGravity;

	}

	return SouthEastGravity;

}

int

xloadfont(Font *f, FcPattern *pattern)

{

	FcPattern *configured;

	FcPattern *match;

	FcResult result;

	XGlyphInfo extents;

	int wantattr, haveattr;

	/*

	 * Manually configure instead of calling XftMatchFont

	 * so that we can use the configured pattern for

	 * "missing glyph" lookups.

	 */

	configured = FcPatternDuplicate(pattern);

	if (!configured)

		return 1;

	FcConfigSubstitute(NULL, configured, FcMatchPattern);

	XftDefaultSubstitute(xw.dpy, xw.scr, configured);

	match = FcFontMatch(NULL, configured, &result);

	if (!match) {

		FcPatternDestroy(configured);

		return 1;

	}

	if (!(f->match = XftFontOpenPattern(xw.dpy, match))) {

		FcPatternDestroy(configured);

		FcPatternDestroy(match);

		return 1;

	}

	if ((XftPatternGetInteger(pattern, "slant", 0, &wantattr) ==

	    XftResultMatch)) {

		/*

		 * Check if xft was unable to find a font with the appropriate

		 * slant but gave us one anyway. Try to mitigate.

		 */

		if ((XftPatternGetInteger(f->match->pattern, "slant", 0,

		    &haveattr) != XftResultMatch) || haveattr < wantattr) {

			f->badslant = 1;

			fputs("font slant does not match\n", stderr);

		}

	}

	if ((XftPatternGetInteger(pattern, "weight", 0, &wantattr) ==

	    XftResultMatch)) {

		if ((XftPatternGetInteger(f->match->pattern, "weight", 0,

		    &haveattr) != XftResultMatch) || haveattr != wantattr) {

			f->badweight = 1;

			fputs("font weight does not match\n", stderr);

		}

	}

	XftTextExtentsUtf8(xw.dpy, f->match,

		(const FcChar8 *) ascii_printable,

		strlen(ascii_printable), &extents);

	f->set = NULL;

	f->pattern = configured;

	f->ascent = f->match->ascent;

	f->descent = f->match->descent;

	f->lbearing = 0;

	f->rbearing = f->match->max_advance_width;

	f->height = f->ascent + f->descent;

	f->width = DIVCEIL(extents.xOff, strlen(ascii_printable));

	return 0;

}

void

xloadfonts(const char *fontstr, double fontsize)

{

	FcPattern *pattern;

	double fontval;

	if (fontstr[0] == '-')

		pattern = XftXlfdParse(fontstr, False, False);

	else

		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, (double)fontsize);

		usedfontsize = fontsize;

	} else {

		if (FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval) ==

				FcResultMatch) {

			usedfontsize = fontval;

		} else if (FcPatternGetDouble(pattern, FC_SIZE, 0, &fontval) ==

				FcResultMatch) {

			usedfontsize = -1;

		} else {

			/*

			 * Default font size is 12, if none given. This is to

			 * have a known usedfontsize value.

			 */

			FcPatternAddDouble(pattern, FC_PIXEL_SIZE, 12);

			usedfontsize = 12;

		}

		defaultfontsize = usedfontsize;

	}

	if (xloadfont(&dc.font, pattern))

		die("can't open font %s\n", fontstr);

	if (usedfontsize < 0) {

		FcPatternGetDouble(dc.font.match->pattern,

		                   FC_PIXEL_SIZE, 0, &fontval);

		usedfontsize = fontval;

		if (fontsize == 0)

			defaultfontsize = fontval;

	}

	/* Setting character width and height. */

	win.cw = ceilf(dc.font.width * cwscale);

	win.ch = ceilf(dc.font.height * chscale);

	FcPatternDel(pattern, FC_SLANT);

	FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC);

	if (xloadfont(&dc.ifont, pattern))

		die("can't open font %s\n", fontstr);

	FcPatternDel(pattern, FC_WEIGHT);

	FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);

	if (xloadfont(&dc.ibfont, pattern))

		die("can't open font %s\n", fontstr);

	FcPatternDel(pattern, FC_SLANT);

	FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN);

	if (xloadfont(&dc.bfont, pattern))

		die("can't open font %s\n", fontstr);

	FcPatternDestroy(pattern);

}

void

xunloadfont(Font *f)

{

	XftFontClose(xw.dpy, f->match);

	FcPatternDestroy(f->pattern);

	if (f->set)

		FcFontSetDestroy(f->set);

}

void

xunloadfonts(void)

{

	/* Free the loaded fonts in the font cache.  */

	while (frclen > 0)

		XftFontClose(xw.dpy, frc[--frclen].font);

	xunloadfont(&dc.font);

	xunloadfont(&dc.bfont);

	xunloadfont(&dc.ifont);

	xunloadfont(&dc.ibfont);

}

int

ximopen(Display *dpy)

{

	XIMCallback imdestroy = { .client_data = NULL, .callback = ximdestroy };

	XICCallback icdestroy = { .client_data = NULL, .callback = xicdestroy };

	xw.ime.xim = XOpenIM(xw.dpy, NULL, NULL, NULL);

	if (xw.ime.xim == NULL)

		return 0;

	if (XSetIMValues(xw.ime.xim, XNDestroyCallback, &imdestroy, NULL))

		fprintf(stderr, "XSetIMValues: "

		                "Could not set XNDestroyCallback.\n");

	xw.ime.spotlist = XVaCreateNestedList(0, XNSpotLocation, &xw.ime.spot,

	                                      NULL);

	if (xw.ime.xic == NULL) {

		xw.ime.xic = XCreateIC(xw.ime.xim, XNInputStyle,

		                       XIMPreeditNothing | XIMStatusNothing,

		                       XNClientWindow, xw.win,

		                       XNDestroyCallback, &icdestroy,

		                       NULL);

	}

	if (xw.ime.xic == NULL)

		fprintf(stderr, "XCreateIC: Could not create input context.\n");

	return 1;

}

void

ximinstantiate(Display *dpy, XPointer client, XPointer call)

{

	if (ximopen(dpy))

		XUnregisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL,

		                                 ximinstantiate, NULL);

}

void

ximdestroy(XIM xim, XPointer client, XPointer call)

{

	xw.ime.xim = NULL;

	XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL,

	                               ximinstantiate, NULL);

	XFree(xw.ime.spotlist);

}

int

xicdestroy(XIC xim, XPointer client, XPointer call)

{

	xw.ime.xic = NULL;

	return 1;

}

void

xinit(int cols, int rows)

{

	XGCValues gcvalues;

	Cursor cursor;

	Window parent, root;

	pid_t thispid = getpid();

	XColor xmousefg, xmousebg;

	XWindowAttributes attr;

	XVisualInfo vis;

	if (!(xw.dpy = XOpenDisplay(NULL)))

		die("can't open display\n");

	xw.scr = XDefaultScreen(xw.dpy);

	root = XRootWindow(xw.dpy, xw.scr);

	if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0))))

		parent = root;

	if (XMatchVisualInfo(xw.dpy, xw.scr, 32, TrueColor, &vis) != 0) {

		xw.vis = vis.visual;

		xw.depth = vis.depth;

	} else {

		XGetWindowAttributes(xw.dpy, parent, &attr);

		xw.vis = attr.visual;

		xw.depth = attr.depth;

	}

	/* font */

	if (!FcInit())

		die("could not init fontconfig.\n");

	usedfont = (opt_font == NULL)? font : opt_font;

	xloadfonts(usedfont, 0);

	/* colors */

	xw.cmap = XCreateColormap(xw.dpy, parent, xw.vis, None);

	xloadcols();

	/* adjust fixed window geometry */

	win.w = 2 * borderpx + cols * win.cw;

	win.h = 2 * borderpx + rows * win.ch;

	if (xw.gm & XNegative)

		xw.l += DisplayWidth(xw.dpy, xw.scr) - win.w - 2;

	if (xw.gm & YNegative)

		xw.t += DisplayHeight(xw.dpy, xw.scr) - win.h - 2;

	/* Events */

	xw.attrs.background_pixel = dc.col[defaultbg].pixel;

	xw.attrs.border_pixel = dc.col[defaultbg].pixel;

	xw.attrs.bit_gravity = NorthWestGravity;

	xw.attrs.event_mask = FocusChangeMask | KeyPressMask | KeyReleaseMask

		| ExposureMask | VisibilityChangeMask | StructureNotifyMask

		| ButtonMotionMask | ButtonPressMask | ButtonReleaseMask;

	xw.attrs.colormap = xw.cmap;

	xw.win = XCreateWindow(xw.dpy, parent, xw.l, xw.t,

			win.w, win.h, 0, xw.depth, InputOutput,

			xw.vis, CWBackPixel | CWBorderPixel | CWBitGravity

			| CWEventMask | CWColormap, &xw.attrs);

	if (parent != root)

		XReparentWindow(xw.dpy, xw.win, parent, xw.l, xw.t);

	memset(&gcvalues, 0, sizeof(gcvalues));

	gcvalues.graphics_exposures = False;

	dc.gc = XCreateGC(xw.dpy, xw.win, GCGraphicsExposures,

			&gcvalues);

	xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h,

			xw.depth);

	XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel);

	XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, win.w, win.h);

	/* font spec buffer */

	xw.specbuf = xmalloc(cols * sizeof(GlyphFontSpec));

	/* Xft rendering context */

	xw.draw = XftDrawCreate(xw.dpy, xw.buf, xw.vis, xw.cmap);

	/* input methods */

	if (!ximopen(xw.dpy)) {

		XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL,

	                                       ximinstantiate, NULL);

	}

	/* white cursor, black outline */

	cursor = XCreateFontCursor(xw.dpy, mouseshape);

	XDefineCursor(xw.dpy, xw.win, cursor);

	if (XParseColor(xw.dpy, xw.cmap, colorname[mousefg], &xmousefg) == 0) {

		xmousefg.red   = 0xffff;

		xmousefg.green = 0xffff;

		xmousefg.blue  = 0xffff;

	}

	if (XParseColor(xw.dpy, xw.cmap, colorname[mousebg], &xmousebg) == 0) {

		xmousebg.red   = 0x0000;

		xmousebg.green = 0x0000;

		xmousebg.blue  = 0x0000;

	}

	XRecolorCursor(xw.dpy, cursor, &xmousefg, &xmousebg);

	xw.xembed = XInternAtom(xw.dpy, "_XEMBED", False);

	xw.wmdeletewin = XInternAtom(xw.dpy, "WM_DELETE_WINDOW", False);

	xw.netwmname = XInternAtom(xw.dpy, "_NET_WM_NAME", False);

	xw.netwmiconname = XInternAtom(xw.dpy, "_NET_WM_ICON_NAME", False);

	XSetWMProtocols(xw.dpy, xw.win, &xw.wmdeletewin, 1);

	xw.netwmpid = XInternAtom(xw.dpy, "_NET_WM_PID", False);

	XChangeProperty(xw.dpy, xw.win, xw.netwmpid, XA_CARDINAL, 32,

			PropModeReplace, (uchar *)&thispid, 1);

	win.mode = MODE_NUMLOCK;

	resettitle();

	xhints();

	XMapWindow(xw.dpy, xw.win);

	XSync(xw.dpy, False);

	clock_gettime(CLOCK_MONOTONIC, &xsel.tclick1);

	clock_gettime(CLOCK_MONOTONIC, &xsel.tclick2);

	xsel.primary = NULL;

	xsel.clipboard = NULL;

	xsel.xtarget = XInternAtom(xw.dpy, "UTF8_STRING", 0);

	if (xsel.xtarget == None)

		xsel.xtarget = XA_STRING;

}

int

xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x, int y)

{

	float winx = borderpx + x * win.cw, winy = borderpx + y * win.ch, xp, yp;

	ushort mode, prevmode = USHRT_MAX;

	Font *font = &dc.font;

	int frcflags = FRC_NORMAL;

	float runewidth = win.cw;

	Rune rune;

	FT_UInt glyphidx;

	FcResult fcres;

	FcPattern *fcpattern, *fontpattern;

	FcFontSet *fcsets[] = { NULL };

	FcCharSet *fccharset;

	int i, f, numspecs = 0;

	for (i = 0, xp = winx, yp = winy + font->ascent; i < len; ++i) {

		/* Fetch rune and mode for current glyph. */

		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.0f : 1.0f);

			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;

		}

		/* Lookup character index with default font. */

		glyphidx = XftCharIndex(xw.dpy, font->match, rune);

		if (glyphidx) {

			specs[numspecs].font = font->match;

			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. */

		for (f = 0; f < frclen; f++) {

			glyphidx = XftCharIndex(xw.dpy, frc[f].font, rune);

			/* 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