source: mainline/uspace/lib/clui/tinput.c@ 2add9ec

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 2add9ec was be61b8f, checked in by Martin Sucha <sucha14@…>, 14 years ago

Display completion options in column format
  • Property mode set to 100644
File size: 20.3 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
593/* Print a list of completions */
594static void tinput_show_completions(tinput_t *ti, char **compl, size_t cnum)
595{
596 unsigned int i;
597 /* Determine the maximum length of the completion in chars */
598 size_t max_length = 0;
599 for (i = 0; i < cnum; i++)
600 max_length = max(max_length, str_length(compl[i]));
601
602 unsigned int cols = max(1, (ti->con_cols + 1) / (max_length + 1));
603 unsigned int col_width = ti->con_cols / cols;
604 unsigned int rows = cnum / cols + ((cnum % cols) != 0);
605
606 unsigned int row, col;
607
608 for (row = 0; row < rows; row++) {
609 bool wlc = false;
610 for (col = 0; col < cols; col++) {
611 size_t compl_idx = col * rows + row;
612 if (compl_idx >= cnum)
613 break;
614 if (col)
615 printf(" ");
616 printf("%s", compl[compl_idx]);
617 size_t compl_len = str_length(compl[compl_idx]);
618 if (col == cols -1) {
619 wlc = (compl_len == max_length);
620 }
621 else {
622 for (i = compl_len; i < col_width; i++) {
623 printf(" ");
624 }
625 }
626 }
627 if (!wlc) printf("\n");
628 }
629}
630
631
632static void tinput_text_complete(tinput_t *ti)
633{
634 void *state;
635 size_t cstart;
636 char *ctmp;
637 char **compl; /* Array of completions */
638 size_t compl_len; /* Current length of @c compl array */
639 size_t cnum;
640 size_t i;
641 int rc;
642
643 if (ti->compl_ops == NULL)
644 return;
645
646 /*
647 * Obtain list of all possible completions (growing array).
648 */
649
650 rc = (*ti->compl_ops->init)(ti->buffer, ti->pos, &cstart, &state);
651 if (rc != EOK)
652 return;
653
654 cnum = 0;
655
656 compl_len = 1;
657 compl = malloc(compl_len * sizeof(char *));
658 if (compl == NULL) {
659 printf("Error: Out of memory.\n");
660 return;
661 }
662
663 while (true) {
664 rc = (*ti->compl_ops->get_next)(state, &ctmp);
665 if (rc != EOK)
666 break;
667
668 if (cnum >= compl_len) {
669 /* Extend array */
670 compl_len = 2 * compl_len;
671 compl = realloc(compl, compl_len * sizeof(char *));
672 if (compl == NULL) {
673 printf("Error: Out of memory.\n");
674 break;
675 }
676 }
677
678 compl[cnum] = str_dup(ctmp);
679 if (compl[cnum] == NULL) {
680 printf("Error: Out of memory.\n");
681 break;
682 }
683 cnum++;
684 }
685
686 (*ti->compl_ops->fini)(state);
687
688 if (cnum > 1) {
689 /*
690 * More than one match. Determine maximum common prefix.
691 */
692 size_t cplen;
693
694 cplen = str_length(compl[0]);
695 for (i = 1; i < cnum; i++)
696 cplen = min(cplen, common_pref_len(compl[0], compl[i]));
697
698 /* Compute how many bytes we should skip. */
699 size_t istart = str_lsize(compl[0], ti->pos - cstart);
700
701 if (cplen > istart) {
702 /* Insert common prefix. */
703
704 /* Copy remainder of common prefix. */
705 char *cpref = str_ndup(compl[0] + istart,
706 str_lsize(compl[0], cplen - istart));
707
708 /* Insert it. */
709 tinput_insert_string(ti, cpref);
710 free(cpref);
711 } else {
712 /* No common prefix. Sort and display all entries. */
713
714 qsort(compl, cnum, sizeof(char *), compl_cmp, NULL);
715
716 tinput_jump_after(ti);
717 tinput_show_completions(ti, compl, cnum);
718 tinput_display(ti);
719 }
720 } else if (cnum == 1) {
721 /*
722 * We have exactly one match. Insert it.
723 */
724
725 /* Compute how many bytes of completion string we should skip. */
726 size_t istart = str_lsize(compl[0], ti->pos - cstart);
727
728 /* Insert remainder of completion string at current position. */
729 tinput_insert_string(ti, compl[0] + istart);
730 }
731
732 for (i = 0; i < cnum; i++)
733 free(compl[i]);
734 free(compl);
735}
736
737/** Initialize text input field.
738 *
739 * Must be called before using the field. It clears the history.
740 */
741static void tinput_init(tinput_t *ti)
742{
743 ti->console = console_init(stdin, stdout);
744 ti->hnum = 0;
745 ti->hpos = 0;
746 ti->history[0] = NULL;
747}
748
749/** Set prompt string.
750 *
751 * @param ti Text input
752 * @param prompt Prompt string
753 *
754 * @return EOK on success, ENOMEM if out of memory.
755 */
756int tinput_set_prompt(tinput_t *ti, const char *prompt)
757{
758 if (ti->prompt != NULL)
759 free(ti->prompt);
760
761 ti->prompt = str_dup(prompt);
762 if (ti->prompt == NULL)
763 return ENOMEM;
764
765 return EOK;
766}
767
768/** Set completion ops.
769 *
770 * Set pointer to completion ops structure that will be used for text
771 * completion.
772 */
773void tinput_set_compl_ops(tinput_t *ti, tinput_compl_ops_t *compl_ops)
774{
775 ti->compl_ops = compl_ops;
776}
777
778/** Read in one line of input.
779 *
780 * @param ti Text input.
781 * @param dstr Place to save pointer to new string.
782 *
783 * @return EOK on success
784 * @return ENOENT if user requested abort
785 * @return EIO if communication with console failed
786 *
787 */
788int tinput_read(tinput_t *ti, char **dstr)
789{
790 console_flush(ti->console);
791 if (console_get_size(ti->console, &ti->con_cols, &ti->con_rows) != EOK)
792 return EIO;
793
794 ti->pos = 0;
795 ti->sel_start = 0;
796 ti->nc = 0;
797 ti->buffer[0] = '\0';
798 ti->done = false;
799 ti->exit_clui = false;
800
801 if (tinput_display(ti) != EOK)
802 return EIO;
803
804 while (!ti->done) {
805 console_flush(ti->console);
806
807 kbd_event_t ev;
808 if (!console_get_kbd_event(ti->console, &ev))
809 return EIO;
810
811 if (ev.type != KEY_PRESS)
812 continue;
813
814 if (((ev.mods & KM_CTRL) != 0) &&
815 ((ev.mods & (KM_ALT | KM_SHIFT)) == 0))
816 tinput_key_ctrl(ti, &ev);
817
818 if (((ev.mods & KM_SHIFT) != 0) &&
819 ((ev.mods & (KM_CTRL | KM_ALT)) == 0))
820 tinput_key_shift(ti, &ev);
821
822 if (((ev.mods & KM_CTRL) != 0) &&
823 ((ev.mods & KM_SHIFT) != 0) &&
824 ((ev.mods & KM_ALT) == 0))
825 tinput_key_ctrl_shift(ti, &ev);
826
827 if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0)
828 tinput_key_unmod(ti, &ev);
829
830 if (ev.c >= ' ') {
831 tinput_sel_delete(ti);
832 tinput_insert_char(ti, ev.c);
833 }
834 }
835
836 if (ti->exit_clui)
837 return ENOENT;
838
839 ti->pos = ti->nc;
840 tinput_position_caret(ti);
841 putchar('\n');
842
843 char *str = tinput_get_str(ti);
844 if (str_cmp(str, "") != 0)
845 tinput_history_insert(ti, str);
846
847 ti->hpos = 0;
848
849 *dstr = str;
850 return EOK;
851}
852
853static void tinput_key_ctrl(tinput_t *ti, kbd_event_t *ev)
854{
855 switch (ev->key) {
856 case KC_LEFT:
857 tinput_seek_word(ti, seek_backward, false);
858 break;
859 case KC_RIGHT:
860 tinput_seek_word(ti, seek_forward, false);
861 break;
862 case KC_UP:
863 tinput_seek_vertical(ti, seek_backward, false);
864 break;
865 case KC_DOWN:
866 tinput_seek_vertical(ti, seek_forward, false);
867 break;
868 case KC_X:
869 tinput_sel_copy_to_cb(ti);
870 tinput_sel_delete(ti);
871 break;
872 case KC_C:
873 tinput_sel_copy_to_cb(ti);
874 break;
875 case KC_V:
876 tinput_sel_delete(ti);
877 tinput_paste_from_cb(ti);
878 break;
879 case KC_A:
880 tinput_sel_all(ti);
881 break;
882 case KC_Q:
883 /* Signal libary client to quit interactive loop. */
884 ti->done = true;
885 ti->exit_clui = true;
886 break;
887 default:
888 break;
889 }
890}
891
892static void tinput_key_ctrl_shift(tinput_t *ti, kbd_event_t *ev)
893{
894 switch (ev->key) {
895 case KC_LEFT:
896 tinput_seek_word(ti, seek_backward, true);
897 break;
898 case KC_RIGHT:
899 tinput_seek_word(ti, seek_forward, true);
900 break;
901 case KC_UP:
902 tinput_seek_vertical(ti, seek_backward, true);
903 break;
904 case KC_DOWN:
905 tinput_seek_vertical(ti, seek_forward, true);
906 break;
907 default:
908 break;
909 }
910}
911
912static void tinput_key_shift(tinput_t *ti, kbd_event_t *ev)
913{
914 switch (ev->key) {
915 case KC_LEFT:
916 tinput_seek_cell(ti, seek_backward, true);
917 break;
918 case KC_RIGHT:
919 tinput_seek_cell(ti, seek_forward, true);
920 break;
921 case KC_UP:
922 tinput_seek_vertical(ti, seek_backward, true);
923 break;
924 case KC_DOWN:
925 tinput_seek_vertical(ti, seek_forward, true);
926 break;
927 case KC_HOME:
928 tinput_seek_max(ti, seek_backward, true);
929 break;
930 case KC_END:
931 tinput_seek_max(ti, seek_forward, true);
932 break;
933 default:
934 break;
935 }
936}
937
938static void tinput_key_unmod(tinput_t *ti, kbd_event_t *ev)
939{
940 switch (ev->key) {
941 case KC_ENTER:
942 case KC_NENTER:
943 ti->done = true;
944 break;
945 case KC_BACKSPACE:
946 tinput_backspace(ti);
947 break;
948 case KC_DELETE:
949 tinput_delete(ti);
950 break;
951 case KC_LEFT:
952 tinput_seek_cell(ti, seek_backward, false);
953 break;
954 case KC_RIGHT:
955 tinput_seek_cell(ti, seek_forward, false);
956 break;
957 case KC_HOME:
958 tinput_seek_max(ti, seek_backward, false);
959 break;
960 case KC_END:
961 tinput_seek_max(ti, seek_forward, false);
962 break;
963 case KC_UP:
964 tinput_history_seek(ti, 1);
965 break;
966 case KC_DOWN:
967 tinput_history_seek(ti, -1);
968 break;
969 case KC_TAB:
970 tinput_text_complete(ti);
971 break;
972 default:
973 break;
974 }
975}
Note: See TracBrowser for help on using the repository browser.