source: mainline/uspace/lib/clui/tinput.c@ 9be9c4d

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 9be9c4d was 9be9c4d, checked in by Jiri Svoboda <jiri@…>, 14 years ago

Shell command and file-name completion.
  • Property mode set to 100644
File size: 19.4 KB
Line 
1/*
2 * Copyright (c) 2011 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sort.h>
30#include <stdio.h>
31#include <stdlib.h>
32#include <str.h>
33#include <io/console.h>
34#include <io/keycode.h>
35#include <io/style.h>
36#include <io/color.h>
37#include <vfs/vfs.h>
38#include <clipboard.h>
39#include <macros.h>
40#include <errno.h>
41#include <assert.h>
42#include <bool.h>
43#include <tinput.h>
44
45#define LIN_TO_COL(ti, lpos) ((lpos) % ((ti)->con_cols))
46#define LIN_TO_ROW(ti, lpos) ((lpos) / ((ti)->con_cols))
47
48/** Seek direction */
49typedef enum {
50 seek_backward = -1,
51 seek_forward = 1
52} seek_dir_t;
53
54static void tinput_init(tinput_t *);
55static void tinput_insert_string(tinput_t *, const char *);
56static void tinput_sel_get_bounds(tinput_t *, size_t *, size_t *);
57static bool tinput_sel_active(tinput_t *);
58static void tinput_sel_all(tinput_t *);
59static void tinput_sel_delete(tinput_t *);
60static void tinput_key_ctrl(tinput_t *, kbd_event_t *);
61static void tinput_key_shift(tinput_t *, kbd_event_t *);
62static void tinput_key_ctrl_shift(tinput_t *, kbd_event_t *);
63static void tinput_key_unmod(tinput_t *, kbd_event_t *);
64static void tinput_pre_seek(tinput_t *, bool);
65static void tinput_post_seek(tinput_t *, bool);
66
67static void tinput_console_set_lpos(tinput_t *ti, unsigned lpos)
68{
69 console_set_pos(ti->console, LIN_TO_COL(ti, lpos),
70 LIN_TO_ROW(ti, lpos));
71}
72
73/** Create a new text input field. */
74tinput_t *tinput_new(void)
75{
76 tinput_t *ti;
77
78 ti = calloc(1, sizeof(tinput_t));
79 if (ti == NULL)
80 return NULL;
81
82 tinput_init(ti);
83 return ti;
84}
85
86/** Destroy text input field. */
87void tinput_destroy(tinput_t *ti)
88{
89 if (ti->prompt != NULL)
90 free(ti->prompt);
91 free(ti);
92}
93
94static void tinput_display_prompt(tinput_t *ti)
95{
96 tinput_console_set_lpos(ti, ti->prompt_coord);
97
98 console_set_style(ti->console, STYLE_EMPHASIS);
99 printf("%s", ti->prompt);
100 console_flush(ti->console);
101 console_set_style(ti->console, STYLE_NORMAL);
102}
103
104static void tinput_display_tail(tinput_t *ti, size_t start, size_t pad)
105{
106 wchar_t dbuf[INPUT_MAX_SIZE + 1];
107
108 size_t sa;
109 size_t sb;
110 tinput_sel_get_bounds(ti, &sa, &sb);
111
112 tinput_console_set_lpos(ti, ti->text_coord + start);
113 console_set_style(ti->console, STYLE_NORMAL);
114
115 size_t p = start;
116 if (p < sa) {
117 memcpy(dbuf, ti->buffer + p, (sa - p) * sizeof(wchar_t));
118 dbuf[sa - p] = '\0';
119 printf("%ls", dbuf);
120 p = sa;
121 }
122
123 if (p < sb) {
124 console_flush(ti->console);
125 console_set_style(ti->console, STYLE_SELECTED);
126
127 memcpy(dbuf, ti->buffer + p,
128 (sb - p) * sizeof(wchar_t));
129 dbuf[sb - p] = '\0';
130 printf("%ls", dbuf);
131 p = sb;
132 }
133
134 console_flush(ti->console);
135 console_set_style(ti->console, STYLE_NORMAL);
136
137 if (p < ti->nc) {
138 memcpy(dbuf, ti->buffer + p,
139 (ti->nc - p) * sizeof(wchar_t));
140 dbuf[ti->nc - p] = '\0';
141 printf("%ls", dbuf);
142 }
143
144 for (p = 0; p < pad; p++)
145 putchar(' ');
146
147 console_flush(ti->console);
148}
149
150static char *tinput_get_str(tinput_t *ti)
151{
152 return wstr_to_astr(ti->buffer);
153}
154
155static void tinput_position_caret(tinput_t *ti)
156{
157 tinput_console_set_lpos(ti, ti->text_coord + ti->pos);
158}
159
160/** Update text_coord, prompt_coord in case the screen could have scrolled. */
161static void tinput_update_origin(tinput_t *ti)
162{
163 unsigned end_coord = ti->text_coord + ti->nc;
164 unsigned end_row = LIN_TO_ROW(ti, end_coord);
165
166 unsigned scroll_rows;
167
168 /* Update coords if the screen scrolled. */
169 if (end_row >= ti->con_rows) {
170 scroll_rows = end_row - ti->con_rows + 1;
171 ti->text_coord -= ti->con_cols * scroll_rows;
172 ti->prompt_coord -= ti->con_cols * scroll_rows;
173 }
174}
175
176static void tinput_jump_after(tinput_t *ti)
177{
178 tinput_console_set_lpos(ti, ti->text_coord + ti->nc);
179 console_flush(ti->console);
180 putchar('\n');
181}
182
183static int tinput_display(tinput_t *ti)
184{
185 sysarg_t col0, row0;
186
187 if (console_get_pos(ti->console, &col0, &row0) != EOK)
188 return EIO;
189
190 ti->prompt_coord = row0 * ti->con_cols + col0;
191 ti->text_coord = ti->prompt_coord + str_length(ti->prompt);
192
193 tinput_display_prompt(ti);
194 tinput_display_tail(ti, 0, 0);
195 tinput_position_caret(ti);
196
197 return EOK;
198}
199
200static void tinput_insert_char(tinput_t *ti, wchar_t c)
201{
202 if (ti->nc == INPUT_MAX_SIZE)
203 return;
204
205 unsigned new_width = LIN_TO_COL(ti, ti->text_coord) + ti->nc + 1;
206 if (new_width % ti->con_cols == 0) {
207 /* Advancing to new line. */
208 sysarg_t new_height = (new_width / ti->con_cols) + 1;
209 if (new_height >= ti->con_rows) {
210 /* Disallow text longer than 1 page for now. */
211 return;
212 }
213 }
214
215 size_t i;
216 for (i = ti->nc; i > ti->pos; i--)
217 ti->buffer[i] = ti->buffer[i - 1];
218
219 ti->buffer[ti->pos] = c;
220 ti->pos += 1;
221 ti->nc += 1;
222 ti->buffer[ti->nc] = '\0';
223 ti->sel_start = ti->pos;
224
225 tinput_display_tail(ti, ti->pos - 1, 0);
226 tinput_update_origin(ti);
227 tinput_position_caret(ti);
228}
229
230static void tinput_insert_string(tinput_t *ti, const char *str)
231{
232 size_t ilen = min(str_length(str), INPUT_MAX_SIZE - ti->nc);
233 if (ilen == 0)
234 return;
235
236 unsigned new_width = LIN_TO_COL(ti, ti->text_coord) + ti->nc + ilen;
237 unsigned new_height = (new_width / ti->con_cols) + 1;
238 if (new_height >= ti->con_rows) {
239 /* Disallow text longer than 1 page for now. */
240 return;
241 }
242
243 if (ti->nc > 0) {
244 size_t i;
245 for (i = ti->nc; i > ti->pos; i--)
246 ti->buffer[i + ilen - 1] = ti->buffer[i - 1];
247 }
248
249 size_t off = 0;
250 size_t i = 0;
251 while (i < ilen) {
252 wchar_t c = str_decode(str, &off, STR_NO_LIMIT);
253 if (c == '\0')
254 break;
255
256 /* Filter out non-printable chars. */
257 if (c < 32)
258 c = 32;
259
260 ti->buffer[ti->pos + i] = c;
261 i++;
262 }
263
264 ti->pos += ilen;
265 ti->nc += ilen;
266 ti->buffer[ti->nc] = '\0';
267 ti->sel_start = ti->pos;
268
269 tinput_display_tail(ti, ti->pos - ilen, 0);
270 tinput_update_origin(ti);
271 tinput_position_caret(ti);
272}
273
274static void tinput_backspace(tinput_t *ti)
275{
276 if (tinput_sel_active(ti)) {
277 tinput_sel_delete(ti);
278 return;
279 }
280
281 if (ti->pos == 0)
282 return;
283
284 size_t i;
285 for (i = ti->pos; i < ti->nc; i++)
286 ti->buffer[i - 1] = ti->buffer[i];
287
288 ti->pos -= 1;
289 ti->nc -= 1;
290 ti->buffer[ti->nc] = '\0';
291 ti->sel_start = ti->pos;
292
293 tinput_display_tail(ti, ti->pos, 1);
294 tinput_position_caret(ti);
295}
296
297static void tinput_delete(tinput_t *ti)
298{
299 if (tinput_sel_active(ti)) {
300 tinput_sel_delete(ti);
301 return;
302 }
303
304 if (ti->pos == ti->nc)
305 return;
306
307 ti->pos += 1;
308 ti->sel_start = ti->pos;
309
310 tinput_backspace(ti);
311}
312
313static void tinput_seek_cell(tinput_t *ti, seek_dir_t dir, bool shift_held)
314{
315 tinput_pre_seek(ti, shift_held);
316
317 if (dir == seek_forward) {
318 if (ti->pos < ti->nc)
319 ti->pos += 1;
320 } else {
321 if (ti->pos > 0)
322 ti->pos -= 1;
323 }
324
325 tinput_post_seek(ti, shift_held);
326}
327
328static void tinput_seek_word(tinput_t *ti, seek_dir_t dir, bool shift_held)
329{
330 tinput_pre_seek(ti, shift_held);
331
332 if (dir == seek_forward) {
333 if (ti->pos == ti->nc)
334 return;
335
336 while (true) {
337 ti->pos += 1;
338
339 if (ti->pos == ti->nc)
340 break;
341
342 if ((ti->buffer[ti->pos - 1] == ' ') &&
343 (ti->buffer[ti->pos] != ' '))
344 break;
345 }
346 } else {
347 if (ti->pos == 0)
348 return;
349
350 while (true) {
351 ti->pos -= 1;
352
353 if (ti->pos == 0)
354 break;
355
356 if (ti->buffer[ti->pos - 1] == ' ' &&
357 ti->buffer[ti->pos] != ' ')
358 break;
359 }
360
361 }
362
363 tinput_post_seek(ti, shift_held);
364}
365
366static void tinput_seek_vertical(tinput_t *ti, seek_dir_t dir, bool shift_held)
367{
368 tinput_pre_seek(ti, shift_held);
369
370 if (dir == seek_forward) {
371 if (ti->pos + ti->con_cols <= ti->nc)
372 ti->pos = ti->pos + ti->con_cols;
373 } else {
374 if (ti->pos >= ti->con_cols)
375 ti->pos = ti->pos - ti->con_cols;
376 }
377
378 tinput_post_seek(ti, shift_held);
379}
380
381static void tinput_seek_max(tinput_t *ti, seek_dir_t dir, bool shift_held)
382{
383 tinput_pre_seek(ti, shift_held);
384
385 if (dir == seek_backward)
386 ti->pos = 0;
387 else
388 ti->pos = ti->nc;
389
390 tinput_post_seek(ti, shift_held);
391}
392
393static void tinput_pre_seek(tinput_t *ti, bool shift_held)
394{
395 if ((tinput_sel_active(ti)) && (!shift_held)) {
396 /* Unselect and redraw. */
397 ti->sel_start = ti->pos;
398 tinput_display_tail(ti, 0, 0);
399 tinput_position_caret(ti);
400 }
401}
402
403static void tinput_post_seek(tinput_t *ti, bool shift_held)
404{
405 if (shift_held) {
406 /* Selecting text. Need redraw. */
407 tinput_display_tail(ti, 0, 0);
408 } else {
409 /* Shift not held. Keep selection empty. */
410 ti->sel_start = ti->pos;
411 }
412
413 tinput_position_caret(ti);
414}
415
416static void tinput_history_insert(tinput_t *ti, char *str)
417{
418 if (ti->hnum < HISTORY_LEN) {
419 ti->hnum += 1;
420 } else {
421 if (ti->history[HISTORY_LEN] != NULL)
422 free(ti->history[HISTORY_LEN]);
423 }
424
425 size_t i;
426 for (i = ti->hnum; i > 1; i--)
427 ti->history[i] = ti->history[i - 1];
428
429 ti->history[1] = str_dup(str);
430
431 if (ti->history[0] != NULL) {
432 free(ti->history[0]);
433 ti->history[0] = NULL;
434 }
435}
436
437static void tinput_set_str(tinput_t *ti, char *str)
438{
439 str_to_wstr(ti->buffer, INPUT_MAX_SIZE, str);
440 ti->nc = wstr_length(ti->buffer);
441 ti->pos = ti->nc;
442 ti->sel_start = ti->pos;
443}
444
445static void tinput_sel_get_bounds(tinput_t *ti, size_t *sa, size_t *sb)
446{
447 if (ti->sel_start < ti->pos) {
448 *sa = ti->sel_start;
449 *sb = ti->pos;
450 } else {
451 *sa = ti->pos;
452 *sb = ti->sel_start;
453 }
454}
455
456static bool tinput_sel_active(tinput_t *ti)
457{
458 return (ti->sel_start != ti->pos);
459}
460
461static void tinput_sel_all(tinput_t *ti)
462{
463 ti->sel_start = 0;
464 ti->pos = ti->nc;
465 tinput_display_tail(ti, 0, 0);
466 tinput_position_caret(ti);
467}
468
469static void tinput_sel_delete(tinput_t *ti)
470{
471 size_t sa;
472 size_t sb;
473
474 tinput_sel_get_bounds(ti, &sa, &sb);
475 if (sa == sb)
476 return;
477
478 memmove(ti->buffer + sa, ti->buffer + sb,
479 (ti->nc - sb) * sizeof(wchar_t));
480
481 ti->pos = ti->sel_start = sa;
482 ti->nc -= (sb - sa);
483 ti->buffer[ti->nc] = '\0';
484
485 tinput_display_tail(ti, sa, sb - sa);
486 tinput_position_caret(ti);
487}
488
489static void tinput_sel_copy_to_cb(tinput_t *ti)
490{
491 size_t sa;
492 size_t sb;
493
494 tinput_sel_get_bounds(ti, &sa, &sb);
495
496 char *str;
497
498 if (sb < ti->nc) {
499 wchar_t tmp_c = ti->buffer[sb];
500 ti->buffer[sb] = '\0';
501 str = wstr_to_astr(ti->buffer + sa);
502 ti->buffer[sb] = tmp_c;
503 } else
504 str = wstr_to_astr(ti->buffer + sa);
505
506 if (str == NULL)
507 goto error;
508
509 if (clipboard_put_str(str) != EOK)
510 goto error;
511
512 free(str);
513 return;
514
515error:
516 /* TODO: Give the user some kind of warning. */
517 return;
518}
519
520static void tinput_paste_from_cb(tinput_t *ti)
521{
522 char *str;
523 int rc = clipboard_get_str(&str);
524
525 if ((rc != EOK) || (str == NULL)) {
526 /* TODO: Give the user some kind of warning. */
527 return;
528 }
529
530 tinput_insert_string(ti, str);
531 free(str);
532}
533
534static void tinput_history_seek(tinput_t *ti, int offs)
535{
536 if (offs >= 0) {
537 if (ti->hpos + offs > ti->hnum)
538 return;
539 } else {
540 if (ti->hpos < (size_t) -offs)
541 return;
542 }
543
544 if (ti->history[ti->hpos] != NULL) {
545 free(ti->history[ti->hpos]);
546 ti->history[ti->hpos] = NULL;
547 }
548
549 ti->history[ti->hpos] = tinput_get_str(ti);
550 ti->hpos += offs;
551
552 int pad = (int) ti->nc - str_length(ti->history[ti->hpos]);
553 if (pad < 0)
554 pad = 0;
555
556 tinput_set_str(ti, ti->history[ti->hpos]);
557 tinput_display_tail(ti, 0, pad);
558 tinput_update_origin(ti);
559 tinput_position_caret(ti);
560}
561
562/** Compare two entries in array of completions. */
563static int compl_cmp(void *va, void *vb, void *arg)
564{
565 const char *a = *(const char **) va;
566 const char *b = *(const char **) vb;
567
568 return str_cmp(a, b);
569}
570
571static size_t common_pref_len(const char *a, const char *b)
572{
573 size_t i;
574 size_t a_off, b_off;
575 wchar_t ca, cb;
576
577 i = 0;
578 a_off = 0;
579 b_off = 0;
580
581 while (true) {
582 ca = str_decode(a, &a_off, STR_NO_LIMIT);
583 cb = str_decode(b, &b_off, STR_NO_LIMIT);
584
585 if (ca == '\0' || cb == '\0' || ca != cb)
586 break;
587 ++i;
588 }
589
590 return i;
591}
592
593static void tinput_text_complete(tinput_t *ti)
594{
595 void *state;
596 size_t cstart;
597 char *ctmp;
598 char **compl; /* Array of completions */
599 size_t compl_len; /* Current length of @c compl array */
600 size_t cnum;
601 size_t i;
602 int rc;
603
604 if (ti->compl_ops == NULL)
605 return;
606
607 /*
608 * Obtain list of all possible completions (growing array).
609 */
610
611 rc = (*ti->compl_ops->init)(ti->buffer, ti->pos, &cstart, &state);
612 if (rc != EOK)
613 return;
614
615 cnum = 0;
616
617 compl_len = 1;
618 compl = malloc(compl_len * sizeof(char *));
619 if (compl == NULL) {
620 printf("Error: Out of memory.\n");
621 return;
622 }
623
624 while (true) {
625 rc = (*ti->compl_ops->get_next)(state, &ctmp);
626 if (rc != EOK)
627 break;
628
629 if (cnum >= compl_len) {
630 /* Extend array */
631 compl_len = 2 * compl_len;
632 compl = realloc(compl, compl_len * sizeof(char *));
633 if (compl == NULL) {
634 printf("Error: Out of memory.\n");
635 break;
636 }
637 }
638
639 compl[cnum] = str_dup(ctmp);
640 if (compl[cnum] == NULL) {
641 printf("Error: Out of memory.\n");
642 break;
643 }
644 cnum++;
645 }
646
647 (*ti->compl_ops->fini)(state);
648
649 if (cnum > 1) {
650 /*
651 * More than one match. Determine maximum common prefix.
652 */
653 size_t cplen;
654
655 cplen = str_length(compl[0]);
656 for (i = 1; i < cnum; i++)
657 cplen = min(cplen, common_pref_len(compl[0], compl[i]));
658
659 /* Compute how many bytes we should skip. */
660 size_t istart = str_lsize(compl[0], ti->pos - cstart);
661
662 if (cplen > istart) {
663 /* Insert common prefix. */
664
665 /* Copy remainder of common prefix. */
666 char *cpref = str_ndup(compl[0] + istart,
667 str_lsize(compl[0], cplen - istart));
668
669 /* Insert it. */
670 tinput_insert_string(ti, cpref);
671 free(cpref);
672 } else {
673 /* No common prefix. Sort and display all entries. */
674
675 qsort(compl, cnum, sizeof(char *), compl_cmp, NULL);
676
677 tinput_jump_after(ti);
678 for (i = 0; i < cnum; i++)
679 printf("%s\n", compl[i]);
680 tinput_display(ti);
681 }
682 } else if (cnum == 1) {
683 /*
684 * We have exactly one match. Insert it.
685 */
686
687 /* Compute how many bytes of completion string we should skip. */
688 size_t istart = str_lsize(compl[0], ti->pos - cstart);
689
690 /* Insert remainder of completion string at current position. */
691 tinput_insert_string(ti, compl[0] + istart);
692 }
693
694 for (i = 0; i < cnum; i++)
695 free(compl[i]);
696 free(compl);
697}
698
699/** Initialize text input field.
700 *
701 * Must be called before using the field. It clears the history.
702 */
703static void tinput_init(tinput_t *ti)
704{
705 ti->console = console_init(stdin, stdout);
706 ti->hnum = 0;
707 ti->hpos = 0;
708 ti->history[0] = NULL;
709}
710
711/** Set prompt string.
712 *
713 * @param ti Text input
714 * @param prompt Prompt string
715 *
716 * @return EOK on success, ENOMEM if out of memory.
717 */
718int tinput_set_prompt(tinput_t *ti, const char *prompt)
719{
720 if (ti->prompt != NULL)
721 free(ti->prompt);
722
723 ti->prompt = str_dup(prompt);
724 if (ti->prompt == NULL)
725 return ENOMEM;
726
727 return EOK;
728}
729
730/** Set completion ops.
731 *
732 * Set pointer to completion ops structure that will be used for text
733 * completion.
734 */
735void tinput_set_compl_ops(tinput_t *ti, tinput_compl_ops_t *compl_ops)
736{
737 ti->compl_ops = compl_ops;
738}
739
740/** Read in one line of input.
741 *
742 * @param ti Text input.
743 * @param dstr Place to save pointer to new string.
744 *
745 * @return EOK on success
746 * @return ENOENT if user requested abort
747 * @return EIO if communication with console failed
748 *
749 */
750int tinput_read(tinput_t *ti, char **dstr)
751{
752 console_flush(ti->console);
753 if (console_get_size(ti->console, &ti->con_cols, &ti->con_rows) != EOK)
754 return EIO;
755
756 ti->pos = 0;
757 ti->sel_start = 0;
758 ti->nc = 0;
759 ti->buffer[0] = '\0';
760 ti->done = false;
761 ti->exit_clui = false;
762
763 if (tinput_display(ti) != EOK)
764 return EIO;
765
766 while (!ti->done) {
767 console_flush(ti->console);
768
769 kbd_event_t ev;
770 if (!console_get_kbd_event(ti->console, &ev))
771 return EIO;
772
773 if (ev.type != KEY_PRESS)
774 continue;
775
776 if (((ev.mods & KM_CTRL) != 0) &&
777 ((ev.mods & (KM_ALT | KM_SHIFT)) == 0))
778 tinput_key_ctrl(ti, &ev);
779
780 if (((ev.mods & KM_SHIFT) != 0) &&
781 ((ev.mods & (KM_CTRL | KM_ALT)) == 0))
782 tinput_key_shift(ti, &ev);
783
784 if (((ev.mods & KM_CTRL) != 0) &&
785 ((ev.mods & KM_SHIFT) != 0) &&
786 ((ev.mods & KM_ALT) == 0))
787 tinput_key_ctrl_shift(ti, &ev);
788
789 if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0)
790 tinput_key_unmod(ti, &ev);
791
792 if (ev.c >= ' ') {
793 tinput_sel_delete(ti);
794 tinput_insert_char(ti, ev.c);
795 }
796 }
797
798 if (ti->exit_clui)
799 return ENOENT;
800
801 ti->pos = ti->nc;
802 tinput_position_caret(ti);
803 putchar('\n');
804
805 char *str = tinput_get_str(ti);
806 if (str_cmp(str, "") != 0)
807 tinput_history_insert(ti, str);
808
809 ti->hpos = 0;
810
811 *dstr = str;
812 return EOK;
813}
814
815static void tinput_key_ctrl(tinput_t *ti, kbd_event_t *ev)
816{
817 switch (ev->key) {
818 case KC_LEFT:
819 tinput_seek_word(ti, seek_backward, false);
820 break;
821 case KC_RIGHT:
822 tinput_seek_word(ti, seek_forward, false);
823 break;
824 case KC_UP:
825 tinput_seek_vertical(ti, seek_backward, false);
826 break;
827 case KC_DOWN:
828 tinput_seek_vertical(ti, seek_forward, false);
829 break;
830 case KC_X:
831 tinput_sel_copy_to_cb(ti);
832 tinput_sel_delete(ti);
833 break;
834 case KC_C:
835 tinput_sel_copy_to_cb(ti);
836 break;
837 case KC_V:
838 tinput_sel_delete(ti);
839 tinput_paste_from_cb(ti);
840 break;
841 case KC_A:
842 tinput_sel_all(ti);
843 break;
844 case KC_Q:
845 /* Signal libary client to quit interactive loop. */
846 ti->done = true;
847 ti->exit_clui = true;
848 break;
849 default:
850 break;
851 }
852}
853
854static void tinput_key_ctrl_shift(tinput_t *ti, kbd_event_t *ev)
855{
856 switch (ev->key) {
857 case KC_LEFT:
858 tinput_seek_word(ti, seek_backward, true);
859 break;
860 case KC_RIGHT:
861 tinput_seek_word(ti, seek_forward, true);
862 break;
863 case KC_UP:
864 tinput_seek_vertical(ti, seek_backward, true);
865 break;
866 case KC_DOWN:
867 tinput_seek_vertical(ti, seek_forward, true);
868 break;
869 default:
870 break;
871 }
872}
873
874static void tinput_key_shift(tinput_t *ti, kbd_event_t *ev)
875{
876 switch (ev->key) {
877 case KC_LEFT:
878 tinput_seek_cell(ti, seek_backward, true);
879 break;
880 case KC_RIGHT:
881 tinput_seek_cell(ti, seek_forward, true);
882 break;
883 case KC_UP:
884 tinput_seek_vertical(ti, seek_backward, true);
885 break;
886 case KC_DOWN:
887 tinput_seek_vertical(ti, seek_forward, true);
888 break;
889 case KC_HOME:
890 tinput_seek_max(ti, seek_backward, true);
891 break;
892 case KC_END:
893 tinput_seek_max(ti, seek_forward, true);
894 break;
895 default:
896 break;
897 }
898}
899
900static void tinput_key_unmod(tinput_t *ti, kbd_event_t *ev)
901{
902 switch (ev->key) {
903 case KC_ENTER:
904 case KC_NENTER:
905 ti->done = true;
906 break;
907 case KC_BACKSPACE:
908 tinput_backspace(ti);
909 break;
910 case KC_DELETE:
911 tinput_delete(ti);
912 break;
913 case KC_LEFT:
914 tinput_seek_cell(ti, seek_backward, false);
915 break;
916 case KC_RIGHT:
917 tinput_seek_cell(ti, seek_forward, false);
918 break;
919 case KC_HOME:
920 tinput_seek_max(ti, seek_backward, false);
921 break;
922 case KC_END:
923 tinput_seek_max(ti, seek_forward, false);
924 break;
925 case KC_UP:
926 tinput_history_seek(ti, 1);
927 break;
928 case KC_DOWN:
929 tinput_history_seek(ti, -1);
930 break;
931 case KC_TAB:
932 tinput_text_complete(ti);
933 break;
934 default:
935 break;
936 }
937}
Note: See TracBrowser for help on using the repository browser.