src/input.c

   1 #include "input.h"
   2
   3 /** glk_request_char_event:
   4  * @win: A window to request char events from.
   5  *
   6  * Request input of a Latin-1 character or special key. A window cannot have
   7  * requests for both character and line input at the same time. Nor can it have
   8  * requests for character input of both types (Latin-1 and Unicode). It is
   9  * illegal to call glk_request_char_event() if the window already has a pending
  10  * request 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->type != wintype_TextBuffer || win->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.
  25  *
  26  * Request input of a Unicode character or special key. See
  27  * glk_request_char_event().
  28  */
  29 void
  30 glk_request_char_event_uni(winid_t win)
  31 {
  32         g_return_if_fail(win);
  33         g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
  34         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
  35
  36         win->input_request_type = INPUT_REQUEST_CHARACTER_UNICODE;
  37         g_signal_handler_unblock( G_OBJECT(win->widget), win->keypress_handler );
  38 }
  39
  40 /* Internal function: Request either latin-1 or unicode line input. */
  41 void
  42 request_line_event_common(winid_t win, glui32 maxlen, gboolean insert, gchar *inserttext)
  43 {
  44         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
  45
  46     if(win->type == wintype_TextGrid)
  47     {
  48         GtkTextMark *cursor = gtk_text_buffer_get_mark(buffer, "cursor_position");
  49         GtkTextIter start_iter, end_iter;
  50         gtk_text_buffer_get_iter_at_mark(buffer, &start_iter, cursor);
  51
  52         /* Determine the maximum length of the line input */
  53         gint cursorpos = gtk_text_iter_get_line_offset(&start_iter);
  54         gint input_length = MIN(win->width - 1 - cursorpos, win->line_input_buffer_max_len);
  55         end_iter = start_iter;
  56         gtk_text_iter_set_line_offset(&end_iter, cursorpos + input_length);
  57
  58         /* Insert pre-entered text if needed */
  59         gchar *text;
  60         if(!insert)
  61             text = g_strnfill(input_length, ' ');
  62         else
  63         {
  64             gchar *blanks = g_strnfill(input_length - g_utf8_strlen(inserttext, -1), ' ');
  65             text = g_strconcat(inserttext, blanks, NULL);
  66             g_free(blanks);
  67         }
  68
  69         /* Erase the text currently in the input field and replace it with blanks or the insert text, with the editable "input_field" tag */
  70         GtkTextIter text_start, text_end;
  71         GtkTextTag *uneditable = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "uneditable");
  72         gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
  73         gtk_text_buffer_get_start_iter(buffer, &text_start);
  74         gtk_text_buffer_apply_tag(buffer, uneditable, &text_start, &start_iter);
  75         gtk_text_buffer_insert_with_tags_by_name(buffer, &start_iter, text, -1, "input_field", NULL);
  76         g_free(text);
  77         gtk_text_buffer_get_end_iter(buffer, &text_end);
  78         gtk_text_buffer_apply_tag(buffer, uneditable, &start_iter, &text_end);
  79
  80         gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), TRUE);
  81         g_signal_handler_unblock(GTK_TEXT_VIEW(win->widget), win->insert_text_handler);
  82     }
  83     else if(win->type == wintype_TextBuffer)
  84     {
  85         /* Move the input_position mark to the end of the window_buffer */
  86         GtkTextMark *input_position = gtk_text_buffer_get_mark(buffer, "input_position");
  87         GtkTextIter end_iter;
  88         gtk_text_buffer_get_end_iter(buffer, &end_iter);
  89         gtk_text_buffer_move_mark(buffer, input_position, &end_iter);
  90
  91         /* Set the entire contents of the window_buffer as uneditable
  92          * (so input can only be entered at the end) */
  93         GtkTextIter start_iter;
  94         gtk_text_buffer_get_start_iter(buffer, &start_iter);
  95         gtk_text_buffer_remove_tag_by_name(buffer, "uneditable", &start_iter, &end_iter);
  96         gtk_text_buffer_apply_tag_by_name(buffer, "uneditable", &start_iter, &end_iter);
  97
  98         /* Insert pre-entered text if needed */
  99         if(insert)
 100             gtk_text_buffer_insert(buffer, &end_iter, inserttext, -1);
 101
 102         /* Scroll to input point */
 103         gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(win->widget), input_position);
 104
 105         gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), TRUE);
 106         g_signal_handler_unblock(buffer, win->insert_text_handler);
 107     }
 108 }
 109
 110 /**
 111  * glk_request_line_event:
 112  * @win: A text buffer or text grid window to request line input on.
 113  * @buf: A buffer of at least @maxlen bytes.
 114  * @maxlen: Length of the buffer.
 115  * @initlen: The number of characters in @buf to pre-enter.
 116  *
 117  * Requests input of a line of Latin-1 characters. A window cannot have requests
 118  * for both character and line input at the same time. Nor can it have requests
 119  * for line input of both types (Latin-1 and Unicode). It is illegal to call
 120  * glk_request_line_event() if the window already has a pending request for
 121  * either character or line input.
 122  *
 123  * The @buf argument is a pointer to space where the line input will be stored.
 124  * (This may not be %NULL.) @maxlen is the length of this space, in bytes; the
 125  * library will not accept more characters than this. If @initlen is nonzero,
 126  * then the first @initlen bytes of @buf will be entered as pre-existing input
 127  * -- just as if the player had typed them himself. (The player can continue
 128  * composing after this pre-entered input, or delete it or edit as usual.)
 129  *
 130  * The contents of the buffer are undefined until the input is completed (either
 131  * by a line input event, or glk_cancel_line_event(). The library may or may not
 132  * fill in the buffer as the player composes, while the input is still pending;
 133  * it is illegal to change the contents of the buffer yourself.
 134  */
 135 void
 136 glk_request_line_event(winid_t win, char* buf, glui32 maxlen, glui32 initlen)
 137 {
 138         g_return_if_fail(win);
 139         g_return_if_fail(buf);
 140         g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
 141         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
 142
 143         win->input_request_type = INPUT_REQUEST_LINE;
 144         win->line_input_buffer = buf;
 145         win->line_input_buffer_max_len = maxlen;
 146
 147         gchar *inserttext = (initlen > 0)? g_strndup(buf, initlen) : g_strdup("");
 148         request_line_event_common(win, maxlen, (initlen > 0), inserttext);
 149         g_free(inserttext);
 150 }
 151
 152 /**
 153  * glk_request_line_event_uni:
 154  * @win: A text buffer or text grid window to request line input on.
 155  * @buf: A buffer of at least @maxlen characters.
 156  * @maxlen: Length of the buffer.
 157  * @initlen: The number of characters in @buf to pre-enter.
 158  *
 159  * Request input of a line of Unicode characters. This works the same as
 160  * glk_request_line_event(), except the result is stored in an array of
 161  * <type>glui32</type> values instead of an array of characters, and the values
 162  * may be any valid Unicode code points.
 163  *
 164  * The result will be in Unicode Normalization Form C. This basically means that
 165  * composite characters will be single characters where possible, instead of
 166  * sequences of base and combining marks. See
 167  * <ulink url="http://www.unicode.org/reports/tr15/">Unicode Standard Annex #15
 168  * </ulink> for the details.
 169  */
 170 void
 171 glk_request_line_event_uni(winid_t win, glui32 *buf, glui32 maxlen, glui32 initlen)
 172 {
 173         g_return_if_fail(win);
 174         g_return_if_fail(buf);
 175         g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
 176         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
 177
 178         win->input_request_type = INPUT_REQUEST_LINE_UNICODE;
 179         win->line_input_buffer_unicode = buf;
 180         win->line_input_buffer_max_len = maxlen;
 181
 182         gchar *utf8;
 183         if(initlen > 0) {
 184                 GError *error = NULL;
 185                 utf8 = g_ucs4_to_utf8(buf, initlen, NULL, NULL, &error);
 186
 187                 if(utf8 == NULL)
 188                 {
 189                         g_warning("Error during unicode->utf8 conversion: %s", error->message);
 190                         return;
 191                 }
 192         }
 193         else
 194                 utf8 = g_strdup("");
 195
 196         request_line_event_common(win, maxlen, (initlen > 0), utf8);
 197         g_free(utf8);
 198 }
 199
 200 /* Internal function: Callback for signal key-press-event on a text buffer or text grid window. */
 201 gboolean
 202 on_window_key_press_event(GtkWidget *widget, GdkEventKey *event, winid_t win)
 203 {
 204         if(win->input_request_type != INPUT_REQUEST_CHARACTER &&
 205                 win->input_request_type != INPUT_REQUEST_CHARACTER_UNICODE)
 206                 return FALSE;
 207
 208         int keycode;
 209
 210         switch(event->keyval) {
 211                 case GDK_Up:
 212                 case GDK_KP_Up: keycode = keycode_Up; break;
 213                 case GDK_Down:
 214                 case GDK_KP_Down: keycode = keycode_Down; break;
 215                 case GDK_Left:
 216                 case GDK_KP_Left: keycode = keycode_Left; break;
 217                 case GDK_Right:
 218                 case GDK_KP_Right: keycode = keycode_Right; break;
 219                 case GDK_Linefeed:
 220                 case GDK_Return:
 221                 case GDK_KP_Enter: keycode = keycode_Return; break;
 222                 case GDK_Delete:
 223                 case GDK_BackSpace:
 224                 case GDK_KP_Delete: keycode = keycode_Delete; break;
 225                 case GDK_Escape: keycode = keycode_Escape; break;
 226                 case GDK_Tab:
 227                 case GDK_KP_Tab: keycode = keycode_Tab; break;
 228                 case GDK_Page_Up:
 229                 case GDK_KP_Page_Up: keycode = keycode_PageUp; break;
 230                 case GDK_Page_Down:
 231                 case GDK_KP_Page_Down: keycode = keycode_PageDown; break;
 232                 case GDK_Home:
 233                 case GDK_KP_Home: keycode = keycode_Home; break;
 234                 case GDK_End:
 235                 case GDK_KP_End: keycode = keycode_End; break;
 236                 case GDK_F1:
 237                 case GDK_KP_F1: keycode = keycode_Func1; break;
 238                 case GDK_F2:
 239                 case GDK_KP_F2: keycode = keycode_Func2; break;
 240                 case GDK_F3:
 241                 case GDK_KP_F3: keycode = keycode_Func3; break;
 242                 case GDK_F4:
 243                 case GDK_KP_F4: keycode = keycode_Func4; break;
 244                 case GDK_F5: keycode = keycode_Func5; break;
 245                 case GDK_F6: keycode = keycode_Func6; break;
 246                 case GDK_F7: keycode = keycode_Func7; break;
 247                 case GDK_F8: keycode = keycode_Func8; break;
 248                 case GDK_F9: keycode = keycode_Func9; break;
 249                 case GDK_F10: keycode = keycode_Func10; break;
 250                 case GDK_F11: keycode = keycode_Func11; break;
 251                 case GDK_F12: keycode = keycode_Func12; break;
 252                 default:
 253                         keycode = gdk_keyval_to_unicode(event->keyval);
 254                         /* If keycode is 0, then keyval was not recognized; also return
 255                         unknown if Latin-1 input was requested and the character is not in
 256                         Latin-1 */
 257                         if(keycode == 0 || (win->input_request_type == INPUT_REQUEST_CHARACTER && keycode > 255))
 258                                 keycode = keycode_Unknown;
 259         }
 260
 261         event_throw(evtype_CharInput, win, keycode, 0);
 262
 263         /* Only one keypress will be handled */
 264         win->input_request_type = INPUT_REQUEST_NONE;
 265         g_signal_handler_block( G_OBJECT(win->widget), win->keypress_handler );
 266
 267         return TRUE;
 268 }
 269
 270 /* Internal function: finish handling a line input request, for both text grid and text buffer windows. */
 271 static void
 272 end_line_input_request(winid_t win, gchar *inserted_text)
 273 {
 274     /* Convert the string from UTF-8 to Latin-1 or Unicode */
 275     if(win->input_request_type == INPUT_REQUEST_LINE)
 276     {
 277         GError *error = NULL;
 278         gchar *latin1;
 279         gsize bytes_written;
 280         latin1 = g_convert_with_fallback(inserted_text, -1, "ISO-8859-1", "UTF-8", "?", NULL, &bytes_written, &error);
 281
 282         if(latin1 == NULL)
 283         {
 284             g_warning("Error during utf8->latin1 conversion: %s", error->message);
 285             event_throw(evtype_LineInput, win, 0, 0);
 286             return;
 287         }
 288
 289         /* Place input in the echo stream */
 290         if(win->echo_stream != NULL)
 291             glk_put_string_stream(win->echo_stream, latin1);
 292
 293         /* Copy the string (but not the NULL at the end) */
 294         int copycount = MIN(win->line_input_buffer_max_len, bytes_written - 1);
 295         memcpy(win->line_input_buffer, latin1, copycount);
 296         g_free(latin1);
 297         event_throw(evtype_LineInput, win, copycount, 0);
 298     }
 299     else if(win->input_request_type == INPUT_REQUEST_LINE_UNICODE)
 300     {
 301         gunichar *unicode;
 302         glong items_written;
 303         unicode = g_utf8_to_ucs4_fast(inserted_text, -1, &items_written);
 304
 305         if(unicode == NULL)
 306         {
 307             g_warning("Error during utf8->unicode conversion");
 308             event_throw(evtype_LineInput, win, 0, 0);
 309             return;
 310         }
 311
 312         /* Place input in the echo stream */
 313         /* TODO: fixme
 314         if(win->echo_stream != NULL)
 315             glk_put_string_stream_uni(window->echo_stream, unicode);*/
 316
 317         /* Copy the string (but not the NULL at the end) */
 318         int copycount = MIN(win->line_input_buffer_max_len, items_written);
 319         memcpy(win->line_input_buffer_unicode, unicode, copycount * sizeof(gunichar));
 320         g_free(unicode);
 321         event_throw(evtype_LineInput, win, copycount, 0);
 322     }
 323     else
 324         g_warning("%s: Wrong input request type.", __func__);
 325
 326     win->input_request_type = INPUT_REQUEST_NONE;
 327 }
 328
 329
 330 /* Internal function: Callback for signal key-press-event on a text grid window. Only unblocked during line input, so that we can catch the enter key before it inserts an enter into the window. */
 331 gboolean
 332 on_text_grid_key_press_event(GtkWidget *widget, GdkEventKey *event, winid_t win)
 333 {
 334     g_return_val_if_fail(win->type == wintype_TextGrid, FALSE);
 335     g_return_val_if_fail(win->input_request_type == INPUT_REQUEST_LINE || win->input_request_type == INPUT_REQUEST_LINE_UNICODE, FALSE);
 336
 337     if(event->keyval == GDK_Linefeed || event->keyval == GDK_Return || event->keyval == GDK_KP_Enter)
 338     {
 339         GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
 340         GtkTextIter start_iter, end_iter;
 341         g_signal_handler_block(GTK_TEXT_VIEW(win->widget), win->insert_text_handler);
 342
 343         /* Determine the bounds of the line input */
 344         GtkTextMark *cursor = gtk_text_buffer_get_mark(window_buffer, "cursor_position");
 345         gtk_text_buffer_get_iter_at_mark(window_buffer, &start_iter, cursor);
 346         gint cursorpos = gtk_text_iter_get_line_offset(&start_iter);
 347         gint input_length = MIN(win->width - 1 - cursorpos, win->line_input_buffer_max_len);
 348         end_iter = start_iter;
 349         gtk_text_iter_set_line_offset(&end_iter, cursorpos + input_length);
 350
 351         gchar *inserted_text = g_strchomp( gtk_text_buffer_get_text(window_buffer, &start_iter, &end_iter, FALSE) );
 352
 353         /* Make the buffer uneditable again and remove the special tags */
 354         gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), FALSE);
 355         gtk_text_buffer_get_start_iter(window_buffer, &start_iter);
 356         gtk_text_buffer_get_end_iter(window_buffer, &end_iter);
 357         gtk_text_buffer_remove_tag_by_name(window_buffer, "uneditable", &start_iter, &end_iter);
 358         gtk_text_buffer_remove_tag_by_name(window_buffer, "input_field", &start_iter, &end_iter);
 359
 360         end_line_input_request(win, inserted_text);
 361         g_free(inserted_text);
 362
 363         /* Block the enter key */
 364         return TRUE;
 365     }
 366
 367     return FALSE;
 368 }
 369
 370 /* Internal function: Callback for signal insert-text on a text buffer window.
 371 Runs after the default handler has already inserted the text.*/
 372 void
 373 after_window_insert_text(GtkTextBuffer *textbuffer, GtkTextIter *location, gchar *text, gint len, winid_t win)
 374 {
 375         if( strchr(text, '\n') != NULL )
 376         {
 377                 /* Remove signal handlers */
 378                 GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
 379                 g_signal_handler_block(window_buffer, win->insert_text_handler);
 380
 381                 /* Make the window uneditable again and retrieve the text that was input */
 382                 gchar *inserted_text;
 383                 GtkTextIter start_iter, end_iter;
 384
 385         gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), FALSE);
 386         GtkTextMark *input_position = gtk_text_buffer_get_mark(window_buffer, "input_position");
 387         gtk_text_buffer_get_iter_at_mark(window_buffer, &start_iter, input_position);
 388         gtk_text_buffer_get_end_iter(window_buffer, &end_iter);
 389
 390         inserted_text = gtk_text_buffer_get_text(window_buffer, &start_iter, &end_iter, FALSE);
 391
 392         end_line_input_request(win, inserted_text);
 393         g_free(inserted_text);
 394         }
 395 }