// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * TextTool
 *
 * Authors:
 *   Lauris Kaplinski <lauris@kaplinski.com>
 *   bulia byak <buliabyak@users.sf.net>
 *   Jon A. Cruz <jon@joncruz.org>
 *   Abhishek Sharma
 *
 * Copyright (C) 1999-2005 authors
 * Copyright (C) 2001 Ximian, Inc.
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */

#include <cmath>
#include <gdk/gdkkeysyms.h>
#include <gtkmm/clipboard.h>
#include <glibmm/i18n.h>
#include <glibmm/regex.h>

#include "text-tool.h"

#include "context-fns.h"
#include "desktop-style.h"
#include "desktop.h"
#include "document-undo.h"
#include "document.h"
#include "include/macros.h"
#include "inkscape.h"
#include "message-context.h"
#include "message-stack.h"
#include "rubberband.h"
#include "selection-chemistry.h"
#include "selection.h"
#include "style.h"
#include "text-editing.h"

#include "display/control/canvas-item-curve.h"
#include "display/control/canvas-item-quad.h"
#include "display/control/canvas-item-rect.h"
#include "display/control/canvas-item-bpath.h"
#include "display/curve.h"

#include "livarot/Path.h"
#include "livarot/Shape.h"

#include "object/sp-flowtext.h"
#include "object/sp-namedview.h"
#include "object/sp-text.h"
#include "object/sp-textpath.h"
#include "object/sp-rect.h"
#include "object/sp-shape.h"
#include "object/sp-ellipse.h"

#include "ui/knot/knot-holder.h"
#include "ui/icon-names.h"
#include "ui/shape-editor.h"
#include "ui/widget/canvas.h"
#include "ui/event-debug.h"

#include "xml/attribute-record.h"
#include "xml/sp-css-attr.h"

using Inkscape::DocumentUndo;

namespace Inkscape {
namespace UI {
namespace Tools {

static void sp_text_context_validate_cursor_iterators(TextTool *tc);
static void sp_text_context_update_cursor(TextTool *tc, bool scroll_to_see = true);
static void sp_text_context_update_text_selection(TextTool *tc);
static gint sp_text_context_timeout(TextTool *tc);
static void sp_text_context_forget_text(TextTool *tc);

static gint sptc_focus_in(GtkWidget *widget, GdkEventFocus *event, TextTool *tc);
static gint sptc_focus_out(GtkWidget *widget, GdkEventFocus *event, TextTool *tc);
static void sptc_commit(GtkIMContext *imc, gchar *string, TextTool *tc);

TextTool::TextTool(SPDesktop *desktop)
    : ToolBase(desktop, "/tools/text", "text.svg")
{
    GtkSettings* settings = gtk_settings_get_default();
    gint timeout = 0;
    g_object_get( settings, "gtk-cursor-blink-time", &timeout, nullptr );

    if (timeout < 0) {
        timeout = 200;
    } else {
        timeout /= 2;
    }

    cursor = make_canvasitem<CanvasItemCurve>(desktop->getCanvasControls());
    cursor->set_stroke(0x000000ff);
    cursor->hide();

    // The rectangle box tightly wrapping text object when selected or under cursor.
    indicator = make_canvasitem<CanvasItemRect>(desktop->getCanvasControls());
    indicator->set_stroke(0x0000ff7f);
    indicator->set_shadow(0xffffff7f, 1);
    indicator->hide();

    // The shape that the text is flowing into
    frame = make_canvasitem<CanvasItemBpath>(desktop->getCanvasControls());
    frame->set_fill(0x00 /* zero alpha */, SP_WIND_RULE_NONZERO);
    frame->set_stroke(0x0000ff7f);
    frame->hide();

    // A second frame for showing the padding of the above frame
    padding_frame = make_canvasitem<CanvasItemBpath>(desktop->getCanvasControls());
    padding_frame->set_fill(0x00 /* zero alpha */, SP_WIND_RULE_NONZERO);
    padding_frame->set_stroke(0xccccccdf);
    padding_frame->hide();

    this->timeout = g_timeout_add(timeout, (GSourceFunc) sp_text_context_timeout, this);

    this->imc = gtk_im_multicontext_new();
    if (this->imc) {
        GtkWidget *canvas = GTK_WIDGET(desktop->getCanvas()->gobj());

        /* im preedit handling is very broken in inkscape for
         * multi-byte characters.  See bug 1086769.
         * We need to let the IM handle the preediting, and
         * just take in the characters when they're finished being
         * entered.
         */
        gtk_im_context_set_use_preedit(this->imc, FALSE);
        gtk_im_context_set_client_window(this->imc, 
            gtk_widget_get_window (canvas));

        g_signal_connect(G_OBJECT(canvas), "focus_in_event", G_CALLBACK(sptc_focus_in), this);
        g_signal_connect(G_OBJECT(canvas), "focus_out_event", G_CALLBACK(sptc_focus_out), this);
        g_signal_connect(G_OBJECT(this->imc), "commit", G_CALLBACK(sptc_commit), this);

        if (gtk_widget_has_focus(canvas)) {
            sptc_focus_in(canvas, nullptr, this);
        }
    }

    this->shape_editor = new ShapeEditor(desktop);

    SPItem *item = desktop->getSelection()->singleItem();
    if (item && (is<SPFlowtext>(item) || is<SPText>(item))) {
        this->shape_editor->set_item(item);
    }

    this->sel_changed_connection = _desktop->getSelection()->connectChangedFirst(
        sigc::mem_fun(*this, &TextTool::_selectionChanged)
    );
    this->sel_modified_connection = _desktop->getSelection()->connectModifiedFirst(
        sigc::mem_fun(*this, &TextTool::_selectionModified)
    );
    this->style_set_connection = _desktop->connectSetStyle(
        sigc::mem_fun(*this, &TextTool::_styleSet)
    );
    this->style_query_connection = _desktop->connectQueryStyle(
        sigc::mem_fun(*this, &TextTool::_styleQueried)
    );

    _selectionChanged(desktop->getSelection());

    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
    if (prefs->getBool("/tools/text/selcue")) {
        this->enableSelectionCue();
    }
    if (prefs->getBool("/tools/text/gradientdrag")) {
        this->enableGrDrag();
    }
}

TextTool::~TextTool()
{
    if (_desktop) {
        sp_signal_disconnect_by_data(_desktop->getCanvas()->gobj(), this);
    }

    this->enableGrDrag(false);

    this->style_set_connection.disconnect();
    this->style_query_connection.disconnect();
    this->sel_changed_connection.disconnect();
    this->sel_modified_connection.disconnect();

    sp_text_context_forget_text(SP_TEXT_CONTEXT(this));

    if (this->imc) {
        g_object_unref(G_OBJECT(this->imc));
        this->imc = nullptr;
    }

    if (this->timeout) {
        g_source_remove(this->timeout);
        this->timeout = 0;
    }

    cursor.reset();
    indicator.reset();
    frame.reset();
    padding_frame.reset();
    text_selection_quads.clear();

    delete this->shape_editor;
    this->shape_editor = nullptr;

    ungrabCanvasEvents();

    Inkscape::Rubberband::get(_desktop)->stop();
}

void TextTool::deleteSelected()
{
    Inkscape::UI::Tools::sp_text_delete_selection(_desktop->event_context);
    DocumentUndo::done(_desktop->getDocument(), _("Delete text"), INKSCAPE_ICON("draw-text"));
}

bool TextTool::item_handler(SPItem* item, GdkEvent* event) {
    SPItem *item_ungrouped;

    gint ret = FALSE;
    sp_text_context_validate_cursor_iterators(this);
    Inkscape::Text::Layout::iterator old_start = this->text_sel_start;

    switch (event->type) {
        case GDK_BUTTON_PRESS:
            if (event->button.button == 1) {
                // this var allow too much lees subbselection queries
                // reducing it to cursor iteracion, mouseup and down
                // find out clicked item, disregarding groups
                item_ungrouped = _desktop->getItemAtPoint(Geom::Point(event->button.x, event->button.y), TRUE);
                if (is<SPText>(item_ungrouped) || is<SPFlowtext>(item_ungrouped)) {
                    _desktop->getSelection()->set(item_ungrouped);
                    if (this->text) {
                        // find out click point in document coordinates
                        Geom::Point p = _desktop->w2d(Geom::Point(event->button.x, event->button.y));
                        // set the cursor closest to that point
                        if (event->button.state & GDK_SHIFT_MASK) {
                            this->text_sel_start = old_start;
                            this->text_sel_end = sp_te_get_position_by_coords(this->text, p);
                        } else {
                            this->text_sel_start = this->text_sel_end = sp_te_get_position_by_coords(this->text, p);
                        }
                        // update display
                        sp_text_context_update_cursor(this);
                        sp_text_context_update_text_selection(this);
                        this->dragging = 1;
                    }
                    ret = TRUE;
                }
            }
            break;
        case GDK_2BUTTON_PRESS:
            if (event->button.button == 1 && this->text && this->dragging) {
                Inkscape::Text::Layout const *layout = te_get_layout(this->text);
                if (layout) {
                    if (!layout->isStartOfWord(this->text_sel_start))
                        this->text_sel_start.prevStartOfWord();
                    if (!layout->isEndOfWord(this->text_sel_end))
                        this->text_sel_end.nextEndOfWord();
                    sp_text_context_update_cursor(this);
                    sp_text_context_update_text_selection(this);
                    this->dragging = 2;
                    ret = TRUE;
                }
            }
            break;
        case GDK_3BUTTON_PRESS:
            if (event->button.button == 1 && this->text && this->dragging) {
                this->text_sel_start.thisStartOfLine();
                this->text_sel_end.thisEndOfLine();
                sp_text_context_update_cursor(this);
                sp_text_context_update_text_selection(this);
                this->dragging = 3;
                ret = TRUE;
            }
            break;
        case GDK_BUTTON_RELEASE:
            if (event->button.button == 1 && this->dragging) {
                this->dragging = 0;
                this->discard_delayed_snap_event();
                ret = TRUE;
                _desktop->emit_text_cursor_moved(this, this);
            }
            break;
        case GDK_MOTION_NOTIFY:
            break;
        default:
            break;
    }

    if (!ret) {
        ret = ToolBase::item_handler(item, event);
    }

    return ret;
}

static void sp_text_context_setup_text(TextTool *tc)
{
    SPDesktop *desktop = tc->getDesktop();

    /* Create <text> */
    Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
    Inkscape::XML::Node *rtext = xml_doc->createElement("svg:text");
    rtext->setAttribute("xml:space", "preserve"); // we preserve spaces in the text objects we create

    /* Set style */
    sp_desktop_apply_style_tool(desktop, rtext, "/tools/text", true);

    rtext->setAttributeSvgDouble("x", tc->pdoc[Geom::X]);
    rtext->setAttributeSvgDouble("y", tc->pdoc[Geom::Y]);

    /* Create <tspan> */
    Inkscape::XML::Node *rtspan = xml_doc->createElement("svg:tspan");
    rtspan->setAttribute("sodipodi:role", "line"); // otherwise, why bother creating the tspan?
    rtext->addChild(rtspan, nullptr);
    Inkscape::GC::release(rtspan);

    /* Create TEXT */
    Inkscape::XML::Node *rstring = xml_doc->createTextNode("");
    rtspan->addChild(rstring, nullptr);
    Inkscape::GC::release(rstring);
    auto text_item = cast<SPItem>(tc->currentLayer()->appendChildRepr(rtext));
    /* fixme: Is selection::changed really immediate? */
    /* yes, it's immediate .. why does it matter? */
    desktop->getSelection()->set(text_item);
    Inkscape::GC::release(rtext);
    text_item->transform = tc->currentLayer()->i2doc_affine().inverse();

    text_item->updateRepr();
    text_item->doWriteTransform(text_item->transform, nullptr, true);
    DocumentUndo::done(desktop->getDocument(), _("Create text"), INKSCAPE_ICON("draw-text"));
}

/**
 * Insert the character indicated by tc.uni to replace the current selection,
 * and reset tc.uni/tc.unipos to empty string.
 *
 * \pre tc.uni/tc.unipos non-empty.
 */
static void insert_uni_char(TextTool *const tc)
{
    g_return_if_fail(tc->unipos
                     && tc->unipos < sizeof(tc->uni)
                     && tc->uni[tc->unipos] == '\0');
    unsigned int uv;
    std::stringstream ss;
    ss << std::hex << tc->uni;
    ss >> uv;
    tc->unipos = 0;
    tc->uni[tc->unipos] = '\0';

    if ( !g_unichar_isprint(static_cast<gunichar>(uv))
         && !(g_unichar_validate(static_cast<gunichar>(uv)) && (g_unichar_type(static_cast<gunichar>(uv)) == G_UNICODE_PRIVATE_USE) ) ) {
        // This may be due to bad input, so it goes to statusbar.
        tc->getDesktop()->messageStack()->flash(Inkscape::ERROR_MESSAGE,
                                                _("Non-printable character"));
    } else {
        if (!tc->text) { // printable key; create text if none (i.e. if nascent_object)
            sp_text_context_setup_text(tc);
            tc->nascent_object = false; // we don't need it anymore, having created a real <text>
        }

        gchar u[10];
        guint const len = g_unichar_to_utf8(uv, u);
        u[len] = '\0';

        tc->text_sel_start = tc->text_sel_end = sp_te_replace(tc->text, tc->text_sel_start, tc->text_sel_end, u);
        sp_text_context_update_cursor(tc);
        sp_text_context_update_text_selection(tc);
        DocumentUndo::done(tc->getDesktop()->getDocument(), _("Insert Unicode character"), INKSCAPE_ICON("draw-text"));
    }
}

static void hex_to_printable_utf8_buf(char const *const ehex, char *utf8)
{
    unsigned int uv;
    std::stringstream ss;
    ss << std::hex << ehex;
    ss >> uv;
    if (!g_unichar_isprint((gunichar) uv)) {
        uv = 0xfffd;
    }
    guint const len = g_unichar_to_utf8(uv, utf8);
    utf8[len] = '\0';
}

static void show_curr_uni_char(TextTool *const tc)
{
    g_return_if_fail(tc->unipos < sizeof(tc->uni)
                     && tc->uni[tc->unipos] == '\0');
    if (tc->unipos) {
        char utf8[10];
        hex_to_printable_utf8_buf(tc->uni, utf8);

        /* Status bar messages are in pango markup, so we need xml escaping. */
        if (utf8[1] == '\0') {
            switch(utf8[0]) {
                case '<': strcpy(utf8, "&lt;"); break;
                case '>': strcpy(utf8, "&gt;"); break;
                case '&': strcpy(utf8, "&amp;"); break;
                default: break;
            }
        }
        tc->defaultMessageContext()->setF(Inkscape::NORMAL_MESSAGE,
                                          _("Unicode (<b>Enter</b> to finish): %s: %s"), tc->uni, utf8);
    } else {
        tc->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, _("Unicode (<b>Enter</b> to finish): "));
    }
}

bool TextTool::root_handler(GdkEvent* event) {

#if EVENT_DEBUG
    ui_dump_event(reinterpret_cast<GdkEvent *>(event), "TextTool::root_handler");
#endif

    indicator->hide();

    sp_text_context_validate_cursor_iterators(this);

    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
    tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);

    switch (event->type) {
        case GDK_BUTTON_PRESS:
            if (event->button.button == 1) {
                if (Inkscape::have_viable_layer(_desktop, _desktop->getMessageStack()) == false) {
                    return TRUE;
                }

                // save drag origin
                this->xp = (gint) event->button.x;
                this->yp = (gint) event->button.y;
                this->within_tolerance = true;

                Geom::Point const button_pt(event->button.x, event->button.y);
                Geom::Point button_dt(_desktop->w2d(button_pt));

                SnapManager &m = _desktop->namedview->snap_manager;
                m.setup(_desktop);
                m.freeSnapReturnByRef(button_dt, Inkscape::SNAPSOURCE_NODE_HANDLE);
                m.unSetup();

                this->p0 = button_dt;
                Inkscape::Rubberband::get(_desktop)->start(_desktop, this->p0);

                grabCanvasEvents();

                this->creating = true;

                /* Processed */
                return TRUE;
            }
            break;
        case GDK_MOTION_NOTIFY: {
            if (this->creating && (event->motion.state & GDK_BUTTON1_MASK)) {
                if ( this->within_tolerance
                     && ( abs( (gint) event->motion.x - this->xp ) < this->tolerance )
                     && ( abs( (gint) event->motion.y - this->yp ) < this->tolerance ) ) {
                    break; // do not drag if we're within tolerance from origin
                }
                // Once the user has moved farther than tolerance from the original location
                // (indicating they intend to draw, not click), then always process the
                // motion notify coordinates as given (no snapping back to origin)
                this->within_tolerance = false;

                Geom::Point const motion_pt(event->motion.x, event->motion.y);
                Geom::Point p = _desktop->w2d(motion_pt);

                SnapManager &m = _desktop->namedview->snap_manager;
                m.setup(_desktop);
                m.freeSnapReturnByRef(p, Inkscape::SNAPSOURCE_NODE_HANDLE);
                m.unSetup();

                Inkscape::Rubberband::get(_desktop)->move(p);
                gobble_motion_events(GDK_BUTTON1_MASK);

                // status text
                Inkscape::Util::Quantity x_q = Inkscape::Util::Quantity(fabs((p - this->p0)[Geom::X]), "px");
                Inkscape::Util::Quantity y_q = Inkscape::Util::Quantity(fabs((p - this->p0)[Geom::Y]), "px");
                Glib::ustring xs = x_q.string(_desktop->namedview->display_units);
                Glib::ustring ys = y_q.string(_desktop->namedview->display_units);
                this->message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Flowed text frame</b>: %s &#215; %s"), xs.c_str(), ys.c_str());
            } else if (!this->sp_event_context_knot_mouseover()) {
                SnapManager &m = _desktop->namedview->snap_manager;
                m.setup(_desktop);

                Geom::Point const motion_w(event->motion.x, event->motion.y);
                Geom::Point motion_dt(_desktop->w2d(motion_w));
                m.preSnap(Inkscape::SnapCandidatePoint(motion_dt, Inkscape::SNAPSOURCE_OTHER_HANDLE));
                m.unSetup();
            }
            if ((event->motion.state & GDK_BUTTON1_MASK) && this->dragging) {
                Inkscape::Text::Layout const *layout = te_get_layout(this->text);
                if (!layout)
                    break;
                // find out click point in document coordinates
                Geom::Point p = _desktop->w2d(Geom::Point(event->button.x, event->button.y));
                // set the cursor closest to that point
                Inkscape::Text::Layout::iterator new_end = sp_te_get_position_by_coords(this->text, p);
                if (this->dragging == 2) {
                    // double-click dragging: go by word
                    if (new_end < this->text_sel_start) {
                        if (!layout->isStartOfWord(new_end))
                            new_end.prevStartOfWord();
                    } else if (!layout->isEndOfWord(new_end))
                        new_end.nextEndOfWord();
                } else if (this->dragging == 3) {
                    // triple-click dragging: go by line
                    if (new_end < this->text_sel_start)
                        new_end.thisStartOfLine();
                    else
                        new_end.thisEndOfLine();
                }
                // update display
                if (this->text_sel_end != new_end) {
                    this->text_sel_end = new_end;
                    sp_text_context_update_cursor(this);
                    sp_text_context_update_text_selection(this);
                }
                gobble_motion_events(GDK_BUTTON1_MASK);
                break;
            }
            // find out item under mouse, disregarding groups
            SPItem *item_ungrouped =
                _desktop->getItemAtPoint(Geom::Point(event->button.x, event->button.y), TRUE, nullptr);
            if (is<SPText>(item_ungrouped) || is<SPFlowtext>(item_ungrouped)) {
                Inkscape::Text::Layout const *layout = te_get_layout(item_ungrouped);
                if (layout->inputTruncated()) {
                    indicator->set_stroke(0xff0000ff);
                } else {
                    indicator->set_stroke(0x0000ff7f);
                }
                Geom::OptRect ibbox = item_ungrouped->desktopVisualBounds();
                if (ibbox) {
                    indicator->set_rect(*ibbox);
                }
                indicator->show();

                this->set_cursor("text-insert.svg");
                sp_text_context_update_text_selection(this);
                if (is<SPText>(item_ungrouped)) {
                    _desktop->event_context->defaultMessageContext()->set(
                        Inkscape::NORMAL_MESSAGE,
                        _("<b>Click</b> to edit the text, <b>drag</b> to select part of the text."));
                } else {
                    _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."));
                }
                this->over_text = true;
            } else {
                // update cursor and statusbar: we are not over a text object now
                this->set_cursor("text.svg");
                _desktop->event_context->defaultMessageContext()->clear();
                this->over_text = false;
            }
        } break;

        case GDK_BUTTON_RELEASE:
            if (event->button.button == 1) {
                this->discard_delayed_snap_event();

                Geom::Point p1 = _desktop->w2d(Geom::Point(event->button.x, event->button.y));

                SnapManager &m = _desktop->namedview->snap_manager;
                m.setup(_desktop);
                m.freeSnapReturnByRef(p1, Inkscape::SNAPSOURCE_NODE_HANDLE);
                m.unSetup();

                ungrabCanvasEvents();

                Inkscape::Rubberband::get(_desktop)->stop();

                if (this->creating && this->within_tolerance) {
                    /* Button 1, set X & Y & new item */
                    _desktop->getSelection()->clear();
                    this->pdoc = _desktop->dt2doc(p1);
                    this->show = TRUE;
                    this->phase = true;
                    this->nascent_object = true; // new object was just created

                    /* Cursor */
                    cursor->show();
                    // Cursor height is defined by the new text object's font size; it needs to be set
                    // artificially here, for the text object does not exist yet:
                    double cursor_height = sp_desktop_get_font_size_tool(_desktop);
                    auto const y_dir = _desktop->yaxisdir();
                    Geom::Point const cursor_size(0, y_dir * cursor_height);
                    cursor->set_coords(p1, p1 - cursor_size);
                    if (this->imc) {
                        GdkRectangle im_cursor;
                        Geom::Point const top_left = _desktop->get_display_area().corner(0);
                        Geom::Point const im_d0 = _desktop->d2w(p1 - top_left);
                        Geom::Point const im_d1 = _desktop->d2w(p1 - cursor_size - top_left);
                        Geom::Rect const im_rect(im_d0, im_d1);
                        im_cursor.x = (int) floor(im_rect.left());
                        im_cursor.y = (int) floor(im_rect.top());
                        im_cursor.width = (int) floor(im_rect.width());
                        im_cursor.height = (int) floor(im_rect.height());
                        gtk_im_context_set_cursor_location(this->imc, &im_cursor);
                    }
                    this->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

                    this->within_tolerance = false;
                } else if (this->creating) {
                    double cursor_height = sp_desktop_get_font_size_tool(_desktop);
                    if (fabs(p1[Geom::Y] - this->p0[Geom::Y]) > cursor_height) {
                        // otherwise even one line won't fit; most probably a slip of hand (even if bigger than tolerance)

                        if (prefs->getBool("/tools/text/use_svg2", true)) {
                            // SVG 2 text

                            SPItem *text = create_text_with_rectangle (_desktop, this->p0, p1);

                            _desktop->getSelection()->set(text);

                        } else {
                            // SVG 1.2 text

                            SPItem *ft = create_flowtext_with_internal_frame (_desktop, this->p0, p1);

                            _desktop->getSelection()->set(ft);
                        }

                        _desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Flowed text is created."));
                        DocumentUndo::done(_desktop->getDocument(),  _("Create flowed text"), INKSCAPE_ICON("draw-text"));

                    } else {
                        _desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("The frame is <b>too small</b> for the current font size. Flowed text not created."));
                    }
                }
                this->creating = false;
                _desktop->emit_text_cursor_moved(this, this);
                return TRUE;
            }
            break;
        case GDK_KEY_PRESS: {
            guint const group0_keyval = get_latin_keyval(&event->key);

            if (group0_keyval == GDK_KEY_KP_Add ||
                group0_keyval == GDK_KEY_KP_Subtract) {
                if (!(event->key.state & GDK_MOD2_MASK)) // mod2 is NumLock; if on, type +/- keys
                    break; // otherwise pass on keypad +/- so they can zoom
            }

            if ((this->text) || (this->nascent_object)) {
                // there is an active text object in this context, or a new object was just created

                // Input methods often use Ctrl+Shift+U for preediting (unimode).
                // Override it so we can use our unimode.
                bool preedit_activation = (MOD__CTRL(event) && MOD__SHIFT(event) && !MOD__ALT(event))
                                          && (group0_keyval == GDK_KEY_U || group0_keyval == GDK_KEY_u);

                if (this->unimode || !this->imc || preedit_activation
                    || !gtk_im_context_filter_keypress(this->imc, (GdkEventKey*) event)) {
                    // IM did not consume the key, or we're in unimode

                    if (!MOD__CTRL_ONLY(event) && this->unimode) {
                            /* TODO: ISO 14755 (section 3 Definitions) says that we should also
                               accept the first 6 characters of alphabets other than the latin
                               alphabet "if the Latin alphabet is not used".  The below is also
                               reasonable (viz. hope that the user's keyboard includes latin
                               characters and force latin interpretation -- just as we do for our
                               keyboard shortcuts), but differs from the ISO 14755
                               recommendation. */
                            switch (group0_keyval) {
                                case GDK_KEY_space:
                                case GDK_KEY_KP_Space: {
                                    if (this->unipos) {
                                        insert_uni_char(this);
                                    }
                                    /* Stay in unimode. */
                                    show_curr_uni_char(this);
                                    return TRUE;
                                }

                                case GDK_KEY_BackSpace: {
                                    g_return_val_if_fail(this->unipos < sizeof(this->uni), TRUE);
                                    if (this->unipos) {
                                        this->uni[--this->unipos] = '\0';
                                    }
                                    show_curr_uni_char(this);
                                    return TRUE;
                                }

                                case GDK_KEY_Return:
                                case GDK_KEY_KP_Enter: {
                                    if (this->unipos) {
                                        insert_uni_char(this);
                                    }
                                    /* Exit unimode. */
                                    this->unimode = false;
                                    this->defaultMessageContext()->clear();
                                    return TRUE;
                                }

                                case GDK_KEY_Escape: {
                                    // Cancel unimode.
                                    this->unimode = false;
                                    gtk_im_context_reset(this->imc);
                                    this->defaultMessageContext()->clear();
                                    return TRUE;
                                }

                                case GDK_KEY_Shift_L:
                                case GDK_KEY_Shift_R:
                                    break;

                                default: {
                                    guint32 xdigit = gdk_keyval_to_unicode(group0_keyval);
                                    if (xdigit <= 255 && g_ascii_isxdigit(xdigit)) {
                                        g_return_val_if_fail(this->unipos < sizeof(this->uni) - 1, TRUE);
                                        this->uni[this->unipos++] = xdigit;
                                        this->uni[this->unipos] = '\0';
                                        if (this->unipos == 8) {
                                            /* This behaviour is partly to allow us to continue to
                                               use a fixed-length buffer for tc->uni.  Reason for
                                               choosing the number 8 is that it's the length of
                                               ``canonical form'' mentioned in the ISO 14755 spec.
                                               An advantage over choosing 6 is that it allows using
                                               backspace for typos & misremembering when entering a
                                               6-digit number. */
                                            insert_uni_char(this);
                                        }
                                        show_curr_uni_char(this);
                                        return TRUE;
                                    } else {
                                        /* The intent is to ignore but consume characters that could be
                                           typos for hex digits.  Gtk seems to ignore & consume all
                                           non-hex-digits, and we do similar here.  Though note that some
                                           shortcuts (like keypad +/- for zoom) get processed before
                                           reaching this code. */
                                        return TRUE;
                                    }
                                }
                            }
                        }

                        Inkscape::Text::Layout::iterator old_start = this->text_sel_start;
                        Inkscape::Text::Layout::iterator old_end = this->text_sel_end;
                        bool cursor_moved = false;
                        int screenlines = 1;
                        if (this->text) {
                            double spacing = sp_te_get_average_linespacing(this->text);
                            Geom::Rect const d = _desktop->get_display_area().bounds();
                            screenlines = (int) floor(fabs(d.min()[Geom::Y] - d.max()[Geom::Y])/spacing) - 1;
                            if (screenlines <= 0)
                                screenlines = 1;
                        }

                        /* Neither unimode nor IM consumed key; process text tool shortcuts */
                        switch (group0_keyval) {
                            case GDK_KEY_x:
                            case GDK_KEY_X:
                                if (MOD__ALT_ONLY(event)) {
                                    _desktop->setToolboxFocusTo("TextFontFamilyAction_entry");
                                    return TRUE;
                                }
                                break;
                            case GDK_KEY_space:
                                if (MOD__CTRL_ONLY(event)) {
                                    /* No-break space */
                                    if (!this->text) { // printable key; create text if none (i.e. if nascent_object)
                                        sp_text_context_setup_text(this);
                                        this->nascent_object = false; // we don't need it anymore, having created a real <text>
                                    }
                                    this->text_sel_start = this->text_sel_end = sp_te_replace(this->text, this->text_sel_start, this->text_sel_end, "\302\240");
                                    sp_text_context_update_cursor(this);
                                    sp_text_context_update_text_selection(this);
                                    _desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("No-break space"));
                                    DocumentUndo::done(_desktop->getDocument(),  _("Insert no-break space"), INKSCAPE_ICON("draw-text"));
                                    return TRUE;
                                }
                                break;
                            case GDK_KEY_U:
                            case GDK_KEY_u:
                                if (MOD__CTRL_ONLY(event) || (MOD__CTRL(event) && MOD__SHIFT(event))) {
                                    if (this->unimode) {
                                        this->unimode = false;
                                        this->defaultMessageContext()->clear();
                                    } else {
                                        this->unimode = true;
                                        this->unipos = 0;
                                        this->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, _("Unicode (<b>Enter</b> to finish): "));
                                    }
                                    if (this->imc) {
                                        gtk_im_context_reset(this->imc);
                                    }
                                    return TRUE;
                                }
                                break;
                            case GDK_KEY_B:
                            case GDK_KEY_b:
                                if (MOD__CTRL_ONLY(event) && this->text) {
                                    SPStyle const *style = sp_te_style_at_position(this->text, std::min(this->text_sel_start, this->text_sel_end));
                                    SPCSSAttr *css = sp_repr_css_attr_new();
                                    if (style->font_weight.computed == SP_CSS_FONT_WEIGHT_NORMAL
                                        || style->font_weight.computed == SP_CSS_FONT_WEIGHT_100
                                        || style->font_weight.computed == SP_CSS_FONT_WEIGHT_200
                                        || style->font_weight.computed == SP_CSS_FONT_WEIGHT_300
                                        || style->font_weight.computed == SP_CSS_FONT_WEIGHT_400)
                                        sp_repr_css_set_property(css, "font-weight", "bold");
                                    else
                                        sp_repr_css_set_property(css, "font-weight", "normal");
                                    sp_te_apply_style(this->text, this->text_sel_start, this->text_sel_end, css);
                                    sp_repr_css_attr_unref(css);
                                    DocumentUndo::done(_desktop->getDocument(),  _("Make bold"), INKSCAPE_ICON("draw-text"));
                                    sp_text_context_update_cursor(this);
                                    sp_text_context_update_text_selection(this);
                                    return TRUE;
                                }
                                break;
                            case GDK_KEY_I:
                            case GDK_KEY_i:
                                if (MOD__CTRL_ONLY(event) && this->text) {
                                    SPStyle const *style = sp_te_style_at_position(this->text, std::min(this->text_sel_start, this->text_sel_end));
                                    SPCSSAttr *css = sp_repr_css_attr_new();
                                    if (style->font_style.computed != SP_CSS_FONT_STYLE_NORMAL)
                                        sp_repr_css_set_property(css, "font-style", "normal");
                                    else
                                        sp_repr_css_set_property(css, "font-style", "italic");
                                    sp_te_apply_style(this->text, this->text_sel_start, this->text_sel_end, css);
                                    sp_repr_css_attr_unref(css);
                                    DocumentUndo::done(_desktop->getDocument(),  _("Make italic"), INKSCAPE_ICON("draw-text"));
                                    sp_text_context_update_cursor(this);
                                    sp_text_context_update_text_selection(this);
                                    return TRUE;
                                }
                                break;

                            case GDK_KEY_A:
                            case GDK_KEY_a:
                                if (MOD__CTRL_ONLY(event) && this->text) {
                                    Inkscape::Text::Layout const *layout = te_get_layout(this->text);
                                    if (layout) {
                                        this->text_sel_start = layout->begin();
                                        this->text_sel_end = layout->end();
                                        sp_text_context_update_cursor(this);
                                        sp_text_context_update_text_selection(this);
                                        return TRUE;
                                    }
                                }
                                break;

                            case GDK_KEY_Return:
                            case GDK_KEY_KP_Enter:
                            {
                                if (!this->text) { // printable key; create text if none (i.e. if nascent_object)
                                    sp_text_context_setup_text(this);
                                    this->nascent_object = false; // we don't need it anymore, having created a real <text>
                                }

                                auto text_element = cast<SPText>(text);
                                if (text_element && (text_element->has_shape_inside() || text_element->has_inline_size())) {
                                    // Handle new line like any other character.
                                    this->text_sel_start = this->text_sel_end = sp_te_insert(this->text, this->text_sel_start, "\n");
                                } else {
                                    // Replace new line by either <tspan sodipodi:role="line" or <flowPara>.
                                    iterator_pair enter_pair;
                                    bool success = sp_te_delete(this->text, this->text_sel_start, this->text_sel_end, enter_pair);
                                    (void)success; // TODO cleanup
                                    this->text_sel_start = this->text_sel_end = enter_pair.first;
                                    this->text_sel_start = this->text_sel_end = sp_te_insert_line(this->text, this->text_sel_start);
                                }

                                sp_text_context_update_cursor(this);
                                sp_text_context_update_text_selection(this);
                                DocumentUndo::done(_desktop->getDocument(),  _("New line"), INKSCAPE_ICON("draw-text"));
                                return TRUE;
                            }
                            case GDK_KEY_BackSpace:
                                if (this->text) { // if nascent_object, do nothing, but return TRUE; same for all other delete and move keys

                                    bool noSelection = false;

                                    if (MOD__CTRL(event)) {
                                        this->text_sel_start = this->text_sel_end;
                                    }

                                    if (this->text_sel_start == this->text_sel_end) {
                                        if (MOD__CTRL(event)) {
                                            this->text_sel_start.prevStartOfWord();
                                        } else {
                                            this->text_sel_start.prevCursorPosition();
                                        }
                                        noSelection = true;
                                    }

                                    iterator_pair bspace_pair;
                                    bool success = sp_te_delete(this->text, this->text_sel_start, this->text_sel_end, bspace_pair);

                                    if (noSelection) {
                                        if (success) {
                                            this->text_sel_start = this->text_sel_end = bspace_pair.first;
                                        } else { // nothing deleted
                                            this->text_sel_start = this->text_sel_end = bspace_pair.second;
                                        }
                                    } else {
                                        if (success) {
                                            this->text_sel_start = this->text_sel_end = bspace_pair.first;
                                        } else { // nothing deleted
                                            this->text_sel_start = bspace_pair.first;
                                            this->text_sel_end = bspace_pair.second;
                                        }
                                    }

                                    sp_text_context_update_cursor(this);
                                    sp_text_context_update_text_selection(this);
                                    DocumentUndo::done(_desktop->getDocument(),  _("Backspace"), INKSCAPE_ICON("draw-text"));
                                }
                                return TRUE;
                            case GDK_KEY_Delete:
                            case GDK_KEY_KP_Delete:
                                if (this->text) {
                                    bool noSelection = false;

                                    if (MOD__CTRL(event)) {
                                        this->text_sel_start = this->text_sel_end;
                                    }

                                    if (this->text_sel_start == this->text_sel_end) {
                                        if (MOD__CTRL(event)) {
                                            this->text_sel_end.nextEndOfWord();
                                        } else {
                                            this->text_sel_end.nextCursorPosition();
                                        }
                                        noSelection = true;
                                    }

                                    iterator_pair del_pair;
                                    bool success = sp_te_delete(this->text, this->text_sel_start, this->text_sel_end, del_pair);

                                    if (noSelection) {
                                        this->text_sel_start = this->text_sel_end = del_pair.first;
                                    } else {
                                        if (success) {
                                            this->text_sel_start = this->text_sel_end = del_pair.first;
                                        } else { // nothing deleted
                                            this->text_sel_start = del_pair.first;
                                            this->text_sel_end = del_pair.second;
                                        }
                                    }


                                    sp_text_context_update_cursor(this);
                                    sp_text_context_update_text_selection(this);
                                    DocumentUndo::done(_desktop->getDocument(),  _("Delete"), INKSCAPE_ICON("draw-text"));
                                }
                                return TRUE;
                            case GDK_KEY_Left:
                            case GDK_KEY_KP_Left:
                            case GDK_KEY_KP_4:
                                if (this->text) {
                                    if (MOD__ALT(event)) {
                                        gint mul = 1 + gobble_key_events(
                                            get_latin_keyval(&event->key), 0); // with any mask
                                        if (MOD__SHIFT(event))
                                            sp_te_adjust_kerning_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, Geom::Point(mul*-10, 0));
                                        else
                                            sp_te_adjust_kerning_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, Geom::Point(mul*-1, 0));
                                        sp_text_context_update_cursor(this);
                                        sp_text_context_update_text_selection(this);
                                        DocumentUndo::maybeDone(_desktop->getDocument(), "kern:left",  _("Kern to the left"), INKSCAPE_ICON("draw-text"));
                                    } else {
                                        if (MOD__CTRL(event))
                                            this->text_sel_end.cursorLeftWithControl();
                                        else
                                            this->text_sel_end.cursorLeft();
                                        cursor_moved = true;
                                        break;
                                    }
                                }
                                return TRUE;
                            case GDK_KEY_Right:
                            case GDK_KEY_KP_Right:
                            case GDK_KEY_KP_6:
                                if (this->text) {
                                    if (MOD__ALT(event)) {
                                        gint mul = 1 + gobble_key_events(
                                            get_latin_keyval(&event->key), 0); // with any mask
                                        if (MOD__SHIFT(event))
                                            sp_te_adjust_kerning_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, Geom::Point(mul*10, 0));
                                        else
                                            sp_te_adjust_kerning_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, Geom::Point(mul*1, 0));
                                        sp_text_context_update_cursor(this);
                                        sp_text_context_update_text_selection(this);
                                        DocumentUndo::maybeDone(_desktop->getDocument(), "kern:right",  _("Kern to the right"), INKSCAPE_ICON("draw-text"));
                                    } else {
                                        if (MOD__CTRL(event))
                                            this->text_sel_end.cursorRightWithControl();
                                        else
                                            this->text_sel_end.cursorRight();
                                        cursor_moved = true;
                                        break;
                                    }
                                }
                                return TRUE;
                            case GDK_KEY_Up:
                            case GDK_KEY_KP_Up:
                            case GDK_KEY_KP_8:
                                if (this->text) {
                                    if (MOD__ALT(event)) {
                                        gint mul = 1 + gobble_key_events(
                                            get_latin_keyval(&event->key), 0); // with any mask
                                        if (MOD__SHIFT(event))
                                            sp_te_adjust_kerning_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, Geom::Point(0, mul*-10));
                                        else
                                            sp_te_adjust_kerning_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, Geom::Point(0, mul*-1));
                                        sp_text_context_update_cursor(this);
                                        sp_text_context_update_text_selection(this);
                                        DocumentUndo::maybeDone(_desktop->getDocument(), "kern:up",  _("Kern up"), INKSCAPE_ICON("draw-text"));
                                    } else {
                                        if (MOD__CTRL(event))
                                            this->text_sel_end.cursorUpWithControl();
                                        else
                                            this->text_sel_end.cursorUp();
                                        cursor_moved = true;
                                        break;
                                    }
                                }
                                return TRUE;
                            case GDK_KEY_Down:
                            case GDK_KEY_KP_Down:
                            case GDK_KEY_KP_2:
                                if (this->text) {
                                    if (MOD__ALT(event)) {
                                        gint mul = 1 + gobble_key_events(
                                            get_latin_keyval(&event->key), 0); // with any mask
                                        if (MOD__SHIFT(event))
                                            sp_te_adjust_kerning_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, Geom::Point(0, mul*10));
                                        else
                                            sp_te_adjust_kerning_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, Geom::Point(0, mul*1));
                                        sp_text_context_update_cursor(this);
                                        sp_text_context_update_text_selection(this);
                                        DocumentUndo::maybeDone(_desktop->getDocument(), "kern:down",  _("Kern down"), INKSCAPE_ICON("draw-text"));
                                    } else {
                                        if (MOD__CTRL(event))
                                            this->text_sel_end.cursorDownWithControl();
                                        else
                                            this->text_sel_end.cursorDown();
                                        cursor_moved = true;
                                        break;
                                    }
                                }
                                return TRUE;
                            case GDK_KEY_Home:
                            case GDK_KEY_KP_Home:
                                if (this->text) {
                                    if (MOD__CTRL(event))
                                        this->text_sel_end.thisStartOfShape();
                                    else
                                        this->text_sel_end.thisStartOfLine();
                                    cursor_moved = true;
                                    break;
                                }
                                return TRUE;
                            case GDK_KEY_End:
                            case GDK_KEY_KP_End:
                                if (this->text) {
                                    if (MOD__CTRL(event))
                                        this->text_sel_end.nextStartOfShape();
                                    else
                                        this->text_sel_end.thisEndOfLine();
                                    cursor_moved = true;
                                    break;
                                }
                                return TRUE;
                            case GDK_KEY_Page_Down:
                            case GDK_KEY_KP_Page_Down:
                                if (this->text) {
                                    this->text_sel_end.cursorDown(screenlines);
                                    cursor_moved = true;
                                    break;
                                }
                                return TRUE;
                            case GDK_KEY_Page_Up:
                            case GDK_KEY_KP_Page_Up:
                                if (this->text) {
                                    this->text_sel_end.cursorUp(screenlines);
                                    cursor_moved = true;
                                    break;
                                }
                                return TRUE;
                            case GDK_KEY_Escape:
                                if (this->creating) {
                                    this->creating = false;
                                    ungrabCanvasEvents();
                                    Inkscape::Rubberband::get(_desktop)->stop();
                                } else {
                                    _desktop->getSelection()->clear();
                                }
                                this->nascent_object = FALSE;
                                return TRUE;
                            case GDK_KEY_bracketleft:
                                if (this->text) {
                                    if (MOD__ALT(event) || MOD__CTRL(event)) {
                                        if (MOD__ALT(event)) {
                                            if (MOD__SHIFT(event)) {
                                                // FIXME: alt+shift+[] does not work, don't know why
                                                sp_te_adjust_rotation_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, -10);
                                            } else {
                                                sp_te_adjust_rotation_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, -1);
                                            }
                                        } else {
                                            sp_te_adjust_rotation(this->text, this->text_sel_start, this->text_sel_end, _desktop, -90);
                                        }
                                        DocumentUndo::maybeDone(_desktop->getDocument(), "textrot:ccw",  _("Rotate counterclockwise"), INKSCAPE_ICON("draw-text"));
                                        sp_text_context_update_cursor(this);
                                        sp_text_context_update_text_selection(this);
                                        return TRUE;
                                    }
                                }
                                break;
                            case GDK_KEY_bracketright:
                                if (this->text) {
                                    if (MOD__ALT(event) || MOD__CTRL(event)) {
                                        if (MOD__ALT(event)) {
                                            if (MOD__SHIFT(event)) {
                                                // FIXME: alt+shift+[] does not work, don't know why
                                                sp_te_adjust_rotation_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, 10);
                                            } else {
                                                sp_te_adjust_rotation_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, 1);
                                            }
                                        } else {
                                            sp_te_adjust_rotation(this->text, this->text_sel_start, this->text_sel_end, _desktop, 90);
                                        }
                                        DocumentUndo::maybeDone(_desktop->getDocument(), "textrot:cw",  _("Rotate clockwise"), INKSCAPE_ICON("draw-text"));
                                        sp_text_context_update_cursor(this);
                                        sp_text_context_update_text_selection(this);
                                        return TRUE;
                                    }
                                }
                                break;
                            case GDK_KEY_less:
                            case GDK_KEY_comma:
                                if (this->text) {
                                    if (MOD__ALT(event)) {
                                        if (MOD__CTRL(event)) {
                                            if (MOD__SHIFT(event))
                                                sp_te_adjust_linespacing_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, -10);
                                            else
                                                sp_te_adjust_linespacing_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, -1);
                                            DocumentUndo::maybeDone(_desktop->getDocument(), "linespacing:dec",  _("Contract line spacing"), INKSCAPE_ICON("draw-text"));
                                        } else {
                                            if (MOD__SHIFT(event))
                                                sp_te_adjust_tspan_letterspacing_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, -10);
                                            else
                                                sp_te_adjust_tspan_letterspacing_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, -1);
                                            DocumentUndo::maybeDone(_desktop->getDocument(), "letterspacing:dec",  _("Contract letter spacing"), INKSCAPE_ICON("draw-text"));
                                        }
                                        sp_text_context_update_cursor(this);
                                        sp_text_context_update_text_selection(this);
                                        return TRUE;
                                    }
                                }
                                break;
                            case GDK_KEY_greater:
                            case GDK_KEY_period:
                                if (this->text) {
                                    if (MOD__ALT(event)) {
                                        if (MOD__CTRL(event)) {
                                            if (MOD__SHIFT(event))
                                                sp_te_adjust_linespacing_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, 10);
                                            else
                                                sp_te_adjust_linespacing_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, 1);
                                            DocumentUndo::maybeDone(_desktop->getDocument(), "linespacing:inc",  _("Expand line spacing"), INKSCAPE_ICON("draw-text"));
                                        } else {
                                            if (MOD__SHIFT(event))
                                                sp_te_adjust_tspan_letterspacing_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, 10);
                                            else
                                                sp_te_adjust_tspan_letterspacing_screen(this->text, this->text_sel_start, this->text_sel_end, _desktop, 1);
                                            DocumentUndo::maybeDone(_desktop->getDocument(), "letterspacing:inc",  _("Expand letter spacing"), INKSCAPE_ICON("draw-text"));
                                        }
                                        sp_text_context_update_cursor(this);
                                        sp_text_context_update_text_selection(this);
                                        return TRUE;
                                    }
                                }
                                break;
                            default:
                                break;
                        }

                        if (cursor_moved) {
                            if (!MOD__SHIFT(event))
                                this->text_sel_start = this->text_sel_end;
                            if (old_start != this->text_sel_start || old_end != this->text_sel_end) {
                                sp_text_context_update_cursor(this);
                                sp_text_context_update_text_selection(this);
                            }
                            return TRUE;
                        }

                } else return TRUE; // return the "I took care of it" value if it was consumed by the IM
            } else { // do nothing if there's no object to type in - the key will be sent to parent context,
                // except up/down that are swallowed to prevent the zoom field from activation
                if ((group0_keyval == GDK_KEY_Up    ||
                     group0_keyval == GDK_KEY_Down  ||
                     group0_keyval == GDK_KEY_KP_Up ||
                     group0_keyval == GDK_KEY_KP_Down )
                    && !MOD__CTRL_ONLY(event)) {
                    return TRUE;
                } else if (group0_keyval == GDK_KEY_Escape) { // cancel rubberband
                    if (this->creating) {
                        this->creating = false;
                        ungrabCanvasEvents();
                        Inkscape::Rubberband::get(_desktop)->stop();
                    }
                } else if ((group0_keyval == GDK_KEY_x || group0_keyval == GDK_KEY_X) && MOD__ALT_ONLY(event)) {
                    _desktop->setToolboxFocusTo("TextFontFamilyAction_entry");
                    return TRUE;
                }
            }
            break;
        }

        case GDK_KEY_RELEASE:
            if (!this->unimode && this->imc && gtk_im_context_filter_keypress(this->imc, (GdkEventKey*) event)) {
                return TRUE;
            }
            break;
        default:
            break;
    }

    // if nobody consumed it so far
//    if ((SP_EVENT_CONTEXT_CLASS(sp_text_context_parent_class))->root_handler) { // and there's a handler in parent context,
//        return (SP_EVENT_CONTEXT_CLASS(sp_text_context_parent_class))->root_handler(event_context, event); // send event to parent
//    } else {
//        return FALSE; // return "I did nothing" value so that global shortcuts can be activated
//    }
    return ToolBase::root_handler(event);

}

/**
 Attempts to paste system clipboard into the currently edited text, returns true on success
 */
bool sp_text_paste_inline(ToolBase *ec)
{
    if (!SP_IS_TEXT_CONTEXT(ec))
        return false;
    TextTool *tc = SP_TEXT_CONTEXT(ec);

    if ((tc->text) || (tc->nascent_object)) {
        // there is an active text object in this context, or a new object was just created

        Glib::RefPtr<Gtk::Clipboard> refClipboard = Gtk::Clipboard::get();
        Glib::ustring const clip_text = refClipboard->wait_for_text();

        if (!clip_text.empty()) {

            bool is_svg2 = false;
            auto textitem = cast<SPText>(tc->text);
            if (textitem) {
                is_svg2 = textitem->has_shape_inside() /*|| textitem->has_inline_size()*/; // Do now since hiding messes this up.
                textitem->hide_shape_inside();
            }

            auto flowtext = cast<SPFlowtext>(tc->text);
            if (flowtext) {
                flowtext->fix_overflow_flowregion(false);
            }

            // Fix for 244940
            // The XML standard defines the following as valid characters
            // (Extensible Markup Language (XML) 1.0 (Fourth Edition) paragraph 2.2)
            // char ::=     #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
            // Since what comes in off the paste buffer will go right into XML, clean
            // the text here.
            Glib::ustring text(clip_text);
            Glib::ustring::iterator itr = text.begin();
            gunichar paste_string_uchar;

            while(itr != text.end())
            {
                paste_string_uchar = *itr;

                // Make sure we don't have a control character. We should really check
                // for the whole range above... Add the rest of the invalid cases from
                // above if we find additional issues
                if(paste_string_uchar >= 0x00000020 ||
                   paste_string_uchar == 0x00000009 ||
                   paste_string_uchar == 0x0000000A ||
                   paste_string_uchar == 0x0000000D) {
                    ++itr;
                } else {
                    itr = text.erase(itr);
                }
            }

            if (!tc->text) { // create text if none (i.e. if nascent_object)
                sp_text_context_setup_text(tc);
                tc->nascent_object = false; // we don't need it anymore, having created a real <text>
            }

            // using indices is slow in ustrings. Whatever.
            Glib::ustring::size_type begin = 0;
            for ( ; ; ) {
                Glib::ustring::size_type end = text.find('\n', begin);

                if (end == Glib::ustring::npos || is_svg2) {
                    // Paste everything
                    if (begin != text.length())
                        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());
                    break;
                }

                // Paste up to new line, add line, repeat.
                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());
                tc->text_sel_start = tc->text_sel_end = sp_te_insert_line(tc->text, tc->text_sel_start);
                begin = end + 1;
            }
            if (textitem) {
                textitem->show_shape_inside();
            }
            if (flowtext) {
                flowtext->fix_overflow_flowregion(true);
            }
            DocumentUndo::done(ec->getDesktop()->getDocument(), _("Paste text"), INKSCAPE_ICON("draw-text"));

            return true;
        }
        
    } // FIXME: else create and select a new object under cursor!

    return false;
}

/**
 Gets the raw characters that comprise the currently selected text, converting line
 breaks into lf characters.
*/
Glib::ustring sp_text_get_selected_text(ToolBase const *ec)
{
    if (!SP_IS_TEXT_CONTEXT(ec))
        return "";
    TextTool const *tc = SP_TEXT_CONTEXT(ec);
    if (tc->text == nullptr)
        return "";

    return sp_te_get_string_multiline(tc->text, tc->text_sel_start, tc->text_sel_end);
}

SPCSSAttr *sp_text_get_style_at_cursor(ToolBase const *ec)
{
    if (!SP_IS_TEXT_CONTEXT(ec))
        return nullptr;
    TextTool const *tc = SP_TEXT_CONTEXT(ec);
    if (tc->text == nullptr)
        return nullptr;

    SPObject const *obj = sp_te_object_at_position(tc->text, tc->text_sel_end);

    if (obj) {
        return take_style_from_item(const_cast<SPObject*>(obj));
    }

    return nullptr;
}
// this two functions are commented because are used on clipboard
// and because slow the text pastinbg and usage a lot
// and couldn't get it working properly we miss font size font style or never work
// and user usually want paste as plain text and get the position context
// style. Anyway I retain for further usage.

/* static bool css_attrs_are_equal(SPCSSAttr const *first, SPCSSAttr const *second)
{
//    Inkscape::Util::List<Inkscape::XML::AttributeRecord const> attrs = first->attributeList();
    for ( ; attrs ; attrs++) {
        gchar const *other_attr = second->attribute(g_quark_to_string(attrs->key));
        if (other_attr == nullptr || strcmp(attrs->value, other_attr))
            return false;
    }
    attrs = second->attributeList();
    for ( ; attrs ; attrs++) {
        gchar const *other_attr = first->attribute(g_quark_to_string(attrs->key));
        if (other_attr == nullptr || strcmp(attrs->value, other_attr))
            return false;
    }
    return true;
}

std::vector<SPCSSAttr*> sp_text_get_selected_style(ToolBase const *ec, unsigned *k, int *b, std::vector<unsigned>
*positions)
{
    std::vector<SPCSSAttr*> vec;
    SPCSSAttr *css, *css_new;
    TextTool *tc = SP_TEXT_CONTEXT(ec);
    Inkscape::Text::Layout::iterator i = std::min(tc->text_sel_start, tc->text_sel_end);
    SPObject const *obj = sp_te_object_at_position(tc->text, i);
    if (obj) {
        css = take_style_from_item(const_cast<SPObject*>(obj));
    }
    vec.push_back(css);
    positions->push_back(0);
    i.nextCharacter();
    *k = 1;
    *b = 1;
    while (i != std::max(tc->text_sel_start, tc->text_sel_end))
    {
        obj = sp_te_object_at_position(tc->text, i);
        if (obj) {
            css_new = take_style_from_item(const_cast<SPObject*>(obj));
        }
        if(!css_attrs_are_equal(css, css_new))
        {
            vec.push_back(css_new);
            css = sp_repr_css_attr_new();
            sp_repr_css_merge(css, css_new);
            positions->push_back(*k);
            (*b)++;
        }
        i.nextCharacter();
        (*k)++;
    }
    positions->push_back(*k);
    return vec;
}
 */

/**
 Deletes the currently selected characters. Returns false if there is no
 text selection currently.
*/
bool sp_text_delete_selection(ToolBase *ec)
{
    if (!SP_IS_TEXT_CONTEXT(ec))
        return false;
    TextTool *tc = SP_TEXT_CONTEXT(ec);
    if (tc->text == nullptr)
        return false;

    if (tc->text_sel_start == tc->text_sel_end)
        return false;

    iterator_pair pair;
    bool success = sp_te_delete(tc->text, tc->text_sel_start, tc->text_sel_end, pair);


    if (success) {
        tc->text_sel_start = tc->text_sel_end = pair.first;
    } else { // nothing deleted
        tc->text_sel_start = pair.first;
        tc->text_sel_end = pair.second;
    }

    sp_text_context_update_cursor(tc);
    sp_text_context_update_text_selection(tc);

    return true;
}

/**
 * \param selection Should not be NULL.
 */
void TextTool::_selectionChanged(Inkscape::Selection *selection)
{
    g_assert(selection != nullptr);
    SPItem *item = selection->singleItem();

    if (this->text && (item != this->text)) {
        sp_text_context_forget_text(this);
    }
    this->text = nullptr;

    shape_editor->unset_item();
    if (is<SPText>(item) || is<SPFlowtext>(item)) {
        shape_editor->set_item(item);

        this->text = item;
        Inkscape::Text::Layout const *layout = te_get_layout(this->text);
        if (layout)
            this->text_sel_start = this->text_sel_end = layout->end();
    } else {
        this->text = nullptr;
    }

    // we update cursor without scrolling, because this position may not be final;
    // item_handler moves cusros to the point of click immediately
    sp_text_context_update_cursor(this, false);
    sp_text_context_update_text_selection(this);
}

void TextTool::_selectionModified(Inkscape::Selection */*selection*/, guint /*flags*/)
{
    bool scroll = !this->shape_editor->has_knotholder() ||
                  !this->shape_editor->knotholder->is_dragging();
    sp_text_context_update_cursor(this, scroll);
    sp_text_context_update_text_selection(this);
}

bool TextTool::_styleSet(SPCSSAttr const *css)
{
    if (this->text == nullptr)
        return false;
    if (this->text_sel_start == this->text_sel_end)
        return false;    // will get picked up by the parent and applied to the whole text object

    sp_te_apply_style(this->text, this->text_sel_start, this->text_sel_end, css);

    // This is a bandaid fix... whenever a style is changed it might cause the text layout to
    // change which requires rewriting the 'x' and 'y' attributes of the tpsans for Inkscape
    // multi-line text (with sodipodi:role="line"). We need to rewrite the repr after this is
    // done. rebuldLayout() will be called a second time unnecessarily.
    auto sptext = cast<SPText>(text);
    if (sptext) {
        sptext->rebuildLayout();
        sptext->updateRepr();
    }

    DocumentUndo::done(_desktop->getDocument(), _("Set text style"), INKSCAPE_ICON("draw-text"));
    sp_text_context_update_cursor(this);
    sp_text_context_update_text_selection(this);
    return true;
}

int TextTool::_styleQueried(SPStyle *style, int property)
{
    if (this->text == nullptr) {
        return QUERY_STYLE_NOTHING;
    }
    const Inkscape::Text::Layout *layout = te_get_layout(this->text);
    if (layout == nullptr) {
        return QUERY_STYLE_NOTHING;
    }
    sp_text_context_validate_cursor_iterators(this);

    std::vector<SPItem*> styles_list;

    Inkscape::Text::Layout::iterator begin_it, end_it;
    if (this->text_sel_start < this->text_sel_end) {
        begin_it = this->text_sel_start;
        end_it = this->text_sel_end;
    } else {
        begin_it = this->text_sel_end;
        end_it = this->text_sel_start;
    }
    if (begin_it == end_it) {
        if (!begin_it.prevCharacter()) {
            end_it.nextCharacter();
        }
    }
    for (Inkscape::Text::Layout::iterator it = begin_it ; it < end_it ; it.nextStartOfSpan()) {
        SPObject *pos_obj = nullptr;
        layout->getSourceOfCharacter(it, &pos_obj);
        if (!pos_obj) {
            continue;
        }
        if (! pos_obj->parent) // the string is not in the document anymore (deleted)
            return 0;

        if ( is<SPString>(pos_obj) ) {
           pos_obj = pos_obj->parent;   // SPStrings don't have style
        }
        styles_list.insert(styles_list.begin(),(SPItem*)pos_obj);
    }

    int result = sp_desktop_query_style_from_list (styles_list, style, property);

    return result;
}

static void sp_text_context_validate_cursor_iterators(TextTool *tc)
{
    if (tc->text == nullptr)
        return;
    Inkscape::Text::Layout const *layout = te_get_layout(tc->text);
    if (layout) {     // undo can change the text length without us knowing it
        layout->validateIterator(&tc->text_sel_start);
        layout->validateIterator(&tc->text_sel_end);
    }
}

static void sp_text_context_update_cursor(TextTool *tc,  bool scroll_to_see)
{
    // due to interruptible display, tc may already be destroyed during a display update before
    // the cursor update (can't do both atomically, alas)
    if (!tc->getDesktop()) return;
    auto desktop = tc->getDesktop();

    if (tc->text) {
        Geom::Point p0, p1;
        sp_te_get_cursor_coords(tc->text, tc->text_sel_end, p0, p1);
        Geom::Point const d0 = p0 * tc->text->i2dt_affine();
        Geom::Point const d1 = p1 * tc->text->i2dt_affine();

        // scroll to show cursor
        if (scroll_to_see) {

            // We don't want to scroll outside the text box area (i.e. when there is hidden text)
            // or we could end up in Timbuktu.
            bool scroll = true;
            if (is<SPText>(tc->text)) {
                Geom::OptRect opt_frame = cast<SPText>(tc->text)->get_frame();
                if (opt_frame && (!opt_frame->contains(p0))) {
                    scroll = false;
                }
            } else if (is<SPFlowtext>(tc->text)) {
                SPItem *frame = cast<SPFlowtext>(tc->text)->get_frame(nullptr); // first frame only
                Geom::OptRect opt_frame = frame->geometricBounds();
                if (opt_frame && (!opt_frame->contains(p0))) {
                    scroll = false;
                }
            }

            if (scroll) {
                Geom::Point const center = desktop->current_center();
                if (Geom::L2(d0 - center) > Geom::L2(d1 - center))
                    // unlike mouse moves, here we must scroll all the way at first shot, so we override the autoscrollspeed
                    desktop->scroll_to_point(d0);
                else
                    desktop->scroll_to_point(d1);
            }
        }

        tc->cursor->set_coords(d0, d1);
        tc->cursor->show();

        /* fixme: ... need another transformation to get canvas widget coordinate space? */
        if (tc->imc) {
            GdkRectangle im_cursor = { 0, 0, 1, 1 };
            Geom::Point const top_left = desktop->get_display_area().corner(0);
            Geom::Point const im_d0 =    desktop->d2w(d0 - top_left);
            Geom::Point const im_d1 =    desktop->d2w(d1 - top_left);
            Geom::Rect const im_rect(im_d0, im_d1);
            im_cursor.x = (int) floor(im_rect.left());
            im_cursor.y = (int) floor(im_rect.top());
            im_cursor.width = (int) floor(im_rect.width());
            im_cursor.height = (int) floor(im_rect.height());
            gtk_im_context_set_cursor_location(tc->imc, &im_cursor);
        }

        tc->show = TRUE;
        tc->phase = true;

        Inkscape::Text::Layout const *layout = te_get_layout(tc->text);
        int const nChars = layout->iteratorToCharIndex(layout->end());
        char const *edit_message = ngettext("Type or edit text (%d character%s); <b>Enter</b> to start new line.", "Type or edit text (%d characters%s); <b>Enter</b> to start new line.", nChars);
        char const *edit_message_flowed = ngettext("Type or edit flowed text (%d character%s); <b>Enter</b> to start new paragraph.", "Type or edit flowed text (%d characters%s); <b>Enter</b> to start new paragraph.", nChars);
        bool truncated = layout->inputTruncated();
        char const *trunc = truncated ? _(" [truncated]") : "";

        if (truncated) {
            tc->frame->set_stroke(0xff0000ff);
        } else {
            tc->frame->set_stroke(0x0000ff7f);
        }

        std::vector<SPItem const *> shapes;
        std::unique_ptr<Shape> exclusion_shape;
        double padding = 0.0;

        // Frame around text
        if (is<SPFlowtext>(tc->text)) {
            SPItem *frame = cast<SPFlowtext>(tc->text)->get_frame (nullptr); // first frame only
            shapes.push_back(frame);

            tc->message_context->setF(Inkscape::NORMAL_MESSAGE, edit_message_flowed, nChars, trunc);

        } else if (auto text = cast<SPText>(tc->text)) {
            if (text->style->shape_inside.set) {
                for (auto const *href : text->style->shape_inside.hrefs) {
                    shapes.push_back(href->getObject());
                }
                if (text->style->shape_padding.set) {
                    // Calculate it here so we never show padding on FlowText or non-flowed Text (even if set)
                    padding = text->style->shape_padding.computed;
                }
                if(text->style->shape_subtract.set) {
                    // Find union of all exclusion shapes for later use
                    exclusion_shape = text->getExclusionShape();
                }
                tc->message_context->setF(Inkscape::NORMAL_MESSAGE, edit_message_flowed, nChars, trunc);
            } else {
                for (SPObject &child : tc->text->children) {
                    if (auto textpath = cast<SPTextPath>(&child)) {
                        shapes.push_back(sp_textpath_get_path_item(textpath));
                    }
                }
                tc->message_context->setF(Inkscape::NORMAL_MESSAGE, edit_message, nChars, trunc);
            }
        }

        SPCurve curve;
        for (auto const *shape_item : shapes) {
            if (auto shape = cast<SPShape>(shape_item)) {
                if (shape->curve()) {
                    curve.append(shape->curve()->transformed(shape->transform));
                }
            }
        }

        if (!curve.is_empty()) {
            bool has_padding = std::fabs(padding) > 1e-12;

            if (has_padding || exclusion_shape) {
                // Should only occur for SVG2 autoflowed text
                // See sp-text.cpp function _buildLayoutInit()
                Path *temp = new Path;
                temp->LoadPathVector(curve.get_pathvector());

                // Get initial shape-inside curve
                Shape *uncross = new Shape;
                {
                    Shape *sh = new Shape;
                    temp->ConvertWithBackData(0.25); // Convert to polyline
                    temp->Fill(sh, 0);
                    uncross->ConvertToShape(sh);
                    delete sh;
                }

                // Get padded shape exclusion
                if (has_padding) {
                    Shape *pad_shape = new Shape;
                    Path *padded = new Path;
                    Path *padt = new Path;
                    Shape *sh = new Shape;
                    padt->LoadPathVector(curve.get_pathvector());
                    padt->Outline(padded, padding, join_round, butt_straight, 20.0);
                    padded->ConvertWithBackData(1.0); // Convert to polyline
                    padded->Fill(sh, 0);
                    pad_shape->ConvertToShape(sh);
                    delete sh;
                    delete padt;
                    delete padded;

                    Shape *copy = new Shape;
                    copy->Booleen(uncross, pad_shape, (padding > 0.0) ? bool_op_diff : bool_op_union);
                    delete uncross;
                    delete pad_shape;
                    uncross = copy;
                }

                // Remove exclusions plus margins from padding frame
                if (exclusion_shape && exclusion_shape->hasEdges()) {
                    Shape *copy = new Shape;
                    copy->Booleen(uncross, exclusion_shape.get(), bool_op_diff);
                    delete uncross;
                    uncross = copy;
                }

                uncross->ConvertToForme(temp);
                tc->padding_frame->set_bpath(temp->MakePathVector() * tc->text->i2dt_affine());
                tc->padding_frame->show();

                delete temp;
                delete uncross;
            } else {
                tc->padding_frame->hide();
            }

            // Transform curve after doing padding.
            curve.transform(tc->text->i2dt_affine());
            tc->frame->set_bpath(&curve);
            tc->frame->show();
        } else {
            tc->frame->hide();
            tc->padding_frame->hide();
        }

    } else {
        tc->cursor->hide();
        tc->frame->hide();
        tc->show = FALSE;
        if (!tc->nascent_object) {
            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
        }
    }

    desktop->emit_text_cursor_moved(tc, tc);
}

static void sp_text_context_update_text_selection(TextTool *tc)
{
    // due to interruptible display, tc may already be destroyed during a display update before
    // the selection update (can't do both atomically, alas)
    if (!tc->getDesktop()) return;

    tc->text_selection_quads.clear();

    std::vector<Geom::Point> quads;
    if (tc->text != nullptr)
        quads = sp_te_create_selection_quads(tc->text, tc->text_sel_start, tc->text_sel_end, (tc->text)->i2dt_affine());
    for (unsigned i = 0 ; i < quads.size() ; i += 4) {
        auto quad = new CanvasItemQuad(tc->getDesktop()->getCanvasControls(), quads[i], quads[i+1], quads[i+2], quads[i+3]);
        quad->set_fill(0x00777777); // Semi-transparent blue as Cairo cannot do inversion.
        quad->show();
        tc->text_selection_quads.emplace_back(quad);
    }

    if (tc->shape_editor) {
        if (tc->shape_editor->knotholder) {
            tc->shape_editor->knotholder->update_knots();
        }
    }
}

static gint sp_text_context_timeout(TextTool *tc)
{
    if (tc->show) {
        if (tc->phase) {
            tc->phase = false;
            tc->cursor->set_stroke(0x000000ff);
        } else {
            tc->phase = true;
            tc->cursor->set_stroke(0xffffffff);
        }
        tc->cursor->show();
    }

    return TRUE;
}

static void sp_text_context_forget_text(TextTool *tc)
{
    if (! tc->text) return;
    SPItem *ti = tc->text;
    (void)ti;
    /* We have to set it to zero,
     * or selection changed signal messes everything up */
    tc->text = nullptr;

/* FIXME: this automatic deletion when nothing is inputted crashes the XML editor and also crashes when duplicating an empty flowtext.
    So don't create an empty flowtext in the first place? Create it when first character is typed.
    */
/*
    if ((is<SPText>(ti) || is<SPFlowtext>(ti)) && sp_te_input_is_empty(ti)) {
        Inkscape::XML::Node *text_repr = ti->getRepr();
        // the repr may already have been unparented
        // if we were called e.g. as the result of
        // an undo or the element being removed from
        // the XML editor
        if ( text_repr && text_repr->parent() ) {
            sp_repr_unparent(text_repr);
            SPDocumentUndo::done(tc->desktop->getDocument(), _("Remove empty text"), INKSCAPE_ICON("draw-text"));
        }
    }
*/
}

gint sptc_focus_in(GtkWidget *widget, GdkEventFocus */*event*/, TextTool *tc)
{
    gtk_im_context_focus_in(tc->imc);
    return FALSE;
}

gint sptc_focus_out(GtkWidget */*widget*/, GdkEventFocus */*event*/, TextTool *tc)
{
    gtk_im_context_focus_out(tc->imc);
    return FALSE;
}

static void sptc_commit(GtkIMContext */*imc*/, gchar *string, TextTool *tc)
{
    if (!tc->text) {
        sp_text_context_setup_text(tc);
        tc->nascent_object = false; // we don't need it anymore, having created a real <text>
    }

    tc->text_sel_start = tc->text_sel_end = sp_te_replace(tc->text, tc->text_sel_start, tc->text_sel_end, string);
    sp_text_context_update_cursor(tc);
    sp_text_context_update_text_selection(tc);

    DocumentUndo::done(tc->text->document, _("Type text"), INKSCAPE_ICON("draw-text"));
}

void sp_text_context_place_cursor (TextTool *tc, SPObject *text, Inkscape::Text::Layout::iterator where)
{
    tc->getDesktop()->getSelection()->set (text);
    tc->text_sel_start = tc->text_sel_end = where;
    sp_text_context_update_cursor(tc);
    sp_text_context_update_text_selection(tc);
}

void sp_text_context_place_cursor_at (TextTool *tc, SPObject *text, Geom::Point const p)
{
    tc->getDesktop()->getSelection()->set (text);
    sp_text_context_place_cursor (tc, text, sp_te_get_position_by_coords(tc->text, p));
}

Inkscape::Text::Layout::iterator *sp_text_context_get_cursor_position(TextTool *tc, SPObject *text)
{
    if (text != tc->text)
        return nullptr;
    return &(tc->text_sel_end);
}

}
}
}

/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
