Changes in uspace/lib/clui/tinput.c [96b02eb9:be61b8f] in mainline

File:

• uspace/lib/clui/tinput.c (modified) (22 diffs)

uspace/lib/clui/tinput.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2010 Jiri Svoboda
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -27 +27 @@
  */
 
+#include <sort.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -42 +43 @@
 #include <tinput.h>
 
+#define LIN_TO_COL(ti, lpos) ((lpos) % ((ti)->con_cols))
+#define LIN_TO_ROW(ti, lpos) ((lpos) / ((ti)->con_cols))
+
 /** Seek direction */
 typedef enum {
@@ -54 +58 @@
 static void tinput_sel_all(tinput_t *);
 static void tinput_sel_delete(tinput_t *);
-static void tinput_key_ctrl(tinput_t *, console_event_t *);
-static void tinput_key_shift(tinput_t *, console_event_t *);
-static void tinput_key_ctrl_shift(tinput_t *, console_event_t *);
-static void tinput_key_unmod(tinput_t *, console_event_t *);
+static void tinput_key_ctrl(tinput_t *, kbd_event_t *);
+static void tinput_key_shift(tinput_t *, kbd_event_t *);
+static void tinput_key_ctrl_shift(tinput_t *, kbd_event_t *);
+static void tinput_key_unmod(tinput_t *, kbd_event_t *);
 static void tinput_pre_seek(tinput_t *, bool);
 static void tinput_post_seek(tinput_t *, bool);
 
+static void tinput_console_set_lpos(tinput_t *ti, unsigned lpos)
+{
+        console_set_pos(ti->console, LIN_TO_COL(ti, lpos),
+            LIN_TO_ROW(ti, lpos));
+}
+
 /** Create a new text input field. */
 tinput_t *tinput_new(void)
@@ -66 +76 @@
         tinput_t *ti;
         
-        ti = malloc(sizeof(tinput_t));
+        ti = calloc(1, sizeof(tinput_t));
         if (ti == NULL)
                 return NULL;
@@ -77 +87 @@
 void tinput_destroy(tinput_t *ti)
 {
+        if (ti->prompt != NULL)
+                free(ti->prompt);
         free(ti);
+}
+
+static void tinput_display_prompt(tinput_t *ti)
+{
+        tinput_console_set_lpos(ti, ti->prompt_coord);
+
+        console_set_style(ti->console, STYLE_EMPHASIS);
+        printf("%s", ti->prompt);
+        console_flush(ti->console);
+        console_set_style(ti->console, STYLE_NORMAL);
 }
 
@@ -88 +110 @@
         tinput_sel_get_bounds(ti, &sa, &sb);
         
-        console_set_pos(fphone(stdout), (ti->col0 + start) % ti->con_cols,
-            ti->row0 + (ti->col0 + start) / ti->con_cols);
-        console_set_style(fphone(stdout), STYLE_NORMAL);
+        tinput_console_set_lpos(ti, ti->text_coord + start);
+        console_set_style(ti->console, STYLE_NORMAL);
         
         size_t p = start;
@@ -101 +122 @@
         
         if (p < sb) {
-                fflush(stdout);
-                console_set_style(fphone(stdout), STYLE_SELECTED);
+                console_flush(ti->console);
+                console_set_style(ti->console, STYLE_SELECTED);
+                
                 memcpy(dbuf, ti->buffer + p,
                     (sb - p) * sizeof(wchar_t));
@@ -110 +132 @@
         }
         
-        fflush(stdout);
-        console_set_style(fphone(stdout), STYLE_NORMAL);
+        console_flush(ti->console);
+        console_set_style(ti->console, STYLE_NORMAL);
         
         if (p < ti->nc) {
@@ -123 +145 @@
                 putchar(' ');
         
-        fflush(stdout);
+        console_flush(ti->console);
 }
 
@@ -133 +155 @@
 static void tinput_position_caret(tinput_t *ti)
 {
-        console_set_pos(fphone(stdout), (ti->col0 + ti->pos) % ti->con_cols,
-            ti->row0 + (ti->col0 + ti->pos) / ti->con_cols);
-}
-
-/** Update row0 in case the screen could have scrolled. */
+        tinput_console_set_lpos(ti, ti->text_coord + ti->pos);
+}
+
+/** Update text_coord, prompt_coord in case the screen could have scrolled. */
 static void tinput_update_origin(tinput_t *ti)
 {
-        sysarg_t width = ti->col0 + ti->nc;
-        sysarg_t rows = (width / ti->con_cols) + 1;
-        
-        /* Update row0 if the screen scrolled. */
-        if (ti->row0 + rows > ti->con_rows)
-                ti->row0 = ti->con_rows - rows;
+        unsigned end_coord = ti->text_coord + ti->nc;
+        unsigned end_row = LIN_TO_ROW(ti, end_coord);
+
+        unsigned scroll_rows;
+
+        /* Update coords if the screen scrolled. */
+        if (end_row >= ti->con_rows) {
+                scroll_rows = end_row - ti->con_rows + 1;
+                ti->text_coord -= ti->con_cols * scroll_rows;
+                ti->prompt_coord -= ti->con_cols * scroll_rows;
+        }
+}
+
+static void tinput_jump_after(tinput_t *ti)
+{
+        tinput_console_set_lpos(ti, ti->text_coord + ti->nc);
+        console_flush(ti->console);
+        putchar('\n');
+}
+
+static int tinput_display(tinput_t *ti)
+{
+        sysarg_t col0, row0;
+        
+        if (console_get_pos(ti->console, &col0, &row0) != EOK)
+                return EIO;
+        
+        ti->prompt_coord = row0 * ti->con_cols + col0;
+        ti->text_coord = ti->prompt_coord + str_length(ti->prompt);
+
+        tinput_display_prompt(ti);
+        tinput_display_tail(ti, 0, 0);
+        tinput_position_caret(ti);
+
+        return EOK;
 }
 
@@ -153 +203 @@
                 return;
         
-        sysarg_t new_width = ti->col0 + ti->nc + 1;
+        unsigned new_width = LIN_TO_COL(ti, ti->text_coord) + ti->nc + 1;
         if (new_width % ti->con_cols == 0) {
                 /* Advancing to new line. */
@@ -184 +234 @@
                 return;
         
-        sysarg_t new_width = ti->col0 + ti->nc + ilen;
-        sysarg_t new_height = (new_width / ti->con_cols) + 1;
+        unsigned new_width = LIN_TO_COL(ti, ti->text_coord) + ti->nc + ilen;
+        unsigned new_height = (new_width / ti->con_cols) + 1;
         if (new_height >= ti->con_rows) {
                 /* Disallow text longer than 1 page for now. */
@@ -510 +560 @@
 }
 
+/** Compare two entries in array of completions. */
+static int compl_cmp(void *va, void *vb, void *arg)
+{
+        const char *a = *(const char **) va;
+        const char *b = *(const char **) vb;
+
+        return str_cmp(a, b);
+}
+
+static size_t common_pref_len(const char *a, const char *b)
+{
+        size_t i;
+        size_t a_off, b_off;
+        wchar_t ca, cb;
+
+        i = 0;
+        a_off = 0;
+        b_off = 0;
+
+        while (true) {
+                ca = str_decode(a, &a_off, STR_NO_LIMIT);
+                cb = str_decode(b, &b_off, STR_NO_LIMIT);
+
+                if (ca == '\0' || cb == '\0' || ca != cb)
+                        break;
+                ++i;
+        }
+
+        return i;
+}
+
+/* Print a list of completions */
+static void tinput_show_completions(tinput_t *ti, char **compl, size_t cnum)
+{
+        unsigned int i;
+        /* Determine the maximum length of the completion in chars */
+        size_t max_length = 0;
+        for (i = 0; i < cnum; i++)
+                max_length = max(max_length, str_length(compl[i]));
+        
+        unsigned int cols = max(1, (ti->con_cols + 1) / (max_length + 1));
+        unsigned int col_width = ti->con_cols / cols;
+        unsigned int rows = cnum / cols + ((cnum % cols) != 0);
+        
+        unsigned int row, col;
+        
+        for (row = 0; row < rows; row++) {
+                bool wlc = false;
+                for (col = 0; col < cols; col++) {
+                        size_t compl_idx = col * rows + row;
+                        if (compl_idx >= cnum)
+                                break;
+                        if (col)
+                                printf(" ");
+                        printf("%s", compl[compl_idx]);
+                        size_t compl_len = str_length(compl[compl_idx]);
+                        if (col == cols -1) {
+                                wlc = (compl_len == max_length);
+                        }
+                        else {
+                                for (i = compl_len; i < col_width; i++) {
+                                        printf(" ");
+                                }
+                        }
+                }
+                if (!wlc) printf("\n");
+        }
+}
+
+
+static void tinput_text_complete(tinput_t *ti)
+{
+        void *state;
+        size_t cstart;
+        char *ctmp;
+        char **compl;           /* Array of completions */
+        size_t compl_len;       /* Current length of @c compl array */
+        size_t cnum;
+        size_t i;
+        int rc;
+
+        if (ti->compl_ops == NULL)
+                return;
+
+        /*
+         * Obtain list of all possible completions (growing array).
+         */
+
+        rc = (*ti->compl_ops->init)(ti->buffer, ti->pos, &cstart, &state);
+        if (rc != EOK)
+                return;
+
+        cnum = 0;
+
+        compl_len = 1;
+        compl = malloc(compl_len * sizeof(char *));
+        if (compl == NULL) {
+                printf("Error: Out of memory.\n");
+                return;
+        }
+
+        while (true) {
+                rc = (*ti->compl_ops->get_next)(state, &ctmp);
+                if (rc != EOK)
+                        break;
+
+                if (cnum >= compl_len) {
+                        /* Extend array */
+                        compl_len = 2 * compl_len;
+                        compl = realloc(compl, compl_len * sizeof(char *));
+                        if (compl == NULL) {
+                                printf("Error: Out of memory.\n");
+                                break;
+                        }
+                }
+
+                compl[cnum] = str_dup(ctmp);
+                if (compl[cnum] == NULL) {
+                        printf("Error: Out of memory.\n");
+                        break;
+                }
+                cnum++;
+        }
+
+        (*ti->compl_ops->fini)(state);
+
+        if (cnum > 1) {
+                /*
+                 * More than one match. Determine maximum common prefix.
+                 */
+                size_t cplen;
+
+                cplen = str_length(compl[0]);
+                for (i = 1; i < cnum; i++)
+                        cplen = min(cplen, common_pref_len(compl[0], compl[i]));
+
+                /* Compute how many bytes we should skip. */
+                size_t istart = str_lsize(compl[0], ti->pos - cstart);
+
+                if (cplen > istart) {
+                        /* Insert common prefix. */
+
+                        /* Copy remainder of common prefix. */
+                        char *cpref = str_ndup(compl[0] + istart,
+                            str_lsize(compl[0], cplen - istart));
+
+                        /* Insert it. */
+                        tinput_insert_string(ti, cpref);
+                        free(cpref);
+                } else {
+                        /* No common prefix. Sort and display all entries. */
+
+                        qsort(compl, cnum, sizeof(char *), compl_cmp, NULL);
+
+                        tinput_jump_after(ti);
+                        tinput_show_completions(ti, compl, cnum);
+                        tinput_display(ti);
+                }
+        } else if (cnum == 1) {
+                /*
+                 * We have exactly one match. Insert it.
+                 */
+
+                /* Compute how many bytes of completion string we should skip. */
+                size_t istart = str_lsize(compl[0], ti->pos - cstart);
+
+                /* Insert remainder of completion string at current position. */
+                tinput_insert_string(ti, compl[0] + istart);
+        }
+
+        for (i = 0; i < cnum; i++)
+                free(compl[i]);
+        free(compl);
+}
+
 /** Initialize text input field.
  *
@@ -516 +741 @@
 static void tinput_init(tinput_t *ti)
 {
+        ti->console = console_init(stdin, stdout);
         ti->hnum = 0;
         ti->hpos = 0;
         ti->history[0] = NULL;
+}
+
+/** Set prompt string.
+ *
+ * @param ti            Text input
+ * @param prompt        Prompt string
+ *
+ * @return              EOK on success, ENOMEM if out of memory.
+ */
+int tinput_set_prompt(tinput_t *ti, const char *prompt)
+{
+        if (ti->prompt != NULL)
+                free(ti->prompt);
+        
+        ti->prompt = str_dup(prompt);
+        if (ti->prompt == NULL)
+                return ENOMEM;
+        
+        return EOK;
+}
+
+/** Set completion ops.
+ *
+ * Set pointer to completion ops structure that will be used for text
+ * completion.
+ */
+void tinput_set_compl_ops(tinput_t *ti, tinput_compl_ops_t *compl_ops)
+{
+        ti->compl_ops = compl_ops;
 }
 
@@ -533 +788 @@
 int tinput_read(tinput_t *ti, char **dstr)
 {
-        fflush(stdout);
-        if (console_get_size(fphone(stdin), &ti->con_cols, &ti->con_rows) != EOK)
-                return EIO;
-        
-        if (console_get_pos(fphone(stdin), &ti->col0, &ti->row0) != EOK)
+        console_flush(ti->console);
+        if (console_get_size(ti->console, &ti->con_cols, &ti->con_rows) != EOK)
                 return EIO;
         
@@ -547 +799 @@
         ti->exit_clui = false;
         
+        if (tinput_display(ti) != EOK)
+                return EIO;
+        
         while (!ti->done) {
-                fflush(stdout);
-                
-                console_event_t ev;
-                if (!console_get_event(fphone(stdin), &ev))
+                console_flush(ti->console);
+                
+                kbd_event_t ev;
+                if (!console_get_kbd_event(ti->console, &ev))
                         return EIO;
                 
@@ -596 +851 @@
 }
 
-static void tinput_key_ctrl(tinput_t *ti, console_event_t *ev)
+static void tinput_key_ctrl(tinput_t *ti, kbd_event_t *ev)
 {
         switch (ev->key) {
@@ -635 +890 @@
 }
 
-static void tinput_key_ctrl_shift(tinput_t *ti, console_event_t *ev)
+static void tinput_key_ctrl_shift(tinput_t *ti, kbd_event_t *ev)
 {
         switch (ev->key) {
@@ -655 +910 @@
 }
 
-static void tinput_key_shift(tinput_t *ti, console_event_t *ev)
+static void tinput_key_shift(tinput_t *ti, kbd_event_t *ev)
 {
         switch (ev->key) {
@@ -681 +936 @@
 }
 
-static void tinput_key_unmod(tinput_t *ti, console_event_t *ev)
+static void tinput_key_unmod(tinput_t *ti, kbd_event_t *ev)
 {
         switch (ev->key) {
@@ -712 +967 @@
                 tinput_history_seek(ti, -1);
                 break;
+        case KC_TAB:
+                tinput_text_complete(ti);
+                break;
         default:
                 break;