src/input.c

   1 #include "input.h"
   2
   3 /** glk_request_char_event:
   4  * @win: A window to request char events from Request
   5  *
   6  * Request input of a Latin-1 character or special key. A window cannot have requests
   7  * for both character and line input at the same time. Nor can it have requests
   8  * for character input of both types (Latin-1 and Unicode). It is illegal to
   9  * call glk_request_char_event() if the window already has a pending request
  10  * for either character or line input.
  11  */
  12 void
  13 glk_request_char_event(winid_t win)
  14 {
  15         g_return_if_fail(win);
  16         g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
  17         g_return_if_fail(win->window_type != wintype_TextBuffer || win->window_type != wintype_TextGrid);
  18
  19         win->input_request_type = INPUT_REQUEST_CHARACTER;
  20         g_signal_handler_unblock( G_OBJECT(win->widget), win->keypress_handler );
  21 }
  22
  23 /** glk_request_char_event_uni:
  24  * @win: A window to request char events from Request
  25  *
  26  * Request input of a Unicode character or special key. A window cannot have requests
  27  * for both character and line input at the same time. Nor can it have requests
  28  * for character input of both types (Latin-1 and Unicode). It is illegal to
  29  * call glk_request_char_event_uni() if the window already has a pending request
  30  * for either character or line input.
  31  */
  32 void
  33 glk_request_char_event_uni(winid_t win)
  34 {
  35         g_return_if_fail(win);
  36         g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
  37         g_return_if_fail(win->window_type != wintype_TextBuffer || win->window_type != wintype_TextGrid);
  38
  39         win->input_request_type = INPUT_REQUEST_CHARACTER_UNICODE;
  40         g_signal_handler_unblock( G_OBJECT(win->widget), win->keypress_handler );
  41 }
  42
  43 void
  44 glk_request_line_event(winid_t win, char* buf, glui32 maxlen, glui32 initlen)
  45 {
  46         GtkTextBuffer *window_buffer;
  47
  48         g_return_if_fail(win);
  49         g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
  50         g_return_if_fail(win->window_type != wintype_TextBuffer || win->window_type != wintype_TextGrid);
  51
  52         window_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(win->widget));
  53
  54         win->input_request_type = INPUT_REQUEST_LINE;
  55         win->line_input_buffer = buf;
  56         win->line_input_buffer_max_len = maxlen;
  57
  58         /* Move the input_position mark to the end of the window_buffer */
  59         GtkTextMark *input_position = gtk_text_buffer_get_mark(window_buffer, "input_position");
  60         GtkTextIter end_iter;
  61         gtk_text_buffer_get_end_iter(window_buffer, &end_iter);
  62         gtk_text_buffer_move_mark(window_buffer, input_position, &end_iter);
  63
  64         /* Set the entire contents of the window_buffer as uneditable
  65          * (so input can only be entered at the end) */
  66         GtkTextIter start_iter;
  67         gtk_text_buffer_get_start_iter(window_buffer, &start_iter);
  68         gtk_text_buffer_remove_tag_by_name(window_buffer, "uneditable", &start_iter, &end_iter);
  69         gtk_text_buffer_apply_tag_by_name(window_buffer, "uneditable", &start_iter, &end_iter);
  70
  71         if(initlen > 0) {
  72                 gtk_text_buffer_insert(window_buffer, &end_iter, buf, initlen);
  73         }
  74
  75         gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(win->widget), input_position);
  76         g_signal_handler_unblock( G_OBJECT(window_buffer), win->insert_text_handler );
  77         gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), TRUE);
  78 }
  79
  80 void
  81 glk_request_line_event_uni(winid_t win, glui32 *buf, glui32 maxlen, glui32 initlen)
  82 {
  83         GtkTextBuffer *window_buffer;
  84
  85         g_return_if_fail(win);
  86         g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
  87         g_return_if_fail(win->window_type != wintype_TextBuffer || win->window_type != wintype_TextGrid);
  88
  89         window_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(win->widget));
  90
  91         win->input_request_type = INPUT_REQUEST_LINE_UNICODE;
  92         win->line_input_buffer_unicode = buf;
  93         win->line_input_buffer_max_len = maxlen;
  94
  95         /* Move the input_position mark to the end of the window_buffer */
  96         GtkTextMark *input_position = gtk_text_buffer_get_mark(window_buffer, "input_position");
  97         GtkTextIter end_iter;
  98         gtk_text_buffer_get_end_iter(window_buffer, &end_iter);
  99         gtk_text_buffer_move_mark(window_buffer, input_position, &end_iter);
 100
 101         /* Set the entire contents of the window_buffer as uneditable
 102          * (so input can only be entered at the end) */
 103         GtkTextIter start_iter;
 104         gtk_text_buffer_get_start_iter(window_buffer, &start_iter);
 105         gtk_text_buffer_remove_tag_by_name(window_buffer, "uneditable", &start_iter, &end_iter);
 106         gtk_text_buffer_apply_tag_by_name(window_buffer, "uneditable", &start_iter, &end_iter);
 107
 108         if(initlen > 0) {
 109                 GError *error = NULL;
 110                 gchar *utf8;
 111                 utf8 = g_ucs4_to_utf8(buf, initlen, NULL, NULL, &error);
 112
 113                 if(utf8 == NULL)
 114                 {
 115                         error_dialog(NULL, error, "Error during unicode->utf8 conversion: ");
 116                         return;
 117                 }
 118
 119                 gtk_text_buffer_insert(window_buffer, &end_iter, utf8, -1);
 120                 g_free(utf8);
 121         }
 122
 123         gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(win->widget), input_position);
 124         g_signal_handler_unblock( G_OBJECT(window_buffer), win->insert_text_handler );
 125         gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), TRUE);
 126 }
 127
 128
 129
 130 gboolean
 131 on_window_key_press_event(GtkWidget *widget, GdkEventKey *event, winid_t window)
 132 {
 133         if(window->input_request_type != INPUT_REQUEST_CHARACTER &&
 134                 window->input_request_type != INPUT_REQUEST_CHARACTER_UNICODE) {
 135                 return FALSE;
 136         }
 137
 138         int keycode;
 139
 140         switch(event->keyval) {
 141                 case GDK_Up:
 142                 case GDK_KP_Up: keycode = keycode_Up; break;
 143                 case GDK_Down:
 144                 case GDK_KP_Down: keycode = keycode_Down; break;
 145                 case GDK_Left:
 146                 case GDK_KP_Left: keycode = keycode_Left; break;
 147                 case GDK_Right:
 148                 case GDK_KP_Right: keycode = keycode_Right; break;
 149                 case GDK_Return:
 150                 case GDK_KP_Enter: keycode = keycode_Return; break;
 151                 case GDK_Delete:
 152                 case GDK_BackSpace:
 153                 case GDK_KP_Delete: keycode = keycode_Delete; break;
 154                 case GDK_Escape: keycode = keycode_Escape; break;
 155                 case GDK_Tab: keycode = keycode_Tab; break;
 156                 case GDK_Page_Up:
 157                 case GDK_KP_Page_Up: keycode = keycode_PageUp; break;
 158                 case GDK_Page_Down:
 159                 case GDK_KP_Page_Down: keycode = keycode_PageDown; break;
 160                 case GDK_Home:
 161                 case GDK_KP_Home: keycode = keycode_Home; break;
 162                 case GDK_End:
 163                 case GDK_KP_End: keycode = keycode_End; break;
 164                 case GDK_F1: keycode = keycode_Func1; break;
 165                 case GDK_F2: keycode = keycode_Func2; break;
 166                 case GDK_F3: keycode = keycode_Func3; break;
 167                 case GDK_F4: keycode = keycode_Func4; break;
 168                 case GDK_F5: keycode = keycode_Func5; break;
 169                 case GDK_F6: keycode = keycode_Func6; break;
 170                 case GDK_F7: keycode = keycode_Func7; break;
 171                 case GDK_F8: keycode = keycode_Func8; break;
 172                 case GDK_F9: keycode = keycode_Func9; break;
 173                 case GDK_F10: keycode = keycode_Func10; break;
 174                 case GDK_F11: keycode = keycode_Func11; break;
 175                 case GDK_F12: keycode = keycode_Func12; break;
 176                 default:
 177                         keycode = gdk_keyval_to_unicode(event->keyval);
 178         }
 179
 180         if(window->input_request_type == INPUT_REQUEST_CHARACTER) {
 181                 if(keycode >= 1 || keycode <= 255) {
 182                         event_throw(evtype_CharInput, window, keycode, 0);
 183                 } else {
 184                         event_throw(evtype_CharInput, window, keycode_Unknown, 0);
 185                 }
 186         } else {
 187                 if(keycode == 0) {
 188                         event_throw(evtype_CharInput, window, keycode_Unknown, 0);
 189                 } else {
 190                         event_throw(evtype_CharInput, window, keycode, 0);
 191                 }
 192         }
 193
 194         /* Only one keypress will be handled */
 195         window->input_request_type = INPUT_REQUEST_NONE;
 196         g_signal_handler_block( G_OBJECT(window->widget), window->keypress_handler );
 197
 198         return TRUE;
 199 }
 200
 201 void
 202 on_window_insert_text(GtkTextBuffer *textbuffer, GtkTextIter *location, gchar *text, gint len, gpointer user_data)
 203 {
 204         gchar *newline_pos = strchr(text, '\n');
 205         if(newline_pos != NULL) {
 206                 printf("position: %d\n", newline_pos-text);
 207                 *newline_pos = 'a';
 208         }
 209 }
 210
 211 void
 212 after_window_insert_text(GtkTextBuffer *textbuffer, GtkTextIter *location, gchar *text, gint len, winid_t window)
 213 {
 214         if( strchr(text, '\n') != NULL) {
 215                 /* Make the window uneditable again and remove signal handlers */
 216                 GtkTextBuffer *window_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(window->widget));
 217                 gtk_text_view_set_editable(GTK_TEXT_VIEW(window->widget), FALSE);
 218                 g_signal_handler_block(window_buffer, window->insert_text_handler);
 219
 220                 /* Retrieve the text that was input */
 221                 GtkTextMark *input_position = gtk_text_buffer_get_mark(window_buffer, "input_position");
 222                 GtkTextIter start_iter;
 223                 GtkTextIter end_iter;
 224                 gtk_text_buffer_get_iter_at_mark(window_buffer, &start_iter, input_position);
 225                 gtk_text_buffer_get_end_iter(window_buffer, &end_iter);
 226                 gchar *inserted_text = gtk_text_buffer_get_text(window_buffer, &start_iter, &end_iter, FALSE);
 227
 228
 229                 /* Convert the string from UTF-8 to Latin-1 or Unicode */
 230                 if(window->input_request_type == INPUT_REQUEST_LINE) {
 231                         GError *error = NULL;
 232                         gchar *latin1;
 233                         gsize bytes_written;
 234                         latin1 = g_convert_with_fallback(inserted_text, -1, "ISO-8859-1", "UTF-8", "?", NULL, &bytes_written, &error);
 235                         g_free(inserted_text);
 236
 237                         if(latin1 == NULL)
 238                         {
 239                                 error_dialog(NULL, error, "Error during utf8->latin1 conversion: ");
 240                                 event_throw(evtype_LineInput, window, 0, 0);
 241                                 return;
 242                         }
 243
 244                         /* Place input in the echo stream */
 245                         if(window->echo_stream != NULL)
 246                                 glk_put_string_stream(window->echo_stream, latin1);
 247
 248                         /* Copy the string (but not the NULL at the end) */
 249                         memcpy(window->line_input_buffer, latin1, MIN(window->line_input_buffer_max_len, bytes_written-1));
 250                         g_free(latin1);
 251                         event_throw(evtype_LineInput, window, MIN(window->line_input_buffer_max_len, bytes_written-1), 0);
 252                 }
 253                 else if(window->input_request_type == INPUT_REQUEST_LINE_UNICODE) {
 254                         gunichar *unicode;
 255                         glong items_written;
 256                         unicode = g_utf8_to_ucs4_fast(inserted_text, -1, &items_written);
 257                         g_free(inserted_text);
 258
 259                         if(unicode == NULL)
 260                         {
 261                                 error_dialog(NULL, NULL, "Error during utf8->unicode conversion");
 262                                 event_throw(evtype_LineInput, window, 0, 0);
 263                                 return;
 264                         }
 265
 266                         /* Place input in the echo stream */
 267                         // TODO: fixme
 268                         // if(window->echo_stream != NULL)
 269                         //      glk_put_string_stream_uni(window->echo_stream, unicode);
 270
 271                         /* Copy the string (but not the NULL at the end) */
 272                         memcpy(window->line_input_buffer_unicode, unicode, MIN(window->line_input_buffer_max_len, items_written)*sizeof(gunichar));
 273                         g_free(unicode);
 274                         event_throw(evtype_LineInput, window, MIN(window->line_input_buffer_max_len, items_written), 0);
 275                 }
 276                 else {
 277                         g_warning("%s: Wrong input request type.", __func__);
 278                 }
 279
 280                 window->input_request_type = INPUT_REQUEST_NONE;
 281         }
 282 }