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