diff --git a/plugins/grepview/kdevgrepview.json b/plugins/grepview/kdevgrepview.json
index 54c743d70e..7ee9d5e9f6 100644
--- a/plugins/grepview/kdevgrepview.json
+++ b/plugins/grepview/kdevgrepview.json
@@ -1,67 +1,67 @@
 {
     "KPlugin": {
         "Category": "Utilities", 
         "Description": "Allows fast searching of multiple files using patterns or regular expressions. And allow to replace it too.", 
         "Description[ar]": "تسمح بالبحث السريع في ملفّات متعدّدة باستخدام أنماط أو تعابير نمطيّة. وتسمح بالاستبدال أيضًا.", 
         "Description[ca@valencia]": "Permet la cerca ràpida de múltiples fitxers usant patrons o expressions regulars. I també permet substitucions.", 
         "Description[ca]": "Permet la cerca ràpida de múltiples fitxers usant patrons o expressions regulars. I també permet substitucions.", 
         "Description[de]": "Ermöglicht es, Dateien mit Hilfe von Mustern und regulären Ausdrücken zu durchsuchen bzw. Ersetzungen vorzunehmen.", 
         "Description[es]": "Permite la búsqueda rápida de múltiples archivos usando patrones o expresiones regulares. También permite realizar sustituciones.", 
         "Description[fi]": "Mahdollistaa nopean useiden tiedostojen etsinnän käyttäen malleja tai säännöllisiä lausekkeita. Sallii myös korvauksen.", 
         "Description[fr]": "Permet de rechercher rapidement dans plusieurs fichiers en utilisant des motifs ou des expressions rationnelles. Et permet de le remplacer aussi.", 
-        "Description[gl]": "Permite facer unha procura rápida en varios ficheiros empregando padróns ou expresións regulares, e tamén realizar substitucións.", 
+        "Description[gl]": "Permite facer unha busca rápida en varios ficheiros empregando padróns ou expresións regulares, e tamén realizar substitucións.", 
         "Description[it]": "Consente la ricerca veloce di file multipli usando espressioni regolari o modelli. E consente anche di sostituirli.", 
         "Description[nl]": "Staat toe snel te zoeken naar meerdere bestanden met gebruik van patronen of reguliere expressies. Staat ook vervanging toe.", 
         "Description[pl]": "Pozwala na szybkie znajdowanie wielu plików wykorzystując wzorce lub regularne wyrażenia. Pozwala także na ich zastępowanie.", 
         "Description[pt]": "Permite a pesquisa rápida em vários ficheiros, usando padrões ou expressões regulares. Permite também a sua substituição.", 
         "Description[pt_BR]": "Permite pesquisar rapidamente em vários arquivos, usando padrões ou expressões regulares e também realizar substituições.", 
         "Description[sk]": "Umožní rýchle hľadanie viacerých súborov pomocou vzorov alebo regulárnych výrazov a umožní ich nahradiť.", 
         "Description[sl]": "Omogoča hitro iskanje po več datotekah z uporabo vzorcev ali regularnih izrazov. Omogoča tudi zamenjave.", 
         "Description[sv]": "Tillåter snabb sökning i flera filer med mönster eller reguljära uttryck, och tillåter dessutom ersättning.", 
         "Description[tr]": "Kalıplar veya düzenli ifadeler kullanarak birden çok dosyada hızlı aramaya izin verir. Yer değiştirmeye de izin verir.", 
         "Description[uk]": "Надає можливості швидкого пошуку та заміни у декількох файлів на основі шаблонів або формальних виразів.", 
         "Description[x-test]": "xxAllows fast searching of multiple files using patterns or regular expressions. And allow to replace it too.xx", 
         "Description[zh_CN]": "可以用模式或正则表达式快速搜索多个文件，还可以替换。", 
         "Icon": "kfind", 
         "Id": "kdevgrepview", 
         "Name": "Find/Replace In Files", 
         "Name[ar]": "اعثر واستبدل في الملفّات", 
         "Name[bg]": "Търсене и заместване във файлове", 
         "Name[bs]": "Nađi/zamijeni u datotekama", 
         "Name[ca@valencia]": "Cerca i substitució en fitxers", 
         "Name[ca]": "Cerca i substitució en fitxers", 
         "Name[cs]": "Hledat-nahradit v souborech", 
         "Name[da]": "Find/erstat i filer", 
         "Name[de]": "In Dateien suchen/ersetzen", 
         "Name[el]": "Αναζήτηση/Αντικατάσταση σε αρχεία", 
         "Name[es]": "Buscar/sustituir en archivos", 
         "Name[et]": "Failides otsimine ja asendamine", 
         "Name[fi]": "Etsi ja korvaa tiedostoista", 
         "Name[fr]": "Rechercher / remplacer dans les fichiers", 
-        "Name[gl]": "Procurar/Substituír nos ficheiros", 
+        "Name[gl]": "Buscar/Substituír nos ficheiros", 
         "Name[hu]": "Keresés/csere fájlokban", 
         "Name[it]": "Trova/Sostituisci nei file", 
         "Name[kk]": "Файлдарда іздеу/ауыстыру", 
         "Name[nb]": "Finn/erstatt i filer", 
         "Name[nds]": "Söken un Utwesseln in Dateien", 
         "Name[nl]": "Zoeken/vervangen in bestanden", 
         "Name[pl]": "Znajdź/zastąp w plikach", 
         "Name[pt]": "Procurar/Substituir nos Ficheiros", 
         "Name[pt_BR]": "Procurar/substituir nos arquivos", 
         "Name[ru]": "Поиск/замена в файлах", 
         "Name[sk]": "Hľadať/nahradiť v súboroch", 
         "Name[sl]": "Najdi/zamenjaj v datotekah", 
         "Name[sv]": "Sök eller ersätt i filer", 
         "Name[tr]": "Bu Dosyalarda Bul ve Değiştir", 
         "Name[ug]": "ھۆججەت ئىچىدىن ئىزدەش/ئالماشتۇرۇش", 
         "Name[uk]": "Пошук або заміна у файлах", 
         "Name[x-test]": "xxFind/Replace In Filesxx", 
         "Name[zh_CN]": "在文件中查找/替换", 
         "Name[zh_TW]": "在檔案中尋找/取代", 
         "ServiceTypes": [
             "KDevelop/Plugin"
         ]
     }, 
     "X-KDevelop-Category": "Global", 
     "X-KDevelop-Mode": "GUI"
 }
diff --git a/shell/ktexteditorpluginintegration.cpp b/shell/ktexteditorpluginintegration.cpp
index 5d87ce8268..c17a332db7 100644
--- a/shell/ktexteditorpluginintegration.cpp
+++ b/shell/ktexteditorpluginintegration.cpp
@@ -1,341 +1,354 @@
 /*
     Copyright 2015 Milian Wolff <mail@milianw.de>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) version 3, or any
     later version accepted by the membership of KDE e.V. (or its
     successor approved by the membership of KDE e.V.), which shall
     act as a proxy defined in Section 6 of version 3 of the license.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "ktexteditorpluginintegration.h"
 
 #include <QWidget>
 #include <QVBoxLayout>
 
 #include <KParts/MainWindow>
 #include <KTextEditor/View>
 #include <KTextEditor/Editor>
 #include <KTextEditor/Application>
 
 #include <sublime/area.h>
 #include <sublime/view.h>
 
 #include "core.h"
 #include "partcontroller.h"
 #include "uicontroller.h"
 #include "documentcontroller.h"
 #include "plugincontroller.h"
 #include "mainwindow.h"
 #include "textdocument.h"
 
 #include <util/objectlist.h>
 
 using namespace KDevelop;
 
 namespace {
 
 KTextEditor::MainWindow *toKteWrapper(KParts::MainWindow *window)
 {
     if (auto mainWindow = dynamic_cast<KDevelop::MainWindow*>(window)) {
         return mainWindow->kateWrapper() ? mainWindow->kateWrapper()->interface() : nullptr;
     } else {
         return nullptr;
     }
 }
 
 KTextEditor::View *toKteView(Sublime::View *view)
 {
     if (auto textView = dynamic_cast<KDevelop::TextView*>(view)) {
         return textView->textView();
     } else {
         return nullptr;
     }
 }
 
 class ToolViewFactory;
 
 /**
  * This HACK is required to massage the KTextEditor plugin API into the
  * GUI concepts we apply in KDevelop. Kate does not allow the user to
  * delete toolviews and then readd them. We do. To support our use case
  * we prevent the widget we return to KTextEditor plugins from
  * MainWindow::createToolView from getting destroyed. This widget class
  * unsets the parent of the so called container in its dtor. The
  * ToolViewFactory handles the ownership and destroys the kate widget
  * as needed.
  */
 class KeepAliveWidget : public QWidget
 {
     Q_OBJECT
 public:
     explicit KeepAliveWidget(ToolViewFactory *factory, QWidget *parent = nullptr)
         : QWidget(parent)
         , m_factory(factory)
     {
     }
 
     ~KeepAliveWidget() override;
 
 private:
     ToolViewFactory *m_factory;
 };
 
 class ToolViewFactory : public QObject, public KDevelop::IToolViewFactory
 {
     Q_OBJECT
 public:
     ToolViewFactory(const QString &text, const QIcon &icon, const QString &identifier,
                     KTextEditor::MainWindow::ToolViewPosition pos)
         : m_text(text)
         , m_icon(icon)
         , m_identifier(identifier)
         , m_container(new QWidget)
         , m_pos(pos)
     {
         m_container->setLayout(new QVBoxLayout);
     }
 
     ~ToolViewFactory() override
     {
         delete m_container;
     }
 
     QWidget *create(QWidget *parent = nullptr) override
     {
         auto widget = new KeepAliveWidget(this, parent);
         widget->setWindowTitle(m_text);
         widget->setWindowIcon(m_icon);
         widget->setLayout(new QVBoxLayout);
         widget->layout()->addWidget(m_container);
         widget->addActions(m_container->actions());
         return widget;
     }
 
     Qt::DockWidgetArea defaultPosition() override
     {
         switch (m_pos) {
             case KTextEditor::MainWindow::Left:
                 return Qt::LeftDockWidgetArea;
             case KTextEditor::MainWindow::Right:
                 return Qt::RightDockWidgetArea;
             case KTextEditor::MainWindow::Top:
                 return Qt::TopDockWidgetArea;
             case KTextEditor::MainWindow::Bottom:
                 return Qt::BottomDockWidgetArea;
         }
         Q_UNREACHABLE();
     }
 
     QString id() const override
     {
         return m_identifier;
     }
 
     QWidget *container() const
     {
         return m_container;
     }
 
 private:
     QString m_text;
     QIcon m_icon;
     QString m_identifier;
     QPointer<QWidget> m_container;
     KTextEditor::MainWindow::ToolViewPosition m_pos;
     friend class KeepAliveWidget;
 };
 
 KeepAliveWidget::~KeepAliveWidget()
 {
     // if the container is still valid, unparent it to prevent it from getting deleted
     // this happens when the user removes a toolview
     // on shutdown, the container does get deleted, thus we must guard against that.
     if (m_factory->container()) {
         Q_ASSERT(m_factory->container()->parentWidget() == this);
         m_factory->container()->setParent(nullptr);
     }
 }
 
 }
 
 namespace KTextEditorIntegration {
 
 Application::Application(QObject *parent)
     : QObject(parent)
 {
 }
 
 Application::~Application()
 {
     KTextEditor::Editor::instance()->setApplication(nullptr);
 }
 
 KTextEditor::MainWindow *Application::activeMainWindow() const
 {
     return toKteWrapper(Core::self()->uiController()->activeMainWindow());
 }
 
 QList<KTextEditor::MainWindow *> Application::mainWindows() const
 {
     return {activeMainWindow()};
 }
 
 bool Application::closeDocument(KTextEditor::Document *document) const
 {
     auto documentController = Core::self()->documentControllerInternal();
     return documentController->closeDocument(document->url());
 }
 
 KTextEditor::Plugin *Application::plugin(const QString &id) const
 {
     auto kdevPlugin = Core::self()->pluginController()->loadPlugin(id);
     const auto plugin = dynamic_cast<Plugin*>(kdevPlugin);
     return plugin ? plugin->interface() : nullptr;
 }
 
 MainWindow::MainWindow(KDevelop::MainWindow *mainWindow)
     : QObject(mainWindow)
     , m_mainWindow(mainWindow)
     , m_interface(new KTextEditor::MainWindow(this))
 {
     connect(mainWindow, &Sublime::MainWindow::viewAdded, this, [this] (Sublime::View *view) {
         if (auto kteView = toKteView(view)) {
             emit m_interface->viewCreated(kteView);
         }
     });
     connect(mainWindow, &Sublime::MainWindow::activeViewChanged, this, [this] (Sublime::View *view) {
         emit m_interface->viewChanged(toKteView(view));
     });
 }
 
 MainWindow::~MainWindow() = default;
 
 QWidget *MainWindow::createToolView(KTextEditor::Plugin* plugin, const QString &identifier,
                                     KTextEditor::MainWindow::ToolViewPosition pos,
                                     const QIcon &icon, const QString &text)
 {
     auto factory = new ToolViewFactory(text, icon, identifier, pos);
     Core::self()->uiController()->addToolView(text, factory);
     connect(plugin, &QObject::destroyed, this, [=] {
         Core::self()->uiController()->removeToolView(factory);
     });
     return factory->container();
 }
 
 KXMLGUIFactory *MainWindow::guiFactory() const
 {
     return m_mainWindow->guiFactory();
 }
 
 QWidget *MainWindow::window() const
 {
     return m_mainWindow;
 }
 
 QList<KTextEditor::View *> MainWindow::views() const
 {
     QList<KTextEditor::View *> views;
     foreach (auto area, m_mainWindow->areas()) {
         foreach (auto view, area->views()) {
             if (auto kteView = toKteView(view)) {
                 views << kteView;
             }
         }
     }
     return views;
 }
 
 KTextEditor::View *MainWindow::activeView() const
 {
     return toKteView(m_mainWindow->activeView());
 }
 
 QObject *MainWindow::pluginView(const QString &id) const
 {
     return m_pluginViews.value(id);
 }
 
+QWidget *MainWindow::createViewBar(KTextEditor::View* view)
+{
+    Q_UNUSED(view);
+    // TODO
+    return nullptr;
+}
+
+void MainWindow::deleteViewBar(KTextEditor::View* view)
+{
+    Q_UNUSED(view);
+    // TODO
+}
+
 KTextEditor::MainWindow *MainWindow::interface() const
 {
     return m_interface;
 }
 
 void MainWindow::addPluginView(const QString &id, QObject *view)
 {
     m_pluginViews.insert(id, view);
     emit m_interface->pluginViewCreated(id, view);
 }
 
 void MainWindow::removePluginView(const QString &id)
 {
     auto view = m_pluginViews.take(id).data();
     delete view;
     emit m_interface->pluginViewDeleted(id, view);
 }
 
 Plugin::Plugin(KTextEditor::Plugin *plugin, QObject *parent)
     : IPlugin({}, parent)
     , m_plugin(plugin)
     , m_tracker(new ObjectListTracker(ObjectListTracker::CleanupWhenDone, this))
 {
 }
 
 Plugin::~Plugin() = default;
 
 void Plugin::unload()
 {
     if (auto mainWindow = KTextEditor::Editor::instance()->application()->activeMainWindow()) {
         auto integration = dynamic_cast<MainWindow*>(mainWindow->parent());
         if (integration) {
             integration->removePluginView(pluginId());
         }
     }
     m_tracker->deleteAll();
     delete m_plugin;
 }
 
 KXMLGUIClient *Plugin::createGUIForMainWindow(Sublime::MainWindow* window)
 {
     auto ret = IPlugin::createGUIForMainWindow(window);
     auto mainWindow = dynamic_cast<KDevelop::MainWindow*>(window);
     Q_ASSERT(mainWindow);
 
     auto wrapper = mainWindow->kateWrapper();
     auto view = m_plugin->createView(wrapper->interface());
     wrapper->addPluginView(pluginId(), view);
     // ensure that unloading the plugin kills all views
     m_tracker->append(view);
 
     return ret;
 }
 
 KTextEditor::Plugin *Plugin::interface() const
 {
     return m_plugin.data();
 }
 
 QString Plugin::pluginId() const
 {
     return Core::self()->pluginController()->pluginInfo(this).pluginId();
 }
 
 void initialize()
 {
     auto app = new KTextEditor::Application(new Application(Core::self()));
     KTextEditor::Editor::instance()->setApplication(app);
 }
 
 }
 
 #include "ktexteditorpluginintegration.moc"
diff --git a/shell/ktexteditorpluginintegration.h b/shell/ktexteditorpluginintegration.h
index 5b75235599..d11cf0ff47 100644
--- a/shell/ktexteditorpluginintegration.h
+++ b/shell/ktexteditorpluginintegration.h
@@ -1,117 +1,121 @@
 /*
     Copyright 2015 Milian Wolff <mail@milianw.de>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) version 3, or any
     later version accepted by the membership of KDE e.V. (or its
     successor approved by the membership of KDE e.V.), which shall
     act as a proxy defined in Section 6 of version 3 of the license.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef KDEVPLATFORM_KTEXTEDITOR_PLUGIN_INTEGRATION_H
 #define KDEVPLATFORM_KTEXTEDITOR_PLUGIN_INTEGRATION_H
 
 #include <QObject>
 #include <QVector>
 #include <QPointer>
 
 #include <KTextEditor/MainWindow>
 #include <KTextEditor/Plugin>
 
 #include <interfaces/iplugin.h>
 
 namespace KDevelop {
 class ObjectListTracker;
 class MainWindow;
 }
 
 namespace KTextEditorIntegration {
 
 /**
  * Class mimicking the KTextEditor::Application interface
  */
 class Application : public QObject
 {
     Q_OBJECT
 public:
     explicit Application(QObject *parent = nullptr);
     ~Application() override;
 
 public slots:
     KTextEditor::MainWindow *activeMainWindow() const;
     QList<KTextEditor::MainWindow *> mainWindows() const;
 
     KTextEditor::Plugin *plugin(const QString &id) const;
 
     bool closeDocument(KTextEditor::Document *document) const;
 };
 
 class MainWindow : public QObject
 {
     Q_OBJECT
 public:
     explicit MainWindow(KDevelop::MainWindow *mainWindow);
     ~MainWindow() override;
 
 public slots:
     QWidget *createToolView(KTextEditor::Plugin *plugin, const QString &identifier,
                             KTextEditor::MainWindow::ToolViewPosition pos,
                             const QIcon &icon, const QString &text);
 
     KXMLGUIFactory *guiFactory() const;
 
     QWidget *window() const;
 
     QList<KTextEditor::View *> views() const;
 
     KTextEditor::View *activeView() const;
 
     QObject *pluginView(const QString &id) const;
 
+    QWidget *createViewBar(KTextEditor::View *view);
+
+    void deleteViewBar(KTextEditor::View *view);
+
 public:
     KTextEditor::MainWindow *interface() const;
 
     void addPluginView(const QString &id, QObject *pluginView);
     void removePluginView(const QString &id);
 
 private:
     KDevelop::MainWindow *m_mainWindow;
     KTextEditor::MainWindow *m_interface;
     QHash<QString, QPointer<QObject>> m_pluginViews;
 };
 
 class Plugin : public KDevelop::IPlugin
 {
     Q_OBJECT
 public:
     explicit Plugin(KTextEditor::Plugin *plugin, QObject *parent = nullptr);
     ~Plugin() override;
 
     KXMLGUIClient* createGUIForMainWindow(Sublime::MainWindow *window) override;
 
     void unload() override;
 
     KTextEditor::Plugin *interface() const;
 
     QString pluginId() const;
 
 private:
     QPointer<KTextEditor::Plugin> m_plugin;
     // view objects and toolviews that should get deleted when the plugin gets unloaded
     KDevelop::ObjectListTracker *m_tracker;
 };
 
 void initialize();
 
 }
 #endif
diff --git a/shell/textdocument.cpp b/shell/textdocument.cpp
index 4c6f6e4a16..e46303ca81 100644
--- a/shell/textdocument.cpp
+++ b/shell/textdocument.cpp
@@ -1,793 +1,795 @@
 /***************************************************************************
  *   Copyright 2007 Alexander Dymo  <adymo@kdevelop.org>                   *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU Library General Public License as       *
  *   published by the Free Software Foundation; either version 2 of the    *
  *   License, or (at your option) any later version.                       *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU Library General Public     *
  *   License along with this program; if not, write to the                 *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 #include "textdocument.h"
 
 #include <QAction>
 #include <QCoreApplication>
 #include <QDebug>
 #include <QFile>
 #include <QMenu>
 #include <QMimeDatabase>
 #include <QPointer>
 #include <QWidget>
 
 #include <KActionCollection>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KTextEditor/View>
 #include <KTextEditor/Document>
 #include <KTextEditor/ModificationInterface>
 #include <KTextEditor/CodeCompletionInterface>
 #include <KTextEditor/MarkInterface>
 #include <KTextEditor/ConfigInterface>
 #include <KTextEditor/SessionConfigInterface>
 
 #include <interfaces/context.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/icompletionsettings.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 
 #include <vcs/interfaces/icontentawareversioncontrol.h>
 
 #include <language/interfaces/editorcontext.h>
 #include <language/backgroundparser/backgroundparser.h>
 
 #include <project/projectutils.h>
 #include <project/projectmodel.h>
 
 #include "core.h"
 #include "mainwindow.h"
 #include "uicontroller.h"
 #include "partcontroller.h"
 #include "plugincontroller.h"
 #include "documentcontroller.h"
+#include "ktexteditorpluginintegration.h"
 #include "debug.h"
+
 #include <path.h>
 #include <shellutils.h>
 
 namespace KDevelop {
 
 const int MAX_DOC_SETTINGS = 20;
 
 // This sets cursor position and selection on the view to the given
 // range. Selection is set only for non-empty ranges
 // Factored into a function since its needed in 3 places already
 static void selectAndReveal( KTextEditor::View* view, const KTextEditor::Range& range ) {
     Q_ASSERT(view);
     if (range.isValid()) {
         view->setCursorPosition(range.start());
         if (!range.isEmpty()) {
             view->setSelection(range);
         }
     }
 }
 
 struct TextDocumentPrivate {
     TextDocumentPrivate(TextDocument *textDocument)
         : document(nullptr), state(IDocument::Clean), encoding(), q(textDocument)
         , m_loaded(false), m_addedContextMenu(nullptr)
     {
     }
 
     ~TextDocumentPrivate()
     {
         delete m_addedContextMenu;
         m_addedContextMenu = nullptr;
 
         saveSessionConfig();
         delete document;
     }
 
     QPointer<KTextEditor::Document> document;
     IDocument::DocumentState state;
     QString encoding;
 
     void setStatus(KTextEditor::Document* document, bool dirty)
     {
         QIcon statusIcon;
 
         if (document->isModified())
             if (dirty) {
                 state = IDocument::DirtyAndModified;
                 statusIcon = QIcon::fromTheme(QStringLiteral("edit-delete"));
             } else {
                 state = IDocument::Modified;
                 statusIcon = QIcon::fromTheme(QStringLiteral("document-save"));
             }
         else
             if (dirty) {
                 state = IDocument::Dirty;
                 statusIcon = QIcon::fromTheme(QStringLiteral("document-revert"));
             } else {
                 state = IDocument::Clean;
             }
 
         q->notifyStateChanged();
         Core::self()->uiControllerInternal()->setStatusIcon(q, statusIcon);
     }
 
     inline KConfigGroup katePartSettingsGroup() const
     {
         return KSharedConfig::openConfig()->group("KatePart Settings");
     }
 
     inline QString docConfigGroupName() const
     {
         return document->url().toDisplayString(QUrl::PreferLocalFile);
     }
 
     inline KConfigGroup docConfigGroup() const
     {
         return katePartSettingsGroup().group(docConfigGroupName());
     }
 
     void saveSessionConfig()
     {
         if(document && document->url().isValid()) {
             // make sure only MAX_DOC_SETTINGS entries are stored
             KConfigGroup katePartSettings = katePartSettingsGroup();
             // ordered list of documents
             QStringList documents = katePartSettings.readEntry("documents", QStringList());
             // ensure this document is "new", i.e. at the end of the list
             documents.removeOne(docConfigGroupName());
             documents.append(docConfigGroupName());
             // remove "old" documents + their group
             while(documents.size() >= MAX_DOC_SETTINGS) {
                 katePartSettings.group(documents.takeFirst()).deleteGroup();
             }
             // update order
             katePartSettings.writeEntry("documents", documents);
 
             // actually save session config
             KConfigGroup group = docConfigGroup();
             document->writeSessionConfig(group);
         }
     }
 
     void loadSessionConfig()
     {
         if (!document || !katePartSettingsGroup().hasGroup(docConfigGroupName())) {
             return;
         }
 
         document->readSessionConfig(docConfigGroup(), {QStringLiteral("SkipUrl")});
     }
 
     // Determines whether the current contents of this document in the editor
     // could be retrieved from the VCS if they were dismissed.
     void queryCanRecreateFromVcs(KTextEditor::Document* document) const {
         IProject* project = nullptr;
         // Find projects by checking which one contains the file's parent directory,
         // to avoid issues with the cmake manager temporarily removing files from a project
         // during reloading.
         KDevelop::Path path(document->url());
         foreach ( KDevelop::IProject* current, Core::self()->projectController()->projects() ) {
             if ( current->path().isParentOf(path) ) {
                 project = current;
                 break;
             }
         }
         if (!project) {
             return;
         }
         IContentAwareVersionControl* iface;
         iface = qobject_cast< KDevelop::IContentAwareVersionControl* >(project->versionControlPlugin());
         if (!iface) {
             return;
         }
         if ( !qobject_cast<KTextEditor::ModificationInterface*>( document ) ) {
             return;
         }
 
         CheckInRepositoryJob* req = iface->isInRepository( document );
         if ( !req ) {
             return;
         }
         QObject::connect(req, &CheckInRepositoryJob::finished,
                             q, &TextDocument::repositoryCheckFinished);
         // Abort the request when the user edits the document
         QObject::connect(q->textDocument(), &KTextEditor::Document::textChanged,
                             req, &CheckInRepositoryJob::abort);
     }
 
     void modifiedOnDisk(KTextEditor::Document *document, bool /*isModified*/,
         KTextEditor::ModificationInterface::ModifiedOnDiskReason reason)
     {
         bool dirty = false;
         switch (reason)
         {
             case KTextEditor::ModificationInterface::OnDiskUnmodified:
                 break;
             case KTextEditor::ModificationInterface::OnDiskModified:
             case KTextEditor::ModificationInterface::OnDiskCreated:
             case KTextEditor::ModificationInterface::OnDiskDeleted:
                 dirty = true;
                 break;
         }
 
         // In some cases, the VCS (e.g. git) can know whether the old contents are "valuable", i.e.
         // not retrieveable from the VCS. If that is not the case, then the document can safely be
         // reloaded without displaying a dialog asking the user.
         if ( dirty ) {
             queryCanRecreateFromVcs(document);
         }
         setStatus(document, dirty);
     }
 
     TextDocument * const q;
     bool m_loaded;
     // we want to remove the added stuff when the menu hides
     QMenu* m_addedContextMenu;
 };
 
 struct TextViewPrivate
 {
     TextViewPrivate(TextView* q) : q(q) {}
 
     TextView* const q;
     QPointer<KTextEditor::View> view;
     KTextEditor::Range initialRange;
 };
 
 TextDocument::TextDocument(const QUrl &url, ICore* core, const QString& encoding)
     :PartDocument(url, core), d(new TextDocumentPrivate(this))
 {
     d->encoding = encoding;
 }
 
 TextDocument::~TextDocument()
 {
     delete d;
 }
 
 bool TextDocument::isTextDocument() const
 {
     if( !d->document )
     {
         /// @todo Somehow it can happen that d->document is zero, which makes
         /// code relying on "isTextDocument() == (bool)textDocument()" crash
         qWarning() << "Broken text-document: " << url();
         return false;
     }
 
     return true;
 }
 
 KTextEditor::Document *TextDocument::textDocument() const
 {
     return d->document;
 }
 
 QWidget *TextDocument::createViewWidget(QWidget *parent)
 {
     KTextEditor::View* view = nullptr;
 
     if (!d->document)
     {
         d->document = Core::self()->partControllerInternal()->createTextPart();
 
         // Connect to the first text changed signal, it occurs before the completed() signal
         connect(d->document.data(), &KTextEditor::Document::textChanged, this, &TextDocument::slotDocumentLoaded);
         // Also connect to the completed signal, sometimes the first text changed signal is missed because the part loads too quickly (? TODO - confirm this is necessary)
         connect(d->document.data(), static_cast<void(KTextEditor::Document::*)()>(&KTextEditor::Document::completed), this, &TextDocument::slotDocumentLoaded);
 
         // force a reparse when a document gets reloaded
         connect(d->document.data(), &KTextEditor::Document::reloaded,
                 this, [] (KTextEditor::Document* document) {
             ICore::self()->languageController()->backgroundParser()->addDocument(IndexedString(document->url()),
                     (TopDUContext::Features) ( TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdate ),
                     BackgroundParser::BestPriority, nullptr);
         });
 
         // Set encoding passed via constructor
         // Needs to be done before openUrl, else katepart won't use the encoding
         // @see KTextEditor::Document::setEncoding
         if (!d->encoding.isEmpty())
             d->document->setEncoding(d->encoding);
 
         if (!url().isEmpty() && !DocumentController::isEmptyDocumentUrl(url()))
             d->document->openUrl( url() );
 
         d->setStatus(d->document, false);
 
         /* It appears, that by default a part will be deleted the
            first view containing it is deleted.  Since we do want
            to have several views, disable that behaviour.  */
         d->document->setAutoDeletePart(false);
 
         Core::self()->partController()->addPart(d->document, false);
 
         d->loadSessionConfig();
 
         connect(d->document.data(), &KTextEditor::Document::modifiedChanged,
                  this, &TextDocument::newDocumentStatus);
         connect(d->document.data(), &KTextEditor::Document::textChanged,
                  this, &TextDocument::textChanged);
         connect(d->document.data(), &KTextEditor::Document::documentUrlChanged,
                  this, &TextDocument::documentUrlChanged);
         connect(d->document.data(), &KTextEditor::Document::documentSavedOrUploaded,
                  this, &TextDocument::documentSaved );
 
         if (qobject_cast<KTextEditor::MarkInterface*>(d->document)) {
             // can't use new signal/slot syntax here, MarkInterface is not a QObject
             connect(d->document.data(), SIGNAL(marksChanged(KTextEditor::Document*)),
                     this, SLOT(saveSessionConfig()));
         }
 
         if (auto iface = qobject_cast<KTextEditor::ModificationInterface*>(d->document)) {
             iface->setModifiedOnDiskWarning(true);
             // can't use new signal/slot syntax here, ModificationInterface is not a QObject
             connect(d->document.data(), SIGNAL(modifiedOnDisk(KTextEditor::Document*,bool,KTextEditor::ModificationInterface::ModifiedOnDiskReason)),
                 this, SLOT(modifiedOnDisk(KTextEditor::Document*,bool,KTextEditor::ModificationInterface::ModifiedOnDiskReason)));
         }
 
         notifyTextDocumentCreated();
     }
 
-    view = d->document->createView(parent);
+    view = d->document->createView(parent, Core::self()->uiControllerInternal()->defaultMainWindow()->kateWrapper()->interface());
 
     // get rid of some actions regarding the config dialog, we merge that one into the kdevelop menu already
     delete view->actionCollection()->action(QStringLiteral("set_confdlg"));
     delete view->actionCollection()->action(QStringLiteral("editor_options"));
 
     view->setStatusBarEnabled(Core::self()->partControllerInternal()->showTextEditorStatusBar());
 
     connect(view, &KTextEditor::View::contextMenuAboutToShow, this, &TextDocument::populateContextMenu);
 
     if (KTextEditor::CodeCompletionInterface* cc = dynamic_cast<KTextEditor::CodeCompletionInterface*>(view))
         cc->setAutomaticInvocationEnabled(core()->languageController()->completionSettings()->automaticCompletionEnabled());
 
     if (KTextEditor::ConfigInterface *config = qobject_cast<KTextEditor::ConfigInterface*>(view)) {
         config->setConfigValue(QStringLiteral("allow-mark-menu"), false);
         config->setConfigValue(QStringLiteral("default-mark-type"), KTextEditor::MarkInterface::BreakpointActive);
     }
 
     return view;
 }
 
 KParts::Part *TextDocument::partForView(QWidget *view) const
 {
     if (d->document && d->document->views().contains((KTextEditor::View*)view))
         return d->document;
     return nullptr;
 }
 
 
 
 // KDevelop::IDocument implementation
 
 void TextDocument::reload()
 {
     if (!d->document)
         return;
 
     KTextEditor::ModificationInterface* modif=nullptr;
     if(d->state==Dirty) {
         modif = qobject_cast<KTextEditor::ModificationInterface*>(d->document);
         modif->setModifiedOnDiskWarning(false);
     }
     d->document->documentReload();
     if(modif)
         modif->setModifiedOnDiskWarning(true);
 }
 
 bool TextDocument::save(DocumentSaveMode mode)
 {
     if (!d->document)
         return true;
 
     if (mode & Discard)
         return true;
 
     switch (d->state)
     {
         case IDocument::Clean:
             return true;
 
         case IDocument::Modified:
             break;
 
         case IDocument::Dirty:
         case IDocument::DirtyAndModified:
             if (!(mode & Silent))
             {
                 int code = KMessageBox::warningYesNoCancel(
                     Core::self()->uiController()->activeMainWindow(),
                     i18n("The file \"%1\" is modified on disk.\n\nAre "
                         "you sure you want to overwrite it? (External "
                         "changes will be lost.)", d->document->url().toLocalFile()),
                     i18nc("@title:window", "Document Externally Modified"));
                 if (code != KMessageBox::Yes)
                     return false;
             }
             break;
     }
 
     if (!KDevelop::ensureWritable(QList<QUrl>() << url())) {
         return false;
     }
 
     QUrl urlBeforeSave = d->document->url();
     if (d->document->documentSave())
     {
         if (d->document->url() != urlBeforeSave)
             notifyUrlChanged();
         return true;
     }
     return false;
 }
 
 IDocument::DocumentState TextDocument::state() const
 {
     return d->state;
 }
 
 KTextEditor::Cursor KDevelop::TextDocument::cursorPosition() const
 {
     if (!d->document) {
         return KTextEditor::Cursor::invalid();
     }
 
     KTextEditor::View *view = activeTextView();
 
     if (view)
         return view->cursorPosition();
 
     return KTextEditor::Cursor::invalid();
 }
 
 void TextDocument::setCursorPosition(const KTextEditor::Cursor &cursor)
 {
     if (!cursor.isValid() || !d->document)
         return;
 
     KTextEditor::View *view = activeTextView();
 
     // Rodda: Cursor must be accurate here, to the definition of accurate for KTextEditor::Cursor.
     // ie, starting from 0,0
 
     if (view)
         view->setCursorPosition(cursor);
 }
 
 KTextEditor::Range TextDocument::textSelection() const
 {
     if (!d->document) {
         return KTextEditor::Range::invalid();
     }
 
     KTextEditor::View *view = activeTextView();
 
     if (view && view->selection()) {
         return view->selectionRange();
     }
 
     return PartDocument::textSelection();
 }
 
 QString TextDocument::text(const KTextEditor::Range &range) const
 {
     if (!d->document) {
         return QString();
     }
 
     return d->document->text( range );
 }
 
 QString TextDocument::textLine() const
 {
     if (!d->document) {
         return QString();
     }
 
     KTextEditor::View *view = activeTextView();
 
     if (view) {
         return d->document->line( view->cursorPosition().line() );
     }
 
     return PartDocument::textLine();
 }
 
 QString TextDocument::textWord() const
 {
     if (!d->document) {
         return QString();
     }
 
     KTextEditor::View *view = activeTextView();
 
     if (view) {
         KTextEditor::Cursor start = view->cursorPosition();
         qCDebug(SHELL) << "got start position from view:" << start.line() << start.column();
         QString linestr = textLine();
         int startPos = qMax( qMin( start.column(), linestr.length() - 1 ), 0 );
         int endPos = startPos;
         startPos --;
         while( startPos >= 0 && ( linestr[startPos].isLetterOrNumber() || linestr[startPos] == '_' || linestr[startPos] == '~' ) )
         {
             --startPos;
         }
 
         while( endPos < linestr.length() && ( linestr[endPos].isLetterOrNumber() || linestr[endPos] == '_' || linestr[endPos] == '~' ) )
         {
             ++endPos;
         }
         if( startPos != endPos )
         {
             qCDebug(SHELL) << "found word" << startPos << endPos << linestr.mid( startPos+1, endPos - startPos - 1 );
             return linestr.mid( startPos + 1, endPos - startPos - 1 );
         }
     }
 
     return PartDocument::textWord();
 }
 
 void TextDocument::setTextSelection(const KTextEditor::Range &range)
 {
     if (!range.isValid() || !d->document)
         return;
 
     KTextEditor::View *view = activeTextView();
 
     if (view) {
         selectAndReveal(view, range);
     }
 }
 
 bool TextDocument::close(DocumentSaveMode mode)
 {
     if (!PartDocument::close(mode))
         return false;
 
     if ( d->document ) {
         d->saveSessionConfig();
         delete d->document; //We have to delete the document right now, to prevent random crashes in the event handler
     }
 
     return true;
 }
 
 Sublime::View* TextDocument::newView(Sublime::Document* doc)
 {
     Q_UNUSED(doc);
     return new TextView(this);
 }
 
 }
 
 KDevelop::TextView::TextView(TextDocument * doc)
     : View(doc, View::TakeOwnership), d(new TextViewPrivate(this))
 {
 }
 
 KDevelop::TextView::~TextView()
 {
     delete d;
 }
 
 QWidget * KDevelop::TextView::createWidget(QWidget * parent)
 {
     auto textDocument = qobject_cast<TextDocument*>(document());
     Q_ASSERT(textDocument);
     QWidget* widget = textDocument->createViewWidget(parent);
     d->view = qobject_cast<KTextEditor::View*>(widget);
     Q_ASSERT(d->view);
     connect(d->view.data(), &KTextEditor::View::cursorPositionChanged, this, &KDevelop::TextView::sendStatusChanged);
     return widget;
 }
 
 QString KDevelop::TextView::viewState() const
 {
     if (d->view) {
         if (d->view->selection()) {
             KTextEditor::Range selection = d->view->selectionRange();
             return QStringLiteral("Selection=%1,%2,%3,%4").arg(selection.start().line())
                                                    .arg(selection.start().column())
                                                    .arg(selection.end().line())
                                                    .arg(selection.end().column());
         } else {
             KTextEditor::Cursor cursor = d->view->cursorPosition();
             return QStringLiteral("Cursor=%1,%2").arg(cursor.line()).arg(cursor.column());
         }
     }
     else {
         KTextEditor::Range selection = d->initialRange;
         return QStringLiteral("Selection=%1,%2,%3,%4").arg(selection.start().line())
                                                    .arg(selection.start().column())
                                                    .arg(selection.end().line())
                                                    .arg(selection.end().column());
     }
 }
 
 void KDevelop::TextView::setInitialRange(const KTextEditor::Range& range)
 {
     if (d->view) {
         selectAndReveal(d->view, range);
     } else {
         d->initialRange = range;
     }
 }
 
 KTextEditor::Range KDevelop::TextView::initialRange() const
 {
     return d->initialRange;
 }
 
 void KDevelop::TextView::setState(const QString & state)
 {
     static QRegExp reCursor("Cursor=([\\d]+),([\\d]+)");
     static QRegExp reSelection("Selection=([\\d]+),([\\d]+),([\\d]+),([\\d]+)");
     if (reCursor.exactMatch(state)) {
         setInitialRange(KTextEditor::Range(KTextEditor::Cursor(reCursor.cap(1).toInt(), reCursor.cap(2).toInt()), 0));
     } else if (reSelection.exactMatch(state)) {
         KTextEditor::Range range(reSelection.cap(1).toInt(), reSelection.cap(2).toInt(), reSelection.cap(3).toInt(), reSelection.cap(4).toInt());
         setInitialRange(range);
     }
 }
 
 QString KDevelop::TextDocument::documentType() const
 {
     return QStringLiteral("Text");
 }
 
 QIcon KDevelop::TextDocument::defaultIcon() const
 {
     if (d->document) {
         QMimeType mime = QMimeDatabase().mimeTypeForName(d->document->mimeType());
         QIcon icon = QIcon::fromTheme(mime.iconName());
         if (!icon.isNull()) {
             return icon;
         }
     }
     return PartDocument::defaultIcon();
 }
 
 KTextEditor::View *KDevelop::TextView::textView() const
 {
     return d->view;
 }
 
 QString KDevelop::TextView::viewStatus() const
 {
     // only show status when KTextEditor's own status bar isn't already enabled
     const bool showStatus = !Core::self()->partControllerInternal()->showTextEditorStatusBar();
     if (!showStatus) {
         return QString();
     }
 
     const KTextEditor::Cursor pos = d->view ? d->view->cursorPosition() : KTextEditor::Cursor::invalid();
     return i18n(" Line: %1 Col: %2 ", pos.line() + 1, pos.column() + 1);
 }
 
 void KDevelop::TextView::sendStatusChanged()
 {
     emit statusChanged(this);
 }
 
 KTextEditor::View* KDevelop::TextDocument::activeTextView() const
 {
     KTextEditor::View* fallback = nullptr;
     for (auto view : views()) {
         auto textView = qobject_cast<TextView*>(view)->textView();
         if (!textView) {
             continue;
         }
         if (textView->hasFocus()) {
             return textView;
         } else if (textView->isVisible()) {
             fallback = textView;
         } else if (!fallback) {
             fallback = textView;
         }
     }
     return fallback;
 }
 
 void KDevelop::TextDocument::newDocumentStatus(KTextEditor::Document *document)
 {
     bool dirty = (d->state == IDocument::Dirty || d->state == IDocument::DirtyAndModified);
 
     d->setStatus(document, dirty);
 }
 
 void KDevelop::TextDocument::textChanged(KTextEditor::Document *document)
 {
     Q_UNUSED(document);
     notifyContentChanged();
 }
 
 void KDevelop::TextDocument::populateContextMenu( KTextEditor::View* v, QMenu* menu )
 {
     if (d->m_addedContextMenu) {
         foreach ( QAction* action, d->m_addedContextMenu->actions() ) {
             menu->removeAction(action);
         }
         delete d->m_addedContextMenu;
     }
 
     d->m_addedContextMenu = new QMenu();
 
     EditorContext c(v, v->cursorPosition());
     auto extensions = Core::self()->pluginController()->queryPluginsForContextMenuExtensions(&c);
 
     ContextMenuExtension::populateMenu(d->m_addedContextMenu, extensions);
 
     {
         QUrl url = v->document()->url();
         QList< ProjectBaseItem* > items = Core::self()->projectController()->projectModel()->itemsForPath( IndexedString(url) );
         if (!items.isEmpty()) {
             populateParentItemsMenu( items.front(), d->m_addedContextMenu );
         }
     }
 
     foreach ( QAction* action, d->m_addedContextMenu->actions() ) {
         menu->addAction(action);
     }
 }
 
 void KDevelop::TextDocument::repositoryCheckFinished(bool canRecreate) {
     if ( d->state != IDocument::Dirty && d->state != IDocument::DirtyAndModified ) {
         // document is not dirty for whatever reason, nothing to do.
         return;
     }
     if ( ! canRecreate ) {
         return;
     }
     KTextEditor::ModificationInterface* modIface = qobject_cast<KTextEditor::ModificationInterface*>( d->document );
     Q_ASSERT(modIface);
     // Ok, all safe, we can clean up the document. Close it if the file is gone,
     // and reload if it's still there.
     d->setStatus(d->document, false);
     modIface->setModifiedOnDisk(KTextEditor::ModificationInterface::OnDiskUnmodified);
     if ( QFile::exists(d->document->url().path()) ) {
         reload();
     } else {
         close(KDevelop::IDocument::Discard);
     }
 }
 
 void KDevelop::TextDocument::slotDocumentLoaded()
 {
     if (d->m_loaded)
         return;
     // Tell the editor integrator first
     d->m_loaded = true;
     notifyLoaded();
 }
 
 void KDevelop::TextDocument::documentSaved(KTextEditor::Document* document, bool saveAs)
 {
     Q_UNUSED(document);
     Q_UNUSED(saveAs);
     notifySaved();
     notifyStateChanged();
 }
 
 void KDevelop::TextDocument::documentUrlChanged(KTextEditor::Document* document)
 {
     Q_UNUSED(document);
     if (url() != d->document->url())
         setUrl(d->document->url());
 }
 
 #include "moc_textdocument.cpp"