feat: added dvtm underneath source tree

8 files changed, 4600 insertions, 0 deletions

diff --git a/sys/cmd/dvtm/LICENSE b/sys/cmd/dvtm/LICENSE
new file mode 100644
index 0000000..7873302
--- /dev/null
+++ b/sys/cmd/dvtm/LICENSE
@@ -0,0 +1,22 @@
+MIT/X Consortium License
+
+ (c) 2006-2007 Anselm R. Garbe <garbeam at gmail dot com>
+ (c) 2007-2016 Marc André Tanner <mat at brain-dump dot org>
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/sys/cmd/dvtm/dvtm.c b/sys/cmd/dvtm/dvtm.c
new file mode 100644
index 0000000..a2ba03b
--- /dev/null
+++ b/sys/cmd/dvtm/dvtm.c
@@ -0,0 +1,1789 @@
+#include "dvtm.h"
+
+/* global variables */
+uint waw, wah, wax, way;
+Client *clients = NULL;
+char *title;
+const char *dvtm_name = "dvtm";
+
+Screen screen = { .mfact = MFACT, .nmaster = NMASTER, .history = SCROLL_HISTORY };
+static Client *stack   = NULL;
+static Client *sel     = NULL;
+static Client *lastsel = NULL;
+static Client *msel    = NULL;
+static uint seltags;
+static uint tagset[2] = { 1, 1 };
+static bool mouse_events_enabled = ENABLE_MOUSE;
+static Layout *layout = layouts;
+static StatusBar bar = { .fd = -1, .lastpos = BAR_POS, .pos = BAR_POS, .autohide = BAR_AUTOHIDE, .h = 1 };
+static CmdFifo cmdfifo = { .fd = -1 };
+static const char *shell;
+static Register copyreg;
+static volatile sig_atomic_t running = true;
+static bool runinall = false;
+
+/* function implementations */
+static 
+void
+eprint(const char *errstr, ...) 
+{
+	va_list ap;
+	va_start(ap, errstr);
+	vfprintf(stderr, errstr, ap);
+	va_end(ap);
+}
+
+static 
+void
+fatal(const char *errstr, ...) 
+{
+	va_list ap;
+	va_start(ap, errstr);
+	vfprintf(stderr, errstr, ap);
+	va_end(ap);
+	exit(EXIT_FAILURE);
+}
+
+static 
+bool
+isarrange(void (*func)()) 
+{
+	return func == layout->arrange;
+}
+
+static 
+bool
+isvisible(Client *c) 
+{
+	return c->tags & tagset[seltags];
+}
+
+static 
+bool
+is_content_visible(Client *c) 
+{
+	if (!c)
+		return false;
+	if (isarrange(fullscreen))
+		return sel == c;
+	return isvisible(c) && !c->minimized;
+}
+
+Client*
+nextvisible(Client *c) 
+{
+	for (; c && !isvisible(c); c = c->next);
+	return c;
+}
+
+static 
+void
+updatebarpos(void) 
+{
+	bar.y = 0;
+	wax = 0;
+	way = 0;
+	wah = screen.h;
+	waw = screen.w;
+	if (bar.pos == BAR_TOP) {
+		wah -= bar.h;
+		way += bar.h;
+	} else if (bar.pos == BAR_BOTTOM) {
+		wah -= bar.h;
+		bar.y = wah;
+	}
+}
+
+static 
+void
+hidebar(void) 
+{
+	if (bar.pos != BAR_OFF) {
+		bar.lastpos = bar.pos;
+		bar.pos = BAR_OFF;
+	}
+}
+
+static 
+void
+showbar(void) 
+{
+	if (bar.pos == BAR_OFF)
+		bar.pos = bar.lastpos;
+}
+
+static 
+void
+drawbar(void) 
+{
+	int sx, sy, x, y, width;
+	uint occupied = 0, urgent = 0;
+	if (bar.pos == BAR_OFF)
+		return;
+
+	for (Client *c = clients; c; c = c->next) {
+		occupied |= c->tags;
+		if (c->urgent)
+			urgent |= c->tags;
+	}
+
+	getyx(stdscr, sy, sx);
+	attrset(BAR_ATTR);
+	move(bar.y, 0);
+
+	for (uint i = 0; i < arrlen(tags); i++){
+		if (tagset[seltags] & (1 << i))
+			attrset(TAG_SEL);
+		else if (urgent & (1 << i))
+			attrset(TAG_URGENT);
+		else if (occupied & (1 << i))
+			attrset(TAG_OCCUPIED);
+		else
+			attrset(TAG_NORMAL);
+		printw(TAG_SYMBOL, tags[i]);
+	}
+
+	attrset(runinall ? TAG_SEL : TAG_NORMAL);
+	addstr(layout->symbol);
+	attrset(TAG_NORMAL);
+
+	getyx(stdscr, y, x);
+	(void)y;
+	int maxwidth = screen.w - x - 2;
+
+	addch(BAR_BEGIN);
+	attrset(BAR_ATTR);
+
+	wchar_t wbuf[sizeof bar.text];
+	size_t numchars = mbstowcs(wbuf, bar.text, sizeof bar.text);
+
+	if (numchars != (size_t)-1 && (width = wcswidth(wbuf, maxwidth)) != -1) {
+		int pos;
+		for (pos = 0; pos + width < maxwidth; pos++)
+			addch(' ');
+
+		for (size_t i = 0; i < numchars; i++) {
+			pos += wcwidth(wbuf[i]);
+			if (pos > maxwidth)
+				break;
+			addnwstr(wbuf+i, 1);
+		}
+
+		clrtoeol();
+	}
+
+	attrset(TAG_NORMAL);
+	mvaddch(bar.y, screen.w - 1, BAR_END);
+	attrset(NORMAL_ATTR);
+	move(sy, sx);
+	wnoutrefresh(stdscr);
+}
+
+static int
+show_border(void) {
+	return (bar.pos != BAR_OFF) || (clients && clients->next);
+}
+
+static void
+draw_border(Client *c) {
+	char t = '\0';
+	int x, y, maxlen, attrs = NORMAL_ATTR;
+
+	if (!show_border())
+		return;
+	if (sel != c && c->urgent)
+		attrs = URGENT_ATTR;
+	if (sel == c || (runinall && !c->minimized))
+		attrs = SELECTED_ATTR;
+
+	wattrset(c->window, attrs);
+	getyx(c->window, y, x);
+	mvwhline(c->window, 0, 0, ACS_HLINE, c->w);
+	maxlen = c->w - 10;
+	if (maxlen < 0)
+		maxlen = 0;
+	if ((size_t)maxlen < sizeof(c->title)) {
+		t = c->title[maxlen];
+		c->title[maxlen] = '\0';
+	}
+
+	mvwprintw(c->window, 0, 2, "[%s%s#%d]",
+	          *c->title ? c->title : "",
+	          *c->title ? " | " : "",
+	          c->order);
+	if (t)
+		c->title[maxlen] = t;
+	wmove(c->window, y, x);
+}
+
+static void
+draw_content(Client *c) {
+	vt_draw(c->term, c->window, c->has_title_line, 0);
+}
+
+static void
+draw(Client *c) {
+	if (is_content_visible(c)) {
+		redrawwin(c->window);
+		draw_content(c);
+	}
+	if (!isarrange(fullscreen) || sel == c)
+		draw_border(c);
+	wnoutrefresh(c->window);
+}
+
+static void
+draw_all(void) {
+	if (!nextvisible(clients)) {
+		sel = NULL;
+		curs_set(0);
+		erase();
+		drawbar();
+		doupdate();
+		return;
+	}
+
+	if (!isarrange(fullscreen)) {
+		for (Client *c = nextvisible(clients); c; c = nextvisible(c->next)) {
+			if (c != sel)
+				draw(c);
+		}
+	}
+	/* as a last step the selected window is redrawn,
+	 * this has the effect that the cursor position is
+	 * accurate
+	 */
+	if (sel)
+		draw(sel);
+}
+
+static void
+arrange(void) {
+	uint m = 0, n = 0;
+	for (Client *c = nextvisible(clients); c; c = nextvisible(c->next)) {
+		c->order = ++n;
+		if (c->minimized)
+			m++;
+	}
+	erase();
+	attrset(NORMAL_ATTR);
+	if (bar.fd == -1 && bar.autohide) {
+		if ((!clients || !clients->next) && n == 1)
+			hidebar();
+		else
+			showbar();
+		updatebarpos();
+	}
+	if (m && !isarrange(fullscreen))
+		wah--;
+	layout->arrange();
+	if (m && !isarrange(fullscreen)) {
+		uint i = 0, nw = waw / m, nx = wax;
+		for (Client *c = nextvisible(clients); c; c = nextvisible(c->next)) {
+			if (c->minimized) {
+				resize(c, nx, way+wah, ++i == m ? waw - nx : nw, 1);
+				nx += nw;
+			}
+		}
+		wah++;
+	}
+	focus(NULL);
+	wnoutrefresh(stdscr);
+	drawbar();
+	draw_all();
+}
+
+static void
+attach(Client *c) {
+	if (clients)
+		clients->prev = c;
+	c->next = clients;
+	c->prev = NULL;
+	clients = c;
+	for (int o = 1; c; c = nextvisible(c->next), o++)
+		c->order = o;
+}
+
+static void
+attachafter(Client *c, Client *a) { /* attach c after a */
+	if (c == a)
+		return;
+	if (!a)
+		for (a = clients; a && a->next; a = a->next);
+
+	if (a) {
+		if (a->next)
+			a->next->prev = c;
+		c->next = a->next;
+		c->prev = a;
+		a->next = c;
+		for (int o = a->order; c; c = nextvisible(c->next))
+			c->order = ++o;
+	}
+}
+
+static void
+attachstack(Client *c) {
+	c->snext = stack;
+	stack = c;
+}
+
+static void
+detach(Client *c) {
+	Client *d;
+	if (c->prev)
+		c->prev->next = c->next;
+	if (c->next) {
+		c->next->prev = c->prev;
+		for (d = nextvisible(c->next); d; d = nextvisible(d->next))
+			--d->order;
+	}
+	if (c == clients)
+		clients = c->next;
+	c->next = c->prev = NULL;
+}
+
+static void
+settitle(Client *c) {
+	char *term, *t = title;
+	if (!t && sel == c && *c->title)
+		t = c->title;
+	if (t && (term = getenv("TERM")) && !strstr(term, "linux")) {
+		printf("\033]0;%s\007", t);
+		fflush(stdout);
+	}
+}
+
+static void
+detachstack(Client *c) {
+	Client **tc;
+	for (tc = &stack; *tc && *tc != c; tc = &(*tc)->snext);
+	*tc = c->snext;
+}
+
+void
+focus(Client *c) {
+	if (!c)
+		for (c = stack; c && !isvisible(c); c = c->snext);
+	if (sel == c)
+		return;
+	lastsel = sel;
+	sel = c;
+	if (lastsel) {
+		lastsel->urgent = false;
+		if (!isarrange(fullscreen)) {
+			draw_border(lastsel);
+			wnoutrefresh(lastsel->window);
+		}
+	}
+
+	if (c) {
+		detachstack(c);
+		attachstack(c);
+		settitle(c);
+		c->urgent = false;
+		if (isarrange(fullscreen)) {
+			draw(c);
+		} else {
+			draw_border(c);
+			wnoutrefresh(c->window);
+		}
+	}
+	curs_set(c && !c->minimized && vt_cursor_visible(c->term));
+}
+
+static void
+applycolorrules(Client *c) {
+	const ColorRule *r = colorrules;
+	short fg = r->color->fg, bg = r->color->bg;
+	attr_t attrs = r->attrs;
+
+	for (uint i = 1; i < arrlen(colorrules); i++) {
+		r = &colorrules[i];
+		if (strstr(c->title, r->title)) {
+			attrs = r->attrs;
+			fg = r->color->fg;
+			bg = r->color->bg;
+			break;
+		}
+	}
+
+	vt_default_colors_set(c->term, attrs, fg, bg);
+}
+
+static void
+term_title_handler(Vt *term, const char *title) {
+	Client *c = (Client *)vt_data_get(term);
+	if (title)
+		strncpy(c->title, title, sizeof(c->title) - 1);
+	c->title[title ? sizeof(c->title) - 1 : 0] = '\0';
+	settitle(c);
+	if (!isarrange(fullscreen) || sel == c)
+		draw_border(c);
+	applycolorrules(c);
+}
+
+static void
+term_urgent_handler(Vt *term) {
+	Client *c = (Client *)vt_data_get(term);
+	c->urgent = true;
+	printf("\a");
+	fflush(stdout);
+	drawbar();
+	if (!isarrange(fullscreen) && sel != c && isvisible(c))
+		draw_border(c);
+}
+
+static 
+void
+move_client(Client *c, int x, int y) 
+{
+	if (c->x == x && c->y == y)
+		return;
+	debug("moving, x: %d y: %d\n", x, y);
+	if (mvwin(c->window, y, x) == ERR) {
+		eprint("error moving, x: %d y: %d\n", x, y);
+	} else {
+		c->x = x;
+		c->y = y;
+	}
+}
+
+static 
+void
+resize_client(Client *c, int w, int h) 
+{
+	bool has_title_line = show_border();
+	bool resize_window = c->w != w || c->h != h;
+	if (resize_window) {
+		debug("resizing, w: %d h: %d\n", w, h);
+		if (wresize(c->window, h, w) == ERR) {
+			eprint("error resizing, w: %d h: %d\n", w, h);
+		} else {
+			c->w = w;
+			c->h = h;
+		}
+	}
+	if (resize_window || c->has_title_line != has_title_line) {
+		c->has_title_line = has_title_line;
+		vt_resize(c->app, h - has_title_line, w);
+		if (c->editor)
+			vt_resize(c->editor, h - has_title_line, w);
+	}
+}
+
+void
+resize(Client *c, int x, int y, int w, int h) 
+{
+	resize_client(c, w, h);
+	move_client(c, x, y);
+}
+
+static 
+Client*
+get_client_by_coord(uint x, unsigned int y) {
+	if (y < way || y >= way+wah)
+		return NULL;
+	if (isarrange(fullscreen))
+		return sel;
+	for (Client *c = nextvisible(clients); c; c = nextvisible(c->next)) {
+		if (x >= c->x && x < c->x + c->w && y >= c->y && y < c->y + c->h) {
+			debug("mouse event, x: %d y: %d client: %d\n", x, y, c->order);
+			return c;
+		}
+	}
+	return NULL;
+}
+
+static 
+void
+sigchld_handler(int sig) {
+	int errsv = errno;
+	int status;
+	pid_t pid;
+
+	while ((pid = waitpid(-1, &status, WNOHANG)) != 0) {
+		if (pid == -1) {
+			if (errno == ECHILD) {
+				/* no more child processes */
+				break;
+			}
+			eprint("waitpid: %s\n", strerror(errno));
+			break;
+		}
+
+		debug("child with pid %d died\n", pid);
+
+		for (Client *c = clients; c; c = c->next) {
+			if (c->pid == pid) {
+				c->died = true;
+				break;
+			}
+			if (c->editor && vt_pid_get(c->editor) == pid) {
+				c->editor_died = true;
+				break;
+			}
+		}
+	}
+
+	errno = errsv;
+}
+
+static 
+void
+sigwinch_handler(int sig) {
+	screen.need_resize = true;
+}
+
+static 
+void
+sigterm_handler(int sig) {
+	running = false;
+}
+
+static 
+void
+resize_screen(void) 
+{
+	struct winsize ws;
+
+	if (ioctl(0, TIOCGWINSZ, &ws) == -1) {
+		getmaxyx(stdscr, screen.h, screen.w);
+	} else {
+		screen.w = ws.ws_col;
+		screen.h = ws.ws_row;
+	}
+
+	debug("resize_screen(), w: %d h: %d\n", screen.w, screen.h);
+
+	resizeterm(screen.h, screen.w);
+	wresize(stdscr, screen.h, screen.w);
+	updatebarpos();
+	clear();
+	arrange();
+}
+
+static 
+KeyBinding*
+keybinding(KeyCombo keys, uint keycount) 
+{
+	for (uint b = 0; b < arrlen(bindings); b++) {
+		for (uint k = 0; k < keycount; k++) {
+			if (keys[k] != bindings[b].keys[k])
+				break;
+			if (k == keycount - 1)
+				return &bindings[b];
+		}
+	}
+	return NULL;
+}
+
+static 
+uint
+bitoftag(const char *tag) 
+{
+	uint i;
+	if (!tag)
+		return ~0;
+	for (i = 0; (i < arrlen(tags)) && strcmp(tags[i], tag); i++);
+	return (i < arrlen(tags)) ? (1 << i) : 0;
+}
+
+static void
+tagschanged() {
+	bool allminimized = true;
+	for (Client *c = nextvisible(clients); c; c = nextvisible(c->next)) {
+		if (!c->minimized) {
+			allminimized = false;
+			break;
+		}
+	}
+	if (allminimized && nextvisible(clients)) {
+		focus(NULL);
+		toggleminimize(NULL);
+	}
+	arrange();
+}
+
+void
+tag(const char *args[]) 
+{
+	if (!sel)
+		return;
+	sel->tags = bitoftag(args[0]) & TAGMASK;
+	tagschanged();
+}
+
+void
+tagid(const char *args[]) 
+{
+	if (!args[0] || !args[1])
+		return;
+
+	const int win_id = atoi(args[0]);
+	for (Client *c = clients; c; c = c->next) {
+		if (c->id == win_id) {
+			uint ntags = c->tags;
+			for (uint i = 1; i < MAX_ARGS && args[i]; i++) {
+				if (args[i][0] == '+')
+					ntags |= bitoftag(args[i]+1);
+				else if (args[i][0] == '-')
+					ntags &= ~bitoftag(args[i]+1);
+				else
+					ntags = bitoftag(args[i]);
+			}
+			ntags &= TAGMASK;
+			if (ntags) {
+				c->tags = ntags;
+				tagschanged();
+			}
+			return;
+		}
+	}
+}
+
+void
+toggletag(const char *args[]) 
+{
+	if (!sel)
+		return;
+	uint newtags = sel->tags ^ (bitoftag(args[0]) & TAGMASK);
+	if (newtags) {
+		sel->tags = newtags;
+		tagschanged();
+	}
+}
+
+void
+toggleview(const char *args[]) 
+{
+	uint newtagset = tagset[seltags] ^ (bitoftag(args[0]) & TAGMASK);
+	if (newtagset) {
+		tagset[seltags] = newtagset;
+		tagschanged();
+	}
+}
+
+void
+view(const char *args[]) 
+{
+	uint newtagset = bitoftag(args[0]) & TAGMASK;
+	if (tagset[seltags] != newtagset && newtagset) {
+		seltags ^= 1; /* toggle sel tagset */
+		tagset[seltags] = newtagset;
+		tagschanged();
+	}
+}
+
+void
+viewprevtag(const char *args[]) 
+{
+	seltags ^= 1;
+	tagschanged();
+}
+
+static void
+keypress(int code) {
+	int key = -1;
+	uint len = 1;
+	char buf[8] = { '\e' };
+
+	if (code == '\e') {
+		/* pass characters following escape to the underlying app */
+		nodelay(stdscr, TRUE);
+		for (int t; len < sizeof(buf) && (t = getch()) != ERR; len++) {
+			if (t > 255) {
+				key = t;
+				break;
+			}
+			buf[len] = t;
+		}
+		nodelay(stdscr, FALSE);
+	}
+
+	for (Client *c = runinall ? nextvisible(clients) : sel; c; c = nextvisible(c->next)) {
+		if (is_content_visible(c)) {
+			c->urgent = false;
+			if (code == '\e')
+				vt_write(c->term, buf, len);
+			else
+				vt_keypress(c->term, code);
+			if (key != -1)
+				vt_keypress(c->term, key);
+		}
+		if (!runinall)
+			break;
+	}
+}
+
+static void
+mouse_setup(void) {
+#ifdef CONFIG_MOUSE
+	mmask_t mask = 0;
+
+	if (mouse_events_enabled) {
+		mask = BUTTON1_CLICKED | BUTTON2_CLICKED;
+		for (uint i = 0; i < arrlen(buttons); i++)
+			mask |= buttons[i].mask;
+	}
+	mousemask(mask, NULL);
+#endif /* CONFIG_MOUSE */
+}
+
+static bool
+checkshell(const char *shell) {
+	if (shell == NULL || *shell == '\0' || *shell != '/')
+		return false;
+	if (!strcmp(strrchr(shell, '/')+1, dvtm_name))
+		return false;
+	if (access(shell, X_OK))
+		return false;
+	return true;
+}
+
+static const char *
+getshell(void) {
+	const char *shell = getenv("SHELL");
+	struct passwd *pw;
+
+	if (checkshell(shell))
+		return shell;
+	if ((pw = getpwuid(getuid())) && checkshell(pw->pw_shell))
+		return pw->pw_shell;
+	return "/bin/sh";
+}
+
+static void
+setup(void) {
+	shell = getshell();
+	setlocale(LC_CTYPE, "");
+	initscr();
+	start_color();
+	noecho();
+	nonl();
+	keypad(stdscr, TRUE);
+	mouse_setup();
+	raw();
+	vt_init();
+	vt_keytable_set(keytable, arrlen(keytable));
+	for (uint i = 0; i < arrlen(colors); i++) {
+		if (COLORS == 256) {
+			if (colors[i].fg256)
+				colors[i].fg = colors[i].fg256;
+			if (colors[i].bg256)
+				colors[i].bg = colors[i].bg256;
+		}
+		colors[i].pair = vt_color_reserve(colors[i].fg, colors[i].bg);
+	}
+	resize_screen();
+	struct sigaction sa;
+	memset(&sa, 0, sizeof sa);
+	sa.sa_flags = 0;
+	sigemptyset(&sa.sa_mask);
+	sa.sa_handler = sigwinch_handler;
+	sigaction(SIGWINCH, &sa, NULL);
+	sa.sa_handler = sigchld_handler;
+	sigaction(SIGCHLD, &sa, NULL);
+	sa.sa_handler = sigterm_handler;
+	sigaction(SIGTERM, &sa, NULL);
+	sa.sa_handler = SIG_IGN;
+	sigaction(SIGPIPE, &sa, NULL);
+}
+
+static void
+destroy(Client *c) {
+	if (sel == c)
+		focusnextnm(NULL);
+	detach(c);
+	detachstack(c);
+	if (sel == c) {
+		Client *next = nextvisible(clients);
+		if (next) {
+			focus(next);
+			toggleminimize(NULL);
+		} else {
+			sel = NULL;
+		}
+	}
+	if (lastsel == c)
+		lastsel = NULL;
+	werase(c->window);
+	wnoutrefresh(c->window);
+	vt_destroy(c->term);
+	delwin(c->window);
+	if (!clients && arrlen(actions)) {
+		if (!strcmp(c->cmd, shell))
+			quit(NULL);
+		else
+			create(NULL);
+	}
+	free(c);
+	arrange();
+}
+
+static void
+cleanup(void) {
+	while (clients)
+		destroy(clients);
+	vt_shutdown();
+	endwin();
+	free(copyreg.data);
+	if (bar.fd > 0)
+		close(bar.fd);
+	if (bar.file)
+		unlink(bar.file);
+	if (cmdfifo.fd > 0)
+		close(cmdfifo.fd);
+	if (cmdfifo.file)
+		unlink(cmdfifo.file);
+}
+
+static char *getcwd_by_pid(Client *c) {
+	if (!c)
+		return NULL;
+	char buf[32];
+	snprintf(buf, sizeof buf, "/proc/%d/cwd", c->pid);
+	return realpath(buf, NULL);
+}
+
+void
+create(const char *args[]) 
+{
+	const char *pargs[4] = { shell, NULL };
+	char buf[8], *cwd = NULL;
+	const char *env[] = {
+		"DVTM_WINDOW_ID", buf,
+		NULL
+	};
+
+	if (args && args[0]) {
+		pargs[1] = "-c";
+		pargs[2] = args[0];
+		pargs[3] = NULL;
+	}
+	Client *c = calloc(1, sizeof(Client));
+	if (!c)
+		return;
+	c->tags = tagset[seltags];
+	c->id = ++cmdfifo.id;
+	snprintf(buf, sizeof buf, "%d", c->id);
+
+	if (!(c->window = newwin(wah, waw, way, wax))) {
+		free(c);
+		return;
+	}
+
+	c->term = c->app = vt_create(screen.h, screen.w, screen.history);
+	if (!c->term) {
+		delwin(c->window);
+		free(c);
+		return;
+	}
+
+	if (args && args[0]) {
+		c->cmd = args[0];
+		char name[PATH_MAX];
+		strncpy(name, args[0], sizeof(name));
+		name[sizeof(name)-1] = '\0';
+		strncpy(c->title, basename(name), sizeof(c->title));
+	} else {
+		c->cmd = shell;
+	}
+
+	if (args && args[1])
+		strncpy(c->title, args[1], sizeof(c->title));
+	c->title[sizeof(c->title)-1] = '\0';
+
+	if (args && args[2])
+		cwd = !strcmp(args[2], "$CWD") ? getcwd_by_pid(sel) : (char*)args[2];
+	c->pid = vt_forkpty(c->term, shell, pargs, cwd, env, NULL, NULL);
+	if (args && args[2] && !strcmp(args[2], "$CWD"))
+		free(cwd);
+	vt_data_set(c->term, c);
+	vt_title_handler_set(c->term, term_title_handler);
+	vt_urgent_handler_set(c->term, term_urgent_handler);
+	applycolorrules(c);
+	c->x = wax;
+	c->y = way;
+	debug("client with pid %d forked\n", c->pid);
+	attach(c);
+	focus(c);
+	arrange();
+}
+
+void
+copymode(const char *args[]) 
+{
+	if (!args || !args[0] || !sel || sel->editor)
+		return;
+
+	bool colored = strstr(args[0], "pager") != NULL;
+
+	if (!(sel->editor = vt_create(sel->h - sel->has_title_line, sel->w, 0)))
+		return;
+
+	int *to = &sel->editor_fds[0];
+	int *from = strstr(args[0], "editor") ? &sel->editor_fds[1] : NULL;
+	sel->editor_fds[0] = sel->editor_fds[1] = -1;
+
+	const char *argv[3] = { args[0], NULL, NULL };
+	char argline[32];
+	int line = vt_content_start(sel->app);
+	snprintf(argline, sizeof(argline), "+%d", line);
+	argv[1] = argline;
+
+	if (vt_forkpty(sel->editor, args[0], argv, NULL, NULL, to, from) < 0) {
+		vt_destroy(sel->editor);
+		sel->editor = NULL;
+		return;
+	}
+
+	sel->term = sel->editor;
+
+	if (sel->editor_fds[0] != -1) {
+		char *buf = NULL;
+		size_t len = vt_content_get(sel->app, &buf, colored);
+		char *cur = buf;
+		while (len > 0) {
+			ssize_t res = write(sel->editor_fds[0], cur, len);
+			if (res < 0) {
+				if (errno == EAGAIN || errno == EINTR)
+					continue;
+				break;
+			}
+			cur += res;
+			len -= res;
+		}
+		free(buf);
+		close(sel->editor_fds[0]);
+		sel->editor_fds[0] = -1;
+	}
+
+	if (args[1])
+		vt_write(sel->editor, args[1], strlen(args[1]));
+}
+
+void
+focusn(const char *args[]) 
+{
+	for (Client *c = nextvisible(clients); c; c = nextvisible(c->next)) {
+		if (c->order == atoi(args[0])) {
+			focus(c);
+			if (c->minimized)
+				toggleminimize(NULL);
+			return;
+		}
+	}
+}
+
+void
+focusid(const char *args[]) 
+{
+	if (!args[0])
+		return;
+
+	const int win_id = atoi(args[0]);
+	for (Client *c = clients; c; c = c->next) {
+		if (c->id == win_id) {
+			focus(c);
+			if (c->minimized)
+				toggleminimize(NULL);
+			if (!isvisible(c)) {
+				c->tags |= tagset[seltags];
+				tagschanged();
+			}
+			return;
+		}
+	}
+}
+
+void
+focusnext(const char *args[]) 
+{
+	Client *c;
+	if (!sel)
+		return;
+	for (c = sel->next; c && !isvisible(c); c = c->next);
+	if (!c)
+		for (c = clients; c && !isvisible(c); c = c->next);
+	if (c)
+		focus(c);
+}
+
+void
+focusnextnm(const char *args[]) 
+{
+	if (!sel)
+		return;
+	Client *c = sel;
+	do {
+		c = nextvisible(c->next);
+		if (!c)
+			c = nextvisible(clients);
+	} while (c->minimized && c != sel);
+	focus(c);
+}
+
+void
+focusprev(const char *args[]) 
+{
+	Client *c;
+	if (!sel)
+		return;
+	for (c = sel->prev; c && !isvisible(c); c = c->prev);
+	if (!c) {
+		for (c = clients; c && c->next; c = c->next);
+		for (; c && !isvisible(c); c = c->prev);
+	}
+	if (c)
+		focus(c);
+}
+
+void
+focusprevnm(const char *args[]) 
+{
+	if (!sel)
+		return;
+	Client *c = sel;
+	do {
+		for (c = c->prev; c && !isvisible(c); c = c->prev);
+		if (!c) {
+			for (c = clients; c && c->next; c = c->next);
+			for (; c && !isvisible(c); c = c->prev);
+		}
+	} while (c && c != sel && c->minimized);
+	focus(c);
+}
+
+void
+focuslast(const char *args[]) 
+{
+	if (lastsel)
+		focus(lastsel);
+}
+
+void
+focusup(const char *args[]) 
+{
+	if (!sel)
+		return;
+	/* avoid vertical separator, hence +1 in x direction */
+	Client *c = get_client_by_coord(sel->x + 1, sel->y - 1);
+	if (c)
+		focus(c);
+	else
+		focusprev(args);
+}
+
+void
+focusdown(const char *args[]) 
+{
+	if (!sel)
+		return;
+	Client *c = get_client_by_coord(sel->x, sel->y + sel->h);
+	if (c)
+		focus(c);
+	else
+		focusnext(args);
+}
+
+void
+focusleft(const char *args[]) 
+{
+	if (!sel)
+		return;
+	Client *c = get_client_by_coord(sel->x - 2, sel->y);
+	if (c)
+		focus(c);
+	else
+		focusprev(args);
+}
+
+void
+focusright(const char *args[]) 
+{
+	if (!sel)
+		return;
+	Client *c = get_client_by_coord(sel->x + sel->w + 1, sel->y);
+	if (c)
+		focus(c);
+	else
+		focusnext(args);
+}
+
+void
+killclient(const char *args[]) 
+{
+	if (!sel)
+		return;
+	debug("killing client with pid: %d\n", sel->pid);
+	kill(-sel->pid, SIGKILL);
+}
+
+void
+paste(const char *args[]) 
+{
+	if (sel && copyreg.data)
+		vt_write(sel->term, copyreg.data, copyreg.len);
+}
+
+void
+quit(const char *args[]) 
+{
+	cleanup();
+	exit(EXIT_SUCCESS);
+}
+
+void
+redraw(const char *args[]) 
+{
+	for (Client *c = clients; c; c = c->next) {
+		if (!c->minimized) {
+			vt_dirty(c->term);
+			wclear(c->window);
+			wnoutrefresh(c->window);
+		}
+	}
+	resize_screen();
+}
+
+void
+scrollback(const char *args[]) 
+{
+	if (!is_content_visible(sel))
+		return;
+
+	if (!args[0] || atoi(args[0]) < 0)
+		vt_scroll(sel->term, -sel->h/2);
+	else
+		vt_scroll(sel->term,  sel->h/2);
+
+	draw(sel);
+	curs_set(vt_cursor_visible(sel->term));
+}
+
+void
+send(const char *args[]) 
+{
+	if (sel && args && args[0])
+		vt_write(sel->term, args[0], strlen(args[0]));
+}
+
+void
+setlayout(const char *args[]) 
+{
+	uint i;
+
+	if (!args || !args[0]) {
+		if (++layout == &layouts[arrlen(layouts)])
+			layout = &layouts[0];
+	} else {
+		for (i = 0; i < arrlen(layouts); i++)
+			if (!strcmp(args[0], layouts[i].symbol))
+				break;
+		if (i == arrlen(layouts))
+			return;
+		layout = &layouts[i];
+	}
+	arrange();
+}
+
+void
+incnmaster(const char *args[]) 
+{
+	int delta;
+
+	if (isarrange(fullscreen) || isarrange(grid))
+		return;
+	/* arg handling, manipulate nmaster */
+	if (args[0] == NULL) {
+		screen.nmaster = NMASTER;
+	} else if (sscanf(args[0], "%d", &delta) == 1) {
+		if (args[0][0] == '+' || args[0][0] == '-')
+			screen.nmaster += delta;
+		else
+			screen.nmaster = delta;
+		if (screen.nmaster < 1)
+			screen.nmaster = 1;
+	}
+	arrange();
+}
+
+void
+setmfact(const char *args[]) 
+{
+	float delta;
+
+	if (isarrange(fullscreen) || isarrange(grid))
+		return;
+	/* arg handling, manipulate mfact */
+	if (args[0] == NULL) {
+		screen.mfact = MFACT;
+	} else if (sscanf(args[0], "%f", &delta) == 1) {
+		if (args[0][0] == '+' || args[0][0] == '-')
+			screen.mfact += delta;
+		else
+			screen.mfact = delta;
+		if (screen.mfact < 0.1)
+			screen.mfact = 0.1;
+		else if (screen.mfact > 0.9)
+			screen.mfact = 0.9;
+	}
+	arrange();
+}
+
+void
+startup(const char *args[]) 
+{
+	for (uint i = 0; i < arrlen(actions); i++)
+		actions[i].cmd(actions[i].args);
+}
+
+void
+togglebar(const char *args[]) 
+{
+	if (bar.pos == BAR_OFF)
+		showbar();
+	else
+		hidebar();
+	bar.autohide = false;
+	updatebarpos();
+	redraw(NULL);
+}
+
+void
+togglebarpos(const char *args[]) 
+{
+	switch (bar.pos == BAR_OFF ? bar.lastpos : bar.pos) {
+	case BAR_TOP:
+		bar.pos = BAR_BOTTOM;
+		break;
+	case BAR_BOTTOM:
+		bar.pos = BAR_TOP;
+		break;
+	}
+	updatebarpos();
+	redraw(NULL);
+}
+
+void
+toggleminimize(const char *args[]) 
+{
+	Client *c, *m, *t;
+	uint n;
+	if (!sel)
+		return;
+	/* the last window can't be minimized */
+	if (!sel->minimized) {
+		for (n = 0, c = nextvisible(clients); c; c = nextvisible(c->next))
+			if (!c->minimized)
+				n++;
+		if (n == 1)
+			return;
+	}
+	sel->minimized = !sel->minimized;
+	m = sel;
+	/* check whether the master client was minimized */
+	if (sel == nextvisible(clients) && sel->minimized) {
+		c = nextvisible(sel->next);
+		detach(c);
+		attach(c);
+		focus(c);
+		detach(m);
+		for (; c && (t = nextvisible(c->next)) && !t->minimized; c = t);
+		attachafter(m, c);
+	} else if (m->minimized) {
+		/* non master window got minimized move it above all other
+		 * minimized ones */
+		focusnextnm(NULL);
+		detach(m);
+		for (c = nextvisible(clients); c && (t = nextvisible(c->next)) && !t->minimized; c = t);
+		attachafter(m, c);
+	} else { /* window is no longer minimized, move it to the master area */
+		vt_dirty(m->term);
+		detach(m);
+		attach(m);
+	}
+	arrange();
+}
+
+void
+togglemouse(const char *args[]) 
+{
+	mouse_events_enabled = !mouse_events_enabled;
+	mouse_setup();
+}
+
+void
+togglerunall(const char *args[]) 
+{
+	runinall = !runinall;
+	drawbar();
+	draw_all();
+}
+
+void
+zoom(const char *args[]) 
+{
+	Client *c;
+
+	if (!sel)
+		return;
+	if (args && args[0])
+		focusn(args);
+	if ((c = sel) == nextvisible(clients))
+		if (!(c = nextvisible(c->next)))
+			return;
+	detach(c);
+	attach(c);
+	focus(c);
+	if (c->minimized)
+		toggleminimize(NULL);
+	arrange();
+}
+
+/* commands for use by mouse bindings */
+void
+mouse_focus(const char *args[]) 
+{
+	focus(msel);
+	if (msel->minimized)
+		toggleminimize(NULL);
+}
+
+void
+mouse_fullscreen(const char *args[]) 
+{
+	mouse_focus(NULL);
+	setlayout(isarrange(fullscreen) ? NULL : args);
+}
+
+void
+mouse_minimize(const char *args[]) 
+{
+	focus(msel);
+	toggleminimize(NULL);
+}
+
+void
+mouse_zoom(const char *args[]) 
+{
+	focus(msel);
+	zoom(NULL);
+}
+
+static 
+Cmd *
+get_cmd_by_name(const char *name) {
+	for (uint i = 0; i < arrlen(commands); i++) {
+		if (!strcmp(name, commands[i].name))
+			return &commands[i];
+	}
+	return NULL;
+}
+
+static 
+void
+handle_cmdfifo(void) {
+	int r;
+	char *p, *s, cmdbuf[512], c;
+	Cmd *cmd;
+
+	r = read(cmdfifo.fd, cmdbuf, sizeof cmdbuf - 1);
+	if (r <= 0) {
+		cmdfifo.fd = -1;
+		return;
+	}
+
+	cmdbuf[r] = '\0';
+	p = cmdbuf;
+	while (*p) {
+		/* find the command name */
+		for (; *p == ' ' || *p == '\n'; p++);
+		for (s = p; *p && *p != ' ' && *p != '\n'; p++);
+		if ((c = *p))
+			*p++ = '\0';
+		if (*s && (cmd = get_cmd_by_name(s)) != NULL) {
+			bool quote = false;
+			int argc = 0;
+			const char *args[MAX_ARGS], *arg;
+			memset(args, 0, sizeof(args));
+			/* if arguments were specified in config.h ignore the one given via
+			 * the named pipe and thus skip everything until we find a new line
+			 */
+			if (cmd->action.args[0] || c == '\n') {
+				debug("execute %s", s);
+				cmd->action.cmd(cmd->action.args);
+				while (*p && *p != '\n')
+					p++;
+				continue;
+			}
+			/* no arguments were given in config.h so we parse the command line */
+			while (*p == ' ')
+				p++;
+			arg = p;
+			for (; (c = *p); p++) {
+				switch (*p) {
+				case '\\':
+					/* remove the escape character '\\' move every
+					 * following character to the left by one position
+					 */
+					switch (p[1]) {
+						case '\\':
+						case '\'':
+						case '\"': {
+							char *t = p+1;
+							do {
+								t[-1] = *t;
+							} while (*t++);
+						}
+					}
+					break;
+				case '\'':
+				case '\"':
+					quote = !quote;
+					break;
+				case ' ':
+					if (!quote) {
+				case '\n':
+						/* remove trailing quote if there is one */
+						if (*(p - 1) == '\'' || *(p - 1) == '\"')
+							*(p - 1) = '\0';
+						*p++ = '\0';
+						/* remove leading quote if there is one */
+						if (*arg == '\'' || *arg == '\"')
+							arg++;
+						if (argc < MAX_ARGS)
+							args[argc++] = arg;
+
+						while (*p == ' ')
+							++p;
+						arg = p--;
+					}
+					break;
+				}
+
+				if (c == '\n' || *p == '\n') {
+					if (!*p)
+						p++;
+					debug("execute %s", s);
+					for(int i = 0; i < argc; i++)
+						debug(" %s", args[i]);
+					debug("\n");
+					cmd->action.cmd(args);
+					break;
+				}
+			}
+		}
+	}
+}
+
+static void
+handle_mouse(void) {
+#ifdef CONFIG_MOUSE
+	MEVENT event;
+	uint i;
+	if (getmouse(&event) != OK)
+		return;
+	msel = get_client_by_coord(event.x, event.y);
+
+	if (!msel)
+		return;
+
+	debug("mouse x:%d y:%d cx:%d cy:%d mask:%d\n", event.x, event.y, event.x - msel->x, event.y - msel->y, event.bstate);
+
+	vt_mouse(msel->term, event.x - msel->x, event.y - msel->y, event.bstate);
+
+	for (i = 0; i < arrlen(buttons); i++) {
+		if (event.bstate & buttons[i].mask)
+			buttons[i].action.cmd(buttons[i].action.args);
+	}
+
+	msel = NULL;
+#endif /* CONFIG_MOUSE */
+}
+
+static void
+handle_statusbar(void) {
+	char *p;
+	int r;
+	switch (r = read(bar.fd, bar.text, sizeof bar.text - 1)) {
+		case -1:
+			strncpy(bar.text, strerror(errno), sizeof bar.text - 1);
+			bar.text[sizeof bar.text - 1] = '\0';
+			bar.fd = -1;
+			break;
+		case 0:
+			bar.fd = -1;
+			break;
+		default:
+			bar.text[r] = '\0';
+			p = bar.text + r - 1;
+			for (; p >= bar.text && *p == '\n'; *p-- = '\0');
+			for (; p >= bar.text && *p != '\n'; --p);
+			if (p >= bar.text)
+				memmove(bar.text, p + 1, strlen(p));
+			drawbar();
+	}
+}
+
+static void
+handle_editor(Client *c) {
+	if (!copyreg.data && (copyreg.data = malloc(screen.history)))
+		copyreg.size = screen.history;
+	copyreg.len = 0;
+	while (c->editor_fds[1] != -1 && copyreg.len < copyreg.size) {
+		ssize_t len = read(c->editor_fds[1], copyreg.data + copyreg.len, copyreg.size - copyreg.len);
+		if (len == -1) {
+			if (errno == EINTR)
+				continue;
+			break;
+		}
+		if (len == 0)
+			break;
+		copyreg.len += len;
+		if (copyreg.len == copyreg.size) {
+			copyreg.size *= 2;
+			if (!(copyreg.data = realloc(copyreg.data, copyreg.size))) {
+				copyreg.size = 0;
+				copyreg.len = 0;
+			}
+		}
+	}
+	c->editor_died = false;
+	c->editor_fds[1] = -1;
+	vt_destroy(c->editor);
+	c->editor = NULL;
+	c->term = c->app;
+	vt_dirty(c->term);
+	draw_content(c);
+	wnoutrefresh(c->window);
+}
+
+static int
+open_or_create_fifo(const char *name, const char **name_created) {
+	struct stat info;
+	int fd;
+
+	do {
+		if ((fd = open(name, O_RDWR|O_NONBLOCK)) == -1) {
+			if (errno == ENOENT && !mkfifo(name, S_IRUSR|S_IWUSR)) {
+				*name_created = name;
+				continue;
+			}
+			fatal("%s\n", strerror(errno));
+		}
+	} while (fd == -1);
+
+	if (fstat(fd, &info) == -1)
+		fatal("%s\n", strerror(errno));
+	if (!S_ISFIFO(info.st_mode))
+		fatal("%s is not a named pipe\n", name);
+	return fd;
+}
+
+static 
+void
+usage(void) {
+	cleanup();
+	eprint("usage: dvtm [-v] [-M] [-m mod] [-d delay] [-h lines] [-t title] "
+	       "[-s status-fifo] [-c cmd-fifo] [cmd...]\n");
+	exit(EXIT_FAILURE);
+}
+
+static 
+bool
+parse_args(int argc, char *argv[]) {
+	bool init = false;
+	const char *name = argv[0];
+
+	if (name && (name = strrchr(name, '/')))
+		dvtm_name = name + 1;
+	if (!getenv("ESCDELAY"))
+		set_escdelay(100);
+	for (int arg = 1; arg < argc; arg++) {
+		if (argv[arg][0] != '-') {
+			const char *args[] = { argv[arg], NULL, NULL };
+			if (!init) {
+				setup();
+				init = true;
+			}
+			create(args);
+			continue;
+		}
+		if (argv[arg][1] != 'v' && argv[arg][1] != 'M' && (arg + 1) >= argc)
+			usage();
+		switch (argv[arg][1]) {
+			case 'v':
+				puts("dvtm-"VERSION);
+				exit(EXIT_SUCCESS);
+			case 'M':
+				mouse_events_enabled = !mouse_events_enabled;
+				break;
+			case 'm': {
+				char *mod = argv[++arg];
+				if (mod[0] == '^' && mod[1])
+					*mod = CTRL(mod[1]);
+				for (uint b = 0; b < arrlen(bindings); b++)
+					if (bindings[b].keys[0] == MOD)
+						bindings[b].keys[0] = *mod;
+				break;
+			}
+			case 'd':
+				set_escdelay(atoi(argv[++arg]));
+				if (ESCDELAY < 50)
+					set_escdelay(50);
+				else if (ESCDELAY > 1000)
+					set_escdelay(1000);
+				break;
+			case 'h':
+				screen.history = atoi(argv[++arg]);
+				break;
+			case 't':
+				title = argv[++arg];
+				break;
+			case 's':
+				bar.fd = open_or_create_fifo(argv[++arg], &bar.file);
+				updatebarpos();
+				break;
+			case 'c': {
+				const char *fifo;
+				cmdfifo.fd = open_or_create_fifo(argv[++arg], &cmdfifo.file);
+				if (!(fifo = realpath(argv[arg], NULL)))
+					fatal("%s\n", strerror(errno));
+				setenv("DVTM_CMD_FIFO", fifo, 1);
+				break;
+			}
+			default:
+				usage();
+		}
+	}
+	return init;
+}
+
+int
+main(int argc, char *argv[]) {
+	KeyCombo keys;
+	uint key_index = 0;
+	memset(keys, 0, sizeof(keys));
+	sigset_t emptyset, blockset;
+
+	setenv("DVTM", VERSION, 1);
+	if (!parse_args(argc, argv)) {
+		setup();
+		startup(NULL);
+	}
+
+	sigemptyset(&emptyset);
+	sigemptyset(&blockset);
+	sigaddset(&blockset, SIGWINCH);
+	sigaddset(&blockset, SIGCHLD);
+	sigprocmask(SIG_BLOCK, &blockset, NULL);
+
+	while (running) {
+		int r, nfds = 0;
+		fd_set rd;
+
+		if (screen.need_resize) {
+			resize_screen();
+			screen.need_resize = false;
+		}
+
+		FD_ZERO(&rd);
+		FD_SET(STDIN_FILENO, &rd);
+
+		if (cmdfifo.fd != -1) {
+			FD_SET(cmdfifo.fd, &rd);
+			nfds = cmdfifo.fd;
+		}
+
+		if (bar.fd != -1) {
+			FD_SET(bar.fd, &rd);
+			nfds = MAX(nfds, bar.fd);
+		}
+
+		for (Client *c = clients; c; ) {
+			if (c->editor && c->editor_died)
+				handle_editor(c);
+			if (!c->editor && c->died) {
+				Client *t = c->next;
+				destroy(c);
+				c = t;
+				continue;
+			}
+			int pty = c->editor ? vt_pty_get(c->editor) : vt_pty_get(c->app);
+			FD_SET(pty, &rd);
+			nfds = MAX(nfds, pty);
+			c = c->next;
+		}
+
+		doupdate();
+		r = pselect(nfds + 1, &rd, NULL, NULL, NULL, &emptyset);
+
+		if (r < 0) {
+			if (errno == EINTR)
+				continue;
+			perror("select()");
+			exit(EXIT_FAILURE);
+		}
+
+		if (FD_ISSET(STDIN_FILENO, &rd)) {
+			int code = getch();
+			if (code >= 0) {
+				keys[key_index++] = code;
+				KeyBinding *binding = NULL;
+				if (code == KEY_MOUSE) {
+					key_index = 0;
+					handle_mouse();
+				} else if ((binding = keybinding(keys, key_index))) {
+					uint key_length = MAX_KEYS;
+					while (key_length > 1 && !binding->keys[key_length-1])
+						key_length--;
+					if (key_index == key_length) {
+						binding->action.cmd(binding->action.args);
+						key_index = 0;
+						memset(keys, 0, sizeof(keys));
+					}
+				} else {
+					key_index = 0;
+					memset(keys, 0, sizeof(keys));
+					keypress(code);
+				}
+			}
+			if (r == 1) /* no data available on pty's */
+				continue;
+		}
+
+		if (cmdfifo.fd != -1 && FD_ISSET(cmdfifo.fd, &rd))
+			handle_cmdfifo();
+
+		if (bar.fd != -1 && FD_ISSET(bar.fd, &rd))
+			handle_statusbar();
+
+		for (Client *c = clients; c; c = c->next) {
+			if (FD_ISSET(vt_pty_get(c->term), &rd)) {
+				if (vt_process(c->term) < 0 && errno == EIO) {
+					if (c->editor)
+						c->editor_died = true;
+					else
+						c->died = true;
+					continue;
+				}
+			}
+
+			if (c != sel && is_content_visible(c)) {
+				draw_content(c);
+				wnoutrefresh(c->window);
+			}
+		}
+
+		if (is_content_visible(sel)) {
+			draw_content(sel);
+			curs_set(vt_cursor_visible(sel->term));
+			wnoutrefresh(sel->window);
+		}
+	}
+
+	cleanup();
+	return 0;
+}
diff --git a/sys/cmd/dvtm/dvtm.h b/sys/cmd/dvtm/dvtm.h
new file mode 100644
index 0000000..18669fb
--- /dev/null
+++ b/sys/cmd/dvtm/dvtm.h
@@ -0,0 +1,245 @@
+#pragma once
+
+/*
+ * The initial "port" of dwm to curses was done by
+ *
+ * © 2007-2016 Marc André Tanner <mat at brain-dump dot org>
+ * © 2020-???? Nicholas Noll <nbnoll at eml.cc>
+ *
+ * It is highly inspired by the original X11 dwm and
+ * reuses some code of it which is mostly
+ *
+ * © 2006-2007 Anselm R. Garbe <garbeam at gmail dot com>
+ *
+ * See LICENSE for details.
+ */
+
+#include <u.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <wchar.h>
+#include <limits.h>
+#include <libgen.h>
+#include <sys/select.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <curses.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <signal.h>
+#include <locale.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <pwd.h>
+#include <termios.h>
+
+#include "vt.h"
+
+#ifdef PDCURSES
+int ESCDELAY;
+#endif
+
+#ifndef NCURSES_REENTRANT
+# define set_escdelay(d) (ESCDELAY = (d))
+#endif
+
+typedef struct {
+	float mfact;
+	unsigned int nmaster;
+	int history;
+	int w;
+	int h;
+	volatile sig_atomic_t need_resize;
+} Screen;
+
+typedef struct {
+	const char *symbol;
+	void (*arrange)(void);
+} Layout;
+
+typedef struct Client Client;
+struct Client {
+	WINDOW *window;
+	Vt *term;
+	Vt *editor, *app;
+	int editor_fds[2];
+	volatile sig_atomic_t editor_died;
+	const char *cmd;
+	char title[255];
+	int order;
+	pid_t pid;
+	ushort id;
+	ushort x;
+	ushort y;
+	ushort w;
+	ushort h;
+	bool has_title_line;
+	bool minimized;
+	bool urgent;
+	volatile sig_atomic_t died;
+	Client *next;
+	Client *prev;
+	Client *snext;
+	unsigned int tags;
+};
+
+typedef struct {
+	short fg;
+	short bg;
+	short fg256;
+	short bg256;
+	short pair;
+} Color;
+
+typedef struct {
+	const char *title;
+	attr_t attrs;
+	Color *color;
+} ColorRule;
+
+#define ALT(k)      ((k) + (161 - 'a'))
+#if defined CTRL && defined _AIX
+  #undef CTRL
+#endif
+#ifndef CTRL
+  #define CTRL(k)   ((k) & 0x1F)
+#endif
+#define CTRL_ALT(k) ((k) + (129 - 'a'))
+
+#define MAX_ARGS 8
+
+typedef struct {
+	void (*cmd)(const char *args[]);
+	const char *args[3];
+} Action;
+
+#define MAX_KEYS 3
+
+typedef unsigned int KeyCombo[MAX_KEYS];
+
+typedef struct {
+	KeyCombo keys;
+	Action action;
+} KeyBinding;
+
+typedef struct {
+	mmask_t mask;
+	Action action;
+} Button;
+
+typedef struct {
+	const char *name;
+	Action action;
+} Cmd;
+
+enum { BAR_TOP, BAR_BOTTOM, BAR_OFF };
+
+typedef struct {
+	int fd;
+	int pos, lastpos;
+	bool autohide;
+	ushort h;
+	ushort y;
+	char text[512];
+	const char *file;
+} StatusBar;
+
+typedef struct {
+	int fd;
+	const char *file;
+	ushort id;
+} CmdFifo;
+
+typedef struct {
+	char *data;
+	size_t len;
+	size_t size;
+} Register;
+
+typedef struct {
+	char *name;
+	const char *argv[4];
+	bool filter;
+	bool color;
+} Editor;
+
+#define TAGMASK     ((1 << arrlen(tags)) - 1)
+
+#ifdef NDEBUG
+ #define debug(format, args...)
+#else
+ #define debug eprint
+#endif
+
+/* commands for use by keybindings */
+void create(const char *args[]);
+void copymode(const char *args[]);
+void focusn(const char *args[]);
+void focusid(const char *args[]);
+void focusnext(const char *args[]);
+void focusnextnm(const char *args[]);
+void focusprev(const char *args[]);
+void focusprevnm(const char *args[]);
+void focuslast(const char *args[]);
+void focusup(const char *args[]);
+void focusdown(const char *args[]);
+void focusleft(const char *args[]);
+void focusright(const char *args[]);
+void killclient(const char *args[]);
+void paste(const char *args[]);
+void quit(const char *args[]);
+void redraw(const char *args[]);
+void scrollback(const char *args[]);
+void send(const char *args[]);
+void setlayout(const char *args[]);
+void incnmaster(const char *args[]);
+void setmfact(const char *args[]);
+void startup(const char *args[]);
+void tag(const char *args[]);
+void tagid(const char *args[]);
+void togglebar(const char *args[]);
+void togglebarpos(const char *args[]);
+void toggleminimize(const char *args[]);
+void togglemouse(const char *args[]);
+void togglerunall(const char *args[]);
+void toggletag(const char *args[]);
+void toggleview(const char *args[]);
+void viewprevtag(const char *args[]);
+void view(const char *args[]);
+void zoom(const char *args[]);
+
+/* commands for use by mouse bindings */
+void mouse_focus(const char *args[]);
+void mouse_fullscreen(const char *args[]);
+void mouse_minimize(const char *args[]);
+void mouse_zoom(const char *args[]);
+
+/* functions and variables available to layouts via config.h */
+Client* nextvisible(Client *c);
+void focus(Client *c);
+void resize(Client *c, int x, int y, int w, int h);
+
+extern Screen screen;
+extern unsigned int waw, wah, wax, way;
+extern Client *clients;
+extern char *title;
+
+void fibonacci(int s);
+void spiral(void);
+void dwindle(void);
+void fullscreen(void);
+void grid(void);
+void tile(void);
+void tstack(void);
+void bstack(void);
+void vstack(void);
+
+#include "config.h"
diff --git a/sys/cmd/dvtm/dvtm.info b/sys/cmd/dvtm/dvtm.info
new file mode 100644
index 0000000..cafc0fe
--- /dev/null
+++ b/sys/cmd/dvtm/dvtm.info
@@ -0,0 +1,136 @@
+dvtm|dynamic virtual terminal manager,
+	am,
+	eo,
+	mir,
+	msgr,
+	xenl,
+	colors#8,
+	cols#80,
+	it#8,
+	lines#24,
+	ncv@,
+	pairs#64,
+	acsc=``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~,
+	bel=^G,
+	blink=\E[5m,
+	bold=\E[1m,
+	civis=\E[?25l,
+	clear=\E[H\E[2J,
+	cnorm=\E[?25h,
+	cr=^M,
+	csr=\E[%i%p1%d;%p2%dr,
+	cub=\E[%p1%dD,
+	cub1=^H,
+	cud=\E[%p1%dB,
+	cud1=^J,
+	cuf=\E[%p1%dC,
+	cuf1=\E[C,
+	cup=\E[%i%p1%d;%p2%dH,
+	cuu=\E[%p1%dA,
+	cuu1=\E[A,
+	dl=\E[%p1%dM,
+	dl1=\E[M,
+	ed=\E[J,
+	el=\E[K,
+	el1=\E[1K,
+	enacs=\E(B\E)0,
+	home=\E[H,
+	hpa=\E[%i%p1%dG,
+	ht=^I,
+	hts=\EH,
+	ich=\E[%p1%d@,
+	ich1=\E[@,
+	il=\E[%p1%dL,
+	il1=\E[L,
+	ind=^J,
+	is1=\E[?47l\E=\E[?1l,
+	is2=\E[r\E[m\E[2J\E[H\E[?7h\E[?1;3;4;6l\E[4l,
+	kDC=\E[3$,
+	kEND=\E[8$,
+	kHOM=\E[7$,
+	kIC=\E[2$,
+	kLFT=\E[d,
+	kNXT=\E[6$,
+	kPRV=\E[5$,
+	kRIT=\E[c,
+	ka1=\EOw,
+	ka3=\EOy,
+	kb2=\EOu,
+	kbs=\177,
+	kc1=\EOq,
+	kc3=\EOs,
+	kcbt=\E[Z,
+	kcub1=\E[D,
+	kcud1=\E[B,
+	kcuf1=\E[C,
+	kcuu1=\E[A,
+	kdch1=\E[3~,
+	kel=\E[8\^,
+	kend=\E[8~,
+	kent=\EOM,
+	kf0=\E[21~,
+	kf1=\E[11~,
+	kf2=\E[12~,
+	kf3=\E[13~,
+	kf4=\E[14~,
+	kf5=\E[15~,
+	kf6=\E[17~,
+	kf7=\E[18~,
+	kf8=\E[19~,
+	kf9=\E[20~,
+	kf10=\E[21~,
+	kf11=\E[23~,
+	kf12=\E[24~,
+	kf13=\E[25~,
+	kf14=\E[26~,
+	kf15=\E[28~,
+	kf16=\E[29~,
+	kf17=\E[31~,
+	kf18=\E[32~,
+	kf19=\E[33~,
+	kf20=\E[34~,
+	kf21=\E[23$,
+	kf22=\E[24$
+	kfnd=\E[1~,
+	khome=\E[7~,
+	kich1=\E[2~,
+	kind=\E[a,
+	kmous=\E[M,
+	knp=\E[6~,
+	kpp=\E[5~,
+	kri=\E[b,
+	kslt=\E[4~,
+	op=\E[39;49m,
+	rc=\E8,
+	rev=\E[7m,
+	ri=\EM,
+	ritm=\E[23m,
+	rmacs=^O,
+	rmcup=\E[2J\E[?47l\E8,
+	rmir=\E[4l,
+	rmso=\E[27m,
+	rmul=\E[24m,
+	rs1=\E>\E[?1;3;4;5;6l\E[?7h\E[m\E[r\E[2J\E[H,
+	rs2=\E[r\E[m\E[2J\E[H\E[?7h\E[?1;3;4;6l\E[4l\E>\E[?1000l\E[?25h,
+	s0ds=\E(B,
+	s1ds=\E(0,
+	sc=\E7,
+	setab=\E[4%p1%dm,
+	setaf=\E[3%p1%dm,
+	sgr=\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m%?%p9%t\016%e\017%;,
+	sgr0=\E[m\017,
+	sitm=\E[3m,
+	smacs=^N,
+	smcup=\E7\E[?47h,
+	smir=\E[4h,
+	smso=\E[7m,
+	smul=\E[4m,
+	tbc=\E[3g,
+	vpa=\E[%i%p1%dd,
+
+dvtm-256color|dynamic virtual terminal manager with 256 colors,
+	use=dvtm,
+        colors#256,
+        pairs#32767,
+        setab=\E[%?%p1%{8}%<%t4%p1%d%e%p1%{16}%<%t10%p1%{8}%-%d%e48;5;%p1%d%;m,
+        setaf=\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m,
diff --git a/sys/cmd/dvtm/hook.c b/sys/cmd/dvtm/hook.c
new file mode 100644
index 0000000..da3946c
--- /dev/null
+++ b/sys/cmd/dvtm/hook.c
@@ -0,0 +1,346 @@
+#include "dvtm.h"
+
+void 
+fibonacci(int s)
+{
+	unsigned int nx, ny, nw, nnw, nh, nnh, i, n, mod;
+	Client *c;
+
+	for (n = 0, c = nextvisible(clients); c; c = nextvisible(c->next))
+		if (!c->minimized)
+			n++;
+
+	/* initial position and dimensions */
+	nx = wax;
+	ny = way;
+	nw = (n == 1) ? waw : screen.mfact * waw;
+	/* don't waste space dviding by 2 doesn't work for odd numbers
+	 * plus we need space for the border too. therefore set up these
+	 * variables for the next new width/height
+	 */
+	nnw = waw - nw - 1;
+	nnh = nh = wah;
+
+	/* set the mod factor, 2 for dwindle, 4 for spiral */
+	mod = s ? 4 : 2;
+
+	for (i = 0, c = nextvisible(clients); c; c = nextvisible(c->next)) {
+		if (c->minimized)
+			continue;
+		/* dwindle: even case, spiral: case 0 */
+		if (i % mod == 0) {
+			if (i) {
+				if (s) {
+					nh = nnh;
+					ny -= nh;
+				} else {
+					ny += nh;
+					nh = nnh;
+				}
+				/* don't adjust the width for the last client */
+				if (i < n - 1) {
+					nw /= 2;
+					nnw -= nw + 1;
+				}
+				mvaddch(ny, nx - 1, ACS_LTEE);
+			}
+		} else if (i % mod == 1) {	/* dwindle: odd case, spiral: case 1 */
+			nx += nw;
+			mvvline(ny, nx, ACS_VLINE, nh);
+			mvaddch(ny, nx, ACS_TTEE);
+			++nx;
+			nw = nnw;
+			/* don't adjust the height for the last client */
+			if (i < n - 1) {
+				nh /= 2;
+				nnh -= nh;
+			}
+		} else if (i % mod == 2 && s) {	/* spiral: case 2 */
+			ny += nh;
+			nh = nnh;
+			/* don't adjust the width for the last client */
+			if (i < n - 1) {
+				nw /= 2;
+				nnw -= nw + 1;
+				nx += nnw;
+				mvvline(ny, nx, ACS_VLINE, nh);
+				mvaddch(ny, nx, ACS_TTEE);
+				++nx;
+			} else {
+				mvaddch(ny, nx - 1, ACS_LTEE);
+			}
+		} else if (s) {	/* spiral: case 3 */
+			nw = nnw;
+			nx -= nw + 1;	/* border */
+			/* don't adjust the height for the last client */
+			if (i < n - 1) {
+				nh /= 2;
+				nnh -= nh;
+				ny += nnh;
+			}
+			mvaddch(ny, nx - 1, ACS_LTEE);
+		}
+
+		resize(c, nx, ny, nw, nh);
+		i++;
+	}
+}
+
+ 
+void 
+spiral(void)
+{
+	fibonacci(1);
+}
+
+void 
+dwindle(void)
+{
+	fibonacci(0);
+}
+
+void 
+fullscreen(void)
+{
+	for (Client *c = nextvisible(clients); c; c = nextvisible(c->next))
+		resize(c, wax, way, waw, wah);
+}
+
+void 
+grid(void)
+{
+	unsigned int i, n, nx, ny, nw, nh, aw, ah, cols, rows;
+	Client *c;
+
+	for (n = 0, c = nextvisible(clients); c; c = nextvisible(c->next))
+		if (!c->minimized)
+			n++;
+	/* grid dimensions */
+	for (cols = 0; cols <= n / 2; cols++)
+		if (cols * cols >= n)
+			break;
+	rows = (cols && (cols - 1) * cols >= n) ? cols - 1 : cols;
+	/* window geoms (cell height/width) */
+	nh = wah / (rows ? rows : 1);
+	nw = waw / (cols ? cols : 1);
+	for (i = 0, c = nextvisible(clients); c; c = nextvisible(c->next)) {
+		if (c->minimized)
+			continue;
+		/* if there are less clients in the last row than normal adjust the
+		 * split rate to fill the empty space */
+		if (rows > 1 && i == (rows * cols) - cols && (n - i) <= (n % cols))
+			nw = waw / (n - i);
+		nx = (i % cols) * nw + wax;
+		ny = (i / cols) * nh + way;
+		/* adjust height/width of last row/column's windows */
+		ah = (i >= cols * (rows - 1)) ? wah - nh * rows : 0;
+		/* special case if there are less clients in the last row */
+		if (rows > 1 && i == n - 1 && (n - i) < (n % cols))
+			/* (n % cols) == number of clients in the last row */
+			aw = waw - nw * (n % cols);
+		else
+			aw = ((i + 1) % cols == 0) ? waw - nw * cols : 0;
+		if (i % cols) {
+			mvvline(ny, nx, ACS_VLINE, nh + ah);
+			/* if we are on the first row, or on the last one and there are fewer clients
+			 * than normal whose border does not match the line above, print a top tree char
+			 * otherwise a plus sign. */
+			if (i <= cols
+			    || (i >= rows * cols - cols && n % cols
+				&& (cols - (n % cols)) % 2))
+				mvaddch(ny, nx, ACS_TTEE);
+			else
+				mvaddch(ny, nx, ACS_PLUS);
+			nx++, aw--;
+		}
+		resize(c, nx, ny, nw + aw, nh + ah);
+		i++;
+	}
+}
+
+void 
+tile(void)
+{
+	unsigned int i, n, nx, ny, nw, nh, m, mw, mh, th;
+	Client *c;
+
+	for (n = 0, c = nextvisible(clients); c; c = nextvisible(c->next))
+		if (!c->minimized)
+			n++;
+
+	m  = MAX(1, MIN(n, screen.nmaster));
+	mw = n == m ? waw : screen.mfact * waw;
+	mh = wah / m;
+	th = n == m ? 0 : wah / (n - m);
+	nx = wax;
+	ny = way;
+
+	for (i = 0, c = nextvisible(clients); c; c = nextvisible(c->next)) {
+		if (c->minimized)
+			continue;
+		if (i < m) {	/* master */
+			nw = mw;
+			nh = (i < m - 1) ? mh : (way + wah) - ny;
+		} else {	/* tile window */
+			if (i == m) {
+				ny = way;
+				nx += mw;
+				mvvline(ny, nx, ACS_VLINE, wah);
+				mvaddch(ny, nx, ACS_TTEE);
+				nx++;
+				nw = waw - mw -1;
+			}
+			nh = (i < n - 1) ? th : (way + wah) - ny;
+			if (i > m)
+				mvaddch(ny, nx - 1, ACS_LTEE);
+		}
+		resize(c, nx, ny, nw, nh);
+		ny += nh;
+		i++;
+	}
+
+	/* Fill in nmaster intersections */
+	if (n > m) {
+		ny = way + mh;
+		for (i = 1; i < m; i++) {
+			mvaddch(ny, nx - 1, ((ny - 1) % th ? ACS_RTEE : ACS_PLUS));
+			ny += mh;
+		}
+	}
+}
+
+void 
+tstack(void)
+{
+	unsigned int i, n, nx, ny, nw, nh, m, mw, mh, tw;
+	Client *c;
+
+	for (n = 0, c = nextvisible(clients); c; c = nextvisible(c->next))
+		if (!c->minimized)
+			n++;
+
+	m  = MAX(1, MIN(n, screen.nmaster));
+	mh = n == m ? wah : screen.mfact * wah;
+	mw = waw / m;
+	tw = n == m ? 0 : waw / (n - m);
+	nx = wax;
+	ny = way + wah - mh;
+
+	for (i = 0, c = nextvisible(clients); c; c = nextvisible(c->next)) {
+		if (c->minimized)
+			continue;
+		if (i < m) {	/* master */
+			if (i > 0) {
+				mvvline(ny, nx, ACS_VLINE, nh);
+				mvaddch(ny, nx, ACS_TTEE);
+				nx++;
+			}
+			nh = mh;
+			nw = (i < m - 1) ? mw : (wax + waw) - nx;
+		} else {	/* tile window */
+			if (i == m) {
+				nx = wax;
+				ny = way;
+				nh = (way + wah) - ny - mh;
+			}
+			if (i > m) {
+				mvvline(ny, nx, ACS_VLINE, nh);
+				mvaddch(ny, nx, ACS_TTEE);
+				nx++;
+			}
+			nw = (i < n - 1) ? tw : (wax + waw) - nx;
+		}
+		resize(c, nx, ny, nw, nh);
+		nx += nw;
+		i++;
+	}
+}
+
+void 
+bstack(void)
+{
+	unsigned int i, n, nx, ny, nw, nh, m, mw, mh, tw;
+	Client *c;
+
+	for (n = 0, c = nextvisible(clients); c; c = nextvisible(c->next))
+		if (!c->minimized)
+			n++;
+
+	m  = MAX(1, MIN(n, screen.nmaster));
+	mh = n == m ? wah : screen.mfact * wah;
+	mw = waw / m;
+	tw = n == m ? 0 : waw / (n - m);
+	nx = wax;
+	ny = way;
+
+	for (i = 0, c = nextvisible(clients); c; c = nextvisible(c->next)) {
+		if (c->minimized)
+			continue;
+		if (i < m) {	/* master */
+			if (i > 0) {
+				mvvline(ny, nx, ACS_VLINE, nh);
+				mvaddch(ny, nx, ACS_TTEE);
+				nx++;
+			}
+			nh = mh;
+			nw = (i < m - 1) ? mw : (wax + waw) - nx;
+		} else {	/* tile window */
+			if (i == m) {
+				nx = wax;
+				ny += mh;
+				nh = (way + wah) - ny;
+			}
+			if (i > m) {
+				mvvline(ny, nx, ACS_VLINE, nh);
+				mvaddch(ny, nx, ACS_TTEE);
+				nx++;
+			}
+			nw = (i < n - 1) ? tw : (wax + waw) - nx;
+		}
+		resize(c, nx, ny, nw, nh);
+		nx += nw;
+		i++;
+	}
+
+	/* Fill in nmaster intersections */
+	if (n > m) {
+		nx = wax;
+		for (i = 0; i < m; i++) {
+			if (i > 0) {
+				mvaddch(ny, nx, ACS_PLUS);
+				nx++;
+			}
+			nw = (i < m - 1) ? mw : (wax + waw) - nx;
+			nx += nw;
+		}
+	}
+}
+
+/* A vertical stack layout, all windows have the full screen width. */
+void 
+vstack(void)
+{
+	unsigned int i, n, ny, nh, m, mh, th;
+	Client *c;
+
+	for (n = 0, c = nextvisible(clients); c; c = nextvisible(c->next))
+		if (!c->minimized)
+			n++;
+
+	m  = MAX(1, MIN(n, screen.nmaster));
+	mh = (n == m ? wah : screen.mfact * wah);
+	th = n == m ? 0 : (wah - mh) / (n - m);
+	ny = way;
+
+	for (i = 0, c = nextvisible(clients); c; c = nextvisible(c->next)) {
+		if (c->minimized)
+			continue;
+		if (i < m) /* master */
+			nh = (i < m - 1) ? mh / m : (way + mh) - ny;
+		else /* tile window */
+			nh = (i < n - 1) ? th : (way + wah) - ny;
+		resize(c, wax, ny, waw, nh);
+		ny += nh;
+		i++;
+	}
+}
diff --git a/sys/cmd/dvtm/rules.mk b/sys/cmd/dvtm/rules.mk
new file mode 100644
index 0000000..6adfd3c
--- /dev/null
+++ b/sys/cmd/dvtm/rules.mk
@@ -0,0 +1,33 @@
+include share/push.mk
+
+# Local sources
+SRCS_$(d) := \
+$(d)/hook.c \
+$(d)/vt.c \
+$(d)/dvtm.c
+
+# needed for additional editor target
+AUX := $(d)/dvtm-editor.o
+AUX := $(patsubst $(SRC_DIR)/%, $(OBJ_DIR)/%, $(AUX))
+
+DVTM      := $(d)/dvtm 
+DVTM-ED   := $(d)/dvtm-editor
+
+DVTM	  := $(patsubst $(SRC_DIR)/%, $(OBJ_DIR)/%, $(DVTM))
+DVTM-ED	  := $(patsubst $(SRC_DIR)/%, $(OBJ_DIR)/%, $(DVTM-ED))
+
+BINS_$(d) := $(DVTM) $(DVTM-ED)
+
+include share/paths.mk
+
+$(DVTM): TCFLAGS = -D_XOPEN_SOURCE=700 -D_XOPEN_SOURCE_EXTENDED -DNDEBUG
+$(DVTM): TCLIBS  = -lncursesw -lutil -lc
+$(DVTM): $(OBJS_$(d))
+	$(COMPLINK)
+
+$(DVTM-ED): TCFLAGS = -D_XOPEN_SOURCE=700 -D_XOPEN_SOURCE_EXTENDED
+$(DVTM-ED): TCLIBS  = -lncursesw -lutil -lc
+$(DVTM-ED): $(AUX)
+	$(COMPLINK)
+
+include share/pop.mk
diff --git a/sys/cmd/dvtm/vt.c b/sys/cmd/dvtm/vt.c
new file mode 100644
index 0000000..916b8b4
--- /dev/null
+++ b/sys/cmd/dvtm/vt.c
@@ -0,0 +1,1962 @@
+/*
+ * Copyright © 2004 Bruno T. C. de Oliveira
+ * Copyright © 2006 Pierre Habouzit
+ * Copyright © 2008-2016 Marc André Tanner
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <langinfo.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <termios.h>
+#include <wchar.h>
+#if defined(__linux__) || defined(__CYGWIN__)
+# include <pty.h>
+#elif defined(__FreeBSD__) || defined(__DragonFly__)
+# include <libutil.h>
+#elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
+# include <util.h>
+#endif
+
+#include "vt.h"
+
+#ifndef NCURSES_ATTR_SHIFT
+# define NCURSES_ATTR_SHIFT 8
+#endif
+
+#ifndef NCURSES_ACS
+# ifdef PDCURSES
+#  define NCURSES_ACS(c) (acs_map[(unsigned char)(c)])
+# else /* BSD curses */
+#  define NCURSES_ACS(c) (_acs_map[(unsigned char)(c)])
+# endif
+#endif
+
+#ifdef NCURSES_VERSION
+# ifndef NCURSES_EXT_COLORS
+#  define NCURSES_EXT_COLORS 0
+# endif
+# if !NCURSES_EXT_COLORS
+#  define MAX_COLOR_PAIRS MIN(COLOR_PAIRS, 256)
+# endif
+#endif
+#ifndef MAX_COLOR_PAIRS
+# define MAX_COLOR_PAIRS COLOR_PAIRS
+#endif
+
+#if defined _AIX && defined CTRL
+# undef CTRL
+#endif
+#ifndef CTRL
+# define CTRL(k)   ((k) & 0x1F)
+#endif
+
+#define IS_CONTROL(ch) !((ch) & 0xffffff60UL)
+#define MIN(x, y) ((x) < (y) ? (x) : (y))
+#define LENGTH(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+static bool is_utf8, has_default_colors;
+static short color_pairs_reserved, color_pairs_max, color_pair_current;
+static short *color2palette, default_fg, default_bg;
+static char vt_term[32];
+
+typedef struct {
+	wchar_t text;
+	attr_t attr;
+	short fg;
+	short bg;
+} Cell;
+
+typedef struct {
+	Cell *cells;
+	unsigned dirty:1;
+} Row;
+
+/* Buffer holding the current terminal window content (as an array) as well
+ * as the scroll back buffer content (as a circular/ring buffer).
+ *
+ * If new content is added to terminal the view port slides down and the
+ * previously top most line is moved into the scroll back buffer at postion
+ * scroll_index. This index will eventually wrap around and thus overwrite
+ * the oldest lines.
+ *
+ * In the scenerio below a scroll up has been performed. That is 'scroll_above'
+ * lines still lie above the current view port. Further scrolling up will show
+ * them. Similarly 'scroll_below' is the amount of lines below the current
+ * viewport.
+ *
+ * The function buffer_boundary sets the row pointers to the start/end range
+ * of the section delimiting the region before/after the viewport. The functions
+ * buffer_row_{first,last} return the first/last logical row. And
+ * buffer_row_{next,prev} allows to iterate over the logical lines in either
+ * direction.
+ *
+ *                                     scroll back buffer
+ *
+ *                      scroll_buf->+----------------+-----+
+ *                                  |                |     | ^  \
+ *                                  |     before     |     | |  |
+ *    current terminal content      |    viewport    |     | |  |
+ *                                  |                |     |    |
+ *    +----------------+-----+\     |                |     | s   > scroll_above
+ *  ^ |                |  i  | \    |                |  i  | c  |
+ *  | |                |  n  |  \   |                |  n  | r  |
+ *    |                |  v  |   \  |                |  v  | o  |
+ *  r |                |  i  |    \ |                |  i  | l  /
+ *  o |    viewport    |  s  |     >|<- scroll_index |  s  | l  \
+ *  w |                |  i  |    / |                |  i  |    |
+ *  s |                |  b  |   /  |     after      |  b  | s   > scroll_below
+ *    |                |  l  |  /   |    viewport    |  l  | i  |
+ *  v |                |  e  | /    |                |  e  | z  /
+ *    +----------------+-----+/     |     unused     |     | e
+ *     <-    maxcols      ->        |   scroll back  |     |
+ *     <-    cols    ->             |     buffer     |     | |
+ *                                  |                |     | |
+ *                                  |                |     | v
+ *          roll_buf + scroll_size->+----------------+-----+
+ *                                   <-    maxcols       ->
+ *                                   <-    cols    ->
+ */
+typedef struct {
+	Row *lines;            /* array of Row pointers of size 'rows' */
+	Row *curs_row;         /* row on which the cursor currently resides */
+	Row *scroll_buf;       /* a ring buffer holding the scroll back content */
+	Row *scroll_top;       /* row in lines where scrolling region starts */
+	Row *scroll_bot;       /* row in lines where scrolling region ends */
+	bool *tabs;            /* a boolean flag for each column whether it is a tab */
+	int scroll_size;       /* maximal capacity of scroll back buffer (in lines) */
+	int scroll_index;      /* current index into the ring buffer */
+	int scroll_above;      /* number of lines above current viewport */
+	int scroll_below;      /* number of lines below current viewport */
+	int rows, cols;        /* current dimension of buffer */
+	int maxcols;           /* allocated cells (maximal cols over time) */
+	attr_t curattrs, savattrs; /* current and saved attributes for cells */
+	int curs_col;          /* current cursor column (zero based) */
+	int curs_srow, curs_scol; /* saved cursor row/colmn (zero based) */
+	short curfg, curbg;    /* current fore and background colors */
+	short savfg, savbg;    /* saved colors */
+} Buffer;
+
+struct Vt {
+	Buffer buffer_normal;    /* normal screen buffer */
+	Buffer buffer_alternate; /* alternate screen buffer */
+	Buffer *buffer;          /* currently active buffer (one of the above) */
+	attr_t defattrs;         /* attributes to use for normal/empty cells */
+	short deffg, defbg;      /* colors to use for back normal/empty cells (white/black) */
+	int pty;                 /* master side pty file descriptor */
+	pid_t pid;               /* process id of the process running in this vt */
+	/* flags */
+	unsigned seen_input:1;
+	unsigned insert:1;
+	unsigned escaped:1;
+	unsigned curshid:1;
+	unsigned curskeymode:1;
+	unsigned bell:1;
+	unsigned relposmode:1;
+	unsigned mousetrack:1;
+	unsigned graphmode:1;
+	unsigned savgraphmode:1;
+	bool charsets[2];
+	/* buffers and parsing state */
+	char rbuf[BUFSIZ];
+	char ebuf[BUFSIZ];
+	unsigned int rlen, elen;
+	int srow, scol;          /* last known offset to display start row, start column */
+	char title[256];         /* xterm style window title */
+	vt_title_handler_t title_handler; /* hook which is called when title changes */
+	vt_urgent_handler_t urgent_handler; /* hook which is called upon bell */
+	void *data;              /* user supplied data */
+};
+
+static const char *keytable[KEY_MAX+1] = {
+	[KEY_ENTER]     = "\r",
+	['\n']          = "\n",
+	/* for the arrow keys the CSI / SS3 sequences are not stored here
+	 * because they depend on the current cursor terminal mode
+	 */
+	[KEY_UP]        = "A",
+	[KEY_DOWN]      = "B",
+	[KEY_RIGHT]     = "C",
+	[KEY_LEFT]      = "D",
+#ifdef KEY_SUP
+	[KEY_SUP]       = "\e[1;2A",
+#endif
+#ifdef KEY_SDOWN
+	[KEY_SDOWN]     = "\e[1;2B",
+#endif
+	[KEY_SRIGHT]    = "\e[1;2C",
+	[KEY_SLEFT]     = "\e[1;2D",
+	[KEY_BACKSPACE] = "\177",
+	[KEY_IC]        = "\e[2~",
+	[KEY_DC]        = "\e[3~",
+	[KEY_PPAGE]     = "\e[5~",
+	[KEY_NPAGE]     = "\e[6~",
+	[KEY_HOME]      = "\e[7~",
+	[KEY_END]       = "\e[8~",
+	[KEY_BTAB]      = "\e[Z",
+	[KEY_SUSPEND]   = "\x1A",  /* Ctrl+Z gets mapped to this */
+	[KEY_F(1)]      = "\e[11~",
+	[KEY_F(2)]      = "\e[12~",
+	[KEY_F(3)]      = "\e[13~",
+	[KEY_F(4)]      = "\e[14~",
+	[KEY_F(5)]      = "\e[15~",
+	[KEY_F(6)]      = "\e[17~",
+	[KEY_F(7)]      = "\e[18~",
+	[KEY_F(8)]      = "\e[19~",
+	[KEY_F(9)]      = "\e[20~",
+	[KEY_F(10)]     = "\e[21~",
+	[KEY_F(11)]     = "\e[23~",
+	[KEY_F(12)]     = "\e[24~",
+	[KEY_F(13)]     = "\e[23~",
+	[KEY_F(14)]     = "\e[24~",
+	[KEY_F(15)]     = "\e[25~",
+	[KEY_F(16)]     = "\e[26~",
+	[KEY_F(17)]     = "\e[28~",
+	[KEY_F(18)]     = "\e[29~",
+	[KEY_F(19)]     = "\e[31~",
+	[KEY_F(20)]     = "\e[32~",
+	[KEY_F(21)]     = "\e[33~",
+	[KEY_F(22)]     = "\e[34~",
+	[KEY_RESIZE]    = "",
+#ifdef KEY_EVENT
+	[KEY_EVENT]     = "",
+#endif
+};
+
+static void puttab(Vt *t, int count);
+static void process_nonprinting(Vt *t, wchar_t wc);
+static void send_curs(Vt *t);
+
+__attribute__ ((const))
+static attr_t build_attrs(attr_t curattrs)
+{
+	return ((curattrs & ~A_COLOR) | COLOR_PAIR(curattrs & 0xff))
+	    >> NCURSES_ATTR_SHIFT;
+}
+
+static void row_set(Row *row, int start, int len, Buffer *t)
+{
+	Cell cell = {
+		.text = L'\0',
+		.attr = t ? build_attrs(t->curattrs) : 0,
+		.fg = t ? t->curfg : -1,
+		.bg = t ? t->curbg : -1,
+	};
+
+	for (int i = start; i < len + start; i++)
+		row->cells[i] = cell;
+	row->dirty = true;
+}
+
+static void row_roll(Row *start, Row *end, int count)
+{
+	int n = end - start;
+
+	count %= n;
+	if (count < 0)
+		count += n;
+
+	if (count) {
+		char buf[count * sizeof(Row)];
+		memcpy(buf, start, count * sizeof(Row));
+		memmove(start, start + count, (n - count) * sizeof(Row));
+		memcpy(end - count, buf, count * sizeof(Row));
+		for (Row *row = start; row < end; row++)
+			row->dirty = true;
+	}
+}
+
+static void buffer_clear(Buffer *b)
+{
+	Cell cell = {
+		.text = L'\0',
+		.attr = A_NORMAL,
+		.fg = -1,
+		.bg = -1,
+	};
+
+	for (int i = 0; i < b->rows; i++) {
+		Row *row = b->lines + i;
+		for (int j = 0; j < b->cols; j++) {
+			row->cells[j] = cell;
+			row->dirty = true;
+		}
+	}
+}
+
+static void buffer_free(Buffer *b)
+{
+	for (int i = 0; i < b->rows; i++)
+		free(b->lines[i].cells);
+	free(b->lines);
+	for (int i = 0; i < b->scroll_size; i++)
+		free(b->scroll_buf[i].cells);
+	free(b->scroll_buf);
+	free(b->tabs);
+}
+
+static void buffer_scroll(Buffer *b, int s)
+{
+	/* work in screenfuls */
+	int ssz = b->scroll_bot - b->scroll_top;
+	if (s > ssz) {
+		buffer_scroll(b, ssz);
+		buffer_scroll(b, s - ssz);
+		return;
+	}
+	if (s < -ssz) {
+		buffer_scroll(b, -ssz);
+		buffer_scroll(b, s + ssz);
+		return;
+	}
+
+	b->scroll_above += s;
+	if (b->scroll_above >= b->scroll_size)
+		b->scroll_above = b->scroll_size;
+
+	if (s > 0 && b->scroll_size) {
+		for (int i = 0; i < s; i++) {
+			Row tmp = b->scroll_top[i];
+			b->scroll_top[i] = b->scroll_buf[b->scroll_index];
+			b->scroll_buf[b->scroll_index] = tmp;
+
+			b->scroll_index++;
+			if (b->scroll_index == b->scroll_size)
+				b->scroll_index = 0;
+		}
+	}
+	row_roll(b->scroll_top, b->scroll_bot, s);
+	if (s < 0 && b->scroll_size) {
+		for (int i = (-s) - 1; i >= 0; i--) {
+			b->scroll_index--;
+			if (b->scroll_index == -1)
+				b->scroll_index = b->scroll_size - 1;
+
+			Row tmp = b->scroll_top[i];
+			b->scroll_top[i] = b->scroll_buf[b->scroll_index];
+			b->scroll_buf[b->scroll_index] = tmp;
+			b->scroll_top[i].dirty = true;
+		}
+	}
+}
+
+static void buffer_resize(Buffer *b, int rows, int cols)
+{
+	Row *lines = b->lines;
+
+	if (b->rows != rows) {
+		if (b->curs_row >= lines + rows) {
+			/* scroll up instead of simply chopping off bottom */
+			buffer_scroll(b, (b->curs_row - b->lines) - rows + 1);
+		}
+		while (b->rows > rows) {
+			free(lines[b->rows - 1].cells);
+			b->rows--;
+		}
+
+		lines = realloc(lines, sizeof(Row) * rows);
+	}
+
+	if (b->maxcols < cols) {
+		for (int row = 0; row < b->rows; row++) {
+			lines[row].cells = realloc(lines[row].cells, sizeof(Cell) * cols);
+			if (b->cols < cols)
+				row_set(lines + row, b->cols, cols - b->cols, NULL);
+			lines[row].dirty = true;
+		}
+		Row *sbuf = b->scroll_buf;
+		for (int row = 0; row < b->scroll_size; row++) {
+			sbuf[row].cells = realloc(sbuf[row].cells, sizeof(Cell) * cols);
+			if (b->cols < cols)
+				row_set(sbuf + row, b->cols, cols - b->cols, NULL);
+		}
+		b->tabs = realloc(b->tabs, sizeof(*b->tabs) * cols);
+		for (int col = b->cols; col < cols; col++)
+			b->tabs[col] = !(col & 7);
+		b->maxcols = cols;
+		b->cols = cols;
+	} else if (b->cols != cols) {
+		for (int row = 0; row < b->rows; row++)
+			lines[row].dirty = true;
+		b->cols = cols;
+	}
+
+	int deltarows = 0;
+	if (b->rows < rows) {
+		while (b->rows < rows) {
+			lines[b->rows].cells = calloc(b->maxcols, sizeof(Cell));
+			row_set(lines + b->rows, 0, b->maxcols, b);
+			b->rows++;
+		}
+
+		/* prepare for backfill */
+		if (b->curs_row >= b->scroll_bot - 1) {
+			deltarows = b->lines + rows - b->curs_row - 1;
+			if (deltarows > b->scroll_above)
+				deltarows = b->scroll_above;
+		}
+	}
+
+	b->curs_row += lines - b->lines;
+	b->scroll_top = lines;
+	b->scroll_bot = lines + rows;
+	b->lines = lines;
+
+	/* perform backfill */
+	if (deltarows > 0) {
+		buffer_scroll(b, -deltarows);
+		b->curs_row += deltarows;
+	}
+}
+
+static bool buffer_init(Buffer *b, int rows, int cols, int scroll_size)
+{
+	b->curattrs = A_NORMAL;	/* white text over black background */
+	b->curfg = b->curbg = -1;
+	if (scroll_size < 0)
+		scroll_size = 0;
+	if (scroll_size && !(b->scroll_buf = calloc(scroll_size, sizeof(Row))))
+		return false;
+	b->scroll_size = scroll_size;
+	buffer_resize(b, rows, cols);
+	return true;
+}
+
+static void buffer_boundry(Buffer *b, Row **bs, Row **be, Row **as, Row **ae) {
+	if (bs)
+		*bs = NULL;
+	if (be)
+		*be = NULL;
+	if (as)
+		*as = NULL;
+	if (ae)
+		*ae = NULL;
+	if (!b->scroll_size)
+		return;
+
+	if (b->scroll_above) {
+		if (bs)
+			*bs = &b->scroll_buf[(b->scroll_index - b->scroll_above + b->scroll_size) % b->scroll_size];
+		if (be)
+			*be = &b->scroll_buf[(b->scroll_index-1 + b->scroll_size) % b->scroll_size];
+	}
+	if (b->scroll_below) {
+		if (as)
+			*as = &b->scroll_buf[b->scroll_index];
+		if (ae)
+			*ae = &b->scroll_buf[(b->scroll_index + b->scroll_below-1) % b->scroll_size];
+	}
+}
+
+static Row *buffer_row_first(Buffer *b) {
+	Row *bstart;
+	if (!b->scroll_size || !b->scroll_above)
+		return b->lines;
+	buffer_boundry(b, &bstart, NULL, NULL, NULL);
+	return bstart;
+}
+
+static Row *buffer_row_last(Buffer *b) {
+	Row *aend;
+	if (!b->scroll_size || !b->scroll_below)
+		return b->lines + b->rows - 1;
+	buffer_boundry(b, NULL, NULL, NULL, &aend);
+	return aend;
+}
+
+static Row *buffer_row_next(Buffer *b, Row *row)
+{
+	Row *before_start, *before_end, *after_start, *after_end;
+	Row *first = b->lines, *last = b->lines + b->rows - 1;
+
+	if (!row)
+		return NULL;
+
+	buffer_boundry(b, &before_start, &before_end, &after_start, &after_end);
+
+	if (row >= first && row < last)
+		return ++row;
+	if (row == last)
+		return after_start;
+	if (row == before_end)
+		return first;
+	if (row == after_end)
+		return NULL;
+	if (row == &b->scroll_buf[b->scroll_size - 1])
+		return b->scroll_buf;
+	return ++row;
+}
+
+static Row *buffer_row_prev(Buffer *b, Row *row)
+{
+	Row *before_start, *before_end, *after_start, *after_end;
+	Row *first = b->lines, *last = b->lines + b->rows - 1;
+
+	if (!row)
+		return NULL;
+
+	buffer_boundry(b, &before_start, &before_end, &after_start, &after_end);
+
+	if (row > first && row <= last)
+		return --row;
+	if (row == first)
+		return before_end;
+	if (row == before_start)
+		return NULL;
+	if (row == after_start)
+		return last;
+	if (row == b->scroll_buf)
+		return &b->scroll_buf[b->scroll_size - 1];
+	return --row;
+}
+
+static void cursor_clamp(Vt *t)
+{
+	Buffer *b = t->buffer;
+	Row *lines = t->relposmode ? b->scroll_top : b->lines;
+	int rows = t->relposmode ? b->scroll_bot - b->scroll_top : b->rows;
+
+	if (b->curs_row < lines)
+		b->curs_row = lines;
+	if (b->curs_row >= lines + rows)
+		b->curs_row = lines + rows - 1;
+	if (b->curs_col < 0)
+		b->curs_col = 0;
+	if (b->curs_col >= b->cols)
+		b->curs_col = b->cols - 1;
+}
+
+static void cursor_line_down(Vt *t)
+{
+	Buffer *b = t->buffer;
+	row_set(b->curs_row, b->cols, b->maxcols - b->cols, NULL);
+	b->curs_row++;
+	if (b->curs_row < b->scroll_bot)
+		return;
+
+	vt_noscroll(t);
+
+	b->curs_row = b->scroll_bot - 1;
+	buffer_scroll(b, 1);
+	row_set(b->curs_row, 0, b->cols, b);
+}
+
+static void cursor_save(Vt *t)
+{
+	Buffer *b = t->buffer;
+	b->curs_srow = b->curs_row - b->lines;
+	b->curs_scol = b->curs_col;
+}
+
+static void cursor_restore(Vt *t)
+{
+	Buffer *b = t->buffer;
+	b->curs_row = b->lines + b->curs_srow;
+	b->curs_col = b->curs_scol;
+	cursor_clamp(t);
+}
+
+static void attributes_save(Vt *t)
+{
+	Buffer *b = t->buffer;
+	b->savattrs = b->curattrs;
+	b->savfg = b->curfg;
+	b->savbg = b->curbg;
+	t->savgraphmode = t->graphmode;
+}
+
+static void attributes_restore(Vt *t)
+{
+	Buffer *b = t->buffer;
+	b->curattrs = b->savattrs;
+	b->curfg = b->savfg;
+	b->curbg = b->savbg;
+	t->graphmode = t->savgraphmode;
+}
+
+static void new_escape_sequence(Vt *t)
+{
+	t->escaped = true;
+	t->elen = 0;
+	t->ebuf[0] = '\0';
+}
+
+static void cancel_escape_sequence(Vt *t)
+{
+	t->escaped = false;
+	t->elen = 0;
+	t->ebuf[0] = '\0';
+}
+
+static bool is_valid_csi_ender(int c)
+{
+	return (c >= 'a' && c <= 'z')
+	    || (c >= 'A' && c <= 'Z')
+	    || (c == '@' || c == '`');
+}
+
+/* interprets a 'set attribute' (SGR) CSI escape sequence */
+static void interpret_csi_sgr(Vt *t, int param[], int pcount)
+{
+	Buffer *b = t->buffer;
+	if (pcount == 0) {
+		/* special case: reset attributes */
+		b->curattrs = A_NORMAL;
+		b->curfg = b->curbg = -1;
+		return;
+	}
+
+	for (int i = 0; i < pcount; i++) {
+		switch (param[i]) {
+		case 0:
+			b->curattrs = A_NORMAL;
+			b->curfg = b->curbg = -1;
+			break;
+		case 1:
+			b->curattrs |= A_BOLD;
+			break;
+		case 2:
+			b->curattrs |= A_DIM;
+			break;
+#ifdef A_ITALIC
+		case 3:
+			b->curattrs |= A_ITALIC;
+			break;
+#endif
+		case 4:
+			b->curattrs |= A_UNDERLINE;
+			break;
+		case 5:
+			b->curattrs |= A_BLINK;
+			break;
+		case 7:
+			b->curattrs |= A_REVERSE;
+			break;
+		case 8:
+			b->curattrs |= A_INVIS;
+			break;
+		case 22:
+			b->curattrs &= ~(A_BOLD | A_DIM);
+			break;
+#ifdef A_ITALIC
+		case 23:
+			b->curattrs &= ~A_ITALIC;
+			break;
+#endif
+		case 24:
+			b->curattrs &= ~A_UNDERLINE;
+			break;
+		case 25:
+			b->curattrs &= ~A_BLINK;
+			break;
+		case 27:
+			b->curattrs &= ~A_REVERSE;
+			break;
+		case 28:
+			b->curattrs &= ~A_INVIS;
+			break;
+		case 30 ... 37:	/* fg */
+			b->curfg = param[i] - 30;
+			break;
+		case 38:
+			if ((i + 2) < pcount && param[i + 1] == 5) {
+				b->curfg = param[i + 2];
+				i += 2;
+			}
+			break;
+		case 39:
+			b->curfg = -1;
+			break;
+		case 40 ... 47:	/* bg */
+			b->curbg = param[i] - 40;
+			break;
+		case 48:
+			if ((i + 2) < pcount && param[i + 1] == 5) {
+				b->curbg = param[i + 2];
+				i += 2;
+			}
+			break;
+		case 49:
+			b->curbg = -1;
+			break;
+		case 90 ... 97:	/* hi fg */
+			b->curfg = param[i] - 82;
+			break;
+		case 100 ... 107: /* hi bg */
+			b->curbg = param[i] - 92;
+			break;
+		default:
+			break;
+		}
+	}
+}
+
+/* interprets an 'erase display' (ED) escape sequence */
+static void interpret_csi_ed(Vt *t, int param[], int pcount)
+{
+	Row *row, *start, *end;
+	Buffer *b = t->buffer;
+
+	attributes_save(t);
+	b->curattrs = A_NORMAL;
+	b->curfg = b->curbg = -1;
+
+	if (pcount && param[0] == 2) {
+		start = b->lines;
+		end = b->lines + b->rows;
+	} else if (pcount && param[0] == 1) {
+		start = b->lines;
+		end = b->curs_row;
+		row_set(b->curs_row, 0, b->curs_col + 1, b);
+	} else {
+		row_set(b->curs_row, b->curs_col, b->cols - b->curs_col, b);
+		start = b->curs_row + 1;
+		end = b->lines + b->rows;
+	}
+
+	for (row = start; row < end; row++)
+		row_set(row, 0, b->cols, b);
+
+	attributes_restore(t);
+}
+
+/* interprets a 'move cursor' (CUP) escape sequence */
+static void interpret_csi_cup(Vt *t, int param[], int pcount)
+{
+	Buffer *b = t->buffer;
+	Row *lines = t->relposmode ? b->scroll_top : b->lines;
+
+	if (pcount == 0) {
+		b->curs_row = lines;
+		b->curs_col = 0;
+	} else if (pcount == 1) {
+		b->curs_row = lines + param[0] - 1;
+		b->curs_col = 0;
+	} else {
+		b->curs_row = lines + param[0] - 1;
+		b->curs_col = param[1] - 1;
+	}
+
+	cursor_clamp(t);
+}
+
+/* Interpret the 'relative mode' sequences: CUU, CUD, CUF, CUB, CNL,
+ * CPL, CHA, HPR, VPA, VPR, HPA */
+static void interpret_csi_c(Vt *t, char verb, int param[], int pcount)
+{
+	Buffer *b = t->buffer;
+	int n = (pcount && param[0] > 0) ? param[0] : 1;
+
+	switch (verb) {
+	case 'A':
+		b->curs_row -= n;
+		break;
+	case 'B':
+	case 'e':
+		b->curs_row += n;
+		break;
+	case 'C':
+	case 'a':
+		b->curs_col += n;
+		break;
+	case 'D':
+		b->curs_col -= n;
+		break;
+	case 'E':
+		b->curs_row += n;
+		b->curs_col = 0;
+		break;
+	case 'F':
+		b->curs_row -= n;
+		b->curs_col = 0;
+		break;
+	case 'G':
+	case '`':
+		b->curs_col = n - 1;
+		break;
+	case 'd':
+		b->curs_row = b->lines + n - 1;
+		break;
+	}
+
+	cursor_clamp(t);
+}
+
+/* Interpret the 'erase line' escape sequence */
+static void interpret_csi_el(Vt *t, int param[], int pcount)
+{
+	Buffer *b = t->buffer;
+	switch (pcount ? param[0] : 0) {
+	case 1:
+		row_set(b->curs_row, 0, b->curs_col + 1, b);
+		break;
+	case 2:
+		row_set(b->curs_row, 0, b->cols, b);
+		break;
+	default:
+		row_set(b->curs_row, b->curs_col, b->cols - b->curs_col, b);
+		break;
+	}
+}
+
+/* Interpret the 'insert blanks' sequence (ICH) */
+static void interpret_csi_ich(Vt *t, int param[], int pcount)
+{
+	Buffer *b = t->buffer;
+	Row *row = b->curs_row;
+	int n = (pcount && param[0] > 0) ? param[0] : 1;
+
+	if (b->curs_col + n > b->cols)
+		n = b->cols - b->curs_col;
+
+	for (int i = b->cols - 1; i >= b->curs_col + n; i--)
+		row->cells[i] = row->cells[i - n];
+
+	row_set(row, b->curs_col, n, b);
+}
+
+/* Interpret the 'delete chars' sequence (DCH) */
+static void interpret_csi_dch(Vt *t, int param[], int pcount)
+{
+	Buffer *b = t->buffer;
+	Row *row = b->curs_row;
+	int n = (pcount && param[0] > 0) ? param[0] : 1;
+
+	if (b->curs_col + n > b->cols)
+		n = b->cols - b->curs_col;
+
+	for (int i = b->curs_col; i < b->cols - n; i++)
+		row->cells[i] = row->cells[i + n];
+
+	row_set(row, b->cols - n, n, b);
+}
+
+/* Interpret an 'insert line' sequence (IL) */
+static void interpret_csi_il(Vt *t, int param[], int pcount)
+{
+	Buffer *b = t->buffer;
+	int n = (pcount && param[0] > 0) ? param[0] : 1;
+
+	if (b->curs_row + n >= b->scroll_bot) {
+		for (Row *row = b->curs_row; row < b->scroll_bot; row++)
+			row_set(row, 0, b->cols, b);
+	} else {
+		row_roll(b->curs_row, b->scroll_bot, -n);
+		for (Row *row = b->curs_row; row < b->curs_row + n; row++)
+			row_set(row, 0, b->cols, b);
+	}
+}
+
+/* Interpret a 'delete line' sequence (DL) */
+static void interpret_csi_dl(Vt *t, int param[], int pcount)
+{
+	Buffer *b = t->buffer;
+	int n = (pcount && param[0] > 0) ? param[0] : 1;
+
+	if (b->curs_row + n >= b->scroll_bot) {
+		for (Row *row = b->curs_row; row < b->scroll_bot; row++)
+			row_set(row, 0, b->cols, b);
+	} else {
+		row_roll(b->curs_row, b->scroll_bot, n);
+		for (Row *row = b->scroll_bot - n; row < b->scroll_bot; row++)
+			row_set(row, 0, b->cols, b);
+	}
+}
+
+/* Interpret an 'erase characters' (ECH) sequence */
+static void interpret_csi_ech(Vt *t, int param[], int pcount)
+{
+	Buffer *b = t->buffer;
+	int n = (pcount && param[0] > 0) ? param[0] : 1;
+
+	if (b->curs_col + n > b->cols)
+		n = b->cols - b->curs_col;
+
+	row_set(b->curs_row, b->curs_col, n, b);
+}
+
+/* Interpret a 'set scrolling region' (DECSTBM) sequence */
+static void interpret_csi_decstbm(Vt *t, int param[], int pcount)
+{
+	Buffer *b = t->buffer;
+	int new_top, new_bot;
+
+	switch (pcount) {
+	case 0:
+		b->scroll_top = b->lines;
+		b->scroll_bot = b->lines + b->rows;
+		break;
+	case 2:
+		new_top = param[0] - 1;
+		new_bot = param[1];
+
+		/* clamp to bounds */
+		if (new_top < 0)
+			new_top = 0;
+		if (new_top >= b->rows)
+			new_top = b->rows - 1;
+		if (new_bot < 0)
+			new_bot = 0;
+		if (new_bot >= b->rows)
+			new_bot = b->rows;
+
+		/* check for range validity */
+		if (new_top < new_bot) {
+			b->scroll_top = b->lines + new_top;
+			b->scroll_bot = b->lines + new_bot;
+		}
+		break;
+	default:
+		return;	/* malformed */
+	}
+	b->curs_row = b->scroll_top;
+	b->curs_col = 0;
+}
+
+static void interpret_csi_mode(Vt *t, int param[], int pcount, bool set)
+{
+	for (int i = 0; i < pcount; i++) {
+		switch (param[i]) {
+		case 4: /* insert/replace mode */
+			t->insert = set;
+			break;
+		}
+	}
+}
+
+static void interpret_csi_priv_mode(Vt *t, int param[], int pcount, bool set)
+{
+	for (int i = 0; i < pcount; i++) {
+		switch (param[i]) {
+		case 1: /* set application/normal cursor key mode (DECCKM) */
+			t->curskeymode = set;
+			break;
+		case 6: /* set origin to relative/absolute (DECOM) */
+			t->relposmode = set;
+			break;
+		case 25: /* make cursor visible/invisible (DECCM) */
+			t->curshid = !set;
+			break;
+		case 1049: /* combine 1047 + 1048 */
+		case 47:   /* use alternate/normal screen buffer */
+		case 1047:
+			if (!set)
+				buffer_clear(&t->buffer_alternate);
+			t->buffer = set ? &t->buffer_alternate : &t->buffer_normal;
+			vt_dirty(t);
+			if (param[i] != 1049)
+				break;
+			/* fall through */
+		case 1048: /* save/restore cursor */
+			if (set)
+				cursor_save(t);
+			else
+				cursor_restore(t);
+			break;
+		case 1000: /* enable/disable normal mouse tracking */
+			t->mousetrack = set;
+			break;
+		}
+	}
+}
+
+static void interpret_csi(Vt *t)
+{
+	Buffer *b = t->buffer;
+	int csiparam[16];
+	unsigned int param_count = 0;
+	const char *p = t->ebuf + 1;
+	char verb = t->ebuf[t->elen - 1];
+
+	/* parse numeric parameters */
+	for (p += (t->ebuf[1] == '?'); *p; p++) {
+		if (IS_CONTROL(*p)) {
+			process_nonprinting(t, *p);
+		} else if (*p == ';') {
+			if (param_count >= LENGTH(csiparam))
+				return;	/* too long! */
+			csiparam[param_count++] = 0;
+		} else if (isdigit((unsigned char)*p)) {
+			if (param_count == 0)
+				csiparam[param_count++] = 0;
+			csiparam[param_count - 1] *= 10;
+			csiparam[param_count - 1] += *p - '0';
+		}
+	}
+
+	if (t->ebuf[1] == '?') {
+		switch (verb) {
+		case 'h':
+		case 'l': /* private set/reset mode */
+			interpret_csi_priv_mode(t, csiparam, param_count, verb == 'h');
+			break;
+		}
+		return;
+	}
+
+	/* delegate handling depending on command character (verb) */
+	switch (verb) {
+	case 'h':
+	case 'l': /* set/reset mode */
+		interpret_csi_mode(t, csiparam, param_count, verb == 'h');
+		break;
+	case 'm': /* set attribute */
+		interpret_csi_sgr(t, csiparam, param_count);
+		break;
+	case 'J': /* erase display */
+		interpret_csi_ed(t, csiparam, param_count);
+		break;
+	case 'H':
+	case 'f': /* move cursor */
+		interpret_csi_cup(t, csiparam, param_count);
+		break;
+	case 'A':
+	case 'B':
+	case 'C':
+	case 'D':
+	case 'E':
+	case 'F':
+	case 'G':
+	case 'e':
+	case 'a':
+	case 'd':
+	case '`': /* relative move */
+		interpret_csi_c(t, verb, csiparam, param_count);
+		break;
+	case 'K': /* erase line */
+		interpret_csi_el(t, csiparam, param_count);
+		break;
+	case '@': /* insert characters */
+		interpret_csi_ich(t, csiparam, param_count);
+		break;
+	case 'P': /* delete characters */
+		interpret_csi_dch(t, csiparam, param_count);
+		break;
+	case 'L': /* insert lines */
+		interpret_csi_il(t, csiparam, param_count);
+		break;
+	case 'M': /* delete lines */
+		interpret_csi_dl(t, csiparam, param_count);
+		break;
+	case 'X': /* erase chars */
+		interpret_csi_ech(t, csiparam, param_count);
+		break;
+	case 'S': /* SU: scroll up */
+		vt_scroll(t, param_count ? -csiparam[0] : -1);
+		break;
+	case 'T': /* SD: scroll down */
+		vt_scroll(t, param_count ? csiparam[0] : 1);
+		break;
+	case 'Z': /* CBT: cursor backward tabulation */
+		puttab(t, param_count ? -csiparam[0] : -1);
+		break;
+	case 'g': /* TBC: tabulation clear */
+		switch (param_count ? csiparam[0] : 0) {
+		case 0:
+			b->tabs[b->curs_col] = false;
+			break;
+		case 3:
+			memset(b->tabs, 0, sizeof(*b->tabs) * b->maxcols);
+			break;
+		}
+		break;
+	case 'r': /* set scrolling region */
+		interpret_csi_decstbm(t, csiparam, param_count);
+		break;
+	case 's': /* save cursor location */
+		cursor_save(t);
+		break;
+	case 'u': /* restore cursor location */
+		cursor_restore(t);
+		break;
+	case 'n': /* query cursor location */
+		if (param_count == 1 && csiparam[0] == 6)
+			send_curs(t);
+		break;
+	default:
+		break;
+	}
+}
+
+/* Interpret an 'index' (IND) sequence */
+static void interpret_csi_ind(Vt *t)
+{
+	Buffer *b = t->buffer;
+	if (b->curs_row < b->lines + b->rows - 1)
+		b->curs_row++;
+}
+
+/* Interpret a 'reverse index' (RI) sequence */
+static void interpret_csi_ri(Vt *t)
+{
+	Buffer *b = t->buffer;
+	if (b->curs_row > b->scroll_top)
+		b->curs_row--;
+	else {
+		row_roll(b->scroll_top, b->scroll_bot, -1);
+		row_set(b->scroll_top, 0, b->cols, b);
+	}
+}
+
+/* Interpret a 'next line' (NEL) sequence */
+static void interpret_csi_nel(Vt *t)
+{
+	Buffer *b = t->buffer;
+	if (b->curs_row < b->lines + b->rows - 1) {
+		b->curs_row++;
+		b->curs_col = 0;
+	}
+}
+
+/* Interpret a 'select character set' (SCS) sequence */
+static void interpret_csi_scs(Vt *t)
+{
+	/* ESC ( sets G0, ESC ) sets G1 */
+	t->charsets[!!(t->ebuf[0] == ')')] = (t->ebuf[1] == '0');
+	t->graphmode = t->charsets[0];
+}
+
+/* Interpret an 'operating system command' (OSC) sequence */
+static void interpret_osc(Vt *t)
+{
+	/* ESC ] command ; data BEL
+	 * ESC ] command ; data ESC \\
+	 * Note that BEL or ESC \\ have already been replaced with NUL.
+	 */
+	char *data = NULL;
+	int command = strtoul(t->ebuf + 1, &data, 10);
+	if (data && *data == ';') {
+		switch (command) {
+		case 0: /* icon name and window title */
+		case 2: /* window title */
+			if (t->title_handler)
+				t->title_handler(t, data+1);
+			break;
+		case 1: /* icon name */
+			break;
+		default:
+#ifndef NDEBUG
+			fprintf(stderr, "unknown OSC command: %d\n", command);
+#endif
+			break;
+		}
+	}
+}
+
+static void try_interpret_escape_seq(Vt *t)
+{
+	char lastchar = t->ebuf[t->elen - 1];
+
+	if (!*t->ebuf)
+		return;
+
+	switch (*t->ebuf) {
+	case '#': /* ignore DECDHL, DECSWL, DECDWL, DECHCP, DECFPP */
+		if (t->elen == 2) {
+			if (lastchar == '8') { /* DECALN */
+				interpret_csi_ed(t, (int []){ 2 }, 1);
+				goto handled;
+			}
+			goto cancel;
+		}
+		break;
+	case '(':
+	case ')':
+		if (t->elen == 2) {
+			interpret_csi_scs(t);
+			goto handled;
+		}
+		break;
+	case ']': /* OSC - operating system command */
+		if (lastchar == '\a' ||
+		   (lastchar == '\\' && t->elen >= 2 && t->ebuf[t->elen - 2] == '\e')) {
+			t->elen -= lastchar == '\a' ? 1 : 2;
+			t->ebuf[t->elen] = '\0';
+			interpret_osc(t);
+			goto handled;
+		}
+		break;
+	case '[': /* CSI - control sequence introducer */
+		if (is_valid_csi_ender(lastchar)) {
+			interpret_csi(t);
+			goto handled;
+		}
+		break;
+	case '7': /* DECSC: save cursor and attributes */
+		attributes_save(t);
+		cursor_save(t);
+		goto handled;
+	case '8': /* DECRC: restore cursor and attributes */
+		attributes_restore(t);
+		cursor_restore(t);
+		goto handled;
+	case 'D': /* IND: index */
+		interpret_csi_ind(t);
+		goto handled;
+	case 'M': /* RI: reverse index */
+		interpret_csi_ri(t);
+		goto handled;
+	case 'E': /* NEL: next line */
+		interpret_csi_nel(t);
+		goto handled;
+	case 'H': /* HTS: horizontal tab set */
+		t->buffer->tabs[t->buffer->curs_col] = true;
+		goto handled;
+	default:
+		goto cancel;
+	}
+
+	if (t->elen + 1 >= sizeof(t->ebuf)) {
+cancel:
+#ifndef NDEBUG
+		fprintf(stderr, "cancelled: \\033");
+		for (unsigned int i = 0; i < t->elen; i++) {
+			if (isprint(t->ebuf[i])) {
+				fputc(t->ebuf[i], stderr);
+			} else {
+				fprintf(stderr, "\\%03o", t->ebuf[i]);
+			}
+		}
+		fputc('\n', stderr);
+#endif
+handled:
+		cancel_escape_sequence(t);
+	}
+}
+
+static void puttab(Vt *t, int count)
+{
+	Buffer *b = t->buffer;
+	int direction = count >= 0 ? 1 : -1;
+	for (int col = b->curs_col + direction; count; col += direction) {
+		if (col < 0) {
+			b->curs_col = 0;
+			break;
+		}
+		if (col >= b->cols) {
+			b->curs_col = b->cols - 1;
+			break;
+		}
+		if (b->tabs[col]) {
+			b->curs_col = col;
+			count -= direction;
+		}
+	}
+}
+
+static void process_nonprinting(Vt *t, wchar_t wc)
+{
+	Buffer *b = t->buffer;
+	switch (wc) {
+	case '\e': /* ESC */
+		new_escape_sequence(t);
+		break;
+	case '\a': /* BEL */
+		if (t->urgent_handler)
+			t->urgent_handler(t);
+		break;
+	case '\b': /* BS */
+		if (b->curs_col > 0)
+			b->curs_col--;
+		break;
+	case '\t': /* HT */
+		puttab(t, 1);
+		break;
+	case '\r': /* CR */
+		b->curs_col = 0;
+		break;
+	case '\v': /* VT */
+	case '\f': /* FF */
+	case '\n': /* LF */
+		cursor_line_down(t);
+		break;
+	case '\016': /* SO: shift out, invoke the G1 character set */
+		t->graphmode = t->charsets[1];
+		break;
+	case '\017': /* SI: shift in, invoke the G0 character set */
+		t->graphmode = t->charsets[0];
+		break;
+	}
+}
+
+static void is_utf8_locale(void)
+{
+	const char *cset = nl_langinfo(CODESET);
+	if (!cset)
+		cset = "ANSI_X3.4-1968";
+	is_utf8 = !strcmp(cset, "UTF-8");
+}
+
+static wchar_t get_vt100_graphic(char c)
+{
+	static char vt100_acs[] = "`afgjklmnopqrstuvwxyz{|}~";
+
+	/*
+	 * 5f-7e standard vt100
+	 * 40-5e rxvt extension for extra curses acs chars
+	 */
+	static uint16_t const vt100_utf8[62] = {
+		        0x2191, 0x2193, 0x2192, 0x2190, 0x2588, 0x259a, 0x2603, // 41-47
+		     0,      0,      0,      0,      0,      0,      0,      0, // 48-4f
+		     0,      0,      0,      0,      0,      0,      0,      0, // 50-57
+		     0,      0,      0,      0,      0,      0,      0, 0x0020, // 58-5f
+		0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1, // 60-67
+		0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba, // 68-6f
+		0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c, // 70-77
+		0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7,         // 78-7e
+	};
+
+	if (is_utf8)
+		return vt100_utf8[c - 0x41];
+	else if (strchr(vt100_acs, c))
+		return NCURSES_ACS(c);
+	return '\0';
+}
+
+static void put_wc(Vt *t, wchar_t wc)
+{
+	int width = 0;
+
+	if (!t->seen_input) {
+		t->seen_input = 1;
+		kill(-t->pid, SIGWINCH);
+	}
+
+	if (t->escaped) {
+		if (t->elen + 1 < sizeof(t->ebuf)) {
+			t->ebuf[t->elen] = wc;
+			t->ebuf[++t->elen] = '\0';
+			try_interpret_escape_seq(t);
+		} else {
+			cancel_escape_sequence(t);
+		}
+	} else if (IS_CONTROL(wc)) {
+		process_nonprinting(t, wc);
+	} else {
+		if (t->graphmode) {
+			if (wc >= 0x41 && wc <= 0x7e) {
+				wchar_t gc = get_vt100_graphic(wc);
+				if (gc)
+					wc = gc;
+			}
+			width = 1;
+		} else if ((width = wcwidth(wc)) < 1) {
+			width = 1;
+		}
+		Buffer *b = t->buffer;
+		Cell blank_cell = { L'\0', build_attrs(b->curattrs), b->curfg, b->curbg };
+		if (width == 2 && b->curs_col == b->cols - 1) {
+			b->curs_row->cells[b->curs_col++] = blank_cell;
+			b->curs_row->dirty = true;
+		}
+
+		if (b->curs_col >= b->cols) {
+			b->curs_col = 0;
+			cursor_line_down(t);
+		}
+
+		if (t->insert) {
+			Cell *src = b->curs_row->cells + b->curs_col;
+			Cell *dest = src + width;
+			size_t len = b->cols - b->curs_col - width;
+			memmove(dest, src, len * sizeof *dest);
+		}
+
+		b->curs_row->cells[b->curs_col] = blank_cell;
+		b->curs_row->cells[b->curs_col++].text = wc;
+		b->curs_row->dirty = true;
+		if (width == 2)
+			b->curs_row->cells[b->curs_col++] = blank_cell;
+	}
+}
+
+int vt_process(Vt *t)
+{
+	int res;
+	unsigned int pos = 0;
+	mbstate_t ps;
+	memset(&ps, 0, sizeof(ps));
+
+	if (t->pty < 0) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	res = read(t->pty, t->rbuf + t->rlen, sizeof(t->rbuf) - t->rlen);
+	if (res < 0)
+		return -1;
+
+	t->rlen += res;
+	while (pos < t->rlen) {
+		wchar_t wc;
+		ssize_t len;
+
+		len = (ssize_t)mbrtowc(&wc, t->rbuf + pos, t->rlen - pos, &ps);
+		if (len == -2) {
+			t->rlen -= pos;
+			memmove(t->rbuf, t->rbuf + pos, t->rlen);
+			return 0;
+		}
+
+		if (len == -1) {
+			len = 1;
+			wc = t->rbuf[pos];
+		}
+
+		pos += len ? len : 1;
+		put_wc(t, wc);
+	}
+
+	t->rlen -= pos;
+	memmove(t->rbuf, t->rbuf + pos, t->rlen);
+	return 0;
+}
+
+void vt_default_colors_set(Vt *t, attr_t attrs, short fg, short bg)
+{
+	t->defattrs = attrs;
+	t->deffg = fg;
+	t->defbg = bg;
+}
+
+Vt *vt_create(int rows, int cols, int scroll_size)
+{
+	if (rows <= 0 || cols <= 0)
+		return NULL;
+
+	Vt *t = calloc(1, sizeof(Vt));
+	if (!t)
+		return NULL;
+
+	t->pty = -1;
+	t->deffg = t->defbg = -1;
+	t->buffer = &t->buffer_normal;
+
+	if (!buffer_init(&t->buffer_normal, rows, cols, scroll_size) ||
+	    !buffer_init(&t->buffer_alternate, rows, cols, 0)) {
+		free(t);
+		return NULL;
+	}
+
+	return t;
+}
+
+void vt_resize(Vt *t, int rows, int cols)
+{
+	struct winsize ws = { .ws_row = rows, .ws_col = cols };
+
+	if (rows <= 0 || cols <= 0)
+		return;
+
+	vt_noscroll(t);
+	buffer_resize(&t->buffer_normal, rows, cols);
+	buffer_resize(&t->buffer_alternate, rows, cols);
+	cursor_clamp(t);
+	ioctl(t->pty, TIOCSWINSZ, &ws);
+	kill(-t->pid, SIGWINCH);
+}
+
+void vt_destroy(Vt *t)
+{
+	if (!t)
+		return;
+	buffer_free(&t->buffer_normal);
+	buffer_free(&t->buffer_alternate);
+	close(t->pty);
+	free(t);
+}
+
+void vt_dirty(Vt *t)
+{
+	Buffer *b = t->buffer;
+	for (Row *row = b->lines, *end = row + b->rows; row < end; row++)
+		row->dirty = true;
+}
+
+void vt_draw(Vt *t, WINDOW *win, int srow, int scol)
+{
+	Buffer *b = t->buffer;
+
+	if (srow != t->srow || scol != t->scol) {
+		vt_dirty(t);
+		t->srow = srow;
+		t->scol = scol;
+	}
+
+	for (int i = 0; i < b->rows; i++) {
+		Row *row = b->lines + i;
+
+		if (!row->dirty)
+			continue;
+
+		wmove(win, srow + i, scol);
+		Cell *cell = NULL;
+		for (int j = 0; j < b->cols; j++) {
+			Cell *prev_cell = cell;
+			cell = row->cells + j;
+			if (!prev_cell || cell->attr != prev_cell->attr
+			    || cell->fg != prev_cell->fg
+			    || cell->bg != prev_cell->bg) {
+				if (cell->attr == A_NORMAL)
+					cell->attr = t->defattrs;
+				if (cell->fg == -1)
+					cell->fg = t->deffg;
+				if (cell->bg == -1)
+					cell->bg = t->defbg;
+				wattrset(win, cell->attr << NCURSES_ATTR_SHIFT);
+				wcolor_set(win, vt_color_get(t, cell->fg, cell->bg), NULL);
+			}
+
+			if (is_utf8 && cell->text >= 128) {
+				char buf[MB_CUR_MAX + 1];
+				size_t len = wcrtomb(buf, cell->text, NULL);
+				if (len > 0) {
+					waddnstr(win, buf, len);
+					if (wcwidth(cell->text) > 1)
+						j++;
+				}
+			} else {
+				waddch(win, cell->text > ' ' ? cell->text : ' ');
+			}
+		}
+
+		int x, y;
+		getyx(win, y, x);
+		(void)y;
+		if (x && x < b->cols - 1)
+			whline(win, ' ', b->cols - x);
+
+		row->dirty = false;
+	}
+
+	wmove(win, srow + b->curs_row - b->lines, scol + b->curs_col);
+}
+
+void vt_scroll(Vt *t, int rows)
+{
+	Buffer *b = t->buffer;
+	if (!b->scroll_size)
+		return;
+	if (rows < 0) { /* scroll back */
+		if (rows < -b->scroll_above)
+			rows = -b->scroll_above;
+	} else { /* scroll forward */
+		if (rows > b->scroll_below)
+			rows = b->scroll_below;
+	}
+	buffer_scroll(b, rows);
+	b->scroll_below -= rows;
+}
+
+void vt_noscroll(Vt *t)
+{
+	int scroll_below = t->buffer->scroll_below;
+	if (scroll_below)
+		vt_scroll(t, scroll_below);
+}
+
+pid_t vt_forkpty(Vt *t, const char *p, const char *argv[], const char *cwd, const char *env[], int *to, int *from)
+{
+	int vt2ed[2], ed2vt[2];
+	struct winsize ws;
+	ws.ws_row = t->buffer->rows;
+	ws.ws_col = t->buffer->cols;
+	ws.ws_xpixel = ws.ws_ypixel = 0;
+
+	if (to && pipe(vt2ed)) {
+		*to = -1;
+		to = NULL;
+	}
+	if (from && pipe(ed2vt)) {
+		*from = -1;
+		from = NULL;
+	}
+
+	pid_t pid = forkpty(&t->pty, NULL, NULL, &ws);
+	if (pid < 0)
+		return -1;
+
+	if (pid == 0) {
+		setsid();
+
+		sigset_t emptyset;
+		sigemptyset(&emptyset);
+		sigprocmask(SIG_SETMASK, &emptyset, NULL);
+
+		if (to) {
+			close(vt2ed[1]);
+			dup2(vt2ed[0], STDIN_FILENO);
+			close(vt2ed[0]);
+		}
+
+		if (from) {
+			close(ed2vt[0]);
+			dup2(ed2vt[1], STDOUT_FILENO);
+			close(ed2vt[1]);
+		}
+
+		int maxfd = sysconf(_SC_OPEN_MAX);
+		for (int fd = 3; fd < maxfd; fd++)
+			if (close(fd) == -1 && errno == EBADF)
+				break;
+
+		for (const char **envp = env; envp && envp[0]; envp += 2)
+			setenv(envp[0], envp[1], 1);
+		setenv("TERM", vt_term, 1);
+
+		if (cwd)
+			chdir(cwd);
+
+		execvp(p, (char *const *)argv);
+		fprintf(stderr, "\nexecv() failed.\nCommand: '%s'\n", argv[0]);
+		exit(1);
+	}
+
+	if (to) {
+		close(vt2ed[0]);
+		*to = vt2ed[1];
+	}
+
+	if (from) {
+		close(ed2vt[1]);
+		*from = ed2vt[0];
+	}
+
+	return t->pid = pid;
+}
+
+int vt_pty_get(Vt *t)
+{
+	return t->pty;
+}
+
+ssize_t vt_write(Vt *t, const char *buf, size_t len)
+{
+	ssize_t ret = len;
+
+	while (len > 0) {
+		ssize_t res = write(t->pty, buf, len);
+		if (res < 0) {
+			if (errno != EAGAIN && errno != EINTR)
+				return -1;
+			continue;
+		}
+		buf += res;
+		len -= res;
+	}
+
+	return ret;
+}
+
+static void send_curs(Vt *t)
+{
+	Buffer *b = t->buffer;
+	char keyseq[16];
+	snprintf(keyseq, sizeof keyseq, "\e[%d;%dR", (int)(b->curs_row - b->lines), b->curs_col);
+	vt_write(t, keyseq, strlen(keyseq));
+}
+
+void vt_keypress(Vt *t, int keycode)
+{
+	vt_noscroll(t);
+
+	if (keycode >= 0 && keycode <= KEY_MAX && keytable[keycode]) {
+		switch (keycode) {
+		case KEY_UP:
+		case KEY_DOWN:
+		case KEY_RIGHT:
+		case KEY_LEFT: {
+			char keyseq[3] = { '\e', (t->curskeymode ? 'O' : '['), keytable[keycode][0] };
+			vt_write(t, keyseq, sizeof keyseq);
+			break;
+		}
+		default:
+			vt_write(t, keytable[keycode], strlen(keytable[keycode]));
+		}
+	} else if (keycode <= UCHAR_MAX) {
+		char c = keycode;
+		vt_write(t, &c, 1);
+	} else {
+#ifndef NDEBUG
+		fprintf(stderr, "unhandled key %#o\n", keycode);
+#endif
+	}
+}
+
+void vt_mouse(Vt *t, int x, int y, mmask_t mask)
+{
+#ifdef NCURSES_MOUSE_VERSION
+	char seq[6] = { '\e', '[', 'M' }, state = 0, button = 0;
+
+	if (!t->mousetrack)
+		return;
+
+	if (mask & (BUTTON1_PRESSED | BUTTON1_CLICKED))
+		button = 0;
+	else if (mask & (BUTTON2_PRESSED | BUTTON2_CLICKED))
+		button = 1;
+	else if (mask & (BUTTON3_PRESSED | BUTTON3_CLICKED))
+		button = 2;
+	else if (mask & (BUTTON1_RELEASED | BUTTON2_RELEASED | BUTTON3_RELEASED))
+		button = 3;
+
+	if (mask & BUTTON_SHIFT)
+		state |= 4;
+	if (mask & BUTTON_ALT)
+		state |= 8;
+	if (mask & BUTTON_CTRL)
+		state |= 16;
+
+	seq[3] = 32 + button + state;
+	seq[4] = 32 + x;
+	seq[5] = 32 + y;
+
+	vt_write(t, seq, sizeof seq);
+
+	if (mask & (BUTTON1_CLICKED | BUTTON2_CLICKED | BUTTON3_CLICKED)) {
+		/* send a button release event */
+		button = 3;
+		seq[3] = 32 + button + state;
+		vt_write(t, seq, sizeof seq);
+	}
+#endif /* NCURSES_MOUSE_VERSION */
+}
+
+static unsigned int color_hash(short fg, short bg)
+{
+	if (fg == -1)
+		fg = COLORS;
+	if (bg == -1)
+		bg = COLORS + 1;
+	return fg * (COLORS + 2) + bg;
+}
+
+short vt_color_get(Vt *t, short fg, short bg)
+{
+	if (fg >= COLORS)
+		fg = (t ? t->deffg : default_fg);
+	if (bg >= COLORS)
+		bg = (t ? t->defbg : default_bg);
+
+	if (!has_default_colors) {
+		if (fg == -1)
+			fg = (t && t->deffg != -1 ? t->deffg : default_fg);
+		if (bg == -1)
+			bg = (t && t->defbg != -1 ? t->defbg : default_bg);
+	}
+
+	if (!color2palette || (fg == -1 && bg == -1))
+		return 0;
+	unsigned int index = color_hash(fg, bg);
+	if (color2palette[index] == 0) {
+		short oldfg, oldbg;
+		for (;;) {
+			if (++color_pair_current >= color_pairs_max)
+				color_pair_current = color_pairs_reserved + 1;
+			pair_content(color_pair_current, &oldfg, &oldbg);
+			unsigned int old_index = color_hash(oldfg, oldbg);
+			if (color2palette[old_index] >= 0) {
+				if (init_pair(color_pair_current, fg, bg) == OK) {
+					color2palette[old_index] = 0;
+					color2palette[index] = color_pair_current;
+				}
+				break;
+			}
+		}
+	}
+
+	short color_pair = color2palette[index];
+	return color_pair >= 0 ? color_pair : -color_pair;
+}
+
+short vt_color_reserve(short fg, short bg)
+{
+	if (!color2palette || fg >= COLORS || bg >= COLORS)
+		return 0;
+	if (!has_default_colors && fg == -1)
+		fg = default_fg;
+	if (!has_default_colors && bg == -1)
+		bg = default_bg;
+	if (fg == -1 && bg == -1)
+		return 0;
+	unsigned int index = color_hash(fg, bg);
+	if (color2palette[index] >= 0) {
+		if (init_pair(color_pairs_reserved + 1, fg, bg) == OK)
+			color2palette[index] = -(++color_pairs_reserved);
+	}
+	short color_pair = color2palette[index];
+	return color_pair >= 0 ? color_pair : -color_pair;
+}
+
+static void init_colors(void)
+{
+	pair_content(0, &default_fg, &default_bg);
+	if (default_fg == -1)
+		default_fg = COLOR_WHITE;
+	if (default_bg == -1)
+		default_bg = COLOR_BLACK;
+	has_default_colors = (use_default_colors() == OK);
+	color_pairs_max = MIN(MAX_COLOR_PAIRS, SHRT_MAX);
+	if (COLORS)
+		color2palette = calloc((COLORS + 2) * (COLORS + 2), sizeof(short));
+	/*
+	 * XXX: On undefined color-pairs NetBSD curses pair_content() set fg
+	 *      and bg to default colors while ncurses set them respectively to
+	 *      0 and 0. Initialize all color-pairs in order to have consistent
+	 *      behaviour despite the implementation used.
+	 */
+	for (short i = 1; i < color_pairs_max; i++)
+		init_pair(i, 0, 0);
+	vt_color_reserve(COLOR_WHITE, COLOR_BLACK);
+}
+
+void vt_init(void)
+{
+	init_colors();
+	is_utf8_locale();
+	char *term = getenv("DVTM_TERM");
+	if (!term)
+		term = "dvtm";
+	snprintf(vt_term, sizeof vt_term, "%s%s", term, COLORS >= 256 ? "-256color" : "");
+}
+
+void vt_keytable_set(const char * const keytable_overlay[], int count)
+{
+	for (int k = 0; k < count && k < KEY_MAX; k++) {
+		const char *keyseq = keytable_overlay[k];
+		if (keyseq)
+			keytable[k] = keyseq;
+	}
+}
+
+void vt_shutdown(void)
+{
+	free(color2palette);
+}
+
+void vt_title_handler_set(Vt *t, vt_title_handler_t handler)
+{
+	t->title_handler = handler;
+}
+
+void vt_urgent_handler_set(Vt *t, vt_urgent_handler_t handler)
+{
+	t->urgent_handler = handler;
+}
+
+void vt_data_set(Vt *t, void *data)
+{
+	t->data = data;
+}
+
+void *vt_data_get(Vt *t)
+{
+	return t->data;
+}
+
+bool vt_cursor_visible(Vt *t)
+{
+	return t->buffer->scroll_below ? false : !t->curshid;
+}
+
+pid_t vt_pid_get(Vt *t)
+{
+	return t->pid;
+}
+
+size_t vt_content_get(Vt *t, char **buf, bool colored)
+{
+	Buffer *b = t->buffer;
+	int lines = b->scroll_above + b->scroll_below + b->rows + 1;
+	size_t size = lines * ((b->cols + 1) * ((colored ? 64 : 0) + MB_CUR_MAX));
+	mbstate_t ps;
+	memset(&ps, 0, sizeof(ps));
+
+	if (!(*buf = malloc(size)))
+		return 0;
+
+	char *s = *buf;
+	Cell *prev_cell = NULL;
+
+	for (Row *row = buffer_row_first(b); row; row = buffer_row_next(b, row)) {
+		size_t len = 0;
+		char *last_non_space = s;
+		for (int col = 0; col < b->cols; col++) {
+			Cell *cell = row->cells + col;
+			if (colored) {
+				int esclen = 0;
+				if (!prev_cell || cell->attr != prev_cell->attr) {
+					attr_t attr = cell->attr << NCURSES_ATTR_SHIFT;
+					esclen = sprintf(s, "\033[0%s%s%s%s%s%sm",
+						attr & A_BOLD ? ";1" : "",
+						attr & A_DIM ? ";2" : "",
+						attr & A_UNDERLINE ? ";4" : "",
+						attr & A_BLINK ? ";5" : "",
+						attr & A_REVERSE ? ";7" : "",
+						attr & A_INVIS ? ";8" : "");
+					if (esclen > 0)
+						s += esclen;
+				}
+				if (!prev_cell || cell->fg != prev_cell->fg || cell->attr != prev_cell->attr) {
+					if (cell->fg == -1)
+						esclen = sprintf(s, "\033[39m");
+					else
+						esclen = sprintf(s, "\033[38;5;%dm", cell->fg);
+					if (esclen > 0)
+						s += esclen;
+				}
+				if (!prev_cell || cell->bg != prev_cell->bg || cell->attr != prev_cell->attr) {
+					if (cell->bg == -1)
+						esclen = sprintf(s, "\033[49m");
+					else
+						esclen = sprintf(s, "\033[48;5;%dm", cell->bg);
+					if (esclen > 0)
+						s += esclen;
+				}
+				prev_cell = cell;
+			}
+			if (cell->text) {
+				len = wcrtomb(s, cell->text, &ps);
+				if (len > 0)
+					s += len;
+				last_non_space = s;
+			} else if (len) {
+				len = 0;
+			} else {
+				*s++ = ' ';
+			}
+		}
+
+		s = last_non_space;
+		*s++ = '\n';
+	}
+
+	return s - *buf;
+}
+
+int vt_content_start(Vt *t)
+{
+	return t->buffer->scroll_above;
+}
diff --git a/sys/cmd/dvtm/vt.h b/sys/cmd/dvtm/vt.h
new file mode 100644
index 0000000..dbc9c8e
--- /dev/null
+++ b/sys/cmd/dvtm/vt.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright © 2004 Bruno T. C. de Oliveira
+ * Copyright © 2006 Pierre Habouzit
+ * Copyright © 2008-2013 Marc André Tanner
+ * Copyright © 2020-20?? Nicholas Noll
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#ifndef VT_H
+#define VT_H
+
+#include <curses.h>
+#include <stdbool.h>
+#include <sys/types.h>
+
+#ifndef NCURSES_MOUSE_VERSION
+#define mmask_t unsigned long
+#endif
+
+typedef struct Vt Vt;
+typedef void (*vt_title_handler_t)(Vt*, const char *title);
+typedef void (*vt_urgent_handler_t)(Vt*);
+
+void vt_init(void);
+void vt_shutdown(void);
+
+void vt_keytable_set(char const * const keytable_overlay[], int count);
+void vt_default_colors_set(Vt*, attr_t attrs, short fg, short bg);
+void vt_title_handler_set(Vt*, vt_title_handler_t);
+void vt_urgent_handler_set(Vt*, vt_urgent_handler_t);
+void vt_data_set(Vt*, void *);
+void *vt_data_get(Vt*);
+
+Vt   *vt_create(int rows, int cols, int scroll_buf_sz);
+void  vt_resize(Vt*, int rows, int cols);
+void  vt_destroy(Vt*);
+pid_t vt_forkpty(Vt*, const char *p, const char *argv[], const char *cwd, const char *env[], int *to, int *from);
+int   vt_pty_get(Vt*);
+bool  vt_cursor_visible(Vt*);
+
+int vt_process(Vt *);
+void vt_keypress(Vt *, int keycode);
+ssize_t vt_write(Vt*, const char *buf, size_t len);
+void vt_mouse(Vt*, int x, int y, mmask_t mask);
+void vt_dirty(Vt*);
+void vt_draw(Vt*, WINDOW *win, int startrow, int startcol);
+short vt_color_get(Vt*, short fg, short bg);
+short vt_color_reserve(short fg, short bg);
+
+void vt_scroll(Vt*, int rows);
+void vt_noscroll(Vt*);
+
+pid_t vt_pid_get(Vt*);
+size_t vt_content_get(Vt*, char **s, bool colored);
+int vt_content_start(Vt*);
+
+#endif /* VT_H */