File indexing completed on 2024-04-21 03:57:27

 /*
     This file is part of the KDE libraries
     SPDX-FileCopyrightText: 2001-2004 Christoph Cullmann <cullmann@kde.org>
     SPDX-FileCopyrightText: 2001 Joseph Wenninger <jowenn@kde.org>
     SPDX-FileCopyrightText: 1999 Jochen Wilhelmy <digisnap@cs.tu-berlin.de>
     SPDX-FileCopyrightText: 2006 Hamish Rodda <rodda@kde.org>
     SPDX-FileCopyrightText: 2007 Mirko Stocker <me@misto.ch>
     SPDX-FileCopyrightText: 2009-2010 Michel Ludwig <michel.ludwig@kdemail.net>
     SPDX-FileCopyrightText: 2013 Gerald Senarclens de Grancy <oss@senarclens.eu>
     SPDX-FileCopyrightText: 2013 Andrey Matveyakin <a.matveyakin@gmail.com>
 
     SPDX-License-Identifier: LGPL-2.0-only
 */
 // BEGIN includes
 #include "katedocument.h"
 #include "config.h"
 #include "kateabstractinputmode.h"
 #include "kateautoindent.h"
 #include "katebuffer.h"
 #include "katecompletionwidget.h"
 #include "kateconfig.h"
 #include "katedialogs.h"
 #include "kateglobal.h"
 #include "katehighlight.h"
 #include "kateindentdetecter.h"
 #include "katemodemanager.h"
 #include "katepartdebug.h"
 #include "kateplaintextsearch.h"
 #include "kateregexpsearch.h"
 #include "katerenderer.h"
 #include "katescriptmanager.h"
 #include "kateswapfile.h"
 #include "katesyntaxmanager.h"
 #include "katetemplatehandler.h"
 #include "kateundomanager.h"
 #include "katevariableexpansionmanager.h"
 #include "kateview.h"
 #include "printing/kateprinter.h"
 #include "spellcheck/ontheflycheck.h"
 #include "spellcheck/prefixstore.h"
 #include "spellcheck/spellcheck.h"
 #include <fcntl.h>
 #include <qchar.h>
 
 #if EDITORCONFIG_FOUND
 #include "editorconfig.h"
 #endif
 
 #include <KTextEditor/Attribute>
 #include <KTextEditor/DocumentCursor>
 #include <ktexteditor/message.h>
 
 #include <KConfigGroup>
 #include <KDirWatch>
 #include <KFileItem>
 #include <KIO/FileCopyJob>
 #include <KIO/JobUiDelegate>
 #include <KIO/StatJob>
 #include <KJobWidgets>
 #include <KMessageBox>
 #include <KMountPoint>
 #include <KNetworkMounts>
 #include <KParts/OpenUrlArguments>
 #include <KStandardAction>
 #include <KStringHandler>
 #include <KToggleAction>
 #include <KXMLGUIFactory>
 
 #include <QApplication>
 #include <QClipboard>
 #include <QCryptographicHash>
 #include <QFile>
 #include <QFileDialog>
 #include <QLocale>
 #include <QMimeDatabase>
 #include <QProcess>
 #include <QRegularExpression>
 #include <QStandardPaths>
 #include <QTemporaryFile>
 #include <QTextStream>
 
 #include <cmath>
 
 // END  includes
 
 #if 0
 #define EDIT_DEBUG qCDebug(LOG_KTE)
 #else
 #define EDIT_DEBUG                                                                                                                                             \
     if (0)                                                                                                                                                     \
     qCDebug(LOG_KTE)
 #endif
 
 template<class C, class E>
 static int indexOf(const std::initializer_list<C> &list, const E &entry)
 {
     auto it = std::find(list.begin(), list.end(), entry);
     return it == list.end() ? -1 : std::distance(list.begin(), it);
 }
 
 template<class C, class E>
 static bool contains(const std::initializer_list<C> &list, const E &entry)
 {
     return indexOf(list, entry) >= 0;
 }
 
 static inline QChar matchingStartBracket(const QChar c)
 {
     switch (c.toLatin1()) {
     case '}':
         return QLatin1Char('{');
     case ']':
         return QLatin1Char('[');
     case ')':
         return QLatin1Char('(');
     }
     return QChar();
 }
 
 static inline QChar matchingEndBracket(const QChar c, bool withQuotes = true)
 {
     switch (c.toLatin1()) {
     case '{':
         return QLatin1Char('}');
     case '[':
         return QLatin1Char(']');
     case '(':
         return QLatin1Char(')');
     case '\'':
         return withQuotes ? QLatin1Char('\'') : QChar();
     case '"':
         return withQuotes ? QLatin1Char('"') : QChar();
     }
     return QChar();
 }
 
 static inline QChar matchingBracket(const QChar c)
 {
     QChar bracket = matchingStartBracket(c);
     if (bracket.isNull()) {
         bracket = matchingEndBracket(c, /*withQuotes=*/false);
     }
     return bracket;
 }
 
 static inline bool isStartBracket(const QChar c)
 {
     return !matchingEndBracket(c, /*withQuotes=*/false).isNull();
 }
 
 static inline bool isEndBracket(const QChar c)
 {
     return !matchingStartBracket(c).isNull();
 }
 
 static inline bool isBracket(const QChar c)
 {
     return isStartBracket(c) || isEndBracket(c);
 }
 
 // BEGIN d'tor, c'tor
 //
 // KTextEditor::DocumentPrivate Constructor
 //
 KTextEditor::DocumentPrivate::DocumentPrivate(const KPluginMetaData &data, bool bSingleViewMode, bool bReadOnly, QWidget *parentWidget, QObject *parent)
     : KTextEditor::Document(this, data, parent)
     , m_bSingleViewMode(bSingleViewMode)
     , m_bReadOnly(bReadOnly)
     ,
 
     m_undoManager(new KateUndoManager(this))
     ,
 
     m_buffer(new KateBuffer(this))
     , m_indenter(new KateAutoIndent(this))
     ,
 
     m_docName(QStringLiteral("need init"))
     ,
 
     m_fileType(QStringLiteral("Normal"))
     ,
 
     m_config(new KateDocumentConfig(this))
 
 {
     // setup component name
     const auto &aboutData = EditorPrivate::self()->aboutData();
     setComponentName(aboutData.componentName(), aboutData.displayName());
 
     // avoid spamming plasma and other window managers with progress dialogs
     // we show such stuff inline in the views!
     setProgressInfoEnabled(false);
 
     // register doc at factory
     KTextEditor::EditorPrivate::self()->registerDocument(this);
 
     // normal hl
     m_buffer->setHighlight(0);
 
     // swap file
     m_swapfile = (config()->swapFileMode() == KateDocumentConfig::DisableSwapFile) ? nullptr : new Kate::SwapFile(this);
 
     // some nice signals from the buffer
     connect(m_buffer, &KateBuffer::tagLines, this, &KTextEditor::DocumentPrivate::tagLines);
 
     // if the user changes the highlight with the dialog, notify the doc
     connect(KateHlManager::self(), &KateHlManager::changed, this, &KTextEditor::DocumentPrivate::internalHlChanged);
 
     // signals for mod on hd
     connect(KTextEditor::EditorPrivate::self()->dirWatch(), &KDirWatch::dirty, this, &KTextEditor::DocumentPrivate::slotModOnHdDirty);
 
     connect(KTextEditor::EditorPrivate::self()->dirWatch(), &KDirWatch::created, this, &KTextEditor::DocumentPrivate::slotModOnHdCreated);
 
     connect(KTextEditor::EditorPrivate::self()->dirWatch(), &KDirWatch::deleted, this, &KTextEditor::DocumentPrivate::slotModOnHdDeleted);
 
     // singleshot timer to handle updates of mod on hd state delayed
     m_modOnHdTimer.setSingleShot(true);
     m_modOnHdTimer.setInterval(200);
     connect(&m_modOnHdTimer, &QTimer::timeout, this, &KTextEditor::DocumentPrivate::slotDelayedHandleModOnHd);
 
     // Setup auto reload stuff
     m_autoReloadMode = new KToggleAction(i18n("Auto Reload Document"), this);
     m_autoReloadMode->setWhatsThis(i18n("Automatic reload the document when it was changed on disk"));
     connect(m_autoReloadMode, &KToggleAction::triggered, this, &DocumentPrivate::autoReloadToggled);
     // Prepare some reload amok protector...
     m_autoReloadThrottle.setSingleShot(true);
     //...but keep the value small in unit tests
     m_autoReloadThrottle.setInterval(KTextEditor::EditorPrivate::self()->unitTestMode() ? 50 : 3000);
     connect(&m_autoReloadThrottle, &QTimer::timeout, this, &DocumentPrivate::onModOnHdAutoReload);
 
     // load handling
     // this is needed to ensure we signal the user if a file is still loading
     // and to disallow him to edit in that time
     connect(this, &KTextEditor::DocumentPrivate::started, this, &KTextEditor::DocumentPrivate::slotStarted);
     connect(this, qOverload<>(&KTextEditor::DocumentPrivate::completed), this, &KTextEditor::DocumentPrivate::slotCompleted);
     connect(this, &KTextEditor::DocumentPrivate::canceled, this, &KTextEditor::DocumentPrivate::slotCanceled);
 
     // handle doc name updates
     connect(this, &KParts::ReadOnlyPart::urlChanged, this, &KTextEditor::DocumentPrivate::slotUrlChanged);
     updateDocName();
 
     // if single view mode, like in the konqui embedding, create a default view ;)
     // be lazy, only create it now, if any parentWidget is given, otherwise widget()
     // will create it on demand...
     if (m_bSingleViewMode && parentWidget) {
         KTextEditor::View *view = (KTextEditor::View *)createView(parentWidget);
         insertChildClient(view);
         view->setContextMenu(view->defaultContextMenu());
         setWidget(view);
     }
 
     connect(m_undoManager, &KateUndoManager::undoChanged, this, &KTextEditor::DocumentPrivate::undoChanged);
     connect(m_undoManager, &KateUndoManager::undoStart, this, &KTextEditor::DocumentPrivate::editingStarted);
     connect(m_undoManager, &KateUndoManager::undoEnd, this, &KTextEditor::DocumentPrivate::editingFinished);
     connect(m_undoManager, &KateUndoManager::redoStart, this, &KTextEditor::DocumentPrivate::editingStarted);
     connect(m_undoManager, &KateUndoManager::redoEnd, this, &KTextEditor::DocumentPrivate::editingFinished);
 
     connect(this, &KTextEditor::DocumentPrivate::sigQueryClose, this, &KTextEditor::DocumentPrivate::slotQueryClose_save);
 
     connect(this, &KTextEditor::DocumentPrivate::aboutToInvalidateMovingInterfaceContent, this, &KTextEditor::DocumentPrivate::clearEditingPosStack);
     onTheFlySpellCheckingEnabled(config()->onTheFlySpellCheck());
 
     // make sure correct defaults are set (indenter, ...)
     updateConfig();
 
     m_autoSaveTimer.setSingleShot(true);
     connect(&m_autoSaveTimer, &QTimer::timeout, this, [this] {
         if (isModified() && url().isLocalFile()) {
             documentSave();
         }
     });
 }
 
 //
 // KTextEditor::DocumentPrivate Destructor
 //
 KTextEditor::DocumentPrivate::~DocumentPrivate()
 {
     // we need to disconnect this as it triggers in destructor of KParts::ReadOnlyPart but we have already deleted
     // important stuff then
     disconnect(this, &KParts::ReadOnlyPart::urlChanged, this, &KTextEditor::DocumentPrivate::slotUrlChanged);
 
     // delete pending mod-on-hd message, if applicable
     delete m_modOnHdHandler;
 
     // we are about to delete cursors/ranges/...
     Q_EMIT aboutToDeleteMovingInterfaceContent(this);
 
     // kill it early, it has ranges!
     delete m_onTheFlyChecker;
     m_onTheFlyChecker = nullptr;
 
     clearDictionaryRanges();
 
     // Tell the world that we're about to close (== destruct)
     // Apps must receive this in a direct signal-slot connection, and prevent
     // any further use of interfaces once they return.
     Q_EMIT aboutToClose(this);
 
     // remove file from dirwatch
     deactivateDirWatch();
 
     // thanks for offering, KPart, but we're already self-destructing
     setAutoDeleteWidget(false);
     setAutoDeletePart(false);
 
     // clean up remaining views
     qDeleteAll(m_views);
     m_views.clear();
 
     // clean up marks
     for (auto &mark : std::as_const(m_marks)) {
         delete mark;
     }
     m_marks.clear();
 
     // de-register document early from global collections
     // otherwise we might "use" them again during destruction in a half-valid state
     // see e.g. bug 422546 for similar issues with view
     // this is still early enough, as as long as m_config is valid, this document is still "OK"
     KTextEditor::EditorPrivate::self()->deregisterDocument(this);
 }
 // END
 
 void KTextEditor::DocumentPrivate::saveEditingPositions(const KTextEditor::Cursor cursor)
 {
     if (m_editingStackPosition != m_editingStack.size() - 1) {
         m_editingStack.resize(m_editingStackPosition);
     }
 
     // try to be clever: reuse existing cursors if possible
     std::shared_ptr<KTextEditor::MovingCursor> mc;
 
     // we might pop last one: reuse that
     if (!m_editingStack.isEmpty() && cursor.line() == m_editingStack.top()->line()) {
         mc = m_editingStack.pop();
     }
 
     // we might expire oldest one, reuse that one, if not already one there
     // we prefer the other one for reuse, as already on the right line aka in the right block!
     const int editingStackSizeLimit = 32;
     if (m_editingStack.size() >= editingStackSizeLimit) {
         if (mc) {
             m_editingStack.removeFirst();
         } else {
             mc = m_editingStack.takeFirst();
         }
     }
 
     // new cursor needed? or adjust existing one?
     if (mc) {
         mc->setPosition(cursor);
     } else {
         mc = std::shared_ptr<KTextEditor::MovingCursor>(newMovingCursor(cursor));
     }
 
     // add new one as top of stack
     m_editingStack.push(mc);
     m_editingStackPosition = m_editingStack.size() - 1;
 }
 
 KTextEditor::Cursor KTextEditor::DocumentPrivate::lastEditingPosition(EditingPositionKind nextOrPrev, KTextEditor::Cursor currentCursor)
 {
     if (m_editingStack.isEmpty()) {
         return KTextEditor::Cursor::invalid();
     }
     auto targetPos = m_editingStack.at(m_editingStackPosition)->toCursor();
     if (targetPos == currentCursor) {
         if (nextOrPrev == Previous) {
             m_editingStackPosition--;
         } else {
             m_editingStackPosition++;
         }
         m_editingStackPosition = qBound(0, m_editingStackPosition, m_editingStack.size() - 1);
     }
     return m_editingStack.at(m_editingStackPosition)->toCursor();
 }
 
 void KTextEditor::DocumentPrivate::clearEditingPosStack()
 {
     m_editingStack.clear();
     m_editingStackPosition = -1;
 }
 
 // on-demand view creation
 QWidget *KTextEditor::DocumentPrivate::widget()
 {
     // no singleViewMode -> no widget()...
     if (!singleViewMode()) {
         return nullptr;
     }
 
     // does a widget exist already? use it!
     if (KTextEditor::Document::widget()) {
         return KTextEditor::Document::widget();
     }
 
     // create and return one...
     KTextEditor::View *view = (KTextEditor::View *)createView(nullptr);
     insertChildClient(view);
     view->setContextMenu(view->defaultContextMenu());
     setWidget(view);
     return view;
 }
 
 // BEGIN KTextEditor::Document stuff
 
 KTextEditor::View *KTextEditor::DocumentPrivate::createView(QWidget *parent, KTextEditor::MainWindow *mainWindow)
 {
     KTextEditor::ViewPrivate *newView = new KTextEditor::ViewPrivate(this, parent, mainWindow);
 
     if (m_fileChangedDialogsActivated) {
         connect(newView, &KTextEditor::ViewPrivate::focusIn, this, &KTextEditor::DocumentPrivate::slotModifiedOnDisk);
     }
 
     Q_EMIT viewCreated(this, newView);
 
     // post existing messages to the new view, if no specific view is given
     const auto keys = m_messageHash.keys();
     for (KTextEditor::Message *message : keys) {
         if (!message->view()) {
             newView->postMessage(message, m_messageHash[message]);
         }
     }
 
     return newView;
 }
 
 KTextEditor::Range KTextEditor::DocumentPrivate::rangeOnLine(KTextEditor::Range range, int line) const
 {
     const int col1 = toVirtualColumn(range.start());
     const int col2 = toVirtualColumn(range.end());
     return KTextEditor::Range(line, fromVirtualColumn(line, col1), line, fromVirtualColumn(line, col2));
 }
 
 // BEGIN KTextEditor::EditInterface stuff
 
 bool KTextEditor::DocumentPrivate::isEditingTransactionRunning() const
 {
     return editSessionNumber > 0;
 }
 
 QString KTextEditor::DocumentPrivate::text() const
 {
     return m_buffer->text();
 }
 
 QString KTextEditor::DocumentPrivate::text(KTextEditor::Range range, bool blockwise) const
 {
     if (!range.isValid()) {
         qCWarning(LOG_KTE) << "Text requested for invalid range" << range;
         return QString();
     }
 
     QString s;
 
     if (range.start().line() == range.end().line()) {
         if (range.start().column() > range.end().column()) {
             return QString();
         }
 
         Kate::TextLine textLine = m_buffer->plainLine(range.start().line());
         return textLine.string(range.start().column(), range.end().column() - range.start().column());
     } else {
         for (int i = range.start().line(); (i <= range.end().line()) && (i < m_buffer->lines()); ++i) {
             Kate::TextLine textLine = m_buffer->plainLine(i);
             if (!blockwise) {
                 if (i == range.start().line()) {
                     s.append(textLine.string(range.start().column(), textLine.length() - range.start().column()));
                 } else if (i == range.end().line()) {
                     s.append(textLine.string(0, range.end().column()));
                 } else {
                     s.append(textLine.text());
                 }
             } else {
                 KTextEditor::Range subRange = rangeOnLine(range, i);
                 s.append(textLine.string(subRange.start().column(), subRange.columnWidth()));
             }
 
             if (i < range.end().line()) {
                 s.append(QLatin1Char('\n'));
             }
         }
     }
 
     return s;
 }
 
 QChar KTextEditor::DocumentPrivate::characterAt(KTextEditor::Cursor position) const
 {
     Kate::TextLine textLine = m_buffer->plainLine(position.line());
     return textLine.at(position.column());
 }
 
 QString KTextEditor::DocumentPrivate::wordAt(KTextEditor::Cursor cursor) const
 {
     return text(wordRangeAt(cursor));
 }
 
 KTextEditor::Range KTextEditor::DocumentPrivate::wordRangeAt(KTextEditor::Cursor cursor) const
 {
     // get text line
     const int line = cursor.line();
     Kate::TextLine textLine = m_buffer->plainLine(line);
 
     // make sure the cursor is
     const int lineLenth = textLine.length();
     if (cursor.column() > lineLenth) {
         return KTextEditor::Range::invalid();
     }
 
     int start = cursor.column();
     int end = start;
 
     while (start > 0 && highlight()->isInWord(textLine.at(start - 1), textLine.attribute(start - 1))) {
         start--;
     }
     while (end < lineLenth && highlight()->isInWord(textLine.at(end), textLine.attribute(end))) {
         end++;
     }
 
     return KTextEditor::Range(line, start, line, end);
 }
 
 bool KTextEditor::DocumentPrivate::isValidTextPosition(KTextEditor::Cursor cursor) const
 {
     const int ln = cursor.line();
     const int col = cursor.column();
     // cursor in document range?
     if (ln < 0 || col < 0 || ln >= lines() || col > lineLength(ln)) {
         return false;
     }
 
     const QString str = line(ln);
     Q_ASSERT(str.length() >= col);
 
     // cursor at end of line?
     const int len = lineLength(ln);
     if (col == 0 || col == len) {
         return true;
     }
 
     // cursor in the middle of a valid utf32-surrogate?
     return (!str.at(col).isLowSurrogate()) || (!str.at(col - 1).isHighSurrogate());
 }
 
 QStringList KTextEditor::DocumentPrivate::textLines(KTextEditor::Range range, bool blockwise) const
 {
     QStringList ret;
 
     if (!range.isValid()) {
         qCWarning(LOG_KTE) << "Text requested for invalid range" << range;
         return ret;
     }
 
     if (blockwise && (range.start().column() > range.end().column())) {
         return ret;
     }
 
     if (range.start().line() == range.end().line()) {
         Q_ASSERT(range.start() <= range.end());
 
         Kate::TextLine textLine = m_buffer->plainLine(range.start().line());
         ret << textLine.string(range.start().column(), range.end().column() - range.start().column());
     } else {
         for (int i = range.start().line(); (i <= range.end().line()) && (i < m_buffer->lines()); ++i) {
             Kate::TextLine textLine = m_buffer->plainLine(i);
             if (!blockwise) {
                 if (i == range.start().line()) {
                     ret << textLine.string(range.start().column(), textLine.length() - range.start().column());
                 } else if (i == range.end().line()) {
                     ret << textLine.string(0, range.end().column());
                 } else {
                     ret << textLine.text();
                 }
             } else {
                 KTextEditor::Range subRange = rangeOnLine(range, i);
                 ret << textLine.string(subRange.start().column(), subRange.columnWidth());
             }
         }
     }
 
     return ret;
 }
 
 QString KTextEditor::DocumentPrivate::line(int line) const
 {
     Kate::TextLine l = m_buffer->plainLine(line);
     return l.text();
 }
 
 bool KTextEditor::DocumentPrivate::setText(const QString &s)
 {
     if (!isReadWrite()) {
         return false;
     }
 
     std::vector<KTextEditor::Mark> msave;
     msave.reserve(m_marks.size());
     std::transform(m_marks.cbegin(), m_marks.cend(), std::back_inserter(msave), [](KTextEditor::Mark *mark) {
         return *mark;
     });
 
     for (auto v : std::as_const(m_views)) {
         static_cast<KTextEditor::ViewPrivate *>(v)->completionWidget()->setIgnoreBufferSignals(true);
     }
 
     editStart();
 
     // delete the text
     clear();
 
     // insert the new text
     insertText(KTextEditor::Cursor(), s);
 
     editEnd();
 
     for (auto v : std::as_const(m_views)) {
         static_cast<KTextEditor::ViewPrivate *>(v)->completionWidget()->setIgnoreBufferSignals(false);
     }
 
     for (KTextEditor::Mark mark : msave) {
         setMark(mark.line, mark.type);
     }
 
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::setText(const QStringList &text)
 {
     if (!isReadWrite()) {
         return false;
     }
 
     std::vector<KTextEditor::Mark> msave;
     msave.reserve(m_marks.size());
     std::transform(m_marks.cbegin(), m_marks.cend(), std::back_inserter(msave), [](KTextEditor::Mark *mark) {
         return *mark;
     });
 
     for (auto v : std::as_const(m_views)) {
         static_cast<KTextEditor::ViewPrivate *>(v)->completionWidget()->setIgnoreBufferSignals(true);
     }
 
     editStart();
 
     // delete the text
     clear();
 
     // insert the new text
     insertText(KTextEditor::Cursor::start(), text);
 
     editEnd();
 
     for (auto v : std::as_const(m_views)) {
         static_cast<KTextEditor::ViewPrivate *>(v)->completionWidget()->setIgnoreBufferSignals(false);
     }
 
     for (KTextEditor::Mark mark : msave) {
         setMark(mark.line, mark.type);
     }
 
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::clear()
 {
     if (!isReadWrite()) {
         return false;
     }
 
     for (auto view : std::as_const(m_views)) {
         static_cast<ViewPrivate *>(view)->clear();
         static_cast<ViewPrivate *>(view)->tagAll();
         view->update();
     }
 
     clearMarks();
 
     Q_EMIT aboutToInvalidateMovingInterfaceContent(this);
     m_buffer->invalidateRanges();
 
     Q_EMIT aboutToRemoveText(documentRange());
 
     return editRemoveLines(0, lastLine());
 }
 
 bool KTextEditor::DocumentPrivate::insertText(const KTextEditor::Cursor position, const QString &text, bool block)
 {
     if (!isReadWrite()) {
         return false;
     }
 
     if (text.isEmpty()) {
         return true;
     }
 
     editStart();
     // Disable emitting textInsertedRange signal in every editInsertText call
     // we will emit a single signal at the end of this function
     bool notify = false;
 
     int currentLine = position.line();
     int currentLineStart = 0;
     const int totalLength = text.length();
     int insertColumn = position.column();
 
     // pad with empty lines, if insert position is after last line
     if (position.line() > lines()) {
         int line = lines();
         while (line <= position.line()) {
             editInsertLine(line, QString(), false);
             line++;
         }
     }
 
     // compute expanded column for block mode
     int positionColumnExpanded = insertColumn;
     const int tabWidth = config()->tabWidth();
     if (block) {
         if (currentLine < lines()) {
             positionColumnExpanded = plainKateTextLine(currentLine).toVirtualColumn(insertColumn, tabWidth);
         }
     }
 
     int endCol = 0;
     int pos = 0;
     for (; pos < totalLength; pos++) {
         const QChar &ch = text.at(pos);
 
         if (ch == QLatin1Char('\n')) {
             // Only perform the text insert if there is text to insert
             if (currentLineStart < pos) {
                 editInsertText(currentLine, insertColumn, text.mid(currentLineStart, pos - currentLineStart), notify);
                 endCol = insertColumn + (pos - currentLineStart);
             }
 
             if (!block) {
                 // ensure we can handle wrap positions behind maximal column, same handling as in editInsertText for invalid columns
                 const auto wrapColumn = insertColumn + pos - currentLineStart;
                 const auto currentLineLength = lineLength(currentLine);
                 if (wrapColumn > currentLineLength) {
                     editInsertText(currentLine, currentLineLength, QString(wrapColumn - currentLineLength, QLatin1Char(' ')), notify);
                 }
 
                 // wrap line call is now save, as wrapColumn is valid for sure!
                 editWrapLine(currentLine, wrapColumn, /*newLine=*/true, nullptr, notify);
                 insertColumn = 0;
                 endCol = 0;
             }
 
             currentLine++;
 
             if (block) {
                 auto l = currentLine < lines();
                 if (currentLine == lastLine() + 1) {
                     editInsertLine(currentLine, QString(), notify);
                     endCol = 0;
                 }
                 insertColumn = positionColumnExpanded;
                 if (l) {
                     insertColumn = plainKateTextLine(currentLine).fromVirtualColumn(insertColumn, tabWidth);
                 }
             }
 
             currentLineStart = pos + 1;
         }
     }
 
     // Only perform the text insert if there is text to insert
     if (currentLineStart < pos) {
         editInsertText(currentLine, insertColumn, text.mid(currentLineStart, pos - currentLineStart), notify);
         endCol = insertColumn + (pos - currentLineStart);
     }
 
     // let the world know that we got some new text
     KTextEditor::Range insertedRange(position, currentLine, endCol);
     Q_EMIT textInsertedRange(this, insertedRange);
 
     editEnd();
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::insertText(KTextEditor::Cursor position, const QStringList &textLines, bool block)
 {
     if (!isReadWrite()) {
         return false;
     }
 
     // just reuse normal function
     return insertText(position, textLines.join(QLatin1Char('\n')), block);
 }
 
 bool KTextEditor::DocumentPrivate::removeText(KTextEditor::Range _range, bool block)
 {
     KTextEditor::Range range = _range;
 
     if (!isReadWrite()) {
         return false;
     }
 
     // Should now be impossible to trigger with the new Range class
     Q_ASSERT(range.start().line() <= range.end().line());
 
     if (range.start().line() > lastLine()) {
         return false;
     }
 
     if (!block) {
         Q_EMIT aboutToRemoveText(range);
     }
 
     editStart();
 
     if (!block) {
         if (range.end().line() > lastLine()) {
             range.setEnd(KTextEditor::Cursor(lastLine() + 1, 0));
         }
 
         if (range.onSingleLine()) {
             editRemoveText(range.start().line(), range.start().column(), range.columnWidth());
         } else {
             int from = range.start().line();
             int to = range.end().line();
 
             // remove last line
             if (to <= lastLine()) {
                 editRemoveText(to, 0, range.end().column());
             }
 
             // editRemoveLines() will be called on first line (to remove bookmark)
             if (range.start().column() == 0 && from > 0) {
                 --from;
             }
 
             // remove middle lines
             editRemoveLines(from + 1, to - 1);
 
             // remove first line if not already removed by editRemoveLines()
             if (range.start().column() > 0 || range.start().line() == 0) {
                 editRemoveText(from, range.start().column(), m_buffer->plainLine(from).length() - range.start().column());
                 editUnWrapLine(from);
             }
         }
     } // if ( ! block )
     else {
         int startLine = qMax(0, range.start().line());
         int vc1 = toVirtualColumn(range.start());
         int vc2 = toVirtualColumn(range.end());
         for (int line = qMin(range.end().line(), lastLine()); line >= startLine; --line) {
             int col1 = fromVirtualColumn(line, vc1);
             int col2 = fromVirtualColumn(line, vc2);
             editRemoveText(line, qMin(col1, col2), qAbs(col2 - col1));
         }
     }
 
     editEnd();
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::insertLine(int l, const QString &str)
 {
     if (!isReadWrite()) {
         return false;
     }
 
     if (l < 0 || l > lines()) {
         return false;
     }
 
     return editInsertLine(l, str);
 }
 
 bool KTextEditor::DocumentPrivate::insertLines(int line, const QStringList &text)
 {
     if (!isReadWrite()) {
         return false;
     }
 
     if (line < 0 || line > lines()) {
         return false;
     }
 
     bool success = true;
     for (const QString &string : text) {
         success &= editInsertLine(line++, string);
     }
 
     return success;
 }
 
 bool KTextEditor::DocumentPrivate::removeLine(int line)
 {
     if (!isReadWrite()) {
         return false;
     }
 
     if (line < 0 || line > lastLine()) {
         return false;
     }
 
     return editRemoveLine(line);
 }
 
 qsizetype KTextEditor::DocumentPrivate::totalCharacters() const
 {
     qsizetype l = 0;
     for (int i = 0; i < m_buffer->lines(); ++i) {
         l += m_buffer->lineLength(i);
     }
     return l;
 }
 
 int KTextEditor::DocumentPrivate::lines() const
 {
     return m_buffer->lines();
 }
 
 int KTextEditor::DocumentPrivate::lineLength(int line) const
 {
     return m_buffer->lineLength(line);
 }
 
 qsizetype KTextEditor::DocumentPrivate::cursorToOffset(KTextEditor::Cursor c) const
 {
     return m_buffer->cursorToOffset(c);
 }
 
 KTextEditor::Cursor KTextEditor::DocumentPrivate::offsetToCursor(qsizetype offset) const
 {
     return m_buffer->offsetToCursor(offset);
 }
 
 bool KTextEditor::DocumentPrivate::isLineModified(int line) const
 {
     if (line < 0 || line >= lines()) {
         return false;
     }
 
     Kate::TextLine l = m_buffer->plainLine(line);
     return l.markedAsModified();
 }
 
 bool KTextEditor::DocumentPrivate::isLineSaved(int line) const
 {
     if (line < 0 || line >= lines()) {
         return false;
     }
 
     Kate::TextLine l = m_buffer->plainLine(line);
     return l.markedAsSavedOnDisk();
 }
 
 bool KTextEditor::DocumentPrivate::isLineTouched(int line) const
 {
     if (line < 0 || line >= lines()) {
         return false;
     }
 
     Kate::TextLine l = m_buffer->plainLine(line);
     return l.markedAsModified() || l.markedAsSavedOnDisk();
 }
 // END
 
 // BEGIN KTextEditor::EditInterface internal stuff
 //
 // Starts an edit session with (or without) undo, update of view disabled during session
 //
 bool KTextEditor::DocumentPrivate::editStart()
 {
     editSessionNumber++;
 
     if (editSessionNumber > 1) {
         return false;
     }
 
     editIsRunning = true;
 
     // no last change cursor at start
     m_editLastChangeStartCursor = KTextEditor::Cursor::invalid();
 
     m_undoManager->editStart();
 
     for (auto view : std::as_const(m_views)) {
         static_cast<ViewPrivate *>(view)->editStart();
     }
 
     m_buffer->editStart();
     return true;
 }
 
 //
 // End edit session and update Views
 //
 bool KTextEditor::DocumentPrivate::editEnd()
 {
     if (editSessionNumber == 0) {
         Q_ASSERT(0);
         return false;
     }
 
     // wrap the new/changed text, if something really changed!
     if (m_buffer->editChanged() && (editSessionNumber == 1)) {
         if (m_undoManager->isActive() && config()->wordWrap()) {
             wrapText(m_buffer->editTagStart(), m_buffer->editTagEnd());
         }
     }
 
     editSessionNumber--;
 
     if (editSessionNumber > 0) {
         return false;
     }
 
     // end buffer edit, will trigger hl update
     // this will cause some possible adjustment of tagline start/end
     m_buffer->editEnd();
 
     m_undoManager->editEnd();
 
     // edit end for all views !!!!!!!!!
     for (auto view : std::as_const(m_views)) {
         static_cast<ViewPrivate *>(view)->editEnd(m_buffer->editTagStart(), m_buffer->editTagEnd(), m_buffer->editTagFrom());
     }
 
     if (m_buffer->editChanged()) {
         setModified(true);
         Q_EMIT textChanged(this);
     }
 
     // remember last change position in the stack, if any
     // this avoid costly updates for longer editing transactions
     // before we did that on textInsert/Removed
     if (m_editLastChangeStartCursor.isValid()) {
         saveEditingPositions(m_editLastChangeStartCursor);
     }
 
     if (config()->autoSave() && config()->autoSaveInterval() > 0) {
         m_autoSaveTimer.start();
     }
 
     editIsRunning = false;
     return true;
 }
 
 void KTextEditor::DocumentPrivate::pushEditState()
 {
     editStateStack.push(editSessionNumber);
 }
 
 void KTextEditor::DocumentPrivate::popEditState()
 {
     if (editStateStack.isEmpty()) {
         return;
     }
 
     int count = editStateStack.pop() - editSessionNumber;
     while (count < 0) {
         ++count;
         editEnd();
     }
     while (count > 0) {
         --count;
         editStart();
     }
 }
 
 void KTextEditor::DocumentPrivate::inputMethodStart()
 {
     m_undoManager->inputMethodStart();
 }
 
 void KTextEditor::DocumentPrivate::inputMethodEnd()
 {
     m_undoManager->inputMethodEnd();
 }
 
 bool KTextEditor::DocumentPrivate::wrapText(int startLine, int endLine)
 {
     if (startLine < 0 || endLine < 0) {
         return false;
     }
 
     if (!isReadWrite()) {
         return false;
     }
 
     int col = config()->wordWrapAt();
 
     if (col == 0) {
         return false;
     }
 
     editStart();
 
     for (int line = startLine; (line <= endLine) && (line < lines()); line++) {
         Kate::TextLine l = kateTextLine(line);
 
         // qCDebug(LOG_KTE) << "try wrap line: " << line;
 
         if (l.virtualLength(m_buffer->tabWidth()) > col) {
             bool nextlValid = line + 1 < lines();
             Kate::TextLine nextl = kateTextLine(line + 1);
 
             // qCDebug(LOG_KTE) << "do wrap line: " << line;
 
             int eolPosition = l.length() - 1;
 
             // take tabs into account here, too
             int x = 0;
             const QString &t = l.text();
             int z2 = 0;
             for (; z2 < l.length(); z2++) {
                 static const QChar tabChar(QLatin1Char('\t'));
                 if (t.at(z2) == tabChar) {
                     x += m_buffer->tabWidth() - (x % m_buffer->tabWidth());
                 } else {
                     x++;
                 }
 
                 if (x > col) {
                     break;
                 }
             }
 
             const int colInChars = qMin(z2, l.length() - 1);
             int searchStart = colInChars;
 
             // If where we are wrapping is an end of line and is a space we don't
             // want to wrap there
             if (searchStart == eolPosition && t.at(searchStart).isSpace()) {
                 searchStart--;
             }
 
             // Scan backwards looking for a place to break the line
             // We are not interested in breaking at the first char
             // of the line (if it is a space), but we are at the second
             // anders: if we can't find a space, try breaking on a word
             // boundary, using KateHighlight::canBreakAt().
             // This could be a priority (setting) in the hl/filetype/document
             int z = -1;
             int nw = -1; // alternative position, a non word character
             for (z = searchStart; z >= 0; z--) {
                 if (t.at(z).isSpace()) {
                     break;
                 }
                 if ((nw < 0) && highlight()->canBreakAt(t.at(z), l.attribute(z))) {
                     nw = z;
                 }
             }
 
             if (z >= 0) {
                 // So why don't we just remove the trailing space right away?
                 // Well, the (view's) cursor may be directly in front of that space
                 // (user typing text before the last word on the line), and if that
                 // happens, the cursor would be moved to the next line, which is not
                 // what we want (bug #106261)
                 z++;
             } else {
                 // There was no space to break at so break at a nonword character if
                 // found, or at the wrapcolumn ( that needs be configurable )
                 // Don't try and add any white space for the break
                 if ((nw >= 0) && nw < colInChars) {
                     nw++; // break on the right side of the character
                 }
                 z = (nw >= 0) ? nw : colInChars;
             }
 
             if (nextlValid && !nextl.isAutoWrapped()) {
                 editWrapLine(line, z, true);
                 editMarkLineAutoWrapped(line + 1, true);
 
                 endLine++;
             } else {
                 if (nextlValid && (nextl.length() > 0) && !nextl.at(0).isSpace() && ((l.length() < 1) || !l.at(l.length() - 1).isSpace())) {
                     editInsertText(line + 1, 0, QStringLiteral(" "));
                 }
 
                 bool newLineAdded = false;
                 editWrapLine(line, z, false, &newLineAdded);
 
                 editMarkLineAutoWrapped(line + 1, true);
 
                 endLine++;
             }
         }
     }
 
     editEnd();
 
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::wrapParagraph(int first, int last)
 {
     if (first == last) {
         return wrapText(first, last);
     }
 
     if (first < 0 || last < first) {
         return false;
     }
 
     if (last >= lines() || first > last) {
         return false;
     }
 
     if (!isReadWrite()) {
         return false;
     }
 
     editStart();
 
     // Because we shrink and expand lines, we need to track the working set by powerful "MovingStuff"
     std::unique_ptr<KTextEditor::MovingRange> range(newMovingRange(KTextEditor::Range(first, 0, last, 0)));
     std::unique_ptr<KTextEditor::MovingCursor> curr(newMovingCursor(KTextEditor::Cursor(range->start())));
 
     // Scan the selected range for paragraphs, whereas each empty line trigger a new paragraph
     for (int line = first; line <= range->end().line(); ++line) {
         // Is our first line a somehow filled line?
         if (plainKateTextLine(first).firstChar() < 0) {
             // Fast forward to first non empty line
             ++first;
             curr->setPosition(curr->line() + 1, 0);
             continue;
         }
 
         // Is our current line a somehow filled line? If not, wrap the paragraph
         if (plainKateTextLine(line).firstChar() < 0) {
             curr->setPosition(line, 0); // Set on empty line
             joinLines(first, line - 1);
             // Don't wrap twice! That may cause a bad result
             if (!wordWrap()) {
                 wrapText(first, first);
             }
             first = curr->line() + 1;
             line = first;
         }
     }
 
     // If there was no paragraph, we need to wrap now
     bool needWrap = (curr->line() != range->end().line());
     if (needWrap && plainKateTextLine(first).firstChar() != -1) {
         joinLines(first, range->end().line());
         // Don't wrap twice! That may cause a bad result
         if (!wordWrap()) {
             wrapText(first, first);
         }
     }
 
     editEnd();
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::editInsertText(int line, int col, const QString &s, bool notify)
 {
     // verbose debug
     EDIT_DEBUG << "editInsertText" << line << col << s;
 
     if (line < 0 || col < 0) {
         return false;
     }
 
     // nothing to do, do nothing!
     if (s.isEmpty()) {
         return true;
     }
 
     if (!isReadWrite()) {
         return false;
     }
 
     auto l = plainKateTextLine(line);
     int length = l.length();
     if (length < 0) {
         return false;
     }
 
     editStart();
 
     QString s2 = s;
     int col2 = col;
     if (col2 > length) {
         s2 = QString(col2 - length, QLatin1Char(' ')) + s;
         col2 = length;
     }
 
     m_undoManager->slotTextInserted(line, col2, s2, l);
 
     // remember last change cursor
     m_editLastChangeStartCursor = KTextEditor::Cursor(line, col2);
 
     // insert text into line
     m_buffer->insertText(m_editLastChangeStartCursor, s2);
 
     if (notify) {
         Q_EMIT textInsertedRange(this, KTextEditor::Range(line, col2, line, col2 + s2.length()));
     }
 
     editEnd();
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::editRemoveText(int line, int col, int len)
 {
     // verbose debug
     EDIT_DEBUG << "editRemoveText" << line << col << len;
 
     if (line < 0 || line >= lines() || col < 0 || len < 0) {
         return false;
     }
 
     if (!isReadWrite()) {
         return false;
     }
 
     Kate::TextLine l = plainKateTextLine(line);
 
     // nothing to do, do nothing!
     if (len == 0) {
         return true;
     }
 
     // wrong column
     if (col >= l.text().size()) {
         return false;
     }
 
     // don't try to remove what's not there
     len = qMin(len, l.text().size() - col);
 
     editStart();
 
     QString oldText = l.string(col, len);
 
     m_undoManager->slotTextRemoved(line, col, oldText, l);
 
     // remember last change cursor
     m_editLastChangeStartCursor = KTextEditor::Cursor(line, col);
 
     // remove text from line
     m_buffer->removeText(KTextEditor::Range(m_editLastChangeStartCursor, KTextEditor::Cursor(line, col + len)));
 
     Q_EMIT textRemoved(this, KTextEditor::Range(line, col, line, col + len), oldText);
 
     editEnd();
 
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::editMarkLineAutoWrapped(int line, bool autowrapped)
 {
     // verbose debug
     EDIT_DEBUG << "editMarkLineAutoWrapped" << line << autowrapped;
 
     if (line < 0 || line >= lines()) {
         return false;
     }
 
     if (!isReadWrite()) {
         return false;
     }
 
     editStart();
 
     m_undoManager->slotMarkLineAutoWrapped(line, autowrapped);
 
     Kate::TextLine l = kateTextLine(line);
     l.setAutoWrapped(autowrapped);
     m_buffer->setLineMetaData(line, l);
 
     editEnd();
 
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::editWrapLine(int line, int col, bool newLine, bool *newLineAdded, bool notify)
 {
     // verbose debug
     EDIT_DEBUG << "editWrapLine" << line << col << newLine;
 
     if (line < 0 || line >= lines() || col < 0) {
         return false;
     }
 
     if (!isReadWrite()) {
         return false;
     }
 
     const auto tl = plainKateTextLine(line);
 
     editStart();
 
     const bool nextLineValid = lineLength(line + 1) >= 0;
 
     m_undoManager->slotLineWrapped(line, col, tl.length() - col, (!nextLineValid || newLine), tl);
 
     if (!nextLineValid || newLine) {
         m_buffer->wrapLine(KTextEditor::Cursor(line, col));
 
         QVarLengthArray<KTextEditor::Mark *, 8> list;
         for (const auto &mark : std::as_const(m_marks)) {
             if (mark->line >= line) {
                 if ((col == 0) || (mark->line > line)) {
                     list.push_back(mark);
                 }
             }
         }
 
         for (const auto &mark : list) {
             m_marks.take(mark->line);
         }
 
         for (const auto &mark : list) {
             mark->line++;
             m_marks.insert(mark->line, mark);
         }
 
         if (!list.empty()) {
             Q_EMIT marksChanged(this);
         }
 
         // yes, we added a new line !
         if (newLineAdded) {
             (*newLineAdded) = true;
         }
     } else {
         m_buffer->wrapLine(KTextEditor::Cursor(line, col));
         m_buffer->unwrapLine(line + 2);
 
         // no, no new line added !
         if (newLineAdded) {
             (*newLineAdded) = false;
         }
     }
 
     // remember last change cursor
     m_editLastChangeStartCursor = KTextEditor::Cursor(line, col);
 
     if (notify) {
         Q_EMIT textInsertedRange(this, KTextEditor::Range(line, col, line + 1, 0));
     }
 
     editEnd();
 
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::editUnWrapLine(int line, bool removeLine, int length)
 {
     // verbose debug
     EDIT_DEBUG << "editUnWrapLine" << line << removeLine << length;
 
     if (line < 0 || line >= lines() || line + 1 >= lines() || length < 0) {
         return false;
     }
 
     if (!isReadWrite()) {
         return false;
     }
 
     const Kate::TextLine tl = plainKateTextLine(line);
     const Kate::TextLine nextLine = plainKateTextLine(line + 1);
 
     editStart();
 
     int col = tl.length();
     m_undoManager->slotLineUnWrapped(line, col, length, removeLine, tl, nextLine);
 
     if (removeLine) {
         m_buffer->unwrapLine(line + 1);
     } else {
         m_buffer->wrapLine(KTextEditor::Cursor(line + 1, length));
         m_buffer->unwrapLine(line + 1);
     }
 
     QVarLengthArray<KTextEditor::Mark *, 8> list;
     for (const auto &mark : std::as_const(m_marks)) {
         if (mark->line >= line + 1) {
             list.push_back(mark);
         }
 
         if (mark->line == line + 1) {
             auto m = m_marks.take(line);
             if (m) {
                 mark->type |= m->type;
                 delete m;
             }
         }
     }
 
     for (const auto &mark : list) {
         m_marks.take(mark->line);
     }
 
     for (const auto &mark : list) {
         mark->line--;
         m_marks.insert(mark->line, mark);
     }
 
     if (!list.isEmpty()) {
         Q_EMIT marksChanged(this);
     }
 
     // remember last change cursor
     m_editLastChangeStartCursor = KTextEditor::Cursor(line, col);
 
     Q_EMIT textRemoved(this, KTextEditor::Range(line, col, line + 1, 0), QStringLiteral("\n"));
 
     editEnd();
 
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::editInsertLine(int line, const QString &s, bool notify)
 {
     // verbose debug
     EDIT_DEBUG << "editInsertLine" << line << s;
 
     if (line < 0) {
         return false;
     }
 
     if (!isReadWrite()) {
         return false;
     }
 
     if (line > lines()) {
         return false;
     }
 
     editStart();
 
     m_undoManager->slotLineInserted(line, s);
 
     // wrap line
     if (line > 0) {
         Kate::TextLine previousLine = m_buffer->line(line - 1);
         m_buffer->wrapLine(KTextEditor::Cursor(line - 1, previousLine.text().size()));
     } else {
         m_buffer->wrapLine(KTextEditor::Cursor(0, 0));
     }
 
     // insert text
     m_buffer->insertText(KTextEditor::Cursor(line, 0), s);
 
     QVarLengthArray<KTextEditor::Mark *, 8> list;
     for (const auto &mark : std::as_const(m_marks)) {
         if (mark->line >= line) {
             list.push_back(mark);
         }
     }
 
     for (const auto &mark : list) {
         m_marks.take(mark->line);
     }
 
     for (const auto &mark : list) {
         mark->line++;
         m_marks.insert(mark->line, mark);
     }
 
     if (!list.isEmpty()) {
         Q_EMIT marksChanged(this);
     }
 
     KTextEditor::Range rangeInserted(line, 0, line, m_buffer->lineLength(line));
 
     if (line) {
         int prevLineLength = lineLength(line - 1);
         rangeInserted.setStart(KTextEditor::Cursor(line - 1, prevLineLength));
     } else {
         rangeInserted.setEnd(KTextEditor::Cursor(line + 1, 0));
     }
 
     // remember last change cursor
     m_editLastChangeStartCursor = rangeInserted.start();
 
     if (notify) {
         Q_EMIT textInsertedRange(this, rangeInserted);
     }
 
     editEnd();
 
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::editRemoveLine(int line)
 {
     return editRemoveLines(line, line);
 }
 
 bool KTextEditor::DocumentPrivate::editRemoveLines(int from, int to)
 {
     // verbose debug
     EDIT_DEBUG << "editRemoveLines" << from << to;
 
     if (to < from || from < 0 || to > lastLine()) {
         return false;
     }
 
     if (!isReadWrite()) {
         return false;
     }
 
     if (lines() == 1) {
         return editRemoveText(0, 0, lineLength(0));
     }
 
     editStart();
     QStringList oldText;
 
     // first remove text
     for (int line = to; line >= from; --line) {
         const Kate::TextLine l = plainKateTextLine(line);
         oldText.prepend(l.text());
         m_undoManager->slotLineRemoved(line, l.text(), l);
 
         m_buffer->removeText(KTextEditor::Range(KTextEditor::Cursor(line, 0), KTextEditor::Cursor(line, l.length())));
     }
 
     // then collapse lines
     for (int line = to; line >= from; --line) {
         // unwrap all lines, prefer to unwrap line behind, skip to wrap line 0
         if (line + 1 < m_buffer->lines()) {
             m_buffer->unwrapLine(line + 1);
         } else if (line) {
             m_buffer->unwrapLine(line);
         }
     }
 
     QVarLengthArray<int, 8> rmark;
     QVarLengthArray<KTextEditor::Mark *, 8> list;
 
     for (KTextEditor::Mark *mark : std::as_const(m_marks)) {
         int line = mark->line;
         if (line > to) {
             list << mark;
         } else if (line >= from) {
             rmark << line;
         }
     }
 
     for (int line : rmark) {
         delete m_marks.take(line);
     }
 
     for (auto mark : list) {
         m_marks.take(mark->line);
     }
 
     for (auto mark : list) {
         mark->line -= to - from + 1;
         m_marks.insert(mark->line, mark);
     }
 
     if (!list.isEmpty()) {
         Q_EMIT marksChanged(this);
     }
 
     KTextEditor::Range rangeRemoved(from, 0, to + 1, 0);
 
     if (to == lastLine() + to - from + 1) {
         rangeRemoved.setEnd(KTextEditor::Cursor(to, oldText.last().length()));
         if (from > 0) {
             int prevLineLength = lineLength(from - 1);
             rangeRemoved.setStart(KTextEditor::Cursor(from - 1, prevLineLength));
         }
     }
 
     // remember last change cursor
     m_editLastChangeStartCursor = rangeRemoved.start();
 
     Q_EMIT textRemoved(this, rangeRemoved, oldText.join(QLatin1Char('\n')) + QLatin1Char('\n'));
 
     editEnd();
 
     return true;
 }
 // END
 
 // BEGIN KTextEditor::UndoInterface stuff
 uint KTextEditor::DocumentPrivate::undoCount() const
 {
     return m_undoManager->undoCount();
 }
 
 uint KTextEditor::DocumentPrivate::redoCount() const
 {
     return m_undoManager->redoCount();
 }
 
 void KTextEditor::DocumentPrivate::undo()
 {
     m_undoManager->undo();
 }
 
 void KTextEditor::DocumentPrivate::redo()
 {
     m_undoManager->redo();
 }
 // END
 
 // BEGIN KTextEditor::SearchInterface stuff
 QList<KTextEditor::Range>
 KTextEditor::DocumentPrivate::searchText(KTextEditor::Range range, const QString &pattern, const KTextEditor::SearchOptions options) const
 {
     const bool escapeSequences = options.testFlag(KTextEditor::EscapeSequences);
     const bool regexMode = options.testFlag(KTextEditor::Regex);
     const bool backwards = options.testFlag(KTextEditor::Backwards);
     const bool wholeWords = options.testFlag(KTextEditor::WholeWords);
     const Qt::CaseSensitivity caseSensitivity = options.testFlag(KTextEditor::CaseInsensitive) ? Qt::CaseInsensitive : Qt::CaseSensitive;
 
     if (regexMode) {
         // regexp search
         // escape sequences are supported by definition
         QRegularExpression::PatternOptions patternOptions;
         if (caseSensitivity == Qt::CaseInsensitive) {
             patternOptions |= QRegularExpression::CaseInsensitiveOption;
         }
         KateRegExpSearch searcher(this);
         return searcher.search(pattern, range, backwards, patternOptions);
     }
 
     if (escapeSequences) {
         // escaped search
         KatePlainTextSearch searcher(this, caseSensitivity, wholeWords);
         KTextEditor::Range match = searcher.search(KateRegExpSearch::escapePlaintext(pattern), range, backwards);
 
         QList<KTextEditor::Range> result;
         result.append(match);
         return result;
     }
 
     // plaintext search
     KatePlainTextSearch searcher(this, caseSensitivity, wholeWords);
     KTextEditor::Range match = searcher.search(pattern, range, backwards);
 
     QList<KTextEditor::Range> result;
     result.append(match);
     return result;
 }
 // END
 
 QWidget *KTextEditor::DocumentPrivate::dialogParent()
 {
     QWidget *w = widget();
 
     if (!w) {
         w = activeView();
 
         if (!w) {
             w = QApplication::activeWindow();
         }
     }
 
     return w;
 }
 
 QUrl KTextEditor::DocumentPrivate::getSaveFileUrl(const QString &dialogTitle)
 {
     // per default we use the url of the current document
     QUrl startUrl = url();
     if (startUrl.isValid()) {
         // for remote files we cut the file name to avoid confusion if it is some directory or not, see bug 454648
         if (!startUrl.isLocalFile()) {
             startUrl = startUrl.adjusted(QUrl::RemoveFilename);
         }
     }
 
     // if that is empty, we will try to get the url of the last used view, we assume some properly ordered views() list is around
     else if (auto mainWindow = KTextEditor::Editor::instance()->application()->activeMainWindow(); mainWindow) {
         const auto views = mainWindow->views();
         for (auto view : views) {
             if (view->document()->url().isValid()) {
                 // as we here pick some perhaps unrelated file, always cut the file name
                 startUrl = view->document()->url().adjusted(QUrl::RemoveFilename);
                 break;
             }
         }
     }
 
     // spawn the dialog, dialogParent will take care of proper parent
     return QFileDialog::getSaveFileUrl(dialogParent(), dialogTitle, startUrl);
 }
 
 // BEGIN KTextEditor::HighlightingInterface stuff
 bool KTextEditor::DocumentPrivate::setMode(const QString &name)
 {
     return updateFileType(name);
 }
 
 KSyntaxHighlighting::Theme::TextStyle KTextEditor::DocumentPrivate::defaultStyleAt(KTextEditor::Cursor position) const
 {
     return const_cast<KTextEditor::DocumentPrivate *>(this)->defStyleNum(position.line(), position.column());
 }
 
 QString KTextEditor::DocumentPrivate::mode() const
 {
     return m_fileType;
 }
 
 QStringList KTextEditor::DocumentPrivate::modes() const
 {
     QStringList m;
 
     const QList<KateFileType *> &modeList = KTextEditor::EditorPrivate::self()->modeManager()->list();
     m.reserve(modeList.size());
     for (KateFileType *type : modeList) {
         m << type->name;
     }
 
     return m;
 }
 
 bool KTextEditor::DocumentPrivate::setHighlightingMode(const QString &name)
 {
     int mode = KateHlManager::self()->nameFind(name);
     if (mode == -1) {
         return false;
     }
     m_buffer->setHighlight(mode);
     return true;
 }
 
 QString KTextEditor::DocumentPrivate::highlightingMode() const
 {
     return highlight()->name();
 }
 
 QStringList KTextEditor::DocumentPrivate::highlightingModes() const
 {
     const auto modeList = KateHlManager::self()->modeList();
     QStringList hls;
     hls.reserve(modeList.size());
     for (const auto &hl : modeList) {
         hls << hl.name();
     }
     return hls;
 }
 
 QString KTextEditor::DocumentPrivate::highlightingModeSection(int index) const
 {
     return KateHlManager::self()->modeList().at(index).section();
 }
 
 QString KTextEditor::DocumentPrivate::modeSection(int index) const
 {
     return KTextEditor::EditorPrivate::self()->modeManager()->list().at(index)->section;
 }
 
 void KTextEditor::DocumentPrivate::bufferHlChanged()
 {
     // update all views
     makeAttribs(false);
 
     // deactivate indenter if necessary
     m_indenter->checkRequiredStyle();
 
     Q_EMIT highlightingModeChanged(this);
 }
 
 void KTextEditor::DocumentPrivate::setDontChangeHlOnSave()
 {
     m_hlSetByUser = true;
 }
 
 void KTextEditor::DocumentPrivate::bomSetByUser()
 {
     m_bomSetByUser = true;
 }
 // END
 
 // BEGIN KTextEditor::SessionConfigInterface and KTextEditor::ParameterizedSessionConfigInterface stuff
 void KTextEditor::DocumentPrivate::readSessionConfig(const KConfigGroup &kconfig, const QSet<QString> &flags)
 {
     if (!flags.contains(QStringLiteral("SkipEncoding"))) {
         // get the encoding
         QString tmpenc = kconfig.readEntry("Encoding");
         if (!tmpenc.isEmpty() && (tmpenc != encoding())) {
             setEncoding(tmpenc);
         }
     }
 
     if (!flags.contains(QStringLiteral("SkipUrl"))) {
         // restore the url
         QUrl url(kconfig.readEntry("URL"));
 
         // open the file if url valid
         if (!url.isEmpty() && url.isValid()) {
             openUrl(url);
         } else {
             completed(); // perhaps this should be emitted at the end of this function
         }
     } else {
         completed(); // perhaps this should be emitted at the end of this function
     }
 
     if (!flags.contains(QStringLiteral("SkipMode"))) {
         // restore the filetype
         // NOTE: if the session config file contains an invalid Mode
         // (for example, one that was deleted or renamed), do not apply it
         if (kconfig.hasKey("Mode Set By User")) {
             // restore if set by user, too!
             m_fileTypeSetByUser = true;
             updateFileType(kconfig.readEntry("Mode"));
         }
     }
 
     if (!flags.contains(QStringLiteral("SkipHighlighting"))) {
         // restore the hl stuff
         if (kconfig.hasKey("Highlighting Set By User")) {
             const int mode = KateHlManager::self()->nameFind(kconfig.readEntry("Highlighting"));
             m_hlSetByUser = true;
             if (mode >= 0) {
                 // restore if set by user, too! see bug 332605, otherwise we loose the hl later again on save
                 m_buffer->setHighlight(mode);
             }
         }
     }
 
     // indent mode
     const QString userSetIndentMode = kconfig.readEntry("Indentation Mode");
     if (!userSetIndentMode.isEmpty()) {
         config()->setIndentationMode(userSetIndentMode);
     }
 
     // Restore Bookmarks
     const QList<int> marks = kconfig.readEntry("Bookmarks", QList<int>());
     for (int i = 0; i < marks.count(); i++) {
         addMark(marks.at(i), KTextEditor::DocumentPrivate::markType01);
     }
 }
 
 void KTextEditor::DocumentPrivate::writeSessionConfig(KConfigGroup &kconfig, const QSet<QString> &flags)
 {
     if (this->url().isLocalFile()) {
         const QString path = this->url().toLocalFile();
         if (path.startsWith(QDir::tempPath())) {
             return; // inside tmp resource, do not save
         }
     }
 
     if (!flags.contains(QStringLiteral("SkipUrl"))) {
         // save url
         kconfig.writeEntry("URL", this->url().toString());
     }
 
     // only save encoding if it's something other than utf-8
     if (encoding() != QLatin1String("UTF-8") && !flags.contains(QStringLiteral("SkipEncoding"))) {
         // save encoding
         kconfig.writeEntry("Encoding", encoding());
     }
 
     if (m_fileTypeSetByUser && !flags.contains(QStringLiteral("SkipMode"))) {
         // save file type
         kconfig.writeEntry("Mode", m_fileType);
         // save if set by user, too!
         kconfig.writeEntry("Mode Set By User", m_fileTypeSetByUser);
     }
 
     if (m_hlSetByUser && !flags.contains(QStringLiteral("SkipHighlighting"))) {
         // save hl
         kconfig.writeEntry("Highlighting", highlight()->name());
 
         // save if set by user, too! see bug 332605, otherwise we loose the hl later again on save
         kconfig.writeEntry("Highlighting Set By User", m_hlSetByUser);
     }
 
     // indent mode
     if (m_indenterSetByUser) {
         kconfig.writeEntry("Indentation Mode", config()->indentationMode());
     }
 
     // Save Bookmarks
     QList<int> marks;
     for (const auto &mark : std::as_const(m_marks)) {
         if (mark->type & KTextEditor::Document::markType01) {
             marks.push_back(mark->line);
         }
     }
 
     if (!marks.isEmpty()) {
         kconfig.writeEntry("Bookmarks", marks);
     }
 }
 
 // END KTextEditor::SessionConfigInterface and KTextEditor::ParameterizedSessionConfigInterface stuff
 
 uint KTextEditor::DocumentPrivate::mark(int line)
 {
     KTextEditor::Mark *m = m_marks.value(line);
     if (!m) {
         return 0;
     }
 
     return m->type;
 }
 
 void KTextEditor::DocumentPrivate::setMark(int line, uint markType)
 {
     clearMark(line);
     addMark(line, markType);
 }
 
 void KTextEditor::DocumentPrivate::clearMark(int line)
 {
     if (line < 0 || line > lastLine()) {
         return;
     }
 
     if (auto mark = m_marks.take(line)) {
         Q_EMIT markChanged(this, *mark, MarkRemoved);
         Q_EMIT marksChanged(this);
         delete mark;
         tagLine(line);
         repaintViews(true);
     }
 }
 
 void KTextEditor::DocumentPrivate::addMark(int line, uint markType)
 {
     KTextEditor::Mark *mark;
 
     if (line < 0 || line > lastLine()) {
         return;
     }
 
     if (markType == 0) {
         return;
     }
 
     if ((mark = m_marks.value(line))) {
         // Remove bits already set
         markType &= ~mark->type;
 
         if (markType == 0) {
             return;
         }
 
         // Add bits
         mark->type |= markType;
     } else {
         mark = new KTextEditor::Mark;
         mark->line = line;
         mark->type = markType;
         m_marks.insert(line, mark);
     }
 
     // Emit with a mark having only the types added.
     KTextEditor::Mark temp;
     temp.line = line;
     temp.type = markType;
     Q_EMIT markChanged(this, temp, MarkAdded);
 
     Q_EMIT marksChanged(this);
     tagLine(line);
     repaintViews(true);
 }
 
 void KTextEditor::DocumentPrivate::removeMark(int line, uint markType)
 {
     if (line < 0 || line > lastLine()) {
         return;
     }
 
     auto it = m_marks.find(line);
     if (it == m_marks.end()) {
         return;
     }
     KTextEditor::Mark *mark = it.value();
 
     // Remove bits not set
     markType &= mark->type;
 
     if (markType == 0) {
         return;
     }
 
     // Subtract bits
     mark->type &= ~markType;
 
     // Emit with a mark having only the types removed.
     KTextEditor::Mark temp;
     temp.line = line;
     temp.type = markType;
     Q_EMIT markChanged(this, temp, MarkRemoved);
 
     if (mark->type == 0) {
         m_marks.erase(it);
         delete mark;
     }
 
     Q_EMIT marksChanged(this);
     tagLine(line);
     repaintViews(true);
 }
 
 const QHash<int, KTextEditor::Mark *> &KTextEditor::DocumentPrivate::marks()
 {
     return m_marks;
 }
 
 void KTextEditor::DocumentPrivate::requestMarkTooltip(int line, QPoint position)
 {
     KTextEditor::Mark *mark = m_marks.value(line);
     if (!mark) {
         return;
     }
 
     bool handled = false;
     Q_EMIT markToolTipRequested(this, *mark, position, handled);
 }
 
 bool KTextEditor::DocumentPrivate::handleMarkClick(int line)
 {
     bool handled = false;
     KTextEditor::Mark *mark = m_marks.value(line);
     if (!mark) {
         Q_EMIT markClicked(this, KTextEditor::Mark{line, 0}, handled);
     } else {
         Q_EMIT markClicked(this, *mark, handled);
     }
 
     return handled;
 }
 
 bool KTextEditor::DocumentPrivate::handleMarkContextMenu(int line, QPoint position)
 {
     bool handled = false;
     KTextEditor::Mark *mark = m_marks.value(line);
     if (!mark) {
         Q_EMIT markContextMenuRequested(this, KTextEditor::Mark{line, 0}, position, handled);
     } else {
         Q_EMIT markContextMenuRequested(this, *mark, position, handled);
     }
 
     return handled;
 }
 
 void KTextEditor::DocumentPrivate::clearMarks()
 {
     /**
      * work on a copy as deletions below might trigger the use
      * of m_marks
      */
     const QHash<int, KTextEditor::Mark *> marksCopy = m_marks;
     m_marks.clear();
 
     for (const auto &m : marksCopy) {
         Q_EMIT markChanged(this, *m, MarkRemoved);
         tagLine(m->line);
         delete m;
     }
 
     Q_EMIT marksChanged(this);
     repaintViews(true);
 }
 
 void KTextEditor::DocumentPrivate::setMarkDescription(Document::MarkTypes type, const QString &description)
 {
     m_markDescriptions.insert(type, description);
 }
 
 QColor KTextEditor::DocumentPrivate::markColor(Document::MarkTypes type) const
 {
     uint reserved = (1U << KTextEditor::Document::reservedMarkersCount()) - 1;
     if ((uint)type >= (uint)markType01 && (uint)type <= reserved) {
         return KateRendererConfig::global()->lineMarkerColor(type);
     } else {
         return QColor();
     }
 }
 
 QString KTextEditor::DocumentPrivate::markDescription(Document::MarkTypes type) const
 {
     return m_markDescriptions.value(type, QString());
 }
 
 void KTextEditor::DocumentPrivate::setEditableMarks(uint markMask)
 {
     m_editableMarks = markMask;
 }
 
 uint KTextEditor::DocumentPrivate::editableMarks() const
 {
     return m_editableMarks;
 }
 // END
 
 void KTextEditor::DocumentPrivate::setMarkIcon(Document::MarkTypes markType, const QIcon &icon)
 {
     m_markIcons.insert(markType, icon);
 }
 
 QIcon KTextEditor::DocumentPrivate::markIcon(Document::MarkTypes markType) const
 {
     return m_markIcons.value(markType, QIcon());
 }
 
 // BEGIN KTextEditor::PrintInterface stuff
 bool KTextEditor::DocumentPrivate::print()
 {
     return KatePrinter::print(this);
 }
 
 void KTextEditor::DocumentPrivate::printPreview()
 {
     KatePrinter::printPreview(this);
 }
 // END KTextEditor::PrintInterface stuff
 
 // BEGIN KTextEditor::DocumentInfoInterface (### unfinished)
 QString KTextEditor::DocumentPrivate::mimeType()
 {
     if (!m_modOnHd && url().isLocalFile()) {
         // for unmodified files that reside directly on disk, we don't need to
         // create a temporary buffer - we can just look at the file directly
         return QMimeDatabase().mimeTypeForFile(url().toLocalFile()).name();
     }
     // collect first 4k of text
     // only heuristic
     QByteArray buf;
     for (int i = 0; (i < lines()) && (buf.size() <= 4096); ++i) {
         buf.append(line(i).toUtf8());
         buf.append('\n');
     }
 
     // use path of url, too, if set
     if (!url().path().isEmpty()) {
         return QMimeDatabase().mimeTypeForFileNameAndData(url().path(), buf).name();
     }
 
     // else only use the content
     return QMimeDatabase().mimeTypeForData(buf).name();
 }
 // END KTextEditor::DocumentInfoInterface
 
 // BEGIN: error
 void KTextEditor::DocumentPrivate::showAndSetOpeningErrorAccess()
 {
     QPointer<KTextEditor::Message> message = new KTextEditor::Message(
         i18n("The file %1 could not be loaded, as it was not possible to read from it.<br />Check if you have read access to this file.",
              this->url().toDisplayString(QUrl::PreferLocalFile)),
         KTextEditor::Message::Error);
     message->setWordWrap(true);
     QAction *tryAgainAction = new QAction(QIcon::fromTheme(QStringLiteral("view-refresh")),
                                           i18nc("translators: you can also translate 'Try Again' with 'Reload'", "Try Again"),
                                           nullptr);
     connect(tryAgainAction, &QAction::triggered, this, &KTextEditor::DocumentPrivate::documentReload, Qt::QueuedConnection);
 
     QAction *closeAction = new QAction(QIcon::fromTheme(QStringLiteral("window-close")), i18n("&Close"), nullptr);
     closeAction->setToolTip(i18nc("Close the message being displayed", "Close message"));
 
     // add try again and close actions
     message->addAction(tryAgainAction);
     message->addAction(closeAction);
 
     // finally post message
     postMessage(message);
 
     // remember error
     m_openingError = true;
 }
 // END: error
 
 void KTextEditor::DocumentPrivate::openWithLineLengthLimitOverride()
 {
     // raise line length limit to the next power of 2
     const int longestLine = m_buffer->longestLineLoaded();
     int newLimit = pow(2, ceil(log2(longestLine)));
     if (newLimit <= longestLine) {
         newLimit *= 2;
     }
 
     // do the raise
     config()->setLineLengthLimit(newLimit);
 
     // just reload
     m_buffer->clear();
     openFile();
     if (!m_openingError) {
         setReadWrite(true);
         m_readWriteStateBeforeLoading = true;
     }
 }
 
 int KTextEditor::DocumentPrivate::lineLengthLimit() const
 {
     return config()->lineLengthLimit();
 }
 
 // BEGIN KParts::ReadWrite stuff
 bool KTextEditor::DocumentPrivate::openFile()
 {
     // we are about to invalidate all cursors/ranges/.. => m_buffer->openFile will do so
     Q_EMIT aboutToInvalidateMovingInterfaceContent(this);
 
     // no open errors until now...
     m_openingError = false;
 
     // add new m_file to dirwatch
     activateDirWatch();
 
     // remember current encoding
     QString currentEncoding = encoding();
 
     //
     // mime type magic to get encoding right
     //
     QString mimeType = arguments().mimeType();
     int pos = mimeType.indexOf(QLatin1Char(';'));
     if (pos != -1 && !(m_reloading && m_userSetEncodingForNextReload)) {
         setEncoding(mimeType.mid(pos + 1));
     }
 
     // update file type, we do this here PRE-LOAD, therefore pass file name for reading from
     updateFileType(KTextEditor::EditorPrivate::self()->modeManager()->fileType(this, localFilePath()));
 
     // read dir config (if possible and wanted)
     // do this PRE-LOAD to get encoding info!
     readDirConfig();
 
     // perhaps we need to re-set again the user encoding
     if (m_reloading && m_userSetEncodingForNextReload && (currentEncoding != encoding())) {
         setEncoding(currentEncoding);
     }
 
     bool success = m_buffer->openFile(localFilePath(), (m_reloading && m_userSetEncodingForNextReload));
 
     //
     // yeah, success
     // read variables
     //
     if (success) {
         readVariables();
     }
 
     //
     // update views
     //
     for (auto view : std::as_const(m_views)) {
         // This is needed here because inserting the text moves the view's start position (it is a MovingCursor)
         view->setCursorPosition(KTextEditor::Cursor());
         static_cast<ViewPrivate *>(view)->updateView(true);
     }
 
     // Inform that the text has changed (required as we're not inside the usual editStart/End stuff)
     Q_EMIT textChanged(this);
     Q_EMIT loaded(this);
 
     //
     // to houston, we are not modified
     //
     if (m_modOnHd) {
         m_modOnHd = false;
         m_modOnHdReason = OnDiskUnmodified;
         m_prevModOnHdReason = OnDiskUnmodified;
         Q_EMIT modifiedOnDisk(this, m_modOnHd, m_modOnHdReason);
     }
 
     // Now that we have some text, try to auto detect indent if enabled
     // skip this if for this document already settings were done, either by the user or .e.g. modelines/.kateconfig files.
     if (!isEmpty() && config()->autoDetectIndent() && !config()->isSet(KateDocumentConfig::IndentationWidth)
         && !config()->isSet(KateDocumentConfig::ReplaceTabsWithSpaces)) {
         KateIndentDetecter detecter(this);
         auto result = detecter.detect(config()->indentationWidth(), config()->replaceTabsDyn());
         config()->setIndentationWidth(result.indentWidth);
         config()->setReplaceTabsDyn(result.indentUsingSpaces);
     }
 
     //
     // display errors
     //
     if (!success) {
         showAndSetOpeningErrorAccess();
     }
 
     // warn: broken encoding
     if (m_buffer->brokenEncoding()) {
         // this file can't be saved again without killing it
         setReadWrite(false);
         m_readWriteStateBeforeLoading = false;
         QPointer<KTextEditor::Message> message = new KTextEditor::Message(
             i18n("The file %1 was opened with %2 encoding but contained invalid characters.<br />"
                  "It is set to read-only mode, as saving might destroy its content.<br />"
                  "Either reopen the file with the correct encoding chosen or enable the read-write mode again in the tools menu to be able to edit it.",
                  this->url().toDisplayString(QUrl::PreferLocalFile),
                  m_buffer->textCodec()),
             KTextEditor::Message::Warning);
         message->setWordWrap(true);
         postMessage(message);
 
         // remember error
         m_openingError = true;
     }
 
     // warn: too long lines
     if (m_buffer->tooLongLinesWrapped()) {
         // this file can't be saved again without modifications
         setReadWrite(false);
         m_readWriteStateBeforeLoading = false;
         QPointer<KTextEditor::Message> message =
             new KTextEditor::Message(i18n("The file %1 was opened and contained lines longer than the configured Line Length Limit (%2 characters).<br />"
                                           "The longest of those lines was %3 characters long<br/>"
                                           "Those lines were wrapped and the document is set to read-only mode, as saving will modify its content.",
                                           this->url().toDisplayString(QUrl::PreferLocalFile),
                                           config()->lineLengthLimit(),
                                           m_buffer->longestLineLoaded()),
                                      KTextEditor::Message::Warning);
         QAction *increaseAndReload = new QAction(i18n("Temporarily raise limit and reload file"), message);
         connect(increaseAndReload, &QAction::triggered, this, &KTextEditor::DocumentPrivate::openWithLineLengthLimitOverride);
         message->addAction(increaseAndReload, true);
         message->addAction(new QAction(i18n("Close"), message), true);
         message->setWordWrap(true);
         postMessage(message);
 
         // remember error
         m_openingError = true;
     }
 
     //
     // return the success
     //
     return success;
 }
 
 bool KTextEditor::DocumentPrivate::saveFile()
 {
     // delete pending mod-on-hd message if applicable.
     delete m_modOnHdHandler;
 
     // some warnings, if file was changed by the outside!
     if (!url().isEmpty()) {
         if (m_fileChangedDialogsActivated && m_modOnHd) {
             QString str = reasonedMOHString() + QLatin1String("\n\n");
 
             if (!isModified()) {
                 if (KMessageBox::warningContinueCancel(
                         dialogParent(),
                         str + i18n("Do you really want to save this unmodified file? You could overwrite changed data in the file on disk."),
                         i18n("Trying to Save Unmodified File"),
                         KGuiItem(i18n("Save Nevertheless")))
                     != KMessageBox::Continue) {
                     return false;
                 }
             } else {
                 if (KMessageBox::warningContinueCancel(
                         dialogParent(),
                         str
                             + i18n(
                                 "Do you really want to save this file? Both your open file and the file on disk were changed. There could be some data lost."),
                         i18n("Possible Data Loss"),
                         KGuiItem(i18n("Save Nevertheless")))
                     != KMessageBox::Continue) {
                     return false;
                 }
             }
         }
     }
 
     //
     // can we encode it if we want to save it ?
     //
     if (!m_buffer->canEncode()
         && (KMessageBox::warningContinueCancel(dialogParent(),
                                                i18n("The selected encoding cannot encode every Unicode character in this document. Do you really want to save "
                                                     "it? There could be some data lost."),
                                                i18n("Possible Data Loss"),
                                                KGuiItem(i18n("Save Nevertheless")))
             != KMessageBox::Continue)) {
         return false;
     }
 
     // create a backup file or abort if that fails!
     // if no backup file wanted, this routine will just return true
     if (!createBackupFile()) {
         return false;
     }
 
     // update file type, pass no file path, read file type content from this document
     QString oldPath = m_dirWatchFile;
 
     // only update file type if path has changed so that variables are not overridden on normal save
     if (oldPath != localFilePath()) {
         updateFileType(KTextEditor::EditorPrivate::self()->modeManager()->fileType(this, QString()));
 
         if (url().isLocalFile()) {
             // if file is local then read dir config for new path
             readDirConfig();
         }
     }
 
     // read our vars
     const bool variablesWereRead = readVariables();
 
     // If variables were read, that means we must have updated view and render config
     // which would update the full view and we don't need to do any repainting. Otherwise
     // loop over all views and update the views if the view has modified lines in the visible
     // range, this should mark the line 'green' in the icon border
     if (!variablesWereRead) {
         for (auto *view : std::as_const(m_views)) {
             auto v = static_cast<ViewPrivate *>(view);
             if (v->isVisible()) {
                 const auto range = v->visibleRange();
 
                 bool repaint = false;
                 for (int i = range.start().line(); i <= range.end().line(); ++i) {
                     if (isLineModified(i)) {
                         repaint = true;
                         v->tagLine({i, 0});
                     }
                 }
 
                 if (repaint) {
                     v->updateView(true);
                 }
             }
         }
     }
 
     // remove file from dirwatch
     deactivateDirWatch();
 
     // remove all trailing spaces in the document and potential add a new line (as edit actions)
     // NOTE: we need this as edit actions, since otherwise the edit actions
     //       in the swap file recovery may happen at invalid cursor positions
     removeTrailingSpacesAndAddNewLineAtEof();
 
     //
     // try to save
     //
     if (!m_buffer->saveFile(localFilePath())) {
         // add m_file again to dirwatch
         activateDirWatch(oldPath);
         KMessageBox::error(dialogParent(),
                            i18n("The document could not be saved, as it was not possible to write to %1.\nCheck that you have write access to this file or "
                                 "that enough disk space is available.\nThe original file may be lost or damaged. "
                                 "Don't quit the application until the file is successfully written.",
                                 this->url().toDisplayString(QUrl::PreferLocalFile)));
         return false;
     }
 
     // update the checksum
     createDigest();
 
     // add m_file again to dirwatch
     activateDirWatch();
 
     //
     // we are not modified
     //
     if (m_modOnHd) {
         m_modOnHd = false;
         m_modOnHdReason = OnDiskUnmodified;
         m_prevModOnHdReason = OnDiskUnmodified;
         Q_EMIT modifiedOnDisk(this, m_modOnHd, m_modOnHdReason);
     }
 
     // (dominik) mark last undo group as not mergeable, otherwise the next
     // edit action might be merged and undo will never stop at the saved state
     m_undoManager->undoSafePoint();
     m_undoManager->updateLineModifications();
 
     //
     // return success
     //
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::createBackupFile()
 {
     // backup for local or remote files wanted?
     const bool backupLocalFiles = config()->backupOnSaveLocal();
     const bool backupRemoteFiles = config()->backupOnSaveRemote();
 
     // early out, before mount check: backup wanted at all?
     // => if not, all fine, just return
     if (!backupLocalFiles && !backupRemoteFiles) {
         return true;
     }
 
     // decide if we need backup based on locality
     // skip that, if we always want backups, as currentMountPoints is not that fast
     QUrl u(url());
     bool needBackup = backupLocalFiles && backupRemoteFiles;
     if (!needBackup) {
         bool slowOrRemoteFile = !u.isLocalFile();
         if (!slowOrRemoteFile) {
             // could be a mounted remote filesystem (e.g. nfs, sshfs, cifs)
             // we have the early out above to skip this, if we want no backup, which is the default
             KMountPoint::Ptr mountPoint = KMountPoint::currentMountPoints().findByDevice(u.toLocalFile());
             slowOrRemoteFile = (mountPoint && mountPoint->probablySlow());
         }
         needBackup = (!slowOrRemoteFile && backupLocalFiles) || (slowOrRemoteFile && backupRemoteFiles);
     }
 
     // no backup needed? be done
     if (!needBackup) {
         return true;
     }
 
     // else: try to backup
     const auto backupPrefix = KTextEditor::EditorPrivate::self()->variableExpansionManager()->expandText(config()->backupPrefix(), nullptr);
     const auto backupSuffix = KTextEditor::EditorPrivate::self()->variableExpansionManager()->expandText(config()->backupSuffix(), nullptr);
     if (backupPrefix.isEmpty() && backupSuffix.isEmpty()) {
         // no sane backup possible
         return true;
     }
 
     if (backupPrefix.contains(QDir::separator())) {
         // replace complete path, as prefix is a path!
         u.setPath(backupPrefix + u.fileName() + backupSuffix);
     } else {
         // replace filename in url
         const QString fileName = u.fileName();
         u = u.adjusted(QUrl::RemoveFilename);
         u.setPath(u.path() + backupPrefix + fileName + backupSuffix);
     }
 
     qCDebug(LOG_KTE) << "backup src file name: " << url();
     qCDebug(LOG_KTE) << "backup dst file name: " << u;
 
     // handle the backup...
     bool backupSuccess = false;
 
     // local file mode, no kio
     if (u.isLocalFile()) {
         if (QFile::exists(url().toLocalFile())) {
             // first: check if backupFile is already there, if true, unlink it
             QFile backupFile(u.toLocalFile());
             if (backupFile.exists()) {
                 backupFile.remove();
             }
 
             backupSuccess = QFile::copy(url().toLocalFile(), u.toLocalFile());
         } else {
             backupSuccess = true;
         }
     } else { // remote file mode, kio
         // get the right permissions, start with safe default
         KIO::StatJob *statJob = KIO::stat(url(), KIO::StatJob::SourceSide, KIO::StatBasic);
         KJobWidgets::setWindow(statJob, QApplication::activeWindow());
         if (statJob->exec()) {
             // do a evil copy which will overwrite target if possible
             KFileItem item(statJob->statResult(), url());
             KIO::FileCopyJob *job = KIO::file_copy(url(), u, item.permissions(), KIO::Overwrite);
             KJobWidgets::setWindow(job, QApplication::activeWindow());
             backupSuccess = job->exec();
         } else {
             backupSuccess = true;
         }
     }
 
     // backup has failed, ask user how to proceed
     if (!backupSuccess
         && (KMessageBox::warningContinueCancel(dialogParent(),
                                                i18n("For file %1 no backup copy could be created before saving."
                                                     " If an error occurs while saving, you might lose the data of this file."
                                                     " A reason could be that the media you write to is full or the directory of the file is read-only for you.",
                                                     url().toDisplayString(QUrl::PreferLocalFile)),
                                                i18n("Failed to create backup copy."),
                                                KGuiItem(i18n("Try to Save Nevertheless")),
                                                KStandardGuiItem::cancel(),
                                                QStringLiteral("Backup Failed Warning"))
             != KMessageBox::Continue)) {
         return false;
     }
 
     return true;
 }
 
 void KTextEditor::DocumentPrivate::readDirConfig()
 {
     if (!url().isLocalFile() || KNetworkMounts::self()->isOptionEnabledForPath(url().toLocalFile(), KNetworkMounts::MediumSideEffectsOptimizations)) {
         return;
     }
 
     // first search .kateconfig upwards
     // with recursion guard
     QSet<QString> seenDirectories;
     QDir dir(QFileInfo(localFilePath()).absolutePath());
     while (!seenDirectories.contains(dir.absolutePath())) {
         // fill recursion guard
         seenDirectories.insert(dir.absolutePath());
 
         // try to open config file in this dir
         QFile f(dir.absolutePath() + QLatin1String("/.kateconfig"));
         if (f.open(QIODevice::ReadOnly)) {
             QTextStream stream(&f);
 
             uint linesRead = 0;
             QString line = stream.readLine();
             while ((linesRead < 32) && !line.isNull()) {
                 readVariableLine(line);
 
                 line = stream.readLine();
 
                 linesRead++;
             }
 
             return;
         }
 
         // else: cd up, if possible or abort
         if (!dir.cdUp()) {
             break;
         }
     }
 
 #if EDITORCONFIG_FOUND
     // if there wasn’t any .kateconfig file and KTextEditor was compiled with
     // EditorConfig support, try to load document config from a .editorconfig
     // file, if such is provided
     EditorConfig editorConfig(this);
     editorConfig.parse();
 #endif
 }
 
 void KTextEditor::DocumentPrivate::activateDirWatch(const QString &useFileName)
 {
     QString fileToUse = useFileName;
     if (fileToUse.isEmpty()) {
         fileToUse = localFilePath();
     }
 
     if (KNetworkMounts::self()->isOptionEnabledForPath(fileToUse, KNetworkMounts::KDirWatchDontAddWatches)) {
         return;
     }
 
     QFileInfo fileInfo = QFileInfo(fileToUse);
     if (fileInfo.isSymLink()) {
         // Monitor the actual data and not the symlink
         fileToUse = fileInfo.canonicalFilePath();
     }
 
     // same file as we are monitoring, return
     if (fileToUse == m_dirWatchFile) {
         return;
     }
 
     // remove the old watched file
     deactivateDirWatch();
 
     // add new file if needed
     if (url().isLocalFile() && !fileToUse.isEmpty()) {
         KTextEditor::EditorPrivate::self()->dirWatch()->addFile(fileToUse);
         m_dirWatchFile = fileToUse;
     }
 }
 
 void KTextEditor::DocumentPrivate::deactivateDirWatch()
 {
     if (!m_dirWatchFile.isEmpty()) {
         KTextEditor::EditorPrivate::self()->dirWatch()->removeFile(m_dirWatchFile);
     }
 
     m_dirWatchFile.clear();
 }
 
 bool KTextEditor::DocumentPrivate::openUrl(const QUrl &url)
 {
     if (!m_reloading) {
         // Reset filetype when opening url
         m_fileTypeSetByUser = false;
     }
     bool res = KTextEditor::Document::openUrl(url);
     updateDocName();
     return res;
 }
 
 bool KTextEditor::DocumentPrivate::closeUrl()
 {
     //
     // file mod on hd
     //
     if (!m_reloading && !url().isEmpty()) {
         if (m_fileChangedDialogsActivated && m_modOnHd) {
             // make sure to not forget pending mod-on-hd handler
             delete m_modOnHdHandler;
 
             QWidget *parentWidget(dialogParent());
             if (!(KMessageBox::warningContinueCancel(parentWidget,
                                                      reasonedMOHString() + QLatin1String("\n\n")
                                                          + i18n("Do you really want to continue to close this file? Data loss may occur."),
                                                      i18n("Possible Data Loss"),
                                                      KGuiItem(i18n("Close Nevertheless")),
                                                      KStandardGuiItem::cancel(),
                                                      QStringLiteral("kate_close_modonhd_%1").arg(m_modOnHdReason))
                   == KMessageBox::Continue)) {
                 // reset reloading
                 m_reloading = false;
                 return false;
             }
         }
     }
 
     //
     // first call the normal kparts implementation
     //
     if (!KParts::ReadWritePart::closeUrl()) {
         // reset reloading
         m_reloading = false;
         return false;
     }
 
     // Tell the world that we're about to go ahead with the close
     if (!m_reloading) {
         Q_EMIT aboutToClose(this);
     }
 
     // delete all KTE::Messages
     if (!m_messageHash.isEmpty()) {
         const auto keys = m_messageHash.keys();
         for (KTextEditor::Message *message : keys) {
             delete message;
         }
     }
 
     // we are about to invalidate all cursors/ranges/.. => m_buffer->clear will do so
     Q_EMIT aboutToInvalidateMovingInterfaceContent(this);
 
     // remove file from dirwatch
     deactivateDirWatch();
 
     //
     // empty url + fileName
     //
     setUrl(QUrl());
     setLocalFilePath(QString());
 
     // we are not modified
     if (m_modOnHd) {
         m_modOnHd = false;
         m_modOnHdReason = OnDiskUnmodified;
         m_prevModOnHdReason = OnDiskUnmodified;
         Q_EMIT modifiedOnDisk(this, m_modOnHd, m_modOnHdReason);
     }
 
     // remove all marks
     clearMarks();
 
     // clear the buffer
     m_buffer->clear();
 
     // clear undo/redo history
     m_undoManager->clearUndo();
     m_undoManager->clearRedo();
 
     // no, we are no longer modified
     setModified(false);
 
     // we have no longer any hl
     m_buffer->setHighlight(0);
 
     // update all our views
     for (auto view : std::as_const(m_views)) {
         static_cast<ViewPrivate *>(view)->clearSelection(); // fix bug #118588
         static_cast<ViewPrivate *>(view)->clear();
     }
 
     // purge swap file
     if (m_swapfile) {
         m_swapfile->fileClosed();
     }
 
     // success
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::isDataRecoveryAvailable() const
 {
     return m_swapfile && m_swapfile->shouldRecover();
 }
 
 void KTextEditor::DocumentPrivate::recoverData()
 {
     if (isDataRecoveryAvailable()) {
         m_swapfile->recover();
     }
 }
 
 void KTextEditor::DocumentPrivate::discardDataRecovery()
 {
     if (isDataRecoveryAvailable()) {
         m_swapfile->discard();
     }
 }
 
 void KTextEditor::DocumentPrivate::setReadWrite(bool rw)
 {
     if (isReadWrite() == rw) {
         return;
     }
 
     KParts::ReadWritePart::setReadWrite(rw);
 
     for (auto v : std::as_const(m_views)) {
         auto view = static_cast<ViewPrivate *>(v);
         view->slotUpdateUndo();
         view->slotReadWriteChanged();
     }
 
     Q_EMIT readWriteChanged(this);
 }
 
 void KTextEditor::DocumentPrivate::setModified(bool m)
 {
     if (isModified() != m) {
         KParts::ReadWritePart::setModified(m);
 
         for (auto view : std::as_const(m_views)) {
             static_cast<ViewPrivate *>(view)->slotUpdateUndo();
         }
 
         Q_EMIT modifiedChanged(this);
     }
 
     m_undoManager->setModified(m);
 }
 // END
 
 // BEGIN Kate specific stuff ;)
 
 void KTextEditor::DocumentPrivate::makeAttribs(bool needInvalidate)
 {
     for (auto view : std::as_const(m_views)) {
         static_cast<ViewPrivate *>(view)->renderer()->updateAttributes();
     }
 
     if (needInvalidate) {
         m_buffer->invalidateHighlighting();
     }
 
     for (auto v : std::as_const(m_views)) {
         auto view = static_cast<ViewPrivate *>(v);
         view->tagAll();
         view->updateView(true);
     }
 }
 
 // the attributes of a hl have changed, update
 void KTextEditor::DocumentPrivate::internalHlChanged()
 {
     makeAttribs();
 }
 
 void KTextEditor::DocumentPrivate::addView(KTextEditor::View *view)
 {
     Q_ASSERT(!m_views.contains(view));
     m_views.append(view);
 
     // apply the view & renderer vars from the file type
     if (!m_fileType.isEmpty()) {
         readVariableLine(KTextEditor::EditorPrivate::self()->modeManager()->fileType(m_fileType).varLine, true);
     }
 
     // apply the view & renderer vars from the file
     readVariables(true);
 
     setActiveView(view);
 }
 
 void KTextEditor::DocumentPrivate::removeView(KTextEditor::View *view)
 {
     Q_ASSERT(m_views.contains(view));
     m_views.removeAll(view);
 
     if (activeView() == view) {
         setActiveView(nullptr);
     }
 }
 
 void KTextEditor::DocumentPrivate::setActiveView(KTextEditor::View *view)
 {
     if (m_activeView == view) {
         return;
     }
 
     m_activeView = static_cast<KTextEditor::ViewPrivate *>(view);
 }
 
 bool KTextEditor::DocumentPrivate::ownedView(KTextEditor::ViewPrivate *view)
 {
     // do we own the given view?
     return (m_views.contains(view));
 }
 
 int KTextEditor::DocumentPrivate::toVirtualColumn(int line, int column) const
 {
     Kate::TextLine textLine = m_buffer->plainLine(line);
     return textLine.toVirtualColumn(column, config()->tabWidth());
 }
 
 int KTextEditor::DocumentPrivate::toVirtualColumn(const KTextEditor::Cursor cursor) const
 {
     return toVirtualColumn(cursor.line(), cursor.column());
 }
 
 int KTextEditor::DocumentPrivate::fromVirtualColumn(int line, int column) const
 {
     Kate::TextLine textLine = m_buffer->plainLine(line);
     return textLine.fromVirtualColumn(column, config()->tabWidth());
 }
 
 int KTextEditor::DocumentPrivate::fromVirtualColumn(const KTextEditor::Cursor cursor) const
 {
     return fromVirtualColumn(cursor.line(), cursor.column());
 }
 
 bool KTextEditor::DocumentPrivate::skipAutoBrace(QChar closingBracket, KTextEditor::Cursor pos)
 {
     // auto bracket handling for newly inserted text
     // we inserted a bracket?
     // => add the matching closing one to the view + input chars
     // try to preserve the cursor position
     bool skipAutobrace = closingBracket == QLatin1Char('\'');
     if (highlight() && skipAutobrace) {
         // skip adding ' in spellchecked areas, because those are text
         skipAutobrace = highlight()->spellCheckingRequiredForLocation(this, pos - Cursor{0, 1});
     }
 
     if (!skipAutobrace && (closingBracket == QLatin1Char('\''))) {
         // skip auto quotes when these looks already balanced, bug 405089
         Kate::TextLine textLine = m_buffer->plainLine(pos.line());
         // RegEx match quote, but not escaped quote, thanks to https://stackoverflow.com/a/11819111
         static const QRegularExpression re(QStringLiteral("(?<!\\\\)(?:\\\\\\\\)*\\\'"));
         const int count = textLine.text().left(pos.column()).count(re);
         skipAutobrace = (count % 2 == 0) ? true : false;
     }
     if (!skipAutobrace && (closingBracket == QLatin1Char('\"'))) {
         // ...same trick for double quotes
         Kate::TextLine textLine = m_buffer->plainLine(pos.line());
         static const QRegularExpression re(QStringLiteral("(?<!\\\\)(?:\\\\\\\\)*\\\""));
         const int count = textLine.text().left(pos.column()).count(re);
         skipAutobrace = (count % 2 == 0) ? true : false;
     }
     return skipAutobrace;
 }
 
 void KTextEditor::DocumentPrivate::typeChars(KTextEditor::ViewPrivate *view, QString chars)
 {
     // nop for empty chars
     if (chars.isEmpty()) {
         return;
     }
 
     // auto bracket handling
     QChar closingBracket;
     if (view->config()->autoBrackets()) {
         // Check if entered closing bracket is already balanced
         const QChar typedChar = chars.at(0);
         const QChar openBracket = matchingStartBracket(typedChar);
         if (!openBracket.isNull()) {
             KTextEditor::Cursor curPos = view->cursorPosition();
             if ((characterAt(curPos) == typedChar) && findMatchingBracket(curPos, 123 /*Which value may best?*/).isValid()) {
                 // Do nothing
                 view->cursorRight();
                 return;
             }
         }
 
         // for newly inserted text: remember if we should auto add some bracket
         if (chars.size() == 1) {
             // we inserted a bracket? => remember the matching closing one
             closingBracket = matchingEndBracket(typedChar);
 
             // closing bracket for the autobracket we inserted earlier?
             if (m_currentAutobraceClosingChar == typedChar && m_currentAutobraceRange) {
                 // do nothing
                 m_currentAutobraceRange.reset(nullptr);
                 view->cursorRight();
                 return;
             }
         }
     }
 
     // Treat some char also as "auto bracket" only when we have a selection
     if (view->selection() && closingBracket.isNull() && view->config()->encloseSelectionInChars()) {
         const QChar typedChar = chars.at(0);
         if (view->config()->charsToEncloseSelection().contains(typedChar)) {
             // The unconditional mirroring cause no harm, but allows funny brackets
             closingBracket = typedChar.mirroredChar();
         }
     }
 
     editStart();
 
     // special handling if we want to add auto brackets to a selection
     if (view->selection() && !closingBracket.isNull()) {
         std::unique_ptr<KTextEditor::MovingRange> selectionRange(newMovingRange(view->selectionRange()));
         const int startLine = qMax(0, selectionRange->start().line());
         const int endLine = qMin(selectionRange->end().line(), lastLine());
         const bool blockMode = view->blockSelection() && (startLine != endLine);
         if (blockMode) {
             if (selectionRange->start().column() > selectionRange->end().column()) {
                 // Selection was done from right->left, requires special setting to ensure the new
                 // added brackets will not be part of the selection
                 selectionRange->setInsertBehaviors(MovingRange::ExpandLeft | MovingRange::ExpandRight);
             }
             // Add brackets to each line of the block
             const int startColumn = qMin(selectionRange->start().column(), selectionRange->end().column());
             const int endColumn = qMax(selectionRange->start().column(), selectionRange->end().column());
             const KTextEditor::Range workingRange(startLine, startColumn, endLine, endColumn);
             for (int line = startLine; line <= endLine; ++line) {
                 const KTextEditor::Range r(rangeOnLine(workingRange, line));
                 insertText(r.end(), QString(closingBracket));
                 view->slotTextInserted(view, r.end(), QString(closingBracket));
                 insertText(r.start(), chars);
                 view->slotTextInserted(view, r.start(), chars);
             }
 
         } else {
             for (const auto &cursor : view->secondaryCursors()) {
                 if (!cursor.range) {
                     continue;
                 }
                 const auto &currSelectionRange = cursor.range;
                 auto expandBehaviour = currSelectionRange->insertBehaviors();
                 currSelectionRange->setInsertBehaviors(KTextEditor::MovingRange::DoNotExpand);
                 insertText(currSelectionRange->end(), QString(closingBracket));
                 insertText(currSelectionRange->start(), chars);
                 currSelectionRange->setInsertBehaviors(expandBehaviour);
                 cursor.pos->setPosition(currSelectionRange->end());
                 auto mutableCursor = const_cast<KTextEditor::ViewPrivate::SecondaryCursor *>(&cursor);
                 mutableCursor->anchor = currSelectionRange->start().toCursor();
             }
 
             // No block, just add to start & end of selection
             insertText(selectionRange->end(), QString(closingBracket));
             view->slotTextInserted(view, selectionRange->end(), QString(closingBracket));
             insertText(selectionRange->start(), chars);
             view->slotTextInserted(view, selectionRange->start(), chars);
         }
 
         // Refresh selection
         view->setSelection(selectionRange->toRange());
         view->setCursorPosition(selectionRange->end());
 
         editEnd();
         return;
     }
 
     // normal handling
     if (!view->config()->persistentSelection() && view->selection()) {
         view->removeSelectedText();
     }
 
     const KTextEditor::Cursor oldCur(view->cursorPosition());
 
     const bool multiLineBlockMode = view->blockSelection() && view->selection();
     if (view->currentInputMode()->overwrite()) {
         // blockmode multiline selection case: remove chars in every line
         const KTextEditor::Range selectionRange = view->selectionRange();
         const int startLine = multiLineBlockMode ? qMax(0, selectionRange.start().line()) : view->cursorPosition().line();
         const int endLine = multiLineBlockMode ? qMin(selectionRange.end().line(), lastLine()) : startLine;
         const int virtualColumn = toVirtualColumn(multiLineBlockMode ? selectionRange.end() : view->cursorPosition());
 
         for (int line = endLine; line >= startLine; --line) {
             Kate::TextLine textLine = m_buffer->plainLine(line);
             const int column = fromVirtualColumn(line, virtualColumn);
             KTextEditor::Range r = KTextEditor::Range(KTextEditor::Cursor(line, column), qMin(chars.length(), textLine.length() - column));
 
             // replace mode needs to know what was removed so it can be restored with backspace
             if (oldCur.column() < lineLength(line)) {
                 QChar removed = characterAt(KTextEditor::Cursor(line, column));
                 view->currentInputMode()->overwrittenChar(removed);
             }
 
             removeText(r);
         }
     }
 
     chars = eventuallyReplaceTabs(view->cursorPosition(), chars);
 
     if (multiLineBlockMode) {
         KTextEditor::Range selectionRange = view->selectionRange();
         const int startLine = qMax(0, selectionRange.start().line());
         const int endLine = qMin(selectionRange.end().line(), lastLine());
         const int column = toVirtualColumn(selectionRange.end());
         for (int line = endLine; line >= startLine; --line) {
             editInsertText(line, fromVirtualColumn(line, column), chars);
         }
         int newSelectionColumn = toVirtualColumn(view->cursorPosition());
         selectionRange.setRange(KTextEditor::Cursor(selectionRange.start().line(), fromVirtualColumn(selectionRange.start().line(), newSelectionColumn)),
                                 KTextEditor::Cursor(selectionRange.end().line(), fromVirtualColumn(selectionRange.end().line(), newSelectionColumn)));
         view->setSelection(selectionRange);
     } else {
         // handle multi cursor input
         // We don't want completionWidget to be doing useless stuff, it
         // should only respond to main cursor text changes
         view->completionWidget()->setIgnoreBufferSignals(true);
         const auto &sc = view->secondaryCursors();
         const bool hasClosingBracket = !closingBracket.isNull();
         const QString closingChar = closingBracket;
         for (const auto &c : sc) {
             insertText(c.cursor(), chars);
             const auto pos = c.cursor();
             const auto nextChar = view->document()->text({pos, pos + Cursor{0, 1}}).trimmed();
             if (hasClosingBracket && !skipAutoBrace(closingBracket, pos) && (nextChar.isEmpty() || !nextChar.at(0).isLetterOrNumber())) {
                 insertText(c.cursor(), closingChar);
                 c.pos->setPosition(pos);
             }
         }
         view->completionWidget()->setIgnoreBufferSignals(false);
         // then our normal cursor
         insertText(view->cursorPosition(), chars);
     }
 
     // auto bracket handling for newly inserted text
     // we inserted a bracket?
     // => add the matching closing one to the view + input chars
     // try to preserve the cursor position
     if (!closingBracket.isNull() && !skipAutoBrace(closingBracket, view->cursorPosition())) {
         // add bracket to the view
         const auto cursorPos = view->cursorPosition();
         const auto nextChar = view->document()->text({cursorPos, cursorPos + Cursor{0, 1}}).trimmed();
         if (nextChar.isEmpty() || !nextChar.at(0).isLetterOrNumber()) {
             insertText(view->cursorPosition(), QString(closingBracket));
             const auto insertedAt(view->cursorPosition());
             view->setCursorPosition(cursorPos);
             m_currentAutobraceRange.reset(newMovingRange({cursorPos - Cursor{0, 1}, insertedAt}, KTextEditor::MovingRange::DoNotExpand));
             connect(view, &View::cursorPositionChanged, this, &DocumentPrivate::checkCursorForAutobrace, Qt::UniqueConnection);
 
             // add bracket to chars inserted! needed for correct signals + indent
             chars.append(closingBracket);
         }
         m_currentAutobraceClosingChar = closingBracket;
     }
 
     // end edit session here, to have updated HL in userTypedChar!
     editEnd();
 
     // indentation for multi cursors
     const auto &secondaryCursors = view->secondaryCursors();
     for (const auto &c : secondaryCursors) {
         m_indenter->userTypedChar(view, c.cursor(), chars.isEmpty() ? QChar() : chars.at(chars.length() - 1));
     }
 
     // trigger indentation for primary
     KTextEditor::Cursor b(view->cursorPosition());
     m_indenter->userTypedChar(view, b, chars.isEmpty() ? QChar() : chars.at(chars.length() - 1));
 
     // inform the view about the original inserted chars
     view->slotTextInserted(view, oldCur, chars);
 }
 
 void KTextEditor::DocumentPrivate::checkCursorForAutobrace(KTextEditor::View *, const KTextEditor::Cursor newPos)
 {
     if (m_currentAutobraceRange && !m_currentAutobraceRange->toRange().contains(newPos)) {
         m_currentAutobraceRange.reset();
     }
 }
 
 void KTextEditor::DocumentPrivate::newLine(KTextEditor::ViewPrivate *v, KTextEditor::DocumentPrivate::NewLineIndent indent, NewLinePos newLinePos)
 {
     editStart();
 
     if (!v->config()->persistentSelection() && v->selection()) {
         v->removeSelectedText();
         v->clearSelection();
     }
 
     auto insertNewLine = [this](KTextEditor::Cursor c) {
         if (c.line() > lastLine()) {
             c.setLine(lastLine());
         }
 
         if (c.line() < 0) {
             c.setLine(0);
         }
 
         int ln = c.line();
 
         int len = lineLength(ln);
 
         if (c.column() > len) {
             c.setColumn(len);
         }
 
         // first: wrap line
         editWrapLine(c.line(), c.column());
 
         // update highlighting to have updated HL in userTypedChar!
         m_buffer->updateHighlighting();
     };
 
     // Helper which allows adding a new line and moving the cursor there
     // without modifying the current line
     auto adjustCusorPos = [newLinePos, this](KTextEditor::Cursor pos) {
         // Handle primary cursor
         bool moveCursorToTop = false;
         if (newLinePos == Above) {
             if (pos.line() <= 0) {
                 pos.setLine(0);
                 pos.setColumn(0);
                 moveCursorToTop = true;
             } else {
                 pos.setLine(pos.line() - 1);
                 pos.setColumn(lineLength(pos.line()));
             }
         } else if (newLinePos == Below) {
             int lastCol = lineLength(pos.line());
             pos.setColumn(lastCol);
         }
         return std::pair{pos, moveCursorToTop};
     };
 
     // Handle multicursors
     const auto &secondaryCursors = v->secondaryCursors();
     if (!secondaryCursors.empty()) {
         // Save the original position of our primary cursor
         Kate::TextCursor savedPrimary(buffer(), v->cursorPosition(), Kate::TextCursor::MoveOnInsert);
         for (const auto &c : secondaryCursors) {
             const auto [newPos, moveCursorToTop] = adjustCusorPos(c.cursor());
             c.pos->setPosition(newPos);
             insertNewLine(c.cursor());
             if (moveCursorToTop) {
                 c.pos->setPosition({0, 0});
             }
             // second: if "indent" is true, indent the new line, if needed...
             if (indent == KTextEditor::DocumentPrivate::Indent) {
                 // Make this secondary cursor primary for a moment
                 // this is necessary because the scripts modify primary cursor
                 // position which can lead to weird indent issues with multicursor
                 v->setCursorPosition(c.cursor());
                 m_indenter->userTypedChar(v, c.cursor(), QLatin1Char('\n'));
                 // restore
                 c.pos->setPosition(v->cursorPosition());
             }
         }
         // Restore the original primary cursor
         v->setCursorPosition(savedPrimary.toCursor());
     }
 
     const auto [newPos, moveCursorToTop] = adjustCusorPos(v->cursorPosition());
     v->setCursorPosition(newPos);
     insertNewLine(v->cursorPosition());
     if (moveCursorToTop) {
         v->setCursorPosition({0, 0});
     }
     // second: if "indent" is true, indent the new line, if needed...
     if (indent == KTextEditor::DocumentPrivate::Indent) {
         m_indenter->userTypedChar(v, v->cursorPosition(), QLatin1Char('\n'));
     }
 
     editEnd();
 }
 
 void KTextEditor::DocumentPrivate::transpose(const KTextEditor::Cursor cursor)
 {
     Kate::TextLine textLine = m_buffer->plainLine(cursor.line());
     if (textLine.length() < 2) {
         return;
     }
 
     uint col = cursor.column();
 
     if (col > 0) {
         col--;
     }
 
     if ((textLine.length() - col) < 2) {
         return;
     }
 
     uint line = cursor.line();
     QString s;
 
     // clever swap code if first character on the line swap right&left
     // otherwise left & right
     s.append(textLine.at(col + 1));
     s.append(textLine.at(col));
     // do the swap
 
     // do it right, never ever manipulate a textline
     editStart();
     editRemoveText(line, col, 2);
     editInsertText(line, col, s);
     editEnd();
 }
 
 void KTextEditor::DocumentPrivate::swapTextRanges(KTextEditor::Range firstWord, KTextEditor::Range secondWord)
 {
     Q_ASSERT(firstWord.isValid() && secondWord.isValid());
     Q_ASSERT(!firstWord.overlaps(secondWord));
     // ensure that secondWord comes AFTER firstWord
     if (firstWord.start().column() > secondWord.start().column() || firstWord.start().line() > secondWord.start().line()) {
         const KTextEditor::Range tempRange = firstWord;
         firstWord.setRange(secondWord);
         secondWord.setRange(tempRange);
     }
 
     const QString tempString = text(secondWord);
     editStart();
     // edit secondWord first as the range might be invalidated after editing firstWord
     replaceText(secondWord, text(firstWord));
     replaceText(firstWord, tempString);
     editEnd();
 }
 
 KTextEditor::Cursor KTextEditor::DocumentPrivate::backspaceAtCursor(KTextEditor::ViewPrivate *view, KTextEditor::Cursor c)
 {
     int col = qMax(c.column(), 0);
     int line = qMax(c.line(), 0);
     if ((col == 0) && (line == 0)) {
         return KTextEditor::Cursor::invalid();
     }
     if (line >= lines()) {
         return KTextEditor::Cursor::invalid();
     }
 
     const Kate::TextLine textLine = m_buffer->plainLine(line);
 
     if (col > 0) {
         bool useNextBlock = false;
         if (config()->backspaceIndents()) {
             // backspace indents: erase to next indent position
             int colX = textLine.toVirtualColumn(col, config()->tabWidth());
             int pos = textLine.firstChar();
             if (pos > 0) {
                 pos = textLine.toVirtualColumn(pos, config()->tabWidth());
             }
             if (pos < 0 || pos >= (int)colX) {
                 // only spaces on left side of cursor
                 if ((int)col > textLine.length()) {
                     // beyond the end of the line, move cursor only
                     return KTextEditor::Cursor(line, col - 1);
                 }
                 indent(KTextEditor::Range(line, 0, line, 0), -1);
             } else {
                 useNextBlock = true;
             }
         }
         if (!config()->backspaceIndents() || useNextBlock) {
             KTextEditor::Cursor beginCursor(line, 0);
             KTextEditor::Cursor endCursor(line, col);
             if (!view->config()->backspaceRemoveComposed()) { // Normal backspace behavior
                 beginCursor.setColumn(col - 1);
                 // move to left of surrogate pair
                 if (!isValidTextPosition(beginCursor)) {
                     Q_ASSERT(col >= 2);
                     beginCursor.setColumn(col - 2);
                 }
             } else {
                 if (auto l = view->textLayout(c)) {
                     beginCursor.setColumn(l->previousCursorPosition(c.column()));
                 }
             }
             removeText(KTextEditor::Range(beginCursor, endCursor));
             // in most cases cursor is moved by removeText, but we should do it manually
             // for past-end-of-line cursors in block mode
             return beginCursor;
         }
         return KTextEditor::Cursor::invalid();
     } else {
         // col == 0: wrap to previous line
         const Kate::TextLine textLine = m_buffer->plainLine(line - 1);
         KTextEditor::Cursor ret = KTextEditor::Cursor::invalid();
 
         if (line > 0) {
             if (config()->wordWrap() && textLine.endsWith(QStringLiteral(" "))) {
                 // gg: in hard wordwrap mode, backspace must also eat the trailing space
                 ret = KTextEditor::Cursor(line - 1, textLine.length() - 1);
                 removeText(KTextEditor::Range(line - 1, textLine.length() - 1, line, 0));
             } else {
                 ret = KTextEditor::Cursor(line - 1, textLine.length());
                 removeText(KTextEditor::Range(line - 1, textLine.length(), line, 0));
             }
         }
         return ret;
     }
 }
 
 void KTextEditor::DocumentPrivate::backspace(KTextEditor::ViewPrivate *view)
 {
     if (!view->config()->persistentSelection() && view->hasSelections()) {
         KTextEditor::Range range = view->selectionRange();
         editStart(); // Avoid bad selection in case of undo
 
         if (view->blockSelection() && view->selection() && range.start().column() > 0 && toVirtualColumn(range.start()) == toVirtualColumn(range.end())) {
             // Remove one character before vertical selection line by expanding the selection
             range.setStart(KTextEditor::Cursor(range.start().line(), range.start().column() - 1));
             view->setSelection(range);
         }
         view->removeSelectedText();
         view->ensureUniqueCursors();
         editEnd();
         return;
     }
 
     editStart();
 
     // Handle multi cursors
     const auto &multiCursors = view->secondaryCursors();
     view->completionWidget()->setIgnoreBufferSignals(true);
     for (const auto &c : multiCursors) {
         const auto newPos = backspaceAtCursor(view, c.cursor());
         if (newPos.isValid()) {
             c.pos->setPosition(newPos);
         }
     }
     view->completionWidget()->setIgnoreBufferSignals(false);
 
     // Handle primary cursor
     auto newPos = backspaceAtCursor(view, view->cursorPosition());
     if (newPos.isValid()) {
         view->setCursorPosition(newPos);
     }
 
     view->ensureUniqueCursors();
 
     editEnd();
 
     // TODO: Handle this for multiple cursors?
     if (m_currentAutobraceRange) {
         const auto r = m_currentAutobraceRange->toRange();
         if (r.columnWidth() == 1 && view->cursorPosition() == r.start()) {
             // start parenthesis removed and range length is 1, remove end as well
             del(view, view->cursorPosition());
             m_currentAutobraceRange.reset();
         }
     }
 }
 
 void KTextEditor::DocumentPrivate::del(KTextEditor::ViewPrivate *view, const KTextEditor::Cursor c)
 {
     if (!view->config()->persistentSelection() && view->selection()) {
         KTextEditor::Range range = view->selectionRange();
         editStart(); // Avoid bad selection in case of undo
         if (view->blockSelection() && toVirtualColumn(range.start()) == toVirtualColumn(range.end())) {
             // Remove one character after vertical selection line by expanding the selection
             range.setEnd(KTextEditor::Cursor(range.end().line(), range.end().column() + 1));
             view->setSelection(range);
         }
         view->removeSelectedText();
         editEnd();
         return;
     }
 
     if (c.column() < m_buffer->lineLength(c.line())) {
         KTextEditor::Cursor endCursor(c.line(), view->textLayout(c)->nextCursorPosition(c.column()));
         removeText(KTextEditor::Range(c, endCursor));
     } else if (c.line() < lastLine()) {
         removeText(KTextEditor::Range(c.line(), c.column(), c.line() + 1, 0));
     }
 }
 
 bool KTextEditor::DocumentPrivate::multiPaste(KTextEditor::ViewPrivate *view, const QStringList &texts)
 {
     if (texts.isEmpty() || view->isMulticursorNotAllowed() || view->secondaryCursors().size() + 1 != (size_t)texts.size()) {
         return false;
     }
 
     m_undoManager->undoSafePoint();
 
     editStart();
     if (view->selection()) {
         view->removeSelectedText();
     }
 
     auto plainSecondaryCursors = view->plainSecondaryCursors();
     KTextEditor::ViewPrivate::PlainSecondaryCursor primary;
     primary.pos = view->cursorPosition();
     primary.range = view->selectionRange();
     plainSecondaryCursors.append(primary);
     std::sort(plainSecondaryCursors.begin(), plainSecondaryCursors.end());
 
     static const QRegularExpression re(QStringLiteral("\r\n?"));
 
     for (int i = texts.size() - 1; i >= 0; --i) {
         QString text = texts[i];
         text.replace(re, QStringLiteral("\n"));
         KTextEditor::Cursor pos = plainSecondaryCursors[i].pos;
         if (pos.isValid()) {
             insertText(pos, text, /*blockmode=*/false);
         }
     }
 
     editEnd();
     return true;
 }
 
 void KTextEditor::DocumentPrivate::paste(KTextEditor::ViewPrivate *view, const QString &text)
 {
     // nop if nothing to paste
     if (text.isEmpty()) {
         return;
     }
 
     // normalize line endings, to e.g. catch issues with \r\n in paste buffer
     // see bug 410951
     QString s = text;
     s.replace(QRegularExpression(QStringLiteral("\r\n?")), QStringLiteral("\n"));
 
     int lines = s.count(QLatin1Char('\n'));
     const bool isSingleLine = lines == 0;
 
     m_undoManager->undoSafePoint();
 
     editStart();
 
     KTextEditor::Cursor pos = view->cursorPosition();
 
     bool skipIndentOnPaste = false;
     if (isSingleLine) {
         const int length = lineLength(pos.line());
         // if its a single line and the line already contains some text, skip indenting
         skipIndentOnPaste = length > 0;
     }
 
     if (!view->config()->persistentSelection() && view->selection()) {
         pos = view->selectionRange().start();
         if (view->blockSelection()) {
             pos = rangeOnLine(view->selectionRange(), pos.line()).start();
             if (lines == 0) {
                 s += QLatin1Char('\n');
                 s = s.repeated(view->selectionRange().numberOfLines() + 1);
                 s.chop(1);
             }
         }
         view->removeSelectedText();
     }
 
     if (config()->ovr()) {
         const auto pasteLines = QStringView(s).split(QLatin1Char('\n'));
 
         if (!view->blockSelection()) {
             int endColumn = (pasteLines.count() == 1 ? pos.column() : 0) + pasteLines.last().length();
             removeText(KTextEditor::Range(pos, pos.line() + pasteLines.count() - 1, endColumn));
         } else {
             int maxi = qMin(pos.line() + pasteLines.count(), this->lines());
 
             for (int i = pos.line(); i < maxi; ++i) {
                 int pasteLength = pasteLines.at(i - pos.line()).length();
                 removeText(KTextEditor::Range(i, pos.column(), i, qMin(pasteLength + pos.column(), lineLength(i))));
             }
         }
     }
 
     insertText(pos, s, view->blockSelection());
     editEnd();
 
     // move cursor right for block select, as the user is moved right internal
     // even in that case, but user expects other behavior in block selection
     // mode !
     // just let cursor stay, that was it before I changed to moving ranges!
     if (view->blockSelection()) {
         view->setCursorPositionInternal(pos);
     }
 
     if (config()->indentPastedText()) {
         KTextEditor::Range range = KTextEditor::Range(KTextEditor::Cursor(pos.line(), 0), KTextEditor::Cursor(pos.line() + lines, 0));
         if (!skipIndentOnPaste) {
             m_indenter->indent(view, range);
         }
     }
 
     if (!view->blockSelection()) {
         Q_EMIT charactersSemiInteractivelyInserted(pos, s);
     }
     m_undoManager->undoSafePoint();
 }
 
 void KTextEditor::DocumentPrivate::indent(KTextEditor::Range range, int change)
 {
     if (!isReadWrite()) {
         return;
     }
 
     editStart();
     m_indenter->changeIndent(range, change);
     editEnd();
 }
 
 void KTextEditor::DocumentPrivate::align(KTextEditor::ViewPrivate *view, KTextEditor::Range range)
 {
     m_indenter->indent(view, range);
 }
 
 void KTextEditor::DocumentPrivate::alignOn(KTextEditor::Range range, const QString &pattern, bool blockwise)
 {
     QStringList lines = textLines(range, blockwise);
     // if we have less then two lines in the selection there is nothing to do
     if (lines.size() < 2) {
         return;
     }
     // align on first non-blank character by default
     QRegularExpression re(pattern.isEmpty() ? QStringLiteral("[^\\s]") : pattern);
     // find all matches actual column (normal selection: first line has offset ; block selection: all lines have offset)
     int selectionStartColumn = range.start().column();
     QList<int> patternStartColumns;
     for (const auto &line : lines) {
         QRegularExpressionMatch match = re.match(line);
         if (!match.hasMatch()) { // no match
             patternStartColumns.append(-1);
         } else if (match.lastCapturedIndex() == 0) { // pattern has no group
             patternStartColumns.append(match.capturedStart(0) + (blockwise ? selectionStartColumn : 0));
         } else { // pattern has a group
             patternStartColumns.append(match.capturedStart(1) + (blockwise ? selectionStartColumn : 0));
         }
     }
     if (!blockwise && patternStartColumns[0] != -1) {
         patternStartColumns[0] += selectionStartColumn;
     }
     // find which column we'll align with
     int maxColumn = *std::max_element(patternStartColumns.cbegin(), patternStartColumns.cend());
     // align!
     editStart();
     for (int i = 0; i < lines.size(); ++i) {
         if (patternStartColumns[i] != -1) {
             insertText(KTextEditor::Cursor(range.start().line() + i, patternStartColumns[i]), QString(maxColumn - patternStartColumns[i], QChar::Space));
         }
     }
     editEnd();
 }
 
 void KTextEditor::DocumentPrivate::insertTab(KTextEditor::ViewPrivate *view, const KTextEditor::Cursor)
 {
     if (!isReadWrite()) {
         return;
     }
 
     int lineLen = line(view->cursorPosition().line()).length();
     KTextEditor::Cursor c = view->cursorPosition();
 
     editStart();
 
     if (!view->config()->persistentSelection() && view->selection()) {
         view->removeSelectedText();
     } else if (view->currentInputMode()->overwrite() && c.column() < lineLen) {
         KTextEditor::Range r = KTextEditor::Range(view->cursorPosition(), 1);
 
         // replace mode needs to know what was removed so it can be restored with backspace
         QChar removed = line(view->cursorPosition().line()).at(r.start().column());
         view->currentInputMode()->overwrittenChar(removed);
         removeText(r);
     }
 
     c = view->cursorPosition();
     editInsertText(c.line(), c.column(), QStringLiteral("\t"));
 
     editEnd();
 }
 
 /*
   Remove a given string at the beginning
   of the current line.
 */
 bool KTextEditor::DocumentPrivate::removeStringFromBeginning(int line, const QString &str)
 {
     Kate::TextLine textline = m_buffer->plainLine(line);
 
     KTextEditor::Cursor cursor(line, 0);
     bool there = textline.startsWith(str);
 
     if (!there) {
         cursor.setColumn(textline.firstChar());
         there = textline.matchesAt(cursor.column(), str);
     }
 
     if (there) {
         // Remove some chars
         removeText(KTextEditor::Range(cursor, str.length()));
     }
 
     return there;
 }
 
 /*
   Remove a given string at the end
   of the current line.
 */
 bool KTextEditor::DocumentPrivate::removeStringFromEnd(int line, const QString &str)
 {
     Kate::TextLine textline = m_buffer->plainLine(line);
 
     KTextEditor::Cursor cursor(line, 0);
     bool there = textline.endsWith(str);
 
     if (there) {
         cursor.setColumn(textline.length() - str.length());
     } else {
         cursor.setColumn(textline.lastChar() - str.length() + 1);
         there = textline.matchesAt(cursor.column(), str);
     }
 
     if (there) {
         // Remove some chars
         removeText(KTextEditor::Range(cursor, str.length()));
     }
 
     return there;
 }
 
 /*
   Replace tabs by spaces in the given string, if enabled.
  */
 QString KTextEditor::DocumentPrivate::eventuallyReplaceTabs(const KTextEditor::Cursor cursorPos, const QString &str) const
 {
     const bool replacetabs = config()->replaceTabsDyn();
     if (!replacetabs) {
         return str;
     }
     const int indentWidth = config()->indentationWidth();
     static const QLatin1Char tabChar('\t');
 
     int column = cursorPos.column();
 
     // The result will always be at least as long as the input
     QString result;
     result.reserve(str.size());
 
     for (const QChar ch : str) {
         if (ch == tabChar) {
             // Insert only enough spaces to align to the next indentWidth column
             // This fixes bug #340212
             int spacesToInsert = indentWidth - (column % indentWidth);
             result += QString(spacesToInsert, QLatin1Char(' '));
             column += spacesToInsert;
         } else {
             // Just keep all other typed characters as-is
             result += ch;
             ++column;
         }
     }
     return result;
 }
 
 /*
   Add to the current line a comment line mark at the beginning.
 */
 void KTextEditor::DocumentPrivate::addStartLineCommentToSingleLine(int line, int attrib)
 {
     const QString commentLineMark = highlight()->getCommentSingleLineStart(attrib) + QLatin1Char(' ');
     int pos = 0;
 
     if (highlight()->getCommentSingleLinePosition(attrib) == KSyntaxHighlighting::CommentPosition::AfterWhitespace) {
         const Kate::TextLine l = kateTextLine(line);
         pos = qMax(0, l.firstChar());
     }
     insertText(KTextEditor::Cursor(line, pos), commentLineMark);
 }
 
 /*
   Remove from the current line a comment line mark at
   the beginning if there is one.
 */
 bool KTextEditor::DocumentPrivate::removeStartLineCommentFromSingleLine(int line, int attrib)
 {
     const QString shortCommentMark = highlight()->getCommentSingleLineStart(attrib);
     const QString longCommentMark = shortCommentMark + QLatin1Char(' ');
 
     editStart();
 
     // Try to remove the long comment mark first
     bool removed = (removeStringFromBeginning(line, longCommentMark) || removeStringFromBeginning(line, shortCommentMark));
 
     editEnd();
 
     return removed;
 }
 
 /*
   Add to the current line a start comment mark at the
   beginning and a stop comment mark at the end.
 */
 void KTextEditor::DocumentPrivate::addStartStopCommentToSingleLine(int line, int attrib)
 {
     const QString startCommentMark = highlight()->getCommentStart(attrib) + QLatin1Char(' ');
     const QString stopCommentMark = QLatin1Char(' ') + highlight()->getCommentEnd(attrib);
 
     editStart();
 
     // Add the start comment mark
     insertText(KTextEditor::Cursor(line, 0), startCommentMark);
 
     // Go to the end of the line
     const int col = m_buffer->lineLength(line);
 
     // Add the stop comment mark
     insertText(KTextEditor::Cursor(line, col), stopCommentMark);
 
     editEnd();
 }
 
 /*
   Remove from the current line a start comment mark at
   the beginning and a stop comment mark at the end.
 */
 bool KTextEditor::DocumentPrivate::removeStartStopCommentFromSingleLine(int line, int attrib)
 {
     const QString shortStartCommentMark = highlight()->getCommentStart(attrib);
     const QString longStartCommentMark = shortStartCommentMark + QLatin1Char(' ');
     const QString shortStopCommentMark = highlight()->getCommentEnd(attrib);
     const QString longStopCommentMark = QLatin1Char(' ') + shortStopCommentMark;
 
     editStart();
 
     // Try to remove the long start comment mark first
     const bool removedStart = (removeStringFromBeginning(line, longStartCommentMark) || removeStringFromBeginning(line, shortStartCommentMark));
 
     // Try to remove the long stop comment mark first
     const bool removedStop = removedStart && (removeStringFromEnd(line, longStopCommentMark) || removeStringFromEnd(line, shortStopCommentMark));
 
     editEnd();
 
     return (removedStart || removedStop);
 }
 
 /*
   Add to the current selection a start comment mark at the beginning
   and a stop comment mark at the end.
 */
 void KTextEditor::DocumentPrivate::addStartStopCommentToSelection(KTextEditor::Range selection, bool blockSelection, int attrib)
 {
     const QString startComment = highlight()->getCommentStart(attrib);
     const QString endComment = highlight()->getCommentEnd(attrib);
 
     KTextEditor::Range range = selection;
 
     if ((range.end().column() == 0) && (range.end().line() > 0)) {
         range.setEnd(KTextEditor::Cursor(range.end().line() - 1, lineLength(range.end().line() - 1)));
     }
 
     editStart();
 
     if (!blockSelection) {
         insertText(range.end(), endComment);
         insertText(range.start(), startComment);
     } else {
         for (int line = range.start().line(); line <= range.end().line(); line++) {
             KTextEditor::Range subRange = rangeOnLine(range, line);
             insertText(subRange.end(), endComment);
             insertText(subRange.start(), startComment);
         }
     }
 
     editEnd();
     // selection automatically updated (MovingRange)
 }
 
 /*
   Add to the current selection a comment line mark at the beginning of each line.
 */
 void KTextEditor::DocumentPrivate::addStartLineCommentToSelection(KTextEditor::Range selection, int attrib)
 {
     int sl = selection.start().line();
     int el = selection.end().line();
 
     // if end of selection is in column 0 in last line, omit the last line
     if ((selection.end().column() == 0) && (el > 0)) {
         el--;
     }
 
     if (sl < 0 || el < 0 || sl >= lines() || el >= lines()) {
         return;
     }
 
     editStart();
 
     const QString commentLineMark = highlight()->getCommentSingleLineStart(attrib) + QLatin1Char(' ');
 
     int col = 0;
     if (highlight()->getCommentSingleLinePosition(attrib) == KSyntaxHighlighting::CommentPosition::AfterWhitespace) {
         // For afterwhitespace, we add comment mark at col for all the lines,
         // where col == smallest indent in selection
         // This means that for somelines for example, a statement in an if block
         // might not have its comment mark exactly afterwhitespace, which is okay
         // and _good_ because if someone runs a formatter after commenting we will
         // loose indentation, which is _really_ bad and makes afterwhitespace useless
 
         col = std::numeric_limits<int>::max();
         // For each line in selection, try to find the smallest indent
         for (int l = el; l >= sl; l--) {
             const auto line = plainKateTextLine(l);
             if (line.length() == 0) {
                 continue;
             }
             col = qMin(col, qMax(0, line.firstChar()));
             if (col == 0) {
                 // early out: there can't be an indent smaller than 0
                 break;
             }
         }
 
         if (col == std::numeric_limits<int>::max()) {
             col = 0;
         }
         Q_ASSERT(col >= 0);
     }
 
     // For each line of the selection
     for (int l = el; l >= sl; l--) {
         insertText(KTextEditor::Cursor(l, col), commentLineMark);
     }
 
     editEnd();
 }
 
 bool KTextEditor::DocumentPrivate::nextNonSpaceCharPos(int &line, int &col)
 {
     for (; line >= 0 && line < m_buffer->lines(); line++) {
         Kate::TextLine textLine = m_buffer->plainLine(line);
         col = textLine.nextNonSpaceChar(col);
         if (col != -1) {
             return true; // Next non-space char found
         }
         col = 0;
     }
     // No non-space char found
     line = -1;
     col = -1;
     return false;
 }
 
 bool KTextEditor::DocumentPrivate::previousNonSpaceCharPos(int &line, int &col)
 {
     while (line >= 0 && line < m_buffer->lines()) {
         Kate::TextLine textLine = m_buffer->plainLine(line);
         col = textLine.previousNonSpaceChar(col);
         if (col != -1) {
             return true;
         }
         if (line == 0) {
             return false;
         }
         --line;
         col = textLine.length();
     }
     // No non-space char found
     line = -1;
     col = -1;
     return false;
 }
 
 /*
   Remove from the selection a start comment mark at
   the beginning and a stop comment mark at the end.
 */
 bool KTextEditor::DocumentPrivate::removeStartStopCommentFromSelection(KTextEditor::Range selection, int attrib)
 {
     const QString startComment = highlight()->getCommentStart(attrib);
     const QString endComment = highlight()->getCommentEnd(attrib);
 
     int sl = qMax<int>(0, selection.start().line());
     int el = qMin<int>(selection.end().line(), lastLine());
     int sc = selection.start().column();
     int ec = selection.end().column();
 
     // The selection ends on the char before selectEnd
     if (ec != 0) {
         --ec;
     } else if (el > 0) {
         --el;
         ec = m_buffer->lineLength(el) - 1;
     }
 
     const int startCommentLen = startComment.length();
     const int endCommentLen = endComment.length();
 
     // had this been perl or sed: s/^\s*$startComment(.+?)$endComment\s*/$2/
 
     bool remove = nextNonSpaceCharPos(sl, sc) && m_buffer->plainLine(sl).matchesAt(sc, startComment) && previousNonSpaceCharPos(el, ec)
         && ((ec - endCommentLen + 1) >= 0) && m_buffer->plainLine(el).matchesAt(ec - endCommentLen + 1, endComment);
 
     if (remove) {
         editStart();
 
         removeText(KTextEditor::Range(el, ec - endCommentLen + 1, el, ec + 1));
         removeText(KTextEditor::Range(sl, sc, sl, sc + startCommentLen));
 
         editEnd();
         // selection automatically updated (MovingRange)
     }
 
     return remove;
 }
 
 bool KTextEditor::DocumentPrivate::removeStartStopCommentFromRegion(const KTextEditor::Cursor start, const KTextEditor::Cursor end, int attrib)
 {
     const QString startComment = highlight()->getCommentStart(attrib);
     const QString endComment = highlight()->getCommentEnd(attrib);
     const int startCommentLen = startComment.length();
     const int endCommentLen = endComment.length();
 
     const bool remove = m_buffer->plainLine(start.line()).matchesAt(start.column(), startComment)
         && m_buffer->plainLine(end.line()).matchesAt(end.column() - endCommentLen, endComment);
     if (remove) {
         editStart();
         removeText(KTextEditor::Range(end.line(), end.column() - endCommentLen, end.line(), end.column()));
         removeText(KTextEditor::Range(start, startCommentLen));
         editEnd();
     }
     return remove;
 }
 
 /*
   Remove from the beginning of each line of the
   selection a start comment line mark.
 */
 bool KTextEditor::DocumentPrivate::removeStartLineCommentFromSelection(KTextEditor::Range selection, int attrib, bool toggleComment)
 {
     const QString shortCommentMark = highlight()->getCommentSingleLineStart(attrib);
     const QString longCommentMark = shortCommentMark + QLatin1Char(' ');
 
     const int startLine = selection.start().line();
     int endLine = selection.end().line();
 
     if ((selection.end().column() == 0) && (endLine > 0)) {
         endLine--;
     }
 
     bool removed = false;
 
     // If we are toggling, we check whether all lines in the selection start
     // with a comment. If they don't, we return early
     // NOTE: When toggling, we only remove comments if all lines in the selection
     // are comments, otherwise we recomment the comments
     if (toggleComment) {
         bool allLinesAreCommented = true;
         for (int line = endLine; line >= startLine; line--) {
             const auto ln = m_buffer->plainLine(line);
             const QString &text = ln.text();
             // Empty lines in between comments is ok
             if (text.isEmpty()) {
                 continue;
             }
             QStringView textView(text.data(), text.size());
             // Must trim any spaces at the beginning
             textView = textView.trimmed();
             if (!textView.startsWith(shortCommentMark) && !textView.startsWith(longCommentMark)) {
                 allLinesAreCommented = false;
                 break;
             }
         }
         if (!allLinesAreCommented) {
             return false;
         }
     }
 
     editStart();
 
     // For each line of the selection
     for (int z = endLine; z >= startLine; z--) {
         // Try to remove the long comment mark first
         removed = (removeStringFromBeginning(z, longCommentMark) || removeStringFromBeginning(z, shortCommentMark) || removed);
     }
 
     editEnd();
     // selection automatically updated (MovingRange)
 
     return removed;
 }
 
 void KTextEditor::DocumentPrivate::commentSelection(KTextEditor::Range selection, KTextEditor::Cursor c, bool blockSelect, CommentType changeType)
 {
     const bool hasSelection = !selection.isEmpty();
     int selectionCol = 0;
 
     if (hasSelection) {
         selectionCol = selection.start().column();
     }
     const int line = c.line();
 
     int startAttrib = 0;
     Kate::TextLine ln = kateTextLine(line);
 
     if (selectionCol < ln.length()) {
         startAttrib = ln.attribute(selectionCol);
     } else if (!ln.attributesList().empty()) {
         startAttrib = ln.attributesList().back().attributeValue;
     }
 
     bool hasStartLineCommentMark = !(highlight()->getCommentSingleLineStart(startAttrib).isEmpty());
     bool hasStartStopCommentMark = (!(highlight()->getCommentStart(startAttrib).isEmpty()) && !(highlight()->getCommentEnd(startAttrib).isEmpty()));
 
     if (changeType == Comment) {
         if (!hasSelection) {
             if (hasStartLineCommentMark) {
                 addStartLineCommentToSingleLine(line, startAttrib);
             } else if (hasStartStopCommentMark) {
                 addStartStopCommentToSingleLine(line, startAttrib);
             }
         } else {
             // anders: prefer single line comment to avoid nesting probs
             // If the selection starts after first char in the first line
             // or ends before the last char of the last line, we may use
             // multiline comment markers.
             // TODO We should try to detect nesting.
             //    - if selection ends at col 0, most likely she wanted that
             // line ignored
             const KTextEditor::Range sel = selection;
             if (hasStartStopCommentMark
                 && (!hasStartLineCommentMark
                     || ((sel.start().column() > m_buffer->plainLine(sel.start().line()).firstChar())
                         || (sel.end().column() > 0 && sel.end().column() < (m_buffer->plainLine(sel.end().line()).length()))))) {
                 addStartStopCommentToSelection(selection, blockSelect, startAttrib);
             } else if (hasStartLineCommentMark) {
                 addStartLineCommentToSelection(selection, startAttrib);
             }
         }
     } else { // uncomment
         bool removed = false;
         const bool toggleComment = changeType == ToggleComment;
         if (!hasSelection) {
             removed = (hasStartLineCommentMark && removeStartLineCommentFromSingleLine(line, startAttrib))
                 || (hasStartStopCommentMark && removeStartStopCommentFromSingleLine(line, startAttrib));
         } else {
             // anders: this seems like it will work with above changes :)
             removed = (hasStartStopCommentMark && removeStartStopCommentFromSelection(selection, startAttrib))
                 || (hasStartLineCommentMark && removeStartLineCommentFromSelection(selection, startAttrib, toggleComment));
         }
 
         // recursive call for toggle comment
         if (!removed && toggleComment) {
             commentSelection(selection, c, blockSelect, Comment);
         }
     }
 }
 
 /*
   Comment or uncomment the selection or the current
   line if there is no selection.
 */
 void KTextEditor::DocumentPrivate::comment(KTextEditor::ViewPrivate *v, uint line, uint column, CommentType change)
 {
     // skip word wrap bug #105373
     const bool skipWordWrap = wordWrap();
     if (skipWordWrap) {
         setWordWrap(false);
     }
 
     editStart();
 
     if (v->selection()) {
         const auto &cursors = v->secondaryCursors();
         for (const auto &c : cursors) {
             if (!c.range) {
                 continue;
             }
             commentSelection(c.range->toRange(), c.cursor(), false, change);
         }
         KTextEditor::Cursor c(line, column);
         commentSelection(v->selectionRange(), c, v->blockSelection(), change);
     } else {
         const auto &cursors = v->secondaryCursors();
         for (const auto &c : cursors) {
             commentSelection({}, c.cursor(), false, change);
         }
         commentSelection({}, KTextEditor::Cursor(line, column), false, change);
     }
 
     editEnd();
 
     if (skipWordWrap) {
         setWordWrap(true); // see begin of function ::comment (bug #105373)
     }
 }
 
 void KTextEditor::DocumentPrivate::transformCursorOrRange(KTextEditor::ViewPrivate *v,
                                                           KTextEditor::Cursor c,
                                                           KTextEditor::Range selection,
                                                           KTextEditor::DocumentPrivate::TextTransform t)
 {
     if (v->selection()) {
         editStart();
 
         KTextEditor::Range range(selection.start(), 0);
         while (range.start().line() <= selection.end().line()) {
             int start = 0;
             int end = lineLength(range.start().line());
 
             if (range.start().line() == selection.start().line() || v->blockSelection()) {
                 start = selection.start().column();
             }
 
             if (range.start().line() == selection.end().line() || v->blockSelection()) {
                 end = selection.end().column();
             }
 
             if (start > end) {
                 int swapCol = start;
                 start = end;
                 end = swapCol;
             }
             range.setStart(KTextEditor::Cursor(range.start().line(), start));
             range.setEnd(KTextEditor::Cursor(range.end().line(), end));
 
             QString s = text(range);
             QString old = s;
 
             if (t == Uppercase) {
                 // honor locale, see bug 467104
                 s = QLocale().toUpper(s);
             } else if (t == Lowercase) {
                 // honor locale, see bug 467104
                 s = QLocale().toLower(s);
             } else { // Capitalize
                 Kate::TextLine l = m_buffer->plainLine(range.start().line());
                 int p(0);
                 while (p < s.length()) {
                     // If bol or the character before is not in a word, up this one:
                     // 1. if both start and p is 0, upper char.
                     // 2. if blockselect or first line, and p == 0 and start-1 is not in a word, upper
                     // 3. if p-1 is not in a word, upper.
                     if ((!range.start().column() && !p)
                         || ((range.start().line() == selection.start().line() || v->blockSelection()) && !p
                             && !highlight()->isInWord(l.at(range.start().column() - 1)))
                         || (p && !highlight()->isInWord(s.at(p - 1)))) {
                         s[p] = s.at(p).toUpper();
                     }
                     p++;
                 }
             }
 
             if (s != old) {
                 removeText(range);
                 insertText(range.start(), s);
             }
 
             range.setBothLines(range.start().line() + 1);
         }
 
         editEnd();
     } else { // no selection
         editStart();
 
         // get cursor
         KTextEditor::Cursor cursor = c;
 
         QString old = text(KTextEditor::Range(cursor, 1));
         QString s;
         switch (t) {
         case Uppercase:
             s = old.toUpper();
             break;
         case Lowercase:
             s = old.toLower();
             break;
         case Capitalize: {
             Kate::TextLine l = m_buffer->plainLine(cursor.line());
             while (cursor.column() > 0 && highlight()->isInWord(l.at(cursor.column() - 1), l.attribute(cursor.column() - 1))) {
                 cursor.setColumn(cursor.column() - 1);
             }
             old = text(KTextEditor::Range(cursor, 1));
             s = old.toUpper();
         } break;
         default:
             break;
         }
 
         removeText(KTextEditor::Range(cursor, 1));
         insertText(cursor, s);
 
         editEnd();
     }
 }
 
 void KTextEditor::DocumentPrivate::transform(KTextEditor::ViewPrivate *v, const KTextEditor::Cursor c, KTextEditor::DocumentPrivate::TextTransform t)
 {
     editStart();
 
     if (v->selection()) {
         const auto &cursors = v->secondaryCursors();
         for (const auto &c : cursors) {
             if (!c.range) {
                 continue;
             }
             auto pos = c.pos->toCursor();
             transformCursorOrRange(v, c.anchor, c.range->toRange(), t);
             c.pos->setPosition(pos);
         }
         // cache the selection and cursor, so we can be sure to restore.
         const auto selRange = v->selectionRange();
         transformCursorOrRange(v, c, v->selectionRange(), t);
         v->setSelection(selRange);
         v->setCursorPosition(c);
     } else { // no selection
         const auto &secondaryCursors = v->secondaryCursors();
         for (const auto &c : secondaryCursors) {
             transformCursorOrRange(v, c.cursor(), {}, t);
         }
         transformCursorOrRange(v, c, {}, t);
     }
 
     editEnd();
 }
 
 void KTextEditor::DocumentPrivate::joinLines(uint first, uint last)
 {
     //   if ( first == last ) last += 1;
     editStart();
     int line(first);
     while (first < last) {
         if (line >= lines() || line + 1 >= lines()) {
             editEnd();
             return;
         }
 
         // Normalize the whitespace in the joined lines by making sure there's
         // always exactly one space between the joined lines
         // This cannot be done in editUnwrapLine, because we do NOT want this
         // behavior when deleting from the start of a line, just when explicitly
         // calling the join command
         Kate::TextLine l = kateTextLine(line);
         Kate::TextLine tl = kateTextLine(line + 1);
 
         int pos = tl.firstChar();
         if (pos >= 0) {
             if (pos != 0) {
                 editRemoveText(line + 1, 0, pos);
             }
             if (!(l.length() == 0 || l.at(l.length() - 1).isSpace())) {
                 editInsertText(line + 1, 0, QStringLiteral(" "));
             }
         } else {
             // Just remove the whitespace and let Kate handle the rest
             editRemoveText(line + 1, 0, tl.length());
         }
 
         editUnWrapLine(line);
         first++;
     }
     editEnd();
 }
 
 void KTextEditor::DocumentPrivate::tagLines(KTextEditor::LineRange lineRange)
 {
     for (auto view : std::as_const(m_views)) {
         static_cast<ViewPrivate *>(view)->tagLines(lineRange, true);
     }
 }
 
 void KTextEditor::DocumentPrivate::tagLine(int line)
 {
     tagLines({line, line});
 }
 
 void KTextEditor::DocumentPrivate::repaintViews(bool paintOnlyDirty)
 {
     for (auto view : std::as_const(m_views)) {
         static_cast<ViewPrivate *>(view)->repaintText(paintOnlyDirty);
     }
 }
 
 /*
    Bracket matching uses the following algorithm:
    If in overwrite mode, match the bracket currently underneath the cursor.
    Otherwise, if the character to the left is a bracket,
    match it. Otherwise if the character to the right of the cursor is a
    bracket, match it. Otherwise, don't match anything.
 */
 KTextEditor::Range KTextEditor::DocumentPrivate::findMatchingBracket(const KTextEditor::Cursor start, int maxLines)
 {
     if (maxLines < 0 || start.line() < 0 || start.line() >= lines()) {
         return KTextEditor::Range::invalid();
     }
 
     Kate::TextLine textLine = m_buffer->plainLine(start.line());
     KTextEditor::Range range(start, start);
     const QChar right = textLine.at(range.start().column());
     const QChar left = textLine.at(range.start().column() - 1);
     QChar bracket;
 
     if (config()->ovr()) {
         if (isBracket(right)) {
             bracket = right;
         } else {
             return KTextEditor::Range::invalid();
         }
     } else if (isBracket(right)) {
         bracket = right;
     } else if (isBracket(left)) {
         range.setStart(KTextEditor::Cursor(range.start().line(), range.start().column() - 1));
         bracket = left;
     } else {
         return KTextEditor::Range::invalid();
     }
 
     const QChar opposite = matchingBracket(bracket);
     if (opposite.isNull()) {
         return KTextEditor::Range::invalid();
     }
 
     const int searchDir = isStartBracket(bracket) ? 1 : -1;
     uint nesting = 0;
 
     const int minLine = qMax(range.start().line() - maxLines, 0);
     const int maxLine = qMin(range.start().line() + maxLines, documentEnd().line());
 
     range.setEnd(range.start());
     KTextEditor::DocumentCursor cursor(this);
     cursor.setPosition(range.start());
     int validAttr = kateTextLine(cursor.line()).attribute(cursor.column());
 
     while (cursor.line() >= minLine && cursor.line() <= maxLine) {
         if (!cursor.move(searchDir)) {
             return KTextEditor::Range::invalid();
         }
 
         Kate::TextLine textLine = kateTextLine(cursor.line());
         if (textLine.attribute(cursor.column()) == validAttr) {
             // Check for match
             QChar c = textLine.at(cursor.column());
             if (c == opposite) {
                 if (nesting == 0) {
                     if (searchDir > 0) { // forward
                         range.setEnd(cursor.toCursor());
                     } else {
                         range.setStart(cursor.toCursor());
                     }
                     return range;
                 }
                 nesting--;
             } else if (c == bracket) {
                 nesting++;
             }
         }
     }
 
     return KTextEditor::Range::invalid();
 }
 
 // helper: remove \r and \n from visible document name (bug #170876)
 inline static QString removeNewLines(const QString &str)
 {
     QString tmp(str);
     return tmp.replace(QLatin1String("\r\n"), QLatin1String(" ")).replace(QLatin1Char('\r'), QLatin1Char(' ')).replace(QLatin1Char('\n'), QLatin1Char(' '));
 }
 
 void KTextEditor::DocumentPrivate::updateDocName()
 {
     // if the name is set, and starts with FILENAME, it should not be changed!
     if (!url().isEmpty() && (m_docName == removeNewLines(url().fileName()) || m_docName.startsWith(removeNewLines(url().fileName()) + QLatin1String(" (")))) {
         return;
     }
 
     int count = -1;
 
     std::vector<KTextEditor::DocumentPrivate *> docsWithSameName;
 
     const auto docs = KTextEditor::EditorPrivate::self()->documents();
     for (KTextEditor::Document *kteDoc : docs) {
         auto doc = static_cast<KTextEditor::DocumentPrivate *>(kteDoc);
         if ((doc != this) && (doc->url().fileName() == url().fileName())) {
             if (doc->m_docNameNumber > count) {
                 count = doc->m_docNameNumber;
             }
             docsWithSameName.push_back(doc);
         }
     }
 
     m_docNameNumber = count + 1;
 
     QString oldName = m_docName;
     m_docName = removeNewLines(url().fileName());
 
     m_isUntitled = m_docName.isEmpty();
 
     if (!m_isUntitled && !docsWithSameName.empty()) {
         docsWithSameName.push_back(this);
         uniquifyDocNames(docsWithSameName);
         return;
     }
 
     if (m_isUntitled) {
         m_docName = i18n("Untitled");
     }
 
     if (m_docNameNumber > 0) {
         m_docName = QString(m_docName + QLatin1String(" (%1)")).arg(m_docNameNumber + 1);
     }
 
     // avoid to emit this, if name doesn't change!
     if (oldName != m_docName) {
         Q_EMIT documentNameChanged(this);
     }
 }
 
 /**
  * Find the shortest prefix for doc from urls
  * @p urls contains a list of urls
  *  - /path/to/some/file
  *  - /some/to/path/file
  *
  * we find the shortest path prefix which can be used to
  * identify @p doc
  *
  * for above, it will return "some" for first and "path" for second
  */
 static QString shortestPrefix(const std::vector<QString> &urls, KTextEditor::DocumentPrivate *doc)
 {
     const auto url = doc->url().toString(QUrl::NormalizePathSegments | QUrl::PreferLocalFile);
     int lastSlash = url.lastIndexOf(QLatin1Char('/'));
     if (lastSlash == -1) {
         // just filename?
         return url;
     }
     int fileNameStart = lastSlash;
 
     lastSlash--;
     lastSlash = url.lastIndexOf(QLatin1Char('/'), lastSlash);
     if (lastSlash == -1) {
         // already too short?
         lastSlash = 0;
         return url.mid(lastSlash, fileNameStart);
     }
 
     QStringView urlView = url;
     QStringView urlv = url;
     urlv = urlv.mid(lastSlash);
 
     for (size_t i = 0; i < urls.size(); ++i) {
         if (urls[i] == url) {
             continue;
         }
 
         if (urls[i].endsWith(urlv)) {
             lastSlash = url.lastIndexOf(QLatin1Char('/'), lastSlash - 1);
             if (lastSlash <= 0) {
                 // reached end if we either found no / or found the slash at the start
                 return url.mid(0, fileNameStart);
             }
             // else update urlv and match again from start
             urlv = urlView.mid(lastSlash);
             i = -1;
         }
     }
 
     return url.mid(lastSlash + 1, fileNameStart - (lastSlash + 1));
 }
 
 void KTextEditor::DocumentPrivate::uniquifyDocNames(const std::vector<KTextEditor::DocumentPrivate *> &docs)
 {
     std::vector<QString> paths;
     paths.reserve(docs.size());
     std::transform(docs.begin(), docs.end(), std::back_inserter(paths), [](const KTextEditor::DocumentPrivate *d) {
         return d->url().toString(QUrl::NormalizePathSegments | QUrl::PreferLocalFile);
     });
 
     for (const auto doc : docs) {
         const QString prefix = shortestPrefix(paths, doc);
         const QString fileName = doc->url().fileName();
         const QString oldName = doc->m_docName;
 
         if (!prefix.isEmpty()) {
             doc->m_docName = fileName + QStringLiteral(" - ") + prefix;
         } else {
             doc->m_docName = fileName;
         }
 
         if (doc->m_docName != oldName) {
             Q_EMIT doc->documentNameChanged(doc);
         }
     }
 }
 
 void KTextEditor::DocumentPrivate::slotModifiedOnDisk(KTextEditor::View * /*v*/)
 {
     if (url().isEmpty() || !m_modOnHd) {
         return;
     }
 
     if (!isModified() && isAutoReload()) {
         onModOnHdAutoReload();
         return;
     }
 
     if (!m_fileChangedDialogsActivated || m_modOnHdHandler) {
         return;
     }
 
     // don't ask the user again and again the same thing
     if (m_modOnHdReason == m_prevModOnHdReason) {
         return;
     }
     m_prevModOnHdReason = m_modOnHdReason;
 
     m_modOnHdHandler = new KateModOnHdPrompt(this, m_modOnHdReason, reasonedMOHString());
     connect(m_modOnHdHandler.data(), &KateModOnHdPrompt::saveAsTriggered, this, &DocumentPrivate::onModOnHdSaveAs);
     connect(m_modOnHdHandler.data(), &KateModOnHdPrompt::closeTriggered, this, &DocumentPrivate::onModOnHdClose);
     connect(m_modOnHdHandler.data(), &KateModOnHdPrompt::reloadTriggered, this, &DocumentPrivate::onModOnHdReload);
     connect(m_modOnHdHandler.data(), &KateModOnHdPrompt::autoReloadTriggered, this, &DocumentPrivate::onModOnHdAutoReload);
     connect(m_modOnHdHandler.data(), &KateModOnHdPrompt::ignoreTriggered, this, &DocumentPrivate::onModOnHdIgnore);
 }
 
 void KTextEditor::DocumentPrivate::onModOnHdSaveAs()
 {
     m_modOnHd = false;
     const QUrl res = getSaveFileUrl(i18n("Save File"));
     if (!res.isEmpty()) {
         if (!saveAs(res)) {
             KMessageBox::error(dialogParent(), i18n("Save failed"));
             m_modOnHd = true;
         } else {
             delete m_modOnHdHandler;
             m_prevModOnHdReason = OnDiskUnmodified;
             Q_EMIT modifiedOnDisk(this, false, OnDiskUnmodified);
         }
     } else { // the save as dialog was canceled, we are still modified on disk
         m_modOnHd = true;
     }
 }
 
 void KTextEditor::DocumentPrivate::onModOnHdClose()
 {
     // avoid prompt in closeUrl()
     m_fileChangedDialogsActivated = false;
 
     // close the file without prompt confirmation
     closeUrl();
 
     // Useful for applications that provide the necessary interface
     // delay this, otherwise we delete ourself during e.g. event handling + deleting this is undefined!
     // see e.g. bug 433180
     QTimer::singleShot(0, this, [this]() {
         KTextEditor::EditorPrivate::self()->application()->closeDocument(this);
     });
 }
 
 void KTextEditor::DocumentPrivate::onModOnHdReload()
 {
     m_modOnHd = false;
     m_prevModOnHdReason = OnDiskUnmodified;
     Q_EMIT modifiedOnDisk(this, false, OnDiskUnmodified);
 
     // MUST Clear Undo/Redo here because by the time we get here
     // the checksum has already been updated and the undo manager
     // sees the new checksum and thinks nothing changed and loads
     // a bad undo history resulting in funny things.
     m_undoManager->clearUndo();
     m_undoManager->clearRedo();
 
     documentReload();
     delete m_modOnHdHandler;
 }
 
 void KTextEditor::DocumentPrivate::autoReloadToggled(bool b)
 {
     m_autoReloadMode->setChecked(b);
     if (b) {
         connect(&m_modOnHdTimer, &QTimer::timeout, this, &DocumentPrivate::onModOnHdAutoReload);
     } else {
         disconnect(&m_modOnHdTimer, &QTimer::timeout, this, &DocumentPrivate::onModOnHdAutoReload);
     }
 }
 
 bool KTextEditor::DocumentPrivate::isAutoReload()
 {
     return m_autoReloadMode->isChecked();
 }
 
 void KTextEditor::DocumentPrivate::delayAutoReload()
 {
     if (isAutoReload()) {
         m_autoReloadThrottle.start();
     }
 }
 
 void KTextEditor::DocumentPrivate::onModOnHdAutoReload()
 {
     if (m_modOnHdHandler) {
         delete m_modOnHdHandler;
         autoReloadToggled(true);
     }
 
     if (!isAutoReload()) {
         return;
     }
 
     if (m_modOnHd && !m_reloading && !m_autoReloadThrottle.isActive()) {
         m_modOnHd = false;
         m_prevModOnHdReason = OnDiskUnmodified;
         Q_EMIT modifiedOnDisk(this, false, OnDiskUnmodified);
 
         // MUST clear undo/redo. This comes way after KDirWatch signaled us
         // and the checksum is already updated by the time we start reload.
         m_undoManager->clearUndo();
         m_undoManager->clearRedo();
 
         documentReload();
         m_autoReloadThrottle.start();
     }
 }
 
 void KTextEditor::DocumentPrivate::onModOnHdIgnore()
 {
     // ignore as long as m_prevModOnHdReason == m_modOnHdReason
     delete m_modOnHdHandler;
 }
 
 void KTextEditor::DocumentPrivate::setModifiedOnDisk(ModifiedOnDiskReason reason)
 {
     m_modOnHdReason = reason;
     m_modOnHd = (reason != OnDiskUnmodified);
     Q_EMIT modifiedOnDisk(this, (reason != OnDiskUnmodified), reason);
 }
 
 class KateDocumentTmpMark
 {
 public:
     QString line;
     KTextEditor::Mark mark;
 };
 
 void KTextEditor::DocumentPrivate::setModifiedOnDiskWarning(bool on)
 {
     m_fileChangedDialogsActivated = on;
 }
 
 bool KTextEditor::DocumentPrivate::documentReload()
 {
     if (url().isEmpty()) {
         return false;
     }
 
     // If we are modified externally clear undo and redo
     // Why:
     // Our checksum() is already updated at this point by
     // slotDelayedHandleModOnHd() so we will end up restoring
     // undo because undo manager relies on checksum() to check
     // if the doc is same or different. Hence any checksum matching
     // is useless at this point and we must clear it here
     if (m_modOnHd) {
         m_undoManager->clearUndo();
         m_undoManager->clearRedo();
     }
 
     // typically, the message for externally modified files is visible. Since it
     // does not make sense showing an additional dialog, just hide the message.
     delete m_modOnHdHandler;
 
     Q_EMIT aboutToReload(this);
 
     QVarLengthArray<KateDocumentTmpMark> tmp;
     tmp.reserve(m_marks.size());
     std::transform(m_marks.cbegin(), m_marks.cend(), std::back_inserter(tmp), [this](KTextEditor::Mark *mark) {
         return KateDocumentTmpMark{line(mark->line), *mark};
     });
 
     // Remember some settings which may changed at reload
     const QString oldMode = mode();
     const bool modeByUser = m_fileTypeSetByUser;
     const QString oldHlMode = highlightingMode();
     const bool hlByUser = m_hlSetByUser;
 
     m_storedVariables.clear();
 
     // save cursor positions for all views
     QVarLengthArray<std::pair<KTextEditor::ViewPrivate *, KTextEditor::Cursor>, 4> cursorPositions;
     std::transform(m_views.cbegin(), m_views.cend(), std::back_inserter(cursorPositions), [](KTextEditor::View *v) {
         return std::pair<KTextEditor::ViewPrivate *, KTextEditor::Cursor>(static_cast<ViewPrivate *>(v), v->cursorPosition());
     });
 
     // clear multicursors
     // FIXME: Restore multicursors, at least for the case where doc is unmodified
     for (auto *view : m_views) {
         static_cast<ViewPrivate *>(view)->clearSecondaryCursors();
         // Clear folding state if we are modified on hd
         if (m_modOnHd) {
             static_cast<ViewPrivate *>(view)->clearFoldingState();
         }
     }
 
     m_reloading = true;
     KTextEditor::DocumentPrivate::openUrl(url());
 
     // reset some flags only valid for one reload!
     m_userSetEncodingForNextReload = false;
 
     // restore cursor positions for all views
     for (auto v : std::as_const(m_views)) {
         setActiveView(v);
         auto it = std::find_if(cursorPositions.cbegin(), cursorPositions.cend(), [v](const std::pair<KTextEditor::ViewPrivate *, KTextEditor::Cursor> &p) {
             return p.first == v;
         });
         v->setCursorPosition(it->second);
         if (v->isVisible()) {
             v->repaint();
         }
     }
 
     int z = 0;
     const int lines = this->lines();
     for (const auto &tmpMark : tmp) {
         if (z < lines) {
             if (tmpMark.line == line(tmpMark.mark.line)) {
                 setMark(tmpMark.mark.line, tmpMark.mark.type);
             }
         }
         ++z;
     }
 
     // Restore old settings
     if (modeByUser) {
         updateFileType(oldMode, true);
     }
     if (hlByUser) {
         setHighlightingMode(oldHlMode);
     }
 
     Q_EMIT reloaded(this);
 
     return true;
 }
 
 bool KTextEditor::DocumentPrivate::documentSave()
 {
     if (!url().isValid() || !isReadWrite()) {
         return documentSaveAs();
     }
 
     return save();
 }
 
 bool KTextEditor::DocumentPrivate::documentSaveAs()
 {
     const QUrl saveUrl = getSaveFileUrl(i18n("Save File"));
     if (saveUrl.isEmpty()) {
         return false;
     }
 
     return saveAs(saveUrl);
 }
 
 bool KTextEditor::DocumentPrivate::documentSaveAsWithEncoding(const QString &encoding)
 {
     const QUrl saveUrl = getSaveFileUrl(i18n("Save File"));
     if (saveUrl.isEmpty()) {
         return false;
     }
 
     setEncoding(encoding);
     return saveAs(saveUrl);
 }
 
 void KTextEditor::DocumentPrivate::documentSaveCopyAs()
 {
     const QUrl saveUrl = getSaveFileUrl(i18n("Save Copy of File"));
     if (saveUrl.isEmpty()) {
         return;
     }
 
     QTemporaryFile *file = new QTemporaryFile();
     if (!file->open()) {
         return;
     }
 
     if (!m_buffer->saveFile(file->fileName())) {
         KMessageBox::error(dialogParent(),
                            i18n("The document could not be saved, as it was not possible to write to %1.\n\nCheck that you have write access to this file or "
                                 "that enough disk space is available.",
                                 this->url().toDisplayString(QUrl::PreferLocalFile)));
         return;
     }
 
     // get the right permissions, start with safe default
     KIO::StatJob *statJob = KIO::stat(url(), KIO::StatJob::SourceSide, KIO::StatBasic);
     KJobWidgets::setWindow(statJob, QApplication::activeWindow());
     const auto url = this->url();
     connect(statJob, &KIO::StatJob::result, this, [url, file, saveUrl](KJob *j) {
         if (auto sj = qobject_cast<KIO::StatJob *>(j)) {
             const int permissions = KFileItem(sj->statResult(), url).permissions();
             KIO::FileCopyJob *job = KIO::file_copy(QUrl::fromLocalFile(file->fileName()), saveUrl, permissions, KIO::Overwrite);
             KJobWidgets::setWindow(job, QApplication::activeWindow());
             connect(job, &KIO::FileCopyJob::finished, file, &QTemporaryFile::deleteLater);
             job->start();
         }
     });
     statJob->start();
 }
 
 void KTextEditor::DocumentPrivate::setWordWrap(bool on)
 {
     config()->setWordWrap(on);
 }
 
 bool KTextEditor::DocumentPrivate::wordWrap() const
 {
     return config()->wordWrap();
 }
 
 void KTextEditor::DocumentPrivate::setWordWrapAt(uint col)
 {
     config()->setWordWrapAt(col);
 }
 
 unsigned int KTextEditor::DocumentPrivate::wordWrapAt() const
 {
     return config()->wordWrapAt();
 }
 
 void KTextEditor::DocumentPrivate::setPageUpDownMovesCursor(bool on)
 {
     config()->setPageUpDownMovesCursor(on);
 }
 
 bool KTextEditor::DocumentPrivate::pageUpDownMovesCursor() const
 {
     return config()->pageUpDownMovesCursor();
 }
 // END
 
 bool KTextEditor::DocumentPrivate::setEncoding(const QString &e)
 {
     return m_config->setEncoding(e);
 }
 
 QString KTextEditor::DocumentPrivate::encoding() const
 {
     return m_config->encoding();
 }
 
 void KTextEditor::DocumentPrivate::updateConfig()
 {
     m_undoManager->updateConfig();
 
     // switch indenter if needed and update config....
     m_indenter->setMode(m_config->indentationMode());
     m_indenter->updateConfig();
 
     // set tab width there, too
     m_buffer->setTabWidth(config()->tabWidth());
 
     // update all views, does tagAll and updateView...
     for (auto view : std::as_const(m_views)) {
         static_cast<ViewPrivate *>(view)->updateDocumentConfig();
     }
 
     // update on-the-fly spell checking as spell checking defaults might have changes
     if (m_onTheFlyChecker) {
         m_onTheFlyChecker->updateConfig();
     }
 
     if (config()->autoSave()) {
         int interval = config()->autoSaveInterval();
         if (interval == 0) {
             m_autoSaveTimer.stop();
         } else {
             m_autoSaveTimer.setInterval(interval * 1000);
             if (isModified()) {
                 m_autoSaveTimer.start();
             }
         }
     }
 
     Q_EMIT configChanged(this);
 }
 
 // BEGIN Variable reader
 // "local variable" feature by anders, 2003
 /* TODO
       add config options (how many lines to read, on/off)
       add interface for plugins/apps to set/get variables
       add view stuff
 */
 bool KTextEditor::DocumentPrivate::readVariables(bool onlyViewAndRenderer)
 {
     const bool hasVariableline = [this] {
         const QLatin1String s("kate");
         if (lines() > 10) {
             for (int i = qMax(10, lines() - 10); i < lines(); ++i) {
                 if (line(i).contains(s)) {
                     return true;
                 }
             }
         }
         for (int i = 0; i < qMin(9, lines()); ++i) {
             if (line(i).contains(s)) {
                 return true;
             }
         }
         return false;
     }();
     if (!hasVariableline) {
         return false;
     }
 
     if (!onlyViewAndRenderer) {
         m_config->configStart();
     }
 
     // views!
     for (auto view : std::as_const(m_views)) {
         auto v = static_cast<ViewPrivate *>(view);
         v->config()->configStart();
         v->rendererConfig()->configStart();
     }
     // read a number of lines in the top/bottom of the document
     for (int i = 0; i < qMin(9, lines()); ++i) {
         readVariableLine(line(i), onlyViewAndRenderer);
     }
     if (lines() > 10) {
         for (int i = qMax(10, lines() - 10); i < lines(); i++) {
             readVariableLine(line(i), onlyViewAndRenderer);
         }
     }
 
     if (!onlyViewAndRenderer) {
         m_config->configEnd();
     }
 
     for (auto view : std::as_const(m_views)) {
         auto v = static_cast<ViewPrivate *>(view);
         v->config()->configEnd();
         v->rendererConfig()->configEnd();
     }
     return true;
 }
 
 void KTextEditor::DocumentPrivate::readVariableLine(const QString &t, bool onlyViewAndRenderer)
 {
     static const QRegularExpression kvLine(QStringLiteral("kate:(.*)"));
     static const QRegularExpression kvLineWildcard(QStringLiteral("kate-wildcard\\((.*)\\):(.*)"));
     static const QRegularExpression kvLineMime(QStringLiteral("kate-mimetype\\((.*)\\):(.*)"));
     static const QRegularExpression kvVar(QStringLiteral("([\\w\\-]+)\\s+([^;]+)"));
 
     // simple check first, no regex
     // no kate inside, no vars, simple...
     if (!t.contains(QLatin1String("kate"))) {
         return;
     }
 
     // found vars, if any
     QString s;
 
     // now, try first the normal ones
     auto match = kvLine.match(t);
     if (match.hasMatch()) {
         s = match.captured(1);
 
         // qCDebug(LOG_KTE) << "normal variable line kate: matched: " << s;
     } else if ((match = kvLineWildcard.match(t)).hasMatch()) { // regex given
         const QStringList wildcards(match.captured(1).split(QLatin1Char(';'), Qt::SkipEmptyParts));
         const QString nameOfFile = url().fileName();
         const QString pathOfFile = url().path();
 
         bool found = false;
         for (const QString &pattern : wildcards) {
             // wildcard with path match, bug 453541, check for /
             // in that case we do some not anchored matching
             const bool matchPath = pattern.contains(QLatin1Char('/'));
             const QRegularExpression wildcard(QRegularExpression::wildcardToRegularExpression(pattern,
                                                                                               matchPath ? QRegularExpression::UnanchoredWildcardConversion
                                                                                                         : QRegularExpression::DefaultWildcardConversion));
             found = wildcard.match(matchPath ? pathOfFile : nameOfFile).hasMatch();
             if (found) {
                 break;
             }
         }
 
         // nothing usable found...
         if (!found) {
             return;
         }
 
         s = match.captured(2);
 
         // qCDebug(LOG_KTE) << "guarded variable line kate-wildcard: matched: " << s;
     } else if ((match = kvLineMime.match(t)).hasMatch()) { // mime-type given
         const QStringList types(match.captured(1).split(QLatin1Char(';'), Qt::SkipEmptyParts));
 
         // no matching type found
         if (!types.contains(mimeType())) {
             return;
         }
 
         s = match.captured(2);
 
         // qCDebug(LOG_KTE) << "guarded variable line kate-mimetype: matched: " << s;
     } else { // nothing found
         return;
     }
 
     // view variable names
     static const auto vvl = {
         QLatin1String("dynamic-word-wrap"),
         QLatin1String("dynamic-word-wrap-indicators"),
         QLatin1String("line-numbers"),
         QLatin1String("icon-border"),
         QLatin1String("folding-markers"),
         QLatin1String("folding-preview"),
         QLatin1String("bookmark-sorting"),
         QLatin1String("auto-center-lines"),
         QLatin1String("icon-bar-color"),
         QLatin1String("scrollbar-minimap"),
         QLatin1String("scrollbar-preview"),
         QLatin1String("enter-to-insert-completion")
         // renderer
         ,
         QLatin1String("background-color"),
         QLatin1String("selection-color"),
         QLatin1String("current-line-color"),
         QLatin1String("bracket-highlight-color"),
         QLatin1String("word-wrap-marker-color"),
         QLatin1String("font"),
         QLatin1String("font-size"),
         QLatin1String("scheme"),
     };
     int spaceIndent = -1; // for backward compatibility; see below
     bool replaceTabsSet = false;
     int startPos(0);
 
     QString var;
     QString val;
     while ((match = kvVar.match(s, startPos)).hasMatch()) {
         startPos = match.capturedEnd(0);
         var = match.captured(1);
         val = match.captured(2).trimmed();
         bool state; // store booleans here
         int n; // store ints here
 
         // only apply view & renderer config stuff
         if (onlyViewAndRenderer) {
             if (contains(vvl, var)) { // FIXME define above
                 setViewVariable(var, val);
             }
         } else {
             // BOOL  SETTINGS
             if (var == QLatin1String("word-wrap") && checkBoolValue(val, &state)) {
                 setWordWrap(state); // ??? FIXME CHECK
             }
             // KateConfig::configFlags
             // FIXME should this be optimized to only a few calls? how?
             else if (var == QLatin1String("backspace-indents") && checkBoolValue(val, &state)) {
                 m_config->setBackspaceIndents(state);
             } else if (var == QLatin1String("indent-pasted-text") && checkBoolValue(val, &state)) {
                 m_config->setIndentPastedText(state);
             } else if (var == QLatin1String("replace-tabs") && checkBoolValue(val, &state)) {
                 m_config->setReplaceTabsDyn(state);
                 replaceTabsSet = true; // for backward compatibility; see below
             } else if (var == QLatin1String("remove-trailing-space") && checkBoolValue(val, &state)) {
                 qCWarning(LOG_KTE) << i18n(
                     "Using deprecated modeline 'remove-trailing-space'. "
                     "Please replace with 'remove-trailing-spaces modified;', see "
                     "https://docs.kde.org/?application=katepart&branch=stable5&path=config-variables.html#variable-remove-trailing-spaces");
                 m_config->setRemoveSpaces(state ? 1 : 0);
             } else if (var == QLatin1String("replace-trailing-space-save") && checkBoolValue(val, &state)) {
                 qCWarning(LOG_KTE) << i18n(
                     "Using deprecated modeline 'replace-trailing-space-save'. "
                     "Please replace with 'remove-trailing-spaces all;', see "
                     "https://docs.kde.org/?application=katepart&branch=stable5&path=config-variables.html#variable-remove-trailing-spaces");
                 m_config->setRemoveSpaces(state ? 2 : 0);
             } else if (var == QLatin1String("overwrite-mode") && checkBoolValue(val, &state)) {
                 m_config->setOvr(state);
             } else if (var == QLatin1String("keep-extra-spaces") && checkBoolValue(val, &state)) {
                 m_config->setKeepExtraSpaces(state);
             } else if (var == QLatin1String("tab-indents") && checkBoolValue(val, &state)) {
                 m_config->setTabIndents(state);
             } else if (var == QLatin1String("show-tabs") && checkBoolValue(val, &state)) {
                 m_config->setShowTabs(state);
             } else if (var == QLatin1String("show-trailing-spaces") && checkBoolValue(val, &state)) {
                 m_config->setShowSpaces(state ? KateDocumentConfig::Trailing : KateDocumentConfig::None);
             } else if (var == QLatin1String("space-indent") && checkBoolValue(val, &state)) {
                 // this is for backward compatibility; see below
                 spaceIndent = state;
             } else if (var == QLatin1String("smart-home") && checkBoolValue(val, &state)) {
                 m_config->setSmartHome(state);
             } else if (var == QLatin1String("newline-at-eof") && checkBoolValue(val, &state)) {
                 m_config->setNewLineAtEof(state);
             }
 
             // INTEGER SETTINGS
             else if (var == QLatin1String("tab-width") && checkIntValue(val, &n)) {
                 m_config->setTabWidth(n);
             } else if (var == QLatin1String("indent-width") && checkIntValue(val, &n)) {
                 m_config->setIndentationWidth(n);
             } else if (var == QLatin1String("indent-mode")) {
                 m_config->setIndentationMode(val);
             } else if (var == QLatin1String("word-wrap-column") && checkIntValue(val, &n) && n > 0) { // uint, but hard word wrap at 0 will be no fun ;)
                 m_config->setWordWrapAt(n);
             }
 
             // STRING SETTINGS
             else if (var == QLatin1String("eol") || var == QLatin1String("end-of-line")) {
                 const auto l = {QLatin1String("unix"), QLatin1String("dos"), QLatin1String("mac")};
                 if ((n = indexOf(l, val.toLower())) != -1) {
                     // set eol + avoid that it is overwritten by auto-detection again!
                     // this fixes e.g. .kateconfig files with // kate: eol dos; to work, bug 365705
                     m_config->setEol(n);
                     m_config->setAllowEolDetection(false);
                 }
             } else if (var == QLatin1String("bom") || var == QLatin1String("byte-order-mark") || var == QLatin1String("byte-order-marker")) {
                 if (checkBoolValue(val, &state)) {
                     m_config->setBom(state);
                 }
             } else if (var == QLatin1String("remove-trailing-spaces")) {
                 val = val.toLower();
                 if (val == QLatin1String("1") || val == QLatin1String("modified") || val == QLatin1String("mod") || val == QLatin1String("+")) {
                     m_config->setRemoveSpaces(1);
                 } else if (val == QLatin1String("2") || val == QLatin1String("all") || val == QLatin1String("*")) {
                     m_config->setRemoveSpaces(2);
                 } else {
                     m_config->setRemoveSpaces(0);
                 }
             } else if (var == QLatin1String("syntax") || var == QLatin1String("hl")) {
                 setHighlightingMode(val);
             } else if (var == QLatin1String("mode")) {
                 setMode(val);
             } else if (var == QLatin1String("encoding")) {
                 setEncoding(val);
             } else if (var == QLatin1String("default-dictionary")) {
                 setDefaultDictionary(val);
             } else if (var == QLatin1String("automatic-spell-checking") && checkBoolValue(val, &state)) {
                 onTheFlySpellCheckingEnabled(state);
             }
 
             // VIEW SETTINGS
             else if (contains(vvl, var)) {
                 setViewVariable(var, val);
             } else {
                 m_storedVariables[var] = val;
             }
         }
     }
 
     // Backward compatibility
     // If space-indent was set, but replace-tabs was not set, we assume
     // that the user wants to replace tabulators and set that flag.
     // If both were set, replace-tabs has precedence.
     // At this point spaceIndent is -1 if it was never set,
     // 0 if it was set to off, and 1 if it was set to on.
     // Note that if onlyViewAndRenderer was requested, spaceIndent is -1.
     if (!replaceTabsSet && spaceIndent >= 0) {
         m_config->setReplaceTabsDyn(spaceIndent > 0);
     }
 }
 
 void KTextEditor::DocumentPrivate::setViewVariable(const QString &var, const QString &val)
 {
     bool state = false;
     int n = 0;
     QColor c;
     for (auto view : std::as_const(m_views)) {
         auto v = static_cast<ViewPrivate *>(view);
         // First, try the new config interface
         QVariant help(val); // Special treatment to catch "on"/"off"
         if (checkBoolValue(val, &state)) {
             help = state;
         }
         if (v->config()->setValue(var, help)) {
         } else if (v->rendererConfig()->setValue(var, help)) {
             // No success? Go the old way
         } else if (var == QLatin1String("dynamic-word-wrap") && checkBoolValue(val, &state)) {
             v->config()->setDynWordWrap(state);
         } else if (var == QLatin1String("block-selection") && checkBoolValue(val, &state)) {
             v->setBlockSelection(state);
 
             // else if ( var = "dynamic-word-wrap-indicators" )
         } else if (var == QLatin1String("icon-bar-color") && checkColorValue(val, c)) {
             v->rendererConfig()->setIconBarColor(c);
         }
         // RENDERER
         else if (var == QLatin1String("background-color") && checkColorValue(val, c)) {
             v->rendererConfig()->setBackgroundColor(c);
         } else if (var == QLatin1String("selection-color") && checkColorValue(val, c)) {
             v->rendererConfig()->setSelectionColor(c);
         } else if (var == QLatin1String("current-line-color") && checkColorValue(val, c)) {
             v->rendererConfig()->setHighlightedLineColor(c);
         } else if (var == QLatin1String("bracket-highlight-color") && checkColorValue(val, c)) {
             v->rendererConfig()->setHighlightedBracketColor(c);
         } else if (var == QLatin1String("word-wrap-marker-color") && checkColorValue(val, c)) {
             v->rendererConfig()->setWordWrapMarkerColor(c);
         } else if (var == QLatin1String("font") || (checkIntValue(val, &n) && n > 0 && var == QLatin1String("font-size"))) {
             QFont _f(v->renderer()->currentFont());
 
             if (var == QLatin1String("font")) {
                 _f.setFamily(val);
                 _f.setFixedPitch(QFont(val).fixedPitch());
             } else {
                 _f.setPointSize(n);
             }
 
             v->rendererConfig()->setFont(_f);
         } else if (var == QLatin1String("scheme")) {
             v->rendererConfig()->setSchema(val);
         }
     }
 }
 
 bool KTextEditor::DocumentPrivate::checkBoolValue(QString val, bool *result)
 {
     val = val.trimmed().toLower();
     static const auto trueValues = {QLatin1String("1"), QLatin1String("on"), QLatin1String("true")};
     if (contains(trueValues, val)) {
         *result = true;
         return true;
     }
 
     static const auto falseValues = {QLatin1String("0"), QLatin1String("off"), QLatin1String("false")};
     if (contains(falseValues, val)) {
         *result = false;
         return true;
     }
     return false;
 }
 
 bool KTextEditor::DocumentPrivate::checkIntValue(const QString &val, int *result)
 {
     bool ret(false);
     *result = val.toInt(&ret);
     return ret;
 }
 
 bool KTextEditor::DocumentPrivate::checkColorValue(const QString &val, QColor &c)
 {
     c = QColor::fromString(val);
     return c.isValid();
 }
 
 // KTextEditor::variable
 QString KTextEditor::DocumentPrivate::variable(const QString &name) const
 {
     auto it = m_storedVariables.find(name);
     if (it == m_storedVariables.end()) {
         return QString();
     }
     return it->second;
 }
 
 void KTextEditor::DocumentPrivate::setVariable(const QString &name, const QString &value)
 {
     QString s = QStringLiteral("kate: ");
     s.append(name);
     s.append(QLatin1Char(' '));
     s.append(value);
     readVariableLine(s);
 }
 
 // END
 
 void KTextEditor::DocumentPrivate::slotModOnHdDirty(const QString &path)
 {
     if ((path == m_dirWatchFile) && (!m_modOnHd || m_modOnHdReason != OnDiskModified)) {
         m_modOnHd = true;
         m_modOnHdReason = OnDiskModified;
 
         if (!m_modOnHdTimer.isActive()) {
             m_modOnHdTimer.start();
         }
     }
 }
 
 void KTextEditor::DocumentPrivate::slotModOnHdCreated(const QString &path)
 {
     if ((path == m_dirWatchFile) && (!m_modOnHd || m_modOnHdReason != OnDiskCreated)) {
         m_modOnHd = true;
         m_modOnHdReason = OnDiskCreated;
 
         if (!m_modOnHdTimer.isActive()) {
             m_modOnHdTimer.start();
         }
     }
 }
 
 void KTextEditor::DocumentPrivate::slotModOnHdDeleted(const QString &path)
 {
     if ((path == m_dirWatchFile) && (!m_modOnHd || m_modOnHdReason != OnDiskDeleted)) {
         m_modOnHd = true;
         m_modOnHdReason = OnDiskDeleted;
 
         if (!m_modOnHdTimer.isActive()) {
             m_modOnHdTimer.start();
         }
     }
 }
 
 void KTextEditor::DocumentPrivate::slotDelayedHandleModOnHd()
 {
     // compare git hash with the one we have (if we have one)
     const QByteArray oldDigest = checksum();
     if (!oldDigest.isEmpty() && !url().isEmpty() && url().isLocalFile()) {
         // if current checksum == checksum of new file => unmodified
         if (m_modOnHdReason != OnDiskDeleted && m_modOnHdReason != OnDiskCreated && createDigest() && oldDigest == checksum()) {
             m_modOnHd = false;
             m_modOnHdReason = OnDiskUnmodified;
             m_prevModOnHdReason = OnDiskUnmodified;
         }
 
         // if still modified, try to take a look at git
         // skip that, if document is modified!
         // only do that, if the file is still there, else reload makes no sense!
         // we have a config option to disable this
         if (m_modOnHd && !isModified() && QFile::exists(url().toLocalFile())
             && config()->value(KateDocumentConfig::AutoReloadIfStateIsInVersionControl).toBool()) {
             // we only want to use git from PATH, cache this
             static const QString fullGitPath = QStandardPaths::findExecutable(QStringLiteral("git"));
             if (!fullGitPath.isEmpty()) {
                 QProcess git;
                 const QStringList args{QStringLiteral("cat-file"), QStringLiteral("-e"), QString::fromUtf8(oldDigest.toHex())};
                 git.setWorkingDirectory(url().adjusted(QUrl::RemoveFilename).toLocalFile());
                 git.start(fullGitPath, args);
                 if (git.waitForStarted()) {
                     git.closeWriteChannel();
                     if (git.waitForFinished()) {
                         if (git.exitCode() == 0) {
                             // this hash exists still in git => just reload
                             m_modOnHd = false;
                             m_modOnHdReason = OnDiskUnmodified;
                             m_prevModOnHdReason = OnDiskUnmodified;
                             documentReload();
                         }
                     }
                 }
             }
         }
     }
 
     // emit our signal to the outside!
     Q_EMIT modifiedOnDisk(this, m_modOnHd, m_modOnHdReason);
 }
 
 QByteArray KTextEditor::DocumentPrivate::checksum() const
 {
     return m_buffer->digest();
 }
 
 bool KTextEditor::DocumentPrivate::createDigest()
 {
     QByteArray digest;
 
     if (url().isLocalFile()) {
         QFile f(url().toLocalFile());
         if (f.open(QIODevice::ReadOnly)) {
             // init the hash with the git header
             QCryptographicHash crypto(QCryptographicHash::Sha1);
             const QString header = QStringLiteral("blob %1").arg(f.size());
             crypto.addData(QByteArray(header.toLatin1() + '\0'));
 
             while (!f.atEnd()) {
                 crypto.addData(f.read(256 * 1024));
             }
 
             digest = crypto.result();
         }
     }
 
     // set new digest
     m_buffer->setDigest(digest);
     return !digest.isEmpty();
 }
 
 QString KTextEditor::DocumentPrivate::reasonedMOHString() const
 {
     // squeeze path
     const QString str = KStringHandler::csqueeze(url().toDisplayString(QUrl::PreferLocalFile));
 
     switch (m_modOnHdReason) {
     case OnDiskModified:
         return i18n("The file '%1' was modified on disk.", str);
         break;
     case OnDiskCreated:
         return i18n("The file '%1' was created on disk.", str);
         break;
     case OnDiskDeleted:
         return i18n("The file '%1' was deleted on disk.", str);
         break;
     default:
         return QString();
     }
     Q_UNREACHABLE();
     return QString();
 }
 
 void KTextEditor::DocumentPrivate::removeTrailingSpacesAndAddNewLineAtEof()
 {
     // skip all work if the user doesn't want any adjustments
     const int remove = config()->removeSpaces();
     const bool newLineAtEof = config()->newLineAtEof();
     if (remove == 0 && !newLineAtEof) {
         return;
     }
 
     // temporarily disable static word wrap (see bug #328900)
     const bool wordWrapEnabled = config()->wordWrap();
     if (wordWrapEnabled) {
         setWordWrap(false);
     }
 
     editStart();
 
     // handle trailing space striping if needed
     const int lines = this->lines();
     if (remove != 0) {
         for (int line = 0; line < lines; ++line) {
             Kate::TextLine textline = plainKateTextLine(line);
 
             // remove trailing spaces in entire document, remove = 2
             // remove trailing spaces of touched lines, remove = 1
             // remove trailing spaces of lines saved on disk, remove = 1
             if (remove == 2 || textline.markedAsModified() || textline.markedAsSavedOnDisk()) {
                 const int p = textline.lastChar() + 1;
                 const int l = textline.length() - p;
                 if (l > 0) {
                     editRemoveText(line, p, l);
                 }
             }
         }
     }
 
     // add a trailing empty line if we want a final line break
     // do we need to add a trailing newline char?
     if (newLineAtEof) {
         Q_ASSERT(lines > 0);
         const auto length = lineLength(lines - 1);
         if (length > 0) {
             // ensure the cursor is not wrapped to the next line if at the end of the document
             // see bug 453252
             const auto oldEndOfDocumentCursor = documentEnd();
             std::vector<KTextEditor::ViewPrivate *> viewsToRestoreCursors;
             for (auto view : std::as_const(m_views)) {
                 auto v = static_cast<ViewPrivate *>(view);
                 if (v->cursorPosition() == oldEndOfDocumentCursor) {
                     viewsToRestoreCursors.push_back(v);
                 }
             }
 
             // wrap the last line, this might move the cursor
             editWrapLine(lines - 1, length);
 
             // undo cursor moving
             for (auto v : viewsToRestoreCursors) {
                 v->setCursorPosition(oldEndOfDocumentCursor);
             }
         }
     }
 
     editEnd();
 
     // enable word wrap again, if it was enabled (see bug #328900)
     if (wordWrapEnabled) {
         setWordWrap(true); // see begin of this function
     }
 }
 
 void KTextEditor::DocumentPrivate::removeAllTrailingSpaces()
 {
     editStart();
     const int lines = this->lines();
     for (int line = 0; line < lines; ++line) {
         const Kate::TextLine textline = plainKateTextLine(line);
         const int p = textline.lastChar() + 1;
         const int l = textline.length() - p;
         if (l > 0) {
             editRemoveText(line, p, l);
         }
     }
     editEnd();
 }
 
 bool KTextEditor::DocumentPrivate::updateFileType(const QString &newType, bool user)
 {
     if (user || !m_fileTypeSetByUser) {
         if (newType.isEmpty()) {
             return false;
         }
         KateFileType fileType = KTextEditor::EditorPrivate::self()->modeManager()->fileType(newType);
         // if the mode "newType" does not exist
         if (fileType.name.isEmpty()) {
             return false;
         }
 
         // remember that we got set by user
         m_fileTypeSetByUser = user;
 
         m_fileType = newType;
 
         m_config->configStart();
 
         // NOTE: if the user changes the Mode, the Highlighting also changes.
         // m_hlSetByUser avoids resetting the highlight when saving the document, if
         // the current hl isn't stored (eg, in sftp:// or fish:// files) (see bug #407763)
         if ((user || !m_hlSetByUser) && !fileType.hl.isEmpty()) {
             int hl(KateHlManager::self()->nameFind(fileType.hl));
 
             if (hl >= 0) {
                 m_buffer->setHighlight(hl);
             }
         }
 
         // set the indentation mode, if any in the mode...
         // and user did not set it before!
         // NOTE: KateBuffer::setHighlight() also sets the indentation.
         if (!m_indenterSetByUser && !fileType.indenter.isEmpty()) {
             config()->setIndentationMode(fileType.indenter);
         }
 
         // views!
         for (auto view : std::as_const(m_views)) {
             auto v = static_cast<ViewPrivate *>(view);
             v->config()->configStart();
             v->rendererConfig()->configStart();
         }
 
         bool bom_settings = false;
         if (m_bomSetByUser) {
             bom_settings = m_config->bom();
         }
         readVariableLine(fileType.varLine);
         if (m_bomSetByUser) {
             m_config->setBom(bom_settings);
         }
         m_config->configEnd();
         for (auto view : std::as_const(m_views)) {
             auto v = static_cast<ViewPrivate *>(view);
             v->config()->configEnd();
             v->rendererConfig()->configEnd();
         }
     }
 
     // fixme, make this better...
     Q_EMIT modeChanged(this);
     return true;
 }
 
 void KTextEditor::DocumentPrivate::slotQueryClose_save(bool *handled, bool *abortClosing)
 {
     *handled = true;
     *abortClosing = true;
     if (url().isEmpty()) {
         const QUrl res = getSaveFileUrl(i18n("Save File"));
         if (res.isEmpty()) {
             *abortClosing = true;
             return;
         }
         saveAs(res);
         *abortClosing = false;
     } else {
         save();
         *abortClosing = false;
     }
 }
 
 // BEGIN KTextEditor::ConfigInterface
 
 // BEGIN ConfigInterface stff
 QStringList KTextEditor::DocumentPrivate::configKeys() const
 {
     // expose all internally registered keys of the KateDocumentConfig
     return m_config->configKeys();
 }
 
 QVariant KTextEditor::DocumentPrivate::configValue(const QString &key)
 {
     // just dispatch to internal key => value lookup
     return m_config->value(key);
 }
 
 void KTextEditor::DocumentPrivate::setConfigValue(const QString &key, const QVariant &value)
 {
     // just dispatch to internal key + value set
     m_config->setValue(key, value);
 }
 
 // END KTextEditor::ConfigInterface
 
 KTextEditor::Cursor KTextEditor::DocumentPrivate::documentEnd() const
 {
     return KTextEditor::Cursor(lastLine(), lineLength(lastLine()));
 }
 
 bool KTextEditor::DocumentPrivate::replaceText(KTextEditor::Range range, const QString &s, bool block)
 {
     // TODO more efficient?
     editStart();
     bool changed = removeText(range, block);
     changed |= insertText(range.start(), s, block);
     editEnd();
     return changed;
 }
 
 KateHighlighting *KTextEditor::DocumentPrivate::highlight() const
 {
     return m_buffer->highlight();
 }
 
 Kate::TextLine KTextEditor::DocumentPrivate::kateTextLine(int i)
 {
     m_buffer->ensureHighlighted(i);
     return m_buffer->plainLine(i);
 }
 
 Kate::TextLine KTextEditor::DocumentPrivate::plainKateTextLine(int i)
 {
     return m_buffer->plainLine(i);
 }
 
 bool KTextEditor::DocumentPrivate::isEditRunning() const
 {
     return editIsRunning;
 }
 
 void KTextEditor::DocumentPrivate::setUndoMergeAllEdits(bool merge)
 {
     if (merge && m_undoMergeAllEdits) {
         // Don't add another undo safe point: it will override our current one,
         // meaning we'll need two undo's to get back there - which defeats the object!
         return;
     }
     m_undoManager->undoSafePoint();
     m_undoManager->setAllowComplexMerge(merge);
     m_undoMergeAllEdits = merge;
 }
 
 // BEGIN KTextEditor::MovingInterface
 KTextEditor::MovingCursor *KTextEditor::DocumentPrivate::newMovingCursor(KTextEditor::Cursor position, KTextEditor::MovingCursor::InsertBehavior insertBehavior)
 {
     return new Kate::TextCursor(buffer(), position, insertBehavior);
 }
 
 KTextEditor::MovingRange *KTextEditor::DocumentPrivate::newMovingRange(KTextEditor::Range range,
                                                                        KTextEditor::MovingRange::InsertBehaviors insertBehaviors,
                                                                        KTextEditor::MovingRange::EmptyBehavior emptyBehavior)
 {
     return new Kate::TextRange(buffer(), range, insertBehaviors, emptyBehavior);
 }
 
 qint64 KTextEditor::DocumentPrivate::revision() const
 {
     return m_buffer->history().revision();
 }
 
 qint64 KTextEditor::DocumentPrivate::lastSavedRevision() const
 {
     return m_buffer->history().lastSavedRevision();
 }
 
 void KTextEditor::DocumentPrivate::lockRevision(qint64 revision)
 {
     m_buffer->history().lockRevision(revision);
 }
 
 void KTextEditor::DocumentPrivate::unlockRevision(qint64 revision)
 {
     m_buffer->history().unlockRevision(revision);
 }
 
 void KTextEditor::DocumentPrivate::transformCursor(int &line,
                                                    int &column,
                                                    KTextEditor::MovingCursor::InsertBehavior insertBehavior,
                                                    qint64 fromRevision,
                                                    qint64 toRevision)
 {
     m_buffer->history().transformCursor(line, column, insertBehavior, fromRevision, toRevision);
 }
 
 void KTextEditor::DocumentPrivate::transformCursor(KTextEditor::Cursor &cursor,
                                                    KTextEditor::MovingCursor::InsertBehavior insertBehavior,
                                                    qint64 fromRevision,
                                                    qint64 toRevision)
 {
     int line = cursor.line();
     int column = cursor.column();
     m_buffer->history().transformCursor(line, column, insertBehavior, fromRevision, toRevision);
     cursor.setPosition(line, column);
 }
 
 void KTextEditor::DocumentPrivate::transformRange(KTextEditor::Range &range,
                                                   KTextEditor::MovingRange::InsertBehaviors insertBehaviors,
                                                   KTextEditor::MovingRange::EmptyBehavior emptyBehavior,
                                                   qint64 fromRevision,
                                                   qint64 toRevision)
 {
     m_buffer->history().transformRange(range, insertBehaviors, emptyBehavior, fromRevision, toRevision);
 }
 
 // END
 
 // BEGIN KTextEditor::AnnotationInterface
 void KTextEditor::DocumentPrivate::setAnnotationModel(KTextEditor::AnnotationModel *model)
 {
     KTextEditor::AnnotationModel *oldmodel = m_annotationModel;
     m_annotationModel = model;
     Q_EMIT annotationModelChanged(oldmodel, m_annotationModel);
 }
 
 KTextEditor::AnnotationModel *KTextEditor::DocumentPrivate::annotationModel() const
 {
     return m_annotationModel;
 }
 // END KTextEditor::AnnotationInterface
 
 // TAKEN FROM kparts.h
 bool KTextEditor::DocumentPrivate::queryClose()
 {
     if (!isModified() || (isEmpty() && url().isEmpty())) {
         return true;
     }
 
     QString docName = documentName();
 
     int res = KMessageBox::warningTwoActionsCancel(dialogParent(),
                                                    i18n("The document \"%1\" has been modified.\n"
                                                         "Do you want to save your changes or discard them?",
                                                         docName),
                                                    i18n("Close Document"),
                                                    KStandardGuiItem::save(),
                                                    KStandardGuiItem::discard());
 
     bool abortClose = false;
     bool handled = false;
 
     switch (res) {
     case KMessageBox::PrimaryAction:
         sigQueryClose(&handled, &abortClose);
         if (!handled) {
             if (url().isEmpty()) {
                 const QUrl url = getSaveFileUrl(i18n("Save File"));
                 if (url.isEmpty()) {
                     return false;
                 }
 
                 saveAs(url);
             } else {
                 save();
             }
         } else if (abortClose) {
             return false;
         }
         return waitSaveComplete();
     case KMessageBox::SecondaryAction:
         return true;
     default: // case KMessageBox::Cancel :
         return false;
     }
 }
 
 void KTextEditor::DocumentPrivate::slotStarted(KIO::Job *job)
 {
     // if we are idle before, we are now loading!
     if (m_documentState == DocumentIdle) {
         m_documentState = DocumentLoading;
     }
 
     // if loading:
     // - remember pre loading read-write mode
     // if remote load:
     // - set to read-only
     // - trigger possible message
     if (m_documentState == DocumentLoading) {
         // remember state
         m_readWriteStateBeforeLoading = isReadWrite();
 
         // perhaps show loading message, but wait one second
         if (job) {
             // only read only if really remote file!
             setReadWrite(false);
 
             // perhaps some message about loading in one second!
             // remember job pointer, we want to be able to kill it!
             m_loadingJob = job;
             QTimer::singleShot(1000, this, SLOT(slotTriggerLoadingMessage()));
         }
     }
 }
 
 void KTextEditor::DocumentPrivate::slotCompleted()
 {
     // if were loading, reset back to old read-write mode before loading
     // and kill the possible loading message
     if (m_documentState == DocumentLoading) {
         setReadWrite(m_readWriteStateBeforeLoading);
         delete m_loadingMessage;
     }
 
     // Emit signal that we saved  the document, if needed
     if (m_documentState == DocumentSaving || m_documentState == DocumentSavingAs) {
         Q_EMIT documentSavedOrUploaded(this, m_documentState == DocumentSavingAs);
     }
 
     // back to idle mode
     m_documentState = DocumentIdle;
     m_reloading = false;
 }
 
 void KTextEditor::DocumentPrivate::slotCanceled()
 {
     // if were loading, reset back to old read-write mode before loading
     // and kill the possible loading message
     if (m_documentState == DocumentLoading) {
         setReadWrite(m_readWriteStateBeforeLoading);
         delete m_loadingMessage;
 
         if (!m_openingError) {
             showAndSetOpeningErrorAccess();
         }
 
         updateDocName();
     }
 
     // back to idle mode
     m_documentState = DocumentIdle;
     m_reloading = false;
 }
 
 void KTextEditor::DocumentPrivate::slotTriggerLoadingMessage()
 {
     // no longer loading?
     // no message needed!
     if (m_documentState != DocumentLoading) {
         return;
     }
 
     // create message about file loading in progress
     delete m_loadingMessage;
     m_loadingMessage =
         new KTextEditor::Message(i18n("The file <a href=\"%1\">%2</a> is still loading.", url().toDisplayString(QUrl::PreferLocalFile), url().fileName()));
     m_loadingMessage->setPosition(KTextEditor::Message::TopInView);
 
     // if around job: add cancel action
     if (m_loadingJob) {
         QAction *cancel = new QAction(i18n("&Abort Loading"), nullptr);
         connect(cancel, &QAction::triggered, this, &KTextEditor::DocumentPrivate::slotAbortLoading);
         m_loadingMessage->addAction(cancel);
     }
 
     // really post message
     postMessage(m_loadingMessage);
 }
 
 void KTextEditor::DocumentPrivate::slotAbortLoading()
 {
     // no job, no work
     if (!m_loadingJob) {
         return;
     }
 
     // abort loading if any job
     // signal results!
     m_loadingJob->kill(KJob::EmitResult);
     m_loadingJob = nullptr;
 }
 
 void KTextEditor::DocumentPrivate::slotUrlChanged(const QUrl &url)
 {
     if (m_reloading) {
         // the URL is temporarily unset and then reset to the previous URL during reload
         // we do not want to notify the outside about this
         return;
     }
 
     Q_UNUSED(url);
     updateDocName();
     Q_EMIT documentUrlChanged(this);
 }
 
 bool KTextEditor::DocumentPrivate::save()
 {
     // no double save/load
     // we need to allow DocumentPreSavingAs here as state, as save is called in saveAs!
     if ((m_documentState != DocumentIdle) && (m_documentState != DocumentPreSavingAs)) {
         return false;
     }
 
     // if we are idle, we are now saving
     if (m_documentState == DocumentIdle) {
         m_documentState = DocumentSaving;
     } else {
         m_documentState = DocumentSavingAs;
     }
 
     // let anyone listening know that we are going to save
     Q_EMIT aboutToSave(this);
 
     // call back implementation for real work
     return KTextEditor::Document::save();
 }
 
 bool KTextEditor::DocumentPrivate::saveAs(const QUrl &url)
 {
     // abort on bad URL
     // that is done in saveAs below, too
     // but we must check it here already to avoid messing up
     // as no signals will be send, then
     if (!url.isValid()) {
         return false;
     }
 
     // no double save/load
     if (m_documentState != DocumentIdle) {
         return false;
     }
 
     // we enter the pre save as phase
     m_documentState = DocumentPreSavingAs;
 
     // call base implementation for real work
     return KTextEditor::Document::saveAs(url);
 }
 
 QString KTextEditor::DocumentPrivate::defaultDictionary() const
 {
     return m_defaultDictionary;
 }
 
 QList<QPair<KTextEditor::MovingRange *, QString>> KTextEditor::DocumentPrivate::dictionaryRanges() const
 {
     return m_dictionaryRanges;
 }
 
 void KTextEditor::DocumentPrivate::clearDictionaryRanges()
 {
     for (auto i = m_dictionaryRanges.cbegin(); i != m_dictionaryRanges.cend(); ++i) {
         delete (*i).first;
     }
     m_dictionaryRanges.clear();
     if (m_onTheFlyChecker) {
         m_onTheFlyChecker->refreshSpellCheck();
     }
     Q_EMIT dictionaryRangesPresent(false);
 }
 
 void KTextEditor::DocumentPrivate::setDictionary(const QString &newDictionary, KTextEditor::Range range, bool blockmode)
 {
     if (blockmode) {
         for (int i = range.start().line(); i <= range.end().line(); ++i) {
             setDictionary(newDictionary, rangeOnLine(range, i));
         }
     } else {
         setDictionary(newDictionary, range);
     }
 
     Q_EMIT dictionaryRangesPresent(!m_dictionaryRanges.isEmpty());
 }
 
 void KTextEditor::DocumentPrivate::setDictionary(const QString &newDictionary, KTextEditor::Range range)
 {
     KTextEditor::Range newDictionaryRange = range;
     if (!newDictionaryRange.isValid() || newDictionaryRange.isEmpty()) {
         return;
     }
     QList<QPair<KTextEditor::MovingRange *, QString>> newRanges;
     // all ranges is 'm_dictionaryRanges' are assumed to be mutually disjoint
     for (auto i = m_dictionaryRanges.begin(); i != m_dictionaryRanges.end();) {
         qCDebug(LOG_KTE) << "new iteration" << newDictionaryRange;
         if (newDictionaryRange.isEmpty()) {
             break;
         }
         QPair<KTextEditor::MovingRange *, QString> pair = *i;
         QString dictionarySet = pair.second;
         KTextEditor::MovingRange *dictionaryRange = pair.first;
         qCDebug(LOG_KTE) << *dictionaryRange << dictionarySet;
         if (dictionaryRange->contains(newDictionaryRange) && newDictionary == dictionarySet) {
             qCDebug(LOG_KTE) << "dictionaryRange contains newDictionaryRange";
             return;
         }
         if (newDictionaryRange.contains(*dictionaryRange)) {
             delete dictionaryRange;
             i = m_dictionaryRanges.erase(i);
             qCDebug(LOG_KTE) << "newDictionaryRange contains dictionaryRange";
             continue;
         }
 
         KTextEditor::Range intersection = dictionaryRange->toRange().intersect(newDictionaryRange);
         if (!intersection.isEmpty() && intersection.isValid()) {
             if (dictionarySet == newDictionary) { // we don't have to do anything for 'intersection'
                 // except cut off the intersection
                 QList<KTextEditor::Range> remainingRanges = KateSpellCheckManager::rangeDifference(newDictionaryRange, intersection);
                 Q_ASSERT(remainingRanges.size() == 1);
                 newDictionaryRange = remainingRanges.first();
                 ++i;
                 qCDebug(LOG_KTE) << "dictionarySet == newDictionary";
                 continue;
             }
             QList<KTextEditor::Range> remainingRanges = KateSpellCheckManager::rangeDifference(*dictionaryRange, intersection);
             for (auto j = remainingRanges.begin(); j != remainingRanges.end(); ++j) {
                 KTextEditor::MovingRange *remainingRange = newMovingRange(*j, KTextEditor::MovingRange::ExpandLeft | KTextEditor::MovingRange::ExpandRight);
                 remainingRange->setFeedback(this);
                 newRanges.push_back({remainingRange, dictionarySet});
             }
             i = m_dictionaryRanges.erase(i);
             delete dictionaryRange;
         } else {
             ++i;
         }
     }
     m_dictionaryRanges += newRanges;
     if (!newDictionaryRange.isEmpty() && !newDictionary.isEmpty()) { // we don't add anything for the default dictionary
         KTextEditor::MovingRange *newDictionaryMovingRange =
             newMovingRange(newDictionaryRange, KTextEditor::MovingRange::ExpandLeft | KTextEditor::MovingRange::ExpandRight);
         newDictionaryMovingRange->setFeedback(this);
         m_dictionaryRanges.push_back({newDictionaryMovingRange, newDictionary});
     }
     if (m_onTheFlyChecker && !newDictionaryRange.isEmpty()) {
         m_onTheFlyChecker->refreshSpellCheck(newDictionaryRange);
     }
 }
 
 void KTextEditor::DocumentPrivate::setDefaultDictionary(const QString &dict)
 {
     if (m_defaultDictionary == dict) {
         return;
     }
 
     m_defaultDictionary = dict;
 
     if (m_onTheFlyChecker) {
         m_onTheFlyChecker->updateConfig();
         refreshOnTheFlyCheck();
     }
     Q_EMIT defaultDictionaryChanged(this);
 }
 
 void KTextEditor::DocumentPrivate::onTheFlySpellCheckingEnabled(bool enable)
 {
     if (isOnTheFlySpellCheckingEnabled() == enable) {
         return;
     }
 
     if (enable) {
         Q_ASSERT(m_onTheFlyChecker == nullptr);
         m_onTheFlyChecker = new KateOnTheFlyChecker(this);
     } else {
         delete m_onTheFlyChecker;
         m_onTheFlyChecker = nullptr;
     }
 
     for (auto view : std::as_const(m_views)) {
         static_cast<ViewPrivate *>(view)->reflectOnTheFlySpellCheckStatus(enable);
     }
 }
 
 bool KTextEditor::DocumentPrivate::isOnTheFlySpellCheckingEnabled() const
 {
     return m_onTheFlyChecker != nullptr;
 }
 
 QString KTextEditor::DocumentPrivate::dictionaryForMisspelledRange(KTextEditor::Range range) const
 {
     if (!m_onTheFlyChecker) {
         return QString();
     } else {
         return m_onTheFlyChecker->dictionaryForMisspelledRange(range);
     }
 }
 
 void KTextEditor::DocumentPrivate::clearMisspellingForWord(const QString &word)
 {
     if (m_onTheFlyChecker) {
         m_onTheFlyChecker->clearMisspellingForWord(word);
     }
 }
 
 void KTextEditor::DocumentPrivate::refreshOnTheFlyCheck(KTextEditor::Range range)
 {
     if (m_onTheFlyChecker) {
         m_onTheFlyChecker->refreshSpellCheck(range);
     }
 }
 
 void KTextEditor::DocumentPrivate::rangeInvalid(KTextEditor::MovingRange *movingRange)
 {
     deleteDictionaryRange(movingRange);
 }
 
 void KTextEditor::DocumentPrivate::rangeEmpty(KTextEditor::MovingRange *movingRange)
 {
     deleteDictionaryRange(movingRange);
 }
 
 void KTextEditor::DocumentPrivate::deleteDictionaryRange(KTextEditor::MovingRange *movingRange)
 {
     qCDebug(LOG_KTE) << "deleting" << movingRange;
 
     auto finder = [=](const QPair<KTextEditor::MovingRange *, QString> &item) -> bool {
         return item.first == movingRange;
     };
 
     auto it = std::find_if(m_dictionaryRanges.begin(), m_dictionaryRanges.end(), finder);
 
     if (it != m_dictionaryRanges.end()) {
         m_dictionaryRanges.erase(it);
         delete movingRange;
     }
 
     Q_ASSERT(std::find_if(m_dictionaryRanges.begin(), m_dictionaryRanges.end(), finder) == m_dictionaryRanges.end());
 }
 
 bool KTextEditor::DocumentPrivate::containsCharacterEncoding(KTextEditor::Range range)
 {
     KateHighlighting *highlighting = highlight();
 
     const int rangeStartLine = range.start().line();
     const int rangeStartColumn = range.start().column();
     const int rangeEndLine = range.end().line();
     const int rangeEndColumn = range.end().column();
 
     for (int line = range.start().line(); line <= rangeEndLine; ++line) {
         const Kate::TextLine textLine = kateTextLine(line);
         const int startColumn = (line == rangeStartLine) ? rangeStartColumn : 0;
         const int endColumn = (line == rangeEndLine) ? rangeEndColumn : textLine.length();
         for (int col = startColumn; col < endColumn; ++col) {
             int attr = textLine.attribute(col);
             const KatePrefixStore &prefixStore = highlighting->getCharacterEncodingsPrefixStore(attr);
             if (!prefixStore.findPrefix(textLine, col).isEmpty()) {
                 return true;
             }
         }
     }
 
     return false;
 }
 
 int KTextEditor::DocumentPrivate::computePositionWrtOffsets(const OffsetList &offsetList, int pos)
 {
     int previousOffset = 0;
     for (auto i = offsetList.cbegin(); i != offsetList.cend(); ++i) {
         if (i->first > pos) {
             break;
         }
         previousOffset = i->second;
     }
     return pos + previousOffset;
 }
 
 QString KTextEditor::DocumentPrivate::decodeCharacters(KTextEditor::Range range,
                                                        KTextEditor::DocumentPrivate::OffsetList &decToEncOffsetList,
                                                        KTextEditor::DocumentPrivate::OffsetList &encToDecOffsetList)
 {
     QString toReturn;
     KTextEditor::Cursor previous = range.start();
     int decToEncCurrentOffset = 0;
     int encToDecCurrentOffset = 0;
     int i = 0;
     int newI = 0;
 
     KateHighlighting *highlighting = highlight();
     Kate::TextLine textLine;
 
     const int rangeStartLine = range.start().line();
     const int rangeStartColumn = range.start().column();
     const int rangeEndLine = range.end().line();
     const int rangeEndColumn = range.end().column();
 
     for (int line = range.start().line(); line <= rangeEndLine; ++line) {
         textLine = kateTextLine(line);
         int startColumn = (line == rangeStartLine) ? rangeStartColumn : 0;
         int endColumn = (line == rangeEndLine) ? rangeEndColumn : textLine.length();
         for (int col = startColumn; col < endColumn;) {
             int attr = textLine.attribute(col);
             const KatePrefixStore &prefixStore = highlighting->getCharacterEncodingsPrefixStore(attr);
             const QHash<QString, QChar> &characterEncodingsHash = highlighting->getCharacterEncodings(attr);
             QString matchingPrefix = prefixStore.findPrefix(textLine, col);
             if (!matchingPrefix.isEmpty()) {
                 toReturn += text(KTextEditor::Range(previous, KTextEditor::Cursor(line, col)));
                 const QChar &c = characterEncodingsHash.value(matchingPrefix);
                 const bool isNullChar = c.isNull();
                 if (!c.isNull()) {
                     toReturn += c;
                 }
                 i += matchingPrefix.length();
                 col += matchingPrefix.length();
                 previous = KTextEditor::Cursor(line, col);
                 decToEncCurrentOffset = decToEncCurrentOffset - (isNullChar ? 0 : 1) + matchingPrefix.length();
                 encToDecCurrentOffset = encToDecCurrentOffset - matchingPrefix.length() + (isNullChar ? 0 : 1);
                 newI += (isNullChar ? 0 : 1);
                 decToEncOffsetList.push_back(QPair<int, int>(newI, decToEncCurrentOffset));
                 encToDecOffsetList.push_back(QPair<int, int>(i, encToDecCurrentOffset));
                 continue;
             }
             ++col;
             ++i;
             ++newI;
         }
         ++i;
         ++newI;
     }
     if (previous < range.end()) {
         toReturn += text(KTextEditor::Range(previous, range.end()));
     }
     return toReturn;
 }
 
 void KTextEditor::DocumentPrivate::replaceCharactersByEncoding(KTextEditor::Range range)
 {
     KateHighlighting *highlighting = highlight();
     Kate::TextLine textLine;
 
     const int rangeStartLine = range.start().line();
     const int rangeStartColumn = range.start().column();
     const int rangeEndLine = range.end().line();
     const int rangeEndColumn = range.end().column();
 
     for (int line = range.start().line(); line <= rangeEndLine; ++line) {
         textLine = kateTextLine(line);
         int startColumn = (line == rangeStartLine) ? rangeStartColumn : 0;
         int endColumn = (line == rangeEndLine) ? rangeEndColumn : textLine.length();
         for (int col = startColumn; col < endColumn;) {
             int attr = textLine.attribute(col);
             const QHash<QChar, QString> &reverseCharacterEncodingsHash = highlighting->getReverseCharacterEncodings(attr);
             auto it = reverseCharacterEncodingsHash.find(textLine.at(col));
             if (it != reverseCharacterEncodingsHash.end()) {
                 replaceText(KTextEditor::Range(line, col, line, col + 1), *it);
                 col += (*it).length();
                 continue;
             }
             ++col;
         }
     }
 }
 
 //
 // Highlighting information
 //
 
 QStringList KTextEditor::DocumentPrivate::embeddedHighlightingModes() const
 {
     return highlight()->getEmbeddedHighlightingModes();
 }
 
 QString KTextEditor::DocumentPrivate::highlightingModeAt(KTextEditor::Cursor position)
 {
     return highlight()->higlightingModeForLocation(this, position);
 }
 
 Kate::SwapFile *KTextEditor::DocumentPrivate::swapFile()
 {
     return m_swapfile;
 }
 
 /**
  * \return \c -1 if \c line or \c column invalid, otherwise one of
  * standard style attribute number
  */
 KSyntaxHighlighting::Theme::TextStyle KTextEditor::DocumentPrivate::defStyleNum(int line, int column)
 {
     // Validate parameters to prevent out of range access
     if (line < 0 || line >= lines() || column < 0) {
         return KSyntaxHighlighting::Theme::TextStyle::Normal;
     }
 
     // get highlighted line
     Kate::TextLine tl = kateTextLine(line);
 
     // either get char attribute or attribute of context still active at end of line
     int attribute = 0;
     if (column < tl.length()) {
         attribute = tl.attribute(column);
     } else if (column == tl.length()) {
         if (!tl.attributesList().empty()) {
             attribute = tl.attributesList().back().attributeValue;
         } else {
             return KSyntaxHighlighting::Theme::TextStyle::Normal;
         }
     } else {
         return KSyntaxHighlighting::Theme::TextStyle::Normal;
     }
 
     return highlight()->defaultStyleForAttribute(attribute);
 }
 
 bool KTextEditor::DocumentPrivate::isComment(int line, int column)
 {
     return defStyleNum(line, column) == KSyntaxHighlighting::Theme::TextStyle::Comment;
 }
 
 int KTextEditor::DocumentPrivate::findTouchedLine(int startLine, bool down)
 {
     const int offset = down ? 1 : -1;
     const int lineCount = lines();
     while (startLine >= 0 && startLine < lineCount) {
         Kate::TextLine tl = m_buffer->plainLine(startLine);
         if (tl.markedAsModified() || tl.markedAsSavedOnDisk()) {
             return startLine;
         }
         startLine += offset;
     }
 
     return -1;
 }
 
 void KTextEditor::DocumentPrivate::setActiveTemplateHandler(KateTemplateHandler *handler)
 {
     // delete any active template handler
     delete m_activeTemplateHandler.data();
     m_activeTemplateHandler = handler;
 }
 
 // BEGIN KTextEditor::MessageInterface
 bool KTextEditor::DocumentPrivate::postMessage(KTextEditor::Message *message)
 {
     // no message -> cancel
     if (!message) {
         return false;
     }
 
     // make sure the desired view belongs to this document
     if (message->view() && message->view()->document() != this) {
         qCWarning(LOG_KTE) << "trying to post a message to a view of another document:" << message->text();
         return false;
     }
 
     message->setParent(this);
     message->setDocument(this);
 
     // if there are no actions, add a close action by default if widget does not auto-hide
     if (message->actions().count() == 0 && message->autoHide() < 0) {
         QAction *closeAction = new QAction(QIcon::fromTheme(QStringLiteral("window-close")), i18n("&Close"), nullptr);
         closeAction->setToolTip(i18nc("Close the message being displayed", "Close message"));
         message->addAction(closeAction);
     }
 
     // reparent actions, as we want full control over when they are deleted
     QList<std::shared_ptr<QAction>> managedMessageActions;
     const auto messageActions = message->actions();
     managedMessageActions.reserve(messageActions.size());
     for (QAction *action : messageActions) {
         action->setParent(nullptr);
         managedMessageActions.append(std::shared_ptr<QAction>(action));
     }
     m_messageHash.insert(message, managedMessageActions);
 
     // post message to requested view, or to all views
     if (KTextEditor::ViewPrivate *view = qobject_cast<KTextEditor::ViewPrivate *>(message->view())) {
         view->postMessage(message, managedMessageActions);
     } else {
         for (auto view : std::as_const(m_views)) {
             static_cast<ViewPrivate *>(view)->postMessage(message, managedMessageActions);
         }
     }
 
     // also catch if the user manually calls delete message
     connect(message, &Message::closed, this, &DocumentPrivate::messageDestroyed);
 
     return true;
 }
 
 void KTextEditor::DocumentPrivate::messageDestroyed(KTextEditor::Message *message)
 {
     // KTE:Message is already in destructor
     Q_ASSERT(m_messageHash.contains(message));
     m_messageHash.remove(message);
 }
 // END KTextEditor::MessageInterface
 
 #include "moc_katedocument.cpp"