Adding upstream version 3:4.8.30.upstream/3%4.8.30

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2252 insertions, 0 deletions

diff --git a/lib/tty/key.c b/lib/tty/key.c
new file mode 100644
index 0000000..5671666
--- /dev/null
+++ b/lib/tty/key.c
@@ -0,0 +1,2252 @@
+/*
+   Keyboard support routines.
+
+   Copyright (C) 1994-2023
+   Free Software Foundation, Inc.
+
+   Written by:
+   Miguel de Icaza, 1994, 1995
+   Janne Kukonlehto, 1994, 1995
+   Jakub Jelinek, 1995
+   Norbert Warmuth, 1997
+   Denys Vlasenko <vda.linux@googlemail.com>, 2013
+   Slava Zanko <slavazanko@gmail.com>, 2013
+   Egmont Koblinger <egmont@gmail.com>, 2013
+
+   This file is part of the Midnight Commander.
+
+   The Midnight Commander is free software: you can redistribute it
+   and/or modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   The Midnight Commander is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** \file key.c
+ *  \brief Source: keyboard support routines
+ */
+
+#include <config.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#else
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
+#include "lib/global.h"
+
+#include "lib/vfs/vfs.h"
+
+#include "tty.h"
+#include "tty-internal.h"       /* mouse_enabled */
+#include "mouse.h"
+#include "key.h"
+
+#include "lib/widget.h"         /* mc_refresh() */
+
+#ifdef HAVE_TEXTMODE_X11_SUPPORT
+#include "x11conn.h"
+#endif
+
+#ifdef __linux__
+#if defined(__GLIBC__) && (__GLIBC__ < 2)
+#include <linux/termios.h>      /* TIOCLINUX */
+#else
+#include <termios.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h>
+#endif
+#endif /* __linux__ */
+
+#ifdef __CYGWIN__
+#include <termios.h>
+#ifdef HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h>
+#endif
+#endif /* __CYGWIN__ */
+
+#ifdef __QNXNTO__
+#include <dlfcn.h>
+#include <Ph.h>
+#include <sys/dcmd_chr.h>
+#endif /* __QNXNTO__ */
+
+/*** global variables ****************************************************************************/
+
+int mou_auto_repeat = 100;      /* ms */
+int double_click_speed = 250;   /* ms */
+gboolean old_esc_mode = TRUE;
+/* timeout for old_esc_mode in usec */
+int old_esc_mode_timeout = G_USEC_PER_SEC;      /* us, settable via env */
+gboolean use_8th_bit_as_meta = FALSE;
+
+gboolean bracketed_pasting_in_progress = FALSE;
+
+/* This table is a mapping between names and the constants we use
+ * We use this to allow users to define alternate definitions for
+ * certain keys that may be missing from the terminal database
+ */
+const key_code_name_t key_name_conv_tab[] = {
+    {ESC_CHAR, "escape", N_("Escape"), "Esc"},
+    /* KEY_F(0) is not here, since we are mapping it to f10, so there is no reason
+       to define f0 as well. Also, it makes Learn keys a bunch of problems :( */
+    {KEY_F (1), "f1", N_("Function key 1"), "F1"},
+    {KEY_F (2), "f2", N_("Function key 2"), "F2"},
+    {KEY_F (3), "f3", N_("Function key 3"), "F3"},
+    {KEY_F (4), "f4", N_("Function key 4"), "F4"},
+    {KEY_F (5), "f5", N_("Function key 5"), "F5"},
+    {KEY_F (6), "f6", N_("Function key 6"), "F6"},
+    {KEY_F (7), "f7", N_("Function key 7"), "F7"},
+    {KEY_F (8), "f8", N_("Function key 8"), "F8"},
+    {KEY_F (9), "f9", N_("Function key 9"), "F9"},
+    {KEY_F (10), "f10", N_("Function key 10"), "F10"},
+    {KEY_F (11), "f11", N_("Function key 11"), "F11"},
+    {KEY_F (12), "f12", N_("Function key 12"), "F12"},
+    {KEY_F (13), "f13", N_("Function key 13"), "F13"},
+    {KEY_F (14), "f14", N_("Function key 14"), "F14"},
+    {KEY_F (15), "f15", N_("Function key 15"), "F15"},
+    {KEY_F (16), "f16", N_("Function key 16"), "F16"},
+    {KEY_F (17), "f17", N_("Function key 17"), "F17"},
+    {KEY_F (18), "f18", N_("Function key 18"), "F18"},
+    {KEY_F (19), "f19", N_("Function key 19"), "F19"},
+    {KEY_F (20), "f20", N_("Function key 20"), "F20"},
+    {ALT ('\t'), "complete", N_("Completion/M-tab"), "Meta-Tab"},
+    {KEY_BTAB, "backtab", N_("BackTab/S-tab"), "Shift-Tab"},
+    {KEY_BACKSPACE, "backspace", N_("Backspace"), "Backspace"},
+    {KEY_UP, "up", N_("Up arrow"), "Up"},
+    {KEY_DOWN, "down", N_("Down arrow"), "Down"},
+    {KEY_LEFT, "left", N_("Left arrow"), "Left"},
+    {KEY_RIGHT, "right", N_("Right arrow"), "Right"},
+    {KEY_IC, "insert", N_("Insert"), "Ins"},
+    {KEY_DC, "delete", N_("Delete"), "Del"},
+    {KEY_HOME, "home", N_("Home"), "Home"},
+    {KEY_END, "end", N_("End key"), "End"},
+    {KEY_PPAGE, "pgup", N_("Page Up"), "PgUp"},
+    {KEY_NPAGE, "pgdn", N_("Page Down"), "PgDn"},
+    {(int) '/', "kpslash", N_("/ on keypad"), "/"},
+    {KEY_KP_MULTIPLY, "kpasterisk", N_("* on keypad"), "*"},
+    {KEY_KP_SUBTRACT, "kpminus", N_("- on keypad"), "-"},
+    {KEY_KP_ADD, "kpplus", N_("+ on keypad"), "+"},
+
+    /* From here on, these won't be shown in Learn keys (no space) */
+    {KEY_LEFT, "kpleft", N_("Left arrow keypad"), "Left"},
+    {KEY_RIGHT, "kpright", N_("Right arrow keypad"), "Right"},
+    {KEY_UP, "kpup", N_("Up arrow keypad"), "Up"},
+    {KEY_DOWN, "kpdown", N_("Down arrow keypad"), "Down"},
+    {KEY_HOME, "kphome", N_("Home on keypad"), "Home"},
+    {KEY_END, "kpend", N_("End on keypad"), "End"},
+    {KEY_NPAGE, "kpnpage", N_("Page Down keypad"), "PgDn"},
+    {KEY_PPAGE, "kpppage", N_("Page Up keypad"), "PgUp"},
+    {KEY_IC, "kpinsert", N_("Insert on keypad"), "Ins"},
+    {KEY_DC, "kpdelete", N_("Delete on keypad"), "Del"},
+    {(int) '\n', "kpenter", N_("Enter on keypad"), "Enter"},
+    {KEY_F (21), "f21", N_("Function key 21"), "F21"},
+    {KEY_F (22), "f22", N_("Function key 22"), "F22"},
+    {KEY_F (23), "f23", N_("Function key 23"), "F23"},
+    {KEY_F (24), "f24", N_("Function key 24"), "F24"},
+    {KEY_A1, "a1", N_("A1 key"), "A1"},
+    {KEY_C1, "c1", N_("C1 key"), "C1"},
+
+    /* Alternative label */
+    {ESC_CHAR, "esc", N_("Escape"), "Esc"},
+    {KEY_BACKSPACE, "bs", N_("Backspace"), "Bakspace"},
+    {KEY_IC, "ins", N_("Insert"), "Ins"},
+    {KEY_DC, "del", N_("Delete"), "Del"},
+    {(int) '*', "asterisk", N_("Asterisk"), "*"},
+    {(int) '-', "minus", N_("Minus"), "-"},
+    {(int) '+', "plus", N_("Plus"), "+"},
+    {(int) '.', "dot", N_("Dot"), "."},
+    {(int) '<', "lt", N_("Less than"), "<"},
+    {(int) '>', "gt", N_("Great than"), ">"},
+    {(int) '=', "equal", N_("Equal"), "="},
+    {(int) ',', "comma", N_("Comma"), ","},
+    {(int) '\'', "apostrophe", N_("Apostrophe"), "\'"},
+    {(int) ':', "colon", N_("Colon"), ":"},
+    {(int) ';', "semicolon", N_("Semicolon"), ";"},
+    {(int) '!', "exclamation", N_("Exclamation mark"), "!"},
+    {(int) '?', "question", N_("Question mark"), "?"},
+    {(int) '&', "ampersand", N_("Ampersand"), "&"},
+    {(int) '$', "dollar", N_("Dollar sign"), "$"},
+    {(int) '"', "quota", N_("Quotation mark"), "\""},
+    {(int) '%', "percent", N_("Percent sign"), "%"},
+    {(int) '^', "caret", N_("Caret"), "^"},
+    {(int) '~', "tilda", N_("Tilda"), "~"},
+    {(int) '`', "prime", N_("Prime"), "`"},
+    {(int) '_', "underline", N_("Underline"), "_"},
+    {(int) '_', "understrike", N_("Understrike"), "_"},
+    {(int) '|', "pipe", N_("Pipe"), "|"},
+    {(int) '(', "lparenthesis", N_("Left parenthesis"), "("},
+    {(int) ')', "rparenthesis", N_("Right parenthesis"), ")"},
+    {(int) '[', "lbracket", N_("Left bracket"), "["},
+    {(int) ']', "rbracket", N_("Right bracket"), "]"},
+    {(int) '{', "lbrace", N_("Left brace"), "{"},
+    {(int) '}', "rbrace", N_("Right brace"), "}"},
+    {(int) '\n', "enter", N_("Enter"), "Enter"},
+    {(int) '\t', "tab", N_("Tab key"), "Tab"},
+    {(int) ' ', "space", N_("Space key"), "Space"},
+    {(int) '/', "slash", N_("Slash key"), "/"},
+    {(int) '\\', "backslash", N_("Backslash key"), "\\"},
+    {(int) '#', "number", N_("Number sign #"), "#"},
+    {(int) '#', "hash", N_("Number sign #"), "#"},
+    /* TRANSLATORS: Please translate as in "at sign" (@). */
+    {(int) '@', "at", N_("At sign"), "@"},
+
+    /* meta keys */
+    {KEY_M_CTRL, "control", N_("Ctrl"), "C"},
+    {KEY_M_CTRL, "ctrl", N_("Ctrl"), "C"},
+    {KEY_M_ALT, "meta", N_("Alt"), "M"},
+    {KEY_M_ALT, "alt", N_("Alt"), "M"},
+    {KEY_M_ALT, "ralt", N_("Alt"), "M"},
+    {KEY_M_SHIFT, "shift", N_("Shift"), "S"},
+
+    {0, NULL, NULL, NULL}
+};
+
+/*** file scope macro definitions ****************************************************************/
+
+#define MC_USEC_PER_MSEC 1000
+
+/* The maximum sequence length (32 + null terminator) */
+#define SEQ_BUFFER_LEN 33
+
+/*** file scope type declarations ****************************************************************/
+
+/* Linux console keyboard modifiers */
+typedef enum
+{
+    SHIFT_PRESSED = (1 << 0),
+    ALTR_PRESSED = (1 << 1),
+    CONTROL_PRESSED = (1 << 2),
+    ALTL_PRESSED = (1 << 3)
+} mod_pressed_t;
+
+typedef struct key_def
+{
+    char ch;                    /* Holds the matching char code */
+    int code;                   /* The code returned, valid if child == NULL */
+    struct key_def *next;
+    struct key_def *child;      /* sequence continuation */
+    int action;                 /* optional action to be done. Now used only
+                                   to mark that we are just after the first
+                                   Escape */
+} key_def;
+
+typedef struct
+{
+    int code;
+    const char *seq;
+    int action;
+} key_define_t;
+
+/* File descriptor monitoring add/remove routines */
+typedef struct
+{
+    int fd;
+    select_fn callback;
+    void *info;
+} select_t;
+
+typedef enum KeySortType
+{
+    KEY_NOSORT = 0,
+    KEY_SORTBYNAME,
+    KEY_SORTBYCODE
+} KeySortType;
+
+#ifdef __QNXNTO__
+typedef int (*ph_dv_f) (void *, void *);
+typedef int (*ph_ov_f) (void *);
+typedef int (*ph_pqc_f) (unsigned short, PhCursorInfo_t *);
+#endif
+
+/*** forward declarations (file scope functions) *************************************************/
+
+/*** file scope variables ************************************************************************/
+
+static key_define_t mc_default_keys[] = {
+    {ESC_CHAR, ESC_STR, MCKEY_ESCAPE},
+    {ESC_CHAR, ESC_STR ESC_STR, MCKEY_NOACTION},
+    {MCKEY_BRACKETED_PASTING_START, ESC_STR "[200~", MCKEY_NOACTION},
+    {MCKEY_BRACKETED_PASTING_END, ESC_STR "[201~", MCKEY_NOACTION},
+    {0, NULL, MCKEY_NOACTION},
+};
+
+/* Broken terminfo and termcap databases on xterminals */
+static key_define_t xterm_key_defines[] = {
+    {KEY_F (1), ESC_STR "OP", MCKEY_NOACTION},
+    {KEY_F (2), ESC_STR "OQ", MCKEY_NOACTION},
+    {KEY_F (3), ESC_STR "OR", MCKEY_NOACTION},
+    {KEY_F (4), ESC_STR "OS", MCKEY_NOACTION},
+    {KEY_F (1), ESC_STR "[11~", MCKEY_NOACTION},
+    {KEY_F (2), ESC_STR "[12~", MCKEY_NOACTION},
+    {KEY_F (3), ESC_STR "[13~", MCKEY_NOACTION},
+    {KEY_F (4), ESC_STR "[14~", MCKEY_NOACTION},
+    {KEY_F (5), ESC_STR "[15~", MCKEY_NOACTION},
+    {KEY_F (6), ESC_STR "[17~", MCKEY_NOACTION},
+    {KEY_F (7), ESC_STR "[18~", MCKEY_NOACTION},
+    {KEY_F (8), ESC_STR "[19~", MCKEY_NOACTION},
+    {KEY_F (9), ESC_STR "[20~", MCKEY_NOACTION},
+    {KEY_F (10), ESC_STR "[21~", MCKEY_NOACTION},
+
+    /* old xterm Shift-arrows */
+    {KEY_M_SHIFT | KEY_UP, ESC_STR "O2A", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_DOWN, ESC_STR "O2B", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_RIGHT, ESC_STR "O2C", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_LEFT, ESC_STR "O2D", MCKEY_NOACTION},
+
+    /* new xterm Shift-arrows */
+    {KEY_M_SHIFT | KEY_UP, ESC_STR "[1;2A", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_DOWN, ESC_STR "[1;2B", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_RIGHT, ESC_STR "[1;2C", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_LEFT, ESC_STR "[1;2D", MCKEY_NOACTION},
+
+    /* more xterm keys with modifiers */
+    {KEY_M_CTRL | KEY_PPAGE, ESC_STR "[5;5~", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_NPAGE, ESC_STR "[6;5~", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_IC, ESC_STR "[2;5~", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_DC, ESC_STR "[3;5~", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_HOME, ESC_STR "[1;5H", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_END, ESC_STR "[1;5F", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_HOME, ESC_STR "[1;2H", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_END, ESC_STR "[1;2F", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_UP, ESC_STR "[1;5A", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_DOWN, ESC_STR "[1;5B", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_RIGHT, ESC_STR "[1;5C", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_LEFT, ESC_STR "[1;5D", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_IC, ESC_STR "[2;2~", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_DC, ESC_STR "[3;2~", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_UP, ESC_STR "[1;6A", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_DOWN, ESC_STR "[1;6B", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_RIGHT, ESC_STR "[1;6C", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_LEFT, ESC_STR "[1;6D", MCKEY_NOACTION},
+    {KEY_M_SHIFT | '\t', ESC_STR "[Z", MCKEY_NOACTION},
+
+    /* putty */
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_UP, ESC_STR "[[1;6A", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_DOWN, ESC_STR "[[1;6B", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_RIGHT, ESC_STR "[[1;6C", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_LEFT, ESC_STR "[[1;6D", MCKEY_NOACTION},
+
+    /* putty alt-arrow keys */
+    /* removed as source esc esc esc trouble */
+    /*
+       { KEY_M_ALT | KEY_UP,    ESC_STR ESC_STR "OA", MCKEY_NOACTION },
+       { KEY_M_ALT | KEY_DOWN,  ESC_STR ESC_STR "OB", MCKEY_NOACTION },
+       { KEY_M_ALT | KEY_RIGHT, ESC_STR ESC_STR "OC", MCKEY_NOACTION },
+       { KEY_M_ALT | KEY_LEFT,  ESC_STR ESC_STR "OD", MCKEY_NOACTION },
+       { KEY_M_ALT | KEY_PPAGE, ESC_STR ESC_STR "[5~", MCKEY_NOACTION },
+       { KEY_M_ALT | KEY_NPAGE, ESC_STR ESC_STR "[6~", MCKEY_NOACTION },
+       { KEY_M_ALT | KEY_HOME,  ESC_STR ESC_STR "[1~", MCKEY_NOACTION },
+       { KEY_M_ALT | KEY_END,   ESC_STR ESC_STR "[4~", MCKEY_NOACTION },
+
+       { KEY_M_CTRL | KEY_M_ALT | KEY_UP,    ESC_STR ESC_STR "[1;2A", MCKEY_NOACTION },
+       { KEY_M_CTRL | KEY_M_ALT | KEY_DOWN,  ESC_STR ESC_STR "[1;2B", MCKEY_NOACTION },
+       { KEY_M_CTRL | KEY_M_ALT | KEY_RIGHT, ESC_STR ESC_STR "[1;2C", MCKEY_NOACTION },
+       { KEY_M_CTRL | KEY_M_ALT | KEY_LEFT,  ESC_STR ESC_STR "[1;2D", MCKEY_NOACTION },
+
+       { KEY_M_CTRL | KEY_M_ALT | KEY_PPAGE, ESC_STR ESC_STR "[[5;5~", MCKEY_NOACTION },
+       { KEY_M_CTRL | KEY_M_ALT | KEY_NPAGE, ESC_STR ESC_STR "[[6;5~", MCKEY_NOACTION },
+       { KEY_M_CTRL | KEY_M_ALT | KEY_HOME,  ESC_STR ESC_STR "[1;5H", MCKEY_NOACTION },
+       { KEY_M_CTRL | KEY_M_ALT | KEY_END,   ESC_STR ESC_STR "[1;5F", MCKEY_NOACTION },
+     */
+    /* xterm alt-arrow keys */
+    {KEY_M_ALT | KEY_UP, ESC_STR "[1;3A", MCKEY_NOACTION},
+    {KEY_M_ALT | KEY_DOWN, ESC_STR "[1;3B", MCKEY_NOACTION},
+    {KEY_M_ALT | KEY_RIGHT, ESC_STR "[1;3C", MCKEY_NOACTION},
+    {KEY_M_ALT | KEY_LEFT, ESC_STR "[1;3D", MCKEY_NOACTION},
+    {KEY_M_ALT | KEY_PPAGE, ESC_STR "[5;3~", MCKEY_NOACTION},
+    {KEY_M_ALT | KEY_NPAGE, ESC_STR "[6;3~", MCKEY_NOACTION},
+    {KEY_M_ALT | KEY_HOME, ESC_STR "[1~", MCKEY_NOACTION},
+    {KEY_M_ALT | KEY_END, ESC_STR "[4~", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_M_ALT | KEY_UP, ESC_STR "[1;7A", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_M_ALT | KEY_DOWN, ESC_STR "[1;7B", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_M_ALT | KEY_RIGHT, ESC_STR "[1;7C", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_M_ALT | KEY_LEFT, ESC_STR "[1;7D", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_M_ALT | KEY_PPAGE, ESC_STR "[5;7~", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_M_ALT | KEY_NPAGE, ESC_STR "[6;7~", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_M_ALT | KEY_HOME, ESC_STR "OH", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_M_ALT | KEY_END, ESC_STR "OF", MCKEY_NOACTION},
+
+    {KEY_M_SHIFT | KEY_M_ALT | KEY_UP, ESC_STR "[1;4A", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_ALT | KEY_DOWN, ESC_STR "[1;4B", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_ALT | KEY_RIGHT, ESC_STR "[1;4C", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_ALT | KEY_LEFT, ESC_STR "[1;4D", MCKEY_NOACTION},
+
+    /* rxvt keys with modifiers */
+    {KEY_M_SHIFT | KEY_UP, ESC_STR "[a", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_DOWN, ESC_STR "[b", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_RIGHT, ESC_STR "[c", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_LEFT, ESC_STR "[d", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_UP, ESC_STR "Oa", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_DOWN, ESC_STR "Ob", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_RIGHT, ESC_STR "Oc", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_LEFT, ESC_STR "Od", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_PPAGE, ESC_STR "[5^", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_NPAGE, ESC_STR "[6^", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_HOME, ESC_STR "[7^", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_END, ESC_STR "[8^", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_HOME, ESC_STR "[7$", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_END, ESC_STR "[8$", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_IC, ESC_STR "[2^", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_DC, ESC_STR "[3^", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_DC, ESC_STR "[3$", MCKEY_NOACTION},
+
+    /* konsole keys with modifiers */
+    {KEY_M_SHIFT | KEY_HOME, ESC_STR "O2H", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_END, ESC_STR "O2F", MCKEY_NOACTION},
+
+    /* gnome-terminal */
+    {KEY_M_SHIFT | KEY_UP, ESC_STR "[2A", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_DOWN, ESC_STR "[2B", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_RIGHT, ESC_STR "[2C", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_LEFT, ESC_STR "[2D", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_UP, ESC_STR "[5A", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_DOWN, ESC_STR "[5B", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_RIGHT, ESC_STR "[5C", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_LEFT, ESC_STR "[5D", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_UP, ESC_STR "[6A", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_DOWN, ESC_STR "[6B", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_RIGHT, ESC_STR "[6C", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_LEFT, ESC_STR "[6D", MCKEY_NOACTION},
+
+    /* gnome-terminal - application mode */
+    {KEY_M_CTRL | KEY_UP, ESC_STR "O5A", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_DOWN, ESC_STR "O5B", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_RIGHT, ESC_STR "O5C", MCKEY_NOACTION},
+    {KEY_M_CTRL | KEY_LEFT, ESC_STR "O5D", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_UP, ESC_STR "O6A", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_DOWN, ESC_STR "O6B", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_RIGHT, ESC_STR "O6C", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_M_CTRL | KEY_LEFT, ESC_STR "O6D", MCKEY_NOACTION},
+
+    /* iTerm */
+    {KEY_M_SHIFT | KEY_PPAGE, ESC_STR "[5;2~", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_NPAGE, ESC_STR "[6;2~", MCKEY_NOACTION},
+
+    /* putty */
+    {KEY_M_SHIFT | KEY_PPAGE, ESC_STR "[[5;53~", MCKEY_NOACTION},
+    {KEY_M_SHIFT | KEY_NPAGE, ESC_STR "[[6;53~", MCKEY_NOACTION},
+
+    /* keypad keys */
+    {KEY_IC, ESC_STR "Op", MCKEY_NOACTION},
+    {KEY_DC, ESC_STR "On", MCKEY_NOACTION},
+    {'/', ESC_STR "Oo", MCKEY_NOACTION},
+    {'\n', ESC_STR "OM", MCKEY_NOACTION},
+
+    {0, NULL, MCKEY_NOACTION},
+};
+
+/* qansi-m terminals have a much more key combinations,
+   which are undefined in termcap/terminfo */
+static key_define_t qansi_key_defines[] = {
+    /* qansi-m terminal */
+    {KEY_M_CTRL | KEY_NPAGE, ESC_STR "[u", MCKEY_NOACTION},     /* Ctrl-PgDown */
+    {KEY_M_CTRL | KEY_PPAGE, ESC_STR "[v", MCKEY_NOACTION},     /* Ctrl-PgUp   */
+    {KEY_M_CTRL | KEY_HOME, ESC_STR "[h", MCKEY_NOACTION},      /* Ctrl-Home   */
+    {KEY_M_CTRL | KEY_END, ESC_STR "[y", MCKEY_NOACTION},       /* Ctrl-End    */
+    {KEY_M_CTRL | KEY_IC, ESC_STR "[`", MCKEY_NOACTION},        /* Ctrl-Insert */
+    {KEY_M_CTRL | KEY_DC, ESC_STR "[p", MCKEY_NOACTION},        /* Ctrl-Delete */
+    {KEY_M_CTRL | KEY_LEFT, ESC_STR "[d", MCKEY_NOACTION},      /* Ctrl-Left   */
+    {KEY_M_CTRL | KEY_RIGHT, ESC_STR "[c", MCKEY_NOACTION},     /* Ctrl-Right  */
+    {KEY_M_CTRL | KEY_DOWN, ESC_STR "[b", MCKEY_NOACTION},      /* Ctrl-Down   */
+    {KEY_M_CTRL | KEY_UP, ESC_STR "[a", MCKEY_NOACTION},        /* Ctrl-Up     */
+    {KEY_M_CTRL | KEY_KP_ADD, ESC_STR "[s", MCKEY_NOACTION},    /* Ctrl-Gr-Plus */
+    {KEY_M_CTRL | KEY_KP_SUBTRACT, ESC_STR "[t", MCKEY_NOACTION},       /* Ctrl-Gr-Minus */
+    {KEY_M_CTRL | '\t', ESC_STR "[z", MCKEY_NOACTION},  /* Ctrl-Tab    */
+    {KEY_M_SHIFT | '\t', ESC_STR "[Z", MCKEY_NOACTION}, /* Shift-Tab   */
+    {KEY_M_CTRL | KEY_F (1), ESC_STR "[1~", MCKEY_NOACTION},    /* Ctrl-F1    */
+    {KEY_M_CTRL | KEY_F (2), ESC_STR "[2~", MCKEY_NOACTION},    /* Ctrl-F2    */
+    {KEY_M_CTRL | KEY_F (3), ESC_STR "[3~", MCKEY_NOACTION},    /* Ctrl-F3    */
+    {KEY_M_CTRL | KEY_F (4), ESC_STR "[4~", MCKEY_NOACTION},    /* Ctrl-F4    */
+    {KEY_M_CTRL | KEY_F (5), ESC_STR "[5~", MCKEY_NOACTION},    /* Ctrl-F5    */
+    {KEY_M_CTRL | KEY_F (6), ESC_STR "[6~", MCKEY_NOACTION},    /* Ctrl-F6    */
+    {KEY_M_CTRL | KEY_F (7), ESC_STR "[7~", MCKEY_NOACTION},    /* Ctrl-F7    */
+    {KEY_M_CTRL | KEY_F (8), ESC_STR "[8~", MCKEY_NOACTION},    /* Ctrl-F8    */
+    {KEY_M_CTRL | KEY_F (9), ESC_STR "[9~", MCKEY_NOACTION},    /* Ctrl-F9    */
+    {KEY_M_CTRL | KEY_F (10), ESC_STR "[10~", MCKEY_NOACTION},  /* Ctrl-F10  */
+    {KEY_M_CTRL | KEY_F (11), ESC_STR "[11~", MCKEY_NOACTION},  /* Ctrl-F11  */
+    {KEY_M_CTRL | KEY_F (12), ESC_STR "[12~", MCKEY_NOACTION},  /* Ctrl-F12  */
+    {KEY_M_ALT | KEY_F (1), ESC_STR "[17~", MCKEY_NOACTION},    /* Alt-F1    */
+    {KEY_M_ALT | KEY_F (2), ESC_STR "[18~", MCKEY_NOACTION},    /* Alt-F2    */
+    {KEY_M_ALT | KEY_F (3), ESC_STR "[19~", MCKEY_NOACTION},    /* Alt-F3    */
+    {KEY_M_ALT | KEY_F (4), ESC_STR "[20~", MCKEY_NOACTION},    /* Alt-F4    */
+    {KEY_M_ALT | KEY_F (5), ESC_STR "[21~", MCKEY_NOACTION},    /* Alt-F5    */
+    {KEY_M_ALT | KEY_F (6), ESC_STR "[22~", MCKEY_NOACTION},    /* Alt-F6    */
+    {KEY_M_ALT | KEY_F (7), ESC_STR "[23~", MCKEY_NOACTION},    /* Alt-F7    */
+    {KEY_M_ALT | KEY_F (8), ESC_STR "[24~", MCKEY_NOACTION},    /* Alt-F8    */
+    {KEY_M_ALT | KEY_F (9), ESC_STR "[25~", MCKEY_NOACTION},    /* Alt-F9    */
+    {KEY_M_ALT | KEY_F (10), ESC_STR "[26~", MCKEY_NOACTION},   /* Alt-F10   */
+    {KEY_M_ALT | KEY_F (11), ESC_STR "[27~", MCKEY_NOACTION},   /* Alt-F11   */
+    {KEY_M_ALT | KEY_F (12), ESC_STR "[28~", MCKEY_NOACTION},   /* Alt-F12   */
+    {KEY_M_ALT | 'a', ESC_STR "Na", MCKEY_NOACTION},    /* Alt-a     */
+    {KEY_M_ALT | 'b', ESC_STR "Nb", MCKEY_NOACTION},    /* Alt-b     */
+    {KEY_M_ALT | 'c', ESC_STR "Nc", MCKEY_NOACTION},    /* Alt-c     */
+    {KEY_M_ALT | 'd', ESC_STR "Nd", MCKEY_NOACTION},    /* Alt-d     */
+    {KEY_M_ALT | 'e', ESC_STR "Ne", MCKEY_NOACTION},    /* Alt-e     */
+    {KEY_M_ALT | 'f', ESC_STR "Nf", MCKEY_NOACTION},    /* Alt-f     */
+    {KEY_M_ALT | 'g', ESC_STR "Ng", MCKEY_NOACTION},    /* Alt-g     */
+    {KEY_M_ALT | 'h', ESC_STR "Nh", MCKEY_NOACTION},    /* Alt-h     */
+    {KEY_M_ALT | 'i', ESC_STR "Ni", MCKEY_NOACTION},    /* Alt-i     */
+    {KEY_M_ALT | 'j', ESC_STR "Nj", MCKEY_NOACTION},    /* Alt-j     */
+    {KEY_M_ALT | 'k', ESC_STR "Nk", MCKEY_NOACTION},    /* Alt-k     */
+    {KEY_M_ALT | 'l', ESC_STR "Nl", MCKEY_NOACTION},    /* Alt-l     */
+    {KEY_M_ALT | 'm', ESC_STR "Nm", MCKEY_NOACTION},    /* Alt-m     */
+    {KEY_M_ALT | 'n', ESC_STR "Nn", MCKEY_NOACTION},    /* Alt-n     */
+    {KEY_M_ALT | 'o', ESC_STR "No", MCKEY_NOACTION},    /* Alt-o     */
+    {KEY_M_ALT | 'p', ESC_STR "Np", MCKEY_NOACTION},    /* Alt-p     */
+    {KEY_M_ALT | 'q', ESC_STR "Nq", MCKEY_NOACTION},    /* Alt-q     */
+    {KEY_M_ALT | 'r', ESC_STR "Nr", MCKEY_NOACTION},    /* Alt-r     */
+    {KEY_M_ALT | 's', ESC_STR "Ns", MCKEY_NOACTION},    /* Alt-s     */
+    {KEY_M_ALT | 't', ESC_STR "Nt", MCKEY_NOACTION},    /* Alt-t     */
+    {KEY_M_ALT | 'u', ESC_STR "Nu", MCKEY_NOACTION},    /* Alt-u     */
+    {KEY_M_ALT | 'v', ESC_STR "Nv", MCKEY_NOACTION},    /* Alt-v     */
+    {KEY_M_ALT | 'w', ESC_STR "Nw", MCKEY_NOACTION},    /* Alt-w     */
+    {KEY_M_ALT | 'x', ESC_STR "Nx", MCKEY_NOACTION},    /* Alt-x     */
+    {KEY_M_ALT | 'y', ESC_STR "Ny", MCKEY_NOACTION},    /* Alt-y     */
+    {KEY_M_ALT | 'z', ESC_STR "Nz", MCKEY_NOACTION},    /* Alt-z     */
+    {KEY_KP_SUBTRACT, ESC_STR "[S", MCKEY_NOACTION},    /* Gr-Minus  */
+    {KEY_KP_ADD, ESC_STR "[T", MCKEY_NOACTION}, /* Gr-Plus   */
+    {0, NULL, MCKEY_NOACTION},
+};
+
+/* This holds all the key definitions */
+static key_def *keys = NULL;
+
+static int input_fd;
+static int disabled_channels = 0;       /* Disable channels checking */
+
+static GSList *select_list = NULL;
+
+static int seq_buffer[SEQ_BUFFER_LEN];
+static int *seq_append = NULL;
+
+static int *pending_keys = NULL;
+
+#ifdef __QNXNTO__
+ph_dv_f ph_attach;
+ph_ov_f ph_input_group;
+ph_pqc_f ph_query_cursor;
+#endif
+
+#ifdef HAVE_TEXTMODE_X11_SUPPORT
+static Display *x11_display;
+static Window x11_window;
+#endif /* HAVE_TEXTMODE_X11_SUPPORT */
+
+static KeySortType has_been_sorted = KEY_NOSORT;
+
+/* *INDENT-OFF* */
+static const size_t key_conv_tab_size = G_N_ELEMENTS (key_name_conv_tab) - 1;
+/* *INDENT-ON* */
+
+static const key_code_name_t *key_conv_tab_sorted[G_N_ELEMENTS (key_name_conv_tab) - 1];
+
+/* --------------------------------------------------------------------------------------------- */
+/*** file scope functions ************************************************************************/
+/* --------------------------------------------------------------------------------------------- */
+
+static int
+select_cmp_by_fd_set (gconstpointer a, gconstpointer b)
+{
+    const select_t *s = (const select_t *) a;
+    const fd_set *f = (const fd_set *) b;
+
+    return (FD_ISSET (s->fd, f) ? 0 : 1);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static int
+select_cmp_by_fd (gconstpointer a, gconstpointer b)
+{
+    const select_t *s = (const select_t *) a;
+    const int fd = GPOINTER_TO_INT (b);
+
+    return (s->fd == fd ? 0 : 1);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static int
+add_selects (fd_set * select_set)
+{
+    int top_fd = 0;
+
+    if (disabled_channels == 0)
+    {
+        GSList *s;
+
+        for (s = select_list; s != NULL; s = g_slist_next (s))
+        {
+            select_t *p = (select_t *) s->data;
+
+            FD_SET (p->fd, select_set);
+            if (p->fd > top_fd)
+                top_fd = p->fd;
+        }
+    }
+
+    return top_fd;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+check_selects (fd_set * select_set)
+{
+    while (disabled_channels == 0)
+    {
+        GSList *s;
+        select_t *p;
+
+        s = g_slist_find_custom (select_list, select_set, select_cmp_by_fd_set);
+        if (s == NULL)
+            break;
+
+        p = (select_t *) s->data;
+        FD_CLR (p->fd, select_set);
+        p->callback (p->fd, p->info);
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/* If set timeout is set, then we wait 0.1 seconds, else, we block */
+
+static void
+try_channels (gboolean set_timeout)
+{
+    struct timeval time_out;
+    static fd_set select_set;
+
+    while (TRUE)
+    {
+        struct timeval *timeptr = NULL;
+        int maxfdp, v;
+
+        FD_ZERO (&select_set);
+        FD_SET (input_fd, &select_set); /* Add stdin */
+        maxfdp = MAX (add_selects (&select_set), input_fd);
+
+        if (set_timeout)
+        {
+            time_out.tv_sec = 0;
+            time_out.tv_usec = 100 * MC_USEC_PER_MSEC;
+            timeptr = &time_out;
+        }
+
+        v = select (maxfdp + 1, &select_set, NULL, NULL, timeptr);
+        if (v > 0)
+        {
+            check_selects (&select_set);
+            if (FD_ISSET (input_fd, &select_set))
+                break;
+        }
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static key_def *
+create_sequence (const char *seq, int code, int action)
+{
+    key_def *base, *p, *attach;
+
+    for (base = attach = NULL; *seq != '\0'; seq++)
+    {
+        p = g_new (key_def, 1);
+        if (base == NULL)
+            base = p;
+        if (attach != NULL)
+            attach->child = p;
+
+        p->ch = *seq;
+        p->code = code;
+        p->child = p->next = NULL;
+        if (seq[1] == '\0')
+            p->action = action;
+        else
+            p->action = MCKEY_NOACTION;
+        attach = p;
+    }
+    return base;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+define_sequences (const key_define_t * kd)
+{
+    int i;
+
+    for (i = 0; kd[i].code != 0; i++)
+        define_sequence (kd[i].code, kd[i].seq, kd[i].action);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+#ifdef HAVE_TEXTMODE_X11_SUPPORT
+static void
+init_key_x11 (void)
+{
+    if (getenv ("DISPLAY") != NULL && !mc_global.tty.disable_x11)
+    {
+        x11_display = mc_XOpenDisplay (0);
+
+        if (x11_display != NULL)
+            x11_window = DefaultRootWindow (x11_display);
+    }
+}
+#endif /* HAVE_TEXTMODE_X11_SUPPORT */
+
+/* --------------------------------------------------------------------------------------------- */
+/* Workaround for System V Curses vt100 bug */
+
+static int
+getch_with_delay (void)
+{
+    int c;
+
+    /* This routine could be used on systems without mouse support,
+       so we need to do the select check :-( */
+    while (TRUE)
+    {
+        if (pending_keys == NULL)
+            try_channels (FALSE);
+
+        /* Try to get a character */
+        c = get_key_code (0);
+        if (c != -1)
+            break;
+
+        /* Failed -> wait 0.1 secs and try again */
+        try_channels (TRUE);
+    }
+
+    /* Success -> return the character */
+    return c;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+xmouse_get_event (Gpm_Event * ev, gboolean extended)
+{
+    static gint64 tv1 = 0;      /* Force first click as single */
+    static int clicks = 0;
+    static int last_btn = 0;
+    int btn;
+
+    /* Decode Xterm mouse information to a GPM style event */
+
+    if (!extended)
+    {
+        /* Variable btn has following meaning: */
+        /* 0 = btn1 dn, 1 = btn2 dn, 2 = btn3 dn, 3 = btn up */
+        btn = tty_lowlevel_getch () - 32;
+        /* Coordinates are 33-based */
+        /* Transform them to 1-based */
+        ev->x = tty_lowlevel_getch () - 32;
+        ev->y = tty_lowlevel_getch () - 32;
+    }
+    else
+    {
+        /* SGR 1006 extension (e.g. "\e[<0;12;300M"):
+           - Numbers are encoded in decimal to make it ASCII-safe
+           and to overcome the limit of 223 columns/rows.
+           - Mouse release is encoded by trailing 'm' rather than 'M'
+           so that the released button can be reported.
+           - Numbers are no longer offset by 32. */
+        char c;
+
+        btn = ev->x = ev->y = 0;
+        ev->type = 0;           /* In case we return on an invalid sequence */
+
+        while ((c = tty_lowlevel_getch ()) != ';')
+        {
+            if (c < '0' || c > '9')
+                return;
+            btn = 10 * btn + (c - '0');
+        }
+        while ((c = tty_lowlevel_getch ()) != ';')
+        {
+            if (c < '0' || c > '9')
+                return;
+            ev->x = 10 * ev->x + (c - '0');
+        }
+        while ((c = tty_lowlevel_getch ()) != 'M' && c != 'm')
+        {
+            if (c < '0' || c > '9')
+                return;
+            ev->y = 10 * ev->y + (c - '0');
+        }
+        /* Legacy mouse protocol doesn't tell which button was released,
+           conveniently all of mc's widgets are written not to rely on this
+           information. With the SGR extension the released button becomes
+           known, but for the sake of simplicity we just ignore it. */
+        if (c == 'm')
+            btn = 3;
+    }
+
+    /* There seems to be no way of knowing which button was released */
+    /* So we assume all the buttons were released */
+
+    if (btn == 3)
+    {
+        if (last_btn != 0)
+        {
+            if ((last_btn & (GPM_B_UP | GPM_B_DOWN)) != 0)
+            {
+                /* FIXME: DIRTY HACK */
+                /* don't generate GPM_UP after mouse wheel */
+                /* need for menu event handling */
+                ev->type = 0;
+                tv1 = 0;
+            }
+            else
+            {
+                ev->type = GPM_UP | (GPM_SINGLE << clicks);
+                tv1 = g_get_monotonic_time ();
+            }
+            ev->buttons = 0;
+            last_btn = 0;
+            clicks = 0;
+        }
+        else
+        {
+            /* Bogus event, maybe mouse wheel */
+            ev->type = 0;
+        }
+    }
+    else
+    {
+        gint64 tv2;
+
+        if (btn >= 32 && btn <= 34)
+        {
+            btn -= 32;
+            ev->type = GPM_DRAG;
+        }
+        else
+            ev->type = GPM_DOWN;
+
+        tv2 = g_get_monotonic_time ();
+        if (tv1 != 0 && tv2 - tv1 < (gint64) double_click_speed * MC_USEC_PER_MSEC)
+        {
+            clicks++;
+            clicks %= 3;
+        }
+        else
+            clicks = 0;
+
+        switch (btn)
+        {
+        case 0:
+            ev->buttons = GPM_B_LEFT;
+            break;
+        case 1:
+            ev->buttons = GPM_B_MIDDLE;
+            break;
+        case 2:
+            ev->buttons = GPM_B_RIGHT;
+            break;
+        case 64:
+            ev->buttons = GPM_B_UP;
+            clicks = 0;
+            break;
+        case 65:
+            ev->buttons = GPM_B_DOWN;
+            clicks = 0;
+            break;
+        default:
+            /* Nothing */
+            ev->type = 0;
+            ev->buttons = 0;
+            break;
+        }
+        last_btn = ev->buttons;
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Get modifier state (shift, alt, ctrl) for the last key pressed.
+ * We are assuming that the state didn't change since the key press.
+ * This is only correct if get_modifier() is called very fast after
+ * the input was received, so that the user didn't release the
+ * modifier keys yet.
+ */
+
+static int
+get_modifier (void)
+{
+    int result = 0;
+#ifdef __QNXNTO__
+    static int in_photon = 0;
+    static int ph_ig = 0;
+#endif /* __QNXNTO__ */
+
+#ifdef HAVE_TEXTMODE_X11_SUPPORT
+    if (x11_window != 0)
+    {
+        Window root, child;
+        int root_x, root_y;
+        int win_x, win_y;
+        unsigned int mask;
+
+        mc_XQueryPointer (x11_display, x11_window, &root, &child, &root_x,
+                          &root_y, &win_x, &win_y, &mask);
+
+        if ((mask & ShiftMask) != 0)
+            result |= KEY_M_SHIFT;
+        if ((mask & ControlMask) != 0)
+            result |= KEY_M_CTRL;
+        return result;
+    }
+#endif /* HAVE_TEXTMODE_X11_SUPPORT */
+
+#ifdef __QNXNTO__
+    if (in_photon == 0)
+    {
+        /* First time here, let's load Photon library and attach to Photon */
+        in_photon = -1;
+
+        if (getenv ("PHOTON2_PATH") != NULL)
+        {
+            /* QNX 6.x has no support for RTLD_LAZY */
+            void *ph_handle;
+
+            ph_handle = dlopen ("/usr/lib/libph.so", RTLD_NOW);
+            if (ph_handle != NULL)
+            {
+                ph_attach = (ph_dv_f) dlsym (ph_handle, "PhAttach");
+                ph_input_group = (ph_ov_f) dlsym (ph_handle, "PhInputGroup");
+                ph_query_cursor = (ph_pqc_f) dlsym (ph_handle, "PhQueryCursor");
+                if ((ph_attach != NULL) && (ph_input_group != NULL) && (ph_query_cursor != NULL)
+                    && (*ph_attach) (0, 0) != NULL)
+                {
+                    /* Attached */
+                    ph_ig = (*ph_input_group) (0);
+                    in_photon = 1;
+                }
+            }
+        }
+    }
+    /* We do not have Photon running. Assume we are in text console or xterm */
+    if (in_photon == -1)
+    {
+        int mod_status;
+        int shift_ext_status;
+
+        if (devctl (fileno (stdin), DCMD_CHR_LINESTATUS, &mod_status, sizeof (mod_status), NULL) ==
+            -1)
+            return 0;
+
+        shift_ext_status = mod_status & 0xffffff00UL;
+        mod_status &= 0x7f;
+        if ((mod_status & _LINESTATUS_CON_ALT) != 0)
+            result |= KEY_M_ALT;
+        if ((mod_status & _LINESTATUS_CON_CTRL) != 0)
+            result |= KEY_M_CTRL;
+        if ((mod_status & _LINESTATUS_CON_SHIFT) != 0 || (shift_ext_status & 0x00000800UL) != 0)
+            result |= KEY_M_SHIFT;
+    }
+    else
+    {
+        PhCursorInfo_t cursor_info;
+
+        (*ph_query_cursor) (ph_ig, &cursor_info);
+        if ((cursor_info.key_mods & 0x04) != 0)
+            result |= KEY_M_ALT;
+        if ((cursor_info.key_mods & 0x02) != 0)
+            result |= KEY_M_CTRL;
+        if ((cursor_info.key_mods & 0x01) != 0)
+            result |= KEY_M_SHIFT;
+    }
+#endif /* __QNXNTO__ */
+
+#if defined __linux__ || (defined __CYGWIN__ && defined TIOCLINUX)
+    {
+        unsigned char modifiers = 6;
+
+        if (ioctl (0, TIOCLINUX, &modifiers) < 0)
+            return 0;
+
+        /* Translate Linux modifiers into mc modifiers */
+        if ((modifiers & SHIFT_PRESSED) != 0)
+            result |= KEY_M_SHIFT;
+        if ((modifiers & (ALTL_PRESSED | ALTR_PRESSED)) != 0)
+            result |= KEY_M_ALT;
+        if ((modifiers & CONTROL_PRESSED) != 0)
+            result |= KEY_M_CTRL;
+    }
+#endif /* !__linux__ */
+
+    return result;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static gboolean
+push_char (int c)
+{
+    gboolean ret = FALSE;
+
+    if (seq_append == NULL)
+        seq_append = seq_buffer;
+
+    if (seq_append != &(seq_buffer[SEQ_BUFFER_LEN - 2]))
+    {
+        *(seq_append++) = c;
+        *seq_append = '\0';
+        ret = TRUE;
+    }
+
+    return ret;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/* Apply corrections for the keycode generated in get_key_code() */
+
+static int
+correct_key_code (int code)
+{
+    unsigned int c = code & ~KEY_M_MASK;        /* code without modifier */
+    unsigned int mod = code & KEY_M_MASK;       /* modifier */
+#ifdef __QNXNTO__
+    unsigned int qmod;          /* bunch of the QNX console
+                                   modifiers needs unchanged */
+#endif /* __QNXNTO__ */
+
+    /*
+     * Add key modifiers directly from X11 or OS.
+     * Ordinary characters only get modifiers from sequences.
+     */
+    if (c < 32 || c >= 256)
+        mod |= get_modifier ();
+
+    /* This is needed if the newline is reported as carriage return */
+    if (c == '\r')
+        c = '\n';
+
+    /* This is reported to be useful on AIX */
+    if (c == KEY_SCANCEL)
+        c = '\t';
+
+    /* Convert Back Tab to Shift+Tab */
+    if (c == KEY_BTAB)
+    {
+        c = '\t';
+        mod = KEY_M_SHIFT;
+    }
+
+    /* F0 is the same as F10 for out purposes */
+    if (c == KEY_F (0))
+        c = KEY_F (10);
+
+    /*
+     * We are not interested if Ctrl was pressed when entering control
+     * characters, so assume that it was.  When checking for such keys,
+     * XCTRL macro should be used.  In some cases, we are interested,
+     * e.g. to distinguish Ctrl-Enter from Enter.
+     */
+    if (c == '\b')
+    {
+        /* Special case for backspase ('\b' < 32) */
+        c = KEY_BACKSPACE;
+        mod &= ~KEY_M_CTRL;
+    }
+    else if (c < 32 && c != ESC_CHAR && c != '\t' && c != '\n')
+        mod |= KEY_M_CTRL;
+
+#ifdef __QNXNTO__
+    qmod = get_modifier ();
+
+    if (c == 127 && mod == 0)
+    {
+        /* Add Ctrl/Alt/Shift-BackSpace */
+        mod |= get_modifier ();
+        c = KEY_BACKSPACE;
+    }
+
+    if (c == '0' && mod == 0 && (qmod & KEY_M_SHIFT) == KEY_M_SHIFT)
+    {
+        /* Add Shift-Insert on key pad */
+        mod = KEY_M_SHIFT;
+        c = KEY_IC;
+    }
+
+    if (c == '.' && mod == 0 && (qmod & KEY_M_SHIFT) == KEY_M_SHIFT)
+    {
+        /* Add Shift-Del on key pad */
+        mod = KEY_M_SHIFT;
+        c = KEY_DC;
+    }
+#endif /* __QNXNTO__ */
+
+    /* Unrecognized 0177 is delete (preserve Ctrl) */
+    if (c == 0177)
+        c = KEY_BACKSPACE;
+
+#if 0
+    /* Unrecognized Ctrl-d is delete */
+    if (c == 'd' & 31)
+    {
+        c = KEY_DC;
+        mod &= ~KEY_M_CTRL;
+    }
+
+    /* Unrecognized Ctrl-h is backspace */
+    if (c == 'h' & 31)
+    {
+        c = KEY_BACKSPACE;
+        mod &= ~KEY_M_CTRL;
+    }
+#endif
+
+    /* Shift+BackSpace is backspace */
+    if (c == KEY_BACKSPACE && (mod & KEY_M_SHIFT) != 0)
+        mod &= ~KEY_M_SHIFT;
+
+    /* Convert Shift+Fn to F(n+10) */
+    if (c >= KEY_F (1) && c <= KEY_F (10) && (mod & KEY_M_SHIFT) != 0)
+        c += 10;
+
+    /* Remove Shift information from function keys */
+    if (c >= KEY_F (1) && c <= KEY_F (20))
+        mod &= ~KEY_M_SHIFT;
+
+    if (!mc_global.tty.alternate_plus_minus)
+        switch (c)
+        {
+        case KEY_KP_ADD:
+            c = '+';
+            break;
+        case KEY_KP_SUBTRACT:
+            c = '-';
+            break;
+        case KEY_KP_MULTIPLY:
+            c = '*';
+            break;
+        default:
+            break;
+        }
+
+    return (mod | c);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static int
+getch_with_timeout (unsigned int delay_us)
+{
+    fd_set Read_FD_Set;
+    int c;
+    struct timeval time_out;
+
+    time_out.tv_sec = delay_us / G_USEC_PER_SEC;
+    time_out.tv_usec = delay_us % G_USEC_PER_SEC;
+    tty_nodelay (TRUE);
+    FD_ZERO (&Read_FD_Set);
+    FD_SET (input_fd, &Read_FD_Set);
+    select (input_fd + 1, &Read_FD_Set, NULL, NULL, &time_out);
+    c = tty_lowlevel_getch ();
+    tty_nodelay (FALSE);
+    return c;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+learn_store_key (char *buffer, char **p, int c)
+{
+    if (*p - buffer > 253)
+        return;
+
+    if (c == ESC_CHAR)
+    {
+        *(*p)++ = '\\';
+        *(*p)++ = 'e';
+    }
+    else if (c < ' ')
+    {
+        *(*p)++ = '^';
+        *(*p)++ = c + 'a' - 1;
+    }
+    else if (c == '^')
+    {
+        *(*p)++ = '^';
+        *(*p)++ = '^';
+    }
+    else
+        *(*p)++ = (char) c;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+k_dispose (key_def * k)
+{
+    if (k != NULL)
+    {
+        k_dispose (k->child);
+        k_dispose (k->next);
+        g_free (k);
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static int
+key_code_comparator_by_name (const void *p1, const void *p2)
+{
+    const key_code_name_t *n1 = *(const key_code_name_t * const *) p1;
+    const key_code_name_t *n2 = *(const key_code_name_t * const *) p2;
+
+    return g_ascii_strcasecmp (n1->name, n2->name);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static int
+key_code_comparator_by_code (const void *p1, const void *p2)
+{
+    const key_code_name_t *n1 = *(const key_code_name_t * const *) p1;
+    const key_code_name_t *n2 = *(const key_code_name_t * const *) p2;
+
+    return n1->code - n2->code;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static inline void
+sort_key_conv_tab (enum KeySortType type_sort)
+{
+    if (has_been_sorted != type_sort)
+    {
+        size_t i;
+
+        for (i = 0; i < key_conv_tab_size; i++)
+            key_conv_tab_sorted[i] = &key_name_conv_tab[i];
+
+        if (type_sort == KEY_SORTBYNAME)
+            qsort (key_conv_tab_sorted, key_conv_tab_size, sizeof (key_conv_tab_sorted[0]),
+                   &key_code_comparator_by_name);
+        else if (type_sort == KEY_SORTBYCODE)
+            qsort (key_conv_tab_sorted, key_conv_tab_size, sizeof (key_conv_tab_sorted[0]),
+                   &key_code_comparator_by_code);
+
+        has_been_sorted = type_sort;
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static int
+lookup_keyname (const char *name, int *idx)
+{
+    if (name[0] != '\0')
+    {
+        const key_code_name_t key = { 0, name, NULL, NULL };
+        const key_code_name_t *keyp = &key;
+        const key_code_name_t **res;
+
+        if (name[1] == '\0')
+        {
+            *idx = -1;
+            return (int) name[0];
+        }
+
+        sort_key_conv_tab (KEY_SORTBYNAME);
+
+        res = bsearch (&keyp, key_conv_tab_sorted, key_conv_tab_size,
+                       sizeof (key_conv_tab_sorted[0]), key_code_comparator_by_name);
+
+        if (res != NULL)
+        {
+            *idx = (int) (res - key_conv_tab_sorted);
+            return (*res)->code;
+        }
+    }
+
+    *idx = -1;
+    return 0;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static gboolean
+lookup_keycode (const long code, int *idx)
+{
+    if (code != 0)
+    {
+        const key_code_name_t key = { code, NULL, NULL, NULL };
+        const key_code_name_t *keyp = &key;
+        const key_code_name_t **res;
+
+        sort_key_conv_tab (KEY_SORTBYCODE);
+
+        res = bsearch (&keyp, key_conv_tab_sorted, key_conv_tab_size,
+                       sizeof (key_conv_tab_sorted[0]), key_code_comparator_by_code);
+
+        if (res != NULL)
+        {
+            *idx = (int) (res - key_conv_tab_sorted);
+            return TRUE;
+        }
+    }
+
+    *idx = -1;
+    return FALSE;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/*** public functions ****************************************************************************/
+/* --------------------------------------------------------------------------------------------- */
+/* This has to be called before init_slang or whatever routine
+   calls any define_sequence */
+
+void
+init_key (void)
+{
+    const char *term;
+
+    term = getenv ("TERM");
+
+    /* This has to be the first define_sequence */
+    /* So, we can assume that the first keys member has ESC */
+    define_sequences (mc_default_keys);
+
+    /* Terminfo on irix does not have some keys */
+    if (mc_global.tty.xterm_flag
+        || (term != NULL
+            && (strncmp (term, "iris-ansi", 9) == 0
+                || strncmp (term, "xterm", 5) == 0
+                || strncmp (term, "rxvt", 4) == 0 || strncmp (term, "screen", 6) == 0)))
+        define_sequences (xterm_key_defines);
+
+    /* load some additional keys (e.g. direct Alt-? support) */
+    load_xtra_key_defines ();
+
+#ifdef __QNX__
+    if ((term != NULL) && (strncmp (term, "qnx", 3) == 0))
+    {
+        /* Modify the default value of use_8th_bit_as_meta: we would
+         * like to provide a working mc for a newbie who knows nothing
+         * about [Options|Display bits|Full 8 bits input]...
+         *
+         * Don't use 'meta'-bit, when we are dealing with a
+         * 'qnx*'-type terminal: clear the default value!
+         * These terminal types use 0xFF as an escape character,
+         * so use_8th_bit_as_meta==1 must not be enabled!
+         *
+         * [mc-4.1.21+,slint.c/getch(): the DEC_8BIT_HACK stuff
+         * is not used now (doesn't even depend on use_8th_bit_as_meta
+         * as in mc-3.1.2)...GREAT!...no additional code is required!]
+         */
+        use_8th_bit_as_meta = FALSE;
+    }
+#endif /* __QNX__ */
+
+#ifdef HAVE_TEXTMODE_X11_SUPPORT
+    init_key_x11 ();
+#endif
+
+    /* Load the qansi-m key definitions
+       if we are running under the qansi-m terminal */
+    if (term != NULL && (strncmp (term, "qansi-m", 7) == 0))
+        define_sequences (qansi_key_defines);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * This has to be called after SLang_init_tty/slint_init
+ */
+
+void
+init_key_input_fd (void)
+{
+#ifdef HAVE_SLANG
+    input_fd = SLang_TT_Read_FD;
+#endif
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+void
+done_key (void)
+{
+    k_dispose (keys);
+    g_slist_free_full (select_list, g_free);
+
+#ifdef HAVE_TEXTMODE_X11_SUPPORT
+    if (x11_display)
+        mc_XCloseDisplay (x11_display);
+#endif
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+void
+add_select_channel (int fd, select_fn callback, void *info)
+{
+    select_t *new;
+
+    new = g_new (select_t, 1);
+    new->fd = fd;
+    new->callback = callback;
+    new->info = info;
+
+    select_list = g_slist_prepend (select_list, new);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+void
+delete_select_channel (int fd)
+{
+    GSList *p;
+
+    p = g_slist_find_custom (select_list, GINT_TO_POINTER (fd), select_cmp_by_fd);
+    if (p != NULL)
+        select_list = g_slist_delete_link (select_list, p);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+void
+channels_up (void)
+{
+    if (disabled_channels == 0)
+        fputs ("Error: channels_up called with disabled_channels = 0\n", stderr);
+    disabled_channels--;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+void
+channels_down (void)
+{
+    disabled_channels++;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Return the code associated with the symbolic name keyname
+ */
+
+long
+tty_keyname_to_keycode (const char *name, char **label)
+{
+    char **lc_keys, **p;
+    char *cname;
+    int k = -1;
+    int key = 0;
+    int lc_index = -1;
+
+    int use_meta = -1;
+    int use_ctrl = -1;
+    int use_shift = -1;
+
+    if (name == NULL)
+        return 0;
+
+    cname = g_strstrip (g_strdup (name));
+    lc_keys = g_strsplit_set (cname, "-+ ", -1);
+    g_free (cname);
+
+    for (p = lc_keys; p != NULL && *p != NULL; p++)
+    {
+        if ((*p)[0] != '\0')
+        {
+            int idx;
+
+            key = lookup_keyname (g_strstrip (*p), &idx);
+
+            if (key == KEY_M_ALT)
+                use_meta = idx;
+            else if (key == KEY_M_CTRL)
+                use_ctrl = idx;
+            else if (key == KEY_M_SHIFT)
+                use_shift = idx;
+            else
+            {
+                k = key;
+                lc_index = idx;
+                break;
+            }
+        }
+    }
+
+    g_strfreev (lc_keys);
+
+    /* output */
+    if (k <= 0)
+        return 0;
+
+    if (label != NULL)
+    {
+        GString *s;
+
+        s = g_string_new ("");
+
+        if (use_meta != -1)
+        {
+            g_string_append (s, key_conv_tab_sorted[use_meta]->shortcut);
+            g_string_append_c (s, '-');
+        }
+        if (use_ctrl != -1)
+        {
+            g_string_append (s, key_conv_tab_sorted[use_ctrl]->shortcut);
+            g_string_append_c (s, '-');
+        }
+        if (use_shift != -1)
+        {
+            if (k < 127)
+                g_string_append_c (s, (gchar) g_ascii_toupper ((gchar) k));
+            else
+            {
+                g_string_append (s, key_conv_tab_sorted[use_shift]->shortcut);
+                g_string_append_c (s, '-');
+                g_string_append (s, key_conv_tab_sorted[lc_index]->shortcut);
+            }
+        }
+        else if (k < 128)
+        {
+            if ((k >= 'A') || (lc_index < 0) || (key_conv_tab_sorted[lc_index]->shortcut == NULL))
+                g_string_append_c (s, (gchar) g_ascii_tolower ((gchar) k));
+            else
+                g_string_append (s, key_conv_tab_sorted[lc_index]->shortcut);
+        }
+        else if ((lc_index != -1) && (key_conv_tab_sorted[lc_index]->shortcut != NULL))
+            g_string_append (s, key_conv_tab_sorted[lc_index]->shortcut);
+        else
+            g_string_append_c (s, (gchar) g_ascii_tolower ((gchar) key));
+
+        *label = g_string_free (s, FALSE);
+    }
+
+    if (use_shift != -1)
+    {
+        if (k < 127 && k > 31)
+            k = g_ascii_toupper ((gchar) k);
+        else
+            k |= KEY_M_SHIFT;
+    }
+
+    if (use_ctrl != -1)
+    {
+        if (k < 256)
+            k = XCTRL (k);
+        else
+            k |= KEY_M_CTRL;
+    }
+
+    if (use_meta != -1)
+        k = ALT (k);
+
+    return (long) k;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+char *
+tty_keycode_to_keyname (const int keycode)
+{
+    /* code without modifier */
+    unsigned int k = keycode & ~KEY_M_MASK;
+    /* modifier */
+    unsigned int mod = keycode & KEY_M_MASK;
+
+    int key_idx = -1;
+
+    GString *s;
+    int idx;
+
+    s = g_string_sized_new (8);
+
+    if (lookup_keycode (k, &key_idx) || (k > 0 && k < 256))
+    {
+        if ((mod & KEY_M_ALT) != 0 && lookup_keycode (KEY_M_ALT, &idx))
+        {
+            g_string_append (s, key_conv_tab_sorted[idx]->name);
+            g_string_append_c (s, '-');
+        }
+
+        if ((mod & KEY_M_CTRL) != 0)
+        {
+            /* non printeble chars like a CTRL-[A..Z] */
+            if (k < 32)
+                k += 64;
+
+            if (lookup_keycode (KEY_M_CTRL, &idx))
+            {
+                g_string_append (s, key_conv_tab_sorted[idx]->name);
+                g_string_append_c (s, '-');
+            }
+        }
+
+        if ((mod & KEY_M_SHIFT) != 0)
+        {
+            if (lookup_keycode (KEY_M_ALT, &idx))
+            {
+                if (k < 127)
+                    g_string_append_c (s, (gchar) g_ascii_toupper ((gchar) k));
+                else
+                {
+                    g_string_append (s, key_conv_tab_sorted[idx]->name);
+                    g_string_append_c (s, '-');
+                    g_string_append (s, key_conv_tab_sorted[key_idx]->name);
+                }
+            }
+        }
+        else if (k < 128)
+        {
+            if ((k >= 'A') || (key_idx < 0) || (key_conv_tab_sorted[key_idx]->name == NULL))
+                g_string_append_c (s, (gchar) k);
+            else
+                g_string_append (s, key_conv_tab_sorted[key_idx]->name);
+        }
+        else if ((key_idx != -1) && (key_conv_tab_sorted[key_idx]->name != NULL))
+            g_string_append (s, key_conv_tab_sorted[key_idx]->name);
+        else
+            g_string_append_c (s, (gchar) keycode);
+    }
+
+    return g_string_free (s, s->len == 0);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Return TRUE on success, FALSE on error.
+ * An error happens if SEQ is a beginning of an existing longer sequence.
+ */
+
+gboolean
+define_sequence (int code, const char *seq, int action)
+{
+    key_def *base;
+
+    if (strlen (seq) > SEQ_BUFFER_LEN - 1)
+        return FALSE;
+
+    for (base = keys; (base != NULL) && (*seq != '\0');)
+        if (*seq == base->ch)
+        {
+            if (base->child == NULL)
+            {
+                if (*(seq + 1) != '\0')
+                    base->child = create_sequence (seq + 1, code, action);
+                else
+                {
+                    /* The sequence matches an existing one.  */
+                    base->code = code;
+                    base->action = action;
+                }
+                return TRUE;
+            }
+
+            base = base->child;
+            seq++;
+        }
+        else
+        {
+            if (base->next != NULL)
+                base = base->next;
+            else
+            {
+                base->next = create_sequence (seq, code, action);
+                return TRUE;
+            }
+        }
+
+    if (*seq == '\0')
+    {
+        /* Attempt to redefine a sequence with a shorter sequence.  */
+        return FALSE;
+    }
+
+    keys = create_sequence (seq, code, action);
+    return TRUE;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Check if we are idle, i.e. there are no pending keyboard or mouse
+ * events.  Return 1 is idle, 0 is there are pending events.
+ */
+gboolean
+is_idle (void)
+{
+    int nfd;
+    fd_set select_set;
+    struct timeval time_out;
+
+    FD_ZERO (&select_set);
+    FD_SET (input_fd, &select_set);
+    nfd = MAX (0, input_fd) + 1;
+    time_out.tv_sec = 0;
+    time_out.tv_usec = 0;
+#ifdef HAVE_LIBGPM
+    if (mouse_enabled && use_mouse_p == MOUSE_GPM)
+    {
+        if (gpm_fd >= 0)
+        {
+            FD_SET (gpm_fd, &select_set);
+            nfd = MAX (nfd, gpm_fd + 1);
+        }
+        else
+        {
+            if (mouse_fd >= 0)  /* error indicative */
+            {
+                if (FD_ISSET (mouse_fd, &select_set))
+                    FD_CLR (mouse_fd, &select_set);
+                mouse_fd = gpm_fd;
+            }
+            /* gpm_fd == -2 means under some X terminal */
+            if (gpm_fd == -1)
+            {
+                mouse_enabled = FALSE;
+                use_mouse_p = MOUSE_NONE;
+            }
+        }
+    }
+#endif
+    return (select (nfd, &select_set, 0, 0, &time_out) <= 0);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+int
+get_key_code (int no_delay)
+{
+    int c;
+    static key_def *this = NULL, *parent;
+    static gint64 esc_time = -1;
+    static int lastnodelay = -1;
+
+    if (no_delay != lastnodelay)
+    {
+        this = NULL;
+        lastnodelay = no_delay;
+    }
+
+  pend_send:
+    if (pending_keys != NULL)
+    {
+        gboolean bad_seq;
+
+        c = *pending_keys++;
+        while (c == ESC_CHAR)
+            c = ALT (*pending_keys++);
+
+        bad_seq = (*pending_keys != ESC_CHAR && *pending_keys != '\0');
+        if (*pending_keys == '\0' || bad_seq)
+            pending_keys = seq_append = NULL;
+
+        if (bad_seq)
+        {
+            /* This is an unknown ESC sequence.
+             * To prevent interpreting its tail as a random garbage,
+             * eat and discard all buffered and quickly following chars.
+             * Small, but non-zero timeout is needed to reconnect
+             * escape sequence split up by e.g. a serial line.
+             */
+            int paranoia = 20;
+
+            while (getch_with_timeout (old_esc_mode_timeout) >= 0 && --paranoia != 0)
+                ;
+        }
+        else
+        {
+            if (c > 127 && c < 256 && use_8th_bit_as_meta)
+                c = ALT (c & 0x7f);
+
+            goto done;
+        }
+    }
+
+  nodelay_try_again:
+    if (no_delay != 0)
+        tty_nodelay (TRUE);
+
+    c = tty_lowlevel_getch ();
+#if (defined(USE_NCURSES) || defined(USE_NCURSESW)) && defined(KEY_RESIZE)
+    if (c == KEY_RESIZE)
+        goto nodelay_try_again;
+#endif
+
+    if (no_delay != 0)
+    {
+        tty_nodelay (FALSE);
+        if (c == -1)
+        {
+            if (this == NULL || parent == NULL || parent->action != MCKEY_ESCAPE || !old_esc_mode ||
+                esc_time == -1 || g_get_monotonic_time () < esc_time + old_esc_mode_timeout)
+                return -1;
+
+            this = NULL;
+            pending_keys = seq_append = NULL;
+            return ESC_CHAR;
+        }
+    }
+    else if (c == -1)
+    {
+        /* Maybe we got an incomplete match.
+           This we do only in delay mode, since otherwise
+           tty_lowlevel_getch can return -1 at any time. */
+        if (seq_append == NULL)
+        {
+            this = NULL;
+            return -1;
+        }
+
+        pending_keys = seq_buffer;
+        goto pend_send;
+    }
+
+    /* Search the key on the root */
+    if (no_delay == 0 || this == NULL)
+    {
+        this = keys;
+        parent = NULL;
+
+        if (c > 127 && c < 256 && use_8th_bit_as_meta)
+        {
+            c &= 0x7f;
+
+            /* The first sequence defined starts with esc */
+            parent = keys;
+            this = keys->child;
+        }
+    }
+
+    while (this != NULL)
+    {
+        if (c == this->ch)
+        {
+            if (this->child == NULL)
+            {
+                /* We got a complete match, return and reset search */
+                pending_keys = seq_append = NULL;
+                c = this->code;
+                goto done;
+            }
+
+            /* No match yet, but it may be a prefix for a valid seq */
+            if (!push_char (c))
+            {
+                pending_keys = seq_buffer;
+                goto pend_send;
+            }
+
+            parent = this;
+            this = this->child;
+            if (parent->action == MCKEY_ESCAPE && old_esc_mode)
+            {
+                if (no_delay != 0)
+                {
+                    esc_time = g_get_monotonic_time ();
+                    goto nodelay_try_again;
+                }
+
+                esc_time = -1;
+                c = getch_with_timeout (old_esc_mode_timeout);
+                if (c != -1)
+                    continue;
+
+                pending_keys = seq_append = NULL;
+                this = NULL;
+                return ESC_CHAR;
+            }
+
+            if (no_delay != 0)
+                goto nodelay_try_again;
+            c = tty_lowlevel_getch ();
+            continue;
+        }
+
+        /* c != this->ch. Try other keys with this prefix */
+        if (this->next != NULL)
+        {
+            this = this->next;
+            continue;
+        }
+
+        /* No match found. Is it one of our ESC <key> specials? */
+        if ((parent != NULL) && (parent->action == MCKEY_ESCAPE))
+        {
+            /* Convert escape-digits to F-keys */
+            if (g_ascii_isdigit (c))
+                c = KEY_F (c - '0');
+            else if (c == ' ')
+                c = ESC_CHAR;
+            else
+                c = ALT (c);
+
+            pending_keys = seq_append = NULL;
+            goto done;
+        }
+
+        /* Unknown sequence. Maybe a prefix of a longer one. Save it. */
+        push_char (c);
+        pending_keys = seq_buffer;
+        goto pend_send;
+    }                           /* while (this != NULL) */
+
+  done:
+    this = NULL;
+    return correct_key_code (c);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/* Returns a character read from stdin with appropriate interpretation */
+/* Also takes care of generated mouse events */
+/* Returns EV_MOUSE if it is a mouse event */
+/* Returns EV_NONE  if non-blocking or interrupt set and nothing was done */
+
+int
+tty_get_event (struct Gpm_Event *event, gboolean redo_event, gboolean block)
+{
+    int c;
+    int flag = 0;               /* Return value from select */
+#ifdef HAVE_LIBGPM
+    static struct Gpm_Event ev; /* Mouse event */
+#endif
+    struct timeval time_out;
+    struct timeval *time_addr = NULL;
+    static int dirty = 3;
+
+    if ((dirty == 3) || is_idle ())
+    {
+        mc_refresh ();
+        dirty = 1;
+    }
+    else
+        dirty++;
+
+    vfs_timeout_handler ();
+
+    /* Ok, we use (event->x < 0) to signal that the event does not contain
+       a suitable position for the mouse, so we can't use show_mouse_pointer
+       on it.
+     */
+    if (event->x > 0)
+    {
+        show_mouse_pointer (event->x, event->y);
+        if (!redo_event)
+            event->x = -1;
+    }
+
+    /* Repeat if using mouse */
+    while (pending_keys == NULL)
+    {
+        int nfd;
+        fd_set select_set;
+
+        FD_ZERO (&select_set);
+        FD_SET (input_fd, &select_set);
+        nfd = MAX (add_selects (&select_set), MAX (0, input_fd)) + 1;
+
+#ifdef HAVE_LIBGPM
+        if (mouse_enabled && (use_mouse_p == MOUSE_GPM))
+        {
+            if (gpm_fd >= 0)
+            {
+                FD_SET (gpm_fd, &select_set);
+                nfd = MAX (nfd, gpm_fd + 1);
+            }
+            else
+            {
+                if (mouse_fd >= 0)      /* error indicative */
+                {
+                    if (FD_ISSET (mouse_fd, &select_set))
+                        FD_CLR (mouse_fd, &select_set);
+                    mouse_fd = gpm_fd;
+                }
+                /* gpm_fd == -2 means under some X terminal */
+                if (gpm_fd == -1)
+                {
+                    mouse_enabled = FALSE;
+                    use_mouse_p = MOUSE_NONE;
+                }
+                break;
+            }
+        }
+#endif
+
+        if (redo_event)
+        {
+            time_out.tv_usec = mou_auto_repeat * MC_USEC_PER_MSEC;
+            time_out.tv_sec = 0;
+
+            time_addr = &time_out;
+        }
+        else
+        {
+            int seconds;
+
+            seconds = vfs_timeouts ();
+            time_addr = NULL;
+
+            if (seconds != 0)
+            {
+                /* the timeout could be improved and actually be
+                 * the number of seconds until the next vfs entry
+                 * timeouts in the stamp list.
+                 */
+
+                time_out.tv_sec = seconds;
+                time_out.tv_usec = 0;
+                time_addr = &time_out;
+            }
+        }
+
+        if (!block || tty_got_winch ())
+        {
+            time_addr = &time_out;
+            time_out.tv_sec = 0;
+            time_out.tv_usec = 0;
+        }
+
+        tty_enable_interrupt_key ();
+        flag = select (nfd, &select_set, NULL, NULL, time_addr);
+        tty_disable_interrupt_key ();
+
+        /* select timed out: it could be for any of the following reasons:
+         * redo_event -> it was because of the MOU_REPEAT handler
+         * !block     -> we did not block in the select call
+         * else       -> 10 second timeout to check the vfs status.
+         */
+        if (flag == 0)
+        {
+            if (redo_event)
+                return EV_MOUSE;
+            if (!block || tty_got_winch ())
+                return EV_NONE;
+            vfs_timeout_handler ();
+        }
+        if (flag == -1 && errno == EINTR)
+            return EV_NONE;
+
+        check_selects (&select_set);
+
+        if (FD_ISSET (input_fd, &select_set))
+            break;
+
+#ifdef HAVE_LIBGPM
+        if (mouse_enabled && use_mouse_p == MOUSE_GPM)
+        {
+            if (gpm_fd >= 0)
+            {
+                if (FD_ISSET (gpm_fd, &select_set))
+                {
+                    int status;
+
+                    status = Gpm_GetEvent (&ev);
+                    if (status == 1)    /* success */
+                    {
+                        Gpm_FitEvent (&ev);
+                        *event = ev;
+                        return EV_MOUSE;
+                    }
+                    if (status <= 0)    /* connection closed; -1 == error */
+                    {
+                        if (mouse_fd >= 0 && FD_ISSET (mouse_fd, &select_set))
+                            FD_CLR (mouse_fd, &select_set);
+
+                        disable_mouse ();
+                        return EV_NONE;
+                    }
+                }
+            }
+            else
+            {
+                if (mouse_fd >= 0)      /* error indicative */
+                {
+                    if (FD_ISSET (mouse_fd, &select_set))
+                        FD_CLR (mouse_fd, &select_set);
+                    mouse_fd = gpm_fd;
+                }
+                /* gpm_fd == -2 means under some X terminal */
+                if (gpm_fd == -1)
+                {
+                    mouse_enabled = FALSE;
+                    use_mouse_p = MOUSE_NONE;
+                }
+                break;
+            }
+        }
+#endif /* !HAVE_LIBGPM */
+    }
+
+#ifndef HAVE_SLANG
+    flag = is_wintouched (stdscr);
+    untouchwin (stdscr);
+#endif /* !HAVE_SLANG */
+    c = block ? getch_with_delay () : get_key_code (1);
+
+#ifndef HAVE_SLANG
+    if (flag > 0)
+        tty_touch_screen ();
+#endif /* !HAVE_SLANG */
+
+    if (mouse_enabled && (c == MCKEY_MOUSE
+#ifdef KEY_MOUSE
+                          || c == KEY_MOUSE
+#endif /* KEY_MOUSE */
+                          || c == MCKEY_EXTENDED_MOUSE))
+    {
+        /* Mouse event. See tickets 2956 and 3954 for extended mode detection. */
+        gboolean extended = c == MCKEY_EXTENDED_MOUSE;
+
+#ifdef KEY_MOUSE
+        extended = extended || (c == KEY_MOUSE && xmouse_seq == NULL
+                                && xmouse_extended_seq != NULL);
+#endif /* KEY_MOUSE */
+
+        xmouse_get_event (event, extended);
+        c = (event->type != 0) ? EV_MOUSE : EV_NONE;
+    }
+    else if (c == MCKEY_BRACKETED_PASTING_START)
+    {
+        bracketed_pasting_in_progress = TRUE;
+        c = EV_NONE;
+    }
+    else if (c == MCKEY_BRACKETED_PASTING_END)
+    {
+        bracketed_pasting_in_progress = FALSE;
+        c = EV_NONE;
+    }
+
+    return c;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/* Returns a key press, mouse events are discarded */
+
+int
+tty_getch (void)
+{
+    Gpm_Event ev;
+    int key;
+
+    ev.x = -1;
+    while ((key = tty_get_event (&ev, FALSE, TRUE)) == EV_NONE)
+        ;
+    return key;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+char *
+learn_key (void)
+{
+    /* LEARN_TIMEOUT in ms */
+#define LEARN_TIMEOUT 200
+
+    fd_set Read_FD_Set;
+    gint64 end_time;
+    int c;
+    char buffer[256];
+    char *p = buffer;
+
+    tty_keypad (FALSE);         /* disable interpreting keys by ncurses */
+    c = tty_lowlevel_getch ();
+    while (c == -1)
+        c = tty_lowlevel_getch ();      /* Sanity check, should be unnecessary */
+    learn_store_key (buffer, &p, c);
+
+    end_time = g_get_monotonic_time () + LEARN_TIMEOUT * MC_USEC_PER_MSEC;
+
+    tty_nodelay (TRUE);
+    while (TRUE)
+    {
+        while ((c = tty_lowlevel_getch ()) == -1)
+        {
+            gint64 time_out;
+            struct timeval tv;
+
+            time_out = end_time - g_get_monotonic_time ();
+            if (time_out <= 0)
+                break;
+
+            tv.tv_sec = time_out / G_USEC_PER_SEC;
+            tv.tv_usec = time_out % G_USEC_PER_SEC;
+            FD_ZERO (&Read_FD_Set);
+            FD_SET (input_fd, &Read_FD_Set);
+            select (input_fd + 1, &Read_FD_Set, NULL, NULL, &tv);
+        }
+        if (c == -1)
+            break;
+        learn_store_key (buffer, &p, c);
+    }
+    tty_keypad (TRUE);
+    tty_nodelay (FALSE);
+    *p = '\0';
+    return (buffer[0] != '\0' ? g_strdup (buffer) : NULL);
+#undef LEARN_TIMEOUT
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/* xterm and linux console only: set keypad to numeric or application
+   mode. Only in application keypad mode it's possible to distinguish
+   the '+' key and the '+' on the keypad ('*' and '-' ditto) */
+
+void
+numeric_keypad_mode (void)
+{
+    if (mc_global.tty.console_flag != '\0' || mc_global.tty.xterm_flag)
+    {
+        fputs (ESC_STR ">", stdout);
+        fflush (stdout);
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+void
+application_keypad_mode (void)
+{
+    if (mc_global.tty.console_flag != '\0' || mc_global.tty.xterm_flag)
+    {
+        fputs (ESC_STR "=", stdout);
+        fflush (stdout);
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+void
+enable_bracketed_paste (void)
+{
+    printf (ESC_STR "[?2004h");
+    fflush (stdout);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+void
+disable_bracketed_paste (void)
+{
+    printf (ESC_STR "[?2004l");
+    fflush (stdout);
+    bracketed_pasting_in_progress = FALSE;
+}
+
+/* --------------------------------------------------------------------------------------------- */