src/input.c

   1 #include "charset.h"
   2 #include "magic.h"
   3 #include "input.h"
   4
   5 /**
   6  * glk_request_char_event:
   7  * @win: A window to request char events from.
   8  *
   9  * Request input of a Latin-1 character or special key. A window cannot have
  10  * requests for both character and line input at the same time. Nor can it have
  11  * requests for character input of both types (Latin-1 and Unicode). It is
  12  * illegal to call glk_request_char_event() if the window already has a pending
  13  * request for either character or line input.
  14  */
  15 void
  16 glk_request_char_event(winid_t win)
  17 {
  18         VALID_WINDOW(win, return);
  19         g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
  20         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
  21
  22         win->input_request_type = INPUT_REQUEST_CHARACTER;
  23         g_signal_handler_unblock( G_OBJECT(win->widget), win->keypress_handler );
  24 }
  25
  26 /**
  27  * glk_request_char_event_uni:
  28  * @win: A window to request char events from.
  29  *
  30  * Request input of a Unicode character or special key. See
  31  * glk_request_char_event().
  32  */
  33 void
  34 glk_request_char_event_uni(winid_t win)
  35 {
  36         VALID_WINDOW(win, return);
  37         g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
  38         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
  39
  40         win->input_request_type = INPUT_REQUEST_CHARACTER_UNICODE;
  41         g_signal_handler_unblock( G_OBJECT(win->widget), win->keypress_handler );
  42 }
  43
  44 /**
  45  * glk_cancel_char_event:
  46  * @win: A window to cancel the latest char event request on.
  47  *
  48  * This cancels a pending request for character input. (Either Latin-1 or
  49  * Unicode.) For convenience, it is legal to call glk_cancel_char_event() even
  50  * if there is no charcter input request on that window. Glk will ignore the
  51  * call in this case.
  52  */
  53 void
  54 glk_cancel_char_event(winid_t win)
  55 {
  56         VALID_WINDOW(win, return);
  57         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
  58
  59         if(win->input_request_type == INPUT_REQUEST_CHARACTER || win->input_request_type == INPUT_REQUEST_CHARACTER_UNICODE)
  60         {
  61                 win->input_request_type = INPUT_REQUEST_NONE;
  62                 g_signal_handler_block( G_OBJECT(win->widget), win->keypress_handler );
  63         }
  64 }
  65
  66 /* Internal function: Request either latin-1 or unicode line input, in a text grid window. */
  67 static void
  68 text_grid_request_line_event_common(winid_t win, glui32 maxlen, gboolean insert, gchar *inserttext)
  69 {
  70         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
  71
  72     GtkTextMark *cursor = gtk_text_buffer_get_mark(buffer, "cursor_position");
  73     GtkTextIter start_iter, end_iter;
  74     gtk_text_buffer_get_iter_at_mark(buffer, &start_iter, cursor);
  75
  76     /* Determine the maximum length of the line input */
  77     gint cursorpos = gtk_text_iter_get_line_offset(&start_iter);
  78     /* Odd; the Glk spec says the maximum input length is
  79     windowwidth - 1 - cursorposition. I say no, because if cursorposition is
  80     zero, then the input should fill the whole line. FIXME??? */
  81     win->input_length = MIN(win->width - cursorpos, win->line_input_buffer_max_len);
  82     end_iter = start_iter;
  83     gtk_text_iter_set_line_offset(&end_iter, cursorpos + win->input_length);
  84
  85         /* If the buffer currently has a selection with one bound in the middle of
  86         the input field, then deselect it. Otherwise the input field gets trashed */
  87         GtkTextIter start_sel, end_sel;
  88         if( gtk_text_buffer_get_selection_bounds(buffer, &start_sel, &end_sel) )
  89         {
  90                 if( gtk_text_iter_in_range(&start_sel, &start_iter, &end_iter) )
  91                         gtk_text_buffer_place_cursor(buffer, &end_sel);
  92                 if( gtk_text_iter_in_range(&end_sel, &start_iter, &end_iter) )
  93                         gtk_text_buffer_place_cursor(buffer, &start_sel);
  94         }
  95
  96     /* Erase the text currently in the input field and replace it with a GtkEntry */
  97     gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
  98     win->input_anchor = gtk_text_buffer_create_child_anchor(buffer, &start_iter);
  99     win->input_entry = gtk_entry_new();
 100         /* Set the entry's font to match that of the window */
 101     GtkRcStyle *style = gtk_widget_get_modifier_style(win->widget);     /* Don't free */
 102         gtk_widget_modify_font(win->input_entry, style->font_desc);
 103         /* Make the entry as small as possible to fit with the text */
 104         gtk_entry_set_has_frame(GTK_ENTRY(win->input_entry), FALSE);
 105         GtkBorder border = { 0, 0, 0, 0 };
 106         gtk_entry_set_inner_border(GTK_ENTRY(win->input_entry), &border);
 107     gtk_entry_set_max_length(GTK_ENTRY(win->input_entry), win->input_length);
 108     gtk_entry_set_width_chars(GTK_ENTRY(win->input_entry), win->input_length);
 109
 110     /* Insert pre-entered text if needed */
 111     if(insert)
 112         gtk_entry_set_text(GTK_ENTRY(win->input_entry), inserttext);
 113
 114     /* Set background color of entry (TODO: implement as property) */
 115     GdkColor background;
 116         gdk_color_parse("grey", &background);
 117     gtk_widget_modify_base(win->input_entry, GTK_STATE_NORMAL, &background);
 118
 119     g_signal_connect(win->input_entry, "activate", G_CALLBACK(on_input_entry_activate), win);
 120
 121     gtk_widget_show(win->input_entry);
 122     gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(win->widget), win->input_entry, win->input_anchor);
 123
 124         g_signal_handler_unblock( G_OBJECT(win->widget), win->keypress_handler );
 125 }
 126
 127 /* Internal function: Request either latin-1 or unicode line input, in a text buffer window. */
 128 static void
 129 text_buffer_request_line_event_common(winid_t win, glui32 maxlen, gboolean insert, gchar *inserttext)
 130 {
 131         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
 132
 133     /* Move the input_position mark to the end of the window_buffer */
 134     GtkTextMark *input_position = gtk_text_buffer_get_mark(buffer, "input_position");
 135     GtkTextIter end_iter;
 136     gtk_text_buffer_get_end_iter(buffer, &end_iter);
 137     gtk_text_buffer_move_mark(buffer, input_position, &end_iter);
 138
 139     /* Set the entire contents of the window_buffer as uneditable
 140      * (so input can only be entered at the end) */
 141     GtkTextIter start_iter;
 142     gtk_text_buffer_get_start_iter(buffer, &start_iter);
 143     gtk_text_buffer_remove_tag_by_name(buffer, "uneditable", &start_iter, &end_iter);
 144     gtk_text_buffer_apply_tag_by_name(buffer, "uneditable", &start_iter, &end_iter);
 145
 146     /* Insert pre-entered text if needed */
 147     if(insert)
 148         gtk_text_buffer_insert(buffer, &end_iter, inserttext, -1);
 149
 150     /* Scroll to input point */
 151     gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(win->widget), input_position);
 152
 153     gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), TRUE);
 154     g_signal_handler_unblock(buffer, win->insert_text_handler);
 155 }
 156
 157 /**
 158  * glk_request_line_event:
 159  * @win: A text buffer or text grid window to request line input on.
 160  * @buf: A buffer of at least @maxlen bytes.
 161  * @maxlen: Length of the buffer.
 162  * @initlen: The number of characters in @buf to pre-enter.
 163  *
 164  * Requests input of a line of Latin-1 characters. A window cannot have requests
 165  * for both character and line input at the same time. Nor can it have requests
 166  * for line input of both types (Latin-1 and Unicode). It is illegal to call
 167  * glk_request_line_event() if the window already has a pending request for
 168  * either character or line input.
 169  *
 170  * The @buf argument is a pointer to space where the line input will be stored.
 171  * (This may not be %NULL.) @maxlen is the length of this space, in bytes; the
 172  * library will not accept more characters than this. If @initlen is nonzero,
 173  * then the first @initlen bytes of @buf will be entered as pre-existing input
 174  * &mdash; just as if the player had typed them himself. (The player can continue
 175  * composing after this pre-entered input, or delete it or edit as usual.)
 176  *
 177  * The contents of the buffer are undefined until the input is completed (either
 178  * by a line input event, or glk_cancel_line_event(). The library may or may not
 179  * fill in the buffer as the player composes, while the input is still pending;
 180  * it is illegal to change the contents of the buffer yourself.
 181  */
 182 void
 183 glk_request_line_event(winid_t win, char* buf, glui32 maxlen, glui32 initlen)
 184 {
 185         VALID_WINDOW(win, return);
 186         g_return_if_fail(buf);
 187         g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
 188         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
 189         g_return_if_fail(initlen <= maxlen);
 190
 191         win->input_request_type = INPUT_REQUEST_LINE;
 192         win->line_input_buffer = buf;
 193         win->line_input_buffer_max_len = maxlen;
 194
 195         gchar *inserttext = (initlen > 0)? g_strndup(buf, initlen) : g_strdup("");
 196         switch(win->type)
 197         {
 198             case wintype_TextBuffer:
 199                 text_buffer_request_line_event_common(win, maxlen, (initlen > 0), inserttext);
 200                 break;
 201             case wintype_TextGrid:
 202                 text_grid_request_line_event_common(win, maxlen, (initlen > 0), inserttext);
 203                 break;
 204     }
 205         g_free(inserttext);
 206 }
 207
 208 /**
 209  * glk_request_line_event_uni:
 210  * @win: A text buffer or text grid window to request line input on.
 211  * @buf: A buffer of at least @maxlen characters.
 212  * @maxlen: Length of the buffer.
 213  * @initlen: The number of characters in @buf to pre-enter.
 214  *
 215  * Request input of a line of Unicode characters. This works the same as
 216  * glk_request_line_event(), except the result is stored in an array of
 217  * <type>glui32</type> values instead of an array of characters, and the values
 218  * may be any valid Unicode code points.
 219  *
 220  * The result will be in Unicode Normalization Form C. This basically means that
 221  * composite characters will be single characters where possible, instead of
 222  * sequences of base and combining marks. See
 223  * <ulink url="http://www.unicode.org/reports/tr15/">Unicode Standard Annex #15
 224  * </ulink> for the details.
 225  */
 226 void
 227 glk_request_line_event_uni(winid_t win, glui32 *buf, glui32 maxlen, glui32 initlen)
 228 {
 229         VALID_WINDOW(win, return);
 230         g_return_if_fail(buf);
 231         g_return_if_fail(win->input_request_type == INPUT_REQUEST_NONE);
 232         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
 233         g_return_if_fail(initlen <= maxlen);
 234
 235         win->input_request_type = INPUT_REQUEST_LINE_UNICODE;
 236         win->line_input_buffer_unicode = buf;
 237         win->line_input_buffer_max_len = maxlen;
 238
 239         gchar *utf8;
 240         if(initlen > 0) {
 241                 utf8 = convert_ucs4_to_utf8(buf, initlen);
 242                 if(utf8 == NULL)
 243                         return;
 244         }
 245         else
 246                 utf8 = g_strdup("");
 247
 248     switch(win->type)
 249         {
 250             case wintype_TextBuffer:
 251                 text_buffer_request_line_event_common(win, maxlen, (initlen > 0), utf8);
 252                 break;
 253             case wintype_TextGrid:
 254                 text_grid_request_line_event_common(win, maxlen, (initlen > 0), utf8);
 255                 break;
 256     }
 257         g_free(utf8);
 258 }
 259
 260 /**
 261  * glk_cancel_line_event:
 262  * @win: A text buffer or text grid window to cancel line input on.
 263  * @event: Will be filled in if the user had already input something.
 264  *
 265  * This cancels a pending request for line input. (Either Latin-1 or Unicode.)
 266  *
 267  * The event pointed to by the event argument will be filled in as if the
 268  * player had hit <keycap>enter</keycap>, and the input composed so far will be stored in the
 269  * buffer; see below. If you do not care about this information, pass %NULL as
 270  * the @event argument. (The buffer will still be filled.)
 271  *
 272  * For convenience, it is legal to call glk_cancel_line_event() even if there
 273  * is no line input request on that window. The event type will be set to
 274  * #evtype_None in this case.
 275  */
 276 void
 277 glk_cancel_line_event(winid_t win, event_t *event)
 278 {
 279         /* TODO: write me */
 280         VALID_WINDOW(win, return);
 281         g_return_if_fail(win->input_request_type != INPUT_REQUEST_NONE);
 282         g_return_if_fail(win->type != wintype_TextBuffer || win->type != wintype_TextGrid);
 283
 284         event->type = evtype_None;
 285         event->win = win;
 286         event->val1 = 0;
 287         event->val2 = 0;
 288
 289         g_signal_handler_block( G_OBJECT(win->widget), win->keypress_handler );
 290
 291         int chars_written = 0;
 292
 293         if(win->type == wintype_TextGrid) {
 294                 g_signal_handler_block( G_OBJECT(win->widget), win->keypress_handler );
 295                 chars_written = flush_text_grid(win);
 296         } else if(win->type == wintype_TextBuffer) {
 297                 GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
 298                 g_signal_handler_block(window_buffer, win->insert_text_handler);
 299                 chars_written = flush_text_buffer(win);
 300         }
 301
 302         if(chars_written > 0) {
 303                 event->type = evtype_LineInput;
 304                 event->val1 = chars_written;
 305         }
 306 }
 307
 308 /* 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. */
 309 gboolean
 310 on_window_key_press_event(GtkWidget *widget, GdkEventKey *event, winid_t win)
 311 {
 312         /* If this is a text grid window, and line input is active, then redirect the key press to the line input GtkEntry */
 313         if( win->type == wintype_TextGrid && (win->input_request_type == INPUT_REQUEST_LINE || win->input_request_type == INPUT_REQUEST_LINE_UNICODE) )
 314         {
 315                 if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up
 316                     || event->keyval == GDK_Down || event->keyval == GDK_KP_Down
 317                     || event->keyval == GDK_Left || event->keyval == GDK_KP_Left
 318                     || event->keyval == GDK_Right || event->keyval == GDK_KP_Right
 319                     || event->keyval == GDK_Tab || event->keyval == GDK_KP_Tab
 320                     || event->keyval == GDK_Page_Up || event->keyval == GDK_KP_Page_Up
 321                     || event->keyval == GDK_Page_Down || event->keyval == GDK_KP_Page_Down
 322                     || event->keyval == GDK_Home || event->keyval == GDK_KP_Home
 323                     || event->keyval == GDK_End || event->keyval == GDK_KP_End)
 324                         return FALSE; /* Don't redirect these keys */
 325                 gtk_widget_grab_focus(win->input_entry);
 326                 gtk_editable_set_position(GTK_EDITABLE(win->input_entry), -1);
 327                 gboolean retval = TRUE;
 328                 g_signal_emit_by_name(win->input_entry, "key-press-event", event, &retval);
 329                 return retval; /* Block this key event if the entry handled it */
 330         }
 331         if(win->input_request_type != INPUT_REQUEST_CHARACTER &&
 332                 win->input_request_type != INPUT_REQUEST_CHARACTER_UNICODE)
 333                 return FALSE;
 334
 335         int keycode;
 336
 337         switch(event->keyval) {
 338                 case GDK_Up:
 339                 case GDK_KP_Up: keycode = keycode_Up; break;
 340                 case GDK_Down:
 341                 case GDK_KP_Down: keycode = keycode_Down; break;
 342                 case GDK_Left:
 343                 case GDK_KP_Left: keycode = keycode_Left; break;
 344                 case GDK_Right:
 345                 case GDK_KP_Right: keycode = keycode_Right; break;
 346                 case GDK_Linefeed:
 347                 case GDK_Return:
 348                 case GDK_KP_Enter: keycode = keycode_Return; break;
 349                 case GDK_Delete:
 350                 case GDK_BackSpace:
 351                 case GDK_KP_Delete: keycode = keycode_Delete; break;
 352                 case GDK_Escape: keycode = keycode_Escape; break;
 353                 case GDK_Tab:
 354                 case GDK_KP_Tab: keycode = keycode_Tab; break;
 355                 case GDK_Page_Up:
 356                 case GDK_KP_Page_Up: keycode = keycode_PageUp; break;
 357                 case GDK_Page_Down:
 358                 case GDK_KP_Page_Down: keycode = keycode_PageDown; break;
 359                 case GDK_Home:
 360                 case GDK_KP_Home: keycode = keycode_Home; break;
 361                 case GDK_End:
 362                 case GDK_KP_End: keycode = keycode_End; break;
 363                 case GDK_F1:
 364                 case GDK_KP_F1: keycode = keycode_Func1; break;
 365                 case GDK_F2:
 366                 case GDK_KP_F2: keycode = keycode_Func2; break;
 367                 case GDK_F3:
 368                 case GDK_KP_F3: keycode = keycode_Func3; break;
 369                 case GDK_F4:
 370                 case GDK_KP_F4: keycode = keycode_Func4; break;
 371                 case GDK_F5: keycode = keycode_Func5; break;
 372                 case GDK_F6: keycode = keycode_Func6; break;
 373                 case GDK_F7: keycode = keycode_Func7; break;
 374                 case GDK_F8: keycode = keycode_Func8; break;
 375                 case GDK_F9: keycode = keycode_Func9; break;
 376                 case GDK_F10: keycode = keycode_Func10; break;
 377                 case GDK_F11: keycode = keycode_Func11; break;
 378                 case GDK_F12: keycode = keycode_Func12; break;
 379                 default:
 380                         keycode = gdk_keyval_to_unicode(event->keyval);
 381                         /* If keycode is 0, then keyval was not recognized; also return
 382                         unknown if Latin-1 input was requested and the character is not in
 383                         Latin-1 */
 384                         if(keycode == 0 || (win->input_request_type == INPUT_REQUEST_CHARACTER && keycode > 255))
 385                                 keycode = keycode_Unknown;
 386         }
 387
 388         event_throw(evtype_CharInput, win, keycode, 0);
 389
 390         /* Only one keypress will be handled */
 391         win->input_request_type = INPUT_REQUEST_NONE;
 392         g_signal_handler_block( G_OBJECT(win->widget), win->keypress_handler );
 393
 394         return TRUE;
 395 }
 396
 397 /* Internal function: finish handling a line input request, for both text grid and text buffer windows. */
 398 static int
 399 write_to_window_buffer(winid_t win, const gchar *inserted_text)
 400 {
 401         int copycount = 0;
 402
 403     /* Convert the string from UTF-8 to Latin-1 or Unicode */
 404     if(win->input_request_type == INPUT_REQUEST_LINE)
 405     {
 406         gsize bytes_written;
 407         gchar *latin1 = convert_utf8_to_latin1(inserted_text, &bytes_written);
 408
 409         if(latin1 == NULL)
 410             return 0;
 411
 412         /* Place input in the echo stream */
 413         if(win->echo_stream != NULL)
 414             glk_put_string_stream(win->echo_stream, latin1);
 415
 416         /* Copy the string (bytes_written does not include the NULL at the end) */
 417         copycount = MIN(win->line_input_buffer_max_len, bytes_written);
 418         memcpy(win->line_input_buffer, latin1, copycount);
 419         g_free(latin1);
 420     }
 421     else if(win->input_request_type == INPUT_REQUEST_LINE_UNICODE)
 422     {
 423         glong items_written;
 424         gunichar *unicode = convert_utf8_to_ucs4(inserted_text, &items_written);
 425
 426         if(unicode == NULL)
 427             return 0;
 428
 429         /* Place input in the echo stream */
 430         if(win->echo_stream != NULL)
 431             glk_put_string_stream_uni(win->echo_stream, unicode);
 432
 433         /* Copy the string (but not the NULL at the end) */
 434         copycount = MIN(win->line_input_buffer_max_len, items_written);
 435         memcpy(win->line_input_buffer_unicode, unicode, copycount * sizeof(gunichar));
 436         g_free(unicode);
 437     }
 438     else
 439         WARNING("Wrong input request type");
 440
 441     win->input_request_type = INPUT_REQUEST_NONE;
 442         return copycount;
 443 }
 444
 445 /* Internal function: Retrieves the input of a TextBuffer window and stores it in the window buffer.
 446  * Returns the number of characters written, suitable for inclusion in a line input event. */
 447 static int
 448 flush_text_buffer(winid_t win)
 449 {
 450         VALID_WINDOW(win, return 0);
 451         g_return_val_if_fail(win->type == wintype_TextBuffer, 0);
 452
 453         GtkTextIter start_iter, end_iter;
 454
 455         GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
 456         GtkTextMark *input_position = gtk_text_buffer_get_mark(window_buffer, "input_position");
 457         gtk_text_buffer_get_iter_at_mark(window_buffer, &start_iter, input_position);
 458         gtk_text_buffer_get_end_iter(window_buffer, &end_iter);
 459         gtk_text_iter_backward_cursor_position(&end_iter); /* don't include \n */
 460
 461         gchar* inserted_text = gtk_text_buffer_get_text(window_buffer, &start_iter, &end_iter, FALSE);
 462         int chars_written = write_to_window_buffer(win, inserted_text);
 463         g_free(inserted_text);
 464
 465         return chars_written;
 466 }
 467
 468 /* Internal function: Retrieves the input of a TextGrid window and stores it in the window buffer.
 469  * Returns the number of characters written, suitable for inclusion in a line input event. */
 470 static int
 471 flush_text_grid(winid_t win)
 472 {
 473         VALID_WINDOW(win, return 0);
 474         g_return_val_if_fail(win->type == wintype_TextBuffer, 0);
 475
 476         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
 477
 478         gchar *text = g_strdup( gtk_entry_get_text(GTK_ENTRY(win->input_entry)) );
 479         /* Move the focus back into the text view */
 480         gtk_widget_grab_focus(win->widget);
 481         /* Remove entry widget from text view */
 482         /* Should be ok even though this is the widget's own signal handler */
 483         gtk_container_remove( GTK_CONTAINER(win->widget), GTK_WIDGET(win->input_entry) );
 484         win->input_entry = NULL;
 485         /* Delete the child anchor */
 486         GtkTextIter start, end;
 487         gtk_text_buffer_get_iter_at_child_anchor(buffer, &start, win->input_anchor);
 488         end = start;
 489         gtk_text_iter_forward_char(&end); /* Point after the child anchor */
 490         gtk_text_buffer_delete(buffer, &start, &end);
 491         win->input_anchor = NULL;
 492
 493     gchar *spaces = g_strnfill(win->input_length - g_utf8_strlen(text, -1), ' ');
 494     gchar *text_to_insert = g_strconcat(text, spaces, NULL);
 495         g_free(spaces);
 496     gtk_text_buffer_insert(buffer, &start, text_to_insert, -1);
 497     g_free(text_to_insert);
 498
 499     int chars_written = write_to_window_buffer(win, text);
 500         g_free(text);
 501
 502         return chars_written;
 503 }
 504
 505 /* Internal function: Callback for signal insert-text on a text buffer window.
 506 Runs after the default handler has already inserted the text.
 507 FIXME: This function assumes that newline was the last character typed into the
 508 window. That assumption is wrong if, for example, text containing a newline was
 509 pasted into the window. */
 510 void
 511 after_window_insert_text(GtkTextBuffer *textbuffer, GtkTextIter *location, gchar *text, gint len, winid_t win)
 512 {
 513         if( strchr(text, '\n') != NULL )
 514         {
 515                 /* Remove signal handlers */
 516                 GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
 517                 g_signal_handler_block(window_buffer, win->insert_text_handler);
 518
 519                 /* Make the window uneditable again and retrieve the text that was input */
 520         gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), FALSE);
 521
 522         int chars_written = flush_text_buffer(win);
 523                 event_throw(evtype_LineInput, win, chars_written, 0);
 524         }
 525 }
 526
 527 /* Internal function: Callback for signal activate on the line input GtkEntry
 528 in a text grid window. */
 529 void
 530 on_input_entry_activate(GtkEntry *input_entry, winid_t win)
 531 {
 532         g_signal_handler_block( G_OBJECT(win->widget), win->keypress_handler );
 533
 534         int chars_written = flush_text_grid(win);
 535         event_throw(evtype_LineInput, win, chars_written, 0);
 536 }
 537