keyboard_control::impl Class Reference

Collaboration diagram for keyboard_control::impl:

Classes
struct	m_mod

Public Member Functions
	impl (struct module *parent)
	~impl ()
void	msg_received ()
void	start ()
void	stop ()

Static Public Member Functions
static void	msg_received_func (struct module *)

Private Member Functions
void	exec_external_commands (const char *commands)
bool	exec_local_command (const char *command)
void	execute_command (const char *command)
int64_t	get_next_key ()
void	info ()
void	load_config_map ()
void	read_command (bool multiple)
void	run ()
void	signal ()
void	usage ()

Private Attributes
std::set< int64_t >	guarded_keys { '*', '/', '9', '0', 'c', 'C', 'm', 'M', '>', '<', 'e', 's', 'S', 'v', 'V', 'r' }
std::map< int64_t, std::pair< std::string, std::string > >	key_mapping
std::condition_variable	m_cv
std::thread	m_keyboard_thread
std::mutex	m_lock
bool	m_locked_against_changes {true}
struct module *	m_parent
std::queue< int64_t >	m_pressed_keys
struct module *	m_root {nullptr}
bool	m_should_exit {false}
std::time_t	m_start_time
bool	m_started {false}

Detailed Description

Definition at line 134 of file keyboard_control.cpp.

Constructor & Destructor Documentation

impl()

keyboard_control::impl::impl ( struct module * parent )

explicit

Definition at line 203 of file keyboard_control.cpp.

                                                :
        m_parent(parent)
{
        m_start_time = time(NULL);
 
        m_root = get_root_module(parent);
 
#ifdef HAVE_TERMIOS_H
        /* get the terminal settings for stdin */
        /* we want to keep the old setting to restore them a the end */
        tcgetattr(STDIN_FILENO,&old_tio);
#endif
 
        module_init_default(&m_mod);
        m_mod.cls = MODULE_CLASS_KEYCONTROL;
        m_mod.priv_data = this;
        m_mod.new_message = keyboard_control::impl::msg_received_func;
        module_register(&m_mod, m_parent);
}

References get_root_module(), m_parent, m_root, m_start_time, MODULE_CLASS_KEYCONTROL, module_init_default(), module_register(), msg_received_func(), and parent.

Here is the call graph for this function:

~impl()

keyboard_control::impl::~impl

(

)

Definition at line 223 of file keyboard_control.cpp.

                            {
        stop(); // in case that it was not called explicitly
}

References keyboard_control::stop().

Here is the call graph for this function:

Member Function Documentation

exec_external_commands()

void keyboard_control::impl::exec_external_commands ( const char * commands )

private

Definition at line 914 of file keyboard_control.cpp.

{
        char *cpy = strdup(commands);
        char *item, *save_ptr, *tmp = cpy;
        while ((item = strtok_r(tmp, ";", &save_ptr))) {
                struct msg_universal *m = (struct msg_universal *) new_message(sizeof(struct msg_universal));
                strcpy(m->text, "execute ");
                strncat(m->text, item, sizeof m->text - strlen(m->text) - 1);
                struct response *r = send_message_sync(m_root, "control", (struct message *) m, 100,  SEND_MESSAGE_FLAG_QUIET | SEND_MESSAGE_FLAG_NO_STORE);
                if (response_get_status(r) != RESPONSE_OK) {
                        LOG(LOG_LEVEL_ERROR) << "Could not send a message!\n";
                }
                free_response(r);
 
                tmp = nullptr;
        }
        free(cpy);
}

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

Here is the call graph for this function:

exec_local_command()

bool keyboard_control::impl::exec_local_command ( const char * command )

private

Definition at line 862 of file keyboard_control.cpp.

{
        if (strcmp(command, "localhelp") == 0) {
                printf("Local help:\n"
                                "\tmap <X> cmd1[;cmd2..][#name]\n"
                                "\t\tmaps key to command(s) for control socket (with an optional\n\t\tidentifier)\n"
                                "\tmap #<X> cmd1[;cmd2..][#name]\n"
                                "\t\tmaps key number (ASCII or multi-byte for non-ASCII) to\n\t\tcommand(s) for control socket (with an optional identifier)\n"
                                "\tunmap <X>\n"
                                "\tpress <num>\n"
                                "\t\tEmulate pressing key <num>\n\n"
                                "Mappings can be stored in " CONFIG_FILE "\n\n");
                return true;
        } else if (strstr(command, "map ") == command) {
                char *ccpy = strdup(command + strlen("map "));
                if (strlen(ccpy) > 3) {
                        int64_t key = ccpy[0];
                        char *command = ccpy + 2;
                        if (key == '#' && isdigit(ccpy[1])) {
                                key = strtoll(ccpy + 1, &command, 10);
                                command += 1; // skip ' '
                        }
                        const char *name = "";
                        if (strchr(command, '#')) {
                                name = strchr(command, '#') + 1;
                                *strchr(command, '#') = '\0';
                        }
                        if (key_mapping.find(key) == key_mapping.end()) {
                                key_mapping.insert({key, make_pair(command, name)});
                        } else {
                                LOG(LOG_LEVEL_ERROR) << MOD_NAME << "Trying to register key shortcut " << get_keycode_representation(key) << ", which is already regestered, ignoring.\n";
                        }
                }
                free(ccpy);
                return true;
        } else if (strstr(command, "unmap ") == command) {
                command += strlen("unmap ");
                if (strlen(command) >= 1) {
                        key_mapping.erase(command[0]);
                }
                return true;
        } else if (strstr(command, "press ") == command) {
                const char *key = command + strlen("press ");
                int64_t k;
                sscanf(key, "%" SCNi64, &k);
                m_pressed_keys.push(k);
                signal();
                return true;
        }
        return false;
}

References CONFIG_FILE, get_keycode_representation(), key, LOG, LOG_LEVEL_ERROR, MOD_NAME, and name.

Here is the call graph for this function:

execute_command()

void keyboard_control::impl::execute_command ( const char * command )

private

Definition at line 933 of file keyboard_control.cpp.

                                                              {
        if (!exec_local_command(command)) {
                exec_external_commands(command);
        }
}

get_next_key()

int64_t keyboard_control::impl::get_next_key ( )

private

Returns

next key either from keyboard or received via control socket.

Return values

0	if m_should_exit is set
-1	on EOF
-2	on error

Definition at line 492 of file keyboard_control.cpp.

{
        int64_t c;
        while (1) {
                {
                        unique_lock<mutex> lk(m_lock);
                        if (m_should_exit) {
                                return 0;
                        }
 
                        if (!m_pressed_keys.empty()) {
                                c = m_pressed_keys.front();
                                m_pressed_keys.pop();
                                return c;
                        }
                }
#ifdef HAVE_TERMIOS_H
                fd_set set;
                FD_ZERO(&set);
                FD_SET(0, &set);
                FD_SET(m_event_pipe[0], &set);
                select(m_event_pipe[0] + 1, &set, NULL, NULL, NULL);
 
                if (FD_ISSET(m_event_pipe[0], &set)) {
                        char c;
                        int bytes = read(m_event_pipe[0], &c, 1);
                        assert(bytes == 1);
                        continue; // skip to event processing
                }
 
                if (FD_ISSET(0, &set)) {
#else
                if (kbhit()) {
#endif
                        int64_t c = GETCH();
                        debug_msg(MOD_NAME "Pressed %" PRId64 "\n", c);
                        if (c == '\033') {
                                if ((c = get_ansi_code()) < 0) {
                                        continue;
                                }
#ifdef _WIN32
                        } else if (c == 0x0 || c == 0xe0) { // Win keycodes
                                int tmp = GETCH();
                                debug_msg(MOD_NAME "Pressed %d\n", tmp);
                                CHECK_EOF(tmp);
                                if ((c = convert_win_to_ansi_keycode(c << 8 | tmp)) == -1) {
                                        continue;
                                }
#else
                        } else if (c > 0x80) {
                                if ((c = get_utf8_code(c)) < 0) {
                                        continue;
                                }
#endif
                        }
                        return c;
                }
#if !defined HAVE_TERMIOS_H
                // kbhit is non-blockinkg - we don't want to busy-wait
                unique_lock<mutex> lk(m_lock);
                m_cv.wait_for(lk, milliseconds(200));
                lk.unlock();
#endif
        }
}

References CHECK_EOF, debug_msg, get_ansi_code(), get_utf8_code(), GETCH, and MOD_NAME.

Here is the call graph for this function:

info()

void keyboard_control::impl::info ( )

private

Definition at line 717 of file keyboard_control.cpp.

{
        col() << TBOLD("UltraGrid version: ") << get_version_details() << "\n";
        print_start_elapsed_time(m_start_time);
        col() << TBOLD("Verbosity level: ") << log_level << (log_level == LOG_LEVEL_INFO ? " (default)" : "") << "\n";
        col() << TBOLD("Locked against changes: ") << (m_locked_against_changes ? "true" : "false") << "\n";
        col() << TBOLD("Audio playback delay: ") << get_audio_delay() << " ms\n";
 
        {
                int muted_sender = -1;
                int muted_receiver = -1;
                const char *path = "audio.receiver";
                auto *m_recv = reinterpret_cast<struct msg_receiver *>(new_message(sizeof(struct msg_receiver)));
                m_recv->type = RECEIVER_MSG_GET_AUDIO_STATUS;
                auto *resp = send_message_sync(m_root, path, reinterpret_cast<struct message *>(m_recv), 100, SEND_MESSAGE_FLAG_QUIET | SEND_MESSAGE_FLAG_NO_STORE);
                if (response_get_status(resp) == 200) {
                        double vol = 0;
                        sscanf(response_get_text(resp), "%lf,%d", &vol, &muted_receiver);
                        double db = 20.0 * log10(vol);
                        color_printf(TBOLD("Playback volume: ") "%.2f%% (%s%.2f dB)\n", vol * 100.0, (db >= 0.0 ? "+" : ""), db);
                }
                free_response(resp);
                path = "audio.sender";
                auto *m_send = reinterpret_cast<struct msg_sender *>(new_message(sizeof(struct msg_sender)));
                m_send->type = SENDER_MSG_GET_STATUS;
                resp = send_message_sync(m_root, path, reinterpret_cast<struct message *>(m_send), 100, SEND_MESSAGE_FLAG_QUIET | SEND_MESSAGE_FLAG_NO_STORE);
                if (response_get_status(resp) == 200) {
                        sscanf(response_get_text(resp), "%d", &muted_sender);
                }
                free_response(resp);
                auto muted_to_string = [](int val) {
                        switch (val) {
                                case 0: return "false";
                                case 1: return "true";
                                default: return "(unknown)";
                        }
                };
                col() << TBOLD("Audio muted - sender: ") << muted_to_string(muted_sender) << ", " << TBOLD("receiver: ") << muted_to_string(muted_receiver) << "\n";
        }
 
        {
                struct video_desc desc{};
                struct msg_sender *m = (struct msg_sender *) new_message(sizeof(struct msg_sender));
                m->type = SENDER_MSG_QUERY_VIDEO_MODE;
                struct response *r = send_message_sync(m_root, "sender", (struct message *) m, 100,  SEND_MESSAGE_FLAG_QUIET | SEND_MESSAGE_FLAG_NO_STORE);
                if (response_get_status(r) == RESPONSE_OK) {
                        const char *text = response_get_text(r);
                        istringstream iss(text);
                        iss >> desc;
                        col() << TBOLD("Captured video format: ") << desc << "\n";
                }
                free_response(r);
        }
 
        {
                struct video_desc desc{};
                struct msg_universal *m = (struct msg_universal *) new_message(sizeof(struct msg_universal));
                strcpy(m->text, "get_format");
                struct response *r = send_message_sync(m_root, "receiver.decoder", (struct message *) m, 100,  SEND_MESSAGE_FLAG_QUIET | SEND_MESSAGE_FLAG_NO_STORE);
                if (response_get_status(r) == RESPONSE_OK) {
                        const char *text = response_get_text(r);
                        istringstream iss(text);
                        iss >> desc;
                        col() << TBOLD("Received video format: ") <<  desc << "\n";
                }
                free_response(r);
        }
 
        {
                struct msg_universal *m = (struct msg_universal *) new_message(sizeof(struct msg_universal));
                strcpy(m->text, "get_port");
                struct response *r = send_message_sync(m_root, "control", (struct message *) m, 100,  SEND_MESSAGE_FLAG_QUIET | SEND_MESSAGE_FLAG_NO_STORE);
                if (response_get_status(r) == RESPONSE_OK) {
                        col() << TBOLD("Control port: ") << response_get_text(r) << "\n";
                }
                free_response(r);
        }
 
        {
                struct msg_universal *m = (struct msg_universal *) new_message(sizeof(struct msg_universal));
                strcpy(m->text, "status");
                struct response *r = send_message_sync(m_root, "exporter", (struct message *) m, 100,  SEND_MESSAGE_FLAG_QUIET | SEND_MESSAGE_FLAG_NO_STORE);
                if (response_get_status(r) == RESPONSE_OK) {
                        col() << TBOLD("Exporting: ") << response_get_text(r) << "\n";
                }
                free_response(r);
        }
 
        cout << "\n";
}

References color_printf(), desc, free_response(), get_audio_delay(), get_version_details(), log_level, LOG_LEVEL_INFO, new_message(), print_start_elapsed_time(), RECEIVER_MSG_GET_AUDIO_STATUS, response_get_status(), response_get_text(), RESPONSE_OK, SEND_MESSAGE_FLAG_NO_STORE, SEND_MESSAGE_FLAG_QUIET, send_message_sync(), SENDER_MSG_GET_STATUS, SENDER_MSG_QUERY_VIDEO_MODE, TBOLD, msg_universal::text, msg_receiver::type, msg_sender::type, and val.

Here is the call graph for this function:

load_config_map()

void keyboard_control::impl::load_config_map ( )

private

Definition at line 841 of file keyboard_control.cpp.

                                           {
        FILE *in = fopen(CONFIG_FILE, "r");
        if (!in) {
                return;
        }
        char buf[1024];
        while (fgets(buf, sizeof buf - 1, in)) {
                if (strlen(buf) > 0 && buf[strlen(buf) - 1] == '\n') { // trim NL
                        buf[strlen(buf) - 1] = '\0';
                }
                if (strlen(buf) == 0) {
                        continue;
                }
                if (!exec_local_command(buf)) {
                        LOG(LOG_LEVEL_ERROR) << "Wrong config: " << buf << "\n";
                        continue;
                }
        }
        fclose(in);
}

References CONFIG_FILE, LOG, and LOG_LEVEL_ERROR.

msg_received()

void keyboard_control::impl::msg_received

(

)

Definition at line 1013 of file keyboard_control.cpp.

                                        {
        struct message *msg;
        while ((msg = check_message(&m_mod))) {
                auto m = reinterpret_cast<struct msg_universal *>(msg);
                lock_guard<mutex> lk(m_lock);
                execute_command(m->text);
                struct response *r = new_response(RESPONSE_OK, nullptr);
                free_message((struct message *) m, r);
        }
}

References check_message(), free_message(), msg, new_response(), and RESPONSE_OK.

Referenced by msg_received_func().

Here is the call graph for this function:

msg_received_func()

void keyboard_control::impl::msg_received_func ( struct module * m )

static

Definition at line 1007 of file keyboard_control.cpp.

                                                             {
        auto s = static_cast<keyboard_control::impl *>(m->priv_data);
 
        s->msg_received();
}

References msg_received(), and module::priv_data.

Referenced by impl().

Here is the call graph for this function:

read_command()

void keyboard_control::impl::read_command ( bool multiple )

private

Definition at line 939 of file keyboard_control.cpp.

{
        int saved_log_level = log_level;
        log_level = LOG_LEVEL_QUIET;
        restore_old_tio();
        if (multiple) {
                printf("Enter commands for control (try \"help\" or \"localhelp\").\n");
                printf("Exit the mode with blank line.\n");
        } else {
                printf("Enter a command for control (try \"help\" or \"localhelp\"):\n");
        }
        while (1) {
                log_level = LOG_LEVEL_QUIET;
                printf("control> ");
                char buf[sizeof msg_universal::text];
                if (!fgets(buf, sizeof buf - 1, stdin)) {
                        log_level = saved_log_level;
                        break;
                }
                log_level = saved_log_level;
 
                if (strlen(buf) == 0 || (strlen(buf) == 1 && buf[0] == '\n')) { // empty input
                        break;
                }
                if (buf[strlen(buf) - 1] == '\n') { // strip newline
                        buf[strlen(buf) - 1] = '\0';
                }
 
                m_lock.lock();
                execute_command(buf);
                m_lock.unlock();
 
                if (!multiple) {
                        break;
                }
        }
 
        set_tio();
}

References log_level, LOG_LEVEL_QUIET, restore_old_tio(), set_tio(), and msg_universal::text.

Here is the call graph for this function:

run()

void keyboard_control::impl::run ( )

private

Definition at line 558 of file keyboard_control.cpp.

{
        set_thread_name("keyboard-control");
        int saved_log_level = -1;
        int64_t c;
 
        while ((c = get_next_key())) {
                if (c == -1) {
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME
                            "EOF detected! Exiting keyboard control.\n";
                        break;
                }
                if (c == -2) {
                        perror(MOD_NAME "Error detected");
                        continue;
                }
                if (c == K_CTRL('X')) {
                        m_locked_against_changes = !m_locked_against_changes; // ctrl-x pressed
                        col() << TGREEN("Keyboard control: " << (m_locked_against_changes ? "" : "un") << "locked against changes\n");
                        continue;
                }
                if (m_locked_against_changes && guarded_keys.find(c) != guarded_keys.end()) {
                        col() << TGREEN("Keyboard control: locked against changes, press 'Ctrl-x' to unlock or 'h' for help.\n");
                        continue;
                }
 
                m_lock.lock();
                if (key_mapping.find(c) != key_mapping.end()) { // user defined mapping exists
                        string cmd = key_mapping.at(c).first;
                        exec_external_commands(cmd.c_str());
                        m_lock.unlock();
                        continue;
                }
                m_lock.unlock();
 
                switch (c) {
                case '*':
                case '/':
                case '9':
                case '0':
                case 'm':
                {
                        char path[] = "audio.receiver";
                        auto m = (struct msg_receiver *) new_message(sizeof(struct msg_receiver));
                        switch (c) {
                        case '0':
                        case '*': m->type = RECEIVER_MSG_INCREASE_VOLUME; break;
                        case '9':
                        case '/': m->type = RECEIVER_MSG_DECREASE_VOLUME; break;
                        case 'm': m->type = RECEIVER_MSG_MUTE_TOGGLE; break;
                        }
 
                        auto resp = send_message(m_root, path, (struct message *) m);
                        free_response(resp);
                        break;
                }
                case 'M':
                {
                        char path[] = "audio.sender";
                        auto m = (struct msg_sender *) new_message(sizeof(struct msg_sender));
                        m->type = SENDER_MSG_MUTE_TOGGLE;
 
                        auto resp = send_message(m_root, path, (struct message *) m);
                        free_response(resp);
                        break;
                }
                case '>':
                case '<':
                {
                        int audio_delay = get_audio_delay();
                        audio_delay += c == '>' ? 10 : -10;
                        log_msg(LOG_LEVEL_INFO, "New audio delay: %d ms.\n", audio_delay);
                        set_audio_delay(audio_delay);
                        break;
                }
                case 'e':
                {
                        char path[] = "exporter";
                        auto m = (struct message *) new_message(sizeof(struct msg_universal));
                        strcpy(((struct msg_universal *) m)->text, "toggle");
                        auto resp = send_message(m_root, path, (struct message *) m);
                        free_response(resp);
                        break;
                }
                case 'c':
                case 'C':
                        read_command(c == 'C');
                        break;
                case 'v':
                case 'V':
                {
                        if (islower(c)) {
                                log_level = (log_level + 1) % (LOG_LEVEL_MAX + 1);
                        } else {
                                log_level = (log_level - 1 + (LOG_LEVEL_MAX + 1)) % (LOG_LEVEL_MAX + 1);
                        }
                        cout << "Log level: " << log_level << "\n";
                        break;
                }
                case 'r':
                {
                        bool skip = !get_log_output().get_skip_repeats();
                        get_log_output().set_skip_repeats(skip);
                        cout << "Skip repeated messages: " << std::boolalpha << skip << std::noboolalpha << "\n";
                        break;
                }
                case 's':
                        if (saved_log_level == -1) {
                                saved_log_level = log_level;
                                col() << TGREEN("Output suspended, press 'q' to continue.\n");
                                log_level = LOG_LEVEL_QUIET;
                        }
                        break;
                case 'S':
                        if (saved_log_level != -1) {
                                log_level = saved_log_level;
                                saved_log_level = -1;
                                col() << TGREEN( "Output resumed.\n");
                        }
                        break;
                case 'h':
                        usage();
                        break;
                case 'i':
                        cout << "\n";
                        info();
                        break;
                case '\n':
                case '\r':
                        cout << endl;
                        break;
                default:
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME "Unsupported key " << get_keycode_representation(c) << " pressed. Press 'h' to help.\n";
                }
        }
}

References free_response(), get_audio_delay(), get_keycode_representation(), get_log_output(), Log_output::get_skip_repeats(), K_CTRL, LOG, log_level, LOG_LEVEL_INFO, LOG_LEVEL_MAX, LOG_LEVEL_QUIET, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, new_message(), RECEIVER_MSG_DECREASE_VOLUME, RECEIVER_MSG_INCREASE_VOLUME, RECEIVER_MSG_MUTE_TOGGLE, send_message(), SENDER_MSG_MUTE_TOGGLE, set_audio_delay(), Log_output::set_skip_repeats(), set_thread_name(), TGREEN, and usage().

Referenced by start().

Here is the call graph for this function:

signal()

void keyboard_control::impl::signal ( )

private

Definition at line 276 of file keyboard_control.cpp.

{
#ifdef HAVE_TERMIOS_H
        char c = 0;
        if (write(m_event_pipe[1], &c, 1) != 1) {
                perror(MOD_NAME "m_event_pipe write");
        }
#else
        m_cv.notify_one();
#endif
}

References MOD_NAME.

start()

void keyboard_control::impl::start

(

)

Definition at line 229 of file keyboard_control.cpp.

{
        bool force_key_control = false;
        if (get_commandline_param("disable-keyboard-control")) {
                if (strcmp(get_commandline_param("disable-keyboard-control"),
                           "no") != 0) {
                        return;
                }
                force_key_control = true;
        }
 
        if (!force_key_control) {
                if (running_in_debugger()) {
                        LOG(LOG_LEVEL_WARNING)
                            << MOD_NAME "Running inside gdb - disabling "
                                        "interactive keyboard control\n";
                        return;
                }
#ifdef HAVE_TERMIOS_H
                if (!isatty(STDIN_FILENO)) {
                        log_msg(LOG_LEVEL_WARNING,
                                "[key control] Stdin is not a TTY - disabling "
                                "keyboard control.\n");
                        return;
                }
#endif // defined HAVE_TERMIOS_H
        }
 
#ifdef HAVE_TERMIOS_H
        if (pipe(m_event_pipe) != 0) {
                log_msg(LOG_LEVEL_ERROR, "[key control] Cannot create control pipe!\n");
                return;
        }
 
        if (!set_tio()) {
                log_msg(LOG_LEVEL_WARNING, "[key control] Background task - disabling keyboard control.\n");
                return;
        }
        atexit(restore_old_tio);
#endif
 
        load_config_map();
 
        m_keyboard_thread = thread(&keyboard_control::impl::run, this);
        m_started = true;
}

References get_commandline_param(), LOG, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, restore_old_tio(), run(), running_in_debugger(), and set_tio().

Referenced by keyboard_control::start().

Here is the call graph for this function:

stop()

void keyboard_control::impl::stop

(

)

Definition at line 288 of file keyboard_control.cpp.

{
        module_done(&m_mod);
        unique_lock<mutex> lk(m_lock);
        if (!m_started) {
                return;
        }
        m_should_exit = true;
        m_started = false;
        lk.unlock();
        signal();
        m_keyboard_thread.join();
 
#ifdef HAVE_TERMIOS_H
        close(m_event_pipe[0]);
        close(m_event_pipe[1]);
#endif
}

References module_done().

Here is the call graph for this function:

usage()

void keyboard_control::impl::usage ( )

private

Definition at line 810 of file keyboard_control.cpp.

{
        col() << "\nAvailable keybindings:\n" <<
                TBOLD("\t  * 0  ") << "- increase receiver volume" << G('*') << "\n" <<
                TBOLD("\t  / 9  ") << "- decrease receiver volume" << G('/') << "\n" <<
                TBOLD("\t   >   ") << "- increase receiver audio delay by 10 ms" << G('>') << "\n" <<
                TBOLD("\t   <   ") << "- decrease receiver audio delay by 10 ms" << G('<') << "\n" <<
                TBOLD("\t   m   ") << "- mute/unmute receiver" << G('m') << "\n" <<
                TBOLD("\t   M   ") << "- mute/unmute sender" << G('M') << "\n" <<
                TBOLD("\t   v   ") << "- increase verbosity level" << G('v') << "\n" <<
                TBOLD("\t   V   ") << "- decrease verbosity level" << G('V') << "\n" <<
                TBOLD("\t   r   ") << "- skip repeated messages (toggle) " << G('r') << "\n" <<
                TBOLD("\t   e   ") << "- record captured content (toggle)" << G('e') << "\n" <<
                TBOLD("\t   h   ") << "- show help" << G('h') << "\n" <<
                TBOLD("\t   i   ") << "- show various information" << G('i') << "\n" <<
                TBOLD("\t  s S  ") << "- suspend/resume output" << G('s') << G('S') << "\n" <<
                TBOLD("\t  c C  ") << "- execute command through control socket (capital for multiple)" << G('c') << G('C') << "\n" <<
                TBOLD("\tCtrl-x ") << "- unlock/lock against changes" << G(K_CTRL('X')) << "\n" <<
                TBOLD("\tCtrl-c ") << "- exit " << G(K_CTRL('c')) << "\n" <<
                "\n";
 
        if (key_mapping.size() > 0) {
                cout << "Custom keybindings:\n";
                for (auto const &it : key_mapping) {
                        col() << TBOLD("\t" << setw(10) << get_keycode_representation(it.first) << setw(0) <<) << " - " << (it.second.second.empty() ? it.second.first : it.second.second) << G(it.first) << "\n";
                }
                cout << "\n";
        }
        col() << TBOLD("[g]") << " indicates that that option is guarded (Ctrl-x needs to be pressed first)\n";
}

References G, get_keycode_representation(), K_CTRL, and TBOLD.

Here is the call graph for this function:

Member Data Documentation

guarded_keys

std::set<int64_t> keyboard_control::impl::guarded_keys { '*', '/', '9', '0', 'c', 'C', 'm', 'M', '>', '<', 'e', 's', 'S', 'v', 'V', 'r' }

private

Definition at line 174 of file keyboard_control.cpp.

{ '*', '/', '9', '0', 'c', 'C', 'm', 'M', '>', '<', 'e', 's', 'S', 'v', 'V', 'r' };

key_mapping

std::map<int64_t, std::pair<std::string, std::string> > keyboard_control::impl::key_mapping

private

Definition at line 175 of file keyboard_control.cpp.

m_cv

std::condition_variable keyboard_control::impl::m_cv

private

Definition at line 166 of file keyboard_control.cpp.

m_keyboard_thread

std::thread keyboard_control::impl::m_keyboard_thread

private

Definition at line 160 of file keyboard_control.cpp.

m_lock

std::mutex keyboard_control::impl::m_lock

private

Definition at line 176 of file keyboard_control.cpp.

m_locked_against_changes

bool keyboard_control::impl::m_locked_against_changes {true}

private

Definition at line 171 of file keyboard_control.cpp.

{true};

m_parent

struct module* keyboard_control::impl::m_parent

private

Definition at line 162 of file keyboard_control.cpp.

Referenced by impl().

m_pressed_keys

std::queue<int64_t> keyboard_control::impl::m_pressed_keys

private

Definition at line 169 of file keyboard_control.cpp.

m_root

struct module* keyboard_control::impl::m_root {nullptr}

private

Definition at line 161 of file keyboard_control.cpp.

{nullptr};

Referenced by impl().

m_should_exit

bool keyboard_control::impl::m_should_exit {false}

private

Definition at line 168 of file keyboard_control.cpp.

{false};

m_start_time

std::time_t keyboard_control::impl::m_start_time

private

Definition at line 172 of file keyboard_control.cpp.

Referenced by impl().

m_started

bool keyboard_control::impl::m_started {false}

private

Definition at line 170 of file keyboard_control.cpp.

{false};

---

The documentation for this class was generated from the following file:

• src/keyboard_control.cpp