source: mainline/uspace/lib/clui/tinput.c@ 91ecaa10

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 91ecaa10 was 597b12e, checked in by Martin Sucha <sucha14@…>, 13 years ago

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