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