input.c

   1 #include <ctype.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <termios.h>
   6
   7 #include "input.h"
   8 #include "util.h"
   9 #include "draw.h"
  10 #include "buffer.h"
  11
  12 /*
  13  * Listen for the user input and call the appropriate functions.
  14  */
  15 void
  16 input_get(Buffer *buffer, int offset, int tty_fd, Opt *opt)
  17 {
  18         FILE *tty_fp = fopen("/dev/tty", "r");
  19
  20         /* receive one character at a time from the terminal */
  21         struct termios termio_old = set_terminal(tty_fd);
  22
  23         /* get input char by char from the keyboard. */
  24         while (input_key(fgetc(tty_fp), buffer, opt)) {
  25                 draw_screen(buffer, offset, tty_fd, opt);
  26         }
  27
  28         /* resets the terminal to the previous state. */
  29         tcsetattr(tty_fd, TCSANOW, &termio_old);
  30
  31         fclose(tty_fp);
  32 }
  33
  34 /*
  35  * Perform action associated with key
  36  */
  37 int
  38 input_key(char key, Buffer *buffer, Opt *opt)
  39 {
  40         if (key == opt->validate_key) {
  41                 action_print_selection(buffer, opt);
  42                 return FALSE;
  43         }
  44
  45         switch (key) {
  46
  47         case CONTROL('C'):
  48                 draw_clear(opt->lines);
  49                 exit(EXIT_FAILURE);
  50                 break;  /* never reached */
  51
  52         case CONTROL('U'):
  53                 buffer->input[0] = '\0';
  54                 buffer->current  = buffer->first;
  55                 filter_lines(buffer, opt);
  56                 action_jump(buffer, BOTH, opt);
  57                 break;
  58
  59         case CONTROL('W'):
  60                 action_remove_word_input(buffer);
  61                 filter_lines(buffer, opt);
  62                 break;
  63
  64         case 127:
  65         case CONTROL('H'):  /* backspace */
  66                 buffer->input[strlen(buffer->input) - 1] = '\0';
  67                 filter_lines(buffer, opt);
  68
  69                 if (!buffer->current->matches) {
  70                         action_jump(buffer, BOTH, opt);
  71                 }
  72                 break;
  73
  74         case CONTROL('N'):
  75                 action_jump(buffer, NEXT, opt);
  76                 break;
  77
  78         case CONTROL('P'):
  79                 action_jump(buffer, PREV, opt);
  80                 break;
  81
  82         case CONTROL('I'):  /* tab */
  83                 strcpy(buffer->input, buffer->current->content);
  84                 filter_lines(buffer, opt);
  85                 break;
  86
  87         case CONTROL('M'):
  88         case CONTROL('J'):  /* enter */
  89                 action_print_selection(buffer, opt);
  90                 return FALSE;
  91
  92         default:
  93                 action_add_character(buffer, key, opt);
  94         }
  95
  96         return TRUE;
  97 }
  98
  99 /*
 100  * Set the current line to the next/previous/closest matching line.
 101  */
 102 void
 103 action_jump(Buffer *buffer, int direction, Opt *opt)
 104 {
 105         Line * line = buffer->current;
 106
 107         if (direction == BOTH) {
 108                 line = matching_next(buffer->current);
 109                 line = (line) ? line : matching_prev(buffer->current);
 110         } else if (direction == NEXT) {
 111                 line = matching_next(line);
 112         } else if (direction == PREV) {
 113                 line = matching_prev(line);
 114         }
 115
 116         buffer->current = (line) ? line : buffer->current;
 117
 118         if (opt->print_numbers)
 119                 action_print_selection(buffer, opt);
 120 }
 121
 122 /*
 123  * Send the selection to stdout.
 124  */
 125 void
 126 action_print_selection(Buffer *buffer, Opt *opt)
 127 {
 128         fputs("\r\033[K", stderr);
 129
 130         if (opt->print_numbers) {
 131                 printf("%d\n", buffer->current->number);
 132         } else {
 133                 if (opt->complete) {
 134                         puts(buffer->input);
 135                 } else {
 136                         puts(buffer->current->content);
 137                 }
 138         }
 139 }
 140
 141 /*
 142  * Remove the last word from the buffer's input
 143  */
 144 void
 145 action_remove_word_input(Buffer *buffer)
 146 {
 147         size_t length = strlen(buffer->input) - 1;
 148         int i;
 149
 150         for (i = length; i >= 0 && isspace(buffer->input[i]); i--) {
 151                 buffer->input[i] = '\0';
 152         }
 153
 154         length = strlen(buffer->input) - 1;
 155         for (i = length; i >= 0 && !isspace(buffer->input[i]); i--) {
 156                 buffer->input[i] = '\0';
 157         }
 158 }
 159
 160 /*
 161  * Add a character to the buffer input and filter lines again.
 162  */
 163 void
 164 action_add_character(Buffer *buffer, char key, Opt *opt)
 165 {
 166         size_t length = strlen(buffer->input);
 167
 168         if (isprint(key)) {
 169                 buffer->input[length]     = key;
 170                 buffer->input[length + 1] = '\0';
 171         }
 172
 173         filter_lines(buffer, opt);
 174
 175         if (!buffer->current->matches) {
 176                 action_jump(buffer, BOTH, opt);
 177         }
 178
 179         if (!buffer->current->matches) {
 180                 buffer->current = buffer->empty;
 181         }
 182 }