src/text-context.cpp

   1 #define __SP_TEXT_CONTEXT_C__
   2
   3 /*
   4  * SPTextContext
   5  *
   6  * Authors:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   bulia byak <buliabyak@users.sf.net>
   9  *
  10  * Copyright (C) 1999-2005 authors
  11  * Copyright (C) 2001 Ximian, Inc.
  12  *
  13  * Released under GNU GPL, read the file 'COPYING' for more information
  14  */
  15
  16 #ifdef HAVE_CONFIG_H
  17 # include <config.h>
  18 #endif
  19
  20 #include <gdk/gdkkeysyms.h>
  21 #include <gtk/gtkmain.h>
  22 #include <display/sp-ctrlline.h>
  23 #include <display/sodipodi-ctrlrect.h>
  24 #include <display/sp-ctrlquadr.h>
  25 #include <gtk/gtkimmulticontext.h>
  26 #include <gtkmm/clipboard.h>
  27
  28 #include "macros.h"
  29 #include "sp-text.h"
  30 #include "sp-flowtext.h"
  31 #include "document.h"
  32 #include "sp-namedview.h"
  33 #include "style.h"
  34 #include "selection.h"
  35 #include "desktop.h"
  36 #include "desktop-style.h"
  37 #include "desktop-handles.h"
  38 #include "message-stack.h"
  39 #include "message-context.h"
  40 #include "pixmaps/cursor-text.xpm"
  41 #include "pixmaps/cursor-text-insert.xpm"
  42 #include <glibmm/i18n.h>
  43 #include "object-edit.h"
  44 #include "xml/repr.h"
  45 #include "xml/node-event-vector.h"
  46 #include "preferences.h"
  47 #include "rubberband.h"
  48 #include "sp-metrics.h"
  49 #include "context-fns.h"
  50 #include "verbs.h"
  51 #include "shape-editor.h"
  52 #include "selection-chemistry.h"
  53 #include "text-editing.h"
  54
  55 #include "text-context.h"
  56
  57
  58 static void sp_text_context_class_init(SPTextContextClass *klass);
  59 static void sp_text_context_init(SPTextContext *text_context);
  60 static void sp_text_context_dispose(GObject *obj);
  61
  62 static void sp_text_context_setup(SPEventContext *ec);
  63 static void sp_text_context_finish(SPEventContext *ec);
  64 static gint sp_text_context_root_handler(SPEventContext *event_context, GdkEvent *event);
  65 static gint sp_text_context_item_handler(SPEventContext *event_context, SPItem *item, GdkEvent *event);
  66
  67 static void sp_text_context_selection_changed(Inkscape::Selection *selection, SPTextContext *tc);
  68 static void sp_text_context_selection_modified(Inkscape::Selection *selection, guint flags, SPTextContext *tc);
  69 static bool sp_text_context_style_set(SPCSSAttr const *css, SPTextContext *tc);
  70 static int sp_text_context_style_query(SPStyle *style, int property, SPTextContext *tc);
  71
  72 static void sp_text_context_validate_cursor_iterators(SPTextContext *tc);
  73 static void sp_text_context_update_cursor(SPTextContext *tc, bool scroll_to_see = true);
  74 static void sp_text_context_update_text_selection(SPTextContext *tc);
  75 static gint sp_text_context_timeout(SPTextContext *tc);
  76 static void sp_text_context_forget_text(SPTextContext *tc);
  77
  78 static gint sptc_focus_in(GtkWidget *widget, GdkEventFocus *event, SPTextContext *tc);
  79 static gint sptc_focus_out(GtkWidget *widget, GdkEventFocus *event, SPTextContext *tc);
  80 static void sptc_commit(GtkIMContext *imc, gchar *string, SPTextContext *tc);
  81
  82 static SPEventContextClass *parent_class;
  83
  84 GType
  85 sp_text_context_get_type()
  86 {
  87     static GType type = 0;
  88     if (!type) {
  89         GTypeInfo info = {
  90             sizeof(SPTextContextClass),
  91             NULL, NULL,
  92             (GClassInitFunc) sp_text_context_class_init,
  93             NULL, NULL,
  94             sizeof(SPTextContext),
  95             4,
  96             (GInstanceInitFunc) sp_text_context_init,
  97             NULL,   /* value_table */
  98         };
  99         type = g_type_register_static(SP_TYPE_EVENT_CONTEXT, "SPTextContext", &info, (GTypeFlags)0);
 100     }
 101     return type;
 102 }
 103
 104 static void
 105 sp_text_context_class_init(SPTextContextClass *klass)
 106 {
 107     GObjectClass *object_class=(GObjectClass *)klass;
 108     SPEventContextClass *event_context_class = (SPEventContextClass *) klass;
 109
 110     parent_class = (SPEventContextClass*)g_type_class_peek_parent(klass);
 111
 112     object_class->dispose = sp_text_context_dispose;
 113
 114     event_context_class->setup = sp_text_context_setup;
 115     event_context_class->finish = sp_text_context_finish;
 116     event_context_class->root_handler = sp_text_context_root_handler;
 117     event_context_class->item_handler = sp_text_context_item_handler;
 118 }
 119
 120 static void
 121 sp_text_context_init(SPTextContext *tc)
 122 {
 123     SPEventContext *event_context = SP_EVENT_CONTEXT(tc);
 124
 125     event_context->cursor_shape = cursor_text_xpm;
 126     event_context->hot_x = 7;
 127     event_context->hot_y = 7;
 128
 129     event_context->xp = 0;
 130     event_context->yp = 0;
 131     event_context->tolerance = 0;
 132     event_context->within_tolerance = false;
 133
 134     tc->imc = NULL;
 135
 136     tc->text = NULL;
 137     tc->pdoc = Geom::Point(0, 0);
 138     new (&tc->text_sel_start) Inkscape::Text::Layout::iterator();
 139     new (&tc->text_sel_end) Inkscape::Text::Layout::iterator();
 140     new (&tc->text_selection_quads) std::vector<SPCanvasItem*>();
 141
 142     tc->unimode = false;
 143
 144     tc->cursor = NULL;
 145     tc->indicator = NULL;
 146     tc->frame = NULL;
 147     tc->grabbed = NULL;
 148     tc->timeout = 0;
 149     tc->show = FALSE;
 150     tc->phase = 0;
 151     tc->nascent_object = 0;
 152     tc->over_text = 0;
 153     tc->dragging = 0;
 154     tc->creating = 0;
 155
 156     new (&tc->sel_changed_connection) sigc::connection();
 157     new (&tc->sel_modified_connection) sigc::connection();
 158     new (&tc->style_set_connection) sigc::connection();
 159     new (&tc->style_query_connection) sigc::connection();
 160 }
 161
 162 static void
 163 sp_text_context_dispose(GObject *obj)
 164 {
 165     SPTextContext *tc = SP_TEXT_CONTEXT(obj);
 166     SPEventContext *ec = SP_EVENT_CONTEXT(tc);
 167     tc->style_query_connection.~connection();
 168     tc->style_set_connection.~connection();
 169     tc->sel_changed_connection.~connection();
 170     tc->sel_modified_connection.~connection();
 171
 172     delete ec->shape_editor;
 173     ec->shape_editor = NULL;
 174
 175     tc->text_sel_end.~iterator();
 176     tc->text_sel_start.~iterator();
 177     tc->text_selection_quads.~vector();
 178     if (G_OBJECT_CLASS(parent_class)->dispose) {
 179         G_OBJECT_CLASS(parent_class)->dispose(obj);
 180     }
 181     if (tc->grabbed) {
 182         sp_canvas_item_ungrab(tc->grabbed, GDK_CURRENT_TIME);
 183         tc->grabbed = NULL;
 184     }
 185
 186     Inkscape::Rubberband::get(ec->desktop)->stop();
 187 }
 188
 189 static void
 190 sp_text_context_setup(SPEventContext *ec)
 191 {
 192     SPTextContext *tc = SP_TEXT_CONTEXT(ec);
 193     SPDesktop *desktop = ec->desktop;
 194     GtkSettings* settings = gtk_settings_get_default();
 195     gint timeout = 0;
 196     g_object_get( settings, "gtk-cursor-blink-time", &timeout, NULL );
 197     if (timeout < 0) {
 198         timeout = 200;
 199     } else {
 200         timeout /= 2;
 201     }
 202
 203     tc->cursor = sp_canvas_item_new(sp_desktop_controls(desktop), SP_TYPE_CTRLLINE, NULL);
 204     sp_ctrlline_set_coords(SP_CTRLLINE(tc->cursor), 100, 0, 100, 100);
 205     sp_ctrlline_set_rgba32(SP_CTRLLINE(tc->cursor), 0x000000ff);
 206     sp_canvas_item_hide(tc->cursor);
 207
 208     tc->indicator = sp_canvas_item_new(sp_desktop_controls(desktop), SP_TYPE_CTRLRECT, NULL);
 209     SP_CTRLRECT(tc->indicator)->setRectangle(Geom::Rect(Geom::Point(0, 0), Geom::Point(100, 100)));
 210     SP_CTRLRECT(tc->indicator)->setColor(0x0000ff7f, false, 0);
 211     sp_canvas_item_hide(tc->indicator);
 212
 213     tc->frame = sp_canvas_item_new(sp_desktop_controls(desktop), SP_TYPE_CTRLRECT, NULL);
 214     SP_CTRLRECT(tc->frame)->setRectangle(Geom::Rect(Geom::Point(0, 0), Geom::Point(100, 100)));
 215     SP_CTRLRECT(tc->frame)->setColor(0x0000ff7f, false, 0);
 216     sp_canvas_item_hide(tc->frame);
 217
 218     tc->timeout = gtk_timeout_add(timeout, (GtkFunction) sp_text_context_timeout, ec);
 219
 220     tc->imc = gtk_im_multicontext_new();
 221     if (tc->imc) {
 222         GtkWidget *canvas = GTK_WIDGET(sp_desktop_canvas(desktop));
 223
 224         /* im preedit handling is very broken in inkscape for
 225          * multi-byte characters.  See bug 1086769.
 226          * We need to let the IM handle the preediting, and
 227          * just take in the characters when they're finished being
 228          * entered.
 229          */
 230         gtk_im_context_set_use_preedit(tc->imc, FALSE);
 231         gtk_im_context_set_client_window(tc->imc, canvas->window);
 232
 233         g_signal_connect(G_OBJECT(canvas), "focus_in_event", G_CALLBACK(sptc_focus_in), tc);
 234         g_signal_connect(G_OBJECT(canvas), "focus_out_event", G_CALLBACK(sptc_focus_out), tc);
 235         g_signal_connect(G_OBJECT(tc->imc), "commit", G_CALLBACK(sptc_commit), tc);
 236
 237         if (GTK_WIDGET_HAS_FOCUS(canvas)) {
 238             sptc_focus_in(canvas, NULL, tc);
 239         }
 240     }
 241
 242     if (((SPEventContextClass *) parent_class)->setup)
 243         ((SPEventContextClass *) parent_class)->setup(ec);
 244
 245     ec->shape_editor = new ShapeEditor(ec->desktop);
 246
 247     SPItem *item = sp_desktop_selection(ec->desktop)->singleItem();
 248     if (item && SP_IS_FLOWTEXT (item) && SP_FLOWTEXT(item)->has_internal_frame()) {
 249         ec->shape_editor->set_item(item, SH_KNOTHOLDER);
 250     }
 251
 252     tc->sel_changed_connection = sp_desktop_selection(desktop)->connectChanged(
 253         sigc::bind(sigc::ptr_fun(&sp_text_context_selection_changed), tc)
 254         );
 255     tc->sel_modified_connection = sp_desktop_selection(desktop)->connectModified(
 256         sigc::bind(sigc::ptr_fun(&sp_text_context_selection_modified), tc)
 257         );
 258     tc->style_set_connection = desktop->connectSetStyle(
 259         sigc::bind(sigc::ptr_fun(&sp_text_context_style_set), tc)
 260         );
 261     tc->style_query_connection = desktop->connectQueryStyle(
 262         sigc::bind(sigc::ptr_fun(&sp_text_context_style_query), tc)
 263         );
 264
 265     sp_text_context_selection_changed(sp_desktop_selection(desktop), tc);
 266
 267     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 268     if (prefs->getBool("/tools/text/selcue")) {
 269         ec->enableSelectionCue();
 270     }
 271     if (prefs->getBool("/tools/text/gradientdrag")) {
 272         ec->enableGrDrag();
 273     }
 274 }
 275
 276 static void
 277 sp_text_context_finish(SPEventContext *ec)
 278 {
 279     SPTextContext *tc = SP_TEXT_CONTEXT(ec);
 280
 281     if (ec->desktop) {
 282         sp_signal_disconnect_by_data(sp_desktop_canvas(ec->desktop), tc);
 283     }
 284
 285     ec->enableGrDrag(false);
 286
 287     tc->style_set_connection.disconnect();
 288     tc->style_query_connection.disconnect();
 289     tc->sel_changed_connection.disconnect();
 290     tc->sel_modified_connection.disconnect();
 291
 292     sp_text_context_forget_text(SP_TEXT_CONTEXT(ec));
 293
 294     if (tc->imc) {
 295         g_object_unref(G_OBJECT(tc->imc));
 296         tc->imc = NULL;
 297     }
 298
 299     if (tc->timeout) {
 300         gtk_timeout_remove(tc->timeout);
 301         tc->timeout = 0;
 302     }
 303
 304     if (tc->cursor) {
 305         gtk_object_destroy(GTK_OBJECT(tc->cursor));
 306         tc->cursor = NULL;
 307     }
 308
 309     if (tc->indicator) {
 310         gtk_object_destroy(GTK_OBJECT(tc->indicator));
 311         tc->indicator = NULL;
 312     }
 313
 314     if (tc->frame) {
 315         gtk_object_destroy(GTK_OBJECT(tc->frame));
 316         tc->frame = NULL;
 317     }
 318
 319     for (std::vector<SPCanvasItem*>::iterator it = tc->text_selection_quads.begin() ;
 320          it != tc->text_selection_quads.end() ; ++it) {
 321         sp_canvas_item_hide(*it);
 322         gtk_object_destroy(*it);
 323     }
 324     tc->text_selection_quads.clear();
 325 }
 326
 327
 328 static gint
 329 sp_text_context_item_handler(SPEventContext *event_context, SPItem *item, GdkEvent *event)
 330 {
 331     SPTextContext *tc = SP_TEXT_CONTEXT(event_context);
 332     SPDesktop *desktop = event_context->desktop;
 333     SPItem *item_ungrouped;
 334
 335     gint ret = FALSE;
 336
 337     sp_text_context_validate_cursor_iterators(tc);
 338
 339     switch (event->type) {
 340         case GDK_BUTTON_PRESS:
 341             if (event->button.button == 1 && !event_context->space_panning) {
 342                 // find out clicked item, disregarding groups
 343                 item_ungrouped = desktop->item_at_point(Geom::Point(event->button.x, event->button.y), TRUE);
 344                 if (SP_IS_TEXT(item_ungrouped) || SP_IS_FLOWTEXT(item_ungrouped)) {
 345                     sp_desktop_selection(desktop)->set(item_ungrouped);
 346                     if (tc->text) {
 347                         // find out click point in document coordinates
 348                         Geom::Point p = desktop->w2d(Geom::Point(event->button.x, event->button.y));
 349                         // set the cursor closest to that point
 350                         tc->text_sel_start = tc->text_sel_end = sp_te_get_position_by_coords(tc->text, p);
 351                         // update display
 352                         sp_text_context_update_cursor(tc);
 353                         sp_text_context_update_text_selection(tc);
 354                         tc->dragging = 1;
 355                         sp_event_context_snap_window_open(event_context);
 356                     }
 357                     ret = TRUE;
 358                 }
 359             }
 360             break;
 361         case GDK_2BUTTON_PRESS:
 362             if (event->button.button == 1 && tc->text) {
 363                 Inkscape::Text::Layout const *layout = te_get_layout(tc->text);
 364                 if (layout) {
 365                     if (!layout->isStartOfWord(tc->text_sel_start))
 366                         tc->text_sel_start.prevStartOfWord();
 367                     if (!layout->isEndOfWord(tc->text_sel_end))
 368                         tc->text_sel_end.nextEndOfWord();
 369                     sp_text_context_update_cursor(tc);
 370                     sp_text_context_update_text_selection(tc);
 371                     tc->dragging = 2;
 372                     sp_event_context_snap_window_open(event_context);
 373                     ret = TRUE;
 374                 }
 375             }
 376             break;
 377         case GDK_3BUTTON_PRESS:
 378             if (event->button.button == 1 && tc->text) {
 379                 tc->text_sel_start.thisStartOfLine();
 380                 tc->text_sel_end.thisEndOfLine();
 381                 sp_text_context_update_cursor(tc);
 382                 sp_text_context_update_text_selection(tc);
 383                 tc->dragging = 3;
 384                 sp_event_context_snap_window_open(event_context);
 385                 ret = TRUE;
 386             }
 387             break;
 388         case GDK_BUTTON_RELEASE:
 389             if (event->button.button == 1 && tc->dragging && !event_context->space_panning) {
 390                 tc->dragging = 0;
 391                 sp_event_context_snap_window_closed(event_context, false); //button release will also occur on a double-click; in that case suppress warnings
 392                 ret = TRUE;
 393             }
 394             break;
 395         case GDK_MOTION_NOTIFY:
 396             if (event->motion.state & GDK_BUTTON1_MASK && tc->dragging && !event_context->space_panning) {
 397                 Inkscape::Text::Layout const *layout = te_get_layout(tc->text);
 398                 if (!layout) break;
 399                 // find out click point in document coordinates
 400                 Geom::Point p = desktop->w2d(Geom::Point(event->button.x, event->button.y));
 401                 // set the cursor closest to that point
 402                 Inkscape::Text::Layout::iterator new_end = sp_te_get_position_by_coords(tc->text, p);
 403                 if (tc->dragging == 2) {
 404                     // double-click dragging: go by word
 405                     if (new_end < tc->text_sel_start) {
 406                         if (!layout->isStartOfWord(new_end))
 407                             new_end.prevStartOfWord();
 408                     } else
 409                         if (!layout->isEndOfWord(new_end))
 410                             new_end.nextEndOfWord();
 411                 } else if (tc->dragging == 3) {
 412                     // triple-click dragging: go by line
 413                     if (new_end < tc->text_sel_start)
 414                         new_end.thisStartOfLine();
 415                     else
 416                         new_end.thisEndOfLine();
 417                 }
 418                 // update display
 419                 if (tc->text_sel_end != new_end) {
 420                     tc->text_sel_end = new_end;
 421                     sp_text_context_update_cursor(tc);
 422                     sp_text_context_update_text_selection(tc);
 423                 }
 424                 gobble_motion_events(GDK_BUTTON1_MASK);
 425                 ret = TRUE;
 426                 break;
 427             }
 428             // find out item under mouse, disregarding groups
 429             item_ungrouped = desktop->item_at_point(Geom::Point(event->button.x, event->button.y), TRUE);
 430             if (SP_IS_TEXT(item_ungrouped) || SP_IS_FLOWTEXT(item_ungrouped)) {
 431                 sp_canvas_item_show(tc->indicator);
 432                 Geom::OptRect ibbox = sp_item_bbox_desktop(item_ungrouped);
 433                 if (ibbox) {
 434                     SP_CTRLRECT(tc->indicator)->setRectangle(*ibbox);
 435                 }
 436
 437                 event_context->cursor_shape = cursor_text_insert_xpm;
 438                 event_context->hot_x = 7;
 439                 event_context->hot_y = 10;
 440                 sp_event_context_update_cursor(event_context);
 441                 sp_text_context_update_text_selection(tc);
 442
 443                 if (SP_IS_TEXT (item_ungrouped)) {
 444                     desktop->event_context->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> to edit the text, <b>drag</b> to select part of the text."));
 445                 } else {
 446                     desktop->event_context->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> to edit the flowed text, <b>drag</b> to select part of the text."));
 447                 }
 448
 449                 tc->over_text = true;
 450
 451                 ret = TRUE;
 452             }
 453             break;
 454         default:
 455             break;
 456     }
 457
 458     if (!ret) {
 459         if (((SPEventContextClass *) parent_class)->item_handler)
 460             ret = ((SPEventContextClass *) parent_class)->item_handler(event_context, item, event);
 461     }
 462
 463     return ret;
 464 }
 465
 466 static void
 467 sp_text_context_setup_text(SPTextContext *tc)
 468 {
 469     SPEventContext *ec = SP_EVENT_CONTEXT(tc);
 470
 471     /* Create <text> */
 472     Inkscape::XML::Document *xml_doc = sp_document_repr_doc(SP_EVENT_CONTEXT_DESKTOP(ec)->doc());
 473     Inkscape::XML::Node *rtext = xml_doc->createElement("svg:text");
 474     rtext->setAttribute("xml:space", "preserve"); // we preserve spaces in the text objects we create
 475
 476     /* Set style */
 477     sp_desktop_apply_style_tool(SP_EVENT_CONTEXT_DESKTOP(ec), rtext, "/tools/text", true);
 478
 479     sp_repr_set_svg_double(rtext, "x", tc->pdoc[Geom::X]);
 480     sp_repr_set_svg_double(rtext, "y", tc->pdoc[Geom::Y]);
 481
 482     /* Create <tspan> */
 483     Inkscape::XML::Node *rtspan = xml_doc->createElement("svg:tspan");
 484     rtspan->setAttribute("sodipodi:role", "line"); // otherwise, why bother creating the tspan?
 485     rtext->addChild(rtspan, NULL);
 486     Inkscape::GC::release(rtspan);
 487
 488     /* Create TEXT */
 489     Inkscape::XML::Node *rstring = xml_doc->createTextNode("");
 490     rtspan->addChild(rstring, NULL);
 491     Inkscape::GC::release(rstring);
 492     SPItem *text_item = SP_ITEM(ec->desktop->currentLayer()->appendChildRepr(rtext));
 493     /* fixme: Is selection::changed really immediate? */
 494     /* yes, it's immediate .. why does it matter? */
 495     sp_desktop_selection(ec->desktop)->set(text_item);
 496     Inkscape::GC::release(rtext);
 497     text_item->transform = sp_item_i2doc_affine(SP_ITEM(ec->desktop->currentLayer())).inverse();
 498
 499     text_item->updateRepr();
 500     sp_document_done(sp_desktop_document(ec->desktop), SP_VERB_CONTEXT_TEXT,
 501                      _("Create text"));
 502 }
 503
 504 /**
 505  * Insert the character indicated by tc.uni to replace the current selection,
 506  * and reset tc.uni/tc.unipos to empty string.
 507  *
 508  * \pre tc.uni/tc.unipos non-empty.
 509  */
 510 static void
 511 insert_uni_char(SPTextContext *const tc)
 512 {
 513     g_return_if_fail(tc->unipos
 514                      && tc->unipos < sizeof(tc->uni)
 515                      && tc->uni[tc->unipos] == '\0');
 516     unsigned int uv;
 517     sscanf(tc->uni, "%x", &uv);
 518     tc->unipos = 0;
 519     tc->uni[tc->unipos] = '\0';
 520
 521     if ( !g_unichar_isprint(static_cast<gunichar>(uv))
 522          && !(g_unichar_validate(static_cast<gunichar>(uv)) && (g_unichar_type(static_cast<gunichar>(uv)) == G_UNICODE_PRIVATE_USE) ) ) {
 523         // This may be due to bad input, so it goes to statusbar.
 524         tc->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE,
 525                                            _("Non-printable character"));
 526     } else {
 527         if (!tc->text) { // printable key; create text if none (i.e. if nascent_object)
 528             sp_text_context_setup_text(tc);
 529             tc->nascent_object = 0; // we don't need it anymore, having created a real <text>
 530         }
 531
 532         gchar u[10];
 533         guint const len = g_unichar_to_utf8(uv, u);
 534         u[len] = '\0';
 535
 536         tc->text_sel_start = tc->text_sel_end = sp_te_replace(tc->text, tc->text_sel_start, tc->text_sel_end, u);
 537         sp_text_context_update_cursor(tc);
 538         sp_text_context_update_text_selection(tc);
 539         sp_document_done(sp_desktop_document(tc->desktop), SP_VERB_DIALOG_TRANSFORM,
 540                          _("Insert Unicode character"));
 541     }
 542 }
 543
 544 static void
 545 hex_to_printable_utf8_buf(char const *const hex, char *utf8)
 546 {
 547     unsigned int uv;
 548     sscanf(hex, "%x", &uv);
 549     if (!g_unichar_isprint((gunichar) uv)) {
 550         uv = 0xfffd;
 551     }
 552     guint const len = g_unichar_to_utf8(uv, utf8);
 553     utf8[len] = '\0';
 554 }
 555
 556 static void
 557 show_curr_uni_char(SPTextContext *const tc)
 558 {
 559     g_return_if_fail(tc->unipos < sizeof(tc->uni)
 560                      && tc->uni[tc->unipos] == '\0');
 561     if (tc->unipos) {
 562         char utf8[10];
 563         hex_to_printable_utf8_buf(tc->uni, utf8);
 564
 565         /* Status bar messages are in pango markup, so we need xml escaping. */
 566         if (utf8[1] == '\0') {
 567             switch(utf8[0]) {
 568                 case '<': strcpy(utf8, "&lt;"); break;
 569                 case '>': strcpy(utf8, "&gt;"); break;
 570                 case '&': strcpy(utf8, "&amp;"); break;
 571                 default: break;
 572             }
 573         }
 574         tc->defaultMessageContext()->setF(Inkscape::NORMAL_MESSAGE,
 575                                           _("Unicode (<b>Enter</b> to finish): %s: %s"), tc->uni, utf8);
 576     } else {
 577         tc->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, _("Unicode (<b>Enter</b> to finish): "));
 578     }
 579 }
 580
 581 static gint
 582 sp_text_context_root_handler(SPEventContext *const event_context, GdkEvent *const event)
 583 {
 584     SPTextContext *const tc = SP_TEXT_CONTEXT(event_context);
 585
 586     SPDesktop *desktop = event_context->desktop;
 587
 588     sp_canvas_item_hide(tc->indicator);
 589
 590     sp_text_context_validate_cursor_iterators(tc);
 591
 592     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 593     event_context->tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
 594
 595     switch (event->type) {
 596         case GDK_BUTTON_PRESS:
 597             if (event->button.button == 1 && !event_context->space_panning) {
 598
 599                 if (Inkscape::have_viable_layer(desktop, desktop->messageStack()) == false) {
 600                     return TRUE;
 601                 }
 602
 603                 // save drag origin
 604                 event_context->xp = (gint) event->button.x;
 605                 event_context->yp = (gint) event->button.y;
 606                 event_context->within_tolerance = true;
 607
 608                 Geom::Point const button_pt(event->button.x, event->button.y);
 609                 tc->p0 = desktop->w2d(button_pt);
 610                 Inkscape::Rubberband::get(desktop)->start(desktop, tc->p0);
 611                 sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
 612                                     GDK_KEY_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK,
 613                                     NULL, event->button.time);
 614                 tc->grabbed = SP_CANVAS_ITEM(desktop->acetate);
 615                 tc->creating = 1;
 616
 617                 /* Processed */
 618                 return TRUE;
 619             }
 620             break;
 621         case GDK_MOTION_NOTIFY:
 622             if (tc->over_text) {
 623                 tc->over_text = 0;
 624                 // update cursor and statusbar: we are not over a text object now
 625                 event_context->cursor_shape = cursor_text_xpm;
 626                 event_context->hot_x = 7;
 627                 event_context->hot_y = 7;
 628                 sp_event_context_update_cursor(event_context);
 629                 desktop->event_context->defaultMessageContext()->clear();
 630             }
 631
 632             if (tc->creating && event->motion.state & GDK_BUTTON1_MASK && !event_context->space_panning) {
 633                 if ( event_context->within_tolerance
 634                      && ( abs( (gint) event->motion.x - event_context->xp ) < event_context->tolerance )
 635                      && ( abs( (gint) event->motion.y - event_context->yp ) < event_context->tolerance ) ) {
 636                     break; // do not drag if we're within tolerance from origin
 637                 }
 638                 // Once the user has moved farther than tolerance from the original location
 639                 // (indicating they intend to draw, not click), then always process the
 640                 // motion notify coordinates as given (no snapping back to origin)
 641                 event_context->within_tolerance = false;
 642
 643                 Geom::Point const motion_pt(event->motion.x, event->motion.y);
 644                 Geom::Point const p = desktop->w2d(motion_pt);
 645
 646                 Inkscape::Rubberband::get(desktop)->move(p);
 647                 gobble_motion_events(GDK_BUTTON1_MASK);
 648
 649                 // status text
 650                 GString *xs = SP_PX_TO_METRIC_STRING(fabs((p - tc->p0)[Geom::X]), desktop->namedview->getDefaultMetric());
 651                 GString *ys = SP_PX_TO_METRIC_STRING(fabs((p - tc->p0)[Geom::Y]), desktop->namedview->getDefaultMetric());
 652                 event_context->_message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Flowed text frame</b>: %s &#215; %s"), xs->str, ys->str);
 653                 g_string_free(xs, FALSE);
 654                 g_string_free(ys, FALSE);
 655
 656             }
 657             break;
 658         case GDK_BUTTON_RELEASE:
 659             if (event->button.button == 1 && !event_context->space_panning) {
 660
 661                 if (tc->grabbed) {
 662                     sp_canvas_item_ungrab(tc->grabbed, GDK_CURRENT_TIME);
 663                     tc->grabbed = NULL;
 664                 }
 665
 666                 Inkscape::Rubberband::get(desktop)->stop();
 667
 668                 if (tc->creating && event_context->within_tolerance) {
 669                     /* Button 1, set X & Y & new item */
 670                     sp_desktop_selection(desktop)->clear();
 671                     Geom::Point dtp = desktop->w2d(Geom::Point(event->button.x, event->button.y));
 672                     tc->pdoc = desktop->dt2doc(dtp);
 673
 674                     tc->show = TRUE;
 675                     tc->phase = 1;
 676                     tc->nascent_object = 1; // new object was just created
 677
 678                     /* Cursor */
 679                     sp_canvas_item_show(tc->cursor);
 680                     // Cursor height is defined by the new text object's font size; it needs to be set
 681                     // articifically here, for the text object does not exist yet:
 682                     double cursor_height = sp_desktop_get_font_size_tool(desktop);
 683                     sp_ctrlline_set_coords(SP_CTRLLINE(tc->cursor), dtp, dtp + Geom::Point(0, cursor_height));
 684                     event_context->_message_context->set(Inkscape::NORMAL_MESSAGE, _("Type text; <b>Enter</b> to start new line.")); // FIXME:: this is a copy of a string from _update_cursor below, do not desync
 685
 686                     event_context->within_tolerance = false;
 687                 } else if (tc->creating) {
 688                     Geom::Point const button_pt(event->button.x, event->button.y);
 689                     Geom::Point p1 = desktop->w2d(button_pt);
 690                     double cursor_height = sp_desktop_get_font_size_tool(desktop);
 691                     if (fabs(p1[Geom::Y] - tc->p0[Geom::Y]) > cursor_height) {
 692                         // otherwise even one line won't fit; most probably a slip of hand (even if bigger than tolerance)
 693                         SPItem *ft = create_flowtext_with_internal_frame (desktop, tc->p0, p1);
 694                         /* Set style */
 695                         sp_desktop_apply_style_tool(desktop, SP_OBJECT_REPR(ft), "/tools/text", true);
 696                         sp_desktop_selection(desktop)->set(ft);
 697                         desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Flowed text is created."));
 698                         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_TEXT,
 699                                          _("Create flowed text"));
 700                     } else {
 701                         desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("The frame is <b>too small</b> for the current font size. Flowed text not created."));
 702                     }
 703                 }
 704                 tc->creating = false;
 705                 return TRUE;
 706             }
 707             break;
 708         case GDK_KEY_PRESS: {
 709             guint const group0_keyval = get_group0_keyval(&event->key);
 710
 711             if (group0_keyval == GDK_KP_Add ||
 712                 group0_keyval == GDK_KP_Subtract) {
 713                 if (!(event->key.state & GDK_MOD2_MASK)) // mod2 is NumLock; if on, type +/- keys
 714                     break; // otherwise pass on keypad +/- so they can zoom
 715             }
 716
 717             if ((tc->text) || (tc->nascent_object)) {
 718                 // there is an active text object in this context, or a new object was just created
 719
 720                 if (tc->unimode || !tc->imc
 721                     || (MOD__CTRL && MOD__SHIFT)    // input methods tend to steal this for unimode,
 722                                                     // but we have our own so make sure they don't swallow it
 723                     || !gtk_im_context_filter_keypress(tc->imc, (GdkEventKey*) event)) {
 724                     //IM did not consume the key, or we're in unimode
 725
 726                         if (!MOD__CTRL_ONLY && tc->unimode) {
 727                             /* TODO: ISO 14755 (section 3 Definitions) says that we should also
 728                                accept the first 6 characters of alphabets other than the latin
 729                                alphabet "if the Latin alphabet is not used".  The below is also
 730                                reasonable (viz. hope that the user's keyboard includes latin
 731                                characters and force latin interpretation -- just as we do for our
 732                                keyboard shortcuts), but differs from the ISO 14755
 733                                recommendation. */
 734                             switch (group0_keyval) {
 735                                 case GDK_space:
 736                                 case GDK_KP_Space: {
 737                                     if (tc->unipos) {
 738                                         insert_uni_char(tc);
 739                                     }
 740                                     /* Stay in unimode. */
 741                                     show_curr_uni_char(tc);
 742                                     return TRUE;
 743                                 }
 744
 745                                 case GDK_BackSpace: {
 746                                     g_return_val_if_fail(tc->unipos < sizeof(tc->uni), TRUE);
 747                                     if (tc->unipos) {
 748                                         tc->uni[--tc->unipos] = '\0';
 749                                     }
 750                                     show_curr_uni_char(tc);
 751                                     return TRUE;
 752                                 }
 753
 754                                 case GDK_Return:
 755                                 case GDK_KP_Enter: {
 756                                     if (tc->unipos) {
 757                                         insert_uni_char(tc);
 758                                     }
 759                                     /* Exit unimode. */
 760                                     tc->unimode = false;
 761                                     event_context->defaultMessageContext()->clear();
 762                                     return TRUE;
 763                                 }
 764
 765                                 case GDK_Escape: {
 766                                     // Cancel unimode.
 767                                     tc->unimode = false;
 768                                     gtk_im_context_reset(tc->imc);
 769                                     event_context->defaultMessageContext()->clear();
 770                                     return TRUE;
 771                                 }
 772
 773                                 case GDK_Shift_L:
 774                                 case GDK_Shift_R:
 775                                     break;
 776
 777                                 default: {
 778                                     if (g_ascii_isxdigit(group0_keyval)) {
 779                                         g_return_val_if_fail(tc->unipos < sizeof(tc->uni) - 1, TRUE);
 780                                         tc->uni[tc->unipos++] = group0_keyval;
 781                                         tc->uni[tc->unipos] = '\0';
 782                                         if (tc->unipos == 8) {
 783                                             /* This behaviour is partly to allow us to continue to
 784                                                use a fixed-length buffer for tc->uni.  Reason for
 785                                                choosing the number 8 is that it's the length of
 786                                                ``canonical form'' mentioned in the ISO 14755 spec.
 787                                                An advantage over choosing 6 is that it allows using
 788                                                backspace for typos & misremembering when entering a
 789                                                6-digit number. */
 790                                             insert_uni_char(tc);
 791                                         }
 792                                         show_curr_uni_char(tc);
 793                                         return TRUE;
 794                                     } else {
 795                                         /* The intent is to ignore but consume characters that could be
 796                                            typos for hex digits.  Gtk seems to ignore & consume all
 797                                            non-hex-digits, and we do similar here.  Though note that some
 798                                            shortcuts (like keypad +/- for zoom) get processed before
 799                                            reaching this code. */
 800                                         return TRUE;
 801                                     }
 802                                 }
 803                             }
 804                         }
 805
 806                         Inkscape::Text::Layout::iterator old_start = tc->text_sel_start;
 807                         Inkscape::Text::Layout::iterator old_end = tc->text_sel_end;
 808                         bool cursor_moved = false;
 809                         int screenlines = 1;
 810                         if (tc->text) {
 811                             double spacing = sp_te_get_average_linespacing(tc->text);
 812                             Geom::Rect const d = desktop->get_display_area();
 813                             screenlines = (int) floor(fabs(d.min()[Geom::Y] - d.max()[Geom::Y])/spacing) - 1;
 814                             if (screenlines <= 0)
 815                                 screenlines = 1;
 816                         }
 817
 818                         /* Neither unimode nor IM consumed key; process text tool shortcuts */
 819                         switch (group0_keyval) {
 820                             case GDK_x:
 821                             case GDK_X:
 822                                 if (MOD__ALT_ONLY) {
 823                                     desktop->setToolboxFocusTo ("altx-text");
 824                                     return TRUE;
 825                                 }
 826                                 break;
 827                             case GDK_space:
 828                                 if (MOD__CTRL_ONLY) {
 829                                     /* No-break space */
 830                                     if (!tc->text) { // printable key; create text if none (i.e. if nascent_object)
 831                                         sp_text_context_setup_text(tc);
 832                                         tc->nascent_object = 0; // we don't need it anymore, having created a real <text>
 833                                     }
 834                                     tc->text_sel_start = tc->text_sel_end = sp_te_replace(tc->text, tc->text_sel_start, tc->text_sel_end, "\302\240");
 835                                     sp_text_context_update_cursor(tc);
 836                                     sp_text_context_update_text_selection(tc);
 837                                     desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("No-break space"));
 838                                     sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_TEXT,
 839                                                      _("Insert no-break space"));
 840                                     return TRUE;
 841                                 }
 842                                 break;
 843                             case GDK_U:
 844                             case GDK_u:
 845                                 if (MOD__CTRL_ONLY || (MOD__CTRL && MOD__SHIFT)) {
 846                                     if (tc->unimode) {
 847                                         tc->unimode = false;
 848                                         event_context->defaultMessageContext()->clear();
 849                                     } else {
 850                                         tc->unimode = true;
 851                                         tc->unipos = 0;
 852                                         event_context->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, _("Unicode (<b>Enter</b> to finish): "));
 853                                     }
 854                                     if (tc->imc) {
 855                                         gtk_im_context_reset(tc->imc);
 856                                     }
 857                                     return TRUE;
 858                                 }
 859                                 break;
 860                             case GDK_B:
 861                             case GDK_b:
 862                                 if (MOD__CTRL_ONLY && tc->text) {
 863                                     SPStyle const *style = sp_te_style_at_position(tc->text, std::min(tc->text_sel_start, tc->text_sel_end));
 864                                     SPCSSAttr *css = sp_repr_css_attr_new();
 865                                     if (style->font_weight.computed == SP_CSS_FONT_WEIGHT_NORMAL
 866                                         || style->font_weight.computed == SP_CSS_FONT_WEIGHT_100
 867                                         || style->font_weight.computed == SP_CSS_FONT_WEIGHT_200
 868                                         || style->font_weight.computed == SP_CSS_FONT_WEIGHT_300
 869                                         || style->font_weight.computed == SP_CSS_FONT_WEIGHT_400)
 870                                         sp_repr_css_set_property(css, "font-weight", "bold");
 871                                     else
 872                                         sp_repr_css_set_property(css, "font-weight", "normal");
 873                                     sp_te_apply_style(tc->text, tc->text_sel_start, tc->text_sel_end, css);
 874                                     sp_repr_css_attr_unref(css);
 875                                     sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_TEXT,
 876                                                      _("Make bold"));
 877                                     sp_text_context_update_cursor(tc);
 878                                     sp_text_context_update_text_selection(tc);
 879                                     return TRUE;
 880                                 }
 881                                 break;
 882                             case GDK_I:
 883                             case GDK_i:
 884                                 if (MOD__CTRL_ONLY && tc->text) {
 885                                     SPStyle const *style = sp_te_style_at_position(tc->text, std::min(tc->text_sel_start, tc->text_sel_end));
 886                                     SPCSSAttr *css = sp_repr_css_attr_new();
 887                                     if (style->font_style.computed == SP_CSS_FONT_STYLE_NORMAL)
 888                                         sp_repr_css_set_property(css, "font-style", "italic");
 889                                     else
 890                                         sp_repr_css_set_property(css, "font-style", "normal");
 891                                     sp_te_apply_style(tc->text, tc->text_sel_start, tc->text_sel_end, css);
 892                                     sp_repr_css_attr_unref(css);
 893                                     sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_TEXT,
 894                                                      _("Make italic"));
 895                                     sp_text_context_update_cursor(tc);
 896                                     sp_text_context_update_text_selection(tc);
 897                                     return TRUE;
 898                                 }
 899                                 break;
 900
 901                             case GDK_A:
 902                             case GDK_a:
 903                                 if (MOD__CTRL_ONLY && tc->text) {
 904                                     Inkscape::Text::Layout const *layout = te_get_layout(tc->text);
 905                                     if (layout) {
 906                                         tc->text_sel_start = layout->begin();
 907                                         tc->text_sel_end = layout->end();
 908                                         sp_text_context_update_cursor(tc);
 909                                         sp_text_context_update_text_selection(tc);
 910                                         return TRUE;
 911                                     }
 912                                 }
 913                                 break;
 914
 915                             case GDK_Return:
 916                             case GDK_KP_Enter:
 917                             {
 918                                 if (!tc->text) { // printable key; create text if none (i.e. if nascent_object)
 919                                     sp_text_context_setup_text(tc);
 920                                     tc->nascent_object = 0; // we don't need it anymore, having created a real <text>
 921                                 }
 922
 923                                 iterator_pair enter_pair;
 924                                 bool success = sp_te_delete(tc->text, tc->text_sel_start, tc->text_sel_end, enter_pair);
 925                                 (void)success; // TODO cleanup
 926                                 tc->text_sel_start = tc->text_sel_end = enter_pair.first;
 927
 928                                 tc->text_sel_start = tc->text_sel_end = sp_te_insert_line(tc->text, tc->text_sel_start);
 929
 930                                 sp_text_context_update_cursor(tc);
 931                                 sp_text_context_update_text_selection(tc);
 932                                 sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_TEXT,
 933                                                  _("New line"));
 934                                 return TRUE;
 935                             }
 936                             case GDK_BackSpace:
 937                                 if (tc->text) { // if nascent_object, do nothing, but return TRUE; same for all other delete and move keys
 938
 939                                     bool noSelection = false;
 940
 941                                         if (tc->text_sel_start == tc->text_sel_end) {
 942                                         tc->text_sel_start.prevCursorPosition();
 943                                         noSelection = true;
 944                                     }
 945
 946                                         iterator_pair bspace_pair;
 947                                         bool success = sp_te_delete(tc->text, tc->text_sel_start, tc->text_sel_end, bspace_pair);
 948
 949                                     if (noSelection) {
 950                                         if (success) {
 951                                             tc->text_sel_start = tc->text_sel_end = bspace_pair.first;
 952                                         } else { // nothing deleted
 953                                             tc->text_sel_start = tc->text_sel_end = bspace_pair.second;
 954                                         }
 955                                     } else {
 956                                         if (success) {
 957                                             tc->text_sel_start = tc->text_sel_end = bspace_pair.first;
 958                                         } else { // nothing deleted
 959                                             tc->text_sel_start = bspace_pair.first;
 960                                             tc->text_sel_end = bspace_pair.second;
 961                                         }
 962                                     }
 963
 964                                     sp_text_context_update_cursor(tc);
 965                                     sp_text_context_update_text_selection(tc);
 966                                     sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_TEXT,
 967                                                      _("Backspace"));
 968                                 }
 969                                 return TRUE;
 970                             case GDK_Delete:
 971                             case GDK_KP_Delete:
 972                                 if (tc->text) {
 973                                     bool noSelection = false;
 974
 975                                     if (tc->text_sel_start == tc->text_sel_end) {
 976                                         tc->text_sel_end.nextCursorPosition();
 977                                         noSelection = true;
 978                                     }
 979
 980                                     iterator_pair del_pair;
 981                                     bool success = sp_te_delete(tc->text, tc->text_sel_start, tc->text_sel_end, del_pair);
 982
 983                                     if (noSelection) {
 984                                         tc->text_sel_start = tc->text_sel_end = del_pair.first;
 985                                     } else {
 986                                         if (success) {
 987                                             tc->text_sel_start = tc->text_sel_end = del_pair.first;
 988                                         } else { // nothing deleted
 989                                             tc->text_sel_start = del_pair.first;
 990                                             tc->text_sel_end = del_pair.second;
 991                                         }
 992                                     }
 993
 994
 995                                     sp_text_context_update_cursor(tc);
 996                                     sp_text_context_update_text_selection(tc);
 997                                     sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_TEXT,
 998                                                      _("Delete"));
 999                                 }
1000                                 return TRUE;
1001                             case GDK_Left:
1002                             case GDK_KP_Left:
1003                             case GDK_KP_4:
1004                                 if (tc->text) {
1005                                     if (MOD__ALT) {
1006                                         gint mul = 1 + gobble_key_events(
1007                                             get_group0_keyval(&event->key), 0); // with any mask
1008                                         if (MOD__SHIFT)
1009                                             sp_te_adjust_kerning_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, Geom::Point(mul*-10, 0));
1010                                         else
1011                                             sp_te_adjust_kerning_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, Geom::Point(mul*-1, 0));
1012                                         sp_text_context_update_cursor(tc);
1013                                         sp_text_context_update_text_selection(tc);
1014                                         sp_document_maybe_done(sp_desktop_document(desktop), "kern:left", SP_VERB_CONTEXT_TEXT,
1015                                                                _("Kern to the left"));
1016                                     } else {
1017                                         if (MOD__CTRL)
1018                                             tc->text_sel_end.cursorLeftWithControl();
1019                                         else
1020                                             tc->text_sel_end.cursorLeft();
1021                                         cursor_moved = true;
1022                                         break;
1023                                     }
1024                                 }
1025                                 return TRUE;
1026                             case GDK_Right:
1027                             case GDK_KP_Right:
1028                             case GDK_KP_6:
1029                                 if (tc->text) {
1030                                     if (MOD__ALT) {
1031                                         gint mul = 1 + gobble_key_events(
1032                                             get_group0_keyval(&event->key), 0); // with any mask
1033                                         if (MOD__SHIFT)
1034                                             sp_te_adjust_kerning_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, Geom::Point(mul*10, 0));
1035                                         else
1036                                             sp_te_adjust_kerning_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, Geom::Point(mul*1, 0));
1037                                         sp_text_context_update_cursor(tc);
1038                                         sp_text_context_update_text_selection(tc);
1039                                         sp_document_maybe_done(sp_desktop_document(desktop), "kern:right", SP_VERB_CONTEXT_TEXT,
1040                                                                _("Kern to the right"));
1041                                     } else {
1042                                         if (MOD__CTRL)
1043                                             tc->text_sel_end.cursorRightWithControl();
1044                                         else
1045                                             tc->text_sel_end.cursorRight();
1046                                         cursor_moved = true;
1047                                         break;
1048                                     }
1049                                 }
1050                                 return TRUE;
1051                             case GDK_Up:
1052                             case GDK_KP_Up:
1053                             case GDK_KP_8:
1054                                 if (tc->text) {
1055                                     if (MOD__ALT) {
1056                                         gint mul = 1 + gobble_key_events(
1057                                             get_group0_keyval(&event->key), 0); // with any mask
1058                                         if (MOD__SHIFT)
1059                                             sp_te_adjust_kerning_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, Geom::Point(0, mul*-10));
1060                                         else
1061                                             sp_te_adjust_kerning_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, Geom::Point(0, mul*-1));
1062                                         sp_text_context_update_cursor(tc);
1063                                         sp_text_context_update_text_selection(tc);
1064                                         sp_document_maybe_done(sp_desktop_document(desktop), "kern:up", SP_VERB_CONTEXT_TEXT,
1065                                                                _("Kern up"));
1066
1067                                     } else {
1068                                         if (MOD__CTRL)
1069                                             tc->text_sel_end.cursorUpWithControl();
1070                                         else
1071                                             tc->text_sel_end.cursorUp();
1072                                         cursor_moved = true;
1073                                         break;
1074                                     }
1075                                 }
1076                                 return TRUE;
1077                             case GDK_Down:
1078                             case GDK_KP_Down:
1079                             case GDK_KP_2:
1080                                 if (tc->text) {
1081                                     if (MOD__ALT) {
1082                                         gint mul = 1 + gobble_key_events(
1083                                             get_group0_keyval(&event->key), 0); // with any mask
1084                                         if (MOD__SHIFT)
1085                                             sp_te_adjust_kerning_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, Geom::Point(0, mul*10));
1086                                         else
1087                                             sp_te_adjust_kerning_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, Geom::Point(0, mul*1));
1088                                         sp_text_context_update_cursor(tc);
1089                                         sp_text_context_update_text_selection(tc);
1090                                         sp_document_maybe_done(sp_desktop_document(desktop), "kern:down", SP_VERB_CONTEXT_TEXT,
1091                                                                _("Kern down"));
1092
1093                                     } else {
1094                                         if (MOD__CTRL)
1095                                             tc->text_sel_end.cursorDownWithControl();
1096                                         else
1097                                             tc->text_sel_end.cursorDown();
1098                                         cursor_moved = true;
1099                                         break;
1100                                     }
1101                                 }
1102                                 return TRUE;
1103                             case GDK_Home:
1104                             case GDK_KP_Home:
1105                                 if (tc->text) {
1106                                     if (MOD__CTRL)
1107                                         tc->text_sel_end.thisStartOfShape();
1108                                     else
1109                                         tc->text_sel_end.thisStartOfLine();
1110                                     cursor_moved = true;
1111                                     break;
1112                                 }
1113                                 return TRUE;
1114                             case GDK_End:
1115                             case GDK_KP_End:
1116                                 if (tc->text) {
1117                                     if (MOD__CTRL)
1118                                         tc->text_sel_end.nextStartOfShape();
1119                                     else
1120                                         tc->text_sel_end.thisEndOfLine();
1121                                     cursor_moved = true;
1122                                     break;
1123                                 }
1124                                 return TRUE;
1125                             case GDK_Page_Down:
1126                             case GDK_KP_Page_Down:
1127                                 if (tc->text) {
1128                                     tc->text_sel_end.cursorDown(screenlines);
1129                                     cursor_moved = true;
1130                                     break;
1131                                 }
1132                                 return TRUE;
1133                             case GDK_Page_Up:
1134                             case GDK_KP_Page_Up:
1135                                 if (tc->text) {
1136                                     tc->text_sel_end.cursorUp(screenlines);
1137                                     cursor_moved = true;
1138                                     break;
1139                                 }
1140                                 return TRUE;
1141                             case GDK_Escape:
1142                                 if (tc->creating) {
1143                                     tc->creating = 0;
1144                                     if (tc->grabbed) {
1145                                         sp_canvas_item_ungrab(tc->grabbed, GDK_CURRENT_TIME);
1146                                         tc->grabbed = NULL;
1147                                     }
1148                                     Inkscape::Rubberband::get(desktop)->stop();
1149                                 } else {
1150                                     sp_desktop_selection(desktop)->clear();
1151                                 }
1152                                 tc->nascent_object = FALSE;
1153                                 return TRUE;
1154                             case GDK_bracketleft:
1155                                 if (tc->text) {
1156                                     if (MOD__ALT || MOD__CTRL) {
1157                                         if (MOD__ALT) {
1158                                             if (MOD__SHIFT) {
1159                                                 // FIXME: alt+shift+[] does not work, don't know why
1160                                                 sp_te_adjust_rotation_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, -10);
1161                                             } else {
1162                                                 sp_te_adjust_rotation_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, -1);
1163                                             }
1164                                         } else {
1165                                             sp_te_adjust_rotation(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, -90);
1166                                         }
1167                                         sp_document_maybe_done(sp_desktop_document(desktop), "textrot:ccw", SP_VERB_CONTEXT_TEXT,
1168                                                                _("Rotate counterclockwise"));
1169                                         sp_text_context_update_cursor(tc);
1170                                         sp_text_context_update_text_selection(tc);
1171                                         return TRUE;
1172                                     }
1173                                 }
1174                                 break;
1175                             case GDK_bracketright:
1176                                 if (tc->text) {
1177                                     if (MOD__ALT || MOD__CTRL) {
1178                                         if (MOD__ALT) {
1179                                             if (MOD__SHIFT) {
1180                                                 // FIXME: alt+shift+[] does not work, don't know why
1181                                                 sp_te_adjust_rotation_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, 10);
1182                                             } else {
1183                                                 sp_te_adjust_rotation_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, 1);
1184                                             }
1185                                         } else {
1186                                             sp_te_adjust_rotation(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, 90);
1187                                         }
1188                                         sp_document_maybe_done(sp_desktop_document(desktop), "textrot:cw", SP_VERB_CONTEXT_TEXT,
1189                                                                 _("Rotate clockwise"));
1190                                         sp_text_context_update_cursor(tc);
1191                                         sp_text_context_update_text_selection(tc);
1192                                         return TRUE;
1193                                     }
1194                                 }
1195                                 break;
1196                             case GDK_less:
1197                             case GDK_comma:
1198                                 if (tc->text) {
1199                                     if (MOD__ALT) {
1200                                         if (MOD__CTRL) {
1201                                             if (MOD__SHIFT)
1202                                                 sp_te_adjust_linespacing_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, -10);
1203                                             else
1204                                                 sp_te_adjust_linespacing_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, -1);
1205                                             sp_document_maybe_done(sp_desktop_document(desktop), "linespacing:dec", SP_VERB_CONTEXT_TEXT,
1206                                                                     _("Contract line spacing"));
1207
1208                                         } else {
1209                                             if (MOD__SHIFT)
1210                                                 sp_te_adjust_tspan_letterspacing_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, -10);
1211                                             else
1212                                                 sp_te_adjust_tspan_letterspacing_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, -1);
1213                                             sp_document_maybe_done(sp_desktop_document(desktop), "letterspacing:dec", SP_VERB_CONTEXT_TEXT,
1214                                                                     _("Contract letter spacing"));
1215
1216                                         }
1217                                         sp_text_context_update_cursor(tc);
1218                                         sp_text_context_update_text_selection(tc);
1219                                         return TRUE;
1220                                     }
1221                                 }
1222                                 break;
1223                             case GDK_greater:
1224                             case GDK_period:
1225                                 if (tc->text) {
1226                                     if (MOD__ALT) {
1227                                         if (MOD__CTRL) {
1228                                             if (MOD__SHIFT)
1229                                                 sp_te_adjust_linespacing_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, 10);
1230                                             else
1231                                                 sp_te_adjust_linespacing_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, 1);
1232                                             sp_document_maybe_done(sp_desktop_document(desktop), "linespacing:inc", SP_VERB_CONTEXT_TEXT,
1233                                                                     _("Expand line spacing"));
1234
1235                                         } else {
1236                                             if (MOD__SHIFT)
1237                                                 sp_te_adjust_tspan_letterspacing_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, 10);
1238                                             else
1239                                                 sp_te_adjust_tspan_letterspacing_screen(tc->text, tc->text_sel_start, tc->text_sel_end, desktop, 1);
1240                                             sp_document_maybe_done(sp_desktop_document(desktop), "letterspacing:inc", SP_VERB_CONTEXT_TEXT,
1241                                                                     _("Expand letter spacing"));
1242
1243                                         }
1244                                         sp_text_context_update_cursor(tc);
1245                                         sp_text_context_update_text_selection(tc);
1246                                         return TRUE;
1247                                     }
1248                                 }
1249                                 break;
1250                             default:
1251                                 break;
1252                         }
1253
1254                         if (cursor_moved) {
1255                             if (!MOD__SHIFT)
1256                                 tc->text_sel_start = tc->text_sel_end;
1257                             if (old_start != tc->text_sel_start || old_end != tc->text_sel_end) {
1258                                 sp_text_context_update_cursor(tc);
1259                                 sp_text_context_update_text_selection(tc);
1260                             }
1261                             return TRUE;
1262                         }
1263
1264                 } else return TRUE; // return the "I took care of it" value if it was consumed by the IM
1265             } else { // do nothing if there's no object to type in - the key will be sent to parent context,
1266                 // except up/down that are swallowed to prevent the zoom field from activation
1267                 if ((group0_keyval == GDK_Up    ||
1268                      group0_keyval == GDK_Down  ||
1269                      group0_keyval == GDK_KP_Up ||
1270                      group0_keyval == GDK_KP_Down )
1271                     && !MOD__CTRL_ONLY) {
1272                     return TRUE;
1273                 } else if (group0_keyval == GDK_Escape) { // cancel rubberband
1274                     if (tc->creating) {
1275                         tc->creating = 0;
1276                         if (tc->grabbed) {
1277                             sp_canvas_item_ungrab(tc->grabbed, GDK_CURRENT_TIME);
1278                             tc->grabbed = NULL;
1279                         }
1280                         Inkscape::Rubberband::get(desktop)->stop();
1281                     }
1282                 } else if ((group0_keyval == GDK_x || group0_keyval == GDK_X) && MOD__ALT_ONLY) {
1283                     desktop->setToolboxFocusTo ("altx-text");
1284                     return TRUE;
1285                 }
1286             }
1287             break;
1288         }
1289
1290         case GDK_KEY_RELEASE:
1291             if (!tc->unimode && tc->imc && gtk_im_context_filter_keypress(tc->imc, (GdkEventKey*) event)) {
1292                 return TRUE;
1293             }
1294             break;
1295         default:
1296             break;
1297     }
1298
1299     // if nobody consumed it so far
1300     if (((SPEventContextClass *) parent_class)->root_handler) { // and there's a handler in parent context,
1301         return ((SPEventContextClass *) parent_class)->root_handler(event_context, event); // send event to parent
1302     } else {
1303         return FALSE; // return "I did nothing" value so that global shortcuts can be activated
1304     }
1305 }
1306
1307 /**
1308  Attempts to paste system clipboard into the currently edited text, returns true on success
1309  */
1310 bool
1311 sp_text_paste_inline(SPEventContext *ec)
1312 {
1313     if (!SP_IS_TEXT_CONTEXT(ec))
1314         return false;
1315
1316     SPTextContext *tc = SP_TEXT_CONTEXT(ec);
1317
1318     if ((tc->text) || (tc->nascent_object)) {
1319         // there is an active text object in this context, or a new object was just created
1320
1321         Glib::RefPtr<Gtk::Clipboard> refClipboard = Gtk::Clipboard::get();
1322         Glib::ustring const clip_text = refClipboard->wait_for_text();
1323
1324         if (!clip_text.empty()) {
1325                 // Fix for 244940
1326                 // The XML standard defines the following as valid characters
1327                 // (Extensible Markup Language (XML) 1.0 (Fourth Edition) paragraph 2.2)
1328                 // char ::=     #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
1329                 // Since what comes in off the paste buffer will go right into XML, clean
1330                 // the text here.
1331                 Glib::ustring text(clip_text);
1332                 Glib::ustring::iterator itr = text.begin();
1333                 gunichar paste_string_uchar;
1334
1335                 while(itr != text.end())
1336                 {
1337                     paste_string_uchar = *itr;
1338
1339                     // Make sure we don't have a control character. We should really check
1340                     // for the whole range above... Add the rest of the invalid cases from
1341                     // above if we find additional issues
1342                     if(paste_string_uchar >= 0x00000020 ||
1343                        paste_string_uchar == 0x00000009 ||
1344                        paste_string_uchar == 0x0000000A ||
1345                        paste_string_uchar == 0x0000000D) {
1346                         itr++;
1347                     } else {
1348                         itr = text.erase(itr);
1349                     }
1350                 }
1351
1352             if (!tc->text) { // create text if none (i.e. if nascent_object)
1353                 sp_text_context_setup_text(tc);
1354                 tc->nascent_object = 0; // we don't need it anymore, having created a real <text>
1355             }
1356
1357             // using indices is slow in ustrings. Whatever.
1358             Glib::ustring::size_type begin = 0;
1359             for ( ; ; ) {
1360                 Glib::ustring::size_type end = text.find('\n', begin);
1361                 if (end == Glib::ustring::npos) {
1362                     if (begin != text.length())
1363                         tc->text_sel_start = tc->text_sel_end = sp_te_replace(tc->text, tc->text_sel_start, tc->text_sel_end, text.substr(begin).c_str());
1364                     break;
1365                 }
1366                 tc->text_sel_start = tc->text_sel_end = sp_te_replace(tc->text, tc->text_sel_start, tc->text_sel_end, text.substr(begin, end - begin).c_str());
1367                 tc->text_sel_start = tc->text_sel_end = sp_te_insert_line(tc->text, tc->text_sel_start);
1368                 begin = end + 1;
1369             }
1370             sp_document_done(sp_desktop_document(ec->desktop), SP_VERB_CONTEXT_TEXT,
1371                              _("Paste text"));
1372
1373             return true;
1374         }
1375     } // FIXME: else create and select a new object under cursor!
1376
1377     return false;
1378 }
1379
1380 /**
1381  Gets the raw characters that comprise the currently selected text, converting line
1382  breaks into lf characters.
1383 */
1384 Glib::ustring
1385 sp_text_get_selected_text(SPEventContext const *ec)
1386 {
1387     if (!SP_IS_TEXT_CONTEXT(ec))
1388         return "";
1389     SPTextContext const *tc = SP_TEXT_CONTEXT(ec);
1390     if (tc->text == NULL)
1391         return "";
1392
1393     return sp_te_get_string_multiline(tc->text, tc->text_sel_start, tc->text_sel_end);
1394 }
1395
1396 SPCSSAttr *
1397 sp_text_get_style_at_cursor(SPEventContext const *ec)
1398 {
1399     if (!SP_IS_TEXT_CONTEXT(ec))
1400         return NULL;
1401     SPTextContext const *tc = SP_TEXT_CONTEXT(ec);
1402     if (tc->text == NULL)
1403         return NULL;
1404
1405     SPObject const *obj = sp_te_object_at_position(tc->text, tc->text_sel_end);
1406     if (obj)
1407         return take_style_from_item((SPItem *) obj);
1408     return NULL;
1409 }
1410
1411 /**
1412  Deletes the currently selected characters. Returns false if there is no
1413  text selection currently.
1414 */
1415 bool sp_text_delete_selection(SPEventContext *ec)
1416 {
1417     if (!SP_IS_TEXT_CONTEXT(ec))
1418         return false;
1419     SPTextContext *tc = SP_TEXT_CONTEXT(ec);
1420     if (tc->text == NULL)
1421         return false;
1422
1423     if (tc->text_sel_start == tc->text_sel_end)
1424         return false;
1425
1426     iterator_pair pair;
1427     bool success = sp_te_delete(tc->text, tc->text_sel_start, tc->text_sel_end, pair);
1428
1429
1430     if (success) {
1431         tc->text_sel_start = tc->text_sel_end = pair.first;
1432     } else { // nothing deleted
1433         tc->text_sel_start = pair.first;
1434         tc->text_sel_end = pair.second;
1435     }
1436
1437     sp_text_context_update_cursor(tc);
1438     sp_text_context_update_text_selection(tc);
1439
1440     return true;
1441 }
1442
1443 /**
1444  * \param selection Should not be NULL.
1445  */
1446 static void
1447 sp_text_context_selection_changed(Inkscape::Selection *selection, SPTextContext *tc)
1448 {
1449     g_assert(selection != NULL);
1450
1451     SPEventContext *ec = SP_EVENT_CONTEXT(tc);
1452
1453     ec->shape_editor->unset_item(SH_KNOTHOLDER);
1454     SPItem *item = selection->singleItem();
1455     if (item && SP_IS_FLOWTEXT (item) && SP_FLOWTEXT(item)->has_internal_frame()) {
1456         ec->shape_editor->set_item(item, SH_KNOTHOLDER);
1457     }
1458
1459     if (tc->text && (item != tc->text)) {
1460         sp_text_context_forget_text(tc);
1461     }
1462     tc->text = NULL;
1463
1464     if (SP_IS_TEXT(item) || SP_IS_FLOWTEXT(item)) {
1465         tc->text = item;
1466         Inkscape::Text::Layout const *layout = te_get_layout(tc->text);
1467         if (layout)
1468             tc->text_sel_start = tc->text_sel_end = layout->end();
1469     } else {
1470         tc->text = NULL;
1471     }
1472
1473     // we update cursor without scrolling, because this position may not be final;
1474     // item_handler moves cusros to the point of click immediately
1475     sp_text_context_update_cursor(tc, false);
1476     sp_text_context_update_text_selection(tc);
1477 }
1478
1479 static void
1480 sp_text_context_selection_modified(Inkscape::Selection */*selection*/, guint /*flags*/, SPTextContext *tc)
1481 {
1482     sp_text_context_update_cursor(tc);
1483     sp_text_context_update_text_selection(tc);
1484 }
1485
1486 static bool
1487 sp_text_context_style_set(SPCSSAttr const *css, SPTextContext *tc)
1488 {
1489     if (tc->text == NULL)
1490         return false;
1491     if (tc->text_sel_start == tc->text_sel_end)
1492         return false;    // will get picked up by the parent and applied to the whole text object
1493
1494     sp_te_apply_style(tc->text, tc->text_sel_start, tc->text_sel_end, css);
1495     sp_document_done(sp_desktop_document(tc->desktop), SP_VERB_CONTEXT_TEXT,
1496                      _("Set text style"));
1497     sp_text_context_update_cursor(tc);
1498     sp_text_context_update_text_selection(tc);
1499
1500     return true;
1501 }
1502
1503 static int
1504 sp_text_context_style_query(SPStyle *style, int property, SPTextContext *tc)
1505 {
1506     if (tc->text == NULL)
1507         return QUERY_STYLE_NOTHING;
1508     const Inkscape::Text::Layout *layout = te_get_layout(tc->text);
1509     if (layout == NULL)
1510         return QUERY_STYLE_NOTHING;
1511     sp_text_context_validate_cursor_iterators(tc);
1512
1513     GSList *styles_list = NULL;
1514
1515     Inkscape::Text::Layout::iterator begin_it, end_it;
1516     if (tc->text_sel_start < tc->text_sel_end) {
1517         begin_it = tc->text_sel_start;
1518         end_it = tc->text_sel_end;
1519     } else {
1520         begin_it = tc->text_sel_end;
1521         end_it = tc->text_sel_start;
1522     }
1523     if (begin_it == end_it)
1524         if (!begin_it.prevCharacter())
1525             end_it.nextCharacter();
1526     for (Inkscape::Text::Layout::iterator it = begin_it ; it < end_it ; it.nextStartOfSpan()) {
1527         SPObject const *pos_obj = 0;
1528         void *rawptr = 0;
1529         layout->getSourceOfCharacter(it, &rawptr);
1530         if (!rawptr || !SP_IS_OBJECT(rawptr))
1531             continue;
1532         pos_obj = SP_OBJECT(rawptr);
1533         while (SP_IS_STRING(pos_obj) && SP_OBJECT_PARENT(pos_obj)) {
1534            pos_obj = SP_OBJECT_PARENT(pos_obj);   // SPStrings don't have style
1535         }
1536         styles_list = g_slist_prepend(styles_list, (gpointer)pos_obj);
1537     }
1538
1539     int result = sp_desktop_query_style_from_list (styles_list, style, property);
1540
1541     g_slist_free(styles_list);
1542     return result;
1543 }
1544
1545 static void
1546 sp_text_context_validate_cursor_iterators(SPTextContext *tc)
1547 {
1548     if (tc->text == NULL)
1549         return;
1550     Inkscape::Text::Layout const *layout = te_get_layout(tc->text);
1551     if (layout) {     // undo can change the text length without us knowing it
1552         layout->validateIterator(&tc->text_sel_start);
1553         layout->validateIterator(&tc->text_sel_end);
1554     }
1555 }
1556
1557 static void
1558 sp_text_context_update_cursor(SPTextContext *tc,  bool scroll_to_see)
1559 {
1560     GdkRectangle im_cursor = { 0, 0, 1, 1 };
1561
1562     // due to interruptible display, tc may already be destroyed during a display update before
1563     // the cursor update (can't do both atomically, alas)
1564     if (!tc->desktop) return;
1565
1566     if (tc->text) {
1567         Geom::Point p0, p1;
1568         sp_te_get_cursor_coords(tc->text, tc->text_sel_end, p0, p1);
1569         Geom::Point const d0 = p0 * sp_item_i2d_affine(SP_ITEM(tc->text));
1570         Geom::Point const d1 = p1 * sp_item_i2d_affine(SP_ITEM(tc->text));
1571
1572         // scroll to show cursor
1573         if (scroll_to_see) {
1574             Geom::Point const center = SP_EVENT_CONTEXT(tc)->desktop->get_display_area().midpoint();
1575             if (Geom::L2(d0 - center) > Geom::L2(d1 - center))
1576                 // unlike mouse moves, here we must scroll all the way at first shot, so we override the autoscrollspeed
1577                 SP_EVENT_CONTEXT(tc)->desktop->scroll_to_point(d0, 1.0);
1578             else
1579                 SP_EVENT_CONTEXT(tc)->desktop->scroll_to_point(d1, 1.0);
1580         }
1581
1582         sp_canvas_item_show(tc->cursor);
1583         sp_ctrlline_set_coords(SP_CTRLLINE(tc->cursor), d0, d1);
1584
1585         /* fixme: ... need another transformation to get canvas widget coordinate space? */
1586         im_cursor.x = (int) floor(d0[Geom::X]);
1587         im_cursor.y = (int) floor(d0[Geom::Y]);
1588         im_cursor.width = (int) floor(d1[Geom::X]) - im_cursor.x;
1589         im_cursor.height = (int) floor(d1[Geom::Y]) - im_cursor.y;
1590
1591         tc->show = TRUE;
1592         tc->phase = 1;
1593
1594         Inkscape::Text::Layout const *layout = te_get_layout(tc->text);
1595         int const nChars = layout->iteratorToCharIndex(layout->end());
1596         if (SP_IS_FLOWTEXT(tc->text)) {
1597             SPItem *frame = SP_FLOWTEXT(tc->text)->get_frame (NULL); // first frame only
1598             if (frame) {
1599                 sp_canvas_item_show(tc->frame);
1600                 Geom::OptRect frame_bbox = sp_item_bbox_desktop(frame);
1601                 if (frame_bbox) {
1602                     SP_CTRLRECT(tc->frame)->setRectangle(*frame_bbox);
1603                 }
1604             }
1605             SP_EVENT_CONTEXT(tc)->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("Type or edit flowed text (%d characters); <b>Enter</b> to start new paragraph."), nChars);
1606         } else {
1607             SP_EVENT_CONTEXT(tc)->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("Type or edit text (%d characters); <b>Enter</b> to start new line."), nChars);
1608         }
1609
1610     } else {
1611         sp_canvas_item_hide(tc->cursor);
1612         sp_canvas_item_hide(tc->frame);
1613         tc->show = FALSE;
1614         if (!tc->nascent_object) {
1615             SP_EVENT_CONTEXT(tc)->_message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> to select or create text, <b>drag</b> to create flowed text; then type.")); // FIXME: this is a copy of string from tools-switch, do not desync
1616         }
1617     }
1618
1619     if (tc->imc) {
1620         gtk_im_context_set_cursor_location(tc->imc, &im_cursor);
1621     }
1622     SP_EVENT_CONTEXT(tc)->desktop->emitToolSubselectionChanged((gpointer)tc);
1623 }
1624
1625 static void sp_text_context_update_text_selection(SPTextContext *tc)
1626 {
1627     // due to interruptible display, tc may already be destroyed during a display update before
1628     // the selection update (can't do both atomically, alas)
1629     if (!tc->desktop) return;
1630
1631     for (std::vector<SPCanvasItem*>::iterator it = tc->text_selection_quads.begin() ; it != tc->text_selection_quads.end() ; it++) {
1632         sp_canvas_item_hide(*it);
1633         gtk_object_destroy(*it);
1634     }
1635     tc->text_selection_quads.clear();
1636
1637     std::vector<Geom::Point> quads;
1638     if (tc->text != NULL)
1639         quads = sp_te_create_selection_quads(tc->text, tc->text_sel_start, tc->text_sel_end, sp_item_i2d_affine(tc->text));
1640     for (unsigned i = 0 ; i < quads.size() ; i += 4) {
1641         SPCanvasItem *quad_canvasitem;
1642         quad_canvasitem = sp_canvas_item_new(sp_desktop_controls(tc->desktop), SP_TYPE_CTRLQUADR, NULL);
1643         // FIXME: make the color settable in prefs
1644         // for now, use semitrasparent blue, as cairo cannot do inversion :(
1645         sp_ctrlquadr_set_rgba32(SP_CTRLQUADR(quad_canvasitem), 0x00777777);
1646         sp_ctrlquadr_set_coords(SP_CTRLQUADR(quad_canvasitem), quads[i], quads[i+1], quads[i+2], quads[i+3]);
1647         sp_canvas_item_show(quad_canvasitem);
1648         tc->text_selection_quads.push_back(quad_canvasitem);
1649     }
1650 }
1651
1652 static gint
1653 sp_text_context_timeout(SPTextContext *tc)
1654 {
1655     if (tc->show) {
1656         sp_canvas_item_show(tc->cursor);
1657         if (tc->phase) {
1658             tc->phase = 0;
1659             sp_ctrlline_set_rgba32(SP_CTRLLINE(tc->cursor), 0x000000ff);
1660         } else {
1661             tc->phase = 1;
1662             sp_ctrlline_set_rgba32(SP_CTRLLINE(tc->cursor), 0xffffffff);
1663         }
1664     }
1665
1666     return TRUE;
1667 }
1668
1669 static void
1670 sp_text_context_forget_text(SPTextContext *tc)
1671 {
1672     if (! tc->text) return;
1673     SPItem *ti = tc->text;
1674     (void)ti;
1675     /* We have to set it to zero,
1676      * or selection changed signal messes everything up */
1677     tc->text = NULL;
1678
1679 /* FIXME: this automatic deletion when nothing is inputted crashes the XML edittor and also crashes when duplicating an empty flowtext.
1680     So don't create an empty flowtext in the first place? Create it when first character is typed.
1681     */
1682 /*
1683     if ((SP_IS_TEXT(ti) || SP_IS_FLOWTEXT(ti)) && sp_te_input_is_empty(ti)) {
1684         Inkscape::XML::Node *text_repr=SP_OBJECT_REPR(ti);
1685         // the repr may already have been unparented
1686         // if we were called e.g. as the result of
1687         // an undo or the element being removed from
1688         // the XML editor
1689         if ( text_repr && sp_repr_parent(text_repr) ) {
1690             sp_repr_unparent(text_repr);
1691             sp_document_done(sp_desktop_document(tc->desktop), SP_VERB_CONTEXT_TEXT,
1692                      _("Remove empty text"));
1693         }
1694     }
1695 */
1696 }
1697
1698 gint
1699 sptc_focus_in(GtkWidget */*widget*/, GdkEventFocus */*event*/, SPTextContext *tc)
1700 {
1701     gtk_im_context_focus_in(tc->imc);
1702     return FALSE;
1703 }
1704
1705 gint
1706 sptc_focus_out(GtkWidget */*widget*/, GdkEventFocus */*event*/, SPTextContext *tc)
1707 {
1708     gtk_im_context_focus_out(tc->imc);
1709     return FALSE;
1710 }
1711
1712 static void
1713 sptc_commit(GtkIMContext */*imc*/, gchar *string, SPTextContext *tc)
1714 {
1715     if (!tc->text) {
1716         sp_text_context_setup_text(tc);
1717         tc->nascent_object = 0; // we don't need it anymore, having created a real <text>
1718     }
1719
1720     tc->text_sel_start = tc->text_sel_end = sp_te_replace(tc->text, tc->text_sel_start, tc->text_sel_end, string);
1721     sp_text_context_update_cursor(tc);
1722     sp_text_context_update_text_selection(tc);
1723
1724     sp_document_done(SP_OBJECT_DOCUMENT(tc->text), SP_VERB_CONTEXT_TEXT,
1725                      _("Type text"));
1726 }
1727
1728 void
1729 sp_text_context_place_cursor (SPTextContext *tc, SPObject *text, Inkscape::Text::Layout::iterator where)
1730 {
1731     SP_EVENT_CONTEXT_DESKTOP (tc)->selection->set (text);
1732     tc->text_sel_start = tc->text_sel_end = where;
1733     sp_text_context_update_cursor(tc);
1734     sp_text_context_update_text_selection(tc);
1735 }
1736
1737 void
1738 sp_text_context_place_cursor_at (SPTextContext *tc, SPObject *text, Geom::Point const p)
1739 {
1740     SP_EVENT_CONTEXT_DESKTOP (tc)->selection->set (text);
1741     sp_text_context_place_cursor (tc, text, sp_te_get_position_by_coords(tc->text, p));
1742 }
1743
1744 Inkscape::Text::Layout::iterator *sp_text_context_get_cursor_position(SPTextContext *tc, SPObject *text)
1745 {
1746     if (text != tc->text)
1747         return NULL;
1748     return &(tc->text_sel_end);
1749 }
1750
1751
1752 /*
1753   Local Variables:
1754   mode:c++
1755   c-file-style:"stroustrup"
1756   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1757   indent-tabs-mode:nil
1758   fill-column:99
1759   End:
1760 */
1761 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :