Implement unicode normalization
[projects/chimara/chimara.git] / libchimara / input.c
1 #include "charset.h"
2 #include "magic.h"
3 #include "input.h"
4 #include "pager.h"
5 #include "chimara-glk-private.h"
6
7 extern GPrivate *glk_data_key;
8
9 /* Forward declarations */
10 static int finish_text_buffer_line_input(winid_t win, gboolean emit_signal);
11 static int finish_text_grid_line_input(winid_t win, gboolean emit_signal);
12 static void cancel_old_input_request(winid_t win);
13
14 /* Internal function: code common to both flavors of char event request */
15 void
16 request_char_event_common(winid_t win, gboolean unicode)
17 {
18         VALID_WINDOW(win, return);
19         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
20
21         cancel_old_input_request(win);
22
23         flush_window_buffer(win);
24
25         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
26
27         win->input_request_type = unicode? INPUT_REQUEST_CHARACTER_UNICODE : INPUT_REQUEST_CHARACTER;
28         g_signal_handler_unblock( win->widget, win->char_input_keypress_handler );
29
30         gdk_threads_enter();
31         gtk_widget_grab_focus( GTK_WIDGET(win->widget) );
32         gdk_threads_leave();
33
34         /* Emit the "waiting" signal to let listeners know we are ready for input */
35         g_signal_emit_by_name(glk_data->self, "waiting");
36 }
37
38 /**
39  * glk_request_char_event:
40  * @win: A window to request char events from.
41  *
42  * Request input of a Latin-1 character or special key. A window cannot have
43  * requests for both character and line input at the same time. Nor can it have
44  * requests for character input of both types (Latin-1 and Unicode). It is
45  * illegal to call glk_request_char_event() if the window already has a pending
46  * request for either character or line input.
47  */
48 void
49 glk_request_char_event(winid_t win)
50 {
51         request_char_event_common(win, FALSE);
52 }
53
54 /**
55  * glk_request_char_event_uni:
56  * @win: A window to request char events from.
57  *
58  * Request input of a Unicode character or special key. See
59  * glk_request_char_event().
60  */
61 void
62 glk_request_char_event_uni(winid_t win)
63 {
64         request_char_event_common(win, TRUE);
65 }
66
67 /**
68  * glk_cancel_char_event:
69  * @win: A window to cancel the latest char event request on.
70  *
71  * This cancels a pending request for character input. (Either Latin-1 or
72  * Unicode.) For convenience, it is legal to call glk_cancel_char_event() even
73  * if there is no charcter input request on that window. Glk will ignore the
74  * call in this case.
75  */
76 void
77 glk_cancel_char_event(winid_t win)
78 {
79         VALID_WINDOW(win, return);
80         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
81
82         if(win->input_request_type == INPUT_REQUEST_CHARACTER || win->input_request_type == INPUT_REQUEST_CHARACTER_UNICODE)
83         {
84                 win->input_request_type = INPUT_REQUEST_NONE;
85                 g_signal_handler_block( win->widget, win->char_input_keypress_handler );
86         }
87 }
88
89 /* Internal function: Request either latin-1 or unicode line input, in a text grid window. */
90 static void
91 text_grid_request_line_event_common(winid_t win, glui32 maxlen, gboolean insert, gchar *inserttext)
92 {
93         gdk_threads_enter();
94
95         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
96
97     GtkTextMark *cursor = gtk_text_buffer_get_mark(buffer, "cursor_position");
98     GtkTextIter start_iter, end_iter;
99     gtk_text_buffer_get_iter_at_mark(buffer, &start_iter, cursor);
100
101     /* Determine the maximum length of the line input */
102     gint cursorpos = gtk_text_iter_get_line_offset(&start_iter);
103     /* Odd; the Glk spec says the maximum input length is
104     windowwidth - 1 - cursorposition. I say no, because if cursorposition is
105     zero, then the input should fill the whole line. FIXME??? */
106     win->input_length = MIN(win->width - cursorpos, win->line_input_buffer_max_len);
107     end_iter = start_iter;
108     gtk_text_iter_set_line_offset(&end_iter, cursorpos + win->input_length);
109
110         /* If the buffer currently has a selection with one bound in the middle of
111         the input field, then deselect it. Otherwise the input field gets trashed */
112         GtkTextIter start_sel, end_sel;
113         if( gtk_text_buffer_get_selection_bounds(buffer, &start_sel, &end_sel) )
114         {
115                 if( gtk_text_iter_in_range(&start_sel, &start_iter, &end_iter) )
116                         gtk_text_buffer_place_cursor(buffer, &end_sel);
117                 if( gtk_text_iter_in_range(&end_sel, &start_iter, &end_iter) )
118                         gtk_text_buffer_place_cursor(buffer, &start_sel);
119         }
120
121     /* Erase the text currently in the input field and replace it with a GtkEntry */
122     gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
123     win->input_anchor = gtk_text_buffer_create_child_anchor(buffer, &start_iter);
124     win->input_entry = gtk_entry_new();
125         /* Set the entry's font to match that of the window */
126     GtkRcStyle *style = gtk_widget_get_modifier_style(win->widget);     /* Don't free */
127         gtk_widget_modify_font(win->input_entry, style->font_desc);
128         /* Make the entry as small as possible to fit with the text */
129         gtk_entry_set_has_frame(GTK_ENTRY(win->input_entry), FALSE);
130         GtkBorder border = { 0, 0, 0, 0 };
131
132         /* COMPAT: */
133 #if GTK_CHECK_VERSION(2,10,0)
134         gtk_entry_set_inner_border(GTK_ENTRY(win->input_entry), &border);
135 #endif
136     gtk_entry_set_max_length(GTK_ENTRY(win->input_entry), win->input_length);
137     gtk_entry_set_width_chars(GTK_ENTRY(win->input_entry), win->input_length);
138
139     /* Insert pre-entered text if needed */
140     if(insert)
141         gtk_entry_set_text(GTK_ENTRY(win->input_entry), inserttext);
142
143     /* Set background color of entry (TODO: implement as property) */
144     GdkColor background;
145         gdk_color_parse("grey", &background);
146     gtk_widget_modify_base(win->input_entry, GTK_STATE_NORMAL, &background);
147
148     g_signal_connect(win->input_entry, "activate", G_CALLBACK(on_input_entry_activate), win);
149     g_signal_connect(win->input_entry, "key-press-event", G_CALLBACK(on_input_entry_key_press_event), win);
150     win->line_input_entry_changed = g_signal_connect(win->input_entry, "changed", G_CALLBACK(on_input_entry_changed), win);
151
152     gtk_widget_show(win->input_entry);
153     gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(win->widget), win->input_entry, win->input_anchor);
154
155         gtk_widget_grab_focus(win->input_entry);
156
157         gdk_threads_leave();
158 }
159
160 /* Internal function: Request either latin-1 or unicode line input, in a text buffer window. */
161 static void
162 text_buffer_request_line_event_common(winid_t win, glui32 maxlen, gboolean insert, gchar *inserttext)
163 {
164         flush_window_buffer(win);
165
166         gdk_threads_enter();
167
168         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
169
170     /* Move the input_position mark to the end of the window_buffer */
171     GtkTextMark *input_position = gtk_text_buffer_get_mark(buffer, "input_position");
172     GtkTextIter end_iter;
173     gtk_text_buffer_get_end_iter(buffer, &end_iter);
174     gtk_text_buffer_move_mark(buffer, input_position, &end_iter);
175
176     /* Set the entire contents of the window_buffer as uneditable
177      * (so input can only be entered at the end) */
178     GtkTextIter start_iter;
179     gtk_text_buffer_get_start_iter(buffer, &start_iter);
180     gtk_text_buffer_remove_tag_by_name(buffer, "uneditable", &start_iter, &end_iter);
181     gtk_text_buffer_apply_tag_by_name(buffer, "uneditable", &start_iter, &end_iter);
182
183     /* Insert pre-entered text if needed */
184     if(insert) {
185         gtk_text_buffer_insert(buffer, &end_iter, inserttext, -1);
186                 gtk_text_buffer_get_end_iter(buffer, &end_iter); /* update after text insertion */
187         }
188
189         /* Apply the correct style to the input prompt */
190         GtkTextIter input_iter;
191     gtk_text_buffer_get_iter_at_mark(buffer, &input_iter, input_position);
192     gtk_text_buffer_apply_tag_by_name(buffer, "input", &input_iter, &end_iter);
193
194     gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), TRUE);
195
196         g_signal_handler_unblock(buffer, win->insert_text_handler);
197         gtk_widget_grab_focus(win->widget);
198
199         gdk_threads_leave();
200 }
201
202 /**
203  * glk_request_line_event:
204  * @win: A text buffer or text grid window to request line input on.
205  * @buf: A buffer of at least @maxlen bytes.
206  * @maxlen: Length of the buffer.
207  * @initlen: The number of characters in @buf to pre-enter.
208  *
209  * Requests input of a line of Latin-1 characters. A window cannot have requests
210  * for both character and line input at the same time. Nor can it have requests
211  * for line input of both types (Latin-1 and Unicode). It is illegal to call
212  * glk_request_line_event() if the window already has a pending request for
213  * either character or line input.
214  *
215  * The @buf argument is a pointer to space where the line input will be stored.
216  * (This may not be %NULL.) @maxlen is the length of this space, in bytes; the
217  * library will not accept more characters than this. If @initlen is nonzero,
218  * then the first @initlen bytes of @buf will be entered as pre-existing input
219  * — just as if the player had typed them himself. (The player can continue
220  * composing after this pre-entered input, or delete it or edit as usual.)
221  *
222  * The contents of the buffer are undefined until the input is completed (either
223  * by a line input event, or glk_cancel_line_event(). The library may or may not
224  * fill in the buffer as the player composes, while the input is still pending;
225  * it is illegal to change the contents of the buffer yourself.
226  */
227 void
228 glk_request_line_event(winid_t win, char *buf, glui32 maxlen, glui32 initlen)
229 {
230         VALID_WINDOW(win, return);
231         g_return_if_fail(buf);
232         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
233         g_return_if_fail(initlen <= maxlen);
234
235         cancel_old_input_request(win);
236
237         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
238
239         /* Register the buffer */
240         if(glk_data->register_arr)
241         win->buffer_rock = (*glk_data->register_arr)(buf, maxlen, "&+#!Cn");
242
243         win->input_request_type = INPUT_REQUEST_LINE;
244         win->line_input_buffer = buf;
245         win->line_input_buffer_max_len = maxlen;
246
247         gchar *inserttext = (initlen > 0)? g_strndup(buf, initlen) : g_strdup("");
248         switch(win->type)
249         {
250             case wintype_TextBuffer:
251                 text_buffer_request_line_event_common(win, maxlen, (initlen > 0), inserttext);
252                 break;
253             case wintype_TextGrid:
254                 text_grid_request_line_event_common(win, maxlen, (initlen > 0), inserttext);
255                 break;
256     }
257         g_free(inserttext);
258         g_signal_handler_unblock(win->widget, win->line_input_keypress_handler);
259
260         /* Emit the "waiting" signal to let listeners know we are ready for input */
261         g_signal_emit_by_name(glk_data->self, "waiting");
262 }
263
264 /**
265  * glk_request_line_event_uni:
266  * @win: A text buffer or text grid window to request line input on.
267  * @buf: A buffer of at least @maxlen characters.
268  * @maxlen: Length of the buffer.
269  * @initlen: The number of characters in @buf to pre-enter.
270  *
271  * Request input of a line of Unicode characters. This works the same as
272  * glk_request_line_event(), except the result is stored in an array of
273  * <type>glui32</type> values instead of an array of characters, and the values
274  * may be any valid Unicode code points.
275  *
276  * If possible, the library should return fully composed Unicode characters,
277  * rather than strings of base and composition characters.
278  *
279  * <note><para>
280  *   Fully-composed characters are the norm for Unicode text, so an
281  *   implementation that ignores this issue will probably produce the right
282  *   result. However, the game may not want to rely on that. Another factor is
283  *   that case-folding can (occasionally) produce non-normalized text.
284  *   Therefore, to cover all its bases, a game should call
285  *   glk_buffer_to_lower_case_uni(), followed by
286  *   glk_buffer_canon_normalize_uni(), before parsing.
287  * </para></note>
288  *
289  * <note><para>
290  *   Earlier versions of this spec said that line input must always be in
291  *   Unicode Normalization Form C. However, this has not been universally
292  *   implemented. It is also somewhat redundant, for the results noted above.
293  *   Therefore, we now merely recommend that line input be fully composed. The
294  *   game is ultimately responsible for all case-folding and normalization. See
295  *   <link linkend="chimara-Unicode-String-Normalization">Unicode String
296  *   Normalization</link>.
297  * </para></note>
298  */
299 void
300 glk_request_line_event_uni(winid_t win, glui32 *buf, glui32 maxlen, glui32 initlen)
301 {
302         VALID_WINDOW(win, return);
303         g_return_if_fail(buf);
304         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
305         g_return_if_fail(initlen <= maxlen);
306
307         cancel_old_input_request(win);
308         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
309
310         /* Register the buffer */
311         if(glk_data->register_arr)
312         win->buffer_rock = (*glk_data->register_arr)(buf, maxlen, "&+#!Iu");
313
314
315
316         win->input_request_type = INPUT_REQUEST_LINE_UNICODE;
317         win->line_input_buffer_unicode = buf;
318         win->line_input_buffer_max_len = maxlen;
319
320         gchar *utf8;
321         if(initlen > 0) {
322                 utf8 = convert_ucs4_to_utf8(buf, initlen);
323                 if(utf8 == NULL)
324                         return;
325         }
326         else
327                 utf8 = g_strdup("");
328
329     switch(win->type)
330         {
331             case wintype_TextBuffer:
332                 text_buffer_request_line_event_common(win, maxlen, (initlen > 0), utf8);
333                 break;
334             case wintype_TextGrid:
335                 text_grid_request_line_event_common(win, maxlen, (initlen > 0), utf8);
336                 break;
337     }
338     g_signal_handler_unblock(win->widget, win->line_input_keypress_handler);
339         g_free(utf8);
340
341         /* Emit the "waiting" signal to let listeners know we are ready for input */
342         g_signal_emit_by_name(glk_data->self, "waiting");
343 }
344
345 /**
346  * glk_cancel_line_event:
347  * @win: A text buffer or text grid window to cancel line input on.
348  * @event: Will be filled in if the user had already input something.
349  *
350  * This cancels a pending request for line input. (Either Latin-1 or Unicode.)
351  *
352  * The event pointed to by the event argument will be filled in as if the
353  * player had hit <keycap>enter</keycap>, and the input composed so far will be
354  * stored in the buffer; see below. If you do not care about this information,
355  * pass %NULL as the @event argument. (The buffer will still be filled.)
356  *
357  * For convenience, it is legal to call glk_cancel_line_event() even if there
358  * is no line input request on that window. The event type will be set to
359  * %evtype_None in this case.
360  */
361 void
362 glk_cancel_line_event(winid_t win, event_t *event)
363 {
364         VALID_WINDOW(win, return);
365         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
366
367         if(event != NULL) {
368                 event->type = evtype_None;
369                 event->win = win;
370                 event->val1 = 0;
371                 event->val2 = 0;
372         }
373
374         if(win->input_request_type != INPUT_REQUEST_LINE && win->input_request_type != INPUT_REQUEST_LINE_UNICODE)
375                 return;
376
377         g_signal_handler_block( win->widget, win->line_input_keypress_handler );
378
379         int chars_written = 0;
380
381         gdk_threads_enter();
382         if(win->type == wintype_TextGrid) {
383                 chars_written = finish_text_grid_line_input(win, FALSE);
384         } else if(win->type == wintype_TextBuffer) {
385                 gtk_text_view_set_editable( GTK_TEXT_VIEW(win->widget), FALSE );
386                 GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
387                 g_signal_handler_block(window_buffer, win->insert_text_handler);
388                 chars_written = finish_text_buffer_line_input(win, FALSE);
389         }
390         gdk_threads_leave();
391
392         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
393         if(glk_data->unregister_arr)
394         {
395                 if(win->input_request_type == INPUT_REQUEST_LINE_UNICODE)
396                         (*glk_data->unregister_arr)(win->line_input_buffer_unicode, win->line_input_buffer_max_len, "&+#!Iu", win->buffer_rock);
397                 else
398                 (*glk_data->unregister_arr)(win->line_input_buffer, win->line_input_buffer_max_len, "&+#!Cn", win->buffer_rock);
399     }
400
401         if(event != NULL && chars_written > 0) {
402                 event->type = evtype_LineInput;
403                 event->val1 = chars_written;
404         }
405 }
406
407 /* Helper function: Turn off shutdown key-press-event signal handler */
408 static gboolean
409 turn_off_handler(GNode *node)
410 {
411         winid_t win = node->data;
412         g_signal_handler_block(win->widget, win->shutdown_keypress_handler);
413         return FALSE; /* don't stop */
414 }
415
416 /* Internal function: Callback for signal key-press-event while waiting for shutdown. */
417 gboolean
418 on_shutdown_key_press_event(GtkWidget *widget, GdkEventKey *event, winid_t win)
419 {
420         ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(widget, CHIMARA_TYPE_GLK));
421         g_assert(glk);
422         CHIMARA_GLK_USE_PRIVATE(glk, priv);
423         
424         /* Turn off all the signal handlers */
425         if(priv->root_window)
426                 g_node_traverse(priv->root_window, G_IN_ORDER, G_TRAVERSE_LEAVES, -1, (GNodeTraverseFunc)turn_off_handler, NULL);
427         
428         /* Signal the Glk library that it can shut everything down now */
429         g_mutex_lock(priv->shutdown_lock);
430         g_cond_signal(priv->shutdown_key_pressed);
431         g_mutex_unlock(priv->shutdown_lock);
432         
433         return TRUE; /* block the event */
434 }
435
436 /* Internal function: General callback for signal key-press-event on a text buffer or text grid window. Used in character input on both text buffers and grids. Blocked when not in use. */
437 gboolean
438 on_char_input_key_press_event(GtkWidget *widget, GdkEventKey *event, winid_t win)
439 {
440         /* Ignore modifier keys, otherwise the char input will already trigger on 
441         the shift key when the user tries to type a capital letter */
442         if(event->is_modifier)
443                 return FALSE; /* don't stop the event */
444
445         /* All text up to the input position is now regarded as being read by the user */
446         if(win->type == wintype_TextBuffer)
447                 pager_update(win);
448         
449         glui32 keycode = keyval_to_glk_keycode(event->keyval, win->input_request_type == INPUT_REQUEST_CHARACTER_UNICODE);
450
451         ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(widget, CHIMARA_TYPE_GLK));
452         g_assert(glk);
453         event_throw(glk, evtype_CharInput, win, keycode, 0);
454         g_signal_emit_by_name(glk, "char-input", win->rock, event->keyval);
455
456         /* Only one keypress will be handled */
457         win->input_request_type = INPUT_REQUEST_NONE;
458         g_signal_handler_block(win->widget, win->char_input_keypress_handler);
459
460         return TRUE;
461 }
462
463 gboolean
464 on_line_input_key_press_event(GtkWidget *widget, GdkEventKey *event, winid_t win)
465 {
466         switch(win->type)
467         {
468                 case wintype_TextBuffer:
469                         /* All text up to the input position is now regarded as being read by the user */
470                         pager_update(win);
471
472                         /* History up/down */
473                         if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up
474                                 || event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
475                         {
476                                 /* Prevent falling off the end of the history list */
477                                 if(win->history == NULL)
478                                         return TRUE;
479                                 if( (event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
480                                         && win->history_pos && win->history_pos->next == NULL)
481                                         return TRUE;
482                                 if( (event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
483                                         && (win->history_pos == NULL || win->history_pos->prev == NULL) )
484                                         return TRUE;
485
486                                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(win->widget));
487                                 GtkTextIter start, end;
488                                 /* Erase any text that was already typed */
489                                 GtkTextMark *input_position = gtk_text_buffer_get_mark(buffer, "input_position");
490                                 gtk_text_buffer_get_iter_at_mark(buffer, &start, input_position);
491                                 gtk_text_buffer_get_end_iter(buffer, &end);
492
493                                 if(win->history_pos == NULL) {
494                                         gchar *current_input = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
495                                         win->history = g_list_prepend(win->history, current_input);
496                                         win->history_pos = win->history;
497                                 }
498
499                                 gtk_text_buffer_delete(buffer, &start, &end);
500
501                                 if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
502                                 {
503                                         if(win->history_pos)
504                                                 win->history_pos = g_list_next(win->history_pos);
505                                         else
506                                                 win->history_pos = win->history;
507                                 }
508                                 else /* down */
509                                         win->history_pos = g_list_previous(win->history_pos);
510
511                                 /* Insert the history item into the window */
512                                 gtk_text_buffer_get_end_iter(buffer, &end);
513
514                                 g_signal_handler_block(buffer, win->insert_text_handler);
515                                 gtk_text_buffer_insert_with_tags_by_name(buffer, &end, win->history_pos->data, -1, "default", "input", NULL);
516                                 g_signal_handler_unblock(buffer, win->insert_text_handler);
517                                 return TRUE;
518                         }
519
520                         /* Move to beginning/end of input field */
521                         else if(event->keyval == GDK_Home) {
522                                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(win->widget));
523                                 GtkTextIter input_iter;
524                                 GtkTextMark *input_position = gtk_text_buffer_get_mark(buffer, "input_position");
525                                 gtk_text_buffer_get_iter_at_mark(buffer, &input_iter, input_position);
526                                 gtk_text_buffer_place_cursor(buffer, &input_iter);
527                                 return TRUE;
528                         }
529                         else if(event->keyval == GDK_End) {
530                                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(win->widget));
531                                 GtkTextIter end_iter;
532                                 gtk_text_buffer_get_end_iter(buffer, &end_iter);
533                                 gtk_text_buffer_place_cursor(buffer, &end_iter);
534                                 return TRUE;
535                         }
536
537                         /* Handle the enter key, which could occur in the middle of the sentence. */
538                         else if(event->keyval == GDK_Return || event->keyval == GDK_KP_Enter) {
539                                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(win->widget));
540                                 GtkTextIter end_iter;
541                                 gtk_text_buffer_get_end_iter(buffer, &end_iter);
542                                 gtk_text_buffer_place_cursor(buffer, &end_iter);
543                                 return FALSE; 
544                         }
545
546                         return FALSE;
547
548                 /* If this is a text grid window, then redirect the key press to the line input GtkEntry */
549                 case wintype_TextGrid:
550                 {
551                         if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up
552                                 || event->keyval == GDK_Down || event->keyval == GDK_KP_Down
553                                 || event->keyval == GDK_Left || event->keyval == GDK_KP_Left
554                                 || event->keyval == GDK_Right || event->keyval == GDK_KP_Right
555                                 || event->keyval == GDK_Tab || event->keyval == GDK_KP_Tab
556                                 || event->keyval == GDK_Page_Up || event->keyval == GDK_KP_Page_Up
557                                 || event->keyval == GDK_Page_Down || event->keyval == GDK_KP_Page_Down
558                                 || event->keyval == GDK_Home || event->keyval == GDK_KP_Home
559                                 || event->keyval == GDK_End || event->keyval == GDK_KP_End)
560                                 return FALSE; /* Don't redirect these keys */
561                         gtk_widget_grab_focus(win->input_entry);
562                         gtk_editable_set_position(GTK_EDITABLE(win->input_entry), -1);
563                         gboolean retval = TRUE;
564                         g_signal_emit_by_name(win->input_entry, "key-press-event", event, &retval);
565                         return retval; /* Block this key event if the entry handled it */
566                 }
567         }
568         return FALSE;
569 }
570
571 /* Internal function: finish handling a line input request, for both text grid and text buffer windows. */
572 static int
573 write_to_window_buffer(winid_t win, const gchar *inserted_text)
574 {
575         int copycount = 0;
576
577     /* Convert the string from UTF-8 to Latin-1 or Unicode */
578     if(win->input_request_type == INPUT_REQUEST_LINE)
579     {
580         gsize bytes_written;
581         gchar *latin1 = convert_utf8_to_latin1(inserted_text, &bytes_written);
582
583         if(latin1 == NULL)
584             return 0;
585
586         /* Place input in the echo stream */
587         if(win->echo_stream != NULL)
588             glk_put_string_stream(win->echo_stream, latin1);
589
590         /* Copy the string (bytes_written does not include the NULL at the end) */
591         copycount = MIN(win->line_input_buffer_max_len, bytes_written);
592         memcpy(win->line_input_buffer, latin1, copycount);
593         g_free(latin1);
594     }
595     else if(win->input_request_type == INPUT_REQUEST_LINE_UNICODE)
596     {
597         glong items_written;
598         gunichar *unicode = convert_utf8_to_ucs4(inserted_text, &items_written);
599
600         if(unicode == NULL)
601             return 0;
602
603         /* Place input in the echo stream */
604         if(win->echo_stream != NULL)
605             glk_put_string_stream_uni(win->echo_stream, unicode);
606
607         /* Copy the string (but not the NULL at the end) */
608         copycount = MIN(win->line_input_buffer_max_len, items_written);
609         memcpy(win->line_input_buffer_unicode, unicode, copycount * sizeof(gunichar));
610         g_free(unicode);
611     }
612     else
613         WARNING("Wrong input request type");
614
615     win->input_request_type = INPUT_REQUEST_NONE;
616         return copycount;
617 }
618
619 /* Internal function: Retrieves the input of a TextBuffer window and stores it in the window buffer.
620  * Returns the number of characters written, suitable for inclusion in a line input event. */
621 static int
622 finish_text_buffer_line_input(winid_t win, gboolean emit_signal)
623 {
624         VALID_WINDOW(win, return 0);
625         g_return_val_if_fail(win->type == wintype_TextBuffer, 0);
626
627         GtkTextIter start_iter, end_iter, last_character;
628
629         GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
630         GtkTextMark *input_position = gtk_text_buffer_get_mark(window_buffer, "input_position");
631         gtk_text_buffer_get_iter_at_mark(window_buffer, &start_iter, input_position);
632         gtk_text_buffer_get_end_iter(window_buffer, &end_iter);
633         gtk_text_buffer_get_end_iter(window_buffer, &last_character);
634         gtk_text_iter_backward_cursor_position(&last_character);
635
636         gchar* last_char = gtk_text_buffer_get_text(window_buffer, &last_character, &end_iter, FALSE);
637
638         if( strchr(last_char, '\n') != NULL )
639                 gtk_text_iter_backward_cursor_position(&end_iter);
640
641         gchar* inserted_text = gtk_text_buffer_get_text(window_buffer, &start_iter, &end_iter, FALSE);
642
643         int chars_written = write_to_window_buffer(win, inserted_text);
644         if(emit_signal)
645         {
646                 ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(win->widget, CHIMARA_TYPE_GLK));
647                 g_assert(glk);
648                 g_signal_emit_by_name(glk, "line-input", win->rock, inserted_text);
649         }
650
651         /* Add the text to the window input history */
652         if(win->history_pos != NULL)
653         {
654                 g_free(win->history->data);
655                 win->history = g_list_delete_link(win->history, win->history);
656         }
657         if(*inserted_text != 0)
658                 win->history = g_list_prepend(win->history, g_strdup(inserted_text));
659
660         win->history_pos = NULL;
661
662         g_free(inserted_text);
663
664         return chars_written;
665 }
666
667 /* Internal function: Retrieves the input of a TextGrid window and stores it in the window buffer.
668  * Returns the number of characters written, suitable for inclusion in a line input event. */
669 static int
670 finish_text_grid_line_input(winid_t win, gboolean emit_signal)
671 {
672         VALID_WINDOW(win, return 0);
673         g_return_val_if_fail(win->type == wintype_TextGrid, 0);
674
675         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
676
677         gchar *text = g_strdup( gtk_entry_get_text(GTK_ENTRY(win->input_entry)) );
678         /* Move the focus back into the text view */
679         gtk_widget_grab_focus(win->widget);
680         /* Remove entry widget from text view */
681         /* Should be ok even though this is the widget's own signal handler */
682         gtk_container_remove( GTK_CONTAINER(win->widget), GTK_WIDGET(win->input_entry) );
683         win->input_entry = NULL;
684         /* Delete the child anchor */
685         GtkTextIter start, end;
686         gtk_text_buffer_get_iter_at_child_anchor(buffer, &start, win->input_anchor);
687         end = start;
688         gtk_text_iter_forward_char(&end); /* Point after the child anchor */
689         gtk_text_buffer_delete(buffer, &start, &end);
690         win->input_anchor = NULL;
691
692     gchar *spaces = g_strnfill(win->input_length - g_utf8_strlen(text, -1), ' ');
693     gchar *text_to_insert = g_strconcat(text, spaces, NULL);
694         g_free(spaces);
695     gtk_text_buffer_insert(buffer, &start, text_to_insert, -1);
696     g_free(text_to_insert);
697
698     int chars_written = write_to_window_buffer(win, text);
699     if(emit_signal)
700     {
701                 ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(win->widget, CHIMARA_TYPE_GLK));
702                 g_assert(glk);
703                 g_signal_emit_by_name(glk, "line-input", win->rock, text);
704     }
705
706         /* Add the text to the window input history */
707         if(win->history_pos != NULL)
708         {
709                 g_free(win->history->data);
710                 win->history = g_list_delete_link(win->history, win->history);
711         }
712         if(*text != 0)
713                 win->history = g_list_prepend(win->history, g_strdup(text));
714         win->history_pos = NULL;
715
716         g_free(text);
717         return chars_written;
718 }
719
720 /* Internal function: Callback for signal insert-text on a text buffer window.
721 Runs after the default handler has already inserted the text.
722 FIXME: This function assumes that newline was the last character typed into the
723 window. That assumption is wrong if, for example, text containing a newline was
724 pasted into the window. */
725 void
726 after_window_insert_text(GtkTextBuffer *textbuffer, GtkTextIter *location, gchar *text, gint len, winid_t win)
727 {
728         GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
729
730         /* Set the history position to NULL and erase the text we were already editing */
731         if(win->history_pos != NULL)
732         {
733                 g_free(win->history->data);
734                 win->history = g_list_delete_link(win->history, win->history);
735                 win->history_pos = NULL;
736         }
737         if( strchr(text, '\n') != NULL )
738         {
739                 /* Remove signal handlers */
740                 g_signal_handler_block(window_buffer, win->insert_text_handler);
741                 g_signal_handler_block(win->widget, win->line_input_keypress_handler);
742
743                 /* Make the window uneditable again and retrieve the text that was input */
744         gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), FALSE);
745
746         int chars_written = finish_text_buffer_line_input(win, TRUE);
747         ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(win->widget, CHIMARA_TYPE_GLK));
748                 event_throw(glk, evtype_LineInput, win, chars_written, 0);
749         }
750
751         /* Apply the 'input' style to the text that was entered */
752         GtkTextIter end_iter;
753         gtk_text_buffer_get_end_iter(window_buffer, &end_iter);
754         GtkTextIter input_iter;
755         GtkTextMark *input_position = gtk_text_buffer_get_mark(window_buffer, "input_position");
756         gtk_text_buffer_get_iter_at_mark(window_buffer, &input_iter, input_position);
757         gtk_text_buffer_apply_tag_by_name(window_buffer, "input", &input_iter, &end_iter);
758 }
759
760 /* Internal function: Callback for signal activate on the line input GtkEntry
761 in a text grid window. */
762 void
763 on_input_entry_activate(GtkEntry *input_entry, winid_t win)
764 {
765         g_signal_handler_block(win->widget, win->line_input_keypress_handler);
766
767         int chars_written = finish_text_grid_line_input(win, TRUE);
768         ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(win->widget, CHIMARA_TYPE_GLK));
769         event_throw(glk, evtype_LineInput, win, chars_written, 0);
770 }
771
772 /* Internal function: Callback for signal key-press-event on the line input
773 GtkEntry in a text grid window. */
774 gboolean
775 on_input_entry_key_press_event(GtkEntry *input_entry, GdkEventKey *event, winid_t win)
776 {
777         if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up
778                 || event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
779         {
780                 /* Prevent falling off the end of the history list */
781                 if( (event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
782                         && win->history_pos && win->history_pos->next == NULL)
783                         return TRUE;
784                 if( (event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
785                         && (win->history_pos == NULL || win->history_pos->prev == NULL) )
786                         return TRUE;
787
788                 if(win->history_pos == NULL)
789                 {
790                         const gchar *current_input = gtk_entry_get_text(input_entry);
791                         win->history = g_list_prepend(win->history, g_strdup(current_input));
792                         win->history_pos = win->history;
793                 }
794
795                 if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
796                 {
797                         if(win->history_pos)
798                                 win->history_pos = g_list_next(win->history_pos);
799                         else
800                                 win->history_pos = win->history;
801                 }
802                 else /* down */
803                         win->history_pos = g_list_previous(win->history_pos);
804
805                 /* Insert the history item into the window */
806                 g_signal_handler_block(input_entry, win->line_input_entry_changed);
807                 gtk_entry_set_text(input_entry, win->history_pos->data);
808                 g_signal_handler_unblock(input_entry, win->line_input_entry_changed);
809                 return TRUE;
810         }
811         return FALSE;
812 }
813
814 void
815 on_input_entry_changed(GtkEditable *editable, winid_t win)
816 {
817         /* Set the history position to NULL and erase the text we were already editing */
818         if(win->history_pos != NULL)
819         {
820                 g_free(win->history->data);
821                 win->history = g_list_delete_link(win->history, win->history);
822                 win->history_pos = NULL;
823         }
824 }
825
826 glui32
827 keyval_to_glk_keycode(guint keyval, gboolean unicode)
828 {
829         glui32 keycode;
830         switch(keyval) {
831                 case GDK_Up:
832                 case GDK_KP_Up: return keycode_Up;
833                 case GDK_Down:
834                 case GDK_KP_Down: return keycode_Down;
835                 case GDK_Left:
836                 case GDK_KP_Left: return keycode_Left;
837                 case GDK_Right:
838                 case GDK_KP_Right: return keycode_Right;
839                 case GDK_Linefeed:
840                 case GDK_Return:
841                 case GDK_KP_Enter: return keycode_Return;
842                 case GDK_Delete:
843                 case GDK_BackSpace:
844                 case GDK_KP_Delete: return keycode_Delete;
845                 case GDK_Escape: return keycode_Escape;
846                 case GDK_Tab:
847                 case GDK_KP_Tab: return keycode_Tab;
848                 case GDK_Page_Up:
849                 case GDK_KP_Page_Up: return keycode_PageUp;
850                 case GDK_Page_Down:
851                 case GDK_KP_Page_Down: return keycode_PageDown;
852                 case GDK_Home:
853                 case GDK_KP_Home: return keycode_Home;
854                 case GDK_End:
855                 case GDK_KP_End: return keycode_End;
856                 case GDK_F1:
857                 case GDK_KP_F1: return keycode_Func1;
858                 case GDK_F2:
859                 case GDK_KP_F2: return keycode_Func2;
860                 case GDK_F3:
861                 case GDK_KP_F3: return keycode_Func3;
862                 case GDK_F4:
863                 case GDK_KP_F4: return keycode_Func4;
864                 case GDK_F5: return keycode_Func5;
865                 case GDK_F6: return keycode_Func6;
866                 case GDK_F7: return keycode_Func7;
867                 case GDK_F8: return keycode_Func8;
868                 case GDK_F9: return keycode_Func9;
869                 case GDK_F10: return keycode_Func10;
870                 case GDK_F11: return keycode_Func11;
871                 case GDK_F12: return keycode_Func12;
872                 default:
873                         keycode = gdk_keyval_to_unicode(keyval);
874                         /* If keycode is 0, then keyval was not recognized; also return
875                         unknown if Latin-1 input was requested and the character is not in
876                         Latin-1 */
877                         if(keycode == 0 || (!unicode && keycode > 255))
878                                 return keycode_Unknown;
879                         return keycode;
880         }
881 }
882
883 void
884 force_char_input_from_queue(winid_t win, event_t *event)
885 {
886         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
887         guint keyval = GPOINTER_TO_UINT(g_async_queue_pop(glk_data->char_input_queue));
888
889         glk_cancel_char_event(win);
890
891         gdk_threads_enter();
892         ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(win->widget, CHIMARA_TYPE_GLK));
893         g_assert(glk);
894         g_signal_emit_by_name(glk, "char-input", win->rock, keyval);
895         gdk_threads_leave();
896
897         event->type = evtype_CharInput;
898         event->win = win;
899         event->val1 = keyval_to_glk_keycode(keyval, win->input_request_type == INPUT_REQUEST_CHARACTER_UNICODE);
900         event->val2 = 0;
901 }
902
903 void
904 force_line_input_from_queue(winid_t win, event_t *event)
905 {
906         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
907         const gchar *text = g_async_queue_pop(glk_data->line_input_queue);
908         glui32 chars_written = 0;
909
910         gdk_threads_enter();
911         if(win->type == wintype_TextBuffer)
912         {
913                 GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
914                 GtkTextIter start, end;
915
916                 /* Remove signal handlers so the line input doesn't get picked up again */
917                 g_signal_handler_block(buffer, win->insert_text_handler);
918                 g_signal_handler_block(win->widget, win->line_input_keypress_handler);
919
920                 /* Erase any text that was already typed */
921                 GtkTextMark *input_position = gtk_text_buffer_get_mark(buffer, "input_position");
922                 gtk_text_buffer_get_iter_at_mark(buffer, &start, input_position);
923                 gtk_text_buffer_get_end_iter(buffer, &end);
924                 gtk_text_buffer_delete(buffer, &start, &end);
925
926                 /* Make the window uneditable again */
927                 gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), FALSE);
928
929                 /* Insert the forced input into the window */
930                 gtk_text_buffer_get_end_iter(buffer, &end);
931                 gchar *text_to_insert = g_strconcat(text, "\n", NULL);
932                 gtk_text_buffer_insert_with_tags_by_name(buffer, &end, text_to_insert, -1, "default", "input", NULL);
933                 chars_written = finish_text_buffer_line_input(win, TRUE);
934         }
935         else if(win->type == wintype_TextGrid)
936         {
937                 /* Remove signal handlers so the line input doesn't get picked up again */
938                 g_signal_handler_block(win->widget, win->char_input_keypress_handler);
939
940                 /* Insert the forced input into the window */
941                 gtk_entry_set_text(GTK_ENTRY(win->input_entry), text);
942                 chars_written = finish_text_grid_line_input(win, TRUE);
943         }
944         gdk_threads_leave();
945
946         event->type = evtype_LineInput;
947         event->win = win;
948         event->val1 = chars_written;
949         event->val2 = 0;
950 }
951
952 /*** Internal function: cancels any pending input requests on the window and presents a warning if not INPUT_REQUEST_NONE ***/
953 void
954 cancel_old_input_request(winid_t win)
955 {
956         switch(win->input_request_type) {
957         case INPUT_REQUEST_NONE:
958                 break; /* All is well */
959         case INPUT_REQUEST_CHARACTER:
960         case INPUT_REQUEST_CHARACTER_UNICODE:
961                 glk_cancel_char_event(win);
962                 WARNING("Cancelling pending char event");
963                 break;
964         case INPUT_REQUEST_LINE:
965         case INPUT_REQUEST_LINE_UNICODE:
966                 glk_cancel_line_event(win, NULL);
967                 WARNING("Cancelling pending line event");
968                 break;
969         default:
970                 WARNING("Could not cancel pending input request: unknown input request");
971         }
972 }
973
974 /**
975  * glk_set_echo_line_event:
976  * @win: The window in which to change the echoing behavior.
977  * @val: Zero to turn off echoing, nonzero for normal echoing.
978  *
979  * Normally, after line input is completed or cancelled in a buffer window, the
980  * library ensures that the complete input line (or its latest state, after
981  * cancelling) is displayed at the end of the buffer, followed by a newline.
982  * This call allows you to suppress this behavior. If the @val argument is zero,
983  * all <emphasis>subsequent</emphasis> line input requests in the given window
984  * will leave the buffer unchanged after the input is completed or cancelled;
985  * the player's input will not be printed. If @val is nonzero, subsequent input
986  * requests will have the normal printing behavior.
987  *
988  * <note><para>
989  *   Note that this feature is unrelated to the window's echo stream.
990  * </para></note>
991  *
992  * If you turn off line input echoing, you can reproduce the standard input
993  * behavior by following each line input event (or line input cancellation) by
994  * printing the input line, in the Input style, followed by a newline in the
995  * original style.
996  *
997  * The glk_set_echo_line_event() does not affect a pending line input request.
998  * It also has no effect in non-buffer windows.
999  * <note><para>
1000  *   In a grid window, the game can overwrite the input area at will, so there
1001  *   is no need for this distinction.
1002  * </para></note>
1003  *
1004  * Not all libraries support this feature. You can test for it with
1005  * %gestalt_LineInputEcho.
1006  */
1007 void
1008 glk_set_echo_line_event(winid_t win, glui32 val)
1009 {
1010         VALID_WINDOW(win, return);
1011 }
1012
1013 /**
1014  * glk_set_terminators_line_event:
1015  * @win: The window for which to set the line input terminator keys.
1016  * @keycodes: An array of <code>keycode_</code> constants, of length @count.
1017  * @count: The array length of @keycodes.
1018  *
1019  * It is possible to request that other keystrokes complete line input as well.
1020  * (This allows a game to intercept function keys or other special keys during
1021  * line input.) To do this, call glk_set_terminators_line_event(), and pass an
1022  * array of @count keycodes. These must all be special keycodes (see <link
1023  * linkend="chimara-Character-Input">Character Input</link>). Do not include
1024  * regular printable characters in the array, nor %keycode_Return (which
1025  * represents the default <keycap>enter</keycap> key and will always be
1026  * recognized). To return to the default behavior, pass a %NULL or empty array.
1027  *
1028  * The glk_set_terminators_line_event() affects <emphasis>subsequent</emphasis>
1029  * line input requests in the given window. It does not affect a pending line
1030  * input request.
1031  *
1032  * <note><para>
1033  *   This distinction makes life easier for interpreters that set up UI
1034  *   callbacks only at the start of input.
1035  * </para></note>
1036  *
1037  * A library may not support this feature; if it does, it may not support all
1038  * special keys as terminators. (Some keystrokes are reserved for OS or
1039  * interpreter control.) You can test for this with %gestalt_LineTerminators and
1040  * %gestalt_LineTerminatorKey.
1041  */
1042 void
1043 glk_set_terminators_line_event(winid_t win, glui32 *keycodes, glui32 count)
1044 {
1045         VALID_WINDOW(win, return);
1046 }