1 /* $OpenBSD$ */
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 <string.h>
22 
23 #include "tmux.h"
24 
25 static key_code	key_string_search_table(const char *);
26 static key_code	key_string_get_modifiers(const char **);
27 
28 const struct {
29 	const char     *string;
30 	key_code	key;
31 } key_string_table[] = {
32 	/* Function keys. */
33 	{ "F1",		KEYC_F1 },
34 	{ "F2",		KEYC_F2 },
35 	{ "F3",		KEYC_F3 },
36 	{ "F4",		KEYC_F4 },
37 	{ "F5",		KEYC_F5 },
38 	{ "F6",		KEYC_F6 },
39 	{ "F7",		KEYC_F7 },
40 	{ "F8",		KEYC_F8 },
41 	{ "F9",		KEYC_F9 },
42 	{ "F10",	KEYC_F10 },
43 	{ "F11",	KEYC_F11 },
44 	{ "F12",	KEYC_F12 },
45 	{ "IC",		KEYC_IC },
46 	{ "DC",		KEYC_DC },
47 	{ "Home",	KEYC_HOME },
48 	{ "End",	KEYC_END },
49 	{ "NPage",	KEYC_NPAGE },
50 	{ "PageDown",	KEYC_NPAGE },
51 	{ "PgDn",	KEYC_NPAGE },
52 	{ "PPage",	KEYC_PPAGE },
53 	{ "PageUp",	KEYC_PPAGE },
54 	{ "PgUp",	KEYC_PPAGE },
55 	{ "Tab",	'\011' },
56 	{ "BTab",	KEYC_BTAB },
57 	{ "Space",	' ' },
58 	{ "BSpace",	KEYC_BSPACE },
59 	{ "Enter",	'\r' },
60 	{ "Escape",	'\033' },
61 
62 	/* Arrow keys. */
63 	{ "Up",		KEYC_UP },
64 	{ "Down",	KEYC_DOWN },
65 	{ "Left",	KEYC_LEFT },
66 	{ "Right",	KEYC_RIGHT },
67 
68 	/* Numeric keypad. */
69 	{ "KP/", 	KEYC_KP_SLASH },
70 	{ "KP*",	KEYC_KP_STAR },
71 	{ "KP-",	KEYC_KP_MINUS },
72 	{ "KP7",	KEYC_KP_SEVEN },
73 	{ "KP8",	KEYC_KP_EIGHT },
74 	{ "KP9",	KEYC_KP_NINE },
75 	{ "KP+",	KEYC_KP_PLUS },
76 	{ "KP4",	KEYC_KP_FOUR },
77 	{ "KP5",	KEYC_KP_FIVE },
78 	{ "KP6",	KEYC_KP_SIX },
79 	{ "KP1",	KEYC_KP_ONE },
80 	{ "KP2",	KEYC_KP_TWO },
81 	{ "KP3",	KEYC_KP_THREE },
82 	{ "KPEnter",	KEYC_KP_ENTER },
83 	{ "KP0",	KEYC_KP_ZERO },
84 	{ "KP.",	KEYC_KP_PERIOD },
85 
86 	/* Mouse keys. */
87 	KEYC_MOUSE_STRING(MOUSEDOWN1, MouseDown1),
88 	KEYC_MOUSE_STRING(MOUSEDOWN2, MouseDown2),
89 	KEYC_MOUSE_STRING(MOUSEDOWN3, MouseDown3),
90 	KEYC_MOUSE_STRING(MOUSEUP1, MouseUp1),
91 	KEYC_MOUSE_STRING(MOUSEUP2, MouseUp2),
92 	KEYC_MOUSE_STRING(MOUSEUP3, MouseUp3),
93 	KEYC_MOUSE_STRING(MOUSEDRAG1, MouseDrag1),
94 	KEYC_MOUSE_STRING(MOUSEDRAG2, MouseDrag2),
95 	KEYC_MOUSE_STRING(MOUSEDRAG3, MouseDrag3),
96 	KEYC_MOUSE_STRING(MOUSEDRAGEND1, MouseDragEnd1),
97 	KEYC_MOUSE_STRING(MOUSEDRAGEND2, MouseDragEnd2),
98 	KEYC_MOUSE_STRING(MOUSEDRAGEND3, MouseDragEnd3),
99 	KEYC_MOUSE_STRING(WHEELUP, WheelUp),
100 	KEYC_MOUSE_STRING(WHEELDOWN, WheelDown),
101 };
102 
103 /* Find key string in table. */
104 static key_code
key_string_search_table(const char * string)105 key_string_search_table(const char *string)
106 {
107 	u_int	i;
108 
109 	for (i = 0; i < nitems(key_string_table); i++) {
110 		if (strcasecmp(string, key_string_table[i].string) == 0)
111 			return (key_string_table[i].key);
112 	}
113 	return (KEYC_UNKNOWN);
114 }
115 
116 /* Find modifiers. */
117 static key_code
key_string_get_modifiers(const char ** string)118 key_string_get_modifiers(const char **string)
119 {
120 	key_code	modifiers;
121 
122 	modifiers = 0;
123 	while (((*string)[0] != '\0') && (*string)[1] == '-') {
124 		switch ((*string)[0]) {
125 		case 'C':
126 		case 'c':
127 			modifiers |= KEYC_CTRL;
128 			break;
129 		case 'M':
130 		case 'm':
131 			modifiers |= KEYC_ESCAPE;
132 			break;
133 		case 'S':
134 		case 's':
135 			modifiers |= KEYC_SHIFT;
136 			break;
137 		}
138 		*string += 2;
139 	}
140 	return (modifiers);
141 }
142 
143 /* Lookup a string and convert to a key value. */
144 key_code
key_string_lookup_string(const char * string)145 key_string_lookup_string(const char *string)
146 {
147 	static const char	*other = "!#()+,-.0123456789:;<=>?'\r\t";
148 	key_code		 key;
149 	u_int			 u;
150 	key_code		 modifiers;
151 	struct utf8_data	 ud;
152 	u_int			 i;
153 	enum utf8_state		 more;
154 	wchar_t			 wc;
155 
156 	/* Is this no key? */
157 	if (strcasecmp(string, "None") == 0)
158 		return (KEYC_NONE);
159 
160 	/* Is this a hexadecimal value? */
161 	if (string[0] == '0' && string[1] == 'x') {
162 	        if (sscanf(string + 2, "%x", &u) != 1)
163 	                return (KEYC_UNKNOWN);
164 		if (u > 0x1fffff)
165 	                return (KEYC_UNKNOWN);
166 	        return (u);
167 	}
168 
169 	/* Check for modifiers. */
170 	modifiers = 0;
171 	if (string[0] == '^' && string[1] != '\0') {
172 		modifiers |= KEYC_CTRL;
173 		string++;
174 	}
175 	modifiers |= key_string_get_modifiers(&string);
176 	if (string[0] == '\0')
177 		return (KEYC_UNKNOWN);
178 
179 	/* Is this a standard ASCII key? */
180 	if (string[1] == '\0' && (u_char)string[0] <= 127) {
181 		key = (u_char)string[0];
182 		if (key < 32 || key == 127)
183 			return (KEYC_UNKNOWN);
184 	} else {
185 		/* Try as a UTF-8 key. */
186 		if ((more = utf8_open(&ud, (u_char)*string)) == UTF8_MORE) {
187 			if (strlen(string) != ud.size)
188 				return (KEYC_UNKNOWN);
189 			for (i = 1; i < ud.size; i++)
190 				more = utf8_append(&ud, (u_char)string[i]);
191 			if (more != UTF8_DONE)
192 				return (KEYC_UNKNOWN);
193 			if (utf8_combine(&ud, &wc) != UTF8_DONE)
194 				return (KEYC_UNKNOWN);
195 			return (wc | modifiers);
196 		}
197 
198 		/* Otherwise look the key up in the table. */
199 		key = key_string_search_table(string);
200 		if (key == KEYC_UNKNOWN)
201 			return (KEYC_UNKNOWN);
202 	}
203 
204 	/* Convert the standard control keys. */
205 	if (key < KEYC_BASE && (modifiers & KEYC_CTRL) && !strchr(other, key)) {
206 		if (key >= 97 && key <= 122)
207 			key -= 96;
208 		else if (key >= 64 && key <= 95)
209 			key -= 64;
210 		else if (key == 32)
211 			key = 0;
212 		else if (key == 63)
213 			key = KEYC_BSPACE;
214 		else
215 			return (KEYC_UNKNOWN);
216 		modifiers &= ~KEYC_CTRL;
217 	}
218 
219 	return (key | modifiers);
220 }
221 
222 /* Convert a key code into string format, with prefix if necessary. */
223 const char *
key_string_lookup_key(key_code key)224 key_string_lookup_key(key_code key)
225 {
226 	static char		out[24];
227 	char			tmp[8];
228 	u_int			i;
229 	struct utf8_data	ud;
230 	size_t			off;
231 
232 	*out = '\0';
233 
234 	/* Handle no key. */
235 	if (key == KEYC_NONE)
236 		return ("None");
237 
238 	/* Handle special keys. */
239 	if (key == KEYC_UNKNOWN)
240 		return ("Unknown");
241 	if (key == KEYC_MOUSE)
242 		return ("Mouse");
243 
244 	/*
245 	 * Special case: display C-@ as C-Space. Could do this below in
246 	 * the (key >= 0 && key <= 32), but this way we let it be found
247 	 * in key_string_table, for the unlikely chance that we might
248 	 * change its name.
249 	 */
250 	if ((key & KEYC_MASK_KEY) == 0)
251 	    key = ' ' | KEYC_CTRL | (key & KEYC_MASK_MOD);
252 
253 	/* Fill in the modifiers. */
254 	if (key & KEYC_CTRL)
255 		strlcat(out, "C-", sizeof out);
256 	if (key & KEYC_ESCAPE)
257 		strlcat(out, "M-", sizeof out);
258 	if (key & KEYC_SHIFT)
259 		strlcat(out, "S-", sizeof out);
260 	key &= KEYC_MASK_KEY;
261 
262 	/* Try the key against the string table. */
263 	for (i = 0; i < nitems(key_string_table); i++) {
264 		if (key == key_string_table[i].key)
265 			break;
266 	}
267 	if (i != nitems(key_string_table)) {
268 		strlcat(out, key_string_table[i].string, sizeof out);
269 		return (out);
270 	}
271 
272 	/* Is this a UTF-8 key? */
273 	if (key > 127 && key < KEYC_BASE) {
274 		if (utf8_split(key, &ud) == UTF8_DONE) {
275 			off = strlen(out);
276 			memcpy(out + off, ud.data, ud.size);
277 			out[off + ud.size] = '\0';
278 			return (out);
279 		}
280 	}
281 
282 	/* Invalid keys are errors. */
283 	if (key == 127 || key > 255) {
284 		snprintf(out, sizeof out, "Invalid#%llx", key);
285 		return (out);
286 	}
287 
288 	/* Check for standard or control key. */
289 	if (key <= 32) {
290 		if (key == 0 || key > 26)
291 			xsnprintf(tmp, sizeof tmp, "C-%c", (int)(64 + key));
292 		else
293 			xsnprintf(tmp, sizeof tmp, "C-%c", (int)(96 + key));
294 	} else if (key >= 32 && key <= 126) {
295 		tmp[0] = key;
296 		tmp[1] = '\0';
297 	} else if (key >= 128)
298 		xsnprintf(tmp, sizeof tmp, "\\%llo", key);
299 
300 	strlcat(out, tmp, sizeof out);
301 	return (out);
302 }
303