4 #include "chimara-glk-private.h"
6 extern GPrivate *glk_data_key;
8 /* Forward declarations */
9 static int finish_text_buffer_line_input(winid_t win, gboolean emit_signal);
10 static int finish_text_grid_line_input(winid_t win, gboolean emit_signal);
12 /* Internal function: code common to both flavors of char event request */
14 request_char_event_common(winid_t win, gboolean unicode)
16 VALID_WINDOW(win, return);
17 g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
18 g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
20 flush_window_buffer(win);
22 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
24 win->input_request_type = unicode? INPUT_REQUEST_CHARACTER_UNICODE : INPUT_REQUEST_CHARACTER;
25 g_signal_handler_unblock( G_OBJECT(win->widget), win->keypress_handler );
29 /* If the request is in a text buffer window, scroll to the end of the
30 text buffer. TODO: This may scroll text off the top of the window that the
31 user hasn't read yet. We need to implement a paging mechanism. */
32 if(win->type == wintype_TextBuffer)
34 GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
36 gtk_text_buffer_get_end_iter(buffer, &iter);
37 gtk_text_buffer_place_cursor(buffer, &iter);
38 gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(win->widget), gtk_text_buffer_get_insert(buffer));
39 /* Why doesn't this always work?? */
42 gtk_widget_grab_focus( GTK_WIDGET(win->widget) );
45 /* Emit the "waiting" signal to let listeners know we are ready for input */
46 g_signal_emit_by_name(glk_data->self, "waiting");
50 * glk_request_char_event:
51 * @win: A window to request char events from.
53 * Request input of a Latin-1 character or special key. A window cannot have
54 * requests for both character and line input at the same time. Nor can it have
55 * requests for character input of both types (Latin-1 and Unicode). It is
56 * illegal to call glk_request_char_event() if the window already has a pending
57 * request for either character or line input.
60 glk_request_char_event(winid_t win)
62 request_char_event_common(win, FALSE);
66 * glk_request_char_event_uni:
67 * @win: A window to request char events from.
69 * Request input of a Unicode character or special key. See
70 * glk_request_char_event().
73 glk_request_char_event_uni(winid_t win)
75 request_char_event_common(win, TRUE);
79 * glk_cancel_char_event:
80 * @win: A window to cancel the latest char event request on.
82 * This cancels a pending request for character input. (Either Latin-1 or
83 * Unicode.) For convenience, it is legal to call glk_cancel_char_event() even
84 * if there is no charcter input request on that window. Glk will ignore the
88 glk_cancel_char_event(winid_t win)
90 VALID_WINDOW(win, return);
91 g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
93 if(win->input_request_type == INPUT_REQUEST_CHARACTER || win->input_request_type == INPUT_REQUEST_CHARACTER_UNICODE)
95 win->input_request_type = INPUT_REQUEST_NONE;
96 g_signal_handler_block( G_OBJECT(win->widget), win->keypress_handler );
100 /* Internal function: Request either latin-1 or unicode line input, in a text grid window. */
102 text_grid_request_line_event_common(winid_t win, glui32 maxlen, gboolean insert, gchar *inserttext)
106 GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
108 GtkTextMark *cursor = gtk_text_buffer_get_mark(buffer, "cursor_position");
109 GtkTextIter start_iter, end_iter;
110 gtk_text_buffer_get_iter_at_mark(buffer, &start_iter, cursor);
112 /* Determine the maximum length of the line input */
113 gint cursorpos = gtk_text_iter_get_line_offset(&start_iter);
114 /* Odd; the Glk spec says the maximum input length is
115 windowwidth - 1 - cursorposition. I say no, because if cursorposition is
116 zero, then the input should fill the whole line. FIXME??? */
117 win->input_length = MIN(win->width - cursorpos, win->line_input_buffer_max_len);
118 end_iter = start_iter;
119 gtk_text_iter_set_line_offset(&end_iter, cursorpos + win->input_length);
121 /* If the buffer currently has a selection with one bound in the middle of
122 the input field, then deselect it. Otherwise the input field gets trashed */
123 GtkTextIter start_sel, end_sel;
124 if( gtk_text_buffer_get_selection_bounds(buffer, &start_sel, &end_sel) )
126 if( gtk_text_iter_in_range(&start_sel, &start_iter, &end_iter) )
127 gtk_text_buffer_place_cursor(buffer, &end_sel);
128 if( gtk_text_iter_in_range(&end_sel, &start_iter, &end_iter) )
129 gtk_text_buffer_place_cursor(buffer, &start_sel);
132 /* Erase the text currently in the input field and replace it with a GtkEntry */
133 gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
134 win->input_anchor = gtk_text_buffer_create_child_anchor(buffer, &start_iter);
135 win->input_entry = gtk_entry_new();
136 /* Set the entry's font to match that of the window */
137 GtkRcStyle *style = gtk_widget_get_modifier_style(win->widget); /* Don't free */
138 gtk_widget_modify_font(win->input_entry, style->font_desc);
139 /* Make the entry as small as possible to fit with the text */
140 gtk_entry_set_has_frame(GTK_ENTRY(win->input_entry), FALSE);
141 GtkBorder border = { 0, 0, 0, 0 };
142 gtk_entry_set_inner_border(GTK_ENTRY(win->input_entry), &border);
143 gtk_entry_set_max_length(GTK_ENTRY(win->input_entry), win->input_length);
144 gtk_entry_set_width_chars(GTK_ENTRY(win->input_entry), win->input_length);
146 /* Insert pre-entered text if needed */
148 gtk_entry_set_text(GTK_ENTRY(win->input_entry), inserttext);
150 /* Set background color of entry (TODO: implement as property) */
152 gdk_color_parse("grey", &background);
153 gtk_widget_modify_base(win->input_entry, GTK_STATE_NORMAL, &background);
155 g_signal_connect(win->input_entry, "activate", G_CALLBACK(on_input_entry_activate), win);
157 gtk_widget_show(win->input_entry);
158 gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(win->widget), win->input_entry, win->input_anchor);
160 g_signal_handler_unblock( G_OBJECT(win->widget), win->keypress_handler );
162 gtk_widget_grab_focus(win->input_entry);
167 /* Internal function: Request either latin-1 or unicode line input, in a text buffer window. */
169 text_buffer_request_line_event_common(winid_t win, glui32 maxlen, gboolean insert, gchar *inserttext)
171 flush_window_buffer(win);
175 GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
177 /* Move the input_position mark to the end of the window_buffer */
178 GtkTextMark *input_position = gtk_text_buffer_get_mark(buffer, "input_position");
179 GtkTextIter end_iter;
180 gtk_text_buffer_get_end_iter(buffer, &end_iter);
181 gtk_text_buffer_move_mark(buffer, input_position, &end_iter);
183 /* Set the entire contents of the window_buffer as uneditable
184 * (so input can only be entered at the end) */
185 GtkTextIter start_iter;
186 gtk_text_buffer_get_start_iter(buffer, &start_iter);
187 gtk_text_buffer_remove_tag_by_name(buffer, "uneditable", &start_iter, &end_iter);
188 gtk_text_buffer_apply_tag_by_name(buffer, "uneditable", &start_iter, &end_iter);
190 /* Insert pre-entered text if needed */
192 gtk_text_buffer_insert(buffer, &end_iter, inserttext, -1);
194 /* Scroll to input point */
195 gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(win->widget), input_position);
197 gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), TRUE);
198 g_signal_handler_unblock(buffer, win->insert_text_handler);
200 gtk_widget_grab_focus(win->widget);
206 * glk_request_line_event:
207 * @win: A text buffer or text grid window to request line input on.
208 * @buf: A buffer of at least @maxlen bytes.
209 * @maxlen: Length of the buffer.
210 * @initlen: The number of characters in @buf to pre-enter.
212 * Requests input of a line of Latin-1 characters. A window cannot have requests
213 * for both character and line input at the same time. Nor can it have requests
214 * for line input of both types (Latin-1 and Unicode). It is illegal to call
215 * glk_request_line_event() if the window already has a pending request for
216 * either character or line input.
218 * The @buf argument is a pointer to space where the line input will be stored.
219 * (This may not be %NULL.) @maxlen is the length of this space, in bytes; the
220 * library will not accept more characters than this. If @initlen is nonzero,
221 * then the first @initlen bytes of @buf will be entered as pre-existing input
222 * — just as if the player had typed them himself. (The player can continue
223 * composing after this pre-entered input, or delete it or edit as usual.)
225 * The contents of the buffer are undefined until the input is completed (either
226 * by a line input event, or glk_cancel_line_event(). The library may or may not
227 * fill in the buffer as the player composes, while the input is still pending;
228 * it is illegal to change the contents of the buffer yourself.
231 glk_request_line_event(winid_t win, char *buf, glui32 maxlen, glui32 initlen)
233 VALID_WINDOW(win, return);
234 g_return_if_fail(buf);
235 g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
236 g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
237 g_return_if_fail(initlen <= maxlen);
239 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
241 /* Register the buffer */
242 if(glk_data->register_arr)
243 win->buffer_rock = (*glk_data->register_arr)(buf, maxlen, "&+#!Cn");
245 win->input_request_type = INPUT_REQUEST_LINE;
246 win->line_input_buffer = buf;
247 win->line_input_buffer_max_len = maxlen;
249 gchar *inserttext = (initlen > 0)? g_strndup(buf, initlen) : g_strdup("");
252 case wintype_TextBuffer:
253 text_buffer_request_line_event_common(win, maxlen, (initlen > 0), inserttext);
255 case wintype_TextGrid:
256 text_grid_request_line_event_common(win, maxlen, (initlen > 0), inserttext);
261 /* Emit the "waiting" signal to let listeners know we are ready for input */
262 g_signal_emit_by_name(glk_data->self, "waiting");
266 * glk_request_line_event_uni:
267 * @win: A text buffer or text grid window to request line input on.
268 * @buf: A buffer of at least @maxlen characters.
269 * @maxlen: Length of the buffer.
270 * @initlen: The number of characters in @buf to pre-enter.
272 * Request input of a line of Unicode characters. This works the same as
273 * glk_request_line_event(), except the result is stored in an array of
274 * <type>glui32</type> values instead of an array of characters, and the values
275 * may be any valid Unicode code points.
277 * The result will be in Unicode Normalization Form C. This basically means that
278 * composite characters will be single characters where possible, instead of
279 * sequences of base and combining marks. See
280 * <ulink url="http://www.unicode.org/reports/tr15/">Unicode Standard Annex
281 * #15</ulink> for the details.
284 glk_request_line_event_uni(winid_t win, glui32 *buf, glui32 maxlen, glui32 initlen)
286 VALID_WINDOW(win, return);
287 g_return_if_fail(buf);
288 g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
289 g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
290 g_return_if_fail(initlen <= maxlen);
292 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
294 /* Register the buffer */
295 if(glk_data->register_arr)
296 win->buffer_rock = (*glk_data->register_arr)(buf, maxlen, "&+#!Iu");
298 win->input_request_type = INPUT_REQUEST_LINE_UNICODE;
299 win->line_input_buffer_unicode = buf;
300 win->line_input_buffer_max_len = maxlen;
304 utf8 = convert_ucs4_to_utf8(buf, initlen);
313 case wintype_TextBuffer:
314 text_buffer_request_line_event_common(win, maxlen, (initlen > 0), utf8);
316 case wintype_TextGrid:
317 text_grid_request_line_event_common(win, maxlen, (initlen > 0), utf8);
322 /* Emit the "waiting" signal to let listeners know we are ready for input */
323 g_signal_emit_by_name(glk_data->self, "waiting");
327 * glk_cancel_line_event:
328 * @win: A text buffer or text grid window to cancel line input on.
329 * @event: Will be filled in if the user had already input something.
331 * This cancels a pending request for line input. (Either Latin-1 or Unicode.)
333 * The event pointed to by the event argument will be filled in as if the
334 * player had hit <keycap>enter</keycap>, and the input composed so far will be
335 * stored in the buffer; see below. If you do not care about this information,
336 * pass %NULL as the @event argument. (The buffer will still be filled.)
338 * For convenience, it is legal to call glk_cancel_line_event() even if there
339 * is no line input request on that window. The event type will be set to
340 * %evtype_None in this case.
343 glk_cancel_line_event(winid_t win, event_t *event)
345 VALID_WINDOW(win, return);
346 g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
349 event->type = evtype_None;
355 if(win->input_request_type != INPUT_REQUEST_LINE && win->input_request_type != INPUT_REQUEST_LINE_UNICODE)
358 g_signal_handler_block( G_OBJECT(win->widget), win->keypress_handler );
360 int chars_written = 0;
362 if(win->type == wintype_TextGrid) {
363 g_signal_handler_block( G_OBJECT(win->widget), win->keypress_handler );
364 chars_written = finish_text_grid_line_input(win, FALSE);
365 } else if(win->type == wintype_TextBuffer) {
366 GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
367 g_signal_handler_block(window_buffer, win->insert_text_handler);
368 chars_written = finish_text_buffer_line_input(win, FALSE);
371 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
372 if(glk_data->unregister_arr)
374 if(win->input_request_type == INPUT_REQUEST_LINE_UNICODE)
375 (*glk_data->unregister_arr)(win->line_input_buffer_unicode, win->line_input_buffer_max_len, "&+#!Iu", win->buffer_rock);
377 (*glk_data->unregister_arr)(win->line_input_buffer, win->line_input_buffer_max_len, "&+#!Cn", win->buffer_rock);
380 if(event != NULL && chars_written > 0) {
381 event->type = evtype_LineInput;
382 event->val1 = chars_written;
386 /* 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, and also in line input on grids, to redirect keystrokes to the line input field. Blocked when not in use. */
388 on_char_input_key_press_event(GtkWidget *widget, GdkEventKey *event, winid_t win)
390 glui32 keycode = keyval_to_glk_keycode(event->keyval, win->input_request_type == INPUT_REQUEST_CHARACTER_UNICODE);
392 ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(widget, CHIMARA_TYPE_GLK));
394 event_throw(glk, evtype_CharInput, win, keycode, 0);
395 g_signal_emit_by_name(glk, "char-input", win->rock, event->keyval);
397 /* Only one keypress will be handled */
398 win->input_request_type = INPUT_REQUEST_NONE;
399 g_signal_handler_block( G_OBJECT(win->widget), win->keypress_handler );
405 on_line_input_key_press_event(GtkWidget *widget, GdkEventKey *event, winid_t win)
409 case wintype_TextBuffer:
410 if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
414 else if(event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
420 /* If this is a text grid window, then redirect the key press to the line input GtkEntry */
421 case wintype_TextGrid:
423 if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up
424 || event->keyval == GDK_Down || event->keyval == GDK_KP_Down
425 || event->keyval == GDK_Left || event->keyval == GDK_KP_Left
426 || event->keyval == GDK_Right || event->keyval == GDK_KP_Right
427 || event->keyval == GDK_Tab || event->keyval == GDK_KP_Tab
428 || event->keyval == GDK_Page_Up || event->keyval == GDK_KP_Page_Up
429 || event->keyval == GDK_Page_Down || event->keyval == GDK_KP_Page_Down
430 || event->keyval == GDK_Home || event->keyval == GDK_KP_Home
431 || event->keyval == GDK_End || event->keyval == GDK_KP_End)
432 return FALSE; /* Don't redirect these keys */
433 gtk_widget_grab_focus(win->input_entry);
434 gtk_editable_set_position(GTK_EDITABLE(win->input_entry), -1);
435 gboolean retval = TRUE;
436 g_signal_emit_by_name(win->input_entry, "key-press-event", event, &retval);
437 return retval; /* Block this key event if the entry handled it */
442 /* Internal function: finish handling a line input request, for both text grid and text buffer windows. */
444 write_to_window_buffer(winid_t win, const gchar *inserted_text)
448 /* Convert the string from UTF-8 to Latin-1 or Unicode */
449 if(win->input_request_type == INPUT_REQUEST_LINE)
452 gchar *latin1 = convert_utf8_to_latin1(inserted_text, &bytes_written);
457 /* Place input in the echo stream */
458 if(win->echo_stream != NULL)
459 glk_put_string_stream(win->echo_stream, latin1);
461 /* Copy the string (bytes_written does not include the NULL at the end) */
462 copycount = MIN(win->line_input_buffer_max_len, bytes_written);
463 memcpy(win->line_input_buffer, latin1, copycount);
466 else if(win->input_request_type == INPUT_REQUEST_LINE_UNICODE)
469 gunichar *unicode = convert_utf8_to_ucs4(inserted_text, &items_written);
474 /* Place input in the echo stream */
475 if(win->echo_stream != NULL)
476 glk_put_string_stream_uni(win->echo_stream, unicode);
478 /* Copy the string (but not the NULL at the end) */
479 copycount = MIN(win->line_input_buffer_max_len, items_written);
480 memcpy(win->line_input_buffer_unicode, unicode, copycount * sizeof(gunichar));
484 WARNING("Wrong input request type");
486 win->input_request_type = INPUT_REQUEST_NONE;
490 /* Internal function: Retrieves the input of a TextBuffer window and stores it in the window buffer.
491 * Returns the number of characters written, suitable for inclusion in a line input event. */
493 finish_text_buffer_line_input(winid_t win, gboolean emit_signal)
495 VALID_WINDOW(win, return 0);
496 g_return_val_if_fail(win->type == wintype_TextBuffer, 0);
498 GtkTextIter start_iter, end_iter, last_character;
500 GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
501 GtkTextMark *input_position = gtk_text_buffer_get_mark(window_buffer, "input_position");
502 gtk_text_buffer_get_iter_at_mark(window_buffer, &start_iter, input_position);
503 gtk_text_buffer_get_end_iter(window_buffer, &end_iter);
504 gtk_text_buffer_get_end_iter(window_buffer, &last_character);
505 gtk_text_iter_backward_cursor_position(&last_character);
507 gchar* last_char = gtk_text_buffer_get_text(window_buffer, &last_character, &end_iter, FALSE);
509 if( strchr(last_char, '\n') != NULL )
510 gtk_text_iter_backward_cursor_position(&end_iter);
512 gchar* inserted_text = gtk_text_buffer_get_text(window_buffer, &start_iter, &end_iter, FALSE);
514 int chars_written = write_to_window_buffer(win, inserted_text);
517 ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(win->widget, CHIMARA_TYPE_GLK));
519 g_signal_emit_by_name(glk, "line-input", win->rock, inserted_text);
522 /* Add the text to the window input history */
523 win->history = g_list_prepend(win->history, g_strdup(inserted_text));
524 win->history_pos = win->history;
526 g_free(inserted_text);
528 return chars_written;
531 /* Internal function: Retrieves the input of a TextGrid window and stores it in the window buffer.
532 * Returns the number of characters written, suitable for inclusion in a line input event. */
534 finish_text_grid_line_input(winid_t win, gboolean emit_signal)
536 VALID_WINDOW(win, return 0);
537 g_return_val_if_fail(win->type == wintype_TextGrid, 0);
539 GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
541 gchar *text = g_strdup( gtk_entry_get_text(GTK_ENTRY(win->input_entry)) );
542 /* Move the focus back into the text view */
543 gtk_widget_grab_focus(win->widget);
544 /* Remove entry widget from text view */
545 /* Should be ok even though this is the widget's own signal handler */
546 gtk_container_remove( GTK_CONTAINER(win->widget), GTK_WIDGET(win->input_entry) );
547 win->input_entry = NULL;
548 /* Delete the child anchor */
549 GtkTextIter start, end;
550 gtk_text_buffer_get_iter_at_child_anchor(buffer, &start, win->input_anchor);
552 gtk_text_iter_forward_char(&end); /* Point after the child anchor */
553 gtk_text_buffer_delete(buffer, &start, &end);
554 win->input_anchor = NULL;
556 gchar *spaces = g_strnfill(win->input_length - g_utf8_strlen(text, -1), ' ');
557 gchar *text_to_insert = g_strconcat(text, spaces, NULL);
559 gtk_text_buffer_insert(buffer, &start, text_to_insert, -1);
560 g_free(text_to_insert);
562 int chars_written = write_to_window_buffer(win, text);
565 ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(win->widget, CHIMARA_TYPE_GLK));
567 g_signal_emit_by_name(glk, "line-input", win->rock, text);
571 return chars_written;
574 /* Internal function: Callback for signal insert-text on a text buffer window.
575 Runs after the default handler has already inserted the text.
576 FIXME: This function assumes that newline was the last character typed into the
577 window. That assumption is wrong if, for example, text containing a newline was
578 pasted into the window. */
580 after_window_insert_text(GtkTextBuffer *textbuffer, GtkTextIter *location, gchar *text, gint len, winid_t win)
582 if( strchr(text, '\n') != NULL )
584 /* Remove signal handlers */
585 GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
586 g_signal_handler_block(window_buffer, win->insert_text_handler);
588 /* Make the window uneditable again and retrieve the text that was input */
589 gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), FALSE);
591 int chars_written = finish_text_buffer_line_input(win, TRUE);
592 ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(win->widget, CHIMARA_TYPE_GLK));
593 event_throw(glk, evtype_LineInput, win, chars_written, 0);
597 /* Internal function: Callback for signal activate on the line input GtkEntry
598 in a text grid window. */
600 on_input_entry_activate(GtkEntry *input_entry, winid_t win)
602 g_signal_handler_block(win->widget, win->keypress_handler);
604 int chars_written = finish_text_grid_line_input(win, TRUE);
605 ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(win->widget, CHIMARA_TYPE_GLK));
606 event_throw(glk, evtype_LineInput, win, chars_written, 0);
610 keyval_to_glk_keycode(guint keyval, gboolean unicode)
615 case GDK_KP_Up: return keycode_Up;
617 case GDK_KP_Down: return keycode_Down;
619 case GDK_KP_Left: return keycode_Left;
621 case GDK_KP_Right: return keycode_Right;
624 case GDK_KP_Enter: return keycode_Return;
627 case GDK_KP_Delete: return keycode_Delete;
628 case GDK_Escape: return keycode_Escape;
630 case GDK_KP_Tab: return keycode_Tab;
632 case GDK_KP_Page_Up: return keycode_PageUp;
634 case GDK_KP_Page_Down: return keycode_PageDown;
636 case GDK_KP_Home: return keycode_Home;
638 case GDK_KP_End: return keycode_End;
640 case GDK_KP_F1: return keycode_Func1;
642 case GDK_KP_F2: return keycode_Func2;
644 case GDK_KP_F3: return keycode_Func3;
646 case GDK_KP_F4: return keycode_Func4;
647 case GDK_F5: return keycode_Func5;
648 case GDK_F6: return keycode_Func6;
649 case GDK_F7: return keycode_Func7;
650 case GDK_F8: return keycode_Func8;
651 case GDK_F9: return keycode_Func9;
652 case GDK_F10: return keycode_Func10;
653 case GDK_F11: return keycode_Func11;
654 case GDK_F12: return keycode_Func12;
656 keycode = gdk_keyval_to_unicode(keyval);
657 /* If keycode is 0, then keyval was not recognized; also return
658 unknown if Latin-1 input was requested and the character is not in
660 if(keycode == 0 || (!unicode && keycode > 255))
661 return keycode_Unknown;
667 force_char_input_from_queue(winid_t win, event_t *event)
669 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
670 guint keyval = GPOINTER_TO_UINT(g_async_queue_pop(glk_data->char_input_queue));
672 glk_cancel_char_event(win);
675 ChimaraGlk *glk = CHIMARA_GLK(gtk_widget_get_ancestor(win->widget, CHIMARA_TYPE_GLK));
677 g_signal_emit_by_name(glk, "char-input", win->rock, keyval);
680 event->type = evtype_CharInput;
682 event->val1 = keyval_to_glk_keycode(keyval, win->input_request_type == INPUT_REQUEST_CHARACTER_UNICODE);
687 force_line_input_from_queue(winid_t win, event_t *event)
689 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
690 const gchar *text = g_async_queue_pop(glk_data->line_input_queue);
691 glui32 chars_written = 0;
694 if(win->type == wintype_TextBuffer)
696 GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
697 GtkTextIter start, end;
699 /* Remove signal handlers so the line input doesn't get picked up again */
700 g_signal_handler_block(buffer, win->insert_text_handler);
702 /* Erase any text that was already typed */
703 GtkTextMark *input_position = gtk_text_buffer_get_mark(buffer, "input_position");
704 gtk_text_buffer_get_iter_at_mark(buffer, &start, input_position);
705 gtk_text_buffer_get_end_iter(buffer, &end);
706 gtk_text_buffer_delete(buffer, &start, &end);
708 /* Make the window uneditable again */
709 gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), FALSE);
711 /* Insert the forced input into the window */
712 gtk_text_buffer_get_end_iter(buffer, &end);
713 gchar *text_to_insert = g_strconcat(text, "\n", NULL);
714 gtk_text_buffer_insert_with_tags_by_name(buffer, &end, text_to_insert, -1, "input", NULL);
715 chars_written = finish_text_buffer_line_input(win, TRUE);
717 else if(win->type == wintype_TextGrid)
719 /* Remove signal handlers so the line input doesn't get picked up again */
720 g_signal_handler_block(win->widget, win->keypress_handler);
722 /* Insert the forced input into the window */
723 gtk_entry_set_text(GTK_ENTRY(win->input_entry), text);
724 chars_written = finish_text_grid_line_input(win, TRUE);
728 event->type = evtype_LineInput;
730 event->val1 = chars_written;