Rename to termo

14 files changed, 1053 insertions, 1053 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 81dbb2c..10665f8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-project (termkey2 C)
+project (termo C)
 cmake_minimum_required (VERSION 2.8.5)
 
 if ("${CMAKE_C_COMPILER_ID}" MATCHES "GNU" OR CMAKE_COMPILER_IS_GNUC)
@@ -18,9 +18,9 @@ set (project_VERSION ${project_VERSION}.${project_VERSION_PATCH})
 set (project_API_VERSION ${project_VERSION_MAJOR})
 
 # Names
-set (project_LIB_NAME "termkey2-${project_API_VERSION}")
-set (project_INCLUDE_NAME "termkey2-${project_API_VERSION}")
-set (project_CMAKE_NAME "TermKey2")
+set (project_LIB_NAME "termo-${project_API_VERSION}")
+set (project_INCLUDE_NAME "termo-${project_API_VERSION}")
+set (project_CMAKE_NAME "Termo")
 
 # Dependecies
 find_package (Curses)
@@ -29,19 +29,19 @@ pkg_check_modules (glib glib-2.0 gio-2.0)
 pkg_check_modules (unibilium unibilium>=0.1.0)
 
 # Header files with configuration
-configure_file (${PROJECT_SOURCE_DIR}/termkey2-config.h.in
-	${PROJECT_BINARY_DIR}/termkey2-config.h)
+configure_file (${PROJECT_SOURCE_DIR}/termo-config.h.in
+	${PROJECT_BINARY_DIR}/termo-config.h)
 include_directories (${PROJECT_SOURCE_DIR} ${PROJECT_BINARY_DIR})
 
 # Project source files
 set (lib_sources
-	termkey2.c
+	termo.c
 	driver-csi.c
 	driver-ti.c)
 set (lib_headers
-	termkey2.h
-	termkey2-internal.h
-	${PROJECT_BINARY_DIR}/termkey2-config.h)
+	termo.h
+	termo-internal.h
+	${PROJECT_BINARY_DIR}/termo-config.h)
 
 # Project libraries
 if (unibilium_FOUND)
@@ -56,33 +56,33 @@ else (CURSES_FOUND)
 endif (unibilium_FOUND)
 
 # Create the library targets
-add_library (termkey2 SHARED ${lib_sources} ${lib_headers})
-target_link_libraries (termkey2 ${lib_libraries})
-set_target_properties (termkey2 PROPERTIES
+add_library (termo SHARED ${lib_sources} ${lib_headers})
+target_link_libraries (termo ${lib_libraries})
+set_target_properties (termo PROPERTIES
 	OUTPUT_NAME ${project_LIB_NAME}
 	VERSION ${project_VERSION}
 	SOVERSION ${project_API_VERSION})
 
-add_library (termkey2-static STATIC ${lib_sources} ${lib_headers})
-target_link_libraries (termkey2-static ${lib_libraries})
-set_target_properties (termkey2-static PROPERTIES
+add_library (termo-static STATIC ${lib_sources} ${lib_headers})
+target_link_libraries (termo-static ${lib_libraries})
+set_target_properties (termo-static PROPERTIES
 	OUTPUT_NAME ${project_LIB_NAME}
 	VERSION ${project_VERSION}
 	SOVERSION ${project_API_VERSION})
 
 # Demos
 add_executable (demo-async EXCLUDE_FROM_ALL demo-async.c)
-target_link_libraries (demo-async termkey2-static ${lib_libraries})
+target_link_libraries (demo-async termo-static ${lib_libraries})
 
 add_executable (demo EXCLUDE_FROM_ALL demo.c)
-target_link_libraries (demo termkey2-static ${lib_libraries})
+target_link_libraries (demo termo-static ${lib_libraries})
 
 set (demos demo demo-async)
 if (glib_FOUND)
 	include_directories (${glib_INCLUDE_DIRS})
 	add_executable (demo-glib EXCLUDE_FROM_ALL demo-glib.c)
 	target_link_libraries (demo
-		termkey2-static ${lib_libraries} ${glib_LIBRARIES})
+		termo-static ${lib_libraries} ${glib_LIBRARIES})
 	list (APPEND demos demo-glib)
 endif (glib_FOUND)
 
@@ -90,9 +90,9 @@ add_custom_target (demos DEPENDS ${demos})
 
 # The files to be installed
 include (GNUInstallDirs)
-install (TARGETS termkey2 termkey2-static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+install (TARGETS termo termo-static DESTINATION ${CMAKE_INSTALL_LIBDIR})
 install (FILES LICENSE DESTINATION ${CMAKE_INSTALL_DOCDIR})
-install (FILES termkey2.h ${PROJECT_BINARY_DIR}/termkey2-config.h
+install (FILES termo.h ${PROJECT_BINARY_DIR}/termo-config.h
 	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${project_INCLUDE_NAME})
 
 # Configuration for other CMake projects
diff --git a/README b/README
index 3a1c2ee..bb776a5 100644
--- a/README
+++ b/README
@@ -1,9 +1,9 @@
-termkey2
-========
+termo
+=====
 
-`termkey2' is a library providing an alternative to ncurses' handling of
-terminal input.  ncurses does a really terrible job at that, mainly wrt. mouse
-support which seems to be utterly broken.  If you can drag things in a terminal
+`termo' is a library providing an alternative to ncurses' handling of terminal
+input.  ncurses does a really terrible job at that, mainly wrt. mouse support
+which seems to be utterly broken.  If you can drag things in a terminal
 application, such as in VIM, I can assure you it's not using ncurses for that.
 
 Since terminal I/O is really complicated and full of special cases, this project
@@ -17,7 +17,7 @@ Building and Installing
 Build dependencies: GCC/Clang, pkg-config, cmake >= 2.8.5
 Optional dependencies: Unibilium (alternative for curses), GLib (for the demos)
 
- $ git clone https://github.com/pjanouch/termkey2.git
+ $ git clone https://github.com/pjanouch/termo.git
  $ mkdir build
  $ cd build
  $ cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local
@@ -27,7 +27,7 @@ To install the library, you can do either the usual:
 
 Or you can try telling CMake to make a package for you.  For Debian it is:
  $ cpack -G DEB
- # dpkg -i termkey2-*.deb
+ # dpkg -i termo-*.deb
 
 To see the library in action, you can try running the demos, which are
 statically linked against the library, and hence they can be run as they are:
@@ -38,7 +38,7 @@ What's Different From the Original termkey?
 -------------------------------------------
 The main change is throwing away any UTF-8 dependent code, making the library
 capable of handling all unibyte and multibyte encodings supported by iconv on
-your system.  The characters are still presented as Unicode at the end, however,
+your system.  The characters are still presented as Unicode in the end, however,
 as the other sensible option is wchar_t and that doesn't really work well, see
 http://gnu.org/software/libunistring/manual/libunistring.html#The-wchar_005ft-mess
 
@@ -52,7 +52,7 @@ Oh, and I've deleted the manpages.  It needs more Doxygen. :)  TBD
 
 License
 -------
-`termkey2' is based on the `termkey' library originally written by Paul Evans
+`termo' is based on the `termkey' library originally written by Paul Evans
 <leonerd@leonerd.org.uk>, with additional changes made by Přemysl Janouch
 <p.janouch@gmail.com>.
 
diff --git a/config.cmake.in b/config.cmake.in
index 9a19a6f..aa0209c 100644
--- a/config.cmake.in
+++ b/config.cmake.in
@@ -4,5 +4,5 @@
 #    @project_CMAKE_NAME@_LIBRARIES
 
 set (@project_CMAKE_NAME@_INCLUDE_DIRS @CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_INCLUDEDIR@/@project_INCLUDE_NAME@)
-set (@project_CMAKE_NAME@_LIBRARIES termkey2)
+set (@project_CMAKE_NAME@_LIBRARIES termo)
 
diff --git a/demo-async.c b/demo-async.c
index 88d68a5..c59b8f6 100644
--- a/demo-async.c
+++ b/demo-async.c
@@ -6,13 +6,13 @@
 #include <unistd.h>
 #include <locale.h>
 
-#include "termkey2.h"
+#include "termo.h"
 
 static void
-on_key (termkey_t *tk, termkey_key_t *key)
+on_key (termo_t *tk, termo_key_t *key)
 {
 	char buffer[50];
-	termkey_strfkey (tk, buffer, sizeof buffer, key, TERMKEY_FORMAT_VIM);
+	termo_strfkey (tk, buffer, sizeof buffer, key, TERMO_FORMAT_VIM);
 	printf ("%s\n", buffer);
 }
 
@@ -22,23 +22,23 @@ main (int argc, char *argv[])
 	(void) argc;
 	(void) argv;
 
-	TERMKEY_CHECK_VERSION;
+	TERMO_CHECK_VERSION;
 	setlocale (LC_CTYPE, "");
 
-	termkey_t *tk = termkey_new (STDIN_FILENO, NULL, 0);
+	termo_t *tk = termo_new (STDIN_FILENO, NULL, 0);
 
 	if (!tk)
 	{
-		fprintf (stderr, "Cannot allocate termkey instance\n");
+		fprintf (stderr, "Cannot allocate termo instance\n");
 		exit (1);
 	}
 
 	struct pollfd fd;
-	fd.fd = STDIN_FILENO; /* the file descriptor we passed to termkey_new() */
+	fd.fd = STDIN_FILENO; /* the file descriptor we passed to termo_new() */
 	fd.events = POLLIN;
 
-	termkey_result_t ret;
-	termkey_key_t key;
+	termo_result_t ret;
+	termo_key_t key;
 
 	int running = 1;
 	int nextwait = -1;
@@ -47,27 +47,27 @@ main (int argc, char *argv[])
 	{
 		if (poll (&fd, 1, nextwait) == 0)
 			// Timed out
-			if (termkey_getkey_force (tk, &key) == TERMKEY_RES_KEY)
+			if (termo_getkey_force (tk, &key) == TERMO_RES_KEY)
 				on_key (tk, &key);
 
 		if (fd.revents & (POLLIN | POLLHUP | POLLERR))
-			termkey_advisereadable (tk);
+			termo_advisereadable (tk);
 
-		while ((ret = termkey_getkey (tk, &key)) == TERMKEY_RES_KEY)
+		while ((ret = termo_getkey (tk, &key)) == TERMO_RES_KEY)
 		{
 			on_key (tk, &key);
 
-			if (key.type == TERMKEY_TYPE_KEY
-			 && (key.modifiers & TERMKEY_KEYMOD_CTRL)
+			if (key.type == TERMO_TYPE_KEY
+			 && (key.modifiers & TERMO_KEYMOD_CTRL)
 			 && (key.code.codepoint == 'C' || key.code.codepoint == 'c'))
 				running = 0;
 		}
 
-		if (ret == TERMKEY_RES_AGAIN)
-			nextwait = termkey_get_waittime (tk);
+		if (ret == TERMO_RES_AGAIN)
+			nextwait = termo_get_waittime (tk);
 		else
 			nextwait = -1;
 	}
 
-	termkey_destroy (tk);
+	termo_destroy (tk);
 }
diff --git a/demo-glib.c b/demo-glib.c
index dfe5cd4..80f3a7b 100644
--- a/demo-glib.c
+++ b/demo-glib.c
@@ -3,24 +3,24 @@
 #include <unistd.h>
 #include <locale.h>
 
-#include "termkey2.h"
+#include "termo.h"
 
-static termkey_t *tk;
+static termo_t *tk;
 static int timeout_id;
 
 static void
-on_key (termkey_t *tk, termkey_key_t *key)
+on_key (termo_t *tk, termo_key_t *key)
 {
 	char buffer[50];
-	termkey_strfkey (tk, buffer, sizeof buffer, key, TERMKEY_FORMAT_VIM);
+	termo_strfkey (tk, buffer, sizeof buffer, key, TERMO_FORMAT_VIM);
 	printf ("%s\n", buffer);
 }
 
 static gboolean
 key_timer (gpointer data)
 {
-	termkey_key_t key;
-	if (termkey_getkey_force (tk, &key) == TERMKEY_RES_KEY)
+	termo_key_t key;
+	if (termo_getkey_force (tk, &key) == TERMO_RES_KEY)
 		on_key (tk, &key);
 	return FALSE;
 }
@@ -33,16 +33,16 @@ stdin_io (GIOChannel *source, GIOCondition condition, gpointer data)
 		if (timeout_id)
 			g_source_remove (timeout_id);
 
-		termkey_advisereadable (tk);
+		termo_advisereadable (tk);
 
-		termkey_result_t ret;
-		termkey_key_t key;
-		while ((ret = termkey_getkey (tk, &key)) == TERMKEY_RES_KEY)
+		termo_result_t ret;
+		termo_key_t key;
+		while ((ret = termo_getkey (tk, &key)) == TERMO_RES_KEY)
 			on_key (tk, &key);
 
-		if (ret == TERMKEY_RES_AGAIN)
+		if (ret == TERMO_RES_AGAIN)
 			timeout_id = g_timeout_add
-				(termkey_get_waittime (tk), key_timer, NULL);
+				(termo_get_waittime (tk), key_timer, NULL);
 	}
 
 	return TRUE;
@@ -54,13 +54,13 @@ main (int argc, char *argv[])
 	(void) argc;
 	(void) argv;
 
-	TERMKEY_CHECK_VERSION;
+	TERMO_CHECK_VERSION;
 	setlocale (LC_CTYPE, "");
 
-	tk = termkey_new (STDIN_FILENO, NULL, 0);
+	tk = termo_new (STDIN_FILENO, NULL, 0);
 	if (!tk)
 	{
-		fprintf (stderr, "Cannot allocate termkey instance\n");
+		fprintf (stderr, "Cannot allocate termo instance\n");
 		exit (1);
 	}
 
@@ -68,5 +68,5 @@ main (int argc, char *argv[])
 	g_io_add_watch (g_io_channel_unix_new (STDIN_FILENO),
 		G_IO_IN, stdin_io, NULL);
 	g_main_loop_run (loop);
-	termkey_destroy (tk);
+	termo_destroy (tk);
 }
diff --git a/demo.c b/demo.c
index 5bb9fc2..d74892c 100644
--- a/demo.c
+++ b/demo.c
@@ -6,20 +6,20 @@
 #include <errno.h>
 #include <locale.h>
 
-#include "termkey2.h"
+#include "termo.h"
 
 int
 main(int argc, char *argv[])
 {
-	TERMKEY_CHECK_VERSION;
+	TERMO_CHECK_VERSION;
 	setlocale (LC_CTYPE, "");
 
 	int mouse = 0;
 	int mouse_proto = 0;
-	termkey_format_t format = TERMKEY_FORMAT_VIM;
+	termo_format_t format = TERMO_FORMAT_VIM;
 
 	char buffer[50];
-	termkey_t *tk;
+	termo_t *tk;
 
 	int opt;
 	while ((opt = getopt (argc, argv, "m::p:")) != -1)
@@ -43,21 +43,21 @@ main(int argc, char *argv[])
 		}
 	}
 
-	tk = termkey_new (STDIN_FILENO, NULL,
-		TERMKEY_FLAG_SPACESYMBOL | TERMKEY_FLAG_CTRLC);
+	tk = termo_new (STDIN_FILENO, NULL,
+		TERMO_FLAG_SPACESYMBOL | TERMO_FLAG_CTRLC);
 	if (!tk)
 	{
-		fprintf (stderr, "Cannot allocate termkey instance\n");
+		fprintf (stderr, "Cannot allocate termo instance\n");
 		exit (1);
 	}
 
-	if (termkey_get_flags (tk) & TERMKEY_FLAG_RAW)
+	if (termo_get_flags (tk) & TERMO_FLAG_RAW)
 		printf ("Termkey in RAW mode\n");
 	else
 		printf ("Termkey in multibyte mode\n");
 
-	termkey_result_t ret;
-	termkey_key_t key;
+	termo_result_t ret;
+	termo_key_t key;
 
 	if (mouse)
 	{
@@ -66,38 +66,38 @@ main(int argc, char *argv[])
 			printf ("\033[?%dh", mouse_proto);
 	}
 
-	while ((ret = termkey_waitkey (tk, &key)) != TERMKEY_RES_EOF)
+	while ((ret = termo_waitkey (tk, &key)) != TERMO_RES_EOF)
 	{
-		if (ret == TERMKEY_RES_KEY)
+		if (ret == TERMO_RES_KEY)
 		{
-			termkey_strfkey (tk, buffer, sizeof buffer, &key, format);
-			if (key.type == TERMKEY_TYPE_MOUSE)
+			termo_strfkey (tk, buffer, sizeof buffer, &key, format);
+			if (key.type == TERMO_TYPE_MOUSE)
 			{
 				int line, col;
-				termkey_interpret_mouse (tk, &key, NULL, NULL, &line, &col);
+				termo_interpret_mouse (tk, &key, NULL, NULL, &line, &col);
 				printf ("%s at line=%d, col=%d\n", buffer, line, col);
 			}
-			else if (key.type == TERMKEY_TYPE_POSITION)
+			else if (key.type == TERMO_TYPE_POSITION)
 			{
 				int line, col;
-				termkey_interpret_position (tk, &key, &line, &col);
+				termo_interpret_position (tk, &key, &line, &col);
 				printf ("Cursor position report at line=%d, col=%d\n",
 					line, col);
 			}
-			else if (key.type == TERMKEY_TYPE_MODEREPORT)
+			else if (key.type == TERMO_TYPE_MODEREPORT)
 			{
 				int initial, mode, value;
-				termkey_interpret_modereport
+				termo_interpret_modereport
 					(tk, &key, &initial, &mode, &value);
 				printf ("Mode report %s mode %d = %d\n",
 					initial ? "DEC" : "ANSI", mode, value);
 			}
-			else if (key.type == TERMKEY_TYPE_UNKNOWN_CSI)
+			else if (key.type == TERMO_TYPE_UNKNOWN_CSI)
 			{
 				long args[16];
 				size_t nargs = 16;
 				unsigned long command;
-				termkey_interpret_csi (tk, &key, args, &nargs, &command);
+				termo_interpret_csi (tk, &key, args, &nargs, &command);
 				printf ("Unrecognised CSI %c %ld;%ld %c%c\n",
 					(char) (command >> 8), args[0], args[1],
 					(char) (command >> 16), (char) command);
@@ -105,12 +105,12 @@ main(int argc, char *argv[])
 			else
 				printf ("Key %s\n", buffer);
 
-			if (key.type == TERMKEY_TYPE_KEY
-			 && key.modifiers & TERMKEY_KEYMOD_CTRL
+			if (key.type == TERMO_TYPE_KEY
+			 && key.modifiers & TERMO_KEYMOD_CTRL
 			 && (key.code.codepoint == 'C' || key.code.codepoint == 'c'))
 				break;
 
-			if (key.type == TERMKEY_TYPE_KEY
+			if (key.type == TERMO_TYPE_KEY
 			 && key.modifiers == 0
 			 && key.code.codepoint == '?')
 			{
@@ -119,11 +119,11 @@ main(int argc, char *argv[])
 				fflush (stdout);
 			}
 		}
-		else if (ret == TERMKEY_RES_ERROR)
+		else if (ret == TERMO_RES_ERROR)
 		{
 			if (errno != EINTR)
 			{
-				perror ("termkey_waitkey");
+				perror ("termo_waitkey");
 				break;
 			}
 			printf ("Interrupted by signal\n");
@@ -133,5 +133,5 @@ main(int argc, char *argv[])
 	if (mouse)
 		printf ("\033[?%dlMouse mode deactivated\n", mouse);
 
-	termkey_destroy (tk);
+	termo_destroy (tk);
 }
diff --git a/driver-csi.c b/driver-csi.c
index a7fcc52..4a954fc 100644
--- a/driver-csi.c
+++ b/driver-csi.c
@@ -1,5 +1,5 @@
-#include "termkey2.h"
-#include "termkey2-internal.h"
+#include "termo.h"
+#include "termo-internal.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -11,12 +11,12 @@ static char ss3_kpalts[64];
 
 typedef struct
 {
-	termkey_t *tk;
+	termo_t *tk;
 }
-termkey_csi_t;
+termo_csi_t;
 
-typedef termkey_result_t (*csi_handler_fn)
-	(termkey_t *tk, termkey_key_t *key, int cmd, long *arg, int args);
+typedef termo_result_t (*csi_handler_fn)
+	(termo_t *tk, termo_key_t *key, int cmd, long *arg, int args);
 static csi_handler_fn csi_handlers[64];
 
 /*
@@ -25,9 +25,9 @@ static csi_handler_fn csi_handlers[64];
 
 static struct keyinfo csi_ss3s[64];
 
-static termkey_result_t
-handle_csi_ss3_full (termkey_t *tk,
-	termkey_key_t *key, int cmd, long *arg, int args)
+static termo_result_t
+handle_csi_ss3_full (termo_t *tk,
+	termo_key_t *key, int cmd, long *arg, int args)
 {
 	(void) tk;
 
@@ -41,13 +41,13 @@ handle_csi_ss3_full (termkey_t *tk,
 	key->modifiers &= ~(csi_ss3s[cmd - 0x40].modifier_mask);
 	key->modifiers |=   csi_ss3s[cmd - 0x40].modifier_set;
 
-	if (key->code.sym == TERMKEY_SYM_UNKNOWN)
-		return TERMKEY_RES_NONE;
-	return TERMKEY_RES_KEY;
+	if (key->code.sym == TERMO_SYM_UNKNOWN)
+		return TERMO_RES_NONE;
+	return TERMO_RES_KEY;
 }
 
 static void
-register_csi_ss3_full (termkey_type_t type, termkey_sym_t sym,
+register_csi_ss3_full (termo_type_t type, termo_sym_t sym,
 	int modifier_set, int modifier_mask, unsigned char cmd)
 {
 	if (cmd < 0x40 || cmd >= 0x80)
@@ -62,7 +62,7 @@ register_csi_ss3_full (termkey_type_t type, termkey_sym_t sym,
 }
 
 static void
-register_csi_ss3 (termkey_type_t type, termkey_sym_t sym, unsigned char cmd)
+register_csi_ss3 (termo_type_t type, termo_sym_t sym, unsigned char cmd)
 {
 	register_csi_ss3_full (type, sym, 0, 0, cmd);
 }
@@ -72,7 +72,7 @@ register_csi_ss3 (termkey_type_t type, termkey_sym_t sym, unsigned char cmd)
  */
 
 static void
-register_ss3kpalt (termkey_type_t type, termkey_sym_t sym,
+register_ss3kpalt (termo_type_t type, termo_sym_t sym,
 	unsigned char cmd, char kpalt)
 {
 	if (cmd < 0x40 || cmd >= 0x80)
@@ -94,8 +94,8 @@ register_ss3kpalt (termkey_type_t type, termkey_sym_t sym,
 static struct keyinfo csifuncs[35];
 #define NCSIFUNCS ((long) (sizeof csifuncs / sizeof csifuncs[0]))
 
-static termkey_result_t
-handle_csifunc (termkey_t *tk, termkey_key_t *key, int cmd, long *arg, int args)
+static termo_result_t
+handle_csifunc (termo_t *tk, termo_key_t *key, int cmd, long *arg, int args)
 {
 	(void) cmd;
 
@@ -103,7 +103,7 @@ handle_csifunc (termkey_t *tk, termkey_key_t *key, int cmd, long *arg, int args)
 		key->modifiers = arg[1] - 1;
 	else
 		key->modifiers = 0;
-	key->type = TERMKEY_TYPE_KEYSYM;
+	key->type = TERMO_TYPE_KEYSYM;
 
 	if (arg[0] == 27)
 	{
@@ -119,21 +119,21 @@ handle_csifunc (termkey_t *tk, termkey_key_t *key, int cmd, long *arg, int args)
 		key->modifiers |=   csifuncs[arg[0]].modifier_set;
 	}
 	else
-		key->code.sym = TERMKEY_SYM_UNKNOWN;
+		key->code.sym = TERMO_SYM_UNKNOWN;
 
-	if (key->code.sym == TERMKEY_SYM_UNKNOWN)
+	if (key->code.sym == TERMO_SYM_UNKNOWN)
 	{
 #ifdef DEBUG
 		fprintf (stderr, "CSI: Unknown function key %ld\n", arg[0]);
 #endif
-		return TERMKEY_RES_NONE;
+		return TERMO_RES_NONE;
 	}
 
-	return TERMKEY_RES_KEY;
+	return TERMO_RES_KEY;
 }
 
 static void
-register_csifunc (termkey_type_t type, termkey_sym_t sym, int number)
+register_csifunc (termo_type_t type, termo_sym_t sym, int number)
 {
 	if (number >= NCSIFUNCS)
 		return;
@@ -150,21 +150,21 @@ register_csifunc (termkey_type_t type, termkey_sym_t sym, int number)
  * URxvt seems to emit this instead of ~ when holding Ctrl
  */
 
-static termkey_result_t
-handle_csi_caret (termkey_t *tk,
-	termkey_key_t *key, int cmd, long *arg, int args)
+static termo_result_t
+handle_csi_caret (termo_t *tk,
+	termo_key_t *key, int cmd, long *arg, int args)
 {
 	switch (cmd)
 	{
 	case '^':
 	{
-		termkey_result_t res = handle_csifunc (tk, key, cmd, arg, args);
-		if (res == TERMKEY_RES_KEY)
-			key->modifiers |= TERMKEY_KEYMOD_CTRL;
+		termo_result_t res = handle_csifunc (tk, key, cmd, arg, args);
+		if (res == TERMO_RES_KEY)
+			key->modifiers |= TERMO_KEYMOD_CTRL;
 		return res;
 	}
 	default:
-		return TERMKEY_RES_NONE;
+		return TERMO_RES_NONE;
 	}
 }
 
@@ -172,8 +172,8 @@ handle_csi_caret (termkey_t *tk,
  * Handler for CSI u extended Unicode keys
  */
 
-static termkey_result_t
-handle_csi_u (termkey_t *tk, termkey_key_t *key, int cmd, long *arg, int args)
+static termo_result_t
+handle_csi_u (termo_t *tk, termo_key_t *key, int cmd, long *arg, int args)
 {
 	switch (cmd)
 	{
@@ -185,13 +185,13 @@ handle_csi_u (termkey_t *tk, termkey_key_t *key, int cmd, long *arg, int args)
 			key->modifiers = 0;
 
 		int mod = key->modifiers;
-		key->type = TERMKEY_TYPE_KEYSYM;
+		key->type = TERMO_TYPE_KEYSYM;
 		(*tk->method.emit_codepoint) (tk, arg[0], key);
 		key->modifiers |= mod;
-		return TERMKEY_RES_KEY;
+		return TERMO_RES_KEY;
 	}
 	default:
-		return TERMKEY_RES_NONE;
+		return TERMO_RES_NONE;
 	}
 }
 
@@ -200,8 +200,8 @@ handle_csi_u (termkey_t *tk, termkey_key_t *key, int cmd, long *arg, int args)
  * Note: This does not handle X10 encoding
  */
 
-static termkey_result_t
-handle_csi_m (termkey_t *tk, termkey_key_t *key, int cmd, long *arg, int args)
+static termo_result_t
+handle_csi_m (termo_t *tk, termo_key_t *key, int cmd, long *arg, int args)
 {
 	(void) tk;
 
@@ -214,57 +214,57 @@ handle_csi_m (termkey_t *tk, termkey_key_t *key, int cmd, long *arg, int args)
 	case 'm':
 		break;
 	default:
-		return TERMKEY_RES_NONE;
+		return TERMO_RES_NONE;
 	}
 
 	if (!initial && args >= 3)
 	{
 		// rxvt protocol
-		key->type = TERMKEY_TYPE_MOUSE;
+		key->type = TERMO_TYPE_MOUSE;
 		key->code.mouse.info = arg[0] - 0x20;
 
 		key->modifiers = (key->code.mouse.info & 0x1c) >> 2;
 		key->code.mouse.info &= ~0x1c;
 
-		termkey_key_set_linecol (key, arg[2] - 1, arg[1] - 1);
-		return TERMKEY_RES_KEY;
+		termo_key_set_linecol (key, arg[2] - 1, arg[1] - 1);
+		return TERMO_RES_KEY;
 	}
 
 	if (initial == '<' && args >= 3)
 	{
 		// SGR protocol
-		key->type = TERMKEY_TYPE_MOUSE;
+		key->type = TERMO_TYPE_MOUSE;
 		key->code.mouse.info = arg[0];
 
 		key->modifiers = (key->code.mouse.info & 0x1c) >> 2;
 		key->code.mouse.info &= ~0x1c;
 
-		termkey_key_set_linecol (key, arg[2] - 1, arg[1] - 1);
+		termo_key_set_linecol (key, arg[2] - 1, arg[1] - 1);
 
 		if (cmd == 'm')  // release
 			key->code.mouse.info |= 0x8000;
-		return TERMKEY_RES_KEY;
+		return TERMO_RES_KEY;
 	}
-	return TERMKEY_RES_NONE;
+	return TERMO_RES_NONE;
 }
 
-termkey_result_t
-termkey_interpret_mouse (termkey_t *tk, const termkey_key_t *key,
-	termkey_mouse_event_t *event, int *button, int *line, int *col)
+termo_result_t
+termo_interpret_mouse (termo_t *tk, const termo_key_t *key,
+	termo_mouse_event_t *event, int *button, int *line, int *col)
 {
 	(void) tk;
 
-	if (key->type != TERMKEY_TYPE_MOUSE)
-		return TERMKEY_RES_NONE;
+	if (key->type != TERMO_TYPE_MOUSE)
+		return TERMO_RES_NONE;
 
 	if (button)
 		*button = 0;
 
-	termkey_key_get_linecol (key, line, col);
+	termo_key_get_linecol (key, line, col);
 
 	// XXX: WTF is this logic?
 	if (!event)
-		return TERMKEY_RES_KEY;
+		return TERMO_RES_KEY;
 
 	int btn = 0;
 	int code = key->code.mouse.info;
@@ -276,30 +276,30 @@ termkey_interpret_mouse (termkey_t *tk, const termkey_key_t *key,
 	case 0:
 	case 1:
 	case 2:
-		*event = drag ? TERMKEY_MOUSE_DRAG : TERMKEY_MOUSE_PRESS;
+		*event = drag ? TERMO_MOUSE_DRAG : TERMO_MOUSE_PRESS;
 		btn = code + 1;
 		break;
 
 	case 3:
-		*event = TERMKEY_MOUSE_RELEASE;
+		*event = TERMO_MOUSE_RELEASE;
 		// no button hint
 		break;
 
 	case 64:
 	case 65:
-		*event = drag ? TERMKEY_MOUSE_DRAG : TERMKEY_MOUSE_PRESS;
+		*event = drag ? TERMO_MOUSE_DRAG : TERMO_MOUSE_PRESS;
 		btn = code + 4 - 64;
 		break;
 
 	default:
-		*event = TERMKEY_MOUSE_UNKNOWN;
+		*event = TERMO_MOUSE_UNKNOWN;
 	}
 
 	if (button)
 		*button = btn;
 	if (key->code.mouse.info & 0x8000)
-		*event = TERMKEY_MOUSE_RELEASE;
-	return TERMKEY_RES_KEY;
+		*event = TERMO_MOUSE_RELEASE;
+	return TERMO_RES_KEY;
 }
 
 /*
@@ -307,43 +307,43 @@ termkey_interpret_mouse (termkey_t *tk, const termkey_key_t *key,
  * A plain CSI R with no arguments is probably actually <F3>
  */
 
-static termkey_result_t
-handle_csi_R (termkey_t *tk, termkey_key_t *key, int cmd, long *arg, int args)
+static termo_result_t
+handle_csi_R (termo_t *tk, termo_key_t *key, int cmd, long *arg, int args)
 {
 	switch (cmd)
 	{
 	case 'R' | '?' << 8:
 		if (args < 2)
-			return TERMKEY_RES_NONE;
+			return TERMO_RES_NONE;
 
-		key->type = TERMKEY_TYPE_POSITION;
-		termkey_key_set_linecol (key, arg[1], arg[0]);
-		return TERMKEY_RES_KEY;
+		key->type = TERMO_TYPE_POSITION;
+		termo_key_set_linecol (key, arg[1], arg[0]);
+		return TERMO_RES_KEY;
 
 	default:
 		return handle_csi_ss3_full (tk, key, cmd, arg, args);
 	}
 }
 
-termkey_result_t
-termkey_interpret_position (termkey_t *tk,
-	const termkey_key_t *key, int *line, int *col)
+termo_result_t
+termo_interpret_position (termo_t *tk,
+	const termo_key_t *key, int *line, int *col)
 {
 	(void) tk;
 
-	if (key->type != TERMKEY_TYPE_POSITION)
-		return TERMKEY_RES_NONE;
+	if (key->type != TERMO_TYPE_POSITION)
+		return TERMO_RES_NONE;
 
-	termkey_key_get_linecol (key, line, col);
-	return TERMKEY_RES_KEY;
+	termo_key_get_linecol (key, line, col);
+	return TERMO_RES_KEY;
 }
 
 /*
  * Handler for CSI $y mode status reports
  */
 
-static termkey_result_t
-handle_csi_y (termkey_t *tk, termkey_key_t *key, int cmd, long *arg, int args)
+static termo_result_t
+handle_csi_y (termo_t *tk, termo_key_t *key, int cmd, long *arg, int args)
 {
 	(void) tk;
 
@@ -352,27 +352,27 @@ handle_csi_y (termkey_t *tk, termkey_key_t *key, int cmd, long *arg, int args)
 	case 'y' | '$' << 16:
 	case 'y' | '$' << 16 | '?' << 8:
 		if (args < 2)
-			return TERMKEY_RES_NONE;
+			return TERMO_RES_NONE;
 
-		key->type = TERMKEY_TYPE_MODEREPORT;
+		key->type = TERMO_TYPE_MODEREPORT;
 		key->code.mode.initial = (cmd >> 8);
 		key->code.mode.mode = arg[0];
 		key->code.mode.value = arg[1];
-		return TERMKEY_RES_KEY;
+		return TERMO_RES_KEY;
 
 	default:
-		return TERMKEY_RES_NONE;
+		return TERMO_RES_NONE;
 	}
 }
 
-termkey_result_t
-termkey_interpret_modereport (termkey_t *tk,
-	const termkey_key_t *key, int *initial, int *mode, int *value)
+termo_result_t
+termo_interpret_modereport (termo_t *tk,
+	const termo_key_t *key, int *initial, int *mode, int *value)
 {
 	(void) tk;
 
-	if (key->type != TERMKEY_TYPE_MODEREPORT)
-		return TERMKEY_RES_NONE;
+	if (key->type != TERMO_TYPE_MODEREPORT)
+		return TERMO_RES_NONE;
 
 	if (initial)
 		*initial = key->code.mode.initial;
@@ -380,13 +380,13 @@ termkey_interpret_modereport (termkey_t *tk,
 		*mode = key->code.mode.mode;
 	if (value)
 		*value = key->code.mode.value;
-	return TERMKEY_RES_KEY;
+	return TERMO_RES_KEY;
 }
 
 #define CHARAT(i) (tk->buffer[tk->buffstart + (i)])
 
-static termkey_result_t
-parse_csi (termkey_t *tk, size_t introlen, size_t *csi_len,
+static termo_result_t
+parse_csi (termo_t *tk, size_t introlen, size_t *csi_len,
 	long args[], size_t *nargs, unsigned long *commandp)
 {
 	size_t csi_end = introlen;
@@ -398,7 +398,7 @@ parse_csi (termkey_t *tk, size_t introlen, size_t *csi_len,
 	}
 
 	if (csi_end >= tk->buffcount)
-		return TERMKEY_RES_AGAIN;
+		return TERMO_RES_AGAIN;
 
 	unsigned char cmd = CHARAT (csi_end);
 	*commandp = cmd;
@@ -451,17 +451,17 @@ parse_csi (termkey_t *tk, size_t introlen, size_t *csi_len,
 
 	*nargs = argi;
 	*csi_len = csi_end + 1;
-	return TERMKEY_RES_KEY;
+	return TERMO_RES_KEY;
 }
 
-termkey_result_t
-termkey_interpret_csi (termkey_t *tk, const termkey_key_t *key,
+termo_result_t
+termo_interpret_csi (termo_t *tk, const termo_key_t *key,
 	long args[], size_t *nargs, unsigned long *cmd)
 {
 	if (tk->hightide == 0)
-		return TERMKEY_RES_NONE;
-	if (key->type != TERMKEY_TYPE_UNKNOWN_CSI)
-		return TERMKEY_RES_NONE;
+		return TERMO_RES_NONE;
+	if (key->type != TERMO_TYPE_UNKNOWN_CSI)
+		return TERMO_RES_NONE;
 
 	size_t dummy;
 	return parse_csi (tk, 0, &dummy, args, nargs, cmd);
@@ -473,76 +473,76 @@ register_keys (void)
 	int i;
 	for (i = 0; i < 64; i++)
 	{
-		csi_ss3s[i].sym = TERMKEY_SYM_UNKNOWN;
-		ss3s[i].sym     = TERMKEY_SYM_UNKNOWN;
+		csi_ss3s[i].sym = TERMO_SYM_UNKNOWN;
+		ss3s[i].sym     = TERMO_SYM_UNKNOWN;
 		ss3_kpalts[i] = 0;
 	}
 	for (i = 0; i < NCSIFUNCS; i++)
-		csifuncs[i].sym = TERMKEY_SYM_UNKNOWN;
-
-	register_csi_ss3 (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_UP,    'A');
-	register_csi_ss3 (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_DOWN,  'B');
-	register_csi_ss3 (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_RIGHT, 'C');
-	register_csi_ss3 (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_LEFT,  'D');
-	register_csi_ss3 (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_BEGIN, 'E');
-	register_csi_ss3 (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_END,   'F');
-	register_csi_ss3 (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_HOME,  'H');
-	register_csi_ss3 (TERMKEY_TYPE_FUNCTION, 1, 'P');
-	register_csi_ss3 (TERMKEY_TYPE_FUNCTION, 2, 'Q');
-	register_csi_ss3 (TERMKEY_TYPE_FUNCTION, 3, 'R');
-	register_csi_ss3 (TERMKEY_TYPE_FUNCTION, 4, 'S');
-
-	register_csi_ss3_full (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_TAB,
-		TERMKEY_KEYMOD_SHIFT, TERMKEY_KEYMOD_SHIFT, 'Z');
-
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KPENTER,  'M', 0);
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KPEQUALS, 'X', '=');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KPMULT,   'j', '*');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KPPLUS,   'k', '+');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KPCOMMA,  'l', ',');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KPMINUS,  'm', '-');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KPPERIOD, 'n', '.');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KPDIV,    'o', '/');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KP0,      'p', '0');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KP1,      'q', '1');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KP2,      'r', '2');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KP3,      's', '3');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KP4,      't', '4');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KP5,      'u', '5');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KP6,      'v', '6');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KP7,      'w', '7');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KP8,      'x', '8');
-	register_ss3kpalt (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_KP9,      'y', '9');
-
-	register_csifunc (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_FIND,      1);
-	register_csifunc (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_INSERT,    2);
-	register_csifunc (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_DELETE,    3);
-	register_csifunc (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_SELECT,    4);
-	register_csifunc (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_PAGEUP,    5);
-	register_csifunc (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_PAGEDOWN,  6);
-	register_csifunc (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_HOME,      7);
-	register_csifunc (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_END,       8);
-
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 1,  11);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 2,  12);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 3,  13);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 4,  14);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 5,  15);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 6,  17);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 7,  18);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 8,  19);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 9,  20);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 10, 21);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 11, 23);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 12, 24);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 13, 25);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 14, 26);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 15, 28);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 16, 29);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 17, 31);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 18, 32);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 19, 33);
-	register_csifunc (TERMKEY_TYPE_FUNCTION, 20, 34);
+		csifuncs[i].sym = TERMO_SYM_UNKNOWN;
+
+	register_csi_ss3 (TERMO_TYPE_KEYSYM, TERMO_SYM_UP,    'A');
+	register_csi_ss3 (TERMO_TYPE_KEYSYM, TERMO_SYM_DOWN,  'B');
+	register_csi_ss3 (TERMO_TYPE_KEYSYM, TERMO_SYM_RIGHT, 'C');
+	register_csi_ss3 (TERMO_TYPE_KEYSYM, TERMO_SYM_LEFT,  'D');
+	register_csi_ss3 (TERMO_TYPE_KEYSYM, TERMO_SYM_BEGIN, 'E');
+	register_csi_ss3 (TERMO_TYPE_KEYSYM, TERMO_SYM_END,   'F');
+	register_csi_ss3 (TERMO_TYPE_KEYSYM, TERMO_SYM_HOME,  'H');
+	register_csi_ss3 (TERMO_TYPE_FUNCTION, 1, 'P');
+	register_csi_ss3 (TERMO_TYPE_FUNCTION, 2, 'Q');
+	register_csi_ss3 (TERMO_TYPE_FUNCTION, 3, 'R');
+	register_csi_ss3 (TERMO_TYPE_FUNCTION, 4, 'S');
+
+	register_csi_ss3_full (TERMO_TYPE_KEYSYM, TERMO_SYM_TAB,
+		TERMO_KEYMOD_SHIFT, TERMO_KEYMOD_SHIFT, 'Z');
+
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KPENTER,  'M', 0);
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KPEQUALS, 'X', '=');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KPMULT,   'j', '*');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KPPLUS,   'k', '+');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KPCOMMA,  'l', ',');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KPMINUS,  'm', '-');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KPPERIOD, 'n', '.');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KPDIV,    'o', '/');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KP0,      'p', '0');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KP1,      'q', '1');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KP2,      'r', '2');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KP3,      's', '3');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KP4,      't', '4');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KP5,      'u', '5');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KP6,      'v', '6');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KP7,      'w', '7');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KP8,      'x', '8');
+	register_ss3kpalt (TERMO_TYPE_KEYSYM, TERMO_SYM_KP9,      'y', '9');
+
+	register_csifunc (TERMO_TYPE_KEYSYM, TERMO_SYM_FIND,      1);
+	register_csifunc (TERMO_TYPE_KEYSYM, TERMO_SYM_INSERT,    2);
+	register_csifunc (TERMO_TYPE_KEYSYM, TERMO_SYM_DELETE,    3);
+	register_csifunc (TERMO_TYPE_KEYSYM, TERMO_SYM_SELECT,    4);
+	register_csifunc (TERMO_TYPE_KEYSYM, TERMO_SYM_PAGEUP,    5);
+	register_csifunc (TERMO_TYPE_KEYSYM, TERMO_SYM_PAGEDOWN,  6);
+	register_csifunc (TERMO_TYPE_KEYSYM, TERMO_SYM_HOME,      7);
+	register_csifunc (TERMO_TYPE_KEYSYM, TERMO_SYM_END,       8);
+
+	register_csifunc (TERMO_TYPE_FUNCTION, 1,  11);
+	register_csifunc (TERMO_TYPE_FUNCTION, 2,  12);
+	register_csifunc (TERMO_TYPE_FUNCTION, 3,  13);
+	register_csifunc (TERMO_TYPE_FUNCTION, 4,  14);
+	register_csifunc (TERMO_TYPE_FUNCTION, 5,  15);
+	register_csifunc (TERMO_TYPE_FUNCTION, 6,  17);
+	register_csifunc (TERMO_TYPE_FUNCTION, 7,  18);
+	register_csifunc (TERMO_TYPE_FUNCTION, 8,  19);
+	register_csifunc (TERMO_TYPE_FUNCTION, 9,  20);
+	register_csifunc (TERMO_TYPE_FUNCTION, 10, 21);
+	register_csifunc (TERMO_TYPE_FUNCTION, 11, 23);
+	register_csifunc (TERMO_TYPE_FUNCTION, 12, 24);
+	register_csifunc (TERMO_TYPE_FUNCTION, 13, 25);
+	register_csifunc (TERMO_TYPE_FUNCTION, 14, 26);
+	register_csifunc (TERMO_TYPE_FUNCTION, 15, 28);
+	register_csifunc (TERMO_TYPE_FUNCTION, 16, 29);
+	register_csifunc (TERMO_TYPE_FUNCTION, 17, 31);
+	register_csifunc (TERMO_TYPE_FUNCTION, 18, 32);
+	register_csifunc (TERMO_TYPE_FUNCTION, 19, 33);
+	register_csifunc (TERMO_TYPE_FUNCTION, 20, 34);
 
 	csi_handlers['u' - 0x40] = &handle_csi_u;
 
@@ -554,14 +554,14 @@ register_keys (void)
 	csi_handlers['y' - 0x40] = &handle_csi_y;
 
 	// URxvt
-	register_csi_ss3_full (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_UP,
-		TERMKEY_KEYMOD_CTRL, TERMKEY_KEYMOD_CTRL, 'a');
-	register_csi_ss3_full (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_DOWN,
-		TERMKEY_KEYMOD_CTRL, TERMKEY_KEYMOD_CTRL, 'b');
-	register_csi_ss3_full (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_RIGHT,
-		TERMKEY_KEYMOD_CTRL, TERMKEY_KEYMOD_CTRL, 'c');
-	register_csi_ss3_full (TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_LEFT,
-		TERMKEY_KEYMOD_CTRL, TERMKEY_KEYMOD_CTRL, 'd');
+	register_csi_ss3_full (TERMO_TYPE_KEYSYM, TERMO_SYM_UP,
+		TERMO_KEYMOD_CTRL, TERMO_KEYMOD_CTRL, 'a');
+	register_csi_ss3_full (TERMO_TYPE_KEYSYM, TERMO_SYM_DOWN,
+		TERMO_KEYMOD_CTRL, TERMO_KEYMOD_CTRL, 'b');
+	register_csi_ss3_full (TERMO_TYPE_KEYSYM, TERMO_SYM_RIGHT,
+		TERMO_KEYMOD_CTRL, TERMO_KEYMOD_CTRL, 'c');
+	register_csi_ss3_full (TERMO_TYPE_KEYSYM, TERMO_SYM_LEFT,
+		TERMO_KEYMOD_CTRL, TERMO_KEYMOD_CTRL, 'd');
 
 	csi_handlers['^' - 0x40] = &handle_csi_caret;
 
@@ -570,14 +570,14 @@ register_keys (void)
 }
 
 static void *
-new_driver (termkey_t *tk, const char *term)
+new_driver (termo_t *tk, const char *term)
 {
 	(void) term;
 
 	if (!keyinfo_initialised && !register_keys ())
 		return NULL;
 
-	termkey_csi_t *csi = malloc (sizeof *csi);
+	termo_csi_t *csi = malloc (sizeof *csi);
 	if (!csi)
 		return NULL;
 
@@ -588,13 +588,13 @@ new_driver (termkey_t *tk, const char *term)
 static void
 free_driver (void *info)
 {
-	termkey_csi_t *csi = info;
+	termo_csi_t *csi = info;
 	free (csi);
 }
 
-static termkey_result_t
-peekkey_csi (termkey_t *tk, termkey_csi_t *csi,
-	size_t introlen, termkey_key_t *key, int force, size_t *nbytep)
+static termo_result_t
+peekkey_csi (termo_t *tk, termo_csi_t *csi,
+	size_t introlen, termo_key_t *key, int force, size_t *nbytep)
 {
 	(void) csi;
 
@@ -603,16 +603,16 @@ peekkey_csi (termkey_t *tk, termkey_csi_t *csi,
 	long arg[16];
 	unsigned long cmd;
 
-	termkey_result_t ret = parse_csi (tk, introlen, &csi_len, arg, &args, &cmd);
-	if (ret == TERMKEY_RES_AGAIN)
+	termo_result_t ret = parse_csi (tk, introlen, &csi_len, arg, &args, &cmd);
+	if (ret == TERMO_RES_AGAIN)
 	{
 		if (!force)
-			return TERMKEY_RES_AGAIN;
+			return TERMO_RES_AGAIN;
 
 		(*tk->method.emit_codepoint) (tk, '[', key);
-		key->modifiers |= TERMKEY_KEYMOD_ALT;
+		key->modifiers |= TERMO_KEYMOD_ALT;
 		*nbytep = introlen;
-		return TERMKEY_RES_KEY;
+		return TERMO_RES_KEY;
 	}
 
 	// Mouse in X10 encoding consumes the next 3 bytes also (or more with 1005)
@@ -621,24 +621,24 @@ peekkey_csi (termkey_t *tk, termkey_csi_t *csi,
 		tk->buffstart += csi_len;
 		tk->buffcount -= csi_len;
 
-		termkey_result_t mouse_result =
+		termo_result_t mouse_result =
 			(*tk->method.peekkey_mouse) (tk, key, nbytep);
 
 		tk->buffstart -= csi_len;
 		tk->buffcount += csi_len;
 
-		if (mouse_result == TERMKEY_RES_KEY)
+		if (mouse_result == TERMO_RES_KEY)
 			*nbytep += csi_len;
 		return mouse_result;
 	}
 
-	termkey_result_t result = TERMKEY_RES_NONE;
+	termo_result_t result = TERMO_RES_NONE;
 
 	// We know from the logic above that cmd must be >= 0x40 and < 0x80
 	if (csi_handlers[(cmd & 0xff) - 0x40])
 		result = (*csi_handlers[(cmd & 0xff) - 0x40]) (tk, key, cmd, arg, args);
 
-	if (result == TERMKEY_RES_NONE)
+	if (result == TERMO_RES_NONE)
 	{
 #ifdef DEBUG
 		switch (args)
@@ -661,49 +661,49 @@ peekkey_csi (termkey_t *tk, termkey_csi_t *csi,
 			break;
 		}
 #endif
-		key->type = TERMKEY_TYPE_UNKNOWN_CSI;
+		key->type = TERMO_TYPE_UNKNOWN_CSI;
 		key->code.number = cmd;
 
 		tk->hightide = csi_len - introlen;
 		*nbytep = introlen; // Do not yet eat the data bytes
-		return TERMKEY_RES_KEY;
+		return TERMO_RES_KEY;
 	}
 
 	*nbytep = csi_len;
 	return result;
 }
 
-static termkey_result_t
-peekkey_ss3 (termkey_t *tk, termkey_csi_t *csi, size_t introlen,
-	termkey_key_t *key, int force, size_t *nbytep)
+static termo_result_t
+peekkey_ss3 (termo_t *tk, termo_csi_t *csi, size_t introlen,
+	termo_key_t *key, int force, size_t *nbytep)
 {
 	(void) csi;
 
 	if (tk->buffcount < introlen + 1)
 	{
 		if (!force)
-			return TERMKEY_RES_AGAIN;
+			return TERMO_RES_AGAIN;
 
 		(*tk->method.emit_codepoint) (tk, 'O', key);
-		key->modifiers |= TERMKEY_KEYMOD_ALT;
+		key->modifiers |= TERMO_KEYMOD_ALT;
 		*nbytep = tk->buffcount;
-		return TERMKEY_RES_KEY;
+		return TERMO_RES_KEY;
 	}
 
 	unsigned char cmd = CHARAT (introlen);
 
 	if (cmd < 0x40 || cmd >= 0x80)
-		return TERMKEY_RES_NONE;
+		return TERMO_RES_NONE;
 
 	key->type      = csi_ss3s[cmd - 0x40].type;
 	key->code.sym  = csi_ss3s[cmd - 0x40].sym;
 	key->modifiers = csi_ss3s[cmd - 0x40].modifier_set;
 
-	if (key->code.sym == TERMKEY_SYM_UNKNOWN)
+	if (key->code.sym == TERMO_SYM_UNKNOWN)
 	{
-		if (tk->flags & TERMKEY_FLAG_CONVERTKP && ss3_kpalts[cmd - 0x40])
+		if (tk->flags & TERMO_FLAG_CONVERTKP && ss3_kpalts[cmd - 0x40])
 		{
-			key->type = TERMKEY_TYPE_KEY;
+			key->type = TERMO_TYPE_KEY;
 			key->code.codepoint = ss3_kpalts[cmd - 0x40];
 			key->modifiers = 0;
 
@@ -718,26 +718,26 @@ peekkey_ss3 (termkey_t *tk, termkey_csi_t *csi, size_t introlen,
 		}
 	}
 
-	if (key->code.sym == TERMKEY_SYM_UNKNOWN)
+	if (key->code.sym == TERMO_SYM_UNKNOWN)
 	{
 #ifdef DEBUG
 		fprintf (stderr, "CSI: Unknown SS3 %c (0x%02x)\n", (char) cmd, cmd);
 #endif
-		return TERMKEY_RES_NONE;
+		return TERMO_RES_NONE;
 	}
 
 	*nbytep = introlen + 1;
-	return TERMKEY_RES_KEY;
+	return TERMO_RES_KEY;
 }
 
-static termkey_result_t
-peekkey (termkey_t *tk, void *info,
-	termkey_key_t *key, int force, size_t *nbytep)
+static termo_result_t
+peekkey (termo_t *tk, void *info,
+	termo_key_t *key, int force, size_t *nbytep)
 {
 	if (tk->buffcount == 0)
-		return tk->is_closed ? TERMKEY_RES_EOF : TERMKEY_RES_NONE;
+		return tk->is_closed ? TERMO_RES_EOF : TERMO_RES_NONE;
 
-	termkey_csi_t *csi = info;
+	termo_csi_t *csi = info;
 
 	// Now we're sure at least 1 byte is valid
 	unsigned char b0 = CHARAT (0);
@@ -750,10 +750,10 @@ peekkey (termkey_t *tk, void *info,
 		return peekkey_ss3 (tk, csi, 1, key, force, nbytep);
 	if (b0 == 0x9b)
 		return peekkey_csi (tk, csi, 1, key, force, nbytep);
-	return TERMKEY_RES_NONE;
+	return TERMO_RES_NONE;
 }
 
-termkey_driver_t termkey_driver_csi =
+termo_driver_t termo_driver_csi =
 {
 	.name        = "CSI",
 	.new_driver  = new_driver,
diff --git a/driver-ti.c b/driver-ti.c
index 1b026fa..80b5d98 100644
--- a/driver-ti.c
+++ b/driver-ti.c
@@ -1,8 +1,8 @@
 // we want strdup()
 #define _XOPEN_SOURCE 600
 
-#include "termkey2.h"
-#include "termkey2-internal.h"
+#include "termo.h"
+#include "termo-internal.h"
 
 #ifdef HAVE_UNIBILIUM
 # include <unibilium.h>
@@ -53,7 +53,7 @@ trie_node_array_t;
 
 typedef struct
 {
-	termkey_t *tk;
+	termo_t *tk;
 	trie_node_t *root;
 
 	char *start_string;
@@ -62,14 +62,14 @@ typedef struct
 	bool have_mouse;
 	char *set_mouse_string;
 }
-termkey_ti_t;
+termo_ti_t;
 
-static int funcname2keysym (const char *funcname, termkey_type_t *typep,
-	termkey_sym_t *symp, int *modmask, int *modsetp);
-static int insert_seq (termkey_ti_t *ti, const char *seq, trie_node_t *node);
+static int funcname2keysym (const char *funcname, termo_type_t *typep,
+	termo_sym_t *symp, int *modmask, int *modsetp);
+static int insert_seq (termo_ti_t *ti, const char *seq, trie_node_t *node);
 
 static trie_node_t *
-new_node_key (termkey_type_t type, termkey_sym_t sym, int modmask, int modset)
+new_node_key (termo_type_t type, termo_sym_t sym, int modmask, int modset)
 {
 	trie_node_key_t *n = malloc (sizeof *n);
 	if (!n)
@@ -176,7 +176,7 @@ compress_trie (struct trie_node *n)
 }
 
 static bool
-load_terminfo (termkey_ti_t *ti, const char *term)
+load_terminfo (termo_ti_t *ti, const char *term)
 {
 	const char *mouse_report_string = NULL;
 
@@ -212,15 +212,15 @@ load_terminfo (termkey_ti_t *ti, const char *term)
 			mouse_report_string = value;
 		else
 		{
-			termkey_type_t type;
-			termkey_sym_t sym;
+			termo_type_t type;
+			termo_sym_t sym;
 			int mask = 0;
 			int set = 0;
 
 			if (!funcname2keysym (name + 4, &type, &sym, &mask, &set))
 				continue;
 
-			if (sym == TERMKEY_SYM_NONE)
+			if (sym == TERMO_SYM_NONE)
 				continue;
 
 			node = new_node_key (type, sym, mask, set);
@@ -262,7 +262,7 @@ load_terminfo (termkey_ti_t *ti, const char *term)
 		}
 	}
 
-	/* Take copies of these terminfo strings, in case we build multiple termkey
+	/* Take copies of these terminfo strings, in case we build multiple termo
 	 * instances for multiple different termtypes, and it's different by the
 	 * time we want to use it
 	 */
@@ -292,9 +292,9 @@ load_terminfo (termkey_ti_t *ti, const char *term)
 }
 
 static void *
-new_driver (termkey_t *tk, const char *term)
+new_driver (termo_t *tk, const char *term)
 {
-	termkey_ti_t *ti = calloc (1, sizeof *ti);
+	termo_ti_t *ti = calloc (1, sizeof *ti);
 	if (!ti)
 		return NULL;
 
@@ -318,7 +318,7 @@ abort_free_ti:
 }
 
 static bool
-write_string (termkey_t *tk, char *string)
+write_string (termo_t *tk, char *string)
 {
 	if (tk->fd == -1 || !isatty (tk->fd) || !string)
 		return true;
@@ -340,7 +340,7 @@ write_string (termkey_t *tk, char *string)
 }
 
 static bool
-set_mouse (termkey_ti_t *ti, bool enable)
+set_mouse (termo_ti_t *ti, bool enable)
 {
 #ifdef HAVE_UNIBILIUM
 	unibi_var_t params[9] = { enable, 0, 0, 0, 0, 0, 0, 0, 0 };
@@ -355,9 +355,9 @@ set_mouse (termkey_ti_t *ti, bool enable)
 }
 
 static int
-start_driver (termkey_t *tk, void *info)
+start_driver (termo_t *tk, void *info)
 {
-	termkey_ti_t *ti = info;
+	termo_ti_t *ti = info;
 	// TODO: Don't start the mouse automatically, find a nice place to put
 	//   a public function to be called by users.
 	// TODO: Try to autodetect rxvt and use its protocol instead of mode 1000
@@ -368,9 +368,9 @@ start_driver (termkey_t *tk, void *info)
 }
 
 static int
-stop_driver (termkey_t *tk, void *info)
+stop_driver (termo_t *tk, void *info)
 {
-	termkey_ti_t *ti = info;
+	termo_ti_t *ti = info;
 	if (ti->have_mouse && !set_mouse (ti, false))
 		return false;
 	return write_string (tk, ti->stop_string);
@@ -379,7 +379,7 @@ stop_driver (termkey_t *tk, void *info)
 static void
 free_driver (void *info)
 {
-	termkey_ti_t *ti = info;
+	termo_ti_t *ti = info;
 	free_trie (ti->root);
 	free (ti->set_mouse_string);
 	free (ti->start_string);
@@ -389,14 +389,14 @@ free_driver (void *info)
 
 #define CHARAT(i) (tk->buffer[tk->buffstart + (i)])
 
-static termkey_result_t
-peekkey (termkey_t *tk, void *info,
-	termkey_key_t *key, int force, size_t *nbytep)
+static termo_result_t
+peekkey (termo_t *tk, void *info,
+	termo_key_t *key, int force, size_t *nbytep)
 {
-	termkey_ti_t *ti = info;
+	termo_ti_t *ti = info;
 
 	if (tk->buffcount == 0)
-		return tk->is_closed ? TERMKEY_RES_EOF : TERMKEY_RES_NONE;
+		return tk->is_closed ? TERMO_RES_EOF : TERMO_RES_NONE;
 
 	trie_node_t *p = ti->root;
 	unsigned int pos = 0;
@@ -415,20 +415,20 @@ peekkey (termkey_t *tk, void *info,
 			key->code.sym  = nk->key.sym;
 			key->modifiers = nk->key.modifier_set;
 			*nbytep = pos;
-			return TERMKEY_RES_KEY;
+			return TERMO_RES_KEY;
 		}
 		else if (p->type == TYPE_MOUSE)
 		{
 			tk->buffstart += pos;
 			tk->buffcount -= pos;
 
-			termkey_result_t mouse_result =
+			termo_result_t mouse_result =
 				(*tk->method.peekkey_mouse) (tk, key, nbytep);
 
 			tk->buffstart -= pos;
 			tk->buffcount += pos;
 
-			if (mouse_result == TERMKEY_RES_KEY)
+			if (mouse_result == TERMO_RES_KEY)
 				*nbytep += pos;
 
 			return mouse_result;
@@ -438,65 +438,65 @@ peekkey (termkey_t *tk, void *info,
 	// If p is not NULL then we hadn't walked off the end yet, so we have a
 	// partial match
 	if (p && !force)
-		return TERMKEY_RES_AGAIN;
+		return TERMO_RES_AGAIN;
 
-	return TERMKEY_RES_NONE;
+	return TERMO_RES_NONE;
 }
 
 static struct func
 {
 	const char *funcname;
-	termkey_type_t type;
-	termkey_sym_t sym;
+	termo_type_t type;
+	termo_sym_t sym;
 	int mods;
 }
 funcs[] =
 {
 	/* THIS LIST MUST REMAIN SORTED! */
-	{ "backspace", TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_BACKSPACE, 0 },
-	{ "begin",     TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_BEGIN,     0 },
-	{ "beg",       TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_BEGIN,     0 },
-	{ "btab",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_TAB,       TERMKEY_KEYMOD_SHIFT },
-	{ "cancel",    TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_CANCEL,    0 },
-	{ "clear",     TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_CLEAR,     0 },
-	{ "close",     TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_CLOSE,     0 },
-	{ "command",   TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_COMMAND,   0 },
-	{ "copy",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_COPY,      0 },
-	{ "dc",        TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_DELETE,    0 },
-	{ "down",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_DOWN,      0 },
-	{ "end",       TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_END,       0 },
-	{ "enter",     TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_ENTER,     0 },
-	{ "exit",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_EXIT,      0 },
-	{ "find",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_FIND,      0 },
-	{ "help",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_HELP,      0 },
-	{ "home",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_HOME,      0 },
-	{ "ic",        TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_INSERT,    0 },
-	{ "left",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_LEFT,      0 },
-	{ "mark",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_MARK,      0 },
-	{ "message",   TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_MESSAGE,   0 },
-	{ "mouse",     TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_NONE,      0 },
-	{ "move",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_MOVE,      0 },
+	{ "backspace", TERMO_TYPE_KEYSYM, TERMO_SYM_BACKSPACE, 0 },
+	{ "begin",     TERMO_TYPE_KEYSYM, TERMO_SYM_BEGIN,     0 },
+	{ "beg",       TERMO_TYPE_KEYSYM, TERMO_SYM_BEGIN,     0 },
+	{ "btab",      TERMO_TYPE_KEYSYM, TERMO_SYM_TAB,       TERMO_KEYMOD_SHIFT },
+	{ "cancel",    TERMO_TYPE_KEYSYM, TERMO_SYM_CANCEL,    0 },
+	{ "clear",     TERMO_TYPE_KEYSYM, TERMO_SYM_CLEAR,     0 },
+	{ "close",     TERMO_TYPE_KEYSYM, TERMO_SYM_CLOSE,     0 },
+	{ "command",   TERMO_TYPE_KEYSYM, TERMO_SYM_COMMAND,   0 },
+	{ "copy",      TERMO_TYPE_KEYSYM, TERMO_SYM_COPY,      0 },
+	{ "dc",        TERMO_TYPE_KEYSYM, TERMO_SYM_DELETE,    0 },
+	{ "down",      TERMO_TYPE_KEYSYM, TERMO_SYM_DOWN,      0 },
+	{ "end",       TERMO_TYPE_KEYSYM, TERMO_SYM_END,       0 },
+	{ "enter",     TERMO_TYPE_KEYSYM, TERMO_SYM_ENTER,     0 },
+	{ "exit",      TERMO_TYPE_KEYSYM, TERMO_SYM_EXIT,      0 },
+	{ "find",      TERMO_TYPE_KEYSYM, TERMO_SYM_FIND,      0 },
+	{ "help",      TERMO_TYPE_KEYSYM, TERMO_SYM_HELP,      0 },
+	{ "home",      TERMO_TYPE_KEYSYM, TERMO_SYM_HOME,      0 },
+	{ "ic",        TERMO_TYPE_KEYSYM, TERMO_SYM_INSERT,    0 },
+	{ "left",      TERMO_TYPE_KEYSYM, TERMO_SYM_LEFT,      0 },
+	{ "mark",      TERMO_TYPE_KEYSYM, TERMO_SYM_MARK,      0 },
+	{ "message",   TERMO_TYPE_KEYSYM, TERMO_SYM_MESSAGE,   0 },
+	{ "mouse",     TERMO_TYPE_KEYSYM, TERMO_SYM_NONE,      0 },
+	{ "move",      TERMO_TYPE_KEYSYM, TERMO_SYM_MOVE,      0 },
 	// Not quite, but it's the best we can do
-	{ "next",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_PAGEDOWN,  0 },
-	{ "npage",     TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_PAGEDOWN,  0 },
-	{ "open",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_OPEN,      0 },
-	{ "options",   TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_OPTIONS,   0 },
-	{ "ppage",     TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_PAGEUP,    0 },
+	{ "next",      TERMO_TYPE_KEYSYM, TERMO_SYM_PAGEDOWN,  0 },
+	{ "npage",     TERMO_TYPE_KEYSYM, TERMO_SYM_PAGEDOWN,  0 },
+	{ "open",      TERMO_TYPE_KEYSYM, TERMO_SYM_OPEN,      0 },
+	{ "options",   TERMO_TYPE_KEYSYM, TERMO_SYM_OPTIONS,   0 },
+	{ "ppage",     TERMO_TYPE_KEYSYM, TERMO_SYM_PAGEUP,    0 },
 	// Not quite, but it's the best we can do
-	{ "previous",  TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_PAGEUP,    0 },
-	{ "print",     TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_PRINT,     0 },
-	{ "redo",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_REDO,      0 },
-	{ "reference", TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_REFERENCE, 0 },
-	{ "refresh",   TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_REFRESH,   0 },
-	{ "replace",   TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_REPLACE,   0 },
-	{ "restart",   TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_RESTART,   0 },
-	{ "resume",    TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_RESUME,    0 },
-	{ "right",     TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_RIGHT,     0 },
-	{ "save",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_SAVE,      0 },
-	{ "select",    TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_SELECT,    0 },
-	{ "suspend",   TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_SUSPEND,   0 },
-	{ "undo",      TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_UNDO,      0 },
-	{ "up",        TERMKEY_TYPE_KEYSYM, TERMKEY_SYM_UP,        0 },
+	{ "previous",  TERMO_TYPE_KEYSYM, TERMO_SYM_PAGEUP,    0 },
+	{ "print",     TERMO_TYPE_KEYSYM, TERMO_SYM_PRINT,     0 },
+	{ "redo",      TERMO_TYPE_KEYSYM, TERMO_SYM_REDO,      0 },
+	{ "reference", TERMO_TYPE_KEYSYM, TERMO_SYM_REFERENCE, 0 },
+	{ "refresh",   TERMO_TYPE_KEYSYM, TERMO_SYM_REFRESH,   0 },
+	{ "replace",   TERMO_TYPE_KEYSYM, TERMO_SYM_REPLACE,   0 },
+	{ "restart",   TERMO_TYPE_KEYSYM, TERMO_SYM_RESTART,   0 },
+	{ "resume",    TERMO_TYPE_KEYSYM, TERMO_SYM_RESUME,    0 },
+	{ "right",     TERMO_TYPE_KEYSYM, TERMO_SYM_RIGHT,     0 },
+	{ "save",      TERMO_TYPE_KEYSYM, TERMO_SYM_SAVE,      0 },
+	{ "select",    TERMO_TYPE_KEYSYM, TERMO_SYM_SELECT,    0 },
+	{ "suspend",   TERMO_TYPE_KEYSYM, TERMO_SYM_SUSPEND,   0 },
+	{ "undo",      TERMO_TYPE_KEYSYM, TERMO_SYM_UNDO,      0 },
+	{ "up",        TERMO_TYPE_KEYSYM, TERMO_SYM_UP,        0 },
 	{ NULL },
 };
 
@@ -508,7 +508,7 @@ func_compare (const void *key, const void *element)
 
 static int
 funcname2keysym (const char *funcname,
-	termkey_type_t *typep, termkey_sym_t *symp, int *modmaskp, int *modsetp)
+	termo_type_t *typep, termo_sym_t *symp, int *modmaskp, int *modsetp)
 {
 	struct func *func = bsearch (funcname, funcs,
 		sizeof funcs / sizeof funcs[0], sizeof funcs[0], func_compare);
@@ -523,7 +523,7 @@ funcname2keysym (const char *funcname,
 
 	if (funcname[0] == 'f' && isdigit (funcname[1]))
 	{
-		*typep = TERMKEY_TYPE_FUNCTION;
+		*typep = TERMO_TYPE_FUNCTION;
 		*symp  = atoi (funcname + 1);
 		return 1;
 	}
@@ -532,8 +532,8 @@ funcname2keysym (const char *funcname,
 	if (funcname[0] == 's' && funcname2keysym
 		(funcname + 1, typep, symp, modmaskp, modsetp))
 	{
-		*modmaskp |= TERMKEY_KEYMOD_SHIFT;
-		*modsetp  |= TERMKEY_KEYMOD_SHIFT;
+		*modmaskp |= TERMO_KEYMOD_SHIFT;
+		*modsetp  |= TERMO_KEYMOD_SHIFT;
 		return 1;
 	}
 
@@ -546,7 +546,7 @@ funcname2keysym (const char *funcname,
 }
 
 static int
-insert_seq (termkey_ti_t *ti, const char *seq, trie_node_t *node)
+insert_seq (termo_ti_t *ti, const char *seq, trie_node_t *node)
 {
 	int pos = 0;
 	trie_node_t *p = ti->root;
@@ -603,7 +603,7 @@ insert_seq (termkey_ti_t *ti, const char *seq, trie_node_t *node)
 	return 1;
 }
 
-termkey_driver_t termkey_driver_ti =
+termo_driver_t termo_driver_ti =
 {
 	.name         = "terminfo",
 	.new_driver   = new_driver,
diff --git a/termkey2-config.h.in b/termkey2-config.h.in
deleted file mode 100644
index 676a2c0..0000000
--- a/termkey2-config.h.in
+++ /dev/null
@@ -1,8 +0,0 @@
-#ifndef TERMKEY2_CONFIG_H
-#define TERMKEY2_CONFIG_H
-
-#define TERMKEY_VERSION_MAJOR @project_VERSION_MAJOR@
-#define TERMKEY_VERSION_MINOR @project_VERSION_MINOR@
-
-#endif  // ! TERMKEY2_CONFIG_H
-
diff --git a/termkey2.h b/termkey2.h
deleted file mode 100644
index 0fa0635..0000000
--- a/termkey2.h
+++ /dev/null
@@ -1,277 +0,0 @@
-#ifndef TERMKEY2_H
-#define TERMKEY2_H
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <limits.h>
-
-#include "termkey2-config.h"
-
-#define TERMKEY_CHECK_VERSION \
-	termkey_check_version (TERMKEY_VERSION_MAJOR, TERMKEY_VERSION_MINOR)
-
-typedef enum termkey_sym termkey_sym_t;
-enum termkey_sym
-{
-	TERMKEY_SYM_UNKNOWN = -1,
-	TERMKEY_SYM_NONE = 0,
-
-	/* Special names in C0 */
-	TERMKEY_SYM_BACKSPACE,
-	TERMKEY_SYM_TAB,
-	TERMKEY_SYM_ENTER,
-	TERMKEY_SYM_ESCAPE,
-
-	/* Special names in G0 */
-	TERMKEY_SYM_SPACE,
-	TERMKEY_SYM_DEL,
-
-	/* Special keys */
-	TERMKEY_SYM_UP,
-	TERMKEY_SYM_DOWN,
-	TERMKEY_SYM_LEFT,
-	TERMKEY_SYM_RIGHT,
-	TERMKEY_SYM_BEGIN,
-	TERMKEY_SYM_FIND,
-	TERMKEY_SYM_INSERT,
-	TERMKEY_SYM_DELETE,
-	TERMKEY_SYM_SELECT,
-	TERMKEY_SYM_PAGEUP,
-	TERMKEY_SYM_PAGEDOWN,
-	TERMKEY_SYM_HOME,
-	TERMKEY_SYM_END,
-
-	/* Special keys from terminfo */
-	TERMKEY_SYM_CANCEL,
-	TERMKEY_SYM_CLEAR,
-	TERMKEY_SYM_CLOSE,
-	TERMKEY_SYM_COMMAND,
-	TERMKEY_SYM_COPY,
-	TERMKEY_SYM_EXIT,
-	TERMKEY_SYM_HELP,
-	TERMKEY_SYM_MARK,
-	TERMKEY_SYM_MESSAGE,
-	TERMKEY_SYM_MOVE,
-	TERMKEY_SYM_OPEN,
-	TERMKEY_SYM_OPTIONS,
-	TERMKEY_SYM_PRINT,
-	TERMKEY_SYM_REDO,
-	TERMKEY_SYM_REFERENCE,
-	TERMKEY_SYM_REFRESH,
-	TERMKEY_SYM_REPLACE,
-	TERMKEY_SYM_RESTART,
-	TERMKEY_SYM_RESUME,
-	TERMKEY_SYM_SAVE,
-	TERMKEY_SYM_SUSPEND,
-	TERMKEY_SYM_UNDO,
-
-	/* Numeric keypad special keys */
-	TERMKEY_SYM_KP0,
-	TERMKEY_SYM_KP1,
-	TERMKEY_SYM_KP2,
-	TERMKEY_SYM_KP3,
-	TERMKEY_SYM_KP4,
-	TERMKEY_SYM_KP5,
-	TERMKEY_SYM_KP6,
-	TERMKEY_SYM_KP7,
-	TERMKEY_SYM_KP8,
-	TERMKEY_SYM_KP9,
-	TERMKEY_SYM_KPENTER,
-	TERMKEY_SYM_KPPLUS,
-	TERMKEY_SYM_KPMINUS,
-	TERMKEY_SYM_KPMULT,
-	TERMKEY_SYM_KPDIV,
-	TERMKEY_SYM_KPCOMMA,
-	TERMKEY_SYM_KPPERIOD,
-	TERMKEY_SYM_KPEQUALS,
-
-	TERMKEY_N_SYMS
-};
-
-typedef enum termkey_type termkey_type_t;
-enum termkey_type
-{
-	TERMKEY_TYPE_KEY,
-	TERMKEY_TYPE_FUNCTION,
-	TERMKEY_TYPE_KEYSYM,
-	TERMKEY_TYPE_MOUSE,
-	TERMKEY_TYPE_POSITION,
-	TERMKEY_TYPE_MODEREPORT,
-	/* add other recognised types here */
-
-	TERMKEY_TYPE_UNKNOWN_CSI = -1
-};
-
-typedef enum termkey_result termkey_result_t;
-enum termkey_result
-{
-	TERMKEY_RES_NONE,
-	TERMKEY_RES_KEY,
-	TERMKEY_RES_EOF,
-	TERMKEY_RES_AGAIN,
-	TERMKEY_RES_ERROR
-};
-
-typedef enum termkey_mouse_event termkey_mouse_event_t;
-enum termkey_mouse_event
-{
-	TERMKEY_MOUSE_UNKNOWN,
-	TERMKEY_MOUSE_PRESS,
-	TERMKEY_MOUSE_DRAG,
-	TERMKEY_MOUSE_RELEASE
-};
-
-enum
-{
-	TERMKEY_KEYMOD_SHIFT = 1 << 0,
-	TERMKEY_KEYMOD_ALT   = 1 << 1,
-	TERMKEY_KEYMOD_CTRL  = 1 << 2
-};
-
-typedef struct termkey_key termkey_key_t;
-struct termkey_key
-{
-	termkey_type_t type;
-	union
-	{
-		uint32_t      codepoint; /* TERMKEY_TYPE_KEY */
-		int           number;    /* TERMKEY_TYPE_FUNCTION */
-		termkey_sym_t sym;       /* TERMKEY_TYPE_KEYSYM */
-
-		/* TERMKEY_TYPE_MODEREPORT */
-		/* opaque, see termkey_interpret_modereport() */
-		struct { char initial; int mode, value; } mode;
-
-		/* TERMKEY_TYPE_MOUSE */
-		/* opaque, see termkey_interpret_mouse() */
-		struct { uint16_t x, y, info; } mouse;
-	} code;
-
-	int modifiers;
-
-	/* The raw multibyte sequence for the key */
-	char multibyte[MB_LEN_MAX + 1];
-};
-
-typedef struct termkey termkey_t;
-
-enum
-{
-	/* Do not interpret C0//DEL codes if possible */
-	TERMKEY_FLAG_NOINTERPRET = 1 << 0,
-	/* Convert KP codes to regular keypresses */
-	TERMKEY_FLAG_CONVERTKP   = 1 << 1,
-	/* Don't try to decode the input characters */
-	TERMKEY_FLAG_RAW         = 1 << 2,
-	/* Do not make initial termios calls on construction */
-	TERMKEY_FLAG_NOTERMIOS   = 1 << 4,
-	/* Sets TERMKEY_CANON_SPACESYMBOL */
-	TERMKEY_FLAG_SPACESYMBOL = 1 << 5,
-	/* Allow Ctrl-C to be read as normal, disabling SIGINT */
-	TERMKEY_FLAG_CTRLC       = 1 << 6,
-	/* Return ERROR on signal (EINTR) rather than retry */
-	TERMKEY_FLAG_EINTR       = 1 << 7
-};
-
-enum
-{
-	TERMKEY_CANON_SPACESYMBOL = 1 << 0, /* Space is symbolic rather than Unicode */
-	TERMKEY_CANON_DELBS       = 1 << 1  /* Del is converted to Backspace */
-};
-
-void termkey_check_version (int major, int minor);
-
-termkey_t *termkey_new (int fd, const char *encoding, int flags);
-termkey_t *termkey_new_abstract (const char *term,
-	const char *encoding, int flags);
-void termkey_free (termkey_t *tk);
-void termkey_destroy (termkey_t *tk);
-
-int termkey_start (termkey_t *tk);
-int termkey_stop (termkey_t *tk);
-int termkey_is_started (termkey_t *tk);
-
-int termkey_get_fd (termkey_t *tk);
-
-int termkey_get_flags (termkey_t *tk);
-void termkey_set_flags (termkey_t *tk, int newflags);
-
-int termkey_get_waittime (termkey_t *tk);
-void termkey_set_waittime (termkey_t *tk, int msec);
-
-int termkey_get_canonflags (termkey_t *tk);
-void termkey_set_canonflags (termkey_t *tk, int flags);
-
-size_t termkey_get_buffer_size (termkey_t *tk);
-int termkey_set_buffer_size (termkey_t *tk, size_t size);
-
-size_t termkey_get_buffer_remaining (termkey_t *tk);
-
-void termkey_canonicalise (termkey_t *tk, termkey_key_t *key);
-
-termkey_result_t termkey_getkey (termkey_t *tk, termkey_key_t *key);
-termkey_result_t termkey_getkey_force (termkey_t *tk, termkey_key_t *key);
-termkey_result_t termkey_waitkey (termkey_t *tk, termkey_key_t *key);
-
-termkey_result_t termkey_advisereadable (termkey_t *tk);
-
-size_t termkey_push_bytes (termkey_t *tk, const char *bytes, size_t len);
-
-termkey_sym_t termkey_register_keyname (termkey_t *tk,
-	termkey_sym_t sym, const char *name);
-const char *termkey_get_keyname (termkey_t *tk, termkey_sym_t sym);
-const char *termkey_lookup_keyname (termkey_t *tk,
-	const char *str, termkey_sym_t *sym);
-
-termkey_sym_t termkey_keyname2sym (termkey_t *tk, const char *keyname);
-
-termkey_result_t termkey_interpret_mouse (termkey_t *tk,
-	const termkey_key_t *key, termkey_mouse_event_t *event,
-	int *button, int *line, int *col);
-termkey_result_t termkey_interpret_position (termkey_t *tk,
-	const termkey_key_t *key, int *line, int *col);
-termkey_result_t termkey_interpret_modereport (termkey_t *tk,
-	const termkey_key_t *key, int *initial, int *mode, int *value);
-termkey_result_t termkey_interpret_csi (termkey_t *tk,
-	const termkey_key_t *key, long args[], size_t *nargs, unsigned long *cmd);
-
-typedef enum termkey_format termkey_format_t;
-enum termkey_format
-{
-	/* Shift-... instead of S-... */
-	TERMKEY_FORMAT_LONGMOD     = 1 << 0,
-	/* ^X instead of C-X */
-	TERMKEY_FORMAT_CARETCTRL   = 1 << 1,
-	/* Meta- or M- instead of Alt- or A- */
-	TERMKEY_FORMAT_ALTISMETA   = 1 << 2,
-	/* Wrap special keys in brackets like <Escape> */
-	TERMKEY_FORMAT_WRAPBRACKET = 1 << 3,
-	/* M Foo instead of M-Foo */
-	TERMKEY_FORMAT_SPACEMOD    = 1 << 4,
-	/* meta or m instead of Meta or M */
-	TERMKEY_FORMAT_LOWERMOD    = 1 << 5,
-	/* page down instead of PageDown */
-	TERMKEY_FORMAT_LOWERSPACE  = 1 << 6,
-	/* Include mouse position if relevant; @ col,line */
-	TERMKEY_FORMAT_MOUSE_POS   = 1 << 8
-};
-
-/* Some useful combinations */
-
-#define TERMKEY_FORMAT_VIM (termkey_format_t) \
-	(TERMKEY_FORMAT_ALTISMETA | TERMKEY_FORMAT_WRAPBRACKET)
-#define TERMKEY_FORMAT_URWID (termkey_format_t) \
-	(TERMKEY_FORMAT_LONGMOD | TERMKEY_FORMAT_ALTISMETA | \
-	 TERMKEY_FORMAT_LOWERMOD | TERMKEY_FORMAT_SPACEMOD | \
-	 TERMKEY_FORMAT_LOWERSPACE)
-
-size_t termkey_strfkey (termkey_t *tk, char *buffer, size_t len,
-	termkey_key_t *key, termkey_format_t format);
-const char *termkey_strpkey (termkey_t *tk, const char *str,
-	termkey_key_t *key, termkey_format_t format);
-
-int termkey_keycmp (termkey_t *tk,
-	const termkey_key_t *key1, const termkey_key_t *key2);
-
-#endif  // ! TERMKEY2_H
-
diff --git a/termo-config.h.in b/termo-config.h.in
new file mode 100644
index 0000000..780927a
--- /dev/null
+++ b/termo-config.h.in
@@ -0,0 +1,8 @@
+#ifndef TERMO_CONFIG_H
+#define TERMO_CONFIG_H
+
+#define TERMO_VERSION_MAJOR @project_VERSION_MAJOR@
+#define TERMO_VERSION_MINOR @project_VERSION_MINOR@
+
+#endif  // ! TERMO_CONFIG_H
+
diff --git a/termkey2-internal.h b/termo-internal.h
index 5da33ff..b9a27c2 100644
--- a/termkey2-internal.h
+++ b/termo-internal.h
@@ -1,43 +1,43 @@
-#ifndef TERMKEY2_INTERNAL_H
-#define TERMKEY2_INTERNAL_H
+#ifndef TERMO_INTERNAL_H
+#define TERMO_INTERNAL_H
 
-#include "termkey2.h"
+#include "termo.h"
 
 #include <stdint.h>
 #include <termios.h>
 #include <stdbool.h>
 #include <iconv.h>
 
-typedef struct termkey_driver termkey_driver_t;
-struct termkey_driver
+typedef struct termo_driver termo_driver_t;
+struct termo_driver
 {
 	const char *name;
-	void *(*new_driver) (termkey_t *tk, const char *term);
+	void *(*new_driver) (termo_t *tk, const char *term);
 	void (*free_driver) (void *info);
-	int (*start_driver) (termkey_t *tk, void *info);
-	int (*stop_driver) (termkey_t *tk, void *info);
-	termkey_result_t (*peekkey) (termkey_t *tk,
-		void *info, termkey_key_t *key, int force, size_t *nbytes);
+	int (*start_driver) (termo_t *tk, void *info);
+	int (*stop_driver) (termo_t *tk, void *info);
+	termo_result_t (*peekkey) (termo_t *tk,
+		void *info, termo_key_t *key, int force, size_t *nbytes);
 };
 
 typedef struct keyinfo keyinfo_t;
 struct keyinfo
 {
-	termkey_type_t type;
-	termkey_sym_t sym;
+	termo_type_t type;
+	termo_sym_t sym;
 	int modifier_mask;
 	int modifier_set;
 };
 
-typedef struct termkey_driver_node termkey_driver_node_t;
-struct termkey_driver_node
+typedef struct termo_driver_node termo_driver_node_t;
+struct termo_driver_node
 {
-	termkey_driver_t *driver;
+	termo_driver_t *driver;
 	void *info;
-	termkey_driver_node_t *next;
+	termo_driver_node_t *next;
 };
 
-struct termkey
+struct termo
 {
 	int fd;
 	int flags;
@@ -49,7 +49,7 @@ struct termkey
 	size_t buffsize; // Total malloc'ed size
 
 	// Position beyond buffstart at which peekkey() should next start.
-	// Normally 0, but see also termkey_interpret_csi().
+	// Normally 0, but see also termo_interpret_csi().
 	size_t hightide;
 
 	struct termios restore_termios;
@@ -66,24 +66,24 @@ struct termkey
 	keyinfo_t c0[32]; // There are 32 C0 codes
 	iconv_t to_utf32_conv;
 	iconv_t from_utf32_conv;
-	termkey_driver_node_t *drivers;
+	termo_driver_node_t *drivers;
 
 	// Now some "protected" methods for the driver to call but which we don't
 	// want exported as real symbols in the library
 	struct
 	{
-		void (*emit_codepoint) (termkey_t *tk,
-			uint32_t codepoint, termkey_key_t *key);
-		termkey_result_t (*peekkey_simple) (termkey_t *tk,
-			termkey_key_t *key, int force, size_t *nbytes);
-		termkey_result_t (*peekkey_mouse) (termkey_t *tk,
-			termkey_key_t *key, size_t *nbytes);
+		void (*emit_codepoint) (termo_t *tk,
+			uint32_t codepoint, termo_key_t *key);
+		termo_result_t (*peekkey_simple) (termo_t *tk,
+			termo_key_t *key, int force, size_t *nbytes);
+		termo_result_t (*peekkey_mouse) (termo_t *tk,
+			termo_key_t *key, size_t *nbytes);
 	}
 	method;
 };
 
 static inline void
-termkey_key_get_linecol (const termkey_key_t *key, int *line, int *col)
+termo_key_get_linecol (const termo_key_t *key, int *line, int *col)
 {
 	if (col)
 		*col = key->code.mouse.x;
@@ -93,7 +93,7 @@ termkey_key_get_linecol (const termkey_key_t *key, int *line, int *col)
 }
 
 static inline void
-termkey_key_set_linecol (termkey_key_t *key, int line, int col)
+termo_key_set_linecol (termo_key_t *key, int line, int col)
 {
 	if (line > UINT16_MAX)
 		line = UINT16_MAX;
@@ -105,8 +105,8 @@ termkey_key_set_linecol (termkey_key_t *key, int line, int col)
 	key->code.mouse.y = line;
 }
 
-extern termkey_driver_t termkey_driver_csi;
-extern termkey_driver_t termkey_driver_ti;
+extern termo_driver_t termo_driver_csi;
+extern termo_driver_t termo_driver_ti;
 
-#endif  // ! TERMKEY2_INTERNAL_H
+#endif  // ! TERMO_INTERNAL_H
 
diff --git a/termkey2.c b/termo.c
index 37831b8..9f23158 100644
--- a/termkey2.c
+++ b/termo.c
@@ -1,5 +1,5 @@
-#include "termkey2.h"
-#include "termkey2-internal.h"
+#include "termo.h"
+#include "termo-internal.h"
 
 #include <ctype.h>
 #include <errno.h>
@@ -12,107 +12,107 @@
 #include <stdio.h>
 
 void
-termkey_check_version (int major, int minor)
+termo_check_version (int major, int minor)
 {
-	if (major != TERMKEY_VERSION_MAJOR)
-		fprintf (stderr, "libtermkey major version mismatch;"
+	if (major != TERMO_VERSION_MAJOR)
+		fprintf (stderr, "libtermo major version mismatch;"
 			" %d (wants) != %d (library)\n",
-			major, TERMKEY_VERSION_MAJOR);
-	else if (minor > TERMKEY_VERSION_MINOR)
-		fprintf (stderr, "libtermkey minor version mismatch;"
+			major, TERMO_VERSION_MAJOR);
+	else if (minor > TERMO_VERSION_MINOR)
+		fprintf (stderr, "libtermo minor version mismatch;"
 			" %d (wants) > %d (library)\n",
-			minor, TERMKEY_VERSION_MINOR);
+			minor, TERMO_VERSION_MINOR);
 	else
 		return;
 	exit (1);
 }
 
-static termkey_driver_t *drivers[] =
+static termo_driver_t *drivers[] =
 {
-	&termkey_driver_ti,
-	&termkey_driver_csi,
+	&termo_driver_ti,
+	&termo_driver_csi,
 	NULL,
 };
 
 // Forwards for the "protected" methods
-static void emit_codepoint (termkey_t *tk, uint32_t codepoint, termkey_key_t *key);
-static termkey_result_t peekkey_simple (termkey_t *tk,
-	termkey_key_t *key, int force, size_t *nbytes);
-static termkey_result_t peekkey_mouse (termkey_t *tk,
-	termkey_key_t *key, size_t *nbytes);
+static void emit_codepoint (termo_t *tk, uint32_t codepoint, termo_key_t *key);
+static termo_result_t peekkey_simple (termo_t *tk,
+	termo_key_t *key, int force, size_t *nbytes);
+static termo_result_t peekkey_mouse (termo_t *tk,
+	termo_key_t *key, size_t *nbytes);
 
-static termkey_sym_t register_c0 (termkey_t *tk, termkey_sym_t sym,
+static termo_sym_t register_c0 (termo_t *tk, termo_sym_t sym,
 	unsigned char ctrl, const char *name);
-static termkey_sym_t register_c0_full (termkey_t *tk, termkey_sym_t sym,
+static termo_sym_t register_c0_full (termo_t *tk, termo_sym_t sym,
 	int modifier_set, int modifier_mask, unsigned char ctrl, const char *name);
 
 static struct
 {
-	termkey_sym_t sym;
+	termo_sym_t sym;
 	const char *name;
 }
 keynames[] =
 {
-	{ TERMKEY_SYM_NONE,      "NONE"      },
-	{ TERMKEY_SYM_BACKSPACE, "Backspace" },
-	{ TERMKEY_SYM_TAB,       "Tab"       },
-	{ TERMKEY_SYM_ENTER,     "Enter"     },
-	{ TERMKEY_SYM_ESCAPE,    "Escape"    },
-	{ TERMKEY_SYM_SPACE,     "Space"     },
-	{ TERMKEY_SYM_DEL,       "DEL"       },
-	{ TERMKEY_SYM_UP,        "Up"        },
-	{ TERMKEY_SYM_DOWN,      "Down"      },
-	{ TERMKEY_SYM_LEFT,      "Left"      },
-	{ TERMKEY_SYM_RIGHT,     "Right"     },
-	{ TERMKEY_SYM_BEGIN,     "Begin"     },
-	{ TERMKEY_SYM_FIND,      "Find"      },
-	{ TERMKEY_SYM_INSERT,    "Insert"    },
-	{ TERMKEY_SYM_DELETE,    "Delete"    },
-	{ TERMKEY_SYM_SELECT,    "Select"    },
-	{ TERMKEY_SYM_PAGEUP,    "PageUp"    },
-	{ TERMKEY_SYM_PAGEDOWN,  "PageDown"  },
-	{ TERMKEY_SYM_HOME,      "Home"      },
-	{ TERMKEY_SYM_END,       "End"       },
-	{ TERMKEY_SYM_CANCEL,    "Cancel"    },
-	{ TERMKEY_SYM_CLEAR,     "Clear"     },
-	{ TERMKEY_SYM_CLOSE,     "Close"     },
-	{ TERMKEY_SYM_COMMAND,   "Command"   },
-	{ TERMKEY_SYM_COPY,      "Copy"      },
-	{ TERMKEY_SYM_EXIT,      "Exit"      },
-	{ TERMKEY_SYM_HELP,      "Help"      },
-	{ TERMKEY_SYM_MARK,      "Mark"      },
-	{ TERMKEY_SYM_MESSAGE,   "Message"   },
-	{ TERMKEY_SYM_MOVE,      "Move"      },
-	{ TERMKEY_SYM_OPEN,      "Open"      },
-	{ TERMKEY_SYM_OPTIONS,   "Options"   },
-	{ TERMKEY_SYM_PRINT,     "Print"     },
-	{ TERMKEY_SYM_REDO,      "Redo"      },
-	{ TERMKEY_SYM_REFERENCE, "Reference" },
-	{ TERMKEY_SYM_REFRESH,   "Refresh"   },
-	{ TERMKEY_SYM_REPLACE,   "Replace"   },
-	{ TERMKEY_SYM_RESTART,   "Restart"   },
-	{ TERMKEY_SYM_RESUME,    "Resume"    },
-	{ TERMKEY_SYM_SAVE,      "Save"      },
-	{ TERMKEY_SYM_SUSPEND,   "Suspend"   },
-	{ TERMKEY_SYM_UNDO,      "Undo"      },
-	{ TERMKEY_SYM_KP0,       "KP0"       },
-	{ TERMKEY_SYM_KP1,       "KP1"       },
-	{ TERMKEY_SYM_KP2,       "KP2"       },
-	{ TERMKEY_SYM_KP3,       "KP3"       },
-	{ TERMKEY_SYM_KP4,       "KP4"       },
-	{ TERMKEY_SYM_KP5,       "KP5"       },
-	{ TERMKEY_SYM_KP6,       "KP6"       },
-	{ TERMKEY_SYM_KP7,       "KP7"       },
-	{ TERMKEY_SYM_KP8,       "KP8"       },
-	{ TERMKEY_SYM_KP9,       "KP9"       },
-	{ TERMKEY_SYM_KPENTER,   "KPEnter"   },
-	{ TERMKEY_SYM_KPPLUS,    "KPPlus"    },
-	{ TERMKEY_SYM_KPMINUS,   "KPMinus"   },
-	{ TERMKEY_SYM_KPMULT,    "KPMult"    },
-	{ TERMKEY_SYM_KPDIV,     "KPDiv"     },
-	{ TERMKEY_SYM_KPCOMMA,   "KPComma"   },
-	{ TERMKEY_SYM_KPPERIOD,  "KPPeriod"  },
-	{ TERMKEY_SYM_KPEQUALS,  "KPEquals"  },
+	{ TERMO_SYM_NONE,      "NONE"      },
+	{ TERMO_SYM_BACKSPACE, "Backspace" },
+	{ TERMO_SYM_TAB,       "Tab"       },
+	{ TERMO_SYM_ENTER,     "Enter"     },
+	{ TERMO_SYM_ESCAPE,    "Escape"    },
+	{ TERMO_SYM_SPACE,     "Space"     },
+	{ TERMO_SYM_DEL,       "DEL"       },
+	{ TERMO_SYM_UP,        "Up"        },
+	{ TERMO_SYM_DOWN,      "Down"      },
+	{ TERMO_SYM_LEFT,      "Left"      },
+	{ TERMO_SYM_RIGHT,     "Right"     },
+	{ TERMO_SYM_BEGIN,     "Begin"     },
+	{ TERMO_SYM_FIND,      "Find"      },
+	{ TERMO_SYM_INSERT,    "Insert"    },
+	{ TERMO_SYM_DELETE,    "Delete"    },
+	{ TERMO_SYM_SELECT,    "Select"    },
+	{ TERMO_SYM_PAGEUP,    "PageUp"    },
+	{ TERMO_SYM_PAGEDOWN,  "PageDown"  },
+	{ TERMO_SYM_HOME,      "Home"      },
+	{ TERMO_SYM_END,       "End"       },
+	{ TERMO_SYM_CANCEL,    "Cancel"    },
+	{ TERMO_SYM_CLEAR,     "Clear"     },
+	{ TERMO_SYM_CLOSE,     "Close"     },
+	{ TERMO_SYM_COMMAND,   "Command"   },
+	{ TERMO_SYM_COPY,      "Copy"      },
+	{ TERMO_SYM_EXIT,      "Exit"      },
+	{ TERMO_SYM_HELP,      "Help"      },
+	{ TERMO_SYM_MARK,      "Mark"      },
+	{ TERMO_SYM_MESSAGE,   "Message"   },
+	{ TERMO_SYM_MOVE,      "Move"      },
+	{ TERMO_SYM_OPEN,      "Open"      },
+	{ TERMO_SYM_OPTIONS,   "Options"   },
+	{ TERMO_SYM_PRINT,     "Print"     },
+	{ TERMO_SYM_REDO,      "Redo"      },
+	{ TERMO_SYM_REFERENCE, "Reference" },
+	{ TERMO_SYM_REFRESH,   "Refresh"   },
+	{ TERMO_SYM_REPLACE,   "Replace"   },
+	{ TERMO_SYM_RESTART,   "Restart"   },
+	{ TERMO_SYM_RESUME,    "Resume"    },
+	{ TERMO_SYM_SAVE,      "Save"      },
+	{ TERMO_SYM_SUSPEND,   "Suspend"   },
+	{ TERMO_SYM_UNDO,      "Undo"      },
+	{ TERMO_SYM_KP0,       "KP0"       },
+	{ TERMO_SYM_KP1,       "KP1"       },
+	{ TERMO_SYM_KP2,       "KP2"       },
+	{ TERMO_SYM_KP3,       "KP3"       },
+	{ TERMO_SYM_KP4,       "KP4"       },
+	{ TERMO_SYM_KP5,       "KP5"       },
+	{ TERMO_SYM_KP6,       "KP6"       },
+	{ TERMO_SYM_KP7,       "KP7"       },
+	{ TERMO_SYM_KP8,       "KP8"       },
+	{ TERMO_SYM_KP9,       "KP9"       },
+	{ TERMO_SYM_KPENTER,   "KPEnter"   },
+	{ TERMO_SYM_KPPLUS,    "KPPlus"    },
+	{ TERMO_SYM_KPMINUS,   "KPMinus"   },
+	{ TERMO_SYM_KPMULT,    "KPMult"    },
+	{ TERMO_SYM_KPDIV,     "KPDiv"     },
+	{ TERMO_SYM_KPCOMMA,   "KPComma"   },
+	{ TERMO_SYM_KPPERIOD,  "KPPeriod"  },
+	{ TERMO_SYM_KPEQUALS,  "KPEquals"  },
 	{ 0,                      NULL       },
 };
 
@@ -122,7 +122,7 @@ keynames[] =
 /* Some internal deubgging functions */
 
 static void
-print_buffer (termkey_t *tk)
+print_buffer (termo_t *tk)
 {
 	size_t i;
 	for (i = 0; i < tk->buffcount && i < 20; i++)
@@ -132,75 +132,75 @@ print_buffer (termkey_t *tk)
 }
 
 static void
-print_key (termkey_t *tk, termkey_key_t *key)
+print_key (termo_t *tk, termo_key_t *key)
 {
 	switch (key->type)
 	{
-	case TERMKEY_TYPE_KEY:
+	case TERMO_TYPE_KEY:
 		fprintf (stderr, "Unicode codepoint=U+%04lx multibyte='%s'",
 			(long) key->code.codepoint, key->multibyte);
 		break;
-	case TERMKEY_TYPE_FUNCTION:
+	case TERMO_TYPE_FUNCTION:
 		fprintf (stderr, "Function F%d", key->code.number);
 		break;
-	case TERMKEY_TYPE_KEYSYM:
+	case TERMO_TYPE_KEYSYM:
 		fprintf (stderr, "Keysym sym=%d(%s)",
-			key->code.sym, termkey_get_keyname (tk, key->code.sym));
+			key->code.sym, termo_get_keyname (tk, key->code.sym));
 		break;
-	case TERMKEY_TYPE_MOUSE:
+	case TERMO_TYPE_MOUSE:
 	{
-		termkey_mouse_event_t ev;
+		termo_mouse_event_t ev;
 		int button, line, col;
-		termkey_interpret_mouse (tk, key, &ev, &button, &line, &col);
+		termo_interpret_mouse (tk, key, &ev, &button, &line, &col);
 		fprintf (stderr, "Mouse ev=%d button=%d pos=(%d,%d)\n",
 			ev, button, line, col);
 		break;
 	}
-	case TERMKEY_TYPE_POSITION:
+	case TERMO_TYPE_POSITION:
 	{
 		int line, col;
-		termkey_interpret_position (tk, key, &line, &col);
+		termo_interpret_position (tk, key, &line, &col);
 		fprintf (stderr, "Position report pos=(%d,%d)\n", line, col);
 		break;
 	}
-	case TERMKEY_TYPE_MODEREPORT:
+	case TERMO_TYPE_MODEREPORT:
 	{
 		int initial, mode, value;
-		termkey_interpret_modereport (tk, key, &initial, &mode, &value);
+		termo_interpret_modereport (tk, key, &initial, &mode, &value);
 		fprintf (stderr, "Mode report mode=%s %d val=%d\n",
 			initial == '?' ? "DEC" : "ANSI", mode, value);
 		break;
 	}
-	case TERMKEY_TYPE_UNKNOWN_CSI:
+	case TERMO_TYPE_UNKNOWN_CSI:
 		fprintf (stderr, "unknown CSI\n");
 	}
 
 	int m = key->modifiers;
 	fprintf (stderr, " mod=%s%s%s+%02x",
-		(m & TERMKEY_KEYMOD_CTRL  ? "C" : ""),
-		(m & TERMKEY_KEYMOD_ALT   ? "A" : ""),
-		(m & TERMKEY_KEYMOD_SHIFT ? "S" : ""),
-		m & ~(TERMKEY_KEYMOD_CTRL | TERMKEY_KEYMOD_ALT | TERMKEY_KEYMOD_SHIFT));
+		(m & TERMO_KEYMOD_CTRL  ? "C" : ""),
+		(m & TERMO_KEYMOD_ALT   ? "A" : ""),
+		(m & TERMO_KEYMOD_SHIFT ? "S" : ""),
+		m & ~(TERMO_KEYMOD_CTRL | TERMO_KEYMOD_ALT | TERMO_KEYMOD_SHIFT));
 }
 
 static const char *
-res2str (termkey_result_t res)
+res2str (termo_result_t res)
 {
 	static char errorbuffer[256];
 
 	switch (res)
 	{
-	case TERMKEY_RES_KEY:
-		return "TERMKEY_RES_KEY";
-	case TERMKEY_RES_EOF:
-		return "TERMKEY_RES_EOF";
-	case TERMKEY_RES_AGAIN:
-		return "TERMKEY_RES_AGAIN";
-	case TERMKEY_RES_NONE:
-		return "TERMKEY_RES_NONE";
-	case TERMKEY_RES_ERROR:
+	case TERMO_RES_KEY:
+		return "TERMO_RES_KEY";
+	case TERMO_RES_EOF:
+		return "TERMO_RES_EOF";
+	case TERMO_RES_AGAIN:
+		return "TERMO_RES_AGAIN";
+	case TERMO_RES_NONE:
+		return "TERMO_RES_NONE";
+	case TERMO_RES_ERROR:
 		snprintf (errorbuffer, sizeof errorbuffer,
-			"TERMKEY_RES_ERROR(errno=%d)\n", errno);
+			"TERMO_RES_ERROR(errno=%d)\n", errno);
 		return (const char*) errorbuffer;
 	}
 
@@ -278,10 +278,10 @@ strpncmp_camel (const char **strp, const char **strcamelp, size_t n)
 	return *str - *strcamel;
 }
 
-static termkey_t *
-termkey_alloc (void)
+static termo_t *
+termo_alloc (void)
 {
-	termkey_t *tk = malloc (sizeof *tk);
+	termo_t *tk = malloc (sizeof *tk);
 	if (!tk)
 		return NULL;
 
@@ -308,7 +308,7 @@ termkey_alloc (void)
 	tk->keynames  = NULL;
 
 	for (int i = 0; i < 32; i++)
-		tk->c0[i].sym = TERMKEY_SYM_NONE;
+		tk->c0[i].sym = TERMO_SYM_NONE;
 
 	tk->drivers = NULL;
 
@@ -319,7 +319,7 @@ termkey_alloc (void)
 }
 
 static int
-termkey_init (termkey_t *tk, const char *term, const char *encoding)
+termo_init (termo_t *tk, const char *term, const char *encoding)
 {
 	if (!encoding)
 		encoding = nl_langinfo (CODESET);
@@ -345,16 +345,16 @@ termkey_init (termkey_t *tk, const char *term, const char *encoding)
 	for (i = 0; i < tk->nkeynames; i++)
 		tk->keynames[i] = NULL;
 	for (i = 0; keynames[i].name; i++)
-		if (termkey_register_keyname (tk,
+		if (termo_register_keyname (tk,
 			keynames[i].sym, keynames[i].name) == -1)
 			goto abort_free_keynames;
 
-	register_c0 (tk, TERMKEY_SYM_BACKSPACE, 0x08, NULL);
-	register_c0 (tk, TERMKEY_SYM_TAB,       0x09, NULL);
-	register_c0 (tk, TERMKEY_SYM_ENTER,     0x0d, NULL);
-	register_c0 (tk, TERMKEY_SYM_ESCAPE,    0x1b, NULL);
+	register_c0 (tk, TERMO_SYM_BACKSPACE, 0x08, NULL);
+	register_c0 (tk, TERMO_SYM_TAB,       0x09, NULL);
+	register_c0 (tk, TERMO_SYM_ENTER,     0x0d, NULL);
+	register_c0 (tk, TERMO_SYM_ESCAPE,    0x1b, NULL);
 
-	termkey_driver_node_t **tail = &tk->drivers;
+	termo_driver_node_t **tail = &tk->drivers;
 	for (i = 0; drivers[i]; i++)
 	{
 		void *info = (*drivers[i]->new_driver) (tk, term);
@@ -365,7 +365,7 @@ termkey_init (termkey_t *tk, const char *term, const char *encoding)
 		fprintf (stderr, "Loading the %s driver...\n", drivers[i]->name);
 #endif
 
-		termkey_driver_node_t *thisdrv = malloc (sizeof *thisdrv);
+		termo_driver_node_t *thisdrv = malloc (sizeof *thisdrv);
 		if (!thisdrv)
 			goto abort_free_drivers;
 
@@ -389,10 +389,10 @@ termkey_init (termkey_t *tk, const char *term, const char *encoding)
 	return 1;
 
 abort_free_drivers:
-	for (termkey_driver_node_t *p = tk->drivers; p; )
+	for (termo_driver_node_t *p = tk->drivers; p; )
 	{
 		(*p->driver->free_driver) (p->info);
-		termkey_driver_node_t *next = p->next;
+		termo_driver_node_t *next = p->next;
 		free (p);
 		p = next;
 	}
@@ -408,47 +408,47 @@ abort_free_to_utf32:
 	return 0;
 }
 
-termkey_t *
-termkey_new (int fd, const char *encoding, int flags)
+termo_t *
+termo_new (int fd, const char *encoding, int flags)
 {
-	termkey_t *tk = termkey_alloc ();
+	termo_t *tk = termo_alloc ();
 	if (!tk)
 		return NULL;
 
 	tk->fd = fd;
-	termkey_set_flags (tk, flags);
+	termo_set_flags (tk, flags);
 
 	const char *term = getenv ("TERM");
-	if (termkey_init (tk, term, encoding)
-	 && termkey_start (tk))
+	if (termo_init (tk, term, encoding)
+	 && termo_start (tk))
 		return tk;
 
 	free (tk);
 	return NULL;
 }
 
-termkey_t *
-termkey_new_abstract (const char *term, const char *encoding, int flags)
+termo_t *
+termo_new_abstract (const char *term, const char *encoding, int flags)
 {
-	termkey_t *tk = termkey_alloc ();
+	termo_t *tk = termo_alloc ();
 	if (!tk)
 		return NULL;
 
 	tk->fd = -1;
-	termkey_set_flags (tk, flags);
+	termo_set_flags (tk, flags);
 
-	if (!termkey_init (tk, term, encoding))
+	if (!termo_init (tk, term, encoding))
 	{
 		free (tk);
 		return NULL;
 	}
 
-	termkey_start (tk);
+	termo_start (tk);
 	return tk;
 }
 
 void
-termkey_free (termkey_t *tk)
+termo_free (termo_t *tk)
 {
 	free (tk->buffer);   tk->buffer   = NULL;
 	free (tk->keynames); tk->keynames = NULL;
@@ -458,7 +458,7 @@ termkey_free (termkey_t *tk)
 	iconv_close (tk->from_utf32_conv);
 	tk->from_utf32_conv = (iconv_t) -1;
 
-	termkey_driver_node_t *p, *next;
+	termo_driver_node_t *p, *next;
 	for (p = tk->drivers; p; p = next)
 	{
 		(*p->driver->free_driver) (p->info);
@@ -469,21 +469,21 @@ termkey_free (termkey_t *tk)
 }
 
 void
-termkey_destroy (termkey_t *tk)
+termo_destroy (termo_t *tk)
 {
 	if (tk->is_started)
-		termkey_stop (tk);
+		termo_stop (tk);
 
-	termkey_free (tk);
+	termo_free (tk);
 }
 
 int
-termkey_start (termkey_t *tk)
+termo_start (termo_t *tk)
 {
 	if (tk->is_started)
 		return 1;
 
-	if (tk->fd != -1 && !(tk->flags & TERMKEY_FLAG_NOTERMIOS))
+	if (tk->fd != -1 && !(tk->flags & TERMO_FLAG_NOTERMIOS))
 	{
 		struct termios termios;
 		if (tcgetattr (tk->fd, &termios) == 0)
@@ -496,7 +496,7 @@ termkey_start (termkey_t *tk)
 			termios.c_cc[VMIN]  = 1;
 			termios.c_cc[VTIME] = 0;
 
-			if (tk->flags & TERMKEY_FLAG_CTRLC)
+			if (tk->flags & TERMO_FLAG_CTRLC)
 				/* want no signal keys at all, so just disable ISIG */
 				termios.c_lflag &= ~ISIG;
 			else
@@ -517,14 +517,14 @@ termkey_start (termkey_t *tk)
 		}
 	}
 
-	termkey_driver_node_t *p;
+	termo_driver_node_t *p;
 	for (p = tk->drivers; p; p = p->next)
 		if (p->driver->start_driver)
 			if (!(*p->driver->start_driver) (tk, p->info))
 				return 0;
 
 #ifdef DEBUG
-	fprintf (stderr, "Drivers started; termkey instance %p is ready\n", tk);
+	fprintf (stderr, "Drivers started; termo instance %p is ready\n", tk);
 #endif
 
 	tk->is_started = 1;
@@ -532,12 +532,12 @@ termkey_start (termkey_t *tk)
 }
 
 int
-termkey_stop (termkey_t *tk)
+termo_stop (termo_t *tk)
 {
 	if (!tk->is_started)
 		return 1;
 
-	struct termkey_driver_node *p;
+	struct termo_driver_node *p;
 	for (p = tk->drivers; p; p = p->next)
 		if (p->driver->stop_driver)
 			(*p->driver->stop_driver) (tk, p->info);
@@ -550,69 +550,69 @@ termkey_stop (termkey_t *tk)
 }
 
 int
-termkey_is_started (termkey_t *tk)
+termo_is_started (termo_t *tk)
 {
 	return tk->is_started;
 }
 
 int
-termkey_get_fd (termkey_t *tk)
+termo_get_fd (termo_t *tk)
 {
 	return tk->fd;
 }
 
 int
-termkey_get_flags (termkey_t *tk)
+termo_get_flags (termo_t *tk)
 {
 	return tk->flags;
 }
 
 void
-termkey_set_flags (termkey_t *tk, int newflags)
+termo_set_flags (termo_t *tk, int newflags)
 {
 	tk->flags = newflags;
-	if (tk->flags & TERMKEY_FLAG_SPACESYMBOL)
-		tk->canonflags |= TERMKEY_CANON_SPACESYMBOL;
+	if (tk->flags & TERMO_FLAG_SPACESYMBOL)
+		tk->canonflags |= TERMO_CANON_SPACESYMBOL;
 	else
-		tk->canonflags &= ~TERMKEY_CANON_SPACESYMBOL;
+		tk->canonflags &= ~TERMO_CANON_SPACESYMBOL;
 }
 
 void
-termkey_set_waittime (termkey_t *tk, int msec)
+termo_set_waittime (termo_t *tk, int msec)
 {
 	tk->waittime = msec;
 }
 
 int
-termkey_get_waittime (termkey_t *tk)
+termo_get_waittime (termo_t *tk)
 {
 	return tk->waittime;
 }
 
 int
-termkey_get_canonflags (termkey_t *tk)
+termo_get_canonflags (termo_t *tk)
 {
 	return tk->canonflags;
 }
 
 void
-termkey_set_canonflags (termkey_t *tk, int flags)
+termo_set_canonflags (termo_t *tk, int flags)
 {
 	tk->canonflags = flags;
-	if (tk->canonflags & TERMKEY_CANON_SPACESYMBOL)
-		tk->flags |= TERMKEY_FLAG_SPACESYMBOL;
+	if (tk->canonflags & TERMO_CANON_SPACESYMBOL)
+		tk->flags |= TERMO_FLAG_SPACESYMBOL;
 	else
-		tk->flags &= ~TERMKEY_FLAG_SPACESYMBOL;
+		tk->flags &= ~TERMO_FLAG_SPACESYMBOL;
 }
 
 size_t
-termkey_get_buffer_size (termkey_t *tk)
+termo_get_buffer_size (termo_t *tk)
 {
 	return tk->buffsize;
 }
 
 int
-termkey_set_buffer_size (termkey_t *tk, size_t size)
+termo_set_buffer_size (termo_t *tk, size_t size)
 {
 	unsigned char *buffer = realloc (tk->buffer, size);
 	if (!buffer)
@@ -624,7 +624,7 @@ termkey_set_buffer_size (termkey_t *tk, size_t size)
 }
 
 size_t
-termkey_get_buffer_remaining (termkey_t *tk)
+termo_get_buffer_remaining (termo_t *tk)
 {
 	/* Return the total number of free bytes in the buffer,
 	 * because that's what is available to the user. */
@@ -632,7 +632,7 @@ termkey_get_buffer_remaining (termkey_t *tk)
 }
 
 static void
-eat_bytes (termkey_t *tk, size_t count)
+eat_bytes (termo_t *tk, size_t count)
 {
 	if (count >= tk->buffcount)
 	{
@@ -648,7 +648,7 @@ eat_bytes (termkey_t *tk, size_t count)
 #define MULTIBYTE_INVALID '?'
 
 static void
-fill_multibyte (termkey_t *tk, termkey_key_t *key)
+fill_multibyte (termo_t *tk, termo_key_t *key)
 {
 	size_t codepoint_len = sizeof key->code.codepoint;
 	char *codepoint_ptr = (char *) &key->code.codepoint;
@@ -671,8 +671,8 @@ fill_multibyte (termkey_t *tk, termkey_key_t *key)
 	key->multibyte[output] = 0;
 }
 
-static termkey_result_t
-parse_multibyte (termkey_t *tk, const unsigned char *bytes, size_t len,
+static termo_result_t
+parse_multibyte (termo_t *tk, const unsigned char *bytes, size_t len,
 	uint32_t *cp, size_t *nbytep)
 {
 	size_t multibyte_len = len;
@@ -694,27 +694,27 @@ parse_multibyte (termkey_t *tk, const unsigned char *bytes, size_t len,
 	{
 		if (errno == 0)
 			// The input was probably a shift sequence
-			return TERMKEY_RES_AGAIN;
+			return TERMO_RES_AGAIN;
 		if (errno == EINVAL)
 			// Incomplete character or shift sequence
-			return TERMKEY_RES_AGAIN;
+			return TERMO_RES_AGAIN;
 		if (errno == EILSEQ)
 		{
 			// Invalid multibyte sequence in the input, let's try going
 			// byte after byte in hope we skip it completely
 			*cp = MULTIBYTE_INVALID;
 			*nbytep = 1;
-			return TERMKEY_RES_KEY;
+			return TERMO_RES_KEY;
 		}
 
 		// We can't really get E2BIG so what the fuck is going on here
 		abort ();
 	}
-	return TERMKEY_RES_KEY;
+	return TERMO_RES_KEY;
 }
 
 static void
-emit_codepoint (termkey_t *tk, uint32_t codepoint, termkey_key_t *key)
+emit_codepoint (termo_t *tk, uint32_t codepoint, termo_key_t *key)
 {
 	if (codepoint < 0x20)
 	{
@@ -722,8 +722,8 @@ emit_codepoint (termkey_t *tk, uint32_t codepoint, termkey_key_t *key)
 		key->code.codepoint = 0;
 		key->modifiers = 0;
 
-		if (!(tk->flags & TERMKEY_FLAG_NOINTERPRET)
-		 && tk->c0[codepoint].sym != TERMKEY_SYM_UNKNOWN)
+		if (!(tk->flags & TERMO_FLAG_NOINTERPRET)
+		 && tk->c0[codepoint].sym != TERMO_SYM_UNKNOWN)
 		{
 			key->code.sym   = tk->c0[codepoint].sym;
 			key->modifiers |= tk->c0[codepoint].modifier_set;
@@ -731,7 +731,7 @@ emit_codepoint (termkey_t *tk, uint32_t codepoint, termkey_key_t *key)
 
 		if (!key->code.sym)
 		{
-			key->type = TERMKEY_TYPE_KEY;
+			key->type = TERMO_TYPE_KEY;
 			/* Generically modified Unicode ought not report the SHIFT state,
 			 * or else we get into complications trying to report Shift-; vs :
 			 * and so on...  In order to be able to represent Ctrl-Shift-A as
@@ -743,70 +743,70 @@ emit_codepoint (termkey_t *tk, uint32_t codepoint, termkey_key_t *key)
 				key->code.codepoint = codepoint + 0x60;
 			else
 				key->code.codepoint = codepoint + 0x40;
-			key->modifiers = TERMKEY_KEYMOD_CTRL;
+			key->modifiers = TERMO_KEYMOD_CTRL;
 		}
 		else
-			key->type = TERMKEY_TYPE_KEYSYM;
+			key->type = TERMO_TYPE_KEYSYM;
 	}
-	else if (codepoint == 0x7f && !(tk->flags & TERMKEY_FLAG_NOINTERPRET))
+	else if (codepoint == 0x7f && !(tk->flags & TERMO_FLAG_NOINTERPRET))
 	{
 		// ASCII DEL
-		key->type = TERMKEY_TYPE_KEYSYM;
-		key->code.sym = TERMKEY_SYM_DEL;
+		key->type = TERMO_TYPE_KEYSYM;
+		key->code.sym = TERMO_SYM_DEL;
 		key->modifiers = 0;
 	}
 	else
 	{
-		key->type = TERMKEY_TYPE_KEY;
+		key->type = TERMO_TYPE_KEY;
 		key->code.codepoint = codepoint;
 		key->modifiers = 0;
 	}
 
-	termkey_canonicalise (tk, key);
+	termo_canonicalise (tk, key);
 
-	if (key->type == TERMKEY_TYPE_KEY)
+	if (key->type == TERMO_TYPE_KEY)
 		fill_multibyte (tk, key);
 }
 
 void
-termkey_canonicalise (termkey_t *tk, termkey_key_t *key)
+termo_canonicalise (termo_t *tk, termo_key_t *key)
 {
 	int flags = tk->canonflags;
 
-	if (flags & TERMKEY_CANON_SPACESYMBOL)
+	if (flags & TERMO_CANON_SPACESYMBOL)
 	{
-		if (key->type == TERMKEY_TYPE_KEY && key->code.codepoint == 0x20)
+		if (key->type == TERMO_TYPE_KEY && key->code.codepoint == 0x20)
 		{
-			key->type = TERMKEY_TYPE_KEYSYM;
-			key->code.sym = TERMKEY_SYM_SPACE;
+			key->type = TERMO_TYPE_KEYSYM;
+			key->code.sym = TERMO_SYM_SPACE;
 		}
 	}
 	else
 	{
-		if (key->type == TERMKEY_TYPE_KEYSYM
-		 && key->code.sym == TERMKEY_SYM_SPACE)
+		if (key->type == TERMO_TYPE_KEYSYM
+		 && key->code.sym == TERMO_SYM_SPACE)
 		{
-			key->type = TERMKEY_TYPE_KEY;
+			key->type = TERMO_TYPE_KEY;
 			key->code.codepoint = 0x20;
 			fill_multibyte (tk, key);
 		}
 	}
 
-	if (flags & TERMKEY_CANON_DELBS)
-		if (key->type == TERMKEY_TYPE_KEYSYM
-		 && key->code.sym == TERMKEY_SYM_DEL)
-			key->code.sym = TERMKEY_SYM_BACKSPACE;
+	if (flags & TERMO_CANON_DELBS)
+		if (key->type == TERMO_TYPE_KEYSYM
+		 && key->code.sym == TERMO_SYM_DEL)
+			key->code.sym = TERMO_SYM_BACKSPACE;
 }
 
-static termkey_result_t
-peekkey (termkey_t *tk, termkey_key_t *key, int force, size_t *nbytep)
+static termo_result_t
+peekkey (termo_t *tk, termo_key_t *key, int force, size_t *nbytep)
 {
 	int again = 0;
 
 	if (!tk->is_started)
 	{
 		errno = EINVAL;
-		return TERMKEY_RES_ERROR;
+		return TERMO_RES_ERROR;
 	}
 
 #ifdef DEBUG
@@ -822,8 +822,8 @@ peekkey (termkey_t *tk, termkey_key_t *key, int force, size_t *nbytep)
 		tk->hightide = 0;
 	}
 
-	termkey_result_t ret;
-	termkey_driver_node_t *p;
+	termo_result_t ret;
+	termo_driver_node_t *p;
 	for (p = tk->drivers; p; p = p->next)
 	{
 		ret = (p->driver->peekkey) (tk, p->info, key, force, nbytep);
@@ -835,7 +835,7 @@ peekkey (termkey_t *tk, termkey_key_t *key, int force, size_t *nbytep)
 
 		switch (ret)
 		{
-		case TERMKEY_RES_KEY:
+		case TERMO_RES_KEY:
 		{
 #ifdef DEBUG
 			print_key (tk, key); fprintf (stderr, "\n");
@@ -850,27 +850,27 @@ peekkey (termkey_t *tk, termkey_key_t *key, int force, size_t *nbytep)
 
 			/* fallthrough */
 		}
-		case TERMKEY_RES_EOF:
-		case TERMKEY_RES_ERROR:
+		case TERMO_RES_EOF:
+		case TERMO_RES_ERROR:
 			return ret;
 
-		case TERMKEY_RES_AGAIN:
+		case TERMO_RES_AGAIN:
 			if (!force)
 				again = 1;
-		case TERMKEY_RES_NONE:
+		case TERMO_RES_NONE:
 			break;
 		}
 	}
 
 	if (again)
-		return TERMKEY_RES_AGAIN;
+		return TERMO_RES_AGAIN;
 
 	ret = peekkey_simple (tk, key, force, nbytep);
 
 #ifdef DEBUG
 	fprintf (stderr, "getkey_simple(force=%d) yields %s\n",
 		force, res2str (ret));
-	if (ret == TERMKEY_RES_KEY)
+	if (ret == TERMO_RES_KEY)
 	{
 		print_key (tk, key);
 		fprintf (stderr, "\n");
@@ -880,11 +880,11 @@ peekkey (termkey_t *tk, termkey_key_t *key, int force, size_t *nbytep)
 	return ret;
 }
 
-static termkey_result_t
-peekkey_simple (termkey_t *tk, termkey_key_t *key, int force, size_t *nbytep)
+static termo_result_t
+peekkey_simple (termo_t *tk, termo_key_t *key, int force, size_t *nbytep)
 {
 	if (tk->buffcount == 0)
-		return tk->is_closed ? TERMKEY_RES_EOF : TERMKEY_RES_NONE;
+		return tk->is_closed ? TERMO_RES_EOF : TERMO_RES_NONE;
 
 	unsigned char b0 = CHARAT (0);
 	if (b0 == 0x1b)
@@ -895,11 +895,11 @@ peekkey_simple (termkey_t *tk, termkey_key_t *key, int force, size_t *nbytep)
 			// This might be an <Esc> press, or it may want to be part
 			// of a longer sequence
 			if (!force)
-				return TERMKEY_RES_AGAIN;
+				return TERMO_RES_AGAIN;
 
 			(*tk->method.emit_codepoint) (tk, b0, key);
 			*nbytep = 1;
-			return TERMKEY_RES_KEY;
+			return TERMO_RES_KEY;
 		}
 
 		// Try another key there
@@ -907,34 +907,34 @@ peekkey_simple (termkey_t *tk, termkey_key_t *key, int force, size_t *nbytep)
 		tk->buffcount--;
 
 		// Run the full driver
-		termkey_result_t metakey_result = peekkey (tk, key, force, nbytep);
+		termo_result_t metakey_result = peekkey (tk, key, force, nbytep);
 
 		tk->buffstart--;
 		tk->buffcount++;
 
 		switch (metakey_result)
 		{
-		case TERMKEY_RES_KEY:
-			key->modifiers |= TERMKEY_KEYMOD_ALT;
+		case TERMO_RES_KEY:
+			key->modifiers |= TERMO_KEYMOD_ALT;
 			(*nbytep)++;
 			break;
 
-		case TERMKEY_RES_NONE:
-		case TERMKEY_RES_EOF:
-		case TERMKEY_RES_AGAIN:
-		case TERMKEY_RES_ERROR:
+		case TERMO_RES_NONE:
+		case TERMO_RES_EOF:
+		case TERMO_RES_AGAIN:
+		case TERMO_RES_ERROR:
 			break;
 		}
 
 		return metakey_result;
 	}
-	else if (!(tk->flags & TERMKEY_FLAG_RAW))
+	else if (!(tk->flags & TERMO_FLAG_RAW))
 	{
 		uint32_t codepoint;
-		termkey_result_t res = parse_multibyte
+		termo_result_t res = parse_multibyte
 			(tk, tk->buffer + tk->buffstart, tk->buffcount, &codepoint, nbytep);
 
-		if (res == TERMKEY_RES_AGAIN && force)
+		if (res == TERMO_RES_AGAIN && force)
 		{
 			/* There weren't enough bytes for a complete character but
 			 * caller demands an answer.  About the best thing we can do here
@@ -943,10 +943,10 @@ peekkey_simple (termkey_t *tk, termkey_key_t *key, int force, size_t *nbytep)
 			 */
 			codepoint = MULTIBYTE_INVALID;
 			*nbytep = tk->buffcount;
-			res = TERMKEY_RES_KEY;
+			res = TERMO_RES_KEY;
 		}
 
-		key->type = TERMKEY_TYPE_KEY;
+		key->type = TERMO_TYPE_KEY;
 		key->modifiers = 0;
 		(*tk->method.emit_codepoint) (tk, codepoint, key);
 		return res;
@@ -954,7 +954,7 @@ peekkey_simple (termkey_t *tk, termkey_key_t *key, int force, size_t *nbytep)
 	else
 	{
 		// Non multibyte case - just report the raw byte
-		key->type = TERMKEY_TYPE_KEY;
+		key->type = TERMO_TYPE_KEY;
 		key->code.codepoint = b0;
 		key->modifiers = 0;
 
@@ -962,7 +962,7 @@ peekkey_simple (termkey_t *tk, termkey_key_t *key, int force, size_t *nbytep)
 		key->multibyte[1] = 0;
 
 		*nbytep = 1;
-		return TERMKEY_RES_KEY;
+		return TERMO_RES_KEY;
 	}
 }
 
@@ -970,7 +970,7 @@ peekkey_simple (termkey_t *tk, termkey_key_t *key, int force, size_t *nbytep)
 //   this.  peekkey() isn't made for skipping invalid inputs.
 #define INVALID_1005 0x20
 
-static termkey_result_t
+static termo_result_t
 parse_1005_value (const unsigned char **bytes, size_t *len, uint32_t *cp)
 {
 	unsigned int nbytes;
@@ -1024,7 +1024,7 @@ parse_1005_value (const unsigned char **bytes, size_t *len, uint32_t *cp)
 	for (unsigned int b = 1; b < nbytes; b++)
 	{
 		if (b >= *len)
-			return TERMKEY_RES_AGAIN;
+			return TERMO_RES_AGAIN;
 
 		unsigned char cb = (*bytes)[b];
 		if (cb < 0x80 || cb >= 0xc0)
@@ -1040,11 +1040,11 @@ parse_1005_value (const unsigned char **bytes, size_t *len, uint32_t *cp)
 end:
 	(*bytes) += nbytes;
 	(*len) -= nbytes;
-	return TERMKEY_RES_KEY;
+	return TERMO_RES_KEY;
 }
 
-static termkey_result_t
-peekkey_mouse (termkey_t *tk, termkey_key_t *key, size_t *nbytep)
+static termo_result_t
+peekkey_mouse (termo_t *tk, termo_key_t *key, size_t *nbytep)
 {
 	uint32_t b, x, y;
 
@@ -1054,17 +1054,17 @@ peekkey_mouse (termkey_t *tk, termkey_key_t *key, size_t *nbytep)
 		const unsigned char *buff = tk->buffer + tk->buffstart;
 		size_t len = tk->buffcount;
 
-		if (parse_1005_value (&buff, &len, &b) == TERMKEY_RES_AGAIN
-		 || parse_1005_value (&buff, &len, &x) == TERMKEY_RES_AGAIN
-		 || parse_1005_value (&buff, &len, &y) == TERMKEY_RES_AGAIN)
-			return TERMKEY_RES_AGAIN;
+		if (parse_1005_value (&buff, &len, &b) == TERMO_RES_AGAIN
+		 || parse_1005_value (&buff, &len, &x) == TERMO_RES_AGAIN
+		 || parse_1005_value (&buff, &len, &y) == TERMO_RES_AGAIN)
+			return TERMO_RES_AGAIN;
 
 		*nbytep = tk->buffcount - len;
 	}
 	else
 	{
 		if (tk->buffcount < 3)
-			return TERMKEY_RES_AGAIN;
+			return TERMO_RES_AGAIN;
 
 		b = CHARAT (0);
 		x = CHARAT (1);
@@ -1073,7 +1073,7 @@ peekkey_mouse (termkey_t *tk, termkey_key_t *key, size_t *nbytep)
 		*nbytep = 3;
 	}
 
-	key->type = TERMKEY_TYPE_MOUSE;
+	key->type = TERMO_TYPE_MOUSE;
 	key->code.mouse.info = b - 0x20;
 	key->code.mouse.x = x - 0x20 - 1;
 	key->code.mouse.y = y - 0x20 - 1;
@@ -1081,19 +1081,19 @@ peekkey_mouse (termkey_t *tk, termkey_key_t *key, size_t *nbytep)
 	key->modifiers = (key->code.mouse.info & 0x1c) >> 2;
 	key->code.mouse.info &= ~0x1c;
 
-	return TERMKEY_RES_KEY;
+	return TERMO_RES_KEY;
 }
 
-termkey_result_t
-termkey_getkey (termkey_t *tk, termkey_key_t *key)
+termo_result_t
+termo_getkey (termo_t *tk, termo_key_t *key)
 {
 	size_t nbytes = 0;
-	termkey_result_t ret = peekkey (tk, key, 0, &nbytes);
+	termo_result_t ret = peekkey (tk, key, 0, &nbytes);
 
-	if (ret == TERMKEY_RES_KEY)
+	if (ret == TERMO_RES_KEY)
 		eat_bytes (tk, nbytes);
 
-	if (ret == TERMKEY_RES_AGAIN)
+	if (ret == TERMO_RES_AGAIN)
 		/* Call peekkey() again in force mode to obtain whatever it can */
 		(void) peekkey (tk, key, 1, &nbytes);
 		/* Don't eat it yet though */
@@ -1101,50 +1101,50 @@ termkey_getkey (termkey_t *tk, termkey_key_t *key)
 	return ret;
 }
 
-termkey_result_t
-termkey_getkey_force (termkey_t *tk, termkey_key_t *key)
+termo_result_t
+termo_getkey_force (termo_t *tk, termo_key_t *key)
 {
 	size_t nbytes = 0;
-	termkey_result_t ret = peekkey (tk, key, 1, &nbytes);
+	termo_result_t ret = peekkey (tk, key, 1, &nbytes);
 
-	if (ret == TERMKEY_RES_KEY)
+	if (ret == TERMO_RES_KEY)
 		eat_bytes (tk, nbytes);
 
 	return ret;
 }
 
-termkey_result_t
-termkey_waitkey (termkey_t *tk, termkey_key_t *key)
+termo_result_t
+termo_waitkey (termo_t *tk, termo_key_t *key)
 {
 	if (tk->fd == -1)
 	{
 		errno = EBADF;
-		return TERMKEY_RES_ERROR;
+		return TERMO_RES_ERROR;
 	}
 
 	while (1)
 	{
-		termkey_result_t ret = termkey_getkey (tk, key);
+		termo_result_t ret = termo_getkey (tk, key);
 
 		switch (ret)
 		{
-		case TERMKEY_RES_KEY:
-		case TERMKEY_RES_EOF:
-		case TERMKEY_RES_ERROR:
+		case TERMO_RES_KEY:
+		case TERMO_RES_EOF:
+		case TERMO_RES_ERROR:
 			return ret;
 
-		case TERMKEY_RES_NONE:
-			ret = termkey_advisereadable (tk);
-			if (ret == TERMKEY_RES_ERROR)
+		case TERMO_RES_NONE:
+			ret = termo_advisereadable (tk);
+			if (ret == TERMO_RES_ERROR)
 				return ret;
 			break;
 
-		case TERMKEY_RES_AGAIN:
+		case TERMO_RES_AGAIN:
 		{
 			if (tk->is_closed)
 				// We're closed now. Never going to get more bytes
 				// so just go with what we have
-				return termkey_getkey_force (tk, key);
+				return termo_getkey_force (tk, key);
 
 			struct pollfd fd;
 retry:
@@ -1154,21 +1154,21 @@ retry:
 			int pollret = poll (&fd, 1, tk->waittime);
 			if (pollret == -1)
 			{
-				if (errno == EINTR && !(tk->flags & TERMKEY_FLAG_EINTR))
+				if (errno == EINTR && !(tk->flags & TERMO_FLAG_EINTR))
 					goto retry;
 
-				return TERMKEY_RES_ERROR;
+				return TERMO_RES_ERROR;
 			}
 
 			if (fd.revents & (POLLIN | POLLHUP | POLLERR))
-				ret = termkey_advisereadable (tk);
+				ret = termo_advisereadable (tk);
 			else
-				ret = TERMKEY_RES_NONE;
+				ret = TERMO_RES_NONE;
 
-			if (ret == TERMKEY_RES_ERROR)
+			if (ret == TERMO_RES_ERROR)
 				return ret;
-			if (ret == TERMKEY_RES_NONE)
-				return termkey_getkey_force (tk, key);
+			if (ret == TERMO_RES_NONE)
+				return termo_getkey_force (tk, key);
 		}
 		}
 	}
@@ -1176,13 +1176,13 @@ retry:
 	/* UNREACHABLE */
 }
 
-termkey_result_t
-termkey_advisereadable (termkey_t *tk)
+termo_result_t
+termo_advisereadable (termo_t *tk)
 {
 	if (tk->fd == -1)
 	{
 		errno = EBADF;
-		return TERMKEY_RES_ERROR;
+		return TERMO_RES_ERROR;
 	}
 
 	if (tk->buffstart)
@@ -1195,7 +1195,7 @@ termkey_advisereadable (termkey_t *tk)
 	if (tk->buffcount >= tk->buffsize)
 	{
 		errno = ENOMEM;
-		return TERMKEY_RES_ERROR;
+		return TERMO_RES_ERROR;
 	}
 
 	ssize_t len;
@@ -1206,22 +1206,22 @@ retry:
 	if (len == -1)
 	{
 		if (errno == EAGAIN)
-			return TERMKEY_RES_NONE;
-		if (errno == EINTR && !(tk->flags & TERMKEY_FLAG_EINTR))
+			return TERMO_RES_NONE;
+		if (errno == EINTR && !(tk->flags & TERMO_FLAG_EINTR))
 			goto retry;
-		return TERMKEY_RES_ERROR;
+		return TERMO_RES_ERROR;
 	}
 	if (len < 1)
 	{
 		tk->is_closed = true;
-		return TERMKEY_RES_NONE;
+		return TERMO_RES_NONE;
 	}
 	tk->buffcount += len;
-	return TERMKEY_RES_AGAIN;
+	return TERMO_RES_AGAIN;
 }
 
 size_t
-termkey_push_bytes (termkey_t *tk, const char *bytes, size_t len)
+termo_push_bytes (termo_t *tk, const char *bytes, size_t len)
 {
 	if (tk->buffstart)
 	{
@@ -1246,8 +1246,8 @@ termkey_push_bytes (termkey_t *tk, const char *bytes, size_t len)
 	return len;
 }
 
-termkey_sym_t
-termkey_register_keyname (termkey_t *tk, termkey_sym_t sym, const char *name)
+termo_sym_t
+termo_register_keyname (termo_t *tk, termo_sym_t sym, const char *name)
 {
 	if (!sym)
 		sym = tk->nkeynames;
@@ -1273,9 +1273,9 @@ termkey_register_keyname (termkey_t *tk, termkey_sym_t sym, const char *name)
 }
 
 const char *
-termkey_get_keyname (termkey_t *tk, termkey_sym_t sym)
+termo_get_keyname (termo_t *tk, termo_sym_t sym)
 {
-	if (sym == TERMKEY_SYM_UNKNOWN)
+	if (sym == TERMO_SYM_UNKNOWN)
 		return "UNKNOWN";
 	if (sym < tk->nkeynames)
 		return tk->keynames[sym];
@@ -1283,8 +1283,8 @@ termkey_get_keyname (termkey_t *tk, termkey_sym_t sym)
 }
 
 static const char *
-termkey_lookup_keyname_format (termkey_t *tk,
-	const char *str, termkey_sym_t *sym, termkey_format_t format)
+termo_lookup_keyname_format (termo_t *tk,
+	const char *str, termo_sym_t *sym, termo_format_t format)
 {
 	/* We store an array, so we can't do better than a linear search. Doesn't
 	 * matter because user won't be calling this too often */
@@ -1295,7 +1295,7 @@ termkey_lookup_keyname_format (termkey_t *tk,
 		if (!thiskey)
 			continue;
 		size_t len = strlen (thiskey);
-		if (format & TERMKEY_FORMAT_LOWERSPACE)
+		if (format & TERMO_FORMAT_LOWERSPACE)
 		{
 			const char *thisstr = str;
 			if (strpncmp_camel (&thisstr, &thiskey, len) == 0)
@@ -1308,30 +1308,30 @@ termkey_lookup_keyname_format (termkey_t *tk,
 }
 
 const char *
-termkey_lookup_keyname (termkey_t *tk, const char *str, termkey_sym_t *sym)
+termo_lookup_keyname (termo_t *tk, const char *str, termo_sym_t *sym)
 {
-	return termkey_lookup_keyname_format (tk, str, sym, 0);
+	return termo_lookup_keyname_format (tk, str, sym, 0);
 }
 
-termkey_sym_t
-termkey_keyname2sym (termkey_t *tk, const char *keyname)
+termo_sym_t
+termo_keyname2sym (termo_t *tk, const char *keyname)
 {
-	termkey_sym_t sym;
-	const char *endp = termkey_lookup_keyname (tk, keyname, &sym);
+	termo_sym_t sym;
+	const char *endp = termo_lookup_keyname (tk, keyname, &sym);
 	if (!endp || endp[0])
-		return TERMKEY_SYM_UNKNOWN;
+		return TERMO_SYM_UNKNOWN;
 	return sym;
 }
 
-static termkey_sym_t
-register_c0 (termkey_t *tk,
-	termkey_sym_t sym, unsigned char ctrl, const char *name)
+static termo_sym_t
+register_c0 (termo_t *tk,
+	termo_sym_t sym, unsigned char ctrl, const char *name)
 {
 	return register_c0_full (tk, sym, 0, 0, ctrl, name);
 }
 
-static termkey_sym_t
-register_c0_full (termkey_t *tk, termkey_sym_t sym,
+static termo_sym_t
+register_c0_full (termo_t *tk, termo_sym_t sym,
 	int modifier_set, int modifier_mask, unsigned char ctrl, const char *name)
 {
 	if (ctrl >= 0x20)
@@ -1341,7 +1341,7 @@ register_c0_full (termkey_t *tk, termkey_sym_t sym,
 	}
 
 	if (name)
-		sym = termkey_register_keyname (tk, sym, name);
+		sym = termo_register_keyname (tk, sym, name);
 
 	tk->c0[ctrl].sym = sym;
 	tk->c0[ctrl].modifier_set = modifier_set;
@@ -1366,25 +1366,25 @@ modnames[] =
 };
 
 size_t
-termkey_strfkey (termkey_t *tk, char *buffer, size_t len,
-	termkey_key_t *key, termkey_format_t format)
+termo_strfkey (termo_t *tk, char *buffer, size_t len,
+	termo_key_t *key, termo_format_t format)
 {
 	size_t pos = 0;
 	size_t l = 0;
 
 	struct modnames *mods = &modnames[
-		!!(format & TERMKEY_FORMAT_LONGMOD) +
-		!!(format & TERMKEY_FORMAT_ALTISMETA) * 2 +
-		!!(format & TERMKEY_FORMAT_LOWERMOD) * 4];
+		!!(format & TERMO_FORMAT_LONGMOD) +
+		!!(format & TERMO_FORMAT_ALTISMETA) * 2 +
+		!!(format & TERMO_FORMAT_LOWERMOD) * 4];
 
-	int wrapbracket = (format & TERMKEY_FORMAT_WRAPBRACKET) &&
-		(key->type != TERMKEY_TYPE_KEY || key->modifiers != 0);
+	int wrapbracket = (format & TERMO_FORMAT_WRAPBRACKET) &&
+		(key->type != TERMO_TYPE_KEY || key->modifiers != 0);
 
-	char sep = (format & TERMKEY_FORMAT_SPACEMOD) ? ' ' : '-';
+	char sep = (format & TERMO_FORMAT_SPACEMOD) ? ' ' : '-';
 
-	if (format & TERMKEY_FORMAT_CARETCTRL &&
-		key->type == TERMKEY_TYPE_KEY &&
- 		key->modifiers == TERMKEY_KEYMOD_CTRL)
+	if (format & TERMO_FORMAT_CARETCTRL &&
+		key->type == TERMO_TYPE_KEY &&
+		key->modifiers == TERMO_KEYMOD_CTRL)
 	{
 		uint32_t codepoint = key->code.codepoint;
 
@@ -1418,21 +1418,21 @@ termkey_strfkey (termkey_t *tk, char *buffer, size_t len,
 		pos += l;
 	}
 
-	if (key->modifiers & TERMKEY_KEYMOD_ALT)
+	if (key->modifiers & TERMO_KEYMOD_ALT)
 	{
 		l = snprintf (buffer + pos, len - pos, "%s%c", mods->alt, sep);
 		if (l <= 0)
 			return pos;
 		pos += l;
 	}
-	if (key->modifiers & TERMKEY_KEYMOD_CTRL)
+	if (key->modifiers & TERMO_KEYMOD_CTRL)
 	{
 		l = snprintf (buffer + pos, len - pos, "%s%c", mods->ctrl, sep);
 		if (l <= 0)
 			return pos;
 		pos += l;
 	}
-	if (key->modifiers & TERMKEY_KEYMOD_SHIFT)
+	if (key->modifiers & TERMO_KEYMOD_SHIFT)
 	{
 		l = snprintf (buffer + pos, len - pos, "%s%c", mods->shift, sep);
 		if (l <= 0)
@@ -1442,36 +1442,36 @@ termkey_strfkey (termkey_t *tk, char *buffer, size_t len,
 
 	switch (key->type)
 	{
-	case TERMKEY_TYPE_KEY:
+	case TERMO_TYPE_KEY:
 		if (!key->multibyte[0]) // In case of user-supplied key structures
 			fill_multibyte (tk, key);
 		l = snprintf (buffer + pos, len - pos, "%s", key->multibyte);
 		break;
-	case TERMKEY_TYPE_KEYSYM:
+	case TERMO_TYPE_KEYSYM:
 	{
-		const char *name = termkey_get_keyname (tk, key->code.sym);
-		if (format & TERMKEY_FORMAT_LOWERSPACE)
+		const char *name = termo_get_keyname (tk, key->code.sym);
+		if (format & TERMO_FORMAT_LOWERSPACE)
 			l = snprint_cameltospaces (buffer + pos, len - pos, name);
 		else
 			l = snprintf (buffer + pos, len - pos, "%s", name);
 		break;
 	}
-	case TERMKEY_TYPE_FUNCTION:
+	case TERMO_TYPE_FUNCTION:
 		l = snprintf (buffer + pos, len - pos, "%c%d",
-			(format & TERMKEY_FORMAT_LOWERSPACE ? 'f' : 'F'), key->code.number);
+			(format & TERMO_FORMAT_LOWERSPACE ? 'f' : 'F'), key->code.number);
 		break;
-	case TERMKEY_TYPE_MOUSE:
+	case TERMO_TYPE_MOUSE:
 	{
-		termkey_mouse_event_t ev;
+		termo_mouse_event_t ev;
 		int button;
 		int line, col;
-		termkey_interpret_mouse (tk, key, &ev, &button, &line, &col);
+		termo_interpret_mouse (tk, key, &ev, &button, &line, &col);
 
 		static const char *evnames[] =
 			{ "Unknown", "Press", "Drag", "Release" };
 		l = snprintf (buffer + pos, len - pos,
 			"Mouse%s(%d)", evnames[ev], button);
-		if (format & TERMKEY_FORMAT_MOUSE_POS)
+		if (format & TERMO_FORMAT_MOUSE_POS)
 		{
 			if (l <= 0)
 				return pos;
@@ -1480,13 +1480,13 @@ termkey_strfkey (termkey_t *tk, char *buffer, size_t len,
 		}
 		break;
 	}
-	case TERMKEY_TYPE_POSITION:
+	case TERMO_TYPE_POSITION:
 		l = snprintf (buffer + pos, len - pos, "Position");
 		break;
-	case TERMKEY_TYPE_MODEREPORT:
+	case TERMO_TYPE_MODEREPORT:
 	{
 		int initial, mode, value;
-		termkey_interpret_modereport (tk, key, &initial, &mode, &value);
+		termo_interpret_modereport (tk, key, &initial, &mode, &value);
 		if (initial)
 			l = snprintf (buffer + pos, len - pos,
 				"Mode(%c%d=%d)", initial, mode, value);
@@ -1495,7 +1495,7 @@ termkey_strfkey (termkey_t *tk, char *buffer, size_t len,
 				"Mode(%d=%d)", mode, value);
 		break;
 	}
-	case TERMKEY_TYPE_UNKNOWN_CSI:
+	case TERMO_TYPE_UNKNOWN_CSI:
 		l = snprintf (buffer + pos, len - pos,
 			"CSI %c", key->code.number & 0xff);
 		break;
@@ -1516,23 +1516,23 @@ termkey_strfkey (termkey_t *tk, char *buffer, size_t len,
 }
 
 const char *
-termkey_strpkey (termkey_t *tk,
-	const char *str, termkey_key_t *key, termkey_format_t format)
+termo_strpkey (termo_t *tk,
+	const char *str, termo_key_t *key, termo_format_t format)
 {
 	struct modnames *mods = &modnames[
-		!!(format & TERMKEY_FORMAT_LONGMOD) +
-		!!(format & TERMKEY_FORMAT_ALTISMETA) * 2 +
-		!!(format & TERMKEY_FORMAT_LOWERMOD) * 4];
+		!!(format & TERMO_FORMAT_LONGMOD) +
+		!!(format & TERMO_FORMAT_ALTISMETA) * 2 +
+		!!(format & TERMO_FORMAT_LOWERMOD) * 4];
 
 	key->modifiers = 0;
 
-	if ((format & TERMKEY_FORMAT_CARETCTRL) && str[0] == '^' && str[1])
+	if ((format & TERMO_FORMAT_CARETCTRL) && str[0] == '^' && str[1])
 	{
-		str = termkey_strpkey (tk,
-			str + 1, key, format & ~TERMKEY_FORMAT_CARETCTRL);
+		str = termo_strpkey (tk,
+			str + 1, key, format & ~TERMO_FORMAT_CARETCTRL);
 
 		if (!str
-		 || key->type != TERMKEY_TYPE_KEY
+		 || key->type != TERMO_TYPE_KEY
  		 || key->code.codepoint < '@'
 		 || key->code.codepoint > '_'
  		 || key->modifiers != 0)
@@ -1541,22 +1541,22 @@ termkey_strpkey (termkey_t *tk,
 		if (key->code.codepoint >= 'A'
 		 && key->code.codepoint <= 'Z')
 			key->code.codepoint += 0x20;
-		key->modifiers = TERMKEY_KEYMOD_CTRL;
+		key->modifiers = TERMO_KEYMOD_CTRL;
 		fill_multibyte (tk, key);
 		return (char *) str;
 	}
 
 	const char *sep_at;
 	while ((sep_at = strchr (str,
-		(format & TERMKEY_FORMAT_SPACEMOD) ? ' ' : '-')))
+		(format & TERMO_FORMAT_SPACEMOD) ? ' ' : '-')))
 	{
 		size_t n = sep_at - str;
 		if (n == strlen (mods->alt) && !strncmp (mods->alt, str, n))
-			key->modifiers |= TERMKEY_KEYMOD_ALT;
+			key->modifiers |= TERMO_KEYMOD_ALT;
 		else if (n == strlen (mods->ctrl) && !strncmp (mods->ctrl, str, n))
-			key->modifiers |= TERMKEY_KEYMOD_CTRL;
+			key->modifiers |= TERMO_KEYMOD_CTRL;
 		else if (n == strlen (mods->shift) && !strncmp (mods->shift, str, n))
-			key->modifiers |= TERMKEY_KEYMOD_SHIFT;
+			key->modifiers |= TERMO_KEYMOD_SHIFT;
 		else
 			break;
 
@@ -1567,22 +1567,22 @@ termkey_strpkey (termkey_t *tk,
 	ssize_t snbytes;
 	const char *endstr;
 
-	if ((endstr = termkey_lookup_keyname_format
+	if ((endstr = termo_lookup_keyname_format
 		(tk, str, &key->code.sym, format)))
 	{
-		key->type = TERMKEY_TYPE_KEYSYM;
+		key->type = TERMO_TYPE_KEYSYM;
 		str = endstr;
 	}
 	else if (sscanf(str, "F%d%zn", &key->code.number, &snbytes) == 1)
 	{
-		key->type = TERMKEY_TYPE_FUNCTION;
+		key->type = TERMO_TYPE_FUNCTION;
 		str += snbytes;
 	}
 	// Multibyte must be last
 	else if (parse_multibyte (tk, (unsigned const char *) str, strlen (str),
-		&key->code.codepoint, &nbytes) == TERMKEY_RES_KEY)
+		&key->code.codepoint, &nbytes) == TERMO_RES_KEY)
 	{
-		key->type = TERMKEY_TYPE_KEY;
+		key->type = TERMO_TYPE_KEY;
 		fill_multibyte (tk, key);
 		str += nbytes;
 	}
@@ -1590,39 +1590,39 @@ termkey_strpkey (termkey_t *tk,
 	else
 		return NULL;
 
-	termkey_canonicalise (tk, key);
+	termo_canonicalise (tk, key);
 	return (char *) str;
 }
 
 int
-termkey_keycmp (termkey_t *tk,
-	const termkey_key_t *key1p, const termkey_key_t *key2p)
+termo_keycmp (termo_t *tk,
+	const termo_key_t *key1p, const termo_key_t *key2p)
 {
 	/* Copy the key structs since we'll be modifying them */
-	termkey_key_t key1 = *key1p, key2 = *key2p;
+	termo_key_t key1 = *key1p, key2 = *key2p;
 
-	termkey_canonicalise (tk, &key1);
-	termkey_canonicalise (tk, &key2);
+	termo_canonicalise (tk, &key1);
+	termo_canonicalise (tk, &key2);
 
 	if (key1.type != key2.type)
 		return key1.type - key2.type;
 
 	switch (key1.type)
 	{
-	case TERMKEY_TYPE_KEY:
+	case TERMO_TYPE_KEY:
 		if (key1.code.codepoint != key2.code.codepoint)
 			return key1.code.codepoint - key2.code.codepoint;
 		break;
-	case TERMKEY_TYPE_KEYSYM:
+	case TERMO_TYPE_KEYSYM:
 		if (key1.code.sym != key2.code.sym)
 			return key1.code.sym - key2.code.sym;
 		break;
-	case TERMKEY_TYPE_FUNCTION:
-	case TERMKEY_TYPE_UNKNOWN_CSI:
+	case TERMO_TYPE_FUNCTION:
+	case TERMO_TYPE_UNKNOWN_CSI:
 		if (key1.code.number != key2.code.number)
 			return key1.code.number - key2.code.number;
 		break;
-	case TERMKEY_TYPE_MOUSE:
+	case TERMO_TYPE_MOUSE:
 	{
 		int cmp = memcmp (&key1.code.mouse, &key2.code.mouse,
 			sizeof key1.code.mouse);
@@ -1630,20 +1630,20 @@ termkey_keycmp (termkey_t *tk,
 			return cmp;
 		break;
 	}
-	case TERMKEY_TYPE_POSITION:
+	case TERMO_TYPE_POSITION:
 	{
 		int line1, col1, line2, col2;
-		termkey_interpret_position (tk, &key1, &line1, &col1);
-		termkey_interpret_position (tk, &key2, &line2, &col2);
+		termo_interpret_position (tk, &key1, &line1, &col1);
+		termo_interpret_position (tk, &key2, &line2, &col2);
 		if (line1 != line2)
 			return line1 - line2;
 		return col1 - col2;
 	}
-	case TERMKEY_TYPE_MODEREPORT:
+	case TERMO_TYPE_MODEREPORT:
 	{
 		int initial1, initial2, mode1, mode2, value1, value2;
-		termkey_interpret_modereport (tk, &key1, &initial1, &mode1, &value1);
-		termkey_interpret_modereport (tk, &key2, &initial2, &mode2, &value2);
+		termo_interpret_modereport (tk, &key1, &initial1, &mode1, &value1);
+		termo_interpret_modereport (tk, &key2, &initial2, &mode2, &value2);
 		if (initial1 != initial2)
 			return initial1 - initial2;
 		if (mode1 != mode2)
diff --git a/termo.h b/termo.h
new file mode 100644
index 0000000..3bd1a00
--- /dev/null
+++ b/termo.h
@@ -0,0 +1,277 @@
+#ifndef TERMO_H
+#define TERMO_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <limits.h>
+
+#include "termo-config.h"
+
+#define TERMO_CHECK_VERSION \
+	termo_check_version (TERMO_VERSION_MAJOR, TERMO_VERSION_MINOR)
+
+typedef enum termo_sym termo_sym_t;
+enum termo_sym
+{
+	TERMO_SYM_UNKNOWN = -1,
+	TERMO_SYM_NONE = 0,
+
+	/* Special names in C0 */
+	TERMO_SYM_BACKSPACE,
+	TERMO_SYM_TAB,
+	TERMO_SYM_ENTER,
+	TERMO_SYM_ESCAPE,
+
+	/* Special names in G0 */
+	TERMO_SYM_SPACE,
+	TERMO_SYM_DEL,
+
+	/* Special keys */
+	TERMO_SYM_UP,
+	TERMO_SYM_DOWN,
+	TERMO_SYM_LEFT,
+	TERMO_SYM_RIGHT,
+	TERMO_SYM_BEGIN,
+	TERMO_SYM_FIND,
+	TERMO_SYM_INSERT,
+	TERMO_SYM_DELETE,
+	TERMO_SYM_SELECT,
+	TERMO_SYM_PAGEUP,
+	TERMO_SYM_PAGEDOWN,
+	TERMO_SYM_HOME,
+	TERMO_SYM_END,
+
+	/* Special keys from terminfo */
+	TERMO_SYM_CANCEL,
+	TERMO_SYM_CLEAR,
+	TERMO_SYM_CLOSE,
+	TERMO_SYM_COMMAND,
+	TERMO_SYM_COPY,
+	TERMO_SYM_EXIT,
+	TERMO_SYM_HELP,
+	TERMO_SYM_MARK,
+	TERMO_SYM_MESSAGE,
+	TERMO_SYM_MOVE,
+	TERMO_SYM_OPEN,
+	TERMO_SYM_OPTIONS,
+	TERMO_SYM_PRINT,
+	TERMO_SYM_REDO,
+	TERMO_SYM_REFERENCE,
+	TERMO_SYM_REFRESH,
+	TERMO_SYM_REPLACE,
+	TERMO_SYM_RESTART,
+	TERMO_SYM_RESUME,
+	TERMO_SYM_SAVE,
+	TERMO_SYM_SUSPEND,
+	TERMO_SYM_UNDO,
+
+	/* Numeric keypad special keys */
+	TERMO_SYM_KP0,
+	TERMO_SYM_KP1,
+	TERMO_SYM_KP2,
+	TERMO_SYM_KP3,
+	TERMO_SYM_KP4,
+	TERMO_SYM_KP5,
+	TERMO_SYM_KP6,
+	TERMO_SYM_KP7,
+	TERMO_SYM_KP8,
+	TERMO_SYM_KP9,
+	TERMO_SYM_KPENTER,
+	TERMO_SYM_KPPLUS,
+	TERMO_SYM_KPMINUS,
+	TERMO_SYM_KPMULT,
+	TERMO_SYM_KPDIV,
+	TERMO_SYM_KPCOMMA,
+	TERMO_SYM_KPPERIOD,
+	TERMO_SYM_KPEQUALS,
+
+	TERMO_N_SYMS
+};
+
+typedef enum termo_type termo_type_t;
+enum termo_type
+{
+	TERMO_TYPE_KEY,
+	TERMO_TYPE_FUNCTION,
+	TERMO_TYPE_KEYSYM,
+	TERMO_TYPE_MOUSE,
+	TERMO_TYPE_POSITION,
+	TERMO_TYPE_MODEREPORT,
+	/* add other recognised types here */
+
+	TERMO_TYPE_UNKNOWN_CSI = -1
+};
+
+typedef enum termo_result termo_result_t;
+enum termo_result
+{
+	TERMO_RES_NONE,
+	TERMO_RES_KEY,
+	TERMO_RES_EOF,
+	TERMO_RES_AGAIN,
+	TERMO_RES_ERROR
+};
+
+typedef enum termo_mouse_event termo_mouse_event_t;
+enum termo_mouse_event
+{
+	TERMO_MOUSE_UNKNOWN,
+	TERMO_MOUSE_PRESS,
+	TERMO_MOUSE_DRAG,
+	TERMO_MOUSE_RELEASE
+};
+
+enum
+{
+	TERMO_KEYMOD_SHIFT = 1 << 0,
+	TERMO_KEYMOD_ALT   = 1 << 1,
+	TERMO_KEYMOD_CTRL  = 1 << 2
+};
+
+typedef struct termo_key termo_key_t;
+struct termo_key
+{
+	termo_type_t type;
+	union
+	{
+		uint32_t      codepoint; /* TERMO_TYPE_KEY */
+		int           number;    /* TERMO_TYPE_FUNCTION */
+		termo_sym_t sym;       /* TERMO_TYPE_KEYSYM */
+
+		/* TERMO_TYPE_MODEREPORT */
+		/* opaque, see termo_interpret_modereport() */
+		struct { char initial; int mode, value; } mode;
+
+		/* TERMO_TYPE_MOUSE */
+		/* opaque, see termo_interpret_mouse() */
+		struct { uint16_t x, y, info; } mouse;
+	} code;
+
+	int modifiers;
+
+	/* The raw multibyte sequence for the key */
+	char multibyte[MB_LEN_MAX + 1];
+};
+
+typedef struct termo termo_t;
+
+enum
+{
+	/* Do not interpret C0//DEL codes if possible */
+	TERMO_FLAG_NOINTERPRET = 1 << 0,
+	/* Convert KP codes to regular keypresses */
+	TERMO_FLAG_CONVERTKP   = 1 << 1,
+	/* Don't try to decode the input characters */
+	TERMO_FLAG_RAW         = 1 << 2,
+	/* Do not make initial termios calls on construction */
+	TERMO_FLAG_NOTERMIOS   = 1 << 4,
+	/* Sets TERMO_CANON_SPACESYMBOL */
+	TERMO_FLAG_SPACESYMBOL = 1 << 5,
+	/* Allow Ctrl-C to be read as normal, disabling SIGINT */
+	TERMO_FLAG_CTRLC       = 1 << 6,
+	/* Return ERROR on signal (EINTR) rather than retry */
+	TERMO_FLAG_EINTR       = 1 << 7
+};
+
+enum
+{
+	TERMO_CANON_SPACESYMBOL = 1 << 0, /* Space is symbolic rather than Unicode */
+	TERMO_CANON_DELBS       = 1 << 1  /* Del is converted to Backspace */
+};
+
+void termo_check_version (int major, int minor);
+
+termo_t *termo_new (int fd, const char *encoding, int flags);
+termo_t *termo_new_abstract (const char *term,
+	const char *encoding, int flags);
+void termo_free (termo_t *tk);
+void termo_destroy (termo_t *tk);
+
+int termo_start (termo_t *tk);
+int termo_stop (termo_t *tk);
+int termo_is_started (termo_t *tk);
+
+int termo_get_fd (termo_t *tk);
+
+int termo_get_flags (termo_t *tk);
+void termo_set_flags (termo_t *tk, int newflags);
+
+int termo_get_waittime (termo_t *tk);
+void termo_set_waittime (termo_t *tk, int msec);
+
+int termo_get_canonflags (termo_t *tk);
+void termo_set_canonflags (termo_t *tk, int flags);
+
+size_t termo_get_buffer_size (termo_t *tk);
+int termo_set_buffer_size (termo_t *tk, size_t size);
+
+size_t termo_get_buffer_remaining (termo_t *tk);
+
+void termo_canonicalise (termo_t *tk, termo_key_t *key);
+
+termo_result_t termo_getkey (termo_t *tk, termo_key_t *key);
+termo_result_t termo_getkey_force (termo_t *tk, termo_key_t *key);
+termo_result_t termo_waitkey (termo_t *tk, termo_key_t *key);
+
+termo_result_t termo_advisereadable (termo_t *tk);
+
+size_t termo_push_bytes (termo_t *tk, const char *bytes, size_t len);
+
+termo_sym_t termo_register_keyname (termo_t *tk,
+	termo_sym_t sym, const char *name);
+const char *termo_get_keyname (termo_t *tk, termo_sym_t sym);
+const char *termo_lookup_keyname (termo_t *tk,
+	const char *str, termo_sym_t *sym);
+
+termo_sym_t termo_keyname2sym (termo_t *tk, const char *keyname);
+
+termo_result_t termo_interpret_mouse (termo_t *tk,
+	const termo_key_t *key, termo_mouse_event_t *event,
+	int *button, int *line, int *col);
+termo_result_t termo_interpret_position (termo_t *tk,
+	const termo_key_t *key, int *line, int *col);
+termo_result_t termo_interpret_modereport (termo_t *tk,
+	const termo_key_t *key, int *initial, int *mode, int *value);
+termo_result_t termo_interpret_csi (termo_t *tk,
+	const termo_key_t *key, long args[], size_t *nargs, unsigned long *cmd);
+
+typedef enum termo_format termo_format_t;
+enum termo_format
+{
+	/* Shift-... instead of S-... */
+	TERMO_FORMAT_LONGMOD     = 1 << 0,
+	/* ^X instead of C-X */
+	TERMO_FORMAT_CARETCTRL   = 1 << 1,
+	/* Meta- or M- instead of Alt- or A- */
+	TERMO_FORMAT_ALTISMETA   = 1 << 2,
+	/* Wrap special keys in brackets like <Escape> */
+	TERMO_FORMAT_WRAPBRACKET = 1 << 3,
+	/* M Foo instead of M-Foo */
+	TERMO_FORMAT_SPACEMOD    = 1 << 4,
+	/* meta or m instead of Meta or M */
+	TERMO_FORMAT_LOWERMOD    = 1 << 5,
+	/* page down instead of PageDown */
+	TERMO_FORMAT_LOWERSPACE  = 1 << 6,
+	/* Include mouse position if relevant; @ col,line */
+	TERMO_FORMAT_MOUSE_POS   = 1 << 8
+};
+
+/* Some useful combinations */
+
+#define TERMO_FORMAT_VIM (termo_format_t) \
+	(TERMO_FORMAT_ALTISMETA | TERMO_FORMAT_WRAPBRACKET)
+#define TERMO_FORMAT_URWID (termo_format_t) \
+	(TERMO_FORMAT_LONGMOD | TERMO_FORMAT_ALTISMETA | \
+	 TERMO_FORMAT_LOWERMOD | TERMO_FORMAT_SPACEMOD | \
+	 TERMO_FORMAT_LOWERSPACE)
+
+size_t termo_strfkey (termo_t *tk, char *buffer, size_t len,
+	termo_key_t *key, termo_format_t format);
+const char *termo_strpkey (termo_t *tk, const char *str,
+	termo_key_t *key, termo_format_t format);
+
+int termo_keycmp (termo_t *tk,
+	const termo_key_t *key1, const termo_key_t *key2);
+
+#endif  // ! TERMO_H
+