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         if(win->type == wintype_TextGrid) {
 292                 /* No possible input, we're done here */
 293                 return;
 294         }
 295
 296         GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
 297         g_signal_handler_block(window_buffer, win->insert_text_handler);
 298
 299         /* Retrieve possible input */
 300         int chars_written = flush_text_buffer(win);
 301         if(chars_written > 0) {
 302                 event->type = evtype_LineInput;
 303                 event->val1 = chars_written;
 304         }
 305 }
 306
 307 /* 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. */
 308 gboolean
 309 on_window_key_press_event(GtkWidget *widget, GdkEventKey *event, winid_t win)
 310 {
 311         /* If this is a text grid window, and line input is active, then redirect the key press to the line input GtkEntry */
 312         if( win->type == wintype_TextGrid && (win->input_request_type == INPUT_REQUEST_LINE || win->input_request_type == INPUT_REQUEST_LINE_UNICODE) )
 313         {
 314                 if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up
 315                     || event->keyval == GDK_Down || event->keyval == GDK_KP_Down
 316                     || event->keyval == GDK_Left || event->keyval == GDK_KP_Left
 317                     || event->keyval == GDK_Right || event->keyval == GDK_KP_Right
 318                     || event->keyval == GDK_Tab || event->keyval == GDK_KP_Tab
 319                     || event->keyval == GDK_Page_Up || event->keyval == GDK_KP_Page_Up
 320                     || event->keyval == GDK_Page_Down || event->keyval == GDK_KP_Page_Down
 321                     || event->keyval == GDK_Home || event->keyval == GDK_KP_Home
 322                     || event->keyval == GDK_End || event->keyval == GDK_KP_End)
 323                         return FALSE; /* Don't redirect these keys */
 324                 gtk_widget_grab_focus(win->input_entry);
 325                 gtk_editable_set_position(GTK_EDITABLE(win->input_entry), -1);
 326                 gboolean retval = TRUE;
 327                 g_signal_emit_by_name(win->input_entry, "key-press-event", event, &retval);
 328                 return retval; /* Block this key event if the entry handled it */
 329         }
 330         if(win->input_request_type != INPUT_REQUEST_CHARACTER &&
 331                 win->input_request_type != INPUT_REQUEST_CHARACTER_UNICODE)
 332                 return FALSE;
 333
 334         int keycode;
 335
 336         switch(event->keyval) {
 337                 case GDK_Up:
 338                 case GDK_KP_Up: keycode = keycode_Up; break;
 339                 case GDK_Down:
 340                 case GDK_KP_Down: keycode = keycode_Down; break;
 341                 case GDK_Left:
 342                 case GDK_KP_Left: keycode = keycode_Left; break;
 343                 case GDK_Right:
 344                 case GDK_KP_Right: keycode = keycode_Right; break;
 345                 case GDK_Linefeed:
 346                 case GDK_Return:
 347                 case GDK_KP_Enter: keycode = keycode_Return; break;
 348                 case GDK_Delete:
 349                 case GDK_BackSpace:
 350                 case GDK_KP_Delete: keycode = keycode_Delete; break;
 351                 case GDK_Escape: keycode = keycode_Escape; break;
 352                 case GDK_Tab:
 353                 case GDK_KP_Tab: keycode = keycode_Tab; break;
 354                 case GDK_Page_Up:
 355                 case GDK_KP_Page_Up: keycode = keycode_PageUp; break;
 356                 case GDK_Page_Down:
 357                 case GDK_KP_Page_Down: keycode = keycode_PageDown; break;
 358                 case GDK_Home:
 359                 case GDK_KP_Home: keycode = keycode_Home; break;
 360                 case GDK_End:
 361                 case GDK_KP_End: keycode = keycode_End; break;
 362                 case GDK_F1:
 363                 case GDK_KP_F1: keycode = keycode_Func1; break;
 364                 case GDK_F2:
 365                 case GDK_KP_F2: keycode = keycode_Func2; break;
 366                 case GDK_F3:
 367                 case GDK_KP_F3: keycode = keycode_Func3; break;
 368                 case GDK_F4:
 369                 case GDK_KP_F4: keycode = keycode_Func4; break;
 370                 case GDK_F5: keycode = keycode_Func5; break;
 371                 case GDK_F6: keycode = keycode_Func6; break;
 372                 case GDK_F7: keycode = keycode_Func7; break;
 373                 case GDK_F8: keycode = keycode_Func8; break;
 374                 case GDK_F9: keycode = keycode_Func9; break;
 375                 case GDK_F10: keycode = keycode_Func10; break;
 376                 case GDK_F11: keycode = keycode_Func11; break;
 377                 case GDK_F12: keycode = keycode_Func12; break;
 378                 default:
 379                         keycode = gdk_keyval_to_unicode(event->keyval);
 380                         /* If keycode is 0, then keyval was not recognized; also return
 381                         unknown if Latin-1 input was requested and the character is not in
 382                         Latin-1 */
 383                         if(keycode == 0 || (win->input_request_type == INPUT_REQUEST_CHARACTER && keycode > 255))
 384                                 keycode = keycode_Unknown;
 385         }
 386
 387         event_throw(evtype_CharInput, win, keycode, 0);
 388
 389         /* Only one keypress will be handled */
 390         win->input_request_type = INPUT_REQUEST_NONE;
 391         g_signal_handler_block( G_OBJECT(win->widget), win->keypress_handler );
 392
 393         return TRUE;
 394 }
 395
 396 /* Internal function: finish handling a line input request, for both text grid and text buffer windows. */
 397 static int
 398 write_to_window_buffer(winid_t win, const gchar *inserted_text)
 399 {
 400         int copycount = 0;
 401
 402     /* Convert the string from UTF-8 to Latin-1 or Unicode */
 403     if(win->input_request_type == INPUT_REQUEST_LINE)
 404     {
 405         gsize bytes_written;
 406         gchar *latin1 = convert_utf8_to_latin1(inserted_text, &bytes_written);
 407
 408         if(latin1 == NULL)
 409             return 0;
 410
 411         /* Place input in the echo stream */
 412         if(win->echo_stream != NULL)
 413             glk_put_string_stream(win->echo_stream, latin1);
 414
 415         /* Copy the string (bytes_written does not include the NULL at the end) */
 416         copycount = MIN(win->line_input_buffer_max_len, bytes_written);
 417         memcpy(win->line_input_buffer, latin1, copycount);
 418         g_free(latin1);
 419     }
 420     else if(win->input_request_type == INPUT_REQUEST_LINE_UNICODE)
 421     {
 422         glong items_written;
 423         gunichar *unicode = convert_utf8_to_ucs4(inserted_text, &items_written);
 424
 425         if(unicode == NULL)
 426             return 0;
 427
 428         /* Place input in the echo stream */
 429         if(win->echo_stream != NULL)
 430             glk_put_string_stream_uni(win->echo_stream, unicode);
 431
 432         /* Copy the string (but not the NULL at the end) */
 433         copycount = MIN(win->line_input_buffer_max_len, items_written);
 434         memcpy(win->line_input_buffer_unicode, unicode, copycount * sizeof(gunichar));
 435         g_free(unicode);
 436     }
 437     else
 438         WARNING("Wrong input request type");
 439
 440     win->input_request_type = INPUT_REQUEST_NONE;
 441         return copycount;
 442 }
 443
 444 /* Internal function: Retrieves the input of a TextBuffer window and stores it in the window buffer.
 445  * Returns the number of characters written, suitable for inclusion in a line input event. */
 446 static int
 447 flush_text_buffer(winid_t win)
 448 {
 449         VALID_WINDOW(win, return 0);
 450         g_return_val_if_fail(win->type == wintype_TextBuffer, 0);
 451
 452         GtkTextIter start_iter, end_iter;
 453
 454         GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
 455         GtkTextMark *input_position = gtk_text_buffer_get_mark(window_buffer, "input_position");
 456         gtk_text_buffer_get_iter_at_mark(window_buffer, &start_iter, input_position);
 457         gtk_text_buffer_get_end_iter(window_buffer, &end_iter);
 458         gtk_text_iter_backward_cursor_position(&end_iter); /* don't include \n */
 459
 460         gchar* inserted_text = gtk_text_buffer_get_text(window_buffer, &start_iter, &end_iter, FALSE);
 461         int chars_written = write_to_window_buffer(win, inserted_text);
 462         g_free(inserted_text);
 463
 464         return chars_written;
 465 }
 466
 467 /* Internal function: Callback for signal insert-text on a text buffer window.
 468 Runs after the default handler has already inserted the text.
 469 FIXME: This function assumes that newline was the last character typed into the
 470 window. That assumption is wrong if, for example, text containing a newline was
 471 pasted into the window. */
 472 void
 473 after_window_insert_text(GtkTextBuffer *textbuffer, GtkTextIter *location, gchar *text, gint len, winid_t win)
 474 {
 475         if( strchr(text, '\n') != NULL )
 476         {
 477                 /* Remove signal handlers */
 478                 GtkTextBuffer *window_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
 479                 g_signal_handler_block(window_buffer, win->insert_text_handler);
 480
 481                 /* Make the window uneditable again and retrieve the text that was input */
 482         gtk_text_view_set_editable(GTK_TEXT_VIEW(win->widget), FALSE);
 483
 484         int chars_written = flush_text_buffer(win);
 485                 event_throw(evtype_LineInput, win, chars_written, 0);
 486         }
 487 }
 488
 489 /* Internal function: Callback for signal activate on the line input GtkEntry
 490 in a text grid window. */
 491 void
 492 on_input_entry_activate(GtkEntry *input_entry, winid_t win)
 493 {
 494         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
 495
 496         gchar *text = g_strdup(gtk_entry_get_text(input_entry));
 497         /* Move the focus back into the text view */
 498         gtk_widget_grab_focus(win->widget);
 499         /* Remove entry widget from text view */
 500         /* Should be ok even though this is the widget's own signal handler */
 501         gtk_container_remove( GTK_CONTAINER(win->widget), GTK_WIDGET(input_entry) );
 502         win->input_entry = NULL;
 503         /* Delete the child anchor */
 504         GtkTextIter start, end;
 505         gtk_text_buffer_get_iter_at_child_anchor(buffer, &start, win->input_anchor);
 506         end = start;
 507         gtk_text_iter_forward_char(&end); /* Point after the child anchor */
 508         gtk_text_buffer_delete(buffer, &start, &end);
 509         win->input_anchor = NULL;
 510
 511     gchar *spaces = g_strnfill(win->input_length - g_utf8_strlen(text, -1), ' ');
 512     gchar *text_to_insert = g_strconcat(text, spaces, NULL);
 513         g_free(spaces);
 514     gtk_text_buffer_insert(buffer, &start, text_to_insert, -1);
 515     g_free(text_to_insert);
 516
 517         g_signal_handler_block( G_OBJECT(win->widget), win->keypress_handler );
 518
 519     int chars_written = write_to_window_buffer(win, text);
 520         event_throw(evtype_LineInput, win, chars_written, 0);
 521         g_free(text);
 522 }
 523