source: mainline/uspace/lib/clui/tinput.c@ c9d011e4

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

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