Minimum implementation of line terminators
[projects/chimara/chimara.git] / libchimara / input.c
index 7f8038c38793de0242dfa47577f1d98894361f2a..1963bfd3378bd97e5ab9cc1502217fb7fe9c4acc 100644 (file)
@@ -3,6 +3,7 @@
 #include "input.h"
 #include "pager.h"
 #include "chimara-glk-private.h"
+#include "garglk.h"
 
 extern GPrivate *glk_data_key;
 
@@ -243,6 +244,8 @@ glk_request_line_event(winid_t win, char *buf, glui32 maxlen, glui32 initlen)
        win->input_request_type = INPUT_REQUEST_LINE;
        win->line_input_buffer = buf;
        win->line_input_buffer_max_len = maxlen;
+       win->echo_current_line_input = win->echo_line_input;
+       win->current_extra_line_terminators = g_slist_copy(win->extra_line_terminators);
 
        gchar *inserttext = (initlen > 0)? g_strndup(buf, initlen) : g_strdup("");
        switch(win->type)
@@ -311,11 +314,10 @@ glk_request_line_event_uni(winid_t win, glui32 *buf, glui32 maxlen, glui32 initl
        if(glk_data->register_arr)
         win->buffer_rock = (*glk_data->register_arr)(buf, maxlen, "&+#!Iu");
 
-
-
        win->input_request_type = INPUT_REQUEST_LINE_UNICODE;
        win->line_input_buffer_unicode = buf;
        win->line_input_buffer_max_len = maxlen;
+       win->current_extra_line_terminators = g_slist_copy(win->extra_line_terminators);
 
        gchar *utf8;
        if(initlen > 0) {
@@ -624,21 +626,23 @@ finish_text_buffer_line_input(winid_t win, gboolean emit_signal)
        VALID_WINDOW(win, return 0);
        g_return_val_if_fail(win->type == wintype_TextBuffer, 0);
 
-       GtkTextIter start_iter, end_iter, last_character;
+       GtkTextIter start_iter, end_iter;
 
        GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
        GtkTextMark *input_position = gtk_text_buffer_get_mark(window_buffer, "input_position");
        gtk_text_buffer_get_iter_at_mark(window_buffer, &start_iter, input_position);
        gtk_text_buffer_get_end_iter(window_buffer, &end_iter);
-       gtk_text_buffer_get_end_iter(window_buffer, &last_character);
-       gtk_text_iter_backward_cursor_position(&last_character);
 
-       gchar* last_char = gtk_text_buffer_get_text(window_buffer, &last_character, &end_iter, FALSE);
+       gchar *inserted_text = gtk_text_buffer_get_text(window_buffer, &start_iter, &end_iter, FALSE);
 
-       if( strchr(last_char, '\n') != NULL )
-               gtk_text_iter_backward_cursor_position(&end_iter);
+       /* If echoing is turned off, remove the text from the window */
+       if(!win->echo_current_line_input)
+               gtk_text_buffer_delete(window_buffer, &start_iter, &end_iter);
 
-       gchar* inserted_text = gtk_text_buffer_get_text(window_buffer, &start_iter, &end_iter, FALSE);
+       /* Don't include the newline in the input */
+       char *last_char = inserted_text + strlen(inserted_text) - 1;
+       if(*last_char == '\n')
+               *last_char = '\0';
 
        int chars_written = write_to_window_buffer(win, inserted_text);
        if(emit_signal)
@@ -927,9 +931,13 @@ force_line_input_from_queue(winid_t win, event_t *event)
                gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), FALSE);
 
                /* Insert the forced input into the window */
-               gtk_text_buffer_get_end_iter(buffer, &end);
-               gchar *text_to_insert = g_strconcat(text, "\n", NULL);
-               gtk_text_buffer_insert_with_tags_by_name(buffer, &end, text_to_insert, -1, "default", "input", NULL);
+               if(win->echo_current_line_input)
+               {
+                       gtk_text_buffer_get_end_iter(buffer, &end);
+                       gchar *text_to_insert = g_strconcat(text, "\n", NULL);
+                       gtk_text_buffer_insert_with_tags_by_name(buffer, &end, text_to_insert, -1, "default", "input", NULL);
+               }
+
                chars_written = finish_text_buffer_line_input(win, TRUE);
        }
        else if(win->type == wintype_TextGrid)
@@ -1008,6 +1016,84 @@ void
 glk_set_echo_line_event(winid_t win, glui32 val)
 {
        VALID_WINDOW(win, return);
+
+       if(win->type != wintype_TextBuffer)
+               return; /* Quietly do nothing */
+
+       win->echo_line_input = val? TRUE : FALSE;
+}
+
+/* Internal function to convert from a Glk keycode to a GDK keyval. */
+static unsigned
+keycode_to_gdk_keyval(glui32 keycode)
+{
+       switch (keycode)
+       {
+               case keycode_Left:
+                       return GDK_Left;
+               case keycode_Right:
+                       return GDK_Right;
+               case keycode_Up:
+                       return GDK_Up;
+               case keycode_Down:
+                       return GDK_Down;
+               case keycode_Return:
+                       return GDK_Return;
+               case keycode_Delete:
+                       return GDK_Delete;
+               case keycode_Escape:
+                       return GDK_Escape;
+               case keycode_Tab:
+                       return GDK_Tab;
+               case keycode_PageUp:
+                       return GDK_Page_Up;
+               case keycode_PageDown:
+                       return GDK_Page_Down;
+               case keycode_Home:
+                       return GDK_Home;
+               case keycode_End:
+                       return GDK_End;
+               case keycode_Func1:
+                       return GDK_F1;
+               case keycode_Func2:
+                       return GDK_F2;
+               case keycode_Func3:
+                       return GDK_F3;
+               case keycode_Func4:
+                       return GDK_F4;
+               case keycode_Func5:
+                       return GDK_F5;
+               case keycode_Func6:
+                       return GDK_F6;
+               case keycode_Func7:
+                       return GDK_F7;
+               case keycode_Func8:
+                       return GDK_F8;
+               case keycode_Func9:
+                       return GDK_F9;
+               case keycode_Func10:
+                       return GDK_F10;
+               case keycode_Func11:
+                       return GDK_F11;
+               case keycode_Func12:
+                       return GDK_F12;
+               case keycode_Erase:
+                       return GDK_BackSpace;
+       }
+       unsigned keyval = gdk_unicode_to_keyval(keycode);
+       if(keyval < 0x01000000) /* magic number meaning illegal unicode point */
+               return keyval;
+       return 0;
+}
+
+/* Internal function to decide whether @keycode is a valid line terminator. */
+gboolean
+is_valid_line_terminator(glui32 keycode)
+{
+       switch(keycode) {
+               default:
+                       return FALSE;
+       }
 }
 
 /**
@@ -1043,4 +1129,20 @@ void
 glk_set_terminators_line_event(winid_t win, glui32 *keycodes, glui32 count)
 {
        VALID_WINDOW(win, return);
+
+       g_slist_free(win->extra_line_terminators);
+       win->extra_line_terminators = NULL;
+
+       if(keycodes == NULL || count == 0)
+               return;
+
+       int i;
+       for(i = 0; i < count; i++)
+       {
+               unsigned key = keycode_to_gdk_keyval(keycodes[i]);
+               if(is_valid_line_terminator(keycodes[i]))
+                       win->extra_line_terminators = g_slist_prepend(win->extra_line_terminators, GUINT_TO_POINTER(key));
+               else
+                  WARNING_S("Ignoring invalid line terminator", gdk_keyval_name(key));
+       }
 }
\ No newline at end of file