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