diff options
Diffstat (limited to 'src/nvim/keymap.c')
| -rw-r--r-- | src/nvim/keymap.c | 777 |
1 files changed, 777 insertions, 0 deletions
diff --git a/src/nvim/keymap.c b/src/nvim/keymap.c new file mode 100644 index 0000000000..bec179c913 --- /dev/null +++ b/src/nvim/keymap.c @@ -0,0 +1,777 @@ +/************************************************************************ + * functions that use lookup tables for various things, generally to do with + * special key codes. + */ + +#include "vim.h" +#include "keymap.h" +#include "charset.h" +#include "edit.h" +#include "term.h" + + +/* + * Some useful tables. + */ + +static struct modmasktable { + short mod_mask; /* Bit-mask for particular key modifier */ + short mod_flag; /* Bit(s) for particular key modifier */ + char_u name; /* Single letter name of modifier */ +} mod_mask_table[] = +{ + {MOD_MASK_ALT, MOD_MASK_ALT, (char_u)'M'}, + {MOD_MASK_META, MOD_MASK_META, (char_u)'T'}, + {MOD_MASK_CTRL, MOD_MASK_CTRL, (char_u)'C'}, + {MOD_MASK_SHIFT, MOD_MASK_SHIFT, (char_u)'S'}, + {MOD_MASK_MULTI_CLICK, MOD_MASK_2CLICK, (char_u)'2'}, + {MOD_MASK_MULTI_CLICK, MOD_MASK_3CLICK, (char_u)'3'}, + {MOD_MASK_MULTI_CLICK, MOD_MASK_4CLICK, (char_u)'4'}, + /* 'A' must be the last one */ + {MOD_MASK_ALT, MOD_MASK_ALT, (char_u)'A'}, + {0, 0, NUL} +}; + +/* + * Shifted key terminal codes and their unshifted equivalent. + * Don't add mouse codes here, they are handled separately! + */ +#define MOD_KEYS_ENTRY_SIZE 5 + +static char_u modifier_keys_table[] = +{ + /* mod mask with modifier without modifier */ + MOD_MASK_SHIFT, '&', '9', '@', '1', /* begin */ + MOD_MASK_SHIFT, '&', '0', '@', '2', /* cancel */ + MOD_MASK_SHIFT, '*', '1', '@', '4', /* command */ + MOD_MASK_SHIFT, '*', '2', '@', '5', /* copy */ + MOD_MASK_SHIFT, '*', '3', '@', '6', /* create */ + MOD_MASK_SHIFT, '*', '4', 'k', 'D', /* delete char */ + MOD_MASK_SHIFT, '*', '5', 'k', 'L', /* delete line */ + MOD_MASK_SHIFT, '*', '7', '@', '7', /* end */ + MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_END, '@', '7', /* end */ + MOD_MASK_SHIFT, '*', '9', '@', '9', /* exit */ + MOD_MASK_SHIFT, '*', '0', '@', '0', /* find */ + MOD_MASK_SHIFT, '#', '1', '%', '1', /* help */ + MOD_MASK_SHIFT, '#', '2', 'k', 'h', /* home */ + MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_HOME, 'k', 'h', /* home */ + MOD_MASK_SHIFT, '#', '3', 'k', 'I', /* insert */ + MOD_MASK_SHIFT, '#', '4', 'k', 'l', /* left arrow */ + MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_LEFT, 'k', 'l', /* left arrow */ + MOD_MASK_SHIFT, '%', 'a', '%', '3', /* message */ + MOD_MASK_SHIFT, '%', 'b', '%', '4', /* move */ + MOD_MASK_SHIFT, '%', 'c', '%', '5', /* next */ + MOD_MASK_SHIFT, '%', 'd', '%', '7', /* options */ + MOD_MASK_SHIFT, '%', 'e', '%', '8', /* previous */ + MOD_MASK_SHIFT, '%', 'f', '%', '9', /* print */ + MOD_MASK_SHIFT, '%', 'g', '%', '0', /* redo */ + MOD_MASK_SHIFT, '%', 'h', '&', '3', /* replace */ + MOD_MASK_SHIFT, '%', 'i', 'k', 'r', /* right arr. */ + MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_RIGHT, 'k', 'r', /* right arr. */ + MOD_MASK_SHIFT, '%', 'j', '&', '5', /* resume */ + MOD_MASK_SHIFT, '!', '1', '&', '6', /* save */ + MOD_MASK_SHIFT, '!', '2', '&', '7', /* suspend */ + MOD_MASK_SHIFT, '!', '3', '&', '8', /* undo */ + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_UP, 'k', 'u', /* up arrow */ + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_DOWN, 'k', 'd', /* down arrow */ + + /* vt100 F1 */ + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF1, KS_EXTRA, (int)KE_XF1, + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF2, KS_EXTRA, (int)KE_XF2, + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF3, KS_EXTRA, (int)KE_XF3, + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF4, KS_EXTRA, (int)KE_XF4, + + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F1, 'k', '1', /* F1 */ + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F2, 'k', '2', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F3, 'k', '3', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F4, 'k', '4', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F5, 'k', '5', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F6, 'k', '6', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F7, 'k', '7', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F8, 'k', '8', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F9, 'k', '9', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F10, 'k', ';', /* F10 */ + + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F11, 'F', '1', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F12, 'F', '2', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F13, 'F', '3', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F14, 'F', '4', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F15, 'F', '5', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F16, 'F', '6', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F17, 'F', '7', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F18, 'F', '8', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F19, 'F', '9', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F20, 'F', 'A', + + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F21, 'F', 'B', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F22, 'F', 'C', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F23, 'F', 'D', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F24, 'F', 'E', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F25, 'F', 'F', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F26, 'F', 'G', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F27, 'F', 'H', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F28, 'F', 'I', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F29, 'F', 'J', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F30, 'F', 'K', + + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F31, 'F', 'L', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F32, 'F', 'M', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F33, 'F', 'N', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F34, 'F', 'O', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F35, 'F', 'P', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F36, 'F', 'Q', + MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F37, 'F', 'R', + + /* TAB pseudo code*/ + MOD_MASK_SHIFT, 'k', 'B', KS_EXTRA, (int)KE_TAB, + + NUL +}; + +static struct key_name_entry { + int key; /* Special key code or ascii value */ + char_u *name; /* Name of key */ +} key_names_table[] = +{ + {' ', (char_u *)"Space"}, + {TAB, (char_u *)"Tab"}, + {K_TAB, (char_u *)"Tab"}, + {NL, (char_u *)"NL"}, + {NL, (char_u *)"NewLine"}, /* Alternative name */ + {NL, (char_u *)"LineFeed"}, /* Alternative name */ + {NL, (char_u *)"LF"}, /* Alternative name */ + {CAR, (char_u *)"CR"}, + {CAR, (char_u *)"Return"}, /* Alternative name */ + {CAR, (char_u *)"Enter"}, /* Alternative name */ + {K_BS, (char_u *)"BS"}, + {K_BS, (char_u *)"BackSpace"}, /* Alternative name */ + {ESC, (char_u *)"Esc"}, + {CSI, (char_u *)"CSI"}, + {K_CSI, (char_u *)"xCSI"}, + {'|', (char_u *)"Bar"}, + {'\\', (char_u *)"Bslash"}, + {K_DEL, (char_u *)"Del"}, + {K_DEL, (char_u *)"Delete"}, /* Alternative name */ + {K_KDEL, (char_u *)"kDel"}, + {K_UP, (char_u *)"Up"}, + {K_DOWN, (char_u *)"Down"}, + {K_LEFT, (char_u *)"Left"}, + {K_RIGHT, (char_u *)"Right"}, + {K_XUP, (char_u *)"xUp"}, + {K_XDOWN, (char_u *)"xDown"}, + {K_XLEFT, (char_u *)"xLeft"}, + {K_XRIGHT, (char_u *)"xRight"}, + + {K_F1, (char_u *)"F1"}, + {K_F2, (char_u *)"F2"}, + {K_F3, (char_u *)"F3"}, + {K_F4, (char_u *)"F4"}, + {K_F5, (char_u *)"F5"}, + {K_F6, (char_u *)"F6"}, + {K_F7, (char_u *)"F7"}, + {K_F8, (char_u *)"F8"}, + {K_F9, (char_u *)"F9"}, + {K_F10, (char_u *)"F10"}, + + {K_F11, (char_u *)"F11"}, + {K_F12, (char_u *)"F12"}, + {K_F13, (char_u *)"F13"}, + {K_F14, (char_u *)"F14"}, + {K_F15, (char_u *)"F15"}, + {K_F16, (char_u *)"F16"}, + {K_F17, (char_u *)"F17"}, + {K_F18, (char_u *)"F18"}, + {K_F19, (char_u *)"F19"}, + {K_F20, (char_u *)"F20"}, + + {K_F21, (char_u *)"F21"}, + {K_F22, (char_u *)"F22"}, + {K_F23, (char_u *)"F23"}, + {K_F24, (char_u *)"F24"}, + {K_F25, (char_u *)"F25"}, + {K_F26, (char_u *)"F26"}, + {K_F27, (char_u *)"F27"}, + {K_F28, (char_u *)"F28"}, + {K_F29, (char_u *)"F29"}, + {K_F30, (char_u *)"F30"}, + + {K_F31, (char_u *)"F31"}, + {K_F32, (char_u *)"F32"}, + {K_F33, (char_u *)"F33"}, + {K_F34, (char_u *)"F34"}, + {K_F35, (char_u *)"F35"}, + {K_F36, (char_u *)"F36"}, + {K_F37, (char_u *)"F37"}, + + {K_XF1, (char_u *)"xF1"}, + {K_XF2, (char_u *)"xF2"}, + {K_XF3, (char_u *)"xF3"}, + {K_XF4, (char_u *)"xF4"}, + + {K_HELP, (char_u *)"Help"}, + {K_UNDO, (char_u *)"Undo"}, + {K_INS, (char_u *)"Insert"}, + {K_INS, (char_u *)"Ins"}, /* Alternative name */ + {K_KINS, (char_u *)"kInsert"}, + {K_HOME, (char_u *)"Home"}, + {K_KHOME, (char_u *)"kHome"}, + {K_XHOME, (char_u *)"xHome"}, + {K_ZHOME, (char_u *)"zHome"}, + {K_END, (char_u *)"End"}, + {K_KEND, (char_u *)"kEnd"}, + {K_XEND, (char_u *)"xEnd"}, + {K_ZEND, (char_u *)"zEnd"}, + {K_PAGEUP, (char_u *)"PageUp"}, + {K_PAGEDOWN, (char_u *)"PageDown"}, + {K_KPAGEUP, (char_u *)"kPageUp"}, + {K_KPAGEDOWN, (char_u *)"kPageDown"}, + + {K_KPLUS, (char_u *)"kPlus"}, + {K_KMINUS, (char_u *)"kMinus"}, + {K_KDIVIDE, (char_u *)"kDivide"}, + {K_KMULTIPLY, (char_u *)"kMultiply"}, + {K_KENTER, (char_u *)"kEnter"}, + {K_KPOINT, (char_u *)"kPoint"}, + + {K_K0, (char_u *)"k0"}, + {K_K1, (char_u *)"k1"}, + {K_K2, (char_u *)"k2"}, + {K_K3, (char_u *)"k3"}, + {K_K4, (char_u *)"k4"}, + {K_K5, (char_u *)"k5"}, + {K_K6, (char_u *)"k6"}, + {K_K7, (char_u *)"k7"}, + {K_K8, (char_u *)"k8"}, + {K_K9, (char_u *)"k9"}, + + {'<', (char_u *)"lt"}, + + {K_MOUSE, (char_u *)"Mouse"}, + {K_NETTERM_MOUSE, (char_u *)"NetMouse"}, + {K_DEC_MOUSE, (char_u *)"DecMouse"}, +#ifdef FEAT_MOUSE_JSB + {K_JSBTERM_MOUSE, (char_u *)"JsbMouse"}, +#endif + {K_URXVT_MOUSE, (char_u *)"UrxvtMouse"}, + {K_SGR_MOUSE, (char_u *)"SgrMouse"}, + {K_LEFTMOUSE, (char_u *)"LeftMouse"}, + {K_LEFTMOUSE_NM, (char_u *)"LeftMouseNM"}, + {K_LEFTDRAG, (char_u *)"LeftDrag"}, + {K_LEFTRELEASE, (char_u *)"LeftRelease"}, + {K_LEFTRELEASE_NM, (char_u *)"LeftReleaseNM"}, + {K_MIDDLEMOUSE, (char_u *)"MiddleMouse"}, + {K_MIDDLEDRAG, (char_u *)"MiddleDrag"}, + {K_MIDDLERELEASE, (char_u *)"MiddleRelease"}, + {K_RIGHTMOUSE, (char_u *)"RightMouse"}, + {K_RIGHTDRAG, (char_u *)"RightDrag"}, + {K_RIGHTRELEASE, (char_u *)"RightRelease"}, + {K_MOUSEDOWN, (char_u *)"ScrollWheelUp"}, + {K_MOUSEUP, (char_u *)"ScrollWheelDown"}, + {K_MOUSELEFT, (char_u *)"ScrollWheelRight"}, + {K_MOUSERIGHT, (char_u *)"ScrollWheelLeft"}, + {K_MOUSEDOWN, (char_u *)"MouseDown"}, /* OBSOLETE: Use */ + {K_MOUSEUP, (char_u *)"MouseUp"}, /* ScrollWheelXXX instead */ + {K_X1MOUSE, (char_u *)"X1Mouse"}, + {K_X1DRAG, (char_u *)"X1Drag"}, + {K_X1RELEASE, (char_u *)"X1Release"}, + {K_X2MOUSE, (char_u *)"X2Mouse"}, + {K_X2DRAG, (char_u *)"X2Drag"}, + {K_X2RELEASE, (char_u *)"X2Release"}, + {K_DROP, (char_u *)"Drop"}, + {K_ZERO, (char_u *)"Nul"}, + {K_SNR, (char_u *)"SNR"}, + {K_PLUG, (char_u *)"Plug"}, + {0, NULL} +}; + +#define KEY_NAMES_TABLE_LEN (sizeof(key_names_table) / \ + sizeof(struct key_name_entry)) + +static struct mousetable { + int pseudo_code; /* Code for pseudo mouse event */ + int button; /* Which mouse button is it? */ + int is_click; /* Is it a mouse button click event? */ + int is_drag; /* Is it a mouse drag event? */ +} mouse_table[] = +{ + {(int)KE_LEFTMOUSE, MOUSE_LEFT, TRUE, FALSE}, + {(int)KE_LEFTDRAG, MOUSE_LEFT, FALSE, TRUE}, + {(int)KE_LEFTRELEASE, MOUSE_LEFT, FALSE, FALSE}, + {(int)KE_MIDDLEMOUSE, MOUSE_MIDDLE, TRUE, FALSE}, + {(int)KE_MIDDLEDRAG, MOUSE_MIDDLE, FALSE, TRUE}, + {(int)KE_MIDDLERELEASE, MOUSE_MIDDLE, FALSE, FALSE}, + {(int)KE_RIGHTMOUSE, MOUSE_RIGHT, TRUE, FALSE}, + {(int)KE_RIGHTDRAG, MOUSE_RIGHT, FALSE, TRUE}, + {(int)KE_RIGHTRELEASE, MOUSE_RIGHT, FALSE, FALSE}, + {(int)KE_X1MOUSE, MOUSE_X1, TRUE, FALSE}, + {(int)KE_X1DRAG, MOUSE_X1, FALSE, TRUE}, + {(int)KE_X1RELEASE, MOUSE_X1, FALSE, FALSE}, + {(int)KE_X2MOUSE, MOUSE_X2, TRUE, FALSE}, + {(int)KE_X2DRAG, MOUSE_X2, FALSE, TRUE}, + {(int)KE_X2RELEASE, MOUSE_X2, FALSE, FALSE}, + /* DRAG without CLICK */ + {(int)KE_IGNORE, MOUSE_RELEASE, FALSE, TRUE}, + /* RELEASE without CLICK */ + {(int)KE_IGNORE, MOUSE_RELEASE, FALSE, FALSE}, + {0, 0, 0, 0}, +}; + +/* + * Return the modifier mask bit (MOD_MASK_*) which corresponds to the given + * modifier name ('S' for Shift, 'C' for Ctrl etc). + */ +int name_to_mod_mask(int c) +{ + int i; + + c = TOUPPER_ASC(c); + for (i = 0; mod_mask_table[i].mod_mask != 0; i++) + if (c == mod_mask_table[i].name) + return mod_mask_table[i].mod_flag; + return 0; +} + +/* + * Check if if there is a special key code for "key" that includes the + * modifiers specified. + */ +int simplify_key(int key, int *modifiers) +{ + int i; + int key0; + int key1; + + if (*modifiers & (MOD_MASK_SHIFT | MOD_MASK_CTRL | MOD_MASK_ALT)) { + /* TAB is a special case */ + if (key == TAB && (*modifiers & MOD_MASK_SHIFT)) { + *modifiers &= ~MOD_MASK_SHIFT; + return K_S_TAB; + } + key0 = KEY2TERMCAP0(key); + key1 = KEY2TERMCAP1(key); + for (i = 0; modifier_keys_table[i] != NUL; i += MOD_KEYS_ENTRY_SIZE) + if (key0 == modifier_keys_table[i + 3] + && key1 == modifier_keys_table[i + 4] + && (*modifiers & modifier_keys_table[i])) { + *modifiers &= ~modifier_keys_table[i]; + return TERMCAP2KEY(modifier_keys_table[i + 1], + modifier_keys_table[i + 2]); + } + } + return key; +} + +/* + * Change <xHome> to <Home>, <xUp> to <Up>, etc. + */ +int handle_x_keys(int key) +{ + switch (key) { + case K_XUP: return K_UP; + case K_XDOWN: return K_DOWN; + case K_XLEFT: return K_LEFT; + case K_XRIGHT: return K_RIGHT; + case K_XHOME: return K_HOME; + case K_ZHOME: return K_HOME; + case K_XEND: return K_END; + case K_ZEND: return K_END; + case K_XF1: return K_F1; + case K_XF2: return K_F2; + case K_XF3: return K_F3; + case K_XF4: return K_F4; + case K_S_XF1: return K_S_F1; + case K_S_XF2: return K_S_F2; + case K_S_XF3: return K_S_F3; + case K_S_XF4: return K_S_F4; + } + return key; +} + +/* + * Return a string which contains the name of the given key when the given + * modifiers are down. + */ +char_u *get_special_key_name(int c, int modifiers) +{ + static char_u string[MAX_KEY_NAME_LEN + 1]; + + int i, idx; + int table_idx; + char_u *s; + + string[0] = '<'; + idx = 1; + + /* Key that stands for a normal character. */ + if (IS_SPECIAL(c) && KEY2TERMCAP0(c) == KS_KEY) + c = KEY2TERMCAP1(c); + + /* + * Translate shifted special keys into unshifted keys and set modifier. + * Same for CTRL and ALT modifiers. + */ + if (IS_SPECIAL(c)) { + for (i = 0; modifier_keys_table[i] != 0; i += MOD_KEYS_ENTRY_SIZE) + if ( KEY2TERMCAP0(c) == (int)modifier_keys_table[i + 1] + && (int)KEY2TERMCAP1(c) == (int)modifier_keys_table[i + 2]) { + modifiers |= modifier_keys_table[i]; + c = TERMCAP2KEY(modifier_keys_table[i + 3], + modifier_keys_table[i + 4]); + break; + } + } + + /* try to find the key in the special key table */ + table_idx = find_special_key_in_table(c); + + /* + * When not a known special key, and not a printable character, try to + * extract modifiers. + */ + if (c > 0 + && (*mb_char2len)(c) == 1 + ) { + if (table_idx < 0 + && (!vim_isprintc(c) || (c & 0x7f) == ' ') + && (c & 0x80)) { + c &= 0x7f; + modifiers |= MOD_MASK_ALT; + /* try again, to find the un-alted key in the special key table */ + table_idx = find_special_key_in_table(c); + } + if (table_idx < 0 && !vim_isprintc(c) && c < ' ') { + c += '@'; + modifiers |= MOD_MASK_CTRL; + } + } + + /* translate the modifier into a string */ + for (i = 0; mod_mask_table[i].name != 'A'; i++) + if ((modifiers & mod_mask_table[i].mod_mask) + == mod_mask_table[i].mod_flag) { + string[idx++] = mod_mask_table[i].name; + string[idx++] = (char_u)'-'; + } + + if (table_idx < 0) { /* unknown special key, may output t_xx */ + if (IS_SPECIAL(c)) { + string[idx++] = 't'; + string[idx++] = '_'; + string[idx++] = KEY2TERMCAP0(c); + string[idx++] = KEY2TERMCAP1(c); + } + /* Not a special key, only modifiers, output directly */ + else { + if (has_mbyte && (*mb_char2len)(c) > 1) + idx += (*mb_char2bytes)(c, string + idx); + else if (vim_isprintc(c)) + string[idx++] = c; + else { + s = transchar(c); + while (*s) + string[idx++] = *s++; + } + } + } else { /* use name of special key */ + STRCPY(string + idx, key_names_table[table_idx].name); + idx = (int)STRLEN(string); + } + string[idx++] = '>'; + string[idx] = NUL; + return string; +} + +/* + * Try translating a <> name at (*srcp)[] to dst[]. + * Return the number of characters added to dst[], zero for no match. + * If there is a match, srcp is advanced to after the <> name. + * dst[] must be big enough to hold the result (up to six characters)! + */ +int +trans_special ( + char_u **srcp, + char_u *dst, + int keycode /* prefer key code, e.g. K_DEL instead of DEL */ +) +{ + int modifiers = 0; + int key; + int dlen = 0; + + key = find_special_key(srcp, &modifiers, keycode, FALSE); + if (key == 0) + return 0; + + /* Put the appropriate modifier in a string */ + if (modifiers != 0) { + dst[dlen++] = K_SPECIAL; + dst[dlen++] = KS_MODIFIER; + dst[dlen++] = modifiers; + } + + if (IS_SPECIAL(key)) { + dst[dlen++] = K_SPECIAL; + dst[dlen++] = KEY2TERMCAP0(key); + dst[dlen++] = KEY2TERMCAP1(key); + } else if (has_mbyte && !keycode) + dlen += (*mb_char2bytes)(key, dst + dlen); + else if (keycode) + dlen = (int)(add_char2buf(key, dst + dlen) - dst); + else + dst[dlen++] = key; + + return dlen; +} + +/* + * Try translating a <> name at (*srcp)[], return the key and modifiers. + * srcp is advanced to after the <> name. + * returns 0 if there is no match. + */ +int +find_special_key ( + char_u **srcp, + int *modp, + int keycode, /* prefer key code, e.g. K_DEL instead of DEL */ + int keep_x_key /* don't translate xHome to Home key */ +) +{ + char_u *last_dash; + char_u *end_of_name; + char_u *src; + char_u *bp; + int modifiers; + int bit; + int key; + unsigned long n; + int l; + + src = *srcp; + if (src[0] != '<') + return 0; + + /* Find end of modifier list */ + last_dash = src; + for (bp = src + 1; *bp == '-' || vim_isIDc(*bp); bp++) { + if (*bp == '-') { + last_dash = bp; + if (bp[1] != NUL) { + if (has_mbyte) + l = mb_ptr2len(bp + 1); + else + l = 1; + if (bp[l + 1] == '>') + bp += l; /* anything accepted, like <C-?> */ + } + } + if (bp[0] == 't' && bp[1] == '_' && bp[2] && bp[3]) + bp += 3; /* skip t_xx, xx may be '-' or '>' */ + else if (STRNICMP(bp, "char-", 5) == 0) { + vim_str2nr(bp + 5, NULL, &l, TRUE, TRUE, NULL, NULL); + bp += l + 5; + break; + } + } + + if (*bp == '>') { /* found matching '>' */ + end_of_name = bp + 1; + + /* Which modifiers are given? */ + modifiers = 0x0; + for (bp = src + 1; bp < last_dash; bp++) { + if (*bp != '-') { + bit = name_to_mod_mask(*bp); + if (bit == 0x0) + break; /* Illegal modifier name */ + modifiers |= bit; + } + } + + /* + * Legal modifier name. + */ + if (bp >= last_dash) { + if (STRNICMP(last_dash + 1, "char-", 5) == 0 + && VIM_ISDIGIT(last_dash[6])) { + /* <Char-123> or <Char-033> or <Char-0x33> */ + vim_str2nr(last_dash + 6, NULL, NULL, TRUE, TRUE, NULL, &n); + key = (int)n; + } else { + /* + * Modifier with single letter, or special key name. + */ + if (has_mbyte) + l = mb_ptr2len(last_dash + 1); + else + l = 1; + if (modifiers != 0 && last_dash[l + 1] == '>') + key = PTR2CHAR(last_dash + 1); + else { + key = get_special_key_code(last_dash + 1); + if (!keep_x_key) + key = handle_x_keys(key); + } + } + + /* + * get_special_key_code() may return NUL for invalid + * special key name. + */ + if (key != NUL) { + /* + * Only use a modifier when there is no special key code that + * includes the modifier. + */ + key = simplify_key(key, &modifiers); + + if (!keycode) { + /* don't want keycode, use single byte code */ + if (key == K_BS) + key = BS; + else if (key == K_DEL || key == K_KDEL) + key = DEL; + } + + /* + * Normal Key with modifier: Try to make a single byte code. + */ + if (!IS_SPECIAL(key)) + key = extract_modifiers(key, &modifiers); + + *modp = modifiers; + *srcp = end_of_name; + return key; + } + } + } + return 0; +} + +/* + * Try to include modifiers in the key. + * Changes "Shift-a" to 'A', "Alt-A" to 0xc0, etc. + */ +int extract_modifiers(int key, int *modp) +{ + int modifiers = *modp; + + if ((modifiers & MOD_MASK_SHIFT) && ASCII_ISALPHA(key)) { + key = TOUPPER_ASC(key); + modifiers &= ~MOD_MASK_SHIFT; + } + if ((modifiers & MOD_MASK_CTRL) + && ((key >= '?' && key <= '_') || ASCII_ISALPHA(key)) + ) { + key = Ctrl_chr(key); + modifiers &= ~MOD_MASK_CTRL; + /* <C-@> is <Nul> */ + if (key == 0) + key = K_ZERO; + } + if ((modifiers & MOD_MASK_ALT) && key < 0x80 + && !enc_dbcs /* avoid creating a lead byte */ + ) { + key |= 0x80; + modifiers &= ~MOD_MASK_ALT; /* remove the META modifier */ + } + + *modp = modifiers; + return key; +} + +/* + * Try to find key "c" in the special key table. + * Return the index when found, -1 when not found. + */ +int find_special_key_in_table(int c) +{ + int i; + + for (i = 0; key_names_table[i].name != NULL; i++) + if (c == key_names_table[i].key) + break; + if (key_names_table[i].name == NULL) + i = -1; + return i; +} + +/* + * Find the special key with the given name (the given string does not have to + * end with NUL, the name is assumed to end before the first non-idchar). + * If the name starts with "t_" the next two characters are interpreted as a + * termcap name. + * Return the key code, or 0 if not found. + */ +int get_special_key_code(char_u *name) +{ + char_u *table_name; + char_u string[3]; + int i, j; + + /* + * If it's <t_xx> we get the code for xx from the termcap + */ + if (name[0] == 't' && name[1] == '_' && name[2] != NUL && name[3] != NUL) { + string[0] = name[2]; + string[1] = name[3]; + string[2] = NUL; + if (add_termcap_entry(string, FALSE) == OK) + return TERMCAP2KEY(name[2], name[3]); + } else + for (i = 0; key_names_table[i].name != NULL; i++) { + table_name = key_names_table[i].name; + for (j = 0; vim_isIDc(name[j]) && table_name[j] != NUL; j++) + if (TOLOWER_ASC(table_name[j]) != TOLOWER_ASC(name[j])) + break; + if (!vim_isIDc(name[j]) && table_name[j] == NUL) + return key_names_table[i].key; + } + return 0; +} + +char_u *get_key_name(int i) +{ + if (i >= (int)KEY_NAMES_TABLE_LEN) + return NULL; + return key_names_table[i].name; +} + +/* + * Look up the given mouse code to return the relevant information in the other + * arguments. Return which button is down or was released. + */ +int get_mouse_button(int code, int *is_click, int *is_drag) +{ + int i; + + for (i = 0; mouse_table[i].pseudo_code; i++) + if (code == mouse_table[i].pseudo_code) { + *is_click = mouse_table[i].is_click; + *is_drag = mouse_table[i].is_drag; + return mouse_table[i].button; + } + return 0; /* Shouldn't get here */ +} + +/* + * Return the appropriate pseudo mouse event token (KE_LEFTMOUSE etc) based on + * the given information about which mouse button is down, and whether the + * mouse was clicked, dragged or released. + */ +int +get_pseudo_mouse_code ( + int button, /* eg MOUSE_LEFT */ + int is_click, + int is_drag +) +{ + int i; + + for (i = 0; mouse_table[i].pseudo_code; i++) + if (button == mouse_table[i].button + && is_click == mouse_table[i].is_click + && is_drag == mouse_table[i].is_drag) { + return mouse_table[i].pseudo_code; + } + return (int)KE_IGNORE; /* not recognized, ignore it */ +} |