-/* $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
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);
}
}
-#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;
- }
- }
-
- /*
- * 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 & 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;
+ return;
}
}
- /*
- * 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;
- }
+ if (event->modifiers & shiftKey)
+ mods |= PKM_SHIFT;
+ if (event->modifiers & controlKey)
+ mods |= PKM_CONTROL;
+ if (event->what == autoKey)
+ flags |= PKF_REPEAT;
+
+ /* 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;
}
- 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)
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;
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);
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 *);
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)