xref: /openbsd/usr.bin/tmux/input-keys.c (revision 097a140d) 
1 /* $OpenBSD: input-keys.c,v 1.83 2021/04/09 07:02:00 nicm Exp $ */
2 
3 /*
4  * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
5  *
6  * Permission to use, copy, modify, and distribute this software for any
7  * purpose with or without fee is hereby granted, provided that the above
8  * copyright notice and this permission notice appear in all copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17  */
18 
19 #include <sys/types.h>
20 
21 #include <stdint.h>
22 #include <stdlib.h>
23 #include <string.h>
24 
25 #include "tmux.h"
26 
27 /*
28  * This file is rather misleadingly named, it contains the code which takes a
29  * key code and translates it into something suitable to be sent to the
30  * application running in a pane (similar to input.c does in the other
31  * direction with output).
32  */
33 
34 static void	 input_key_mouse(struct window_pane *, struct mouse_event *);
35 
36 /* Entry in the key tree. */
37 struct input_key_entry {
38 	key_code			 key;
39 	const char			*data;
40 
41 	RB_ENTRY(input_key_entry)	 entry;
42 };
43 RB_HEAD(input_key_tree, input_key_entry);
44 
45 /* Tree of input keys. */
46 static int	input_key_cmp(struct input_key_entry *,
47 		    struct input_key_entry *);
48 RB_GENERATE_STATIC(input_key_tree, input_key_entry, entry, input_key_cmp);
49 struct input_key_tree input_key_tree = RB_INITIALIZER(&input_key_tree);
50 
51 /* List of default keys, the tree is built from this. */
52 static struct input_key_entry input_key_defaults[] = {
53 	/* Paste keys. */
54 	{ .key = KEYC_PASTE_START,
55 	  .data = "\033[200~"
56 	},
57 	{ .key = KEYC_PASTE_END,
58 	  .data = "\033[201~"
59 	},
60 
61 	/* Function keys. */
62 	{ .key = KEYC_F1,
63 	  .data = "\033OP"
64 	},
65 	{ .key = KEYC_F2,
66 	  .data = "\033OQ"
67 	},
68 	{ .key = KEYC_F3,
69 	  .data = "\033OR"
70 	},
71 	{ .key = KEYC_F4,
72 	  .data = "\033OS"
73 	},
74 	{ .key = KEYC_F5,
75 	  .data = "\033[15~"
76 	},
77 	{ .key = KEYC_F6,
78 	  .data = "\033[17~"
79 	},
80 	{ .key = KEYC_F7,
81 	  .data = "\033[18~"
82 	},
83 	{ .key = KEYC_F8,
84 	  .data = "\033[19~"
85 	},
86 	{ .key = KEYC_F9,
87 	  .data = "\033[20~"
88 	},
89 	{ .key = KEYC_F10,
90 	  .data = "\033[21~"
91 	},
92 	{ .key = KEYC_F11,
93 	  .data = "\033[23~"
94 	},
95 	{ .key = KEYC_F12,
96 	  .data = "\033[24~"
97 	},
98 	{ .key = KEYC_F1|KEYC_SHIFT,
99 	  .data = "\033[25~"
100 	},
101 	{ .key = KEYC_F2|KEYC_SHIFT,
102 	  .data = "\033[26~"
103 	},
104 	{ .key = KEYC_F3|KEYC_SHIFT,
105 	  .data = "\033[28~"
106 	},
107 	{ .key = KEYC_F4|KEYC_SHIFT,
108 	  .data = "\033[29~"
109 	},
110 	{ .key = KEYC_F5|KEYC_SHIFT,
111 	  .data = "\033[31~"
112 	},
113 	{ .key = KEYC_F6|KEYC_SHIFT,
114 	  .data = "\033[32~"
115 	},
116 	{ .key = KEYC_F7|KEYC_SHIFT,
117 	  .data = "\033[33~"
118 	},
119 	{ .key = KEYC_F8|KEYC_SHIFT,
120 	  .data = "\033[34~"
121 	},
122 	{ .key = KEYC_IC,
123 	  .data = "\033[2~"
124 	},
125 	{ .key = KEYC_DC,
126 	  .data = "\033[3~"
127 	},
128 	{ .key = KEYC_HOME,
129 	  .data = "\033[1~"
130 	},
131 	{ .key = KEYC_END,
132 	  .data = "\033[4~"
133 	},
134 	{ .key = KEYC_NPAGE,
135 	  .data = "\033[6~"
136 	},
137 	{ .key = KEYC_PPAGE,
138 	  .data = "\033[5~"
139 	},
140 	{ .key = KEYC_BTAB,
141 	  .data = "\033[Z"
142 	},
143 
144 	/* Arrow keys. */
145 	{ .key = KEYC_UP|KEYC_CURSOR,
146 	  .data = "\033OA"
147 	},
148 	{ .key = KEYC_DOWN|KEYC_CURSOR,
149 	  .data = "\033OB"
150 	},
151 	{ .key = KEYC_RIGHT|KEYC_CURSOR,
152 	  .data = "\033OC"
153 	},
154 	{ .key = KEYC_LEFT|KEYC_CURSOR,
155 	  .data = "\033OD"
156 	},
157 	{ .key = KEYC_UP,
158 	  .data = "\033[A"
159 	},
160 	{ .key = KEYC_DOWN,
161 	  .data = "\033[B"
162 	},
163 	{ .key = KEYC_RIGHT,
164 	  .data = "\033[C"
165 	},
166 	{ .key = KEYC_LEFT,
167 	  .data = "\033[D"
168 	},
169 
170 	/* Keypad keys. */
171 	{ .key = KEYC_KP_SLASH|KEYC_KEYPAD,
172 	  .data = "\033Oo"
173 	},
174 	{ .key = KEYC_KP_STAR|KEYC_KEYPAD,
175 	  .data = "\033Oj"
176 	},
177 	{ .key = KEYC_KP_MINUS|KEYC_KEYPAD,
178 	  .data = "\033Om"
179 	},
180 	{ .key = KEYC_KP_SEVEN|KEYC_KEYPAD,
181 	  .data = "\033Ow"
182 	},
183 	{ .key = KEYC_KP_EIGHT|KEYC_KEYPAD,
184 	  .data = "\033Ox"
185 	},
186 	{ .key = KEYC_KP_NINE|KEYC_KEYPAD,
187 	  .data = "\033Oy"
188 	},
189 	{ .key = KEYC_KP_PLUS|KEYC_KEYPAD,
190 	  .data = "\033Ok"
191 	},
192 	{ .key = KEYC_KP_FOUR|KEYC_KEYPAD,
193 	  .data = "\033Ot"
194 	},
195 	{ .key = KEYC_KP_FIVE|KEYC_KEYPAD,
196 	  .data = "\033Ou"
197 	},
198 	{ .key = KEYC_KP_SIX|KEYC_KEYPAD,
199 	  .data = "\033Ov"
200 	},
201 	{ .key = KEYC_KP_ONE|KEYC_KEYPAD,
202 	  .data = "\033Oq"
203 	},
204 	{ .key = KEYC_KP_TWO|KEYC_KEYPAD,
205 	  .data = "\033Or"
206 	},
207 	{ .key = KEYC_KP_THREE|KEYC_KEYPAD,
208 	  .data = "\033Os"
209 	},
210 	{ .key = KEYC_KP_ENTER|KEYC_KEYPAD,
211 	  .data = "\033OM"
212 	},
213 	{ .key = KEYC_KP_ZERO|KEYC_KEYPAD,
214 	  .data = "\033Op"
215 	},
216 	{ .key = KEYC_KP_PERIOD|KEYC_KEYPAD,
217 	  .data = "\033On"
218 	},
219 	{ .key = KEYC_KP_SLASH,
220 	  .data = "/"
221 	},
222 	{ .key = KEYC_KP_STAR,
223 	  .data = "*"
224 	},
225 	{ .key = KEYC_KP_MINUS,
226 	  .data = "-"
227 	},
228 	{ .key = KEYC_KP_SEVEN,
229 	  .data = "7"
230 	},
231 	{ .key = KEYC_KP_EIGHT,
232 	  .data = "8"
233 	},
234 	{ .key = KEYC_KP_NINE,
235 	  .data = "9"
236 	},
237 	{ .key = KEYC_KP_PLUS,
238 	  .data = "+"
239 	},
240 	{ .key = KEYC_KP_FOUR,
241 	  .data = "4"
242 	},
243 	{ .key = KEYC_KP_FIVE,
244 	  .data = "5"
245 	},
246 	{ .key = KEYC_KP_SIX,
247 	  .data = "6"
248 	},
249 	{ .key = KEYC_KP_ONE,
250 	  .data = "1"
251 	},
252 	{ .key = KEYC_KP_TWO,
253 	  .data = "2"
254 	},
255 	{ .key = KEYC_KP_THREE,
256 	  .data = "3"
257 	},
258 	{ .key = KEYC_KP_ENTER,
259 	  .data = "\n"
260 	},
261 	{ .key = KEYC_KP_ZERO,
262 	  .data = "0"
263 	},
264 	{ .key = KEYC_KP_PERIOD,
265 	  .data = "."
266 	},
267 
268 	/* Keys with an embedded modifier. */
269 	{ .key = KEYC_F1|KEYC_BUILD_MODIFIERS,
270 	  .data = "\033[1;_P"
271 	},
272 	{ .key = KEYC_F2|KEYC_BUILD_MODIFIERS,
273 	  .data = "\033[1;_Q"
274 	},
275 	{ .key = KEYC_F3|KEYC_BUILD_MODIFIERS,
276 	  .data = "\033[1;_R"
277 	},
278 	{ .key = KEYC_F4|KEYC_BUILD_MODIFIERS,
279 	  .data = "\033[1;_S"
280 	},
281 	{ .key = KEYC_F5|KEYC_BUILD_MODIFIERS,
282 	  .data = "\033[15;_~"
283 	},
284 	{ .key = KEYC_F6|KEYC_BUILD_MODIFIERS,
285 	  .data = "\033[17;_~"
286 	},
287 	{ .key = KEYC_F7|KEYC_BUILD_MODIFIERS,
288 	  .data = "\033[18;_~"
289 	},
290 	{ .key = KEYC_F8|KEYC_BUILD_MODIFIERS,
291 	  .data = "\033[19;_~"
292 	},
293 	{ .key = KEYC_F9|KEYC_BUILD_MODIFIERS,
294 	  .data = "\033[20;_~"
295 	},
296 	{ .key = KEYC_F10|KEYC_BUILD_MODIFIERS,
297 	  .data = "\033[21;_~"
298 	},
299 	{ .key = KEYC_F11|KEYC_BUILD_MODIFIERS,
300 	  .data = "\033[23;_~"
301 	},
302 	{ .key = KEYC_F12|KEYC_BUILD_MODIFIERS,
303 	  .data = "\033[24;_~"
304 	},
305 	{ .key = KEYC_UP|KEYC_BUILD_MODIFIERS,
306 	  .data = "\033[1;_A"
307 	},
308 	{ .key = KEYC_DOWN|KEYC_BUILD_MODIFIERS,
309 	  .data = "\033[1;_B"
310 	},
311 	{ .key = KEYC_RIGHT|KEYC_BUILD_MODIFIERS,
312 	  .data = "\033[1;_C"
313 	},
314 	{ .key = KEYC_LEFT|KEYC_BUILD_MODIFIERS,
315 	  .data = "\033[1;_D"
316 	},
317 	{ .key = KEYC_HOME|KEYC_BUILD_MODIFIERS,
318 	  .data = "\033[1;_H"
319 	},
320 	{ .key = KEYC_END|KEYC_BUILD_MODIFIERS,
321 	  .data = "\033[1;_F"
322 	},
323 	{ .key = KEYC_PPAGE|KEYC_BUILD_MODIFIERS,
324 	  .data = "\033[5;_~"
325 	},
326 	{ .key = KEYC_NPAGE|KEYC_BUILD_MODIFIERS,
327 	  .data = "\033[6;_~"
328 	},
329 	{ .key = KEYC_IC|KEYC_BUILD_MODIFIERS,
330 	  .data = "\033[2;_~"
331 	},
332 	{ .key = KEYC_DC|KEYC_BUILD_MODIFIERS,
333 	  .data = "\033[3;_~"
334 	}
335 };
336 static const key_code input_key_modifiers[] = {
337 	0,
338 	0,
339 	KEYC_SHIFT,
340 	KEYC_META|KEYC_IMPLIED_META,
341 	KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META,
342 	KEYC_CTRL,
343 	KEYC_SHIFT|KEYC_CTRL,
344 	KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL,
345 	KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL
346 };
347 
348 /* Input key comparison function. */
349 static int
350 input_key_cmp(struct input_key_entry *ike1, struct input_key_entry *ike2)
351 {
352 	if (ike1->key < ike2->key)
353 		return (-1);
354 	if (ike1->key > ike2->key)
355 		return (1);
356 	return (0);
357 }
358 
359 /* Look for key in tree. */
360 static struct input_key_entry *
361 input_key_get (key_code key)
362 {
363 	struct input_key_entry	entry = { .key = key };
364 
365 	return (RB_FIND(input_key_tree, &input_key_tree, &entry));
366 }
367 
368 /* Split a character into two UTF-8 bytes. */
369 static size_t
370 input_key_split2(u_int c, u_char *dst)
371 {
372 	if (c > 0x7f) {
373 		dst[0] = (c >> 6) | 0xc0;
374 		dst[1] = (c & 0x3f) | 0x80;
375 		return (2);
376 	}
377 	dst[0] = c;
378 	return (1);
379 }
380 
381 /* Build input key tree. */
382 void
383 input_key_build(void)
384 {
385 	struct input_key_entry	*ike, *new;
386 	u_int			 i, j;
387 	char			*data;
388 	key_code		 key;
389 
390 	for (i = 0; i < nitems(input_key_defaults); i++) {
391 		ike = &input_key_defaults[i];
392 		if (~ike->key & KEYC_BUILD_MODIFIERS) {
393 			RB_INSERT(input_key_tree, &input_key_tree, ike);
394 			continue;
395 		}
396 
397 		for (j = 2; j < nitems(input_key_modifiers); j++) {
398 			key = (ike->key & ~KEYC_BUILD_MODIFIERS);
399 			data = xstrdup(ike->data);
400 			data[strcspn(data, "_")] = '0' + j;
401 
402 			new = xcalloc(1, sizeof *new);
403 			new->key = key|input_key_modifiers[j];
404 			new->data = data;
405 			RB_INSERT(input_key_tree, &input_key_tree, new);
406 		}
407 	}
408 
409 	RB_FOREACH(ike, input_key_tree, &input_key_tree) {
410 		log_debug("%s: 0x%llx (%s) is %s", __func__, ike->key,
411 		    key_string_lookup_key(ike->key, 1), ike->data);
412 	}
413 }
414 
415 /* Translate a key code into an output key sequence for a pane. */
416 int
417 input_key_pane(struct window_pane *wp, key_code key, struct mouse_event *m)
418 {
419 	if (log_get_level() != 0) {
420 		log_debug("writing key 0x%llx (%s) to %%%u", key,
421 		    key_string_lookup_key(key, 1), wp->id);
422 	}
423 
424 	if (KEYC_IS_MOUSE(key)) {
425 		if (m != NULL && m->wp != -1 && (u_int)m->wp == wp->id)
426 			input_key_mouse(wp, m);
427 		return (0);
428 	}
429 	return (input_key(wp->screen, wp->event, key));
430 }
431 
432 static void
433 input_key_write(const char *from, struct bufferevent *bev, const char *data,
434     size_t size)
435 {
436 	log_debug("%s: %.*s", from, (int)size, data);
437 	bufferevent_write(bev, data, size);
438 }
439 
440 /* Translate a key code into an output key sequence. */
441 int
442 input_key(struct screen *s, struct bufferevent *bev, key_code key)
443 {
444 	struct input_key_entry	*ike;
445 	key_code		 justkey, newkey, outkey;
446 	struct utf8_data	 ud;
447 	char			 tmp[64], modifier;
448 
449 	/* Mouse keys need a pane. */
450 	if (KEYC_IS_MOUSE(key))
451 		return (0);
452 
453 	/* Literal keys go as themselves (can't be more than eight bits). */
454 	if (key & KEYC_LITERAL) {
455 		ud.data[0] = (u_char)key;
456 		input_key_write(__func__, bev, &ud.data[0], 1);
457 		return (0);
458 	}
459 
460 	/* Is this backspace? */
461 	if ((key & KEYC_MASK_KEY) == KEYC_BSPACE) {
462 		newkey = options_get_number(global_options, "backspace");
463 		if (newkey >= 0x7f)
464 			newkey = '\177';
465 		key = newkey|(key & (KEYC_MASK_MODIFIERS|KEYC_MASK_FLAGS));
466 	}
467 
468 	/*
469 	 * If this is a normal 7-bit key, just send it, with a leading escape
470 	 * if necessary. If it is a UTF-8 key, split it and send it.
471 	 */
472 	justkey = (key & ~(KEYC_META|KEYC_IMPLIED_META));
473 	if (justkey <= 0x7f) {
474 		if (key & KEYC_META)
475 			input_key_write(__func__, bev, "\033", 1);
476 		ud.data[0] = justkey;
477 		input_key_write(__func__, bev, &ud.data[0], 1);
478 		return (0);
479 	}
480 	if (justkey > 0x7f && justkey < KEYC_BASE) {
481 		if (key & KEYC_META)
482 			input_key_write(__func__, bev, "\033", 1);
483 		utf8_to_data(justkey, &ud);
484 		input_key_write(__func__, bev, ud.data, ud.size);
485 		return (0);
486 	}
487 
488 	/*
489 	 * Look up in the tree. If not in application keypad or cursor mode,
490 	 * remove the flags from the key.
491 	 */
492 	if (~s->mode & MODE_KKEYPAD)
493 		key &= ~KEYC_KEYPAD;
494 	if (~s->mode & MODE_KCURSOR)
495 		key &= ~KEYC_CURSOR;
496 	ike = input_key_get(key);
497 	if (ike == NULL && (key & KEYC_META) && (~key & KEYC_IMPLIED_META))
498 		ike = input_key_get(key & ~KEYC_META);
499 	if (ike == NULL && (key & KEYC_CURSOR))
500 		ike = input_key_get(key & ~KEYC_CURSOR);
501 	if (ike == NULL && (key & KEYC_KEYPAD))
502 		ike = input_key_get(key & ~KEYC_KEYPAD);
503 	if (ike != NULL) {
504 		log_debug("found key 0x%llx: \"%s\"", key, ike->data);
505 		if ((key & KEYC_META) && (~key & KEYC_IMPLIED_META))
506 			input_key_write(__func__, bev, "\033", 1);
507 		input_key_write(__func__, bev, ike->data, strlen(ike->data));
508 		return (0);
509 	}
510 
511 	/* No builtin key sequence; construct an extended key sequence. */
512 	if (~s->mode & MODE_KEXTENDED) {
513 		if ((key & KEYC_MASK_MODIFIERS) != KEYC_CTRL)
514 			goto missing;
515 		justkey = (key & KEYC_MASK_KEY);
516 		switch (justkey) {
517 		case ' ':
518 		case '2':
519 			key = 0|(key & ~KEYC_MASK_KEY);
520 			break;
521 		case '|':
522 			key = 28|(key & ~KEYC_MASK_KEY);
523 			break;
524 		case '6':
525 			key = 30|(key & ~KEYC_MASK_KEY);
526 			break;
527 		case '-':
528 		case '/':
529 			key = 31|(key & ~KEYC_MASK_KEY);
530 			break;
531 		case '?':
532 			key = 127|(key & ~KEYC_MASK_KEY);
533 			break;
534 		default:
535 			if (justkey >= 'A' && justkey <= '_')
536 				key = (justkey - 'A')|(key & ~KEYC_MASK_KEY);
537 			else if (justkey >= 'a' && justkey <= '~')
538 				key = (justkey - 96)|(key & ~KEYC_MASK_KEY);
539 			else
540 				return (0);
541 			break;
542 		}
543 		return (input_key(s, bev, key & ~KEYC_CTRL));
544 	}
545 	outkey = (key & KEYC_MASK_KEY);
546 	switch (key & KEYC_MASK_MODIFIERS) {
547 	case KEYC_SHIFT:
548 		modifier = '2';
549 		break;
550 	case KEYC_META:
551 		modifier = '3';
552 		break;
553 	case KEYC_SHIFT|KEYC_META:
554 		modifier = '4';
555 		break;
556 	case KEYC_CTRL:
557 		modifier = '5';
558 		break;
559 	case KEYC_SHIFT|KEYC_CTRL:
560 		modifier = '6';
561 		break;
562 	case KEYC_META|KEYC_CTRL:
563 		modifier = '7';
564 		break;
565 	case KEYC_SHIFT|KEYC_META|KEYC_CTRL:
566 		modifier = '8';
567 		break;
568 	default:
569 		goto missing;
570 	}
571 	xsnprintf(tmp, sizeof tmp, "\033[%llu;%cu", outkey, modifier);
572 	input_key_write(__func__, bev, tmp, strlen(tmp));
573 	return (0);
574 
575 missing:
576 	log_debug("key 0x%llx missing", key);
577 	return (-1);
578 }
579 
580 /* Get mouse event string. */
581 int
582 input_key_get_mouse(struct screen *s, struct mouse_event *m, u_int x, u_int y,
583     const char **rbuf, size_t *rlen)
584 {
585 	static char	 buf[40];
586 	size_t		 len;
587 
588 	*rbuf = NULL;
589 	*rlen = 0;
590 
591 	/* If this pane is not in button or all mode, discard motion events. */
592 	if (MOUSE_DRAG(m->b) && (s->mode & MOTION_MOUSE_MODES) == 0)
593 		return (0);
594 	if ((s->mode & ALL_MOUSE_MODES) == 0)
595 		return (0);
596 
597 	/*
598 	 * If this event is a release event and not in all mode, discard it.
599 	 * In SGR mode we can tell absolutely because a release is normally
600 	 * shown by the last character. Without SGR, we check if the last
601 	 * buttons was also a release.
602 	 */
603 	if (m->sgr_type != ' ') {
604 		if (MOUSE_DRAG(m->sgr_b) &&
605 		    MOUSE_BUTTONS(m->sgr_b) == 3 &&
606 		    (~s->mode & MODE_MOUSE_ALL))
607 			return (0);
608 	} else {
609 		if (MOUSE_DRAG(m->b) &&
610 		    MOUSE_BUTTONS(m->b) == 3 &&
611 		    MOUSE_BUTTONS(m->lb) == 3 &&
612 		    (~s->mode & MODE_MOUSE_ALL))
613 			return (0);
614 	}
615 
616 	/*
617 	 * Use the SGR (1006) extension only if the application requested it
618 	 * and the underlying terminal also sent the event in this format (this
619 	 * is because an old style mouse release event cannot be converted into
620 	 * the new SGR format, since the released button is unknown). Otherwise
621 	 * pretend that tmux doesn't speak this extension, and fall back to the
622 	 * UTF-8 (1005) extension if the application requested, or to the
623 	 * legacy format.
624 	 */
625 	if (m->sgr_type != ' ' && (s->mode & MODE_MOUSE_SGR)) {
626 		len = xsnprintf(buf, sizeof buf, "\033[<%u;%u;%u%c",
627 		    m->sgr_b, x + 1, y + 1, m->sgr_type);
628 	} else if (s->mode & MODE_MOUSE_UTF8) {
629 		if (m->b > 0x7ff - 32 || x > 0x7ff - 33 || y > 0x7ff - 33)
630 			return (0);
631 		len = xsnprintf(buf, sizeof buf, "\033[M");
632 		len += input_key_split2(m->b + 32, &buf[len]);
633 		len += input_key_split2(x + 33, &buf[len]);
634 		len += input_key_split2(y + 33, &buf[len]);
635 	} else {
636 		if (m->b > 223)
637 			return (0);
638 		len = xsnprintf(buf, sizeof buf, "\033[M");
639 		buf[len++] = m->b + 32;
640 		buf[len++] = x + 33;
641 		buf[len++] = y + 33;
642 	}
643 
644 	*rbuf = buf;
645 	*rlen = len;
646 	return (1);
647 }
648 
649 /* Translate mouse and output. */
650 static void
651 input_key_mouse(struct window_pane *wp, struct mouse_event *m)
652 {
653 	struct screen	*s = wp->screen;
654 	u_int		 x, y;
655 	const char	*buf;
656 	size_t		 len;
657 
658 	/* Ignore events if no mouse mode or the pane is not visible. */
659 	if (m->ignore || (s->mode & ALL_MOUSE_MODES) == 0)
660 		return;
661 	if (cmd_mouse_at(wp, m, &x, &y, 0) != 0)
662 		return;
663 	if (!window_pane_visible(wp))
664 		return;
665 	if (!input_key_get_mouse(s, m, x, y, &buf, &len))
666 		return;
667 	log_debug("writing mouse %.*s to %%%u", (int)len, buf, wp->id);
668 	input_key_write(__func__, wp->event, buf, len);
669 }
670