diff --git a/mac/macterm.c b/mac/macterm.c index 377ea010..4c463565 100644 --- a/mac/macterm.c +++ b/mac/macterm.c @@ -1,4 +1,4 @@ -/* $Id: macterm.c,v 1.56 2003/01/25 19:23:03 ben Exp $ */ +/* $Id: macterm.c,v 1.57 2003/01/27 00:39:01 ben Exp $ */ /* * Copyright (c) 1999 Simon Tatham * Copyright (c) 1999, 2002 Ben Harris @@ -89,7 +89,6 @@ static void mac_drawgrowicon(Session *s); static pascal void mac_growtermdraghook(void); static pascal void mac_scrolltracker(ControlHandle, short); static pascal void do_text_for_device(short, short, GDHandle, long); -static int mac_keytrans(Session *, EventRecord *, unsigned char *); static void text_click(Session *, EventRecord *); void pre_paint(Session *s); @@ -685,202 +684,96 @@ static pascal void mac_scrolltracker(ControlHandle control, short part) { } } -#define K_BS 0x3300 -#define K_F1 0x7a00 -#define K_F2 0x7800 -#define K_F3 0x6300 -#define K_F4 0x7600 -#define K_F5 0x6000 -#define K_F6 0x6100 -#define K_F7 0x6200 -#define K_F8 0x6400 -#define K_F9 0x6500 -#define K_F10 0x6d00 -#define K_F11 0x6700 -#define K_F12 0x6f00 -#define K_F13 0x6900 -#define K_F14 0x6b00 -#define K_F15 0x7100 -#define K_INSERT 0x7200 -#define K_HOME 0x7300 -#define K_PRIOR 0x7400 -#define K_DELETE 0x7500 -#define K_END 0x7700 -#define K_NEXT 0x7900 -#define K_LEFT 0x7b00 -#define K_RIGHT 0x7c00 -#define K_DOWN 0x7d00 -#define K_UP 0x7e00 -#define KP_0 0x5200 -#define KP_1 0x5300 -#define KP_2 0x5400 -#define KP_3 0x5500 -#define KP_4 0x5600 -#define KP_5 0x5700 -#define KP_6 0x5800 -#define KP_7 0x5900 -#define KP_8 0x5b00 -#define KP_9 0x5c00 -#define KP_CLEAR 0x4700 -#define KP_EQUAL 0x5100 -#define KP_SLASH 0x4b00 -#define KP_STAR 0x4300 -#define KP_PLUS 0x4500 -#define KP_MINUS 0x4e00 -#define KP_DOT 0x4100 -#define KP_ENTER 0x4c00 - void mac_keyterm(WindowPtr window, EventRecord *event) { - unsigned char buf[20]; - int len; - Session *s; + Session *s = (Session *)GetWRefCon(window); + Key_Sym keysym = PK_NULL; + unsigned int mods = 0, flags = PKF_NUMLOCK; + wchar_t utxt[1]; - s = (Session *)GetWRefCon(window); - len = mac_keytrans(s, event, buf); - ldisc_send(s->ldisc, (char *)buf, len, 1); ObscureCursor(); - term_seen_key_event(s->term); - term_out(s->term); - term_update(s->term); -} -static int mac_keytrans(Session *s, EventRecord *event, - unsigned char *output) { - unsigned char *p = output; - int code; + fprintf(stderr, "Got key event %08x\n", event->message); /* No meta key yet -- that'll be rather fun. */ /* Keys that we handle locally */ if (event->modifiers & shiftKey) { - switch (event->message & keyCodeMask) { - case K_PRIOR: /* shift-pageup */ + switch ((event->message & keyCodeMask) >> 8) { + case 0x74: /* shift-pageup */ term_scroll(s->term, 0, -(s->term->rows - 1)); - return 0; - case K_NEXT: /* shift-pagedown */ + return; + case 0x79: /* shift-pagedown */ term_scroll(s->term, 0, +(s->term->rows - 1)); - return 0; + return; } } - /* - * Control-2 should return ^@ (0x00), Control-6 should return - * ^^ (0x1E), and Control-Minus should return ^_ (0x1F). Since - * the DOS keyboard handling did it, and we have nothing better - * to do with the key combo in question, we'll also map - * Control-Backquote to ^\ (0x1C). - */ + if (event->modifiers & shiftKey) + mods |= PKM_SHIFT; + if (event->modifiers & controlKey) + mods |= PKM_CONTROL; + if (event->what == autoKey) + flags |= PKF_REPEAT; - if (event->modifiers & controlKey) { - switch (event->message & charCodeMask) { - case ' ': case '2': - *p++ = 0x00; - return p - output; - case '`': - *p++ = 0x1c; - return p - output; - case '6': - *p++ = 0x1e; - return p - output; - case '/': - *p++ = 0x1f; - return p - output; - } + /* Mac key events consist of a virtual key code and a character code. */ + + switch ((event->message & keyCodeMask) >> 8) { + case 0x24: keysym = PK_RETURN; break; + case 0x30: keysym = PK_TAB; break; + case 0x33: keysym = PK_BACKSPACE; break; + case 0x35: keysym = PK_ESCAPE; break; + + case 0x7A: keysym = PK_F1; break; + case 0x78: keysym = PK_F2; break; + case 0x63: keysym = PK_F3; break; + case 0x76: keysym = PK_F4; break; + case 0x60: keysym = PK_F5; break; + case 0x61: keysym = PK_F6; break; + case 0x62: keysym = PK_F7; break; + case 0x64: keysym = PK_F8; break; + case 0x65: keysym = PK_F9; break; + case 0x6D: keysym = PK_F10; break; + case 0x67: keysym = PK_F11; break; + case 0x6F: keysym = PK_F12; break; + case 0x69: keysym = PK_F13; break; + case 0x6B: keysym = PK_F14; break; + case 0x71: keysym = PK_F15; break; + + case 0x72: keysym = PK_INSERT; break; + case 0x73: keysym = PK_HOME; break; + case 0x74: keysym = PK_PAGEUP; break; + case 0x75: keysym = PK_DELETE; break; + case 0x77: keysym = PK_END; break; + case 0x79: keysym = PK_PAGEDOWN; break; + + case 0x47: keysym = PK_PF1; break; + case 0x51: keysym = PK_PF2; break; + case 0x4B: keysym = PK_PF3; break; + case 0x43: keysym = PK_PF4; break; + case 0x4E: keysym = PK_KPMINUS; break; + case 0x45: keysym = PK_KPCOMMA; break; + case 0x41: keysym = PK_KPDECIMAL; break; + case 0x4C: keysym = PK_KPENTER; break; + case 0x52: keysym = PK_KP0; break; + case 0x53: keysym = PK_KP1; break; + case 0x54: keysym = PK_KP2; break; + case 0x55: keysym = PK_KP3; break; + case 0x56: keysym = PK_KP4; break; + case 0x57: keysym = PK_KP5; break; + case 0x58: keysym = PK_KP6; break; + case 0x59: keysym = PK_KP7; break; + case 0x5B: keysym = PK_KP8; break; + case 0x5C: keysym = PK_KP9; break; + + case 0x7B: keysym = PK_LEFT; break; + case 0x7C: keysym = PK_RIGHT; break; + case 0x7D: keysym = PK_DOWN; break; + case 0x7E: keysym = PK_UP; break; } - /* - * First, all the keys that do tilde codes. (ESC '[' nn '~', - * for integer decimal nn.) - * - * We also deal with the weird ones here. Linux VCs replace F1 - * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but - * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w - * respectively. - */ - code = 0; - switch (event->message & keyCodeMask) { - case K_F1: code = (event->modifiers & shiftKey ? 23 : 11); break; - case K_F2: code = (event->modifiers & shiftKey ? 24 : 12); break; - case K_F3: code = (event->modifiers & shiftKey ? 25 : 13); break; - case K_F4: code = (event->modifiers & shiftKey ? 26 : 14); break; - case K_F5: code = (event->modifiers & shiftKey ? 28 : 15); break; - case K_F6: code = (event->modifiers & shiftKey ? 29 : 17); break; - case K_F7: code = (event->modifiers & shiftKey ? 31 : 18); break; - case K_F8: code = (event->modifiers & shiftKey ? 32 : 19); break; - case K_F9: code = (event->modifiers & shiftKey ? 33 : 20); break; - case K_F10: code = (event->modifiers & shiftKey ? 34 : 21); break; - case K_F11: code = 23; break; - case K_F12: code = 24; break; - case K_HOME: code = 1; break; - case K_INSERT: code = 2; break; - case K_DELETE: code = 3; break; - case K_END: code = 4; break; - case K_PRIOR: code = 5; break; - case K_NEXT: code = 6; break; - } - if (s->cfg.funky_type == 1 && code >= 11 && code <= 15) { - p += sprintf((char *)p, "\x1B[[%c", code + 'A' - 11); - return p - output; - } - if (s->cfg.rxvt_homeend && (code == 1 || code == 4)) { - p += sprintf((char *)p, code == 1 ? "\x1B[H" : "\x1BOw"); - return p - output; - } - if (code) { - p += sprintf((char *)p, "\x1B[%d~", code); - return p - output; - } - - if (s->term->app_keypad_keys) { - switch (event->message & keyCodeMask) { - case KP_ENTER: p += sprintf((char *)p, "\x1BOM"); return p - output; - case KP_CLEAR: p += sprintf((char *)p, "\x1BOP"); return p - output; - case KP_EQUAL: p += sprintf((char *)p, "\x1BOQ"); return p - output; - case KP_SLASH: p += sprintf((char *)p, "\x1BOR"); return p - output; - case KP_STAR: p += sprintf((char *)p, "\x1BOS"); return p - output; - case KP_PLUS: p += sprintf((char *)p, "\x1BOl"); return p - output; - case KP_MINUS: p += sprintf((char *)p, "\x1BOm"); return p - output; - case KP_DOT: p += sprintf((char *)p, "\x1BOn"); return p - output; - case KP_0: p += sprintf((char *)p, "\x1BOp"); return p - output; - case KP_1: p += sprintf((char *)p, "\x1BOq"); return p - output; - case KP_2: p += sprintf((char *)p, "\x1BOr"); return p - output; - case KP_3: p += sprintf((char *)p, "\x1BOs"); return p - output; - case KP_4: p += sprintf((char *)p, "\x1BOt"); return p - output; - case KP_5: p += sprintf((char *)p, "\x1BOu"); return p - output; - case KP_6: p += sprintf((char *)p, "\x1BOv"); return p - output; - case KP_7: p += sprintf((char *)p, "\x1BOw"); return p - output; - case KP_8: p += sprintf((char *)p, "\x1BOx"); return p - output; - case KP_9: p += sprintf((char *)p, "\x1BOy"); return p - output; - } - } - - switch (event->message & keyCodeMask) { - case K_UP: - p += sprintf((char *)p, - s->term->app_cursor_keys ? "\x1BOA" : "\x1B[A"); - return p - output; - case K_DOWN: - p += sprintf((char *)p, - s->term->app_cursor_keys ? "\x1BOB" : "\x1B[B"); - return p - output; - case K_RIGHT: - p += sprintf((char *)p, - s->term->app_cursor_keys ? "\x1BOC" : "\x1B[C"); - return p - output; - case K_LEFT: - p += sprintf((char *)p, - s->term->app_cursor_keys ? "\x1BOD" : "\x1B[D"); - return p - output; - case KP_ENTER: - *p++ = 0x0d; - return p - output; - case K_BS: - *p++ = (s->cfg.bksp_is_delete ? 0x7f : 0x08); - return p - output; - default: - *p++ = event->message & charCodeMask; - return p - output; - } + /* XXX Map from key script to Unicode. */ + utxt[0] = event->message & charCodeMask; + term_key(s->term, keysym, utxt, 1, mods, flags); } void request_paste(void *frontend) diff --git a/putty.h b/putty.h index c8f95ff4..3782f913 100644 --- a/putty.h +++ b/putty.h @@ -146,6 +146,47 @@ typedef enum { MA_NOTHING, MA_CLICK, MA_2CLK, MA_3CLK, MA_DRAG, MA_RELEASE } Mouse_Action; +/* Keyboard modifiers -- keys the user is actually holding down */ + +#define PKM_SHIFT 0x01 +#define PKM_CONTROL 0x02 +#define PKM_META 0x04 +#define PKM_ALT 0x08 + +/* Keyboard flags that aren't really modifiers */ +#define PKF_CAPSLOCK 0x10 +#define PKF_NUMLOCK 0x20 +#define PKF_REPEAT 0x40 + +/* Stand-alone keysyms for function keys */ + +typedef enum { + PK_NULL, /* No symbol for this key */ + /* Main keypad keys */ + PK_ESCAPE, PK_TAB, PK_BACKSPACE, PK_RETURN, PK_COMPOSE, + /* Editing keys */ + PK_HOME, PK_INSERT, PK_DELETE, PK_END, PK_PAGEUP, PK_PAGEDOWN, + /* Cursor keys */ + PK_UP, PK_DOWN, PK_RIGHT, PK_LEFT, PK_REST, + /* Numeric keypad */ /* Real one looks like: */ + PK_PF1, PK_PF2, PK_PF3, PK_PF4, /* PF1 PF2 PF3 PF4 */ + PK_KPCOMMA, PK_KPMINUS, PK_KPDECIMAL, /* 7 8 9 - */ + PK_KP0, PK_KP1, PK_KP2, PK_KP3, PK_KP4, /* 4 5 6 , */ + PK_KP5, PK_KP6, PK_KP7, PK_KP8, PK_KP9, /* 1 2 3 en- */ + PK_KPBIGPLUS, PK_KPENTER, /* 0 . ter */ + /* Top row */ + PK_F1, PK_F2, PK_F3, PK_F4, PK_F5, + PK_F6, PK_F7, PK_F8, PK_F9, PK_F10, + PK_F11, PK_F12, PK_F13, PK_F14, PK_F15, + PK_F16, PK_F17, PK_F18, PK_F19, PK_F20, + PK_PAUSE +} Key_Sym; + +#define PK_ISEDITING(k) ((k) >= PK_HOME && (k) <= PK_PAGEDOWN) +#define PK_ISCURSOR(k) ((k) >= PK_UP && (k) <= PK_REST) +#define PK_ISKEYPAD(k) ((k) >= PK_PF1 && (k) <= PK_KPENTER) +#define PK_ISFKEY(k) ((k) >= PK_F1 && (k) <= PK_F20) + typedef enum { VT_XWINDOWS, VT_OEMANSI, VT_OEMONLY, VT_POORMAN, VT_UNICODE } VT_Mode; @@ -186,6 +227,16 @@ enum { COE_ALWAYS /* Always close the window */ }; +enum { + /* Function key types (cfg.funky_type) */ + FUNKY_TILDE, + FUNKY_LINUX, + FUNKY_XTERM, + FUNKY_VT400, + FUNKY_VT100P, + FUNKY_SCO +}; + struct backend_tag { char *(*init) (void *frontend_handle, void **backend_handle, Config *cfg, char *host, int port, char **realhost, int nodelay); @@ -506,6 +557,8 @@ void term_pwron(Terminal *); void term_clrsb(Terminal *); void term_mouse(Terminal *, Mouse_Button, Mouse_Button, Mouse_Action, int,int,int,int,int); +void term_key(Terminal *, Key_Sym, wchar_t *, size_t, unsigned int, + unsigned int); void term_deselect(Terminal *); void term_update(Terminal *); void term_invalidate(Terminal *); diff --git a/terminal.c b/terminal.c index 87085c66..93879d60 100644 --- a/terminal.c +++ b/terminal.c @@ -4009,6 +4009,429 @@ void term_mouse(Terminal *term, Mouse_Button braw, Mouse_Button bcooked, term_update(term); } +void term_key(Terminal *term, Key_Sym keysym, wchar_t *text, size_t tlen, + unsigned int modifiers, unsigned int flags) +{ + char output[10]; + char *p = output; + int prependesc = FALSE; + int i; + + fprintf(stderr, "keysym = %d, %d chars:", keysym, tlen); + for (i = 0; i < tlen; i++) + fprintf(stderr, " %04x", text[i]); + fprintf(stderr, "\n"); + + /* XXX Num Lock */ + if ((flags & PKF_REPEAT) && term->repeat_off) + return; + + /* Currently, Meta always just prefixes everything with ESC. */ + if (modifiers & PKM_META) + prependesc = TRUE; + modifiers &= ~PKM_META; + + /* + * Alt is only used for Alt+keypad, which isn't supported yet, so + * ignore it. + */ + modifiers &= ~PKM_ALT; + + /* Standard local function keys */ + switch (modifiers & (PKM_SHIFT | PKM_CONTROL)) { + case PKM_SHIFT: + if (keysym == PK_PAGEUP) + /* scroll up one page */; + if (keysym == PK_PAGEDOWN) + /* scroll down on page */; + if (keysym == PK_INSERT) + term_do_paste(term); + break; + case PKM_CONTROL: + if (keysym == PK_PAGEUP) + /* scroll up one line */; + if (keysym == PK_PAGEDOWN) + /* scroll down one line */; + /* Control-Numlock for app-keypad mode switch */ + if (keysym == PK_PF1) + term->app_keypad_keys ^= 1; + break; + } + + if (modifiers & PKM_ALT) { + /* Alt+F4 (close) */ + /* Alt+Return (full screen) */ + /* Alt+Space (system menu) */ + } + + if (keysym == PK_NULL && (modifiers & PKM_CONTROL) && tlen == 1 && + text[0] >= 0x20 && text[0] <= 0x7e) { + /* ASCII chars + Control */ + if (text[0] >= 0x40 && text[0] <= 0x5f || + text[0] >= 0x61 && text[0] <= 0x7a) + text[0] &= 0x1f; + else { + /* + * Control-2 should return ^@ (0x00), Control-6 should return + * ^^ (0x1E), and Control-Minus should return ^_ (0x1F). Since + * the DOS keyboard handling did it, and we have nothing better + * to do with the key combo in question, we'll also map + * Control-Backquote to ^\ (0x1C). + */ + switch (text[0]) { + case ' ': text[0] = 0x00; break; + case '-': text[0] = 0x1f; break; + case '/': text[0] = 0x1f; break; + case '2': text[0] = 0x00; break; + case '3': text[0] = 0x1b; break; + case '4': text[0] = 0x1c; break; + case '5': text[0] = 0x1d; break; + case '6': text[0] = 0x1e; break; + case '7': text[0] = 0x1f; break; + case '8': text[0] = 0x7f; break; + case '`': text[0] = 0x1c; break; + } + } + } + + /* Nethack keypad */ + if (term->cfg.nethack_keypad) { + char c = 0; + switch (keysym) { + case PK_KP1: c = 'b'; break; + case PK_KP2: c = 'j'; break; + case PK_KP3: c = 'n'; break; + case PK_KP4: c = 'h'; break; + case PK_KP5: c = '.'; break; + case PK_KP6: c = 'l'; break; + case PK_KP7: c = 'y'; break; + case PK_KP8: c = 'k'; break; + case PK_KP9: c = 'u'; break; + } + if (c != 0) { + if (c != '.') { + if (modifiers & PKM_CONTROL) + c &= 0x1f; + else if (modifiers & PKM_SHIFT) + c = toupper(c); + } + *p++ = c; + goto done; + } + } + + /* Numeric Keypad */ + if (PK_ISKEYPAD(keysym)) { + int xkey = 0; + + /* + * In VT400 mode, PFn always emits an escape sequence. In + * Linux and tilde modes, this only happens in app keypad mode. + */ + if (term->cfg.funky_type == FUNKY_VT400 || + ((term->cfg.funky_type == FUNKY_LINUX || + term->cfg.funky_type == FUNKY_TILDE) && + term->app_keypad_keys && !term->cfg.no_applic_k)) { + switch (keysym) { + case PK_PF1: xkey = 'P'; break; + case PK_PF2: xkey = 'Q'; break; + case PK_PF3: xkey = 'R'; break; + case PK_PF4: xkey = 'S'; break; + } + } + if (term->app_keypad_keys && !term->cfg.no_applic_k) { + switch (keysym) { + case PK_KP0: xkey = 'p'; break; + case PK_KP1: xkey = 'q'; break; + case PK_KP2: xkey = 'r'; break; + case PK_KP3: xkey = 's'; break; + case PK_KP4: xkey = 't'; break; + case PK_KP5: xkey = 'u'; break; + case PK_KP6: xkey = 'v'; break; + case PK_KP7: xkey = 'w'; break; + case PK_KP8: xkey = 'x'; break; + case PK_KP9: xkey = 'y'; break; + case PK_KPDECIMAL: xkey = 'n'; break; + case PK_KPENTER: xkey = 'M'; break; + } + if (term->cfg.funky_type == FUNKY_XTERM && tlen > 0) { + /* + * xterm can't see the layout of the keypad, so it has + * to rely on the X keysyms returned by the keys. + * Hence, we look at the strings here, not the PuTTY + * keysyms (which describe the layout). + */ + switch (text[0]) { + case '+': + if (modifiers & PKM_SHIFT) + xkey = 'l'; + else + xkey = 'k'; + break; + case '/': xkey = 'o'; break; + case '*': xkey = 'j'; break; + case '-': xkey = 'm'; break; + } + } else { + /* + * In all other modes, we try to retain the layout of + * the DEC keypad in application mode. + */ + switch (keysym) { + case PK_KPBIGPLUS: + /* This key covers the '-' and ',' keys on a VT220 */ + if (modifiers & PKM_SHIFT) + xkey = 'm'; /* VT220 '-' */ + else + xkey = 'l'; /* VT220 ',' */ + break; + case PK_KPMINUS: xkey = 'm'; break; + case PK_KPCOMMA: xkey = 'l'; break; + } + } + } + if (xkey) { + if (term->vt52_mode) { + if (xkey >= 'P' && xkey <= 'S') + p += sprintf((char *) p, "\x1B%c", xkey); + else + p += sprintf((char *) p, "\x1B?%c", xkey); + } else + p += sprintf((char *) p, "\x1BO%c", xkey); + goto done; + } + /* Not in application mode -- treat the number pad as arrow keys? */ + if ((flags & PKF_NUMLOCK) == 0) { + switch (keysym) { + case PK_KP0: keysym = PK_INSERT; break; + case PK_KP1: keysym = PK_END; break; + case PK_KP2: keysym = PK_DOWN; break; + case PK_KP3: keysym = PK_PAGEDOWN; break; + case PK_KP4: keysym = PK_LEFT; break; + case PK_KP5: keysym = PK_REST; break; + case PK_KP6: keysym = PK_RIGHT; break; + case PK_KP7: keysym = PK_HOME; break; + case PK_KP8: keysym = PK_UP; break; + case PK_KP9: keysym = PK_PAGEUP; break; + } + } + } + + /* Miscellaneous keys */ + switch (keysym) { + case PK_ESCAPE: + *p++ = 0x1b; + goto done; + case PK_BACKSPACE: + if (modifiers == 0) + *p++ = (term->cfg.bksp_is_delete ? 0x7F : 0x08); + else if (modifiers == PKM_SHIFT) + /* We do the opposite of what is configured */ + *p++ = (term->cfg.bksp_is_delete ? 0x08 : 0x7F); + else break; + goto done; + case PK_TAB: + if (modifiers == 0) + *p++ = 0x09; + else if (modifiers == PKM_SHIFT) + *p++ = 0x1B, *p++ = '[', *p++ = 'Z'; + else break; + goto done; + /* XXX window.c has ctrl+shift+space sending 0xa0 */ + case PK_PAUSE: + if (modifiers == PKM_CONTROL) + *p++ = 26; + else break; + goto done; + case PK_RETURN: + case PK_KPENTER: /* Odd keypad modes handled above */ + if (modifiers == 0) { + *p++ = 0x0d; + if (term->cr_lf_return) + *p++ = 0x0a; + goto done; + } + } + + /* SCO function keys and editing keys */ + if (term->cfg.funky_type == FUNKY_SCO) { + if (PK_ISFKEY(keysym) && keysym <= PK_F12) { + static char const codes[] = + "MNOPQRSTUVWX" "YZabcdefghij" "klmnopqrstuv" "wxyz@[\\]^_`{"; + int index = keysym - PK_F1; + + if (modifiers & PKM_SHIFT) index += 12; + if (modifiers & PKM_CONTROL) index += 24; + p += sprintf((char *) p, "\x1B[%c", codes[index]); + goto done; + } + if (PK_ISEDITING(keysym)) { + int xkey = 0; + + switch (keysym) { + case PK_DELETE: *p++ = 0x7f; goto done; + case PK_HOME: xkey = 'H'; break; + case PK_INSERT: xkey = 'L'; break; + case PK_END: xkey = 'F'; break; + case PK_PAGEUP: xkey = 'I'; break; + case PK_PAGEDOWN: xkey = 'G'; break; + } + p += sprintf((char *) p, "\x1B[%c", xkey); + } + } + + if (PK_ISEDITING(keysym) && (modifiers & PKM_SHIFT) == 0) { + int code; + + if (term->cfg.funky_type == FUNKY_XTERM) { + /* Xterm shuffles these keys, apparently. */ + switch (keysym) { + case PK_HOME: keysym = PK_INSERT; break; + case PK_INSERT: keysym = PK_HOME; break; + case PK_DELETE: keysym = PK_END; break; + case PK_END: keysym = PK_PAGEUP; break; + case PK_PAGEUP: keysym = PK_DELETE; break; + case PK_PAGEDOWN: keysym = PK_PAGEDOWN; break; + } + } + + /* RXVT Home/End */ + if (term->cfg.rxvt_homeend && + (keysym == PK_HOME || keysym == PK_END)) { + p += sprintf((char *) p, keysym == PK_HOME ? "\x1B[H" : "\x1BOw"); + goto done; + } + + if (term->vt52_mode) { + int xkey; + + /* + * A real VT52 doesn't have these, and a VT220 doesn't + * send anything for them in VT52 mode. + */ + switch (keysym) { + case PK_HOME: xkey = 'H'; break; + case PK_INSERT: xkey = 'L'; break; + case PK_DELETE: xkey = 'M'; break; + case PK_END: xkey = 'E'; break; + case PK_PAGEUP: xkey = 'I'; break; + case PK_PAGEDOWN: xkey = 'G'; break; + } + p += sprintf((char *) p, "\x1B%c", xkey); + goto done; + } + + switch (keysym) { + case PK_HOME: code = 1; break; + case PK_INSERT: code = 2; break; + case PK_DELETE: code = 3; break; + case PK_END: code = 4; break; + case PK_PAGEUP: code = 5; break; + case PK_PAGEDOWN: code = 6; break; + } + p += sprintf((char *) p, "\x1B[%d~", code); + goto done; + } + + if (PK_ISFKEY(keysym)) { + /* Map Shift+F1-F10 to F11-F20 */ + if (keysym >= PK_F1 && keysym <= PK_F10 && (modifiers & PKM_SHIFT)) + keysym += 10; + if ((term->vt52_mode || term->cfg.funky_type == FUNKY_VT100P) && + keysym <= PK_F14) { + /* XXX This overrides the XTERM/VT52 mode below */ + int offt = 0; + if (keysym >= PK_F6) offt++; + if (keysym >= PK_F12) offt++; + p += sprintf((char *) p, term->vt52_mode ? "\x1B%c" : "\x1BO%c", + 'P' + keysym - PK_F1 - offt); + goto done; + } + if (term->cfg.funky_type == FUNKY_LINUX && keysym <= PK_F5) { + p += sprintf((char *) p, "\x1B[[%c", 'A' + keysym - PK_F1); + goto done; + } + if (term->cfg.funky_type == FUNKY_XTERM && keysym <= PK_F4) { + if (term->vt52_mode) + p += sprintf((char *) p, "\x1B%c", 'P' + keysym - PK_F1); + else + p += sprintf((char *) p, "\x1BO%c", 'P' + keysym - PK_F1); + goto done; + } + p += sprintf((char *) p, "\x1B[%d~", 11 + keysym - PK_F1); + goto done; + } + + if (PK_ISCURSOR(keysym)) { + int xkey; + + switch (keysym) { + case PK_UP: xkey = 'A'; break; + case PK_DOWN: xkey = 'B'; break; + case PK_RIGHT: xkey = 'C'; break; + case PK_LEFT: xkey = 'D'; break; + case PK_REST: xkey = 'G'; break; /* centre key on number pad */ + } + if (term->vt52_mode) + p += sprintf((char *) p, "\x1B%c", xkey); + else { + int app_flg = (term->app_cursor_keys && !term->cfg.no_applic_c); + + /* Useful mapping of Ctrl-arrows */ + if (modifiers == PKM_CONTROL) + app_flg = !app_flg; + + if (app_flg) + p += sprintf((char *) p, "\x1BO%c", xkey); + else + p += sprintf((char *) p, "\x1B[%c", xkey); + } + goto done; + } + + done: + if (p > output || tlen > 0) { + /* + * Interrupt an ongoing paste. I'm not sure + * this is sensible, but for the moment it's + * preferable to having to faff about buffering + * things. + */ + term_nopaste(term); + + /* + * We need not bother about stdin backlogs + * here, because in GUI PuTTY we can't do + * anything about it anyway; there's no means + * of asking Windows to hold off on KEYDOWN + * messages. We _have_ to buffer everything + * we're sent. + */ + term_seen_key_event(term); + + if (prependesc) { + fprintf(stderr, "sending ESC\n"); + ldisc_send(term->ldisc, "\x1b", 1, 1); + } + + if (p > output) { + fprintf(stderr, "sending %d bytes:", p - output); + for (i = 0; i < p - output; i++) + fprintf(stderr, " %02x", output[i]); + fprintf(stderr, "\n"); + + ldisc_send(term->ldisc, output, p - output, 1); + } else if (tlen > 0) { + fprintf(stderr, "sending %d unichars:", tlen); + for (i = 0; i < tlen; i++) + fprintf(stderr, " %04x", text[i]); + fprintf(stderr, "\n"); + + luni_send(term->ldisc, text, tlen, 1); + } + } +} + void term_nopaste(Terminal *term) { if (term->paste_len == 0)