key-bindings.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 <ctype.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "tmux.h"
  26
  27 RB_GENERATE(key_bindings, key_binding, entry, key_bindings_cmp);
  28
  29 struct key_bindings     key_bindings;
  30 struct key_bindings     dead_key_bindings;
  31
  32 int
  33 key_bindings_cmp(struct key_binding *bd1, struct key_binding *bd2)
  34 {
  35         int     key1, key2;
  36
  37         key1 = bd1->key & ~KEYC_PREFIX;
  38         key2 = bd2->key & ~KEYC_PREFIX;
  39         if (key1 != key2)
  40                 return (key1 - key2);
  41
  42         if (bd1->key & KEYC_PREFIX && !(bd2->key & KEYC_PREFIX))
  43                 return (-1);
  44         if (bd2->key & KEYC_PREFIX && !(bd1->key & KEYC_PREFIX))
  45                 return (1);
  46         return (0);
  47 }
  48
  49 struct key_binding *
  50 key_bindings_lookup(int key)
  51 {
  52         struct key_binding      bd;
  53
  54         bd.key = key;
  55         return (RB_FIND(key_bindings, &key_bindings, &bd));
  56 }
  57
  58 void
  59 key_bindings_add(int key, int can_repeat, struct cmd_list *cmdlist)
  60 {
  61         struct key_binding      *bd;
  62
  63         key_bindings_remove(key);
  64
  65         bd = xmalloc(sizeof *bd);
  66         bd->key = key;
  67         RB_INSERT(key_bindings, &key_bindings, bd);
  68
  69         bd->can_repeat = can_repeat;
  70         bd->cmdlist = cmdlist;
  71 }
  72
  73 void
  74 key_bindings_remove(int key)
  75 {
  76         struct key_binding      *bd;
  77
  78         if ((bd = key_bindings_lookup(key)) == NULL)
  79                 return;
  80         RB_REMOVE(key_bindings, &key_bindings, bd);
  81         RB_INSERT(key_bindings, &dead_key_bindings, bd);
  82 }
  83
  84 void
  85 key_bindings_clean(void)
  86 {
  87         struct key_binding      *bd;
  88
  89         while (!RB_EMPTY(&dead_key_bindings)) {
  90                 bd = RB_ROOT(&dead_key_bindings);
  91                 RB_REMOVE(key_bindings, &dead_key_bindings, bd);
  92                 cmd_list_free(bd->cmdlist);
  93                 xfree(bd);
  94         }
  95 }
  96
  97 void
  98 key_bindings_init(void)
  99 {
 100         static const struct {
 101                 int                      key;
 102                 int                      can_repeat;
 103                 const struct cmd_entry  *entry;
 104         } table[] = {
 105                 { ' ',                    0, &cmd_next_layout_entry },
 106                 { '!',                    0, &cmd_break_pane_entry },
 107                 { '"',                    0, &cmd_split_window_entry },
 108                 { '#',                    0, &cmd_list_buffers_entry },
 109                 { '$',                    0, &cmd_command_prompt_entry },
 110                 { '%',                    0, &cmd_split_window_entry },
 111                 { '&',                    0, &cmd_confirm_before_entry },
 112                 { '(',                    0, &cmd_switch_client_entry },
 113                 { ')',                    0, &cmd_switch_client_entry },
 114                 { ',',                    0, &cmd_command_prompt_entry },
 115                 { '-',                    0, &cmd_delete_buffer_entry },
 116                 { '.',                    0, &cmd_command_prompt_entry },
 117                 { '0',                    0, &cmd_select_window_entry },
 118                 { '1',                    0, &cmd_select_window_entry },
 119                 { '2',                    0, &cmd_select_window_entry },
 120                 { '3',                    0, &cmd_select_window_entry },
 121                 { '4',                    0, &cmd_select_window_entry },
 122                 { '5',                    0, &cmd_select_window_entry },
 123                 { '6',                    0, &cmd_select_window_entry },
 124                 { '7',                    0, &cmd_select_window_entry },
 125                 { '8',                    0, &cmd_select_window_entry },
 126                 { '9',                    0, &cmd_select_window_entry },
 127                 { ':',                    0, &cmd_command_prompt_entry },
 128                 { ';',                    0, &cmd_last_pane_entry },
 129                 { '=',                    0, &cmd_choose_buffer_entry },
 130                 { '?',                    0, &cmd_list_keys_entry },
 131                 { 'D',                    0, &cmd_choose_client_entry },
 132                 { 'L',                    0, &cmd_switch_client_entry },
 133                 { 'U',                    1, &cmd_select_layout_entry },
 134                 { '[',                    0, &cmd_copy_mode_entry },
 135                 { '\'',                   0, &cmd_command_prompt_entry },
 136                 { '\002', /* C-b */       0, &cmd_send_prefix_entry },
 137                 { '\017', /* C-o */       0, &cmd_rotate_window_entry },
 138                 { '\032', /* C-z */       0, &cmd_suspend_client_entry },
 139                 { ']',                    0, &cmd_paste_buffer_entry },
 140                 { 'c',                    0, &cmd_new_window_entry },
 141                 { 'd',                    0, &cmd_detach_client_entry },
 142                 { 'f',                    0, &cmd_command_prompt_entry },
 143                 { 'i',                    0, &cmd_display_message_entry },
 144                 { 'l',                    0, &cmd_last_window_entry },
 145                 { 'n',                    0, &cmd_next_window_entry },
 146                 { 'o',                    0, &cmd_select_pane_entry },
 147                 { 'p',                    0, &cmd_previous_window_entry },
 148                 { 'q',                    0, &cmd_display_panes_entry },
 149                 { 'r',                    0, &cmd_refresh_client_entry },
 150                 { 's',                    0, &cmd_choose_session_entry },
 151                 { 't',                    0, &cmd_clock_mode_entry },
 152                 { 'u',                    1, &cmd_select_layout_entry },
 153                 { 'w',                    0, &cmd_choose_window_entry },
 154                 { 'x',                    0, &cmd_confirm_before_entry },
 155                 { '{',                    0, &cmd_swap_pane_entry },
 156                 { '}',                    0, &cmd_swap_pane_entry },
 157                 { '~',                    0, &cmd_show_messages_entry },
 158                 { '1' | KEYC_ESCAPE,      0, &cmd_select_layout_entry },
 159                 { '2' | KEYC_ESCAPE,      0, &cmd_select_layout_entry },
 160                 { '3' | KEYC_ESCAPE,      0, &cmd_select_layout_entry },
 161                 { '4' | KEYC_ESCAPE,      0, &cmd_select_layout_entry },
 162                 { '5' | KEYC_ESCAPE,      0, &cmd_select_layout_entry },
 163                 { KEYC_PPAGE,             0, &cmd_copy_mode_entry },
 164                 { 'n' | KEYC_ESCAPE,      0, &cmd_next_window_entry },
 165                 { 'o' | KEYC_ESCAPE,      0, &cmd_rotate_window_entry },
 166                 { 'p' | KEYC_ESCAPE,      0, &cmd_previous_window_entry },
 167                 { KEYC_UP,                1, &cmd_select_pane_entry },
 168                 { KEYC_DOWN,              1, &cmd_select_pane_entry },
 169                 { KEYC_LEFT,              1, &cmd_select_pane_entry },
 170                 { KEYC_RIGHT,             1, &cmd_select_pane_entry },
 171                 { KEYC_UP | KEYC_ESCAPE,  1, &cmd_resize_pane_entry },
 172                 { KEYC_DOWN | KEYC_ESCAPE,  1, &cmd_resize_pane_entry },
 173                 { KEYC_LEFT | KEYC_ESCAPE,  1, &cmd_resize_pane_entry },
 174                 { KEYC_RIGHT | KEYC_ESCAPE, 1, &cmd_resize_pane_entry },
 175                 { KEYC_UP | KEYC_CTRL,    1, &cmd_resize_pane_entry },
 176                 { KEYC_DOWN | KEYC_CTRL,  1, &cmd_resize_pane_entry },
 177                 { KEYC_LEFT | KEYC_CTRL,  1, &cmd_resize_pane_entry },
 178                 { KEYC_RIGHT | KEYC_CTRL, 1, &cmd_resize_pane_entry },
 179         };
 180         u_int            i;
 181         struct cmd      *cmd;
 182         struct cmd_list *cmdlist;
 183
 184         RB_INIT(&key_bindings);
 185
 186         for (i = 0; i < nitems(table); i++) {
 187                 cmdlist = xmalloc(sizeof *cmdlist);
 188                 TAILQ_INIT(&cmdlist->list);
 189                 cmdlist->references = 1;
 190
 191                 cmd = xmalloc(sizeof *cmd);
 192                 cmd->entry = table[i].entry;
 193                 if (cmd->entry->key_binding != NULL)
 194                         cmd->entry->key_binding(cmd, table[i].key);
 195                 else
 196                         cmd->args = args_create(0);
 197                 TAILQ_INSERT_HEAD(&cmdlist->list, cmd, qentry);
 198
 199                 key_bindings_add(
 200                     table[i].key | KEYC_PREFIX, table[i].can_repeat, cmdlist);
 201         }
 202 }
 203
 204 void printflike2
 205 key_bindings_error(struct cmd_ctx *ctx, const char *fmt, ...)
 206 {
 207         va_list ap;
 208         char   *msg;
 209
 210         va_start(ap, fmt);
 211         xvasprintf(&msg, fmt, ap);
 212         va_end(ap);
 213
 214         *msg = toupper((u_char) *msg);
 215         status_message_set(ctx->curclient, "%s", msg);
 216         xfree(msg);
 217 }
 218
 219 void printflike2
 220 key_bindings_print(struct cmd_ctx *ctx, const char *fmt, ...)
 221 {
 222         struct winlink  *wl = ctx->curclient->session->curw;
 223         va_list          ap;
 224
 225         if (wl->window->active->mode != &window_copy_mode) {
 226                 window_pane_reset_mode(wl->window->active);
 227                 window_pane_set_mode(wl->window->active, &window_copy_mode);
 228                 window_copy_init_for_output(wl->window->active);
 229         }
 230
 231         va_start(ap, fmt);
 232         window_copy_vadd(wl->window->active, fmt, ap);
 233         va_end(ap);
 234 }
 235
 236 void printflike2
 237 key_bindings_info(struct cmd_ctx *ctx, const char *fmt, ...)
 238 {
 239         va_list ap;
 240         char   *msg;
 241
 242         if (options_get_number(&global_options, "quiet"))
 243                 return;
 244
 245         va_start(ap, fmt);
 246         xvasprintf(&msg, fmt, ap);
 247         va_end(ap);
 248
 249         *msg = toupper((u_char) *msg);
 250         status_message_set(ctx->curclient, "%s", msg);
 251         xfree(msg);
 252 }
 253
 254 void
 255 key_bindings_dispatch(struct key_binding *bd, struct client *c)
 256 {
 257         struct cmd_ctx   ctx;
 258         struct cmd      *cmd;
 259         int              readonly;
 260
 261         ctx.msgdata = NULL;
 262         ctx.curclient = c;
 263
 264         ctx.error = key_bindings_error;
 265         ctx.print = key_bindings_print;
 266         ctx.info = key_bindings_info;
 267
 268         ctx.cmdclient = NULL;
 269
 270         readonly = 1;
 271         TAILQ_FOREACH(cmd, &bd->cmdlist->list, qentry) {
 272                 if (!(cmd->entry->flags & CMD_READONLY))
 273                         readonly = 0;
 274         }
 275         if (!readonly && c->flags & CLIENT_READONLY) {
 276                 key_bindings_info(&ctx, "Client is read-only");
 277                 return;
 278         }
 279
 280         cmd_list_exec(bd->cmdlist, &ctx);
 281 }