src/keys.c

   1 /* Copyright (c) 2006-2015 Jonas Fonseca <jonas.fonseca@gmail.com>
   2  *
   3  * This program is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU General Public License as
   5  * published by the Free Software Foundation; either version 2 of
   6  * the License, or (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include "tig/tig.h"
  15 #include "tig/types.h"
  16 #include "tig/argv.h"
  17 #include "tig/io.h"
  18 #include "tig/keys.h"
  19
  20 struct keybinding {
  21         enum request request;
  22         size_t keys;
  23         struct key key[1];
  24 };
  25
  26 static struct keymap keymaps[] = {
  27         { "generic" },
  28         { "search" },
  29 #define VIEW_KEYMAP(id, name) { #name }
  30         VIEW_INFO(VIEW_KEYMAP)
  31 };
  32
  33 static struct keymap *generic_keymap = keymaps;
  34 #define is_generic_keymap(keymap) ((keymap) == generic_keymap)
  35
  36 static struct keymap *search_keymap = keymaps + 1;
  37 #define is_search_keymap(keymap) ((keymap) == search_keymap)
  38
  39 struct keymap *
  40 get_keymap(const char *name, size_t namelen)
  41 {
  42         int i;
  43
  44         for (i = 0; i < ARRAY_SIZE(keymaps); i++)
  45                 if (!strncasecmp(keymaps[i].name, name, namelen))
  46                         return &keymaps[i];
  47
  48         return NULL;
  49 }
  50
  51 static bool
  52 keybinding_matches(const struct keybinding *keybinding, const struct key key[],
  53                   size_t keys, bool *conflict_ptr)
  54 {
  55         bool conflict = false;
  56         int i;
  57
  58         if (keybinding->request == REQ_NONE)
  59                 return false;
  60
  61         for (i = 0; i < keys; i++) {
  62                 const struct key *key1 = &keybinding->key[i];
  63                 const struct key *key2 = &key[i];
  64
  65                 if (key1->modifiers.control &&
  66                     key1->modifiers.multibytes &&
  67                     !memcmp(&key1->modifiers, &key2->modifiers, sizeof(key1->modifiers)) &&
  68                     strlen(key1->data.bytes) == 1 &&
  69                     strlen(key2->data.bytes) == 1) {
  70                         int c1 = key1->data.bytes[0];
  71                         int c2 = key2->data.bytes[0];
  72
  73                         if (ascii_toupper(c1) != ascii_toupper(c2))
  74                                 return false;
  75                         if (c1 != c2)
  76                                 conflict = true;
  77                 } else {
  78                         if (memcmp(key1, key2, sizeof(*key1)))
  79                                 return false;
  80                 }
  81         }
  82
  83         if (conflict_ptr)
  84                 *conflict_ptr = conflict;
  85         return true;
  86 }
  87
  88 static bool
  89 keybinding_equals(const struct keybinding *keybinding, const struct key key[],
  90                   size_t keys, bool *conflict_ptr)
  91 {
  92         if (keybinding->keys != keys)
  93                 return false;
  94         return keybinding_matches(keybinding, key, keys, conflict_ptr);
  95 }
  96
  97 enum status_code
  98 add_keybinding(struct keymap *table, enum request request,
  99                const struct key key[], size_t keys)
 100 {
 101         struct keybinding *keybinding;
 102         char buf[SIZEOF_STR];
 103         bool conflict = false;
 104         size_t i;
 105
 106         for (i = 0; i < table->size; i++) {
 107                 if (keybinding_equals(table->data[i], key, keys, &conflict)) {
 108                         enum request old_request = table->data[i]->request;
 109                         const char *old_name;
 110
 111                         table->data[i]->request = request;
 112                         if (!conflict)
 113                                 return SUCCESS;
 114
 115                         old_name = get_request_name(old_request);
 116                         string_ncopy(buf, old_name, strlen(old_name));
 117                         return error("Key binding for %s and %s conflict; "
 118                                      "keys using Ctrl are case insensitive",
 119                                      buf, get_request_name(request));
 120                 }
 121         }
 122
 123         table->data = realloc(table->data, (table->size + 1) * sizeof(*table->data));
 124         keybinding = calloc(1, sizeof(*keybinding) + (sizeof(*key) * (keys - 1)));
 125         if (!table->data || !keybinding)
 126                 die("Failed to allocate keybinding");
 127
 128         memcpy(keybinding->key, key, sizeof(*key) * keys);
 129         keybinding->keys = keys;
 130         keybinding->request = request;
 131         table->data[table->size++] = keybinding;
 132         return SUCCESS;
 133 }
 134
 135 /* Looks for a key binding first in the given map, then in the generic map, and
 136  * lastly in the default keybindings. */
 137 enum request
 138 get_keybinding(const struct keymap *keymap, const struct key key[], size_t keys, int *matches)
 139 {
 140         enum request request = REQ_UNKNOWN;
 141         size_t i;
 142
 143         for (i = 0; i < keymap->size; i++)
 144                 if (keybinding_matches(keymap->data[i], key, keys, NULL)) {
 145                         if (matches)
 146                                 (*matches)++;
 147                         if (keymap->data[i]->keys == keys)
 148                                 request = keymap->data[i]->request;
 149                 }
 150
 151         if (is_search_keymap(keymap))
 152                 return request;
 153
 154         for (i = 0; i < generic_keymap->size; i++)
 155                 if (keybinding_matches(generic_keymap->data[i], key, keys, NULL)) {
 156                         if (matches)
 157                                 (*matches)++;
 158                         if (request == REQ_UNKNOWN && generic_keymap->data[i]->keys == keys)
 159                                 request = generic_keymap->data[i]->request;
 160                 }
 161
 162         return request;
 163 }
 164
 165
 166 struct key_mapping {
 167         const char *name;
 168         int value;
 169 };
 170
 171 static const struct key_mapping key_mappings[] = {
 172         { "Enter",      KEY_RETURN },
 173         { "Space",      ' ' },
 174         { "Backspace",  KEY_BACKSPACE },
 175         { "Tab",        KEY_TAB },
 176         { "Escape",     KEY_ESC },
 177         { "Esc",        KEY_ESC },
 178         { "Left",       KEY_LEFT },
 179         { "Right",      KEY_RIGHT },
 180         { "Up",         KEY_UP },
 181         { "Down",       KEY_DOWN },
 182         { "Insert",     KEY_IC },
 183         { "Ins",        KEY_IC },
 184         { "Delete",     KEY_DC },
 185         { "Del",        KEY_DC },
 186         { "Hash",       '#' },
 187         { "Home",       KEY_HOME },
 188         { "End",        KEY_END },
 189         { "PageUp",     KEY_PPAGE },
 190         { "PgUp",       KEY_PPAGE },
 191         { "PageDown",   KEY_NPAGE },
 192         { "PgDown",     KEY_NPAGE },
 193         { "LessThan",   '<' },
 194         { "LT",         '<' },
 195         { "F1",         KEY_F(1) },
 196         { "F2",         KEY_F(2) },
 197         { "F3",         KEY_F(3) },
 198         { "F4",         KEY_F(4) },
 199         { "F5",         KEY_F(5) },
 200         { "F6",         KEY_F(6) },
 201         { "F7",         KEY_F(7) },
 202         { "F8",         KEY_F(8) },
 203         { "F9",         KEY_F(9) },
 204         { "F10",        KEY_F(10) },
 205         { "F11",        KEY_F(11) },
 206         { "F12",        KEY_F(12) },
 207         { "ScrollBack", KEY_SR },
 208         { "SBack",      KEY_SR },
 209         { "ScrollFwd",  KEY_SF },
 210         { "SFwd",       KEY_SF },
 211 };
 212
 213 static const struct key_mapping *
 214 get_key_mapping(const char *name, size_t namelen)
 215 {
 216         int i;
 217
 218         for (i = 0; i < ARRAY_SIZE(key_mappings); i++) {
 219                 if (namelen == strlen(key_mappings[i].name) &&
 220                     !strncasecmp(key_mappings[i].name, name, namelen))
 221                         return &key_mappings[i];
 222         }
 223
 224         return NULL;
 225 }
 226
 227 static enum status_code
 228 parse_key_value(struct key *key, const char **name_ptr, size_t offset,
 229                 const char *replacement, const char *end)
 230 {
 231         const char *name = replacement ? replacement : *name_ptr + offset;
 232         size_t namelen = utf8_char_length(name);
 233         const char *nameend = name + namelen;
 234
 235         if (strlen(name) < namelen || utf8_to_unicode(name, namelen) == 0)
 236                 return error("Error parsing UTF-8 bytes: %s", name);
 237
 238         strncpy(key->data.bytes, name, namelen);
 239         key->modifiers.multibytes = 1;
 240         if (end) {
 241                 *name_ptr = end + 1;
 242                 if (!replacement && nameend + 1 < end)
 243                         return success("Ignoring text after key mapping: %.*s",
 244                                 (int) (end - nameend), nameend);
 245         } else {
 246                 *name_ptr = nameend;
 247         }
 248
 249         return SUCCESS;
 250 }
 251
 252 enum status_code
 253 get_key_value(const char **name_ptr, struct key *key)
 254 {
 255         const char *name = *name_ptr;
 256         const char *end = NULL;
 257
 258         memset(key, 0, sizeof(*key));
 259
 260         if (*name == '<') {
 261                 end = strchr(name + 1, '>');
 262                 if (!end)
 263                         return error("Missing '>' from key mapping: %s", name);
 264
 265                 if (!prefixcmp(name, "<Ctrl-")) {
 266                         key->modifiers.control = 1;
 267                         return parse_key_value(key, name_ptr, 6, NULL, end);
 268
 269                 } else if (!prefixcmp(name, "<C-")) {
 270                         key->modifiers.control = 1;
 271                         return parse_key_value(key, name_ptr, 3, NULL, end);
 272
 273                 } else {
 274                         const struct key_mapping *mapping;
 275                         const char *start = name + 1;
 276                         int len = end - start;
 277
 278                         mapping = get_key_mapping(start, len);
 279                         if (!mapping)
 280                                 return error("Unknown key mapping: %.*s", len, start);
 281
 282                         if (mapping->value == ' ')
 283                                 return parse_key_value(key, name_ptr, 0, " ", end);
 284
 285                         if (mapping->value == '#')
 286                                 return parse_key_value(key, name_ptr, 0, "#", end);
 287
 288                         if (mapping->value == '<')
 289                                 return parse_key_value(key, name_ptr, 0, "<", end);
 290
 291                         *name_ptr = end + 1;
 292                         key->data.value = mapping->value;
 293                         return SUCCESS;
 294                 }
 295         }
 296
 297         if (name[0] == '^' && name[1] == '[') {
 298                 return error("Escape key combo must now use '<Esc>%s' "
 299                              "instead of '%s'", name + 2, name);
 300         } else if (name[0] == '^' && name[1] != '\0') {
 301                 return error("Control key mapping must now use '<Ctrl-%s>' "
 302                              "instead of '%s'", name + 1, name);
 303         }
 304
 305         return parse_key_value(key, name_ptr, 0, NULL, end);
 306 }
 307
 308 const char *
 309 get_key_name(const struct key key[], size_t keys, bool quote_comma)
 310 {
 311         static char buf[SIZEOF_STR];
 312         size_t pos = 0;
 313         int i;
 314
 315         for (i = 0; i < keys; i++) {
 316                 bool multibytes = key[i].modifiers.multibytes;
 317                 const char *name = multibytes ? key[i].data.bytes : "";
 318                 const char *start = "";
 319                 const char *end = "";
 320                 bool use_symbolic;
 321
 322                 if (key[i].modifiers.control) {
 323                         start = "<Ctrl-";
 324                         end = ">";
 325                 } else if (*name == ',' && quote_comma) {
 326                         /* Quote commas so they stand out in the help view. */
 327                         start = "'";
 328                         end = "'";
 329                 }
 330
 331                 /* Use symbolic name for spaces so they are readable. */
 332                 use_symbolic = !*name || *name == ' ';
 333                 /* When listing keys for :save-options quote illegal characters. */
 334                 if (!quote_comma && (*name == '<' || *name == '#'))
 335                         use_symbolic = true;
 336
 337                 if (use_symbolic) {
 338                         int value = *name ? *name : key[i].data.value;
 339                         int j;
 340
 341                         name = "<?>";
 342                         for (j = 0; j < ARRAY_SIZE(key_mappings); j++)
 343                                 if (key_mappings[j].value == value) {
 344                                         start = "<";
 345                                         end = ">";
 346                                         name = key_mappings[j].name;
 347                                         break;
 348                                 }
 349                 }
 350
 351                 if (!string_format_from(buf, &pos, "%s%s%s", start, name, end))
 352                         return "(no key)";
 353         }
 354
 355         return buf;
 356 }
 357
 358 static bool
 359 append_key(char *buf, size_t *pos, const struct keybinding *keybinding, bool all)
 360 {
 361         const char *sep = *pos > 0 ? ", " : "";
 362         const char *keyname = get_key_name(keybinding->key, keybinding->keys, all);
 363
 364         return string_nformat(buf, BUFSIZ, pos, "%s%s", sep, keyname);
 365 }
 366
 367 static bool
 368 append_keymap_request_keys(char *buf, size_t *pos, enum request request,
 369                            const struct keymap *keymap, bool all)
 370 {
 371         int i;
 372
 373         for (i = 0; i < keymap->size; i++) {
 374                 if (keymap->data[i]->request == request) {
 375                         if (!append_key(buf, pos, keymap->data[i], all))
 376                                 return false;
 377                         if (!all)
 378                                 break;
 379                 }
 380         }
 381
 382         return true;
 383 }
 384
 385 const char *
 386 get_keys(const struct keymap *keymap, enum request request, bool all)
 387 {
 388         static char buf[BUFSIZ];
 389         size_t pos = 0;
 390
 391         buf[pos] = 0;
 392
 393         if (!append_keymap_request_keys(buf, &pos, request, keymap, all))
 394                 return "Too many keybindings!";
 395         if (pos > 0 && !all)
 396                 return buf;
 397
 398         if (!is_generic_keymap(keymap)) {
 399                 /* Only the generic keymap includes the default keybindings when
 400                  * listing all keys. */
 401                 if (all)
 402                         return buf;
 403
 404                 if (!append_keymap_request_keys(buf, &pos, request, generic_keymap, all))
 405                         return "Too many keybindings!";
 406                 if (pos)
 407                         return buf;
 408         }
 409
 410         return buf;
 411 }
 412
 413 static struct run_request *run_request;
 414 static size_t run_requests;
 415
 416 DEFINE_ALLOCATOR(realloc_run_requests, struct run_request, 8)
 417
 418 #define COMMAND_FLAGS ":!?@<"
 419
 420 enum status_code
 421 parse_run_request_flags(struct run_request_flags *flags, const char **argv)
 422 {
 423         if (!strchr(COMMAND_FLAGS, *argv[0]))
 424                 return error("Unknown command flag '%c'; expected one of %s", argv[0][0], COMMAND_FLAGS);
 425
 426         while (*argv[0]) {
 427                 if (*argv[0] == ':') {
 428                         flags->internal = 1;
 429                         argv[0]++;
 430                         break;
 431                 } else if (*argv[0] == '@') {
 432                         flags->silent = 1;
 433                 } else if (*argv[0] == '?') {
 434                         flags->confirm = 1;
 435                 } else if (*argv[0] == '<') {
 436                         flags->exit = 1;
 437                 } else if (*argv[0] != '!') {
 438                         break;
 439                 }
 440                 argv[0]++;
 441         }
 442
 443         return SUCCESS;
 444 }
 445
 446 enum status_code
 447 add_run_request(struct keymap *keymap, const struct key key[],
 448                 size_t keys, const char **argv)
 449 {
 450         struct run_request *req;
 451         struct run_request_flags flags = {0};
 452         enum status_code code = parse_run_request_flags(&flags, argv);
 453
 454         if (code != SUCCESS)
 455                 return code;
 456
 457         if (!realloc_run_requests(&run_request, run_requests, 1))
 458                 return ERROR_OUT_OF_MEMORY;
 459
 460         if (!argv_copy(&run_request[run_requests].argv, argv))
 461                 return ERROR_OUT_OF_MEMORY;
 462
 463         req = &run_request[run_requests++];
 464         req->flags = flags;
 465         req->keymap = keymap;
 466
 467         return add_keybinding(keymap, REQ_RUN_REQUESTS + run_requests, key, keys);
 468 }
 469
 470 struct run_request *
 471 get_run_request(enum request request)
 472 {
 473         if (request <= REQ_RUN_REQUESTS || request > REQ_RUN_REQUESTS + run_requests)
 474                 return NULL;
 475         return &run_request[request - REQ_RUN_REQUESTS - 1];
 476 }
 477
 478 const char *
 479 format_run_request_flags(const struct run_request *req)
 480 {
 481         static char flags[8];
 482         int flagspos = 0;
 483
 484         memset(flags, 0, sizeof(flags));
 485
 486         if (req->flags.internal)
 487                 flags[flagspos++] = ':';
 488         else
 489                 flags[flagspos] = '!'; /* Optional, if other flags are defined */
 490
 491         if (req->flags.silent)
 492             flags[flagspos++] = '@';
 493         if (req->flags.confirm)
 494             flags[flagspos++] = '?';
 495         if (req->flags.exit)
 496                 flags[flagspos++] = '<';
 497         if (flagspos > 1)
 498                 flags[flagspos++] = 0;
 499
 500         return flags;
 501 }
 502
 503 struct key_visitor_state {
 504         key_visitor_fn visitor;
 505         void *data;
 506         struct keymap *keymap;
 507         bool combine_keys;
 508         const char *group;
 509 };
 510
 511 static bool
 512 foreach_key_visit(struct key_visitor_state *state, const char *group,
 513                   enum request request,
 514                   const struct request_info *req_info, const struct run_request *run_req)
 515 {
 516         struct keymap *keymap = state->keymap;
 517         int i;
 518
 519         if (state->group == group)
 520                 group = NULL;
 521
 522         if (state->combine_keys) {
 523                 const char *key = get_keys(keymap, request, true);
 524
 525                 if (!key || !*key)
 526                         return true;
 527
 528                 if (group)
 529                         state->group = group;
 530                 return state->visitor(state->data, group, keymap, request,
 531                                       key, req_info, run_req);
 532         }
 533
 534         for (i = 0; i < keymap->size; i++) {
 535                 if (keymap->data[i]->request == request) {
 536                         struct keybinding *keybinding = keymap->data[i];
 537                         const char *key = get_key_name(keybinding->key, keybinding->keys, false);
 538
 539                         if (!key || !*key)
 540                                 continue;
 541
 542                         if (!state->visitor(state->data, group, keymap, request,
 543                                             key, req_info, run_req))
 544                                 return false;
 545
 546                         if (group)
 547                                 state->group = group;
 548                         group = NULL;
 549                 }
 550         }
 551
 552         return true;
 553 }
 554
 555 static bool
 556 foreach_key_request(void *data, const struct request_info *req_info, const char *group)
 557 {
 558         struct key_visitor_state *state = data;
 559
 560         if (req_info->request == REQ_NONE)
 561                 return true;
 562
 563         return foreach_key_visit(state, group, req_info->request, req_info, NULL);
 564 }
 565
 566 static bool
 567 foreach_key_run_request(struct key_visitor_state *state, bool internal, bool toggles)
 568 {
 569         struct keymap *keymap = state->keymap;
 570         const char *group = !internal ? "External commands:" :
 571                             toggles ?   "Option toggling:" :
 572                                         "Internal commands:";
 573         enum request request = REQ_RUN_REQUESTS + 1;
 574
 575         for (; true; request++) {
 576                 struct run_request *req = get_run_request(request);
 577                 const char *key;
 578
 579                 if (!req)
 580                         break;
 581
 582                 if (req->flags.internal != !!internal ||
 583                     req->keymap != keymap ||
 584                     !*(key = get_keys(keymap, request, true)))
 585                         continue;
 586
 587                 if (toggles != !strcmp(req->argv[0], "toggle"))
 588                         continue;
 589
 590                 if (!foreach_key_visit(state, group, request, NULL, req))
 591                         return false;
 592         }
 593
 594         return true;
 595 }
 596
 597 bool
 598 foreach_key(key_visitor_fn visitor, void *data, bool combine_keys)
 599 {
 600         int i;
 601
 602         for (i = 0; i < ARRAY_SIZE(keymaps); i++) {
 603                 struct key_visitor_state state = { visitor, data, &keymaps[i], combine_keys };
 604
 605                 if (!foreach_request(foreach_key_request, &state)
 606                     || !foreach_key_run_request(&state, true, true)
 607                     || !foreach_key_run_request(&state, true, false)
 608                     || !foreach_key_run_request(&state, false, false))
 609                         return false;
 610         }
 611
 612         return true;
 613 }
 614
 615 /* vim: set ts=8 sw=8 noexpandtab: */