key-string.c

   1 /* $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
   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 int     key_string_search_table(const char *);
  26 int     key_string_get_modifiers(const char **);
  27
  28 const struct {
  29         const char     *string;
  30         int             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         { "F13",        KEYC_F13 },
  46         { "F14",        KEYC_F14 },
  47         { "F15",        KEYC_F15 },
  48         { "F16",        KEYC_F16 },
  49         { "F17",        KEYC_F17 },
  50         { "F18",        KEYC_F18 },
  51         { "F19",        KEYC_F19 },
  52         { "F20",        KEYC_F20 },
  53         { "IC",         KEYC_IC },
  54         { "DC",         KEYC_DC },
  55         { "Home",       KEYC_HOME },
  56         { "End",        KEYC_END },
  57         { "NPage",      KEYC_NPAGE },
  58         { "PPage",      KEYC_PPAGE },
  59         { "Tab",        '\011' },
  60         { "BTab",       KEYC_BTAB },
  61         { "Space",      ' ' },
  62         { "BSpace",     KEYC_BSPACE },
  63         { "Enter",      '\r' },
  64         { "Escape",     '\033' },
  65
  66         /* Arrow keys. */
  67         { "Up",         KEYC_UP },
  68         { "Down",       KEYC_DOWN },
  69         { "Left",       KEYC_LEFT },
  70         { "Right",      KEYC_RIGHT },
  71
  72         /* Numeric keypad. */
  73         { "KP/",        KEYC_KP_SLASH },
  74         { "KP*",        KEYC_KP_STAR },
  75         { "KP-",        KEYC_KP_MINUS },
  76         { "KP7",        KEYC_KP_SEVEN },
  77         { "KP8",        KEYC_KP_EIGHT },
  78         { "KP9",        KEYC_KP_NINE },
  79         { "KP+",        KEYC_KP_PLUS },
  80         { "KP4",        KEYC_KP_FOUR },
  81         { "KP5",        KEYC_KP_FIVE },
  82         { "KP6",        KEYC_KP_SIX },
  83         { "KP1",        KEYC_KP_ONE },
  84         { "KP2",        KEYC_KP_TWO },
  85         { "KP3",        KEYC_KP_THREE },
  86         { "KPEnter",    KEYC_KP_ENTER },
  87         { "KP0",        KEYC_KP_ZERO },
  88         { "KP.",        KEYC_KP_PERIOD },
  89 };
  90
  91 /* Find key string in table. */
  92 int
  93 key_string_search_table(const char *string)
  94 {
  95         u_int   i;
  96
  97         for (i = 0; i < nitems(key_string_table); i++) {
  98                 if (strcasecmp(string, key_string_table[i].string) == 0)
  99                         return (key_string_table[i].key);
 100         }
 101         return (KEYC_NONE);
 102 }
 103
 104 /* Find modifiers. */
 105 int
 106 key_string_get_modifiers(const char **string)
 107 {
 108         int     modifiers;
 109
 110         modifiers = 0;
 111         while (((*string)[0] != '\0') && (*string)[1] == '-') {
 112                 switch ((*string)[0]) {
 113                 case 'C':
 114                 case 'c':
 115                         modifiers |= KEYC_CTRL;
 116                         break;
 117                 case 'M':
 118                 case 'm':
 119                         modifiers |= KEYC_ESCAPE;
 120                         break;
 121                 case 'S':
 122                 case 's':
 123                         modifiers |= KEYC_SHIFT;
 124                         break;
 125                 }
 126                 *string += 2;
 127         }
 128         return (modifiers);
 129 }
 130
 131 /* Lookup a string and convert to a key value. */
 132 int
 133 key_string_lookup_string(const char *string)
 134 {
 135         int     key, modifiers;
 136
 137         /* Check for modifiers. */
 138         modifiers = 0;
 139         if (string[0] == '^' && string[1] != '\0') {
 140                 modifiers |= KEYC_CTRL;
 141                 string++;
 142         }
 143         modifiers |= key_string_get_modifiers(&string);
 144         if (string[0] == '\0')
 145                 return (KEYC_NONE);
 146
 147         /* Is this a standard ASCII key? */
 148         if (string[1] == '\0') {
 149                 key = (u_char) string[0];
 150                 if (key < 32 || key == 127 || key > 255)
 151                         return (KEYC_NONE);
 152         } else {
 153                 /* Otherwise look the key up in the table. */
 154                 key = key_string_search_table(string);
 155                 if (key == KEYC_NONE)
 156                         return (KEYC_NONE);
 157         }
 158
 159         /* Convert the standard control keys. */
 160         if (key < KEYC_BASE && (modifiers & KEYC_CTRL)) {
 161                 if (key >= 97 && key <= 122)
 162                         key -= 96;
 163                 else if (key >= 64 && key <= 95)
 164                         key -= 64;
 165                 else if (key == 32)
 166                         key = 0;
 167                 else if (key == 63)
 168                         key = KEYC_BSPACE;
 169                 else
 170                         return (KEYC_NONE);
 171                 modifiers &= ~KEYC_CTRL;
 172         }
 173
 174         return (key | modifiers);
 175 }
 176
 177 /* Convert a key code into string format, with prefix if necessary. */
 178 const char *
 179 key_string_lookup_key(int key)
 180 {
 181         static char     out[24];
 182         char            tmp[8];
 183         u_int           i;
 184
 185         *out = '\0';
 186
 187         /*
 188          * Special case: display C-@ as C-Space. Could do this below in
 189          * the (key >= 0 && key <= 32), but this way we let it be found
 190          * in key_string_table, for the unlikely chance that we might
 191          * change its name.
 192          */
 193         if ((key & KEYC_MASK_KEY) == 0)
 194             key = ' ' | KEYC_CTRL | (key & KEYC_MASK_MOD);
 195
 196         /* Fill in the modifiers. */
 197         if (key & KEYC_CTRL)
 198                 strlcat(out, "C-", sizeof out);
 199         if (key & KEYC_ESCAPE)
 200                 strlcat(out, "M-", sizeof out);
 201         if (key & KEYC_SHIFT)
 202                 strlcat(out, "S-", sizeof out);
 203         key &= KEYC_MASK_KEY;
 204
 205         /* Try the key against the string table. */
 206         for (i = 0; i < nitems(key_string_table); i++) {
 207                 if (key == key_string_table[i].key)
 208                         break;
 209         }
 210         if (i != nitems(key_string_table)) {
 211                 strlcat(out, key_string_table[i].string, sizeof out);
 212                 return (out);
 213         }
 214
 215         /* Invalid keys are errors. */
 216         if (key == 127 || key > 255)
 217                 return (NULL);
 218
 219         /* Check for standard or control key. */
 220         if (key >= 0 && key <= 32) {
 221                 if (key == 0 || key > 26)
 222                         xsnprintf(tmp, sizeof tmp, "C-%c", 64 + key);
 223                 else
 224                         xsnprintf(tmp, sizeof tmp, "C-%c", 96 + key);
 225         } else if (key >= 32 && key <= 126) {
 226                 tmp[0] = key;
 227                 tmp[1] = '\0';
 228         } else if (key >= 128)
 229                 xsnprintf(tmp, sizeof tmp, "\\%o", key);
 230
 231         strlcat(out, tmp, sizeof out);
 232         return (out);
 233 }