keyboard_control.cpp File Reference

#include <cassert>
#include <cctype>
#include <chrono>
#include <climits>
#include <cmath>
#include <condition_variable>
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <mutex>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <thread>
#include <utility>
#include <sys/select.h>
#include "compat/time.h"
#include "debug.h"
#include "host.h"
#include "keyboard_control.h"
#include "messaging.h"
#include "module.h"
#include "types.h"
#include "utils/color_out.h"
#include "utils/thread.h"
#include "video.h"
#include <conio.h>

Include dependency graph for keyboard_control.cpp:

Go to the source code of this file.

Classes
class	keyboard_control::impl
struct	keyboard_control::impl::m_mod

Macros
#define	CHECK_EOF(x)
#define	CONFIG_FILE   "ug-key-map.txt"
#define	G(key)
#define	GETCH   getch
#define	MOD_NAME   "[key control] "

Functions
	ADD_TO_PARAM ("disable-keyboard-control", "* disable-keyboard-control[=no]\n" " disables keyboard control (usable mainly for non-interactive runs)\n")
static int	count_utf8_bytes (unsigned int i)
static int64_t	get_ansi_code ()
void	get_keycode_name (int64_t ch, char *buf, size_t buflen)
static string	get_keycode_representation (int64_t ch)
static int64_t	get_utf8_code (int c)
static string	get_utf8_representation (int64_t ch)
static bool	is_utf8 (int64_t ch)
bool	keycontrol_register_key (struct module *receiver_mod, int64_t key, const char *message, const char *description)
	Registers callback message for given key.
void	keycontrol_send_key (struct module *root, int64_t key)
static void	print_start_elapsed_time (time_t start_time)
void	restore_old_tio (void)
static bool	set_tio ()

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

With code taken from Olivier Mehani (set_tio()).

Todo

Consider using some abstraction over terminal control mainly because differencies between Linux and Windows (ANSI mode or terminfo?)

Todo

• key should not be overriden (eg. preset and custom)
• preset keys and customs ones should be unified (in key mapping)

Definition in file keyboard_control.cpp.

Macro Definition Documentation

CHECK_EOF

#define CHECK_EOF

(

x

)

Value:

        do { \
                if ((x) < 0) { \
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME \
                            "Unexpected " << ((x) == -1 ? "EOF" : "error") \
                                               << " detected!\n"; \
                        return EOF; \
                } \
        } while (0)

Definition at line 319 of file keyboard_control.cpp.

#define CHECK_EOF(x) \
        do { \
                if ((x) < 0) { \
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME \
                            "Unexpected " << ((x) == -1 ? "EOF" : "error") \
                                               << " detected!\n"; \
                        return EOF; \
                } \
        } while (0)

Referenced by get_ansi_code(), keyboard_control::impl::get_next_key(), and get_utf8_code().

CONFIG_FILE

#define CONFIG_FILE   "ug-key-map.txt"

Definition at line 102 of file keyboard_control.cpp.

Referenced by keyboard_control::impl::exec_local_command(), and keyboard_control::impl::load_config_map().

G

#define G

(

key

)

Value:

(guarded_keys.find(key) != guarded_keys.end() ? " [g]" : "")

Definition at line 808 of file keyboard_control.cpp.

GETCH

#define GETCH   getch

Definition at line 316 of file keyboard_control.cpp.

Referenced by get_ansi_code(), keyboard_control::impl::get_next_key(), and get_utf8_code().

MOD_NAME

#define MOD_NAME   "[key control] "

Definition at line 103 of file keyboard_control.cpp.

Function Documentation

ADD_TO_PARAM()

ADD_TO_PARAM	(	"disable-keyboard-control"	,
		"* disable-keyboard-control\n" " disables keyboard control (usable mainly for non-interactive runs)\n"	[=no] )

count_utf8_bytes()

static int count_utf8_bytes ( unsigned int i )

static

Definition at line 380 of file keyboard_control.cpp.

                                            {
        int count = 0;
        while ((i & 0x80) != 0u) {
                count++;
                i <<= 1;
        }
        return count;
}

References count.

Referenced by get_utf8_code().

get_ansi_code()

static int64_t get_ansi_code ( )

static

Tries to parse at least some small subset of ANSI control sequences not to be ArrowUp interpreted as '\033', '[' and 'A' individually.

Return values

<0

on error

Todo

• improve coverage and/or find some suitable implemnation (ideally one file, not ncurses)
• the function can be moved to separate util file

Definition at line 340 of file keyboard_control.cpp.

                               {
        int64_t c = GETCH();
        debug_msg(MOD_NAME "Pressed %" PRId64 "\n", c);
        if (c == '[') { // CSI
                c = '\033' << 8 | '[';
                while (true) {
                        if ((c >> 56u) != 0) {
                                LOG(LOG_LEVEL_WARNING) << MOD_NAME "Long control sequence detected!\n";
                                return INT64_MIN;
                        }
                        c <<= 8;
                        int tmp = GETCH();
                        assert(tmp < 0x80); // ANSI esc seq should use only 7-bit encoding
                        debug_msg(MOD_NAME "Pressed %d\n", tmp);
                        CHECK_EOF(tmp);
                        c |= tmp;
                        if (tmp >= 0x40 && tmp <= 0xee) { // final byte
                                break;
                        }
                }
        } else if (c == 'N' // is this even used?
                        || c == 'O') { // eg. \EOP - F1-F4 (the rest of Fn is CSI)
                int tmp = GETCH();
                debug_msg(MOD_NAME "Pressed %d\n", tmp);
                CHECK_EOF(tmp);
                c = '\033' << 16 | c << 8 | tmp;
        } else if (c >= 'a' && c <= 'z') {
                return K_ALT(c);
        } else {
                LOG(LOG_LEVEL_WARNING) << MOD_NAME "Unknown control sequence!\n";
                return INT64_MIN;
        }
 
        return c;
}

References CHECK_EOF, debug_msg, GETCH, K_ALT, LOG, LOG_LEVEL_WARNING, and MOD_NAME.

Referenced by keyboard_control::impl::get_next_key().

get_keycode_name()

void get_keycode_name	(	int64_t	ch,
		char *	buf,
		size_t	buflen )

Definition at line 1063 of file keyboard_control.cpp.

                                                            {
        if (buflen == 0) {
                return;
        }
        string name = get_keycode_representation(ch);
        strncpy(buf, name.c_str(), buflen - 1);
        buf[buflen - 1] = '\0';
}

References get_keycode_representation(), and name.

Referenced by gl_show_help(), and glfw_key_callback().

Here is the call graph for this function:

get_keycode_representation()

static string get_keycode_representation ( int64_t ch )

static

Definition at line 453 of file keyboard_control.cpp.

                                                     {
        switch (ch) {
        case K_UP: return "Up";
        case K_DOWN: return "Down";
        case K_LEFT: return "Left";
        case K_RIGHT: return "Right";
        case K_PGUP: return "Page-Up";
        case K_PGDOWN: return "Page-Dn";
        case K_CTRL_UP: return "Ctrl-Up";
        case K_CTRL_DOWN: return "Ctrl-Dn";
        }
 
        if (ch >= 1 && ch <= 'z' - 'a' + 1) {
                return string("Ctrl-") + string(1, 'a' + ch - 1);
        }
 
        if (ch >> 16 == 0 && ch >> 8 == '\033') {
                return string("Alt-") + string(1, ch & 0xff);
        }
 
        if (ch <= UCHAR_MAX && isprint(ch)) {
                return string("'") + string(1, ch) + "'";
        }
 
        if (is_utf8(ch)) {
                return string("'") + get_utf8_representation(ch) + "'";
        }
 
        stringstream oss;
        oss << "0x" << hex << ch;
        return oss.str();
}

References get_utf8_representation(), is_utf8(), K_CTRL_DOWN, K_CTRL_UP, K_DOWN, K_LEFT, K_PGDOWN, K_PGUP, K_RIGHT, and K_UP.

Referenced by keyboard_control::impl::exec_local_command(), get_keycode_name(), keyboard_control::impl::run(), and keyboard_control::impl::usage().

Here is the call graph for this function:

get_utf8_code()

static int64_t get_utf8_code ( int c )

static

Return values

<0

on error

Definition at line 390 of file keyboard_control.cpp.

                                    {
        if (c < 0xc0) {
                LOG(LOG_LEVEL_WARNING) << MOD_NAME "Wrong UTF sequence!\n";
                return INT64_MIN;
        }
        int ones = count_utf8_bytes(c);
        for (int i = 1; i < ones; ++i) {
                c = (c & 0x7fffff) << 8;
                int tmp = GETCH();
                debug_msg(MOD_NAME "Pressed %d\n", tmp);
                CHECK_EOF(tmp);
                c |= tmp;
        }
        if (ones > 7) {
                LOG(LOG_LEVEL_WARNING) << MOD_NAME "Unsupported UTF sequence length!\n";
                return INT64_MIN;
        }
        return c;
}

References CHECK_EOF, count_utf8_bytes(), debug_msg, GETCH, LOG, LOG_LEVEL_WARNING, and MOD_NAME.

Referenced by keyboard_control::impl::get_next_key().

Here is the call graph for this function:

get_utf8_representation()

static string get_utf8_representation ( int64_t ch )

static

Definition at line 443 of file keyboard_control.cpp.

                                                  {
        char str[9] = "";
        while (ch != 0) {
                memmove(str + 1, str, 8);
                str[0] = ch & 0xff;
                ch >>= 8;
        }
        return str;
}

Referenced by get_keycode_representation().

is_utf8()

static bool is_utf8 ( int64_t ch )

static

Todo

UTF-8 validity check would be nice

Definition at line 426 of file keyboard_control.cpp.

                                {
#ifdef _WIN32
        return false;
#endif
 
        if (ch <= 0) {
                return false;
        }
 
        unsigned char first_byte = 0U;
        while (ch != 0) {
                first_byte = ch & 0xff;
                ch >>= 8;
        }
        return first_byte & 0x80; 
}

Referenced by get_keycode_representation().

keycontrol_register_key()

bool keycontrol_register_key	(	struct module *	receiver_mod,
		int64_t	key,
		const char *	message,
		const char *	description )

Registers callback message for given key.

message_universal message type is always sent

Parameters

[in]	sender_mod	module that should receive the message for key
[in]	message	text that will be passed back to receiver_mod if key was pressed
[in]	description	optional decription that will be displayed in keyboard control help (may be NULL)

Definition at line 1041 of file keyboard_control.cpp.

                                                                                                                     {
        assert(strchr(message, '#') == nullptr && (description == nullptr || strchr(description, '#') == nullptr));
        char receiver_path[1024];
        if (!module_get_path_str(receiver_mod, receiver_path, sizeof receiver_path)) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot format format path for sender!\n");
                return false;
        }
        struct msg_universal *m = (struct msg_universal *) new_message(sizeof(struct msg_universal));
        if (description == nullptr) {
                description = message;
        }
        snprintf(m->text, sizeof m->text, "map #%" PRId64 " %s %s#%s", key, receiver_path, message, description);
        struct response *r = send_message_sync(get_root_module(receiver_mod), "keycontrol", (struct message *) m, 100,  SEND_MESSAGE_FLAG_QUIET | SEND_MESSAGE_FLAG_NO_STORE);
        if (response_get_status(r) != RESPONSE_OK) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot register keyboard control (error %d)!\n", response_get_status(r));
                free_response(r);
                return false;
        }
        free_response(r);
        return true;
}

References description, free_response(), get_root_module(), key, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, module_get_path_str(), new_message(), response_get_status(), RESPONSE_OK, SEND_MESSAGE_FLAG_NO_STORE, SEND_MESSAGE_FLAG_QUIET, send_message_sync(), and msg_universal::text.

Referenced by display_gl_init(), display_sdl2_init(), display_sdl_init(), and playback_register_keyboard_ctl().

Here is the call graph for this function:

keycontrol_send_key()

void keycontrol_send_key	(	struct module *	root,
		int64_t	key )

Todo

all UG core functions should have the 'used' attribute

Definition at line 1024 of file keyboard_control.cpp.

                                                           {
        struct msg_universal *m = (struct msg_universal *) new_message(sizeof(struct msg_universal));
        snprintf(m->text, sizeof m->text, "press %" PRId64, key);
        struct response *r = send_message_sync(root, "keycontrol", (struct message *) m, 100,  SEND_MESSAGE_FLAG_QUIET | SEND_MESSAGE_FLAG_NO_STORE);
        if (response_get_status(r) != RESPONSE_OK) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot set key to keycontrol (error %d)!\n", response_get_status(r));
        }
        free_response(r);
}

References free_response(), key, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, new_message(), response_get_status(), RESPONSE_OK, SEND_MESSAGE_FLAG_NO_STORE, SEND_MESSAGE_FLAG_QUIET, send_message_sync(), and msg_universal::text.

Referenced by display_sdl2_run(), and glfw_key_callback().

Here is the call graph for this function:

print_start_elapsed_time()

static void print_start_elapsed_time ( time_t start_time )

static

Definition at line 696 of file keyboard_control.cpp.

{
        enum {
                ELAPS_LEN = 9,
                START_LEN = 25,
        };
        struct tm tm_buf = {};
 
        localtime_s(&start_time, &tm_buf);
        char start[START_LEN] = "";
        strftime(start, sizeof start, "%c", &tm_buf);
 
        const time_t diff = time(nullptr) - start_time;
        gmtime_s(&diff, &tm_buf);
        char elapsed[ELAPS_LEN] = "";
        strftime(elapsed, sizeof elapsed, "%T", &tm_buf);
 
        col() << TBOLD("Start time: ") << start << " (elapsed " << elapsed
              << ")\n";
}

References gmtime_s, localtime_s, keyboard_control::start(), start_time, and TBOLD.

Referenced by keyboard_control::impl::info().

Here is the call graph for this function:

restore_old_tio()

void restore_old_tio

(

void

)

Definition at line 188 of file keyboard_control.cpp.

{
#ifdef HAVE_TERMIOS_H
        struct sigaction sa, sa_old;
        memset(&sa, 0, sizeof sa);
        sa.sa_handler = SIG_IGN;
        sigemptyset(&sa.sa_mask);
        sigaction(SIGTTOU, &sa, &sa_old);
        /* set the new settings immediately */
        /* restore the former settings */
        tcsetattr(STDIN_FILENO,TCSANOW,&old_tio);
        sigaction(SIGTTOU, &sa_old, NULL);
#endif
}

Referenced by crash_signal_handler(), keyboard_control::impl::read_command(), and keyboard_control::impl::start().

set_tio()

static bool set_tio ( )

static

From http://shtrom.ssji.net/skb/getc.html

Definition at line 982 of file keyboard_control.cpp.

{
#ifdef HAVE_TERMIOS_H
        struct termios new_tio = old_tio;
        /* disable canonical mode (buffered i/o) and local echo */
        new_tio.c_lflag &=(~ICANON & ~ECHO);
        // Wrap calling of tcsetattr() by handling SIGTTOU. SIGTTOU can be raised if task is
        // run in background and trying to call tcsetattr(). If so, we disable keyboard
        // control.
        struct sigaction sa, sa_old;
        memset(&sa, 0, sizeof sa);
        sa.sa_handler = catch_signal;
        sigemptyset(&sa.sa_mask);
        sigaction(SIGTTOU, &sa, &sa_old);
        /* set the new settings immediately */
        tcsetattr(STDIN_FILENO,TCSANOW,&new_tio);
        sigaction(SIGTTOU, &sa_old, NULL);
 
        if (!signal_catched) {
                return true;
        }
#endif
        return false;
}

Referenced by keyboard_control::impl::read_command(), and keyboard_control::impl::start().