diff --git a/autotests/src/kateview_test.cpp b/autotests/src/kateview_test.cpp
index fb217bd8..cb7cb3d4 100644
--- a/autotests/src/kateview_test.cpp
+++ b/autotests/src/kateview_test.cpp
@@ -1,531 +1,530 @@
 /* This file is part of the KDE libraries
    Copyright (C) 2010 Milian Wolff <mail@milianw.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "kateview_test.h"
 #include "moc_kateview_test.cpp"
 
 #include <kateglobal.h>
 #include <katedocument.h>
 #include <kateview.h>
 #include <ktexteditor/movingcursor.h>
 #include <kateconfig.h>
 #include <katebuffer.h>
 #include <ktexteditor/message.h>
 
 #include <QtTestWidgets>
 #include <QTemporaryFile>
 
 #define testNewRow() (QTest::newRow(QString("line %1").arg(__LINE__).toLatin1().data()))
 
 using namespace KTextEditor;
 
 QTEST_MAIN(KateViewTest)
 
 KateViewTest::KateViewTest()
     : QObject()
 {
     KTextEditor::EditorPrivate::enableUnitTestMode();
 }
 
 KateViewTest::~KateViewTest()
 {
 }
 
 void KateViewTest::testCoordinatesToCursor()
 {
     KTextEditor::DocumentPrivate doc(false, false);
     doc.setText("Hi World!\nHi\n");
 
     KTextEditor::View* view1 = static_cast<KTextEditor::View*>(doc.createView(nullptr));
     view1->resize(400, 300);
     view1->show();
 
     QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(0, 2))),
              KTextEditor::Cursor(0, 2));
     QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(1, 1))),
              KTextEditor::Cursor(1, 1));
     // behind end of line should give an invalid cursor
     QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(1, 5))),
              KTextEditor::Cursor::invalid());
     QCOMPARE(view1->cursorToCoordinate(KTextEditor::Cursor(3, 1)), QPoint(-1, -1));
 
     // check consistency between cursorToCoordinate(view->cursorPosition() and cursorPositionCoordinates()
     // random position
     view1->setCursorPosition(KTextEditor::Cursor(0, 3));
     QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(view1->cursorPosition())),
              KTextEditor::Cursor(0, 3));
     QCOMPARE(view1->coordinatesToCursor(view1->cursorPositionCoordinates()), KTextEditor::Cursor(0, 3));
     // end of line
     view1->setCursorPosition(KTextEditor::Cursor(0, 9));
     QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(0, 9))),
              KTextEditor::Cursor(0, 9));
     QCOMPARE(view1->coordinatesToCursor(view1->cursorPositionCoordinates()), KTextEditor::Cursor(0, 9));
     // empty line
     view1->setCursorPosition(KTextEditor::Cursor(2, 0));
     QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(2, 0))),
              KTextEditor::Cursor(2, 0));
     QCOMPARE(view1->coordinatesToCursor(view1->cursorPositionCoordinates()), KTextEditor::Cursor(2, 0));
 
     // same test again, but with message widget on top visible
     KTextEditor::Message *message = new KTextEditor::Message("Jo World!", KTextEditor::Message::Information);
     doc.postMessage(message);
 
     // wait 500ms until show animation is finished, so the message widget is visible
     QTest::qWait(500);
 
     QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(0, 2))),
              KTextEditor::Cursor(0, 2));
     QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(1, 1))),
              KTextEditor::Cursor(1, 1));
     // behind end of line should give an invalid cursor
     QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(1, 5))),
              KTextEditor::Cursor::invalid());
     QCOMPARE(view1->cursorToCoordinate(KTextEditor::Cursor(3, 1)), QPoint(-1, -1));
 }
 
 void KateViewTest::testCursorToCoordinates()
 {
     KTextEditor::DocumentPrivate doc(false, false);
     doc.setText("int a;");
 
     KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
     view->config()->setDynWordWrap(true);
     view->show();
 
     // don't crash, see https://bugs.kde.org/show_bug.cgi?id=337863
     view->cursorToCoordinate(Cursor(0, 0));
     view->cursorToCoordinate(Cursor(1, 0));
     view->cursorToCoordinate(Cursor(-1, 0));
 }
 
 void KateViewTest::testReloadMultipleViews()
 {
     QTemporaryFile file("XXXXXX.cpp");
     file.open();
     QTextStream stream(&file);
     const QString line = "const char* foo = \"asdf\"\n";
     for (int i = 0; i < 200; ++i) {
         stream << line;
     }
     stream << flush;
     file.close();
 
     KTextEditor::DocumentPrivate doc;
     QVERIFY(doc.openUrl(QUrl::fromLocalFile(file.fileName())));
     QCOMPARE(doc.highlightingMode(), QString("C++"));
 
     KTextEditor::ViewPrivate *view1 = new KTextEditor::ViewPrivate(&doc, nullptr);
     KTextEditor::ViewPrivate *view2 = new KTextEditor::ViewPrivate(&doc, nullptr);
     view1->show();
     view2->show();
     QCOMPARE(doc.views().count(), 2);
 
     QVERIFY(doc.documentReload());
 }
 
 void KateViewTest::testTabCursorOnReload()
 {
     // testcase for https://bugs.kde.org/show_bug.cgi?id=258480
     QTemporaryFile file("XXXXXX.cpp");
     file.open();
     QTextStream stream(&file);
     stream << "\tfoo\n";
     file.close();
 
     KTextEditor::DocumentPrivate doc;
     QVERIFY(doc.openUrl(QUrl::fromLocalFile(file.fileName())));
 
     KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
     const KTextEditor::Cursor cursor(0, 4);
     view->setCursorPosition(cursor);
     QCOMPARE(view->cursorPosition(), cursor);
     QVERIFY(doc.documentReload());
     QCOMPARE(view->cursorPosition(), cursor);
 }
 
 void KateViewTest::testLowerCaseBlockSelection()
 {
     // testcase for https://bugs.kde.org/show_bug.cgi?id=258480
     KTextEditor::DocumentPrivate doc;
     doc.setText("nY\nnYY\n");
 
     KTextEditor::ViewPrivate *view1 = new KTextEditor::ViewPrivate(&doc, nullptr);
     view1->setBlockSelection(true);
     view1->setSelection(Range(0, 1, 1, 3));
     view1->lowercase();
 
     QCOMPARE(doc.text(), QString("ny\nnyy\n"));
 }
 
 namespace
 {
     QWidget *findViewInternal(KTextEditor::View* view)
     {
         foreach (QObject* child, view->children()) {
             if (child->metaObject()->className() == QByteArrayLiteral("KateViewInternal")) {
                 return qobject_cast<QWidget*>(child);
             }
         }
         return nullptr;
     }
 }
 
 void KateViewTest::testSelection()
 {
     // see also: https://bugs.kde.org/show_bug.cgi?id=277422
     // wrong behavior before:
     // Open file with text
     // click at end of some line (A) and drag to right, i.e. without selecting anything
     // click somewhere else (B)
     // shift click to another place (C)
     // => expected: selection from B to C
     // => actual: selection from A to C
 
     QTemporaryFile file("XXXXXX.txt");
     file.open();
     QTextStream stream(&file);
     stream << "A\n"
            << "B\n"
            << "C";
     stream << flush;
     file.close();
 
     KTextEditor::DocumentPrivate doc;
     QVERIFY(doc.openUrl(QUrl::fromLocalFile(file.fileName())));
 
     KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
     view->resize(100, 200);
     view->show();
 
 
     QObject *internalView = findViewInternal(view);
     QVERIFY(internalView);
 
     const QPoint afterA = view->cursorToCoordinate(Cursor(0, 1));
     const QPoint afterB = view->cursorToCoordinate(Cursor(1, 1));
     const QPoint afterC = view->cursorToCoordinate(Cursor(2, 1));
 
     // click after A
     QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonPress, afterA,
                                 Qt::LeftButton, Qt::LeftButton,
                                 Qt::NoModifier));
 
     QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonRelease, afterA,
                                 Qt::LeftButton, Qt::LeftButton,
                                 Qt::NoModifier));
     QCOMPARE(view->cursorPosition(), Cursor(0, 1));
     // drag to right
     QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonPress, afterA,
                                 Qt::LeftButton, Qt::LeftButton,
                                 Qt::NoModifier));
 
     QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseMove, afterA + QPoint(50, 0),
                                 Qt::LeftButton, Qt::LeftButton,
                                 Qt::NoModifier));
 
     QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonRelease, afterA + QPoint(50, 0),
                                 Qt::LeftButton, Qt::LeftButton,
                                 Qt::NoModifier));
 
     QCOMPARE(view->cursorPosition(), Cursor(0, 1));
     QVERIFY(!view->selection());
 
     // click after C
     QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonPress, afterC,
                                 Qt::LeftButton, Qt::LeftButton,
                                 Qt::NoModifier));
 
     QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonRelease, afterC,
                                 Qt::LeftButton, Qt::LeftButton,
                                 Qt::NoModifier));
 
     QCOMPARE(view->cursorPosition(), Cursor(2, 1));
     // shift+click after B
     QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonPress, afterB,
                                 Qt::LeftButton, Qt::LeftButton,
                                 Qt::ShiftModifier));
 
     QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonRelease, afterB,
                                 Qt::LeftButton, Qt::LeftButton,
                                 Qt::ShiftModifier));
 
     QCOMPARE(view->cursorPosition(), Cursor(1, 1));
     QCOMPARE(view->selectionRange(), Range(1, 1, 2, 1));
 }
 
 void KateViewTest::testDeselectByArrowKeys_data()
 {
     QTest::addColumn<QString>("text");
 
     testNewRow() << "foobarhaz";
     testNewRow() << "كلسشمن يتبكسب"; // We all win, translates Google
 }
 
 void KateViewTest::testDeselectByArrowKeys()
 {
     QFETCH(QString, text);
 
     KTextEditor::DocumentPrivate doc;
     doc.setText(text);
     KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
     KTextEditor::Cursor cur1(0, 3); // Start of bar: foo|barhaz
     KTextEditor::Cursor cur2(0, 6); //   End of bar: foobar|haz
     KTextEditor::Cursor curDelta(0, 1);
     Range range(cur1, cur2); // Select "bar"
 
     // RTL drives me nuts!
     KTextEditor::Cursor help;
     if (text.isRightToLeft()) {
         help = cur1;
         cur1 = cur2;
         cur2 = help;
     }
 
     view->setSelection(range);
     view->setCursorPositionInternal(cur1);
     view->cursorLeft();
     QCOMPARE(view->cursorPosition(), cur1); // Be at begin: foo|barhaz
     QCOMPARE(view->selection(), false);
 
     view->setSelection(range);
     view->setCursorPositionInternal(cur1);
     view->cursorRight();
     QCOMPARE(view->cursorPosition(), cur2);  // Be at end: foobar|haz
     QCOMPARE(view->selection(), false);
 
     view->config()->setPersistentSelection(true);
 
     view->setSelection(range);
     view->setCursorPositionInternal(cur1);
     view->cursorLeft();
     // RTL drives me nuts!
     help = text.isRightToLeft() ? (cur1 + curDelta): (cur1 - curDelta);
     QCOMPARE(view->cursorPosition(), help); // Be one left: fo|obarhaz
     QCOMPARE(view->selection(), true);
 
     view->setSelection(range);
     view->setCursorPositionInternal(cur1);
     view->cursorRight();
     // RTL drives me nuts!
     help = text.isRightToLeft() ? (cur1 - curDelta): (cur1 + curDelta);
     QCOMPARE(view->cursorPosition(), help); // Be one right: foob|arhaz
     QCOMPARE(view->selection(), true);
 }
 
 void KateViewTest::testKillline()
 {
     KTextEditor::DocumentPrivate doc;
     doc.insertLines(0, { "foo", "bar", "baz" });
 
     KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
 
     view->setCursorPositionInternal(KTextEditor::Cursor(1, 2));
     view->killLine();
 
     QCOMPARE(doc.text(), QLatin1String("foo\nbaz\n"));
 
     doc.clear();
     QVERIFY(doc.isEmpty());
 
     doc.insertLines(0, { "foo", "bar", "baz", "xxx" });
 
     view->setCursorPositionInternal(KTextEditor::Cursor(1, 2));
     view->shiftDown();
     view->killLine();
 
     QCOMPARE(doc.text(), QLatin1String("foo\nxxx\n"));
 }
 
 void KateViewTest::testScrollPastEndOfDocument()
 {
-#if 0 // bug still exists, see bug 306745
+    // bug 306745
     KTextEditor::DocumentPrivate doc;
     doc.setText(QStringLiteral("0000000000\n"
                                "1111111111\n"
                                "2222222222\n"
                                "3333333333\n"
                                "4444444444"));
     QCOMPARE(doc.lines(), 5);
 
     KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
     view->setCursorPosition({ 3, 5 });
     view->resize(400, 300);
     view->show();
 
     // enable "[x] Scroll past end of document"
     view->config()->setScrollPastEnd(true);
     QCOMPARE(view->config()->scrollPastEnd(), true);
 
     // disable dynamic word wrap
     view->config()->setDynWordWrap(false);
     QCOMPARE(view->config()->dynWordWrap(), false);
 
     view->scrollDown();
     view->scrollDown();
     view->scrollDown();
     // at this point, only lines 3333333333 and 4444444444 are visible.
     view->down();
     QCOMPARE(view->cursorPosition(), KTextEditor::Cursor(4, 5));
     // verify, that only lines 3333333333 and 4444444444 are still visible.
     QCOMPARE(view->firstDisplayedLineInternal(KTextEditor::View::RealLine), 3);
-#endif
 }
 
 void KateViewTest::testFoldFirstLine()
 {
     QTemporaryFile file("XXXXXX.cpp");
     file.open();
     QTextStream stream(&file);
     stream << "/**\n"
            << " * foo\n"
            << " */\n"
            << "\n"
            << "int main() {}\n";
     file.close();
 
     KTextEditor::DocumentPrivate doc;
     QVERIFY(doc.openUrl(QUrl::fromLocalFile(file.fileName())));
     QCOMPARE(doc.highlightingMode(), QString("C++"));
 
     KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
     view->config()->setFoldFirstLine(false);
     view->setCursorPosition({4, 0});
 
     // initially, nothing is folded
     QVERIFY(view->textFolding().isLineVisible(1));
 
     // now change the config, and expect the header to be folded
     view->config()->setFoldFirstLine(true);
     qint64 foldedRangeId = 0;
     QVERIFY(!view->textFolding().isLineVisible(1, &foldedRangeId));
 
     // now unfold the range
     QVERIFY(view->textFolding().unfoldRange(foldedRangeId));
     QVERIFY(view->textFolding().isLineVisible(1));
 
     // and save the file, we do not expect the folding to change then
     doc.setModified(true);
     doc.saveFile();
     QVERIFY(view->textFolding().isLineVisible(1));
 
     // now reload the document, nothing should change
     doc.setModified(false);
     QVERIFY(doc.documentReload());
     QVERIFY(view->textFolding().isLineVisible(1));
 }
 
 // test for bug https://bugs.kde.org/374163
 void KateViewTest::testDragAndDrop()
 {
     KTextEditor::DocumentPrivate doc(false, false);
     doc.setText("line0\n"
                 "line1\n"
                 "line2\n"
                 "\n"
                 "line4");
 
     KTextEditor::View* view = static_cast<KTextEditor::View*>(doc.createView(nullptr));
     view->show();
     view->resize(400, 300);
 
     QWidget *internalView = findViewInternal(view);
     QVERIFY(internalView);
 
     // select "line1\n"
     view->setSelection(Range(1, 0, 2, 0));
     QCOMPARE(view->selectionRange(), Range(1, 0, 2, 0));
 
     QVERIFY(QTest::qWaitForWindowExposed(view));
     const QPoint startDragPos = internalView->mapFrom(view, view->cursorToCoordinate(KTextEditor::Cursor(1, 2)));
     const QPoint endDragPos = internalView->mapFrom(view, view->cursorToCoordinate(KTextEditor::Cursor(3, 0)));
     const QPoint gStartDragPos = internalView->mapToGlobal(startDragPos);
     const QPoint gEndDragPos = internalView->mapToGlobal(endDragPos);
 
     // now drag and drop selected text to Cursor(3, 0)
     QMouseEvent pressEvent(QEvent::MouseButtonPress, startDragPos, gStartDragPos,
                                 Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
     QCoreApplication::sendEvent(internalView, &pressEvent);
 
     // ugly workaround: Drag & Drop has own blocking event queue. Therefore, we need a single-shot timer to
     // break out of the blocking event queue, see (*)
     QTimer::singleShot(50, [&](){
         QMouseEvent moveEvent(QEvent::MouseMove, endDragPos + QPoint(5, 0), gEndDragPos + QPoint(5, 0),
                             Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
         QMouseEvent releaseEvent(QEvent::MouseButtonRelease, endDragPos, gEndDragPos,
                             Qt::LeftButton, Qt::NoButton, Qt::NoModifier);
         QCoreApplication::sendEvent(internalView, &moveEvent);
         QCoreApplication::sendEvent(internalView, &releaseEvent);
     });
 
     // (*) this somehow blocks...
     QMouseEvent moveEvent1(QEvent::MouseMove, endDragPos + QPoint(10, 0), gEndDragPos + QPoint(10, 0),
                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
     QCoreApplication::sendEvent(internalView, &moveEvent1);
 
     QTest::qWait(100);
 
     // final tests of dragged text
     QCOMPARE(doc.text(), QString("line0\n"
                                  "line2\n"
                                  "line1\n"
                                  "\n"
                                  "line4"));
 
     QCOMPARE(view->cursorPosition(), KTextEditor::Cursor(3, 0));
     QCOMPARE(view->selectionRange(), Range(2, 0, 3, 0));
 }
 
 // test for bug https://bugs.kde.org/402594
 void KateViewTest::testGotoMatchingBracket()
 {
     KTextEditor::DocumentPrivate doc(false, false);
     doc.setText("foo(bar)baz");
     //           0123456789
 
     KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
     const KTextEditor::Cursor cursor1(0, 3); // Starting point on open (
     const KTextEditor::Cursor cursor2(0, 8); // Insert Mode differ slightly from...
     const KTextEditor::Cursor cursor3(0, 7); // Overwrite Mode
 
     doc.config()->setOvr(false); // Insert Mode
 
     view->setCursorPosition(cursor1);
     view->toMatchingBracket();
     QCOMPARE(view->cursorPosition(), cursor2);
     view->toMatchingBracket();
     QCOMPARE(view->cursorPosition(), cursor1);
 
     // Currently has it in Insert Mode also to work when the cursor is placed inside the parentheses
     view->setCursorPosition(cursor1 + KTextEditor::Cursor(0, 1));
     view->toMatchingBracket();
     QCOMPARE(view->cursorPosition(), cursor2);
     view->setCursorPosition(cursor2 + KTextEditor::Cursor(0, -1));
     view->toMatchingBracket();
     QCOMPARE(view->cursorPosition(), cursor1);
 
     doc.config()->setOvr(true);// Overwrite Mode
 
     view->setCursorPosition(cursor1);
     view->toMatchingBracket();
     QCOMPARE(view->cursorPosition(), cursor3);
     view->toMatchingBracket();
     QCOMPARE(view->cursorPosition(), cursor1);
 }
 
 // kate: indent-mode cstyle; indent-width 4; replace-tabs on;
diff --git a/src/view/kateview.cpp b/src/view/kateview.cpp
index e1ffda64..7220d26a 100644
--- a/src/view/kateview.cpp
+++ b/src/view/kateview.cpp
@@ -1,3873 +1,3873 @@
 /* This file is part of the KDE libraries
    Copyright (C) 2009 Michel Ludwig <michel.ludwig@kdemail.net>
    Copyright (C) 2007 Mirko Stocker <me@misto.ch>
    Copyright (C) 2003 Hamish Rodda <rodda@kde.org>
    Copyright (C) 2002 John Firebaugh <jfirebaugh@kde.org>
    Copyright (C) 2001-2004 Christoph Cullmann <cullmann@kde.org>
    Copyright (C) 2001-2010 Joseph Wenninger <jowenn@kde.org>
    Copyright (C) 1999 Jochen Wilhelmy <digisnap@cs.tu-berlin.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 //BEGIN includes
 #include "kateview.h"
 
 #include "kateviewinternal.h"
 #include "kateviewhelpers.h"
 #include "katerenderer.h"
 #include "katedocument.h"
 #include "kateundomanager.h"
 #include "kateglobal.h"
 #include "katehighlight.h"
 #include "katehighlightmenu.h"
 #include "katedialogs.h"
 #include "katetextline.h"
 #include "kateschema.h"
 #include "katebookmarks.h"
 #include "kateconfig.h"
 #include "katemodemenu.h"
 #include "kateautoindent.h"
 #include "katecompletionwidget.h"
 #include "katewordcompletion.h"
 #include "katekeywordcompletion.h"
 #include "katelayoutcache.h"
 #include "spellcheck/spellcheck.h"
 #include "spellcheck/spellcheckdialog.h"
 #include "spellcheck/spellingmenu.h"
 #include "katebuffer.h"
 #include "script/katescriptmanager.h"
 #include "script/katescriptaction.h"
 #include "export/exporter.h"
 #include "katemessagewidget.h"
 #include "katetemplatehandler.h"
 #include "katepartdebug.h"
 #include "printing/kateprinter.h"
 #include "katestatusbar.h"
 #include "kateabstractinputmode.h"
 #include "inlinenotedata.h"
 
 #include <ktexteditor/inlinenoteprovider.h>
 #include <KTextEditor/Message>
 
 #include <KParts/Event>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KCursor>
 #include <KCharsets>
 #include <KMessageBox>
 #include <KStandardAction>
 #include <KXMLGUIFactory>
 #include <KStandardShortcut>
 #include <KToggleAction>
 #include <KSelectAction>
 #include <KActionCollection>
 
 #include <QFileInfo>
 #include <QMimeData>
 #include <QFont>
 #include <QKeyEvent>
 #include <QApplication>
 #include <QLayout>
 #include <QPainter>
 #include <QClipboard>
 #include <QFileDialog>
 #include <QToolTip>
 
 //#define VIEW_RANGE_DEBUG
 
 //END includes
 
 namespace {
 
 bool hasCommentInFirstLine(KTextEditor::DocumentPrivate* doc)
 {
     const Kate::TextLine& line = doc->kateTextLine(0);
     Q_ASSERT(line);
     return doc->isComment(0, line->firstChar());
 }
 
 }
 
 void KTextEditor::ViewPrivate::blockFix(KTextEditor::Range &range)
 {
     if (range.start().column() > range.end().column()) {
         int tmp = range.start().column();
         range.setStart(KTextEditor::Cursor(range.start().line(), range.end().column()));
         range.setEnd(KTextEditor::Cursor(range.end().line(), tmp));
     }
 }
 
 KTextEditor::ViewPrivate::ViewPrivate(KTextEditor::DocumentPrivate *doc, QWidget *parent, KTextEditor::MainWindow *mainWindow)
     : KTextEditor::View (this, parent)
     , m_completionWidget(nullptr)
     , m_annotationModel(nullptr)
     , m_hasWrap(false)
     , m_doc(doc)
     , m_textFolding(doc->buffer())
     , m_config(new KateViewConfig(this))
     , m_renderer(new KateRenderer(doc, m_textFolding, this))
     , m_viewInternal(new KateViewInternal(this))
     , m_spell(new KateSpellCheckDialog(this))
     , m_bookmarks(new KateBookmarks(this))
     , m_topSpacer(new QSpacerItem(0,0))
     , m_leftSpacer(new QSpacerItem(0,0))
     , m_rightSpacer(new QSpacerItem(0,0))
     , m_bottomSpacer(new QSpacerItem(0,0))
     , m_startingUp(true)
     , m_updatingDocumentConfig(false)
     , m_selection(m_doc->buffer(), KTextEditor::Range::invalid(), Kate::TextRange::ExpandLeft, Kate::TextRange::AllowEmpty)
     , blockSelect(false)
     , m_bottomViewBar(nullptr)
     , m_gotoBar(nullptr)
     , m_dictionaryBar(nullptr)
     , m_spellingMenu(new KateSpellingMenu(this))
     , m_userContextMenuSet(false)
     , m_delayedUpdateTriggered(false)
     , m_lineToUpdateMin(-1)
     , m_lineToUpdateMax(-1)
     , m_mainWindow(mainWindow ? mainWindow : KTextEditor::EditorPrivate::self()->dummyMainWindow()) // use dummy window if no window there!
     , m_statusBar(nullptr)
     , m_temporaryAutomaticInvocationDisabled(false)
     , m_autoFoldedFirstLine(false)
 {
     // queued connect to collapse view updates for range changes, INIT THIS EARLY ENOUGH!
     connect(this, SIGNAL(delayedUpdateOfView()), this, SLOT(slotDelayedUpdateOfView()), Qt::QueuedConnection);
 
     KXMLGUIClient::setComponentName(KTextEditor::EditorPrivate::self()->aboutData().componentName(), KTextEditor::EditorPrivate::self()->aboutData().displayName());
 
     // selection if for this view only and will invalidate if becoming empty
     m_selection.setView(this);
 
     // use z depth defined in moving ranges interface
     m_selection.setZDepth(-100000.0);
 
     KTextEditor::EditorPrivate::self()->registerView(this);
 
     /**
      * try to let the main window, if any, create a view bar for this view
      */
     QWidget *bottomBarParent = m_mainWindow->createViewBar(this);
 
     m_bottomViewBar = new KateViewBar(bottomBarParent != nullptr, bottomBarParent ? bottomBarParent : this, this);
 
     // ugly workaround:
     // Force the layout to be left-to-right even on RTL desktop, as discussed
     // on the mailing list. This will cause the lines and icons panel to be on
     // the left, even for Arabic/Hebrew/Farsi/whatever users.
     setLayoutDirection(Qt::LeftToRight);
 
     m_bottomViewBar->installEventFilter(m_viewInternal);
 
     // add KateMessageWidget for KTE::MessageInterface immediately above view
     m_messageWidgets[KTextEditor::Message::AboveView] = new KateMessageWidget(this);
     m_messageWidgets[KTextEditor::Message::AboveView]->hide();
 
     // add KateMessageWidget for KTE::MessageInterface immediately above view
     m_messageWidgets[KTextEditor::Message::BelowView] = new KateMessageWidget(this);
     m_messageWidgets[KTextEditor::Message::BelowView]->hide();
 
     // add bottom viewbar...
     if (bottomBarParent) {
         m_mainWindow->addWidgetToViewBar(this, m_bottomViewBar);
     }
 
     // add layout for floating message widgets to KateViewInternal
     m_notificationLayout = new KateMessageLayout(m_viewInternal);
     m_notificationLayout->setContentsMargins(20, 20, 20, 20);
     m_viewInternal->setLayout(m_notificationLayout);
 
     // this really is needed :)
     m_viewInternal->updateView();
 
     doc->addView(this);
 
     setFocusProxy(m_viewInternal);
     setFocusPolicy(Qt::StrongFocus);
 
     setXMLFile(QStringLiteral("katepart5ui.rc"));
 
     setupConnections();
     setupActions();
 
     // auto word completion
     new KateWordCompletionView(this, actionCollection());
 
     // update the enabled state of the undo/redo actions...
     slotUpdateUndo();
 
     /**
      * create the status bar of this view
      * do this after action creation, we use some of them!
      */
     toggleStatusBar();
 
     m_startingUp = false;
     updateConfig();
 
     slotHlChanged();
     KCursor::setAutoHideCursor(m_viewInternal, true);
 
     for (auto messageWidget : m_messageWidgets) {
         if (messageWidget) {
             // user interaction (scrolling) starts notification auto-hide timer
             connect(this, SIGNAL(displayRangeChanged(KTextEditor::ViewPrivate*)), messageWidget, SLOT(startAutoHideTimer()));
 
             // user interaction (cursor navigation) starts notification auto-hide timer
             connect(this, SIGNAL(cursorPositionChanged(KTextEditor::View*,KTextEditor::Cursor)), messageWidget, SLOT(startAutoHideTimer()));
         }
     }
 
     // folding restoration on reload
     connect(m_doc, SIGNAL(aboutToReload(KTextEditor::Document*)), SLOT(saveFoldingState()));
     connect(m_doc, SIGNAL(reloaded(KTextEditor::Document*)), SLOT(applyFoldingState()));
 
     connect(m_doc, &KTextEditor::DocumentPrivate::reloaded, this, &KTextEditor::ViewPrivate::slotDocumentReloaded);
     connect(m_doc, &KTextEditor::DocumentPrivate::aboutToReload, this, &KTextEditor::ViewPrivate::slotDocumentAboutToReload);
 
     // update highlights on scrolling and co
     connect(this, SIGNAL(displayRangeChanged(KTextEditor::ViewPrivate*)), this, SLOT(createHighlights()));
 
     // clear highlights on reload
     connect(m_doc, SIGNAL(aboutToReload(KTextEditor::Document*)), SLOT(clearHighlights()));
 
     // setup layout
     setupLayout();
 }
 
 KTextEditor::ViewPrivate::~ViewPrivate()
 {
     // invalidate update signal
     m_delayedUpdateTriggered = false;
 
     // remove from xmlgui factory, to be safe
     if (factory()) {
         factory()->removeClient(this);
     }
 
     // delete internal view before view bar!
     delete m_viewInternal;
 
     /**
      * remove view bar again, if needed
      */
     m_mainWindow->deleteViewBar(this);
     m_bottomViewBar = nullptr;
 
     doc()->removeView(this);
 
     delete m_renderer;
 
     delete m_config;
 
     KTextEditor::EditorPrivate::self()->deregisterView(this);
 }
 
 void KTextEditor::ViewPrivate::toggleStatusBar()
 {
     /**
      * if there, delete it
      */
     if (m_statusBar) {
         bottomViewBar()->removePermanentBarWidget(m_statusBar);
         delete m_statusBar;
         m_statusBar = nullptr;
         emit statusBarEnabledChanged(this, false);
         return;
     }
 
     /**
      * else: create it
      */
     m_statusBar = new KateStatusBar(this);
     bottomViewBar()->addPermanentBarWidget(m_statusBar);
     emit statusBarEnabledChanged(this, true);
 }
 
 void KTextEditor::ViewPrivate::setupLayout()
 {
 
     // delete old layout if any
     if (layout())
     {
         delete layout();
 
         /**
          *  need to recreate spacers because they are deleted with
          *  their belonging layout
          */
         m_topSpacer = new QSpacerItem(0,0);
         m_leftSpacer = new QSpacerItem(0,0);
         m_rightSpacer = new QSpacerItem(0,0);
         m_bottomSpacer = new QSpacerItem(0,0);
     }
 
     // set margins
     QStyleOptionFrame opt;
     opt.initFrom(this);
     opt.frameShape = QFrame::StyledPanel;
     opt.state |= QStyle::State_Sunken;
     const int margin = style()->pixelMetric(QStyle::PM_DefaultFrameWidth, &opt, this);
     m_topSpacer->changeSize(0, margin, QSizePolicy::Minimum, QSizePolicy::Fixed);
     m_leftSpacer->changeSize(margin, 0, QSizePolicy::Fixed, QSizePolicy::Minimum);
     m_rightSpacer->changeSize(margin, 0, QSizePolicy::Fixed, QSizePolicy::Minimum);
     m_bottomSpacer->changeSize(0, margin, QSizePolicy::Minimum, QSizePolicy::Fixed);
 
     // define layout
     QGridLayout *layout=new QGridLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
     layout->setSpacing(0);
 
     const bool frameAroundContents = style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents, &opt, this);
     if (frameAroundContents) {
 
         // top message widget
         layout->addWidget(m_messageWidgets[KTextEditor::Message::AboveView], 0, 0, 1, 5);
 
         // top spacer
         layout->addItem(m_topSpacer, 1, 0, 1, 4);
 
         // left spacer
         layout->addItem(m_leftSpacer, 2, 0, 1, 1);
 
         // left border
         layout->addWidget(m_viewInternal->m_leftBorder, 2, 1, 1, 1);
 
         // view
         layout->addWidget(m_viewInternal, 2, 2, 1, 1);
 
         // right spacer
         layout->addItem(m_rightSpacer, 2, 3, 1, 1);
 
         // bottom spacer
         layout->addItem(m_bottomSpacer, 3, 0, 1, 4);
 
         // vertical scrollbar
         layout->addWidget(m_viewInternal->m_lineScroll, 1, 4, 3, 1);
 
         // horizontal scrollbar
         layout->addWidget(m_viewInternal->m_columnScroll, 4, 0, 1, 4);
 
         // dummy
         layout->addWidget(m_viewInternal->m_dummy, 4, 4, 1, 1);
 
         // bottom message
         layout->addWidget(m_messageWidgets[KTextEditor::Message::BelowView], 5, 0, 1, 5);
 
         // bottom viewbar
         if (m_bottomViewBar->parentWidget() == this) {
             layout->addWidget(m_bottomViewBar, 6, 0, 1, 5);
         }
 
         // stretch
         layout->setColumnStretch(2, 1);
         layout->setRowStretch(2, 1);
 
         // adjust scrollbar background
         m_viewInternal->m_lineScroll->setBackgroundRole(QPalette::Window);
         m_viewInternal->m_lineScroll->setAutoFillBackground(false);
 
         m_viewInternal->m_columnScroll->setBackgroundRole(QPalette::Window);
         m_viewInternal->m_columnScroll->setAutoFillBackground(false);
 
     } else {
 
         // top message widget
         layout->addWidget(m_messageWidgets[KTextEditor::Message::AboveView], 0, 0, 1, 5);
 
         // top spacer
         layout->addItem(m_topSpacer, 1, 0, 1, 5);
 
         // left spacer
         layout->addItem(m_leftSpacer, 2, 0, 1, 1);
 
         // left border
         layout->addWidget(m_viewInternal->m_leftBorder, 2, 1, 1, 1);
 
         // view
         layout->addWidget(m_viewInternal, 2, 2, 1, 1);
 
         // vertical scrollbar
         layout->addWidget(m_viewInternal->m_lineScroll, 2, 3, 1, 1);
 
         // right spacer
         layout->addItem(m_rightSpacer, 2, 4, 1, 1);
 
         // horizontal scrollbar
         layout->addWidget(m_viewInternal->m_columnScroll, 3, 1, 1, 2);
 
         // dummy
         layout->addWidget(m_viewInternal->m_dummy, 3, 3, 1, 1);
 
         // bottom spacer
         layout->addItem(m_bottomSpacer, 4, 0, 1, 5);
 
         // bottom message
         layout->addWidget(m_messageWidgets[KTextEditor::Message::BelowView], 5, 0, 1, 5);
 
         // bottom viewbar
         if (m_bottomViewBar->parentWidget() == this) {
             layout->addWidget(m_bottomViewBar, 6, 0, 1, 5);
         }
 
         // stretch
         layout->setColumnStretch(2, 1);
         layout->setRowStretch(2, 1);
 
         // adjust scrollbar background
         m_viewInternal->m_lineScroll->setBackgroundRole(QPalette::Base);
         m_viewInternal->m_lineScroll->setAutoFillBackground(true);
 
         m_viewInternal->m_columnScroll->setBackgroundRole(QPalette::Base);
         m_viewInternal->m_columnScroll->setAutoFillBackground(true);
     }
 }
 
 void KTextEditor::ViewPrivate::setupConnections()
 {
     connect(m_doc, SIGNAL(undoChanged()),
             this, SLOT(slotUpdateUndo()));
     connect(m_doc, SIGNAL(highlightingModeChanged(KTextEditor::Document*)),
             this, SLOT(slotHlChanged()));
     connect(m_doc, SIGNAL(canceled(QString)),
             this, SLOT(slotSaveCanceled(QString)));
     connect(m_viewInternal, SIGNAL(dropEventPass(QDropEvent*)),
             this,           SIGNAL(dropEventPass(QDropEvent*)));
 
     connect(m_doc, SIGNAL(annotationModelChanged(KTextEditor::AnnotationModel*,KTextEditor::AnnotationModel*)),
             m_viewInternal->m_leftBorder, SLOT(annotationModelChanged(KTextEditor::AnnotationModel*,KTextEditor::AnnotationModel*)));
 }
 
 void KTextEditor::ViewPrivate::goToPreviousEditingPosition()
 {
     auto c = doc()->lastEditingPosition(KTextEditor::DocumentPrivate::Previous, cursorPosition());
     if(c.isValid()){
         setCursorPosition(c);
     }
 }
 
 void KTextEditor::ViewPrivate::goToNextEditingPosition()
 {
     auto c = doc()->lastEditingPosition(KTextEditor::DocumentPrivate::Next, cursorPosition());
     if(c.isValid()){
         setCursorPosition(c);
     }
 }
 void KTextEditor::ViewPrivate::setupActions()
 {
     KActionCollection *ac = actionCollection();
     QAction *a;
 
     m_toggleWriteLock = nullptr;
 
     m_cut = a = ac->addAction(KStandardAction::Cut, this, SLOT(cut()));
     a->setWhatsThis(i18n("Cut the selected text and move it to the clipboard"));
 
     m_paste = a = ac->addAction(KStandardAction::Paste, this, SLOT(paste()));
     a->setWhatsThis(i18n("Paste previously copied or cut clipboard contents"));
 
     m_copy = a = ac->addAction(KStandardAction::Copy, this, SLOT(copy()));
     a->setWhatsThis(i18n("Use this command to copy the currently selected text to the system clipboard."));
 
     m_pasteMenu = ac->addAction(QStringLiteral("edit_paste_menu"), new KatePasteMenu(i18n("Clipboard &History"), this));
     connect(KTextEditor::EditorPrivate::self(), SIGNAL(clipboardHistoryChanged()), this, SLOT(slotClipboardHistoryChanged()));
 
     if (!doc()->readOnly()) {
         a = ac->addAction(KStandardAction::Save, m_doc, SLOT(documentSave()));
         a->setWhatsThis(i18n("Save the current document"));
 
         a = m_editUndo = ac->addAction(KStandardAction::Undo, m_doc, SLOT(undo()));
         a->setWhatsThis(i18n("Revert the most recent editing actions"));
 
         a = m_editRedo = ac->addAction(KStandardAction::Redo, m_doc, SLOT(redo()));
         a->setWhatsThis(i18n("Revert the most recent undo operation"));
 
         // Tools > Scripts
         // stored inside scoped pointer to ensure we destruct it early enough as it does internal cleanups of other child objects
         m_scriptActionMenu.reset(new KateScriptActionMenu(this, i18n("&Scripts")));
         ac->addAction(QStringLiteral("tools_scripts"), m_scriptActionMenu.data());
 
         a = ac->addAction(QStringLiteral("tools_apply_wordwrap"));
         a->setText(i18n("Apply &Word Wrap"));
         a->setWhatsThis(i18n("Use this to wrap the current line, or to reformat the selected lines as paragraph, "
                              "to fit the 'Wrap words at' setting in the configuration dialog.<br /><br />"
                              "This is a static word wrap, meaning the document is changed."));
         connect(a, SIGNAL(triggered(bool)), SLOT(applyWordWrap()));
 
         a = ac->addAction(QStringLiteral("tools_cleanIndent"));
         a->setText(i18n("&Clean Indentation"));
         a->setWhatsThis(i18n("Use this to clean the indentation of a selected block of text (only tabs/only spaces).<br /><br />"
                              "You can configure whether tabs should be honored and used or replaced with spaces, in the configuration dialog."));
         connect(a, SIGNAL(triggered(bool)), SLOT(cleanIndent()));
 
         a = ac->addAction(QStringLiteral("tools_align"));
         a->setText(i18n("&Align"));
         a->setWhatsThis(i18n("Use this to align the current line or block of text to its proper indent level."));
         connect(a, SIGNAL(triggered(bool)), SLOT(align()));
 
         a = ac->addAction(QStringLiteral("tools_comment"));
         a->setText(i18n("C&omment"));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_D));
         a->setWhatsThis(i18n("This command comments out the current line or a selected block of text.<br /><br />"
                              "The characters for single/multiple line comments are defined within the language's highlighting."));
         connect(a, SIGNAL(triggered(bool)), SLOT(comment()));
 
         a = ac->addAction(QStringLiteral("Previous Editing Line"));
         a->setText(i18n("Go to previous editing line"));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_E));
         connect(a, SIGNAL(triggered(bool)), SLOT(goToPreviousEditingPosition()));
 
         a = ac->addAction(QStringLiteral("Next Editing Line"));
         a->setText(i18n("Go to next editing line"));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_E));
         connect(a, SIGNAL(triggered(bool)), SLOT(goToNextEditingPosition()));
 
         a = ac->addAction(QStringLiteral("tools_uncomment"));
         a->setText(i18n("Unco&mment"));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_D));
         a->setWhatsThis(i18n("This command removes comments from the current line or a selected block of text.<br /><br />"
                              "The characters for single/multiple line comments are defined within the language's highlighting."));
         connect(a, SIGNAL(triggered(bool)), SLOT(uncomment()));
 
         a = ac->addAction(QStringLiteral("tools_toggle_comment"));
         a->setText(i18n("Toggle Comment"));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_Slash));
         connect(a, SIGNAL(triggered(bool)), SLOT(toggleComment()));
 
         a = m_toggleWriteLock = new KToggleAction(i18n("&Read Only Mode"), this);
         a->setWhatsThis(i18n("Lock/unlock the document for writing"));
         a->setChecked(!doc()->isReadWrite());
         connect(a, SIGNAL(triggered(bool)), SLOT(toggleWriteLock()));
         ac->addAction(QStringLiteral("tools_toggle_write_lock"), a);
 
         a = ac->addAction(QStringLiteral("tools_uppercase"));
         a->setIcon(QIcon::fromTheme(QStringLiteral("format-text-uppercase")));
         a->setText(i18n("Uppercase"));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_U));
         a->setWhatsThis(i18n("Convert the selection to uppercase, or the character to the "
                              "right of the cursor if no text is selected."));
         connect(a, SIGNAL(triggered(bool)), SLOT(uppercase()));
 
         a = ac->addAction(QStringLiteral("tools_lowercase"));
         a->setIcon(QIcon::fromTheme(QStringLiteral("format-text-lowercase")));
         a->setText(i18n("Lowercase"));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_U));
         a->setWhatsThis(i18n("Convert the selection to lowercase, or the character to the "
                              "right of the cursor if no text is selected."));
         connect(a, SIGNAL(triggered(bool)), SLOT(lowercase()));
 
         a = ac->addAction(QStringLiteral("tools_capitalize"));
         a->setIcon(QIcon::fromTheme(QStringLiteral("format-text-capitalize")));
         a->setText(i18n("Capitalize"));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_U));
         a->setWhatsThis(i18n("Capitalize the selection, or the word under the "
                              "cursor if no text is selected."));
         connect(a, SIGNAL(triggered(bool)), SLOT(capitalize()));
 
         a = ac->addAction(QStringLiteral("tools_join_lines"));
         a->setText(i18n("Join Lines"));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_J));
         connect(a, SIGNAL(triggered(bool)), SLOT(joinLines()));
 
         a = ac->addAction(QStringLiteral("tools_invoke_code_completion"));
         a->setText(i18n("Invoke Code Completion"));
         a->setWhatsThis(i18n("Manually invoke command completion, usually by using a shortcut bound to this action."));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_Space));
         connect(a, SIGNAL(triggered(bool)), SLOT(userInvokedCompletion()));
     } else {
         m_cut->setEnabled(false);
         m_paste->setEnabled(false);
         m_pasteMenu->setEnabled(false);
         m_editUndo = nullptr;
         m_editRedo = nullptr;
     }
 
     a = ac->addAction(KStandardAction::Print, this, SLOT(print()));
     a->setWhatsThis(i18n("Print the current document."));
 
     a = ac->addAction(KStandardAction::PrintPreview, this, SLOT(printPreview()));
     a->setWhatsThis(i18n("Show print preview of current document"));
 
     a = ac->addAction(QStringLiteral("file_reload"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("view-refresh")));
     a->setText(i18n("Reloa&d"));
     ac->setDefaultShortcuts(a, KStandardShortcut::reload());
     a->setWhatsThis(i18n("Reload the current document from disk."));
     connect(a, SIGNAL(triggered(bool)), SLOT(reloadFile()));
 
     a = ac->addAction(KStandardAction::SaveAs, m_doc, SLOT(documentSaveAs()));
     a->setWhatsThis(i18n("Save the current document to disk, with a name of your choice."));
 
     a = new KateViewEncodingAction(m_doc, this, i18n("Save As with Encoding..."), this, true /* special mode for save as */);
     a->setIcon(QIcon::fromTheme(QStringLiteral("document-save-as")));
     ac->addAction(QStringLiteral("file_save_as_with_encoding"), a);
 
     a = ac->addAction(QStringLiteral("file_save_copy_as"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("document-save-as")));
     a->setText(i18n("Save &Copy As..."));
     a->setWhatsThis(i18n("Save a copy of the current document to disk."));
     connect(a, SIGNAL(triggered(bool)), m_doc, SLOT(documentSaveCopyAs()));
 
     a = ac->addAction(KStandardAction::GotoLine, this, SLOT(gotoLine()));
     a->setWhatsThis(i18n("This command opens a dialog and lets you choose a line that you want the cursor to move to."));
 
     a = ac->addAction(QStringLiteral("modified_line_up"));
     a->setText(i18n("Move to Previous Modified Line"));
     a->setWhatsThis(i18n("Move upwards to the previous modified line."));
     connect(a, SIGNAL(triggered(bool)), SLOT(toPrevModifiedLine()));
 
     a = ac->addAction(QStringLiteral("modified_line_down"));
     a->setText(i18n("Move to Next Modified Line"));
     a->setWhatsThis(i18n("Move downwards to the next modified line."));
     connect(a, SIGNAL(triggered(bool)), SLOT(toNextModifiedLine()));
 
     a = ac->addAction(QStringLiteral("set_confdlg"));
     a->setText(i18n("&Configure Editor..."));
     a->setIcon(QIcon::fromTheme(QStringLiteral("preferences-other")));
     a->setWhatsThis(i18n("Configure various aspects of this editor."));
     connect(a, SIGNAL(triggered(bool)), SLOT(slotConfigDialog()));
 
     m_modeAction = new KateModeMenu(i18n("&Mode"), this);
     ac->addAction(QStringLiteral("tools_mode"), m_modeAction);
     m_modeAction->setWhatsThis(i18n("Here you can choose which mode should be used for the current document. This will influence the highlighting and folding being used, for example."));
     m_modeAction->updateMenu(m_doc);
 
     KateHighlightingMenu *menu = new KateHighlightingMenu(i18n("&Highlighting"), this);
     ac->addAction(QStringLiteral("tools_highlighting"), menu);
     menu->setWhatsThis(i18n("Here you can choose how the current document should be highlighted."));
     menu->updateMenu(m_doc);
 
     KateViewSchemaAction *schemaMenu = new KateViewSchemaAction(i18n("&Schema"), this);
     ac->addAction(QStringLiteral("view_schemas"), schemaMenu);
     schemaMenu->updateMenu(this);
 
     // indentation menu
     KateViewIndentationAction *indentMenu = new KateViewIndentationAction(m_doc, i18n("&Indentation"), this);
     ac->addAction(QStringLiteral("tools_indentation"), indentMenu);
 
     m_selectAll = a = ac->addAction(KStandardAction::SelectAll, this, SLOT(selectAll()));
     a->setWhatsThis(i18n("Select the entire text of the current document."));
 
     m_deSelect = a = ac->addAction(KStandardAction::Deselect, this, SLOT(clearSelection()));
     a->setWhatsThis(i18n("If you have selected something within the current document, this will no longer be selected."));
 
     a = ac->addAction(QStringLiteral("view_inc_font_sizes"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("zoom-in")));
     a->setText(i18n("Enlarge Font"));
     ac->setDefaultShortcuts(a, KStandardShortcut::zoomIn());
     a->setWhatsThis(i18n("This increases the display font size."));
     connect(a, SIGNAL(triggered(bool)), m_viewInternal, SLOT(slotIncFontSizes()));
 
     a = ac->addAction(QStringLiteral("view_dec_font_sizes"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("zoom-out")));
     a->setText(i18n("Shrink Font"));
     ac->setDefaultShortcuts(a, KStandardShortcut::zoomOut());
     a->setWhatsThis(i18n("This decreases the display font size."));
     connect(a, SIGNAL(triggered(bool)), m_viewInternal, SLOT(slotDecFontSizes()));
 
     a = m_toggleBlockSelection = new KToggleAction(i18n("Bl&ock Selection Mode"), this);
     ac->addAction(QStringLiteral("set_verticalSelect"), a);
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_B));
     a->setWhatsThis(i18n("This command allows switching between the normal (line based) selection mode and the block selection mode."));
     connect(a, SIGNAL(triggered(bool)), SLOT(toggleBlockSelection()));
 
     a = ac->addAction(QStringLiteral("switch_next_input_mode"));
     a->setText(i18n("Switch to Next Input Mode"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_V));
     a->setWhatsThis(i18n("Switch to the next input mode."));
     connect(a, SIGNAL(triggered(bool)), SLOT(cycleInputMode()));
 
     a = m_toggleInsert = new KToggleAction(i18n("Overwr&ite Mode"), this);
     ac->addAction(QStringLiteral("set_insert"), a);
     ac->setDefaultShortcut(a, QKeySequence(Qt::Key_Insert));
     a->setWhatsThis(i18n("Choose whether you want the text you type to be inserted or to overwrite existing text."));
     connect(a, SIGNAL(triggered(bool)), SLOT(toggleInsert()));
 
     KToggleAction *toggleAction;
     a = m_toggleDynWrap = toggleAction = new KToggleAction(i18n("&Dynamic Word Wrap"), this);
     ac->addAction(QStringLiteral("view_dynamic_word_wrap"), a);
     ac->setDefaultShortcut(a, QKeySequence(Qt::Key_F10));
     a->setWhatsThis(i18n("If this option is checked, the text lines will be wrapped at the view border on the screen.<br /><br />"
                          "This is only a view option, meaning the document will not changed."));
     connect(a, SIGNAL(triggered(bool)), SLOT(toggleDynWordWrap()));
 
     a = m_setDynWrapIndicators = new KSelectAction(i18n("Dynamic Word Wrap Indicators"), this);
     ac->addAction(QStringLiteral("dynamic_word_wrap_indicators"), a);
     a->setWhatsThis(i18n("Choose when the Dynamic Word Wrap Indicators should be displayed"));
     connect(m_setDynWrapIndicators, SIGNAL(triggered(int)), this, SLOT(setDynWrapIndicators(int)));
     const QStringList list2{ i18n("&Off"), i18n("Follow &Line Numbers"), i18n("&Always On") };
     m_setDynWrapIndicators->setItems(list2);
     m_setDynWrapIndicators->setEnabled(m_toggleDynWrap->isChecked()); // only synced on real change, later
 
     a = toggleAction = new KToggleAction(i18n("Static Word Wrap"), this);
     ac->addAction(QStringLiteral("view_static_word_wrap"), a);
     a->setWhatsThis(i18n("If this option is checked, the text lines will be wrapped at the column defined in the editing properties."));
     connect(a, &KToggleAction::triggered, [=] { if (m_doc) { m_doc->setWordWrap(!m_doc->wordWrap()); }});
 
     a = toggleAction = m_toggleWWMarker = new KToggleAction(i18n("Show Static &Word Wrap Marker"), this);
     ac->addAction(QStringLiteral("view_word_wrap_marker"), a);
     a->setWhatsThis(i18n("Show/hide the Word Wrap Marker, a vertical line drawn at the word "
                          "wrap column as defined in the editing properties"));
     connect(a, SIGNAL(triggered(bool)), SLOT(toggleWWMarker()));
 
     a = toggleAction = m_toggleFoldingMarkers = new KToggleAction(i18n("Show Folding &Markers"), this);
     ac->addAction(QStringLiteral("view_folding_markers"), a);
     ac->setDefaultShortcut(a, QKeySequence(Qt::Key_F9));
     a->setWhatsThis(i18n("You can choose if the codefolding marks should be shown, if codefolding is possible."));
     connect(a, SIGNAL(triggered(bool)), SLOT(toggleFoldingMarkers()));
 
     a = m_toggleIconBar = toggleAction = new KToggleAction(i18n("Show &Icon Border"), this);
     ac->addAction(QStringLiteral("view_border"), a);
     ac->setDefaultShortcut(a, QKeySequence(Qt::Key_F6));
     a->setWhatsThis(i18n("Show/hide the icon border.<br /><br />The icon border shows bookmark symbols, for instance."));
     connect(a, SIGNAL(triggered(bool)), SLOT(toggleIconBorder()));
 
     a = toggleAction = m_toggleLineNumbers = new KToggleAction(i18n("Show &Line Numbers"), this);
     ac->addAction(QStringLiteral("view_line_numbers"), a);
     ac->setDefaultShortcut(a, QKeySequence(Qt::Key_F11));
     a->setWhatsThis(i18n("Show/hide the line numbers on the left hand side of the view."));
     connect(a, SIGNAL(triggered(bool)), SLOT(toggleLineNumbersOn()));
 
     a = m_toggleScrollBarMarks = toggleAction = new KToggleAction(i18n("Show Scroll&bar Marks"), this);
     ac->addAction(QStringLiteral("view_scrollbar_marks"), a);
     a->setWhatsThis(i18n("Show/hide the marks on the vertical scrollbar.<br /><br />The marks show bookmarks, for instance."));
     connect(a, SIGNAL(triggered(bool)), SLOT(toggleScrollBarMarks()));
 
     a = m_toggleScrollBarMiniMap = toggleAction = new KToggleAction(i18n("Show Scrollbar Mini-Map"), this);
     ac->addAction(QStringLiteral("view_scrollbar_minimap"), a);
     a->setWhatsThis(i18n("Show/hide the mini-map on the vertical scrollbar.<br /><br />The mini-map shows an overview of the whole document."));
     connect(a, SIGNAL(triggered(bool)), SLOT(toggleScrollBarMiniMap()));
 
     a = m_doc->autoReloadToggleAction();
     ac->addAction(QStringLiteral("view_auto_reload"), a);
 
 //   a = m_toggleScrollBarMiniMapAll = toggleAction = new KToggleAction(i18n("Show the whole document in the Mini-Map"), this);
 //   ac->addAction(QLatin1String("view_scrollbar_minimap_all"), a);
 //   a->setWhatsThis(i18n("Display the whole document in the mini-map.<br /><br />With this option set the whole document will be visible in the mini-map."));
 //   connect(a, SIGNAL(triggered(bool)), SLOT(toggleScrollBarMiniMapAll()));
 //   connect(m_toggleScrollBarMiniMap, SIGNAL(triggered(bool)), m_toggleScrollBarMiniMapAll, SLOT(setEnabled(bool)));
 
     a = m_toggleNPSpaces = new KToggleAction(i18n("Show Non-Printable Spaces"), this);
     ac->addAction(QStringLiteral("view_non_printable_spaces"), a);
     a->setWhatsThis(i18n("Show/hide bounding box around non-printable spaces"));
     connect(a, SIGNAL(triggered(bool)), SLOT(toggleNPSpaces()));
 
     a = m_switchCmdLine = ac->addAction(QStringLiteral("switch_to_cmd_line"));
     a->setText(i18n("Switch to Command Line"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::Key_F7));
     a->setWhatsThis(i18n("Show/hide the command line on the bottom of the view."));
     connect(a, SIGNAL(triggered(bool)), SLOT(switchToCmdLine()));
 
     KActionMenu *am = new KActionMenu(i18n("Input Modes"), this);
     m_inputModeActions = new QActionGroup(am);
     ac->addAction(QStringLiteral("view_input_modes"), am);
 
     Q_FOREACH(KateAbstractInputMode *mode, m_viewInternal->m_inputModes) {
         a = new QAction(mode->viewInputModeHuman(), m_inputModeActions);
         am->addAction(a);
         a->setWhatsThis(i18n("Activate/deactivate %1", mode->viewInputModeHuman()));
         const InputMode im = mode->viewInputMode();
         a->setData(static_cast<int>(im));
         a->setCheckable(true);
         if (im == m_config->inputMode())
             a->setChecked(true);
         connect(a, SIGNAL(triggered()), SLOT(toggleInputMode()));
     }
 
     a = m_setEndOfLine = new KSelectAction(i18n("&End of Line"), this);
     ac->addAction(QStringLiteral("set_eol"), a);
     a->setWhatsThis(i18n("Choose which line endings should be used, when you save the document"));
     const QStringList list {
           i18nc("@item:inmenu End of Line", "&UNIX")
         , i18nc("@item:inmenu End of Line", "&Windows/DOS")
         , i18nc("@item:inmenu End of Line", "&Macintosh")
     };
     m_setEndOfLine->setItems(list);
     m_setEndOfLine->setCurrentItem(doc()->config()->eol());
     connect(m_setEndOfLine, SIGNAL(triggered(int)), this, SLOT(setEol(int)));
 
     a = m_addBom = new KToggleAction(i18n("Add &Byte Order Mark (BOM)"), this);
     m_addBom->setChecked(doc()->config()->bom());
     ac->addAction(QStringLiteral("add_bom"), a);
     a->setWhatsThis(i18n("Enable/disable adding of byte order marks for UTF-8/UTF-16 encoded files while saving"));
     connect(m_addBom, SIGNAL(triggered(bool)), this, SLOT(setAddBom(bool)));
 
     // encoding menu
     m_encodingAction = new KateViewEncodingAction(m_doc, this, i18n("E&ncoding"), this);
     ac->addAction(QStringLiteral("set_encoding"), m_encodingAction);
 
     a = ac->addAction(KStandardAction::Find, this, SLOT(find()));
     a->setWhatsThis(i18n("Look up the first occurrence of a piece of text or regular expression."));
     addAction(a);
 
     a = ac->addAction(QStringLiteral("edit_find_selected"));
     a->setText(i18n("Find Selected"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_H));
     a->setWhatsThis(i18n("Finds next occurrence of selected text."));
     connect(a, SIGNAL(triggered(bool)), SLOT(findSelectedForwards()));
 
     a = ac->addAction(QStringLiteral("edit_find_selected_backwards"));
     a->setText(i18n("Find Selected Backwards"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_H));
     a->setWhatsThis(i18n("Finds previous occurrence of selected text."));
     connect(a, SIGNAL(triggered(bool)), SLOT(findSelectedBackwards()));
 
     a = ac->addAction(KStandardAction::FindNext, this, SLOT(findNext()));
     a->setWhatsThis(i18n("Look up the next occurrence of the search phrase."));
     addAction(a);
 
     a = ac->addAction(KStandardAction::FindPrev, QStringLiteral("edit_find_prev"), this, SLOT(findPrevious()));
     a->setWhatsThis(i18n("Look up the previous occurrence of the search phrase."));
     addAction(a);
 
     a = ac->addAction(KStandardAction::Replace, this, SLOT(replace()));
     a->setWhatsThis(i18n("Look up a piece of text or regular expression and replace the result with some given text."));
 
     m_spell->createActions(ac);
     m_toggleOnTheFlySpellCheck = new KToggleAction(i18n("Automatic Spell Checking"), this);
     m_toggleOnTheFlySpellCheck->setWhatsThis(i18n("Enable/disable automatic spell checking"));
     connect(m_toggleOnTheFlySpellCheck, SIGNAL(triggered(bool)), SLOT(toggleOnTheFlySpellCheck(bool)));
     ac->addAction(QStringLiteral("tools_toggle_automatic_spell_checking"), m_toggleOnTheFlySpellCheck);
     ac->setDefaultShortcut(m_toggleOnTheFlySpellCheck, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_O));
 
     a = ac->addAction(QStringLiteral("tools_change_dictionary"));
     a->setText(i18n("Change Dictionary..."));
     a->setWhatsThis(i18n("Change the dictionary that is used for spell checking."));
     connect(a, SIGNAL(triggered()), SLOT(changeDictionary()));
 
     a = ac->addAction(QStringLiteral("tools_clear_dictionary_ranges"));
     a->setText(i18n("Clear Dictionary Ranges"));
     a->setEnabled(false);
     a->setWhatsThis(i18n("Remove all the separate dictionary ranges that were set for spell checking."));
     connect(a, SIGNAL(triggered()), m_doc, SLOT(clearDictionaryRanges()));
     connect(m_doc, SIGNAL(dictionaryRangesPresent(bool)), a, SLOT(setEnabled(bool)));
 
     m_copyHtmlAction = ac->addAction(QStringLiteral("edit_copy_html"), this, SLOT(exportHtmlToClipboard()));
     m_copyHtmlAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy")));
     m_copyHtmlAction->setText(i18n("Copy as &HTML"));
     m_copyHtmlAction->setWhatsThis(i18n("Use this command to copy the currently selected text as HTML to the system clipboard."));
 
     a = ac->addAction(QStringLiteral("file_export_html"), this, SLOT(exportHtmlToFile()));
     a->setIcon(QIcon::fromTheme(QStringLiteral("document-export")));
     a->setText(i18n("E&xport as HTML..."));
     a->setWhatsThis(i18n("This command allows you to export the current document"
                         " with all highlighting information into a HTML document."));
 
     m_spellingMenu->createActions(ac);
 
     m_bookmarks->createActions(ac);
 
     slotSelectionChanged();
 
     //Now setup the editing actions before adding the associated
     //widget and setting the shortcut context
     setupEditActions();
     setupCodeFolding();
     slotClipboardHistoryChanged();
 
     ac->addAssociatedWidget(m_viewInternal);
 
     foreach (QAction *action, ac->actions()) {
         action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     }
 
     connect(this, SIGNAL(selectionChanged(KTextEditor::View*)), this, SLOT(slotSelectionChanged()));
 }
 
 void KTextEditor::ViewPrivate::slotConfigDialog()
 {
     // invoke config dialog, will auto-save configuration to katepartrc
     KTextEditor::EditorPrivate::self()->configDialog(this);
 }
 
 void KTextEditor::ViewPrivate::setupEditActions()
 {
     //If you add an editing action to this
     //function make sure to include the line
     //m_editActions << a after creating the action
     KActionCollection *ac = actionCollection();
 
     QAction *a = ac->addAction(QStringLiteral("word_left"));
     a->setText(i18n("Move Word Left"));
     ac->setDefaultShortcuts(a, KStandardShortcut::backwardWord());
     connect(a, SIGNAL(triggered(bool)),  SLOT(wordLeft()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_char_left"));
     a->setText(i18n("Select Character Left"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::Key_Left));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftCursorLeft()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_word_left"));
     a->setText(i18n("Select Word Left"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::CTRL + Qt::Key_Left));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftWordLeft()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("word_right"));
     a->setText(i18n("Move Word Right"));
     ac->setDefaultShortcuts(a, KStandardShortcut::forwardWord());
     connect(a, SIGNAL(triggered(bool)), SLOT(wordRight()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_char_right"));
     a->setText(i18n("Select Character Right"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::Key_Right));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftCursorRight()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_word_right"));
     a->setText(i18n("Select Word Right"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::CTRL + Qt::Key_Right));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftWordRight()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("beginning_of_line"));
     a->setText(i18n("Move to Beginning of Line"));
     ac->setDefaultShortcuts(a, KStandardShortcut::beginningOfLine());
     connect(a, SIGNAL(triggered(bool)), SLOT(home()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("beginning_of_document"));
     a->setText(i18n("Move to Beginning of Document"));
     ac->setDefaultShortcuts(a, KStandardShortcut::begin());
     connect(a, SIGNAL(triggered(bool)), SLOT(top()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_beginning_of_line"));
     a->setText(i18n("Select to Beginning of Line"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::Key_Home));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftHome()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_beginning_of_document"));
     a->setText(i18n("Select to Beginning of Document"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::CTRL + Qt::Key_Home));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftTop()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("end_of_line"));
     a->setText(i18n("Move to End of Line"));
     ac->setDefaultShortcuts(a, KStandardShortcut::endOfLine());
     connect(a, SIGNAL(triggered(bool)), SLOT(end()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("end_of_document"));
     a->setText(i18n("Move to End of Document"));
     ac->setDefaultShortcuts(a, KStandardShortcut::end());
     connect(a, SIGNAL(triggered(bool)), SLOT(bottom()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_end_of_line"));
     a->setText(i18n("Select to End of Line"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::Key_End));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftEnd()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_end_of_document"));
     a->setText(i18n("Select to End of Document"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::CTRL + Qt::Key_End));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftBottom()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_line_up"));
     a->setText(i18n("Select to Previous Line"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::Key_Up));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftUp()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("scroll_line_up"));
     a->setText(i18n("Scroll Line Up"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_Up));
     connect(a, SIGNAL(triggered(bool)), SLOT(scrollUp()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("move_line_down"));
     a->setText(i18n("Move to Next Line"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::Key_Down));
     connect(a, SIGNAL(triggered(bool)), SLOT(down()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("move_line_up"));
     a->setText(i18n("Move to Previous Line"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::Key_Up));
     connect(a, SIGNAL(triggered(bool)), SLOT(up()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("move_cursor_right"));
     a->setText(i18n("Move Cursor Right"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::Key_Right));
     connect(a, SIGNAL(triggered(bool)), SLOT(cursorRight()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("move_cursor_left"));
     a->setText(i18n("Move Cursor Left"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::Key_Left));
     connect(a, SIGNAL(triggered(bool)), SLOT(cursorLeft()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_line_down"));
     a->setText(i18n("Select to Next Line"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::Key_Down));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftDown()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("scroll_line_down"));
     a->setText(i18n("Scroll Line Down"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_Down));
     connect(a, SIGNAL(triggered(bool)), SLOT(scrollDown()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("scroll_page_up"));
     a->setText(i18n("Scroll Page Up"));
     ac->setDefaultShortcuts(a, KStandardShortcut::prior());
     connect(a, SIGNAL(triggered(bool)), SLOT(pageUp()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_page_up"));
     a->setText(i18n("Select Page Up"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::Key_PageUp));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftPageUp()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("move_top_of_view"));
     a->setText(i18n("Move to Top of View"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_PageUp));
     connect(a, SIGNAL(triggered(bool)), SLOT(topOfView()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_top_of_view"));
     a->setText(i18n("Select to Top of View"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::SHIFT +  Qt::Key_PageUp));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftTopOfView()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("scroll_page_down"));
     a->setText(i18n("Scroll Page Down"));
     ac->setDefaultShortcuts(a, KStandardShortcut::next());
     connect(a, SIGNAL(triggered(bool)), SLOT(pageDown()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_page_down"));
     a->setText(i18n("Select Page Down"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::Key_PageDown));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftPageDown()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("move_bottom_of_view"));
     a->setText(i18n("Move to Bottom of View"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_PageDown));
     connect(a, SIGNAL(triggered(bool)), SLOT(bottomOfView()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_bottom_of_view"));
     a->setText(i18n("Select to Bottom of View"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_PageDown));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftBottomOfView()));
     m_editActions << a;
 
     a = ac->addAction(QStringLiteral("to_matching_bracket"));
     a->setText(i18n("Move to Matching Bracket"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_6));
     connect(a, SIGNAL(triggered(bool)), SLOT(toMatchingBracket()));
     //m_editActions << a;
 
     a = ac->addAction(QStringLiteral("select_matching_bracket"));
     a->setText(i18n("Select to Matching Bracket"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::SHIFT + Qt::CTRL + Qt::Key_6));
     connect(a, SIGNAL(triggered(bool)), SLOT(shiftToMatchingBracket()));
     //m_editActions << a;
 
     // anders: shortcuts doing any changes should not be created in read-only mode
     if (!doc()->readOnly()) {
         a = ac->addAction(QStringLiteral("transpose_char"));
         a->setText(i18n("Transpose Characters"));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_T));
         connect(a, SIGNAL(triggered(bool)), SLOT(transpose()));
         m_editActions << a;
 
         a = ac->addAction(QStringLiteral("delete_line"));
         a->setText(i18n("Delete Line"));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_K));
         connect(a, SIGNAL(triggered(bool)), SLOT(killLine()));
         m_editActions << a;
 
         a = ac->addAction(QStringLiteral("delete_word_left"));
         a->setText(i18n("Delete Word Left"));
         ac->setDefaultShortcuts(a, KStandardShortcut::deleteWordBack());
         connect(a, SIGNAL(triggered(bool)), SLOT(deleteWordLeft()));
         m_editActions << a;
 
         a = ac->addAction(QStringLiteral("delete_word_right"));
         a->setText(i18n("Delete Word Right"));
         ac->setDefaultShortcuts(a, KStandardShortcut::deleteWordForward());
         connect(a, SIGNAL(triggered(bool)), SLOT(deleteWordRight()));
         m_editActions << a;
 
         a = ac->addAction(QStringLiteral("delete_next_character"));
         a->setText(i18n("Delete Next Character"));
         ac->setDefaultShortcut(a, QKeySequence(Qt::Key_Delete));
         connect(a, SIGNAL(triggered(bool)), SLOT(keyDelete()));
         m_editActions << a;
 
         a = ac->addAction(QStringLiteral("backspace"));
         a->setText(i18n("Backspace"));
         QList<QKeySequence> scuts;
         scuts << QKeySequence(Qt::Key_Backspace)
               << QKeySequence(Qt::SHIFT + Qt::Key_Backspace);
         ac->setDefaultShortcuts(a, scuts);
         connect(a, SIGNAL(triggered(bool)), SLOT(backspace()));
         m_editActions << a;
 
         a = ac->addAction(QStringLiteral("insert_tabulator"));
         a->setText(i18n("Insert Tab"));
         connect(a, SIGNAL(triggered(bool)), SLOT(insertTab()));
         m_editActions << a;
 
         a = ac->addAction(QStringLiteral("smart_newline"));
         a->setText(i18n("Insert Smart Newline"));
         a->setWhatsThis(i18n("Insert newline including leading characters of the current line which are not letters or numbers."));
         scuts.clear();
         scuts << QKeySequence(Qt::SHIFT + Qt::Key_Return)
               << QKeySequence(Qt::SHIFT + Qt::Key_Enter);
         ac->setDefaultShortcuts(a, scuts);
         connect(a, SIGNAL(triggered(bool)), SLOT(smartNewline()));
         m_editActions << a;
 
         a = ac->addAction(QStringLiteral("tools_indent"));
         a->setIcon(QIcon::fromTheme(QStringLiteral("format-indent-more")));
         a->setText(i18n("&Indent"));
         a->setWhatsThis(i18n("Use this to indent a selected block of text.<br /><br />"
                              "You can configure whether tabs should be honored and used or replaced with spaces, in the configuration dialog."));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_I));
         connect(a, SIGNAL(triggered(bool)), SLOT(indent()));
 
         a = ac->addAction(QStringLiteral("tools_unindent"));
         a->setIcon(QIcon::fromTheme(QStringLiteral("format-indent-less")));
         a->setText(i18n("&Unindent"));
         a->setWhatsThis(i18n("Use this to unindent a selected block of text."));
         ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_I));
         connect(a, SIGNAL(triggered(bool)), SLOT(unIndent()));
     }
 
     if (hasFocus()) {
         slotGotFocus();
     } else {
         slotLostFocus();
     }
 }
 
 void KTextEditor::ViewPrivate::setupCodeFolding()
 {
     KActionCollection *ac = this->actionCollection();
     QAction *a;
 
     a = ac->addAction(QStringLiteral("folding_toplevel"));
     a->setText(i18n("Fold Toplevel Nodes"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Minus));
     connect(a, SIGNAL(triggered(bool)), SLOT(slotFoldToplevelNodes()));
 
     a = ac->addAction(QLatin1String("folding_expandtoplevel"));
     a->setText(i18n("Unfold Toplevel Nodes"));
     ac->setDefaultShortcut(a, QKeySequence(Qt::CTRL+Qt::SHIFT+Qt::Key_Plus));
     connect(a, SIGNAL(triggered(bool)), SLOT(slotExpandToplevelNodes()));
 
     /*a = ac->addAction(QLatin1String("folding_expandall"));
     a->setText(i18n("Unfold All Nodes"));
     connect(a, SIGNAL(triggered(bool)), doc()->foldingTree(), SLOT(expandAll()));
 
     a = ac->addAction(QLatin1String("folding_collapse_dsComment"));
     a->setText(i18n("Fold Multiline Comments"));
     connect(a, SIGNAL(triggered(bool)), doc()->foldingTree(), SLOT(collapseAll_dsComments()));
     */
     a = ac->addAction(QStringLiteral("folding_collapselocal"));
     a->setText(i18n("Fold Current Node"));
     connect(a, SIGNAL(triggered(bool)), SLOT(slotCollapseLocal()));
 
     a = ac->addAction(QStringLiteral("folding_expandlocal"));
     a->setText(i18n("Unfold Current Node"));
     connect(a, SIGNAL(triggered(bool)), SLOT(slotExpandLocal()));
 }
 
 void KTextEditor::ViewPrivate::slotFoldToplevelNodes()
 {
     for (int line = 0; line < doc()->lines(); ++line) {
         if (textFolding().isLineVisible(line)) {
             foldLine(line);
         }
     }
 }
 
 void KTextEditor::ViewPrivate::slotExpandToplevelNodes()
 {
     const auto topLevelRanges(textFolding().foldingRangesForParentRange());
     for (const auto &range : topLevelRanges) {
         textFolding().unfoldRange(range.first);
     }
 }
 
 void KTextEditor::ViewPrivate::slotCollapseLocal()
 {
     foldLine(cursorPosition().line());
 }
 
 void KTextEditor::ViewPrivate::slotExpandLocal()
 {
     unfoldLine(cursorPosition().line());
 }
 
 void KTextEditor::ViewPrivate::foldLine(int startLine)
 {
     // only for valid lines
     if (startLine < 0 || startLine >= doc()->buffer().lines()) {
         return;
     }
 
     // try to fold all known ranges
     QVector<QPair<qint64, Kate::TextFolding::FoldingRangeFlags> > startingRanges = textFolding().foldingRangesStartingOnLine(startLine);
     for (int i = 0; i < startingRanges.size(); ++i) {
         textFolding().foldRange(startingRanges[i].first);
     }
 
     // try if the highlighting can help us and create a fold
     textFolding().newFoldingRange(doc()->buffer().computeFoldingRangeForStartLine(startLine), Kate::TextFolding::Folded);
 }
 
 void KTextEditor::ViewPrivate::unfoldLine(int startLine)
 {
     // only for valid lines
     if (startLine < 0 || startLine >= doc()->buffer().lines()) {
         return;
     }
 
     // try to unfold all known ranges
     QVector<QPair<qint64, Kate::TextFolding::FoldingRangeFlags> > startingRanges = textFolding().foldingRangesStartingOnLine(startLine);
     for (int i = 0; i < startingRanges.size(); ++i) {
         textFolding().unfoldRange(startingRanges[i].first);
     }
 }
 
 KTextEditor::View::ViewMode KTextEditor::ViewPrivate::viewMode() const
 {
     return currentInputMode()->viewMode();
 }
 
 QString KTextEditor::ViewPrivate::viewModeHuman() const
 {
     QString currentMode = currentInputMode()->viewModeHuman();
 
     /**
      * append read-only if needed
      */
     if (!doc()->isReadWrite()) {
         currentMode = i18n("(R/O) %1", currentMode);
     }
 
     /**
      * return full mode
      */
     return currentMode;
 }
 
 KTextEditor::View::InputMode KTextEditor::ViewPrivate::viewInputMode() const
 {
     return currentInputMode()->viewInputMode();
 }
 
 QString KTextEditor::ViewPrivate::viewInputModeHuman() const
 {
     return currentInputMode()->viewInputModeHuman();
 }
 
 void KTextEditor::ViewPrivate::setInputMode(KTextEditor::View::InputMode mode)
 {
     if (currentInputMode()->viewInputMode() == mode) {
         return;
     }
 
     if (!m_viewInternal->m_inputModes.contains(mode)) {
         return;
     }
 
     m_viewInternal->m_currentInputMode->deactivate();
     m_viewInternal->m_currentInputMode = m_viewInternal->m_inputModes[mode];
     m_viewInternal->m_currentInputMode->activate();
 
     config()->setInputMode(mode); // TODO: this could be called from read config procedure, so it's not a good idea to set a specific view mode here
 
     /* small duplication, but need to do this if not toggled by action */
     Q_FOREACH(QAction *action, m_inputModeActions->actions()) {
         if (static_cast<InputMode>(action->data().toInt()) == mode) {
             action->setChecked(true);
             break;
         }
     }
 
     /* inform the rest of the system about the change */
     emit viewInputModeChanged(this, mode);
     emit viewModeChanged(this, viewMode());
 }
 
 void KTextEditor::ViewPrivate::slotDocumentAboutToReload()
 {
     if (doc()->isAutoReload()) {
         const int lastVisibleLine = m_viewInternal->endLine();
         const int currentLine = cursorPosition().line();
         m_gotoBottomAfterReload = (lastVisibleLine == currentLine) && (currentLine == doc()->lastLine());
         if (!m_gotoBottomAfterReload) {
             // Ensure the view jumps not back when user scrolls around
             const int firstVisibleLine = 1 + lastVisibleLine - m_viewInternal->linesDisplayed();
             const int newLine = qBound(firstVisibleLine, currentLine, lastVisibleLine);
             setCursorPositionVisual(KTextEditor::Cursor(newLine, cursorPosition().column()));
         }
     } else {
         m_gotoBottomAfterReload = false;
     }
 }
 
 void KTextEditor::ViewPrivate::slotDocumentReloaded()
 {
     if (m_gotoBottomAfterReload) {
         bottom();
     }
 }
 
 void KTextEditor::ViewPrivate::slotGotFocus()
 {
     //qCDebug(LOG_KTE) << "KTextEditor::ViewPrivate::slotGotFocus";
     currentInputMode()->gotFocus();
 
     /**
      *  update current view and scrollbars
      *  it is needed for styles that implement different frame and scrollbar
      * rendering when focused
      */
     update();
     if (m_viewInternal->m_lineScroll->isVisible()) {
         m_viewInternal->m_lineScroll->update();
     }
 
     if (m_viewInternal->m_columnScroll->isVisible()) {
         m_viewInternal->m_columnScroll->update();
     }
 
     emit focusIn(this);
 }
 
 void KTextEditor::ViewPrivate::slotLostFocus()
 {
     //qCDebug(LOG_KTE) << "KTextEditor::ViewPrivate::slotLostFocus";
     currentInputMode()->lostFocus();
 
     /**
      *  update current view and scrollbars
      *  it is needed for styles that implement different frame and scrollbar
      * rendering when focused
      */
     update();
     if (m_viewInternal->m_lineScroll->isVisible()) {
         m_viewInternal->m_lineScroll->update();
     }
 
     if (m_viewInternal->m_columnScroll->isVisible()) {
         m_viewInternal->m_columnScroll->update();
     }
 
     emit focusOut(this);
 }
 
 void KTextEditor::ViewPrivate::setDynWrapIndicators(int mode)
 {
     config()->setDynWordWrapIndicators(mode);
 }
 
 bool KTextEditor::ViewPrivate::isOverwriteMode() const
 {
     return doc()->config()->ovr();
 }
 
 void KTextEditor::ViewPrivate::reloadFile()
 {
     // bookmarks and cursor positions are temporarily saved by the document
     doc()->documentReload();
 }
 
 void KTextEditor::ViewPrivate::slotReadWriteChanged()
 {
     if (m_toggleWriteLock) {
         m_toggleWriteLock->setChecked(! doc()->isReadWrite());
     }
 
     m_cut->setEnabled(doc()->isReadWrite() && (selection() || m_config->smartCopyCut()));
     m_paste->setEnabled(doc()->isReadWrite());
     m_pasteMenu->setEnabled(doc()->isReadWrite() && !KTextEditor::EditorPrivate::self()->clipboardHistory().isEmpty());
     m_setEndOfLine->setEnabled(doc()->isReadWrite());
 
     static const auto l = {
           QStringLiteral("edit_replace")
         , QStringLiteral("tools_spelling")
         , QStringLiteral("tools_indent")
         , QStringLiteral("tools_unindent")
         , QStringLiteral("tools_cleanIndent")
         , QStringLiteral("tools_align")
         , QStringLiteral("tools_comment")
         , QStringLiteral("tools_uncomment")
         , QStringLiteral("tools_toggle_comment")
         , QStringLiteral("tools_uppercase")
         , QStringLiteral("tools_lowercase")
         , QStringLiteral("tools_capitalize")
         , QStringLiteral("tools_join_lines")
         , QStringLiteral("tools_apply_wordwrap")
         , QStringLiteral("tools_spelling_from_cursor")
         , QStringLiteral("tools_spelling_selection")
     };
 
     foreach (const auto &action, l) {
         QAction *a = actionCollection()->action(action);
         if (a) {
             a->setEnabled(doc()->isReadWrite());
         }
     }
     slotUpdateUndo();
 
     currentInputMode()->readWriteChanged(doc()->isReadWrite());
 
     // => view mode changed
     emit viewModeChanged(this, viewMode());
     emit viewInputModeChanged(this, viewInputMode());
 }
 
 void KTextEditor::ViewPrivate::slotClipboardHistoryChanged()
 {
     m_pasteMenu->setEnabled(doc()->isReadWrite() && !KTextEditor::EditorPrivate::self()->clipboardHistory().isEmpty());
 }
 
 void KTextEditor::ViewPrivate::slotUpdateUndo()
 {
     if (doc()->readOnly()) {
         return;
     }
 
     m_editUndo->setEnabled(doc()->isReadWrite() && doc()->undoCount() > 0);
     m_editRedo->setEnabled(doc()->isReadWrite() && doc()->redoCount() > 0);
 }
 
 bool KTextEditor::ViewPrivate::setCursorPositionInternal(const KTextEditor::Cursor &position, uint tabwidth, bool calledExternally)
 {
     Kate::TextLine l = doc()->kateTextLine(position.line());
 
     if (!l) {
         return false;
     }
 
     QString line_str = doc()->line(position.line());
 
     int x = 0;
     int z = 0;
     for (; z < line_str.length() && z < position.column(); z++) {
         if (line_str[z] == QLatin1Char('\t')) {
             x += tabwidth - (x % tabwidth);
         } else {
             x++;
         }
     }
 
     if (blockSelection())
         if (z < position.column()) {
             x += position.column() - z;
         }
 
-    m_viewInternal->updateCursor(KTextEditor::Cursor(position.line(), x), false, true, calledExternally);
+    m_viewInternal->updateCursor(KTextEditor::Cursor(position.line(), x), false, false, calledExternally);
 
     return true;
 }
 
 void KTextEditor::ViewPrivate::toggleInsert()
 {
     doc()->config()->setOvr(!doc()->config()->ovr());
     m_toggleInsert->setChecked(isOverwriteMode());
 
     emit viewModeChanged(this, viewMode());
     emit viewInputModeChanged(this, viewInputMode());
 }
 
 void KTextEditor::ViewPrivate::slotSaveCanceled(const QString &error)
 {
     if (!error.isEmpty()) { // happens when canceling a job
         KMessageBox::error(this, error);
     }
 }
 
 void KTextEditor::ViewPrivate::gotoLine()
 {
     gotoBar()->updateData();
     bottomViewBar()->showBarWidget(gotoBar());
 }
 
 void KTextEditor::ViewPrivate::changeDictionary()
 {
     dictionaryBar()->updateData();
     bottomViewBar()->showBarWidget(dictionaryBar());
 }
 
 void KTextEditor::ViewPrivate::joinLines()
 {
     int first = selectionRange().start().line();
     int last = selectionRange().end().line();
     //int left = doc()->line( last ).length() - doc()->selEndCol();
     if (first == last) {
         first = cursorPosition().line();
         last = first + 1;
     }
     doc()->joinLines(first, last);
 }
 
 void KTextEditor::ViewPrivate::readSessionConfig(const KConfigGroup &config, const QSet<QString> &flags)
 {
     Q_UNUSED(flags)
 
     // cursor position
     setCursorPositionInternal(KTextEditor::Cursor(config.readEntry("CursorLine", 0), config.readEntry("CursorColumn", 0)));
 
     // restore dyn word wrap if set for this view
     if (config.hasKey("Dynamic Word Wrap")) {
         m_config->setDynWordWrap(config.readEntry("Dynamic Word Wrap", false));
     }
 
     // restore text folding
     m_savedFoldingState = QJsonDocument::fromJson(config.readEntry("TextFolding", QByteArray()));
     applyFoldingState();
 
     Q_FOREACH(KateAbstractInputMode *mode, m_viewInternal->m_inputModes) {
         mode->readSessionConfig(config);
     }
 }
 
 void KTextEditor::ViewPrivate::writeSessionConfig(KConfigGroup &config, const QSet<QString> &flags)
 {
     Q_UNUSED(flags)
 
     // cursor position
     config.writeEntry("CursorLine", cursorPosition().line());
     config.writeEntry("CursorColumn", cursorPosition().column());
 
     // save dyn word wrap if set for this view
     if (m_config->dynWordWrapSet()) {
         config.writeEntry("Dynamic Word Wrap", m_config->dynWordWrap());
     }
 
     // save text folding state
     saveFoldingState();
     config.writeEntry("TextFolding", m_savedFoldingState.toJson(QJsonDocument::Compact));
     m_savedFoldingState = QJsonDocument();
 
     Q_FOREACH(KateAbstractInputMode *mode, m_viewInternal->m_inputModes) {
         mode->writeSessionConfig(config);
     }
 }
 
 int KTextEditor::ViewPrivate::getEol() const
 {
     return doc()->config()->eol();
 }
 
 void KTextEditor::ViewPrivate::setEol(int eol)
 {
     if (!doc()->isReadWrite()) {
         return;
     }
 
     if (m_updatingDocumentConfig) {
         return;
     }
 
     if (eol != doc()->config()->eol()) {
         doc()->setModified(true); // mark modified (bug #143120)
         doc()->config()->setEol(eol);
     }
 }
 
 void KTextEditor::ViewPrivate::setAddBom(bool enabled)
 {
     if (!doc()->isReadWrite()) {
         return;
     }
 
     if (m_updatingDocumentConfig) {
         return;
     }
 
     doc()->config()->setBom(enabled);
     doc()->bomSetByUser();
 }
 
 void KTextEditor::ViewPrivate::setIconBorder(bool enable)
 {
     config()->setIconBar(enable);
 }
 
 void KTextEditor::ViewPrivate::toggleIconBorder()
 {
     config()->setIconBar(!config()->iconBar());
 }
 
 void KTextEditor::ViewPrivate::setLineNumbersOn(bool enable)
 {
     config()->setLineNumbers(enable);
 }
 
 void KTextEditor::ViewPrivate::toggleLineNumbersOn()
 {
     config()->setLineNumbers(!config()->lineNumbers());
 }
 
 void KTextEditor::ViewPrivate::setScrollBarMarks(bool enable)
 {
     config()->setScrollBarMarks(enable);
 }
 
 void KTextEditor::ViewPrivate::toggleScrollBarMarks()
 {
     config()->setScrollBarMarks(!config()->scrollBarMarks());
 }
 
 void KTextEditor::ViewPrivate::setScrollBarMiniMap(bool enable)
 {
     config()->setScrollBarMiniMap(enable);
 }
 
 void KTextEditor::ViewPrivate::toggleScrollBarMiniMap()
 {
     config()->setScrollBarMiniMap(!config()->scrollBarMiniMap());
 }
 
 void KTextEditor::ViewPrivate::setScrollBarMiniMapAll(bool enable)
 {
     config()->setScrollBarMiniMapAll(enable);
 }
 
 void KTextEditor::ViewPrivate::toggleScrollBarMiniMapAll()
 {
     config()->setScrollBarMiniMapAll(!config()->scrollBarMiniMapAll());
 }
 
 void KTextEditor::ViewPrivate::setScrollBarMiniMapWidth(int width)
 {
     config()->setScrollBarMiniMapWidth(width);
 }
 
 void KTextEditor::ViewPrivate::toggleDynWordWrap()
 {
     config()->setDynWordWrap(!config()->dynWordWrap());
 }
 
 void KTextEditor::ViewPrivate::toggleWWMarker()
 {
     m_renderer->config()->setWordWrapMarker(!m_renderer->config()->wordWrapMarker());
 }
 
 void KTextEditor::ViewPrivate::toggleNPSpaces()
 {
     m_renderer->setShowNonPrintableSpaces(!m_renderer->showNonPrintableSpaces());
     m_viewInternal->update(); // force redraw
 }
 
 void KTextEditor::ViewPrivate::toggleWordCount(bool on)
 {
     config()->setShowWordCount(on);
 }
 
 void KTextEditor::ViewPrivate::setFoldingMarkersOn(bool enable)
 {
     config()->setFoldingBar(enable);
 }
 
 void KTextEditor::ViewPrivate::toggleFoldingMarkers()
 {
     config()->setFoldingBar(!config()->foldingBar());
 }
 
 bool KTextEditor::ViewPrivate::iconBorder()
 {
     return m_viewInternal->m_leftBorder->iconBorderOn();
 }
 
 bool KTextEditor::ViewPrivate::lineNumbersOn()
 {
     return m_viewInternal->m_leftBorder->lineNumbersOn();
 }
 
 bool KTextEditor::ViewPrivate::scrollBarMarks()
 {
     return m_viewInternal->m_lineScroll->showMarks();
 }
 
 bool KTextEditor::ViewPrivate::scrollBarMiniMap()
 {
     return m_viewInternal->m_lineScroll->showMiniMap();
 }
 
 int KTextEditor::ViewPrivate::dynWrapIndicators()
 {
     return m_viewInternal->m_leftBorder->dynWrapIndicators();
 }
 
 bool KTextEditor::ViewPrivate::foldingMarkersOn()
 {
     return m_viewInternal->m_leftBorder->foldingMarkersOn();
 }
 
 void KTextEditor::ViewPrivate::toggleWriteLock()
 {
     doc()->setReadWrite(! doc()->isReadWrite());
 }
 
 void KTextEditor::ViewPrivate::registerTextHintProvider(KTextEditor::TextHintProvider *provider)
 {
     m_viewInternal->registerTextHintProvider(provider);
 }
 
 void KTextEditor::ViewPrivate::unregisterTextHintProvider(KTextEditor::TextHintProvider *provider)
 {
     m_viewInternal->unregisterTextHintProvider(provider);
 }
 
 void KTextEditor::ViewPrivate::setTextHintDelay(int delay)
 {
     m_viewInternal->setTextHintDelay(delay);
 }
 
 int KTextEditor::ViewPrivate::textHintDelay() const
 {
     return m_viewInternal->textHintDelay();
 }
 
 void KTextEditor::ViewPrivate::find()
 {
     currentInputMode()->find();
 }
 
 void KTextEditor::ViewPrivate::findSelectedForwards()
 {
     currentInputMode()->findSelectedForwards();
 }
 
 void KTextEditor::ViewPrivate::findSelectedBackwards()
 {
     currentInputMode()->findSelectedBackwards();
 }
 
 void KTextEditor::ViewPrivate::replace()
 {
     currentInputMode()->findReplace();
 }
 
 void KTextEditor::ViewPrivate::findNext()
 {
     currentInputMode()->findNext();
 }
 
 void KTextEditor::ViewPrivate::findPrevious()
 {
     currentInputMode()->findPrevious();
 }
 
 void KTextEditor::ViewPrivate::slotSelectionChanged()
 {
     m_copy->setEnabled(selection() || m_config->smartCopyCut());
     m_deSelect->setEnabled(selection());
     m_copyHtmlAction->setEnabled (selection());
 
     // update highlighting of current selected word
     selectionChangedForHighlights ();
 
     if (doc()->readOnly()) {
         return;
     }
 
     m_cut->setEnabled(selection() || m_config->smartCopyCut());
 }
 
 void KTextEditor::ViewPrivate::switchToCmdLine()
 {
     currentInputMode()->activateCommandLine();
 }
 
 KateRenderer *KTextEditor::ViewPrivate::renderer()
 {
     return m_renderer;
 }
 
 void KTextEditor::ViewPrivate::updateConfig()
 {
     if (m_startingUp) {
         return;
     }
 
     // dyn. word wrap & markers
     if (m_hasWrap != config()->dynWordWrap()) {
         m_viewInternal->prepareForDynWrapChange();
 
         m_hasWrap = config()->dynWordWrap();
 
         m_viewInternal->dynWrapChanged();
 
         m_setDynWrapIndicators->setEnabled(config()->dynWordWrap());
         m_toggleDynWrap->setChecked(config()->dynWordWrap());
     }
 
     m_viewInternal->m_leftBorder->setDynWrapIndicators(config()->dynWordWrapIndicators());
     m_setDynWrapIndicators->setCurrentItem(config()->dynWordWrapIndicators());
 
     // line numbers
     m_viewInternal->m_leftBorder->setLineNumbersOn(config()->lineNumbers());
     m_toggleLineNumbers->setChecked(config()->lineNumbers());
 
     // icon bar
     m_viewInternal->m_leftBorder->setIconBorderOn(config()->iconBar());
     m_toggleIconBar->setChecked(config()->iconBar());
 
     // scrollbar marks
     m_viewInternal->m_lineScroll->setShowMarks(config()->scrollBarMarks());
     m_toggleScrollBarMarks->setChecked(config()->scrollBarMarks());
 
     // scrollbar mini-map
     m_viewInternal->m_lineScroll->setShowMiniMap(config()->scrollBarMiniMap());
     m_toggleScrollBarMiniMap->setChecked(config()->scrollBarMiniMap());
 
     // scrollbar mini-map - (whole document)
     m_viewInternal->m_lineScroll->setMiniMapAll(config()->scrollBarMiniMapAll());
     //m_toggleScrollBarMiniMapAll->setChecked( config()->scrollBarMiniMapAll() );
 
     // scrollbar mini-map.width
     m_viewInternal->m_lineScroll->setMiniMapWidth(config()->scrollBarMiniMapWidth());
 
     // misc edit
     m_toggleBlockSelection->setChecked(blockSelection());
     m_toggleInsert->setChecked(isOverwriteMode());
 
     updateFoldingConfig();
 
     // bookmark
     m_bookmarks->setSorting((KateBookmarks::Sorting) config()->bookmarkSort());
 
     m_viewInternal->setAutoCenterLines(config()->autoCenterLines());
 
     Q_FOREACH(KateAbstractInputMode *input, m_viewInternal->m_inputModes) {
         input->updateConfig();
     }
 
     setInputMode(config()->inputMode());
 
     reflectOnTheFlySpellCheckStatus(doc()->isOnTheFlySpellCheckingEnabled());
 
     // register/unregister word completion...
     bool wc = config()->wordCompletion();
     if (wc != isCompletionModelRegistered(KTextEditor::EditorPrivate::self()->wordCompletionModel())) {
         if (wc)
             registerCompletionModel(KTextEditor::EditorPrivate::self()->wordCompletionModel());
         else
             unregisterCompletionModel(KTextEditor::EditorPrivate::self()->wordCompletionModel());
     }
 
     bool kc = config()->keywordCompletion();
     if (kc != isCompletionModelRegistered(KTextEditor::EditorPrivate::self()->keywordCompletionModel())) {
         if (kc)
             registerCompletionModel(KTextEditor::EditorPrivate::self()->keywordCompletionModel());
         else
             unregisterCompletionModel (KTextEditor::EditorPrivate::self()->keywordCompletionModel());
     }
 
     m_cut->setEnabled(doc()->isReadWrite() && (selection() || m_config->smartCopyCut()));
     m_copy->setEnabled(selection() || m_config->smartCopyCut());
 
     // if not disabled, update status bar
     if (m_statusBar) {
         m_statusBar->updateStatus();
     }
 
     // now redraw...
     m_viewInternal->cache()->clear();
     tagAll();
     updateView(true);
 
     emit configChanged();
 }
 
 void KTextEditor::ViewPrivate::updateDocumentConfig()
 {
     if (m_startingUp) {
         return;
     }
 
     m_updatingDocumentConfig = true;
 
     m_setEndOfLine->setCurrentItem(doc()->config()->eol());
 
     m_addBom->setChecked(doc()->config()->bom());
 
     m_updatingDocumentConfig = false;
 
     // maybe block selection or wrap-cursor mode changed
     ensureCursorColumnValid();
 
     // first change this
     m_renderer->setTabWidth(doc()->config()->tabWidth());
     m_renderer->setIndentWidth(doc()->config()->indentationWidth());
 
     // now redraw...
     m_viewInternal->cache()->clear();
     tagAll();
     updateView(true);
 }
 
 void KTextEditor::ViewPrivate::updateRendererConfig()
 {
     if (m_startingUp) {
         return;
     }
 
     m_toggleWWMarker->setChecked(m_renderer->config()->wordWrapMarker());
 
     m_viewInternal->updateBracketMarkAttributes();
     m_viewInternal->updateBracketMarks();
 
     // now redraw...
     m_viewInternal->cache()->clear();
     tagAll();
     m_viewInternal->updateView(true);
 
     // update the left border right, for example linenumbers
     m_viewInternal->m_leftBorder->updateFont();
     m_viewInternal->m_leftBorder->repaint();
 
     m_viewInternal->m_lineScroll->queuePixmapUpdate();
 
     currentInputMode()->updateRendererConfig();
 
 // @@ showIndentLines is not cached anymore.
 //  m_renderer->setShowIndentLines (m_renderer->config()->showIndentationLines());
     emit configChanged();
 }
 
 void KTextEditor::ViewPrivate::updateFoldingConfig()
 {
     // folding bar
     m_viewInternal->m_leftBorder->setFoldingMarkersOn(config()->foldingBar());
     m_toggleFoldingMarkers->setChecked(config()->foldingBar());
 
     if (hasCommentInFirstLine(m_doc)) {
         if (config()->foldFirstLine() && !m_autoFoldedFirstLine) {
             foldLine(0);
             m_autoFoldedFirstLine = true;
        } else if (!config()->foldFirstLine() && m_autoFoldedFirstLine) {
             unfoldLine(0);
             m_autoFoldedFirstLine = false;
         }
     } else {
         m_autoFoldedFirstLine = false;
     }
 
 #if 0
     // FIXME: FOLDING
     const QStringList l = {
           QStringLiteral("folding_toplevel")
         , QStringLiteral("folding_expandtoplevel")
         , QStringLiteral("folding_collapselocal")
         , QStringLiteral("folding_expandlocal")
     };
 
     QAction *a = 0;
     for (int z = 0; z < l.size(); z++)
         if ((a = actionCollection()->action(l[z].toAscii().constData()))) {
             a->setEnabled(doc()->highlight() && doc()->highlight()->allowsFolding());
         }
 #endif
 }
 
 void KTextEditor::ViewPrivate::ensureCursorColumnValid()
 {
     KTextEditor::Cursor c = m_viewInternal->cursorPosition();
 
     // make sure the cursor is valid:
     // - in block selection mode or if wrap cursor is off, the column is arbitrary
     // - otherwise: it's bounded by the line length
     if (!blockSelection() && wrapCursor()
             && (!c.isValid() || c.column() > doc()->lineLength(c.line()))) {
         c.setColumn(doc()->kateTextLine(cursorPosition().line())->length());
         setCursorPosition(c);
     }
 }
 
 //BEGIN EDIT STUFF
 void KTextEditor::ViewPrivate::editStart()
 {
     m_viewInternal->editStart();
 }
 
 void KTextEditor::ViewPrivate::editEnd(int editTagLineStart, int editTagLineEnd, bool tagFrom)
 {
     m_viewInternal->editEnd(editTagLineStart, editTagLineEnd, tagFrom);
 }
 
 void KTextEditor::ViewPrivate::editSetCursor(const KTextEditor::Cursor &cursor)
 {
     m_viewInternal->editSetCursor(cursor);
 }
 //END
 
 //BEGIN TAG & CLEAR
 bool KTextEditor::ViewPrivate::tagLine(const KTextEditor::Cursor &virtualCursor)
 {
     return m_viewInternal->tagLine(virtualCursor);
 }
 
 bool KTextEditor::ViewPrivate::tagRange(const KTextEditor::Range &range, bool realLines)
 {
     return m_viewInternal->tagRange(range, realLines);
 }
 
 bool KTextEditor::ViewPrivate::tagLines(int start, int end, bool realLines)
 {
     return m_viewInternal->tagLines(start, end, realLines);
 }
 
 bool KTextEditor::ViewPrivate::tagLines(KTextEditor::Cursor start, KTextEditor::Cursor end, bool realCursors)
 {
     return m_viewInternal->tagLines(start, end, realCursors);
 }
 
 void KTextEditor::ViewPrivate::tagAll()
 {
     m_viewInternal->tagAll();
 }
 
 void KTextEditor::ViewPrivate::clear()
 {
     m_viewInternal->clear();
 }
 
 void KTextEditor::ViewPrivate::repaintText(bool paintOnlyDirty)
 {
     if (paintOnlyDirty) {
         m_viewInternal->updateDirty();
     } else {
         m_viewInternal->update();
     }
 }
 
 void KTextEditor::ViewPrivate::updateView(bool changed)
 {
     //qCDebug(LOG_KTE) << "KTextEditor::ViewPrivate::updateView";
 
     m_viewInternal->updateView(changed);
     m_viewInternal->m_leftBorder->update();
 }
 
 //END
 
 void KTextEditor::ViewPrivate::slotHlChanged()
 {
     KateHighlighting *hl = doc()->highlight();
     bool ok(!hl->getCommentStart(0).isEmpty() || !hl->getCommentSingleLineStart(0).isEmpty());
 
     if (actionCollection()->action(QStringLiteral("tools_comment"))) {
         actionCollection()->action(QStringLiteral("tools_comment"))->setEnabled(ok);
     }
 
     if (actionCollection()->action(QStringLiteral("tools_uncomment"))) {
         actionCollection()->action(QStringLiteral("tools_uncomment"))->setEnabled(ok);
     }
 
     if (actionCollection()->action(QStringLiteral("tools_toggle_comment"))) {
         actionCollection()->action(QStringLiteral("tools_toggle_comment"))->setEnabled(ok);
     }
 
     // show folding bar if "view defaults" says so, otherwise enable/disable only the menu entry
     updateFoldingConfig();
 }
 
 int KTextEditor::ViewPrivate::virtualCursorColumn() const
 {
     return doc()->toVirtualColumn(m_viewInternal->cursorPosition());
 }
 
 void KTextEditor::ViewPrivate::notifyMousePositionChanged(const KTextEditor::Cursor &newPosition)
 {
     emit mousePositionChanged(this, newPosition);
 }
 
 //BEGIN KTextEditor::SelectionInterface stuff
 
 bool KTextEditor::ViewPrivate::setSelection(const KTextEditor::Range &selection)
 {
     /**
      * anything to do?
      */
     if (selection == m_selection) {
         return true;
     }
 
     /**
      * backup old range
      */
     KTextEditor::Range oldSelection = m_selection;
 
     /**
      * set new range
      */
     m_selection.setRange(selection.isEmpty() ? KTextEditor::Range::invalid() : selection);
 
     /**
      * trigger update of correct area
      */
     tagSelection(oldSelection);
     repaintText(true);
 
     /**
      * emit holy signal
      */
     emit selectionChanged(this);
 
     /**
      * be done
      */
     return true;
 }
 
 bool KTextEditor::ViewPrivate::clearSelection()
 {
     return clearSelection(true);
 }
 
 bool KTextEditor::ViewPrivate::clearSelection(bool redraw, bool finishedChangingSelection)
 {
     /**
      * no selection, nothing to do...
      */
     if (!selection()) {
         return false;
     }
 
     /**
      * backup old range
      */
     KTextEditor::Range oldSelection = m_selection;
 
     /**
      * invalidate current selection
      */
     m_selection.setRange(KTextEditor::Range::invalid());
 
     /**
      * trigger update of correct area
      */
     tagSelection(oldSelection);
     if (redraw) {
         repaintText(true);
     }
 
     /**
      * emit holy signal
      */
     if (finishedChangingSelection) {
         emit selectionChanged(this);
     }
 
     /**
      * be done
      */
     return true;
 }
 
 bool KTextEditor::ViewPrivate::selection() const
 {
     if (!wrapCursor()) {
         return m_selection != KTextEditor::Range::invalid();
     } else {
         return m_selection.toRange().isValid();
     }
 }
 
 QString KTextEditor::ViewPrivate::selectionText() const
 {
     return doc()->text(m_selection, blockSelect);
 }
 
 bool KTextEditor::ViewPrivate::removeSelectedText()
 {
     if (!selection()) {
         return false;
     }
 
     doc()->editStart();
 
     // Optimization: clear selection before removing text
     KTextEditor::Range selection = m_selection;
 
     doc()->removeText(selection, blockSelect);
 
     // don't redraw the cleared selection - that's done in editEnd().
     if (blockSelect) {
         int selectionColumn = qMin(doc()->toVirtualColumn(selection.start()), doc()->toVirtualColumn(selection.end()));
         KTextEditor::Range newSelection = selection;
         newSelection.setStart(KTextEditor::Cursor(newSelection.start().line(), doc()->fromVirtualColumn(newSelection.start().line(), selectionColumn)));
         newSelection.setEnd(KTextEditor::Cursor(newSelection.end().line(), doc()->fromVirtualColumn(newSelection.end().line(), selectionColumn)));
         setSelection(newSelection);
         setCursorPositionInternal(newSelection.start());
     } else {
         clearSelection(false);
     }
 
     doc()->editEnd();
 
     return true;
 }
 
 bool KTextEditor::ViewPrivate::selectAll()
 {
     setBlockSelection(false);
     top();
     shiftBottom();
     return true;
 }
 
 bool KTextEditor::ViewPrivate::cursorSelected(const KTextEditor::Cursor &cursor)
 {
     KTextEditor::Cursor ret = cursor;
     if ((!blockSelect) && (ret.column() < 0)) {
         ret.setColumn(0);
     }
 
     if (blockSelect)
         return cursor.line() >= m_selection.start().line() && ret.line() <= m_selection.end().line()
                && ret.column() >= m_selection.start().column() && ret.column() <= m_selection.end().column();
     else {
         return m_selection.toRange().contains(cursor) || m_selection.end() == cursor;
     }
 }
 
 bool KTextEditor::ViewPrivate::lineSelected(int line)
 {
     return !blockSelect && m_selection.toRange().containsLine(line);
 }
 
 bool KTextEditor::ViewPrivate::lineEndSelected(const KTextEditor::Cursor &lineEndPos)
 {
     return (!blockSelect)
            && (lineEndPos.line() > m_selection.start().line() || (lineEndPos.line() == m_selection.start().line() && (m_selection.start().column() < lineEndPos.column() || lineEndPos.column() == -1)))
            && (lineEndPos.line() < m_selection.end().line() || (lineEndPos.line() == m_selection.end().line() && (lineEndPos.column() <= m_selection.end().column() && lineEndPos.column() != -1)));
 }
 
 bool KTextEditor::ViewPrivate::lineHasSelected(int line)
 {
     return selection() && m_selection.toRange().containsLine(line);
 }
 
 bool KTextEditor::ViewPrivate::lineIsSelection(int line)
 {
     return (line == m_selection.start().line() && line == m_selection.end().line());
 }
 
 void KTextEditor::ViewPrivate::tagSelection(const KTextEditor::Range &oldSelection)
 {
     if (selection()) {
         if (oldSelection.start().line() == -1) {
             // We have to tag the whole lot if
             // 1) we have a selection, and:
             //  a) it's new; or
             tagLines(m_selection, true);
 
         } else if (blockSelection() && (oldSelection.start().column() != m_selection.start().column() || oldSelection.end().column() != m_selection.end().column())) {
             //  b) we're in block selection mode and the columns have changed
             tagLines(m_selection, true);
             tagLines(oldSelection, true);
 
         } else {
             if (oldSelection.start() != m_selection.start()) {
                 if (oldSelection.start() < m_selection.start()) {
                     tagLines(oldSelection.start(), m_selection.start(), true);
                 } else {
                     tagLines(m_selection.start(), oldSelection.start(), true);
                 }
             }
 
             if (oldSelection.end() != m_selection.end()) {
                 if (oldSelection.end() < m_selection.end()) {
                     tagLines(oldSelection.end(), m_selection.end(), true);
                 } else {
                     tagLines(m_selection.end(), oldSelection.end(), true);
                 }
             }
         }
 
     } else {
         // No more selection, clean up
         tagLines(oldSelection, true);
     }
 }
 
 void KTextEditor::ViewPrivate::selectWord(const KTextEditor::Cursor &cursor)
 {
     setSelection(doc()->wordRangeAt(cursor));
 }
 
 void KTextEditor::ViewPrivate::selectLine(const KTextEditor::Cursor &cursor)
 {
     int line = cursor.line();
     if (line + 1 >= doc()->lines()) {
         setSelection(KTextEditor::Range(line, 0, line, doc()->lineLength(line)));
     } else {
         setSelection(KTextEditor::Range(line, 0, line + 1, 0));
     }
 }
 
 void KTextEditor::ViewPrivate::cut()
 {
     if (!selection() && !m_config->smartCopyCut()) {
         return;
     }
 
     copy();
     if (!selection()) {
         selectLine(cursorPosition());
     }
     removeSelectedText();
 }
 
 void KTextEditor::ViewPrivate::copy() const
 {
     QString text;
 
     if (!selection()) {
         if (!m_config->smartCopyCut()) {
             return;
         }
         text = doc()->line(cursorPosition().line()) + QLatin1Char('\n');
         m_viewInternal->moveEdge(KateViewInternal::left, false);
     } else {
         text = selectionText();
     }
 
     // copy to clipboard and our history!
     KTextEditor::EditorPrivate::self()->copyToClipboard(text);
 }
 
 void KTextEditor::ViewPrivate::applyWordWrap()
 {
     int first = selectionRange().start().line();
     int last  = selectionRange().end().line();
 
     if (first == last) {
         // Either no selection or only one line selected, wrap only the current line
         first = cursorPosition().line();
         last  = first;
     }
 
     doc()->wrapParagraph(first, last);
 }
 
 //END
 
 //BEGIN KTextEditor::BlockSelectionInterface stuff
 
 bool KTextEditor::ViewPrivate::blockSelection() const
 {
     return blockSelect;
 }
 
 bool KTextEditor::ViewPrivate::setBlockSelection(bool on)
 {
     if (on != blockSelect) {
         blockSelect = on;
 
         KTextEditor::Range oldSelection = m_selection;
 
         const bool hadSelection = clearSelection(false, false);
 
         setSelection(oldSelection);
 
         m_toggleBlockSelection->setChecked(blockSelection());
 
         // when leaving block selection mode, if cursor is at an invalid position or past the end of the
         // line, move the cursor to the last column of the current line unless cursor wrapping is off
         ensureCursorColumnValid();
 
         if (!hadSelection) {
             // emit selectionChanged() according to the KTextEditor::View api
             // documentation also if there is no selection around. This is needed,
             // as e.g. the Kate App status bar uses this signal to update the state
             // of the selection mode (block selection, line based selection)
             emit selectionChanged(this);
         }
     }
 
     return true;
 }
 
 bool KTextEditor::ViewPrivate::toggleBlockSelection()
 {
     m_toggleBlockSelection->setChecked(!blockSelect);
     return setBlockSelection(!blockSelect);
 }
 
 bool KTextEditor::ViewPrivate::wrapCursor() const
 {
     return !blockSelection();
 }
 
 //END
 
 void KTextEditor::ViewPrivate::slotTextInserted(KTextEditor::View *view, const KTextEditor::Cursor &position, const QString &text)
 {
     emit textInserted(view, position, text);
 }
 
 bool KTextEditor::ViewPrivate::insertTemplateInternal(const KTextEditor::Cursor& c,
                                                       const QString& templateString,
                                                       const QString& script)
 {
     /**
      * no empty templates
      */
     if (templateString.isEmpty()) {
         return false;
     }
 
     /**
      * not for read-only docs
      */
     if (!doc()->isReadWrite()) {
         return false;
     }
 
     /**
      * only one handler maybe active at a time; store it in the document.
      * Clear it first to make sure at no time two handlers are active at once
      */
     doc()->setActiveTemplateHandler(nullptr);
     doc()->setActiveTemplateHandler(new KateTemplateHandler(this, c, templateString, script, doc()->undoManager()));
     return true;
 }
 
 bool KTextEditor::ViewPrivate::tagLines(KTextEditor::Range range, bool realRange)
 {
     return tagLines(range.start(), range.end(), realRange);
 }
 
 void KTextEditor::ViewPrivate::deactivateEditActions()
 {
     foreach (QAction *action, m_editActions) {
         action->setEnabled(false);
     }
 }
 
 void KTextEditor::ViewPrivate::activateEditActions()
 {
     foreach (QAction *action, m_editActions) {
         action->setEnabled(true);
     }
 }
 
 bool KTextEditor::ViewPrivate::mouseTrackingEnabled() const
 {
     // FIXME support
     return true;
 }
 
 bool KTextEditor::ViewPrivate::setMouseTrackingEnabled(bool)
 {
     // FIXME support
     return true;
 }
 
 bool KTextEditor::ViewPrivate::isCompletionActive() const
 {
     return completionWidget()->isCompletionActive();
 }
 
 KateCompletionWidget *KTextEditor::ViewPrivate::completionWidget() const
 {
     if (!m_completionWidget) {
         m_completionWidget = new KateCompletionWidget(const_cast<KTextEditor::ViewPrivate *>(this));
     }
 
     return m_completionWidget;
 }
 
 void KTextEditor::ViewPrivate::startCompletion(const KTextEditor::Range &word, KTextEditor::CodeCompletionModel *model)
 {
     completionWidget()->startCompletion(word, model);
 }
 
 void KTextEditor::ViewPrivate::abortCompletion()
 {
     completionWidget()->abortCompletion();
 }
 
 void KTextEditor::ViewPrivate::forceCompletion()
 {
     completionWidget()->execute();
 }
 
 void KTextEditor::ViewPrivate::registerCompletionModel(KTextEditor::CodeCompletionModel *model)
 {
     completionWidget()->registerCompletionModel(model);
 }
 
 void KTextEditor::ViewPrivate::unregisterCompletionModel(KTextEditor::CodeCompletionModel *model)
 {
     completionWidget()->unregisterCompletionModel(model);
 }
 
 bool KTextEditor::ViewPrivate::isCompletionModelRegistered(KTextEditor::CodeCompletionModel *model) const
 {
     return completionWidget()->isCompletionModelRegistered(model);
 }
 
 bool KTextEditor::ViewPrivate::isAutomaticInvocationEnabled() const
 {
     return !m_temporaryAutomaticInvocationDisabled && m_config->automaticCompletionInvocation();
 }
 
 void KTextEditor::ViewPrivate::setAutomaticInvocationEnabled(bool enabled)
 {
     config()->setAutomaticCompletionInvocation(enabled);
 }
 
 void KTextEditor::ViewPrivate::sendCompletionExecuted(const KTextEditor::Cursor &position, KTextEditor::CodeCompletionModel *model, const QModelIndex &index)
 {
     emit completionExecuted(this, position, model, index);
 }
 
 void KTextEditor::ViewPrivate::sendCompletionAborted()
 {
     emit completionAborted(this);
 }
 
 void KTextEditor::ViewPrivate::paste(const QString *textToPaste)
 {
     m_temporaryAutomaticInvocationDisabled = true;
     doc()->paste(this, textToPaste ? *textToPaste : QApplication::clipboard()->text(QClipboard::Clipboard));
     m_temporaryAutomaticInvocationDisabled = false;
 }
 
 bool KTextEditor::ViewPrivate::setCursorPosition(KTextEditor::Cursor position)
 {
     return setCursorPositionInternal(position, 1, true);
 }
 
 KTextEditor::Cursor KTextEditor::ViewPrivate::cursorPosition() const
 {
     return m_viewInternal->cursorPosition();
 }
 
 KTextEditor::Cursor KTextEditor::ViewPrivate::cursorPositionVirtual() const
 {
     return KTextEditor::Cursor(m_viewInternal->cursorPosition().line(), virtualCursorColumn());
 }
 
 QPoint KTextEditor::ViewPrivate::cursorToCoordinate(const KTextEditor::Cursor &cursor) const
 {
     // map from ViewInternal to View coordinates
     const QPoint pt = m_viewInternal->cursorToCoordinate(cursor, true, false);
     return pt == QPoint(-1, -1) ? pt : m_viewInternal->mapToParent(pt);
 }
 
 KTextEditor::Cursor KTextEditor::ViewPrivate::coordinatesToCursor(const QPoint &coords) const
 {
     // map from View to ViewInternal coordinates
     return m_viewInternal->coordinatesToCursor(m_viewInternal->mapFromParent(coords), false);
 }
 
 QPoint KTextEditor::ViewPrivate::cursorPositionCoordinates() const
 {
     // map from ViewInternal to View coordinates
     const QPoint pt = m_viewInternal->cursorCoordinates(false);
     return pt == QPoint(-1, -1) ? pt : m_viewInternal->mapToParent(pt);
 }
 
 void KTextEditor::ViewPrivate::setScrollPositionInternal(KTextEditor::Cursor &cursor)
 {
     m_viewInternal->scrollPos(cursor, false, true, false);
 }
 
 void KTextEditor::ViewPrivate::setHorizontalScrollPositionInternal(int x)
 {
     m_viewInternal->scrollColumns(x);
 }
 
 KTextEditor::Cursor KTextEditor::ViewPrivate::maxScrollPositionInternal() const
 {
     return m_viewInternal->maxStartPos(true);
 }
 
 
 int KTextEditor::ViewPrivate::firstDisplayedLineInternal(LineType lineType) const
 {
     if (lineType == RealLine) {
         return m_textFolding.visibleLineToLine(m_viewInternal->startLine());
     } else {
         return m_viewInternal->startLine();
     }
 }
 
 int KTextEditor::ViewPrivate::lastDisplayedLineInternal(LineType lineType) const
 {
     if (lineType == RealLine) {
         return  m_textFolding.visibleLineToLine(m_viewInternal->endLine());
     } else {
         return m_viewInternal->endLine();
     }
 }
 
 QRect KTextEditor::ViewPrivate::textAreaRectInternal() const
 {
     const auto sourceRect = m_viewInternal->rect();
     const auto topLeft = m_viewInternal->mapTo(this, sourceRect.topLeft());
     const auto bottomRight = m_viewInternal->mapTo(this, sourceRect.bottomRight());
     return {topLeft, bottomRight};
 }
 
 bool KTextEditor::ViewPrivate::setCursorPositionVisual(const KTextEditor::Cursor &position)
 {
     return setCursorPositionInternal(position, doc()->config()->tabWidth(), true);
 }
 
 QString KTextEditor::ViewPrivate::currentTextLine()
 {
     return doc()->line(cursorPosition().line());
 }
 
 QTextLayout * KTextEditor::ViewPrivate::textLayout(int line) const
 {
     KateLineLayoutPtr thisLine = m_viewInternal->cache()->line(line);
 
     return thisLine->isValid() ? thisLine->layout() : nullptr;
 }
 
 QTextLayout * KTextEditor::ViewPrivate::textLayout(const KTextEditor::Cursor &pos) const
 {
     KateLineLayoutPtr thisLine = m_viewInternal->cache()->line(pos);
 
     return thisLine->isValid() ? thisLine->layout() : nullptr;
 }
 
 void KTextEditor::ViewPrivate::indent()
 {
     KTextEditor::Cursor c(cursorPosition().line(), 0);
     KTextEditor::Range r = selection() ? selectionRange() : KTextEditor::Range(c, c);
     doc()->indent(r, 1);
 }
 
 void KTextEditor::ViewPrivate::unIndent()
 {
     KTextEditor::Cursor c(cursorPosition().line(), 0);
     KTextEditor::Range r = selection() ? selectionRange() : KTextEditor::Range(c, c);
     doc()->indent(r, -1);
 }
 
 void KTextEditor::ViewPrivate::cleanIndent()
 {
     KTextEditor::Cursor c(cursorPosition().line(), 0);
     KTextEditor::Range r = selection() ? selectionRange() : KTextEditor::Range(c, c);
     doc()->indent(r, 0);
 }
 
 void KTextEditor::ViewPrivate::align()
 {
     // no selection: align current line; selection: use selection range
     const int line = cursorPosition().line();
     KTextEditor::Range alignRange(KTextEditor::Cursor(line, 0), KTextEditor::Cursor(line, 0));
     if (selection()) {
         alignRange = selectionRange();
     }
 
     doc()->align(this, alignRange);
 }
 
 void KTextEditor::ViewPrivate::comment()
 {
     m_selection.setInsertBehaviors(Kate::TextRange::ExpandLeft | Kate::TextRange::ExpandRight);
     doc()->comment(this, cursorPosition().line(), cursorPosition().column(), 1);
     m_selection.setInsertBehaviors(Kate::TextRange::ExpandRight);
 }
 
 void KTextEditor::ViewPrivate::uncomment()
 {
     doc()->comment(this, cursorPosition().line(), cursorPosition().column(), -1);
 }
 
 void KTextEditor::ViewPrivate::toggleComment()
 {
     m_selection.setInsertBehaviors(Kate::TextRange::ExpandLeft | Kate::TextRange::ExpandRight);
     doc()->comment(this, cursorPosition().line(), cursorPosition().column(), 0);
     m_selection.setInsertBehaviors(Kate::TextRange::ExpandRight);
 }
 
 void KTextEditor::ViewPrivate::uppercase()
 {
     doc()->transform(this, cursorPosition(), KTextEditor::DocumentPrivate::Uppercase);
 }
 
 void KTextEditor::ViewPrivate::killLine()
 {
     if (m_selection.isEmpty()) {
         doc()->removeLine(cursorPosition().line());
     } else {
         doc()->editStart();
         // cache endline, else that moves and we might delete complete document if last line is selected!
         for (int line = m_selection.end().line(), endLine = m_selection.start().line(); line >= endLine; line--) {
             doc()->removeLine(line);
         }
         doc()->editEnd();
     }
 }
 
 void KTextEditor::ViewPrivate::lowercase()
 {
     doc()->transform(this, cursorPosition(), KTextEditor::DocumentPrivate::Lowercase);
 }
 
 void KTextEditor::ViewPrivate::capitalize()
 {
     doc()->editStart();
     doc()->transform(this, cursorPosition(), KTextEditor::DocumentPrivate::Lowercase);
     doc()->transform(this, cursorPosition(), KTextEditor::DocumentPrivate::Capitalize);
     doc()->editEnd();
 }
 
 void KTextEditor::ViewPrivate::keyReturn()
 {
     doc()->newLine(this);
     m_viewInternal->iconBorder()->updateForCursorLineChange();
     m_viewInternal->updateView();
 }
 
 void KTextEditor::ViewPrivate::smartNewline()
 {
     const KTextEditor::Cursor cursor = cursorPosition();
     const int ln = cursor.line();
     Kate::TextLine line = doc()->kateTextLine(ln);
     int col = qMin(cursor.column(), line->firstChar());
     if (col != -1) {
         while (line->length() > col &&
                 !(line->at(col).isLetterOrNumber() || line->at(col) == QLatin1Char('_')) &&
                 col < cursor.column()) {
             ++col;
         }
     } else {
         col = line->length(); // stay indented
     }
     doc()->editStart();
     doc()->editWrapLine(ln, cursor.column());
     doc()->insertText(KTextEditor::Cursor(ln + 1, 0), line->string(0, col));
     doc()->editEnd();
 
     m_viewInternal->updateView();
 }
 
 void KTextEditor::ViewPrivate::backspace()
 {
     doc()->backspace(this, cursorPosition());
 }
 
 void KTextEditor::ViewPrivate::insertTab()
 {
     doc()->insertTab(this, cursorPosition());
 }
 
 void KTextEditor::ViewPrivate::deleteWordLeft()
 {
     doc()->editStart();
     m_viewInternal->wordPrev(true);
     KTextEditor::Range selection = selectionRange();
     removeSelectedText();
     doc()->editEnd();
     m_viewInternal->tagRange(selection, true);
     m_viewInternal->updateDirty();
 }
 
 void KTextEditor::ViewPrivate::keyDelete()
 {
     doc()->del(this, cursorPosition());
 }
 
 void KTextEditor::ViewPrivate::deleteWordRight()
 {
     doc()->editStart();
     m_viewInternal->wordNext(true);
     KTextEditor::Range selection = selectionRange();
     removeSelectedText();
     doc()->editEnd();
     m_viewInternal->tagRange(selection, true);
     m_viewInternal->updateDirty();
 }
 
 void KTextEditor::ViewPrivate::transpose()
 {
     doc()->transpose(cursorPosition());
 }
 
 void KTextEditor::ViewPrivate::cursorLeft()
 {
     if (selection() && !config()->persistentSelection()) {
         if (currentTextLine().isRightToLeft()) {
             m_viewInternal->updateCursor(selectionRange().end());
             setSelection(KTextEditor::Range::invalid());
         } else {
             m_viewInternal->updateCursor(selectionRange().start());
             setSelection(KTextEditor::Range::invalid());
         }
 
     } else {
         if (currentTextLine().isRightToLeft()) {
             m_viewInternal->cursorNextChar();
         } else {
             m_viewInternal->cursorPrevChar();
         }
     }
 }
 
 void KTextEditor::ViewPrivate::shiftCursorLeft()
 {
     if (currentTextLine().isRightToLeft()) {
         m_viewInternal->cursorNextChar(true);
     } else {
         m_viewInternal->cursorPrevChar(true);
     }
 }
 
 void KTextEditor::ViewPrivate::cursorRight()
 {
     if (selection() && !config()->persistentSelection()) {
         if (currentTextLine().isRightToLeft()) {
             m_viewInternal->updateCursor(selectionRange().start());
             setSelection(KTextEditor::Range::invalid());
         } else {
             m_viewInternal->updateCursor(selectionRange().end());
             setSelection(KTextEditor::Range::invalid());
         }
 
     } else {
         if (currentTextLine().isRightToLeft()) {
             m_viewInternal->cursorPrevChar();
         } else {
             m_viewInternal->cursorNextChar();
         }
     }
 }
 
 void KTextEditor::ViewPrivate::shiftCursorRight()
 {
     if (currentTextLine().isRightToLeft()) {
         m_viewInternal->cursorPrevChar(true);
     } else {
         m_viewInternal->cursorNextChar(true);
     }
 }
 
 void KTextEditor::ViewPrivate::wordLeft()
 {
     if (currentTextLine().isRightToLeft()) {
         m_viewInternal->wordNext();
     } else {
         m_viewInternal->wordPrev();
     }
 }
 
 void KTextEditor::ViewPrivate::shiftWordLeft()
 {
     if (currentTextLine().isRightToLeft()) {
         m_viewInternal->wordNext(true);
     } else {
         m_viewInternal->wordPrev(true);
     }
 }
 
 void KTextEditor::ViewPrivate::wordRight()
 {
     if (currentTextLine().isRightToLeft()) {
         m_viewInternal->wordPrev();
     } else {
         m_viewInternal->wordNext();
     }
 }
 
 void KTextEditor::ViewPrivate::shiftWordRight()
 {
     if (currentTextLine().isRightToLeft()) {
         m_viewInternal->wordPrev(true);
     } else {
         m_viewInternal->wordNext(true);
     }
 }
 
 void KTextEditor::ViewPrivate::home()
 {
     m_viewInternal->home();
 }
 
 void KTextEditor::ViewPrivate::shiftHome()
 {
     m_viewInternal->home(true);
 }
 
 void KTextEditor::ViewPrivate::end()
 {
     m_viewInternal->end();
 }
 
 void KTextEditor::ViewPrivate::shiftEnd()
 {
     m_viewInternal->end(true);
 }
 
 void KTextEditor::ViewPrivate::up()
 {
     m_viewInternal->cursorUp();
 }
 
 void KTextEditor::ViewPrivate::shiftUp()
 {
     m_viewInternal->cursorUp(true);
 }
 
 void KTextEditor::ViewPrivate::down()
 {
     m_viewInternal->cursorDown();
 }
 
 void KTextEditor::ViewPrivate::shiftDown()
 {
     m_viewInternal->cursorDown(true);
 }
 
 void KTextEditor::ViewPrivate::scrollUp()
 {
     m_viewInternal->scrollUp();
 }
 
 void KTextEditor::ViewPrivate::scrollDown()
 {
     m_viewInternal->scrollDown();
 }
 
 void KTextEditor::ViewPrivate::topOfView()
 {
     m_viewInternal->topOfView();
 }
 
 void KTextEditor::ViewPrivate::shiftTopOfView()
 {
     m_viewInternal->topOfView(true);
 }
 
 void KTextEditor::ViewPrivate::bottomOfView()
 {
     m_viewInternal->bottomOfView();
 }
 
 void KTextEditor::ViewPrivate::shiftBottomOfView()
 {
     m_viewInternal->bottomOfView(true);
 }
 
 void KTextEditor::ViewPrivate::pageUp()
 {
     m_viewInternal->pageUp();
 }
 
 void KTextEditor::ViewPrivate::shiftPageUp()
 {
     m_viewInternal->pageUp(true);
 }
 
 void KTextEditor::ViewPrivate::pageDown()
 {
     m_viewInternal->pageDown();
 }
 
 void KTextEditor::ViewPrivate::shiftPageDown()
 {
     m_viewInternal->pageDown(true);
 }
 
 void KTextEditor::ViewPrivate::top()
 {
     m_viewInternal->top_home();
 }
 
 void KTextEditor::ViewPrivate::shiftTop()
 {
     m_viewInternal->top_home(true);
 }
 
 void KTextEditor::ViewPrivate::bottom()
 {
     m_viewInternal->bottom_end();
 }
 
 void KTextEditor::ViewPrivate::shiftBottom()
 {
     m_viewInternal->bottom_end(true);
 }
 
 void KTextEditor::ViewPrivate::toMatchingBracket()
 {
     m_viewInternal->cursorToMatchingBracket();
 }
 
 void KTextEditor::ViewPrivate::shiftToMatchingBracket()
 {
     m_viewInternal->cursorToMatchingBracket(true);
 }
 
 void KTextEditor::ViewPrivate::toPrevModifiedLine()
 {
     const int startLine = cursorPosition().line() - 1;
     const int line = doc()->findTouchedLine(startLine, false);
     if (line >= 0) {
         KTextEditor::Cursor c(line, 0);
         m_viewInternal->updateSelection(c, false);
         m_viewInternal->updateCursor(c);
     }
 }
 
 void KTextEditor::ViewPrivate::toNextModifiedLine()
 {
     const int startLine = cursorPosition().line() + 1;
     const int line = doc()->findTouchedLine(startLine, true);
     if (line >= 0) {
         KTextEditor::Cursor c(line, 0);
         m_viewInternal->updateSelection(c, false);
         m_viewInternal->updateCursor(c);
     }
 }
 
 KTextEditor::Range KTextEditor::ViewPrivate::selectionRange() const
 {
     return m_selection;
 }
 
 KTextEditor::Document *KTextEditor::ViewPrivate::document() const
 {
     return m_doc;
 }
 
 void KTextEditor::ViewPrivate::setContextMenu(QMenu *menu)
 {
     if (m_contextMenu) {
         disconnect(m_contextMenu, SIGNAL(aboutToShow()), this, SLOT(aboutToShowContextMenu()));
         disconnect(m_contextMenu, SIGNAL(aboutToHide()), this, SLOT(aboutToHideContextMenu()));
     }
     m_contextMenu = menu;
     m_userContextMenuSet = true;
 
     if (m_contextMenu) {
         connect(m_contextMenu, SIGNAL(aboutToShow()), this, SLOT(aboutToShowContextMenu()));
         connect(m_contextMenu, SIGNAL(aboutToHide()), this, SLOT(aboutToHideContextMenu()));
     }
 }
 
 QMenu *KTextEditor::ViewPrivate::contextMenu() const
 {
     if (m_userContextMenuSet) {
         return m_contextMenu;
     } else {
         KXMLGUIClient *client = const_cast<KTextEditor::ViewPrivate *>(this);
         while (client->parentClient()) {
             client = client->parentClient();
         }
 
         //qCDebug(LOG_KTE) << "looking up all menu containers";
         if (client->factory()) {
             QList<QWidget *> conts = client->factory()->containers(QStringLiteral("menu"));
             foreach (QWidget *w, conts) {
                 if (w->objectName() == QLatin1String("ktexteditor_popup")) {
                     //perhaps optimize this block
                     QMenu *menu = (QMenu *)w;
                     // menu is a reusable instance shared among all views. Therefore,
                     // disconnect the current receiver(s) from the menu show/hide signals
                     // before connecting `this` view. This ensures that only the current
                     // view gets a signal when the menu is about to be shown or hidden,
                     // and not also the view(s) that previously had the menu open.
                     disconnect(menu, SIGNAL(aboutToShow()), nullptr, nullptr);
                     disconnect(menu, SIGNAL(aboutToHide()), nullptr, nullptr);
                     connect(menu, SIGNAL(aboutToShow()), this, SLOT(aboutToShowContextMenu()));
                     connect(menu, SIGNAL(aboutToHide()), this, SLOT(aboutToHideContextMenu()));
                     return menu;
                 }
             }
         }
     }
     return nullptr;
 }
 
 QMenu *KTextEditor::ViewPrivate::defaultContextMenu(QMenu *menu) const
 {
     if (!menu) {
         menu = new QMenu(const_cast<KTextEditor::ViewPrivate *>(this));
     }
 
     menu->addAction(m_editUndo);
     menu->addAction(m_editRedo);
     menu->addSeparator();
     menu->addAction(m_cut);
     menu->addAction(m_copy);
     menu->addAction(m_paste);
     menu->addSeparator();
     menu->addAction(m_selectAll);
     menu->addAction(m_deSelect);
     if (QAction *spellingSuggestions = actionCollection()->action(QStringLiteral("spelling_suggestions"))) {
         menu->addSeparator();
         menu->addAction(spellingSuggestions);
     }
     if (QAction *bookmark = actionCollection()->action(QStringLiteral("bookmarks"))) {
         menu->addSeparator();
         menu->addAction(bookmark);
     }
     return menu;
 }
 
 void KTextEditor::ViewPrivate::aboutToShowContextMenu()
 {
     QMenu *menu = qobject_cast<QMenu *>(sender());
 
     if (menu) {
         emit contextMenuAboutToShow(this, menu);
     }
 }
 
 void KTextEditor::ViewPrivate::aboutToHideContextMenu()
 {
     m_spellingMenu->setUseMouseForMisspelledRange(false);
 }
 
 // BEGIN ConfigInterface stff
 QStringList KTextEditor::ViewPrivate::configKeys() const
 {
     static const QStringList keys = {
         QStringLiteral("icon-bar"),
         QStringLiteral("line-numbers"),
         QStringLiteral("dynamic-word-wrap"),
         QStringLiteral("background-color"),
         QStringLiteral("selection-color"),
         QStringLiteral("search-highlight-color"),
         QStringLiteral("replace-highlight-color"),
         QStringLiteral("default-mark-type"),
         QStringLiteral("allow-mark-menu"),
         QStringLiteral("folding-bar"),
         QStringLiteral("folding-preview"),
         QStringLiteral("icon-border-color"),
         QStringLiteral("folding-marker-color"),
         QStringLiteral("line-number-color"),
         QStringLiteral("current-line-number-color"),
         QStringLiteral("modification-markers"),
         QStringLiteral("keyword-completion"),
         QStringLiteral("word-count"),
         QStringLiteral("scrollbar-minimap"),
         QStringLiteral("scrollbar-preview"),
         QStringLiteral("font")
     };
     return keys;
 }
 
 QVariant KTextEditor::ViewPrivate::configValue(const QString &key)
 {
     if (key == QLatin1String("icon-bar")) {
         return config()->iconBar();
     } else if (key == QLatin1String("line-numbers")) {
         return config()->lineNumbers();
     } else if (key == QLatin1String("dynamic-word-wrap")) {
         return config()->dynWordWrap();
     } else if (key == QLatin1String("background-color")) {
         return renderer()->config()->backgroundColor();
     } else if (key == QLatin1String("selection-color")) {
         return renderer()->config()->selectionColor();
     } else if (key == QLatin1String("search-highlight-color")) {
         return renderer()->config()->searchHighlightColor();
     } else if (key == QLatin1String("replace-highlight-color")) {
         return renderer()->config()->replaceHighlightColor();
     } else if (key == QLatin1String("default-mark-type")) {
         return config()->defaultMarkType();
     } else if (key == QLatin1String("allow-mark-menu")) {
         return config()->allowMarkMenu();
     } else if (key == QLatin1String("folding-bar")) {
         return config()->foldingBar();
     } else if (key == QLatin1String("folding-preview")) {
         return config()->foldingPreview();
     } else if (key == QLatin1String("icon-border-color")) {
         return renderer()->config()->iconBarColor();
     } else if (key == QLatin1String("folding-marker-color")) {
         return renderer()->config()->foldingColor();
     } else if (key == QLatin1String("line-number-color")) {
         return renderer()->config()->lineNumberColor();
     } else if (key == QLatin1String("current-line-number-color")) {
         return renderer()->config()->currentLineNumberColor();
     } else if (key == QLatin1String("modification-markers")) {
         return config()->lineModification();
     } else if (key == QLatin1String("keyword-completion")) {
         return config()->keywordCompletion();
     } else if (key == QLatin1String("word-count")) {
         return config()->showWordCount();
     } else if (key == QLatin1String("scrollbar-minimap")) {
         return config()->scrollBarMiniMap();
     } else if (key == QLatin1String("scrollbar-preview")) {
         return config()->scrollBarPreview();
     } else if (key == QLatin1String("font")) {
         return renderer()->config()->font();
     }
 
     // return invalid variant
     return QVariant();
 }
 
 void KTextEditor::ViewPrivate::setConfigValue(const QString &key, const QVariant &value)
 {
     if (value.canConvert(QVariant::Color)) {
         if (key == QLatin1String("background-color")) {
             renderer()->config()->setBackgroundColor(value.value<QColor>());
         } else if (key == QLatin1String("selection-color")) {
             renderer()->config()->setSelectionColor(value.value<QColor>());
         } else if (key == QLatin1String("search-highlight-color")) {
             renderer()->config()->setSearchHighlightColor(value.value<QColor>());
         } else if (key == QLatin1String("replace-highlight-color")) {
             renderer()->config()->setReplaceHighlightColor(value.value<QColor>());
         } else if (key == QLatin1String("icon-border-color")) {
             renderer()->config()->setIconBarColor(value.value<QColor>());
         } else if (key == QLatin1String("folding-marker-color")) {
             renderer()->config()->setFoldingColor(value.value<QColor>());
         } else if (key == QLatin1String("line-number-color")) {
             renderer()->config()->setLineNumberColor(value.value<QColor>());
         } else if (key == QLatin1String("current-line-number-color")) {
             renderer()->config()->setCurrentLineNumberColor(value.value<QColor>());
         }
 
     } else if (value.type() == QVariant::Bool) {
         // Note explicit type check above. If we used canConvert, then
         // values of type UInt will be trapped here.
         if (key == QLatin1String("icon-bar")) {
             config()->setIconBar(value.toBool());
         } else if (key == QLatin1String("line-numbers")) {
             config()->setLineNumbers(value.toBool());
         } else if (key == QLatin1String("dynamic-word-wrap")) {
             config()->setDynWordWrap(value.toBool());
         } else if (key == QLatin1String("allow-mark-menu")) {
             config()->setAllowMarkMenu(value.toBool());
         } else if (key == QLatin1String("folding-bar")) {
             config()->setFoldingBar(value.toBool());
         } else if (key == QLatin1String("folding-preview")) {
             config()->setFoldingPreview(value.toBool());
         } else if (key == QLatin1String("modification-markers")) {
             config()->setLineModification(value.toBool());
         } else if (key == QLatin1String("keyword-completion")) {
             config()->setKeywordCompletion(value.toBool());
         } else if (key == QLatin1String("word-count")) {
             config()->setShowWordCount(value.toBool());
         } else if (key == QLatin1String("scrollbar-minimap")) {
             config()->setScrollBarMiniMap(value.toBool());
         } else if (key == QLatin1String("scrollbar-preview")) {
             config()->setScrollBarPreview(value.toBool());
         }
 
     } else if (value.canConvert(QVariant::UInt)) {
         if (key == QLatin1String("default-mark-type")) {
             config()->setDefaultMarkType(value.toUInt());
         }
 
     } else if (value.canConvert(QVariant::Font)) {
         if (key == QLatin1String("font")) {
             renderer()->config()->setFont(value.value<QFont>());
         }
     }
 }
 
 // END ConfigInterface
 
 void KTextEditor::ViewPrivate::userInvokedCompletion()
 {
     completionWidget()->userInvokedCompletion();
 }
 
 KateViewBar *KTextEditor::ViewPrivate::bottomViewBar() const
 {
     return m_bottomViewBar;
 }
 
 KateGotoBar *KTextEditor::ViewPrivate::gotoBar()
 {
     if (!m_gotoBar) {
         m_gotoBar = new KateGotoBar(this);
         bottomViewBar()->addBarWidget(m_gotoBar);
     }
 
     return m_gotoBar;
 }
 
 KateDictionaryBar *KTextEditor::ViewPrivate::dictionaryBar()
 {
     if (!m_dictionaryBar) {
         m_dictionaryBar = new KateDictionaryBar(this);
         bottomViewBar()->addBarWidget(m_dictionaryBar);
     }
 
     return m_dictionaryBar;
 }
 
 void KTextEditor::ViewPrivate::setAnnotationModel(KTextEditor::AnnotationModel *model)
 {
     KTextEditor::AnnotationModel *oldmodel = m_annotationModel;
     m_annotationModel = model;
     m_viewInternal->m_leftBorder->annotationModelChanged(oldmodel, m_annotationModel);
 }
 
 KTextEditor::AnnotationModel *KTextEditor::ViewPrivate::annotationModel() const
 {
     return m_annotationModel;
 }
 
 void KTextEditor::ViewPrivate::setAnnotationBorderVisible(bool visible)
 {
     m_viewInternal->m_leftBorder->setAnnotationBorderOn(visible);
 }
 
 bool KTextEditor::ViewPrivate::isAnnotationBorderVisible() const
 {
     return m_viewInternal->m_leftBorder->annotationBorderOn();
 }
 
 KTextEditor::AbstractAnnotationItemDelegate* KTextEditor::ViewPrivate::annotationItemDelegate() const
 {
     return m_viewInternal->m_leftBorder->annotationItemDelegate();
 }
 
 void KTextEditor::ViewPrivate::setAnnotationItemDelegate(KTextEditor::AbstractAnnotationItemDelegate *delegate)
 {
     m_viewInternal->m_leftBorder->setAnnotationItemDelegate(delegate);
 }
 
 bool KTextEditor::ViewPrivate::uniformAnnotationItemSizes() const
 {
     return m_viewInternal->m_leftBorder->uniformAnnotationItemSizes();
 }
 
 void KTextEditor::ViewPrivate::setAnnotationUniformItemSizes(bool enable)
 {
     m_viewInternal->m_leftBorder->setAnnotationUniformItemSizes(enable);
 }
 
 KTextEditor::Range KTextEditor::ViewPrivate::visibleRange()
 {
     //ensure that the view is up-to-date, otherwise 'endPos()' might fail!
     if (!m_viewInternal->endPos().isValid()) {
         m_viewInternal->updateView();
     }
     return KTextEditor::Range(m_viewInternal->toRealCursor(m_viewInternal->startPos()),
                               m_viewInternal->toRealCursor(m_viewInternal->endPos()));
 }
 
 bool KTextEditor::ViewPrivate::event(QEvent *e)
 {
     switch (e->type()) {
         case QEvent::StyleChange:
             setupLayout();
             return true;
         default:
             return KTextEditor::View::event(e);
     }
 }
 
 void KTextEditor::ViewPrivate::paintEvent(QPaintEvent *e)
 {
     //base class
     KTextEditor::View::paintEvent(e);
 
     const QRect contentsRect = m_topSpacer->geometry()|
         m_bottomSpacer->geometry()|
         m_leftSpacer->geometry()|
         m_rightSpacer->geometry();
 
     if (contentsRect.isValid()) {
         QStyleOptionFrame opt;
         opt.initFrom(this);
         opt.frameShape = QFrame::StyledPanel;
         opt.state |= QStyle::State_Sunken;
 
         // clear mouseOver and focus state
         // update from relevant widgets
         opt.state &= ~(QStyle::State_HasFocus|QStyle::State_MouseOver);
         const QList<QWidget *> widgets = QList<QWidget *>() << m_viewInternal << m_viewInternal->m_leftBorder << m_viewInternal->m_lineScroll << m_viewInternal->m_columnScroll;
         foreach (const QWidget *w, widgets) {
             if (w->hasFocus()) opt.state |= QStyle::State_HasFocus;
             if (w->underMouse()) opt.state |= QStyle::State_MouseOver;
         }
 
         // update rect
         opt.rect=contentsRect;
 
         // render
         QPainter paint(this);
         paint.setClipRegion(e->region());
         paint.setRenderHints(QPainter::Antialiasing);
         style()->drawControl(QStyle::CE_ShapedFrame, &opt, &paint, this);
     }
 }
 
 void KTextEditor::ViewPrivate::toggleOnTheFlySpellCheck(bool b)
 {
     doc()->onTheFlySpellCheckingEnabled(b);
 }
 
 void KTextEditor::ViewPrivate::reflectOnTheFlySpellCheckStatus(bool enabled)
 {
     m_spellingMenu->setVisible(enabled);
     m_toggleOnTheFlySpellCheck->setChecked(enabled);
 }
 
 KateSpellingMenu *KTextEditor::ViewPrivate::spellingMenu()
 {
     return m_spellingMenu;
 }
 
 void KTextEditor::ViewPrivate::notifyAboutRangeChange(int startLine, int endLine, bool rangeWithAttribute)
 {
 #ifdef VIEW_RANGE_DEBUG
     // output args
     qCDebug(LOG_KTE) << "trigger attribute changed from" << startLine << "to" << endLine << "rangeWithAttribute" << rangeWithAttribute;
 #endif
 
     // first call:
     if (!m_delayedUpdateTriggered) {
         m_delayedUpdateTriggered = true;
         m_lineToUpdateMin = -1;
         m_lineToUpdateMax = -1;
 
         // only set initial line range, if range with attribute!
         if (rangeWithAttribute) {
             m_lineToUpdateMin = startLine;
             m_lineToUpdateMax = endLine;
         }
 
         // emit queued signal and be done
         emit delayedUpdateOfView();
         return;
     }
 
     // ignore lines if no attribute
     if (!rangeWithAttribute) {
         return;
     }
 
     // update line range
     if (startLine != -1 && (m_lineToUpdateMin == -1 || startLine < m_lineToUpdateMin)) {
         m_lineToUpdateMin = startLine;
     }
 
     if (endLine != -1 && endLine > m_lineToUpdateMax) {
         m_lineToUpdateMax = endLine;
     }
 }
 
 void KTextEditor::ViewPrivate::slotDelayedUpdateOfView()
 {
     if (!m_delayedUpdateTriggered) {
         return;
     }
 
 #ifdef VIEW_RANGE_DEBUG
     // output args
     qCDebug(LOG_KTE) << "delayed attribute changed from" << m_lineToUpdateMin << "to" << m_lineToUpdateMax;
 #endif
 
     // update ranges in
     updateRangesIn(KTextEditor::Attribute::ActivateMouseIn);
     updateRangesIn(KTextEditor::Attribute::ActivateCaretIn);
 
     // update view, if valid line range, else only feedback update wanted anyway
     if (m_lineToUpdateMin != -1 && m_lineToUpdateMax != -1) {
         tagLines(m_lineToUpdateMin, m_lineToUpdateMax, true);
         updateView(true);
     }
 
     // reset flags
     m_delayedUpdateTriggered = false;
     m_lineToUpdateMin = -1;
     m_lineToUpdateMax = -1;
 }
 
 void KTextEditor::ViewPrivate::updateRangesIn(KTextEditor::Attribute::ActivationType activationType)
 {
     // new ranges with cursor in, default none
     QSet<Kate::TextRange *> newRangesIn;
 
     // on which range set we work?
     QSet<Kate::TextRange *> &oldSet = (activationType == KTextEditor::Attribute::ActivateMouseIn) ? m_rangesMouseIn : m_rangesCaretIn;
 
     // which cursor position to honor?
     KTextEditor::Cursor currentCursor = (activationType == KTextEditor::Attribute::ActivateMouseIn) ? m_viewInternal->mousePosition() : m_viewInternal->cursorPosition();
 
     // first: validate the remembered ranges
     QSet<Kate::TextRange *> validRanges;
     foreach (Kate::TextRange *range, oldSet)
         if (doc()->buffer().rangePointerValid(range)) {
             validRanges.insert(range);
         }
 
     // cursor valid? else no new ranges can be found
     if (currentCursor.isValid() && currentCursor.line() < doc()->buffer().lines()) {
         // now: get current ranges for the line of cursor with an attribute
         QList<Kate::TextRange *> rangesForCurrentCursor = doc()->buffer().rangesForLine(currentCursor.line(), this, false);
 
         // match which ranges really fit the given cursor
         foreach (Kate::TextRange *range, rangesForCurrentCursor) {
             // range has no dynamic attribute of right type and no feedback object
             if ((!range->attribute() || !range->attribute()->dynamicAttribute(activationType)) && !range->feedback()) {
                 continue;
             }
 
             // range doesn't contain cursor, not interesting
             if ((range->start().insertBehavior() == KTextEditor::MovingCursor::StayOnInsert)
                     ? (currentCursor < range->start().toCursor()) : (currentCursor <= range->start().toCursor())) {
                 continue;
             }
 
             if ((range->end().insertBehavior() == KTextEditor::MovingCursor::StayOnInsert)
                     ? (range->end().toCursor() <= currentCursor) : (range->end().toCursor() < currentCursor)) {
                 continue;
             }
 
             // range contains cursor, was it already in old set?
             if (validRanges.contains(range)) {
                 // insert in new, remove from old, be done with it
                 newRangesIn.insert(range);
                 validRanges.remove(range);
                 continue;
             }
 
             // oh, new range, trigger update and insert into new set
             newRangesIn.insert(range);
 
             if (range->attribute() && range->attribute()->dynamicAttribute(activationType)) {
                 notifyAboutRangeChange(range->start().line(), range->end().line(), true);
             }
 
             // feedback
             if (range->feedback()) {
                 if (activationType == KTextEditor::Attribute::ActivateMouseIn) {
                     range->feedback()->mouseEnteredRange(range, this);
                 } else {
                     range->feedback()->caretEnteredRange(range, this);
                     emit caretChangedRange(this);
                 }
             }
 
 #ifdef VIEW_RANGE_DEBUG
             // found new range for activation
             qCDebug(LOG_KTE) << "activated new range" << range << "by" << activationType;
 #endif
         }
     }
 
     // now: notify for left ranges!
     foreach (Kate::TextRange *range, validRanges) {
         // range valid + right dynamic attribute, trigger update
         if (range->toRange().isValid() && range->attribute() && range->attribute()->dynamicAttribute(activationType)) {
             notifyAboutRangeChange(range->start().line(), range->end().line(), true);
         }
 
         // feedback
         if (range->feedback()) {
             if (activationType == KTextEditor::Attribute::ActivateMouseIn) {
                 range->feedback()->mouseExitedRange(range, this);
             } else {
                 range->feedback()->caretExitedRange(range, this);
                 emit caretChangedRange(this);
             }
         }
     }
 
     // set new ranges
     oldSet = newRangesIn;
 }
 
 void KTextEditor::ViewPrivate::postMessage(KTextEditor::Message *message,
                            QList<QSharedPointer<QAction> > actions)
 {
     // just forward to KateMessageWidget :-)
     auto messageWidget = m_messageWidgets[message->position()];
     if (!messageWidget) {
         // this branch is used for: TopInView, CenterInView, and BottomInView
         messageWidget = new KateMessageWidget(m_viewInternal, true);
         m_messageWidgets[message->position()] = messageWidget;
         m_notificationLayout->addWidget(messageWidget, message->position());
         connect(this, SIGNAL(displayRangeChanged(KTextEditor::ViewPrivate*)), messageWidget, SLOT(startAutoHideTimer()));
         connect(this, SIGNAL(cursorPositionChanged(KTextEditor::View*,KTextEditor::Cursor)), messageWidget, SLOT(startAutoHideTimer()));
     }
     messageWidget->postMessage(message, actions);
 }
 
 KateMessageWidget *KTextEditor::ViewPrivate::messageWidget()
 {
     return m_messageWidgets[KTextEditor::Message::TopInView];
 }
 
 void KTextEditor::ViewPrivate::saveFoldingState()
 {
     m_savedFoldingState = m_textFolding.exportFoldingRanges();
 }
 
 void KTextEditor::ViewPrivate::applyFoldingState()
 {
     m_textFolding.importFoldingRanges(m_savedFoldingState);
     m_savedFoldingState = QJsonDocument();
 }
 
 void KTextEditor::ViewPrivate::exportHtmlToFile(const QString &file)
 {
     KateExporter(this).exportToFile(file);
 }
 
 void KTextEditor::ViewPrivate::exportHtmlToClipboard ()
 {
     KateExporter(this).exportToClipboard();
 }
 
 void KTextEditor::ViewPrivate::exportHtmlToFile ()
 {
     const QString file = QFileDialog::getSaveFileName(this, i18n("Export File as HTML"), doc()->documentName());
     if (!file.isEmpty()) {
         KateExporter(this).exportToFile(file);
     }
 }
 
 void KTextEditor::ViewPrivate::clearHighlights()
 {
     qDeleteAll(m_rangesForHighlights);
     m_rangesForHighlights.clear();
     m_currentTextForHighlights.clear();
 }
 
 void KTextEditor::ViewPrivate::selectionChangedForHighlights()
 {
     QString text;
     // if text of selection is still the same, abort
     if (selection() && selectionRange().onSingleLine()) {
         text = selectionText();
         if (text == m_currentTextForHighlights)
             return;
     }
 
     // text changed: remove all highlights + create new ones
     // (do not call clearHighlights(), since this also resets the m_currentTextForHighlights
     qDeleteAll(m_rangesForHighlights);
     m_rangesForHighlights.clear();
 
     // do not highlight strings with leading and trailing spaces
     if (!text.isEmpty() && (text.at(0).isSpace() || text.at(text.length()-1).isSpace()))
         return;
 
     // trigger creation of ranges for current view range
     m_currentTextForHighlights = text;
     createHighlights();
 }
 
 void KTextEditor::ViewPrivate::createHighlights()
 {
     // do nothing if no text to highlight
     if (m_currentTextForHighlights.isEmpty()) {
         return;
     }
 
     KTextEditor::Attribute::Ptr attr(new KTextEditor::Attribute());
     attr->setBackground(Qt::yellow);
 
     // set correct highlight color from Kate's color schema
     QColor fgColor = defaultStyleAttribute(KTextEditor::dsNormal)->foreground().color();
     QColor bgColor = renderer()->config()->searchHighlightColor();
     attr->setForeground(fgColor);
     attr->setBackground(bgColor);
 
     KTextEditor::Cursor start(visibleRange().start());
     KTextEditor::Range searchRange;
 
     /**
      * only add word boundary if we can find the text then
      * fixes $lala hl
      */
     QString regex = QRegExp::escape (m_currentTextForHighlights);
     if (QRegExp (QStringLiteral("\\b%1").arg(regex)).indexIn (QStringLiteral(" %1 ").arg(m_currentTextForHighlights)) != -1)
         regex = QStringLiteral("\\b%1").arg(regex);
     if (QRegExp (QStringLiteral("%1\\b").arg(regex)).indexIn (QStringLiteral(" %1 ").arg(m_currentTextForHighlights)) != -1)
         regex = QStringLiteral("%1\\b").arg(regex);
 
     QVector<KTextEditor::Range> matches;
     do {
         searchRange.setRange(start, visibleRange().end());
 
         matches = doc()->searchText(searchRange, regex, KTextEditor::Regex);
 
         if (matches.first().isValid()) {
             KTextEditor::MovingRange* mr = doc()->newMovingRange(matches.first());
             mr->setAttribute(attr);
             mr->setView(this);
             mr->setZDepth(-90000.0); // Set the z-depth to slightly worse than the selection
             mr->setAttributeOnlyForViews(true);
             m_rangesForHighlights.append(mr);
             start = matches.first().end();
         }
     } while (matches.first().isValid());
 }
 
 KateAbstractInputMode *KTextEditor::ViewPrivate::currentInputMode() const
 {
     return m_viewInternal->m_currentInputMode;
 }
 
 void KTextEditor::ViewPrivate::toggleInputMode()
 {
     if (QAction *a = dynamic_cast<QAction *>(sender())) {
         setInputMode(static_cast<KTextEditor::View::InputMode>(a->data().toInt()));
     }
 }
 
 void KTextEditor::ViewPrivate::cycleInputMode()
 {
     InputMode current = currentInputMode()->viewInputMode();
     InputMode to = (current == KTextEditor::View::NormalInputMode) ? KTextEditor::View::ViInputMode : KTextEditor::View::NormalInputMode;
     setInputMode(to);
 }
 
 //BEGIN KTextEditor::PrintInterface stuff
 bool KTextEditor::ViewPrivate::print()
 {
     return KatePrinter::print(this);
 }
 
 void KTextEditor::ViewPrivate::printPreview()
 {
     KatePrinter::printPreview(this);
 }
 
 //END
 
 //BEGIN KTextEditor::InlineNoteInterface
 void KTextEditor::ViewPrivate::registerInlineNoteProvider(KTextEditor::InlineNoteProvider *provider)
 {
     if (! m_inlineNoteProviders.contains(provider)) {
         m_inlineNoteProviders.append(provider);
 
         connect(provider, &KTextEditor::InlineNoteProvider::inlineNotesReset, this, &ViewPrivate::inlineNotesReset);
         connect(provider, &KTextEditor::InlineNoteProvider::inlineNotesChanged, this, &ViewPrivate::inlineNotesLineChanged);
 
         inlineNotesReset();
     }
 }
 
 void KTextEditor::ViewPrivate::unregisterInlineNoteProvider(KTextEditor::InlineNoteProvider *provider)
 {
     const int index = m_inlineNoteProviders.indexOf(provider);
     if (index >= 0) {
         m_inlineNoteProviders.removeAt(index);
 
         provider->disconnect(this);
 
         inlineNotesReset();
     }
 }
 
 QVarLengthArray<KateInlineNoteData, 8> KTextEditor::ViewPrivate::inlineNotes(int line) const
 {
     QVarLengthArray<KateInlineNoteData, 8> allInlineNotes;
     for (KTextEditor::InlineNoteProvider *provider: m_inlineNoteProviders) {
         int index = 0;
         for (auto column: provider->inlineNotes(line)) {
             KateInlineNoteData note = {
                 provider,
                 this,
                 {line, column},
                 index,
                 m_viewInternal->m_activeInlineNote.m_underMouse,
                 m_viewInternal->renderer()->currentFont(),
                 m_viewInternal->renderer()->lineHeight()
             };
             allInlineNotes.append(note);
             index++;
         }
     }
     return allInlineNotes;
 }
 
 QRect KTextEditor::ViewPrivate::inlineNoteRect(const KateInlineNoteData& note) const
 {
     return m_viewInternal->inlineNoteRect(note);
 }
 
 void KTextEditor::ViewPrivate::inlineNotesReset()
 {
     m_viewInternal->m_activeInlineNote = {};
     tagLines(0, doc()->lastLine(), true);
 }
 
 void KTextEditor::ViewPrivate::inlineNotesLineChanged(int line)
 {
     if ( line == m_viewInternal->m_activeInlineNote.m_position.line() ) {
         m_viewInternal->m_activeInlineNote = {};
     }
     tagLines(line, line, true);
 }
 
 //END KTextEditor::InlineNoteInterface
 
 KTextEditor::Attribute::Ptr KTextEditor::ViewPrivate::defaultStyleAttribute(KTextEditor::DefaultStyle defaultStyle) const
 {
     KateRendererConfig * renderConfig = const_cast<KTextEditor::ViewPrivate*>(this)->renderer()->config();
 
     KTextEditor::Attribute::Ptr style = doc()->highlight()->attributes(renderConfig->schema()).at(defaultStyle);
     if (!style->hasProperty(QTextFormat::BackgroundBrush)) {
         // make sure the returned style has the default background color set
         style = new KTextEditor::Attribute(*style);
         style->setBackground(QBrush(renderConfig->backgroundColor()));
     }
     return style;
 }
 
 QList<KTextEditor::AttributeBlock> KTextEditor::ViewPrivate::lineAttributes(int line)
 {
     QList<KTextEditor::AttributeBlock> attribs;
 
     if (line < 0 || line >= doc()->lines())
         return attribs;
 
     Kate::TextLine kateLine = doc()->kateTextLine(line);
     if (!kateLine) {
         return attribs;
     }
 
     const QVector<Kate::TextLineData::Attribute> &intAttrs = kateLine->attributesList();
     for (int i = 0; i < intAttrs.size(); ++i) {
         if (intAttrs[i].length > 0 && intAttrs[i].attributeValue > 0) {
             attribs << KTextEditor::AttributeBlock(
                         intAttrs.at(i).offset,
                         intAttrs.at(i).length,
                         renderer()->attribute(intAttrs.at(i).attributeValue)
                     );
         }
     }
 
     return attribs;
 }
diff --git a/src/view/kateviewinternal.cpp b/src/view/kateviewinternal.cpp
index 7a263159..ddbaa76f 100644
--- a/src/view/kateviewinternal.cpp
+++ b/src/view/kateviewinternal.cpp
@@ -1,3856 +1,3859 @@
 /* This file is part of the KDE libraries
    Copyright (C) 2002 John Firebaugh <jfirebaugh@kde.org>
    Copyright (C) 2002 Joseph Wenninger <jowenn@kde.org>
    Copyright (C) 2002,2003 Christoph Cullmann <cullmann@kde.org>
    Copyright (C) 2002-2007 Hamish Rodda <rodda@kde.org>
    Copyright (C) 2003 Anakim Border <aborder@sources.sourceforge.net>
    Copyright (C) 2007 Mirko Stocker <me@misto.ch>
    Copyright (C) 2007 Matthew Woehlke <mw_triad@users.sourceforge.net>
    Copyright (C) 2008 Erlend Hamberg <ehamberg@gmail.com>
 
    Based on:
      KWriteView : Copyright (C) 1999 Jochen Wilhelmy <digisnap@cs.tu-berlin.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "kateviewinternal.h"
 
 #include "kateview.h"
 #include "kateviewhelpers.h"
 #include "katehighlight.h"
 #include "katebuffer.h"
 #include "katerenderer.h"
 #include "kateconfig.h"
 #include "katelayoutcache.h"
 #include "katecompletionwidget.h"
 #include "spellcheck/spellingmenu.h"
 #include "kateviewaccessible.h"
 #include "katetextanimation.h"
 #include "katemessagewidget.h"
 #include "kateglobal.h"
 #include "kateabstractinputmodefactory.h"
 #include "kateabstractinputmode.h"
 #include "katepartdebug.h"
 #include "inlinenotedata.h"
 
 #include <ktexteditor/movingrange.h>
 #include <ktexteditor/documentcursor.h>
 #include <ktexteditor/inlinenoteprovider.h>
 #include <ktexteditor/texthintinterface.h>
 #include <KCursor>
 
 #include <QMimeData>
 #include <QAccessible>
 #include <QClipboard>
 #include <QKeyEvent>
 #include <QPainter>
 #include <QPixmap>
 #include <QApplication>
 #include <QLayout>
 #include <QStyle>
 #include <QToolTip>
 
 static const bool debugPainting = false;
 
 class ZoomEventFilter
 {
 public:
     ZoomEventFilter() = default;
 
     bool detectZoomingEvent(QWheelEvent *e, Qt::KeyboardModifiers modifier = Qt::ControlModifier)
     {
         Qt::KeyboardModifiers modState = e->modifiers();
         if (modState == modifier) {
             if (m_lastWheelEvent.isValid()) {
                 const qint64 deltaT = m_lastWheelEvent.elapsed();
                 // Pressing the specified modifier key within 200ms of the previous "unmodified"
                 // wheelevent is not allowed to toggle on text zooming
                 if (m_lastWheelEventUnmodified && deltaT < 200) {
                     m_ignoreZoom = true;
                 }
                 else if (deltaT > 1000) {
                     // the protection is kept active for 1s after the last wheel event
                     // TODO: this value should be tuned, preferably by someone using
                     // Ctrl+Wheel zooming frequently.
                     m_ignoreZoom = false;
                 }
             } else {
                 // we can't say anything and have to assume there's nothing
                 // accidental to the modifier being pressed.
                 m_ignoreZoom = false;
             }
             m_lastWheelEventUnmodified = false;
             if (m_ignoreZoom) {
                 // unset the modifier so the view scrollbars can handle the scroll
                 // event and produce normal, not accelerated scrolling
                 modState &= ~modifier;
                 e->setModifiers(modState);
             }
         } else {
             // state is reset after any wheel event without the zoom modifier
             m_lastWheelEventUnmodified = true;
             m_ignoreZoom = false;
         }
         m_lastWheelEvent.start();
 
         // inform the caller whether this event is allowed to trigger text zooming.
         return !m_ignoreZoom && modState == modifier;
     }
 
 protected:
     QElapsedTimer m_lastWheelEvent;
     bool m_ignoreZoom = false;
     bool m_lastWheelEventUnmodified = false;
 };
 
 KateViewInternal::KateViewInternal(KTextEditor::ViewPrivate *view)
     : QWidget(view)
     , editSessionNumber(0)
     , editIsRunning(false)
     , m_view(view)
     , m_cursor(doc()->buffer(), KTextEditor::Cursor(0, 0), Kate::TextCursor::MoveOnInsert)
     , m_mouse()
     , m_possibleTripleClick(false)
     , m_completionItemExpanded(false)
     , m_bm(doc()->newMovingRange(KTextEditor::Range::invalid(), KTextEditor::MovingRange::DoNotExpand))
     , m_bmStart(doc()->newMovingRange(KTextEditor::Range::invalid(), KTextEditor::MovingRange::DoNotExpand))
     , m_bmEnd(doc()->newMovingRange(KTextEditor::Range::invalid(), KTextEditor::MovingRange::DoNotExpand))
     , m_bmLastFlashPos(doc()->newMovingCursor(KTextEditor::Cursor::invalid()))
     , m_dummy(nullptr)
 
     // stay on cursor will avoid that the view scroll around on press return at beginning
     , m_startPos(doc()->buffer(), KTextEditor::Cursor(0, 0), Kate::TextCursor::StayOnInsert)
 
     , m_visibleLineCount(0)
     , m_madeVisible(false)
     , m_shiftKeyPressed(false)
     , m_autoCenterLines(0)
     , m_minLinesVisible(0)
     , m_selChangedByUser(false)
     , m_selectAnchor(-1, -1)
     , m_selectionMode(Default)
     , m_layoutCache(new KateLayoutCache(renderer(), this))
     , m_preserveX(false)
     , m_preservedX(0)
     , m_cachedMaxStartPos(-1, -1)
     , m_dragScrollTimer(this)
     , m_scrollTimer(this)
     , m_cursorTimer(this)
     , m_textHintTimer(this)
     , m_textHintDelay(500)
     , m_textHintPos(-1, -1)
     , m_imPreeditRange(nullptr)
 {
     QList<KateAbstractInputModeFactory *> factories = KTextEditor::EditorPrivate::self()->inputModeFactories();
     Q_FOREACH(KateAbstractInputModeFactory *factory, factories) {
         KateAbstractInputMode *m = factory->createInputMode(this);
         m_inputModes.insert(m->viewInputMode(), m);
     }
     m_currentInputMode = m_inputModes[KTextEditor::View::NormalInputMode]; // TODO: twisted, but needed
 
     setMinimumSize(0, 0);
     setAttribute(Qt::WA_OpaquePaintEvent);
     setAttribute(Qt::WA_InputMethodEnabled);
 
     // invalidate m_selectionCached.start(), or keyb selection is screwed initially
     m_selectionCached = KTextEditor::Range::invalid();
 
     // bracket markers are only for this view and should not be printed
     m_bm->setView(m_view);
     m_bmStart->setView(m_view);
     m_bmEnd->setView(m_view);
     m_bm->setAttributeOnlyForViews(true);
     m_bmStart->setAttributeOnlyForViews(true);
     m_bmEnd->setAttributeOnlyForViews(true);
 
     // use z depth defined in moving ranges interface
     m_bm->setZDepth(-1000.0);
     m_bmStart->setZDepth(-1000.0);
     m_bmEnd->setZDepth(-1000.0);
 
     // update mark attributes
     updateBracketMarkAttributes();
 
     //
     // scrollbar for lines
     //
     m_lineScroll = new KateScrollBar(Qt::Vertical, this);
     m_lineScroll->show();
     m_lineScroll->setTracking(true);
     m_lineScroll->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
 
     // Hijack the line scroller's controls, so we can scroll nicely for word-wrap
     connect(m_lineScroll, SIGNAL(actionTriggered(int)), SLOT(scrollAction(int)));
     connect(m_lineScroll, SIGNAL(sliderMoved(int)), SLOT(scrollLines(int)));
     connect(m_lineScroll, SIGNAL(sliderMMBMoved(int)), SLOT(scrollLines(int)));
     connect(m_lineScroll, SIGNAL(valueChanged(int)), SLOT(scrollLines(int)));
 
     //
     // scrollbar for columns
     //
     m_columnScroll = new QScrollBar(Qt::Horizontal, m_view);
 
     if (m_view->dynWordWrap()) {
         m_columnScroll->hide();
     } else {
         m_columnScroll->show();
     }
 
     m_columnScroll->setTracking(true);
     m_startX = 0;
 
     connect(m_columnScroll, SIGNAL(valueChanged(int)), SLOT(scrollColumns(int)));
 
     // bottom corner box
     m_dummy = new QWidget(m_view);
     m_dummy->setFixedSize(m_lineScroll->width(), m_columnScroll->sizeHint().height());
     m_dummy->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
     if (m_view->dynWordWrap()) {
         m_dummy->hide();
     } else {
         m_dummy->show();
     }
 
     cache()->setWrap(m_view->dynWordWrap());
 
     //
     // iconborder ;)
     //
     m_leftBorder = new KateIconBorder(this, m_view);
     m_leftBorder->show();
 
     // update view if folding ranges change
     connect(&m_view->textFolding(), SIGNAL(foldingRangesChanged()), SLOT(slotRegionVisibilityChanged()));
 
     m_displayCursor.setPosition(0, 0);
 
     setAcceptDrops(true);
 
     m_zoomEventFilter = new ZoomEventFilter();
     // event filter
     installEventFilter(this);
 
     // set initial cursor
     m_mouseCursor = Qt::IBeamCursor;
     setCursor(m_mouseCursor);
 
     // call mouseMoveEvent also if no mouse button is pressed
     setMouseTracking(true);
 
     m_dragInfo.state = diNone;
 
     // timers
     connect(&m_dragScrollTimer, SIGNAL(timeout()),
             this, SLOT(doDragScroll()));
 
     connect(&m_scrollTimer, SIGNAL(timeout()),
             this, SLOT(scrollTimeout()));
 
     connect(&m_cursorTimer, SIGNAL(timeout()),
             this, SLOT(cursorTimeout()));
 
     connect(&m_textHintTimer, SIGNAL(timeout()),
             this, SLOT(textHintTimeout()));
 
     // selection changed to set anchor
     connect(m_view, SIGNAL(selectionChanged(KTextEditor::View*)),
             this, SLOT(viewSelectionChanged()));
 
 #ifndef QT_NO_ACCESSIBILITY
     QAccessible::installFactory(accessibleInterfaceFactory);
 #endif
     connect(doc(), &KTextEditor::DocumentPrivate::textInserted, this, &KateViewInternal::documentTextInserted);
     connect(doc(), &KTextEditor::DocumentPrivate::textRemoved, this, &KateViewInternal::documentTextRemoved);
 
     // update is called in KTextEditor::ViewPrivate, after construction and layout is over
     // but before any other kateviewinternal call
 }
 
 KateViewInternal::~KateViewInternal()
 {
     // delete text animation object here, otherwise it updates the view in its destructor
     delete m_textAnimation;
 
 #ifndef QT_NO_ACCESSIBILITY
     QAccessible::removeFactory(accessibleInterfaceFactory);
 #endif
 
     // kill preedit ranges
     delete m_imPreeditRange;
     qDeleteAll(m_imPreeditRangeChildren);
 
     qDeleteAll(m_inputModes);
 
     // delete bracket markers
     delete m_bm;
     delete m_bmStart;
     delete m_bmEnd;
 
     delete m_zoomEventFilter;
 }
 
 void KateViewInternal::prepareForDynWrapChange()
 {
     // Which is the current view line?
     m_wrapChangeViewLine = cache()->displayViewLine(m_displayCursor, true);
 }
 
 void KateViewInternal::dynWrapChanged()
 {
     m_dummy->setFixedSize(m_lineScroll->width(), m_columnScroll->sizeHint().height());
     if (view()->dynWordWrap()) {
         m_columnScroll->hide();
         m_dummy->hide();
 
     } else {
         // column scrollbar + bottom corner box
         m_columnScroll->show();
         m_dummy->show();
     }
 
     cache()->setWrap(view()->dynWordWrap());
     updateView();
 
     if (view()->dynWordWrap()) {
         scrollColumns(0);
     }
 
     // Determine where the cursor should be to get the cursor on the same view line
     if (m_wrapChangeViewLine != -1) {
         KTextEditor::Cursor newStart = viewLineOffset(m_displayCursor, -m_wrapChangeViewLine);
         makeVisible(newStart, newStart.column(), true);
 
     } else {
         update();
     }
 }
 
 KTextEditor::Cursor KateViewInternal::endPos() const
 {
     // Hrm, no lines laid out at all??
     if (!cache()->viewCacheLineCount()) {
         return KTextEditor::Cursor();
     }
 
     for (int i = qMin(linesDisplayed() - 1, cache()->viewCacheLineCount() - 1); i >= 0; i--) {
         const KateTextLayout &thisLine = cache()->viewLine(i);
 
         if (thisLine.line() == -1) {
             continue;
         }
 
         if (thisLine.virtualLine() >= view()->textFolding().visibleLines()) {
             // Cache is too out of date
             return KTextEditor::Cursor(view()->textFolding().visibleLines() - 1, doc()->lineLength(view()->textFolding().visibleLineToLine(view()->textFolding().visibleLines() - 1)));
         }
 
         return KTextEditor::Cursor(thisLine.virtualLine(), thisLine.wrap() ? thisLine.endCol() - 1 : thisLine.endCol());
     }
 
     // can happen, if view is still invisible
     return KTextEditor::Cursor();
 }
 
 int KateViewInternal::endLine() const
 {
     return endPos().line();
 }
 
 KateTextLayout KateViewInternal::yToKateTextLayout(int y) const
 {
     if (y < 0 || y > size().height()) {
         return KateTextLayout::invalid();
     }
 
     int range = y / renderer()->lineHeight();
 
     // lineRanges is always bigger than 0, after the initial updateView call
     if (range >= 0 && range < cache()->viewCacheLineCount()) {
         return cache()->viewLine(range);
     }
 
     return KateTextLayout::invalid();
 }
 
 int KateViewInternal::lineToY(int viewLine) const
 {
     return (viewLine - startLine()) * renderer()->lineHeight();
 }
 
 void KateViewInternal::slotIncFontSizes(qreal step)
 {
     renderer()->increaseFontSizes(step);
 }
 
 void KateViewInternal::slotDecFontSizes(qreal step)
 {
     renderer()->decreaseFontSizes(step);
 }
 
 /**
  * Line is the real line number to scroll to.
  */
 void KateViewInternal::scrollLines(int line)
 {
     KTextEditor::Cursor newPos(line, 0);
     scrollPos(newPos);
 }
 
 // This can scroll less than one true line
 void KateViewInternal::scrollViewLines(int offset)
 {
     KTextEditor::Cursor c = viewLineOffset(startPos(), offset);
     scrollPos(c);
 
     bool blocked = m_lineScroll->blockSignals(true);
     m_lineScroll->setValue(startLine());
     m_lineScroll->blockSignals(blocked);
 }
 
 void KateViewInternal::scrollAction(int action)
 {
     switch (action) {
     case QAbstractSlider::SliderSingleStepAdd:
         scrollNextLine();
         break;
 
     case QAbstractSlider::SliderSingleStepSub:
         scrollPrevLine();
         break;
 
     case QAbstractSlider::SliderPageStepAdd:
         scrollNextPage();
         break;
 
     case QAbstractSlider::SliderPageStepSub:
         scrollPrevPage();
         break;
 
     case QAbstractSlider::SliderToMinimum:
         top_home();
         break;
 
     case QAbstractSlider::SliderToMaximum:
         bottom_end();
         break;
     }
 }
 
 void KateViewInternal::scrollNextPage()
 {
     scrollViewLines(qMax(linesDisplayed() - 1, 0));
 }
 
 void KateViewInternal::scrollPrevPage()
 {
     scrollViewLines(-qMax(linesDisplayed() - 1, 0));
 }
 
 void KateViewInternal::scrollPrevLine()
 {
     scrollViewLines(-1);
 }
 
 void KateViewInternal::scrollNextLine()
 {
     scrollViewLines(1);
 }
 
 KTextEditor::Cursor KateViewInternal::maxStartPos(bool changed)
 {
     cache()->setAcceptDirtyLayouts(true);
 
     if (m_cachedMaxStartPos.line() == -1 || changed) {
         KTextEditor::Cursor end(view()->textFolding().visibleLines() - 1, doc()->lineLength(view()->textFolding().visibleLineToLine(view()->textFolding().visibleLines() - 1)));
 
         if (view()->config()->scrollPastEnd()) {
             m_cachedMaxStartPos = viewLineOffset(end, -m_minLinesVisible);
         } else {
             m_cachedMaxStartPos = viewLineOffset(end, -(linesDisplayed() - 1));
         }
     }
 
     cache()->setAcceptDirtyLayouts(false);
 
     return m_cachedMaxStartPos;
 }
 
 // c is a virtual cursor
 void KateViewInternal::scrollPos(KTextEditor::Cursor &c, bool force, bool calledExternally, bool emitSignals)
 {
     if (!force && ((!view()->dynWordWrap() && c.line() == startLine()) || c == startPos())) {
         return;
     }
 
     if (c.line() < 0) {
         c.setLine(0);
     }
 
     KTextEditor::Cursor limit = maxStartPos();
     if (c > limit) {
         c = limit;
 
         // Re-check we're not just scrolling to the same place
         if (!force && ((!view()->dynWordWrap() && c.line() == startLine()) || c == startPos())) {
             return;
         }
     }
 
     int viewLinesScrolled = 0;
 
     // only calculate if this is really used and useful, could be wrong here, please recheck
     // for larger scrolls this makes 2-4 seconds difference on my xeon with dyn. word wrap on
     // try to get it really working ;)
     bool viewLinesScrolledUsable = !force
                                    && (c.line() >= startLine() - linesDisplayed() - 1)
                                    && (c.line() <= endLine() + linesDisplayed() + 1);
 
     if (viewLinesScrolledUsable) {
         viewLinesScrolled = cache()->displayViewLine(c);
     }
 
     m_startPos.setPosition(c);
 
     // set false here but reversed if we return to makeVisible
     m_madeVisible = false;
 
     if (viewLinesScrolledUsable) {
         int lines = linesDisplayed();
         if (view()->textFolding().visibleLines() < lines) {
             KTextEditor::Cursor end(view()->textFolding().visibleLines() - 1, doc()->lineLength(view()->textFolding().visibleLineToLine(view()->textFolding().visibleLines() - 1)));
             lines = qMin(linesDisplayed(), cache()->displayViewLine(end) + 1);
         }
 
         Q_ASSERT(lines >= 0);
 
         if (!calledExternally && qAbs(viewLinesScrolled) < lines &&
             // NOTE: on some machines we must update if the floating widget is visible
             //       otherwise strange painting bugs may occur during scrolling...
             !((view()->m_messageWidgets[KTextEditor::Message::TopInView] &&
                view()->m_messageWidgets[KTextEditor::Message::TopInView]->isVisible())
             ||(view()->m_messageWidgets[KTextEditor::Message::CenterInView] &&
                view()->m_messageWidgets[KTextEditor::Message::CenterInView]->isVisible())
             ||(view()->m_messageWidgets[KTextEditor::Message::BottomInView] &&
                view()->m_messageWidgets[KTextEditor::Message::BottomInView]->isVisible())
             )
         ) {
             updateView(false, viewLinesScrolled);
 
             int scrollHeight = -(viewLinesScrolled * (int)renderer()->lineHeight());
 
             // scroll excluding child widgets (floating notifications)
             scroll(0, scrollHeight, rect());
             m_leftBorder->scroll(0, scrollHeight);
 
             if (emitSignals) {
                 emit view()->verticalScrollPositionChanged(m_view, c);
                 emit view()->displayRangeChanged(m_view);
             }
             return;
         }
     }
 
     updateView();
     update();
     m_leftBorder->update();
     if (emitSignals) {
         emit view()->verticalScrollPositionChanged(m_view, c);
         emit view()->displayRangeChanged(m_view);
     }
 }
 
 void KateViewInternal::scrollColumns(int x)
 {
     if (x < 0) {
         x = 0;
     }
 
     if (x > m_columnScroll->maximum()) {
         x = m_columnScroll->maximum();
     }
 
     if (x == startX()) {
         return;
     }
 
     int dx = startX() - x;
     m_startX = x;
 
     if (qAbs(dx) < width()) {
         // scroll excluding child widgets (floating notifications)
         scroll(dx, 0, rect());
     } else {
         update();
     }
 
     emit view()->horizontalScrollPositionChanged(m_view);
     emit view()->displayRangeChanged(m_view);
 
     bool blocked = m_columnScroll->blockSignals(true);
     m_columnScroll->setValue(startX());
     m_columnScroll->blockSignals(blocked);
 }
 
 // If changed is true, the lines that have been set dirty have been updated.
 void KateViewInternal::updateView(bool changed, int viewLinesScrolled)
 {
     if (!isVisible() && !viewLinesScrolled && !changed) {
         return;    //When this view is not visible, don't do anything
     }
 
     view()->doc()->delayAutoReload(); // Don't reload while user scrolls around
     bool blocked = m_lineScroll->blockSignals(true);
 
     int wrapWidth = width();
     if (view()->config()->dynWrapAtStaticMarker() && view()->config()->dynWordWrap()) {
         // We need to transform char count to a pixel width, stolen from PrintPainter::updateCache()
         QString s; s.fill(QLatin1Char('5'), view()->doc()->config()->wordWrapAt());
         wrapWidth = qMin(width(), static_cast<int>(renderer()->currentFontMetrics().width(s)));
     }
 
     if (wrapWidth != cache()->viewWidth()) {
         cache()->setViewWidth(wrapWidth);
         changed = true;
     }
 
     /* It was observed that height() could be negative here --
        when the main Kate view has 0 as size (during creation),
        and there frame around KateViewInternal.  In which
        case we'd set the view cache to 0 (or less!) lines, and
        start allocating huge chunks of data, later. */
     int newSize = (qMax(0, height()) / renderer()->lineHeight()) + 1;
     cache()->updateViewCache(startPos(), newSize, viewLinesScrolled);
     m_visibleLineCount = newSize;
 
     KTextEditor::Cursor maxStart = maxStartPos(changed);
     int maxLineScrollRange = maxStart.line();
     if (view()->dynWordWrap() && maxStart.column() != 0) {
         maxLineScrollRange++;
     }
     m_lineScroll->setRange(0, maxLineScrollRange);
 
     m_lineScroll->setValue(startLine());
     m_lineScroll->setSingleStep(1);
     m_lineScroll->setPageStep(qMax(0, height()) / renderer()->lineHeight());
     m_lineScroll->blockSignals(blocked);
 
     KateViewConfig::ScrollbarMode show_scrollbars = static_cast<KateViewConfig::ScrollbarMode>(view()->config()->showScrollbars());
 
     bool visible = ((show_scrollbars == KateViewConfig::AlwaysOn) ||
                     ((show_scrollbars == KateViewConfig::ShowWhenNeeded) && (maxLineScrollRange != 0)));
     bool visible_dummy = visible;
 
     m_lineScroll->setVisible(visible);
 
     if (!view()->dynWordWrap()) {
         int max = maxLen(startLine()) - width();
         if (max < 0) {
             max = 0;
         }
 
         // if we lose the ability to scroll horizontally, move view to the far-left
         if (max == 0) {
             scrollColumns(0);
         }
 
         blocked = m_columnScroll->blockSignals(true);
 
         // disable scrollbar
         m_columnScroll->setDisabled(max == 0);
 
         visible = ((show_scrollbars == KateViewConfig::AlwaysOn) ||
                    ((show_scrollbars == KateViewConfig::ShowWhenNeeded) && (max != 0)));
         visible_dummy &= visible;
         m_columnScroll->setVisible(visible);
 
         m_columnScroll->setRange(0, max + (renderer()->spaceWidth() / 2)); // Add some space for the caret at EOL
 
         m_columnScroll->setValue(startX());
 
         // Approximate linescroll
         m_columnScroll->setSingleStep(renderer()->config()->fontMetrics().width(QLatin1Char('a')));
         m_columnScroll->setPageStep(width());
 
         m_columnScroll->blockSignals(blocked);
     } else {
         visible_dummy = false;
     }
 
     m_dummy->setVisible(visible_dummy);
 
     if (changed) {
         updateDirty();
     }
 }
 
 /**
  * this function ensures a certain location is visible on the screen.
  * if endCol is -1, ignore making the columns visible.
  */
 void KateViewInternal::makeVisible(const KTextEditor::Cursor &c, int endCol, bool force, bool center, bool calledExternally)
 {
     //qCDebug(LOG_KTE) << "MakeVisible start " << startPos() << " end " << endPos() << " -> request: " << c;// , new start [" << scroll.line << "," << scroll.col << "] lines " << (linesDisplayed() - 1) << " height " << height();
     // if the line is in a folded region, unfold all the way up
     //if ( doc()->foldingTree()->findNodeForLine( c.line )->visible )
     //  qCDebug(LOG_KTE)<<"line ("<<c.line<<") should be visible";
 
+    const int lnDisp = linesDisplayed();
+    const bool curBelowScreen = (cache()->displayViewLine(c, true) < 0 && cache()->displayViewLine(c, false) > 0);
+
     if (force) {
         KTextEditor::Cursor scroll = c;
         scrollPos(scroll, force, calledExternally);
     } else if (center && (c < startPos() || c > endPos())) {
-        KTextEditor::Cursor scroll = viewLineOffset(c, -int(linesDisplayed()) / 2);
+        KTextEditor::Cursor scroll = viewLineOffset(c, -int(lnDisp) / 2);
         scrollPos(scroll, false, calledExternally);
-    } else if (c > viewLineOffset(startPos(), linesDisplayed() - m_minLinesVisible - 1)) {
-        KTextEditor::Cursor scroll = viewLineOffset(c, -(linesDisplayed() - m_minLinesVisible - 1));
+    } else if ((cache()->displayViewLine(c, true) >= (lnDisp - m_minLinesVisible)) || (curBelowScreen)) {
+        KTextEditor::Cursor scroll = viewLineOffset(c, -(lnDisp - m_minLinesVisible - 1));
         scrollPos(scroll, false, calledExternally);
     } else if (c < viewLineOffset(startPos(), m_minLinesVisible)) {
         KTextEditor::Cursor scroll = viewLineOffset(c, -m_minLinesVisible);
         scrollPos(scroll, false, calledExternally);
     } else {
         // Check to see that we're not showing blank lines
         KTextEditor::Cursor max = maxStartPos();
         if (startPos() > max) {
             scrollPos(max, max.column(), calledExternally);
         }
     }
 
     if (!view()->dynWordWrap() && (endCol != -1 || view()->wrapCursor())) {
         KTextEditor::Cursor rc = toRealCursor(c);
         int sX = renderer()->cursorToX(cache()->textLayout(rc), rc, !view()->wrapCursor());
 
         int sXborder = sX - 8;
         if (sXborder < 0) {
             sXborder = 0;
         }
 
         if (sX < startX()) {
             scrollColumns(sXborder);
         } else if (sX > startX() + width()) {
             scrollColumns(sX - width() + 8);
         }
     }
 
     m_madeVisible = !force;
 
 #ifndef QT_NO_ACCESSIBILITY
     // FIXME -- is this needed?
 //    QAccessible::updateAccessibility(this, KateCursorAccessible::ChildId, QAccessible::Focus);
 #endif
 
 }
 
 void KateViewInternal::slotRegionVisibilityChanged()
 {
     qCDebug(LOG_KTE);
     cache()->clear();
 
     m_cachedMaxStartPos.setLine(-1);
     KTextEditor::Cursor max = maxStartPos();
     if (startPos() > max) {
         scrollPos(max, false, false, false /* don't emit signals! */);
     }
 
     // if text was folded: make sure the cursor is on a visible line
     qint64 foldedRangeId = -1;
     if (!view()->textFolding().isLineVisible(m_cursor.line(), &foldedRangeId)) {
         KTextEditor::Range foldingRange = view()->textFolding().foldingRange(foldedRangeId);
         Q_ASSERT(foldingRange.start().isValid());
 
         // set cursor to start of folding region
         updateCursor(foldingRange.start(), true);
     } else {
         // force an update of the cursor, since otherwise the m_displayCursor
         // line may be below the total amount of visible lines.
         updateCursor(m_cursor, true);
     }
 
     updateView();
     update();
     m_leftBorder->update();
 
     // emit signals here, scrollPos has this disabled, to ensure we do this after all stuff is updated!
     emit view()->verticalScrollPositionChanged(m_view, max);
     emit view()->displayRangeChanged(m_view);
 }
 
 void KateViewInternal::slotRegionBeginEndAddedRemoved(unsigned int)
 {
     qCDebug(LOG_KTE);
     // FIXME: performance problem
     m_leftBorder->update();
 }
 
 void KateViewInternal::showEvent(QShowEvent *e)
 {
     updateView();
 
     QWidget::showEvent(e);
 }
 
 int KateViewInternal::linesDisplayed() const
 {
     int h = height();
 
     // catch zero heights, even if should not happen
     int fh = qMax(1, renderer()->lineHeight());
 
     // default to 1, there is always one line around....
     // too many places calc with linesDisplayed() - 1
     return qMax(1, (h - (h % fh)) / fh);
 }
 
 QPoint KateViewInternal::cursorToCoordinate(const KTextEditor::Cursor &cursor, bool realCursor, bool includeBorder) const
 {
     if (cursor.line() >= doc()->lines()) {
         return QPoint(-1, -1);
     }
 
     int viewLine = cache()->displayViewLine(realCursor ? toVirtualCursor(cursor) : cursor, true);
 
     if (viewLine < 0 || viewLine >= cache()->viewCacheLineCount()) {
         return QPoint(-1, -1);
     }
 
     const int y = (int)viewLine * renderer()->lineHeight();
 
     KateTextLayout layout = cache()->viewLine(viewLine);
 
     if (cursor.column() > doc()->lineLength(cursor.line())) {
         return QPoint(-1, -1);
     }
 
     int x = 0;
 
     // only set x value if we have a valid layout (bug #171027)
     if (layout.isValid()) {
         x = (int)layout.lineLayout().cursorToX(cursor.column());
     }
 //  else
 //    qCDebug(LOG_KTE) << "Invalid Layout";
 
     if (includeBorder) {
         x += m_leftBorder->width();
     }
 
     x -= startX();
 
     return QPoint(x, y);
 }
 
 QPoint KateViewInternal::cursorCoordinates(bool includeBorder) const
 {
     return cursorToCoordinate(m_displayCursor, false, includeBorder);
 }
 
 KTextEditor::Cursor KateViewInternal::findMatchingBracket()
 {
     KTextEditor::Cursor c;
 
     if (!m_bm->toRange().isValid()) {
         return KTextEditor::Cursor::invalid();
     }
 
     Q_ASSERT(m_bmEnd->toRange().isValid());
     Q_ASSERT(m_bmStart->toRange().isValid());
 
     if (m_bmStart->toRange().contains(m_cursor) || m_bmStart->end() == m_cursor.toCursor()) {
         c = m_bmEnd->end();
         // We need to adjust the cursor positon in case of override mode, BUG-402594
         if (doc()->config()->ovr()) {
             c.setColumn(c.column() - 1);
         }
     } else if (m_bmEnd->toRange().contains(m_cursor) || m_bmEnd->end() == m_cursor.toCursor()) {
         c = m_bmStart->start();
     } else {
         // should never happen: a range exists, but the cursor position is
         // neither at the start nor at the end...
         return KTextEditor::Cursor::invalid();
     }
 
     return c;
 }
 
 
 class CalculatingCursor
 {
 public:
     // These constructors constrain their arguments to valid positions
     // before only the third one did, but that leads to crashs
     // see bug 227449
     CalculatingCursor(KateViewInternal *vi)
         : m_vi(vi)
     {
         makeValid();
     }
 
     CalculatingCursor(KateViewInternal *vi, const KTextEditor::Cursor &c)
         : m_cursor(c)
         , m_vi(vi)
     {
         makeValid();
     }
 
     CalculatingCursor(KateViewInternal *vi, int line, int col)
         : m_cursor(line, col)
         , m_vi(vi)
     {
         makeValid();
     }
 
     virtual ~CalculatingCursor()
     {
     }
 
     int line() const
     {
         return m_cursor.line();
     }
 
     int column() const
     {
         return m_cursor.column();
     }
 
     operator KTextEditor::Cursor() const
     {
         return m_cursor;
     }
 
     virtual CalculatingCursor &operator+=(int n) = 0;
 
     virtual CalculatingCursor &operator-=(int n) = 0;
 
     CalculatingCursor &operator++()
     {
         return operator+=(1);
     }
 
     CalculatingCursor &operator--()
     {
         return operator-=(1);
     }
 
     void makeValid()
     {
         m_cursor.setLine(qBound(0, line(), int(doc()->lines() - 1)));
         if (view()->wrapCursor()) {
             m_cursor.setColumn(qBound(0, column(), doc()->lineLength(line())));
         } else {
             m_cursor.setColumn(qMax(0, column()));
         }
         Q_ASSERT(valid());
     }
 
     void toEdge(KateViewInternal::Bias bias)
     {
         if (bias == KateViewInternal::left) {
             m_cursor.setColumn(0);
         } else if (bias == KateViewInternal::right) {
             m_cursor.setColumn(doc()->lineLength(line()));
         }
     }
 
     bool atEdge() const
     {
         return atEdge(KateViewInternal::left) || atEdge(KateViewInternal::right);
     }
 
     bool atEdge(KateViewInternal::Bias bias) const
     {
         switch (bias) {
         case KateViewInternal::left:  return column() == 0;
         case KateViewInternal::none:  return atEdge();
         case KateViewInternal::right: return column() >= doc()->lineLength(line());
         default: Q_ASSERT(false); return false;
         }
     }
 
 protected:
     bool valid() const
     {
         return line() >= 0 &&
                line() < doc()->lines() &&
                column() >= 0 &&
                (!view()->wrapCursor() || column() <= doc()->lineLength(line()));
     }
     KTextEditor::ViewPrivate *view()
     {
         return m_vi->m_view;
     }
     const KTextEditor::ViewPrivate *view() const
     {
         return m_vi->m_view;
     }
     KTextEditor::DocumentPrivate *doc()
     {
         return view()->doc();
     }
     const KTextEditor::DocumentPrivate *doc() const
     {
         return view()->doc();
     }
     KTextEditor::Cursor m_cursor;
     KateViewInternal *m_vi;
 };
 
 class BoundedCursor : public CalculatingCursor
 {
 public:
     BoundedCursor(KateViewInternal *vi)
         : CalculatingCursor(vi) {}
     BoundedCursor(KateViewInternal *vi, const KTextEditor::Cursor &c)
         : CalculatingCursor(vi, c) {}
     BoundedCursor(KateViewInternal *vi, int line, int col)
         : CalculatingCursor(vi, line, col) {}
     CalculatingCursor &operator+=(int n) override
     {
         KateLineLayoutPtr thisLine = m_vi->cache()->line(line());
         if (!thisLine->isValid()) {
             qCWarning(LOG_KTE) << "Did not retrieve valid layout for line " << line();
             return *this;
         }
 
         const bool wrapCursor = view()->wrapCursor();
         int maxColumn = -1;
         if (n >= 0) {
             for (int i = 0; i < n; i++) {
                 if (column() >= thisLine->length()) {
                     if (wrapCursor) {
                         break;
 
                     } else if (view()->dynWordWrap()) {
                         // Don't go past the edge of the screen in dynamic wrapping mode
                         if (maxColumn == -1) {
                             maxColumn = thisLine->length() + ((m_vi->width() - thisLine->widthOfLastLine()) / m_vi->renderer()->spaceWidth()) - 1;
                         }
 
                         if (column() >= maxColumn) {
                             m_cursor.setColumn(maxColumn);
                             break;
                         }
 
                         m_cursor.setColumn(column() + 1);
 
                     } else {
                         m_cursor.setColumn(column() + 1);
                     }
 
                 } else {
                     m_cursor.setColumn(thisLine->layout()->nextCursorPosition(column()));
                 }
             }
         } else {
             for (int i = 0; i > n; i--) {
                 if (column() >= thisLine->length()) {
                     m_cursor.setColumn(column() - 1);
                 } else if (column() == 0) {
                     break;
                 } else {
                     m_cursor.setColumn(thisLine->layout()->previousCursorPosition(column()));
                 }
             }
         }
 
         Q_ASSERT(valid());
         return *this;
     }
     CalculatingCursor &operator-=(int n) override
     {
         return operator+=(-n);
     }
 };
 
 class WrappingCursor : public CalculatingCursor
 {
 public:
     WrappingCursor(KateViewInternal *vi)
         : CalculatingCursor(vi) {}
     WrappingCursor(KateViewInternal *vi, const KTextEditor::Cursor &c)
         : CalculatingCursor(vi, c) {}
     WrappingCursor(KateViewInternal *vi, int line, int col)
         : CalculatingCursor(vi, line, col) {}
 
     CalculatingCursor &operator+=(int n) override
     {
         KateLineLayoutPtr thisLine = m_vi->cache()->line(line());
         if (!thisLine->isValid()) {
             qCWarning(LOG_KTE) << "Did not retrieve a valid layout for line " << line();
             return *this;
         }
 
         if (n >= 0) {
             for (int i = 0; i < n; i++) {
                 if (column() >= thisLine->length()) {
                     // Have come to the end of a line
                     if (line() >= doc()->lines() - 1)
                         // Have come to the end of the document
                     {
                         break;
                     }
 
                     // Advance to the beginning of the next line
                     m_cursor.setColumn(0);
                     m_cursor.setLine(line() + 1);
 
                     // Retrieve the next text range
                     thisLine = m_vi->cache()->line(line());
                     if (!thisLine->isValid()) {
                         qCWarning(LOG_KTE) << "Did not retrieve a valid layout for line " << line();
                         return *this;
                     }
 
                     continue;
                 }
 
                 m_cursor.setColumn(thisLine->layout()->nextCursorPosition(column()));
             }
 
         } else {
             for (int i = 0; i > n; i--) {
                 if (column() == 0) {
                     // Have come to the start of the document
                     if (line() == 0) {
                         break;
                     }
 
                     // Start going back to the end of the last line
                     m_cursor.setLine(line() - 1);
 
                     // Retrieve the next text range
                     thisLine = m_vi->cache()->line(line());
                     if (!thisLine->isValid()) {
                         qCWarning(LOG_KTE) << "Did not retrieve a valid layout for line " << line();
                         return *this;
                     }
 
                     // Finish going back to the end of the last line
                     m_cursor.setColumn(thisLine->length());
 
                     continue;
                 }
 
                 if (column() > thisLine->length()) {
                     m_cursor.setColumn(column() - 1);
                 } else {
                     m_cursor.setColumn(thisLine->layout()->previousCursorPosition(column()));
                 }
             }
         }
 
         Q_ASSERT(valid());
         return *this;
     }
     CalculatingCursor &operator-=(int n) override
     {
         return operator+=(-n);
     }
 };
 
 void KateViewInternal::moveChar(KateViewInternal::Bias bias, bool sel)
 {
     KTextEditor::Cursor c;
     if (view()->wrapCursor()) {
         c = WrappingCursor(this, m_cursor) += bias;
     } else {
         c = BoundedCursor(this, m_cursor) += bias;
     }
 
     updateSelection(c, sel);
     updateCursor(c);
 }
 
 void KateViewInternal::cursorPrevChar(bool sel)
 {
     if (! view()->wrapCursor() && m_cursor.column() == 0) {
         return;
     }
 
     moveChar(KateViewInternal::left, sel);
 }
 
 void KateViewInternal::cursorNextChar(bool sel)
 {
     moveChar(KateViewInternal::right, sel);
 }
 
 void KateViewInternal::wordPrev(bool sel)
 {
     WrappingCursor c(this, m_cursor);
 
     // First we skip backwards all space.
     // Then we look up into which category the current position falls:
     // 1. a "word" character
     // 2. a "non-word" character (except space)
     // 3. the beginning of the line
     // and skip all preceding characters that fall into this class.
     // The code assumes that space is never part of the word character class.
 
     KateHighlighting *h = doc()->highlight();
     if (!c.atEdge(left)) {
 
         while (!c.atEdge(left) && doc()->line(c.line())[ c.column() - 1 ].isSpace()) {
             --c;
         }
     }
     if (c.atEdge(left)) {
         --c;
     } else if (h->isInWord(doc()->line(c.line())[ c.column() - 1 ])) {
         while (!c.atEdge(left) && h->isInWord(doc()->line(c.line())[ c.column() - 1 ])) {
             --c;
         }
     } else {
         while (!c.atEdge(left)
                 && !h->isInWord(doc()->line(c.line())[ c.column() - 1 ])
                 // in order to stay symmetric to wordLeft()
                 // we must not skip space preceding a non-word sequence
                 && !doc()->line(c.line())[ c.column() - 1 ].isSpace()) {
             --c;
         }
     }
 
     updateSelection(c, sel);
     updateCursor(c);
 }
 
 void KateViewInternal::wordNext(bool sel)
 {
     WrappingCursor c(this, m_cursor);
 
     // We look up into which category the current position falls:
     // 1. a "word" character
     // 2. a "non-word" character (except space)
     // 3. the end of the line
     // and skip all following characters that fall into this class.
     // If the skipped characters are followed by space, we skip that too.
     // The code assumes that space is never part of the word character class.
 
     KateHighlighting *h = doc()->highlight();
     if (c.atEdge(right)) {
         ++c;
     } else if (h->isInWord(doc()->line(c.line())[ c.column() ])) {
         while (!c.atEdge(right) && h->isInWord(doc()->line(c.line())[ c.column() ])) {
             ++c;
         }
     } else {
         while (!c.atEdge(right)
                 && !h->isInWord(doc()->line(c.line())[ c.column() ])
                 // we must not skip space, because if that space is followed
                 // by more non-word characters, we would skip them, too
                 && !doc()->line(c.line())[ c.column() ].isSpace()) {
             ++c;
         }
     }
 
     while (!c.atEdge(right) && doc()->line(c.line())[ c.column() ].isSpace()) {
         ++c;
     }
 
     updateSelection(c, sel);
     updateCursor(c);
 }
 
 void KateViewInternal::moveEdge(KateViewInternal::Bias bias, bool sel)
 {
     BoundedCursor c(this, m_cursor);
     c.toEdge(bias);
     updateSelection(c, sel);
     updateCursor(c);
 }
 
 void KateViewInternal::home(bool sel)
 {
     if (view()->dynWordWrap() && currentLayout().startCol()) {
         // Allow us to go to the real start if we're already at the start of the view line
         if (m_cursor.column() != currentLayout().startCol()) {
             KTextEditor::Cursor c = currentLayout().start();
             updateSelection(c, sel);
             updateCursor(c);
             return;
         }
     }
 
     if (!doc()->config()->smartHome()) {
         moveEdge(left, sel);
         return;
     }
 
     Kate::TextLine l = doc()->kateTextLine(m_cursor.line());
 
     if (!l) {
         return;
     }
 
     KTextEditor::Cursor c = m_cursor;
     int lc = l->firstChar();
 
     if (lc < 0 || c.column() == lc) {
         c.setColumn(0);
     } else {
         c.setColumn(lc);
     }
 
     updateSelection(c, sel);
     updateCursor(c, true);
 }
 
 void KateViewInternal::end(bool sel)
 {
     KateTextLayout layout = currentLayout();
 
     if (view()->dynWordWrap() && layout.wrap()) {
         // Allow us to go to the real end if we're already at the end of the view line
         if (m_cursor.column() < layout.endCol() - 1) {
             KTextEditor::Cursor c(m_cursor.line(), layout.endCol() - 1);
             updateSelection(c, sel);
             updateCursor(c);
             return;
         }
     }
 
     if (!doc()->config()->smartHome()) {
         moveEdge(right, sel);
         return;
     }
 
     Kate::TextLine l = doc()->kateTextLine(m_cursor.line());
 
     if (!l) {
         return;
     }
 
     // "Smart End", as requested in bugs #78258 and #106970
     if (m_cursor.column() == doc()->lineLength(m_cursor.line())) {
         KTextEditor::Cursor c = m_cursor;
         c.setColumn(l->lastChar() + 1);
         updateSelection(c, sel);
         updateCursor(c, true);
     } else {
         moveEdge(right, sel);
     }
 }
 
 KateTextLayout KateViewInternal::currentLayout() const
 {
     return cache()->textLayout(m_cursor);
 }
 
 KateTextLayout KateViewInternal::previousLayout() const
 {
     int currentViewLine = cache()->viewLine(m_cursor);
 
     if (currentViewLine) {
         return cache()->textLayout(m_cursor.line(), currentViewLine - 1);
     } else {
         return cache()->textLayout(view()->textFolding().visibleLineToLine(m_displayCursor.line() - 1), -1);
     }
 }
 
 KateTextLayout KateViewInternal::nextLayout() const
 {
     int currentViewLine = cache()->viewLine(m_cursor) + 1;
 
     if (currentViewLine >= cache()->line(m_cursor.line())->viewLineCount()) {
         currentViewLine = 0;
         return cache()->textLayout(view()->textFolding().visibleLineToLine(m_displayCursor.line() + 1), currentViewLine);
     } else {
         return cache()->textLayout(m_cursor.line(), currentViewLine);
     }
 }
 
 /*
  * This returns the cursor which is offset by (offset) view lines.
  * This is the main function which is called by code not specifically dealing with word-wrap.
  * The opposite conversion (cursor to offset) can be done with cache()->displayViewLine().
  *
  * The cursors involved are virtual cursors (ie. equivalent to m_displayCursor)
  */
 
 KTextEditor::Cursor KateViewInternal::viewLineOffset(const KTextEditor::Cursor &virtualCursor, int offset, bool keepX)
 {
     if (!view()->dynWordWrap()) {
         KTextEditor::Cursor ret(qMin((int)view()->textFolding().visibleLines() - 1, virtualCursor.line() + offset), 0);
 
         if (ret.line() < 0) {
             ret.setLine(0);
         }
 
         if (keepX) {
             int realLine = view()->textFolding().visibleLineToLine(ret.line());
             KateTextLayout t = cache()->textLayout(realLine, 0);
             Q_ASSERT(t.isValid());
 
             ret.setColumn(renderer()->xToCursor(t, m_preservedX, !view()->wrapCursor()).column());
         }
 
         return ret;
     }
 
     KTextEditor::Cursor realCursor = virtualCursor;
     realCursor.setLine(view()->textFolding().visibleLineToLine(view()->textFolding().lineToVisibleLine(virtualCursor.line())));
 
     int cursorViewLine = cache()->viewLine(realCursor);
 
     int currentOffset = 0;
     int virtualLine = 0;
 
     bool forwards = (offset > 0) ? true : false;
 
     if (forwards) {
         currentOffset = cache()->lastViewLine(realCursor.line()) - cursorViewLine;
         if (offset <= currentOffset) {
             // the answer is on the same line
             KateTextLayout thisLine = cache()->textLayout(realCursor.line(), cursorViewLine + offset);
             Q_ASSERT(thisLine.virtualLine() == (int) view()->textFolding().lineToVisibleLine(virtualCursor.line()));
             return KTextEditor::Cursor(virtualCursor.line(), thisLine.startCol());
         }
 
         virtualLine = virtualCursor.line() + 1;
 
     } else {
         offset = -offset;
         currentOffset = cursorViewLine;
         if (offset <= currentOffset) {
             // the answer is on the same line
             KateTextLayout thisLine = cache()->textLayout(realCursor.line(), cursorViewLine - offset);
             Q_ASSERT(thisLine.virtualLine() == (int) view()->textFolding().lineToVisibleLine(virtualCursor.line()));
             return KTextEditor::Cursor(virtualCursor.line(), thisLine.startCol());
         }
 
         virtualLine = virtualCursor.line() - 1;
     }
 
     currentOffset++;
 
     while (virtualLine >= 0 && virtualLine < (int)view()->textFolding().visibleLines()) {
         int realLine = view()->textFolding().visibleLineToLine(virtualLine);
         KateLineLayoutPtr thisLine = cache()->line(realLine, virtualLine);
         if (!thisLine) {
             break;
         }
 
         for (int i = 0; i < thisLine->viewLineCount(); ++i) {
             if (offset == currentOffset) {
                 KateTextLayout thisViewLine = thisLine->viewLine(i);
 
                 if (!forwards) {
                     // We actually want it the other way around
                     int requiredViewLine = cache()->lastViewLine(realLine) - thisViewLine.viewLine();
                     if (requiredViewLine != thisViewLine.viewLine()) {
                         thisViewLine = thisLine->viewLine(requiredViewLine);
                     }
                 }
 
                 KTextEditor::Cursor ret(virtualLine, thisViewLine.startCol());
 
                 // keep column position
                 if (keepX) {
                     KTextEditor::Cursor realCursor = toRealCursor(virtualCursor);
                     KateTextLayout t = cache()->textLayout(realCursor);
                     // renderer()->cursorToX(t, realCursor, !view()->wrapCursor());
 
                     realCursor = renderer()->xToCursor(thisViewLine, m_preservedX, !view()->wrapCursor());
                     ret.setColumn(realCursor.column());
                 }
 
                 return ret;
             }
 
             currentOffset++;
         }
 
         if (forwards) {
             virtualLine++;
         } else {
             virtualLine--;
         }
     }
 
     // Looks like we were asked for something a bit exotic.
     // Return the max/min valid position.
     if (forwards) {
         return KTextEditor::Cursor(view()->textFolding().visibleLines() - 1, doc()->lineLength(view()->textFolding().visibleLineToLine(view()->textFolding().visibleLines() - 1)));
     } else {
         return KTextEditor::Cursor(0, 0);
     }
 }
 
 int KateViewInternal::lineMaxCursorX(const KateTextLayout &range)
 {
     if (!view()->wrapCursor() && !range.wrap()) {
         return INT_MAX;
     }
 
     int maxX = range.endX();
 
     if (maxX && range.wrap()) {
         QChar lastCharInLine = doc()->kateTextLine(range.line())->at(range.endCol() - 1);
         maxX -= renderer()->config()->fontMetrics().width(lastCharInLine);
     }
 
     return maxX;
 }
 
 int KateViewInternal::lineMaxCol(const KateTextLayout &range)
 {
     int maxCol = range.endCol();
 
     if (maxCol && range.wrap()) {
         maxCol--;
     }
 
     return maxCol;
 }
 
 void KateViewInternal::cursorUp(bool sel)
 {
     if (!sel && view()->completionWidget()->isCompletionActive()) {
         view()->completionWidget()->cursorUp();
         return;
     }
 
     // assert that the display cursor is in visible lines
     Q_ASSERT(m_displayCursor.line() < view()->textFolding().visibleLines());
 
     /**
      * move cursor to start of line, if we are at first line!
      */
     if (m_displayCursor.line() == 0 && (!view()->dynWordWrap() || cache()->viewLine(m_cursor) == 0)) {
         home(sel);
         return;
     }
 
     m_preserveX = true;
 
     KateTextLayout thisLine = currentLayout();
     // This is not the first line because that is already simplified out above
     KateTextLayout pRange = previousLayout();
 
     // Ensure we're in the right spot
     Q_ASSERT(m_cursor.line() == thisLine.line());
     Q_ASSERT(m_cursor.column() >= thisLine.startCol());
     Q_ASSERT(!thisLine.wrap() || m_cursor.column() < thisLine.endCol());
 
     KTextEditor::Cursor c = renderer()->xToCursor(pRange, m_preservedX, !view()->wrapCursor());
 
     updateSelection(c, sel);
     updateCursor(c);
 }
 
 void KateViewInternal::cursorDown(bool sel)
 {
     if (!sel && view()->completionWidget()->isCompletionActive()) {
         view()->completionWidget()->cursorDown();
         return;
     }
 
     /**
      * move cursor to end of line, if we are at last line!
      */
     if ((m_displayCursor.line() >= view()->textFolding().visibleLines() - 1) && (!view()->dynWordWrap() || cache()->viewLine(m_cursor) == cache()->lastViewLine(m_cursor.line()))) {
         end(sel);
         return;
     }
 
     m_preserveX = true;
 
     KateTextLayout thisLine = currentLayout();
     // This is not the last line because that is already simplified out above
     KateTextLayout nRange = nextLayout();
 
     // Ensure we're in the right spot
     Q_ASSERT((m_cursor.line() == thisLine.line()) &&
              (m_cursor.column() >= thisLine.startCol()) &&
              (!thisLine.wrap() || m_cursor.column() < thisLine.endCol()));
 
     KTextEditor::Cursor c = renderer()->xToCursor(nRange, m_preservedX, !view()->wrapCursor());
 
     updateSelection(c, sel);
     updateCursor(c);
 }
 
 void KateViewInternal::cursorToMatchingBracket(bool sel)
 {
     KTextEditor::Cursor c = findMatchingBracket();
 
     if (c.isValid()) {
         updateSelection(c, sel);
         updateCursor(c);
     }
 }
 
 void KateViewInternal::topOfView(bool sel)
 {
     KTextEditor::Cursor c = viewLineOffset(startPos(), m_minLinesVisible);
     updateSelection(toRealCursor(c), sel);
     updateCursor(toRealCursor(c));
 }
 
 void KateViewInternal::bottomOfView(bool sel)
 {
     KTextEditor::Cursor c = viewLineOffset(endPos(), -m_minLinesVisible);
     updateSelection(toRealCursor(c), sel);
     updateCursor(toRealCursor(c));
 }
 
 // lines is the offset to scroll by
 void KateViewInternal::scrollLines(int lines, bool sel)
 {
     KTextEditor::Cursor c = viewLineOffset(m_displayCursor, lines, true);
 
     // Fix the virtual cursor -> real cursor
     c.setLine(view()->textFolding().visibleLineToLine(c.line()));
 
     updateSelection(c, sel);
     updateCursor(c);
 }
 
 // This is a bit misleading... it's asking for the view to be scrolled, not the cursor
 void KateViewInternal::scrollUp()
 {
     KTextEditor::Cursor newPos = viewLineOffset(startPos(), -1);
     scrollPos(newPos);
 }
 
 void KateViewInternal::scrollDown()
 {
     KTextEditor::Cursor newPos = viewLineOffset(startPos(), 1);
     scrollPos(newPos);
 }
 
 void KateViewInternal::setAutoCenterLines(int viewLines, bool updateView)
 {
     m_autoCenterLines = viewLines;
     m_minLinesVisible = qMin(int((linesDisplayed() - 1) / 2), m_autoCenterLines);
     if (updateView) {
         KateViewInternal::updateView();
     }
 }
 
 void KateViewInternal::pageUp(bool sel, bool half)
 {
     if (view()->isCompletionActive()) {
         view()->completionWidget()->pageUp();
         return;
     }
 
     // remember the view line and x pos
     int viewLine = cache()->displayViewLine(m_displayCursor);
     bool atTop = startPos().atStartOfDocument();
 
     // Adjust for an auto-centering cursor
     int lineadj = m_minLinesVisible;
 
     int linesToScroll;
     if (! half) {
         linesToScroll = -qMax((linesDisplayed() - 1) - lineadj, 0);
     } else {
         linesToScroll = -qMax((linesDisplayed() / 2 - 1) - lineadj, 0);
     }
 
     m_preserveX = true;
 
     if (!doc()->pageUpDownMovesCursor() && !atTop) {
         KTextEditor::Cursor newStartPos = viewLineOffset(startPos(), linesToScroll - 1);
         scrollPos(newStartPos);
 
         // put the cursor back approximately where it was
         KTextEditor::Cursor newPos = toRealCursor(viewLineOffset(newStartPos, viewLine, true));
 
         KateTextLayout newLine = cache()->textLayout(newPos);
 
         newPos = renderer()->xToCursor(newLine, m_preservedX, !view()->wrapCursor());
 
         m_preserveX = true;
         updateSelection(newPos, sel);
         updateCursor(newPos);
 
     } else {
         scrollLines(linesToScroll, sel);
     }
 }
 
 void KateViewInternal::pageDown(bool sel, bool half)
 {
     if (view()->isCompletionActive()) {
         view()->completionWidget()->pageDown();
         return;
     }
 
     // remember the view line
     int viewLine = cache()->displayViewLine(m_displayCursor);
     bool atEnd = startPos() >= m_cachedMaxStartPos;
 
     // Adjust for an auto-centering cursor
     int lineadj = m_minLinesVisible;
 
     int linesToScroll;
     if (! half) {
         linesToScroll = qMax((linesDisplayed() - 1) - lineadj, 0);
     } else {
         linesToScroll = qMax((linesDisplayed() / 2 - 1) - lineadj, 0);
     }
 
     m_preserveX = true;
 
     if (!doc()->pageUpDownMovesCursor() && !atEnd) {
         KTextEditor::Cursor newStartPos = viewLineOffset(startPos(), linesToScroll + 1);
         scrollPos(newStartPos);
 
         // put the cursor back approximately where it was
         KTextEditor::Cursor newPos = toRealCursor(viewLineOffset(newStartPos, viewLine, true));
 
         KateTextLayout newLine = cache()->textLayout(newPos);
 
         newPos = renderer()->xToCursor(newLine, m_preservedX, !view()->wrapCursor());
 
         m_preserveX = true;
         updateSelection(newPos, sel);
         updateCursor(newPos);
 
     } else {
         scrollLines(linesToScroll, sel);
     }
 }
 
 int KateViewInternal::maxLen(int startLine)
 {
     Q_ASSERT(!view()->dynWordWrap());
 
     int displayLines = (view()->height() / renderer()->lineHeight()) + 1;
 
     int maxLen = 0;
 
     for (int z = 0; z < displayLines; z++) {
         int virtualLine = startLine + z;
 
         if (virtualLine < 0 || virtualLine >= (int)view()->textFolding().visibleLines()) {
             break;
         }
 
         maxLen = qMax(maxLen, cache()->line(view()->textFolding().visibleLineToLine(virtualLine))->width());
     }
 
     return maxLen;
 }
 
 bool KateViewInternal::columnScrollingPossible()
 {
     return !view()->dynWordWrap() && m_columnScroll->isEnabled() && (m_columnScroll->maximum() > 0);
 }
 
 bool KateViewInternal::lineScrollingPossible()
 {
     return m_lineScroll->minimum() != m_lineScroll->maximum();
 }
 
 void KateViewInternal::top(bool sel)
 {
     KTextEditor::Cursor newCursor(0, 0);
 
     newCursor = renderer()->xToCursor(cache()->textLayout(newCursor), m_preservedX, !view()->wrapCursor());
 
     updateSelection(newCursor, sel);
     updateCursor(newCursor);
 }
 
 void KateViewInternal::bottom(bool sel)
 {
     KTextEditor::Cursor newCursor(doc()->lastLine(), 0);
 
     newCursor = renderer()->xToCursor(cache()->textLayout(newCursor), m_preservedX, !view()->wrapCursor());
 
     updateSelection(newCursor, sel);
     updateCursor(newCursor);
 }
 
 void KateViewInternal::top_home(bool sel)
 {
     if (view()->isCompletionActive()) {
         view()->completionWidget()->top();
         return;
     }
 
     KTextEditor::Cursor c(0, 0);
     updateSelection(c, sel);
     updateCursor(c);
 }
 
 void KateViewInternal::bottom_end(bool sel)
 {
     if (view()->isCompletionActive()) {
         view()->completionWidget()->bottom();
         return;
     }
 
     KTextEditor::Cursor c(doc()->lastLine(), doc()->lineLength(doc()->lastLine()));
     updateSelection(c, sel);
     updateCursor(c);
 }
 
 void KateViewInternal::updateSelection(const KTextEditor::Cursor &_newCursor, bool keepSel)
 {
     KTextEditor::Cursor newCursor = _newCursor;
     if (keepSel) {
         if (!view()->selection() || (m_selectAnchor.line() == -1)
                 //don't kill the selection if we have a persistent selection and
                 //the cursor is inside or at the boundaries of the selected area
                 || (view()->config()->persistentSelection()
                     && !(view()->selectionRange().contains(m_cursor)
                          || view()->selectionRange().boundaryAtCursor(m_cursor)))) {
             m_selectAnchor = m_cursor;
             setSelection(KTextEditor::Range(m_cursor, newCursor));
         } else {
             bool doSelect = true;
             switch (m_selectionMode) {
             case Word: {
                 // Restore selStartCached if needed. It gets nuked by
                 // viewSelectionChanged if we drag the selection into non-existence,
                 // which can legitimately happen if a shift+DC selection is unable to
                 // set a "proper" (i.e. non-empty) cached selection, e.g. because the
                 // start was on something that isn't a word. Word select mode relies
                 // on the cached selection being set properly, even if it is empty
                 // (i.e. selStartCached == selEndCached).
                 if (!m_selectionCached.isValid()) {
                     m_selectionCached.setStart(m_selectionCached.end());
                 }
 
                 int c;
                 if (newCursor > m_selectionCached.start()) {
                     m_selectAnchor = m_selectionCached.start();
 
                     Kate::TextLine l = doc()->kateTextLine(newCursor.line());
 
                     c = newCursor.column();
                     if (c > 0 && doc()->highlight()->isInWord(l->at(c - 1))) {
                         for (; c < l->length(); c++)
                             if (!doc()->highlight()->isInWord(l->at(c))) {
                                 break;
                             }
                     }
 
                     newCursor.setColumn(c);
                 } else if (newCursor < m_selectionCached.start()) {
                     m_selectAnchor = m_selectionCached.end();
 
                     Kate::TextLine l = doc()->kateTextLine(newCursor.line());
 
                     c = newCursor.column();
                     if (c > 0 && c < doc()->lineLength(newCursor.line())
                             && doc()->highlight()->isInWord(l->at(c))
                             && doc()->highlight()->isInWord(l->at(c - 1))) {
                         for (c -= 2; c >= 0; c--)
                             if (!doc()->highlight()->isInWord(l->at(c))) {
                                 break;
                             }
                         newCursor.setColumn(c + 1);
                     }
                 } else {
                     doSelect = false;
                 }
 
             }
             break;
             case Line:
                 if (!m_selectionCached.isValid()) {
                     m_selectionCached = KTextEditor::Range(endLine(), 0, endLine(), 0);
                 }
                 if (newCursor.line() > m_selectionCached.start().line()) {
                     if (newCursor.line() + 1 >= doc()->lines()) {
                         newCursor.setColumn(doc()->line(newCursor.line()).length());
                     } else {
                         newCursor.setPosition(newCursor.line() + 1, 0);
                     }
                     // Grow to include the entire line
                     m_selectAnchor = m_selectionCached.start();
                     m_selectAnchor.setColumn(0);
                 } else if (newCursor.line() < m_selectionCached.start().line()) {
                     newCursor.setColumn(0);
                     // Grow to include entire line
                     m_selectAnchor = m_selectionCached.end();
                     if (m_selectAnchor.column() > 0) {
                         if (m_selectAnchor.line() + 1 >= doc()->lines()) {
                             m_selectAnchor.setColumn(doc()->line(newCursor.line()).length());
                         } else {
                             m_selectAnchor.setPosition(m_selectAnchor.line() + 1, 0);
                         }
                     }
                 } else { // same line, ignore
                     doSelect = false;
                 }
                 break;
             case Mouse: {
                 if (!m_selectionCached.isValid()) {
                     break;
                 }
 
                 if (newCursor > m_selectionCached.end()) {
                     m_selectAnchor = m_selectionCached.start();
                 } else if (newCursor < m_selectionCached.start()) {
                     m_selectAnchor = m_selectionCached.end();
                 } else {
                     doSelect = false;
                 }
             }
             break;
             default: /* nothing special to do */;
             }
 
             if (doSelect) {
                 setSelection(KTextEditor::Range(m_selectAnchor, newCursor));
             } else if (m_selectionCached.isValid()) { // we have a cached selection, so we restore that
                 setSelection(m_selectionCached);
             }
         }
 
         m_selChangedByUser = true;
     } else if (!view()->config()->persistentSelection()) {
         view()->clearSelection();
 
         m_selectionCached = KTextEditor::Range::invalid();
         m_selectAnchor = KTextEditor::Cursor::invalid();
     }
 
 #ifndef QT_NO_ACCESSIBILITY
 //    FIXME KF5
 //    QAccessibleTextSelectionEvent ev(this, /* selection start, selection end*/);
 //    QAccessible::updateAccessibility(&ev);
 #endif
 }
 
 void KateViewInternal::setSelection(const KTextEditor::Range &range)
 {
     disconnect(m_view, SIGNAL(selectionChanged(KTextEditor::View*)), this, SLOT(viewSelectionChanged()));
     view()->setSelection(range);
     connect(m_view, SIGNAL(selectionChanged(KTextEditor::View*)), this, SLOT(viewSelectionChanged()));
 }
 
 void KateViewInternal::moveCursorToSelectionEdge()
 {
     if (!view()->selection()) {
         return;
     }
 
     int tmp = m_minLinesVisible;
     m_minLinesVisible = 0;
 
     if (view()->selectionRange().start() < m_selectAnchor) {
         updateCursor(view()->selectionRange().start());
     } else {
         updateCursor(view()->selectionRange().end());
     }
 
     m_minLinesVisible = tmp;
 }
 
 void KateViewInternal::updateCursor(const KTextEditor::Cursor &newCursor, bool force, bool center, bool calledExternally)
 {
     if (!force && (m_cursor.toCursor() == newCursor)) {
         m_displayCursor = toVirtualCursor(newCursor);
         if (!m_madeVisible && m_view == doc()->activeView()) {
             // unfold if required
             view()->textFolding().ensureLineIsVisible(newCursor.line());
 
             makeVisible(m_displayCursor, m_displayCursor.column(), false, center, calledExternally);
         }
 
         return;
     }
 
     if (m_cursor.line() != newCursor.line()) {
         m_leftBorder->updateForCursorLineChange();
     }
 
     // unfold if required
     view()->textFolding().ensureLineIsVisible(newCursor.line());
 
     KTextEditor::Cursor oldDisplayCursor = m_displayCursor;
 
     m_displayCursor = toVirtualCursor(newCursor);
     m_cursor.setPosition(newCursor);
 
     if (m_view == doc()->activeView()) {
         makeVisible(m_displayCursor, m_displayCursor.column(), false, center, calledExternally);
     }
 
     updateBracketMarks();
 
     // It's efficient enough to just tag them both without checking to see if they're on the same view line
     /*  kdDebug()<<"oldDisplayCursor:"<<oldDisplayCursor<<endl;
       kdDebug()<<"m_displayCursor:"<<m_displayCursor<<endl;*/
     tagLine(oldDisplayCursor);
     tagLine(m_displayCursor);
 
     updateMicroFocus();
 
     if (m_cursorTimer.isActive()) {
         if (QApplication::cursorFlashTime() > 0) {
             m_cursorTimer.start(QApplication::cursorFlashTime() / 2);
         }
         renderer()->setDrawCaret(true);
     }
 
     // Remember the maximum X position if requested
     if (m_preserveX) {
         m_preserveX = false;
     } else {
         m_preservedX = renderer()->cursorToX(cache()->textLayout(m_cursor), m_cursor, !view()->wrapCursor());
     }
 
     //qCDebug(LOG_KTE) << "m_preservedX: " << m_preservedX << " (was "<< oldmaxx << "), m_cursorX: " << m_cursorX;
     //qCDebug(LOG_KTE) << "Cursor now located at real " << cursor.line << "," << cursor.col << ", virtual " << m_displayCursor.line << ", " << m_displayCursor.col << "; Top is " << startLine() << ", " << startPos().col;
 
     cursorMoved();
 
     updateDirty(); //paintText(0, 0, width(), height(), true);
 
     emit view()->cursorPositionChanged(m_view, m_cursor);
 }
 
 void KateViewInternal::updateBracketMarkAttributes()
 {
     KTextEditor::Attribute::Ptr bracketFill = KTextEditor::Attribute::Ptr(new KTextEditor::Attribute());
     bracketFill->setBackground(view()->m_renderer->config()->highlightedBracketColor());
     bracketFill->setBackgroundFillWhitespace(false);
     if (QFontInfo(renderer()->currentFont()).fixedPitch()) {
         // make font bold only for fixed fonts, otherwise text jumps around
         bracketFill->setFontBold();
     }
 
     m_bmStart->setAttribute(bracketFill);
     m_bmEnd->setAttribute(bracketFill);
 
     if (view()->m_renderer->config()->showWholeBracketExpression()) {
         KTextEditor::Attribute::Ptr expressionFill = KTextEditor::Attribute::Ptr(new KTextEditor::Attribute());
         expressionFill->setBackground(view()->m_renderer->config()->highlightedBracketColor());
         expressionFill->setBackgroundFillWhitespace(false);
 
         m_bm->setAttribute(expressionFill);
     } else {
         m_bm->setAttribute(KTextEditor::Attribute::Ptr(new KTextEditor::Attribute()));
     }
 }
 
 void KateViewInternal::updateBracketMarks()
 {
     // add some limit to this, this is really endless on big files without limit
     const int maxLines = 5000;
     const KTextEditor::Range newRange = doc()->findMatchingBracket(m_cursor, maxLines);
 
     // new range valid, then set ranges to it
     if (newRange.isValid()) {
         if (m_bm->toRange() == newRange) {
             return;
         }
 
         // modify full range
         m_bm->setRange(newRange);
 
         // modify start and end ranges
         m_bmStart->setRange(KTextEditor::Range(m_bm->start(), KTextEditor::Cursor(m_bm->start().line(), m_bm->start().column() + 1)));
         m_bmEnd->setRange(KTextEditor::Range(m_bm->end(), KTextEditor::Cursor(m_bm->end().line(), m_bm->end().column() + 1)));
 
         // flash matching bracket
         if (!renderer()->config()->animateBracketMatching()) {
             return;
         }
         const KTextEditor::Cursor flashPos = (m_cursor == m_bmStart->start() || m_cursor == m_bmStart->end()) ? m_bmEnd->start() : m_bm->start();
         if (flashPos != m_bmLastFlashPos->toCursor()) {
             m_bmLastFlashPos->setPosition(flashPos);
 
             KTextEditor::Attribute::Ptr attribute = doc()->attributeAt(flashPos);
             attribute->setBackground(view()->m_renderer->config()->highlightedBracketColor());
             attribute->setFontBold(m_bmStart->attribute()->fontBold());
 
             flashChar(flashPos, attribute);
         }
         return;
     }
 
     // new range was invalid
     m_bm->setRange(KTextEditor::Range::invalid());
     m_bmStart->setRange(KTextEditor::Range::invalid());
     m_bmEnd->setRange(KTextEditor::Range::invalid());
     m_bmLastFlashPos->setPosition(KTextEditor::Cursor::invalid());
 }
 
 bool KateViewInternal::tagLine(const KTextEditor::Cursor &virtualCursor)
 {
     // FIXME may be a more efficient way for this
     if ((int)view()->textFolding().visibleLineToLine(virtualCursor.line()) > doc()->lastLine()) {
         return false;
     }
     // End FIXME
 
     int viewLine = cache()->displayViewLine(virtualCursor, true);
     if (viewLine >= 0 && viewLine < cache()->viewCacheLineCount()) {
         cache()->viewLine(viewLine).setDirty();
 
         // tag one line more because of overlapping things like _, bug 335079
         if (viewLine+1 < cache()->viewCacheLineCount()) {
             cache()->viewLine(viewLine+1).setDirty();
         }
 
         m_leftBorder->update(0, lineToY(viewLine), m_leftBorder->width(), renderer()->lineHeight());
         return true;
     }
     return false;
 }
 
 bool KateViewInternal::tagLines(int start, int end, bool realLines)
 {
     return tagLines(KTextEditor::Cursor(start, 0), KTextEditor::Cursor(end, -1), realLines);
 }
 
 bool KateViewInternal::tagLines(KTextEditor::Cursor start, KTextEditor::Cursor end, bool realCursors)
 {
     if (realCursors) {
         cache()->relayoutLines(start.line(), end.line());
 
         //qCDebug(LOG_KTE)<<"realLines is true";
         start = toVirtualCursor(start);
         end = toVirtualCursor(end);
 
     } else {
         cache()->relayoutLines(toRealCursor(start).line(), toRealCursor(end).line());
     }
 
     if (end.line() < startLine()) {
         //qCDebug(LOG_KTE)<<"end<startLine";
         return false;
     }
     // Used to be > endLine(), but cache may not be valid when checking, so use a
     // less optimal but still adequate approximation (potential overestimation but minimal performance difference)
     if (start.line() > startLine() + cache()->viewCacheLineCount()) {
         //qCDebug(LOG_KTE)<<"start> endLine"<<start<<" "<<(endLine());
         return false;
     }
 
     cache()->updateViewCache(startPos());
 
     //qCDebug(LOG_KTE) << "tagLines( [" << start << "], [" << end << "] )";
 
     bool ret = false;
 
     for (int z = 0; z < cache()->viewCacheLineCount(); z++) {
         KateTextLayout &line = cache()->viewLine(z);
         if ((line.virtualLine() > start.line() || (line.virtualLine() == start.line() && line.endCol() >= start.column() && start.column() != -1)) &&
                 (line.virtualLine() < end.line() || (line.virtualLine() == end.line() && (line.startCol() <= end.column() || end.column() == -1)))) {
             ret = true;
             break;
             //qCDebug(LOG_KTE) << "Tagged line " << line.line();
         }
     }
 
     if (!view()->dynWordWrap()) {
         int y = lineToY(start.line());
         // FIXME is this enough for when multiple lines are deleted
         int h = (end.line() - start.line() + 2) * renderer()->lineHeight();
         if (end.line() >= view()->textFolding().visibleLines() - 1) {
             h = height();
         }
 
         m_leftBorder->update(0, y, m_leftBorder->width(), h);
     } else {
         // FIXME Do we get enough good info in editRemoveText to optimize this more?
         //bool justTagged = false;
         for (int z = 0; z < cache()->viewCacheLineCount(); z++) {
             KateTextLayout &line = cache()->viewLine(z);
             if (!line.isValid() ||
                     ((line.virtualLine() > start.line() || (line.virtualLine() == start.line() && line.endCol() >= start.column() && start.column() != -1)) &&
                      (line.virtualLine() < end.line() || (line.virtualLine() == end.line() && (line.startCol() <= end.column() || end.column() == -1))))) {
                 //justTagged = true;
                 m_leftBorder->update(0, z * renderer()->lineHeight(), m_leftBorder->width(), m_leftBorder->height());
                 break;
             }
             /*else if (justTagged)
             {
               justTagged = false;
               leftBorder->update (0, z * doc()->viewFont.fontHeight, leftBorder->width(), doc()->viewFont.fontHeight);
               break;
             }*/
         }
     }
 
     return ret;
 }
 
 bool KateViewInternal::tagRange(const KTextEditor::Range &range, bool realCursors)
 {
     return tagLines(range.start(), range.end(), realCursors);
 }
 
 void KateViewInternal::tagAll()
 {
     // clear the cache...
     cache()->clear();
 
     m_leftBorder->updateFont();
     m_leftBorder->update();
 }
 
 void KateViewInternal::paintCursor()
 {
     if (tagLine(m_displayCursor)) {
         updateDirty();    //paintText (0,0,width(), height(), true);
     }
 }
 
 // Point in content coordinates
 void KateViewInternal::placeCursor(const QPoint &p, bool keepSelection, bool updateSelection)
 {
     KateTextLayout thisLine = yToKateTextLayout(p.y());
     KTextEditor::Cursor c;
 
     if (!thisLine.isValid()) { // probably user clicked below the last line -> use the last line
         thisLine = cache()->textLayout(doc()->lines() - 1, -1);
     }
 
     c = renderer()->xToCursor(thisLine, startX() + p.x(), !view()->wrapCursor());
 
     if (c.line() < 0 || c.line() >= doc()->lines()) {
         return;
     }
 
     if (updateSelection) {
         KateViewInternal::updateSelection(c, keepSelection);
     }
 
     int tmp = m_minLinesVisible;
     m_minLinesVisible = 0;
     updateCursor(c);
     m_minLinesVisible = tmp;
 
     if (updateSelection && keepSelection) {
         moveCursorToSelectionEdge();
     }
 }
 
 // Point in content coordinates
 bool KateViewInternal::isTargetSelected(const QPoint &p)
 {
     const KateTextLayout &thisLine = yToKateTextLayout(p.y());
     if (!thisLine.isValid()) {
         return false;
     }
 
     return view()->cursorSelected(renderer()->xToCursor(thisLine, startX() + p.x(), !view()->wrapCursor()));
 }
 
 //BEGIN EVENT HANDLING STUFF
 
 bool KateViewInternal::eventFilter(QObject *obj, QEvent *e)
 {
 
     switch (e->type()) {
     case QEvent::ChildAdded:
     case QEvent::ChildRemoved: {
         QChildEvent *c = static_cast<QChildEvent *>(e);
         if (c->added()) {
             c->child()->installEventFilter(this);
             /*foreach (QWidget* child, c->child()->findChildren<QWidget*>())
               child->installEventFilter(this);*/
 
         } else if (c->removed()) {
             c->child()->removeEventFilter(this);
 
             /*foreach (QWidget* child, c->child()->findChildren<QWidget*>())
               child->removeEventFilter(this);*/
         }
     } break;
 
     case QEvent::ShortcutOverride: {
         QKeyEvent *k = static_cast<QKeyEvent *>(e);
 
         if (k->key() == Qt::Key_Escape && k->modifiers() == Qt::NoModifier) {
             if (view()->isCompletionActive()) {
                 view()->abortCompletion();
                 k->accept();
                 //qCDebug(LOG_KTE) << obj << "shortcut override" << k->key() << "aborting completion";
                 return true;
             } else if (!view()->bottomViewBar()->hiddenOrPermanent()) {
                 view()->bottomViewBar()->hideCurrentBarWidget();
                 k->accept();
                 //qCDebug(LOG_KTE) << obj << "shortcut override" << k->key() << "closing view bar";
                 return true;
             } else if (!view()->config()->persistentSelection() && view()->selection()) {
                 m_currentInputMode->clearSelection();
                 k->accept();
                 //qCDebug(LOG_KTE) << obj << "shortcut override" << k->key() << "clearing selection";
                 return true;
             }
         }
 
         if (m_currentInputMode->stealKey(k)) {
             k->accept();
             return true;
         }
 
     } break;
 
     case QEvent::KeyPress: {
         QKeyEvent *k = static_cast<QKeyEvent *>(e);
 
         // Override all other single key shortcuts which do not use a modifier other than Shift
         if (obj == this && (!k->modifiers() || k->modifiers() == Qt::ShiftModifier)) {
             keyPressEvent(k);
             if (k->isAccepted()) {
                 //qCDebug(LOG_KTE) << obj << "shortcut override" << k->key() << "using keystroke";
                 return true;
             }
         }
 
         //qCDebug(LOG_KTE) << obj << "shortcut override" << k->key() << "ignoring";
     } break;
 
     case QEvent::DragMove: {
         QPoint currentPoint = ((QDragMoveEvent *) e)->pos();
 
         QRect doNotScrollRegion(s_scrollMargin, s_scrollMargin,
                                 width() - s_scrollMargin * 2,
                                 height() - s_scrollMargin * 2);
 
         if (!doNotScrollRegion.contains(currentPoint)) {
             startDragScroll();
             // Keep sending move events
             ((QDragMoveEvent *)e)->accept(QRect(0, 0, 0, 0));
         }
 
         dragMoveEvent((QDragMoveEvent *)e);
     } break;
 
     case QEvent::DragLeave:
         // happens only when pressing ESC while dragging
         stopDragScroll();
         break;
 
     default:
         break;
     }
 
     return QWidget::eventFilter(obj, e);
 }
 
 void KateViewInternal::keyPressEvent(QKeyEvent *e)
 {
     if (e->key() == Qt::Key_Left && e->modifiers() == Qt::AltModifier) {
         view()->emitNavigateLeft();
         e->setAccepted(true);
         return;
     }
     if (e->key() == Qt::Key_Right && e->modifiers() == Qt::AltModifier) {
         view()->emitNavigateRight();
         e->setAccepted(true);
         return;
     }
     if (e->key() == Qt::Key_Up && e->modifiers() == Qt::AltModifier) {
         view()->emitNavigateUp();
         e->setAccepted(true);
         return;
     }
     if (e->key() == Qt::Key_Down && e->modifiers() == Qt::AltModifier) {
         view()->emitNavigateDown();
         e->setAccepted(true);
         return;
     }
     if (e->key() == Qt::Key_Return && e->modifiers() == Qt::AltModifier) {
         view()->emitNavigateAccept();
         e->setAccepted(true);
         return;
     }
     if (e->key() == Qt::Key_Backspace && e->modifiers() == Qt::AltModifier) {
         view()->emitNavigateBack();
         e->setAccepted(true);
         return;
     }
 
     if (e->key() == Qt::Key_Alt && view()->completionWidget()->isCompletionActive()) {
         m_completionItemExpanded = view()->completionWidget()->toggleExpanded(true);
         view()->completionWidget()->resetHadNavigation();
         m_altDownTime.start();
     }
 
     // Note: AND'ing with <Shift> is a quick hack to fix Key_Enter
     const int key = e->key() | (e->modifiers() & Qt::ShiftModifier);
 
     if (m_currentInputMode->keyPress(e)) {
         return;
     }
 
 
     if (!doc()->isReadWrite()) {
         e->ignore();
         return;
     }
 
     if ((key == Qt::Key_Return) || (key == Qt::Key_Enter) || (key == Qt::SHIFT + Qt::Key_Return) || (key == Qt::SHIFT + Qt::Key_Enter)) {
         view()->keyReturn();
         e->accept();
         return;
     }
 
     if (key == Qt::Key_Backspace || key == Qt::SHIFT + Qt::Key_Backspace) {
         //view()->backspace();
         e->accept();
 
         return;
     }
 
     if (key == Qt::Key_Tab || key == Qt::SHIFT + Qt::Key_Backtab || key == Qt::Key_Backtab) {
         if (view()->completionWidget()->isCompletionActive()) {
             e->accept();
             view()->completionWidget()->tab(key != Qt::Key_Tab);
             return;
         }
 
         if (key == Qt::Key_Tab) {
             uint tabHandling = doc()->config()->tabHandling();
             // convert tabSmart into tabInsertsTab or tabIndents:
             if (tabHandling == KateDocumentConfig::tabSmart) {
                 // multiple lines selected
                 if (view()->selection() && !view()->selectionRange().onSingleLine()) {
                     tabHandling = KateDocumentConfig::tabIndents;
                 }
 
                 // otherwise: take look at cursor position
                 else {
                     // if the cursor is at or before the first non-space character
                     // or on an empty line,
                     // Tab indents, otherwise it inserts a tab character.
                     Kate::TextLine line = doc()->kateTextLine(m_cursor.line());
                     int first = line->firstChar();
                     if (first < 0 || m_cursor.column() <= first) {
                         tabHandling = KateDocumentConfig::tabIndents;
                     } else {
                         tabHandling = KateDocumentConfig::tabInsertsTab;
                     }
                 }
             }
 
             if (tabHandling == KateDocumentConfig::tabInsertsTab) {
                 doc()->typeChars(m_view, QStringLiteral("\t"));
             } else {
                 doc()->indent(view()->selection() ? view()->selectionRange() : KTextEditor::Range(m_cursor.line(), 0, m_cursor.line(), 0), 1);
             }
 
             e->accept();
 
             return;
         } else if (doc()->config()->tabHandling() != KateDocumentConfig::tabInsertsTab) {
             // key == Qt::SHIFT+Qt::Key_Backtab || key == Qt::Key_Backtab
             doc()->indent(view()->selection() ? view()->selectionRange() : KTextEditor::Range(m_cursor.line(), 0, m_cursor.line(), 0), -1);
             e->accept();
 
             return;
         }
     }
 
     if (!(e->modifiers() & Qt::ControlModifier) && !e->text().isEmpty() && doc()->typeChars(m_view, e->text())) {
         e->accept();
 
         return;
     }
 
     // allow composition of AltGr + (q|2|3) on windows
     static const int altGR = Qt::ControlModifier | Qt::AltModifier;
     if ((e->modifiers() & altGR) == altGR && !e->text().isEmpty() && doc()->typeChars(m_view, e->text())) {
         e->accept();
 
         return;
     }
 
     e->ignore();
 }
 
 void KateViewInternal::keyReleaseEvent(QKeyEvent *e)
 {
     if (e->key() == Qt::Key_Alt && view()->completionWidget()->isCompletionActive() && ((m_completionItemExpanded && (view()->completionWidget()->hadNavigation() || m_altDownTime.elapsed() > 300)) || (!m_completionItemExpanded && !view()->completionWidget()->hadNavigation()))) {
 
         view()->completionWidget()->toggleExpanded(false, true);
     }
 
     if ((e->modifiers() & Qt::SHIFT) == Qt::SHIFT) {
         m_shiftKeyPressed = true;
     } else {
         if (m_shiftKeyPressed) {
             m_shiftKeyPressed = false;
 
             if (m_selChangedByUser) {
                 if (view()->selection()) {
                     QApplication::clipboard()->setText(view()->selectionText(), QClipboard::Selection);
                 }
 
                 m_selChangedByUser = false;
             }
         }
     }
 
     e->ignore();
     return;
 }
 
 void KateViewInternal::contextMenuEvent(QContextMenuEvent *e)
 {
     // try to show popup menu
 
     QPoint p = e->pos();
 
     if (e->reason() == QContextMenuEvent::Keyboard) {
         makeVisible(m_displayCursor, 0);
         p = cursorCoordinates(false);
         p.rx() -= startX();
     } else if (! view()->selection() || view()->config()->persistentSelection()) {
         placeCursor(e->pos());
     }
 
     // popup is a qguardedptr now
     if (view()->contextMenu()) {
         view()->spellingMenu()->setUseMouseForMisspelledRange((e->reason() == QContextMenuEvent::Mouse));
         view()->contextMenu()->popup(mapToGlobal(p));
         e->accept();
     }
 }
 
 void KateViewInternal::mousePressEvent(QMouseEvent *e)
 {
     // was an inline note clicked?
     const auto noteData = inlineNoteAt(e->globalPos());
     const KTextEditor::InlineNote note(noteData);
     if (note.position().isValid()) {
         note.provider()->inlineNoteActivated(noteData, e->button(), e->globalPos());
         return;
     }
 
     // no -- continue with normal handling
     switch (e->button()) {
     case Qt::LeftButton:
 
         m_selChangedByUser = false;
 
         if (m_possibleTripleClick) {
             m_possibleTripleClick = false;
 
             m_selectionMode = Line;
 
             if (e->modifiers() & Qt::ShiftModifier) {
                 updateSelection(m_cursor, true);
             } else {
                 view()->selectLine(m_cursor);
                 if (view()->selection()) {
                     m_selectAnchor = view()->selectionRange().start();
                 }
             }
 
             if (view()->selection()) {
                 QApplication::clipboard()->setText(view()->selectionText(), QClipboard::Selection);
             }
 
             // Keep the line at the select anchor selected during further
             // mouse selection
             if (m_selectAnchor.line() > view()->selectionRange().start().line()) {
                 // Preserve the last selected line
                 if (m_selectAnchor == view()->selectionRange().end() && m_selectAnchor.column() == 0) {
                     m_selectionCached.setStart(KTextEditor::Cursor(m_selectAnchor.line() - 1, 0));
                 } else {
                     m_selectionCached.setStart(KTextEditor::Cursor(m_selectAnchor.line(), 0));
                 }
                 m_selectionCached.setEnd(view()->selectionRange().end());
             } else {
                 // Preserve the first selected line
                 m_selectionCached.setStart(view()->selectionRange().start());
                 if (view()->selectionRange().end().line() > view()->selectionRange().start().line()) {
                     m_selectionCached.setEnd(KTextEditor::Cursor(view()->selectionRange().start().line() + 1, 0));
                 } else {
                     m_selectionCached.setEnd(view()->selectionRange().end());
                 }
             }
 
             moveCursorToSelectionEdge();
 
             m_scrollX = 0;
             m_scrollY = 0;
             m_scrollTimer.start(50);
 
             e->accept();
             return;
         } else if (m_selectionMode == Default) {
             m_selectionMode = Mouse;
         }
 
         // request the software keyboard, if any
         if (e->button() == Qt::LeftButton && qApp->autoSipEnabled()) {
             QStyle::RequestSoftwareInputPanel behavior = QStyle::RequestSoftwareInputPanel(style()->styleHint(QStyle::SH_RequestSoftwareInputPanel));
             if (hasFocus() || behavior == QStyle::RSIP_OnMouseClick) {
                 QEvent event(QEvent::RequestSoftwareInputPanel);
                 QApplication::sendEvent(this, &event);
             }
         }
 
         if (e->modifiers() & Qt::ShiftModifier) {
             if (!m_selectAnchor.isValid()) {
                 m_selectAnchor = m_cursor;
             }
         } else {
             m_selectionCached = KTextEditor::Range::invalid();
         }
 
         if (!(e->modifiers() & Qt::ShiftModifier) && isTargetSelected(e->pos())) {
             m_dragInfo.state = diPending;
             m_dragInfo.start = e->pos();
         } else {
             m_dragInfo.state = diNone;
 
             if (e->modifiers() & Qt::ShiftModifier) {
                 placeCursor(e->pos(), true, false);
                 if (m_selectionCached.start().isValid()) {
                     if (m_cursor.toCursor() < m_selectionCached.start()) {
                         m_selectAnchor = m_selectionCached.end();
                     } else {
                         m_selectAnchor = m_selectionCached.start();
                     }
                 }
                 setSelection(KTextEditor::Range(m_selectAnchor, m_cursor));
             } else {
                 placeCursor(e->pos());
             }
 
             m_scrollX = 0;
             m_scrollY = 0;
 
             m_scrollTimer.start(50);
         }
 
         e->accept();
         break;
 
     default:
         e->ignore();
         break;
     }
 }
 
 void KateViewInternal::mouseDoubleClickEvent(QMouseEvent *e)
 {
     if (e->button() == Qt::LeftButton) {
         m_selectionMode = Word;
 
         if (e->modifiers() & Qt::ShiftModifier) {
             // Now select the word under the select anchor
             int cs, ce;
             Kate::TextLine l = doc()->kateTextLine(m_selectAnchor.line());
 
             ce = m_selectAnchor.column();
             if (ce > 0 && doc()->highlight()->isInWord(l->at(ce))) {
                 for (; ce < l->length(); ce++)
                     if (!doc()->highlight()->isInWord(l->at(ce))) {
                         break;
                     }
             }
 
             cs = m_selectAnchor.column() - 1;
             if (cs < doc()->lineLength(m_selectAnchor.line())
                     && doc()->highlight()->isInWord(l->at(cs))) {
                 for (cs--; cs >= 0; cs--)
                     if (!doc()->highlight()->isInWord(l->at(cs))) {
                         break;
                     }
             }
 
             // ...and keep it selected
             if (cs + 1 < ce) {
                 m_selectionCached.setStart(KTextEditor::Cursor(m_selectAnchor.line(), cs + 1));
                 m_selectionCached.setEnd(KTextEditor::Cursor(m_selectAnchor.line(), ce));
             } else {
                 m_selectionCached.setStart(m_selectAnchor);
                 m_selectionCached.setEnd(m_selectAnchor);
             }
             // Now word select to the mouse cursor
             placeCursor(e->pos(), true);
         } else {
             // first clear the selection, otherwise we run into bug #106402
             // ...and set the cursor position, for the same reason (otherwise there
             // are *other* idiosyncrasies we can't fix without reintroducing said
             // bug)
             // Parameters: don't redraw, and don't emit selectionChanged signal yet
             view()->clearSelection(false, false);
             placeCursor(e->pos());
             view()->selectWord(m_cursor);
             cursorToMatchingBracket(true);
 
             if (view()->selection()) {
                 m_selectAnchor = view()->selectionRange().start();
                 m_selectionCached = view()->selectionRange();
             } else {
                 m_selectAnchor = m_cursor;
                 m_selectionCached = KTextEditor::Range(m_cursor, m_cursor);
             }
         }
 
         // Move cursor to end (or beginning) of selected word
 #ifndef Q_OS_MACOS
         if (view()->selection()) {
             QApplication::clipboard()->setText(view()->selectionText(), QClipboard::Selection);
         }
 #endif
 
         moveCursorToSelectionEdge();
         m_possibleTripleClick = true;
         QTimer::singleShot(QApplication::doubleClickInterval(), this, SLOT(tripleClickTimeout()));
 
         m_scrollX = 0;
         m_scrollY = 0;
 
         m_scrollTimer.start(50);
 
         e->accept();
     } else {
         e->ignore();
     }
 }
 
 void KateViewInternal::tripleClickTimeout()
 {
     m_possibleTripleClick = false;
 }
 
 void KateViewInternal::beginSelectLine(const QPoint &pos)
 {
     placeCursor(pos);
     m_possibleTripleClick = true; // set so subsequent mousePressEvent will select line
 }
 
 void KateViewInternal::mouseReleaseEvent(QMouseEvent *e)
 {
     switch (e->button()) {
     case Qt::LeftButton:
         m_selectionMode = Default;
 //       m_selectionCached.start().setLine( -1 );
 
         if (m_selChangedByUser) {
             if (view()->selection()) {
                 QApplication::clipboard()->setText(view()->selectionText(), QClipboard::Selection);
             }
             moveCursorToSelectionEdge();
 
             m_selChangedByUser = false;
         }
 
         if (m_dragInfo.state == diPending) {
             placeCursor(e->pos(), e->modifiers() & Qt::ShiftModifier);
         } else if (m_dragInfo.state == diNone) {
             m_scrollTimer.stop();
         }
 
         m_dragInfo.state = diNone;
 
         e->accept();
         break;
 
     case Qt::MidButton:
         if (!view()->config()->mousePasteAtCursorPosition()) {
             placeCursor(e->pos());
         }
 
         if (doc()->isReadWrite()) {
             QString clipboard = QApplication::clipboard()->text(QClipboard::Selection);
             view()->paste(&clipboard);
         }
 
         e->accept();
         break;
 
     default:
         e->ignore();
         break;
     }
 }
 
 void KateViewInternal::leaveEvent(QEvent *)
 {
     m_textHintTimer.stop();
 
     // fix bug 194452, scrolling keeps going if you scroll via mouse drag and press and other mouse
     // button outside the view area
     if (m_dragInfo.state == diNone) {
         m_scrollTimer.stop();
     }
 }
 
 KTextEditor::Cursor KateViewInternal::coordinatesToCursor(const QPoint &_coord, bool includeBorder) const
 {
     QPoint coord(_coord);
 
     KTextEditor::Cursor ret = KTextEditor::Cursor::invalid();
 
     if (includeBorder) {
         coord.rx() -= m_leftBorder->width();
     }
     coord.rx() += startX();
 
     const KateTextLayout &thisLine = yToKateTextLayout(coord.y());
     if (thisLine.isValid()) {
         ret = renderer()->xToCursor(thisLine, coord.x(), !view()->wrapCursor());
     }
 
     if (ret.column() > view()->document()->lineLength(ret.line())) {
         // The cursor is beyond the end of the line; in that case the renderer
         // gives the index of the character behind the last one.
         return KTextEditor::Cursor::invalid();
     }
 
     return ret;
 }
 
 void KateViewInternal::mouseMoveEvent(QMouseEvent *e)
 {
     KTextEditor::Cursor newPosition = coordinatesToCursor(e->pos(), false);
     if (newPosition != m_mouse) {
         m_mouse = newPosition;
         mouseMoved();
     }
 
     if (e->buttons() == Qt::NoButton) {
         const auto noteData = inlineNoteAt(e->globalPos());
         const KTextEditor::InlineNote note(noteData);
         const KTextEditor::InlineNote activeNote(m_activeInlineNote);
         if (note.position().isValid()) {
             if (!activeNote.position().isValid()) {
                 // no active note -- focus in
                 note.provider()->inlineNoteFocusInEvent(note, e->globalPos());
                 m_activeInlineNote = noteData;
             } else {
                 note.provider()->inlineNoteMouseMoveEvent(note, e->globalPos());
             }
             // the note might change its appearance in result to the event
             tagLines(note.position(), note.position(), true);
         }
         else if (activeNote.position().isValid()) {
             activeNote.provider()->inlineNoteFocusOutEvent(activeNote);
             tagLines(activeNote.position(), activeNote.position(), true);
             m_activeInlineNote = {};
         }
     }
 
     if (e->buttons() & Qt::LeftButton) {
         if (m_dragInfo.state == diPending) {
             // we had a mouse down, but haven't confirmed a drag yet
             // if the mouse has moved sufficiently, we will confirm
             QPoint p(e->pos() - m_dragInfo.start);
 
             // we've left the drag square, we can start a real drag operation now
             if (p.manhattanLength() > QApplication::startDragDistance()) {
                 doDrag();
             }
 
             return;
         } else if (m_dragInfo.state == diDragging) {
             // Don't do anything after a canceled drag until the user lets go of
             // the mouse button!
             return;
         }
 
         m_mouseX = e->x();
         m_mouseY = e->y();
 
         m_scrollX = 0;
         m_scrollY = 0;
         int d = renderer()->lineHeight();
 
         if (m_mouseX < 0) {
             m_scrollX = -d;
         }
 
         if (m_mouseX > width()) {
             m_scrollX = d;
         }
 
         if (m_mouseY < 0) {
             m_mouseY = 0;
             m_scrollY = -d;
         }
 
         if (m_mouseY > height()) {
             m_mouseY = height();
             m_scrollY = d;
         }
 
         placeCursor(QPoint(m_mouseX, m_mouseY), true);
 
     } else {
         if (isTargetSelected(e->pos())) {
             // mouse is over selected text. indicate that the text is draggable by setting
             // the arrow cursor as other Qt text editing widgets do
             if (m_mouseCursor != Qt::ArrowCursor) {
                 m_mouseCursor = Qt::ArrowCursor;
                 setCursor(m_mouseCursor);
             }
         } else {
             // normal text cursor
             if (m_mouseCursor != Qt::IBeamCursor) {
                 m_mouseCursor = Qt::IBeamCursor;
                 setCursor(m_mouseCursor);
             }
         }
         //We need to check whether the mouse position is actually within the widget,
         //because other widgets like the icon border forward their events to this,
         //and we will create invalid text hint requests if we don't check
         if (textHintsEnabled() && geometry().contains(parentWidget()->mapFromGlobal(e->globalPos()))) {
             if (QToolTip::isVisible()) {
                 QToolTip::hideText();
             }
             m_textHintTimer.start(m_textHintDelay);
             m_textHintPos = e->pos();
         }
     }
 }
 
 void KateViewInternal::updateDirty()
 {
     const int h = renderer()->lineHeight();
 
     int currentRectStart = -1;
     int currentRectEnd = -1;
 
     QRegion updateRegion;
 
     {
         for (int i = 0; i < cache()->viewCacheLineCount(); ++i) {
             if (cache()->viewLine(i).isDirty()) {
                 if (currentRectStart == -1) {
                     currentRectStart = h * i;
                     currentRectEnd = h;
                 } else {
                     currentRectEnd += h;
                 }
 
             } else if (currentRectStart != -1) {
                 updateRegion += QRect(0, currentRectStart, width(), currentRectEnd);
                 currentRectStart = -1;
                 currentRectEnd = -1;
             }
         }
     }
 
     if (currentRectStart != -1) {
         updateRegion += QRect(0, currentRectStart, width(), currentRectEnd);
     }
 
     if (!updateRegion.isEmpty()) {
         if (debugPainting) {
             qCDebug(LOG_KTE) << "Update dirty region " << updateRegion;
         }
         update(updateRegion);
     }
 }
 
 void KateViewInternal::hideEvent(QHideEvent *e)
 {
     Q_UNUSED(e);
     if (view()->isCompletionActive()) {
         view()->completionWidget()->abortCompletion();
     }
 }
 
 void KateViewInternal::paintEvent(QPaintEvent *e)
 {
     if (debugPainting) {
         qCDebug(LOG_KTE) << "GOT PAINT EVENT: Region" << e->region();
     }
 
     const QRect &unionRect = e->rect();
 
     int xStart = startX() + unionRect.x();
     int xEnd = xStart + unionRect.width();
     uint h = renderer()->lineHeight();
     uint startz = (unionRect.y() / h);
     uint endz = startz + 1 + (unionRect.height() / h);
     uint lineRangesSize = cache()->viewCacheLineCount();
     const KTextEditor::Cursor pos = m_cursor;
 
     QPainter paint(this);
     paint.setRenderHints(QPainter::Antialiasing);
 
     paint.save();
 
     renderer()->setCaretStyle(m_currentInputMode->caretStyle());
     renderer()->setShowTabs(doc()->config()->showTabs());
     renderer()->setShowSpaces(doc()->config()->showSpaces());
     renderer()->updateMarkerSize();
 
     /**
      * paint line by line
      * this includes parts that span areas without real lines
      * translate to first line to paint
      */
     paint.translate(unionRect.x(), startz * h);
     for (uint z = startz; z <= endz; z++) {
         /**
          * paint regions without lines mapped to
          */
         if ((z >= lineRangesSize) || (cache()->viewLine(z).line() == -1)) {
             if (!(z >= lineRangesSize)) {
                 cache()->viewLine(z).setDirty(false);
             }
             paint.fillRect(0, 0, unionRect.width(), h, renderer()->config()->backgroundColor());
         }
 
         /**
          * paint text lines
          */
         else {
             /**
              * If viewLine() returns non-zero, then a document line was split
              * in several visual lines, and we're trying to paint visual line
              * that is not the first.  In that case, this line was already
              * painted previously, since KateRenderer::paintTextLine paints
              * all visual lines.
              *
              * Except if we're at the start of the region that needs to
              * be painted -- when no previous calls to paintTextLine were made.
             */
             KateTextLayout &thisLine = cache()->viewLine(z);
             if (!thisLine.viewLine() || z == startz) {
                 /**
                  * paint our line
                  * set clipping region to only paint the relevant parts
                  */
                 paint.save();
                 paint.translate(QPoint(0, h * - thisLine.viewLine()));
                 paint.setClipRect(QRect(0, 0, unionRect.width(), h * thisLine.kateLineLayout()->viewLineCount()));
                 renderer()->paintTextLine(paint, thisLine.kateLineLayout(), xStart, xEnd, &pos);
                 paint.restore();
 
                 /**
                  * line painted, reset and state + mark line as non-dirty
                  */
                 thisLine.setDirty(false);
             }
         }
 
         /**
          * translate to next line
          */
         paint.translate(0, h);
     }
 
     paint.restore();
 
     if (m_textAnimation) {
         m_textAnimation->draw(paint);
     }
 }
 
 void KateViewInternal::resizeEvent(QResizeEvent *e)
 {
     bool expandedHorizontally = width() > e->oldSize().width();
     bool expandedVertically = height() > e->oldSize().height();
     bool heightChanged = height() != e->oldSize().height();
 
     m_dummy->setFixedSize(m_lineScroll->width(), m_columnScroll->sizeHint().height());
     m_madeVisible = false;
 
     if (heightChanged) {
         setAutoCenterLines(m_autoCenterLines, false);
         m_cachedMaxStartPos.setPosition(-1, -1);
     }
 
     if (view()->dynWordWrap()) {
         bool dirtied = false;
 
         for (int i = 0; i < cache()->viewCacheLineCount(); i++) {
             // find the first dirty line
             // the word wrap updateView algorithm is forced to check all lines after a dirty one
             KateTextLayout viewLine = cache()->viewLine(i);
 
             if (viewLine.wrap() || viewLine.isRightToLeft() || viewLine.width() > width()) {
                 dirtied = true;
                 viewLine.setDirty();
                 break;
             }
         }
 
         if (dirtied || heightChanged) {
             updateView(true);
             m_leftBorder->update();
         }
     } else {
         updateView();
 
         if (expandedHorizontally && startX() > 0) {
             scrollColumns(startX() - (width() - e->oldSize().width()));
         }
     }
 
     if (width() < e->oldSize().width() && !view()->wrapCursor()) {
         // May have to restrain cursor to new smaller width...
         if (m_cursor.column() > doc()->lineLength(m_cursor.line())) {
             KateTextLayout thisLine = currentLayout();
 
             KTextEditor::Cursor newCursor(m_cursor.line(), thisLine.endCol() + ((width() - thisLine.xOffset() - (thisLine.width() - startX())) / renderer()->spaceWidth()) - 1);
             if (newCursor.column() < m_cursor.column()) {
                 updateCursor(newCursor);
             }
         }
     }
 
     if (expandedVertically) {
         KTextEditor::Cursor max = maxStartPos();
         if (startPos() > max) {
             scrollPos(max);
             return; // already fired displayRangeChanged
         }
     }
     emit view()->displayRangeChanged(m_view);
 }
 
 void KateViewInternal::scrollTimeout()
 {
     if (m_scrollX || m_scrollY) {
         scrollLines(startLine() + (m_scrollY / (int) renderer()->lineHeight()));
         placeCursor(QPoint(m_mouseX, m_mouseY), true);
     }
 }
 
 void KateViewInternal::cursorTimeout()
 {
     if (!debugPainting && m_currentInputMode->blinkCaret()) {
         renderer()->setDrawCaret(!renderer()->drawCaret());
         paintCursor();
     }
 }
 
 void KateViewInternal::textHintTimeout()
 {
     m_textHintTimer.stop();
 
     KTextEditor::Cursor c = coordinatesToCursor(m_textHintPos, false);
     if (!c.isValid()) {
         return;
     }
 
     QStringList textHints;
     foreach(KTextEditor::TextHintProvider * const p, m_textHintProviders) {
         const QString hint = p->textHint(m_view, c);
         if (!hint.isEmpty()) {
             textHints.append(hint);
         }
     }
 
     if (!textHints.isEmpty()) {
         qCDebug(LOG_KTE) << "Hint text: " << textHints;
         QString hint;
         foreach(const QString & str, textHints) {
             hint += QStringLiteral("<p>%1</p>").arg(str);
         }
         QPoint pos(startX() + m_textHintPos.x(), m_textHintPos.y());
         QToolTip::showText(mapToGlobal(pos), hint);
     }
 }
 
 void KateViewInternal::focusInEvent(QFocusEvent *)
 {
     if (QApplication::cursorFlashTime() > 0) {
         m_cursorTimer.start(QApplication::cursorFlashTime() / 2);
     }
 
     paintCursor();
 
     doc()->setActiveView(m_view);
 
     // this will handle focus stuff in kateview
     view()->slotGotFocus();
 }
 
 void KateViewInternal::focusOutEvent(QFocusEvent *)
 {
     //if (view()->isCompletionActive())
     //view()->abortCompletion();
 
     m_cursorTimer.stop();
     view()->renderer()->setDrawCaret(true);
     paintCursor();
 
     m_textHintTimer.stop();
 
     view()->slotLostFocus();
 }
 
 void KateViewInternal::doDrag()
 {
     m_dragInfo.state = diDragging;
     m_dragInfo.dragObject = new QDrag(this);
     QMimeData *mimeData = new QMimeData();
     mimeData->setText(view()->selectionText());
     m_dragInfo.dragObject->setMimeData(mimeData);
     m_dragInfo.dragObject->start(Qt::MoveAction);
 }
 
 void KateViewInternal::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->source() == this) {
         event->setDropAction(Qt::MoveAction);
     }
     event->setAccepted((event->mimeData()->hasText() && doc()->isReadWrite()) ||
                        event->mimeData()->hasUrls());
 }
 
 void KateViewInternal::fixDropEvent(QDropEvent *event)
 {
     if (event->source() != this) {
         event->setDropAction(Qt::CopyAction);
     } else {
         Qt::DropAction action = Qt::MoveAction;
 #ifdef Q_WS_MAC
         if (event->keyboardModifiers() & Qt::AltModifier) {
             action = Qt::CopyAction;
         }
 #else
         if (event->keyboardModifiers() & Qt::ControlModifier) {
             action = Qt::CopyAction;
         }
 #endif
         event->setDropAction(action);
     }
 }
 
 void KateViewInternal::dragMoveEvent(QDragMoveEvent *event)
 {
     // track the cursor to the current drop location
     placeCursor(event->pos(), true, false);
 
     // important: accept action to switch between copy and move mode
     // without this, the text will always be copied.
     fixDropEvent(event);
 }
 
 void KateViewInternal::dropEvent(QDropEvent *event)
 {
     /**
      * if we have urls, pass this event off to the hosting application
      */
     if (event->mimeData()->hasUrls()) {
         emit dropEventPass(event);
         return;
     }
 
     if (event->mimeData()->hasText() && doc()->isReadWrite()) {
 
         const QString text = event->mimeData()->text();
         const bool blockMode = view()->blockSelection();
 
         fixDropEvent(event);
 
         // Remember where to paste/move...
         KTextEditor::Cursor targetCursor(m_cursor);
         // Use powerful MovingCursor to track our changes we may do
         std::unique_ptr<KTextEditor::MovingCursor> targetCursor2(doc()->newMovingCursor(m_cursor));
 
         // As always need the BlockMode some special treatment
         const KTextEditor::Range selRange(view()->selectionRange());
         const KTextEditor::Cursor blockAdjust(selRange.numberOfLines(), selRange.columnWidth());
 
         // Restore the cursor position before editStart(), so that it is correctly stored for the undo action
         if (event->dropAction() != Qt::CopyAction) {
             editSetCursor(selRange.end());
         } else {
             view()->clearSelection();
         }
 
         // use one transaction
         doc()->editStart();
 
         if (event->dropAction() != Qt::CopyAction) {
             view()->removeSelectedText();
             if (targetCursor2->toCursor() != targetCursor) {
                 // Hm, multi line selection moved down, we need to adjust our dumb cursor
                 targetCursor = targetCursor2->toCursor();
             }
             doc()->insertText(targetCursor2->toCursor(), text, blockMode);
 
         } else {
             doc()->insertText(targetCursor, text, blockMode);
         }
 
         if (blockMode) {
             setSelection(KTextEditor::Range(targetCursor, targetCursor + blockAdjust));
             editSetCursor(targetCursor + blockAdjust);
         } else {
             setSelection(KTextEditor::Range(targetCursor, targetCursor2->toCursor()));
             editSetCursor(targetCursor2->toCursor()); // Just to satisfy autotest
         }
 
         doc()->editEnd();
 
         event->acceptProposedAction();
         updateView();
     }
 
     // finally finish drag and drop mode
     m_dragInfo.state = diNone;
     // important, because the eventFilter`s DragLeave does not occur
     stopDragScroll();
 }
 //END EVENT HANDLING STUFF
 
 void KateViewInternal::clear()
 {
     m_startPos.setPosition(0, 0);
     m_displayCursor = KTextEditor::Cursor(0, 0);
     m_cursor.setPosition(0, 0);
     cache()->clear();
     updateView(true);
     m_lineScroll->updatePixmap();
 }
 
 void KateViewInternal::wheelEvent(QWheelEvent *e)
 {
     // check if this event should change the font size (Ctrl pressed, angle reported and not accidentally so)
     // Note: if detectZoomingEvent() doesn't unset the ControlModifier we'll get accelerated scrolling.
     if (m_zoomEventFilter->detectZoomingEvent(e)) {
         if (e->angleDelta().y() > 0) {
             slotIncFontSizes(qreal(e->angleDelta().y()) / QWheelEvent::DefaultDeltasPerStep);
         } else if (e->angleDelta().y() < 0) {
             slotDecFontSizes(qreal(-e->angleDelta().y()) / QWheelEvent::DefaultDeltasPerStep);
         }
 
         // accept always and be done for zooming
         e->accept();
         return;
     }
 
     // handle vertical scrolling via the scrollbar
     if (e->orientation() == Qt::Vertical) {
         // compute distance
         auto sign = m_lineScroll->invertedControls() ? -1 : 1;
         auto offset = sign * qreal(e->angleDelta().y()) / 120.0;
         if ( e->modifiers() & Qt::ShiftModifier ) {
             const auto pageStep = m_lineScroll->pageStep();
             offset = qBound(-pageStep, int(offset * pageStep), pageStep);
         } else {
             offset *= QApplication::wheelScrollLines();
         }
 
         // handle accumulation
         m_accumulatedScroll += offset - int(offset);
         const auto extraAccumulated = int(m_accumulatedScroll);
         m_accumulatedScroll -= extraAccumulated;
 
         // do scroll
         scrollViewLines(int(offset) + extraAccumulated);
         e->accept();
     }
 
     // handle horizontal scrolling via the scrollbar
     if (e->orientation() == Qt::Horizontal) {
         // if we have dyn word wrap, we should ignore the scroll events
         if (view()->dynWordWrap()) {
             e->accept();
             return;
         }
 
         QWheelEvent copy = *e;
         QApplication::sendEvent(m_columnScroll, &copy);
         if (copy.isAccepted()) {
             e->accept();
         }
     }
 }
 
 void KateViewInternal::startDragScroll()
 {
     if (!m_dragScrollTimer.isActive()) {
         m_dragScrollTimer.start(s_scrollTime);
     }
 }
 
 void KateViewInternal::stopDragScroll()
 {
     m_dragScrollTimer.stop();
     updateView();
 }
 
 void KateViewInternal::doDragScroll()
 {
     QPoint p = this->mapFromGlobal(QCursor::pos());
 
     int dx = 0, dy = 0;
     if (p.y() < s_scrollMargin) {
         dy = p.y() - s_scrollMargin;
     } else if (p.y() > height() - s_scrollMargin) {
         dy = s_scrollMargin - (height() - p.y());
     }
 
     if (p.x() < s_scrollMargin) {
         dx = p.x() - s_scrollMargin;
     } else if (p.x() > width() - s_scrollMargin) {
         dx = s_scrollMargin - (width() - p.x());
     }
 
     dy /= 4;
 
     if (dy) {
         scrollLines(startLine() + dy);
     }
 
     if (columnScrollingPossible() && dx) {
         scrollColumns(qMin(startX() + dx, m_columnScroll->maximum()));
     }
 
     if (!dy && !dx) {
         stopDragScroll();
     }
 }
 
 void KateViewInternal::registerTextHintProvider(KTextEditor::TextHintProvider *provider)
 {
     if (! m_textHintProviders.contains(provider)) {
         m_textHintProviders.append(provider);
     }
 
     // we have a client, so start timeout
     m_textHintTimer.start(m_textHintDelay);
 }
 
 void KateViewInternal::unregisterTextHintProvider(KTextEditor::TextHintProvider *provider)
 {
     const int index = m_textHintProviders.indexOf(provider);
     if (index >= 0) {
         m_textHintProviders.removeAt(index);
     }
 
     if (m_textHintProviders.isEmpty()) {
         m_textHintTimer.stop();
     }
 }
 
 void KateViewInternal::setTextHintDelay(int delay)
 {
     if (delay <= 0) {
         m_textHintDelay = 200; // ms
     } else {
         m_textHintDelay = delay; // ms
     }
 }
 
 int KateViewInternal::textHintDelay() const
 {
     return m_textHintDelay;
 }
 
 bool KateViewInternal::textHintsEnabled()
 {
     return ! m_textHintProviders.isEmpty();
 }
 
 //BEGIN EDIT STUFF
 void KateViewInternal::editStart()
 {
     editSessionNumber++;
 
     if (editSessionNumber > 1) {
         return;
     }
 
     editIsRunning = true;
     editOldCursor = m_cursor;
     editOldSelection = view()->selectionRange();
 }
 
 void KateViewInternal::editEnd(int editTagLineStart, int editTagLineEnd, bool tagFrom)
 {
     if (editSessionNumber == 0) {
         return;
     }
 
     editSessionNumber--;
 
     if (editSessionNumber > 0) {
         return;
     }
 
     // fix start position, might have moved from column 0
     // try to clever calculate the right start column for the tricky dyn word wrap case
     int col = 0;
     if (view()->dynWordWrap()) {
         if (KateLineLayoutPtr layout = cache()->line(startLine())) {
             int index = layout->viewLineForColumn(startPos().column());
             if (index >= 0 && index < layout->viewLineCount()) {
                 col = layout->viewLine(index).startCol();
             }
         }
     }
     m_startPos.setPosition(startLine(), col);
 
     if (tagFrom && (editTagLineStart <= int(view()->textFolding().visibleLineToLine(startLine())))) {
         tagAll();
     } else {
         tagLines(editTagLineStart, tagFrom ? qMax(doc()->lastLine() + 1, editTagLineEnd) : editTagLineEnd, true);
     }
 
     if (editOldCursor == m_cursor.toCursor()) {
         updateBracketMarks();
     }
 
     updateView(true);
 
     if (editOldCursor != m_cursor.toCursor() || m_view == doc()->activeView()) {
         // Only scroll the view to the cursor if the insertion happens at the cursor.
         // This might not be the case for e.g. collaborative editing, when a remote user
         // inserts text at a position not at the caret.
         if (m_cursor.line() >= editTagLineStart && m_cursor.line() <= editTagLineEnd) {
             m_madeVisible = false;
             updateCursor(m_cursor, true);
         }
     }
 
     /**
      * selection changed?
      * fixes bug 316226
      */
     if (editOldSelection != view()->selectionRange()
             || (editOldSelection.isValid() && !editOldSelection.isEmpty() && !(editTagLineStart > editOldSelection.end().line() && editTagLineEnd < editOldSelection.start().line()))) {
         emit view()->selectionChanged(m_view);
     }
 
     editIsRunning = false;
 }
 
 void KateViewInternal::editSetCursor(const KTextEditor::Cursor &_cursor)
 {
     if (m_cursor.toCursor() != _cursor) {
         m_cursor.setPosition(_cursor);
     }
 }
 //END
 
 void KateViewInternal::viewSelectionChanged()
 {
     if (!view()->selection()) {
         m_selectAnchor = KTextEditor::Cursor::invalid();
     } else {
         m_selectAnchor = view()->selectionRange().start();
     }
     // Do NOT nuke the entire range! The reason is that a shift+DC selection
     // might (correctly) set the range to be empty (i.e. start() == end()), and
     // subsequent dragging might shrink the selection into non-existence. When
     // this happens, we use the cached end to restore the cached start so that
     // updateSelection is not confused. See also comments in updateSelection.
     m_selectionCached.setStart(KTextEditor::Cursor::invalid());
 }
 
 KateLayoutCache *KateViewInternal::cache() const
 {
     return m_layoutCache;
 }
 
 KTextEditor::Cursor KateViewInternal::toRealCursor(const KTextEditor::Cursor &virtualCursor) const
 {
     return KTextEditor::Cursor(view()->textFolding().visibleLineToLine(virtualCursor.line()), virtualCursor.column());
 }
 
 KTextEditor::Cursor KateViewInternal::toVirtualCursor(const KTextEditor::Cursor &realCursor) const
 {
     /**
      * only convert valid lines, folding doesn't like invalid input!
      * don't validate whole cursor, column might be -1
      */
     if (realCursor.line() < 0) {
         return KTextEditor::Cursor::invalid();
     }
 
     return KTextEditor::Cursor(view()->textFolding().lineToVisibleLine(realCursor.line()), realCursor.column());
 }
 
 KateRenderer *KateViewInternal::renderer() const
 {
     return view()->renderer();
 }
 
 void KateViewInternal::mouseMoved()
 {
     view()->notifyMousePositionChanged(m_mouse);
     view()->updateRangesIn(KTextEditor::Attribute::ActivateMouseIn);
 }
 
 void KateViewInternal::cursorMoved()
 {
     view()->updateRangesIn(KTextEditor::Attribute::ActivateCaretIn);
 
 #ifndef QT_NO_ACCESSIBILITY
     if (QAccessible::isActive()) {
         QAccessibleTextCursorEvent ev(this, static_cast<KateViewAccessible *>(QAccessible::queryAccessibleInterface(this))->positionFromCursor(this, m_cursor));
         QAccessible::updateAccessibility(&ev);
     }
 #endif
 }
 
 bool KateViewInternal::rangeAffectsView(const KTextEditor::Range &range, bool realCursors) const
 {
     int startLine = KateViewInternal::startLine();
     int endLine = startLine + (int)m_visibleLineCount;
 
     if (realCursors) {
         startLine = (int)view()->textFolding().visibleLineToLine(startLine);
         endLine = (int)view()->textFolding().visibleLineToLine(endLine);
     }
 
     return (range.end().line() >= startLine) || (range.start().line() <= endLine);
 }
 
 //BEGIN IM INPUT STUFF
 QVariant KateViewInternal::inputMethodQuery(Qt::InputMethodQuery query) const
 {
     switch (query) {
     case Qt::ImCursorRectangle: {
         // Cursor placement code is changed for Asian input method that
         // shows candidate window. This behavior is same as Qt/E 2.3.7
         // which supports Asian input methods. Asian input methods need
         // start point of IM selection text to place candidate window as
         // adjacent to the selection text.
         //
         // in Qt5, cursor rectangle is used as QRectF internally, and it
         // will be checked by QRectF::isValid(), which will mark rectangle
         // with width == 0 or height == 0 as invalid.
         auto lineHeight = renderer()->lineHeight();
         return QRect(cursorToCoordinate(m_cursor, true, false), QSize(1, lineHeight ? lineHeight : 1));
     }
 
     case Qt::ImFont:
         return renderer()->currentFont();
 
     case Qt::ImCursorPosition:
         return m_cursor.column();
 
     case Qt::ImAnchorPosition:
         // If selectAnchor is at the same line, return the real anchor position
         // Otherwise return the same position of cursor
         if (view()->selection() && m_selectAnchor.line() == m_cursor.line()) {
             return m_selectAnchor.column();
         } else {
             return m_cursor.column();
         }
 
     case Qt::ImSurroundingText:
         if (Kate::TextLine l = doc()->kateTextLine(m_cursor.line())) {
             return l->string();
         } else {
             return QString();
         }
 
     case Qt::ImCurrentSelection:
         if (view()->selection()) {
             return view()->selectionText();
         } else {
             return QString();
         }
     default:
         /* values: ImMaximumTextLength */
         break;
     }
 
     return QWidget::inputMethodQuery(query);
 }
 
 void KateViewInternal::inputMethodEvent(QInputMethodEvent *e)
 {
     if (doc()->readOnly()) {
         e->ignore();
         return;
     }
 
     //qCDebug(LOG_KTE) << "Event: cursor" << m_cursor << "commit" << e->commitString() << "preedit" << e->preeditString() << "replacement start" << e->replacementStart() << "length" << e->replacementLength();
 
     if (!m_imPreeditRange) {
         m_imPreeditRange = doc()->newMovingRange(KTextEditor::Range(m_cursor, m_cursor), KTextEditor::MovingRange::ExpandLeft | KTextEditor::MovingRange::ExpandRight);
     }
 
     if (!m_imPreeditRange->toRange().isEmpty()) {
         doc()->inputMethodStart();
         doc()->removeText(*m_imPreeditRange);
         doc()->inputMethodEnd();
     }
 
     if (!e->commitString().isEmpty() || e->replacementLength()) {
         view()->removeSelectedText();
 
         KTextEditor::Range preeditRange = *m_imPreeditRange;
 
         KTextEditor::Cursor start(m_imPreeditRange->start().line(), m_imPreeditRange->start().column() + e->replacementStart());
         KTextEditor::Cursor removeEnd = start + KTextEditor::Cursor(0, e->replacementLength());
 
         doc()->editStart();
         if (start != removeEnd) {
             doc()->removeText(KTextEditor::Range(start, removeEnd));
         }
         if (!e->commitString().isEmpty()) {
             // if the input method event is text that should be inserted, call KTextEditor::DocumentPrivate::typeChars()
             // with the text. that method will handle the input and take care of overwrite mode, etc.
             doc()->typeChars(m_view, e->commitString());
         }
         doc()->editEnd();
 
         // Revert to the same range as above
         m_imPreeditRange->setRange(preeditRange);
     }
 
     if (!e->preeditString().isEmpty()) {
         doc()->inputMethodStart();
         doc()->insertText(m_imPreeditRange->start(), e->preeditString());
         doc()->inputMethodEnd();
         // The preedit range gets automatically repositioned
     }
 
     // Finished this input method context?
     if (m_imPreeditRange && e->preeditString().isEmpty()) {
         // delete the range and reset the pointer
         delete m_imPreeditRange;
         m_imPreeditRange = nullptr;
         qDeleteAll(m_imPreeditRangeChildren);
         m_imPreeditRangeChildren.clear();
 
         if (QApplication::cursorFlashTime() > 0) {
             renderer()->setDrawCaret(false);
         }
         renderer()->setCaretOverrideColor(QColor());
 
         e->accept();
         return;
     }
 
     KTextEditor::Cursor newCursor = m_cursor;
     bool hideCursor = false;
     QColor caretColor;
 
     if (m_imPreeditRange) {
         qDeleteAll(m_imPreeditRangeChildren);
         m_imPreeditRangeChildren.clear();
 
         int decorationColumn = 0;
         foreach (const QInputMethodEvent::Attribute &a, e->attributes()) {
             if (a.type == QInputMethodEvent::Cursor) {
                 newCursor = m_imPreeditRange->start() + KTextEditor::Cursor(0, a.start);
                 hideCursor = !a.length;
                 QColor c = qvariant_cast<QColor>(a.value);
                 if (c.isValid()) {
                     caretColor = c;
                 }
 
             } else if (a.type == QInputMethodEvent::TextFormat) {
                 QTextCharFormat f = qvariant_cast<QTextFormat>(a.value).toCharFormat();
                 if (f.isValid() && decorationColumn <= a.start) {
                     KTextEditor::Range fr(m_imPreeditRange->start().line(),  m_imPreeditRange->start().column() + a.start, m_imPreeditRange->start().line(), m_imPreeditRange->start().column() + a.start + a.length);
                     KTextEditor::MovingRange *formatRange = doc()->newMovingRange(fr);
                     KTextEditor::Attribute::Ptr attribute(new KTextEditor::Attribute());
                     attribute->merge(f);
                     formatRange->setAttribute(attribute);
                     decorationColumn = a.start + a.length;
                     m_imPreeditRangeChildren.push_back(formatRange);
                 }
             }
         }
     }
 
     renderer()->setDrawCaret(hideCursor);
     renderer()->setCaretOverrideColor(caretColor);
 
     if (newCursor != m_cursor.toCursor()) {
         updateCursor(newCursor);
     }
 
     e->accept();
 }
 
 //END IM INPUT STUFF
 
 void KateViewInternal::flashChar(const KTextEditor::Cursor &pos, KTextEditor::Attribute::Ptr attribute)
 {
     Q_ASSERT(pos.isValid());
     Q_ASSERT(attribute.constData());
 
     // if line is folded away, do nothing
     if (!view()->textFolding().isLineVisible(pos.line())) {
         return;
     }
 
     KTextEditor::Range range(pos, KTextEditor::Cursor(pos.line(), pos.column() + 1));
     if (m_textAnimation) {
         m_textAnimation->deleteLater();
     }
     m_textAnimation = new KateTextAnimation(range, attribute, this);
 }
 
 void KateViewInternal::documentTextInserted(KTextEditor::Document *document, const KTextEditor::Range &range)
 {
 #ifndef QT_NO_ACCESSIBILITY
     if (QAccessible::isActive()) {
         QAccessibleTextInsertEvent ev(this,
             static_cast<KateViewAccessible *>(QAccessible::queryAccessibleInterface(this))->positionFromCursor(this, range.start()), document->text(range));
         QAccessible::updateAccessibility(&ev);
     }
 #endif
 }
 
 void  KateViewInternal::documentTextRemoved(KTextEditor::Document * /*document*/, const KTextEditor::Range &range, const QString &oldText)
 {
 #ifndef QT_NO_ACCESSIBILITY
     if (QAccessible::isActive()) {
         QAccessibleTextRemoveEvent ev(this,
             static_cast<KateViewAccessible *>(QAccessible::queryAccessibleInterface(this))->positionFromCursor(this, range.start()), oldText);
         QAccessible::updateAccessibility(&ev);
     }
 #endif
 }
 
 QRect KateViewInternal::inlineNoteRect(const KateInlineNoteData& noteData) const
 {
     KTextEditor::InlineNote note(noteData);
     // compute note width and position
     const auto noteWidth = note.width();
     auto noteCursor = note.position();
 
     // The cursor might be outside of the text. In that case, clamp it to the text and
     // later on add the missing x offset.
     const auto lineLength = view()->document()->lineLength(noteCursor.line());
     int extraOffset = -noteWidth;
     if (noteCursor.column() == lineLength) {
         extraOffset = 0;
     } else if (noteCursor.column() > lineLength) {
         extraOffset = (noteCursor.column() - lineLength) * renderer()->spaceWidth();
         noteCursor.setColumn(lineLength);
     }
     auto noteStartPos = mapToGlobal(cursorToCoordinate(noteCursor, true, false));
 
     // compute the note's rect
     auto globalNoteRect = QRect(noteStartPos + QPoint{extraOffset, 0}, QSize(noteWidth, renderer()->lineHeight()));
 
     return globalNoteRect;
 }
 
 KateInlineNoteData KateViewInternal::inlineNoteAt(const QPoint& globalPos) const
 {
     // compute the associated cursor to get the right line
     const int line = coordinatesToCursor(mapFromGlobal(globalPos)).line();
     const auto inlineNotes = view()->inlineNotes(line);
     // loop over all notes and check if the point is inside it
     foreach (const auto& note, inlineNotes) {
         auto globalNoteRect = inlineNoteRect(note);
         if (globalNoteRect.contains(globalPos)) {
             return note;
         }
     }
     // none found -- return an invalid note
     return {};
 }