diff options
| -rw-r--r-- | CMakeLists.txt | 42 | ||||
| -rw-r--r-- | README | 18 | ||||
| -rw-r--r-- | config.cmake.in | 2 | ||||
| -rw-r--r-- | demo-async.c | 34 | ||||
| -rw-r--r-- | demo-glib.c | 32 | ||||
| -rw-r--r-- | demo.c | 54 | ||||
| -rw-r--r-- | driver-csi.c | 408 | ||||
| -rw-r--r-- | driver-ti.c | 164 | ||||
| -rw-r--r-- | termkey2-config.h.in | 8 | ||||
| -rw-r--r-- | termkey2.h | 277 | ||||
| -rw-r--r-- | termo-config.h.in | 8 | ||||
| -rw-r--r-- | termo-internal.h (renamed from termkey2-internal.h) | 60 | ||||
| -rw-r--r-- | termo.c (renamed from termkey2.c) | 722 | ||||
| -rw-r--r-- | termo.h | 277 |
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 @@ -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); } @@ -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 @@ -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) @@ -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 + |