Annotation of src/usr.bin/vim/tables.c, Revision 1.1.1.1
1.1 downsj 1: /* $OpenBSD$ */
2: /* vi:set ts=4 sw=4:
3: *
4: * VIM - Vi IMproved by Bram Moolenaar
5: * This file by Robert Webb
6: *
7: * Do ":help uganda" in Vim to read copying and usage conditions.
8: * Do ":help credits" in Vim to see a list of people who contributed.
9: */
10:
11: /*
12: * tables.c: functions that use lookup tables for various things, generally to
13: * do with special key codes.
14: */
15:
16: #include "vim.h"
17: #include "globals.h"
18: #include "proto.h"
19: #include "option.h"
20:
21: /*
22: * Some useful tables.
23: */
24:
25: static struct
26: {
27: int mod_mask; /* Bit-mask for particular key modifier */
28: char_u name; /* Single letter name of modifier */
29: } mod_mask_table[] =
30: {
31: {MOD_MASK_ALT, (char_u)'M'},
32: {MOD_MASK_CTRL, (char_u)'C'},
33: {MOD_MASK_SHIFT, (char_u)'S'},
34: {MOD_MASK_2CLICK, (char_u)'2'},
35: {MOD_MASK_3CLICK, (char_u)'3'},
36: {MOD_MASK_4CLICK, (char_u)'4'},
37: {0x0, NUL}
38: };
39:
40: /*
41: * Shifted key terminal codes and their unshifted equivalent.
42: * Don't add mouse codes here, they are handled seperately!
43: */
44: static char_u shifted_keys_table[] =
45: {
46: /* shifted unshifted */
47: '&', '9', '@', '1', /* begin */
48: '&', '0', '@', '2', /* cancel */
49: '*', '1', '@', '4', /* command */
50: '*', '2', '@', '5', /* copy */
51: '*', '3', '@', '6', /* create */
52: '*', '4', 'k', 'D', /* delete char */
53: '*', '5', 'k', 'L', /* delete line */
54: '*', '7', '@', '7', /* end */
55: '*', '9', '@', '9', /* exit */
56: '*', '0', '@', '0', /* find */
57: '#', '1', '%', '1', /* help */
58: '#', '2', 'k', 'h', /* home */
59: '#', '3', 'k', 'I', /* insert */
60: '#', '4', 'k', 'l', /* left arrow */
61: '%', 'a', '%', '3', /* message */
62: '%', 'b', '%', '4', /* move */
63: '%', 'c', '%', '5', /* next */
64: '%', 'd', '%', '7', /* options */
65: '%', 'e', '%', '8', /* previous */
66: '%', 'f', '%', '9', /* print */
67: '%', 'g', '%', '0', /* redo */
68: '%', 'h', '&', '3', /* replace */
69: '%', 'i', 'k', 'r', /* right arrow */
70: '%', 'j', '&', '5', /* resume */
71: '!', '1', '&', '6', /* save */
72: '!', '2', '&', '7', /* suspend */
73: '!', '3', '&', '8', /* undo */
74: KS_EXTRA, KE_S_UP, 'k', 'u', /* up arrow */
75: KS_EXTRA, KE_S_DOWN, 'k', 'd', /* down arrow */
76:
77: KS_EXTRA, KE_S_F1, 'k', '1', /* F1 */
78: KS_EXTRA, KE_S_F2, 'k', '2',
79: KS_EXTRA, KE_S_F3, 'k', '3',
80: KS_EXTRA, KE_S_F4, 'k', '4',
81: KS_EXTRA, KE_S_F5, 'k', '5',
82: KS_EXTRA, KE_S_F6, 'k', '6',
83: KS_EXTRA, KE_S_F7, 'k', '7',
84: KS_EXTRA, KE_S_F8, 'k', '8',
85: KS_EXTRA, KE_S_F9, 'k', '9',
86: KS_EXTRA, KE_S_F10, 'k', ';', /* F10 */
87:
88: KS_EXTRA, KE_S_F11, 'F', '1',
89: KS_EXTRA, KE_S_F12, 'F', '2',
90: KS_EXTRA, KE_S_F13, 'F', '3',
91: KS_EXTRA, KE_S_F14, 'F', '4',
92: KS_EXTRA, KE_S_F15, 'F', '5',
93: KS_EXTRA, KE_S_F16, 'F', '6',
94: KS_EXTRA, KE_S_F17, 'F', '7',
95: KS_EXTRA, KE_S_F18, 'F', '8',
96: KS_EXTRA, KE_S_F19, 'F', '9',
97: KS_EXTRA, KE_S_F20, 'F', 'A',
98:
99: KS_EXTRA, KE_S_F21, 'F', 'B',
100: KS_EXTRA, KE_S_F22, 'F', 'C',
101: KS_EXTRA, KE_S_F23, 'F', 'D',
102: KS_EXTRA, KE_S_F24, 'F', 'E',
103: KS_EXTRA, KE_S_F25, 'F', 'F',
104: KS_EXTRA, KE_S_F26, 'F', 'G',
105: KS_EXTRA, KE_S_F27, 'F', 'H',
106: KS_EXTRA, KE_S_F28, 'F', 'I',
107: KS_EXTRA, KE_S_F29, 'F', 'J',
108: KS_EXTRA, KE_S_F30, 'F', 'K',
109:
110: KS_EXTRA, KE_S_F31, 'F', 'L',
111: KS_EXTRA, KE_S_F32, 'F', 'M',
112: KS_EXTRA, KE_S_F33, 'F', 'N',
113: KS_EXTRA, KE_S_F34, 'F', 'O',
114: KS_EXTRA, KE_S_F35, 'F', 'P',
115:
116: KS_EXTRA, KE_S_TAB, KS_EXTRA, KE_TAB, /* TAB */
117: NUL
118: };
119:
120: static struct key_name_entry
121: {
122: int key; /* Special key code or ascii value */
123: char_u *name; /* Name of key */
124: } key_names_table[] =
125: {
126: {' ', (char_u *)"Space"},
127: {TAB, (char_u *)"Tab"},
128: {K_TAB, (char_u *)"Tab"},
129: {NL, (char_u *)"NL"},
130: {NL, (char_u *)"NewLine"}, /* Alternative name */
131: {NL, (char_u *)"LineFeed"}, /* Alternative name */
132: {NL, (char_u *)"LF"}, /* Alternative name */
133: {CR, (char_u *)"CR"},
134: {CR, (char_u *)"Return"}, /* Alternative name */
135: {ESC, (char_u *)"Esc"},
136: {K_UP, (char_u *)"Up"},
137: {K_DOWN, (char_u *)"Down"},
138: {K_LEFT, (char_u *)"Left"},
139: {K_RIGHT, (char_u *)"Right"},
140:
141: {K_F1, (char_u *)"F1"},
142: {K_F2, (char_u *)"F2"},
143: {K_F3, (char_u *)"F3"},
144: {K_F4, (char_u *)"F4"},
145: {K_F5, (char_u *)"F5"},
146: {K_F6, (char_u *)"F6"},
147: {K_F7, (char_u *)"F7"},
148: {K_F8, (char_u *)"F8"},
149: {K_F9, (char_u *)"F9"},
150: {K_F10, (char_u *)"F10"},
151:
152: {K_F11, (char_u *)"F11"},
153: {K_F12, (char_u *)"F12"},
154: {K_F13, (char_u *)"F13"},
155: {K_F14, (char_u *)"F14"},
156: {K_F15, (char_u *)"F15"},
157: {K_F16, (char_u *)"F16"},
158: {K_F17, (char_u *)"F17"},
159: {K_F18, (char_u *)"F18"},
160: {K_F19, (char_u *)"F19"},
161: {K_F20, (char_u *)"F20"},
162:
163: {K_F21, (char_u *)"F21"},
164: {K_F22, (char_u *)"F22"},
165: {K_F23, (char_u *)"F23"},
166: {K_F24, (char_u *)"F24"},
167: {K_F25, (char_u *)"F25"},
168: {K_F26, (char_u *)"F26"},
169: {K_F27, (char_u *)"F27"},
170: {K_F28, (char_u *)"F28"},
171: {K_F29, (char_u *)"F29"},
172: {K_F30, (char_u *)"F30"},
173:
174: {K_F31, (char_u *)"F31"},
175: {K_F32, (char_u *)"F32"},
176: {K_F33, (char_u *)"F33"},
177: {K_F34, (char_u *)"F34"},
178: {K_F35, (char_u *)"F35"},
179:
180: {K_HELP, (char_u *)"Help"},
181: {K_UNDO, (char_u *)"Undo"},
182: {K_BS, (char_u *)"BS"},
183: {K_BS, (char_u *)"BackSpace"}, /* Alternative name */
184: {K_INS, (char_u *)"Insert"},
185: {K_INS, (char_u *)"Ins"}, /* Alternative name */
186: {K_DEL, (char_u *)"Del"},
187: {K_DEL, (char_u *)"Delete"}, /* Alternative name */
188: {K_HOME, (char_u *)"Home"},
189: {K_END, (char_u *)"End"},
190: {K_PAGEUP, (char_u *)"PageUp"},
191: {K_PAGEDOWN, (char_u *)"PageDown"},
192: {K_MOUSE, (char_u *)"Mouse"},
193: {K_LEFTMOUSE, (char_u *)"LeftMouse"},
194: {K_LEFTDRAG, (char_u *)"LeftDrag"},
195: {K_LEFTRELEASE, (char_u *)"LeftRelease"},
196: {K_MIDDLEMOUSE, (char_u *)"MiddleMouse"},
197: {K_MIDDLEDRAG, (char_u *)"MiddleDrag"},
198: {K_MIDDLERELEASE, (char_u *)"MiddleRelease"},
199: {K_RIGHTMOUSE, (char_u *)"RightMouse"},
200: {K_RIGHTDRAG, (char_u *)"RightDrag"},
201: {K_RIGHTRELEASE, (char_u *)"RightRelease"},
202: {K_ZERO, (char_u *)"Nul"},
203: {0, NULL}
204: };
205:
206: #define KEY_NAMES_TABLE_LEN (sizeof(key_names_table) / sizeof(struct key_name_entry))
207:
208: #ifdef USE_MOUSE
209: static struct
210: {
211: int pseudo_code; /* Code for pseudo mouse event */
212: int button; /* Which mouse button is it? */
213: int is_click; /* Is it a mouse button click event? */
214: int is_drag; /* Is it a mouse drag event? */
215: } mouse_table[] =
216: {
217: {KE_LEFTMOUSE, MOUSE_LEFT, TRUE, FALSE},
218: {KE_LEFTDRAG, MOUSE_LEFT, FALSE, TRUE},
219: {KE_LEFTRELEASE, MOUSE_LEFT, FALSE, FALSE},
220: {KE_MIDDLEMOUSE, MOUSE_MIDDLE, TRUE, FALSE},
221: {KE_MIDDLEDRAG, MOUSE_MIDDLE, FALSE, TRUE},
222: {KE_MIDDLERELEASE, MOUSE_MIDDLE, FALSE, FALSE},
223: {KE_RIGHTMOUSE, MOUSE_RIGHT, TRUE, FALSE},
224: {KE_RIGHTDRAG, MOUSE_RIGHT, FALSE, TRUE},
225: {KE_RIGHTRELEASE, MOUSE_RIGHT, FALSE, FALSE},
226: {KE_IGNORE, MOUSE_RELEASE, FALSE, TRUE}, /* DRAG without CLICK */
227: {KE_IGNORE, MOUSE_RELEASE, FALSE, FALSE}, /* RELEASE without CLICK */
228: {0, 0, 0, 0},
229: };
230: #endif /* USE_MOUSE */
231:
232: /*
233: * Return the modifier mask bit (MOD_MASK_*) which corresponds to the given
234: * modifier name ('S' for Shift, 'C' for Ctrl etc).
235: */
236: int
237: name_to_mod_mask(c)
238: int c;
239: {
240: int i;
241:
242: for (i = 0; mod_mask_table[i].mod_mask; i++)
243: if (TO_LOWER(c) == TO_LOWER(mod_mask_table[i].name))
244: return mod_mask_table[i].mod_mask;
245: return 0x0;
246: }
247:
248: /*
249: * Decide whether the given key code (K_*) is a shifted special
250: * key (by looking at mod_mask). If it is, then return the appropriate shifted
251: * key code, otherwise just return the character as is.
252: */
253: int
254: check_shifted_spec_key(c)
255: int c;
256: {
257: int i;
258: int key0;
259: int key1;
260:
261: if (mod_mask & MOD_MASK_SHIFT)
262: {
263: if (c == TAB) /* TAB is not in the table, K_TAB is */
264: return K_S_TAB;
265: key0 = KEY2TERMCAP0(c);
266: key1 = KEY2TERMCAP1(c);
267: for (i = 0; shifted_keys_table[i] != NUL; i += 4)
268: if (key0 == shifted_keys_table[i + 2] &&
269: key1 == shifted_keys_table[i + 3])
270: return TERMCAP2KEY(shifted_keys_table[i],
271: shifted_keys_table[i + 1]);
272: }
273: return c;
274: }
275:
276: /*
277: * Decide whether the given special key is shifted or not. If it is we
278: * return OK and change it to the equivalent unshifted special key code,
279: * otherwise we leave it as is and return FAIL.
280: */
281: int
282: unshift_special_key(p)
283: char_u *p;
284: {
285: int i;
286:
287: for (i = 0; shifted_keys_table[i]; i += 4)
288: if (p[0] == shifted_keys_table[i] && p[1] == shifted_keys_table[i + 1])
289: {
290: p[0] = shifted_keys_table[i + 2];
291: p[1] = shifted_keys_table[i + 3];
292: return OK;
293: }
294: return FAIL;
295: }
296:
297: /*
298: * Return a string which contains the name of the given key when the given
299: * modifiers are down.
300: */
301: char_u *
302: get_special_key_name(c, modifiers)
303: int c;
304: int modifiers;
305: {
306: static char_u string[MAX_KEY_NAME_LEN + 1];
307:
308: int i, idx;
309: char_u *s;
310: char_u name[2];
311:
312: string[0] = '<';
313: idx = 1;
314:
315: /* translate shifted keys into unshifted keys and set modifier */
316: if (IS_SPECIAL(c))
317: {
318: name[0] = KEY2TERMCAP0(c);
319: name[1] = KEY2TERMCAP1(c);
320: if (unshift_special_key(&name[0]))
321: modifiers |= MOD_MASK_SHIFT;
322: c = TERMCAP2KEY(name[0], name[1]);
323: }
324:
325: /* translate the modifier into a string */
326: for (i = 0; mod_mask_table[i].mod_mask; i++)
327: if (modifiers & mod_mask_table[i].mod_mask)
328: {
329: string[idx++] = mod_mask_table[i].name;
330: string[idx++] = (char_u)'-';
331: }
332:
333: /* try to find the key in the special key table */
334: i = find_special_key_in_table(c);
335: if (i < 0) /* unknown special key, output t_xx */
336: {
337: if (IS_SPECIAL(c))
338: {
339: string[idx++] = 't';
340: string[idx++] = '_';
341: string[idx++] = KEY2TERMCAP0(c);
342: string[idx++] = KEY2TERMCAP1(c);
343: }
344: /* Not a special key, only modifiers, output directly */
345: else
346: {
347: if (isprintchar(c))
348: string[idx++] = c;
349: else
350: {
351: s = transchar(c);
352: while (*s)
353: string[idx++] = *s++;
354: }
355: }
356: }
357: else /* use name of special key */
358: {
359: STRCPY(string + idx, key_names_table[i].name);
360: idx = STRLEN(string);
361: }
362: string[idx++] = '>';
363: string[idx] = NUL;
364: return string;
365: }
366:
367: /*
368: * Try to find key "c" in the special key table.
369: * Return the index when found, -1 when not found.
370: */
371: int
372: find_special_key_in_table(c)
373: int c;
374: {
375: int i;
376:
377: for (i = 0; key_names_table[i].name != NULL; i++)
378: if (c == key_names_table[i].key)
379: break;
380: if (key_names_table[i].name == NULL)
381: i = -1;
382: return i;
383: }
384:
385: /*
386: * Find the special key with the given name (the given string does not have to
387: * end with NUL, the name is assumed to end before the first non-idchar).
388: * If the name starts with "t_" the next two characters are interpreted as a
389: * termcap name.
390: * Return the key code, or 0 if not found.
391: */
392: int
393: get_special_key_code(name)
394: char_u *name;
395: {
396: char_u *table_name;
397: char_u string[3];
398: int i, j;
399:
400: /*
401: * If it's <t_xx> we get the code for xx from the termcap
402: */
403: if (name[0] == 't' && name[1] == '_' && name[2] != NUL && name[3] != NUL)
404: {
405: string[0] = name[2];
406: string[1] = name[3];
407: string[2] = NUL;
408: if (add_termcap_entry(string, FALSE) == OK)
409: return TERMCAP2KEY(name[2], name[3]);
410: }
411: else
412: for (i = 0; key_names_table[i].name != NULL; i++)
413: {
414: table_name = key_names_table[i].name;
415: for (j = 0; isidchar(name[j]) && table_name[j] != NUL; j++)
416: if (TO_LOWER(table_name[j]) != TO_LOWER(name[j]))
417: break;
418: if (!isidchar(name[j]) && table_name[j] == NUL)
419: return key_names_table[i].key;
420: }
421: return 0;
422: }
423:
424: char_u *
425: get_key_name(i)
426: int i;
427: {
428: if (i >= KEY_NAMES_TABLE_LEN)
429: return NULL;
430: return key_names_table[i].name;
431: }
432:
433: #ifdef USE_MOUSE
434: /*
435: * Look up the given mouse code to return the relevant information in the other
436: * arguments. Return which button is down or was released.
437: */
438: int
439: get_mouse_button(code, is_click, is_drag)
440: int code;
441: int *is_click;
442: int *is_drag;
443: {
444: int i;
445:
446: for (i = 0; mouse_table[i].pseudo_code; i++)
447: if (code == mouse_table[i].pseudo_code)
448: {
449: *is_click = mouse_table[i].is_click;
450: *is_drag = mouse_table[i].is_drag;
451: return mouse_table[i].button;
452: }
453: return 0; /* Shouldn't get here */
454: }
455:
456: /*
457: * Return the appropriate pseudo mouse event token (KE_LEFTMOUSE etc) based on
458: * the given information about which mouse button is down, and whether the
459: * mouse was clicked, dragged or released.
460: */
461: int
462: get_pseudo_mouse_code(button, is_click, is_drag)
463: int button; /* eg MOUSE_LEFT */
464: int is_click;
465: int is_drag;
466: {
467: int i;
468:
469: for (i = 0; mouse_table[i].pseudo_code; i++)
470: if (button == mouse_table[i].button
471: && is_click == mouse_table[i].is_click
472: && is_drag == mouse_table[i].is_drag)
473: {
474: return mouse_table[i].pseudo_code;
475: }
476: return KE_IGNORE; /* not recongnized, ignore it */
477: }
478: #endif /* USE_MOUSE */
![[BACK]](/icons/back.gif){kind=icon}
Return to tables.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim